From 4e89ba22414e0dcc0fb13cb9ca01abc92a3a8c45 Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 05:11:01 -0700 Subject: [PATCH 1/7] Add initial vulkan impl - seens faster than CUDA approach, on tested hw we get 2-14ms vs. 12-30? --- .../omnidreams_local_window.yaml | 4 +- .../omnidreams_local_window_vulkan.yaml | 12 + .../omnidreams/ludus-renderer/README.md | 34 +- .../ludus-renderer/ludus_renderer/__init__.py | 4 + .../_cpp/bindings/torch_rasterize_vk.cpp | 536 + .../ludus_renderer/_cpp/common/vkutil.cpp | 707 ++ .../ludus_renderer/_cpp/common/vkutil.h | 185 + .../ludus_renderer/_cpp/render/ludus_jpeg.cu | 58 + .../_cpp/render/ludus_timestamped_vk.cpp | 1596 +++ .../ludus_renderer/_cpp/render/ludus_vk.h | 332 + .../ludus_renderer/_cpp/render/shaders_spv.h | 9854 +++++++++++++++++ .../ludus_renderer/_ops/__init__.py | 3 + .../ludus_renderer/_ops/_plugin_vk.py | 217 + .../ludus_renderer/_ops/context_vk.py | 904 ++ .../ludus_renderer/shaders/compile.sh | 63 + .../ludus_renderer/shaders/embed_spv.py | 93 + .../shaders/ts_export.comp.glsl | 56 + .../shaders/ts_obstacle.frag.glsl | 67 + .../shaders/ts_obstacle.mesh.glsl | 1135 ++ .../shaders/ts_obstacle.task.glsl | 1185 ++ .../shaders/ts_polygon.frag.glsl | 62 + .../shaders/ts_polygon.mesh.glsl | 1127 ++ .../shaders/ts_polygon.task.glsl | 1014 ++ .../shaders/ts_polyline.frag.glsl | 62 + .../shaders/ts_polyline.mesh.glsl | 1451 +++ .../shaders/ts_polyline.task.glsl | 993 ++ .../omnidreams/ludus-renderer/pyproject.toml | 6 +- .../tests/test_vulkan_backend_contract.py | 149 + .../omnidreams/interactive_drive/README.md | 752 +- .../omnidreams/interactive_drive/cli.py | 10 + .../omnidreams/interactive_drive/config.py | 2 + .../interactive_drive/rasterizer.py | 13 +- integrations/omnidreams/omnidreams/launch.py | 2 + 33 files changed, 21987 insertions(+), 701 deletions(-) create mode 100644 configs/launch_manifest/omnidreams_local_window_vulkan.yaml create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_jpeg.cu create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/shaders_spv.h create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/_plugin_vk.py create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/context_vk.py create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/compile.sh create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/embed_spv.py create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_export.comp.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.frag.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.mesh.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.task.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.frag.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.mesh.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.task.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.frag.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.mesh.glsl create mode 100644 integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.task.glsl create mode 100644 integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py diff --git a/configs/launch_manifest/omnidreams_local_window.yaml b/configs/launch_manifest/omnidreams_local_window.yaml index 1d712ef96..1a01726f7 100644 --- a/configs/launch_manifest/omnidreams_local_window.yaml +++ b/configs/launch_manifest/omnidreams_local_window.yaml @@ -3,8 +3,10 @@ runner: omnidreams-perf mode: local-window scenario: - auto_start: false + auto_start: true + game_mode: true preload_scenes: false output: world_model_manifest_path: ../../integrations/omnidreams/omnidreams/interactive_drive/configs/example_world_model_perf.yaml + ludus_backend: vulkan \ No newline at end of file diff --git a/configs/launch_manifest/omnidreams_local_window_vulkan.yaml b/configs/launch_manifest/omnidreams_local_window_vulkan.yaml new file mode 100644 index 000000000..1a01726f7 --- /dev/null +++ b/configs/launch_manifest/omnidreams_local_window_vulkan.yaml @@ -0,0 +1,12 @@ +schema_version: 1 +runner: omnidreams-perf +mode: local-window + +scenario: + auto_start: true + game_mode: true + preload_scenes: false + +output: + world_model_manifest_path: ../../integrations/omnidreams/omnidreams/interactive_drive/configs/example_world_model_perf.yaml + ludus_backend: vulkan \ No newline at end of file diff --git a/integrations/omnidreams/ludus-renderer/README.md b/integrations/omnidreams/ludus-renderer/README.md index 4063d649c..1195bccea 100644 --- a/integrations/omnidreams/ludus-renderer/README.md +++ b/integrations/omnidreams/ludus-renderer/README.md @@ -1,13 +1,16 @@ # Ludus Renderer GPU-native F-theta renderer and PhysX-first object graph for autonomous -vehicle simulation. Rendering is CUDA-only and is built on the HPG 2011 -CudaRaster triangle pipeline. +vehicle simulation. The default CUDA backend uses the HPG 2011 CudaRaster +triangle pipeline; an optional Windows/Linux Vulkan backend uses task, mesh, +fragment, and compute shaders with zero-copy CUDA/Vulkan external-memory +handoff. ## Features - **F-theta Camera Model**: Native support for fisheye lens distortion using polynomial projection -- **One CUDA rendering path**: no graphics API interop or duplicate backend +- **CUDA and Vulkan rendering paths**: matching timestamped-scene APIs, with + Vulkan using device-local shared buffers and GPU timeline-semaphore ordering - **PhysX object graph**: generic rigid bodies and invisible map barriers; applications own semantic vehicle design and driving policy - **Mutable simulation buffers**: actor add/update/remove operations preserve one @@ -27,12 +30,21 @@ CudaRaster triangle pipeline. ## Requirements **Always:** + - NVIDIA GPU (Turing or later) - CUDA 11+ - Python 3.10+ - A C++17 compiler (Visual Studio 2022 on Windows) - ffmpeg (for MP4 muxing with `--output-format mp4`) +**Vulkan backend (optional, Windows and Linux):** + +- Vulkan 1.3 headers and loader (LunarG Vulkan SDK on Windows; + `libvulkan-dev` on Debian/Ubuntu) +- `VK_EXT_mesh_shader`, `VK_KHR_fragment_shader_barycentric`, + timeline semaphore, and platform-native external-memory/semaphore support on + the CUDA-paired Vulkan device (`*_win32` on Windows, `*_fd` on Linux) + ## Installation ```bash @@ -57,13 +69,27 @@ uv run --package ludus-renderer python -c "from ludus_renderer import prepare_ph ## Usage -The CUDA renderer is the only public rendering backend: +CUDA remains the default backend: ```python from ludus_renderer import LudusCudaTimestampedContext ctx = LudusCudaTimestampedContext(device="cuda") ``` +The Vulkan backend mirrors the timestamped context API. Fixed-function color +and depth attachments resolve visibility, then one compute dispatch packs RGBA8 +into a reusable exported linear SSBO. PyTorch wraps CUDA's mapping of that same +device allocation, so the handoff has no output copy or layered CUDA image +import. Timeline semaphores and external queue-family ownership barriers order +the work without a steady-state CPU wait. Attachments are cached per resolution; +the current path is single-sample. Platform-native OS handles are transient and +closed or transferred immediately after CUDA imports them. + +```python +from ludus_renderer import LudusVulkanTimestampedContext +ctx = LudusVulkanTimestampedContext(device="cuda") +``` + `PhysXWorld` consumes `PhysicsObjectGraph` and creates `PxScene`, rigid actors, materials, and shapes directly, without an intermediate scene-format runtime. The first PhysX use in each process asks CMake to configure and build the pinned diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/__init__.py b/integrations/omnidreams/ludus-renderer/ludus_renderer/__init__.py index 760d400eb..6ed9119ee 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/__init__.py +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/__init__.py @@ -60,6 +60,8 @@ FThetaCamera, # Contexts LudusCudaTimestampedContext, + LudusTimestampedContext, + LudusVulkanTimestampedContext, ObstaclePool, Polygon, # Primitives @@ -125,6 +127,8 @@ "mirror_augment_scene", # Rendering contexts "LudusCudaTimestampedContext", + "LudusTimestampedContext", + "LudusVulkanTimestampedContext", "MutableObjectSceneBuffer", # Primitives "Polyline", diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp new file mode 100644 index 000000000..feb6c9628 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp @@ -0,0 +1,536 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Vulkan-backend Python bindings. Compiled into its own torch extension +// (ludus_renderer_vk_plugin) so the CUDA-only extension stays buildable on +// systems without Vulkan headers. + +#include "torch_common.inl" +#include "../common/common.h" +#include "../render/ludus_vk.h" +#include +#include +#include +#include +#include + +//------------------------------------------------------------------------ +// FLU (front-left-up) to RDF (right-down-front) basis conversion. +// The shaders consume RDF column-major matrices; PyTorch poses are FLU. +//------------------------------------------------------------------------ + +static torch::Tensor flu_to_rdf(const torch::Tensor& camera_poses) +{ + static const float kFluToRdf[16] = { + 0, -1, 0, 0, + 0, 0, -1, 0, + 1, 0, 0, 0, + 0, 0, 0, 1, + }; + auto conv = torch::from_blob((void*)kFluToRdf, {4, 4}, torch::kFloat32) + .to(camera_poses.device()); + return torch::matmul(conv, camera_poses); +} + +//------------------------------------------------------------------------ +// Python-facing wrapper for the Vulkan timestamped renderer. +//------------------------------------------------------------------------ + +struct VulkanSharedState +{ + LudusTimestampedVkState* pState; + std::array, LUDUS_VK_OUTPUT_SLOTS> inUse; + std::array, LUDUS_VK_OUTPUT_SLOTS> releaseRecorded; + std::array releaseEvents; + int cudaDeviceIdx; + + explicit VulkanSharedState(int deviceIdx) + : pState(new LudusTimestampedVkState()) + , cudaDeviceIdx(deviceIdx) + { + const at::cuda::OptionalCUDAGuard device_guard( + c10::Device(c10::kCUDA, cudaDeviceIdx)); + memset(pState, 0, sizeof(LudusTimestampedVkState)); + for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) { + inUse[i].store(false, std::memory_order_relaxed); + releaseRecorded[i].store(false, std::memory_order_relaxed); + AT_CUDA_CHECK(cudaEventCreateWithFlags( + &releaseEvents[i], cudaEventDisableTiming)); + } + ludusTimestampedInitVk(NVDR_CTX_PARAMS, *pState, cudaDeviceIdx); + } + + ~VulkanSharedState() + { + cudaSetDevice(cudaDeviceIdx); + // Output tensors keep this owner alive. When the final tensor releases + // it records its consumer stream here; drain those events before + // destroying CUDA's mappings or the Vulkan allocations behind them. + for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) { + if (releaseRecorded[i].load(std::memory_order_acquire)) + cudaEventSynchronize(releaseEvents[i]); + } + ludusTimestampedReleaseVk(NVDR_CTX_PARAMS, *pState); + delete pState; + for (cudaEvent_t event : releaseEvents) + cudaEventDestroy(event); + } +}; + +class LudusTimestampedVkStateWrapper +{ +public: + std::shared_ptr sharedState; + LudusTimestampedVkState* pState; + int cudaDeviceIdx; + cudaEvent_t lastUseEvent; + bool hasLastUseEvent; + std::mutex stateMutex; + int outputCursor; + + LudusTimestampedVkStateWrapper(int cudaDeviceIdx_) + : sharedState(std::make_shared(cudaDeviceIdx_)) + , pState(sharedState->pState) + , cudaDeviceIdx(cudaDeviceIdx_) + , lastUseEvent(nullptr) + , hasLastUseEvent(false) + , outputCursor(0) + { + const at::cuda::OptionalCUDAGuard device_guard( + c10::Device(c10::kCUDA, cudaDeviceIdx)); + AT_CUDA_CHECK(cudaEventCreateWithFlags(&lastUseEvent, cudaEventDisableTiming)); + } + + ~LudusTimestampedVkStateWrapper() + { + const at::cuda::OptionalCUDAGuard device_guard( + c10::Device(c10::kCUDA, cudaDeviceIdx)); + std::lock_guard lock(stateMutex); + if (hasLastUseEvent) + AT_CUDA_CHECK(cudaEventSynchronize(lastUseEvent)); + AT_CUDA_CHECK(cudaEventDestroy(lastUseEvent)); + } + + void waitForLastUse(cudaStream_t stream) + { + if (hasLastUseEvent) + AT_CUDA_CHECK(cudaStreamWaitEvent(stream, lastUseEvent, 0)); + } + + void recordLastUse(cudaStream_t stream) + { + AT_CUDA_CHECK(cudaEventRecord(lastUseEvent, stream)); + hasLastUseEvent = true; + } + + int acquireOutputSlot() + { + for (int attempt = 0; attempt < LUDUS_VK_OUTPUT_SLOTS; ++attempt) { + int slot = (outputCursor + attempt) % LUDUS_VK_OUTPUT_SLOTS; + bool expected = false; + if (sharedState->inUse[slot].compare_exchange_strong( + expected, true, std::memory_order_acq_rel)) { + outputCursor = (slot + 1) % LUDUS_VK_OUTPUT_SLOTS; + return slot; + } + } + TORCH_CHECK(false, + "all Vulkan zero-copy output slots are still referenced; " + "release an older render tensor before submitting another batch"); + return -1; + } + + void releaseOutputSlot(int slot) + { + sharedState->inUse[slot].store(false, std::memory_order_release); + } + + void waitForOutputRelease(cudaStream_t stream, int slot) + { + if (sharedState->releaseRecorded[slot].load( + std::memory_order_acquire)) { + AT_CUDA_CHECK(cudaStreamWaitEvent( + stream, sharedState->releaseEvents[slot], 0)); + } + } + + int uploadScene( + torch::Tensor scene_desc, torch::Tensor polyline_pools, + torch::Tensor polygon_pools, torch::Tensor obstacle_pools, + int max_obstacles_in_pool, + int max_varrays_per_ts_polyline, int max_varrays_per_ts_polygon, + torch::Tensor timestamps, + torch::Tensor int32_data, torch::Tensor vertices, + torch::Tensor triangles, torch::Tensor poses, + torch::Tensor float_data) + { + const at::cuda::OptionalCUDAGuard device_guard(device_of(scene_desc)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard lock(stateMutex); + waitForLastUse(stream); + int sceneId = ludusUploadSceneVk( + NVDR_CTX_PARAMS, *pState, stream, + reinterpret_cast(scene_desc.data_ptr()), + reinterpret_cast(polyline_pools.data_ptr()), + polyline_pools.numel() > 0 ? (int)polyline_pools.size(0) : 0, + reinterpret_cast(polygon_pools.data_ptr()), + polygon_pools.numel() > 0 ? (int)polygon_pools.size(0) : 0, + reinterpret_cast(obstacle_pools.data_ptr()), + obstacle_pools.numel() > 0 ? (int)obstacle_pools.size(0) : 0, + max_obstacles_in_pool, + max_varrays_per_ts_polyline, max_varrays_per_ts_polygon, + timestamps.data_ptr(), (int)timestamps.numel(), + int32_data.data_ptr(), (int)int32_data.numel(), + reinterpret_cast(vertices.data_ptr()), (int)vertices.size(0), + reinterpret_cast(triangles.data_ptr()), (int)triangles.size(0), + reinterpret_cast(poses.data_ptr()), (int)poses.size(0), + float_data.data_ptr(), (int)float_data.numel() + ); + recordLastUse(stream); + return sceneId; + } + + void uploadCameras(torch::Tensor intrinsics) + { + const at::cuda::OptionalCUDAGuard device_guard(device_of(intrinsics)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard lock(stateMutex); + waitForLastUse(stream); + ludusUploadCamerasVk(NVDR_CTX_PARAMS, *pState, stream, + reinterpret_cast(intrinsics.data_ptr()), + (int)intrinsics.size(0)); + recordLastUse(stream); + } + + void uploadColorPalette(torch::Tensor colors) + { + // Accept either packed int32 RGBA8 (CUDA backend convention) or + // float[N,4] RGBA in [0,1]. The Vulkan shaders sample float; we + // convert int32 packed -> float here so callers can use either. + const at::cuda::OptionalCUDAGuard device_guard(device_of(colors)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard lock(stateMutex); + waitForLastUse(stream); + + torch::Tensor f; + int numColors; + if (colors.dtype() == torch::kInt32) { + numColors = (int)colors.numel(); + auto packed = colors.to(torch::kInt64).clone(); + auto r = (packed.bitwise_and(0xFFLL)).to(torch::kFloat32).div(255.0f); + auto g = (packed.bitwise_right_shift(8).bitwise_and(0xFFLL)).to(torch::kFloat32).div(255.0f); + auto b = (packed.bitwise_right_shift(16).bitwise_and(0xFFLL)).to(torch::kFloat32).div(255.0f); + auto a = (packed.bitwise_right_shift(24).bitwise_and(0xFFLL)).to(torch::kFloat32).div(255.0f); + f = torch::stack({r, g, b, a}, /*dim=*/-1).contiguous(); + } else { + TORCH_CHECK(colors.dtype() == torch::kFloat32, + "upload_color_palette: expected int32 packed RGBA8 or float32 [N,4]"); + TORCH_CHECK(colors.dim() == 2 && colors.size(1) == 4, + "upload_color_palette: float tensor must be [N,4]"); + f = colors.contiguous(); + numColors = (int)f.size(0); + } + // The tensor came in on CPU/CUDA; the VK uploader needs CUDA memory. + if (!f.is_cuda()) + f = f.to(torch::kCUDA); + + ludusUploadColorPaletteVk(NVDR_CTX_PARAMS, *pState, stream, + f.data_ptr(), numColors); + recordLastUse(stream); + } + + void removeScene(int sceneId) + { + const at::cuda::OptionalCUDAGuard device_guard(c10::Device(c10::kCUDA, cudaDeviceIdx)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard lock(stateMutex); + waitForLastUse(stream); + ludusRemoveSceneVk(NVDR_CTX_PARAMS, *pState, sceneId, stream); + recordLastUse(stream); + } + + void updateCubePool( + int absolutePoolIndex, + int timestampOffset, int trackTimestampOffset, int int32Offset, + int translationOffset, int quaternionOffset, int scaleOffset, int colorOffset, + torch::Tensor timestamps, torch::Tensor trackTimestamps, + torch::Tensor prefixSum, torch::Tensor translations, + torch::Tensor quaternions, torch::Tensor scales, + torch::Tensor colors, torch::Tensor poolHeader) + { + const at::cuda::OptionalCUDAGuard device_guard(device_of(timestamps)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard lock(stateMutex); + waitForLastUse(stream); + + NVDR_CHECK_DEVICE(timestamps, trackTimestamps, prefixSum, translations, + quaternions, scales, colors, poolHeader); + NVDR_CHECK_CONTIGUOUS(timestamps, trackTimestamps, prefixSum, translations, + quaternions, scales, colors, poolHeader); + TORCH_CHECK(timestamps.dtype() == torch::kInt64 && + trackTimestamps.dtype() == torch::kInt64, + "update_cube_pool timestamps must be int64"); + TORCH_CHECK(prefixSum.dtype() == torch::kInt32, + "update_cube_pool prefix sum must be int32"); + NVDR_CHECK_F32(translations, quaternions, scales, colors); + TORCH_CHECK(poolHeader.dtype() == torch::kUInt8 && poolHeader.numel() == 64, + "update_cube_pool header must contain exactly 64 uint8 values"); + + ludusUpdateCubePoolVk( + NVDR_CTX_PARAMS, *pState, stream, absolutePoolIndex, + timestampOffset, trackTimestampOffset, int32Offset, + translationOffset, quaternionOffset, scaleOffset, colorOffset, + timestamps.data_ptr(), (int)timestamps.numel(), + trackTimestamps.data_ptr(), (int)trackTimestamps.numel(), + prefixSum.data_ptr(), (int)prefixSum.numel(), + translations.data_ptr(), (int)translations.numel(), + quaternions.data_ptr(), (int)quaternions.numel(), + scales.data_ptr(), (int)scales.numel(), + colors.data_ptr(), (int)colors.numel(), + reinterpret_cast(poolHeader.data_ptr())); + recordLastUse(stream); + } + + void clearScenes() { + std::lock_guard lock(stateMutex); + ludusClearScenesVk(NVDR_CTX_PARAMS, *pState); + } + + void setTessellationThreshold(float t) { + std::lock_guard lock(stateMutex); + pState->tessellationThreshold = t; + } + + void setMaxTessellationLevels(int pl, int pg, int c) { + std::lock_guard lock(stateMutex); + pState->maxTessellationLevelPolyline = pl; + pState->maxTessellationLevelPolygon = pg; + pState->maxTessellationLevelCube = c; + } + + void setLineWidths(float pr, float pb, float er, float eb, float w) { + std::lock_guard lock(stateMutex); + pState->widthPolylineRegular = pr; + pState->widthPolylineBev = pb; + pState->widthEgoTrajRegular = er; + pState->widthEgoTrajBev = eb; + pState->widthWireframe = w; + } + + void setResolutionScale(float s) { + std::lock_guard lock(stateMutex); + pState->resolutionScale = s; + } + void setDepthScaling(float e) { + std::lock_guard lock(stateMutex); + pState->depthScaling = e; + } + void setCullRadius(float r) { + std::lock_guard lock(stateMutex); + pState->cullRadiusScale = r; + } + + void setMsaaSamples(int s) { + std::lock_guard lock(stateMutex); + TORCH_CHECK(s <= 1, + "Vulkan color-attachment compute export currently supports one " + "sample; multisample resolve is not enabled"); + pState->msaaSamples = s; + // ensureFramebuffer detects the sample mismatch and rebuilds the + // depth-target cache and compatible pipelines on the next render. + } + + int getMaxBatchSize() { + std::lock_guard lock(stateMutex); + // Vulkan multi-view has driver-dependent layer limits; 2048 is a safe + // working upper bound on contemporary NVIDIA drivers. + return 2048; + } +}; + +//------------------------------------------------------------------------ +// Render batch +//------------------------------------------------------------------------ + +torch::Tensor ludus_timestamped_render_batch_vk( + LudusTimestampedVkStateWrapper& stateWrapper, + torch::Tensor queries, torch::Tensor camera_poses, + std::tuple resolution) +{ + const at::cuda::OptionalCUDAGuard device_guard(device_of(queries)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard state_lock(stateWrapper.stateMutex); + stateWrapper.waitForLastUse(stream); + LudusTimestampedVkState& s = *stateWrapper.pState; + + NVDR_CHECK_DEVICE(queries, camera_poses); + NVDR_CHECK_CONTIGUOUS(queries, camera_poses); + + int numQueries = queries.size(0); + int height = std::get<0>(resolution); + int width = std::get<1>(resolution); + auto opts = torch::TensorOptions().dtype(torch::kUInt8).device(queries.device()); + if (numQueries == 0) + return torch::empty({0, height, width, 4}, opts); + + // FLU -> RDF then transpose (column-major mat4 for GLSL). + torch::Tensor poses_rdf = flu_to_rdf(camera_poses).transpose(-2, -1).contiguous(); + const int outputSlot = stateWrapper.acquireOutputSlot(); + try { + stateWrapper.waitForOutputRelease(stream, outputSlot); + ludusRenderBatchVk(NVDR_CTX_PARAMS, s, stream, + reinterpret_cast(queries.data_ptr()), + reinterpret_cast(poses_rdf.data_ptr()), + numQueries, width, height, outputSlot); + + uint8_t* sharedOutput = ludusMapBatchResultsVk( + NVDR_CTX_PARAMS, s, stream, outputSlot, + width, height, numQueries); + auto sharedState = stateWrapper.sharedState; + const int cudaDeviceIdx = stateWrapper.cudaDeviceIdx; + torch::Tensor out = torch::from_blob( + sharedOutput, + {numQueries, height, width, 4}, + [sharedState, outputSlot, cudaDeviceIdx](void*) { + // Record the release on the consumer's current stream. A + // future render stream waits this event before signaling the + // CUDA->Vulkan timeline value for slot reuse. + if (cudaSetDevice(cudaDeviceIdx) == cudaSuccess && + cudaEventRecord( + sharedState->releaseEvents[outputSlot], + at::cuda::getCurrentCUDAStream(cudaDeviceIdx)) + == cudaSuccess) { + sharedState->releaseRecorded[outputSlot].store( + true, std::memory_order_release); + sharedState->inUse[outputSlot].store( + false, std::memory_order_release); + } + }, + opts); + stateWrapper.recordLastUse(stream); + return out; + } catch (...) { + stateWrapper.releaseOutputSlot(outputSlot); + throw; + } +} + +//------------------------------------------------------------------------ +// Render to staging (for double-buffered async output) +//------------------------------------------------------------------------ + +std::tuple ludus_timestamped_render_to_staging_vk( + LudusTimestampedVkStateWrapper& stateWrapper, + torch::Tensor queries, torch::Tensor camera_poses, + std::tuple resolution) +{ + const at::cuda::OptionalCUDAGuard device_guard(device_of(queries)); + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + std::lock_guard state_lock(stateWrapper.stateMutex); + stateWrapper.waitForLastUse(stream); + LudusTimestampedVkState& s = *stateWrapper.pState; + + NVDR_CHECK_DEVICE(queries, camera_poses); + NVDR_CHECK_CONTIGUOUS(queries, camera_poses); + + int numQueries = queries.size(0); + int height = std::get<0>(resolution); + int width = std::get<1>(resolution); + + torch::Tensor poses_rdf = flu_to_rdf(camera_poses).transpose(-2, -1).contiguous(); + const int outputSlot = stateWrapper.acquireOutputSlot(); + try { + stateWrapper.waitForOutputRelease(stream, outputSlot); + ludusRenderBatchVk(NVDR_CTX_PARAMS, s, stream, + reinterpret_cast(queries.data_ptr()), + reinterpret_cast(poses_rdf.data_ptr()), + numQueries, width, height, outputSlot); + + int stagingIdx = ludusCopyBatchResultsToStagingVk( + NVDR_CTX_PARAMS, s, stream, width, height, numQueries); + stateWrapper.recordLastUse(stream); + // The staging copy is ordered before lastUseEvent, so the next wrapper + // call cannot reuse this slot until that copy has completed. + stateWrapper.releaseOutputSlot(outputSlot); + return std::make_tuple(stagingIdx, true); + } catch (...) { + stateWrapper.releaseOutputSlot(outputSlot); + throw; + } +} + +torch::Tensor ludus_timestamped_get_staging_data_vk( + LudusTimestampedVkStateWrapper& stateWrapper, int stagingIdx) +{ + std::lock_guard state_lock(stateWrapper.stateMutex); + LudusTimestampedVkState& s = *stateWrapper.pState; + int w = s.stagingWidth, h = s.stagingHeight, n = s.stagingNumQueries; + auto opts = torch::TensorOptions().dtype(torch::kUInt8).device(torch::kCUDA, stateWrapper.cudaDeviceIdx); + torch::Tensor out = torch::empty({n, h, w, 4}, opts); + + ludusCopyStagingToOutputVk(NVDR_CTX_PARAMS, s, stagingIdx, + out.data_ptr(), w, h, n); + return out; +} + +py::list ludus_timestamped_encode_jpeg_batch_staging_vk( + LudusTimestampedVkStateWrapper& stateWrapper, int stagingIdx, int quality) +{ + std::lock_guard state_lock(stateWrapper.stateMutex); + LudusTimestampedVkState& s = *stateWrapper.pState; + std::vector> jpegs; + ludusEncodeJpegBatchStagingVk(NVDR_CTX_PARAMS, s, stagingIdx, quality, jpegs); + + py::list result; + for (auto& [data, size] : jpegs) { + result.append(py::bytes(reinterpret_cast(data), size)); + free(data); + } + return result; +} + +bool ludus_timestamped_is_nvjpeg_available_vk(LudusTimestampedVkStateWrapper& /*stateWrapper*/) +{ + return true; +} + +//------------------------------------------------------------------------ +// pybind11 module +//------------------------------------------------------------------------ + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + pybind11::class_(m, "LudusTimestampedVkStateWrapper") + .def(pybind11::init()) + .def("upload_scene", &LudusTimestampedVkStateWrapper::uploadScene) + .def("upload_cameras", &LudusTimestampedVkStateWrapper::uploadCameras) + .def("upload_color_palette", &LudusTimestampedVkStateWrapper::uploadColorPalette) + .def("update_cube_pool", &LudusTimestampedVkStateWrapper::updateCubePool) + .def("remove_scene", &LudusTimestampedVkStateWrapper::removeScene) + .def("clear_scenes", &LudusTimestampedVkStateWrapper::clearScenes) + .def("set_tessellation_threshold", &LudusTimestampedVkStateWrapper::setTessellationThreshold) + .def("set_max_tessellation_levels", &LudusTimestampedVkStateWrapper::setMaxTessellationLevels) + .def("set_line_widths", &LudusTimestampedVkStateWrapper::setLineWidths) + .def("set_resolution_scale", &LudusTimestampedVkStateWrapper::setResolutionScale) + .def("set_depth_scaling", &LudusTimestampedVkStateWrapper::setDepthScaling) + .def("set_cull_radius", &LudusTimestampedVkStateWrapper::setCullRadius) + .def("set_msaa_samples", &LudusTimestampedVkStateWrapper::setMsaaSamples) + .def("get_max_batch_size", &LudusTimestampedVkStateWrapper::getMaxBatchSize); + + m.def("ludus_timestamped_render_batch", &ludus_timestamped_render_batch_vk); + m.def("ludus_timestamped_render_to_staging", &ludus_timestamped_render_to_staging_vk); + m.def("ludus_timestamped_get_staging_data", &ludus_timestamped_get_staging_data_vk); + m.def("ludus_timestamped_is_nvjpeg_available", &ludus_timestamped_is_nvjpeg_available_vk); + m.def("ludus_timestamped_encode_jpeg_batch_staging", &ludus_timestamped_encode_jpeg_batch_staging_vk); +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp new file mode 100644 index 000000000..ea16503d9 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp @@ -0,0 +1,707 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "framework.h" +#include "vkutil.h" +#include +#include +#if !defined(_WIN32) +#include +#endif + +// VK_CHECK / VK_DBG / ludus_vk_debug() live in vkutil.h (shared with the +// renderer translation unit). + +#if defined(_WIN32) +static constexpr VkExternalMemoryHandleTypeFlagBits kExternalMemoryHandleType = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; +static constexpr VkExternalSemaphoreHandleTypeFlagBits kExternalSemaphoreHandleType = + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT; +static constexpr const char* kExternalMemoryExtension = + VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME; +static constexpr const char* kExternalSemaphoreExtension = + VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME; +#else +static constexpr VkExternalMemoryHandleTypeFlagBits kExternalMemoryHandleType = + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT; +static constexpr VkExternalSemaphoreHandleTypeFlagBits kExternalSemaphoreHandleType = + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT; +static constexpr const char* kExternalMemoryExtension = + VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME; +static constexpr const char* kExternalSemaphoreExtension = + VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME; +#endif + +// --------------------------------------------------------------------------- +// Debug messenger (optional, only attached when validation layer is loaded). +// --------------------------------------------------------------------------- + +static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback( + VkDebugUtilsMessageSeverityFlagBitsEXT severity, + VkDebugUtilsMessageTypeFlagsEXT /*type*/, + const VkDebugUtilsMessengerCallbackDataEXT* data, + void* /*userData*/) +{ + if (severity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { + fprintf(stderr, "[Vulkan] %s\n", data->pMessage); + fflush(stderr); + } + return VK_FALSE; +} + +// --------------------------------------------------------------------------- +// UUID pairing with a CUDA device. Zero-copy interop must never silently bind +// Vulkan and CUDA to different physical GPUs. +// --------------------------------------------------------------------------- + +static bool matchCudaDevice(VkInstance /*instance*/, VkPhysicalDevice physDev, int cudaDeviceIdx) +{ + cudaDeviceProp cudaProps; + if (cudaGetDeviceProperties(&cudaProps, cudaDeviceIdx) != cudaSuccess) + return false; + + VkPhysicalDeviceProperties2 props2 = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2}; + VkPhysicalDeviceIDProperties id = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES}; + props2.pNext = &id; + vkGetPhysicalDeviceProperties2(physDev, &props2); + + return memcmp(id.deviceUUID, cudaProps.uuid.bytes, VK_UUID_SIZE) == 0; +} + +// --------------------------------------------------------------------------- +// Context creation +// --------------------------------------------------------------------------- + +VkContext createVkContext(int cudaDeviceIdx) +{ + VkContext ctx = {}; + ctx.cudaDeviceIdx = cudaDeviceIdx; + + VkApplicationInfo appInfo = {VK_STRUCTURE_TYPE_APPLICATION_INFO}; + appInfo.pApplicationName = "ludus-renderer"; + appInfo.apiVersion = VK_API_VERSION_1_3; + + std::vector instExts = { + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, + VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, + VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, + }; + std::vector layers; + +#ifndef NDEBUG + uint32_t layerCount = 0; + vkEnumerateInstanceLayerProperties(&layerCount, nullptr); + std::vector availLayers(layerCount); + vkEnumerateInstanceLayerProperties(&layerCount, availLayers.data()); + for (auto& l : availLayers) { + if (strcmp(l.layerName, "VK_LAYER_KHRONOS_validation") == 0) { + layers.push_back("VK_LAYER_KHRONOS_validation"); + instExts.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + break; + } + } +#endif + + VkInstanceCreateInfo instCI = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO}; + instCI.pApplicationInfo = &appInfo; + instCI.enabledExtensionCount = (uint32_t)instExts.size(); + instCI.ppEnabledExtensionNames = instExts.data(); + instCI.enabledLayerCount = (uint32_t)layers.size(); + instCI.ppEnabledLayerNames = layers.data(); + VK_CHECK(vkCreateInstance(&instCI, nullptr, &ctx.instance)); + + uint32_t devCount = 0; + vkEnumeratePhysicalDevices(ctx.instance, &devCount, nullptr); + TORCH_CHECK(devCount > 0, "No Vulkan physical devices found"); + std::vector physDevs(devCount); + vkEnumeratePhysicalDevices(ctx.instance, &devCount, physDevs.data()); + + ctx.physicalDevice = VK_NULL_HANDLE; + if (cudaDeviceIdx >= 0) { + for (auto& pd : physDevs) { + if (matchCudaDevice(ctx.instance, pd, cudaDeviceIdx)) { + ctx.physicalDevice = pd; + break; + } + } + } + if (ctx.physicalDevice == VK_NULL_HANDLE) { + TORCH_CHECK(cudaDeviceIdx < 0, + "No Vulkan physical device matches CUDA device ", cudaDeviceIdx, + "; zero-copy CUDA/Vulkan external memory requires one physical GPU"); + ctx.physicalDevice = physDevs[0]; + } + + VkPhysicalDeviceProperties devProps; + vkGetPhysicalDeviceProperties(ctx.physicalDevice, &devProps); + VK_DBG("[Vulkan] Device: %s (apiVersion %u.%u.%u)\n", + devProps.deviceName, + VK_API_VERSION_MAJOR(devProps.apiVersion), + VK_API_VERSION_MINOR(devProps.apiVersion), + VK_API_VERSION_PATCH(devProps.apiVersion)); + + vkGetPhysicalDeviceMemoryProperties(ctx.physicalDevice, &ctx.memProperties); + + uint32_t extCount = 0; + vkEnumerateDeviceExtensionProperties(ctx.physicalDevice, nullptr, &extCount, nullptr); + std::vector availExts(extCount); + vkEnumerateDeviceExtensionProperties(ctx.physicalDevice, nullptr, &extCount, availExts.data()); + + auto hasExt = [&](const char* name) { + for (auto& e : availExts) + if (strcmp(e.extensionName, name) == 0) return true; + return false; + }; + + ctx.hasMeshShader = hasExt(VK_EXT_MESH_SHADER_EXTENSION_NAME); + ctx.hasFragmentShaderBarycentric = hasExt(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME); + ctx.hasExternalMemory = hasExt(kExternalMemoryExtension); + ctx.hasExternalSemaphore = hasExt(kExternalSemaphoreExtension); + + TORCH_CHECK(ctx.hasMeshShader, + "VK_EXT_mesh_shader is required but not supported by Vulkan device '", + devProps.deviceName, "'"); + TORCH_CHECK(ctx.hasFragmentShaderBarycentric, + "VK_KHR_fragment_shader_barycentric is required but not supported by " + "Vulkan device '", devProps.deviceName, "'"); + TORCH_CHECK(ctx.hasExternalMemory, + kExternalMemoryExtension, " is required for CUDA interop"); + TORCH_CHECK(ctx.hasExternalSemaphore, + kExternalSemaphoreExtension, + " is required for asynchronous CUDA interop"); + + uint32_t qfCount = 0; + vkGetPhysicalDeviceQueueFamilyProperties(ctx.physicalDevice, &qfCount, nullptr); + std::vector qfProps(qfCount); + vkGetPhysicalDeviceQueueFamilyProperties(ctx.physicalDevice, &qfCount, qfProps.data()); + + ctx.graphicsQueueFamily = UINT32_MAX; + for (uint32_t i = 0; i < qfCount; i++) { + if (qfProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) { + ctx.graphicsQueueFamily = i; + break; + } + } + TORCH_CHECK(ctx.graphicsQueueFamily != UINT32_MAX, "No graphics queue family found"); + + float queuePriority = 1.0f; + VkDeviceQueueCreateInfo queueCI = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO}; + queueCI.queueFamilyIndex = ctx.graphicsQueueFamily; + queueCI.queueCount = 1; + queueCI.pQueuePriorities = &queuePriority; + + std::vector devExts = { + VK_EXT_MESH_SHADER_EXTENSION_NAME, + VK_KHR_SPIRV_1_4_EXTENSION_NAME, + VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME, + VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, + kExternalMemoryExtension, + VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME, + kExternalSemaphoreExtension, + }; + if (ctx.hasFragmentShaderBarycentric) + devExts.push_back(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME); + + // Feature chain: VK_EXT_mesh_shader requires its own features struct, + // plus maintenance4 to allow the task/mesh shader stages to express + // workgroup sizes via local_size_x_id constants. + VkPhysicalDeviceMeshShaderFeaturesEXT meshFeatures = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT}; + meshFeatures.taskShader = VK_TRUE; + meshFeatures.meshShader = VK_TRUE; + + VkPhysicalDeviceMaintenance4Features maint4 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES}; + maint4.maintenance4 = VK_TRUE; + meshFeatures.pNext = &maint4; + + VkPhysicalDeviceTimelineSemaphoreFeatures timelineFeatures = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES}; + timelineFeatures.timelineSemaphore = VK_TRUE; + + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR barycentricFeatures = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR}; + barycentricFeatures.fragmentShaderBarycentric = VK_TRUE; + maint4.pNext = &timelineFeatures; + timelineFeatures.pNext = ctx.hasFragmentShaderBarycentric ? (void*)&barycentricFeatures : nullptr; + + VkPhysicalDeviceFeatures2 features2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2}; + VkPhysicalDeviceFeatures supportedFeatures = {}; + vkGetPhysicalDeviceFeatures(ctx.physicalDevice, &supportedFeatures); + TORCH_CHECK(supportedFeatures.geometryShader, + "geometryShader is required for layered mesh-shader rasterization"); + TORCH_CHECK(supportedFeatures.shaderInt64, + "shaderInt64 is required by timestamped Ludus shaders"); + TORCH_CHECK(supportedFeatures.fillModeNonSolid, + "fillModeNonSolid is required by Ludus pipeline configuration"); + features2.features.multiDrawIndirect = VK_TRUE; + features2.features.fillModeNonSolid = VK_TRUE; + features2.features.shaderInt64 = VK_TRUE; + // gl_Layer emitted by the mesh stage is represented by SPIR-V's Geometry + // capability even though no classic geometry shader stage is present. + features2.features.geometryShader = VK_TRUE; + features2.pNext = &meshFeatures; + + VkDeviceCreateInfo devCI = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO}; + devCI.queueCreateInfoCount = 1; + devCI.pQueueCreateInfos = &queueCI; + devCI.enabledExtensionCount = (uint32_t)devExts.size(); + devCI.ppEnabledExtensionNames = devExts.data(); + devCI.pNext = &features2; + + VK_CHECK(vkCreateDevice(ctx.physicalDevice, &devCI, nullptr, &ctx.device)); + vkGetDeviceQueue(ctx.device, ctx.graphicsQueueFamily, 0, &ctx.graphicsQueue); + + ctx.pfnCmdDrawMeshTasksEXT = (PFN_vkCmdDrawMeshTasksEXT) + vkGetDeviceProcAddr(ctx.device, "vkCmdDrawMeshTasksEXT"); + TORCH_CHECK(ctx.pfnCmdDrawMeshTasksEXT != nullptr, + "vkCmdDrawMeshTasksEXT not available even though VK_EXT_mesh_shader is reported"); + + VkCommandPoolCreateInfo poolCI = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO}; + poolCI.queueFamilyIndex = ctx.graphicsQueueFamily; + poolCI.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + VK_CHECK(vkCreateCommandPool(ctx.device, &poolCI, nullptr, &ctx.commandPool)); + + VkCommandBufferAllocateInfo allocCI = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO}; + allocCI.commandPool = ctx.commandPool; + allocCI.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocCI.commandBufferCount = VkContext::kFramesInFlight; + VK_CHECK(vkAllocateCommandBuffers(ctx.device, &allocCI, ctx.commandBuffers)); + + VkFenceCreateInfo fenceCI = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + fenceCI.flags = VK_FENCE_CREATE_SIGNALED_BIT; + for (uint32_t i = 0; i < VkContext::kFramesInFlight; ++i) + VK_CHECK(vkCreateFence(ctx.device, &fenceCI, nullptr, &ctx.fences[i])); + + VkExportSemaphoreCreateInfo exportSemaphore = { + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO}; + exportSemaphore.handleTypes = kExternalSemaphoreHandleType; + VkSemaphoreTypeCreateInfo timelineCI = { + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO}; + timelineCI.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE; + timelineCI.initialValue = 0; + timelineCI.pNext = &exportSemaphore; + VkSemaphoreCreateInfo semaphoreCI = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; + semaphoreCI.pNext = &timelineCI; + VK_CHECK(vkCreateSemaphore(ctx.device, &semaphoreCI, nullptr, &ctx.interopTimeline)); + + CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC semaphoreDesc = {}; +#if defined(_WIN32) + auto vkGetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR) + vkGetDeviceProcAddr(ctx.device, "vkGetSemaphoreWin32HandleKHR"); + TORCH_CHECK(vkGetSemaphoreWin32HandleKHR, + "vkGetSemaphoreWin32HandleKHR not available"); + VkSemaphoreGetWin32HandleInfoKHR semaphoreHandleInfo = { + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR}; + semaphoreHandleInfo.semaphore = ctx.interopTimeline; + semaphoreHandleInfo.handleType = kExternalSemaphoreHandleType; + HANDLE semaphoreHandle = nullptr; + VK_CHECK(vkGetSemaphoreWin32HandleKHR( + ctx.device, &semaphoreHandleInfo, &semaphoreHandle)); + semaphoreDesc.type = + CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32; + semaphoreDesc.handle.win32.handle = semaphoreHandle; + CUresult cr = cuImportExternalSemaphore( + &ctx.cuInteropTimeline, &semaphoreDesc); + // CUDA retains the imported object but does not take ownership of an NT + // handle. Close our transport handle on both success and failure. + CloseHandle(semaphoreHandle); +#else + auto vkGetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR) + vkGetDeviceProcAddr(ctx.device, "vkGetSemaphoreFdKHR"); + TORCH_CHECK(vkGetSemaphoreFdKHR, "vkGetSemaphoreFdKHR not available"); + VkSemaphoreGetFdInfoKHR semaphoreHandleInfo = { + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR}; + semaphoreHandleInfo.semaphore = ctx.interopTimeline; + semaphoreHandleInfo.handleType = kExternalSemaphoreHandleType; + int semaphoreFd = -1; + VK_CHECK(vkGetSemaphoreFdKHR( + ctx.device, &semaphoreHandleInfo, &semaphoreFd)); + semaphoreDesc.type = CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD; + semaphoreDesc.handle.fd = semaphoreFd; + CUresult cr = cuImportExternalSemaphore( + &ctx.cuInteropTimeline, &semaphoreDesc); + // A successful CUDA import consumes an opaque fd. Retain no descriptor; + // close it ourselves only when ownership was not transferred. + if (cr != CUDA_SUCCESS) close(semaphoreFd); +#endif + TORCH_CHECK(cr == CUDA_SUCCESS, + "cuImportExternalSemaphore (timeline) failed: ", (int)cr); + ctx.frameCursor = 0; + ctx.nextTimelineValue = 0; + + VK_DBG("[Vulkan] Context ready (mesh_shader=EXT, barycentric=%s)\n", + ctx.hasFragmentShaderBarycentric ? "KHR" : "off"); + + return ctx; +} + +void destroyVkContext(VkContext& ctx) +{ + if (ctx.device) { + vkDeviceWaitIdle(ctx.device); + if (ctx.cuInteropTimeline) { + cuDestroyExternalSemaphore(ctx.cuInteropTimeline); + ctx.cuInteropTimeline = nullptr; + } + if (ctx.interopTimeline) + vkDestroySemaphore(ctx.device, ctx.interopTimeline, nullptr); + for (uint32_t i = 0; i < VkContext::kFramesInFlight; ++i) + if (ctx.fences[i]) vkDestroyFence(ctx.device, ctx.fences[i], nullptr); + if (ctx.commandPool) vkDestroyCommandPool(ctx.device, ctx.commandPool, nullptr); + vkDestroyDevice(ctx.device, nullptr); + } + if (ctx.instance) vkDestroyInstance(ctx.instance, nullptr); + memset(&ctx, 0, sizeof(VkContext)); +} + +uint64_t signalInteropTimelineFromCuda(VkContext& ctx, cudaStream_t stream) +{ + const uint64_t value = ++ctx.nextTimelineValue; + CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS params = {}; + params.params.fence.value = value; + CUexternalSemaphore semaphore = ctx.cuInteropTimeline; + CUresult cr = cuSignalExternalSemaphoresAsync( + &semaphore, ¶ms, 1, reinterpret_cast(stream)); + TORCH_CHECK(cr == CUDA_SUCCESS, + "cuSignalExternalSemaphoresAsync failed: ", (int)cr); + return value; +} + +void waitInteropTimelineOnCuda( + VkContext& ctx, cudaStream_t stream, uint64_t value) +{ + if (value == 0) return; + CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS params = {}; + params.params.fence.value = value; + CUexternalSemaphore semaphore = ctx.cuInteropTimeline; + CUresult cr = cuWaitExternalSemaphoresAsync( + &semaphore, ¶ms, 1, reinterpret_cast(stream)); + TORCH_CHECK(cr == CUDA_SUCCESS, + "cuWaitExternalSemaphoresAsync failed: ", (int)cr); +} + +// --------------------------------------------------------------------------- +// Memory helpers +// --------------------------------------------------------------------------- + +uint32_t findMemoryType( + const VkPhysicalDeviceMemoryProperties& memProps, + uint32_t typeFilter, + VkMemoryPropertyFlags properties) +{ + for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) { + if ((typeFilter & (1 << i)) && + (memProps.memoryTypes[i].propertyFlags & properties) == properties) + return i; + } + TORCH_CHECK(false, "Failed to find suitable Vulkan memory type"); + return UINT32_MAX; +} + +// --------------------------------------------------------------------------- +// External buffer (SSBO with CUDA import) +// --------------------------------------------------------------------------- + +VkExternalBuffer createExternalBuffer( + VkContext& ctx, + VkDeviceSize size, + VkBufferUsageFlags usage, + bool cudaImportable) +{ + VkExternalBuffer buf = {}; + buf.size = size; + + if (size == 0) return buf; + + VkExternalMemoryBufferCreateInfo extBufCI = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO}; + extBufCI.handleTypes = kExternalMemoryHandleType; + + bool dedicatedOnly = false; + if (cudaImportable) { + VkPhysicalDeviceExternalBufferInfo externalInfo = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO}; + externalInfo.flags = 0; + externalInfo.usage = usage; + externalInfo.handleType = kExternalMemoryHandleType; + VkExternalBufferProperties externalProps = { + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES}; + vkGetPhysicalDeviceExternalBufferProperties( + ctx.physicalDevice, &externalInfo, &externalProps); + const VkExternalMemoryFeatureFlags features = + externalProps.externalMemoryProperties.externalMemoryFeatures; + TORCH_CHECK( + (features & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) != 0, + "Vulkan buffer usage is not external-memory exportable"); + dedicatedOnly = + (features & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0; + } + + VkBufferCreateInfo bufCI = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; + bufCI.size = size; + bufCI.usage = usage; + bufCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + if (cudaImportable) bufCI.pNext = &extBufCI; + + VK_CHECK(vkCreateBuffer(ctx.device, &bufCI, nullptr, &buf.buffer)); + + VkMemoryRequirements memReqs; + vkGetBufferMemoryRequirements(ctx.device, buf.buffer, &memReqs); + + VkExportMemoryAllocateInfo exportAI = {VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO}; + exportAI.handleTypes = kExternalMemoryHandleType; + VkMemoryDedicatedAllocateInfo dedicatedAI = { + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO}; + dedicatedAI.buffer = buf.buffer; + if (dedicatedOnly) + exportAI.pNext = &dedicatedAI; + + VkMemoryAllocateInfo allocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO}; + allocInfo.allocationSize = memReqs.size; + allocInfo.memoryTypeIndex = findMemoryType(ctx.memProperties, memReqs.memoryTypeBits, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + if (cudaImportable) allocInfo.pNext = &exportAI; + + VK_CHECK(vkAllocateMemory(ctx.device, &allocInfo, nullptr, &buf.memory)); + VK_CHECK(vkBindBufferMemory(ctx.device, buf.buffer, buf.memory, 0)); + + if (cudaImportable) { + CUDA_EXTERNAL_MEMORY_HANDLE_DESC memDesc = {}; +#if defined(_WIN32) + VkMemoryGetWin32HandleInfoKHR getHandleInfo = { + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR}; + getHandleInfo.memory = buf.memory; + getHandleInfo.handleType = kExternalMemoryHandleType; + auto vkGetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR) + vkGetDeviceProcAddr(ctx.device, "vkGetMemoryWin32HandleKHR"); + TORCH_CHECK(vkGetMemoryWin32HandleKHR, + "vkGetMemoryWin32HandleKHR not available"); + HANDLE memoryHandle = nullptr; + VK_CHECK(vkGetMemoryWin32HandleKHR( + ctx.device, &getHandleInfo, &memoryHandle)); + memDesc.type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32; + memDesc.handle.win32.handle = memoryHandle; +#else + VkMemoryGetFdInfoKHR getHandleInfo = { + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR}; + getHandleInfo.memory = buf.memory; + getHandleInfo.handleType = kExternalMemoryHandleType; + auto vkGetMemoryFdKHR = (PFN_vkGetMemoryFdKHR) + vkGetDeviceProcAddr(ctx.device, "vkGetMemoryFdKHR"); + TORCH_CHECK(vkGetMemoryFdKHR, "vkGetMemoryFdKHR not available"); + int memoryFd = -1; + VK_CHECK(vkGetMemoryFdKHR(ctx.device, &getHandleInfo, &memoryFd)); + memDesc.type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD; + memDesc.handle.fd = memoryFd; +#endif + memDesc.size = memReqs.size; + memDesc.flags = dedicatedOnly ? CUDA_EXTERNAL_MEMORY_DEDICATED : 0; + CUresult cr = cuImportExternalMemory(&buf.cuExtMem, &memDesc); +#if defined(_WIN32) + // Unlike an fd import, CUDA does not consume the Win32 NT handle. + CloseHandle(memoryHandle); +#else + if (cr != CUDA_SUCCESS) close(memoryFd); +#endif + TORCH_CHECK(cr == CUDA_SUCCESS, "cuImportExternalMemory failed: ", (int)cr); + + CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufDesc = {}; + bufDesc.offset = 0; + bufDesc.size = size; + cr = cuExternalMemoryGetMappedBuffer(&buf.cuDevPtr, buf.cuExtMem, &bufDesc); + TORCH_CHECK(cr == CUDA_SUCCESS, "cuExternalMemoryGetMappedBuffer failed: ", (int)cr); + } + + return buf; +} + +void destroyExternalBuffer(VkContext& ctx, VkExternalBuffer& buf) +{ + if (buf.cuDevPtr) { cuMemFree(buf.cuDevPtr); buf.cuDevPtr = 0; } + if (buf.cuExtMem) { cuDestroyExternalMemory(buf.cuExtMem); buf.cuExtMem = 0; } + if (buf.buffer) { vkDestroyBuffer(ctx.device, buf.buffer, nullptr); buf.buffer = VK_NULL_HANDLE; } + if (buf.memory) { vkFreeMemory(ctx.device, buf.memory, nullptr); buf.memory = VK_NULL_HANDLE; } + buf.size = 0; +} + +void resizeExternalBuffer( + VkContext& ctx, + VkExternalBuffer& buf, + VkDeviceSize newSize, + VkBufferUsageFlags usage, + bool cudaImportable) +{ + bool needsCuda = cudaImportable && (buf.cuDevPtr == 0); + if (buf.size >= newSize && buf.buffer != VK_NULL_HANDLE && !needsCuda) return; + destroyExternalBuffer(ctx, buf); + buf = createExternalBuffer(ctx, newSize, usage, cudaImportable); +} + +// --------------------------------------------------------------------------- +// Vulkan-only images. Layered CUDA image import is intentionally absent. +// --------------------------------------------------------------------------- + +VkExternalImage createExternalImage( + VkContext& ctx, + uint32_t width, uint32_t height, uint32_t layers, + VkFormat format, + VkImageUsageFlags usage, + VkSampleCountFlagBits samples) +{ + VkExternalImage img = {}; + img.width = width; + img.height = height; + img.layers = layers; + img.format = format; + + VkImageCreateInfo imgCI = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; + imgCI.imageType = VK_IMAGE_TYPE_2D; + imgCI.format = format; + imgCI.extent = {width, height, 1}; + imgCI.mipLevels = 1; + imgCI.arrayLayers = layers; + imgCI.samples = samples; + imgCI.tiling = VK_IMAGE_TILING_OPTIMAL; + imgCI.usage = usage; + imgCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + imgCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + + VK_CHECK(vkCreateImage(ctx.device, &imgCI, nullptr, &img.image)); + + VkMemoryRequirements memReqs; + vkGetImageMemoryRequirements(ctx.device, img.image, &memReqs); + img.size = memReqs.size; + + VkMemoryAllocateInfo allocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO}; + allocInfo.allocationSize = memReqs.size; + allocInfo.memoryTypeIndex = findMemoryType(ctx.memProperties, memReqs.memoryTypeBits, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + + VK_CHECK(vkAllocateMemory(ctx.device, &allocInfo, nullptr, &img.memory)); + VK_CHECK(vkBindImageMemory(ctx.device, img.image, img.memory, 0)); + + VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT; + if (format == VK_FORMAT_D24_UNORM_S8_UINT || format == VK_FORMAT_D32_SFLOAT_S8_UINT) + aspect = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; + + VkImageViewCreateInfo viewCI = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; + viewCI.image = img.image; + viewCI.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; + viewCI.format = format; + viewCI.subresourceRange.aspectMask = aspect; + viewCI.subresourceRange.baseMipLevel = 0; + viewCI.subresourceRange.levelCount = 1; + viewCI.subresourceRange.baseArrayLayer = 0; + viewCI.subresourceRange.layerCount = layers; + VK_CHECK(vkCreateImageView(ctx.device, &viewCI, nullptr, &img.imageView)); + + return img; +} + +void destroyExternalImage(VkContext& ctx, VkExternalImage& img) +{ + if (img.imageView) { vkDestroyImageView(ctx.device, img.imageView, nullptr); img.imageView = VK_NULL_HANDLE; } + if (img.image) { vkDestroyImage(ctx.device, img.image, nullptr); img.image = VK_NULL_HANDLE; } + if (img.memory) { vkFreeMemory(ctx.device, img.memory, nullptr); img.memory = VK_NULL_HANDLE; } +} + +// --------------------------------------------------------------------------- +// Command buffer helpers +// --------------------------------------------------------------------------- + +VkCommandBuffer beginSingleTimeCommands(VkContext& ctx) +{ + VkCommandBufferAllocateInfo allocCI = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO}; + allocCI.commandPool = ctx.commandPool; + allocCI.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocCI.commandBufferCount = 1; + + VkCommandBuffer cmd; + VK_CHECK(vkAllocateCommandBuffers(ctx.device, &allocCI, &cmd)); + + VkCommandBufferBeginInfo beginCI = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; + beginCI.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + VK_CHECK(vkBeginCommandBuffer(cmd, &beginCI)); + return cmd; +} + +void endSingleTimeCommands(VkContext& ctx, VkCommandBuffer cmd) +{ + VK_CHECK(vkEndCommandBuffer(cmd)); + + VkSubmitInfo submitInfo = {VK_STRUCTURE_TYPE_SUBMIT_INFO}; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &cmd; + + VkFence tempFence; + VkFenceCreateInfo fenceCI = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + VK_CHECK(vkCreateFence(ctx.device, &fenceCI, nullptr, &tempFence)); + VK_CHECK(vkQueueSubmit(ctx.graphicsQueue, 1, &submitInfo, tempFence)); + VK_CHECK(vkWaitForFences(ctx.device, 1, &tempFence, VK_TRUE, UINT64_MAX)); + + vkDestroyFence(ctx.device, tempFence, nullptr); + vkFreeCommandBuffers(ctx.device, ctx.commandPool, 1, &cmd); +} + +void transitionImageLayout( + VkCommandBuffer cmd, + VkImage image, + VkImageLayout oldLayout, + VkImageLayout newLayout, + uint32_t layerCount, + VkImageAspectFlags aspect) +{ + VkImageMemoryBarrier barrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}; + barrier.oldLayout = oldLayout; + barrier.newLayout = newLayout; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = image; + barrier.subresourceRange.aspectMask = aspect; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = 1; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = layerCount; + + VkPipelineStageFlags srcStage, dstStage; + if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) { + barrier.srcAccessMask = 0; + srcStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; + } else { + barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + srcStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; + } + + if (newLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) { + barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + dstStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + } else if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) { + barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + dstStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + } else if (newLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) { + barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + dstStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + } else if (newLayout == VK_IMAGE_LAYOUT_GENERAL) { + barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT; + dstStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + } else { + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + dstStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + } + + vkCmdPipelineBarrier(cmd, srcStage, dstStage, 0, 0, nullptr, 0, nullptr, 1, &barrier); +} + +// CUDA<->Vulkan handoff uses the exported timeline semaphore above. The +// single-use helpers below are reserved for initialization/control paths. diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h new file mode 100644 index 000000000..9774b1ad4 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h @@ -0,0 +1,185 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#if defined(_WIN32) +#ifndef NOMINMAX +#define NOMINMAX +#endif +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#ifndef VK_USE_PLATFORM_WIN32_KHR +#define VK_USE_PLATFORM_WIN32_KHR +#endif +#endif + +#include +#include +#include +#include +#include +#include +#include + +// --------------------------------------------------------------------------- +// Shared helpers for the Vulkan backend translation units (vkutil.cpp and +// ludus_timestamped_vk.cpp). Defined here so they aren't copy-pasted per file. +// --------------------------------------------------------------------------- + +// Raise via torch's TORCH_CHECK (from framework.h, included by each .cpp before +// this header) when a Vulkan call doesn't return VK_SUCCESS. +#define VK_CHECK(call) do { \ + VkResult _r = (call); \ + TORCH_CHECK(_r == VK_SUCCESS, #call " failed with VkResult ", (int)_r); \ +} while(0) + +// Verbose "[Vulkan] ..." diagnostics, gated on LUDUS_VK_DEBUG=1 so device and +// per-frame traces stay out of production output. +inline bool ludus_vk_debug() { + static int cached = -1; + if (cached == -1) { + const char* e = getenv("LUDUS_VK_DEBUG"); + cached = (e && *e && *e != '0') ? 1 : 0; + } + return cached != 0; +} + +#define VK_DBG(...) do { if (ludus_vk_debug()) { fprintf(stderr, __VA_ARGS__); fflush(stderr); } } while(0) + +// --------------------------------------------------------------------------- +// VkContext: instance + physical device + logical device + queue + command +// pool. Targets Vulkan 1.3 with VK_EXT_mesh_shader for hardware mesh shading. +// --------------------------------------------------------------------------- + +struct VkContext +{ + static constexpr uint32_t kFramesInFlight = 3; + + VkInstance instance; + VkPhysicalDevice physicalDevice; + VkDevice device; + VkQueue graphicsQueue; + uint32_t graphicsQueueFamily; + VkCommandPool commandPool; + VkCommandBuffer commandBuffers[kFramesInFlight]; + VkFence fences[kFramesInFlight]; + uint32_t frameCursor; + VkPhysicalDeviceMemoryProperties memProperties; + int cudaDeviceIdx; + + // Device capabilities (checked at init) + bool hasMeshShader; // VK_EXT_mesh_shader + bool hasFragmentShaderBarycentric; + bool hasExternalMemory; + bool hasExternalSemaphore; + + // Shared timeline: CUDA-ready -> Vulkan-done -> CUDA-release. + VkSemaphore interopTimeline; + CUexternalSemaphore cuInteropTimeline; + uint64_t nextTimelineValue; + + // Cached EXT entry point (resolved at device creation) + PFN_vkCmdDrawMeshTasksEXT pfnCmdDrawMeshTasksEXT; +}; + +// Vulkan buffer with optional CUDA-importable external memory backing. +// When cudaImportable is true the underlying allocation is exported through +// the platform-native Vulkan handle type (Win32 NT handle or Linux fd) and +// imported into CUDA so that PyTorch tensors can write directly into it. The +// transient OS handle is released/transferred immediately after import and is +// deliberately not retained in this long-lived resource. +struct VkExternalBuffer +{ + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize size; + CUexternalMemory cuExtMem; + CUdeviceptr cuDevPtr; +}; + +// Vulkan-only image. CUDA image import is deliberately unsupported; layered +// output interop uses exported linear buffers instead. +struct VkExternalImage +{ + VkImage image; + VkDeviceMemory memory; + VkImageView imageView; + VkDeviceSize size; + uint32_t width; + uint32_t height; + uint32_t layers; + VkFormat format; +}; + +// Context lifecycle. +VkContext createVkContext(int cudaDeviceIdx); +void destroyVkContext(VkContext& ctx); + +// Buffer management with CUDA external memory. +VkExternalBuffer createExternalBuffer( + VkContext& ctx, + VkDeviceSize size, + VkBufferUsageFlags usage, + bool cudaImportable +); +void destroyExternalBuffer(VkContext& ctx, VkExternalBuffer& buf); +void resizeExternalBuffer( + VkContext& ctx, + VkExternalBuffer& buf, + VkDeviceSize newSize, + VkBufferUsageFlags usage, + bool cudaImportable +); + +// Vulkan-only image management (currently depth attachments). +VkExternalImage createExternalImage( + VkContext& ctx, + uint32_t width, uint32_t height, uint32_t layers, + VkFormat format, + VkImageUsageFlags usage, + VkSampleCountFlagBits samples +); +void destroyExternalImage(VkContext& ctx, VkExternalImage& img); + +// Memory type helpers. +uint32_t findMemoryType( + const VkPhysicalDeviceMemoryProperties& memProps, + uint32_t typeFilter, + VkMemoryPropertyFlags properties +); + +// Single-use command buffer helpers. +VkCommandBuffer beginSingleTimeCommands(VkContext& ctx); +void endSingleTimeCommands(VkContext& ctx, VkCommandBuffer cmd); + +// Image layout transitions. +void transitionImageLayout( + VkCommandBuffer cmd, + VkImage image, + VkImageLayout oldLayout, + VkImageLayout newLayout, + uint32_t layerCount, + VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT +); + +// GPU-only CUDA/Vulkan timeline handoff helpers. Neither waits on the host. +uint64_t signalInteropTimelineFromCuda(VkContext& ctx, cudaStream_t stream); +void waitInteropTimelineOnCuda( + VkContext& ctx, + cudaStream_t stream, + uint64_t value +); diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_jpeg.cu b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_jpeg.cu new file mode 100644 index 000000000..a91b06321 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_jpeg.cu @@ -0,0 +1,58 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// CUDA helper used by the Vulkan timestamped renderer to prep RGBA color +// buffers for nvJPEG encoding. The Vulkan render path uses an inverted +// viewport-height to match the shaders' GL-style NDC, which means the +// framebuffer is stored bottom-up in image memory. nvJPEG expects RGB +// top-down, so the kernel both strips alpha and flips rows. + +#include +#include + +__global__ void rgbaToRgbFlipKernel( + const uint8_t* __restrict__ srcRgba, + uint8_t* __restrict__ dstRgb, + int width, + int height) +{ + int x = blockIdx.x * blockDim.x + threadIdx.x; + int y = blockIdx.y * blockDim.y + threadIdx.y; + + if (x >= width || y >= height) return; + + int srcRow = height - 1 - y; + int srcIdx = (srcRow * width + x) * 4; + uint8_t r = srcRgba[srcIdx + 0]; + uint8_t g = srcRgba[srcIdx + 1]; + uint8_t b = srcRgba[srcIdx + 2]; + + int dstIdx = (y * width + x) * 3; + dstRgb[dstIdx + 0] = r; + dstRgb[dstIdx + 1] = g; + dstRgb[dstIdx + 2] = b; +} + +extern "C" void launchRgbaToRgbFlip( + const uint8_t* srcRgba, + uint8_t* dstRgb, + int width, + int height, + cudaStream_t stream) +{ + dim3 block(16, 16); + dim3 grid((width + block.x - 1) / block.x, (height + block.y - 1) / block.y); + rgbaToRgbFlipKernel<<>>(srcRgba, dstRgb, width, height); +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp new file mode 100644 index 000000000..4490d7066 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp @@ -0,0 +1,1596 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//============================================================================= +// Vulkan Timestamped Renderer (VK_EXT_mesh_shader path). +// +// Port from the GL-based timestamped renderer to native Vulkan. Geometry is +// generated procedurally in task/mesh shaders. CUDA tensors are bridged in +// through platform-native Vulkan external memory: every SSBO that needs to +// receive CUDA writes is imported into CUDA, allowing scene/query writes into +// Vulkan buffers. Fixed-function color/depth rendering resolves visibility, +// then compute writes the result into a CUDA-visible SSBO mapped directly by +// PyTorch without a host or CUDA result copy. +//============================================================================= + +#include "ludus_vk.h" +#include "shaders_spv.h" // generated header with embedded SPIR-V byte arrays +#include +#include +#include +#include +#include + +// VK_CHECK / VK_DBG / ludus_vk_debug() are shared from vkutil.h (included via +// ludus_vk.h). + +// Vulkan requires every vkCmdPushConstants update to include all stages from +// each overlapping range in the pipeline layout. Graphics and compute share +// this one struct/range, so use one mask for both declaration and updates. +static constexpr VkShaderStageFlags kLudusPushConstantStages = + VK_SHADER_STAGE_TASK_BIT_EXT + | VK_SHADER_STAGE_MESH_BIT_EXT + | VK_SHADER_STAGE_FRAGMENT_BIT + | VK_SHADER_STAGE_COMPUTE_BIT; + +//============================================================================= +// SPIR-V Shader Module Creation +//============================================================================= + +static VkShaderModule createShaderModule(VkDevice device, const uint32_t* code, size_t bytes) +{ + VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; + ci.codeSize = bytes; + ci.pCode = code; + VkShaderModule module; + VK_CHECK(vkCreateShaderModule(device, &ci, nullptr, &module)); + return module; +} + +//============================================================================= +// Render Pass +//============================================================================= + +static VkRenderPass createTimestampedRenderPass( + VkDevice device, VkFormat depthFormat, VkSampleCountFlagBits samples) +{ + VkAttachmentDescription color = {}; + color.format = VK_FORMAT_R8G8B8A8_UNORM; + color.samples = samples; + color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + color.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + color.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + color.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + color.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + color.finalLayout = VK_IMAGE_LAYOUT_GENERAL; + + VkAttachmentDescription depth = {}; + depth.format = depthFormat; + depth.samples = samples; + depth.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + depth.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + depth.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + depth.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + depth.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + depth.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + + VkAttachmentReference colorRef = { + 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; + VkAttachmentReference depthRef = { + 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL}; + + VkSubpassDescription subpass = {}; + subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &colorRef; + subpass.pDepthStencilAttachment = &depthRef; + + VkSubpassDependency dep = {}; + dep.srcSubpass = VK_SUBPASS_EXTERNAL; + dep.dstSubpass = 0; + dep.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT + | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; + dep.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT + | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; + dep.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT + | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + + VkAttachmentDescription attachments[] = {color, depth}; + + VkRenderPassCreateInfo rpCI = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO}; + rpCI.attachmentCount = 2; + rpCI.pAttachments = attachments; + rpCI.subpassCount = 1; + rpCI.pSubpasses = &subpass; + rpCI.dependencyCount = 1; + rpCI.pDependencies = &dep; + + VkRenderPass renderPass; + VK_CHECK(vkCreateRenderPass(device, &rpCI, nullptr, &renderPass)); + return renderPass; +} + +//============================================================================= +// Descriptor Set Layout (14 inputs + compute output SSBO + color storage image) +//============================================================================= + +static VkDescriptorSetLayout createDescriptorSetLayout(VkDevice device) +{ + constexpr uint32_t kNumBindings = 16; + std::vector bindings; + for (uint32_t i = 0; i < kNumBindings; i++) { + VkDescriptorSetLayoutBinding b = {}; + b.binding = i; + b.descriptorType = + i == 15 ? VK_DESCRIPTOR_TYPE_STORAGE_IMAGE + : VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + b.descriptorCount = 1; + if (i >= 14) { + b.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + } else { + b.stageFlags = VK_SHADER_STAGE_TASK_BIT_EXT + | VK_SHADER_STAGE_MESH_BIT_EXT + | VK_SHADER_STAGE_FRAGMENT_BIT; + } + bindings.push_back(b); + } + + VkDescriptorSetLayoutCreateInfo ci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; + ci.bindingCount = (uint32_t)bindings.size(); + ci.pBindings = bindings.data(); + + VkDescriptorSetLayout layout; + VK_CHECK(vkCreateDescriptorSetLayout(device, &ci, nullptr, &layout)); + return layout; +} + +//============================================================================= +// Pipeline Layout +//============================================================================= + +static VkPipelineLayout createPipelineLayout(VkDevice device, VkDescriptorSetLayout dsLayout) +{ + VkPushConstantRange pushRange = {}; + pushRange.stageFlags = kLudusPushConstantStages; + pushRange.offset = 0; + pushRange.size = sizeof(LudusPushConstants); + + VkPipelineLayoutCreateInfo ci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; + ci.setLayoutCount = 1; + ci.pSetLayouts = &dsLayout; + ci.pushConstantRangeCount = 1; + ci.pPushConstantRanges = &pushRange; + + VkPipelineLayout layout; + VK_CHECK(vkCreatePipelineLayout(device, &ci, nullptr, &layout)); + return layout; +} + +//============================================================================= +// Mesh Pipeline (task + mesh + fragment) +//============================================================================= + +static VkPipeline createMeshPipeline( + VkDevice device, + VkPipelineLayout layout, + VkRenderPass renderPass, + VkShaderModule taskModule, + VkShaderModule meshModule, + VkShaderModule fragModule, + VkSampleCountFlagBits samples) +{ + std::vector stages; + + if (taskModule != VK_NULL_HANDLE) { + VkPipelineShaderStageCreateInfo taskStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; + taskStage.stage = VK_SHADER_STAGE_TASK_BIT_EXT; + taskStage.module = taskModule; + taskStage.pName = "main"; + stages.push_back(taskStage); + } + + VkPipelineShaderStageCreateInfo meshStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; + meshStage.stage = VK_SHADER_STAGE_MESH_BIT_EXT; + meshStage.module = meshModule; + meshStage.pName = "main"; + stages.push_back(meshStage); + + VkPipelineShaderStageCreateInfo fragStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; + fragStage.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + fragStage.module = fragModule; + fragStage.pName = "main"; + stages.push_back(fragStage); + + VkPipelineViewportStateCreateInfo viewportState = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO}; + viewportState.viewportCount = 1; + viewportState.scissorCount = 1; + + VkPipelineRasterizationStateCreateInfo rasterState = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO}; + rasterState.polygonMode = VK_POLYGON_MODE_FILL; + rasterState.cullMode = VK_CULL_MODE_NONE; + rasterState.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; + rasterState.lineWidth = 1.0f; + + VkPipelineMultisampleStateCreateInfo msaaState = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO}; + msaaState.rasterizationSamples = samples; + + VkPipelineDepthStencilStateCreateInfo depthState = {VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO}; + depthState.depthTestEnable = VK_TRUE; + depthState.depthWriteEnable = VK_TRUE; + depthState.depthCompareOp = VK_COMPARE_OP_LESS; + + VkPipelineColorBlendAttachmentState blendAttachment = {}; + blendAttachment.blendEnable = VK_FALSE; + blendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT + | VK_COLOR_COMPONENT_G_BIT + | VK_COLOR_COMPONENT_B_BIT + | VK_COLOR_COMPONENT_A_BIT; + VkPipelineColorBlendStateCreateInfo blendState = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO}; + blendState.attachmentCount = 1; + blendState.pAttachments = &blendAttachment; + + VkDynamicState dynamicStates[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + VkPipelineDynamicStateCreateInfo dynamicState = {VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO}; + dynamicState.dynamicStateCount = 2; + dynamicState.pDynamicStates = dynamicStates; + + VkGraphicsPipelineCreateInfo pipelineCI = {VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO}; + pipelineCI.stageCount = (uint32_t)stages.size(); + pipelineCI.pStages = stages.data(); + pipelineCI.pViewportState = &viewportState; + pipelineCI.pRasterizationState = &rasterState; + pipelineCI.pMultisampleState = &msaaState; + pipelineCI.pDepthStencilState = &depthState; + pipelineCI.pColorBlendState = &blendState; + pipelineCI.pDynamicState = &dynamicState; + pipelineCI.layout = layout; + pipelineCI.renderPass = renderPass; + pipelineCI.subpass = 0; + + VkPipeline pipeline; + VkResult r = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineCI, nullptr, &pipeline); + TORCH_CHECK(r == VK_SUCCESS, "vkCreateGraphicsPipelines failed for mesh pipeline: ", (int)r); + return pipeline; +} + +static VkPipeline createComputePipeline( + VkDevice device, VkPipelineLayout layout, VkShaderModule module) +{ + VkPipelineShaderStageCreateInfo stage = { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; + stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; + stage.module = module; + stage.pName = "main"; + + VkComputePipelineCreateInfo ci = { + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; + ci.stage = stage; + ci.layout = layout; + + VkPipeline pipeline = VK_NULL_HANDLE; + VK_CHECK(vkCreateComputePipelines( + device, VK_NULL_HANDLE, 1, &ci, nullptr, &pipeline)); + return pipeline; +} + +//============================================================================= +// Descriptor Set Update +//============================================================================= + +static void updateDescriptorSet(VkDevice device, VkDescriptorSet& ds, LudusTimestampedVkState& s) +{ + struct BufInfo { uint32_t binding; VkBuffer buffer; VkDeviceSize size; }; + BufInfo bufs[] = { + { 0, s.timestampsBuffer.buffer, s.timestampsBuffer.size}, + { 1, s.int32Buffer.buffer, s.int32Buffer.size}, + { 2, s.vertexBuffer.buffer, s.vertexBuffer.size}, + { 3, s.triangleBuffer.buffer, s.triangleBuffer.size}, + { 4, s.poseBuffer.buffer, s.poseBuffer.size}, + { 5, s.floatBuffer.buffer, s.floatBuffer.size}, + { 6, s.sceneBuffer.buffer, s.sceneBuffer.size}, + { 7, s.polylinePoolBuffer.buffer, s.polylinePoolBuffer.size}, + { 8, s.polygonPoolBuffer.buffer, s.polygonPoolBuffer.size}, + { 9, s.obstaclePoolBuffer.buffer, s.obstaclePoolBuffer.size}, + {10, s.colorPaletteBuffer.buffer, s.colorPaletteBuffer.size}, + {11, s.cameraIntrinsicsBuffer.buffer, s.cameraIntrinsicsBuffer.size}, + {12, s.cameraPoseBuffer.buffer, s.cameraPoseBuffer.size}, + {13, s.queryBuffer.buffer, s.queryBuffer.size}, + }; + + std::vector writes; + std::vector bufInfos(14); + + for (int i = 0; i < 14; i++) { + if (bufs[i].buffer == VK_NULL_HANDLE || bufs[i].size == 0) + continue; + + bufInfos[i].buffer = bufs[i].buffer; + bufInfos[i].offset = 0; + bufInfos[i].range = bufs[i].size; + + VkWriteDescriptorSet w = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}; + w.dstSet = ds; + w.dstBinding = bufs[i].binding; + w.descriptorCount = 1; + w.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + w.pBufferInfo = &bufInfos[i]; + writes.push_back(w); + } + + if (!writes.empty()) { + vkUpdateDescriptorSets(device, (uint32_t)writes.size(), writes.data(), 0, nullptr); + } +} + +static void updateAllInputDescriptorSets(LudusTimestampedVkState& s) +{ + for (uint32_t i = 0; i < VkContext::kFramesInFlight; ++i) + updateDescriptorSet(s.vkctx.device, s.descriptorSets[i], s); +} + +static void updateFrameOutputDescriptors( + VkDevice device, VkDescriptorSet ds, const VkExternalBuffer& output, + VkDeviceSize bytes, const VkExternalImage& colorImage) +{ + VkDescriptorBufferInfo info = {}; + info.buffer = output.buffer; + info.offset = 0; + info.range = bytes; + VkDescriptorImageInfo imageInfo = {}; + imageInfo.imageView = colorImage.imageView; + imageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL; + + VkWriteDescriptorSet writes[2] = {}; + writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writes[0].dstSet = ds; + writes[0].dstBinding = 14; + writes[0].descriptorCount = 1; + writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + writes[0].pBufferInfo = &info; + writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writes[1].dstSet = ds; + writes[1].dstBinding = 15; + writes[1].descriptorCount = 1; + writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + writes[1].pImageInfo = &imageInfo; + vkUpdateDescriptorSets(device, 2, writes, 0, nullptr); +} + +//============================================================================= +// Initialization +//============================================================================= + +void ludusTimestampedInitVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s, int cudaDeviceIdx) +{ + (void)nvdr_ctx; + memset(&s, 0, sizeof(s)); + + // cuImportExternalMemory and friends require a current CUDA context. + // Force the runtime to materialize a primary context on the requested + // device before any external-memory imports happen during init. + cudaSetDevice(cudaDeviceIdx); + cudaFree(nullptr); + + s.vkctx = createVkContext(cudaDeviceIdx); + s.hasMeshShader = s.vkctx.hasMeshShader ? 1 : 0; + + s.msaaSamples = 0; + s.tessellationThreshold = 1.0f; + s.maxTessellationLevelPolyline = 4; + s.maxTessellationLevelPolygon = 3; + s.maxTessellationLevelCube = 3; + s.depthScaling = 1.0f; + s.maxExtrapolationUs = 500000; + s.cullRadiusScale = 1.5f; + + s.renderPass = createTimestampedRenderPass( + s.vkctx.device, VK_FORMAT_D24_UNORM_S8_UINT, VK_SAMPLE_COUNT_1_BIT + ); + + s.descriptorSetLayout = createDescriptorSetLayout(s.vkctx.device); + s.pipelineLayout = createPipelineLayout(s.vkctx.device, s.descriptorSetLayout); + + VkDescriptorPoolSize poolSizes[2] = {}; + poolSizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + poolSizes[0].descriptorCount = 15 * VkContext::kFramesInFlight; + poolSizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + poolSizes[1].descriptorCount = VkContext::kFramesInFlight; + + VkDescriptorPoolCreateInfo poolCI = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO}; + poolCI.maxSets = VkContext::kFramesInFlight; + poolCI.poolSizeCount = 2; + poolCI.pPoolSizes = poolSizes; + VK_CHECK(vkCreateDescriptorPool(s.vkctx.device, &poolCI, nullptr, &s.descriptorPool)); + + VkDescriptorSetAllocateInfo dsAllocCI = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; + dsAllocCI.descriptorPool = s.descriptorPool; + VkDescriptorSetLayout layouts[VkContext::kFramesInFlight]; + for (uint32_t i = 0; i < VkContext::kFramesInFlight; ++i) + layouts[i] = s.descriptorSetLayout; + dsAllocCI.descriptorSetCount = VkContext::kFramesInFlight; + dsAllocCI.pSetLayouts = layouts; + VK_CHECK(vkAllocateDescriptorSets( + s.vkctx.device, &dsAllocCI, s.descriptorSets)); + + // Embedded SPIR-V (generated from shaders/*.spv at build time). + struct ShaderBin { const uint32_t* code; size_t bytes; }; + const ShaderBin bins[10] = { + {kSpv_ts_polyline_task, sizeof(kSpv_ts_polyline_task)}, + {kSpv_ts_polyline_mesh, sizeof(kSpv_ts_polyline_mesh)}, + {kSpv_ts_polyline_frag, sizeof(kSpv_ts_polyline_frag)}, + {kSpv_ts_polygon_task, sizeof(kSpv_ts_polygon_task)}, + {kSpv_ts_polygon_mesh, sizeof(kSpv_ts_polygon_mesh)}, + {kSpv_ts_polygon_frag, sizeof(kSpv_ts_polygon_frag)}, + {kSpv_ts_obstacle_task, sizeof(kSpv_ts_obstacle_task)}, + {kSpv_ts_obstacle_mesh, sizeof(kSpv_ts_obstacle_mesh)}, + {kSpv_ts_obstacle_frag, sizeof(kSpv_ts_obstacle_frag)}, + {kSpv_ts_export_comp, sizeof(kSpv_ts_export_comp)}, + }; + for (int i = 0; i < 10; i++) + s.shaderModules[i] = createShaderModule(s.vkctx.device, bins[i].code, bins[i].bytes); + + VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT; + s.pipelinePolyline = createMeshPipeline(s.vkctx.device, s.pipelineLayout, s.renderPass, + s.shaderModules[0], s.shaderModules[1], s.shaderModules[2], samples); + s.pipelinePolygon = createMeshPipeline(s.vkctx.device, s.pipelineLayout, s.renderPass, + s.shaderModules[3], s.shaderModules[4], s.shaderModules[5], samples); + s.pipelineObstacle = createMeshPipeline(s.vkctx.device, s.pipelineLayout, s.renderPass, + s.shaderModules[6], s.shaderModules[7], s.shaderModules[8], samples); + s.pipelineExport = createComputePipeline( + s.vkctx.device, s.pipelineLayout, s.shaderModules[9]); + s.renderPassSamples = 1; // render pass + pipelines built single-sample above + + // Dummy buffers so every descriptor binding has a valid buffer before + // the first upload_scene call. Placeholders are deliberately not exported; + // the first real upload grows/upgrades only the required buffers and then + // performs their one-time Vulkan->external ownership release. + VkDeviceSize dummySize = 256; + VkBufferUsageFlags ssboUsage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; + auto makeDummy = [&](VkExternalBuffer& buf, bool needsCuda = false) { + if (buf.buffer == VK_NULL_HANDLE) + buf = createExternalBuffer(s.vkctx, dummySize, ssboUsage, needsCuda); + }; + makeDummy(s.timestampsBuffer); + makeDummy(s.int32Buffer); + makeDummy(s.vertexBuffer); + makeDummy(s.triangleBuffer); + makeDummy(s.poseBuffer); + makeDummy(s.floatBuffer); + // Scene buffer: smaller dummy so uploadScene always creates a larger one + s.sceneBuffer = createExternalBuffer(s.vkctx, 64, ssboUsage, false); + makeDummy(s.polylinePoolBuffer); + makeDummy(s.polygonPoolBuffer); + makeDummy(s.obstaclePoolBuffer); + makeDummy(s.colorPaletteBuffer); + makeDummy(s.cameraIntrinsicsBuffer); + makeDummy(s.cameraPoseBuffer); + makeDummy(s.queryBuffer); + updateAllInputDescriptorSets(s); + + cudaStreamCreate(&s.copyStream); + for (int i = 0; i < 2; i++) { + cudaEventCreateWithFlags(&s.stagingReadyEvent[i], cudaEventDisableTiming); + cudaEventCreateWithFlags(&s.pinnedReadyEvent[i], cudaEventDisableTiming); + } + + VK_DBG("[Vulkan] Timestamped renderer initialized\n"); +} + +//============================================================================= +// Buffer Resize Helpers +//============================================================================= + +static const VkBufferUsageFlags SSBO_USAGE = + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; + +static void synchronizeForResourceMutation( + LudusTimestampedVkState& s, cudaStream_t stream) +{ + // Buffer/image handle replacement is a control-plane operation. Drain the + // last shared-memory consumer on this stream, then wait for Vulkan before + // destroying handles. This path runs only on capacity/resolution changes; + // steady-state rendering remains fully GPU ordered. + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + cudaError_t syncError = cudaStreamSynchronize(stream); + TORCH_CHECK(syncError == cudaSuccess, + "cudaStreamSynchronize during Vulkan resource mutation failed: ", + (int)syncError); + VK_CHECK(vkDeviceWaitIdle(s.vkctx.device)); +} + +static bool externalBufferNeedsResize( + const VkExternalBuffer& buffer, VkDeviceSize size) +{ + return size > 0 && + (buffer.buffer == VK_NULL_HANDLE || buffer.size < size || buffer.cuDevPtr == 0); +} + +static void releaseNewExternalBuffersToCuda( + LudusTimestampedVkState& s, + const std::vector& buffers) +{ + if (buffers.empty()) return; + VkCommandBuffer cmd = beginSingleTimeCommands(s.vkctx); + std::vector barriers; + for (VkExternalBuffer* buffer : buffers) { + if (!buffer || buffer->buffer == VK_NULL_HANDLE || !buffer->cuExtMem) + continue; + VkBufferMemoryBarrier release = { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER}; + release.srcAccessMask = 0; + release.dstAccessMask = 0; + release.srcQueueFamilyIndex = s.vkctx.graphicsQueueFamily; + release.dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL; + release.buffer = buffer->buffer; + release.offset = 0; + release.size = VK_WHOLE_SIZE; + barriers.push_back(release); + } + vkCmdPipelineBarrier(cmd, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + 0, 0, nullptr, (uint32_t)barriers.size(), barriers.data(), 0, nullptr); + endSingleTimeCommands(s.vkctx, cmd); +} + +struct PendingSharedBufferGrowth +{ + VkExternalBuffer* slot; + VkExternalBuffer previous; + VkDeviceSize preserveBytes; +}; + +static int growCapacityGeometrically(int capacity, int needed) +{ + if (needed <= capacity) return capacity; + int grown = std::max(1, capacity); + while (grown < needed && grown <= INT_MAX / 2) grown *= 2; + return std::max(grown, needed); +} + +static void queueSharedBufferGrowth( + LudusTimestampedVkState& s, + VkExternalBuffer& buffer, + VkDeviceSize targetBytes, + VkDeviceSize preserveBytes, + std::vector& pending) +{ + if (targetBytes == 0) return; + const bool needsCudaUpgrade = buffer.cuDevPtr == 0; + const bool needsGrowth = + buffer.buffer == VK_NULL_HANDLE || buffer.size < targetBytes; + if (!needsCudaUpgrade && !needsGrowth) return; + + PendingSharedBufferGrowth growth = {}; + growth.slot = &buffer; + growth.previous = buffer; + growth.preserveBytes = preserveBytes; + buffer = createExternalBuffer( + s.vkctx, std::max(targetBytes, growth.previous.size), SSBO_USAGE, true); + pending.push_back(growth); +} + +static void finishSharedBufferGrowth( + LudusTimestampedVkState& s, + cudaStream_t stream, + std::vector& pending) +{ + if (pending.empty()) return; + + std::vector replacements; + replacements.reserve(pending.size()); + for (PendingSharedBufferGrowth& growth : pending) + replacements.push_back(growth.slot); + releaseNewExternalBuffersToCuda(s, replacements); + + bool copied = false; + for (PendingSharedBufferGrowth& growth : pending) { + if (growth.preserveBytes == 0) continue; + TORCH_CHECK(growth.previous.cuDevPtr != 0, + "cannot preserve a Vulkan shared buffer without an old CUDA mapping"); + TORCH_CHECK(growth.preserveBytes <= growth.previous.size, + "preserved Vulkan buffer range exceeds the old allocation"); + cudaError_t error = cudaMemcpyAsync( + (void*)growth.slot->cuDevPtr, + (const void*)growth.previous.cuDevPtr, + (size_t)growth.preserveBytes, + cudaMemcpyDeviceToDevice, + stream); + TORCH_CHECK(error == cudaSuccess, + "cudaMemcpyAsync while preserving Vulkan buffer growth failed: ", + (int)error); + copied = true; + } + + // Growth is a rare control-plane operation. The old external allocations + // cannot be destroyed until their stream-ordered preservation copies end. + if (copied) { + cudaError_t error = cudaStreamSynchronize(stream); + TORCH_CHECK(error == cudaSuccess, + "cudaStreamSynchronize after preserving Vulkan buffers failed: ", + (int)error); + } + for (PendingSharedBufferGrowth& growth : pending) + destroyExternalBuffer(s.vkctx, growth.previous); +} + +// Rebuild the render pass + pipelines for a new sample count (their attachment +// layout and rasterizationSamples are fixed at creation). Caller must be idle. +static void rebuildRenderPassAndPipelines(LudusTimestampedVkState& s, VkSampleCountFlagBits samples) +{ + if (s.pipelinePolyline) { vkDestroyPipeline(s.vkctx.device, s.pipelinePolyline, nullptr); s.pipelinePolyline = VK_NULL_HANDLE; } + if (s.pipelinePolygon) { vkDestroyPipeline(s.vkctx.device, s.pipelinePolygon, nullptr); s.pipelinePolygon = VK_NULL_HANDLE; } + if (s.pipelineObstacle) { vkDestroyPipeline(s.vkctx.device, s.pipelineObstacle, nullptr); s.pipelineObstacle = VK_NULL_HANDLE; } + if (s.renderPass) { vkDestroyRenderPass(s.vkctx.device, s.renderPass, nullptr); s.renderPass = VK_NULL_HANDLE; } + + s.renderPass = createTimestampedRenderPass( + s.vkctx.device, VK_FORMAT_D24_UNORM_S8_UINT, samples); + + s.pipelinePolyline = createMeshPipeline(s.vkctx.device, s.pipelineLayout, s.renderPass, + s.shaderModules[0], s.shaderModules[1], s.shaderModules[2], samples); + s.pipelinePolygon = createMeshPipeline(s.vkctx.device, s.pipelineLayout, s.renderPass, + s.shaderModules[3], s.shaderModules[4], s.shaderModules[5], samples); + s.pipelineObstacle = createMeshPipeline(s.vkctx.device, s.pipelineLayout, s.renderPass, + s.shaderModules[6], s.shaderModules[7], s.shaderModules[8], samples); + + s.renderPassSamples = (samples == VK_SAMPLE_COUNT_1_BIT) ? 1 : (int)samples; +} + +static void destroyRenderTarget( + LudusTimestampedVkState& s, LudusVkRenderTarget& target) +{ + if (target.framebuffer) + vkDestroyFramebuffer(s.vkctx.device, target.framebuffer, nullptr); + destroyExternalImage(s.vkctx, target.colorImage); + destroyExternalImage(s.vkctx, target.depthStencilImage); + memset(&target, 0, sizeof(target)); +} + +static void destroyRenderTargets(LudusTimestampedVkState& s) +{ + for (int i = 0; i < s.numRenderTargets; ++i) + destroyRenderTarget(s, s.renderTargets[i]); + s.numRenderTargets = 0; + s.activeRenderTarget = -1; +} + +static void ensureFramebuffer( + LudusTimestampedVkState& s, + cudaStream_t stream, + int width, + int height, + int layers) +{ + int desiredSamplesInt = (s.msaaSamples > 1) ? s.msaaSamples : 1; + for (int i = 0; i < s.numRenderTargets; ++i) { + const LudusVkRenderTarget& target = s.renderTargets[i]; + if (target.width == width && target.height == height && + target.samples == desiredSamplesInt && target.maxLayers >= layers) { + s.activeRenderTarget = i; + return; + } + } + + synchronizeForResourceMutation(s, stream); + if (s.renderPassSamples != desiredSamplesInt) { + destroyRenderTargets(s); + rebuildRenderPassAndPipelines( + s, (VkSampleCountFlagBits)desiredSamplesInt); + } + + int targetIndex = -1; + for (int i = 0; i < s.numRenderTargets; ++i) { + if (s.renderTargets[i].width == width && + s.renderTargets[i].height == height) { + targetIndex = i; + destroyRenderTarget(s, s.renderTargets[i]); + break; + } + } + if (targetIndex < 0) { + if (s.numRenderTargets < LUDUS_VK_RENDER_TARGET_CACHE_SIZE) { + targetIndex = s.numRenderTargets++; + } else { + targetIndex = 0; + destroyRenderTarget(s, s.renderTargets[targetIndex]); + } + } + + LudusVkRenderTarget& target = s.renderTargets[targetIndex]; + target.width = width; + target.height = height; + target.maxLayers = layers; + target.samples = desiredSamplesInt; + target.colorImage = createExternalImage(s.vkctx, width, height, layers, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT, + (VkSampleCountFlagBits)desiredSamplesInt); + target.depthStencilImage = createExternalImage(s.vkctx, width, height, layers, + VK_FORMAT_D24_UNORM_S8_UINT, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + (VkSampleCountFlagBits)desiredSamplesInt); + + VkFramebufferCreateInfo fbCI = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO}; + fbCI.renderPass = s.renderPass; + VkImageView attachments[] = { + target.colorImage.imageView, + target.depthStencilImage.imageView, + }; + fbCI.attachmentCount = 2; + fbCI.pAttachments = attachments; + fbCI.width = width; + fbCI.height = height; + fbCI.layers = layers; + VK_CHECK(vkCreateFramebuffer( + s.vkctx.device, &fbCI, nullptr, &target.framebuffer)); + s.activeRenderTarget = targetIndex; + + // CUDA staging is optional and allocated lazily only by the legacy + // staging/JPEG API. Interactive drive reuses this cached color/depth target. +} + +//============================================================================= +// Scene Upload +//============================================================================= + +void ludusUploadCamerasVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const FThetaCamera* intrinsics, int numCameras) +{ + (void)nvdr_ctx; + if (numCameras > s.cameraCapacity) { + synchronizeForResourceMutation(s, stream); + s.cameraCapacity = numCameras; + resizeExternalBuffer(s.vkctx, s.cameraIntrinsicsBuffer, + numCameras * sizeof(FThetaCamera), SSBO_USAGE, true); + releaseNewExternalBuffersToCuda(s, {&s.cameraIntrinsicsBuffer}); + updateAllInputDescriptorSets(s); + } else { + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + } + s.numCameras = numCameras; + + cudaMemcpyAsync((void*)s.cameraIntrinsicsBuffer.cuDevPtr, intrinsics, + numCameras * sizeof(FThetaCamera), cudaMemcpyDeviceToDevice, stream); + s.sceneBuffersDirty = 1; +} + +void ludusUploadColorPaletteVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const float* colors, int numColors) +{ + (void)nvdr_ctx; + VkDeviceSize size = numColors * 4 * sizeof(float); + if (externalBufferNeedsResize(s.colorPaletteBuffer, size)) { + synchronizeForResourceMutation(s, stream); + resizeExternalBuffer(s.vkctx, s.colorPaletteBuffer, size, SSBO_USAGE, true); + releaseNewExternalBuffersToCuda(s, {&s.colorPaletteBuffer}); + updateAllInputDescriptorSets(s); + } else { + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + } + cudaMemcpyAsync((void*)s.colorPaletteBuffer.cuDevPtr, colors, size, + cudaMemcpyDeviceToDevice, stream); + s.colorPaletteSize = numColors; + s.sceneBuffersDirty = 1; +} + +int ludusUploadSceneVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const TimestampedScene* sceneDesc, + const TimestampedPolylinePool* polylinePools, int numPolylinePools, + const TimestampedPolygonPool* polygonPools, int numPolygonPools, + const ObstaclePool* obstaclePools, int numObstaclePools, + int maxObstaclesInPool, + int maxVarraysPerTsPolyline, int maxVarraysPerTsPolygon, + const int64_t* timestamps, int numTimestamps, + const int32_t* int32Data, int numInt32, + const Vertex* vertices, int numVertices, + const Triangle* triangles, int numTriangles, + const CameraPose* poses, int numPoses, + const float* floatData, int numFloats) +{ + (void)nvdr_ctx; + int sceneId = s.numScenes++; + + s.timestampsCapacity = growCapacityGeometrically( + s.timestampsCapacity, s.timestampsUsed + numTimestamps); + s.int32Capacity = growCapacityGeometrically( + s.int32Capacity, s.int32Used + numInt32); + s.vertexCapacity = growCapacityGeometrically( + s.vertexCapacity, s.vertexUsed + numVertices); + s.triangleCapacity = growCapacityGeometrically( + s.triangleCapacity, s.triangleUsed + numTriangles); + s.poseCapacity = growCapacityGeometrically( + s.poseCapacity, s.poseUsed + numPoses); + s.floatCapacity = growCapacityGeometrically( + s.floatCapacity, s.floatUsed + numFloats); + s.polylinePoolCapacity = growCapacityGeometrically( + s.polylinePoolCapacity, s.polylinePoolUsed + numPolylinePools); + s.polygonPoolCapacity = growCapacityGeometrically( + s.polygonPoolCapacity, s.polygonPoolUsed + numPolygonPools); + s.obstaclePoolCapacity = growCapacityGeometrically( + s.obstaclePoolCapacity, s.obstaclePoolUsed + numObstaclePools); + s.maxObstaclesPerPool = std::max(s.maxObstaclesPerPool, maxObstaclesInPool); + s.maxPolylinePoolsPerScene = std::max(s.maxPolylinePoolsPerScene, numPolylinePools); + s.maxPolygonPoolsPerScene = std::max(s.maxPolygonPoolsPerScene, numPolygonPools); + s.maxCubePoolsPerScene = std::max(s.maxCubePoolsPerScene, numObstaclePools); + s.maxVarraysPerTsPolyline = std::max(s.maxVarraysPerTsPolyline, maxVarraysPerTsPolyline); + s.maxVarraysPerTsPolygon = std::max(s.maxVarraysPerTsPolygon, maxVarraysPerTsPolygon); + + int sceneCapNeeded = sceneId + 1; + const bool sceneBufferNeedsResize = sceneCapNeeded > s.maxScenes; + const bool dataBuffersNeedResize = + externalBufferNeedsResize(s.timestampsBuffer, + (VkDeviceSize)s.timestampsCapacity * sizeof(int64_t)) || + externalBufferNeedsResize(s.int32Buffer, + (VkDeviceSize)s.int32Capacity * sizeof(int32_t)) || + externalBufferNeedsResize(s.vertexBuffer, + (VkDeviceSize)s.vertexCapacity * sizeof(Vertex)) || + externalBufferNeedsResize(s.triangleBuffer, + (VkDeviceSize)s.triangleCapacity * sizeof(Triangle)) || + externalBufferNeedsResize(s.poseBuffer, + (VkDeviceSize)s.poseCapacity * sizeof(CameraPose)) || + externalBufferNeedsResize(s.floatBuffer, + (VkDeviceSize)s.floatCapacity * sizeof(float)) || + externalBufferNeedsResize(s.polylinePoolBuffer, + (VkDeviceSize)s.polylinePoolCapacity * sizeof(TimestampedPolylinePool)) || + externalBufferNeedsResize(s.polygonPoolBuffer, + (VkDeviceSize)s.polygonPoolCapacity * sizeof(TimestampedPolygonPool)) || + externalBufferNeedsResize(s.obstaclePoolBuffer, + (VkDeviceSize)s.obstaclePoolCapacity * sizeof(ObstaclePool)); + if (sceneBufferNeedsResize || dataBuffersNeedResize) { + synchronizeForResourceMutation(s, stream); + } else { + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + } + + std::vector pendingGrowth; + pendingGrowth.reserve(10); + if (sceneBufferNeedsResize) { + s.maxScenes = growCapacityGeometrically(s.maxScenes, sceneCapNeeded); + queueSharedBufferGrowth( + s, s.sceneBuffer, + (VkDeviceSize)s.maxScenes * sizeof(TimestampedScene), + (VkDeviceSize)sceneId * sizeof(TimestampedScene), + pendingGrowth); + } + queueSharedBufferGrowth(s, s.timestampsBuffer, + (VkDeviceSize)s.timestampsCapacity * sizeof(int64_t), + (VkDeviceSize)s.timestampsUsed * sizeof(int64_t), pendingGrowth); + queueSharedBufferGrowth(s, s.int32Buffer, + (VkDeviceSize)s.int32Capacity * sizeof(int32_t), + (VkDeviceSize)s.int32Used * sizeof(int32_t), pendingGrowth); + queueSharedBufferGrowth(s, s.vertexBuffer, + (VkDeviceSize)s.vertexCapacity * sizeof(Vertex), + (VkDeviceSize)s.vertexUsed * sizeof(Vertex), pendingGrowth); + queueSharedBufferGrowth(s, s.triangleBuffer, + (VkDeviceSize)s.triangleCapacity * sizeof(Triangle), + (VkDeviceSize)s.triangleUsed * sizeof(Triangle), pendingGrowth); + queueSharedBufferGrowth(s, s.poseBuffer, + (VkDeviceSize)s.poseCapacity * sizeof(CameraPose), + (VkDeviceSize)s.poseUsed * sizeof(CameraPose), pendingGrowth); + queueSharedBufferGrowth(s, s.floatBuffer, + (VkDeviceSize)s.floatCapacity * sizeof(float), + (VkDeviceSize)s.floatUsed * sizeof(float), pendingGrowth); + queueSharedBufferGrowth(s, s.polylinePoolBuffer, + (VkDeviceSize)s.polylinePoolCapacity * sizeof(TimestampedPolylinePool), + (VkDeviceSize)s.polylinePoolUsed * sizeof(TimestampedPolylinePool), + pendingGrowth); + queueSharedBufferGrowth(s, s.polygonPoolBuffer, + (VkDeviceSize)s.polygonPoolCapacity * sizeof(TimestampedPolygonPool), + (VkDeviceSize)s.polygonPoolUsed * sizeof(TimestampedPolygonPool), + pendingGrowth); + queueSharedBufferGrowth(s, s.obstaclePoolBuffer, + (VkDeviceSize)s.obstaclePoolCapacity * sizeof(ObstaclePool), + (VkDeviceSize)s.obstaclePoolUsed * sizeof(ObstaclePool), pendingGrowth); + if (!pendingGrowth.empty()) { + finishSharedBufferGrowth(s, stream, pendingGrowth); + updateAllInputDescriptorSets(s); + } + + auto copyAppend = [&](VkExternalBuffer& buf, const void* data, int count, size_t elemSize, + int& used, const char* tag) { + if (count > 0 && data) { + TORCH_CHECK(buf.cuDevPtr != 0, + "upload_scene: buffer ", tag, " has no CUDA pointer (cudaImportable not set?)"); + size_t dstOff = (size_t)used * elemSize; + size_t bytes = (size_t)count * elemSize; + CUdeviceptr dst = buf.cuDevPtr + dstOff; + cudaError_t e = cudaMemcpyAsync((void*)dst, data, bytes, + cudaMemcpyDeviceToDevice, stream); + TORCH_CHECK(e == cudaSuccess, "upload_scene: cudaMemcpyAsync ", tag, + " failed: ", (int)e); + VK_DBG("[Vulkan] upload %6s: count=%d bytes=%zu\n", tag, count, bytes); + } + int offset = used; + used += count; + return offset; + }; + + copyAppend(s.timestampsBuffer, timestamps, numTimestamps, sizeof(int64_t), s.timestampsUsed, "ts"); + copyAppend(s.int32Buffer, int32Data, numInt32, sizeof(int32_t), s.int32Used, "i32"); + copyAppend(s.vertexBuffer, vertices, numVertices, sizeof(Vertex), s.vertexUsed, "vert"); + copyAppend(s.triangleBuffer, triangles, numTriangles, sizeof(Triangle), s.triangleUsed, "tri"); + copyAppend(s.poseBuffer, poses, numPoses, sizeof(CameraPose), s.poseUsed, "pose"); + copyAppend(s.floatBuffer, floatData, numFloats, sizeof(float), s.floatUsed, "flt"); + copyAppend(s.polylinePoolBuffer, polylinePools, numPolylinePools, sizeof(TimestampedPolylinePool), s.polylinePoolUsed, "pl"); + copyAppend(s.polygonPoolBuffer, polygonPools, numPolygonPools, sizeof(TimestampedPolygonPool), s.polygonPoolUsed, "pg"); + copyAppend(s.obstaclePoolBuffer, obstaclePools, numObstaclePools, sizeof(ObstaclePool), s.obstaclePoolUsed, "obs"); + + TORCH_CHECK(s.sceneBuffer.cuDevPtr != 0, + "upload_scene: sceneBuffer has no CUDA pointer (cudaImportable not set?)"); + cudaError_t e_scene = cudaMemcpyAsync( + (void*)(s.sceneBuffer.cuDevPtr + sceneId * sizeof(TimestampedScene)), + sceneDesc, sizeof(TimestampedScene), cudaMemcpyDeviceToDevice, stream); + TORCH_CHECK(e_scene == cudaSuccess, + "upload_scene: cudaMemcpyAsync (scene desc) failed: ", (int)e_scene); + + s.sceneBuffersDirty = 1; + return sceneId; +} + +void ludusUpdateCubePoolVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + int absolutePoolIndex, + int timestampOffset, int trackTimestampOffset, int int32Offset, + int translationOffset, int quaternionOffset, int scaleOffset, int colorOffset, + const int64_t* timestamps, int numTimestamps, + const int64_t* trackTimestamps, int numTrackTimestamps, + const int32_t* prefixSum, int numCubes, + const float* translations, int numTranslationFloats, + const float* quaternions, int numQuaternionFloats, + const float* scales, int numScaleFloats, + const float* colors, int numColorFloats, + const ObstaclePool* poolHeader) +{ + (void)nvdr_ctx; + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + auto copyAt = [&](VkExternalBuffer& buffer, size_t elementOffset, + const void* source, size_t bytes, const char* tag) { + if (bytes == 0) return; + TORCH_CHECK(buffer.cuDevPtr != 0, + "update_cube_pool: shared buffer ", tag, " has no CUDA mapping"); + cudaError_t error = cudaMemcpyAsync( + (void*)(buffer.cuDevPtr + elementOffset), source, bytes, + cudaMemcpyDeviceToDevice, stream); + TORCH_CHECK(error == cudaSuccess, + "update_cube_pool: cudaMemcpyAsync ", tag, " failed: ", (int)error); + }; + + copyAt(s.timestampsBuffer, (size_t)timestampOffset * sizeof(int64_t), + timestamps, (size_t)numTimestamps * sizeof(int64_t), "timestamps"); + copyAt(s.timestampsBuffer, (size_t)trackTimestampOffset * sizeof(int64_t), + trackTimestamps, (size_t)numTrackTimestamps * sizeof(int64_t), + "track timestamps"); + copyAt(s.int32Buffer, (size_t)int32Offset * sizeof(int32_t), + prefixSum, (size_t)numCubes * sizeof(int32_t), "prefix sum"); + copyAt(s.floatBuffer, (size_t)translationOffset * sizeof(float), + translations, (size_t)numTranslationFloats * sizeof(float), "translations"); + copyAt(s.floatBuffer, (size_t)quaternionOffset * sizeof(float), + quaternions, (size_t)numQuaternionFloats * sizeof(float), "quaternions"); + copyAt(s.floatBuffer, (size_t)scaleOffset * sizeof(float), + scales, (size_t)numScaleFloats * sizeof(float), "scales"); + copyAt(s.floatBuffer, (size_t)colorOffset * sizeof(float), + colors, (size_t)numColorFloats * sizeof(float), "colors"); + copyAt(s.obstaclePoolBuffer, + (size_t)absolutePoolIndex * sizeof(ObstaclePool), + poolHeader, sizeof(ObstaclePool), "pool header"); +} + +void ludusRemoveSceneVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s, int sceneId, cudaStream_t stream) +{ + (void)nvdr_ctx; + // Tombstone with a stream-ordered memset; no host lifetime or CPU wait. + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + cudaError_t e = cudaMemsetAsync( + (void*)(s.sceneBuffer.cuDevPtr + sceneId * sizeof(TimestampedScene)), + 0, sizeof(int), stream); + TORCH_CHECK(e == cudaSuccess, "remove_scene: cudaMemsetAsync (tombstone) failed: ", (int)e); + s.sceneBuffersDirty = 1; +} + +//============================================================================= +// Render Batch +//============================================================================= + +void ludusRenderBatchVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const RenderQuery* queries, const CameraPose* cameraPoses, + int numQueries, int width, int height, int outputSlot) +{ + (void)nvdr_ctx; + if (numQueries <= 0) return; + TORCH_CHECK(outputSlot >= 0 && outputSlot < LUDUS_VK_OUTPUT_SLOTS, + "invalid Vulkan output slot ", outputSlot); + + VK_DBG("[Vulkan] renderBatch: nq=%d size=%dx%d\n", numQueries, width, height); + + ensureFramebuffer(s, stream, width, height, numQueries); + + if (numQueries > s.queryCapacity) { + synchronizeForResourceMutation(s, stream); + s.queryCapacity = numQueries; + resizeExternalBuffer(s.vkctx, s.queryBuffer, + numQueries * sizeof(RenderQuery), SSBO_USAGE, true); + resizeExternalBuffer(s.vkctx, s.cameraPoseBuffer, + numQueries * sizeof(CameraPose), SSBO_USAGE, true); + releaseNewExternalBuffersToCuda( + s, {&s.queryBuffer, &s.cameraPoseBuffer}); + updateAllInputDescriptorSets(s); + } + + const size_t totalSize = (size_t)width * height * 4 * numQueries; + VkExternalBuffer& outputBuffer = s.outputBuffers[outputSlot]; + if (externalBufferNeedsResize(outputBuffer, totalSize)) { + synchronizeForResourceMutation(s, stream); + resizeExternalBuffer(s.vkctx, outputBuffer, totalSize, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + true); + // Fresh allocations start in Vulkan ownership. Reused output slots + // were released to CUDA by their previous render submission. + s.outputReleasedToCuda[outputSlot] = 0; + } + s.activeOutputSlot = outputSlot; + s.activeOutputSize = totalSize; + + // A single stream-ordered timeline signal publishes CUDA-written inputs + // and releases a reused output lease to Vulkan. No host wait is involved. + cudaError_t e1 = cudaMemcpyAsync((void*)s.queryBuffer.cuDevPtr, queries, + numQueries * sizeof(RenderQuery), cudaMemcpyDeviceToDevice, stream); + cudaError_t e2 = cudaMemcpyAsync((void*)s.cameraPoseBuffer.cuDevPtr, cameraPoses, + numQueries * sizeof(CameraPose), cudaMemcpyDeviceToDevice, stream); + TORCH_CHECK(e1 == cudaSuccess, "renderBatch: cudaMemcpyAsync (queries) failed: ", (int)e1); + TORCH_CHECK(e2 == cudaSuccess, "renderBatch: cudaMemcpyAsync (poses) failed: ", (int)e2); + + const uint64_t cudaReadyValue = + signalInteropTimelineFromCuda(s.vkctx, stream); + + // Rotate command buffers. A host fence wait occurs only if the CPU gets + // three submissions ahead; there is no steady-state per-frame fence wait. + const uint32_t frameSlot = + s.vkctx.frameCursor++ % VkContext::kFramesInFlight; + VkFence frameFence = s.vkctx.fences[frameSlot]; + VkResult fenceStatus = vkGetFenceStatus(s.vkctx.device, frameFence); + if (fenceStatus == VK_NOT_READY) { + VK_CHECK(vkWaitForFences( + s.vkctx.device, 1, &frameFence, VK_TRUE, UINT64_MAX)); + } else { + TORCH_CHECK(fenceStatus == VK_SUCCESS, + "vkGetFenceStatus failed with VkResult ", (int)fenceStatus); + } + VK_CHECK(vkResetFences(s.vkctx.device, 1, &frameFence)); + VkDescriptorSet descriptorSet = s.descriptorSets[frameSlot]; + // This frame slot's fence guarantees its descriptor set is no longer in + // use. Point compute bindings at the leased output and cached color image + // without touching the other in-flight sets. + LudusVkRenderTarget& renderTarget = + s.renderTargets[s.activeRenderTarget]; + updateFrameOutputDescriptors( + s.vkctx.device, descriptorSet, outputBuffer, totalSize, + renderTarget.colorImage); + VkCommandBuffer cmd = s.vkctx.commandBuffers[frameSlot]; + VK_CHECK(vkResetCommandBuffer(cmd, 0)); + VkCommandBufferBeginInfo beginCI = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; + beginCI.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + VK_CHECK(vkBeginCommandBuffer(cmd, &beginCI)); + + // Queue family ownership acquire from VK_QUEUE_FAMILY_EXTERNAL. + // CUDA writes happen on an external queue family; this barrier transfers + // ownership to the graphics queue and makes the writes visible to shaders. + { + std::vector bufBarriers; + auto addBarrier = [&](VkExternalBuffer& buf, VkAccessFlags dstAccess) { + if (buf.buffer == VK_NULL_HANDLE || buf.size == 0 || !buf.cuExtMem) return; + VkBufferMemoryBarrier b = {VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER}; + b.srcAccessMask = 0; + b.dstAccessMask = dstAccess; + b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL; + b.dstQueueFamilyIndex = s.vkctx.graphicsQueueFamily; + b.buffer = buf.buffer; + b.offset = 0; + b.size = VK_WHOLE_SIZE; + bufBarriers.push_back(b); + }; + addBarrier(s.timestampsBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.int32Buffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.vertexBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.triangleBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.poseBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.floatBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.sceneBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.polylinePoolBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.polygonPoolBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.obstaclePoolBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.colorPaletteBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.cameraIntrinsicsBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.cameraPoseBuffer, VK_ACCESS_SHADER_READ_BIT); + addBarrier(s.queryBuffer, VK_ACCESS_SHADER_READ_BIT); + if (s.outputReleasedToCuda[outputSlot]) { + addBarrier(outputBuffer, VK_ACCESS_SHADER_WRITE_BIT); + } else { + VkBufferMemoryBarrier initialOutput = { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER}; + initialOutput.srcAccessMask = 0; + initialOutput.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + initialOutput.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + initialOutput.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + initialOutput.buffer = outputBuffer.buffer; + initialOutput.offset = 0; + initialOutput.size = VK_WHOLE_SIZE; + bufBarriers.push_back(initialOutput); + } + + if (!bufBarriers.empty()) { + vkCmdPipelineBarrier(cmd, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT + | VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT + | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT + | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + 0, 0, nullptr, + (uint32_t)bufBarriers.size(), bufBarriers.data(), + 0, nullptr); + } + } + + VkClearValue clearValues[2] = {}; + clearValues[0].color = {{0.0f, 0.0f, 0.0f, 0.0f}}; + clearValues[1].depthStencil = {1.0f, 0}; + + VkRenderPassBeginInfo rpBegin = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO}; + rpBegin.renderPass = s.renderPass; + rpBegin.framebuffer = renderTarget.framebuffer; + rpBegin.renderArea = {{0, 0}, {(uint32_t)width, (uint32_t)height}}; + rpBegin.clearValueCount = 2; + rpBegin.pClearValues = clearValues; + vkCmdBeginRenderPass(cmd, &rpBegin, VK_SUBPASS_CONTENTS_INLINE); + + // Y-flip viewport: shaders use OpenGL-style NDC (+Y up); Vulkan framebuffer + // origin is top-left. Negative height inverts Y so the math stays GL-style. + VkViewport viewport = {0, (float)height, (float)width, -(float)height, 0.0f, 1.0f}; + vkCmdSetViewport(cmd, 0, 1, &viewport); + VkRect2D scissor = {{0, 0}, {(uint32_t)width, (uint32_t)height}}; + vkCmdSetScissor(cmd, 0, 1, &scissor); + + vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, + s.pipelineLayout, 0, 1, &descriptorSet, 0, nullptr); + + LudusPushConstants pc = {}; + pc.u_width_polyline_regular = s.widthPolylineRegular > 0 ? s.widthPolylineRegular : 7.0f; + pc.u_width_polyline_bev = s.widthPolylineBev > 0 ? s.widthPolylineBev : 4.0f; + pc.u_width_ego_traj_regular = s.widthEgoTrajRegular > 0 ? s.widthEgoTrajRegular : 12.0f; + pc.u_width_ego_traj_bev = s.widthEgoTrajBev > 0 ? s.widthEgoTrajBev : 5.0f; + pc.u_width_wireframe = s.widthWireframe > 0 ? s.widthWireframe : 2.0f; + pc.u_resolution_scale = s.resolutionScale > 0 ? s.resolutionScale : 1.0f; + pc.u_depth_scaling = s.depthScaling; + pc.u_max_extrapolation_us = s.maxExtrapolationUs; + pc.u_color_palette_size = s.colorPaletteSize; + pc.u_num_queries = numQueries; + pc.u_tessellation_threshold = s.tessellationThreshold; + pc.u_max_tessellation_polyline = s.maxTessellationLevelPolyline; + pc.u_max_tessellation_polygon = s.maxTessellationLevelPolygon; + pc.u_max_tessellation_cube = s.maxTessellationLevelCube; + pc.u_cull_radius_scale = s.cullRadiusScale; + pc.u_fog_enabled = s.depthScaling; + pc.u_output_width = (uint32_t)width; + pc.u_output_height = (uint32_t)height; + + const char* dbg = getenv("LUDUS_VK_PIPELINES"); + bool draw_polyline = !dbg || strchr(dbg, 'P'); + bool draw_polygon = !dbg || strchr(dbg, 'G'); + bool draw_obstacle = !dbg || strchr(dbg, 'O'); + + auto drawMeshTasks = s.vkctx.pfnCmdDrawMeshTasksEXT; + + if (draw_polyline && s.polylinePoolUsed > 0 && drawMeshTasks && s.pipelinePolyline) { + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, s.pipelinePolyline); + pc.u_num_polyline_pools = std::max(1u, (uint32_t)s.maxPolylinePoolsPerScene); + pc.u_max_varrays_per_pool = std::max(1u, (uint32_t)s.maxVarraysPerTsPolyline); + pc.u_cube_pool_index = 0; + vkCmdPushConstants(cmd, s.pipelineLayout, + kLudusPushConstantStages, 0, sizeof(pc), &pc); + uint32_t totalWG = numQueries * pc.u_num_polyline_pools * pc.u_max_varrays_per_pool; + drawMeshTasks(cmd, totalWG, 1, 1); + } + + if (draw_polygon && s.polygonPoolUsed > 0 && drawMeshTasks && s.pipelinePolygon) { + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, s.pipelinePolygon); + pc.u_num_polygon_pools = std::max(1u, (uint32_t)s.maxPolygonPoolsPerScene); + pc.u_max_varrays_per_pool = std::max(1u, (uint32_t)s.maxVarraysPerTsPolygon); + pc.u_cube_pool_index = 0; + vkCmdPushConstants(cmd, s.pipelineLayout, + kLudusPushConstantStages, 0, sizeof(pc), &pc); + uint32_t totalWG = numQueries * pc.u_num_polygon_pools * pc.u_max_varrays_per_pool; + drawMeshTasks(cmd, totalWG, 1, 1); + } + + uint32_t maxObstacles = std::max(1u, (uint32_t)s.maxObstaclesPerPool); + for (int poolIdx = 0; poolIdx < s.maxCubePoolsPerScene; poolIdx++) { + if (!(draw_obstacle && drawMeshTasks && s.pipelineObstacle)) break; + vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, s.pipelineObstacle); + pc.u_max_obstacles = maxObstacles; + pc.u_cube_pool_index = poolIdx; + // Wireframe rendering is driven by the per-pool ObstaclePool.render_flags + // SSBO field that the mesh shader reads (CUBE_FLAG_WIREFRAME bit). + vkCmdPushConstants(cmd, s.pipelineLayout, + kLudusPushConstantStages, 0, sizeof(pc), &pc); + uint32_t totalWG = numQueries * maxObstacles; + drawMeshTasks(cmd, totalWG, 1, 1); + } + + vkCmdEndRenderPass(cmd); + + // Fixed-function color/depth operations are ordered, unlike fragment SSBO + // stores. Publish the resolved color attachment to one compute pass that + // writes the CUDA-visible linear buffer. This is the only steady-state + // intra-submission synchronization point added by the export path. + VkImageMemoryBarrier colorToCompute = { + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}; + colorToCompute.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + colorToCompute.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + colorToCompute.oldLayout = VK_IMAGE_LAYOUT_GENERAL; + colorToCompute.newLayout = VK_IMAGE_LAYOUT_GENERAL; + colorToCompute.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + colorToCompute.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + colorToCompute.image = renderTarget.colorImage.image; + colorToCompute.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + colorToCompute.subresourceRange.baseMipLevel = 0; + colorToCompute.subresourceRange.levelCount = 1; + colorToCompute.subresourceRange.baseArrayLayer = 0; + colorToCompute.subresourceRange.layerCount = numQueries; + vkCmdPipelineBarrier(cmd, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + 0, 0, nullptr, 0, nullptr, 1, &colorToCompute); + + vkCmdBindPipeline( + cmd, VK_PIPELINE_BIND_POINT_COMPUTE, s.pipelineExport); + vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, + s.pipelineLayout, 0, 1, &descriptorSet, 0, nullptr); + vkCmdPushConstants(cmd, s.pipelineLayout, kLudusPushConstantStages, + 0, sizeof(pc), &pc); + vkCmdDispatch(cmd, + ((uint32_t)width + 15u) / 16u, + ((uint32_t)height + 15u) / 16u, + (uint32_t)numQueries); + + // Compute has populated the exported SSBO; release it and the input + // allocations to CUDA in the existing timeline handoff. + std::vector releaseBarriers; + auto releaseToCuda = [&](VkExternalBuffer& buffer, VkAccessFlags srcAccess) { + if (buffer.buffer == VK_NULL_HANDLE || buffer.size == 0 || !buffer.cuExtMem) + return; + VkBufferMemoryBarrier barrier = { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER}; + barrier.srcAccessMask = srcAccess; + barrier.dstAccessMask = 0; + barrier.srcQueueFamilyIndex = s.vkctx.graphicsQueueFamily; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL; + barrier.buffer = buffer.buffer; + barrier.offset = 0; + barrier.size = VK_WHOLE_SIZE; + releaseBarriers.push_back(barrier); + }; + releaseToCuda(s.timestampsBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.int32Buffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.vertexBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.triangleBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.poseBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.floatBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.sceneBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.polylinePoolBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.polygonPoolBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.obstaclePoolBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.colorPaletteBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.cameraIntrinsicsBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.cameraPoseBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(s.queryBuffer, VK_ACCESS_SHADER_READ_BIT); + releaseToCuda(outputBuffer, VK_ACCESS_SHADER_WRITE_BIT); + + vkCmdPipelineBarrier(cmd, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT + | VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT + | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT + | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + 0, 0, nullptr, + (uint32_t)releaseBarriers.size(), releaseBarriers.data(), + 0, nullptr); + + VK_CHECK(vkEndCommandBuffer(cmd)); + + const uint64_t vulkanDoneValue = ++s.vkctx.nextTimelineValue; + VkTimelineSemaphoreSubmitInfo timelineSubmit = { + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO}; + timelineSubmit.waitSemaphoreValueCount = 1; + timelineSubmit.pWaitSemaphoreValues = &cudaReadyValue; + timelineSubmit.signalSemaphoreValueCount = 1; + timelineSubmit.pSignalSemaphoreValues = &vulkanDoneValue; + VkPipelineStageFlags waitStage = + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT + | VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT + | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT + | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + VkSubmitInfo submitInfo = {VK_STRUCTURE_TYPE_SUBMIT_INFO}; + submitInfo.pNext = &timelineSubmit; + submitInfo.waitSemaphoreCount = 1; + submitInfo.pWaitSemaphores = &s.vkctx.interopTimeline; + submitInfo.pWaitDstStageMask = &waitStage; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &cmd; + submitInfo.signalSemaphoreCount = 1; + submitInfo.pSignalSemaphores = &s.vkctx.interopTimeline; + VK_CHECK(vkQueueSubmit(s.vkctx.graphicsQueue, 1, &submitInfo, frameFence)); + s.lastVulkanDoneValue = vulkanDoneValue; + s.outputReleasedToCuda[outputSlot] = 1; +} + +//============================================================================= +// Copy Results +//============================================================================= + +uint8_t* ludusMapBatchResultsVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + int outputSlot, int width, int height, int numQueries) +{ + (void)nvdr_ctx; + TORCH_CHECK(outputSlot >= 0 && outputSlot < LUDUS_VK_OUTPUT_SLOTS, + "invalid Vulkan output slot ", outputSlot); + const size_t bytes = (size_t)width * height * 4 * numQueries; + VkExternalBuffer& output = s.outputBuffers[outputSlot]; + TORCH_CHECK(output.cuDevPtr != 0 && output.size >= bytes, + "Vulkan output SSBO is not CUDA-importable or is undersized"); + waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); + return reinterpret_cast(output.cuDevPtr); +} + +void ludusCopyBatchResultsVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + uint8_t* outputPtr, int width, int height, int numQueries) +{ + size_t totalSize = (size_t)width * height * 4 * numQueries; + uint8_t* sharedOutput = ludusMapBatchResultsVk( + NVDR_CTX_PARAMS, s, stream, s.activeOutputSlot, + width, height, numQueries); + // Legacy staging/JPEG entry points request an owned CUDA copy. The primary + // torch render binding bypasses this function and wraps sharedOutput. + cudaError_t copyError = cudaMemcpyAsync( + outputPtr, + sharedOutput, + totalSize, + cudaMemcpyDeviceToDevice, + stream); + TORCH_CHECK(copyError == cudaSuccess, + "cudaMemcpyAsync from Vulkan shared output failed: ", (int)copyError); +} + +int ludusCopyBatchResultsToStagingVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + int width, int height, int numQueries) +{ + int idx = s.currentStagingIdx; + s.currentStagingIdx = 1 - idx; + + size_t totalSize = (size_t)width * height * 4 * numQueries; + if (totalSize > s.stagingBufferSize) { + for (int i = 0; i < 2; i++) { + if (s.stagingBuffer[i]) cudaFree(s.stagingBuffer[i]); + cudaMalloc(&s.stagingBuffer[i], totalSize); + s.stagingValid[i] = 0; + } + s.stagingBufferSize = totalSize; + } + + ludusCopyBatchResultsVk(NVDR_CTX_PARAMS, s, stream, s.stagingBuffer[idx], width, height, numQueries); + cudaEventRecord(s.stagingReadyEvent[idx], stream); + + s.stagingWidth = width; + s.stagingHeight = height; + s.stagingNumQueries = numQueries; + s.stagingValid[idx] = 1; + + return idx; +} + +void ludusCopyStagingToOutputVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx, + uint8_t* outputPtr, int width, int height, int numQueries) +{ + (void)nvdr_ctx; + cudaEventSynchronize(s.stagingReadyEvent[stagingIdx]); + size_t size = (size_t)width * height * 4 * numQueries; + cudaMemcpy(outputPtr, s.stagingBuffer[stagingIdx], size, cudaMemcpyDeviceToDevice); +} + +int ludusStartAsyncHostTransferVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx) +{ + (void)nvdr_ctx; + if (!s.stagingValid[stagingIdx]) return -1; + + int pinnedIdx = s.currentPinnedIdx; + s.currentPinnedIdx = 1 - pinnedIdx; + + size_t size = (size_t)s.stagingWidth * s.stagingHeight * 4 * s.stagingNumQueries; + if (size > s.pinnedHostBufferSize) { + for (int i = 0; i < 2; i++) { + if (s.pinnedHostBuffer[i]) cudaFreeHost(s.pinnedHostBuffer[i]); + cudaMallocHost(&s.pinnedHostBuffer[i], size); + s.pinnedValid[i] = 0; + } + s.pinnedHostBufferSize = size; + } + + cudaEventSynchronize(s.stagingReadyEvent[stagingIdx]); + cudaMemcpyAsync(s.pinnedHostBuffer[pinnedIdx], s.stagingBuffer[stagingIdx], + size, cudaMemcpyDeviceToHost, s.copyStream); + cudaEventRecord(s.pinnedReadyEvent[pinnedIdx], s.copyStream); + + s.pinnedWidth[pinnedIdx] = s.stagingWidth; + s.pinnedHeight[pinnedIdx] = s.stagingHeight; + s.pinnedNumQueries[pinnedIdx] = s.stagingNumQueries; + s.pinnedValid[pinnedIdx] = 1; + + return pinnedIdx; +} + +int ludusIsPinnedBufferReadyVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int pinnedIdx) +{ + (void)nvdr_ctx; + if (!s.pinnedValid[pinnedIdx]) return 0; + return (cudaEventQuery(s.pinnedReadyEvent[pinnedIdx]) == cudaSuccess) ? 1 : 0; +} + +int ludusIsHostTransferCompleteVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s) +{ + int prev = 1 - s.currentPinnedIdx; + return ludusIsPinnedBufferReadyVk(NVDR_CTX_PARAMS, s, prev); +} + +int ludusEncodeJpegBatchStagingVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx, int quality, + std::vector>& outJpegs) +{ + (void)nvdr_ctx; + if (!s.nvjpegInitialized) { + nvjpegCreateSimple(&s.nvjpegHandle); + nvjpegEncoderStateCreate(s.nvjpegHandle, &s.nvjpegEncoderState, 0); + nvjpegEncoderParamsCreate(s.nvjpegHandle, &s.nvjpegEncoderParams, 0); + s.nvjpegInitialized = 1; + } + nvjpegEncoderParamsSetQuality(s.nvjpegEncoderParams, quality, 0); + + cudaEventSynchronize(s.stagingReadyEvent[stagingIdx]); + + int w = s.stagingWidth; + int h = s.stagingHeight; + int n = s.stagingNumQueries; + size_t layerSize = (size_t)w * h * 4; + size_t rgbSize = (size_t)w * h * 3; + + if (rgbSize > s.jpegFlipBufferSize) { + if (s.jpegFlipBuffer) cudaFree(s.jpegFlipBuffer); + cudaMalloc(&s.jpegFlipBuffer, rgbSize); + s.jpegFlipBufferSize = rgbSize; + } + + outJpegs.resize(n); + for (int i = 0; i < n; i++) { + uint8_t* srcRgba = s.stagingBuffer[stagingIdx] + i * layerSize; + launchRgbaToRgbFlip(srcRgba, s.jpegFlipBuffer, w, h, 0); + cudaDeviceSynchronize(); + + nvjpegImage_t img; + memset(&img, 0, sizeof(img)); + img.channel[0] = s.jpegFlipBuffer; + img.pitch[0] = w * 3; + + nvjpegEncodeImage(s.nvjpegHandle, s.nvjpegEncoderState, s.nvjpegEncoderParams, + &img, NVJPEG_INPUT_RGBI, w, h, 0); + + size_t jpegSize = 0; + nvjpegEncodeRetrieveBitstream(s.nvjpegHandle, s.nvjpegEncoderState, nullptr, &jpegSize, 0); + + if (jpegSize > s.jpegOutputBufferSize) { + if (s.jpegOutputBuffer) cudaFreeHost(s.jpegOutputBuffer); + cudaMallocHost(&s.jpegOutputBuffer, jpegSize); + s.jpegOutputBufferSize = jpegSize; + } + + nvjpegEncodeRetrieveBitstream(s.nvjpegHandle, s.nvjpegEncoderState, + s.jpegOutputBuffer, &jpegSize, 0); + + uint8_t* jpegCopy = (uint8_t*)malloc(jpegSize); + memcpy(jpegCopy, s.jpegOutputBuffer, jpegSize); + outJpegs[i] = {jpegCopy, jpegSize}; + } + + return n; +} + +//============================================================================= +// Cleanup +//============================================================================= + +void ludusClearScenesVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s) +{ + (void)nvdr_ctx; + s.numScenes = 0; + s.timestampsUsed = s.int32Used = s.vertexUsed = s.triangleUsed = 0; + s.poseUsed = s.floatUsed = 0; + s.polylinePoolUsed = s.polygonPoolUsed = s.obstaclePoolUsed = 0; + s.maxObstaclesPerPool = s.maxCubePoolsPerScene = 0; + s.maxPolylinePoolsPerScene = s.maxPolygonPoolsPerScene = 0; + s.maxVarraysPerTsPolyline = s.maxVarraysPerTsPolygon = 0; + s.sceneBuffersDirty = 1; +} + +void ludusTimestampedReleaseVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s) +{ + (void)nvdr_ctx; + if (s.vkctx.device) vkDeviceWaitIdle(s.vkctx.device); + + for (int i = 0; i < 2; i++) { + if (s.stagingBuffer[i]) cudaFree(s.stagingBuffer[i]); + if (s.pinnedHostBuffer[i]) cudaFreeHost(s.pinnedHostBuffer[i]); + if (s.stagingReadyEvent[i]) cudaEventDestroy(s.stagingReadyEvent[i]); + if (s.pinnedReadyEvent[i]) cudaEventDestroy(s.pinnedReadyEvent[i]); + } + if (s.copyStream) cudaStreamDestroy(s.copyStream); + if (s.jpegOutputBuffer) cudaFreeHost(s.jpegOutputBuffer); + if (s.jpegFlipBuffer) cudaFree(s.jpegFlipBuffer); + if (s.nvjpegInitialized) { + nvjpegEncoderParamsDestroy(s.nvjpegEncoderParams); + nvjpegEncoderStateDestroy(s.nvjpegEncoderState); + nvjpegDestroy(s.nvjpegHandle); + } + + for (int i = 0; i < 10; i++) + if (s.shaderModules[i]) vkDestroyShaderModule(s.vkctx.device, s.shaderModules[i], nullptr); + + if (s.pipelinePolyline) vkDestroyPipeline(s.vkctx.device, s.pipelinePolyline, nullptr); + if (s.pipelinePolygon) vkDestroyPipeline(s.vkctx.device, s.pipelinePolygon, nullptr); + if (s.pipelineObstacle) vkDestroyPipeline(s.vkctx.device, s.pipelineObstacle, nullptr); + if (s.pipelineExport) vkDestroyPipeline(s.vkctx.device, s.pipelineExport, nullptr); + if (s.pipelineLayout) vkDestroyPipelineLayout(s.vkctx.device, s.pipelineLayout, nullptr); + if (s.descriptorPool) vkDestroyDescriptorPool(s.vkctx.device, s.descriptorPool, nullptr); + if (s.descriptorSetLayout) vkDestroyDescriptorSetLayout(s.vkctx.device, s.descriptorSetLayout, nullptr); + + destroyRenderTargets(s); + if (s.renderPass) vkDestroyRenderPass(s.vkctx.device, s.renderPass, nullptr); + + destroyExternalBuffer(s.vkctx, s.timestampsBuffer); + destroyExternalBuffer(s.vkctx, s.int32Buffer); + destroyExternalBuffer(s.vkctx, s.vertexBuffer); + destroyExternalBuffer(s.vkctx, s.triangleBuffer); + destroyExternalBuffer(s.vkctx, s.poseBuffer); + destroyExternalBuffer(s.vkctx, s.floatBuffer); + destroyExternalBuffer(s.vkctx, s.sceneBuffer); + destroyExternalBuffer(s.vkctx, s.polylinePoolBuffer); + destroyExternalBuffer(s.vkctx, s.polygonPoolBuffer); + destroyExternalBuffer(s.vkctx, s.obstaclePoolBuffer); + destroyExternalBuffer(s.vkctx, s.colorPaletteBuffer); + destroyExternalBuffer(s.vkctx, s.cameraIntrinsicsBuffer); + destroyExternalBuffer(s.vkctx, s.cameraPoseBuffer); + destroyExternalBuffer(s.vkctx, s.queryBuffer); + for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) + destroyExternalBuffer(s.vkctx, s.outputBuffers[i]); + + destroyVkContext(s.vkctx); + memset(&s, 0, sizeof(s)); +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h new file mode 100644 index 000000000..3032dbf47 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h @@ -0,0 +1,332 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#if !(defined(NVDR_TORCH) && defined(__CUDACC__)) +#include "../common/framework.h" +#include "../common/vkutil.h" +#include "ludus_types.h" +#include +#include + +// Forward-declared helper kernel (defined in render/ludus_jpeg.cu). +extern "C" void launchRgbaToRgbFlip( + const uint8_t* srcRgba, uint8_t* dstRgb, + int width, int height, cudaStream_t stream +); + +// ======================================================================== +// Vulkan Timestamped Rendering State +// +// Mirrors the GL-based timestamped renderer (now removed from this project) +// but uses Vulkan task/mesh/fragment pipelines via VK_EXT_mesh_shader. +// +// Same public API signatures as the CUDA backend in ludus_cuda.h so the +// Python bindings can dispatch to either with minimal differences. +// ======================================================================== + +constexpr int LUDUS_VK_OUTPUT_SLOTS = 8; +constexpr int LUDUS_VK_RENDER_TARGET_CACHE_SIZE = 4; + +struct LudusVkRenderTarget +{ + int width; + int height; + int maxLayers; + int samples; + VkExternalImage colorImage; + VkExternalImage depthStencilImage; + VkFramebuffer framebuffer; +}; + +struct LudusTimestampedVkState +{ + // ---------- Scene storage bookkeeping ---------- + int maxScenes; + int numScenes; + + int timestampsCapacity, timestampsUsed; + int int32Capacity, int32Used; + int vertexCapacity, vertexUsed; + int triangleCapacity, triangleUsed; + int poseCapacity, poseUsed; + int floatCapacity, floatUsed; + int polylinePoolCapacity, polylinePoolUsed; + int polygonPoolCapacity, polygonPoolUsed; + int obstaclePoolCapacity, obstaclePoolUsed; + int maxObstaclesPerPool; + int maxCubePoolsPerScene; + int maxPolylinePoolsPerScene; + int maxPolygonPoolsPerScene; + // Max varrays in any pool at a single timestamp, per family. Drives the + // per-pool mesh-task dispatch stride so large pools aren't silently capped. + int maxVarraysPerTsPolyline; + int maxVarraysPerTsPolygon; + + // ---------- Cameras ---------- + int cameraCapacity; + int numCameras; + + // ---------- Query batch ---------- + int queryCapacity; + + // ---------- Vulkan context ---------- + VkContext vkctx; + + // ---------- MSAA ---------- + int msaaSamples; + + // ---------- Color/depth render pass and reusable framebuffer cache ---------- + VkRenderPass renderPass; + LudusVkRenderTarget renderTargets[LUDUS_VK_RENDER_TARGET_CACHE_SIZE]; + int numRenderTargets; + int activeRenderTarget; + // Sample count the renderPass + pipelines were last built with (1 = no + // MSAA). The render pass attachment layout and the pipelines bake in the + // sample count, so both must be rebuilt when msaaSamples changes. + int renderPassSamples; + + // ---------- Data buffers (SSBOs, CUDA-importable) ---------- + VkExternalBuffer timestampsBuffer; // binding 0: int64[] + VkExternalBuffer int32Buffer; // binding 1: int32[] + VkExternalBuffer vertexBuffer; // binding 2: Vertex[] + VkExternalBuffer triangleBuffer; // binding 3: Triangle[] + VkExternalBuffer poseBuffer; // binding 4: CameraPose[] + VkExternalBuffer floatBuffer; // binding 5: float[] + VkExternalBuffer sceneBuffer; // binding 6: TimestampedScene[] + VkExternalBuffer polylinePoolBuffer; // binding 7: TimestampedPolylinePool[] + VkExternalBuffer polygonPoolBuffer; // binding 8: TimestampedPolygonPool[] + VkExternalBuffer obstaclePoolBuffer; // binding 9: ObstaclePool[] + VkExternalBuffer colorPaletteBuffer; // binding 10: vec4[] + VkExternalBuffer cameraIntrinsicsBuffer; // binding 11: FThetaCamera[] + VkExternalBuffer cameraPoseBuffer; // binding 12: CameraPose[] per-query + VkExternalBuffer queryBuffer; // binding 13: RenderQuery[] + + int colorPaletteSize; + + // Set by control-plane ops (upload/remove/clear); the per-frame host + // roundtrip re-pushes the scene SSBOs only when set. + int sceneBuffersDirty; + + // ---------- Descriptor set ---------- + VkDescriptorSetLayout descriptorSetLayout; + VkDescriptorPool descriptorPool; + VkDescriptorSet descriptorSets[VkContext::kFramesInFlight]; + + // ---------- Pipeline layout (shared across all 3 pipelines) ---------- + VkPipelineLayout pipelineLayout; + + // ---------- Pipelines (one per draw type) ---------- + VkPipeline pipelinePolyline; + VkPipeline pipelinePolygon; + VkPipeline pipelineObstacle; + VkPipeline pipelineExport; + + // ---------- Shader modules: 3 graphics pipelines + one compute export ---------- + VkShaderModule shaderModules[10]; + + // ---------- Capability flags ---------- + int hasMeshShader; + float tessellationThreshold; + + // ---------- Configurable parameters ---------- + int maxTessellationLevelPolyline; + int maxTessellationLevelPolygon; + int maxTessellationLevelCube; + float widthPolylineRegular; + float widthPolylineBev; + float widthEgoTrajRegular; + float widthEgoTrajBev; + float widthWireframe; + float resolutionScale; + float depthScaling; + int maxExtrapolationUs; + float cullRadiusScale; + + // ---------- Double-buffered staging for async transfer ---------- + uint8_t* stagingBuffer[2]; + size_t stagingBufferSize; + int stagingWidth, stagingHeight, stagingNumQueries; + int currentStagingIdx; + int stagingValid[2]; + cudaStream_t copyStream; + cudaEvent_t stagingReadyEvent[2]; + + uint8_t* pinnedHostBuffer[2]; + size_t pinnedHostBufferSize; + int currentPinnedIdx; + int pinnedValid[2]; + int pinnedWidth[2], pinnedHeight[2], pinnedNumQueries[2]; + cudaEvent_t pinnedReadyEvent[2]; + + // ---------- NVJPEG (GPU JPEG encoding) ---------- + nvjpegHandle_t nvjpegHandle; + nvjpegEncoderState_t nvjpegEncoderState; + nvjpegEncoderParams_t nvjpegEncoderParams; + int nvjpegInitialized; + uint8_t* jpegOutputBuffer; + size_t jpegOutputBufferSize; + uint8_t* jpegFlipBuffer; + size_t jpegFlipBufferSize; + + // ---------- Zero-copy compute-export output pool ---------- + // Fixed-function color/depth rendering resolves visibility into a cached, + // Vulkan-only color attachment. A compute pass then writes packed RGBA8 + // directly into one exported SSBO. CUDA maps the same allocation and the + // binding wraps its CUdeviceptr with torch::from_blob. There is no host or + // CUDA result copy, and no layered CUDA image import. Slots are leased until + // their returned tensor is released. + VkExternalBuffer outputBuffers[LUDUS_VK_OUTPUT_SLOTS]; + int outputReleasedToCuda[LUDUS_VK_OUTPUT_SLOTS]; + int activeOutputSlot; + size_t activeOutputSize; + + // ---------- CUDA/Vulkan asynchronous ownership chain ---------- + // Per render: CUDA signals inputs-ready, Vulkan signals render-done, + // CUDA maps the shared output directly. The next render's inputs-ready + // signal also releases a reused output slot from CUDA to Vulkan. + uint64_t lastVulkanDoneValue; +}; + +// Unified push constants block, shared across all 3 pipelines and stages. +// 21 fields, 84 bytes -- must match the layout(push_constant) block in +// every Vulkan GLSL shader. Per-cube wireframe rendering is driven by the +// ObstaclePool.render_flags SSBO field (not a push constant) so that +// different cube pools in the same draw can mix solid and wireframe modes. +struct LudusPushConstants +{ + float u_width_polyline_regular; // 0 + float u_width_polyline_bev; // 4 + float u_width_ego_traj_regular; // 8 + float u_width_ego_traj_bev; // 12 + float u_width_wireframe; // 16 + float u_resolution_scale; // 20 + float u_depth_scaling; // 24 + int32_t u_max_extrapolation_us; // 28 + int32_t u_color_palette_size; // 32 + uint32_t u_num_queries; // 36 + float u_tessellation_threshold; // 40 + uint32_t u_max_tessellation_polyline; // 44 + uint32_t u_max_tessellation_polygon; // 48 + uint32_t u_max_tessellation_cube; // 52 + float u_cull_radius_scale; // 56 + float u_fog_enabled; // 60 + uint32_t u_max_obstacles; // 64 + uint32_t u_cube_pool_index; // 68 + uint32_t u_num_polygon_pools; // 72 + uint32_t u_max_varrays_per_pool; // 76 + uint32_t u_num_polyline_pools; // 80 + uint32_t u_output_width; // 84 + uint32_t u_output_height; // 88 +}; +static_assert(sizeof(LudusPushConstants) == 92, "LudusPushConstants must be 92 bytes"); + +// ======================================================================== +// Public API -- same shape as the GL/CUDA backends so bindings can dispatch. +// ======================================================================== + +void ludusTimestampedInitVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s, int cudaDeviceIdx); + +void ludusUploadCamerasVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const FThetaCamera* intrinsics, int numCameras +); + +void ludusUploadColorPaletteVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const float* colors, int numColors +); + +int ludusUploadSceneVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const TimestampedScene* sceneDesc, + const TimestampedPolylinePool* polylinePools, int numPolylinePools, + const TimestampedPolygonPool* polygonPools, int numPolygonPools, + const ObstaclePool* obstaclePools, int numObstaclePools, + int maxObstaclesInPool, + int maxVarraysPerTsPolyline, int maxVarraysPerTsPolygon, + const int64_t* timestamps, int numTimestamps, + const int32_t* int32Data, int numInt32, + const Vertex* vertices, int numVertices, + const Triangle* triangles, int numTriangles, + const CameraPose* poses, int numPoses, + const float* floatData, int numFloats +); + +void ludusUpdateCubePoolVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + int absolutePoolIndex, + int timestampOffset, int trackTimestampOffset, int int32Offset, + int translationOffset, int quaternionOffset, int scaleOffset, int colorOffset, + const int64_t* timestamps, int numTimestamps, + const int64_t* trackTimestamps, int numTrackTimestamps, + const int32_t* prefixSum, int numCubes, + const float* translations, int numTranslationFloats, + const float* quaternions, int numQuaternionFloats, + const float* scales, int numScaleFloats, + const float* colors, int numColorFloats, + const ObstaclePool* poolHeader +); + +void ludusRemoveSceneVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s, int sceneId, cudaStream_t stream); + +void ludusRenderBatchVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + const RenderQuery* queries, const CameraPose* cameraPoses, + int numQueries, int width, int height, int outputSlot +); + +uint8_t* ludusMapBatchResultsVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + int outputSlot, int width, int height, int numQueries +); + +void ludusCopyBatchResultsVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + uint8_t* outputPtr, int width, int height, int numQueries +); + +int ludusCopyBatchResultsToStagingVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, + int width, int height, int numQueries +); + +void ludusCopyStagingToOutputVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx, + uint8_t* outputPtr, int width, int height, int numQueries +); + +int ludusStartAsyncHostTransferVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx +); + +int ludusIsPinnedBufferReadyVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int pinnedIdx +); + +int ludusIsHostTransferCompleteVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s +); + +int ludusEncodeJpegBatchStagingVk( + NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx, int quality, + std::vector>& outJpegs +); + +void ludusClearScenesVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s); +void ludusTimestampedReleaseVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s); + +#endif // !(defined(NVDR_TORCH) && defined(__CUDACC__)) diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/shaders_spv.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/shaders_spv.h new file mode 100644 index 000000000..1f1ef1c7b --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/shaders_spv.h @@ -0,0 +1,9854 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// AUTOGENERATED by ludus_renderer/shaders/embed_spv.py +// DO NOT EDIT BY HAND. Regenerate with: +// bash ludus_renderer/shaders/compile.sh (compiles GLSL -> SPIR-V and re-embeds) + +#pragma once +#include + +static const uint32_t kSpv_ts_polyline_task[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000349u, 0x00000000u, 0x00020011u, 0x0000000bu, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x0016000fu, 0x000014f4u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x000000d7u, 0x000000edu, 0x00000176u, + 0x000001bau, 0x000001e6u, 0x000001f5u, 0x0000020cu, 0x00000234u, 0x00000270u, 0x0000027fu, 0x000002a2u, + 0x0000030fu, 0x00000335u, 0x00000339u, 0x0000033du, 0x00000342u, 0x00000347u, 0x0006014bu, 0x00000004u, + 0x00000026u, 0x00000007u, 0x00000007u, 0x00000007u, 0x00030003u, 0x00000002u, 0x000001ccu, 0x00060004u, + 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, 0x000d0004u, 0x455f4c47u, 0x735f5458u, + 0x65646168u, 0x78655f72u, 0x63696c70u, 0x615f7469u, 0x68746972u, 0x6974656du, 0x79745f63u, 0x5f736570u, + 0x36746e69u, 0x00000034u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00090005u, 0x0000000du, + 0x5f746567u, 0x61666564u, 0x5f746c75u, 0x6d697270u, 0x6c6f635fu, 0x7528726fu, 0x00003b31u, 0x00060005u, + 0x0000000cu, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00070005u, 0x00000010u, 0x5f746567u, + 0x6d697270u, 0x6c6f635fu, 0x7528726fu, 0x00003b31u, 0x00060005u, 0x0000000fu, 0x6d697270u, 0x7079745fu, + 0x64695f65u, 0x00000000u, 0x00080005u, 0x00000015u, 0x645f7369u, 0x705f746fu, 0x696d6972u, 0x65766974u, + 0x3b317528u, 0x00000000u, 0x00060005u, 0x00000014u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, + 0x00080005u, 0x0000001au, 0x5f746567u, 0x6d697270u, 0x6469775fu, 0x75286874u, 0x31753b31u, 0x0000003bu, + 0x00060005u, 0x00000018u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00060005u, 0x00000019u, + 0x656d6163u, 0x745f6172u, 0x5f657079u, 0x00006469u, 0x000c0005u, 0x00000023u, 0x616e6962u, 0x735f7972u, + 0x63726165u, 0x69745f68u, 0x7473656du, 0x73706d61u, 0x3b317528u, 0x693b3175u, 0x3b313436u, 0x00000000u, + 0x00050005u, 0x00000020u, 0x65736162u, 0x66666f5fu, 0x00746573u, 0x00040005u, 0x00000021u, 0x6e756f63u, + 0x00000074u, 0x00040005u, 0x00000022u, 0x67726174u, 0x00007465u, 0x000b0005u, 0x0000002bu, 0x6c6c7563u, + 0x6261615fu, 0x766f5f62u, 0x616c7265u, 0x66762870u, 0x66763b33u, 0x66763b33u, 0x66763b33u, 0x00003b33u, + 0x00040005u, 0x00000027u, 0x696d5f61u, 0x0000006eu, 0x00040005u, 0x00000028u, 0x616d5f61u, 0x00000078u, + 0x00040005u, 0x00000029u, 0x696d5f62u, 0x0000006eu, 0x00040005u, 0x0000002au, 0x616d5f62u, 0x00000078u, + 0x00050005u, 0x0000002fu, 0x656d6143u, 0x6f506172u, 0x00006573u, 0x00070006u, 0x0000002fu, 0x00000000u, + 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00617265u, 0x000e0005u, 0x00000033u, 0x5f746567u, 0x656d6163u, + 0x775f6172u, 0x646c726fu, 0x736f705fu, 0x72747328u, 0x2d746375u, 0x656d6143u, 0x6f506172u, 0x6d2d6573u, + 0x31343466u, 0x0000003bu, 0x00040005u, 0x00000032u, 0x65736f70u, 0x00000000u, 0x00060005u, 0x000000d5u, + 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, 0x000a0006u, 0x000000d5u, 0x00000000u, 0x69775f75u, + 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x000000d5u, + 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, + 0x000000d5u, 0x00000002u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, + 0x00000000u, 0x00090006u, 0x000000d5u, 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, + 0x7665625fu, 0x00000000u, 0x00080006u, 0x000000d5u, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, + 0x6d617266u, 0x00000065u, 0x00080006u, 0x000000d5u, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, + 0x6163735fu, 0x0000656cu, 0x00070006u, 0x000000d5u, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, + 0x00676e69u, 0x00090006u, 0x000000d5u, 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, + 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x000000d5u, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, + 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, 0x000000d5u, 0x00000009u, 0x756e5f75u, 0x75715f6du, + 0x65697265u, 0x00000073u, 0x000a0006u, 0x000000d5u, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, + 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, 0x000a0006u, 0x000000d5u, 0x0000000bu, 0x616d5f75u, + 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x000000d5u, + 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, + 0x00090006u, 0x000000d5u, 0x0000000du, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, + 0x00656275u, 0x00080006u, 0x000000d5u, 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, + 0x00656c61u, 0x00070006u, 0x000000d5u, 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, + 0x00070006u, 0x000000d5u, 0x00000010u, 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, + 0x000000d5u, 0x00000011u, 0x75635f75u, 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, + 0x000000d5u, 0x00000012u, 0x756e5f75u, 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, + 0x000000d5u, 0x00000013u, 0x616d5f75u, 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, + 0x00090006u, 0x000000d5u, 0x00000014u, 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, + 0x00000000u, 0x00070006u, 0x000000d5u, 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, + 0x00070006u, 0x000000d5u, 0x00000016u, 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, + 0x000000d7u, 0x00006370u, 0x00060005u, 0x000000e9u, 0x656c6170u, 0x5f657474u, 0x6f6c6f63u, 0x00000072u, + 0x00080005u, 0x000000ebu, 0x6f6c6f43u, 0x6c615072u, 0x65747465u, 0x66667542u, 0x61457265u, 0x00796c72u, + 0x00070006u, 0x000000ebu, 0x00000000u, 0x6f635f67u, 0x5f726f6cu, 0x656c6170u, 0x00657474u, 0x00030005u, + 0x000000edu, 0x00000000u, 0x00040005u, 0x000000fbu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000108u, + 0x625f7369u, 0x00007665u, 0x00040005u, 0x0000010bu, 0x6c616373u, 0x00000065u, 0x00050005u, 0x0000011cu, + 0x61666564u, 0x5f746c75u, 0x00000077u, 0x00050005u, 0x00000121u, 0x74737563u, 0x775f6d6fu, 0x00000000u, + 0x00050005u, 0x0000012eu, 0x65736162u, 0x6469775fu, 0x00006874u, 0x00050005u, 0x0000013du, 0x61666564u, + 0x5f746c75u, 0x00000077u, 0x00050005u, 0x00000142u, 0x74737563u, 0x775f6d6fu, 0x00000000u, 0x00040005u, + 0x0000015fu, 0x7466656cu, 0x00000000u, 0x00040005u, 0x00000160u, 0x68676972u, 0x00000074u, 0x00040005u, + 0x00000164u, 0x75736572u, 0x0000746cu, 0x00030005u, 0x0000016du, 0x0064696du, 0x00030005u, 0x00000172u, + 0x006c6176u, 0x00070005u, 0x00000174u, 0x656d6954u, 0x6d617473u, 0x75427370u, 0x72656666u, 0x00000000u, + 0x00070006u, 0x00000174u, 0x00000000u, 0x69745f67u, 0x7473656du, 0x73706d61u, 0x00000000u, 0x00030005u, + 0x00000176u, 0x00000000u, 0x00030005u, 0x0000019cu, 0x00000052u, 0x00050005u, 0x000001b6u, 0x7361745fu, + 0x6f635f6bu, 0x00746e75u, 0x00040005u, 0x000001b7u, 0x6b726f77u, 0x0064695fu, 0x00060005u, 0x000001bau, + 0x575f6c67u, 0x476b726fu, 0x70756f72u, 0x00004449u, 0x00060005u, 0x000001beu, 0x72726176u, 0x6f5f7961u, + 0x65736666u, 0x00000074u, 0x00040005u, 0x000001c5u, 0x706d6574u, 0x00000000u, 0x00060005u, 0x000001cau, + 0x6c6f6f70u, 0x5f64695fu, 0x61636f6cu, 0x0000006cu, 0x00060005u, 0x000001d0u, 0x72657571u, 0x64695f79u, + 0x636f6c5fu, 0x00006c61u, 0x00050005u, 0x000001dfu, 0x646e6552u, 0x75517265u, 0x00797265u, 0x00060006u, + 0x000001dfu, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, 0x000001dfu, 0x00000001u, + 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x000001dfu, 0x00000002u, 0x656d6974u, 0x6d617473u, + 0x73755f70u, 0x00000000u, 0x00070006u, 0x000001dfu, 0x00000003u, 0x656d6163u, 0x745f6172u, 0x5f657079u, + 0x00006469u, 0x00050006u, 0x000001dfu, 0x00000004u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x000001dfu, + 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x000001dfu, 0x00000006u, 0x6461705fu, 0x00000033u, + 0x00040005u, 0x000001e1u, 0x72657571u, 0x00000079u, 0x00050005u, 0x000001e2u, 0x646e6552u, 0x75517265u, + 0x00797265u, 0x00060006u, 0x000001e2u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, + 0x000001e2u, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x000001e2u, 0x00000002u, + 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x000001e2u, 0x00000003u, 0x656d6163u, + 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x000001e2u, 0x00000004u, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x000001e2u, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x000001e2u, 0x00000006u, + 0x6461705fu, 0x00000033u, 0x00050005u, 0x000001e4u, 0x72657551u, 0x66754279u, 0x00726566u, 0x00060006u, + 0x000001e4u, 0x00000000u, 0x75715f67u, 0x65697265u, 0x00000073u, 0x00030005u, 0x000001e6u, 0x00000000u, + 0x00070005u, 0x000001edu, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, + 0x000001edu, 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, + 0x000001edu, 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, + 0x00080006u, 0x000001edu, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, + 0x00090006u, 0x000001edu, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, + 0x00000000u, 0x00070006u, 0x000001edu, 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, + 0x00080006u, 0x000001edu, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, + 0x000a0006u, 0x000001edu, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, + 0x74657366u, 0x00000000u, 0x00080006u, 0x000001edu, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, + 0x66666f5fu, 0x00746573u, 0x00090006u, 0x000001edu, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, + 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00090006u, 0x000001edu, 0x00000009u, 0x61697274u, 0x656c676eu, + 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x000001edu, 0x0000000au, 0x65736f70u, + 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x000001edu, 0x0000000bu, 0x616f6c66u, + 0x75625f74u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x000001edu, 0x0000000cu, 0x6461705fu, + 0x00000000u, 0x00040005u, 0x000001efu, 0x6e656373u, 0x00000065u, 0x00070005u, 0x000001f1u, 0x656d6954u, + 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x000001f1u, 0x00000000u, 0x5f6d756eu, + 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x000001f1u, 0x00000001u, 0x796c6f70u, + 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, 0x000001f1u, 0x00000002u, + 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, 0x000001f1u, 0x00000003u, + 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00070006u, 0x000001f1u, + 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, 0x000001f1u, 0x00000005u, + 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, 0x000001f1u, 0x00000006u, + 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00080006u, + 0x000001f1u, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00090006u, + 0x000001f1u, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, + 0x00090006u, 0x000001f1u, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, 0x5f726566u, 0x7366666fu, + 0x00007465u, 0x00080006u, 0x000001f1u, 0x0000000au, 0x65736f70u, 0x6675625fu, 0x5f726566u, 0x7366666fu, + 0x00007465u, 0x00080006u, 0x000001f1u, 0x0000000bu, 0x616f6c66u, 0x75625f74u, 0x72656666u, 0x66666f5fu, + 0x00746573u, 0x00050006u, 0x000001f1u, 0x0000000cu, 0x6461705fu, 0x00000000u, 0x00050005u, 0x000001f3u, + 0x6e656353u, 0x66754265u, 0x00726566u, 0x00060006u, 0x000001f3u, 0x00000000u, 0x63735f67u, 0x73656e65u, + 0x00000000u, 0x00030005u, 0x000001f5u, 0x00000000u, 0x00080005u, 0x00000205u, 0x656d6954u, 0x6d617473u, + 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x00000205u, 0x00000000u, 0x5f6d756eu, + 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000205u, 0x00000001u, 0x5f6d756eu, 0x72726176u, + 0x00737961u, 0x00070006u, 0x00000205u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, + 0x00070006u, 0x00000205u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, + 0x00000205u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, + 0x00000205u, 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, + 0x00080006u, 0x00000205u, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00070006u, 0x00000205u, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00060006u, + 0x00000205u, 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000205u, 0x00000009u, + 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000205u, 0x0000000au, 0x6461705fu, 0x00000032u, 0x00050006u, + 0x00000205u, 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000205u, 0x0000000cu, 0x6461705fu, + 0x00000034u, 0x00050006u, 0x00000205u, 0x0000000du, 0x6461705fu, 0x00000035u, 0x00050006u, 0x00000205u, + 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, 0x00000205u, 0x0000000fu, 0x6461705fu, 0x00000037u, + 0x00040005u, 0x00000207u, 0x6c6f6f70u, 0x00000000u, 0x00080005u, 0x00000208u, 0x656d6954u, 0x6d617473u, + 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x00000208u, 0x00000000u, 0x5f6d756eu, + 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000208u, 0x00000001u, 0x5f6d756eu, 0x72726176u, + 0x00737961u, 0x00070006u, 0x00000208u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, + 0x00070006u, 0x00000208u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, + 0x00000208u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, + 0x00000208u, 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, + 0x00080006u, 0x00000208u, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00070006u, 0x00000208u, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00060006u, + 0x00000208u, 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000208u, 0x00000009u, + 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000208u, 0x0000000au, 0x6461705fu, 0x00000032u, 0x00050006u, + 0x00000208u, 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000208u, 0x0000000cu, 0x6461705fu, + 0x00000034u, 0x00050006u, 0x00000208u, 0x0000000du, 0x6461705fu, 0x00000035u, 0x00050006u, 0x00000208u, + 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, 0x00000208u, 0x0000000fu, 0x6461705fu, 0x00000037u, + 0x00070005u, 0x0000020au, 0x796c6f50u, 0x656e696cu, 0x6c6f6f50u, 0x66667542u, 0x00007265u, 0x00080006u, + 0x0000020au, 0x00000000u, 0x6f705f67u, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00030005u, + 0x0000020cu, 0x00000000u, 0x00040005u, 0x00000215u, 0x695f7374u, 0x00007864u, 0x00040005u, 0x0000021du, + 0x61726170u, 0x0000006du, 0x00040005u, 0x0000021eu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000221u, + 0x61726170u, 0x0000006du, 0x00060005u, 0x0000022cu, 0x72726176u, 0x735f7961u, 0x74726174u, 0x00000000u, + 0x00050005u, 0x00000232u, 0x33746e49u, 0x66754232u, 0x00726566u, 0x00050006u, 0x00000232u, 0x00000000u, + 0x6e695f67u, 0x00323374u, 0x00030005u, 0x00000234u, 0x00000000u, 0x00050005u, 0x00000243u, 0x72726176u, + 0x655f7961u, 0x0000646eu, 0x00050005u, 0x0000024fu, 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070005u, + 0x00000253u, 0x63726f66u, 0x657a5f65u, 0x745f6f72u, 0x736b7361u, 0x00000000u, 0x00070005u, 0x0000025bu, + 0x75746361u, 0x765f6c61u, 0x61727261u, 0x64695f79u, 0x00000078u, 0x00040005u, 0x0000026bu, 0x6c6c7563u, + 0x0000725fu, 0x00060005u, 0x0000026cu, 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, 0x00040006u, + 0x0000026cu, 0x00000000u, 0x00007863u, 0x00040006u, 0x0000026cu, 0x00000001u, 0x00007963u, 0x00050006u, + 0x0000026cu, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, 0x0000026cu, 0x00000003u, 0x5f676d69u, + 0x00000068u, 0x00050006u, 0x0000026cu, 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, 0x0000026cu, + 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x0000026cu, 0x00000006u, 0x796c6f70u, 0x00000032u, + 0x00050006u, 0x0000026cu, 0x00000007u, 0x796c6f70u, 0x00000033u, 0x00050006u, 0x0000026cu, 0x00000008u, + 0x796c6f70u, 0x00000034u, 0x00050006u, 0x0000026cu, 0x00000009u, 0x796c6f70u, 0x00000035u, 0x00070006u, + 0x0000026cu, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, 0x0000026cu, + 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, 0x0000026cu, + 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, 0x0000026cu, + 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, 0x0000026cu, 0x0000000eu, 0x635f646cu, + 0x00000000u, 0x00050006u, 0x0000026cu, 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, 0x0000026cu, + 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x0000026cu, 0x00000011u, 0x665f646cu, 0x00000000u, + 0x00080005u, 0x0000026eu, 0x656d6143u, 0x6e496172u, 0x6e697274u, 0x73636973u, 0x66667542u, 0x00007265u, + 0x00080006u, 0x0000026eu, 0x00000000u, 0x61635f67u, 0x6172656du, 0x746e695fu, 0x736e6972u, 0x00736369u, + 0x00030005u, 0x00000270u, 0x00000000u, 0x00050005u, 0x0000027au, 0x6c6c7563u, 0x736f705fu, 0x00000065u, + 0x00050005u, 0x0000027bu, 0x656d6143u, 0x6f506172u, 0x00006573u, 0x00070006u, 0x0000027bu, 0x00000000u, + 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00617265u, 0x00070005u, 0x0000027du, 0x656d6143u, 0x6f506172u, + 0x75426573u, 0x72656666u, 0x00000000u, 0x00070006u, 0x0000027du, 0x00000000u, 0x61635f67u, 0x6172656du, + 0x736f705fu, 0x00007365u, 0x00030005u, 0x0000027fu, 0x00000000u, 0x00040005u, 0x00000285u, 0x5f6d6163u, + 0x00736f70u, 0x00040005u, 0x00000286u, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000289u, 0x77656976u, + 0x6e696d5fu, 0x00000000u, 0x00050005u, 0x0000028eu, 0x77656976u, 0x78616d5fu, 0x00000000u, 0x00030005u, + 0x00000293u, 0x00006261u, 0x00040005u, 0x0000029eu, 0x696d5f65u, 0x0000006eu, 0x00050005u, 0x000002a0u, + 0x616f6c46u, 0x66754274u, 0x00726566u, 0x00060006u, 0x000002a0u, 0x00000000u, 0x6c665f67u, 0x7374616fu, + 0x00000000u, 0x00030005u, 0x000002a2u, 0x00000000u, 0x00040005u, 0x000002afu, 0x616d5f65u, 0x00000078u, + 0x00040005u, 0x000002beu, 0x61726170u, 0x0000006du, 0x00040005u, 0x000002c0u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x000002c2u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000002c4u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x000002cau, 0x74735f76u, 0x00747261u, 0x00040005u, 0x000002dau, 0x6e655f76u, 0x00000064u, + 0x00050005u, 0x000002e5u, 0x61746f74u, 0x74705f6cu, 0x00000073u, 0x00040005u, 0x000002e9u, 0x645f7369u, + 0x0000746fu, 0x00040005u, 0x000002eau, 0x61726170u, 0x0000006du, 0x00050005u, 0x000002f1u, 0x5f6d756eu, + 0x6e756863u, 0x0000736bu, 0x00060005u, 0x00000300u, 0x5f6d756eu, 0x6d676573u, 0x73746e65u, 0x00000000u, + 0x00050005u, 0x00000303u, 0x5f6d756eu, 0x6e756863u, 0x0000736bu, 0x00070005u, 0x0000030du, 0x796c6f50u, + 0x656e696cu, 0x6b736154u, 0x6c796150u, 0x0064616fu, 0x00060006u, 0x0000030du, 0x00000000u, 0x72657571u, + 0x64695f79u, 0x00000000u, 0x00050006u, 0x0000030du, 0x00000001u, 0x6c6f6f70u, 0x0064695fu, 0x00060006u, + 0x0000030du, 0x00000002u, 0x72726176u, 0x695f7961u, 0x00007864u, 0x00070006u, 0x0000030du, 0x00000003u, + 0x61746f74u, 0x6f705f6cu, 0x73746e69u, 0x00000000u, 0x00050006u, 0x0000030du, 0x00000004u, 0x74646977u, + 0x00000068u, 0x00050006u, 0x0000030du, 0x00000005u, 0x6f6c6f63u, 0x00000072u, 0x00060006u, 0x0000030du, + 0x00000006u, 0x5f706163u, 0x6c797473u, 0x00000065u, 0x00050006u, 0x0000030du, 0x00000007u, 0x625f7369u, + 0x00007665u, 0x00040005u, 0x0000030fu, 0x6c796170u, 0x0064616fu, 0x00040005u, 0x00000319u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x0000031cu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000322u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000331u, 0x74726556u, 0x00007865u, 0x00040006u, 0x00000331u, 0x00000000u, + 0x00000078u, 0x00040006u, 0x00000331u, 0x00000001u, 0x00000079u, 0x00040006u, 0x00000331u, 0x00000002u, + 0x0000007au, 0x00050006u, 0x00000331u, 0x00000003u, 0x6461705fu, 0x00000000u, 0x00060005u, 0x00000333u, + 0x74726556u, 0x75427865u, 0x72656666u, 0x00000000u, 0x00060006u, 0x00000333u, 0x00000000u, 0x65765f67u, + 0x63697472u, 0x00007365u, 0x00030005u, 0x00000335u, 0x00000000u, 0x00060005u, 0x00000337u, 0x61697254u, + 0x656c676eu, 0x66667542u, 0x00007265u, 0x00060006u, 0x00000337u, 0x00000000u, 0x72745f67u, 0x676e6169u, + 0x0073656cu, 0x00030005u, 0x00000339u, 0x00000000u, 0x00050005u, 0x0000033bu, 0x65736f50u, 0x66667542u, + 0x00007265u, 0x00050006u, 0x0000033bu, 0x00000000u, 0x6f705f67u, 0x00736573u, 0x00030005u, 0x0000033du, + 0x00000000u, 0x00080005u, 0x0000033eu, 0x656d6954u, 0x6d617473u, 0x50646570u, 0x67796c6fu, 0x6f506e6fu, + 0x00006c6fu, 0x00070006u, 0x0000033eu, 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, + 0x00060006u, 0x0000033eu, 0x00000001u, 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, 0x0000033eu, + 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, 0x00070006u, 0x0000033eu, 0x00000003u, + 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, 0x00070006u, 0x0000033eu, 0x00000004u, 0x6d697270u, + 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x0000033eu, 0x00000005u, 0x656d6974u, 0x6d617473u, + 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x0000033eu, 0x00000006u, 0x765f7374u, 0x61727261u, + 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, 0x0000033eu, 0x00000007u, 0x72726176u, + 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x0000033eu, 0x00000008u, 0x5f697274u, + 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x0000033eu, 0x00000009u, 0x74726576u, 0x73656369u, + 0x66666f5fu, 0x00746573u, 0x00080006u, 0x0000033eu, 0x0000000au, 0x61697274u, 0x656c676eu, 0x666f5f73u, + 0x74657366u, 0x00000000u, 0x00060006u, 0x0000033eu, 0x0000000bu, 0x62626161u, 0x66666f5fu, 0x00746573u, + 0x00050006u, 0x0000033eu, 0x0000000cu, 0x6461705fu, 0x00000031u, 0x00050006u, 0x0000033eu, 0x0000000du, + 0x6461705fu, 0x00000032u, 0x00050006u, 0x0000033eu, 0x0000000eu, 0x6461705fu, 0x00000033u, 0x00050006u, + 0x0000033eu, 0x0000000fu, 0x6461705fu, 0x00000034u, 0x00070005u, 0x00000340u, 0x796c6f50u, 0x506e6f67u, + 0x426c6f6fu, 0x65666675u, 0x00000072u, 0x00070006u, 0x00000340u, 0x00000000u, 0x6f705f67u, 0x6f67796cu, + 0x6f705f6eu, 0x00736c6fu, 0x00030005u, 0x00000342u, 0x00000000u, 0x00060005u, 0x00000343u, 0x7473624fu, + 0x656c6361u, 0x6c6f6f50u, 0x00000000u, 0x00060006u, 0x00000343u, 0x00000000u, 0x5f6d756eu, 0x65627563u, + 0x00000073u, 0x00070006u, 0x00000343u, 0x00000001u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, + 0x00070006u, 0x00000343u, 0x00000002u, 0x5f6d756eu, 0x63617274u, 0x6f705f6bu, 0x00736573u, 0x00070006u, + 0x00000343u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x00000343u, + 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00080006u, 0x00000343u, + 0x00000005u, 0x65627563u, 0x5f73745fu, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x00000343u, + 0x00000006u, 0x63617274u, 0x69745f6bu, 0x7473656du, 0x73706d61u, 0x66666f5fu, 0x00746573u, 0x00080006u, + 0x00000343u, 0x00000007u, 0x6e617274u, 0x74616c73u, 0x736e6f69u, 0x66666f5fu, 0x00746573u, 0x00080006u, + 0x00000343u, 0x00000008u, 0x74617571u, 0x696e7265u, 0x5f736e6fu, 0x7366666fu, 0x00007465u, 0x00070006u, + 0x00000343u, 0x00000009u, 0x6c616373u, 0x6f5f7365u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000343u, + 0x0000000au, 0x6f6c6f63u, 0x6f5f7372u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000343u, 0x0000000bu, + 0x646e6572u, 0x665f7265u, 0x7367616cu, 0x00000000u, 0x00050006u, 0x00000343u, 0x0000000cu, 0x6461705fu, + 0x00000032u, 0x00050006u, 0x00000343u, 0x0000000du, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000343u, + 0x0000000eu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x00000343u, 0x0000000fu, 0x6461705fu, 0x00000035u, + 0x00070005u, 0x00000345u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x66667542u, 0x00007265u, 0x00080006u, + 0x00000345u, 0x00000000u, 0x626f5f67u, 0x63617473u, 0x705f656cu, 0x736c6f6fu, 0x00000000u, 0x00030005u, + 0x00000347u, 0x00000000u, 0x00030047u, 0x000000d5u, 0x00000002u, 0x00050048u, 0x000000d5u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00050048u, 0x000000d5u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, + 0x000000d5u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x000000d5u, 0x00000003u, 0x00000023u, + 0x0000000cu, 0x00050048u, 0x000000d5u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x000000d5u, + 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x000000d5u, 0x00000006u, 0x00000023u, 0x00000018u, + 0x00050048u, 0x000000d5u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x000000d5u, 0x00000008u, + 0x00000023u, 0x00000020u, 0x00050048u, 0x000000d5u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, + 0x000000d5u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x000000d5u, 0x0000000bu, 0x00000023u, + 0x0000002cu, 0x00050048u, 0x000000d5u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x000000d5u, + 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x000000d5u, 0x0000000eu, 0x00000023u, 0x00000038u, + 0x00050048u, 0x000000d5u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x000000d5u, 0x00000010u, + 0x00000023u, 0x00000040u, 0x00050048u, 0x000000d5u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00050048u, + 0x000000d5u, 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x000000d5u, 0x00000013u, 0x00000023u, + 0x0000004cu, 0x00050048u, 0x000000d5u, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, 0x000000d5u, + 0x00000015u, 0x00000023u, 0x00000054u, 0x00050048u, 0x000000d5u, 0x00000016u, 0x00000023u, 0x00000058u, + 0x00040047u, 0x000000eau, 0x00000006u, 0x00000010u, 0x00030047u, 0x000000ebu, 0x00000002u, 0x00040048u, + 0x000000ebu, 0x00000000u, 0x00000018u, 0x00050048u, 0x000000ebu, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x000000edu, 0x00000018u, 0x00040047u, 0x000000edu, 0x00000021u, 0x0000000au, 0x00040047u, + 0x000000edu, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000173u, 0x00000006u, 0x00000008u, 0x00030047u, + 0x00000174u, 0x00000002u, 0x00040048u, 0x00000174u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000174u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000176u, 0x00000018u, 0x00040047u, 0x00000176u, + 0x00000021u, 0x00000000u, 0x00040047u, 0x00000176u, 0x00000022u, 0x00000000u, 0x00040047u, 0x000001bau, + 0x0000000bu, 0x0000001au, 0x00050048u, 0x000001e2u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, + 0x000001e2u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000001e2u, 0x00000002u, 0x00000023u, + 0x00000008u, 0x00050048u, 0x000001e2u, 0x00000003u, 0x00000023u, 0x00000010u, 0x00050048u, 0x000001e2u, + 0x00000004u, 0x00000023u, 0x00000014u, 0x00050048u, 0x000001e2u, 0x00000005u, 0x00000023u, 0x00000018u, + 0x00050048u, 0x000001e2u, 0x00000006u, 0x00000023u, 0x0000001cu, 0x00040047u, 0x000001e3u, 0x00000006u, + 0x00000020u, 0x00030047u, 0x000001e4u, 0x00000002u, 0x00040048u, 0x000001e4u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x000001e4u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000001e6u, 0x00000018u, + 0x00040047u, 0x000001e6u, 0x00000021u, 0x0000000du, 0x00040047u, 0x000001e6u, 0x00000022u, 0x00000000u, + 0x00040047u, 0x000001f0u, 0x00000006u, 0x00000004u, 0x00050048u, 0x000001f1u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x000001f1u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000001f1u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x000001f1u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x000001f1u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x000001f1u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x000001f1u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x000001f1u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x000001f1u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x000001f1u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x000001f1u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x000001f1u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x000001f1u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00040047u, 0x000001f2u, 0x00000006u, + 0x00000080u, 0x00030047u, 0x000001f3u, 0x00000002u, 0x00040048u, 0x000001f3u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x000001f3u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000001f5u, 0x00000018u, + 0x00040047u, 0x000001f5u, 0x00000021u, 0x00000006u, 0x00040047u, 0x000001f5u, 0x00000022u, 0x00000000u, + 0x00050048u, 0x00000208u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000208u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000208u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000208u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000208u, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x00000208u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000208u, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000208u, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x00000208u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000208u, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x00000208u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x00000208u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000208u, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00050048u, 0x00000208u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000208u, + 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000208u, 0x0000000fu, 0x00000023u, 0x0000003cu, + 0x00040047u, 0x00000209u, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000020au, 0x00000002u, 0x00040048u, + 0x0000020au, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000020au, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x0000020cu, 0x00000018u, 0x00040047u, 0x0000020cu, 0x00000021u, 0x00000007u, 0x00040047u, + 0x0000020cu, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000231u, 0x00000006u, 0x00000004u, 0x00030047u, + 0x00000232u, 0x00000002u, 0x00040048u, 0x00000232u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000232u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000234u, 0x00000018u, 0x00040047u, 0x00000234u, + 0x00000021u, 0x00000001u, 0x00040047u, 0x00000234u, 0x00000022u, 0x00000000u, 0x00050048u, 0x0000026cu, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000026cu, 0x00000001u, 0x00000023u, 0x00000004u, + 0x00050048u, 0x0000026cu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000026cu, 0x00000003u, + 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000026cu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, + 0x0000026cu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000026cu, 0x00000006u, 0x00000023u, + 0x00000018u, 0x00050048u, 0x0000026cu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000026cu, + 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000026cu, 0x00000009u, 0x00000023u, 0x00000024u, + 0x00050048u, 0x0000026cu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000026cu, 0x0000000bu, + 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000026cu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, + 0x0000026cu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000026cu, 0x0000000eu, 0x00000023u, + 0x00000038u, 0x00050048u, 0x0000026cu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x0000026cu, + 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x0000026cu, 0x00000011u, 0x00000023u, 0x00000044u, + 0x00040047u, 0x0000026du, 0x00000006u, 0x00000048u, 0x00030047u, 0x0000026eu, 0x00000002u, 0x00040048u, + 0x0000026eu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000026eu, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x00000270u, 0x00000018u, 0x00040047u, 0x00000270u, 0x00000021u, 0x0000000bu, 0x00040047u, + 0x00000270u, 0x00000022u, 0x00000000u, 0x00040048u, 0x0000027bu, 0x00000000u, 0x00000005u, 0x00050048u, + 0x0000027bu, 0x00000000u, 0x00000007u, 0x00000010u, 0x00050048u, 0x0000027bu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00040047u, 0x0000027cu, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000027du, 0x00000002u, + 0x00040048u, 0x0000027du, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000027du, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000027fu, 0x00000018u, 0x00040047u, 0x0000027fu, 0x00000021u, 0x0000000cu, + 0x00040047u, 0x0000027fu, 0x00000022u, 0x00000000u, 0x00040047u, 0x0000029fu, 0x00000006u, 0x00000004u, + 0x00030047u, 0x000002a0u, 0x00000002u, 0x00040048u, 0x000002a0u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x000002a0u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000002a2u, 0x00000018u, 0x00040047u, + 0x000002a2u, 0x00000021u, 0x00000005u, 0x00040047u, 0x000002a2u, 0x00000022u, 0x00000000u, 0x00050048u, + 0x00000331u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000331u, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x00000331u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000331u, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00040047u, 0x00000332u, 0x00000006u, 0x00000010u, 0x00030047u, + 0x00000333u, 0x00000002u, 0x00040048u, 0x00000333u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000333u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000335u, 0x00000018u, 0x00040047u, 0x00000335u, + 0x00000021u, 0x00000002u, 0x00040047u, 0x00000335u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000336u, + 0x00000006u, 0x00000010u, 0x00030047u, 0x00000337u, 0x00000002u, 0x00040048u, 0x00000337u, 0x00000000u, + 0x00000018u, 0x00050048u, 0x00000337u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000339u, + 0x00000018u, 0x00040047u, 0x00000339u, 0x00000021u, 0x00000003u, 0x00040047u, 0x00000339u, 0x00000022u, + 0x00000000u, 0x00040047u, 0x0000033au, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000033bu, 0x00000002u, + 0x00040048u, 0x0000033bu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000033bu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000033du, 0x00000018u, 0x00040047u, 0x0000033du, 0x00000021u, 0x00000004u, + 0x00040047u, 0x0000033du, 0x00000022u, 0x00000000u, 0x00050048u, 0x0000033eu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x0000033eu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x0000033eu, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000033eu, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x0000033eu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000033eu, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x0000033eu, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x0000033eu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000033eu, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x0000033eu, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x0000033eu, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000033eu, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x0000033eu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x0000033eu, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x0000033eu, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x0000033eu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x0000033fu, 0x00000006u, 0x00000040u, + 0x00030047u, 0x00000340u, 0x00000002u, 0x00040048u, 0x00000340u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x00000340u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000342u, 0x00000018u, 0x00040047u, + 0x00000342u, 0x00000021u, 0x00000008u, 0x00040047u, 0x00000342u, 0x00000022u, 0x00000000u, 0x00050048u, + 0x00000343u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000343u, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x00000343u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000343u, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000343u, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x00000343u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000343u, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x00000343u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x00000343u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000343u, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x00000343u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000343u, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000343u, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x00000343u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000343u, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x00000343u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, + 0x00000344u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000345u, 0x00000002u, 0x00040048u, 0x00000345u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x00000345u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x00000347u, 0x00000018u, 0x00040047u, 0x00000347u, 0x00000021u, 0x00000009u, 0x00040047u, 0x00000347u, + 0x00000022u, 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00040015u, + 0x00000006u, 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000006u, 0x00000007u, 0x00000001u, 0x00040020u, + 0x00000008u, 0x00000007u, 0x00000006u, 0x00030016u, 0x00000009u, 0x00000020u, 0x00040017u, 0x0000000au, + 0x00000009u, 0x00000003u, 0x00040021u, 0x0000000bu, 0x0000000au, 0x00000008u, 0x00020014u, 0x00000012u, + 0x00040021u, 0x00000013u, 0x00000012u, 0x00000008u, 0x00050021u, 0x00000017u, 0x00000009u, 0x00000008u, + 0x00000008u, 0x00040015u, 0x0000001cu, 0x00000040u, 0x00000001u, 0x00040020u, 0x0000001du, 0x00000007u, + 0x0000001cu, 0x00040015u, 0x0000001eu, 0x00000020u, 0x00000001u, 0x00060021u, 0x0000001fu, 0x0000001eu, + 0x00000008u, 0x00000008u, 0x0000001du, 0x00040020u, 0x00000025u, 0x00000007u, 0x0000000au, 0x00070021u, + 0x00000026u, 0x00000012u, 0x00000025u, 0x00000025u, 0x00000025u, 0x00000025u, 0x00040017u, 0x0000002du, + 0x00000009u, 0x00000004u, 0x00040018u, 0x0000002eu, 0x0000002du, 0x00000004u, 0x0003001eu, 0x0000002fu, + 0x0000002eu, 0x00040020u, 0x00000030u, 0x00000007u, 0x0000002fu, 0x00040021u, 0x00000031u, 0x0000000au, + 0x00000030u, 0x0004002bu, 0x00000006u, 0x00000036u, 0x00000000u, 0x0004002bu, 0x00000009u, 0x0000003au, + 0x3f7dfdfeu, 0x0004002bu, 0x00000009u, 0x0000003bu, 0x3b808081u, 0x0004002bu, 0x00000009u, 0x0000003cu, + 0x3f68e8e9u, 0x0006002cu, 0x0000000au, 0x0000003du, 0x0000003au, 0x0000003bu, 0x0000003cu, 0x0004002bu, + 0x00000009u, 0x00000043u, 0x3ec4c4c5u, 0x0004002bu, 0x00000009u, 0x00000044u, 0x3f37b7b8u, 0x0004002bu, + 0x00000009u, 0x00000045u, 0x3f79f9fau, 0x0006002cu, 0x0000000au, 0x00000046u, 0x00000043u, 0x00000044u, + 0x00000045u, 0x0004002bu, 0x00000006u, 0x00000049u, 0x00000002u, 0x0004002bu, 0x00000009u, 0x0000004du, + 0x3f0b8b8cu, 0x0004002bu, 0x00000009u, 0x0000004eu, 0x3ebababbu, 0x0004002bu, 0x00000009u, 0x0000004fu, + 0x3f800000u, 0x0006002cu, 0x0000000au, 0x00000050u, 0x0000004du, 0x0000004eu, 0x0000004fu, 0x0004002bu, + 0x00000006u, 0x00000053u, 0x00000003u, 0x0004002bu, 0x00000009u, 0x00000057u, 0x3ec8c8c9u, 0x0004002bu, + 0x00000009u, 0x00000058u, 0x00000000u, 0x0006002cu, 0x0000000au, 0x00000059u, 0x0000004fu, 0x00000057u, + 0x00000058u, 0x0004002bu, 0x00000006u, 0x0000005cu, 0x00000004u, 0x0006002cu, 0x0000000au, 0x00000060u, + 0x00000058u, 0x0000004fu, 0x00000058u, 0x0004002bu, 0x00000006u, 0x00000063u, 0x00000007u, 0x0004002bu, + 0x00000009u, 0x00000067u, 0x3ed8d8d9u, 0x0004002bu, 0x00000009u, 0x00000068u, 0x3f33b3b4u, 0x0004002bu, + 0x00000009u, 0x00000069u, 0x3e6cecedu, 0x0006002cu, 0x0000000au, 0x0000006au, 0x00000067u, 0x00000068u, + 0x00000069u, 0x0004002bu, 0x00000006u, 0x0000006du, 0x00000008u, 0x0004002bu, 0x00000009u, 0x00000071u, + 0x3e8a8a8bu, 0x0004002bu, 0x00000009u, 0x00000072u, 0x3f31b1b2u, 0x0006002cu, 0x0000000au, 0x00000073u, + 0x00000044u, 0x00000071u, 0x00000072u, 0x0004002bu, 0x00000006u, 0x00000076u, 0x00000009u, 0x0004002bu, + 0x00000009u, 0x0000007au, 0x3da0a0a1u, 0x0004002bu, 0x00000009u, 0x0000007bu, 0x3f7efeffu, 0x0004002bu, + 0x00000009u, 0x0000007cu, 0x3f39b9bau, 0x0006002cu, 0x0000000au, 0x0000007du, 0x0000007au, 0x0000007bu, + 0x0000007cu, 0x0004002bu, 0x00000006u, 0x00000080u, 0x0000000au, 0x0004002bu, 0x00000006u, 0x00000086u, + 0x0000000bu, 0x0006002cu, 0x0000000au, 0x0000008au, 0x00000057u, 0x00000057u, 0x00000057u, 0x0004002bu, + 0x00000006u, 0x0000008du, 0x0000000cu, 0x0004002bu, 0x00000009u, 0x00000091u, 0x3d008081u, 0x0004002bu, + 0x00000009u, 0x00000092u, 0x3c008081u, 0x0006002cu, 0x0000000au, 0x00000093u, 0x00000091u, 0x00000092u, + 0x0000004fu, 0x0004002bu, 0x00000006u, 0x00000096u, 0x0000000du, 0x0004002bu, 0x00000009u, 0x0000009au, + 0x3ea0a0a1u, 0x0004002bu, 0x00000009u, 0x0000009bu, 0x3ef0f0f1u, 0x0006002cu, 0x0000000au, 0x0000009cu, + 0x0000009au, 0x0000009au, 0x0000009bu, 0x0004002bu, 0x00000006u, 0x0000009fu, 0x0000000eu, 0x0004002bu, + 0x00000009u, 0x000000a3u, 0x3e70f0f1u, 0x0006002cu, 0x0000000au, 0x000000a4u, 0x000000a3u, 0x0000009bu, + 0x000000a3u, 0x0004002bu, 0x00000006u, 0x000000a7u, 0x0000000fu, 0x0006002cu, 0x0000000au, 0x000000abu, + 0x0000009bu, 0x0000009au, 0x0000009au, 0x0004002bu, 0x00000006u, 0x000000aeu, 0x00000010u, 0x0006002cu, + 0x0000000au, 0x000000b2u, 0x0000004fu, 0x0000004fu, 0x0000004fu, 0x0004002bu, 0x00000006u, 0x000000b5u, + 0x00000011u, 0x0004002bu, 0x00000006u, 0x000000bbu, 0x00000012u, 0x0006002cu, 0x0000000au, 0x000000bfu, + 0x0000004fu, 0x0000004fu, 0x00000058u, 0x0004002bu, 0x00000006u, 0x000000c2u, 0x00000013u, 0x0004002bu, + 0x00000006u, 0x000000c8u, 0x00000014u, 0x0004002bu, 0x00000006u, 0x000000ceu, 0x00000015u, 0x0019001eu, + 0x000000d5u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x0000001eu, 0x0000001eu, 0x00000006u, 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000009u, + 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00040020u, 0x000000d6u, 0x00000009u, 0x000000d5u, 0x0004003bu, 0x000000d6u, 0x000000d7u, 0x00000009u, + 0x0004002bu, 0x0000001eu, 0x000000d8u, 0x00000008u, 0x00040020u, 0x000000d9u, 0x00000009u, 0x0000001eu, + 0x0004002bu, 0x0000001eu, 0x000000dcu, 0x00000000u, 0x00040020u, 0x000000e8u, 0x00000007u, 0x0000002du, + 0x0003001du, 0x000000eau, 0x0000002du, 0x0003001eu, 0x000000ebu, 0x000000eau, 0x00040020u, 0x000000ecu, + 0x0000000cu, 0x000000ebu, 0x0004003bu, 0x000000ecu, 0x000000edu, 0x0000000cu, 0x00040020u, 0x000000efu, + 0x0000000cu, 0x0000002du, 0x00040020u, 0x000000f2u, 0x00000007u, 0x00000009u, 0x00040020u, 0x00000107u, + 0x00000007u, 0x00000012u, 0x0004002bu, 0x0000001eu, 0x0000010cu, 0x00000005u, 0x00040020u, 0x0000010du, + 0x00000009u, 0x00000009u, 0x0004002bu, 0x00000009u, 0x0000011eu, 0x40a00000u, 0x0004002bu, 0x00000009u, + 0x0000011fu, 0x41400000u, 0x0004002bu, 0x0000001eu, 0x00000126u, 0x00000003u, 0x0004002bu, 0x0000001eu, + 0x0000012au, 0x00000002u, 0x0004002bu, 0x00000009u, 0x0000013au, 0x40400000u, 0x0004002bu, 0x00000009u, + 0x0000013fu, 0x40800000u, 0x0004002bu, 0x00000009u, 0x00000140u, 0x40e00000u, 0x0004002bu, 0x0000001eu, + 0x00000147u, 0x00000001u, 0x0004002bu, 0x0000001eu, 0x0000015cu, 0xffffffffu, 0x00040020u, 0x0000015eu, + 0x00000007u, 0x0000001eu, 0x0003001du, 0x00000173u, 0x0000001cu, 0x0003001eu, 0x00000174u, 0x00000173u, + 0x00040020u, 0x00000175u, 0x0000000cu, 0x00000174u, 0x0004003bu, 0x00000175u, 0x00000176u, 0x0000000cu, + 0x00040020u, 0x0000017bu, 0x0000000cu, 0x0000001cu, 0x00040017u, 0x0000018eu, 0x00000012u, 0x00000003u, + 0x00040018u, 0x0000019au, 0x0000000au, 0x00000003u, 0x00040020u, 0x0000019bu, 0x00000007u, 0x0000019au, + 0x00040020u, 0x0000019du, 0x00000007u, 0x0000002eu, 0x00040017u, 0x000001b8u, 0x00000006u, 0x00000003u, + 0x00040020u, 0x000001b9u, 0x00000001u, 0x000001b8u, 0x0004003bu, 0x000001b9u, 0x000001bau, 0x00000001u, + 0x00040020u, 0x000001bbu, 0x00000001u, 0x00000006u, 0x0004002bu, 0x0000001eu, 0x000001c0u, 0x00000013u, + 0x00040020u, 0x000001c1u, 0x00000009u, 0x00000006u, 0x0004002bu, 0x0000001eu, 0x000001ccu, 0x00000014u, + 0x0004002bu, 0x0000001eu, 0x000001d6u, 0x00000009u, 0x0009001eu, 0x000001dfu, 0x00000006u, 0x00000006u, + 0x0000001cu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x000001e0u, 0x00000007u, + 0x000001dfu, 0x0009001eu, 0x000001e2u, 0x00000006u, 0x00000006u, 0x0000001cu, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x0003001du, 0x000001e3u, 0x000001e2u, 0x0003001eu, 0x000001e4u, 0x000001e3u, + 0x00040020u, 0x000001e5u, 0x0000000cu, 0x000001e4u, 0x0004003bu, 0x000001e5u, 0x000001e6u, 0x0000000cu, + 0x00040020u, 0x000001e8u, 0x0000000cu, 0x000001e2u, 0x0004001cu, 0x000001ecu, 0x00000006u, 0x000000c8u, + 0x000f001eu, 0x000001edu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x000001ecu, 0x00040020u, + 0x000001eeu, 0x00000007u, 0x000001edu, 0x0004001cu, 0x000001f0u, 0x00000006u, 0x000000c8u, 0x000f001eu, + 0x000001f1u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x000001f0u, 0x0003001du, 0x000001f2u, + 0x000001f1u, 0x0003001eu, 0x000001f3u, 0x000001f2u, 0x00040020u, 0x000001f4u, 0x0000000cu, 0x000001f3u, + 0x0004003bu, 0x000001f4u, 0x000001f5u, 0x0000000cu, 0x00040020u, 0x000001f8u, 0x0000000cu, 0x000001f1u, + 0x0012001eu, 0x00000205u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00040020u, 0x00000206u, 0x00000007u, 0x00000205u, 0x0012001eu, 0x00000208u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x0003001du, 0x00000209u, 0x00000208u, 0x0003001eu, 0x0000020au, 0x00000209u, 0x00040020u, 0x0000020bu, + 0x0000000cu, 0x0000020au, 0x0004003bu, 0x0000020bu, 0x0000020cu, 0x0000000cu, 0x00040020u, 0x00000211u, + 0x0000000cu, 0x00000208u, 0x0004002bu, 0x0000001eu, 0x00000216u, 0x00000006u, 0x0004002bu, 0x0000001eu, + 0x00000219u, 0x00000004u, 0x0003001du, 0x00000231u, 0x0000001eu, 0x0003001eu, 0x00000232u, 0x00000231u, + 0x00040020u, 0x00000233u, 0x0000000cu, 0x00000232u, 0x0004003bu, 0x00000233u, 0x00000234u, 0x0000000cu, + 0x0004002bu, 0x0000001eu, 0x00000235u, 0x00000007u, 0x00040020u, 0x0000023fu, 0x0000000cu, 0x0000001eu, + 0x0003002au, 0x00000012u, 0x00000254u, 0x00030029u, 0x00000012u, 0x0000025au, 0x0004002bu, 0x0000001eu, + 0x0000025fu, 0x0000000eu, 0x0014001eu, 0x0000026cu, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x0003001du, 0x0000026du, + 0x0000026cu, 0x0003001eu, 0x0000026eu, 0x0000026du, 0x00040020u, 0x0000026fu, 0x0000000cu, 0x0000026eu, + 0x0004003bu, 0x0000026fu, 0x00000270u, 0x0000000cu, 0x0004002bu, 0x0000001eu, 0x00000273u, 0x0000000du, + 0x00040020u, 0x00000274u, 0x0000000cu, 0x00000009u, 0x0003001eu, 0x0000027bu, 0x0000002eu, 0x0003001du, + 0x0000027cu, 0x0000027bu, 0x0003001eu, 0x0000027du, 0x0000027cu, 0x00040020u, 0x0000027eu, 0x0000000cu, + 0x0000027du, 0x0004003bu, 0x0000027eu, 0x0000027fu, 0x0000000cu, 0x00040020u, 0x00000281u, 0x0000000cu, + 0x0000027bu, 0x0004002bu, 0x0000001eu, 0x00000294u, 0x0000000bu, 0x0004002bu, 0x00000006u, 0x0000029bu, + 0x00000006u, 0x0003001du, 0x0000029fu, 0x00000009u, 0x0003001eu, 0x000002a0u, 0x0000029fu, 0x00040020u, + 0x000002a1u, 0x0000000cu, 0x000002a0u, 0x0004003bu, 0x000002a1u, 0x000002a2u, 0x0000000cu, 0x0004002bu, + 0x00000006u, 0x000002b9u, 0x00000005u, 0x000a001eu, 0x0000030du, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000009u, 0x0000000au, 0x00000006u, 0x00000009u, 0x00040020u, 0x0000030eu, 0x0000151au, + 0x0000030du, 0x0004003bu, 0x0000030eu, 0x0000030fu, 0x0000151au, 0x00040020u, 0x00000311u, 0x0000151au, + 0x00000006u, 0x00040020u, 0x00000320u, 0x0000151au, 0x00000009u, 0x00040020u, 0x00000326u, 0x0000151au, + 0x0000000au, 0x0004002bu, 0x00000009u, 0x00000330u, 0x40000000u, 0x0006001eu, 0x00000331u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x0003001du, 0x00000332u, 0x00000331u, 0x0003001eu, 0x00000333u, + 0x00000332u, 0x00040020u, 0x00000334u, 0x0000000cu, 0x00000333u, 0x0004003bu, 0x00000334u, 0x00000335u, + 0x0000000cu, 0x0003001du, 0x00000336u, 0x000001b8u, 0x0003001eu, 0x00000337u, 0x00000336u, 0x00040020u, + 0x00000338u, 0x0000000cu, 0x00000337u, 0x0004003bu, 0x00000338u, 0x00000339u, 0x0000000cu, 0x0003001du, + 0x0000033au, 0x0000027bu, 0x0003001eu, 0x0000033bu, 0x0000033au, 0x00040020u, 0x0000033cu, 0x0000000cu, + 0x0000033bu, 0x0004003bu, 0x0000033cu, 0x0000033du, 0x0000000cu, 0x0012001eu, 0x0000033eu, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, + 0x0000033fu, 0x0000033eu, 0x0003001eu, 0x00000340u, 0x0000033fu, 0x00040020u, 0x00000341u, 0x0000000cu, + 0x00000340u, 0x0004003bu, 0x00000341u, 0x00000342u, 0x0000000cu, 0x0012001eu, 0x00000343u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, + 0x00000344u, 0x00000343u, 0x0003001eu, 0x00000345u, 0x00000344u, 0x00040020u, 0x00000346u, 0x0000000cu, + 0x00000345u, 0x0004003bu, 0x00000346u, 0x00000347u, 0x0000000cu, 0x0006002cu, 0x000001b8u, 0x00000348u, + 0x00000007u, 0x00000007u, 0x00000007u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, + 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000008u, 0x000001b6u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x000001b7u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000001beu, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x000001c5u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000001cau, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x000001d0u, 0x00000007u, 0x0004003bu, 0x000001e0u, 0x000001e1u, 0x00000007u, 0x0004003bu, 0x000001eeu, + 0x000001efu, 0x00000007u, 0x0004003bu, 0x00000206u, 0x00000207u, 0x00000007u, 0x0004003bu, 0x0000015eu, + 0x00000215u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x0000021du, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x0000021eu, 0x00000007u, 0x0004003bu, 0x0000001du, 0x00000221u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x0000022cu, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000243u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x0000024fu, 0x00000007u, 0x0004003bu, 0x00000107u, 0x00000253u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x0000025bu, 0x00000007u, 0x0004003bu, 0x000000f2u, 0x0000026bu, 0x00000007u, 0x0004003bu, 0x00000030u, + 0x0000027au, 0x00000007u, 0x0004003bu, 0x00000025u, 0x00000285u, 0x00000007u, 0x0004003bu, 0x00000030u, + 0x00000286u, 0x00000007u, 0x0004003bu, 0x00000025u, 0x00000289u, 0x00000007u, 0x0004003bu, 0x00000025u, + 0x0000028eu, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000293u, 0x00000007u, 0x0004003bu, 0x00000025u, + 0x0000029eu, 0x00000007u, 0x0004003bu, 0x00000025u, 0x000002afu, 0x00000007u, 0x0004003bu, 0x00000025u, + 0x000002beu, 0x00000007u, 0x0004003bu, 0x00000025u, 0x000002c0u, 0x00000007u, 0x0004003bu, 0x00000025u, + 0x000002c2u, 0x00000007u, 0x0004003bu, 0x00000025u, 0x000002c4u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x000002cau, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000002dau, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x000002e5u, 0x00000007u, 0x0004003bu, 0x00000107u, 0x000002e9u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x000002eau, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000002f1u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x00000300u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000303u, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x00000319u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x0000031cu, 0x00000007u, 0x0004003bu, 0x00000008u, + 0x00000322u, 0x00000007u, 0x0003003eu, 0x000001b6u, 0x00000036u, 0x00050041u, 0x000001bbu, 0x000001bcu, + 0x000001bau, 0x00000036u, 0x0004003du, 0x00000006u, 0x000001bdu, 0x000001bcu, 0x0003003eu, 0x000001b7u, + 0x000001bdu, 0x0004003du, 0x00000006u, 0x000001bfu, 0x000001b7u, 0x00050041u, 0x000001c1u, 0x000001c2u, + 0x000000d7u, 0x000001c0u, 0x0004003du, 0x00000006u, 0x000001c3u, 0x000001c2u, 0x00050089u, 0x00000006u, + 0x000001c4u, 0x000001bfu, 0x000001c3u, 0x0003003eu, 0x000001beu, 0x000001c4u, 0x0004003du, 0x00000006u, + 0x000001c6u, 0x000001b7u, 0x00050041u, 0x000001c1u, 0x000001c7u, 0x000000d7u, 0x000001c0u, 0x0004003du, + 0x00000006u, 0x000001c8u, 0x000001c7u, 0x00050086u, 0x00000006u, 0x000001c9u, 0x000001c6u, 0x000001c8u, + 0x0003003eu, 0x000001c5u, 0x000001c9u, 0x0004003du, 0x00000006u, 0x000001cbu, 0x000001c5u, 0x00050041u, + 0x000001c1u, 0x000001cdu, 0x000000d7u, 0x000001ccu, 0x0004003du, 0x00000006u, 0x000001ceu, 0x000001cdu, + 0x00050089u, 0x00000006u, 0x000001cfu, 0x000001cbu, 0x000001ceu, 0x0003003eu, 0x000001cau, 0x000001cfu, + 0x0004003du, 0x00000006u, 0x000001d1u, 0x000001c5u, 0x00050041u, 0x000001c1u, 0x000001d2u, 0x000000d7u, + 0x000001ccu, 0x0004003du, 0x00000006u, 0x000001d3u, 0x000001d2u, 0x00050086u, 0x00000006u, 0x000001d4u, + 0x000001d1u, 0x000001d3u, 0x0003003eu, 0x000001d0u, 0x000001d4u, 0x0004003du, 0x00000006u, 0x000001d5u, + 0x000001d0u, 0x00050041u, 0x000001c1u, 0x000001d7u, 0x000000d7u, 0x000001d6u, 0x0004003du, 0x00000006u, + 0x000001d8u, 0x000001d7u, 0x000500aeu, 0x00000012u, 0x000001d9u, 0x000001d5u, 0x000001d8u, 0x000300f7u, + 0x000001dbu, 0x00000000u, 0x000400fau, 0x000001d9u, 0x000001dau, 0x000001dbu, 0x000200f8u, 0x000001dau, + 0x0003003eu, 0x000001b6u, 0x00000036u, 0x0004003du, 0x00000006u, 0x000001dcu, 0x000001b6u, 0x000414aeu, + 0x000001dcu, 0x00000007u, 0x00000007u, 0x000200f8u, 0x000001dbu, 0x0004003du, 0x00000006u, 0x000001e7u, + 0x000001d0u, 0x00060041u, 0x000001e8u, 0x000001e9u, 0x000001e6u, 0x000000dcu, 0x000001e7u, 0x0004003du, + 0x000001e2u, 0x000001eau, 0x000001e9u, 0x00040190u, 0x000001dfu, 0x000001ebu, 0x000001eau, 0x0003003eu, + 0x000001e1u, 0x000001ebu, 0x00050041u, 0x00000008u, 0x000001f6u, 0x000001e1u, 0x000000dcu, 0x0004003du, + 0x00000006u, 0x000001f7u, 0x000001f6u, 0x00060041u, 0x000001f8u, 0x000001f9u, 0x000001f5u, 0x000000dcu, + 0x000001f7u, 0x0004003du, 0x000001f1u, 0x000001fau, 0x000001f9u, 0x00040190u, 0x000001edu, 0x000001fbu, + 0x000001fau, 0x0003003eu, 0x000001efu, 0x000001fbu, 0x0004003du, 0x00000006u, 0x000001fcu, 0x000001cau, + 0x00050041u, 0x00000008u, 0x000001fdu, 0x000001efu, 0x000000dcu, 0x0004003du, 0x00000006u, 0x000001feu, + 0x000001fdu, 0x000500aeu, 0x00000012u, 0x000001ffu, 0x000001fcu, 0x000001feu, 0x000300f7u, 0x00000201u, + 0x00000000u, 0x000400fau, 0x000001ffu, 0x00000200u, 0x00000201u, 0x000200f8u, 0x00000200u, 0x0003003eu, + 0x000001b6u, 0x00000036u, 0x0004003du, 0x00000006u, 0x00000202u, 0x000001b6u, 0x000414aeu, 0x00000202u, + 0x00000007u, 0x00000007u, 0x000200f8u, 0x00000201u, 0x00050041u, 0x00000008u, 0x0000020du, 0x000001efu, + 0x00000147u, 0x0004003du, 0x00000006u, 0x0000020eu, 0x0000020du, 0x0004003du, 0x00000006u, 0x0000020fu, + 0x000001cau, 0x00050080u, 0x00000006u, 0x00000210u, 0x0000020eu, 0x0000020fu, 0x00060041u, 0x00000211u, + 0x00000212u, 0x0000020cu, 0x000000dcu, 0x00000210u, 0x0004003du, 0x00000208u, 0x00000213u, 0x00000212u, + 0x00040190u, 0x00000205u, 0x00000214u, 0x00000213u, 0x0003003eu, 0x00000207u, 0x00000214u, 0x00050041u, + 0x00000008u, 0x00000217u, 0x000001efu, 0x00000216u, 0x0004003du, 0x00000006u, 0x00000218u, 0x00000217u, + 0x00050041u, 0x00000008u, 0x0000021au, 0x00000207u, 0x00000219u, 0x0004003du, 0x00000006u, 0x0000021bu, + 0x0000021au, 0x00050080u, 0x00000006u, 0x0000021cu, 0x00000218u, 0x0000021bu, 0x0003003eu, 0x0000021du, + 0x0000021cu, 0x00050041u, 0x00000008u, 0x0000021fu, 0x00000207u, 0x000000dcu, 0x0004003du, 0x00000006u, + 0x00000220u, 0x0000021fu, 0x0003003eu, 0x0000021eu, 0x00000220u, 0x00050041u, 0x0000001du, 0x00000222u, + 0x000001e1u, 0x0000012au, 0x0004003du, 0x0000001cu, 0x00000223u, 0x00000222u, 0x0003003eu, 0x00000221u, + 0x00000223u, 0x00070039u, 0x0000001eu, 0x00000224u, 0x00000023u, 0x0000021du, 0x0000021eu, 0x00000221u, + 0x0003003eu, 0x00000215u, 0x00000224u, 0x0004003du, 0x0000001eu, 0x00000225u, 0x00000215u, 0x000500b1u, + 0x00000012u, 0x00000226u, 0x00000225u, 0x000000dcu, 0x000300f7u, 0x00000228u, 0x00000000u, 0x000400fau, + 0x00000226u, 0x00000227u, 0x00000228u, 0x000200f8u, 0x00000227u, 0x0003003eu, 0x000001b6u, 0x00000036u, + 0x0004003du, 0x00000006u, 0x00000229u, 0x000001b6u, 0x000414aeu, 0x00000229u, 0x00000007u, 0x00000007u, + 0x000200f8u, 0x00000228u, 0x0003003eu, 0x0000022cu, 0x00000036u, 0x0004003du, 0x0000001eu, 0x0000022du, + 0x00000215u, 0x000500adu, 0x00000012u, 0x0000022eu, 0x0000022du, 0x000000dcu, 0x000300f7u, 0x00000230u, + 0x00000000u, 0x000400fau, 0x0000022eu, 0x0000022fu, 0x00000230u, 0x000200f8u, 0x0000022fu, 0x00050041u, + 0x00000008u, 0x00000236u, 0x000001efu, 0x00000235u, 0x0004003du, 0x00000006u, 0x00000237u, 0x00000236u, + 0x00050041u, 0x00000008u, 0x00000238u, 0x00000207u, 0x0000010cu, 0x0004003du, 0x00000006u, 0x00000239u, + 0x00000238u, 0x00050080u, 0x00000006u, 0x0000023au, 0x00000237u, 0x00000239u, 0x0004003du, 0x0000001eu, + 0x0000023bu, 0x00000215u, 0x0004007cu, 0x00000006u, 0x0000023cu, 0x0000023bu, 0x00050080u, 0x00000006u, + 0x0000023du, 0x0000023au, 0x0000023cu, 0x00050082u, 0x00000006u, 0x0000023eu, 0x0000023du, 0x00000007u, + 0x00060041u, 0x0000023fu, 0x00000240u, 0x00000234u, 0x000000dcu, 0x0000023eu, 0x0004003du, 0x0000001eu, + 0x00000241u, 0x00000240u, 0x0004007cu, 0x00000006u, 0x00000242u, 0x00000241u, 0x0003003eu, 0x0000022cu, + 0x00000242u, 0x000200f9u, 0x00000230u, 0x000200f8u, 0x00000230u, 0x00050041u, 0x00000008u, 0x00000244u, + 0x000001efu, 0x00000235u, 0x0004003du, 0x00000006u, 0x00000245u, 0x00000244u, 0x00050041u, 0x00000008u, + 0x00000246u, 0x00000207u, 0x0000010cu, 0x0004003du, 0x00000006u, 0x00000247u, 0x00000246u, 0x00050080u, + 0x00000006u, 0x00000248u, 0x00000245u, 0x00000247u, 0x0004003du, 0x0000001eu, 0x00000249u, 0x00000215u, + 0x0004007cu, 0x00000006u, 0x0000024au, 0x00000249u, 0x00050080u, 0x00000006u, 0x0000024bu, 0x00000248u, + 0x0000024au, 0x00060041u, 0x0000023fu, 0x0000024cu, 0x00000234u, 0x000000dcu, 0x0000024bu, 0x0004003du, + 0x0000001eu, 0x0000024du, 0x0000024cu, 0x0004007cu, 0x00000006u, 0x0000024eu, 0x0000024du, 0x0003003eu, + 0x00000243u, 0x0000024eu, 0x0004003du, 0x00000006u, 0x00000250u, 0x00000243u, 0x0004003du, 0x00000006u, + 0x00000251u, 0x0000022cu, 0x00050082u, 0x00000006u, 0x00000252u, 0x00000250u, 0x00000251u, 0x0003003eu, + 0x0000024fu, 0x00000252u, 0x0003003eu, 0x00000253u, 0x00000254u, 0x0004003du, 0x00000006u, 0x00000255u, + 0x000001beu, 0x0004003du, 0x00000006u, 0x00000256u, 0x0000024fu, 0x000500aeu, 0x00000012u, 0x00000257u, + 0x00000255u, 0x00000256u, 0x000300f7u, 0x00000259u, 0x00000000u, 0x000400fau, 0x00000257u, 0x00000258u, + 0x00000259u, 0x000200f8u, 0x00000258u, 0x0003003eu, 0x00000253u, 0x0000025au, 0x0003003eu, 0x000001beu, + 0x00000036u, 0x000200f9u, 0x00000259u, 0x000200f8u, 0x00000259u, 0x0004003du, 0x00000006u, 0x0000025cu, + 0x0000022cu, 0x0004003du, 0x00000006u, 0x0000025du, 0x000001beu, 0x00050080u, 0x00000006u, 0x0000025eu, + 0x0000025cu, 0x0000025du, 0x0003003eu, 0x0000025bu, 0x0000025eu, 0x00050041u, 0x0000010du, 0x00000260u, + 0x000000d7u, 0x0000025fu, 0x0004003du, 0x00000009u, 0x00000261u, 0x00000260u, 0x000500bau, 0x00000012u, + 0x00000262u, 0x00000261u, 0x00000058u, 0x000300f7u, 0x00000264u, 0x00000000u, 0x000400fau, 0x00000262u, + 0x00000263u, 0x00000264u, 0x000200f8u, 0x00000263u, 0x00050041u, 0x00000008u, 0x00000265u, 0x00000207u, + 0x000000d8u, 0x0004003du, 0x00000006u, 0x00000266u, 0x00000265u, 0x000500abu, 0x00000012u, 0x00000267u, + 0x00000266u, 0x00000036u, 0x000200f9u, 0x00000264u, 0x000200f8u, 0x00000264u, 0x000700f5u, 0x00000012u, + 0x00000268u, 0x00000262u, 0x00000259u, 0x00000267u, 0x00000263u, 0x000300f7u, 0x0000026au, 0x00000000u, + 0x000400fau, 0x00000268u, 0x00000269u, 0x0000026au, 0x000200f8u, 0x00000269u, 0x00050041u, 0x00000008u, + 0x00000271u, 0x000001e1u, 0x00000147u, 0x0004003du, 0x00000006u, 0x00000272u, 0x00000271u, 0x00070041u, + 0x00000274u, 0x00000275u, 0x00000270u, 0x000000dcu, 0x00000272u, 0x00000273u, 0x0004003du, 0x00000009u, + 0x00000276u, 0x00000275u, 0x00050041u, 0x0000010du, 0x00000277u, 0x000000d7u, 0x0000025fu, 0x0004003du, + 0x00000009u, 0x00000278u, 0x00000277u, 0x00050085u, 0x00000009u, 0x00000279u, 0x00000276u, 0x00000278u, + 0x0003003eu, 0x0000026bu, 0x00000279u, 0x0004003du, 0x00000006u, 0x00000280u, 0x000001d0u, 0x00060041u, + 0x00000281u, 0x00000282u, 0x0000027fu, 0x000000dcu, 0x00000280u, 0x0004003du, 0x0000027bu, 0x00000283u, + 0x00000282u, 0x00040190u, 0x0000002fu, 0x00000284u, 0x00000283u, 0x0003003eu, 0x0000027au, 0x00000284u, + 0x0004003du, 0x0000002fu, 0x00000287u, 0x0000027au, 0x0003003eu, 0x00000286u, 0x00000287u, 0x00050039u, + 0x0000000au, 0x00000288u, 0x00000033u, 0x00000286u, 0x0003003eu, 0x00000285u, 0x00000288u, 0x0004003du, + 0x0000000au, 0x0000028au, 0x00000285u, 0x0004003du, 0x00000009u, 0x0000028bu, 0x0000026bu, 0x00060050u, + 0x0000000au, 0x0000028cu, 0x0000028bu, 0x0000028bu, 0x0000028bu, 0x00050083u, 0x0000000au, 0x0000028du, + 0x0000028au, 0x0000028cu, 0x0003003eu, 0x00000289u, 0x0000028du, 0x0004003du, 0x0000000au, 0x0000028fu, + 0x00000285u, 0x0004003du, 0x00000009u, 0x00000290u, 0x0000026bu, 0x00060050u, 0x0000000au, 0x00000291u, + 0x00000290u, 0x00000290u, 0x00000290u, 0x00050081u, 0x0000000au, 0x00000292u, 0x0000028fu, 0x00000291u, + 0x0003003eu, 0x0000028eu, 0x00000292u, 0x00050041u, 0x00000008u, 0x00000295u, 0x000001efu, 0x00000294u, + 0x0004003du, 0x00000006u, 0x00000296u, 0x00000295u, 0x00050041u, 0x00000008u, 0x00000297u, 0x00000207u, + 0x000000d8u, 0x0004003du, 0x00000006u, 0x00000298u, 0x00000297u, 0x00050080u, 0x00000006u, 0x00000299u, + 0x00000296u, 0x00000298u, 0x0004003du, 0x00000006u, 0x0000029au, 0x0000025bu, 0x00050084u, 0x00000006u, + 0x0000029cu, 0x0000029au, 0x0000029bu, 0x00050080u, 0x00000006u, 0x0000029du, 0x00000299u, 0x0000029cu, + 0x0003003eu, 0x00000293u, 0x0000029du, 0x0004003du, 0x00000006u, 0x000002a3u, 0x00000293u, 0x00060041u, + 0x00000274u, 0x000002a4u, 0x000002a2u, 0x000000dcu, 0x000002a3u, 0x0004003du, 0x00000009u, 0x000002a5u, + 0x000002a4u, 0x0004003du, 0x00000006u, 0x000002a6u, 0x00000293u, 0x00050080u, 0x00000006u, 0x000002a7u, + 0x000002a6u, 0x00000007u, 0x00060041u, 0x00000274u, 0x000002a8u, 0x000002a2u, 0x000000dcu, 0x000002a7u, + 0x0004003du, 0x00000009u, 0x000002a9u, 0x000002a8u, 0x0004003du, 0x00000006u, 0x000002aau, 0x00000293u, + 0x00050080u, 0x00000006u, 0x000002abu, 0x000002aau, 0x00000049u, 0x00060041u, 0x00000274u, 0x000002acu, + 0x000002a2u, 0x000000dcu, 0x000002abu, 0x0004003du, 0x00000009u, 0x000002adu, 0x000002acu, 0x00060050u, + 0x0000000au, 0x000002aeu, 0x000002a5u, 0x000002a9u, 0x000002adu, 0x0003003eu, 0x0000029eu, 0x000002aeu, + 0x0004003du, 0x00000006u, 0x000002b0u, 0x00000293u, 0x00050080u, 0x00000006u, 0x000002b1u, 0x000002b0u, + 0x00000053u, 0x00060041u, 0x00000274u, 0x000002b2u, 0x000002a2u, 0x000000dcu, 0x000002b1u, 0x0004003du, + 0x00000009u, 0x000002b3u, 0x000002b2u, 0x0004003du, 0x00000006u, 0x000002b4u, 0x00000293u, 0x00050080u, + 0x00000006u, 0x000002b5u, 0x000002b4u, 0x0000005cu, 0x00060041u, 0x00000274u, 0x000002b6u, 0x000002a2u, + 0x000000dcu, 0x000002b5u, 0x0004003du, 0x00000009u, 0x000002b7u, 0x000002b6u, 0x0004003du, 0x00000006u, + 0x000002b8u, 0x00000293u, 0x00050080u, 0x00000006u, 0x000002bau, 0x000002b8u, 0x000002b9u, 0x00060041u, + 0x00000274u, 0x000002bbu, 0x000002a2u, 0x000000dcu, 0x000002bau, 0x0004003du, 0x00000009u, 0x000002bcu, + 0x000002bbu, 0x00060050u, 0x0000000au, 0x000002bdu, 0x000002b3u, 0x000002b7u, 0x000002bcu, 0x0003003eu, + 0x000002afu, 0x000002bdu, 0x0004003du, 0x0000000au, 0x000002bfu, 0x0000029eu, 0x0003003eu, 0x000002beu, + 0x000002bfu, 0x0004003du, 0x0000000au, 0x000002c1u, 0x000002afu, 0x0003003eu, 0x000002c0u, 0x000002c1u, + 0x0004003du, 0x0000000au, 0x000002c3u, 0x00000289u, 0x0003003eu, 0x000002c2u, 0x000002c3u, 0x0004003du, + 0x0000000au, 0x000002c5u, 0x0000028eu, 0x0003003eu, 0x000002c4u, 0x000002c5u, 0x00080039u, 0x00000012u, + 0x000002c6u, 0x0000002bu, 0x000002beu, 0x000002c0u, 0x000002c2u, 0x000002c4u, 0x000400a8u, 0x00000012u, + 0x000002c7u, 0x000002c6u, 0x000300f7u, 0x000002c9u, 0x00000000u, 0x000400fau, 0x000002c7u, 0x000002c8u, + 0x000002c9u, 0x000200f8u, 0x000002c8u, 0x0003003eu, 0x00000253u, 0x0000025au, 0x000200f9u, 0x000002c9u, + 0x000200f8u, 0x000002c9u, 0x000200f9u, 0x0000026au, 0x000200f8u, 0x0000026au, 0x0003003eu, 0x000002cau, + 0x00000036u, 0x0004003du, 0x00000006u, 0x000002cbu, 0x0000025bu, 0x000500acu, 0x00000012u, 0x000002ccu, + 0x000002cbu, 0x00000036u, 0x000300f7u, 0x000002ceu, 0x00000000u, 0x000400fau, 0x000002ccu, 0x000002cdu, + 0x000002ceu, 0x000200f8u, 0x000002cdu, 0x00050041u, 0x00000008u, 0x000002cfu, 0x000001efu, 0x00000235u, + 0x0004003du, 0x00000006u, 0x000002d0u, 0x000002cfu, 0x00050041u, 0x00000008u, 0x000002d1u, 0x00000207u, + 0x00000216u, 0x0004003du, 0x00000006u, 0x000002d2u, 0x000002d1u, 0x00050080u, 0x00000006u, 0x000002d3u, + 0x000002d0u, 0x000002d2u, 0x0004003du, 0x00000006u, 0x000002d4u, 0x0000025bu, 0x00050080u, 0x00000006u, + 0x000002d5u, 0x000002d3u, 0x000002d4u, 0x00050082u, 0x00000006u, 0x000002d6u, 0x000002d5u, 0x00000007u, + 0x00060041u, 0x0000023fu, 0x000002d7u, 0x00000234u, 0x000000dcu, 0x000002d6u, 0x0004003du, 0x0000001eu, + 0x000002d8u, 0x000002d7u, 0x0004007cu, 0x00000006u, 0x000002d9u, 0x000002d8u, 0x0003003eu, 0x000002cau, + 0x000002d9u, 0x000200f9u, 0x000002ceu, 0x000200f8u, 0x000002ceu, 0x00050041u, 0x00000008u, 0x000002dbu, + 0x000001efu, 0x00000235u, 0x0004003du, 0x00000006u, 0x000002dcu, 0x000002dbu, 0x00050041u, 0x00000008u, + 0x000002ddu, 0x00000207u, 0x00000216u, 0x0004003du, 0x00000006u, 0x000002deu, 0x000002ddu, 0x00050080u, + 0x00000006u, 0x000002dfu, 0x000002dcu, 0x000002deu, 0x0004003du, 0x00000006u, 0x000002e0u, 0x0000025bu, + 0x00050080u, 0x00000006u, 0x000002e1u, 0x000002dfu, 0x000002e0u, 0x00060041u, 0x0000023fu, 0x000002e2u, + 0x00000234u, 0x000000dcu, 0x000002e1u, 0x0004003du, 0x0000001eu, 0x000002e3u, 0x000002e2u, 0x0004007cu, + 0x00000006u, 0x000002e4u, 0x000002e3u, 0x0003003eu, 0x000002dau, 0x000002e4u, 0x0004003du, 0x00000006u, + 0x000002e6u, 0x000002dau, 0x0004003du, 0x00000006u, 0x000002e7u, 0x000002cau, 0x00050082u, 0x00000006u, + 0x000002e8u, 0x000002e6u, 0x000002e7u, 0x0003003eu, 0x000002e5u, 0x000002e8u, 0x00050041u, 0x00000008u, + 0x000002ebu, 0x00000207u, 0x00000126u, 0x0004003du, 0x00000006u, 0x000002ecu, 0x000002ebu, 0x0003003eu, + 0x000002eau, 0x000002ecu, 0x00050039u, 0x00000012u, 0x000002edu, 0x00000015u, 0x000002eau, 0x0003003eu, + 0x000002e9u, 0x000002edu, 0x0004003du, 0x00000012u, 0x000002eeu, 0x000002e9u, 0x000300f7u, 0x000002f0u, + 0x00000000u, 0x000400fau, 0x000002eeu, 0x000002efu, 0x000002fbu, 0x000200f8u, 0x000002efu, 0x0004003du, + 0x00000006u, 0x000002f2u, 0x000002e5u, 0x00050080u, 0x00000006u, 0x000002f3u, 0x000002f2u, 0x00000063u, + 0x00050082u, 0x00000006u, 0x000002f4u, 0x000002f3u, 0x00000007u, 0x00050086u, 0x00000006u, 0x000002f5u, + 0x000002f4u, 0x00000063u, 0x0003003eu, 0x000002f1u, 0x000002f5u, 0x0004003du, 0x00000006u, 0x000002f6u, + 0x000002f1u, 0x0007000cu, 0x00000006u, 0x000002f7u, 0x00000001u, 0x00000029u, 0x000002f6u, 0x00000007u, + 0x0003003eu, 0x000002f1u, 0x000002f7u, 0x0004003du, 0x00000012u, 0x000002f8u, 0x00000253u, 0x0004003du, + 0x00000006u, 0x000002f9u, 0x000002f1u, 0x000600a9u, 0x00000006u, 0x000002fau, 0x000002f8u, 0x00000036u, + 0x000002f9u, 0x0003003eu, 0x000001b6u, 0x000002fau, 0x000200f9u, 0x000002f0u, 0x000200f8u, 0x000002fbu, + 0x0004003du, 0x00000006u, 0x000002fcu, 0x000002e5u, 0x000500b0u, 0x00000012u, 0x000002fdu, 0x000002fcu, + 0x00000049u, 0x000300f7u, 0x000002ffu, 0x00000000u, 0x000400fau, 0x000002fdu, 0x000002feu, 0x000002ffu, + 0x000200f8u, 0x000002feu, 0x0003003eu, 0x00000253u, 0x0000025au, 0x0003003eu, 0x000002e5u, 0x00000049u, + 0x000200f9u, 0x000002ffu, 0x000200f8u, 0x000002ffu, 0x0004003du, 0x00000006u, 0x00000301u, 0x000002e5u, + 0x00050082u, 0x00000006u, 0x00000302u, 0x00000301u, 0x00000007u, 0x0003003eu, 0x00000300u, 0x00000302u, + 0x0004003du, 0x00000006u, 0x00000304u, 0x00000300u, 0x00050080u, 0x00000006u, 0x00000305u, 0x00000304u, + 0x00000053u, 0x00050082u, 0x00000006u, 0x00000306u, 0x00000305u, 0x00000007u, 0x00050086u, 0x00000006u, + 0x00000307u, 0x00000306u, 0x00000053u, 0x0003003eu, 0x00000303u, 0x00000307u, 0x0004003du, 0x00000006u, + 0x00000308u, 0x00000303u, 0x0007000cu, 0x00000006u, 0x00000309u, 0x00000001u, 0x00000029u, 0x00000308u, + 0x00000007u, 0x0003003eu, 0x00000303u, 0x00000309u, 0x0004003du, 0x00000012u, 0x0000030au, 0x00000253u, + 0x0004003du, 0x00000006u, 0x0000030bu, 0x00000303u, 0x000600a9u, 0x00000006u, 0x0000030cu, 0x0000030au, + 0x00000036u, 0x0000030bu, 0x0003003eu, 0x000001b6u, 0x0000030cu, 0x000200f9u, 0x000002f0u, 0x000200f8u, + 0x000002f0u, 0x0004003du, 0x00000006u, 0x00000310u, 0x000001d0u, 0x00050041u, 0x00000311u, 0x00000312u, + 0x0000030fu, 0x000000dcu, 0x0003003eu, 0x00000312u, 0x00000310u, 0x0004003du, 0x00000006u, 0x00000313u, + 0x000001cau, 0x00050041u, 0x00000311u, 0x00000314u, 0x0000030fu, 0x00000147u, 0x0003003eu, 0x00000314u, + 0x00000313u, 0x0004003du, 0x00000006u, 0x00000315u, 0x0000025bu, 0x00050041u, 0x00000311u, 0x00000316u, + 0x0000030fu, 0x0000012au, 0x0003003eu, 0x00000316u, 0x00000315u, 0x0004003du, 0x00000006u, 0x00000317u, + 0x000002e5u, 0x00050041u, 0x00000311u, 0x00000318u, 0x0000030fu, 0x00000126u, 0x0003003eu, 0x00000318u, + 0x00000317u, 0x00050041u, 0x00000008u, 0x0000031au, 0x00000207u, 0x00000126u, 0x0004003du, 0x00000006u, + 0x0000031bu, 0x0000031au, 0x0003003eu, 0x00000319u, 0x0000031bu, 0x00050041u, 0x00000008u, 0x0000031du, + 0x000001e1u, 0x00000126u, 0x0004003du, 0x00000006u, 0x0000031eu, 0x0000031du, 0x0003003eu, 0x0000031cu, + 0x0000031eu, 0x00060039u, 0x00000009u, 0x0000031fu, 0x0000001au, 0x00000319u, 0x0000031cu, 0x00050041u, + 0x00000320u, 0x00000321u, 0x0000030fu, 0x00000219u, 0x0003003eu, 0x00000321u, 0x0000031fu, 0x00050041u, + 0x00000008u, 0x00000323u, 0x00000207u, 0x00000126u, 0x0004003du, 0x00000006u, 0x00000324u, 0x00000323u, + 0x0003003eu, 0x00000322u, 0x00000324u, 0x00050039u, 0x0000000au, 0x00000325u, 0x00000010u, 0x00000322u, + 0x00050041u, 0x00000326u, 0x00000327u, 0x0000030fu, 0x0000010cu, 0x0003003eu, 0x00000327u, 0x00000325u, + 0x00050041u, 0x00000311u, 0x00000328u, 0x0000030fu, 0x00000216u, 0x0003003eu, 0x00000328u, 0x00000049u, + 0x00050041u, 0x00000008u, 0x00000329u, 0x000001e1u, 0x00000126u, 0x0004003du, 0x00000006u, 0x0000032au, + 0x00000329u, 0x000500aau, 0x00000012u, 0x0000032bu, 0x0000032au, 0x00000007u, 0x000600a9u, 0x00000009u, + 0x0000032cu, 0x0000032bu, 0x0000004fu, 0x00000058u, 0x00050041u, 0x00000320u, 0x0000032du, 0x0000030fu, + 0x00000235u, 0x0003003eu, 0x0000032du, 0x0000032cu, 0x0004003du, 0x00000006u, 0x0000032eu, 0x000001b6u, + 0x000514aeu, 0x0000032eu, 0x00000007u, 0x00000007u, 0x0000030fu, 0x00010038u, 0x00050036u, 0x0000000au, + 0x0000000du, 0x00000000u, 0x0000000bu, 0x00030037u, 0x00000008u, 0x0000000cu, 0x000200f8u, 0x0000000eu, + 0x0004003du, 0x00000006u, 0x00000035u, 0x0000000cu, 0x000500aau, 0x00000012u, 0x00000037u, 0x00000035u, + 0x00000036u, 0x000300f7u, 0x00000039u, 0x00000000u, 0x000400fau, 0x00000037u, 0x00000038u, 0x00000039u, + 0x000200f8u, 0x00000038u, 0x000200feu, 0x0000003du, 0x000200f8u, 0x00000039u, 0x0004003du, 0x00000006u, + 0x0000003fu, 0x0000000cu, 0x000500aau, 0x00000012u, 0x00000040u, 0x0000003fu, 0x00000007u, 0x000300f7u, + 0x00000042u, 0x00000000u, 0x000400fau, 0x00000040u, 0x00000041u, 0x00000042u, 0x000200f8u, 0x00000041u, + 0x000200feu, 0x00000046u, 0x000200f8u, 0x00000042u, 0x0004003du, 0x00000006u, 0x00000048u, 0x0000000cu, + 0x000500aau, 0x00000012u, 0x0000004au, 0x00000048u, 0x00000049u, 0x000300f7u, 0x0000004cu, 0x00000000u, + 0x000400fau, 0x0000004au, 0x0000004bu, 0x0000004cu, 0x000200f8u, 0x0000004bu, 0x000200feu, 0x00000050u, + 0x000200f8u, 0x0000004cu, 0x0004003du, 0x00000006u, 0x00000052u, 0x0000000cu, 0x000500aau, 0x00000012u, + 0x00000054u, 0x00000052u, 0x00000053u, 0x000300f7u, 0x00000056u, 0x00000000u, 0x000400fau, 0x00000054u, + 0x00000055u, 0x00000056u, 0x000200f8u, 0x00000055u, 0x000200feu, 0x00000059u, 0x000200f8u, 0x00000056u, + 0x0004003du, 0x00000006u, 0x0000005bu, 0x0000000cu, 0x000500aau, 0x00000012u, 0x0000005du, 0x0000005bu, + 0x0000005cu, 0x000300f7u, 0x0000005fu, 0x00000000u, 0x000400fau, 0x0000005du, 0x0000005eu, 0x0000005fu, + 0x000200f8u, 0x0000005eu, 0x000200feu, 0x00000060u, 0x000200f8u, 0x0000005fu, 0x0004003du, 0x00000006u, + 0x00000062u, 0x0000000cu, 0x000500aau, 0x00000012u, 0x00000064u, 0x00000062u, 0x00000063u, 0x000300f7u, + 0x00000066u, 0x00000000u, 0x000400fau, 0x00000064u, 0x00000065u, 0x00000066u, 0x000200f8u, 0x00000065u, + 0x000200feu, 0x0000006au, 0x000200f8u, 0x00000066u, 0x0004003du, 0x00000006u, 0x0000006cu, 0x0000000cu, + 0x000500aau, 0x00000012u, 0x0000006eu, 0x0000006cu, 0x0000006du, 0x000300f7u, 0x00000070u, 0x00000000u, + 0x000400fau, 0x0000006eu, 0x0000006fu, 0x00000070u, 0x000200f8u, 0x0000006fu, 0x000200feu, 0x00000073u, + 0x000200f8u, 0x00000070u, 0x0004003du, 0x00000006u, 0x00000075u, 0x0000000cu, 0x000500aau, 0x00000012u, + 0x00000077u, 0x00000075u, 0x00000076u, 0x000300f7u, 0x00000079u, 0x00000000u, 0x000400fau, 0x00000077u, + 0x00000078u, 0x00000079u, 0x000200f8u, 0x00000078u, 0x000200feu, 0x0000007du, 0x000200f8u, 0x00000079u, + 0x0004003du, 0x00000006u, 0x0000007fu, 0x0000000cu, 0x000500aau, 0x00000012u, 0x00000081u, 0x0000007fu, + 0x00000080u, 0x000300f7u, 0x00000083u, 0x00000000u, 0x000400fau, 0x00000081u, 0x00000082u, 0x00000083u, + 0x000200f8u, 0x00000082u, 0x000200feu, 0x00000046u, 0x000200f8u, 0x00000083u, 0x0004003du, 0x00000006u, + 0x00000085u, 0x0000000cu, 0x000500aau, 0x00000012u, 0x00000087u, 0x00000085u, 0x00000086u, 0x000300f7u, + 0x00000089u, 0x00000000u, 0x000400fau, 0x00000087u, 0x00000088u, 0x00000089u, 0x000200f8u, 0x00000088u, + 0x000200feu, 0x0000008au, 0x000200f8u, 0x00000089u, 0x0004003du, 0x00000006u, 0x0000008cu, 0x0000000cu, + 0x000500aau, 0x00000012u, 0x0000008eu, 0x0000008cu, 0x0000008du, 0x000300f7u, 0x00000090u, 0x00000000u, + 0x000400fau, 0x0000008eu, 0x0000008fu, 0x00000090u, 0x000200f8u, 0x0000008fu, 0x000200feu, 0x00000093u, + 0x000200f8u, 0x00000090u, 0x0004003du, 0x00000006u, 0x00000095u, 0x0000000cu, 0x000500aau, 0x00000012u, + 0x00000097u, 0x00000095u, 0x00000096u, 0x000300f7u, 0x00000099u, 0x00000000u, 0x000400fau, 0x00000097u, + 0x00000098u, 0x00000099u, 0x000200f8u, 0x00000098u, 0x000200feu, 0x0000009cu, 0x000200f8u, 0x00000099u, + 0x0004003du, 0x00000006u, 0x0000009eu, 0x0000000cu, 0x000500aau, 0x00000012u, 0x000000a0u, 0x0000009eu, + 0x0000009fu, 0x000300f7u, 0x000000a2u, 0x00000000u, 0x000400fau, 0x000000a0u, 0x000000a1u, 0x000000a2u, + 0x000200f8u, 0x000000a1u, 0x000200feu, 0x000000a4u, 0x000200f8u, 0x000000a2u, 0x0004003du, 0x00000006u, + 0x000000a6u, 0x0000000cu, 0x000500aau, 0x00000012u, 0x000000a8u, 0x000000a6u, 0x000000a7u, 0x000300f7u, + 0x000000aau, 0x00000000u, 0x000400fau, 0x000000a8u, 0x000000a9u, 0x000000aau, 0x000200f8u, 0x000000a9u, + 0x000200feu, 0x000000abu, 0x000200f8u, 0x000000aau, 0x0004003du, 0x00000006u, 0x000000adu, 0x0000000cu, + 0x000500aau, 0x00000012u, 0x000000afu, 0x000000adu, 0x000000aeu, 0x000300f7u, 0x000000b1u, 0x00000000u, + 0x000400fau, 0x000000afu, 0x000000b0u, 0x000000b1u, 0x000200f8u, 0x000000b0u, 0x000200feu, 0x000000b2u, + 0x000200f8u, 0x000000b1u, 0x0004003du, 0x00000006u, 0x000000b4u, 0x0000000cu, 0x000500aau, 0x00000012u, + 0x000000b6u, 0x000000b4u, 0x000000b5u, 0x000300f7u, 0x000000b8u, 0x00000000u, 0x000400fau, 0x000000b6u, + 0x000000b7u, 0x000000b8u, 0x000200f8u, 0x000000b7u, 0x000200feu, 0x000000b2u, 0x000200f8u, 0x000000b8u, + 0x0004003du, 0x00000006u, 0x000000bau, 0x0000000cu, 0x000500aau, 0x00000012u, 0x000000bcu, 0x000000bau, + 0x000000bbu, 0x000300f7u, 0x000000beu, 0x00000000u, 0x000400fau, 0x000000bcu, 0x000000bdu, 0x000000beu, + 0x000200f8u, 0x000000bdu, 0x000200feu, 0x000000bfu, 0x000200f8u, 0x000000beu, 0x0004003du, 0x00000006u, + 0x000000c1u, 0x0000000cu, 0x000500aau, 0x00000012u, 0x000000c3u, 0x000000c1u, 0x000000c2u, 0x000300f7u, + 0x000000c5u, 0x00000000u, 0x000400fau, 0x000000c3u, 0x000000c4u, 0x000000c5u, 0x000200f8u, 0x000000c4u, + 0x000200feu, 0x000000bfu, 0x000200f8u, 0x000000c5u, 0x0004003du, 0x00000006u, 0x000000c7u, 0x0000000cu, + 0x000500aau, 0x00000012u, 0x000000c9u, 0x000000c7u, 0x000000c8u, 0x000300f7u, 0x000000cbu, 0x00000000u, + 0x000400fau, 0x000000c9u, 0x000000cau, 0x000000cbu, 0x000200f8u, 0x000000cau, 0x000200feu, 0x000000bfu, + 0x000200f8u, 0x000000cbu, 0x0004003du, 0x00000006u, 0x000000cdu, 0x0000000cu, 0x000500aau, 0x00000012u, + 0x000000cfu, 0x000000cdu, 0x000000ceu, 0x000300f7u, 0x000000d1u, 0x00000000u, 0x000400fau, 0x000000cfu, + 0x000000d0u, 0x000000d1u, 0x000200f8u, 0x000000d0u, 0x000200feu, 0x000000b2u, 0x000200f8u, 0x000000d1u, + 0x000200feu, 0x000000b2u, 0x00010038u, 0x00050036u, 0x0000000au, 0x00000010u, 0x00000000u, 0x0000000bu, + 0x00030037u, 0x00000008u, 0x0000000fu, 0x000200f8u, 0x00000011u, 0x0004003bu, 0x000000e8u, 0x000000e9u, + 0x00000007u, 0x0004003bu, 0x00000008u, 0x000000fbu, 0x00000007u, 0x00050041u, 0x000000d9u, 0x000000dau, + 0x000000d7u, 0x000000d8u, 0x0004003du, 0x0000001eu, 0x000000dbu, 0x000000dau, 0x000500adu, 0x00000012u, + 0x000000ddu, 0x000000dbu, 0x000000dcu, 0x000300f7u, 0x000000dfu, 0x00000000u, 0x000400fau, 0x000000ddu, + 0x000000deu, 0x000000dfu, 0x000200f8u, 0x000000deu, 0x0004003du, 0x00000006u, 0x000000e0u, 0x0000000fu, + 0x00050041u, 0x000000d9u, 0x000000e1u, 0x000000d7u, 0x000000d8u, 0x0004003du, 0x0000001eu, 0x000000e2u, + 0x000000e1u, 0x0004007cu, 0x00000006u, 0x000000e3u, 0x000000e2u, 0x000500b0u, 0x00000012u, 0x000000e4u, + 0x000000e0u, 0x000000e3u, 0x000200f9u, 0x000000dfu, 0x000200f8u, 0x000000dfu, 0x000700f5u, 0x00000012u, + 0x000000e5u, 0x000000ddu, 0x00000011u, 0x000000e4u, 0x000000deu, 0x000300f7u, 0x000000e7u, 0x00000000u, + 0x000400fau, 0x000000e5u, 0x000000e6u, 0x000000e7u, 0x000200f8u, 0x000000e6u, 0x0004003du, 0x00000006u, + 0x000000eeu, 0x0000000fu, 0x00060041u, 0x000000efu, 0x000000f0u, 0x000000edu, 0x000000dcu, 0x000000eeu, + 0x0004003du, 0x0000002du, 0x000000f1u, 0x000000f0u, 0x0003003eu, 0x000000e9u, 0x000000f1u, 0x00050041u, + 0x000000f2u, 0x000000f3u, 0x000000e9u, 0x00000053u, 0x0004003du, 0x00000009u, 0x000000f4u, 0x000000f3u, + 0x000500beu, 0x00000012u, 0x000000f5u, 0x000000f4u, 0x00000058u, 0x000300f7u, 0x000000f7u, 0x00000000u, + 0x000400fau, 0x000000f5u, 0x000000f6u, 0x000000f7u, 0x000200f8u, 0x000000f6u, 0x0004003du, 0x0000002du, + 0x000000f8u, 0x000000e9u, 0x0008004fu, 0x0000000au, 0x000000f9u, 0x000000f8u, 0x000000f8u, 0x00000000u, + 0x00000001u, 0x00000002u, 0x000200feu, 0x000000f9u, 0x000200f8u, 0x000000f7u, 0x000200f9u, 0x000000e7u, + 0x000200f8u, 0x000000e7u, 0x0004003du, 0x00000006u, 0x000000fcu, 0x0000000fu, 0x0003003eu, 0x000000fbu, + 0x000000fcu, 0x00050039u, 0x0000000au, 0x000000fdu, 0x0000000du, 0x000000fbu, 0x000200feu, 0x000000fdu, + 0x00010038u, 0x00050036u, 0x00000012u, 0x00000015u, 0x00000000u, 0x00000013u, 0x00030037u, 0x00000008u, + 0x00000014u, 0x000200f8u, 0x00000016u, 0x0004003du, 0x00000006u, 0x00000100u, 0x00000014u, 0x000500aau, + 0x00000012u, 0x00000101u, 0x00000100u, 0x000000c8u, 0x0004003du, 0x00000006u, 0x00000102u, 0x00000014u, + 0x000500aau, 0x00000012u, 0x00000103u, 0x00000102u, 0x000000ceu, 0x000500a6u, 0x00000012u, 0x00000104u, + 0x00000101u, 0x00000103u, 0x000200feu, 0x00000104u, 0x00010038u, 0x00050036u, 0x00000009u, 0x0000001au, + 0x00000000u, 0x00000017u, 0x00030037u, 0x00000008u, 0x00000018u, 0x00030037u, 0x00000008u, 0x00000019u, + 0x000200f8u, 0x0000001bu, 0x0004003bu, 0x00000107u, 0x00000108u, 0x00000007u, 0x0004003bu, 0x000000f2u, + 0x0000010bu, 0x00000007u, 0x0004003bu, 0x000000f2u, 0x00000111u, 0x00000007u, 0x0004003bu, 0x000000f2u, + 0x0000011cu, 0x00000007u, 0x0004003bu, 0x000000f2u, 0x00000121u, 0x00000007u, 0x0004003bu, 0x000000f2u, + 0x00000123u, 0x00000007u, 0x0004003bu, 0x000000f2u, 0x0000012eu, 0x00000007u, 0x0004003bu, 0x000000f2u, + 0x0000013du, 0x00000007u, 0x0004003bu, 0x000000f2u, 0x00000142u, 0x00000007u, 0x0004003bu, 0x000000f2u, + 0x00000144u, 0x00000007u, 0x0004003du, 0x00000006u, 0x00000109u, 0x00000019u, 0x000500aau, 0x00000012u, + 0x0000010au, 0x00000109u, 0x00000007u, 0x0003003eu, 0x00000108u, 0x0000010au, 0x00050041u, 0x0000010du, + 0x0000010eu, 0x000000d7u, 0x0000010cu, 0x0004003du, 0x00000009u, 0x0000010fu, 0x0000010eu, 0x000500bau, + 0x00000012u, 0x00000110u, 0x0000010fu, 0x00000058u, 0x000300f7u, 0x00000113u, 0x00000000u, 0x000400fau, + 0x00000110u, 0x00000112u, 0x00000116u, 0x000200f8u, 0x00000112u, 0x00050041u, 0x0000010du, 0x00000114u, + 0x000000d7u, 0x0000010cu, 0x0004003du, 0x00000009u, 0x00000115u, 0x00000114u, 0x0003003eu, 0x00000111u, + 0x00000115u, 0x000200f9u, 0x00000113u, 0x000200f8u, 0x00000116u, 0x0003003eu, 0x00000111u, 0x0000004fu, + 0x000200f9u, 0x00000113u, 0x000200f8u, 0x00000113u, 0x0004003du, 0x00000009u, 0x00000117u, 0x00000111u, + 0x0003003eu, 0x0000010bu, 0x00000117u, 0x0004003du, 0x00000006u, 0x00000118u, 0x00000018u, 0x000500aau, + 0x00000012u, 0x00000119u, 0x00000118u, 0x0000005cu, 0x000300f7u, 0x0000011bu, 0x00000000u, 0x000400fau, + 0x00000119u, 0x0000011au, 0x00000134u, 0x000200f8u, 0x0000011au, 0x0004003du, 0x00000012u, 0x0000011du, + 0x00000108u, 0x000600a9u, 0x00000009u, 0x00000120u, 0x0000011du, 0x0000011eu, 0x0000011fu, 0x0003003eu, + 0x0000011cu, 0x00000120u, 0x0004003du, 0x00000012u, 0x00000122u, 0x00000108u, 0x000300f7u, 0x00000125u, + 0x00000000u, 0x000400fau, 0x00000122u, 0x00000124u, 0x00000129u, 0x000200f8u, 0x00000124u, 0x00050041u, + 0x0000010du, 0x00000127u, 0x000000d7u, 0x00000126u, 0x0004003du, 0x00000009u, 0x00000128u, 0x00000127u, + 0x0003003eu, 0x00000123u, 0x00000128u, 0x000200f9u, 0x00000125u, 0x000200f8u, 0x00000129u, 0x00050041u, + 0x0000010du, 0x0000012bu, 0x000000d7u, 0x0000012au, 0x0004003du, 0x00000009u, 0x0000012cu, 0x0000012bu, + 0x0003003eu, 0x00000123u, 0x0000012cu, 0x000200f9u, 0x00000125u, 0x000200f8u, 0x00000125u, 0x0004003du, + 0x00000009u, 0x0000012du, 0x00000123u, 0x0003003eu, 0x00000121u, 0x0000012du, 0x0004003du, 0x00000009u, + 0x0000012fu, 0x00000121u, 0x000500bau, 0x00000012u, 0x00000130u, 0x0000012fu, 0x00000058u, 0x0004003du, + 0x00000009u, 0x00000131u, 0x00000121u, 0x0004003du, 0x00000009u, 0x00000132u, 0x0000011cu, 0x000600a9u, + 0x00000009u, 0x00000133u, 0x00000130u, 0x00000131u, 0x00000132u, 0x0003003eu, 0x0000012eu, 0x00000133u, + 0x000200f9u, 0x0000011bu, 0x000200f8u, 0x00000134u, 0x0004003du, 0x00000006u, 0x00000135u, 0x00000018u, + 0x000500aau, 0x00000012u, 0x00000136u, 0x00000135u, 0x0000006du, 0x000300f7u, 0x00000138u, 0x00000000u, + 0x000400fau, 0x00000136u, 0x00000137u, 0x0000013cu, 0x000200f8u, 0x00000137u, 0x0004003du, 0x00000012u, + 0x00000139u, 0x00000108u, 0x000600a9u, 0x00000009u, 0x0000013bu, 0x00000139u, 0x0000013au, 0x0000011eu, + 0x0003003eu, 0x0000012eu, 0x0000013bu, 0x000200f9u, 0x00000138u, 0x000200f8u, 0x0000013cu, 0x0004003du, + 0x00000012u, 0x0000013eu, 0x00000108u, 0x000600a9u, 0x00000009u, 0x00000141u, 0x0000013eu, 0x0000013fu, + 0x00000140u, 0x0003003eu, 0x0000013du, 0x00000141u, 0x0004003du, 0x00000012u, 0x00000143u, 0x00000108u, + 0x000300f7u, 0x00000146u, 0x00000000u, 0x000400fau, 0x00000143u, 0x00000145u, 0x0000014au, 0x000200f8u, + 0x00000145u, 0x00050041u, 0x0000010du, 0x00000148u, 0x000000d7u, 0x00000147u, 0x0004003du, 0x00000009u, + 0x00000149u, 0x00000148u, 0x0003003eu, 0x00000144u, 0x00000149u, 0x000200f9u, 0x00000146u, 0x000200f8u, + 0x0000014au, 0x00050041u, 0x0000010du, 0x0000014bu, 0x000000d7u, 0x000000dcu, 0x0004003du, 0x00000009u, + 0x0000014cu, 0x0000014bu, 0x0003003eu, 0x00000144u, 0x0000014cu, 0x000200f9u, 0x00000146u, 0x000200f8u, + 0x00000146u, 0x0004003du, 0x00000009u, 0x0000014du, 0x00000144u, 0x0003003eu, 0x00000142u, 0x0000014du, + 0x0004003du, 0x00000009u, 0x0000014eu, 0x00000142u, 0x000500bau, 0x00000012u, 0x0000014fu, 0x0000014eu, + 0x00000058u, 0x0004003du, 0x00000009u, 0x00000150u, 0x00000142u, 0x0004003du, 0x00000009u, 0x00000151u, + 0x0000013du, 0x000600a9u, 0x00000009u, 0x00000152u, 0x0000014fu, 0x00000150u, 0x00000151u, 0x0003003eu, + 0x0000012eu, 0x00000152u, 0x000200f9u, 0x00000138u, 0x000200f8u, 0x00000138u, 0x000200f9u, 0x0000011bu, + 0x000200f8u, 0x0000011bu, 0x0004003du, 0x00000009u, 0x00000153u, 0x0000012eu, 0x0004003du, 0x00000009u, + 0x00000154u, 0x0000010bu, 0x00050085u, 0x00000009u, 0x00000155u, 0x00000153u, 0x00000154u, 0x000200feu, + 0x00000155u, 0x00010038u, 0x00050036u, 0x0000001eu, 0x00000023u, 0x00000000u, 0x0000001fu, 0x00030037u, + 0x00000008u, 0x00000020u, 0x00030037u, 0x00000008u, 0x00000021u, 0x00030037u, 0x0000001du, 0x00000022u, + 0x000200f8u, 0x00000024u, 0x0004003bu, 0x0000015eu, 0x0000015fu, 0x00000007u, 0x0004003bu, 0x0000015eu, + 0x00000160u, 0x00000007u, 0x0004003bu, 0x0000015eu, 0x00000164u, 0x00000007u, 0x0004003bu, 0x0000015eu, + 0x0000016du, 0x00000007u, 0x0004003bu, 0x0000001du, 0x00000172u, 0x00000007u, 0x0004003du, 0x00000006u, + 0x00000158u, 0x00000021u, 0x000500aau, 0x00000012u, 0x00000159u, 0x00000158u, 0x00000036u, 0x000300f7u, + 0x0000015bu, 0x00000000u, 0x000400fau, 0x00000159u, 0x0000015au, 0x0000015bu, 0x000200f8u, 0x0000015au, + 0x000200feu, 0x0000015cu, 0x000200f8u, 0x0000015bu, 0x0003003eu, 0x0000015fu, 0x000000dcu, 0x0004003du, + 0x00000006u, 0x00000161u, 0x00000021u, 0x0004007cu, 0x0000001eu, 0x00000162u, 0x00000161u, 0x00050082u, + 0x0000001eu, 0x00000163u, 0x00000162u, 0x00000147u, 0x0003003eu, 0x00000160u, 0x00000163u, 0x0003003eu, + 0x00000164u, 0x0000015cu, 0x000200f9u, 0x00000165u, 0x000200f8u, 0x00000165u, 0x000400f6u, 0x00000167u, + 0x00000168u, 0x00000000u, 0x000200f9u, 0x00000169u, 0x000200f8u, 0x00000169u, 0x0004003du, 0x0000001eu, + 0x0000016au, 0x0000015fu, 0x0004003du, 0x0000001eu, 0x0000016bu, 0x00000160u, 0x000500b3u, 0x00000012u, + 0x0000016cu, 0x0000016au, 0x0000016bu, 0x000400fau, 0x0000016cu, 0x00000166u, 0x00000167u, 0x000200f8u, + 0x00000166u, 0x0004003du, 0x0000001eu, 0x0000016eu, 0x0000015fu, 0x0004003du, 0x0000001eu, 0x0000016fu, + 0x00000160u, 0x00050080u, 0x0000001eu, 0x00000170u, 0x0000016eu, 0x0000016fu, 0x00050087u, 0x0000001eu, + 0x00000171u, 0x00000170u, 0x0000012au, 0x0003003eu, 0x0000016du, 0x00000171u, 0x0004003du, 0x00000006u, + 0x00000177u, 0x00000020u, 0x0004003du, 0x0000001eu, 0x00000178u, 0x0000016du, 0x0004007cu, 0x00000006u, + 0x00000179u, 0x00000178u, 0x00050080u, 0x00000006u, 0x0000017au, 0x00000177u, 0x00000179u, 0x00060041u, + 0x0000017bu, 0x0000017cu, 0x00000176u, 0x000000dcu, 0x0000017au, 0x0004003du, 0x0000001cu, 0x0000017du, + 0x0000017cu, 0x0003003eu, 0x00000172u, 0x0000017du, 0x0004003du, 0x0000001cu, 0x0000017eu, 0x00000172u, + 0x0004003du, 0x0000001cu, 0x0000017fu, 0x00000022u, 0x000500b3u, 0x00000012u, 0x00000180u, 0x0000017eu, + 0x0000017fu, 0x000300f7u, 0x00000182u, 0x00000000u, 0x000400fau, 0x00000180u, 0x00000181u, 0x00000186u, + 0x000200f8u, 0x00000181u, 0x0004003du, 0x0000001eu, 0x00000183u, 0x0000016du, 0x0003003eu, 0x00000164u, + 0x00000183u, 0x0004003du, 0x0000001eu, 0x00000184u, 0x0000016du, 0x00050080u, 0x0000001eu, 0x00000185u, + 0x00000184u, 0x00000147u, 0x0003003eu, 0x0000015fu, 0x00000185u, 0x000200f9u, 0x00000182u, 0x000200f8u, + 0x00000186u, 0x0004003du, 0x0000001eu, 0x00000187u, 0x0000016du, 0x00050082u, 0x0000001eu, 0x00000188u, + 0x00000187u, 0x00000147u, 0x0003003eu, 0x00000160u, 0x00000188u, 0x000200f9u, 0x00000182u, 0x000200f8u, + 0x00000182u, 0x000200f9u, 0x00000168u, 0x000200f8u, 0x00000168u, 0x000200f9u, 0x00000165u, 0x000200f8u, + 0x00000167u, 0x0004003du, 0x0000001eu, 0x00000189u, 0x00000164u, 0x000200feu, 0x00000189u, 0x00010038u, + 0x00050036u, 0x00000012u, 0x0000002bu, 0x00000000u, 0x00000026u, 0x00030037u, 0x00000025u, 0x00000027u, + 0x00030037u, 0x00000025u, 0x00000028u, 0x00030037u, 0x00000025u, 0x00000029u, 0x00030037u, 0x00000025u, + 0x0000002au, 0x000200f8u, 0x0000002cu, 0x0004003du, 0x0000000au, 0x0000018cu, 0x00000027u, 0x0004003du, + 0x0000000au, 0x0000018du, 0x0000002au, 0x000500bcu, 0x0000018eu, 0x0000018fu, 0x0000018cu, 0x0000018du, + 0x0004009bu, 0x00000012u, 0x00000190u, 0x0000018fu, 0x000300f7u, 0x00000192u, 0x00000000u, 0x000400fau, + 0x00000190u, 0x00000191u, 0x00000192u, 0x000200f8u, 0x00000191u, 0x0004003du, 0x0000000au, 0x00000193u, + 0x00000028u, 0x0004003du, 0x0000000au, 0x00000194u, 0x00000029u, 0x000500beu, 0x0000018eu, 0x00000195u, + 0x00000193u, 0x00000194u, 0x0004009bu, 0x00000012u, 0x00000196u, 0x00000195u, 0x000200f9u, 0x00000192u, + 0x000200f8u, 0x00000192u, 0x000700f5u, 0x00000012u, 0x00000197u, 0x00000190u, 0x0000002cu, 0x00000196u, + 0x00000191u, 0x000200feu, 0x00000197u, 0x00010038u, 0x00050036u, 0x0000000au, 0x00000033u, 0x00000000u, + 0x00000031u, 0x00030037u, 0x00000030u, 0x00000032u, 0x000200f8u, 0x00000034u, 0x0004003bu, 0x0000019bu, + 0x0000019cu, 0x00000007u, 0x00050041u, 0x0000019du, 0x0000019eu, 0x00000032u, 0x000000dcu, 0x0004003du, + 0x0000002eu, 0x0000019fu, 0x0000019eu, 0x00050051u, 0x0000002du, 0x000001a0u, 0x0000019fu, 0x00000000u, + 0x0008004fu, 0x0000000au, 0x000001a1u, 0x000001a0u, 0x000001a0u, 0x00000000u, 0x00000001u, 0x00000002u, + 0x00050051u, 0x0000002du, 0x000001a2u, 0x0000019fu, 0x00000001u, 0x0008004fu, 0x0000000au, 0x000001a3u, + 0x000001a2u, 0x000001a2u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050051u, 0x0000002du, 0x000001a4u, + 0x0000019fu, 0x00000002u, 0x0008004fu, 0x0000000au, 0x000001a5u, 0x000001a4u, 0x000001a4u, 0x00000000u, + 0x00000001u, 0x00000002u, 0x00060050u, 0x0000019au, 0x000001a6u, 0x000001a1u, 0x000001a3u, 0x000001a5u, + 0x0003003eu, 0x0000019cu, 0x000001a6u, 0x0004003du, 0x0000019au, 0x000001a7u, 0x0000019cu, 0x00040054u, + 0x0000019au, 0x000001a8u, 0x000001a7u, 0x00050051u, 0x0000000au, 0x000001a9u, 0x000001a8u, 0x00000000u, + 0x0004007fu, 0x0000000au, 0x000001aau, 0x000001a9u, 0x00050051u, 0x0000000au, 0x000001abu, 0x000001a8u, + 0x00000001u, 0x0004007fu, 0x0000000au, 0x000001acu, 0x000001abu, 0x00050051u, 0x0000000au, 0x000001adu, + 0x000001a8u, 0x00000002u, 0x0004007fu, 0x0000000au, 0x000001aeu, 0x000001adu, 0x00060050u, 0x0000019au, + 0x000001afu, 0x000001aau, 0x000001acu, 0x000001aeu, 0x00060041u, 0x000000e8u, 0x000001b0u, 0x00000032u, + 0x000000dcu, 0x00000126u, 0x0004003du, 0x0000002du, 0x000001b1u, 0x000001b0u, 0x0008004fu, 0x0000000au, + 0x000001b2u, 0x000001b1u, 0x000001b1u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050091u, 0x0000000au, + 0x000001b3u, 0x000001afu, 0x000001b2u, 0x000200feu, 0x000001b3u, 0x00010038u, +}; + +static const uint32_t kSpv_ts_polyline_mesh[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000a8du, 0x00000000u, 0x00020011u, 0x0000000bu, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x001e000fu, 0x000014f5u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x0000002eu, 0x00000309u, 0x0000030eu, + 0x00000314u, 0x00000320u, 0x00000330u, 0x0000033eu, 0x0000034du, 0x00000359u, 0x00000385u, 0x000003c7u, + 0x00000400u, 0x0000045au, 0x0000046du, 0x00000479u, 0x000004e5u, 0x000005b4u, 0x000005f9u, 0x00000a6eu, + 0x00000a72u, 0x00000a76u, 0x00000a7au, 0x00000a7eu, 0x00000a83u, 0x00000a88u, 0x0006014bu, 0x00000004u, + 0x00000026u, 0x00000007u, 0x00000008u, 0x00000008u, 0x00040010u, 0x00000004u, 0x0000001au, 0x00000080u, + 0x00040010u, 0x00000004u, 0x00001496u, 0x0000007eu, 0x00030010u, 0x00000004u, 0x000014b2u, 0x00030003u, + 0x00000002u, 0x000001ccu, 0x00060004u, 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, + 0x000d0004u, 0x455f4c47u, 0x735f5458u, 0x65646168u, 0x78655f72u, 0x63696c70u, 0x615f7469u, 0x68746972u, + 0x6974656du, 0x79745f63u, 0x5f736570u, 0x36746e69u, 0x00000034u, 0x00040005u, 0x00000004u, 0x6e69616du, + 0x00000000u, 0x00080005u, 0x0000000eu, 0x5f746567u, 0x74706564u, 0x63735f68u, 0x28656c61u, 0x3b346676u, + 0x00000000u, 0x00040005u, 0x0000000du, 0x70696c63u, 0x00000000u, 0x00080005u, 0x00000014u, 0x645f7369u, + 0x705f746fu, 0x696d6972u, 0x65766974u, 0x3b317528u, 0x00000000u, 0x00060005u, 0x00000013u, 0x6d697270u, + 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00050005u, 0x00000019u, 0x656d6143u, 0x6f506172u, 0x00006573u, + 0x00070006u, 0x00000019u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00617265u, 0x00060005u, + 0x0000001bu, 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, 0x00040006u, 0x0000001bu, 0x00000000u, + 0x00007863u, 0x00040006u, 0x0000001bu, 0x00000001u, 0x00007963u, 0x00050006u, 0x0000001bu, 0x00000002u, + 0x5f676d69u, 0x00000077u, 0x00050006u, 0x0000001bu, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, + 0x0000001bu, 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, 0x0000001bu, 0x00000005u, 0x796c6f70u, + 0x00000031u, 0x00050006u, 0x0000001bu, 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x0000001bu, + 0x00000007u, 0x796c6f70u, 0x00000033u, 0x00050006u, 0x0000001bu, 0x00000008u, 0x796c6f70u, 0x00000034u, + 0x00050006u, 0x0000001bu, 0x00000009u, 0x796c6f70u, 0x00000035u, 0x00070006u, 0x0000001bu, 0x0000000au, + 0x5f78616du, 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, 0x0000001bu, 0x0000000bu, 0x5f78616du, + 0x74736964u, 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, 0x0000001bu, 0x0000000cu, 0x5f78616du, + 0x74736964u, 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, 0x0000001bu, 0x0000000du, 0x74706564u, + 0x616d5f68u, 0x00000078u, 0x00050006u, 0x0000001bu, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, + 0x0000001bu, 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, 0x0000001bu, 0x00000010u, 0x655f646cu, + 0x00000000u, 0x00050006u, 0x0000001bu, 0x00000011u, 0x665f646cu, 0x00000000u, 0x00200005u, 0x00000021u, + 0x65687466u, 0x705f6174u, 0x656a6f72u, 0x76287463u, 0x733b3366u, 0x63757274u, 0x61432d74u, 0x6172656du, + 0x65736f50u, 0x34666d2du, 0x733b3134u, 0x63757274u, 0x54462d74u, 0x61746568u, 0x656d6143u, 0x662d6172u, + 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x00003b31u, 0x00050005u, 0x0000001eu, + 0x6c726f77u, 0x6f705f64u, 0x00000073u, 0x00040005u, 0x0000001fu, 0x65736f70u, 0x00000000u, 0x00030005u, + 0x00000020u, 0x006d6163u, 0x00220005u, 0x00000029u, 0x69747365u, 0x6574616du, 0x6764655fu, 0x69645f65u, + 0x726f7473u, 0x6e6f6974u, 0x7869705fu, 0x5f736c65u, 0x3474616du, 0x33667628u, 0x3366763bu, 0x34666d3bu, + 0x74733b34u, 0x74637572u, 0x6854462du, 0x43617465u, 0x72656d61u, 0x31662d61u, 0x2d31662du, 0x662d3166u, + 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x3131662du, 0x0000003bu, 0x00030005u, 0x00000025u, 0x00003076u, 0x00030005u, + 0x00000026u, 0x00003176u, 0x00060005u, 0x00000027u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00000000u, + 0x00030005u, 0x00000028u, 0x006d6163u, 0x00060005u, 0x0000002cu, 0x68737550u, 0x736e6f43u, 0x746e6174u, + 0x00000073u, 0x000a0006u, 0x0000002cu, 0x00000000u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, + 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x0000002cu, 0x00000001u, 0x69775f75u, 0x5f687464u, + 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, 0x0000002cu, 0x00000002u, 0x69775f75u, + 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x0000002cu, + 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x7665625fu, 0x00000000u, 0x00080006u, + 0x0000002cu, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, 0x6d617266u, 0x00000065u, 0x00080006u, + 0x0000002cu, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, 0x6163735fu, 0x0000656cu, 0x00070006u, + 0x0000002cu, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, 0x00676e69u, 0x00090006u, 0x0000002cu, + 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, 0x5f6e6f69u, 0x00007375u, 0x00090006u, + 0x0000002cu, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, 0x5f657474u, 0x657a6973u, 0x00000000u, + 0x00070006u, 0x0000002cu, 0x00000009u, 0x756e5f75u, 0x75715f6du, 0x65697265u, 0x00000073u, 0x000a0006u, + 0x0000002cu, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, 0x745f6e6fu, 0x73657268u, 0x646c6f68u, + 0x00000000u, 0x000a0006u, 0x0000002cu, 0x0000000bu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, + 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x0000002cu, 0x0000000cu, 0x616d5f75u, 0x65745f78u, + 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, 0x00090006u, 0x0000002cu, 0x0000000du, + 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, 0x00656275u, 0x00080006u, 0x0000002cu, + 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, 0x00656c61u, 0x00070006u, 0x0000002cu, + 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, 0x00070006u, 0x0000002cu, 0x00000010u, + 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, 0x0000002cu, 0x00000011u, 0x75635f75u, + 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, 0x0000002cu, 0x00000012u, 0x756e5f75u, + 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, 0x0000002cu, 0x00000013u, 0x616d5f75u, + 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, 0x00090006u, 0x0000002cu, 0x00000014u, + 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00070006u, 0x0000002cu, + 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, 0x00070006u, 0x0000002cu, 0x00000016u, + 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, 0x0000002eu, 0x00006370u, 0x00040005u, + 0x0000003au, 0x646e5f7au, 0x00000063u, 0x00050005u, 0x00000042u, 0x74706564u, 0x63735f68u, 0x00656c61u, + 0x00040005u, 0x00000053u, 0x5f6d6163u, 0x00007470u, 0x00040005u, 0x0000005eu, 0x74706564u, 0x00000068u, + 0x00050005u, 0x00000061u, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00040005u, 0x0000006bu, 0x666c6168u, + 0x0069705fu, 0x00060005u, 0x00000078u, 0x75657370u, 0x665f6f64u, 0x6c61636fu, 0x00000000u, 0x00040005u, + 0x0000007cu, 0x6c635f78u, 0x00007069u, 0x00040005u, 0x00000087u, 0x6c635f79u, 0x00007069u, 0x00040005u, + 0x00000099u, 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x0000009eu, 0x5f736f63u, 0x68706c61u, 0x00000061u, + 0x00040005u, 0x000000a5u, 0x68706c61u, 0x00000061u, 0x00030005u, 0x000000a8u, 0x00003261u, 0x00030005u, + 0x000000acu, 0x00003361u, 0x00030005u, 0x000000b0u, 0x00003461u, 0x00030005u, 0x000000b4u, 0x00003561u, + 0x00040005u, 0x000000b8u, 0x746c6564u, 0x00000061u, 0x00040005u, 0x000000eau, 0x6c616373u, 0x00000065u, + 0x00050005u, 0x000000f6u, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x000000fbu, 0x65786970u, + 0x69645f6cu, 0x00007473u, 0x00040005u, 0x00000118u, 0x65786970u, 0x0000006cu, 0x00040005u, 0x00000121u, + 0x646e5f78u, 0x00000063u, 0x00040005u, 0x0000012au, 0x646e5f79u, 0x00000063u, 0x00040005u, 0x00000138u, + 0x61765f7au, 0x0065756cu, 0x00040005u, 0x00000146u, 0x646e5f7au, 0x00000063u, 0x00040005u, 0x00000152u, + 0x5f6d6163u, 0x00307470u, 0x00040005u, 0x0000015bu, 0x5f6d6163u, 0x00317470u, 0x00050005u, 0x00000164u, + 0x5f64696du, 0x6c726f77u, 0x00000064u, 0x00050005u, 0x00000169u, 0x5f6d6163u, 0x6d5f7470u, 0x00006469u, + 0x00040005u, 0x00000172u, 0x74706564u, 0x00003068u, 0x00040005u, 0x00000176u, 0x74706564u, 0x00003168u, + 0x00050005u, 0x0000017au, 0x74706564u, 0x696d5f68u, 0x00000064u, 0x00040005u, 0x0000017eu, 0x6e5f7978u, + 0x006d726fu, 0x00050005u, 0x00000182u, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00050005u, 0x0000018cu, + 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, 0x00000191u, 0x68706c61u, 0x00000061u, 0x00030005u, + 0x00000194u, 0x00003261u, 0x00040005u, 0x00000198u, 0x746c6564u, 0x00000061u, 0x00040005u, 0x000001ccu, + 0x6c616373u, 0x00000065u, 0x00050005u, 0x000001d7u, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, + 0x000001dcu, 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00040005u, 0x000001f4u, 0x65786970u, 0x0000306cu, + 0x00040005u, 0x000001fcu, 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x00000200u, 0x5f796172u, 0x6d726f6eu, + 0x00000000u, 0x00050005u, 0x00000209u, 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, 0x0000020eu, + 0x68706c61u, 0x00000061u, 0x00030005u, 0x00000211u, 0x00003261u, 0x00040005u, 0x00000215u, 0x746c6564u, + 0x00000061u, 0x00040005u, 0x00000249u, 0x6c616373u, 0x00000065u, 0x00050005u, 0x00000254u, 0x65786970u, + 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x00000259u, 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00040005u, + 0x00000271u, 0x65786970u, 0x0000316cu, 0x00040005u, 0x00000279u, 0x6e5f7978u, 0x006d726fu, 0x00050005u, + 0x0000027du, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00050005u, 0x00000286u, 0x5f736f63u, 0x68706c61u, + 0x00000061u, 0x00040005u, 0x0000028bu, 0x68706c61u, 0x00000061u, 0x00030005u, 0x0000028eu, 0x00003261u, + 0x00040005u, 0x00000292u, 0x746c6564u, 0x00000061u, 0x00040005u, 0x000002c6u, 0x6c616373u, 0x00000065u, + 0x00050005u, 0x000002d1u, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x000002d6u, 0x65786970u, + 0x69645f6cu, 0x00007473u, 0x00050005u, 0x000002eeu, 0x65786970u, 0x696d5f6cu, 0x00000064u, 0x00070005u, + 0x000002f6u, 0x656e696cu, 0x705f7261u, 0x6c657869u, 0x64696d5fu, 0x00000000u, 0x00060005u, 0x000002fbu, + 0x6f727265u, 0x69705f72u, 0x736c6578u, 0x00000000u, 0x00050005u, 0x00000305u, 0x6972705fu, 0x6f635f6du, + 0x00746e75u, 0x00050005u, 0x00000306u, 0x6e756863u, 0x64695f6bu, 0x00000000u, 0x00060005u, 0x00000309u, + 0x575f6c67u, 0x476b726fu, 0x70756f72u, 0x00004449u, 0x00030005u, 0x0000030du, 0x00646974u, 0x00080005u, + 0x0000030eu, 0x4c5f6c67u, 0x6c61636fu, 0x6f766e49u, 0x69746163u, 0x44496e6fu, 0x00000000u, 0x00050005u, + 0x00000311u, 0x61746f74u, 0x74705f6cu, 0x00000073u, 0x00070005u, 0x00000312u, 0x796c6f50u, 0x656e696cu, + 0x6b736154u, 0x6c796150u, 0x0064616fu, 0x00060006u, 0x00000312u, 0x00000000u, 0x72657571u, 0x64695f79u, + 0x00000000u, 0x00050006u, 0x00000312u, 0x00000001u, 0x6c6f6f70u, 0x0064695fu, 0x00060006u, 0x00000312u, + 0x00000002u, 0x72726176u, 0x695f7961u, 0x00007864u, 0x00070006u, 0x00000312u, 0x00000003u, 0x61746f74u, + 0x6f705f6cu, 0x73746e69u, 0x00000000u, 0x00050006u, 0x00000312u, 0x00000004u, 0x74646977u, 0x00000068u, + 0x00050006u, 0x00000312u, 0x00000005u, 0x6f6c6f63u, 0x00000072u, 0x00060006u, 0x00000312u, 0x00000006u, + 0x5f706163u, 0x6c797473u, 0x00000065u, 0x00050006u, 0x00000312u, 0x00000007u, 0x625f7369u, 0x00007665u, + 0x00040005u, 0x00000314u, 0x6c796170u, 0x0064616fu, 0x00050005u, 0x00000319u, 0x646e6552u, 0x75517265u, + 0x00797265u, 0x00060006u, 0x00000319u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, + 0x00000319u, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000319u, 0x00000002u, + 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x00000319u, 0x00000003u, 0x656d6163u, + 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x00000319u, 0x00000004u, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x00000319u, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000319u, 0x00000006u, + 0x6461705fu, 0x00000033u, 0x00040005u, 0x0000031bu, 0x72657571u, 0x00000079u, 0x00050005u, 0x0000031cu, + 0x646e6552u, 0x75517265u, 0x00797265u, 0x00060006u, 0x0000031cu, 0x00000000u, 0x6e656373u, 0x64695f65u, + 0x00000000u, 0x00060006u, 0x0000031cu, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, + 0x0000031cu, 0x00000002u, 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x0000031cu, + 0x00000003u, 0x656d6163u, 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x0000031cu, 0x00000004u, + 0x6461705fu, 0x00000031u, 0x00050006u, 0x0000031cu, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, + 0x0000031cu, 0x00000006u, 0x6461705fu, 0x00000033u, 0x00050005u, 0x0000031eu, 0x72657551u, 0x66754279u, + 0x00726566u, 0x00060006u, 0x0000031eu, 0x00000000u, 0x75715f67u, 0x65697265u, 0x00000073u, 0x00030005u, + 0x00000320u, 0x00000000u, 0x00070005u, 0x00000328u, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, + 0x00000000u, 0x00080006u, 0x00000328u, 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, + 0x0000736cu, 0x00090006u, 0x00000328u, 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, + 0x65736666u, 0x00000074u, 0x00080006u, 0x00000328u, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, + 0x6c6f6f70u, 0x00000073u, 0x00090006u, 0x00000328u, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, + 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00070006u, 0x00000328u, 0x00000004u, 0x5f6d756eu, 0x65627563u, + 0x6f6f705fu, 0x0000736cu, 0x00080006u, 0x00000328u, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, + 0x65736666u, 0x00000074u, 0x000a0006u, 0x00000328u, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, + 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00080006u, 0x00000328u, 0x00000007u, 0x33746e69u, + 0x75625f32u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00090006u, 0x00000328u, 0x00000008u, 0x74726576u, + 0x625f7865u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00090006u, 0x00000328u, 0x00000009u, + 0x61697274u, 0x656c676eu, 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000328u, + 0x0000000au, 0x65736f70u, 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000328u, + 0x0000000bu, 0x616f6c66u, 0x75625f74u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000328u, + 0x0000000cu, 0x6461705fu, 0x00000000u, 0x00040005u, 0x0000032au, 0x6e656373u, 0x00000065u, 0x00070005u, + 0x0000032cu, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x0000032cu, + 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x0000032cu, + 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, + 0x0000032cu, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, + 0x0000032cu, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, + 0x00070006u, 0x0000032cu, 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, + 0x0000032cu, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, + 0x0000032cu, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, + 0x00000000u, 0x00080006u, 0x0000032cu, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, + 0x00746573u, 0x00090006u, 0x0000032cu, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, + 0x74657366u, 0x00000000u, 0x00090006u, 0x0000032cu, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, + 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x0000032cu, 0x0000000au, 0x65736f70u, 0x6675625fu, + 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x0000032cu, 0x0000000bu, 0x616f6c66u, 0x75625f74u, + 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x0000032cu, 0x0000000cu, 0x6461705fu, 0x00000000u, + 0x00050005u, 0x0000032eu, 0x6e656353u, 0x66754265u, 0x00726566u, 0x00060006u, 0x0000032eu, 0x00000000u, + 0x63735f67u, 0x73656e65u, 0x00000000u, 0x00030005u, 0x00000330u, 0x00000000u, 0x00080005u, 0x00000337u, + 0x656d6954u, 0x6d617473u, 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x00000337u, + 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000337u, 0x00000001u, + 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, 0x00000337u, 0x00000002u, 0x5f6d756eu, 0x74726576u, + 0x73656369u, 0x00000000u, 0x00070006u, 0x00000337u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, + 0x00000000u, 0x00080006u, 0x00000337u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, + 0x00000074u, 0x00090006u, 0x00000337u, 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, + 0x74657366u, 0x00000000u, 0x00080006u, 0x00000337u, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, + 0x65736666u, 0x00000074u, 0x00070006u, 0x00000337u, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, + 0x00746573u, 0x00060006u, 0x00000337u, 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, + 0x00000337u, 0x00000009u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000337u, 0x0000000au, 0x6461705fu, + 0x00000032u, 0x00050006u, 0x00000337u, 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000337u, + 0x0000000cu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x00000337u, 0x0000000du, 0x6461705fu, 0x00000035u, + 0x00050006u, 0x00000337u, 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, 0x00000337u, 0x0000000fu, + 0x6461705fu, 0x00000037u, 0x00040005u, 0x00000339u, 0x6c6f6f70u, 0x00000000u, 0x00080005u, 0x0000033au, + 0x656d6954u, 0x6d617473u, 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x0000033au, + 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x0000033au, 0x00000001u, + 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, 0x0000033au, 0x00000002u, 0x5f6d756eu, 0x74726576u, + 0x73656369u, 0x00000000u, 0x00070006u, 0x0000033au, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, + 0x00000000u, 0x00080006u, 0x0000033au, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, + 0x00000074u, 0x00090006u, 0x0000033au, 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, + 0x74657366u, 0x00000000u, 0x00080006u, 0x0000033au, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, + 0x65736666u, 0x00000074u, 0x00070006u, 0x0000033au, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, + 0x00746573u, 0x00060006u, 0x0000033au, 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, + 0x0000033au, 0x00000009u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x0000033au, 0x0000000au, 0x6461705fu, + 0x00000032u, 0x00050006u, 0x0000033au, 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x0000033au, + 0x0000000cu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x0000033au, 0x0000000du, 0x6461705fu, 0x00000035u, + 0x00050006u, 0x0000033au, 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, 0x0000033au, 0x0000000fu, + 0x6461705fu, 0x00000037u, 0x00070005u, 0x0000033cu, 0x796c6f50u, 0x656e696cu, 0x6c6f6f50u, 0x66667542u, + 0x00007265u, 0x00080006u, 0x0000033cu, 0x00000000u, 0x6f705f67u, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, + 0x00000000u, 0x00030005u, 0x0000033eu, 0x00000000u, 0x00030005u, 0x00000348u, 0x006d6163u, 0x00060005u, + 0x00000349u, 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, 0x00040006u, 0x00000349u, 0x00000000u, + 0x00007863u, 0x00040006u, 0x00000349u, 0x00000001u, 0x00007963u, 0x00050006u, 0x00000349u, 0x00000002u, + 0x5f676d69u, 0x00000077u, 0x00050006u, 0x00000349u, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, + 0x00000349u, 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, 0x00000349u, 0x00000005u, 0x796c6f70u, + 0x00000031u, 0x00050006u, 0x00000349u, 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x00000349u, + 0x00000007u, 0x796c6f70u, 0x00000033u, 0x00050006u, 0x00000349u, 0x00000008u, 0x796c6f70u, 0x00000034u, + 0x00050006u, 0x00000349u, 0x00000009u, 0x796c6f70u, 0x00000035u, 0x00070006u, 0x00000349u, 0x0000000au, + 0x5f78616du, 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, 0x00000349u, 0x0000000bu, 0x5f78616du, + 0x74736964u, 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, 0x00000349u, 0x0000000cu, 0x5f78616du, + 0x74736964u, 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, 0x00000349u, 0x0000000du, 0x74706564u, + 0x616d5f68u, 0x00000078u, 0x00050006u, 0x00000349u, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, + 0x00000349u, 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, 0x00000349u, 0x00000010u, 0x655f646cu, + 0x00000000u, 0x00050006u, 0x00000349u, 0x00000011u, 0x665f646cu, 0x00000000u, 0x00080005u, 0x0000034bu, + 0x656d6143u, 0x6e496172u, 0x6e697274u, 0x73636973u, 0x66667542u, 0x00007265u, 0x00080006u, 0x0000034bu, + 0x00000000u, 0x61635f67u, 0x6172656du, 0x746e695fu, 0x736e6972u, 0x00736369u, 0x00030005u, 0x0000034du, + 0x00000000u, 0x00040005u, 0x00000354u, 0x65736f70u, 0x00000000u, 0x00050005u, 0x00000355u, 0x656d6143u, + 0x6f506172u, 0x00006573u, 0x00070006u, 0x00000355u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, + 0x00617265u, 0x00070005u, 0x00000357u, 0x656d6143u, 0x6f506172u, 0x75426573u, 0x72656666u, 0x00000000u, + 0x00070006u, 0x00000357u, 0x00000000u, 0x61635f67u, 0x6172656du, 0x736f705fu, 0x00007365u, 0x00030005u, + 0x00000359u, 0x00000000u, 0x00060005u, 0x00000360u, 0x5f706163u, 0x6c797473u, 0x6f6c5f65u, 0x006c6163u, + 0x00040005u, 0x00000363u, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000369u, 0x5f746f64u, 0x72617473u, + 0x00000074u, 0x00040005u, 0x0000036du, 0x5f746f64u, 0x00646e65u, 0x00050005u, 0x00000372u, 0x5f6d756eu, + 0x73746f64u, 0x00000000u, 0x00060005u, 0x0000037cu, 0x74735f76u, 0x5f747261u, 0x65736162u, 0x00000000u, + 0x00050005u, 0x00000383u, 0x33746e49u, 0x66754232u, 0x00726566u, 0x00050006u, 0x00000383u, 0x00000000u, + 0x6e695f67u, 0x00323374u, 0x00030005u, 0x00000385u, 0x00000000u, 0x00050005u, 0x00000393u, 0x65736162u, + 0x695f765fu, 0x00007864u, 0x00050005u, 0x0000039bu, 0x666c6168u, 0x6469775fu, 0x00006874u, 0x00050005u, + 0x000003a0u, 0x61746f74u, 0x65765f6cu, 0x00737472u, 0x00050005u, 0x000003a4u, 0x61746f74u, 0x72745f6cu, + 0x00007369u, 0x00030005u, 0x000003afu, 0x00000064u, 0x00050005u, 0x000003b8u, 0x626f6c67u, 0x645f6c61u, + 0x0000746fu, 0x00030005u, 0x000003bcu, 0x00006976u, 0x00040005u, 0x000003c0u, 0x74726556u, 0x00007865u, + 0x00040006u, 0x000003c0u, 0x00000000u, 0x00000078u, 0x00040006u, 0x000003c0u, 0x00000001u, 0x00000079u, + 0x00040006u, 0x000003c0u, 0x00000002u, 0x0000007au, 0x00050006u, 0x000003c0u, 0x00000003u, 0x6461705fu, + 0x00000000u, 0x00030005u, 0x000003c2u, 0x00007876u, 0x00040005u, 0x000003c3u, 0x74726556u, 0x00007865u, + 0x00040006u, 0x000003c3u, 0x00000000u, 0x00000078u, 0x00040006u, 0x000003c3u, 0x00000001u, 0x00000079u, + 0x00040006u, 0x000003c3u, 0x00000002u, 0x0000007au, 0x00050006u, 0x000003c3u, 0x00000003u, 0x6461705fu, + 0x00000000u, 0x00060005u, 0x000003c5u, 0x74726556u, 0x75427865u, 0x72656666u, 0x00000000u, 0x00060006u, + 0x000003c5u, 0x00000000u, 0x65765f67u, 0x63697472u, 0x00007365u, 0x00030005u, 0x000003c7u, 0x00000000u, + 0x00050005u, 0x000003cdu, 0x6c726f77u, 0x6f705f64u, 0x00000073u, 0x00050005u, 0x000003d5u, 0x746e6563u, + 0x635f7265u, 0x0070696cu, 0x00040005u, 0x000003d6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000003d8u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000003dau, 0x61726170u, 0x0000006du, 0x00030005u, 0x000003ddu, + 0x00000077u, 0x00060005u, 0x000003e5u, 0x746e6563u, 0x735f7265u, 0x65657263u, 0x0000006eu, 0x00050005u, + 0x000003f9u, 0x65736162u, 0x7265765fu, 0x00000074u, 0x00070005u, 0x000003fcu, 0x4d5f6c67u, 0x50687365u, + 0x65567265u, 0x78657472u, 0x00545845u, 0x00060006u, 0x000003fcu, 0x00000000u, 0x505f6c67u, 0x7469736fu, + 0x006e6f69u, 0x00070005u, 0x00000400u, 0x4d5f6c67u, 0x56687365u, 0x69747265u, 0x45736563u, 0x00005458u, + 0x00060005u, 0x00000405u, 0x5f746f64u, 0x74706564u, 0x63735f68u, 0x00656c61u, 0x00040005u, 0x00000406u, + 0x61726170u, 0x0000006du, 0x00070005u, 0x00000409u, 0x6c616373u, 0x685f6465u, 0x5f666c61u, 0x74646977u, + 0x00000068u, 0x00030005u, 0x0000040du, 0x00000069u, 0x00040005u, 0x00000415u, 0x6c676e61u, 0x00000065u, + 0x00040005u, 0x0000041au, 0x7366666fu, 0x00007465u, 0x00050005u, 0x00000422u, 0x676e6972u, 0x7263735fu, + 0x006e6565u, 0x00050005u, 0x00000426u, 0x676e6972u, 0x696c635fu, 0x00000070u, 0x00050005u, 0x00000448u, + 0x65736162u, 0x6972745fu, 0x00000000u, 0x00030005u, 0x0000044bu, 0x00000069u, 0x00040005u, 0x00000453u, + 0x7478656eu, 0x0000695fu, 0x000a0005u, 0x0000045au, 0x505f6c67u, 0x696d6972u, 0x65766974u, 0x61697254u, + 0x656c676eu, 0x69646e49u, 0x45736563u, 0x00005458u, 0x00080005u, 0x0000046au, 0x4d5f6c67u, 0x50687365u, + 0x72507265u, 0x74696d69u, 0x45657669u, 0x00005458u, 0x00060006u, 0x0000046au, 0x00000000u, 0x4c5f6c67u, + 0x72657961u, 0x00000000u, 0x00080005u, 0x0000046du, 0x4d5f6c67u, 0x50687365u, 0x696d6972u, 0x65766974u, + 0x54584573u, 0x00000000u, 0x00060005u, 0x00000476u, 0x6d697250u, 0x6f6c6f43u, 0x6f6c4272u, 0x00006b63u, + 0x00050006u, 0x00000476u, 0x00000000u, 0x6f6c6f63u, 0x00000072u, 0x00050006u, 0x00000476u, 0x00000001u, + 0x625f7369u, 0x00007665u, 0x00050005u, 0x00000479u, 0x6d697270u, 0x74756f5fu, 0x00000000u, 0x00060005u, + 0x0000048eu, 0x5f6d756eu, 0x6d676573u, 0x73746e65u, 0x00000000u, 0x00050005u, 0x00000491u, 0x5f676573u, + 0x72617473u, 0x00000074u, 0x00040005u, 0x00000494u, 0x5f676573u, 0x00646e65u, 0x00070005u, 0x00000499u, + 0x5f6d756eu, 0x73676573u, 0x5f6e695fu, 0x6e756863u, 0x0000006bu, 0x00060005u, 0x0000049eu, 0x665f7369u, + 0x74737269u, 0x7568635fu, 0x00006b6eu, 0x00060005u, 0x000004a1u, 0x6c5f7369u, 0x5f747361u, 0x6e756863u, + 0x0000006bu, 0x00050005u, 0x000004abu, 0x666c6168u, 0x6469775fu, 0x00006874u, 0x00040005u, 0x000004afu, + 0x74735f76u, 0x00747261u, 0x00050005u, 0x000004c1u, 0x65736162u, 0x695f765fu, 0x00007864u, 0x00060005u, + 0x000004c9u, 0x5f666665u, 0x6e696f70u, 0x6f635f74u, 0x00746e75u, 0x00070005u, 0x000004cau, 0x5f736168u, + 0x7265766fu, 0x5f70616cu, 0x6f666562u, 0x00006572u, 0x00070005u, 0x000004ccu, 0x5f736168u, 0x7265766fu, + 0x5f70616cu, 0x65746661u, 0x00000072u, 0x00050005u, 0x000004d8u, 0x625f6976u, 0x726f6665u, 0x00000065u, + 0x00050005u, 0x000004ddu, 0x625f7876u, 0x726f6665u, 0x00000065u, 0x00050005u, 0x000004e5u, 0x6f775f73u, + 0x5f646c72u, 0x00736f70u, 0x00050005u, 0x000004f9u, 0x615f6976u, 0x72657466u, 0x00000000u, 0x00050005u, + 0x000004feu, 0x615f7876u, 0x72657466u, 0x00000000u, 0x00040005u, 0x0000050cu, 0x5f676573u, 0x00786469u, + 0x00050005u, 0x00000515u, 0x626f6c67u, 0x735f6c61u, 0x00006765u, 0x00030005u, 0x00000519u, 0x00306976u, + 0x00030005u, 0x0000051du, 0x00316976u, 0x00030005u, 0x00000522u, 0x00307876u, 0x00030005u, 0x00000527u, + 0x00317876u, 0x00030005u, 0x0000052cu, 0x00003070u, 0x00030005u, 0x00000534u, 0x00003170u, 0x00040005u, + 0x0000053cu, 0x6f727265u, 0x00000072u, 0x00040005u, 0x0000053du, 0x61726170u, 0x0000006du, 0x00040005u, + 0x0000053fu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000541u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x00000544u, 0x61726170u, 0x0000006du, 0x00060005u, 0x00000547u, 0x64627573u, 0x6c5f7669u, 0x6c657665u, + 0x00000000u, 0x00050005u, 0x00000548u, 0x73736574u, 0x7268745fu, 0x00687365u, 0x00060005u, 0x0000057du, + 0x5f6d756eu, 0x73627573u, 0x656d6765u, 0x0073746eu, 0x00040005u, 0x00000589u, 0x5f627573u, 0x00000069u, + 0x00030005u, 0x00000592u, 0x00000074u, 0x00050005u, 0x00000598u, 0x6c726f77u, 0x6f705f64u, 0x00000073u, + 0x00050005u, 0x000005b4u, 0x6c635f73u, 0x705f7069u, 0x0000736fu, 0x00060005u, 0x000005c1u, 0x5f6d756eu, + 0x5f666665u, 0x6e696f70u, 0x00007374u, 0x00070005u, 0x000005c5u, 0x5f657375u, 0x7265766fu, 0x5f70616cu, + 0x6f666562u, 0x00006572u, 0x00070005u, 0x000005c9u, 0x5f657375u, 0x7265766fu, 0x5f70616cu, 0x65746661u, + 0x00000072u, 0x00030005u, 0x000005d5u, 0x00007470u, 0x00050005u, 0x000005dfu, 0x6c726f77u, 0x6f705f64u, + 0x00000073u, 0x00040005u, 0x000005e3u, 0x70696c63u, 0x00000000u, 0x00040005u, 0x000005e4u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x000005e6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005e8u, 0x61726170u, + 0x0000006du, 0x00030005u, 0x000005efu, 0x00000077u, 0x00060005u, 0x000005f9u, 0x63735f73u, 0x6e656572u, + 0x736f705fu, 0x00000000u, 0x00060005u, 0x00000612u, 0x5f6d756eu, 0x5f666665u, 0x73676573u, 0x00000000u, + 0x00060005u, 0x00000615u, 0x77617264u, 0x6174735fu, 0x635f7472u, 0x00007061u, 0x00060005u, 0x00000616u, + 0x77617264u, 0x646e655fu, 0x7061635fu, 0x00000000u, 0x00060005u, 0x00000617u, 0x5f6d756eu, 0x5f706163u, + 0x74726576u, 0x00000073u, 0x00060005u, 0x0000061du, 0x5f6d756eu, 0x5f706163u, 0x73697274u, 0x00000000u, + 0x00060005u, 0x00000623u, 0x6e696f70u, 0x65765f74u, 0x5f737472u, 0x00646e65u, 0x00060005u, 0x00000626u, + 0x72617473u, 0x61635f74u, 0x61625f70u, 0x00006573u, 0x00060005u, 0x00000628u, 0x5f646e65u, 0x5f706163u, + 0x65736162u, 0x00000000u, 0x00050005u, 0x0000062du, 0x5f6d756eu, 0x74726576u, 0x00000073u, 0x00050005u, + 0x00000631u, 0x5f6d756eu, 0x73697274u, 0x00000000u, 0x00030005u, 0x0000063bu, 0x00007470u, 0x00040005u, + 0x00000645u, 0x70696c63u, 0x00000000u, 0x00040005u, 0x00000649u, 0x65726373u, 0x00006e65u, 0x00040005u, + 0x0000064du, 0x696d5f77u, 0x0000006eu, 0x00050005u, 0x0000064eu, 0x5f726964u, 0x76657270u, 0x00000000u, + 0x00050005u, 0x00000650u, 0x5f726964u, 0x7478656eu, 0x00000000u, 0x00050005u, 0x00000651u, 0x5f736168u, + 0x76657270u, 0x00000000u, 0x00050005u, 0x00000654u, 0x5f736168u, 0x7478656eu, 0x00000000u, 0x00060005u, + 0x00000659u, 0x65726373u, 0x665f6e65u, 0x645f726fu, 0x00007269u, 0x00050005u, 0x0000065bu, 0x70696c63u, + 0x7275635fu, 0x00000072u, 0x00040005u, 0x0000066fu, 0x646f6f67u, 0x00000000u, 0x00030005u, 0x00000674u, + 0x00646162u, 0x00040005u, 0x00000679u, 0x72657469u, 0x00000000u, 0x00030005u, 0x00000681u, 0x0064696du, + 0x00050005u, 0x00000686u, 0x5f64696du, 0x70696c63u, 0x00000000u, 0x00040005u, 0x00000687u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000689u, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000068bu, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000699u, 0x6d616c63u, 0x00646570u, 0x00040005u, 0x0000069au, 0x61726170u, + 0x0000006du, 0x00040005u, 0x0000069cu, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000069eu, 0x61726170u, + 0x0000006du, 0x00030005u, 0x000006a1u, 0x00635f77u, 0x00040005u, 0x000006cfu, 0x646f6f67u, 0x00000000u, + 0x00030005u, 0x000006d4u, 0x00646162u, 0x00040005u, 0x000006d8u, 0x72657469u, 0x00000000u, 0x00030005u, + 0x000006e0u, 0x0064696du, 0x00050005u, 0x000006e5u, 0x5f64696du, 0x70696c63u, 0x00000000u, 0x00040005u, + 0x000006e6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006e8u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000006eau, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006f8u, 0x6d616c63u, 0x00646570u, 0x00040005u, + 0x000006f9u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006fbu, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000006fdu, 0x61726170u, 0x0000006du, 0x00030005u, 0x00000700u, 0x00635f77u, 0x00050005u, 0x0000071au, + 0x65726373u, 0x705f6e65u, 0x00766572u, 0x00040005u, 0x0000072eu, 0x646f6f67u, 0x00000000u, 0x00030005u, + 0x00000732u, 0x00646162u, 0x00040005u, 0x00000737u, 0x72657469u, 0x00000000u, 0x00030005u, 0x0000073fu, + 0x0064696du, 0x00050005u, 0x00000744u, 0x5f64696du, 0x70696c63u, 0x00000000u, 0x00040005u, 0x00000745u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x00000747u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000749u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x00000757u, 0x6d616c63u, 0x00646570u, 0x00040005u, 0x00000758u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x0000075au, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000075cu, + 0x61726170u, 0x0000006du, 0x00030005u, 0x0000075fu, 0x00635f77u, 0x00030005u, 0x00000776u, 0x00000064u, + 0x00030005u, 0x0000077au, 0x006e656cu, 0x00050005u, 0x00000788u, 0x65726373u, 0x6e5f6e65u, 0x00747865u, + 0x00040005u, 0x0000079cu, 0x646f6f67u, 0x00000000u, 0x00030005u, 0x000007a0u, 0x00646162u, 0x00040005u, + 0x000007a5u, 0x72657469u, 0x00000000u, 0x00030005u, 0x000007adu, 0x0064696du, 0x00050005u, 0x000007b2u, + 0x5f64696du, 0x70696c63u, 0x00000000u, 0x00040005u, 0x000007b3u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000007b5u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000007b7u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000007c5u, 0x6d616c63u, 0x00646570u, 0x00040005u, 0x000007c6u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000007c8u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000007cau, 0x61726170u, 0x0000006du, 0x00030005u, + 0x000007cdu, 0x00635f77u, 0x00030005u, 0x000007e4u, 0x00000064u, 0x00030005u, 0x000007e8u, 0x006e656cu, + 0x00050005u, 0x000007f3u, 0x6574696du, 0x63735f72u, 0x00656c61u, 0x00050005u, 0x00000805u, 0x70726570u, + 0x6572705fu, 0x00000076u, 0x00050005u, 0x0000080cu, 0x70726570u, 0x78656e5fu, 0x00000074u, 0x00050005u, + 0x00000813u, 0x6574696du, 0x75735f72u, 0x0000006du, 0x00050005u, 0x00000817u, 0x6574696du, 0x656c5f72u, + 0x0000006eu, 0x00040005u, 0x0000081eu, 0x6574696du, 0x00000072u, 0x00050005u, 0x00000823u, 0x5f736f63u, + 0x666c6168u, 0x00000000u, 0x00050005u, 0x00000854u, 0x74706564u, 0x63735f68u, 0x00656c61u, 0x00040005u, + 0x00000855u, 0x61726170u, 0x0000006du, 0x00070005u, 0x00000858u, 0x6c616373u, 0x685f6465u, 0x5f666c61u, + 0x74646977u, 0x00000068u, 0x00040005u, 0x0000085cu, 0x5f66666fu, 0x00000078u, 0x00040005u, 0x0000086au, + 0x5f66666fu, 0x00000079u, 0x00040005u, 0x00000879u, 0x65736162u, 0x00000000u, 0x00040005u, 0x000008a7u, + 0x70696c63u, 0x00000030u, 0x00040005u, 0x000008aau, 0x65726373u, 0x00306e65u, 0x00040005u, 0x000008adu, + 0x65726373u, 0x00316e65u, 0x00050005u, 0x000008b0u, 0x656e696cu, 0x7269645fu, 0x00000000u, 0x00040005u, + 0x000008b5u, 0x70726570u, 0x00000000u, 0x00040005u, 0x000008c1u, 0x6c676e61u, 0x00007365u, 0x00070005u, + 0x000008c6u, 0x30706163u, 0x7065645fu, 0x735f6874u, 0x656c6163u, 0x00000000u, 0x00040005u, 0x000008c7u, + 0x61726170u, 0x0000006du, 0x00080005u, 0x000008cau, 0x30706163u, 0x6163735fu, 0x5f64656cu, 0x666c6168u, + 0x6469775fu, 0x00006874u, 0x00030005u, 0x000008ceu, 0x00000069u, 0x00030005u, 0x000008d6u, 0x00000061u, + 0x00040005u, 0x000008dau, 0x5f637261u, 0x00726964u, 0x00050005u, 0x000008e5u, 0x5f637261u, 0x5f66666fu, + 0x00000078u, 0x00050005u, 0x000008f1u, 0x5f637261u, 0x5f66666fu, 0x00000079u, 0x00040005u, 0x00000919u, + 0x7473616cu, 0x0074705fu, 0x00040005u, 0x0000091cu, 0x70696c63u, 0x0000004eu, 0x00040005u, 0x00000920u, + 0x65726373u, 0x004e6e65u, 0x00050005u, 0x00000924u, 0x65726373u, 0x314e6e65u, 0x00000000u, 0x00050005u, + 0x00000929u, 0x656e696cu, 0x7269645fu, 0x00000000u, 0x00040005u, 0x0000092eu, 0x70726570u, 0x00000000u, + 0x00040005u, 0x00000938u, 0x6c676e61u, 0x00007365u, 0x00070005u, 0x00000939u, 0x4e706163u, 0x7065645fu, + 0x735f6874u, 0x656c6163u, 0x00000000u, 0x00040005u, 0x0000093au, 0x61726170u, 0x0000006du, 0x00080005u, + 0x0000093du, 0x4e706163u, 0x6163735fu, 0x5f64656cu, 0x666c6168u, 0x6469775fu, 0x00006874u, 0x00030005u, + 0x00000941u, 0x00000069u, 0x00030005u, 0x00000949u, 0x00000061u, 0x00040005u, 0x0000094du, 0x5f637261u, + 0x00726964u, 0x00050005u, 0x00000958u, 0x5f637261u, 0x5f66666fu, 0x00000078u, 0x00050005u, 0x00000964u, + 0x5f637261u, 0x5f66666fu, 0x00000079u, 0x00040005u, 0x0000098au, 0x5f697274u, 0x00786469u, 0x00030005u, + 0x0000098bu, 0x00676573u, 0x00040005u, 0x00000994u, 0x7466656cu, 0x00000030u, 0x00040005u, 0x00000997u, + 0x68676972u, 0x00003074u, 0x00040005u, 0x0000099bu, 0x7466656cu, 0x00000031u, 0x00040005u, 0x0000099fu, + 0x68676972u, 0x00003174u, 0x00040005u, 0x000009b9u, 0x746e6563u, 0x00007265u, 0x00050005u, 0x000009bbu, + 0x68676972u, 0x64655f74u, 0x00006567u, 0x00050005u, 0x000009bcu, 0x7466656cu, 0x6764655fu, 0x00000065u, + 0x00040005u, 0x000009bdu, 0x31637261u, 0x00000000u, 0x00040005u, 0x000009c0u, 0x32637261u, 0x00000000u, + 0x00040005u, 0x000009c3u, 0x33637261u, 0x00000000u, 0x00040005u, 0x000009e9u, 0x7473616cu, 0x0074705fu, + 0x00040005u, 0x000009ecu, 0x746e6563u, 0x00007265u, 0x00050005u, 0x000009eeu, 0x7466656cu, 0x6764655fu, + 0x00000065u, 0x00050005u, 0x000009f1u, 0x68676972u, 0x64655f74u, 0x00006567u, 0x00040005u, 0x000009f5u, + 0x31637261u, 0x00000000u, 0x00040005u, 0x000009f8u, 0x32637261u, 0x00000000u, 0x00040005u, 0x000009fbu, + 0x33637261u, 0x00000000u, 0x00030005u, 0x00000a1eu, 0x00000069u, 0x00080005u, 0x00000a6cu, 0x6f6c6f43u, + 0x6c615072u, 0x65747465u, 0x66667542u, 0x61457265u, 0x00796c72u, 0x00070006u, 0x00000a6cu, 0x00000000u, + 0x6f635f67u, 0x5f726f6cu, 0x656c6170u, 0x00657474u, 0x00030005u, 0x00000a6eu, 0x00000000u, 0x00070005u, + 0x00000a70u, 0x656d6954u, 0x6d617473u, 0x75427370u, 0x72656666u, 0x00000000u, 0x00070006u, 0x00000a70u, + 0x00000000u, 0x69745f67u, 0x7473656du, 0x73706d61u, 0x00000000u, 0x00030005u, 0x00000a72u, 0x00000000u, + 0x00060005u, 0x00000a74u, 0x61697254u, 0x656c676eu, 0x66667542u, 0x00007265u, 0x00060006u, 0x00000a74u, + 0x00000000u, 0x72745f67u, 0x676e6169u, 0x0073656cu, 0x00030005u, 0x00000a76u, 0x00000000u, 0x00050005u, + 0x00000a78u, 0x65736f50u, 0x66667542u, 0x00007265u, 0x00050006u, 0x00000a78u, 0x00000000u, 0x6f705f67u, + 0x00736573u, 0x00030005u, 0x00000a7au, 0x00000000u, 0x00050005u, 0x00000a7cu, 0x616f6c46u, 0x66754274u, + 0x00726566u, 0x00060006u, 0x00000a7cu, 0x00000000u, 0x6c665f67u, 0x7374616fu, 0x00000000u, 0x00030005u, + 0x00000a7eu, 0x00000000u, 0x00080005u, 0x00000a7fu, 0x656d6954u, 0x6d617473u, 0x50646570u, 0x67796c6fu, + 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x00000a7fu, 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, + 0x00007370u, 0x00060006u, 0x00000a7fu, 0x00000001u, 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, + 0x00000a7fu, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, 0x00070006u, 0x00000a7fu, + 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, 0x00070006u, 0x00000a7fu, 0x00000004u, + 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x00000a7fu, 0x00000005u, 0x656d6974u, + 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x00000a7fu, 0x00000006u, 0x765f7374u, + 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, 0x00000a7fu, 0x00000007u, + 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000a7fu, 0x00000008u, + 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000a7fu, 0x00000009u, 0x74726576u, + 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x00000a7fu, 0x0000000au, 0x61697274u, 0x656c676eu, + 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, 0x00000a7fu, 0x0000000bu, 0x62626161u, 0x66666f5fu, + 0x00746573u, 0x00050006u, 0x00000a7fu, 0x0000000cu, 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000a7fu, + 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000a7fu, 0x0000000eu, 0x6461705fu, 0x00000033u, + 0x00050006u, 0x00000a7fu, 0x0000000fu, 0x6461705fu, 0x00000034u, 0x00070005u, 0x00000a81u, 0x796c6f50u, + 0x506e6f67u, 0x426c6f6fu, 0x65666675u, 0x00000072u, 0x00070006u, 0x00000a81u, 0x00000000u, 0x6f705f67u, + 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00030005u, 0x00000a83u, 0x00000000u, 0x00060005u, 0x00000a84u, + 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x00000000u, 0x00060006u, 0x00000a84u, 0x00000000u, 0x5f6d756eu, + 0x65627563u, 0x00000073u, 0x00070006u, 0x00000a84u, 0x00000001u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, + 0x00007370u, 0x00070006u, 0x00000a84u, 0x00000002u, 0x5f6d756eu, 0x63617274u, 0x6f705f6bu, 0x00736573u, + 0x00070006u, 0x00000a84u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, + 0x00000a84u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00080006u, + 0x00000a84u, 0x00000005u, 0x65627563u, 0x5f73745fu, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, + 0x00000a84u, 0x00000006u, 0x63617274u, 0x69745f6bu, 0x7473656du, 0x73706d61u, 0x66666f5fu, 0x00746573u, + 0x00080006u, 0x00000a84u, 0x00000007u, 0x6e617274u, 0x74616c73u, 0x736e6f69u, 0x66666f5fu, 0x00746573u, + 0x00080006u, 0x00000a84u, 0x00000008u, 0x74617571u, 0x696e7265u, 0x5f736e6fu, 0x7366666fu, 0x00007465u, + 0x00070006u, 0x00000a84u, 0x00000009u, 0x6c616373u, 0x6f5f7365u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x00000a84u, 0x0000000au, 0x6f6c6f63u, 0x6f5f7372u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000a84u, + 0x0000000bu, 0x646e6572u, 0x665f7265u, 0x7367616cu, 0x00000000u, 0x00050006u, 0x00000a84u, 0x0000000cu, + 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000a84u, 0x0000000du, 0x6461705fu, 0x00000033u, 0x00050006u, + 0x00000a84u, 0x0000000eu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x00000a84u, 0x0000000fu, 0x6461705fu, + 0x00000035u, 0x00070005u, 0x00000a86u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x66667542u, 0x00007265u, + 0x00080006u, 0x00000a86u, 0x00000000u, 0x626f5f67u, 0x63617473u, 0x705f656cu, 0x736c6f6fu, 0x00000000u, + 0x00030005u, 0x00000a88u, 0x00000000u, 0x00030047u, 0x0000002cu, 0x00000002u, 0x00050048u, 0x0000002cu, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000002cu, 0x00000001u, 0x00000023u, 0x00000004u, + 0x00050048u, 0x0000002cu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000002cu, 0x00000003u, + 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000002cu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, + 0x0000002cu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000002cu, 0x00000006u, 0x00000023u, + 0x00000018u, 0x00050048u, 0x0000002cu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000002cu, + 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000002cu, 0x00000009u, 0x00000023u, 0x00000024u, + 0x00050048u, 0x0000002cu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000002cu, 0x0000000bu, + 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000002cu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, + 0x0000002cu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000002cu, 0x0000000eu, 0x00000023u, + 0x00000038u, 0x00050048u, 0x0000002cu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x0000002cu, + 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x0000002cu, 0x00000011u, 0x00000023u, 0x00000044u, + 0x00050048u, 0x0000002cu, 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x0000002cu, 0x00000013u, + 0x00000023u, 0x0000004cu, 0x00050048u, 0x0000002cu, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, + 0x0000002cu, 0x00000015u, 0x00000023u, 0x00000054u, 0x00050048u, 0x0000002cu, 0x00000016u, 0x00000023u, + 0x00000058u, 0x00040047u, 0x00000309u, 0x0000000bu, 0x0000001au, 0x00040047u, 0x0000030eu, 0x0000000bu, + 0x0000001bu, 0x00050048u, 0x0000031cu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000031cu, + 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x0000031cu, 0x00000002u, 0x00000023u, 0x00000008u, + 0x00050048u, 0x0000031cu, 0x00000003u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000031cu, 0x00000004u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x0000031cu, 0x00000005u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x0000031cu, 0x00000006u, 0x00000023u, 0x0000001cu, 0x00040047u, 0x0000031du, 0x00000006u, 0x00000020u, + 0x00030047u, 0x0000031eu, 0x00000002u, 0x00040048u, 0x0000031eu, 0x00000000u, 0x00000018u, 0x00050048u, + 0x0000031eu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000320u, 0x00000018u, 0x00040047u, + 0x00000320u, 0x00000021u, 0x0000000du, 0x00040047u, 0x00000320u, 0x00000022u, 0x00000000u, 0x00040047u, + 0x0000032bu, 0x00000006u, 0x00000004u, 0x00050048u, 0x0000032cu, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00050048u, 0x0000032cu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x0000032cu, 0x00000002u, + 0x00000023u, 0x00000008u, 0x00050048u, 0x0000032cu, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, + 0x0000032cu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000032cu, 0x00000005u, 0x00000023u, + 0x00000014u, 0x00050048u, 0x0000032cu, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x0000032cu, + 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000032cu, 0x00000008u, 0x00000023u, 0x00000020u, + 0x00050048u, 0x0000032cu, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x0000032cu, 0x0000000au, + 0x00000023u, 0x00000028u, 0x00050048u, 0x0000032cu, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, + 0x0000032cu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00040047u, 0x0000032du, 0x00000006u, 0x00000080u, + 0x00030047u, 0x0000032eu, 0x00000002u, 0x00040048u, 0x0000032eu, 0x00000000u, 0x00000018u, 0x00050048u, + 0x0000032eu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000330u, 0x00000018u, 0x00040047u, + 0x00000330u, 0x00000021u, 0x00000006u, 0x00040047u, 0x00000330u, 0x00000022u, 0x00000000u, 0x00050048u, + 0x0000033au, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000033au, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x0000033au, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000033au, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000033au, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x0000033au, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000033au, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x0000033au, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x0000033au, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000033au, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x0000033au, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000033au, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000033au, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x0000033au, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000033au, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x0000033au, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, + 0x0000033bu, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000033cu, 0x00000002u, 0x00040048u, 0x0000033cu, + 0x00000000u, 0x00000018u, 0x00050048u, 0x0000033cu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x0000033eu, 0x00000018u, 0x00040047u, 0x0000033eu, 0x00000021u, 0x00000007u, 0x00040047u, 0x0000033eu, + 0x00000022u, 0x00000000u, 0x00050048u, 0x00000349u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, + 0x00000349u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000349u, 0x00000002u, 0x00000023u, + 0x00000008u, 0x00050048u, 0x00000349u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000349u, + 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000349u, 0x00000005u, 0x00000023u, 0x00000014u, + 0x00050048u, 0x00000349u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000349u, 0x00000007u, + 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000349u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, + 0x00000349u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000349u, 0x0000000au, 0x00000023u, + 0x00000028u, 0x00050048u, 0x00000349u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000349u, + 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000349u, 0x0000000du, 0x00000023u, 0x00000034u, + 0x00050048u, 0x00000349u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000349u, 0x0000000fu, + 0x00000023u, 0x0000003cu, 0x00050048u, 0x00000349u, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, + 0x00000349u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00040047u, 0x0000034au, 0x00000006u, 0x00000048u, + 0x00030047u, 0x0000034bu, 0x00000002u, 0x00040048u, 0x0000034bu, 0x00000000u, 0x00000018u, 0x00050048u, + 0x0000034bu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000034du, 0x00000018u, 0x00040047u, + 0x0000034du, 0x00000021u, 0x0000000bu, 0x00040047u, 0x0000034du, 0x00000022u, 0x00000000u, 0x00040048u, + 0x00000355u, 0x00000000u, 0x00000005u, 0x00050048u, 0x00000355u, 0x00000000u, 0x00000007u, 0x00000010u, + 0x00050048u, 0x00000355u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00040047u, 0x00000356u, 0x00000006u, + 0x00000040u, 0x00030047u, 0x00000357u, 0x00000002u, 0x00040048u, 0x00000357u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x00000357u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000359u, 0x00000018u, + 0x00040047u, 0x00000359u, 0x00000021u, 0x0000000cu, 0x00040047u, 0x00000359u, 0x00000022u, 0x00000000u, + 0x00040047u, 0x00000382u, 0x00000006u, 0x00000004u, 0x00030047u, 0x00000383u, 0x00000002u, 0x00040048u, + 0x00000383u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000383u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x00000385u, 0x00000018u, 0x00040047u, 0x00000385u, 0x00000021u, 0x00000001u, 0x00040047u, + 0x00000385u, 0x00000022u, 0x00000000u, 0x00050048u, 0x000003c3u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00050048u, 0x000003c3u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000003c3u, 0x00000002u, + 0x00000023u, 0x00000008u, 0x00050048u, 0x000003c3u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00040047u, + 0x000003c4u, 0x00000006u, 0x00000010u, 0x00030047u, 0x000003c5u, 0x00000002u, 0x00040048u, 0x000003c5u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x000003c5u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x000003c7u, 0x00000018u, 0x00040047u, 0x000003c7u, 0x00000021u, 0x00000002u, 0x00040047u, 0x000003c7u, + 0x00000022u, 0x00000000u, 0x00030047u, 0x000003fcu, 0x00000002u, 0x00050048u, 0x000003fcu, 0x00000000u, + 0x0000000bu, 0x00000000u, 0x00040047u, 0x0000045au, 0x0000000bu, 0x000014b0u, 0x00030047u, 0x0000046au, + 0x00000002u, 0x00050048u, 0x0000046au, 0x00000000u, 0x0000000bu, 0x00000009u, 0x00040048u, 0x0000046au, + 0x00000000u, 0x00001497u, 0x00030047u, 0x00000476u, 0x00000002u, 0x00040048u, 0x00000476u, 0x00000000u, + 0x00001497u, 0x00040048u, 0x00000476u, 0x00000001u, 0x00001497u, 0x00040047u, 0x00000479u, 0x0000001eu, + 0x00000000u, 0x00040047u, 0x00000a6bu, 0x00000006u, 0x00000010u, 0x00030047u, 0x00000a6cu, 0x00000002u, + 0x00040048u, 0x00000a6cu, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000a6cu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x00000a6eu, 0x00000018u, 0x00040047u, 0x00000a6eu, 0x00000021u, 0x0000000au, + 0x00040047u, 0x00000a6eu, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000a6fu, 0x00000006u, 0x00000008u, + 0x00030047u, 0x00000a70u, 0x00000002u, 0x00040048u, 0x00000a70u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x00000a70u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000a72u, 0x00000018u, 0x00040047u, + 0x00000a72u, 0x00000021u, 0x00000000u, 0x00040047u, 0x00000a72u, 0x00000022u, 0x00000000u, 0x00040047u, + 0x00000a73u, 0x00000006u, 0x00000010u, 0x00030047u, 0x00000a74u, 0x00000002u, 0x00040048u, 0x00000a74u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x00000a74u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x00000a76u, 0x00000018u, 0x00040047u, 0x00000a76u, 0x00000021u, 0x00000003u, 0x00040047u, 0x00000a76u, + 0x00000022u, 0x00000000u, 0x00040047u, 0x00000a77u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000a78u, + 0x00000002u, 0x00040048u, 0x00000a78u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000a78u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x00000a7au, 0x00000018u, 0x00040047u, 0x00000a7au, 0x00000021u, + 0x00000004u, 0x00040047u, 0x00000a7au, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000a7bu, 0x00000006u, + 0x00000004u, 0x00030047u, 0x00000a7cu, 0x00000002u, 0x00040048u, 0x00000a7cu, 0x00000000u, 0x00000018u, + 0x00050048u, 0x00000a7cu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000a7eu, 0x00000018u, + 0x00040047u, 0x00000a7eu, 0x00000021u, 0x00000005u, 0x00040047u, 0x00000a7eu, 0x00000022u, 0x00000000u, + 0x00050048u, 0x00000a7fu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000a7fu, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000a7fu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000a7fu, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000a7fu, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x00000a7fu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000a7fu, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000a7fu, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x00000a7fu, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000a7fu, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x00000a7fu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x00000a7fu, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000a7fu, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00050048u, 0x00000a7fu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000a7fu, + 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000a7fu, 0x0000000fu, 0x00000023u, 0x0000003cu, + 0x00040047u, 0x00000a80u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000a81u, 0x00000002u, 0x00040048u, + 0x00000a81u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000a81u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x00000a83u, 0x00000018u, 0x00040047u, 0x00000a83u, 0x00000021u, 0x00000008u, 0x00040047u, + 0x00000a83u, 0x00000022u, 0x00000000u, 0x00050048u, 0x00000a84u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00050048u, 0x00000a84u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000a84u, 0x00000002u, + 0x00000023u, 0x00000008u, 0x00050048u, 0x00000a84u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, + 0x00000a84u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000a84u, 0x00000005u, 0x00000023u, + 0x00000014u, 0x00050048u, 0x00000a84u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000a84u, + 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000a84u, 0x00000008u, 0x00000023u, 0x00000020u, + 0x00050048u, 0x00000a84u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000a84u, 0x0000000au, + 0x00000023u, 0x00000028u, 0x00050048u, 0x00000a84u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, + 0x00000a84u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000a84u, 0x0000000du, 0x00000023u, + 0x00000034u, 0x00050048u, 0x00000a84u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000a84u, + 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x00000a85u, 0x00000006u, 0x00000040u, 0x00030047u, + 0x00000a86u, 0x00000002u, 0x00040048u, 0x00000a86u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000a86u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000a88u, 0x00000018u, 0x00040047u, 0x00000a88u, + 0x00000021u, 0x00000009u, 0x00040047u, 0x00000a88u, 0x00000022u, 0x00000000u, 0x00020013u, 0x00000002u, + 0x00030021u, 0x00000003u, 0x00000002u, 0x00040015u, 0x00000006u, 0x00000020u, 0x00000000u, 0x0004002bu, + 0x00000006u, 0x00000007u, 0x00000020u, 0x0004002bu, 0x00000006u, 0x00000008u, 0x00000001u, 0x00030016u, + 0x00000009u, 0x00000020u, 0x00040017u, 0x0000000au, 0x00000009u, 0x00000004u, 0x00040020u, 0x0000000bu, + 0x00000007u, 0x0000000au, 0x00040021u, 0x0000000cu, 0x00000009u, 0x0000000bu, 0x00040020u, 0x00000010u, + 0x00000007u, 0x00000006u, 0x00020014u, 0x00000011u, 0x00040021u, 0x00000012u, 0x00000011u, 0x00000010u, + 0x00040017u, 0x00000016u, 0x00000009u, 0x00000003u, 0x00040020u, 0x00000017u, 0x00000007u, 0x00000016u, + 0x00040018u, 0x00000018u, 0x0000000au, 0x00000004u, 0x0003001eu, 0x00000019u, 0x00000018u, 0x00040020u, + 0x0000001au, 0x00000007u, 0x00000019u, 0x0014001eu, 0x0000001bu, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00040020u, + 0x0000001cu, 0x00000007u, 0x0000001bu, 0x00060021u, 0x0000001du, 0x0000000au, 0x00000017u, 0x0000001au, + 0x0000001cu, 0x00040020u, 0x00000023u, 0x00000007u, 0x00000018u, 0x00070021u, 0x00000024u, 0x00000009u, + 0x00000017u, 0x00000017u, 0x00000023u, 0x0000001cu, 0x00040015u, 0x0000002bu, 0x00000020u, 0x00000001u, + 0x0019001eu, 0x0000002cu, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x0000002bu, 0x0000002bu, 0x00000006u, 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000009u, 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00040020u, 0x0000002du, 0x00000009u, 0x0000002cu, 0x0004003bu, 0x0000002du, 0x0000002eu, + 0x00000009u, 0x0004002bu, 0x0000002bu, 0x0000002fu, 0x00000006u, 0x00040020u, 0x00000030u, 0x00000009u, + 0x00000009u, 0x0004002bu, 0x00000009u, 0x00000033u, 0x3f000000u, 0x0004002bu, 0x00000009u, 0x00000037u, + 0x3f800000u, 0x00040020u, 0x00000039u, 0x00000007u, 0x00000009u, 0x0004002bu, 0x00000006u, 0x0000003bu, + 0x00000002u, 0x0004002bu, 0x00000006u, 0x0000003eu, 0x00000003u, 0x0004002bu, 0x00000009u, 0x00000046u, + 0x00000000u, 0x0004002bu, 0x00000006u, 0x0000004bu, 0x00000014u, 0x0004002bu, 0x00000006u, 0x0000004eu, + 0x00000015u, 0x0004002bu, 0x0000002bu, 0x00000054u, 0x00000000u, 0x0004002bu, 0x00000009u, 0x00000065u, + 0x358637bdu, 0x0007002cu, 0x0000000au, 0x00000069u, 0x00000046u, 0x00000046u, 0x00000046u, 0x00000037u, + 0x0004002bu, 0x00000009u, 0x0000006cu, 0x3fc90fdau, 0x0004002bu, 0x0000002bu, 0x0000006du, 0x0000000au, + 0x0004002bu, 0x00000009u, 0x00000073u, 0x3a83126fu, 0x0004002bu, 0x0000002bu, 0x00000079u, 0x00000005u, + 0x0004002bu, 0x00000006u, 0x0000007du, 0x00000000u, 0x0004002bu, 0x0000002bu, 0x00000082u, 0x00000002u, + 0x0004002bu, 0x0000002bu, 0x0000008du, 0x00000003u, 0x0004002bu, 0x00000009u, 0x00000093u, 0x41200000u, + 0x00040017u, 0x0000009au, 0x00000009u, 0x00000002u, 0x0004002bu, 0x00000009u, 0x000000a3u, 0xbf800000u, + 0x0004002bu, 0x0000002bu, 0x000000b9u, 0x00000004u, 0x0004002bu, 0x0000002bu, 0x000000c6u, 0x00000007u, + 0x0004002bu, 0x0000002bu, 0x000000ccu, 0x00000008u, 0x0004002bu, 0x0000002bu, 0x000000d2u, 0x00000009u, + 0x0004002bu, 0x0000002bu, 0x000000deu, 0x0000000bu, 0x0004002bu, 0x0000002bu, 0x000000e5u, 0x0000000cu, + 0x00040020u, 0x000000f5u, 0x00000007u, 0x0000009au, 0x0004002bu, 0x0000002bu, 0x000000fcu, 0x0000000eu, + 0x0004002bu, 0x0000002bu, 0x00000102u, 0x0000000fu, 0x0004002bu, 0x0000002bu, 0x0000010au, 0x00000010u, + 0x0004002bu, 0x0000002bu, 0x00000110u, 0x00000011u, 0x0004002bu, 0x0000002bu, 0x0000011cu, 0x00000001u, + 0x0004002bu, 0x00000009u, 0x00000122u, 0x40000000u, 0x0004002bu, 0x0000002bu, 0x00000140u, 0x0000000du, + 0x0004002bu, 0x00000009u, 0x0000018au, 0x2edbe6ffu, 0x0004002bu, 0x00000009u, 0x00000301u, 0x461c4000u, + 0x00040017u, 0x00000307u, 0x00000006u, 0x00000003u, 0x00040020u, 0x00000308u, 0x00000001u, 0x00000307u, + 0x0004003bu, 0x00000308u, 0x00000309u, 0x00000001u, 0x00040020u, 0x0000030au, 0x00000001u, 0x00000006u, + 0x0004003bu, 0x00000308u, 0x0000030eu, 0x00000001u, 0x000a001eu, 0x00000312u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000009u, 0x00000016u, 0x00000006u, 0x00000009u, 0x00040020u, 0x00000313u, + 0x0000151au, 0x00000312u, 0x0004003bu, 0x00000313u, 0x00000314u, 0x0000151au, 0x00040020u, 0x00000315u, + 0x0000151au, 0x00000006u, 0x00040015u, 0x00000318u, 0x00000040u, 0x00000001u, 0x0009001eu, 0x00000319u, + 0x00000006u, 0x00000006u, 0x00000318u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, + 0x0000031au, 0x00000007u, 0x00000319u, 0x0009001eu, 0x0000031cu, 0x00000006u, 0x00000006u, 0x00000318u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x0000031du, 0x0000031cu, 0x0003001eu, + 0x0000031eu, 0x0000031du, 0x00040020u, 0x0000031fu, 0x0000000cu, 0x0000031eu, 0x0004003bu, 0x0000031fu, + 0x00000320u, 0x0000000cu, 0x00040020u, 0x00000323u, 0x0000000cu, 0x0000031cu, 0x0004001cu, 0x00000327u, + 0x00000006u, 0x0000004bu, 0x000f001eu, 0x00000328u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000327u, 0x00040020u, 0x00000329u, 0x00000007u, 0x00000328u, 0x0004001cu, 0x0000032bu, 0x00000006u, + 0x0000004bu, 0x000f001eu, 0x0000032cu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0000032bu, + 0x0003001du, 0x0000032du, 0x0000032cu, 0x0003001eu, 0x0000032eu, 0x0000032du, 0x00040020u, 0x0000032fu, + 0x0000000cu, 0x0000032eu, 0x0004003bu, 0x0000032fu, 0x00000330u, 0x0000000cu, 0x00040020u, 0x00000333u, + 0x0000000cu, 0x0000032cu, 0x0012001eu, 0x00000337u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x00000338u, 0x00000007u, 0x00000337u, + 0x0012001eu, 0x0000033au, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x0003001du, 0x0000033bu, 0x0000033au, 0x0003001eu, 0x0000033cu, 0x0000033bu, + 0x00040020u, 0x0000033du, 0x0000000cu, 0x0000033cu, 0x0004003bu, 0x0000033du, 0x0000033eu, 0x0000000cu, + 0x00040020u, 0x00000344u, 0x0000000cu, 0x0000033au, 0x0014001eu, 0x00000349u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x0003001du, 0x0000034au, 0x00000349u, 0x0003001eu, 0x0000034bu, 0x0000034au, 0x00040020u, 0x0000034cu, + 0x0000000cu, 0x0000034bu, 0x0004003bu, 0x0000034cu, 0x0000034du, 0x0000000cu, 0x00040020u, 0x00000350u, + 0x0000000cu, 0x00000349u, 0x0003001eu, 0x00000355u, 0x00000018u, 0x0003001du, 0x00000356u, 0x00000355u, + 0x0003001eu, 0x00000357u, 0x00000356u, 0x00040020u, 0x00000358u, 0x0000000cu, 0x00000357u, 0x0004003bu, + 0x00000358u, 0x00000359u, 0x0000000cu, 0x00040020u, 0x0000035cu, 0x0000000cu, 0x00000355u, 0x0004002bu, + 0x00000006u, 0x0000036bu, 0x00000007u, 0x0003001du, 0x00000382u, 0x0000002bu, 0x0003001eu, 0x00000383u, + 0x00000382u, 0x00040020u, 0x00000384u, 0x0000000cu, 0x00000383u, 0x0004003bu, 0x00000384u, 0x00000385u, + 0x0000000cu, 0x00040020u, 0x0000038fu, 0x0000000cu, 0x0000002bu, 0x00040020u, 0x0000039cu, 0x0000151au, + 0x00000009u, 0x0004002bu, 0x00000006u, 0x000003a2u, 0x00000009u, 0x0004002bu, 0x00000006u, 0x000003a6u, + 0x00000008u, 0x0006001eu, 0x000003c0u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00040020u, + 0x000003c1u, 0x00000007u, 0x000003c0u, 0x0006001eu, 0x000003c3u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x0003001du, 0x000003c4u, 0x000003c3u, 0x0003001eu, 0x000003c5u, 0x000003c4u, 0x00040020u, + 0x000003c6u, 0x0000000cu, 0x000003c5u, 0x0004003bu, 0x000003c6u, 0x000003c7u, 0x0000000cu, 0x00040020u, + 0x000003c9u, 0x0000000cu, 0x000003c3u, 0x0003001eu, 0x000003fcu, 0x0000000au, 0x0004002bu, 0x00000006u, + 0x000003fdu, 0x00000080u, 0x0004001cu, 0x000003feu, 0x000003fcu, 0x000003fdu, 0x00040020u, 0x000003ffu, + 0x00000003u, 0x000003feu, 0x0004003bu, 0x000003ffu, 0x00000400u, 0x00000003u, 0x00040020u, 0x00000403u, + 0x00000003u, 0x0000000au, 0x0004002bu, 0x00000009u, 0x00000418u, 0x3f490fd8u, 0x0004002bu, 0x00000006u, + 0x00000457u, 0x0000007eu, 0x0004001cu, 0x00000458u, 0x00000307u, 0x00000457u, 0x00040020u, 0x00000459u, + 0x00000003u, 0x00000458u, 0x0004003bu, 0x00000459u, 0x0000045au, 0x00000003u, 0x00040020u, 0x00000468u, + 0x00000003u, 0x00000307u, 0x0003001eu, 0x0000046au, 0x0000002bu, 0x0004001cu, 0x0000046bu, 0x0000046au, + 0x00000457u, 0x00040020u, 0x0000046cu, 0x00000003u, 0x0000046bu, 0x0004003bu, 0x0000046cu, 0x0000046du, + 0x00000003u, 0x00040020u, 0x00000474u, 0x00000003u, 0x0000002bu, 0x0004001eu, 0x00000476u, 0x00000016u, + 0x00000009u, 0x0004001cu, 0x00000477u, 0x00000476u, 0x00000457u, 0x00040020u, 0x00000478u, 0x00000003u, + 0x00000477u, 0x0004003bu, 0x00000478u, 0x00000479u, 0x00000003u, 0x00040020u, 0x0000047du, 0x0000151au, + 0x00000016u, 0x00040020u, 0x00000480u, 0x00000003u, 0x00000016u, 0x00040020u, 0x00000487u, 0x00000003u, + 0x00000009u, 0x00040020u, 0x0000049du, 0x00000007u, 0x00000011u, 0x0003002au, 0x00000011u, 0x000004cbu, + 0x0004002bu, 0x00000006u, 0x000004e2u, 0x00000040u, 0x0004001cu, 0x000004e3u, 0x00000016u, 0x000004e2u, + 0x00040020u, 0x000004e4u, 0x00000004u, 0x000004e3u, 0x0004003bu, 0x000004e4u, 0x000004e5u, 0x00000004u, + 0x0004002bu, 0x0000002bu, 0x000004e6u, 0x0000003eu, 0x00040020u, 0x000004eeu, 0x00000004u, 0x00000016u, + 0x00030029u, 0x00000011u, 0x000004f0u, 0x0004002bu, 0x0000002bu, 0x00000503u, 0x0000003fu, 0x0004002bu, + 0x00000009u, 0x00000559u, 0x40800000u, 0x0004002bu, 0x00000009u, 0x00000565u, 0x41800000u, 0x0004002bu, + 0x00000009u, 0x00000571u, 0x42800000u, 0x0004002bu, 0x00000006u, 0x00000577u, 0x00000004u, 0x00040020u, + 0x00000579u, 0x00000009u, 0x00000006u, 0x0004002bu, 0x00000006u, 0x000005a4u, 0x00000032u, 0x0004001cu, + 0x000005b2u, 0x0000000au, 0x000004e2u, 0x00040020u, 0x000005b3u, 0x00000004u, 0x000005b2u, 0x0004003bu, + 0x000005b3u, 0x000005b4u, 0x00000004u, 0x0004002bu, 0x0000002bu, 0x000005b5u, 0x0000003du, 0x00040020u, + 0x000005b8u, 0x00000004u, 0x00000009u, 0x0004002bu, 0x00000006u, 0x000005c0u, 0x00000108u, 0x00040020u, + 0x000005edu, 0x00000004u, 0x0000000au, 0x0004001cu, 0x000005f7u, 0x0000009au, 0x000004e2u, 0x00040020u, + 0x000005f8u, 0x00000004u, 0x000005f7u, 0x0004003bu, 0x000005f8u, 0x000005f9u, 0x00000004u, 0x00040020u, + 0x0000060eu, 0x00000004u, 0x0000009au, 0x0004002bu, 0x00000006u, 0x00000637u, 0x00000078u, 0x0005002cu, + 0x0000009au, 0x0000064fu, 0x00000046u, 0x00000046u, 0x00040020u, 0x00000678u, 0x00000007u, 0x0000002bu, + 0x0005002cu, 0x0000009au, 0x00000853u, 0x00000037u, 0x00000046u, 0x0004001cu, 0x000008bfu, 0x00000009u, + 0x0000003eu, 0x00040020u, 0x000008c0u, 0x00000007u, 0x000008bfu, 0x0004002bu, 0x00000009u, 0x000008c2u, + 0x3f490ff9u, 0x0004002bu, 0x00000009u, 0x000008c3u, 0x3fc90ff9u, 0x0004002bu, 0x00000009u, 0x000008c4u, + 0x4016cbfbu, 0x0006002cu, 0x000008bfu, 0x000008c5u, 0x000008c2u, 0x000008c3u, 0x000008c4u, 0x0004002bu, + 0x00000006u, 0x00000a36u, 0x00000005u, 0x0004002bu, 0x00000006u, 0x00000a37u, 0x00000006u, 0x0004002bu, + 0x00000006u, 0x00000a38u, 0x0000000au, 0x0004002bu, 0x00000006u, 0x00000a39u, 0x0000000bu, 0x0004002bu, + 0x00000006u, 0x00000a3au, 0x0000000cu, 0x0004002bu, 0x00000006u, 0x00000a3bu, 0x0000000du, 0x0004002bu, + 0x00000006u, 0x00000a3cu, 0x0000000eu, 0x0004002bu, 0x00000006u, 0x00000a3du, 0x0000000fu, 0x0004002bu, + 0x00000006u, 0x00000a3eu, 0x00000010u, 0x0004002bu, 0x00000006u, 0x00000a3fu, 0x00000011u, 0x0004002bu, + 0x00000006u, 0x00000a40u, 0x00000012u, 0x0004002bu, 0x00000006u, 0x00000a41u, 0x00000013u, 0x0004002bu, + 0x00000009u, 0x00000a42u, 0x3f7dfdfeu, 0x0004002bu, 0x00000009u, 0x00000a43u, 0x3b808081u, 0x0004002bu, + 0x00000009u, 0x00000a44u, 0x3f68e8e9u, 0x0006002cu, 0x00000016u, 0x00000a45u, 0x00000a42u, 0x00000a43u, + 0x00000a44u, 0x0004002bu, 0x00000009u, 0x00000a46u, 0x3ec4c4c5u, 0x0004002bu, 0x00000009u, 0x00000a47u, + 0x3f37b7b8u, 0x0004002bu, 0x00000009u, 0x00000a48u, 0x3f79f9fau, 0x0006002cu, 0x00000016u, 0x00000a49u, + 0x00000a46u, 0x00000a47u, 0x00000a48u, 0x0004002bu, 0x00000009u, 0x00000a4au, 0x3f0b8b8cu, 0x0004002bu, + 0x00000009u, 0x00000a4bu, 0x3ebababbu, 0x0006002cu, 0x00000016u, 0x00000a4cu, 0x00000a4au, 0x00000a4bu, + 0x00000037u, 0x0004002bu, 0x00000009u, 0x00000a4du, 0x3ec8c8c9u, 0x0006002cu, 0x00000016u, 0x00000a4eu, + 0x00000037u, 0x00000a4du, 0x00000046u, 0x0006002cu, 0x00000016u, 0x00000a4fu, 0x00000046u, 0x00000037u, + 0x00000046u, 0x0004002bu, 0x00000009u, 0x00000a50u, 0x3ed8d8d9u, 0x0004002bu, 0x00000009u, 0x00000a51u, + 0x3f33b3b4u, 0x0004002bu, 0x00000009u, 0x00000a52u, 0x3e6cecedu, 0x0006002cu, 0x00000016u, 0x00000a53u, + 0x00000a50u, 0x00000a51u, 0x00000a52u, 0x0004002bu, 0x00000009u, 0x00000a54u, 0x3e8a8a8bu, 0x0004002bu, + 0x00000009u, 0x00000a55u, 0x3f31b1b2u, 0x0006002cu, 0x00000016u, 0x00000a56u, 0x00000a47u, 0x00000a54u, + 0x00000a55u, 0x0004002bu, 0x00000009u, 0x00000a57u, 0x3da0a0a1u, 0x0004002bu, 0x00000009u, 0x00000a58u, + 0x3f7efeffu, 0x0004002bu, 0x00000009u, 0x00000a59u, 0x3f39b9bau, 0x0006002cu, 0x00000016u, 0x00000a5au, + 0x00000a57u, 0x00000a58u, 0x00000a59u, 0x0006002cu, 0x00000016u, 0x00000a5bu, 0x00000a4du, 0x00000a4du, + 0x00000a4du, 0x0004002bu, 0x00000009u, 0x00000a5cu, 0x3d008081u, 0x0004002bu, 0x00000009u, 0x00000a5du, + 0x3c008081u, 0x0006002cu, 0x00000016u, 0x00000a5eu, 0x00000a5cu, 0x00000a5du, 0x00000037u, 0x0004002bu, + 0x00000009u, 0x00000a5fu, 0x3ea0a0a1u, 0x0004002bu, 0x00000009u, 0x00000a60u, 0x3ef0f0f1u, 0x0006002cu, + 0x00000016u, 0x00000a61u, 0x00000a5fu, 0x00000a5fu, 0x00000a60u, 0x0004002bu, 0x00000009u, 0x00000a62u, + 0x3e70f0f1u, 0x0006002cu, 0x00000016u, 0x00000a63u, 0x00000a62u, 0x00000a60u, 0x00000a62u, 0x0006002cu, + 0x00000016u, 0x00000a64u, 0x00000a60u, 0x00000a5fu, 0x00000a5fu, 0x0006002cu, 0x00000016u, 0x00000a65u, + 0x00000037u, 0x00000037u, 0x00000037u, 0x0006002cu, 0x00000016u, 0x00000a66u, 0x00000037u, 0x00000037u, + 0x00000046u, 0x0004002bu, 0x00000009u, 0x00000a67u, 0x40e00000u, 0x0004002bu, 0x00000009u, 0x00000a68u, + 0x41400000u, 0x0004002bu, 0x00000009u, 0x00000a69u, 0x40a00000u, 0x0004002bu, 0x00000009u, 0x00000a6au, + 0x40400000u, 0x0003001du, 0x00000a6bu, 0x0000000au, 0x0003001eu, 0x00000a6cu, 0x00000a6bu, 0x00040020u, + 0x00000a6du, 0x0000000cu, 0x00000a6cu, 0x0004003bu, 0x00000a6du, 0x00000a6eu, 0x0000000cu, 0x0003001du, + 0x00000a6fu, 0x00000318u, 0x0003001eu, 0x00000a70u, 0x00000a6fu, 0x00040020u, 0x00000a71u, 0x0000000cu, + 0x00000a70u, 0x0004003bu, 0x00000a71u, 0x00000a72u, 0x0000000cu, 0x0003001du, 0x00000a73u, 0x00000307u, + 0x0003001eu, 0x00000a74u, 0x00000a73u, 0x00040020u, 0x00000a75u, 0x0000000cu, 0x00000a74u, 0x0004003bu, + 0x00000a75u, 0x00000a76u, 0x0000000cu, 0x0003001du, 0x00000a77u, 0x00000355u, 0x0003001eu, 0x00000a78u, + 0x00000a77u, 0x00040020u, 0x00000a79u, 0x0000000cu, 0x00000a78u, 0x0004003bu, 0x00000a79u, 0x00000a7au, + 0x0000000cu, 0x0003001du, 0x00000a7bu, 0x00000009u, 0x0003001eu, 0x00000a7cu, 0x00000a7bu, 0x00040020u, + 0x00000a7du, 0x0000000cu, 0x00000a7cu, 0x0004003bu, 0x00000a7du, 0x00000a7eu, 0x0000000cu, 0x0012001eu, + 0x00000a7fu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x0003001du, 0x00000a80u, 0x00000a7fu, 0x0003001eu, 0x00000a81u, 0x00000a80u, 0x00040020u, + 0x00000a82u, 0x0000000cu, 0x00000a81u, 0x0004003bu, 0x00000a82u, 0x00000a83u, 0x0000000cu, 0x0012001eu, + 0x00000a84u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x0003001du, 0x00000a85u, 0x00000a84u, 0x0003001eu, 0x00000a86u, 0x00000a85u, 0x00040020u, + 0x00000a87u, 0x0000000cu, 0x00000a86u, 0x0004003bu, 0x00000a87u, 0x00000a88u, 0x0000000cu, 0x0006002cu, + 0x00000307u, 0x00000a89u, 0x00000007u, 0x00000008u, 0x00000008u, 0x0004002bu, 0x00000006u, 0x00000a8au, + 0x0000003eu, 0x0004002bu, 0x00000006u, 0x00000a8bu, 0x0000003fu, 0x0004002bu, 0x00000006u, 0x00000a8cu, + 0x0000003du, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, + 0x0004003bu, 0x00000010u, 0x00000305u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000306u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000030du, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000311u, 0x00000007u, + 0x0004003bu, 0x0000031au, 0x0000031bu, 0x00000007u, 0x0004003bu, 0x00000329u, 0x0000032au, 0x00000007u, + 0x0004003bu, 0x00000338u, 0x00000339u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x00000348u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x00000354u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000360u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000363u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000369u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000036du, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000372u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000037cu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000393u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000039bu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000003a0u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000003a4u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000003afu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000003b8u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000003bcu, 0x00000007u, + 0x0004003bu, 0x000003c1u, 0x000003c2u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000003cdu, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000003d5u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000003d6u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x000003d8u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x000003dau, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x000003ddu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000003e5u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000003f9u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000405u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x00000406u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000409u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000040du, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000415u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x0000041au, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000422u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x00000426u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000448u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000044bu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000453u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000048eu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000491u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000494u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000499u, 0x00000007u, + 0x0004003bu, 0x0000049du, 0x0000049eu, 0x00000007u, 0x0004003bu, 0x0000049du, 0x000004a1u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x000004abu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000004afu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000004c1u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000004c9u, 0x00000007u, + 0x0004003bu, 0x0000049du, 0x000004cau, 0x00000007u, 0x0004003bu, 0x0000049du, 0x000004ccu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000004d8u, 0x00000007u, 0x0004003bu, 0x000003c1u, 0x000004ddu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000004f9u, 0x00000007u, 0x0004003bu, 0x000003c1u, 0x000004feu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000050cu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000515u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000519u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000051du, 0x00000007u, + 0x0004003bu, 0x000003c1u, 0x00000522u, 0x00000007u, 0x0004003bu, 0x000003c1u, 0x00000527u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x0000052cu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x00000534u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000053cu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x0000053du, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x0000053fu, 0x00000007u, 0x0004003bu, 0x00000023u, 0x00000541u, 0x00000007u, + 0x0004003bu, 0x0000001cu, 0x00000544u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000547u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x00000548u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000057du, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000589u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000592u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x00000598u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000005c1u, 0x00000007u, + 0x0004003bu, 0x0000049du, 0x000005c5u, 0x00000007u, 0x0004003bu, 0x0000049du, 0x000005c9u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000005d5u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000005dfu, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000005e3u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000005e4u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x000005e6u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x000005e8u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x000005efu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000612u, 0x00000007u, + 0x0004003bu, 0x0000049du, 0x00000615u, 0x00000007u, 0x0004003bu, 0x0000049du, 0x00000616u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000617u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000061du, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000623u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000626u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000628u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000062du, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000631u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000063bu, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x00000645u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000649u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000064du, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x0000064eu, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x00000650u, 0x00000007u, 0x0004003bu, 0x0000049du, 0x00000651u, 0x00000007u, + 0x0004003bu, 0x0000049du, 0x00000654u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000659u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x0000065bu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x0000066fu, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x00000674u, 0x00000007u, 0x0004003bu, 0x00000678u, 0x00000679u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x00000681u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000686u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x00000687u, 0x00000007u, 0x0004003bu, 0x0000001au, 0x00000689u, 0x00000007u, + 0x0004003bu, 0x0000001cu, 0x0000068bu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000699u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x0000069au, 0x00000007u, 0x0004003bu, 0x0000001au, 0x0000069cu, 0x00000007u, + 0x0004003bu, 0x0000001cu, 0x0000069eu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000006a1u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x000006cfu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000006d4u, 0x00000007u, + 0x0004003bu, 0x00000678u, 0x000006d8u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000006e0u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000006e5u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000006e6u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x000006e8u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x000006eau, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000006f8u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000006f9u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x000006fbu, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x000006fdu, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x00000700u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x0000071au, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x0000072eu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x00000732u, 0x00000007u, + 0x0004003bu, 0x00000678u, 0x00000737u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x0000073fu, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x00000744u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x00000745u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x00000747u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x00000749u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x00000757u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x00000758u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x0000075au, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x0000075cu, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000075fu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000776u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000077au, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000788u, 0x00000007u, + 0x0004003bu, 0x00000017u, 0x0000079cu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000007a0u, 0x00000007u, + 0x0004003bu, 0x00000678u, 0x000007a5u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000007adu, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000007b2u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000007b3u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x000007b5u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x000007b7u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000007c5u, 0x00000007u, 0x0004003bu, 0x00000017u, 0x000007c6u, 0x00000007u, + 0x0004003bu, 0x0000001au, 0x000007c8u, 0x00000007u, 0x0004003bu, 0x0000001cu, 0x000007cau, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x000007cdu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000007e4u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x000007e8u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000007f3u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x00000805u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x0000080cu, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x00000813u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000817u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x0000081eu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000823u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x00000829u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000854u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x00000855u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000858u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000085cu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000086au, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000879u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000008a7u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x000008aau, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000008adu, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x000008b0u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000008b5u, 0x00000007u, + 0x0004003bu, 0x000008c0u, 0x000008c1u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000008c6u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x000008c7u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000008cau, 0x00000007u, + 0x0004003bu, 0x00000678u, 0x000008ceu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000008d6u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x000008dau, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000008e5u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x000008f1u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000919u, 0x00000007u, + 0x0004003bu, 0x0000000bu, 0x0000091cu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000920u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x00000924u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000929u, 0x00000007u, + 0x0004003bu, 0x000000f5u, 0x0000092eu, 0x00000007u, 0x0004003bu, 0x000008c0u, 0x00000938u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x00000939u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000093au, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x0000093du, 0x00000007u, 0x0004003bu, 0x00000678u, 0x00000941u, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x00000949u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x0000094du, 0x00000007u, + 0x0004003bu, 0x00000039u, 0x00000958u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000964u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000098au, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000098bu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x00000994u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000997u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x0000099bu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x0000099fu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009b9u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000009bbu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009bcu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000009bdu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009c0u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000009c3u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009e9u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000009ecu, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009eeu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000009f1u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009f5u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x000009f8u, 0x00000007u, + 0x0004003bu, 0x00000010u, 0x000009fbu, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000a1eu, 0x00000007u, + 0x0003003eu, 0x00000305u, 0x0000007du, 0x00050041u, 0x0000030au, 0x0000030bu, 0x00000309u, 0x0000007du, + 0x0004003du, 0x00000006u, 0x0000030cu, 0x0000030bu, 0x0003003eu, 0x00000306u, 0x0000030cu, 0x00050041u, + 0x0000030au, 0x0000030fu, 0x0000030eu, 0x0000007du, 0x0004003du, 0x00000006u, 0x00000310u, 0x0000030fu, + 0x0003003eu, 0x0000030du, 0x00000310u, 0x00050041u, 0x00000315u, 0x00000316u, 0x00000314u, 0x0000008du, + 0x0004003du, 0x00000006u, 0x00000317u, 0x00000316u, 0x0003003eu, 0x00000311u, 0x00000317u, 0x00050041u, + 0x00000315u, 0x00000321u, 0x00000314u, 0x00000054u, 0x0004003du, 0x00000006u, 0x00000322u, 0x00000321u, + 0x00060041u, 0x00000323u, 0x00000324u, 0x00000320u, 0x00000054u, 0x00000322u, 0x0004003du, 0x0000031cu, + 0x00000325u, 0x00000324u, 0x00040190u, 0x00000319u, 0x00000326u, 0x00000325u, 0x0003003eu, 0x0000031bu, + 0x00000326u, 0x00050041u, 0x00000010u, 0x00000331u, 0x0000031bu, 0x00000054u, 0x0004003du, 0x00000006u, + 0x00000332u, 0x00000331u, 0x00060041u, 0x00000333u, 0x00000334u, 0x00000330u, 0x00000054u, 0x00000332u, + 0x0004003du, 0x0000032cu, 0x00000335u, 0x00000334u, 0x00040190u, 0x00000328u, 0x00000336u, 0x00000335u, + 0x0003003eu, 0x0000032au, 0x00000336u, 0x00050041u, 0x00000010u, 0x0000033fu, 0x0000032au, 0x0000011cu, + 0x0004003du, 0x00000006u, 0x00000340u, 0x0000033fu, 0x00050041u, 0x00000315u, 0x00000341u, 0x00000314u, + 0x0000011cu, 0x0004003du, 0x00000006u, 0x00000342u, 0x00000341u, 0x00050080u, 0x00000006u, 0x00000343u, + 0x00000340u, 0x00000342u, 0x00060041u, 0x00000344u, 0x00000345u, 0x0000033eu, 0x00000054u, 0x00000343u, + 0x0004003du, 0x0000033au, 0x00000346u, 0x00000345u, 0x00040190u, 0x00000337u, 0x00000347u, 0x00000346u, + 0x0003003eu, 0x00000339u, 0x00000347u, 0x00050041u, 0x00000010u, 0x0000034eu, 0x0000031bu, 0x0000011cu, + 0x0004003du, 0x00000006u, 0x0000034fu, 0x0000034eu, 0x00060041u, 0x00000350u, 0x00000351u, 0x0000034du, + 0x00000054u, 0x0000034fu, 0x0004003du, 0x00000349u, 0x00000352u, 0x00000351u, 0x00040190u, 0x0000001bu, + 0x00000353u, 0x00000352u, 0x0003003eu, 0x00000348u, 0x00000353u, 0x00050041u, 0x00000315u, 0x0000035au, + 0x00000314u, 0x00000054u, 0x0004003du, 0x00000006u, 0x0000035bu, 0x0000035au, 0x00060041u, 0x0000035cu, + 0x0000035du, 0x00000359u, 0x00000054u, 0x0000035bu, 0x0004003du, 0x00000355u, 0x0000035eu, 0x0000035du, + 0x00040190u, 0x00000019u, 0x0000035fu, 0x0000035eu, 0x0003003eu, 0x00000354u, 0x0000035fu, 0x00050041u, + 0x00000315u, 0x00000361u, 0x00000314u, 0x0000002fu, 0x0004003du, 0x00000006u, 0x00000362u, 0x00000361u, + 0x0003003eu, 0x00000360u, 0x00000362u, 0x00050041u, 0x00000010u, 0x00000364u, 0x00000339u, 0x0000008du, + 0x0004003du, 0x00000006u, 0x00000365u, 0x00000364u, 0x0003003eu, 0x00000363u, 0x00000365u, 0x00050039u, + 0x00000011u, 0x00000366u, 0x00000014u, 0x00000363u, 0x000300f7u, 0x00000368u, 0x00000000u, 0x000400fau, + 0x00000366u, 0x00000367u, 0x00000368u, 0x000200f8u, 0x00000367u, 0x0004003du, 0x00000006u, 0x0000036au, + 0x00000306u, 0x00050084u, 0x00000006u, 0x0000036cu, 0x0000036au, 0x0000036bu, 0x0003003eu, 0x00000369u, + 0x0000036cu, 0x0004003du, 0x00000006u, 0x0000036eu, 0x00000369u, 0x00050080u, 0x00000006u, 0x0000036fu, + 0x0000036eu, 0x0000036bu, 0x0004003du, 0x00000006u, 0x00000370u, 0x00000311u, 0x0007000cu, 0x00000006u, + 0x00000371u, 0x00000001u, 0x00000026u, 0x0000036fu, 0x00000370u, 0x0003003eu, 0x0000036du, 0x00000371u, + 0x0004003du, 0x00000006u, 0x00000373u, 0x0000036du, 0x0004003du, 0x00000006u, 0x00000374u, 0x00000369u, + 0x00050082u, 0x00000006u, 0x00000375u, 0x00000373u, 0x00000374u, 0x0003003eu, 0x00000372u, 0x00000375u, + 0x0004003du, 0x00000006u, 0x00000376u, 0x00000372u, 0x000500aau, 0x00000011u, 0x00000377u, 0x00000376u, + 0x0000007du, 0x000300f7u, 0x00000379u, 0x00000000u, 0x000400fau, 0x00000377u, 0x00000378u, 0x00000379u, + 0x000200f8u, 0x00000378u, 0x0003003eu, 0x00000305u, 0x0000007du, 0x0004003du, 0x00000006u, 0x0000037au, + 0x00000305u, 0x000314afu, 0x0000007du, 0x0000037au, 0x000100fdu, 0x000200f8u, 0x00000379u, 0x0003003eu, + 0x0000037cu, 0x0000007du, 0x00050041u, 0x00000315u, 0x0000037du, 0x00000314u, 0x00000082u, 0x0004003du, + 0x00000006u, 0x0000037eu, 0x0000037du, 0x000500acu, 0x00000011u, 0x0000037fu, 0x0000037eu, 0x0000007du, + 0x000300f7u, 0x00000381u, 0x00000000u, 0x000400fau, 0x0000037fu, 0x00000380u, 0x00000381u, 0x000200f8u, + 0x00000380u, 0x00050041u, 0x00000010u, 0x00000386u, 0x0000032au, 0x000000c6u, 0x0004003du, 0x00000006u, + 0x00000387u, 0x00000386u, 0x00050041u, 0x00000010u, 0x00000388u, 0x00000339u, 0x0000002fu, 0x0004003du, + 0x00000006u, 0x00000389u, 0x00000388u, 0x00050080u, 0x00000006u, 0x0000038au, 0x00000387u, 0x00000389u, + 0x00050041u, 0x00000315u, 0x0000038bu, 0x00000314u, 0x00000082u, 0x0004003du, 0x00000006u, 0x0000038cu, + 0x0000038bu, 0x00050080u, 0x00000006u, 0x0000038du, 0x0000038au, 0x0000038cu, 0x00050082u, 0x00000006u, + 0x0000038eu, 0x0000038du, 0x00000008u, 0x00060041u, 0x0000038fu, 0x00000390u, 0x00000385u, 0x00000054u, + 0x0000038eu, 0x0004003du, 0x0000002bu, 0x00000391u, 0x00000390u, 0x0004007cu, 0x00000006u, 0x00000392u, + 0x00000391u, 0x0003003eu, 0x0000037cu, 0x00000392u, 0x000200f9u, 0x00000381u, 0x000200f8u, 0x00000381u, + 0x00050041u, 0x00000010u, 0x00000394u, 0x0000032au, 0x000000ccu, 0x0004003du, 0x00000006u, 0x00000395u, + 0x00000394u, 0x00050041u, 0x00000010u, 0x00000396u, 0x00000339u, 0x000000c6u, 0x0004003du, 0x00000006u, + 0x00000397u, 0x00000396u, 0x00050080u, 0x00000006u, 0x00000398u, 0x00000395u, 0x00000397u, 0x0004003du, + 0x00000006u, 0x00000399u, 0x0000037cu, 0x00050080u, 0x00000006u, 0x0000039au, 0x00000398u, 0x00000399u, + 0x0003003eu, 0x00000393u, 0x0000039au, 0x00050041u, 0x0000039cu, 0x0000039du, 0x00000314u, 0x000000b9u, + 0x0004003du, 0x00000009u, 0x0000039eu, 0x0000039du, 0x00050085u, 0x00000009u, 0x0000039fu, 0x0000039eu, + 0x00000033u, 0x0003003eu, 0x0000039bu, 0x0000039fu, 0x0004003du, 0x00000006u, 0x000003a1u, 0x00000372u, + 0x00050084u, 0x00000006u, 0x000003a3u, 0x000003a1u, 0x000003a2u, 0x0003003eu, 0x000003a0u, 0x000003a3u, + 0x0004003du, 0x00000006u, 0x000003a5u, 0x00000372u, 0x00050084u, 0x00000006u, 0x000003a7u, 0x000003a5u, + 0x000003a6u, 0x0003003eu, 0x000003a4u, 0x000003a7u, 0x0004003du, 0x00000006u, 0x000003a8u, 0x000003a4u, + 0x0003003eu, 0x00000305u, 0x000003a8u, 0x0004003du, 0x00000006u, 0x000003a9u, 0x000003a0u, 0x0004003du, + 0x00000006u, 0x000003aau, 0x00000305u, 0x000314afu, 0x000003a9u, 0x000003aau, 0x0004003du, 0x00000006u, + 0x000003abu, 0x0000030du, 0x000500aau, 0x00000011u, 0x000003acu, 0x000003abu, 0x0000007du, 0x000300f7u, + 0x000003aeu, 0x00000000u, 0x000400fau, 0x000003acu, 0x000003adu, 0x000003aeu, 0x000200f8u, 0x000003adu, + 0x0003003eu, 0x000003afu, 0x0000007du, 0x000200f9u, 0x000003b0u, 0x000200f8u, 0x000003b0u, 0x000400f6u, + 0x000003b2u, 0x000003b3u, 0x00000000u, 0x000200f9u, 0x000003b4u, 0x000200f8u, 0x000003b4u, 0x0004003du, + 0x00000006u, 0x000003b5u, 0x000003afu, 0x0004003du, 0x00000006u, 0x000003b6u, 0x00000372u, 0x000500b0u, + 0x00000011u, 0x000003b7u, 0x000003b5u, 0x000003b6u, 0x000400fau, 0x000003b7u, 0x000003b1u, 0x000003b2u, + 0x000200f8u, 0x000003b1u, 0x0004003du, 0x00000006u, 0x000003b9u, 0x00000369u, 0x0004003du, 0x00000006u, + 0x000003bau, 0x000003afu, 0x00050080u, 0x00000006u, 0x000003bbu, 0x000003b9u, 0x000003bau, 0x0003003eu, + 0x000003b8u, 0x000003bbu, 0x0004003du, 0x00000006u, 0x000003bdu, 0x00000393u, 0x0004003du, 0x00000006u, + 0x000003beu, 0x000003b8u, 0x00050080u, 0x00000006u, 0x000003bfu, 0x000003bdu, 0x000003beu, 0x0003003eu, + 0x000003bcu, 0x000003bfu, 0x0004003du, 0x00000006u, 0x000003c8u, 0x000003bcu, 0x00060041u, 0x000003c9u, + 0x000003cau, 0x000003c7u, 0x00000054u, 0x000003c8u, 0x0004003du, 0x000003c3u, 0x000003cbu, 0x000003cau, + 0x00040190u, 0x000003c0u, 0x000003ccu, 0x000003cbu, 0x0003003eu, 0x000003c2u, 0x000003ccu, 0x00050041u, + 0x00000039u, 0x000003ceu, 0x000003c2u, 0x00000054u, 0x0004003du, 0x00000009u, 0x000003cfu, 0x000003ceu, + 0x00050041u, 0x00000039u, 0x000003d0u, 0x000003c2u, 0x0000011cu, 0x0004003du, 0x00000009u, 0x000003d1u, + 0x000003d0u, 0x00050041u, 0x00000039u, 0x000003d2u, 0x000003c2u, 0x00000082u, 0x0004003du, 0x00000009u, + 0x000003d3u, 0x000003d2u, 0x00060050u, 0x00000016u, 0x000003d4u, 0x000003cfu, 0x000003d1u, 0x000003d3u, + 0x0003003eu, 0x000003cdu, 0x000003d4u, 0x0004003du, 0x00000016u, 0x000003d7u, 0x000003cdu, 0x0003003eu, + 0x000003d6u, 0x000003d7u, 0x0004003du, 0x00000019u, 0x000003d9u, 0x00000354u, 0x0003003eu, 0x000003d8u, + 0x000003d9u, 0x0004003du, 0x0000001bu, 0x000003dbu, 0x00000348u, 0x0003003eu, 0x000003dau, 0x000003dbu, + 0x00070039u, 0x0000000au, 0x000003dcu, 0x00000021u, 0x000003d6u, 0x000003d8u, 0x000003dau, 0x0003003eu, + 0x000003d5u, 0x000003dcu, 0x00050041u, 0x00000039u, 0x000003deu, 0x000003d5u, 0x0000003eu, 0x0004003du, + 0x00000009u, 0x000003dfu, 0x000003deu, 0x0003003eu, 0x000003ddu, 0x000003dfu, 0x0004003du, 0x00000009u, + 0x000003e0u, 0x000003ddu, 0x0006000cu, 0x00000009u, 0x000003e1u, 0x00000001u, 0x00000004u, 0x000003e0u, + 0x000500b8u, 0x00000011u, 0x000003e2u, 0x000003e1u, 0x00000065u, 0x000300f7u, 0x000003e4u, 0x00000000u, + 0x000400fau, 0x000003e2u, 0x000003e3u, 0x000003e4u, 0x000200f8u, 0x000003e3u, 0x0003003eu, 0x000003ddu, + 0x00000065u, 0x000200f9u, 0x000003e4u, 0x000200f8u, 0x000003e4u, 0x00050041u, 0x00000039u, 0x000003e6u, + 0x000003d5u, 0x0000007du, 0x0004003du, 0x00000009u, 0x000003e7u, 0x000003e6u, 0x0004003du, 0x00000009u, + 0x000003e8u, 0x000003ddu, 0x00050088u, 0x00000009u, 0x000003e9u, 0x000003e7u, 0x000003e8u, 0x00050085u, + 0x00000009u, 0x000003eau, 0x000003e9u, 0x00000033u, 0x00050081u, 0x00000009u, 0x000003ebu, 0x000003eau, + 0x00000033u, 0x00050041u, 0x00000039u, 0x000003ecu, 0x00000348u, 0x00000082u, 0x0004003du, 0x00000009u, + 0x000003edu, 0x000003ecu, 0x00050085u, 0x00000009u, 0x000003eeu, 0x000003ebu, 0x000003edu, 0x00050041u, + 0x00000039u, 0x000003efu, 0x000003d5u, 0x00000008u, 0x0004003du, 0x00000009u, 0x000003f0u, 0x000003efu, + 0x0004003du, 0x00000009u, 0x000003f1u, 0x000003ddu, 0x00050088u, 0x00000009u, 0x000003f2u, 0x000003f0u, + 0x000003f1u, 0x00050085u, 0x00000009u, 0x000003f3u, 0x000003f2u, 0x00000033u, 0x00050083u, 0x00000009u, + 0x000003f4u, 0x00000033u, 0x000003f3u, 0x00050041u, 0x00000039u, 0x000003f5u, 0x00000348u, 0x0000008du, + 0x0004003du, 0x00000009u, 0x000003f6u, 0x000003f5u, 0x00050085u, 0x00000009u, 0x000003f7u, 0x000003f4u, + 0x000003f6u, 0x00050050u, 0x0000009au, 0x000003f8u, 0x000003eeu, 0x000003f7u, 0x0003003eu, 0x000003e5u, + 0x000003f8u, 0x0004003du, 0x00000006u, 0x000003fau, 0x000003afu, 0x00050084u, 0x00000006u, 0x000003fbu, + 0x000003fau, 0x000003a2u, 0x0003003eu, 0x000003f9u, 0x000003fbu, 0x0004003du, 0x00000006u, 0x00000401u, + 0x000003f9u, 0x0004003du, 0x0000000au, 0x00000402u, 0x000003d5u, 0x00060041u, 0x00000403u, 0x00000404u, + 0x00000400u, 0x00000401u, 0x00000054u, 0x0003003eu, 0x00000404u, 0x00000402u, 0x0004003du, 0x0000000au, + 0x00000407u, 0x000003d5u, 0x0003003eu, 0x00000406u, 0x00000407u, 0x00050039u, 0x00000009u, 0x00000408u, + 0x0000000eu, 0x00000406u, 0x0003003eu, 0x00000405u, 0x00000408u, 0x0004003du, 0x00000009u, 0x0000040au, + 0x0000039bu, 0x0004003du, 0x00000009u, 0x0000040bu, 0x00000405u, 0x00050085u, 0x00000009u, 0x0000040cu, + 0x0000040au, 0x0000040bu, 0x0003003eu, 0x00000409u, 0x0000040cu, 0x0003003eu, 0x0000040du, 0x0000007du, + 0x000200f9u, 0x0000040eu, 0x000200f8u, 0x0000040eu, 0x000400f6u, 0x00000410u, 0x00000411u, 0x00000000u, + 0x000200f9u, 0x00000412u, 0x000200f8u, 0x00000412u, 0x0004003du, 0x00000006u, 0x00000413u, 0x0000040du, + 0x000500b0u, 0x00000011u, 0x00000414u, 0x00000413u, 0x000003a6u, 0x000400fau, 0x00000414u, 0x0000040fu, + 0x00000410u, 0x000200f8u, 0x0000040fu, 0x0004003du, 0x00000006u, 0x00000416u, 0x0000040du, 0x00040070u, + 0x00000009u, 0x00000417u, 0x00000416u, 0x00050085u, 0x00000009u, 0x00000419u, 0x00000417u, 0x00000418u, + 0x0003003eu, 0x00000415u, 0x00000419u, 0x0004003du, 0x00000009u, 0x0000041bu, 0x00000415u, 0x0006000cu, + 0x00000009u, 0x0000041cu, 0x00000001u, 0x0000000eu, 0x0000041bu, 0x0004003du, 0x00000009u, 0x0000041du, + 0x00000415u, 0x0006000cu, 0x00000009u, 0x0000041eu, 0x00000001u, 0x0000000du, 0x0000041du, 0x00050050u, + 0x0000009au, 0x0000041fu, 0x0000041cu, 0x0000041eu, 0x0004003du, 0x00000009u, 0x00000420u, 0x00000409u, + 0x0005008eu, 0x0000009au, 0x00000421u, 0x0000041fu, 0x00000420u, 0x0003003eu, 0x0000041au, 0x00000421u, + 0x0004003du, 0x0000009au, 0x00000423u, 0x000003e5u, 0x0004003du, 0x0000009au, 0x00000424u, 0x0000041au, + 0x00050081u, 0x0000009au, 0x00000425u, 0x00000423u, 0x00000424u, 0x0003003eu, 0x00000422u, 0x00000425u, + 0x00050041u, 0x00000039u, 0x00000427u, 0x00000422u, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000428u, + 0x00000427u, 0x00050041u, 0x00000039u, 0x00000429u, 0x00000348u, 0x00000082u, 0x0004003du, 0x00000009u, + 0x0000042au, 0x00000429u, 0x00050088u, 0x00000009u, 0x0000042bu, 0x00000428u, 0x0000042au, 0x00050085u, + 0x00000009u, 0x0000042cu, 0x0000042bu, 0x00000122u, 0x00050083u, 0x00000009u, 0x0000042du, 0x0000042cu, + 0x00000037u, 0x0004003du, 0x00000009u, 0x0000042eu, 0x000003ddu, 0x00050085u, 0x00000009u, 0x0000042fu, + 0x0000042du, 0x0000042eu, 0x00050041u, 0x00000039u, 0x00000430u, 0x00000426u, 0x0000007du, 0x0003003eu, + 0x00000430u, 0x0000042fu, 0x00050041u, 0x00000039u, 0x00000431u, 0x00000422u, 0x00000008u, 0x0004003du, + 0x00000009u, 0x00000432u, 0x00000431u, 0x00050041u, 0x00000039u, 0x00000433u, 0x00000348u, 0x0000008du, + 0x0004003du, 0x00000009u, 0x00000434u, 0x00000433u, 0x00050088u, 0x00000009u, 0x00000435u, 0x00000432u, + 0x00000434u, 0x00050083u, 0x00000009u, 0x00000436u, 0x00000033u, 0x00000435u, 0x00050085u, 0x00000009u, + 0x00000437u, 0x00000436u, 0x00000122u, 0x0004003du, 0x00000009u, 0x00000438u, 0x000003ddu, 0x00050085u, + 0x00000009u, 0x00000439u, 0x00000437u, 0x00000438u, 0x00050041u, 0x00000039u, 0x0000043au, 0x00000426u, + 0x00000008u, 0x0003003eu, 0x0000043au, 0x00000439u, 0x00050041u, 0x00000039u, 0x0000043bu, 0x000003d5u, + 0x0000003bu, 0x0004003du, 0x00000009u, 0x0000043cu, 0x0000043bu, 0x00050041u, 0x00000039u, 0x0000043du, + 0x00000426u, 0x0000003bu, 0x0003003eu, 0x0000043du, 0x0000043cu, 0x0004003du, 0x00000009u, 0x0000043eu, + 0x000003ddu, 0x00050041u, 0x00000039u, 0x0000043fu, 0x00000426u, 0x0000003eu, 0x0003003eu, 0x0000043fu, + 0x0000043eu, 0x0004003du, 0x00000006u, 0x00000440u, 0x000003f9u, 0x00050080u, 0x00000006u, 0x00000441u, + 0x00000440u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000442u, 0x0000040du, 0x00050080u, 0x00000006u, + 0x00000443u, 0x00000441u, 0x00000442u, 0x0004003du, 0x0000000au, 0x00000444u, 0x00000426u, 0x00060041u, + 0x00000403u, 0x00000445u, 0x00000400u, 0x00000443u, 0x00000054u, 0x0003003eu, 0x00000445u, 0x00000444u, + 0x000200f9u, 0x00000411u, 0x000200f8u, 0x00000411u, 0x0004003du, 0x00000006u, 0x00000446u, 0x0000040du, + 0x00050080u, 0x00000006u, 0x00000447u, 0x00000446u, 0x0000011cu, 0x0003003eu, 0x0000040du, 0x00000447u, + 0x000200f9u, 0x0000040eu, 0x000200f8u, 0x00000410u, 0x0004003du, 0x00000006u, 0x00000449u, 0x000003afu, + 0x00050084u, 0x00000006u, 0x0000044au, 0x00000449u, 0x000003a6u, 0x0003003eu, 0x00000448u, 0x0000044au, + 0x0003003eu, 0x0000044bu, 0x0000007du, 0x000200f9u, 0x0000044cu, 0x000200f8u, 0x0000044cu, 0x000400f6u, + 0x0000044eu, 0x0000044fu, 0x00000000u, 0x000200f9u, 0x00000450u, 0x000200f8u, 0x00000450u, 0x0004003du, + 0x00000006u, 0x00000451u, 0x0000044bu, 0x000500b0u, 0x00000011u, 0x00000452u, 0x00000451u, 0x000003a6u, + 0x000400fau, 0x00000452u, 0x0000044du, 0x0000044eu, 0x000200f8u, 0x0000044du, 0x0004003du, 0x00000006u, + 0x00000454u, 0x0000044bu, 0x00050080u, 0x00000006u, 0x00000455u, 0x00000454u, 0x00000008u, 0x00050089u, + 0x00000006u, 0x00000456u, 0x00000455u, 0x000003a6u, 0x0003003eu, 0x00000453u, 0x00000456u, 0x0004003du, + 0x00000006u, 0x0000045bu, 0x00000448u, 0x0004003du, 0x00000006u, 0x0000045cu, 0x0000044bu, 0x00050080u, + 0x00000006u, 0x0000045du, 0x0000045bu, 0x0000045cu, 0x0004003du, 0x00000006u, 0x0000045eu, 0x000003f9u, + 0x0004003du, 0x00000006u, 0x0000045fu, 0x000003f9u, 0x00050080u, 0x00000006u, 0x00000460u, 0x0000045fu, + 0x00000008u, 0x0004003du, 0x00000006u, 0x00000461u, 0x0000044bu, 0x00050080u, 0x00000006u, 0x00000462u, + 0x00000460u, 0x00000461u, 0x0004003du, 0x00000006u, 0x00000463u, 0x000003f9u, 0x00050080u, 0x00000006u, + 0x00000464u, 0x00000463u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000465u, 0x00000453u, 0x00050080u, + 0x00000006u, 0x00000466u, 0x00000464u, 0x00000465u, 0x00060050u, 0x00000307u, 0x00000467u, 0x0000045eu, + 0x00000462u, 0x00000466u, 0x00050041u, 0x00000468u, 0x00000469u, 0x0000045au, 0x0000045du, 0x0003003eu, + 0x00000469u, 0x00000467u, 0x0004003du, 0x00000006u, 0x0000046eu, 0x00000448u, 0x0004003du, 0x00000006u, + 0x0000046fu, 0x0000044bu, 0x00050080u, 0x00000006u, 0x00000470u, 0x0000046eu, 0x0000046fu, 0x00050041u, + 0x00000315u, 0x00000471u, 0x00000314u, 0x00000054u, 0x0004003du, 0x00000006u, 0x00000472u, 0x00000471u, + 0x0004007cu, 0x0000002bu, 0x00000473u, 0x00000472u, 0x00060041u, 0x00000474u, 0x00000475u, 0x0000046du, + 0x00000470u, 0x00000054u, 0x0003003eu, 0x00000475u, 0x00000473u, 0x0004003du, 0x00000006u, 0x0000047au, + 0x00000448u, 0x0004003du, 0x00000006u, 0x0000047bu, 0x0000044bu, 0x00050080u, 0x00000006u, 0x0000047cu, + 0x0000047au, 0x0000047bu, 0x00050041u, 0x0000047du, 0x0000047eu, 0x00000314u, 0x00000079u, 0x0004003du, + 0x00000016u, 0x0000047fu, 0x0000047eu, 0x00060041u, 0x00000480u, 0x00000481u, 0x00000479u, 0x0000047cu, + 0x00000054u, 0x0003003eu, 0x00000481u, 0x0000047fu, 0x0004003du, 0x00000006u, 0x00000482u, 0x00000448u, + 0x0004003du, 0x00000006u, 0x00000483u, 0x0000044bu, 0x00050080u, 0x00000006u, 0x00000484u, 0x00000482u, + 0x00000483u, 0x00050041u, 0x0000039cu, 0x00000485u, 0x00000314u, 0x000000c6u, 0x0004003du, 0x00000009u, + 0x00000486u, 0x00000485u, 0x00060041u, 0x00000487u, 0x00000488u, 0x00000479u, 0x00000484u, 0x0000011cu, + 0x0003003eu, 0x00000488u, 0x00000486u, 0x000200f9u, 0x0000044fu, 0x000200f8u, 0x0000044fu, 0x0004003du, + 0x00000006u, 0x00000489u, 0x0000044bu, 0x00050080u, 0x00000006u, 0x0000048au, 0x00000489u, 0x0000011cu, + 0x0003003eu, 0x0000044bu, 0x0000048au, 0x000200f9u, 0x0000044cu, 0x000200f8u, 0x0000044eu, 0x000200f9u, + 0x000003b3u, 0x000200f8u, 0x000003b3u, 0x0004003du, 0x00000006u, 0x0000048bu, 0x000003afu, 0x00050080u, + 0x00000006u, 0x0000048cu, 0x0000048bu, 0x0000011cu, 0x0003003eu, 0x000003afu, 0x0000048cu, 0x000200f9u, + 0x000003b0u, 0x000200f8u, 0x000003b2u, 0x000200f9u, 0x000003aeu, 0x000200f8u, 0x000003aeu, 0x000100fdu, + 0x000200f8u, 0x00000368u, 0x0004003du, 0x00000006u, 0x0000048fu, 0x00000311u, 0x00050082u, 0x00000006u, + 0x00000490u, 0x0000048fu, 0x00000008u, 0x0003003eu, 0x0000048eu, 0x00000490u, 0x0004003du, 0x00000006u, + 0x00000492u, 0x00000306u, 0x00050084u, 0x00000006u, 0x00000493u, 0x00000492u, 0x0000003eu, 0x0003003eu, + 0x00000491u, 0x00000493u, 0x0004003du, 0x00000006u, 0x00000495u, 0x00000491u, 0x00050080u, 0x00000006u, + 0x00000496u, 0x00000495u, 0x0000003eu, 0x0004003du, 0x00000006u, 0x00000497u, 0x0000048eu, 0x0007000cu, + 0x00000006u, 0x00000498u, 0x00000001u, 0x00000026u, 0x00000496u, 0x00000497u, 0x0003003eu, 0x00000494u, + 0x00000498u, 0x0004003du, 0x00000006u, 0x0000049au, 0x00000494u, 0x0004003du, 0x00000006u, 0x0000049bu, + 0x00000491u, 0x00050082u, 0x00000006u, 0x0000049cu, 0x0000049au, 0x0000049bu, 0x0003003eu, 0x00000499u, + 0x0000049cu, 0x0004003du, 0x00000006u, 0x0000049fu, 0x00000306u, 0x000500aau, 0x00000011u, 0x000004a0u, + 0x0000049fu, 0x0000007du, 0x0003003eu, 0x0000049eu, 0x000004a0u, 0x0004003du, 0x00000006u, 0x000004a2u, + 0x00000494u, 0x0004003du, 0x00000006u, 0x000004a3u, 0x0000048eu, 0x000500aeu, 0x00000011u, 0x000004a4u, + 0x000004a2u, 0x000004a3u, 0x0003003eu, 0x000004a1u, 0x000004a4u, 0x0004003du, 0x00000006u, 0x000004a5u, + 0x00000499u, 0x000500aau, 0x00000011u, 0x000004a6u, 0x000004a5u, 0x0000007du, 0x000300f7u, 0x000004a8u, + 0x00000000u, 0x000400fau, 0x000004a6u, 0x000004a7u, 0x000004a8u, 0x000200f8u, 0x000004a7u, 0x0003003eu, + 0x00000305u, 0x0000007du, 0x0004003du, 0x00000006u, 0x000004a9u, 0x00000305u, 0x000314afu, 0x0000007du, + 0x000004a9u, 0x000100fdu, 0x000200f8u, 0x000004a8u, 0x00050041u, 0x0000039cu, 0x000004acu, 0x00000314u, + 0x000000b9u, 0x0004003du, 0x00000009u, 0x000004adu, 0x000004acu, 0x00050085u, 0x00000009u, 0x000004aeu, + 0x000004adu, 0x00000033u, 0x0003003eu, 0x000004abu, 0x000004aeu, 0x0003003eu, 0x000004afu, 0x0000007du, + 0x00050041u, 0x00000315u, 0x000004b0u, 0x00000314u, 0x00000082u, 0x0004003du, 0x00000006u, 0x000004b1u, + 0x000004b0u, 0x000500acu, 0x00000011u, 0x000004b2u, 0x000004b1u, 0x0000007du, 0x000300f7u, 0x000004b4u, + 0x00000000u, 0x000400fau, 0x000004b2u, 0x000004b3u, 0x000004b4u, 0x000200f8u, 0x000004b3u, 0x00050041u, + 0x00000010u, 0x000004b5u, 0x0000032au, 0x000000c6u, 0x0004003du, 0x00000006u, 0x000004b6u, 0x000004b5u, + 0x00050041u, 0x00000010u, 0x000004b7u, 0x00000339u, 0x0000002fu, 0x0004003du, 0x00000006u, 0x000004b8u, + 0x000004b7u, 0x00050080u, 0x00000006u, 0x000004b9u, 0x000004b6u, 0x000004b8u, 0x00050041u, 0x00000315u, + 0x000004bau, 0x00000314u, 0x00000082u, 0x0004003du, 0x00000006u, 0x000004bbu, 0x000004bau, 0x00050080u, + 0x00000006u, 0x000004bcu, 0x000004b9u, 0x000004bbu, 0x00050082u, 0x00000006u, 0x000004bdu, 0x000004bcu, + 0x00000008u, 0x00060041u, 0x0000038fu, 0x000004beu, 0x00000385u, 0x00000054u, 0x000004bdu, 0x0004003du, + 0x0000002bu, 0x000004bfu, 0x000004beu, 0x0004007cu, 0x00000006u, 0x000004c0u, 0x000004bfu, 0x0003003eu, + 0x000004afu, 0x000004c0u, 0x000200f9u, 0x000004b4u, 0x000200f8u, 0x000004b4u, 0x00050041u, 0x00000010u, + 0x000004c2u, 0x0000032au, 0x000000ccu, 0x0004003du, 0x00000006u, 0x000004c3u, 0x000004c2u, 0x00050041u, + 0x00000010u, 0x000004c4u, 0x00000339u, 0x000000c6u, 0x0004003du, 0x00000006u, 0x000004c5u, 0x000004c4u, + 0x00050080u, 0x00000006u, 0x000004c6u, 0x000004c3u, 0x000004c5u, 0x0004003du, 0x00000006u, 0x000004c7u, + 0x000004afu, 0x00050080u, 0x00000006u, 0x000004c8u, 0x000004c6u, 0x000004c7u, 0x0003003eu, 0x000004c1u, + 0x000004c8u, 0x0003003eu, 0x000004c9u, 0x0000007du, 0x0003003eu, 0x000004cau, 0x000004cbu, 0x0003003eu, + 0x000004ccu, 0x000004cbu, 0x0004003du, 0x00000006u, 0x000004cdu, 0x0000030du, 0x000500aau, 0x00000011u, + 0x000004ceu, 0x000004cdu, 0x0000007du, 0x000300f7u, 0x000004d0u, 0x00000000u, 0x000400fau, 0x000004ceu, + 0x000004cfu, 0x000004d0u, 0x000200f8u, 0x000004cfu, 0x0004003du, 0x00000011u, 0x000004d1u, 0x0000049eu, + 0x000400a8u, 0x00000011u, 0x000004d2u, 0x000004d1u, 0x0004003du, 0x00000006u, 0x000004d3u, 0x00000491u, + 0x000500acu, 0x00000011u, 0x000004d4u, 0x000004d3u, 0x0000007du, 0x000500a7u, 0x00000011u, 0x000004d5u, + 0x000004d2u, 0x000004d4u, 0x000300f7u, 0x000004d7u, 0x00000000u, 0x000400fau, 0x000004d5u, 0x000004d6u, + 0x000004d7u, 0x000200f8u, 0x000004d6u, 0x0004003du, 0x00000006u, 0x000004d9u, 0x000004c1u, 0x0004003du, + 0x00000006u, 0x000004dau, 0x00000491u, 0x00050080u, 0x00000006u, 0x000004dbu, 0x000004d9u, 0x000004dau, + 0x00050082u, 0x00000006u, 0x000004dcu, 0x000004dbu, 0x00000008u, 0x0003003eu, 0x000004d8u, 0x000004dcu, + 0x0004003du, 0x00000006u, 0x000004deu, 0x000004d8u, 0x00060041u, 0x000003c9u, 0x000004dfu, 0x000003c7u, + 0x00000054u, 0x000004deu, 0x0004003du, 0x000003c3u, 0x000004e0u, 0x000004dfu, 0x00040190u, 0x000003c0u, + 0x000004e1u, 0x000004e0u, 0x0003003eu, 0x000004ddu, 0x000004e1u, 0x00050041u, 0x00000039u, 0x000004e7u, + 0x000004ddu, 0x00000054u, 0x0004003du, 0x00000009u, 0x000004e8u, 0x000004e7u, 0x00050041u, 0x00000039u, + 0x000004e9u, 0x000004ddu, 0x0000011cu, 0x0004003du, 0x00000009u, 0x000004eau, 0x000004e9u, 0x00050041u, + 0x00000039u, 0x000004ebu, 0x000004ddu, 0x00000082u, 0x0004003du, 0x00000009u, 0x000004ecu, 0x000004ebu, + 0x00060050u, 0x00000016u, 0x000004edu, 0x000004e8u, 0x000004eau, 0x000004ecu, 0x00050041u, 0x000004eeu, + 0x000004efu, 0x000004e5u, 0x000004e6u, 0x0003003eu, 0x000004efu, 0x000004edu, 0x0003003eu, 0x000004cau, + 0x000004f0u, 0x000200f9u, 0x000004d7u, 0x000200f8u, 0x000004d7u, 0x0004003du, 0x00000011u, 0x000004f1u, + 0x000004a1u, 0x000400a8u, 0x00000011u, 0x000004f2u, 0x000004f1u, 0x0004003du, 0x00000006u, 0x000004f3u, + 0x00000494u, 0x0004003du, 0x00000006u, 0x000004f4u, 0x0000048eu, 0x000500b0u, 0x00000011u, 0x000004f5u, + 0x000004f3u, 0x000004f4u, 0x000500a7u, 0x00000011u, 0x000004f6u, 0x000004f2u, 0x000004f5u, 0x000300f7u, + 0x000004f8u, 0x00000000u, 0x000400fau, 0x000004f6u, 0x000004f7u, 0x000004f8u, 0x000200f8u, 0x000004f7u, + 0x0004003du, 0x00000006u, 0x000004fau, 0x000004c1u, 0x0004003du, 0x00000006u, 0x000004fbu, 0x00000494u, + 0x00050080u, 0x00000006u, 0x000004fcu, 0x000004fau, 0x000004fbu, 0x00050080u, 0x00000006u, 0x000004fdu, + 0x000004fcu, 0x00000008u, 0x0003003eu, 0x000004f9u, 0x000004fdu, 0x0004003du, 0x00000006u, 0x000004ffu, + 0x000004f9u, 0x00060041u, 0x000003c9u, 0x00000500u, 0x000003c7u, 0x00000054u, 0x000004ffu, 0x0004003du, + 0x000003c3u, 0x00000501u, 0x00000500u, 0x00040190u, 0x000003c0u, 0x00000502u, 0x00000501u, 0x0003003eu, + 0x000004feu, 0x00000502u, 0x00050041u, 0x00000039u, 0x00000504u, 0x000004feu, 0x00000054u, 0x0004003du, + 0x00000009u, 0x00000505u, 0x00000504u, 0x00050041u, 0x00000039u, 0x00000506u, 0x000004feu, 0x0000011cu, + 0x0004003du, 0x00000009u, 0x00000507u, 0x00000506u, 0x00050041u, 0x00000039u, 0x00000508u, 0x000004feu, + 0x00000082u, 0x0004003du, 0x00000009u, 0x00000509u, 0x00000508u, 0x00060050u, 0x00000016u, 0x0000050au, + 0x00000505u, 0x00000507u, 0x00000509u, 0x00050041u, 0x000004eeu, 0x0000050bu, 0x000004e5u, 0x00000503u, + 0x0003003eu, 0x0000050bu, 0x0000050au, 0x0003003eu, 0x000004ccu, 0x000004f0u, 0x000200f9u, 0x000004f8u, + 0x000200f8u, 0x000004f8u, 0x0003003eu, 0x0000050cu, 0x0000007du, 0x000200f9u, 0x0000050du, 0x000200f8u, + 0x0000050du, 0x000400f6u, 0x0000050fu, 0x00000510u, 0x00000000u, 0x000200f9u, 0x00000511u, 0x000200f8u, + 0x00000511u, 0x0004003du, 0x00000006u, 0x00000512u, 0x0000050cu, 0x0004003du, 0x00000006u, 0x00000513u, + 0x00000499u, 0x000500b0u, 0x00000011u, 0x00000514u, 0x00000512u, 0x00000513u, 0x000400fau, 0x00000514u, + 0x0000050eu, 0x0000050fu, 0x000200f8u, 0x0000050eu, 0x0004003du, 0x00000006u, 0x00000516u, 0x00000491u, + 0x0004003du, 0x00000006u, 0x00000517u, 0x0000050cu, 0x00050080u, 0x00000006u, 0x00000518u, 0x00000516u, + 0x00000517u, 0x0003003eu, 0x00000515u, 0x00000518u, 0x0004003du, 0x00000006u, 0x0000051au, 0x000004c1u, + 0x0004003du, 0x00000006u, 0x0000051bu, 0x00000515u, 0x00050080u, 0x00000006u, 0x0000051cu, 0x0000051au, + 0x0000051bu, 0x0003003eu, 0x00000519u, 0x0000051cu, 0x0004003du, 0x00000006u, 0x0000051eu, 0x000004c1u, + 0x0004003du, 0x00000006u, 0x0000051fu, 0x00000515u, 0x00050080u, 0x00000006u, 0x00000520u, 0x0000051eu, + 0x0000051fu, 0x00050080u, 0x00000006u, 0x00000521u, 0x00000520u, 0x00000008u, 0x0003003eu, 0x0000051du, + 0x00000521u, 0x0004003du, 0x00000006u, 0x00000523u, 0x00000519u, 0x00060041u, 0x000003c9u, 0x00000524u, + 0x000003c7u, 0x00000054u, 0x00000523u, 0x0004003du, 0x000003c3u, 0x00000525u, 0x00000524u, 0x00040190u, + 0x000003c0u, 0x00000526u, 0x00000525u, 0x0003003eu, 0x00000522u, 0x00000526u, 0x0004003du, 0x00000006u, + 0x00000528u, 0x0000051du, 0x00060041u, 0x000003c9u, 0x00000529u, 0x000003c7u, 0x00000054u, 0x00000528u, + 0x0004003du, 0x000003c3u, 0x0000052au, 0x00000529u, 0x00040190u, 0x000003c0u, 0x0000052bu, 0x0000052au, + 0x0003003eu, 0x00000527u, 0x0000052bu, 0x00050041u, 0x00000039u, 0x0000052du, 0x00000522u, 0x00000054u, + 0x0004003du, 0x00000009u, 0x0000052eu, 0x0000052du, 0x00050041u, 0x00000039u, 0x0000052fu, 0x00000522u, + 0x0000011cu, 0x0004003du, 0x00000009u, 0x00000530u, 0x0000052fu, 0x00050041u, 0x00000039u, 0x00000531u, + 0x00000522u, 0x00000082u, 0x0004003du, 0x00000009u, 0x00000532u, 0x00000531u, 0x00060050u, 0x00000016u, + 0x00000533u, 0x0000052eu, 0x00000530u, 0x00000532u, 0x0003003eu, 0x0000052cu, 0x00000533u, 0x00050041u, + 0x00000039u, 0x00000535u, 0x00000527u, 0x00000054u, 0x0004003du, 0x00000009u, 0x00000536u, 0x00000535u, + 0x00050041u, 0x00000039u, 0x00000537u, 0x00000527u, 0x0000011cu, 0x0004003du, 0x00000009u, 0x00000538u, + 0x00000537u, 0x00050041u, 0x00000039u, 0x00000539u, 0x00000527u, 0x00000082u, 0x0004003du, 0x00000009u, + 0x0000053au, 0x00000539u, 0x00060050u, 0x00000016u, 0x0000053bu, 0x00000536u, 0x00000538u, 0x0000053au, + 0x0003003eu, 0x00000534u, 0x0000053bu, 0x0004003du, 0x00000016u, 0x0000053eu, 0x0000052cu, 0x0003003eu, + 0x0000053du, 0x0000053eu, 0x0004003du, 0x00000016u, 0x00000540u, 0x00000534u, 0x0003003eu, 0x0000053fu, + 0x00000540u, 0x00050041u, 0x00000023u, 0x00000542u, 0x00000354u, 0x00000054u, 0x0004003du, 0x00000018u, + 0x00000543u, 0x00000542u, 0x0003003eu, 0x00000541u, 0x00000543u, 0x0004003du, 0x0000001bu, 0x00000545u, + 0x00000348u, 0x0003003eu, 0x00000544u, 0x00000545u, 0x00080039u, 0x00000009u, 0x00000546u, 0x00000029u, + 0x0000053du, 0x0000053fu, 0x00000541u, 0x00000544u, 0x0003003eu, 0x0000053cu, 0x00000546u, 0x0003003eu, + 0x00000547u, 0x0000007du, 0x00050041u, 0x00000030u, 0x00000549u, 0x0000002eu, 0x0000006du, 0x0004003du, + 0x00000009u, 0x0000054au, 0x00000549u, 0x0003003eu, 0x00000548u, 0x0000054au, 0x0004003du, 0x00000009u, + 0x0000054bu, 0x00000548u, 0x000500bau, 0x00000011u, 0x0000054cu, 0x0000054bu, 0x00000046u, 0x0004003du, + 0x00000009u, 0x0000054du, 0x0000053cu, 0x0004003du, 0x00000009u, 0x0000054eu, 0x00000548u, 0x000500bau, + 0x00000011u, 0x0000054fu, 0x0000054du, 0x0000054eu, 0x000500a7u, 0x00000011u, 0x00000550u, 0x0000054cu, + 0x0000054fu, 0x000300f7u, 0x00000552u, 0x00000000u, 0x000400fau, 0x00000550u, 0x00000551u, 0x00000552u, + 0x000200f8u, 0x00000551u, 0x0003003eu, 0x00000547u, 0x00000008u, 0x000200f9u, 0x00000552u, 0x000200f8u, + 0x00000552u, 0x0004003du, 0x00000009u, 0x00000553u, 0x00000548u, 0x000500bau, 0x00000011u, 0x00000554u, + 0x00000553u, 0x00000046u, 0x000300f7u, 0x00000556u, 0x00000000u, 0x000400fau, 0x00000554u, 0x00000555u, + 0x00000556u, 0x000200f8u, 0x00000555u, 0x0004003du, 0x00000009u, 0x00000557u, 0x0000053cu, 0x0004003du, + 0x00000009u, 0x00000558u, 0x00000548u, 0x00050085u, 0x00000009u, 0x0000055au, 0x00000558u, 0x00000559u, + 0x000500bau, 0x00000011u, 0x0000055bu, 0x00000557u, 0x0000055au, 0x000200f9u, 0x00000556u, 0x000200f8u, + 0x00000556u, 0x000700f5u, 0x00000011u, 0x0000055cu, 0x00000554u, 0x00000552u, 0x0000055bu, 0x00000555u, + 0x000300f7u, 0x0000055eu, 0x00000000u, 0x000400fau, 0x0000055cu, 0x0000055du, 0x0000055eu, 0x000200f8u, + 0x0000055du, 0x0003003eu, 0x00000547u, 0x0000003bu, 0x000200f9u, 0x0000055eu, 0x000200f8u, 0x0000055eu, + 0x0004003du, 0x00000009u, 0x0000055fu, 0x00000548u, 0x000500bau, 0x00000011u, 0x00000560u, 0x0000055fu, + 0x00000046u, 0x000300f7u, 0x00000562u, 0x00000000u, 0x000400fau, 0x00000560u, 0x00000561u, 0x00000562u, + 0x000200f8u, 0x00000561u, 0x0004003du, 0x00000009u, 0x00000563u, 0x0000053cu, 0x0004003du, 0x00000009u, + 0x00000564u, 0x00000548u, 0x00050085u, 0x00000009u, 0x00000566u, 0x00000564u, 0x00000565u, 0x000500bau, + 0x00000011u, 0x00000567u, 0x00000563u, 0x00000566u, 0x000200f9u, 0x00000562u, 0x000200f8u, 0x00000562u, + 0x000700f5u, 0x00000011u, 0x00000568u, 0x00000560u, 0x0000055eu, 0x00000567u, 0x00000561u, 0x000300f7u, + 0x0000056au, 0x00000000u, 0x000400fau, 0x00000568u, 0x00000569u, 0x0000056au, 0x000200f8u, 0x00000569u, + 0x0003003eu, 0x00000547u, 0x0000003eu, 0x000200f9u, 0x0000056au, 0x000200f8u, 0x0000056au, 0x0004003du, + 0x00000009u, 0x0000056bu, 0x00000548u, 0x000500bau, 0x00000011u, 0x0000056cu, 0x0000056bu, 0x00000046u, + 0x000300f7u, 0x0000056eu, 0x00000000u, 0x000400fau, 0x0000056cu, 0x0000056du, 0x0000056eu, 0x000200f8u, + 0x0000056du, 0x0004003du, 0x00000009u, 0x0000056fu, 0x0000053cu, 0x0004003du, 0x00000009u, 0x00000570u, + 0x00000548u, 0x00050085u, 0x00000009u, 0x00000572u, 0x00000570u, 0x00000571u, 0x000500bau, 0x00000011u, + 0x00000573u, 0x0000056fu, 0x00000572u, 0x000200f9u, 0x0000056eu, 0x000200f8u, 0x0000056eu, 0x000700f5u, + 0x00000011u, 0x00000574u, 0x0000056cu, 0x0000056au, 0x00000573u, 0x0000056du, 0x000300f7u, 0x00000576u, + 0x00000000u, 0x000400fau, 0x00000574u, 0x00000575u, 0x00000576u, 0x000200f8u, 0x00000575u, 0x0003003eu, + 0x00000547u, 0x00000577u, 0x000200f9u, 0x00000576u, 0x000200f8u, 0x00000576u, 0x0004003du, 0x00000006u, + 0x00000578u, 0x00000547u, 0x00050041u, 0x00000579u, 0x0000057au, 0x0000002eu, 0x000000deu, 0x0004003du, + 0x00000006u, 0x0000057bu, 0x0000057au, 0x0007000cu, 0x00000006u, 0x0000057cu, 0x00000001u, 0x00000026u, + 0x00000578u, 0x0000057bu, 0x0003003eu, 0x00000547u, 0x0000057cu, 0x0004003du, 0x00000006u, 0x0000057eu, + 0x00000547u, 0x000500c4u, 0x00000006u, 0x0000057fu, 0x00000008u, 0x0000057eu, 0x0003003eu, 0x0000057du, + 0x0000057fu, 0x0004003du, 0x00000006u, 0x00000580u, 0x0000050cu, 0x000500aau, 0x00000011u, 0x00000581u, + 0x00000580u, 0x0000007du, 0x000300f7u, 0x00000583u, 0x00000000u, 0x000400fau, 0x00000581u, 0x00000582u, + 0x00000583u, 0x000200f8u, 0x00000582u, 0x0004003du, 0x00000006u, 0x00000584u, 0x000004c9u, 0x0004003du, + 0x00000016u, 0x00000585u, 0x0000052cu, 0x00050041u, 0x000004eeu, 0x00000586u, 0x000004e5u, 0x00000584u, + 0x0003003eu, 0x00000586u, 0x00000585u, 0x0004003du, 0x00000006u, 0x00000587u, 0x000004c9u, 0x00050080u, + 0x00000006u, 0x00000588u, 0x00000587u, 0x0000011cu, 0x0003003eu, 0x000004c9u, 0x00000588u, 0x000200f9u, + 0x00000583u, 0x000200f8u, 0x00000583u, 0x0003003eu, 0x00000589u, 0x00000008u, 0x000200f9u, 0x0000058au, + 0x000200f8u, 0x0000058au, 0x000400f6u, 0x0000058cu, 0x0000058du, 0x00000000u, 0x000200f9u, 0x0000058eu, + 0x000200f8u, 0x0000058eu, 0x0004003du, 0x00000006u, 0x0000058fu, 0x00000589u, 0x0004003du, 0x00000006u, + 0x00000590u, 0x0000057du, 0x000500b2u, 0x00000011u, 0x00000591u, 0x0000058fu, 0x00000590u, 0x000400fau, + 0x00000591u, 0x0000058bu, 0x0000058cu, 0x000200f8u, 0x0000058bu, 0x0004003du, 0x00000006u, 0x00000593u, + 0x00000589u, 0x00040070u, 0x00000009u, 0x00000594u, 0x00000593u, 0x0004003du, 0x00000006u, 0x00000595u, + 0x0000057du, 0x00040070u, 0x00000009u, 0x00000596u, 0x00000595u, 0x00050088u, 0x00000009u, 0x00000597u, + 0x00000594u, 0x00000596u, 0x0003003eu, 0x00000592u, 0x00000597u, 0x0004003du, 0x00000016u, 0x00000599u, + 0x0000052cu, 0x0004003du, 0x00000016u, 0x0000059au, 0x00000534u, 0x0004003du, 0x00000009u, 0x0000059bu, + 0x00000592u, 0x00060050u, 0x00000016u, 0x0000059cu, 0x0000059bu, 0x0000059bu, 0x0000059bu, 0x0008000cu, + 0x00000016u, 0x0000059du, 0x00000001u, 0x0000002eu, 0x00000599u, 0x0000059au, 0x0000059cu, 0x0003003eu, + 0x00000598u, 0x0000059du, 0x0004003du, 0x00000006u, 0x0000059eu, 0x000004c9u, 0x0004003du, 0x00000016u, + 0x0000059fu, 0x00000598u, 0x00050041u, 0x000004eeu, 0x000005a0u, 0x000004e5u, 0x0000059eu, 0x0003003eu, + 0x000005a0u, 0x0000059fu, 0x0004003du, 0x00000006u, 0x000005a1u, 0x000004c9u, 0x00050080u, 0x00000006u, + 0x000005a2u, 0x000005a1u, 0x0000011cu, 0x0003003eu, 0x000004c9u, 0x000005a2u, 0x0004003du, 0x00000006u, + 0x000005a3u, 0x000004c9u, 0x000500aeu, 0x00000011u, 0x000005a5u, 0x000005a3u, 0x000005a4u, 0x000300f7u, + 0x000005a7u, 0x00000000u, 0x000400fau, 0x000005a5u, 0x000005a6u, 0x000005a7u, 0x000200f8u, 0x000005a6u, + 0x000200f9u, 0x0000058cu, 0x000200f8u, 0x000005a7u, 0x000200f9u, 0x0000058du, 0x000200f8u, 0x0000058du, + 0x0004003du, 0x00000006u, 0x000005a9u, 0x00000589u, 0x00050080u, 0x00000006u, 0x000005aau, 0x000005a9u, + 0x0000011cu, 0x0003003eu, 0x00000589u, 0x000005aau, 0x000200f9u, 0x0000058au, 0x000200f8u, 0x0000058cu, + 0x0004003du, 0x00000006u, 0x000005abu, 0x000004c9u, 0x000500aeu, 0x00000011u, 0x000005acu, 0x000005abu, + 0x000005a4u, 0x000300f7u, 0x000005aeu, 0x00000000u, 0x000400fau, 0x000005acu, 0x000005adu, 0x000005aeu, + 0x000200f8u, 0x000005adu, 0x000200f9u, 0x0000050fu, 0x000200f8u, 0x000005aeu, 0x000200f9u, 0x00000510u, + 0x000200f8u, 0x00000510u, 0x0004003du, 0x00000006u, 0x000005b0u, 0x0000050cu, 0x00050080u, 0x00000006u, + 0x000005b1u, 0x000005b0u, 0x0000011cu, 0x0003003eu, 0x0000050cu, 0x000005b1u, 0x000200f9u, 0x0000050du, + 0x000200f8u, 0x0000050fu, 0x0004003du, 0x00000006u, 0x000005b6u, 0x000004c9u, 0x00040070u, 0x00000009u, + 0x000005b7u, 0x000005b6u, 0x00060041u, 0x000005b8u, 0x000005b9u, 0x000005b4u, 0x000005b5u, 0x0000007du, + 0x0003003eu, 0x000005b9u, 0x000005b7u, 0x0004003du, 0x00000011u, 0x000005bau, 0x000004cau, 0x000600a9u, + 0x00000009u, 0x000005bbu, 0x000005bau, 0x00000037u, 0x00000046u, 0x00060041u, 0x000005b8u, 0x000005bcu, + 0x000005b4u, 0x000005b5u, 0x00000008u, 0x0003003eu, 0x000005bcu, 0x000005bbu, 0x0004003du, 0x00000011u, + 0x000005bdu, 0x000004ccu, 0x000600a9u, 0x00000009u, 0x000005beu, 0x000005bdu, 0x00000037u, 0x00000046u, + 0x00060041u, 0x000005b8u, 0x000005bfu, 0x000005b4u, 0x000005b5u, 0x0000003bu, 0x0003003eu, 0x000005bfu, + 0x000005beu, 0x000200f9u, 0x000004d0u, 0x000200f8u, 0x000004d0u, 0x000400e0u, 0x0000003bu, 0x0000003bu, + 0x000005c0u, 0x00060041u, 0x000005b8u, 0x000005c2u, 0x000005b4u, 0x000005b5u, 0x0000007du, 0x0004003du, + 0x00000009u, 0x000005c3u, 0x000005c2u, 0x0004006du, 0x00000006u, 0x000005c4u, 0x000005c3u, 0x0003003eu, + 0x000005c1u, 0x000005c4u, 0x00060041u, 0x000005b8u, 0x000005c6u, 0x000005b4u, 0x000005b5u, 0x00000008u, + 0x0004003du, 0x00000009u, 0x000005c7u, 0x000005c6u, 0x000500bau, 0x00000011u, 0x000005c8u, 0x000005c7u, + 0x00000033u, 0x0003003eu, 0x000005c5u, 0x000005c8u, 0x00060041u, 0x000005b8u, 0x000005cau, 0x000005b4u, + 0x000005b5u, 0x0000003bu, 0x0004003du, 0x00000009u, 0x000005cbu, 0x000005cau, 0x000500bau, 0x00000011u, + 0x000005ccu, 0x000005cbu, 0x00000033u, 0x0003003eu, 0x000005c9u, 0x000005ccu, 0x0004003du, 0x00000006u, + 0x000005cdu, 0x000005c1u, 0x0007000cu, 0x00000006u, 0x000005ceu, 0x00000001u, 0x00000026u, 0x000005cdu, + 0x000005a4u, 0x0003003eu, 0x000005c1u, 0x000005ceu, 0x0004003du, 0x00000006u, 0x000005cfu, 0x000005c1u, + 0x000500b0u, 0x00000011u, 0x000005d0u, 0x000005cfu, 0x0000003bu, 0x000300f7u, 0x000005d2u, 0x00000000u, + 0x000400fau, 0x000005d0u, 0x000005d1u, 0x000005d2u, 0x000200f8u, 0x000005d1u, 0x0003003eu, 0x00000305u, + 0x0000007du, 0x0004003du, 0x00000006u, 0x000005d3u, 0x00000305u, 0x000314afu, 0x0000007du, 0x000005d3u, + 0x000100fdu, 0x000200f8u, 0x000005d2u, 0x0004003du, 0x00000006u, 0x000005d6u, 0x0000030du, 0x0003003eu, + 0x000005d5u, 0x000005d6u, 0x000200f9u, 0x000005d7u, 0x000200f8u, 0x000005d7u, 0x000400f6u, 0x000005d9u, + 0x000005dau, 0x00000000u, 0x000200f9u, 0x000005dbu, 0x000200f8u, 0x000005dbu, 0x0004003du, 0x00000006u, + 0x000005dcu, 0x000005d5u, 0x0004003du, 0x00000006u, 0x000005ddu, 0x000005c1u, 0x000500b0u, 0x00000011u, + 0x000005deu, 0x000005dcu, 0x000005ddu, 0x000400fau, 0x000005deu, 0x000005d8u, 0x000005d9u, 0x000200f8u, + 0x000005d8u, 0x0004003du, 0x00000006u, 0x000005e0u, 0x000005d5u, 0x00050041u, 0x000004eeu, 0x000005e1u, + 0x000004e5u, 0x000005e0u, 0x0004003du, 0x00000016u, 0x000005e2u, 0x000005e1u, 0x0003003eu, 0x000005dfu, + 0x000005e2u, 0x0004003du, 0x00000016u, 0x000005e5u, 0x000005dfu, 0x0003003eu, 0x000005e4u, 0x000005e5u, + 0x0004003du, 0x00000019u, 0x000005e7u, 0x00000354u, 0x0003003eu, 0x000005e6u, 0x000005e7u, 0x0004003du, + 0x0000001bu, 0x000005e9u, 0x00000348u, 0x0003003eu, 0x000005e8u, 0x000005e9u, 0x00070039u, 0x0000000au, + 0x000005eau, 0x00000021u, 0x000005e4u, 0x000005e6u, 0x000005e8u, 0x0003003eu, 0x000005e3u, 0x000005eau, + 0x0004003du, 0x00000006u, 0x000005ebu, 0x000005d5u, 0x0004003du, 0x0000000au, 0x000005ecu, 0x000005e3u, + 0x00050041u, 0x000005edu, 0x000005eeu, 0x000005b4u, 0x000005ebu, 0x0003003eu, 0x000005eeu, 0x000005ecu, + 0x00050041u, 0x00000039u, 0x000005f0u, 0x000005e3u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x000005f1u, + 0x000005f0u, 0x0003003eu, 0x000005efu, 0x000005f1u, 0x0004003du, 0x00000009u, 0x000005f2u, 0x000005efu, + 0x0006000cu, 0x00000009u, 0x000005f3u, 0x00000001u, 0x00000004u, 0x000005f2u, 0x000500b8u, 0x00000011u, + 0x000005f4u, 0x000005f3u, 0x00000065u, 0x000300f7u, 0x000005f6u, 0x00000000u, 0x000400fau, 0x000005f4u, + 0x000005f5u, 0x000005f6u, 0x000200f8u, 0x000005f5u, 0x0003003eu, 0x000005efu, 0x00000065u, 0x000200f9u, + 0x000005f6u, 0x000200f8u, 0x000005f6u, 0x0004003du, 0x00000006u, 0x000005fau, 0x000005d5u, 0x00050041u, + 0x00000039u, 0x000005fbu, 0x000005e3u, 0x0000007du, 0x0004003du, 0x00000009u, 0x000005fcu, 0x000005fbu, + 0x0004003du, 0x00000009u, 0x000005fdu, 0x000005efu, 0x00050088u, 0x00000009u, 0x000005feu, 0x000005fcu, + 0x000005fdu, 0x00050085u, 0x00000009u, 0x000005ffu, 0x000005feu, 0x00000033u, 0x00050081u, 0x00000009u, + 0x00000600u, 0x000005ffu, 0x00000033u, 0x00050041u, 0x00000039u, 0x00000601u, 0x00000348u, 0x00000082u, + 0x0004003du, 0x00000009u, 0x00000602u, 0x00000601u, 0x00050085u, 0x00000009u, 0x00000603u, 0x00000600u, + 0x00000602u, 0x00050041u, 0x00000039u, 0x00000604u, 0x000005e3u, 0x00000008u, 0x0004003du, 0x00000009u, + 0x00000605u, 0x00000604u, 0x0004003du, 0x00000009u, 0x00000606u, 0x000005efu, 0x00050088u, 0x00000009u, + 0x00000607u, 0x00000605u, 0x00000606u, 0x00050085u, 0x00000009u, 0x00000608u, 0x00000607u, 0x00000033u, + 0x00050083u, 0x00000009u, 0x00000609u, 0x00000033u, 0x00000608u, 0x00050041u, 0x00000039u, 0x0000060au, + 0x00000348u, 0x0000008du, 0x0004003du, 0x00000009u, 0x0000060bu, 0x0000060au, 0x00050085u, 0x00000009u, + 0x0000060cu, 0x00000609u, 0x0000060bu, 0x00050050u, 0x0000009au, 0x0000060du, 0x00000603u, 0x0000060cu, + 0x00050041u, 0x0000060eu, 0x0000060fu, 0x000005f9u, 0x000005fau, 0x0003003eu, 0x0000060fu, 0x0000060du, + 0x000200f9u, 0x000005dau, 0x000200f8u, 0x000005dau, 0x0004003du, 0x00000006u, 0x00000610u, 0x000005d5u, + 0x00050080u, 0x00000006u, 0x00000611u, 0x00000610u, 0x00000007u, 0x0003003eu, 0x000005d5u, 0x00000611u, + 0x000200f9u, 0x000005d7u, 0x000200f8u, 0x000005d9u, 0x000400e0u, 0x0000003bu, 0x0000003bu, 0x000005c0u, + 0x0004003du, 0x00000006u, 0x00000613u, 0x000005c1u, 0x00050082u, 0x00000006u, 0x00000614u, 0x00000613u, + 0x00000008u, 0x0003003eu, 0x00000612u, 0x00000614u, 0x0003003eu, 0x00000615u, 0x000004f0u, 0x0003003eu, + 0x00000616u, 0x000004f0u, 0x0004003du, 0x00000011u, 0x00000618u, 0x00000615u, 0x000600a9u, 0x00000006u, + 0x00000619u, 0x00000618u, 0x00000577u, 0x0000007du, 0x0004003du, 0x00000011u, 0x0000061au, 0x00000616u, + 0x000600a9u, 0x00000006u, 0x0000061bu, 0x0000061au, 0x00000577u, 0x0000007du, 0x00050080u, 0x00000006u, + 0x0000061cu, 0x00000619u, 0x0000061bu, 0x0003003eu, 0x00000617u, 0x0000061cu, 0x0004003du, 0x00000011u, + 0x0000061eu, 0x00000615u, 0x000600a9u, 0x00000006u, 0x0000061fu, 0x0000061eu, 0x00000577u, 0x0000007du, + 0x0004003du, 0x00000011u, 0x00000620u, 0x00000616u, 0x000600a9u, 0x00000006u, 0x00000621u, 0x00000620u, + 0x00000577u, 0x0000007du, 0x00050080u, 0x00000006u, 0x00000622u, 0x0000061fu, 0x00000621u, 0x0003003eu, + 0x0000061du, 0x00000622u, 0x0004003du, 0x00000006u, 0x00000624u, 0x000005c1u, 0x00050084u, 0x00000006u, + 0x00000625u, 0x00000624u, 0x0000003bu, 0x0003003eu, 0x00000623u, 0x00000625u, 0x0004003du, 0x00000006u, + 0x00000627u, 0x00000623u, 0x0003003eu, 0x00000626u, 0x00000627u, 0x0004003du, 0x00000006u, 0x00000629u, + 0x00000626u, 0x0004003du, 0x00000011u, 0x0000062au, 0x00000615u, 0x000600a9u, 0x00000006u, 0x0000062bu, + 0x0000062au, 0x00000577u, 0x0000007du, 0x00050080u, 0x00000006u, 0x0000062cu, 0x00000629u, 0x0000062bu, + 0x0003003eu, 0x00000628u, 0x0000062cu, 0x0004003du, 0x00000006u, 0x0000062eu, 0x00000623u, 0x0004003du, + 0x00000006u, 0x0000062fu, 0x00000617u, 0x00050080u, 0x00000006u, 0x00000630u, 0x0000062eu, 0x0000062fu, + 0x0003003eu, 0x0000062du, 0x00000630u, 0x0004003du, 0x00000006u, 0x00000632u, 0x00000612u, 0x00050084u, + 0x00000006u, 0x00000633u, 0x00000632u, 0x0000003bu, 0x0004003du, 0x00000006u, 0x00000634u, 0x0000061du, + 0x00050080u, 0x00000006u, 0x00000635u, 0x00000633u, 0x00000634u, 0x0003003eu, 0x00000631u, 0x00000635u, + 0x0004003du, 0x00000006u, 0x00000636u, 0x00000631u, 0x0007000cu, 0x00000006u, 0x00000638u, 0x00000001u, + 0x00000026u, 0x00000636u, 0x00000637u, 0x0003003eu, 0x00000305u, 0x00000638u, 0x0004003du, 0x00000006u, + 0x00000639u, 0x0000062du, 0x0004003du, 0x00000006u, 0x0000063au, 0x00000305u, 0x000314afu, 0x00000639u, + 0x0000063au, 0x0004003du, 0x00000006u, 0x0000063cu, 0x0000030du, 0x0003003eu, 0x0000063bu, 0x0000063cu, + 0x000200f9u, 0x0000063du, 0x000200f8u, 0x0000063du, 0x000400f6u, 0x0000063fu, 0x00000640u, 0x00000000u, + 0x000200f9u, 0x00000641u, 0x000200f8u, 0x00000641u, 0x0004003du, 0x00000006u, 0x00000642u, 0x0000063bu, + 0x0004003du, 0x00000006u, 0x00000643u, 0x000005c1u, 0x000500b0u, 0x00000011u, 0x00000644u, 0x00000642u, + 0x00000643u, 0x000400fau, 0x00000644u, 0x0000063eu, 0x0000063fu, 0x000200f8u, 0x0000063eu, 0x0004003du, + 0x00000006u, 0x00000646u, 0x0000063bu, 0x00050041u, 0x000005edu, 0x00000647u, 0x000005b4u, 0x00000646u, + 0x0004003du, 0x0000000au, 0x00000648u, 0x00000647u, 0x0003003eu, 0x00000645u, 0x00000648u, 0x0004003du, + 0x00000006u, 0x0000064au, 0x0000063bu, 0x00050041u, 0x0000060eu, 0x0000064bu, 0x000005f9u, 0x0000064au, + 0x0004003du, 0x0000009au, 0x0000064cu, 0x0000064bu, 0x0003003eu, 0x00000649u, 0x0000064cu, 0x0003003eu, + 0x0000064du, 0x00000037u, 0x0003003eu, 0x0000064eu, 0x0000064fu, 0x0003003eu, 0x00000650u, 0x0000064fu, + 0x0004003du, 0x00000006u, 0x00000652u, 0x0000063bu, 0x000500acu, 0x00000011u, 0x00000653u, 0x00000652u, + 0x0000007du, 0x0003003eu, 0x00000651u, 0x00000653u, 0x0004003du, 0x00000006u, 0x00000655u, 0x0000063bu, + 0x0004003du, 0x00000006u, 0x00000656u, 0x000005c1u, 0x00050082u, 0x00000006u, 0x00000657u, 0x00000656u, + 0x00000008u, 0x000500b0u, 0x00000011u, 0x00000658u, 0x00000655u, 0x00000657u, 0x0003003eu, 0x00000654u, + 0x00000658u, 0x0004003du, 0x0000009au, 0x0000065au, 0x00000649u, 0x0003003eu, 0x00000659u, 0x0000065au, + 0x0004003du, 0x0000000au, 0x0000065cu, 0x00000645u, 0x0003003eu, 0x0000065bu, 0x0000065cu, 0x00050041u, + 0x00000039u, 0x0000065du, 0x0000065bu, 0x0000003eu, 0x0004003du, 0x00000009u, 0x0000065eu, 0x0000065du, + 0x0004003du, 0x00000009u, 0x0000065fu, 0x0000064du, 0x000500b8u, 0x00000011u, 0x00000660u, 0x0000065eu, + 0x0000065fu, 0x0004003du, 0x00000006u, 0x00000661u, 0x0000063bu, 0x000500acu, 0x00000011u, 0x00000662u, + 0x00000661u, 0x0000007du, 0x000500a7u, 0x00000011u, 0x00000663u, 0x00000660u, 0x00000662u, 0x000300f7u, + 0x00000665u, 0x00000000u, 0x000400fau, 0x00000663u, 0x00000664u, 0x00000665u, 0x000200f8u, 0x00000664u, + 0x0004003du, 0x00000006u, 0x00000666u, 0x0000063bu, 0x00050082u, 0x00000006u, 0x00000667u, 0x00000666u, + 0x00000008u, 0x00060041u, 0x000005b8u, 0x00000668u, 0x000005b4u, 0x00000667u, 0x0000003eu, 0x0004003du, + 0x00000009u, 0x00000669u, 0x00000668u, 0x0004003du, 0x00000009u, 0x0000066au, 0x0000064du, 0x000500beu, + 0x00000011u, 0x0000066bu, 0x00000669u, 0x0000066au, 0x000200f9u, 0x00000665u, 0x000200f8u, 0x00000665u, + 0x000700f5u, 0x00000011u, 0x0000066cu, 0x00000663u, 0x0000063eu, 0x0000066bu, 0x00000664u, 0x000300f7u, + 0x0000066eu, 0x00000000u, 0x000400fau, 0x0000066cu, 0x0000066du, 0x000006b8u, 0x000200f8u, 0x0000066du, + 0x0004003du, 0x00000006u, 0x00000670u, 0x0000063bu, 0x00050082u, 0x00000006u, 0x00000671u, 0x00000670u, + 0x00000008u, 0x00050041u, 0x000004eeu, 0x00000672u, 0x000004e5u, 0x00000671u, 0x0004003du, 0x00000016u, + 0x00000673u, 0x00000672u, 0x0003003eu, 0x0000066fu, 0x00000673u, 0x0004003du, 0x00000006u, 0x00000675u, + 0x0000063bu, 0x00050041u, 0x000004eeu, 0x00000676u, 0x000004e5u, 0x00000675u, 0x0004003du, 0x00000016u, + 0x00000677u, 0x00000676u, 0x0003003eu, 0x00000674u, 0x00000677u, 0x0003003eu, 0x00000679u, 0x00000054u, + 0x000200f9u, 0x0000067au, 0x000200f8u, 0x0000067au, 0x000400f6u, 0x0000067cu, 0x0000067du, 0x00000000u, + 0x000200f9u, 0x0000067eu, 0x000200f8u, 0x0000067eu, 0x0004003du, 0x0000002bu, 0x0000067fu, 0x00000679u, + 0x000500b1u, 0x00000011u, 0x00000680u, 0x0000067fu, 0x00000079u, 0x000400fau, 0x00000680u, 0x0000067bu, + 0x0000067cu, 0x000200f8u, 0x0000067bu, 0x0004003du, 0x00000016u, 0x00000682u, 0x0000066fu, 0x0004003du, + 0x00000016u, 0x00000683u, 0x00000674u, 0x00050081u, 0x00000016u, 0x00000684u, 0x00000682u, 0x00000683u, + 0x0005008eu, 0x00000016u, 0x00000685u, 0x00000684u, 0x00000033u, 0x0003003eu, 0x00000681u, 0x00000685u, + 0x0004003du, 0x00000016u, 0x00000688u, 0x00000681u, 0x0003003eu, 0x00000687u, 0x00000688u, 0x0004003du, + 0x00000019u, 0x0000068au, 0x00000354u, 0x0003003eu, 0x00000689u, 0x0000068au, 0x0004003du, 0x0000001bu, + 0x0000068cu, 0x00000348u, 0x0003003eu, 0x0000068bu, 0x0000068cu, 0x00070039u, 0x0000000au, 0x0000068du, + 0x00000021u, 0x00000687u, 0x00000689u, 0x0000068bu, 0x0003003eu, 0x00000686u, 0x0000068du, 0x00050041u, + 0x00000039u, 0x0000068eu, 0x00000686u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x0000068fu, 0x0000068eu, + 0x0004003du, 0x00000009u, 0x00000690u, 0x0000064du, 0x000500beu, 0x00000011u, 0x00000691u, 0x0000068fu, + 0x00000690u, 0x000300f7u, 0x00000693u, 0x00000000u, 0x000400fau, 0x00000691u, 0x00000692u, 0x00000695u, + 0x000200f8u, 0x00000692u, 0x0004003du, 0x00000016u, 0x00000694u, 0x00000681u, 0x0003003eu, 0x0000066fu, + 0x00000694u, 0x000200f9u, 0x00000693u, 0x000200f8u, 0x00000695u, 0x0004003du, 0x00000016u, 0x00000696u, + 0x00000681u, 0x0003003eu, 0x00000674u, 0x00000696u, 0x000200f9u, 0x00000693u, 0x000200f8u, 0x00000693u, + 0x000200f9u, 0x0000067du, 0x000200f8u, 0x0000067du, 0x0004003du, 0x0000002bu, 0x00000697u, 0x00000679u, + 0x00050080u, 0x0000002bu, 0x00000698u, 0x00000697u, 0x0000011cu, 0x0003003eu, 0x00000679u, 0x00000698u, + 0x000200f9u, 0x0000067au, 0x000200f8u, 0x0000067cu, 0x0004003du, 0x00000016u, 0x0000069bu, 0x0000066fu, + 0x0003003eu, 0x0000069au, 0x0000069bu, 0x0004003du, 0x00000019u, 0x0000069du, 0x00000354u, 0x0003003eu, + 0x0000069cu, 0x0000069du, 0x0004003du, 0x0000001bu, 0x0000069fu, 0x00000348u, 0x0003003eu, 0x0000069eu, + 0x0000069fu, 0x00070039u, 0x0000000au, 0x000006a0u, 0x00000021u, 0x0000069au, 0x0000069cu, 0x0000069eu, + 0x0003003eu, 0x00000699u, 0x000006a0u, 0x00050041u, 0x00000039u, 0x000006a2u, 0x00000699u, 0x0000003eu, + 0x0004003du, 0x00000009u, 0x000006a3u, 0x000006a2u, 0x0007000cu, 0x00000009u, 0x000006a4u, 0x00000001u, + 0x00000028u, 0x000006a3u, 0x00000073u, 0x0003003eu, 0x000006a1u, 0x000006a4u, 0x00050041u, 0x00000039u, + 0x000006a5u, 0x00000699u, 0x0000007du, 0x0004003du, 0x00000009u, 0x000006a6u, 0x000006a5u, 0x0004003du, + 0x00000009u, 0x000006a7u, 0x000006a1u, 0x00050088u, 0x00000009u, 0x000006a8u, 0x000006a6u, 0x000006a7u, + 0x00050085u, 0x00000009u, 0x000006a9u, 0x000006a8u, 0x00000033u, 0x00050081u, 0x00000009u, 0x000006aau, + 0x000006a9u, 0x00000033u, 0x00050041u, 0x00000039u, 0x000006abu, 0x00000348u, 0x00000082u, 0x0004003du, + 0x00000009u, 0x000006acu, 0x000006abu, 0x00050085u, 0x00000009u, 0x000006adu, 0x000006aau, 0x000006acu, + 0x00050041u, 0x00000039u, 0x000006aeu, 0x00000699u, 0x00000008u, 0x0004003du, 0x00000009u, 0x000006afu, + 0x000006aeu, 0x0004003du, 0x00000009u, 0x000006b0u, 0x000006a1u, 0x00050088u, 0x00000009u, 0x000006b1u, + 0x000006afu, 0x000006b0u, 0x00050085u, 0x00000009u, 0x000006b2u, 0x000006b1u, 0x00000033u, 0x00050083u, + 0x00000009u, 0x000006b3u, 0x00000033u, 0x000006b2u, 0x00050041u, 0x00000039u, 0x000006b4u, 0x00000348u, + 0x0000008du, 0x0004003du, 0x00000009u, 0x000006b5u, 0x000006b4u, 0x00050085u, 0x00000009u, 0x000006b6u, + 0x000006b3u, 0x000006b5u, 0x00050050u, 0x0000009au, 0x000006b7u, 0x000006adu, 0x000006b6u, 0x0003003eu, + 0x00000659u, 0x000006b7u, 0x000200f9u, 0x0000066eu, 0x000200f8u, 0x000006b8u, 0x00050041u, 0x00000039u, + 0x000006b9u, 0x0000065bu, 0x0000003eu, 0x0004003du, 0x00000009u, 0x000006bau, 0x000006b9u, 0x0004003du, + 0x00000009u, 0x000006bbu, 0x0000064du, 0x000500b8u, 0x00000011u, 0x000006bcu, 0x000006bau, 0x000006bbu, + 0x000300f7u, 0x000006beu, 0x00000000u, 0x000400fau, 0x000006bcu, 0x000006bdu, 0x000006beu, 0x000200f8u, + 0x000006bdu, 0x0004003du, 0x00000006u, 0x000006bfu, 0x0000063bu, 0x0004003du, 0x00000006u, 0x000006c0u, + 0x000005c1u, 0x00050082u, 0x00000006u, 0x000006c1u, 0x000006c0u, 0x00000008u, 0x000500b0u, 0x00000011u, + 0x000006c2u, 0x000006bfu, 0x000006c1u, 0x000200f9u, 0x000006beu, 0x000200f8u, 0x000006beu, 0x000700f5u, + 0x00000011u, 0x000006c3u, 0x000006bcu, 0x000006b8u, 0x000006c2u, 0x000006bdu, 0x000300f7u, 0x000006c5u, + 0x00000000u, 0x000400fau, 0x000006c3u, 0x000006c4u, 0x000006c5u, 0x000200f8u, 0x000006c4u, 0x0004003du, + 0x00000006u, 0x000006c6u, 0x0000063bu, 0x00050080u, 0x00000006u, 0x000006c7u, 0x000006c6u, 0x00000008u, + 0x00060041u, 0x000005b8u, 0x000006c8u, 0x000005b4u, 0x000006c7u, 0x0000003eu, 0x0004003du, 0x00000009u, + 0x000006c9u, 0x000006c8u, 0x0004003du, 0x00000009u, 0x000006cau, 0x0000064du, 0x000500beu, 0x00000011u, + 0x000006cbu, 0x000006c9u, 0x000006cau, 0x000200f9u, 0x000006c5u, 0x000200f8u, 0x000006c5u, 0x000700f5u, + 0x00000011u, 0x000006ccu, 0x000006c3u, 0x000006beu, 0x000006cbu, 0x000006c4u, 0x000300f7u, 0x000006ceu, + 0x00000000u, 0x000400fau, 0x000006ccu, 0x000006cdu, 0x000006ceu, 0x000200f8u, 0x000006cdu, 0x0004003du, + 0x00000006u, 0x000006d0u, 0x0000063bu, 0x00050080u, 0x00000006u, 0x000006d1u, 0x000006d0u, 0x00000008u, + 0x00050041u, 0x000004eeu, 0x000006d2u, 0x000004e5u, 0x000006d1u, 0x0004003du, 0x00000016u, 0x000006d3u, + 0x000006d2u, 0x0003003eu, 0x000006cfu, 0x000006d3u, 0x0004003du, 0x00000006u, 0x000006d5u, 0x0000063bu, + 0x00050041u, 0x000004eeu, 0x000006d6u, 0x000004e5u, 0x000006d5u, 0x0004003du, 0x00000016u, 0x000006d7u, + 0x000006d6u, 0x0003003eu, 0x000006d4u, 0x000006d7u, 0x0003003eu, 0x000006d8u, 0x00000054u, 0x000200f9u, + 0x000006d9u, 0x000200f8u, 0x000006d9u, 0x000400f6u, 0x000006dbu, 0x000006dcu, 0x00000000u, 0x000200f9u, + 0x000006ddu, 0x000200f8u, 0x000006ddu, 0x0004003du, 0x0000002bu, 0x000006deu, 0x000006d8u, 0x000500b1u, + 0x00000011u, 0x000006dfu, 0x000006deu, 0x00000079u, 0x000400fau, 0x000006dfu, 0x000006dau, 0x000006dbu, + 0x000200f8u, 0x000006dau, 0x0004003du, 0x00000016u, 0x000006e1u, 0x000006cfu, 0x0004003du, 0x00000016u, + 0x000006e2u, 0x000006d4u, 0x00050081u, 0x00000016u, 0x000006e3u, 0x000006e1u, 0x000006e2u, 0x0005008eu, + 0x00000016u, 0x000006e4u, 0x000006e3u, 0x00000033u, 0x0003003eu, 0x000006e0u, 0x000006e4u, 0x0004003du, + 0x00000016u, 0x000006e7u, 0x000006e0u, 0x0003003eu, 0x000006e6u, 0x000006e7u, 0x0004003du, 0x00000019u, + 0x000006e9u, 0x00000354u, 0x0003003eu, 0x000006e8u, 0x000006e9u, 0x0004003du, 0x0000001bu, 0x000006ebu, + 0x00000348u, 0x0003003eu, 0x000006eau, 0x000006ebu, 0x00070039u, 0x0000000au, 0x000006ecu, 0x00000021u, + 0x000006e6u, 0x000006e8u, 0x000006eau, 0x0003003eu, 0x000006e5u, 0x000006ecu, 0x00050041u, 0x00000039u, + 0x000006edu, 0x000006e5u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x000006eeu, 0x000006edu, 0x0004003du, + 0x00000009u, 0x000006efu, 0x0000064du, 0x000500beu, 0x00000011u, 0x000006f0u, 0x000006eeu, 0x000006efu, + 0x000300f7u, 0x000006f2u, 0x00000000u, 0x000400fau, 0x000006f0u, 0x000006f1u, 0x000006f4u, 0x000200f8u, + 0x000006f1u, 0x0004003du, 0x00000016u, 0x000006f3u, 0x000006e0u, 0x0003003eu, 0x000006cfu, 0x000006f3u, + 0x000200f9u, 0x000006f2u, 0x000200f8u, 0x000006f4u, 0x0004003du, 0x00000016u, 0x000006f5u, 0x000006e0u, + 0x0003003eu, 0x000006d4u, 0x000006f5u, 0x000200f9u, 0x000006f2u, 0x000200f8u, 0x000006f2u, 0x000200f9u, + 0x000006dcu, 0x000200f8u, 0x000006dcu, 0x0004003du, 0x0000002bu, 0x000006f6u, 0x000006d8u, 0x00050080u, + 0x0000002bu, 0x000006f7u, 0x000006f6u, 0x0000011cu, 0x0003003eu, 0x000006d8u, 0x000006f7u, 0x000200f9u, + 0x000006d9u, 0x000200f8u, 0x000006dbu, 0x0004003du, 0x00000016u, 0x000006fau, 0x000006cfu, 0x0003003eu, + 0x000006f9u, 0x000006fau, 0x0004003du, 0x00000019u, 0x000006fcu, 0x00000354u, 0x0003003eu, 0x000006fbu, + 0x000006fcu, 0x0004003du, 0x0000001bu, 0x000006feu, 0x00000348u, 0x0003003eu, 0x000006fdu, 0x000006feu, + 0x00070039u, 0x0000000au, 0x000006ffu, 0x00000021u, 0x000006f9u, 0x000006fbu, 0x000006fdu, 0x0003003eu, + 0x000006f8u, 0x000006ffu, 0x00050041u, 0x00000039u, 0x00000701u, 0x000006f8u, 0x0000003eu, 0x0004003du, + 0x00000009u, 0x00000702u, 0x00000701u, 0x0007000cu, 0x00000009u, 0x00000703u, 0x00000001u, 0x00000028u, + 0x00000702u, 0x00000073u, 0x0003003eu, 0x00000700u, 0x00000703u, 0x00050041u, 0x00000039u, 0x00000704u, + 0x000006f8u, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000705u, 0x00000704u, 0x0004003du, 0x00000009u, + 0x00000706u, 0x00000700u, 0x00050088u, 0x00000009u, 0x00000707u, 0x00000705u, 0x00000706u, 0x00050085u, + 0x00000009u, 0x00000708u, 0x00000707u, 0x00000033u, 0x00050081u, 0x00000009u, 0x00000709u, 0x00000708u, + 0x00000033u, 0x00050041u, 0x00000039u, 0x0000070au, 0x00000348u, 0x00000082u, 0x0004003du, 0x00000009u, + 0x0000070bu, 0x0000070au, 0x00050085u, 0x00000009u, 0x0000070cu, 0x00000709u, 0x0000070bu, 0x00050041u, + 0x00000039u, 0x0000070du, 0x000006f8u, 0x00000008u, 0x0004003du, 0x00000009u, 0x0000070eu, 0x0000070du, + 0x0004003du, 0x00000009u, 0x0000070fu, 0x00000700u, 0x00050088u, 0x00000009u, 0x00000710u, 0x0000070eu, + 0x0000070fu, 0x00050085u, 0x00000009u, 0x00000711u, 0x00000710u, 0x00000033u, 0x00050083u, 0x00000009u, + 0x00000712u, 0x00000033u, 0x00000711u, 0x00050041u, 0x00000039u, 0x00000713u, 0x00000348u, 0x0000008du, + 0x0004003du, 0x00000009u, 0x00000714u, 0x00000713u, 0x00050085u, 0x00000009u, 0x00000715u, 0x00000712u, + 0x00000714u, 0x00050050u, 0x0000009au, 0x00000716u, 0x0000070cu, 0x00000715u, 0x0003003eu, 0x00000659u, + 0x00000716u, 0x000200f9u, 0x000006ceu, 0x000200f8u, 0x000006ceu, 0x000200f9u, 0x0000066eu, 0x000200f8u, + 0x0000066eu, 0x0004003du, 0x00000011u, 0x00000717u, 0x00000651u, 0x000300f7u, 0x00000719u, 0x00000000u, + 0x000400fau, 0x00000717u, 0x00000718u, 0x00000719u, 0x000200f8u, 0x00000718u, 0x0004003du, 0x00000006u, + 0x0000071bu, 0x0000063bu, 0x00050082u, 0x00000006u, 0x0000071cu, 0x0000071bu, 0x00000008u, 0x00050041u, + 0x0000060eu, 0x0000071du, 0x000005f9u, 0x0000071cu, 0x0004003du, 0x0000009au, 0x0000071eu, 0x0000071du, + 0x0003003eu, 0x0000071au, 0x0000071eu, 0x0004003du, 0x00000006u, 0x0000071fu, 0x0000063bu, 0x00050082u, + 0x00000006u, 0x00000720u, 0x0000071fu, 0x00000008u, 0x00060041u, 0x000005b8u, 0x00000721u, 0x000005b4u, + 0x00000720u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000722u, 0x00000721u, 0x0004003du, 0x00000009u, + 0x00000723u, 0x0000064du, 0x000500b8u, 0x00000011u, 0x00000724u, 0x00000722u, 0x00000723u, 0x000300f7u, + 0x00000726u, 0x00000000u, 0x000400fau, 0x00000724u, 0x00000725u, 0x00000726u, 0x000200f8u, 0x00000725u, + 0x00050041u, 0x00000039u, 0x00000727u, 0x0000065bu, 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000728u, + 0x00000727u, 0x0004003du, 0x00000009u, 0x00000729u, 0x0000064du, 0x000500beu, 0x00000011u, 0x0000072au, + 0x00000728u, 0x00000729u, 0x000200f9u, 0x00000726u, 0x000200f8u, 0x00000726u, 0x000700f5u, 0x00000011u, + 0x0000072bu, 0x00000724u, 0x00000718u, 0x0000072au, 0x00000725u, 0x000300f7u, 0x0000072du, 0x00000000u, + 0x000400fau, 0x0000072bu, 0x0000072cu, 0x0000072du, 0x000200f8u, 0x0000072cu, 0x0004003du, 0x00000006u, + 0x0000072fu, 0x0000063bu, 0x00050041u, 0x000004eeu, 0x00000730u, 0x000004e5u, 0x0000072fu, 0x0004003du, + 0x00000016u, 0x00000731u, 0x00000730u, 0x0003003eu, 0x0000072eu, 0x00000731u, 0x0004003du, 0x00000006u, + 0x00000733u, 0x0000063bu, 0x00050082u, 0x00000006u, 0x00000734u, 0x00000733u, 0x00000008u, 0x00050041u, + 0x000004eeu, 0x00000735u, 0x000004e5u, 0x00000734u, 0x0004003du, 0x00000016u, 0x00000736u, 0x00000735u, + 0x0003003eu, 0x00000732u, 0x00000736u, 0x0003003eu, 0x00000737u, 0x00000054u, 0x000200f9u, 0x00000738u, + 0x000200f8u, 0x00000738u, 0x000400f6u, 0x0000073au, 0x0000073bu, 0x00000000u, 0x000200f9u, 0x0000073cu, + 0x000200f8u, 0x0000073cu, 0x0004003du, 0x0000002bu, 0x0000073du, 0x00000737u, 0x000500b1u, 0x00000011u, + 0x0000073eu, 0x0000073du, 0x00000079u, 0x000400fau, 0x0000073eu, 0x00000739u, 0x0000073au, 0x000200f8u, + 0x00000739u, 0x0004003du, 0x00000016u, 0x00000740u, 0x0000072eu, 0x0004003du, 0x00000016u, 0x00000741u, + 0x00000732u, 0x00050081u, 0x00000016u, 0x00000742u, 0x00000740u, 0x00000741u, 0x0005008eu, 0x00000016u, + 0x00000743u, 0x00000742u, 0x00000033u, 0x0003003eu, 0x0000073fu, 0x00000743u, 0x0004003du, 0x00000016u, + 0x00000746u, 0x0000073fu, 0x0003003eu, 0x00000745u, 0x00000746u, 0x0004003du, 0x00000019u, 0x00000748u, + 0x00000354u, 0x0003003eu, 0x00000747u, 0x00000748u, 0x0004003du, 0x0000001bu, 0x0000074au, 0x00000348u, + 0x0003003eu, 0x00000749u, 0x0000074au, 0x00070039u, 0x0000000au, 0x0000074bu, 0x00000021u, 0x00000745u, + 0x00000747u, 0x00000749u, 0x0003003eu, 0x00000744u, 0x0000074bu, 0x00050041u, 0x00000039u, 0x0000074cu, + 0x00000744u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x0000074du, 0x0000074cu, 0x0004003du, 0x00000009u, + 0x0000074eu, 0x0000064du, 0x000500beu, 0x00000011u, 0x0000074fu, 0x0000074du, 0x0000074eu, 0x000300f7u, + 0x00000751u, 0x00000000u, 0x000400fau, 0x0000074fu, 0x00000750u, 0x00000753u, 0x000200f8u, 0x00000750u, + 0x0004003du, 0x00000016u, 0x00000752u, 0x0000073fu, 0x0003003eu, 0x0000072eu, 0x00000752u, 0x000200f9u, + 0x00000751u, 0x000200f8u, 0x00000753u, 0x0004003du, 0x00000016u, 0x00000754u, 0x0000073fu, 0x0003003eu, + 0x00000732u, 0x00000754u, 0x000200f9u, 0x00000751u, 0x000200f8u, 0x00000751u, 0x000200f9u, 0x0000073bu, + 0x000200f8u, 0x0000073bu, 0x0004003du, 0x0000002bu, 0x00000755u, 0x00000737u, 0x00050080u, 0x0000002bu, + 0x00000756u, 0x00000755u, 0x0000011cu, 0x0003003eu, 0x00000737u, 0x00000756u, 0x000200f9u, 0x00000738u, + 0x000200f8u, 0x0000073au, 0x0004003du, 0x00000016u, 0x00000759u, 0x0000072eu, 0x0003003eu, 0x00000758u, + 0x00000759u, 0x0004003du, 0x00000019u, 0x0000075bu, 0x00000354u, 0x0003003eu, 0x0000075au, 0x0000075bu, + 0x0004003du, 0x0000001bu, 0x0000075du, 0x00000348u, 0x0003003eu, 0x0000075cu, 0x0000075du, 0x00070039u, + 0x0000000au, 0x0000075eu, 0x00000021u, 0x00000758u, 0x0000075au, 0x0000075cu, 0x0003003eu, 0x00000757u, + 0x0000075eu, 0x00050041u, 0x00000039u, 0x00000760u, 0x00000757u, 0x0000003eu, 0x0004003du, 0x00000009u, + 0x00000761u, 0x00000760u, 0x0007000cu, 0x00000009u, 0x00000762u, 0x00000001u, 0x00000028u, 0x00000761u, + 0x00000073u, 0x0003003eu, 0x0000075fu, 0x00000762u, 0x00050041u, 0x00000039u, 0x00000763u, 0x00000757u, + 0x0000007du, 0x0004003du, 0x00000009u, 0x00000764u, 0x00000763u, 0x0004003du, 0x00000009u, 0x00000765u, + 0x0000075fu, 0x00050088u, 0x00000009u, 0x00000766u, 0x00000764u, 0x00000765u, 0x00050085u, 0x00000009u, + 0x00000767u, 0x00000766u, 0x00000033u, 0x00050081u, 0x00000009u, 0x00000768u, 0x00000767u, 0x00000033u, + 0x00050041u, 0x00000039u, 0x00000769u, 0x00000348u, 0x00000082u, 0x0004003du, 0x00000009u, 0x0000076au, + 0x00000769u, 0x00050085u, 0x00000009u, 0x0000076bu, 0x00000768u, 0x0000076au, 0x00050041u, 0x00000039u, + 0x0000076cu, 0x00000757u, 0x00000008u, 0x0004003du, 0x00000009u, 0x0000076du, 0x0000076cu, 0x0004003du, + 0x00000009u, 0x0000076eu, 0x0000075fu, 0x00050088u, 0x00000009u, 0x0000076fu, 0x0000076du, 0x0000076eu, + 0x00050085u, 0x00000009u, 0x00000770u, 0x0000076fu, 0x00000033u, 0x00050083u, 0x00000009u, 0x00000771u, + 0x00000033u, 0x00000770u, 0x00050041u, 0x00000039u, 0x00000772u, 0x00000348u, 0x0000008du, 0x0004003du, + 0x00000009u, 0x00000773u, 0x00000772u, 0x00050085u, 0x00000009u, 0x00000774u, 0x00000771u, 0x00000773u, + 0x00050050u, 0x0000009au, 0x00000775u, 0x0000076bu, 0x00000774u, 0x0003003eu, 0x0000071au, 0x00000775u, + 0x000200f9u, 0x0000072du, 0x000200f8u, 0x0000072du, 0x0004003du, 0x0000009au, 0x00000777u, 0x00000659u, + 0x0004003du, 0x0000009au, 0x00000778u, 0x0000071au, 0x00050083u, 0x0000009au, 0x00000779u, 0x00000777u, + 0x00000778u, 0x0003003eu, 0x00000776u, 0x00000779u, 0x0004003du, 0x0000009au, 0x0000077bu, 0x00000776u, + 0x0006000cu, 0x00000009u, 0x0000077cu, 0x00000001u, 0x00000042u, 0x0000077bu, 0x0003003eu, 0x0000077au, + 0x0000077cu, 0x0004003du, 0x00000009u, 0x0000077du, 0x0000077au, 0x000500bau, 0x00000011u, 0x0000077eu, + 0x0000077du, 0x00000073u, 0x000300f7u, 0x00000780u, 0x00000000u, 0x000400fau, 0x0000077eu, 0x0000077fu, + 0x00000780u, 0x000200f8u, 0x0000077fu, 0x0004003du, 0x0000009au, 0x00000781u, 0x00000776u, 0x0004003du, + 0x00000009u, 0x00000782u, 0x0000077au, 0x00050050u, 0x0000009au, 0x00000783u, 0x00000782u, 0x00000782u, + 0x00050088u, 0x0000009au, 0x00000784u, 0x00000781u, 0x00000783u, 0x0003003eu, 0x0000064eu, 0x00000784u, + 0x000200f9u, 0x00000780u, 0x000200f8u, 0x00000780u, 0x000200f9u, 0x00000719u, 0x000200f8u, 0x00000719u, + 0x0004003du, 0x00000011u, 0x00000785u, 0x00000654u, 0x000300f7u, 0x00000787u, 0x00000000u, 0x000400fau, + 0x00000785u, 0x00000786u, 0x00000787u, 0x000200f8u, 0x00000786u, 0x0004003du, 0x00000006u, 0x00000789u, + 0x0000063bu, 0x00050080u, 0x00000006u, 0x0000078au, 0x00000789u, 0x00000008u, 0x00050041u, 0x0000060eu, + 0x0000078bu, 0x000005f9u, 0x0000078au, 0x0004003du, 0x0000009au, 0x0000078cu, 0x0000078bu, 0x0003003eu, + 0x00000788u, 0x0000078cu, 0x0004003du, 0x00000006u, 0x0000078du, 0x0000063bu, 0x00050080u, 0x00000006u, + 0x0000078eu, 0x0000078du, 0x00000008u, 0x00060041u, 0x000005b8u, 0x0000078fu, 0x000005b4u, 0x0000078eu, + 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000790u, 0x0000078fu, 0x0004003du, 0x00000009u, 0x00000791u, + 0x0000064du, 0x000500b8u, 0x00000011u, 0x00000792u, 0x00000790u, 0x00000791u, 0x000300f7u, 0x00000794u, + 0x00000000u, 0x000400fau, 0x00000792u, 0x00000793u, 0x00000794u, 0x000200f8u, 0x00000793u, 0x00050041u, + 0x00000039u, 0x00000795u, 0x0000065bu, 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000796u, 0x00000795u, + 0x0004003du, 0x00000009u, 0x00000797u, 0x0000064du, 0x000500beu, 0x00000011u, 0x00000798u, 0x00000796u, + 0x00000797u, 0x000200f9u, 0x00000794u, 0x000200f8u, 0x00000794u, 0x000700f5u, 0x00000011u, 0x00000799u, + 0x00000792u, 0x00000786u, 0x00000798u, 0x00000793u, 0x000300f7u, 0x0000079bu, 0x00000000u, 0x000400fau, + 0x00000799u, 0x0000079au, 0x0000079bu, 0x000200f8u, 0x0000079au, 0x0004003du, 0x00000006u, 0x0000079du, + 0x0000063bu, 0x00050041u, 0x000004eeu, 0x0000079eu, 0x000004e5u, 0x0000079du, 0x0004003du, 0x00000016u, + 0x0000079fu, 0x0000079eu, 0x0003003eu, 0x0000079cu, 0x0000079fu, 0x0004003du, 0x00000006u, 0x000007a1u, + 0x0000063bu, 0x00050080u, 0x00000006u, 0x000007a2u, 0x000007a1u, 0x00000008u, 0x00050041u, 0x000004eeu, + 0x000007a3u, 0x000004e5u, 0x000007a2u, 0x0004003du, 0x00000016u, 0x000007a4u, 0x000007a3u, 0x0003003eu, + 0x000007a0u, 0x000007a4u, 0x0003003eu, 0x000007a5u, 0x00000054u, 0x000200f9u, 0x000007a6u, 0x000200f8u, + 0x000007a6u, 0x000400f6u, 0x000007a8u, 0x000007a9u, 0x00000000u, 0x000200f9u, 0x000007aau, 0x000200f8u, + 0x000007aau, 0x0004003du, 0x0000002bu, 0x000007abu, 0x000007a5u, 0x000500b1u, 0x00000011u, 0x000007acu, + 0x000007abu, 0x00000079u, 0x000400fau, 0x000007acu, 0x000007a7u, 0x000007a8u, 0x000200f8u, 0x000007a7u, + 0x0004003du, 0x00000016u, 0x000007aeu, 0x0000079cu, 0x0004003du, 0x00000016u, 0x000007afu, 0x000007a0u, + 0x00050081u, 0x00000016u, 0x000007b0u, 0x000007aeu, 0x000007afu, 0x0005008eu, 0x00000016u, 0x000007b1u, + 0x000007b0u, 0x00000033u, 0x0003003eu, 0x000007adu, 0x000007b1u, 0x0004003du, 0x00000016u, 0x000007b4u, + 0x000007adu, 0x0003003eu, 0x000007b3u, 0x000007b4u, 0x0004003du, 0x00000019u, 0x000007b6u, 0x00000354u, + 0x0003003eu, 0x000007b5u, 0x000007b6u, 0x0004003du, 0x0000001bu, 0x000007b8u, 0x00000348u, 0x0003003eu, + 0x000007b7u, 0x000007b8u, 0x00070039u, 0x0000000au, 0x000007b9u, 0x00000021u, 0x000007b3u, 0x000007b5u, + 0x000007b7u, 0x0003003eu, 0x000007b2u, 0x000007b9u, 0x00050041u, 0x00000039u, 0x000007bau, 0x000007b2u, + 0x0000003eu, 0x0004003du, 0x00000009u, 0x000007bbu, 0x000007bau, 0x0004003du, 0x00000009u, 0x000007bcu, + 0x0000064du, 0x000500beu, 0x00000011u, 0x000007bdu, 0x000007bbu, 0x000007bcu, 0x000300f7u, 0x000007bfu, + 0x00000000u, 0x000400fau, 0x000007bdu, 0x000007beu, 0x000007c1u, 0x000200f8u, 0x000007beu, 0x0004003du, + 0x00000016u, 0x000007c0u, 0x000007adu, 0x0003003eu, 0x0000079cu, 0x000007c0u, 0x000200f9u, 0x000007bfu, + 0x000200f8u, 0x000007c1u, 0x0004003du, 0x00000016u, 0x000007c2u, 0x000007adu, 0x0003003eu, 0x000007a0u, + 0x000007c2u, 0x000200f9u, 0x000007bfu, 0x000200f8u, 0x000007bfu, 0x000200f9u, 0x000007a9u, 0x000200f8u, + 0x000007a9u, 0x0004003du, 0x0000002bu, 0x000007c3u, 0x000007a5u, 0x00050080u, 0x0000002bu, 0x000007c4u, + 0x000007c3u, 0x0000011cu, 0x0003003eu, 0x000007a5u, 0x000007c4u, 0x000200f9u, 0x000007a6u, 0x000200f8u, + 0x000007a8u, 0x0004003du, 0x00000016u, 0x000007c7u, 0x0000079cu, 0x0003003eu, 0x000007c6u, 0x000007c7u, + 0x0004003du, 0x00000019u, 0x000007c9u, 0x00000354u, 0x0003003eu, 0x000007c8u, 0x000007c9u, 0x0004003du, + 0x0000001bu, 0x000007cbu, 0x00000348u, 0x0003003eu, 0x000007cau, 0x000007cbu, 0x00070039u, 0x0000000au, + 0x000007ccu, 0x00000021u, 0x000007c6u, 0x000007c8u, 0x000007cau, 0x0003003eu, 0x000007c5u, 0x000007ccu, + 0x00050041u, 0x00000039u, 0x000007ceu, 0x000007c5u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x000007cfu, + 0x000007ceu, 0x0007000cu, 0x00000009u, 0x000007d0u, 0x00000001u, 0x00000028u, 0x000007cfu, 0x00000073u, + 0x0003003eu, 0x000007cdu, 0x000007d0u, 0x00050041u, 0x00000039u, 0x000007d1u, 0x000007c5u, 0x0000007du, + 0x0004003du, 0x00000009u, 0x000007d2u, 0x000007d1u, 0x0004003du, 0x00000009u, 0x000007d3u, 0x000007cdu, + 0x00050088u, 0x00000009u, 0x000007d4u, 0x000007d2u, 0x000007d3u, 0x00050085u, 0x00000009u, 0x000007d5u, + 0x000007d4u, 0x00000033u, 0x00050081u, 0x00000009u, 0x000007d6u, 0x000007d5u, 0x00000033u, 0x00050041u, + 0x00000039u, 0x000007d7u, 0x00000348u, 0x00000082u, 0x0004003du, 0x00000009u, 0x000007d8u, 0x000007d7u, + 0x00050085u, 0x00000009u, 0x000007d9u, 0x000007d6u, 0x000007d8u, 0x00050041u, 0x00000039u, 0x000007dau, + 0x000007c5u, 0x00000008u, 0x0004003du, 0x00000009u, 0x000007dbu, 0x000007dau, 0x0004003du, 0x00000009u, + 0x000007dcu, 0x000007cdu, 0x00050088u, 0x00000009u, 0x000007ddu, 0x000007dbu, 0x000007dcu, 0x00050085u, + 0x00000009u, 0x000007deu, 0x000007ddu, 0x00000033u, 0x00050083u, 0x00000009u, 0x000007dfu, 0x00000033u, + 0x000007deu, 0x00050041u, 0x00000039u, 0x000007e0u, 0x00000348u, 0x0000008du, 0x0004003du, 0x00000009u, + 0x000007e1u, 0x000007e0u, 0x00050085u, 0x00000009u, 0x000007e2u, 0x000007dfu, 0x000007e1u, 0x00050050u, + 0x0000009au, 0x000007e3u, 0x000007d9u, 0x000007e2u, 0x0003003eu, 0x00000788u, 0x000007e3u, 0x000200f9u, + 0x0000079bu, 0x000200f8u, 0x0000079bu, 0x0004003du, 0x0000009au, 0x000007e5u, 0x00000788u, 0x0004003du, + 0x0000009au, 0x000007e6u, 0x00000659u, 0x00050083u, 0x0000009au, 0x000007e7u, 0x000007e5u, 0x000007e6u, + 0x0003003eu, 0x000007e4u, 0x000007e7u, 0x0004003du, 0x0000009au, 0x000007e9u, 0x000007e4u, 0x0006000cu, + 0x00000009u, 0x000007eau, 0x00000001u, 0x00000042u, 0x000007e9u, 0x0003003eu, 0x000007e8u, 0x000007eau, + 0x0004003du, 0x00000009u, 0x000007ebu, 0x000007e8u, 0x000500bau, 0x00000011u, 0x000007ecu, 0x000007ebu, + 0x00000073u, 0x000300f7u, 0x000007eeu, 0x00000000u, 0x000400fau, 0x000007ecu, 0x000007edu, 0x000007eeu, + 0x000200f8u, 0x000007edu, 0x0004003du, 0x0000009au, 0x000007efu, 0x000007e4u, 0x0004003du, 0x00000009u, + 0x000007f0u, 0x000007e8u, 0x00050050u, 0x0000009au, 0x000007f1u, 0x000007f0u, 0x000007f0u, 0x00050088u, + 0x0000009au, 0x000007f2u, 0x000007efu, 0x000007f1u, 0x0003003eu, 0x00000650u, 0x000007f2u, 0x000200f9u, + 0x000007eeu, 0x000200f8u, 0x000007eeu, 0x000200f9u, 0x00000787u, 0x000200f8u, 0x00000787u, 0x0003003eu, + 0x000007f3u, 0x00000037u, 0x0004003du, 0x00000011u, 0x000007f4u, 0x00000651u, 0x0004003du, 0x00000011u, + 0x000007f5u, 0x00000654u, 0x000500a7u, 0x00000011u, 0x000007f6u, 0x000007f4u, 0x000007f5u, 0x000300f7u, + 0x000007f8u, 0x00000000u, 0x000400fau, 0x000007f6u, 0x000007f7u, 0x000007f8u, 0x000200f8u, 0x000007f7u, + 0x0004003du, 0x0000009au, 0x000007f9u, 0x0000064eu, 0x0006000cu, 0x00000009u, 0x000007fau, 0x00000001u, + 0x00000042u, 0x000007f9u, 0x000500bau, 0x00000011u, 0x000007fbu, 0x000007fau, 0x00000073u, 0x000200f9u, + 0x000007f8u, 0x000200f8u, 0x000007f8u, 0x000700f5u, 0x00000011u, 0x000007fcu, 0x000007f6u, 0x00000787u, + 0x000007fbu, 0x000007f7u, 0x000300f7u, 0x000007feu, 0x00000000u, 0x000400fau, 0x000007fcu, 0x000007fdu, + 0x000007feu, 0x000200f8u, 0x000007fdu, 0x0004003du, 0x0000009au, 0x000007ffu, 0x00000650u, 0x0006000cu, + 0x00000009u, 0x00000800u, 0x00000001u, 0x00000042u, 0x000007ffu, 0x000500bau, 0x00000011u, 0x00000801u, + 0x00000800u, 0x00000073u, 0x000200f9u, 0x000007feu, 0x000200f8u, 0x000007feu, 0x000700f5u, 0x00000011u, + 0x00000802u, 0x000007fcu, 0x000007f8u, 0x00000801u, 0x000007fdu, 0x000300f7u, 0x00000804u, 0x00000000u, + 0x000400fau, 0x00000802u, 0x00000803u, 0x00000832u, 0x000200f8u, 0x00000803u, 0x00050041u, 0x00000039u, + 0x00000806u, 0x0000064eu, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000807u, 0x00000806u, 0x0004007fu, + 0x00000009u, 0x00000808u, 0x00000807u, 0x00050041u, 0x00000039u, 0x00000809u, 0x0000064eu, 0x0000007du, + 0x0004003du, 0x00000009u, 0x0000080au, 0x00000809u, 0x00050050u, 0x0000009au, 0x0000080bu, 0x00000808u, + 0x0000080au, 0x0003003eu, 0x00000805u, 0x0000080bu, 0x00050041u, 0x00000039u, 0x0000080du, 0x00000650u, + 0x00000008u, 0x0004003du, 0x00000009u, 0x0000080eu, 0x0000080du, 0x0004007fu, 0x00000009u, 0x0000080fu, + 0x0000080eu, 0x00050041u, 0x00000039u, 0x00000810u, 0x00000650u, 0x0000007du, 0x0004003du, 0x00000009u, + 0x00000811u, 0x00000810u, 0x00050050u, 0x0000009au, 0x00000812u, 0x0000080fu, 0x00000811u, 0x0003003eu, + 0x0000080cu, 0x00000812u, 0x0004003du, 0x0000009au, 0x00000814u, 0x00000805u, 0x0004003du, 0x0000009au, + 0x00000815u, 0x0000080cu, 0x00050081u, 0x0000009au, 0x00000816u, 0x00000814u, 0x00000815u, 0x0003003eu, + 0x00000813u, 0x00000816u, 0x0004003du, 0x0000009au, 0x00000818u, 0x00000813u, 0x0006000cu, 0x00000009u, + 0x00000819u, 0x00000001u, 0x00000042u, 0x00000818u, 0x0003003eu, 0x00000817u, 0x00000819u, 0x0004003du, + 0x00000009u, 0x0000081au, 0x00000817u, 0x000500bau, 0x00000011u, 0x0000081bu, 0x0000081au, 0x00000073u, + 0x000300f7u, 0x0000081du, 0x00000000u, 0x000400fau, 0x0000081bu, 0x0000081cu, 0x00000830u, 0x000200f8u, + 0x0000081cu, 0x0004003du, 0x0000009au, 0x0000081fu, 0x00000813u, 0x0004003du, 0x00000009u, 0x00000820u, + 0x00000817u, 0x00050050u, 0x0000009au, 0x00000821u, 0x00000820u, 0x00000820u, 0x00050088u, 0x0000009au, + 0x00000822u, 0x0000081fu, 0x00000821u, 0x0003003eu, 0x0000081eu, 0x00000822u, 0x0004003du, 0x0000009au, + 0x00000824u, 0x0000081eu, 0x0004003du, 0x0000009au, 0x00000825u, 0x0000080cu, 0x00050094u, 0x00000009u, + 0x00000826u, 0x00000824u, 0x00000825u, 0x0003003eu, 0x00000823u, 0x00000826u, 0x0004003du, 0x00000009u, + 0x00000827u, 0x00000823u, 0x000500bau, 0x00000011u, 0x00000828u, 0x00000827u, 0x00000033u, 0x000300f7u, + 0x0000082bu, 0x00000000u, 0x000400fau, 0x00000828u, 0x0000082au, 0x0000082eu, 0x000200f8u, 0x0000082au, + 0x0004003du, 0x00000009u, 0x0000082cu, 0x00000823u, 0x00050088u, 0x00000009u, 0x0000082du, 0x00000037u, + 0x0000082cu, 0x0003003eu, 0x00000829u, 0x0000082du, 0x000200f9u, 0x0000082bu, 0x000200f8u, 0x0000082eu, + 0x0003003eu, 0x00000829u, 0x00000122u, 0x000200f9u, 0x0000082bu, 0x000200f8u, 0x0000082bu, 0x0004003du, + 0x00000009u, 0x0000082fu, 0x00000829u, 0x0003003eu, 0x000007f3u, 0x0000082fu, 0x000200f9u, 0x0000081du, + 0x000200f8u, 0x00000830u, 0x0004003du, 0x0000009au, 0x00000831u, 0x0000080cu, 0x0003003eu, 0x0000081eu, + 0x00000831u, 0x000200f9u, 0x0000081du, 0x000200f8u, 0x0000081du, 0x000200f9u, 0x00000804u, 0x000200f8u, + 0x00000832u, 0x0004003du, 0x00000011u, 0x00000833u, 0x00000654u, 0x000300f7u, 0x00000835u, 0x00000000u, + 0x000400fau, 0x00000833u, 0x00000834u, 0x00000835u, 0x000200f8u, 0x00000834u, 0x0004003du, 0x0000009au, + 0x00000836u, 0x00000650u, 0x0006000cu, 0x00000009u, 0x00000837u, 0x00000001u, 0x00000042u, 0x00000836u, + 0x000500bau, 0x00000011u, 0x00000838u, 0x00000837u, 0x00000073u, 0x000200f9u, 0x00000835u, 0x000200f8u, + 0x00000835u, 0x000700f5u, 0x00000011u, 0x00000839u, 0x00000833u, 0x00000832u, 0x00000838u, 0x00000834u, + 0x000300f7u, 0x0000083bu, 0x00000000u, 0x000400fau, 0x00000839u, 0x0000083au, 0x00000842u, 0x000200f8u, + 0x0000083au, 0x00050041u, 0x00000039u, 0x0000083cu, 0x00000650u, 0x00000008u, 0x0004003du, 0x00000009u, + 0x0000083du, 0x0000083cu, 0x0004007fu, 0x00000009u, 0x0000083eu, 0x0000083du, 0x00050041u, 0x00000039u, + 0x0000083fu, 0x00000650u, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000840u, 0x0000083fu, 0x00050050u, + 0x0000009au, 0x00000841u, 0x0000083eu, 0x00000840u, 0x0003003eu, 0x0000081eu, 0x00000841u, 0x000200f9u, + 0x0000083bu, 0x000200f8u, 0x00000842u, 0x0004003du, 0x00000011u, 0x00000843u, 0x00000651u, 0x000300f7u, + 0x00000845u, 0x00000000u, 0x000400fau, 0x00000843u, 0x00000844u, 0x00000845u, 0x000200f8u, 0x00000844u, + 0x0004003du, 0x0000009au, 0x00000846u, 0x0000064eu, 0x0006000cu, 0x00000009u, 0x00000847u, 0x00000001u, + 0x00000042u, 0x00000846u, 0x000500bau, 0x00000011u, 0x00000848u, 0x00000847u, 0x00000073u, 0x000200f9u, + 0x00000845u, 0x000200f8u, 0x00000845u, 0x000700f5u, 0x00000011u, 0x00000849u, 0x00000843u, 0x00000842u, + 0x00000848u, 0x00000844u, 0x000300f7u, 0x0000084bu, 0x00000000u, 0x000400fau, 0x00000849u, 0x0000084au, + 0x00000852u, 0x000200f8u, 0x0000084au, 0x00050041u, 0x00000039u, 0x0000084cu, 0x0000064eu, 0x00000008u, + 0x0004003du, 0x00000009u, 0x0000084du, 0x0000084cu, 0x0004007fu, 0x00000009u, 0x0000084eu, 0x0000084du, + 0x00050041u, 0x00000039u, 0x0000084fu, 0x0000064eu, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000850u, + 0x0000084fu, 0x00050050u, 0x0000009au, 0x00000851u, 0x0000084eu, 0x00000850u, 0x0003003eu, 0x0000081eu, + 0x00000851u, 0x000200f9u, 0x0000084bu, 0x000200f8u, 0x00000852u, 0x0003003eu, 0x0000081eu, 0x00000853u, + 0x000200f9u, 0x0000084bu, 0x000200f8u, 0x0000084bu, 0x000200f9u, 0x0000083bu, 0x000200f8u, 0x0000083bu, + 0x000200f9u, 0x00000804u, 0x000200f8u, 0x00000804u, 0x0004003du, 0x0000000au, 0x00000856u, 0x00000645u, + 0x0003003eu, 0x00000855u, 0x00000856u, 0x00050039u, 0x00000009u, 0x00000857u, 0x0000000eu, 0x00000855u, + 0x0003003eu, 0x00000854u, 0x00000857u, 0x0004003du, 0x00000009u, 0x00000859u, 0x000004abu, 0x0004003du, + 0x00000009u, 0x0000085au, 0x00000854u, 0x00050085u, 0x00000009u, 0x0000085bu, 0x00000859u, 0x0000085au, + 0x0003003eu, 0x00000858u, 0x0000085bu, 0x00050041u, 0x00000039u, 0x0000085du, 0x0000081eu, 0x0000007du, + 0x0004003du, 0x00000009u, 0x0000085eu, 0x0000085du, 0x0004003du, 0x00000009u, 0x0000085fu, 0x00000858u, + 0x00050085u, 0x00000009u, 0x00000860u, 0x0000085eu, 0x0000085fu, 0x0004003du, 0x00000009u, 0x00000861u, + 0x000007f3u, 0x00050085u, 0x00000009u, 0x00000862u, 0x00000860u, 0x00000861u, 0x00050085u, 0x00000009u, + 0x00000863u, 0x00000862u, 0x00000122u, 0x00050041u, 0x00000039u, 0x00000864u, 0x00000348u, 0x00000082u, + 0x0004003du, 0x00000009u, 0x00000865u, 0x00000864u, 0x00050088u, 0x00000009u, 0x00000866u, 0x00000863u, + 0x00000865u, 0x00050041u, 0x00000039u, 0x00000867u, 0x00000645u, 0x0000003eu, 0x0004003du, 0x00000009u, + 0x00000868u, 0x00000867u, 0x00050085u, 0x00000009u, 0x00000869u, 0x00000866u, 0x00000868u, 0x0003003eu, + 0x0000085cu, 0x00000869u, 0x00050041u, 0x00000039u, 0x0000086bu, 0x0000081eu, 0x00000008u, 0x0004003du, + 0x00000009u, 0x0000086cu, 0x0000086bu, 0x0004007fu, 0x00000009u, 0x0000086du, 0x0000086cu, 0x0004003du, + 0x00000009u, 0x0000086eu, 0x00000858u, 0x00050085u, 0x00000009u, 0x0000086fu, 0x0000086du, 0x0000086eu, + 0x0004003du, 0x00000009u, 0x00000870u, 0x000007f3u, 0x00050085u, 0x00000009u, 0x00000871u, 0x0000086fu, + 0x00000870u, 0x00050085u, 0x00000009u, 0x00000872u, 0x00000871u, 0x00000122u, 0x00050041u, 0x00000039u, + 0x00000873u, 0x00000348u, 0x0000008du, 0x0004003du, 0x00000009u, 0x00000874u, 0x00000873u, 0x00050088u, + 0x00000009u, 0x00000875u, 0x00000872u, 0x00000874u, 0x00050041u, 0x00000039u, 0x00000876u, 0x00000645u, + 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000877u, 0x00000876u, 0x00050085u, 0x00000009u, 0x00000878u, + 0x00000875u, 0x00000877u, 0x0003003eu, 0x0000086au, 0x00000878u, 0x0004003du, 0x00000006u, 0x0000087au, + 0x0000063bu, 0x00050084u, 0x00000006u, 0x0000087bu, 0x0000087au, 0x0000003bu, 0x0003003eu, 0x00000879u, + 0x0000087bu, 0x0004003du, 0x00000006u, 0x0000087cu, 0x00000879u, 0x00050041u, 0x00000039u, 0x0000087du, + 0x00000645u, 0x0000007du, 0x0004003du, 0x00000009u, 0x0000087eu, 0x0000087du, 0x0004003du, 0x00000009u, + 0x0000087fu, 0x0000085cu, 0x00050083u, 0x00000009u, 0x00000880u, 0x0000087eu, 0x0000087fu, 0x00050041u, + 0x00000039u, 0x00000881u, 0x00000645u, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000882u, 0x00000881u, + 0x0004003du, 0x00000009u, 0x00000883u, 0x0000086au, 0x00050083u, 0x00000009u, 0x00000884u, 0x00000882u, + 0x00000883u, 0x00050041u, 0x00000039u, 0x00000885u, 0x00000645u, 0x0000003bu, 0x0004003du, 0x00000009u, + 0x00000886u, 0x00000885u, 0x00050041u, 0x00000039u, 0x00000887u, 0x00000645u, 0x0000003eu, 0x0004003du, + 0x00000009u, 0x00000888u, 0x00000887u, 0x00070050u, 0x0000000au, 0x00000889u, 0x00000880u, 0x00000884u, + 0x00000886u, 0x00000888u, 0x00060041u, 0x00000403u, 0x0000088au, 0x00000400u, 0x0000087cu, 0x00000054u, + 0x0003003eu, 0x0000088au, 0x00000889u, 0x0004003du, 0x00000006u, 0x0000088bu, 0x00000879u, 0x00050080u, + 0x00000006u, 0x0000088cu, 0x0000088bu, 0x00000008u, 0x00050041u, 0x00000039u, 0x0000088du, 0x00000645u, + 0x0000007du, 0x0004003du, 0x00000009u, 0x0000088eu, 0x0000088du, 0x0004003du, 0x00000009u, 0x0000088fu, + 0x0000085cu, 0x00050081u, 0x00000009u, 0x00000890u, 0x0000088eu, 0x0000088fu, 0x00050041u, 0x00000039u, + 0x00000891u, 0x00000645u, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000892u, 0x00000891u, 0x0004003du, + 0x00000009u, 0x00000893u, 0x0000086au, 0x00050081u, 0x00000009u, 0x00000894u, 0x00000892u, 0x00000893u, + 0x00050041u, 0x00000039u, 0x00000895u, 0x00000645u, 0x0000003bu, 0x0004003du, 0x00000009u, 0x00000896u, + 0x00000895u, 0x00050041u, 0x00000039u, 0x00000897u, 0x00000645u, 0x0000003eu, 0x0004003du, 0x00000009u, + 0x00000898u, 0x00000897u, 0x00070050u, 0x0000000au, 0x00000899u, 0x00000890u, 0x00000894u, 0x00000896u, + 0x00000898u, 0x00060041u, 0x00000403u, 0x0000089au, 0x00000400u, 0x0000088cu, 0x00000054u, 0x0003003eu, + 0x0000089au, 0x00000899u, 0x000200f9u, 0x00000640u, 0x000200f8u, 0x00000640u, 0x0004003du, 0x00000006u, + 0x0000089bu, 0x0000063bu, 0x00050080u, 0x00000006u, 0x0000089cu, 0x0000089bu, 0x00000007u, 0x0003003eu, + 0x0000063bu, 0x0000089cu, 0x000200f9u, 0x0000063du, 0x000200f8u, 0x0000063fu, 0x0004003du, 0x00000006u, + 0x0000089du, 0x0000030du, 0x000500aau, 0x00000011u, 0x0000089eu, 0x0000089du, 0x0000007du, 0x000300f7u, + 0x000008a0u, 0x00000000u, 0x000400fau, 0x0000089eu, 0x0000089fu, 0x000008a0u, 0x000200f8u, 0x0000089fu, + 0x0004003du, 0x00000011u, 0x000008a1u, 0x00000615u, 0x0004003du, 0x00000006u, 0x000008a2u, 0x000005c1u, + 0x000500aeu, 0x00000011u, 0x000008a3u, 0x000008a2u, 0x0000003bu, 0x000500a7u, 0x00000011u, 0x000008a4u, + 0x000008a1u, 0x000008a3u, 0x000300f7u, 0x000008a6u, 0x00000000u, 0x000400fau, 0x000008a4u, 0x000008a5u, + 0x000008a6u, 0x000200f8u, 0x000008a5u, 0x00050041u, 0x000005edu, 0x000008a8u, 0x000005b4u, 0x00000054u, + 0x0004003du, 0x0000000au, 0x000008a9u, 0x000008a8u, 0x0003003eu, 0x000008a7u, 0x000008a9u, 0x00050041u, + 0x0000060eu, 0x000008abu, 0x000005f9u, 0x00000054u, 0x0004003du, 0x0000009au, 0x000008acu, 0x000008abu, + 0x0003003eu, 0x000008aau, 0x000008acu, 0x00050041u, 0x0000060eu, 0x000008aeu, 0x000005f9u, 0x0000011cu, + 0x0004003du, 0x0000009au, 0x000008afu, 0x000008aeu, 0x0003003eu, 0x000008adu, 0x000008afu, 0x0004003du, + 0x0000009au, 0x000008b1u, 0x000008adu, 0x0004003du, 0x0000009au, 0x000008b2u, 0x000008aau, 0x00050083u, + 0x0000009au, 0x000008b3u, 0x000008b1u, 0x000008b2u, 0x0006000cu, 0x0000009au, 0x000008b4u, 0x00000001u, + 0x00000045u, 0x000008b3u, 0x0003003eu, 0x000008b0u, 0x000008b4u, 0x00050041u, 0x00000039u, 0x000008b6u, + 0x000008b0u, 0x00000008u, 0x0004003du, 0x00000009u, 0x000008b7u, 0x000008b6u, 0x0004007fu, 0x00000009u, + 0x000008b8u, 0x000008b7u, 0x00050041u, 0x00000039u, 0x000008b9u, 0x000008b0u, 0x0000007du, 0x0004003du, + 0x00000009u, 0x000008bau, 0x000008b9u, 0x00050050u, 0x0000009au, 0x000008bbu, 0x000008b8u, 0x000008bau, + 0x0003003eu, 0x000008b5u, 0x000008bbu, 0x0004003du, 0x00000006u, 0x000008bcu, 0x00000626u, 0x0004003du, + 0x0000000au, 0x000008bdu, 0x000008a7u, 0x00060041u, 0x00000403u, 0x000008beu, 0x00000400u, 0x000008bcu, + 0x00000054u, 0x0003003eu, 0x000008beu, 0x000008bdu, 0x0003003eu, 0x000008c1u, 0x000008c5u, 0x0004003du, + 0x0000000au, 0x000008c8u, 0x000008a7u, 0x0003003eu, 0x000008c7u, 0x000008c8u, 0x00050039u, 0x00000009u, + 0x000008c9u, 0x0000000eu, 0x000008c7u, 0x0003003eu, 0x000008c6u, 0x000008c9u, 0x0004003du, 0x00000009u, + 0x000008cbu, 0x000004abu, 0x0004003du, 0x00000009u, 0x000008ccu, 0x000008c6u, 0x00050085u, 0x00000009u, + 0x000008cdu, 0x000008cbu, 0x000008ccu, 0x0003003eu, 0x000008cau, 0x000008cdu, 0x0003003eu, 0x000008ceu, + 0x00000054u, 0x000200f9u, 0x000008cfu, 0x000200f8u, 0x000008cfu, 0x000400f6u, 0x000008d1u, 0x000008d2u, + 0x00000000u, 0x000200f9u, 0x000008d3u, 0x000200f8u, 0x000008d3u, 0x0004003du, 0x0000002bu, 0x000008d4u, + 0x000008ceu, 0x000500b1u, 0x00000011u, 0x000008d5u, 0x000008d4u, 0x0000008du, 0x000400fau, 0x000008d5u, + 0x000008d0u, 0x000008d1u, 0x000200f8u, 0x000008d0u, 0x0004003du, 0x0000002bu, 0x000008d7u, 0x000008ceu, + 0x00050041u, 0x00000039u, 0x000008d8u, 0x000008c1u, 0x000008d7u, 0x0004003du, 0x00000009u, 0x000008d9u, + 0x000008d8u, 0x0003003eu, 0x000008d6u, 0x000008d9u, 0x0004003du, 0x00000009u, 0x000008dbu, 0x000008d6u, + 0x0006000cu, 0x00000009u, 0x000008dcu, 0x00000001u, 0x0000000eu, 0x000008dbu, 0x0004003du, 0x0000009au, + 0x000008ddu, 0x000008b5u, 0x0005008eu, 0x0000009au, 0x000008deu, 0x000008ddu, 0x000008dcu, 0x0004003du, + 0x00000009u, 0x000008dfu, 0x000008d6u, 0x0006000cu, 0x00000009u, 0x000008e0u, 0x00000001u, 0x0000000du, + 0x000008dfu, 0x0004003du, 0x0000009au, 0x000008e1u, 0x000008b0u, 0x0004007fu, 0x0000009au, 0x000008e2u, + 0x000008e1u, 0x0005008eu, 0x0000009au, 0x000008e3u, 0x000008e2u, 0x000008e0u, 0x00050081u, 0x0000009au, + 0x000008e4u, 0x000008deu, 0x000008e3u, 0x0003003eu, 0x000008dau, 0x000008e4u, 0x00050041u, 0x00000039u, + 0x000008e6u, 0x000008dau, 0x0000007du, 0x0004003du, 0x00000009u, 0x000008e7u, 0x000008e6u, 0x0004003du, + 0x00000009u, 0x000008e8u, 0x000008cau, 0x00050085u, 0x00000009u, 0x000008e9u, 0x000008e7u, 0x000008e8u, + 0x00050085u, 0x00000009u, 0x000008eau, 0x000008e9u, 0x00000122u, 0x00050041u, 0x00000039u, 0x000008ebu, + 0x00000348u, 0x00000082u, 0x0004003du, 0x00000009u, 0x000008ecu, 0x000008ebu, 0x00050088u, 0x00000009u, + 0x000008edu, 0x000008eau, 0x000008ecu, 0x00050041u, 0x00000039u, 0x000008eeu, 0x000008a7u, 0x0000003eu, + 0x0004003du, 0x00000009u, 0x000008efu, 0x000008eeu, 0x00050085u, 0x00000009u, 0x000008f0u, 0x000008edu, + 0x000008efu, 0x0003003eu, 0x000008e5u, 0x000008f0u, 0x00050041u, 0x00000039u, 0x000008f2u, 0x000008dau, + 0x00000008u, 0x0004003du, 0x00000009u, 0x000008f3u, 0x000008f2u, 0x0004007fu, 0x00000009u, 0x000008f4u, + 0x000008f3u, 0x0004003du, 0x00000009u, 0x000008f5u, 0x000008cau, 0x00050085u, 0x00000009u, 0x000008f6u, + 0x000008f4u, 0x000008f5u, 0x00050085u, 0x00000009u, 0x000008f7u, 0x000008f6u, 0x00000122u, 0x00050041u, + 0x00000039u, 0x000008f8u, 0x00000348u, 0x0000008du, 0x0004003du, 0x00000009u, 0x000008f9u, 0x000008f8u, + 0x00050088u, 0x00000009u, 0x000008fau, 0x000008f7u, 0x000008f9u, 0x00050041u, 0x00000039u, 0x000008fbu, + 0x000008a7u, 0x0000003eu, 0x0004003du, 0x00000009u, 0x000008fcu, 0x000008fbu, 0x00050085u, 0x00000009u, + 0x000008fdu, 0x000008fau, 0x000008fcu, 0x0003003eu, 0x000008f1u, 0x000008fdu, 0x0004003du, 0x00000006u, + 0x000008feu, 0x00000626u, 0x00050080u, 0x00000006u, 0x000008ffu, 0x000008feu, 0x00000008u, 0x0004003du, + 0x0000002bu, 0x00000900u, 0x000008ceu, 0x0004007cu, 0x00000006u, 0x00000901u, 0x00000900u, 0x00050080u, + 0x00000006u, 0x00000902u, 0x000008ffu, 0x00000901u, 0x00050041u, 0x00000039u, 0x00000903u, 0x000008a7u, + 0x0000007du, 0x0004003du, 0x00000009u, 0x00000904u, 0x00000903u, 0x0004003du, 0x00000009u, 0x00000905u, + 0x000008e5u, 0x00050081u, 0x00000009u, 0x00000906u, 0x00000904u, 0x00000905u, 0x00050041u, 0x00000039u, + 0x00000907u, 0x000008a7u, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000908u, 0x00000907u, 0x0004003du, + 0x00000009u, 0x00000909u, 0x000008f1u, 0x00050081u, 0x00000009u, 0x0000090au, 0x00000908u, 0x00000909u, + 0x00050041u, 0x00000039u, 0x0000090bu, 0x000008a7u, 0x0000003bu, 0x0004003du, 0x00000009u, 0x0000090cu, + 0x0000090bu, 0x00050041u, 0x00000039u, 0x0000090du, 0x000008a7u, 0x0000003eu, 0x0004003du, 0x00000009u, + 0x0000090eu, 0x0000090du, 0x00070050u, 0x0000000au, 0x0000090fu, 0x00000906u, 0x0000090au, 0x0000090cu, + 0x0000090eu, 0x00060041u, 0x00000403u, 0x00000910u, 0x00000400u, 0x00000902u, 0x00000054u, 0x0003003eu, + 0x00000910u, 0x0000090fu, 0x000200f9u, 0x000008d2u, 0x000200f8u, 0x000008d2u, 0x0004003du, 0x0000002bu, + 0x00000911u, 0x000008ceu, 0x00050080u, 0x0000002bu, 0x00000912u, 0x00000911u, 0x0000011cu, 0x0003003eu, + 0x000008ceu, 0x00000912u, 0x000200f9u, 0x000008cfu, 0x000200f8u, 0x000008d1u, 0x000200f9u, 0x000008a6u, + 0x000200f8u, 0x000008a6u, 0x0004003du, 0x00000011u, 0x00000913u, 0x00000616u, 0x0004003du, 0x00000006u, + 0x00000914u, 0x000005c1u, 0x000500aeu, 0x00000011u, 0x00000915u, 0x00000914u, 0x0000003bu, 0x000500a7u, + 0x00000011u, 0x00000916u, 0x00000913u, 0x00000915u, 0x000300f7u, 0x00000918u, 0x00000000u, 0x000400fau, + 0x00000916u, 0x00000917u, 0x00000918u, 0x000200f8u, 0x00000917u, 0x0004003du, 0x00000006u, 0x0000091au, + 0x000005c1u, 0x00050082u, 0x00000006u, 0x0000091bu, 0x0000091au, 0x00000008u, 0x0003003eu, 0x00000919u, + 0x0000091bu, 0x0004003du, 0x00000006u, 0x0000091du, 0x00000919u, 0x00050041u, 0x000005edu, 0x0000091eu, + 0x000005b4u, 0x0000091du, 0x0004003du, 0x0000000au, 0x0000091fu, 0x0000091eu, 0x0003003eu, 0x0000091cu, + 0x0000091fu, 0x0004003du, 0x00000006u, 0x00000921u, 0x00000919u, 0x00050041u, 0x0000060eu, 0x00000922u, + 0x000005f9u, 0x00000921u, 0x0004003du, 0x0000009au, 0x00000923u, 0x00000922u, 0x0003003eu, 0x00000920u, + 0x00000923u, 0x0004003du, 0x00000006u, 0x00000925u, 0x00000919u, 0x00050082u, 0x00000006u, 0x00000926u, + 0x00000925u, 0x00000008u, 0x00050041u, 0x0000060eu, 0x00000927u, 0x000005f9u, 0x00000926u, 0x0004003du, + 0x0000009au, 0x00000928u, 0x00000927u, 0x0003003eu, 0x00000924u, 0x00000928u, 0x0004003du, 0x0000009au, + 0x0000092au, 0x00000920u, 0x0004003du, 0x0000009au, 0x0000092bu, 0x00000924u, 0x00050083u, 0x0000009au, + 0x0000092cu, 0x0000092au, 0x0000092bu, 0x0006000cu, 0x0000009au, 0x0000092du, 0x00000001u, 0x00000045u, + 0x0000092cu, 0x0003003eu, 0x00000929u, 0x0000092du, 0x00050041u, 0x00000039u, 0x0000092fu, 0x00000929u, + 0x00000008u, 0x0004003du, 0x00000009u, 0x00000930u, 0x0000092fu, 0x0004007fu, 0x00000009u, 0x00000931u, + 0x00000930u, 0x00050041u, 0x00000039u, 0x00000932u, 0x00000929u, 0x0000007du, 0x0004003du, 0x00000009u, + 0x00000933u, 0x00000932u, 0x00050050u, 0x0000009au, 0x00000934u, 0x00000931u, 0x00000933u, 0x0003003eu, + 0x0000092eu, 0x00000934u, 0x0004003du, 0x00000006u, 0x00000935u, 0x00000628u, 0x0004003du, 0x0000000au, + 0x00000936u, 0x0000091cu, 0x00060041u, 0x00000403u, 0x00000937u, 0x00000400u, 0x00000935u, 0x00000054u, + 0x0003003eu, 0x00000937u, 0x00000936u, 0x0003003eu, 0x00000938u, 0x000008c5u, 0x0004003du, 0x0000000au, + 0x0000093bu, 0x0000091cu, 0x0003003eu, 0x0000093au, 0x0000093bu, 0x00050039u, 0x00000009u, 0x0000093cu, + 0x0000000eu, 0x0000093au, 0x0003003eu, 0x00000939u, 0x0000093cu, 0x0004003du, 0x00000009u, 0x0000093eu, + 0x000004abu, 0x0004003du, 0x00000009u, 0x0000093fu, 0x00000939u, 0x00050085u, 0x00000009u, 0x00000940u, + 0x0000093eu, 0x0000093fu, 0x0003003eu, 0x0000093du, 0x00000940u, 0x0003003eu, 0x00000941u, 0x00000054u, + 0x000200f9u, 0x00000942u, 0x000200f8u, 0x00000942u, 0x000400f6u, 0x00000944u, 0x00000945u, 0x00000000u, + 0x000200f9u, 0x00000946u, 0x000200f8u, 0x00000946u, 0x0004003du, 0x0000002bu, 0x00000947u, 0x00000941u, + 0x000500b1u, 0x00000011u, 0x00000948u, 0x00000947u, 0x0000008du, 0x000400fau, 0x00000948u, 0x00000943u, + 0x00000944u, 0x000200f8u, 0x00000943u, 0x0004003du, 0x0000002bu, 0x0000094au, 0x00000941u, 0x00050041u, + 0x00000039u, 0x0000094bu, 0x00000938u, 0x0000094au, 0x0004003du, 0x00000009u, 0x0000094cu, 0x0000094bu, + 0x0003003eu, 0x00000949u, 0x0000094cu, 0x0004003du, 0x00000009u, 0x0000094eu, 0x00000949u, 0x0006000cu, + 0x00000009u, 0x0000094fu, 0x00000001u, 0x0000000eu, 0x0000094eu, 0x0004003du, 0x0000009au, 0x00000950u, + 0x0000092eu, 0x0004007fu, 0x0000009au, 0x00000951u, 0x00000950u, 0x0005008eu, 0x0000009au, 0x00000952u, + 0x00000951u, 0x0000094fu, 0x0004003du, 0x00000009u, 0x00000953u, 0x00000949u, 0x0006000cu, 0x00000009u, + 0x00000954u, 0x00000001u, 0x0000000du, 0x00000953u, 0x0004003du, 0x0000009au, 0x00000955u, 0x00000929u, + 0x0005008eu, 0x0000009au, 0x00000956u, 0x00000955u, 0x00000954u, 0x00050081u, 0x0000009au, 0x00000957u, + 0x00000952u, 0x00000956u, 0x0003003eu, 0x0000094du, 0x00000957u, 0x00050041u, 0x00000039u, 0x00000959u, + 0x0000094du, 0x0000007du, 0x0004003du, 0x00000009u, 0x0000095au, 0x00000959u, 0x0004003du, 0x00000009u, + 0x0000095bu, 0x0000093du, 0x00050085u, 0x00000009u, 0x0000095cu, 0x0000095au, 0x0000095bu, 0x00050085u, + 0x00000009u, 0x0000095du, 0x0000095cu, 0x00000122u, 0x00050041u, 0x00000039u, 0x0000095eu, 0x00000348u, + 0x00000082u, 0x0004003du, 0x00000009u, 0x0000095fu, 0x0000095eu, 0x00050088u, 0x00000009u, 0x00000960u, + 0x0000095du, 0x0000095fu, 0x00050041u, 0x00000039u, 0x00000961u, 0x0000091cu, 0x0000003eu, 0x0004003du, + 0x00000009u, 0x00000962u, 0x00000961u, 0x00050085u, 0x00000009u, 0x00000963u, 0x00000960u, 0x00000962u, + 0x0003003eu, 0x00000958u, 0x00000963u, 0x00050041u, 0x00000039u, 0x00000965u, 0x0000094du, 0x00000008u, + 0x0004003du, 0x00000009u, 0x00000966u, 0x00000965u, 0x0004007fu, 0x00000009u, 0x00000967u, 0x00000966u, + 0x0004003du, 0x00000009u, 0x00000968u, 0x0000093du, 0x00050085u, 0x00000009u, 0x00000969u, 0x00000967u, + 0x00000968u, 0x00050085u, 0x00000009u, 0x0000096au, 0x00000969u, 0x00000122u, 0x00050041u, 0x00000039u, + 0x0000096bu, 0x00000348u, 0x0000008du, 0x0004003du, 0x00000009u, 0x0000096cu, 0x0000096bu, 0x00050088u, + 0x00000009u, 0x0000096du, 0x0000096au, 0x0000096cu, 0x00050041u, 0x00000039u, 0x0000096eu, 0x0000091cu, + 0x0000003eu, 0x0004003du, 0x00000009u, 0x0000096fu, 0x0000096eu, 0x00050085u, 0x00000009u, 0x00000970u, + 0x0000096du, 0x0000096fu, 0x0003003eu, 0x00000964u, 0x00000970u, 0x0004003du, 0x00000006u, 0x00000971u, + 0x00000628u, 0x00050080u, 0x00000006u, 0x00000972u, 0x00000971u, 0x00000008u, 0x0004003du, 0x0000002bu, + 0x00000973u, 0x00000941u, 0x0004007cu, 0x00000006u, 0x00000974u, 0x00000973u, 0x00050080u, 0x00000006u, + 0x00000975u, 0x00000972u, 0x00000974u, 0x00050041u, 0x00000039u, 0x00000976u, 0x0000091cu, 0x0000007du, + 0x0004003du, 0x00000009u, 0x00000977u, 0x00000976u, 0x0004003du, 0x00000009u, 0x00000978u, 0x00000958u, + 0x00050081u, 0x00000009u, 0x00000979u, 0x00000977u, 0x00000978u, 0x00050041u, 0x00000039u, 0x0000097au, + 0x0000091cu, 0x00000008u, 0x0004003du, 0x00000009u, 0x0000097bu, 0x0000097au, 0x0004003du, 0x00000009u, + 0x0000097cu, 0x00000964u, 0x00050081u, 0x00000009u, 0x0000097du, 0x0000097bu, 0x0000097cu, 0x00050041u, + 0x00000039u, 0x0000097eu, 0x0000091cu, 0x0000003bu, 0x0004003du, 0x00000009u, 0x0000097fu, 0x0000097eu, + 0x00050041u, 0x00000039u, 0x00000980u, 0x0000091cu, 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000981u, + 0x00000980u, 0x00070050u, 0x0000000au, 0x00000982u, 0x00000979u, 0x0000097du, 0x0000097fu, 0x00000981u, + 0x00060041u, 0x00000403u, 0x00000983u, 0x00000400u, 0x00000975u, 0x00000054u, 0x0003003eu, 0x00000983u, + 0x00000982u, 0x000200f9u, 0x00000945u, 0x000200f8u, 0x00000945u, 0x0004003du, 0x0000002bu, 0x00000984u, + 0x00000941u, 0x00050080u, 0x0000002bu, 0x00000985u, 0x00000984u, 0x0000011cu, 0x0003003eu, 0x00000941u, + 0x00000985u, 0x000200f9u, 0x00000942u, 0x000200f8u, 0x00000944u, 0x000200f9u, 0x00000918u, 0x000200f8u, + 0x00000918u, 0x000200f9u, 0x000008a0u, 0x000200f8u, 0x000008a0u, 0x0004003du, 0x00000006u, 0x00000986u, + 0x0000030du, 0x000500aau, 0x00000011u, 0x00000987u, 0x00000986u, 0x0000007du, 0x000300f7u, 0x00000989u, + 0x00000000u, 0x000400fau, 0x00000987u, 0x00000988u, 0x00000989u, 0x000200f8u, 0x00000988u, 0x0003003eu, + 0x0000098au, 0x0000007du, 0x0003003eu, 0x0000098bu, 0x0000007du, 0x000200f9u, 0x0000098cu, 0x000200f8u, + 0x0000098cu, 0x000400f6u, 0x0000098eu, 0x0000098fu, 0x00000000u, 0x000200f9u, 0x00000990u, 0x000200f8u, + 0x00000990u, 0x0004003du, 0x00000006u, 0x00000991u, 0x0000098bu, 0x0004003du, 0x00000006u, 0x00000992u, + 0x00000612u, 0x000500b0u, 0x00000011u, 0x00000993u, 0x00000991u, 0x00000992u, 0x000400fau, 0x00000993u, + 0x0000098du, 0x0000098eu, 0x000200f8u, 0x0000098du, 0x0004003du, 0x00000006u, 0x00000995u, 0x0000098bu, + 0x00050084u, 0x00000006u, 0x00000996u, 0x00000995u, 0x0000003bu, 0x0003003eu, 0x00000994u, 0x00000996u, + 0x0004003du, 0x00000006u, 0x00000998u, 0x0000098bu, 0x00050084u, 0x00000006u, 0x00000999u, 0x00000998u, + 0x0000003bu, 0x00050080u, 0x00000006u, 0x0000099au, 0x00000999u, 0x00000008u, 0x0003003eu, 0x00000997u, + 0x0000099au, 0x0004003du, 0x00000006u, 0x0000099cu, 0x0000098bu, 0x00050080u, 0x00000006u, 0x0000099du, + 0x0000099cu, 0x00000008u, 0x00050084u, 0x00000006u, 0x0000099eu, 0x0000099du, 0x0000003bu, 0x0003003eu, + 0x0000099bu, 0x0000099eu, 0x0004003du, 0x00000006u, 0x000009a0u, 0x0000098bu, 0x00050080u, 0x00000006u, + 0x000009a1u, 0x000009a0u, 0x00000008u, 0x00050084u, 0x00000006u, 0x000009a2u, 0x000009a1u, 0x0000003bu, + 0x00050080u, 0x00000006u, 0x000009a3u, 0x000009a2u, 0x00000008u, 0x0003003eu, 0x0000099fu, 0x000009a3u, + 0x0004003du, 0x00000006u, 0x000009a4u, 0x0000098au, 0x0004003du, 0x00000006u, 0x000009a5u, 0x00000994u, + 0x0004003du, 0x00000006u, 0x000009a6u, 0x00000997u, 0x0004003du, 0x00000006u, 0x000009a7u, 0x0000099bu, + 0x00060050u, 0x00000307u, 0x000009a8u, 0x000009a5u, 0x000009a6u, 0x000009a7u, 0x00050041u, 0x00000468u, + 0x000009a9u, 0x0000045au, 0x000009a4u, 0x0003003eu, 0x000009a9u, 0x000009a8u, 0x0004003du, 0x00000006u, + 0x000009aau, 0x0000098au, 0x00050080u, 0x00000006u, 0x000009abu, 0x000009aau, 0x0000011cu, 0x0003003eu, + 0x0000098au, 0x000009abu, 0x0004003du, 0x00000006u, 0x000009acu, 0x0000098au, 0x0004003du, 0x00000006u, + 0x000009adu, 0x00000997u, 0x0004003du, 0x00000006u, 0x000009aeu, 0x0000099fu, 0x0004003du, 0x00000006u, + 0x000009afu, 0x0000099bu, 0x00060050u, 0x00000307u, 0x000009b0u, 0x000009adu, 0x000009aeu, 0x000009afu, + 0x00050041u, 0x00000468u, 0x000009b1u, 0x0000045au, 0x000009acu, 0x0003003eu, 0x000009b1u, 0x000009b0u, + 0x0004003du, 0x00000006u, 0x000009b2u, 0x0000098au, 0x00050080u, 0x00000006u, 0x000009b3u, 0x000009b2u, + 0x0000011cu, 0x0003003eu, 0x0000098au, 0x000009b3u, 0x000200f9u, 0x0000098fu, 0x000200f8u, 0x0000098fu, + 0x0004003du, 0x00000006u, 0x000009b4u, 0x0000098bu, 0x00050080u, 0x00000006u, 0x000009b5u, 0x000009b4u, + 0x0000011cu, 0x0003003eu, 0x0000098bu, 0x000009b5u, 0x000200f9u, 0x0000098cu, 0x000200f8u, 0x0000098eu, + 0x0004003du, 0x00000011u, 0x000009b6u, 0x00000615u, 0x000300f7u, 0x000009b8u, 0x00000000u, 0x000400fau, + 0x000009b6u, 0x000009b7u, 0x000009b8u, 0x000200f8u, 0x000009b7u, 0x0004003du, 0x00000006u, 0x000009bau, + 0x00000626u, 0x0003003eu, 0x000009b9u, 0x000009bau, 0x0003003eu, 0x000009bbu, 0x00000008u, 0x0003003eu, + 0x000009bcu, 0x0000007du, 0x0004003du, 0x00000006u, 0x000009beu, 0x00000626u, 0x00050080u, 0x00000006u, + 0x000009bfu, 0x000009beu, 0x00000008u, 0x0003003eu, 0x000009bdu, 0x000009bfu, 0x0004003du, 0x00000006u, + 0x000009c1u, 0x00000626u, 0x00050080u, 0x00000006u, 0x000009c2u, 0x000009c1u, 0x0000003bu, 0x0003003eu, + 0x000009c0u, 0x000009c2u, 0x0004003du, 0x00000006u, 0x000009c4u, 0x00000626u, 0x00050080u, 0x00000006u, + 0x000009c5u, 0x000009c4u, 0x0000003eu, 0x0003003eu, 0x000009c3u, 0x000009c5u, 0x0004003du, 0x00000006u, + 0x000009c6u, 0x0000098au, 0x0004003du, 0x00000006u, 0x000009c7u, 0x000009b9u, 0x0004003du, 0x00000006u, + 0x000009c8u, 0x000009bbu, 0x0004003du, 0x00000006u, 0x000009c9u, 0x000009bdu, 0x00060050u, 0x00000307u, + 0x000009cau, 0x000009c7u, 0x000009c8u, 0x000009c9u, 0x00050041u, 0x00000468u, 0x000009cbu, 0x0000045au, + 0x000009c6u, 0x0003003eu, 0x000009cbu, 0x000009cau, 0x0004003du, 0x00000006u, 0x000009ccu, 0x0000098au, + 0x00050080u, 0x00000006u, 0x000009cdu, 0x000009ccu, 0x0000011cu, 0x0003003eu, 0x0000098au, 0x000009cdu, + 0x0004003du, 0x00000006u, 0x000009ceu, 0x0000098au, 0x0004003du, 0x00000006u, 0x000009cfu, 0x000009b9u, + 0x0004003du, 0x00000006u, 0x000009d0u, 0x000009bdu, 0x0004003du, 0x00000006u, 0x000009d1u, 0x000009c0u, + 0x00060050u, 0x00000307u, 0x000009d2u, 0x000009cfu, 0x000009d0u, 0x000009d1u, 0x00050041u, 0x00000468u, + 0x000009d3u, 0x0000045au, 0x000009ceu, 0x0003003eu, 0x000009d3u, 0x000009d2u, 0x0004003du, 0x00000006u, + 0x000009d4u, 0x0000098au, 0x00050080u, 0x00000006u, 0x000009d5u, 0x000009d4u, 0x0000011cu, 0x0003003eu, + 0x0000098au, 0x000009d5u, 0x0004003du, 0x00000006u, 0x000009d6u, 0x0000098au, 0x0004003du, 0x00000006u, + 0x000009d7u, 0x000009b9u, 0x0004003du, 0x00000006u, 0x000009d8u, 0x000009c0u, 0x0004003du, 0x00000006u, + 0x000009d9u, 0x000009c3u, 0x00060050u, 0x00000307u, 0x000009dau, 0x000009d7u, 0x000009d8u, 0x000009d9u, + 0x00050041u, 0x00000468u, 0x000009dbu, 0x0000045au, 0x000009d6u, 0x0003003eu, 0x000009dbu, 0x000009dau, + 0x0004003du, 0x00000006u, 0x000009dcu, 0x0000098au, 0x00050080u, 0x00000006u, 0x000009ddu, 0x000009dcu, + 0x0000011cu, 0x0003003eu, 0x0000098au, 0x000009ddu, 0x0004003du, 0x00000006u, 0x000009deu, 0x0000098au, + 0x0004003du, 0x00000006u, 0x000009dfu, 0x000009b9u, 0x0004003du, 0x00000006u, 0x000009e0u, 0x000009c3u, + 0x0004003du, 0x00000006u, 0x000009e1u, 0x000009bcu, 0x00060050u, 0x00000307u, 0x000009e2u, 0x000009dfu, + 0x000009e0u, 0x000009e1u, 0x00050041u, 0x00000468u, 0x000009e3u, 0x0000045au, 0x000009deu, 0x0003003eu, + 0x000009e3u, 0x000009e2u, 0x0004003du, 0x00000006u, 0x000009e4u, 0x0000098au, 0x00050080u, 0x00000006u, + 0x000009e5u, 0x000009e4u, 0x0000011cu, 0x0003003eu, 0x0000098au, 0x000009e5u, 0x000200f9u, 0x000009b8u, + 0x000200f8u, 0x000009b8u, 0x0004003du, 0x00000011u, 0x000009e6u, 0x00000616u, 0x000300f7u, 0x000009e8u, + 0x00000000u, 0x000400fau, 0x000009e6u, 0x000009e7u, 0x000009e8u, 0x000200f8u, 0x000009e7u, 0x0004003du, + 0x00000006u, 0x000009eau, 0x000005c1u, 0x00050082u, 0x00000006u, 0x000009ebu, 0x000009eau, 0x00000008u, + 0x0003003eu, 0x000009e9u, 0x000009ebu, 0x0004003du, 0x00000006u, 0x000009edu, 0x00000628u, 0x0003003eu, + 0x000009ecu, 0x000009edu, 0x0004003du, 0x00000006u, 0x000009efu, 0x000009e9u, 0x00050084u, 0x00000006u, + 0x000009f0u, 0x000009efu, 0x0000003bu, 0x0003003eu, 0x000009eeu, 0x000009f0u, 0x0004003du, 0x00000006u, + 0x000009f2u, 0x000009e9u, 0x00050084u, 0x00000006u, 0x000009f3u, 0x000009f2u, 0x0000003bu, 0x00050080u, + 0x00000006u, 0x000009f4u, 0x000009f3u, 0x00000008u, 0x0003003eu, 0x000009f1u, 0x000009f4u, 0x0004003du, + 0x00000006u, 0x000009f6u, 0x00000628u, 0x00050080u, 0x00000006u, 0x000009f7u, 0x000009f6u, 0x00000008u, + 0x0003003eu, 0x000009f5u, 0x000009f7u, 0x0004003du, 0x00000006u, 0x000009f9u, 0x00000628u, 0x00050080u, + 0x00000006u, 0x000009fau, 0x000009f9u, 0x0000003bu, 0x0003003eu, 0x000009f8u, 0x000009fau, 0x0004003du, + 0x00000006u, 0x000009fcu, 0x00000628u, 0x00050080u, 0x00000006u, 0x000009fdu, 0x000009fcu, 0x0000003eu, + 0x0003003eu, 0x000009fbu, 0x000009fdu, 0x0004003du, 0x00000006u, 0x000009feu, 0x0000098au, 0x0004003du, + 0x00000006u, 0x000009ffu, 0x000009ecu, 0x0004003du, 0x00000006u, 0x00000a00u, 0x000009eeu, 0x0004003du, + 0x00000006u, 0x00000a01u, 0x000009f5u, 0x00060050u, 0x00000307u, 0x00000a02u, 0x000009ffu, 0x00000a00u, + 0x00000a01u, 0x00050041u, 0x00000468u, 0x00000a03u, 0x0000045au, 0x000009feu, 0x0003003eu, 0x00000a03u, + 0x00000a02u, 0x0004003du, 0x00000006u, 0x00000a04u, 0x0000098au, 0x00050080u, 0x00000006u, 0x00000a05u, + 0x00000a04u, 0x0000011cu, 0x0003003eu, 0x0000098au, 0x00000a05u, 0x0004003du, 0x00000006u, 0x00000a06u, + 0x0000098au, 0x0004003du, 0x00000006u, 0x00000a07u, 0x000009ecu, 0x0004003du, 0x00000006u, 0x00000a08u, + 0x000009f5u, 0x0004003du, 0x00000006u, 0x00000a09u, 0x000009f8u, 0x00060050u, 0x00000307u, 0x00000a0au, + 0x00000a07u, 0x00000a08u, 0x00000a09u, 0x00050041u, 0x00000468u, 0x00000a0bu, 0x0000045au, 0x00000a06u, + 0x0003003eu, 0x00000a0bu, 0x00000a0au, 0x0004003du, 0x00000006u, 0x00000a0cu, 0x0000098au, 0x00050080u, + 0x00000006u, 0x00000a0du, 0x00000a0cu, 0x0000011cu, 0x0003003eu, 0x0000098au, 0x00000a0du, 0x0004003du, + 0x00000006u, 0x00000a0eu, 0x0000098au, 0x0004003du, 0x00000006u, 0x00000a0fu, 0x000009ecu, 0x0004003du, + 0x00000006u, 0x00000a10u, 0x000009f8u, 0x0004003du, 0x00000006u, 0x00000a11u, 0x000009fbu, 0x00060050u, + 0x00000307u, 0x00000a12u, 0x00000a0fu, 0x00000a10u, 0x00000a11u, 0x00050041u, 0x00000468u, 0x00000a13u, + 0x0000045au, 0x00000a0eu, 0x0003003eu, 0x00000a13u, 0x00000a12u, 0x0004003du, 0x00000006u, 0x00000a14u, + 0x0000098au, 0x00050080u, 0x00000006u, 0x00000a15u, 0x00000a14u, 0x0000011cu, 0x0003003eu, 0x0000098au, + 0x00000a15u, 0x0004003du, 0x00000006u, 0x00000a16u, 0x0000098au, 0x0004003du, 0x00000006u, 0x00000a17u, + 0x000009ecu, 0x0004003du, 0x00000006u, 0x00000a18u, 0x000009fbu, 0x0004003du, 0x00000006u, 0x00000a19u, + 0x000009f1u, 0x00060050u, 0x00000307u, 0x00000a1au, 0x00000a17u, 0x00000a18u, 0x00000a19u, 0x00050041u, + 0x00000468u, 0x00000a1bu, 0x0000045au, 0x00000a16u, 0x0003003eu, 0x00000a1bu, 0x00000a1au, 0x0004003du, + 0x00000006u, 0x00000a1cu, 0x0000098au, 0x00050080u, 0x00000006u, 0x00000a1du, 0x00000a1cu, 0x0000011cu, + 0x0003003eu, 0x0000098au, 0x00000a1du, 0x000200f9u, 0x000009e8u, 0x000200f8u, 0x000009e8u, 0x0003003eu, + 0x00000a1eu, 0x0000007du, 0x000200f9u, 0x00000a1fu, 0x000200f8u, 0x00000a1fu, 0x000400f6u, 0x00000a21u, + 0x00000a22u, 0x00000000u, 0x000200f9u, 0x00000a23u, 0x000200f8u, 0x00000a23u, 0x0004003du, 0x00000006u, + 0x00000a24u, 0x00000a1eu, 0x0004003du, 0x00000006u, 0x00000a25u, 0x00000305u, 0x000500b0u, 0x00000011u, + 0x00000a26u, 0x00000a24u, 0x00000a25u, 0x000400fau, 0x00000a26u, 0x00000a20u, 0x00000a21u, 0x000200f8u, + 0x00000a20u, 0x0004003du, 0x00000006u, 0x00000a27u, 0x00000a1eu, 0x00050041u, 0x00000315u, 0x00000a28u, + 0x00000314u, 0x00000054u, 0x0004003du, 0x00000006u, 0x00000a29u, 0x00000a28u, 0x0004007cu, 0x0000002bu, + 0x00000a2au, 0x00000a29u, 0x00060041u, 0x00000474u, 0x00000a2bu, 0x0000046du, 0x00000a27u, 0x00000054u, + 0x0003003eu, 0x00000a2bu, 0x00000a2au, 0x0004003du, 0x00000006u, 0x00000a2cu, 0x00000a1eu, 0x00050041u, + 0x0000047du, 0x00000a2du, 0x00000314u, 0x00000079u, 0x0004003du, 0x00000016u, 0x00000a2eu, 0x00000a2du, + 0x00060041u, 0x00000480u, 0x00000a2fu, 0x00000479u, 0x00000a2cu, 0x00000054u, 0x0003003eu, 0x00000a2fu, + 0x00000a2eu, 0x0004003du, 0x00000006u, 0x00000a30u, 0x00000a1eu, 0x00050041u, 0x0000039cu, 0x00000a31u, + 0x00000314u, 0x000000c6u, 0x0004003du, 0x00000009u, 0x00000a32u, 0x00000a31u, 0x00060041u, 0x00000487u, + 0x00000a33u, 0x00000479u, 0x00000a30u, 0x0000011cu, 0x0003003eu, 0x00000a33u, 0x00000a32u, 0x000200f9u, + 0x00000a22u, 0x000200f8u, 0x00000a22u, 0x0004003du, 0x00000006u, 0x00000a34u, 0x00000a1eu, 0x00050080u, + 0x00000006u, 0x00000a35u, 0x00000a34u, 0x0000011cu, 0x0003003eu, 0x00000a1eu, 0x00000a35u, 0x000200f9u, + 0x00000a1fu, 0x000200f8u, 0x00000a21u, 0x000200f9u, 0x00000989u, 0x000200f8u, 0x00000989u, 0x000100fdu, + 0x00010038u, 0x00050036u, 0x00000009u, 0x0000000eu, 0x00000000u, 0x0000000cu, 0x00030037u, 0x0000000bu, + 0x0000000du, 0x000200f8u, 0x0000000fu, 0x0004003bu, 0x00000039u, 0x0000003au, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000042u, 0x00000007u, 0x00050041u, 0x00000030u, 0x00000031u, 0x0000002eu, 0x0000002fu, + 0x0004003du, 0x00000009u, 0x00000032u, 0x00000031u, 0x000500b8u, 0x00000011u, 0x00000034u, 0x00000032u, + 0x00000033u, 0x000300f7u, 0x00000036u, 0x00000000u, 0x000400fau, 0x00000034u, 0x00000035u, 0x00000036u, + 0x000200f8u, 0x00000035u, 0x000200feu, 0x00000037u, 0x000200f8u, 0x00000036u, 0x00050041u, 0x00000039u, + 0x0000003cu, 0x0000000du, 0x0000003bu, 0x0004003du, 0x00000009u, 0x0000003du, 0x0000003cu, 0x00050041u, + 0x00000039u, 0x0000003fu, 0x0000000du, 0x0000003eu, 0x0004003du, 0x00000009u, 0x00000040u, 0x0000003fu, + 0x00050088u, 0x00000009u, 0x00000041u, 0x0000003du, 0x00000040u, 0x0003003eu, 0x0000003au, 0x00000041u, + 0x0004003du, 0x00000009u, 0x00000043u, 0x0000003au, 0x00050083u, 0x00000009u, 0x00000044u, 0x00000037u, + 0x00000043u, 0x0003003eu, 0x00000042u, 0x00000044u, 0x0004003du, 0x00000009u, 0x00000045u, 0x00000042u, + 0x0008000cu, 0x00000009u, 0x00000047u, 0x00000001u, 0x0000002bu, 0x00000045u, 0x00000046u, 0x00000037u, + 0x000200feu, 0x00000047u, 0x00010038u, 0x00050036u, 0x00000011u, 0x00000014u, 0x00000000u, 0x00000012u, + 0x00030037u, 0x00000010u, 0x00000013u, 0x000200f8u, 0x00000015u, 0x0004003du, 0x00000006u, 0x0000004au, + 0x00000013u, 0x000500aau, 0x00000011u, 0x0000004cu, 0x0000004au, 0x0000004bu, 0x0004003du, 0x00000006u, + 0x0000004du, 0x00000013u, 0x000500aau, 0x00000011u, 0x0000004fu, 0x0000004du, 0x0000004eu, 0x000500a6u, + 0x00000011u, 0x00000050u, 0x0000004cu, 0x0000004fu, 0x000200feu, 0x00000050u, 0x00010038u, 0x00050036u, + 0x0000000au, 0x00000021u, 0x00000000u, 0x0000001du, 0x00030037u, 0x00000017u, 0x0000001eu, 0x00030037u, + 0x0000001au, 0x0000001fu, 0x00030037u, 0x0000001cu, 0x00000020u, 0x000200f8u, 0x00000022u, 0x0004003bu, + 0x00000017u, 0x00000053u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000005eu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000061u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000006bu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000078u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000007cu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000087u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000099u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x0000009eu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000000a5u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000000a8u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000000acu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000000b0u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000000b4u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000000b8u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000000eau, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000000edu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000000f6u, 0x00000007u, 0x0004003bu, + 0x000000f5u, 0x000000fbu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000118u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000121u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000012au, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000138u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000013bu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000146u, 0x00000007u, 0x00050041u, 0x00000023u, 0x00000055u, 0x0000001fu, 0x00000054u, + 0x0004003du, 0x00000018u, 0x00000056u, 0x00000055u, 0x0004003du, 0x00000016u, 0x00000057u, 0x0000001eu, + 0x00050051u, 0x00000009u, 0x00000058u, 0x00000057u, 0x00000000u, 0x00050051u, 0x00000009u, 0x00000059u, + 0x00000057u, 0x00000001u, 0x00050051u, 0x00000009u, 0x0000005au, 0x00000057u, 0x00000002u, 0x00070050u, + 0x0000000au, 0x0000005bu, 0x00000058u, 0x00000059u, 0x0000005au, 0x00000037u, 0x00050091u, 0x0000000au, + 0x0000005cu, 0x00000056u, 0x0000005bu, 0x0008004fu, 0x00000016u, 0x0000005du, 0x0000005cu, 0x0000005cu, + 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000053u, 0x0000005du, 0x00050041u, 0x00000039u, + 0x0000005fu, 0x00000053u, 0x0000003bu, 0x0004003du, 0x00000009u, 0x00000060u, 0x0000005fu, 0x0003003eu, + 0x0000005eu, 0x00000060u, 0x0004003du, 0x00000016u, 0x00000062u, 0x00000053u, 0x0006000cu, 0x00000009u, + 0x00000063u, 0x00000001u, 0x00000042u, 0x00000062u, 0x0003003eu, 0x00000061u, 0x00000063u, 0x0004003du, + 0x00000009u, 0x00000064u, 0x00000061u, 0x000500b8u, 0x00000011u, 0x00000066u, 0x00000064u, 0x00000065u, + 0x000300f7u, 0x00000068u, 0x00000000u, 0x000400fau, 0x00000066u, 0x00000067u, 0x00000068u, 0x000200f8u, + 0x00000067u, 0x000200feu, 0x00000069u, 0x000200f8u, 0x00000068u, 0x0003003eu, 0x0000006bu, 0x0000006cu, + 0x00050041u, 0x00000039u, 0x0000006eu, 0x00000020u, 0x0000006du, 0x0004003du, 0x00000009u, 0x0000006fu, + 0x0000006eu, 0x0004003du, 0x00000009u, 0x00000070u, 0x0000006bu, 0x000500bcu, 0x00000011u, 0x00000071u, + 0x0000006fu, 0x00000070u, 0x0004003du, 0x00000009u, 0x00000072u, 0x0000005eu, 0x000500b8u, 0x00000011u, + 0x00000074u, 0x00000072u, 0x00000073u, 0x000500a7u, 0x00000011u, 0x00000075u, 0x00000071u, 0x00000074u, + 0x000300f7u, 0x00000077u, 0x00000000u, 0x000400fau, 0x00000075u, 0x00000076u, 0x00000077u, 0x000200f8u, + 0x00000076u, 0x00050041u, 0x00000039u, 0x0000007au, 0x00000020u, 0x00000079u, 0x0004003du, 0x00000009u, + 0x0000007bu, 0x0000007au, 0x0003003eu, 0x00000078u, 0x0000007bu, 0x00050041u, 0x00000039u, 0x0000007eu, + 0x00000053u, 0x0000007du, 0x0004003du, 0x00000009u, 0x0000007fu, 0x0000007eu, 0x0004003du, 0x00000009u, + 0x00000080u, 0x00000078u, 0x00050085u, 0x00000009u, 0x00000081u, 0x0000007fu, 0x00000080u, 0x00050041u, + 0x00000039u, 0x00000083u, 0x00000020u, 0x00000082u, 0x0004003du, 0x00000009u, 0x00000084u, 0x00000083u, + 0x00050085u, 0x00000009u, 0x00000085u, 0x00000084u, 0x00000033u, 0x00050088u, 0x00000009u, 0x00000086u, + 0x00000081u, 0x00000085u, 0x0003003eu, 0x0000007cu, 0x00000086u, 0x00050041u, 0x00000039u, 0x00000088u, + 0x00000053u, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000089u, 0x00000088u, 0x0004007fu, 0x00000009u, + 0x0000008au, 0x00000089u, 0x0004003du, 0x00000009u, 0x0000008bu, 0x00000078u, 0x00050085u, 0x00000009u, + 0x0000008cu, 0x0000008au, 0x0000008bu, 0x00050041u, 0x00000039u, 0x0000008eu, 0x00000020u, 0x0000008du, + 0x0004003du, 0x00000009u, 0x0000008fu, 0x0000008eu, 0x00050085u, 0x00000009u, 0x00000090u, 0x0000008fu, + 0x00000033u, 0x00050088u, 0x00000009u, 0x00000091u, 0x0000008cu, 0x00000090u, 0x0003003eu, 0x00000087u, + 0x00000091u, 0x0004003du, 0x00000009u, 0x00000092u, 0x0000007cu, 0x00050085u, 0x00000009u, 0x00000094u, + 0x00000092u, 0x00000093u, 0x0004003du, 0x00000009u, 0x00000095u, 0x00000087u, 0x00050085u, 0x00000009u, + 0x00000096u, 0x00000095u, 0x00000093u, 0x00070050u, 0x0000000au, 0x00000097u, 0x00000094u, 0x00000096u, + 0x00000037u, 0x00000037u, 0x000200feu, 0x00000097u, 0x000200f8u, 0x00000077u, 0x0004003du, 0x00000016u, + 0x0000009bu, 0x00000053u, 0x0007004fu, 0x0000009au, 0x0000009cu, 0x0000009bu, 0x0000009bu, 0x00000000u, + 0x00000001u, 0x0006000cu, 0x00000009u, 0x0000009du, 0x00000001u, 0x00000042u, 0x0000009cu, 0x0003003eu, + 0x00000099u, 0x0000009du, 0x00050041u, 0x00000039u, 0x0000009fu, 0x00000053u, 0x0000003bu, 0x0004003du, + 0x00000009u, 0x000000a0u, 0x0000009fu, 0x0004003du, 0x00000009u, 0x000000a1u, 0x00000061u, 0x00050088u, + 0x00000009u, 0x000000a2u, 0x000000a0u, 0x000000a1u, 0x0008000cu, 0x00000009u, 0x000000a4u, 0x00000001u, + 0x0000002bu, 0x000000a2u, 0x000000a3u, 0x00000037u, 0x0003003eu, 0x0000009eu, 0x000000a4u, 0x0004003du, + 0x00000009u, 0x000000a6u, 0x0000009eu, 0x0006000cu, 0x00000009u, 0x000000a7u, 0x00000001u, 0x00000011u, + 0x000000a6u, 0x0003003eu, 0x000000a5u, 0x000000a7u, 0x0004003du, 0x00000009u, 0x000000a9u, 0x000000a5u, + 0x0004003du, 0x00000009u, 0x000000aau, 0x000000a5u, 0x00050085u, 0x00000009u, 0x000000abu, 0x000000a9u, + 0x000000aau, 0x0003003eu, 0x000000a8u, 0x000000abu, 0x0004003du, 0x00000009u, 0x000000adu, 0x000000a8u, + 0x0004003du, 0x00000009u, 0x000000aeu, 0x000000a5u, 0x00050085u, 0x00000009u, 0x000000afu, 0x000000adu, + 0x000000aeu, 0x0003003eu, 0x000000acu, 0x000000afu, 0x0004003du, 0x00000009u, 0x000000b1u, 0x000000a8u, + 0x0004003du, 0x00000009u, 0x000000b2u, 0x000000a8u, 0x00050085u, 0x00000009u, 0x000000b3u, 0x000000b1u, + 0x000000b2u, 0x0003003eu, 0x000000b0u, 0x000000b3u, 0x0004003du, 0x00000009u, 0x000000b5u, 0x000000b0u, + 0x0004003du, 0x00000009u, 0x000000b6u, 0x000000a5u, 0x00050085u, 0x00000009u, 0x000000b7u, 0x000000b5u, + 0x000000b6u, 0x0003003eu, 0x000000b4u, 0x000000b7u, 0x00050041u, 0x00000039u, 0x000000bau, 0x00000020u, + 0x000000b9u, 0x0004003du, 0x00000009u, 0x000000bbu, 0x000000bau, 0x00050041u, 0x00000039u, 0x000000bcu, + 0x00000020u, 0x00000079u, 0x0004003du, 0x00000009u, 0x000000bdu, 0x000000bcu, 0x0004003du, 0x00000009u, + 0x000000beu, 0x000000a5u, 0x00050085u, 0x00000009u, 0x000000bfu, 0x000000bdu, 0x000000beu, 0x00050081u, + 0x00000009u, 0x000000c0u, 0x000000bbu, 0x000000bfu, 0x00050041u, 0x00000039u, 0x000000c1u, 0x00000020u, + 0x0000002fu, 0x0004003du, 0x00000009u, 0x000000c2u, 0x000000c1u, 0x0004003du, 0x00000009u, 0x000000c3u, + 0x000000a8u, 0x00050085u, 0x00000009u, 0x000000c4u, 0x000000c2u, 0x000000c3u, 0x00050081u, 0x00000009u, + 0x000000c5u, 0x000000c0u, 0x000000c4u, 0x00050041u, 0x00000039u, 0x000000c7u, 0x00000020u, 0x000000c6u, + 0x0004003du, 0x00000009u, 0x000000c8u, 0x000000c7u, 0x0004003du, 0x00000009u, 0x000000c9u, 0x000000acu, + 0x00050085u, 0x00000009u, 0x000000cau, 0x000000c8u, 0x000000c9u, 0x00050081u, 0x00000009u, 0x000000cbu, + 0x000000c5u, 0x000000cau, 0x00050041u, 0x00000039u, 0x000000cdu, 0x00000020u, 0x000000ccu, 0x0004003du, + 0x00000009u, 0x000000ceu, 0x000000cdu, 0x0004003du, 0x00000009u, 0x000000cfu, 0x000000b0u, 0x00050085u, + 0x00000009u, 0x000000d0u, 0x000000ceu, 0x000000cfu, 0x00050081u, 0x00000009u, 0x000000d1u, 0x000000cbu, + 0x000000d0u, 0x00050041u, 0x00000039u, 0x000000d3u, 0x00000020u, 0x000000d2u, 0x0004003du, 0x00000009u, + 0x000000d4u, 0x000000d3u, 0x0004003du, 0x00000009u, 0x000000d5u, 0x000000b4u, 0x00050085u, 0x00000009u, + 0x000000d6u, 0x000000d4u, 0x000000d5u, 0x00050081u, 0x00000009u, 0x000000d7u, 0x000000d1u, 0x000000d6u, + 0x0003003eu, 0x000000b8u, 0x000000d7u, 0x0004003du, 0x00000009u, 0x000000d8u, 0x000000a5u, 0x00050041u, + 0x00000039u, 0x000000d9u, 0x00000020u, 0x0000006du, 0x0004003du, 0x00000009u, 0x000000dau, 0x000000d9u, + 0x000500bau, 0x00000011u, 0x000000dbu, 0x000000d8u, 0x000000dau, 0x000300f7u, 0x000000ddu, 0x00000000u, + 0x000400fau, 0x000000dbu, 0x000000dcu, 0x000000ddu, 0x000200f8u, 0x000000dcu, 0x00050041u, 0x00000039u, + 0x000000dfu, 0x00000020u, 0x000000deu, 0x0004003du, 0x00000009u, 0x000000e0u, 0x000000dfu, 0x0004003du, + 0x00000009u, 0x000000e1u, 0x000000a5u, 0x00050041u, 0x00000039u, 0x000000e2u, 0x00000020u, 0x0000006du, + 0x0004003du, 0x00000009u, 0x000000e3u, 0x000000e2u, 0x00050083u, 0x00000009u, 0x000000e4u, 0x000000e1u, + 0x000000e3u, 0x00050041u, 0x00000039u, 0x000000e6u, 0x00000020u, 0x000000e5u, 0x0004003du, 0x00000009u, + 0x000000e7u, 0x000000e6u, 0x00050085u, 0x00000009u, 0x000000e8u, 0x000000e4u, 0x000000e7u, 0x00050081u, + 0x00000009u, 0x000000e9u, 0x000000e0u, 0x000000e8u, 0x0003003eu, 0x000000b8u, 0x000000e9u, 0x000200f9u, + 0x000000ddu, 0x000200f8u, 0x000000ddu, 0x0004003du, 0x00000009u, 0x000000ebu, 0x00000099u, 0x000500bau, + 0x00000011u, 0x000000ecu, 0x000000ebu, 0x00000065u, 0x000300f7u, 0x000000efu, 0x00000000u, 0x000400fau, + 0x000000ecu, 0x000000eeu, 0x000000f3u, 0x000200f8u, 0x000000eeu, 0x0004003du, 0x00000009u, 0x000000f0u, + 0x000000b8u, 0x0004003du, 0x00000009u, 0x000000f1u, 0x00000099u, 0x00050088u, 0x00000009u, 0x000000f2u, + 0x000000f0u, 0x000000f1u, 0x0003003eu, 0x000000edu, 0x000000f2u, 0x000200f9u, 0x000000efu, 0x000200f8u, + 0x000000f3u, 0x0003003eu, 0x000000edu, 0x00000046u, 0x000200f9u, 0x000000efu, 0x000200f8u, 0x000000efu, + 0x0004003du, 0x00000009u, 0x000000f4u, 0x000000edu, 0x0003003eu, 0x000000eau, 0x000000f4u, 0x0004003du, + 0x00000009u, 0x000000f7u, 0x000000eau, 0x0004003du, 0x00000016u, 0x000000f8u, 0x00000053u, 0x0007004fu, + 0x0000009au, 0x000000f9u, 0x000000f8u, 0x000000f8u, 0x00000000u, 0x00000001u, 0x0005008eu, 0x0000009au, + 0x000000fau, 0x000000f9u, 0x000000f7u, 0x0003003eu, 0x000000f6u, 0x000000fau, 0x00050041u, 0x00000039u, + 0x000000fdu, 0x00000020u, 0x000000fcu, 0x0004003du, 0x00000009u, 0x000000feu, 0x000000fdu, 0x00050041u, + 0x00000039u, 0x000000ffu, 0x000000f6u, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000100u, 0x000000ffu, + 0x00050085u, 0x00000009u, 0x00000101u, 0x000000feu, 0x00000100u, 0x00050041u, 0x00000039u, 0x00000103u, + 0x00000020u, 0x00000102u, 0x0004003du, 0x00000009u, 0x00000104u, 0x00000103u, 0x00050041u, 0x00000039u, + 0x00000105u, 0x000000f6u, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000106u, 0x00000105u, 0x00050085u, + 0x00000009u, 0x00000107u, 0x00000104u, 0x00000106u, 0x00050081u, 0x00000009u, 0x00000108u, 0x00000101u, + 0x00000107u, 0x00050041u, 0x00000039u, 0x00000109u, 0x000000fbu, 0x0000007du, 0x0003003eu, 0x00000109u, + 0x00000108u, 0x00050041u, 0x00000039u, 0x0000010bu, 0x00000020u, 0x0000010au, 0x0004003du, 0x00000009u, + 0x0000010cu, 0x0000010bu, 0x00050041u, 0x00000039u, 0x0000010du, 0x000000f6u, 0x0000007du, 0x0004003du, + 0x00000009u, 0x0000010eu, 0x0000010du, 0x00050085u, 0x00000009u, 0x0000010fu, 0x0000010cu, 0x0000010eu, + 0x00050041u, 0x00000039u, 0x00000111u, 0x00000020u, 0x00000110u, 0x0004003du, 0x00000009u, 0x00000112u, + 0x00000111u, 0x00050041u, 0x00000039u, 0x00000113u, 0x000000f6u, 0x00000008u, 0x0004003du, 0x00000009u, + 0x00000114u, 0x00000113u, 0x00050085u, 0x00000009u, 0x00000115u, 0x00000112u, 0x00000114u, 0x00050081u, + 0x00000009u, 0x00000116u, 0x0000010fu, 0x00000115u, 0x00050041u, 0x00000039u, 0x00000117u, 0x000000fbu, + 0x00000008u, 0x0003003eu, 0x00000117u, 0x00000116u, 0x0004003du, 0x0000009au, 0x00000119u, 0x000000fbu, + 0x00050041u, 0x00000039u, 0x0000011au, 0x00000020u, 0x00000054u, 0x0004003du, 0x00000009u, 0x0000011bu, + 0x0000011au, 0x00050041u, 0x00000039u, 0x0000011du, 0x00000020u, 0x0000011cu, 0x0004003du, 0x00000009u, + 0x0000011eu, 0x0000011du, 0x00050050u, 0x0000009au, 0x0000011fu, 0x0000011bu, 0x0000011eu, 0x00050081u, + 0x0000009au, 0x00000120u, 0x00000119u, 0x0000011fu, 0x0003003eu, 0x00000118u, 0x00000120u, 0x00050041u, + 0x00000039u, 0x00000123u, 0x00000118u, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000124u, 0x00000123u, + 0x00050085u, 0x00000009u, 0x00000125u, 0x00000122u, 0x00000124u, 0x00050041u, 0x00000039u, 0x00000126u, + 0x00000020u, 0x00000082u, 0x0004003du, 0x00000009u, 0x00000127u, 0x00000126u, 0x00050088u, 0x00000009u, + 0x00000128u, 0x00000125u, 0x00000127u, 0x00050083u, 0x00000009u, 0x00000129u, 0x00000128u, 0x00000037u, + 0x0003003eu, 0x00000121u, 0x00000129u, 0x00050041u, 0x00000039u, 0x0000012bu, 0x00000118u, 0x00000008u, + 0x0004003du, 0x00000009u, 0x0000012cu, 0x0000012bu, 0x00050085u, 0x00000009u, 0x0000012du, 0x00000122u, + 0x0000012cu, 0x00050041u, 0x00000039u, 0x0000012eu, 0x00000020u, 0x0000008du, 0x0004003du, 0x00000009u, + 0x0000012fu, 0x0000012eu, 0x00050088u, 0x00000009u, 0x00000130u, 0x0000012du, 0x0000012fu, 0x00050083u, + 0x00000009u, 0x00000131u, 0x00000037u, 0x00000130u, 0x0003003eu, 0x0000012au, 0x00000131u, 0x00050041u, + 0x00000039u, 0x00000132u, 0x00000020u, 0x0000006du, 0x0004003du, 0x00000009u, 0x00000133u, 0x00000132u, + 0x0004003du, 0x00000009u, 0x00000134u, 0x0000006bu, 0x000500bau, 0x00000011u, 0x00000135u, 0x00000133u, + 0x00000134u, 0x000300f7u, 0x00000137u, 0x00000000u, 0x000400fau, 0x00000135u, 0x00000136u, 0x00000144u, + 0x000200f8u, 0x00000136u, 0x0004003du, 0x00000009u, 0x00000139u, 0x0000005eu, 0x000500beu, 0x00000011u, + 0x0000013au, 0x00000139u, 0x00000046u, 0x000300f7u, 0x0000013du, 0x00000000u, 0x000400fau, 0x0000013au, + 0x0000013cu, 0x0000013fu, 0x000200f8u, 0x0000013cu, 0x0004003du, 0x00000009u, 0x0000013eu, 0x00000061u, + 0x0003003eu, 0x0000013bu, 0x0000013eu, 0x000200f9u, 0x0000013du, 0x000200f8u, 0x0000013fu, 0x00050041u, + 0x00000039u, 0x00000141u, 0x00000020u, 0x00000140u, 0x0004003du, 0x00000009u, 0x00000142u, 0x00000141u, + 0x0003003eu, 0x0000013bu, 0x00000142u, 0x000200f9u, 0x0000013du, 0x000200f8u, 0x0000013du, 0x0004003du, + 0x00000009u, 0x00000143u, 0x0000013bu, 0x0003003eu, 0x00000138u, 0x00000143u, 0x000200f9u, 0x00000137u, + 0x000200f8u, 0x00000144u, 0x0004003du, 0x00000009u, 0x00000145u, 0x0000005eu, 0x0003003eu, 0x00000138u, + 0x00000145u, 0x000200f9u, 0x00000137u, 0x000200f8u, 0x00000137u, 0x0004003du, 0x00000009u, 0x00000147u, + 0x00000138u, 0x00050041u, 0x00000039u, 0x00000148u, 0x00000020u, 0x00000140u, 0x0004003du, 0x00000009u, + 0x00000149u, 0x00000148u, 0x00050088u, 0x00000009u, 0x0000014au, 0x00000147u, 0x00000149u, 0x0008000cu, + 0x00000009u, 0x0000014bu, 0x00000001u, 0x0000002bu, 0x0000014au, 0x00000046u, 0x00000037u, 0x0003003eu, + 0x00000146u, 0x0000014bu, 0x0004003du, 0x00000009u, 0x0000014cu, 0x00000121u, 0x0004003du, 0x00000009u, + 0x0000014du, 0x0000012au, 0x0004003du, 0x00000009u, 0x0000014eu, 0x00000146u, 0x00070050u, 0x0000000au, + 0x0000014fu, 0x0000014cu, 0x0000014du, 0x0000014eu, 0x00000037u, 0x000200feu, 0x0000014fu, 0x00010038u, + 0x00050036u, 0x00000009u, 0x00000029u, 0x00000000u, 0x00000024u, 0x00030037u, 0x00000017u, 0x00000025u, + 0x00030037u, 0x00000017u, 0x00000026u, 0x00030037u, 0x00000023u, 0x00000027u, 0x00030037u, 0x0000001cu, + 0x00000028u, 0x000200f8u, 0x0000002au, 0x0004003bu, 0x00000017u, 0x00000152u, 0x00000007u, 0x0004003bu, + 0x00000017u, 0x0000015bu, 0x00000007u, 0x0004003bu, 0x00000017u, 0x00000164u, 0x00000007u, 0x0004003bu, + 0x00000017u, 0x00000169u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000172u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000176u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000017au, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x0000017eu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000182u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x0000018cu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000191u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000194u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000198u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000001ccu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000001cfu, 0x00000007u, 0x0004003bu, + 0x000000f5u, 0x000001d7u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000001dcu, 0x00000007u, 0x0004003bu, + 0x000000f5u, 0x000001f4u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000001fcu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000200u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000209u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x0000020eu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000211u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000215u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000249u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x0000024cu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000254u, 0x00000007u, 0x0004003bu, + 0x000000f5u, 0x00000259u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x00000271u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000279u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000027du, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x00000286u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000028bu, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x0000028eu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000292u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000002c6u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000002c9u, 0x00000007u, 0x0004003bu, + 0x000000f5u, 0x000002d1u, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000002d6u, 0x00000007u, 0x0004003bu, + 0x000000f5u, 0x000002eeu, 0x00000007u, 0x0004003bu, 0x000000f5u, 0x000002f6u, 0x00000007u, 0x0004003bu, + 0x00000039u, 0x000002fbu, 0x00000007u, 0x0004003du, 0x00000018u, 0x00000153u, 0x00000027u, 0x0004003du, + 0x00000016u, 0x00000154u, 0x00000025u, 0x00050051u, 0x00000009u, 0x00000155u, 0x00000154u, 0x00000000u, + 0x00050051u, 0x00000009u, 0x00000156u, 0x00000154u, 0x00000001u, 0x00050051u, 0x00000009u, 0x00000157u, + 0x00000154u, 0x00000002u, 0x00070050u, 0x0000000au, 0x00000158u, 0x00000155u, 0x00000156u, 0x00000157u, + 0x00000037u, 0x00050091u, 0x0000000au, 0x00000159u, 0x00000153u, 0x00000158u, 0x0008004fu, 0x00000016u, + 0x0000015au, 0x00000159u, 0x00000159u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000152u, + 0x0000015au, 0x0004003du, 0x00000018u, 0x0000015cu, 0x00000027u, 0x0004003du, 0x00000016u, 0x0000015du, + 0x00000026u, 0x00050051u, 0x00000009u, 0x0000015eu, 0x0000015du, 0x00000000u, 0x00050051u, 0x00000009u, + 0x0000015fu, 0x0000015du, 0x00000001u, 0x00050051u, 0x00000009u, 0x00000160u, 0x0000015du, 0x00000002u, + 0x00070050u, 0x0000000au, 0x00000161u, 0x0000015eu, 0x0000015fu, 0x00000160u, 0x00000037u, 0x00050091u, + 0x0000000au, 0x00000162u, 0x0000015cu, 0x00000161u, 0x0008004fu, 0x00000016u, 0x00000163u, 0x00000162u, + 0x00000162u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x0000015bu, 0x00000163u, 0x0004003du, + 0x00000016u, 0x00000165u, 0x00000025u, 0x0004003du, 0x00000016u, 0x00000166u, 0x00000026u, 0x00050081u, + 0x00000016u, 0x00000167u, 0x00000165u, 0x00000166u, 0x0005008eu, 0x00000016u, 0x00000168u, 0x00000167u, + 0x00000033u, 0x0003003eu, 0x00000164u, 0x00000168u, 0x0004003du, 0x00000018u, 0x0000016au, 0x00000027u, + 0x0004003du, 0x00000016u, 0x0000016bu, 0x00000164u, 0x00050051u, 0x00000009u, 0x0000016cu, 0x0000016bu, + 0x00000000u, 0x00050051u, 0x00000009u, 0x0000016du, 0x0000016bu, 0x00000001u, 0x00050051u, 0x00000009u, + 0x0000016eu, 0x0000016bu, 0x00000002u, 0x00070050u, 0x0000000au, 0x0000016fu, 0x0000016cu, 0x0000016du, + 0x0000016eu, 0x00000037u, 0x00050091u, 0x0000000au, 0x00000170u, 0x0000016au, 0x0000016fu, 0x0008004fu, + 0x00000016u, 0x00000171u, 0x00000170u, 0x00000170u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, + 0x00000169u, 0x00000171u, 0x00050041u, 0x00000039u, 0x00000173u, 0x00000152u, 0x0000003bu, 0x0004003du, + 0x00000009u, 0x00000174u, 0x00000173u, 0x0007000cu, 0x00000009u, 0x00000175u, 0x00000001u, 0x00000028u, + 0x00000174u, 0x00000073u, 0x0003003eu, 0x00000172u, 0x00000175u, 0x00050041u, 0x00000039u, 0x00000177u, + 0x0000015bu, 0x0000003bu, 0x0004003du, 0x00000009u, 0x00000178u, 0x00000177u, 0x0007000cu, 0x00000009u, + 0x00000179u, 0x00000001u, 0x00000028u, 0x00000178u, 0x00000073u, 0x0003003eu, 0x00000176u, 0x00000179u, + 0x00050041u, 0x00000039u, 0x0000017bu, 0x00000169u, 0x0000003bu, 0x0004003du, 0x00000009u, 0x0000017cu, + 0x0000017bu, 0x0007000cu, 0x00000009u, 0x0000017du, 0x00000001u, 0x00000028u, 0x0000017cu, 0x00000073u, + 0x0003003eu, 0x0000017au, 0x0000017du, 0x0004003du, 0x00000016u, 0x0000017fu, 0x00000152u, 0x0007004fu, + 0x0000009au, 0x00000180u, 0x0000017fu, 0x0000017fu, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000009u, + 0x00000181u, 0x00000001u, 0x00000042u, 0x00000180u, 0x0003003eu, 0x0000017eu, 0x00000181u, 0x0004003du, + 0x00000016u, 0x00000183u, 0x00000152u, 0x0007004fu, 0x0000009au, 0x00000184u, 0x00000183u, 0x00000183u, + 0x00000000u, 0x00000001u, 0x0004003du, 0x00000009u, 0x00000185u, 0x00000172u, 0x00050051u, 0x00000009u, + 0x00000186u, 0x00000184u, 0x00000000u, 0x00050051u, 0x00000009u, 0x00000187u, 0x00000184u, 0x00000001u, + 0x00060050u, 0x00000016u, 0x00000188u, 0x00000186u, 0x00000187u, 0x00000185u, 0x0006000cu, 0x00000009u, + 0x00000189u, 0x00000001u, 0x00000042u, 0x00000188u, 0x00050081u, 0x00000009u, 0x0000018bu, 0x00000189u, + 0x0000018au, 0x0003003eu, 0x00000182u, 0x0000018bu, 0x0004003du, 0x00000009u, 0x0000018du, 0x00000172u, + 0x0004003du, 0x00000009u, 0x0000018eu, 0x00000182u, 0x00050088u, 0x00000009u, 0x0000018fu, 0x0000018du, + 0x0000018eu, 0x0008000cu, 0x00000009u, 0x00000190u, 0x00000001u, 0x0000002bu, 0x0000018fu, 0x000000a3u, + 0x00000037u, 0x0003003eu, 0x0000018cu, 0x00000190u, 0x0004003du, 0x00000009u, 0x00000192u, 0x0000018cu, + 0x0006000cu, 0x00000009u, 0x00000193u, 0x00000001u, 0x00000011u, 0x00000192u, 0x0003003eu, 0x00000191u, + 0x00000193u, 0x0004003du, 0x00000009u, 0x00000195u, 0x00000191u, 0x0004003du, 0x00000009u, 0x00000196u, + 0x00000191u, 0x00050085u, 0x00000009u, 0x00000197u, 0x00000195u, 0x00000196u, 0x0003003eu, 0x00000194u, + 0x00000197u, 0x00050041u, 0x00000039u, 0x00000199u, 0x00000028u, 0x000000b9u, 0x0004003du, 0x00000009u, + 0x0000019au, 0x00000199u, 0x00050041u, 0x00000039u, 0x0000019bu, 0x00000028u, 0x00000079u, 0x0004003du, + 0x00000009u, 0x0000019cu, 0x0000019bu, 0x0004003du, 0x00000009u, 0x0000019du, 0x00000191u, 0x00050085u, + 0x00000009u, 0x0000019eu, 0x0000019cu, 0x0000019du, 0x00050081u, 0x00000009u, 0x0000019fu, 0x0000019au, + 0x0000019eu, 0x00050041u, 0x00000039u, 0x000001a0u, 0x00000028u, 0x0000002fu, 0x0004003du, 0x00000009u, + 0x000001a1u, 0x000001a0u, 0x0004003du, 0x00000009u, 0x000001a2u, 0x00000194u, 0x00050085u, 0x00000009u, + 0x000001a3u, 0x000001a1u, 0x000001a2u, 0x00050081u, 0x00000009u, 0x000001a4u, 0x0000019fu, 0x000001a3u, + 0x00050041u, 0x00000039u, 0x000001a5u, 0x00000028u, 0x000000c6u, 0x0004003du, 0x00000009u, 0x000001a6u, + 0x000001a5u, 0x0004003du, 0x00000009u, 0x000001a7u, 0x00000194u, 0x0004003du, 0x00000009u, 0x000001a8u, + 0x00000191u, 0x00050085u, 0x00000009u, 0x000001a9u, 0x000001a7u, 0x000001a8u, 0x00050085u, 0x00000009u, + 0x000001aau, 0x000001a6u, 0x000001a9u, 0x00050081u, 0x00000009u, 0x000001abu, 0x000001a4u, 0x000001aau, + 0x00050041u, 0x00000039u, 0x000001acu, 0x00000028u, 0x000000ccu, 0x0004003du, 0x00000009u, 0x000001adu, + 0x000001acu, 0x0004003du, 0x00000009u, 0x000001aeu, 0x00000194u, 0x0004003du, 0x00000009u, 0x000001afu, + 0x00000194u, 0x00050085u, 0x00000009u, 0x000001b0u, 0x000001aeu, 0x000001afu, 0x00050085u, 0x00000009u, + 0x000001b1u, 0x000001adu, 0x000001b0u, 0x00050081u, 0x00000009u, 0x000001b2u, 0x000001abu, 0x000001b1u, + 0x00050041u, 0x00000039u, 0x000001b3u, 0x00000028u, 0x000000d2u, 0x0004003du, 0x00000009u, 0x000001b4u, + 0x000001b3u, 0x0004003du, 0x00000009u, 0x000001b5u, 0x00000194u, 0x0004003du, 0x00000009u, 0x000001b6u, + 0x00000194u, 0x00050085u, 0x00000009u, 0x000001b7u, 0x000001b5u, 0x000001b6u, 0x0004003du, 0x00000009u, + 0x000001b8u, 0x00000191u, 0x00050085u, 0x00000009u, 0x000001b9u, 0x000001b7u, 0x000001b8u, 0x00050085u, + 0x00000009u, 0x000001bau, 0x000001b4u, 0x000001b9u, 0x00050081u, 0x00000009u, 0x000001bbu, 0x000001b2u, + 0x000001bau, 0x0003003eu, 0x00000198u, 0x000001bbu, 0x0004003du, 0x00000009u, 0x000001bcu, 0x00000191u, + 0x00050041u, 0x00000039u, 0x000001bdu, 0x00000028u, 0x0000006du, 0x0004003du, 0x00000009u, 0x000001beu, + 0x000001bdu, 0x000500bau, 0x00000011u, 0x000001bfu, 0x000001bcu, 0x000001beu, 0x000300f7u, 0x000001c1u, + 0x00000000u, 0x000400fau, 0x000001bfu, 0x000001c0u, 0x000001c1u, 0x000200f8u, 0x000001c0u, 0x00050041u, + 0x00000039u, 0x000001c2u, 0x00000028u, 0x000000deu, 0x0004003du, 0x00000009u, 0x000001c3u, 0x000001c2u, + 0x0004003du, 0x00000009u, 0x000001c4u, 0x00000191u, 0x00050041u, 0x00000039u, 0x000001c5u, 0x00000028u, + 0x0000006du, 0x0004003du, 0x00000009u, 0x000001c6u, 0x000001c5u, 0x00050083u, 0x00000009u, 0x000001c7u, + 0x000001c4u, 0x000001c6u, 0x00050041u, 0x00000039u, 0x000001c8u, 0x00000028u, 0x000000e5u, 0x0004003du, + 0x00000009u, 0x000001c9u, 0x000001c8u, 0x00050085u, 0x00000009u, 0x000001cau, 0x000001c7u, 0x000001c9u, + 0x00050081u, 0x00000009u, 0x000001cbu, 0x000001c3u, 0x000001cau, 0x0003003eu, 0x00000198u, 0x000001cbu, + 0x000200f9u, 0x000001c1u, 0x000200f8u, 0x000001c1u, 0x0004003du, 0x00000009u, 0x000001cdu, 0x0000017eu, + 0x000500bau, 0x00000011u, 0x000001ceu, 0x000001cdu, 0x00000065u, 0x000300f7u, 0x000001d1u, 0x00000000u, + 0x000400fau, 0x000001ceu, 0x000001d0u, 0x000001d5u, 0x000200f8u, 0x000001d0u, 0x0004003du, 0x00000009u, + 0x000001d2u, 0x00000198u, 0x0004003du, 0x00000009u, 0x000001d3u, 0x0000017eu, 0x00050088u, 0x00000009u, + 0x000001d4u, 0x000001d2u, 0x000001d3u, 0x0003003eu, 0x000001cfu, 0x000001d4u, 0x000200f9u, 0x000001d1u, + 0x000200f8u, 0x000001d5u, 0x0003003eu, 0x000001cfu, 0x00000046u, 0x000200f9u, 0x000001d1u, 0x000200f8u, + 0x000001d1u, 0x0004003du, 0x00000009u, 0x000001d6u, 0x000001cfu, 0x0003003eu, 0x000001ccu, 0x000001d6u, + 0x0004003du, 0x00000009u, 0x000001d8u, 0x000001ccu, 0x0004003du, 0x00000016u, 0x000001d9u, 0x00000152u, + 0x0007004fu, 0x0000009au, 0x000001dau, 0x000001d9u, 0x000001d9u, 0x00000000u, 0x00000001u, 0x0005008eu, + 0x0000009au, 0x000001dbu, 0x000001dau, 0x000001d8u, 0x0003003eu, 0x000001d7u, 0x000001dbu, 0x00050041u, + 0x00000039u, 0x000001ddu, 0x00000028u, 0x000000fcu, 0x0004003du, 0x00000009u, 0x000001deu, 0x000001ddu, + 0x00050041u, 0x00000039u, 0x000001dfu, 0x000001d7u, 0x0000007du, 0x0004003du, 0x00000009u, 0x000001e0u, + 0x000001dfu, 0x00050085u, 0x00000009u, 0x000001e1u, 0x000001deu, 0x000001e0u, 0x00050041u, 0x00000039u, + 0x000001e2u, 0x00000028u, 0x00000102u, 0x0004003du, 0x00000009u, 0x000001e3u, 0x000001e2u, 0x00050041u, + 0x00000039u, 0x000001e4u, 0x000001d7u, 0x00000008u, 0x0004003du, 0x00000009u, 0x000001e5u, 0x000001e4u, + 0x00050085u, 0x00000009u, 0x000001e6u, 0x000001e3u, 0x000001e5u, 0x00050081u, 0x00000009u, 0x000001e7u, + 0x000001e1u, 0x000001e6u, 0x00050041u, 0x00000039u, 0x000001e8u, 0x00000028u, 0x0000010au, 0x0004003du, + 0x00000009u, 0x000001e9u, 0x000001e8u, 0x00050041u, 0x00000039u, 0x000001eau, 0x000001d7u, 0x0000007du, + 0x0004003du, 0x00000009u, 0x000001ebu, 0x000001eau, 0x00050085u, 0x00000009u, 0x000001ecu, 0x000001e9u, + 0x000001ebu, 0x00050041u, 0x00000039u, 0x000001edu, 0x00000028u, 0x00000110u, 0x0004003du, 0x00000009u, + 0x000001eeu, 0x000001edu, 0x00050041u, 0x00000039u, 0x000001efu, 0x000001d7u, 0x00000008u, 0x0004003du, + 0x00000009u, 0x000001f0u, 0x000001efu, 0x00050085u, 0x00000009u, 0x000001f1u, 0x000001eeu, 0x000001f0u, + 0x00050081u, 0x00000009u, 0x000001f2u, 0x000001ecu, 0x000001f1u, 0x00050050u, 0x0000009au, 0x000001f3u, + 0x000001e7u, 0x000001f2u, 0x0003003eu, 0x000001dcu, 0x000001f3u, 0x0004003du, 0x0000009au, 0x000001f5u, + 0x000001dcu, 0x00050041u, 0x00000039u, 0x000001f6u, 0x00000028u, 0x00000054u, 0x0004003du, 0x00000009u, + 0x000001f7u, 0x000001f6u, 0x00050041u, 0x00000039u, 0x000001f8u, 0x00000028u, 0x0000011cu, 0x0004003du, + 0x00000009u, 0x000001f9u, 0x000001f8u, 0x00050050u, 0x0000009au, 0x000001fau, 0x000001f7u, 0x000001f9u, + 0x00050081u, 0x0000009au, 0x000001fbu, 0x000001f5u, 0x000001fau, 0x0003003eu, 0x000001f4u, 0x000001fbu, + 0x0004003du, 0x00000016u, 0x000001fdu, 0x0000015bu, 0x0007004fu, 0x0000009au, 0x000001feu, 0x000001fdu, + 0x000001fdu, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000009u, 0x000001ffu, 0x00000001u, 0x00000042u, + 0x000001feu, 0x0003003eu, 0x000001fcu, 0x000001ffu, 0x0004003du, 0x00000016u, 0x00000201u, 0x0000015bu, + 0x0007004fu, 0x0000009au, 0x00000202u, 0x00000201u, 0x00000201u, 0x00000000u, 0x00000001u, 0x0004003du, + 0x00000009u, 0x00000203u, 0x00000176u, 0x00050051u, 0x00000009u, 0x00000204u, 0x00000202u, 0x00000000u, + 0x00050051u, 0x00000009u, 0x00000205u, 0x00000202u, 0x00000001u, 0x00060050u, 0x00000016u, 0x00000206u, + 0x00000204u, 0x00000205u, 0x00000203u, 0x0006000cu, 0x00000009u, 0x00000207u, 0x00000001u, 0x00000042u, + 0x00000206u, 0x00050081u, 0x00000009u, 0x00000208u, 0x00000207u, 0x0000018au, 0x0003003eu, 0x00000200u, + 0x00000208u, 0x0004003du, 0x00000009u, 0x0000020au, 0x00000176u, 0x0004003du, 0x00000009u, 0x0000020bu, + 0x00000200u, 0x00050088u, 0x00000009u, 0x0000020cu, 0x0000020au, 0x0000020bu, 0x0008000cu, 0x00000009u, + 0x0000020du, 0x00000001u, 0x0000002bu, 0x0000020cu, 0x000000a3u, 0x00000037u, 0x0003003eu, 0x00000209u, + 0x0000020du, 0x0004003du, 0x00000009u, 0x0000020fu, 0x00000209u, 0x0006000cu, 0x00000009u, 0x00000210u, + 0x00000001u, 0x00000011u, 0x0000020fu, 0x0003003eu, 0x0000020eu, 0x00000210u, 0x0004003du, 0x00000009u, + 0x00000212u, 0x0000020eu, 0x0004003du, 0x00000009u, 0x00000213u, 0x0000020eu, 0x00050085u, 0x00000009u, + 0x00000214u, 0x00000212u, 0x00000213u, 0x0003003eu, 0x00000211u, 0x00000214u, 0x00050041u, 0x00000039u, + 0x00000216u, 0x00000028u, 0x000000b9u, 0x0004003du, 0x00000009u, 0x00000217u, 0x00000216u, 0x00050041u, + 0x00000039u, 0x00000218u, 0x00000028u, 0x00000079u, 0x0004003du, 0x00000009u, 0x00000219u, 0x00000218u, + 0x0004003du, 0x00000009u, 0x0000021au, 0x0000020eu, 0x00050085u, 0x00000009u, 0x0000021bu, 0x00000219u, + 0x0000021au, 0x00050081u, 0x00000009u, 0x0000021cu, 0x00000217u, 0x0000021bu, 0x00050041u, 0x00000039u, + 0x0000021du, 0x00000028u, 0x0000002fu, 0x0004003du, 0x00000009u, 0x0000021eu, 0x0000021du, 0x0004003du, + 0x00000009u, 0x0000021fu, 0x00000211u, 0x00050085u, 0x00000009u, 0x00000220u, 0x0000021eu, 0x0000021fu, + 0x00050081u, 0x00000009u, 0x00000221u, 0x0000021cu, 0x00000220u, 0x00050041u, 0x00000039u, 0x00000222u, + 0x00000028u, 0x000000c6u, 0x0004003du, 0x00000009u, 0x00000223u, 0x00000222u, 0x0004003du, 0x00000009u, + 0x00000224u, 0x00000211u, 0x0004003du, 0x00000009u, 0x00000225u, 0x0000020eu, 0x00050085u, 0x00000009u, + 0x00000226u, 0x00000224u, 0x00000225u, 0x00050085u, 0x00000009u, 0x00000227u, 0x00000223u, 0x00000226u, + 0x00050081u, 0x00000009u, 0x00000228u, 0x00000221u, 0x00000227u, 0x00050041u, 0x00000039u, 0x00000229u, + 0x00000028u, 0x000000ccu, 0x0004003du, 0x00000009u, 0x0000022au, 0x00000229u, 0x0004003du, 0x00000009u, + 0x0000022bu, 0x00000211u, 0x0004003du, 0x00000009u, 0x0000022cu, 0x00000211u, 0x00050085u, 0x00000009u, + 0x0000022du, 0x0000022bu, 0x0000022cu, 0x00050085u, 0x00000009u, 0x0000022eu, 0x0000022au, 0x0000022du, + 0x00050081u, 0x00000009u, 0x0000022fu, 0x00000228u, 0x0000022eu, 0x00050041u, 0x00000039u, 0x00000230u, + 0x00000028u, 0x000000d2u, 0x0004003du, 0x00000009u, 0x00000231u, 0x00000230u, 0x0004003du, 0x00000009u, + 0x00000232u, 0x00000211u, 0x0004003du, 0x00000009u, 0x00000233u, 0x00000211u, 0x00050085u, 0x00000009u, + 0x00000234u, 0x00000232u, 0x00000233u, 0x0004003du, 0x00000009u, 0x00000235u, 0x0000020eu, 0x00050085u, + 0x00000009u, 0x00000236u, 0x00000234u, 0x00000235u, 0x00050085u, 0x00000009u, 0x00000237u, 0x00000231u, + 0x00000236u, 0x00050081u, 0x00000009u, 0x00000238u, 0x0000022fu, 0x00000237u, 0x0003003eu, 0x00000215u, + 0x00000238u, 0x0004003du, 0x00000009u, 0x00000239u, 0x0000020eu, 0x00050041u, 0x00000039u, 0x0000023au, + 0x00000028u, 0x0000006du, 0x0004003du, 0x00000009u, 0x0000023bu, 0x0000023au, 0x000500bau, 0x00000011u, + 0x0000023cu, 0x00000239u, 0x0000023bu, 0x000300f7u, 0x0000023eu, 0x00000000u, 0x000400fau, 0x0000023cu, + 0x0000023du, 0x0000023eu, 0x000200f8u, 0x0000023du, 0x00050041u, 0x00000039u, 0x0000023fu, 0x00000028u, + 0x000000deu, 0x0004003du, 0x00000009u, 0x00000240u, 0x0000023fu, 0x0004003du, 0x00000009u, 0x00000241u, + 0x0000020eu, 0x00050041u, 0x00000039u, 0x00000242u, 0x00000028u, 0x0000006du, 0x0004003du, 0x00000009u, + 0x00000243u, 0x00000242u, 0x00050083u, 0x00000009u, 0x00000244u, 0x00000241u, 0x00000243u, 0x00050041u, + 0x00000039u, 0x00000245u, 0x00000028u, 0x000000e5u, 0x0004003du, 0x00000009u, 0x00000246u, 0x00000245u, + 0x00050085u, 0x00000009u, 0x00000247u, 0x00000244u, 0x00000246u, 0x00050081u, 0x00000009u, 0x00000248u, + 0x00000240u, 0x00000247u, 0x0003003eu, 0x00000215u, 0x00000248u, 0x000200f9u, 0x0000023eu, 0x000200f8u, + 0x0000023eu, 0x0004003du, 0x00000009u, 0x0000024au, 0x000001fcu, 0x000500bau, 0x00000011u, 0x0000024bu, + 0x0000024au, 0x00000065u, 0x000300f7u, 0x0000024eu, 0x00000000u, 0x000400fau, 0x0000024bu, 0x0000024du, + 0x00000252u, 0x000200f8u, 0x0000024du, 0x0004003du, 0x00000009u, 0x0000024fu, 0x00000215u, 0x0004003du, + 0x00000009u, 0x00000250u, 0x000001fcu, 0x00050088u, 0x00000009u, 0x00000251u, 0x0000024fu, 0x00000250u, + 0x0003003eu, 0x0000024cu, 0x00000251u, 0x000200f9u, 0x0000024eu, 0x000200f8u, 0x00000252u, 0x0003003eu, + 0x0000024cu, 0x00000046u, 0x000200f9u, 0x0000024eu, 0x000200f8u, 0x0000024eu, 0x0004003du, 0x00000009u, + 0x00000253u, 0x0000024cu, 0x0003003eu, 0x00000249u, 0x00000253u, 0x0004003du, 0x00000009u, 0x00000255u, + 0x00000249u, 0x0004003du, 0x00000016u, 0x00000256u, 0x0000015bu, 0x0007004fu, 0x0000009au, 0x00000257u, + 0x00000256u, 0x00000256u, 0x00000000u, 0x00000001u, 0x0005008eu, 0x0000009au, 0x00000258u, 0x00000257u, + 0x00000255u, 0x0003003eu, 0x00000254u, 0x00000258u, 0x00050041u, 0x00000039u, 0x0000025au, 0x00000028u, + 0x000000fcu, 0x0004003du, 0x00000009u, 0x0000025bu, 0x0000025au, 0x00050041u, 0x00000039u, 0x0000025cu, + 0x00000254u, 0x0000007du, 0x0004003du, 0x00000009u, 0x0000025du, 0x0000025cu, 0x00050085u, 0x00000009u, + 0x0000025eu, 0x0000025bu, 0x0000025du, 0x00050041u, 0x00000039u, 0x0000025fu, 0x00000028u, 0x00000102u, + 0x0004003du, 0x00000009u, 0x00000260u, 0x0000025fu, 0x00050041u, 0x00000039u, 0x00000261u, 0x00000254u, + 0x00000008u, 0x0004003du, 0x00000009u, 0x00000262u, 0x00000261u, 0x00050085u, 0x00000009u, 0x00000263u, + 0x00000260u, 0x00000262u, 0x00050081u, 0x00000009u, 0x00000264u, 0x0000025eu, 0x00000263u, 0x00050041u, + 0x00000039u, 0x00000265u, 0x00000028u, 0x0000010au, 0x0004003du, 0x00000009u, 0x00000266u, 0x00000265u, + 0x00050041u, 0x00000039u, 0x00000267u, 0x00000254u, 0x0000007du, 0x0004003du, 0x00000009u, 0x00000268u, + 0x00000267u, 0x00050085u, 0x00000009u, 0x00000269u, 0x00000266u, 0x00000268u, 0x00050041u, 0x00000039u, + 0x0000026au, 0x00000028u, 0x00000110u, 0x0004003du, 0x00000009u, 0x0000026bu, 0x0000026au, 0x00050041u, + 0x00000039u, 0x0000026cu, 0x00000254u, 0x00000008u, 0x0004003du, 0x00000009u, 0x0000026du, 0x0000026cu, + 0x00050085u, 0x00000009u, 0x0000026eu, 0x0000026bu, 0x0000026du, 0x00050081u, 0x00000009u, 0x0000026fu, + 0x00000269u, 0x0000026eu, 0x00050050u, 0x0000009au, 0x00000270u, 0x00000264u, 0x0000026fu, 0x0003003eu, + 0x00000259u, 0x00000270u, 0x0004003du, 0x0000009au, 0x00000272u, 0x00000259u, 0x00050041u, 0x00000039u, + 0x00000273u, 0x00000028u, 0x00000054u, 0x0004003du, 0x00000009u, 0x00000274u, 0x00000273u, 0x00050041u, + 0x00000039u, 0x00000275u, 0x00000028u, 0x0000011cu, 0x0004003du, 0x00000009u, 0x00000276u, 0x00000275u, + 0x00050050u, 0x0000009au, 0x00000277u, 0x00000274u, 0x00000276u, 0x00050081u, 0x0000009au, 0x00000278u, + 0x00000272u, 0x00000277u, 0x0003003eu, 0x00000271u, 0x00000278u, 0x0004003du, 0x00000016u, 0x0000027au, + 0x00000169u, 0x0007004fu, 0x0000009au, 0x0000027bu, 0x0000027au, 0x0000027au, 0x00000000u, 0x00000001u, + 0x0006000cu, 0x00000009u, 0x0000027cu, 0x00000001u, 0x00000042u, 0x0000027bu, 0x0003003eu, 0x00000279u, + 0x0000027cu, 0x0004003du, 0x00000016u, 0x0000027eu, 0x00000169u, 0x0007004fu, 0x0000009au, 0x0000027fu, + 0x0000027eu, 0x0000027eu, 0x00000000u, 0x00000001u, 0x0004003du, 0x00000009u, 0x00000280u, 0x0000017au, + 0x00050051u, 0x00000009u, 0x00000281u, 0x0000027fu, 0x00000000u, 0x00050051u, 0x00000009u, 0x00000282u, + 0x0000027fu, 0x00000001u, 0x00060050u, 0x00000016u, 0x00000283u, 0x00000281u, 0x00000282u, 0x00000280u, + 0x0006000cu, 0x00000009u, 0x00000284u, 0x00000001u, 0x00000042u, 0x00000283u, 0x00050081u, 0x00000009u, + 0x00000285u, 0x00000284u, 0x0000018au, 0x0003003eu, 0x0000027du, 0x00000285u, 0x0004003du, 0x00000009u, + 0x00000287u, 0x0000017au, 0x0004003du, 0x00000009u, 0x00000288u, 0x0000027du, 0x00050088u, 0x00000009u, + 0x00000289u, 0x00000287u, 0x00000288u, 0x0008000cu, 0x00000009u, 0x0000028au, 0x00000001u, 0x0000002bu, + 0x00000289u, 0x000000a3u, 0x00000037u, 0x0003003eu, 0x00000286u, 0x0000028au, 0x0004003du, 0x00000009u, + 0x0000028cu, 0x00000286u, 0x0006000cu, 0x00000009u, 0x0000028du, 0x00000001u, 0x00000011u, 0x0000028cu, + 0x0003003eu, 0x0000028bu, 0x0000028du, 0x0004003du, 0x00000009u, 0x0000028fu, 0x0000028bu, 0x0004003du, + 0x00000009u, 0x00000290u, 0x0000028bu, 0x00050085u, 0x00000009u, 0x00000291u, 0x0000028fu, 0x00000290u, + 0x0003003eu, 0x0000028eu, 0x00000291u, 0x00050041u, 0x00000039u, 0x00000293u, 0x00000028u, 0x000000b9u, + 0x0004003du, 0x00000009u, 0x00000294u, 0x00000293u, 0x00050041u, 0x00000039u, 0x00000295u, 0x00000028u, + 0x00000079u, 0x0004003du, 0x00000009u, 0x00000296u, 0x00000295u, 0x0004003du, 0x00000009u, 0x00000297u, + 0x0000028bu, 0x00050085u, 0x00000009u, 0x00000298u, 0x00000296u, 0x00000297u, 0x00050081u, 0x00000009u, + 0x00000299u, 0x00000294u, 0x00000298u, 0x00050041u, 0x00000039u, 0x0000029au, 0x00000028u, 0x0000002fu, + 0x0004003du, 0x00000009u, 0x0000029bu, 0x0000029au, 0x0004003du, 0x00000009u, 0x0000029cu, 0x0000028eu, + 0x00050085u, 0x00000009u, 0x0000029du, 0x0000029bu, 0x0000029cu, 0x00050081u, 0x00000009u, 0x0000029eu, + 0x00000299u, 0x0000029du, 0x00050041u, 0x00000039u, 0x0000029fu, 0x00000028u, 0x000000c6u, 0x0004003du, + 0x00000009u, 0x000002a0u, 0x0000029fu, 0x0004003du, 0x00000009u, 0x000002a1u, 0x0000028eu, 0x0004003du, + 0x00000009u, 0x000002a2u, 0x0000028bu, 0x00050085u, 0x00000009u, 0x000002a3u, 0x000002a1u, 0x000002a2u, + 0x00050085u, 0x00000009u, 0x000002a4u, 0x000002a0u, 0x000002a3u, 0x00050081u, 0x00000009u, 0x000002a5u, + 0x0000029eu, 0x000002a4u, 0x00050041u, 0x00000039u, 0x000002a6u, 0x00000028u, 0x000000ccu, 0x0004003du, + 0x00000009u, 0x000002a7u, 0x000002a6u, 0x0004003du, 0x00000009u, 0x000002a8u, 0x0000028eu, 0x0004003du, + 0x00000009u, 0x000002a9u, 0x0000028eu, 0x00050085u, 0x00000009u, 0x000002aau, 0x000002a8u, 0x000002a9u, + 0x00050085u, 0x00000009u, 0x000002abu, 0x000002a7u, 0x000002aau, 0x00050081u, 0x00000009u, 0x000002acu, + 0x000002a5u, 0x000002abu, 0x00050041u, 0x00000039u, 0x000002adu, 0x00000028u, 0x000000d2u, 0x0004003du, + 0x00000009u, 0x000002aeu, 0x000002adu, 0x0004003du, 0x00000009u, 0x000002afu, 0x0000028eu, 0x0004003du, + 0x00000009u, 0x000002b0u, 0x0000028eu, 0x00050085u, 0x00000009u, 0x000002b1u, 0x000002afu, 0x000002b0u, + 0x0004003du, 0x00000009u, 0x000002b2u, 0x0000028bu, 0x00050085u, 0x00000009u, 0x000002b3u, 0x000002b1u, + 0x000002b2u, 0x00050085u, 0x00000009u, 0x000002b4u, 0x000002aeu, 0x000002b3u, 0x00050081u, 0x00000009u, + 0x000002b5u, 0x000002acu, 0x000002b4u, 0x0003003eu, 0x00000292u, 0x000002b5u, 0x0004003du, 0x00000009u, + 0x000002b6u, 0x0000028bu, 0x00050041u, 0x00000039u, 0x000002b7u, 0x00000028u, 0x0000006du, 0x0004003du, + 0x00000009u, 0x000002b8u, 0x000002b7u, 0x000500bau, 0x00000011u, 0x000002b9u, 0x000002b6u, 0x000002b8u, + 0x000300f7u, 0x000002bbu, 0x00000000u, 0x000400fau, 0x000002b9u, 0x000002bau, 0x000002bbu, 0x000200f8u, + 0x000002bau, 0x00050041u, 0x00000039u, 0x000002bcu, 0x00000028u, 0x000000deu, 0x0004003du, 0x00000009u, + 0x000002bdu, 0x000002bcu, 0x0004003du, 0x00000009u, 0x000002beu, 0x0000028bu, 0x00050041u, 0x00000039u, + 0x000002bfu, 0x00000028u, 0x0000006du, 0x0004003du, 0x00000009u, 0x000002c0u, 0x000002bfu, 0x00050083u, + 0x00000009u, 0x000002c1u, 0x000002beu, 0x000002c0u, 0x00050041u, 0x00000039u, 0x000002c2u, 0x00000028u, + 0x000000e5u, 0x0004003du, 0x00000009u, 0x000002c3u, 0x000002c2u, 0x00050085u, 0x00000009u, 0x000002c4u, + 0x000002c1u, 0x000002c3u, 0x00050081u, 0x00000009u, 0x000002c5u, 0x000002bdu, 0x000002c4u, 0x0003003eu, + 0x00000292u, 0x000002c5u, 0x000200f9u, 0x000002bbu, 0x000200f8u, 0x000002bbu, 0x0004003du, 0x00000009u, + 0x000002c7u, 0x00000279u, 0x000500bau, 0x00000011u, 0x000002c8u, 0x000002c7u, 0x00000065u, 0x000300f7u, + 0x000002cbu, 0x00000000u, 0x000400fau, 0x000002c8u, 0x000002cau, 0x000002cfu, 0x000200f8u, 0x000002cau, + 0x0004003du, 0x00000009u, 0x000002ccu, 0x00000292u, 0x0004003du, 0x00000009u, 0x000002cdu, 0x00000279u, + 0x00050088u, 0x00000009u, 0x000002ceu, 0x000002ccu, 0x000002cdu, 0x0003003eu, 0x000002c9u, 0x000002ceu, + 0x000200f9u, 0x000002cbu, 0x000200f8u, 0x000002cfu, 0x0003003eu, 0x000002c9u, 0x00000046u, 0x000200f9u, + 0x000002cbu, 0x000200f8u, 0x000002cbu, 0x0004003du, 0x00000009u, 0x000002d0u, 0x000002c9u, 0x0003003eu, + 0x000002c6u, 0x000002d0u, 0x0004003du, 0x00000009u, 0x000002d2u, 0x000002c6u, 0x0004003du, 0x00000016u, + 0x000002d3u, 0x00000169u, 0x0007004fu, 0x0000009au, 0x000002d4u, 0x000002d3u, 0x000002d3u, 0x00000000u, + 0x00000001u, 0x0005008eu, 0x0000009au, 0x000002d5u, 0x000002d4u, 0x000002d2u, 0x0003003eu, 0x000002d1u, + 0x000002d5u, 0x00050041u, 0x00000039u, 0x000002d7u, 0x00000028u, 0x000000fcu, 0x0004003du, 0x00000009u, + 0x000002d8u, 0x000002d7u, 0x00050041u, 0x00000039u, 0x000002d9u, 0x000002d1u, 0x0000007du, 0x0004003du, + 0x00000009u, 0x000002dau, 0x000002d9u, 0x00050085u, 0x00000009u, 0x000002dbu, 0x000002d8u, 0x000002dau, + 0x00050041u, 0x00000039u, 0x000002dcu, 0x00000028u, 0x00000102u, 0x0004003du, 0x00000009u, 0x000002ddu, + 0x000002dcu, 0x00050041u, 0x00000039u, 0x000002deu, 0x000002d1u, 0x00000008u, 0x0004003du, 0x00000009u, + 0x000002dfu, 0x000002deu, 0x00050085u, 0x00000009u, 0x000002e0u, 0x000002ddu, 0x000002dfu, 0x00050081u, + 0x00000009u, 0x000002e1u, 0x000002dbu, 0x000002e0u, 0x00050041u, 0x00000039u, 0x000002e2u, 0x00000028u, + 0x0000010au, 0x0004003du, 0x00000009u, 0x000002e3u, 0x000002e2u, 0x00050041u, 0x00000039u, 0x000002e4u, + 0x000002d1u, 0x0000007du, 0x0004003du, 0x00000009u, 0x000002e5u, 0x000002e4u, 0x00050085u, 0x00000009u, + 0x000002e6u, 0x000002e3u, 0x000002e5u, 0x00050041u, 0x00000039u, 0x000002e7u, 0x00000028u, 0x00000110u, + 0x0004003du, 0x00000009u, 0x000002e8u, 0x000002e7u, 0x00050041u, 0x00000039u, 0x000002e9u, 0x000002d1u, + 0x00000008u, 0x0004003du, 0x00000009u, 0x000002eau, 0x000002e9u, 0x00050085u, 0x00000009u, 0x000002ebu, + 0x000002e8u, 0x000002eau, 0x00050081u, 0x00000009u, 0x000002ecu, 0x000002e6u, 0x000002ebu, 0x00050050u, + 0x0000009au, 0x000002edu, 0x000002e1u, 0x000002ecu, 0x0003003eu, 0x000002d6u, 0x000002edu, 0x0004003du, + 0x0000009au, 0x000002efu, 0x000002d6u, 0x00050041u, 0x00000039u, 0x000002f0u, 0x00000028u, 0x00000054u, + 0x0004003du, 0x00000009u, 0x000002f1u, 0x000002f0u, 0x00050041u, 0x00000039u, 0x000002f2u, 0x00000028u, + 0x0000011cu, 0x0004003du, 0x00000009u, 0x000002f3u, 0x000002f2u, 0x00050050u, 0x0000009au, 0x000002f4u, + 0x000002f1u, 0x000002f3u, 0x00050081u, 0x0000009au, 0x000002f5u, 0x000002efu, 0x000002f4u, 0x0003003eu, + 0x000002eeu, 0x000002f5u, 0x0004003du, 0x0000009au, 0x000002f7u, 0x000001f4u, 0x0004003du, 0x0000009au, + 0x000002f8u, 0x00000271u, 0x00050081u, 0x0000009au, 0x000002f9u, 0x000002f7u, 0x000002f8u, 0x0005008eu, + 0x0000009au, 0x000002fau, 0x000002f9u, 0x00000033u, 0x0003003eu, 0x000002f6u, 0x000002fau, 0x0004003du, + 0x0000009au, 0x000002fcu, 0x000002eeu, 0x0004003du, 0x0000009au, 0x000002fdu, 0x000002f6u, 0x00050083u, + 0x0000009au, 0x000002feu, 0x000002fcu, 0x000002fdu, 0x0006000cu, 0x00000009u, 0x000002ffu, 0x00000001u, + 0x00000042u, 0x000002feu, 0x0003003eu, 0x000002fbu, 0x000002ffu, 0x0004003du, 0x00000009u, 0x00000300u, + 0x000002fbu, 0x0008000cu, 0x00000009u, 0x00000302u, 0x00000001u, 0x0000002bu, 0x00000300u, 0x00000046u, + 0x00000301u, 0x000200feu, 0x00000302u, 0x00010038u, +}; + +static const uint32_t kSpv_ts_polyline_frag[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000041u, 0x00000000u, 0x00020011u, 0x00000001u, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x0009000fu, 0x00000004u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000cu, 0x00000016u, 0x0000002cu, + 0x00000038u, 0x00030010u, 0x00000004u, 0x00000007u, 0x00030010u, 0x00000004u, 0x00000009u, 0x00030003u, + 0x00000002u, 0x000001ccu, 0x000a0004u, 0x455f4c47u, 0x665f5458u, 0x6d676172u, 0x5f746e65u, 0x64616873u, + 0x625f7265u, 0x63797261u, 0x72746e65u, 0x00006369u, 0x00060004u, 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, + 0x64616873u, 0x00007265u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00040005u, 0x00000009u, + 0x6f6c6f63u, 0x00000072u, 0x00060005u, 0x0000000au, 0x6d697250u, 0x6f6c6f43u, 0x6f6c4272u, 0x00006b63u, + 0x00050006u, 0x0000000au, 0x00000000u, 0x6f6c6f63u, 0x00000072u, 0x00050006u, 0x0000000au, 0x00000001u, + 0x625f7369u, 0x00007665u, 0x00040005u, 0x0000000cu, 0x6d697270u, 0x006e695fu, 0x00060005u, 0x00000014u, + 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, 0x000a0006u, 0x00000014u, 0x00000000u, 0x69775f75u, + 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000014u, + 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, + 0x00000014u, 0x00000002u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, + 0x00000000u, 0x00090006u, 0x00000014u, 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, + 0x7665625fu, 0x00000000u, 0x00080006u, 0x00000014u, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, + 0x6d617266u, 0x00000065u, 0x00080006u, 0x00000014u, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, + 0x6163735fu, 0x0000656cu, 0x00070006u, 0x00000014u, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, + 0x00676e69u, 0x00090006u, 0x00000014u, 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, + 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x00000014u, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, + 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, 0x00000014u, 0x00000009u, 0x756e5f75u, 0x75715f6du, + 0x65697265u, 0x00000073u, 0x000a0006u, 0x00000014u, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, + 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, 0x000a0006u, 0x00000014u, 0x0000000bu, 0x616d5f75u, + 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x00000014u, + 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, + 0x00090006u, 0x00000014u, 0x0000000du, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, + 0x00656275u, 0x00080006u, 0x00000014u, 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, + 0x00656c61u, 0x00070006u, 0x00000014u, 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, + 0x00070006u, 0x00000014u, 0x00000010u, 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, + 0x00000014u, 0x00000011u, 0x75635f75u, 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, + 0x00000014u, 0x00000012u, 0x756e5f75u, 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, + 0x00000014u, 0x00000013u, 0x616d5f75u, 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, + 0x00090006u, 0x00000014u, 0x00000014u, 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, + 0x00000000u, 0x00070006u, 0x00000014u, 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, + 0x00070006u, 0x00000014u, 0x00000016u, 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, + 0x00000016u, 0x00006370u, 0x00050005u, 0x00000028u, 0x5f676f66u, 0x74636166u, 0x0000726fu, 0x00060005u, + 0x0000002cu, 0x465f6c67u, 0x43676172u, 0x64726f6fu, 0x00000000u, 0x00050005u, 0x00000038u, 0x5f74756fu, + 0x6f6c6f63u, 0x00000072u, 0x00030047u, 0x0000000au, 0x00000002u, 0x00040048u, 0x0000000au, 0x00000000u, + 0x00001497u, 0x00040048u, 0x0000000au, 0x00000001u, 0x00001497u, 0x00040047u, 0x0000000cu, 0x0000001eu, + 0x00000000u, 0x00030047u, 0x00000014u, 0x00000002u, 0x00050048u, 0x00000014u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x00000014u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000014u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000014u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x00000014u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000014u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x00000014u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x00000014u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000014u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x00000014u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000014u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000014u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x00000014u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000014u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x00000014u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x00000014u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x00000014u, 0x00000010u, 0x00000023u, + 0x00000040u, 0x00050048u, 0x00000014u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00050048u, 0x00000014u, + 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x00000014u, 0x00000013u, 0x00000023u, 0x0000004cu, + 0x00050048u, 0x00000014u, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, 0x00000014u, 0x00000015u, + 0x00000023u, 0x00000054u, 0x00050048u, 0x00000014u, 0x00000016u, 0x00000023u, 0x00000058u, 0x00040047u, + 0x0000002cu, 0x0000000bu, 0x0000000fu, 0x00040047u, 0x00000038u, 0x0000001eu, 0x00000000u, 0x00020013u, + 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00030016u, 0x00000006u, 0x00000020u, 0x00040017u, + 0x00000007u, 0x00000006u, 0x00000003u, 0x00040020u, 0x00000008u, 0x00000007u, 0x00000007u, 0x0004001eu, + 0x0000000au, 0x00000007u, 0x00000006u, 0x00040020u, 0x0000000bu, 0x00000001u, 0x0000000au, 0x0004003bu, + 0x0000000bu, 0x0000000cu, 0x00000001u, 0x00040015u, 0x0000000du, 0x00000020u, 0x00000001u, 0x0004002bu, + 0x0000000du, 0x0000000eu, 0x00000000u, 0x00040020u, 0x0000000fu, 0x00000001u, 0x00000007u, 0x00020014u, + 0x00000012u, 0x00040015u, 0x00000013u, 0x00000020u, 0x00000000u, 0x0019001eu, 0x00000014u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0000000du, 0x0000000du, + 0x00000013u, 0x00000006u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00000006u, 0x00000006u, 0x00000013u, + 0x00000013u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00040020u, 0x00000015u, + 0x00000009u, 0x00000014u, 0x0004003bu, 0x00000015u, 0x00000016u, 0x00000009u, 0x0004002bu, 0x0000000du, + 0x00000017u, 0x0000000fu, 0x00040020u, 0x00000018u, 0x00000009u, 0x00000006u, 0x0004002bu, 0x00000006u, + 0x0000001bu, 0x3f000000u, 0x0004002bu, 0x0000000du, 0x0000001fu, 0x00000001u, 0x00040020u, 0x00000020u, + 0x00000001u, 0x00000006u, 0x00040020u, 0x00000027u, 0x00000007u, 0x00000006u, 0x0004002bu, 0x00000006u, + 0x00000029u, 0x3f800000u, 0x00040017u, 0x0000002au, 0x00000006u, 0x00000004u, 0x00040020u, 0x0000002bu, + 0x00000001u, 0x0000002au, 0x0004003bu, 0x0000002bu, 0x0000002cu, 0x00000001u, 0x0004002bu, 0x00000013u, + 0x0000002du, 0x00000002u, 0x0004002bu, 0x00000006u, 0x00000032u, 0x00000000u, 0x00040020u, 0x00000037u, + 0x00000003u, 0x0000002au, 0x0004003bu, 0x00000037u, 0x00000038u, 0x00000003u, 0x00050036u, 0x00000002u, + 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000008u, 0x00000009u, + 0x00000007u, 0x0004003bu, 0x00000027u, 0x00000028u, 0x00000007u, 0x00050041u, 0x0000000fu, 0x00000010u, + 0x0000000cu, 0x0000000eu, 0x0004003du, 0x00000007u, 0x00000011u, 0x00000010u, 0x0003003eu, 0x00000009u, + 0x00000011u, 0x00050041u, 0x00000018u, 0x00000019u, 0x00000016u, 0x00000017u, 0x0004003du, 0x00000006u, + 0x0000001au, 0x00000019u, 0x000500bau, 0x00000012u, 0x0000001cu, 0x0000001au, 0x0000001bu, 0x000300f7u, + 0x0000001eu, 0x00000000u, 0x000400fau, 0x0000001cu, 0x0000001du, 0x0000001eu, 0x000200f8u, 0x0000001du, + 0x00050041u, 0x00000020u, 0x00000021u, 0x0000000cu, 0x0000001fu, 0x0004003du, 0x00000006u, 0x00000022u, + 0x00000021u, 0x000500b8u, 0x00000012u, 0x00000023u, 0x00000022u, 0x0000001bu, 0x000200f9u, 0x0000001eu, + 0x000200f8u, 0x0000001eu, 0x000700f5u, 0x00000012u, 0x00000024u, 0x0000001cu, 0x00000005u, 0x00000023u, + 0x0000001du, 0x000300f7u, 0x00000026u, 0x00000000u, 0x000400fau, 0x00000024u, 0x00000025u, 0x00000026u, + 0x000200f8u, 0x00000025u, 0x00050041u, 0x00000020u, 0x0000002eu, 0x0000002cu, 0x0000002du, 0x0004003du, + 0x00000006u, 0x0000002fu, 0x0000002eu, 0x00050083u, 0x00000006u, 0x00000030u, 0x00000029u, 0x0000002fu, + 0x0003003eu, 0x00000028u, 0x00000030u, 0x0004003du, 0x00000006u, 0x00000031u, 0x00000028u, 0x0008000cu, + 0x00000006u, 0x00000033u, 0x00000001u, 0x0000002bu, 0x00000031u, 0x00000032u, 0x00000029u, 0x0003003eu, + 0x00000028u, 0x00000033u, 0x0004003du, 0x00000006u, 0x00000034u, 0x00000028u, 0x0004003du, 0x00000007u, + 0x00000035u, 0x00000009u, 0x0005008eu, 0x00000007u, 0x00000036u, 0x00000035u, 0x00000034u, 0x0003003eu, + 0x00000009u, 0x00000036u, 0x000200f9u, 0x00000026u, 0x000200f8u, 0x00000026u, 0x0004003du, 0x00000007u, + 0x00000039u, 0x00000009u, 0x00060050u, 0x00000007u, 0x0000003au, 0x00000032u, 0x00000032u, 0x00000032u, + 0x00060050u, 0x00000007u, 0x0000003bu, 0x00000029u, 0x00000029u, 0x00000029u, 0x0008000cu, 0x00000007u, + 0x0000003cu, 0x00000001u, 0x0000002bu, 0x00000039u, 0x0000003au, 0x0000003bu, 0x00050051u, 0x00000006u, + 0x0000003du, 0x0000003cu, 0x00000000u, 0x00050051u, 0x00000006u, 0x0000003eu, 0x0000003cu, 0x00000001u, + 0x00050051u, 0x00000006u, 0x0000003fu, 0x0000003cu, 0x00000002u, 0x00070050u, 0x0000002au, 0x00000040u, + 0x0000003du, 0x0000003eu, 0x0000003fu, 0x00000029u, 0x0003003eu, 0x00000038u, 0x00000040u, 0x000100fdu, + 0x00010038u, +}; + +static const uint32_t kSpv_ts_polygon_task[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000599u, 0x00000000u, 0x00020011u, 0x0000000bu, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x0016000fu, 0x000014f4u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x000000e1u, 0x000000f7u, 0x00000129u, + 0x00000355u, 0x00000380u, 0x0000038fu, 0x000003a6u, 0x000003ccu, 0x00000408u, 0x00000417u, 0x00000439u, + 0x000004d6u, 0x000004e4u, 0x0000056au, 0x0000058du, 0x00000592u, 0x00000597u, 0x0006014bu, 0x00000004u, + 0x00000026u, 0x00000007u, 0x00000007u, 0x00000007u, 0x00030003u, 0x00000002u, 0x000001ccu, 0x00060004u, + 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, 0x000d0004u, 0x455f4c47u, 0x735f5458u, + 0x65646168u, 0x78655f72u, 0x63696c70u, 0x615f7469u, 0x68746972u, 0x6974656du, 0x79745f63u, 0x5f736570u, + 0x36746e69u, 0x00000034u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00090005u, 0x0000000du, + 0x5f746567u, 0x61666564u, 0x5f746c75u, 0x6d697270u, 0x6c6f635fu, 0x7528726fu, 0x00003b31u, 0x00060005u, + 0x0000000cu, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00070005u, 0x00000010u, 0x5f746567u, + 0x6d697270u, 0x6c6f635fu, 0x7528726fu, 0x00003b31u, 0x00060005u, 0x0000000fu, 0x6d697270u, 0x7079745fu, + 0x64695f65u, 0x00000000u, 0x000c0005u, 0x00000019u, 0x616e6962u, 0x735f7972u, 0x63726165u, 0x69745f68u, + 0x7473656du, 0x73706d61u, 0x3b317528u, 0x693b3175u, 0x3b313436u, 0x00000000u, 0x00050005u, 0x00000016u, + 0x65736162u, 0x66666f5fu, 0x00746573u, 0x00040005u, 0x00000017u, 0x6e756f63u, 0x00000074u, 0x00040005u, + 0x00000018u, 0x67726174u, 0x00007465u, 0x000b0005u, 0x00000022u, 0x6c6c7563u, 0x6261615fu, 0x766f5f62u, + 0x616c7265u, 0x66762870u, 0x66763b33u, 0x66763b33u, 0x66763b33u, 0x00003b33u, 0x00040005u, 0x0000001eu, + 0x696d5f61u, 0x0000006eu, 0x00040005u, 0x0000001fu, 0x616d5f61u, 0x00000078u, 0x00040005u, 0x00000020u, + 0x696d5f62u, 0x0000006eu, 0x00040005u, 0x00000021u, 0x616d5f62u, 0x00000078u, 0x00050005u, 0x00000026u, + 0x656d6143u, 0x6f506172u, 0x00006573u, 0x00070006u, 0x00000026u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, + 0x6d61635fu, 0x00617265u, 0x000e0005u, 0x0000002au, 0x5f746567u, 0x656d6163u, 0x775f6172u, 0x646c726fu, + 0x736f705fu, 0x72747328u, 0x2d746375u, 0x656d6143u, 0x6f506172u, 0x6d2d6573u, 0x31343466u, 0x0000003bu, + 0x00040005u, 0x00000029u, 0x65736f70u, 0x00000000u, 0x00060005u, 0x0000002du, 0x65685446u, 0x61436174u, + 0x6172656du, 0x00000000u, 0x00040006u, 0x0000002du, 0x00000000u, 0x00007863u, 0x00040006u, 0x0000002du, + 0x00000001u, 0x00007963u, 0x00050006u, 0x0000002du, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, + 0x0000002du, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, 0x0000002du, 0x00000004u, 0x796c6f70u, + 0x00000030u, 0x00050006u, 0x0000002du, 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x0000002du, + 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x0000002du, 0x00000007u, 0x796c6f70u, 0x00000033u, + 0x00050006u, 0x0000002du, 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, 0x0000002du, 0x00000009u, + 0x796c6f70u, 0x00000035u, 0x00070006u, 0x0000002du, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, + 0x00000065u, 0x00080006u, 0x0000002du, 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, + 0x00006c61u, 0x00080006u, 0x0000002du, 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, + 0x006c6176u, 0x00060006u, 0x0000002du, 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, + 0x0000002du, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, 0x0000002du, 0x0000000fu, 0x645f646cu, + 0x00000000u, 0x00050006u, 0x0000002du, 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x0000002du, + 0x00000011u, 0x665f646cu, 0x00000000u, 0x00220005u, 0x00000034u, 0x69747365u, 0x6574616du, 0x6764655fu, + 0x69645f65u, 0x726f7473u, 0x6e6f6974u, 0x7869705fu, 0x5f736c65u, 0x3474616du, 0x33667628u, 0x3366763bu, + 0x34666d3bu, 0x74733b34u, 0x74637572u, 0x6854462du, 0x43617465u, 0x72656d61u, 0x31662d61u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, + 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x3131662du, 0x0000003bu, 0x00030005u, 0x00000030u, 0x00003076u, + 0x00030005u, 0x00000031u, 0x00003176u, 0x00060005u, 0x00000032u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, + 0x00000000u, 0x00030005u, 0x00000033u, 0x006d6163u, 0x00250005u, 0x0000003du, 0x706d6f63u, 0x5f657475u, + 0x64627573u, 0x73697669u, 0x5f6e6f69u, 0x6576656cu, 0x6676286cu, 0x66763b33u, 0x74733b33u, 0x74637572u, + 0x6d61432du, 0x50617265u, 0x2d65736fu, 0x3434666du, 0x74733b31u, 0x74637572u, 0x6854462du, 0x43617465u, + 0x72656d61u, 0x31662d61u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, + 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x3131662du, 0x3b31663bu, + 0x00000000u, 0x00030005u, 0x00000038u, 0x00003076u, 0x00030005u, 0x00000039u, 0x00003176u, 0x00040005u, + 0x0000003au, 0x65736f70u, 0x00000000u, 0x00030005u, 0x0000003bu, 0x006d6163u, 0x00070005u, 0x0000003cu, + 0x65726874u, 0x6c6f6873u, 0x69705f64u, 0x736c6578u, 0x00000000u, 0x00060005u, 0x000000dfu, 0x68737550u, + 0x736e6f43u, 0x746e6174u, 0x00000073u, 0x000a0006u, 0x000000dfu, 0x00000000u, 0x69775f75u, 0x5f687464u, + 0x796c6f70u, 0x656e696cu, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x000000dfu, 0x00000001u, + 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, 0x000000dfu, + 0x00000002u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, 0x00000000u, + 0x00090006u, 0x000000dfu, 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x7665625fu, + 0x00000000u, 0x00080006u, 0x000000dfu, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, 0x6d617266u, + 0x00000065u, 0x00080006u, 0x000000dfu, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, 0x6163735fu, + 0x0000656cu, 0x00070006u, 0x000000dfu, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, 0x00676e69u, + 0x00090006u, 0x000000dfu, 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, 0x5f6e6f69u, + 0x00007375u, 0x00090006u, 0x000000dfu, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, 0x5f657474u, + 0x657a6973u, 0x00000000u, 0x00070006u, 0x000000dfu, 0x00000009u, 0x756e5f75u, 0x75715f6du, 0x65697265u, + 0x00000073u, 0x000a0006u, 0x000000dfu, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, 0x745f6e6fu, + 0x73657268u, 0x646c6f68u, 0x00000000u, 0x000a0006u, 0x000000dfu, 0x0000000bu, 0x616d5f75u, 0x65745f78u, + 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x000000dfu, 0x0000000cu, + 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, 0x00090006u, + 0x000000dfu, 0x0000000du, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, 0x00656275u, + 0x00080006u, 0x000000dfu, 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, 0x00656c61u, + 0x00070006u, 0x000000dfu, 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, 0x00070006u, + 0x000000dfu, 0x00000010u, 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, 0x000000dfu, + 0x00000011u, 0x75635f75u, 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, 0x000000dfu, + 0x00000012u, 0x756e5f75u, 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, 0x000000dfu, + 0x00000013u, 0x616d5f75u, 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, 0x00090006u, + 0x000000dfu, 0x00000014u, 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, + 0x00070006u, 0x000000dfu, 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, 0x00070006u, + 0x000000dfu, 0x00000016u, 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, 0x000000e1u, + 0x00006370u, 0x00060005u, 0x000000f3u, 0x656c6170u, 0x5f657474u, 0x6f6c6f63u, 0x00000072u, 0x00080005u, + 0x000000f5u, 0x6f6c6f43u, 0x6c615072u, 0x65747465u, 0x66667542u, 0x61457265u, 0x00796c72u, 0x00070006u, + 0x000000f5u, 0x00000000u, 0x6f635f67u, 0x5f726f6cu, 0x656c6170u, 0x00657474u, 0x00030005u, 0x000000f7u, + 0x00000000u, 0x00040005u, 0x00000104u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000110u, 0x7466656cu, + 0x00000000u, 0x00040005u, 0x00000111u, 0x68676972u, 0x00000074u, 0x00040005u, 0x00000116u, 0x75736572u, + 0x0000746cu, 0x00030005u, 0x0000011fu, 0x0064696du, 0x00030005u, 0x00000125u, 0x006c6176u, 0x00070005u, + 0x00000127u, 0x656d6954u, 0x6d617473u, 0x75427370u, 0x72656666u, 0x00000000u, 0x00070006u, 0x00000127u, + 0x00000000u, 0x69745f67u, 0x7473656du, 0x73706d61u, 0x00000000u, 0x00030005u, 0x00000129u, 0x00000000u, + 0x00030005u, 0x0000014fu, 0x00000052u, 0x00040005u, 0x00000169u, 0x5f6d6163u, 0x00307470u, 0x00040005u, + 0x00000172u, 0x5f6d6163u, 0x00317470u, 0x00050005u, 0x0000017bu, 0x5f64696du, 0x6c726f77u, 0x00000064u, + 0x00050005u, 0x00000181u, 0x5f6d6163u, 0x6d5f7470u, 0x00006469u, 0x00040005u, 0x0000018au, 0x74706564u, + 0x00003068u, 0x00040005u, 0x0000018fu, 0x74706564u, 0x00003168u, 0x00050005u, 0x00000193u, 0x74706564u, + 0x696d5f68u, 0x00000064u, 0x00040005u, 0x00000197u, 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x0000019cu, + 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00050005u, 0x000001a6u, 0x5f736f63u, 0x68706c61u, 0x00000061u, + 0x00040005u, 0x000001acu, 0x68706c61u, 0x00000061u, 0x00030005u, 0x000001afu, 0x00003261u, 0x00040005u, + 0x000001b3u, 0x746c6564u, 0x00000061u, 0x00040005u, 0x000001efu, 0x6c616373u, 0x00000065u, 0x00050005u, + 0x000001fcu, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x00000201u, 0x65786970u, 0x69645f6cu, + 0x00007473u, 0x00040005u, 0x0000021du, 0x65786970u, 0x0000306cu, 0x00040005u, 0x00000225u, 0x6e5f7978u, + 0x006d726fu, 0x00050005u, 0x00000229u, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00050005u, 0x00000232u, + 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, 0x00000237u, 0x68706c61u, 0x00000061u, 0x00030005u, + 0x0000023au, 0x00003261u, 0x00040005u, 0x0000023eu, 0x746c6564u, 0x00000061u, 0x00040005u, 0x00000272u, + 0x6c616373u, 0x00000065u, 0x00050005u, 0x0000027du, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, + 0x00000282u, 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00040005u, 0x0000029au, 0x65786970u, 0x0000316cu, + 0x00040005u, 0x000002a2u, 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x000002a6u, 0x5f796172u, 0x6d726f6eu, + 0x00000000u, 0x00050005u, 0x000002afu, 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, 0x000002b4u, + 0x68706c61u, 0x00000061u, 0x00030005u, 0x000002b7u, 0x00003261u, 0x00040005u, 0x000002bbu, 0x746c6564u, + 0x00000061u, 0x00040005u, 0x000002efu, 0x6c616373u, 0x00000065u, 0x00050005u, 0x000002fau, 0x65786970u, + 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x000002ffu, 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00050005u, + 0x00000317u, 0x65786970u, 0x696d5f6cu, 0x00000064u, 0x00070005u, 0x0000031fu, 0x656e696cu, 0x705f7261u, + 0x6c657869u, 0x64696d5fu, 0x00000000u, 0x00060005u, 0x00000324u, 0x6f727265u, 0x69705f72u, 0x736c6578u, + 0x00000000u, 0x00040005u, 0x0000032eu, 0x6f727265u, 0x00000072u, 0x00040005u, 0x0000032fu, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000331u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000333u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000336u, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000351u, 0x7361745fu, + 0x6f635f6bu, 0x00746e75u, 0x00040005u, 0x00000352u, 0x6b726f77u, 0x0064695fu, 0x00060005u, 0x00000355u, + 0x575f6c67u, 0x476b726fu, 0x70756f72u, 0x00004449u, 0x00060005u, 0x00000359u, 0x72726176u, 0x6f5f7961u, + 0x65736666u, 0x00000074u, 0x00040005u, 0x00000360u, 0x706d6574u, 0x00000000u, 0x00060005u, 0x00000365u, + 0x6c6f6f70u, 0x5f64695fu, 0x61636f6cu, 0x0000006cu, 0x00060005u, 0x0000036bu, 0x72657571u, 0x64695f79u, + 0x636f6c5fu, 0x00006c61u, 0x00050005u, 0x00000379u, 0x646e6552u, 0x75517265u, 0x00797265u, 0x00060006u, + 0x00000379u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, 0x00000379u, 0x00000001u, + 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000379u, 0x00000002u, 0x656d6974u, 0x6d617473u, + 0x73755f70u, 0x00000000u, 0x00070006u, 0x00000379u, 0x00000003u, 0x656d6163u, 0x745f6172u, 0x5f657079u, + 0x00006469u, 0x00050006u, 0x00000379u, 0x00000004u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000379u, + 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000379u, 0x00000006u, 0x6461705fu, 0x00000033u, + 0x00040005u, 0x0000037bu, 0x72657571u, 0x00000079u, 0x00050005u, 0x0000037cu, 0x646e6552u, 0x75517265u, + 0x00797265u, 0x00060006u, 0x0000037cu, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, + 0x0000037cu, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x0000037cu, 0x00000002u, + 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x0000037cu, 0x00000003u, 0x656d6163u, + 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x0000037cu, 0x00000004u, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x0000037cu, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x0000037cu, 0x00000006u, + 0x6461705fu, 0x00000033u, 0x00050005u, 0x0000037eu, 0x72657551u, 0x66754279u, 0x00726566u, 0x00060006u, + 0x0000037eu, 0x00000000u, 0x75715f67u, 0x65697265u, 0x00000073u, 0x00030005u, 0x00000380u, 0x00000000u, + 0x00070005u, 0x00000387u, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, + 0x00000387u, 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, + 0x00000387u, 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, + 0x00080006u, 0x00000387u, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, + 0x00090006u, 0x00000387u, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, + 0x00000000u, 0x00070006u, 0x00000387u, 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, + 0x00080006u, 0x00000387u, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, + 0x000a0006u, 0x00000387u, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, + 0x74657366u, 0x00000000u, 0x00080006u, 0x00000387u, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, + 0x66666f5fu, 0x00746573u, 0x00090006u, 0x00000387u, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, + 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00090006u, 0x00000387u, 0x00000009u, 0x61697274u, 0x656c676eu, + 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000387u, 0x0000000au, 0x65736f70u, + 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000387u, 0x0000000bu, 0x616f6c66u, + 0x75625f74u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000387u, 0x0000000cu, 0x6461705fu, + 0x00000000u, 0x00040005u, 0x00000389u, 0x6e656373u, 0x00000065u, 0x00070005u, 0x0000038bu, 0x656d6954u, + 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x0000038bu, 0x00000000u, 0x5f6d756eu, + 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x0000038bu, 0x00000001u, 0x796c6f70u, + 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, 0x0000038bu, 0x00000002u, + 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, 0x0000038bu, 0x00000003u, + 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00070006u, 0x0000038bu, + 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, 0x0000038bu, 0x00000005u, + 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, 0x0000038bu, 0x00000006u, + 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00080006u, + 0x0000038bu, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00090006u, + 0x0000038bu, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, + 0x00090006u, 0x0000038bu, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, 0x5f726566u, 0x7366666fu, + 0x00007465u, 0x00080006u, 0x0000038bu, 0x0000000au, 0x65736f70u, 0x6675625fu, 0x5f726566u, 0x7366666fu, + 0x00007465u, 0x00080006u, 0x0000038bu, 0x0000000bu, 0x616f6c66u, 0x75625f74u, 0x72656666u, 0x66666f5fu, + 0x00746573u, 0x00050006u, 0x0000038bu, 0x0000000cu, 0x6461705fu, 0x00000000u, 0x00050005u, 0x0000038du, + 0x6e656353u, 0x66754265u, 0x00726566u, 0x00060006u, 0x0000038du, 0x00000000u, 0x63735f67u, 0x73656e65u, + 0x00000000u, 0x00030005u, 0x0000038fu, 0x00000000u, 0x00080005u, 0x0000039fu, 0x656d6954u, 0x6d617473u, + 0x50646570u, 0x67796c6fu, 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x0000039fu, 0x00000000u, 0x5f6d756eu, + 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x0000039fu, 0x00000001u, 0x5f6d756eu, 0x72726176u, + 0x00737961u, 0x00070006u, 0x0000039fu, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, + 0x00070006u, 0x0000039fu, 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, 0x00070006u, + 0x0000039fu, 0x00000004u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x0000039fu, + 0x00000005u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x0000039fu, + 0x00000006u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, + 0x0000039fu, 0x00000007u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x0000039fu, 0x00000008u, 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x0000039fu, + 0x00000009u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x0000039fu, 0x0000000au, + 0x61697274u, 0x656c676eu, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, 0x0000039fu, 0x0000000bu, + 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x0000039fu, 0x0000000cu, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x0000039fu, 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, 0x0000039fu, 0x0000000eu, + 0x6461705fu, 0x00000033u, 0x00050006u, 0x0000039fu, 0x0000000fu, 0x6461705fu, 0x00000034u, 0x00040005u, + 0x000003a1u, 0x6c6f6f70u, 0x00000000u, 0x00080005u, 0x000003a2u, 0x656d6954u, 0x6d617473u, 0x50646570u, + 0x67796c6fu, 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x000003a2u, 0x00000000u, 0x5f6d756eu, 0x656d6974u, + 0x6d617473u, 0x00007370u, 0x00060006u, 0x000003a2u, 0x00000001u, 0x5f6d756eu, 0x72726176u, 0x00737961u, + 0x00070006u, 0x000003a2u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, 0x00070006u, + 0x000003a2u, 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, 0x00070006u, 0x000003a2u, + 0x00000004u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x000003a2u, 0x00000005u, + 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x000003a2u, 0x00000006u, + 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, 0x000003a2u, + 0x00000007u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x000003a2u, + 0x00000008u, 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x000003a2u, 0x00000009u, + 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x000003a2u, 0x0000000au, 0x61697274u, + 0x656c676eu, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, 0x000003a2u, 0x0000000bu, 0x62626161u, + 0x66666f5fu, 0x00746573u, 0x00050006u, 0x000003a2u, 0x0000000cu, 0x6461705fu, 0x00000031u, 0x00050006u, + 0x000003a2u, 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, 0x000003a2u, 0x0000000eu, 0x6461705fu, + 0x00000033u, 0x00050006u, 0x000003a2u, 0x0000000fu, 0x6461705fu, 0x00000034u, 0x00070005u, 0x000003a4u, + 0x796c6f50u, 0x506e6f67u, 0x426c6f6fu, 0x65666675u, 0x00000072u, 0x00070006u, 0x000003a4u, 0x00000000u, + 0x6f705f67u, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00030005u, 0x000003a6u, 0x00000000u, 0x00040005u, + 0x000003afu, 0x695f7374u, 0x00007864u, 0x00040005u, 0x000003b5u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000003b6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000003b9u, 0x61726170u, 0x0000006du, 0x00060005u, + 0x000003c4u, 0x72726176u, 0x735f7961u, 0x74726174u, 0x00000000u, 0x00050005u, 0x000003cau, 0x33746e49u, + 0x66754232u, 0x00726566u, 0x00050006u, 0x000003cau, 0x00000000u, 0x6e695f67u, 0x00323374u, 0x00030005u, + 0x000003ccu, 0x00000000u, 0x00050005u, 0x000003dau, 0x72726176u, 0x655f7961u, 0x0000646eu, 0x00050005u, + 0x000003e6u, 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070005u, 0x000003ebu, 0x63726f66u, 0x657a5f65u, + 0x745f6f72u, 0x736b7361u, 0x00000000u, 0x00070005u, 0x000003f3u, 0x75746361u, 0x765f6c61u, 0x61727261u, + 0x64695f79u, 0x00000078u, 0x00040005u, 0x00000403u, 0x6c6c7563u, 0x0000725fu, 0x00060005u, 0x00000404u, + 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, 0x00040006u, 0x00000404u, 0x00000000u, 0x00007863u, + 0x00040006u, 0x00000404u, 0x00000001u, 0x00007963u, 0x00050006u, 0x00000404u, 0x00000002u, 0x5f676d69u, + 0x00000077u, 0x00050006u, 0x00000404u, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, 0x00000404u, + 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, 0x00000404u, 0x00000005u, 0x796c6f70u, 0x00000031u, + 0x00050006u, 0x00000404u, 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x00000404u, 0x00000007u, + 0x796c6f70u, 0x00000033u, 0x00050006u, 0x00000404u, 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, + 0x00000404u, 0x00000009u, 0x796c6f70u, 0x00000035u, 0x00070006u, 0x00000404u, 0x0000000au, 0x5f78616du, + 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, 0x00000404u, 0x0000000bu, 0x5f78616du, 0x74736964u, + 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, 0x00000404u, 0x0000000cu, 0x5f78616du, 0x74736964u, + 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, 0x00000404u, 0x0000000du, 0x74706564u, 0x616d5f68u, + 0x00000078u, 0x00050006u, 0x00000404u, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, 0x00000404u, + 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, 0x00000404u, 0x00000010u, 0x655f646cu, 0x00000000u, + 0x00050006u, 0x00000404u, 0x00000011u, 0x665f646cu, 0x00000000u, 0x00080005u, 0x00000406u, 0x656d6143u, + 0x6e496172u, 0x6e697274u, 0x73636973u, 0x66667542u, 0x00007265u, 0x00080006u, 0x00000406u, 0x00000000u, + 0x61635f67u, 0x6172656du, 0x746e695fu, 0x736e6972u, 0x00736369u, 0x00030005u, 0x00000408u, 0x00000000u, + 0x00050005u, 0x00000412u, 0x6c6c7563u, 0x736f705fu, 0x00000065u, 0x00050005u, 0x00000413u, 0x656d6143u, + 0x6f506172u, 0x00006573u, 0x00070006u, 0x00000413u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, + 0x00617265u, 0x00070005u, 0x00000415u, 0x656d6143u, 0x6f506172u, 0x75426573u, 0x72656666u, 0x00000000u, + 0x00070006u, 0x00000415u, 0x00000000u, 0x61635f67u, 0x6172656du, 0x736f705fu, 0x00007365u, 0x00030005u, + 0x00000417u, 0x00000000u, 0x00040005u, 0x0000041du, 0x5f6d6163u, 0x00736f70u, 0x00040005u, 0x0000041eu, + 0x61726170u, 0x0000006du, 0x00050005u, 0x00000421u, 0x77656976u, 0x6e696d5fu, 0x00000000u, 0x00050005u, + 0x00000426u, 0x77656976u, 0x78616d5fu, 0x00000000u, 0x00030005u, 0x0000042bu, 0x00006261u, 0x00040005u, + 0x00000435u, 0x696d5f65u, 0x0000006eu, 0x00050005u, 0x00000437u, 0x616f6c46u, 0x66754274u, 0x00726566u, + 0x00060006u, 0x00000437u, 0x00000000u, 0x6c665f67u, 0x7374616fu, 0x00000000u, 0x00030005u, 0x00000439u, + 0x00000000u, 0x00040005u, 0x00000446u, 0x616d5f65u, 0x00000078u, 0x00040005u, 0x00000455u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000457u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000459u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x0000045bu, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000461u, 0x5f697274u, + 0x72617473u, 0x00000074u, 0x00040005u, 0x00000471u, 0x5f697274u, 0x00646e65u, 0x00050005u, 0x0000047cu, + 0x61746f74u, 0x72745f6cu, 0x00007369u, 0x00040005u, 0x00000484u, 0x74735f76u, 0x00747261u, 0x00040005u, + 0x00000494u, 0x6e655f76u, 0x00000064u, 0x00050005u, 0x0000049fu, 0x61746f74u, 0x65765f6cu, 0x00737472u, + 0x00030005u, 0x000004a3u, 0x006d6163u, 0x00040005u, 0x000004aau, 0x65736f70u, 0x00000000u, 0x00050005u, + 0x000004afu, 0x5f78616du, 0x64627573u, 0x00007669u, 0x00050005u, 0x000004b5u, 0x65736162u, 0x695f765fu, + 0x00007864u, 0x00050005u, 0x000004bdu, 0x65736162u, 0x695f745fu, 0x00007864u, 0x00060005u, 0x000004c5u, + 0x706d6173u, 0x635f656cu, 0x746e756fu, 0x00000000u, 0x00030005u, 0x000004c8u, 0x00000074u, 0x00030005u, + 0x000004d2u, 0x00697274u, 0x00060005u, 0x000004d4u, 0x61697254u, 0x656c676eu, 0x66667542u, 0x00007265u, + 0x00060006u, 0x000004d4u, 0x00000000u, 0x72745f67u, 0x676e6169u, 0x0073656cu, 0x00030005u, 0x000004d6u, + 0x00000000u, 0x00040005u, 0x000004ddu, 0x74726556u, 0x00007865u, 0x00040006u, 0x000004ddu, 0x00000000u, + 0x00000078u, 0x00040006u, 0x000004ddu, 0x00000001u, 0x00000079u, 0x00040006u, 0x000004ddu, 0x00000002u, + 0x0000007au, 0x00050006u, 0x000004ddu, 0x00000003u, 0x6461705fu, 0x00000000u, 0x00030005u, 0x000004dfu, + 0x00003076u, 0x00040005u, 0x000004e0u, 0x74726556u, 0x00007865u, 0x00040006u, 0x000004e0u, 0x00000000u, + 0x00000078u, 0x00040006u, 0x000004e0u, 0x00000001u, 0x00000079u, 0x00040006u, 0x000004e0u, 0x00000002u, + 0x0000007au, 0x00050006u, 0x000004e0u, 0x00000003u, 0x6461705fu, 0x00000000u, 0x00060005u, 0x000004e2u, + 0x74726556u, 0x75427865u, 0x72656666u, 0x00000000u, 0x00060006u, 0x000004e2u, 0x00000000u, 0x65765f67u, + 0x63697472u, 0x00007365u, 0x00030005u, 0x000004e4u, 0x00000000u, 0x00030005u, 0x000004edu, 0x00003176u, + 0x00030005u, 0x000004f5u, 0x00003276u, 0x00030005u, 0x000004fdu, 0x00003070u, 0x00030005u, 0x00000505u, + 0x00003170u, 0x00030005u, 0x0000050du, 0x00003270u, 0x00040005u, 0x00000516u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000518u, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000051au, 0x61726170u, 0x0000006du, + 0x00040005u, 0x0000051cu, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000051eu, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000524u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000526u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000528u, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000052au, 0x61726170u, 0x0000006du, + 0x00040005u, 0x0000052cu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000532u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000534u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000536u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000538u, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000053au, 0x61726170u, 0x0000006du, + 0x00050005u, 0x0000054bu, 0x5f6d756eu, 0x6e756863u, 0x0000736bu, 0x00060005u, 0x00000551u, 0x73697274u, + 0x7265705fu, 0x7568635fu, 0x00006b6eu, 0x00070005u, 0x00000568u, 0x796c6f50u, 0x546e6f67u, 0x506b7361u, + 0x6f6c7961u, 0x00006461u, 0x00060006u, 0x00000568u, 0x00000000u, 0x72657571u, 0x64695f79u, 0x00000000u, + 0x00050006u, 0x00000568u, 0x00000001u, 0x6c6f6f70u, 0x0064695fu, 0x00060006u, 0x00000568u, 0x00000002u, + 0x72726176u, 0x695f7961u, 0x00007864u, 0x00070006u, 0x00000568u, 0x00000003u, 0x61697274u, 0x656c676eu, + 0x756f635fu, 0x0000746eu, 0x00070006u, 0x00000568u, 0x00000004u, 0x74726576u, 0x635f7865u, 0x746e756fu, + 0x00000000u, 0x00080006u, 0x00000568u, 0x00000005u, 0x64627573u, 0x73697669u, 0x5f6e6f69u, 0x6576656cu, + 0x0000006cu, 0x00050006u, 0x00000568u, 0x00000006u, 0x6f6c6f63u, 0x00000072u, 0x00050006u, 0x00000568u, + 0x00000007u, 0x625f7369u, 0x00007665u, 0x00040005u, 0x0000056au, 0x6c796170u, 0x0064616fu, 0x00040005u, + 0x00000578u, 0x61726170u, 0x0000006du, 0x00050005u, 0x0000058bu, 0x65736f50u, 0x66667542u, 0x00007265u, + 0x00050006u, 0x0000058bu, 0x00000000u, 0x6f705f67u, 0x00736573u, 0x00030005u, 0x0000058du, 0x00000000u, + 0x00080005u, 0x0000058eu, 0x656d6954u, 0x6d617473u, 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, + 0x00070006u, 0x0000058eu, 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, + 0x0000058eu, 0x00000001u, 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, 0x0000058eu, 0x00000002u, + 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, 0x00070006u, 0x0000058eu, 0x00000003u, 0x6d697270u, + 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x0000058eu, 0x00000004u, 0x656d6974u, 0x6d617473u, + 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x0000058eu, 0x00000005u, 0x765f7374u, 0x61727261u, + 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, 0x0000058eu, 0x00000006u, 0x72726176u, + 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x0000058eu, 0x00000007u, 0x74726576u, + 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00060006u, 0x0000058eu, 0x00000008u, 0x62626161u, 0x66666f5fu, + 0x00746573u, 0x00050006u, 0x0000058eu, 0x00000009u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x0000058eu, + 0x0000000au, 0x6461705fu, 0x00000032u, 0x00050006u, 0x0000058eu, 0x0000000bu, 0x6461705fu, 0x00000033u, + 0x00050006u, 0x0000058eu, 0x0000000cu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x0000058eu, 0x0000000du, + 0x6461705fu, 0x00000035u, 0x00050006u, 0x0000058eu, 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, + 0x0000058eu, 0x0000000fu, 0x6461705fu, 0x00000037u, 0x00070005u, 0x00000590u, 0x796c6f50u, 0x656e696cu, + 0x6c6f6f50u, 0x66667542u, 0x00007265u, 0x00080006u, 0x00000590u, 0x00000000u, 0x6f705f67u, 0x696c796cu, + 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00030005u, 0x00000592u, 0x00000000u, 0x00060005u, 0x00000593u, + 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x00000000u, 0x00060006u, 0x00000593u, 0x00000000u, 0x5f6d756eu, + 0x65627563u, 0x00000073u, 0x00070006u, 0x00000593u, 0x00000001u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, + 0x00007370u, 0x00070006u, 0x00000593u, 0x00000002u, 0x5f6d756eu, 0x63617274u, 0x6f705f6bu, 0x00736573u, + 0x00070006u, 0x00000593u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, + 0x00000593u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00080006u, + 0x00000593u, 0x00000005u, 0x65627563u, 0x5f73745fu, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, + 0x00000593u, 0x00000006u, 0x63617274u, 0x69745f6bu, 0x7473656du, 0x73706d61u, 0x66666f5fu, 0x00746573u, + 0x00080006u, 0x00000593u, 0x00000007u, 0x6e617274u, 0x74616c73u, 0x736e6f69u, 0x66666f5fu, 0x00746573u, + 0x00080006u, 0x00000593u, 0x00000008u, 0x74617571u, 0x696e7265u, 0x5f736e6fu, 0x7366666fu, 0x00007465u, + 0x00070006u, 0x00000593u, 0x00000009u, 0x6c616373u, 0x6f5f7365u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x00000593u, 0x0000000au, 0x6f6c6f63u, 0x6f5f7372u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000593u, + 0x0000000bu, 0x646e6572u, 0x665f7265u, 0x7367616cu, 0x00000000u, 0x00050006u, 0x00000593u, 0x0000000cu, + 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000593u, 0x0000000du, 0x6461705fu, 0x00000033u, 0x00050006u, + 0x00000593u, 0x0000000eu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x00000593u, 0x0000000fu, 0x6461705fu, + 0x00000035u, 0x00070005u, 0x00000595u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x66667542u, 0x00007265u, + 0x00080006u, 0x00000595u, 0x00000000u, 0x626f5f67u, 0x63617473u, 0x705f656cu, 0x736c6f6fu, 0x00000000u, + 0x00030005u, 0x00000597u, 0x00000000u, 0x00030047u, 0x000000dfu, 0x00000002u, 0x00050048u, 0x000000dfu, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x000000dfu, 0x00000001u, 0x00000023u, 0x00000004u, + 0x00050048u, 0x000000dfu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x000000dfu, 0x00000003u, + 0x00000023u, 0x0000000cu, 0x00050048u, 0x000000dfu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, + 0x000000dfu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x000000dfu, 0x00000006u, 0x00000023u, + 0x00000018u, 0x00050048u, 0x000000dfu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x000000dfu, + 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x000000dfu, 0x00000009u, 0x00000023u, 0x00000024u, + 0x00050048u, 0x000000dfu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x000000dfu, 0x0000000bu, + 0x00000023u, 0x0000002cu, 0x00050048u, 0x000000dfu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, + 0x000000dfu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x000000dfu, 0x0000000eu, 0x00000023u, + 0x00000038u, 0x00050048u, 0x000000dfu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x000000dfu, + 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x000000dfu, 0x00000011u, 0x00000023u, 0x00000044u, + 0x00050048u, 0x000000dfu, 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x000000dfu, 0x00000013u, + 0x00000023u, 0x0000004cu, 0x00050048u, 0x000000dfu, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, + 0x000000dfu, 0x00000015u, 0x00000023u, 0x00000054u, 0x00050048u, 0x000000dfu, 0x00000016u, 0x00000023u, + 0x00000058u, 0x00040047u, 0x000000f4u, 0x00000006u, 0x00000010u, 0x00030047u, 0x000000f5u, 0x00000002u, + 0x00040048u, 0x000000f5u, 0x00000000u, 0x00000018u, 0x00050048u, 0x000000f5u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x000000f7u, 0x00000018u, 0x00040047u, 0x000000f7u, 0x00000021u, 0x0000000au, + 0x00040047u, 0x000000f7u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000126u, 0x00000006u, 0x00000008u, + 0x00030047u, 0x00000127u, 0x00000002u, 0x00040048u, 0x00000127u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x00000127u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000129u, 0x00000018u, 0x00040047u, + 0x00000129u, 0x00000021u, 0x00000000u, 0x00040047u, 0x00000129u, 0x00000022u, 0x00000000u, 0x00040047u, + 0x00000355u, 0x0000000bu, 0x0000001au, 0x00050048u, 0x0000037cu, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00050048u, 0x0000037cu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x0000037cu, 0x00000002u, + 0x00000023u, 0x00000008u, 0x00050048u, 0x0000037cu, 0x00000003u, 0x00000023u, 0x00000010u, 0x00050048u, + 0x0000037cu, 0x00000004u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000037cu, 0x00000005u, 0x00000023u, + 0x00000018u, 0x00050048u, 0x0000037cu, 0x00000006u, 0x00000023u, 0x0000001cu, 0x00040047u, 0x0000037du, + 0x00000006u, 0x00000020u, 0x00030047u, 0x0000037eu, 0x00000002u, 0x00040048u, 0x0000037eu, 0x00000000u, + 0x00000018u, 0x00050048u, 0x0000037eu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000380u, + 0x00000018u, 0x00040047u, 0x00000380u, 0x00000021u, 0x0000000du, 0x00040047u, 0x00000380u, 0x00000022u, + 0x00000000u, 0x00040047u, 0x0000038au, 0x00000006u, 0x00000004u, 0x00050048u, 0x0000038bu, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00050048u, 0x0000038bu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, + 0x0000038bu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000038bu, 0x00000003u, 0x00000023u, + 0x0000000cu, 0x00050048u, 0x0000038bu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000038bu, + 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000038bu, 0x00000006u, 0x00000023u, 0x00000018u, + 0x00050048u, 0x0000038bu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000038bu, 0x00000008u, + 0x00000023u, 0x00000020u, 0x00050048u, 0x0000038bu, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, + 0x0000038bu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000038bu, 0x0000000bu, 0x00000023u, + 0x0000002cu, 0x00050048u, 0x0000038bu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00040047u, 0x0000038cu, + 0x00000006u, 0x00000080u, 0x00030047u, 0x0000038du, 0x00000002u, 0x00040048u, 0x0000038du, 0x00000000u, + 0x00000018u, 0x00050048u, 0x0000038du, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000038fu, + 0x00000018u, 0x00040047u, 0x0000038fu, 0x00000021u, 0x00000006u, 0x00040047u, 0x0000038fu, 0x00000022u, + 0x00000000u, 0x00050048u, 0x000003a2u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x000003a2u, + 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000003a2u, 0x00000002u, 0x00000023u, 0x00000008u, + 0x00050048u, 0x000003a2u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x000003a2u, 0x00000004u, + 0x00000023u, 0x00000010u, 0x00050048u, 0x000003a2u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, + 0x000003a2u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x000003a2u, 0x00000007u, 0x00000023u, + 0x0000001cu, 0x00050048u, 0x000003a2u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x000003a2u, + 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x000003a2u, 0x0000000au, 0x00000023u, 0x00000028u, + 0x00050048u, 0x000003a2u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x000003a2u, 0x0000000cu, + 0x00000023u, 0x00000030u, 0x00050048u, 0x000003a2u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, + 0x000003a2u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x000003a2u, 0x0000000fu, 0x00000023u, + 0x0000003cu, 0x00040047u, 0x000003a3u, 0x00000006u, 0x00000040u, 0x00030047u, 0x000003a4u, 0x00000002u, + 0x00040048u, 0x000003a4u, 0x00000000u, 0x00000018u, 0x00050048u, 0x000003a4u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x000003a6u, 0x00000018u, 0x00040047u, 0x000003a6u, 0x00000021u, 0x00000008u, + 0x00040047u, 0x000003a6u, 0x00000022u, 0x00000000u, 0x00040047u, 0x000003c9u, 0x00000006u, 0x00000004u, + 0x00030047u, 0x000003cau, 0x00000002u, 0x00040048u, 0x000003cau, 0x00000000u, 0x00000018u, 0x00050048u, + 0x000003cau, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000003ccu, 0x00000018u, 0x00040047u, + 0x000003ccu, 0x00000021u, 0x00000001u, 0x00040047u, 0x000003ccu, 0x00000022u, 0x00000000u, 0x00050048u, + 0x00000404u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000404u, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x00000404u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000404u, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000404u, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x00000404u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000404u, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x00000404u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x00000404u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000404u, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x00000404u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000404u, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000404u, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x00000404u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000404u, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x00000404u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, + 0x00000404u, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x00000404u, 0x00000011u, 0x00000023u, + 0x00000044u, 0x00040047u, 0x00000405u, 0x00000006u, 0x00000048u, 0x00030047u, 0x00000406u, 0x00000002u, + 0x00040048u, 0x00000406u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000406u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x00000408u, 0x00000018u, 0x00040047u, 0x00000408u, 0x00000021u, 0x0000000bu, + 0x00040047u, 0x00000408u, 0x00000022u, 0x00000000u, 0x00040048u, 0x00000413u, 0x00000000u, 0x00000005u, + 0x00050048u, 0x00000413u, 0x00000000u, 0x00000007u, 0x00000010u, 0x00050048u, 0x00000413u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00040047u, 0x00000414u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000415u, + 0x00000002u, 0x00040048u, 0x00000415u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000415u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x00000417u, 0x00000018u, 0x00040047u, 0x00000417u, 0x00000021u, + 0x0000000cu, 0x00040047u, 0x00000417u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000436u, 0x00000006u, + 0x00000004u, 0x00030047u, 0x00000437u, 0x00000002u, 0x00040048u, 0x00000437u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x00000437u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000439u, 0x00000018u, + 0x00040047u, 0x00000439u, 0x00000021u, 0x00000005u, 0x00040047u, 0x00000439u, 0x00000022u, 0x00000000u, + 0x00040047u, 0x000004d3u, 0x00000006u, 0x00000010u, 0x00030047u, 0x000004d4u, 0x00000002u, 0x00040048u, + 0x000004d4u, 0x00000000u, 0x00000018u, 0x00050048u, 0x000004d4u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x000004d6u, 0x00000018u, 0x00040047u, 0x000004d6u, 0x00000021u, 0x00000003u, 0x00040047u, + 0x000004d6u, 0x00000022u, 0x00000000u, 0x00050048u, 0x000004e0u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00050048u, 0x000004e0u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000004e0u, 0x00000002u, + 0x00000023u, 0x00000008u, 0x00050048u, 0x000004e0u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00040047u, + 0x000004e1u, 0x00000006u, 0x00000010u, 0x00030047u, 0x000004e2u, 0x00000002u, 0x00040048u, 0x000004e2u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x000004e2u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x000004e4u, 0x00000018u, 0x00040047u, 0x000004e4u, 0x00000021u, 0x00000002u, 0x00040047u, 0x000004e4u, + 0x00000022u, 0x00000000u, 0x00040047u, 0x0000058au, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000058bu, + 0x00000002u, 0x00040048u, 0x0000058bu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000058bu, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x0000058du, 0x00000018u, 0x00040047u, 0x0000058du, 0x00000021u, + 0x00000004u, 0x00040047u, 0x0000058du, 0x00000022u, 0x00000000u, 0x00050048u, 0x0000058eu, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00050048u, 0x0000058eu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, + 0x0000058eu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000058eu, 0x00000003u, 0x00000023u, + 0x0000000cu, 0x00050048u, 0x0000058eu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000058eu, + 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000058eu, 0x00000006u, 0x00000023u, 0x00000018u, + 0x00050048u, 0x0000058eu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000058eu, 0x00000008u, + 0x00000023u, 0x00000020u, 0x00050048u, 0x0000058eu, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, + 0x0000058eu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000058eu, 0x0000000bu, 0x00000023u, + 0x0000002cu, 0x00050048u, 0x0000058eu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x0000058eu, + 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000058eu, 0x0000000eu, 0x00000023u, 0x00000038u, + 0x00050048u, 0x0000058eu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x0000058fu, 0x00000006u, + 0x00000040u, 0x00030047u, 0x00000590u, 0x00000002u, 0x00040048u, 0x00000590u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x00000590u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000592u, 0x00000018u, + 0x00040047u, 0x00000592u, 0x00000021u, 0x00000007u, 0x00040047u, 0x00000592u, 0x00000022u, 0x00000000u, + 0x00050048u, 0x00000593u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000593u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000593u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000593u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000593u, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x00000593u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000593u, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000593u, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x00000593u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000593u, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x00000593u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x00000593u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000593u, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00050048u, 0x00000593u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000593u, + 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000593u, 0x0000000fu, 0x00000023u, 0x0000003cu, + 0x00040047u, 0x00000594u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000595u, 0x00000002u, 0x00040048u, + 0x00000595u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000595u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x00000597u, 0x00000018u, 0x00040047u, 0x00000597u, 0x00000021u, 0x00000009u, 0x00040047u, + 0x00000597u, 0x00000022u, 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, + 0x00040015u, 0x00000006u, 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000006u, 0x00000007u, 0x00000001u, + 0x00040020u, 0x00000008u, 0x00000007u, 0x00000006u, 0x00030016u, 0x00000009u, 0x00000020u, 0x00040017u, + 0x0000000au, 0x00000009u, 0x00000003u, 0x00040021u, 0x0000000bu, 0x0000000au, 0x00000008u, 0x00040015u, + 0x00000012u, 0x00000040u, 0x00000001u, 0x00040020u, 0x00000013u, 0x00000007u, 0x00000012u, 0x00040015u, + 0x00000014u, 0x00000020u, 0x00000001u, 0x00060021u, 0x00000015u, 0x00000014u, 0x00000008u, 0x00000008u, + 0x00000013u, 0x00040020u, 0x0000001bu, 0x00000007u, 0x0000000au, 0x00020014u, 0x0000001cu, 0x00070021u, + 0x0000001du, 0x0000001cu, 0x0000001bu, 0x0000001bu, 0x0000001bu, 0x0000001bu, 0x00040017u, 0x00000024u, + 0x00000009u, 0x00000004u, 0x00040018u, 0x00000025u, 0x00000024u, 0x00000004u, 0x0003001eu, 0x00000026u, + 0x00000025u, 0x00040020u, 0x00000027u, 0x00000007u, 0x00000026u, 0x00040021u, 0x00000028u, 0x0000000au, + 0x00000027u, 0x00040020u, 0x0000002cu, 0x00000007u, 0x00000025u, 0x0014001eu, 0x0000002du, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00040020u, 0x0000002eu, 0x00000007u, 0x0000002du, 0x00070021u, 0x0000002fu, 0x00000009u, + 0x0000001bu, 0x0000001bu, 0x0000002cu, 0x0000002eu, 0x00040020u, 0x00000036u, 0x00000007u, 0x00000009u, + 0x00080021u, 0x00000037u, 0x00000006u, 0x0000001bu, 0x0000001bu, 0x00000027u, 0x0000002eu, 0x00000036u, + 0x0004002bu, 0x00000006u, 0x00000040u, 0x00000000u, 0x0004002bu, 0x00000009u, 0x00000044u, 0x3f7dfdfeu, + 0x0004002bu, 0x00000009u, 0x00000045u, 0x3b808081u, 0x0004002bu, 0x00000009u, 0x00000046u, 0x3f68e8e9u, + 0x0006002cu, 0x0000000au, 0x00000047u, 0x00000044u, 0x00000045u, 0x00000046u, 0x0004002bu, 0x00000009u, + 0x0000004du, 0x3ec4c4c5u, 0x0004002bu, 0x00000009u, 0x0000004eu, 0x3f37b7b8u, 0x0004002bu, 0x00000009u, + 0x0000004fu, 0x3f79f9fau, 0x0006002cu, 0x0000000au, 0x00000050u, 0x0000004du, 0x0000004eu, 0x0000004fu, + 0x0004002bu, 0x00000006u, 0x00000053u, 0x00000002u, 0x0004002bu, 0x00000009u, 0x00000057u, 0x3f0b8b8cu, + 0x0004002bu, 0x00000009u, 0x00000058u, 0x3ebababbu, 0x0004002bu, 0x00000009u, 0x00000059u, 0x3f800000u, + 0x0006002cu, 0x0000000au, 0x0000005au, 0x00000057u, 0x00000058u, 0x00000059u, 0x0004002bu, 0x00000006u, + 0x0000005du, 0x00000003u, 0x0004002bu, 0x00000009u, 0x00000061u, 0x3ec8c8c9u, 0x0004002bu, 0x00000009u, + 0x00000062u, 0x00000000u, 0x0006002cu, 0x0000000au, 0x00000063u, 0x00000059u, 0x00000061u, 0x00000062u, + 0x0004002bu, 0x00000006u, 0x00000066u, 0x00000004u, 0x0006002cu, 0x0000000au, 0x0000006au, 0x00000062u, + 0x00000059u, 0x00000062u, 0x0004002bu, 0x00000006u, 0x0000006du, 0x00000007u, 0x0004002bu, 0x00000009u, + 0x00000071u, 0x3ed8d8d9u, 0x0004002bu, 0x00000009u, 0x00000072u, 0x3f33b3b4u, 0x0004002bu, 0x00000009u, + 0x00000073u, 0x3e6cecedu, 0x0006002cu, 0x0000000au, 0x00000074u, 0x00000071u, 0x00000072u, 0x00000073u, + 0x0004002bu, 0x00000006u, 0x00000077u, 0x00000008u, 0x0004002bu, 0x00000009u, 0x0000007bu, 0x3e8a8a8bu, + 0x0004002bu, 0x00000009u, 0x0000007cu, 0x3f31b1b2u, 0x0006002cu, 0x0000000au, 0x0000007du, 0x0000004eu, + 0x0000007bu, 0x0000007cu, 0x0004002bu, 0x00000006u, 0x00000080u, 0x00000009u, 0x0004002bu, 0x00000009u, + 0x00000084u, 0x3da0a0a1u, 0x0004002bu, 0x00000009u, 0x00000085u, 0x3f7efeffu, 0x0004002bu, 0x00000009u, + 0x00000086u, 0x3f39b9bau, 0x0006002cu, 0x0000000au, 0x00000087u, 0x00000084u, 0x00000085u, 0x00000086u, + 0x0004002bu, 0x00000006u, 0x0000008au, 0x0000000au, 0x0004002bu, 0x00000006u, 0x00000090u, 0x0000000bu, + 0x0006002cu, 0x0000000au, 0x00000094u, 0x00000061u, 0x00000061u, 0x00000061u, 0x0004002bu, 0x00000006u, + 0x00000097u, 0x0000000cu, 0x0004002bu, 0x00000009u, 0x0000009bu, 0x3d008081u, 0x0004002bu, 0x00000009u, + 0x0000009cu, 0x3c008081u, 0x0006002cu, 0x0000000au, 0x0000009du, 0x0000009bu, 0x0000009cu, 0x00000059u, + 0x0004002bu, 0x00000006u, 0x000000a0u, 0x0000000du, 0x0004002bu, 0x00000009u, 0x000000a4u, 0x3ea0a0a1u, + 0x0004002bu, 0x00000009u, 0x000000a5u, 0x3ef0f0f1u, 0x0006002cu, 0x0000000au, 0x000000a6u, 0x000000a4u, + 0x000000a4u, 0x000000a5u, 0x0004002bu, 0x00000006u, 0x000000a9u, 0x0000000eu, 0x0004002bu, 0x00000009u, + 0x000000adu, 0x3e70f0f1u, 0x0006002cu, 0x0000000au, 0x000000aeu, 0x000000adu, 0x000000a5u, 0x000000adu, + 0x0004002bu, 0x00000006u, 0x000000b1u, 0x0000000fu, 0x0006002cu, 0x0000000au, 0x000000b5u, 0x000000a5u, + 0x000000a4u, 0x000000a4u, 0x0004002bu, 0x00000006u, 0x000000b8u, 0x00000010u, 0x0006002cu, 0x0000000au, + 0x000000bcu, 0x00000059u, 0x00000059u, 0x00000059u, 0x0004002bu, 0x00000006u, 0x000000bfu, 0x00000011u, + 0x0004002bu, 0x00000006u, 0x000000c5u, 0x00000012u, 0x0006002cu, 0x0000000au, 0x000000c9u, 0x00000059u, + 0x00000059u, 0x00000062u, 0x0004002bu, 0x00000006u, 0x000000ccu, 0x00000013u, 0x0004002bu, 0x00000006u, + 0x000000d2u, 0x00000014u, 0x0004002bu, 0x00000006u, 0x000000d8u, 0x00000015u, 0x0019001eu, 0x000000dfu, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000014u, + 0x00000014u, 0x00000006u, 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000009u, 0x00000009u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, + 0x000000e0u, 0x00000009u, 0x000000dfu, 0x0004003bu, 0x000000e0u, 0x000000e1u, 0x00000009u, 0x0004002bu, + 0x00000014u, 0x000000e2u, 0x00000008u, 0x00040020u, 0x000000e3u, 0x00000009u, 0x00000014u, 0x0004002bu, + 0x00000014u, 0x000000e6u, 0x00000000u, 0x00040020u, 0x000000f2u, 0x00000007u, 0x00000024u, 0x0003001du, + 0x000000f4u, 0x00000024u, 0x0003001eu, 0x000000f5u, 0x000000f4u, 0x00040020u, 0x000000f6u, 0x0000000cu, + 0x000000f5u, 0x0004003bu, 0x000000f6u, 0x000000f7u, 0x0000000cu, 0x00040020u, 0x000000f9u, 0x0000000cu, + 0x00000024u, 0x0004002bu, 0x00000014u, 0x0000010du, 0xffffffffu, 0x00040020u, 0x0000010fu, 0x00000007u, + 0x00000014u, 0x0004002bu, 0x00000014u, 0x00000114u, 0x00000001u, 0x0004002bu, 0x00000014u, 0x00000123u, + 0x00000002u, 0x0003001du, 0x00000126u, 0x00000012u, 0x0003001eu, 0x00000127u, 0x00000126u, 0x00040020u, + 0x00000128u, 0x0000000cu, 0x00000127u, 0x0004003bu, 0x00000128u, 0x00000129u, 0x0000000cu, 0x00040020u, + 0x0000012eu, 0x0000000cu, 0x00000012u, 0x00040017u, 0x00000141u, 0x0000001cu, 0x00000003u, 0x00040018u, + 0x0000014du, 0x0000000au, 0x00000003u, 0x00040020u, 0x0000014eu, 0x00000007u, 0x0000014du, 0x0004002bu, + 0x00000014u, 0x00000162u, 0x00000003u, 0x0004002bu, 0x00000009u, 0x0000017fu, 0x3f000000u, 0x0004002bu, + 0x00000009u, 0x0000018du, 0x3a83126fu, 0x00040017u, 0x00000198u, 0x00000009u, 0x00000002u, 0x0004002bu, + 0x00000009u, 0x000001a4u, 0x2edbe6ffu, 0x0004002bu, 0x00000009u, 0x000001aau, 0xbf800000u, 0x0004002bu, + 0x00000014u, 0x000001b4u, 0x00000004u, 0x0004002bu, 0x00000014u, 0x000001b7u, 0x00000005u, 0x0004002bu, + 0x00000014u, 0x000001bdu, 0x00000006u, 0x0004002bu, 0x00000014u, 0x000001c3u, 0x00000007u, 0x0004002bu, + 0x00000014u, 0x000001d2u, 0x00000009u, 0x0004002bu, 0x00000014u, 0x000001ddu, 0x0000000au, 0x0004002bu, + 0x00000014u, 0x000001e3u, 0x0000000bu, 0x0004002bu, 0x00000014u, 0x000001eau, 0x0000000cu, 0x0004002bu, + 0x00000009u, 0x000001f1u, 0x358637bdu, 0x00040020u, 0x000001fbu, 0x00000007u, 0x00000198u, 0x0004002bu, + 0x00000014u, 0x00000202u, 0x0000000eu, 0x0004002bu, 0x00000014u, 0x00000208u, 0x0000000fu, 0x0004002bu, + 0x00000014u, 0x0000020fu, 0x00000010u, 0x0004002bu, 0x00000014u, 0x00000215u, 0x00000011u, 0x0004002bu, + 0x00000009u, 0x0000032au, 0x461c4000u, 0x0004002bu, 0x00000009u, 0x00000341u, 0x40000000u, 0x0004002bu, + 0x00000009u, 0x00000349u, 0x40800000u, 0x00040017u, 0x00000353u, 0x00000006u, 0x00000003u, 0x00040020u, + 0x00000354u, 0x00000001u, 0x00000353u, 0x0004003bu, 0x00000354u, 0x00000355u, 0x00000001u, 0x00040020u, + 0x00000356u, 0x00000001u, 0x00000006u, 0x0004002bu, 0x00000014u, 0x0000035bu, 0x00000013u, 0x00040020u, + 0x0000035cu, 0x00000009u, 0x00000006u, 0x0004002bu, 0x00000014u, 0x00000367u, 0x00000012u, 0x0009001eu, + 0x00000379u, 0x00000006u, 0x00000006u, 0x00000012u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00040020u, 0x0000037au, 0x00000007u, 0x00000379u, 0x0009001eu, 0x0000037cu, 0x00000006u, 0x00000006u, + 0x00000012u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x0000037du, 0x0000037cu, + 0x0003001eu, 0x0000037eu, 0x0000037du, 0x00040020u, 0x0000037fu, 0x0000000cu, 0x0000037eu, 0x0004003bu, + 0x0000037fu, 0x00000380u, 0x0000000cu, 0x00040020u, 0x00000382u, 0x0000000cu, 0x0000037cu, 0x0004001cu, + 0x00000386u, 0x00000006u, 0x000000d2u, 0x000f001eu, 0x00000387u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000386u, 0x00040020u, 0x00000388u, 0x00000007u, 0x00000387u, 0x0004001cu, 0x0000038au, + 0x00000006u, 0x000000d2u, 0x000f001eu, 0x0000038bu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x0000038au, 0x0003001du, 0x0000038cu, 0x0000038bu, 0x0003001eu, 0x0000038du, 0x0000038cu, 0x00040020u, + 0x0000038eu, 0x0000000cu, 0x0000038du, 0x0004003bu, 0x0000038eu, 0x0000038fu, 0x0000000cu, 0x00040020u, + 0x00000392u, 0x0000000cu, 0x0000038bu, 0x0012001eu, 0x0000039fu, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x000003a0u, 0x00000007u, + 0x0000039fu, 0x0012001eu, 0x000003a2u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x000003a3u, 0x000003a2u, 0x0003001eu, 0x000003a4u, + 0x000003a3u, 0x00040020u, 0x000003a5u, 0x0000000cu, 0x000003a4u, 0x0004003bu, 0x000003a5u, 0x000003a6u, + 0x0000000cu, 0x00040020u, 0x000003abu, 0x0000000cu, 0x000003a2u, 0x0003001du, 0x000003c9u, 0x00000014u, + 0x0003001eu, 0x000003cau, 0x000003c9u, 0x00040020u, 0x000003cbu, 0x0000000cu, 0x000003cau, 0x0004003bu, + 0x000003cbu, 0x000003ccu, 0x0000000cu, 0x00040020u, 0x000003d6u, 0x0000000cu, 0x00000014u, 0x00040020u, + 0x000003eau, 0x00000007u, 0x0000001cu, 0x0003002au, 0x0000001cu, 0x000003ecu, 0x00030029u, 0x0000001cu, + 0x000003f2u, 0x00040020u, 0x000003f7u, 0x00000009u, 0x00000009u, 0x0014001eu, 0x00000404u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x0003001du, 0x00000405u, 0x00000404u, 0x0003001eu, 0x00000406u, 0x00000405u, 0x00040020u, + 0x00000407u, 0x0000000cu, 0x00000406u, 0x0004003bu, 0x00000407u, 0x00000408u, 0x0000000cu, 0x0004002bu, + 0x00000014u, 0x0000040bu, 0x0000000du, 0x00040020u, 0x0000040cu, 0x0000000cu, 0x00000009u, 0x0003001eu, + 0x00000413u, 0x00000025u, 0x0003001du, 0x00000414u, 0x00000413u, 0x0003001eu, 0x00000415u, 0x00000414u, + 0x00040020u, 0x00000416u, 0x0000000cu, 0x00000415u, 0x0004003bu, 0x00000416u, 0x00000417u, 0x0000000cu, + 0x00040020u, 0x00000419u, 0x0000000cu, 0x00000413u, 0x0004002bu, 0x00000006u, 0x00000432u, 0x00000006u, + 0x0003001du, 0x00000436u, 0x00000009u, 0x0003001eu, 0x00000437u, 0x00000436u, 0x00040020u, 0x00000438u, + 0x0000000cu, 0x00000437u, 0x0004003bu, 0x00000438u, 0x00000439u, 0x0000000cu, 0x0004002bu, 0x00000006u, + 0x00000450u, 0x00000005u, 0x00040020u, 0x000004a6u, 0x0000000cu, 0x00000404u, 0x00040020u, 0x000004d1u, + 0x00000007u, 0x00000353u, 0x0003001du, 0x000004d3u, 0x00000353u, 0x0003001eu, 0x000004d4u, 0x000004d3u, + 0x00040020u, 0x000004d5u, 0x0000000cu, 0x000004d4u, 0x0004003bu, 0x000004d5u, 0x000004d6u, 0x0000000cu, + 0x00040020u, 0x000004dau, 0x0000000cu, 0x00000353u, 0x0006001eu, 0x000004ddu, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00040020u, 0x000004deu, 0x00000007u, 0x000004ddu, 0x0006001eu, 0x000004e0u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x0003001du, 0x000004e1u, 0x000004e0u, 0x0003001eu, + 0x000004e2u, 0x000004e1u, 0x00040020u, 0x000004e3u, 0x0000000cu, 0x000004e2u, 0x0004003bu, 0x000004e3u, + 0x000004e4u, 0x0000000cu, 0x00040020u, 0x000004e9u, 0x0000000cu, 0x000004e0u, 0x0004002bu, 0x00000006u, + 0x00000546u, 0x0000001eu, 0x000a001eu, 0x00000568u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x0000000au, 0x00000009u, 0x00040020u, 0x00000569u, 0x0000151au, 0x00000568u, + 0x0004003bu, 0x00000569u, 0x0000056au, 0x0000151au, 0x00040020u, 0x0000056cu, 0x0000151au, 0x00000006u, + 0x00040020u, 0x0000057cu, 0x0000151au, 0x0000000au, 0x00040020u, 0x00000582u, 0x0000151au, 0x00000009u, + 0x0004002bu, 0x00000009u, 0x00000586u, 0x40e00000u, 0x0004002bu, 0x00000009u, 0x00000587u, 0x41400000u, + 0x0004002bu, 0x00000009u, 0x00000588u, 0x40a00000u, 0x0004002bu, 0x00000009u, 0x00000589u, 0x40400000u, + 0x0003001du, 0x0000058au, 0x00000413u, 0x0003001eu, 0x0000058bu, 0x0000058au, 0x00040020u, 0x0000058cu, + 0x0000000cu, 0x0000058bu, 0x0004003bu, 0x0000058cu, 0x0000058du, 0x0000000cu, 0x0012001eu, 0x0000058eu, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x0003001du, 0x0000058fu, 0x0000058eu, 0x0003001eu, 0x00000590u, 0x0000058fu, 0x00040020u, 0x00000591u, + 0x0000000cu, 0x00000590u, 0x0004003bu, 0x00000591u, 0x00000592u, 0x0000000cu, 0x0012001eu, 0x00000593u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x0003001du, 0x00000594u, 0x00000593u, 0x0003001eu, 0x00000595u, 0x00000594u, 0x00040020u, 0x00000596u, + 0x0000000cu, 0x00000595u, 0x0004003bu, 0x00000596u, 0x00000597u, 0x0000000cu, 0x0006002cu, 0x00000353u, + 0x00000598u, 0x00000007u, 0x00000007u, 0x00000007u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, + 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000008u, 0x00000351u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x00000352u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000359u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x00000360u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000365u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x0000036bu, 0x00000007u, 0x0004003bu, 0x0000037au, 0x0000037bu, 0x00000007u, 0x0004003bu, + 0x00000388u, 0x00000389u, 0x00000007u, 0x0004003bu, 0x000003a0u, 0x000003a1u, 0x00000007u, 0x0004003bu, + 0x0000010fu, 0x000003afu, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000003b5u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000003b6u, 0x00000007u, 0x0004003bu, 0x00000013u, 0x000003b9u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000003c4u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000003dau, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000003e6u, 0x00000007u, 0x0004003bu, 0x000003eau, 0x000003ebu, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000003f3u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000403u, 0x00000007u, 0x0004003bu, + 0x00000027u, 0x00000412u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000041du, 0x00000007u, 0x0004003bu, + 0x00000027u, 0x0000041eu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000421u, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000426u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x0000042bu, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000435u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000446u, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000455u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000457u, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000459u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000045bu, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x00000461u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000471u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x0000047cu, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000484u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x00000494u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x0000049fu, 0x00000007u, 0x0004003bu, + 0x0000002eu, 0x000004a3u, 0x00000007u, 0x0004003bu, 0x00000027u, 0x000004aau, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000004afu, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000004b5u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000004bdu, 0x00000007u, 0x0004003bu, 0x00000008u, 0x000004c5u, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x000004c8u, 0x00000007u, 0x0004003bu, 0x000004d1u, 0x000004d2u, 0x00000007u, 0x0004003bu, + 0x000004deu, 0x000004dfu, 0x00000007u, 0x0004003bu, 0x000004deu, 0x000004edu, 0x00000007u, 0x0004003bu, + 0x000004deu, 0x000004f5u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000004fdu, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000505u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000050du, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000516u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000518u, 0x00000007u, 0x0004003bu, + 0x00000027u, 0x0000051au, 0x00000007u, 0x0004003bu, 0x0000002eu, 0x0000051cu, 0x00000007u, 0x0004003bu, + 0x00000036u, 0x0000051eu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000524u, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000526u, 0x00000007u, 0x0004003bu, 0x00000027u, 0x00000528u, 0x00000007u, 0x0004003bu, + 0x0000002eu, 0x0000052au, 0x00000007u, 0x0004003bu, 0x00000036u, 0x0000052cu, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000532u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000534u, 0x00000007u, 0x0004003bu, + 0x00000027u, 0x00000536u, 0x00000007u, 0x0004003bu, 0x0000002eu, 0x00000538u, 0x00000007u, 0x0004003bu, + 0x00000036u, 0x0000053au, 0x00000007u, 0x0004003bu, 0x00000008u, 0x0000054bu, 0x00000007u, 0x0004003bu, + 0x00000008u, 0x00000551u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000578u, 0x00000007u, 0x0003003eu, + 0x00000351u, 0x00000040u, 0x00050041u, 0x00000356u, 0x00000357u, 0x00000355u, 0x00000040u, 0x0004003du, + 0x00000006u, 0x00000358u, 0x00000357u, 0x0003003eu, 0x00000352u, 0x00000358u, 0x0004003du, 0x00000006u, + 0x0000035au, 0x00000352u, 0x00050041u, 0x0000035cu, 0x0000035du, 0x000000e1u, 0x0000035bu, 0x0004003du, + 0x00000006u, 0x0000035eu, 0x0000035du, 0x00050089u, 0x00000006u, 0x0000035fu, 0x0000035au, 0x0000035eu, + 0x0003003eu, 0x00000359u, 0x0000035fu, 0x0004003du, 0x00000006u, 0x00000361u, 0x00000352u, 0x00050041u, + 0x0000035cu, 0x00000362u, 0x000000e1u, 0x0000035bu, 0x0004003du, 0x00000006u, 0x00000363u, 0x00000362u, + 0x00050086u, 0x00000006u, 0x00000364u, 0x00000361u, 0x00000363u, 0x0003003eu, 0x00000360u, 0x00000364u, + 0x0004003du, 0x00000006u, 0x00000366u, 0x00000360u, 0x00050041u, 0x0000035cu, 0x00000368u, 0x000000e1u, + 0x00000367u, 0x0004003du, 0x00000006u, 0x00000369u, 0x00000368u, 0x00050089u, 0x00000006u, 0x0000036au, + 0x00000366u, 0x00000369u, 0x0003003eu, 0x00000365u, 0x0000036au, 0x0004003du, 0x00000006u, 0x0000036cu, + 0x00000360u, 0x00050041u, 0x0000035cu, 0x0000036du, 0x000000e1u, 0x00000367u, 0x0004003du, 0x00000006u, + 0x0000036eu, 0x0000036du, 0x00050086u, 0x00000006u, 0x0000036fu, 0x0000036cu, 0x0000036eu, 0x0003003eu, + 0x0000036bu, 0x0000036fu, 0x0004003du, 0x00000006u, 0x00000370u, 0x0000036bu, 0x00050041u, 0x0000035cu, + 0x00000371u, 0x000000e1u, 0x000001d2u, 0x0004003du, 0x00000006u, 0x00000372u, 0x00000371u, 0x000500aeu, + 0x0000001cu, 0x00000373u, 0x00000370u, 0x00000372u, 0x000300f7u, 0x00000375u, 0x00000000u, 0x000400fau, + 0x00000373u, 0x00000374u, 0x00000375u, 0x000200f8u, 0x00000374u, 0x0003003eu, 0x00000351u, 0x00000040u, + 0x0004003du, 0x00000006u, 0x00000376u, 0x00000351u, 0x000414aeu, 0x00000376u, 0x00000007u, 0x00000007u, + 0x000200f8u, 0x00000375u, 0x0004003du, 0x00000006u, 0x00000381u, 0x0000036bu, 0x00060041u, 0x00000382u, + 0x00000383u, 0x00000380u, 0x000000e6u, 0x00000381u, 0x0004003du, 0x0000037cu, 0x00000384u, 0x00000383u, + 0x00040190u, 0x00000379u, 0x00000385u, 0x00000384u, 0x0003003eu, 0x0000037bu, 0x00000385u, 0x00050041u, + 0x00000008u, 0x00000390u, 0x0000037bu, 0x000000e6u, 0x0004003du, 0x00000006u, 0x00000391u, 0x00000390u, + 0x00060041u, 0x00000392u, 0x00000393u, 0x0000038fu, 0x000000e6u, 0x00000391u, 0x0004003du, 0x0000038bu, + 0x00000394u, 0x00000393u, 0x00040190u, 0x00000387u, 0x00000395u, 0x00000394u, 0x0003003eu, 0x00000389u, + 0x00000395u, 0x0004003du, 0x00000006u, 0x00000396u, 0x00000365u, 0x00050041u, 0x00000008u, 0x00000397u, + 0x00000389u, 0x00000123u, 0x0004003du, 0x00000006u, 0x00000398u, 0x00000397u, 0x000500aeu, 0x0000001cu, + 0x00000399u, 0x00000396u, 0x00000398u, 0x000300f7u, 0x0000039bu, 0x00000000u, 0x000400fau, 0x00000399u, + 0x0000039au, 0x0000039bu, 0x000200f8u, 0x0000039au, 0x0003003eu, 0x00000351u, 0x00000040u, 0x0004003du, + 0x00000006u, 0x0000039cu, 0x00000351u, 0x000414aeu, 0x0000039cu, 0x00000007u, 0x00000007u, 0x000200f8u, + 0x0000039bu, 0x00050041u, 0x00000008u, 0x000003a7u, 0x00000389u, 0x00000162u, 0x0004003du, 0x00000006u, + 0x000003a8u, 0x000003a7u, 0x0004003du, 0x00000006u, 0x000003a9u, 0x00000365u, 0x00050080u, 0x00000006u, + 0x000003aau, 0x000003a8u, 0x000003a9u, 0x00060041u, 0x000003abu, 0x000003acu, 0x000003a6u, 0x000000e6u, + 0x000003aau, 0x0004003du, 0x000003a2u, 0x000003adu, 0x000003acu, 0x00040190u, 0x0000039fu, 0x000003aeu, + 0x000003adu, 0x0003003eu, 0x000003a1u, 0x000003aeu, 0x00050041u, 0x00000008u, 0x000003b0u, 0x00000389u, + 0x000001bdu, 0x0004003du, 0x00000006u, 0x000003b1u, 0x000003b0u, 0x00050041u, 0x00000008u, 0x000003b2u, + 0x000003a1u, 0x000001b7u, 0x0004003du, 0x00000006u, 0x000003b3u, 0x000003b2u, 0x00050080u, 0x00000006u, + 0x000003b4u, 0x000003b1u, 0x000003b3u, 0x0003003eu, 0x000003b5u, 0x000003b4u, 0x00050041u, 0x00000008u, + 0x000003b7u, 0x000003a1u, 0x000000e6u, 0x0004003du, 0x00000006u, 0x000003b8u, 0x000003b7u, 0x0003003eu, + 0x000003b6u, 0x000003b8u, 0x00050041u, 0x00000013u, 0x000003bau, 0x0000037bu, 0x00000123u, 0x0004003du, + 0x00000012u, 0x000003bbu, 0x000003bau, 0x0003003eu, 0x000003b9u, 0x000003bbu, 0x00070039u, 0x00000014u, + 0x000003bcu, 0x00000019u, 0x000003b5u, 0x000003b6u, 0x000003b9u, 0x0003003eu, 0x000003afu, 0x000003bcu, + 0x0004003du, 0x00000014u, 0x000003bdu, 0x000003afu, 0x000500b1u, 0x0000001cu, 0x000003beu, 0x000003bdu, + 0x000000e6u, 0x000300f7u, 0x000003c0u, 0x00000000u, 0x000400fau, 0x000003beu, 0x000003bfu, 0x000003c0u, + 0x000200f8u, 0x000003bfu, 0x0003003eu, 0x00000351u, 0x00000040u, 0x0004003du, 0x00000006u, 0x000003c1u, + 0x00000351u, 0x000414aeu, 0x000003c1u, 0x00000007u, 0x00000007u, 0x000200f8u, 0x000003c0u, 0x0003003eu, + 0x000003c4u, 0x00000040u, 0x0004003du, 0x00000014u, 0x000003c5u, 0x000003afu, 0x000500adu, 0x0000001cu, + 0x000003c6u, 0x000003c5u, 0x000000e6u, 0x000300f7u, 0x000003c8u, 0x00000000u, 0x000400fau, 0x000003c6u, + 0x000003c7u, 0x000003c8u, 0x000200f8u, 0x000003c7u, 0x00050041u, 0x00000008u, 0x000003cdu, 0x00000389u, + 0x000001c3u, 0x0004003du, 0x00000006u, 0x000003ceu, 0x000003cdu, 0x00050041u, 0x00000008u, 0x000003cfu, + 0x000003a1u, 0x000001bdu, 0x0004003du, 0x00000006u, 0x000003d0u, 0x000003cfu, 0x00050080u, 0x00000006u, + 0x000003d1u, 0x000003ceu, 0x000003d0u, 0x0004003du, 0x00000014u, 0x000003d2u, 0x000003afu, 0x0004007cu, + 0x00000006u, 0x000003d3u, 0x000003d2u, 0x00050080u, 0x00000006u, 0x000003d4u, 0x000003d1u, 0x000003d3u, + 0x00050082u, 0x00000006u, 0x000003d5u, 0x000003d4u, 0x00000007u, 0x00060041u, 0x000003d6u, 0x000003d7u, + 0x000003ccu, 0x000000e6u, 0x000003d5u, 0x0004003du, 0x00000014u, 0x000003d8u, 0x000003d7u, 0x0004007cu, + 0x00000006u, 0x000003d9u, 0x000003d8u, 0x0003003eu, 0x000003c4u, 0x000003d9u, 0x000200f9u, 0x000003c8u, + 0x000200f8u, 0x000003c8u, 0x00050041u, 0x00000008u, 0x000003dbu, 0x00000389u, 0x000001c3u, 0x0004003du, + 0x00000006u, 0x000003dcu, 0x000003dbu, 0x00050041u, 0x00000008u, 0x000003ddu, 0x000003a1u, 0x000001bdu, + 0x0004003du, 0x00000006u, 0x000003deu, 0x000003ddu, 0x00050080u, 0x00000006u, 0x000003dfu, 0x000003dcu, + 0x000003deu, 0x0004003du, 0x00000014u, 0x000003e0u, 0x000003afu, 0x0004007cu, 0x00000006u, 0x000003e1u, + 0x000003e0u, 0x00050080u, 0x00000006u, 0x000003e2u, 0x000003dfu, 0x000003e1u, 0x00060041u, 0x000003d6u, + 0x000003e3u, 0x000003ccu, 0x000000e6u, 0x000003e2u, 0x0004003du, 0x00000014u, 0x000003e4u, 0x000003e3u, + 0x0004007cu, 0x00000006u, 0x000003e5u, 0x000003e4u, 0x0003003eu, 0x000003dau, 0x000003e5u, 0x0004003du, + 0x00000006u, 0x000003e7u, 0x000003dau, 0x0004003du, 0x00000006u, 0x000003e8u, 0x000003c4u, 0x00050082u, + 0x00000006u, 0x000003e9u, 0x000003e7u, 0x000003e8u, 0x0003003eu, 0x000003e6u, 0x000003e9u, 0x0003003eu, + 0x000003ebu, 0x000003ecu, 0x0004003du, 0x00000006u, 0x000003edu, 0x00000359u, 0x0004003du, 0x00000006u, + 0x000003eeu, 0x000003e6u, 0x000500aeu, 0x0000001cu, 0x000003efu, 0x000003edu, 0x000003eeu, 0x000300f7u, + 0x000003f1u, 0x00000000u, 0x000400fau, 0x000003efu, 0x000003f0u, 0x000003f1u, 0x000200f8u, 0x000003f0u, + 0x0003003eu, 0x000003ebu, 0x000003f2u, 0x0003003eu, 0x00000359u, 0x00000040u, 0x000200f9u, 0x000003f1u, + 0x000200f8u, 0x000003f1u, 0x0004003du, 0x00000006u, 0x000003f4u, 0x000003c4u, 0x0004003du, 0x00000006u, + 0x000003f5u, 0x00000359u, 0x00050080u, 0x00000006u, 0x000003f6u, 0x000003f4u, 0x000003f5u, 0x0003003eu, + 0x000003f3u, 0x000003f6u, 0x00050041u, 0x000003f7u, 0x000003f8u, 0x000000e1u, 0x00000202u, 0x0004003du, + 0x00000009u, 0x000003f9u, 0x000003f8u, 0x000500bau, 0x0000001cu, 0x000003fau, 0x000003f9u, 0x00000062u, + 0x000300f7u, 0x000003fcu, 0x00000000u, 0x000400fau, 0x000003fau, 0x000003fbu, 0x000003fcu, 0x000200f8u, + 0x000003fbu, 0x00050041u, 0x00000008u, 0x000003fdu, 0x000003a1u, 0x000001e3u, 0x0004003du, 0x00000006u, + 0x000003feu, 0x000003fdu, 0x000500abu, 0x0000001cu, 0x000003ffu, 0x000003feu, 0x00000040u, 0x000200f9u, + 0x000003fcu, 0x000200f8u, 0x000003fcu, 0x000700f5u, 0x0000001cu, 0x00000400u, 0x000003fau, 0x000003f1u, + 0x000003ffu, 0x000003fbu, 0x000300f7u, 0x00000402u, 0x00000000u, 0x000400fau, 0x00000400u, 0x00000401u, + 0x00000402u, 0x000200f8u, 0x00000401u, 0x00050041u, 0x00000008u, 0x00000409u, 0x0000037bu, 0x00000114u, + 0x0004003du, 0x00000006u, 0x0000040au, 0x00000409u, 0x00070041u, 0x0000040cu, 0x0000040du, 0x00000408u, + 0x000000e6u, 0x0000040au, 0x0000040bu, 0x0004003du, 0x00000009u, 0x0000040eu, 0x0000040du, 0x00050041u, + 0x000003f7u, 0x0000040fu, 0x000000e1u, 0x00000202u, 0x0004003du, 0x00000009u, 0x00000410u, 0x0000040fu, + 0x00050085u, 0x00000009u, 0x00000411u, 0x0000040eu, 0x00000410u, 0x0003003eu, 0x00000403u, 0x00000411u, + 0x0004003du, 0x00000006u, 0x00000418u, 0x0000036bu, 0x00060041u, 0x00000419u, 0x0000041au, 0x00000417u, + 0x000000e6u, 0x00000418u, 0x0004003du, 0x00000413u, 0x0000041bu, 0x0000041au, 0x00040190u, 0x00000026u, + 0x0000041cu, 0x0000041bu, 0x0003003eu, 0x00000412u, 0x0000041cu, 0x0004003du, 0x00000026u, 0x0000041fu, + 0x00000412u, 0x0003003eu, 0x0000041eu, 0x0000041fu, 0x00050039u, 0x0000000au, 0x00000420u, 0x0000002au, + 0x0000041eu, 0x0003003eu, 0x0000041du, 0x00000420u, 0x0004003du, 0x0000000au, 0x00000422u, 0x0000041du, + 0x0004003du, 0x00000009u, 0x00000423u, 0x00000403u, 0x00060050u, 0x0000000au, 0x00000424u, 0x00000423u, + 0x00000423u, 0x00000423u, 0x00050083u, 0x0000000au, 0x00000425u, 0x00000422u, 0x00000424u, 0x0003003eu, + 0x00000421u, 0x00000425u, 0x0004003du, 0x0000000au, 0x00000427u, 0x0000041du, 0x0004003du, 0x00000009u, + 0x00000428u, 0x00000403u, 0x00060050u, 0x0000000au, 0x00000429u, 0x00000428u, 0x00000428u, 0x00000428u, + 0x00050081u, 0x0000000au, 0x0000042au, 0x00000427u, 0x00000429u, 0x0003003eu, 0x00000426u, 0x0000042au, + 0x00050041u, 0x00000008u, 0x0000042cu, 0x00000389u, 0x000001e3u, 0x0004003du, 0x00000006u, 0x0000042du, + 0x0000042cu, 0x00050041u, 0x00000008u, 0x0000042eu, 0x000003a1u, 0x000001e3u, 0x0004003du, 0x00000006u, + 0x0000042fu, 0x0000042eu, 0x00050080u, 0x00000006u, 0x00000430u, 0x0000042du, 0x0000042fu, 0x0004003du, + 0x00000006u, 0x00000431u, 0x000003f3u, 0x00050084u, 0x00000006u, 0x00000433u, 0x00000431u, 0x00000432u, + 0x00050080u, 0x00000006u, 0x00000434u, 0x00000430u, 0x00000433u, 0x0003003eu, 0x0000042bu, 0x00000434u, + 0x0004003du, 0x00000006u, 0x0000043au, 0x0000042bu, 0x00060041u, 0x0000040cu, 0x0000043bu, 0x00000439u, + 0x000000e6u, 0x0000043au, 0x0004003du, 0x00000009u, 0x0000043cu, 0x0000043bu, 0x0004003du, 0x00000006u, + 0x0000043du, 0x0000042bu, 0x00050080u, 0x00000006u, 0x0000043eu, 0x0000043du, 0x00000007u, 0x00060041u, + 0x0000040cu, 0x0000043fu, 0x00000439u, 0x000000e6u, 0x0000043eu, 0x0004003du, 0x00000009u, 0x00000440u, + 0x0000043fu, 0x0004003du, 0x00000006u, 0x00000441u, 0x0000042bu, 0x00050080u, 0x00000006u, 0x00000442u, + 0x00000441u, 0x00000053u, 0x00060041u, 0x0000040cu, 0x00000443u, 0x00000439u, 0x000000e6u, 0x00000442u, + 0x0004003du, 0x00000009u, 0x00000444u, 0x00000443u, 0x00060050u, 0x0000000au, 0x00000445u, 0x0000043cu, + 0x00000440u, 0x00000444u, 0x0003003eu, 0x00000435u, 0x00000445u, 0x0004003du, 0x00000006u, 0x00000447u, + 0x0000042bu, 0x00050080u, 0x00000006u, 0x00000448u, 0x00000447u, 0x0000005du, 0x00060041u, 0x0000040cu, + 0x00000449u, 0x00000439u, 0x000000e6u, 0x00000448u, 0x0004003du, 0x00000009u, 0x0000044au, 0x00000449u, + 0x0004003du, 0x00000006u, 0x0000044bu, 0x0000042bu, 0x00050080u, 0x00000006u, 0x0000044cu, 0x0000044bu, + 0x00000066u, 0x00060041u, 0x0000040cu, 0x0000044du, 0x00000439u, 0x000000e6u, 0x0000044cu, 0x0004003du, + 0x00000009u, 0x0000044eu, 0x0000044du, 0x0004003du, 0x00000006u, 0x0000044fu, 0x0000042bu, 0x00050080u, + 0x00000006u, 0x00000451u, 0x0000044fu, 0x00000450u, 0x00060041u, 0x0000040cu, 0x00000452u, 0x00000439u, + 0x000000e6u, 0x00000451u, 0x0004003du, 0x00000009u, 0x00000453u, 0x00000452u, 0x00060050u, 0x0000000au, + 0x00000454u, 0x0000044au, 0x0000044eu, 0x00000453u, 0x0003003eu, 0x00000446u, 0x00000454u, 0x0004003du, + 0x0000000au, 0x00000456u, 0x00000435u, 0x0003003eu, 0x00000455u, 0x00000456u, 0x0004003du, 0x0000000au, + 0x00000458u, 0x00000446u, 0x0003003eu, 0x00000457u, 0x00000458u, 0x0004003du, 0x0000000au, 0x0000045au, + 0x00000421u, 0x0003003eu, 0x00000459u, 0x0000045au, 0x0004003du, 0x0000000au, 0x0000045cu, 0x00000426u, + 0x0003003eu, 0x0000045bu, 0x0000045cu, 0x00080039u, 0x0000001cu, 0x0000045du, 0x00000022u, 0x00000455u, + 0x00000457u, 0x00000459u, 0x0000045bu, 0x000400a8u, 0x0000001cu, 0x0000045eu, 0x0000045du, 0x000300f7u, + 0x00000460u, 0x00000000u, 0x000400fau, 0x0000045eu, 0x0000045fu, 0x00000460u, 0x000200f8u, 0x0000045fu, + 0x0003003eu, 0x000003ebu, 0x000003f2u, 0x000200f9u, 0x00000460u, 0x000200f8u, 0x00000460u, 0x000200f9u, + 0x00000402u, 0x000200f8u, 0x00000402u, 0x0003003eu, 0x00000461u, 0x00000040u, 0x0004003du, 0x00000006u, + 0x00000462u, 0x000003f3u, 0x000500acu, 0x0000001cu, 0x00000463u, 0x00000462u, 0x00000040u, 0x000300f7u, + 0x00000465u, 0x00000000u, 0x000400fau, 0x00000463u, 0x00000464u, 0x00000465u, 0x000200f8u, 0x00000464u, + 0x00050041u, 0x00000008u, 0x00000466u, 0x00000389u, 0x000001c3u, 0x0004003du, 0x00000006u, 0x00000467u, + 0x00000466u, 0x00050041u, 0x00000008u, 0x00000468u, 0x000003a1u, 0x000000e2u, 0x0004003du, 0x00000006u, + 0x00000469u, 0x00000468u, 0x00050080u, 0x00000006u, 0x0000046au, 0x00000467u, 0x00000469u, 0x0004003du, + 0x00000006u, 0x0000046bu, 0x000003f3u, 0x00050080u, 0x00000006u, 0x0000046cu, 0x0000046au, 0x0000046bu, + 0x00050082u, 0x00000006u, 0x0000046du, 0x0000046cu, 0x00000007u, 0x00060041u, 0x000003d6u, 0x0000046eu, + 0x000003ccu, 0x000000e6u, 0x0000046du, 0x0004003du, 0x00000014u, 0x0000046fu, 0x0000046eu, 0x0004007cu, + 0x00000006u, 0x00000470u, 0x0000046fu, 0x0003003eu, 0x00000461u, 0x00000470u, 0x000200f9u, 0x00000465u, + 0x000200f8u, 0x00000465u, 0x00050041u, 0x00000008u, 0x00000472u, 0x00000389u, 0x000001c3u, 0x0004003du, + 0x00000006u, 0x00000473u, 0x00000472u, 0x00050041u, 0x00000008u, 0x00000474u, 0x000003a1u, 0x000000e2u, + 0x0004003du, 0x00000006u, 0x00000475u, 0x00000474u, 0x00050080u, 0x00000006u, 0x00000476u, 0x00000473u, + 0x00000475u, 0x0004003du, 0x00000006u, 0x00000477u, 0x000003f3u, 0x00050080u, 0x00000006u, 0x00000478u, + 0x00000476u, 0x00000477u, 0x00060041u, 0x000003d6u, 0x00000479u, 0x000003ccu, 0x000000e6u, 0x00000478u, + 0x0004003du, 0x00000014u, 0x0000047au, 0x00000479u, 0x0004007cu, 0x00000006u, 0x0000047bu, 0x0000047au, + 0x0003003eu, 0x00000471u, 0x0000047bu, 0x0004003du, 0x00000006u, 0x0000047du, 0x00000471u, 0x0004003du, + 0x00000006u, 0x0000047eu, 0x00000461u, 0x00050082u, 0x00000006u, 0x0000047fu, 0x0000047du, 0x0000047eu, + 0x0003003eu, 0x0000047cu, 0x0000047fu, 0x0004003du, 0x00000006u, 0x00000480u, 0x0000047cu, 0x000500aau, + 0x0000001cu, 0x00000481u, 0x00000480u, 0x00000040u, 0x000300f7u, 0x00000483u, 0x00000000u, 0x000400fau, + 0x00000481u, 0x00000482u, 0x00000483u, 0x000200f8u, 0x00000482u, 0x0003003eu, 0x000003ebu, 0x000003f2u, + 0x000200f9u, 0x00000483u, 0x000200f8u, 0x00000483u, 0x0003003eu, 0x00000484u, 0x00000040u, 0x0004003du, + 0x00000006u, 0x00000485u, 0x000003f3u, 0x000500acu, 0x0000001cu, 0x00000486u, 0x00000485u, 0x00000040u, + 0x000300f7u, 0x00000488u, 0x00000000u, 0x000400fau, 0x00000486u, 0x00000487u, 0x00000488u, 0x000200f8u, + 0x00000487u, 0x00050041u, 0x00000008u, 0x00000489u, 0x00000389u, 0x000001c3u, 0x0004003du, 0x00000006u, + 0x0000048au, 0x00000489u, 0x00050041u, 0x00000008u, 0x0000048bu, 0x000003a1u, 0x000001c3u, 0x0004003du, + 0x00000006u, 0x0000048cu, 0x0000048bu, 0x00050080u, 0x00000006u, 0x0000048du, 0x0000048au, 0x0000048cu, + 0x0004003du, 0x00000006u, 0x0000048eu, 0x000003f3u, 0x00050080u, 0x00000006u, 0x0000048fu, 0x0000048du, + 0x0000048eu, 0x00050082u, 0x00000006u, 0x00000490u, 0x0000048fu, 0x00000007u, 0x00060041u, 0x000003d6u, + 0x00000491u, 0x000003ccu, 0x000000e6u, 0x00000490u, 0x0004003du, 0x00000014u, 0x00000492u, 0x00000491u, + 0x0004007cu, 0x00000006u, 0x00000493u, 0x00000492u, 0x0003003eu, 0x00000484u, 0x00000493u, 0x000200f9u, + 0x00000488u, 0x000200f8u, 0x00000488u, 0x00050041u, 0x00000008u, 0x00000495u, 0x00000389u, 0x000001c3u, + 0x0004003du, 0x00000006u, 0x00000496u, 0x00000495u, 0x00050041u, 0x00000008u, 0x00000497u, 0x000003a1u, + 0x000001c3u, 0x0004003du, 0x00000006u, 0x00000498u, 0x00000497u, 0x00050080u, 0x00000006u, 0x00000499u, + 0x00000496u, 0x00000498u, 0x0004003du, 0x00000006u, 0x0000049au, 0x000003f3u, 0x00050080u, 0x00000006u, + 0x0000049bu, 0x00000499u, 0x0000049au, 0x00060041u, 0x000003d6u, 0x0000049cu, 0x000003ccu, 0x000000e6u, + 0x0000049bu, 0x0004003du, 0x00000014u, 0x0000049du, 0x0000049cu, 0x0004007cu, 0x00000006u, 0x0000049eu, + 0x0000049du, 0x0003003eu, 0x00000494u, 0x0000049eu, 0x0004003du, 0x00000006u, 0x000004a0u, 0x00000494u, + 0x0004003du, 0x00000006u, 0x000004a1u, 0x00000484u, 0x00050082u, 0x00000006u, 0x000004a2u, 0x000004a0u, + 0x000004a1u, 0x0003003eu, 0x0000049fu, 0x000004a2u, 0x00050041u, 0x00000008u, 0x000004a4u, 0x0000037bu, + 0x00000114u, 0x0004003du, 0x00000006u, 0x000004a5u, 0x000004a4u, 0x00060041u, 0x000004a6u, 0x000004a7u, + 0x00000408u, 0x000000e6u, 0x000004a5u, 0x0004003du, 0x00000404u, 0x000004a8u, 0x000004a7u, 0x00040190u, + 0x0000002du, 0x000004a9u, 0x000004a8u, 0x0003003eu, 0x000004a3u, 0x000004a9u, 0x0004003du, 0x00000006u, + 0x000004abu, 0x0000036bu, 0x00060041u, 0x00000419u, 0x000004acu, 0x00000417u, 0x000000e6u, 0x000004abu, + 0x0004003du, 0x00000413u, 0x000004adu, 0x000004acu, 0x00040190u, 0x00000026u, 0x000004aeu, 0x000004adu, + 0x0003003eu, 0x000004aau, 0x000004aeu, 0x0003003eu, 0x000004afu, 0x00000040u, 0x00050041u, 0x000003f7u, + 0x000004b0u, 0x000000e1u, 0x000001ddu, 0x0004003du, 0x00000009u, 0x000004b1u, 0x000004b0u, 0x000500bau, + 0x0000001cu, 0x000004b2u, 0x000004b1u, 0x00000062u, 0x000300f7u, 0x000004b4u, 0x00000000u, 0x000400fau, + 0x000004b2u, 0x000004b3u, 0x000004b4u, 0x000200f8u, 0x000004b3u, 0x00050041u, 0x00000008u, 0x000004b6u, + 0x00000389u, 0x000000e2u, 0x0004003du, 0x00000006u, 0x000004b7u, 0x000004b6u, 0x00050041u, 0x00000008u, + 0x000004b8u, 0x000003a1u, 0x000001d2u, 0x0004003du, 0x00000006u, 0x000004b9u, 0x000004b8u, 0x00050080u, + 0x00000006u, 0x000004bau, 0x000004b7u, 0x000004b9u, 0x0004003du, 0x00000006u, 0x000004bbu, 0x00000484u, + 0x00050080u, 0x00000006u, 0x000004bcu, 0x000004bau, 0x000004bbu, 0x0003003eu, 0x000004b5u, 0x000004bcu, + 0x00050041u, 0x00000008u, 0x000004beu, 0x00000389u, 0x000001d2u, 0x0004003du, 0x00000006u, 0x000004bfu, + 0x000004beu, 0x00050041u, 0x00000008u, 0x000004c0u, 0x000003a1u, 0x000001ddu, 0x0004003du, 0x00000006u, + 0x000004c1u, 0x000004c0u, 0x00050080u, 0x00000006u, 0x000004c2u, 0x000004bfu, 0x000004c1u, 0x0004003du, + 0x00000006u, 0x000004c3u, 0x00000461u, 0x00050080u, 0x00000006u, 0x000004c4u, 0x000004c2u, 0x000004c3u, + 0x0003003eu, 0x000004bdu, 0x000004c4u, 0x0004003du, 0x00000006u, 0x000004c6u, 0x0000047cu, 0x0007000cu, + 0x00000006u, 0x000004c7u, 0x00000001u, 0x00000026u, 0x000004c6u, 0x00000077u, 0x0003003eu, 0x000004c5u, + 0x000004c7u, 0x0003003eu, 0x000004c8u, 0x00000040u, 0x000200f9u, 0x000004c9u, 0x000200f8u, 0x000004c9u, + 0x000400f6u, 0x000004cbu, 0x000004ccu, 0x00000000u, 0x000200f9u, 0x000004cdu, 0x000200f8u, 0x000004cdu, + 0x0004003du, 0x00000006u, 0x000004ceu, 0x000004c8u, 0x0004003du, 0x00000006u, 0x000004cfu, 0x000004c5u, + 0x000500b0u, 0x0000001cu, 0x000004d0u, 0x000004ceu, 0x000004cfu, 0x000400fau, 0x000004d0u, 0x000004cau, + 0x000004cbu, 0x000200f8u, 0x000004cau, 0x0004003du, 0x00000006u, 0x000004d7u, 0x000004bdu, 0x0004003du, + 0x00000006u, 0x000004d8u, 0x000004c8u, 0x00050080u, 0x00000006u, 0x000004d9u, 0x000004d7u, 0x000004d8u, + 0x00060041u, 0x000004dau, 0x000004dbu, 0x000004d6u, 0x000000e6u, 0x000004d9u, 0x0004003du, 0x00000353u, + 0x000004dcu, 0x000004dbu, 0x0003003eu, 0x000004d2u, 0x000004dcu, 0x0004003du, 0x00000006u, 0x000004e5u, + 0x000004b5u, 0x00050041u, 0x00000008u, 0x000004e6u, 0x000004d2u, 0x00000040u, 0x0004003du, 0x00000006u, + 0x000004e7u, 0x000004e6u, 0x00050080u, 0x00000006u, 0x000004e8u, 0x000004e5u, 0x000004e7u, 0x00060041u, + 0x000004e9u, 0x000004eau, 0x000004e4u, 0x000000e6u, 0x000004e8u, 0x0004003du, 0x000004e0u, 0x000004ebu, + 0x000004eau, 0x00040190u, 0x000004ddu, 0x000004ecu, 0x000004ebu, 0x0003003eu, 0x000004dfu, 0x000004ecu, + 0x0004003du, 0x00000006u, 0x000004eeu, 0x000004b5u, 0x00050041u, 0x00000008u, 0x000004efu, 0x000004d2u, + 0x00000007u, 0x0004003du, 0x00000006u, 0x000004f0u, 0x000004efu, 0x00050080u, 0x00000006u, 0x000004f1u, + 0x000004eeu, 0x000004f0u, 0x00060041u, 0x000004e9u, 0x000004f2u, 0x000004e4u, 0x000000e6u, 0x000004f1u, + 0x0004003du, 0x000004e0u, 0x000004f3u, 0x000004f2u, 0x00040190u, 0x000004ddu, 0x000004f4u, 0x000004f3u, + 0x0003003eu, 0x000004edu, 0x000004f4u, 0x0004003du, 0x00000006u, 0x000004f6u, 0x000004b5u, 0x00050041u, + 0x00000008u, 0x000004f7u, 0x000004d2u, 0x00000053u, 0x0004003du, 0x00000006u, 0x000004f8u, 0x000004f7u, + 0x00050080u, 0x00000006u, 0x000004f9u, 0x000004f6u, 0x000004f8u, 0x00060041u, 0x000004e9u, 0x000004fau, + 0x000004e4u, 0x000000e6u, 0x000004f9u, 0x0004003du, 0x000004e0u, 0x000004fbu, 0x000004fau, 0x00040190u, + 0x000004ddu, 0x000004fcu, 0x000004fbu, 0x0003003eu, 0x000004f5u, 0x000004fcu, 0x00050041u, 0x00000036u, + 0x000004feu, 0x000004dfu, 0x000000e6u, 0x0004003du, 0x00000009u, 0x000004ffu, 0x000004feu, 0x00050041u, + 0x00000036u, 0x00000500u, 0x000004dfu, 0x00000114u, 0x0004003du, 0x00000009u, 0x00000501u, 0x00000500u, + 0x00050041u, 0x00000036u, 0x00000502u, 0x000004dfu, 0x00000123u, 0x0004003du, 0x00000009u, 0x00000503u, + 0x00000502u, 0x00060050u, 0x0000000au, 0x00000504u, 0x000004ffu, 0x00000501u, 0x00000503u, 0x0003003eu, + 0x000004fdu, 0x00000504u, 0x00050041u, 0x00000036u, 0x00000506u, 0x000004edu, 0x000000e6u, 0x0004003du, + 0x00000009u, 0x00000507u, 0x00000506u, 0x00050041u, 0x00000036u, 0x00000508u, 0x000004edu, 0x00000114u, + 0x0004003du, 0x00000009u, 0x00000509u, 0x00000508u, 0x00050041u, 0x00000036u, 0x0000050au, 0x000004edu, + 0x00000123u, 0x0004003du, 0x00000009u, 0x0000050bu, 0x0000050au, 0x00060050u, 0x0000000au, 0x0000050cu, + 0x00000507u, 0x00000509u, 0x0000050bu, 0x0003003eu, 0x00000505u, 0x0000050cu, 0x00050041u, 0x00000036u, + 0x0000050eu, 0x000004f5u, 0x000000e6u, 0x0004003du, 0x00000009u, 0x0000050fu, 0x0000050eu, 0x00050041u, + 0x00000036u, 0x00000510u, 0x000004f5u, 0x00000114u, 0x0004003du, 0x00000009u, 0x00000511u, 0x00000510u, + 0x00050041u, 0x00000036u, 0x00000512u, 0x000004f5u, 0x00000123u, 0x0004003du, 0x00000009u, 0x00000513u, + 0x00000512u, 0x00060050u, 0x0000000au, 0x00000514u, 0x0000050fu, 0x00000511u, 0x00000513u, 0x0003003eu, + 0x0000050du, 0x00000514u, 0x0004003du, 0x00000006u, 0x00000515u, 0x000004afu, 0x0004003du, 0x0000000au, + 0x00000517u, 0x000004fdu, 0x0003003eu, 0x00000516u, 0x00000517u, 0x0004003du, 0x0000000au, 0x00000519u, + 0x00000505u, 0x0003003eu, 0x00000518u, 0x00000519u, 0x0004003du, 0x00000026u, 0x0000051bu, 0x000004aau, + 0x0003003eu, 0x0000051au, 0x0000051bu, 0x0004003du, 0x0000002du, 0x0000051du, 0x000004a3u, 0x0003003eu, + 0x0000051cu, 0x0000051du, 0x00050041u, 0x000003f7u, 0x0000051fu, 0x000000e1u, 0x000001ddu, 0x0004003du, + 0x00000009u, 0x00000520u, 0x0000051fu, 0x0003003eu, 0x0000051eu, 0x00000520u, 0x00090039u, 0x00000006u, + 0x00000521u, 0x0000003du, 0x00000516u, 0x00000518u, 0x0000051au, 0x0000051cu, 0x0000051eu, 0x0007000cu, + 0x00000006u, 0x00000522u, 0x00000001u, 0x00000029u, 0x00000515u, 0x00000521u, 0x0003003eu, 0x000004afu, + 0x00000522u, 0x0004003du, 0x00000006u, 0x00000523u, 0x000004afu, 0x0004003du, 0x0000000au, 0x00000525u, + 0x00000505u, 0x0003003eu, 0x00000524u, 0x00000525u, 0x0004003du, 0x0000000au, 0x00000527u, 0x0000050du, + 0x0003003eu, 0x00000526u, 0x00000527u, 0x0004003du, 0x00000026u, 0x00000529u, 0x000004aau, 0x0003003eu, + 0x00000528u, 0x00000529u, 0x0004003du, 0x0000002du, 0x0000052bu, 0x000004a3u, 0x0003003eu, 0x0000052au, + 0x0000052bu, 0x00050041u, 0x000003f7u, 0x0000052du, 0x000000e1u, 0x000001ddu, 0x0004003du, 0x00000009u, + 0x0000052eu, 0x0000052du, 0x0003003eu, 0x0000052cu, 0x0000052eu, 0x00090039u, 0x00000006u, 0x0000052fu, + 0x0000003du, 0x00000524u, 0x00000526u, 0x00000528u, 0x0000052au, 0x0000052cu, 0x0007000cu, 0x00000006u, + 0x00000530u, 0x00000001u, 0x00000029u, 0x00000523u, 0x0000052fu, 0x0003003eu, 0x000004afu, 0x00000530u, + 0x0004003du, 0x00000006u, 0x00000531u, 0x000004afu, 0x0004003du, 0x0000000au, 0x00000533u, 0x0000050du, + 0x0003003eu, 0x00000532u, 0x00000533u, 0x0004003du, 0x0000000au, 0x00000535u, 0x000004fdu, 0x0003003eu, + 0x00000534u, 0x00000535u, 0x0004003du, 0x00000026u, 0x00000537u, 0x000004aau, 0x0003003eu, 0x00000536u, + 0x00000537u, 0x0004003du, 0x0000002du, 0x00000539u, 0x000004a3u, 0x0003003eu, 0x00000538u, 0x00000539u, + 0x00050041u, 0x000003f7u, 0x0000053bu, 0x000000e1u, 0x000001ddu, 0x0004003du, 0x00000009u, 0x0000053cu, + 0x0000053bu, 0x0003003eu, 0x0000053au, 0x0000053cu, 0x00090039u, 0x00000006u, 0x0000053du, 0x0000003du, + 0x00000532u, 0x00000534u, 0x00000536u, 0x00000538u, 0x0000053au, 0x0007000cu, 0x00000006u, 0x0000053eu, + 0x00000001u, 0x00000029u, 0x00000531u, 0x0000053du, 0x0003003eu, 0x000004afu, 0x0000053eu, 0x000200f9u, + 0x000004ccu, 0x000200f8u, 0x000004ccu, 0x0004003du, 0x00000006u, 0x0000053fu, 0x000004c8u, 0x00050080u, + 0x00000006u, 0x00000540u, 0x0000053fu, 0x00000114u, 0x0003003eu, 0x000004c8u, 0x00000540u, 0x000200f9u, + 0x000004c9u, 0x000200f8u, 0x000004cbu, 0x0004003du, 0x00000006u, 0x00000541u, 0x000004afu, 0x0007000cu, + 0x00000006u, 0x00000542u, 0x00000001u, 0x00000026u, 0x00000541u, 0x0000005du, 0x0003003eu, 0x000004afu, + 0x00000542u, 0x000200f9u, 0x000004b4u, 0x000200f8u, 0x000004b4u, 0x0004003du, 0x00000006u, 0x00000543u, + 0x000004afu, 0x000500aau, 0x0000001cu, 0x00000544u, 0x00000543u, 0x00000040u, 0x0004003du, 0x00000006u, + 0x00000545u, 0x0000049fu, 0x000500b2u, 0x0000001cu, 0x00000547u, 0x00000545u, 0x00000546u, 0x000500a7u, + 0x0000001cu, 0x00000548u, 0x00000544u, 0x00000547u, 0x000300f7u, 0x0000054au, 0x00000000u, 0x000400fau, + 0x00000548u, 0x00000549u, 0x0000054cu, 0x000200f8u, 0x00000549u, 0x0003003eu, 0x0000054bu, 0x00000007u, + 0x000200f9u, 0x0000054au, 0x000200f8u, 0x0000054cu, 0x0004003du, 0x00000006u, 0x0000054du, 0x000004afu, + 0x000500aau, 0x0000001cu, 0x0000054eu, 0x0000054du, 0x00000040u, 0x000300f7u, 0x00000550u, 0x00000000u, + 0x000400fau, 0x0000054eu, 0x0000054fu, 0x00000552u, 0x000200f8u, 0x0000054fu, 0x0003003eu, 0x00000551u, + 0x00000077u, 0x000200f9u, 0x00000550u, 0x000200f8u, 0x00000552u, 0x0004003du, 0x00000006u, 0x00000553u, + 0x000004afu, 0x000500aau, 0x0000001cu, 0x00000554u, 0x00000553u, 0x00000007u, 0x000300f7u, 0x00000556u, + 0x00000000u, 0x000400fau, 0x00000554u, 0x00000555u, 0x00000557u, 0x000200f8u, 0x00000555u, 0x0003003eu, + 0x00000551u, 0x00000450u, 0x000200f9u, 0x00000556u, 0x000200f8u, 0x00000557u, 0x0004003du, 0x00000006u, + 0x00000558u, 0x000004afu, 0x000500aau, 0x0000001cu, 0x00000559u, 0x00000558u, 0x00000053u, 0x000300f7u, + 0x0000055bu, 0x00000000u, 0x000400fau, 0x00000559u, 0x0000055au, 0x0000055cu, 0x000200f8u, 0x0000055au, + 0x0003003eu, 0x00000551u, 0x00000053u, 0x000200f9u, 0x0000055bu, 0x000200f8u, 0x0000055cu, 0x0003003eu, + 0x00000551u, 0x00000007u, 0x000200f9u, 0x0000055bu, 0x000200f8u, 0x0000055bu, 0x000200f9u, 0x00000556u, + 0x000200f8u, 0x00000556u, 0x000200f9u, 0x00000550u, 0x000200f8u, 0x00000550u, 0x0004003du, 0x00000006u, + 0x0000055du, 0x0000047cu, 0x0004003du, 0x00000006u, 0x0000055eu, 0x00000551u, 0x00050080u, 0x00000006u, + 0x0000055fu, 0x0000055du, 0x0000055eu, 0x00050082u, 0x00000006u, 0x00000560u, 0x0000055fu, 0x00000007u, + 0x0004003du, 0x00000006u, 0x00000561u, 0x00000551u, 0x00050086u, 0x00000006u, 0x00000562u, 0x00000560u, + 0x00000561u, 0x0003003eu, 0x0000054bu, 0x00000562u, 0x0004003du, 0x00000006u, 0x00000563u, 0x0000054bu, + 0x0007000cu, 0x00000006u, 0x00000564u, 0x00000001u, 0x00000029u, 0x00000563u, 0x00000007u, 0x0003003eu, + 0x0000054bu, 0x00000564u, 0x000200f9u, 0x0000054au, 0x000200f8u, 0x0000054au, 0x0004003du, 0x0000001cu, + 0x00000565u, 0x000003ebu, 0x0004003du, 0x00000006u, 0x00000566u, 0x0000054bu, 0x000600a9u, 0x00000006u, + 0x00000567u, 0x00000565u, 0x00000040u, 0x00000566u, 0x0003003eu, 0x00000351u, 0x00000567u, 0x0004003du, + 0x00000006u, 0x0000056bu, 0x0000036bu, 0x00050041u, 0x0000056cu, 0x0000056du, 0x0000056au, 0x000000e6u, + 0x0003003eu, 0x0000056du, 0x0000056bu, 0x0004003du, 0x00000006u, 0x0000056eu, 0x00000365u, 0x00050041u, + 0x0000056cu, 0x0000056fu, 0x0000056au, 0x00000114u, 0x0003003eu, 0x0000056fu, 0x0000056eu, 0x0004003du, + 0x00000006u, 0x00000570u, 0x000003f3u, 0x00050041u, 0x0000056cu, 0x00000571u, 0x0000056au, 0x00000123u, + 0x0003003eu, 0x00000571u, 0x00000570u, 0x0004003du, 0x00000006u, 0x00000572u, 0x0000047cu, 0x00050041u, + 0x0000056cu, 0x00000573u, 0x0000056au, 0x00000162u, 0x0003003eu, 0x00000573u, 0x00000572u, 0x0004003du, + 0x00000006u, 0x00000574u, 0x0000049fu, 0x00050041u, 0x0000056cu, 0x00000575u, 0x0000056au, 0x000001b4u, + 0x0003003eu, 0x00000575u, 0x00000574u, 0x0004003du, 0x00000006u, 0x00000576u, 0x000004afu, 0x00050041u, + 0x0000056cu, 0x00000577u, 0x0000056au, 0x000001b7u, 0x0003003eu, 0x00000577u, 0x00000576u, 0x00050041u, + 0x00000008u, 0x00000579u, 0x000003a1u, 0x000001b4u, 0x0004003du, 0x00000006u, 0x0000057au, 0x00000579u, + 0x0003003eu, 0x00000578u, 0x0000057au, 0x00050039u, 0x0000000au, 0x0000057bu, 0x00000010u, 0x00000578u, + 0x00050041u, 0x0000057cu, 0x0000057du, 0x0000056au, 0x000001bdu, 0x0003003eu, 0x0000057du, 0x0000057bu, + 0x00050041u, 0x00000008u, 0x0000057eu, 0x0000037bu, 0x00000162u, 0x0004003du, 0x00000006u, 0x0000057fu, + 0x0000057eu, 0x000500aau, 0x0000001cu, 0x00000580u, 0x0000057fu, 0x00000007u, 0x000600a9u, 0x00000009u, + 0x00000581u, 0x00000580u, 0x00000059u, 0x00000062u, 0x00050041u, 0x00000582u, 0x00000583u, 0x0000056au, + 0x000001c3u, 0x0003003eu, 0x00000583u, 0x00000581u, 0x0004003du, 0x00000006u, 0x00000584u, 0x00000351u, + 0x000514aeu, 0x00000584u, 0x00000007u, 0x00000007u, 0x0000056au, 0x00010038u, 0x00050036u, 0x0000000au, + 0x0000000du, 0x00000000u, 0x0000000bu, 0x00030037u, 0x00000008u, 0x0000000cu, 0x000200f8u, 0x0000000eu, + 0x0004003du, 0x00000006u, 0x0000003fu, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x00000041u, 0x0000003fu, + 0x00000040u, 0x000300f7u, 0x00000043u, 0x00000000u, 0x000400fau, 0x00000041u, 0x00000042u, 0x00000043u, + 0x000200f8u, 0x00000042u, 0x000200feu, 0x00000047u, 0x000200f8u, 0x00000043u, 0x0004003du, 0x00000006u, + 0x00000049u, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x0000004au, 0x00000049u, 0x00000007u, 0x000300f7u, + 0x0000004cu, 0x00000000u, 0x000400fau, 0x0000004au, 0x0000004bu, 0x0000004cu, 0x000200f8u, 0x0000004bu, + 0x000200feu, 0x00000050u, 0x000200f8u, 0x0000004cu, 0x0004003du, 0x00000006u, 0x00000052u, 0x0000000cu, + 0x000500aau, 0x0000001cu, 0x00000054u, 0x00000052u, 0x00000053u, 0x000300f7u, 0x00000056u, 0x00000000u, + 0x000400fau, 0x00000054u, 0x00000055u, 0x00000056u, 0x000200f8u, 0x00000055u, 0x000200feu, 0x0000005au, + 0x000200f8u, 0x00000056u, 0x0004003du, 0x00000006u, 0x0000005cu, 0x0000000cu, 0x000500aau, 0x0000001cu, + 0x0000005eu, 0x0000005cu, 0x0000005du, 0x000300f7u, 0x00000060u, 0x00000000u, 0x000400fau, 0x0000005eu, + 0x0000005fu, 0x00000060u, 0x000200f8u, 0x0000005fu, 0x000200feu, 0x00000063u, 0x000200f8u, 0x00000060u, + 0x0004003du, 0x00000006u, 0x00000065u, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x00000067u, 0x00000065u, + 0x00000066u, 0x000300f7u, 0x00000069u, 0x00000000u, 0x000400fau, 0x00000067u, 0x00000068u, 0x00000069u, + 0x000200f8u, 0x00000068u, 0x000200feu, 0x0000006au, 0x000200f8u, 0x00000069u, 0x0004003du, 0x00000006u, + 0x0000006cu, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x0000006eu, 0x0000006cu, 0x0000006du, 0x000300f7u, + 0x00000070u, 0x00000000u, 0x000400fau, 0x0000006eu, 0x0000006fu, 0x00000070u, 0x000200f8u, 0x0000006fu, + 0x000200feu, 0x00000074u, 0x000200f8u, 0x00000070u, 0x0004003du, 0x00000006u, 0x00000076u, 0x0000000cu, + 0x000500aau, 0x0000001cu, 0x00000078u, 0x00000076u, 0x00000077u, 0x000300f7u, 0x0000007au, 0x00000000u, + 0x000400fau, 0x00000078u, 0x00000079u, 0x0000007au, 0x000200f8u, 0x00000079u, 0x000200feu, 0x0000007du, + 0x000200f8u, 0x0000007au, 0x0004003du, 0x00000006u, 0x0000007fu, 0x0000000cu, 0x000500aau, 0x0000001cu, + 0x00000081u, 0x0000007fu, 0x00000080u, 0x000300f7u, 0x00000083u, 0x00000000u, 0x000400fau, 0x00000081u, + 0x00000082u, 0x00000083u, 0x000200f8u, 0x00000082u, 0x000200feu, 0x00000087u, 0x000200f8u, 0x00000083u, + 0x0004003du, 0x00000006u, 0x00000089u, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x0000008bu, 0x00000089u, + 0x0000008au, 0x000300f7u, 0x0000008du, 0x00000000u, 0x000400fau, 0x0000008bu, 0x0000008cu, 0x0000008du, + 0x000200f8u, 0x0000008cu, 0x000200feu, 0x00000050u, 0x000200f8u, 0x0000008du, 0x0004003du, 0x00000006u, + 0x0000008fu, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x00000091u, 0x0000008fu, 0x00000090u, 0x000300f7u, + 0x00000093u, 0x00000000u, 0x000400fau, 0x00000091u, 0x00000092u, 0x00000093u, 0x000200f8u, 0x00000092u, + 0x000200feu, 0x00000094u, 0x000200f8u, 0x00000093u, 0x0004003du, 0x00000006u, 0x00000096u, 0x0000000cu, + 0x000500aau, 0x0000001cu, 0x00000098u, 0x00000096u, 0x00000097u, 0x000300f7u, 0x0000009au, 0x00000000u, + 0x000400fau, 0x00000098u, 0x00000099u, 0x0000009au, 0x000200f8u, 0x00000099u, 0x000200feu, 0x0000009du, + 0x000200f8u, 0x0000009au, 0x0004003du, 0x00000006u, 0x0000009fu, 0x0000000cu, 0x000500aau, 0x0000001cu, + 0x000000a1u, 0x0000009fu, 0x000000a0u, 0x000300f7u, 0x000000a3u, 0x00000000u, 0x000400fau, 0x000000a1u, + 0x000000a2u, 0x000000a3u, 0x000200f8u, 0x000000a2u, 0x000200feu, 0x000000a6u, 0x000200f8u, 0x000000a3u, + 0x0004003du, 0x00000006u, 0x000000a8u, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x000000aau, 0x000000a8u, + 0x000000a9u, 0x000300f7u, 0x000000acu, 0x00000000u, 0x000400fau, 0x000000aau, 0x000000abu, 0x000000acu, + 0x000200f8u, 0x000000abu, 0x000200feu, 0x000000aeu, 0x000200f8u, 0x000000acu, 0x0004003du, 0x00000006u, + 0x000000b0u, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x000000b2u, 0x000000b0u, 0x000000b1u, 0x000300f7u, + 0x000000b4u, 0x00000000u, 0x000400fau, 0x000000b2u, 0x000000b3u, 0x000000b4u, 0x000200f8u, 0x000000b3u, + 0x000200feu, 0x000000b5u, 0x000200f8u, 0x000000b4u, 0x0004003du, 0x00000006u, 0x000000b7u, 0x0000000cu, + 0x000500aau, 0x0000001cu, 0x000000b9u, 0x000000b7u, 0x000000b8u, 0x000300f7u, 0x000000bbu, 0x00000000u, + 0x000400fau, 0x000000b9u, 0x000000bau, 0x000000bbu, 0x000200f8u, 0x000000bau, 0x000200feu, 0x000000bcu, + 0x000200f8u, 0x000000bbu, 0x0004003du, 0x00000006u, 0x000000beu, 0x0000000cu, 0x000500aau, 0x0000001cu, + 0x000000c0u, 0x000000beu, 0x000000bfu, 0x000300f7u, 0x000000c2u, 0x00000000u, 0x000400fau, 0x000000c0u, + 0x000000c1u, 0x000000c2u, 0x000200f8u, 0x000000c1u, 0x000200feu, 0x000000bcu, 0x000200f8u, 0x000000c2u, + 0x0004003du, 0x00000006u, 0x000000c4u, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x000000c6u, 0x000000c4u, + 0x000000c5u, 0x000300f7u, 0x000000c8u, 0x00000000u, 0x000400fau, 0x000000c6u, 0x000000c7u, 0x000000c8u, + 0x000200f8u, 0x000000c7u, 0x000200feu, 0x000000c9u, 0x000200f8u, 0x000000c8u, 0x0004003du, 0x00000006u, + 0x000000cbu, 0x0000000cu, 0x000500aau, 0x0000001cu, 0x000000cdu, 0x000000cbu, 0x000000ccu, 0x000300f7u, + 0x000000cfu, 0x00000000u, 0x000400fau, 0x000000cdu, 0x000000ceu, 0x000000cfu, 0x000200f8u, 0x000000ceu, + 0x000200feu, 0x000000c9u, 0x000200f8u, 0x000000cfu, 0x0004003du, 0x00000006u, 0x000000d1u, 0x0000000cu, + 0x000500aau, 0x0000001cu, 0x000000d3u, 0x000000d1u, 0x000000d2u, 0x000300f7u, 0x000000d5u, 0x00000000u, + 0x000400fau, 0x000000d3u, 0x000000d4u, 0x000000d5u, 0x000200f8u, 0x000000d4u, 0x000200feu, 0x000000c9u, + 0x000200f8u, 0x000000d5u, 0x0004003du, 0x00000006u, 0x000000d7u, 0x0000000cu, 0x000500aau, 0x0000001cu, + 0x000000d9u, 0x000000d7u, 0x000000d8u, 0x000300f7u, 0x000000dbu, 0x00000000u, 0x000400fau, 0x000000d9u, + 0x000000dau, 0x000000dbu, 0x000200f8u, 0x000000dau, 0x000200feu, 0x000000bcu, 0x000200f8u, 0x000000dbu, + 0x000200feu, 0x000000bcu, 0x00010038u, 0x00050036u, 0x0000000au, 0x00000010u, 0x00000000u, 0x0000000bu, + 0x00030037u, 0x00000008u, 0x0000000fu, 0x000200f8u, 0x00000011u, 0x0004003bu, 0x000000f2u, 0x000000f3u, + 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000104u, 0x00000007u, 0x00050041u, 0x000000e3u, 0x000000e4u, + 0x000000e1u, 0x000000e2u, 0x0004003du, 0x00000014u, 0x000000e5u, 0x000000e4u, 0x000500adu, 0x0000001cu, + 0x000000e7u, 0x000000e5u, 0x000000e6u, 0x000300f7u, 0x000000e9u, 0x00000000u, 0x000400fau, 0x000000e7u, + 0x000000e8u, 0x000000e9u, 0x000200f8u, 0x000000e8u, 0x0004003du, 0x00000006u, 0x000000eau, 0x0000000fu, + 0x00050041u, 0x000000e3u, 0x000000ebu, 0x000000e1u, 0x000000e2u, 0x0004003du, 0x00000014u, 0x000000ecu, + 0x000000ebu, 0x0004007cu, 0x00000006u, 0x000000edu, 0x000000ecu, 0x000500b0u, 0x0000001cu, 0x000000eeu, + 0x000000eau, 0x000000edu, 0x000200f9u, 0x000000e9u, 0x000200f8u, 0x000000e9u, 0x000700f5u, 0x0000001cu, + 0x000000efu, 0x000000e7u, 0x00000011u, 0x000000eeu, 0x000000e8u, 0x000300f7u, 0x000000f1u, 0x00000000u, + 0x000400fau, 0x000000efu, 0x000000f0u, 0x000000f1u, 0x000200f8u, 0x000000f0u, 0x0004003du, 0x00000006u, + 0x000000f8u, 0x0000000fu, 0x00060041u, 0x000000f9u, 0x000000fau, 0x000000f7u, 0x000000e6u, 0x000000f8u, + 0x0004003du, 0x00000024u, 0x000000fbu, 0x000000fau, 0x0003003eu, 0x000000f3u, 0x000000fbu, 0x00050041u, + 0x00000036u, 0x000000fcu, 0x000000f3u, 0x0000005du, 0x0004003du, 0x00000009u, 0x000000fdu, 0x000000fcu, + 0x000500beu, 0x0000001cu, 0x000000feu, 0x000000fdu, 0x00000062u, 0x000300f7u, 0x00000100u, 0x00000000u, + 0x000400fau, 0x000000feu, 0x000000ffu, 0x00000100u, 0x000200f8u, 0x000000ffu, 0x0004003du, 0x00000024u, + 0x00000101u, 0x000000f3u, 0x0008004fu, 0x0000000au, 0x00000102u, 0x00000101u, 0x00000101u, 0x00000000u, + 0x00000001u, 0x00000002u, 0x000200feu, 0x00000102u, 0x000200f8u, 0x00000100u, 0x000200f9u, 0x000000f1u, + 0x000200f8u, 0x000000f1u, 0x0004003du, 0x00000006u, 0x00000105u, 0x0000000fu, 0x0003003eu, 0x00000104u, + 0x00000105u, 0x00050039u, 0x0000000au, 0x00000106u, 0x0000000du, 0x00000104u, 0x000200feu, 0x00000106u, + 0x00010038u, 0x00050036u, 0x00000014u, 0x00000019u, 0x00000000u, 0x00000015u, 0x00030037u, 0x00000008u, + 0x00000016u, 0x00030037u, 0x00000008u, 0x00000017u, 0x00030037u, 0x00000013u, 0x00000018u, 0x000200f8u, + 0x0000001au, 0x0004003bu, 0x0000010fu, 0x00000110u, 0x00000007u, 0x0004003bu, 0x0000010fu, 0x00000111u, + 0x00000007u, 0x0004003bu, 0x0000010fu, 0x00000116u, 0x00000007u, 0x0004003bu, 0x0000010fu, 0x0000011fu, + 0x00000007u, 0x0004003bu, 0x00000013u, 0x00000125u, 0x00000007u, 0x0004003du, 0x00000006u, 0x00000109u, + 0x00000017u, 0x000500aau, 0x0000001cu, 0x0000010au, 0x00000109u, 0x00000040u, 0x000300f7u, 0x0000010cu, + 0x00000000u, 0x000400fau, 0x0000010au, 0x0000010bu, 0x0000010cu, 0x000200f8u, 0x0000010bu, 0x000200feu, + 0x0000010du, 0x000200f8u, 0x0000010cu, 0x0003003eu, 0x00000110u, 0x000000e6u, 0x0004003du, 0x00000006u, + 0x00000112u, 0x00000017u, 0x0004007cu, 0x00000014u, 0x00000113u, 0x00000112u, 0x00050082u, 0x00000014u, + 0x00000115u, 0x00000113u, 0x00000114u, 0x0003003eu, 0x00000111u, 0x00000115u, 0x0003003eu, 0x00000116u, + 0x0000010du, 0x000200f9u, 0x00000117u, 0x000200f8u, 0x00000117u, 0x000400f6u, 0x00000119u, 0x0000011au, + 0x00000000u, 0x000200f9u, 0x0000011bu, 0x000200f8u, 0x0000011bu, 0x0004003du, 0x00000014u, 0x0000011cu, + 0x00000110u, 0x0004003du, 0x00000014u, 0x0000011du, 0x00000111u, 0x000500b3u, 0x0000001cu, 0x0000011eu, + 0x0000011cu, 0x0000011du, 0x000400fau, 0x0000011eu, 0x00000118u, 0x00000119u, 0x000200f8u, 0x00000118u, + 0x0004003du, 0x00000014u, 0x00000120u, 0x00000110u, 0x0004003du, 0x00000014u, 0x00000121u, 0x00000111u, + 0x00050080u, 0x00000014u, 0x00000122u, 0x00000120u, 0x00000121u, 0x00050087u, 0x00000014u, 0x00000124u, + 0x00000122u, 0x00000123u, 0x0003003eu, 0x0000011fu, 0x00000124u, 0x0004003du, 0x00000006u, 0x0000012au, + 0x00000016u, 0x0004003du, 0x00000014u, 0x0000012bu, 0x0000011fu, 0x0004007cu, 0x00000006u, 0x0000012cu, + 0x0000012bu, 0x00050080u, 0x00000006u, 0x0000012du, 0x0000012au, 0x0000012cu, 0x00060041u, 0x0000012eu, + 0x0000012fu, 0x00000129u, 0x000000e6u, 0x0000012du, 0x0004003du, 0x00000012u, 0x00000130u, 0x0000012fu, + 0x0003003eu, 0x00000125u, 0x00000130u, 0x0004003du, 0x00000012u, 0x00000131u, 0x00000125u, 0x0004003du, + 0x00000012u, 0x00000132u, 0x00000018u, 0x000500b3u, 0x0000001cu, 0x00000133u, 0x00000131u, 0x00000132u, + 0x000300f7u, 0x00000135u, 0x00000000u, 0x000400fau, 0x00000133u, 0x00000134u, 0x00000139u, 0x000200f8u, + 0x00000134u, 0x0004003du, 0x00000014u, 0x00000136u, 0x0000011fu, 0x0003003eu, 0x00000116u, 0x00000136u, + 0x0004003du, 0x00000014u, 0x00000137u, 0x0000011fu, 0x00050080u, 0x00000014u, 0x00000138u, 0x00000137u, + 0x00000114u, 0x0003003eu, 0x00000110u, 0x00000138u, 0x000200f9u, 0x00000135u, 0x000200f8u, 0x00000139u, + 0x0004003du, 0x00000014u, 0x0000013au, 0x0000011fu, 0x00050082u, 0x00000014u, 0x0000013bu, 0x0000013au, + 0x00000114u, 0x0003003eu, 0x00000111u, 0x0000013bu, 0x000200f9u, 0x00000135u, 0x000200f8u, 0x00000135u, + 0x000200f9u, 0x0000011au, 0x000200f8u, 0x0000011au, 0x000200f9u, 0x00000117u, 0x000200f8u, 0x00000119u, + 0x0004003du, 0x00000014u, 0x0000013cu, 0x00000116u, 0x000200feu, 0x0000013cu, 0x00010038u, 0x00050036u, + 0x0000001cu, 0x00000022u, 0x00000000u, 0x0000001du, 0x00030037u, 0x0000001bu, 0x0000001eu, 0x00030037u, + 0x0000001bu, 0x0000001fu, 0x00030037u, 0x0000001bu, 0x00000020u, 0x00030037u, 0x0000001bu, 0x00000021u, + 0x000200f8u, 0x00000023u, 0x0004003du, 0x0000000au, 0x0000013fu, 0x0000001eu, 0x0004003du, 0x0000000au, + 0x00000140u, 0x00000021u, 0x000500bcu, 0x00000141u, 0x00000142u, 0x0000013fu, 0x00000140u, 0x0004009bu, + 0x0000001cu, 0x00000143u, 0x00000142u, 0x000300f7u, 0x00000145u, 0x00000000u, 0x000400fau, 0x00000143u, + 0x00000144u, 0x00000145u, 0x000200f8u, 0x00000144u, 0x0004003du, 0x0000000au, 0x00000146u, 0x0000001fu, + 0x0004003du, 0x0000000au, 0x00000147u, 0x00000020u, 0x000500beu, 0x00000141u, 0x00000148u, 0x00000146u, + 0x00000147u, 0x0004009bu, 0x0000001cu, 0x00000149u, 0x00000148u, 0x000200f9u, 0x00000145u, 0x000200f8u, + 0x00000145u, 0x000700f5u, 0x0000001cu, 0x0000014au, 0x00000143u, 0x00000023u, 0x00000149u, 0x00000144u, + 0x000200feu, 0x0000014au, 0x00010038u, 0x00050036u, 0x0000000au, 0x0000002au, 0x00000000u, 0x00000028u, + 0x00030037u, 0x00000027u, 0x00000029u, 0x000200f8u, 0x0000002bu, 0x0004003bu, 0x0000014eu, 0x0000014fu, + 0x00000007u, 0x00050041u, 0x0000002cu, 0x00000150u, 0x00000029u, 0x000000e6u, 0x0004003du, 0x00000025u, + 0x00000151u, 0x00000150u, 0x00050051u, 0x00000024u, 0x00000152u, 0x00000151u, 0x00000000u, 0x0008004fu, + 0x0000000au, 0x00000153u, 0x00000152u, 0x00000152u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050051u, + 0x00000024u, 0x00000154u, 0x00000151u, 0x00000001u, 0x0008004fu, 0x0000000au, 0x00000155u, 0x00000154u, + 0x00000154u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050051u, 0x00000024u, 0x00000156u, 0x00000151u, + 0x00000002u, 0x0008004fu, 0x0000000au, 0x00000157u, 0x00000156u, 0x00000156u, 0x00000000u, 0x00000001u, + 0x00000002u, 0x00060050u, 0x0000014du, 0x00000158u, 0x00000153u, 0x00000155u, 0x00000157u, 0x0003003eu, + 0x0000014fu, 0x00000158u, 0x0004003du, 0x0000014du, 0x00000159u, 0x0000014fu, 0x00040054u, 0x0000014du, + 0x0000015au, 0x00000159u, 0x00050051u, 0x0000000au, 0x0000015bu, 0x0000015au, 0x00000000u, 0x0004007fu, + 0x0000000au, 0x0000015cu, 0x0000015bu, 0x00050051u, 0x0000000au, 0x0000015du, 0x0000015au, 0x00000001u, + 0x0004007fu, 0x0000000au, 0x0000015eu, 0x0000015du, 0x00050051u, 0x0000000au, 0x0000015fu, 0x0000015au, + 0x00000002u, 0x0004007fu, 0x0000000au, 0x00000160u, 0x0000015fu, 0x00060050u, 0x0000014du, 0x00000161u, + 0x0000015cu, 0x0000015eu, 0x00000160u, 0x00060041u, 0x000000f2u, 0x00000163u, 0x00000029u, 0x000000e6u, + 0x00000162u, 0x0004003du, 0x00000024u, 0x00000164u, 0x00000163u, 0x0008004fu, 0x0000000au, 0x00000165u, + 0x00000164u, 0x00000164u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050091u, 0x0000000au, 0x00000166u, + 0x00000161u, 0x00000165u, 0x000200feu, 0x00000166u, 0x00010038u, 0x00050036u, 0x00000009u, 0x00000034u, + 0x00000000u, 0x0000002fu, 0x00030037u, 0x0000001bu, 0x00000030u, 0x00030037u, 0x0000001bu, 0x00000031u, + 0x00030037u, 0x0000002cu, 0x00000032u, 0x00030037u, 0x0000002eu, 0x00000033u, 0x000200f8u, 0x00000035u, + 0x0004003bu, 0x0000001bu, 0x00000169u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000172u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x0000017bu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000181u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x0000018au, 0x00000007u, 0x0004003bu, 0x00000036u, 0x0000018fu, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x00000193u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000197u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x0000019cu, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000001a6u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000001acu, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000001afu, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000001b3u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000001efu, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000001f3u, 0x00000007u, 0x0004003bu, 0x000001fbu, 0x000001fcu, 0x00000007u, + 0x0004003bu, 0x000001fbu, 0x00000201u, 0x00000007u, 0x0004003bu, 0x000001fbu, 0x0000021du, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x00000225u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000229u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x00000232u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000237u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x0000023au, 0x00000007u, 0x0004003bu, 0x00000036u, 0x0000023eu, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x00000272u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000275u, 0x00000007u, + 0x0004003bu, 0x000001fbu, 0x0000027du, 0x00000007u, 0x0004003bu, 0x000001fbu, 0x00000282u, 0x00000007u, + 0x0004003bu, 0x000001fbu, 0x0000029au, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000002a2u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000002a6u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000002afu, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000002b4u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000002b7u, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000002bbu, 0x00000007u, 0x0004003bu, 0x00000036u, 0x000002efu, 0x00000007u, + 0x0004003bu, 0x00000036u, 0x000002f2u, 0x00000007u, 0x0004003bu, 0x000001fbu, 0x000002fau, 0x00000007u, + 0x0004003bu, 0x000001fbu, 0x000002ffu, 0x00000007u, 0x0004003bu, 0x000001fbu, 0x00000317u, 0x00000007u, + 0x0004003bu, 0x000001fbu, 0x0000031fu, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000324u, 0x00000007u, + 0x0004003du, 0x00000025u, 0x0000016au, 0x00000032u, 0x0004003du, 0x0000000au, 0x0000016bu, 0x00000030u, + 0x00050051u, 0x00000009u, 0x0000016cu, 0x0000016bu, 0x00000000u, 0x00050051u, 0x00000009u, 0x0000016du, + 0x0000016bu, 0x00000001u, 0x00050051u, 0x00000009u, 0x0000016eu, 0x0000016bu, 0x00000002u, 0x00070050u, + 0x00000024u, 0x0000016fu, 0x0000016cu, 0x0000016du, 0x0000016eu, 0x00000059u, 0x00050091u, 0x00000024u, + 0x00000170u, 0x0000016au, 0x0000016fu, 0x0008004fu, 0x0000000au, 0x00000171u, 0x00000170u, 0x00000170u, + 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000169u, 0x00000171u, 0x0004003du, 0x00000025u, + 0x00000173u, 0x00000032u, 0x0004003du, 0x0000000au, 0x00000174u, 0x00000031u, 0x00050051u, 0x00000009u, + 0x00000175u, 0x00000174u, 0x00000000u, 0x00050051u, 0x00000009u, 0x00000176u, 0x00000174u, 0x00000001u, + 0x00050051u, 0x00000009u, 0x00000177u, 0x00000174u, 0x00000002u, 0x00070050u, 0x00000024u, 0x00000178u, + 0x00000175u, 0x00000176u, 0x00000177u, 0x00000059u, 0x00050091u, 0x00000024u, 0x00000179u, 0x00000173u, + 0x00000178u, 0x0008004fu, 0x0000000au, 0x0000017au, 0x00000179u, 0x00000179u, 0x00000000u, 0x00000001u, + 0x00000002u, 0x0003003eu, 0x00000172u, 0x0000017au, 0x0004003du, 0x0000000au, 0x0000017cu, 0x00000030u, + 0x0004003du, 0x0000000au, 0x0000017du, 0x00000031u, 0x00050081u, 0x0000000au, 0x0000017eu, 0x0000017cu, + 0x0000017du, 0x0005008eu, 0x0000000au, 0x00000180u, 0x0000017eu, 0x0000017fu, 0x0003003eu, 0x0000017bu, + 0x00000180u, 0x0004003du, 0x00000025u, 0x00000182u, 0x00000032u, 0x0004003du, 0x0000000au, 0x00000183u, + 0x0000017bu, 0x00050051u, 0x00000009u, 0x00000184u, 0x00000183u, 0x00000000u, 0x00050051u, 0x00000009u, + 0x00000185u, 0x00000183u, 0x00000001u, 0x00050051u, 0x00000009u, 0x00000186u, 0x00000183u, 0x00000002u, + 0x00070050u, 0x00000024u, 0x00000187u, 0x00000184u, 0x00000185u, 0x00000186u, 0x00000059u, 0x00050091u, + 0x00000024u, 0x00000188u, 0x00000182u, 0x00000187u, 0x0008004fu, 0x0000000au, 0x00000189u, 0x00000188u, + 0x00000188u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000181u, 0x00000189u, 0x00050041u, + 0x00000036u, 0x0000018bu, 0x00000169u, 0x00000053u, 0x0004003du, 0x00000009u, 0x0000018cu, 0x0000018bu, + 0x0007000cu, 0x00000009u, 0x0000018eu, 0x00000001u, 0x00000028u, 0x0000018cu, 0x0000018du, 0x0003003eu, + 0x0000018au, 0x0000018eu, 0x00050041u, 0x00000036u, 0x00000190u, 0x00000172u, 0x00000053u, 0x0004003du, + 0x00000009u, 0x00000191u, 0x00000190u, 0x0007000cu, 0x00000009u, 0x00000192u, 0x00000001u, 0x00000028u, + 0x00000191u, 0x0000018du, 0x0003003eu, 0x0000018fu, 0x00000192u, 0x00050041u, 0x00000036u, 0x00000194u, + 0x00000181u, 0x00000053u, 0x0004003du, 0x00000009u, 0x00000195u, 0x00000194u, 0x0007000cu, 0x00000009u, + 0x00000196u, 0x00000001u, 0x00000028u, 0x00000195u, 0x0000018du, 0x0003003eu, 0x00000193u, 0x00000196u, + 0x0004003du, 0x0000000au, 0x00000199u, 0x00000169u, 0x0007004fu, 0x00000198u, 0x0000019au, 0x00000199u, + 0x00000199u, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000009u, 0x0000019bu, 0x00000001u, 0x00000042u, + 0x0000019au, 0x0003003eu, 0x00000197u, 0x0000019bu, 0x0004003du, 0x0000000au, 0x0000019du, 0x00000169u, + 0x0007004fu, 0x00000198u, 0x0000019eu, 0x0000019du, 0x0000019du, 0x00000000u, 0x00000001u, 0x0004003du, + 0x00000009u, 0x0000019fu, 0x0000018au, 0x00050051u, 0x00000009u, 0x000001a0u, 0x0000019eu, 0x00000000u, + 0x00050051u, 0x00000009u, 0x000001a1u, 0x0000019eu, 0x00000001u, 0x00060050u, 0x0000000au, 0x000001a2u, + 0x000001a0u, 0x000001a1u, 0x0000019fu, 0x0006000cu, 0x00000009u, 0x000001a3u, 0x00000001u, 0x00000042u, + 0x000001a2u, 0x00050081u, 0x00000009u, 0x000001a5u, 0x000001a3u, 0x000001a4u, 0x0003003eu, 0x0000019cu, + 0x000001a5u, 0x0004003du, 0x00000009u, 0x000001a7u, 0x0000018au, 0x0004003du, 0x00000009u, 0x000001a8u, + 0x0000019cu, 0x00050088u, 0x00000009u, 0x000001a9u, 0x000001a7u, 0x000001a8u, 0x0008000cu, 0x00000009u, + 0x000001abu, 0x00000001u, 0x0000002bu, 0x000001a9u, 0x000001aau, 0x00000059u, 0x0003003eu, 0x000001a6u, + 0x000001abu, 0x0004003du, 0x00000009u, 0x000001adu, 0x000001a6u, 0x0006000cu, 0x00000009u, 0x000001aeu, + 0x00000001u, 0x00000011u, 0x000001adu, 0x0003003eu, 0x000001acu, 0x000001aeu, 0x0004003du, 0x00000009u, + 0x000001b0u, 0x000001acu, 0x0004003du, 0x00000009u, 0x000001b1u, 0x000001acu, 0x00050085u, 0x00000009u, + 0x000001b2u, 0x000001b0u, 0x000001b1u, 0x0003003eu, 0x000001afu, 0x000001b2u, 0x00050041u, 0x00000036u, + 0x000001b5u, 0x00000033u, 0x000001b4u, 0x0004003du, 0x00000009u, 0x000001b6u, 0x000001b5u, 0x00050041u, + 0x00000036u, 0x000001b8u, 0x00000033u, 0x000001b7u, 0x0004003du, 0x00000009u, 0x000001b9u, 0x000001b8u, + 0x0004003du, 0x00000009u, 0x000001bau, 0x000001acu, 0x00050085u, 0x00000009u, 0x000001bbu, 0x000001b9u, + 0x000001bau, 0x00050081u, 0x00000009u, 0x000001bcu, 0x000001b6u, 0x000001bbu, 0x00050041u, 0x00000036u, + 0x000001beu, 0x00000033u, 0x000001bdu, 0x0004003du, 0x00000009u, 0x000001bfu, 0x000001beu, 0x0004003du, + 0x00000009u, 0x000001c0u, 0x000001afu, 0x00050085u, 0x00000009u, 0x000001c1u, 0x000001bfu, 0x000001c0u, + 0x00050081u, 0x00000009u, 0x000001c2u, 0x000001bcu, 0x000001c1u, 0x00050041u, 0x00000036u, 0x000001c4u, + 0x00000033u, 0x000001c3u, 0x0004003du, 0x00000009u, 0x000001c5u, 0x000001c4u, 0x0004003du, 0x00000009u, + 0x000001c6u, 0x000001afu, 0x0004003du, 0x00000009u, 0x000001c7u, 0x000001acu, 0x00050085u, 0x00000009u, + 0x000001c8u, 0x000001c6u, 0x000001c7u, 0x00050085u, 0x00000009u, 0x000001c9u, 0x000001c5u, 0x000001c8u, + 0x00050081u, 0x00000009u, 0x000001cau, 0x000001c2u, 0x000001c9u, 0x00050041u, 0x00000036u, 0x000001cbu, + 0x00000033u, 0x000000e2u, 0x0004003du, 0x00000009u, 0x000001ccu, 0x000001cbu, 0x0004003du, 0x00000009u, + 0x000001cdu, 0x000001afu, 0x0004003du, 0x00000009u, 0x000001ceu, 0x000001afu, 0x00050085u, 0x00000009u, + 0x000001cfu, 0x000001cdu, 0x000001ceu, 0x00050085u, 0x00000009u, 0x000001d0u, 0x000001ccu, 0x000001cfu, + 0x00050081u, 0x00000009u, 0x000001d1u, 0x000001cau, 0x000001d0u, 0x00050041u, 0x00000036u, 0x000001d3u, + 0x00000033u, 0x000001d2u, 0x0004003du, 0x00000009u, 0x000001d4u, 0x000001d3u, 0x0004003du, 0x00000009u, + 0x000001d5u, 0x000001afu, 0x0004003du, 0x00000009u, 0x000001d6u, 0x000001afu, 0x00050085u, 0x00000009u, + 0x000001d7u, 0x000001d5u, 0x000001d6u, 0x0004003du, 0x00000009u, 0x000001d8u, 0x000001acu, 0x00050085u, + 0x00000009u, 0x000001d9u, 0x000001d7u, 0x000001d8u, 0x00050085u, 0x00000009u, 0x000001dau, 0x000001d4u, + 0x000001d9u, 0x00050081u, 0x00000009u, 0x000001dbu, 0x000001d1u, 0x000001dau, 0x0003003eu, 0x000001b3u, + 0x000001dbu, 0x0004003du, 0x00000009u, 0x000001dcu, 0x000001acu, 0x00050041u, 0x00000036u, 0x000001deu, + 0x00000033u, 0x000001ddu, 0x0004003du, 0x00000009u, 0x000001dfu, 0x000001deu, 0x000500bau, 0x0000001cu, + 0x000001e0u, 0x000001dcu, 0x000001dfu, 0x000300f7u, 0x000001e2u, 0x00000000u, 0x000400fau, 0x000001e0u, + 0x000001e1u, 0x000001e2u, 0x000200f8u, 0x000001e1u, 0x00050041u, 0x00000036u, 0x000001e4u, 0x00000033u, + 0x000001e3u, 0x0004003du, 0x00000009u, 0x000001e5u, 0x000001e4u, 0x0004003du, 0x00000009u, 0x000001e6u, + 0x000001acu, 0x00050041u, 0x00000036u, 0x000001e7u, 0x00000033u, 0x000001ddu, 0x0004003du, 0x00000009u, + 0x000001e8u, 0x000001e7u, 0x00050083u, 0x00000009u, 0x000001e9u, 0x000001e6u, 0x000001e8u, 0x00050041u, + 0x00000036u, 0x000001ebu, 0x00000033u, 0x000001eau, 0x0004003du, 0x00000009u, 0x000001ecu, 0x000001ebu, + 0x00050085u, 0x00000009u, 0x000001edu, 0x000001e9u, 0x000001ecu, 0x00050081u, 0x00000009u, 0x000001eeu, + 0x000001e5u, 0x000001edu, 0x0003003eu, 0x000001b3u, 0x000001eeu, 0x000200f9u, 0x000001e2u, 0x000200f8u, + 0x000001e2u, 0x0004003du, 0x00000009u, 0x000001f0u, 0x00000197u, 0x000500bau, 0x0000001cu, 0x000001f2u, + 0x000001f0u, 0x000001f1u, 0x000300f7u, 0x000001f5u, 0x00000000u, 0x000400fau, 0x000001f2u, 0x000001f4u, + 0x000001f9u, 0x000200f8u, 0x000001f4u, 0x0004003du, 0x00000009u, 0x000001f6u, 0x000001b3u, 0x0004003du, + 0x00000009u, 0x000001f7u, 0x00000197u, 0x00050088u, 0x00000009u, 0x000001f8u, 0x000001f6u, 0x000001f7u, + 0x0003003eu, 0x000001f3u, 0x000001f8u, 0x000200f9u, 0x000001f5u, 0x000200f8u, 0x000001f9u, 0x0003003eu, + 0x000001f3u, 0x00000062u, 0x000200f9u, 0x000001f5u, 0x000200f8u, 0x000001f5u, 0x0004003du, 0x00000009u, + 0x000001fau, 0x000001f3u, 0x0003003eu, 0x000001efu, 0x000001fau, 0x0004003du, 0x00000009u, 0x000001fdu, + 0x000001efu, 0x0004003du, 0x0000000au, 0x000001feu, 0x00000169u, 0x0007004fu, 0x00000198u, 0x000001ffu, + 0x000001feu, 0x000001feu, 0x00000000u, 0x00000001u, 0x0005008eu, 0x00000198u, 0x00000200u, 0x000001ffu, + 0x000001fdu, 0x0003003eu, 0x000001fcu, 0x00000200u, 0x00050041u, 0x00000036u, 0x00000203u, 0x00000033u, + 0x00000202u, 0x0004003du, 0x00000009u, 0x00000204u, 0x00000203u, 0x00050041u, 0x00000036u, 0x00000205u, + 0x000001fcu, 0x00000040u, 0x0004003du, 0x00000009u, 0x00000206u, 0x00000205u, 0x00050085u, 0x00000009u, + 0x00000207u, 0x00000204u, 0x00000206u, 0x00050041u, 0x00000036u, 0x00000209u, 0x00000033u, 0x00000208u, + 0x0004003du, 0x00000009u, 0x0000020au, 0x00000209u, 0x00050041u, 0x00000036u, 0x0000020bu, 0x000001fcu, + 0x00000007u, 0x0004003du, 0x00000009u, 0x0000020cu, 0x0000020bu, 0x00050085u, 0x00000009u, 0x0000020du, + 0x0000020au, 0x0000020cu, 0x00050081u, 0x00000009u, 0x0000020eu, 0x00000207u, 0x0000020du, 0x00050041u, + 0x00000036u, 0x00000210u, 0x00000033u, 0x0000020fu, 0x0004003du, 0x00000009u, 0x00000211u, 0x00000210u, + 0x00050041u, 0x00000036u, 0x00000212u, 0x000001fcu, 0x00000040u, 0x0004003du, 0x00000009u, 0x00000213u, + 0x00000212u, 0x00050085u, 0x00000009u, 0x00000214u, 0x00000211u, 0x00000213u, 0x00050041u, 0x00000036u, + 0x00000216u, 0x00000033u, 0x00000215u, 0x0004003du, 0x00000009u, 0x00000217u, 0x00000216u, 0x00050041u, + 0x00000036u, 0x00000218u, 0x000001fcu, 0x00000007u, 0x0004003du, 0x00000009u, 0x00000219u, 0x00000218u, + 0x00050085u, 0x00000009u, 0x0000021au, 0x00000217u, 0x00000219u, 0x00050081u, 0x00000009u, 0x0000021bu, + 0x00000214u, 0x0000021au, 0x00050050u, 0x00000198u, 0x0000021cu, 0x0000020eu, 0x0000021bu, 0x0003003eu, + 0x00000201u, 0x0000021cu, 0x0004003du, 0x00000198u, 0x0000021eu, 0x00000201u, 0x00050041u, 0x00000036u, + 0x0000021fu, 0x00000033u, 0x000000e6u, 0x0004003du, 0x00000009u, 0x00000220u, 0x0000021fu, 0x00050041u, + 0x00000036u, 0x00000221u, 0x00000033u, 0x00000114u, 0x0004003du, 0x00000009u, 0x00000222u, 0x00000221u, + 0x00050050u, 0x00000198u, 0x00000223u, 0x00000220u, 0x00000222u, 0x00050081u, 0x00000198u, 0x00000224u, + 0x0000021eu, 0x00000223u, 0x0003003eu, 0x0000021du, 0x00000224u, 0x0004003du, 0x0000000au, 0x00000226u, + 0x00000172u, 0x0007004fu, 0x00000198u, 0x00000227u, 0x00000226u, 0x00000226u, 0x00000000u, 0x00000001u, + 0x0006000cu, 0x00000009u, 0x00000228u, 0x00000001u, 0x00000042u, 0x00000227u, 0x0003003eu, 0x00000225u, + 0x00000228u, 0x0004003du, 0x0000000au, 0x0000022au, 0x00000172u, 0x0007004fu, 0x00000198u, 0x0000022bu, + 0x0000022au, 0x0000022au, 0x00000000u, 0x00000001u, 0x0004003du, 0x00000009u, 0x0000022cu, 0x0000018fu, + 0x00050051u, 0x00000009u, 0x0000022du, 0x0000022bu, 0x00000000u, 0x00050051u, 0x00000009u, 0x0000022eu, + 0x0000022bu, 0x00000001u, 0x00060050u, 0x0000000au, 0x0000022fu, 0x0000022du, 0x0000022eu, 0x0000022cu, + 0x0006000cu, 0x00000009u, 0x00000230u, 0x00000001u, 0x00000042u, 0x0000022fu, 0x00050081u, 0x00000009u, + 0x00000231u, 0x00000230u, 0x000001a4u, 0x0003003eu, 0x00000229u, 0x00000231u, 0x0004003du, 0x00000009u, + 0x00000233u, 0x0000018fu, 0x0004003du, 0x00000009u, 0x00000234u, 0x00000229u, 0x00050088u, 0x00000009u, + 0x00000235u, 0x00000233u, 0x00000234u, 0x0008000cu, 0x00000009u, 0x00000236u, 0x00000001u, 0x0000002bu, + 0x00000235u, 0x000001aau, 0x00000059u, 0x0003003eu, 0x00000232u, 0x00000236u, 0x0004003du, 0x00000009u, + 0x00000238u, 0x00000232u, 0x0006000cu, 0x00000009u, 0x00000239u, 0x00000001u, 0x00000011u, 0x00000238u, + 0x0003003eu, 0x00000237u, 0x00000239u, 0x0004003du, 0x00000009u, 0x0000023bu, 0x00000237u, 0x0004003du, + 0x00000009u, 0x0000023cu, 0x00000237u, 0x00050085u, 0x00000009u, 0x0000023du, 0x0000023bu, 0x0000023cu, + 0x0003003eu, 0x0000023au, 0x0000023du, 0x00050041u, 0x00000036u, 0x0000023fu, 0x00000033u, 0x000001b4u, + 0x0004003du, 0x00000009u, 0x00000240u, 0x0000023fu, 0x00050041u, 0x00000036u, 0x00000241u, 0x00000033u, + 0x000001b7u, 0x0004003du, 0x00000009u, 0x00000242u, 0x00000241u, 0x0004003du, 0x00000009u, 0x00000243u, + 0x00000237u, 0x00050085u, 0x00000009u, 0x00000244u, 0x00000242u, 0x00000243u, 0x00050081u, 0x00000009u, + 0x00000245u, 0x00000240u, 0x00000244u, 0x00050041u, 0x00000036u, 0x00000246u, 0x00000033u, 0x000001bdu, + 0x0004003du, 0x00000009u, 0x00000247u, 0x00000246u, 0x0004003du, 0x00000009u, 0x00000248u, 0x0000023au, + 0x00050085u, 0x00000009u, 0x00000249u, 0x00000247u, 0x00000248u, 0x00050081u, 0x00000009u, 0x0000024au, + 0x00000245u, 0x00000249u, 0x00050041u, 0x00000036u, 0x0000024bu, 0x00000033u, 0x000001c3u, 0x0004003du, + 0x00000009u, 0x0000024cu, 0x0000024bu, 0x0004003du, 0x00000009u, 0x0000024du, 0x0000023au, 0x0004003du, + 0x00000009u, 0x0000024eu, 0x00000237u, 0x00050085u, 0x00000009u, 0x0000024fu, 0x0000024du, 0x0000024eu, + 0x00050085u, 0x00000009u, 0x00000250u, 0x0000024cu, 0x0000024fu, 0x00050081u, 0x00000009u, 0x00000251u, + 0x0000024au, 0x00000250u, 0x00050041u, 0x00000036u, 0x00000252u, 0x00000033u, 0x000000e2u, 0x0004003du, + 0x00000009u, 0x00000253u, 0x00000252u, 0x0004003du, 0x00000009u, 0x00000254u, 0x0000023au, 0x0004003du, + 0x00000009u, 0x00000255u, 0x0000023au, 0x00050085u, 0x00000009u, 0x00000256u, 0x00000254u, 0x00000255u, + 0x00050085u, 0x00000009u, 0x00000257u, 0x00000253u, 0x00000256u, 0x00050081u, 0x00000009u, 0x00000258u, + 0x00000251u, 0x00000257u, 0x00050041u, 0x00000036u, 0x00000259u, 0x00000033u, 0x000001d2u, 0x0004003du, + 0x00000009u, 0x0000025au, 0x00000259u, 0x0004003du, 0x00000009u, 0x0000025bu, 0x0000023au, 0x0004003du, + 0x00000009u, 0x0000025cu, 0x0000023au, 0x00050085u, 0x00000009u, 0x0000025du, 0x0000025bu, 0x0000025cu, + 0x0004003du, 0x00000009u, 0x0000025eu, 0x00000237u, 0x00050085u, 0x00000009u, 0x0000025fu, 0x0000025du, + 0x0000025eu, 0x00050085u, 0x00000009u, 0x00000260u, 0x0000025au, 0x0000025fu, 0x00050081u, 0x00000009u, + 0x00000261u, 0x00000258u, 0x00000260u, 0x0003003eu, 0x0000023eu, 0x00000261u, 0x0004003du, 0x00000009u, + 0x00000262u, 0x00000237u, 0x00050041u, 0x00000036u, 0x00000263u, 0x00000033u, 0x000001ddu, 0x0004003du, + 0x00000009u, 0x00000264u, 0x00000263u, 0x000500bau, 0x0000001cu, 0x00000265u, 0x00000262u, 0x00000264u, + 0x000300f7u, 0x00000267u, 0x00000000u, 0x000400fau, 0x00000265u, 0x00000266u, 0x00000267u, 0x000200f8u, + 0x00000266u, 0x00050041u, 0x00000036u, 0x00000268u, 0x00000033u, 0x000001e3u, 0x0004003du, 0x00000009u, + 0x00000269u, 0x00000268u, 0x0004003du, 0x00000009u, 0x0000026au, 0x00000237u, 0x00050041u, 0x00000036u, + 0x0000026bu, 0x00000033u, 0x000001ddu, 0x0004003du, 0x00000009u, 0x0000026cu, 0x0000026bu, 0x00050083u, + 0x00000009u, 0x0000026du, 0x0000026au, 0x0000026cu, 0x00050041u, 0x00000036u, 0x0000026eu, 0x00000033u, + 0x000001eau, 0x0004003du, 0x00000009u, 0x0000026fu, 0x0000026eu, 0x00050085u, 0x00000009u, 0x00000270u, + 0x0000026du, 0x0000026fu, 0x00050081u, 0x00000009u, 0x00000271u, 0x00000269u, 0x00000270u, 0x0003003eu, + 0x0000023eu, 0x00000271u, 0x000200f9u, 0x00000267u, 0x000200f8u, 0x00000267u, 0x0004003du, 0x00000009u, + 0x00000273u, 0x00000225u, 0x000500bau, 0x0000001cu, 0x00000274u, 0x00000273u, 0x000001f1u, 0x000300f7u, + 0x00000277u, 0x00000000u, 0x000400fau, 0x00000274u, 0x00000276u, 0x0000027bu, 0x000200f8u, 0x00000276u, + 0x0004003du, 0x00000009u, 0x00000278u, 0x0000023eu, 0x0004003du, 0x00000009u, 0x00000279u, 0x00000225u, + 0x00050088u, 0x00000009u, 0x0000027au, 0x00000278u, 0x00000279u, 0x0003003eu, 0x00000275u, 0x0000027au, + 0x000200f9u, 0x00000277u, 0x000200f8u, 0x0000027bu, 0x0003003eu, 0x00000275u, 0x00000062u, 0x000200f9u, + 0x00000277u, 0x000200f8u, 0x00000277u, 0x0004003du, 0x00000009u, 0x0000027cu, 0x00000275u, 0x0003003eu, + 0x00000272u, 0x0000027cu, 0x0004003du, 0x00000009u, 0x0000027eu, 0x00000272u, 0x0004003du, 0x0000000au, + 0x0000027fu, 0x00000172u, 0x0007004fu, 0x00000198u, 0x00000280u, 0x0000027fu, 0x0000027fu, 0x00000000u, + 0x00000001u, 0x0005008eu, 0x00000198u, 0x00000281u, 0x00000280u, 0x0000027eu, 0x0003003eu, 0x0000027du, + 0x00000281u, 0x00050041u, 0x00000036u, 0x00000283u, 0x00000033u, 0x00000202u, 0x0004003du, 0x00000009u, + 0x00000284u, 0x00000283u, 0x00050041u, 0x00000036u, 0x00000285u, 0x0000027du, 0x00000040u, 0x0004003du, + 0x00000009u, 0x00000286u, 0x00000285u, 0x00050085u, 0x00000009u, 0x00000287u, 0x00000284u, 0x00000286u, + 0x00050041u, 0x00000036u, 0x00000288u, 0x00000033u, 0x00000208u, 0x0004003du, 0x00000009u, 0x00000289u, + 0x00000288u, 0x00050041u, 0x00000036u, 0x0000028au, 0x0000027du, 0x00000007u, 0x0004003du, 0x00000009u, + 0x0000028bu, 0x0000028au, 0x00050085u, 0x00000009u, 0x0000028cu, 0x00000289u, 0x0000028bu, 0x00050081u, + 0x00000009u, 0x0000028du, 0x00000287u, 0x0000028cu, 0x00050041u, 0x00000036u, 0x0000028eu, 0x00000033u, + 0x0000020fu, 0x0004003du, 0x00000009u, 0x0000028fu, 0x0000028eu, 0x00050041u, 0x00000036u, 0x00000290u, + 0x0000027du, 0x00000040u, 0x0004003du, 0x00000009u, 0x00000291u, 0x00000290u, 0x00050085u, 0x00000009u, + 0x00000292u, 0x0000028fu, 0x00000291u, 0x00050041u, 0x00000036u, 0x00000293u, 0x00000033u, 0x00000215u, + 0x0004003du, 0x00000009u, 0x00000294u, 0x00000293u, 0x00050041u, 0x00000036u, 0x00000295u, 0x0000027du, + 0x00000007u, 0x0004003du, 0x00000009u, 0x00000296u, 0x00000295u, 0x00050085u, 0x00000009u, 0x00000297u, + 0x00000294u, 0x00000296u, 0x00050081u, 0x00000009u, 0x00000298u, 0x00000292u, 0x00000297u, 0x00050050u, + 0x00000198u, 0x00000299u, 0x0000028du, 0x00000298u, 0x0003003eu, 0x00000282u, 0x00000299u, 0x0004003du, + 0x00000198u, 0x0000029bu, 0x00000282u, 0x00050041u, 0x00000036u, 0x0000029cu, 0x00000033u, 0x000000e6u, + 0x0004003du, 0x00000009u, 0x0000029du, 0x0000029cu, 0x00050041u, 0x00000036u, 0x0000029eu, 0x00000033u, + 0x00000114u, 0x0004003du, 0x00000009u, 0x0000029fu, 0x0000029eu, 0x00050050u, 0x00000198u, 0x000002a0u, + 0x0000029du, 0x0000029fu, 0x00050081u, 0x00000198u, 0x000002a1u, 0x0000029bu, 0x000002a0u, 0x0003003eu, + 0x0000029au, 0x000002a1u, 0x0004003du, 0x0000000au, 0x000002a3u, 0x00000181u, 0x0007004fu, 0x00000198u, + 0x000002a4u, 0x000002a3u, 0x000002a3u, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000009u, 0x000002a5u, + 0x00000001u, 0x00000042u, 0x000002a4u, 0x0003003eu, 0x000002a2u, 0x000002a5u, 0x0004003du, 0x0000000au, + 0x000002a7u, 0x00000181u, 0x0007004fu, 0x00000198u, 0x000002a8u, 0x000002a7u, 0x000002a7u, 0x00000000u, + 0x00000001u, 0x0004003du, 0x00000009u, 0x000002a9u, 0x00000193u, 0x00050051u, 0x00000009u, 0x000002aau, + 0x000002a8u, 0x00000000u, 0x00050051u, 0x00000009u, 0x000002abu, 0x000002a8u, 0x00000001u, 0x00060050u, + 0x0000000au, 0x000002acu, 0x000002aau, 0x000002abu, 0x000002a9u, 0x0006000cu, 0x00000009u, 0x000002adu, + 0x00000001u, 0x00000042u, 0x000002acu, 0x00050081u, 0x00000009u, 0x000002aeu, 0x000002adu, 0x000001a4u, + 0x0003003eu, 0x000002a6u, 0x000002aeu, 0x0004003du, 0x00000009u, 0x000002b0u, 0x00000193u, 0x0004003du, + 0x00000009u, 0x000002b1u, 0x000002a6u, 0x00050088u, 0x00000009u, 0x000002b2u, 0x000002b0u, 0x000002b1u, + 0x0008000cu, 0x00000009u, 0x000002b3u, 0x00000001u, 0x0000002bu, 0x000002b2u, 0x000001aau, 0x00000059u, + 0x0003003eu, 0x000002afu, 0x000002b3u, 0x0004003du, 0x00000009u, 0x000002b5u, 0x000002afu, 0x0006000cu, + 0x00000009u, 0x000002b6u, 0x00000001u, 0x00000011u, 0x000002b5u, 0x0003003eu, 0x000002b4u, 0x000002b6u, + 0x0004003du, 0x00000009u, 0x000002b8u, 0x000002b4u, 0x0004003du, 0x00000009u, 0x000002b9u, 0x000002b4u, + 0x00050085u, 0x00000009u, 0x000002bau, 0x000002b8u, 0x000002b9u, 0x0003003eu, 0x000002b7u, 0x000002bau, + 0x00050041u, 0x00000036u, 0x000002bcu, 0x00000033u, 0x000001b4u, 0x0004003du, 0x00000009u, 0x000002bdu, + 0x000002bcu, 0x00050041u, 0x00000036u, 0x000002beu, 0x00000033u, 0x000001b7u, 0x0004003du, 0x00000009u, + 0x000002bfu, 0x000002beu, 0x0004003du, 0x00000009u, 0x000002c0u, 0x000002b4u, 0x00050085u, 0x00000009u, + 0x000002c1u, 0x000002bfu, 0x000002c0u, 0x00050081u, 0x00000009u, 0x000002c2u, 0x000002bdu, 0x000002c1u, + 0x00050041u, 0x00000036u, 0x000002c3u, 0x00000033u, 0x000001bdu, 0x0004003du, 0x00000009u, 0x000002c4u, + 0x000002c3u, 0x0004003du, 0x00000009u, 0x000002c5u, 0x000002b7u, 0x00050085u, 0x00000009u, 0x000002c6u, + 0x000002c4u, 0x000002c5u, 0x00050081u, 0x00000009u, 0x000002c7u, 0x000002c2u, 0x000002c6u, 0x00050041u, + 0x00000036u, 0x000002c8u, 0x00000033u, 0x000001c3u, 0x0004003du, 0x00000009u, 0x000002c9u, 0x000002c8u, + 0x0004003du, 0x00000009u, 0x000002cau, 0x000002b7u, 0x0004003du, 0x00000009u, 0x000002cbu, 0x000002b4u, + 0x00050085u, 0x00000009u, 0x000002ccu, 0x000002cau, 0x000002cbu, 0x00050085u, 0x00000009u, 0x000002cdu, + 0x000002c9u, 0x000002ccu, 0x00050081u, 0x00000009u, 0x000002ceu, 0x000002c7u, 0x000002cdu, 0x00050041u, + 0x00000036u, 0x000002cfu, 0x00000033u, 0x000000e2u, 0x0004003du, 0x00000009u, 0x000002d0u, 0x000002cfu, + 0x0004003du, 0x00000009u, 0x000002d1u, 0x000002b7u, 0x0004003du, 0x00000009u, 0x000002d2u, 0x000002b7u, + 0x00050085u, 0x00000009u, 0x000002d3u, 0x000002d1u, 0x000002d2u, 0x00050085u, 0x00000009u, 0x000002d4u, + 0x000002d0u, 0x000002d3u, 0x00050081u, 0x00000009u, 0x000002d5u, 0x000002ceu, 0x000002d4u, 0x00050041u, + 0x00000036u, 0x000002d6u, 0x00000033u, 0x000001d2u, 0x0004003du, 0x00000009u, 0x000002d7u, 0x000002d6u, + 0x0004003du, 0x00000009u, 0x000002d8u, 0x000002b7u, 0x0004003du, 0x00000009u, 0x000002d9u, 0x000002b7u, + 0x00050085u, 0x00000009u, 0x000002dau, 0x000002d8u, 0x000002d9u, 0x0004003du, 0x00000009u, 0x000002dbu, + 0x000002b4u, 0x00050085u, 0x00000009u, 0x000002dcu, 0x000002dau, 0x000002dbu, 0x00050085u, 0x00000009u, + 0x000002ddu, 0x000002d7u, 0x000002dcu, 0x00050081u, 0x00000009u, 0x000002deu, 0x000002d5u, 0x000002ddu, + 0x0003003eu, 0x000002bbu, 0x000002deu, 0x0004003du, 0x00000009u, 0x000002dfu, 0x000002b4u, 0x00050041u, + 0x00000036u, 0x000002e0u, 0x00000033u, 0x000001ddu, 0x0004003du, 0x00000009u, 0x000002e1u, 0x000002e0u, + 0x000500bau, 0x0000001cu, 0x000002e2u, 0x000002dfu, 0x000002e1u, 0x000300f7u, 0x000002e4u, 0x00000000u, + 0x000400fau, 0x000002e2u, 0x000002e3u, 0x000002e4u, 0x000200f8u, 0x000002e3u, 0x00050041u, 0x00000036u, + 0x000002e5u, 0x00000033u, 0x000001e3u, 0x0004003du, 0x00000009u, 0x000002e6u, 0x000002e5u, 0x0004003du, + 0x00000009u, 0x000002e7u, 0x000002b4u, 0x00050041u, 0x00000036u, 0x000002e8u, 0x00000033u, 0x000001ddu, + 0x0004003du, 0x00000009u, 0x000002e9u, 0x000002e8u, 0x00050083u, 0x00000009u, 0x000002eau, 0x000002e7u, + 0x000002e9u, 0x00050041u, 0x00000036u, 0x000002ebu, 0x00000033u, 0x000001eau, 0x0004003du, 0x00000009u, + 0x000002ecu, 0x000002ebu, 0x00050085u, 0x00000009u, 0x000002edu, 0x000002eau, 0x000002ecu, 0x00050081u, + 0x00000009u, 0x000002eeu, 0x000002e6u, 0x000002edu, 0x0003003eu, 0x000002bbu, 0x000002eeu, 0x000200f9u, + 0x000002e4u, 0x000200f8u, 0x000002e4u, 0x0004003du, 0x00000009u, 0x000002f0u, 0x000002a2u, 0x000500bau, + 0x0000001cu, 0x000002f1u, 0x000002f0u, 0x000001f1u, 0x000300f7u, 0x000002f4u, 0x00000000u, 0x000400fau, + 0x000002f1u, 0x000002f3u, 0x000002f8u, 0x000200f8u, 0x000002f3u, 0x0004003du, 0x00000009u, 0x000002f5u, + 0x000002bbu, 0x0004003du, 0x00000009u, 0x000002f6u, 0x000002a2u, 0x00050088u, 0x00000009u, 0x000002f7u, + 0x000002f5u, 0x000002f6u, 0x0003003eu, 0x000002f2u, 0x000002f7u, 0x000200f9u, 0x000002f4u, 0x000200f8u, + 0x000002f8u, 0x0003003eu, 0x000002f2u, 0x00000062u, 0x000200f9u, 0x000002f4u, 0x000200f8u, 0x000002f4u, + 0x0004003du, 0x00000009u, 0x000002f9u, 0x000002f2u, 0x0003003eu, 0x000002efu, 0x000002f9u, 0x0004003du, + 0x00000009u, 0x000002fbu, 0x000002efu, 0x0004003du, 0x0000000au, 0x000002fcu, 0x00000181u, 0x0007004fu, + 0x00000198u, 0x000002fdu, 0x000002fcu, 0x000002fcu, 0x00000000u, 0x00000001u, 0x0005008eu, 0x00000198u, + 0x000002feu, 0x000002fdu, 0x000002fbu, 0x0003003eu, 0x000002fau, 0x000002feu, 0x00050041u, 0x00000036u, + 0x00000300u, 0x00000033u, 0x00000202u, 0x0004003du, 0x00000009u, 0x00000301u, 0x00000300u, 0x00050041u, + 0x00000036u, 0x00000302u, 0x000002fau, 0x00000040u, 0x0004003du, 0x00000009u, 0x00000303u, 0x00000302u, + 0x00050085u, 0x00000009u, 0x00000304u, 0x00000301u, 0x00000303u, 0x00050041u, 0x00000036u, 0x00000305u, + 0x00000033u, 0x00000208u, 0x0004003du, 0x00000009u, 0x00000306u, 0x00000305u, 0x00050041u, 0x00000036u, + 0x00000307u, 0x000002fau, 0x00000007u, 0x0004003du, 0x00000009u, 0x00000308u, 0x00000307u, 0x00050085u, + 0x00000009u, 0x00000309u, 0x00000306u, 0x00000308u, 0x00050081u, 0x00000009u, 0x0000030au, 0x00000304u, + 0x00000309u, 0x00050041u, 0x00000036u, 0x0000030bu, 0x00000033u, 0x0000020fu, 0x0004003du, 0x00000009u, + 0x0000030cu, 0x0000030bu, 0x00050041u, 0x00000036u, 0x0000030du, 0x000002fau, 0x00000040u, 0x0004003du, + 0x00000009u, 0x0000030eu, 0x0000030du, 0x00050085u, 0x00000009u, 0x0000030fu, 0x0000030cu, 0x0000030eu, + 0x00050041u, 0x00000036u, 0x00000310u, 0x00000033u, 0x00000215u, 0x0004003du, 0x00000009u, 0x00000311u, + 0x00000310u, 0x00050041u, 0x00000036u, 0x00000312u, 0x000002fau, 0x00000007u, 0x0004003du, 0x00000009u, + 0x00000313u, 0x00000312u, 0x00050085u, 0x00000009u, 0x00000314u, 0x00000311u, 0x00000313u, 0x00050081u, + 0x00000009u, 0x00000315u, 0x0000030fu, 0x00000314u, 0x00050050u, 0x00000198u, 0x00000316u, 0x0000030au, + 0x00000315u, 0x0003003eu, 0x000002ffu, 0x00000316u, 0x0004003du, 0x00000198u, 0x00000318u, 0x000002ffu, + 0x00050041u, 0x00000036u, 0x00000319u, 0x00000033u, 0x000000e6u, 0x0004003du, 0x00000009u, 0x0000031au, + 0x00000319u, 0x00050041u, 0x00000036u, 0x0000031bu, 0x00000033u, 0x00000114u, 0x0004003du, 0x00000009u, + 0x0000031cu, 0x0000031bu, 0x00050050u, 0x00000198u, 0x0000031du, 0x0000031au, 0x0000031cu, 0x00050081u, + 0x00000198u, 0x0000031eu, 0x00000318u, 0x0000031du, 0x0003003eu, 0x00000317u, 0x0000031eu, 0x0004003du, + 0x00000198u, 0x00000320u, 0x0000021du, 0x0004003du, 0x00000198u, 0x00000321u, 0x0000029au, 0x00050081u, + 0x00000198u, 0x00000322u, 0x00000320u, 0x00000321u, 0x0005008eu, 0x00000198u, 0x00000323u, 0x00000322u, + 0x0000017fu, 0x0003003eu, 0x0000031fu, 0x00000323u, 0x0004003du, 0x00000198u, 0x00000325u, 0x00000317u, + 0x0004003du, 0x00000198u, 0x00000326u, 0x0000031fu, 0x00050083u, 0x00000198u, 0x00000327u, 0x00000325u, + 0x00000326u, 0x0006000cu, 0x00000009u, 0x00000328u, 0x00000001u, 0x00000042u, 0x00000327u, 0x0003003eu, + 0x00000324u, 0x00000328u, 0x0004003du, 0x00000009u, 0x00000329u, 0x00000324u, 0x0008000cu, 0x00000009u, + 0x0000032bu, 0x00000001u, 0x0000002bu, 0x00000329u, 0x00000062u, 0x0000032au, 0x000200feu, 0x0000032bu, + 0x00010038u, 0x00050036u, 0x00000006u, 0x0000003du, 0x00000000u, 0x00000037u, 0x00030037u, 0x0000001bu, + 0x00000038u, 0x00030037u, 0x0000001bu, 0x00000039u, 0x00030037u, 0x00000027u, 0x0000003au, 0x00030037u, + 0x0000002eu, 0x0000003bu, 0x00030037u, 0x00000036u, 0x0000003cu, 0x000200f8u, 0x0000003eu, 0x0004003bu, + 0x00000036u, 0x0000032eu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000032fu, 0x00000007u, 0x0004003bu, + 0x0000001bu, 0x00000331u, 0x00000007u, 0x0004003bu, 0x0000002cu, 0x00000333u, 0x00000007u, 0x0004003bu, + 0x0000002eu, 0x00000336u, 0x00000007u, 0x0004003du, 0x0000000au, 0x00000330u, 0x00000038u, 0x0003003eu, + 0x0000032fu, 0x00000330u, 0x0004003du, 0x0000000au, 0x00000332u, 0x00000039u, 0x0003003eu, 0x00000331u, + 0x00000332u, 0x00050041u, 0x0000002cu, 0x00000334u, 0x0000003au, 0x000000e6u, 0x0004003du, 0x00000025u, + 0x00000335u, 0x00000334u, 0x0003003eu, 0x00000333u, 0x00000335u, 0x0004003du, 0x0000002du, 0x00000337u, + 0x0000003bu, 0x0003003eu, 0x00000336u, 0x00000337u, 0x00080039u, 0x00000009u, 0x00000338u, 0x00000034u, + 0x0000032fu, 0x00000331u, 0x00000333u, 0x00000336u, 0x0003003eu, 0x0000032eu, 0x00000338u, 0x0004003du, + 0x00000009u, 0x00000339u, 0x0000032eu, 0x0004003du, 0x00000009u, 0x0000033au, 0x0000003cu, 0x000500b8u, + 0x0000001cu, 0x0000033bu, 0x00000339u, 0x0000033au, 0x000300f7u, 0x0000033du, 0x00000000u, 0x000400fau, + 0x0000033bu, 0x0000033cu, 0x0000033du, 0x000200f8u, 0x0000033cu, 0x000200feu, 0x00000040u, 0x000200f8u, + 0x0000033du, 0x0004003du, 0x00000009u, 0x0000033fu, 0x0000032eu, 0x0004003du, 0x00000009u, 0x00000340u, + 0x0000003cu, 0x00050085u, 0x00000009u, 0x00000342u, 0x00000340u, 0x00000341u, 0x000500b8u, 0x0000001cu, + 0x00000343u, 0x0000033fu, 0x00000342u, 0x000300f7u, 0x00000345u, 0x00000000u, 0x000400fau, 0x00000343u, + 0x00000344u, 0x00000345u, 0x000200f8u, 0x00000344u, 0x000200feu, 0x00000007u, 0x000200f8u, 0x00000345u, + 0x0004003du, 0x00000009u, 0x00000347u, 0x0000032eu, 0x0004003du, 0x00000009u, 0x00000348u, 0x0000003cu, + 0x00050085u, 0x00000009u, 0x0000034au, 0x00000348u, 0x00000349u, 0x000500b8u, 0x0000001cu, 0x0000034bu, + 0x00000347u, 0x0000034au, 0x000300f7u, 0x0000034du, 0x00000000u, 0x000400fau, 0x0000034bu, 0x0000034cu, + 0x0000034du, 0x000200f8u, 0x0000034cu, 0x000200feu, 0x00000053u, 0x000200f8u, 0x0000034du, 0x000200feu, + 0x0000005du, 0x00010038u, +}; + +static const uint32_t kSpv_ts_polygon_mesh[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000781u, 0x00000000u, 0x00020011u, 0x0000000bu, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x001b000fu, 0x000014f5u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00000357u, 0x0000035eu, 0x00000363u, + 0x0000036eu, 0x0000037fu, 0x0000038du, 0x0000039cu, 0x000003a8u, 0x000003b8u, 0x0000041bu, 0x00000437u, + 0x00000446u, 0x00000452u, 0x00000461u, 0x0000046bu, 0x00000736u, 0x00000769u, 0x0000076du, 0x00000771u, + 0x00000775u, 0x0000077au, 0x0000077fu, 0x0006014bu, 0x00000004u, 0x00000026u, 0x00000007u, 0x00000008u, + 0x00000008u, 0x00040010u, 0x00000004u, 0x0000001au, 0x00000040u, 0x00040010u, 0x00000004u, 0x00001496u, + 0x00000040u, 0x00030010u, 0x00000004u, 0x000014b2u, 0x00030003u, 0x00000002u, 0x000001ccu, 0x00060004u, + 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, 0x000d0004u, 0x455f4c47u, 0x735f5458u, + 0x65646168u, 0x78655f72u, 0x63696c70u, 0x615f7469u, 0x68746972u, 0x6974656du, 0x79745f63u, 0x5f736570u, + 0x36746e69u, 0x00000034u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00050005u, 0x0000000eu, + 0x656d6143u, 0x6f506172u, 0x00006573u, 0x00070006u, 0x0000000eu, 0x00000000u, 0x6c726f77u, 0x6f745f64u, + 0x6d61635fu, 0x00617265u, 0x00060005u, 0x00000010u, 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, + 0x00040006u, 0x00000010u, 0x00000000u, 0x00007863u, 0x00040006u, 0x00000010u, 0x00000001u, 0x00007963u, + 0x00050006u, 0x00000010u, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, 0x00000010u, 0x00000003u, + 0x5f676d69u, 0x00000068u, 0x00050006u, 0x00000010u, 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, + 0x00000010u, 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x00000010u, 0x00000006u, 0x796c6f70u, + 0x00000032u, 0x00050006u, 0x00000010u, 0x00000007u, 0x796c6f70u, 0x00000033u, 0x00050006u, 0x00000010u, + 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, 0x00000010u, 0x00000009u, 0x796c6f70u, 0x00000035u, + 0x00070006u, 0x00000010u, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, + 0x00000010u, 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, + 0x00000010u, 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, + 0x00000010u, 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, 0x00000010u, 0x0000000eu, + 0x635f646cu, 0x00000000u, 0x00050006u, 0x00000010u, 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, + 0x00000010u, 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x00000010u, 0x00000011u, 0x665f646cu, + 0x00000000u, 0x00200005u, 0x00000016u, 0x65687466u, 0x705f6174u, 0x656a6f72u, 0x76287463u, 0x733b3366u, + 0x63757274u, 0x61432d74u, 0x6172656du, 0x65736f50u, 0x34666d2du, 0x733b3134u, 0x63757274u, 0x54462d74u, + 0x61746568u, 0x656d6143u, 0x662d6172u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, + 0x00003b31u, 0x00050005u, 0x00000013u, 0x6c726f77u, 0x6f705f64u, 0x00000073u, 0x00040005u, 0x00000014u, + 0x65736f70u, 0x00000000u, 0x00030005u, 0x00000015u, 0x006d6163u, 0x00080005u, 0x0000001bu, 0x79726162u, + 0x7265765fu, 0x5f786574u, 0x6e756f63u, 0x31752874u, 0x0000003bu, 0x00040005u, 0x0000001au, 0x6576656cu, + 0x0000006cu, 0x00080005u, 0x0000001eu, 0x79726162u, 0x6972745fu, 0x6c676e61u, 0x6f635f65u, 0x28746e75u, + 0x003b3175u, 0x00040005u, 0x0000001du, 0x6576656cu, 0x0000006cu, 0x00080005u, 0x00000024u, 0x79726162u, + 0x7265765fu, 0x5f786574u, 0x75287675u, 0x31753b31u, 0x0000003bu, 0x00050005u, 0x00000022u, 0x74726576u, + 0x695f7865u, 0x00007864u, 0x00040005u, 0x00000023u, 0x6576656cu, 0x0000006cu, 0x000b0005u, 0x0000002cu, + 0x79726162u, 0x746e695fu, 0x6f707265u, 0x6574616cu, 0x33667628u, 0x3366763bu, 0x3366763bu, 0x3266763bu, + 0x0000003bu, 0x00030005u, 0x00000028u, 0x00003076u, 0x00030005u, 0x00000029u, 0x00003176u, 0x00030005u, + 0x0000002au, 0x00003276u, 0x00030005u, 0x0000002bu, 0x00007675u, 0x000a0005u, 0x00000032u, 0x79726162u, + 0x6972745fu, 0x6c676e61u, 0x6e695f65u, 0x65636964u, 0x31752873u, 0x3b31753bu, 0x00000000u, 0x00040005u, + 0x00000030u, 0x5f697274u, 0x00786469u, 0x00040005u, 0x00000031u, 0x6576656cu, 0x0000006cu, 0x00040005u, + 0x00000034u, 0x5f6d6163u, 0x00007470u, 0x00040005u, 0x00000043u, 0x74706564u, 0x00000068u, 0x00050005u, + 0x00000047u, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00040005u, 0x00000053u, 0x666c6168u, 0x0069705fu, + 0x00060005u, 0x00000060u, 0x75657370u, 0x665f6f64u, 0x6c61636fu, 0x00000000u, 0x00040005u, 0x00000064u, + 0x6c635f78u, 0x00007069u, 0x00040005u, 0x00000070u, 0x6c635f79u, 0x00007069u, 0x00040005u, 0x00000082u, + 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x00000086u, 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, + 0x0000008du, 0x68706c61u, 0x00000061u, 0x00030005u, 0x00000090u, 0x00003261u, 0x00030005u, 0x00000094u, + 0x00003361u, 0x00030005u, 0x00000098u, 0x00003461u, 0x00030005u, 0x0000009cu, 0x00003561u, 0x00040005u, + 0x000000a0u, 0x746c6564u, 0x00000061u, 0x00040005u, 0x000000d3u, 0x6c616373u, 0x00000065u, 0x00050005u, + 0x000000deu, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x000000e3u, 0x65786970u, 0x69645f6cu, + 0x00007473u, 0x00040005u, 0x00000100u, 0x65786970u, 0x0000006cu, 0x00040005u, 0x00000109u, 0x646e5f78u, + 0x00000063u, 0x00040005u, 0x00000112u, 0x646e5f79u, 0x00000063u, 0x00040005u, 0x00000120u, 0x61765f7au, + 0x0065756cu, 0x00040005u, 0x0000012eu, 0x646e5f7au, 0x00000063u, 0x00030005u, 0x0000017cu, 0x00737675u, + 0x00030005u, 0x00000194u, 0x00776f72u, 0x00030005u, 0x00000195u, 0x006c6f63u, 0x00030005u, 0x000001beu, + 0x00776f72u, 0x00030005u, 0x000001bfu, 0x006c6f63u, 0x00030005u, 0x00000206u, 0x00000077u, 0x00040005u, + 0x00000229u, 0x73697274u, 0x00000000u, 0x00050005u, 0x0000023eu, 0x5f776f72u, 0x72617473u, 0x00000074u, + 0x00030005u, 0x00000240u, 0x00000074u, 0x00030005u, 0x00000242u, 0x00776f72u, 0x00030005u, 0x00000243u, + 0x006c6f63u, 0x00040005u, 0x00000245u, 0x645f7369u, 0x006e776fu, 0x00030005u, 0x00000259u, 0x0000746cu, + 0x00030005u, 0x00000269u, 0x0000746cu, 0x00030005u, 0x00000279u, 0x00003069u, 0x00030005u, 0x0000027fu, + 0x00003169u, 0x00030005u, 0x00000286u, 0x00003269u, 0x00050005u, 0x000002a9u, 0x5f776f72u, 0x72617473u, + 0x00000074u, 0x00030005u, 0x000002abu, 0x00000074u, 0x00030005u, 0x000002adu, 0x00776f72u, 0x00030005u, + 0x000002aeu, 0x006c6f63u, 0x00040005u, 0x000002afu, 0x645f7369u, 0x006e776fu, 0x00030005u, 0x000002c2u, + 0x0000746cu, 0x00030005u, 0x000002d2u, 0x0000746cu, 0x00030005u, 0x000002e3u, 0x0000746cu, 0x00030005u, + 0x000002f4u, 0x0000746cu, 0x00030005u, 0x00000305u, 0x0000746cu, 0x00030005u, 0x00000316u, 0x0000746cu, + 0x00030005u, 0x00000326u, 0x00003069u, 0x00030005u, 0x0000032cu, 0x00003169u, 0x00030005u, 0x00000333u, + 0x00003269u, 0x00050005u, 0x00000354u, 0x6972705fu, 0x6f635f6du, 0x00746e75u, 0x00050005u, 0x00000355u, + 0x6e756863u, 0x64695f6bu, 0x00000000u, 0x00060005u, 0x00000357u, 0x575f6c67u, 0x476b726fu, 0x70756f72u, + 0x00004449u, 0x00040005u, 0x0000035bu, 0x64627573u, 0x00007669u, 0x00070005u, 0x0000035cu, 0x796c6f50u, + 0x546e6f67u, 0x506b7361u, 0x6f6c7961u, 0x00006461u, 0x00060006u, 0x0000035cu, 0x00000000u, 0x72657571u, + 0x64695f79u, 0x00000000u, 0x00050006u, 0x0000035cu, 0x00000001u, 0x6c6f6f70u, 0x0064695fu, 0x00060006u, + 0x0000035cu, 0x00000002u, 0x72726176u, 0x695f7961u, 0x00007864u, 0x00070006u, 0x0000035cu, 0x00000003u, + 0x61697274u, 0x656c676eu, 0x756f635fu, 0x0000746eu, 0x00070006u, 0x0000035cu, 0x00000004u, 0x74726576u, + 0x635f7865u, 0x746e756fu, 0x00000000u, 0x00080006u, 0x0000035cu, 0x00000005u, 0x64627573u, 0x73697669u, + 0x5f6e6f69u, 0x6576656cu, 0x0000006cu, 0x00050006u, 0x0000035cu, 0x00000006u, 0x6f6c6f63u, 0x00000072u, + 0x00050006u, 0x0000035cu, 0x00000007u, 0x625f7369u, 0x00007665u, 0x00040005u, 0x0000035eu, 0x6c796170u, + 0x0064616fu, 0x00030005u, 0x00000362u, 0x00646974u, 0x00080005u, 0x00000363u, 0x4c5f6c67u, 0x6c61636fu, + 0x6f766e49u, 0x69746163u, 0x44496e6fu, 0x00000000u, 0x00050005u, 0x00000367u, 0x646e6552u, 0x75517265u, + 0x00797265u, 0x00060006u, 0x00000367u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, + 0x00000367u, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000367u, 0x00000002u, + 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x00000367u, 0x00000003u, 0x656d6163u, + 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x00000367u, 0x00000004u, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x00000367u, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000367u, 0x00000006u, + 0x6461705fu, 0x00000033u, 0x00040005u, 0x00000369u, 0x72657571u, 0x00000079u, 0x00050005u, 0x0000036au, + 0x646e6552u, 0x75517265u, 0x00797265u, 0x00060006u, 0x0000036au, 0x00000000u, 0x6e656373u, 0x64695f65u, + 0x00000000u, 0x00060006u, 0x0000036au, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, + 0x0000036au, 0x00000002u, 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x0000036au, + 0x00000003u, 0x656d6163u, 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x0000036au, 0x00000004u, + 0x6461705fu, 0x00000031u, 0x00050006u, 0x0000036au, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, + 0x0000036au, 0x00000006u, 0x6461705fu, 0x00000033u, 0x00050005u, 0x0000036cu, 0x72657551u, 0x66754279u, + 0x00726566u, 0x00060006u, 0x0000036cu, 0x00000000u, 0x75715f67u, 0x65697265u, 0x00000073u, 0x00030005u, + 0x0000036eu, 0x00000000u, 0x00070005u, 0x00000377u, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, + 0x00000000u, 0x00080006u, 0x00000377u, 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, + 0x0000736cu, 0x00090006u, 0x00000377u, 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, + 0x65736666u, 0x00000074u, 0x00080006u, 0x00000377u, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, + 0x6c6f6f70u, 0x00000073u, 0x00090006u, 0x00000377u, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, + 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00070006u, 0x00000377u, 0x00000004u, 0x5f6d756eu, 0x65627563u, + 0x6f6f705fu, 0x0000736cu, 0x00080006u, 0x00000377u, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, + 0x65736666u, 0x00000074u, 0x000a0006u, 0x00000377u, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, + 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00080006u, 0x00000377u, 0x00000007u, 0x33746e69u, + 0x75625f32u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00090006u, 0x00000377u, 0x00000008u, 0x74726576u, + 0x625f7865u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00090006u, 0x00000377u, 0x00000009u, + 0x61697274u, 0x656c676eu, 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000377u, + 0x0000000au, 0x65736f70u, 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000377u, + 0x0000000bu, 0x616f6c66u, 0x75625f74u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000377u, + 0x0000000cu, 0x6461705fu, 0x00000000u, 0x00040005u, 0x00000379u, 0x6e656373u, 0x00000065u, 0x00070005u, + 0x0000037bu, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x0000037bu, + 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x0000037bu, + 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, + 0x0000037bu, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, + 0x0000037bu, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, + 0x00070006u, 0x0000037bu, 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, + 0x0000037bu, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, + 0x0000037bu, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, + 0x00000000u, 0x00080006u, 0x0000037bu, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, + 0x00746573u, 0x00090006u, 0x0000037bu, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, + 0x74657366u, 0x00000000u, 0x00090006u, 0x0000037bu, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, + 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x0000037bu, 0x0000000au, 0x65736f70u, 0x6675625fu, + 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x0000037bu, 0x0000000bu, 0x616f6c66u, 0x75625f74u, + 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x0000037bu, 0x0000000cu, 0x6461705fu, 0x00000000u, + 0x00050005u, 0x0000037du, 0x6e656353u, 0x66754265u, 0x00726566u, 0x00060006u, 0x0000037du, 0x00000000u, + 0x63735f67u, 0x73656e65u, 0x00000000u, 0x00030005u, 0x0000037fu, 0x00000000u, 0x00080005u, 0x00000386u, + 0x656d6954u, 0x6d617473u, 0x50646570u, 0x67796c6fu, 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x00000386u, + 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000386u, 0x00000001u, + 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, 0x00000386u, 0x00000002u, 0x5f6d756eu, 0x74726576u, + 0x73656369u, 0x00000000u, 0x00070006u, 0x00000386u, 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, + 0x00000073u, 0x00070006u, 0x00000386u, 0x00000004u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, + 0x00080006u, 0x00000386u, 0x00000005u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00090006u, 0x00000386u, 0x00000006u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, + 0x00000000u, 0x00080006u, 0x00000386u, 0x00000007u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, + 0x00000074u, 0x00070006u, 0x00000386u, 0x00000008u, 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00070006u, 0x00000386u, 0x00000009u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, + 0x00000386u, 0x0000000au, 0x61697274u, 0x656c676eu, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, + 0x00000386u, 0x0000000bu, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000386u, 0x0000000cu, + 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000386u, 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, + 0x00000386u, 0x0000000eu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000386u, 0x0000000fu, 0x6461705fu, + 0x00000034u, 0x00040005u, 0x00000388u, 0x6c6f6f70u, 0x00000000u, 0x00080005u, 0x00000389u, 0x656d6954u, + 0x6d617473u, 0x50646570u, 0x67796c6fu, 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x00000389u, 0x00000000u, + 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000389u, 0x00000001u, 0x5f6d756eu, + 0x72726176u, 0x00737961u, 0x00070006u, 0x00000389u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, + 0x00000000u, 0x00070006u, 0x00000389u, 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, + 0x00070006u, 0x00000389u, 0x00000004u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, + 0x00000389u, 0x00000005u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, + 0x00000389u, 0x00000006u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, + 0x00080006u, 0x00000389u, 0x00000007u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00070006u, 0x00000389u, 0x00000008u, 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x00000389u, 0x00000009u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x00000389u, + 0x0000000au, 0x61697274u, 0x656c676eu, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, 0x00000389u, + 0x0000000bu, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000389u, 0x0000000cu, 0x6461705fu, + 0x00000031u, 0x00050006u, 0x00000389u, 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000389u, + 0x0000000eu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000389u, 0x0000000fu, 0x6461705fu, 0x00000034u, + 0x00070005u, 0x0000038bu, 0x796c6f50u, 0x506e6f67u, 0x426c6f6fu, 0x65666675u, 0x00000072u, 0x00070006u, + 0x0000038bu, 0x00000000u, 0x6f705f67u, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00030005u, 0x0000038du, + 0x00000000u, 0x00030005u, 0x00000397u, 0x006d6163u, 0x00060005u, 0x00000398u, 0x65685446u, 0x61436174u, + 0x6172656du, 0x00000000u, 0x00040006u, 0x00000398u, 0x00000000u, 0x00007863u, 0x00040006u, 0x00000398u, + 0x00000001u, 0x00007963u, 0x00050006u, 0x00000398u, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, + 0x00000398u, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, 0x00000398u, 0x00000004u, 0x796c6f70u, + 0x00000030u, 0x00050006u, 0x00000398u, 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x00000398u, + 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x00000398u, 0x00000007u, 0x796c6f70u, 0x00000033u, + 0x00050006u, 0x00000398u, 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, 0x00000398u, 0x00000009u, + 0x796c6f70u, 0x00000035u, 0x00070006u, 0x00000398u, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, + 0x00000065u, 0x00080006u, 0x00000398u, 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, + 0x00006c61u, 0x00080006u, 0x00000398u, 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, + 0x006c6176u, 0x00060006u, 0x00000398u, 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, + 0x00000398u, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, 0x00000398u, 0x0000000fu, 0x645f646cu, + 0x00000000u, 0x00050006u, 0x00000398u, 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x00000398u, + 0x00000011u, 0x665f646cu, 0x00000000u, 0x00080005u, 0x0000039au, 0x656d6143u, 0x6e496172u, 0x6e697274u, + 0x73636973u, 0x66667542u, 0x00007265u, 0x00080006u, 0x0000039au, 0x00000000u, 0x61635f67u, 0x6172656du, + 0x746e695fu, 0x736e6972u, 0x00736369u, 0x00030005u, 0x0000039cu, 0x00000000u, 0x00040005u, 0x000003a3u, + 0x65736f70u, 0x00000000u, 0x00050005u, 0x000003a4u, 0x656d6143u, 0x6f506172u, 0x00006573u, 0x00070006u, + 0x000003a4u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00617265u, 0x00070005u, 0x000003a6u, + 0x656d6143u, 0x6f506172u, 0x75426573u, 0x72656666u, 0x00000000u, 0x00070006u, 0x000003a6u, 0x00000000u, + 0x61635f67u, 0x6172656du, 0x736f705fu, 0x00007365u, 0x00030005u, 0x000003a8u, 0x00000000u, 0x00050005u, + 0x000003afu, 0x5f697274u, 0x72617473u, 0x00000074u, 0x00050005u, 0x000003b6u, 0x33746e49u, 0x66754232u, + 0x00726566u, 0x00050006u, 0x000003b6u, 0x00000000u, 0x6e695f67u, 0x00323374u, 0x00030005u, 0x000003b8u, + 0x00000000u, 0x00040005u, 0x000003c6u, 0x5f697274u, 0x00646e65u, 0x00050005u, 0x000003d2u, 0x61746f74u, + 0x72745f6cu, 0x00007369u, 0x00040005u, 0x000003d6u, 0x74735f76u, 0x00747261u, 0x00050005u, 0x000003e8u, + 0x65736162u, 0x695f765fu, 0x00007864u, 0x00050005u, 0x000003f0u, 0x65736162u, 0x695f745fu, 0x00007864u, + 0x00050005u, 0x00000405u, 0x5f6d756eu, 0x74726576u, 0x00000073u, 0x00050005u, 0x00000409u, 0x5f6d756eu, + 0x73697274u, 0x00000000u, 0x00040005u, 0x00000414u, 0x74726556u, 0x00007865u, 0x00040006u, 0x00000414u, + 0x00000000u, 0x00000078u, 0x00040006u, 0x00000414u, 0x00000001u, 0x00000079u, 0x00040006u, 0x00000414u, + 0x00000002u, 0x0000007au, 0x00050006u, 0x00000414u, 0x00000003u, 0x6461705fu, 0x00000000u, 0x00030005u, + 0x00000416u, 0x00787476u, 0x00040005u, 0x00000417u, 0x74726556u, 0x00007865u, 0x00040006u, 0x00000417u, + 0x00000000u, 0x00000078u, 0x00040006u, 0x00000417u, 0x00000001u, 0x00000079u, 0x00040006u, 0x00000417u, + 0x00000002u, 0x0000007au, 0x00050006u, 0x00000417u, 0x00000003u, 0x6461705fu, 0x00000000u, 0x00060005u, + 0x00000419u, 0x74726556u, 0x75427865u, 0x72656666u, 0x00000000u, 0x00060006u, 0x00000419u, 0x00000000u, + 0x65765f67u, 0x63697472u, 0x00007365u, 0x00030005u, 0x0000041bu, 0x00000000u, 0x00050005u, 0x00000423u, + 0x6c726f77u, 0x6f705f64u, 0x00000073u, 0x00040005u, 0x0000042cu, 0x70696c63u, 0x00000000u, 0x00040005u, + 0x0000042du, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000042fu, 0x61726170u, 0x0000006du, 0x00040005u, + 0x00000431u, 0x61726170u, 0x0000006du, 0x00070005u, 0x00000434u, 0x4d5f6c67u, 0x50687365u, 0x65567265u, + 0x78657472u, 0x00545845u, 0x00060006u, 0x00000434u, 0x00000000u, 0x505f6c67u, 0x7469736fu, 0x006e6f69u, + 0x00070005u, 0x00000437u, 0x4d5f6c67u, 0x56687365u, 0x69747265u, 0x45736563u, 0x00005458u, 0x00030005u, + 0x00000442u, 0x00697274u, 0x00060005u, 0x00000444u, 0x61697254u, 0x656c676eu, 0x66667542u, 0x00007265u, + 0x00060006u, 0x00000444u, 0x00000000u, 0x72745f67u, 0x676e6169u, 0x0073656cu, 0x00030005u, 0x00000446u, + 0x00000000u, 0x00040005u, 0x0000044du, 0x65736162u, 0x00000000u, 0x000a0005u, 0x00000452u, 0x505f6c67u, + 0x696d6972u, 0x65766974u, 0x61697254u, 0x656c676eu, 0x69646e49u, 0x45736563u, 0x00005458u, 0x00080005u, + 0x0000045eu, 0x4d5f6c67u, 0x50687365u, 0x72507265u, 0x74696d69u, 0x45657669u, 0x00005458u, 0x00060006u, + 0x0000045eu, 0x00000000u, 0x4c5f6c67u, 0x72657961u, 0x00000000u, 0x00080005u, 0x00000461u, 0x4d5f6c67u, + 0x50687365u, 0x696d6972u, 0x65766974u, 0x54584573u, 0x00000000u, 0x00060005u, 0x00000468u, 0x6d697250u, + 0x6f6c6f43u, 0x6f6c4272u, 0x00006b63u, 0x00050006u, 0x00000468u, 0x00000000u, 0x6f6c6f63u, 0x00000072u, + 0x00050006u, 0x00000468u, 0x00000001u, 0x625f7369u, 0x00007665u, 0x00050005u, 0x0000046bu, 0x6d697270u, + 0x74756f5fu, 0x00000000u, 0x00060005u, 0x0000047du, 0x74726576u, 0x65705f73u, 0x72745f72u, 0x00000069u, + 0x00040005u, 0x0000047eu, 0x61726170u, 0x0000006du, 0x00060005u, 0x00000480u, 0x73697274u, 0x7265705fu, + 0x6972745fu, 0x00000000u, 0x00040005u, 0x00000481u, 0x61726170u, 0x0000006du, 0x00060005u, 0x00000483u, + 0x73697274u, 0x7265705fu, 0x7568635fu, 0x00006b6eu, 0x00050005u, 0x00000484u, 0x6e756863u, 0x74735f6bu, + 0x00747261u, 0x00050005u, 0x00000488u, 0x6e756863u, 0x6e655f6bu, 0x00000064u, 0x00060005u, 0x0000048eu, + 0x5f6d756eu, 0x6769726fu, 0x6972745fu, 0x00000073u, 0x00060005u, 0x00000498u, 0x5f6d756eu, 0x5f74756fu, + 0x74726576u, 0x00000073u, 0x00060005u, 0x0000049cu, 0x5f6d756eu, 0x5f74756fu, 0x73697274u, 0x00000000u, + 0x00030005u, 0x000004a8u, 0x00697274u, 0x00040005u, 0x000004b0u, 0x645f3076u, 0x00617461u, 0x00040005u, + 0x000004b8u, 0x645f3176u, 0x00617461u, 0x00040005u, 0x000004c0u, 0x645f3276u, 0x00617461u, 0x00030005u, + 0x000004c8u, 0x00003076u, 0x00030005u, 0x000004d0u, 0x00003176u, 0x00030005u, 0x000004d8u, 0x00003276u, + 0x00050005u, 0x000004e0u, 0x74726576u, 0x7361625fu, 0x00000065u, 0x00030005u, 0x000004e4u, 0x00000069u, + 0x00030005u, 0x000004edu, 0x00007675u, 0x00040005u, 0x000004eeu, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000004f0u, 0x61726170u, 0x0000006du, 0x00030005u, 0x000004f2u, 0x00007470u, 0x00040005u, 0x000004f3u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000004f5u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004f7u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000004f9u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004fcu, + 0x70696c63u, 0x00000000u, 0x00040005u, 0x000004fdu, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004ffu, + 0x61726170u, 0x0000006du, 0x00040005u, 0x00000501u, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000510u, + 0x74726576u, 0x7361625fu, 0x00000065u, 0x00050005u, 0x00000514u, 0x5f697274u, 0x65736162u, 0x00000000u, + 0x00030005u, 0x00000518u, 0x00000074u, 0x00030005u, 0x00000521u, 0x00786469u, 0x00040005u, 0x00000522u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x00000524u, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000526u, + 0x5f786469u, 0x65736162u, 0x00000000u, 0x00050005u, 0x00000555u, 0x6e756863u, 0x74735f6bu, 0x00747261u, + 0x00050005u, 0x00000558u, 0x6e756863u, 0x6e655f6bu, 0x00000064u, 0x00060005u, 0x0000055du, 0x5f6d756eu, + 0x6769726fu, 0x6972745fu, 0x00000073u, 0x00060005u, 0x00000567u, 0x5f6d756eu, 0x5f74756fu, 0x74726576u, + 0x00000073u, 0x00050005u, 0x0000056eu, 0x5f697274u, 0x61636f6cu, 0x0000006cu, 0x00050005u, 0x00000571u, + 0x74726576u, 0x636f6c5fu, 0x00006c61u, 0x00030005u, 0x0000057cu, 0x00697274u, 0x00040005u, 0x00000584u, + 0x645f3076u, 0x00617461u, 0x00040005u, 0x0000058cu, 0x645f3176u, 0x00617461u, 0x00040005u, 0x00000594u, + 0x645f3276u, 0x00617461u, 0x00030005u, 0x0000059cu, 0x00003076u, 0x00030005u, 0x000005a4u, 0x00003176u, + 0x00030005u, 0x000005acu, 0x00003276u, 0x00030005u, 0x000005b4u, 0x00007675u, 0x00040005u, 0x000005b5u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000005b7u, 0x61726170u, 0x0000006du, 0x00030005u, 0x000005b9u, + 0x00007470u, 0x00040005u, 0x000005bau, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005bcu, 0x61726170u, + 0x0000006du, 0x00040005u, 0x000005beu, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005c0u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x000005c3u, 0x70696c63u, 0x00000000u, 0x00040005u, 0x000005c4u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x000005c6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005c8u, 0x61726170u, + 0x0000006du, 0x00050005u, 0x000005cbu, 0x74726576u, 0x7864695fu, 0x00000000u, 0x00050005u, 0x000005dbu, + 0x74726576u, 0x7361625fu, 0x00000065u, 0x00050005u, 0x000005deu, 0x5f697274u, 0x5f74756fu, 0x00786469u, + 0x00030005u, 0x000005e3u, 0x00786469u, 0x00040005u, 0x000005e4u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000005e6u, 0x61726170u, 0x0000006du, 0x00050005u, 0x000005e8u, 0x5f786469u, 0x65736162u, 0x00000000u, + 0x00050005u, 0x0000060du, 0x6e756863u, 0x74735f6bu, 0x00747261u, 0x00030005u, 0x00000618u, 0x00697274u, + 0x00040005u, 0x0000061eu, 0x645f3076u, 0x00617461u, 0x00040005u, 0x00000626u, 0x645f3176u, 0x00617461u, + 0x00040005u, 0x0000062eu, 0x645f3276u, 0x00617461u, 0x00030005u, 0x00000636u, 0x00003076u, 0x00030005u, + 0x0000063eu, 0x00003176u, 0x00030005u, 0x00000646u, 0x00003276u, 0x00030005u, 0x0000064eu, 0x00000076u, + 0x00030005u, 0x00000657u, 0x00007675u, 0x00040005u, 0x00000658u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x0000065au, 0x61726170u, 0x0000006du, 0x00030005u, 0x0000065cu, 0x00007470u, 0x00040005u, 0x0000065du, + 0x61726170u, 0x0000006du, 0x00040005u, 0x0000065fu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000661u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x00000663u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000666u, + 0x70696c63u, 0x00000000u, 0x00040005u, 0x00000667u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000669u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x0000066bu, 0x61726170u, 0x0000006du, 0x00030005u, 0x00000673u, + 0x00000074u, 0x00030005u, 0x0000067cu, 0x00786469u, 0x00040005u, 0x0000067du, 0x61726170u, 0x0000006du, + 0x00040005u, 0x0000067fu, 0x61726170u, 0x0000006du, 0x00050005u, 0x00000681u, 0x5f786469u, 0x65736162u, + 0x00000000u, 0x00050005u, 0x0000069eu, 0x6e756863u, 0x74735f6bu, 0x00747261u, 0x00050005u, 0x000006a1u, + 0x6e756863u, 0x6e655f6bu, 0x00000064u, 0x00060005u, 0x000006a6u, 0x5f6d756eu, 0x6769726fu, 0x6972745fu, + 0x00000073u, 0x00060005u, 0x000006b0u, 0x5f6d756eu, 0x5f74756fu, 0x74726576u, 0x00000073u, 0x00030005u, + 0x000006bbu, 0x00697274u, 0x00040005u, 0x000006c3u, 0x645f3076u, 0x00617461u, 0x00040005u, 0x000006cbu, + 0x645f3176u, 0x00617461u, 0x00040005u, 0x000006d3u, 0x645f3276u, 0x00617461u, 0x00030005u, 0x000006dbu, + 0x00003076u, 0x00030005u, 0x000006e3u, 0x00003176u, 0x00030005u, 0x000006ebu, 0x00003276u, 0x00050005u, + 0x000006f3u, 0x74726576u, 0x7361625fu, 0x00000065u, 0x00040005u, 0x000006f6u, 0x70696c63u, 0x00000030u, + 0x00040005u, 0x000006f7u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006f9u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x000006fbu, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006feu, 0x70696c63u, 0x00000031u, + 0x00040005u, 0x000006ffu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000701u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000703u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000706u, 0x70696c63u, 0x00000032u, + 0x00040005u, 0x00000707u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000709u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x0000070bu, 0x61726170u, 0x0000006du, 0x00050005u, 0x0000071au, 0x5f786469u, 0x65736162u, + 0x00000000u, 0x00060005u, 0x00000734u, 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, 0x000a0006u, + 0x00000734u, 0x00000000u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, 0x72616c75u, + 0x00000000u, 0x00090006u, 0x00000734u, 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, + 0x7665625fu, 0x00000000u, 0x000a0006u, 0x00000734u, 0x00000002u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, + 0x6a617274u, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000734u, 0x00000003u, 0x69775f75u, + 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x7665625fu, 0x00000000u, 0x00080006u, 0x00000734u, 0x00000004u, + 0x69775f75u, 0x5f687464u, 0x65726977u, 0x6d617266u, 0x00000065u, 0x00080006u, 0x00000734u, 0x00000005u, + 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, 0x6163735fu, 0x0000656cu, 0x00070006u, 0x00000734u, 0x00000006u, + 0x65645f75u, 0x5f687470u, 0x6c616373u, 0x00676e69u, 0x00090006u, 0x00000734u, 0x00000007u, 0x616d5f75u, + 0x78655f78u, 0x70617274u, 0x74616c6fu, 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x00000734u, 0x00000008u, + 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, 0x00000734u, + 0x00000009u, 0x756e5f75u, 0x75715f6du, 0x65697265u, 0x00000073u, 0x000a0006u, 0x00000734u, 0x0000000au, + 0x65745f75u, 0x6c657373u, 0x6974616cu, 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, 0x000a0006u, + 0x00000734u, 0x0000000bu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x6c796c6fu, + 0x00656e69u, 0x000a0006u, 0x00000734u, 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, + 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, 0x00090006u, 0x00000734u, 0x0000000du, 0x616d5f75u, 0x65745f78u, + 0x6c657373u, 0x6974616cu, 0x635f6e6fu, 0x00656275u, 0x00080006u, 0x00000734u, 0x0000000eu, 0x75635f75u, + 0x725f6c6cu, 0x75696461u, 0x63735f73u, 0x00656c61u, 0x00070006u, 0x00000734u, 0x0000000fu, 0x6f665f75u, + 0x6e655f67u, 0x656c6261u, 0x00000064u, 0x00070006u, 0x00000734u, 0x00000010u, 0x616d5f75u, 0x626f5f78u, + 0x63617473u, 0x0073656cu, 0x00080006u, 0x00000734u, 0x00000011u, 0x75635f75u, 0x705f6562u, 0x5f6c6f6fu, + 0x65646e69u, 0x00000078u, 0x00080006u, 0x00000734u, 0x00000012u, 0x756e5f75u, 0x6f705f6du, 0x6f67796cu, + 0x6f705f6eu, 0x00736c6fu, 0x00090006u, 0x00000734u, 0x00000013u, 0x616d5f75u, 0x61765f78u, 0x79617272u, + 0x65705f73u, 0x6f705f72u, 0x00006c6fu, 0x00090006u, 0x00000734u, 0x00000014u, 0x756e5f75u, 0x6f705f6du, + 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00070006u, 0x00000734u, 0x00000015u, 0x756f5f75u, + 0x74757074u, 0x6469775fu, 0x00006874u, 0x00070006u, 0x00000734u, 0x00000016u, 0x756f5f75u, 0x74757074u, + 0x6965685fu, 0x00746867u, 0x00030005u, 0x00000736u, 0x00006370u, 0x00080005u, 0x00000767u, 0x6f6c6f43u, + 0x6c615072u, 0x65747465u, 0x66667542u, 0x61457265u, 0x00796c72u, 0x00070006u, 0x00000767u, 0x00000000u, + 0x6f635f67u, 0x5f726f6cu, 0x656c6170u, 0x00657474u, 0x00030005u, 0x00000769u, 0x00000000u, 0x00070005u, + 0x0000076bu, 0x656d6954u, 0x6d617473u, 0x75427370u, 0x72656666u, 0x00000000u, 0x00070006u, 0x0000076bu, + 0x00000000u, 0x69745f67u, 0x7473656du, 0x73706d61u, 0x00000000u, 0x00030005u, 0x0000076du, 0x00000000u, + 0x00050005u, 0x0000076fu, 0x65736f50u, 0x66667542u, 0x00007265u, 0x00050006u, 0x0000076fu, 0x00000000u, + 0x6f705f67u, 0x00736573u, 0x00030005u, 0x00000771u, 0x00000000u, 0x00050005u, 0x00000773u, 0x616f6c46u, + 0x66754274u, 0x00726566u, 0x00060006u, 0x00000773u, 0x00000000u, 0x6c665f67u, 0x7374616fu, 0x00000000u, + 0x00030005u, 0x00000775u, 0x00000000u, 0x00080005u, 0x00000776u, 0x656d6954u, 0x6d617473u, 0x50646570u, + 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x00000776u, 0x00000000u, 0x5f6d756eu, 0x656d6974u, + 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000776u, 0x00000001u, 0x5f6d756eu, 0x72726176u, 0x00737961u, + 0x00070006u, 0x00000776u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, 0x00070006u, + 0x00000776u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x00000776u, + 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x00000776u, + 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, + 0x00000776u, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x00000776u, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00060006u, 0x00000776u, + 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000776u, 0x00000009u, 0x6461705fu, + 0x00000031u, 0x00050006u, 0x00000776u, 0x0000000au, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000776u, + 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000776u, 0x0000000cu, 0x6461705fu, 0x00000034u, + 0x00050006u, 0x00000776u, 0x0000000du, 0x6461705fu, 0x00000035u, 0x00050006u, 0x00000776u, 0x0000000eu, + 0x6461705fu, 0x00000036u, 0x00050006u, 0x00000776u, 0x0000000fu, 0x6461705fu, 0x00000037u, 0x00070005u, + 0x00000778u, 0x796c6f50u, 0x656e696cu, 0x6c6f6f50u, 0x66667542u, 0x00007265u, 0x00080006u, 0x00000778u, + 0x00000000u, 0x6f705f67u, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00030005u, 0x0000077au, + 0x00000000u, 0x00060005u, 0x0000077bu, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x00000000u, 0x00060006u, + 0x0000077bu, 0x00000000u, 0x5f6d756eu, 0x65627563u, 0x00000073u, 0x00070006u, 0x0000077bu, 0x00000001u, + 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00070006u, 0x0000077bu, 0x00000002u, 0x5f6d756eu, + 0x63617274u, 0x6f705f6bu, 0x00736573u, 0x00070006u, 0x0000077bu, 0x00000003u, 0x6d697270u, 0x7079745fu, + 0x64695f65u, 0x00000000u, 0x00080006u, 0x0000077bu, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, + 0x65736666u, 0x00000074u, 0x00080006u, 0x0000077bu, 0x00000005u, 0x65627563u, 0x5f73745fu, 0x6f5f7370u, + 0x65736666u, 0x00000074u, 0x00090006u, 0x0000077bu, 0x00000006u, 0x63617274u, 0x69745f6bu, 0x7473656du, + 0x73706d61u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x0000077bu, 0x00000007u, 0x6e617274u, 0x74616c73u, + 0x736e6f69u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x0000077bu, 0x00000008u, 0x74617571u, 0x696e7265u, + 0x5f736e6fu, 0x7366666fu, 0x00007465u, 0x00070006u, 0x0000077bu, 0x00000009u, 0x6c616373u, 0x6f5f7365u, + 0x65736666u, 0x00000074u, 0x00070006u, 0x0000077bu, 0x0000000au, 0x6f6c6f63u, 0x6f5f7372u, 0x65736666u, + 0x00000074u, 0x00070006u, 0x0000077bu, 0x0000000bu, 0x646e6572u, 0x665f7265u, 0x7367616cu, 0x00000000u, + 0x00050006u, 0x0000077bu, 0x0000000cu, 0x6461705fu, 0x00000032u, 0x00050006u, 0x0000077bu, 0x0000000du, + 0x6461705fu, 0x00000033u, 0x00050006u, 0x0000077bu, 0x0000000eu, 0x6461705fu, 0x00000034u, 0x00050006u, + 0x0000077bu, 0x0000000fu, 0x6461705fu, 0x00000035u, 0x00070005u, 0x0000077du, 0x7473624fu, 0x656c6361u, + 0x6c6f6f50u, 0x66667542u, 0x00007265u, 0x00080006u, 0x0000077du, 0x00000000u, 0x626f5f67u, 0x63617473u, + 0x705f656cu, 0x736c6f6fu, 0x00000000u, 0x00030005u, 0x0000077fu, 0x00000000u, 0x00040047u, 0x00000357u, + 0x0000000bu, 0x0000001au, 0x00040047u, 0x00000363u, 0x0000000bu, 0x0000001bu, 0x00050048u, 0x0000036au, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000036au, 0x00000001u, 0x00000023u, 0x00000004u, + 0x00050048u, 0x0000036au, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000036au, 0x00000003u, + 0x00000023u, 0x00000010u, 0x00050048u, 0x0000036au, 0x00000004u, 0x00000023u, 0x00000014u, 0x00050048u, + 0x0000036au, 0x00000005u, 0x00000023u, 0x00000018u, 0x00050048u, 0x0000036au, 0x00000006u, 0x00000023u, + 0x0000001cu, 0x00040047u, 0x0000036bu, 0x00000006u, 0x00000020u, 0x00030047u, 0x0000036cu, 0x00000002u, + 0x00040048u, 0x0000036cu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000036cu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000036eu, 0x00000018u, 0x00040047u, 0x0000036eu, 0x00000021u, 0x0000000du, + 0x00040047u, 0x0000036eu, 0x00000022u, 0x00000000u, 0x00040047u, 0x0000037au, 0x00000006u, 0x00000004u, + 0x00050048u, 0x0000037bu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000037bu, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x0000037bu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x0000037bu, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000037bu, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x0000037bu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000037bu, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x0000037bu, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x0000037bu, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000037bu, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x0000037bu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x0000037bu, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000037bu, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00040047u, 0x0000037cu, 0x00000006u, 0x00000080u, 0x00030047u, 0x0000037du, 0x00000002u, + 0x00040048u, 0x0000037du, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000037du, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000037fu, 0x00000018u, 0x00040047u, 0x0000037fu, 0x00000021u, 0x00000006u, + 0x00040047u, 0x0000037fu, 0x00000022u, 0x00000000u, 0x00050048u, 0x00000389u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x00000389u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000389u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000389u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x00000389u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000389u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x00000389u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x00000389u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000389u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x00000389u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000389u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000389u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x00000389u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000389u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x00000389u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x00000389u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x0000038au, 0x00000006u, 0x00000040u, + 0x00030047u, 0x0000038bu, 0x00000002u, 0x00040048u, 0x0000038bu, 0x00000000u, 0x00000018u, 0x00050048u, + 0x0000038bu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000038du, 0x00000018u, 0x00040047u, + 0x0000038du, 0x00000021u, 0x00000008u, 0x00040047u, 0x0000038du, 0x00000022u, 0x00000000u, 0x00050048u, + 0x00000398u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000398u, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x00000398u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000398u, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000398u, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x00000398u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000398u, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x00000398u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x00000398u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000398u, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x00000398u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000398u, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000398u, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x00000398u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000398u, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x00000398u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, + 0x00000398u, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x00000398u, 0x00000011u, 0x00000023u, + 0x00000044u, 0x00040047u, 0x00000399u, 0x00000006u, 0x00000048u, 0x00030047u, 0x0000039au, 0x00000002u, + 0x00040048u, 0x0000039au, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000039au, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000039cu, 0x00000018u, 0x00040047u, 0x0000039cu, 0x00000021u, 0x0000000bu, + 0x00040047u, 0x0000039cu, 0x00000022u, 0x00000000u, 0x00040048u, 0x000003a4u, 0x00000000u, 0x00000005u, + 0x00050048u, 0x000003a4u, 0x00000000u, 0x00000007u, 0x00000010u, 0x00050048u, 0x000003a4u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00040047u, 0x000003a5u, 0x00000006u, 0x00000040u, 0x00030047u, 0x000003a6u, + 0x00000002u, 0x00040048u, 0x000003a6u, 0x00000000u, 0x00000018u, 0x00050048u, 0x000003a6u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x000003a8u, 0x00000018u, 0x00040047u, 0x000003a8u, 0x00000021u, + 0x0000000cu, 0x00040047u, 0x000003a8u, 0x00000022u, 0x00000000u, 0x00040047u, 0x000003b5u, 0x00000006u, + 0x00000004u, 0x00030047u, 0x000003b6u, 0x00000002u, 0x00040048u, 0x000003b6u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x000003b6u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000003b8u, 0x00000018u, + 0x00040047u, 0x000003b8u, 0x00000021u, 0x00000001u, 0x00040047u, 0x000003b8u, 0x00000022u, 0x00000000u, + 0x00050048u, 0x00000417u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000417u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000417u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000417u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00040047u, 0x00000418u, 0x00000006u, 0x00000010u, + 0x00030047u, 0x00000419u, 0x00000002u, 0x00040048u, 0x00000419u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x00000419u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000041bu, 0x00000018u, 0x00040047u, + 0x0000041bu, 0x00000021u, 0x00000002u, 0x00040047u, 0x0000041bu, 0x00000022u, 0x00000000u, 0x00030047u, + 0x00000434u, 0x00000002u, 0x00050048u, 0x00000434u, 0x00000000u, 0x0000000bu, 0x00000000u, 0x00040047u, + 0x00000443u, 0x00000006u, 0x00000010u, 0x00030047u, 0x00000444u, 0x00000002u, 0x00040048u, 0x00000444u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x00000444u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x00000446u, 0x00000018u, 0x00040047u, 0x00000446u, 0x00000021u, 0x00000003u, 0x00040047u, 0x00000446u, + 0x00000022u, 0x00000000u, 0x00040047u, 0x00000452u, 0x0000000bu, 0x000014b0u, 0x00030047u, 0x0000045eu, + 0x00000002u, 0x00050048u, 0x0000045eu, 0x00000000u, 0x0000000bu, 0x00000009u, 0x00040048u, 0x0000045eu, + 0x00000000u, 0x00001497u, 0x00030047u, 0x00000468u, 0x00000002u, 0x00040048u, 0x00000468u, 0x00000000u, + 0x00001497u, 0x00040048u, 0x00000468u, 0x00000001u, 0x00001497u, 0x00040047u, 0x0000046bu, 0x0000001eu, + 0x00000000u, 0x00030047u, 0x00000734u, 0x00000002u, 0x00050048u, 0x00000734u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x00000734u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000734u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000734u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x00000734u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000734u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x00000734u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x00000734u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000734u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x00000734u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000734u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000734u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x00000734u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000734u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x00000734u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x00000734u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x00000734u, 0x00000010u, 0x00000023u, + 0x00000040u, 0x00050048u, 0x00000734u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00050048u, 0x00000734u, + 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x00000734u, 0x00000013u, 0x00000023u, 0x0000004cu, + 0x00050048u, 0x00000734u, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, 0x00000734u, 0x00000015u, + 0x00000023u, 0x00000054u, 0x00050048u, 0x00000734u, 0x00000016u, 0x00000023u, 0x00000058u, 0x00040047u, + 0x00000766u, 0x00000006u, 0x00000010u, 0x00030047u, 0x00000767u, 0x00000002u, 0x00040048u, 0x00000767u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x00000767u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x00000769u, 0x00000018u, 0x00040047u, 0x00000769u, 0x00000021u, 0x0000000au, 0x00040047u, 0x00000769u, + 0x00000022u, 0x00000000u, 0x00040047u, 0x0000076au, 0x00000006u, 0x00000008u, 0x00030047u, 0x0000076bu, + 0x00000002u, 0x00040048u, 0x0000076bu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000076bu, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x0000076du, 0x00000018u, 0x00040047u, 0x0000076du, 0x00000021u, + 0x00000000u, 0x00040047u, 0x0000076du, 0x00000022u, 0x00000000u, 0x00040047u, 0x0000076eu, 0x00000006u, + 0x00000040u, 0x00030047u, 0x0000076fu, 0x00000002u, 0x00040048u, 0x0000076fu, 0x00000000u, 0x00000018u, + 0x00050048u, 0x0000076fu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000771u, 0x00000018u, + 0x00040047u, 0x00000771u, 0x00000021u, 0x00000004u, 0x00040047u, 0x00000771u, 0x00000022u, 0x00000000u, + 0x00040047u, 0x00000772u, 0x00000006u, 0x00000004u, 0x00030047u, 0x00000773u, 0x00000002u, 0x00040048u, + 0x00000773u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000773u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x00000775u, 0x00000018u, 0x00040047u, 0x00000775u, 0x00000021u, 0x00000005u, 0x00040047u, + 0x00000775u, 0x00000022u, 0x00000000u, 0x00050048u, 0x00000776u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00050048u, 0x00000776u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000776u, 0x00000002u, + 0x00000023u, 0x00000008u, 0x00050048u, 0x00000776u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, + 0x00000776u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000776u, 0x00000005u, 0x00000023u, + 0x00000014u, 0x00050048u, 0x00000776u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000776u, + 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000776u, 0x00000008u, 0x00000023u, 0x00000020u, + 0x00050048u, 0x00000776u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000776u, 0x0000000au, + 0x00000023u, 0x00000028u, 0x00050048u, 0x00000776u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, + 0x00000776u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000776u, 0x0000000du, 0x00000023u, + 0x00000034u, 0x00050048u, 0x00000776u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000776u, + 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x00000777u, 0x00000006u, 0x00000040u, 0x00030047u, + 0x00000778u, 0x00000002u, 0x00040048u, 0x00000778u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000778u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000077au, 0x00000018u, 0x00040047u, 0x0000077au, + 0x00000021u, 0x00000007u, 0x00040047u, 0x0000077au, 0x00000022u, 0x00000000u, 0x00050048u, 0x0000077bu, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000077bu, 0x00000001u, 0x00000023u, 0x00000004u, + 0x00050048u, 0x0000077bu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000077bu, 0x00000003u, + 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000077bu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, + 0x0000077bu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000077bu, 0x00000006u, 0x00000023u, + 0x00000018u, 0x00050048u, 0x0000077bu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000077bu, + 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000077bu, 0x00000009u, 0x00000023u, 0x00000024u, + 0x00050048u, 0x0000077bu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000077bu, 0x0000000bu, + 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000077bu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, + 0x0000077bu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000077bu, 0x0000000eu, 0x00000023u, + 0x00000038u, 0x00050048u, 0x0000077bu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x0000077cu, + 0x00000006u, 0x00000040u, 0x00030047u, 0x0000077du, 0x00000002u, 0x00040048u, 0x0000077du, 0x00000000u, + 0x00000018u, 0x00050048u, 0x0000077du, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000077fu, + 0x00000018u, 0x00040047u, 0x0000077fu, 0x00000021u, 0x00000009u, 0x00040047u, 0x0000077fu, 0x00000022u, + 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00040015u, 0x00000006u, + 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000006u, 0x00000007u, 0x00000020u, 0x0004002bu, 0x00000006u, + 0x00000008u, 0x00000001u, 0x00030016u, 0x00000009u, 0x00000020u, 0x00040017u, 0x0000000au, 0x00000009u, + 0x00000003u, 0x00040020u, 0x0000000bu, 0x00000007u, 0x0000000au, 0x00040017u, 0x0000000cu, 0x00000009u, + 0x00000004u, 0x00040018u, 0x0000000du, 0x0000000cu, 0x00000004u, 0x0003001eu, 0x0000000eu, 0x0000000du, + 0x00040020u, 0x0000000fu, 0x00000007u, 0x0000000eu, 0x0014001eu, 0x00000010u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00040020u, 0x00000011u, 0x00000007u, 0x00000010u, 0x00060021u, 0x00000012u, 0x0000000cu, 0x0000000bu, + 0x0000000fu, 0x00000011u, 0x00040020u, 0x00000018u, 0x00000007u, 0x00000006u, 0x00040021u, 0x00000019u, + 0x00000006u, 0x00000018u, 0x00040017u, 0x00000020u, 0x00000009u, 0x00000002u, 0x00050021u, 0x00000021u, + 0x00000020u, 0x00000018u, 0x00000018u, 0x00040020u, 0x00000026u, 0x00000007u, 0x00000020u, 0x00070021u, + 0x00000027u, 0x0000000au, 0x0000000bu, 0x0000000bu, 0x0000000bu, 0x00000026u, 0x00040017u, 0x0000002eu, + 0x00000006u, 0x00000003u, 0x00050021u, 0x0000002fu, 0x0000002eu, 0x00000018u, 0x00000018u, 0x00040015u, + 0x00000035u, 0x00000020u, 0x00000001u, 0x0004002bu, 0x00000035u, 0x00000036u, 0x00000000u, 0x00040020u, + 0x00000037u, 0x00000007u, 0x0000000du, 0x0004002bu, 0x00000009u, 0x0000003bu, 0x3f800000u, 0x00040020u, + 0x00000042u, 0x00000007u, 0x00000009u, 0x0004002bu, 0x00000006u, 0x00000044u, 0x00000002u, 0x0004002bu, + 0x00000009u, 0x0000004bu, 0x358637bdu, 0x00020014u, 0x0000004cu, 0x0004002bu, 0x00000009u, 0x00000050u, + 0x00000000u, 0x0007002cu, 0x0000000cu, 0x00000051u, 0x00000050u, 0x00000050u, 0x00000050u, 0x0000003bu, + 0x0004002bu, 0x00000009u, 0x00000054u, 0x3fc90fdau, 0x0004002bu, 0x00000035u, 0x00000055u, 0x0000000au, + 0x0004002bu, 0x00000009u, 0x0000005bu, 0x3a83126fu, 0x0004002bu, 0x00000035u, 0x00000061u, 0x00000005u, + 0x0004002bu, 0x00000006u, 0x00000065u, 0x00000000u, 0x0004002bu, 0x00000035u, 0x0000006au, 0x00000002u, + 0x0004002bu, 0x00000009u, 0x0000006du, 0x3f000000u, 0x0004002bu, 0x00000035u, 0x00000076u, 0x00000003u, + 0x0004002bu, 0x00000009u, 0x0000007cu, 0x41200000u, 0x0004002bu, 0x00000009u, 0x0000008bu, 0xbf800000u, + 0x0004002bu, 0x00000035u, 0x000000a1u, 0x00000004u, 0x0004002bu, 0x00000035u, 0x000000a9u, 0x00000006u, + 0x0004002bu, 0x00000035u, 0x000000afu, 0x00000007u, 0x0004002bu, 0x00000035u, 0x000000b5u, 0x00000008u, + 0x0004002bu, 0x00000035u, 0x000000bbu, 0x00000009u, 0x0004002bu, 0x00000035u, 0x000000c7u, 0x0000000bu, + 0x0004002bu, 0x00000035u, 0x000000ceu, 0x0000000cu, 0x0004002bu, 0x00000035u, 0x000000e4u, 0x0000000eu, + 0x0004002bu, 0x00000035u, 0x000000eau, 0x0000000fu, 0x0004002bu, 0x00000035u, 0x000000f2u, 0x00000010u, + 0x0004002bu, 0x00000035u, 0x000000f8u, 0x00000011u, 0x0004002bu, 0x00000035u, 0x00000104u, 0x00000001u, + 0x0004002bu, 0x00000009u, 0x0000010au, 0x40000000u, 0x0004002bu, 0x00000035u, 0x00000128u, 0x0000000du, + 0x0004002bu, 0x00000006u, 0x0000013eu, 0x00000003u, 0x0004002bu, 0x00000006u, 0x00000144u, 0x00000006u, + 0x0004002bu, 0x00000006u, 0x0000014au, 0x0000000fu, 0x0004002bu, 0x00000006u, 0x0000014cu, 0x0000002du, + 0x0004002bu, 0x00000006u, 0x00000158u, 0x00000004u, 0x0004002bu, 0x00000006u, 0x0000015eu, 0x00000010u, + 0x0004002bu, 0x00000006u, 0x00000160u, 0x00000040u, 0x0005002cu, 0x00000020u, 0x0000016bu, 0x00000050u, + 0x00000050u, 0x0005002cu, 0x00000020u, 0x00000171u, 0x0000003bu, 0x00000050u, 0x0005002cu, 0x00000020u, + 0x00000173u, 0x00000050u, 0x0000003bu, 0x0004001cu, 0x0000017au, 0x00000020u, 0x00000144u, 0x00040020u, + 0x0000017bu, 0x00000007u, 0x0000017au, 0x0005002cu, 0x00000020u, 0x00000180u, 0x0000006du, 0x00000050u, + 0x0005002cu, 0x00000020u, 0x00000182u, 0x0000006du, 0x0000006du, 0x0005002cu, 0x00000020u, 0x00000184u, + 0x00000050u, 0x0000006du, 0x0004002bu, 0x00000006u, 0x00000190u, 0x00000005u, 0x0004002bu, 0x00000006u, + 0x00000199u, 0x00000009u, 0x0004002bu, 0x00000006u, 0x000001a1u, 0x0000000cu, 0x0004002bu, 0x00000006u, + 0x000001a9u, 0x0000000eu, 0x0004002bu, 0x00000009u, 0x000001b2u, 0x40800000u, 0x0004002bu, 0x00000006u, + 0x000001c3u, 0x00000011u, 0x0004002bu, 0x00000006u, 0x000001cbu, 0x00000018u, 0x0004002bu, 0x00000006u, + 0x000001d3u, 0x0000001eu, 0x0004002bu, 0x00000006u, 0x000001dbu, 0x00000023u, 0x0004002bu, 0x00000006u, + 0x000001e3u, 0x00000027u, 0x0004002bu, 0x00000006u, 0x000001ebu, 0x0000002au, 0x0004002bu, 0x00000006u, + 0x000001f3u, 0x0000002cu, 0x0004002bu, 0x00000006u, 0x000001f7u, 0x00000007u, 0x0004002bu, 0x00000006u, + 0x000001fbu, 0x00000008u, 0x0004002bu, 0x00000009u, 0x000001feu, 0x41000000u, 0x0006002cu, 0x0000002eu, + 0x00000220u, 0x00000065u, 0x00000008u, 0x00000044u, 0x0004001cu, 0x00000227u, 0x0000002eu, 0x00000158u, + 0x00040020u, 0x00000228u, 0x00000007u, 0x00000227u, 0x0006002cu, 0x0000002eu, 0x0000022au, 0x00000065u, + 0x0000013eu, 0x00000190u, 0x00040020u, 0x0000022bu, 0x00000007u, 0x0000002eu, 0x0006002cu, 0x0000002eu, + 0x0000022du, 0x0000013eu, 0x00000008u, 0x00000158u, 0x0006002cu, 0x0000002eu, 0x0000022fu, 0x00000190u, + 0x00000158u, 0x00000044u, 0x0006002cu, 0x0000002eu, 0x00000231u, 0x0000013eu, 0x00000158u, 0x00000190u, + 0x0004001cu, 0x0000023cu, 0x00000006u, 0x00000190u, 0x00040020u, 0x0000023du, 0x00000007u, 0x0000023cu, + 0x0008002cu, 0x0000023cu, 0x0000023fu, 0x00000065u, 0x00000190u, 0x00000199u, 0x000001a1u, 0x000001a9u, + 0x00040020u, 0x00000244u, 0x00000007u, 0x0000004cu, 0x0003002au, 0x0000004cu, 0x00000246u, 0x00030029u, + 0x0000004cu, 0x00000253u, 0x0004001cu, 0x000002a7u, 0x00000006u, 0x00000199u, 0x00040020u, 0x000002a8u, + 0x00000007u, 0x000002a7u, 0x000c002cu, 0x000002a7u, 0x000002aau, 0x00000065u, 0x00000199u, 0x000001c3u, + 0x000001cbu, 0x000001d3u, 0x000001dbu, 0x000001e3u, 0x000001ebu, 0x000001f3u, 0x0004002bu, 0x00000006u, + 0x000002beu, 0x0000001cu, 0x0004002bu, 0x00000006u, 0x000002dfu, 0x00000030u, 0x0004002bu, 0x00000006u, + 0x000002f0u, 0x00000037u, 0x0004002bu, 0x00000006u, 0x00000301u, 0x0000003cu, 0x0004002bu, 0x00000006u, + 0x00000312u, 0x0000003fu, 0x00040020u, 0x00000356u, 0x00000001u, 0x0000002eu, 0x0004003bu, 0x00000356u, + 0x00000357u, 0x00000001u, 0x00040020u, 0x00000358u, 0x00000001u, 0x00000006u, 0x000a001eu, 0x0000035cu, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0000000au, 0x00000009u, + 0x00040020u, 0x0000035du, 0x0000151au, 0x0000035cu, 0x0004003bu, 0x0000035du, 0x0000035eu, 0x0000151au, + 0x00040020u, 0x0000035fu, 0x0000151au, 0x00000006u, 0x0004003bu, 0x00000356u, 0x00000363u, 0x00000001u, + 0x00040015u, 0x00000366u, 0x00000040u, 0x00000001u, 0x0009001eu, 0x00000367u, 0x00000006u, 0x00000006u, + 0x00000366u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x00000368u, 0x00000007u, + 0x00000367u, 0x0009001eu, 0x0000036au, 0x00000006u, 0x00000006u, 0x00000366u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x0003001du, 0x0000036bu, 0x0000036au, 0x0003001eu, 0x0000036cu, 0x0000036bu, + 0x00040020u, 0x0000036du, 0x0000000cu, 0x0000036cu, 0x0004003bu, 0x0000036du, 0x0000036eu, 0x0000000cu, + 0x00040020u, 0x00000371u, 0x0000000cu, 0x0000036au, 0x0004002bu, 0x00000006u, 0x00000375u, 0x00000014u, + 0x0004001cu, 0x00000376u, 0x00000006u, 0x00000375u, 0x000f001eu, 0x00000377u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000376u, 0x00040020u, 0x00000378u, 0x00000007u, 0x00000377u, 0x0004001cu, + 0x0000037au, 0x00000006u, 0x00000375u, 0x000f001eu, 0x0000037bu, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x0000037au, 0x0003001du, 0x0000037cu, 0x0000037bu, 0x0003001eu, 0x0000037du, 0x0000037cu, + 0x00040020u, 0x0000037eu, 0x0000000cu, 0x0000037du, 0x0004003bu, 0x0000037eu, 0x0000037fu, 0x0000000cu, + 0x00040020u, 0x00000382u, 0x0000000cu, 0x0000037bu, 0x0012001eu, 0x00000386u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x00000387u, + 0x00000007u, 0x00000386u, 0x0012001eu, 0x00000389u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x0000038au, 0x00000389u, 0x0003001eu, + 0x0000038bu, 0x0000038au, 0x00040020u, 0x0000038cu, 0x0000000cu, 0x0000038bu, 0x0004003bu, 0x0000038cu, + 0x0000038du, 0x0000000cu, 0x00040020u, 0x00000393u, 0x0000000cu, 0x00000389u, 0x0014001eu, 0x00000398u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x0003001du, 0x00000399u, 0x00000398u, 0x0003001eu, 0x0000039au, 0x00000399u, + 0x00040020u, 0x0000039bu, 0x0000000cu, 0x0000039au, 0x0004003bu, 0x0000039bu, 0x0000039cu, 0x0000000cu, + 0x00040020u, 0x0000039fu, 0x0000000cu, 0x00000398u, 0x0003001eu, 0x000003a4u, 0x0000000du, 0x0003001du, + 0x000003a5u, 0x000003a4u, 0x0003001eu, 0x000003a6u, 0x000003a5u, 0x00040020u, 0x000003a7u, 0x0000000cu, + 0x000003a6u, 0x0004003bu, 0x000003a7u, 0x000003a8u, 0x0000000cu, 0x00040020u, 0x000003abu, 0x0000000cu, + 0x000003a4u, 0x0003001du, 0x000003b5u, 0x00000035u, 0x0003001eu, 0x000003b6u, 0x000003b5u, 0x00040020u, + 0x000003b7u, 0x0000000cu, 0x000003b6u, 0x0004003bu, 0x000003b7u, 0x000003b8u, 0x0000000cu, 0x00040020u, + 0x000003c2u, 0x0000000cu, 0x00000035u, 0x0006001eu, 0x00000414u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00040020u, 0x00000415u, 0x00000007u, 0x00000414u, 0x0006001eu, 0x00000417u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x0003001du, 0x00000418u, 0x00000417u, 0x0003001eu, 0x00000419u, + 0x00000418u, 0x00040020u, 0x0000041au, 0x0000000cu, 0x00000419u, 0x0004003bu, 0x0000041au, 0x0000041bu, + 0x0000000cu, 0x00040020u, 0x0000041fu, 0x0000000cu, 0x00000417u, 0x00040020u, 0x0000042bu, 0x00000007u, + 0x0000000cu, 0x0003001eu, 0x00000434u, 0x0000000cu, 0x0004001cu, 0x00000435u, 0x00000434u, 0x00000160u, + 0x00040020u, 0x00000436u, 0x00000003u, 0x00000435u, 0x0004003bu, 0x00000436u, 0x00000437u, 0x00000003u, + 0x00040020u, 0x0000043au, 0x00000003u, 0x0000000cu, 0x0004002bu, 0x00000006u, 0x0000043cu, 0x00000108u, + 0x0003001du, 0x00000443u, 0x0000002eu, 0x0003001eu, 0x00000444u, 0x00000443u, 0x00040020u, 0x00000445u, + 0x0000000cu, 0x00000444u, 0x0004003bu, 0x00000445u, 0x00000446u, 0x0000000cu, 0x00040020u, 0x0000044au, + 0x0000000cu, 0x0000002eu, 0x0004001cu, 0x00000450u, 0x0000002eu, 0x00000160u, 0x00040020u, 0x00000451u, + 0x00000003u, 0x00000450u, 0x0004003bu, 0x00000451u, 0x00000452u, 0x00000003u, 0x00040020u, 0x0000045cu, + 0x00000003u, 0x0000002eu, 0x0003001eu, 0x0000045eu, 0x00000035u, 0x0004001cu, 0x0000045fu, 0x0000045eu, + 0x00000160u, 0x00040020u, 0x00000460u, 0x00000003u, 0x0000045fu, 0x0004003bu, 0x00000460u, 0x00000461u, + 0x00000003u, 0x00040020u, 0x00000466u, 0x00000003u, 0x00000035u, 0x0004001eu, 0x00000468u, 0x0000000au, + 0x00000009u, 0x0004001cu, 0x00000469u, 0x00000468u, 0x00000160u, 0x00040020u, 0x0000046au, 0x00000003u, + 0x00000469u, 0x0004003bu, 0x0000046au, 0x0000046bu, 0x00000003u, 0x00040020u, 0x0000046du, 0x0000151au, + 0x0000000au, 0x00040020u, 0x00000470u, 0x00000003u, 0x0000000au, 0x00040020u, 0x00000473u, 0x0000151au, + 0x00000009u, 0x00040020u, 0x00000476u, 0x00000003u, 0x00000009u, 0x0019001eu, 0x00000734u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000035u, 0x00000035u, + 0x00000006u, 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000009u, 0x00000009u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x00000735u, + 0x00000009u, 0x00000734u, 0x0004003bu, 0x00000735u, 0x00000736u, 0x00000009u, 0x0004002bu, 0x00000006u, + 0x00000737u, 0x0000000au, 0x0004002bu, 0x00000006u, 0x00000738u, 0x0000000bu, 0x0004002bu, 0x00000006u, + 0x00000739u, 0x0000000du, 0x0004002bu, 0x00000006u, 0x0000073au, 0x00000012u, 0x0004002bu, 0x00000006u, + 0x0000073bu, 0x00000013u, 0x0004002bu, 0x00000006u, 0x0000073cu, 0x00000015u, 0x0004002bu, 0x00000009u, + 0x0000073du, 0x3f7dfdfeu, 0x0004002bu, 0x00000009u, 0x0000073eu, 0x3b808081u, 0x0004002bu, 0x00000009u, + 0x0000073fu, 0x3f68e8e9u, 0x0006002cu, 0x0000000au, 0x00000740u, 0x0000073du, 0x0000073eu, 0x0000073fu, + 0x0004002bu, 0x00000009u, 0x00000741u, 0x3ec4c4c5u, 0x0004002bu, 0x00000009u, 0x00000742u, 0x3f37b7b8u, + 0x0004002bu, 0x00000009u, 0x00000743u, 0x3f79f9fau, 0x0006002cu, 0x0000000au, 0x00000744u, 0x00000741u, + 0x00000742u, 0x00000743u, 0x0004002bu, 0x00000009u, 0x00000745u, 0x3f0b8b8cu, 0x0004002bu, 0x00000009u, + 0x00000746u, 0x3ebababbu, 0x0006002cu, 0x0000000au, 0x00000747u, 0x00000745u, 0x00000746u, 0x0000003bu, + 0x0004002bu, 0x00000009u, 0x00000748u, 0x3ec8c8c9u, 0x0006002cu, 0x0000000au, 0x00000749u, 0x0000003bu, + 0x00000748u, 0x00000050u, 0x0006002cu, 0x0000000au, 0x0000074au, 0x00000050u, 0x0000003bu, 0x00000050u, + 0x0004002bu, 0x00000009u, 0x0000074bu, 0x3ed8d8d9u, 0x0004002bu, 0x00000009u, 0x0000074cu, 0x3f33b3b4u, + 0x0004002bu, 0x00000009u, 0x0000074du, 0x3e6cecedu, 0x0006002cu, 0x0000000au, 0x0000074eu, 0x0000074bu, + 0x0000074cu, 0x0000074du, 0x0004002bu, 0x00000009u, 0x0000074fu, 0x3e8a8a8bu, 0x0004002bu, 0x00000009u, + 0x00000750u, 0x3f31b1b2u, 0x0006002cu, 0x0000000au, 0x00000751u, 0x00000742u, 0x0000074fu, 0x00000750u, + 0x0004002bu, 0x00000009u, 0x00000752u, 0x3da0a0a1u, 0x0004002bu, 0x00000009u, 0x00000753u, 0x3f7efeffu, + 0x0004002bu, 0x00000009u, 0x00000754u, 0x3f39b9bau, 0x0006002cu, 0x0000000au, 0x00000755u, 0x00000752u, + 0x00000753u, 0x00000754u, 0x0006002cu, 0x0000000au, 0x00000756u, 0x00000748u, 0x00000748u, 0x00000748u, + 0x0004002bu, 0x00000009u, 0x00000757u, 0x3d008081u, 0x0004002bu, 0x00000009u, 0x00000758u, 0x3c008081u, + 0x0006002cu, 0x0000000au, 0x00000759u, 0x00000757u, 0x00000758u, 0x0000003bu, 0x0004002bu, 0x00000009u, + 0x0000075au, 0x3ea0a0a1u, 0x0004002bu, 0x00000009u, 0x0000075bu, 0x3ef0f0f1u, 0x0006002cu, 0x0000000au, + 0x0000075cu, 0x0000075au, 0x0000075au, 0x0000075bu, 0x0004002bu, 0x00000009u, 0x0000075du, 0x3e70f0f1u, + 0x0006002cu, 0x0000000au, 0x0000075eu, 0x0000075du, 0x0000075bu, 0x0000075du, 0x0006002cu, 0x0000000au, + 0x0000075fu, 0x0000075bu, 0x0000075au, 0x0000075au, 0x0006002cu, 0x0000000au, 0x00000760u, 0x0000003bu, + 0x0000003bu, 0x0000003bu, 0x0006002cu, 0x0000000au, 0x00000761u, 0x0000003bu, 0x0000003bu, 0x00000050u, + 0x0004002bu, 0x00000009u, 0x00000762u, 0x40e00000u, 0x0004002bu, 0x00000009u, 0x00000763u, 0x41400000u, + 0x0004002bu, 0x00000009u, 0x00000764u, 0x40a00000u, 0x0004002bu, 0x00000009u, 0x00000765u, 0x40400000u, + 0x0003001du, 0x00000766u, 0x0000000cu, 0x0003001eu, 0x00000767u, 0x00000766u, 0x00040020u, 0x00000768u, + 0x0000000cu, 0x00000767u, 0x0004003bu, 0x00000768u, 0x00000769u, 0x0000000cu, 0x0003001du, 0x0000076au, + 0x00000366u, 0x0003001eu, 0x0000076bu, 0x0000076au, 0x00040020u, 0x0000076cu, 0x0000000cu, 0x0000076bu, + 0x0004003bu, 0x0000076cu, 0x0000076du, 0x0000000cu, 0x0003001du, 0x0000076eu, 0x000003a4u, 0x0003001eu, + 0x0000076fu, 0x0000076eu, 0x00040020u, 0x00000770u, 0x0000000cu, 0x0000076fu, 0x0004003bu, 0x00000770u, + 0x00000771u, 0x0000000cu, 0x0003001du, 0x00000772u, 0x00000009u, 0x0003001eu, 0x00000773u, 0x00000772u, + 0x00040020u, 0x00000774u, 0x0000000cu, 0x00000773u, 0x0004003bu, 0x00000774u, 0x00000775u, 0x0000000cu, + 0x0012001eu, 0x00000776u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x0003001du, 0x00000777u, 0x00000776u, 0x0003001eu, 0x00000778u, 0x00000777u, + 0x00040020u, 0x00000779u, 0x0000000cu, 0x00000778u, 0x0004003bu, 0x00000779u, 0x0000077au, 0x0000000cu, + 0x0012001eu, 0x0000077bu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x0003001du, 0x0000077cu, 0x0000077bu, 0x0003001eu, 0x0000077du, 0x0000077cu, + 0x00040020u, 0x0000077eu, 0x0000000cu, 0x0000077du, 0x0004003bu, 0x0000077eu, 0x0000077fu, 0x0000000cu, + 0x0006002cu, 0x0000002eu, 0x00000780u, 0x00000007u, 0x00000008u, 0x00000008u, 0x00050036u, 0x00000002u, + 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000018u, 0x00000354u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000355u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000035bu, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000362u, 0x00000007u, 0x0004003bu, 0x00000368u, 0x00000369u, + 0x00000007u, 0x0004003bu, 0x00000378u, 0x00000379u, 0x00000007u, 0x0004003bu, 0x00000387u, 0x00000388u, + 0x00000007u, 0x0004003bu, 0x00000011u, 0x00000397u, 0x00000007u, 0x0004003bu, 0x0000000fu, 0x000003a3u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000003afu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000003c6u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000003d2u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000003d6u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000003e8u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000003f0u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000405u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000409u, + 0x00000007u, 0x0004003bu, 0x00000415u, 0x00000416u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000423u, + 0x00000007u, 0x0004003bu, 0x0000042bu, 0x0000042cu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000042du, + 0x00000007u, 0x0004003bu, 0x0000000fu, 0x0000042fu, 0x00000007u, 0x0004003bu, 0x00000011u, 0x00000431u, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x00000442u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000044du, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000047du, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000047eu, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000480u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000481u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000483u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000484u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000488u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000048eu, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000498u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000049cu, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x000004a8u, 0x00000007u, 0x0004003bu, 0x00000415u, 0x000004b0u, + 0x00000007u, 0x0004003bu, 0x00000415u, 0x000004b8u, 0x00000007u, 0x0004003bu, 0x00000415u, 0x000004c0u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004c8u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004d0u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004d8u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000004e0u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000004e4u, 0x00000007u, 0x0004003bu, 0x00000026u, 0x000004edu, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000004eeu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000004f0u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004f2u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004f3u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004f5u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004f7u, + 0x00000007u, 0x0004003bu, 0x00000026u, 0x000004f9u, 0x00000007u, 0x0004003bu, 0x0000042bu, 0x000004fcu, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000004fdu, 0x00000007u, 0x0004003bu, 0x0000000fu, 0x000004ffu, + 0x00000007u, 0x0004003bu, 0x00000011u, 0x00000501u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000510u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000514u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000518u, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x00000521u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000522u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000524u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000526u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000555u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000558u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000055du, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000567u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000056eu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000571u, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x0000057cu, 0x00000007u, 0x0004003bu, 0x00000415u, 0x00000584u, + 0x00000007u, 0x0004003bu, 0x00000415u, 0x0000058cu, 0x00000007u, 0x0004003bu, 0x00000415u, 0x00000594u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000059cu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005a4u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005acu, 0x00000007u, 0x0004003bu, 0x00000026u, 0x000005b4u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005b5u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005b7u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005b9u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005bau, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005bcu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005beu, + 0x00000007u, 0x0004003bu, 0x00000026u, 0x000005c0u, 0x00000007u, 0x0004003bu, 0x0000042bu, 0x000005c3u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000005c4u, 0x00000007u, 0x0004003bu, 0x0000000fu, 0x000005c6u, + 0x00000007u, 0x0004003bu, 0x00000011u, 0x000005c8u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005cbu, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005dbu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005deu, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x000005e3u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005e4u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005e6u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000005e8u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000060du, 0x00000007u, 0x0004003bu, 0x0000022bu, 0x00000618u, + 0x00000007u, 0x0004003bu, 0x00000415u, 0x0000061eu, 0x00000007u, 0x0004003bu, 0x00000415u, 0x00000626u, + 0x00000007u, 0x0004003bu, 0x00000415u, 0x0000062eu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000636u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000063eu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000646u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000064eu, 0x00000007u, 0x0004003bu, 0x00000026u, 0x00000657u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000658u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000065au, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000065cu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000065du, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x0000065fu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000661u, + 0x00000007u, 0x0004003bu, 0x00000026u, 0x00000663u, 0x00000007u, 0x0004003bu, 0x0000042bu, 0x00000666u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000667u, 0x00000007u, 0x0004003bu, 0x0000000fu, 0x00000669u, + 0x00000007u, 0x0004003bu, 0x00000011u, 0x0000066bu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000673u, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x0000067cu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000067du, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000067fu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000681u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000069eu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000006a1u, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x000006a6u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000006b0u, + 0x00000007u, 0x0004003bu, 0x0000022bu, 0x000006bbu, 0x00000007u, 0x0004003bu, 0x00000415u, 0x000006c3u, + 0x00000007u, 0x0004003bu, 0x00000415u, 0x000006cbu, 0x00000007u, 0x0004003bu, 0x00000415u, 0x000006d3u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000006dbu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000006e3u, + 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000006ebu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000006f3u, + 0x00000007u, 0x0004003bu, 0x0000042bu, 0x000006f6u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000006f7u, + 0x00000007u, 0x0004003bu, 0x0000000fu, 0x000006f9u, 0x00000007u, 0x0004003bu, 0x00000011u, 0x000006fbu, + 0x00000007u, 0x0004003bu, 0x0000042bu, 0x000006feu, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x000006ffu, + 0x00000007u, 0x0004003bu, 0x0000000fu, 0x00000701u, 0x00000007u, 0x0004003bu, 0x00000011u, 0x00000703u, + 0x00000007u, 0x0004003bu, 0x0000042bu, 0x00000706u, 0x00000007u, 0x0004003bu, 0x0000000bu, 0x00000707u, + 0x00000007u, 0x0004003bu, 0x0000000fu, 0x00000709u, 0x00000007u, 0x0004003bu, 0x00000011u, 0x0000070bu, + 0x00000007u, 0x0004003bu, 0x00000018u, 0x0000071au, 0x00000007u, 0x0003003eu, 0x00000354u, 0x00000065u, + 0x00050041u, 0x00000358u, 0x00000359u, 0x00000357u, 0x00000065u, 0x0004003du, 0x00000006u, 0x0000035au, + 0x00000359u, 0x0003003eu, 0x00000355u, 0x0000035au, 0x00050041u, 0x0000035fu, 0x00000360u, 0x0000035eu, + 0x00000061u, 0x0004003du, 0x00000006u, 0x00000361u, 0x00000360u, 0x0003003eu, 0x0000035bu, 0x00000361u, + 0x00050041u, 0x00000358u, 0x00000364u, 0x00000363u, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000365u, + 0x00000364u, 0x0003003eu, 0x00000362u, 0x00000365u, 0x00050041u, 0x0000035fu, 0x0000036fu, 0x0000035eu, + 0x00000036u, 0x0004003du, 0x00000006u, 0x00000370u, 0x0000036fu, 0x00060041u, 0x00000371u, 0x00000372u, + 0x0000036eu, 0x00000036u, 0x00000370u, 0x0004003du, 0x0000036au, 0x00000373u, 0x00000372u, 0x00040190u, + 0x00000367u, 0x00000374u, 0x00000373u, 0x0003003eu, 0x00000369u, 0x00000374u, 0x00050041u, 0x00000018u, + 0x00000380u, 0x00000369u, 0x00000036u, 0x0004003du, 0x00000006u, 0x00000381u, 0x00000380u, 0x00060041u, + 0x00000382u, 0x00000383u, 0x0000037fu, 0x00000036u, 0x00000381u, 0x0004003du, 0x0000037bu, 0x00000384u, + 0x00000383u, 0x00040190u, 0x00000377u, 0x00000385u, 0x00000384u, 0x0003003eu, 0x00000379u, 0x00000385u, + 0x00050041u, 0x00000018u, 0x0000038eu, 0x00000379u, 0x00000076u, 0x0004003du, 0x00000006u, 0x0000038fu, + 0x0000038eu, 0x00050041u, 0x0000035fu, 0x00000390u, 0x0000035eu, 0x00000104u, 0x0004003du, 0x00000006u, + 0x00000391u, 0x00000390u, 0x00050080u, 0x00000006u, 0x00000392u, 0x0000038fu, 0x00000391u, 0x00060041u, + 0x00000393u, 0x00000394u, 0x0000038du, 0x00000036u, 0x00000392u, 0x0004003du, 0x00000389u, 0x00000395u, + 0x00000394u, 0x00040190u, 0x00000386u, 0x00000396u, 0x00000395u, 0x0003003eu, 0x00000388u, 0x00000396u, + 0x00050041u, 0x00000018u, 0x0000039du, 0x00000369u, 0x00000104u, 0x0004003du, 0x00000006u, 0x0000039eu, + 0x0000039du, 0x00060041u, 0x0000039fu, 0x000003a0u, 0x0000039cu, 0x00000036u, 0x0000039eu, 0x0004003du, + 0x00000398u, 0x000003a1u, 0x000003a0u, 0x00040190u, 0x00000010u, 0x000003a2u, 0x000003a1u, 0x0003003eu, + 0x00000397u, 0x000003a2u, 0x00050041u, 0x0000035fu, 0x000003a9u, 0x0000035eu, 0x00000036u, 0x0004003du, + 0x00000006u, 0x000003aau, 0x000003a9u, 0x00060041u, 0x000003abu, 0x000003acu, 0x000003a8u, 0x00000036u, + 0x000003aau, 0x0004003du, 0x000003a4u, 0x000003adu, 0x000003acu, 0x00040190u, 0x0000000eu, 0x000003aeu, + 0x000003adu, 0x0003003eu, 0x000003a3u, 0x000003aeu, 0x0003003eu, 0x000003afu, 0x00000065u, 0x00050041u, + 0x0000035fu, 0x000003b0u, 0x0000035eu, 0x0000006au, 0x0004003du, 0x00000006u, 0x000003b1u, 0x000003b0u, + 0x000500acu, 0x0000004cu, 0x000003b2u, 0x000003b1u, 0x00000065u, 0x000300f7u, 0x000003b4u, 0x00000000u, + 0x000400fau, 0x000003b2u, 0x000003b3u, 0x000003b4u, 0x000200f8u, 0x000003b3u, 0x00050041u, 0x00000018u, + 0x000003b9u, 0x00000379u, 0x000000afu, 0x0004003du, 0x00000006u, 0x000003bau, 0x000003b9u, 0x00050041u, + 0x00000018u, 0x000003bbu, 0x00000388u, 0x000000b5u, 0x0004003du, 0x00000006u, 0x000003bcu, 0x000003bbu, + 0x00050080u, 0x00000006u, 0x000003bdu, 0x000003bau, 0x000003bcu, 0x00050041u, 0x0000035fu, 0x000003beu, + 0x0000035eu, 0x0000006au, 0x0004003du, 0x00000006u, 0x000003bfu, 0x000003beu, 0x00050080u, 0x00000006u, + 0x000003c0u, 0x000003bdu, 0x000003bfu, 0x00050082u, 0x00000006u, 0x000003c1u, 0x000003c0u, 0x00000008u, + 0x00060041u, 0x000003c2u, 0x000003c3u, 0x000003b8u, 0x00000036u, 0x000003c1u, 0x0004003du, 0x00000035u, + 0x000003c4u, 0x000003c3u, 0x0004007cu, 0x00000006u, 0x000003c5u, 0x000003c4u, 0x0003003eu, 0x000003afu, + 0x000003c5u, 0x000200f9u, 0x000003b4u, 0x000200f8u, 0x000003b4u, 0x00050041u, 0x00000018u, 0x000003c7u, + 0x00000379u, 0x000000afu, 0x0004003du, 0x00000006u, 0x000003c8u, 0x000003c7u, 0x00050041u, 0x00000018u, + 0x000003c9u, 0x00000388u, 0x000000b5u, 0x0004003du, 0x00000006u, 0x000003cau, 0x000003c9u, 0x00050080u, + 0x00000006u, 0x000003cbu, 0x000003c8u, 0x000003cau, 0x00050041u, 0x0000035fu, 0x000003ccu, 0x0000035eu, + 0x0000006au, 0x0004003du, 0x00000006u, 0x000003cdu, 0x000003ccu, 0x00050080u, 0x00000006u, 0x000003ceu, + 0x000003cbu, 0x000003cdu, 0x00060041u, 0x000003c2u, 0x000003cfu, 0x000003b8u, 0x00000036u, 0x000003ceu, + 0x0004003du, 0x00000035u, 0x000003d0u, 0x000003cfu, 0x0004007cu, 0x00000006u, 0x000003d1u, 0x000003d0u, + 0x0003003eu, 0x000003c6u, 0x000003d1u, 0x0004003du, 0x00000006u, 0x000003d3u, 0x000003c6u, 0x0004003du, + 0x00000006u, 0x000003d4u, 0x000003afu, 0x00050082u, 0x00000006u, 0x000003d5u, 0x000003d3u, 0x000003d4u, + 0x0003003eu, 0x000003d2u, 0x000003d5u, 0x0003003eu, 0x000003d6u, 0x00000065u, 0x00050041u, 0x0000035fu, + 0x000003d7u, 0x0000035eu, 0x0000006au, 0x0004003du, 0x00000006u, 0x000003d8u, 0x000003d7u, 0x000500acu, + 0x0000004cu, 0x000003d9u, 0x000003d8u, 0x00000065u, 0x000300f7u, 0x000003dbu, 0x00000000u, 0x000400fau, + 0x000003d9u, 0x000003dau, 0x000003dbu, 0x000200f8u, 0x000003dau, 0x00050041u, 0x00000018u, 0x000003dcu, + 0x00000379u, 0x000000afu, 0x0004003du, 0x00000006u, 0x000003ddu, 0x000003dcu, 0x00050041u, 0x00000018u, + 0x000003deu, 0x00000388u, 0x000000afu, 0x0004003du, 0x00000006u, 0x000003dfu, 0x000003deu, 0x00050080u, + 0x00000006u, 0x000003e0u, 0x000003ddu, 0x000003dfu, 0x00050041u, 0x0000035fu, 0x000003e1u, 0x0000035eu, + 0x0000006au, 0x0004003du, 0x00000006u, 0x000003e2u, 0x000003e1u, 0x00050080u, 0x00000006u, 0x000003e3u, + 0x000003e0u, 0x000003e2u, 0x00050082u, 0x00000006u, 0x000003e4u, 0x000003e3u, 0x00000008u, 0x00060041u, + 0x000003c2u, 0x000003e5u, 0x000003b8u, 0x00000036u, 0x000003e4u, 0x0004003du, 0x00000035u, 0x000003e6u, + 0x000003e5u, 0x0004007cu, 0x00000006u, 0x000003e7u, 0x000003e6u, 0x0003003eu, 0x000003d6u, 0x000003e7u, + 0x000200f9u, 0x000003dbu, 0x000200f8u, 0x000003dbu, 0x00050041u, 0x00000018u, 0x000003e9u, 0x00000379u, + 0x000000b5u, 0x0004003du, 0x00000006u, 0x000003eau, 0x000003e9u, 0x00050041u, 0x00000018u, 0x000003ebu, + 0x00000388u, 0x000000bbu, 0x0004003du, 0x00000006u, 0x000003ecu, 0x000003ebu, 0x00050080u, 0x00000006u, + 0x000003edu, 0x000003eau, 0x000003ecu, 0x0004003du, 0x00000006u, 0x000003eeu, 0x000003d6u, 0x00050080u, + 0x00000006u, 0x000003efu, 0x000003edu, 0x000003eeu, 0x0003003eu, 0x000003e8u, 0x000003efu, 0x00050041u, + 0x00000018u, 0x000003f1u, 0x00000379u, 0x000000bbu, 0x0004003du, 0x00000006u, 0x000003f2u, 0x000003f1u, + 0x00050041u, 0x00000018u, 0x000003f3u, 0x00000388u, 0x00000055u, 0x0004003du, 0x00000006u, 0x000003f4u, + 0x000003f3u, 0x00050080u, 0x00000006u, 0x000003f5u, 0x000003f2u, 0x000003f4u, 0x0004003du, 0x00000006u, + 0x000003f6u, 0x000003afu, 0x00050080u, 0x00000006u, 0x000003f7u, 0x000003f5u, 0x000003f6u, 0x0003003eu, + 0x000003f0u, 0x000003f7u, 0x0004003du, 0x00000006u, 0x000003f8u, 0x0000035bu, 0x000500aau, 0x0000004cu, + 0x000003f9u, 0x000003f8u, 0x00000065u, 0x000300f7u, 0x000003fbu, 0x00000000u, 0x000400fau, 0x000003f9u, + 0x000003fau, 0x000003fbu, 0x000200f8u, 0x000003fau, 0x00050041u, 0x0000035fu, 0x000003fcu, 0x0000035eu, + 0x000000a1u, 0x0004003du, 0x00000006u, 0x000003fdu, 0x000003fcu, 0x000500b2u, 0x0000004cu, 0x000003feu, + 0x000003fdu, 0x000001d3u, 0x000200f9u, 0x000003fbu, 0x000200f8u, 0x000003fbu, 0x000700f5u, 0x0000004cu, + 0x000003ffu, 0x000003f9u, 0x000003dbu, 0x000003feu, 0x000003fau, 0x0004003du, 0x00000006u, 0x00000400u, + 0x00000355u, 0x000500aau, 0x0000004cu, 0x00000401u, 0x00000400u, 0x00000065u, 0x000500a7u, 0x0000004cu, + 0x00000402u, 0x000003ffu, 0x00000401u, 0x000300f7u, 0x00000404u, 0x00000000u, 0x000400fau, 0x00000402u, + 0x00000403u, 0x00000478u, 0x000200f8u, 0x00000403u, 0x00050041u, 0x0000035fu, 0x00000406u, 0x0000035eu, + 0x000000a1u, 0x0004003du, 0x00000006u, 0x00000407u, 0x00000406u, 0x0007000cu, 0x00000006u, 0x00000408u, + 0x00000001u, 0x00000026u, 0x00000407u, 0x000001d3u, 0x0003003eu, 0x00000405u, 0x00000408u, 0x0004003du, + 0x00000006u, 0x0000040au, 0x000003d2u, 0x0007000cu, 0x00000006u, 0x0000040bu, 0x00000001u, 0x00000026u, + 0x0000040au, 0x000002beu, 0x0003003eu, 0x00000409u, 0x0000040bu, 0x0004003du, 0x00000006u, 0x0000040cu, + 0x00000409u, 0x0003003eu, 0x00000354u, 0x0000040cu, 0x0004003du, 0x00000006u, 0x0000040du, 0x00000405u, + 0x0004003du, 0x00000006u, 0x0000040eu, 0x00000354u, 0x000314afu, 0x0000040du, 0x0000040eu, 0x0004003du, + 0x00000006u, 0x0000040fu, 0x00000362u, 0x0004003du, 0x00000006u, 0x00000410u, 0x00000405u, 0x000500b0u, + 0x0000004cu, 0x00000411u, 0x0000040fu, 0x00000410u, 0x000300f7u, 0x00000413u, 0x00000000u, 0x000400fau, + 0x00000411u, 0x00000412u, 0x00000413u, 0x000200f8u, 0x00000412u, 0x0004003du, 0x00000006u, 0x0000041cu, + 0x000003e8u, 0x0004003du, 0x00000006u, 0x0000041du, 0x00000362u, 0x00050080u, 0x00000006u, 0x0000041eu, + 0x0000041cu, 0x0000041du, 0x00060041u, 0x0000041fu, 0x00000420u, 0x0000041bu, 0x00000036u, 0x0000041eu, + 0x0004003du, 0x00000417u, 0x00000421u, 0x00000420u, 0x00040190u, 0x00000414u, 0x00000422u, 0x00000421u, + 0x0003003eu, 0x00000416u, 0x00000422u, 0x00050041u, 0x00000042u, 0x00000424u, 0x00000416u, 0x00000036u, + 0x0004003du, 0x00000009u, 0x00000425u, 0x00000424u, 0x00050041u, 0x00000042u, 0x00000426u, 0x00000416u, + 0x00000104u, 0x0004003du, 0x00000009u, 0x00000427u, 0x00000426u, 0x00050041u, 0x00000042u, 0x00000428u, + 0x00000416u, 0x0000006au, 0x0004003du, 0x00000009u, 0x00000429u, 0x00000428u, 0x00060050u, 0x0000000au, + 0x0000042au, 0x00000425u, 0x00000427u, 0x00000429u, 0x0003003eu, 0x00000423u, 0x0000042au, 0x0004003du, + 0x0000000au, 0x0000042eu, 0x00000423u, 0x0003003eu, 0x0000042du, 0x0000042eu, 0x0004003du, 0x0000000eu, + 0x00000430u, 0x000003a3u, 0x0003003eu, 0x0000042fu, 0x00000430u, 0x0004003du, 0x00000010u, 0x00000432u, + 0x00000397u, 0x0003003eu, 0x00000431u, 0x00000432u, 0x00070039u, 0x0000000cu, 0x00000433u, 0x00000016u, + 0x0000042du, 0x0000042fu, 0x00000431u, 0x0003003eu, 0x0000042cu, 0x00000433u, 0x0004003du, 0x00000006u, + 0x00000438u, 0x00000362u, 0x0004003du, 0x0000000cu, 0x00000439u, 0x0000042cu, 0x00060041u, 0x0000043au, + 0x0000043bu, 0x00000437u, 0x00000438u, 0x00000036u, 0x0003003eu, 0x0000043bu, 0x00000439u, 0x000200f9u, + 0x00000413u, 0x000200f8u, 0x00000413u, 0x000400e0u, 0x00000044u, 0x00000044u, 0x0000043cu, 0x0004003du, + 0x00000006u, 0x0000043du, 0x00000362u, 0x0004003du, 0x00000006u, 0x0000043eu, 0x00000409u, 0x000500b0u, + 0x0000004cu, 0x0000043fu, 0x0000043du, 0x0000043eu, 0x000300f7u, 0x00000441u, 0x00000000u, 0x000400fau, + 0x0000043fu, 0x00000440u, 0x00000441u, 0x000200f8u, 0x00000440u, 0x0004003du, 0x00000006u, 0x00000447u, + 0x000003f0u, 0x0004003du, 0x00000006u, 0x00000448u, 0x00000362u, 0x00050080u, 0x00000006u, 0x00000449u, + 0x00000447u, 0x00000448u, 0x00060041u, 0x0000044au, 0x0000044bu, 0x00000446u, 0x00000036u, 0x00000449u, + 0x0004003du, 0x0000002eu, 0x0000044cu, 0x0000044bu, 0x0003003eu, 0x00000442u, 0x0000044cu, 0x0004003du, + 0x00000006u, 0x0000044eu, 0x00000362u, 0x00050084u, 0x00000006u, 0x0000044fu, 0x0000044eu, 0x0000013eu, + 0x0003003eu, 0x0000044du, 0x0000044fu, 0x0004003du, 0x00000006u, 0x00000453u, 0x0000044du, 0x00050086u, + 0x00000006u, 0x00000454u, 0x00000453u, 0x0000013eu, 0x00050041u, 0x00000018u, 0x00000455u, 0x00000442u, + 0x00000065u, 0x0004003du, 0x00000006u, 0x00000456u, 0x00000455u, 0x00050041u, 0x00000018u, 0x00000457u, + 0x00000442u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000458u, 0x00000457u, 0x00050041u, 0x00000018u, + 0x00000459u, 0x00000442u, 0x00000044u, 0x0004003du, 0x00000006u, 0x0000045au, 0x00000459u, 0x00060050u, + 0x0000002eu, 0x0000045bu, 0x00000456u, 0x00000458u, 0x0000045au, 0x00050041u, 0x0000045cu, 0x0000045du, + 0x00000452u, 0x00000454u, 0x0003003eu, 0x0000045du, 0x0000045bu, 0x0004003du, 0x00000006u, 0x00000462u, + 0x00000362u, 0x00050041u, 0x0000035fu, 0x00000463u, 0x0000035eu, 0x00000036u, 0x0004003du, 0x00000006u, + 0x00000464u, 0x00000463u, 0x0004007cu, 0x00000035u, 0x00000465u, 0x00000464u, 0x00060041u, 0x00000466u, + 0x00000467u, 0x00000461u, 0x00000462u, 0x00000036u, 0x0003003eu, 0x00000467u, 0x00000465u, 0x0004003du, + 0x00000006u, 0x0000046cu, 0x00000362u, 0x00050041u, 0x0000046du, 0x0000046eu, 0x0000035eu, 0x000000a9u, + 0x0004003du, 0x0000000au, 0x0000046fu, 0x0000046eu, 0x00060041u, 0x00000470u, 0x00000471u, 0x0000046bu, + 0x0000046cu, 0x00000036u, 0x0003003eu, 0x00000471u, 0x0000046fu, 0x0004003du, 0x00000006u, 0x00000472u, + 0x00000362u, 0x00050041u, 0x00000473u, 0x00000474u, 0x0000035eu, 0x000000afu, 0x0004003du, 0x00000009u, + 0x00000475u, 0x00000474u, 0x00060041u, 0x00000476u, 0x00000477u, 0x0000046bu, 0x00000472u, 0x00000104u, + 0x0003003eu, 0x00000477u, 0x00000475u, 0x000200f9u, 0x00000441u, 0x000200f8u, 0x00000441u, 0x000200f9u, + 0x00000404u, 0x000200f8u, 0x00000478u, 0x0004003du, 0x00000006u, 0x00000479u, 0x0000035bu, 0x000500aau, + 0x0000004cu, 0x0000047au, 0x00000479u, 0x00000008u, 0x000300f7u, 0x0000047cu, 0x00000000u, 0x000400fau, + 0x0000047au, 0x0000047bu, 0x00000550u, 0x000200f8u, 0x0000047bu, 0x0003003eu, 0x0000047eu, 0x00000008u, + 0x00050039u, 0x00000006u, 0x0000047fu, 0x0000001bu, 0x0000047eu, 0x0003003eu, 0x0000047du, 0x0000047fu, + 0x0003003eu, 0x00000481u, 0x00000008u, 0x00050039u, 0x00000006u, 0x00000482u, 0x0000001eu, 0x00000481u, + 0x0003003eu, 0x00000480u, 0x00000482u, 0x0003003eu, 0x00000483u, 0x00000190u, 0x0004003du, 0x00000006u, + 0x00000485u, 0x00000355u, 0x0004003du, 0x00000006u, 0x00000486u, 0x00000483u, 0x00050084u, 0x00000006u, + 0x00000487u, 0x00000485u, 0x00000486u, 0x0003003eu, 0x00000484u, 0x00000487u, 0x0004003du, 0x00000006u, + 0x00000489u, 0x00000484u, 0x0004003du, 0x00000006u, 0x0000048au, 0x00000483u, 0x00050080u, 0x00000006u, + 0x0000048bu, 0x00000489u, 0x0000048au, 0x0004003du, 0x00000006u, 0x0000048cu, 0x000003d2u, 0x0007000cu, + 0x00000006u, 0x0000048du, 0x00000001u, 0x00000026u, 0x0000048bu, 0x0000048cu, 0x0003003eu, 0x00000488u, + 0x0000048du, 0x0004003du, 0x00000006u, 0x0000048fu, 0x00000488u, 0x0004003du, 0x00000006u, 0x00000490u, + 0x00000484u, 0x00050082u, 0x00000006u, 0x00000491u, 0x0000048fu, 0x00000490u, 0x0003003eu, 0x0000048eu, + 0x00000491u, 0x0004003du, 0x00000006u, 0x00000492u, 0x0000048eu, 0x000500aau, 0x0000004cu, 0x00000493u, + 0x00000492u, 0x00000065u, 0x000300f7u, 0x00000495u, 0x00000000u, 0x000400fau, 0x00000493u, 0x00000494u, + 0x00000495u, 0x000200f8u, 0x00000494u, 0x0003003eu, 0x00000354u, 0x00000065u, 0x0004003du, 0x00000006u, + 0x00000496u, 0x00000354u, 0x000314afu, 0x00000065u, 0x00000496u, 0x000100fdu, 0x000200f8u, 0x00000495u, + 0x0004003du, 0x00000006u, 0x00000499u, 0x0000048eu, 0x0004003du, 0x00000006u, 0x0000049au, 0x0000047du, + 0x00050084u, 0x00000006u, 0x0000049bu, 0x00000499u, 0x0000049au, 0x0003003eu, 0x00000498u, 0x0000049bu, + 0x0004003du, 0x00000006u, 0x0000049du, 0x0000048eu, 0x0004003du, 0x00000006u, 0x0000049eu, 0x00000480u, + 0x00050084u, 0x00000006u, 0x0000049fu, 0x0000049du, 0x0000049eu, 0x0003003eu, 0x0000049cu, 0x0000049fu, + 0x0004003du, 0x00000006u, 0x000004a0u, 0x0000049cu, 0x0003003eu, 0x00000354u, 0x000004a0u, 0x0004003du, + 0x00000006u, 0x000004a1u, 0x00000498u, 0x0004003du, 0x00000006u, 0x000004a2u, 0x00000354u, 0x000314afu, + 0x000004a1u, 0x000004a2u, 0x0004003du, 0x00000006u, 0x000004a3u, 0x00000362u, 0x0004003du, 0x00000006u, + 0x000004a4u, 0x0000048eu, 0x000500b0u, 0x0000004cu, 0x000004a5u, 0x000004a3u, 0x000004a4u, 0x000300f7u, + 0x000004a7u, 0x00000000u, 0x000400fau, 0x000004a5u, 0x000004a6u, 0x000004a7u, 0x000200f8u, 0x000004a6u, + 0x0004003du, 0x00000006u, 0x000004a9u, 0x000003f0u, 0x0004003du, 0x00000006u, 0x000004aau, 0x00000484u, + 0x00050080u, 0x00000006u, 0x000004abu, 0x000004a9u, 0x000004aau, 0x0004003du, 0x00000006u, 0x000004acu, + 0x00000362u, 0x00050080u, 0x00000006u, 0x000004adu, 0x000004abu, 0x000004acu, 0x00060041u, 0x0000044au, + 0x000004aeu, 0x00000446u, 0x00000036u, 0x000004adu, 0x0004003du, 0x0000002eu, 0x000004afu, 0x000004aeu, + 0x0003003eu, 0x000004a8u, 0x000004afu, 0x0004003du, 0x00000006u, 0x000004b1u, 0x000003e8u, 0x00050041u, + 0x00000018u, 0x000004b2u, 0x000004a8u, 0x00000065u, 0x0004003du, 0x00000006u, 0x000004b3u, 0x000004b2u, + 0x00050080u, 0x00000006u, 0x000004b4u, 0x000004b1u, 0x000004b3u, 0x00060041u, 0x0000041fu, 0x000004b5u, + 0x0000041bu, 0x00000036u, 0x000004b4u, 0x0004003du, 0x00000417u, 0x000004b6u, 0x000004b5u, 0x00040190u, + 0x00000414u, 0x000004b7u, 0x000004b6u, 0x0003003eu, 0x000004b0u, 0x000004b7u, 0x0004003du, 0x00000006u, + 0x000004b9u, 0x000003e8u, 0x00050041u, 0x00000018u, 0x000004bau, 0x000004a8u, 0x00000008u, 0x0004003du, + 0x00000006u, 0x000004bbu, 0x000004bau, 0x00050080u, 0x00000006u, 0x000004bcu, 0x000004b9u, 0x000004bbu, + 0x00060041u, 0x0000041fu, 0x000004bdu, 0x0000041bu, 0x00000036u, 0x000004bcu, 0x0004003du, 0x00000417u, + 0x000004beu, 0x000004bdu, 0x00040190u, 0x00000414u, 0x000004bfu, 0x000004beu, 0x0003003eu, 0x000004b8u, + 0x000004bfu, 0x0004003du, 0x00000006u, 0x000004c1u, 0x000003e8u, 0x00050041u, 0x00000018u, 0x000004c2u, + 0x000004a8u, 0x00000044u, 0x0004003du, 0x00000006u, 0x000004c3u, 0x000004c2u, 0x00050080u, 0x00000006u, + 0x000004c4u, 0x000004c1u, 0x000004c3u, 0x00060041u, 0x0000041fu, 0x000004c5u, 0x0000041bu, 0x00000036u, + 0x000004c4u, 0x0004003du, 0x00000417u, 0x000004c6u, 0x000004c5u, 0x00040190u, 0x00000414u, 0x000004c7u, + 0x000004c6u, 0x0003003eu, 0x000004c0u, 0x000004c7u, 0x00050041u, 0x00000042u, 0x000004c9u, 0x000004b0u, + 0x00000036u, 0x0004003du, 0x00000009u, 0x000004cau, 0x000004c9u, 0x00050041u, 0x00000042u, 0x000004cbu, + 0x000004b0u, 0x00000104u, 0x0004003du, 0x00000009u, 0x000004ccu, 0x000004cbu, 0x00050041u, 0x00000042u, + 0x000004cdu, 0x000004b0u, 0x0000006au, 0x0004003du, 0x00000009u, 0x000004ceu, 0x000004cdu, 0x00060050u, + 0x0000000au, 0x000004cfu, 0x000004cau, 0x000004ccu, 0x000004ceu, 0x0003003eu, 0x000004c8u, 0x000004cfu, + 0x00050041u, 0x00000042u, 0x000004d1u, 0x000004b8u, 0x00000036u, 0x0004003du, 0x00000009u, 0x000004d2u, + 0x000004d1u, 0x00050041u, 0x00000042u, 0x000004d3u, 0x000004b8u, 0x00000104u, 0x0004003du, 0x00000009u, + 0x000004d4u, 0x000004d3u, 0x00050041u, 0x00000042u, 0x000004d5u, 0x000004b8u, 0x0000006au, 0x0004003du, + 0x00000009u, 0x000004d6u, 0x000004d5u, 0x00060050u, 0x0000000au, 0x000004d7u, 0x000004d2u, 0x000004d4u, + 0x000004d6u, 0x0003003eu, 0x000004d0u, 0x000004d7u, 0x00050041u, 0x00000042u, 0x000004d9u, 0x000004c0u, + 0x00000036u, 0x0004003du, 0x00000009u, 0x000004dau, 0x000004d9u, 0x00050041u, 0x00000042u, 0x000004dbu, + 0x000004c0u, 0x00000104u, 0x0004003du, 0x00000009u, 0x000004dcu, 0x000004dbu, 0x00050041u, 0x00000042u, + 0x000004ddu, 0x000004c0u, 0x0000006au, 0x0004003du, 0x00000009u, 0x000004deu, 0x000004ddu, 0x00060050u, + 0x0000000au, 0x000004dfu, 0x000004dau, 0x000004dcu, 0x000004deu, 0x0003003eu, 0x000004d8u, 0x000004dfu, + 0x0004003du, 0x00000006u, 0x000004e1u, 0x00000362u, 0x0004003du, 0x00000006u, 0x000004e2u, 0x0000047du, + 0x00050084u, 0x00000006u, 0x000004e3u, 0x000004e1u, 0x000004e2u, 0x0003003eu, 0x000004e0u, 0x000004e3u, + 0x0003003eu, 0x000004e4u, 0x00000065u, 0x000200f9u, 0x000004e5u, 0x000200f8u, 0x000004e5u, 0x000400f6u, + 0x000004e7u, 0x000004e8u, 0x00000000u, 0x000200f9u, 0x000004e9u, 0x000200f8u, 0x000004e9u, 0x0004003du, + 0x00000006u, 0x000004eau, 0x000004e4u, 0x0004003du, 0x00000006u, 0x000004ebu, 0x0000047du, 0x000500b0u, + 0x0000004cu, 0x000004ecu, 0x000004eau, 0x000004ebu, 0x000400fau, 0x000004ecu, 0x000004e6u, 0x000004e7u, + 0x000200f8u, 0x000004e6u, 0x0004003du, 0x00000006u, 0x000004efu, 0x000004e4u, 0x0003003eu, 0x000004eeu, + 0x000004efu, 0x0003003eu, 0x000004f0u, 0x00000008u, 0x00060039u, 0x00000020u, 0x000004f1u, 0x00000024u, + 0x000004eeu, 0x000004f0u, 0x0003003eu, 0x000004edu, 0x000004f1u, 0x0004003du, 0x0000000au, 0x000004f4u, + 0x000004c8u, 0x0003003eu, 0x000004f3u, 0x000004f4u, 0x0004003du, 0x0000000au, 0x000004f6u, 0x000004d0u, + 0x0003003eu, 0x000004f5u, 0x000004f6u, 0x0004003du, 0x0000000au, 0x000004f8u, 0x000004d8u, 0x0003003eu, + 0x000004f7u, 0x000004f8u, 0x0004003du, 0x00000020u, 0x000004fau, 0x000004edu, 0x0003003eu, 0x000004f9u, + 0x000004fau, 0x00080039u, 0x0000000au, 0x000004fbu, 0x0000002cu, 0x000004f3u, 0x000004f5u, 0x000004f7u, + 0x000004f9u, 0x0003003eu, 0x000004f2u, 0x000004fbu, 0x0004003du, 0x0000000au, 0x000004feu, 0x000004f2u, + 0x0003003eu, 0x000004fdu, 0x000004feu, 0x0004003du, 0x0000000eu, 0x00000500u, 0x000003a3u, 0x0003003eu, + 0x000004ffu, 0x00000500u, 0x0004003du, 0x00000010u, 0x00000502u, 0x00000397u, 0x0003003eu, 0x00000501u, + 0x00000502u, 0x00070039u, 0x0000000cu, 0x00000503u, 0x00000016u, 0x000004fdu, 0x000004ffu, 0x00000501u, + 0x0003003eu, 0x000004fcu, 0x00000503u, 0x0004003du, 0x00000006u, 0x00000504u, 0x000004e0u, 0x0004003du, + 0x00000006u, 0x00000505u, 0x000004e4u, 0x00050080u, 0x00000006u, 0x00000506u, 0x00000504u, 0x00000505u, + 0x0004003du, 0x0000000cu, 0x00000507u, 0x000004fcu, 0x00060041u, 0x0000043au, 0x00000508u, 0x00000437u, + 0x00000506u, 0x00000036u, 0x0003003eu, 0x00000508u, 0x00000507u, 0x000200f9u, 0x000004e8u, 0x000200f8u, + 0x000004e8u, 0x0004003du, 0x00000006u, 0x00000509u, 0x000004e4u, 0x00050080u, 0x00000006u, 0x0000050au, + 0x00000509u, 0x00000104u, 0x0003003eu, 0x000004e4u, 0x0000050au, 0x000200f9u, 0x000004e5u, 0x000200f8u, + 0x000004e7u, 0x000200f9u, 0x000004a7u, 0x000200f8u, 0x000004a7u, 0x000400e0u, 0x00000044u, 0x00000044u, + 0x0000043cu, 0x0004003du, 0x00000006u, 0x0000050bu, 0x00000362u, 0x0004003du, 0x00000006u, 0x0000050cu, + 0x0000048eu, 0x000500b0u, 0x0000004cu, 0x0000050du, 0x0000050bu, 0x0000050cu, 0x000300f7u, 0x0000050fu, + 0x00000000u, 0x000400fau, 0x0000050du, 0x0000050eu, 0x0000050fu, 0x000200f8u, 0x0000050eu, 0x0004003du, + 0x00000006u, 0x00000511u, 0x00000362u, 0x0004003du, 0x00000006u, 0x00000512u, 0x0000047du, 0x00050084u, + 0x00000006u, 0x00000513u, 0x00000511u, 0x00000512u, 0x0003003eu, 0x00000510u, 0x00000513u, 0x0004003du, + 0x00000006u, 0x00000515u, 0x00000362u, 0x0004003du, 0x00000006u, 0x00000516u, 0x00000480u, 0x00050084u, + 0x00000006u, 0x00000517u, 0x00000515u, 0x00000516u, 0x0003003eu, 0x00000514u, 0x00000517u, 0x0003003eu, + 0x00000518u, 0x00000065u, 0x000200f9u, 0x00000519u, 0x000200f8u, 0x00000519u, 0x000400f6u, 0x0000051bu, + 0x0000051cu, 0x00000000u, 0x000200f9u, 0x0000051du, 0x000200f8u, 0x0000051du, 0x0004003du, 0x00000006u, + 0x0000051eu, 0x00000518u, 0x0004003du, 0x00000006u, 0x0000051fu, 0x00000480u, 0x000500b0u, 0x0000004cu, + 0x00000520u, 0x0000051eu, 0x0000051fu, 0x000400fau, 0x00000520u, 0x0000051au, 0x0000051bu, 0x000200f8u, + 0x0000051au, 0x0004003du, 0x00000006u, 0x00000523u, 0x00000518u, 0x0003003eu, 0x00000522u, 0x00000523u, + 0x0003003eu, 0x00000524u, 0x00000008u, 0x00060039u, 0x0000002eu, 0x00000525u, 0x00000032u, 0x00000522u, + 0x00000524u, 0x0003003eu, 0x00000521u, 0x00000525u, 0x0004003du, 0x00000006u, 0x00000527u, 0x00000514u, + 0x0004003du, 0x00000006u, 0x00000528u, 0x00000518u, 0x00050080u, 0x00000006u, 0x00000529u, 0x00000527u, + 0x00000528u, 0x00050084u, 0x00000006u, 0x0000052au, 0x00000529u, 0x0000013eu, 0x0003003eu, 0x00000526u, + 0x0000052au, 0x0004003du, 0x00000006u, 0x0000052bu, 0x00000526u, 0x00050086u, 0x00000006u, 0x0000052cu, + 0x0000052bu, 0x0000013eu, 0x0004003du, 0x00000006u, 0x0000052du, 0x00000510u, 0x00050041u, 0x00000018u, + 0x0000052eu, 0x00000521u, 0x00000065u, 0x0004003du, 0x00000006u, 0x0000052fu, 0x0000052eu, 0x00050080u, + 0x00000006u, 0x00000530u, 0x0000052du, 0x0000052fu, 0x0004003du, 0x00000006u, 0x00000531u, 0x00000510u, + 0x00050041u, 0x00000018u, 0x00000532u, 0x00000521u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000533u, + 0x00000532u, 0x00050080u, 0x00000006u, 0x00000534u, 0x00000531u, 0x00000533u, 0x0004003du, 0x00000006u, + 0x00000535u, 0x00000510u, 0x00050041u, 0x00000018u, 0x00000536u, 0x00000521u, 0x00000044u, 0x0004003du, + 0x00000006u, 0x00000537u, 0x00000536u, 0x00050080u, 0x00000006u, 0x00000538u, 0x00000535u, 0x00000537u, + 0x00060050u, 0x0000002eu, 0x00000539u, 0x00000530u, 0x00000534u, 0x00000538u, 0x00050041u, 0x0000045cu, + 0x0000053au, 0x00000452u, 0x0000052cu, 0x0003003eu, 0x0000053au, 0x00000539u, 0x0004003du, 0x00000006u, + 0x0000053bu, 0x00000514u, 0x0004003du, 0x00000006u, 0x0000053cu, 0x00000518u, 0x00050080u, 0x00000006u, + 0x0000053du, 0x0000053bu, 0x0000053cu, 0x00050041u, 0x0000035fu, 0x0000053eu, 0x0000035eu, 0x00000036u, + 0x0004003du, 0x00000006u, 0x0000053fu, 0x0000053eu, 0x0004007cu, 0x00000035u, 0x00000540u, 0x0000053fu, + 0x00060041u, 0x00000466u, 0x00000541u, 0x00000461u, 0x0000053du, 0x00000036u, 0x0003003eu, 0x00000541u, + 0x00000540u, 0x0004003du, 0x00000006u, 0x00000542u, 0x00000514u, 0x0004003du, 0x00000006u, 0x00000543u, + 0x00000518u, 0x00050080u, 0x00000006u, 0x00000544u, 0x00000542u, 0x00000543u, 0x00050041u, 0x0000046du, + 0x00000545u, 0x0000035eu, 0x000000a9u, 0x0004003du, 0x0000000au, 0x00000546u, 0x00000545u, 0x00060041u, + 0x00000470u, 0x00000547u, 0x0000046bu, 0x00000544u, 0x00000036u, 0x0003003eu, 0x00000547u, 0x00000546u, + 0x0004003du, 0x00000006u, 0x00000548u, 0x00000514u, 0x0004003du, 0x00000006u, 0x00000549u, 0x00000518u, + 0x00050080u, 0x00000006u, 0x0000054au, 0x00000548u, 0x00000549u, 0x00050041u, 0x00000473u, 0x0000054bu, + 0x0000035eu, 0x000000afu, 0x0004003du, 0x00000009u, 0x0000054cu, 0x0000054bu, 0x00060041u, 0x00000476u, + 0x0000054du, 0x0000046bu, 0x0000054au, 0x00000104u, 0x0003003eu, 0x0000054du, 0x0000054cu, 0x000200f9u, + 0x0000051cu, 0x000200f8u, 0x0000051cu, 0x0004003du, 0x00000006u, 0x0000054eu, 0x00000518u, 0x00050080u, + 0x00000006u, 0x0000054fu, 0x0000054eu, 0x00000104u, 0x0003003eu, 0x00000518u, 0x0000054fu, 0x000200f9u, + 0x00000519u, 0x000200f8u, 0x0000051bu, 0x000200f9u, 0x0000050fu, 0x000200f8u, 0x0000050fu, 0x000200f9u, + 0x0000047cu, 0x000200f8u, 0x00000550u, 0x0004003du, 0x00000006u, 0x00000551u, 0x0000035bu, 0x000500aau, + 0x0000004cu, 0x00000552u, 0x00000551u, 0x00000044u, 0x000300f7u, 0x00000554u, 0x00000000u, 0x000400fau, + 0x00000552u, 0x00000553u, 0x00000608u, 0x000200f8u, 0x00000553u, 0x0004003du, 0x00000006u, 0x00000556u, + 0x00000355u, 0x00050084u, 0x00000006u, 0x00000557u, 0x00000556u, 0x00000044u, 0x0003003eu, 0x00000555u, + 0x00000557u, 0x0004003du, 0x00000006u, 0x00000559u, 0x00000555u, 0x00050080u, 0x00000006u, 0x0000055au, + 0x00000559u, 0x00000044u, 0x0004003du, 0x00000006u, 0x0000055bu, 0x000003d2u, 0x0007000cu, 0x00000006u, + 0x0000055cu, 0x00000001u, 0x00000026u, 0x0000055au, 0x0000055bu, 0x0003003eu, 0x00000558u, 0x0000055cu, + 0x0004003du, 0x00000006u, 0x0000055eu, 0x00000558u, 0x0004003du, 0x00000006u, 0x0000055fu, 0x00000555u, + 0x00050082u, 0x00000006u, 0x00000560u, 0x0000055eu, 0x0000055fu, 0x0003003eu, 0x0000055du, 0x00000560u, + 0x0004003du, 0x00000006u, 0x00000561u, 0x0000055du, 0x000500aau, 0x0000004cu, 0x00000562u, 0x00000561u, + 0x00000065u, 0x000300f7u, 0x00000564u, 0x00000000u, 0x000400fau, 0x00000562u, 0x00000563u, 0x00000564u, + 0x000200f8u, 0x00000563u, 0x0003003eu, 0x00000354u, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000565u, + 0x00000354u, 0x000314afu, 0x00000065u, 0x00000565u, 0x000100fdu, 0x000200f8u, 0x00000564u, 0x0004003du, + 0x00000006u, 0x00000568u, 0x0000055du, 0x00050084u, 0x00000006u, 0x00000569u, 0x00000568u, 0x0000014au, + 0x0003003eu, 0x00000567u, 0x00000569u, 0x0004003du, 0x00000006u, 0x0000056au, 0x0000055du, 0x00050084u, + 0x00000006u, 0x0000056bu, 0x0000056au, 0x0000015eu, 0x0003003eu, 0x00000354u, 0x0000056bu, 0x0004003du, + 0x00000006u, 0x0000056cu, 0x00000567u, 0x0004003du, 0x00000006u, 0x0000056du, 0x00000354u, 0x000314afu, + 0x0000056cu, 0x0000056du, 0x0004003du, 0x00000006u, 0x0000056fu, 0x00000362u, 0x00050086u, 0x00000006u, + 0x00000570u, 0x0000056fu, 0x0000015eu, 0x0003003eu, 0x0000056eu, 0x00000570u, 0x0004003du, 0x00000006u, + 0x00000572u, 0x00000362u, 0x00050089u, 0x00000006u, 0x00000573u, 0x00000572u, 0x0000015eu, 0x0003003eu, + 0x00000571u, 0x00000573u, 0x0004003du, 0x00000006u, 0x00000574u, 0x0000056eu, 0x0004003du, 0x00000006u, + 0x00000575u, 0x0000055du, 0x000500b0u, 0x0000004cu, 0x00000576u, 0x00000574u, 0x00000575u, 0x0004003du, + 0x00000006u, 0x00000577u, 0x00000571u, 0x000500b0u, 0x0000004cu, 0x00000578u, 0x00000577u, 0x0000014au, + 0x000500a7u, 0x0000004cu, 0x00000579u, 0x00000576u, 0x00000578u, 0x000300f7u, 0x0000057bu, 0x00000000u, + 0x000400fau, 0x00000579u, 0x0000057au, 0x0000057bu, 0x000200f8u, 0x0000057au, 0x0004003du, 0x00000006u, + 0x0000057du, 0x000003f0u, 0x0004003du, 0x00000006u, 0x0000057eu, 0x00000555u, 0x00050080u, 0x00000006u, + 0x0000057fu, 0x0000057du, 0x0000057eu, 0x0004003du, 0x00000006u, 0x00000580u, 0x0000056eu, 0x00050080u, + 0x00000006u, 0x00000581u, 0x0000057fu, 0x00000580u, 0x00060041u, 0x0000044au, 0x00000582u, 0x00000446u, + 0x00000036u, 0x00000581u, 0x0004003du, 0x0000002eu, 0x00000583u, 0x00000582u, 0x0003003eu, 0x0000057cu, + 0x00000583u, 0x0004003du, 0x00000006u, 0x00000585u, 0x000003e8u, 0x00050041u, 0x00000018u, 0x00000586u, + 0x0000057cu, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000587u, 0x00000586u, 0x00050080u, 0x00000006u, + 0x00000588u, 0x00000585u, 0x00000587u, 0x00060041u, 0x0000041fu, 0x00000589u, 0x0000041bu, 0x00000036u, + 0x00000588u, 0x0004003du, 0x00000417u, 0x0000058au, 0x00000589u, 0x00040190u, 0x00000414u, 0x0000058bu, + 0x0000058au, 0x0003003eu, 0x00000584u, 0x0000058bu, 0x0004003du, 0x00000006u, 0x0000058du, 0x000003e8u, + 0x00050041u, 0x00000018u, 0x0000058eu, 0x0000057cu, 0x00000008u, 0x0004003du, 0x00000006u, 0x0000058fu, + 0x0000058eu, 0x00050080u, 0x00000006u, 0x00000590u, 0x0000058du, 0x0000058fu, 0x00060041u, 0x0000041fu, + 0x00000591u, 0x0000041bu, 0x00000036u, 0x00000590u, 0x0004003du, 0x00000417u, 0x00000592u, 0x00000591u, + 0x00040190u, 0x00000414u, 0x00000593u, 0x00000592u, 0x0003003eu, 0x0000058cu, 0x00000593u, 0x0004003du, + 0x00000006u, 0x00000595u, 0x000003e8u, 0x00050041u, 0x00000018u, 0x00000596u, 0x0000057cu, 0x00000044u, + 0x0004003du, 0x00000006u, 0x00000597u, 0x00000596u, 0x00050080u, 0x00000006u, 0x00000598u, 0x00000595u, + 0x00000597u, 0x00060041u, 0x0000041fu, 0x00000599u, 0x0000041bu, 0x00000036u, 0x00000598u, 0x0004003du, + 0x00000417u, 0x0000059au, 0x00000599u, 0x00040190u, 0x00000414u, 0x0000059bu, 0x0000059au, 0x0003003eu, + 0x00000594u, 0x0000059bu, 0x00050041u, 0x00000042u, 0x0000059du, 0x00000584u, 0x00000036u, 0x0004003du, + 0x00000009u, 0x0000059eu, 0x0000059du, 0x00050041u, 0x00000042u, 0x0000059fu, 0x00000584u, 0x00000104u, + 0x0004003du, 0x00000009u, 0x000005a0u, 0x0000059fu, 0x00050041u, 0x00000042u, 0x000005a1u, 0x00000584u, + 0x0000006au, 0x0004003du, 0x00000009u, 0x000005a2u, 0x000005a1u, 0x00060050u, 0x0000000au, 0x000005a3u, + 0x0000059eu, 0x000005a0u, 0x000005a2u, 0x0003003eu, 0x0000059cu, 0x000005a3u, 0x00050041u, 0x00000042u, + 0x000005a5u, 0x0000058cu, 0x00000036u, 0x0004003du, 0x00000009u, 0x000005a6u, 0x000005a5u, 0x00050041u, + 0x00000042u, 0x000005a7u, 0x0000058cu, 0x00000104u, 0x0004003du, 0x00000009u, 0x000005a8u, 0x000005a7u, + 0x00050041u, 0x00000042u, 0x000005a9u, 0x0000058cu, 0x0000006au, 0x0004003du, 0x00000009u, 0x000005aau, + 0x000005a9u, 0x00060050u, 0x0000000au, 0x000005abu, 0x000005a6u, 0x000005a8u, 0x000005aau, 0x0003003eu, + 0x000005a4u, 0x000005abu, 0x00050041u, 0x00000042u, 0x000005adu, 0x00000594u, 0x00000036u, 0x0004003du, + 0x00000009u, 0x000005aeu, 0x000005adu, 0x00050041u, 0x00000042u, 0x000005afu, 0x00000594u, 0x00000104u, + 0x0004003du, 0x00000009u, 0x000005b0u, 0x000005afu, 0x00050041u, 0x00000042u, 0x000005b1u, 0x00000594u, + 0x0000006au, 0x0004003du, 0x00000009u, 0x000005b2u, 0x000005b1u, 0x00060050u, 0x0000000au, 0x000005b3u, + 0x000005aeu, 0x000005b0u, 0x000005b2u, 0x0003003eu, 0x000005acu, 0x000005b3u, 0x0004003du, 0x00000006u, + 0x000005b6u, 0x00000571u, 0x0003003eu, 0x000005b5u, 0x000005b6u, 0x0003003eu, 0x000005b7u, 0x00000044u, + 0x00060039u, 0x00000020u, 0x000005b8u, 0x00000024u, 0x000005b5u, 0x000005b7u, 0x0003003eu, 0x000005b4u, + 0x000005b8u, 0x0004003du, 0x0000000au, 0x000005bbu, 0x0000059cu, 0x0003003eu, 0x000005bau, 0x000005bbu, + 0x0004003du, 0x0000000au, 0x000005bdu, 0x000005a4u, 0x0003003eu, 0x000005bcu, 0x000005bdu, 0x0004003du, + 0x0000000au, 0x000005bfu, 0x000005acu, 0x0003003eu, 0x000005beu, 0x000005bfu, 0x0004003du, 0x00000020u, + 0x000005c1u, 0x000005b4u, 0x0003003eu, 0x000005c0u, 0x000005c1u, 0x00080039u, 0x0000000au, 0x000005c2u, + 0x0000002cu, 0x000005bau, 0x000005bcu, 0x000005beu, 0x000005c0u, 0x0003003eu, 0x000005b9u, 0x000005c2u, + 0x0004003du, 0x0000000au, 0x000005c5u, 0x000005b9u, 0x0003003eu, 0x000005c4u, 0x000005c5u, 0x0004003du, + 0x0000000eu, 0x000005c7u, 0x000003a3u, 0x0003003eu, 0x000005c6u, 0x000005c7u, 0x0004003du, 0x00000010u, + 0x000005c9u, 0x00000397u, 0x0003003eu, 0x000005c8u, 0x000005c9u, 0x00070039u, 0x0000000cu, 0x000005cau, + 0x00000016u, 0x000005c4u, 0x000005c6u, 0x000005c8u, 0x0003003eu, 0x000005c3u, 0x000005cau, 0x0004003du, + 0x00000006u, 0x000005ccu, 0x0000056eu, 0x00050084u, 0x00000006u, 0x000005cdu, 0x000005ccu, 0x0000014au, + 0x0004003du, 0x00000006u, 0x000005ceu, 0x00000571u, 0x00050080u, 0x00000006u, 0x000005cfu, 0x000005cdu, + 0x000005ceu, 0x0003003eu, 0x000005cbu, 0x000005cfu, 0x0004003du, 0x00000006u, 0x000005d0u, 0x000005cbu, + 0x0004003du, 0x0000000cu, 0x000005d1u, 0x000005c3u, 0x00060041u, 0x0000043au, 0x000005d2u, 0x00000437u, + 0x000005d0u, 0x00000036u, 0x0003003eu, 0x000005d2u, 0x000005d1u, 0x000200f9u, 0x0000057bu, 0x000200f8u, + 0x0000057bu, 0x000400e0u, 0x00000044u, 0x00000044u, 0x0000043cu, 0x0004003du, 0x00000006u, 0x000005d3u, + 0x0000056eu, 0x0004003du, 0x00000006u, 0x000005d4u, 0x0000055du, 0x000500b0u, 0x0000004cu, 0x000005d5u, + 0x000005d3u, 0x000005d4u, 0x0004003du, 0x00000006u, 0x000005d6u, 0x00000571u, 0x000500b0u, 0x0000004cu, + 0x000005d7u, 0x000005d6u, 0x0000015eu, 0x000500a7u, 0x0000004cu, 0x000005d8u, 0x000005d5u, 0x000005d7u, + 0x000300f7u, 0x000005dau, 0x00000000u, 0x000400fau, 0x000005d8u, 0x000005d9u, 0x000005dau, 0x000200f8u, + 0x000005d9u, 0x0004003du, 0x00000006u, 0x000005dcu, 0x0000056eu, 0x00050084u, 0x00000006u, 0x000005ddu, + 0x000005dcu, 0x0000014au, 0x0003003eu, 0x000005dbu, 0x000005ddu, 0x0004003du, 0x00000006u, 0x000005dfu, + 0x0000056eu, 0x00050084u, 0x00000006u, 0x000005e0u, 0x000005dfu, 0x0000015eu, 0x0004003du, 0x00000006u, + 0x000005e1u, 0x00000571u, 0x00050080u, 0x00000006u, 0x000005e2u, 0x000005e0u, 0x000005e1u, 0x0003003eu, + 0x000005deu, 0x000005e2u, 0x0004003du, 0x00000006u, 0x000005e5u, 0x00000571u, 0x0003003eu, 0x000005e4u, + 0x000005e5u, 0x0003003eu, 0x000005e6u, 0x00000044u, 0x00060039u, 0x0000002eu, 0x000005e7u, 0x00000032u, + 0x000005e4u, 0x000005e6u, 0x0003003eu, 0x000005e3u, 0x000005e7u, 0x0004003du, 0x00000006u, 0x000005e9u, + 0x000005deu, 0x00050084u, 0x00000006u, 0x000005eau, 0x000005e9u, 0x0000013eu, 0x0003003eu, 0x000005e8u, + 0x000005eau, 0x0004003du, 0x00000006u, 0x000005ebu, 0x000005e8u, 0x00050086u, 0x00000006u, 0x000005ecu, + 0x000005ebu, 0x0000013eu, 0x0004003du, 0x00000006u, 0x000005edu, 0x000005dbu, 0x00050041u, 0x00000018u, + 0x000005eeu, 0x000005e3u, 0x00000065u, 0x0004003du, 0x00000006u, 0x000005efu, 0x000005eeu, 0x00050080u, + 0x00000006u, 0x000005f0u, 0x000005edu, 0x000005efu, 0x0004003du, 0x00000006u, 0x000005f1u, 0x000005dbu, + 0x00050041u, 0x00000018u, 0x000005f2u, 0x000005e3u, 0x00000008u, 0x0004003du, 0x00000006u, 0x000005f3u, + 0x000005f2u, 0x00050080u, 0x00000006u, 0x000005f4u, 0x000005f1u, 0x000005f3u, 0x0004003du, 0x00000006u, + 0x000005f5u, 0x000005dbu, 0x00050041u, 0x00000018u, 0x000005f6u, 0x000005e3u, 0x00000044u, 0x0004003du, + 0x00000006u, 0x000005f7u, 0x000005f6u, 0x00050080u, 0x00000006u, 0x000005f8u, 0x000005f5u, 0x000005f7u, + 0x00060050u, 0x0000002eu, 0x000005f9u, 0x000005f0u, 0x000005f4u, 0x000005f8u, 0x00050041u, 0x0000045cu, + 0x000005fau, 0x00000452u, 0x000005ecu, 0x0003003eu, 0x000005fau, 0x000005f9u, 0x0004003du, 0x00000006u, + 0x000005fbu, 0x000005deu, 0x00050041u, 0x0000035fu, 0x000005fcu, 0x0000035eu, 0x00000036u, 0x0004003du, + 0x00000006u, 0x000005fdu, 0x000005fcu, 0x0004007cu, 0x00000035u, 0x000005feu, 0x000005fdu, 0x00060041u, + 0x00000466u, 0x000005ffu, 0x00000461u, 0x000005fbu, 0x00000036u, 0x0003003eu, 0x000005ffu, 0x000005feu, + 0x0004003du, 0x00000006u, 0x00000600u, 0x000005deu, 0x00050041u, 0x0000046du, 0x00000601u, 0x0000035eu, + 0x000000a9u, 0x0004003du, 0x0000000au, 0x00000602u, 0x00000601u, 0x00060041u, 0x00000470u, 0x00000603u, + 0x0000046bu, 0x00000600u, 0x00000036u, 0x0003003eu, 0x00000603u, 0x00000602u, 0x0004003du, 0x00000006u, + 0x00000604u, 0x000005deu, 0x00050041u, 0x00000473u, 0x00000605u, 0x0000035eu, 0x000000afu, 0x0004003du, + 0x00000009u, 0x00000606u, 0x00000605u, 0x00060041u, 0x00000476u, 0x00000607u, 0x0000046bu, 0x00000604u, + 0x00000104u, 0x0003003eu, 0x00000607u, 0x00000606u, 0x000200f9u, 0x000005dau, 0x000200f8u, 0x000005dau, + 0x000200f9u, 0x00000554u, 0x000200f8u, 0x00000608u, 0x0004003du, 0x00000006u, 0x00000609u, 0x0000035bu, + 0x000500aau, 0x0000004cu, 0x0000060au, 0x00000609u, 0x0000013eu, 0x000300f7u, 0x0000060cu, 0x00000000u, + 0x000400fau, 0x0000060au, 0x0000060bu, 0x0000069du, 0x000200f8u, 0x0000060bu, 0x0004003du, 0x00000006u, + 0x0000060eu, 0x00000355u, 0x00050084u, 0x00000006u, 0x0000060fu, 0x0000060eu, 0x00000008u, 0x0003003eu, + 0x0000060du, 0x0000060fu, 0x0004003du, 0x00000006u, 0x00000610u, 0x0000060du, 0x0004003du, 0x00000006u, + 0x00000611u, 0x000003d2u, 0x000500aeu, 0x0000004cu, 0x00000612u, 0x00000610u, 0x00000611u, 0x000300f7u, + 0x00000614u, 0x00000000u, 0x000400fau, 0x00000612u, 0x00000613u, 0x00000614u, 0x000200f8u, 0x00000613u, + 0x0003003eu, 0x00000354u, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000615u, 0x00000354u, 0x000314afu, + 0x00000065u, 0x00000615u, 0x000100fdu, 0x000200f8u, 0x00000614u, 0x0003003eu, 0x00000354u, 0x00000160u, + 0x0004003du, 0x00000006u, 0x00000617u, 0x00000354u, 0x000314afu, 0x0000014cu, 0x00000617u, 0x0004003du, + 0x00000006u, 0x00000619u, 0x000003f0u, 0x0004003du, 0x00000006u, 0x0000061au, 0x0000060du, 0x00050080u, + 0x00000006u, 0x0000061bu, 0x00000619u, 0x0000061au, 0x00060041u, 0x0000044au, 0x0000061cu, 0x00000446u, + 0x00000036u, 0x0000061bu, 0x0004003du, 0x0000002eu, 0x0000061du, 0x0000061cu, 0x0003003eu, 0x00000618u, + 0x0000061du, 0x0004003du, 0x00000006u, 0x0000061fu, 0x000003e8u, 0x00050041u, 0x00000018u, 0x00000620u, + 0x00000618u, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000621u, 0x00000620u, 0x00050080u, 0x00000006u, + 0x00000622u, 0x0000061fu, 0x00000621u, 0x00060041u, 0x0000041fu, 0x00000623u, 0x0000041bu, 0x00000036u, + 0x00000622u, 0x0004003du, 0x00000417u, 0x00000624u, 0x00000623u, 0x00040190u, 0x00000414u, 0x00000625u, + 0x00000624u, 0x0003003eu, 0x0000061eu, 0x00000625u, 0x0004003du, 0x00000006u, 0x00000627u, 0x000003e8u, + 0x00050041u, 0x00000018u, 0x00000628u, 0x00000618u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000629u, + 0x00000628u, 0x00050080u, 0x00000006u, 0x0000062au, 0x00000627u, 0x00000629u, 0x00060041u, 0x0000041fu, + 0x0000062bu, 0x0000041bu, 0x00000036u, 0x0000062au, 0x0004003du, 0x00000417u, 0x0000062cu, 0x0000062bu, + 0x00040190u, 0x00000414u, 0x0000062du, 0x0000062cu, 0x0003003eu, 0x00000626u, 0x0000062du, 0x0004003du, + 0x00000006u, 0x0000062fu, 0x000003e8u, 0x00050041u, 0x00000018u, 0x00000630u, 0x00000618u, 0x00000044u, + 0x0004003du, 0x00000006u, 0x00000631u, 0x00000630u, 0x00050080u, 0x00000006u, 0x00000632u, 0x0000062fu, + 0x00000631u, 0x00060041u, 0x0000041fu, 0x00000633u, 0x0000041bu, 0x00000036u, 0x00000632u, 0x0004003du, + 0x00000417u, 0x00000634u, 0x00000633u, 0x00040190u, 0x00000414u, 0x00000635u, 0x00000634u, 0x0003003eu, + 0x0000062eu, 0x00000635u, 0x00050041u, 0x00000042u, 0x00000637u, 0x0000061eu, 0x00000036u, 0x0004003du, + 0x00000009u, 0x00000638u, 0x00000637u, 0x00050041u, 0x00000042u, 0x00000639u, 0x0000061eu, 0x00000104u, + 0x0004003du, 0x00000009u, 0x0000063au, 0x00000639u, 0x00050041u, 0x00000042u, 0x0000063bu, 0x0000061eu, + 0x0000006au, 0x0004003du, 0x00000009u, 0x0000063cu, 0x0000063bu, 0x00060050u, 0x0000000au, 0x0000063du, + 0x00000638u, 0x0000063au, 0x0000063cu, 0x0003003eu, 0x00000636u, 0x0000063du, 0x00050041u, 0x00000042u, + 0x0000063fu, 0x00000626u, 0x00000036u, 0x0004003du, 0x00000009u, 0x00000640u, 0x0000063fu, 0x00050041u, + 0x00000042u, 0x00000641u, 0x00000626u, 0x00000104u, 0x0004003du, 0x00000009u, 0x00000642u, 0x00000641u, + 0x00050041u, 0x00000042u, 0x00000643u, 0x00000626u, 0x0000006au, 0x0004003du, 0x00000009u, 0x00000644u, + 0x00000643u, 0x00060050u, 0x0000000au, 0x00000645u, 0x00000640u, 0x00000642u, 0x00000644u, 0x0003003eu, + 0x0000063eu, 0x00000645u, 0x00050041u, 0x00000042u, 0x00000647u, 0x0000062eu, 0x00000036u, 0x0004003du, + 0x00000009u, 0x00000648u, 0x00000647u, 0x00050041u, 0x00000042u, 0x00000649u, 0x0000062eu, 0x00000104u, + 0x0004003du, 0x00000009u, 0x0000064au, 0x00000649u, 0x00050041u, 0x00000042u, 0x0000064bu, 0x0000062eu, + 0x0000006au, 0x0004003du, 0x00000009u, 0x0000064cu, 0x0000064bu, 0x00060050u, 0x0000000au, 0x0000064du, + 0x00000648u, 0x0000064au, 0x0000064cu, 0x0003003eu, 0x00000646u, 0x0000064du, 0x0004003du, 0x00000006u, + 0x0000064fu, 0x00000362u, 0x0003003eu, 0x0000064eu, 0x0000064fu, 0x000200f9u, 0x00000650u, 0x000200f8u, + 0x00000650u, 0x000400f6u, 0x00000652u, 0x00000653u, 0x00000000u, 0x000200f9u, 0x00000654u, 0x000200f8u, + 0x00000654u, 0x0004003du, 0x00000006u, 0x00000655u, 0x0000064eu, 0x000500b0u, 0x0000004cu, 0x00000656u, + 0x00000655u, 0x0000014cu, 0x000400fau, 0x00000656u, 0x00000651u, 0x00000652u, 0x000200f8u, 0x00000651u, + 0x0004003du, 0x00000006u, 0x00000659u, 0x0000064eu, 0x0003003eu, 0x00000658u, 0x00000659u, 0x0003003eu, + 0x0000065au, 0x0000013eu, 0x00060039u, 0x00000020u, 0x0000065bu, 0x00000024u, 0x00000658u, 0x0000065au, + 0x0003003eu, 0x00000657u, 0x0000065bu, 0x0004003du, 0x0000000au, 0x0000065eu, 0x00000636u, 0x0003003eu, + 0x0000065du, 0x0000065eu, 0x0004003du, 0x0000000au, 0x00000660u, 0x0000063eu, 0x0003003eu, 0x0000065fu, + 0x00000660u, 0x0004003du, 0x0000000au, 0x00000662u, 0x00000646u, 0x0003003eu, 0x00000661u, 0x00000662u, + 0x0004003du, 0x00000020u, 0x00000664u, 0x00000657u, 0x0003003eu, 0x00000663u, 0x00000664u, 0x00080039u, + 0x0000000au, 0x00000665u, 0x0000002cu, 0x0000065du, 0x0000065fu, 0x00000661u, 0x00000663u, 0x0003003eu, + 0x0000065cu, 0x00000665u, 0x0004003du, 0x0000000au, 0x00000668u, 0x0000065cu, 0x0003003eu, 0x00000667u, + 0x00000668u, 0x0004003du, 0x0000000eu, 0x0000066au, 0x000003a3u, 0x0003003eu, 0x00000669u, 0x0000066au, + 0x0004003du, 0x00000010u, 0x0000066cu, 0x00000397u, 0x0003003eu, 0x0000066bu, 0x0000066cu, 0x00070039u, + 0x0000000cu, 0x0000066du, 0x00000016u, 0x00000667u, 0x00000669u, 0x0000066bu, 0x0003003eu, 0x00000666u, + 0x0000066du, 0x0004003du, 0x00000006u, 0x0000066eu, 0x0000064eu, 0x0004003du, 0x0000000cu, 0x0000066fu, + 0x00000666u, 0x00060041u, 0x0000043au, 0x00000670u, 0x00000437u, 0x0000066eu, 0x00000036u, 0x0003003eu, + 0x00000670u, 0x0000066fu, 0x000200f9u, 0x00000653u, 0x000200f8u, 0x00000653u, 0x0004003du, 0x00000006u, + 0x00000671u, 0x0000064eu, 0x00050080u, 0x00000006u, 0x00000672u, 0x00000671u, 0x00000007u, 0x0003003eu, + 0x0000064eu, 0x00000672u, 0x000200f9u, 0x00000650u, 0x000200f8u, 0x00000652u, 0x000400e0u, 0x00000044u, + 0x00000044u, 0x0000043cu, 0x0004003du, 0x00000006u, 0x00000674u, 0x00000362u, 0x0003003eu, 0x00000673u, + 0x00000674u, 0x000200f9u, 0x00000675u, 0x000200f8u, 0x00000675u, 0x000400f6u, 0x00000677u, 0x00000678u, + 0x00000000u, 0x000200f9u, 0x00000679u, 0x000200f8u, 0x00000679u, 0x0004003du, 0x00000006u, 0x0000067au, + 0x00000673u, 0x000500b0u, 0x0000004cu, 0x0000067bu, 0x0000067au, 0x00000160u, 0x000400fau, 0x0000067bu, + 0x00000676u, 0x00000677u, 0x000200f8u, 0x00000676u, 0x0004003du, 0x00000006u, 0x0000067eu, 0x00000673u, + 0x0003003eu, 0x0000067du, 0x0000067eu, 0x0003003eu, 0x0000067fu, 0x0000013eu, 0x00060039u, 0x0000002eu, + 0x00000680u, 0x00000032u, 0x0000067du, 0x0000067fu, 0x0003003eu, 0x0000067cu, 0x00000680u, 0x0004003du, + 0x00000006u, 0x00000682u, 0x00000673u, 0x00050084u, 0x00000006u, 0x00000683u, 0x00000682u, 0x0000013eu, + 0x0003003eu, 0x00000681u, 0x00000683u, 0x0004003du, 0x00000006u, 0x00000684u, 0x00000681u, 0x00050086u, + 0x00000006u, 0x00000685u, 0x00000684u, 0x0000013eu, 0x00050041u, 0x00000018u, 0x00000686u, 0x0000067cu, + 0x00000065u, 0x0004003du, 0x00000006u, 0x00000687u, 0x00000686u, 0x00050041u, 0x00000018u, 0x00000688u, + 0x0000067cu, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000689u, 0x00000688u, 0x00050041u, 0x00000018u, + 0x0000068au, 0x0000067cu, 0x00000044u, 0x0004003du, 0x00000006u, 0x0000068bu, 0x0000068au, 0x00060050u, + 0x0000002eu, 0x0000068cu, 0x00000687u, 0x00000689u, 0x0000068bu, 0x00050041u, 0x0000045cu, 0x0000068du, + 0x00000452u, 0x00000685u, 0x0003003eu, 0x0000068du, 0x0000068cu, 0x0004003du, 0x00000006u, 0x0000068eu, + 0x00000673u, 0x00050041u, 0x0000035fu, 0x0000068fu, 0x0000035eu, 0x00000036u, 0x0004003du, 0x00000006u, + 0x00000690u, 0x0000068fu, 0x0004007cu, 0x00000035u, 0x00000691u, 0x00000690u, 0x00060041u, 0x00000466u, + 0x00000692u, 0x00000461u, 0x0000068eu, 0x00000036u, 0x0003003eu, 0x00000692u, 0x00000691u, 0x0004003du, + 0x00000006u, 0x00000693u, 0x00000673u, 0x00050041u, 0x0000046du, 0x00000694u, 0x0000035eu, 0x000000a9u, + 0x0004003du, 0x0000000au, 0x00000695u, 0x00000694u, 0x00060041u, 0x00000470u, 0x00000696u, 0x0000046bu, + 0x00000693u, 0x00000036u, 0x0003003eu, 0x00000696u, 0x00000695u, 0x0004003du, 0x00000006u, 0x00000697u, + 0x00000673u, 0x00050041u, 0x00000473u, 0x00000698u, 0x0000035eu, 0x000000afu, 0x0004003du, 0x00000009u, + 0x00000699u, 0x00000698u, 0x00060041u, 0x00000476u, 0x0000069au, 0x0000046bu, 0x00000697u, 0x00000104u, + 0x0003003eu, 0x0000069au, 0x00000699u, 0x000200f9u, 0x00000678u, 0x000200f8u, 0x00000678u, 0x0004003du, + 0x00000006u, 0x0000069bu, 0x00000673u, 0x00050080u, 0x00000006u, 0x0000069cu, 0x0000069bu, 0x00000007u, + 0x0003003eu, 0x00000673u, 0x0000069cu, 0x000200f9u, 0x00000675u, 0x000200f8u, 0x00000677u, 0x000200f9u, + 0x0000060cu, 0x000200f8u, 0x0000069du, 0x0004003du, 0x00000006u, 0x0000069fu, 0x00000355u, 0x00050084u, + 0x00000006u, 0x000006a0u, 0x0000069fu, 0x000001fbu, 0x0003003eu, 0x0000069eu, 0x000006a0u, 0x0004003du, + 0x00000006u, 0x000006a2u, 0x0000069eu, 0x00050080u, 0x00000006u, 0x000006a3u, 0x000006a2u, 0x000001fbu, + 0x0004003du, 0x00000006u, 0x000006a4u, 0x000003d2u, 0x0007000cu, 0x00000006u, 0x000006a5u, 0x00000001u, + 0x00000026u, 0x000006a3u, 0x000006a4u, 0x0003003eu, 0x000006a1u, 0x000006a5u, 0x0004003du, 0x00000006u, + 0x000006a7u, 0x000006a1u, 0x0004003du, 0x00000006u, 0x000006a8u, 0x0000069eu, 0x00050082u, 0x00000006u, + 0x000006a9u, 0x000006a7u, 0x000006a8u, 0x0003003eu, 0x000006a6u, 0x000006a9u, 0x0004003du, 0x00000006u, + 0x000006aau, 0x000006a6u, 0x000500aau, 0x0000004cu, 0x000006abu, 0x000006aau, 0x00000065u, 0x000300f7u, + 0x000006adu, 0x00000000u, 0x000400fau, 0x000006abu, 0x000006acu, 0x000006adu, 0x000200f8u, 0x000006acu, + 0x0003003eu, 0x00000354u, 0x00000065u, 0x0004003du, 0x00000006u, 0x000006aeu, 0x00000354u, 0x000314afu, + 0x00000065u, 0x000006aeu, 0x000100fdu, 0x000200f8u, 0x000006adu, 0x0004003du, 0x00000006u, 0x000006b1u, + 0x000006a6u, 0x00050084u, 0x00000006u, 0x000006b2u, 0x000006b1u, 0x0000013eu, 0x0003003eu, 0x000006b0u, + 0x000006b2u, 0x0004003du, 0x00000006u, 0x000006b3u, 0x000006a6u, 0x0003003eu, 0x00000354u, 0x000006b3u, + 0x0004003du, 0x00000006u, 0x000006b4u, 0x000006b0u, 0x0004003du, 0x00000006u, 0x000006b5u, 0x00000354u, + 0x000314afu, 0x000006b4u, 0x000006b5u, 0x0004003du, 0x00000006u, 0x000006b6u, 0x00000362u, 0x0004003du, + 0x00000006u, 0x000006b7u, 0x000006a6u, 0x000500b0u, 0x0000004cu, 0x000006b8u, 0x000006b6u, 0x000006b7u, + 0x000300f7u, 0x000006bau, 0x00000000u, 0x000400fau, 0x000006b8u, 0x000006b9u, 0x000006bau, 0x000200f8u, + 0x000006b9u, 0x0004003du, 0x00000006u, 0x000006bcu, 0x000003f0u, 0x0004003du, 0x00000006u, 0x000006bdu, + 0x0000069eu, 0x00050080u, 0x00000006u, 0x000006beu, 0x000006bcu, 0x000006bdu, 0x0004003du, 0x00000006u, + 0x000006bfu, 0x00000362u, 0x00050080u, 0x00000006u, 0x000006c0u, 0x000006beu, 0x000006bfu, 0x00060041u, + 0x0000044au, 0x000006c1u, 0x00000446u, 0x00000036u, 0x000006c0u, 0x0004003du, 0x0000002eu, 0x000006c2u, + 0x000006c1u, 0x0003003eu, 0x000006bbu, 0x000006c2u, 0x0004003du, 0x00000006u, 0x000006c4u, 0x000003e8u, + 0x00050041u, 0x00000018u, 0x000006c5u, 0x000006bbu, 0x00000065u, 0x0004003du, 0x00000006u, 0x000006c6u, + 0x000006c5u, 0x00050080u, 0x00000006u, 0x000006c7u, 0x000006c4u, 0x000006c6u, 0x00060041u, 0x0000041fu, + 0x000006c8u, 0x0000041bu, 0x00000036u, 0x000006c7u, 0x0004003du, 0x00000417u, 0x000006c9u, 0x000006c8u, + 0x00040190u, 0x00000414u, 0x000006cau, 0x000006c9u, 0x0003003eu, 0x000006c3u, 0x000006cau, 0x0004003du, + 0x00000006u, 0x000006ccu, 0x000003e8u, 0x00050041u, 0x00000018u, 0x000006cdu, 0x000006bbu, 0x00000008u, + 0x0004003du, 0x00000006u, 0x000006ceu, 0x000006cdu, 0x00050080u, 0x00000006u, 0x000006cfu, 0x000006ccu, + 0x000006ceu, 0x00060041u, 0x0000041fu, 0x000006d0u, 0x0000041bu, 0x00000036u, 0x000006cfu, 0x0004003du, + 0x00000417u, 0x000006d1u, 0x000006d0u, 0x00040190u, 0x00000414u, 0x000006d2u, 0x000006d1u, 0x0003003eu, + 0x000006cbu, 0x000006d2u, 0x0004003du, 0x00000006u, 0x000006d4u, 0x000003e8u, 0x00050041u, 0x00000018u, + 0x000006d5u, 0x000006bbu, 0x00000044u, 0x0004003du, 0x00000006u, 0x000006d6u, 0x000006d5u, 0x00050080u, + 0x00000006u, 0x000006d7u, 0x000006d4u, 0x000006d6u, 0x00060041u, 0x0000041fu, 0x000006d8u, 0x0000041bu, + 0x00000036u, 0x000006d7u, 0x0004003du, 0x00000417u, 0x000006d9u, 0x000006d8u, 0x00040190u, 0x00000414u, + 0x000006dau, 0x000006d9u, 0x0003003eu, 0x000006d3u, 0x000006dau, 0x00050041u, 0x00000042u, 0x000006dcu, + 0x000006c3u, 0x00000036u, 0x0004003du, 0x00000009u, 0x000006ddu, 0x000006dcu, 0x00050041u, 0x00000042u, + 0x000006deu, 0x000006c3u, 0x00000104u, 0x0004003du, 0x00000009u, 0x000006dfu, 0x000006deu, 0x00050041u, + 0x00000042u, 0x000006e0u, 0x000006c3u, 0x0000006au, 0x0004003du, 0x00000009u, 0x000006e1u, 0x000006e0u, + 0x00060050u, 0x0000000au, 0x000006e2u, 0x000006ddu, 0x000006dfu, 0x000006e1u, 0x0003003eu, 0x000006dbu, + 0x000006e2u, 0x00050041u, 0x00000042u, 0x000006e4u, 0x000006cbu, 0x00000036u, 0x0004003du, 0x00000009u, + 0x000006e5u, 0x000006e4u, 0x00050041u, 0x00000042u, 0x000006e6u, 0x000006cbu, 0x00000104u, 0x0004003du, + 0x00000009u, 0x000006e7u, 0x000006e6u, 0x00050041u, 0x00000042u, 0x000006e8u, 0x000006cbu, 0x0000006au, + 0x0004003du, 0x00000009u, 0x000006e9u, 0x000006e8u, 0x00060050u, 0x0000000au, 0x000006eau, 0x000006e5u, + 0x000006e7u, 0x000006e9u, 0x0003003eu, 0x000006e3u, 0x000006eau, 0x00050041u, 0x00000042u, 0x000006ecu, + 0x000006d3u, 0x00000036u, 0x0004003du, 0x00000009u, 0x000006edu, 0x000006ecu, 0x00050041u, 0x00000042u, + 0x000006eeu, 0x000006d3u, 0x00000104u, 0x0004003du, 0x00000009u, 0x000006efu, 0x000006eeu, 0x00050041u, + 0x00000042u, 0x000006f0u, 0x000006d3u, 0x0000006au, 0x0004003du, 0x00000009u, 0x000006f1u, 0x000006f0u, + 0x00060050u, 0x0000000au, 0x000006f2u, 0x000006edu, 0x000006efu, 0x000006f1u, 0x0003003eu, 0x000006ebu, + 0x000006f2u, 0x0004003du, 0x00000006u, 0x000006f4u, 0x00000362u, 0x00050084u, 0x00000006u, 0x000006f5u, + 0x000006f4u, 0x0000013eu, 0x0003003eu, 0x000006f3u, 0x000006f5u, 0x0004003du, 0x0000000au, 0x000006f8u, + 0x000006dbu, 0x0003003eu, 0x000006f7u, 0x000006f8u, 0x0004003du, 0x0000000eu, 0x000006fau, 0x000003a3u, + 0x0003003eu, 0x000006f9u, 0x000006fau, 0x0004003du, 0x00000010u, 0x000006fcu, 0x00000397u, 0x0003003eu, + 0x000006fbu, 0x000006fcu, 0x00070039u, 0x0000000cu, 0x000006fdu, 0x00000016u, 0x000006f7u, 0x000006f9u, + 0x000006fbu, 0x0003003eu, 0x000006f6u, 0x000006fdu, 0x0004003du, 0x0000000au, 0x00000700u, 0x000006e3u, + 0x0003003eu, 0x000006ffu, 0x00000700u, 0x0004003du, 0x0000000eu, 0x00000702u, 0x000003a3u, 0x0003003eu, + 0x00000701u, 0x00000702u, 0x0004003du, 0x00000010u, 0x00000704u, 0x00000397u, 0x0003003eu, 0x00000703u, + 0x00000704u, 0x00070039u, 0x0000000cu, 0x00000705u, 0x00000016u, 0x000006ffu, 0x00000701u, 0x00000703u, + 0x0003003eu, 0x000006feu, 0x00000705u, 0x0004003du, 0x0000000au, 0x00000708u, 0x000006ebu, 0x0003003eu, + 0x00000707u, 0x00000708u, 0x0004003du, 0x0000000eu, 0x0000070au, 0x000003a3u, 0x0003003eu, 0x00000709u, + 0x0000070au, 0x0004003du, 0x00000010u, 0x0000070cu, 0x00000397u, 0x0003003eu, 0x0000070bu, 0x0000070cu, + 0x00070039u, 0x0000000cu, 0x0000070du, 0x00000016u, 0x00000707u, 0x00000709u, 0x0000070bu, 0x0003003eu, + 0x00000706u, 0x0000070du, 0x0004003du, 0x00000006u, 0x0000070eu, 0x000006f3u, 0x00050080u, 0x00000006u, + 0x0000070fu, 0x0000070eu, 0x00000065u, 0x0004003du, 0x0000000cu, 0x00000710u, 0x000006f6u, 0x00060041u, + 0x0000043au, 0x00000711u, 0x00000437u, 0x0000070fu, 0x00000036u, 0x0003003eu, 0x00000711u, 0x00000710u, + 0x0004003du, 0x00000006u, 0x00000712u, 0x000006f3u, 0x00050080u, 0x00000006u, 0x00000713u, 0x00000712u, + 0x00000008u, 0x0004003du, 0x0000000cu, 0x00000714u, 0x000006feu, 0x00060041u, 0x0000043au, 0x00000715u, + 0x00000437u, 0x00000713u, 0x00000036u, 0x0003003eu, 0x00000715u, 0x00000714u, 0x0004003du, 0x00000006u, + 0x00000716u, 0x000006f3u, 0x00050080u, 0x00000006u, 0x00000717u, 0x00000716u, 0x00000044u, 0x0004003du, + 0x0000000cu, 0x00000718u, 0x00000706u, 0x00060041u, 0x0000043au, 0x00000719u, 0x00000437u, 0x00000717u, + 0x00000036u, 0x0003003eu, 0x00000719u, 0x00000718u, 0x0004003du, 0x00000006u, 0x0000071bu, 0x00000362u, + 0x00050084u, 0x00000006u, 0x0000071cu, 0x0000071bu, 0x0000013eu, 0x0003003eu, 0x0000071au, 0x0000071cu, + 0x0004003du, 0x00000006u, 0x0000071du, 0x0000071au, 0x00050086u, 0x00000006u, 0x0000071eu, 0x0000071du, + 0x0000013eu, 0x0004003du, 0x00000006u, 0x0000071fu, 0x000006f3u, 0x00050080u, 0x00000006u, 0x00000720u, + 0x0000071fu, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000721u, 0x000006f3u, 0x00050080u, 0x00000006u, + 0x00000722u, 0x00000721u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000723u, 0x000006f3u, 0x00050080u, + 0x00000006u, 0x00000724u, 0x00000723u, 0x00000044u, 0x00060050u, 0x0000002eu, 0x00000725u, 0x00000720u, + 0x00000722u, 0x00000724u, 0x00050041u, 0x0000045cu, 0x00000726u, 0x00000452u, 0x0000071eu, 0x0003003eu, + 0x00000726u, 0x00000725u, 0x0004003du, 0x00000006u, 0x00000727u, 0x00000362u, 0x00050041u, 0x0000035fu, + 0x00000728u, 0x0000035eu, 0x00000036u, 0x0004003du, 0x00000006u, 0x00000729u, 0x00000728u, 0x0004007cu, + 0x00000035u, 0x0000072au, 0x00000729u, 0x00060041u, 0x00000466u, 0x0000072bu, 0x00000461u, 0x00000727u, + 0x00000036u, 0x0003003eu, 0x0000072bu, 0x0000072au, 0x0004003du, 0x00000006u, 0x0000072cu, 0x00000362u, + 0x00050041u, 0x0000046du, 0x0000072du, 0x0000035eu, 0x000000a9u, 0x0004003du, 0x0000000au, 0x0000072eu, + 0x0000072du, 0x00060041u, 0x00000470u, 0x0000072fu, 0x0000046bu, 0x0000072cu, 0x00000036u, 0x0003003eu, + 0x0000072fu, 0x0000072eu, 0x0004003du, 0x00000006u, 0x00000730u, 0x00000362u, 0x00050041u, 0x00000473u, + 0x00000731u, 0x0000035eu, 0x000000afu, 0x0004003du, 0x00000009u, 0x00000732u, 0x00000731u, 0x00060041u, + 0x00000476u, 0x00000733u, 0x0000046bu, 0x00000730u, 0x00000104u, 0x0003003eu, 0x00000733u, 0x00000732u, + 0x000200f9u, 0x000006bau, 0x000200f8u, 0x000006bau, 0x000200f9u, 0x0000060cu, 0x000200f8u, 0x0000060cu, + 0x000200f9u, 0x00000554u, 0x000200f8u, 0x00000554u, 0x000200f9u, 0x0000047cu, 0x000200f8u, 0x0000047cu, + 0x000200f9u, 0x00000404u, 0x000200f8u, 0x00000404u, 0x000100fdu, 0x00010038u, 0x00050036u, 0x0000000cu, + 0x00000016u, 0x00000000u, 0x00000012u, 0x00030037u, 0x0000000bu, 0x00000013u, 0x00030037u, 0x0000000fu, + 0x00000014u, 0x00030037u, 0x00000011u, 0x00000015u, 0x000200f8u, 0x00000017u, 0x0004003bu, 0x0000000bu, + 0x00000034u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000043u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000047u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000053u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000060u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000064u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000070u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000082u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000086u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x0000008du, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000090u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000094u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000098u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x0000009cu, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x000000a0u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x000000d3u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x000000d6u, 0x00000007u, 0x0004003bu, 0x00000026u, 0x000000deu, 0x00000007u, 0x0004003bu, 0x00000026u, + 0x000000e3u, 0x00000007u, 0x0004003bu, 0x00000026u, 0x00000100u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000109u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000112u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x00000120u, 0x00000007u, 0x0004003bu, 0x00000042u, 0x00000123u, 0x00000007u, 0x0004003bu, 0x00000042u, + 0x0000012eu, 0x00000007u, 0x00050041u, 0x00000037u, 0x00000038u, 0x00000014u, 0x00000036u, 0x0004003du, + 0x0000000du, 0x00000039u, 0x00000038u, 0x0004003du, 0x0000000au, 0x0000003au, 0x00000013u, 0x00050051u, + 0x00000009u, 0x0000003cu, 0x0000003au, 0x00000000u, 0x00050051u, 0x00000009u, 0x0000003du, 0x0000003au, + 0x00000001u, 0x00050051u, 0x00000009u, 0x0000003eu, 0x0000003au, 0x00000002u, 0x00070050u, 0x0000000cu, + 0x0000003fu, 0x0000003cu, 0x0000003du, 0x0000003eu, 0x0000003bu, 0x00050091u, 0x0000000cu, 0x00000040u, + 0x00000039u, 0x0000003fu, 0x0008004fu, 0x0000000au, 0x00000041u, 0x00000040u, 0x00000040u, 0x00000000u, + 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000034u, 0x00000041u, 0x00050041u, 0x00000042u, 0x00000045u, + 0x00000034u, 0x00000044u, 0x0004003du, 0x00000009u, 0x00000046u, 0x00000045u, 0x0003003eu, 0x00000043u, + 0x00000046u, 0x0004003du, 0x0000000au, 0x00000048u, 0x00000034u, 0x0006000cu, 0x00000009u, 0x00000049u, + 0x00000001u, 0x00000042u, 0x00000048u, 0x0003003eu, 0x00000047u, 0x00000049u, 0x0004003du, 0x00000009u, + 0x0000004au, 0x00000047u, 0x000500b8u, 0x0000004cu, 0x0000004du, 0x0000004au, 0x0000004bu, 0x000300f7u, + 0x0000004fu, 0x00000000u, 0x000400fau, 0x0000004du, 0x0000004eu, 0x0000004fu, 0x000200f8u, 0x0000004eu, + 0x000200feu, 0x00000051u, 0x000200f8u, 0x0000004fu, 0x0003003eu, 0x00000053u, 0x00000054u, 0x00050041u, + 0x00000042u, 0x00000056u, 0x00000015u, 0x00000055u, 0x0004003du, 0x00000009u, 0x00000057u, 0x00000056u, + 0x0004003du, 0x00000009u, 0x00000058u, 0x00000053u, 0x000500bcu, 0x0000004cu, 0x00000059u, 0x00000057u, + 0x00000058u, 0x0004003du, 0x00000009u, 0x0000005au, 0x00000043u, 0x000500b8u, 0x0000004cu, 0x0000005cu, + 0x0000005au, 0x0000005bu, 0x000500a7u, 0x0000004cu, 0x0000005du, 0x00000059u, 0x0000005cu, 0x000300f7u, + 0x0000005fu, 0x00000000u, 0x000400fau, 0x0000005du, 0x0000005eu, 0x0000005fu, 0x000200f8u, 0x0000005eu, + 0x00050041u, 0x00000042u, 0x00000062u, 0x00000015u, 0x00000061u, 0x0004003du, 0x00000009u, 0x00000063u, + 0x00000062u, 0x0003003eu, 0x00000060u, 0x00000063u, 0x00050041u, 0x00000042u, 0x00000066u, 0x00000034u, + 0x00000065u, 0x0004003du, 0x00000009u, 0x00000067u, 0x00000066u, 0x0004003du, 0x00000009u, 0x00000068u, + 0x00000060u, 0x00050085u, 0x00000009u, 0x00000069u, 0x00000067u, 0x00000068u, 0x00050041u, 0x00000042u, + 0x0000006bu, 0x00000015u, 0x0000006au, 0x0004003du, 0x00000009u, 0x0000006cu, 0x0000006bu, 0x00050085u, + 0x00000009u, 0x0000006eu, 0x0000006cu, 0x0000006du, 0x00050088u, 0x00000009u, 0x0000006fu, 0x00000069u, + 0x0000006eu, 0x0003003eu, 0x00000064u, 0x0000006fu, 0x00050041u, 0x00000042u, 0x00000071u, 0x00000034u, + 0x00000008u, 0x0004003du, 0x00000009u, 0x00000072u, 0x00000071u, 0x0004007fu, 0x00000009u, 0x00000073u, + 0x00000072u, 0x0004003du, 0x00000009u, 0x00000074u, 0x00000060u, 0x00050085u, 0x00000009u, 0x00000075u, + 0x00000073u, 0x00000074u, 0x00050041u, 0x00000042u, 0x00000077u, 0x00000015u, 0x00000076u, 0x0004003du, + 0x00000009u, 0x00000078u, 0x00000077u, 0x00050085u, 0x00000009u, 0x00000079u, 0x00000078u, 0x0000006du, + 0x00050088u, 0x00000009u, 0x0000007au, 0x00000075u, 0x00000079u, 0x0003003eu, 0x00000070u, 0x0000007au, + 0x0004003du, 0x00000009u, 0x0000007bu, 0x00000064u, 0x00050085u, 0x00000009u, 0x0000007du, 0x0000007bu, + 0x0000007cu, 0x0004003du, 0x00000009u, 0x0000007eu, 0x00000070u, 0x00050085u, 0x00000009u, 0x0000007fu, + 0x0000007eu, 0x0000007cu, 0x00070050u, 0x0000000cu, 0x00000080u, 0x0000007du, 0x0000007fu, 0x0000003bu, + 0x0000003bu, 0x000200feu, 0x00000080u, 0x000200f8u, 0x0000005fu, 0x0004003du, 0x0000000au, 0x00000083u, + 0x00000034u, 0x0007004fu, 0x00000020u, 0x00000084u, 0x00000083u, 0x00000083u, 0x00000000u, 0x00000001u, + 0x0006000cu, 0x00000009u, 0x00000085u, 0x00000001u, 0x00000042u, 0x00000084u, 0x0003003eu, 0x00000082u, + 0x00000085u, 0x00050041u, 0x00000042u, 0x00000087u, 0x00000034u, 0x00000044u, 0x0004003du, 0x00000009u, + 0x00000088u, 0x00000087u, 0x0004003du, 0x00000009u, 0x00000089u, 0x00000047u, 0x00050088u, 0x00000009u, + 0x0000008au, 0x00000088u, 0x00000089u, 0x0008000cu, 0x00000009u, 0x0000008cu, 0x00000001u, 0x0000002bu, + 0x0000008au, 0x0000008bu, 0x0000003bu, 0x0003003eu, 0x00000086u, 0x0000008cu, 0x0004003du, 0x00000009u, + 0x0000008eu, 0x00000086u, 0x0006000cu, 0x00000009u, 0x0000008fu, 0x00000001u, 0x00000011u, 0x0000008eu, + 0x0003003eu, 0x0000008du, 0x0000008fu, 0x0004003du, 0x00000009u, 0x00000091u, 0x0000008du, 0x0004003du, + 0x00000009u, 0x00000092u, 0x0000008du, 0x00050085u, 0x00000009u, 0x00000093u, 0x00000091u, 0x00000092u, + 0x0003003eu, 0x00000090u, 0x00000093u, 0x0004003du, 0x00000009u, 0x00000095u, 0x00000090u, 0x0004003du, + 0x00000009u, 0x00000096u, 0x0000008du, 0x00050085u, 0x00000009u, 0x00000097u, 0x00000095u, 0x00000096u, + 0x0003003eu, 0x00000094u, 0x00000097u, 0x0004003du, 0x00000009u, 0x00000099u, 0x00000090u, 0x0004003du, + 0x00000009u, 0x0000009au, 0x00000090u, 0x00050085u, 0x00000009u, 0x0000009bu, 0x00000099u, 0x0000009au, + 0x0003003eu, 0x00000098u, 0x0000009bu, 0x0004003du, 0x00000009u, 0x0000009du, 0x00000098u, 0x0004003du, + 0x00000009u, 0x0000009eu, 0x0000008du, 0x00050085u, 0x00000009u, 0x0000009fu, 0x0000009du, 0x0000009eu, + 0x0003003eu, 0x0000009cu, 0x0000009fu, 0x00050041u, 0x00000042u, 0x000000a2u, 0x00000015u, 0x000000a1u, + 0x0004003du, 0x00000009u, 0x000000a3u, 0x000000a2u, 0x00050041u, 0x00000042u, 0x000000a4u, 0x00000015u, + 0x00000061u, 0x0004003du, 0x00000009u, 0x000000a5u, 0x000000a4u, 0x0004003du, 0x00000009u, 0x000000a6u, + 0x0000008du, 0x00050085u, 0x00000009u, 0x000000a7u, 0x000000a5u, 0x000000a6u, 0x00050081u, 0x00000009u, + 0x000000a8u, 0x000000a3u, 0x000000a7u, 0x00050041u, 0x00000042u, 0x000000aau, 0x00000015u, 0x000000a9u, + 0x0004003du, 0x00000009u, 0x000000abu, 0x000000aau, 0x0004003du, 0x00000009u, 0x000000acu, 0x00000090u, + 0x00050085u, 0x00000009u, 0x000000adu, 0x000000abu, 0x000000acu, 0x00050081u, 0x00000009u, 0x000000aeu, + 0x000000a8u, 0x000000adu, 0x00050041u, 0x00000042u, 0x000000b0u, 0x00000015u, 0x000000afu, 0x0004003du, + 0x00000009u, 0x000000b1u, 0x000000b0u, 0x0004003du, 0x00000009u, 0x000000b2u, 0x00000094u, 0x00050085u, + 0x00000009u, 0x000000b3u, 0x000000b1u, 0x000000b2u, 0x00050081u, 0x00000009u, 0x000000b4u, 0x000000aeu, + 0x000000b3u, 0x00050041u, 0x00000042u, 0x000000b6u, 0x00000015u, 0x000000b5u, 0x0004003du, 0x00000009u, + 0x000000b7u, 0x000000b6u, 0x0004003du, 0x00000009u, 0x000000b8u, 0x00000098u, 0x00050085u, 0x00000009u, + 0x000000b9u, 0x000000b7u, 0x000000b8u, 0x00050081u, 0x00000009u, 0x000000bau, 0x000000b4u, 0x000000b9u, + 0x00050041u, 0x00000042u, 0x000000bcu, 0x00000015u, 0x000000bbu, 0x0004003du, 0x00000009u, 0x000000bdu, + 0x000000bcu, 0x0004003du, 0x00000009u, 0x000000beu, 0x0000009cu, 0x00050085u, 0x00000009u, 0x000000bfu, + 0x000000bdu, 0x000000beu, 0x00050081u, 0x00000009u, 0x000000c0u, 0x000000bau, 0x000000bfu, 0x0003003eu, + 0x000000a0u, 0x000000c0u, 0x0004003du, 0x00000009u, 0x000000c1u, 0x0000008du, 0x00050041u, 0x00000042u, + 0x000000c2u, 0x00000015u, 0x00000055u, 0x0004003du, 0x00000009u, 0x000000c3u, 0x000000c2u, 0x000500bau, + 0x0000004cu, 0x000000c4u, 0x000000c1u, 0x000000c3u, 0x000300f7u, 0x000000c6u, 0x00000000u, 0x000400fau, + 0x000000c4u, 0x000000c5u, 0x000000c6u, 0x000200f8u, 0x000000c5u, 0x00050041u, 0x00000042u, 0x000000c8u, + 0x00000015u, 0x000000c7u, 0x0004003du, 0x00000009u, 0x000000c9u, 0x000000c8u, 0x0004003du, 0x00000009u, + 0x000000cau, 0x0000008du, 0x00050041u, 0x00000042u, 0x000000cbu, 0x00000015u, 0x00000055u, 0x0004003du, + 0x00000009u, 0x000000ccu, 0x000000cbu, 0x00050083u, 0x00000009u, 0x000000cdu, 0x000000cau, 0x000000ccu, + 0x00050041u, 0x00000042u, 0x000000cfu, 0x00000015u, 0x000000ceu, 0x0004003du, 0x00000009u, 0x000000d0u, + 0x000000cfu, 0x00050085u, 0x00000009u, 0x000000d1u, 0x000000cdu, 0x000000d0u, 0x00050081u, 0x00000009u, + 0x000000d2u, 0x000000c9u, 0x000000d1u, 0x0003003eu, 0x000000a0u, 0x000000d2u, 0x000200f9u, 0x000000c6u, + 0x000200f8u, 0x000000c6u, 0x0004003du, 0x00000009u, 0x000000d4u, 0x00000082u, 0x000500bau, 0x0000004cu, + 0x000000d5u, 0x000000d4u, 0x0000004bu, 0x000300f7u, 0x000000d8u, 0x00000000u, 0x000400fau, 0x000000d5u, + 0x000000d7u, 0x000000dcu, 0x000200f8u, 0x000000d7u, 0x0004003du, 0x00000009u, 0x000000d9u, 0x000000a0u, + 0x0004003du, 0x00000009u, 0x000000dau, 0x00000082u, 0x00050088u, 0x00000009u, 0x000000dbu, 0x000000d9u, + 0x000000dau, 0x0003003eu, 0x000000d6u, 0x000000dbu, 0x000200f9u, 0x000000d8u, 0x000200f8u, 0x000000dcu, + 0x0003003eu, 0x000000d6u, 0x00000050u, 0x000200f9u, 0x000000d8u, 0x000200f8u, 0x000000d8u, 0x0004003du, + 0x00000009u, 0x000000ddu, 0x000000d6u, 0x0003003eu, 0x000000d3u, 0x000000ddu, 0x0004003du, 0x00000009u, + 0x000000dfu, 0x000000d3u, 0x0004003du, 0x0000000au, 0x000000e0u, 0x00000034u, 0x0007004fu, 0x00000020u, + 0x000000e1u, 0x000000e0u, 0x000000e0u, 0x00000000u, 0x00000001u, 0x0005008eu, 0x00000020u, 0x000000e2u, + 0x000000e1u, 0x000000dfu, 0x0003003eu, 0x000000deu, 0x000000e2u, 0x00050041u, 0x00000042u, 0x000000e5u, + 0x00000015u, 0x000000e4u, 0x0004003du, 0x00000009u, 0x000000e6u, 0x000000e5u, 0x00050041u, 0x00000042u, + 0x000000e7u, 0x000000deu, 0x00000065u, 0x0004003du, 0x00000009u, 0x000000e8u, 0x000000e7u, 0x00050085u, + 0x00000009u, 0x000000e9u, 0x000000e6u, 0x000000e8u, 0x00050041u, 0x00000042u, 0x000000ebu, 0x00000015u, + 0x000000eau, 0x0004003du, 0x00000009u, 0x000000ecu, 0x000000ebu, 0x00050041u, 0x00000042u, 0x000000edu, + 0x000000deu, 0x00000008u, 0x0004003du, 0x00000009u, 0x000000eeu, 0x000000edu, 0x00050085u, 0x00000009u, + 0x000000efu, 0x000000ecu, 0x000000eeu, 0x00050081u, 0x00000009u, 0x000000f0u, 0x000000e9u, 0x000000efu, + 0x00050041u, 0x00000042u, 0x000000f1u, 0x000000e3u, 0x00000065u, 0x0003003eu, 0x000000f1u, 0x000000f0u, + 0x00050041u, 0x00000042u, 0x000000f3u, 0x00000015u, 0x000000f2u, 0x0004003du, 0x00000009u, 0x000000f4u, + 0x000000f3u, 0x00050041u, 0x00000042u, 0x000000f5u, 0x000000deu, 0x00000065u, 0x0004003du, 0x00000009u, + 0x000000f6u, 0x000000f5u, 0x00050085u, 0x00000009u, 0x000000f7u, 0x000000f4u, 0x000000f6u, 0x00050041u, + 0x00000042u, 0x000000f9u, 0x00000015u, 0x000000f8u, 0x0004003du, 0x00000009u, 0x000000fau, 0x000000f9u, + 0x00050041u, 0x00000042u, 0x000000fbu, 0x000000deu, 0x00000008u, 0x0004003du, 0x00000009u, 0x000000fcu, + 0x000000fbu, 0x00050085u, 0x00000009u, 0x000000fdu, 0x000000fau, 0x000000fcu, 0x00050081u, 0x00000009u, + 0x000000feu, 0x000000f7u, 0x000000fdu, 0x00050041u, 0x00000042u, 0x000000ffu, 0x000000e3u, 0x00000008u, + 0x0003003eu, 0x000000ffu, 0x000000feu, 0x0004003du, 0x00000020u, 0x00000101u, 0x000000e3u, 0x00050041u, + 0x00000042u, 0x00000102u, 0x00000015u, 0x00000036u, 0x0004003du, 0x00000009u, 0x00000103u, 0x00000102u, + 0x00050041u, 0x00000042u, 0x00000105u, 0x00000015u, 0x00000104u, 0x0004003du, 0x00000009u, 0x00000106u, + 0x00000105u, 0x00050050u, 0x00000020u, 0x00000107u, 0x00000103u, 0x00000106u, 0x00050081u, 0x00000020u, + 0x00000108u, 0x00000101u, 0x00000107u, 0x0003003eu, 0x00000100u, 0x00000108u, 0x00050041u, 0x00000042u, + 0x0000010bu, 0x00000100u, 0x00000065u, 0x0004003du, 0x00000009u, 0x0000010cu, 0x0000010bu, 0x00050085u, + 0x00000009u, 0x0000010du, 0x0000010au, 0x0000010cu, 0x00050041u, 0x00000042u, 0x0000010eu, 0x00000015u, + 0x0000006au, 0x0004003du, 0x00000009u, 0x0000010fu, 0x0000010eu, 0x00050088u, 0x00000009u, 0x00000110u, + 0x0000010du, 0x0000010fu, 0x00050083u, 0x00000009u, 0x00000111u, 0x00000110u, 0x0000003bu, 0x0003003eu, + 0x00000109u, 0x00000111u, 0x00050041u, 0x00000042u, 0x00000113u, 0x00000100u, 0x00000008u, 0x0004003du, + 0x00000009u, 0x00000114u, 0x00000113u, 0x00050085u, 0x00000009u, 0x00000115u, 0x0000010au, 0x00000114u, + 0x00050041u, 0x00000042u, 0x00000116u, 0x00000015u, 0x00000076u, 0x0004003du, 0x00000009u, 0x00000117u, + 0x00000116u, 0x00050088u, 0x00000009u, 0x00000118u, 0x00000115u, 0x00000117u, 0x00050083u, 0x00000009u, + 0x00000119u, 0x0000003bu, 0x00000118u, 0x0003003eu, 0x00000112u, 0x00000119u, 0x00050041u, 0x00000042u, + 0x0000011au, 0x00000015u, 0x00000055u, 0x0004003du, 0x00000009u, 0x0000011bu, 0x0000011au, 0x0004003du, + 0x00000009u, 0x0000011cu, 0x00000053u, 0x000500bau, 0x0000004cu, 0x0000011du, 0x0000011bu, 0x0000011cu, + 0x000300f7u, 0x0000011fu, 0x00000000u, 0x000400fau, 0x0000011du, 0x0000011eu, 0x0000012cu, 0x000200f8u, + 0x0000011eu, 0x0004003du, 0x00000009u, 0x00000121u, 0x00000043u, 0x000500beu, 0x0000004cu, 0x00000122u, + 0x00000121u, 0x00000050u, 0x000300f7u, 0x00000125u, 0x00000000u, 0x000400fau, 0x00000122u, 0x00000124u, + 0x00000127u, 0x000200f8u, 0x00000124u, 0x0004003du, 0x00000009u, 0x00000126u, 0x00000047u, 0x0003003eu, + 0x00000123u, 0x00000126u, 0x000200f9u, 0x00000125u, 0x000200f8u, 0x00000127u, 0x00050041u, 0x00000042u, + 0x00000129u, 0x00000015u, 0x00000128u, 0x0004003du, 0x00000009u, 0x0000012au, 0x00000129u, 0x0003003eu, + 0x00000123u, 0x0000012au, 0x000200f9u, 0x00000125u, 0x000200f8u, 0x00000125u, 0x0004003du, 0x00000009u, + 0x0000012bu, 0x00000123u, 0x0003003eu, 0x00000120u, 0x0000012bu, 0x000200f9u, 0x0000011fu, 0x000200f8u, + 0x0000012cu, 0x0004003du, 0x00000009u, 0x0000012du, 0x00000043u, 0x0003003eu, 0x00000120u, 0x0000012du, + 0x000200f9u, 0x0000011fu, 0x000200f8u, 0x0000011fu, 0x0004003du, 0x00000009u, 0x0000012fu, 0x00000120u, + 0x00050041u, 0x00000042u, 0x00000130u, 0x00000015u, 0x00000128u, 0x0004003du, 0x00000009u, 0x00000131u, + 0x00000130u, 0x00050088u, 0x00000009u, 0x00000132u, 0x0000012fu, 0x00000131u, 0x0008000cu, 0x00000009u, + 0x00000133u, 0x00000001u, 0x0000002bu, 0x00000132u, 0x00000050u, 0x0000003bu, 0x0003003eu, 0x0000012eu, + 0x00000133u, 0x0004003du, 0x00000009u, 0x00000134u, 0x00000109u, 0x0004003du, 0x00000009u, 0x00000135u, + 0x00000112u, 0x0004003du, 0x00000009u, 0x00000136u, 0x0000012eu, 0x00070050u, 0x0000000cu, 0x00000137u, + 0x00000134u, 0x00000135u, 0x00000136u, 0x0000003bu, 0x000200feu, 0x00000137u, 0x00010038u, 0x00050036u, + 0x00000006u, 0x0000001bu, 0x00000000u, 0x00000019u, 0x00030037u, 0x00000018u, 0x0000001au, 0x000200f8u, + 0x0000001cu, 0x0004003du, 0x00000006u, 0x0000013au, 0x0000001au, 0x000500aau, 0x0000004cu, 0x0000013bu, + 0x0000013au, 0x00000065u, 0x000300f7u, 0x0000013du, 0x00000000u, 0x000400fau, 0x0000013bu, 0x0000013cu, + 0x0000013du, 0x000200f8u, 0x0000013cu, 0x000200feu, 0x0000013eu, 0x000200f8u, 0x0000013du, 0x0004003du, + 0x00000006u, 0x00000140u, 0x0000001au, 0x000500aau, 0x0000004cu, 0x00000141u, 0x00000140u, 0x00000008u, + 0x000300f7u, 0x00000143u, 0x00000000u, 0x000400fau, 0x00000141u, 0x00000142u, 0x00000143u, 0x000200f8u, + 0x00000142u, 0x000200feu, 0x00000144u, 0x000200f8u, 0x00000143u, 0x0004003du, 0x00000006u, 0x00000146u, + 0x0000001au, 0x000500aau, 0x0000004cu, 0x00000147u, 0x00000146u, 0x00000044u, 0x000300f7u, 0x00000149u, + 0x00000000u, 0x000400fau, 0x00000147u, 0x00000148u, 0x00000149u, 0x000200f8u, 0x00000148u, 0x000200feu, + 0x0000014au, 0x000200f8u, 0x00000149u, 0x000200feu, 0x0000014cu, 0x00010038u, 0x00050036u, 0x00000006u, + 0x0000001eu, 0x00000000u, 0x00000019u, 0x00030037u, 0x00000018u, 0x0000001du, 0x000200f8u, 0x0000001fu, + 0x0004003du, 0x00000006u, 0x0000014fu, 0x0000001du, 0x000500aau, 0x0000004cu, 0x00000150u, 0x0000014fu, + 0x00000065u, 0x000300f7u, 0x00000152u, 0x00000000u, 0x000400fau, 0x00000150u, 0x00000151u, 0x00000152u, + 0x000200f8u, 0x00000151u, 0x000200feu, 0x00000008u, 0x000200f8u, 0x00000152u, 0x0004003du, 0x00000006u, + 0x00000154u, 0x0000001du, 0x000500aau, 0x0000004cu, 0x00000155u, 0x00000154u, 0x00000008u, 0x000300f7u, + 0x00000157u, 0x00000000u, 0x000400fau, 0x00000155u, 0x00000156u, 0x00000157u, 0x000200f8u, 0x00000156u, + 0x000200feu, 0x00000158u, 0x000200f8u, 0x00000157u, 0x0004003du, 0x00000006u, 0x0000015au, 0x0000001du, + 0x000500aau, 0x0000004cu, 0x0000015bu, 0x0000015au, 0x00000044u, 0x000300f7u, 0x0000015du, 0x00000000u, + 0x000400fau, 0x0000015bu, 0x0000015cu, 0x0000015du, 0x000200f8u, 0x0000015cu, 0x000200feu, 0x0000015eu, + 0x000200f8u, 0x0000015du, 0x000200feu, 0x00000160u, 0x00010038u, 0x00050036u, 0x00000020u, 0x00000024u, + 0x00000000u, 0x00000021u, 0x00030037u, 0x00000018u, 0x00000022u, 0x00030037u, 0x00000018u, 0x00000023u, + 0x000200f8u, 0x00000025u, 0x0004003bu, 0x0000017bu, 0x0000017cu, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x00000194u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000195u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x000001beu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000001bfu, 0x00000007u, 0x0004003du, 0x00000006u, + 0x00000163u, 0x00000023u, 0x000500aau, 0x0000004cu, 0x00000164u, 0x00000163u, 0x00000065u, 0x000300f7u, + 0x00000166u, 0x00000000u, 0x000400fau, 0x00000164u, 0x00000165u, 0x00000175u, 0x000200f8u, 0x00000165u, + 0x0004003du, 0x00000006u, 0x00000167u, 0x00000022u, 0x000500aau, 0x0000004cu, 0x00000168u, 0x00000167u, + 0x00000065u, 0x000300f7u, 0x0000016au, 0x00000000u, 0x000400fau, 0x00000168u, 0x00000169u, 0x0000016au, + 0x000200f8u, 0x00000169u, 0x000200feu, 0x0000016bu, 0x000200f8u, 0x0000016au, 0x0004003du, 0x00000006u, + 0x0000016du, 0x00000022u, 0x000500aau, 0x0000004cu, 0x0000016eu, 0x0000016du, 0x00000008u, 0x000300f7u, + 0x00000170u, 0x00000000u, 0x000400fau, 0x0000016eu, 0x0000016fu, 0x00000170u, 0x000200f8u, 0x0000016fu, + 0x000200feu, 0x00000171u, 0x000200f8u, 0x00000170u, 0x000200feu, 0x00000173u, 0x000200f8u, 0x00000175u, + 0x0004003du, 0x00000006u, 0x00000176u, 0x00000023u, 0x000500aau, 0x0000004cu, 0x00000177u, 0x00000176u, + 0x00000008u, 0x000300f7u, 0x00000179u, 0x00000000u, 0x000400fau, 0x00000177u, 0x00000178u, 0x0000018au, + 0x000200f8u, 0x00000178u, 0x00050041u, 0x00000026u, 0x0000017du, 0x0000017cu, 0x00000036u, 0x0003003eu, + 0x0000017du, 0x0000016bu, 0x00050041u, 0x00000026u, 0x0000017eu, 0x0000017cu, 0x00000104u, 0x0003003eu, + 0x0000017eu, 0x00000171u, 0x00050041u, 0x00000026u, 0x0000017fu, 0x0000017cu, 0x0000006au, 0x0003003eu, + 0x0000017fu, 0x00000173u, 0x00050041u, 0x00000026u, 0x00000181u, 0x0000017cu, 0x00000076u, 0x0003003eu, + 0x00000181u, 0x00000180u, 0x00050041u, 0x00000026u, 0x00000183u, 0x0000017cu, 0x000000a1u, 0x0003003eu, + 0x00000183u, 0x00000182u, 0x00050041u, 0x00000026u, 0x00000185u, 0x0000017cu, 0x00000061u, 0x0003003eu, + 0x00000185u, 0x00000184u, 0x0004003du, 0x00000006u, 0x00000186u, 0x00000022u, 0x00050041u, 0x00000026u, + 0x00000187u, 0x0000017cu, 0x00000186u, 0x0004003du, 0x00000020u, 0x00000188u, 0x00000187u, 0x000200feu, + 0x00000188u, 0x000200f8u, 0x0000018au, 0x0004003du, 0x00000006u, 0x0000018bu, 0x00000023u, 0x000500aau, + 0x0000004cu, 0x0000018cu, 0x0000018bu, 0x00000044u, 0x000300f7u, 0x0000018eu, 0x00000000u, 0x000400fau, + 0x0000018cu, 0x0000018du, 0x000001b9u, 0x000200f8u, 0x0000018du, 0x0004003du, 0x00000006u, 0x0000018fu, + 0x00000022u, 0x000500b0u, 0x0000004cu, 0x00000191u, 0x0000018fu, 0x00000190u, 0x000300f7u, 0x00000193u, + 0x00000000u, 0x000400fau, 0x00000191u, 0x00000192u, 0x00000197u, 0x000200f8u, 0x00000192u, 0x0003003eu, + 0x00000194u, 0x00000065u, 0x0004003du, 0x00000006u, 0x00000196u, 0x00000022u, 0x0003003eu, 0x00000195u, + 0x00000196u, 0x000200f9u, 0x00000193u, 0x000200f8u, 0x00000197u, 0x0004003du, 0x00000006u, 0x00000198u, + 0x00000022u, 0x000500b0u, 0x0000004cu, 0x0000019au, 0x00000198u, 0x00000199u, 0x000300f7u, 0x0000019cu, + 0x00000000u, 0x000400fau, 0x0000019au, 0x0000019bu, 0x0000019fu, 0x000200f8u, 0x0000019bu, 0x0003003eu, + 0x00000194u, 0x00000008u, 0x0004003du, 0x00000006u, 0x0000019du, 0x00000022u, 0x00050082u, 0x00000006u, + 0x0000019eu, 0x0000019du, 0x00000190u, 0x0003003eu, 0x00000195u, 0x0000019eu, 0x000200f9u, 0x0000019cu, + 0x000200f8u, 0x0000019fu, 0x0004003du, 0x00000006u, 0x000001a0u, 0x00000022u, 0x000500b0u, 0x0000004cu, + 0x000001a2u, 0x000001a0u, 0x000001a1u, 0x000300f7u, 0x000001a4u, 0x00000000u, 0x000400fau, 0x000001a2u, + 0x000001a3u, 0x000001a7u, 0x000200f8u, 0x000001a3u, 0x0003003eu, 0x00000194u, 0x00000044u, 0x0004003du, + 0x00000006u, 0x000001a5u, 0x00000022u, 0x00050082u, 0x00000006u, 0x000001a6u, 0x000001a5u, 0x00000199u, + 0x0003003eu, 0x00000195u, 0x000001a6u, 0x000200f9u, 0x000001a4u, 0x000200f8u, 0x000001a7u, 0x0004003du, + 0x00000006u, 0x000001a8u, 0x00000022u, 0x000500b0u, 0x0000004cu, 0x000001aau, 0x000001a8u, 0x000001a9u, + 0x000300f7u, 0x000001acu, 0x00000000u, 0x000400fau, 0x000001aau, 0x000001abu, 0x000001afu, 0x000200f8u, + 0x000001abu, 0x0003003eu, 0x00000194u, 0x0000013eu, 0x0004003du, 0x00000006u, 0x000001adu, 0x00000022u, + 0x00050082u, 0x00000006u, 0x000001aeu, 0x000001adu, 0x000001a1u, 0x0003003eu, 0x00000195u, 0x000001aeu, + 0x000200f9u, 0x000001acu, 0x000200f8u, 0x000001afu, 0x0003003eu, 0x00000194u, 0x00000158u, 0x0003003eu, + 0x00000195u, 0x00000065u, 0x000200f9u, 0x000001acu, 0x000200f8u, 0x000001acu, 0x000200f9u, 0x000001a4u, + 0x000200f8u, 0x000001a4u, 0x000200f9u, 0x0000019cu, 0x000200f8u, 0x0000019cu, 0x000200f9u, 0x00000193u, + 0x000200f8u, 0x00000193u, 0x0004003du, 0x00000006u, 0x000001b0u, 0x00000195u, 0x00040070u, 0x00000009u, + 0x000001b1u, 0x000001b0u, 0x00050088u, 0x00000009u, 0x000001b3u, 0x000001b1u, 0x000001b2u, 0x0004003du, + 0x00000006u, 0x000001b4u, 0x00000194u, 0x00040070u, 0x00000009u, 0x000001b5u, 0x000001b4u, 0x00050088u, + 0x00000009u, 0x000001b6u, 0x000001b5u, 0x000001b2u, 0x00050050u, 0x00000020u, 0x000001b7u, 0x000001b3u, + 0x000001b6u, 0x000200feu, 0x000001b7u, 0x000200f8u, 0x000001b9u, 0x0004003du, 0x00000006u, 0x000001bau, + 0x00000022u, 0x000500b0u, 0x0000004cu, 0x000001bbu, 0x000001bau, 0x00000199u, 0x000300f7u, 0x000001bdu, + 0x00000000u, 0x000400fau, 0x000001bbu, 0x000001bcu, 0x000001c1u, 0x000200f8u, 0x000001bcu, 0x0003003eu, + 0x000001beu, 0x00000065u, 0x0004003du, 0x00000006u, 0x000001c0u, 0x00000022u, 0x0003003eu, 0x000001bfu, + 0x000001c0u, 0x000200f9u, 0x000001bdu, 0x000200f8u, 0x000001c1u, 0x0004003du, 0x00000006u, 0x000001c2u, + 0x00000022u, 0x000500b0u, 0x0000004cu, 0x000001c4u, 0x000001c2u, 0x000001c3u, 0x000300f7u, 0x000001c6u, + 0x00000000u, 0x000400fau, 0x000001c4u, 0x000001c5u, 0x000001c9u, 0x000200f8u, 0x000001c5u, 0x0003003eu, + 0x000001beu, 0x00000008u, 0x0004003du, 0x00000006u, 0x000001c7u, 0x00000022u, 0x00050082u, 0x00000006u, + 0x000001c8u, 0x000001c7u, 0x00000199u, 0x0003003eu, 0x000001bfu, 0x000001c8u, 0x000200f9u, 0x000001c6u, + 0x000200f8u, 0x000001c9u, 0x0004003du, 0x00000006u, 0x000001cau, 0x00000022u, 0x000500b0u, 0x0000004cu, + 0x000001ccu, 0x000001cau, 0x000001cbu, 0x000300f7u, 0x000001ceu, 0x00000000u, 0x000400fau, 0x000001ccu, + 0x000001cdu, 0x000001d1u, 0x000200f8u, 0x000001cdu, 0x0003003eu, 0x000001beu, 0x00000044u, 0x0004003du, + 0x00000006u, 0x000001cfu, 0x00000022u, 0x00050082u, 0x00000006u, 0x000001d0u, 0x000001cfu, 0x000001c3u, + 0x0003003eu, 0x000001bfu, 0x000001d0u, 0x000200f9u, 0x000001ceu, 0x000200f8u, 0x000001d1u, 0x0004003du, + 0x00000006u, 0x000001d2u, 0x00000022u, 0x000500b0u, 0x0000004cu, 0x000001d4u, 0x000001d2u, 0x000001d3u, + 0x000300f7u, 0x000001d6u, 0x00000000u, 0x000400fau, 0x000001d4u, 0x000001d5u, 0x000001d9u, 0x000200f8u, + 0x000001d5u, 0x0003003eu, 0x000001beu, 0x0000013eu, 0x0004003du, 0x00000006u, 0x000001d7u, 0x00000022u, + 0x00050082u, 0x00000006u, 0x000001d8u, 0x000001d7u, 0x000001cbu, 0x0003003eu, 0x000001bfu, 0x000001d8u, + 0x000200f9u, 0x000001d6u, 0x000200f8u, 0x000001d9u, 0x0004003du, 0x00000006u, 0x000001dau, 0x00000022u, + 0x000500b0u, 0x0000004cu, 0x000001dcu, 0x000001dau, 0x000001dbu, 0x000300f7u, 0x000001deu, 0x00000000u, + 0x000400fau, 0x000001dcu, 0x000001ddu, 0x000001e1u, 0x000200f8u, 0x000001ddu, 0x0003003eu, 0x000001beu, + 0x00000158u, 0x0004003du, 0x00000006u, 0x000001dfu, 0x00000022u, 0x00050082u, 0x00000006u, 0x000001e0u, + 0x000001dfu, 0x000001d3u, 0x0003003eu, 0x000001bfu, 0x000001e0u, 0x000200f9u, 0x000001deu, 0x000200f8u, + 0x000001e1u, 0x0004003du, 0x00000006u, 0x000001e2u, 0x00000022u, 0x000500b0u, 0x0000004cu, 0x000001e4u, + 0x000001e2u, 0x000001e3u, 0x000300f7u, 0x000001e6u, 0x00000000u, 0x000400fau, 0x000001e4u, 0x000001e5u, + 0x000001e9u, 0x000200f8u, 0x000001e5u, 0x0003003eu, 0x000001beu, 0x00000190u, 0x0004003du, 0x00000006u, + 0x000001e7u, 0x00000022u, 0x00050082u, 0x00000006u, 0x000001e8u, 0x000001e7u, 0x000001dbu, 0x0003003eu, + 0x000001bfu, 0x000001e8u, 0x000200f9u, 0x000001e6u, 0x000200f8u, 0x000001e9u, 0x0004003du, 0x00000006u, + 0x000001eau, 0x00000022u, 0x000500b0u, 0x0000004cu, 0x000001ecu, 0x000001eau, 0x000001ebu, 0x000300f7u, + 0x000001eeu, 0x00000000u, 0x000400fau, 0x000001ecu, 0x000001edu, 0x000001f1u, 0x000200f8u, 0x000001edu, + 0x0003003eu, 0x000001beu, 0x00000144u, 0x0004003du, 0x00000006u, 0x000001efu, 0x00000022u, 0x00050082u, + 0x00000006u, 0x000001f0u, 0x000001efu, 0x000001e3u, 0x0003003eu, 0x000001bfu, 0x000001f0u, 0x000200f9u, + 0x000001eeu, 0x000200f8u, 0x000001f1u, 0x0004003du, 0x00000006u, 0x000001f2u, 0x00000022u, 0x000500b0u, + 0x0000004cu, 0x000001f4u, 0x000001f2u, 0x000001f3u, 0x000300f7u, 0x000001f6u, 0x00000000u, 0x000400fau, + 0x000001f4u, 0x000001f5u, 0x000001fau, 0x000200f8u, 0x000001f5u, 0x0003003eu, 0x000001beu, 0x000001f7u, + 0x0004003du, 0x00000006u, 0x000001f8u, 0x00000022u, 0x00050082u, 0x00000006u, 0x000001f9u, 0x000001f8u, + 0x000001ebu, 0x0003003eu, 0x000001bfu, 0x000001f9u, 0x000200f9u, 0x000001f6u, 0x000200f8u, 0x000001fau, + 0x0003003eu, 0x000001beu, 0x000001fbu, 0x0003003eu, 0x000001bfu, 0x00000065u, 0x000200f9u, 0x000001f6u, + 0x000200f8u, 0x000001f6u, 0x000200f9u, 0x000001eeu, 0x000200f8u, 0x000001eeu, 0x000200f9u, 0x000001e6u, + 0x000200f8u, 0x000001e6u, 0x000200f9u, 0x000001deu, 0x000200f8u, 0x000001deu, 0x000200f9u, 0x000001d6u, + 0x000200f8u, 0x000001d6u, 0x000200f9u, 0x000001ceu, 0x000200f8u, 0x000001ceu, 0x000200f9u, 0x000001c6u, + 0x000200f8u, 0x000001c6u, 0x000200f9u, 0x000001bdu, 0x000200f8u, 0x000001bdu, 0x0004003du, 0x00000006u, + 0x000001fcu, 0x000001bfu, 0x00040070u, 0x00000009u, 0x000001fdu, 0x000001fcu, 0x00050088u, 0x00000009u, + 0x000001ffu, 0x000001fdu, 0x000001feu, 0x0004003du, 0x00000006u, 0x00000200u, 0x000001beu, 0x00040070u, + 0x00000009u, 0x00000201u, 0x00000200u, 0x00050088u, 0x00000009u, 0x00000202u, 0x00000201u, 0x000001feu, + 0x00050050u, 0x00000020u, 0x00000203u, 0x000001ffu, 0x00000202u, 0x000200feu, 0x00000203u, 0x000200f8u, + 0x0000018eu, 0x000100ffu, 0x000200f8u, 0x00000179u, 0x000100ffu, 0x000200f8u, 0x00000166u, 0x000100ffu, + 0x00010038u, 0x00050036u, 0x0000000au, 0x0000002cu, 0x00000000u, 0x00000027u, 0x00030037u, 0x0000000bu, + 0x00000028u, 0x00030037u, 0x0000000bu, 0x00000029u, 0x00030037u, 0x0000000bu, 0x0000002au, 0x00030037u, + 0x00000026u, 0x0000002bu, 0x000200f8u, 0x0000002du, 0x0004003bu, 0x00000042u, 0x00000206u, 0x00000007u, + 0x00050041u, 0x00000042u, 0x00000207u, 0x0000002bu, 0x00000065u, 0x0004003du, 0x00000009u, 0x00000208u, + 0x00000207u, 0x00050083u, 0x00000009u, 0x00000209u, 0x0000003bu, 0x00000208u, 0x00050041u, 0x00000042u, + 0x0000020au, 0x0000002bu, 0x00000008u, 0x0004003du, 0x00000009u, 0x0000020bu, 0x0000020au, 0x00050083u, + 0x00000009u, 0x0000020cu, 0x00000209u, 0x0000020bu, 0x0003003eu, 0x00000206u, 0x0000020cu, 0x0004003du, + 0x0000000au, 0x0000020du, 0x00000028u, 0x0004003du, 0x00000009u, 0x0000020eu, 0x00000206u, 0x0005008eu, + 0x0000000au, 0x0000020fu, 0x0000020du, 0x0000020eu, 0x0004003du, 0x0000000au, 0x00000210u, 0x00000029u, + 0x00050041u, 0x00000042u, 0x00000211u, 0x0000002bu, 0x00000065u, 0x0004003du, 0x00000009u, 0x00000212u, + 0x00000211u, 0x0005008eu, 0x0000000au, 0x00000213u, 0x00000210u, 0x00000212u, 0x00050081u, 0x0000000au, + 0x00000214u, 0x0000020fu, 0x00000213u, 0x0004003du, 0x0000000au, 0x00000215u, 0x0000002au, 0x00050041u, + 0x00000042u, 0x00000216u, 0x0000002bu, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000217u, 0x00000216u, + 0x0005008eu, 0x0000000au, 0x00000218u, 0x00000215u, 0x00000217u, 0x00050081u, 0x0000000au, 0x00000219u, + 0x00000214u, 0x00000218u, 0x000200feu, 0x00000219u, 0x00010038u, 0x00050036u, 0x0000002eu, 0x00000032u, + 0x00000000u, 0x0000002fu, 0x00030037u, 0x00000018u, 0x00000030u, 0x00030037u, 0x00000018u, 0x00000031u, + 0x000200f8u, 0x00000033u, 0x0004003bu, 0x00000228u, 0x00000229u, 0x00000007u, 0x0004003bu, 0x0000023du, + 0x0000023eu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000240u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x00000242u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000243u, 0x00000007u, 0x0004003bu, 0x00000244u, + 0x00000245u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000259u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x00000269u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000279u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x0000027fu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000286u, 0x00000007u, 0x0004003bu, 0x000002a8u, + 0x000002a9u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000002abu, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x000002adu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000002aeu, 0x00000007u, 0x0004003bu, 0x00000244u, + 0x000002afu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000002c2u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x000002d2u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x000002e3u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x000002f4u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000305u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x00000316u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000326u, 0x00000007u, 0x0004003bu, 0x00000018u, + 0x0000032cu, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000333u, 0x00000007u, 0x0004003du, 0x00000006u, + 0x0000021cu, 0x00000031u, 0x000500aau, 0x0000004cu, 0x0000021du, 0x0000021cu, 0x00000065u, 0x000300f7u, + 0x0000021fu, 0x00000000u, 0x000400fau, 0x0000021du, 0x0000021eu, 0x00000222u, 0x000200f8u, 0x0000021eu, + 0x000200feu, 0x00000220u, 0x000200f8u, 0x00000222u, 0x0004003du, 0x00000006u, 0x00000223u, 0x00000031u, + 0x000500aau, 0x0000004cu, 0x00000224u, 0x00000223u, 0x00000008u, 0x000300f7u, 0x00000226u, 0x00000000u, + 0x000400fau, 0x00000224u, 0x00000225u, 0x00000237u, 0x000200f8u, 0x00000225u, 0x00050041u, 0x0000022bu, + 0x0000022cu, 0x00000229u, 0x00000036u, 0x0003003eu, 0x0000022cu, 0x0000022au, 0x00050041u, 0x0000022bu, + 0x0000022eu, 0x00000229u, 0x00000104u, 0x0003003eu, 0x0000022eu, 0x0000022du, 0x00050041u, 0x0000022bu, + 0x00000230u, 0x00000229u, 0x0000006au, 0x0003003eu, 0x00000230u, 0x0000022fu, 0x00050041u, 0x0000022bu, + 0x00000232u, 0x00000229u, 0x00000076u, 0x0003003eu, 0x00000232u, 0x00000231u, 0x0004003du, 0x00000006u, + 0x00000233u, 0x00000030u, 0x00050041u, 0x0000022bu, 0x00000234u, 0x00000229u, 0x00000233u, 0x0004003du, + 0x0000002eu, 0x00000235u, 0x00000234u, 0x000200feu, 0x00000235u, 0x000200f8u, 0x00000237u, 0x0004003du, + 0x00000006u, 0x00000238u, 0x00000031u, 0x000500aau, 0x0000004cu, 0x00000239u, 0x00000238u, 0x00000044u, + 0x000300f7u, 0x0000023bu, 0x00000000u, 0x000400fau, 0x00000239u, 0x0000023au, 0x000002a6u, 0x000200f8u, + 0x0000023au, 0x0003003eu, 0x0000023eu, 0x0000023fu, 0x0004003du, 0x00000006u, 0x00000241u, 0x00000030u, + 0x0003003eu, 0x00000240u, 0x00000241u, 0x0003003eu, 0x00000242u, 0x00000065u, 0x0003003eu, 0x00000243u, + 0x00000065u, 0x0003003eu, 0x00000245u, 0x00000246u, 0x0004003du, 0x00000006u, 0x00000247u, 0x00000240u, + 0x000500b0u, 0x0000004cu, 0x00000248u, 0x00000247u, 0x000001f7u, 0x000300f7u, 0x0000024au, 0x00000000u, + 0x000400fau, 0x00000248u, 0x00000249u, 0x00000254u, 0x000200f8u, 0x00000249u, 0x0003003eu, 0x00000242u, + 0x00000065u, 0x0004003du, 0x00000006u, 0x0000024bu, 0x00000240u, 0x000500b0u, 0x0000004cu, 0x0000024cu, + 0x0000024bu, 0x00000158u, 0x000300f7u, 0x0000024eu, 0x00000000u, 0x000400fau, 0x0000024cu, 0x0000024du, + 0x00000250u, 0x000200f8u, 0x0000024du, 0x0004003du, 0x00000006u, 0x0000024fu, 0x00000240u, 0x0003003eu, + 0x00000243u, 0x0000024fu, 0x0003003eu, 0x00000245u, 0x00000246u, 0x000200f9u, 0x0000024eu, 0x000200f8u, + 0x00000250u, 0x0004003du, 0x00000006u, 0x00000251u, 0x00000240u, 0x00050082u, 0x00000006u, 0x00000252u, + 0x00000251u, 0x00000158u, 0x0003003eu, 0x00000243u, 0x00000252u, 0x0003003eu, 0x00000245u, 0x00000253u, + 0x000200f9u, 0x0000024eu, 0x000200f8u, 0x0000024eu, 0x000200f9u, 0x0000024au, 0x000200f8u, 0x00000254u, + 0x0004003du, 0x00000006u, 0x00000255u, 0x00000240u, 0x000500b0u, 0x0000004cu, 0x00000256u, 0x00000255u, + 0x000001a1u, 0x000300f7u, 0x00000258u, 0x00000000u, 0x000400fau, 0x00000256u, 0x00000257u, 0x00000264u, + 0x000200f8u, 0x00000257u, 0x0003003eu, 0x00000242u, 0x00000008u, 0x0004003du, 0x00000006u, 0x0000025au, + 0x00000240u, 0x00050082u, 0x00000006u, 0x0000025bu, 0x0000025au, 0x000001f7u, 0x0003003eu, 0x00000259u, + 0x0000025bu, 0x0004003du, 0x00000006u, 0x0000025cu, 0x00000259u, 0x000500b0u, 0x0000004cu, 0x0000025du, + 0x0000025cu, 0x0000013eu, 0x000300f7u, 0x0000025fu, 0x00000000u, 0x000400fau, 0x0000025du, 0x0000025eu, + 0x00000261u, 0x000200f8u, 0x0000025eu, 0x0004003du, 0x00000006u, 0x00000260u, 0x00000259u, 0x0003003eu, + 0x00000243u, 0x00000260u, 0x0003003eu, 0x00000245u, 0x00000246u, 0x000200f9u, 0x0000025fu, 0x000200f8u, + 0x00000261u, 0x0004003du, 0x00000006u, 0x00000262u, 0x00000259u, 0x00050082u, 0x00000006u, 0x00000263u, + 0x00000262u, 0x0000013eu, 0x0003003eu, 0x00000243u, 0x00000263u, 0x0003003eu, 0x00000245u, 0x00000253u, + 0x000200f9u, 0x0000025fu, 0x000200f8u, 0x0000025fu, 0x000200f9u, 0x00000258u, 0x000200f8u, 0x00000264u, + 0x0004003du, 0x00000006u, 0x00000265u, 0x00000240u, 0x000500b0u, 0x0000004cu, 0x00000266u, 0x00000265u, + 0x0000014au, 0x000300f7u, 0x00000268u, 0x00000000u, 0x000400fau, 0x00000266u, 0x00000267u, 0x00000274u, + 0x000200f8u, 0x00000267u, 0x0003003eu, 0x00000242u, 0x00000044u, 0x0004003du, 0x00000006u, 0x0000026au, + 0x00000240u, 0x00050082u, 0x00000006u, 0x0000026bu, 0x0000026au, 0x000001a1u, 0x0003003eu, 0x00000269u, + 0x0000026bu, 0x0004003du, 0x00000006u, 0x0000026cu, 0x00000269u, 0x000500b0u, 0x0000004cu, 0x0000026du, + 0x0000026cu, 0x00000044u, 0x000300f7u, 0x0000026fu, 0x00000000u, 0x000400fau, 0x0000026du, 0x0000026eu, + 0x00000271u, 0x000200f8u, 0x0000026eu, 0x0004003du, 0x00000006u, 0x00000270u, 0x00000269u, 0x0003003eu, + 0x00000243u, 0x00000270u, 0x0003003eu, 0x00000245u, 0x00000246u, 0x000200f9u, 0x0000026fu, 0x000200f8u, + 0x00000271u, 0x0004003du, 0x00000006u, 0x00000272u, 0x00000269u, 0x00050082u, 0x00000006u, 0x00000273u, + 0x00000272u, 0x00000044u, 0x0003003eu, 0x00000243u, 0x00000273u, 0x0003003eu, 0x00000245u, 0x00000253u, + 0x000200f9u, 0x0000026fu, 0x000200f8u, 0x0000026fu, 0x000200f9u, 0x00000268u, 0x000200f8u, 0x00000274u, + 0x0003003eu, 0x00000242u, 0x0000013eu, 0x0003003eu, 0x00000243u, 0x00000065u, 0x0003003eu, 0x00000245u, + 0x00000246u, 0x000200f9u, 0x00000268u, 0x000200f8u, 0x00000268u, 0x000200f9u, 0x00000258u, 0x000200f8u, + 0x00000258u, 0x000200f9u, 0x0000024au, 0x000200f8u, 0x0000024au, 0x0004003du, 0x0000004cu, 0x00000275u, + 0x00000245u, 0x000400a8u, 0x0000004cu, 0x00000276u, 0x00000275u, 0x000300f7u, 0x00000278u, 0x00000000u, + 0x000400fau, 0x00000276u, 0x00000277u, 0x0000028du, 0x000200f8u, 0x00000277u, 0x0004003du, 0x00000006u, + 0x0000027au, 0x00000242u, 0x00050041u, 0x00000018u, 0x0000027bu, 0x0000023eu, 0x0000027au, 0x0004003du, + 0x00000006u, 0x0000027cu, 0x0000027bu, 0x0004003du, 0x00000006u, 0x0000027du, 0x00000243u, 0x00050080u, + 0x00000006u, 0x0000027eu, 0x0000027cu, 0x0000027du, 0x0003003eu, 0x00000279u, 0x0000027eu, 0x0004003du, + 0x00000006u, 0x00000280u, 0x00000242u, 0x00050041u, 0x00000018u, 0x00000281u, 0x0000023eu, 0x00000280u, + 0x0004003du, 0x00000006u, 0x00000282u, 0x00000281u, 0x0004003du, 0x00000006u, 0x00000283u, 0x00000243u, + 0x00050080u, 0x00000006u, 0x00000284u, 0x00000282u, 0x00000283u, 0x00050080u, 0x00000006u, 0x00000285u, + 0x00000284u, 0x00000008u, 0x0003003eu, 0x0000027fu, 0x00000285u, 0x0004003du, 0x00000006u, 0x00000287u, + 0x00000242u, 0x00050080u, 0x00000006u, 0x00000288u, 0x00000287u, 0x00000008u, 0x00050041u, 0x00000018u, + 0x00000289u, 0x0000023eu, 0x00000288u, 0x0004003du, 0x00000006u, 0x0000028au, 0x00000289u, 0x0004003du, + 0x00000006u, 0x0000028bu, 0x00000243u, 0x00050080u, 0x00000006u, 0x0000028cu, 0x0000028au, 0x0000028bu, + 0x0003003eu, 0x00000286u, 0x0000028cu, 0x000200f9u, 0x00000278u, 0x000200f8u, 0x0000028du, 0x0004003du, + 0x00000006u, 0x0000028eu, 0x00000242u, 0x00050041u, 0x00000018u, 0x0000028fu, 0x0000023eu, 0x0000028eu, + 0x0004003du, 0x00000006u, 0x00000290u, 0x0000028fu, 0x0004003du, 0x00000006u, 0x00000291u, 0x00000243u, + 0x00050080u, 0x00000006u, 0x00000292u, 0x00000290u, 0x00000291u, 0x00050080u, 0x00000006u, 0x00000293u, + 0x00000292u, 0x00000008u, 0x0003003eu, 0x00000279u, 0x00000293u, 0x0004003du, 0x00000006u, 0x00000294u, + 0x00000242u, 0x00050080u, 0x00000006u, 0x00000295u, 0x00000294u, 0x00000008u, 0x00050041u, 0x00000018u, + 0x00000296u, 0x0000023eu, 0x00000295u, 0x0004003du, 0x00000006u, 0x00000297u, 0x00000296u, 0x0004003du, + 0x00000006u, 0x00000298u, 0x00000243u, 0x00050080u, 0x00000006u, 0x00000299u, 0x00000297u, 0x00000298u, + 0x00050080u, 0x00000006u, 0x0000029au, 0x00000299u, 0x00000008u, 0x0003003eu, 0x0000027fu, 0x0000029au, + 0x0004003du, 0x00000006u, 0x0000029bu, 0x00000242u, 0x00050080u, 0x00000006u, 0x0000029cu, 0x0000029bu, + 0x00000008u, 0x00050041u, 0x00000018u, 0x0000029du, 0x0000023eu, 0x0000029cu, 0x0004003du, 0x00000006u, + 0x0000029eu, 0x0000029du, 0x0004003du, 0x00000006u, 0x0000029fu, 0x00000243u, 0x00050080u, 0x00000006u, + 0x000002a0u, 0x0000029eu, 0x0000029fu, 0x0003003eu, 0x00000286u, 0x000002a0u, 0x000200f9u, 0x00000278u, + 0x000200f8u, 0x00000278u, 0x0004003du, 0x00000006u, 0x000002a1u, 0x00000279u, 0x0004003du, 0x00000006u, + 0x000002a2u, 0x0000027fu, 0x0004003du, 0x00000006u, 0x000002a3u, 0x00000286u, 0x00060050u, 0x0000002eu, + 0x000002a4u, 0x000002a1u, 0x000002a2u, 0x000002a3u, 0x000200feu, 0x000002a4u, 0x000200f8u, 0x000002a6u, + 0x0003003eu, 0x000002a9u, 0x000002aau, 0x0004003du, 0x00000006u, 0x000002acu, 0x00000030u, 0x0003003eu, + 0x000002abu, 0x000002acu, 0x0003003eu, 0x000002adu, 0x00000065u, 0x0003003eu, 0x000002aeu, 0x00000065u, + 0x0003003eu, 0x000002afu, 0x00000246u, 0x0004003du, 0x00000006u, 0x000002b0u, 0x000002abu, 0x000500b0u, + 0x0000004cu, 0x000002b1u, 0x000002b0u, 0x0000014au, 0x000300f7u, 0x000002b3u, 0x00000000u, 0x000400fau, + 0x000002b1u, 0x000002b2u, 0x000002bcu, 0x000200f8u, 0x000002b2u, 0x0003003eu, 0x000002adu, 0x00000065u, + 0x0004003du, 0x00000006u, 0x000002b4u, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x000002b5u, 0x000002b4u, + 0x000001fbu, 0x000300f7u, 0x000002b7u, 0x00000000u, 0x000400fau, 0x000002b5u, 0x000002b6u, 0x000002b9u, + 0x000200f8u, 0x000002b6u, 0x0004003du, 0x00000006u, 0x000002b8u, 0x000002abu, 0x0003003eu, 0x000002aeu, + 0x000002b8u, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x000002b7u, 0x000200f8u, 0x000002b9u, + 0x0004003du, 0x00000006u, 0x000002bau, 0x000002abu, 0x00050082u, 0x00000006u, 0x000002bbu, 0x000002bau, + 0x000001fbu, 0x0003003eu, 0x000002aeu, 0x000002bbu, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x000002b7u, 0x000200f8u, 0x000002b7u, 0x000200f9u, 0x000002b3u, 0x000200f8u, 0x000002bcu, 0x0004003du, + 0x00000006u, 0x000002bdu, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x000002bfu, 0x000002bdu, 0x000002beu, + 0x000300f7u, 0x000002c1u, 0x00000000u, 0x000400fau, 0x000002bfu, 0x000002c0u, 0x000002cdu, 0x000200f8u, + 0x000002c0u, 0x0003003eu, 0x000002adu, 0x00000008u, 0x0004003du, 0x00000006u, 0x000002c3u, 0x000002abu, + 0x00050082u, 0x00000006u, 0x000002c4u, 0x000002c3u, 0x0000014au, 0x0003003eu, 0x000002c2u, 0x000002c4u, + 0x0004003du, 0x00000006u, 0x000002c5u, 0x000002c2u, 0x000500b0u, 0x0000004cu, 0x000002c6u, 0x000002c5u, + 0x000001f7u, 0x000300f7u, 0x000002c8u, 0x00000000u, 0x000400fau, 0x000002c6u, 0x000002c7u, 0x000002cau, + 0x000200f8u, 0x000002c7u, 0x0004003du, 0x00000006u, 0x000002c9u, 0x000002c2u, 0x0003003eu, 0x000002aeu, + 0x000002c9u, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x000002c8u, 0x000200f8u, 0x000002cau, + 0x0004003du, 0x00000006u, 0x000002cbu, 0x000002c2u, 0x00050082u, 0x00000006u, 0x000002ccu, 0x000002cbu, + 0x000001f7u, 0x0003003eu, 0x000002aeu, 0x000002ccu, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x000002c8u, 0x000200f8u, 0x000002c8u, 0x000200f9u, 0x000002c1u, 0x000200f8u, 0x000002cdu, 0x0004003du, + 0x00000006u, 0x000002ceu, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x000002cfu, 0x000002ceu, 0x000001e3u, + 0x000300f7u, 0x000002d1u, 0x00000000u, 0x000400fau, 0x000002cfu, 0x000002d0u, 0x000002ddu, 0x000200f8u, + 0x000002d0u, 0x0003003eu, 0x000002adu, 0x00000044u, 0x0004003du, 0x00000006u, 0x000002d3u, 0x000002abu, + 0x00050082u, 0x00000006u, 0x000002d4u, 0x000002d3u, 0x000002beu, 0x0003003eu, 0x000002d2u, 0x000002d4u, + 0x0004003du, 0x00000006u, 0x000002d5u, 0x000002d2u, 0x000500b0u, 0x0000004cu, 0x000002d6u, 0x000002d5u, + 0x00000144u, 0x000300f7u, 0x000002d8u, 0x00000000u, 0x000400fau, 0x000002d6u, 0x000002d7u, 0x000002dau, + 0x000200f8u, 0x000002d7u, 0x0004003du, 0x00000006u, 0x000002d9u, 0x000002d2u, 0x0003003eu, 0x000002aeu, + 0x000002d9u, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x000002d8u, 0x000200f8u, 0x000002dau, + 0x0004003du, 0x00000006u, 0x000002dbu, 0x000002d2u, 0x00050082u, 0x00000006u, 0x000002dcu, 0x000002dbu, + 0x00000144u, 0x0003003eu, 0x000002aeu, 0x000002dcu, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x000002d8u, 0x000200f8u, 0x000002d8u, 0x000200f9u, 0x000002d1u, 0x000200f8u, 0x000002ddu, 0x0004003du, + 0x00000006u, 0x000002deu, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x000002e0u, 0x000002deu, 0x000002dfu, + 0x000300f7u, 0x000002e2u, 0x00000000u, 0x000400fau, 0x000002e0u, 0x000002e1u, 0x000002eeu, 0x000200f8u, + 0x000002e1u, 0x0003003eu, 0x000002adu, 0x0000013eu, 0x0004003du, 0x00000006u, 0x000002e4u, 0x000002abu, + 0x00050082u, 0x00000006u, 0x000002e5u, 0x000002e4u, 0x000001e3u, 0x0003003eu, 0x000002e3u, 0x000002e5u, + 0x0004003du, 0x00000006u, 0x000002e6u, 0x000002e3u, 0x000500b0u, 0x0000004cu, 0x000002e7u, 0x000002e6u, + 0x00000190u, 0x000300f7u, 0x000002e9u, 0x00000000u, 0x000400fau, 0x000002e7u, 0x000002e8u, 0x000002ebu, + 0x000200f8u, 0x000002e8u, 0x0004003du, 0x00000006u, 0x000002eau, 0x000002e3u, 0x0003003eu, 0x000002aeu, + 0x000002eau, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x000002e9u, 0x000200f8u, 0x000002ebu, + 0x0004003du, 0x00000006u, 0x000002ecu, 0x000002e3u, 0x00050082u, 0x00000006u, 0x000002edu, 0x000002ecu, + 0x00000190u, 0x0003003eu, 0x000002aeu, 0x000002edu, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x000002e9u, 0x000200f8u, 0x000002e9u, 0x000200f9u, 0x000002e2u, 0x000200f8u, 0x000002eeu, 0x0004003du, + 0x00000006u, 0x000002efu, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x000002f1u, 0x000002efu, 0x000002f0u, + 0x000300f7u, 0x000002f3u, 0x00000000u, 0x000400fau, 0x000002f1u, 0x000002f2u, 0x000002ffu, 0x000200f8u, + 0x000002f2u, 0x0003003eu, 0x000002adu, 0x00000158u, 0x0004003du, 0x00000006u, 0x000002f5u, 0x000002abu, + 0x00050082u, 0x00000006u, 0x000002f6u, 0x000002f5u, 0x000002dfu, 0x0003003eu, 0x000002f4u, 0x000002f6u, + 0x0004003du, 0x00000006u, 0x000002f7u, 0x000002f4u, 0x000500b0u, 0x0000004cu, 0x000002f8u, 0x000002f7u, + 0x00000158u, 0x000300f7u, 0x000002fau, 0x00000000u, 0x000400fau, 0x000002f8u, 0x000002f9u, 0x000002fcu, + 0x000200f8u, 0x000002f9u, 0x0004003du, 0x00000006u, 0x000002fbu, 0x000002f4u, 0x0003003eu, 0x000002aeu, + 0x000002fbu, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x000002fau, 0x000200f8u, 0x000002fcu, + 0x0004003du, 0x00000006u, 0x000002fdu, 0x000002f4u, 0x00050082u, 0x00000006u, 0x000002feu, 0x000002fdu, + 0x00000158u, 0x0003003eu, 0x000002aeu, 0x000002feu, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x000002fau, 0x000200f8u, 0x000002fau, 0x000200f9u, 0x000002f3u, 0x000200f8u, 0x000002ffu, 0x0004003du, + 0x00000006u, 0x00000300u, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x00000302u, 0x00000300u, 0x00000301u, + 0x000300f7u, 0x00000304u, 0x00000000u, 0x000400fau, 0x00000302u, 0x00000303u, 0x00000310u, 0x000200f8u, + 0x00000303u, 0x0003003eu, 0x000002adu, 0x00000190u, 0x0004003du, 0x00000006u, 0x00000306u, 0x000002abu, + 0x00050082u, 0x00000006u, 0x00000307u, 0x00000306u, 0x000002f0u, 0x0003003eu, 0x00000305u, 0x00000307u, + 0x0004003du, 0x00000006u, 0x00000308u, 0x00000305u, 0x000500b0u, 0x0000004cu, 0x00000309u, 0x00000308u, + 0x0000013eu, 0x000300f7u, 0x0000030bu, 0x00000000u, 0x000400fau, 0x00000309u, 0x0000030au, 0x0000030du, + 0x000200f8u, 0x0000030au, 0x0004003du, 0x00000006u, 0x0000030cu, 0x00000305u, 0x0003003eu, 0x000002aeu, + 0x0000030cu, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x0000030bu, 0x000200f8u, 0x0000030du, + 0x0004003du, 0x00000006u, 0x0000030eu, 0x00000305u, 0x00050082u, 0x00000006u, 0x0000030fu, 0x0000030eu, + 0x0000013eu, 0x0003003eu, 0x000002aeu, 0x0000030fu, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x0000030bu, 0x000200f8u, 0x0000030bu, 0x000200f9u, 0x00000304u, 0x000200f8u, 0x00000310u, 0x0004003du, + 0x00000006u, 0x00000311u, 0x000002abu, 0x000500b0u, 0x0000004cu, 0x00000313u, 0x00000311u, 0x00000312u, + 0x000300f7u, 0x00000315u, 0x00000000u, 0x000400fau, 0x00000313u, 0x00000314u, 0x00000321u, 0x000200f8u, + 0x00000314u, 0x0003003eu, 0x000002adu, 0x00000144u, 0x0004003du, 0x00000006u, 0x00000317u, 0x000002abu, + 0x00050082u, 0x00000006u, 0x00000318u, 0x00000317u, 0x00000301u, 0x0003003eu, 0x00000316u, 0x00000318u, + 0x0004003du, 0x00000006u, 0x00000319u, 0x00000316u, 0x000500b0u, 0x0000004cu, 0x0000031au, 0x00000319u, + 0x00000044u, 0x000300f7u, 0x0000031cu, 0x00000000u, 0x000400fau, 0x0000031au, 0x0000031bu, 0x0000031eu, + 0x000200f8u, 0x0000031bu, 0x0004003du, 0x00000006u, 0x0000031du, 0x00000316u, 0x0003003eu, 0x000002aeu, + 0x0000031du, 0x0003003eu, 0x000002afu, 0x00000246u, 0x000200f9u, 0x0000031cu, 0x000200f8u, 0x0000031eu, + 0x0004003du, 0x00000006u, 0x0000031fu, 0x00000316u, 0x00050082u, 0x00000006u, 0x00000320u, 0x0000031fu, + 0x00000044u, 0x0003003eu, 0x000002aeu, 0x00000320u, 0x0003003eu, 0x000002afu, 0x00000253u, 0x000200f9u, + 0x0000031cu, 0x000200f8u, 0x0000031cu, 0x000200f9u, 0x00000315u, 0x000200f8u, 0x00000321u, 0x0003003eu, + 0x000002adu, 0x000001f7u, 0x0003003eu, 0x000002aeu, 0x00000065u, 0x0003003eu, 0x000002afu, 0x00000246u, + 0x000200f9u, 0x00000315u, 0x000200f8u, 0x00000315u, 0x000200f9u, 0x00000304u, 0x000200f8u, 0x00000304u, + 0x000200f9u, 0x000002f3u, 0x000200f8u, 0x000002f3u, 0x000200f9u, 0x000002e2u, 0x000200f8u, 0x000002e2u, + 0x000200f9u, 0x000002d1u, 0x000200f8u, 0x000002d1u, 0x000200f9u, 0x000002c1u, 0x000200f8u, 0x000002c1u, + 0x000200f9u, 0x000002b3u, 0x000200f8u, 0x000002b3u, 0x0004003du, 0x0000004cu, 0x00000322u, 0x000002afu, + 0x000400a8u, 0x0000004cu, 0x00000323u, 0x00000322u, 0x000300f7u, 0x00000325u, 0x00000000u, 0x000400fau, + 0x00000323u, 0x00000324u, 0x0000033au, 0x000200f8u, 0x00000324u, 0x0004003du, 0x00000006u, 0x00000327u, + 0x000002adu, 0x00050041u, 0x00000018u, 0x00000328u, 0x000002a9u, 0x00000327u, 0x0004003du, 0x00000006u, + 0x00000329u, 0x00000328u, 0x0004003du, 0x00000006u, 0x0000032au, 0x000002aeu, 0x00050080u, 0x00000006u, + 0x0000032bu, 0x00000329u, 0x0000032au, 0x0003003eu, 0x00000326u, 0x0000032bu, 0x0004003du, 0x00000006u, + 0x0000032du, 0x000002adu, 0x00050041u, 0x00000018u, 0x0000032eu, 0x000002a9u, 0x0000032du, 0x0004003du, + 0x00000006u, 0x0000032fu, 0x0000032eu, 0x0004003du, 0x00000006u, 0x00000330u, 0x000002aeu, 0x00050080u, + 0x00000006u, 0x00000331u, 0x0000032fu, 0x00000330u, 0x00050080u, 0x00000006u, 0x00000332u, 0x00000331u, + 0x00000008u, 0x0003003eu, 0x0000032cu, 0x00000332u, 0x0004003du, 0x00000006u, 0x00000334u, 0x000002adu, + 0x00050080u, 0x00000006u, 0x00000335u, 0x00000334u, 0x00000008u, 0x00050041u, 0x00000018u, 0x00000336u, + 0x000002a9u, 0x00000335u, 0x0004003du, 0x00000006u, 0x00000337u, 0x00000336u, 0x0004003du, 0x00000006u, + 0x00000338u, 0x000002aeu, 0x00050080u, 0x00000006u, 0x00000339u, 0x00000337u, 0x00000338u, 0x0003003eu, + 0x00000333u, 0x00000339u, 0x000200f9u, 0x00000325u, 0x000200f8u, 0x0000033au, 0x0004003du, 0x00000006u, + 0x0000033bu, 0x000002adu, 0x00050041u, 0x00000018u, 0x0000033cu, 0x000002a9u, 0x0000033bu, 0x0004003du, + 0x00000006u, 0x0000033du, 0x0000033cu, 0x0004003du, 0x00000006u, 0x0000033eu, 0x000002aeu, 0x00050080u, + 0x00000006u, 0x0000033fu, 0x0000033du, 0x0000033eu, 0x00050080u, 0x00000006u, 0x00000340u, 0x0000033fu, + 0x00000008u, 0x0003003eu, 0x00000326u, 0x00000340u, 0x0004003du, 0x00000006u, 0x00000341u, 0x000002adu, + 0x00050080u, 0x00000006u, 0x00000342u, 0x00000341u, 0x00000008u, 0x00050041u, 0x00000018u, 0x00000343u, + 0x000002a9u, 0x00000342u, 0x0004003du, 0x00000006u, 0x00000344u, 0x00000343u, 0x0004003du, 0x00000006u, + 0x00000345u, 0x000002aeu, 0x00050080u, 0x00000006u, 0x00000346u, 0x00000344u, 0x00000345u, 0x00050080u, + 0x00000006u, 0x00000347u, 0x00000346u, 0x00000008u, 0x0003003eu, 0x0000032cu, 0x00000347u, 0x0004003du, + 0x00000006u, 0x00000348u, 0x000002adu, 0x00050080u, 0x00000006u, 0x00000349u, 0x00000348u, 0x00000008u, + 0x00050041u, 0x00000018u, 0x0000034au, 0x000002a9u, 0x00000349u, 0x0004003du, 0x00000006u, 0x0000034bu, + 0x0000034au, 0x0004003du, 0x00000006u, 0x0000034cu, 0x000002aeu, 0x00050080u, 0x00000006u, 0x0000034du, + 0x0000034bu, 0x0000034cu, 0x0003003eu, 0x00000333u, 0x0000034du, 0x000200f9u, 0x00000325u, 0x000200f8u, + 0x00000325u, 0x0004003du, 0x00000006u, 0x0000034eu, 0x00000326u, 0x0004003du, 0x00000006u, 0x0000034fu, + 0x0000032cu, 0x0004003du, 0x00000006u, 0x00000350u, 0x00000333u, 0x00060050u, 0x0000002eu, 0x00000351u, + 0x0000034eu, 0x0000034fu, 0x00000350u, 0x000200feu, 0x00000351u, 0x000200f8u, 0x0000023bu, 0x000100ffu, + 0x000200f8u, 0x00000226u, 0x000100ffu, 0x000200f8u, 0x0000021fu, 0x000100ffu, 0x00010038u, +}; + +static const uint32_t kSpv_ts_polygon_frag[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000041u, 0x00000000u, 0x00020011u, 0x00000001u, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x0009000fu, 0x00000004u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000cu, 0x00000016u, 0x0000002cu, + 0x00000038u, 0x00030010u, 0x00000004u, 0x00000007u, 0x00030010u, 0x00000004u, 0x00000009u, 0x00030003u, + 0x00000002u, 0x000001ccu, 0x000a0004u, 0x455f4c47u, 0x665f5458u, 0x6d676172u, 0x5f746e65u, 0x64616873u, + 0x625f7265u, 0x63797261u, 0x72746e65u, 0x00006369u, 0x00060004u, 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, + 0x64616873u, 0x00007265u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00040005u, 0x00000009u, + 0x6f6c6f63u, 0x00000072u, 0x00060005u, 0x0000000au, 0x6d697250u, 0x6f6c6f43u, 0x6f6c4272u, 0x00006b63u, + 0x00050006u, 0x0000000au, 0x00000000u, 0x6f6c6f63u, 0x00000072u, 0x00050006u, 0x0000000au, 0x00000001u, + 0x625f7369u, 0x00007665u, 0x00040005u, 0x0000000cu, 0x6d697270u, 0x006e695fu, 0x00060005u, 0x00000014u, + 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, 0x000a0006u, 0x00000014u, 0x00000000u, 0x69775f75u, + 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000014u, + 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, + 0x00000014u, 0x00000002u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, + 0x00000000u, 0x00090006u, 0x00000014u, 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, + 0x7665625fu, 0x00000000u, 0x00080006u, 0x00000014u, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, + 0x6d617266u, 0x00000065u, 0x00080006u, 0x00000014u, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, + 0x6163735fu, 0x0000656cu, 0x00070006u, 0x00000014u, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, + 0x00676e69u, 0x00090006u, 0x00000014u, 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, + 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x00000014u, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, + 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, 0x00000014u, 0x00000009u, 0x756e5f75u, 0x75715f6du, + 0x65697265u, 0x00000073u, 0x000a0006u, 0x00000014u, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, + 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, 0x000a0006u, 0x00000014u, 0x0000000bu, 0x616d5f75u, + 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x00000014u, + 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, + 0x00090006u, 0x00000014u, 0x0000000du, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, + 0x00656275u, 0x00080006u, 0x00000014u, 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, + 0x00656c61u, 0x00070006u, 0x00000014u, 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, + 0x00070006u, 0x00000014u, 0x00000010u, 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, + 0x00000014u, 0x00000011u, 0x75635f75u, 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, + 0x00000014u, 0x00000012u, 0x756e5f75u, 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, + 0x00000014u, 0x00000013u, 0x616d5f75u, 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, + 0x00090006u, 0x00000014u, 0x00000014u, 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, + 0x00000000u, 0x00070006u, 0x00000014u, 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, + 0x00070006u, 0x00000014u, 0x00000016u, 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, + 0x00000016u, 0x00006370u, 0x00050005u, 0x00000028u, 0x5f676f66u, 0x74636166u, 0x0000726fu, 0x00060005u, + 0x0000002cu, 0x465f6c67u, 0x43676172u, 0x64726f6fu, 0x00000000u, 0x00050005u, 0x00000038u, 0x5f74756fu, + 0x6f6c6f63u, 0x00000072u, 0x00030047u, 0x0000000au, 0x00000002u, 0x00040048u, 0x0000000au, 0x00000000u, + 0x00001497u, 0x00040048u, 0x0000000au, 0x00000001u, 0x00001497u, 0x00040047u, 0x0000000cu, 0x0000001eu, + 0x00000000u, 0x00030047u, 0x00000014u, 0x00000002u, 0x00050048u, 0x00000014u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x00000014u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000014u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000014u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x00000014u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000014u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x00000014u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x00000014u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000014u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x00000014u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000014u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000014u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x00000014u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000014u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x00000014u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x00000014u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x00000014u, 0x00000010u, 0x00000023u, + 0x00000040u, 0x00050048u, 0x00000014u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00050048u, 0x00000014u, + 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x00000014u, 0x00000013u, 0x00000023u, 0x0000004cu, + 0x00050048u, 0x00000014u, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, 0x00000014u, 0x00000015u, + 0x00000023u, 0x00000054u, 0x00050048u, 0x00000014u, 0x00000016u, 0x00000023u, 0x00000058u, 0x00040047u, + 0x0000002cu, 0x0000000bu, 0x0000000fu, 0x00040047u, 0x00000038u, 0x0000001eu, 0x00000000u, 0x00020013u, + 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00030016u, 0x00000006u, 0x00000020u, 0x00040017u, + 0x00000007u, 0x00000006u, 0x00000003u, 0x00040020u, 0x00000008u, 0x00000007u, 0x00000007u, 0x0004001eu, + 0x0000000au, 0x00000007u, 0x00000006u, 0x00040020u, 0x0000000bu, 0x00000001u, 0x0000000au, 0x0004003bu, + 0x0000000bu, 0x0000000cu, 0x00000001u, 0x00040015u, 0x0000000du, 0x00000020u, 0x00000001u, 0x0004002bu, + 0x0000000du, 0x0000000eu, 0x00000000u, 0x00040020u, 0x0000000fu, 0x00000001u, 0x00000007u, 0x00020014u, + 0x00000012u, 0x00040015u, 0x00000013u, 0x00000020u, 0x00000000u, 0x0019001eu, 0x00000014u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0000000du, 0x0000000du, + 0x00000013u, 0x00000006u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00000006u, 0x00000006u, 0x00000013u, + 0x00000013u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00000013u, 0x00040020u, 0x00000015u, + 0x00000009u, 0x00000014u, 0x0004003bu, 0x00000015u, 0x00000016u, 0x00000009u, 0x0004002bu, 0x0000000du, + 0x00000017u, 0x0000000fu, 0x00040020u, 0x00000018u, 0x00000009u, 0x00000006u, 0x0004002bu, 0x00000006u, + 0x0000001bu, 0x3f000000u, 0x0004002bu, 0x0000000du, 0x0000001fu, 0x00000001u, 0x00040020u, 0x00000020u, + 0x00000001u, 0x00000006u, 0x00040020u, 0x00000027u, 0x00000007u, 0x00000006u, 0x0004002bu, 0x00000006u, + 0x00000029u, 0x3f800000u, 0x00040017u, 0x0000002au, 0x00000006u, 0x00000004u, 0x00040020u, 0x0000002bu, + 0x00000001u, 0x0000002au, 0x0004003bu, 0x0000002bu, 0x0000002cu, 0x00000001u, 0x0004002bu, 0x00000013u, + 0x0000002du, 0x00000002u, 0x0004002bu, 0x00000006u, 0x00000032u, 0x00000000u, 0x00040020u, 0x00000037u, + 0x00000003u, 0x0000002au, 0x0004003bu, 0x00000037u, 0x00000038u, 0x00000003u, 0x00050036u, 0x00000002u, + 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000008u, 0x00000009u, + 0x00000007u, 0x0004003bu, 0x00000027u, 0x00000028u, 0x00000007u, 0x00050041u, 0x0000000fu, 0x00000010u, + 0x0000000cu, 0x0000000eu, 0x0004003du, 0x00000007u, 0x00000011u, 0x00000010u, 0x0003003eu, 0x00000009u, + 0x00000011u, 0x00050041u, 0x00000018u, 0x00000019u, 0x00000016u, 0x00000017u, 0x0004003du, 0x00000006u, + 0x0000001au, 0x00000019u, 0x000500bau, 0x00000012u, 0x0000001cu, 0x0000001au, 0x0000001bu, 0x000300f7u, + 0x0000001eu, 0x00000000u, 0x000400fau, 0x0000001cu, 0x0000001du, 0x0000001eu, 0x000200f8u, 0x0000001du, + 0x00050041u, 0x00000020u, 0x00000021u, 0x0000000cu, 0x0000001fu, 0x0004003du, 0x00000006u, 0x00000022u, + 0x00000021u, 0x000500b8u, 0x00000012u, 0x00000023u, 0x00000022u, 0x0000001bu, 0x000200f9u, 0x0000001eu, + 0x000200f8u, 0x0000001eu, 0x000700f5u, 0x00000012u, 0x00000024u, 0x0000001cu, 0x00000005u, 0x00000023u, + 0x0000001du, 0x000300f7u, 0x00000026u, 0x00000000u, 0x000400fau, 0x00000024u, 0x00000025u, 0x00000026u, + 0x000200f8u, 0x00000025u, 0x00050041u, 0x00000020u, 0x0000002eu, 0x0000002cu, 0x0000002du, 0x0004003du, + 0x00000006u, 0x0000002fu, 0x0000002eu, 0x00050083u, 0x00000006u, 0x00000030u, 0x00000029u, 0x0000002fu, + 0x0003003eu, 0x00000028u, 0x00000030u, 0x0004003du, 0x00000006u, 0x00000031u, 0x00000028u, 0x0008000cu, + 0x00000006u, 0x00000033u, 0x00000001u, 0x0000002bu, 0x00000031u, 0x00000032u, 0x00000029u, 0x0003003eu, + 0x00000028u, 0x00000033u, 0x0004003du, 0x00000006u, 0x00000034u, 0x00000028u, 0x0004003du, 0x00000007u, + 0x00000035u, 0x00000009u, 0x0005008eu, 0x00000007u, 0x00000036u, 0x00000035u, 0x00000034u, 0x0003003eu, + 0x00000009u, 0x00000036u, 0x000200f9u, 0x00000026u, 0x000200f8u, 0x00000026u, 0x0004003du, 0x00000007u, + 0x00000039u, 0x00000009u, 0x00060050u, 0x00000007u, 0x0000003au, 0x00000032u, 0x00000032u, 0x00000032u, + 0x00060050u, 0x00000007u, 0x0000003bu, 0x00000029u, 0x00000029u, 0x00000029u, 0x0008000cu, 0x00000007u, + 0x0000003cu, 0x00000001u, 0x0000002bu, 0x00000039u, 0x0000003au, 0x0000003bu, 0x00050051u, 0x00000006u, + 0x0000003du, 0x0000003cu, 0x00000000u, 0x00050051u, 0x00000006u, 0x0000003eu, 0x0000003cu, 0x00000001u, + 0x00050051u, 0x00000006u, 0x0000003fu, 0x0000003cu, 0x00000002u, 0x00070050u, 0x0000002au, 0x00000040u, + 0x0000003du, 0x0000003eu, 0x0000003fu, 0x00000029u, 0x0003003eu, 0x00000038u, 0x00000040u, 0x000100fdu, + 0x00010038u, +}; + +static const uint32_t kSpv_ts_obstacle_task[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x0000076au, 0x00000000u, 0x00020011u, 0x0000000bu, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x0016000fu, 0x000014f4u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00000375u, 0x0000037du, 0x00000398u, + 0x000003a8u, 0x000003c7u, 0x000003efu, 0x0000041fu, 0x00000516u, 0x000005bdu, 0x000005cbu, 0x000006fdu, + 0x00000751u, 0x00000756u, 0x0000075au, 0x0000075eu, 0x00000763u, 0x00000768u, 0x0006014bu, 0x00000004u, + 0x00000026u, 0x00000007u, 0x00000007u, 0x00000007u, 0x00030003u, 0x00000002u, 0x000001ccu, 0x00060004u, + 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, 0x000d0004u, 0x455f4c47u, 0x735f5458u, + 0x65646168u, 0x78655f72u, 0x63696c70u, 0x615f7469u, 0x68746972u, 0x6974656du, 0x79745f63u, 0x5f736570u, + 0x36746e69u, 0x00000034u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00070005u, 0x0000000eu, + 0x74617571u, 0x746f645fu, 0x34667628u, 0x3466763bu, 0x0000003bu, 0x00030005u, 0x0000000cu, 0x00000061u, + 0x00030005u, 0x0000000du, 0x00000062u, 0x00070005u, 0x00000012u, 0x74617571u, 0x726f6e5fu, 0x696c616du, + 0x7628657au, 0x003b3466u, 0x00030005u, 0x00000011u, 0x00000071u, 0x00080005u, 0x00000019u, 0x74617571u, + 0x656c735fu, 0x76287072u, 0x763b3466u, 0x663b3466u, 0x00003b31u, 0x00030005u, 0x00000016u, 0x00003071u, + 0x00030005u, 0x00000017u, 0x00003171u, 0x00030005u, 0x00000018u, 0x00000074u, 0x00070005u, 0x0000001fu, + 0x74617571u, 0x5f6f745fu, 0x7274616du, 0x76287869u, 0x003b3466u, 0x00030005u, 0x0000001eu, 0x00000071u, + 0x000a0005u, 0x00000027u, 0x6c697562u, 0x72745f64u, 0x66736e61u, 0x286d726fu, 0x3b336676u, 0x3b346676u, + 0x3b336676u, 0x00000000u, 0x00050005u, 0x00000024u, 0x6e617274u, 0x74616c73u, 0x006e6f69u, 0x00050005u, + 0x00000025u, 0x74617571u, 0x696e7265u, 0x00006e6fu, 0x00040005u, 0x00000026u, 0x6c616373u, 0x00000065u, + 0x000d0005u, 0x0000002fu, 0x6c6c7563u, 0x6870735fu, 0x5f657265u, 0x62626161u, 0x65766f5fu, 0x70616c72u, + 0x33667628u, 0x3b31663bu, 0x3b336676u, 0x3b336676u, 0x00000000u, 0x00040005u, 0x0000002bu, 0x746e6563u, + 0x00007265u, 0x00040005u, 0x0000002cu, 0x69646172u, 0x00007375u, 0x00040005u, 0x0000002du, 0x696d5f62u, + 0x0000006eu, 0x00040005u, 0x0000002eu, 0x616d5f62u, 0x00000078u, 0x00050005u, 0x00000031u, 0x656d6143u, + 0x6f506172u, 0x00006573u, 0x00070006u, 0x00000031u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, + 0x00617265u, 0x000e0005u, 0x00000035u, 0x5f746567u, 0x656d6163u, 0x775f6172u, 0x646c726fu, 0x736f705fu, + 0x72747328u, 0x2d746375u, 0x656d6143u, 0x6f506172u, 0x6d2d6573u, 0x31343466u, 0x0000003bu, 0x00040005u, + 0x00000034u, 0x65736f70u, 0x00000000u, 0x00060005u, 0x00000038u, 0x65685446u, 0x61436174u, 0x6172656du, + 0x00000000u, 0x00040006u, 0x00000038u, 0x00000000u, 0x00007863u, 0x00040006u, 0x00000038u, 0x00000001u, + 0x00007963u, 0x00050006u, 0x00000038u, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, 0x00000038u, + 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, 0x00000038u, 0x00000004u, 0x796c6f70u, 0x00000030u, + 0x00050006u, 0x00000038u, 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x00000038u, 0x00000006u, + 0x796c6f70u, 0x00000032u, 0x00050006u, 0x00000038u, 0x00000007u, 0x796c6f70u, 0x00000033u, 0x00050006u, + 0x00000038u, 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, 0x00000038u, 0x00000009u, 0x796c6f70u, + 0x00000035u, 0x00070006u, 0x00000038u, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, 0x00000065u, + 0x00080006u, 0x00000038u, 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, 0x00006c61u, + 0x00080006u, 0x00000038u, 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, 0x006c6176u, + 0x00060006u, 0x00000038u, 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, 0x00000038u, + 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, 0x00000038u, 0x0000000fu, 0x645f646cu, 0x00000000u, + 0x00050006u, 0x00000038u, 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x00000038u, 0x00000011u, + 0x665f646cu, 0x00000000u, 0x00220005u, 0x0000003fu, 0x69747365u, 0x6574616du, 0x6764655fu, 0x69645f65u, + 0x726f7473u, 0x6e6f6974u, 0x7869705fu, 0x5f736c65u, 0x3474616du, 0x33667628u, 0x3366763bu, 0x34666d3bu, + 0x74733b34u, 0x74637572u, 0x6854462du, 0x43617465u, 0x72656d61u, 0x31662d61u, 0x2d31662du, 0x662d3166u, + 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x3131662du, 0x0000003bu, 0x00030005u, 0x0000003bu, 0x00003076u, 0x00030005u, + 0x0000003cu, 0x00003176u, 0x00060005u, 0x0000003du, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00000000u, + 0x00030005u, 0x0000003eu, 0x006d6163u, 0x00250005u, 0x00000047u, 0x706d6f63u, 0x5f657475u, 0x64627573u, + 0x73697669u, 0x5f6e6f69u, 0x6576656cu, 0x6676286cu, 0x66763b33u, 0x74733b33u, 0x74637572u, 0x6d61432du, + 0x50617265u, 0x2d65736fu, 0x3434666du, 0x74733b31u, 0x74637572u, 0x6854462du, 0x43617465u, 0x72656d61u, + 0x31662d61u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x3131662du, 0x3b31663bu, 0x00000000u, + 0x00030005u, 0x00000042u, 0x00003076u, 0x00030005u, 0x00000043u, 0x00003176u, 0x00040005u, 0x00000044u, + 0x65736f70u, 0x00000000u, 0x00030005u, 0x00000045u, 0x006d6163u, 0x00070005u, 0x00000046u, 0x65726874u, + 0x6c6f6873u, 0x69705f64u, 0x736c6578u, 0x00000000u, 0x00030005u, 0x00000065u, 0x006e656cu, 0x00030005u, + 0x00000079u, 0x00000064u, 0x00040005u, 0x0000007au, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000007cu, + 0x61726170u, 0x0000006du, 0x00040005u, 0x00000091u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000094u, + 0x74656874u, 0x00305f61u, 0x00040005u, 0x00000099u, 0x74656874u, 0x00000061u, 0x00050005u, 0x0000009du, + 0x5f6e6973u, 0x74656874u, 0x00000061u, 0x00050005u, 0x000000a0u, 0x5f6e6973u, 0x74656874u, 0x00305f61u, + 0x00030005u, 0x000000a3u, 0x00003073u, 0x00030005u, 0x000000acu, 0x00003173u, 0x00040005u, 0x000000b7u, + 0x61726170u, 0x0000006du, 0x00030005u, 0x000000bbu, 0x00000078u, 0x00030005u, 0x000000beu, 0x00000079u, + 0x00030005u, 0x000000c1u, 0x0000007au, 0x00030005u, 0x000000c4u, 0x00000077u, 0x00030005u, 0x000000c7u, + 0x00003278u, 0x00030005u, 0x000000cbu, 0x00003279u, 0x00030005u, 0x000000cfu, 0x0000327au, 0x00030005u, + 0x000000d3u, 0x00007878u, 0x00030005u, 0x000000d7u, 0x00007978u, 0x00030005u, 0x000000dbu, 0x00007a78u, + 0x00030005u, 0x000000dfu, 0x00007979u, 0x00030005u, 0x000000e3u, 0x00007a79u, 0x00030005u, 0x000000e7u, + 0x00007a7au, 0x00030005u, 0x000000ebu, 0x00007877u, 0x00030005u, 0x000000efu, 0x00007977u, 0x00030005u, + 0x000000f3u, 0x00007a77u, 0x00030005u, 0x0000011cu, 0x00746f72u, 0x00040005u, 0x0000011du, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000120u, 0x75736572u, 0x0000746cu, 0x00040005u, 0x0000015du, 0x7261656eu, + 0x00747365u, 0x00030005u, 0x00000162u, 0x00000064u, 0x00030005u, 0x0000016fu, 0x00000052u, 0x00040005u, + 0x00000189u, 0x5f6d6163u, 0x00307470u, 0x00040005u, 0x00000192u, 0x5f6d6163u, 0x00317470u, 0x00050005u, + 0x0000019bu, 0x5f64696du, 0x6c726f77u, 0x00000064u, 0x00050005u, 0x000001a1u, 0x5f6d6163u, 0x6d5f7470u, + 0x00006469u, 0x00040005u, 0x000001aau, 0x74706564u, 0x00003068u, 0x00040005u, 0x000001afu, 0x74706564u, + 0x00003168u, 0x00050005u, 0x000001b3u, 0x74706564u, 0x696d5f68u, 0x00000064u, 0x00040005u, 0x000001b7u, + 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x000001bcu, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00050005u, + 0x000001c5u, 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, 0x000001cau, 0x68706c61u, 0x00000061u, + 0x00030005u, 0x000001cdu, 0x00003261u, 0x00040005u, 0x000001d1u, 0x746c6564u, 0x00000061u, 0x00040005u, + 0x0000020eu, 0x6c616373u, 0x00000065u, 0x00050005u, 0x0000021bu, 0x65786970u, 0x65725f6cu, 0x0000006cu, + 0x00050005u, 0x00000220u, 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00040005u, 0x0000023cu, 0x65786970u, + 0x0000306cu, 0x00040005u, 0x00000244u, 0x6e5f7978u, 0x006d726fu, 0x00050005u, 0x00000248u, 0x5f796172u, + 0x6d726f6eu, 0x00000000u, 0x00050005u, 0x00000251u, 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, + 0x00000256u, 0x68706c61u, 0x00000061u, 0x00030005u, 0x00000259u, 0x00003261u, 0x00040005u, 0x0000025du, + 0x746c6564u, 0x00000061u, 0x00040005u, 0x00000291u, 0x6c616373u, 0x00000065u, 0x00050005u, 0x0000029cu, + 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x000002a1u, 0x65786970u, 0x69645f6cu, 0x00007473u, + 0x00040005u, 0x000002b9u, 0x65786970u, 0x0000316cu, 0x00040005u, 0x000002c1u, 0x6e5f7978u, 0x006d726fu, + 0x00050005u, 0x000002c5u, 0x5f796172u, 0x6d726f6eu, 0x00000000u, 0x00050005u, 0x000002ceu, 0x5f736f63u, + 0x68706c61u, 0x00000061u, 0x00040005u, 0x000002d3u, 0x68706c61u, 0x00000061u, 0x00030005u, 0x000002d6u, + 0x00003261u, 0x00040005u, 0x000002dau, 0x746c6564u, 0x00000061u, 0x00040005u, 0x0000030eu, 0x6c616373u, + 0x00000065u, 0x00050005u, 0x00000319u, 0x65786970u, 0x65725f6cu, 0x0000006cu, 0x00050005u, 0x0000031eu, + 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00050005u, 0x00000336u, 0x65786970u, 0x696d5f6cu, 0x00000064u, + 0x00070005u, 0x0000033eu, 0x656e696cu, 0x705f7261u, 0x6c657869u, 0x64696d5fu, 0x00000000u, 0x00060005u, + 0x00000343u, 0x6f727265u, 0x69705f72u, 0x736c6578u, 0x00000000u, 0x00040005u, 0x0000034du, 0x6f727265u, + 0x00000072u, 0x00040005u, 0x0000034eu, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000350u, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000352u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000355u, 0x61726170u, + 0x0000006du, 0x00050005u, 0x00000371u, 0x7361745fu, 0x6f635f6bu, 0x00746e75u, 0x00040005u, 0x00000372u, + 0x6b726f77u, 0x0064695fu, 0x00060005u, 0x00000375u, 0x575f6c67u, 0x476b726fu, 0x70756f72u, 0x00004449u, + 0x00060005u, 0x00000379u, 0x72657571u, 0x64695f79u, 0x636f6c5fu, 0x00006c61u, 0x00060005u, 0x0000037bu, + 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, 0x000a0006u, 0x0000037bu, 0x00000000u, 0x69775f75u, + 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x0000037bu, + 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, + 0x0000037bu, 0x00000002u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, + 0x00000000u, 0x00090006u, 0x0000037bu, 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, + 0x7665625fu, 0x00000000u, 0x00080006u, 0x0000037bu, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, + 0x6d617266u, 0x00000065u, 0x00080006u, 0x0000037bu, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, + 0x6163735fu, 0x0000656cu, 0x00070006u, 0x0000037bu, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, + 0x00676e69u, 0x00090006u, 0x0000037bu, 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, + 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x0000037bu, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, + 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, 0x0000037bu, 0x00000009u, 0x756e5f75u, 0x75715f6du, + 0x65697265u, 0x00000073u, 0x000a0006u, 0x0000037bu, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, + 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, 0x000a0006u, 0x0000037bu, 0x0000000bu, 0x616d5f75u, + 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x0000037bu, + 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, + 0x00090006u, 0x0000037bu, 0x0000000du, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, + 0x00656275u, 0x00080006u, 0x0000037bu, 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, + 0x00656c61u, 0x00070006u, 0x0000037bu, 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, + 0x00070006u, 0x0000037bu, 0x00000010u, 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, + 0x0000037bu, 0x00000011u, 0x75635f75u, 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, + 0x0000037bu, 0x00000012u, 0x756e5f75u, 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, + 0x0000037bu, 0x00000013u, 0x616d5f75u, 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, + 0x00090006u, 0x0000037bu, 0x00000014u, 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, + 0x00000000u, 0x00070006u, 0x0000037bu, 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, + 0x00070006u, 0x0000037bu, 0x00000016u, 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, + 0x0000037du, 0x00006370u, 0x00070005u, 0x00000382u, 0x7473626fu, 0x656c6361u, 0x5f64695fu, 0x61636f6cu, + 0x0000006cu, 0x00050005u, 0x00000391u, 0x646e6552u, 0x75517265u, 0x00797265u, 0x00060006u, 0x00000391u, + 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, 0x00000391u, 0x00000001u, 0x656d6163u, + 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000391u, 0x00000002u, 0x656d6974u, 0x6d617473u, 0x73755f70u, + 0x00000000u, 0x00070006u, 0x00000391u, 0x00000003u, 0x656d6163u, 0x745f6172u, 0x5f657079u, 0x00006469u, + 0x00050006u, 0x00000391u, 0x00000004u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000391u, 0x00000005u, + 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000391u, 0x00000006u, 0x6461705fu, 0x00000033u, 0x00040005u, + 0x00000393u, 0x72657571u, 0x00000079u, 0x00050005u, 0x00000394u, 0x646e6552u, 0x75517265u, 0x00797265u, + 0x00060006u, 0x00000394u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, 0x00000394u, + 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000394u, 0x00000002u, 0x656d6974u, + 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x00000394u, 0x00000003u, 0x656d6163u, 0x745f6172u, + 0x5f657079u, 0x00006469u, 0x00050006u, 0x00000394u, 0x00000004u, 0x6461705fu, 0x00000031u, 0x00050006u, + 0x00000394u, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000394u, 0x00000006u, 0x6461705fu, + 0x00000033u, 0x00050005u, 0x00000396u, 0x72657551u, 0x66754279u, 0x00726566u, 0x00060006u, 0x00000396u, + 0x00000000u, 0x75715f67u, 0x65697265u, 0x00000073u, 0x00030005u, 0x00000398u, 0x00000000u, 0x00070005u, + 0x000003a0u, 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x000003a0u, + 0x00000000u, 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x000003a0u, + 0x00000001u, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, + 0x000003a0u, 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, + 0x000003a0u, 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, + 0x00070006u, 0x000003a0u, 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, + 0x000003a0u, 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, + 0x000003a0u, 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, + 0x00000000u, 0x00080006u, 0x000003a0u, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, + 0x00746573u, 0x00090006u, 0x000003a0u, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, + 0x74657366u, 0x00000000u, 0x00090006u, 0x000003a0u, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, + 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x000003a0u, 0x0000000au, 0x65736f70u, 0x6675625fu, + 0x5f726566u, 0x7366666fu, 0x00007465u, 0x00080006u, 0x000003a0u, 0x0000000bu, 0x616f6c66u, 0x75625f74u, + 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x000003a0u, 0x0000000cu, 0x6461705fu, 0x00000000u, + 0x00040005u, 0x000003a2u, 0x6e656373u, 0x00000065u, 0x00070005u, 0x000003a4u, 0x656d6954u, 0x6d617473u, + 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x000003a4u, 0x00000000u, 0x5f6d756eu, 0x796c6f70u, + 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x000003a4u, 0x00000001u, 0x796c6f70u, 0x656e696cu, + 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, 0x000003a4u, 0x00000002u, 0x5f6d756eu, + 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, 0x000003a4u, 0x00000003u, 0x796c6f70u, + 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00070006u, 0x000003a4u, 0x00000004u, + 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, 0x000003a4u, 0x00000005u, 0x65627563u, + 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, 0x000003a4u, 0x00000006u, 0x656d6974u, + 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00080006u, 0x000003a4u, + 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, 0x00746573u, 0x00090006u, 0x000003a4u, + 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, 0x00090006u, + 0x000003a4u, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, + 0x00080006u, 0x000003a4u, 0x0000000au, 0x65736f70u, 0x6675625fu, 0x5f726566u, 0x7366666fu, 0x00007465u, + 0x00080006u, 0x000003a4u, 0x0000000bu, 0x616f6c66u, 0x75625f74u, 0x72656666u, 0x66666f5fu, 0x00746573u, + 0x00050006u, 0x000003a4u, 0x0000000cu, 0x6461705fu, 0x00000000u, 0x00050005u, 0x000003a6u, 0x6e656353u, + 0x66754265u, 0x00726566u, 0x00060006u, 0x000003a6u, 0x00000000u, 0x63735f67u, 0x73656e65u, 0x00000000u, + 0x00030005u, 0x000003a8u, 0x00000000u, 0x00060005u, 0x000003c0u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, + 0x00000000u, 0x00060006u, 0x000003c0u, 0x00000000u, 0x5f6d756eu, 0x65627563u, 0x00000073u, 0x00070006u, + 0x000003c0u, 0x00000001u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00070006u, 0x000003c0u, + 0x00000002u, 0x5f6d756eu, 0x63617274u, 0x6f705f6bu, 0x00736573u, 0x00070006u, 0x000003c0u, 0x00000003u, + 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x000003c0u, 0x00000004u, 0x656d6974u, + 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00080006u, 0x000003c0u, 0x00000005u, 0x65627563u, + 0x5f73745fu, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x000003c0u, 0x00000006u, 0x63617274u, + 0x69745f6bu, 0x7473656du, 0x73706d61u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x000003c0u, 0x00000007u, + 0x6e617274u, 0x74616c73u, 0x736e6f69u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x000003c0u, 0x00000008u, + 0x74617571u, 0x696e7265u, 0x5f736e6fu, 0x7366666fu, 0x00007465u, 0x00070006u, 0x000003c0u, 0x00000009u, + 0x6c616373u, 0x6f5f7365u, 0x65736666u, 0x00000074u, 0x00070006u, 0x000003c0u, 0x0000000au, 0x6f6c6f63u, + 0x6f5f7372u, 0x65736666u, 0x00000074u, 0x00070006u, 0x000003c0u, 0x0000000bu, 0x646e6572u, 0x665f7265u, + 0x7367616cu, 0x00000000u, 0x00050006u, 0x000003c0u, 0x0000000cu, 0x6461705fu, 0x00000032u, 0x00050006u, + 0x000003c0u, 0x0000000du, 0x6461705fu, 0x00000033u, 0x00050006u, 0x000003c0u, 0x0000000eu, 0x6461705fu, + 0x00000034u, 0x00050006u, 0x000003c0u, 0x0000000fu, 0x6461705fu, 0x00000035u, 0x00040005u, 0x000003c2u, + 0x6c6f6f70u, 0x00000000u, 0x00060005u, 0x000003c3u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x00000000u, + 0x00060006u, 0x000003c3u, 0x00000000u, 0x5f6d756eu, 0x65627563u, 0x00000073u, 0x00070006u, 0x000003c3u, + 0x00000001u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00070006u, 0x000003c3u, 0x00000002u, + 0x5f6d756eu, 0x63617274u, 0x6f705f6bu, 0x00736573u, 0x00070006u, 0x000003c3u, 0x00000003u, 0x6d697270u, + 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x000003c3u, 0x00000004u, 0x656d6974u, 0x6d617473u, + 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00080006u, 0x000003c3u, 0x00000005u, 0x65627563u, 0x5f73745fu, + 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x000003c3u, 0x00000006u, 0x63617274u, 0x69745f6bu, + 0x7473656du, 0x73706d61u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x000003c3u, 0x00000007u, 0x6e617274u, + 0x74616c73u, 0x736e6f69u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x000003c3u, 0x00000008u, 0x74617571u, + 0x696e7265u, 0x5f736e6fu, 0x7366666fu, 0x00007465u, 0x00070006u, 0x000003c3u, 0x00000009u, 0x6c616373u, + 0x6f5f7365u, 0x65736666u, 0x00000074u, 0x00070006u, 0x000003c3u, 0x0000000au, 0x6f6c6f63u, 0x6f5f7372u, + 0x65736666u, 0x00000074u, 0x00070006u, 0x000003c3u, 0x0000000bu, 0x646e6572u, 0x665f7265u, 0x7367616cu, + 0x00000000u, 0x00050006u, 0x000003c3u, 0x0000000cu, 0x6461705fu, 0x00000032u, 0x00050006u, 0x000003c3u, + 0x0000000du, 0x6461705fu, 0x00000033u, 0x00050006u, 0x000003c3u, 0x0000000eu, 0x6461705fu, 0x00000034u, + 0x00050006u, 0x000003c3u, 0x0000000fu, 0x6461705fu, 0x00000035u, 0x00070005u, 0x000003c5u, 0x7473624fu, + 0x656c6361u, 0x6c6f6f50u, 0x66667542u, 0x00007265u, 0x00080006u, 0x000003c5u, 0x00000000u, 0x626f5f67u, + 0x63617473u, 0x705f656cu, 0x736c6f6fu, 0x00000000u, 0x00030005u, 0x000003c7u, 0x00000000u, 0x00070005u, + 0x000003d2u, 0x63726f66u, 0x657a5f65u, 0x745f6f72u, 0x736b7361u, 0x00000000u, 0x00050005u, 0x000003e7u, + 0x63617274u, 0x74735f6bu, 0x00747261u, 0x00050005u, 0x000003edu, 0x33746e49u, 0x66754232u, 0x00726566u, + 0x00050006u, 0x000003edu, 0x00000000u, 0x6e695f67u, 0x00323374u, 0x00030005u, 0x000003efu, 0x00000000u, + 0x00050005u, 0x000003fcu, 0x63617274u, 0x6e655f6bu, 0x00000064u, 0x00050005u, 0x00000407u, 0x63617274u, + 0x656c5f6bu, 0x0000006eu, 0x00060005u, 0x0000040fu, 0x63617274u, 0x73745f6bu, 0x7361625fu, 0x00000065u, + 0x00050005u, 0x00000418u, 0x67726174u, 0x745f7465u, 0x00000073u, 0x00050005u, 0x0000041bu, 0x73726966u, + 0x73745f74u, 0x00000000u, 0x00070005u, 0x0000041du, 0x656d6954u, 0x6d617473u, 0x75427370u, 0x72656666u, + 0x00000000u, 0x00070006u, 0x0000041du, 0x00000000u, 0x69745f67u, 0x7473656du, 0x73706d61u, 0x00000000u, + 0x00030005u, 0x0000041fu, 0x00000000u, 0x00040005u, 0x00000424u, 0x7473616cu, 0x0073745fu, 0x00070005u, + 0x0000042bu, 0x72747865u, 0x6c6f7061u, 0x5f657461u, 0x6f666562u, 0x00006572u, 0x00070005u, 0x0000042fu, + 0x72747865u, 0x6c6f7061u, 0x5f657461u, 0x65746661u, 0x00000072u, 0x00030005u, 0x00000436u, 0x00007464u, + 0x00030005u, 0x00000449u, 0x00007464u, 0x00040005u, 0x00000458u, 0x30786469u, 0x00000000u, 0x00040005u, + 0x00000459u, 0x31786469u, 0x00000000u, 0x00040005u, 0x0000045au, 0x68706c61u, 0x00000061u, 0x00030005u, + 0x00000463u, 0x00003074u, 0x00030005u, 0x00000467u, 0x00003174u, 0x00030005u, 0x00000485u, 0x00003074u, + 0x00030005u, 0x0000048cu, 0x00003174u, 0x00040005u, 0x000004a3u, 0x7466656cu, 0x00000000u, 0x00040005u, + 0x000004a4u, 0x68676972u, 0x00000074u, 0x00030005u, 0x000004b0u, 0x0064696du, 0x00030005u, 0x000004b5u, + 0x00003074u, 0x00030005u, 0x000004bcu, 0x00003174u, 0x00030005u, 0x000004e2u, 0x00003074u, 0x00030005u, + 0x000004e9u, 0x00003174u, 0x00050005u, 0x000004ffu, 0x6e617274u, 0x61625f73u, 0x00006573u, 0x00050005u, + 0x00000508u, 0x74617571u, 0x7361625fu, 0x00000065u, 0x00040005u, 0x00000512u, 0x6e617274u, 0x00003073u, + 0x00050005u, 0x00000514u, 0x616f6c46u, 0x66754274u, 0x00726566u, 0x00060006u, 0x00000514u, 0x00000000u, + 0x6c665f67u, 0x7374616fu, 0x00000000u, 0x00030005u, 0x00000516u, 0x00000000u, 0x00040005u, 0x00000530u, + 0x6e617274u, 0x00003173u, 0x00040005u, 0x00000549u, 0x74617571u, 0x00000030u, 0x00040005u, 0x0000056au, + 0x74617571u, 0x00000031u, 0x00060005u, 0x0000058bu, 0x6e617274u, 0x6e695f73u, 0x70726574u, 0x00000000u, + 0x00060005u, 0x00000591u, 0x68706c61u, 0x6c635f61u, 0x65706d61u, 0x00000064u, 0x00050005u, 0x00000594u, + 0x74617571u, 0x746e695fu, 0x00707265u, 0x00040005u, 0x00000595u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x00000597u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000599u, 0x61726170u, 0x0000006du, 0x00060005u, + 0x0000059cu, 0x6c616373u, 0x666f5f65u, 0x74657366u, 0x00000000u, 0x00050005u, 0x000005a5u, 0x6c616373u, + 0x6f6c5f65u, 0x006c6163u, 0x00040005u, 0x000005b8u, 0x6c6c7563u, 0x0000725fu, 0x00060005u, 0x000005b9u, + 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, 0x00040006u, 0x000005b9u, 0x00000000u, 0x00007863u, + 0x00040006u, 0x000005b9u, 0x00000001u, 0x00007963u, 0x00050006u, 0x000005b9u, 0x00000002u, 0x5f676d69u, + 0x00000077u, 0x00050006u, 0x000005b9u, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, 0x000005b9u, + 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, 0x000005b9u, 0x00000005u, 0x796c6f70u, 0x00000031u, + 0x00050006u, 0x000005b9u, 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x000005b9u, 0x00000007u, + 0x796c6f70u, 0x00000033u, 0x00050006u, 0x000005b9u, 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, + 0x000005b9u, 0x00000009u, 0x796c6f70u, 0x00000035u, 0x00070006u, 0x000005b9u, 0x0000000au, 0x5f78616du, + 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, 0x000005b9u, 0x0000000bu, 0x5f78616du, 0x74736964u, + 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, 0x000005b9u, 0x0000000cu, 0x5f78616du, 0x74736964u, + 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, 0x000005b9u, 0x0000000du, 0x74706564u, 0x616d5f68u, + 0x00000078u, 0x00050006u, 0x000005b9u, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, 0x000005b9u, + 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, 0x000005b9u, 0x00000010u, 0x655f646cu, 0x00000000u, + 0x00050006u, 0x000005b9u, 0x00000011u, 0x665f646cu, 0x00000000u, 0x00080005u, 0x000005bbu, 0x656d6143u, + 0x6e496172u, 0x6e697274u, 0x73636973u, 0x66667542u, 0x00007265u, 0x00080006u, 0x000005bbu, 0x00000000u, + 0x61635f67u, 0x6172656du, 0x746e695fu, 0x736e6972u, 0x00736369u, 0x00030005u, 0x000005bdu, 0x00000000u, + 0x00050005u, 0x000005c6u, 0x6c6c7563u, 0x736f705fu, 0x00000065u, 0x00050005u, 0x000005c7u, 0x656d6143u, + 0x6f506172u, 0x00006573u, 0x00070006u, 0x000005c7u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, + 0x00617265u, 0x00070005u, 0x000005c9u, 0x656d6143u, 0x6f506172u, 0x75426573u, 0x72656666u, 0x00000000u, + 0x00070006u, 0x000005c9u, 0x00000000u, 0x61635f67u, 0x6172656du, 0x736f705fu, 0x00007365u, 0x00030005u, + 0x000005cbu, 0x00000000u, 0x00040005u, 0x000005d1u, 0x5f6d6163u, 0x00736f70u, 0x00040005u, 0x000005d2u, + 0x61726170u, 0x0000006du, 0x00050005u, 0x000005d5u, 0x77656976u, 0x6e696d5fu, 0x00000000u, 0x00050005u, + 0x000005dau, 0x77656976u, 0x78616d5fu, 0x00000000u, 0x00040005u, 0x000005dfu, 0x69646172u, 0x00007375u, + 0x00040005u, 0x000005e2u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005e4u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x000005e6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005e8u, 0x61726170u, 0x0000006du, + 0x00060005u, 0x000005eeu, 0x5f6a626fu, 0x775f6f74u, 0x646c726fu, 0x00000000u, 0x00040005u, 0x000005f0u, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000005f2u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000005f4u, + 0x61726170u, 0x0000006du, 0x00060005u, 0x000005f6u, 0x6f6c6f63u, 0x666f5f72u, 0x74657366u, 0x00000000u, + 0x00040005u, 0x000005ffu, 0x6e6f7266u, 0x00000074u, 0x00040005u, 0x0000060cu, 0x6b636162u, 0x00000000u, + 0x00030005u, 0x0000061bu, 0x006d6163u, 0x00050005u, 0x00000622u, 0x77656976u, 0x736f705fu, 0x00000065u, + 0x00040005u, 0x00000627u, 0x69765f52u, 0x00007765u, 0x00050005u, 0x00000631u, 0x5f6d6163u, 0x6c726f77u, + 0x00000064u, 0x00040005u, 0x0000063fu, 0x626f5f52u, 0x0000006au, 0x00040005u, 0x00000648u, 0x73616d66u, + 0x0000006bu, 0x00030005u, 0x00000649u, 0x00000066u, 0x00040005u, 0x00000651u, 0x6f775f6eu, 0x00646c72u, + 0x00050005u, 0x0000065du, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00060005u, 0x00000661u, 0x746e6563u, + 0x6c5f7265u, 0x6c61636fu, 0x00000000u, 0x00050005u, 0x00000663u, 0x65646e69u, 0x6c626178u, 0x00000065u, + 0x00060005u, 0x00000669u, 0x746e6563u, 0x775f7265u, 0x646c726fu, 0x00000000u, 0x00050005u, 0x00000684u, + 0x5f78616du, 0x64627573u, 0x00007669u, 0x00030005u, 0x0000068au, 0x00000065u, 0x00050005u, 0x00000693u, + 0x6c5f3076u, 0x6c61636fu, 0x00000000u, 0x00050005u, 0x000006b2u, 0x65646e69u, 0x6c626178u, 0x00000065u, + 0x00050005u, 0x000006b6u, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, 0x000006bbu, 0x6c5f3176u, + 0x6c61636fu, 0x00000000u, 0x00050005u, 0x000006bdu, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, + 0x000006c0u, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, 0x000006c5u, 0x775f3076u, 0x646c726fu, + 0x00000000u, 0x00050005u, 0x000006ceu, 0x775f3176u, 0x646c726fu, 0x00000000u, 0x00040005u, 0x000006d7u, + 0x64627573u, 0x00007669u, 0x00040005u, 0x000006d8u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006dau, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000006dcu, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006deu, + 0x61726170u, 0x0000006du, 0x00040005u, 0x000006e0u, 0x61726170u, 0x0000006du, 0x00050005u, 0x000006edu, + 0x65726977u, 0x6d617266u, 0x00000065u, 0x00070005u, 0x000006fbu, 0x7473624fu, 0x656c6361u, 0x6b736154u, + 0x6c796150u, 0x0064616fu, 0x00060006u, 0x000006fbu, 0x00000000u, 0x72657571u, 0x64695f79u, 0x00000000u, + 0x00060006u, 0x000006fbu, 0x00000001u, 0x7473626fu, 0x656c6361u, 0x0064695fu, 0x00070006u, 0x000006fbu, + 0x00000002u, 0x656a626fu, 0x745f7463u, 0x6f775f6fu, 0x00646c72u, 0x00050006u, 0x000006fbu, 0x00000003u, + 0x6c616373u, 0x00000065u, 0x00060006u, 0x000006fbu, 0x00000004u, 0x6e6f7266u, 0x6f635f74u, 0x00726f6cu, + 0x00060006u, 0x000006fbu, 0x00000005u, 0x6b636162u, 0x6c6f635fu, 0x0000726fu, 0x00080006u, 0x000006fbu, + 0x00000006u, 0x64627573u, 0x73697669u, 0x5f6e6f69u, 0x6576656cu, 0x0000006cu, 0x00070006u, 0x000006fbu, + 0x00000007u, 0x646e6572u, 0x665f7265u, 0x7367616cu, 0x00000000u, 0x00050006u, 0x000006fbu, 0x00000008u, + 0x625f7369u, 0x00007665u, 0x00060006u, 0x000006fbu, 0x00000009u, 0x65636166u, 0x73616d5fu, 0x0000006bu, + 0x00040005u, 0x000006fdu, 0x6c796170u, 0x0064616fu, 0x00080005u, 0x0000074fu, 0x6f6c6f43u, 0x6c615072u, + 0x65747465u, 0x66667542u, 0x61457265u, 0x00796c72u, 0x00070006u, 0x0000074fu, 0x00000000u, 0x6f635f67u, + 0x5f726f6cu, 0x656c6170u, 0x00657474u, 0x00030005u, 0x00000751u, 0x00000000u, 0x00040005u, 0x00000752u, + 0x74726556u, 0x00007865u, 0x00040006u, 0x00000752u, 0x00000000u, 0x00000078u, 0x00040006u, 0x00000752u, + 0x00000001u, 0x00000079u, 0x00040006u, 0x00000752u, 0x00000002u, 0x0000007au, 0x00050006u, 0x00000752u, + 0x00000003u, 0x6461705fu, 0x00000000u, 0x00060005u, 0x00000754u, 0x74726556u, 0x75427865u, 0x72656666u, + 0x00000000u, 0x00060006u, 0x00000754u, 0x00000000u, 0x65765f67u, 0x63697472u, 0x00007365u, 0x00030005u, + 0x00000756u, 0x00000000u, 0x00060005u, 0x00000758u, 0x61697254u, 0x656c676eu, 0x66667542u, 0x00007265u, + 0x00060006u, 0x00000758u, 0x00000000u, 0x72745f67u, 0x676e6169u, 0x0073656cu, 0x00030005u, 0x0000075au, + 0x00000000u, 0x00050005u, 0x0000075cu, 0x65736f50u, 0x66667542u, 0x00007265u, 0x00050006u, 0x0000075cu, + 0x00000000u, 0x6f705f67u, 0x00736573u, 0x00030005u, 0x0000075eu, 0x00000000u, 0x00080005u, 0x0000075fu, + 0x656d6954u, 0x6d617473u, 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x0000075fu, + 0x00000000u, 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x0000075fu, 0x00000001u, + 0x5f6d756eu, 0x72726176u, 0x00737961u, 0x00070006u, 0x0000075fu, 0x00000002u, 0x5f6d756eu, 0x74726576u, + 0x73656369u, 0x00000000u, 0x00070006u, 0x0000075fu, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, + 0x00000000u, 0x00080006u, 0x0000075fu, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, + 0x00000074u, 0x00090006u, 0x0000075fu, 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, + 0x74657366u, 0x00000000u, 0x00080006u, 0x0000075fu, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, + 0x65736666u, 0x00000074u, 0x00070006u, 0x0000075fu, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, + 0x00746573u, 0x00060006u, 0x0000075fu, 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, + 0x0000075fu, 0x00000009u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x0000075fu, 0x0000000au, 0x6461705fu, + 0x00000032u, 0x00050006u, 0x0000075fu, 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x0000075fu, + 0x0000000cu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x0000075fu, 0x0000000du, 0x6461705fu, 0x00000035u, + 0x00050006u, 0x0000075fu, 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, 0x0000075fu, 0x0000000fu, + 0x6461705fu, 0x00000037u, 0x00070005u, 0x00000761u, 0x796c6f50u, 0x656e696cu, 0x6c6f6f50u, 0x66667542u, + 0x00007265u, 0x00080006u, 0x00000761u, 0x00000000u, 0x6f705f67u, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, + 0x00000000u, 0x00030005u, 0x00000763u, 0x00000000u, 0x00080005u, 0x00000764u, 0x656d6954u, 0x6d617473u, + 0x50646570u, 0x67796c6fu, 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x00000764u, 0x00000000u, 0x5f6d756eu, + 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000764u, 0x00000001u, 0x5f6d756eu, 0x72726176u, + 0x00737961u, 0x00070006u, 0x00000764u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, + 0x00070006u, 0x00000764u, 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, 0x00070006u, + 0x00000764u, 0x00000004u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x00000764u, + 0x00000005u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x00000764u, + 0x00000006u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, + 0x00000764u, 0x00000007u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x00000764u, 0x00000008u, 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x00000764u, + 0x00000009u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x00000764u, 0x0000000au, + 0x61697274u, 0x656c676eu, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, 0x00000764u, 0x0000000bu, + 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000764u, 0x0000000cu, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x00000764u, 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000764u, 0x0000000eu, + 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000764u, 0x0000000fu, 0x6461705fu, 0x00000034u, 0x00070005u, + 0x00000766u, 0x796c6f50u, 0x506e6f67u, 0x426c6f6fu, 0x65666675u, 0x00000072u, 0x00070006u, 0x00000766u, + 0x00000000u, 0x6f705f67u, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00030005u, 0x00000768u, 0x00000000u, + 0x00040047u, 0x00000375u, 0x0000000bu, 0x0000001au, 0x00030047u, 0x0000037bu, 0x00000002u, 0x00050048u, + 0x0000037bu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000037bu, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x0000037bu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000037bu, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000037bu, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x0000037bu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000037bu, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x0000037bu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x0000037bu, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000037bu, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x0000037bu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000037bu, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000037bu, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x0000037bu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000037bu, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x0000037bu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, + 0x0000037bu, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x0000037bu, 0x00000011u, 0x00000023u, + 0x00000044u, 0x00050048u, 0x0000037bu, 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x0000037bu, + 0x00000013u, 0x00000023u, 0x0000004cu, 0x00050048u, 0x0000037bu, 0x00000014u, 0x00000023u, 0x00000050u, + 0x00050048u, 0x0000037bu, 0x00000015u, 0x00000023u, 0x00000054u, 0x00050048u, 0x0000037bu, 0x00000016u, + 0x00000023u, 0x00000058u, 0x00050048u, 0x00000394u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, + 0x00000394u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000394u, 0x00000002u, 0x00000023u, + 0x00000008u, 0x00050048u, 0x00000394u, 0x00000003u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000394u, + 0x00000004u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000394u, 0x00000005u, 0x00000023u, 0x00000018u, + 0x00050048u, 0x00000394u, 0x00000006u, 0x00000023u, 0x0000001cu, 0x00040047u, 0x00000395u, 0x00000006u, + 0x00000020u, 0x00030047u, 0x00000396u, 0x00000002u, 0x00040048u, 0x00000396u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x00000396u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000398u, 0x00000018u, + 0x00040047u, 0x00000398u, 0x00000021u, 0x0000000du, 0x00040047u, 0x00000398u, 0x00000022u, 0x00000000u, + 0x00040047u, 0x000003a3u, 0x00000006u, 0x00000004u, 0x00050048u, 0x000003a4u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x000003a4u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000003a4u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x000003a4u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x000003a4u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x000003a4u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x000003a4u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x000003a4u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x000003a4u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x000003a4u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x000003a4u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x000003a4u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x000003a4u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00040047u, 0x000003a5u, 0x00000006u, + 0x00000080u, 0x00030047u, 0x000003a6u, 0x00000002u, 0x00040048u, 0x000003a6u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x000003a6u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000003a8u, 0x00000018u, + 0x00040047u, 0x000003a8u, 0x00000021u, 0x00000006u, 0x00040047u, 0x000003a8u, 0x00000022u, 0x00000000u, + 0x00050048u, 0x000003c3u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x000003c3u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x000003c3u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x000003c3u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x000003c3u, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x000003c3u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x000003c3u, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x000003c3u, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x000003c3u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x000003c3u, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x000003c3u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x000003c3u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x000003c3u, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00050048u, 0x000003c3u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x000003c3u, + 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x000003c3u, 0x0000000fu, 0x00000023u, 0x0000003cu, + 0x00040047u, 0x000003c4u, 0x00000006u, 0x00000040u, 0x00030047u, 0x000003c5u, 0x00000002u, 0x00040048u, + 0x000003c5u, 0x00000000u, 0x00000018u, 0x00050048u, 0x000003c5u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x000003c7u, 0x00000018u, 0x00040047u, 0x000003c7u, 0x00000021u, 0x00000009u, 0x00040047u, + 0x000003c7u, 0x00000022u, 0x00000000u, 0x00040047u, 0x000003ecu, 0x00000006u, 0x00000004u, 0x00030047u, + 0x000003edu, 0x00000002u, 0x00040048u, 0x000003edu, 0x00000000u, 0x00000018u, 0x00050048u, 0x000003edu, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000003efu, 0x00000018u, 0x00040047u, 0x000003efu, + 0x00000021u, 0x00000001u, 0x00040047u, 0x000003efu, 0x00000022u, 0x00000000u, 0x00040047u, 0x0000041cu, + 0x00000006u, 0x00000008u, 0x00030047u, 0x0000041du, 0x00000002u, 0x00040048u, 0x0000041du, 0x00000000u, + 0x00000018u, 0x00050048u, 0x0000041du, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000041fu, + 0x00000018u, 0x00040047u, 0x0000041fu, 0x00000021u, 0x00000000u, 0x00040047u, 0x0000041fu, 0x00000022u, + 0x00000000u, 0x00040047u, 0x00000513u, 0x00000006u, 0x00000004u, 0x00030047u, 0x00000514u, 0x00000002u, + 0x00040048u, 0x00000514u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000514u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x00000516u, 0x00000018u, 0x00040047u, 0x00000516u, 0x00000021u, 0x00000005u, + 0x00040047u, 0x00000516u, 0x00000022u, 0x00000000u, 0x00050048u, 0x000005b9u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x000005b9u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x000005b9u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x000005b9u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x000005b9u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x000005b9u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x000005b9u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x000005b9u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x000005b9u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x000005b9u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x000005b9u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x000005b9u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x000005b9u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x000005b9u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x000005b9u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x000005b9u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x000005b9u, 0x00000010u, 0x00000023u, + 0x00000040u, 0x00050048u, 0x000005b9u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00040047u, 0x000005bau, + 0x00000006u, 0x00000048u, 0x00030047u, 0x000005bbu, 0x00000002u, 0x00040048u, 0x000005bbu, 0x00000000u, + 0x00000018u, 0x00050048u, 0x000005bbu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000005bdu, + 0x00000018u, 0x00040047u, 0x000005bdu, 0x00000021u, 0x0000000bu, 0x00040047u, 0x000005bdu, 0x00000022u, + 0x00000000u, 0x00040048u, 0x000005c7u, 0x00000000u, 0x00000005u, 0x00050048u, 0x000005c7u, 0x00000000u, + 0x00000007u, 0x00000010u, 0x00050048u, 0x000005c7u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00040047u, + 0x000005c8u, 0x00000006u, 0x00000040u, 0x00030047u, 0x000005c9u, 0x00000002u, 0x00040048u, 0x000005c9u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x000005c9u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x000005cbu, 0x00000018u, 0x00040047u, 0x000005cbu, 0x00000021u, 0x0000000cu, 0x00040047u, 0x000005cbu, + 0x00000022u, 0x00000000u, 0x00030047u, 0x0000065du, 0x00000018u, 0x00030047u, 0x00000663u, 0x00000018u, + 0x00030047u, 0x000006b2u, 0x00000018u, 0x00030047u, 0x000006b6u, 0x00000018u, 0x00030047u, 0x000006bdu, + 0x00000018u, 0x00030047u, 0x000006c0u, 0x00000018u, 0x00040047u, 0x0000074eu, 0x00000006u, 0x00000010u, + 0x00030047u, 0x0000074fu, 0x00000002u, 0x00040048u, 0x0000074fu, 0x00000000u, 0x00000018u, 0x00050048u, + 0x0000074fu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000751u, 0x00000018u, 0x00040047u, + 0x00000751u, 0x00000021u, 0x0000000au, 0x00040047u, 0x00000751u, 0x00000022u, 0x00000000u, 0x00050048u, + 0x00000752u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000752u, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x00000752u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000752u, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00040047u, 0x00000753u, 0x00000006u, 0x00000010u, 0x00030047u, + 0x00000754u, 0x00000002u, 0x00040048u, 0x00000754u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000754u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000756u, 0x00000018u, 0x00040047u, 0x00000756u, + 0x00000021u, 0x00000002u, 0x00040047u, 0x00000756u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000757u, + 0x00000006u, 0x00000010u, 0x00030047u, 0x00000758u, 0x00000002u, 0x00040048u, 0x00000758u, 0x00000000u, + 0x00000018u, 0x00050048u, 0x00000758u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000075au, + 0x00000018u, 0x00040047u, 0x0000075au, 0x00000021u, 0x00000003u, 0x00040047u, 0x0000075au, 0x00000022u, + 0x00000000u, 0x00040047u, 0x0000075bu, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000075cu, 0x00000002u, + 0x00040048u, 0x0000075cu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000075cu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000075eu, 0x00000018u, 0x00040047u, 0x0000075eu, 0x00000021u, 0x00000004u, + 0x00040047u, 0x0000075eu, 0x00000022u, 0x00000000u, 0x00050048u, 0x0000075fu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x0000075fu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x0000075fu, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000075fu, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x0000075fu, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000075fu, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x0000075fu, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x0000075fu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x0000075fu, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x0000075fu, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x0000075fu, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000075fu, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x0000075fu, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x0000075fu, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x0000075fu, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x0000075fu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x00000760u, 0x00000006u, 0x00000040u, + 0x00030047u, 0x00000761u, 0x00000002u, 0x00040048u, 0x00000761u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x00000761u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000763u, 0x00000018u, 0x00040047u, + 0x00000763u, 0x00000021u, 0x00000007u, 0x00040047u, 0x00000763u, 0x00000022u, 0x00000000u, 0x00050048u, + 0x00000764u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000764u, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x00000764u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000764u, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000764u, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x00000764u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000764u, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x00000764u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x00000764u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000764u, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x00000764u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000764u, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000764u, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x00000764u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000764u, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x00000764u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, + 0x00000765u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000766u, 0x00000002u, 0x00040048u, 0x00000766u, + 0x00000000u, 0x00000018u, 0x00050048u, 0x00000766u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x00000768u, 0x00000018u, 0x00040047u, 0x00000768u, 0x00000021u, 0x00000008u, 0x00040047u, 0x00000768u, + 0x00000022u, 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00040015u, + 0x00000006u, 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000006u, 0x00000007u, 0x00000001u, 0x00030016u, + 0x00000008u, 0x00000020u, 0x00040017u, 0x00000009u, 0x00000008u, 0x00000004u, 0x00040020u, 0x0000000au, + 0x00000007u, 0x00000009u, 0x00050021u, 0x0000000bu, 0x00000008u, 0x0000000au, 0x0000000au, 0x00040021u, + 0x00000010u, 0x00000009u, 0x0000000au, 0x00040020u, 0x00000014u, 0x00000007u, 0x00000008u, 0x00060021u, + 0x00000015u, 0x00000009u, 0x0000000au, 0x0000000au, 0x00000014u, 0x00040017u, 0x0000001bu, 0x00000008u, + 0x00000003u, 0x00040018u, 0x0000001cu, 0x0000001bu, 0x00000003u, 0x00040021u, 0x0000001du, 0x0000001cu, + 0x0000000au, 0x00040020u, 0x00000021u, 0x00000007u, 0x0000001bu, 0x00040018u, 0x00000022u, 0x00000009u, + 0x00000004u, 0x00060021u, 0x00000023u, 0x00000022u, 0x00000021u, 0x0000000au, 0x00000021u, 0x00020014u, + 0x00000029u, 0x00070021u, 0x0000002au, 0x00000029u, 0x00000021u, 0x00000014u, 0x00000021u, 0x00000021u, + 0x0003001eu, 0x00000031u, 0x00000022u, 0x00040020u, 0x00000032u, 0x00000007u, 0x00000031u, 0x00040021u, + 0x00000033u, 0x0000001bu, 0x00000032u, 0x00040020u, 0x00000037u, 0x00000007u, 0x00000022u, 0x0014001eu, + 0x00000038u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, + 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, + 0x00000008u, 0x00000008u, 0x00000008u, 0x00040020u, 0x00000039u, 0x00000007u, 0x00000038u, 0x00070021u, + 0x0000003au, 0x00000008u, 0x00000021u, 0x00000021u, 0x00000037u, 0x00000039u, 0x00080021u, 0x00000041u, + 0x00000006u, 0x00000021u, 0x00000021u, 0x00000032u, 0x00000039u, 0x00000014u, 0x0004002bu, 0x00000006u, + 0x00000049u, 0x00000000u, 0x0004002bu, 0x00000006u, 0x00000055u, 0x00000002u, 0x0004002bu, 0x00000006u, + 0x0000005cu, 0x00000003u, 0x0004002bu, 0x00000008u, 0x00000069u, 0x2edbe6ffu, 0x0004002bu, 0x00000008u, + 0x00000073u, 0x00000000u, 0x0004002bu, 0x00000008u, 0x00000074u, 0x3f800000u, 0x0007002cu, 0x00000009u, + 0x00000075u, 0x00000073u, 0x00000073u, 0x00000073u, 0x00000074u, 0x0004002bu, 0x00000008u, 0x00000088u, + 0x3f7fdf3bu, 0x0004002bu, 0x00000008u, 0x00000096u, 0xbf800000u, 0x00040020u, 0x0000011bu, 0x00000007u, + 0x0000001cu, 0x00040015u, 0x00000121u, 0x00000020u, 0x00000001u, 0x0004002bu, 0x00000121u, 0x00000122u, + 0x00000000u, 0x0004002bu, 0x00000121u, 0x0000012cu, 0x00000001u, 0x0004002bu, 0x00000121u, 0x00000136u, + 0x00000002u, 0x0004002bu, 0x00000121u, 0x00000182u, 0x00000003u, 0x0004002bu, 0x00000008u, 0x0000019fu, + 0x3f000000u, 0x0004002bu, 0x00000008u, 0x000001adu, 0x3a83126fu, 0x00040017u, 0x000001b8u, 0x00000008u, + 0x00000002u, 0x0004002bu, 0x00000121u, 0x000001d2u, 0x00000004u, 0x0004002bu, 0x00000121u, 0x000001d5u, + 0x00000005u, 0x0004002bu, 0x00000121u, 0x000001dbu, 0x00000006u, 0x0004002bu, 0x00000121u, 0x000001e1u, + 0x00000007u, 0x0004002bu, 0x00000121u, 0x000001e9u, 0x00000008u, 0x0004002bu, 0x00000121u, 0x000001f1u, + 0x00000009u, 0x0004002bu, 0x00000121u, 0x000001fcu, 0x0000000au, 0x0004002bu, 0x00000121u, 0x00000202u, + 0x0000000bu, 0x0004002bu, 0x00000121u, 0x00000209u, 0x0000000cu, 0x0004002bu, 0x00000008u, 0x00000210u, + 0x358637bdu, 0x00040020u, 0x0000021au, 0x00000007u, 0x000001b8u, 0x0004002bu, 0x00000121u, 0x00000221u, + 0x0000000eu, 0x0004002bu, 0x00000121u, 0x00000227u, 0x0000000fu, 0x0004002bu, 0x00000121u, 0x0000022eu, + 0x00000010u, 0x0004002bu, 0x00000121u, 0x00000234u, 0x00000011u, 0x0004002bu, 0x00000008u, 0x00000349u, + 0x461c4000u, 0x0004002bu, 0x00000008u, 0x00000360u, 0x40000000u, 0x0004002bu, 0x00000008u, 0x00000368u, + 0x40800000u, 0x00040020u, 0x00000370u, 0x00000007u, 0x00000006u, 0x00040017u, 0x00000373u, 0x00000006u, + 0x00000003u, 0x00040020u, 0x00000374u, 0x00000001u, 0x00000373u, 0x0004003bu, 0x00000374u, 0x00000375u, + 0x00000001u, 0x00040020u, 0x00000376u, 0x00000001u, 0x00000006u, 0x0019001eu, 0x0000037bu, 0x00000008u, + 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000121u, 0x00000121u, + 0x00000006u, 0x00000008u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000008u, 0x00000008u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x0000037cu, + 0x00000009u, 0x0000037bu, 0x0004003bu, 0x0000037cu, 0x0000037du, 0x00000009u, 0x00040020u, 0x0000037eu, + 0x00000009u, 0x00000006u, 0x00040015u, 0x00000390u, 0x00000040u, 0x00000001u, 0x0009001eu, 0x00000391u, + 0x00000006u, 0x00000006u, 0x00000390u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, + 0x00000392u, 0x00000007u, 0x00000391u, 0x0009001eu, 0x00000394u, 0x00000006u, 0x00000006u, 0x00000390u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x00000395u, 0x00000394u, 0x0003001eu, + 0x00000396u, 0x00000395u, 0x00040020u, 0x00000397u, 0x0000000cu, 0x00000396u, 0x0004003bu, 0x00000397u, + 0x00000398u, 0x0000000cu, 0x00040020u, 0x0000039au, 0x0000000cu, 0x00000394u, 0x0004002bu, 0x00000006u, + 0x0000039eu, 0x00000014u, 0x0004001cu, 0x0000039fu, 0x00000006u, 0x0000039eu, 0x000f001eu, 0x000003a0u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0000039fu, 0x00040020u, 0x000003a1u, 0x00000007u, + 0x000003a0u, 0x0004001cu, 0x000003a3u, 0x00000006u, 0x0000039eu, 0x000f001eu, 0x000003a4u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x000003a3u, 0x0003001du, 0x000003a5u, 0x000003a4u, 0x0003001eu, + 0x000003a6u, 0x000003a5u, 0x00040020u, 0x000003a7u, 0x0000000cu, 0x000003a6u, 0x0004003bu, 0x000003a7u, + 0x000003a8u, 0x0000000cu, 0x00040020u, 0x000003abu, 0x0000000cu, 0x000003a4u, 0x0012001eu, 0x000003c0u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00040020u, 0x000003c1u, 0x00000007u, 0x000003c0u, 0x0012001eu, 0x000003c3u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x000003c4u, + 0x000003c3u, 0x0003001eu, 0x000003c5u, 0x000003c4u, 0x00040020u, 0x000003c6u, 0x0000000cu, 0x000003c5u, + 0x0004003bu, 0x000003c6u, 0x000003c7u, 0x0000000cu, 0x00040020u, 0x000003cdu, 0x0000000cu, 0x000003c3u, + 0x00040020u, 0x000003d1u, 0x00000007u, 0x00000029u, 0x0003002au, 0x00000029u, 0x000003d3u, 0x00030029u, + 0x00000029u, 0x000003dau, 0x0004002bu, 0x00000006u, 0x000003ddu, 0x00000006u, 0x0003001du, 0x000003ecu, + 0x00000121u, 0x0003001eu, 0x000003edu, 0x000003ecu, 0x00040020u, 0x000003eeu, 0x0000000cu, 0x000003edu, + 0x0004003bu, 0x000003eeu, 0x000003efu, 0x0000000cu, 0x00040020u, 0x000003f8u, 0x0000000cu, 0x00000121u, + 0x00040020u, 0x00000417u, 0x00000007u, 0x00000390u, 0x0003001du, 0x0000041cu, 0x00000390u, 0x0003001eu, + 0x0000041du, 0x0000041cu, 0x00040020u, 0x0000041eu, 0x0000000cu, 0x0000041du, 0x0004003bu, 0x0000041eu, + 0x0000041fu, 0x0000000cu, 0x00040020u, 0x00000421u, 0x0000000cu, 0x00000390u, 0x00040020u, 0x0000043bu, + 0x00000009u, 0x00000121u, 0x00040020u, 0x00000457u, 0x00000007u, 0x00000121u, 0x0004002bu, 0x00000006u, + 0x0000050fu, 0x00000004u, 0x0003001du, 0x00000513u, 0x00000008u, 0x0003001eu, 0x00000514u, 0x00000513u, + 0x00040020u, 0x00000515u, 0x0000000cu, 0x00000514u, 0x0004003bu, 0x00000515u, 0x00000516u, 0x0000000cu, + 0x00040020u, 0x0000051cu, 0x0000000cu, 0x00000008u, 0x00040020u, 0x000005b2u, 0x00000009u, 0x00000008u, + 0x0014001eu, 0x000005b9u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, + 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, + 0x00000008u, 0x00000008u, 0x00000008u, 0x00000008u, 0x0003001du, 0x000005bau, 0x000005b9u, 0x0003001eu, + 0x000005bbu, 0x000005bau, 0x00040020u, 0x000005bcu, 0x0000000cu, 0x000005bbu, 0x0004003bu, 0x000005bcu, + 0x000005bdu, 0x0000000cu, 0x0004002bu, 0x00000121u, 0x000005c0u, 0x0000000du, 0x0003001eu, 0x000005c7u, + 0x00000022u, 0x0003001du, 0x000005c8u, 0x000005c7u, 0x0003001eu, 0x000005c9u, 0x000005c8u, 0x00040020u, + 0x000005cau, 0x0000000cu, 0x000005c9u, 0x0004003bu, 0x000005cau, 0x000005cbu, 0x0000000cu, 0x00040020u, + 0x000005cdu, 0x0000000cu, 0x000005c7u, 0x0006002cu, 0x0000001bu, 0x000005efu, 0x00000074u, 0x00000074u, + 0x00000074u, 0x0004002bu, 0x00000006u, 0x00000616u, 0x00000005u, 0x00040020u, 0x0000061eu, 0x0000000cu, + 0x000005b9u, 0x0004001cu, 0x00000653u, 0x0000001bu, 0x000003ddu, 0x0006002cu, 0x0000001bu, 0x00000654u, + 0x00000073u, 0x00000073u, 0x00000096u, 0x0006002cu, 0x0000001bu, 0x00000655u, 0x00000073u, 0x00000073u, + 0x00000074u, 0x0006002cu, 0x0000001bu, 0x00000656u, 0x00000096u, 0x00000073u, 0x00000073u, 0x0006002cu, + 0x0000001bu, 0x00000657u, 0x00000074u, 0x00000073u, 0x00000073u, 0x0006002cu, 0x0000001bu, 0x00000658u, + 0x00000073u, 0x00000096u, 0x00000073u, 0x0006002cu, 0x0000001bu, 0x00000659u, 0x00000073u, 0x00000074u, + 0x00000073u, 0x0009002cu, 0x00000653u, 0x0000065au, 0x00000654u, 0x00000655u, 0x00000656u, 0x00000657u, + 0x00000658u, 0x00000659u, 0x00040020u, 0x0000065cu, 0x00000007u, 0x00000653u, 0x0004002bu, 0x00000006u, + 0x00000691u, 0x0000000cu, 0x0004002bu, 0x00000006u, 0x00000694u, 0x00000008u, 0x0004001cu, 0x00000695u, + 0x0000001bu, 0x00000694u, 0x0004002bu, 0x00000008u, 0x00000696u, 0xbf000000u, 0x0006002cu, 0x0000001bu, + 0x00000697u, 0x00000696u, 0x00000696u, 0x00000696u, 0x0006002cu, 0x0000001bu, 0x00000698u, 0x0000019fu, + 0x00000696u, 0x00000696u, 0x0006002cu, 0x0000001bu, 0x00000699u, 0x0000019fu, 0x0000019fu, 0x00000696u, + 0x0006002cu, 0x0000001bu, 0x0000069au, 0x00000696u, 0x0000019fu, 0x00000696u, 0x0006002cu, 0x0000001bu, + 0x0000069bu, 0x00000696u, 0x00000696u, 0x0000019fu, 0x0006002cu, 0x0000001bu, 0x0000069cu, 0x0000019fu, + 0x00000696u, 0x0000019fu, 0x0006002cu, 0x0000001bu, 0x0000069du, 0x0000019fu, 0x0000019fu, 0x0000019fu, + 0x0006002cu, 0x0000001bu, 0x0000069eu, 0x00000696u, 0x0000019fu, 0x0000019fu, 0x000b002cu, 0x00000695u, + 0x0000069fu, 0x00000697u, 0x00000698u, 0x00000699u, 0x0000069au, 0x0000069bu, 0x0000069cu, 0x0000069du, + 0x0000069eu, 0x00040017u, 0x000006a0u, 0x00000006u, 0x00000002u, 0x0004001cu, 0x000006a1u, 0x000006a0u, + 0x00000691u, 0x0005002cu, 0x000006a0u, 0x000006a2u, 0x00000049u, 0x00000007u, 0x0005002cu, 0x000006a0u, + 0x000006a3u, 0x00000007u, 0x00000055u, 0x0005002cu, 0x000006a0u, 0x000006a4u, 0x00000055u, 0x0000005cu, + 0x0005002cu, 0x000006a0u, 0x000006a5u, 0x0000005cu, 0x00000049u, 0x0005002cu, 0x000006a0u, 0x000006a6u, + 0x0000050fu, 0x00000616u, 0x0005002cu, 0x000006a0u, 0x000006a7u, 0x00000616u, 0x000003ddu, 0x0004002bu, + 0x00000006u, 0x000006a8u, 0x00000007u, 0x0005002cu, 0x000006a0u, 0x000006a9u, 0x000003ddu, 0x000006a8u, + 0x0005002cu, 0x000006a0u, 0x000006aau, 0x000006a8u, 0x0000050fu, 0x0005002cu, 0x000006a0u, 0x000006abu, + 0x00000049u, 0x0000050fu, 0x0005002cu, 0x000006a0u, 0x000006acu, 0x00000007u, 0x00000616u, 0x0005002cu, + 0x000006a0u, 0x000006adu, 0x00000055u, 0x000003ddu, 0x0005002cu, 0x000006a0u, 0x000006aeu, 0x0000005cu, + 0x000006a8u, 0x000f002cu, 0x000006a1u, 0x000006afu, 0x000006a2u, 0x000006a3u, 0x000006a4u, 0x000006a5u, + 0x000006a6u, 0x000006a7u, 0x000006a9u, 0x000006aau, 0x000006abu, 0x000006acu, 0x000006adu, 0x000006aeu, + 0x00040020u, 0x000006b1u, 0x00000007u, 0x000006a1u, 0x00040020u, 0x000006b5u, 0x00000007u, 0x00000695u, + 0x000c001eu, 0x000006fbu, 0x00000006u, 0x00000006u, 0x00000022u, 0x0000001bu, 0x0000001bu, 0x0000001bu, + 0x00000006u, 0x00000006u, 0x00000008u, 0x00000006u, 0x00040020u, 0x000006fcu, 0x0000151au, 0x000006fbu, + 0x0004003bu, 0x000006fcu, 0x000006fdu, 0x0000151au, 0x00040020u, 0x000006ffu, 0x0000151au, 0x00000006u, + 0x00040020u, 0x00000704u, 0x0000151au, 0x00000022u, 0x00040020u, 0x00000707u, 0x0000151au, 0x0000001bu, + 0x00040020u, 0x00000716u, 0x0000151au, 0x00000008u, 0x0004002bu, 0x00000006u, 0x0000071cu, 0x00000009u, + 0x0004002bu, 0x00000006u, 0x0000071du, 0x0000000au, 0x0004002bu, 0x00000006u, 0x0000071eu, 0x0000000bu, + 0x0004002bu, 0x00000006u, 0x0000071fu, 0x0000000du, 0x0004002bu, 0x00000006u, 0x00000720u, 0x0000000eu, + 0x0004002bu, 0x00000006u, 0x00000721u, 0x0000000fu, 0x0004002bu, 0x00000006u, 0x00000722u, 0x00000010u, + 0x0004002bu, 0x00000006u, 0x00000723u, 0x00000011u, 0x0004002bu, 0x00000006u, 0x00000724u, 0x00000012u, + 0x0004002bu, 0x00000006u, 0x00000725u, 0x00000013u, 0x0004002bu, 0x00000006u, 0x00000726u, 0x00000015u, + 0x0004002bu, 0x00000008u, 0x00000727u, 0x3f7dfdfeu, 0x0004002bu, 0x00000008u, 0x00000728u, 0x3b808081u, + 0x0004002bu, 0x00000008u, 0x00000729u, 0x3f68e8e9u, 0x0006002cu, 0x0000001bu, 0x0000072au, 0x00000727u, + 0x00000728u, 0x00000729u, 0x0004002bu, 0x00000008u, 0x0000072bu, 0x3ec4c4c5u, 0x0004002bu, 0x00000008u, + 0x0000072cu, 0x3f37b7b8u, 0x0004002bu, 0x00000008u, 0x0000072du, 0x3f79f9fau, 0x0006002cu, 0x0000001bu, + 0x0000072eu, 0x0000072bu, 0x0000072cu, 0x0000072du, 0x0004002bu, 0x00000008u, 0x0000072fu, 0x3f0b8b8cu, + 0x0004002bu, 0x00000008u, 0x00000730u, 0x3ebababbu, 0x0006002cu, 0x0000001bu, 0x00000731u, 0x0000072fu, + 0x00000730u, 0x00000074u, 0x0004002bu, 0x00000008u, 0x00000732u, 0x3ec8c8c9u, 0x0006002cu, 0x0000001bu, + 0x00000733u, 0x00000074u, 0x00000732u, 0x00000073u, 0x0004002bu, 0x00000008u, 0x00000734u, 0x3ed8d8d9u, + 0x0004002bu, 0x00000008u, 0x00000735u, 0x3f33b3b4u, 0x0004002bu, 0x00000008u, 0x00000736u, 0x3e6cecedu, + 0x0006002cu, 0x0000001bu, 0x00000737u, 0x00000734u, 0x00000735u, 0x00000736u, 0x0004002bu, 0x00000008u, + 0x00000738u, 0x3e8a8a8bu, 0x0004002bu, 0x00000008u, 0x00000739u, 0x3f31b1b2u, 0x0006002cu, 0x0000001bu, + 0x0000073au, 0x0000072cu, 0x00000738u, 0x00000739u, 0x0004002bu, 0x00000008u, 0x0000073bu, 0x3da0a0a1u, + 0x0004002bu, 0x00000008u, 0x0000073cu, 0x3f7efeffu, 0x0004002bu, 0x00000008u, 0x0000073du, 0x3f39b9bau, + 0x0006002cu, 0x0000001bu, 0x0000073eu, 0x0000073bu, 0x0000073cu, 0x0000073du, 0x0006002cu, 0x0000001bu, + 0x0000073fu, 0x00000732u, 0x00000732u, 0x00000732u, 0x0004002bu, 0x00000008u, 0x00000740u, 0x3d008081u, + 0x0004002bu, 0x00000008u, 0x00000741u, 0x3c008081u, 0x0006002cu, 0x0000001bu, 0x00000742u, 0x00000740u, + 0x00000741u, 0x00000074u, 0x0004002bu, 0x00000008u, 0x00000743u, 0x3ea0a0a1u, 0x0004002bu, 0x00000008u, + 0x00000744u, 0x3ef0f0f1u, 0x0006002cu, 0x0000001bu, 0x00000745u, 0x00000743u, 0x00000743u, 0x00000744u, + 0x0004002bu, 0x00000008u, 0x00000746u, 0x3e70f0f1u, 0x0006002cu, 0x0000001bu, 0x00000747u, 0x00000746u, + 0x00000744u, 0x00000746u, 0x0006002cu, 0x0000001bu, 0x00000748u, 0x00000744u, 0x00000743u, 0x00000743u, + 0x0006002cu, 0x0000001bu, 0x00000749u, 0x00000074u, 0x00000074u, 0x00000073u, 0x0004002bu, 0x00000008u, + 0x0000074au, 0x40e00000u, 0x0004002bu, 0x00000008u, 0x0000074bu, 0x41400000u, 0x0004002bu, 0x00000008u, + 0x0000074cu, 0x40a00000u, 0x0004002bu, 0x00000008u, 0x0000074du, 0x40400000u, 0x0003001du, 0x0000074eu, + 0x00000009u, 0x0003001eu, 0x0000074fu, 0x0000074eu, 0x00040020u, 0x00000750u, 0x0000000cu, 0x0000074fu, + 0x0004003bu, 0x00000750u, 0x00000751u, 0x0000000cu, 0x0006001eu, 0x00000752u, 0x00000008u, 0x00000008u, + 0x00000008u, 0x00000008u, 0x0003001du, 0x00000753u, 0x00000752u, 0x0003001eu, 0x00000754u, 0x00000753u, + 0x00040020u, 0x00000755u, 0x0000000cu, 0x00000754u, 0x0004003bu, 0x00000755u, 0x00000756u, 0x0000000cu, + 0x0003001du, 0x00000757u, 0x00000373u, 0x0003001eu, 0x00000758u, 0x00000757u, 0x00040020u, 0x00000759u, + 0x0000000cu, 0x00000758u, 0x0004003bu, 0x00000759u, 0x0000075au, 0x0000000cu, 0x0003001du, 0x0000075bu, + 0x000005c7u, 0x0003001eu, 0x0000075cu, 0x0000075bu, 0x00040020u, 0x0000075du, 0x0000000cu, 0x0000075cu, + 0x0004003bu, 0x0000075du, 0x0000075eu, 0x0000000cu, 0x0012001eu, 0x0000075fu, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x00000760u, + 0x0000075fu, 0x0003001eu, 0x00000761u, 0x00000760u, 0x00040020u, 0x00000762u, 0x0000000cu, 0x00000761u, + 0x0004003bu, 0x00000762u, 0x00000763u, 0x0000000cu, 0x0012001eu, 0x00000764u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x0003001du, 0x00000765u, + 0x00000764u, 0x0003001eu, 0x00000766u, 0x00000765u, 0x00040020u, 0x00000767u, 0x0000000cu, 0x00000766u, + 0x0004003bu, 0x00000767u, 0x00000768u, 0x0000000cu, 0x0006002cu, 0x00000373u, 0x00000769u, 0x00000007u, + 0x00000007u, 0x00000007u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, + 0x00000005u, 0x0004003bu, 0x00000370u, 0x00000371u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000372u, + 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000379u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000382u, + 0x00000007u, 0x0004003bu, 0x00000392u, 0x00000393u, 0x00000007u, 0x0004003bu, 0x000003a1u, 0x000003a2u, + 0x00000007u, 0x0004003bu, 0x000003c1u, 0x000003c2u, 0x00000007u, 0x0004003bu, 0x000003d1u, 0x000003d2u, + 0x00000007u, 0x0004003bu, 0x00000370u, 0x000003e7u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x000003fcu, + 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000407u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x0000040fu, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000418u, 0x00000007u, 0x0004003bu, 0x00000417u, 0x0000041bu, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000424u, 0x00000007u, 0x0004003bu, 0x000003d1u, 0x0000042bu, + 0x00000007u, 0x0004003bu, 0x000003d1u, 0x0000042fu, 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000436u, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000449u, 0x00000007u, 0x0004003bu, 0x00000457u, 0x00000458u, + 0x00000007u, 0x0004003bu, 0x00000457u, 0x00000459u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x0000045au, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000463u, 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000467u, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x00000485u, 0x00000007u, 0x0004003bu, 0x00000417u, 0x0000048cu, + 0x00000007u, 0x0004003bu, 0x00000457u, 0x000004a3u, 0x00000007u, 0x0004003bu, 0x00000457u, 0x000004a4u, + 0x00000007u, 0x0004003bu, 0x00000457u, 0x000004b0u, 0x00000007u, 0x0004003bu, 0x00000417u, 0x000004b5u, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x000004bcu, 0x00000007u, 0x0004003bu, 0x00000417u, 0x000004e2u, + 0x00000007u, 0x0004003bu, 0x00000417u, 0x000004e9u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x000004ffu, + 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000508u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x00000512u, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x00000530u, 0x00000007u, 0x0004003bu, 0x0000000au, 0x00000549u, + 0x00000007u, 0x0004003bu, 0x0000000au, 0x0000056au, 0x00000007u, 0x0004003bu, 0x00000021u, 0x0000058bu, + 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000591u, 0x00000007u, 0x0004003bu, 0x0000000au, 0x00000594u, + 0x00000007u, 0x0004003bu, 0x0000000au, 0x00000595u, 0x00000007u, 0x0004003bu, 0x0000000au, 0x00000597u, + 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000599u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x0000059cu, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005a5u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000005b8u, + 0x00000007u, 0x0004003bu, 0x00000032u, 0x000005c6u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005d1u, + 0x00000007u, 0x0004003bu, 0x00000032u, 0x000005d2u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005d5u, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005dau, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000005dfu, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005e2u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000005e4u, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005e6u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005e8u, + 0x00000007u, 0x0004003bu, 0x00000037u, 0x000005eeu, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005f0u, + 0x00000007u, 0x0004003bu, 0x0000000au, 0x000005f2u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005f4u, + 0x00000007u, 0x0004003bu, 0x00000370u, 0x000005f6u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000005ffu, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x0000060cu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x0000061bu, + 0x00000007u, 0x0004003bu, 0x00000032u, 0x00000622u, 0x00000007u, 0x0004003bu, 0x0000011bu, 0x00000627u, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x00000631u, 0x00000007u, 0x0004003bu, 0x0000011bu, 0x0000063fu, + 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000648u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x00000649u, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x00000651u, 0x00000007u, 0x0005003bu, 0x0000065cu, 0x0000065du, + 0x00000007u, 0x0000065au, 0x0004003bu, 0x00000021u, 0x00000661u, 0x00000007u, 0x0005003bu, 0x0000065cu, + 0x00000663u, 0x00000007u, 0x0000065au, 0x0004003bu, 0x00000021u, 0x00000669u, 0x00000007u, 0x0004003bu, + 0x00000370u, 0x00000684u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x0000068au, 0x00000007u, 0x0004003bu, + 0x00000021u, 0x00000693u, 0x00000007u, 0x0005003bu, 0x000006b1u, 0x000006b2u, 0x00000007u, 0x000006afu, + 0x0005003bu, 0x000006b5u, 0x000006b6u, 0x00000007u, 0x0000069fu, 0x0004003bu, 0x00000021u, 0x000006bbu, + 0x00000007u, 0x0005003bu, 0x000006b1u, 0x000006bdu, 0x00000007u, 0x000006afu, 0x0005003bu, 0x000006b5u, + 0x000006c0u, 0x00000007u, 0x0000069fu, 0x0004003bu, 0x00000021u, 0x000006c5u, 0x00000007u, 0x0004003bu, + 0x00000021u, 0x000006ceu, 0x00000007u, 0x0004003bu, 0x00000370u, 0x000006d7u, 0x00000007u, 0x0004003bu, + 0x00000021u, 0x000006d8u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x000006dau, 0x00000007u, 0x0004003bu, + 0x00000032u, 0x000006dcu, 0x00000007u, 0x0004003bu, 0x00000039u, 0x000006deu, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000006e0u, 0x00000007u, 0x0004003bu, 0x00000370u, 0x000006edu, 0x00000007u, 0x0004003bu, + 0x00000370u, 0x000006f4u, 0x00000007u, 0x0003003eu, 0x00000371u, 0x00000049u, 0x00050041u, 0x00000376u, + 0x00000377u, 0x00000375u, 0x00000049u, 0x0004003du, 0x00000006u, 0x00000378u, 0x00000377u, 0x0003003eu, + 0x00000372u, 0x00000378u, 0x0004003du, 0x00000006u, 0x0000037au, 0x00000372u, 0x00050041u, 0x0000037eu, + 0x0000037fu, 0x0000037du, 0x0000022eu, 0x0004003du, 0x00000006u, 0x00000380u, 0x0000037fu, 0x00050086u, + 0x00000006u, 0x00000381u, 0x0000037au, 0x00000380u, 0x0003003eu, 0x00000379u, 0x00000381u, 0x0004003du, + 0x00000006u, 0x00000383u, 0x00000372u, 0x00050041u, 0x0000037eu, 0x00000384u, 0x0000037du, 0x0000022eu, + 0x0004003du, 0x00000006u, 0x00000385u, 0x00000384u, 0x00050089u, 0x00000006u, 0x00000386u, 0x00000383u, + 0x00000385u, 0x0003003eu, 0x00000382u, 0x00000386u, 0x0004003du, 0x00000006u, 0x00000387u, 0x00000379u, + 0x00050041u, 0x0000037eu, 0x00000388u, 0x0000037du, 0x000001f1u, 0x0004003du, 0x00000006u, 0x00000389u, + 0x00000388u, 0x000500aeu, 0x00000029u, 0x0000038au, 0x00000387u, 0x00000389u, 0x000300f7u, 0x0000038cu, + 0x00000000u, 0x000400fau, 0x0000038au, 0x0000038bu, 0x0000038cu, 0x000200f8u, 0x0000038bu, 0x0003003eu, + 0x00000371u, 0x00000049u, 0x0004003du, 0x00000006u, 0x0000038du, 0x00000371u, 0x000414aeu, 0x0000038du, + 0x00000007u, 0x00000007u, 0x000200f8u, 0x0000038cu, 0x0004003du, 0x00000006u, 0x00000399u, 0x00000379u, + 0x00060041u, 0x0000039au, 0x0000039bu, 0x00000398u, 0x00000122u, 0x00000399u, 0x0004003du, 0x00000394u, + 0x0000039cu, 0x0000039bu, 0x00040190u, 0x00000391u, 0x0000039du, 0x0000039cu, 0x0003003eu, 0x00000393u, + 0x0000039du, 0x00050041u, 0x00000370u, 0x000003a9u, 0x00000393u, 0x00000122u, 0x0004003du, 0x00000006u, + 0x000003aau, 0x000003a9u, 0x00060041u, 0x000003abu, 0x000003acu, 0x000003a8u, 0x00000122u, 0x000003aau, + 0x0004003du, 0x000003a4u, 0x000003adu, 0x000003acu, 0x00040190u, 0x000003a0u, 0x000003aeu, 0x000003adu, + 0x0003003eu, 0x000003a2u, 0x000003aeu, 0x00050041u, 0x00000370u, 0x000003afu, 0x000003a2u, 0x000001d2u, + 0x0004003du, 0x00000006u, 0x000003b0u, 0x000003afu, 0x000500aau, 0x00000029u, 0x000003b1u, 0x000003b0u, + 0x00000049u, 0x000400a8u, 0x00000029u, 0x000003b2u, 0x000003b1u, 0x000300f7u, 0x000003b4u, 0x00000000u, + 0x000400fau, 0x000003b2u, 0x000003b3u, 0x000003b4u, 0x000200f8u, 0x000003b3u, 0x00050041u, 0x0000037eu, + 0x000003b5u, 0x0000037du, 0x00000234u, 0x0004003du, 0x00000006u, 0x000003b6u, 0x000003b5u, 0x00050041u, + 0x00000370u, 0x000003b7u, 0x000003a2u, 0x000001d2u, 0x0004003du, 0x00000006u, 0x000003b8u, 0x000003b7u, + 0x000500aeu, 0x00000029u, 0x000003b9u, 0x000003b6u, 0x000003b8u, 0x000200f9u, 0x000003b4u, 0x000200f8u, + 0x000003b4u, 0x000700f5u, 0x00000029u, 0x000003bau, 0x000003b1u, 0x0000038cu, 0x000003b9u, 0x000003b3u, + 0x000300f7u, 0x000003bcu, 0x00000000u, 0x000400fau, 0x000003bau, 0x000003bbu, 0x000003bcu, 0x000200f8u, + 0x000003bbu, 0x0003003eu, 0x00000371u, 0x00000049u, 0x0004003du, 0x00000006u, 0x000003bdu, 0x00000371u, + 0x000414aeu, 0x000003bdu, 0x00000007u, 0x00000007u, 0x000200f8u, 0x000003bcu, 0x00050041u, 0x00000370u, + 0x000003c8u, 0x000003a2u, 0x000001d5u, 0x0004003du, 0x00000006u, 0x000003c9u, 0x000003c8u, 0x00050041u, + 0x0000037eu, 0x000003cau, 0x0000037du, 0x00000234u, 0x0004003du, 0x00000006u, 0x000003cbu, 0x000003cau, + 0x00050080u, 0x00000006u, 0x000003ccu, 0x000003c9u, 0x000003cbu, 0x00060041u, 0x000003cdu, 0x000003ceu, + 0x000003c7u, 0x00000122u, 0x000003ccu, 0x0004003du, 0x000003c3u, 0x000003cfu, 0x000003ceu, 0x00040190u, + 0x000003c0u, 0x000003d0u, 0x000003cfu, 0x0003003eu, 0x000003c2u, 0x000003d0u, 0x0003003eu, 0x000003d2u, + 0x000003d3u, 0x0004003du, 0x00000006u, 0x000003d4u, 0x00000382u, 0x00050041u, 0x00000370u, 0x000003d5u, + 0x000003c2u, 0x00000122u, 0x0004003du, 0x00000006u, 0x000003d6u, 0x000003d5u, 0x000500aeu, 0x00000029u, + 0x000003d7u, 0x000003d4u, 0x000003d6u, 0x000300f7u, 0x000003d9u, 0x00000000u, 0x000400fau, 0x000003d7u, + 0x000003d8u, 0x000003d9u, 0x000200f8u, 0x000003d8u, 0x0003003eu, 0x000003d2u, 0x000003dau, 0x0003003eu, + 0x00000382u, 0x00000049u, 0x000200f9u, 0x000003d9u, 0x000200f8u, 0x000003d9u, 0x00050041u, 0x00000370u, + 0x000003dbu, 0x000003c2u, 0x00000182u, 0x0004003du, 0x00000006u, 0x000003dcu, 0x000003dbu, 0x000500aau, + 0x00000029u, 0x000003deu, 0x000003dcu, 0x000003ddu, 0x000300f7u, 0x000003e0u, 0x00000000u, 0x000400fau, + 0x000003deu, 0x000003dfu, 0x000003e0u, 0x000200f8u, 0x000003dfu, 0x00050041u, 0x00000370u, 0x000003e1u, + 0x00000393u, 0x00000182u, 0x0004003du, 0x00000006u, 0x000003e2u, 0x000003e1u, 0x000500abu, 0x00000029u, + 0x000003e3u, 0x000003e2u, 0x00000007u, 0x000200f9u, 0x000003e0u, 0x000200f8u, 0x000003e0u, 0x000700f5u, + 0x00000029u, 0x000003e4u, 0x000003deu, 0x000003d9u, 0x000003e3u, 0x000003dfu, 0x000300f7u, 0x000003e6u, + 0x00000000u, 0x000400fau, 0x000003e4u, 0x000003e5u, 0x000003e6u, 0x000200f8u, 0x000003e5u, 0x0003003eu, + 0x000003d2u, 0x000003dau, 0x000200f9u, 0x000003e6u, 0x000200f8u, 0x000003e6u, 0x0003003eu, 0x000003e7u, + 0x00000049u, 0x0004003du, 0x00000006u, 0x000003e8u, 0x00000382u, 0x000500acu, 0x00000029u, 0x000003e9u, + 0x000003e8u, 0x00000049u, 0x000300f7u, 0x000003ebu, 0x00000000u, 0x000400fau, 0x000003e9u, 0x000003eau, + 0x000003ebu, 0x000200f8u, 0x000003eau, 0x00050041u, 0x00000370u, 0x000003f0u, 0x000003a2u, 0x000001e1u, + 0x0004003du, 0x00000006u, 0x000003f1u, 0x000003f0u, 0x00050041u, 0x00000370u, 0x000003f2u, 0x000003c2u, + 0x000001d5u, 0x0004003du, 0x00000006u, 0x000003f3u, 0x000003f2u, 0x00050080u, 0x00000006u, 0x000003f4u, + 0x000003f1u, 0x000003f3u, 0x0004003du, 0x00000006u, 0x000003f5u, 0x00000382u, 0x00050080u, 0x00000006u, + 0x000003f6u, 0x000003f4u, 0x000003f5u, 0x00050082u, 0x00000006u, 0x000003f7u, 0x000003f6u, 0x00000007u, + 0x00060041u, 0x000003f8u, 0x000003f9u, 0x000003efu, 0x00000122u, 0x000003f7u, 0x0004003du, 0x00000121u, + 0x000003fau, 0x000003f9u, 0x0004007cu, 0x00000006u, 0x000003fbu, 0x000003fau, 0x0003003eu, 0x000003e7u, + 0x000003fbu, 0x000200f9u, 0x000003ebu, 0x000200f8u, 0x000003ebu, 0x00050041u, 0x00000370u, 0x000003fdu, + 0x000003a2u, 0x000001e1u, 0x0004003du, 0x00000006u, 0x000003feu, 0x000003fdu, 0x00050041u, 0x00000370u, + 0x000003ffu, 0x000003c2u, 0x000001d5u, 0x0004003du, 0x00000006u, 0x00000400u, 0x000003ffu, 0x00050080u, + 0x00000006u, 0x00000401u, 0x000003feu, 0x00000400u, 0x0004003du, 0x00000006u, 0x00000402u, 0x00000382u, + 0x00050080u, 0x00000006u, 0x00000403u, 0x00000401u, 0x00000402u, 0x00060041u, 0x000003f8u, 0x00000404u, + 0x000003efu, 0x00000122u, 0x00000403u, 0x0004003du, 0x00000121u, 0x00000405u, 0x00000404u, 0x0004007cu, + 0x00000006u, 0x00000406u, 0x00000405u, 0x0003003eu, 0x000003fcu, 0x00000406u, 0x0004003du, 0x00000006u, + 0x00000408u, 0x000003fcu, 0x0004003du, 0x00000006u, 0x00000409u, 0x000003e7u, 0x00050082u, 0x00000006u, + 0x0000040au, 0x00000408u, 0x00000409u, 0x0003003eu, 0x00000407u, 0x0000040au, 0x0004003du, 0x00000006u, + 0x0000040bu, 0x00000407u, 0x000500b0u, 0x00000029u, 0x0000040cu, 0x0000040bu, 0x00000007u, 0x000300f7u, + 0x0000040eu, 0x00000000u, 0x000400fau, 0x0000040cu, 0x0000040du, 0x0000040eu, 0x000200f8u, 0x0000040du, + 0x0003003eu, 0x000003d2u, 0x000003dau, 0x0003003eu, 0x00000407u, 0x00000007u, 0x000200f9u, 0x0000040eu, + 0x000200f8u, 0x0000040eu, 0x00050041u, 0x00000370u, 0x00000410u, 0x000003a2u, 0x000001dbu, 0x0004003du, + 0x00000006u, 0x00000411u, 0x00000410u, 0x00050041u, 0x00000370u, 0x00000412u, 0x000003c2u, 0x000001dbu, + 0x0004003du, 0x00000006u, 0x00000413u, 0x00000412u, 0x00050080u, 0x00000006u, 0x00000414u, 0x00000411u, + 0x00000413u, 0x0004003du, 0x00000006u, 0x00000415u, 0x000003e7u, 0x00050080u, 0x00000006u, 0x00000416u, + 0x00000414u, 0x00000415u, 0x0003003eu, 0x0000040fu, 0x00000416u, 0x00050041u, 0x00000417u, 0x00000419u, + 0x00000393u, 0x00000136u, 0x0004003du, 0x00000390u, 0x0000041au, 0x00000419u, 0x0003003eu, 0x00000418u, + 0x0000041au, 0x0004003du, 0x00000006u, 0x00000420u, 0x0000040fu, 0x00060041u, 0x00000421u, 0x00000422u, + 0x0000041fu, 0x00000122u, 0x00000420u, 0x0004003du, 0x00000390u, 0x00000423u, 0x00000422u, 0x0003003eu, + 0x0000041bu, 0x00000423u, 0x0004003du, 0x00000006u, 0x00000425u, 0x0000040fu, 0x0004003du, 0x00000006u, + 0x00000426u, 0x00000407u, 0x00050080u, 0x00000006u, 0x00000427u, 0x00000425u, 0x00000426u, 0x00050082u, + 0x00000006u, 0x00000428u, 0x00000427u, 0x00000007u, 0x00060041u, 0x00000421u, 0x00000429u, 0x0000041fu, + 0x00000122u, 0x00000428u, 0x0004003du, 0x00000390u, 0x0000042au, 0x00000429u, 0x0003003eu, 0x00000424u, + 0x0000042au, 0x0004003du, 0x00000390u, 0x0000042cu, 0x00000418u, 0x0004003du, 0x00000390u, 0x0000042du, + 0x0000041bu, 0x000500b1u, 0x00000029u, 0x0000042eu, 0x0000042cu, 0x0000042du, 0x0003003eu, 0x0000042bu, + 0x0000042eu, 0x0004003du, 0x00000390u, 0x00000430u, 0x00000418u, 0x0004003du, 0x00000390u, 0x00000431u, + 0x00000424u, 0x000500adu, 0x00000029u, 0x00000432u, 0x00000430u, 0x00000431u, 0x0003003eu, 0x0000042fu, + 0x00000432u, 0x0004003du, 0x00000029u, 0x00000433u, 0x0000042bu, 0x000300f7u, 0x00000435u, 0x00000000u, + 0x000400fau, 0x00000433u, 0x00000434u, 0x00000445u, 0x000200f8u, 0x00000434u, 0x0004003du, 0x00000390u, + 0x00000437u, 0x0000041bu, 0x0004003du, 0x00000390u, 0x00000438u, 0x00000418u, 0x00050082u, 0x00000390u, + 0x00000439u, 0x00000437u, 0x00000438u, 0x0003003eu, 0x00000436u, 0x00000439u, 0x0004003du, 0x00000390u, + 0x0000043au, 0x00000436u, 0x00050041u, 0x0000043bu, 0x0000043cu, 0x0000037du, 0x000001e1u, 0x0004003du, + 0x00000121u, 0x0000043du, 0x0000043cu, 0x00040072u, 0x00000390u, 0x0000043eu, 0x0000043du, 0x000500adu, + 0x00000029u, 0x0000043fu, 0x0000043au, 0x0000043eu, 0x0004003du, 0x00000006u, 0x00000440u, 0x00000407u, + 0x000500b0u, 0x00000029u, 0x00000441u, 0x00000440u, 0x00000055u, 0x000500a6u, 0x00000029u, 0x00000442u, + 0x0000043fu, 0x00000441u, 0x000300f7u, 0x00000444u, 0x00000000u, 0x000400fau, 0x00000442u, 0x00000443u, + 0x00000444u, 0x000200f8u, 0x00000443u, 0x0003003eu, 0x000003d2u, 0x000003dau, 0x000200f9u, 0x00000444u, + 0x000200f8u, 0x00000444u, 0x000200f9u, 0x00000435u, 0x000200f8u, 0x00000445u, 0x0004003du, 0x00000029u, + 0x00000446u, 0x0000042fu, 0x000300f7u, 0x00000448u, 0x00000000u, 0x000400fau, 0x00000446u, 0x00000447u, + 0x00000448u, 0x000200f8u, 0x00000447u, 0x0004003du, 0x00000390u, 0x0000044au, 0x00000418u, 0x0004003du, + 0x00000390u, 0x0000044bu, 0x00000424u, 0x00050082u, 0x00000390u, 0x0000044cu, 0x0000044au, 0x0000044bu, + 0x0003003eu, 0x00000449u, 0x0000044cu, 0x0004003du, 0x00000390u, 0x0000044du, 0x00000449u, 0x00050041u, + 0x0000043bu, 0x0000044eu, 0x0000037du, 0x000001e1u, 0x0004003du, 0x00000121u, 0x0000044fu, 0x0000044eu, + 0x00040072u, 0x00000390u, 0x00000450u, 0x0000044fu, 0x000500adu, 0x00000029u, 0x00000451u, 0x0000044du, + 0x00000450u, 0x0004003du, 0x00000006u, 0x00000452u, 0x00000407u, 0x000500b0u, 0x00000029u, 0x00000453u, + 0x00000452u, 0x00000055u, 0x000500a6u, 0x00000029u, 0x00000454u, 0x00000451u, 0x00000453u, 0x000300f7u, + 0x00000456u, 0x00000000u, 0x000400fau, 0x00000454u, 0x00000455u, 0x00000456u, 0x000200f8u, 0x00000455u, + 0x0003003eu, 0x000003d2u, 0x000003dau, 0x000200f9u, 0x00000456u, 0x000200f8u, 0x00000456u, 0x000200f9u, + 0x00000448u, 0x000200f8u, 0x00000448u, 0x000200f9u, 0x00000435u, 0x000200f8u, 0x00000435u, 0x0003003eu, + 0x00000458u, 0x00000122u, 0x0003003eu, 0x00000459u, 0x00000122u, 0x0003003eu, 0x0000045au, 0x00000073u, + 0x0004003du, 0x00000006u, 0x0000045bu, 0x00000407u, 0x000500aau, 0x00000029u, 0x0000045cu, 0x0000045bu, + 0x00000007u, 0x000300f7u, 0x0000045eu, 0x00000000u, 0x000400fau, 0x0000045cu, 0x0000045du, 0x0000045fu, + 0x000200f8u, 0x0000045du, 0x0003003eu, 0x00000458u, 0x00000122u, 0x0003003eu, 0x00000459u, 0x00000122u, + 0x0003003eu, 0x0000045au, 0x00000073u, 0x000200f9u, 0x0000045eu, 0x000200f8u, 0x0000045fu, 0x0004003du, + 0x00000029u, 0x00000460u, 0x0000042bu, 0x000300f7u, 0x00000462u, 0x00000000u, 0x000400fau, 0x00000460u, + 0x00000461u, 0x0000047bu, 0x000200f8u, 0x00000461u, 0x0003003eu, 0x00000458u, 0x00000122u, 0x0003003eu, + 0x00000459u, 0x0000012cu, 0x0004003du, 0x00000006u, 0x00000464u, 0x0000040fu, 0x00060041u, 0x00000421u, + 0x00000465u, 0x0000041fu, 0x00000122u, 0x00000464u, 0x0004003du, 0x00000390u, 0x00000466u, 0x00000465u, + 0x0003003eu, 0x00000463u, 0x00000466u, 0x0004003du, 0x00000006u, 0x00000468u, 0x0000040fu, 0x00050080u, + 0x00000006u, 0x00000469u, 0x00000468u, 0x00000007u, 0x00060041u, 0x00000421u, 0x0000046au, 0x0000041fu, + 0x00000122u, 0x00000469u, 0x0004003du, 0x00000390u, 0x0000046bu, 0x0000046au, 0x0003003eu, 0x00000467u, + 0x0000046bu, 0x0004003du, 0x00000390u, 0x0000046cu, 0x00000467u, 0x0004003du, 0x00000390u, 0x0000046du, + 0x00000463u, 0x000500adu, 0x00000029u, 0x0000046eu, 0x0000046cu, 0x0000046du, 0x000300f7u, 0x00000470u, + 0x00000000u, 0x000400fau, 0x0000046eu, 0x0000046fu, 0x0000047au, 0x000200f8u, 0x0000046fu, 0x0004003du, + 0x00000390u, 0x00000471u, 0x00000418u, 0x0004003du, 0x00000390u, 0x00000472u, 0x00000463u, 0x00050082u, + 0x00000390u, 0x00000473u, 0x00000471u, 0x00000472u, 0x0004006fu, 0x00000008u, 0x00000474u, 0x00000473u, + 0x0004003du, 0x00000390u, 0x00000475u, 0x00000467u, 0x0004003du, 0x00000390u, 0x00000476u, 0x00000463u, + 0x00050082u, 0x00000390u, 0x00000477u, 0x00000475u, 0x00000476u, 0x0004006fu, 0x00000008u, 0x00000478u, + 0x00000477u, 0x00050088u, 0x00000008u, 0x00000479u, 0x00000474u, 0x00000478u, 0x0003003eu, 0x0000045au, + 0x00000479u, 0x000200f9u, 0x00000470u, 0x000200f8u, 0x0000047au, 0x0003003eu, 0x0000045au, 0x00000073u, + 0x000200f9u, 0x00000470u, 0x000200f8u, 0x00000470u, 0x000200f9u, 0x00000462u, 0x000200f8u, 0x0000047bu, + 0x0004003du, 0x00000029u, 0x0000047cu, 0x0000042fu, 0x000300f7u, 0x0000047eu, 0x00000000u, 0x000400fau, + 0x0000047cu, 0x0000047du, 0x000004a2u, 0x000200f8u, 0x0000047du, 0x0004003du, 0x00000006u, 0x0000047fu, + 0x00000407u, 0x0004007cu, 0x00000121u, 0x00000480u, 0x0000047fu, 0x00050082u, 0x00000121u, 0x00000481u, + 0x00000480u, 0x00000136u, 0x0003003eu, 0x00000458u, 0x00000481u, 0x0004003du, 0x00000006u, 0x00000482u, + 0x00000407u, 0x0004007cu, 0x00000121u, 0x00000483u, 0x00000482u, 0x00050082u, 0x00000121u, 0x00000484u, + 0x00000483u, 0x0000012cu, 0x0003003eu, 0x00000459u, 0x00000484u, 0x0004003du, 0x00000006u, 0x00000486u, + 0x0000040fu, 0x0004003du, 0x00000121u, 0x00000487u, 0x00000458u, 0x0004007cu, 0x00000006u, 0x00000488u, + 0x00000487u, 0x00050080u, 0x00000006u, 0x00000489u, 0x00000486u, 0x00000488u, 0x00060041u, 0x00000421u, + 0x0000048au, 0x0000041fu, 0x00000122u, 0x00000489u, 0x0004003du, 0x00000390u, 0x0000048bu, 0x0000048au, + 0x0003003eu, 0x00000485u, 0x0000048bu, 0x0004003du, 0x00000006u, 0x0000048du, 0x0000040fu, 0x0004003du, + 0x00000121u, 0x0000048eu, 0x00000459u, 0x0004007cu, 0x00000006u, 0x0000048fu, 0x0000048eu, 0x00050080u, + 0x00000006u, 0x00000490u, 0x0000048du, 0x0000048fu, 0x00060041u, 0x00000421u, 0x00000491u, 0x0000041fu, + 0x00000122u, 0x00000490u, 0x0004003du, 0x00000390u, 0x00000492u, 0x00000491u, 0x0003003eu, 0x0000048cu, + 0x00000492u, 0x0004003du, 0x00000390u, 0x00000493u, 0x0000048cu, 0x0004003du, 0x00000390u, 0x00000494u, + 0x00000485u, 0x000500adu, 0x00000029u, 0x00000495u, 0x00000493u, 0x00000494u, 0x000300f7u, 0x00000497u, + 0x00000000u, 0x000400fau, 0x00000495u, 0x00000496u, 0x000004a1u, 0x000200f8u, 0x00000496u, 0x0004003du, + 0x00000390u, 0x00000498u, 0x00000418u, 0x0004003du, 0x00000390u, 0x00000499u, 0x00000485u, 0x00050082u, + 0x00000390u, 0x0000049au, 0x00000498u, 0x00000499u, 0x0004006fu, 0x00000008u, 0x0000049bu, 0x0000049au, + 0x0004003du, 0x00000390u, 0x0000049cu, 0x0000048cu, 0x0004003du, 0x00000390u, 0x0000049du, 0x00000485u, + 0x00050082u, 0x00000390u, 0x0000049eu, 0x0000049cu, 0x0000049du, 0x0004006fu, 0x00000008u, 0x0000049fu, + 0x0000049eu, 0x00050088u, 0x00000008u, 0x000004a0u, 0x0000049bu, 0x0000049fu, 0x0003003eu, 0x0000045au, + 0x000004a0u, 0x000200f9u, 0x00000497u, 0x000200f8u, 0x000004a1u, 0x0003003eu, 0x0000045au, 0x00000074u, + 0x000200f9u, 0x00000497u, 0x000200f8u, 0x00000497u, 0x000200f9u, 0x0000047eu, 0x000200f8u, 0x000004a2u, + 0x0003003eu, 0x000004a3u, 0x00000122u, 0x0004003du, 0x00000006u, 0x000004a5u, 0x00000407u, 0x0004007cu, + 0x00000121u, 0x000004a6u, 0x000004a5u, 0x00050082u, 0x00000121u, 0x000004a7u, 0x000004a6u, 0x00000136u, + 0x0003003eu, 0x000004a4u, 0x000004a7u, 0x0003003eu, 0x00000458u, 0x00000122u, 0x000200f9u, 0x000004a8u, + 0x000200f8u, 0x000004a8u, 0x000400f6u, 0x000004aau, 0x000004abu, 0x00000000u, 0x000200f9u, 0x000004acu, + 0x000200f8u, 0x000004acu, 0x0004003du, 0x00000121u, 0x000004adu, 0x000004a3u, 0x0004003du, 0x00000121u, + 0x000004aeu, 0x000004a4u, 0x000500b3u, 0x00000029u, 0x000004afu, 0x000004adu, 0x000004aeu, 0x000400fau, + 0x000004afu, 0x000004a9u, 0x000004aau, 0x000200f8u, 0x000004a9u, 0x0004003du, 0x00000121u, 0x000004b1u, + 0x000004a3u, 0x0004003du, 0x00000121u, 0x000004b2u, 0x000004a4u, 0x00050080u, 0x00000121u, 0x000004b3u, + 0x000004b1u, 0x000004b2u, 0x00050087u, 0x00000121u, 0x000004b4u, 0x000004b3u, 0x00000136u, 0x0003003eu, + 0x000004b0u, 0x000004b4u, 0x0004003du, 0x00000006u, 0x000004b6u, 0x0000040fu, 0x0004003du, 0x00000121u, + 0x000004b7u, 0x000004b0u, 0x0004007cu, 0x00000006u, 0x000004b8u, 0x000004b7u, 0x00050080u, 0x00000006u, + 0x000004b9u, 0x000004b6u, 0x000004b8u, 0x00060041u, 0x00000421u, 0x000004bau, 0x0000041fu, 0x00000122u, + 0x000004b9u, 0x0004003du, 0x00000390u, 0x000004bbu, 0x000004bau, 0x0003003eu, 0x000004b5u, 0x000004bbu, + 0x0004003du, 0x00000006u, 0x000004bdu, 0x0000040fu, 0x0004003du, 0x00000121u, 0x000004beu, 0x000004b0u, + 0x0004007cu, 0x00000006u, 0x000004bfu, 0x000004beu, 0x00050080u, 0x00000006u, 0x000004c0u, 0x000004bdu, + 0x000004bfu, 0x00050080u, 0x00000006u, 0x000004c1u, 0x000004c0u, 0x00000007u, 0x00060041u, 0x00000421u, + 0x000004c2u, 0x0000041fu, 0x00000122u, 0x000004c1u, 0x0004003du, 0x00000390u, 0x000004c3u, 0x000004c2u, + 0x0003003eu, 0x000004bcu, 0x000004c3u, 0x0004003du, 0x00000390u, 0x000004c4u, 0x000004b5u, 0x0004003du, + 0x00000390u, 0x000004c5u, 0x00000418u, 0x000500b3u, 0x00000029u, 0x000004c6u, 0x000004c4u, 0x000004c5u, + 0x0004003du, 0x00000390u, 0x000004c7u, 0x00000418u, 0x0004003du, 0x00000390u, 0x000004c8u, 0x000004bcu, + 0x000500b3u, 0x00000029u, 0x000004c9u, 0x000004c7u, 0x000004c8u, 0x000500a7u, 0x00000029u, 0x000004cau, + 0x000004c6u, 0x000004c9u, 0x000300f7u, 0x000004ccu, 0x00000000u, 0x000400fau, 0x000004cau, 0x000004cbu, + 0x000004cfu, 0x000200f8u, 0x000004cbu, 0x0004003du, 0x00000121u, 0x000004cdu, 0x000004b0u, 0x0003003eu, + 0x00000458u, 0x000004cdu, 0x000200f9u, 0x000004aau, 0x000200f8u, 0x000004cfu, 0x0004003du, 0x00000390u, + 0x000004d0u, 0x00000418u, 0x0004003du, 0x00000390u, 0x000004d1u, 0x000004b5u, 0x000500b1u, 0x00000029u, + 0x000004d2u, 0x000004d0u, 0x000004d1u, 0x000300f7u, 0x000004d4u, 0x00000000u, 0x000400fau, 0x000004d2u, + 0x000004d3u, 0x000004d7u, 0x000200f8u, 0x000004d3u, 0x0004003du, 0x00000121u, 0x000004d5u, 0x000004b0u, + 0x00050082u, 0x00000121u, 0x000004d6u, 0x000004d5u, 0x0000012cu, 0x0003003eu, 0x000004a4u, 0x000004d6u, + 0x000200f9u, 0x000004d4u, 0x000200f8u, 0x000004d7u, 0x0004003du, 0x00000121u, 0x000004d8u, 0x000004b0u, + 0x00050080u, 0x00000121u, 0x000004d9u, 0x000004d8u, 0x0000012cu, 0x0003003eu, 0x000004a3u, 0x000004d9u, + 0x0004003du, 0x00000121u, 0x000004dau, 0x000004b0u, 0x00050080u, 0x00000121u, 0x000004dbu, 0x000004dau, + 0x0000012cu, 0x0003003eu, 0x00000458u, 0x000004dbu, 0x000200f9u, 0x000004d4u, 0x000200f8u, 0x000004d4u, + 0x000200f9u, 0x000004ccu, 0x000200f8u, 0x000004ccu, 0x000200f9u, 0x000004abu, 0x000200f8u, 0x000004abu, + 0x000200f9u, 0x000004a8u, 0x000200f8u, 0x000004aau, 0x0004003du, 0x00000121u, 0x000004dcu, 0x00000458u, + 0x00050080u, 0x00000121u, 0x000004ddu, 0x000004dcu, 0x0000012cu, 0x0004003du, 0x00000006u, 0x000004deu, + 0x00000407u, 0x0004007cu, 0x00000121u, 0x000004dfu, 0x000004deu, 0x00050082u, 0x00000121u, 0x000004e0u, + 0x000004dfu, 0x0000012cu, 0x0007000cu, 0x00000121u, 0x000004e1u, 0x00000001u, 0x00000027u, 0x000004ddu, + 0x000004e0u, 0x0003003eu, 0x00000459u, 0x000004e1u, 0x0004003du, 0x00000006u, 0x000004e3u, 0x0000040fu, + 0x0004003du, 0x00000121u, 0x000004e4u, 0x00000458u, 0x0004007cu, 0x00000006u, 0x000004e5u, 0x000004e4u, + 0x00050080u, 0x00000006u, 0x000004e6u, 0x000004e3u, 0x000004e5u, 0x00060041u, 0x00000421u, 0x000004e7u, + 0x0000041fu, 0x00000122u, 0x000004e6u, 0x0004003du, 0x00000390u, 0x000004e8u, 0x000004e7u, 0x0003003eu, + 0x000004e2u, 0x000004e8u, 0x0004003du, 0x00000006u, 0x000004eau, 0x0000040fu, 0x0004003du, 0x00000121u, + 0x000004ebu, 0x00000459u, 0x0004007cu, 0x00000006u, 0x000004ecu, 0x000004ebu, 0x00050080u, 0x00000006u, + 0x000004edu, 0x000004eau, 0x000004ecu, 0x00060041u, 0x00000421u, 0x000004eeu, 0x0000041fu, 0x00000122u, + 0x000004edu, 0x0004003du, 0x00000390u, 0x000004efu, 0x000004eeu, 0x0003003eu, 0x000004e9u, 0x000004efu, + 0x0004003du, 0x00000390u, 0x000004f0u, 0x000004e9u, 0x0004003du, 0x00000390u, 0x000004f1u, 0x000004e2u, + 0x000500adu, 0x00000029u, 0x000004f2u, 0x000004f0u, 0x000004f1u, 0x000300f7u, 0x000004f4u, 0x00000000u, + 0x000400fau, 0x000004f2u, 0x000004f3u, 0x000004feu, 0x000200f8u, 0x000004f3u, 0x0004003du, 0x00000390u, + 0x000004f5u, 0x00000418u, 0x0004003du, 0x00000390u, 0x000004f6u, 0x000004e2u, 0x00050082u, 0x00000390u, + 0x000004f7u, 0x000004f5u, 0x000004f6u, 0x0004006fu, 0x00000008u, 0x000004f8u, 0x000004f7u, 0x0004003du, + 0x00000390u, 0x000004f9u, 0x000004e9u, 0x0004003du, 0x00000390u, 0x000004fau, 0x000004e2u, 0x00050082u, + 0x00000390u, 0x000004fbu, 0x000004f9u, 0x000004fau, 0x0004006fu, 0x00000008u, 0x000004fcu, 0x000004fbu, + 0x00050088u, 0x00000008u, 0x000004fdu, 0x000004f8u, 0x000004fcu, 0x0003003eu, 0x0000045au, 0x000004fdu, + 0x000200f9u, 0x000004f4u, 0x000200f8u, 0x000004feu, 0x0003003eu, 0x0000045au, 0x00000073u, 0x000200f9u, + 0x000004f4u, 0x000200f8u, 0x000004f4u, 0x000200f9u, 0x0000047eu, 0x000200f8u, 0x0000047eu, 0x000200f9u, + 0x00000462u, 0x000200f8u, 0x00000462u, 0x000200f9u, 0x0000045eu, 0x000200f8u, 0x0000045eu, 0x00050041u, + 0x00000370u, 0x00000500u, 0x000003a2u, 0x00000202u, 0x0004003du, 0x00000006u, 0x00000501u, 0x00000500u, + 0x00050041u, 0x00000370u, 0x00000502u, 0x000003c2u, 0x000001e1u, 0x0004003du, 0x00000006u, 0x00000503u, + 0x00000502u, 0x00050080u, 0x00000006u, 0x00000504u, 0x00000501u, 0x00000503u, 0x0004003du, 0x00000006u, + 0x00000505u, 0x000003e7u, 0x00050084u, 0x00000006u, 0x00000506u, 0x00000505u, 0x0000005cu, 0x00050080u, + 0x00000006u, 0x00000507u, 0x00000504u, 0x00000506u, 0x0003003eu, 0x000004ffu, 0x00000507u, 0x00050041u, + 0x00000370u, 0x00000509u, 0x000003a2u, 0x00000202u, 0x0004003du, 0x00000006u, 0x0000050au, 0x00000509u, + 0x00050041u, 0x00000370u, 0x0000050bu, 0x000003c2u, 0x000001e9u, 0x0004003du, 0x00000006u, 0x0000050cu, + 0x0000050bu, 0x00050080u, 0x00000006u, 0x0000050du, 0x0000050au, 0x0000050cu, 0x0004003du, 0x00000006u, + 0x0000050eu, 0x000003e7u, 0x00050084u, 0x00000006u, 0x00000510u, 0x0000050eu, 0x0000050fu, 0x00050080u, + 0x00000006u, 0x00000511u, 0x0000050du, 0x00000510u, 0x0003003eu, 0x00000508u, 0x00000511u, 0x0004003du, + 0x00000006u, 0x00000517u, 0x000004ffu, 0x0004003du, 0x00000121u, 0x00000518u, 0x00000458u, 0x0004007cu, + 0x00000006u, 0x00000519u, 0x00000518u, 0x00050084u, 0x00000006u, 0x0000051au, 0x00000519u, 0x0000005cu, + 0x00050080u, 0x00000006u, 0x0000051bu, 0x00000517u, 0x0000051au, 0x00060041u, 0x0000051cu, 0x0000051du, + 0x00000516u, 0x00000122u, 0x0000051bu, 0x0004003du, 0x00000008u, 0x0000051eu, 0x0000051du, 0x0004003du, + 0x00000006u, 0x0000051fu, 0x000004ffu, 0x0004003du, 0x00000121u, 0x00000520u, 0x00000458u, 0x0004007cu, + 0x00000006u, 0x00000521u, 0x00000520u, 0x00050084u, 0x00000006u, 0x00000522u, 0x00000521u, 0x0000005cu, + 0x00050080u, 0x00000006u, 0x00000523u, 0x0000051fu, 0x00000522u, 0x00050080u, 0x00000006u, 0x00000524u, + 0x00000523u, 0x00000007u, 0x00060041u, 0x0000051cu, 0x00000525u, 0x00000516u, 0x00000122u, 0x00000524u, + 0x0004003du, 0x00000008u, 0x00000526u, 0x00000525u, 0x0004003du, 0x00000006u, 0x00000527u, 0x000004ffu, + 0x0004003du, 0x00000121u, 0x00000528u, 0x00000458u, 0x0004007cu, 0x00000006u, 0x00000529u, 0x00000528u, + 0x00050084u, 0x00000006u, 0x0000052au, 0x00000529u, 0x0000005cu, 0x00050080u, 0x00000006u, 0x0000052bu, + 0x00000527u, 0x0000052au, 0x00050080u, 0x00000006u, 0x0000052cu, 0x0000052bu, 0x00000055u, 0x00060041u, + 0x0000051cu, 0x0000052du, 0x00000516u, 0x00000122u, 0x0000052cu, 0x0004003du, 0x00000008u, 0x0000052eu, + 0x0000052du, 0x00060050u, 0x0000001bu, 0x0000052fu, 0x0000051eu, 0x00000526u, 0x0000052eu, 0x0003003eu, + 0x00000512u, 0x0000052fu, 0x0004003du, 0x00000006u, 0x00000531u, 0x000004ffu, 0x0004003du, 0x00000121u, + 0x00000532u, 0x00000459u, 0x0004007cu, 0x00000006u, 0x00000533u, 0x00000532u, 0x00050084u, 0x00000006u, + 0x00000534u, 0x00000533u, 0x0000005cu, 0x00050080u, 0x00000006u, 0x00000535u, 0x00000531u, 0x00000534u, + 0x00060041u, 0x0000051cu, 0x00000536u, 0x00000516u, 0x00000122u, 0x00000535u, 0x0004003du, 0x00000008u, + 0x00000537u, 0x00000536u, 0x0004003du, 0x00000006u, 0x00000538u, 0x000004ffu, 0x0004003du, 0x00000121u, + 0x00000539u, 0x00000459u, 0x0004007cu, 0x00000006u, 0x0000053au, 0x00000539u, 0x00050084u, 0x00000006u, + 0x0000053bu, 0x0000053au, 0x0000005cu, 0x00050080u, 0x00000006u, 0x0000053cu, 0x00000538u, 0x0000053bu, + 0x00050080u, 0x00000006u, 0x0000053du, 0x0000053cu, 0x00000007u, 0x00060041u, 0x0000051cu, 0x0000053eu, + 0x00000516u, 0x00000122u, 0x0000053du, 0x0004003du, 0x00000008u, 0x0000053fu, 0x0000053eu, 0x0004003du, + 0x00000006u, 0x00000540u, 0x000004ffu, 0x0004003du, 0x00000121u, 0x00000541u, 0x00000459u, 0x0004007cu, + 0x00000006u, 0x00000542u, 0x00000541u, 0x00050084u, 0x00000006u, 0x00000543u, 0x00000542u, 0x0000005cu, + 0x00050080u, 0x00000006u, 0x00000544u, 0x00000540u, 0x00000543u, 0x00050080u, 0x00000006u, 0x00000545u, + 0x00000544u, 0x00000055u, 0x00060041u, 0x0000051cu, 0x00000546u, 0x00000516u, 0x00000122u, 0x00000545u, + 0x0004003du, 0x00000008u, 0x00000547u, 0x00000546u, 0x00060050u, 0x0000001bu, 0x00000548u, 0x00000537u, + 0x0000053fu, 0x00000547u, 0x0003003eu, 0x00000530u, 0x00000548u, 0x0004003du, 0x00000006u, 0x0000054au, + 0x00000508u, 0x0004003du, 0x00000121u, 0x0000054bu, 0x00000458u, 0x0004007cu, 0x00000006u, 0x0000054cu, + 0x0000054bu, 0x00050084u, 0x00000006u, 0x0000054du, 0x0000054cu, 0x0000050fu, 0x00050080u, 0x00000006u, + 0x0000054eu, 0x0000054au, 0x0000054du, 0x00060041u, 0x0000051cu, 0x0000054fu, 0x00000516u, 0x00000122u, + 0x0000054eu, 0x0004003du, 0x00000008u, 0x00000550u, 0x0000054fu, 0x0004003du, 0x00000006u, 0x00000551u, + 0x00000508u, 0x0004003du, 0x00000121u, 0x00000552u, 0x00000458u, 0x0004007cu, 0x00000006u, 0x00000553u, + 0x00000552u, 0x00050084u, 0x00000006u, 0x00000554u, 0x00000553u, 0x0000050fu, 0x00050080u, 0x00000006u, + 0x00000555u, 0x00000551u, 0x00000554u, 0x00050080u, 0x00000006u, 0x00000556u, 0x00000555u, 0x00000007u, + 0x00060041u, 0x0000051cu, 0x00000557u, 0x00000516u, 0x00000122u, 0x00000556u, 0x0004003du, 0x00000008u, + 0x00000558u, 0x00000557u, 0x0004003du, 0x00000006u, 0x00000559u, 0x00000508u, 0x0004003du, 0x00000121u, + 0x0000055au, 0x00000458u, 0x0004007cu, 0x00000006u, 0x0000055bu, 0x0000055au, 0x00050084u, 0x00000006u, + 0x0000055cu, 0x0000055bu, 0x0000050fu, 0x00050080u, 0x00000006u, 0x0000055du, 0x00000559u, 0x0000055cu, + 0x00050080u, 0x00000006u, 0x0000055eu, 0x0000055du, 0x00000055u, 0x00060041u, 0x0000051cu, 0x0000055fu, + 0x00000516u, 0x00000122u, 0x0000055eu, 0x0004003du, 0x00000008u, 0x00000560u, 0x0000055fu, 0x0004003du, + 0x00000006u, 0x00000561u, 0x00000508u, 0x0004003du, 0x00000121u, 0x00000562u, 0x00000458u, 0x0004007cu, + 0x00000006u, 0x00000563u, 0x00000562u, 0x00050084u, 0x00000006u, 0x00000564u, 0x00000563u, 0x0000050fu, + 0x00050080u, 0x00000006u, 0x00000565u, 0x00000561u, 0x00000564u, 0x00050080u, 0x00000006u, 0x00000566u, + 0x00000565u, 0x0000005cu, 0x00060041u, 0x0000051cu, 0x00000567u, 0x00000516u, 0x00000122u, 0x00000566u, + 0x0004003du, 0x00000008u, 0x00000568u, 0x00000567u, 0x00070050u, 0x00000009u, 0x00000569u, 0x00000550u, + 0x00000558u, 0x00000560u, 0x00000568u, 0x0003003eu, 0x00000549u, 0x00000569u, 0x0004003du, 0x00000006u, + 0x0000056bu, 0x00000508u, 0x0004003du, 0x00000121u, 0x0000056cu, 0x00000459u, 0x0004007cu, 0x00000006u, + 0x0000056du, 0x0000056cu, 0x00050084u, 0x00000006u, 0x0000056eu, 0x0000056du, 0x0000050fu, 0x00050080u, + 0x00000006u, 0x0000056fu, 0x0000056bu, 0x0000056eu, 0x00060041u, 0x0000051cu, 0x00000570u, 0x00000516u, + 0x00000122u, 0x0000056fu, 0x0004003du, 0x00000008u, 0x00000571u, 0x00000570u, 0x0004003du, 0x00000006u, + 0x00000572u, 0x00000508u, 0x0004003du, 0x00000121u, 0x00000573u, 0x00000459u, 0x0004007cu, 0x00000006u, + 0x00000574u, 0x00000573u, 0x00050084u, 0x00000006u, 0x00000575u, 0x00000574u, 0x0000050fu, 0x00050080u, + 0x00000006u, 0x00000576u, 0x00000572u, 0x00000575u, 0x00050080u, 0x00000006u, 0x00000577u, 0x00000576u, + 0x00000007u, 0x00060041u, 0x0000051cu, 0x00000578u, 0x00000516u, 0x00000122u, 0x00000577u, 0x0004003du, + 0x00000008u, 0x00000579u, 0x00000578u, 0x0004003du, 0x00000006u, 0x0000057au, 0x00000508u, 0x0004003du, + 0x00000121u, 0x0000057bu, 0x00000459u, 0x0004007cu, 0x00000006u, 0x0000057cu, 0x0000057bu, 0x00050084u, + 0x00000006u, 0x0000057du, 0x0000057cu, 0x0000050fu, 0x00050080u, 0x00000006u, 0x0000057eu, 0x0000057au, + 0x0000057du, 0x00050080u, 0x00000006u, 0x0000057fu, 0x0000057eu, 0x00000055u, 0x00060041u, 0x0000051cu, + 0x00000580u, 0x00000516u, 0x00000122u, 0x0000057fu, 0x0004003du, 0x00000008u, 0x00000581u, 0x00000580u, + 0x0004003du, 0x00000006u, 0x00000582u, 0x00000508u, 0x0004003du, 0x00000121u, 0x00000583u, 0x00000459u, + 0x0004007cu, 0x00000006u, 0x00000584u, 0x00000583u, 0x00050084u, 0x00000006u, 0x00000585u, 0x00000584u, + 0x0000050fu, 0x00050080u, 0x00000006u, 0x00000586u, 0x00000582u, 0x00000585u, 0x00050080u, 0x00000006u, + 0x00000587u, 0x00000586u, 0x0000005cu, 0x00060041u, 0x0000051cu, 0x00000588u, 0x00000516u, 0x00000122u, + 0x00000587u, 0x0004003du, 0x00000008u, 0x00000589u, 0x00000588u, 0x00070050u, 0x00000009u, 0x0000058au, + 0x00000571u, 0x00000579u, 0x00000581u, 0x00000589u, 0x0003003eu, 0x0000056au, 0x0000058au, 0x0004003du, + 0x0000001bu, 0x0000058cu, 0x00000512u, 0x0004003du, 0x0000001bu, 0x0000058du, 0x00000530u, 0x0004003du, + 0x00000008u, 0x0000058eu, 0x0000045au, 0x00060050u, 0x0000001bu, 0x0000058fu, 0x0000058eu, 0x0000058eu, + 0x0000058eu, 0x0008000cu, 0x0000001bu, 0x00000590u, 0x00000001u, 0x0000002eu, 0x0000058cu, 0x0000058du, + 0x0000058fu, 0x0003003eu, 0x0000058bu, 0x00000590u, 0x0004003du, 0x00000008u, 0x00000592u, 0x0000045au, + 0x0008000cu, 0x00000008u, 0x00000593u, 0x00000001u, 0x0000002bu, 0x00000592u, 0x00000073u, 0x00000074u, + 0x0003003eu, 0x00000591u, 0x00000593u, 0x0004003du, 0x00000009u, 0x00000596u, 0x00000549u, 0x0003003eu, + 0x00000595u, 0x00000596u, 0x0004003du, 0x00000009u, 0x00000598u, 0x0000056au, 0x0003003eu, 0x00000597u, + 0x00000598u, 0x0004003du, 0x00000008u, 0x0000059au, 0x00000591u, 0x0003003eu, 0x00000599u, 0x0000059au, + 0x00070039u, 0x00000009u, 0x0000059bu, 0x00000019u, 0x00000595u, 0x00000597u, 0x00000599u, 0x0003003eu, + 0x00000594u, 0x0000059bu, 0x00050041u, 0x00000370u, 0x0000059du, 0x000003a2u, 0x00000202u, 0x0004003du, + 0x00000006u, 0x0000059eu, 0x0000059du, 0x00050041u, 0x00000370u, 0x0000059fu, 0x000003c2u, 0x000001f1u, + 0x0004003du, 0x00000006u, 0x000005a0u, 0x0000059fu, 0x00050080u, 0x00000006u, 0x000005a1u, 0x0000059eu, + 0x000005a0u, 0x0004003du, 0x00000006u, 0x000005a2u, 0x00000382u, 0x00050084u, 0x00000006u, 0x000005a3u, + 0x000005a2u, 0x0000005cu, 0x00050080u, 0x00000006u, 0x000005a4u, 0x000005a1u, 0x000005a3u, 0x0003003eu, + 0x0000059cu, 0x000005a4u, 0x0004003du, 0x00000006u, 0x000005a6u, 0x0000059cu, 0x00060041u, 0x0000051cu, + 0x000005a7u, 0x00000516u, 0x00000122u, 0x000005a6u, 0x0004003du, 0x00000008u, 0x000005a8u, 0x000005a7u, + 0x0004003du, 0x00000006u, 0x000005a9u, 0x0000059cu, 0x00050080u, 0x00000006u, 0x000005aau, 0x000005a9u, + 0x00000007u, 0x00060041u, 0x0000051cu, 0x000005abu, 0x00000516u, 0x00000122u, 0x000005aau, 0x0004003du, + 0x00000008u, 0x000005acu, 0x000005abu, 0x0004003du, 0x00000006u, 0x000005adu, 0x0000059cu, 0x00050080u, + 0x00000006u, 0x000005aeu, 0x000005adu, 0x00000055u, 0x00060041u, 0x0000051cu, 0x000005afu, 0x00000516u, + 0x00000122u, 0x000005aeu, 0x0004003du, 0x00000008u, 0x000005b0u, 0x000005afu, 0x00060050u, 0x0000001bu, + 0x000005b1u, 0x000005a8u, 0x000005acu, 0x000005b0u, 0x0003003eu, 0x000005a5u, 0x000005b1u, 0x00050041u, + 0x000005b2u, 0x000005b3u, 0x0000037du, 0x00000221u, 0x0004003du, 0x00000008u, 0x000005b4u, 0x000005b3u, + 0x000500bau, 0x00000029u, 0x000005b5u, 0x000005b4u, 0x00000073u, 0x000300f7u, 0x000005b7u, 0x00000000u, + 0x000400fau, 0x000005b5u, 0x000005b6u, 0x000005b7u, 0x000200f8u, 0x000005b6u, 0x00050041u, 0x00000370u, + 0x000005beu, 0x00000393u, 0x0000012cu, 0x0004003du, 0x00000006u, 0x000005bfu, 0x000005beu, 0x00070041u, + 0x0000051cu, 0x000005c1u, 0x000005bdu, 0x00000122u, 0x000005bfu, 0x000005c0u, 0x0004003du, 0x00000008u, + 0x000005c2u, 0x000005c1u, 0x00050041u, 0x000005b2u, 0x000005c3u, 0x0000037du, 0x00000221u, 0x0004003du, + 0x00000008u, 0x000005c4u, 0x000005c3u, 0x00050085u, 0x00000008u, 0x000005c5u, 0x000005c2u, 0x000005c4u, + 0x0003003eu, 0x000005b8u, 0x000005c5u, 0x0004003du, 0x00000006u, 0x000005ccu, 0x00000379u, 0x00060041u, + 0x000005cdu, 0x000005ceu, 0x000005cbu, 0x00000122u, 0x000005ccu, 0x0004003du, 0x000005c7u, 0x000005cfu, + 0x000005ceu, 0x00040190u, 0x00000031u, 0x000005d0u, 0x000005cfu, 0x0003003eu, 0x000005c6u, 0x000005d0u, + 0x0004003du, 0x00000031u, 0x000005d3u, 0x000005c6u, 0x0003003eu, 0x000005d2u, 0x000005d3u, 0x00050039u, + 0x0000001bu, 0x000005d4u, 0x00000035u, 0x000005d2u, 0x0003003eu, 0x000005d1u, 0x000005d4u, 0x0004003du, + 0x0000001bu, 0x000005d6u, 0x000005d1u, 0x0004003du, 0x00000008u, 0x000005d7u, 0x000005b8u, 0x00060050u, + 0x0000001bu, 0x000005d8u, 0x000005d7u, 0x000005d7u, 0x000005d7u, 0x00050083u, 0x0000001bu, 0x000005d9u, + 0x000005d6u, 0x000005d8u, 0x0003003eu, 0x000005d5u, 0x000005d9u, 0x0004003du, 0x0000001bu, 0x000005dbu, + 0x000005d1u, 0x0004003du, 0x00000008u, 0x000005dcu, 0x000005b8u, 0x00060050u, 0x0000001bu, 0x000005ddu, + 0x000005dcu, 0x000005dcu, 0x000005dcu, 0x00050081u, 0x0000001bu, 0x000005deu, 0x000005dbu, 0x000005ddu, + 0x0003003eu, 0x000005dau, 0x000005deu, 0x0004003du, 0x0000001bu, 0x000005e0u, 0x000005a5u, 0x0006000cu, + 0x00000008u, 0x000005e1u, 0x00000001u, 0x00000042u, 0x000005e0u, 0x0003003eu, 0x000005dfu, 0x000005e1u, + 0x0004003du, 0x0000001bu, 0x000005e3u, 0x0000058bu, 0x0003003eu, 0x000005e2u, 0x000005e3u, 0x0004003du, + 0x00000008u, 0x000005e5u, 0x000005dfu, 0x0003003eu, 0x000005e4u, 0x000005e5u, 0x0004003du, 0x0000001bu, + 0x000005e7u, 0x000005d5u, 0x0003003eu, 0x000005e6u, 0x000005e7u, 0x0004003du, 0x0000001bu, 0x000005e9u, + 0x000005dau, 0x0003003eu, 0x000005e8u, 0x000005e9u, 0x00080039u, 0x00000029u, 0x000005eau, 0x0000002fu, + 0x000005e2u, 0x000005e4u, 0x000005e6u, 0x000005e8u, 0x000400a8u, 0x00000029u, 0x000005ebu, 0x000005eau, + 0x000300f7u, 0x000005edu, 0x00000000u, 0x000400fau, 0x000005ebu, 0x000005ecu, 0x000005edu, 0x000200f8u, + 0x000005ecu, 0x0003003eu, 0x000003d2u, 0x000003dau, 0x000200f9u, 0x000005edu, 0x000200f8u, 0x000005edu, + 0x000200f9u, 0x000005b7u, 0x000200f8u, 0x000005b7u, 0x0004003du, 0x0000001bu, 0x000005f1u, 0x0000058bu, + 0x0003003eu, 0x000005f0u, 0x000005f1u, 0x0004003du, 0x00000009u, 0x000005f3u, 0x00000594u, 0x0003003eu, + 0x000005f2u, 0x000005f3u, 0x0003003eu, 0x000005f4u, 0x000005efu, 0x00070039u, 0x00000022u, 0x000005f5u, + 0x00000027u, 0x000005f0u, 0x000005f2u, 0x000005f4u, 0x0003003eu, 0x000005eeu, 0x000005f5u, 0x00050041u, + 0x00000370u, 0x000005f7u, 0x000003a2u, 0x00000202u, 0x0004003du, 0x00000006u, 0x000005f8u, 0x000005f7u, + 0x00050041u, 0x00000370u, 0x000005f9u, 0x000003c2u, 0x000001fcu, 0x0004003du, 0x00000006u, 0x000005fau, + 0x000005f9u, 0x00050080u, 0x00000006u, 0x000005fbu, 0x000005f8u, 0x000005fau, 0x0004003du, 0x00000006u, + 0x000005fcu, 0x00000382u, 0x00050084u, 0x00000006u, 0x000005fdu, 0x000005fcu, 0x000003ddu, 0x00050080u, + 0x00000006u, 0x000005feu, 0x000005fbu, 0x000005fdu, 0x0003003eu, 0x000005f6u, 0x000005feu, 0x0004003du, + 0x00000006u, 0x00000600u, 0x000005f6u, 0x00060041u, 0x0000051cu, 0x00000601u, 0x00000516u, 0x00000122u, + 0x00000600u, 0x0004003du, 0x00000008u, 0x00000602u, 0x00000601u, 0x0004003du, 0x00000006u, 0x00000603u, + 0x000005f6u, 0x00050080u, 0x00000006u, 0x00000604u, 0x00000603u, 0x00000007u, 0x00060041u, 0x0000051cu, + 0x00000605u, 0x00000516u, 0x00000122u, 0x00000604u, 0x0004003du, 0x00000008u, 0x00000606u, 0x00000605u, + 0x0004003du, 0x00000006u, 0x00000607u, 0x000005f6u, 0x00050080u, 0x00000006u, 0x00000608u, 0x00000607u, + 0x00000055u, 0x00060041u, 0x0000051cu, 0x00000609u, 0x00000516u, 0x00000122u, 0x00000608u, 0x0004003du, + 0x00000008u, 0x0000060au, 0x00000609u, 0x00060050u, 0x0000001bu, 0x0000060bu, 0x00000602u, 0x00000606u, + 0x0000060au, 0x0003003eu, 0x000005ffu, 0x0000060bu, 0x0004003du, 0x00000006u, 0x0000060du, 0x000005f6u, + 0x00050080u, 0x00000006u, 0x0000060eu, 0x0000060du, 0x0000005cu, 0x00060041u, 0x0000051cu, 0x0000060fu, + 0x00000516u, 0x00000122u, 0x0000060eu, 0x0004003du, 0x00000008u, 0x00000610u, 0x0000060fu, 0x0004003du, + 0x00000006u, 0x00000611u, 0x000005f6u, 0x00050080u, 0x00000006u, 0x00000612u, 0x00000611u, 0x0000050fu, + 0x00060041u, 0x0000051cu, 0x00000613u, 0x00000516u, 0x00000122u, 0x00000612u, 0x0004003du, 0x00000008u, + 0x00000614u, 0x00000613u, 0x0004003du, 0x00000006u, 0x00000615u, 0x000005f6u, 0x00050080u, 0x00000006u, + 0x00000617u, 0x00000615u, 0x00000616u, 0x00060041u, 0x0000051cu, 0x00000618u, 0x00000516u, 0x00000122u, + 0x00000617u, 0x0004003du, 0x00000008u, 0x00000619u, 0x00000618u, 0x00060050u, 0x0000001bu, 0x0000061au, + 0x00000610u, 0x00000614u, 0x00000619u, 0x0003003eu, 0x0000060cu, 0x0000061au, 0x00050041u, 0x00000370u, + 0x0000061cu, 0x00000393u, 0x0000012cu, 0x0004003du, 0x00000006u, 0x0000061du, 0x0000061cu, 0x00060041u, + 0x0000061eu, 0x0000061fu, 0x000005bdu, 0x00000122u, 0x0000061du, 0x0004003du, 0x000005b9u, 0x00000620u, + 0x0000061fu, 0x00040190u, 0x00000038u, 0x00000621u, 0x00000620u, 0x0003003eu, 0x0000061bu, 0x00000621u, + 0x0004003du, 0x00000006u, 0x00000623u, 0x00000379u, 0x00060041u, 0x000005cdu, 0x00000624u, 0x000005cbu, + 0x00000122u, 0x00000623u, 0x0004003du, 0x000005c7u, 0x00000625u, 0x00000624u, 0x00040190u, 0x00000031u, + 0x00000626u, 0x00000625u, 0x0003003eu, 0x00000622u, 0x00000626u, 0x00050041u, 0x00000037u, 0x00000628u, + 0x00000622u, 0x00000122u, 0x0004003du, 0x00000022u, 0x00000629u, 0x00000628u, 0x00050051u, 0x00000009u, + 0x0000062au, 0x00000629u, 0x00000000u, 0x0008004fu, 0x0000001bu, 0x0000062bu, 0x0000062au, 0x0000062au, + 0x00000000u, 0x00000001u, 0x00000002u, 0x00050051u, 0x00000009u, 0x0000062cu, 0x00000629u, 0x00000001u, + 0x0008004fu, 0x0000001bu, 0x0000062du, 0x0000062cu, 0x0000062cu, 0x00000000u, 0x00000001u, 0x00000002u, + 0x00050051u, 0x00000009u, 0x0000062eu, 0x00000629u, 0x00000002u, 0x0008004fu, 0x0000001bu, 0x0000062fu, + 0x0000062eu, 0x0000062eu, 0x00000000u, 0x00000001u, 0x00000002u, 0x00060050u, 0x0000001cu, 0x00000630u, + 0x0000062bu, 0x0000062du, 0x0000062fu, 0x0003003eu, 0x00000627u, 0x00000630u, 0x0004003du, 0x0000001cu, + 0x00000632u, 0x00000627u, 0x00040054u, 0x0000001cu, 0x00000633u, 0x00000632u, 0x00050051u, 0x0000001bu, + 0x00000634u, 0x00000633u, 0x00000000u, 0x0004007fu, 0x0000001bu, 0x00000635u, 0x00000634u, 0x00050051u, + 0x0000001bu, 0x00000636u, 0x00000633u, 0x00000001u, 0x0004007fu, 0x0000001bu, 0x00000637u, 0x00000636u, + 0x00050051u, 0x0000001bu, 0x00000638u, 0x00000633u, 0x00000002u, 0x0004007fu, 0x0000001bu, 0x00000639u, + 0x00000638u, 0x00060050u, 0x0000001cu, 0x0000063au, 0x00000635u, 0x00000637u, 0x00000639u, 0x00060041u, + 0x0000000au, 0x0000063bu, 0x00000622u, 0x00000122u, 0x00000182u, 0x0004003du, 0x00000009u, 0x0000063cu, + 0x0000063bu, 0x0008004fu, 0x0000001bu, 0x0000063du, 0x0000063cu, 0x0000063cu, 0x00000000u, 0x00000001u, + 0x00000002u, 0x00050091u, 0x0000001bu, 0x0000063eu, 0x0000063au, 0x0000063du, 0x0003003eu, 0x00000631u, + 0x0000063eu, 0x0004003du, 0x00000022u, 0x00000640u, 0x000005eeu, 0x00050051u, 0x00000009u, 0x00000641u, + 0x00000640u, 0x00000000u, 0x0008004fu, 0x0000001bu, 0x00000642u, 0x00000641u, 0x00000641u, 0x00000000u, + 0x00000001u, 0x00000002u, 0x00050051u, 0x00000009u, 0x00000643u, 0x00000640u, 0x00000001u, 0x0008004fu, + 0x0000001bu, 0x00000644u, 0x00000643u, 0x00000643u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050051u, + 0x00000009u, 0x00000645u, 0x00000640u, 0x00000002u, 0x0008004fu, 0x0000001bu, 0x00000646u, 0x00000645u, + 0x00000645u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00060050u, 0x0000001cu, 0x00000647u, 0x00000642u, + 0x00000644u, 0x00000646u, 0x0003003eu, 0x0000063fu, 0x00000647u, 0x0003003eu, 0x00000648u, 0x00000049u, + 0x0003003eu, 0x00000649u, 0x00000049u, 0x000200f9u, 0x0000064au, 0x000200f8u, 0x0000064au, 0x000400f6u, + 0x0000064cu, 0x0000064du, 0x00000000u, 0x000200f9u, 0x0000064eu, 0x000200f8u, 0x0000064eu, 0x0004003du, + 0x00000006u, 0x0000064fu, 0x00000649u, 0x000500b0u, 0x00000029u, 0x00000650u, 0x0000064fu, 0x000003ddu, + 0x000400fau, 0x00000650u, 0x0000064bu, 0x0000064cu, 0x000200f8u, 0x0000064bu, 0x0004003du, 0x0000001cu, + 0x00000652u, 0x0000063fu, 0x0004003du, 0x00000006u, 0x0000065bu, 0x00000649u, 0x00050041u, 0x00000021u, + 0x0000065eu, 0x0000065du, 0x0000065bu, 0x0004003du, 0x0000001bu, 0x0000065fu, 0x0000065eu, 0x00050091u, + 0x0000001bu, 0x00000660u, 0x00000652u, 0x0000065fu, 0x0003003eu, 0x00000651u, 0x00000660u, 0x0004003du, + 0x00000006u, 0x00000662u, 0x00000649u, 0x00050041u, 0x00000021u, 0x00000664u, 0x00000663u, 0x00000662u, + 0x0004003du, 0x0000001bu, 0x00000665u, 0x00000664u, 0x0005008eu, 0x0000001bu, 0x00000666u, 0x00000665u, + 0x0000019fu, 0x0004003du, 0x0000001bu, 0x00000667u, 0x000005a5u, 0x00050085u, 0x0000001bu, 0x00000668u, + 0x00000666u, 0x00000667u, 0x0003003eu, 0x00000661u, 0x00000668u, 0x0004003du, 0x00000022u, 0x0000066au, + 0x000005eeu, 0x0004003du, 0x0000001bu, 0x0000066bu, 0x00000661u, 0x00050051u, 0x00000008u, 0x0000066cu, + 0x0000066bu, 0x00000000u, 0x00050051u, 0x00000008u, 0x0000066du, 0x0000066bu, 0x00000001u, 0x00050051u, + 0x00000008u, 0x0000066eu, 0x0000066bu, 0x00000002u, 0x00070050u, 0x00000009u, 0x0000066fu, 0x0000066cu, + 0x0000066du, 0x0000066eu, 0x00000074u, 0x00050091u, 0x00000009u, 0x00000670u, 0x0000066au, 0x0000066fu, + 0x0008004fu, 0x0000001bu, 0x00000671u, 0x00000670u, 0x00000670u, 0x00000000u, 0x00000001u, 0x00000002u, + 0x0003003eu, 0x00000669u, 0x00000671u, 0x0004003du, 0x0000001bu, 0x00000672u, 0x00000651u, 0x0004003du, + 0x0000001bu, 0x00000673u, 0x00000631u, 0x0004003du, 0x0000001bu, 0x00000674u, 0x00000669u, 0x00050083u, + 0x0000001bu, 0x00000675u, 0x00000673u, 0x00000674u, 0x00050094u, 0x00000008u, 0x00000676u, 0x00000672u, + 0x00000675u, 0x000500bau, 0x00000029u, 0x00000677u, 0x00000676u, 0x00000073u, 0x000300f7u, 0x00000679u, + 0x00000000u, 0x000400fau, 0x00000677u, 0x00000678u, 0x00000679u, 0x000200f8u, 0x00000678u, 0x0004003du, + 0x00000006u, 0x0000067au, 0x00000649u, 0x000500c4u, 0x00000006u, 0x0000067bu, 0x00000007u, 0x0000067au, + 0x0004003du, 0x00000006u, 0x0000067cu, 0x00000648u, 0x000500c5u, 0x00000006u, 0x0000067du, 0x0000067cu, + 0x0000067bu, 0x0003003eu, 0x00000648u, 0x0000067du, 0x000200f9u, 0x00000679u, 0x000200f8u, 0x00000679u, + 0x000200f9u, 0x0000064du, 0x000200f8u, 0x0000064du, 0x0004003du, 0x00000006u, 0x0000067eu, 0x00000649u, + 0x00050080u, 0x00000006u, 0x0000067fu, 0x0000067eu, 0x0000012cu, 0x0003003eu, 0x00000649u, 0x0000067fu, + 0x000200f9u, 0x0000064au, 0x000200f8u, 0x0000064cu, 0x0004003du, 0x00000006u, 0x00000680u, 0x00000648u, + 0x000500aau, 0x00000029u, 0x00000681u, 0x00000680u, 0x00000049u, 0x000300f7u, 0x00000683u, 0x00000000u, + 0x000400fau, 0x00000681u, 0x00000682u, 0x00000683u, 0x000200f8u, 0x00000682u, 0x0003003eu, 0x000003d2u, + 0x000003dau, 0x000200f9u, 0x00000683u, 0x000200f8u, 0x00000683u, 0x0003003eu, 0x00000684u, 0x00000049u, + 0x00050041u, 0x000005b2u, 0x00000685u, 0x0000037du, 0x000001fcu, 0x0004003du, 0x00000008u, 0x00000686u, + 0x00000685u, 0x000500bau, 0x00000029u, 0x00000687u, 0x00000686u, 0x00000073u, 0x000300f7u, 0x00000689u, + 0x00000000u, 0x000400fau, 0x00000687u, 0x00000688u, 0x00000689u, 0x000200f8u, 0x00000688u, 0x0003003eu, + 0x0000068au, 0x00000049u, 0x000200f9u, 0x0000068bu, 0x000200f8u, 0x0000068bu, 0x000400f6u, 0x0000068du, + 0x0000068eu, 0x00000000u, 0x000200f9u, 0x0000068fu, 0x000200f8u, 0x0000068fu, 0x0004003du, 0x00000006u, + 0x00000690u, 0x0000068au, 0x000500b0u, 0x00000029u, 0x00000692u, 0x00000690u, 0x00000691u, 0x000400fau, + 0x00000692u, 0x0000068cu, 0x0000068du, 0x000200f8u, 0x0000068cu, 0x0004003du, 0x00000006u, 0x000006b0u, + 0x0000068au, 0x00060041u, 0x00000370u, 0x000006b3u, 0x000006b2u, 0x000006b0u, 0x00000049u, 0x0004003du, + 0x00000006u, 0x000006b4u, 0x000006b3u, 0x00050041u, 0x00000021u, 0x000006b7u, 0x000006b6u, 0x000006b4u, + 0x0004003du, 0x0000001bu, 0x000006b8u, 0x000006b7u, 0x0004003du, 0x0000001bu, 0x000006b9u, 0x000005a5u, + 0x00050085u, 0x0000001bu, 0x000006bau, 0x000006b8u, 0x000006b9u, 0x0003003eu, 0x00000693u, 0x000006bau, + 0x0004003du, 0x00000006u, 0x000006bcu, 0x0000068au, 0x00060041u, 0x00000370u, 0x000006beu, 0x000006bdu, + 0x000006bcu, 0x00000007u, 0x0004003du, 0x00000006u, 0x000006bfu, 0x000006beu, 0x00050041u, 0x00000021u, + 0x000006c1u, 0x000006c0u, 0x000006bfu, 0x0004003du, 0x0000001bu, 0x000006c2u, 0x000006c1u, 0x0004003du, + 0x0000001bu, 0x000006c3u, 0x000005a5u, 0x00050085u, 0x0000001bu, 0x000006c4u, 0x000006c2u, 0x000006c3u, + 0x0003003eu, 0x000006bbu, 0x000006c4u, 0x0004003du, 0x00000022u, 0x000006c6u, 0x000005eeu, 0x0004003du, + 0x0000001bu, 0x000006c7u, 0x00000693u, 0x00050051u, 0x00000008u, 0x000006c8u, 0x000006c7u, 0x00000000u, + 0x00050051u, 0x00000008u, 0x000006c9u, 0x000006c7u, 0x00000001u, 0x00050051u, 0x00000008u, 0x000006cau, + 0x000006c7u, 0x00000002u, 0x00070050u, 0x00000009u, 0x000006cbu, 0x000006c8u, 0x000006c9u, 0x000006cau, + 0x00000074u, 0x00050091u, 0x00000009u, 0x000006ccu, 0x000006c6u, 0x000006cbu, 0x0008004fu, 0x0000001bu, + 0x000006cdu, 0x000006ccu, 0x000006ccu, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x000006c5u, + 0x000006cdu, 0x0004003du, 0x00000022u, 0x000006cfu, 0x000005eeu, 0x0004003du, 0x0000001bu, 0x000006d0u, + 0x000006bbu, 0x00050051u, 0x00000008u, 0x000006d1u, 0x000006d0u, 0x00000000u, 0x00050051u, 0x00000008u, + 0x000006d2u, 0x000006d0u, 0x00000001u, 0x00050051u, 0x00000008u, 0x000006d3u, 0x000006d0u, 0x00000002u, + 0x00070050u, 0x00000009u, 0x000006d4u, 0x000006d1u, 0x000006d2u, 0x000006d3u, 0x00000074u, 0x00050091u, + 0x00000009u, 0x000006d5u, 0x000006cfu, 0x000006d4u, 0x0008004fu, 0x0000001bu, 0x000006d6u, 0x000006d5u, + 0x000006d5u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x000006ceu, 0x000006d6u, 0x0004003du, + 0x0000001bu, 0x000006d9u, 0x000006c5u, 0x0003003eu, 0x000006d8u, 0x000006d9u, 0x0004003du, 0x0000001bu, + 0x000006dbu, 0x000006ceu, 0x0003003eu, 0x000006dau, 0x000006dbu, 0x0004003du, 0x00000031u, 0x000006ddu, + 0x00000622u, 0x0003003eu, 0x000006dcu, 0x000006ddu, 0x0004003du, 0x00000038u, 0x000006dfu, 0x0000061bu, + 0x0003003eu, 0x000006deu, 0x000006dfu, 0x00050041u, 0x000005b2u, 0x000006e1u, 0x0000037du, 0x000001fcu, + 0x0004003du, 0x00000008u, 0x000006e2u, 0x000006e1u, 0x0003003eu, 0x000006e0u, 0x000006e2u, 0x00090039u, + 0x00000006u, 0x000006e3u, 0x00000047u, 0x000006d8u, 0x000006dau, 0x000006dcu, 0x000006deu, 0x000006e0u, + 0x0003003eu, 0x000006d7u, 0x000006e3u, 0x0004003du, 0x00000006u, 0x000006e4u, 0x00000684u, 0x0004003du, + 0x00000006u, 0x000006e5u, 0x000006d7u, 0x0007000cu, 0x00000006u, 0x000006e6u, 0x00000001u, 0x00000029u, + 0x000006e4u, 0x000006e5u, 0x0003003eu, 0x00000684u, 0x000006e6u, 0x000200f9u, 0x0000068eu, 0x000200f8u, + 0x0000068eu, 0x0004003du, 0x00000006u, 0x000006e7u, 0x0000068au, 0x00050080u, 0x00000006u, 0x000006e8u, + 0x000006e7u, 0x0000012cu, 0x0003003eu, 0x0000068au, 0x000006e8u, 0x000200f9u, 0x0000068bu, 0x000200f8u, + 0x0000068du, 0x0004003du, 0x00000006u, 0x000006e9u, 0x00000684u, 0x00050041u, 0x0000037eu, 0x000006eau, + 0x0000037du, 0x000005c0u, 0x0004003du, 0x00000006u, 0x000006ebu, 0x000006eau, 0x0007000cu, 0x00000006u, + 0x000006ecu, 0x00000001u, 0x00000026u, 0x000006e9u, 0x000006ebu, 0x0003003eu, 0x00000684u, 0x000006ecu, + 0x000200f9u, 0x00000689u, 0x000200f8u, 0x00000689u, 0x00050041u, 0x00000370u, 0x000006eeu, 0x000003c2u, + 0x00000202u, 0x0004003du, 0x00000006u, 0x000006efu, 0x000006eeu, 0x000500c7u, 0x00000006u, 0x000006f0u, + 0x000006efu, 0x00000007u, 0x000500abu, 0x00000029u, 0x000006f1u, 0x000006f0u, 0x00000049u, 0x000600a9u, + 0x00000006u, 0x000006f2u, 0x000006f1u, 0x000003ddu, 0x00000049u, 0x0003003eu, 0x000006edu, 0x000006f2u, + 0x0004003du, 0x00000029u, 0x000006f3u, 0x000003d2u, 0x000300f7u, 0x000006f6u, 0x00000000u, 0x000400fau, + 0x000006f3u, 0x000006f5u, 0x000006f7u, 0x000200f8u, 0x000006f5u, 0x0003003eu, 0x000006f4u, 0x00000049u, + 0x000200f9u, 0x000006f6u, 0x000200f8u, 0x000006f7u, 0x0004003du, 0x00000006u, 0x000006f8u, 0x000006edu, + 0x00050080u, 0x00000006u, 0x000006f9u, 0x000003ddu, 0x000006f8u, 0x0003003eu, 0x000006f4u, 0x000006f9u, + 0x000200f9u, 0x000006f6u, 0x000200f8u, 0x000006f6u, 0x0004003du, 0x00000006u, 0x000006fau, 0x000006f4u, + 0x0003003eu, 0x00000371u, 0x000006fau, 0x0004003du, 0x00000006u, 0x000006feu, 0x00000379u, 0x00050041u, + 0x000006ffu, 0x00000700u, 0x000006fdu, 0x00000122u, 0x0003003eu, 0x00000700u, 0x000006feu, 0x0004003du, + 0x00000006u, 0x00000701u, 0x00000382u, 0x00050041u, 0x000006ffu, 0x00000702u, 0x000006fdu, 0x0000012cu, + 0x0003003eu, 0x00000702u, 0x00000701u, 0x0004003du, 0x00000022u, 0x00000703u, 0x000005eeu, 0x00050041u, + 0x00000704u, 0x00000705u, 0x000006fdu, 0x00000136u, 0x0003003eu, 0x00000705u, 0x00000703u, 0x0004003du, + 0x0000001bu, 0x00000706u, 0x000005a5u, 0x00050041u, 0x00000707u, 0x00000708u, 0x000006fdu, 0x00000182u, + 0x0003003eu, 0x00000708u, 0x00000706u, 0x0004003du, 0x0000001bu, 0x00000709u, 0x000005ffu, 0x00050041u, + 0x00000707u, 0x0000070au, 0x000006fdu, 0x000001d2u, 0x0003003eu, 0x0000070au, 0x00000709u, 0x0004003du, + 0x0000001bu, 0x0000070bu, 0x0000060cu, 0x00050041u, 0x00000707u, 0x0000070cu, 0x000006fdu, 0x000001d5u, + 0x0003003eu, 0x0000070cu, 0x0000070bu, 0x0004003du, 0x00000006u, 0x0000070du, 0x00000684u, 0x00050041u, + 0x000006ffu, 0x0000070eu, 0x000006fdu, 0x000001dbu, 0x0003003eu, 0x0000070eu, 0x0000070du, 0x00050041u, + 0x00000370u, 0x0000070fu, 0x000003c2u, 0x00000202u, 0x0004003du, 0x00000006u, 0x00000710u, 0x0000070fu, + 0x00050041u, 0x000006ffu, 0x00000711u, 0x000006fdu, 0x000001e1u, 0x0003003eu, 0x00000711u, 0x00000710u, + 0x00050041u, 0x00000370u, 0x00000712u, 0x00000393u, 0x00000182u, 0x0004003du, 0x00000006u, 0x00000713u, + 0x00000712u, 0x000500aau, 0x00000029u, 0x00000714u, 0x00000713u, 0x00000007u, 0x000600a9u, 0x00000008u, + 0x00000715u, 0x00000714u, 0x00000074u, 0x00000073u, 0x00050041u, 0x00000716u, 0x00000717u, 0x000006fdu, + 0x000001e9u, 0x0003003eu, 0x00000717u, 0x00000715u, 0x0004003du, 0x00000006u, 0x00000718u, 0x00000648u, + 0x00050041u, 0x000006ffu, 0x00000719u, 0x000006fdu, 0x000001f1u, 0x0003003eu, 0x00000719u, 0x00000718u, + 0x0004003du, 0x00000006u, 0x0000071au, 0x00000371u, 0x000514aeu, 0x0000071au, 0x00000007u, 0x00000007u, + 0x000006fdu, 0x00010038u, 0x00050036u, 0x00000008u, 0x0000000eu, 0x00000000u, 0x0000000bu, 0x00030037u, + 0x0000000au, 0x0000000cu, 0x00030037u, 0x0000000au, 0x0000000du, 0x000200f8u, 0x0000000fu, 0x00050041u, + 0x00000014u, 0x0000004au, 0x0000000cu, 0x00000049u, 0x0004003du, 0x00000008u, 0x0000004bu, 0x0000004au, + 0x00050041u, 0x00000014u, 0x0000004cu, 0x0000000du, 0x00000049u, 0x0004003du, 0x00000008u, 0x0000004du, + 0x0000004cu, 0x00050085u, 0x00000008u, 0x0000004eu, 0x0000004bu, 0x0000004du, 0x00050041u, 0x00000014u, + 0x0000004fu, 0x0000000cu, 0x00000007u, 0x0004003du, 0x00000008u, 0x00000050u, 0x0000004fu, 0x00050041u, + 0x00000014u, 0x00000051u, 0x0000000du, 0x00000007u, 0x0004003du, 0x00000008u, 0x00000052u, 0x00000051u, + 0x00050085u, 0x00000008u, 0x00000053u, 0x00000050u, 0x00000052u, 0x00050081u, 0x00000008u, 0x00000054u, + 0x0000004eu, 0x00000053u, 0x00050041u, 0x00000014u, 0x00000056u, 0x0000000cu, 0x00000055u, 0x0004003du, + 0x00000008u, 0x00000057u, 0x00000056u, 0x00050041u, 0x00000014u, 0x00000058u, 0x0000000du, 0x00000055u, + 0x0004003du, 0x00000008u, 0x00000059u, 0x00000058u, 0x00050085u, 0x00000008u, 0x0000005au, 0x00000057u, + 0x00000059u, 0x00050081u, 0x00000008u, 0x0000005bu, 0x00000054u, 0x0000005au, 0x00050041u, 0x00000014u, + 0x0000005du, 0x0000000cu, 0x0000005cu, 0x0004003du, 0x00000008u, 0x0000005eu, 0x0000005du, 0x00050041u, + 0x00000014u, 0x0000005fu, 0x0000000du, 0x0000005cu, 0x0004003du, 0x00000008u, 0x00000060u, 0x0000005fu, + 0x00050085u, 0x00000008u, 0x00000061u, 0x0000005eu, 0x00000060u, 0x00050081u, 0x00000008u, 0x00000062u, + 0x0000005bu, 0x00000061u, 0x000200feu, 0x00000062u, 0x00010038u, 0x00050036u, 0x00000009u, 0x00000012u, + 0x00000000u, 0x00000010u, 0x00030037u, 0x0000000au, 0x00000011u, 0x000200f8u, 0x00000013u, 0x0004003bu, + 0x00000014u, 0x00000065u, 0x00000007u, 0x0004003bu, 0x0000000au, 0x0000006bu, 0x00000007u, 0x0004003du, + 0x00000009u, 0x00000066u, 0x00000011u, 0x0006000cu, 0x00000008u, 0x00000067u, 0x00000001u, 0x00000042u, + 0x00000066u, 0x0003003eu, 0x00000065u, 0x00000067u, 0x0004003du, 0x00000008u, 0x00000068u, 0x00000065u, + 0x000500bau, 0x00000029u, 0x0000006au, 0x00000068u, 0x00000069u, 0x000300f7u, 0x0000006du, 0x00000000u, + 0x000400fau, 0x0000006au, 0x0000006cu, 0x00000072u, 0x000200f8u, 0x0000006cu, 0x0004003du, 0x00000009u, + 0x0000006eu, 0x00000011u, 0x0004003du, 0x00000008u, 0x0000006fu, 0x00000065u, 0x00070050u, 0x00000009u, + 0x00000070u, 0x0000006fu, 0x0000006fu, 0x0000006fu, 0x0000006fu, 0x00050088u, 0x00000009u, 0x00000071u, + 0x0000006eu, 0x00000070u, 0x0003003eu, 0x0000006bu, 0x00000071u, 0x000200f9u, 0x0000006du, 0x000200f8u, + 0x00000072u, 0x0003003eu, 0x0000006bu, 0x00000075u, 0x000200f9u, 0x0000006du, 0x000200f8u, 0x0000006du, + 0x0004003du, 0x00000009u, 0x00000076u, 0x0000006bu, 0x000200feu, 0x00000076u, 0x00010038u, 0x00050036u, + 0x00000009u, 0x00000019u, 0x00000000u, 0x00000015u, 0x00030037u, 0x0000000au, 0x00000016u, 0x00030037u, + 0x0000000au, 0x00000017u, 0x00030037u, 0x00000014u, 0x00000018u, 0x000200f8u, 0x0000001au, 0x0004003bu, + 0x00000014u, 0x00000079u, 0x00000007u, 0x0004003bu, 0x0000000au, 0x0000007au, 0x00000007u, 0x0004003bu, + 0x0000000au, 0x0000007cu, 0x00000007u, 0x0004003bu, 0x0000000au, 0x00000091u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x00000094u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000099u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x0000009du, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000a0u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000000a3u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000acu, 0x00000007u, 0x0004003bu, + 0x0000000au, 0x000000b7u, 0x00000007u, 0x0004003du, 0x00000009u, 0x0000007bu, 0x00000016u, 0x0003003eu, + 0x0000007au, 0x0000007bu, 0x0004003du, 0x00000009u, 0x0000007du, 0x00000017u, 0x0003003eu, 0x0000007cu, + 0x0000007du, 0x00060039u, 0x00000008u, 0x0000007eu, 0x0000000eu, 0x0000007au, 0x0000007cu, 0x0003003eu, + 0x00000079u, 0x0000007eu, 0x0004003du, 0x00000008u, 0x0000007fu, 0x00000079u, 0x000500b8u, 0x00000029u, + 0x00000080u, 0x0000007fu, 0x00000073u, 0x000300f7u, 0x00000082u, 0x00000000u, 0x000400fau, 0x00000080u, + 0x00000081u, 0x00000082u, 0x000200f8u, 0x00000081u, 0x0004003du, 0x00000009u, 0x00000083u, 0x00000017u, + 0x0004007fu, 0x00000009u, 0x00000084u, 0x00000083u, 0x0003003eu, 0x00000017u, 0x00000084u, 0x0004003du, + 0x00000008u, 0x00000085u, 0x00000079u, 0x0004007fu, 0x00000008u, 0x00000086u, 0x00000085u, 0x0003003eu, + 0x00000079u, 0x00000086u, 0x000200f9u, 0x00000082u, 0x000200f8u, 0x00000082u, 0x0004003du, 0x00000008u, + 0x00000087u, 0x00000079u, 0x000500bau, 0x00000029u, 0x00000089u, 0x00000087u, 0x00000088u, 0x000300f7u, + 0x0000008bu, 0x00000000u, 0x000400fau, 0x00000089u, 0x0000008au, 0x0000008bu, 0x000200f8u, 0x0000008au, + 0x0004003du, 0x00000009u, 0x0000008cu, 0x00000016u, 0x0004003du, 0x00000009u, 0x0000008du, 0x00000017u, + 0x0004003du, 0x00000008u, 0x0000008eu, 0x00000018u, 0x00070050u, 0x00000009u, 0x0000008fu, 0x0000008eu, + 0x0000008eu, 0x0000008eu, 0x0000008eu, 0x0008000cu, 0x00000009u, 0x00000090u, 0x00000001u, 0x0000002eu, + 0x0000008cu, 0x0000008du, 0x0000008fu, 0x0003003eu, 0x00000091u, 0x00000090u, 0x00050039u, 0x00000009u, + 0x00000092u, 0x00000012u, 0x00000091u, 0x000200feu, 0x00000092u, 0x000200f8u, 0x0000008bu, 0x0004003du, + 0x00000008u, 0x00000095u, 0x00000079u, 0x0008000cu, 0x00000008u, 0x00000097u, 0x00000001u, 0x0000002bu, + 0x00000095u, 0x00000096u, 0x00000074u, 0x0006000cu, 0x00000008u, 0x00000098u, 0x00000001u, 0x00000011u, + 0x00000097u, 0x0003003eu, 0x00000094u, 0x00000098u, 0x0004003du, 0x00000008u, 0x0000009au, 0x00000094u, + 0x0004003du, 0x00000008u, 0x0000009bu, 0x00000018u, 0x00050085u, 0x00000008u, 0x0000009cu, 0x0000009au, + 0x0000009bu, 0x0003003eu, 0x00000099u, 0x0000009cu, 0x0004003du, 0x00000008u, 0x0000009eu, 0x00000099u, + 0x0006000cu, 0x00000008u, 0x0000009fu, 0x00000001u, 0x0000000du, 0x0000009eu, 0x0003003eu, 0x0000009du, + 0x0000009fu, 0x0004003du, 0x00000008u, 0x000000a1u, 0x00000094u, 0x0006000cu, 0x00000008u, 0x000000a2u, + 0x00000001u, 0x0000000du, 0x000000a1u, 0x0003003eu, 0x000000a0u, 0x000000a2u, 0x0004003du, 0x00000008u, + 0x000000a4u, 0x00000099u, 0x0006000cu, 0x00000008u, 0x000000a5u, 0x00000001u, 0x0000000eu, 0x000000a4u, + 0x0004003du, 0x00000008u, 0x000000a6u, 0x00000079u, 0x0004003du, 0x00000008u, 0x000000a7u, 0x0000009du, + 0x00050085u, 0x00000008u, 0x000000a8u, 0x000000a6u, 0x000000a7u, 0x0004003du, 0x00000008u, 0x000000a9u, + 0x000000a0u, 0x00050088u, 0x00000008u, 0x000000aau, 0x000000a8u, 0x000000a9u, 0x00050083u, 0x00000008u, + 0x000000abu, 0x000000a5u, 0x000000aau, 0x0003003eu, 0x000000a3u, 0x000000abu, 0x0004003du, 0x00000008u, + 0x000000adu, 0x0000009du, 0x0004003du, 0x00000008u, 0x000000aeu, 0x000000a0u, 0x00050088u, 0x00000008u, + 0x000000afu, 0x000000adu, 0x000000aeu, 0x0003003eu, 0x000000acu, 0x000000afu, 0x0004003du, 0x00000008u, + 0x000000b0u, 0x000000a3u, 0x0004003du, 0x00000009u, 0x000000b1u, 0x00000016u, 0x0005008eu, 0x00000009u, + 0x000000b2u, 0x000000b1u, 0x000000b0u, 0x0004003du, 0x00000008u, 0x000000b3u, 0x000000acu, 0x0004003du, + 0x00000009u, 0x000000b4u, 0x00000017u, 0x0005008eu, 0x00000009u, 0x000000b5u, 0x000000b4u, 0x000000b3u, + 0x00050081u, 0x00000009u, 0x000000b6u, 0x000000b2u, 0x000000b5u, 0x0003003eu, 0x000000b7u, 0x000000b6u, + 0x00050039u, 0x00000009u, 0x000000b8u, 0x00000012u, 0x000000b7u, 0x000200feu, 0x000000b8u, 0x00010038u, + 0x00050036u, 0x0000001cu, 0x0000001fu, 0x00000000u, 0x0000001du, 0x00030037u, 0x0000000au, 0x0000001eu, + 0x000200f8u, 0x00000020u, 0x0004003bu, 0x00000014u, 0x000000bbu, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000beu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000c1u, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000c4u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000c7u, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000cbu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000cfu, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000d3u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000d7u, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000dbu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000dfu, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000e3u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000e7u, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000ebu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000000efu, 0x00000007u, 0x0004003bu, 0x00000014u, + 0x000000f3u, 0x00000007u, 0x00050041u, 0x00000014u, 0x000000bcu, 0x0000001eu, 0x00000049u, 0x0004003du, + 0x00000008u, 0x000000bdu, 0x000000bcu, 0x0003003eu, 0x000000bbu, 0x000000bdu, 0x00050041u, 0x00000014u, + 0x000000bfu, 0x0000001eu, 0x00000007u, 0x0004003du, 0x00000008u, 0x000000c0u, 0x000000bfu, 0x0003003eu, + 0x000000beu, 0x000000c0u, 0x00050041u, 0x00000014u, 0x000000c2u, 0x0000001eu, 0x00000055u, 0x0004003du, + 0x00000008u, 0x000000c3u, 0x000000c2u, 0x0003003eu, 0x000000c1u, 0x000000c3u, 0x00050041u, 0x00000014u, + 0x000000c5u, 0x0000001eu, 0x0000005cu, 0x0004003du, 0x00000008u, 0x000000c6u, 0x000000c5u, 0x0003003eu, + 0x000000c4u, 0x000000c6u, 0x0004003du, 0x00000008u, 0x000000c8u, 0x000000bbu, 0x0004003du, 0x00000008u, + 0x000000c9u, 0x000000bbu, 0x00050081u, 0x00000008u, 0x000000cau, 0x000000c8u, 0x000000c9u, 0x0003003eu, + 0x000000c7u, 0x000000cau, 0x0004003du, 0x00000008u, 0x000000ccu, 0x000000beu, 0x0004003du, 0x00000008u, + 0x000000cdu, 0x000000beu, 0x00050081u, 0x00000008u, 0x000000ceu, 0x000000ccu, 0x000000cdu, 0x0003003eu, + 0x000000cbu, 0x000000ceu, 0x0004003du, 0x00000008u, 0x000000d0u, 0x000000c1u, 0x0004003du, 0x00000008u, + 0x000000d1u, 0x000000c1u, 0x00050081u, 0x00000008u, 0x000000d2u, 0x000000d0u, 0x000000d1u, 0x0003003eu, + 0x000000cfu, 0x000000d2u, 0x0004003du, 0x00000008u, 0x000000d4u, 0x000000bbu, 0x0004003du, 0x00000008u, + 0x000000d5u, 0x000000c7u, 0x00050085u, 0x00000008u, 0x000000d6u, 0x000000d4u, 0x000000d5u, 0x0003003eu, + 0x000000d3u, 0x000000d6u, 0x0004003du, 0x00000008u, 0x000000d8u, 0x000000bbu, 0x0004003du, 0x00000008u, + 0x000000d9u, 0x000000cbu, 0x00050085u, 0x00000008u, 0x000000dau, 0x000000d8u, 0x000000d9u, 0x0003003eu, + 0x000000d7u, 0x000000dau, 0x0004003du, 0x00000008u, 0x000000dcu, 0x000000bbu, 0x0004003du, 0x00000008u, + 0x000000ddu, 0x000000cfu, 0x00050085u, 0x00000008u, 0x000000deu, 0x000000dcu, 0x000000ddu, 0x0003003eu, + 0x000000dbu, 0x000000deu, 0x0004003du, 0x00000008u, 0x000000e0u, 0x000000beu, 0x0004003du, 0x00000008u, + 0x000000e1u, 0x000000cbu, 0x00050085u, 0x00000008u, 0x000000e2u, 0x000000e0u, 0x000000e1u, 0x0003003eu, + 0x000000dfu, 0x000000e2u, 0x0004003du, 0x00000008u, 0x000000e4u, 0x000000beu, 0x0004003du, 0x00000008u, + 0x000000e5u, 0x000000cfu, 0x00050085u, 0x00000008u, 0x000000e6u, 0x000000e4u, 0x000000e5u, 0x0003003eu, + 0x000000e3u, 0x000000e6u, 0x0004003du, 0x00000008u, 0x000000e8u, 0x000000c1u, 0x0004003du, 0x00000008u, + 0x000000e9u, 0x000000cfu, 0x00050085u, 0x00000008u, 0x000000eau, 0x000000e8u, 0x000000e9u, 0x0003003eu, + 0x000000e7u, 0x000000eau, 0x0004003du, 0x00000008u, 0x000000ecu, 0x000000c4u, 0x0004003du, 0x00000008u, + 0x000000edu, 0x000000c7u, 0x00050085u, 0x00000008u, 0x000000eeu, 0x000000ecu, 0x000000edu, 0x0003003eu, + 0x000000ebu, 0x000000eeu, 0x0004003du, 0x00000008u, 0x000000f0u, 0x000000c4u, 0x0004003du, 0x00000008u, + 0x000000f1u, 0x000000cbu, 0x00050085u, 0x00000008u, 0x000000f2u, 0x000000f0u, 0x000000f1u, 0x0003003eu, + 0x000000efu, 0x000000f2u, 0x0004003du, 0x00000008u, 0x000000f4u, 0x000000c4u, 0x0004003du, 0x00000008u, + 0x000000f5u, 0x000000cfu, 0x00050085u, 0x00000008u, 0x000000f6u, 0x000000f4u, 0x000000f5u, 0x0003003eu, + 0x000000f3u, 0x000000f6u, 0x0004003du, 0x00000008u, 0x000000f7u, 0x000000dfu, 0x0004003du, 0x00000008u, + 0x000000f8u, 0x000000e7u, 0x00050081u, 0x00000008u, 0x000000f9u, 0x000000f7u, 0x000000f8u, 0x00050083u, + 0x00000008u, 0x000000fau, 0x00000074u, 0x000000f9u, 0x0004003du, 0x00000008u, 0x000000fbu, 0x000000d7u, + 0x0004003du, 0x00000008u, 0x000000fcu, 0x000000f3u, 0x00050081u, 0x00000008u, 0x000000fdu, 0x000000fbu, + 0x000000fcu, 0x0004003du, 0x00000008u, 0x000000feu, 0x000000dbu, 0x0004003du, 0x00000008u, 0x000000ffu, + 0x000000efu, 0x00050083u, 0x00000008u, 0x00000100u, 0x000000feu, 0x000000ffu, 0x0004003du, 0x00000008u, + 0x00000101u, 0x000000d7u, 0x0004003du, 0x00000008u, 0x00000102u, 0x000000f3u, 0x00050083u, 0x00000008u, + 0x00000103u, 0x00000101u, 0x00000102u, 0x0004003du, 0x00000008u, 0x00000104u, 0x000000d3u, 0x0004003du, + 0x00000008u, 0x00000105u, 0x000000e7u, 0x00050081u, 0x00000008u, 0x00000106u, 0x00000104u, 0x00000105u, + 0x00050083u, 0x00000008u, 0x00000107u, 0x00000074u, 0x00000106u, 0x0004003du, 0x00000008u, 0x00000108u, + 0x000000e3u, 0x0004003du, 0x00000008u, 0x00000109u, 0x000000ebu, 0x00050081u, 0x00000008u, 0x0000010au, + 0x00000108u, 0x00000109u, 0x0004003du, 0x00000008u, 0x0000010bu, 0x000000dbu, 0x0004003du, 0x00000008u, + 0x0000010cu, 0x000000efu, 0x00050081u, 0x00000008u, 0x0000010du, 0x0000010bu, 0x0000010cu, 0x0004003du, + 0x00000008u, 0x0000010eu, 0x000000e3u, 0x0004003du, 0x00000008u, 0x0000010fu, 0x000000ebu, 0x00050083u, + 0x00000008u, 0x00000110u, 0x0000010eu, 0x0000010fu, 0x0004003du, 0x00000008u, 0x00000111u, 0x000000d3u, + 0x0004003du, 0x00000008u, 0x00000112u, 0x000000dfu, 0x00050081u, 0x00000008u, 0x00000113u, 0x00000111u, + 0x00000112u, 0x00050083u, 0x00000008u, 0x00000114u, 0x00000074u, 0x00000113u, 0x00060050u, 0x0000001bu, + 0x00000115u, 0x000000fau, 0x000000fdu, 0x00000100u, 0x00060050u, 0x0000001bu, 0x00000116u, 0x00000103u, + 0x00000107u, 0x0000010au, 0x00060050u, 0x0000001bu, 0x00000117u, 0x0000010du, 0x00000110u, 0x00000114u, + 0x00060050u, 0x0000001cu, 0x00000118u, 0x00000115u, 0x00000116u, 0x00000117u, 0x000200feu, 0x00000118u, + 0x00010038u, 0x00050036u, 0x00000022u, 0x00000027u, 0x00000000u, 0x00000023u, 0x00030037u, 0x00000021u, + 0x00000024u, 0x00030037u, 0x0000000au, 0x00000025u, 0x00030037u, 0x00000021u, 0x00000026u, 0x000200f8u, + 0x00000028u, 0x0004003bu, 0x0000011bu, 0x0000011cu, 0x00000007u, 0x0004003bu, 0x0000000au, 0x0000011du, + 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000120u, 0x00000007u, 0x0004003du, 0x00000009u, 0x0000011eu, + 0x00000025u, 0x0003003eu, 0x0000011du, 0x0000011eu, 0x00050039u, 0x0000001cu, 0x0000011fu, 0x0000001fu, + 0x0000011du, 0x0003003eu, 0x0000011cu, 0x0000011fu, 0x00050041u, 0x00000021u, 0x00000123u, 0x0000011cu, + 0x00000122u, 0x0004003du, 0x0000001bu, 0x00000124u, 0x00000123u, 0x00050041u, 0x00000014u, 0x00000125u, + 0x00000026u, 0x00000049u, 0x0004003du, 0x00000008u, 0x00000126u, 0x00000125u, 0x0005008eu, 0x0000001bu, + 0x00000127u, 0x00000124u, 0x00000126u, 0x00050051u, 0x00000008u, 0x00000128u, 0x00000127u, 0x00000000u, + 0x00050051u, 0x00000008u, 0x00000129u, 0x00000127u, 0x00000001u, 0x00050051u, 0x00000008u, 0x0000012au, + 0x00000127u, 0x00000002u, 0x00070050u, 0x00000009u, 0x0000012bu, 0x00000128u, 0x00000129u, 0x0000012au, + 0x00000073u, 0x00050041u, 0x00000021u, 0x0000012du, 0x0000011cu, 0x0000012cu, 0x0004003du, 0x0000001bu, + 0x0000012eu, 0x0000012du, 0x00050041u, 0x00000014u, 0x0000012fu, 0x00000026u, 0x00000007u, 0x0004003du, + 0x00000008u, 0x00000130u, 0x0000012fu, 0x0005008eu, 0x0000001bu, 0x00000131u, 0x0000012eu, 0x00000130u, + 0x00050051u, 0x00000008u, 0x00000132u, 0x00000131u, 0x00000000u, 0x00050051u, 0x00000008u, 0x00000133u, + 0x00000131u, 0x00000001u, 0x00050051u, 0x00000008u, 0x00000134u, 0x00000131u, 0x00000002u, 0x00070050u, + 0x00000009u, 0x00000135u, 0x00000132u, 0x00000133u, 0x00000134u, 0x00000073u, 0x00050041u, 0x00000021u, + 0x00000137u, 0x0000011cu, 0x00000136u, 0x0004003du, 0x0000001bu, 0x00000138u, 0x00000137u, 0x00050041u, + 0x00000014u, 0x00000139u, 0x00000026u, 0x00000055u, 0x0004003du, 0x00000008u, 0x0000013au, 0x00000139u, + 0x0005008eu, 0x0000001bu, 0x0000013bu, 0x00000138u, 0x0000013au, 0x00050051u, 0x00000008u, 0x0000013cu, + 0x0000013bu, 0x00000000u, 0x00050051u, 0x00000008u, 0x0000013du, 0x0000013bu, 0x00000001u, 0x00050051u, + 0x00000008u, 0x0000013eu, 0x0000013bu, 0x00000002u, 0x00070050u, 0x00000009u, 0x0000013fu, 0x0000013cu, + 0x0000013du, 0x0000013eu, 0x00000073u, 0x0004003du, 0x0000001bu, 0x00000140u, 0x00000024u, 0x00050051u, + 0x00000008u, 0x00000141u, 0x00000140u, 0x00000000u, 0x00050051u, 0x00000008u, 0x00000142u, 0x00000140u, + 0x00000001u, 0x00050051u, 0x00000008u, 0x00000143u, 0x00000140u, 0x00000002u, 0x00070050u, 0x00000009u, + 0x00000144u, 0x00000141u, 0x00000142u, 0x00000143u, 0x00000074u, 0x00050051u, 0x00000008u, 0x00000145u, + 0x0000012bu, 0x00000000u, 0x00050051u, 0x00000008u, 0x00000146u, 0x0000012bu, 0x00000001u, 0x00050051u, + 0x00000008u, 0x00000147u, 0x0000012bu, 0x00000002u, 0x00050051u, 0x00000008u, 0x00000148u, 0x0000012bu, + 0x00000003u, 0x00050051u, 0x00000008u, 0x00000149u, 0x00000135u, 0x00000000u, 0x00050051u, 0x00000008u, + 0x0000014au, 0x00000135u, 0x00000001u, 0x00050051u, 0x00000008u, 0x0000014bu, 0x00000135u, 0x00000002u, + 0x00050051u, 0x00000008u, 0x0000014cu, 0x00000135u, 0x00000003u, 0x00050051u, 0x00000008u, 0x0000014du, + 0x0000013fu, 0x00000000u, 0x00050051u, 0x00000008u, 0x0000014eu, 0x0000013fu, 0x00000001u, 0x00050051u, + 0x00000008u, 0x0000014fu, 0x0000013fu, 0x00000002u, 0x00050051u, 0x00000008u, 0x00000150u, 0x0000013fu, + 0x00000003u, 0x00050051u, 0x00000008u, 0x00000151u, 0x00000144u, 0x00000000u, 0x00050051u, 0x00000008u, + 0x00000152u, 0x00000144u, 0x00000001u, 0x00050051u, 0x00000008u, 0x00000153u, 0x00000144u, 0x00000002u, + 0x00050051u, 0x00000008u, 0x00000154u, 0x00000144u, 0x00000003u, 0x00070050u, 0x00000009u, 0x00000155u, + 0x00000145u, 0x00000146u, 0x00000147u, 0x00000148u, 0x00070050u, 0x00000009u, 0x00000156u, 0x00000149u, + 0x0000014au, 0x0000014bu, 0x0000014cu, 0x00070050u, 0x00000009u, 0x00000157u, 0x0000014du, 0x0000014eu, + 0x0000014fu, 0x00000150u, 0x00070050u, 0x00000009u, 0x00000158u, 0x00000151u, 0x00000152u, 0x00000153u, + 0x00000154u, 0x00070050u, 0x00000022u, 0x00000159u, 0x00000155u, 0x00000156u, 0x00000157u, 0x00000158u, + 0x0003003eu, 0x00000120u, 0x00000159u, 0x0004003du, 0x00000022u, 0x0000015au, 0x00000120u, 0x000200feu, + 0x0000015au, 0x00010038u, 0x00050036u, 0x00000029u, 0x0000002fu, 0x00000000u, 0x0000002au, 0x00030037u, + 0x00000021u, 0x0000002bu, 0x00030037u, 0x00000014u, 0x0000002cu, 0x00030037u, 0x00000021u, 0x0000002du, + 0x00030037u, 0x00000021u, 0x0000002eu, 0x000200f8u, 0x00000030u, 0x0004003bu, 0x00000021u, 0x0000015du, + 0x00000007u, 0x0004003bu, 0x00000021u, 0x00000162u, 0x00000007u, 0x0004003du, 0x0000001bu, 0x0000015eu, + 0x0000002bu, 0x0004003du, 0x0000001bu, 0x0000015fu, 0x0000002du, 0x0004003du, 0x0000001bu, 0x00000160u, + 0x0000002eu, 0x0008000cu, 0x0000001bu, 0x00000161u, 0x00000001u, 0x0000002bu, 0x0000015eu, 0x0000015fu, + 0x00000160u, 0x0003003eu, 0x0000015du, 0x00000161u, 0x0004003du, 0x0000001bu, 0x00000163u, 0x0000002bu, + 0x0004003du, 0x0000001bu, 0x00000164u, 0x0000015du, 0x00050083u, 0x0000001bu, 0x00000165u, 0x00000163u, + 0x00000164u, 0x0003003eu, 0x00000162u, 0x00000165u, 0x0004003du, 0x0000001bu, 0x00000166u, 0x00000162u, + 0x0004003du, 0x0000001bu, 0x00000167u, 0x00000162u, 0x00050094u, 0x00000008u, 0x00000168u, 0x00000166u, + 0x00000167u, 0x0004003du, 0x00000008u, 0x00000169u, 0x0000002cu, 0x0004003du, 0x00000008u, 0x0000016au, + 0x0000002cu, 0x00050085u, 0x00000008u, 0x0000016bu, 0x00000169u, 0x0000016au, 0x000500bcu, 0x00000029u, + 0x0000016cu, 0x00000168u, 0x0000016bu, 0x000200feu, 0x0000016cu, 0x00010038u, 0x00050036u, 0x0000001bu, + 0x00000035u, 0x00000000u, 0x00000033u, 0x00030037u, 0x00000032u, 0x00000034u, 0x000200f8u, 0x00000036u, + 0x0004003bu, 0x0000011bu, 0x0000016fu, 0x00000007u, 0x00050041u, 0x00000037u, 0x00000170u, 0x00000034u, + 0x00000122u, 0x0004003du, 0x00000022u, 0x00000171u, 0x00000170u, 0x00050051u, 0x00000009u, 0x00000172u, + 0x00000171u, 0x00000000u, 0x0008004fu, 0x0000001bu, 0x00000173u, 0x00000172u, 0x00000172u, 0x00000000u, + 0x00000001u, 0x00000002u, 0x00050051u, 0x00000009u, 0x00000174u, 0x00000171u, 0x00000001u, 0x0008004fu, + 0x0000001bu, 0x00000175u, 0x00000174u, 0x00000174u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00050051u, + 0x00000009u, 0x00000176u, 0x00000171u, 0x00000002u, 0x0008004fu, 0x0000001bu, 0x00000177u, 0x00000176u, + 0x00000176u, 0x00000000u, 0x00000001u, 0x00000002u, 0x00060050u, 0x0000001cu, 0x00000178u, 0x00000173u, + 0x00000175u, 0x00000177u, 0x0003003eu, 0x0000016fu, 0x00000178u, 0x0004003du, 0x0000001cu, 0x00000179u, + 0x0000016fu, 0x00040054u, 0x0000001cu, 0x0000017au, 0x00000179u, 0x00050051u, 0x0000001bu, 0x0000017bu, + 0x0000017au, 0x00000000u, 0x0004007fu, 0x0000001bu, 0x0000017cu, 0x0000017bu, 0x00050051u, 0x0000001bu, + 0x0000017du, 0x0000017au, 0x00000001u, 0x0004007fu, 0x0000001bu, 0x0000017eu, 0x0000017du, 0x00050051u, + 0x0000001bu, 0x0000017fu, 0x0000017au, 0x00000002u, 0x0004007fu, 0x0000001bu, 0x00000180u, 0x0000017fu, + 0x00060050u, 0x0000001cu, 0x00000181u, 0x0000017cu, 0x0000017eu, 0x00000180u, 0x00060041u, 0x0000000au, + 0x00000183u, 0x00000034u, 0x00000122u, 0x00000182u, 0x0004003du, 0x00000009u, 0x00000184u, 0x00000183u, + 0x0008004fu, 0x0000001bu, 0x00000185u, 0x00000184u, 0x00000184u, 0x00000000u, 0x00000001u, 0x00000002u, + 0x00050091u, 0x0000001bu, 0x00000186u, 0x00000181u, 0x00000185u, 0x000200feu, 0x00000186u, 0x00010038u, + 0x00050036u, 0x00000008u, 0x0000003fu, 0x00000000u, 0x0000003au, 0x00030037u, 0x00000021u, 0x0000003bu, + 0x00030037u, 0x00000021u, 0x0000003cu, 0x00030037u, 0x00000037u, 0x0000003du, 0x00030037u, 0x00000039u, + 0x0000003eu, 0x000200f8u, 0x00000040u, 0x0004003bu, 0x00000021u, 0x00000189u, 0x00000007u, 0x0004003bu, + 0x00000021u, 0x00000192u, 0x00000007u, 0x0004003bu, 0x00000021u, 0x0000019bu, 0x00000007u, 0x0004003bu, + 0x00000021u, 0x000001a1u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000001aau, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000001afu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000001b3u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000001b7u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000001bcu, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000001c5u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000001cau, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000001cdu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000001d1u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x0000020eu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000212u, 0x00000007u, 0x0004003bu, + 0x0000021au, 0x0000021bu, 0x00000007u, 0x0004003bu, 0x0000021au, 0x00000220u, 0x00000007u, 0x0004003bu, + 0x0000021au, 0x0000023cu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000244u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x00000248u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000251u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x00000256u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000259u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x0000025du, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000291u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x00000294u, 0x00000007u, 0x0004003bu, 0x0000021au, 0x0000029cu, 0x00000007u, 0x0004003bu, + 0x0000021au, 0x000002a1u, 0x00000007u, 0x0004003bu, 0x0000021au, 0x000002b9u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000002c1u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000002c5u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000002ceu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000002d3u, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x000002d6u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x000002dau, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x0000030eu, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000311u, 0x00000007u, 0x0004003bu, + 0x0000021au, 0x00000319u, 0x00000007u, 0x0004003bu, 0x0000021au, 0x0000031eu, 0x00000007u, 0x0004003bu, + 0x0000021au, 0x00000336u, 0x00000007u, 0x0004003bu, 0x0000021au, 0x0000033eu, 0x00000007u, 0x0004003bu, + 0x00000014u, 0x00000343u, 0x00000007u, 0x0004003du, 0x00000022u, 0x0000018au, 0x0000003du, 0x0004003du, + 0x0000001bu, 0x0000018bu, 0x0000003bu, 0x00050051u, 0x00000008u, 0x0000018cu, 0x0000018bu, 0x00000000u, + 0x00050051u, 0x00000008u, 0x0000018du, 0x0000018bu, 0x00000001u, 0x00050051u, 0x00000008u, 0x0000018eu, + 0x0000018bu, 0x00000002u, 0x00070050u, 0x00000009u, 0x0000018fu, 0x0000018cu, 0x0000018du, 0x0000018eu, + 0x00000074u, 0x00050091u, 0x00000009u, 0x00000190u, 0x0000018au, 0x0000018fu, 0x0008004fu, 0x0000001bu, + 0x00000191u, 0x00000190u, 0x00000190u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000189u, + 0x00000191u, 0x0004003du, 0x00000022u, 0x00000193u, 0x0000003du, 0x0004003du, 0x0000001bu, 0x00000194u, + 0x0000003cu, 0x00050051u, 0x00000008u, 0x00000195u, 0x00000194u, 0x00000000u, 0x00050051u, 0x00000008u, + 0x00000196u, 0x00000194u, 0x00000001u, 0x00050051u, 0x00000008u, 0x00000197u, 0x00000194u, 0x00000002u, + 0x00070050u, 0x00000009u, 0x00000198u, 0x00000195u, 0x00000196u, 0x00000197u, 0x00000074u, 0x00050091u, + 0x00000009u, 0x00000199u, 0x00000193u, 0x00000198u, 0x0008004fu, 0x0000001bu, 0x0000019au, 0x00000199u, + 0x00000199u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000192u, 0x0000019au, 0x0004003du, + 0x0000001bu, 0x0000019cu, 0x0000003bu, 0x0004003du, 0x0000001bu, 0x0000019du, 0x0000003cu, 0x00050081u, + 0x0000001bu, 0x0000019eu, 0x0000019cu, 0x0000019du, 0x0005008eu, 0x0000001bu, 0x000001a0u, 0x0000019eu, + 0x0000019fu, 0x0003003eu, 0x0000019bu, 0x000001a0u, 0x0004003du, 0x00000022u, 0x000001a2u, 0x0000003du, + 0x0004003du, 0x0000001bu, 0x000001a3u, 0x0000019bu, 0x00050051u, 0x00000008u, 0x000001a4u, 0x000001a3u, + 0x00000000u, 0x00050051u, 0x00000008u, 0x000001a5u, 0x000001a3u, 0x00000001u, 0x00050051u, 0x00000008u, + 0x000001a6u, 0x000001a3u, 0x00000002u, 0x00070050u, 0x00000009u, 0x000001a7u, 0x000001a4u, 0x000001a5u, + 0x000001a6u, 0x00000074u, 0x00050091u, 0x00000009u, 0x000001a8u, 0x000001a2u, 0x000001a7u, 0x0008004fu, + 0x0000001bu, 0x000001a9u, 0x000001a8u, 0x000001a8u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, + 0x000001a1u, 0x000001a9u, 0x00050041u, 0x00000014u, 0x000001abu, 0x00000189u, 0x00000055u, 0x0004003du, + 0x00000008u, 0x000001acu, 0x000001abu, 0x0007000cu, 0x00000008u, 0x000001aeu, 0x00000001u, 0x00000028u, + 0x000001acu, 0x000001adu, 0x0003003eu, 0x000001aau, 0x000001aeu, 0x00050041u, 0x00000014u, 0x000001b0u, + 0x00000192u, 0x00000055u, 0x0004003du, 0x00000008u, 0x000001b1u, 0x000001b0u, 0x0007000cu, 0x00000008u, + 0x000001b2u, 0x00000001u, 0x00000028u, 0x000001b1u, 0x000001adu, 0x0003003eu, 0x000001afu, 0x000001b2u, + 0x00050041u, 0x00000014u, 0x000001b4u, 0x000001a1u, 0x00000055u, 0x0004003du, 0x00000008u, 0x000001b5u, + 0x000001b4u, 0x0007000cu, 0x00000008u, 0x000001b6u, 0x00000001u, 0x00000028u, 0x000001b5u, 0x000001adu, + 0x0003003eu, 0x000001b3u, 0x000001b6u, 0x0004003du, 0x0000001bu, 0x000001b9u, 0x00000189u, 0x0007004fu, + 0x000001b8u, 0x000001bau, 0x000001b9u, 0x000001b9u, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000008u, + 0x000001bbu, 0x00000001u, 0x00000042u, 0x000001bau, 0x0003003eu, 0x000001b7u, 0x000001bbu, 0x0004003du, + 0x0000001bu, 0x000001bdu, 0x00000189u, 0x0007004fu, 0x000001b8u, 0x000001beu, 0x000001bdu, 0x000001bdu, + 0x00000000u, 0x00000001u, 0x0004003du, 0x00000008u, 0x000001bfu, 0x000001aau, 0x00050051u, 0x00000008u, + 0x000001c0u, 0x000001beu, 0x00000000u, 0x00050051u, 0x00000008u, 0x000001c1u, 0x000001beu, 0x00000001u, + 0x00060050u, 0x0000001bu, 0x000001c2u, 0x000001c0u, 0x000001c1u, 0x000001bfu, 0x0006000cu, 0x00000008u, + 0x000001c3u, 0x00000001u, 0x00000042u, 0x000001c2u, 0x00050081u, 0x00000008u, 0x000001c4u, 0x000001c3u, + 0x00000069u, 0x0003003eu, 0x000001bcu, 0x000001c4u, 0x0004003du, 0x00000008u, 0x000001c6u, 0x000001aau, + 0x0004003du, 0x00000008u, 0x000001c7u, 0x000001bcu, 0x00050088u, 0x00000008u, 0x000001c8u, 0x000001c6u, + 0x000001c7u, 0x0008000cu, 0x00000008u, 0x000001c9u, 0x00000001u, 0x0000002bu, 0x000001c8u, 0x00000096u, + 0x00000074u, 0x0003003eu, 0x000001c5u, 0x000001c9u, 0x0004003du, 0x00000008u, 0x000001cbu, 0x000001c5u, + 0x0006000cu, 0x00000008u, 0x000001ccu, 0x00000001u, 0x00000011u, 0x000001cbu, 0x0003003eu, 0x000001cau, + 0x000001ccu, 0x0004003du, 0x00000008u, 0x000001ceu, 0x000001cau, 0x0004003du, 0x00000008u, 0x000001cfu, + 0x000001cau, 0x00050085u, 0x00000008u, 0x000001d0u, 0x000001ceu, 0x000001cfu, 0x0003003eu, 0x000001cdu, + 0x000001d0u, 0x00050041u, 0x00000014u, 0x000001d3u, 0x0000003eu, 0x000001d2u, 0x0004003du, 0x00000008u, + 0x000001d4u, 0x000001d3u, 0x00050041u, 0x00000014u, 0x000001d6u, 0x0000003eu, 0x000001d5u, 0x0004003du, + 0x00000008u, 0x000001d7u, 0x000001d6u, 0x0004003du, 0x00000008u, 0x000001d8u, 0x000001cau, 0x00050085u, + 0x00000008u, 0x000001d9u, 0x000001d7u, 0x000001d8u, 0x00050081u, 0x00000008u, 0x000001dau, 0x000001d4u, + 0x000001d9u, 0x00050041u, 0x00000014u, 0x000001dcu, 0x0000003eu, 0x000001dbu, 0x0004003du, 0x00000008u, + 0x000001ddu, 0x000001dcu, 0x0004003du, 0x00000008u, 0x000001deu, 0x000001cdu, 0x00050085u, 0x00000008u, + 0x000001dfu, 0x000001ddu, 0x000001deu, 0x00050081u, 0x00000008u, 0x000001e0u, 0x000001dau, 0x000001dfu, + 0x00050041u, 0x00000014u, 0x000001e2u, 0x0000003eu, 0x000001e1u, 0x0004003du, 0x00000008u, 0x000001e3u, + 0x000001e2u, 0x0004003du, 0x00000008u, 0x000001e4u, 0x000001cdu, 0x0004003du, 0x00000008u, 0x000001e5u, + 0x000001cau, 0x00050085u, 0x00000008u, 0x000001e6u, 0x000001e4u, 0x000001e5u, 0x00050085u, 0x00000008u, + 0x000001e7u, 0x000001e3u, 0x000001e6u, 0x00050081u, 0x00000008u, 0x000001e8u, 0x000001e0u, 0x000001e7u, + 0x00050041u, 0x00000014u, 0x000001eau, 0x0000003eu, 0x000001e9u, 0x0004003du, 0x00000008u, 0x000001ebu, + 0x000001eau, 0x0004003du, 0x00000008u, 0x000001ecu, 0x000001cdu, 0x0004003du, 0x00000008u, 0x000001edu, + 0x000001cdu, 0x00050085u, 0x00000008u, 0x000001eeu, 0x000001ecu, 0x000001edu, 0x00050085u, 0x00000008u, + 0x000001efu, 0x000001ebu, 0x000001eeu, 0x00050081u, 0x00000008u, 0x000001f0u, 0x000001e8u, 0x000001efu, + 0x00050041u, 0x00000014u, 0x000001f2u, 0x0000003eu, 0x000001f1u, 0x0004003du, 0x00000008u, 0x000001f3u, + 0x000001f2u, 0x0004003du, 0x00000008u, 0x000001f4u, 0x000001cdu, 0x0004003du, 0x00000008u, 0x000001f5u, + 0x000001cdu, 0x00050085u, 0x00000008u, 0x000001f6u, 0x000001f4u, 0x000001f5u, 0x0004003du, 0x00000008u, + 0x000001f7u, 0x000001cau, 0x00050085u, 0x00000008u, 0x000001f8u, 0x000001f6u, 0x000001f7u, 0x00050085u, + 0x00000008u, 0x000001f9u, 0x000001f3u, 0x000001f8u, 0x00050081u, 0x00000008u, 0x000001fau, 0x000001f0u, + 0x000001f9u, 0x0003003eu, 0x000001d1u, 0x000001fau, 0x0004003du, 0x00000008u, 0x000001fbu, 0x000001cau, + 0x00050041u, 0x00000014u, 0x000001fdu, 0x0000003eu, 0x000001fcu, 0x0004003du, 0x00000008u, 0x000001feu, + 0x000001fdu, 0x000500bau, 0x00000029u, 0x000001ffu, 0x000001fbu, 0x000001feu, 0x000300f7u, 0x00000201u, + 0x00000000u, 0x000400fau, 0x000001ffu, 0x00000200u, 0x00000201u, 0x000200f8u, 0x00000200u, 0x00050041u, + 0x00000014u, 0x00000203u, 0x0000003eu, 0x00000202u, 0x0004003du, 0x00000008u, 0x00000204u, 0x00000203u, + 0x0004003du, 0x00000008u, 0x00000205u, 0x000001cau, 0x00050041u, 0x00000014u, 0x00000206u, 0x0000003eu, + 0x000001fcu, 0x0004003du, 0x00000008u, 0x00000207u, 0x00000206u, 0x00050083u, 0x00000008u, 0x00000208u, + 0x00000205u, 0x00000207u, 0x00050041u, 0x00000014u, 0x0000020au, 0x0000003eu, 0x00000209u, 0x0004003du, + 0x00000008u, 0x0000020bu, 0x0000020au, 0x00050085u, 0x00000008u, 0x0000020cu, 0x00000208u, 0x0000020bu, + 0x00050081u, 0x00000008u, 0x0000020du, 0x00000204u, 0x0000020cu, 0x0003003eu, 0x000001d1u, 0x0000020du, + 0x000200f9u, 0x00000201u, 0x000200f8u, 0x00000201u, 0x0004003du, 0x00000008u, 0x0000020fu, 0x000001b7u, + 0x000500bau, 0x00000029u, 0x00000211u, 0x0000020fu, 0x00000210u, 0x000300f7u, 0x00000214u, 0x00000000u, + 0x000400fau, 0x00000211u, 0x00000213u, 0x00000218u, 0x000200f8u, 0x00000213u, 0x0004003du, 0x00000008u, + 0x00000215u, 0x000001d1u, 0x0004003du, 0x00000008u, 0x00000216u, 0x000001b7u, 0x00050088u, 0x00000008u, + 0x00000217u, 0x00000215u, 0x00000216u, 0x0003003eu, 0x00000212u, 0x00000217u, 0x000200f9u, 0x00000214u, + 0x000200f8u, 0x00000218u, 0x0003003eu, 0x00000212u, 0x00000073u, 0x000200f9u, 0x00000214u, 0x000200f8u, + 0x00000214u, 0x0004003du, 0x00000008u, 0x00000219u, 0x00000212u, 0x0003003eu, 0x0000020eu, 0x00000219u, + 0x0004003du, 0x00000008u, 0x0000021cu, 0x0000020eu, 0x0004003du, 0x0000001bu, 0x0000021du, 0x00000189u, + 0x0007004fu, 0x000001b8u, 0x0000021eu, 0x0000021du, 0x0000021du, 0x00000000u, 0x00000001u, 0x0005008eu, + 0x000001b8u, 0x0000021fu, 0x0000021eu, 0x0000021cu, 0x0003003eu, 0x0000021bu, 0x0000021fu, 0x00050041u, + 0x00000014u, 0x00000222u, 0x0000003eu, 0x00000221u, 0x0004003du, 0x00000008u, 0x00000223u, 0x00000222u, + 0x00050041u, 0x00000014u, 0x00000224u, 0x0000021bu, 0x00000049u, 0x0004003du, 0x00000008u, 0x00000225u, + 0x00000224u, 0x00050085u, 0x00000008u, 0x00000226u, 0x00000223u, 0x00000225u, 0x00050041u, 0x00000014u, + 0x00000228u, 0x0000003eu, 0x00000227u, 0x0004003du, 0x00000008u, 0x00000229u, 0x00000228u, 0x00050041u, + 0x00000014u, 0x0000022au, 0x0000021bu, 0x00000007u, 0x0004003du, 0x00000008u, 0x0000022bu, 0x0000022au, + 0x00050085u, 0x00000008u, 0x0000022cu, 0x00000229u, 0x0000022bu, 0x00050081u, 0x00000008u, 0x0000022du, + 0x00000226u, 0x0000022cu, 0x00050041u, 0x00000014u, 0x0000022fu, 0x0000003eu, 0x0000022eu, 0x0004003du, + 0x00000008u, 0x00000230u, 0x0000022fu, 0x00050041u, 0x00000014u, 0x00000231u, 0x0000021bu, 0x00000049u, + 0x0004003du, 0x00000008u, 0x00000232u, 0x00000231u, 0x00050085u, 0x00000008u, 0x00000233u, 0x00000230u, + 0x00000232u, 0x00050041u, 0x00000014u, 0x00000235u, 0x0000003eu, 0x00000234u, 0x0004003du, 0x00000008u, + 0x00000236u, 0x00000235u, 0x00050041u, 0x00000014u, 0x00000237u, 0x0000021bu, 0x00000007u, 0x0004003du, + 0x00000008u, 0x00000238u, 0x00000237u, 0x00050085u, 0x00000008u, 0x00000239u, 0x00000236u, 0x00000238u, + 0x00050081u, 0x00000008u, 0x0000023au, 0x00000233u, 0x00000239u, 0x00050050u, 0x000001b8u, 0x0000023bu, + 0x0000022du, 0x0000023au, 0x0003003eu, 0x00000220u, 0x0000023bu, 0x0004003du, 0x000001b8u, 0x0000023du, + 0x00000220u, 0x00050041u, 0x00000014u, 0x0000023eu, 0x0000003eu, 0x00000122u, 0x0004003du, 0x00000008u, + 0x0000023fu, 0x0000023eu, 0x00050041u, 0x00000014u, 0x00000240u, 0x0000003eu, 0x0000012cu, 0x0004003du, + 0x00000008u, 0x00000241u, 0x00000240u, 0x00050050u, 0x000001b8u, 0x00000242u, 0x0000023fu, 0x00000241u, + 0x00050081u, 0x000001b8u, 0x00000243u, 0x0000023du, 0x00000242u, 0x0003003eu, 0x0000023cu, 0x00000243u, + 0x0004003du, 0x0000001bu, 0x00000245u, 0x00000192u, 0x0007004fu, 0x000001b8u, 0x00000246u, 0x00000245u, + 0x00000245u, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000008u, 0x00000247u, 0x00000001u, 0x00000042u, + 0x00000246u, 0x0003003eu, 0x00000244u, 0x00000247u, 0x0004003du, 0x0000001bu, 0x00000249u, 0x00000192u, + 0x0007004fu, 0x000001b8u, 0x0000024au, 0x00000249u, 0x00000249u, 0x00000000u, 0x00000001u, 0x0004003du, + 0x00000008u, 0x0000024bu, 0x000001afu, 0x00050051u, 0x00000008u, 0x0000024cu, 0x0000024au, 0x00000000u, + 0x00050051u, 0x00000008u, 0x0000024du, 0x0000024au, 0x00000001u, 0x00060050u, 0x0000001bu, 0x0000024eu, + 0x0000024cu, 0x0000024du, 0x0000024bu, 0x0006000cu, 0x00000008u, 0x0000024fu, 0x00000001u, 0x00000042u, + 0x0000024eu, 0x00050081u, 0x00000008u, 0x00000250u, 0x0000024fu, 0x00000069u, 0x0003003eu, 0x00000248u, + 0x00000250u, 0x0004003du, 0x00000008u, 0x00000252u, 0x000001afu, 0x0004003du, 0x00000008u, 0x00000253u, + 0x00000248u, 0x00050088u, 0x00000008u, 0x00000254u, 0x00000252u, 0x00000253u, 0x0008000cu, 0x00000008u, + 0x00000255u, 0x00000001u, 0x0000002bu, 0x00000254u, 0x00000096u, 0x00000074u, 0x0003003eu, 0x00000251u, + 0x00000255u, 0x0004003du, 0x00000008u, 0x00000257u, 0x00000251u, 0x0006000cu, 0x00000008u, 0x00000258u, + 0x00000001u, 0x00000011u, 0x00000257u, 0x0003003eu, 0x00000256u, 0x00000258u, 0x0004003du, 0x00000008u, + 0x0000025au, 0x00000256u, 0x0004003du, 0x00000008u, 0x0000025bu, 0x00000256u, 0x00050085u, 0x00000008u, + 0x0000025cu, 0x0000025au, 0x0000025bu, 0x0003003eu, 0x00000259u, 0x0000025cu, 0x00050041u, 0x00000014u, + 0x0000025eu, 0x0000003eu, 0x000001d2u, 0x0004003du, 0x00000008u, 0x0000025fu, 0x0000025eu, 0x00050041u, + 0x00000014u, 0x00000260u, 0x0000003eu, 0x000001d5u, 0x0004003du, 0x00000008u, 0x00000261u, 0x00000260u, + 0x0004003du, 0x00000008u, 0x00000262u, 0x00000256u, 0x00050085u, 0x00000008u, 0x00000263u, 0x00000261u, + 0x00000262u, 0x00050081u, 0x00000008u, 0x00000264u, 0x0000025fu, 0x00000263u, 0x00050041u, 0x00000014u, + 0x00000265u, 0x0000003eu, 0x000001dbu, 0x0004003du, 0x00000008u, 0x00000266u, 0x00000265u, 0x0004003du, + 0x00000008u, 0x00000267u, 0x00000259u, 0x00050085u, 0x00000008u, 0x00000268u, 0x00000266u, 0x00000267u, + 0x00050081u, 0x00000008u, 0x00000269u, 0x00000264u, 0x00000268u, 0x00050041u, 0x00000014u, 0x0000026au, + 0x0000003eu, 0x000001e1u, 0x0004003du, 0x00000008u, 0x0000026bu, 0x0000026au, 0x0004003du, 0x00000008u, + 0x0000026cu, 0x00000259u, 0x0004003du, 0x00000008u, 0x0000026du, 0x00000256u, 0x00050085u, 0x00000008u, + 0x0000026eu, 0x0000026cu, 0x0000026du, 0x00050085u, 0x00000008u, 0x0000026fu, 0x0000026bu, 0x0000026eu, + 0x00050081u, 0x00000008u, 0x00000270u, 0x00000269u, 0x0000026fu, 0x00050041u, 0x00000014u, 0x00000271u, + 0x0000003eu, 0x000001e9u, 0x0004003du, 0x00000008u, 0x00000272u, 0x00000271u, 0x0004003du, 0x00000008u, + 0x00000273u, 0x00000259u, 0x0004003du, 0x00000008u, 0x00000274u, 0x00000259u, 0x00050085u, 0x00000008u, + 0x00000275u, 0x00000273u, 0x00000274u, 0x00050085u, 0x00000008u, 0x00000276u, 0x00000272u, 0x00000275u, + 0x00050081u, 0x00000008u, 0x00000277u, 0x00000270u, 0x00000276u, 0x00050041u, 0x00000014u, 0x00000278u, + 0x0000003eu, 0x000001f1u, 0x0004003du, 0x00000008u, 0x00000279u, 0x00000278u, 0x0004003du, 0x00000008u, + 0x0000027au, 0x00000259u, 0x0004003du, 0x00000008u, 0x0000027bu, 0x00000259u, 0x00050085u, 0x00000008u, + 0x0000027cu, 0x0000027au, 0x0000027bu, 0x0004003du, 0x00000008u, 0x0000027du, 0x00000256u, 0x00050085u, + 0x00000008u, 0x0000027eu, 0x0000027cu, 0x0000027du, 0x00050085u, 0x00000008u, 0x0000027fu, 0x00000279u, + 0x0000027eu, 0x00050081u, 0x00000008u, 0x00000280u, 0x00000277u, 0x0000027fu, 0x0003003eu, 0x0000025du, + 0x00000280u, 0x0004003du, 0x00000008u, 0x00000281u, 0x00000256u, 0x00050041u, 0x00000014u, 0x00000282u, + 0x0000003eu, 0x000001fcu, 0x0004003du, 0x00000008u, 0x00000283u, 0x00000282u, 0x000500bau, 0x00000029u, + 0x00000284u, 0x00000281u, 0x00000283u, 0x000300f7u, 0x00000286u, 0x00000000u, 0x000400fau, 0x00000284u, + 0x00000285u, 0x00000286u, 0x000200f8u, 0x00000285u, 0x00050041u, 0x00000014u, 0x00000287u, 0x0000003eu, + 0x00000202u, 0x0004003du, 0x00000008u, 0x00000288u, 0x00000287u, 0x0004003du, 0x00000008u, 0x00000289u, + 0x00000256u, 0x00050041u, 0x00000014u, 0x0000028au, 0x0000003eu, 0x000001fcu, 0x0004003du, 0x00000008u, + 0x0000028bu, 0x0000028au, 0x00050083u, 0x00000008u, 0x0000028cu, 0x00000289u, 0x0000028bu, 0x00050041u, + 0x00000014u, 0x0000028du, 0x0000003eu, 0x00000209u, 0x0004003du, 0x00000008u, 0x0000028eu, 0x0000028du, + 0x00050085u, 0x00000008u, 0x0000028fu, 0x0000028cu, 0x0000028eu, 0x00050081u, 0x00000008u, 0x00000290u, + 0x00000288u, 0x0000028fu, 0x0003003eu, 0x0000025du, 0x00000290u, 0x000200f9u, 0x00000286u, 0x000200f8u, + 0x00000286u, 0x0004003du, 0x00000008u, 0x00000292u, 0x00000244u, 0x000500bau, 0x00000029u, 0x00000293u, + 0x00000292u, 0x00000210u, 0x000300f7u, 0x00000296u, 0x00000000u, 0x000400fau, 0x00000293u, 0x00000295u, + 0x0000029au, 0x000200f8u, 0x00000295u, 0x0004003du, 0x00000008u, 0x00000297u, 0x0000025du, 0x0004003du, + 0x00000008u, 0x00000298u, 0x00000244u, 0x00050088u, 0x00000008u, 0x00000299u, 0x00000297u, 0x00000298u, + 0x0003003eu, 0x00000294u, 0x00000299u, 0x000200f9u, 0x00000296u, 0x000200f8u, 0x0000029au, 0x0003003eu, + 0x00000294u, 0x00000073u, 0x000200f9u, 0x00000296u, 0x000200f8u, 0x00000296u, 0x0004003du, 0x00000008u, + 0x0000029bu, 0x00000294u, 0x0003003eu, 0x00000291u, 0x0000029bu, 0x0004003du, 0x00000008u, 0x0000029du, + 0x00000291u, 0x0004003du, 0x0000001bu, 0x0000029eu, 0x00000192u, 0x0007004fu, 0x000001b8u, 0x0000029fu, + 0x0000029eu, 0x0000029eu, 0x00000000u, 0x00000001u, 0x0005008eu, 0x000001b8u, 0x000002a0u, 0x0000029fu, + 0x0000029du, 0x0003003eu, 0x0000029cu, 0x000002a0u, 0x00050041u, 0x00000014u, 0x000002a2u, 0x0000003eu, + 0x00000221u, 0x0004003du, 0x00000008u, 0x000002a3u, 0x000002a2u, 0x00050041u, 0x00000014u, 0x000002a4u, + 0x0000029cu, 0x00000049u, 0x0004003du, 0x00000008u, 0x000002a5u, 0x000002a4u, 0x00050085u, 0x00000008u, + 0x000002a6u, 0x000002a3u, 0x000002a5u, 0x00050041u, 0x00000014u, 0x000002a7u, 0x0000003eu, 0x00000227u, + 0x0004003du, 0x00000008u, 0x000002a8u, 0x000002a7u, 0x00050041u, 0x00000014u, 0x000002a9u, 0x0000029cu, + 0x00000007u, 0x0004003du, 0x00000008u, 0x000002aau, 0x000002a9u, 0x00050085u, 0x00000008u, 0x000002abu, + 0x000002a8u, 0x000002aau, 0x00050081u, 0x00000008u, 0x000002acu, 0x000002a6u, 0x000002abu, 0x00050041u, + 0x00000014u, 0x000002adu, 0x0000003eu, 0x0000022eu, 0x0004003du, 0x00000008u, 0x000002aeu, 0x000002adu, + 0x00050041u, 0x00000014u, 0x000002afu, 0x0000029cu, 0x00000049u, 0x0004003du, 0x00000008u, 0x000002b0u, + 0x000002afu, 0x00050085u, 0x00000008u, 0x000002b1u, 0x000002aeu, 0x000002b0u, 0x00050041u, 0x00000014u, + 0x000002b2u, 0x0000003eu, 0x00000234u, 0x0004003du, 0x00000008u, 0x000002b3u, 0x000002b2u, 0x00050041u, + 0x00000014u, 0x000002b4u, 0x0000029cu, 0x00000007u, 0x0004003du, 0x00000008u, 0x000002b5u, 0x000002b4u, + 0x00050085u, 0x00000008u, 0x000002b6u, 0x000002b3u, 0x000002b5u, 0x00050081u, 0x00000008u, 0x000002b7u, + 0x000002b1u, 0x000002b6u, 0x00050050u, 0x000001b8u, 0x000002b8u, 0x000002acu, 0x000002b7u, 0x0003003eu, + 0x000002a1u, 0x000002b8u, 0x0004003du, 0x000001b8u, 0x000002bau, 0x000002a1u, 0x00050041u, 0x00000014u, + 0x000002bbu, 0x0000003eu, 0x00000122u, 0x0004003du, 0x00000008u, 0x000002bcu, 0x000002bbu, 0x00050041u, + 0x00000014u, 0x000002bdu, 0x0000003eu, 0x0000012cu, 0x0004003du, 0x00000008u, 0x000002beu, 0x000002bdu, + 0x00050050u, 0x000001b8u, 0x000002bfu, 0x000002bcu, 0x000002beu, 0x00050081u, 0x000001b8u, 0x000002c0u, + 0x000002bau, 0x000002bfu, 0x0003003eu, 0x000002b9u, 0x000002c0u, 0x0004003du, 0x0000001bu, 0x000002c2u, + 0x000001a1u, 0x0007004fu, 0x000001b8u, 0x000002c3u, 0x000002c2u, 0x000002c2u, 0x00000000u, 0x00000001u, + 0x0006000cu, 0x00000008u, 0x000002c4u, 0x00000001u, 0x00000042u, 0x000002c3u, 0x0003003eu, 0x000002c1u, + 0x000002c4u, 0x0004003du, 0x0000001bu, 0x000002c6u, 0x000001a1u, 0x0007004fu, 0x000001b8u, 0x000002c7u, + 0x000002c6u, 0x000002c6u, 0x00000000u, 0x00000001u, 0x0004003du, 0x00000008u, 0x000002c8u, 0x000001b3u, + 0x00050051u, 0x00000008u, 0x000002c9u, 0x000002c7u, 0x00000000u, 0x00050051u, 0x00000008u, 0x000002cau, + 0x000002c7u, 0x00000001u, 0x00060050u, 0x0000001bu, 0x000002cbu, 0x000002c9u, 0x000002cau, 0x000002c8u, + 0x0006000cu, 0x00000008u, 0x000002ccu, 0x00000001u, 0x00000042u, 0x000002cbu, 0x00050081u, 0x00000008u, + 0x000002cdu, 0x000002ccu, 0x00000069u, 0x0003003eu, 0x000002c5u, 0x000002cdu, 0x0004003du, 0x00000008u, + 0x000002cfu, 0x000001b3u, 0x0004003du, 0x00000008u, 0x000002d0u, 0x000002c5u, 0x00050088u, 0x00000008u, + 0x000002d1u, 0x000002cfu, 0x000002d0u, 0x0008000cu, 0x00000008u, 0x000002d2u, 0x00000001u, 0x0000002bu, + 0x000002d1u, 0x00000096u, 0x00000074u, 0x0003003eu, 0x000002ceu, 0x000002d2u, 0x0004003du, 0x00000008u, + 0x000002d4u, 0x000002ceu, 0x0006000cu, 0x00000008u, 0x000002d5u, 0x00000001u, 0x00000011u, 0x000002d4u, + 0x0003003eu, 0x000002d3u, 0x000002d5u, 0x0004003du, 0x00000008u, 0x000002d7u, 0x000002d3u, 0x0004003du, + 0x00000008u, 0x000002d8u, 0x000002d3u, 0x00050085u, 0x00000008u, 0x000002d9u, 0x000002d7u, 0x000002d8u, + 0x0003003eu, 0x000002d6u, 0x000002d9u, 0x00050041u, 0x00000014u, 0x000002dbu, 0x0000003eu, 0x000001d2u, + 0x0004003du, 0x00000008u, 0x000002dcu, 0x000002dbu, 0x00050041u, 0x00000014u, 0x000002ddu, 0x0000003eu, + 0x000001d5u, 0x0004003du, 0x00000008u, 0x000002deu, 0x000002ddu, 0x0004003du, 0x00000008u, 0x000002dfu, + 0x000002d3u, 0x00050085u, 0x00000008u, 0x000002e0u, 0x000002deu, 0x000002dfu, 0x00050081u, 0x00000008u, + 0x000002e1u, 0x000002dcu, 0x000002e0u, 0x00050041u, 0x00000014u, 0x000002e2u, 0x0000003eu, 0x000001dbu, + 0x0004003du, 0x00000008u, 0x000002e3u, 0x000002e2u, 0x0004003du, 0x00000008u, 0x000002e4u, 0x000002d6u, + 0x00050085u, 0x00000008u, 0x000002e5u, 0x000002e3u, 0x000002e4u, 0x00050081u, 0x00000008u, 0x000002e6u, + 0x000002e1u, 0x000002e5u, 0x00050041u, 0x00000014u, 0x000002e7u, 0x0000003eu, 0x000001e1u, 0x0004003du, + 0x00000008u, 0x000002e8u, 0x000002e7u, 0x0004003du, 0x00000008u, 0x000002e9u, 0x000002d6u, 0x0004003du, + 0x00000008u, 0x000002eau, 0x000002d3u, 0x00050085u, 0x00000008u, 0x000002ebu, 0x000002e9u, 0x000002eau, + 0x00050085u, 0x00000008u, 0x000002ecu, 0x000002e8u, 0x000002ebu, 0x00050081u, 0x00000008u, 0x000002edu, + 0x000002e6u, 0x000002ecu, 0x00050041u, 0x00000014u, 0x000002eeu, 0x0000003eu, 0x000001e9u, 0x0004003du, + 0x00000008u, 0x000002efu, 0x000002eeu, 0x0004003du, 0x00000008u, 0x000002f0u, 0x000002d6u, 0x0004003du, + 0x00000008u, 0x000002f1u, 0x000002d6u, 0x00050085u, 0x00000008u, 0x000002f2u, 0x000002f0u, 0x000002f1u, + 0x00050085u, 0x00000008u, 0x000002f3u, 0x000002efu, 0x000002f2u, 0x00050081u, 0x00000008u, 0x000002f4u, + 0x000002edu, 0x000002f3u, 0x00050041u, 0x00000014u, 0x000002f5u, 0x0000003eu, 0x000001f1u, 0x0004003du, + 0x00000008u, 0x000002f6u, 0x000002f5u, 0x0004003du, 0x00000008u, 0x000002f7u, 0x000002d6u, 0x0004003du, + 0x00000008u, 0x000002f8u, 0x000002d6u, 0x00050085u, 0x00000008u, 0x000002f9u, 0x000002f7u, 0x000002f8u, + 0x0004003du, 0x00000008u, 0x000002fau, 0x000002d3u, 0x00050085u, 0x00000008u, 0x000002fbu, 0x000002f9u, + 0x000002fau, 0x00050085u, 0x00000008u, 0x000002fcu, 0x000002f6u, 0x000002fbu, 0x00050081u, 0x00000008u, + 0x000002fdu, 0x000002f4u, 0x000002fcu, 0x0003003eu, 0x000002dau, 0x000002fdu, 0x0004003du, 0x00000008u, + 0x000002feu, 0x000002d3u, 0x00050041u, 0x00000014u, 0x000002ffu, 0x0000003eu, 0x000001fcu, 0x0004003du, + 0x00000008u, 0x00000300u, 0x000002ffu, 0x000500bau, 0x00000029u, 0x00000301u, 0x000002feu, 0x00000300u, + 0x000300f7u, 0x00000303u, 0x00000000u, 0x000400fau, 0x00000301u, 0x00000302u, 0x00000303u, 0x000200f8u, + 0x00000302u, 0x00050041u, 0x00000014u, 0x00000304u, 0x0000003eu, 0x00000202u, 0x0004003du, 0x00000008u, + 0x00000305u, 0x00000304u, 0x0004003du, 0x00000008u, 0x00000306u, 0x000002d3u, 0x00050041u, 0x00000014u, + 0x00000307u, 0x0000003eu, 0x000001fcu, 0x0004003du, 0x00000008u, 0x00000308u, 0x00000307u, 0x00050083u, + 0x00000008u, 0x00000309u, 0x00000306u, 0x00000308u, 0x00050041u, 0x00000014u, 0x0000030au, 0x0000003eu, + 0x00000209u, 0x0004003du, 0x00000008u, 0x0000030bu, 0x0000030au, 0x00050085u, 0x00000008u, 0x0000030cu, + 0x00000309u, 0x0000030bu, 0x00050081u, 0x00000008u, 0x0000030du, 0x00000305u, 0x0000030cu, 0x0003003eu, + 0x000002dau, 0x0000030du, 0x000200f9u, 0x00000303u, 0x000200f8u, 0x00000303u, 0x0004003du, 0x00000008u, + 0x0000030fu, 0x000002c1u, 0x000500bau, 0x00000029u, 0x00000310u, 0x0000030fu, 0x00000210u, 0x000300f7u, + 0x00000313u, 0x00000000u, 0x000400fau, 0x00000310u, 0x00000312u, 0x00000317u, 0x000200f8u, 0x00000312u, + 0x0004003du, 0x00000008u, 0x00000314u, 0x000002dau, 0x0004003du, 0x00000008u, 0x00000315u, 0x000002c1u, + 0x00050088u, 0x00000008u, 0x00000316u, 0x00000314u, 0x00000315u, 0x0003003eu, 0x00000311u, 0x00000316u, + 0x000200f9u, 0x00000313u, 0x000200f8u, 0x00000317u, 0x0003003eu, 0x00000311u, 0x00000073u, 0x000200f9u, + 0x00000313u, 0x000200f8u, 0x00000313u, 0x0004003du, 0x00000008u, 0x00000318u, 0x00000311u, 0x0003003eu, + 0x0000030eu, 0x00000318u, 0x0004003du, 0x00000008u, 0x0000031au, 0x0000030eu, 0x0004003du, 0x0000001bu, + 0x0000031bu, 0x000001a1u, 0x0007004fu, 0x000001b8u, 0x0000031cu, 0x0000031bu, 0x0000031bu, 0x00000000u, + 0x00000001u, 0x0005008eu, 0x000001b8u, 0x0000031du, 0x0000031cu, 0x0000031au, 0x0003003eu, 0x00000319u, + 0x0000031du, 0x00050041u, 0x00000014u, 0x0000031fu, 0x0000003eu, 0x00000221u, 0x0004003du, 0x00000008u, + 0x00000320u, 0x0000031fu, 0x00050041u, 0x00000014u, 0x00000321u, 0x00000319u, 0x00000049u, 0x0004003du, + 0x00000008u, 0x00000322u, 0x00000321u, 0x00050085u, 0x00000008u, 0x00000323u, 0x00000320u, 0x00000322u, + 0x00050041u, 0x00000014u, 0x00000324u, 0x0000003eu, 0x00000227u, 0x0004003du, 0x00000008u, 0x00000325u, + 0x00000324u, 0x00050041u, 0x00000014u, 0x00000326u, 0x00000319u, 0x00000007u, 0x0004003du, 0x00000008u, + 0x00000327u, 0x00000326u, 0x00050085u, 0x00000008u, 0x00000328u, 0x00000325u, 0x00000327u, 0x00050081u, + 0x00000008u, 0x00000329u, 0x00000323u, 0x00000328u, 0x00050041u, 0x00000014u, 0x0000032au, 0x0000003eu, + 0x0000022eu, 0x0004003du, 0x00000008u, 0x0000032bu, 0x0000032au, 0x00050041u, 0x00000014u, 0x0000032cu, + 0x00000319u, 0x00000049u, 0x0004003du, 0x00000008u, 0x0000032du, 0x0000032cu, 0x00050085u, 0x00000008u, + 0x0000032eu, 0x0000032bu, 0x0000032du, 0x00050041u, 0x00000014u, 0x0000032fu, 0x0000003eu, 0x00000234u, + 0x0004003du, 0x00000008u, 0x00000330u, 0x0000032fu, 0x00050041u, 0x00000014u, 0x00000331u, 0x00000319u, + 0x00000007u, 0x0004003du, 0x00000008u, 0x00000332u, 0x00000331u, 0x00050085u, 0x00000008u, 0x00000333u, + 0x00000330u, 0x00000332u, 0x00050081u, 0x00000008u, 0x00000334u, 0x0000032eu, 0x00000333u, 0x00050050u, + 0x000001b8u, 0x00000335u, 0x00000329u, 0x00000334u, 0x0003003eu, 0x0000031eu, 0x00000335u, 0x0004003du, + 0x000001b8u, 0x00000337u, 0x0000031eu, 0x00050041u, 0x00000014u, 0x00000338u, 0x0000003eu, 0x00000122u, + 0x0004003du, 0x00000008u, 0x00000339u, 0x00000338u, 0x00050041u, 0x00000014u, 0x0000033au, 0x0000003eu, + 0x0000012cu, 0x0004003du, 0x00000008u, 0x0000033bu, 0x0000033au, 0x00050050u, 0x000001b8u, 0x0000033cu, + 0x00000339u, 0x0000033bu, 0x00050081u, 0x000001b8u, 0x0000033du, 0x00000337u, 0x0000033cu, 0x0003003eu, + 0x00000336u, 0x0000033du, 0x0004003du, 0x000001b8u, 0x0000033fu, 0x0000023cu, 0x0004003du, 0x000001b8u, + 0x00000340u, 0x000002b9u, 0x00050081u, 0x000001b8u, 0x00000341u, 0x0000033fu, 0x00000340u, 0x0005008eu, + 0x000001b8u, 0x00000342u, 0x00000341u, 0x0000019fu, 0x0003003eu, 0x0000033eu, 0x00000342u, 0x0004003du, + 0x000001b8u, 0x00000344u, 0x00000336u, 0x0004003du, 0x000001b8u, 0x00000345u, 0x0000033eu, 0x00050083u, + 0x000001b8u, 0x00000346u, 0x00000344u, 0x00000345u, 0x0006000cu, 0x00000008u, 0x00000347u, 0x00000001u, + 0x00000042u, 0x00000346u, 0x0003003eu, 0x00000343u, 0x00000347u, 0x0004003du, 0x00000008u, 0x00000348u, + 0x00000343u, 0x0008000cu, 0x00000008u, 0x0000034au, 0x00000001u, 0x0000002bu, 0x00000348u, 0x00000073u, + 0x00000349u, 0x000200feu, 0x0000034au, 0x00010038u, 0x00050036u, 0x00000006u, 0x00000047u, 0x00000000u, + 0x00000041u, 0x00030037u, 0x00000021u, 0x00000042u, 0x00030037u, 0x00000021u, 0x00000043u, 0x00030037u, + 0x00000032u, 0x00000044u, 0x00030037u, 0x00000039u, 0x00000045u, 0x00030037u, 0x00000014u, 0x00000046u, + 0x000200f8u, 0x00000048u, 0x0004003bu, 0x00000014u, 0x0000034du, 0x00000007u, 0x0004003bu, 0x00000021u, + 0x0000034eu, 0x00000007u, 0x0004003bu, 0x00000021u, 0x00000350u, 0x00000007u, 0x0004003bu, 0x00000037u, + 0x00000352u, 0x00000007u, 0x0004003bu, 0x00000039u, 0x00000355u, 0x00000007u, 0x0004003du, 0x0000001bu, + 0x0000034fu, 0x00000042u, 0x0003003eu, 0x0000034eu, 0x0000034fu, 0x0004003du, 0x0000001bu, 0x00000351u, + 0x00000043u, 0x0003003eu, 0x00000350u, 0x00000351u, 0x00050041u, 0x00000037u, 0x00000353u, 0x00000044u, + 0x00000122u, 0x0004003du, 0x00000022u, 0x00000354u, 0x00000353u, 0x0003003eu, 0x00000352u, 0x00000354u, + 0x0004003du, 0x00000038u, 0x00000356u, 0x00000045u, 0x0003003eu, 0x00000355u, 0x00000356u, 0x00080039u, + 0x00000008u, 0x00000357u, 0x0000003fu, 0x0000034eu, 0x00000350u, 0x00000352u, 0x00000355u, 0x0003003eu, + 0x0000034du, 0x00000357u, 0x0004003du, 0x00000008u, 0x00000358u, 0x0000034du, 0x0004003du, 0x00000008u, + 0x00000359u, 0x00000046u, 0x000500b8u, 0x00000029u, 0x0000035au, 0x00000358u, 0x00000359u, 0x000300f7u, + 0x0000035cu, 0x00000000u, 0x000400fau, 0x0000035au, 0x0000035bu, 0x0000035cu, 0x000200f8u, 0x0000035bu, + 0x000200feu, 0x00000049u, 0x000200f8u, 0x0000035cu, 0x0004003du, 0x00000008u, 0x0000035eu, 0x0000034du, + 0x0004003du, 0x00000008u, 0x0000035fu, 0x00000046u, 0x00050085u, 0x00000008u, 0x00000361u, 0x0000035fu, + 0x00000360u, 0x000500b8u, 0x00000029u, 0x00000362u, 0x0000035eu, 0x00000361u, 0x000300f7u, 0x00000364u, + 0x00000000u, 0x000400fau, 0x00000362u, 0x00000363u, 0x00000364u, 0x000200f8u, 0x00000363u, 0x000200feu, + 0x00000007u, 0x000200f8u, 0x00000364u, 0x0004003du, 0x00000008u, 0x00000366u, 0x0000034du, 0x0004003du, + 0x00000008u, 0x00000367u, 0x00000046u, 0x00050085u, 0x00000008u, 0x00000369u, 0x00000367u, 0x00000368u, + 0x000500b8u, 0x00000029u, 0x0000036au, 0x00000366u, 0x00000369u, 0x000300f7u, 0x0000036cu, 0x00000000u, + 0x000400fau, 0x0000036au, 0x0000036bu, 0x0000036cu, 0x000200f8u, 0x0000036bu, 0x000200feu, 0x00000055u, + 0x000200f8u, 0x0000036cu, 0x000200feu, 0x0000005cu, 0x00010038u, +}; + +static const uint32_t kSpv_ts_obstacle_mesh[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x00000786u, 0x00000000u, 0x00020011u, 0x0000000bu, 0x00020011u, + 0x000014a3u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, 0x00726564u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x001b000fu, 0x000014f5u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x0000003cu, 0x00000379u, 0x0000037eu, + 0x00000389u, 0x0000038cu, 0x00000399u, 0x000003a5u, 0x00000432u, 0x00000537u, 0x00000546u, 0x00000551u, + 0x00000756u, 0x0000075au, 0x0000075eu, 0x00000763u, 0x00000767u, 0x0000076bu, 0x0000076fu, 0x00000775u, + 0x0000077au, 0x0000077fu, 0x00000784u, 0x0006014bu, 0x00000004u, 0x00000026u, 0x00000007u, 0x00000008u, + 0x00000008u, 0x00040010u, 0x00000004u, 0x0000001au, 0x00000060u, 0x00040010u, 0x00000004u, 0x00001496u, + 0x00000080u, 0x00030010u, 0x00000004u, 0x000014b2u, 0x00030003u, 0x00000002u, 0x000001ccu, 0x00060004u, + 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, 0x000d0004u, 0x455f4c47u, 0x735f5458u, + 0x65646168u, 0x78655f72u, 0x63696c70u, 0x615f7469u, 0x68746972u, 0x6974656du, 0x79745f63u, 0x5f736570u, + 0x36746e69u, 0x00000034u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00080005u, 0x0000000bu, + 0x5f746567u, 0x65726977u, 0x6d617266u, 0x69775f65u, 0x28687464u, 0x00000000u, 0x00050005u, 0x00000011u, + 0x656d6143u, 0x6f506172u, 0x00006573u, 0x00070006u, 0x00000011u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, + 0x6d61635fu, 0x00617265u, 0x00060005u, 0x00000013u, 0x65685446u, 0x61436174u, 0x6172656du, 0x00000000u, + 0x00040006u, 0x00000013u, 0x00000000u, 0x00007863u, 0x00040006u, 0x00000013u, 0x00000001u, 0x00007963u, + 0x00050006u, 0x00000013u, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, 0x00000013u, 0x00000003u, + 0x5f676d69u, 0x00000068u, 0x00050006u, 0x00000013u, 0x00000004u, 0x796c6f70u, 0x00000030u, 0x00050006u, + 0x00000013u, 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x00000013u, 0x00000006u, 0x796c6f70u, + 0x00000032u, 0x00050006u, 0x00000013u, 0x00000007u, 0x796c6f70u, 0x00000033u, 0x00050006u, 0x00000013u, + 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, 0x00000013u, 0x00000009u, 0x796c6f70u, 0x00000035u, + 0x00070006u, 0x00000013u, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, 0x00000065u, 0x00080006u, + 0x00000013u, 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, 0x00006c61u, 0x00080006u, + 0x00000013u, 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, 0x006c6176u, 0x00060006u, + 0x00000013u, 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, 0x00000013u, 0x0000000eu, + 0x635f646cu, 0x00000000u, 0x00050006u, 0x00000013u, 0x0000000fu, 0x645f646cu, 0x00000000u, 0x00050006u, + 0x00000013u, 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x00000013u, 0x00000011u, 0x665f646cu, + 0x00000000u, 0x00200005u, 0x00000019u, 0x65687466u, 0x705f6174u, 0x656a6f72u, 0x76287463u, 0x733b3366u, + 0x63757274u, 0x61432d74u, 0x6172656du, 0x65736f50u, 0x34666d2du, 0x733b3134u, 0x63757274u, 0x54462d74u, + 0x61746568u, 0x656d6143u, 0x662d6172u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, + 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, 0x2d31662du, 0x662d3166u, 0x31662d31u, + 0x00003b31u, 0x00050005u, 0x00000016u, 0x6c726f77u, 0x6f705f64u, 0x00000073u, 0x00040005u, 0x00000017u, + 0x65736f70u, 0x00000000u, 0x00030005u, 0x00000018u, 0x006d6163u, 0x00080005u, 0x0000001eu, 0x79726162u, + 0x7265765fu, 0x5f786574u, 0x6e756f63u, 0x31752874u, 0x0000003bu, 0x00040005u, 0x0000001du, 0x6576656cu, + 0x0000006cu, 0x00080005u, 0x00000021u, 0x79726162u, 0x6972745fu, 0x6c676e61u, 0x6f635f65u, 0x28746e75u, + 0x003b3175u, 0x00040005u, 0x00000020u, 0x6576656cu, 0x0000006cu, 0x00080005u, 0x00000027u, 0x79726162u, + 0x7265765fu, 0x5f786574u, 0x75287675u, 0x31753b31u, 0x0000003bu, 0x00050005u, 0x00000025u, 0x74726576u, + 0x695f7865u, 0x00007864u, 0x00040005u, 0x00000026u, 0x6576656cu, 0x0000006cu, 0x000b0005u, 0x0000002fu, + 0x79726162u, 0x746e695fu, 0x6f707265u, 0x6574616cu, 0x33667628u, 0x3366763bu, 0x3366763bu, 0x3266763bu, + 0x0000003bu, 0x00030005u, 0x0000002bu, 0x00003076u, 0x00030005u, 0x0000002cu, 0x00003176u, 0x00030005u, + 0x0000002du, 0x00003276u, 0x00030005u, 0x0000002eu, 0x00007675u, 0x000a0005u, 0x00000035u, 0x79726162u, + 0x6972745fu, 0x6c676e61u, 0x6e695f65u, 0x65636964u, 0x31752873u, 0x3b31753bu, 0x00000000u, 0x00040005u, + 0x00000033u, 0x5f697274u, 0x00786469u, 0x00040005u, 0x00000034u, 0x6576656cu, 0x0000006cu, 0x00040005u, + 0x00000038u, 0x6c616373u, 0x00000065u, 0x00060005u, 0x0000003au, 0x68737550u, 0x736e6f43u, 0x746e6174u, + 0x00000073u, 0x000a0006u, 0x0000003au, 0x00000000u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, + 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x0000003au, 0x00000001u, 0x69775f75u, 0x5f687464u, + 0x796c6f70u, 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, 0x0000003au, 0x00000002u, 0x69775f75u, + 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x0000003au, + 0x00000003u, 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x7665625fu, 0x00000000u, 0x00080006u, + 0x0000003au, 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, 0x6d617266u, 0x00000065u, 0x00080006u, + 0x0000003au, 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, 0x6163735fu, 0x0000656cu, 0x00070006u, + 0x0000003au, 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, 0x00676e69u, 0x00090006u, 0x0000003au, + 0x00000007u, 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, 0x5f6e6f69u, 0x00007375u, 0x00090006u, + 0x0000003au, 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, 0x5f657474u, 0x657a6973u, 0x00000000u, + 0x00070006u, 0x0000003au, 0x00000009u, 0x756e5f75u, 0x75715f6du, 0x65697265u, 0x00000073u, 0x000a0006u, + 0x0000003au, 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, 0x745f6e6fu, 0x73657268u, 0x646c6f68u, + 0x00000000u, 0x000a0006u, 0x0000003au, 0x0000000bu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, + 0x705f6e6fu, 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x0000003au, 0x0000000cu, 0x616d5f75u, 0x65745f78u, + 0x6c657373u, 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, 0x00090006u, 0x0000003au, 0x0000000du, + 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, 0x00656275u, 0x00080006u, 0x0000003au, + 0x0000000eu, 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, 0x00656c61u, 0x00070006u, 0x0000003au, + 0x0000000fu, 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, 0x00070006u, 0x0000003au, 0x00000010u, + 0x616d5f75u, 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, 0x0000003au, 0x00000011u, 0x75635f75u, + 0x705f6562u, 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, 0x0000003au, 0x00000012u, 0x756e5f75u, + 0x6f705f6du, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, 0x0000003au, 0x00000013u, 0x616d5f75u, + 0x61765f78u, 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, 0x00090006u, 0x0000003au, 0x00000014u, + 0x756e5f75u, 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00070006u, 0x0000003au, + 0x00000015u, 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, 0x00070006u, 0x0000003au, 0x00000016u, + 0x756f5f75u, 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, 0x0000003cu, 0x00006370u, 0x00050005u, + 0x0000004cu, 0x65736162u, 0x6469775fu, 0x00006874u, 0x00040005u, 0x0000005eu, 0x5f6d6163u, 0x00007470u, + 0x00040005u, 0x0000006au, 0x74706564u, 0x00000068u, 0x00050005u, 0x0000006eu, 0x5f796172u, 0x6d726f6eu, + 0x00000000u, 0x00040005u, 0x00000078u, 0x666c6168u, 0x0069705fu, 0x00060005u, 0x00000085u, 0x75657370u, + 0x665f6f64u, 0x6c61636fu, 0x00000000u, 0x00040005u, 0x00000088u, 0x6c635f78u, 0x00007069u, 0x00040005u, + 0x00000094u, 0x6c635f79u, 0x00007069u, 0x00040005u, 0x000000a6u, 0x6e5f7978u, 0x006d726fu, 0x00050005u, + 0x000000aau, 0x5f736f63u, 0x68706c61u, 0x00000061u, 0x00040005u, 0x000000b1u, 0x68706c61u, 0x00000061u, + 0x00030005u, 0x000000b4u, 0x00003261u, 0x00030005u, 0x000000b8u, 0x00003361u, 0x00030005u, 0x000000bcu, + 0x00003461u, 0x00030005u, 0x000000c0u, 0x00003561u, 0x00040005u, 0x000000c4u, 0x746c6564u, 0x00000061u, + 0x00040005u, 0x000000f6u, 0x6c616373u, 0x00000065u, 0x00050005u, 0x00000101u, 0x65786970u, 0x65725f6cu, + 0x0000006cu, 0x00050005u, 0x00000106u, 0x65786970u, 0x69645f6cu, 0x00007473u, 0x00040005u, 0x00000123u, + 0x65786970u, 0x0000006cu, 0x00040005u, 0x0000012cu, 0x646e5f78u, 0x00000063u, 0x00040005u, 0x00000134u, + 0x646e5f79u, 0x00000063u, 0x00040005u, 0x00000142u, 0x61765f7au, 0x0065756cu, 0x00040005u, 0x00000150u, + 0x646e5f7au, 0x00000063u, 0x00030005u, 0x0000019eu, 0x00737675u, 0x00030005u, 0x000001b6u, 0x00776f72u, + 0x00030005u, 0x000001b7u, 0x006c6f63u, 0x00030005u, 0x000001e0u, 0x00776f72u, 0x00030005u, 0x000001e1u, + 0x006c6f63u, 0x00030005u, 0x00000228u, 0x00000077u, 0x00040005u, 0x0000024bu, 0x73697274u, 0x00000000u, + 0x00050005u, 0x00000260u, 0x5f776f72u, 0x72617473u, 0x00000074u, 0x00030005u, 0x00000262u, 0x00000074u, + 0x00030005u, 0x00000264u, 0x00776f72u, 0x00030005u, 0x00000265u, 0x006c6f63u, 0x00040005u, 0x00000267u, + 0x645f7369u, 0x006e776fu, 0x00030005u, 0x0000027bu, 0x0000746cu, 0x00030005u, 0x0000028bu, 0x0000746cu, + 0x00030005u, 0x0000029bu, 0x00003069u, 0x00030005u, 0x000002a1u, 0x00003169u, 0x00030005u, 0x000002a8u, + 0x00003269u, 0x00050005u, 0x000002cbu, 0x5f776f72u, 0x72617473u, 0x00000074u, 0x00030005u, 0x000002cdu, + 0x00000074u, 0x00030005u, 0x000002cfu, 0x00776f72u, 0x00030005u, 0x000002d0u, 0x006c6f63u, 0x00040005u, + 0x000002d1u, 0x645f7369u, 0x006e776fu, 0x00030005u, 0x000002e4u, 0x0000746cu, 0x00030005u, 0x000002f4u, + 0x0000746cu, 0x00030005u, 0x00000305u, 0x0000746cu, 0x00030005u, 0x00000316u, 0x0000746cu, 0x00030005u, + 0x00000327u, 0x0000746cu, 0x00030005u, 0x00000338u, 0x0000746cu, 0x00030005u, 0x00000348u, 0x00003069u, + 0x00030005u, 0x0000034eu, 0x00003169u, 0x00030005u, 0x00000355u, 0x00003269u, 0x00050005u, 0x00000376u, + 0x6972705fu, 0x6f635f6du, 0x00746e75u, 0x00060005u, 0x00000377u, 0x6b726f77u, 0x756f7267u, 0x64695f70u, + 0x00000000u, 0x00060005u, 0x00000379u, 0x575f6c67u, 0x476b726fu, 0x70756f72u, 0x00004449u, 0x00030005u, + 0x0000037du, 0x00646974u, 0x00080005u, 0x0000037eu, 0x4c5f6c67u, 0x6c61636fu, 0x6f766e49u, 0x69746163u, + 0x44496e6fu, 0x00000000u, 0x00050005u, 0x00000382u, 0x646e6552u, 0x75517265u, 0x00797265u, 0x00060006u, + 0x00000382u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, 0x00000382u, 0x00000001u, + 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000382u, 0x00000002u, 0x656d6974u, 0x6d617473u, + 0x73755f70u, 0x00000000u, 0x00070006u, 0x00000382u, 0x00000003u, 0x656d6163u, 0x745f6172u, 0x5f657079u, + 0x00006469u, 0x00050006u, 0x00000382u, 0x00000004u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000382u, + 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000382u, 0x00000006u, 0x6461705fu, 0x00000033u, + 0x00040005u, 0x00000384u, 0x72657571u, 0x00000079u, 0x00050005u, 0x00000385u, 0x646e6552u, 0x75517265u, + 0x00797265u, 0x00060006u, 0x00000385u, 0x00000000u, 0x6e656373u, 0x64695f65u, 0x00000000u, 0x00060006u, + 0x00000385u, 0x00000001u, 0x656d6163u, 0x695f6172u, 0x00000064u, 0x00070006u, 0x00000385u, 0x00000002u, + 0x656d6974u, 0x6d617473u, 0x73755f70u, 0x00000000u, 0x00070006u, 0x00000385u, 0x00000003u, 0x656d6163u, + 0x745f6172u, 0x5f657079u, 0x00006469u, 0x00050006u, 0x00000385u, 0x00000004u, 0x6461705fu, 0x00000031u, + 0x00050006u, 0x00000385u, 0x00000005u, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000385u, 0x00000006u, + 0x6461705fu, 0x00000033u, 0x00050005u, 0x00000387u, 0x72657551u, 0x66754279u, 0x00726566u, 0x00060006u, + 0x00000387u, 0x00000000u, 0x75715f67u, 0x65697265u, 0x00000073u, 0x00030005u, 0x00000389u, 0x00000000u, + 0x00070005u, 0x0000038au, 0x7473624fu, 0x656c6361u, 0x6b736154u, 0x6c796150u, 0x0064616fu, 0x00060006u, + 0x0000038au, 0x00000000u, 0x72657571u, 0x64695f79u, 0x00000000u, 0x00060006u, 0x0000038au, 0x00000001u, + 0x7473626fu, 0x656c6361u, 0x0064695fu, 0x00070006u, 0x0000038au, 0x00000002u, 0x656a626fu, 0x745f7463u, + 0x6f775f6fu, 0x00646c72u, 0x00050006u, 0x0000038au, 0x00000003u, 0x6c616373u, 0x00000065u, 0x00060006u, + 0x0000038au, 0x00000004u, 0x6e6f7266u, 0x6f635f74u, 0x00726f6cu, 0x00060006u, 0x0000038au, 0x00000005u, + 0x6b636162u, 0x6c6f635fu, 0x0000726fu, 0x00080006u, 0x0000038au, 0x00000006u, 0x64627573u, 0x73697669u, + 0x5f6e6f69u, 0x6576656cu, 0x0000006cu, 0x00070006u, 0x0000038au, 0x00000007u, 0x646e6572u, 0x665f7265u, + 0x7367616cu, 0x00000000u, 0x00050006u, 0x0000038au, 0x00000008u, 0x625f7369u, 0x00007665u, 0x00060006u, + 0x0000038au, 0x00000009u, 0x65636166u, 0x73616d5fu, 0x0000006bu, 0x00040005u, 0x0000038cu, 0x6c796170u, + 0x0064616fu, 0x00030005u, 0x00000394u, 0x006d6163u, 0x00060005u, 0x00000395u, 0x65685446u, 0x61436174u, + 0x6172656du, 0x00000000u, 0x00040006u, 0x00000395u, 0x00000000u, 0x00007863u, 0x00040006u, 0x00000395u, + 0x00000001u, 0x00007963u, 0x00050006u, 0x00000395u, 0x00000002u, 0x5f676d69u, 0x00000077u, 0x00050006u, + 0x00000395u, 0x00000003u, 0x5f676d69u, 0x00000068u, 0x00050006u, 0x00000395u, 0x00000004u, 0x796c6f70u, + 0x00000030u, 0x00050006u, 0x00000395u, 0x00000005u, 0x796c6f70u, 0x00000031u, 0x00050006u, 0x00000395u, + 0x00000006u, 0x796c6f70u, 0x00000032u, 0x00050006u, 0x00000395u, 0x00000007u, 0x796c6f70u, 0x00000033u, + 0x00050006u, 0x00000395u, 0x00000008u, 0x796c6f70u, 0x00000034u, 0x00050006u, 0x00000395u, 0x00000009u, + 0x796c6f70u, 0x00000035u, 0x00070006u, 0x00000395u, 0x0000000au, 0x5f78616du, 0x5f796172u, 0x6c676e61u, + 0x00000065u, 0x00080006u, 0x00000395u, 0x0000000bu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x765f6e6fu, + 0x00006c61u, 0x00080006u, 0x00000395u, 0x0000000cu, 0x5f78616du, 0x74736964u, 0x6974726fu, 0x645f6e6fu, + 0x006c6176u, 0x00060006u, 0x00000395u, 0x0000000du, 0x74706564u, 0x616d5f68u, 0x00000078u, 0x00050006u, + 0x00000395u, 0x0000000eu, 0x635f646cu, 0x00000000u, 0x00050006u, 0x00000395u, 0x0000000fu, 0x645f646cu, + 0x00000000u, 0x00050006u, 0x00000395u, 0x00000010u, 0x655f646cu, 0x00000000u, 0x00050006u, 0x00000395u, + 0x00000011u, 0x665f646cu, 0x00000000u, 0x00080005u, 0x00000397u, 0x656d6143u, 0x6e496172u, 0x6e697274u, + 0x73636973u, 0x66667542u, 0x00007265u, 0x00080006u, 0x00000397u, 0x00000000u, 0x61635f67u, 0x6172656du, + 0x746e695fu, 0x736e6972u, 0x00736369u, 0x00030005u, 0x00000399u, 0x00000000u, 0x00050005u, 0x000003a0u, + 0x77656976u, 0x736f705fu, 0x00000065u, 0x00050005u, 0x000003a1u, 0x656d6143u, 0x6f506172u, 0x00006573u, + 0x00070006u, 0x000003a1u, 0x00000000u, 0x6c726f77u, 0x6f745f64u, 0x6d61635fu, 0x00617265u, 0x00070005u, + 0x000003a3u, 0x656d6143u, 0x6f506172u, 0x75426573u, 0x72656666u, 0x00000000u, 0x00070006u, 0x000003a3u, + 0x00000000u, 0x61635f67u, 0x6172656du, 0x736f705fu, 0x00007365u, 0x00030005u, 0x000003a5u, 0x00000000u, + 0x00060005u, 0x000003b0u, 0x655f6777u, 0x5f656764u, 0x7366666fu, 0x00007465u, 0x00050005u, 0x000003b4u, + 0x45474445u, 0x4449575fu, 0x00004854u, 0x00030005u, 0x000003b6u, 0x00003065u, 0x00030005u, 0x000003b8u, + 0x00003165u, 0x00040005u, 0x000003bbu, 0x765f3065u, 0x00007369u, 0x00050005u, 0x000003cfu, 0x65646e69u, + 0x6c626178u, 0x00000065u, 0x00050005u, 0x000003d4u, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00040005u, + 0x000003dbu, 0x765f3165u, 0x00007369u, 0x00050005u, 0x000003dfu, 0x65646e69u, 0x6c626178u, 0x00000065u, + 0x00050005u, 0x000003e4u, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00060005u, 0x000003f4u, 0x73676573u, + 0x7265705fu, 0x6764655fu, 0x00000065u, 0x00060005u, 0x000003f8u, 0x61746f74u, 0x65735f6cu, 0x6e656d67u, + 0x00007374u, 0x00070005u, 0x000003fbu, 0x61746f74u, 0x64655f6cu, 0x765f6567u, 0x73747265u, 0x00000000u, + 0x00050005u, 0x00000402u, 0x61636f6cu, 0x65735f6cu, 0x00000067u, 0x00050005u, 0x0000040cu, 0x65676465u, + 0x5f6e695fu, 0x00006777u, 0x00050005u, 0x00000410u, 0x5f676573u, 0x655f6e69u, 0x00656764u, 0x00040005u, + 0x00000414u, 0x65676465u, 0x0064695fu, 0x00030005u, 0x00000419u, 0x006a6461u, 0x00050005u, 0x0000041bu, + 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, 0x0000042bu, 0x65736162u, 0x7265765fu, 0x00000074u, + 0x00070005u, 0x0000042eu, 0x4d5f6c67u, 0x50687365u, 0x65567265u, 0x78657472u, 0x00545845u, 0x00060006u, + 0x0000042eu, 0x00000000u, 0x505f6c67u, 0x7469736fu, 0x006e6f69u, 0x00070005u, 0x00000432u, 0x4d5f6c67u, + 0x56687365u, 0x69747265u, 0x45736563u, 0x00005458u, 0x00040005u, 0x00000440u, 0x65676465u, 0x00000000u, + 0x00050005u, 0x0000044cu, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, 0x0000044fu, 0x6c5f3076u, + 0x6c61636fu, 0x00000000u, 0x00050005u, 0x0000045eu, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, + 0x00000465u, 0x6c5f3176u, 0x6c61636fu, 0x00000000u, 0x00050005u, 0x00000468u, 0x65646e69u, 0x6c626178u, + 0x00000065u, 0x00050005u, 0x0000046eu, 0x775f3076u, 0x646c726fu, 0x00000000u, 0x00050005u, 0x00000479u, + 0x775f3176u, 0x646c726fu, 0x00000000u, 0x00030005u, 0x00000483u, 0x00003074u, 0x00030005u, 0x00000489u, + 0x00003174u, 0x00050005u, 0x00000490u, 0x5f307470u, 0x6c726f77u, 0x00000064u, 0x00050005u, 0x00000496u, + 0x5f317470u, 0x6c726f77u, 0x00000064u, 0x00040005u, 0x0000049du, 0x70696c63u, 0x00000030u, 0x00040005u, + 0x0000049eu, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004a0u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000004a2u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004a5u, 0x70696c63u, 0x00000031u, 0x00040005u, + 0x000004a6u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004a8u, 0x61726170u, 0x0000006du, 0x00040005u, + 0x000004aau, 0x61726170u, 0x0000006du, 0x00040005u, 0x000004adu, 0x3063646eu, 0x00000000u, 0x00040005u, + 0x000004b4u, 0x3163646eu, 0x00000000u, 0x00050005u, 0x000004bbu, 0x65676465u, 0x7269645fu, 0x00000000u, + 0x00040005u, 0x000004c0u, 0x70726570u, 0x00000000u, 0x00040005u, 0x000004c7u, 0x7366666fu, 0x00007465u, + 0x00050005u, 0x000004d1u, 0x65736162u, 0x7265765fu, 0x00000074u, 0x00040005u, 0x000004d4u, 0x3066666fu, + 0x00000000u, 0x00040005u, 0x000004dcu, 0x3166666fu, 0x00000000u, 0x00040005u, 0x000004e4u, 0x69625f7au, + 0x00307361u, 0x00040005u, 0x000004e9u, 0x69625f7au, 0x00317361u, 0x00030005u, 0x000004edu, 0x00003070u, + 0x00030005u, 0x000004f6u, 0x00003170u, 0x00030005u, 0x000004ffu, 0x00003270u, 0x00030005u, 0x00000508u, + 0x00003370u, 0x00050005u, 0x00000524u, 0x61636f6cu, 0x65735f6cu, 0x00000067u, 0x00050005u, 0x0000052eu, + 0x65736162u, 0x7265765fu, 0x00000074u, 0x00050005u, 0x00000531u, 0x65736162u, 0x6972745fu, 0x00000000u, + 0x000a0005u, 0x00000537u, 0x505f6c67u, 0x696d6972u, 0x65766974u, 0x61697254u, 0x656c676eu, 0x69646e49u, + 0x45736563u, 0x00005458u, 0x00080005u, 0x00000543u, 0x4d5f6c67u, 0x50687365u, 0x72507265u, 0x74696d69u, + 0x45657669u, 0x00005458u, 0x00060006u, 0x00000543u, 0x00000000u, 0x4c5f6c67u, 0x72657961u, 0x00000000u, + 0x00080005u, 0x00000546u, 0x4d5f6c67u, 0x50687365u, 0x696d6972u, 0x65766974u, 0x54584573u, 0x00000000u, + 0x00070005u, 0x0000054eu, 0x65627543u, 0x64617247u, 0x746e6569u, 0x636f6c42u, 0x0000006bu, 0x00060006u, + 0x0000054eu, 0x00000000u, 0x6e726f63u, 0x745f7265u, 0x00000000u, 0x00060006u, 0x0000054eu, 0x00000001u, + 0x6e6f7266u, 0x6f635f74u, 0x00726f6cu, 0x00060006u, 0x0000054eu, 0x00000002u, 0x6b636162u, 0x6c6f635fu, + 0x0000726fu, 0x00050006u, 0x0000054eu, 0x00000003u, 0x625f7369u, 0x00007665u, 0x00050005u, 0x00000551u, + 0x6d697270u, 0x74756f5fu, 0x00000000u, 0x00040005u, 0x00000586u, 0x65636166u, 0x0064695fu, 0x00040005u, + 0x00000588u, 0x64627573u, 0x00007669u, 0x00040005u, 0x00000597u, 0x65636166u, 0x00000000u, 0x00050005u, + 0x000005a2u, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00030005u, 0x000005a5u, 0x00000069u, 0x00050005u, + 0x000005adu, 0x74726576u, 0x7864695fu, 0x00000000u, 0x00050005u, 0x000005cbu, 0x61636f6cu, 0x65765f6cu, + 0x00007472u, 0x00050005u, 0x000005cdu, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00050005u, 0x000005d2u, + 0x6e726f63u, 0x745f7265u, 0x00000000u, 0x00040005u, 0x000005dau, 0x6e726f63u, 0x00737265u, 0x00060005u, + 0x000005ebu, 0x74726576u, 0x65705f73u, 0x72745f72u, 0x00000069u, 0x00040005u, 0x000005ecu, 0x61726170u, + 0x0000006du, 0x00060005u, 0x000005efu, 0x73697274u, 0x7265705fu, 0x6972745fu, 0x00000000u, 0x00040005u, + 0x000005f0u, 0x61726170u, 0x0000006du, 0x00050005u, 0x000005f3u, 0x61746f74u, 0x65765f6cu, 0x00737472u, + 0x00050005u, 0x000005f6u, 0x61746f74u, 0x72745f6cu, 0x00007369u, 0x00050005u, 0x000005feu, 0x5f697274u, + 0x74726576u, 0x00000073u, 0x00040005u, 0x00000613u, 0x5f697274u, 0x00000074u, 0x00030005u, 0x00000626u, + 0x00000074u, 0x00030005u, 0x0000062eu, 0x00003076u, 0x00030005u, 0x00000633u, 0x00003176u, 0x00030005u, + 0x00000639u, 0x00003276u, 0x00050005u, 0x0000063fu, 0x74726576u, 0x7361625fu, 0x00000065u, 0x00030005u, + 0x00000643u, 0x00000076u, 0x00030005u, 0x0000064du, 0x00007675u, 0x00040005u, 0x0000064eu, 0x61726170u, + 0x0000006du, 0x00040005u, 0x00000650u, 0x61726170u, 0x0000006du, 0x00030005u, 0x00000653u, 0x00007470u, + 0x00040005u, 0x00000654u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000656u, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000658u, 0x61726170u, 0x0000006du, 0x00040005u, 0x0000065au, 0x61726170u, 0x0000006du, + 0x00040005u, 0x0000065du, 0x70696c63u, 0x00000000u, 0x00040005u, 0x0000065eu, 0x61726170u, 0x0000006du, + 0x00040005u, 0x00000660u, 0x61726170u, 0x0000006du, 0x00040005u, 0x00000662u, 0x61726170u, 0x0000006du, + 0x00030005u, 0x0000066eu, 0x00000074u, 0x00050005u, 0x00000676u, 0x74726576u, 0x7361625fu, 0x00000065u, + 0x00050005u, 0x0000067au, 0x5f697274u, 0x65736162u, 0x00000000u, 0x00030005u, 0x0000067eu, 0x00003074u, + 0x00030005u, 0x00000683u, 0x00003174u, 0x00030005u, 0x00000689u, 0x00003274u, 0x00030005u, 0x0000068fu, + 0x00000069u, 0x00030005u, 0x00000699u, 0x00786469u, 0x00040005u, 0x0000069au, 0x61726170u, 0x0000006du, + 0x00040005u, 0x0000069cu, 0x61726170u, 0x0000006du, 0x00050005u, 0x0000069fu, 0x5f786469u, 0x65736162u, + 0x00000000u, 0x00030005u, 0x000006bbu, 0x00307675u, 0x00040005u, 0x000006bcu, 0x61726170u, 0x0000006du, + 0x00040005u, 0x000006bfu, 0x61726170u, 0x0000006du, 0x00030005u, 0x000006c2u, 0x00317675u, 0x00040005u, + 0x000006c3u, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006c6u, 0x61726170u, 0x0000006du, 0x00030005u, + 0x000006c9u, 0x00327675u, 0x00040005u, 0x000006cau, 0x61726170u, 0x0000006du, 0x00040005u, 0x000006cdu, + 0x61726170u, 0x0000006du, 0x00060005u, 0x000006d0u, 0x6e726f63u, 0x745f7265u, 0x6c61765fu, 0x00736575u, + 0x00080005u, 0x00000754u, 0x6f6c6f43u, 0x6c615072u, 0x65747465u, 0x66667542u, 0x61457265u, 0x00796c72u, + 0x00070006u, 0x00000754u, 0x00000000u, 0x6f635f67u, 0x5f726f6cu, 0x656c6170u, 0x00657474u, 0x00030005u, + 0x00000756u, 0x00000000u, 0x00070005u, 0x00000758u, 0x656d6954u, 0x6d617473u, 0x75427370u, 0x72656666u, + 0x00000000u, 0x00070006u, 0x00000758u, 0x00000000u, 0x69745f67u, 0x7473656du, 0x73706d61u, 0x00000000u, + 0x00030005u, 0x0000075au, 0x00000000u, 0x00050005u, 0x0000075cu, 0x33746e49u, 0x66754232u, 0x00726566u, + 0x00050006u, 0x0000075cu, 0x00000000u, 0x6e695f67u, 0x00323374u, 0x00030005u, 0x0000075eu, 0x00000000u, + 0x00040005u, 0x0000075fu, 0x74726556u, 0x00007865u, 0x00040006u, 0x0000075fu, 0x00000000u, 0x00000078u, + 0x00040006u, 0x0000075fu, 0x00000001u, 0x00000079u, 0x00040006u, 0x0000075fu, 0x00000002u, 0x0000007au, + 0x00050006u, 0x0000075fu, 0x00000003u, 0x6461705fu, 0x00000000u, 0x00060005u, 0x00000761u, 0x74726556u, + 0x75427865u, 0x72656666u, 0x00000000u, 0x00060006u, 0x00000761u, 0x00000000u, 0x65765f67u, 0x63697472u, + 0x00007365u, 0x00030005u, 0x00000763u, 0x00000000u, 0x00060005u, 0x00000765u, 0x61697254u, 0x656c676eu, + 0x66667542u, 0x00007265u, 0x00060006u, 0x00000765u, 0x00000000u, 0x72745f67u, 0x676e6169u, 0x0073656cu, + 0x00030005u, 0x00000767u, 0x00000000u, 0x00050005u, 0x00000769u, 0x65736f50u, 0x66667542u, 0x00007265u, + 0x00050006u, 0x00000769u, 0x00000000u, 0x6f705f67u, 0x00736573u, 0x00030005u, 0x0000076bu, 0x00000000u, + 0x00050005u, 0x0000076du, 0x616f6c46u, 0x66754274u, 0x00726566u, 0x00060006u, 0x0000076du, 0x00000000u, + 0x6c665f67u, 0x7374616fu, 0x00000000u, 0x00030005u, 0x0000076fu, 0x00000000u, 0x00070005u, 0x00000771u, + 0x656d6954u, 0x6d617473u, 0x53646570u, 0x656e6563u, 0x00000000u, 0x00080006u, 0x00000771u, 0x00000000u, + 0x5f6d756eu, 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x0000736cu, 0x00090006u, 0x00000771u, 0x00000001u, + 0x796c6f70u, 0x656e696cu, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x00080006u, 0x00000771u, + 0x00000002u, 0x5f6d756eu, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x00000073u, 0x00090006u, 0x00000771u, + 0x00000003u, 0x796c6f70u, 0x5f6e6f67u, 0x6c6f6f70u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00070006u, + 0x00000771u, 0x00000004u, 0x5f6d756eu, 0x65627563u, 0x6f6f705fu, 0x0000736cu, 0x00080006u, 0x00000771u, + 0x00000005u, 0x65627563u, 0x6f6f705fu, 0x6f5f736cu, 0x65736666u, 0x00000074u, 0x000a0006u, 0x00000771u, + 0x00000006u, 0x656d6974u, 0x6d617473u, 0x625f7370u, 0x65666675u, 0x666f5f72u, 0x74657366u, 0x00000000u, + 0x00080006u, 0x00000771u, 0x00000007u, 0x33746e69u, 0x75625f32u, 0x72656666u, 0x66666f5fu, 0x00746573u, + 0x00090006u, 0x00000771u, 0x00000008u, 0x74726576u, 0x625f7865u, 0x65666675u, 0x666f5f72u, 0x74657366u, + 0x00000000u, 0x00090006u, 0x00000771u, 0x00000009u, 0x61697274u, 0x656c676eu, 0x6675625fu, 0x5f726566u, + 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000771u, 0x0000000au, 0x65736f70u, 0x6675625fu, 0x5f726566u, + 0x7366666fu, 0x00007465u, 0x00080006u, 0x00000771u, 0x0000000bu, 0x616f6c66u, 0x75625f74u, 0x72656666u, + 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000771u, 0x0000000cu, 0x6461705fu, 0x00000000u, 0x00050005u, + 0x00000773u, 0x6e656353u, 0x66754265u, 0x00726566u, 0x00060006u, 0x00000773u, 0x00000000u, 0x63735f67u, + 0x73656e65u, 0x00000000u, 0x00030005u, 0x00000775u, 0x00000000u, 0x00080005u, 0x00000776u, 0x656d6954u, + 0x6d617473u, 0x50646570u, 0x6c796c6fu, 0x50656e69u, 0x006c6f6fu, 0x00070006u, 0x00000776u, 0x00000000u, + 0x5f6d756eu, 0x656d6974u, 0x6d617473u, 0x00007370u, 0x00060006u, 0x00000776u, 0x00000001u, 0x5f6d756eu, + 0x72726176u, 0x00737961u, 0x00070006u, 0x00000776u, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, + 0x00000000u, 0x00070006u, 0x00000776u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, + 0x00080006u, 0x00000776u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00090006u, 0x00000776u, 0x00000005u, 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, + 0x00000000u, 0x00080006u, 0x00000776u, 0x00000006u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, + 0x00000074u, 0x00070006u, 0x00000776u, 0x00000007u, 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, + 0x00060006u, 0x00000776u, 0x00000008u, 0x62626161u, 0x66666f5fu, 0x00746573u, 0x00050006u, 0x00000776u, + 0x00000009u, 0x6461705fu, 0x00000031u, 0x00050006u, 0x00000776u, 0x0000000au, 0x6461705fu, 0x00000032u, + 0x00050006u, 0x00000776u, 0x0000000bu, 0x6461705fu, 0x00000033u, 0x00050006u, 0x00000776u, 0x0000000cu, + 0x6461705fu, 0x00000034u, 0x00050006u, 0x00000776u, 0x0000000du, 0x6461705fu, 0x00000035u, 0x00050006u, + 0x00000776u, 0x0000000eu, 0x6461705fu, 0x00000036u, 0x00050006u, 0x00000776u, 0x0000000fu, 0x6461705fu, + 0x00000037u, 0x00070005u, 0x00000778u, 0x796c6f50u, 0x656e696cu, 0x6c6f6f50u, 0x66667542u, 0x00007265u, + 0x00080006u, 0x00000778u, 0x00000000u, 0x6f705f67u, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, + 0x00030005u, 0x0000077au, 0x00000000u, 0x00080005u, 0x0000077bu, 0x656d6954u, 0x6d617473u, 0x50646570u, + 0x67796c6fu, 0x6f506e6fu, 0x00006c6fu, 0x00070006u, 0x0000077bu, 0x00000000u, 0x5f6d756eu, 0x656d6974u, + 0x6d617473u, 0x00007370u, 0x00060006u, 0x0000077bu, 0x00000001u, 0x5f6d756eu, 0x72726176u, 0x00737961u, + 0x00070006u, 0x0000077bu, 0x00000002u, 0x5f6d756eu, 0x74726576u, 0x73656369u, 0x00000000u, 0x00070006u, + 0x0000077bu, 0x00000003u, 0x5f6d756eu, 0x61697274u, 0x656c676eu, 0x00000073u, 0x00070006u, 0x0000077bu, + 0x00000004u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, 0x00080006u, 0x0000077bu, 0x00000005u, + 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00090006u, 0x0000077bu, 0x00000006u, + 0x765f7374u, 0x61727261u, 0x705f7379u, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00080006u, 0x0000077bu, + 0x00000007u, 0x72726176u, 0x5f737961u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x0000077bu, + 0x00000008u, 0x5f697274u, 0x6f5f7370u, 0x65736666u, 0x00000074u, 0x00070006u, 0x0000077bu, 0x00000009u, + 0x74726576u, 0x73656369u, 0x66666f5fu, 0x00746573u, 0x00080006u, 0x0000077bu, 0x0000000au, 0x61697274u, + 0x656c676eu, 0x666f5f73u, 0x74657366u, 0x00000000u, 0x00060006u, 0x0000077bu, 0x0000000bu, 0x62626161u, + 0x66666f5fu, 0x00746573u, 0x00050006u, 0x0000077bu, 0x0000000cu, 0x6461705fu, 0x00000031u, 0x00050006u, + 0x0000077bu, 0x0000000du, 0x6461705fu, 0x00000032u, 0x00050006u, 0x0000077bu, 0x0000000eu, 0x6461705fu, + 0x00000033u, 0x00050006u, 0x0000077bu, 0x0000000fu, 0x6461705fu, 0x00000034u, 0x00070005u, 0x0000077du, + 0x796c6f50u, 0x506e6f67u, 0x426c6f6fu, 0x65666675u, 0x00000072u, 0x00070006u, 0x0000077du, 0x00000000u, + 0x6f705f67u, 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00030005u, 0x0000077fu, 0x00000000u, 0x00060005u, + 0x00000780u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x00000000u, 0x00060006u, 0x00000780u, 0x00000000u, + 0x5f6d756eu, 0x65627563u, 0x00000073u, 0x00070006u, 0x00000780u, 0x00000001u, 0x5f6d756eu, 0x656d6974u, + 0x6d617473u, 0x00007370u, 0x00070006u, 0x00000780u, 0x00000002u, 0x5f6d756eu, 0x63617274u, 0x6f705f6bu, + 0x00736573u, 0x00070006u, 0x00000780u, 0x00000003u, 0x6d697270u, 0x7079745fu, 0x64695f65u, 0x00000000u, + 0x00080006u, 0x00000780u, 0x00000004u, 0x656d6974u, 0x6d617473u, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00080006u, 0x00000780u, 0x00000005u, 0x65627563u, 0x5f73745fu, 0x6f5f7370u, 0x65736666u, 0x00000074u, + 0x00090006u, 0x00000780u, 0x00000006u, 0x63617274u, 0x69745f6bu, 0x7473656du, 0x73706d61u, 0x66666f5fu, + 0x00746573u, 0x00080006u, 0x00000780u, 0x00000007u, 0x6e617274u, 0x74616c73u, 0x736e6f69u, 0x66666f5fu, + 0x00746573u, 0x00080006u, 0x00000780u, 0x00000008u, 0x74617571u, 0x696e7265u, 0x5f736e6fu, 0x7366666fu, + 0x00007465u, 0x00070006u, 0x00000780u, 0x00000009u, 0x6c616373u, 0x6f5f7365u, 0x65736666u, 0x00000074u, + 0x00070006u, 0x00000780u, 0x0000000au, 0x6f6c6f63u, 0x6f5f7372u, 0x65736666u, 0x00000074u, 0x00070006u, + 0x00000780u, 0x0000000bu, 0x646e6572u, 0x665f7265u, 0x7367616cu, 0x00000000u, 0x00050006u, 0x00000780u, + 0x0000000cu, 0x6461705fu, 0x00000032u, 0x00050006u, 0x00000780u, 0x0000000du, 0x6461705fu, 0x00000033u, + 0x00050006u, 0x00000780u, 0x0000000eu, 0x6461705fu, 0x00000034u, 0x00050006u, 0x00000780u, 0x0000000fu, + 0x6461705fu, 0x00000035u, 0x00070005u, 0x00000782u, 0x7473624fu, 0x656c6361u, 0x6c6f6f50u, 0x66667542u, + 0x00007265u, 0x00080006u, 0x00000782u, 0x00000000u, 0x626f5f67u, 0x63617473u, 0x705f656cu, 0x736c6f6fu, + 0x00000000u, 0x00030005u, 0x00000784u, 0x00000000u, 0x00030047u, 0x0000003au, 0x00000002u, 0x00050048u, + 0x0000003au, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000003au, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x0000003au, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000003au, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000003au, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x0000003au, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000003au, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x0000003au, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x0000003au, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000003au, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x0000003au, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000003au, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000003au, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x0000003au, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000003au, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x0000003au, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, + 0x0000003au, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x0000003au, 0x00000011u, 0x00000023u, + 0x00000044u, 0x00050048u, 0x0000003au, 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x0000003au, + 0x00000013u, 0x00000023u, 0x0000004cu, 0x00050048u, 0x0000003au, 0x00000014u, 0x00000023u, 0x00000050u, + 0x00050048u, 0x0000003au, 0x00000015u, 0x00000023u, 0x00000054u, 0x00050048u, 0x0000003au, 0x00000016u, + 0x00000023u, 0x00000058u, 0x00040047u, 0x00000379u, 0x0000000bu, 0x0000001au, 0x00040047u, 0x0000037eu, + 0x0000000bu, 0x0000001bu, 0x00050048u, 0x00000385u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, + 0x00000385u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000385u, 0x00000002u, 0x00000023u, + 0x00000008u, 0x00050048u, 0x00000385u, 0x00000003u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000385u, + 0x00000004u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000385u, 0x00000005u, 0x00000023u, 0x00000018u, + 0x00050048u, 0x00000385u, 0x00000006u, 0x00000023u, 0x0000001cu, 0x00040047u, 0x00000386u, 0x00000006u, + 0x00000020u, 0x00030047u, 0x00000387u, 0x00000002u, 0x00040048u, 0x00000387u, 0x00000000u, 0x00000018u, + 0x00050048u, 0x00000387u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000389u, 0x00000018u, + 0x00040047u, 0x00000389u, 0x00000021u, 0x0000000du, 0x00040047u, 0x00000389u, 0x00000022u, 0x00000000u, + 0x00050048u, 0x00000395u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000395u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000395u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000395u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000395u, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x00000395u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000395u, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000395u, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x00000395u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000395u, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x00000395u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x00000395u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000395u, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00050048u, 0x00000395u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000395u, + 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000395u, 0x0000000fu, 0x00000023u, 0x0000003cu, + 0x00050048u, 0x00000395u, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x00000395u, 0x00000011u, + 0x00000023u, 0x00000044u, 0x00040047u, 0x00000396u, 0x00000006u, 0x00000048u, 0x00030047u, 0x00000397u, + 0x00000002u, 0x00040048u, 0x00000397u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000397u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x00000399u, 0x00000018u, 0x00040047u, 0x00000399u, 0x00000021u, + 0x0000000bu, 0x00040047u, 0x00000399u, 0x00000022u, 0x00000000u, 0x00040048u, 0x000003a1u, 0x00000000u, + 0x00000005u, 0x00050048u, 0x000003a1u, 0x00000000u, 0x00000007u, 0x00000010u, 0x00050048u, 0x000003a1u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00040047u, 0x000003a2u, 0x00000006u, 0x00000040u, 0x00030047u, + 0x000003a3u, 0x00000002u, 0x00040048u, 0x000003a3u, 0x00000000u, 0x00000018u, 0x00050048u, 0x000003a3u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x000003a5u, 0x00000018u, 0x00040047u, 0x000003a5u, + 0x00000021u, 0x0000000cu, 0x00040047u, 0x000003a5u, 0x00000022u, 0x00000000u, 0x00030047u, 0x000003cfu, + 0x00000018u, 0x00030047u, 0x000003d4u, 0x00000018u, 0x00030047u, 0x000003dfu, 0x00000018u, 0x00030047u, + 0x000003e4u, 0x00000018u, 0x00030047u, 0x0000041bu, 0x00000018u, 0x00030047u, 0x0000042eu, 0x00000002u, + 0x00050048u, 0x0000042eu, 0x00000000u, 0x0000000bu, 0x00000000u, 0x00030047u, 0x0000044cu, 0x00000018u, + 0x00030047u, 0x0000045eu, 0x00000018u, 0x00030047u, 0x00000468u, 0x00000018u, 0x00040047u, 0x00000537u, + 0x0000000bu, 0x000014b0u, 0x00030047u, 0x00000543u, 0x00000002u, 0x00050048u, 0x00000543u, 0x00000000u, + 0x0000000bu, 0x00000009u, 0x00040048u, 0x00000543u, 0x00000000u, 0x00001497u, 0x00030047u, 0x0000054eu, + 0x00000002u, 0x00040048u, 0x0000054eu, 0x00000000u, 0x00001497u, 0x00040048u, 0x0000054eu, 0x00000001u, + 0x00001497u, 0x00040048u, 0x0000054eu, 0x00000002u, 0x00001497u, 0x00040048u, 0x0000054eu, 0x00000003u, + 0x00001497u, 0x00040047u, 0x00000551u, 0x0000001eu, 0x00000000u, 0x00030047u, 0x000005a2u, 0x00000018u, + 0x00030047u, 0x000005cdu, 0x00000018u, 0x00040047u, 0x00000753u, 0x00000006u, 0x00000010u, 0x00030047u, + 0x00000754u, 0x00000002u, 0x00040048u, 0x00000754u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000754u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000756u, 0x00000018u, 0x00040047u, 0x00000756u, + 0x00000021u, 0x0000000au, 0x00040047u, 0x00000756u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000757u, + 0x00000006u, 0x00000008u, 0x00030047u, 0x00000758u, 0x00000002u, 0x00040048u, 0x00000758u, 0x00000000u, + 0x00000018u, 0x00050048u, 0x00000758u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000075au, + 0x00000018u, 0x00040047u, 0x0000075au, 0x00000021u, 0x00000000u, 0x00040047u, 0x0000075au, 0x00000022u, + 0x00000000u, 0x00040047u, 0x0000075bu, 0x00000006u, 0x00000004u, 0x00030047u, 0x0000075cu, 0x00000002u, + 0x00040048u, 0x0000075cu, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000075cu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000075eu, 0x00000018u, 0x00040047u, 0x0000075eu, 0x00000021u, 0x00000001u, + 0x00040047u, 0x0000075eu, 0x00000022u, 0x00000000u, 0x00050048u, 0x0000075fu, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x0000075fu, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x0000075fu, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000075fu, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00040047u, 0x00000760u, 0x00000006u, 0x00000010u, 0x00030047u, 0x00000761u, 0x00000002u, 0x00040048u, + 0x00000761u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000761u, 0x00000000u, 0x00000023u, 0x00000000u, + 0x00030047u, 0x00000763u, 0x00000018u, 0x00040047u, 0x00000763u, 0x00000021u, 0x00000002u, 0x00040047u, + 0x00000763u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000764u, 0x00000006u, 0x00000010u, 0x00030047u, + 0x00000765u, 0x00000002u, 0x00040048u, 0x00000765u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000765u, + 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000767u, 0x00000018u, 0x00040047u, 0x00000767u, + 0x00000021u, 0x00000003u, 0x00040047u, 0x00000767u, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000768u, + 0x00000006u, 0x00000040u, 0x00030047u, 0x00000769u, 0x00000002u, 0x00040048u, 0x00000769u, 0x00000000u, + 0x00000018u, 0x00050048u, 0x00000769u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000076bu, + 0x00000018u, 0x00040047u, 0x0000076bu, 0x00000021u, 0x00000004u, 0x00040047u, 0x0000076bu, 0x00000022u, + 0x00000000u, 0x00040047u, 0x0000076cu, 0x00000006u, 0x00000004u, 0x00030047u, 0x0000076du, 0x00000002u, + 0x00040048u, 0x0000076du, 0x00000000u, 0x00000018u, 0x00050048u, 0x0000076du, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x0000076fu, 0x00000018u, 0x00040047u, 0x0000076fu, 0x00000021u, 0x00000005u, + 0x00040047u, 0x0000076fu, 0x00000022u, 0x00000000u, 0x00040047u, 0x00000770u, 0x00000006u, 0x00000004u, + 0x00050048u, 0x00000771u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000771u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000771u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000771u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000771u, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x00000771u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000771u, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000771u, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x00000771u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000771u, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x00000771u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x00000771u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000771u, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00040047u, 0x00000772u, 0x00000006u, 0x00000080u, 0x00030047u, 0x00000773u, 0x00000002u, + 0x00040048u, 0x00000773u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000773u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00030047u, 0x00000775u, 0x00000018u, 0x00040047u, 0x00000775u, 0x00000021u, 0x00000006u, + 0x00040047u, 0x00000775u, 0x00000022u, 0x00000000u, 0x00050048u, 0x00000776u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x00000776u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000776u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000776u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x00000776u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000776u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x00000776u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x00000776u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000776u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x00000776u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000776u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000776u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x00000776u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000776u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x00000776u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x00000776u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, 0x00000777u, 0x00000006u, 0x00000040u, + 0x00030047u, 0x00000778u, 0x00000002u, 0x00040048u, 0x00000778u, 0x00000000u, 0x00000018u, 0x00050048u, + 0x00000778u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x0000077au, 0x00000018u, 0x00040047u, + 0x0000077au, 0x00000021u, 0x00000007u, 0x00040047u, 0x0000077au, 0x00000022u, 0x00000000u, 0x00050048u, + 0x0000077bu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x0000077bu, 0x00000001u, 0x00000023u, + 0x00000004u, 0x00050048u, 0x0000077bu, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x0000077bu, + 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x0000077bu, 0x00000004u, 0x00000023u, 0x00000010u, + 0x00050048u, 0x0000077bu, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x0000077bu, 0x00000006u, + 0x00000023u, 0x00000018u, 0x00050048u, 0x0000077bu, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, + 0x0000077bu, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x0000077bu, 0x00000009u, 0x00000023u, + 0x00000024u, 0x00050048u, 0x0000077bu, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x0000077bu, + 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x0000077bu, 0x0000000cu, 0x00000023u, 0x00000030u, + 0x00050048u, 0x0000077bu, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x0000077bu, 0x0000000eu, + 0x00000023u, 0x00000038u, 0x00050048u, 0x0000077bu, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00040047u, + 0x0000077cu, 0x00000006u, 0x00000040u, 0x00030047u, 0x0000077du, 0x00000002u, 0x00040048u, 0x0000077du, + 0x00000000u, 0x00000018u, 0x00050048u, 0x0000077du, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, + 0x0000077fu, 0x00000018u, 0x00040047u, 0x0000077fu, 0x00000021u, 0x00000008u, 0x00040047u, 0x0000077fu, + 0x00000022u, 0x00000000u, 0x00050048u, 0x00000780u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, + 0x00000780u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000780u, 0x00000002u, 0x00000023u, + 0x00000008u, 0x00050048u, 0x00000780u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000780u, + 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000780u, 0x00000005u, 0x00000023u, 0x00000014u, + 0x00050048u, 0x00000780u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000780u, 0x00000007u, + 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000780u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, + 0x00000780u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000780u, 0x0000000au, 0x00000023u, + 0x00000028u, 0x00050048u, 0x00000780u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000780u, + 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000780u, 0x0000000du, 0x00000023u, 0x00000034u, + 0x00050048u, 0x00000780u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000780u, 0x0000000fu, + 0x00000023u, 0x0000003cu, 0x00040047u, 0x00000781u, 0x00000006u, 0x00000040u, 0x00030047u, 0x00000782u, + 0x00000002u, 0x00040048u, 0x00000782u, 0x00000000u, 0x00000018u, 0x00050048u, 0x00000782u, 0x00000000u, + 0x00000023u, 0x00000000u, 0x00030047u, 0x00000784u, 0x00000018u, 0x00040047u, 0x00000784u, 0x00000021u, + 0x00000009u, 0x00040047u, 0x00000784u, 0x00000022u, 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, + 0x00000003u, 0x00000002u, 0x00040015u, 0x00000006u, 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000006u, + 0x00000007u, 0x00000020u, 0x0004002bu, 0x00000006u, 0x00000008u, 0x00000001u, 0x00030016u, 0x00000009u, + 0x00000020u, 0x00030021u, 0x0000000au, 0x00000009u, 0x00040017u, 0x0000000du, 0x00000009u, 0x00000003u, + 0x00040020u, 0x0000000eu, 0x00000007u, 0x0000000du, 0x00040017u, 0x0000000fu, 0x00000009u, 0x00000004u, + 0x00040018u, 0x00000010u, 0x0000000fu, 0x00000004u, 0x0003001eu, 0x00000011u, 0x00000010u, 0x00040020u, + 0x00000012u, 0x00000007u, 0x00000011u, 0x0014001eu, 0x00000013u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00040020u, + 0x00000014u, 0x00000007u, 0x00000013u, 0x00060021u, 0x00000015u, 0x0000000fu, 0x0000000eu, 0x00000012u, + 0x00000014u, 0x00040020u, 0x0000001bu, 0x00000007u, 0x00000006u, 0x00040021u, 0x0000001cu, 0x00000006u, + 0x0000001bu, 0x00040017u, 0x00000023u, 0x00000009u, 0x00000002u, 0x00050021u, 0x00000024u, 0x00000023u, + 0x0000001bu, 0x0000001bu, 0x00040020u, 0x00000029u, 0x00000007u, 0x00000023u, 0x00070021u, 0x0000002au, + 0x0000000du, 0x0000000eu, 0x0000000eu, 0x0000000eu, 0x00000029u, 0x00040017u, 0x00000031u, 0x00000006u, + 0x00000003u, 0x00050021u, 0x00000032u, 0x00000031u, 0x0000001bu, 0x0000001bu, 0x00040020u, 0x00000037u, + 0x00000007u, 0x00000009u, 0x00040015u, 0x00000039u, 0x00000020u, 0x00000001u, 0x0019001eu, 0x0000003au, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000039u, + 0x00000039u, 0x00000006u, 0x00000009u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000009u, 0x00000009u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, + 0x0000003bu, 0x00000009u, 0x0000003au, 0x0004003bu, 0x0000003bu, 0x0000003cu, 0x00000009u, 0x0004002bu, + 0x00000039u, 0x0000003du, 0x00000005u, 0x00040020u, 0x0000003eu, 0x00000009u, 0x00000009u, 0x0004002bu, + 0x00000009u, 0x00000041u, 0x00000000u, 0x00020014u, 0x00000042u, 0x0004002bu, 0x00000009u, 0x0000004au, + 0x3f800000u, 0x0004002bu, 0x00000039u, 0x0000004du, 0x00000004u, 0x0004002bu, 0x00000009u, 0x00000057u, + 0x40000000u, 0x0004002bu, 0x00000039u, 0x0000005fu, 0x00000000u, 0x00040020u, 0x00000060u, 0x00000007u, + 0x00000010u, 0x0004002bu, 0x00000006u, 0x0000006bu, 0x00000002u, 0x0004002bu, 0x00000009u, 0x00000072u, + 0x358637bdu, 0x0007002cu, 0x0000000fu, 0x00000076u, 0x00000041u, 0x00000041u, 0x00000041u, 0x0000004au, + 0x0004002bu, 0x00000009u, 0x00000079u, 0x3fc90fdau, 0x0004002bu, 0x00000039u, 0x0000007au, 0x0000000au, + 0x0004002bu, 0x00000009u, 0x00000080u, 0x3a83126fu, 0x0004002bu, 0x00000006u, 0x00000089u, 0x00000000u, + 0x0004002bu, 0x00000039u, 0x0000008eu, 0x00000002u, 0x0004002bu, 0x00000009u, 0x00000091u, 0x3f000000u, + 0x0004002bu, 0x00000039u, 0x0000009au, 0x00000003u, 0x0004002bu, 0x00000009u, 0x000000a0u, 0x41200000u, + 0x0004002bu, 0x00000009u, 0x000000afu, 0xbf800000u, 0x0004002bu, 0x00000039u, 0x000000ccu, 0x00000006u, + 0x0004002bu, 0x00000039u, 0x000000d2u, 0x00000007u, 0x0004002bu, 0x00000039u, 0x000000d8u, 0x00000008u, + 0x0004002bu, 0x00000039u, 0x000000deu, 0x00000009u, 0x0004002bu, 0x00000039u, 0x000000eau, 0x0000000bu, + 0x0004002bu, 0x00000039u, 0x000000f1u, 0x0000000cu, 0x0004002bu, 0x00000039u, 0x00000107u, 0x0000000eu, + 0x0004002bu, 0x00000039u, 0x0000010du, 0x0000000fu, 0x0004002bu, 0x00000039u, 0x00000115u, 0x00000010u, + 0x0004002bu, 0x00000039u, 0x0000011bu, 0x00000011u, 0x0004002bu, 0x00000039u, 0x00000127u, 0x00000001u, + 0x0004002bu, 0x00000039u, 0x0000014au, 0x0000000du, 0x0004002bu, 0x00000006u, 0x00000160u, 0x00000003u, + 0x0004002bu, 0x00000006u, 0x00000166u, 0x00000006u, 0x0004002bu, 0x00000006u, 0x0000016cu, 0x0000000fu, + 0x0004002bu, 0x00000006u, 0x0000016eu, 0x0000002du, 0x0004002bu, 0x00000006u, 0x0000017au, 0x00000004u, + 0x0004002bu, 0x00000006u, 0x00000180u, 0x00000010u, 0x0004002bu, 0x00000006u, 0x00000182u, 0x00000040u, + 0x0005002cu, 0x00000023u, 0x0000018du, 0x00000041u, 0x00000041u, 0x0005002cu, 0x00000023u, 0x00000193u, + 0x0000004au, 0x00000041u, 0x0005002cu, 0x00000023u, 0x00000195u, 0x00000041u, 0x0000004au, 0x0004001cu, + 0x0000019cu, 0x00000023u, 0x00000166u, 0x00040020u, 0x0000019du, 0x00000007u, 0x0000019cu, 0x0005002cu, + 0x00000023u, 0x000001a2u, 0x00000091u, 0x00000041u, 0x0005002cu, 0x00000023u, 0x000001a4u, 0x00000091u, + 0x00000091u, 0x0005002cu, 0x00000023u, 0x000001a6u, 0x00000041u, 0x00000091u, 0x0004002bu, 0x00000006u, + 0x000001b2u, 0x00000005u, 0x0004002bu, 0x00000006u, 0x000001bbu, 0x00000009u, 0x0004002bu, 0x00000006u, + 0x000001c3u, 0x0000000cu, 0x0004002bu, 0x00000006u, 0x000001cbu, 0x0000000eu, 0x0004002bu, 0x00000009u, + 0x000001d4u, 0x40800000u, 0x0004002bu, 0x00000006u, 0x000001e5u, 0x00000011u, 0x0004002bu, 0x00000006u, + 0x000001edu, 0x00000018u, 0x0004002bu, 0x00000006u, 0x000001f5u, 0x0000001eu, 0x0004002bu, 0x00000006u, + 0x000001fdu, 0x00000023u, 0x0004002bu, 0x00000006u, 0x00000205u, 0x00000027u, 0x0004002bu, 0x00000006u, + 0x0000020du, 0x0000002au, 0x0004002bu, 0x00000006u, 0x00000215u, 0x0000002cu, 0x0004002bu, 0x00000006u, + 0x00000219u, 0x00000007u, 0x0004002bu, 0x00000006u, 0x0000021du, 0x00000008u, 0x0004002bu, 0x00000009u, + 0x00000220u, 0x41000000u, 0x0006002cu, 0x00000031u, 0x00000242u, 0x00000089u, 0x00000008u, 0x0000006bu, + 0x0004001cu, 0x00000249u, 0x00000031u, 0x0000017au, 0x00040020u, 0x0000024au, 0x00000007u, 0x00000249u, + 0x0006002cu, 0x00000031u, 0x0000024cu, 0x00000089u, 0x00000160u, 0x000001b2u, 0x00040020u, 0x0000024du, + 0x00000007u, 0x00000031u, 0x0006002cu, 0x00000031u, 0x0000024fu, 0x00000160u, 0x00000008u, 0x0000017au, + 0x0006002cu, 0x00000031u, 0x00000251u, 0x000001b2u, 0x0000017au, 0x0000006bu, 0x0006002cu, 0x00000031u, + 0x00000253u, 0x00000160u, 0x0000017au, 0x000001b2u, 0x0004001cu, 0x0000025eu, 0x00000006u, 0x000001b2u, + 0x00040020u, 0x0000025fu, 0x00000007u, 0x0000025eu, 0x0008002cu, 0x0000025eu, 0x00000261u, 0x00000089u, + 0x000001b2u, 0x000001bbu, 0x000001c3u, 0x000001cbu, 0x00040020u, 0x00000266u, 0x00000007u, 0x00000042u, + 0x0003002au, 0x00000042u, 0x00000268u, 0x00030029u, 0x00000042u, 0x00000275u, 0x0004001cu, 0x000002c9u, + 0x00000006u, 0x000001bbu, 0x00040020u, 0x000002cau, 0x00000007u, 0x000002c9u, 0x000c002cu, 0x000002c9u, + 0x000002ccu, 0x00000089u, 0x000001bbu, 0x000001e5u, 0x000001edu, 0x000001f5u, 0x000001fdu, 0x00000205u, + 0x0000020du, 0x00000215u, 0x0004002bu, 0x00000006u, 0x000002e0u, 0x0000001cu, 0x0004002bu, 0x00000006u, + 0x00000301u, 0x00000030u, 0x0004002bu, 0x00000006u, 0x00000312u, 0x00000037u, 0x0004002bu, 0x00000006u, + 0x00000323u, 0x0000003cu, 0x0004002bu, 0x00000006u, 0x00000334u, 0x0000003fu, 0x00040020u, 0x00000378u, + 0x00000001u, 0x00000031u, 0x0004003bu, 0x00000378u, 0x00000379u, 0x00000001u, 0x00040020u, 0x0000037au, + 0x00000001u, 0x00000006u, 0x0004003bu, 0x00000378u, 0x0000037eu, 0x00000001u, 0x00040015u, 0x00000381u, + 0x00000040u, 0x00000001u, 0x0009001eu, 0x00000382u, 0x00000006u, 0x00000006u, 0x00000381u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x00000383u, 0x00000007u, 0x00000382u, 0x0009001eu, + 0x00000385u, 0x00000006u, 0x00000006u, 0x00000381u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x0003001du, 0x00000386u, 0x00000385u, 0x0003001eu, 0x00000387u, 0x00000386u, 0x00040020u, 0x00000388u, + 0x0000000cu, 0x00000387u, 0x0004003bu, 0x00000388u, 0x00000389u, 0x0000000cu, 0x000c001eu, 0x0000038au, + 0x00000006u, 0x00000006u, 0x00000010u, 0x0000000du, 0x0000000du, 0x0000000du, 0x00000006u, 0x00000006u, + 0x00000009u, 0x00000006u, 0x00040020u, 0x0000038bu, 0x0000151au, 0x0000038au, 0x0004003bu, 0x0000038bu, + 0x0000038cu, 0x0000151au, 0x00040020u, 0x0000038du, 0x0000151au, 0x00000006u, 0x00040020u, 0x00000390u, + 0x0000000cu, 0x00000385u, 0x0014001eu, 0x00000395u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, + 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x0003001du, 0x00000396u, + 0x00000395u, 0x0003001eu, 0x00000397u, 0x00000396u, 0x00040020u, 0x00000398u, 0x0000000cu, 0x00000397u, + 0x0004003bu, 0x00000398u, 0x00000399u, 0x0000000cu, 0x00040020u, 0x0000039cu, 0x0000000cu, 0x00000395u, + 0x0003001eu, 0x000003a1u, 0x00000010u, 0x0003001du, 0x000003a2u, 0x000003a1u, 0x0003001eu, 0x000003a3u, + 0x000003a2u, 0x00040020u, 0x000003a4u, 0x0000000cu, 0x000003a3u, 0x0004003bu, 0x000003a4u, 0x000003a5u, + 0x0000000cu, 0x00040020u, 0x000003a8u, 0x0000000cu, 0x000003a1u, 0x00040017u, 0x000003beu, 0x00000006u, + 0x00000002u, 0x0004001cu, 0x000003bfu, 0x000003beu, 0x000001c3u, 0x0005002cu, 0x000003beu, 0x000003c0u, + 0x00000089u, 0x0000017au, 0x0005002cu, 0x000003beu, 0x000003c1u, 0x00000089u, 0x00000160u, 0x0005002cu, + 0x000003beu, 0x000003c2u, 0x00000089u, 0x000001b2u, 0x0005002cu, 0x000003beu, 0x000003c3u, 0x00000089u, + 0x0000006bu, 0x0005002cu, 0x000003beu, 0x000003c4u, 0x00000008u, 0x0000017au, 0x0005002cu, 0x000003beu, + 0x000003c5u, 0x00000008u, 0x00000160u, 0x0005002cu, 0x000003beu, 0x000003c6u, 0x00000008u, 0x000001b2u, + 0x0005002cu, 0x000003beu, 0x000003c7u, 0x00000008u, 0x0000006bu, 0x0005002cu, 0x000003beu, 0x000003c8u, + 0x0000006bu, 0x0000017au, 0x0005002cu, 0x000003beu, 0x000003c9u, 0x00000160u, 0x0000017au, 0x0005002cu, + 0x000003beu, 0x000003cau, 0x00000160u, 0x000001b2u, 0x0005002cu, 0x000003beu, 0x000003cbu, 0x0000006bu, + 0x000001b2u, 0x000f002cu, 0x000003bfu, 0x000003ccu, 0x000003c0u, 0x000003c1u, 0x000003c2u, 0x000003c3u, + 0x000003c4u, 0x000003c5u, 0x000003c6u, 0x000003c7u, 0x000003c8u, 0x000003c9u, 0x000003cau, 0x000003cbu, + 0x00040020u, 0x000003ceu, 0x00000007u, 0x000003bfu, 0x00040020u, 0x00000418u, 0x00000007u, 0x000003beu, + 0x0003001eu, 0x0000042eu, 0x0000000fu, 0x0004002bu, 0x00000006u, 0x0000042fu, 0x00000060u, 0x0004001cu, + 0x00000430u, 0x0000042eu, 0x0000042fu, 0x00040020u, 0x00000431u, 0x00000003u, 0x00000430u, 0x0004003bu, + 0x00000431u, 0x00000432u, 0x00000003u, 0x00040020u, 0x00000434u, 0x00000003u, 0x0000000fu, 0x0005002cu, + 0x000003beu, 0x00000441u, 0x00000089u, 0x00000008u, 0x0005002cu, 0x000003beu, 0x00000442u, 0x0000006bu, + 0x00000160u, 0x0005002cu, 0x000003beu, 0x00000443u, 0x00000160u, 0x00000089u, 0x0005002cu, 0x000003beu, + 0x00000444u, 0x0000017au, 0x000001b2u, 0x0005002cu, 0x000003beu, 0x00000445u, 0x000001b2u, 0x00000166u, + 0x0005002cu, 0x000003beu, 0x00000446u, 0x00000166u, 0x00000219u, 0x0005002cu, 0x000003beu, 0x00000447u, + 0x00000219u, 0x0000017au, 0x0005002cu, 0x000003beu, 0x00000448u, 0x0000006bu, 0x00000166u, 0x0005002cu, + 0x000003beu, 0x00000449u, 0x00000160u, 0x00000219u, 0x000f002cu, 0x000003bfu, 0x0000044au, 0x00000441u, + 0x000003c7u, 0x00000442u, 0x00000443u, 0x00000444u, 0x00000445u, 0x00000446u, 0x00000447u, 0x000003c0u, + 0x000003c6u, 0x00000448u, 0x00000449u, 0x0004001cu, 0x00000450u, 0x0000000du, 0x0000021du, 0x0004002bu, + 0x00000009u, 0x00000451u, 0xbf000000u, 0x0006002cu, 0x0000000du, 0x00000452u, 0x00000451u, 0x00000451u, + 0x00000451u, 0x0006002cu, 0x0000000du, 0x00000453u, 0x00000091u, 0x00000451u, 0x00000451u, 0x0006002cu, + 0x0000000du, 0x00000454u, 0x00000091u, 0x00000091u, 0x00000451u, 0x0006002cu, 0x0000000du, 0x00000455u, + 0x00000451u, 0x00000091u, 0x00000451u, 0x0006002cu, 0x0000000du, 0x00000456u, 0x00000451u, 0x00000451u, + 0x00000091u, 0x0006002cu, 0x0000000du, 0x00000457u, 0x00000091u, 0x00000451u, 0x00000091u, 0x0006002cu, + 0x0000000du, 0x00000458u, 0x00000091u, 0x00000091u, 0x00000091u, 0x0006002cu, 0x0000000du, 0x00000459u, + 0x00000451u, 0x00000091u, 0x00000091u, 0x000b002cu, 0x00000450u, 0x0000045au, 0x00000452u, 0x00000453u, + 0x00000454u, 0x00000455u, 0x00000456u, 0x00000457u, 0x00000458u, 0x00000459u, 0x00040020u, 0x0000045du, + 0x00000007u, 0x00000450u, 0x00040020u, 0x00000461u, 0x0000151au, 0x0000000du, 0x00040020u, 0x0000046fu, + 0x0000151au, 0x00000010u, 0x00040020u, 0x0000049cu, 0x00000007u, 0x0000000fu, 0x0004002bu, 0x00000009u, + 0x000004e5u, 0xba83126fu, 0x0004002bu, 0x00000006u, 0x00000523u, 0x00000108u, 0x0004002bu, 0x00000006u, + 0x00000534u, 0x00000080u, 0x0004001cu, 0x00000535u, 0x00000031u, 0x00000534u, 0x00040020u, 0x00000536u, + 0x00000003u, 0x00000535u, 0x0004003bu, 0x00000536u, 0x00000537u, 0x00000003u, 0x00040020u, 0x00000541u, + 0x00000003u, 0x00000031u, 0x0003001eu, 0x00000543u, 0x00000039u, 0x0004001cu, 0x00000544u, 0x00000543u, + 0x00000534u, 0x00040020u, 0x00000545u, 0x00000003u, 0x00000544u, 0x0004003bu, 0x00000545u, 0x00000546u, + 0x00000003u, 0x00040020u, 0x0000054cu, 0x00000003u, 0x00000039u, 0x0006001eu, 0x0000054eu, 0x0000000du, + 0x0000000du, 0x0000000du, 0x00000009u, 0x0004001cu, 0x0000054fu, 0x0000054eu, 0x00000534u, 0x00040020u, + 0x00000550u, 0x00000003u, 0x0000054fu, 0x0004003bu, 0x00000550u, 0x00000551u, 0x00000003u, 0x00040020u, + 0x00000554u, 0x00000003u, 0x0000000du, 0x0004002bu, 0x00000009u, 0x00000558u, 0x3f48b439u, 0x0006002cu, + 0x0000000du, 0x00000559u, 0x00000558u, 0x00000558u, 0x00000558u, 0x00040020u, 0x00000560u, 0x0000151au, + 0x00000009u, 0x00040020u, 0x00000563u, 0x00000003u, 0x00000009u, 0x00040017u, 0x00000595u, 0x00000006u, + 0x00000004u, 0x00040020u, 0x00000596u, 0x00000007u, 0x00000595u, 0x0004001cu, 0x00000598u, 0x00000595u, + 0x00000166u, 0x0007002cu, 0x00000595u, 0x00000599u, 0x00000089u, 0x00000160u, 0x0000006bu, 0x00000008u, + 0x0007002cu, 0x00000595u, 0x0000059au, 0x0000017au, 0x000001b2u, 0x00000166u, 0x00000219u, 0x0007002cu, + 0x00000595u, 0x0000059bu, 0x00000089u, 0x0000017au, 0x00000219u, 0x00000160u, 0x0007002cu, 0x00000595u, + 0x0000059cu, 0x00000008u, 0x0000006bu, 0x00000166u, 0x000001b2u, 0x0007002cu, 0x00000595u, 0x0000059du, + 0x00000089u, 0x00000008u, 0x000001b2u, 0x0000017au, 0x0007002cu, 0x00000595u, 0x0000059eu, 0x00000160u, + 0x00000219u, 0x00000166u, 0x0000006bu, 0x0009002cu, 0x00000598u, 0x0000059fu, 0x00000599u, 0x0000059au, + 0x0000059bu, 0x0000059cu, 0x0000059du, 0x0000059eu, 0x00040020u, 0x000005a1u, 0x00000007u, 0x00000598u, + 0x0004001cu, 0x000005d0u, 0x00000009u, 0x0000017au, 0x00040020u, 0x000005d1u, 0x00000007u, 0x000005d0u, + 0x0004001cu, 0x000005d8u, 0x0000000du, 0x0000017au, 0x00040020u, 0x000005d9u, 0x00000007u, 0x000005d8u, + 0x0004001cu, 0x000005fcu, 0x0000000du, 0x00000166u, 0x00040020u, 0x000005fdu, 0x00000007u, 0x000005fcu, + 0x0004001cu, 0x00000611u, 0x00000009u, 0x00000166u, 0x00040020u, 0x00000612u, 0x00000007u, 0x00000611u, + 0x0004002bu, 0x00000006u, 0x00000723u, 0x0000000au, 0x0004002bu, 0x00000006u, 0x00000724u, 0x0000000bu, + 0x0004002bu, 0x00000006u, 0x00000725u, 0x0000000du, 0x0004002bu, 0x00000006u, 0x00000726u, 0x00000012u, + 0x0004002bu, 0x00000006u, 0x00000727u, 0x00000013u, 0x0004002bu, 0x00000006u, 0x00000728u, 0x00000014u, + 0x0004002bu, 0x00000006u, 0x00000729u, 0x00000015u, 0x0004002bu, 0x00000009u, 0x0000072au, 0x3f7dfdfeu, + 0x0004002bu, 0x00000009u, 0x0000072bu, 0x3b808081u, 0x0004002bu, 0x00000009u, 0x0000072cu, 0x3f68e8e9u, + 0x0006002cu, 0x0000000du, 0x0000072du, 0x0000072au, 0x0000072bu, 0x0000072cu, 0x0004002bu, 0x00000009u, + 0x0000072eu, 0x3ec4c4c5u, 0x0004002bu, 0x00000009u, 0x0000072fu, 0x3f37b7b8u, 0x0004002bu, 0x00000009u, + 0x00000730u, 0x3f79f9fau, 0x0006002cu, 0x0000000du, 0x00000731u, 0x0000072eu, 0x0000072fu, 0x00000730u, + 0x0004002bu, 0x00000009u, 0x00000732u, 0x3f0b8b8cu, 0x0004002bu, 0x00000009u, 0x00000733u, 0x3ebababbu, + 0x0006002cu, 0x0000000du, 0x00000734u, 0x00000732u, 0x00000733u, 0x0000004au, 0x0004002bu, 0x00000009u, + 0x00000735u, 0x3ec8c8c9u, 0x0006002cu, 0x0000000du, 0x00000736u, 0x0000004au, 0x00000735u, 0x00000041u, + 0x0006002cu, 0x0000000du, 0x00000737u, 0x00000041u, 0x0000004au, 0x00000041u, 0x0004002bu, 0x00000009u, + 0x00000738u, 0x3ed8d8d9u, 0x0004002bu, 0x00000009u, 0x00000739u, 0x3f33b3b4u, 0x0004002bu, 0x00000009u, + 0x0000073au, 0x3e6cecedu, 0x0006002cu, 0x0000000du, 0x0000073bu, 0x00000738u, 0x00000739u, 0x0000073au, + 0x0004002bu, 0x00000009u, 0x0000073cu, 0x3e8a8a8bu, 0x0004002bu, 0x00000009u, 0x0000073du, 0x3f31b1b2u, + 0x0006002cu, 0x0000000du, 0x0000073eu, 0x0000072fu, 0x0000073cu, 0x0000073du, 0x0004002bu, 0x00000009u, + 0x0000073fu, 0x3da0a0a1u, 0x0004002bu, 0x00000009u, 0x00000740u, 0x3f7efeffu, 0x0004002bu, 0x00000009u, + 0x00000741u, 0x3f39b9bau, 0x0006002cu, 0x0000000du, 0x00000742u, 0x0000073fu, 0x00000740u, 0x00000741u, + 0x0006002cu, 0x0000000du, 0x00000743u, 0x00000735u, 0x00000735u, 0x00000735u, 0x0004002bu, 0x00000009u, + 0x00000744u, 0x3d008081u, 0x0004002bu, 0x00000009u, 0x00000745u, 0x3c008081u, 0x0006002cu, 0x0000000du, + 0x00000746u, 0x00000744u, 0x00000745u, 0x0000004au, 0x0004002bu, 0x00000009u, 0x00000747u, 0x3ea0a0a1u, + 0x0004002bu, 0x00000009u, 0x00000748u, 0x3ef0f0f1u, 0x0006002cu, 0x0000000du, 0x00000749u, 0x00000747u, + 0x00000747u, 0x00000748u, 0x0004002bu, 0x00000009u, 0x0000074au, 0x3e70f0f1u, 0x0006002cu, 0x0000000du, + 0x0000074bu, 0x0000074au, 0x00000748u, 0x0000074au, 0x0006002cu, 0x0000000du, 0x0000074cu, 0x00000748u, + 0x00000747u, 0x00000747u, 0x0006002cu, 0x0000000du, 0x0000074du, 0x0000004au, 0x0000004au, 0x0000004au, + 0x0006002cu, 0x0000000du, 0x0000074eu, 0x0000004au, 0x0000004au, 0x00000041u, 0x0004002bu, 0x00000009u, + 0x0000074fu, 0x40e00000u, 0x0004002bu, 0x00000009u, 0x00000750u, 0x41400000u, 0x0004002bu, 0x00000009u, + 0x00000751u, 0x40a00000u, 0x0004002bu, 0x00000009u, 0x00000752u, 0x40400000u, 0x0003001du, 0x00000753u, + 0x0000000fu, 0x0003001eu, 0x00000754u, 0x00000753u, 0x00040020u, 0x00000755u, 0x0000000cu, 0x00000754u, + 0x0004003bu, 0x00000755u, 0x00000756u, 0x0000000cu, 0x0003001du, 0x00000757u, 0x00000381u, 0x0003001eu, + 0x00000758u, 0x00000757u, 0x00040020u, 0x00000759u, 0x0000000cu, 0x00000758u, 0x0004003bu, 0x00000759u, + 0x0000075au, 0x0000000cu, 0x0003001du, 0x0000075bu, 0x00000039u, 0x0003001eu, 0x0000075cu, 0x0000075bu, + 0x00040020u, 0x0000075du, 0x0000000cu, 0x0000075cu, 0x0004003bu, 0x0000075du, 0x0000075eu, 0x0000000cu, + 0x0006001eu, 0x0000075fu, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000009u, 0x0003001du, 0x00000760u, + 0x0000075fu, 0x0003001eu, 0x00000761u, 0x00000760u, 0x00040020u, 0x00000762u, 0x0000000cu, 0x00000761u, + 0x0004003bu, 0x00000762u, 0x00000763u, 0x0000000cu, 0x0003001du, 0x00000764u, 0x00000031u, 0x0003001eu, + 0x00000765u, 0x00000764u, 0x00040020u, 0x00000766u, 0x0000000cu, 0x00000765u, 0x0004003bu, 0x00000766u, + 0x00000767u, 0x0000000cu, 0x0003001du, 0x00000768u, 0x000003a1u, 0x0003001eu, 0x00000769u, 0x00000768u, + 0x00040020u, 0x0000076au, 0x0000000cu, 0x00000769u, 0x0004003bu, 0x0000076au, 0x0000076bu, 0x0000000cu, + 0x0003001du, 0x0000076cu, 0x00000009u, 0x0003001eu, 0x0000076du, 0x0000076cu, 0x00040020u, 0x0000076eu, + 0x0000000cu, 0x0000076du, 0x0004003bu, 0x0000076eu, 0x0000076fu, 0x0000000cu, 0x0004001cu, 0x00000770u, + 0x00000006u, 0x00000728u, 0x000f001eu, 0x00000771u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000770u, 0x0003001du, 0x00000772u, 0x00000771u, 0x0003001eu, 0x00000773u, 0x00000772u, 0x00040020u, + 0x00000774u, 0x0000000cu, 0x00000773u, 0x0004003bu, 0x00000774u, 0x00000775u, 0x0000000cu, 0x0012001eu, + 0x00000776u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x0003001du, 0x00000777u, 0x00000776u, 0x0003001eu, 0x00000778u, 0x00000777u, 0x00040020u, + 0x00000779u, 0x0000000cu, 0x00000778u, 0x0004003bu, 0x00000779u, 0x0000077au, 0x0000000cu, 0x0012001eu, + 0x0000077bu, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x0003001du, 0x0000077cu, 0x0000077bu, 0x0003001eu, 0x0000077du, 0x0000077cu, 0x00040020u, + 0x0000077eu, 0x0000000cu, 0x0000077du, 0x0004003bu, 0x0000077eu, 0x0000077fu, 0x0000000cu, 0x0012001eu, + 0x00000780u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x0003001du, 0x00000781u, 0x00000780u, 0x0003001eu, 0x00000782u, 0x00000781u, 0x00040020u, + 0x00000783u, 0x0000000cu, 0x00000782u, 0x0004003bu, 0x00000783u, 0x00000784u, 0x0000000cu, 0x0006002cu, + 0x00000031u, 0x00000785u, 0x00000007u, 0x00000008u, 0x00000008u, 0x00050036u, 0x00000002u, 0x00000004u, + 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x0000001bu, 0x00000376u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000377u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000037du, 0x00000007u, + 0x0004003bu, 0x00000383u, 0x00000384u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000394u, 0x00000007u, + 0x0004003bu, 0x00000012u, 0x000003a0u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000003b0u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000003b4u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000003b6u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000003b8u, 0x00000007u, 0x0004003bu, 0x00000266u, 0x000003bbu, 0x00000007u, + 0x0005003bu, 0x000003ceu, 0x000003cfu, 0x00000007u, 0x000003ccu, 0x0005003bu, 0x000003ceu, 0x000003d4u, + 0x00000007u, 0x000003ccu, 0x0004003bu, 0x00000266u, 0x000003dbu, 0x00000007u, 0x0005003bu, 0x000003ceu, + 0x000003dfu, 0x00000007u, 0x000003ccu, 0x0005003bu, 0x000003ceu, 0x000003e4u, 0x00000007u, 0x000003ccu, + 0x0004003bu, 0x0000001bu, 0x000003f4u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000003f8u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000003fbu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000402u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x0000040cu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000410u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000414u, 0x00000007u, 0x0004003bu, 0x00000418u, 0x00000419u, 0x00000007u, + 0x0005003bu, 0x000003ceu, 0x0000041bu, 0x00000007u, 0x000003ccu, 0x0004003bu, 0x0000001bu, 0x0000042bu, + 0x00000007u, 0x0004003bu, 0x00000418u, 0x00000440u, 0x00000007u, 0x0005003bu, 0x000003ceu, 0x0000044cu, + 0x00000007u, 0x0000044au, 0x0004003bu, 0x0000000eu, 0x0000044fu, 0x00000007u, 0x0005003bu, 0x0000045du, + 0x0000045eu, 0x00000007u, 0x0000045au, 0x0004003bu, 0x0000000eu, 0x00000465u, 0x00000007u, 0x0005003bu, + 0x0000045du, 0x00000468u, 0x00000007u, 0x0000045au, 0x0004003bu, 0x0000000eu, 0x0000046eu, 0x00000007u, + 0x0004003bu, 0x0000000eu, 0x00000479u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000483u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x00000489u, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x00000490u, 0x00000007u, + 0x0004003bu, 0x0000000eu, 0x00000496u, 0x00000007u, 0x0004003bu, 0x0000049cu, 0x0000049du, 0x00000007u, + 0x0004003bu, 0x0000000eu, 0x0000049eu, 0x00000007u, 0x0004003bu, 0x00000012u, 0x000004a0u, 0x00000007u, + 0x0004003bu, 0x00000014u, 0x000004a2u, 0x00000007u, 0x0004003bu, 0x0000049cu, 0x000004a5u, 0x00000007u, + 0x0004003bu, 0x0000000eu, 0x000004a6u, 0x00000007u, 0x0004003bu, 0x00000012u, 0x000004a8u, 0x00000007u, + 0x0004003bu, 0x00000014u, 0x000004aau, 0x00000007u, 0x0004003bu, 0x00000029u, 0x000004adu, 0x00000007u, + 0x0004003bu, 0x00000029u, 0x000004b4u, 0x00000007u, 0x0004003bu, 0x00000029u, 0x000004bbu, 0x00000007u, + 0x0004003bu, 0x00000029u, 0x000004c0u, 0x00000007u, 0x0004003bu, 0x00000029u, 0x000004c7u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000004d1u, 0x00000007u, 0x0004003bu, 0x0000049cu, 0x000004d4u, 0x00000007u, + 0x0004003bu, 0x0000049cu, 0x000004dcu, 0x00000007u, 0x0004003bu, 0x00000037u, 0x000004e4u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000004e9u, 0x00000007u, 0x0004003bu, 0x0000049cu, 0x000004edu, 0x00000007u, + 0x0004003bu, 0x0000049cu, 0x000004f6u, 0x00000007u, 0x0004003bu, 0x0000049cu, 0x000004ffu, 0x00000007u, + 0x0004003bu, 0x0000049cu, 0x00000508u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000524u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x0000052eu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000531u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000586u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000588u, 0x00000007u, + 0x0004003bu, 0x00000596u, 0x00000597u, 0x00000007u, 0x0005003bu, 0x000005a1u, 0x000005a2u, 0x00000007u, + 0x0000059fu, 0x0004003bu, 0x0000001bu, 0x000005a5u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005adu, + 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005b0u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005b8u, + 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005c0u, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x000005cbu, + 0x00000007u, 0x0005003bu, 0x0000045du, 0x000005cdu, 0x00000007u, 0x0000045au, 0x0004003bu, 0x000005d1u, + 0x000005d2u, 0x00000007u, 0x0004003bu, 0x000005d9u, 0x000005dau, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x000005ebu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005ecu, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x000005efu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005f0u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x000005f3u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000005f6u, 0x00000007u, 0x0004003bu, 0x000005fdu, + 0x000005feu, 0x00000007u, 0x0004003bu, 0x00000612u, 0x00000613u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x00000626u, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x0000062eu, 0x00000007u, 0x0004003bu, 0x0000000eu, + 0x00000633u, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x00000639u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x0000063fu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000643u, 0x00000007u, 0x0004003bu, 0x00000029u, + 0x0000064du, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000064eu, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x00000650u, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x00000653u, 0x00000007u, 0x0004003bu, 0x0000000eu, + 0x00000654u, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x00000656u, 0x00000007u, 0x0004003bu, 0x0000000eu, + 0x00000658u, 0x00000007u, 0x0004003bu, 0x00000029u, 0x0000065au, 0x00000007u, 0x0004003bu, 0x0000049cu, + 0x0000065du, 0x00000007u, 0x0004003bu, 0x0000000eu, 0x0000065eu, 0x00000007u, 0x0004003bu, 0x00000012u, + 0x00000660u, 0x00000007u, 0x0004003bu, 0x00000014u, 0x00000662u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x0000066eu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000676u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x0000067au, 0x00000007u, 0x0004003bu, 0x00000037u, 0x0000067eu, 0x00000007u, 0x0004003bu, 0x00000037u, + 0x00000683u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000689u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x0000068fu, 0x00000007u, 0x0004003bu, 0x0000024du, 0x00000699u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x0000069au, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000069cu, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x0000069fu, 0x00000007u, 0x0004003bu, 0x00000029u, 0x000006bbu, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x000006bcu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000006bfu, 0x00000007u, 0x0004003bu, 0x00000029u, + 0x000006c2u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000006c3u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x000006c6u, 0x00000007u, 0x0004003bu, 0x00000029u, 0x000006c9u, 0x00000007u, 0x0004003bu, 0x0000001bu, + 0x000006cau, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000006cdu, 0x00000007u, 0x0004003bu, 0x0000000eu, + 0x000006d0u, 0x00000007u, 0x0003003eu, 0x00000376u, 0x00000089u, 0x00050041u, 0x0000037au, 0x0000037bu, + 0x00000379u, 0x00000089u, 0x0004003du, 0x00000006u, 0x0000037cu, 0x0000037bu, 0x0003003eu, 0x00000377u, + 0x0000037cu, 0x00050041u, 0x0000037au, 0x0000037fu, 0x0000037eu, 0x00000089u, 0x0004003du, 0x00000006u, + 0x00000380u, 0x0000037fu, 0x0003003eu, 0x0000037du, 0x00000380u, 0x00050041u, 0x0000038du, 0x0000038eu, + 0x0000038cu, 0x0000005fu, 0x0004003du, 0x00000006u, 0x0000038fu, 0x0000038eu, 0x00060041u, 0x00000390u, + 0x00000391u, 0x00000389u, 0x0000005fu, 0x0000038fu, 0x0004003du, 0x00000385u, 0x00000392u, 0x00000391u, + 0x00040190u, 0x00000382u, 0x00000393u, 0x00000392u, 0x0003003eu, 0x00000384u, 0x00000393u, 0x00050041u, + 0x0000001bu, 0x0000039au, 0x00000384u, 0x00000127u, 0x0004003du, 0x00000006u, 0x0000039bu, 0x0000039au, + 0x00060041u, 0x0000039cu, 0x0000039du, 0x00000399u, 0x0000005fu, 0x0000039bu, 0x0004003du, 0x00000395u, + 0x0000039eu, 0x0000039du, 0x00040190u, 0x00000013u, 0x0000039fu, 0x0000039eu, 0x0003003eu, 0x00000394u, + 0x0000039fu, 0x00050041u, 0x0000038du, 0x000003a6u, 0x0000038cu, 0x0000005fu, 0x0004003du, 0x00000006u, + 0x000003a7u, 0x000003a6u, 0x00060041u, 0x000003a8u, 0x000003a9u, 0x000003a5u, 0x0000005fu, 0x000003a7u, + 0x0004003du, 0x000003a1u, 0x000003aau, 0x000003a9u, 0x00040190u, 0x00000011u, 0x000003abu, 0x000003aau, + 0x0003003eu, 0x000003a0u, 0x000003abu, 0x0004003du, 0x00000006u, 0x000003acu, 0x00000377u, 0x000500aeu, + 0x00000042u, 0x000003adu, 0x000003acu, 0x00000166u, 0x000300f7u, 0x000003afu, 0x00000000u, 0x000400fau, + 0x000003adu, 0x000003aeu, 0x000003afu, 0x000200f8u, 0x000003aeu, 0x0004003du, 0x00000006u, 0x000003b1u, + 0x00000377u, 0x00050082u, 0x00000006u, 0x000003b2u, 0x000003b1u, 0x00000166u, 0x00050084u, 0x00000006u, + 0x000003b3u, 0x000003b2u, 0x0000006bu, 0x0003003eu, 0x000003b0u, 0x000003b3u, 0x00040039u, 0x00000009u, + 0x000003b5u, 0x0000000bu, 0x0003003eu, 0x000003b4u, 0x000003b5u, 0x0004003du, 0x00000006u, 0x000003b7u, + 0x000003b0u, 0x0003003eu, 0x000003b6u, 0x000003b7u, 0x0004003du, 0x00000006u, 0x000003b9u, 0x000003b0u, + 0x00050080u, 0x00000006u, 0x000003bau, 0x000003b9u, 0x00000008u, 0x0003003eu, 0x000003b8u, 0x000003bau, + 0x00050041u, 0x0000038du, 0x000003bcu, 0x0000038cu, 0x000000deu, 0x0004003du, 0x00000006u, 0x000003bdu, + 0x000003bcu, 0x0004003du, 0x00000006u, 0x000003cdu, 0x000003b6u, 0x00060041u, 0x0000001bu, 0x000003d0u, + 0x000003cfu, 0x000003cdu, 0x00000089u, 0x0004003du, 0x00000006u, 0x000003d1u, 0x000003d0u, 0x000500c4u, + 0x00000006u, 0x000003d2u, 0x00000008u, 0x000003d1u, 0x0004003du, 0x00000006u, 0x000003d3u, 0x000003b6u, + 0x00060041u, 0x0000001bu, 0x000003d5u, 0x000003d4u, 0x000003d3u, 0x00000008u, 0x0004003du, 0x00000006u, + 0x000003d6u, 0x000003d5u, 0x000500c4u, 0x00000006u, 0x000003d7u, 0x00000008u, 0x000003d6u, 0x000500c5u, + 0x00000006u, 0x000003d8u, 0x000003d2u, 0x000003d7u, 0x000500c7u, 0x00000006u, 0x000003d9u, 0x000003bdu, + 0x000003d8u, 0x000500abu, 0x00000042u, 0x000003dau, 0x000003d9u, 0x00000089u, 0x0003003eu, 0x000003bbu, + 0x000003dau, 0x00050041u, 0x0000038du, 0x000003dcu, 0x0000038cu, 0x000000deu, 0x0004003du, 0x00000006u, + 0x000003ddu, 0x000003dcu, 0x0004003du, 0x00000006u, 0x000003deu, 0x000003b8u, 0x00060041u, 0x0000001bu, + 0x000003e0u, 0x000003dfu, 0x000003deu, 0x00000089u, 0x0004003du, 0x00000006u, 0x000003e1u, 0x000003e0u, + 0x000500c4u, 0x00000006u, 0x000003e2u, 0x00000008u, 0x000003e1u, 0x0004003du, 0x00000006u, 0x000003e3u, + 0x000003b8u, 0x00060041u, 0x0000001bu, 0x000003e5u, 0x000003e4u, 0x000003e3u, 0x00000008u, 0x0004003du, + 0x00000006u, 0x000003e6u, 0x000003e5u, 0x000500c4u, 0x00000006u, 0x000003e7u, 0x00000008u, 0x000003e6u, + 0x000500c5u, 0x00000006u, 0x000003e8u, 0x000003e2u, 0x000003e7u, 0x000500c7u, 0x00000006u, 0x000003e9u, + 0x000003ddu, 0x000003e8u, 0x000500abu, 0x00000042u, 0x000003eau, 0x000003e9u, 0x00000089u, 0x0003003eu, + 0x000003dbu, 0x000003eau, 0x0004003du, 0x00000042u, 0x000003ebu, 0x000003bbu, 0x000400a8u, 0x00000042u, + 0x000003ecu, 0x000003ebu, 0x0004003du, 0x00000042u, 0x000003edu, 0x000003dbu, 0x000400a8u, 0x00000042u, + 0x000003eeu, 0x000003edu, 0x000500a7u, 0x00000042u, 0x000003efu, 0x000003ecu, 0x000003eeu, 0x000300f7u, + 0x000003f1u, 0x00000000u, 0x000400fau, 0x000003efu, 0x000003f0u, 0x000003f1u, 0x000200f8u, 0x000003f0u, + 0x0003003eu, 0x00000376u, 0x00000089u, 0x0004003du, 0x00000006u, 0x000003f2u, 0x00000376u, 0x000314afu, + 0x00000089u, 0x000003f2u, 0x000100fdu, 0x000200f8u, 0x000003f1u, 0x00050041u, 0x0000038du, 0x000003f5u, + 0x0000038cu, 0x000000ccu, 0x0004003du, 0x00000006u, 0x000003f6u, 0x000003f5u, 0x000500c4u, 0x00000006u, + 0x000003f7u, 0x00000008u, 0x000003f6u, 0x0003003eu, 0x000003f4u, 0x000003f7u, 0x0004003du, 0x00000006u, + 0x000003f9u, 0x000003f4u, 0x00050084u, 0x00000006u, 0x000003fau, 0x000003f9u, 0x0000006bu, 0x0003003eu, + 0x000003f8u, 0x000003fau, 0x0004003du, 0x00000006u, 0x000003fcu, 0x000003f8u, 0x00050084u, 0x00000006u, + 0x000003fdu, 0x000003fcu, 0x0000017au, 0x0003003eu, 0x000003fbu, 0x000003fdu, 0x0004003du, 0x00000006u, + 0x000003feu, 0x000003f8u, 0x00050084u, 0x00000006u, 0x000003ffu, 0x000003feu, 0x0000006bu, 0x0003003eu, + 0x00000376u, 0x000003ffu, 0x0004003du, 0x00000006u, 0x00000400u, 0x000003fbu, 0x0004003du, 0x00000006u, + 0x00000401u, 0x00000376u, 0x000314afu, 0x00000400u, 0x00000401u, 0x0004003du, 0x00000006u, 0x00000403u, + 0x0000037du, 0x0003003eu, 0x00000402u, 0x00000403u, 0x000200f9u, 0x00000404u, 0x000200f8u, 0x00000404u, + 0x000400f6u, 0x00000406u, 0x00000407u, 0x00000000u, 0x000200f9u, 0x00000408u, 0x000200f8u, 0x00000408u, + 0x0004003du, 0x00000006u, 0x00000409u, 0x00000402u, 0x0004003du, 0x00000006u, 0x0000040au, 0x000003f8u, + 0x000500b0u, 0x00000042u, 0x0000040bu, 0x00000409u, 0x0000040au, 0x000400fau, 0x0000040bu, 0x00000405u, + 0x00000406u, 0x000200f8u, 0x00000405u, 0x0004003du, 0x00000006u, 0x0000040du, 0x00000402u, 0x0004003du, + 0x00000006u, 0x0000040eu, 0x000003f4u, 0x00050086u, 0x00000006u, 0x0000040fu, 0x0000040du, 0x0000040eu, + 0x0003003eu, 0x0000040cu, 0x0000040fu, 0x0004003du, 0x00000006u, 0x00000411u, 0x00000402u, 0x0004003du, + 0x00000006u, 0x00000412u, 0x000003f4u, 0x00050089u, 0x00000006u, 0x00000413u, 0x00000411u, 0x00000412u, + 0x0003003eu, 0x00000410u, 0x00000413u, 0x0004003du, 0x00000006u, 0x00000415u, 0x000003b0u, 0x0004003du, + 0x00000006u, 0x00000416u, 0x0000040cu, 0x00050080u, 0x00000006u, 0x00000417u, 0x00000415u, 0x00000416u, + 0x0003003eu, 0x00000414u, 0x00000417u, 0x0004003du, 0x00000006u, 0x0000041au, 0x00000414u, 0x00050041u, + 0x00000418u, 0x0000041cu, 0x0000041bu, 0x0000041au, 0x0004003du, 0x000003beu, 0x0000041du, 0x0000041cu, + 0x0003003eu, 0x00000419u, 0x0000041du, 0x00050041u, 0x0000038du, 0x0000041eu, 0x0000038cu, 0x000000deu, + 0x0004003du, 0x00000006u, 0x0000041fu, 0x0000041eu, 0x00050041u, 0x0000001bu, 0x00000420u, 0x00000419u, + 0x00000089u, 0x0004003du, 0x00000006u, 0x00000421u, 0x00000420u, 0x000500c4u, 0x00000006u, 0x00000422u, + 0x00000008u, 0x00000421u, 0x00050041u, 0x0000001bu, 0x00000423u, 0x00000419u, 0x00000008u, 0x0004003du, + 0x00000006u, 0x00000424u, 0x00000423u, 0x000500c4u, 0x00000006u, 0x00000425u, 0x00000008u, 0x00000424u, + 0x000500c5u, 0x00000006u, 0x00000426u, 0x00000422u, 0x00000425u, 0x000500c7u, 0x00000006u, 0x00000427u, + 0x0000041fu, 0x00000426u, 0x000500aau, 0x00000042u, 0x00000428u, 0x00000427u, 0x00000089u, 0x000300f7u, + 0x0000042au, 0x00000000u, 0x000400fau, 0x00000428u, 0x00000429u, 0x0000042au, 0x000200f8u, 0x00000429u, + 0x0004003du, 0x00000006u, 0x0000042cu, 0x00000402u, 0x00050084u, 0x00000006u, 0x0000042du, 0x0000042cu, + 0x0000017au, 0x0003003eu, 0x0000042bu, 0x0000042du, 0x0004003du, 0x00000006u, 0x00000433u, 0x0000042bu, + 0x00060041u, 0x00000434u, 0x00000435u, 0x00000432u, 0x00000433u, 0x0000005fu, 0x0003003eu, 0x00000435u, + 0x00000076u, 0x0004003du, 0x00000006u, 0x00000436u, 0x0000042bu, 0x00050080u, 0x00000006u, 0x00000437u, + 0x00000436u, 0x00000008u, 0x00060041u, 0x00000434u, 0x00000438u, 0x00000432u, 0x00000437u, 0x0000005fu, + 0x0003003eu, 0x00000438u, 0x00000076u, 0x0004003du, 0x00000006u, 0x00000439u, 0x0000042bu, 0x00050080u, + 0x00000006u, 0x0000043au, 0x00000439u, 0x0000006bu, 0x00060041u, 0x00000434u, 0x0000043bu, 0x00000432u, + 0x0000043au, 0x0000005fu, 0x0003003eu, 0x0000043bu, 0x00000076u, 0x0004003du, 0x00000006u, 0x0000043cu, + 0x0000042bu, 0x00050080u, 0x00000006u, 0x0000043du, 0x0000043cu, 0x00000160u, 0x00060041u, 0x00000434u, + 0x0000043eu, 0x00000432u, 0x0000043du, 0x0000005fu, 0x0003003eu, 0x0000043eu, 0x00000076u, 0x000200f9u, + 0x00000407u, 0x000200f8u, 0x0000042au, 0x0004003du, 0x00000006u, 0x0000044bu, 0x00000414u, 0x00050041u, + 0x00000418u, 0x0000044du, 0x0000044cu, 0x0000044bu, 0x0004003du, 0x000003beu, 0x0000044eu, 0x0000044du, + 0x0003003eu, 0x00000440u, 0x0000044eu, 0x00050041u, 0x0000001bu, 0x0000045bu, 0x00000440u, 0x00000089u, + 0x0004003du, 0x00000006u, 0x0000045cu, 0x0000045bu, 0x00050041u, 0x0000000eu, 0x0000045fu, 0x0000045eu, + 0x0000045cu, 0x0004003du, 0x0000000du, 0x00000460u, 0x0000045fu, 0x00050041u, 0x00000461u, 0x00000462u, + 0x0000038cu, 0x0000009au, 0x0004003du, 0x0000000du, 0x00000463u, 0x00000462u, 0x00050085u, 0x0000000du, + 0x00000464u, 0x00000460u, 0x00000463u, 0x0003003eu, 0x0000044fu, 0x00000464u, 0x00050041u, 0x0000001bu, + 0x00000466u, 0x00000440u, 0x00000008u, 0x0004003du, 0x00000006u, 0x00000467u, 0x00000466u, 0x00050041u, + 0x0000000eu, 0x00000469u, 0x00000468u, 0x00000467u, 0x0004003du, 0x0000000du, 0x0000046au, 0x00000469u, + 0x00050041u, 0x00000461u, 0x0000046bu, 0x0000038cu, 0x0000009au, 0x0004003du, 0x0000000du, 0x0000046cu, + 0x0000046bu, 0x00050085u, 0x0000000du, 0x0000046du, 0x0000046au, 0x0000046cu, 0x0003003eu, 0x00000465u, + 0x0000046du, 0x00050041u, 0x0000046fu, 0x00000470u, 0x0000038cu, 0x0000008eu, 0x0004003du, 0x00000010u, + 0x00000471u, 0x00000470u, 0x0004003du, 0x0000000du, 0x00000472u, 0x0000044fu, 0x00050051u, 0x00000009u, + 0x00000473u, 0x00000472u, 0x00000000u, 0x00050051u, 0x00000009u, 0x00000474u, 0x00000472u, 0x00000001u, + 0x00050051u, 0x00000009u, 0x00000475u, 0x00000472u, 0x00000002u, 0x00070050u, 0x0000000fu, 0x00000476u, + 0x00000473u, 0x00000474u, 0x00000475u, 0x0000004au, 0x00050091u, 0x0000000fu, 0x00000477u, 0x00000471u, + 0x00000476u, 0x0008004fu, 0x0000000du, 0x00000478u, 0x00000477u, 0x00000477u, 0x00000000u, 0x00000001u, + 0x00000002u, 0x0003003eu, 0x0000046eu, 0x00000478u, 0x00050041u, 0x0000046fu, 0x0000047au, 0x0000038cu, + 0x0000008eu, 0x0004003du, 0x00000010u, 0x0000047bu, 0x0000047au, 0x0004003du, 0x0000000du, 0x0000047cu, + 0x00000465u, 0x00050051u, 0x00000009u, 0x0000047du, 0x0000047cu, 0x00000000u, 0x00050051u, 0x00000009u, + 0x0000047eu, 0x0000047cu, 0x00000001u, 0x00050051u, 0x00000009u, 0x0000047fu, 0x0000047cu, 0x00000002u, + 0x00070050u, 0x0000000fu, 0x00000480u, 0x0000047du, 0x0000047eu, 0x0000047fu, 0x0000004au, 0x00050091u, + 0x0000000fu, 0x00000481u, 0x0000047bu, 0x00000480u, 0x0008004fu, 0x0000000du, 0x00000482u, 0x00000481u, + 0x00000481u, 0x00000000u, 0x00000001u, 0x00000002u, 0x0003003eu, 0x00000479u, 0x00000482u, 0x0004003du, + 0x00000006u, 0x00000484u, 0x00000410u, 0x00040070u, 0x00000009u, 0x00000485u, 0x00000484u, 0x0004003du, + 0x00000006u, 0x00000486u, 0x000003f4u, 0x00040070u, 0x00000009u, 0x00000487u, 0x00000486u, 0x00050088u, + 0x00000009u, 0x00000488u, 0x00000485u, 0x00000487u, 0x0003003eu, 0x00000483u, 0x00000488u, 0x0004003du, + 0x00000006u, 0x0000048au, 0x00000410u, 0x00050080u, 0x00000006u, 0x0000048bu, 0x0000048au, 0x00000008u, + 0x00040070u, 0x00000009u, 0x0000048cu, 0x0000048bu, 0x0004003du, 0x00000006u, 0x0000048du, 0x000003f4u, + 0x00040070u, 0x00000009u, 0x0000048eu, 0x0000048du, 0x00050088u, 0x00000009u, 0x0000048fu, 0x0000048cu, + 0x0000048eu, 0x0003003eu, 0x00000489u, 0x0000048fu, 0x0004003du, 0x0000000du, 0x00000491u, 0x0000046eu, + 0x0004003du, 0x0000000du, 0x00000492u, 0x00000479u, 0x0004003du, 0x00000009u, 0x00000493u, 0x00000483u, + 0x00060050u, 0x0000000du, 0x00000494u, 0x00000493u, 0x00000493u, 0x00000493u, 0x0008000cu, 0x0000000du, + 0x00000495u, 0x00000001u, 0x0000002eu, 0x00000491u, 0x00000492u, 0x00000494u, 0x0003003eu, 0x00000490u, + 0x00000495u, 0x0004003du, 0x0000000du, 0x00000497u, 0x0000046eu, 0x0004003du, 0x0000000du, 0x00000498u, + 0x00000479u, 0x0004003du, 0x00000009u, 0x00000499u, 0x00000489u, 0x00060050u, 0x0000000du, 0x0000049au, + 0x00000499u, 0x00000499u, 0x00000499u, 0x0008000cu, 0x0000000du, 0x0000049bu, 0x00000001u, 0x0000002eu, + 0x00000497u, 0x00000498u, 0x0000049au, 0x0003003eu, 0x00000496u, 0x0000049bu, 0x0004003du, 0x0000000du, + 0x0000049fu, 0x00000490u, 0x0003003eu, 0x0000049eu, 0x0000049fu, 0x0004003du, 0x00000011u, 0x000004a1u, + 0x000003a0u, 0x0003003eu, 0x000004a0u, 0x000004a1u, 0x0004003du, 0x00000013u, 0x000004a3u, 0x00000394u, + 0x0003003eu, 0x000004a2u, 0x000004a3u, 0x00070039u, 0x0000000fu, 0x000004a4u, 0x00000019u, 0x0000049eu, + 0x000004a0u, 0x000004a2u, 0x0003003eu, 0x0000049du, 0x000004a4u, 0x0004003du, 0x0000000du, 0x000004a7u, + 0x00000496u, 0x0003003eu, 0x000004a6u, 0x000004a7u, 0x0004003du, 0x00000011u, 0x000004a9u, 0x000003a0u, + 0x0003003eu, 0x000004a8u, 0x000004a9u, 0x0004003du, 0x00000013u, 0x000004abu, 0x00000394u, 0x0003003eu, + 0x000004aau, 0x000004abu, 0x00070039u, 0x0000000fu, 0x000004acu, 0x00000019u, 0x000004a6u, 0x000004a8u, + 0x000004aau, 0x0003003eu, 0x000004a5u, 0x000004acu, 0x0004003du, 0x0000000fu, 0x000004aeu, 0x0000049du, + 0x0007004fu, 0x00000023u, 0x000004afu, 0x000004aeu, 0x000004aeu, 0x00000000u, 0x00000001u, 0x00050041u, + 0x00000037u, 0x000004b0u, 0x0000049du, 0x00000160u, 0x0004003du, 0x00000009u, 0x000004b1u, 0x000004b0u, + 0x00050050u, 0x00000023u, 0x000004b2u, 0x000004b1u, 0x000004b1u, 0x00050088u, 0x00000023u, 0x000004b3u, + 0x000004afu, 0x000004b2u, 0x0003003eu, 0x000004adu, 0x000004b3u, 0x0004003du, 0x0000000fu, 0x000004b5u, + 0x000004a5u, 0x0007004fu, 0x00000023u, 0x000004b6u, 0x000004b5u, 0x000004b5u, 0x00000000u, 0x00000001u, + 0x00050041u, 0x00000037u, 0x000004b7u, 0x000004a5u, 0x00000160u, 0x0004003du, 0x00000009u, 0x000004b8u, + 0x000004b7u, 0x00050050u, 0x00000023u, 0x000004b9u, 0x000004b8u, 0x000004b8u, 0x00050088u, 0x00000023u, + 0x000004bau, 0x000004b6u, 0x000004b9u, 0x0003003eu, 0x000004b4u, 0x000004bau, 0x0004003du, 0x00000023u, + 0x000004bcu, 0x000004b4u, 0x0004003du, 0x00000023u, 0x000004bdu, 0x000004adu, 0x00050083u, 0x00000023u, + 0x000004beu, 0x000004bcu, 0x000004bdu, 0x0006000cu, 0x00000023u, 0x000004bfu, 0x00000001u, 0x00000045u, + 0x000004beu, 0x0003003eu, 0x000004bbu, 0x000004bfu, 0x00050041u, 0x00000037u, 0x000004c1u, 0x000004bbu, + 0x00000008u, 0x0004003du, 0x00000009u, 0x000004c2u, 0x000004c1u, 0x0004007fu, 0x00000009u, 0x000004c3u, + 0x000004c2u, 0x00050041u, 0x00000037u, 0x000004c4u, 0x000004bbu, 0x00000089u, 0x0004003du, 0x00000009u, + 0x000004c5u, 0x000004c4u, 0x00050050u, 0x00000023u, 0x000004c6u, 0x000004c3u, 0x000004c5u, 0x0003003eu, + 0x000004c0u, 0x000004c6u, 0x0004003du, 0x00000023u, 0x000004c8u, 0x000004c0u, 0x0004003du, 0x00000009u, + 0x000004c9u, 0x000003b4u, 0x0005008eu, 0x00000023u, 0x000004cau, 0x000004c8u, 0x000004c9u, 0x00050041u, + 0x00000037u, 0x000004cbu, 0x00000394u, 0x0000008eu, 0x0004003du, 0x00000009u, 0x000004ccu, 0x000004cbu, + 0x00050041u, 0x00000037u, 0x000004cdu, 0x00000394u, 0x0000009au, 0x0004003du, 0x00000009u, 0x000004ceu, + 0x000004cdu, 0x00050050u, 0x00000023u, 0x000004cfu, 0x000004ccu, 0x000004ceu, 0x00050088u, 0x00000023u, + 0x000004d0u, 0x000004cau, 0x000004cfu, 0x0003003eu, 0x000004c7u, 0x000004d0u, 0x0004003du, 0x00000006u, + 0x000004d2u, 0x00000402u, 0x00050084u, 0x00000006u, 0x000004d3u, 0x000004d2u, 0x0000017au, 0x0003003eu, + 0x000004d1u, 0x000004d3u, 0x0004003du, 0x00000023u, 0x000004d5u, 0x000004c7u, 0x00050041u, 0x00000037u, + 0x000004d6u, 0x0000049du, 0x00000160u, 0x0004003du, 0x00000009u, 0x000004d7u, 0x000004d6u, 0x0005008eu, + 0x00000023u, 0x000004d8u, 0x000004d5u, 0x000004d7u, 0x00050051u, 0x00000009u, 0x000004d9u, 0x000004d8u, + 0x00000000u, 0x00050051u, 0x00000009u, 0x000004dau, 0x000004d8u, 0x00000001u, 0x00070050u, 0x0000000fu, + 0x000004dbu, 0x000004d9u, 0x000004dau, 0x00000041u, 0x00000041u, 0x0003003eu, 0x000004d4u, 0x000004dbu, + 0x0004003du, 0x00000023u, 0x000004ddu, 0x000004c7u, 0x00050041u, 0x00000037u, 0x000004deu, 0x000004a5u, + 0x00000160u, 0x0004003du, 0x00000009u, 0x000004dfu, 0x000004deu, 0x0005008eu, 0x00000023u, 0x000004e0u, + 0x000004ddu, 0x000004dfu, 0x00050051u, 0x00000009u, 0x000004e1u, 0x000004e0u, 0x00000000u, 0x00050051u, + 0x00000009u, 0x000004e2u, 0x000004e0u, 0x00000001u, 0x00070050u, 0x0000000fu, 0x000004e3u, 0x000004e1u, + 0x000004e2u, 0x00000041u, 0x00000041u, 0x0003003eu, 0x000004dcu, 0x000004e3u, 0x00050041u, 0x00000037u, + 0x000004e6u, 0x0000049du, 0x00000160u, 0x0004003du, 0x00000009u, 0x000004e7u, 0x000004e6u, 0x00050085u, + 0x00000009u, 0x000004e8u, 0x000004e5u, 0x000004e7u, 0x0003003eu, 0x000004e4u, 0x000004e8u, 0x00050041u, + 0x00000037u, 0x000004eau, 0x000004a5u, 0x00000160u, 0x0004003du, 0x00000009u, 0x000004ebu, 0x000004eau, + 0x00050085u, 0x00000009u, 0x000004ecu, 0x000004e5u, 0x000004ebu, 0x0003003eu, 0x000004e9u, 0x000004ecu, + 0x0004003du, 0x0000000fu, 0x000004eeu, 0x0000049du, 0x0004003du, 0x0000000fu, 0x000004efu, 0x000004d4u, + 0x00050083u, 0x0000000fu, 0x000004f0u, 0x000004eeu, 0x000004efu, 0x0003003eu, 0x000004edu, 0x000004f0u, + 0x0004003du, 0x00000009u, 0x000004f1u, 0x000004e4u, 0x00050041u, 0x00000037u, 0x000004f2u, 0x000004edu, + 0x0000006bu, 0x0004003du, 0x00000009u, 0x000004f3u, 0x000004f2u, 0x00050081u, 0x00000009u, 0x000004f4u, + 0x000004f3u, 0x000004f1u, 0x00050041u, 0x00000037u, 0x000004f5u, 0x000004edu, 0x0000006bu, 0x0003003eu, + 0x000004f5u, 0x000004f4u, 0x0004003du, 0x0000000fu, 0x000004f7u, 0x0000049du, 0x0004003du, 0x0000000fu, + 0x000004f8u, 0x000004d4u, 0x00050081u, 0x0000000fu, 0x000004f9u, 0x000004f7u, 0x000004f8u, 0x0003003eu, + 0x000004f6u, 0x000004f9u, 0x0004003du, 0x00000009u, 0x000004fau, 0x000004e4u, 0x00050041u, 0x00000037u, + 0x000004fbu, 0x000004f6u, 0x0000006bu, 0x0004003du, 0x00000009u, 0x000004fcu, 0x000004fbu, 0x00050081u, + 0x00000009u, 0x000004fdu, 0x000004fcu, 0x000004fau, 0x00050041u, 0x00000037u, 0x000004feu, 0x000004f6u, + 0x0000006bu, 0x0003003eu, 0x000004feu, 0x000004fdu, 0x0004003du, 0x0000000fu, 0x00000500u, 0x000004a5u, + 0x0004003du, 0x0000000fu, 0x00000501u, 0x000004dcu, 0x00050081u, 0x0000000fu, 0x00000502u, 0x00000500u, + 0x00000501u, 0x0003003eu, 0x000004ffu, 0x00000502u, 0x0004003du, 0x00000009u, 0x00000503u, 0x000004e9u, + 0x00050041u, 0x00000037u, 0x00000504u, 0x000004ffu, 0x0000006bu, 0x0004003du, 0x00000009u, 0x00000505u, + 0x00000504u, 0x00050081u, 0x00000009u, 0x00000506u, 0x00000505u, 0x00000503u, 0x00050041u, 0x00000037u, + 0x00000507u, 0x000004ffu, 0x0000006bu, 0x0003003eu, 0x00000507u, 0x00000506u, 0x0004003du, 0x0000000fu, + 0x00000509u, 0x000004a5u, 0x0004003du, 0x0000000fu, 0x0000050au, 0x000004dcu, 0x00050083u, 0x0000000fu, + 0x0000050bu, 0x00000509u, 0x0000050au, 0x0003003eu, 0x00000508u, 0x0000050bu, 0x0004003du, 0x00000009u, + 0x0000050cu, 0x000004e9u, 0x00050041u, 0x00000037u, 0x0000050du, 0x00000508u, 0x0000006bu, 0x0004003du, + 0x00000009u, 0x0000050eu, 0x0000050du, 0x00050081u, 0x00000009u, 0x0000050fu, 0x0000050eu, 0x0000050cu, + 0x00050041u, 0x00000037u, 0x00000510u, 0x00000508u, 0x0000006bu, 0x0003003eu, 0x00000510u, 0x0000050fu, + 0x0004003du, 0x00000006u, 0x00000511u, 0x000004d1u, 0x00050080u, 0x00000006u, 0x00000512u, 0x00000511u, + 0x00000089u, 0x0004003du, 0x0000000fu, 0x00000513u, 0x000004edu, 0x00060041u, 0x00000434u, 0x00000514u, + 0x00000432u, 0x00000512u, 0x0000005fu, 0x0003003eu, 0x00000514u, 0x00000513u, 0x0004003du, 0x00000006u, + 0x00000515u, 0x000004d1u, 0x00050080u, 0x00000006u, 0x00000516u, 0x00000515u, 0x00000008u, 0x0004003du, + 0x0000000fu, 0x00000517u, 0x000004f6u, 0x00060041u, 0x00000434u, 0x00000518u, 0x00000432u, 0x00000516u, + 0x0000005fu, 0x0003003eu, 0x00000518u, 0x00000517u, 0x0004003du, 0x00000006u, 0x00000519u, 0x000004d1u, + 0x00050080u, 0x00000006u, 0x0000051au, 0x00000519u, 0x0000006bu, 0x0004003du, 0x0000000fu, 0x0000051bu, + 0x000004ffu, 0x00060041u, 0x00000434u, 0x0000051cu, 0x00000432u, 0x0000051au, 0x0000005fu, 0x0003003eu, + 0x0000051cu, 0x0000051bu, 0x0004003du, 0x00000006u, 0x0000051du, 0x000004d1u, 0x00050080u, 0x00000006u, + 0x0000051eu, 0x0000051du, 0x00000160u, 0x0004003du, 0x0000000fu, 0x0000051fu, 0x00000508u, 0x00060041u, + 0x00000434u, 0x00000520u, 0x00000432u, 0x0000051eu, 0x0000005fu, 0x0003003eu, 0x00000520u, 0x0000051fu, + 0x000200f9u, 0x00000407u, 0x000200f8u, 0x00000407u, 0x0004003du, 0x00000006u, 0x00000521u, 0x00000402u, + 0x00050080u, 0x00000006u, 0x00000522u, 0x00000521u, 0x00000007u, 0x0003003eu, 0x00000402u, 0x00000522u, + 0x000200f9u, 0x00000404u, 0x000200f8u, 0x00000406u, 0x000400e0u, 0x0000006bu, 0x0000006bu, 0x00000523u, + 0x0004003du, 0x00000006u, 0x00000525u, 0x0000037du, 0x0003003eu, 0x00000524u, 0x00000525u, 0x000200f9u, + 0x00000526u, 0x000200f8u, 0x00000526u, 0x000400f6u, 0x00000528u, 0x00000529u, 0x00000000u, 0x000200f9u, + 0x0000052au, 0x000200f8u, 0x0000052au, 0x0004003du, 0x00000006u, 0x0000052bu, 0x00000524u, 0x0004003du, + 0x00000006u, 0x0000052cu, 0x000003f8u, 0x000500b0u, 0x00000042u, 0x0000052du, 0x0000052bu, 0x0000052cu, + 0x000400fau, 0x0000052du, 0x00000527u, 0x00000528u, 0x000200f8u, 0x00000527u, 0x0004003du, 0x00000006u, + 0x0000052fu, 0x00000524u, 0x00050084u, 0x00000006u, 0x00000530u, 0x0000052fu, 0x0000017au, 0x0003003eu, + 0x0000052eu, 0x00000530u, 0x0004003du, 0x00000006u, 0x00000532u, 0x00000524u, 0x00050084u, 0x00000006u, + 0x00000533u, 0x00000532u, 0x0000006bu, 0x0003003eu, 0x00000531u, 0x00000533u, 0x0004003du, 0x00000006u, + 0x00000538u, 0x00000531u, 0x00050080u, 0x00000006u, 0x00000539u, 0x00000538u, 0x00000089u, 0x0004003du, + 0x00000006u, 0x0000053au, 0x0000052eu, 0x00050080u, 0x00000006u, 0x0000053bu, 0x0000053au, 0x00000089u, + 0x0004003du, 0x00000006u, 0x0000053cu, 0x0000052eu, 0x00050080u, 0x00000006u, 0x0000053du, 0x0000053cu, + 0x00000008u, 0x0004003du, 0x00000006u, 0x0000053eu, 0x0000052eu, 0x00050080u, 0x00000006u, 0x0000053fu, + 0x0000053eu, 0x0000006bu, 0x00060050u, 0x00000031u, 0x00000540u, 0x0000053bu, 0x0000053du, 0x0000053fu, + 0x00050041u, 0x00000541u, 0x00000542u, 0x00000537u, 0x00000539u, 0x0003003eu, 0x00000542u, 0x00000540u, + 0x0004003du, 0x00000006u, 0x00000547u, 0x00000531u, 0x00050080u, 0x00000006u, 0x00000548u, 0x00000547u, + 0x00000089u, 0x00050041u, 0x0000038du, 0x00000549u, 0x0000038cu, 0x0000005fu, 0x0004003du, 0x00000006u, + 0x0000054au, 0x00000549u, 0x0004007cu, 0x00000039u, 0x0000054bu, 0x0000054au, 0x00060041u, 0x0000054cu, + 0x0000054du, 0x00000546u, 0x00000548u, 0x0000005fu, 0x0003003eu, 0x0000054du, 0x0000054bu, 0x0004003du, + 0x00000006u, 0x00000552u, 0x00000531u, 0x00050080u, 0x00000006u, 0x00000553u, 0x00000552u, 0x00000089u, + 0x00060041u, 0x00000554u, 0x00000555u, 0x00000551u, 0x00000553u, 0x0000005fu, 0x0003003eu, 0x00000555u, + 0x00000458u, 0x0004003du, 0x00000006u, 0x00000556u, 0x00000531u, 0x00050080u, 0x00000006u, 0x00000557u, + 0x00000556u, 0x00000089u, 0x00060041u, 0x00000554u, 0x0000055au, 0x00000551u, 0x00000557u, 0x00000127u, + 0x0003003eu, 0x0000055au, 0x00000559u, 0x0004003du, 0x00000006u, 0x0000055bu, 0x00000531u, 0x00050080u, + 0x00000006u, 0x0000055cu, 0x0000055bu, 0x00000089u, 0x00060041u, 0x00000554u, 0x0000055du, 0x00000551u, + 0x0000055cu, 0x0000008eu, 0x0003003eu, 0x0000055du, 0x00000559u, 0x0004003du, 0x00000006u, 0x0000055eu, + 0x00000531u, 0x00050080u, 0x00000006u, 0x0000055fu, 0x0000055eu, 0x00000089u, 0x00050041u, 0x00000560u, + 0x00000561u, 0x0000038cu, 0x000000d8u, 0x0004003du, 0x00000009u, 0x00000562u, 0x00000561u, 0x00060041u, + 0x00000563u, 0x00000564u, 0x00000551u, 0x0000055fu, 0x0000009au, 0x0003003eu, 0x00000564u, 0x00000562u, + 0x0004003du, 0x00000006u, 0x00000565u, 0x00000531u, 0x00050080u, 0x00000006u, 0x00000566u, 0x00000565u, + 0x00000008u, 0x0004003du, 0x00000006u, 0x00000567u, 0x0000052eu, 0x00050080u, 0x00000006u, 0x00000568u, + 0x00000567u, 0x00000089u, 0x0004003du, 0x00000006u, 0x00000569u, 0x0000052eu, 0x00050080u, 0x00000006u, + 0x0000056au, 0x00000569u, 0x0000006bu, 0x0004003du, 0x00000006u, 0x0000056bu, 0x0000052eu, 0x00050080u, + 0x00000006u, 0x0000056cu, 0x0000056bu, 0x00000160u, 0x00060050u, 0x00000031u, 0x0000056du, 0x00000568u, + 0x0000056au, 0x0000056cu, 0x00050041u, 0x00000541u, 0x0000056eu, 0x00000537u, 0x00000566u, 0x0003003eu, + 0x0000056eu, 0x0000056du, 0x0004003du, 0x00000006u, 0x0000056fu, 0x00000531u, 0x00050080u, 0x00000006u, + 0x00000570u, 0x0000056fu, 0x00000008u, 0x00050041u, 0x0000038du, 0x00000571u, 0x0000038cu, 0x0000005fu, + 0x0004003du, 0x00000006u, 0x00000572u, 0x00000571u, 0x0004007cu, 0x00000039u, 0x00000573u, 0x00000572u, + 0x00060041u, 0x0000054cu, 0x00000574u, 0x00000546u, 0x00000570u, 0x0000005fu, 0x0003003eu, 0x00000574u, + 0x00000573u, 0x0004003du, 0x00000006u, 0x00000575u, 0x00000531u, 0x00050080u, 0x00000006u, 0x00000576u, + 0x00000575u, 0x00000008u, 0x00060041u, 0x00000554u, 0x00000577u, 0x00000551u, 0x00000576u, 0x0000005fu, + 0x0003003eu, 0x00000577u, 0x00000458u, 0x0004003du, 0x00000006u, 0x00000578u, 0x00000531u, 0x00050080u, + 0x00000006u, 0x00000579u, 0x00000578u, 0x00000008u, 0x00060041u, 0x00000554u, 0x0000057au, 0x00000551u, + 0x00000579u, 0x00000127u, 0x0003003eu, 0x0000057au, 0x00000559u, 0x0004003du, 0x00000006u, 0x0000057bu, + 0x00000531u, 0x00050080u, 0x00000006u, 0x0000057cu, 0x0000057bu, 0x00000008u, 0x00060041u, 0x00000554u, + 0x0000057du, 0x00000551u, 0x0000057cu, 0x0000008eu, 0x0003003eu, 0x0000057du, 0x00000559u, 0x0004003du, + 0x00000006u, 0x0000057eu, 0x00000531u, 0x00050080u, 0x00000006u, 0x0000057fu, 0x0000057eu, 0x00000008u, + 0x00050041u, 0x00000560u, 0x00000580u, 0x0000038cu, 0x000000d8u, 0x0004003du, 0x00000009u, 0x00000581u, + 0x00000580u, 0x00060041u, 0x00000563u, 0x00000582u, 0x00000551u, 0x0000057fu, 0x0000009au, 0x0003003eu, + 0x00000582u, 0x00000581u, 0x000200f9u, 0x00000529u, 0x000200f8u, 0x00000529u, 0x0004003du, 0x00000006u, + 0x00000583u, 0x00000524u, 0x00050080u, 0x00000006u, 0x00000584u, 0x00000583u, 0x00000007u, 0x0003003eu, + 0x00000524u, 0x00000584u, 0x000200f9u, 0x00000526u, 0x000200f8u, 0x00000528u, 0x000100fdu, 0x000200f8u, + 0x000003afu, 0x0004003du, 0x00000006u, 0x00000587u, 0x00000377u, 0x0003003eu, 0x00000586u, 0x00000587u, + 0x00050041u, 0x0000038du, 0x00000589u, 0x0000038cu, 0x000000ccu, 0x0004003du, 0x00000006u, 0x0000058au, + 0x00000589u, 0x0003003eu, 0x00000588u, 0x0000058au, 0x00050041u, 0x0000038du, 0x0000058bu, 0x0000038cu, + 0x000000deu, 0x0004003du, 0x00000006u, 0x0000058cu, 0x0000058bu, 0x0004003du, 0x00000006u, 0x0000058du, + 0x00000586u, 0x000500c4u, 0x00000006u, 0x0000058eu, 0x00000008u, 0x0000058du, 0x000500c7u, 0x00000006u, + 0x0000058fu, 0x0000058cu, 0x0000058eu, 0x000500aau, 0x00000042u, 0x00000590u, 0x0000058fu, 0x00000089u, + 0x000300f7u, 0x00000592u, 0x00000000u, 0x000400fau, 0x00000590u, 0x00000591u, 0x00000592u, 0x000200f8u, + 0x00000591u, 0x0003003eu, 0x00000376u, 0x00000089u, 0x0004003du, 0x00000006u, 0x00000593u, 0x00000376u, + 0x000314afu, 0x00000089u, 0x00000593u, 0x000100fdu, 0x000200f8u, 0x00000592u, 0x0004003du, 0x00000006u, + 0x000005a0u, 0x00000586u, 0x00050041u, 0x00000596u, 0x000005a3u, 0x000005a2u, 0x000005a0u, 0x0004003du, + 0x00000595u, 0x000005a4u, 0x000005a3u, 0x0003003eu, 0x00000597u, 0x000005a4u, 0x0003003eu, 0x000005a5u, + 0x00000089u, 0x000200f9u, 0x000005a6u, 0x000200f8u, 0x000005a6u, 0x000400f6u, 0x000005a8u, 0x000005a9u, + 0x00000000u, 0x000200f9u, 0x000005aau, 0x000200f8u, 0x000005aau, 0x0004003du, 0x00000006u, 0x000005abu, + 0x000005a5u, 0x000500b0u, 0x00000042u, 0x000005acu, 0x000005abu, 0x0000017au, 0x000400fau, 0x000005acu, + 0x000005a7u, 0x000005a8u, 0x000200f8u, 0x000005a7u, 0x0004003du, 0x00000006u, 0x000005aeu, 0x000005a5u, + 0x000500aau, 0x00000042u, 0x000005afu, 0x000005aeu, 0x00000089u, 0x000300f7u, 0x000005b2u, 0x00000000u, + 0x000400fau, 0x000005afu, 0x000005b1u, 0x000005b5u, 0x000200f8u, 0x000005b1u, 0x00050041u, 0x0000001bu, + 0x000005b3u, 0x00000597u, 0x00000089u, 0x0004003du, 0x00000006u, 0x000005b4u, 0x000005b3u, 0x0003003eu, + 0x000005b0u, 0x000005b4u, 0x000200f9u, 0x000005b2u, 0x000200f8u, 0x000005b5u, 0x0004003du, 0x00000006u, + 0x000005b6u, 0x000005a5u, 0x000500aau, 0x00000042u, 0x000005b7u, 0x000005b6u, 0x00000008u, 0x000300f7u, + 0x000005bau, 0x00000000u, 0x000400fau, 0x000005b7u, 0x000005b9u, 0x000005bdu, 0x000200f8u, 0x000005b9u, + 0x00050041u, 0x0000001bu, 0x000005bbu, 0x00000597u, 0x00000008u, 0x0004003du, 0x00000006u, 0x000005bcu, + 0x000005bbu, 0x0003003eu, 0x000005b8u, 0x000005bcu, 0x000200f9u, 0x000005bau, 0x000200f8u, 0x000005bdu, + 0x0004003du, 0x00000006u, 0x000005beu, 0x000005a5u, 0x000500aau, 0x00000042u, 0x000005bfu, 0x000005beu, + 0x0000006bu, 0x000300f7u, 0x000005c2u, 0x00000000u, 0x000400fau, 0x000005bfu, 0x000005c1u, 0x000005c5u, + 0x000200f8u, 0x000005c1u, 0x00050041u, 0x0000001bu, 0x000005c3u, 0x00000597u, 0x0000006bu, 0x0004003du, + 0x00000006u, 0x000005c4u, 0x000005c3u, 0x0003003eu, 0x000005c0u, 0x000005c4u, 0x000200f9u, 0x000005c2u, + 0x000200f8u, 0x000005c5u, 0x00050041u, 0x0000001bu, 0x000005c6u, 0x00000597u, 0x00000160u, 0x0004003du, + 0x00000006u, 0x000005c7u, 0x000005c6u, 0x0003003eu, 0x000005c0u, 0x000005c7u, 0x000200f9u, 0x000005c2u, + 0x000200f8u, 0x000005c2u, 0x0004003du, 0x00000006u, 0x000005c8u, 0x000005c0u, 0x0003003eu, 0x000005b8u, + 0x000005c8u, 0x000200f9u, 0x000005bau, 0x000200f8u, 0x000005bau, 0x0004003du, 0x00000006u, 0x000005c9u, + 0x000005b8u, 0x0003003eu, 0x000005b0u, 0x000005c9u, 0x000200f9u, 0x000005b2u, 0x000200f8u, 0x000005b2u, + 0x0004003du, 0x00000006u, 0x000005cau, 0x000005b0u, 0x0003003eu, 0x000005adu, 0x000005cau, 0x0004003du, + 0x00000006u, 0x000005ccu, 0x000005adu, 0x00050041u, 0x0000000eu, 0x000005ceu, 0x000005cdu, 0x000005ccu, + 0x0004003du, 0x0000000du, 0x000005cfu, 0x000005ceu, 0x0003003eu, 0x000005cbu, 0x000005cfu, 0x0004003du, + 0x00000006u, 0x000005d3u, 0x000005a5u, 0x00050041u, 0x00000037u, 0x000005d4u, 0x000005cbu, 0x00000089u, + 0x0004003du, 0x00000009u, 0x000005d5u, 0x000005d4u, 0x00050081u, 0x00000009u, 0x000005d6u, 0x000005d5u, + 0x00000091u, 0x00050041u, 0x00000037u, 0x000005d7u, 0x000005d2u, 0x000005d3u, 0x0003003eu, 0x000005d7u, + 0x000005d6u, 0x0004003du, 0x00000006u, 0x000005dbu, 0x000005a5u, 0x00050041u, 0x0000046fu, 0x000005dcu, + 0x0000038cu, 0x0000008eu, 0x0004003du, 0x00000010u, 0x000005ddu, 0x000005dcu, 0x0004003du, 0x0000000du, + 0x000005deu, 0x000005cbu, 0x00050041u, 0x00000461u, 0x000005dfu, 0x0000038cu, 0x0000009au, 0x0004003du, + 0x0000000du, 0x000005e0u, 0x000005dfu, 0x00050085u, 0x0000000du, 0x000005e1u, 0x000005deu, 0x000005e0u, + 0x00050051u, 0x00000009u, 0x000005e2u, 0x000005e1u, 0x00000000u, 0x00050051u, 0x00000009u, 0x000005e3u, + 0x000005e1u, 0x00000001u, 0x00050051u, 0x00000009u, 0x000005e4u, 0x000005e1u, 0x00000002u, 0x00070050u, + 0x0000000fu, 0x000005e5u, 0x000005e2u, 0x000005e3u, 0x000005e4u, 0x0000004au, 0x00050091u, 0x0000000fu, + 0x000005e6u, 0x000005ddu, 0x000005e5u, 0x0008004fu, 0x0000000du, 0x000005e7u, 0x000005e6u, 0x000005e6u, + 0x00000000u, 0x00000001u, 0x00000002u, 0x00050041u, 0x0000000eu, 0x000005e8u, 0x000005dau, 0x000005dbu, + 0x0003003eu, 0x000005e8u, 0x000005e7u, 0x000200f9u, 0x000005a9u, 0x000200f8u, 0x000005a9u, 0x0004003du, + 0x00000006u, 0x000005e9u, 0x000005a5u, 0x00050080u, 0x00000006u, 0x000005eau, 0x000005e9u, 0x00000127u, + 0x0003003eu, 0x000005a5u, 0x000005eau, 0x000200f9u, 0x000005a6u, 0x000200f8u, 0x000005a8u, 0x0004003du, + 0x00000006u, 0x000005edu, 0x00000588u, 0x0003003eu, 0x000005ecu, 0x000005edu, 0x00050039u, 0x00000006u, + 0x000005eeu, 0x0000001eu, 0x000005ecu, 0x0003003eu, 0x000005ebu, 0x000005eeu, 0x0004003du, 0x00000006u, + 0x000005f1u, 0x00000588u, 0x0003003eu, 0x000005f0u, 0x000005f1u, 0x00050039u, 0x00000006u, 0x000005f2u, + 0x00000021u, 0x000005f0u, 0x0003003eu, 0x000005efu, 0x000005f2u, 0x0004003du, 0x00000006u, 0x000005f4u, + 0x000005ebu, 0x00050084u, 0x00000006u, 0x000005f5u, 0x000005f4u, 0x0000006bu, 0x0003003eu, 0x000005f3u, + 0x000005f5u, 0x0004003du, 0x00000006u, 0x000005f7u, 0x000005efu, 0x00050084u, 0x00000006u, 0x000005f8u, + 0x000005f7u, 0x0000006bu, 0x0003003eu, 0x000005f6u, 0x000005f8u, 0x0004003du, 0x00000006u, 0x000005f9u, + 0x000005f6u, 0x0003003eu, 0x00000376u, 0x000005f9u, 0x0004003du, 0x00000006u, 0x000005fau, 0x000005f3u, + 0x0004003du, 0x00000006u, 0x000005fbu, 0x00000376u, 0x000314afu, 0x000005fau, 0x000005fbu, 0x00050041u, + 0x0000000eu, 0x000005ffu, 0x000005dau, 0x0000005fu, 0x0004003du, 0x0000000du, 0x00000600u, 0x000005ffu, + 0x00050041u, 0x0000000eu, 0x00000601u, 0x000005feu, 0x0000005fu, 0x0003003eu, 0x00000601u, 0x00000600u, + 0x00050041u, 0x0000000eu, 0x00000602u, 0x000005dau, 0x00000127u, 0x0004003du, 0x0000000du, 0x00000603u, + 0x00000602u, 0x00050041u, 0x0000000eu, 0x00000604u, 0x000005feu, 0x00000127u, 0x0003003eu, 0x00000604u, + 0x00000603u, 0x00050041u, 0x0000000eu, 0x00000605u, 0x000005dau, 0x0000008eu, 0x0004003du, 0x0000000du, + 0x00000606u, 0x00000605u, 0x00050041u, 0x0000000eu, 0x00000607u, 0x000005feu, 0x0000008eu, 0x0003003eu, + 0x00000607u, 0x00000606u, 0x00050041u, 0x0000000eu, 0x00000608u, 0x000005dau, 0x0000005fu, 0x0004003du, + 0x0000000du, 0x00000609u, 0x00000608u, 0x00050041u, 0x0000000eu, 0x0000060au, 0x000005feu, 0x0000009au, + 0x0003003eu, 0x0000060au, 0x00000609u, 0x00050041u, 0x0000000eu, 0x0000060bu, 0x000005dau, 0x0000008eu, + 0x0004003du, 0x0000000du, 0x0000060cu, 0x0000060bu, 0x00050041u, 0x0000000eu, 0x0000060du, 0x000005feu, + 0x0000004du, 0x0003003eu, 0x0000060du, 0x0000060cu, 0x00050041u, 0x0000000eu, 0x0000060eu, 0x000005dau, + 0x0000009au, 0x0004003du, 0x0000000du, 0x0000060fu, 0x0000060eu, 0x00050041u, 0x0000000eu, 0x00000610u, + 0x000005feu, 0x0000003du, 0x0003003eu, 0x00000610u, 0x0000060fu, 0x00050041u, 0x00000037u, 0x00000614u, + 0x000005d2u, 0x0000005fu, 0x0004003du, 0x00000009u, 0x00000615u, 0x00000614u, 0x00050041u, 0x00000037u, + 0x00000616u, 0x00000613u, 0x0000005fu, 0x0003003eu, 0x00000616u, 0x00000615u, 0x00050041u, 0x00000037u, + 0x00000617u, 0x000005d2u, 0x00000127u, 0x0004003du, 0x00000009u, 0x00000618u, 0x00000617u, 0x00050041u, + 0x00000037u, 0x00000619u, 0x00000613u, 0x00000127u, 0x0003003eu, 0x00000619u, 0x00000618u, 0x00050041u, + 0x00000037u, 0x0000061au, 0x000005d2u, 0x0000008eu, 0x0004003du, 0x00000009u, 0x0000061bu, 0x0000061au, + 0x00050041u, 0x00000037u, 0x0000061cu, 0x00000613u, 0x0000008eu, 0x0003003eu, 0x0000061cu, 0x0000061bu, + 0x00050041u, 0x00000037u, 0x0000061du, 0x000005d2u, 0x0000005fu, 0x0004003du, 0x00000009u, 0x0000061eu, + 0x0000061du, 0x00050041u, 0x00000037u, 0x0000061fu, 0x00000613u, 0x0000009au, 0x0003003eu, 0x0000061fu, + 0x0000061eu, 0x00050041u, 0x00000037u, 0x00000620u, 0x000005d2u, 0x0000008eu, 0x0004003du, 0x00000009u, + 0x00000621u, 0x00000620u, 0x00050041u, 0x00000037u, 0x00000622u, 0x00000613u, 0x0000004du, 0x0003003eu, + 0x00000622u, 0x00000621u, 0x00050041u, 0x00000037u, 0x00000623u, 0x000005d2u, 0x0000009au, 0x0004003du, + 0x00000009u, 0x00000624u, 0x00000623u, 0x00050041u, 0x00000037u, 0x00000625u, 0x00000613u, 0x0000003du, + 0x0003003eu, 0x00000625u, 0x00000624u, 0x0003003eu, 0x00000626u, 0x00000089u, 0x000200f9u, 0x00000627u, + 0x000200f8u, 0x00000627u, 0x000400f6u, 0x00000629u, 0x0000062au, 0x00000000u, 0x000200f9u, 0x0000062bu, + 0x000200f8u, 0x0000062bu, 0x0004003du, 0x00000006u, 0x0000062cu, 0x00000626u, 0x000500b0u, 0x00000042u, + 0x0000062du, 0x0000062cu, 0x0000006bu, 0x000400fau, 0x0000062du, 0x00000628u, 0x00000629u, 0x000200f8u, + 0x00000628u, 0x0004003du, 0x00000006u, 0x0000062fu, 0x00000626u, 0x00050084u, 0x00000006u, 0x00000630u, + 0x0000062fu, 0x00000160u, 0x00050041u, 0x0000000eu, 0x00000631u, 0x000005feu, 0x00000630u, 0x0004003du, + 0x0000000du, 0x00000632u, 0x00000631u, 0x0003003eu, 0x0000062eu, 0x00000632u, 0x0004003du, 0x00000006u, + 0x00000634u, 0x00000626u, 0x00050084u, 0x00000006u, 0x00000635u, 0x00000634u, 0x00000160u, 0x00050080u, + 0x00000006u, 0x00000636u, 0x00000635u, 0x00000008u, 0x00050041u, 0x0000000eu, 0x00000637u, 0x000005feu, + 0x00000636u, 0x0004003du, 0x0000000du, 0x00000638u, 0x00000637u, 0x0003003eu, 0x00000633u, 0x00000638u, + 0x0004003du, 0x00000006u, 0x0000063au, 0x00000626u, 0x00050084u, 0x00000006u, 0x0000063bu, 0x0000063au, + 0x00000160u, 0x00050080u, 0x00000006u, 0x0000063cu, 0x0000063bu, 0x0000006bu, 0x00050041u, 0x0000000eu, + 0x0000063du, 0x000005feu, 0x0000063cu, 0x0004003du, 0x0000000du, 0x0000063eu, 0x0000063du, 0x0003003eu, + 0x00000639u, 0x0000063eu, 0x0004003du, 0x00000006u, 0x00000640u, 0x00000626u, 0x0004003du, 0x00000006u, + 0x00000641u, 0x000005ebu, 0x00050084u, 0x00000006u, 0x00000642u, 0x00000640u, 0x00000641u, 0x0003003eu, + 0x0000063fu, 0x00000642u, 0x0004003du, 0x00000006u, 0x00000644u, 0x0000037du, 0x0003003eu, 0x00000643u, + 0x00000644u, 0x000200f9u, 0x00000645u, 0x000200f8u, 0x00000645u, 0x000400f6u, 0x00000647u, 0x00000648u, + 0x00000000u, 0x000200f9u, 0x00000649u, 0x000200f8u, 0x00000649u, 0x0004003du, 0x00000006u, 0x0000064au, + 0x00000643u, 0x0004003du, 0x00000006u, 0x0000064bu, 0x000005ebu, 0x000500b0u, 0x00000042u, 0x0000064cu, + 0x0000064au, 0x0000064bu, 0x000400fau, 0x0000064cu, 0x00000646u, 0x00000647u, 0x000200f8u, 0x00000646u, + 0x0004003du, 0x00000006u, 0x0000064fu, 0x00000643u, 0x0003003eu, 0x0000064eu, 0x0000064fu, 0x0004003du, + 0x00000006u, 0x00000651u, 0x00000588u, 0x0003003eu, 0x00000650u, 0x00000651u, 0x00060039u, 0x00000023u, + 0x00000652u, 0x00000027u, 0x0000064eu, 0x00000650u, 0x0003003eu, 0x0000064du, 0x00000652u, 0x0004003du, + 0x0000000du, 0x00000655u, 0x0000062eu, 0x0003003eu, 0x00000654u, 0x00000655u, 0x0004003du, 0x0000000du, + 0x00000657u, 0x00000633u, 0x0003003eu, 0x00000656u, 0x00000657u, 0x0004003du, 0x0000000du, 0x00000659u, + 0x00000639u, 0x0003003eu, 0x00000658u, 0x00000659u, 0x0004003du, 0x00000023u, 0x0000065bu, 0x0000064du, + 0x0003003eu, 0x0000065au, 0x0000065bu, 0x00080039u, 0x0000000du, 0x0000065cu, 0x0000002fu, 0x00000654u, + 0x00000656u, 0x00000658u, 0x0000065au, 0x0003003eu, 0x00000653u, 0x0000065cu, 0x0004003du, 0x0000000du, + 0x0000065fu, 0x00000653u, 0x0003003eu, 0x0000065eu, 0x0000065fu, 0x0004003du, 0x00000011u, 0x00000661u, + 0x000003a0u, 0x0003003eu, 0x00000660u, 0x00000661u, 0x0004003du, 0x00000013u, 0x00000663u, 0x00000394u, + 0x0003003eu, 0x00000662u, 0x00000663u, 0x00070039u, 0x0000000fu, 0x00000664u, 0x00000019u, 0x0000065eu, + 0x00000660u, 0x00000662u, 0x0003003eu, 0x0000065du, 0x00000664u, 0x0004003du, 0x00000006u, 0x00000665u, + 0x0000063fu, 0x0004003du, 0x00000006u, 0x00000666u, 0x00000643u, 0x00050080u, 0x00000006u, 0x00000667u, + 0x00000665u, 0x00000666u, 0x0004003du, 0x0000000fu, 0x00000668u, 0x0000065du, 0x00060041u, 0x00000434u, + 0x00000669u, 0x00000432u, 0x00000667u, 0x0000005fu, 0x0003003eu, 0x00000669u, 0x00000668u, 0x000200f9u, + 0x00000648u, 0x000200f8u, 0x00000648u, 0x0004003du, 0x00000006u, 0x0000066au, 0x00000643u, 0x00050080u, + 0x00000006u, 0x0000066bu, 0x0000066au, 0x00000007u, 0x0003003eu, 0x00000643u, 0x0000066bu, 0x000200f9u, + 0x00000645u, 0x000200f8u, 0x00000647u, 0x000200f9u, 0x0000062au, 0x000200f8u, 0x0000062au, 0x0004003du, + 0x00000006u, 0x0000066cu, 0x00000626u, 0x00050080u, 0x00000006u, 0x0000066du, 0x0000066cu, 0x00000127u, + 0x0003003eu, 0x00000626u, 0x0000066du, 0x000200f9u, 0x00000627u, 0x000200f8u, 0x00000629u, 0x000400e0u, + 0x0000006bu, 0x0000006bu, 0x00000523u, 0x0003003eu, 0x0000066eu, 0x00000089u, 0x000200f9u, 0x0000066fu, + 0x000200f8u, 0x0000066fu, 0x000400f6u, 0x00000671u, 0x00000672u, 0x00000000u, 0x000200f9u, 0x00000673u, + 0x000200f8u, 0x00000673u, 0x0004003du, 0x00000006u, 0x00000674u, 0x0000066eu, 0x000500b0u, 0x00000042u, + 0x00000675u, 0x00000674u, 0x0000006bu, 0x000400fau, 0x00000675u, 0x00000670u, 0x00000671u, 0x000200f8u, + 0x00000670u, 0x0004003du, 0x00000006u, 0x00000677u, 0x0000066eu, 0x0004003du, 0x00000006u, 0x00000678u, + 0x000005ebu, 0x00050084u, 0x00000006u, 0x00000679u, 0x00000677u, 0x00000678u, 0x0003003eu, 0x00000676u, + 0x00000679u, 0x0004003du, 0x00000006u, 0x0000067bu, 0x0000066eu, 0x0004003du, 0x00000006u, 0x0000067cu, + 0x000005efu, 0x00050084u, 0x00000006u, 0x0000067du, 0x0000067bu, 0x0000067cu, 0x0003003eu, 0x0000067au, + 0x0000067du, 0x0004003du, 0x00000006u, 0x0000067fu, 0x0000066eu, 0x00050084u, 0x00000006u, 0x00000680u, + 0x0000067fu, 0x00000160u, 0x00050041u, 0x00000037u, 0x00000681u, 0x00000613u, 0x00000680u, 0x0004003du, + 0x00000009u, 0x00000682u, 0x00000681u, 0x0003003eu, 0x0000067eu, 0x00000682u, 0x0004003du, 0x00000006u, + 0x00000684u, 0x0000066eu, 0x00050084u, 0x00000006u, 0x00000685u, 0x00000684u, 0x00000160u, 0x00050080u, + 0x00000006u, 0x00000686u, 0x00000685u, 0x00000008u, 0x00050041u, 0x00000037u, 0x00000687u, 0x00000613u, + 0x00000686u, 0x0004003du, 0x00000009u, 0x00000688u, 0x00000687u, 0x0003003eu, 0x00000683u, 0x00000688u, + 0x0004003du, 0x00000006u, 0x0000068au, 0x0000066eu, 0x00050084u, 0x00000006u, 0x0000068bu, 0x0000068au, + 0x00000160u, 0x00050080u, 0x00000006u, 0x0000068cu, 0x0000068bu, 0x0000006bu, 0x00050041u, 0x00000037u, + 0x0000068du, 0x00000613u, 0x0000068cu, 0x0004003du, 0x00000009u, 0x0000068eu, 0x0000068du, 0x0003003eu, + 0x00000689u, 0x0000068eu, 0x0004003du, 0x00000006u, 0x00000690u, 0x0000037du, 0x0003003eu, 0x0000068fu, + 0x00000690u, 0x000200f9u, 0x00000691u, 0x000200f8u, 0x00000691u, 0x000400f6u, 0x00000693u, 0x00000694u, + 0x00000000u, 0x000200f9u, 0x00000695u, 0x000200f8u, 0x00000695u, 0x0004003du, 0x00000006u, 0x00000696u, + 0x0000068fu, 0x0004003du, 0x00000006u, 0x00000697u, 0x000005efu, 0x000500b0u, 0x00000042u, 0x00000698u, + 0x00000696u, 0x00000697u, 0x000400fau, 0x00000698u, 0x00000692u, 0x00000693u, 0x000200f8u, 0x00000692u, + 0x0004003du, 0x00000006u, 0x0000069bu, 0x0000068fu, 0x0003003eu, 0x0000069au, 0x0000069bu, 0x0004003du, + 0x00000006u, 0x0000069du, 0x00000588u, 0x0003003eu, 0x0000069cu, 0x0000069du, 0x00060039u, 0x00000031u, + 0x0000069eu, 0x00000035u, 0x0000069au, 0x0000069cu, 0x0003003eu, 0x00000699u, 0x0000069eu, 0x0004003du, + 0x00000006u, 0x000006a0u, 0x0000067au, 0x0004003du, 0x00000006u, 0x000006a1u, 0x0000068fu, 0x00050080u, + 0x00000006u, 0x000006a2u, 0x000006a0u, 0x000006a1u, 0x00050084u, 0x00000006u, 0x000006a3u, 0x000006a2u, + 0x00000160u, 0x0003003eu, 0x0000069fu, 0x000006a3u, 0x0004003du, 0x00000006u, 0x000006a4u, 0x0000069fu, + 0x00050086u, 0x00000006u, 0x000006a5u, 0x000006a4u, 0x00000160u, 0x0004003du, 0x00000006u, 0x000006a6u, + 0x00000676u, 0x00050041u, 0x0000001bu, 0x000006a7u, 0x00000699u, 0x00000089u, 0x0004003du, 0x00000006u, + 0x000006a8u, 0x000006a7u, 0x00050080u, 0x00000006u, 0x000006a9u, 0x000006a6u, 0x000006a8u, 0x0004003du, + 0x00000006u, 0x000006aau, 0x00000676u, 0x00050041u, 0x0000001bu, 0x000006abu, 0x00000699u, 0x00000008u, + 0x0004003du, 0x00000006u, 0x000006acu, 0x000006abu, 0x00050080u, 0x00000006u, 0x000006adu, 0x000006aau, + 0x000006acu, 0x0004003du, 0x00000006u, 0x000006aeu, 0x00000676u, 0x00050041u, 0x0000001bu, 0x000006afu, + 0x00000699u, 0x0000006bu, 0x0004003du, 0x00000006u, 0x000006b0u, 0x000006afu, 0x00050080u, 0x00000006u, + 0x000006b1u, 0x000006aeu, 0x000006b0u, 0x00060050u, 0x00000031u, 0x000006b2u, 0x000006a9u, 0x000006adu, + 0x000006b1u, 0x00050041u, 0x00000541u, 0x000006b3u, 0x00000537u, 0x000006a5u, 0x0003003eu, 0x000006b3u, + 0x000006b2u, 0x0004003du, 0x00000006u, 0x000006b4u, 0x0000067au, 0x0004003du, 0x00000006u, 0x000006b5u, + 0x0000068fu, 0x00050080u, 0x00000006u, 0x000006b6u, 0x000006b4u, 0x000006b5u, 0x00050041u, 0x0000038du, + 0x000006b7u, 0x0000038cu, 0x0000005fu, 0x0004003du, 0x00000006u, 0x000006b8u, 0x000006b7u, 0x0004007cu, + 0x00000039u, 0x000006b9u, 0x000006b8u, 0x00060041u, 0x0000054cu, 0x000006bau, 0x00000546u, 0x000006b6u, + 0x0000005fu, 0x0003003eu, 0x000006bau, 0x000006b9u, 0x00050041u, 0x0000001bu, 0x000006bdu, 0x00000699u, + 0x00000089u, 0x0004003du, 0x00000006u, 0x000006beu, 0x000006bdu, 0x0003003eu, 0x000006bcu, 0x000006beu, + 0x0004003du, 0x00000006u, 0x000006c0u, 0x00000588u, 0x0003003eu, 0x000006bfu, 0x000006c0u, 0x00060039u, + 0x00000023u, 0x000006c1u, 0x00000027u, 0x000006bcu, 0x000006bfu, 0x0003003eu, 0x000006bbu, 0x000006c1u, + 0x00050041u, 0x0000001bu, 0x000006c4u, 0x00000699u, 0x00000008u, 0x0004003du, 0x00000006u, 0x000006c5u, + 0x000006c4u, 0x0003003eu, 0x000006c3u, 0x000006c5u, 0x0004003du, 0x00000006u, 0x000006c7u, 0x00000588u, + 0x0003003eu, 0x000006c6u, 0x000006c7u, 0x00060039u, 0x00000023u, 0x000006c8u, 0x00000027u, 0x000006c3u, + 0x000006c6u, 0x0003003eu, 0x000006c2u, 0x000006c8u, 0x00050041u, 0x0000001bu, 0x000006cbu, 0x00000699u, + 0x0000006bu, 0x0004003du, 0x00000006u, 0x000006ccu, 0x000006cbu, 0x0003003eu, 0x000006cau, 0x000006ccu, + 0x0004003du, 0x00000006u, 0x000006ceu, 0x00000588u, 0x0003003eu, 0x000006cdu, 0x000006ceu, 0x00060039u, + 0x00000023u, 0x000006cfu, 0x00000027u, 0x000006cau, 0x000006cdu, 0x0003003eu, 0x000006c9u, 0x000006cfu, + 0x00050041u, 0x00000037u, 0x000006d1u, 0x000006bbu, 0x00000089u, 0x0004003du, 0x00000009u, 0x000006d2u, + 0x000006d1u, 0x00050083u, 0x00000009u, 0x000006d3u, 0x0000004au, 0x000006d2u, 0x00050041u, 0x00000037u, + 0x000006d4u, 0x000006bbu, 0x00000008u, 0x0004003du, 0x00000009u, 0x000006d5u, 0x000006d4u, 0x00050083u, + 0x00000009u, 0x000006d6u, 0x000006d3u, 0x000006d5u, 0x0004003du, 0x00000009u, 0x000006d7u, 0x0000067eu, + 0x00050085u, 0x00000009u, 0x000006d8u, 0x000006d6u, 0x000006d7u, 0x00050041u, 0x00000037u, 0x000006d9u, + 0x000006bbu, 0x00000089u, 0x0004003du, 0x00000009u, 0x000006dau, 0x000006d9u, 0x0004003du, 0x00000009u, + 0x000006dbu, 0x00000683u, 0x00050085u, 0x00000009u, 0x000006dcu, 0x000006dau, 0x000006dbu, 0x00050081u, + 0x00000009u, 0x000006ddu, 0x000006d8u, 0x000006dcu, 0x00050041u, 0x00000037u, 0x000006deu, 0x000006bbu, + 0x00000008u, 0x0004003du, 0x00000009u, 0x000006dfu, 0x000006deu, 0x0004003du, 0x00000009u, 0x000006e0u, + 0x00000689u, 0x00050085u, 0x00000009u, 0x000006e1u, 0x000006dfu, 0x000006e0u, 0x00050081u, 0x00000009u, + 0x000006e2u, 0x000006ddu, 0x000006e1u, 0x00050041u, 0x00000037u, 0x000006e3u, 0x000006c2u, 0x00000089u, + 0x0004003du, 0x00000009u, 0x000006e4u, 0x000006e3u, 0x00050083u, 0x00000009u, 0x000006e5u, 0x0000004au, + 0x000006e4u, 0x00050041u, 0x00000037u, 0x000006e6u, 0x000006c2u, 0x00000008u, 0x0004003du, 0x00000009u, + 0x000006e7u, 0x000006e6u, 0x00050083u, 0x00000009u, 0x000006e8u, 0x000006e5u, 0x000006e7u, 0x0004003du, + 0x00000009u, 0x000006e9u, 0x0000067eu, 0x00050085u, 0x00000009u, 0x000006eau, 0x000006e8u, 0x000006e9u, + 0x00050041u, 0x00000037u, 0x000006ebu, 0x000006c2u, 0x00000089u, 0x0004003du, 0x00000009u, 0x000006ecu, + 0x000006ebu, 0x0004003du, 0x00000009u, 0x000006edu, 0x00000683u, 0x00050085u, 0x00000009u, 0x000006eeu, + 0x000006ecu, 0x000006edu, 0x00050081u, 0x00000009u, 0x000006efu, 0x000006eau, 0x000006eeu, 0x00050041u, + 0x00000037u, 0x000006f0u, 0x000006c2u, 0x00000008u, 0x0004003du, 0x00000009u, 0x000006f1u, 0x000006f0u, + 0x0004003du, 0x00000009u, 0x000006f2u, 0x00000689u, 0x00050085u, 0x00000009u, 0x000006f3u, 0x000006f1u, + 0x000006f2u, 0x00050081u, 0x00000009u, 0x000006f4u, 0x000006efu, 0x000006f3u, 0x00050041u, 0x00000037u, + 0x000006f5u, 0x000006c9u, 0x00000089u, 0x0004003du, 0x00000009u, 0x000006f6u, 0x000006f5u, 0x00050083u, + 0x00000009u, 0x000006f7u, 0x0000004au, 0x000006f6u, 0x00050041u, 0x00000037u, 0x000006f8u, 0x000006c9u, + 0x00000008u, 0x0004003du, 0x00000009u, 0x000006f9u, 0x000006f8u, 0x00050083u, 0x00000009u, 0x000006fau, + 0x000006f7u, 0x000006f9u, 0x0004003du, 0x00000009u, 0x000006fbu, 0x0000067eu, 0x00050085u, 0x00000009u, + 0x000006fcu, 0x000006fau, 0x000006fbu, 0x00050041u, 0x00000037u, 0x000006fdu, 0x000006c9u, 0x00000089u, + 0x0004003du, 0x00000009u, 0x000006feu, 0x000006fdu, 0x0004003du, 0x00000009u, 0x000006ffu, 0x00000683u, + 0x00050085u, 0x00000009u, 0x00000700u, 0x000006feu, 0x000006ffu, 0x00050081u, 0x00000009u, 0x00000701u, + 0x000006fcu, 0x00000700u, 0x00050041u, 0x00000037u, 0x00000702u, 0x000006c9u, 0x00000008u, 0x0004003du, + 0x00000009u, 0x00000703u, 0x00000702u, 0x0004003du, 0x00000009u, 0x00000704u, 0x00000689u, 0x00050085u, + 0x00000009u, 0x00000705u, 0x00000703u, 0x00000704u, 0x00050081u, 0x00000009u, 0x00000706u, 0x00000701u, + 0x00000705u, 0x00060050u, 0x0000000du, 0x00000707u, 0x000006e2u, 0x000006f4u, 0x00000706u, 0x0003003eu, + 0x000006d0u, 0x00000707u, 0x0004003du, 0x00000006u, 0x00000708u, 0x0000067au, 0x0004003du, 0x00000006u, + 0x00000709u, 0x0000068fu, 0x00050080u, 0x00000006u, 0x0000070au, 0x00000708u, 0x00000709u, 0x0004003du, + 0x0000000du, 0x0000070bu, 0x000006d0u, 0x00060041u, 0x00000554u, 0x0000070cu, 0x00000551u, 0x0000070au, + 0x0000005fu, 0x0003003eu, 0x0000070cu, 0x0000070bu, 0x0004003du, 0x00000006u, 0x0000070du, 0x0000067au, + 0x0004003du, 0x00000006u, 0x0000070eu, 0x0000068fu, 0x00050080u, 0x00000006u, 0x0000070fu, 0x0000070du, + 0x0000070eu, 0x00050041u, 0x00000461u, 0x00000710u, 0x0000038cu, 0x0000004du, 0x0004003du, 0x0000000du, + 0x00000711u, 0x00000710u, 0x00060041u, 0x00000554u, 0x00000712u, 0x00000551u, 0x0000070fu, 0x00000127u, + 0x0003003eu, 0x00000712u, 0x00000711u, 0x0004003du, 0x00000006u, 0x00000713u, 0x0000067au, 0x0004003du, + 0x00000006u, 0x00000714u, 0x0000068fu, 0x00050080u, 0x00000006u, 0x00000715u, 0x00000713u, 0x00000714u, + 0x00050041u, 0x00000461u, 0x00000716u, 0x0000038cu, 0x0000003du, 0x0004003du, 0x0000000du, 0x00000717u, + 0x00000716u, 0x00060041u, 0x00000554u, 0x00000718u, 0x00000551u, 0x00000715u, 0x0000008eu, 0x0003003eu, + 0x00000718u, 0x00000717u, 0x0004003du, 0x00000006u, 0x00000719u, 0x0000067au, 0x0004003du, 0x00000006u, + 0x0000071au, 0x0000068fu, 0x00050080u, 0x00000006u, 0x0000071bu, 0x00000719u, 0x0000071au, 0x00050041u, + 0x00000560u, 0x0000071cu, 0x0000038cu, 0x000000d8u, 0x0004003du, 0x00000009u, 0x0000071du, 0x0000071cu, + 0x00060041u, 0x00000563u, 0x0000071eu, 0x00000551u, 0x0000071bu, 0x0000009au, 0x0003003eu, 0x0000071eu, + 0x0000071du, 0x000200f9u, 0x00000694u, 0x000200f8u, 0x00000694u, 0x0004003du, 0x00000006u, 0x0000071fu, + 0x0000068fu, 0x00050080u, 0x00000006u, 0x00000720u, 0x0000071fu, 0x00000007u, 0x0003003eu, 0x0000068fu, + 0x00000720u, 0x000200f9u, 0x00000691u, 0x000200f8u, 0x00000693u, 0x000200f9u, 0x00000672u, 0x000200f8u, + 0x00000672u, 0x0004003du, 0x00000006u, 0x00000721u, 0x0000066eu, 0x00050080u, 0x00000006u, 0x00000722u, + 0x00000721u, 0x00000127u, 0x0003003eu, 0x0000066eu, 0x00000722u, 0x000200f9u, 0x0000066fu, 0x000200f8u, + 0x00000671u, 0x000100fdu, 0x00010038u, 0x00050036u, 0x00000009u, 0x0000000bu, 0x00000000u, 0x0000000au, + 0x000200f8u, 0x0000000cu, 0x0004003bu, 0x00000037u, 0x00000038u, 0x00000007u, 0x0004003bu, 0x00000037u, + 0x00000044u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x0000004cu, 0x00000007u, 0x0004003bu, 0x00000037u, + 0x00000051u, 0x00000007u, 0x00050041u, 0x0000003eu, 0x0000003fu, 0x0000003cu, 0x0000003du, 0x0004003du, + 0x00000009u, 0x00000040u, 0x0000003fu, 0x000500bau, 0x00000042u, 0x00000043u, 0x00000040u, 0x00000041u, + 0x000300f7u, 0x00000046u, 0x00000000u, 0x000400fau, 0x00000043u, 0x00000045u, 0x00000049u, 0x000200f8u, + 0x00000045u, 0x00050041u, 0x0000003eu, 0x00000047u, 0x0000003cu, 0x0000003du, 0x0004003du, 0x00000009u, + 0x00000048u, 0x00000047u, 0x0003003eu, 0x00000044u, 0x00000048u, 0x000200f9u, 0x00000046u, 0x000200f8u, + 0x00000049u, 0x0003003eu, 0x00000044u, 0x0000004au, 0x000200f9u, 0x00000046u, 0x000200f8u, 0x00000046u, + 0x0004003du, 0x00000009u, 0x0000004bu, 0x00000044u, 0x0003003eu, 0x00000038u, 0x0000004bu, 0x00050041u, + 0x0000003eu, 0x0000004eu, 0x0000003cu, 0x0000004du, 0x0004003du, 0x00000009u, 0x0000004fu, 0x0000004eu, + 0x000500bau, 0x00000042u, 0x00000050u, 0x0000004fu, 0x00000041u, 0x000300f7u, 0x00000053u, 0x00000000u, + 0x000400fau, 0x00000050u, 0x00000052u, 0x00000056u, 0x000200f8u, 0x00000052u, 0x00050041u, 0x0000003eu, + 0x00000054u, 0x0000003cu, 0x0000004du, 0x0004003du, 0x00000009u, 0x00000055u, 0x00000054u, 0x0003003eu, + 0x00000051u, 0x00000055u, 0x000200f9u, 0x00000053u, 0x000200f8u, 0x00000056u, 0x0003003eu, 0x00000051u, + 0x00000057u, 0x000200f9u, 0x00000053u, 0x000200f8u, 0x00000053u, 0x0004003du, 0x00000009u, 0x00000058u, + 0x00000051u, 0x0003003eu, 0x0000004cu, 0x00000058u, 0x0004003du, 0x00000009u, 0x00000059u, 0x0000004cu, + 0x0004003du, 0x00000009u, 0x0000005au, 0x00000038u, 0x00050085u, 0x00000009u, 0x0000005bu, 0x00000059u, + 0x0000005au, 0x000200feu, 0x0000005bu, 0x00010038u, 0x00050036u, 0x0000000fu, 0x00000019u, 0x00000000u, + 0x00000015u, 0x00030037u, 0x0000000eu, 0x00000016u, 0x00030037u, 0x00000012u, 0x00000017u, 0x00030037u, + 0x00000014u, 0x00000018u, 0x000200f8u, 0x0000001au, 0x0004003bu, 0x0000000eu, 0x0000005eu, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x0000006au, 0x00000007u, 0x0004003bu, 0x00000037u, 0x0000006eu, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x00000078u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000085u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x00000088u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000094u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000000a6u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x000000aau, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000000b1u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x000000b4u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000000b8u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x000000bcu, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000000c0u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x000000c4u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x000000f6u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x000000f9u, 0x00000007u, + 0x0004003bu, 0x00000029u, 0x00000101u, 0x00000007u, 0x0004003bu, 0x00000029u, 0x00000106u, 0x00000007u, + 0x0004003bu, 0x00000029u, 0x00000123u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x0000012cu, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x00000134u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000142u, 0x00000007u, + 0x0004003bu, 0x00000037u, 0x00000145u, 0x00000007u, 0x0004003bu, 0x00000037u, 0x00000150u, 0x00000007u, + 0x00050041u, 0x00000060u, 0x00000061u, 0x00000017u, 0x0000005fu, 0x0004003du, 0x00000010u, 0x00000062u, + 0x00000061u, 0x0004003du, 0x0000000du, 0x00000063u, 0x00000016u, 0x00050051u, 0x00000009u, 0x00000064u, + 0x00000063u, 0x00000000u, 0x00050051u, 0x00000009u, 0x00000065u, 0x00000063u, 0x00000001u, 0x00050051u, + 0x00000009u, 0x00000066u, 0x00000063u, 0x00000002u, 0x00070050u, 0x0000000fu, 0x00000067u, 0x00000064u, + 0x00000065u, 0x00000066u, 0x0000004au, 0x00050091u, 0x0000000fu, 0x00000068u, 0x00000062u, 0x00000067u, + 0x0008004fu, 0x0000000du, 0x00000069u, 0x00000068u, 0x00000068u, 0x00000000u, 0x00000001u, 0x00000002u, + 0x0003003eu, 0x0000005eu, 0x00000069u, 0x00050041u, 0x00000037u, 0x0000006cu, 0x0000005eu, 0x0000006bu, + 0x0004003du, 0x00000009u, 0x0000006du, 0x0000006cu, 0x0003003eu, 0x0000006au, 0x0000006du, 0x0004003du, + 0x0000000du, 0x0000006fu, 0x0000005eu, 0x0006000cu, 0x00000009u, 0x00000070u, 0x00000001u, 0x00000042u, + 0x0000006fu, 0x0003003eu, 0x0000006eu, 0x00000070u, 0x0004003du, 0x00000009u, 0x00000071u, 0x0000006eu, + 0x000500b8u, 0x00000042u, 0x00000073u, 0x00000071u, 0x00000072u, 0x000300f7u, 0x00000075u, 0x00000000u, + 0x000400fau, 0x00000073u, 0x00000074u, 0x00000075u, 0x000200f8u, 0x00000074u, 0x000200feu, 0x00000076u, + 0x000200f8u, 0x00000075u, 0x0003003eu, 0x00000078u, 0x00000079u, 0x00050041u, 0x00000037u, 0x0000007bu, + 0x00000018u, 0x0000007au, 0x0004003du, 0x00000009u, 0x0000007cu, 0x0000007bu, 0x0004003du, 0x00000009u, + 0x0000007du, 0x00000078u, 0x000500bcu, 0x00000042u, 0x0000007eu, 0x0000007cu, 0x0000007du, 0x0004003du, + 0x00000009u, 0x0000007fu, 0x0000006au, 0x000500b8u, 0x00000042u, 0x00000081u, 0x0000007fu, 0x00000080u, + 0x000500a7u, 0x00000042u, 0x00000082u, 0x0000007eu, 0x00000081u, 0x000300f7u, 0x00000084u, 0x00000000u, + 0x000400fau, 0x00000082u, 0x00000083u, 0x00000084u, 0x000200f8u, 0x00000083u, 0x00050041u, 0x00000037u, + 0x00000086u, 0x00000018u, 0x0000003du, 0x0004003du, 0x00000009u, 0x00000087u, 0x00000086u, 0x0003003eu, + 0x00000085u, 0x00000087u, 0x00050041u, 0x00000037u, 0x0000008au, 0x0000005eu, 0x00000089u, 0x0004003du, + 0x00000009u, 0x0000008bu, 0x0000008au, 0x0004003du, 0x00000009u, 0x0000008cu, 0x00000085u, 0x00050085u, + 0x00000009u, 0x0000008du, 0x0000008bu, 0x0000008cu, 0x00050041u, 0x00000037u, 0x0000008fu, 0x00000018u, + 0x0000008eu, 0x0004003du, 0x00000009u, 0x00000090u, 0x0000008fu, 0x00050085u, 0x00000009u, 0x00000092u, + 0x00000090u, 0x00000091u, 0x00050088u, 0x00000009u, 0x00000093u, 0x0000008du, 0x00000092u, 0x0003003eu, + 0x00000088u, 0x00000093u, 0x00050041u, 0x00000037u, 0x00000095u, 0x0000005eu, 0x00000008u, 0x0004003du, + 0x00000009u, 0x00000096u, 0x00000095u, 0x0004007fu, 0x00000009u, 0x00000097u, 0x00000096u, 0x0004003du, + 0x00000009u, 0x00000098u, 0x00000085u, 0x00050085u, 0x00000009u, 0x00000099u, 0x00000097u, 0x00000098u, + 0x00050041u, 0x00000037u, 0x0000009bu, 0x00000018u, 0x0000009au, 0x0004003du, 0x00000009u, 0x0000009cu, + 0x0000009bu, 0x00050085u, 0x00000009u, 0x0000009du, 0x0000009cu, 0x00000091u, 0x00050088u, 0x00000009u, + 0x0000009eu, 0x00000099u, 0x0000009du, 0x0003003eu, 0x00000094u, 0x0000009eu, 0x0004003du, 0x00000009u, + 0x0000009fu, 0x00000088u, 0x00050085u, 0x00000009u, 0x000000a1u, 0x0000009fu, 0x000000a0u, 0x0004003du, + 0x00000009u, 0x000000a2u, 0x00000094u, 0x00050085u, 0x00000009u, 0x000000a3u, 0x000000a2u, 0x000000a0u, + 0x00070050u, 0x0000000fu, 0x000000a4u, 0x000000a1u, 0x000000a3u, 0x0000004au, 0x0000004au, 0x000200feu, + 0x000000a4u, 0x000200f8u, 0x00000084u, 0x0004003du, 0x0000000du, 0x000000a7u, 0x0000005eu, 0x0007004fu, + 0x00000023u, 0x000000a8u, 0x000000a7u, 0x000000a7u, 0x00000000u, 0x00000001u, 0x0006000cu, 0x00000009u, + 0x000000a9u, 0x00000001u, 0x00000042u, 0x000000a8u, 0x0003003eu, 0x000000a6u, 0x000000a9u, 0x00050041u, + 0x00000037u, 0x000000abu, 0x0000005eu, 0x0000006bu, 0x0004003du, 0x00000009u, 0x000000acu, 0x000000abu, + 0x0004003du, 0x00000009u, 0x000000adu, 0x0000006eu, 0x00050088u, 0x00000009u, 0x000000aeu, 0x000000acu, + 0x000000adu, 0x0008000cu, 0x00000009u, 0x000000b0u, 0x00000001u, 0x0000002bu, 0x000000aeu, 0x000000afu, + 0x0000004au, 0x0003003eu, 0x000000aau, 0x000000b0u, 0x0004003du, 0x00000009u, 0x000000b2u, 0x000000aau, + 0x0006000cu, 0x00000009u, 0x000000b3u, 0x00000001u, 0x00000011u, 0x000000b2u, 0x0003003eu, 0x000000b1u, + 0x000000b3u, 0x0004003du, 0x00000009u, 0x000000b5u, 0x000000b1u, 0x0004003du, 0x00000009u, 0x000000b6u, + 0x000000b1u, 0x00050085u, 0x00000009u, 0x000000b7u, 0x000000b5u, 0x000000b6u, 0x0003003eu, 0x000000b4u, + 0x000000b7u, 0x0004003du, 0x00000009u, 0x000000b9u, 0x000000b4u, 0x0004003du, 0x00000009u, 0x000000bau, + 0x000000b1u, 0x00050085u, 0x00000009u, 0x000000bbu, 0x000000b9u, 0x000000bau, 0x0003003eu, 0x000000b8u, + 0x000000bbu, 0x0004003du, 0x00000009u, 0x000000bdu, 0x000000b4u, 0x0004003du, 0x00000009u, 0x000000beu, + 0x000000b4u, 0x00050085u, 0x00000009u, 0x000000bfu, 0x000000bdu, 0x000000beu, 0x0003003eu, 0x000000bcu, + 0x000000bfu, 0x0004003du, 0x00000009u, 0x000000c1u, 0x000000bcu, 0x0004003du, 0x00000009u, 0x000000c2u, + 0x000000b1u, 0x00050085u, 0x00000009u, 0x000000c3u, 0x000000c1u, 0x000000c2u, 0x0003003eu, 0x000000c0u, + 0x000000c3u, 0x00050041u, 0x00000037u, 0x000000c5u, 0x00000018u, 0x0000004du, 0x0004003du, 0x00000009u, + 0x000000c6u, 0x000000c5u, 0x00050041u, 0x00000037u, 0x000000c7u, 0x00000018u, 0x0000003du, 0x0004003du, + 0x00000009u, 0x000000c8u, 0x000000c7u, 0x0004003du, 0x00000009u, 0x000000c9u, 0x000000b1u, 0x00050085u, + 0x00000009u, 0x000000cau, 0x000000c8u, 0x000000c9u, 0x00050081u, 0x00000009u, 0x000000cbu, 0x000000c6u, + 0x000000cau, 0x00050041u, 0x00000037u, 0x000000cdu, 0x00000018u, 0x000000ccu, 0x0004003du, 0x00000009u, + 0x000000ceu, 0x000000cdu, 0x0004003du, 0x00000009u, 0x000000cfu, 0x000000b4u, 0x00050085u, 0x00000009u, + 0x000000d0u, 0x000000ceu, 0x000000cfu, 0x00050081u, 0x00000009u, 0x000000d1u, 0x000000cbu, 0x000000d0u, + 0x00050041u, 0x00000037u, 0x000000d3u, 0x00000018u, 0x000000d2u, 0x0004003du, 0x00000009u, 0x000000d4u, + 0x000000d3u, 0x0004003du, 0x00000009u, 0x000000d5u, 0x000000b8u, 0x00050085u, 0x00000009u, 0x000000d6u, + 0x000000d4u, 0x000000d5u, 0x00050081u, 0x00000009u, 0x000000d7u, 0x000000d1u, 0x000000d6u, 0x00050041u, + 0x00000037u, 0x000000d9u, 0x00000018u, 0x000000d8u, 0x0004003du, 0x00000009u, 0x000000dau, 0x000000d9u, + 0x0004003du, 0x00000009u, 0x000000dbu, 0x000000bcu, 0x00050085u, 0x00000009u, 0x000000dcu, 0x000000dau, + 0x000000dbu, 0x00050081u, 0x00000009u, 0x000000ddu, 0x000000d7u, 0x000000dcu, 0x00050041u, 0x00000037u, + 0x000000dfu, 0x00000018u, 0x000000deu, 0x0004003du, 0x00000009u, 0x000000e0u, 0x000000dfu, 0x0004003du, + 0x00000009u, 0x000000e1u, 0x000000c0u, 0x00050085u, 0x00000009u, 0x000000e2u, 0x000000e0u, 0x000000e1u, + 0x00050081u, 0x00000009u, 0x000000e3u, 0x000000ddu, 0x000000e2u, 0x0003003eu, 0x000000c4u, 0x000000e3u, + 0x0004003du, 0x00000009u, 0x000000e4u, 0x000000b1u, 0x00050041u, 0x00000037u, 0x000000e5u, 0x00000018u, + 0x0000007au, 0x0004003du, 0x00000009u, 0x000000e6u, 0x000000e5u, 0x000500bau, 0x00000042u, 0x000000e7u, + 0x000000e4u, 0x000000e6u, 0x000300f7u, 0x000000e9u, 0x00000000u, 0x000400fau, 0x000000e7u, 0x000000e8u, + 0x000000e9u, 0x000200f8u, 0x000000e8u, 0x00050041u, 0x00000037u, 0x000000ebu, 0x00000018u, 0x000000eau, + 0x0004003du, 0x00000009u, 0x000000ecu, 0x000000ebu, 0x0004003du, 0x00000009u, 0x000000edu, 0x000000b1u, + 0x00050041u, 0x00000037u, 0x000000eeu, 0x00000018u, 0x0000007au, 0x0004003du, 0x00000009u, 0x000000efu, + 0x000000eeu, 0x00050083u, 0x00000009u, 0x000000f0u, 0x000000edu, 0x000000efu, 0x00050041u, 0x00000037u, + 0x000000f2u, 0x00000018u, 0x000000f1u, 0x0004003du, 0x00000009u, 0x000000f3u, 0x000000f2u, 0x00050085u, + 0x00000009u, 0x000000f4u, 0x000000f0u, 0x000000f3u, 0x00050081u, 0x00000009u, 0x000000f5u, 0x000000ecu, + 0x000000f4u, 0x0003003eu, 0x000000c4u, 0x000000f5u, 0x000200f9u, 0x000000e9u, 0x000200f8u, 0x000000e9u, + 0x0004003du, 0x00000009u, 0x000000f7u, 0x000000a6u, 0x000500bau, 0x00000042u, 0x000000f8u, 0x000000f7u, + 0x00000072u, 0x000300f7u, 0x000000fbu, 0x00000000u, 0x000400fau, 0x000000f8u, 0x000000fau, 0x000000ffu, + 0x000200f8u, 0x000000fau, 0x0004003du, 0x00000009u, 0x000000fcu, 0x000000c4u, 0x0004003du, 0x00000009u, + 0x000000fdu, 0x000000a6u, 0x00050088u, 0x00000009u, 0x000000feu, 0x000000fcu, 0x000000fdu, 0x0003003eu, + 0x000000f9u, 0x000000feu, 0x000200f9u, 0x000000fbu, 0x000200f8u, 0x000000ffu, 0x0003003eu, 0x000000f9u, + 0x00000041u, 0x000200f9u, 0x000000fbu, 0x000200f8u, 0x000000fbu, 0x0004003du, 0x00000009u, 0x00000100u, + 0x000000f9u, 0x0003003eu, 0x000000f6u, 0x00000100u, 0x0004003du, 0x00000009u, 0x00000102u, 0x000000f6u, + 0x0004003du, 0x0000000du, 0x00000103u, 0x0000005eu, 0x0007004fu, 0x00000023u, 0x00000104u, 0x00000103u, + 0x00000103u, 0x00000000u, 0x00000001u, 0x0005008eu, 0x00000023u, 0x00000105u, 0x00000104u, 0x00000102u, + 0x0003003eu, 0x00000101u, 0x00000105u, 0x00050041u, 0x00000037u, 0x00000108u, 0x00000018u, 0x00000107u, + 0x0004003du, 0x00000009u, 0x00000109u, 0x00000108u, 0x00050041u, 0x00000037u, 0x0000010au, 0x00000101u, + 0x00000089u, 0x0004003du, 0x00000009u, 0x0000010bu, 0x0000010au, 0x00050085u, 0x00000009u, 0x0000010cu, + 0x00000109u, 0x0000010bu, 0x00050041u, 0x00000037u, 0x0000010eu, 0x00000018u, 0x0000010du, 0x0004003du, + 0x00000009u, 0x0000010fu, 0x0000010eu, 0x00050041u, 0x00000037u, 0x00000110u, 0x00000101u, 0x00000008u, + 0x0004003du, 0x00000009u, 0x00000111u, 0x00000110u, 0x00050085u, 0x00000009u, 0x00000112u, 0x0000010fu, + 0x00000111u, 0x00050081u, 0x00000009u, 0x00000113u, 0x0000010cu, 0x00000112u, 0x00050041u, 0x00000037u, + 0x00000114u, 0x00000106u, 0x00000089u, 0x0003003eu, 0x00000114u, 0x00000113u, 0x00050041u, 0x00000037u, + 0x00000116u, 0x00000018u, 0x00000115u, 0x0004003du, 0x00000009u, 0x00000117u, 0x00000116u, 0x00050041u, + 0x00000037u, 0x00000118u, 0x00000101u, 0x00000089u, 0x0004003du, 0x00000009u, 0x00000119u, 0x00000118u, + 0x00050085u, 0x00000009u, 0x0000011au, 0x00000117u, 0x00000119u, 0x00050041u, 0x00000037u, 0x0000011cu, + 0x00000018u, 0x0000011bu, 0x0004003du, 0x00000009u, 0x0000011du, 0x0000011cu, 0x00050041u, 0x00000037u, + 0x0000011eu, 0x00000101u, 0x00000008u, 0x0004003du, 0x00000009u, 0x0000011fu, 0x0000011eu, 0x00050085u, + 0x00000009u, 0x00000120u, 0x0000011du, 0x0000011fu, 0x00050081u, 0x00000009u, 0x00000121u, 0x0000011au, + 0x00000120u, 0x00050041u, 0x00000037u, 0x00000122u, 0x00000106u, 0x00000008u, 0x0003003eu, 0x00000122u, + 0x00000121u, 0x0004003du, 0x00000023u, 0x00000124u, 0x00000106u, 0x00050041u, 0x00000037u, 0x00000125u, + 0x00000018u, 0x0000005fu, 0x0004003du, 0x00000009u, 0x00000126u, 0x00000125u, 0x00050041u, 0x00000037u, + 0x00000128u, 0x00000018u, 0x00000127u, 0x0004003du, 0x00000009u, 0x00000129u, 0x00000128u, 0x00050050u, + 0x00000023u, 0x0000012au, 0x00000126u, 0x00000129u, 0x00050081u, 0x00000023u, 0x0000012bu, 0x00000124u, + 0x0000012au, 0x0003003eu, 0x00000123u, 0x0000012bu, 0x00050041u, 0x00000037u, 0x0000012du, 0x00000123u, + 0x00000089u, 0x0004003du, 0x00000009u, 0x0000012eu, 0x0000012du, 0x00050085u, 0x00000009u, 0x0000012fu, + 0x00000057u, 0x0000012eu, 0x00050041u, 0x00000037u, 0x00000130u, 0x00000018u, 0x0000008eu, 0x0004003du, + 0x00000009u, 0x00000131u, 0x00000130u, 0x00050088u, 0x00000009u, 0x00000132u, 0x0000012fu, 0x00000131u, + 0x00050083u, 0x00000009u, 0x00000133u, 0x00000132u, 0x0000004au, 0x0003003eu, 0x0000012cu, 0x00000133u, + 0x00050041u, 0x00000037u, 0x00000135u, 0x00000123u, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000136u, + 0x00000135u, 0x00050085u, 0x00000009u, 0x00000137u, 0x00000057u, 0x00000136u, 0x00050041u, 0x00000037u, + 0x00000138u, 0x00000018u, 0x0000009au, 0x0004003du, 0x00000009u, 0x00000139u, 0x00000138u, 0x00050088u, + 0x00000009u, 0x0000013au, 0x00000137u, 0x00000139u, 0x00050083u, 0x00000009u, 0x0000013bu, 0x0000004au, + 0x0000013au, 0x0003003eu, 0x00000134u, 0x0000013bu, 0x00050041u, 0x00000037u, 0x0000013cu, 0x00000018u, + 0x0000007au, 0x0004003du, 0x00000009u, 0x0000013du, 0x0000013cu, 0x0004003du, 0x00000009u, 0x0000013eu, + 0x00000078u, 0x000500bau, 0x00000042u, 0x0000013fu, 0x0000013du, 0x0000013eu, 0x000300f7u, 0x00000141u, + 0x00000000u, 0x000400fau, 0x0000013fu, 0x00000140u, 0x0000014eu, 0x000200f8u, 0x00000140u, 0x0004003du, + 0x00000009u, 0x00000143u, 0x0000006au, 0x000500beu, 0x00000042u, 0x00000144u, 0x00000143u, 0x00000041u, + 0x000300f7u, 0x00000147u, 0x00000000u, 0x000400fau, 0x00000144u, 0x00000146u, 0x00000149u, 0x000200f8u, + 0x00000146u, 0x0004003du, 0x00000009u, 0x00000148u, 0x0000006eu, 0x0003003eu, 0x00000145u, 0x00000148u, + 0x000200f9u, 0x00000147u, 0x000200f8u, 0x00000149u, 0x00050041u, 0x00000037u, 0x0000014bu, 0x00000018u, + 0x0000014au, 0x0004003du, 0x00000009u, 0x0000014cu, 0x0000014bu, 0x0003003eu, 0x00000145u, 0x0000014cu, + 0x000200f9u, 0x00000147u, 0x000200f8u, 0x00000147u, 0x0004003du, 0x00000009u, 0x0000014du, 0x00000145u, + 0x0003003eu, 0x00000142u, 0x0000014du, 0x000200f9u, 0x00000141u, 0x000200f8u, 0x0000014eu, 0x0004003du, + 0x00000009u, 0x0000014fu, 0x0000006au, 0x0003003eu, 0x00000142u, 0x0000014fu, 0x000200f9u, 0x00000141u, + 0x000200f8u, 0x00000141u, 0x0004003du, 0x00000009u, 0x00000151u, 0x00000142u, 0x00050041u, 0x00000037u, + 0x00000152u, 0x00000018u, 0x0000014au, 0x0004003du, 0x00000009u, 0x00000153u, 0x00000152u, 0x00050088u, + 0x00000009u, 0x00000154u, 0x00000151u, 0x00000153u, 0x0008000cu, 0x00000009u, 0x00000155u, 0x00000001u, + 0x0000002bu, 0x00000154u, 0x00000041u, 0x0000004au, 0x0003003eu, 0x00000150u, 0x00000155u, 0x0004003du, + 0x00000009u, 0x00000156u, 0x0000012cu, 0x0004003du, 0x00000009u, 0x00000157u, 0x00000134u, 0x0004003du, + 0x00000009u, 0x00000158u, 0x00000150u, 0x00070050u, 0x0000000fu, 0x00000159u, 0x00000156u, 0x00000157u, + 0x00000158u, 0x0000004au, 0x000200feu, 0x00000159u, 0x00010038u, 0x00050036u, 0x00000006u, 0x0000001eu, + 0x00000000u, 0x0000001cu, 0x00030037u, 0x0000001bu, 0x0000001du, 0x000200f8u, 0x0000001fu, 0x0004003du, + 0x00000006u, 0x0000015cu, 0x0000001du, 0x000500aau, 0x00000042u, 0x0000015du, 0x0000015cu, 0x00000089u, + 0x000300f7u, 0x0000015fu, 0x00000000u, 0x000400fau, 0x0000015du, 0x0000015eu, 0x0000015fu, 0x000200f8u, + 0x0000015eu, 0x000200feu, 0x00000160u, 0x000200f8u, 0x0000015fu, 0x0004003du, 0x00000006u, 0x00000162u, + 0x0000001du, 0x000500aau, 0x00000042u, 0x00000163u, 0x00000162u, 0x00000008u, 0x000300f7u, 0x00000165u, + 0x00000000u, 0x000400fau, 0x00000163u, 0x00000164u, 0x00000165u, 0x000200f8u, 0x00000164u, 0x000200feu, + 0x00000166u, 0x000200f8u, 0x00000165u, 0x0004003du, 0x00000006u, 0x00000168u, 0x0000001du, 0x000500aau, + 0x00000042u, 0x00000169u, 0x00000168u, 0x0000006bu, 0x000300f7u, 0x0000016bu, 0x00000000u, 0x000400fau, + 0x00000169u, 0x0000016au, 0x0000016bu, 0x000200f8u, 0x0000016au, 0x000200feu, 0x0000016cu, 0x000200f8u, + 0x0000016bu, 0x000200feu, 0x0000016eu, 0x00010038u, 0x00050036u, 0x00000006u, 0x00000021u, 0x00000000u, + 0x0000001cu, 0x00030037u, 0x0000001bu, 0x00000020u, 0x000200f8u, 0x00000022u, 0x0004003du, 0x00000006u, + 0x00000171u, 0x00000020u, 0x000500aau, 0x00000042u, 0x00000172u, 0x00000171u, 0x00000089u, 0x000300f7u, + 0x00000174u, 0x00000000u, 0x000400fau, 0x00000172u, 0x00000173u, 0x00000174u, 0x000200f8u, 0x00000173u, + 0x000200feu, 0x00000008u, 0x000200f8u, 0x00000174u, 0x0004003du, 0x00000006u, 0x00000176u, 0x00000020u, + 0x000500aau, 0x00000042u, 0x00000177u, 0x00000176u, 0x00000008u, 0x000300f7u, 0x00000179u, 0x00000000u, + 0x000400fau, 0x00000177u, 0x00000178u, 0x00000179u, 0x000200f8u, 0x00000178u, 0x000200feu, 0x0000017au, + 0x000200f8u, 0x00000179u, 0x0004003du, 0x00000006u, 0x0000017cu, 0x00000020u, 0x000500aau, 0x00000042u, + 0x0000017du, 0x0000017cu, 0x0000006bu, 0x000300f7u, 0x0000017fu, 0x00000000u, 0x000400fau, 0x0000017du, + 0x0000017eu, 0x0000017fu, 0x000200f8u, 0x0000017eu, 0x000200feu, 0x00000180u, 0x000200f8u, 0x0000017fu, + 0x000200feu, 0x00000182u, 0x00010038u, 0x00050036u, 0x00000023u, 0x00000027u, 0x00000000u, 0x00000024u, + 0x00030037u, 0x0000001bu, 0x00000025u, 0x00030037u, 0x0000001bu, 0x00000026u, 0x000200f8u, 0x00000028u, + 0x0004003bu, 0x0000019du, 0x0000019eu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000001b6u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000001b7u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000001e0u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000001e1u, 0x00000007u, 0x0004003du, 0x00000006u, 0x00000185u, 0x00000026u, + 0x000500aau, 0x00000042u, 0x00000186u, 0x00000185u, 0x00000089u, 0x000300f7u, 0x00000188u, 0x00000000u, + 0x000400fau, 0x00000186u, 0x00000187u, 0x00000197u, 0x000200f8u, 0x00000187u, 0x0004003du, 0x00000006u, + 0x00000189u, 0x00000025u, 0x000500aau, 0x00000042u, 0x0000018au, 0x00000189u, 0x00000089u, 0x000300f7u, + 0x0000018cu, 0x00000000u, 0x000400fau, 0x0000018au, 0x0000018bu, 0x0000018cu, 0x000200f8u, 0x0000018bu, + 0x000200feu, 0x0000018du, 0x000200f8u, 0x0000018cu, 0x0004003du, 0x00000006u, 0x0000018fu, 0x00000025u, + 0x000500aau, 0x00000042u, 0x00000190u, 0x0000018fu, 0x00000008u, 0x000300f7u, 0x00000192u, 0x00000000u, + 0x000400fau, 0x00000190u, 0x00000191u, 0x00000192u, 0x000200f8u, 0x00000191u, 0x000200feu, 0x00000193u, + 0x000200f8u, 0x00000192u, 0x000200feu, 0x00000195u, 0x000200f8u, 0x00000197u, 0x0004003du, 0x00000006u, + 0x00000198u, 0x00000026u, 0x000500aau, 0x00000042u, 0x00000199u, 0x00000198u, 0x00000008u, 0x000300f7u, + 0x0000019bu, 0x00000000u, 0x000400fau, 0x00000199u, 0x0000019au, 0x000001acu, 0x000200f8u, 0x0000019au, + 0x00050041u, 0x00000029u, 0x0000019fu, 0x0000019eu, 0x0000005fu, 0x0003003eu, 0x0000019fu, 0x0000018du, + 0x00050041u, 0x00000029u, 0x000001a0u, 0x0000019eu, 0x00000127u, 0x0003003eu, 0x000001a0u, 0x00000193u, + 0x00050041u, 0x00000029u, 0x000001a1u, 0x0000019eu, 0x0000008eu, 0x0003003eu, 0x000001a1u, 0x00000195u, + 0x00050041u, 0x00000029u, 0x000001a3u, 0x0000019eu, 0x0000009au, 0x0003003eu, 0x000001a3u, 0x000001a2u, + 0x00050041u, 0x00000029u, 0x000001a5u, 0x0000019eu, 0x0000004du, 0x0003003eu, 0x000001a5u, 0x000001a4u, + 0x00050041u, 0x00000029u, 0x000001a7u, 0x0000019eu, 0x0000003du, 0x0003003eu, 0x000001a7u, 0x000001a6u, + 0x0004003du, 0x00000006u, 0x000001a8u, 0x00000025u, 0x00050041u, 0x00000029u, 0x000001a9u, 0x0000019eu, + 0x000001a8u, 0x0004003du, 0x00000023u, 0x000001aau, 0x000001a9u, 0x000200feu, 0x000001aau, 0x000200f8u, + 0x000001acu, 0x0004003du, 0x00000006u, 0x000001adu, 0x00000026u, 0x000500aau, 0x00000042u, 0x000001aeu, + 0x000001adu, 0x0000006bu, 0x000300f7u, 0x000001b0u, 0x00000000u, 0x000400fau, 0x000001aeu, 0x000001afu, + 0x000001dbu, 0x000200f8u, 0x000001afu, 0x0004003du, 0x00000006u, 0x000001b1u, 0x00000025u, 0x000500b0u, + 0x00000042u, 0x000001b3u, 0x000001b1u, 0x000001b2u, 0x000300f7u, 0x000001b5u, 0x00000000u, 0x000400fau, + 0x000001b3u, 0x000001b4u, 0x000001b9u, 0x000200f8u, 0x000001b4u, 0x0003003eu, 0x000001b6u, 0x00000089u, + 0x0004003du, 0x00000006u, 0x000001b8u, 0x00000025u, 0x0003003eu, 0x000001b7u, 0x000001b8u, 0x000200f9u, + 0x000001b5u, 0x000200f8u, 0x000001b9u, 0x0004003du, 0x00000006u, 0x000001bau, 0x00000025u, 0x000500b0u, + 0x00000042u, 0x000001bcu, 0x000001bau, 0x000001bbu, 0x000300f7u, 0x000001beu, 0x00000000u, 0x000400fau, + 0x000001bcu, 0x000001bdu, 0x000001c1u, 0x000200f8u, 0x000001bdu, 0x0003003eu, 0x000001b6u, 0x00000008u, + 0x0004003du, 0x00000006u, 0x000001bfu, 0x00000025u, 0x00050082u, 0x00000006u, 0x000001c0u, 0x000001bfu, + 0x000001b2u, 0x0003003eu, 0x000001b7u, 0x000001c0u, 0x000200f9u, 0x000001beu, 0x000200f8u, 0x000001c1u, + 0x0004003du, 0x00000006u, 0x000001c2u, 0x00000025u, 0x000500b0u, 0x00000042u, 0x000001c4u, 0x000001c2u, + 0x000001c3u, 0x000300f7u, 0x000001c6u, 0x00000000u, 0x000400fau, 0x000001c4u, 0x000001c5u, 0x000001c9u, + 0x000200f8u, 0x000001c5u, 0x0003003eu, 0x000001b6u, 0x0000006bu, 0x0004003du, 0x00000006u, 0x000001c7u, + 0x00000025u, 0x00050082u, 0x00000006u, 0x000001c8u, 0x000001c7u, 0x000001bbu, 0x0003003eu, 0x000001b7u, + 0x000001c8u, 0x000200f9u, 0x000001c6u, 0x000200f8u, 0x000001c9u, 0x0004003du, 0x00000006u, 0x000001cau, + 0x00000025u, 0x000500b0u, 0x00000042u, 0x000001ccu, 0x000001cau, 0x000001cbu, 0x000300f7u, 0x000001ceu, + 0x00000000u, 0x000400fau, 0x000001ccu, 0x000001cdu, 0x000001d1u, 0x000200f8u, 0x000001cdu, 0x0003003eu, + 0x000001b6u, 0x00000160u, 0x0004003du, 0x00000006u, 0x000001cfu, 0x00000025u, 0x00050082u, 0x00000006u, + 0x000001d0u, 0x000001cfu, 0x000001c3u, 0x0003003eu, 0x000001b7u, 0x000001d0u, 0x000200f9u, 0x000001ceu, + 0x000200f8u, 0x000001d1u, 0x0003003eu, 0x000001b6u, 0x0000017au, 0x0003003eu, 0x000001b7u, 0x00000089u, + 0x000200f9u, 0x000001ceu, 0x000200f8u, 0x000001ceu, 0x000200f9u, 0x000001c6u, 0x000200f8u, 0x000001c6u, + 0x000200f9u, 0x000001beu, 0x000200f8u, 0x000001beu, 0x000200f9u, 0x000001b5u, 0x000200f8u, 0x000001b5u, + 0x0004003du, 0x00000006u, 0x000001d2u, 0x000001b7u, 0x00040070u, 0x00000009u, 0x000001d3u, 0x000001d2u, + 0x00050088u, 0x00000009u, 0x000001d5u, 0x000001d3u, 0x000001d4u, 0x0004003du, 0x00000006u, 0x000001d6u, + 0x000001b6u, 0x00040070u, 0x00000009u, 0x000001d7u, 0x000001d6u, 0x00050088u, 0x00000009u, 0x000001d8u, + 0x000001d7u, 0x000001d4u, 0x00050050u, 0x00000023u, 0x000001d9u, 0x000001d5u, 0x000001d8u, 0x000200feu, + 0x000001d9u, 0x000200f8u, 0x000001dbu, 0x0004003du, 0x00000006u, 0x000001dcu, 0x00000025u, 0x000500b0u, + 0x00000042u, 0x000001ddu, 0x000001dcu, 0x000001bbu, 0x000300f7u, 0x000001dfu, 0x00000000u, 0x000400fau, + 0x000001ddu, 0x000001deu, 0x000001e3u, 0x000200f8u, 0x000001deu, 0x0003003eu, 0x000001e0u, 0x00000089u, + 0x0004003du, 0x00000006u, 0x000001e2u, 0x00000025u, 0x0003003eu, 0x000001e1u, 0x000001e2u, 0x000200f9u, + 0x000001dfu, 0x000200f8u, 0x000001e3u, 0x0004003du, 0x00000006u, 0x000001e4u, 0x00000025u, 0x000500b0u, + 0x00000042u, 0x000001e6u, 0x000001e4u, 0x000001e5u, 0x000300f7u, 0x000001e8u, 0x00000000u, 0x000400fau, + 0x000001e6u, 0x000001e7u, 0x000001ebu, 0x000200f8u, 0x000001e7u, 0x0003003eu, 0x000001e0u, 0x00000008u, + 0x0004003du, 0x00000006u, 0x000001e9u, 0x00000025u, 0x00050082u, 0x00000006u, 0x000001eau, 0x000001e9u, + 0x000001bbu, 0x0003003eu, 0x000001e1u, 0x000001eau, 0x000200f9u, 0x000001e8u, 0x000200f8u, 0x000001ebu, + 0x0004003du, 0x00000006u, 0x000001ecu, 0x00000025u, 0x000500b0u, 0x00000042u, 0x000001eeu, 0x000001ecu, + 0x000001edu, 0x000300f7u, 0x000001f0u, 0x00000000u, 0x000400fau, 0x000001eeu, 0x000001efu, 0x000001f3u, + 0x000200f8u, 0x000001efu, 0x0003003eu, 0x000001e0u, 0x0000006bu, 0x0004003du, 0x00000006u, 0x000001f1u, + 0x00000025u, 0x00050082u, 0x00000006u, 0x000001f2u, 0x000001f1u, 0x000001e5u, 0x0003003eu, 0x000001e1u, + 0x000001f2u, 0x000200f9u, 0x000001f0u, 0x000200f8u, 0x000001f3u, 0x0004003du, 0x00000006u, 0x000001f4u, + 0x00000025u, 0x000500b0u, 0x00000042u, 0x000001f6u, 0x000001f4u, 0x000001f5u, 0x000300f7u, 0x000001f8u, + 0x00000000u, 0x000400fau, 0x000001f6u, 0x000001f7u, 0x000001fbu, 0x000200f8u, 0x000001f7u, 0x0003003eu, + 0x000001e0u, 0x00000160u, 0x0004003du, 0x00000006u, 0x000001f9u, 0x00000025u, 0x00050082u, 0x00000006u, + 0x000001fau, 0x000001f9u, 0x000001edu, 0x0003003eu, 0x000001e1u, 0x000001fau, 0x000200f9u, 0x000001f8u, + 0x000200f8u, 0x000001fbu, 0x0004003du, 0x00000006u, 0x000001fcu, 0x00000025u, 0x000500b0u, 0x00000042u, + 0x000001feu, 0x000001fcu, 0x000001fdu, 0x000300f7u, 0x00000200u, 0x00000000u, 0x000400fau, 0x000001feu, + 0x000001ffu, 0x00000203u, 0x000200f8u, 0x000001ffu, 0x0003003eu, 0x000001e0u, 0x0000017au, 0x0004003du, + 0x00000006u, 0x00000201u, 0x00000025u, 0x00050082u, 0x00000006u, 0x00000202u, 0x00000201u, 0x000001f5u, + 0x0003003eu, 0x000001e1u, 0x00000202u, 0x000200f9u, 0x00000200u, 0x000200f8u, 0x00000203u, 0x0004003du, + 0x00000006u, 0x00000204u, 0x00000025u, 0x000500b0u, 0x00000042u, 0x00000206u, 0x00000204u, 0x00000205u, + 0x000300f7u, 0x00000208u, 0x00000000u, 0x000400fau, 0x00000206u, 0x00000207u, 0x0000020bu, 0x000200f8u, + 0x00000207u, 0x0003003eu, 0x000001e0u, 0x000001b2u, 0x0004003du, 0x00000006u, 0x00000209u, 0x00000025u, + 0x00050082u, 0x00000006u, 0x0000020au, 0x00000209u, 0x000001fdu, 0x0003003eu, 0x000001e1u, 0x0000020au, + 0x000200f9u, 0x00000208u, 0x000200f8u, 0x0000020bu, 0x0004003du, 0x00000006u, 0x0000020cu, 0x00000025u, + 0x000500b0u, 0x00000042u, 0x0000020eu, 0x0000020cu, 0x0000020du, 0x000300f7u, 0x00000210u, 0x00000000u, + 0x000400fau, 0x0000020eu, 0x0000020fu, 0x00000213u, 0x000200f8u, 0x0000020fu, 0x0003003eu, 0x000001e0u, + 0x00000166u, 0x0004003du, 0x00000006u, 0x00000211u, 0x00000025u, 0x00050082u, 0x00000006u, 0x00000212u, + 0x00000211u, 0x00000205u, 0x0003003eu, 0x000001e1u, 0x00000212u, 0x000200f9u, 0x00000210u, 0x000200f8u, + 0x00000213u, 0x0004003du, 0x00000006u, 0x00000214u, 0x00000025u, 0x000500b0u, 0x00000042u, 0x00000216u, + 0x00000214u, 0x00000215u, 0x000300f7u, 0x00000218u, 0x00000000u, 0x000400fau, 0x00000216u, 0x00000217u, + 0x0000021cu, 0x000200f8u, 0x00000217u, 0x0003003eu, 0x000001e0u, 0x00000219u, 0x0004003du, 0x00000006u, + 0x0000021au, 0x00000025u, 0x00050082u, 0x00000006u, 0x0000021bu, 0x0000021au, 0x0000020du, 0x0003003eu, + 0x000001e1u, 0x0000021bu, 0x000200f9u, 0x00000218u, 0x000200f8u, 0x0000021cu, 0x0003003eu, 0x000001e0u, + 0x0000021du, 0x0003003eu, 0x000001e1u, 0x00000089u, 0x000200f9u, 0x00000218u, 0x000200f8u, 0x00000218u, + 0x000200f9u, 0x00000210u, 0x000200f8u, 0x00000210u, 0x000200f9u, 0x00000208u, 0x000200f8u, 0x00000208u, + 0x000200f9u, 0x00000200u, 0x000200f8u, 0x00000200u, 0x000200f9u, 0x000001f8u, 0x000200f8u, 0x000001f8u, + 0x000200f9u, 0x000001f0u, 0x000200f8u, 0x000001f0u, 0x000200f9u, 0x000001e8u, 0x000200f8u, 0x000001e8u, + 0x000200f9u, 0x000001dfu, 0x000200f8u, 0x000001dfu, 0x0004003du, 0x00000006u, 0x0000021eu, 0x000001e1u, + 0x00040070u, 0x00000009u, 0x0000021fu, 0x0000021eu, 0x00050088u, 0x00000009u, 0x00000221u, 0x0000021fu, + 0x00000220u, 0x0004003du, 0x00000006u, 0x00000222u, 0x000001e0u, 0x00040070u, 0x00000009u, 0x00000223u, + 0x00000222u, 0x00050088u, 0x00000009u, 0x00000224u, 0x00000223u, 0x00000220u, 0x00050050u, 0x00000023u, + 0x00000225u, 0x00000221u, 0x00000224u, 0x000200feu, 0x00000225u, 0x000200f8u, 0x000001b0u, 0x000100ffu, + 0x000200f8u, 0x0000019bu, 0x000100ffu, 0x000200f8u, 0x00000188u, 0x000100ffu, 0x00010038u, 0x00050036u, + 0x0000000du, 0x0000002fu, 0x00000000u, 0x0000002au, 0x00030037u, 0x0000000eu, 0x0000002bu, 0x00030037u, + 0x0000000eu, 0x0000002cu, 0x00030037u, 0x0000000eu, 0x0000002du, 0x00030037u, 0x00000029u, 0x0000002eu, + 0x000200f8u, 0x00000030u, 0x0004003bu, 0x00000037u, 0x00000228u, 0x00000007u, 0x00050041u, 0x00000037u, + 0x00000229u, 0x0000002eu, 0x00000089u, 0x0004003du, 0x00000009u, 0x0000022au, 0x00000229u, 0x00050083u, + 0x00000009u, 0x0000022bu, 0x0000004au, 0x0000022au, 0x00050041u, 0x00000037u, 0x0000022cu, 0x0000002eu, + 0x00000008u, 0x0004003du, 0x00000009u, 0x0000022du, 0x0000022cu, 0x00050083u, 0x00000009u, 0x0000022eu, + 0x0000022bu, 0x0000022du, 0x0003003eu, 0x00000228u, 0x0000022eu, 0x0004003du, 0x0000000du, 0x0000022fu, + 0x0000002bu, 0x0004003du, 0x00000009u, 0x00000230u, 0x00000228u, 0x0005008eu, 0x0000000du, 0x00000231u, + 0x0000022fu, 0x00000230u, 0x0004003du, 0x0000000du, 0x00000232u, 0x0000002cu, 0x00050041u, 0x00000037u, + 0x00000233u, 0x0000002eu, 0x00000089u, 0x0004003du, 0x00000009u, 0x00000234u, 0x00000233u, 0x0005008eu, + 0x0000000du, 0x00000235u, 0x00000232u, 0x00000234u, 0x00050081u, 0x0000000du, 0x00000236u, 0x00000231u, + 0x00000235u, 0x0004003du, 0x0000000du, 0x00000237u, 0x0000002du, 0x00050041u, 0x00000037u, 0x00000238u, + 0x0000002eu, 0x00000008u, 0x0004003du, 0x00000009u, 0x00000239u, 0x00000238u, 0x0005008eu, 0x0000000du, + 0x0000023au, 0x00000237u, 0x00000239u, 0x00050081u, 0x0000000du, 0x0000023bu, 0x00000236u, 0x0000023au, + 0x000200feu, 0x0000023bu, 0x00010038u, 0x00050036u, 0x00000031u, 0x00000035u, 0x00000000u, 0x00000032u, + 0x00030037u, 0x0000001bu, 0x00000033u, 0x00030037u, 0x0000001bu, 0x00000034u, 0x000200f8u, 0x00000036u, + 0x0004003bu, 0x0000024au, 0x0000024bu, 0x00000007u, 0x0004003bu, 0x0000025fu, 0x00000260u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000262u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000264u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000265u, 0x00000007u, 0x0004003bu, 0x00000266u, 0x00000267u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x0000027bu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000028bu, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x0000029bu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000002a1u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000002a8u, 0x00000007u, 0x0004003bu, 0x000002cau, 0x000002cbu, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000002cdu, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000002cfu, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000002d0u, 0x00000007u, 0x0004003bu, 0x00000266u, 0x000002d1u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x000002e4u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x000002f4u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000305u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000316u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000327u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x00000338u, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000348u, 0x00000007u, 0x0004003bu, 0x0000001bu, 0x0000034eu, 0x00000007u, + 0x0004003bu, 0x0000001bu, 0x00000355u, 0x00000007u, 0x0004003du, 0x00000006u, 0x0000023eu, 0x00000034u, + 0x000500aau, 0x00000042u, 0x0000023fu, 0x0000023eu, 0x00000089u, 0x000300f7u, 0x00000241u, 0x00000000u, + 0x000400fau, 0x0000023fu, 0x00000240u, 0x00000244u, 0x000200f8u, 0x00000240u, 0x000200feu, 0x00000242u, + 0x000200f8u, 0x00000244u, 0x0004003du, 0x00000006u, 0x00000245u, 0x00000034u, 0x000500aau, 0x00000042u, + 0x00000246u, 0x00000245u, 0x00000008u, 0x000300f7u, 0x00000248u, 0x00000000u, 0x000400fau, 0x00000246u, + 0x00000247u, 0x00000259u, 0x000200f8u, 0x00000247u, 0x00050041u, 0x0000024du, 0x0000024eu, 0x0000024bu, + 0x0000005fu, 0x0003003eu, 0x0000024eu, 0x0000024cu, 0x00050041u, 0x0000024du, 0x00000250u, 0x0000024bu, + 0x00000127u, 0x0003003eu, 0x00000250u, 0x0000024fu, 0x00050041u, 0x0000024du, 0x00000252u, 0x0000024bu, + 0x0000008eu, 0x0003003eu, 0x00000252u, 0x00000251u, 0x00050041u, 0x0000024du, 0x00000254u, 0x0000024bu, + 0x0000009au, 0x0003003eu, 0x00000254u, 0x00000253u, 0x0004003du, 0x00000006u, 0x00000255u, 0x00000033u, + 0x00050041u, 0x0000024du, 0x00000256u, 0x0000024bu, 0x00000255u, 0x0004003du, 0x00000031u, 0x00000257u, + 0x00000256u, 0x000200feu, 0x00000257u, 0x000200f8u, 0x00000259u, 0x0004003du, 0x00000006u, 0x0000025au, + 0x00000034u, 0x000500aau, 0x00000042u, 0x0000025bu, 0x0000025au, 0x0000006bu, 0x000300f7u, 0x0000025du, + 0x00000000u, 0x000400fau, 0x0000025bu, 0x0000025cu, 0x000002c8u, 0x000200f8u, 0x0000025cu, 0x0003003eu, + 0x00000260u, 0x00000261u, 0x0004003du, 0x00000006u, 0x00000263u, 0x00000033u, 0x0003003eu, 0x00000262u, + 0x00000263u, 0x0003003eu, 0x00000264u, 0x00000089u, 0x0003003eu, 0x00000265u, 0x00000089u, 0x0003003eu, + 0x00000267u, 0x00000268u, 0x0004003du, 0x00000006u, 0x00000269u, 0x00000262u, 0x000500b0u, 0x00000042u, + 0x0000026au, 0x00000269u, 0x00000219u, 0x000300f7u, 0x0000026cu, 0x00000000u, 0x000400fau, 0x0000026au, + 0x0000026bu, 0x00000276u, 0x000200f8u, 0x0000026bu, 0x0003003eu, 0x00000264u, 0x00000089u, 0x0004003du, + 0x00000006u, 0x0000026du, 0x00000262u, 0x000500b0u, 0x00000042u, 0x0000026eu, 0x0000026du, 0x0000017au, + 0x000300f7u, 0x00000270u, 0x00000000u, 0x000400fau, 0x0000026eu, 0x0000026fu, 0x00000272u, 0x000200f8u, + 0x0000026fu, 0x0004003du, 0x00000006u, 0x00000271u, 0x00000262u, 0x0003003eu, 0x00000265u, 0x00000271u, + 0x0003003eu, 0x00000267u, 0x00000268u, 0x000200f9u, 0x00000270u, 0x000200f8u, 0x00000272u, 0x0004003du, + 0x00000006u, 0x00000273u, 0x00000262u, 0x00050082u, 0x00000006u, 0x00000274u, 0x00000273u, 0x0000017au, + 0x0003003eu, 0x00000265u, 0x00000274u, 0x0003003eu, 0x00000267u, 0x00000275u, 0x000200f9u, 0x00000270u, + 0x000200f8u, 0x00000270u, 0x000200f9u, 0x0000026cu, 0x000200f8u, 0x00000276u, 0x0004003du, 0x00000006u, + 0x00000277u, 0x00000262u, 0x000500b0u, 0x00000042u, 0x00000278u, 0x00000277u, 0x000001c3u, 0x000300f7u, + 0x0000027au, 0x00000000u, 0x000400fau, 0x00000278u, 0x00000279u, 0x00000286u, 0x000200f8u, 0x00000279u, + 0x0003003eu, 0x00000264u, 0x00000008u, 0x0004003du, 0x00000006u, 0x0000027cu, 0x00000262u, 0x00050082u, + 0x00000006u, 0x0000027du, 0x0000027cu, 0x00000219u, 0x0003003eu, 0x0000027bu, 0x0000027du, 0x0004003du, + 0x00000006u, 0x0000027eu, 0x0000027bu, 0x000500b0u, 0x00000042u, 0x0000027fu, 0x0000027eu, 0x00000160u, + 0x000300f7u, 0x00000281u, 0x00000000u, 0x000400fau, 0x0000027fu, 0x00000280u, 0x00000283u, 0x000200f8u, + 0x00000280u, 0x0004003du, 0x00000006u, 0x00000282u, 0x0000027bu, 0x0003003eu, 0x00000265u, 0x00000282u, + 0x0003003eu, 0x00000267u, 0x00000268u, 0x000200f9u, 0x00000281u, 0x000200f8u, 0x00000283u, 0x0004003du, + 0x00000006u, 0x00000284u, 0x0000027bu, 0x00050082u, 0x00000006u, 0x00000285u, 0x00000284u, 0x00000160u, + 0x0003003eu, 0x00000265u, 0x00000285u, 0x0003003eu, 0x00000267u, 0x00000275u, 0x000200f9u, 0x00000281u, + 0x000200f8u, 0x00000281u, 0x000200f9u, 0x0000027au, 0x000200f8u, 0x00000286u, 0x0004003du, 0x00000006u, + 0x00000287u, 0x00000262u, 0x000500b0u, 0x00000042u, 0x00000288u, 0x00000287u, 0x0000016cu, 0x000300f7u, + 0x0000028au, 0x00000000u, 0x000400fau, 0x00000288u, 0x00000289u, 0x00000296u, 0x000200f8u, 0x00000289u, + 0x0003003eu, 0x00000264u, 0x0000006bu, 0x0004003du, 0x00000006u, 0x0000028cu, 0x00000262u, 0x00050082u, + 0x00000006u, 0x0000028du, 0x0000028cu, 0x000001c3u, 0x0003003eu, 0x0000028bu, 0x0000028du, 0x0004003du, + 0x00000006u, 0x0000028eu, 0x0000028bu, 0x000500b0u, 0x00000042u, 0x0000028fu, 0x0000028eu, 0x0000006bu, + 0x000300f7u, 0x00000291u, 0x00000000u, 0x000400fau, 0x0000028fu, 0x00000290u, 0x00000293u, 0x000200f8u, + 0x00000290u, 0x0004003du, 0x00000006u, 0x00000292u, 0x0000028bu, 0x0003003eu, 0x00000265u, 0x00000292u, + 0x0003003eu, 0x00000267u, 0x00000268u, 0x000200f9u, 0x00000291u, 0x000200f8u, 0x00000293u, 0x0004003du, + 0x00000006u, 0x00000294u, 0x0000028bu, 0x00050082u, 0x00000006u, 0x00000295u, 0x00000294u, 0x0000006bu, + 0x0003003eu, 0x00000265u, 0x00000295u, 0x0003003eu, 0x00000267u, 0x00000275u, 0x000200f9u, 0x00000291u, + 0x000200f8u, 0x00000291u, 0x000200f9u, 0x0000028au, 0x000200f8u, 0x00000296u, 0x0003003eu, 0x00000264u, + 0x00000160u, 0x0003003eu, 0x00000265u, 0x00000089u, 0x0003003eu, 0x00000267u, 0x00000268u, 0x000200f9u, + 0x0000028au, 0x000200f8u, 0x0000028au, 0x000200f9u, 0x0000027au, 0x000200f8u, 0x0000027au, 0x000200f9u, + 0x0000026cu, 0x000200f8u, 0x0000026cu, 0x0004003du, 0x00000042u, 0x00000297u, 0x00000267u, 0x000400a8u, + 0x00000042u, 0x00000298u, 0x00000297u, 0x000300f7u, 0x0000029au, 0x00000000u, 0x000400fau, 0x00000298u, + 0x00000299u, 0x000002afu, 0x000200f8u, 0x00000299u, 0x0004003du, 0x00000006u, 0x0000029cu, 0x00000264u, + 0x00050041u, 0x0000001bu, 0x0000029du, 0x00000260u, 0x0000029cu, 0x0004003du, 0x00000006u, 0x0000029eu, + 0x0000029du, 0x0004003du, 0x00000006u, 0x0000029fu, 0x00000265u, 0x00050080u, 0x00000006u, 0x000002a0u, + 0x0000029eu, 0x0000029fu, 0x0003003eu, 0x0000029bu, 0x000002a0u, 0x0004003du, 0x00000006u, 0x000002a2u, + 0x00000264u, 0x00050041u, 0x0000001bu, 0x000002a3u, 0x00000260u, 0x000002a2u, 0x0004003du, 0x00000006u, + 0x000002a4u, 0x000002a3u, 0x0004003du, 0x00000006u, 0x000002a5u, 0x00000265u, 0x00050080u, 0x00000006u, + 0x000002a6u, 0x000002a4u, 0x000002a5u, 0x00050080u, 0x00000006u, 0x000002a7u, 0x000002a6u, 0x00000008u, + 0x0003003eu, 0x000002a1u, 0x000002a7u, 0x0004003du, 0x00000006u, 0x000002a9u, 0x00000264u, 0x00050080u, + 0x00000006u, 0x000002aau, 0x000002a9u, 0x00000008u, 0x00050041u, 0x0000001bu, 0x000002abu, 0x00000260u, + 0x000002aau, 0x0004003du, 0x00000006u, 0x000002acu, 0x000002abu, 0x0004003du, 0x00000006u, 0x000002adu, + 0x00000265u, 0x00050080u, 0x00000006u, 0x000002aeu, 0x000002acu, 0x000002adu, 0x0003003eu, 0x000002a8u, + 0x000002aeu, 0x000200f9u, 0x0000029au, 0x000200f8u, 0x000002afu, 0x0004003du, 0x00000006u, 0x000002b0u, + 0x00000264u, 0x00050041u, 0x0000001bu, 0x000002b1u, 0x00000260u, 0x000002b0u, 0x0004003du, 0x00000006u, + 0x000002b2u, 0x000002b1u, 0x0004003du, 0x00000006u, 0x000002b3u, 0x00000265u, 0x00050080u, 0x00000006u, + 0x000002b4u, 0x000002b2u, 0x000002b3u, 0x00050080u, 0x00000006u, 0x000002b5u, 0x000002b4u, 0x00000008u, + 0x0003003eu, 0x0000029bu, 0x000002b5u, 0x0004003du, 0x00000006u, 0x000002b6u, 0x00000264u, 0x00050080u, + 0x00000006u, 0x000002b7u, 0x000002b6u, 0x00000008u, 0x00050041u, 0x0000001bu, 0x000002b8u, 0x00000260u, + 0x000002b7u, 0x0004003du, 0x00000006u, 0x000002b9u, 0x000002b8u, 0x0004003du, 0x00000006u, 0x000002bau, + 0x00000265u, 0x00050080u, 0x00000006u, 0x000002bbu, 0x000002b9u, 0x000002bau, 0x00050080u, 0x00000006u, + 0x000002bcu, 0x000002bbu, 0x00000008u, 0x0003003eu, 0x000002a1u, 0x000002bcu, 0x0004003du, 0x00000006u, + 0x000002bdu, 0x00000264u, 0x00050080u, 0x00000006u, 0x000002beu, 0x000002bdu, 0x00000008u, 0x00050041u, + 0x0000001bu, 0x000002bfu, 0x00000260u, 0x000002beu, 0x0004003du, 0x00000006u, 0x000002c0u, 0x000002bfu, + 0x0004003du, 0x00000006u, 0x000002c1u, 0x00000265u, 0x00050080u, 0x00000006u, 0x000002c2u, 0x000002c0u, + 0x000002c1u, 0x0003003eu, 0x000002a8u, 0x000002c2u, 0x000200f9u, 0x0000029au, 0x000200f8u, 0x0000029au, + 0x0004003du, 0x00000006u, 0x000002c3u, 0x0000029bu, 0x0004003du, 0x00000006u, 0x000002c4u, 0x000002a1u, + 0x0004003du, 0x00000006u, 0x000002c5u, 0x000002a8u, 0x00060050u, 0x00000031u, 0x000002c6u, 0x000002c3u, + 0x000002c4u, 0x000002c5u, 0x000200feu, 0x000002c6u, 0x000200f8u, 0x000002c8u, 0x0003003eu, 0x000002cbu, + 0x000002ccu, 0x0004003du, 0x00000006u, 0x000002ceu, 0x00000033u, 0x0003003eu, 0x000002cdu, 0x000002ceu, + 0x0003003eu, 0x000002cfu, 0x00000089u, 0x0003003eu, 0x000002d0u, 0x00000089u, 0x0003003eu, 0x000002d1u, + 0x00000268u, 0x0004003du, 0x00000006u, 0x000002d2u, 0x000002cdu, 0x000500b0u, 0x00000042u, 0x000002d3u, + 0x000002d2u, 0x0000016cu, 0x000300f7u, 0x000002d5u, 0x00000000u, 0x000400fau, 0x000002d3u, 0x000002d4u, + 0x000002deu, 0x000200f8u, 0x000002d4u, 0x0003003eu, 0x000002cfu, 0x00000089u, 0x0004003du, 0x00000006u, + 0x000002d6u, 0x000002cdu, 0x000500b0u, 0x00000042u, 0x000002d7u, 0x000002d6u, 0x0000021du, 0x000300f7u, + 0x000002d9u, 0x00000000u, 0x000400fau, 0x000002d7u, 0x000002d8u, 0x000002dbu, 0x000200f8u, 0x000002d8u, + 0x0004003du, 0x00000006u, 0x000002dau, 0x000002cdu, 0x0003003eu, 0x000002d0u, 0x000002dau, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x000002d9u, 0x000200f8u, 0x000002dbu, 0x0004003du, 0x00000006u, + 0x000002dcu, 0x000002cdu, 0x00050082u, 0x00000006u, 0x000002ddu, 0x000002dcu, 0x0000021du, 0x0003003eu, + 0x000002d0u, 0x000002ddu, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x000002d9u, 0x000200f8u, + 0x000002d9u, 0x000200f9u, 0x000002d5u, 0x000200f8u, 0x000002deu, 0x0004003du, 0x00000006u, 0x000002dfu, + 0x000002cdu, 0x000500b0u, 0x00000042u, 0x000002e1u, 0x000002dfu, 0x000002e0u, 0x000300f7u, 0x000002e3u, + 0x00000000u, 0x000400fau, 0x000002e1u, 0x000002e2u, 0x000002efu, 0x000200f8u, 0x000002e2u, 0x0003003eu, + 0x000002cfu, 0x00000008u, 0x0004003du, 0x00000006u, 0x000002e5u, 0x000002cdu, 0x00050082u, 0x00000006u, + 0x000002e6u, 0x000002e5u, 0x0000016cu, 0x0003003eu, 0x000002e4u, 0x000002e6u, 0x0004003du, 0x00000006u, + 0x000002e7u, 0x000002e4u, 0x000500b0u, 0x00000042u, 0x000002e8u, 0x000002e7u, 0x00000219u, 0x000300f7u, + 0x000002eau, 0x00000000u, 0x000400fau, 0x000002e8u, 0x000002e9u, 0x000002ecu, 0x000200f8u, 0x000002e9u, + 0x0004003du, 0x00000006u, 0x000002ebu, 0x000002e4u, 0x0003003eu, 0x000002d0u, 0x000002ebu, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x000002eau, 0x000200f8u, 0x000002ecu, 0x0004003du, 0x00000006u, + 0x000002edu, 0x000002e4u, 0x00050082u, 0x00000006u, 0x000002eeu, 0x000002edu, 0x00000219u, 0x0003003eu, + 0x000002d0u, 0x000002eeu, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x000002eau, 0x000200f8u, + 0x000002eau, 0x000200f9u, 0x000002e3u, 0x000200f8u, 0x000002efu, 0x0004003du, 0x00000006u, 0x000002f0u, + 0x000002cdu, 0x000500b0u, 0x00000042u, 0x000002f1u, 0x000002f0u, 0x00000205u, 0x000300f7u, 0x000002f3u, + 0x00000000u, 0x000400fau, 0x000002f1u, 0x000002f2u, 0x000002ffu, 0x000200f8u, 0x000002f2u, 0x0003003eu, + 0x000002cfu, 0x0000006bu, 0x0004003du, 0x00000006u, 0x000002f5u, 0x000002cdu, 0x00050082u, 0x00000006u, + 0x000002f6u, 0x000002f5u, 0x000002e0u, 0x0003003eu, 0x000002f4u, 0x000002f6u, 0x0004003du, 0x00000006u, + 0x000002f7u, 0x000002f4u, 0x000500b0u, 0x00000042u, 0x000002f8u, 0x000002f7u, 0x00000166u, 0x000300f7u, + 0x000002fau, 0x00000000u, 0x000400fau, 0x000002f8u, 0x000002f9u, 0x000002fcu, 0x000200f8u, 0x000002f9u, + 0x0004003du, 0x00000006u, 0x000002fbu, 0x000002f4u, 0x0003003eu, 0x000002d0u, 0x000002fbu, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x000002fau, 0x000200f8u, 0x000002fcu, 0x0004003du, 0x00000006u, + 0x000002fdu, 0x000002f4u, 0x00050082u, 0x00000006u, 0x000002feu, 0x000002fdu, 0x00000166u, 0x0003003eu, + 0x000002d0u, 0x000002feu, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x000002fau, 0x000200f8u, + 0x000002fau, 0x000200f9u, 0x000002f3u, 0x000200f8u, 0x000002ffu, 0x0004003du, 0x00000006u, 0x00000300u, + 0x000002cdu, 0x000500b0u, 0x00000042u, 0x00000302u, 0x00000300u, 0x00000301u, 0x000300f7u, 0x00000304u, + 0x00000000u, 0x000400fau, 0x00000302u, 0x00000303u, 0x00000310u, 0x000200f8u, 0x00000303u, 0x0003003eu, + 0x000002cfu, 0x00000160u, 0x0004003du, 0x00000006u, 0x00000306u, 0x000002cdu, 0x00050082u, 0x00000006u, + 0x00000307u, 0x00000306u, 0x00000205u, 0x0003003eu, 0x00000305u, 0x00000307u, 0x0004003du, 0x00000006u, + 0x00000308u, 0x00000305u, 0x000500b0u, 0x00000042u, 0x00000309u, 0x00000308u, 0x000001b2u, 0x000300f7u, + 0x0000030bu, 0x00000000u, 0x000400fau, 0x00000309u, 0x0000030au, 0x0000030du, 0x000200f8u, 0x0000030au, + 0x0004003du, 0x00000006u, 0x0000030cu, 0x00000305u, 0x0003003eu, 0x000002d0u, 0x0000030cu, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x0000030bu, 0x000200f8u, 0x0000030du, 0x0004003du, 0x00000006u, + 0x0000030eu, 0x00000305u, 0x00050082u, 0x00000006u, 0x0000030fu, 0x0000030eu, 0x000001b2u, 0x0003003eu, + 0x000002d0u, 0x0000030fu, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x0000030bu, 0x000200f8u, + 0x0000030bu, 0x000200f9u, 0x00000304u, 0x000200f8u, 0x00000310u, 0x0004003du, 0x00000006u, 0x00000311u, + 0x000002cdu, 0x000500b0u, 0x00000042u, 0x00000313u, 0x00000311u, 0x00000312u, 0x000300f7u, 0x00000315u, + 0x00000000u, 0x000400fau, 0x00000313u, 0x00000314u, 0x00000321u, 0x000200f8u, 0x00000314u, 0x0003003eu, + 0x000002cfu, 0x0000017au, 0x0004003du, 0x00000006u, 0x00000317u, 0x000002cdu, 0x00050082u, 0x00000006u, + 0x00000318u, 0x00000317u, 0x00000301u, 0x0003003eu, 0x00000316u, 0x00000318u, 0x0004003du, 0x00000006u, + 0x00000319u, 0x00000316u, 0x000500b0u, 0x00000042u, 0x0000031au, 0x00000319u, 0x0000017au, 0x000300f7u, + 0x0000031cu, 0x00000000u, 0x000400fau, 0x0000031au, 0x0000031bu, 0x0000031eu, 0x000200f8u, 0x0000031bu, + 0x0004003du, 0x00000006u, 0x0000031du, 0x00000316u, 0x0003003eu, 0x000002d0u, 0x0000031du, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x0000031cu, 0x000200f8u, 0x0000031eu, 0x0004003du, 0x00000006u, + 0x0000031fu, 0x00000316u, 0x00050082u, 0x00000006u, 0x00000320u, 0x0000031fu, 0x0000017au, 0x0003003eu, + 0x000002d0u, 0x00000320u, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x0000031cu, 0x000200f8u, + 0x0000031cu, 0x000200f9u, 0x00000315u, 0x000200f8u, 0x00000321u, 0x0004003du, 0x00000006u, 0x00000322u, + 0x000002cdu, 0x000500b0u, 0x00000042u, 0x00000324u, 0x00000322u, 0x00000323u, 0x000300f7u, 0x00000326u, + 0x00000000u, 0x000400fau, 0x00000324u, 0x00000325u, 0x00000332u, 0x000200f8u, 0x00000325u, 0x0003003eu, + 0x000002cfu, 0x000001b2u, 0x0004003du, 0x00000006u, 0x00000328u, 0x000002cdu, 0x00050082u, 0x00000006u, + 0x00000329u, 0x00000328u, 0x00000312u, 0x0003003eu, 0x00000327u, 0x00000329u, 0x0004003du, 0x00000006u, + 0x0000032au, 0x00000327u, 0x000500b0u, 0x00000042u, 0x0000032bu, 0x0000032au, 0x00000160u, 0x000300f7u, + 0x0000032du, 0x00000000u, 0x000400fau, 0x0000032bu, 0x0000032cu, 0x0000032fu, 0x000200f8u, 0x0000032cu, + 0x0004003du, 0x00000006u, 0x0000032eu, 0x00000327u, 0x0003003eu, 0x000002d0u, 0x0000032eu, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x0000032du, 0x000200f8u, 0x0000032fu, 0x0004003du, 0x00000006u, + 0x00000330u, 0x00000327u, 0x00050082u, 0x00000006u, 0x00000331u, 0x00000330u, 0x00000160u, 0x0003003eu, + 0x000002d0u, 0x00000331u, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x0000032du, 0x000200f8u, + 0x0000032du, 0x000200f9u, 0x00000326u, 0x000200f8u, 0x00000332u, 0x0004003du, 0x00000006u, 0x00000333u, + 0x000002cdu, 0x000500b0u, 0x00000042u, 0x00000335u, 0x00000333u, 0x00000334u, 0x000300f7u, 0x00000337u, + 0x00000000u, 0x000400fau, 0x00000335u, 0x00000336u, 0x00000343u, 0x000200f8u, 0x00000336u, 0x0003003eu, + 0x000002cfu, 0x00000166u, 0x0004003du, 0x00000006u, 0x00000339u, 0x000002cdu, 0x00050082u, 0x00000006u, + 0x0000033au, 0x00000339u, 0x00000323u, 0x0003003eu, 0x00000338u, 0x0000033au, 0x0004003du, 0x00000006u, + 0x0000033bu, 0x00000338u, 0x000500b0u, 0x00000042u, 0x0000033cu, 0x0000033bu, 0x0000006bu, 0x000300f7u, + 0x0000033eu, 0x00000000u, 0x000400fau, 0x0000033cu, 0x0000033du, 0x00000340u, 0x000200f8u, 0x0000033du, + 0x0004003du, 0x00000006u, 0x0000033fu, 0x00000338u, 0x0003003eu, 0x000002d0u, 0x0000033fu, 0x0003003eu, + 0x000002d1u, 0x00000268u, 0x000200f9u, 0x0000033eu, 0x000200f8u, 0x00000340u, 0x0004003du, 0x00000006u, + 0x00000341u, 0x00000338u, 0x00050082u, 0x00000006u, 0x00000342u, 0x00000341u, 0x0000006bu, 0x0003003eu, + 0x000002d0u, 0x00000342u, 0x0003003eu, 0x000002d1u, 0x00000275u, 0x000200f9u, 0x0000033eu, 0x000200f8u, + 0x0000033eu, 0x000200f9u, 0x00000337u, 0x000200f8u, 0x00000343u, 0x0003003eu, 0x000002cfu, 0x00000219u, + 0x0003003eu, 0x000002d0u, 0x00000089u, 0x0003003eu, 0x000002d1u, 0x00000268u, 0x000200f9u, 0x00000337u, + 0x000200f8u, 0x00000337u, 0x000200f9u, 0x00000326u, 0x000200f8u, 0x00000326u, 0x000200f9u, 0x00000315u, + 0x000200f8u, 0x00000315u, 0x000200f9u, 0x00000304u, 0x000200f8u, 0x00000304u, 0x000200f9u, 0x000002f3u, + 0x000200f8u, 0x000002f3u, 0x000200f9u, 0x000002e3u, 0x000200f8u, 0x000002e3u, 0x000200f9u, 0x000002d5u, + 0x000200f8u, 0x000002d5u, 0x0004003du, 0x00000042u, 0x00000344u, 0x000002d1u, 0x000400a8u, 0x00000042u, + 0x00000345u, 0x00000344u, 0x000300f7u, 0x00000347u, 0x00000000u, 0x000400fau, 0x00000345u, 0x00000346u, + 0x0000035cu, 0x000200f8u, 0x00000346u, 0x0004003du, 0x00000006u, 0x00000349u, 0x000002cfu, 0x00050041u, + 0x0000001bu, 0x0000034au, 0x000002cbu, 0x00000349u, 0x0004003du, 0x00000006u, 0x0000034bu, 0x0000034au, + 0x0004003du, 0x00000006u, 0x0000034cu, 0x000002d0u, 0x00050080u, 0x00000006u, 0x0000034du, 0x0000034bu, + 0x0000034cu, 0x0003003eu, 0x00000348u, 0x0000034du, 0x0004003du, 0x00000006u, 0x0000034fu, 0x000002cfu, + 0x00050041u, 0x0000001bu, 0x00000350u, 0x000002cbu, 0x0000034fu, 0x0004003du, 0x00000006u, 0x00000351u, + 0x00000350u, 0x0004003du, 0x00000006u, 0x00000352u, 0x000002d0u, 0x00050080u, 0x00000006u, 0x00000353u, + 0x00000351u, 0x00000352u, 0x00050080u, 0x00000006u, 0x00000354u, 0x00000353u, 0x00000008u, 0x0003003eu, + 0x0000034eu, 0x00000354u, 0x0004003du, 0x00000006u, 0x00000356u, 0x000002cfu, 0x00050080u, 0x00000006u, + 0x00000357u, 0x00000356u, 0x00000008u, 0x00050041u, 0x0000001bu, 0x00000358u, 0x000002cbu, 0x00000357u, + 0x0004003du, 0x00000006u, 0x00000359u, 0x00000358u, 0x0004003du, 0x00000006u, 0x0000035au, 0x000002d0u, + 0x00050080u, 0x00000006u, 0x0000035bu, 0x00000359u, 0x0000035au, 0x0003003eu, 0x00000355u, 0x0000035bu, + 0x000200f9u, 0x00000347u, 0x000200f8u, 0x0000035cu, 0x0004003du, 0x00000006u, 0x0000035du, 0x000002cfu, + 0x00050041u, 0x0000001bu, 0x0000035eu, 0x000002cbu, 0x0000035du, 0x0004003du, 0x00000006u, 0x0000035fu, + 0x0000035eu, 0x0004003du, 0x00000006u, 0x00000360u, 0x000002d0u, 0x00050080u, 0x00000006u, 0x00000361u, + 0x0000035fu, 0x00000360u, 0x00050080u, 0x00000006u, 0x00000362u, 0x00000361u, 0x00000008u, 0x0003003eu, + 0x00000348u, 0x00000362u, 0x0004003du, 0x00000006u, 0x00000363u, 0x000002cfu, 0x00050080u, 0x00000006u, + 0x00000364u, 0x00000363u, 0x00000008u, 0x00050041u, 0x0000001bu, 0x00000365u, 0x000002cbu, 0x00000364u, + 0x0004003du, 0x00000006u, 0x00000366u, 0x00000365u, 0x0004003du, 0x00000006u, 0x00000367u, 0x000002d0u, + 0x00050080u, 0x00000006u, 0x00000368u, 0x00000366u, 0x00000367u, 0x00050080u, 0x00000006u, 0x00000369u, + 0x00000368u, 0x00000008u, 0x0003003eu, 0x0000034eu, 0x00000369u, 0x0004003du, 0x00000006u, 0x0000036au, + 0x000002cfu, 0x00050080u, 0x00000006u, 0x0000036bu, 0x0000036au, 0x00000008u, 0x00050041u, 0x0000001bu, + 0x0000036cu, 0x000002cbu, 0x0000036bu, 0x0004003du, 0x00000006u, 0x0000036du, 0x0000036cu, 0x0004003du, + 0x00000006u, 0x0000036eu, 0x000002d0u, 0x00050080u, 0x00000006u, 0x0000036fu, 0x0000036du, 0x0000036eu, + 0x0003003eu, 0x00000355u, 0x0000036fu, 0x000200f9u, 0x00000347u, 0x000200f8u, 0x00000347u, 0x0004003du, + 0x00000006u, 0x00000370u, 0x00000348u, 0x0004003du, 0x00000006u, 0x00000371u, 0x0000034eu, 0x0004003du, + 0x00000006u, 0x00000372u, 0x00000355u, 0x00060050u, 0x00000031u, 0x00000373u, 0x00000370u, 0x00000371u, + 0x00000372u, 0x000200feu, 0x00000373u, 0x000200f8u, 0x0000025du, 0x000100ffu, 0x000200f8u, 0x00000248u, + 0x000100ffu, 0x000200f8u, 0x00000241u, 0x000100ffu, 0x00010038u, +}; + +static const uint32_t kSpv_ts_obstacle_frag[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x0000004eu, 0x00000000u, 0x00020011u, 0x00000001u, 0x00020011u, + 0x000014a3u, 0x00020011u, 0x000014a4u, 0x0006000au, 0x5f565053u, 0x5f545845u, 0x6873656du, 0x6168735fu, + 0x00726564u, 0x000a000au, 0x5f565053u, 0x5f52484bu, 0x67617266u, 0x746e656du, 0x6168735fu, 0x5f726564u, + 0x79726162u, 0x746e6563u, 0x00636972u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, + 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x000a000fu, 0x00000004u, 0x00000004u, 0x6e69616du, + 0x00000000u, 0x0000000cu, 0x00000012u, 0x00000024u, 0x00000039u, 0x00000045u, 0x00030010u, 0x00000004u, + 0x00000007u, 0x00030010u, 0x00000004u, 0x00000009u, 0x00030003u, 0x00000002u, 0x000001ccu, 0x000a0004u, + 0x455f4c47u, 0x665f5458u, 0x6d676172u, 0x5f746e65u, 0x64616873u, 0x625f7265u, 0x63797261u, 0x72746e65u, + 0x00006369u, 0x00060004u, 0x455f4c47u, 0x6d5f5458u, 0x5f687365u, 0x64616873u, 0x00007265u, 0x00040005u, + 0x00000004u, 0x6e69616du, 0x00000000u, 0x00030005u, 0x00000008u, 0x00000074u, 0x00070005u, 0x0000000au, + 0x65627543u, 0x64617247u, 0x746e6569u, 0x636f6c42u, 0x0000006bu, 0x00060006u, 0x0000000au, 0x00000000u, + 0x6e726f63u, 0x745f7265u, 0x00000000u, 0x00060006u, 0x0000000au, 0x00000001u, 0x6e6f7266u, 0x6f635f74u, + 0x00726f6cu, 0x00060006u, 0x0000000au, 0x00000002u, 0x6b636162u, 0x6c6f635fu, 0x0000726fu, 0x00050006u, + 0x0000000au, 0x00000003u, 0x625f7369u, 0x00007665u, 0x00040005u, 0x0000000cu, 0x6d697270u, 0x006e695fu, + 0x00060005u, 0x00000012u, 0x425f6c67u, 0x43797261u, 0x64726f6fu, 0x00545845u, 0x00040005u, 0x00000016u, + 0x6f6c6f63u, 0x00000072u, 0x00060005u, 0x00000022u, 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, + 0x000a0006u, 0x00000022u, 0x00000000u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, + 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000022u, 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, + 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, 0x00000022u, 0x00000002u, 0x69775f75u, 0x5f687464u, + 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000022u, 0x00000003u, + 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x7665625fu, 0x00000000u, 0x00080006u, 0x00000022u, + 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, 0x6d617266u, 0x00000065u, 0x00080006u, 0x00000022u, + 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, 0x6163735fu, 0x0000656cu, 0x00070006u, 0x00000022u, + 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, 0x00676e69u, 0x00090006u, 0x00000022u, 0x00000007u, + 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x00000022u, + 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, + 0x00000022u, 0x00000009u, 0x756e5f75u, 0x75715f6du, 0x65697265u, 0x00000073u, 0x000a0006u, 0x00000022u, + 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, + 0x000a0006u, 0x00000022u, 0x0000000bu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, + 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x00000022u, 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, + 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, 0x00090006u, 0x00000022u, 0x0000000du, 0x616d5f75u, + 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, 0x00656275u, 0x00080006u, 0x00000022u, 0x0000000eu, + 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, 0x00656c61u, 0x00070006u, 0x00000022u, 0x0000000fu, + 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, 0x00070006u, 0x00000022u, 0x00000010u, 0x616d5f75u, + 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, 0x00000022u, 0x00000011u, 0x75635f75u, 0x705f6562u, + 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, 0x00000022u, 0x00000012u, 0x756e5f75u, 0x6f705f6du, + 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, 0x00000022u, 0x00000013u, 0x616d5f75u, 0x61765f78u, + 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, 0x00090006u, 0x00000022u, 0x00000014u, 0x756e5f75u, + 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00070006u, 0x00000022u, 0x00000015u, + 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, 0x00070006u, 0x00000022u, 0x00000016u, 0x756f5f75u, + 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, 0x00000024u, 0x00006370u, 0x00050005u, 0x00000035u, + 0x5f676f66u, 0x74636166u, 0x0000726fu, 0x00060005u, 0x00000039u, 0x465f6c67u, 0x43676172u, 0x64726f6fu, + 0x00000000u, 0x00050005u, 0x00000045u, 0x5f74756fu, 0x6f6c6f63u, 0x00000072u, 0x00030047u, 0x0000000au, + 0x00000002u, 0x00040048u, 0x0000000au, 0x00000000u, 0x00001497u, 0x00040048u, 0x0000000au, 0x00000001u, + 0x00001497u, 0x00040048u, 0x0000000au, 0x00000002u, 0x00001497u, 0x00040048u, 0x0000000au, 0x00000003u, + 0x00001497u, 0x00040047u, 0x0000000cu, 0x0000001eu, 0x00000000u, 0x00040047u, 0x00000012u, 0x0000000bu, + 0x000014a6u, 0x00030047u, 0x00000022u, 0x00000002u, 0x00050048u, 0x00000022u, 0x00000000u, 0x00000023u, + 0x00000000u, 0x00050048u, 0x00000022u, 0x00000001u, 0x00000023u, 0x00000004u, 0x00050048u, 0x00000022u, + 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, 0x00000022u, 0x00000003u, 0x00000023u, 0x0000000cu, + 0x00050048u, 0x00000022u, 0x00000004u, 0x00000023u, 0x00000010u, 0x00050048u, 0x00000022u, 0x00000005u, + 0x00000023u, 0x00000014u, 0x00050048u, 0x00000022u, 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, + 0x00000022u, 0x00000007u, 0x00000023u, 0x0000001cu, 0x00050048u, 0x00000022u, 0x00000008u, 0x00000023u, + 0x00000020u, 0x00050048u, 0x00000022u, 0x00000009u, 0x00000023u, 0x00000024u, 0x00050048u, 0x00000022u, + 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, 0x00000022u, 0x0000000bu, 0x00000023u, 0x0000002cu, + 0x00050048u, 0x00000022u, 0x0000000cu, 0x00000023u, 0x00000030u, 0x00050048u, 0x00000022u, 0x0000000du, + 0x00000023u, 0x00000034u, 0x00050048u, 0x00000022u, 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, + 0x00000022u, 0x0000000fu, 0x00000023u, 0x0000003cu, 0x00050048u, 0x00000022u, 0x00000010u, 0x00000023u, + 0x00000040u, 0x00050048u, 0x00000022u, 0x00000011u, 0x00000023u, 0x00000044u, 0x00050048u, 0x00000022u, + 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, 0x00000022u, 0x00000013u, 0x00000023u, 0x0000004cu, + 0x00050048u, 0x00000022u, 0x00000014u, 0x00000023u, 0x00000050u, 0x00050048u, 0x00000022u, 0x00000015u, + 0x00000023u, 0x00000054u, 0x00050048u, 0x00000022u, 0x00000016u, 0x00000023u, 0x00000058u, 0x00040047u, + 0x00000039u, 0x0000000bu, 0x0000000fu, 0x00040047u, 0x00000045u, 0x0000001eu, 0x00000000u, 0x00020013u, + 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00030016u, 0x00000006u, 0x00000020u, 0x00040020u, + 0x00000007u, 0x00000007u, 0x00000006u, 0x00040017u, 0x00000009u, 0x00000006u, 0x00000003u, 0x0006001eu, + 0x0000000au, 0x00000009u, 0x00000009u, 0x00000009u, 0x00000006u, 0x00040020u, 0x0000000bu, 0x00000001u, + 0x0000000au, 0x0004003bu, 0x0000000bu, 0x0000000cu, 0x00000001u, 0x00040015u, 0x0000000du, 0x00000020u, + 0x00000001u, 0x0004002bu, 0x0000000du, 0x0000000eu, 0x00000000u, 0x00040020u, 0x0000000fu, 0x00000001u, + 0x00000009u, 0x0004003bu, 0x0000000fu, 0x00000012u, 0x00000001u, 0x00040020u, 0x00000015u, 0x00000007u, + 0x00000009u, 0x0004002bu, 0x0000000du, 0x00000017u, 0x00000002u, 0x0004002bu, 0x0000000du, 0x0000001au, + 0x00000001u, 0x00020014u, 0x00000020u, 0x00040015u, 0x00000021u, 0x00000020u, 0x00000000u, 0x0019001eu, + 0x00000022u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x0000000du, 0x0000000du, 0x00000021u, 0x00000006u, 0x00000021u, 0x00000021u, 0x00000021u, 0x00000006u, + 0x00000006u, 0x00000021u, 0x00000021u, 0x00000021u, 0x00000021u, 0x00000021u, 0x00000021u, 0x00000021u, + 0x00040020u, 0x00000023u, 0x00000009u, 0x00000022u, 0x0004003bu, 0x00000023u, 0x00000024u, 0x00000009u, + 0x0004002bu, 0x0000000du, 0x00000025u, 0x0000000fu, 0x00040020u, 0x00000026u, 0x00000009u, 0x00000006u, + 0x0004002bu, 0x00000006u, 0x00000029u, 0x3f000000u, 0x0004002bu, 0x0000000du, 0x0000002du, 0x00000003u, + 0x00040020u, 0x0000002eu, 0x00000001u, 0x00000006u, 0x0004002bu, 0x00000006u, 0x00000036u, 0x3f800000u, + 0x00040017u, 0x00000037u, 0x00000006u, 0x00000004u, 0x00040020u, 0x00000038u, 0x00000001u, 0x00000037u, + 0x0004003bu, 0x00000038u, 0x00000039u, 0x00000001u, 0x0004002bu, 0x00000021u, 0x0000003au, 0x00000002u, + 0x0004002bu, 0x00000006u, 0x0000003fu, 0x00000000u, 0x00040020u, 0x00000044u, 0x00000003u, 0x00000037u, + 0x0004003bu, 0x00000044u, 0x00000045u, 0x00000003u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, + 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000007u, 0x00000008u, 0x00000007u, 0x0004003bu, + 0x00000015u, 0x00000016u, 0x00000007u, 0x0004003bu, 0x00000007u, 0x00000035u, 0x00000007u, 0x00050041u, + 0x0000000fu, 0x00000010u, 0x0000000cu, 0x0000000eu, 0x0004003du, 0x00000009u, 0x00000011u, 0x00000010u, + 0x0004003du, 0x00000009u, 0x00000013u, 0x00000012u, 0x00050094u, 0x00000006u, 0x00000014u, 0x00000011u, + 0x00000013u, 0x0003003eu, 0x00000008u, 0x00000014u, 0x00050041u, 0x0000000fu, 0x00000018u, 0x0000000cu, + 0x00000017u, 0x0004003du, 0x00000009u, 0x00000019u, 0x00000018u, 0x00050041u, 0x0000000fu, 0x0000001bu, + 0x0000000cu, 0x0000001au, 0x0004003du, 0x00000009u, 0x0000001cu, 0x0000001bu, 0x0004003du, 0x00000006u, + 0x0000001du, 0x00000008u, 0x00060050u, 0x00000009u, 0x0000001eu, 0x0000001du, 0x0000001du, 0x0000001du, + 0x0008000cu, 0x00000009u, 0x0000001fu, 0x00000001u, 0x0000002eu, 0x00000019u, 0x0000001cu, 0x0000001eu, + 0x0003003eu, 0x00000016u, 0x0000001fu, 0x00050041u, 0x00000026u, 0x00000027u, 0x00000024u, 0x00000025u, + 0x0004003du, 0x00000006u, 0x00000028u, 0x00000027u, 0x000500bau, 0x00000020u, 0x0000002au, 0x00000028u, + 0x00000029u, 0x000300f7u, 0x0000002cu, 0x00000000u, 0x000400fau, 0x0000002au, 0x0000002bu, 0x0000002cu, + 0x000200f8u, 0x0000002bu, 0x00050041u, 0x0000002eu, 0x0000002fu, 0x0000000cu, 0x0000002du, 0x0004003du, + 0x00000006u, 0x00000030u, 0x0000002fu, 0x000500b8u, 0x00000020u, 0x00000031u, 0x00000030u, 0x00000029u, + 0x000200f9u, 0x0000002cu, 0x000200f8u, 0x0000002cu, 0x000700f5u, 0x00000020u, 0x00000032u, 0x0000002au, + 0x00000005u, 0x00000031u, 0x0000002bu, 0x000300f7u, 0x00000034u, 0x00000000u, 0x000400fau, 0x00000032u, + 0x00000033u, 0x00000034u, 0x000200f8u, 0x00000033u, 0x00050041u, 0x0000002eu, 0x0000003bu, 0x00000039u, + 0x0000003au, 0x0004003du, 0x00000006u, 0x0000003cu, 0x0000003bu, 0x00050083u, 0x00000006u, 0x0000003du, + 0x00000036u, 0x0000003cu, 0x0003003eu, 0x00000035u, 0x0000003du, 0x0004003du, 0x00000006u, 0x0000003eu, + 0x00000035u, 0x0008000cu, 0x00000006u, 0x00000040u, 0x00000001u, 0x0000002bu, 0x0000003eu, 0x0000003fu, + 0x00000036u, 0x0003003eu, 0x00000035u, 0x00000040u, 0x0004003du, 0x00000006u, 0x00000041u, 0x00000035u, + 0x0004003du, 0x00000009u, 0x00000042u, 0x00000016u, 0x0005008eu, 0x00000009u, 0x00000043u, 0x00000042u, + 0x00000041u, 0x0003003eu, 0x00000016u, 0x00000043u, 0x000200f9u, 0x00000034u, 0x000200f8u, 0x00000034u, + 0x0004003du, 0x00000009u, 0x00000046u, 0x00000016u, 0x00060050u, 0x00000009u, 0x00000047u, 0x0000003fu, + 0x0000003fu, 0x0000003fu, 0x00060050u, 0x00000009u, 0x00000048u, 0x00000036u, 0x00000036u, 0x00000036u, + 0x0008000cu, 0x00000009u, 0x00000049u, 0x00000001u, 0x0000002bu, 0x00000046u, 0x00000047u, 0x00000048u, + 0x00050051u, 0x00000006u, 0x0000004au, 0x00000049u, 0x00000000u, 0x00050051u, 0x00000006u, 0x0000004bu, + 0x00000049u, 0x00000001u, 0x00050051u, 0x00000006u, 0x0000004cu, 0x00000049u, 0x00000002u, 0x00070050u, + 0x00000037u, 0x0000004du, 0x0000004au, 0x0000004bu, 0x0000004cu, 0x00000036u, 0x0003003eu, 0x00000045u, + 0x0000004du, 0x000100fdu, 0x00010038u, +}; + +static const uint32_t kSpv_ts_export_comp[] = { + 0x07230203u, 0x00010600u, 0x0008000bu, 0x0000007au, 0x00000000u, 0x00020011u, 0x00000001u, 0x0006000bu, + 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, + 0x0009000fu, 0x00000005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000bu, 0x00000016u, 0x0000003au, + 0x00000061u, 0x00060010u, 0x00000004u, 0x00000011u, 0x00000010u, 0x00000010u, 0x00000001u, 0x00030003u, + 0x00000002u, 0x000001ccu, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00040005u, 0x00000009u, + 0x65786970u, 0x0000006cu, 0x00080005u, 0x0000000bu, 0x475f6c67u, 0x61626f6cu, 0x766e496cu, 0x7461636fu, + 0x496e6f69u, 0x00000044u, 0x00060005u, 0x00000014u, 0x68737550u, 0x736e6f43u, 0x746e6174u, 0x00000073u, + 0x000a0006u, 0x00000014u, 0x00000000u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, 0x656e696cu, 0x6765725fu, + 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000014u, 0x00000001u, 0x69775f75u, 0x5f687464u, 0x796c6f70u, + 0x656e696cu, 0x7665625fu, 0x00000000u, 0x000a0006u, 0x00000014u, 0x00000002u, 0x69775f75u, 0x5f687464u, + 0x5f6f6765u, 0x6a617274u, 0x6765725fu, 0x72616c75u, 0x00000000u, 0x00090006u, 0x00000014u, 0x00000003u, + 0x69775f75u, 0x5f687464u, 0x5f6f6765u, 0x6a617274u, 0x7665625fu, 0x00000000u, 0x00080006u, 0x00000014u, + 0x00000004u, 0x69775f75u, 0x5f687464u, 0x65726977u, 0x6d617266u, 0x00000065u, 0x00080006u, 0x00000014u, + 0x00000005u, 0x65725f75u, 0x756c6f73u, 0x6e6f6974u, 0x6163735fu, 0x0000656cu, 0x00070006u, 0x00000014u, + 0x00000006u, 0x65645f75u, 0x5f687470u, 0x6c616373u, 0x00676e69u, 0x00090006u, 0x00000014u, 0x00000007u, + 0x616d5f75u, 0x78655f78u, 0x70617274u, 0x74616c6fu, 0x5f6e6f69u, 0x00007375u, 0x00090006u, 0x00000014u, + 0x00000008u, 0x6f635f75u, 0x5f726f6cu, 0x656c6170u, 0x5f657474u, 0x657a6973u, 0x00000000u, 0x00070006u, + 0x00000014u, 0x00000009u, 0x756e5f75u, 0x75715f6du, 0x65697265u, 0x00000073u, 0x000a0006u, 0x00000014u, + 0x0000000au, 0x65745f75u, 0x6c657373u, 0x6974616cu, 0x745f6e6fu, 0x73657268u, 0x646c6f68u, 0x00000000u, + 0x000a0006u, 0x00000014u, 0x0000000bu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x705f6e6fu, + 0x6c796c6fu, 0x00656e69u, 0x000a0006u, 0x00000014u, 0x0000000cu, 0x616d5f75u, 0x65745f78u, 0x6c657373u, + 0x6974616cu, 0x705f6e6fu, 0x67796c6fu, 0x00006e6fu, 0x00090006u, 0x00000014u, 0x0000000du, 0x616d5f75u, + 0x65745f78u, 0x6c657373u, 0x6974616cu, 0x635f6e6fu, 0x00656275u, 0x00080006u, 0x00000014u, 0x0000000eu, + 0x75635f75u, 0x725f6c6cu, 0x75696461u, 0x63735f73u, 0x00656c61u, 0x00070006u, 0x00000014u, 0x0000000fu, + 0x6f665f75u, 0x6e655f67u, 0x656c6261u, 0x00000064u, 0x00070006u, 0x00000014u, 0x00000010u, 0x616d5f75u, + 0x626f5f78u, 0x63617473u, 0x0073656cu, 0x00080006u, 0x00000014u, 0x00000011u, 0x75635f75u, 0x705f6562u, + 0x5f6c6f6fu, 0x65646e69u, 0x00000078u, 0x00080006u, 0x00000014u, 0x00000012u, 0x756e5f75u, 0x6f705f6du, + 0x6f67796cu, 0x6f705f6eu, 0x00736c6fu, 0x00090006u, 0x00000014u, 0x00000013u, 0x616d5f75u, 0x61765f78u, + 0x79617272u, 0x65705f73u, 0x6f705f72u, 0x00006c6fu, 0x00090006u, 0x00000014u, 0x00000014u, 0x756e5f75u, + 0x6f705f6du, 0x696c796cu, 0x705f656eu, 0x736c6f6fu, 0x00000000u, 0x00070006u, 0x00000014u, 0x00000015u, + 0x756f5f75u, 0x74757074u, 0x6469775fu, 0x00006874u, 0x00070006u, 0x00000014u, 0x00000016u, 0x756f5f75u, + 0x74757074u, 0x6965685fu, 0x00746867u, 0x00030005u, 0x00000016u, 0x00006370u, 0x00040005u, 0x00000037u, + 0x6f6c6f63u, 0x00000072u, 0x00050005u, 0x0000003au, 0x6f6c6f63u, 0x6d695f72u, 0x00656761u, 0x00040005u, + 0x00000042u, 0x61626772u, 0x00000000u, 0x00050005u, 0x0000004fu, 0x65786970u, 0x6e695f6cu, 0x00786564u, + 0x00060005u, 0x0000005fu, 0x7074754fu, 0x69507475u, 0x736c6578u, 0x00000000u, 0x00050006u, 0x0000005fu, + 0x00000000u, 0x61626772u, 0x00000038u, 0x00060005u, 0x00000061u, 0x7074756fu, 0x705f7475u, 0x6c657869u, + 0x00000073u, 0x00040047u, 0x0000000bu, 0x0000000bu, 0x0000001cu, 0x00030047u, 0x00000014u, 0x00000002u, + 0x00050048u, 0x00000014u, 0x00000000u, 0x00000023u, 0x00000000u, 0x00050048u, 0x00000014u, 0x00000001u, + 0x00000023u, 0x00000004u, 0x00050048u, 0x00000014u, 0x00000002u, 0x00000023u, 0x00000008u, 0x00050048u, + 0x00000014u, 0x00000003u, 0x00000023u, 0x0000000cu, 0x00050048u, 0x00000014u, 0x00000004u, 0x00000023u, + 0x00000010u, 0x00050048u, 0x00000014u, 0x00000005u, 0x00000023u, 0x00000014u, 0x00050048u, 0x00000014u, + 0x00000006u, 0x00000023u, 0x00000018u, 0x00050048u, 0x00000014u, 0x00000007u, 0x00000023u, 0x0000001cu, + 0x00050048u, 0x00000014u, 0x00000008u, 0x00000023u, 0x00000020u, 0x00050048u, 0x00000014u, 0x00000009u, + 0x00000023u, 0x00000024u, 0x00050048u, 0x00000014u, 0x0000000au, 0x00000023u, 0x00000028u, 0x00050048u, + 0x00000014u, 0x0000000bu, 0x00000023u, 0x0000002cu, 0x00050048u, 0x00000014u, 0x0000000cu, 0x00000023u, + 0x00000030u, 0x00050048u, 0x00000014u, 0x0000000du, 0x00000023u, 0x00000034u, 0x00050048u, 0x00000014u, + 0x0000000eu, 0x00000023u, 0x00000038u, 0x00050048u, 0x00000014u, 0x0000000fu, 0x00000023u, 0x0000003cu, + 0x00050048u, 0x00000014u, 0x00000010u, 0x00000023u, 0x00000040u, 0x00050048u, 0x00000014u, 0x00000011u, + 0x00000023u, 0x00000044u, 0x00050048u, 0x00000014u, 0x00000012u, 0x00000023u, 0x00000048u, 0x00050048u, + 0x00000014u, 0x00000013u, 0x00000023u, 0x0000004cu, 0x00050048u, 0x00000014u, 0x00000014u, 0x00000023u, + 0x00000050u, 0x00050048u, 0x00000014u, 0x00000015u, 0x00000023u, 0x00000054u, 0x00050048u, 0x00000014u, + 0x00000016u, 0x00000023u, 0x00000058u, 0x00030047u, 0x0000003au, 0x00000018u, 0x00040047u, 0x0000003au, + 0x00000021u, 0x0000000fu, 0x00040047u, 0x0000003au, 0x00000022u, 0x00000000u, 0x00040047u, 0x0000005eu, + 0x00000006u, 0x00000004u, 0x00030047u, 0x0000005fu, 0x00000002u, 0x00040048u, 0x0000005fu, 0x00000000u, + 0x00000019u, 0x00050048u, 0x0000005fu, 0x00000000u, 0x00000023u, 0x00000000u, 0x00030047u, 0x00000061u, + 0x00000019u, 0x00040047u, 0x00000061u, 0x00000021u, 0x0000000eu, 0x00040047u, 0x00000061u, 0x00000022u, + 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00040015u, 0x00000006u, + 0x00000020u, 0x00000000u, 0x00040017u, 0x00000007u, 0x00000006u, 0x00000003u, 0x00040020u, 0x00000008u, + 0x00000007u, 0x00000007u, 0x00040020u, 0x0000000au, 0x00000001u, 0x00000007u, 0x0004003bu, 0x0000000au, + 0x0000000bu, 0x00000001u, 0x00020014u, 0x0000000du, 0x0004002bu, 0x00000006u, 0x0000000eu, 0x00000000u, + 0x00040020u, 0x0000000fu, 0x00000007u, 0x00000006u, 0x00030016u, 0x00000012u, 0x00000020u, 0x00040015u, + 0x00000013u, 0x00000020u, 0x00000001u, 0x0019001eu, 0x00000014u, 0x00000012u, 0x00000012u, 0x00000012u, + 0x00000012u, 0x00000012u, 0x00000012u, 0x00000012u, 0x00000013u, 0x00000013u, 0x00000006u, 0x00000012u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000012u, 0x00000012u, 0x00000006u, 0x00000006u, 0x00000006u, + 0x00000006u, 0x00000006u, 0x00000006u, 0x00000006u, 0x00040020u, 0x00000015u, 0x00000009u, 0x00000014u, + 0x0004003bu, 0x00000015u, 0x00000016u, 0x00000009u, 0x0004002bu, 0x00000013u, 0x00000017u, 0x00000015u, + 0x00040020u, 0x00000018u, 0x00000009u, 0x00000006u, 0x0004002bu, 0x00000006u, 0x0000001fu, 0x00000001u, + 0x0004002bu, 0x00000013u, 0x00000022u, 0x00000016u, 0x0004002bu, 0x00000006u, 0x0000002au, 0x00000002u, + 0x0004002bu, 0x00000013u, 0x0000002du, 0x00000009u, 0x00040017u, 0x00000035u, 0x00000012u, 0x00000004u, + 0x00040020u, 0x00000036u, 0x00000007u, 0x00000035u, 0x00090019u, 0x00000038u, 0x00000012u, 0x00000001u, + 0x00000000u, 0x00000001u, 0x00000000u, 0x00000002u, 0x00000004u, 0x00040020u, 0x00000039u, 0x00000000u, + 0x00000038u, 0x0004003bu, 0x00000039u, 0x0000003au, 0x00000000u, 0x00040017u, 0x0000003du, 0x00000013u, + 0x00000003u, 0x00040017u, 0x00000040u, 0x00000006u, 0x00000004u, 0x00040020u, 0x00000041u, 0x00000007u, + 0x00000040u, 0x0004002bu, 0x00000012u, 0x00000044u, 0x00000000u, 0x0004002bu, 0x00000012u, 0x00000045u, + 0x3f800000u, 0x0004002bu, 0x00000012u, 0x00000049u, 0x437f0000u, 0x0004002bu, 0x00000012u, 0x0000004bu, + 0x3f000000u, 0x0003001du, 0x0000005eu, 0x00000006u, 0x0003001eu, 0x0000005fu, 0x0000005eu, 0x00040020u, + 0x00000060u, 0x0000000cu, 0x0000005fu, 0x0004003bu, 0x00000060u, 0x00000061u, 0x0000000cu, 0x0004002bu, + 0x00000013u, 0x00000062u, 0x00000000u, 0x0004002bu, 0x00000013u, 0x00000068u, 0x00000008u, 0x0004002bu, + 0x00000013u, 0x0000006du, 0x00000010u, 0x0004002bu, 0x00000006u, 0x00000070u, 0x00000003u, 0x0004002bu, + 0x00000013u, 0x00000073u, 0x00000018u, 0x00040020u, 0x00000076u, 0x0000000cu, 0x00000006u, 0x0004002bu, + 0x00000006u, 0x00000078u, 0x00000010u, 0x0006002cu, 0x00000007u, 0x00000079u, 0x00000078u, 0x00000078u, + 0x0000001fu, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, + 0x0004003bu, 0x00000008u, 0x00000009u, 0x00000007u, 0x0004003bu, 0x00000036u, 0x00000037u, 0x00000007u, + 0x0004003bu, 0x00000041u, 0x00000042u, 0x00000007u, 0x0004003bu, 0x0000000fu, 0x0000004fu, 0x00000007u, + 0x0004003du, 0x00000007u, 0x0000000cu, 0x0000000bu, 0x0003003eu, 0x00000009u, 0x0000000cu, 0x00050041u, + 0x0000000fu, 0x00000010u, 0x00000009u, 0x0000000eu, 0x0004003du, 0x00000006u, 0x00000011u, 0x00000010u, + 0x00050041u, 0x00000018u, 0x00000019u, 0x00000016u, 0x00000017u, 0x0004003du, 0x00000006u, 0x0000001au, + 0x00000019u, 0x000500aeu, 0x0000000du, 0x0000001bu, 0x00000011u, 0x0000001au, 0x000400a8u, 0x0000000du, + 0x0000001cu, 0x0000001bu, 0x000300f7u, 0x0000001eu, 0x00000000u, 0x000400fau, 0x0000001cu, 0x0000001du, + 0x0000001eu, 0x000200f8u, 0x0000001du, 0x00050041u, 0x0000000fu, 0x00000020u, 0x00000009u, 0x0000001fu, + 0x0004003du, 0x00000006u, 0x00000021u, 0x00000020u, 0x00050041u, 0x00000018u, 0x00000023u, 0x00000016u, + 0x00000022u, 0x0004003du, 0x00000006u, 0x00000024u, 0x00000023u, 0x000500aeu, 0x0000000du, 0x00000025u, + 0x00000021u, 0x00000024u, 0x000200f9u, 0x0000001eu, 0x000200f8u, 0x0000001eu, 0x000700f5u, 0x0000000du, + 0x00000026u, 0x0000001bu, 0x00000005u, 0x00000025u, 0x0000001du, 0x000400a8u, 0x0000000du, 0x00000027u, + 0x00000026u, 0x000300f7u, 0x00000029u, 0x00000000u, 0x000400fau, 0x00000027u, 0x00000028u, 0x00000029u, + 0x000200f8u, 0x00000028u, 0x00050041u, 0x0000000fu, 0x0000002bu, 0x00000009u, 0x0000002au, 0x0004003du, + 0x00000006u, 0x0000002cu, 0x0000002bu, 0x00050041u, 0x00000018u, 0x0000002eu, 0x00000016u, 0x0000002du, + 0x0004003du, 0x00000006u, 0x0000002fu, 0x0000002eu, 0x000500aeu, 0x0000000du, 0x00000030u, 0x0000002cu, + 0x0000002fu, 0x000200f9u, 0x00000029u, 0x000200f8u, 0x00000029u, 0x000700f5u, 0x0000000du, 0x00000031u, + 0x00000026u, 0x0000001eu, 0x00000030u, 0x00000028u, 0x000300f7u, 0x00000033u, 0x00000000u, 0x000400fau, + 0x00000031u, 0x00000032u, 0x00000033u, 0x000200f8u, 0x00000032u, 0x000100fdu, 0x000200f8u, 0x00000033u, + 0x0004003du, 0x00000038u, 0x0000003bu, 0x0000003au, 0x0004003du, 0x00000007u, 0x0000003cu, 0x00000009u, + 0x0004007cu, 0x0000003du, 0x0000003eu, 0x0000003cu, 0x00050062u, 0x00000035u, 0x0000003fu, 0x0000003bu, + 0x0000003eu, 0x0003003eu, 0x00000037u, 0x0000003fu, 0x0004003du, 0x00000035u, 0x00000043u, 0x00000037u, + 0x00070050u, 0x00000035u, 0x00000046u, 0x00000044u, 0x00000044u, 0x00000044u, 0x00000044u, 0x00070050u, + 0x00000035u, 0x00000047u, 0x00000045u, 0x00000045u, 0x00000045u, 0x00000045u, 0x0008000cu, 0x00000035u, + 0x00000048u, 0x00000001u, 0x0000002bu, 0x00000043u, 0x00000046u, 0x00000047u, 0x0005008eu, 0x00000035u, + 0x0000004au, 0x00000048u, 0x00000049u, 0x00070050u, 0x00000035u, 0x0000004cu, 0x0000004bu, 0x0000004bu, + 0x0000004bu, 0x0000004bu, 0x00050081u, 0x00000035u, 0x0000004du, 0x0000004au, 0x0000004cu, 0x0004006du, + 0x00000040u, 0x0000004eu, 0x0000004du, 0x0003003eu, 0x00000042u, 0x0000004eu, 0x00050041u, 0x0000000fu, + 0x00000050u, 0x00000009u, 0x0000002au, 0x0004003du, 0x00000006u, 0x00000051u, 0x00000050u, 0x00050041u, + 0x00000018u, 0x00000052u, 0x00000016u, 0x00000022u, 0x0004003du, 0x00000006u, 0x00000053u, 0x00000052u, + 0x00050084u, 0x00000006u, 0x00000054u, 0x00000051u, 0x00000053u, 0x00050041u, 0x0000000fu, 0x00000055u, + 0x00000009u, 0x0000001fu, 0x0004003du, 0x00000006u, 0x00000056u, 0x00000055u, 0x00050080u, 0x00000006u, + 0x00000057u, 0x00000054u, 0x00000056u, 0x00050041u, 0x00000018u, 0x00000058u, 0x00000016u, 0x00000017u, + 0x0004003du, 0x00000006u, 0x00000059u, 0x00000058u, 0x00050084u, 0x00000006u, 0x0000005au, 0x00000057u, + 0x00000059u, 0x00050041u, 0x0000000fu, 0x0000005bu, 0x00000009u, 0x0000000eu, 0x0004003du, 0x00000006u, + 0x0000005cu, 0x0000005bu, 0x00050080u, 0x00000006u, 0x0000005du, 0x0000005au, 0x0000005cu, 0x0003003eu, + 0x0000004fu, 0x0000005du, 0x0004003du, 0x00000006u, 0x00000063u, 0x0000004fu, 0x00050041u, 0x0000000fu, + 0x00000064u, 0x00000042u, 0x0000000eu, 0x0004003du, 0x00000006u, 0x00000065u, 0x00000064u, 0x00050041u, + 0x0000000fu, 0x00000066u, 0x00000042u, 0x0000001fu, 0x0004003du, 0x00000006u, 0x00000067u, 0x00000066u, + 0x000500c4u, 0x00000006u, 0x00000069u, 0x00000067u, 0x00000068u, 0x000500c5u, 0x00000006u, 0x0000006au, + 0x00000065u, 0x00000069u, 0x00050041u, 0x0000000fu, 0x0000006bu, 0x00000042u, 0x0000002au, 0x0004003du, + 0x00000006u, 0x0000006cu, 0x0000006bu, 0x000500c4u, 0x00000006u, 0x0000006eu, 0x0000006cu, 0x0000006du, + 0x000500c5u, 0x00000006u, 0x0000006fu, 0x0000006au, 0x0000006eu, 0x00050041u, 0x0000000fu, 0x00000071u, + 0x00000042u, 0x00000070u, 0x0004003du, 0x00000006u, 0x00000072u, 0x00000071u, 0x000500c4u, 0x00000006u, + 0x00000074u, 0x00000072u, 0x00000073u, 0x000500c5u, 0x00000006u, 0x00000075u, 0x0000006fu, 0x00000074u, + 0x00060041u, 0x00000076u, 0x00000077u, 0x00000061u, 0x00000062u, 0x00000063u, 0x0003003eu, 0x00000077u, + 0x00000075u, 0x000100fdu, 0x00010038u, +}; + +// total embedded SPIR-V: 313844 bytes diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/__init__.py b/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/__init__.py index c81e837d4..0f800df31 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/__init__.py +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/__init__.py @@ -27,6 +27,7 @@ # Ludus rendering contexts. from .context import LudusCudaTimestampedContext +from .context_vk import LudusTimestampedContext, LudusVulkanTimestampedContext # Primitive data types and packing from .primitives import ( @@ -127,4 +128,6 @@ "_triangulate_polygon_ear_clipping", # Ludus rendering contexts "LudusCudaTimestampedContext", + "LudusTimestampedContext", + "LudusVulkanTimestampedContext", ] diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/_plugin_vk.py b/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/_plugin_vk.py new file mode 100644 index 000000000..b98262856 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/_plugin_vk.py @@ -0,0 +1,217 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""JIT compilation of the Vulkan torch extension. + +This is a second, optional plugin alongside :mod:`._plugin`. It compiles +the Vulkan rasterizer (``ludus_renderer_vk_plugin``) which depends on +Vulkan headers and the Vulkan loader library at link time. + +Importing this module is lazy and safe -- the actual compilation only +runs the first time :func:`_get_vk_plugin` is called. Failures surface +as ``RuntimeError`` from that call, which the :class:`LudusTimestampedContext` +constructor turns into a friendly :class:`ImportError` with installation +hints. +""" + +from __future__ import annotations + +import logging +import os +import shutil + +import torch +import torch.utils.cpp_extension + +_cached_plugin = None +_log = logging.getLogger("ludus_renderer.vk") +_dll_directory_handles = [] + + +def _cuda_home() -> str: + return ( + os.environ.get("CUDA_HOME") + or os.environ.get("CUDA_PATH") + or torch.utils.cpp_extension.CUDA_HOME + or "" + ) + + +def _prepare_windows_build() -> None: + """Make the MSVC linker and dependent runtime DLLs discoverable.""" + if os.name != "nt": + return + + if shutil.which("cl.exe") is None: + import glob + + pattern = ( + r"C:\Program Files*\Microsoft Visual Studio\*\*\VC\Tools\MSVC\*" + r"\bin\Hostx64\x64\cl.exe" + ) + candidates = sorted(glob.glob(pattern)) + if not candidates: + raise RuntimeError( + "Could not locate a supported Microsoft Visual C++ installation" + ) + os.environ["PATH"] += os.pathsep + os.path.dirname(candidates[-1]) + + add_dll_directory = getattr(os, "add_dll_directory", None) + if add_dll_directory is None: + return + candidates = [os.path.join(os.path.dirname(torch.__file__), "lib")] + cuda_home = _cuda_home() + if cuda_home: + candidates.append(os.path.join(cuda_home, "bin")) + # CUDA 13.2's Windows toolkit places nvJPEG in bin/x64 while the + # import library remains under lib/x64. + candidates.append(os.path.join(cuda_home, "bin", "x64")) + sdk = os.environ.get("VULKAN_SDK") + if sdk: + candidates.append(os.path.join(sdk, "Bin")) + for path in candidates: + if os.path.isdir(path): + _dll_directory_handles.append(add_dll_directory(path)) + + +def _resolve_vulkan_include() -> list[str]: + """Find Vulkan headers. Try VULKAN_SDK, then common system paths.""" + candidates: list[str] = [] + sdk = os.environ.get("VULKAN_SDK") + if sdk: + for sub in ("Include", "include", os.path.join("x86_64", "include")): + p = os.path.join(sdk, sub) + if os.path.isdir(p): + candidates.append(p) + for p in ("/usr/include", "/usr/local/include"): + if os.path.isdir(os.path.join(p, "vulkan")): + candidates.append(p) + return candidates + + +def _resolve_vulkan_libdir() -> list[str]: + """Find the directory containing the platform Vulkan loader library.""" + dirs: list[str] = [] + sdk = os.environ.get("VULKAN_SDK") + if sdk: + for sub in ("Lib", "lib", os.path.join("x86_64", "lib")): + p = os.path.join(sdk, sub) + if os.path.isdir(p): + dirs.append(p) + for p in ("/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/usr/lib", "/usr/local/lib"): + if any( + f.startswith("libvulkan.so") + for f in (os.listdir(p) if os.path.isdir(p) else []) + ): + dirs.append(p) + return dirs + + +def _vulkan_available() -> tuple[bool, str]: + """Check that Vulkan headers and loader library are present.""" + if not _resolve_vulkan_include(): + platform_hint = ( + "install the LunarG Vulkan SDK and set VULKAN_SDK" + if os.name == "nt" + else "install libvulkan-dev (Debian/Ubuntu) or set VULKAN_SDK" + ) + return False, (f"Vulkan headers not found; {platform_hint} to its root.") + libdirs = _resolve_vulkan_libdir() + if os.name == "nt": + if not any( + os.path.isfile(os.path.join(path, "vulkan-1.lib")) for path in libdirs + ): + return False, ( + "Vulkan loader import library not found; install the LunarG " + "Vulkan SDK and set VULKAN_SDK to its root." + ) + elif not libdirs and not shutil.which("vulkaninfo"): + return False, ( + "Vulkan loader (libvulkan.so) not found. Install " + "libvulkan1 (Debian/Ubuntu) or the Vulkan SDK." + ) + return True, "" + + +def _get_vk_plugin(): + """Compile (if needed) and return the Vulkan plugin module. + + Raises ``RuntimeError`` if Vulkan headers/loader are missing, or if + JIT compilation fails. + """ + global _cached_plugin + if _cached_plugin is not None: + return _cached_plugin + + ok, msg = _vulkan_available() + if not ok: + raise RuntimeError(f"Vulkan backend unavailable: {msg}") + + _prepare_windows_build() + + common_opts = ["-DNVDR_TORCH", "-DFW_DO_NOT_OVERRIDE_NEW_DELETE"] + cc_opts = common_opts + (["/wd4067", "/wd4624"] if os.name == "nt" else []) + cuda_opts = common_opts + ["-lineinfo"] + + source_files = [ + "../_cpp/common/common.cpp", + "../_cpp/common/vkutil.cpp", + "../_cpp/render/ludus_timestamped_vk.cpp", + "../_cpp/render/ludus_jpeg.cu", + "../_cpp/bindings/torch_rasterize_vk.cpp", + ] + source_paths = [os.path.join(os.path.dirname(__file__), fn) for fn in source_files] + + extra_include_paths = _resolve_vulkan_include() + vulkan_libdirs = _resolve_vulkan_libdir() + if os.name == "nt": + ldflags = ["cuda.lib", "vulkan-1.lib", "nvjpeg.lib"] + libdirs = list(vulkan_libdirs) + cuda_home = _cuda_home() + if cuda_home: + libdirs.append(os.path.join(cuda_home, "lib", "x64")) + ldflags.extend(f"/LIBPATH:{path}" for path in dict.fromkeys(libdirs)) + else: + ldflags = ["-lcuda", "-lvulkan", "-lnvjpeg"] + for path in vulkan_libdirs: + ldflags.insert(0, f"-L{path}") + ldflags.insert(0, f"-Wl,-rpath,{path}") + + # Reset CUDA arch list to let PyTorch detect the installed GPU. + os.environ["TORCH_CUDA_ARCH_LIST"] = "" + + plugin_name = "ludus_renderer_vk_plugin" + + try: + lock_fn = os.path.join( + torch.utils.cpp_extension._get_build_directory(plugin_name, False), "lock" + ) + if os.path.exists(lock_fn): + _log.warning("Stale lock file in Vulkan plugin build dir: %s", lock_fn) + except (OSError, RuntimeError) as exc: + _log.debug("Could not inspect Vulkan plugin build directory: %s", exc) + + _log.info("Compiling Vulkan plugin (this may take a minute on first run)...") + _cached_plugin = torch.utils.cpp_extension.load( + name=plugin_name, + sources=source_paths, + extra_include_paths=extra_include_paths, + extra_cflags=cc_opts, + extra_cuda_cflags=cuda_opts, + extra_ldflags=ldflags, + with_cuda=True, + verbose=True, + ) + return _cached_plugin diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/context_vk.py b/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/context_vk.py new file mode 100644 index 000000000..4c44ed4d7 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_ops/context_vk.py @@ -0,0 +1,904 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Ludus Vulkan timestamped rendering context. + +:class:`LudusTimestampedContext` is the Vulkan-backed counterpart to +:class:`LudusCudaTimestampedContext`. They expose the same public method +surface so callers can swap them at runtime. + +Compared to the CUDA backend: + +- Scene data is uploaded once into GPU-resident Vulkan SSBOs (rather than + cached in Python tensors and passed to the kernel on every render). +- Rendering preserves the CUDA backend's one-batched-call scheduling model; + Vulkan records one task/mesh/fragment submission for the full query batch. +- Geometry is generated procedurally in task/mesh shaders rather than in + CUDA kernels. +- Fixed-function color/depth rendering resolves visibility, then compute writes + a CUDA-imported output SSBO exposed as the returned tensor without an interop + copy or layered CUDA image import. + +The Vulkan extension is built on demand the first time you instantiate +this class. If the Vulkan loader or headers are missing, the constructor +raises :class:`ImportError` with an actionable hint. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import List, Optional, Tuple + +import torch + +from .context import _compute_element_aabbs +from .primitives import ( + CubePool, + FThetaCamera, + TimestampedScene, + _pack_cameras, +) + + +def _max_varrays_per_ts(timestamped_varrays_prefix_sum: torch.Tensor) -> int: + """Max number of varrays present at any single timestamp in a pool. + + The prefix sum is cumulative across timestamps, so consecutive differences + give the per-timestamp varray counts; the max drives the mesh-task dispatch + stride (mirrors the CUDA backend's ``max_varrays_per_ts_*``). + """ + ps = timestamped_varrays_prefix_sum + if ps.numel() == 0: + return 0 + diffs = torch.diff(ps, prepend=torch.zeros(1, dtype=ps.dtype, device=ps.device)) + return int(diffs.max().item()) + + +class LudusTimestampedContext: + """Vulkan context for timestamped scene rendering. + + All timestamp search, element extraction, color lookup, and procedural + geometry generation happen on the GPU in task/mesh shaders. + + Example:: + + ctx = LudusTimestampedContext(device="cuda") + ctx.upload_cameras(cameras) + scene_id = ctx.upload_scene(scene) + + queries = [(scene_id, cam_id, ts_us, CAMERA_TYPE_REGULAR)] + poses = scene.get_ego_poses_at_timestamps(...) + images = ctx.render_batch(queries, poses, resolution=(720, 1280)) + """ + + # ------------------------------------------------------------------ + # Construction + # ------------------------------------------------------------------ + def __init__(self, device=None): + if device is None: + cuda_device_idx = torch.cuda.current_device() + else: + with torch.cuda.device(device): + cuda_device_idx = torch.cuda.current_device() + self.cuda_device_idx = cuda_device_idx + self._device = torch.device(f"cuda:{cuda_device_idx}") + + # Keep the default CUDA context's import path free of Vulkan extension + # discovery and cpp_extension setup. + from ._plugin_vk import _get_vk_plugin + + try: + plugin = _get_vk_plugin() + except RuntimeError as exc: + raise ImportError(str(exc)) from exc + + self._plugin = plugin + self.cpp_wrapper = plugin.LudusTimestampedVkStateWrapper(cuda_device_idx) + + # Some defaults that the wrapper sets but Python should track. + self._tessellation_threshold = 1.0 + + self._cameras: List[FThetaCamera] = [] + self._camera_intrinsics: Optional[torch.Tensor] = None + + # Mirror the CUDA context's scene bookkeeping so mutable cube pools can + # update only their shared-memory slices without rebuilding static map + # buffers. ``scene`` is retained only for rare topology replacement. + self._scenes: list[dict] = [] + + # Running SSBO base offsets per scene (mirror the C++ *Used counters), + # so scene N reads its own data, not scene 0's. Reset by clear_scenes. + self._global_ts_off = 0 + self._global_i32_off = 0 + self._global_vert_off = 0 + self._global_tri_off = 0 + self._global_float_off = 0 + self._global_pl_pool_off = 0 + self._global_pg_pool_off = 0 + self._global_cb_pool_off = 0 + + # GL/Vulkan render their layered framebuffer top-down by default; + # Vulkan's viewport y-flip in the renderer matches the CUDA backend's + # output convention so callers don't need to vflip. + self.needs_vflip = False + + # ------------------------------------------------------------------ + @property + def max_batch_size(self) -> int: + """Maximum number of queries the backend can render in one call.""" + return int(self.cpp_wrapper.get_max_batch_size()) + + # ------------------------------------------------------------------ + def upload_cameras(self, cameras: List[FThetaCamera]) -> None: + """Upload camera intrinsics to the GPU.""" + self._cameras = list(cameras) + self._camera_intrinsics = _pack_cameras(cameras, self._device) + self.cpp_wrapper.upload_cameras(self._camera_intrinsics) + + # ------------------------------------------------------------------ + # Pool packers: each builds 16-uint32 row matching the C++ struct + # layout (`ludus_types.h`) so the binding can `reinterpret_cast` rows + # into structured pool descriptors. + # ------------------------------------------------------------------ + @staticmethod + def _pack_polyline_pool_row( + num_timestamps: int, + num_varrays: int, + num_vertices: int, + prim_type_id: int, + ts_offset: int, + ts_varrays_ps_offset: int, + varrays_ps_offset: int, + vertices_offset: int, + aabb_offset: int, + ) -> torch.Tensor: + row = torch.zeros(16, dtype=torch.uint32) + row[0] = num_timestamps + row[1] = num_varrays + row[2] = num_vertices + row[3] = prim_type_id + row[4] = ts_offset + row[5] = ts_varrays_ps_offset + row[6] = varrays_ps_offset + row[7] = vertices_offset + row[8] = aabb_offset + return row + + @staticmethod + def _pack_polygon_pool_row( + num_timestamps: int, + num_varrays: int, + num_vertices: int, + num_triangles: int, + prim_type_id: int, + ts_offset: int, + ts_varrays_ps_offset: int, + varrays_ps_offset: int, + tri_ps_offset: int, + vertices_offset: int, + triangles_offset: int, + aabb_offset: int, + ) -> torch.Tensor: + row = torch.zeros(16, dtype=torch.uint32) + row[0] = num_timestamps + row[1] = num_varrays + row[2] = num_vertices + row[3] = num_triangles + row[4] = prim_type_id + row[5] = ts_offset + row[6] = ts_varrays_ps_offset + row[7] = varrays_ps_offset + row[8] = tri_ps_offset + row[9] = vertices_offset + row[10] = triangles_offset + row[11] = aabb_offset + return row + + @staticmethod + def _pack_cube_pool_row( + num_cubes: int, + num_timestamps: int, + num_track_poses: int, + prim_type_id: int, + ts_offset: int, + cube_ts_ps_offset: int, + track_ts_offset: int, + translations_offset: int, + quaternions_offset: int, + scales_offset: int, + colors_offset: int, + render_flags: int, + ) -> torch.Tensor: + row = torch.zeros(16, dtype=torch.uint32) + row[0] = num_cubes + row[1] = num_timestamps + row[2] = num_track_poses + row[3] = prim_type_id + row[4] = ts_offset + row[5] = cube_ts_ps_offset + row[6] = track_ts_offset + row[7] = translations_offset + row[8] = quaternions_offset + row[9] = scales_offset + row[10] = colors_offset + row[11] = render_flags + return row + + @staticmethod + def _pack_scene_desc( + num_pl_pools: int, + pl_pools_offset: int, + num_pg_pools: int, + pg_pools_offset: int, + num_cb_pools: int, + cb_pools_offset: int, + ts_buf_offset: int, + int32_buf_offset: int, + vert_buf_offset: int, + tri_buf_offset: int, + pose_buf_offset: int, + float_buf_offset: int, + ) -> torch.Tensor: + # 128-byte scene descriptor = 32 uint32. + row = torch.zeros(32, dtype=torch.uint32) + row[0] = num_pl_pools + row[1] = pl_pools_offset + row[2] = num_pg_pools + row[3] = pg_pools_offset + row[4] = num_cb_pools + row[5] = cb_pools_offset + row[6] = ts_buf_offset + row[7] = int32_buf_offset + row[8] = vert_buf_offset + row[9] = tri_buf_offset + row[10] = pose_buf_offset + row[11] = float_buf_offset + return row + + # ------------------------------------------------------------------ + def upload_scene(self, scene: TimestampedScene) -> int: + """Pack the scene and upload it to GPU SSBOs in a single call. + + Returns the scene id assigned by the backend. + """ + device = self._device + + timestamps_list: List[torch.Tensor] = [] + int32_list: List[torch.Tensor] = [] + vertices_list: List[torch.Tensor] = [] + triangles_list: List[torch.Tensor] = [] + float_list: List[torch.Tensor] = [] + + polyline_pool_rows: List[torch.Tensor] = [] + polygon_pool_rows: List[torch.Tensor] = [] + cube_pool_rows: List[torch.Tensor] = [] + cube_pool_metadata: list[dict[str, int]] = [] + + # Per-scene local offsets. The C++ side appends each scene's data + # to the global SSBOs and patches absolute offsets later via the + # scene descriptor's *_buffer_offset fields. + ts_off = 0 + i32_off = 0 + vert_off = 0 + tri_off = 0 + # Start float_off at 1 (and prepend a dummy float below) so that the + # first pool never gets aabb_offset == 0. The task shaders use 0 as + # a sentinel meaning "no AABB available, skip culling", so a real + # aabb located at offset 0 silently disables culling for that pool, + # which lets behind-camera polygons through and produces giant + # garbage triangles when they straddle the camera plane. + float_off = 1 + float_list.append(torch.zeros(1, dtype=torch.float32, device=device)) + + # Max varrays present at any single timestamp, per family. Drives the + # per-pool mesh-task dispatch stride (u_max_varrays_per_pool) so pools + # larger than this are not silently truncated. + max_varrays_per_ts_polyline = 0 + max_varrays_per_ts_polygon = 0 + + # ---------- polyline pools ---------- + for pool in scene.polyline_pools: + n_ts = int(pool.timestamps_us.shape[0]) + n_var = int(pool.varrays_prefix_sum.shape[0]) + n_v = int(pool.vertices.shape[0]) + max_varrays_per_ts_polyline = max( + max_varrays_per_ts_polyline, + _max_varrays_per_ts(pool.timestamped_varrays_prefix_sum), + ) + + aabbs = _compute_element_aabbs( + pool.vertices, pool.varrays_prefix_sum, device + ) + + row = self._pack_polyline_pool_row( + num_timestamps=n_ts, + num_varrays=n_var, + num_vertices=n_v, + prim_type_id=pool.prim_type_id, + ts_offset=ts_off, + ts_varrays_ps_offset=i32_off, + varrays_ps_offset=i32_off + n_ts, + vertices_offset=vert_off, + aabb_offset=float_off, + ) + polyline_pool_rows.append(row) + + timestamps_list.append(pool.timestamps_us.to(device, dtype=torch.int64)) + int32_list.append( + pool.timestamped_varrays_prefix_sum.to(device, dtype=torch.int32) + ) + int32_list.append(pool.varrays_prefix_sum.to(device, dtype=torch.int32)) + + # Vertices are stored as Vertex (vec3 + pad) in the SSBO. + v_padded = torch.zeros(n_v, 4, dtype=torch.float32, device=device) + v_padded[:, :3] = pool.vertices.to(device, dtype=torch.float32) + vertices_list.append(v_padded) + + float_list.append(aabbs) + + ts_off += n_ts + i32_off += n_ts + n_var + vert_off += n_v + float_off += int(aabbs.numel()) + + # ---------- polygon pools ---------- + for pool in scene.polygon_pools: + n_ts = int(pool.timestamps_us.shape[0]) + n_var = int(pool.varrays_prefix_sum.shape[0]) + n_v = int(pool.vertices.shape[0]) + n_t = int(pool.triangles.shape[0]) + max_varrays_per_ts_polygon = max( + max_varrays_per_ts_polygon, + _max_varrays_per_ts(pool.timestamped_varrays_prefix_sum), + ) + + aabbs = _compute_element_aabbs( + pool.vertices, pool.varrays_prefix_sum, device + ) + + row = self._pack_polygon_pool_row( + num_timestamps=n_ts, + num_varrays=n_var, + num_vertices=n_v, + num_triangles=n_t, + prim_type_id=pool.prim_type_id, + ts_offset=ts_off, + ts_varrays_ps_offset=i32_off, + varrays_ps_offset=i32_off + n_ts, + tri_ps_offset=i32_off + n_ts + n_var, + vertices_offset=vert_off, + triangles_offset=tri_off, + aabb_offset=float_off, + ) + polygon_pool_rows.append(row) + + timestamps_list.append(pool.timestamps_us.to(device, dtype=torch.int64)) + int32_list.append( + pool.timestamped_varrays_prefix_sum.to(device, dtype=torch.int32) + ) + int32_list.append(pool.varrays_prefix_sum.to(device, dtype=torch.int32)) + int32_list.append(pool.triangle_prefix_sum.to(device, dtype=torch.int32)) + + v_padded = torch.zeros(n_v, 4, dtype=torch.float32, device=device) + v_padded[:, :3] = pool.vertices.to(device, dtype=torch.float32) + vertices_list.append(v_padded) + + t_padded = torch.zeros(n_t, 4, dtype=torch.int32, device=device) + t_padded[:, :3] = pool.triangles.to(device, dtype=torch.int32) + triangles_list.append(t_padded) + + float_list.append(aabbs) + + ts_off += n_ts + i32_off += n_ts + 2 * n_var + vert_off += n_v + tri_off += n_t + float_off += int(aabbs.numel()) + + # ---------- cube pools ---------- + for pool in scene.cube_pools or []: + n_global_ts = int(pool.timestamps_us.shape[0]) + n_cubes = int(pool.scales.shape[0]) + n_track = int(pool.translations.shape[0]) + + row = self._pack_cube_pool_row( + num_cubes=n_cubes, + num_timestamps=n_global_ts, + num_track_poses=n_track, + prim_type_id=pool.prim_type_id, + ts_offset=ts_off, + cube_ts_ps_offset=i32_off, + track_ts_offset=ts_off + n_global_ts, + translations_offset=float_off, + quaternions_offset=float_off + n_track * 3, + scales_offset=float_off + n_track * 7, + colors_offset=float_off + n_track * 7 + n_cubes * 3, + render_flags=int(pool.render_flags), + ) + cube_pool_rows.append(row) + cube_pool_metadata.append( + { + "prim_type_id": int(pool.prim_type_id), + "n_cubes": n_cubes, + "n_global_ts": n_global_ts, + "n_track_poses": n_track, + "absolute_pool_index": self._global_cb_pool_off + + len(cube_pool_rows) + - 1, + "timestamp_offset": self._global_ts_off + ts_off, + "track_timestamp_offset": self._global_ts_off + + ts_off + + n_global_ts, + "int32_offset": self._global_i32_off + i32_off, + "translation_offset": self._global_float_off + float_off, + "quaternion_offset": self._global_float_off + + float_off + + n_track * 3, + "scale_offset": self._global_float_off + float_off + n_track * 7, + "color_offset": self._global_float_off + + float_off + + n_track * 7 + + n_cubes * 3, + } + ) + + timestamps_list.append(pool.timestamps_us.to(device, dtype=torch.int64)) + timestamps_list.append( + pool.track_timestamps_us.to(device, dtype=torch.int64) + ) + int32_list.append(pool.cube_ts_prefix_sum.to(device, dtype=torch.int32)) + float_list.append( + pool.translations.to(device, dtype=torch.float32).reshape(-1) + ) + float_list.append( + pool.quaternions.to(device, dtype=torch.float32).reshape(-1) + ) + float_list.append(pool.scales.to(device, dtype=torch.float32).reshape(-1)) + float_list.append(pool.colors.to(device, dtype=torch.float32).reshape(-1)) + + ts_off += n_global_ts + n_track + i32_off += n_cubes + float_off += n_track * 7 + n_cubes * 9 + + # ---------- concatenate flat buffers ---------- + all_timestamps = ( + torch.cat(timestamps_list).contiguous() + if timestamps_list + else torch.empty(0, dtype=torch.int64, device=device) + ) + all_int32 = ( + torch.cat(int32_list).contiguous() + if int32_list + else torch.empty(0, dtype=torch.int32, device=device) + ) + all_vertices = ( + torch.cat(vertices_list).contiguous() + if vertices_list + else torch.empty((0, 4), dtype=torch.float32, device=device) + ) + all_triangles = ( + torch.cat(triangles_list).contiguous() + if triangles_list + else torch.empty((0, 4), dtype=torch.int32, device=device) + ) + all_floats = ( + torch.cat(float_list).contiguous() + if float_list + else torch.empty(0, dtype=torch.float32, device=device) + ) + + # Pool descriptor tensors (16 uint32 per row, viewed as raw bytes + # so the C++ side can reinterpret_cast). + def _pools_to_bytes( + rows: List[torch.Tensor], stride_u32: int = 16 + ) -> torch.Tensor: + if not rows: + return torch.empty( + (0, stride_u32 * 4), dtype=torch.uint8, device=device + ) + stacked = torch.stack(rows).to(device).contiguous() # [N, 16] uint32 + return stacked.view(torch.uint8).reshape(-1, stride_u32 * 4).contiguous() + + polyline_pool_bytes = _pools_to_bytes(polyline_pool_rows, stride_u32=16) + polygon_pool_bytes = _pools_to_bytes(polygon_pool_rows, stride_u32=16) + cube_pool_bytes = _pools_to_bytes(cube_pool_rows, stride_u32=16) + + # Scene descriptor (128 bytes). + # This scene's base offset in each shared SSBO (0 for the first scene). + # Shaders index as scene._offset + pool._offset. + scene_desc_row = self._pack_scene_desc( + num_pl_pools=len(polyline_pool_rows), + pl_pools_offset=self._global_pl_pool_off, + num_pg_pools=len(polygon_pool_rows), + pg_pools_offset=self._global_pg_pool_off, + num_cb_pools=len(cube_pool_rows), + cb_pools_offset=self._global_cb_pool_off, + ts_buf_offset=self._global_ts_off, + int32_buf_offset=self._global_i32_off, + vert_buf_offset=self._global_vert_off, + tri_buf_offset=self._global_tri_off, + pose_buf_offset=0, + float_buf_offset=self._global_float_off, + ) + scene_desc = scene_desc_row.to(device).contiguous().view(torch.uint8) + + # Empty CameraPose tensor -- this backend uses per-query camera + # poses uploaded at render time, not per-scene poses. + empty_poses = torch.empty((0, 16), dtype=torch.float32, device=device) + + # Per-pool max obstacle count drives one dispatch per pool. + max_obstacles = max( + (int(p.scales.shape[0]) for p in (scene.cube_pools or [])), default=0 + ) + + scene_id = int( + self.cpp_wrapper.upload_scene( + scene_desc, + polyline_pool_bytes, + polygon_pool_bytes, + cube_pool_bytes, + max_obstacles, + max_varrays_per_ts_polyline, + max_varrays_per_ts_polygon, + all_timestamps, + all_int32, + all_vertices, + all_triangles, + empty_poses, + all_floats, + ) + ) + + # Advance the cursors past this scene for the next upload_scene. + self._global_ts_off += ts_off + self._global_i32_off += i32_off + self._global_vert_off += vert_off + self._global_tri_off += tri_off + self._global_float_off += float_off + self._global_pl_pool_off += len(polyline_pool_rows) + self._global_pg_pool_off += len(polygon_pool_rows) + self._global_cb_pool_off += len(cube_pool_rows) + + if scene_id != len(self._scenes): + raise RuntimeError( + "Vulkan scene ids must remain dense and append-only during upload" + ) + self._scenes.append( + { + "scene": scene, + "cube_pool_metadata": cube_pool_metadata, + "cube_pool_rows": cube_pool_rows, + } + ) + return scene_id + + # ------------------------------------------------------------------ + def remove_scene(self, scene_id: int) -> None: + if not 0 <= scene_id < len(self._scenes): + raise IndexError(f"scene_id {scene_id} is out of range") + self.cpp_wrapper.remove_scene(int(scene_id)) + self._scenes[scene_id]["active"] = False + + def clear_scenes(self) -> None: + self.cpp_wrapper.clear_scenes() + self._scenes.clear() + self._global_ts_off = 0 + self._global_i32_off = 0 + self._global_vert_off = 0 + self._global_tri_off = 0 + self._global_float_off = 0 + self._global_pl_pool_off = 0 + self._global_pg_pool_off = 0 + self._global_cb_pool_off = 0 + + def replace_scene(self, scene_id: int, scene: TimestampedScene) -> int: + """Replace a scene while preserving its externally visible id. + + Topology changes are intentionally the slow control path. Repacking all + active scene descriptors keeps Vulkan's append-only SSBO layout simple; + same-topology object motion uses :meth:`update_cube_pool_at_index` and + touches only the mutable shared-memory slices. + """ + if not 0 <= scene_id < len(self._scenes): + raise IndexError(f"scene_id {scene_id} is out of range") + scenes = [entry["scene"] for entry in self._scenes] + scenes[scene_id] = scene + self.clear_scenes() + for expected_id, replacement in enumerate(scenes): + uploaded_id = self.upload_scene(replacement) + if uploaded_id != expected_id: + raise RuntimeError("Vulkan scene ids changed during replacement") + return scene_id + + def update_cube_pool( + self, scene_id: int, prim_type_id: int, pool: CubePool + ) -> bool: + """Update the unique same-topology cube pool of a primitive type.""" + if not 0 <= scene_id < len(self._scenes): + raise IndexError(f"scene_id {scene_id} is out of range") + candidates = [ + index + for index, metadata in enumerate( + self._scenes[scene_id]["cube_pool_metadata"] + ) + if metadata["prim_type_id"] == int(prim_type_id) + ] + if len(candidates) != 1: + return False + return self.update_cube_pool_at_index(scene_id, candidates[0], pool) + + def update_cube_pool_at_index( + self, scene_id: int, pool_index: int, pool: CubePool + ) -> bool: + """Update one cube pool in-place when its allocation shape is stable.""" + if not 0 <= scene_id < len(self._scenes): + raise IndexError(f"scene_id {scene_id} is out of range") + entry = self._scenes[scene_id] + metadata_values = entry["cube_pool_metadata"] + if not 0 <= pool_index < len(metadata_values): + raise IndexError(f"cube pool index {pool_index} is out of range") + + metadata = metadata_values[pool_index] + n_cubes = int(pool.scales.shape[0]) + n_global_ts = int(pool.timestamps_us.shape[0]) + n_track_poses = int(pool.translations.shape[0]) + if ( + int(pool.prim_type_id) != metadata["prim_type_id"] + or n_cubes != metadata["n_cubes"] + or n_global_ts != metadata["n_global_ts"] + or n_track_poses != metadata["n_track_poses"] + or tuple(pool.quaternions.shape) != (n_track_poses, 4) + or tuple(pool.scales.shape) != (n_cubes, 3) + or tuple(pool.colors.shape) != (n_cubes, 6) + ): + return False + + def _gpu(tensor: torch.Tensor, dtype: torch.dtype) -> torch.Tensor: + return tensor.to( + device=self._device, dtype=dtype, non_blocking=True + ).contiguous() + + # Pool offsets remain local to the scene descriptor. Only render flags + # are mutable, so preserve the packed header and patch that field. + pool_row = entry["cube_pool_rows"][pool_index].clone() + pool_row[11] = int(pool.render_flags) + pool_header = pool_row.to(self._device).contiguous().view(torch.uint8) + + self.cpp_wrapper.update_cube_pool( + metadata["absolute_pool_index"], + metadata["timestamp_offset"], + metadata["track_timestamp_offset"], + metadata["int32_offset"], + metadata["translation_offset"], + metadata["quaternion_offset"], + metadata["scale_offset"], + metadata["color_offset"], + _gpu(pool.timestamps_us, torch.int64), + _gpu(pool.track_timestamps_us, torch.int64), + _gpu(pool.cube_ts_prefix_sum, torch.int32), + _gpu(pool.translations, torch.float32), + _gpu(pool.quaternions, torch.float32), + _gpu(pool.scales, torch.float32), + _gpu(pool.colors, torch.float32), + pool_header, + ) + entry["cube_pool_rows"][pool_index] = pool_row + entry["scene"].cube_pools[pool_index] = pool + return True + + # ------------------------------------------------------------------ + # Render-tuning settings (mirror LudusCudaTimestampedContext) + # ------------------------------------------------------------------ + def set_tessellation_threshold(self, threshold: float) -> None: + self._tessellation_threshold = float(threshold) + self.cpp_wrapper.set_tessellation_threshold(float(threshold)) + + def set_depth_scaling(self, enabled: bool = True) -> None: + self.cpp_wrapper.set_depth_scaling(1.0 if enabled else 0.0) + + def set_resolution_scale( + self, + width: int, + height: int, + reference_width: int = 1280, + reference_height: int = 720, + ) -> None: + scale = min(width / reference_width, height / reference_height) + self.cpp_wrapper.set_resolution_scale(float(scale)) + + def set_cull_radius(self, scale: float = 1.5) -> None: + self.cpp_wrapper.set_cull_radius(float(scale)) + + def set_msaa_samples(self, samples: int) -> None: + self.cpp_wrapper.set_msaa_samples(int(samples)) + + def set_line_widths( + self, + polyline_regular: float = 0.0, + polyline_bev: float = 0.0, + ego_traj_regular: float = 0.0, + ego_traj_bev: float = 0.0, + wireframe: float = 0.0, + ) -> None: + self.cpp_wrapper.set_line_widths( + float(polyline_regular), + float(polyline_bev), + float(ego_traj_regular), + float(ego_traj_bev), + float(wireframe), + ) + + def set_max_tessellation_levels( + self, + polyline: int = 4, + polygon: int = 3, + cube: int = 3, + ) -> None: + self.cpp_wrapper.set_max_tessellation_levels( + int(polyline), int(polygon), int(cube) + ) + + def upload_color_palette(self, colors: dict) -> None: + """Upload a custom color palette. + + ``colors`` maps ``prim_type_id`` (int) to an RGBA tuple + ``(r, g, b, a)`` with each component in [0, 255]. Internally the + Vulkan binding accepts either int32 packed RGBA8 or float [N,4] + in [0,1]; we send float so the shader can use it as ``vec4``. + """ + max_prim = max(colors.keys()) + 1 if colors else 0 + palette = torch.zeros((max_prim, 4), dtype=torch.float32) + for prim_id, rgba in colors.items(): + r, g, b = int(rgba[0]), int(rgba[1]), int(rgba[2]) + a = int(rgba[3]) if len(rgba) > 3 else 255 + palette[prim_id, 0] = r / 255.0 + palette[prim_id, 1] = g / 255.0 + palette[prim_id, 2] = b / 255.0 + palette[prim_id, 3] = a / 255.0 + self.cpp_wrapper.upload_color_palette(palette.to(self._device)) + + # ------------------------------------------------------------------ + # Render + # ------------------------------------------------------------------ + def _pack_queries( + self, + scene_ids: torch.Tensor, + camera_ids: torch.Tensor, + timestamps_us: torch.Tensor, + camera_type_ids: torch.Tensor, + ) -> torch.Tensor: + """Pack into ``RenderQuery[]`` (32 bytes each, returned as uint8).""" + n = int(scene_ids.shape[0]) + # Layout (32 bytes per query): + # u32 scene_id offset 0..4 + # u32 camera_id offset 4..8 + # i64 timestamp_us offset 8..16 + # u32 camera_type_id offset 16..20 + # u32 pad[3] offset 20..32 + # + # We assemble the 32-byte record from two CPU int32/int64 columns to + # avoid relying on `torch.uint32` / view-dtype machinery (which has + # historically been finicky across torch versions). The final + # tensor is then copied to the target device in one go. + ints = torch.zeros((n, 5), dtype=torch.int32) + ints[:, 0] = scene_ids.to("cpu", dtype=torch.int32) + ints[:, 1] = camera_ids.to("cpu", dtype=torch.int32) + # Skip slots 2..3 (int64 timestamp - filled separately). + ints[:, 4] = camera_type_ids.to("cpu", dtype=torch.int32) + ts = timestamps_us.to("cpu", dtype=torch.int64) + + buf = torch.zeros(n, 32, dtype=torch.uint8) + buf_i32_view = buf.view(torch.int32).reshape(n, 8) + buf_i64_view = buf.view(torch.int64).reshape(n, 4) + buf_i32_view[:, 0] = ints[:, 0] # scene_id + buf_i32_view[:, 1] = ints[:, 1] # camera_id + buf_i64_view[:, 1] = ts # timestamp_us + buf_i32_view[:, 4] = ints[:, 4] # camera_type_id + return buf.to(self._device).contiguous() + + def render( + self, + scene_ids: torch.Tensor, + camera_ids: torch.Tensor, + timestamps_us: torch.Tensor, + camera_type_ids: torch.Tensor, + camera_poses: torch.Tensor, + resolution: Tuple[int, int], + ) -> torch.Tensor: + """Render a batch of queries with one Vulkan submission.""" + if self._camera_intrinsics is None: + raise RuntimeError("call upload_cameras() before render()") + n = int(scene_ids.shape[0]) + if n == 0: + h, w = resolution + return torch.empty((0, h, w, 4), dtype=torch.uint8, device=self._device) + + queries = self._pack_queries( + scene_ids, + camera_ids, + timestamps_us, + camera_type_ids, + ) + poses = camera_poses.to(self._device, dtype=torch.float32).contiguous() + return self._plugin.ludus_timestamped_render_batch( + self.cpp_wrapper, queries, poses, resolution + ) + + def render_batch( + self, + queries: List[Tuple[int, int, int, int]], + camera_poses: torch.Tensor, + resolution: Tuple[int, int], + ) -> torch.Tensor: + """Render a batch of queries (tuple-based API). Mirrors + :meth:`LudusCudaTimestampedContext.render_batch`.""" + + # Build each column on the host and copy once; per-element GPU writes + # would force a host/device sync per query. + def _ts(q): + ts = q[2] + return int(ts.item() if isinstance(ts, torch.Tensor) else ts) + + scene_ids = torch.tensor([int(q[0]) for q in queries], dtype=torch.int32) + camera_ids = torch.tensor([int(q[1]) for q in queries], dtype=torch.int32) + timestamps_us = torch.tensor([_ts(q) for q in queries], dtype=torch.int64) + camera_type_ids = torch.tensor( + [int(q[3]) if len(q) > 3 else 0 for q in queries], + dtype=torch.int32, + ) + return self.render( + scene_ids, + camera_ids, + timestamps_us, + camera_type_ids, + camera_poses, + resolution, + ) + + def render_uniform( + self, + *, + scene_id: int, + camera_id: int, + timestamps_us: Sequence[int] | torch.Tensor, + camera_type_id: int, + camera_poses: torch.Tensor, + resolution: Tuple[int, int], + ) -> torch.Tensor: + """Render a uniform batch through the same single-submit fast path.""" + if self._camera_intrinsics is None: + raise RuntimeError("call upload_cameras() before render_uniform()") + if not 0 <= scene_id < len(self._scenes): + raise IndexError(f"scene_id {scene_id} is out of range") + if not 0 <= camera_id < len(self._cameras): + raise IndexError(f"camera_id {camera_id} is out of range") + + frame_count = int(camera_poses.shape[0]) + if len(timestamps_us) != frame_count: + raise ValueError("timestamps_us must match the camera pose count") + timestamp_tensor = torch.as_tensor(timestamps_us, dtype=torch.int64).cpu() + return self.render( + torch.full((frame_count,), scene_id, dtype=torch.int32), + torch.full((frame_count,), camera_id, dtype=torch.int32), + timestamp_tensor, + torch.full((frame_count,), camera_type_id, dtype=torch.int32), + camera_poses, + resolution, + ) + + +# Explicit name for backend selectors; retain the shorter historical name for +# callers that imported the prototype directly. +LudusVulkanTimestampedContext = LudusTimestampedContext diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/compile.sh b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/compile.sh new file mode 100644 index 000000000..eae1b0685 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/compile.sh @@ -0,0 +1,63 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Compile the EXT-style timestamped mesh-shader pipeline to SPIR-V and +# embed the bytecode into a C++ header for the Vulkan renderer. +# +# Prerequisites: +# - glslangValidator (Vulkan SDK or distro package) on PATH, or +# GLSLANG_VALIDATOR / VULKAN_SDK env var pointing at it. +# - python3 with the standard library. +set -euo pipefail +SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd) +cd "$SCRIPT_DIR" + +if [ -n "${GLSLANG_VALIDATOR:-}" ] && [ -x "$GLSLANG_VALIDATOR" ]; then + GLSLANG="$GLSLANG_VALIDATOR" +elif [ -n "${VULKAN_SDK:-}" ] && [ -x "$VULKAN_SDK/bin/glslangValidator" ]; then + GLSLANG="$VULKAN_SDK/bin/glslangValidator" +elif [ -n "${VULKAN_SDK:-}" ] && [ -x "$VULKAN_SDK/x86_64/bin/glslangValidator" ]; then + GLSLANG="$VULKAN_SDK/x86_64/bin/glslangValidator" +else + GLSLANG=$(command -v glslangValidator || true) +fi + +if [ -z "${GLSLANG:-}" ]; then + echo "error: glslangValidator not found. Install the Vulkan SDK or set GLSLANG_VALIDATOR." >&2 + exit 2 +fi + +echo "Using: $GLSLANG" +"$GLSLANG" --version 2>/dev/null | head -1 || true + +GLSL_FILES=( + ts_polyline.task.glsl ts_polyline.mesh.glsl ts_polyline.frag.glsl + ts_polygon.task.glsl ts_polygon.mesh.glsl ts_polygon.frag.glsl + ts_obstacle.task.glsl ts_obstacle.mesh.glsl ts_obstacle.frag.glsl + ts_export.comp.glsl +) + +failed=0 +for f in "${GLSL_FILES[@]}"; do + if [ ! -f "$f" ]; then + echo " missing source: $f" + failed=$((failed+1)) + continue + fi + spv="${f%.glsl}.spv" + if "$GLSLANG" --target-env vulkan1.3 --target-env spirv1.6 -V -o "$spv" "$f"; then + : + else + failed=$((failed+1)) + fi +done + +if [ $failed -ne 0 ]; then + echo "FAILED: $failed shader(s) did not compile" + exit 1 +fi + +echo "All shaders compiled. Embedding into C++ header..." +python3 "$SCRIPT_DIR/embed_spv.py" +echo "Done." diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/embed_spv.py b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/embed_spv.py new file mode 100644 index 000000000..cb763861b --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/embed_spv.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +"""Embed the timestamped SPIR-V shader modules into a C++ header. + +The generated header (``_cpp/render/shaders_spv.h``) defines one +``static const uint32_t kSpv_[]`` array per stage. The Vulkan +renderer includes this header and feeds the arrays directly to +``vkCreateShaderModule`` -- no runtime file loading required. + +Normally invoked automatically by ``compile.sh`` after it compiles the GLSL to +SPIR-V; run it directly only to re-embed already-compiled ``.spv`` files: + + python3 ludus_renderer/shaders/embed_spv.py +""" + +from __future__ import annotations + +import os +import struct +import sys + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +OUT_HEADER = os.path.normpath( + os.path.join(SCRIPT_DIR, "..", "_cpp", "render", "shaders_spv.h") +) + +SPV_FILES = [ + ("ts_polyline_task", "ts_polyline.task.spv"), + ("ts_polyline_mesh", "ts_polyline.mesh.spv"), + ("ts_polyline_frag", "ts_polyline.frag.spv"), + ("ts_polygon_task", "ts_polygon.task.spv"), + ("ts_polygon_mesh", "ts_polygon.mesh.spv"), + ("ts_polygon_frag", "ts_polygon.frag.spv"), + ("ts_obstacle_task", "ts_obstacle.task.spv"), + ("ts_obstacle_mesh", "ts_obstacle.mesh.spv"), + ("ts_obstacle_frag", "ts_obstacle.frag.spv"), + ("ts_export_comp", "ts_export.comp.spv"), +] + +HEADER_TOP = """\ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +// +// AUTOGENERATED by ludus_renderer/shaders/embed_spv.py +// DO NOT EDIT BY HAND. Regenerate with: +// bash ludus_renderer/shaders/compile.sh (compiles GLSL -> SPIR-V and re-embeds) + +#pragma once +#include + +""" + + +def emit_array(name: str, data: bytes, out) -> int: + if len(data) % 4 != 0: + raise RuntimeError(f"{name}: SPIR-V length {len(data)} not 4-byte aligned") + words = struct.unpack(f"<{len(data) // 4}I", data) + out.write(f"static const uint32_t kSpv_{name}[] = {{\n") + for i in range(0, len(words), 8): + chunk = ", ".join(f"0x{w:08x}u" for w in words[i : i + 8]) + out.write(f" {chunk},\n") + out.write("};\n\n") + return len(words) + + +def main() -> int: + missing = [ + fn for _, fn in SPV_FILES if not os.path.exists(os.path.join(SCRIPT_DIR, fn)) + ] + if missing: + print("Missing .spv files (run compile.sh first):", file=sys.stderr) + for m in missing: + print(f" {m}", file=sys.stderr) + return 1 + + os.makedirs(os.path.dirname(OUT_HEADER), exist_ok=True) + with open(OUT_HEADER, "w") as out: + out.write(HEADER_TOP) + total_words = 0 + for var, fn in SPV_FILES: + with open(os.path.join(SCRIPT_DIR, fn), "rb") as f: + data = f.read() + words = emit_array(var, data, out) + total_words += words + print(f" {fn:30s} -> kSpv_{var:20s} ({words * 4} bytes)") + out.write(f"// total embedded SPIR-V: {total_words * 4} bytes\n") + print(f"Wrote {OUT_HEADER}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_export.comp.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_export.comp.glsl new file mode 100644 index 000000000..056e0a493 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_export.comp.glsl @@ -0,0 +1,56 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 + +// The graphics pass resolves visibility into this cached Vulkan-only image. +// This compute pass is the sole writer of the CUDA-visible linear allocation, +// avoiding unordered fragment SSBO stores while retaining zero-copy interop. +layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in; + +layout(set = 0, binding = 14, std430) writeonly buffer OutputPixels { + uint rgba8[]; +} output_pixels; + +layout(set = 0, binding = 15, rgba8) uniform readonly image2DArray color_image; + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +void main() { + uvec3 pixel = gl_GlobalInvocationID; + if (pixel.x >= pc.u_output_width || + pixel.y >= pc.u_output_height || + pixel.z >= pc.u_num_queries) { + return; + } + + vec4 color = imageLoad(color_image, ivec3(pixel)); + uvec4 rgba = uvec4(clamp(color, 0.0, 1.0) * 255.0 + 0.5); + uint pixel_index = + (pixel.z * pc.u_output_height + pixel.y) * pc.u_output_width + pixel.x; + output_pixels.rgba8[pixel_index] = + rgba.r | (rgba.g << 8) | (rgba.b << 16) | (rgba.a << 24); +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.frag.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.frag.glsl new file mode 100644 index 000000000..db8650493 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.frag.glsl @@ -0,0 +1,67 @@ + +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_fragment_shader_barycentric : require +#extension GL_EXT_mesh_shader : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Per-primitive gradient data from mesh shader (no per-vertex outputs needed!) +layout(location = 0) perprimitiveEXT in CubeGradientBlock { + vec3 corner_t; // gradient t values at triangle's 3 corners + vec3 front_color; + vec3 back_color; + float is_bev; // 1.0 for BEV cameras (disables fog), 0.0 otherwise +} prim_in; + +layout(location = 0) out vec4 out_color; + +layout(early_fragment_tests) in; + + +IF_ZMODIFY(layout(location = 0) uniform float in_dummy;) + +void main() { + // Interpolate gradient t using hardware barycentric coordinates + float t = dot(prim_in.corner_t, gl_BaryCoordEXT); + + // Compute gradient color + vec3 color = mix(prim_in.back_color, prim_in.front_color, t); + + // Apply distance-based fog (darken with distance) - disabled for BEV cameras + if (pc.u_fog_enabled > 0.5 && prim_in.is_bev < 0.5) { + float fog_factor = 1.0 - gl_FragCoord.z; + fog_factor = clamp(fog_factor, 0.0, 1.0); + color *= fog_factor; + } + + out_color = vec4(clamp(color, 0.0, 1.0), 1.0); + IF_ZMODIFY(gl_FragDepth = gl_FragCoord.z + in_dummy;) +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.mesh.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.mesh.glsl new file mode 100644 index 000000000..ebcdf27f5 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.mesh.glsl @@ -0,0 +1,1135 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_mesh_shader : require +#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Cap styles +const uint CAP_NONE = 0u; +const uint CAP_FLAT = 1u; +const uint CAP_ROUND = 2u; + +// Primitive type IDs (must match Python PRIM_* constants in ops.py) +const uint PRIM_ROAD_BOUNDARY = 0u; +const uint PRIM_LANE_LINE = 1u; // Legacy cyan lane line +const uint PRIM_CROSSWALK = 2u; +const uint PRIM_STATIC_OBSTACLE = 3u; // Legacy, avoid using +const uint PRIM_EGO_TRAJECTORY = 4u; +const uint PRIM_OBSTACLE = 5u; +const uint PRIM_EGO_OBSTACLE = 6u; +const uint PRIM_WAIT_LINE = 7u; +const uint PRIM_POLE = 8u; +const uint PRIM_ROAD_MARKING = 9u; +const uint PRIM_LANE_BOUNDARY = 10u; +const uint PRIM_TRAFFIC_LIGHT = 11u; +const uint PRIM_TRAFFIC_SIGN = 12u; +const uint PRIM_INTERSECTION = 13u; +const uint PRIM_ROAD_ISLAND = 14u; +const uint PRIM_BUFFER_ZONE = 15u; +// Lane line variants by color/style +const uint PRIM_LANE_LINE_WHITE_SOLID = 16u; +const uint PRIM_LANE_LINE_WHITE_DASHED = 17u; +const uint PRIM_LANE_LINE_YELLOW_SOLID = 18u; +const uint PRIM_LANE_LINE_YELLOW_DASHED = 19u; +// Dot primitives - each vertex is rendered as a circle +const uint PRIM_DOT_YELLOW = 20u; +const uint PRIM_DOT_WHITE = 21u; + +// Camera type IDs +const uint CAMERA_TYPE_REGULAR = 0u; +const uint CAMERA_TYPE_BEV = 1u; + +//============================================================================= +// Hardcoded Primitive Styles (matching wm-render colorscheme v3) +//============================================================================= + +// Colors (RGB normalized) - matching imaginaire4 v3 colorscheme +// Source: imaginaire4/imaginaire/auxiliary/world_scenario/color_scheme/config_color_hdmap.json +const vec3 COLOR_ROAD_BOUNDARY = vec3(253.0/255.0, 1.0/255.0, 232.0/255.0); // Magenta (253, 1, 232) +const vec3 COLOR_LANE_LINE = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (98, 183, 249) - "lanelines" (legacy) +const vec3 COLOR_CROSSWALK = vec3(139.0/255.0, 93.0/255.0, 255.0/255.0); // Purple (139, 93, 255) +const vec3 COLOR_STATIC_OBSTACLE = vec3(255.0/255.0, 100.0/255.0, 0.0/255.0); // Orange (legacy) +const vec3 COLOR_EGO_TRAJECTORY = vec3(0.0/255.0, 255.0/255.0, 0.0/255.0); // Green (0, 255, 0) +const vec3 COLOR_WAIT_LINE = vec3(108.0/255.0, 179.0/255.0, 59.0/255.0); // Yellow-green (108, 179, 59) +const vec3 COLOR_POLE = vec3(183.0/255.0, 69.0/255.0, 177.0/255.0); // Purple-magenta (183, 69, 177) +const vec3 COLOR_ROAD_MARKING = vec3(20.0/255.0, 254.0/255.0, 185.0/255.0); // Cyan-green (20, 254, 185) +const vec3 COLOR_LANE_BOUNDARY = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (same as lane line) +const vec3 COLOR_TRAFFIC_LIGHT = vec3(100.0/255.0, 100.0/255.0, 100.0/255.0); // Gray (100, 100, 100) +const vec3 COLOR_TRAFFIC_SIGN = vec3(8.0/255.0, 2.0/255.0, 255.0/255.0); // Blue (8, 2, 255) +const vec3 COLOR_INTERSECTION = vec3(80.0/255.0, 80.0/255.0, 120.0/255.0); // Dark blue-gray (approximated) +const vec3 COLOR_ROAD_ISLAND = vec3(60.0/255.0, 120.0/255.0, 60.0/255.0); // Dark green (approximated) +const vec3 COLOR_BUFFER_ZONE = vec3(120.0/255.0, 80.0/255.0, 80.0/255.0); // Dark red-brown (approximated) +// Lane line variants from config_color_geometry_laneline.json +const vec3 COLOR_LANE_LINE_WHITE = vec3(255.0/255.0, 255.0/255.0, 255.0/255.0); // White (255, 255, 255) +const vec3 COLOR_LANE_LINE_YELLOW = vec3(255.0/255.0, 255.0/255.0, 0.0/255.0); // Yellow (255, 255, 0) + +// Default polyline widths (pixels at reference resolution 1280x720) +const float DEFAULT_WIDTH_POLYLINE_REGULAR = 7.0; +const float DEFAULT_WIDTH_POLYLINE_BEV = 4.0; +const float DEFAULT_WIDTH_EGO_TRAJ_REGULAR = 12.0; +const float DEFAULT_WIDTH_EGO_TRAJ_BEV = 5.0; +const float DEFAULT_WIDTH_POLE_REGULAR = 5.0; // Poles are thinner (reference: 5 vs 12) +const float DEFAULT_WIDTH_POLE_BEV = 3.0; +const float DEFAULT_WIDTH_WIREFRAME = 2.0; + +// Configurable width uniforms (set from Python, or use defaults) + +// Compute depth-based scaling factor for line width +// z_ndc is in [-1, 1] where -1 is near, +1 is far +// Returns 1.0 at near, 0.0 at far (linear fade) +float get_depth_scale(vec4 clip) { + if (pc.u_depth_scaling < 0.5) return 1.0; // Disabled + float z_ndc = clip.z / clip.w; // Convert to NDC + float depth_scale = 1.0 - z_ndc; // Map [-1,1] to [1,0] + return clamp(depth_scale, 0.0, 1.0); +} + +// Color palette buffer (optional, configured from Python) +// Declared early so get_prim_color can use it; actual buffer layout defined later +layout(std430, binding = 10) readonly buffer ColorPaletteBufferEarly { + vec4 g_color_palette[]; +}; + +// Get default color for primitive type (hardcoded fallback) +vec3 get_default_prim_color(uint prim_type_id) { + if (prim_type_id == PRIM_ROAD_BOUNDARY) return COLOR_ROAD_BOUNDARY; + if (prim_type_id == PRIM_LANE_LINE) return COLOR_LANE_LINE; + if (prim_type_id == PRIM_CROSSWALK) return COLOR_CROSSWALK; + if (prim_type_id == PRIM_STATIC_OBSTACLE) return COLOR_STATIC_OBSTACLE; + if (prim_type_id == PRIM_EGO_TRAJECTORY) return COLOR_EGO_TRAJECTORY; + if (prim_type_id == PRIM_WAIT_LINE) return COLOR_WAIT_LINE; + if (prim_type_id == PRIM_POLE) return COLOR_POLE; + if (prim_type_id == PRIM_ROAD_MARKING) return COLOR_ROAD_MARKING; + if (prim_type_id == PRIM_LANE_BOUNDARY) return COLOR_LANE_BOUNDARY; + if (prim_type_id == PRIM_TRAFFIC_LIGHT) return COLOR_TRAFFIC_LIGHT; + if (prim_type_id == PRIM_TRAFFIC_SIGN) return COLOR_TRAFFIC_SIGN; + if (prim_type_id == PRIM_INTERSECTION) return COLOR_INTERSECTION; + if (prim_type_id == PRIM_ROAD_ISLAND) return COLOR_ROAD_ISLAND; + if (prim_type_id == PRIM_BUFFER_ZONE) return COLOR_BUFFER_ZONE; + // Lane line variants + if (prim_type_id == PRIM_LANE_LINE_WHITE_SOLID) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_WHITE_DASHED) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_SOLID) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_DASHED) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_YELLOW) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_WHITE) return COLOR_LANE_LINE_WHITE; + return vec3(1.0, 1.0, 1.0); // Default white for obstacles +} + +// Get color for primitive type (checks palette first, then falls back to defaults) +vec3 get_prim_color(uint prim_type_id) { + // If color palette is configured, check if this prim_type has a custom color + // Alpha < 0 means "use default", alpha >= 0 means "use this color" + if (pc.u_color_palette_size > 0 && prim_type_id < uint(pc.u_color_palette_size)) { + vec4 palette_color = g_color_palette[prim_type_id]; + if (palette_color.a >= 0.0) { + return palette_color.rgb; + } + } + // Fall back to hardcoded defaults + return get_default_prim_color(prim_type_id); +} + +// Check if primitive is a dot type (rendered as circles at each vertex) +bool is_dot_primitive(uint prim_type_id) { + return prim_type_id == PRIM_DOT_YELLOW || prim_type_id == PRIM_DOT_WHITE; +} + +// Get polyline width for primitive type and camera type (scaled by resolution) +float get_prim_width(uint prim_type_id, uint camera_type_id) { + bool is_bev = (camera_type_id == CAMERA_TYPE_BEV); + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + + float base_width; + if (prim_type_id == PRIM_EGO_TRAJECTORY) { + float default_w = is_bev ? DEFAULT_WIDTH_EGO_TRAJ_BEV : DEFAULT_WIDTH_EGO_TRAJ_REGULAR; + float custom_w = is_bev ? pc.u_width_ego_traj_bev : pc.u_width_ego_traj_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } else if (prim_type_id == PRIM_POLE) { + // Poles use thinner lines (reference: 5 pixels vs 12 for other polylines) + base_width = is_bev ? DEFAULT_WIDTH_POLE_BEV : DEFAULT_WIDTH_POLE_REGULAR; + } else { + float default_w = is_bev ? DEFAULT_WIDTH_POLYLINE_BEV : DEFAULT_WIDTH_POLYLINE_REGULAR; + float custom_w = is_bev ? pc.u_width_polyline_bev : pc.u_width_polyline_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } + return base_width * scale; +} + +// Get wireframe edge width (scaled by resolution) +float get_wireframe_width() { + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + float base_width = (pc.u_width_wireframe > 0.0) ? pc.u_width_wireframe : DEFAULT_WIDTH_WIREFRAME; + return base_width * scale; +} + +//============================================================================= +// Data Structures (must match C++ structs) +//============================================================================= + +// TimestampedPolylinePool (64 bytes) +struct TimestampedPolylinePool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint vertices_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4, _pad5, _pad6, _pad7; // Padding to 64 bytes +}; + +// TimestampedPolygonPool (64 bytes) +struct TimestampedPolygonPool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint num_triangles; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint tri_ps_offset; + uint vertices_offset; + uint triangles_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4; // Padding to 64 bytes (16 uints) +}; + +// CubePool (64 bytes) - used for obstacles, traffic lights, traffic signs, etc. +// Renamed from ObstaclePool but keeping struct name for backward compat +struct ObstaclePool { + uint num_cubes; // Was: num_obstacles + uint num_timestamps; + uint num_track_poses; + uint prim_type_id; // Semantic type for color lookup + uint timestamps_offset; // Global timestamps for this pool + uint cube_ts_ps_offset; // Per-cube track length prefix sum (was: obstacle_ts_ps_offset) + uint track_timestamps_offset; // Per-pose timestamps in float buffer (as 2x uint for int64) + uint translations_offset; // Per-pose translations (3 floats each) + uint quaternions_offset; // Per-pose quaternions (4 floats each) + uint scales_offset; // Per-cube scales (3 floats each) + uint colors_offset; // Per-cube colors (6 floats each) + uint render_flags; // CUBE_FLAG_* bits (e.g., CUBE_FLAG_WIREFRAME) + uint _pad2, _pad3, _pad4, _pad5; // 4 padding fields for 64 bytes total +}; + +// Cube render flags +const uint CUBE_FLAG_WIREFRAME = 1u; // Draw wireframe edges in addition to solid faces + +// TimestampedScene (128 bytes) +struct TimestampedScene { + uint num_polyline_pools; + uint polyline_pools_offset; + uint num_polygon_pools; + uint polygon_pools_offset; + uint num_cube_pools; // Was: has_obstacle_pool (0/1), now supports multiple + uint cube_pools_offset; // Was: obstacle_pool_offset + uint timestamps_buffer_offset; + uint int32_buffer_offset; + uint vertex_buffer_offset; + uint triangle_buffer_offset; + uint pose_buffer_offset; + uint float_buffer_offset; + uint _pad[20]; +}; + +// RenderQuery (16 bytes) +struct RenderQuery { + uint scene_id; + uint camera_id; + int64_t timestamp_us; + uint camera_type_id; // CAMERA_TYPE_REGULAR or CAMERA_TYPE_BEV + uint _pad1, _pad2, _pad3; // Padding to 32 bytes +}; + +// FThetaCamera (72 bytes) +struct FThetaCamera { + float cx, cy; + float img_w, img_h; + float poly0, poly1, poly2, poly3, poly4, poly5; + float max_ray_angle; + float max_distortion_val; + float max_distortion_dval; + float depth_max; + float ld_c, ld_d, ld_e, ld_f; +}; + +// CameraPose (64 bytes) +struct CameraPose { + mat4 world_to_camera; +}; + +// Vertex (16 bytes) +struct Vertex { + float x, y, z; + float _pad; +}; + +//============================================================================= +// Buffer Bindings +//============================================================================= + +// Global data buffers +layout(std430, binding = 0) readonly buffer TimestampsBuffer { + int64_t g_timestamps[]; +}; + +layout(std430, binding = 1) readonly buffer Int32Buffer { + int g_int32[]; +}; + +layout(std430, binding = 2) readonly buffer VertexBuffer { + Vertex g_vertices[]; +}; + +layout(std430, binding = 3) readonly buffer TriangleBuffer { + uvec3 g_triangles[]; +}; + +layout(std430, binding = 4) readonly buffer PoseBuffer { + CameraPose g_poses[]; +}; + +layout(std430, binding = 5) readonly buffer FloatBuffer { + float g_floats[]; +}; + +// Scene metadata +layout(std430, binding = 6) readonly buffer SceneBuffer { + TimestampedScene g_scenes[]; +}; + +layout(std430, binding = 7) readonly buffer PolylinePoolBuffer { + TimestampedPolylinePool g_polyline_pools[]; +}; + +layout(std430, binding = 8) readonly buffer PolygonPoolBuffer { + TimestampedPolygonPool g_polygon_pools[]; +}; + +layout(std430, binding = 9) readonly buffer ObstaclePoolBuffer { + ObstaclePool g_obstacle_pools[]; +}; + +// Camera buffers +layout(std430, binding = 11) readonly buffer CameraIntrinsicsBuffer { + FThetaCamera g_camera_intrinsics[]; +}; + +layout(std430, binding = 12) readonly buffer CameraPoseBuffer { + CameraPose g_camera_poses[]; // One per query (dynamic viewpoints) +}; + +// Query buffer +layout(std430, binding = 13) readonly buffer QueryBuffer { + RenderQuery g_queries[]; +}; + +// Uniforms +// Spatial culling: elements beyond depth_max * scale from the camera are +// discarded in the task shader. Scale > 1 gives headroom so nothing at +// the visible boundary pops in/out. Set to 0 to disable culling. + +//============================================================================= +// GPU Binary Search +// Returns index of last element <= target, or -1 if target < all elements +//============================================================================= + +int binary_search_timestamps(uint base_offset, uint count, int64_t target) { + if (count == 0u) return -1; + + int left = 0; + int right = int(count) - 1; + int result = -1; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t val = g_timestamps[base_offset + uint(mid)]; + + if (val <= target) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + + return result; +} + +//============================================================================= +// Quaternion Math for Track Interpolation +//============================================================================= + +// Quaternion dot product +float quat_dot(vec4 a, vec4 b) { + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +// Quaternion normalize +vec4 quat_normalize(vec4 q) { + float len = length(q); + return len > 1e-10 ? q / len : vec4(0.0, 0.0, 0.0, 1.0); +} + +// Quaternion spherical linear interpolation (slerp) +vec4 quat_slerp(vec4 q0, vec4 q1, float t) { + // Ensure shortest path + float d = quat_dot(q0, q1); + if (d < 0.0) { + q1 = -q1; + d = -d; + } + + // If quaternions are very close, use linear interpolation + if (d > 0.9995) { + return quat_normalize(mix(q0, q1, t)); + } + + // Spherical interpolation + float theta_0 = acos(clamp(d, -1.0, 1.0)); + float theta = theta_0 * t; + float sin_theta = sin(theta); + float sin_theta_0 = sin(theta_0); + + float s0 = cos(theta) - d * sin_theta / sin_theta_0; + float s1 = sin_theta / sin_theta_0; + + return quat_normalize(s0 * q0 + s1 * q1); +} + +// Convert quaternion (x, y, z, w) to 3x3 rotation matrix +// GLSL mat3 is column-major: mat3(col0, col1, col2) +mat3 quat_to_matrix(vec4 q) { + float x = q.x, y = q.y, z = q.z, w = q.w; + + float x2 = x + x, y2 = y + y, z2 = z + z; + float xx = x * x2, xy = x * y2, xz = x * z2; + float yy = y * y2, yz = y * z2, zz = z * z2; + float wx = w * x2, wy = w * y2, wz = w * z2; + + // Column 0: (R00, R10, R20), Column 1: (R01, R11, R21), Column 2: (R02, R12, R22) + return mat3( + 1.0 - (yy + zz), xy + wz, xz - wy, // Column 0 + xy - wz, 1.0 - (xx + zz), yz + wx, // Column 1 + xz + wy, yz - wx, 1.0 - (xx + yy) // Column 2 + ); +} + +// Build 4x4 transform from translation and quaternion (with scale) +mat4 build_transform(vec3 translation, vec4 quaternion, vec3 scale) { + mat3 rot = quat_to_matrix(quaternion); + + // Apply scale to each column of rotation matrix + mat4 result = mat4( + vec4(rot[0] * scale.x, 0.0), + vec4(rot[1] * scale.y, 0.0), + vec4(rot[2] * scale.z, 0.0), + vec4(translation, 1.0) + ); + + return result; +} + +// Binary search for track interpolation (returns index where t0 <= target < t1) +// Returns -1 if target is outside the track range +int binary_search_track(uint base_offset, uint count, int64_t target) { + if (count < 2u) return -1; // Need at least 2 points for interpolation + + int64_t first_ts = g_timestamps[base_offset]; + int64_t last_ts = g_timestamps[base_offset + count - 1u]; + + // Check bounds + if (target < first_ts || target > last_ts) return -1; + + int left = 0; + int right = int(count) - 2; // Max valid index for interpolation start + int result = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[base_offset + uint(mid)]; + int64_t t1 = g_timestamps[base_offset + uint(mid) + 1u]; + + if (t0 <= target && target <= t1) { + return mid; + } else if (target < t0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + + return -1; // Should not reach here for valid input +} + +//============================================================================= +// Spatial Culling Helpers +//============================================================================= + +// AABB-AABB overlap test +bool cull_aabb_overlap(vec3 a_min, vec3 a_max, vec3 b_min, vec3 b_max) { + return all(lessThanEqual(a_min, b_max)) && all(greaterThanEqual(a_max, b_min)); +} + +// Sphere-AABB overlap test +bool cull_sphere_aabb_overlap(vec3 center, float radius, vec3 b_min, vec3 b_max) { + vec3 nearest = clamp(center, b_min, b_max); + vec3 d = center - nearest; + return dot(d, d) <= radius * radius; +} + +// Extract camera world position from view pose +vec3 get_camera_world_pos(CameraPose pose) { + mat3 R = mat3(pose.world_to_camera); + return -transpose(R) * pose.world_to_camera[3].xyz; +} + +//============================================================================= +// F-theta Projection +//============================================================================= + +vec3 rotate_rodrigues(vec3 v, vec3 r) { + float theta = length(r); + if (theta < 1e-8) return v; + vec3 k = r / theta; + float c = cos(theta); + float s = sin(theta); + return v * c + cross(k, v) * s + k * dot(k, v) * (1.0 - c); +} + +// F-theta projection: world point -> NDC +// Supports >180° FOV fisheye cameras where points can have negative z (behind camera plane) +vec4 ftheta_project(vec3 world_pos, CameraPose pose, FThetaCamera cam) { + vec3 cam_pt = (pose.world_to_camera * vec4(world_pos, 1.0)).xyz; + float depth = cam_pt.z; + + float ray_norm = length(cam_pt); + + // Handle points at camera origin + if (ray_norm < 1e-6) { + return vec4(0.0, 0.0, 0.0, 1.0); + } + + float half_pi = 1.5707963; // π/2 + + // For cameras with FOV <= 180° (max_ray_angle <= π/2), points behind camera should be clipped + // Use pseudo-pinhole projection to push them far away in the correct direction + if (cam.max_ray_angle <= half_pi && depth < 0.001) { + float pseudo_focal = cam.poly1; + float x_clip = cam_pt.x * pseudo_focal / (cam.img_w * 0.5); + float y_clip = -cam_pt.y * pseudo_focal / (cam.img_h * 0.5); + return vec4(x_clip * 10.0, y_clip * 10.0, 1.0, 1.0); // Scale by 10 to push far outside + } + + float xy_norm = length(cam_pt.xy); + float cos_alpha = clamp(cam_pt.z / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); // alpha in [0, π] + + // Apply polynomial projection (with linear extrapolation beyond max_ray_angle) + float a2 = alpha * alpha; + float a3 = a2 * alpha; + float a4 = a2 * a2; + float a5 = a4 * alpha; + + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * a3 + cam.poly4 * a4 + cam.poly5 * a5; + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt.xy; + + vec2 pixel_dist; + pixel_dist.x = cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y; + pixel_dist.y = cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y; + + vec2 pixel = pixel_dist + vec2(cam.cx, cam.cy); + + float x_ndc = 2.0 * pixel.x / cam.img_w - 1.0; + float y_ndc = 1.0 - 2.0 * pixel.y / cam.img_h; + + // For z-buffer depth mapping: + // - Narrow FOV (<=180°): use signed depth (cam_pt.z) + // - Wide FOV (>180°): use ray_norm for front-camera vertices (unchanged), + // but push behind-camera vertices to depth_max so they never occlude + // forward geometry. ray_norm alone can't distinguish front from behind. + float z_value; + if (cam.max_ray_angle > half_pi) { + z_value = (depth >= 0.0) ? ray_norm : cam.depth_max; + } else { + z_value = depth; + } + float z_ndc = clamp(z_value / cam.depth_max, 0.0, 1.0); + + return vec4(x_ndc, y_ndc, z_ndc, 1.0); +} + +// Inline version that takes mat4 directly +float estimate_edge_distortion_pixels_mat4(vec3 v0, vec3 v1, mat4 world_to_cam, FThetaCamera cam) { + // Transform to camera space + vec3 cam_pt0 = (world_to_cam * vec4(v0, 1.0)).xyz; + vec3 cam_pt1 = (world_to_cam * vec4(v1, 1.0)).xyz; + vec3 mid_world = (v0 + v1) * 0.5; + vec3 cam_pt_mid = (world_to_cam * vec4(mid_world, 1.0)).xyz; + + // Just clamp depths to avoid division issues + + // For segments in front of camera, compute f-theta projection error directly + // Use depth-clamped projection to handle near-plane cases + float depth0 = max(cam_pt0.z, 0.001); + float depth1 = max(cam_pt1.z, 0.001); + float depth_mid = max(cam_pt_mid.z, 0.001); + + // Compute f-theta projection for each point + // We inline the projection to avoid struct-passing issues + vec2 pixel0, pixel1, pixel_mid; + { + float xy_norm = length(cam_pt0.xy); + float ray_norm = length(vec3(cam_pt0.xy, depth0)) + 1e-10; + float cos_alpha = clamp(depth0 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt0.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel0 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt1.xy); + float ray_norm = length(vec3(cam_pt1.xy, depth1)) + 1e-10; + float cos_alpha = clamp(depth1 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt1.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel1 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt_mid.xy); + float ray_norm = length(vec3(cam_pt_mid.xy, depth_mid)) + 1e-10; + float cos_alpha = clamp(depth_mid / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt_mid.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel_mid = pixel_dist + vec2(cam.cx, cam.cy); + } + + // Compute error: distance from projected midpoint to linear interpolation + vec2 linear_pixel_mid = (pixel0 + pixel1) * 0.5; + float error_pixels = length(pixel_mid - linear_pixel_mid); + + // Clamp to reasonable range to handle edge cases + return clamp(error_pixels, 0.0, 10000.0); +} + +uint compute_subdivision_level(vec3 v0, vec3 v1, CameraPose pose, FThetaCamera cam, float threshold_pixels) { + float error = estimate_edge_distortion_pixels_mat4(v0, v1, pose.world_to_camera, cam); + + if (error < threshold_pixels) return 0u; + if (error < threshold_pixels * 2.0) return 1u; + if (error < threshold_pixels * 4.0) return 2u; + return 3u; +} + +//============================================================================= +// Barycentric Subdivision Utilities (shared with polygon/cube) +//============================================================================= + +uint bary_vertex_count(uint level) { + // Vertices = (n+1)(n+2)/2 where n = 2^level + if (level == 0u) return 3u; + if (level == 1u) return 6u; + if (level == 2u) return 15u; + return 45u; // level 3 +} + +uint bary_triangle_count(uint level) { + // Triangles = 4^level + if (level == 0u) return 1u; + if (level == 1u) return 4u; + if (level == 2u) return 16u; + return 64u; // level 3 +} + +vec2 bary_vertex_uv(uint vertex_idx, uint level) { + if (level == 0u) { + if (vertex_idx == 0u) return vec2(0.0, 0.0); + if (vertex_idx == 1u) return vec2(1.0, 0.0); + return vec2(0.0, 1.0); + } else if (level == 1u) { + vec2 uvs[6]; + uvs[0] = vec2(0.0, 0.0); + uvs[1] = vec2(1.0, 0.0); + uvs[2] = vec2(0.0, 1.0); + uvs[3] = vec2(0.5, 0.0); + uvs[4] = vec2(0.5, 0.5); + uvs[5] = vec2(0.0, 0.5); + return uvs[vertex_idx]; + } else if (level == 2u) { + uint row, col; + if (vertex_idx < 5u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 9u) { row = 1u; col = vertex_idx - 5u; } + else if (vertex_idx < 12u) { row = 2u; col = vertex_idx - 9u; } + else if (vertex_idx < 14u) { row = 3u; col = vertex_idx - 12u; } + else { row = 4u; col = 0u; } + return vec2(float(col) / 4.0, float(row) / 4.0); + } else { + // Level 3: 9 rows (0-8), row r has (9-r) vertices + uint row, col; + if (vertex_idx < 9u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 17u) { row = 1u; col = vertex_idx - 9u; } + else if (vertex_idx < 24u) { row = 2u; col = vertex_idx - 17u; } + else if (vertex_idx < 30u) { row = 3u; col = vertex_idx - 24u; } + else if (vertex_idx < 35u) { row = 4u; col = vertex_idx - 30u; } + else if (vertex_idx < 39u) { row = 5u; col = vertex_idx - 35u; } + else if (vertex_idx < 42u) { row = 6u; col = vertex_idx - 39u; } + else if (vertex_idx < 44u) { row = 7u; col = vertex_idx - 42u; } + else { row = 8u; col = 0u; } + return vec2(float(col) / 8.0, float(row) / 8.0); + } +} + +vec3 bary_interpolate(vec3 v0, vec3 v1, vec3 v2, vec2 uv) { + float w = 1.0 - uv.x - uv.y; + return v0 * w + v1 * uv.x + v2 * uv.y; +} + +uvec3 bary_triangle_indices(uint tri_idx, uint level) { + if (level == 0u) { + return uvec3(0u, 1u, 2u); + } else if (level == 1u) { + uvec3 tris[4]; + tris[0] = uvec3(0u, 3u, 5u); + tris[1] = uvec3(3u, 1u, 4u); + tris[2] = uvec3(5u, 4u, 2u); + tris[3] = uvec3(3u, 4u, 5u); + return tris[tri_idx]; + } else if (level == 2u) { + uint row_start[5] = uint[5](0u, 5u, 9u, 12u, 14u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + if (t < 7u) { + row = 0u; + if (t < 4u) { col = t; is_down = false; } + else { col = t - 4u; is_down = true; } + } else if (t < 12u) { + row = 1u; + uint lt = t - 7u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 15u) { + row = 2u; + uint lt = t - 12u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 3u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } else { + // Level 3: row_start for 9 rows + uint row_start[9] = uint[9](0u, 9u, 17u, 24u, 30u, 35u, 39u, 42u, 44u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + // Row 0: 8 up + 7 down = 15, Row 1: 7 up + 6 down = 13, etc. + if (t < 15u) { + row = 0u; + if (t < 8u) { col = t; is_down = false; } + else { col = t - 8u; is_down = true; } + } else if (t < 28u) { + row = 1u; uint lt = t - 15u; + if (lt < 7u) { col = lt; is_down = false; } + else { col = lt - 7u; is_down = true; } + } else if (t < 39u) { + row = 2u; uint lt = t - 28u; + if (lt < 6u) { col = lt; is_down = false; } + else { col = lt - 6u; is_down = true; } + } else if (t < 48u) { + row = 3u; uint lt = t - 39u; + if (lt < 5u) { col = lt; is_down = false; } + else { col = lt - 5u; is_down = true; } + } else if (t < 55u) { + row = 4u; uint lt = t - 48u; + if (lt < 4u) { col = lt; is_down = false; } + else { col = lt - 4u; is_down = true; } + } else if (t < 60u) { + row = 5u; uint lt = t - 55u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 63u) { + row = 6u; uint lt = t - 60u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 7u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } +} + + +layout(local_size_x = 32) in; +// No per-vertex output arrays - all gradient data passed per-primitive +// This allows unlimited vertices (within mesh shader spec) +layout(triangles, max_vertices = 96, max_primitives = 128) out; + +struct ObstacleTaskPayload { + uint query_id; + uint obstacle_id; + mat4 object_to_world; + vec3 scale; + vec3 front_color; + vec3 back_color; + uint subdivision_level; // From task shader + uint render_flags; // CUBE_FLAG_* bits from pool + float is_bev; + uint face_mask; // Bitmask of front-facing faces +}; +taskPayloadSharedEXT ObstacleTaskPayload payload; + +out gl_MeshPerVertexNV { + vec4 gl_Position; +} gl_MeshVerticesEXT[]; + +perprimitiveEXT out gl_MeshPerPrimitiveNV { + int gl_Layer; +} gl_MeshPrimitivesEXT[]; + +// Per-primitive gradient data (no per-vertex outputs needed!) +layout(location = 0) perprimitiveEXT out CubeGradientBlock { + vec3 corner_t; // gradient t values at triangle's 3 corners + vec3 front_color; + vec3 back_color; + float is_bev; // 1.0 for BEV cameras (disables fog), 0.0 otherwise +} prim_out[]; + +// Unit cube vertices +const vec3 CUBE_VERTS[8] = vec3[8]( + vec3(-0.5, -0.5, -0.5), vec3(+0.5, -0.5, -0.5), + vec3(+0.5, +0.5, -0.5), vec3(-0.5, +0.5, -0.5), + vec3(-0.5, -0.5, +0.5), vec3(+0.5, -0.5, +0.5), + vec3(+0.5, +0.5, +0.5), vec3(-0.5, +0.5, +0.5) +); + +// Face vertex indices (CCW winding) +const uvec4 FACE_VERTS[6] = uvec4[6]( + uvec4(0, 3, 2, 1), // -Z (back) + uvec4(4, 5, 6, 7), // +Z (front) + uvec4(0, 4, 7, 3), // -X + uvec4(1, 2, 6, 5), // +X + uvec4(0, 1, 5, 4), // -Y + uvec4(3, 7, 6, 2) // +Y +); + +// 12 edges of cube (pairs of vertex indices) +const uvec2 CUBE_EDGES[12] = uvec2[12]( + uvec2(0,1), uvec2(1,2), uvec2(2,3), uvec2(3,0), // back face + uvec2(4,5), uvec2(5,6), uvec2(6,7), uvec2(7,4), // front face + uvec2(0,4), uvec2(1,5), uvec2(2,6), uvec2(3,7) // connecting edges +); + +// Edge wireframe color (light gray - matches reference: [200, 200, 200] / 255.0) +const vec3 EDGE_COLOR = vec3(0.784, 0.784, 0.784); + +void main() { + uint _prim_count = 0u; + uint workgroup_id = gl_WorkGroupID.x; + uint tid = gl_LocalInvocationID.x; + + RenderQuery query = g_queries[payload.query_id]; + FThetaCamera cam = g_camera_intrinsics[query.camera_id]; + CameraPose view_pose = g_camera_poses[payload.query_id]; + + // Workgroups 6-11 = wireframe edges (2 edges per workgroup, subdivided to match face tessellation) + if (workgroup_id >= 6u) { + uint wg_edge_offset = (workgroup_id - 6u) * 2u; // 0, 2, 4, 6, 8, 10 + float EDGE_WIDTH = get_wireframe_width(); + + // Edge-to-face adjacency for backface culling of wireframe edges + const uvec2 EDGE_FACES[12] = uvec2[12]( + uvec2(0, 4), uvec2(0, 3), uvec2(0, 5), uvec2(0, 2), + uvec2(1, 4), uvec2(1, 3), uvec2(1, 5), uvec2(1, 2), + uvec2(2, 4), uvec2(3, 4), uvec2(3, 5), uvec2(2, 5) + ); + + // Check if either edge in this workgroup is adjacent to a visible face + uint e0 = wg_edge_offset; + uint e1 = wg_edge_offset + 1u; + bool e0_vis = (payload.face_mask & ((1u << EDGE_FACES[e0].x) | (1u << EDGE_FACES[e0].y))) != 0u; + bool e1_vis = (payload.face_mask & ((1u << EDGE_FACES[e1].x) | (1u << EDGE_FACES[e1].y))) != 0u; + + if (!e0_vis && !e1_vis) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + // Number of segments per edge based on subdivision level (matches face tessellation) + // subdiv 0 = 1 segment, subdiv 1 = 2 segments, subdiv 2 = 4 segments + uint segs_per_edge = 1u << payload.subdivision_level; // 1, 2, or 4 + uint total_segments = segs_per_edge * 2u; // 2 edges + + uint total_edge_verts = total_segments * 4u; + _prim_count = total_segments * 2u; SetMeshOutputsEXT(total_edge_verts, _prim_count); // 2 triangles per segment quad + + // Process both edges in this workgroup + for (uint local_seg = tid; local_seg < total_segments; local_seg += 32u) { + uint edge_in_wg = local_seg / segs_per_edge; // 0 or 1 + uint seg_in_edge = local_seg % segs_per_edge; + uint edge_id = wg_edge_offset + edge_in_wg; + + // Skip edges adjacent only to back-facing faces + uvec2 adj = EDGE_FACES[edge_id]; + if ((payload.face_mask & ((1u << adj.x) | (1u << adj.y))) == 0u) { + uint base_vert = local_seg * 4u; + gl_MeshVerticesEXT[base_vert].gl_Position = vec4(0, 0, 0, 1); + gl_MeshVerticesEXT[base_vert + 1u].gl_Position = vec4(0, 0, 0, 1); + gl_MeshVerticesEXT[base_vert + 2u].gl_Position = vec4(0, 0, 0, 1); + gl_MeshVerticesEXT[base_vert + 3u].gl_Position = vec4(0, 0, 0, 1); + continue; + } + + // Get edge endpoints + uvec2 edge = CUBE_EDGES[edge_id]; + vec3 v0_local = CUBE_VERTS[edge.x] * payload.scale; + vec3 v1_local = CUBE_VERTS[edge.y] * payload.scale; + + vec3 v0_world = (payload.object_to_world * vec4(v0_local, 1.0)).xyz; + vec3 v1_world = (payload.object_to_world * vec4(v1_local, 1.0)).xyz; + + // Interpolate two world-space points for this segment + float t0 = float(seg_in_edge) / float(segs_per_edge); + float t1 = float(seg_in_edge + 1u) / float(segs_per_edge); + + vec3 pt0_world = mix(v0_world, v1_world, t0); + vec3 pt1_world = mix(v0_world, v1_world, t1); + + // Project to clip space (f-theta curvature applied here) + vec4 clip0 = ftheta_project(pt0_world, view_pose, cam); + vec4 clip1 = ftheta_project(pt1_world, view_pose, cam); + + // Edge direction and perpendicular for width + vec2 ndc0 = clip0.xy / clip0.w; + vec2 ndc1 = clip1.xy / clip1.w; + vec2 edge_dir = normalize(ndc1 - ndc0); + vec2 perp = vec2(-edge_dir.y, edge_dir.x); + vec2 offset = perp * EDGE_WIDTH / vec2(cam.img_w, cam.img_h); + + // Create 4 vertices for the quad + uint base_vert = local_seg * 4u; + + vec4 off0 = vec4(offset * clip0.w, 0.0, 0.0); + vec4 off1 = vec4(offset * clip1.w, 0.0, 0.0); + + // Depth bias to render edges on top of faces + float z_bias0 = -0.001 * clip0.w; + float z_bias1 = -0.001 * clip1.w; + + vec4 p0 = clip0 - off0; p0.z += z_bias0; + vec4 p1 = clip0 + off0; p1.z += z_bias0; + vec4 p2 = clip1 + off1; p2.z += z_bias1; + vec4 p3 = clip1 - off1; p3.z += z_bias1; + + gl_MeshVerticesEXT[base_vert + 0u].gl_Position = p0; + gl_MeshVerticesEXT[base_vert + 1u].gl_Position = p1; + gl_MeshVerticesEXT[base_vert + 2u].gl_Position = p2; + gl_MeshVerticesEXT[base_vert + 3u].gl_Position = p3; + } + + barrier(); + + // Generate triangle indices for segment quads + for (uint local_seg = tid; local_seg < total_segments; local_seg += 32u) { + uint base_vert = local_seg * 4u; + uint base_tri = local_seg * 2u; + + // Triangle 1: 0, 1, 2 + gl_PrimitiveTriangleIndicesEXT[base_tri + 0u] = uvec3(base_vert + 0u, base_vert + 1u, base_vert + 2u); + gl_MeshPrimitivesEXT[base_tri + 0u].gl_Layer = int(payload.query_id); + // Wireframe uses solid edge color (front = back = EDGE_COLOR, corner_t doesn't matter) + prim_out[base_tri + 0u].corner_t = vec3(0.5); + prim_out[base_tri + 0u].front_color = EDGE_COLOR; + prim_out[base_tri + 0u].back_color = EDGE_COLOR; + prim_out[base_tri + 0u].is_bev = payload.is_bev; + + // Triangle 2: 0, 2, 3 + gl_PrimitiveTriangleIndicesEXT[base_tri + 1u] = uvec3(base_vert + 0u, base_vert + 2u, base_vert + 3u); + gl_MeshPrimitivesEXT[base_tri + 1u].gl_Layer = int(payload.query_id); + prim_out[base_tri + 1u].corner_t = vec3(0.5); + prim_out[base_tri + 1u].front_color = EDGE_COLOR; + prim_out[base_tri + 1u].back_color = EDGE_COLOR; + prim_out[base_tri + 1u].is_bev = payload.is_bev; + } + + return; + } + + // Workgroups 0-5: Face rendering (2 triangles per face) + uint face_id = workgroup_id; + uint subdiv = payload.subdivision_level; + + // Backface culling: skip faces not visible from camera + if ((payload.face_mask & (1u << face_id)) == 0u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + // Get face corner info + uvec4 face = FACE_VERTS[face_id]; + + // Compute per-corner gradient t values and world positions + float corner_t[4]; + vec3 corners[4]; + for (uint i = 0u; i < 4u; i++) { + uint vert_idx = (i == 0u) ? face.x : (i == 1u) ? face.y : (i == 2u) ? face.z : face.w; + vec3 local_vert = CUBE_VERTS[vert_idx]; + corner_t[i] = local_vert.x + 0.5; // 0 at back (-X), 1 at front (+X) + corners[i] = (payload.object_to_world * vec4(local_vert * payload.scale, 1.0)).xyz; + } + + // Use shared barycentric subdivision utilities + uint verts_per_tri = bary_vertex_count(subdiv); + uint tris_per_tri = bary_triangle_count(subdiv); + + // 2 triangles per face + uint total_verts = verts_per_tri * 2u; + uint total_tris = tris_per_tri * 2u; + + _prim_count = total_tris; SetMeshOutputsEXT(total_verts, _prim_count); + + // Face = 2 triangles: (c0,c1,c2) and (c0,c2,c3) + vec3 tri_verts[6]; + float tri_t[6]; + tri_verts[0] = corners[0]; tri_verts[1] = corners[1]; tri_verts[2] = corners[2]; + tri_verts[3] = corners[0]; tri_verts[4] = corners[2]; tri_verts[5] = corners[3]; + tri_t[0] = corner_t[0]; tri_t[1] = corner_t[1]; tri_t[2] = corner_t[2]; + tri_t[3] = corner_t[0]; tri_t[4] = corner_t[2]; tri_t[5] = corner_t[3]; + + // Generate vertices for both triangles (position only, no per-vertex outputs) + for (uint t = 0u; t < 2u; t++) { + vec3 v0 = tri_verts[t * 3u]; + vec3 v1 = tri_verts[t * 3u + 1u]; + vec3 v2 = tri_verts[t * 3u + 2u]; + uint vert_base = t * verts_per_tri; + + for (uint v = tid; v < verts_per_tri; v += 32u) { + vec2 uv = bary_vertex_uv(v, subdiv); + vec3 pt = bary_interpolate(v0, v1, v2, uv); + vec4 clip = ftheta_project(pt, view_pose, cam); + gl_MeshVerticesEXT[vert_base + v].gl_Position = clip; + } + } + + barrier(); + + // Generate triangle indices and set per-primitive data (including corner_t) + for (uint t = 0u; t < 2u; t++) { + uint vert_base = t * verts_per_tri; + uint tri_base = t * tris_per_tri; + float t0 = tri_t[t * 3u]; + float t1 = tri_t[t * 3u + 1u]; + float t2 = tri_t[t * 3u + 2u]; + + for (uint i = tid; i < tris_per_tri; i += 32u) { + uvec3 idx = bary_triangle_indices(i, subdiv); + uint idx_base = (tri_base + i) * 3u; + gl_PrimitiveTriangleIndicesEXT[(idx_base) / 3u] = uvec3(vert_base + idx.x, vert_base + idx.y, vert_base + idx.z); + gl_MeshPrimitivesEXT[tri_base + i].gl_Layer = int(payload.query_id); + + // Compute gradient t values at each corner of this sub-triangle + vec2 uv0 = bary_vertex_uv(idx.x, subdiv); + vec2 uv1 = bary_vertex_uv(idx.y, subdiv); + vec2 uv2 = bary_vertex_uv(idx.z, subdiv); + vec3 corner_t_values = vec3( + (1.0 - uv0.x - uv0.y) * t0 + uv0.x * t1 + uv0.y * t2, + (1.0 - uv1.x - uv1.y) * t0 + uv1.x * t1 + uv1.y * t2, + (1.0 - uv2.x - uv2.y) * t0 + uv2.x * t1 + uv2.y * t2 + ); + + // Set per-primitive gradient data + prim_out[tri_base + i].corner_t = corner_t_values; + prim_out[tri_base + i].front_color = payload.front_color; + prim_out[tri_base + i].back_color = payload.back_color; + prim_out[tri_base + i].is_bev = payload.is_bev; + } + } +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.task.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.task.glsl new file mode 100644 index 000000000..c4580c148 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_obstacle.task.glsl @@ -0,0 +1,1185 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_mesh_shader : require +#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Cap styles +const uint CAP_NONE = 0u; +const uint CAP_FLAT = 1u; +const uint CAP_ROUND = 2u; + +// Primitive type IDs (must match Python PRIM_* constants in ops.py) +const uint PRIM_ROAD_BOUNDARY = 0u; +const uint PRIM_LANE_LINE = 1u; // Legacy cyan lane line +const uint PRIM_CROSSWALK = 2u; +const uint PRIM_STATIC_OBSTACLE = 3u; // Legacy, avoid using +const uint PRIM_EGO_TRAJECTORY = 4u; +const uint PRIM_OBSTACLE = 5u; +const uint PRIM_EGO_OBSTACLE = 6u; +const uint PRIM_WAIT_LINE = 7u; +const uint PRIM_POLE = 8u; +const uint PRIM_ROAD_MARKING = 9u; +const uint PRIM_LANE_BOUNDARY = 10u; +const uint PRIM_TRAFFIC_LIGHT = 11u; +const uint PRIM_TRAFFIC_SIGN = 12u; +const uint PRIM_INTERSECTION = 13u; +const uint PRIM_ROAD_ISLAND = 14u; +const uint PRIM_BUFFER_ZONE = 15u; +// Lane line variants by color/style +const uint PRIM_LANE_LINE_WHITE_SOLID = 16u; +const uint PRIM_LANE_LINE_WHITE_DASHED = 17u; +const uint PRIM_LANE_LINE_YELLOW_SOLID = 18u; +const uint PRIM_LANE_LINE_YELLOW_DASHED = 19u; +// Dot primitives - each vertex is rendered as a circle +const uint PRIM_DOT_YELLOW = 20u; +const uint PRIM_DOT_WHITE = 21u; + +// Camera type IDs +const uint CAMERA_TYPE_REGULAR = 0u; +const uint CAMERA_TYPE_BEV = 1u; + +//============================================================================= +// Hardcoded Primitive Styles (matching wm-render colorscheme v3) +//============================================================================= + +// Colors (RGB normalized) - matching imaginaire4 v3 colorscheme +// Source: imaginaire4/imaginaire/auxiliary/world_scenario/color_scheme/config_color_hdmap.json +const vec3 COLOR_ROAD_BOUNDARY = vec3(253.0/255.0, 1.0/255.0, 232.0/255.0); // Magenta (253, 1, 232) +const vec3 COLOR_LANE_LINE = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (98, 183, 249) - "lanelines" (legacy) +const vec3 COLOR_CROSSWALK = vec3(139.0/255.0, 93.0/255.0, 255.0/255.0); // Purple (139, 93, 255) +const vec3 COLOR_STATIC_OBSTACLE = vec3(255.0/255.0, 100.0/255.0, 0.0/255.0); // Orange (legacy) +const vec3 COLOR_EGO_TRAJECTORY = vec3(0.0/255.0, 255.0/255.0, 0.0/255.0); // Green (0, 255, 0) +const vec3 COLOR_WAIT_LINE = vec3(108.0/255.0, 179.0/255.0, 59.0/255.0); // Yellow-green (108, 179, 59) +const vec3 COLOR_POLE = vec3(183.0/255.0, 69.0/255.0, 177.0/255.0); // Purple-magenta (183, 69, 177) +const vec3 COLOR_ROAD_MARKING = vec3(20.0/255.0, 254.0/255.0, 185.0/255.0); // Cyan-green (20, 254, 185) +const vec3 COLOR_LANE_BOUNDARY = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (same as lane line) +const vec3 COLOR_TRAFFIC_LIGHT = vec3(100.0/255.0, 100.0/255.0, 100.0/255.0); // Gray (100, 100, 100) +const vec3 COLOR_TRAFFIC_SIGN = vec3(8.0/255.0, 2.0/255.0, 255.0/255.0); // Blue (8, 2, 255) +const vec3 COLOR_INTERSECTION = vec3(80.0/255.0, 80.0/255.0, 120.0/255.0); // Dark blue-gray (approximated) +const vec3 COLOR_ROAD_ISLAND = vec3(60.0/255.0, 120.0/255.0, 60.0/255.0); // Dark green (approximated) +const vec3 COLOR_BUFFER_ZONE = vec3(120.0/255.0, 80.0/255.0, 80.0/255.0); // Dark red-brown (approximated) +// Lane line variants from config_color_geometry_laneline.json +const vec3 COLOR_LANE_LINE_WHITE = vec3(255.0/255.0, 255.0/255.0, 255.0/255.0); // White (255, 255, 255) +const vec3 COLOR_LANE_LINE_YELLOW = vec3(255.0/255.0, 255.0/255.0, 0.0/255.0); // Yellow (255, 255, 0) + +// Default polyline widths (pixels at reference resolution 1280x720) +const float DEFAULT_WIDTH_POLYLINE_REGULAR = 7.0; +const float DEFAULT_WIDTH_POLYLINE_BEV = 4.0; +const float DEFAULT_WIDTH_EGO_TRAJ_REGULAR = 12.0; +const float DEFAULT_WIDTH_EGO_TRAJ_BEV = 5.0; +const float DEFAULT_WIDTH_POLE_REGULAR = 5.0; // Poles are thinner (reference: 5 vs 12) +const float DEFAULT_WIDTH_POLE_BEV = 3.0; +const float DEFAULT_WIDTH_WIREFRAME = 2.0; + +// Configurable width uniforms (set from Python, or use defaults) + +// Compute depth-based scaling factor for line width +// z_ndc is in [-1, 1] where -1 is near, +1 is far +// Returns 1.0 at near, 0.0 at far (linear fade) +float get_depth_scale(vec4 clip) { + if (pc.u_depth_scaling < 0.5) return 1.0; // Disabled + float z_ndc = clip.z / clip.w; // Convert to NDC + float depth_scale = 1.0 - z_ndc; // Map [-1,1] to [1,0] + return clamp(depth_scale, 0.0, 1.0); +} + +// Color palette buffer (optional, configured from Python) +// Declared early so get_prim_color can use it; actual buffer layout defined later +layout(std430, binding = 10) readonly buffer ColorPaletteBufferEarly { + vec4 g_color_palette[]; +}; + +// Get default color for primitive type (hardcoded fallback) +vec3 get_default_prim_color(uint prim_type_id) { + if (prim_type_id == PRIM_ROAD_BOUNDARY) return COLOR_ROAD_BOUNDARY; + if (prim_type_id == PRIM_LANE_LINE) return COLOR_LANE_LINE; + if (prim_type_id == PRIM_CROSSWALK) return COLOR_CROSSWALK; + if (prim_type_id == PRIM_STATIC_OBSTACLE) return COLOR_STATIC_OBSTACLE; + if (prim_type_id == PRIM_EGO_TRAJECTORY) return COLOR_EGO_TRAJECTORY; + if (prim_type_id == PRIM_WAIT_LINE) return COLOR_WAIT_LINE; + if (prim_type_id == PRIM_POLE) return COLOR_POLE; + if (prim_type_id == PRIM_ROAD_MARKING) return COLOR_ROAD_MARKING; + if (prim_type_id == PRIM_LANE_BOUNDARY) return COLOR_LANE_BOUNDARY; + if (prim_type_id == PRIM_TRAFFIC_LIGHT) return COLOR_TRAFFIC_LIGHT; + if (prim_type_id == PRIM_TRAFFIC_SIGN) return COLOR_TRAFFIC_SIGN; + if (prim_type_id == PRIM_INTERSECTION) return COLOR_INTERSECTION; + if (prim_type_id == PRIM_ROAD_ISLAND) return COLOR_ROAD_ISLAND; + if (prim_type_id == PRIM_BUFFER_ZONE) return COLOR_BUFFER_ZONE; + // Lane line variants + if (prim_type_id == PRIM_LANE_LINE_WHITE_SOLID) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_WHITE_DASHED) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_SOLID) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_DASHED) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_YELLOW) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_WHITE) return COLOR_LANE_LINE_WHITE; + return vec3(1.0, 1.0, 1.0); // Default white for obstacles +} + +// Get color for primitive type (checks palette first, then falls back to defaults) +vec3 get_prim_color(uint prim_type_id) { + // If color palette is configured, check if this prim_type has a custom color + // Alpha < 0 means "use default", alpha >= 0 means "use this color" + if (pc.u_color_palette_size > 0 && prim_type_id < uint(pc.u_color_palette_size)) { + vec4 palette_color = g_color_palette[prim_type_id]; + if (palette_color.a >= 0.0) { + return palette_color.rgb; + } + } + // Fall back to hardcoded defaults + return get_default_prim_color(prim_type_id); +} + +// Check if primitive is a dot type (rendered as circles at each vertex) +bool is_dot_primitive(uint prim_type_id) { + return prim_type_id == PRIM_DOT_YELLOW || prim_type_id == PRIM_DOT_WHITE; +} + +// Get polyline width for primitive type and camera type (scaled by resolution) +float get_prim_width(uint prim_type_id, uint camera_type_id) { + bool is_bev = (camera_type_id == CAMERA_TYPE_BEV); + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + + float base_width; + if (prim_type_id == PRIM_EGO_TRAJECTORY) { + float default_w = is_bev ? DEFAULT_WIDTH_EGO_TRAJ_BEV : DEFAULT_WIDTH_EGO_TRAJ_REGULAR; + float custom_w = is_bev ? pc.u_width_ego_traj_bev : pc.u_width_ego_traj_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } else if (prim_type_id == PRIM_POLE) { + // Poles use thinner lines (reference: 5 pixels vs 12 for other polylines) + base_width = is_bev ? DEFAULT_WIDTH_POLE_BEV : DEFAULT_WIDTH_POLE_REGULAR; + } else { + float default_w = is_bev ? DEFAULT_WIDTH_POLYLINE_BEV : DEFAULT_WIDTH_POLYLINE_REGULAR; + float custom_w = is_bev ? pc.u_width_polyline_bev : pc.u_width_polyline_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } + return base_width * scale; +} + +// Get wireframe edge width (scaled by resolution) +float get_wireframe_width() { + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + float base_width = (pc.u_width_wireframe > 0.0) ? pc.u_width_wireframe : DEFAULT_WIDTH_WIREFRAME; + return base_width * scale; +} + +//============================================================================= +// Data Structures (must match C++ structs) +//============================================================================= + +// TimestampedPolylinePool (64 bytes) +struct TimestampedPolylinePool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint vertices_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4, _pad5, _pad6, _pad7; // Padding to 64 bytes +}; + +// TimestampedPolygonPool (64 bytes) +struct TimestampedPolygonPool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint num_triangles; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint tri_ps_offset; + uint vertices_offset; + uint triangles_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4; // Padding to 64 bytes (16 uints) +}; + +// CubePool (64 bytes) - used for obstacles, traffic lights, traffic signs, etc. +// Renamed from ObstaclePool but keeping struct name for backward compat +struct ObstaclePool { + uint num_cubes; // Was: num_obstacles + uint num_timestamps; + uint num_track_poses; + uint prim_type_id; // Semantic type for color lookup + uint timestamps_offset; // Global timestamps for this pool + uint cube_ts_ps_offset; // Per-cube track length prefix sum (was: obstacle_ts_ps_offset) + uint track_timestamps_offset; // Per-pose timestamps in float buffer (as 2x uint for int64) + uint translations_offset; // Per-pose translations (3 floats each) + uint quaternions_offset; // Per-pose quaternions (4 floats each) + uint scales_offset; // Per-cube scales (3 floats each) + uint colors_offset; // Per-cube colors (6 floats each) + uint render_flags; // CUBE_FLAG_* bits (e.g., CUBE_FLAG_WIREFRAME) + uint _pad2, _pad3, _pad4, _pad5; // 4 padding fields for 64 bytes total +}; + +// Cube render flags +const uint CUBE_FLAG_WIREFRAME = 1u; // Draw wireframe edges in addition to solid faces + +// TimestampedScene (128 bytes) +struct TimestampedScene { + uint num_polyline_pools; + uint polyline_pools_offset; + uint num_polygon_pools; + uint polygon_pools_offset; + uint num_cube_pools; // Was: has_obstacle_pool (0/1), now supports multiple + uint cube_pools_offset; // Was: obstacle_pool_offset + uint timestamps_buffer_offset; + uint int32_buffer_offset; + uint vertex_buffer_offset; + uint triangle_buffer_offset; + uint pose_buffer_offset; + uint float_buffer_offset; + uint _pad[20]; +}; + +// RenderQuery (16 bytes) +struct RenderQuery { + uint scene_id; + uint camera_id; + int64_t timestamp_us; + uint camera_type_id; // CAMERA_TYPE_REGULAR or CAMERA_TYPE_BEV + uint _pad1, _pad2, _pad3; // Padding to 32 bytes +}; + +// FThetaCamera (72 bytes) +struct FThetaCamera { + float cx, cy; + float img_w, img_h; + float poly0, poly1, poly2, poly3, poly4, poly5; + float max_ray_angle; + float max_distortion_val; + float max_distortion_dval; + float depth_max; + float ld_c, ld_d, ld_e, ld_f; +}; + +// CameraPose (64 bytes) +struct CameraPose { + mat4 world_to_camera; +}; + +// Vertex (16 bytes) +struct Vertex { + float x, y, z; + float _pad; +}; + +//============================================================================= +// Buffer Bindings +//============================================================================= + +// Global data buffers +layout(std430, binding = 0) readonly buffer TimestampsBuffer { + int64_t g_timestamps[]; +}; + +layout(std430, binding = 1) readonly buffer Int32Buffer { + int g_int32[]; +}; + +layout(std430, binding = 2) readonly buffer VertexBuffer { + Vertex g_vertices[]; +}; + +layout(std430, binding = 3) readonly buffer TriangleBuffer { + uvec3 g_triangles[]; +}; + +layout(std430, binding = 4) readonly buffer PoseBuffer { + CameraPose g_poses[]; +}; + +layout(std430, binding = 5) readonly buffer FloatBuffer { + float g_floats[]; +}; + +// Scene metadata +layout(std430, binding = 6) readonly buffer SceneBuffer { + TimestampedScene g_scenes[]; +}; + +layout(std430, binding = 7) readonly buffer PolylinePoolBuffer { + TimestampedPolylinePool g_polyline_pools[]; +}; + +layout(std430, binding = 8) readonly buffer PolygonPoolBuffer { + TimestampedPolygonPool g_polygon_pools[]; +}; + +layout(std430, binding = 9) readonly buffer ObstaclePoolBuffer { + ObstaclePool g_obstacle_pools[]; +}; + +// Camera buffers +layout(std430, binding = 11) readonly buffer CameraIntrinsicsBuffer { + FThetaCamera g_camera_intrinsics[]; +}; + +layout(std430, binding = 12) readonly buffer CameraPoseBuffer { + CameraPose g_camera_poses[]; // One per query (dynamic viewpoints) +}; + +// Query buffer +layout(std430, binding = 13) readonly buffer QueryBuffer { + RenderQuery g_queries[]; +}; + +// Uniforms +// Spatial culling: elements beyond depth_max * scale from the camera are +// discarded in the task shader. Scale > 1 gives headroom so nothing at +// the visible boundary pops in/out. Set to 0 to disable culling. + +//============================================================================= +// GPU Binary Search +// Returns index of last element <= target, or -1 if target < all elements +//============================================================================= + +int binary_search_timestamps(uint base_offset, uint count, int64_t target) { + if (count == 0u) return -1; + + int left = 0; + int right = int(count) - 1; + int result = -1; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t val = g_timestamps[base_offset + uint(mid)]; + + if (val <= target) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + + return result; +} + +//============================================================================= +// Quaternion Math for Track Interpolation +//============================================================================= + +// Quaternion dot product +float quat_dot(vec4 a, vec4 b) { + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +// Quaternion normalize +vec4 quat_normalize(vec4 q) { + float len = length(q); + return len > 1e-10 ? q / len : vec4(0.0, 0.0, 0.0, 1.0); +} + +// Quaternion spherical linear interpolation (slerp) +vec4 quat_slerp(vec4 q0, vec4 q1, float t) { + // Ensure shortest path + float d = quat_dot(q0, q1); + if (d < 0.0) { + q1 = -q1; + d = -d; + } + + // If quaternions are very close, use linear interpolation + if (d > 0.9995) { + return quat_normalize(mix(q0, q1, t)); + } + + // Spherical interpolation + float theta_0 = acos(clamp(d, -1.0, 1.0)); + float theta = theta_0 * t; + float sin_theta = sin(theta); + float sin_theta_0 = sin(theta_0); + + float s0 = cos(theta) - d * sin_theta / sin_theta_0; + float s1 = sin_theta / sin_theta_0; + + return quat_normalize(s0 * q0 + s1 * q1); +} + +// Convert quaternion (x, y, z, w) to 3x3 rotation matrix +// GLSL mat3 is column-major: mat3(col0, col1, col2) +mat3 quat_to_matrix(vec4 q) { + float x = q.x, y = q.y, z = q.z, w = q.w; + + float x2 = x + x, y2 = y + y, z2 = z + z; + float xx = x * x2, xy = x * y2, xz = x * z2; + float yy = y * y2, yz = y * z2, zz = z * z2; + float wx = w * x2, wy = w * y2, wz = w * z2; + + // Column 0: (R00, R10, R20), Column 1: (R01, R11, R21), Column 2: (R02, R12, R22) + return mat3( + 1.0 - (yy + zz), xy + wz, xz - wy, // Column 0 + xy - wz, 1.0 - (xx + zz), yz + wx, // Column 1 + xz + wy, yz - wx, 1.0 - (xx + yy) // Column 2 + ); +} + +// Build 4x4 transform from translation and quaternion (with scale) +mat4 build_transform(vec3 translation, vec4 quaternion, vec3 scale) { + mat3 rot = quat_to_matrix(quaternion); + + // Apply scale to each column of rotation matrix + mat4 result = mat4( + vec4(rot[0] * scale.x, 0.0), + vec4(rot[1] * scale.y, 0.0), + vec4(rot[2] * scale.z, 0.0), + vec4(translation, 1.0) + ); + + return result; +} + +// Binary search for track interpolation (returns index where t0 <= target < t1) +// Returns -1 if target is outside the track range +int binary_search_track(uint base_offset, uint count, int64_t target) { + if (count < 2u) return -1; // Need at least 2 points for interpolation + + int64_t first_ts = g_timestamps[base_offset]; + int64_t last_ts = g_timestamps[base_offset + count - 1u]; + + // Check bounds + if (target < first_ts || target > last_ts) return -1; + + int left = 0; + int right = int(count) - 2; // Max valid index for interpolation start + int result = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[base_offset + uint(mid)]; + int64_t t1 = g_timestamps[base_offset + uint(mid) + 1u]; + + if (t0 <= target && target <= t1) { + return mid; + } else if (target < t0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + + return -1; // Should not reach here for valid input +} + +//============================================================================= +// Spatial Culling Helpers +//============================================================================= + +// AABB-AABB overlap test +bool cull_aabb_overlap(vec3 a_min, vec3 a_max, vec3 b_min, vec3 b_max) { + return all(lessThanEqual(a_min, b_max)) && all(greaterThanEqual(a_max, b_min)); +} + +// Sphere-AABB overlap test +bool cull_sphere_aabb_overlap(vec3 center, float radius, vec3 b_min, vec3 b_max) { + vec3 nearest = clamp(center, b_min, b_max); + vec3 d = center - nearest; + return dot(d, d) <= radius * radius; +} + +// Extract camera world position from view pose +vec3 get_camera_world_pos(CameraPose pose) { + mat3 R = mat3(pose.world_to_camera); + return -transpose(R) * pose.world_to_camera[3].xyz; +} + +//============================================================================= +// F-theta Projection +//============================================================================= + +vec3 rotate_rodrigues(vec3 v, vec3 r) { + float theta = length(r); + if (theta < 1e-8) return v; + vec3 k = r / theta; + float c = cos(theta); + float s = sin(theta); + return v * c + cross(k, v) * s + k * dot(k, v) * (1.0 - c); +} + +// F-theta projection: world point -> NDC +// Supports >180° FOV fisheye cameras where points can have negative z (behind camera plane) +vec4 ftheta_project(vec3 world_pos, CameraPose pose, FThetaCamera cam) { + vec3 cam_pt = (pose.world_to_camera * vec4(world_pos, 1.0)).xyz; + float depth = cam_pt.z; + + float ray_norm = length(cam_pt); + + // Handle points at camera origin + if (ray_norm < 1e-6) { + return vec4(0.0, 0.0, 0.0, 1.0); + } + + float half_pi = 1.5707963; // π/2 + + // For cameras with FOV <= 180° (max_ray_angle <= π/2), points behind camera should be clipped + // Use pseudo-pinhole projection to push them far away in the correct direction + if (cam.max_ray_angle <= half_pi && depth < 0.001) { + float pseudo_focal = cam.poly1; + float x_clip = cam_pt.x * pseudo_focal / (cam.img_w * 0.5); + float y_clip = -cam_pt.y * pseudo_focal / (cam.img_h * 0.5); + return vec4(x_clip * 10.0, y_clip * 10.0, 1.0, 1.0); // Scale by 10 to push far outside + } + + float xy_norm = length(cam_pt.xy); + float cos_alpha = clamp(cam_pt.z / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); // alpha in [0, π] + + // Apply polynomial projection (with linear extrapolation beyond max_ray_angle) + float a2 = alpha * alpha; + float a3 = a2 * alpha; + float a4 = a2 * a2; + float a5 = a4 * alpha; + + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * a3 + cam.poly4 * a4 + cam.poly5 * a5; + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt.xy; + + vec2 pixel_dist; + pixel_dist.x = cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y; + pixel_dist.y = cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y; + + vec2 pixel = pixel_dist + vec2(cam.cx, cam.cy); + + float x_ndc = 2.0 * pixel.x / cam.img_w - 1.0; + float y_ndc = 1.0 - 2.0 * pixel.y / cam.img_h; + + // For z-buffer depth mapping: + // - Narrow FOV (<=180°): use signed depth (cam_pt.z) + // - Wide FOV (>180°): use ray_norm for front-camera vertices (unchanged), + // but push behind-camera vertices to depth_max so they never occlude + // forward geometry. ray_norm alone can't distinguish front from behind. + float z_value; + if (cam.max_ray_angle > half_pi) { + z_value = (depth >= 0.0) ? ray_norm : cam.depth_max; + } else { + z_value = depth; + } + float z_ndc = clamp(z_value / cam.depth_max, 0.0, 1.0); + + return vec4(x_ndc, y_ndc, z_ndc, 1.0); +} + +// Inline version that takes mat4 directly +float estimate_edge_distortion_pixels_mat4(vec3 v0, vec3 v1, mat4 world_to_cam, FThetaCamera cam) { + // Transform to camera space + vec3 cam_pt0 = (world_to_cam * vec4(v0, 1.0)).xyz; + vec3 cam_pt1 = (world_to_cam * vec4(v1, 1.0)).xyz; + vec3 mid_world = (v0 + v1) * 0.5; + vec3 cam_pt_mid = (world_to_cam * vec4(mid_world, 1.0)).xyz; + + // Just clamp depths to avoid division issues + + // For segments in front of camera, compute f-theta projection error directly + // Use depth-clamped projection to handle near-plane cases + float depth0 = max(cam_pt0.z, 0.001); + float depth1 = max(cam_pt1.z, 0.001); + float depth_mid = max(cam_pt_mid.z, 0.001); + + // Compute f-theta projection for each point + // We inline the projection to avoid struct-passing issues + vec2 pixel0, pixel1, pixel_mid; + { + float xy_norm = length(cam_pt0.xy); + float ray_norm = length(vec3(cam_pt0.xy, depth0)) + 1e-10; + float cos_alpha = clamp(depth0 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt0.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel0 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt1.xy); + float ray_norm = length(vec3(cam_pt1.xy, depth1)) + 1e-10; + float cos_alpha = clamp(depth1 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt1.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel1 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt_mid.xy); + float ray_norm = length(vec3(cam_pt_mid.xy, depth_mid)) + 1e-10; + float cos_alpha = clamp(depth_mid / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt_mid.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel_mid = pixel_dist + vec2(cam.cx, cam.cy); + } + + // Compute error: distance from projected midpoint to linear interpolation + vec2 linear_pixel_mid = (pixel0 + pixel1) * 0.5; + float error_pixels = length(pixel_mid - linear_pixel_mid); + + // Clamp to reasonable range to handle edge cases + return clamp(error_pixels, 0.0, 10000.0); +} + +uint compute_subdivision_level(vec3 v0, vec3 v1, CameraPose pose, FThetaCamera cam, float threshold_pixels) { + float error = estimate_edge_distortion_pixels_mat4(v0, v1, pose.world_to_camera, cam); + + if (error < threshold_pixels) return 0u; + if (error < threshold_pixels * 2.0) return 1u; + if (error < threshold_pixels * 4.0) return 2u; + return 3u; +} + +//============================================================================= +// Barycentric Subdivision Utilities (shared with polygon/cube) +//============================================================================= + +uint bary_vertex_count(uint level) { + // Vertices = (n+1)(n+2)/2 where n = 2^level + if (level == 0u) return 3u; + if (level == 1u) return 6u; + if (level == 2u) return 15u; + return 45u; // level 3 +} + +uint bary_triangle_count(uint level) { + // Triangles = 4^level + if (level == 0u) return 1u; + if (level == 1u) return 4u; + if (level == 2u) return 16u; + return 64u; // level 3 +} + +vec2 bary_vertex_uv(uint vertex_idx, uint level) { + if (level == 0u) { + if (vertex_idx == 0u) return vec2(0.0, 0.0); + if (vertex_idx == 1u) return vec2(1.0, 0.0); + return vec2(0.0, 1.0); + } else if (level == 1u) { + vec2 uvs[6]; + uvs[0] = vec2(0.0, 0.0); + uvs[1] = vec2(1.0, 0.0); + uvs[2] = vec2(0.0, 1.0); + uvs[3] = vec2(0.5, 0.0); + uvs[4] = vec2(0.5, 0.5); + uvs[5] = vec2(0.0, 0.5); + return uvs[vertex_idx]; + } else if (level == 2u) { + uint row, col; + if (vertex_idx < 5u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 9u) { row = 1u; col = vertex_idx - 5u; } + else if (vertex_idx < 12u) { row = 2u; col = vertex_idx - 9u; } + else if (vertex_idx < 14u) { row = 3u; col = vertex_idx - 12u; } + else { row = 4u; col = 0u; } + return vec2(float(col) / 4.0, float(row) / 4.0); + } else { + // Level 3: 9 rows (0-8), row r has (9-r) vertices + uint row, col; + if (vertex_idx < 9u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 17u) { row = 1u; col = vertex_idx - 9u; } + else if (vertex_idx < 24u) { row = 2u; col = vertex_idx - 17u; } + else if (vertex_idx < 30u) { row = 3u; col = vertex_idx - 24u; } + else if (vertex_idx < 35u) { row = 4u; col = vertex_idx - 30u; } + else if (vertex_idx < 39u) { row = 5u; col = vertex_idx - 35u; } + else if (vertex_idx < 42u) { row = 6u; col = vertex_idx - 39u; } + else if (vertex_idx < 44u) { row = 7u; col = vertex_idx - 42u; } + else { row = 8u; col = 0u; } + return vec2(float(col) / 8.0, float(row) / 8.0); + } +} + +vec3 bary_interpolate(vec3 v0, vec3 v1, vec3 v2, vec2 uv) { + float w = 1.0 - uv.x - uv.y; + return v0 * w + v1 * uv.x + v2 * uv.y; +} + +uvec3 bary_triangle_indices(uint tri_idx, uint level) { + if (level == 0u) { + return uvec3(0u, 1u, 2u); + } else if (level == 1u) { + uvec3 tris[4]; + tris[0] = uvec3(0u, 3u, 5u); + tris[1] = uvec3(3u, 1u, 4u); + tris[2] = uvec3(5u, 4u, 2u); + tris[3] = uvec3(3u, 4u, 5u); + return tris[tri_idx]; + } else if (level == 2u) { + uint row_start[5] = uint[5](0u, 5u, 9u, 12u, 14u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + if (t < 7u) { + row = 0u; + if (t < 4u) { col = t; is_down = false; } + else { col = t - 4u; is_down = true; } + } else if (t < 12u) { + row = 1u; + uint lt = t - 7u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 15u) { + row = 2u; + uint lt = t - 12u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 3u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } else { + // Level 3: row_start for 9 rows + uint row_start[9] = uint[9](0u, 9u, 17u, 24u, 30u, 35u, 39u, 42u, 44u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + // Row 0: 8 up + 7 down = 15, Row 1: 7 up + 6 down = 13, etc. + if (t < 15u) { + row = 0u; + if (t < 8u) { col = t; is_down = false; } + else { col = t - 8u; is_down = true; } + } else if (t < 28u) { + row = 1u; uint lt = t - 15u; + if (lt < 7u) { col = lt; is_down = false; } + else { col = lt - 7u; is_down = true; } + } else if (t < 39u) { + row = 2u; uint lt = t - 28u; + if (lt < 6u) { col = lt; is_down = false; } + else { col = lt - 6u; is_down = true; } + } else if (t < 48u) { + row = 3u; uint lt = t - 39u; + if (lt < 5u) { col = lt; is_down = false; } + else { col = lt - 5u; is_down = true; } + } else if (t < 55u) { + row = 4u; uint lt = t - 48u; + if (lt < 4u) { col = lt; is_down = false; } + else { col = lt - 4u; is_down = true; } + } else if (t < 60u) { + row = 5u; uint lt = t - 55u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 63u) { + row = 6u; uint lt = t - 60u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 7u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } +} + + +layout(local_size_x = 1) in; + +// Uniforms for obstacle/cube dispatch + +// Unit cube vertices for edge distortion calculation (same as non-timestamped) +const vec3 CUBE_VERTS[8] = vec3[8]( + vec3(-0.5, -0.5, -0.5), vec3(+0.5, -0.5, -0.5), + vec3(+0.5, +0.5, -0.5), vec3(-0.5, +0.5, -0.5), + vec3(-0.5, -0.5, +0.5), vec3(+0.5, -0.5, +0.5), + vec3(+0.5, +0.5, +0.5), vec3(-0.5, +0.5, +0.5) +); + +// 12 edges of cube (pairs of vertex indices) +const uvec2 CUBE_EDGES[12] = uvec2[12]( + uvec2(0,1), uvec2(1,2), uvec2(2,3), uvec2(3,0), // back face + uvec2(4,5), uvec2(5,6), uvec2(6,7), uvec2(7,4), // front face + uvec2(0,4), uvec2(1,5), uvec2(2,6), uvec2(3,7) // connecting edges +); + +struct ObstacleTaskPayload { + uint query_id; + uint obstacle_id; + mat4 object_to_world; + vec3 scale; + vec3 front_color; + vec3 back_color; + uint subdivision_level; + uint render_flags; // CUBE_FLAG_* bits from pool + float is_bev; + uint face_mask; // Bitmask of front-facing faces (backface culling) +}; +taskPayloadSharedEXT ObstacleTaskPayload payload; + +// Face normals in local space (outward-facing, matches FACE_VERTS winding) +const vec3 FACE_NORMALS[6] = vec3[6]( + vec3( 0, 0, -1), // face 0: -Z (back) + vec3( 0, 0, +1), // face 1: +Z (front) + vec3(-1, 0, 0), // face 2: -X + vec3(+1, 0, 0), // face 3: +X + vec3( 0, -1, 0), // face 4: -Y + vec3( 0, +1, 0) // face 5: +Y +); + +// Helper to read translation from float buffer +vec3 read_translation(uint base_offset, uint pose_idx) { + uint off = base_offset + pose_idx * 3u; + return vec3(g_floats[off], g_floats[off + 1u], g_floats[off + 2u]); +} + +// Helper to read quaternion from float buffer (x, y, z, w) +vec4 read_quaternion(uint base_offset, uint pose_idx) { + uint off = base_offset + pose_idx * 4u; + return vec4(g_floats[off], g_floats[off + 1u], g_floats[off + 2u], g_floats[off + 3u]); +} + +// Helper to read int64 timestamp from float buffer (stored as 2 uints) +int64_t read_track_timestamp(uint base_offset, uint pose_idx) { + // Track timestamps stored in timestamps buffer, not float buffer + return g_timestamps[base_offset + pose_idx]; +} + +void main() { + uint _task_count = 0u; + uint work_id = gl_WorkGroupID.x; + + // Decode work_id = query_id * max_obstacles + obstacle_id + uint query_id_local = work_id / pc.u_max_obstacles; + uint obstacle_id_local = work_id % pc.u_max_obstacles; + + if (query_id_local >= pc.u_num_queries) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + RenderQuery query = g_queries[query_id_local]; + TimestampedScene scene = g_scenes[query.scene_id]; + + if (scene.num_cube_pools == 0u || pc.u_cube_pool_index >= scene.num_cube_pools) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + // Access the cube pool at the specified index + ObstaclePool pool = g_obstacle_pools[scene.cube_pools_offset + pc.u_cube_pool_index]; + + // Mirror the polygon/polyline task-shader guard: keep subsequent SSBO + // reads in-bounds when the workgroup is over-dispatched (this pool has + // fewer cubes than the per-dispatch max), then force the final emit + // count to zero. Without this, invalid workgroups can read the next + // pool's prefix sums / translations / scales and produce ghost cubes + // scattered throughout the scene. + bool force_zero_tasks = false; + if (obstacle_id_local >= pool.num_cubes) { + force_zero_tasks = true; + obstacle_id_local = 0u; + } + + // Ego obstacle is only visible in BEV cameras + if (pool.prim_type_id == PRIM_EGO_OBSTACLE && query.camera_type_id != CAMERA_TYPE_BEV) { + force_zero_tasks = true; + } + + // Get this obstacle's track range + uint track_start = 0u; + if (obstacle_id_local > 0u) { + track_start = uint(g_int32[scene.int32_buffer_offset + pool.cube_ts_ps_offset + obstacle_id_local - 1u]); + } + uint track_end = uint(g_int32[scene.int32_buffer_offset + pool.cube_ts_ps_offset + obstacle_id_local]); + uint track_len = track_end - track_start; + + if (track_len < 1u) { + force_zero_tasks = true; + track_len = 1u; + } + + // Find bracketing timestamps for interpolation + uint track_ts_base = scene.timestamps_buffer_offset + pool.track_timestamps_offset + track_start; + int64_t target_ts = query.timestamp_us; + + // Check bounds with extrapolation support + int64_t first_ts = g_timestamps[track_ts_base]; + int64_t last_ts = g_timestamps[track_ts_base + track_len - 1u]; + + // Determine if we need extrapolation + bool extrapolate_before = (target_ts < first_ts); + bool extrapolate_after = (target_ts > last_ts); + + if (extrapolate_before) { + int64_t dt = first_ts - target_ts; + if (dt > int64_t(pc.u_max_extrapolation_us) || track_len < 2u) { + force_zero_tasks = true; + } + } else if (extrapolate_after) { + int64_t dt = target_ts - last_ts; + if (dt > int64_t(pc.u_max_extrapolation_us) || track_len < 2u) { + force_zero_tasks = true; + } + } + + // Binary search for interpolation interval [t0, t1] where t0 <= target <= t1 + // For extrapolation, we use the first/last interval + int idx0 = 0; + int idx1 = 0; + float alpha = 0.0; + + if (track_len == 1u) { + // Single pose - no interpolation needed + idx0 = 0; + idx1 = 0; + alpha = 0.0; + } else if (extrapolate_before) { + // Extrapolate backwards: use first two poses + idx0 = 0; + idx1 = 1; + int64_t t0 = g_timestamps[track_ts_base]; + int64_t t1 = g_timestamps[track_ts_base + 1u]; + // alpha will be negative for backwards extrapolation + if (t1 > t0) { + alpha = float(target_ts - t0) / float(t1 - t0); + } else { + alpha = 0.0; + } + } else if (extrapolate_after) { + // Extrapolate forwards: use last two poses + idx0 = int(track_len) - 2; + idx1 = int(track_len) - 1; + int64_t t0 = g_timestamps[track_ts_base + uint(idx0)]; + int64_t t1 = g_timestamps[track_ts_base + uint(idx1)]; + // alpha will be > 1.0 for forward extrapolation + if (t1 > t0) { + alpha = float(target_ts - t0) / float(t1 - t0); + } else { + alpha = 1.0; + } + } else { + // Normal interpolation: binary search for the interval + int left = 0; + int right = int(track_len) - 2; + idx0 = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[track_ts_base + uint(mid)]; + int64_t t1 = g_timestamps[track_ts_base + uint(mid) + 1u]; + + if (t0 <= target_ts && target_ts <= t1) { + idx0 = mid; + break; + } else if (target_ts < t0) { + right = mid - 1; + } else { + left = mid + 1; + idx0 = mid + 1; // Update in case we exit + } + } + + idx1 = min(idx0 + 1, int(track_len) - 1); + + // Compute interpolation factor + int64_t t0 = g_timestamps[track_ts_base + uint(idx0)]; + int64_t t1 = g_timestamps[track_ts_base + uint(idx1)]; + + if (t1 > t0) { + alpha = float(target_ts - t0) / float(t1 - t0); + } else { + alpha = 0.0; + } + } + + // Read translations and quaternions for interpolation + uint trans_base = scene.float_buffer_offset + pool.translations_offset + track_start * 3u; + uint quat_base = scene.float_buffer_offset + pool.quaternions_offset + track_start * 4u; + + vec3 trans0 = vec3( + g_floats[trans_base + uint(idx0) * 3u], + g_floats[trans_base + uint(idx0) * 3u + 1u], + g_floats[trans_base + uint(idx0) * 3u + 2u] + ); + vec3 trans1 = vec3( + g_floats[trans_base + uint(idx1) * 3u], + g_floats[trans_base + uint(idx1) * 3u + 1u], + g_floats[trans_base + uint(idx1) * 3u + 2u] + ); + + vec4 quat0 = vec4( + g_floats[quat_base + uint(idx0) * 4u], + g_floats[quat_base + uint(idx0) * 4u + 1u], + g_floats[quat_base + uint(idx0) * 4u + 2u], + g_floats[quat_base + uint(idx0) * 4u + 3u] + ); + vec4 quat1 = vec4( + g_floats[quat_base + uint(idx1) * 4u], + g_floats[quat_base + uint(idx1) * 4u + 1u], + g_floats[quat_base + uint(idx1) * 4u + 2u], + g_floats[quat_base + uint(idx1) * 4u + 3u] + ); + + // Interpolate translation (lerp) and rotation (slerp) + // For position: extrapolate linearly (alpha can be negative or > 1) + // For orientation: clamp to first/last keyframe (match wm-render behavior) + vec3 trans_interp = mix(trans0, trans1, alpha); + float alpha_clamped = clamp(alpha, 0.0, 1.0); + vec4 quat_interp = quat_slerp(quat0, quat1, alpha_clamped); + + // Get scale + uint scale_offset = scene.float_buffer_offset + pool.scales_offset + obstacle_id_local * 3u; + vec3 scale_local = vec3( + g_floats[scale_offset], + g_floats[scale_offset + 1u], + g_floats[scale_offset + 2u] + ); + + // Spatial culling: test bounding sphere against camera-centred view volume + if (pc.u_cull_radius_scale > 0.0) { + float cull_r = g_camera_intrinsics[query.camera_id].depth_max * pc.u_cull_radius_scale; + CameraPose cull_pose = g_camera_poses[query_id_local]; + vec3 cam_pos = get_camera_world_pos(cull_pose); + vec3 view_min = cam_pos - vec3(cull_r); + vec3 view_max = cam_pos + vec3(cull_r); + float radius = length(scale_local); + if (!cull_sphere_aabb_overlap(trans_interp, radius, view_min, view_max)) { + force_zero_tasks = true; + } + } + + // Build object_to_world matrix (rotation + translation, scale applied in mesh shader) + mat4 obj_to_world = build_transform(trans_interp, quat_interp, vec3(1.0)); + + // Get colors from buffer (first 3 floats = front, next 3 = back) + uint color_offset = scene.float_buffer_offset + pool.colors_offset + obstacle_id_local * 6u; + vec3 front = vec3( + g_floats[color_offset], + g_floats[color_offset + 1u], + g_floats[color_offset + 2u] + ); + vec3 back = vec3( + g_floats[color_offset + 3u], + g_floats[color_offset + 4u], + g_floats[color_offset + 5u] + ); + + // Compute max subdivision level from all 12 edges + FThetaCamera cam = g_camera_intrinsics[query.camera_id]; + CameraPose view_pose = g_camera_poses[query_id_local]; + + // Backface culling: compute which faces are visible from camera + mat3 R_view = mat3(view_pose.world_to_camera); + vec3 cam_world = -transpose(R_view) * view_pose.world_to_camera[3].xyz; + mat3 R_obj = mat3(obj_to_world); + + uint fmask = 0u; + for (uint f = 0u; f < 6u; f++) { + vec3 n_world = R_obj * FACE_NORMALS[f]; + vec3 center_local = FACE_NORMALS[f] * 0.5 * scale_local; + vec3 center_world = (obj_to_world * vec4(center_local, 1.0)).xyz; + if (dot(n_world, cam_world - center_world) > 0.0) { + fmask |= (1u << f); + } + } + + if (fmask == 0u) { + force_zero_tasks = true; + } + + uint max_subdiv = 0u; + if (pc.u_tessellation_threshold > 0.0) { + for (uint e = 0u; e < 12u; e++) { + vec3 v0_local = CUBE_VERTS[CUBE_EDGES[e].x] * scale_local; + vec3 v1_local = CUBE_VERTS[CUBE_EDGES[e].y] * scale_local; + // Transform to world space using interpolated object_to_world matrix + vec3 v0_world = (obj_to_world * vec4(v0_local, 1.0)).xyz; + vec3 v1_world = (obj_to_world * vec4(v1_local, 1.0)).xyz; + + uint subdiv = compute_subdivision_level(v0_world, v1_world, view_pose, cam, pc.u_tessellation_threshold); + max_subdiv = max(max_subdiv, subdiv); + } + max_subdiv = min(max_subdiv, pc.u_max_tessellation_cube); + } + + // Dispatch 6 faces + 6 for wireframe edges if enabled + uint wireframe = (pool.render_flags & CUBE_FLAG_WIREFRAME) != 0u ? 6u : 0u; + _task_count = force_zero_tasks ? 0u : (6u + wireframe); + + payload.query_id = query_id_local; + payload.obstacle_id = obstacle_id_local; + payload.object_to_world = obj_to_world; + payload.scale = scale_local; + payload.front_color = front; + payload.back_color = back; + payload.subdivision_level = max_subdiv; + payload.render_flags = pool.render_flags; + payload.is_bev = (query.camera_type_id == CAMERA_TYPE_BEV) ? 1.0 : 0.0; + payload.face_mask = fmask; + EmitMeshTasksEXT(_task_count, 1, 1); +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.frag.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.frag.glsl new file mode 100644 index 000000000..11ecfa8d4 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.frag.glsl @@ -0,0 +1,62 @@ + +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_fragment_shader_barycentric : require +#extension GL_EXT_mesh_shader : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Per-primitive color block from mesh shader +layout(location = 0) perprimitiveEXT in PrimColorBlock { + vec3 color; + float is_bev; +} prim_in; + +layout(location = 0) out vec4 out_color; + +layout(early_fragment_tests) in; + + +IF_ZMODIFY(layout(location = 0) uniform float in_dummy;) + +void main() { + vec3 color = prim_in.color; + + // Apply distance-based fog (darken with distance) - disabled for BEV cameras + // gl_FragCoord.z is in [0, 1] where 0=near, 1=far + if (pc.u_fog_enabled > 0.5 && prim_in.is_bev < 0.5) { + float fog_factor = 1.0 - gl_FragCoord.z; // 1.0 at near, 0.0 at far + fog_factor = clamp(fog_factor, 0.0, 1.0); + color *= fog_factor; + } + + out_color = vec4(clamp(color, 0.0, 1.0), 1.0); + IF_ZMODIFY(gl_FragDepth = gl_FragCoord.z + in_dummy;) +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.mesh.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.mesh.glsl new file mode 100644 index 000000000..2a57a8954 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.mesh.glsl @@ -0,0 +1,1127 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_mesh_shader : require +#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Cap styles +const uint CAP_NONE = 0u; +const uint CAP_FLAT = 1u; +const uint CAP_ROUND = 2u; + +// Primitive type IDs (must match Python PRIM_* constants in ops.py) +const uint PRIM_ROAD_BOUNDARY = 0u; +const uint PRIM_LANE_LINE = 1u; // Legacy cyan lane line +const uint PRIM_CROSSWALK = 2u; +const uint PRIM_STATIC_OBSTACLE = 3u; // Legacy, avoid using +const uint PRIM_EGO_TRAJECTORY = 4u; +const uint PRIM_OBSTACLE = 5u; +const uint PRIM_EGO_OBSTACLE = 6u; +const uint PRIM_WAIT_LINE = 7u; +const uint PRIM_POLE = 8u; +const uint PRIM_ROAD_MARKING = 9u; +const uint PRIM_LANE_BOUNDARY = 10u; +const uint PRIM_TRAFFIC_LIGHT = 11u; +const uint PRIM_TRAFFIC_SIGN = 12u; +const uint PRIM_INTERSECTION = 13u; +const uint PRIM_ROAD_ISLAND = 14u; +const uint PRIM_BUFFER_ZONE = 15u; +// Lane line variants by color/style +const uint PRIM_LANE_LINE_WHITE_SOLID = 16u; +const uint PRIM_LANE_LINE_WHITE_DASHED = 17u; +const uint PRIM_LANE_LINE_YELLOW_SOLID = 18u; +const uint PRIM_LANE_LINE_YELLOW_DASHED = 19u; +// Dot primitives - each vertex is rendered as a circle +const uint PRIM_DOT_YELLOW = 20u; +const uint PRIM_DOT_WHITE = 21u; + +// Camera type IDs +const uint CAMERA_TYPE_REGULAR = 0u; +const uint CAMERA_TYPE_BEV = 1u; + +//============================================================================= +// Hardcoded Primitive Styles (matching wm-render colorscheme v3) +//============================================================================= + +// Colors (RGB normalized) - matching imaginaire4 v3 colorscheme +// Source: imaginaire4/imaginaire/auxiliary/world_scenario/color_scheme/config_color_hdmap.json +const vec3 COLOR_ROAD_BOUNDARY = vec3(253.0/255.0, 1.0/255.0, 232.0/255.0); // Magenta (253, 1, 232) +const vec3 COLOR_LANE_LINE = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (98, 183, 249) - "lanelines" (legacy) +const vec3 COLOR_CROSSWALK = vec3(139.0/255.0, 93.0/255.0, 255.0/255.0); // Purple (139, 93, 255) +const vec3 COLOR_STATIC_OBSTACLE = vec3(255.0/255.0, 100.0/255.0, 0.0/255.0); // Orange (legacy) +const vec3 COLOR_EGO_TRAJECTORY = vec3(0.0/255.0, 255.0/255.0, 0.0/255.0); // Green (0, 255, 0) +const vec3 COLOR_WAIT_LINE = vec3(108.0/255.0, 179.0/255.0, 59.0/255.0); // Yellow-green (108, 179, 59) +const vec3 COLOR_POLE = vec3(183.0/255.0, 69.0/255.0, 177.0/255.0); // Purple-magenta (183, 69, 177) +const vec3 COLOR_ROAD_MARKING = vec3(20.0/255.0, 254.0/255.0, 185.0/255.0); // Cyan-green (20, 254, 185) +const vec3 COLOR_LANE_BOUNDARY = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (same as lane line) +const vec3 COLOR_TRAFFIC_LIGHT = vec3(100.0/255.0, 100.0/255.0, 100.0/255.0); // Gray (100, 100, 100) +const vec3 COLOR_TRAFFIC_SIGN = vec3(8.0/255.0, 2.0/255.0, 255.0/255.0); // Blue (8, 2, 255) +const vec3 COLOR_INTERSECTION = vec3(80.0/255.0, 80.0/255.0, 120.0/255.0); // Dark blue-gray (approximated) +const vec3 COLOR_ROAD_ISLAND = vec3(60.0/255.0, 120.0/255.0, 60.0/255.0); // Dark green (approximated) +const vec3 COLOR_BUFFER_ZONE = vec3(120.0/255.0, 80.0/255.0, 80.0/255.0); // Dark red-brown (approximated) +// Lane line variants from config_color_geometry_laneline.json +const vec3 COLOR_LANE_LINE_WHITE = vec3(255.0/255.0, 255.0/255.0, 255.0/255.0); // White (255, 255, 255) +const vec3 COLOR_LANE_LINE_YELLOW = vec3(255.0/255.0, 255.0/255.0, 0.0/255.0); // Yellow (255, 255, 0) + +// Default polyline widths (pixels at reference resolution 1280x720) +const float DEFAULT_WIDTH_POLYLINE_REGULAR = 7.0; +const float DEFAULT_WIDTH_POLYLINE_BEV = 4.0; +const float DEFAULT_WIDTH_EGO_TRAJ_REGULAR = 12.0; +const float DEFAULT_WIDTH_EGO_TRAJ_BEV = 5.0; +const float DEFAULT_WIDTH_POLE_REGULAR = 5.0; // Poles are thinner (reference: 5 vs 12) +const float DEFAULT_WIDTH_POLE_BEV = 3.0; +const float DEFAULT_WIDTH_WIREFRAME = 2.0; + +// Configurable width uniforms (set from Python, or use defaults) + +// Compute depth-based scaling factor for line width +// z_ndc is in [-1, 1] where -1 is near, +1 is far +// Returns 1.0 at near, 0.0 at far (linear fade) +float get_depth_scale(vec4 clip) { + if (pc.u_depth_scaling < 0.5) return 1.0; // Disabled + float z_ndc = clip.z / clip.w; // Convert to NDC + float depth_scale = 1.0 - z_ndc; // Map [-1,1] to [1,0] + return clamp(depth_scale, 0.0, 1.0); +} + +// Color palette buffer (optional, configured from Python) +// Declared early so get_prim_color can use it; actual buffer layout defined later +layout(std430, binding = 10) readonly buffer ColorPaletteBufferEarly { + vec4 g_color_palette[]; +}; + +// Get default color for primitive type (hardcoded fallback) +vec3 get_default_prim_color(uint prim_type_id) { + if (prim_type_id == PRIM_ROAD_BOUNDARY) return COLOR_ROAD_BOUNDARY; + if (prim_type_id == PRIM_LANE_LINE) return COLOR_LANE_LINE; + if (prim_type_id == PRIM_CROSSWALK) return COLOR_CROSSWALK; + if (prim_type_id == PRIM_STATIC_OBSTACLE) return COLOR_STATIC_OBSTACLE; + if (prim_type_id == PRIM_EGO_TRAJECTORY) return COLOR_EGO_TRAJECTORY; + if (prim_type_id == PRIM_WAIT_LINE) return COLOR_WAIT_LINE; + if (prim_type_id == PRIM_POLE) return COLOR_POLE; + if (prim_type_id == PRIM_ROAD_MARKING) return COLOR_ROAD_MARKING; + if (prim_type_id == PRIM_LANE_BOUNDARY) return COLOR_LANE_BOUNDARY; + if (prim_type_id == PRIM_TRAFFIC_LIGHT) return COLOR_TRAFFIC_LIGHT; + if (prim_type_id == PRIM_TRAFFIC_SIGN) return COLOR_TRAFFIC_SIGN; + if (prim_type_id == PRIM_INTERSECTION) return COLOR_INTERSECTION; + if (prim_type_id == PRIM_ROAD_ISLAND) return COLOR_ROAD_ISLAND; + if (prim_type_id == PRIM_BUFFER_ZONE) return COLOR_BUFFER_ZONE; + // Lane line variants + if (prim_type_id == PRIM_LANE_LINE_WHITE_SOLID) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_WHITE_DASHED) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_SOLID) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_DASHED) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_YELLOW) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_WHITE) return COLOR_LANE_LINE_WHITE; + return vec3(1.0, 1.0, 1.0); // Default white for obstacles +} + +// Get color for primitive type (checks palette first, then falls back to defaults) +vec3 get_prim_color(uint prim_type_id) { + // If color palette is configured, check if this prim_type has a custom color + // Alpha < 0 means "use default", alpha >= 0 means "use this color" + if (pc.u_color_palette_size > 0 && prim_type_id < uint(pc.u_color_palette_size)) { + vec4 palette_color = g_color_palette[prim_type_id]; + if (palette_color.a >= 0.0) { + return palette_color.rgb; + } + } + // Fall back to hardcoded defaults + return get_default_prim_color(prim_type_id); +} + +// Check if primitive is a dot type (rendered as circles at each vertex) +bool is_dot_primitive(uint prim_type_id) { + return prim_type_id == PRIM_DOT_YELLOW || prim_type_id == PRIM_DOT_WHITE; +} + +// Get polyline width for primitive type and camera type (scaled by resolution) +float get_prim_width(uint prim_type_id, uint camera_type_id) { + bool is_bev = (camera_type_id == CAMERA_TYPE_BEV); + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + + float base_width; + if (prim_type_id == PRIM_EGO_TRAJECTORY) { + float default_w = is_bev ? DEFAULT_WIDTH_EGO_TRAJ_BEV : DEFAULT_WIDTH_EGO_TRAJ_REGULAR; + float custom_w = is_bev ? pc.u_width_ego_traj_bev : pc.u_width_ego_traj_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } else if (prim_type_id == PRIM_POLE) { + // Poles use thinner lines (reference: 5 pixels vs 12 for other polylines) + base_width = is_bev ? DEFAULT_WIDTH_POLE_BEV : DEFAULT_WIDTH_POLE_REGULAR; + } else { + float default_w = is_bev ? DEFAULT_WIDTH_POLYLINE_BEV : DEFAULT_WIDTH_POLYLINE_REGULAR; + float custom_w = is_bev ? pc.u_width_polyline_bev : pc.u_width_polyline_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } + return base_width * scale; +} + +// Get wireframe edge width (scaled by resolution) +float get_wireframe_width() { + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + float base_width = (pc.u_width_wireframe > 0.0) ? pc.u_width_wireframe : DEFAULT_WIDTH_WIREFRAME; + return base_width * scale; +} + +//============================================================================= +// Data Structures (must match C++ structs) +//============================================================================= + +// TimestampedPolylinePool (64 bytes) +struct TimestampedPolylinePool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint vertices_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4, _pad5, _pad6, _pad7; // Padding to 64 bytes +}; + +// TimestampedPolygonPool (64 bytes) +struct TimestampedPolygonPool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint num_triangles; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint tri_ps_offset; + uint vertices_offset; + uint triangles_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4; // Padding to 64 bytes (16 uints) +}; + +// CubePool (64 bytes) - used for obstacles, traffic lights, traffic signs, etc. +// Renamed from ObstaclePool but keeping struct name for backward compat +struct ObstaclePool { + uint num_cubes; // Was: num_obstacles + uint num_timestamps; + uint num_track_poses; + uint prim_type_id; // Semantic type for color lookup + uint timestamps_offset; // Global timestamps for this pool + uint cube_ts_ps_offset; // Per-cube track length prefix sum (was: obstacle_ts_ps_offset) + uint track_timestamps_offset; // Per-pose timestamps in float buffer (as 2x uint for int64) + uint translations_offset; // Per-pose translations (3 floats each) + uint quaternions_offset; // Per-pose quaternions (4 floats each) + uint scales_offset; // Per-cube scales (3 floats each) + uint colors_offset; // Per-cube colors (6 floats each) + uint render_flags; // CUBE_FLAG_* bits (e.g., CUBE_FLAG_WIREFRAME) + uint _pad2, _pad3, _pad4, _pad5; // 4 padding fields for 64 bytes total +}; + +// Cube render flags +const uint CUBE_FLAG_WIREFRAME = 1u; // Draw wireframe edges in addition to solid faces + +// TimestampedScene (128 bytes) +struct TimestampedScene { + uint num_polyline_pools; + uint polyline_pools_offset; + uint num_polygon_pools; + uint polygon_pools_offset; + uint num_cube_pools; // Was: has_obstacle_pool (0/1), now supports multiple + uint cube_pools_offset; // Was: obstacle_pool_offset + uint timestamps_buffer_offset; + uint int32_buffer_offset; + uint vertex_buffer_offset; + uint triangle_buffer_offset; + uint pose_buffer_offset; + uint float_buffer_offset; + uint _pad[20]; +}; + +// RenderQuery (16 bytes) +struct RenderQuery { + uint scene_id; + uint camera_id; + int64_t timestamp_us; + uint camera_type_id; // CAMERA_TYPE_REGULAR or CAMERA_TYPE_BEV + uint _pad1, _pad2, _pad3; // Padding to 32 bytes +}; + +// FThetaCamera (72 bytes) +struct FThetaCamera { + float cx, cy; + float img_w, img_h; + float poly0, poly1, poly2, poly3, poly4, poly5; + float max_ray_angle; + float max_distortion_val; + float max_distortion_dval; + float depth_max; + float ld_c, ld_d, ld_e, ld_f; +}; + +// CameraPose (64 bytes) +struct CameraPose { + mat4 world_to_camera; +}; + +// Vertex (16 bytes) +struct Vertex { + float x, y, z; + float _pad; +}; + +//============================================================================= +// Buffer Bindings +//============================================================================= + +// Global data buffers +layout(std430, binding = 0) readonly buffer TimestampsBuffer { + int64_t g_timestamps[]; +}; + +layout(std430, binding = 1) readonly buffer Int32Buffer { + int g_int32[]; +}; + +layout(std430, binding = 2) readonly buffer VertexBuffer { + Vertex g_vertices[]; +}; + +layout(std430, binding = 3) readonly buffer TriangleBuffer { + uvec3 g_triangles[]; +}; + +layout(std430, binding = 4) readonly buffer PoseBuffer { + CameraPose g_poses[]; +}; + +layout(std430, binding = 5) readonly buffer FloatBuffer { + float g_floats[]; +}; + +// Scene metadata +layout(std430, binding = 6) readonly buffer SceneBuffer { + TimestampedScene g_scenes[]; +}; + +layout(std430, binding = 7) readonly buffer PolylinePoolBuffer { + TimestampedPolylinePool g_polyline_pools[]; +}; + +layout(std430, binding = 8) readonly buffer PolygonPoolBuffer { + TimestampedPolygonPool g_polygon_pools[]; +}; + +layout(std430, binding = 9) readonly buffer ObstaclePoolBuffer { + ObstaclePool g_obstacle_pools[]; +}; + +// Camera buffers +layout(std430, binding = 11) readonly buffer CameraIntrinsicsBuffer { + FThetaCamera g_camera_intrinsics[]; +}; + +layout(std430, binding = 12) readonly buffer CameraPoseBuffer { + CameraPose g_camera_poses[]; // One per query (dynamic viewpoints) +}; + +// Query buffer +layout(std430, binding = 13) readonly buffer QueryBuffer { + RenderQuery g_queries[]; +}; + +// Uniforms +// Spatial culling: elements beyond depth_max * scale from the camera are +// discarded in the task shader. Scale > 1 gives headroom so nothing at +// the visible boundary pops in/out. Set to 0 to disable culling. + +//============================================================================= +// GPU Binary Search +// Returns index of last element <= target, or -1 if target < all elements +//============================================================================= + +int binary_search_timestamps(uint base_offset, uint count, int64_t target) { + if (count == 0u) return -1; + + int left = 0; + int right = int(count) - 1; + int result = -1; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t val = g_timestamps[base_offset + uint(mid)]; + + if (val <= target) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + + return result; +} + +//============================================================================= +// Quaternion Math for Track Interpolation +//============================================================================= + +// Quaternion dot product +float quat_dot(vec4 a, vec4 b) { + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +// Quaternion normalize +vec4 quat_normalize(vec4 q) { + float len = length(q); + return len > 1e-10 ? q / len : vec4(0.0, 0.0, 0.0, 1.0); +} + +// Quaternion spherical linear interpolation (slerp) +vec4 quat_slerp(vec4 q0, vec4 q1, float t) { + // Ensure shortest path + float d = quat_dot(q0, q1); + if (d < 0.0) { + q1 = -q1; + d = -d; + } + + // If quaternions are very close, use linear interpolation + if (d > 0.9995) { + return quat_normalize(mix(q0, q1, t)); + } + + // Spherical interpolation + float theta_0 = acos(clamp(d, -1.0, 1.0)); + float theta = theta_0 * t; + float sin_theta = sin(theta); + float sin_theta_0 = sin(theta_0); + + float s0 = cos(theta) - d * sin_theta / sin_theta_0; + float s1 = sin_theta / sin_theta_0; + + return quat_normalize(s0 * q0 + s1 * q1); +} + +// Convert quaternion (x, y, z, w) to 3x3 rotation matrix +// GLSL mat3 is column-major: mat3(col0, col1, col2) +mat3 quat_to_matrix(vec4 q) { + float x = q.x, y = q.y, z = q.z, w = q.w; + + float x2 = x + x, y2 = y + y, z2 = z + z; + float xx = x * x2, xy = x * y2, xz = x * z2; + float yy = y * y2, yz = y * z2, zz = z * z2; + float wx = w * x2, wy = w * y2, wz = w * z2; + + // Column 0: (R00, R10, R20), Column 1: (R01, R11, R21), Column 2: (R02, R12, R22) + return mat3( + 1.0 - (yy + zz), xy + wz, xz - wy, // Column 0 + xy - wz, 1.0 - (xx + zz), yz + wx, // Column 1 + xz + wy, yz - wx, 1.0 - (xx + yy) // Column 2 + ); +} + +// Build 4x4 transform from translation and quaternion (with scale) +mat4 build_transform(vec3 translation, vec4 quaternion, vec3 scale) { + mat3 rot = quat_to_matrix(quaternion); + + // Apply scale to each column of rotation matrix + mat4 result = mat4( + vec4(rot[0] * scale.x, 0.0), + vec4(rot[1] * scale.y, 0.0), + vec4(rot[2] * scale.z, 0.0), + vec4(translation, 1.0) + ); + + return result; +} + +// Binary search for track interpolation (returns index where t0 <= target < t1) +// Returns -1 if target is outside the track range +int binary_search_track(uint base_offset, uint count, int64_t target) { + if (count < 2u) return -1; // Need at least 2 points for interpolation + + int64_t first_ts = g_timestamps[base_offset]; + int64_t last_ts = g_timestamps[base_offset + count - 1u]; + + // Check bounds + if (target < first_ts || target > last_ts) return -1; + + int left = 0; + int right = int(count) - 2; // Max valid index for interpolation start + int result = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[base_offset + uint(mid)]; + int64_t t1 = g_timestamps[base_offset + uint(mid) + 1u]; + + if (t0 <= target && target <= t1) { + return mid; + } else if (target < t0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + + return -1; // Should not reach here for valid input +} + +//============================================================================= +// Spatial Culling Helpers +//============================================================================= + +// AABB-AABB overlap test +bool cull_aabb_overlap(vec3 a_min, vec3 a_max, vec3 b_min, vec3 b_max) { + return all(lessThanEqual(a_min, b_max)) && all(greaterThanEqual(a_max, b_min)); +} + +// Sphere-AABB overlap test +bool cull_sphere_aabb_overlap(vec3 center, float radius, vec3 b_min, vec3 b_max) { + vec3 nearest = clamp(center, b_min, b_max); + vec3 d = center - nearest; + return dot(d, d) <= radius * radius; +} + +// Extract camera world position from view pose +vec3 get_camera_world_pos(CameraPose pose) { + mat3 R = mat3(pose.world_to_camera); + return -transpose(R) * pose.world_to_camera[3].xyz; +} + +//============================================================================= +// F-theta Projection +//============================================================================= + +vec3 rotate_rodrigues(vec3 v, vec3 r) { + float theta = length(r); + if (theta < 1e-8) return v; + vec3 k = r / theta; + float c = cos(theta); + float s = sin(theta); + return v * c + cross(k, v) * s + k * dot(k, v) * (1.0 - c); +} + +// F-theta projection: world point -> NDC +// Supports >180° FOV fisheye cameras where points can have negative z (behind camera plane) +vec4 ftheta_project(vec3 world_pos, CameraPose pose, FThetaCamera cam) { + vec3 cam_pt = (pose.world_to_camera * vec4(world_pos, 1.0)).xyz; + float depth = cam_pt.z; + + float ray_norm = length(cam_pt); + + // Handle points at camera origin + if (ray_norm < 1e-6) { + return vec4(0.0, 0.0, 0.0, 1.0); + } + + float half_pi = 1.5707963; // π/2 + + // For cameras with FOV <= 180° (max_ray_angle <= π/2), points behind camera should be clipped + // Use pseudo-pinhole projection to push them far away in the correct direction + if (cam.max_ray_angle <= half_pi && depth < 0.001) { + float pseudo_focal = cam.poly1; + float x_clip = cam_pt.x * pseudo_focal / (cam.img_w * 0.5); + float y_clip = -cam_pt.y * pseudo_focal / (cam.img_h * 0.5); + return vec4(x_clip * 10.0, y_clip * 10.0, 1.0, 1.0); // Scale by 10 to push far outside + } + + float xy_norm = length(cam_pt.xy); + float cos_alpha = clamp(cam_pt.z / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); // alpha in [0, π] + + // Apply polynomial projection (with linear extrapolation beyond max_ray_angle) + float a2 = alpha * alpha; + float a3 = a2 * alpha; + float a4 = a2 * a2; + float a5 = a4 * alpha; + + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * a3 + cam.poly4 * a4 + cam.poly5 * a5; + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt.xy; + + vec2 pixel_dist; + pixel_dist.x = cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y; + pixel_dist.y = cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y; + + vec2 pixel = pixel_dist + vec2(cam.cx, cam.cy); + + float x_ndc = 2.0 * pixel.x / cam.img_w - 1.0; + float y_ndc = 1.0 - 2.0 * pixel.y / cam.img_h; + + // For z-buffer depth mapping: + // - Narrow FOV (<=180°): use signed depth (cam_pt.z) + // - Wide FOV (>180°): use ray_norm for front-camera vertices (unchanged), + // but push behind-camera vertices to depth_max so they never occlude + // forward geometry. ray_norm alone can't distinguish front from behind. + float z_value; + if (cam.max_ray_angle > half_pi) { + z_value = (depth >= 0.0) ? ray_norm : cam.depth_max; + } else { + z_value = depth; + } + float z_ndc = clamp(z_value / cam.depth_max, 0.0, 1.0); + + return vec4(x_ndc, y_ndc, z_ndc, 1.0); +} + +// Inline version that takes mat4 directly +float estimate_edge_distortion_pixels_mat4(vec3 v0, vec3 v1, mat4 world_to_cam, FThetaCamera cam) { + // Transform to camera space + vec3 cam_pt0 = (world_to_cam * vec4(v0, 1.0)).xyz; + vec3 cam_pt1 = (world_to_cam * vec4(v1, 1.0)).xyz; + vec3 mid_world = (v0 + v1) * 0.5; + vec3 cam_pt_mid = (world_to_cam * vec4(mid_world, 1.0)).xyz; + + // Just clamp depths to avoid division issues + + // For segments in front of camera, compute f-theta projection error directly + // Use depth-clamped projection to handle near-plane cases + float depth0 = max(cam_pt0.z, 0.001); + float depth1 = max(cam_pt1.z, 0.001); + float depth_mid = max(cam_pt_mid.z, 0.001); + + // Compute f-theta projection for each point + // We inline the projection to avoid struct-passing issues + vec2 pixel0, pixel1, pixel_mid; + { + float xy_norm = length(cam_pt0.xy); + float ray_norm = length(vec3(cam_pt0.xy, depth0)) + 1e-10; + float cos_alpha = clamp(depth0 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt0.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel0 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt1.xy); + float ray_norm = length(vec3(cam_pt1.xy, depth1)) + 1e-10; + float cos_alpha = clamp(depth1 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt1.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel1 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt_mid.xy); + float ray_norm = length(vec3(cam_pt_mid.xy, depth_mid)) + 1e-10; + float cos_alpha = clamp(depth_mid / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt_mid.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel_mid = pixel_dist + vec2(cam.cx, cam.cy); + } + + // Compute error: distance from projected midpoint to linear interpolation + vec2 linear_pixel_mid = (pixel0 + pixel1) * 0.5; + float error_pixels = length(pixel_mid - linear_pixel_mid); + + // Clamp to reasonable range to handle edge cases + return clamp(error_pixels, 0.0, 10000.0); +} + +uint compute_subdivision_level(vec3 v0, vec3 v1, CameraPose pose, FThetaCamera cam, float threshold_pixels) { + float error = estimate_edge_distortion_pixels_mat4(v0, v1, pose.world_to_camera, cam); + + if (error < threshold_pixels) return 0u; + if (error < threshold_pixels * 2.0) return 1u; + if (error < threshold_pixels * 4.0) return 2u; + return 3u; +} + +//============================================================================= +// Barycentric Subdivision Utilities (shared with polygon/cube) +//============================================================================= + +uint bary_vertex_count(uint level) { + // Vertices = (n+1)(n+2)/2 where n = 2^level + if (level == 0u) return 3u; + if (level == 1u) return 6u; + if (level == 2u) return 15u; + return 45u; // level 3 +} + +uint bary_triangle_count(uint level) { + // Triangles = 4^level + if (level == 0u) return 1u; + if (level == 1u) return 4u; + if (level == 2u) return 16u; + return 64u; // level 3 +} + +vec2 bary_vertex_uv(uint vertex_idx, uint level) { + if (level == 0u) { + if (vertex_idx == 0u) return vec2(0.0, 0.0); + if (vertex_idx == 1u) return vec2(1.0, 0.0); + return vec2(0.0, 1.0); + } else if (level == 1u) { + vec2 uvs[6]; + uvs[0] = vec2(0.0, 0.0); + uvs[1] = vec2(1.0, 0.0); + uvs[2] = vec2(0.0, 1.0); + uvs[3] = vec2(0.5, 0.0); + uvs[4] = vec2(0.5, 0.5); + uvs[5] = vec2(0.0, 0.5); + return uvs[vertex_idx]; + } else if (level == 2u) { + uint row, col; + if (vertex_idx < 5u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 9u) { row = 1u; col = vertex_idx - 5u; } + else if (vertex_idx < 12u) { row = 2u; col = vertex_idx - 9u; } + else if (vertex_idx < 14u) { row = 3u; col = vertex_idx - 12u; } + else { row = 4u; col = 0u; } + return vec2(float(col) / 4.0, float(row) / 4.0); + } else { + // Level 3: 9 rows (0-8), row r has (9-r) vertices + uint row, col; + if (vertex_idx < 9u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 17u) { row = 1u; col = vertex_idx - 9u; } + else if (vertex_idx < 24u) { row = 2u; col = vertex_idx - 17u; } + else if (vertex_idx < 30u) { row = 3u; col = vertex_idx - 24u; } + else if (vertex_idx < 35u) { row = 4u; col = vertex_idx - 30u; } + else if (vertex_idx < 39u) { row = 5u; col = vertex_idx - 35u; } + else if (vertex_idx < 42u) { row = 6u; col = vertex_idx - 39u; } + else if (vertex_idx < 44u) { row = 7u; col = vertex_idx - 42u; } + else { row = 8u; col = 0u; } + return vec2(float(col) / 8.0, float(row) / 8.0); + } +} + +vec3 bary_interpolate(vec3 v0, vec3 v1, vec3 v2, vec2 uv) { + float w = 1.0 - uv.x - uv.y; + return v0 * w + v1 * uv.x + v2 * uv.y; +} + +uvec3 bary_triangle_indices(uint tri_idx, uint level) { + if (level == 0u) { + return uvec3(0u, 1u, 2u); + } else if (level == 1u) { + uvec3 tris[4]; + tris[0] = uvec3(0u, 3u, 5u); + tris[1] = uvec3(3u, 1u, 4u); + tris[2] = uvec3(5u, 4u, 2u); + tris[3] = uvec3(3u, 4u, 5u); + return tris[tri_idx]; + } else if (level == 2u) { + uint row_start[5] = uint[5](0u, 5u, 9u, 12u, 14u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + if (t < 7u) { + row = 0u; + if (t < 4u) { col = t; is_down = false; } + else { col = t - 4u; is_down = true; } + } else if (t < 12u) { + row = 1u; + uint lt = t - 7u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 15u) { + row = 2u; + uint lt = t - 12u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 3u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } else { + // Level 3: row_start for 9 rows + uint row_start[9] = uint[9](0u, 9u, 17u, 24u, 30u, 35u, 39u, 42u, 44u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + // Row 0: 8 up + 7 down = 15, Row 1: 7 up + 6 down = 13, etc. + if (t < 15u) { + row = 0u; + if (t < 8u) { col = t; is_down = false; } + else { col = t - 8u; is_down = true; } + } else if (t < 28u) { + row = 1u; uint lt = t - 15u; + if (lt < 7u) { col = lt; is_down = false; } + else { col = lt - 7u; is_down = true; } + } else if (t < 39u) { + row = 2u; uint lt = t - 28u; + if (lt < 6u) { col = lt; is_down = false; } + else { col = lt - 6u; is_down = true; } + } else if (t < 48u) { + row = 3u; uint lt = t - 39u; + if (lt < 5u) { col = lt; is_down = false; } + else { col = lt - 5u; is_down = true; } + } else if (t < 55u) { + row = 4u; uint lt = t - 48u; + if (lt < 4u) { col = lt; is_down = false; } + else { col = lt - 4u; is_down = true; } + } else if (t < 60u) { + row = 5u; uint lt = t - 55u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 63u) { + row = 6u; uint lt = t - 60u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 7u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } +} + + +layout(local_size_x = 32) in; +layout(triangles, max_vertices = 64, max_primitives = 64) out; + +struct PolygonTaskPayload { + uint query_id; + uint pool_id; + uint varray_idx; + uint triangle_count; + uint vertex_count; + uint subdivision_level; + vec3 color; + float is_bev; +}; +taskPayloadSharedEXT PolygonTaskPayload payload; + +out gl_MeshPerVertexNV { + vec4 gl_Position; +} gl_MeshVerticesEXT[]; + +perprimitiveEXT out gl_MeshPerPrimitiveNV { + int gl_Layer; +} gl_MeshPrimitivesEXT[]; + +// Per-primitive color (same as polylines) - no per-vertex array needed +layout(location = 0) perprimitiveEXT out PrimColorBlock { + vec3 color; + float is_bev; // 1.0 for BEV cameras (disables fog), 0.0 otherwise +} prim_out[]; + +void main() { + uint _prim_count = 0u; + uint chunk_id = gl_WorkGroupID.x; + uint subdiv = payload.subdivision_level; + uint tid = gl_LocalInvocationID.x; + + RenderQuery query = g_queries[payload.query_id]; + TimestampedScene scene = g_scenes[query.scene_id]; + TimestampedPolygonPool pool = g_polygon_pools[scene.polygon_pools_offset + payload.pool_id]; + + FThetaCamera cam = g_camera_intrinsics[query.camera_id]; + CameraPose pose = g_camera_poses[payload.query_id]; + + // Get triangle/vertex ranges for this polygon + uint tri_start = 0u; + if (payload.varray_idx > 0u) { + tri_start = uint(g_int32[scene.int32_buffer_offset + pool.tri_ps_offset + payload.varray_idx - 1u]); + } + uint tri_end = uint(g_int32[scene.int32_buffer_offset + pool.tri_ps_offset + payload.varray_idx]); + uint total_tris = tri_end - tri_start; + + uint v_start = 0u; + if (payload.varray_idx > 0u) { + v_start = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + payload.varray_idx - 1u]); + } + + uint base_v_idx = scene.vertex_buffer_offset + pool.vertices_offset + v_start; + uint base_t_idx = scene.triangle_buffer_offset + pool.triangles_offset + tri_start; + + const uint CHUNK_SIZE = 8u; // Conservative chunking + const uint MAX_SHARED_VERTS = 30u; // Match original + + if (subdiv == 0u && payload.vertex_count <= MAX_SHARED_VERTS && chunk_id == 0u) { + // ===== NO SUBDIVISION, SHARED VERTEX MODE (small polygons) ===== + uint num_verts = min(payload.vertex_count, 30u); + uint num_tris = min(total_tris, 28u); + + _prim_count = num_tris; SetMeshOutputsEXT(num_verts, _prim_count); + + if (tid < num_verts) { + Vertex vtx = g_vertices[base_v_idx + tid]; + vec3 world_pos = vec3(vtx.x, vtx.y, vtx.z); + + vec4 clip = ftheta_project(world_pos, pose, cam); + gl_MeshVerticesEXT[tid].gl_Position = clip; + } + + barrier(); + + if (tid < num_tris) { + uvec3 tri = g_triangles[base_t_idx + tid]; + + uint base = tid * 3u; + gl_PrimitiveTriangleIndicesEXT[(base) / 3u] = uvec3(tri.x, tri.y, tri.z); + + gl_MeshPrimitivesEXT[tid].gl_Layer = int(payload.query_id); + prim_out[tid].color = payload.color; + prim_out[tid].is_bev = payload.is_bev; + } + } else if (subdiv == 1u) { + // ===== LEVEL 1 SUBDIVISION: 4 sub-triangles per triangle ===== + uint verts_per_tri = bary_vertex_count(1u); // 6 + uint tris_per_tri = bary_triangle_count(1u); // 4 + + uint tris_per_chunk = 5u; // Original value + uint chunk_start = chunk_id * tris_per_chunk; + uint chunk_end = min(chunk_start + tris_per_chunk, total_tris); + uint num_orig_tris = chunk_end - chunk_start; + + if (num_orig_tris == 0u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + uint num_out_verts = num_orig_tris * verts_per_tri; + uint num_out_tris = num_orig_tris * tris_per_tri; + _prim_count = num_out_tris; SetMeshOutputsEXT(num_out_verts, _prim_count); + + if (tid < num_orig_tris) { + uvec3 tri = g_triangles[base_t_idx + chunk_start + tid]; + + Vertex v0_data = g_vertices[base_v_idx + tri.x]; + Vertex v1_data = g_vertices[base_v_idx + tri.y]; + Vertex v2_data = g_vertices[base_v_idx + tri.z]; + + vec3 v0 = vec3(v0_data.x, v0_data.y, v0_data.z); + vec3 v1 = vec3(v1_data.x, v1_data.y, v1_data.z); + vec3 v2 = vec3(v2_data.x, v2_data.y, v2_data.z); + + uint vert_base = tid * verts_per_tri; + for (uint i = 0u; i < verts_per_tri; i++) { + vec2 uv = bary_vertex_uv(i, 1u); + vec3 pt = bary_interpolate(v0, v1, v2, uv); + + vec4 clip = ftheta_project(pt, pose, cam); + gl_MeshVerticesEXT[vert_base + i].gl_Position = clip; + } + } + + barrier(); + + if (tid < num_orig_tris) { + uint vert_base = tid * verts_per_tri; + uint tri_base = tid * tris_per_tri; + + for (uint t = 0u; t < tris_per_tri; t++) { + uvec3 idx = bary_triangle_indices(t, 1u); + uint idx_base = (tri_base + t) * 3u; + gl_PrimitiveTriangleIndicesEXT[(idx_base) / 3u] = uvec3(vert_base + idx.x, vert_base + idx.y, vert_base + idx.z); + gl_MeshPrimitivesEXT[tri_base + t].gl_Layer = int(payload.query_id); + prim_out[tri_base + t].color = payload.color; + prim_out[tri_base + t].is_bev = payload.is_bev; + } + } + } else if (subdiv == 2u) { + // ===== LEVEL 2 SUBDIVISION: 16 sub-triangles per triangle ===== + const uint TRIS_PER_CHUNK = 2u; // Original value + uint chunk_start = chunk_id * TRIS_PER_CHUNK; + uint chunk_end = min(chunk_start + TRIS_PER_CHUNK, total_tris); + uint num_orig_tris = chunk_end - chunk_start; + + if (num_orig_tris == 0u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + uint num_out_verts = num_orig_tris * 15u; + _prim_count = num_orig_tris * 16u; SetMeshOutputsEXT(num_out_verts, _prim_count); + + uint tri_local = tid / 16u; + uint vert_local = tid % 16u; + + if (tri_local < num_orig_tris && vert_local < 15u) { + uvec3 tri = g_triangles[base_t_idx + chunk_start + tri_local]; + + Vertex v0_data = g_vertices[base_v_idx + tri.x]; + Vertex v1_data = g_vertices[base_v_idx + tri.y]; + Vertex v2_data = g_vertices[base_v_idx + tri.z]; + + vec3 v0 = vec3(v0_data.x, v0_data.y, v0_data.z); + vec3 v1 = vec3(v1_data.x, v1_data.y, v1_data.z); + vec3 v2 = vec3(v2_data.x, v2_data.y, v2_data.z); + + vec2 uv = bary_vertex_uv(vert_local, 2u); + vec3 pt = bary_interpolate(v0, v1, v2, uv); + + vec4 clip = ftheta_project(pt, pose, cam); + uint vert_idx = tri_local * 15u + vert_local; + gl_MeshVerticesEXT[vert_idx].gl_Position = clip; + } + + barrier(); + + if (tri_local < num_orig_tris && vert_local < 16u) { + uint vert_base = tri_local * 15u; + uint tri_out_idx = tri_local * 16u + vert_local; + + uvec3 idx = bary_triangle_indices(vert_local, 2u); + + uint idx_base = tri_out_idx * 3u; + gl_PrimitiveTriangleIndicesEXT[(idx_base) / 3u] = uvec3(vert_base + idx.x, vert_base + idx.y, vert_base + idx.z); + gl_MeshPrimitivesEXT[tri_out_idx].gl_Layer = int(payload.query_id); + prim_out[tri_out_idx].color = payload.color; + prim_out[tri_out_idx].is_bev = payload.is_bev; + } + } else if (subdiv == 3u) { + // ===== LEVEL 3 SUBDIVISION: 64 sub-triangles per triangle ===== + // 1 original triangle per chunk (45 verts, 64 output tris) + const uint TRIS_PER_CHUNK = 1u; + uint chunk_start = chunk_id * TRIS_PER_CHUNK; + + if (chunk_start >= total_tris) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + _prim_count = 64u; SetMeshOutputsEXT(45u, _prim_count); + + // Load the single triangle for this chunk + uvec3 tri = g_triangles[base_t_idx + chunk_start]; + Vertex v0_data = g_vertices[base_v_idx + tri.x]; + Vertex v1_data = g_vertices[base_v_idx + tri.y]; + Vertex v2_data = g_vertices[base_v_idx + tri.z]; + vec3 v0 = vec3(v0_data.x, v0_data.y, v0_data.z); + vec3 v1 = vec3(v1_data.x, v1_data.y, v1_data.z); + vec3 v2 = vec3(v2_data.x, v2_data.y, v2_data.z); + + // Each thread handles ~2 vertices (45 verts / 32 threads) + for (uint v = tid; v < 45u; v += 32u) { + vec2 uv = bary_vertex_uv(v, 3u); + vec3 pt = bary_interpolate(v0, v1, v2, uv); + vec4 clip = ftheta_project(pt, pose, cam); + gl_MeshVerticesEXT[v].gl_Position = clip; + } + + barrier(); + + // Each thread handles 2 triangles (64 tris / 32 threads) + for (uint t = tid; t < 64u; t += 32u) { + uvec3 idx = bary_triangle_indices(t, 3u); + uint idx_base = t * 3u; + gl_PrimitiveTriangleIndicesEXT[(idx_base) / 3u] = uvec3(idx.x, idx.y, idx.z); + gl_MeshPrimitivesEXT[t].gl_Layer = int(payload.query_id); + prim_out[t].color = payload.color; + prim_out[t].is_bev = payload.is_bev; + } + } else { + // ===== LARGE POLYGON WITHOUT SUBDIVISION ===== + uint chunk_start = chunk_id * CHUNK_SIZE; + uint chunk_end = min(chunk_start + CHUNK_SIZE, total_tris); + uint num_orig_tris = chunk_end - chunk_start; + + if (num_orig_tris == 0u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + uint num_out_verts = num_orig_tris * 3u; + _prim_count = num_orig_tris; SetMeshOutputsEXT(num_out_verts, _prim_count); + + if (tid < num_orig_tris) { + uvec3 tri = g_triangles[base_t_idx + chunk_start + tid]; + + Vertex v0_data = g_vertices[base_v_idx + tri.x]; + Vertex v1_data = g_vertices[base_v_idx + tri.y]; + Vertex v2_data = g_vertices[base_v_idx + tri.z]; + + vec3 v0 = vec3(v0_data.x, v0_data.y, v0_data.z); + vec3 v1 = vec3(v1_data.x, v1_data.y, v1_data.z); + vec3 v2 = vec3(v2_data.x, v2_data.y, v2_data.z); + + uint vert_base = tid * 3u; + + vec4 clip0 = ftheta_project(v0, pose, cam); + vec4 clip1 = ftheta_project(v1, pose, cam); + vec4 clip2 = ftheta_project(v2, pose, cam); + gl_MeshVerticesEXT[vert_base + 0u].gl_Position = clip0; + gl_MeshVerticesEXT[vert_base + 1u].gl_Position = clip1; + gl_MeshVerticesEXT[vert_base + 2u].gl_Position = clip2; + + uint idx_base = tid * 3u; + gl_PrimitiveTriangleIndicesEXT[(idx_base) / 3u] = uvec3(vert_base + 0u, vert_base + 1u, vert_base + 2u); + gl_MeshPrimitivesEXT[tid].gl_Layer = int(payload.query_id); + prim_out[tid].color = payload.color; + prim_out[tid].is_bev = payload.is_bev; + } + } +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.task.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.task.glsl new file mode 100644 index 000000000..a708f2854 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polygon.task.glsl @@ -0,0 +1,1014 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_mesh_shader : require +#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Cap styles +const uint CAP_NONE = 0u; +const uint CAP_FLAT = 1u; +const uint CAP_ROUND = 2u; + +// Primitive type IDs (must match Python PRIM_* constants in ops.py) +const uint PRIM_ROAD_BOUNDARY = 0u; +const uint PRIM_LANE_LINE = 1u; // Legacy cyan lane line +const uint PRIM_CROSSWALK = 2u; +const uint PRIM_STATIC_OBSTACLE = 3u; // Legacy, avoid using +const uint PRIM_EGO_TRAJECTORY = 4u; +const uint PRIM_OBSTACLE = 5u; +const uint PRIM_EGO_OBSTACLE = 6u; +const uint PRIM_WAIT_LINE = 7u; +const uint PRIM_POLE = 8u; +const uint PRIM_ROAD_MARKING = 9u; +const uint PRIM_LANE_BOUNDARY = 10u; +const uint PRIM_TRAFFIC_LIGHT = 11u; +const uint PRIM_TRAFFIC_SIGN = 12u; +const uint PRIM_INTERSECTION = 13u; +const uint PRIM_ROAD_ISLAND = 14u; +const uint PRIM_BUFFER_ZONE = 15u; +// Lane line variants by color/style +const uint PRIM_LANE_LINE_WHITE_SOLID = 16u; +const uint PRIM_LANE_LINE_WHITE_DASHED = 17u; +const uint PRIM_LANE_LINE_YELLOW_SOLID = 18u; +const uint PRIM_LANE_LINE_YELLOW_DASHED = 19u; +// Dot primitives - each vertex is rendered as a circle +const uint PRIM_DOT_YELLOW = 20u; +const uint PRIM_DOT_WHITE = 21u; + +// Camera type IDs +const uint CAMERA_TYPE_REGULAR = 0u; +const uint CAMERA_TYPE_BEV = 1u; + +//============================================================================= +// Hardcoded Primitive Styles (matching wm-render colorscheme v3) +//============================================================================= + +// Colors (RGB normalized) - matching imaginaire4 v3 colorscheme +// Source: imaginaire4/imaginaire/auxiliary/world_scenario/color_scheme/config_color_hdmap.json +const vec3 COLOR_ROAD_BOUNDARY = vec3(253.0/255.0, 1.0/255.0, 232.0/255.0); // Magenta (253, 1, 232) +const vec3 COLOR_LANE_LINE = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (98, 183, 249) - "lanelines" (legacy) +const vec3 COLOR_CROSSWALK = vec3(139.0/255.0, 93.0/255.0, 255.0/255.0); // Purple (139, 93, 255) +const vec3 COLOR_STATIC_OBSTACLE = vec3(255.0/255.0, 100.0/255.0, 0.0/255.0); // Orange (legacy) +const vec3 COLOR_EGO_TRAJECTORY = vec3(0.0/255.0, 255.0/255.0, 0.0/255.0); // Green (0, 255, 0) +const vec3 COLOR_WAIT_LINE = vec3(108.0/255.0, 179.0/255.0, 59.0/255.0); // Yellow-green (108, 179, 59) +const vec3 COLOR_POLE = vec3(183.0/255.0, 69.0/255.0, 177.0/255.0); // Purple-magenta (183, 69, 177) +const vec3 COLOR_ROAD_MARKING = vec3(20.0/255.0, 254.0/255.0, 185.0/255.0); // Cyan-green (20, 254, 185) +const vec3 COLOR_LANE_BOUNDARY = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (same as lane line) +const vec3 COLOR_TRAFFIC_LIGHT = vec3(100.0/255.0, 100.0/255.0, 100.0/255.0); // Gray (100, 100, 100) +const vec3 COLOR_TRAFFIC_SIGN = vec3(8.0/255.0, 2.0/255.0, 255.0/255.0); // Blue (8, 2, 255) +const vec3 COLOR_INTERSECTION = vec3(80.0/255.0, 80.0/255.0, 120.0/255.0); // Dark blue-gray (approximated) +const vec3 COLOR_ROAD_ISLAND = vec3(60.0/255.0, 120.0/255.0, 60.0/255.0); // Dark green (approximated) +const vec3 COLOR_BUFFER_ZONE = vec3(120.0/255.0, 80.0/255.0, 80.0/255.0); // Dark red-brown (approximated) +// Lane line variants from config_color_geometry_laneline.json +const vec3 COLOR_LANE_LINE_WHITE = vec3(255.0/255.0, 255.0/255.0, 255.0/255.0); // White (255, 255, 255) +const vec3 COLOR_LANE_LINE_YELLOW = vec3(255.0/255.0, 255.0/255.0, 0.0/255.0); // Yellow (255, 255, 0) + +// Default polyline widths (pixels at reference resolution 1280x720) +const float DEFAULT_WIDTH_POLYLINE_REGULAR = 7.0; +const float DEFAULT_WIDTH_POLYLINE_BEV = 4.0; +const float DEFAULT_WIDTH_EGO_TRAJ_REGULAR = 12.0; +const float DEFAULT_WIDTH_EGO_TRAJ_BEV = 5.0; +const float DEFAULT_WIDTH_POLE_REGULAR = 5.0; // Poles are thinner (reference: 5 vs 12) +const float DEFAULT_WIDTH_POLE_BEV = 3.0; +const float DEFAULT_WIDTH_WIREFRAME = 2.0; + +// Configurable width uniforms (set from Python, or use defaults) + +// Compute depth-based scaling factor for line width +// z_ndc is in [-1, 1] where -1 is near, +1 is far +// Returns 1.0 at near, 0.0 at far (linear fade) +float get_depth_scale(vec4 clip) { + if (pc.u_depth_scaling < 0.5) return 1.0; // Disabled + float z_ndc = clip.z / clip.w; // Convert to NDC + float depth_scale = 1.0 - z_ndc; // Map [-1,1] to [1,0] + return clamp(depth_scale, 0.0, 1.0); +} + +// Color palette buffer (optional, configured from Python) +// Declared early so get_prim_color can use it; actual buffer layout defined later +layout(std430, binding = 10) readonly buffer ColorPaletteBufferEarly { + vec4 g_color_palette[]; +}; + +// Get default color for primitive type (hardcoded fallback) +vec3 get_default_prim_color(uint prim_type_id) { + if (prim_type_id == PRIM_ROAD_BOUNDARY) return COLOR_ROAD_BOUNDARY; + if (prim_type_id == PRIM_LANE_LINE) return COLOR_LANE_LINE; + if (prim_type_id == PRIM_CROSSWALK) return COLOR_CROSSWALK; + if (prim_type_id == PRIM_STATIC_OBSTACLE) return COLOR_STATIC_OBSTACLE; + if (prim_type_id == PRIM_EGO_TRAJECTORY) return COLOR_EGO_TRAJECTORY; + if (prim_type_id == PRIM_WAIT_LINE) return COLOR_WAIT_LINE; + if (prim_type_id == PRIM_POLE) return COLOR_POLE; + if (prim_type_id == PRIM_ROAD_MARKING) return COLOR_ROAD_MARKING; + if (prim_type_id == PRIM_LANE_BOUNDARY) return COLOR_LANE_BOUNDARY; + if (prim_type_id == PRIM_TRAFFIC_LIGHT) return COLOR_TRAFFIC_LIGHT; + if (prim_type_id == PRIM_TRAFFIC_SIGN) return COLOR_TRAFFIC_SIGN; + if (prim_type_id == PRIM_INTERSECTION) return COLOR_INTERSECTION; + if (prim_type_id == PRIM_ROAD_ISLAND) return COLOR_ROAD_ISLAND; + if (prim_type_id == PRIM_BUFFER_ZONE) return COLOR_BUFFER_ZONE; + // Lane line variants + if (prim_type_id == PRIM_LANE_LINE_WHITE_SOLID) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_WHITE_DASHED) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_SOLID) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_DASHED) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_YELLOW) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_WHITE) return COLOR_LANE_LINE_WHITE; + return vec3(1.0, 1.0, 1.0); // Default white for obstacles +} + +// Get color for primitive type (checks palette first, then falls back to defaults) +vec3 get_prim_color(uint prim_type_id) { + // If color palette is configured, check if this prim_type has a custom color + // Alpha < 0 means "use default", alpha >= 0 means "use this color" + if (pc.u_color_palette_size > 0 && prim_type_id < uint(pc.u_color_palette_size)) { + vec4 palette_color = g_color_palette[prim_type_id]; + if (palette_color.a >= 0.0) { + return palette_color.rgb; + } + } + // Fall back to hardcoded defaults + return get_default_prim_color(prim_type_id); +} + +// Check if primitive is a dot type (rendered as circles at each vertex) +bool is_dot_primitive(uint prim_type_id) { + return prim_type_id == PRIM_DOT_YELLOW || prim_type_id == PRIM_DOT_WHITE; +} + +// Get polyline width for primitive type and camera type (scaled by resolution) +float get_prim_width(uint prim_type_id, uint camera_type_id) { + bool is_bev = (camera_type_id == CAMERA_TYPE_BEV); + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + + float base_width; + if (prim_type_id == PRIM_EGO_TRAJECTORY) { + float default_w = is_bev ? DEFAULT_WIDTH_EGO_TRAJ_BEV : DEFAULT_WIDTH_EGO_TRAJ_REGULAR; + float custom_w = is_bev ? pc.u_width_ego_traj_bev : pc.u_width_ego_traj_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } else if (prim_type_id == PRIM_POLE) { + // Poles use thinner lines (reference: 5 pixels vs 12 for other polylines) + base_width = is_bev ? DEFAULT_WIDTH_POLE_BEV : DEFAULT_WIDTH_POLE_REGULAR; + } else { + float default_w = is_bev ? DEFAULT_WIDTH_POLYLINE_BEV : DEFAULT_WIDTH_POLYLINE_REGULAR; + float custom_w = is_bev ? pc.u_width_polyline_bev : pc.u_width_polyline_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } + return base_width * scale; +} + +// Get wireframe edge width (scaled by resolution) +float get_wireframe_width() { + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + float base_width = (pc.u_width_wireframe > 0.0) ? pc.u_width_wireframe : DEFAULT_WIDTH_WIREFRAME; + return base_width * scale; +} + +//============================================================================= +// Data Structures (must match C++ structs) +//============================================================================= + +// TimestampedPolylinePool (64 bytes) +struct TimestampedPolylinePool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint vertices_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4, _pad5, _pad6, _pad7; // Padding to 64 bytes +}; + +// TimestampedPolygonPool (64 bytes) +struct TimestampedPolygonPool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint num_triangles; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint tri_ps_offset; + uint vertices_offset; + uint triangles_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4; // Padding to 64 bytes (16 uints) +}; + +// CubePool (64 bytes) - used for obstacles, traffic lights, traffic signs, etc. +// Renamed from ObstaclePool but keeping struct name for backward compat +struct ObstaclePool { + uint num_cubes; // Was: num_obstacles + uint num_timestamps; + uint num_track_poses; + uint prim_type_id; // Semantic type for color lookup + uint timestamps_offset; // Global timestamps for this pool + uint cube_ts_ps_offset; // Per-cube track length prefix sum (was: obstacle_ts_ps_offset) + uint track_timestamps_offset; // Per-pose timestamps in float buffer (as 2x uint for int64) + uint translations_offset; // Per-pose translations (3 floats each) + uint quaternions_offset; // Per-pose quaternions (4 floats each) + uint scales_offset; // Per-cube scales (3 floats each) + uint colors_offset; // Per-cube colors (6 floats each) + uint render_flags; // CUBE_FLAG_* bits (e.g., CUBE_FLAG_WIREFRAME) + uint _pad2, _pad3, _pad4, _pad5; // 4 padding fields for 64 bytes total +}; + +// Cube render flags +const uint CUBE_FLAG_WIREFRAME = 1u; // Draw wireframe edges in addition to solid faces + +// TimestampedScene (128 bytes) +struct TimestampedScene { + uint num_polyline_pools; + uint polyline_pools_offset; + uint num_polygon_pools; + uint polygon_pools_offset; + uint num_cube_pools; // Was: has_obstacle_pool (0/1), now supports multiple + uint cube_pools_offset; // Was: obstacle_pool_offset + uint timestamps_buffer_offset; + uint int32_buffer_offset; + uint vertex_buffer_offset; + uint triangle_buffer_offset; + uint pose_buffer_offset; + uint float_buffer_offset; + uint _pad[20]; +}; + +// RenderQuery (16 bytes) +struct RenderQuery { + uint scene_id; + uint camera_id; + int64_t timestamp_us; + uint camera_type_id; // CAMERA_TYPE_REGULAR or CAMERA_TYPE_BEV + uint _pad1, _pad2, _pad3; // Padding to 32 bytes +}; + +// FThetaCamera (72 bytes) +struct FThetaCamera { + float cx, cy; + float img_w, img_h; + float poly0, poly1, poly2, poly3, poly4, poly5; + float max_ray_angle; + float max_distortion_val; + float max_distortion_dval; + float depth_max; + float ld_c, ld_d, ld_e, ld_f; +}; + +// CameraPose (64 bytes) +struct CameraPose { + mat4 world_to_camera; +}; + +// Vertex (16 bytes) +struct Vertex { + float x, y, z; + float _pad; +}; + +//============================================================================= +// Buffer Bindings +//============================================================================= + +// Global data buffers +layout(std430, binding = 0) readonly buffer TimestampsBuffer { + int64_t g_timestamps[]; +}; + +layout(std430, binding = 1) readonly buffer Int32Buffer { + int g_int32[]; +}; + +layout(std430, binding = 2) readonly buffer VertexBuffer { + Vertex g_vertices[]; +}; + +layout(std430, binding = 3) readonly buffer TriangleBuffer { + uvec3 g_triangles[]; +}; + +layout(std430, binding = 4) readonly buffer PoseBuffer { + CameraPose g_poses[]; +}; + +layout(std430, binding = 5) readonly buffer FloatBuffer { + float g_floats[]; +}; + +// Scene metadata +layout(std430, binding = 6) readonly buffer SceneBuffer { + TimestampedScene g_scenes[]; +}; + +layout(std430, binding = 7) readonly buffer PolylinePoolBuffer { + TimestampedPolylinePool g_polyline_pools[]; +}; + +layout(std430, binding = 8) readonly buffer PolygonPoolBuffer { + TimestampedPolygonPool g_polygon_pools[]; +}; + +layout(std430, binding = 9) readonly buffer ObstaclePoolBuffer { + ObstaclePool g_obstacle_pools[]; +}; + +// Camera buffers +layout(std430, binding = 11) readonly buffer CameraIntrinsicsBuffer { + FThetaCamera g_camera_intrinsics[]; +}; + +layout(std430, binding = 12) readonly buffer CameraPoseBuffer { + CameraPose g_camera_poses[]; // One per query (dynamic viewpoints) +}; + +// Query buffer +layout(std430, binding = 13) readonly buffer QueryBuffer { + RenderQuery g_queries[]; +}; + +// Uniforms +// Spatial culling: elements beyond depth_max * scale from the camera are +// discarded in the task shader. Scale > 1 gives headroom so nothing at +// the visible boundary pops in/out. Set to 0 to disable culling. + +//============================================================================= +// GPU Binary Search +// Returns index of last element <= target, or -1 if target < all elements +//============================================================================= + +int binary_search_timestamps(uint base_offset, uint count, int64_t target) { + if (count == 0u) return -1; + + int left = 0; + int right = int(count) - 1; + int result = -1; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t val = g_timestamps[base_offset + uint(mid)]; + + if (val <= target) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + + return result; +} + +//============================================================================= +// Quaternion Math for Track Interpolation +//============================================================================= + +// Quaternion dot product +float quat_dot(vec4 a, vec4 b) { + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +// Quaternion normalize +vec4 quat_normalize(vec4 q) { + float len = length(q); + return len > 1e-10 ? q / len : vec4(0.0, 0.0, 0.0, 1.0); +} + +// Quaternion spherical linear interpolation (slerp) +vec4 quat_slerp(vec4 q0, vec4 q1, float t) { + // Ensure shortest path + float d = quat_dot(q0, q1); + if (d < 0.0) { + q1 = -q1; + d = -d; + } + + // If quaternions are very close, use linear interpolation + if (d > 0.9995) { + return quat_normalize(mix(q0, q1, t)); + } + + // Spherical interpolation + float theta_0 = acos(clamp(d, -1.0, 1.0)); + float theta = theta_0 * t; + float sin_theta = sin(theta); + float sin_theta_0 = sin(theta_0); + + float s0 = cos(theta) - d * sin_theta / sin_theta_0; + float s1 = sin_theta / sin_theta_0; + + return quat_normalize(s0 * q0 + s1 * q1); +} + +// Convert quaternion (x, y, z, w) to 3x3 rotation matrix +// GLSL mat3 is column-major: mat3(col0, col1, col2) +mat3 quat_to_matrix(vec4 q) { + float x = q.x, y = q.y, z = q.z, w = q.w; + + float x2 = x + x, y2 = y + y, z2 = z + z; + float xx = x * x2, xy = x * y2, xz = x * z2; + float yy = y * y2, yz = y * z2, zz = z * z2; + float wx = w * x2, wy = w * y2, wz = w * z2; + + // Column 0: (R00, R10, R20), Column 1: (R01, R11, R21), Column 2: (R02, R12, R22) + return mat3( + 1.0 - (yy + zz), xy + wz, xz - wy, // Column 0 + xy - wz, 1.0 - (xx + zz), yz + wx, // Column 1 + xz + wy, yz - wx, 1.0 - (xx + yy) // Column 2 + ); +} + +// Build 4x4 transform from translation and quaternion (with scale) +mat4 build_transform(vec3 translation, vec4 quaternion, vec3 scale) { + mat3 rot = quat_to_matrix(quaternion); + + // Apply scale to each column of rotation matrix + mat4 result = mat4( + vec4(rot[0] * scale.x, 0.0), + vec4(rot[1] * scale.y, 0.0), + vec4(rot[2] * scale.z, 0.0), + vec4(translation, 1.0) + ); + + return result; +} + +// Binary search for track interpolation (returns index where t0 <= target < t1) +// Returns -1 if target is outside the track range +int binary_search_track(uint base_offset, uint count, int64_t target) { + if (count < 2u) return -1; // Need at least 2 points for interpolation + + int64_t first_ts = g_timestamps[base_offset]; + int64_t last_ts = g_timestamps[base_offset + count - 1u]; + + // Check bounds + if (target < first_ts || target > last_ts) return -1; + + int left = 0; + int right = int(count) - 2; // Max valid index for interpolation start + int result = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[base_offset + uint(mid)]; + int64_t t1 = g_timestamps[base_offset + uint(mid) + 1u]; + + if (t0 <= target && target <= t1) { + return mid; + } else if (target < t0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + + return -1; // Should not reach here for valid input +} + +//============================================================================= +// Spatial Culling Helpers +//============================================================================= + +// AABB-AABB overlap test +bool cull_aabb_overlap(vec3 a_min, vec3 a_max, vec3 b_min, vec3 b_max) { + return all(lessThanEqual(a_min, b_max)) && all(greaterThanEqual(a_max, b_min)); +} + +// Sphere-AABB overlap test +bool cull_sphere_aabb_overlap(vec3 center, float radius, vec3 b_min, vec3 b_max) { + vec3 nearest = clamp(center, b_min, b_max); + vec3 d = center - nearest; + return dot(d, d) <= radius * radius; +} + +// Extract camera world position from view pose +vec3 get_camera_world_pos(CameraPose pose) { + mat3 R = mat3(pose.world_to_camera); + return -transpose(R) * pose.world_to_camera[3].xyz; +} + +//============================================================================= +// F-theta Projection +//============================================================================= + +vec3 rotate_rodrigues(vec3 v, vec3 r) { + float theta = length(r); + if (theta < 1e-8) return v; + vec3 k = r / theta; + float c = cos(theta); + float s = sin(theta); + return v * c + cross(k, v) * s + k * dot(k, v) * (1.0 - c); +} + +// F-theta projection: world point -> NDC +// Supports >180° FOV fisheye cameras where points can have negative z (behind camera plane) +vec4 ftheta_project(vec3 world_pos, CameraPose pose, FThetaCamera cam) { + vec3 cam_pt = (pose.world_to_camera * vec4(world_pos, 1.0)).xyz; + float depth = cam_pt.z; + + float ray_norm = length(cam_pt); + + // Handle points at camera origin + if (ray_norm < 1e-6) { + return vec4(0.0, 0.0, 0.0, 1.0); + } + + float half_pi = 1.5707963; // π/2 + + // For cameras with FOV <= 180° (max_ray_angle <= π/2), points behind camera should be clipped + // Use pseudo-pinhole projection to push them far away in the correct direction + if (cam.max_ray_angle <= half_pi && depth < 0.001) { + float pseudo_focal = cam.poly1; + float x_clip = cam_pt.x * pseudo_focal / (cam.img_w * 0.5); + float y_clip = -cam_pt.y * pseudo_focal / (cam.img_h * 0.5); + return vec4(x_clip * 10.0, y_clip * 10.0, 1.0, 1.0); // Scale by 10 to push far outside + } + + float xy_norm = length(cam_pt.xy); + float cos_alpha = clamp(cam_pt.z / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); // alpha in [0, π] + + // Apply polynomial projection (with linear extrapolation beyond max_ray_angle) + float a2 = alpha * alpha; + float a3 = a2 * alpha; + float a4 = a2 * a2; + float a5 = a4 * alpha; + + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * a3 + cam.poly4 * a4 + cam.poly5 * a5; + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt.xy; + + vec2 pixel_dist; + pixel_dist.x = cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y; + pixel_dist.y = cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y; + + vec2 pixel = pixel_dist + vec2(cam.cx, cam.cy); + + float x_ndc = 2.0 * pixel.x / cam.img_w - 1.0; + float y_ndc = 1.0 - 2.0 * pixel.y / cam.img_h; + + // For z-buffer depth mapping: + // - Narrow FOV (<=180°): use signed depth (cam_pt.z) + // - Wide FOV (>180°): use ray_norm for front-camera vertices (unchanged), + // but push behind-camera vertices to depth_max so they never occlude + // forward geometry. ray_norm alone can't distinguish front from behind. + float z_value; + if (cam.max_ray_angle > half_pi) { + z_value = (depth >= 0.0) ? ray_norm : cam.depth_max; + } else { + z_value = depth; + } + float z_ndc = clamp(z_value / cam.depth_max, 0.0, 1.0); + + return vec4(x_ndc, y_ndc, z_ndc, 1.0); +} + +// Inline version that takes mat4 directly +float estimate_edge_distortion_pixels_mat4(vec3 v0, vec3 v1, mat4 world_to_cam, FThetaCamera cam) { + // Transform to camera space + vec3 cam_pt0 = (world_to_cam * vec4(v0, 1.0)).xyz; + vec3 cam_pt1 = (world_to_cam * vec4(v1, 1.0)).xyz; + vec3 mid_world = (v0 + v1) * 0.5; + vec3 cam_pt_mid = (world_to_cam * vec4(mid_world, 1.0)).xyz; + + // Just clamp depths to avoid division issues + + // For segments in front of camera, compute f-theta projection error directly + // Use depth-clamped projection to handle near-plane cases + float depth0 = max(cam_pt0.z, 0.001); + float depth1 = max(cam_pt1.z, 0.001); + float depth_mid = max(cam_pt_mid.z, 0.001); + + // Compute f-theta projection for each point + // We inline the projection to avoid struct-passing issues + vec2 pixel0, pixel1, pixel_mid; + { + float xy_norm = length(cam_pt0.xy); + float ray_norm = length(vec3(cam_pt0.xy, depth0)) + 1e-10; + float cos_alpha = clamp(depth0 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt0.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel0 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt1.xy); + float ray_norm = length(vec3(cam_pt1.xy, depth1)) + 1e-10; + float cos_alpha = clamp(depth1 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt1.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel1 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt_mid.xy); + float ray_norm = length(vec3(cam_pt_mid.xy, depth_mid)) + 1e-10; + float cos_alpha = clamp(depth_mid / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt_mid.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel_mid = pixel_dist + vec2(cam.cx, cam.cy); + } + + // Compute error: distance from projected midpoint to linear interpolation + vec2 linear_pixel_mid = (pixel0 + pixel1) * 0.5; + float error_pixels = length(pixel_mid - linear_pixel_mid); + + // Clamp to reasonable range to handle edge cases + return clamp(error_pixels, 0.0, 10000.0); +} + +uint compute_subdivision_level(vec3 v0, vec3 v1, CameraPose pose, FThetaCamera cam, float threshold_pixels) { + float error = estimate_edge_distortion_pixels_mat4(v0, v1, pose.world_to_camera, cam); + + if (error < threshold_pixels) return 0u; + if (error < threshold_pixels * 2.0) return 1u; + if (error < threshold_pixels * 4.0) return 2u; + return 3u; +} + +//============================================================================= +// Barycentric Subdivision Utilities (shared with polygon/cube) +//============================================================================= + +uint bary_vertex_count(uint level) { + // Vertices = (n+1)(n+2)/2 where n = 2^level + if (level == 0u) return 3u; + if (level == 1u) return 6u; + if (level == 2u) return 15u; + return 45u; // level 3 +} + +uint bary_triangle_count(uint level) { + // Triangles = 4^level + if (level == 0u) return 1u; + if (level == 1u) return 4u; + if (level == 2u) return 16u; + return 64u; // level 3 +} + +vec2 bary_vertex_uv(uint vertex_idx, uint level) { + if (level == 0u) { + if (vertex_idx == 0u) return vec2(0.0, 0.0); + if (vertex_idx == 1u) return vec2(1.0, 0.0); + return vec2(0.0, 1.0); + } else if (level == 1u) { + vec2 uvs[6]; + uvs[0] = vec2(0.0, 0.0); + uvs[1] = vec2(1.0, 0.0); + uvs[2] = vec2(0.0, 1.0); + uvs[3] = vec2(0.5, 0.0); + uvs[4] = vec2(0.5, 0.5); + uvs[5] = vec2(0.0, 0.5); + return uvs[vertex_idx]; + } else if (level == 2u) { + uint row, col; + if (vertex_idx < 5u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 9u) { row = 1u; col = vertex_idx - 5u; } + else if (vertex_idx < 12u) { row = 2u; col = vertex_idx - 9u; } + else if (vertex_idx < 14u) { row = 3u; col = vertex_idx - 12u; } + else { row = 4u; col = 0u; } + return vec2(float(col) / 4.0, float(row) / 4.0); + } else { + // Level 3: 9 rows (0-8), row r has (9-r) vertices + uint row, col; + if (vertex_idx < 9u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 17u) { row = 1u; col = vertex_idx - 9u; } + else if (vertex_idx < 24u) { row = 2u; col = vertex_idx - 17u; } + else if (vertex_idx < 30u) { row = 3u; col = vertex_idx - 24u; } + else if (vertex_idx < 35u) { row = 4u; col = vertex_idx - 30u; } + else if (vertex_idx < 39u) { row = 5u; col = vertex_idx - 35u; } + else if (vertex_idx < 42u) { row = 6u; col = vertex_idx - 39u; } + else if (vertex_idx < 44u) { row = 7u; col = vertex_idx - 42u; } + else { row = 8u; col = 0u; } + return vec2(float(col) / 8.0, float(row) / 8.0); + } +} + +vec3 bary_interpolate(vec3 v0, vec3 v1, vec3 v2, vec2 uv) { + float w = 1.0 - uv.x - uv.y; + return v0 * w + v1 * uv.x + v2 * uv.y; +} + +uvec3 bary_triangle_indices(uint tri_idx, uint level) { + if (level == 0u) { + return uvec3(0u, 1u, 2u); + } else if (level == 1u) { + uvec3 tris[4]; + tris[0] = uvec3(0u, 3u, 5u); + tris[1] = uvec3(3u, 1u, 4u); + tris[2] = uvec3(5u, 4u, 2u); + tris[3] = uvec3(3u, 4u, 5u); + return tris[tri_idx]; + } else if (level == 2u) { + uint row_start[5] = uint[5](0u, 5u, 9u, 12u, 14u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + if (t < 7u) { + row = 0u; + if (t < 4u) { col = t; is_down = false; } + else { col = t - 4u; is_down = true; } + } else if (t < 12u) { + row = 1u; + uint lt = t - 7u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 15u) { + row = 2u; + uint lt = t - 12u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 3u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } else { + // Level 3: row_start for 9 rows + uint row_start[9] = uint[9](0u, 9u, 17u, 24u, 30u, 35u, 39u, 42u, 44u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + // Row 0: 8 up + 7 down = 15, Row 1: 7 up + 6 down = 13, etc. + if (t < 15u) { + row = 0u; + if (t < 8u) { col = t; is_down = false; } + else { col = t - 8u; is_down = true; } + } else if (t < 28u) { + row = 1u; uint lt = t - 15u; + if (lt < 7u) { col = lt; is_down = false; } + else { col = lt - 7u; is_down = true; } + } else if (t < 39u) { + row = 2u; uint lt = t - 28u; + if (lt < 6u) { col = lt; is_down = false; } + else { col = lt - 6u; is_down = true; } + } else if (t < 48u) { + row = 3u; uint lt = t - 39u; + if (lt < 5u) { col = lt; is_down = false; } + else { col = lt - 5u; is_down = true; } + } else if (t < 55u) { + row = 4u; uint lt = t - 48u; + if (lt < 4u) { col = lt; is_down = false; } + else { col = lt - 4u; is_down = true; } + } else if (t < 60u) { + row = 5u; uint lt = t - 55u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 63u) { + row = 6u; uint lt = t - 60u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 7u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } +} + + +layout(local_size_x = 1) in; + +// Uniforms for dispatch decoding (same pattern as polylines) + +// Task payload - matches non-timestamped version +struct PolygonTaskPayload { + uint query_id; + uint pool_id; + uint varray_idx; + uint triangle_count; + uint vertex_count; + uint subdivision_level; + vec3 color; + float is_bev; +}; +taskPayloadSharedEXT PolygonTaskPayload payload; + +void main() { + uint _task_count = 0u; + uint work_id = gl_WorkGroupID.x; + + uint varray_offset = work_id % pc.u_max_varrays_per_pool; + uint temp = work_id / pc.u_max_varrays_per_pool; + uint pool_id_local = temp % pc.u_num_polygon_pools; + uint query_id_local = temp / pc.u_num_polygon_pools; + + if (query_id_local >= pc.u_num_queries) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + RenderQuery query = g_queries[query_id_local]; + TimestampedScene scene = g_scenes[query.scene_id]; + + if (pool_id_local >= scene.num_polygon_pools) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + TimestampedPolygonPool pool = g_polygon_pools[scene.polygon_pools_offset + pool_id_local]; + + int ts_idx = binary_search_timestamps( + scene.timestamps_buffer_offset + pool.timestamps_offset, + pool.num_timestamps, + query.timestamp_us + ); + + if (ts_idx < 0) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + // Get varray range for this timestamp + uint varray_start = 0u; + if (ts_idx > 0) { + varray_start = uint(g_int32[scene.int32_buffer_offset + pool.ts_varrays_ps_offset + uint(ts_idx) - 1u]); + } + uint varray_end = uint(g_int32[scene.int32_buffer_offset + pool.ts_varrays_ps_offset + uint(ts_idx)]); + uint num_varrays = varray_end - varray_start; + + bool force_zero_tasks = false; + if (varray_offset >= num_varrays) { + // Do not rely on an early EmitMeshTasksEXT(0, ...) here. Keep + // subsequent SSBO reads in-bounds by redirecting to a valid varray, + // then force the final emit count to zero. Without this, invalid + // workgroups for smaller pools can read the following pool's prefix + // sums/vertices and produce huge garbage triangles. + force_zero_tasks = true; + varray_offset = 0u; + } + + uint actual_varray_idx = varray_start + varray_offset; + + // Spatial culling: test per-element AABB against camera-centred view volume + if (pc.u_cull_radius_scale > 0.0 && pool.aabb_offset != 0u) { + float cull_r = g_camera_intrinsics[query.camera_id].depth_max * pc.u_cull_radius_scale; + CameraPose cull_pose = g_camera_poses[query_id_local]; + vec3 cam_pos = get_camera_world_pos(cull_pose); + vec3 view_min = cam_pos - vec3(cull_r); + vec3 view_max = cam_pos + vec3(cull_r); + uint ab = scene.float_buffer_offset + pool.aabb_offset + actual_varray_idx * 6u; + vec3 e_min = vec3(g_floats[ab], g_floats[ab+1u], g_floats[ab+2u]); + vec3 e_max = vec3(g_floats[ab+3u], g_floats[ab+4u], g_floats[ab+5u]); + if (!cull_aabb_overlap(e_min, e_max, view_min, view_max)) { + force_zero_tasks = true; + } + } + + // Get triangle range for this polygon + uint tri_start = 0u; + if (actual_varray_idx > 0u) { + tri_start = uint(g_int32[scene.int32_buffer_offset + pool.tri_ps_offset + actual_varray_idx - 1u]); + } + uint tri_end = uint(g_int32[scene.int32_buffer_offset + pool.tri_ps_offset + actual_varray_idx]); + uint total_tris = tri_end - tri_start; + + if (total_tris == 0u) { + force_zero_tasks = true; + } + + // Get vertex range + uint v_start = 0u; + if (actual_varray_idx > 0u) { + v_start = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + actual_varray_idx - 1u]); + } + uint v_end = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + actual_varray_idx]); + uint total_verts = v_end - v_start; + + // Compute max subdivision level (sample first few triangles) + FThetaCamera cam = g_camera_intrinsics[query.camera_id]; + CameraPose pose = g_camera_poses[query_id_local]; + + uint max_subdiv = 0u; + if (pc.u_tessellation_threshold > 0.0) { + uint base_v_idx = scene.vertex_buffer_offset + pool.vertices_offset + v_start; + uint base_t_idx = scene.triangle_buffer_offset + pool.triangles_offset + tri_start; + uint sample_count = min(total_tris, 8u); + + for (uint t = 0u; t < sample_count; t++) { + uvec3 tri = g_triangles[base_t_idx + t]; + Vertex v0 = g_vertices[base_v_idx + tri.x]; + Vertex v1 = g_vertices[base_v_idx + tri.y]; + Vertex v2 = g_vertices[base_v_idx + tri.z]; + + vec3 p0 = vec3(v0.x, v0.y, v0.z); + vec3 p1 = vec3(v1.x, v1.y, v1.z); + vec3 p2 = vec3(v2.x, v2.y, v2.z); + + max_subdiv = max(max_subdiv, compute_subdivision_level(p0, p1, pose, cam, pc.u_tessellation_threshold)); + max_subdiv = max(max_subdiv, compute_subdivision_level(p1, p2, pose, cam, pc.u_tessellation_threshold)); + max_subdiv = max(max_subdiv, compute_subdivision_level(p2, p0, pose, cam, pc.u_tessellation_threshold)); + } + max_subdiv = min(max_subdiv, 3u); // Allow up to level 3 + } + + // Compute chunks based on subdivision level (must match mesh shader constants) + const uint MAX_SHARED_VERTS = 30u; + uint num_chunks; + uint tris_per_chunk; + + if (max_subdiv == 0u && total_verts <= MAX_SHARED_VERTS) { + num_chunks = 1u; + } else { + if (max_subdiv == 0u) tris_per_chunk = 8u; + else if (max_subdiv == 1u) tris_per_chunk = 5u; + else if (max_subdiv == 2u) tris_per_chunk = 2u; + else tris_per_chunk = 1u; // Level 3: 1 tri per chunk + + num_chunks = (total_tris + tris_per_chunk - 1u) / tris_per_chunk; + num_chunks = max(num_chunks, 1u); + } + + _task_count = force_zero_tasks ? 0u : num_chunks; + + payload.query_id = query_id_local; + payload.pool_id = pool_id_local; + payload.varray_idx = actual_varray_idx; + payload.triangle_count = total_tris; + payload.vertex_count = total_verts; + payload.subdivision_level = max_subdiv; + payload.color = get_prim_color(pool.prim_type_id); + payload.is_bev = (query.camera_type_id == CAMERA_TYPE_BEV) ? 1.0 : 0.0; + EmitMeshTasksEXT(_task_count, 1, 1); +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.frag.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.frag.glsl new file mode 100644 index 000000000..11ecfa8d4 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.frag.glsl @@ -0,0 +1,62 @@ + +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_fragment_shader_barycentric : require +#extension GL_EXT_mesh_shader : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Per-primitive color block from mesh shader +layout(location = 0) perprimitiveEXT in PrimColorBlock { + vec3 color; + float is_bev; +} prim_in; + +layout(location = 0) out vec4 out_color; + +layout(early_fragment_tests) in; + + +IF_ZMODIFY(layout(location = 0) uniform float in_dummy;) + +void main() { + vec3 color = prim_in.color; + + // Apply distance-based fog (darken with distance) - disabled for BEV cameras + // gl_FragCoord.z is in [0, 1] where 0=near, 1=far + if (pc.u_fog_enabled > 0.5 && prim_in.is_bev < 0.5) { + float fog_factor = 1.0 - gl_FragCoord.z; // 1.0 at near, 0.0 at far + fog_factor = clamp(fog_factor, 0.0, 1.0); + color *= fog_factor; + } + + out_color = vec4(clamp(color, 0.0, 1.0), 1.0); + IF_ZMODIFY(gl_FragDepth = gl_FragCoord.z + in_dummy;) +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.mesh.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.mesh.glsl new file mode 100644 index 000000000..09e44cb76 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.mesh.glsl @@ -0,0 +1,1451 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_mesh_shader : require +#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Cap styles +const uint CAP_NONE = 0u; +const uint CAP_FLAT = 1u; +const uint CAP_ROUND = 2u; + +// Primitive type IDs (must match Python PRIM_* constants in ops.py) +const uint PRIM_ROAD_BOUNDARY = 0u; +const uint PRIM_LANE_LINE = 1u; // Legacy cyan lane line +const uint PRIM_CROSSWALK = 2u; +const uint PRIM_STATIC_OBSTACLE = 3u; // Legacy, avoid using +const uint PRIM_EGO_TRAJECTORY = 4u; +const uint PRIM_OBSTACLE = 5u; +const uint PRIM_EGO_OBSTACLE = 6u; +const uint PRIM_WAIT_LINE = 7u; +const uint PRIM_POLE = 8u; +const uint PRIM_ROAD_MARKING = 9u; +const uint PRIM_LANE_BOUNDARY = 10u; +const uint PRIM_TRAFFIC_LIGHT = 11u; +const uint PRIM_TRAFFIC_SIGN = 12u; +const uint PRIM_INTERSECTION = 13u; +const uint PRIM_ROAD_ISLAND = 14u; +const uint PRIM_BUFFER_ZONE = 15u; +// Lane line variants by color/style +const uint PRIM_LANE_LINE_WHITE_SOLID = 16u; +const uint PRIM_LANE_LINE_WHITE_DASHED = 17u; +const uint PRIM_LANE_LINE_YELLOW_SOLID = 18u; +const uint PRIM_LANE_LINE_YELLOW_DASHED = 19u; +// Dot primitives - each vertex is rendered as a circle +const uint PRIM_DOT_YELLOW = 20u; +const uint PRIM_DOT_WHITE = 21u; + +// Camera type IDs +const uint CAMERA_TYPE_REGULAR = 0u; +const uint CAMERA_TYPE_BEV = 1u; + +//============================================================================= +// Hardcoded Primitive Styles (matching wm-render colorscheme v3) +//============================================================================= + +// Colors (RGB normalized) - matching imaginaire4 v3 colorscheme +// Source: imaginaire4/imaginaire/auxiliary/world_scenario/color_scheme/config_color_hdmap.json +const vec3 COLOR_ROAD_BOUNDARY = vec3(253.0/255.0, 1.0/255.0, 232.0/255.0); // Magenta (253, 1, 232) +const vec3 COLOR_LANE_LINE = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (98, 183, 249) - "lanelines" (legacy) +const vec3 COLOR_CROSSWALK = vec3(139.0/255.0, 93.0/255.0, 255.0/255.0); // Purple (139, 93, 255) +const vec3 COLOR_STATIC_OBSTACLE = vec3(255.0/255.0, 100.0/255.0, 0.0/255.0); // Orange (legacy) +const vec3 COLOR_EGO_TRAJECTORY = vec3(0.0/255.0, 255.0/255.0, 0.0/255.0); // Green (0, 255, 0) +const vec3 COLOR_WAIT_LINE = vec3(108.0/255.0, 179.0/255.0, 59.0/255.0); // Yellow-green (108, 179, 59) +const vec3 COLOR_POLE = vec3(183.0/255.0, 69.0/255.0, 177.0/255.0); // Purple-magenta (183, 69, 177) +const vec3 COLOR_ROAD_MARKING = vec3(20.0/255.0, 254.0/255.0, 185.0/255.0); // Cyan-green (20, 254, 185) +const vec3 COLOR_LANE_BOUNDARY = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (same as lane line) +const vec3 COLOR_TRAFFIC_LIGHT = vec3(100.0/255.0, 100.0/255.0, 100.0/255.0); // Gray (100, 100, 100) +const vec3 COLOR_TRAFFIC_SIGN = vec3(8.0/255.0, 2.0/255.0, 255.0/255.0); // Blue (8, 2, 255) +const vec3 COLOR_INTERSECTION = vec3(80.0/255.0, 80.0/255.0, 120.0/255.0); // Dark blue-gray (approximated) +const vec3 COLOR_ROAD_ISLAND = vec3(60.0/255.0, 120.0/255.0, 60.0/255.0); // Dark green (approximated) +const vec3 COLOR_BUFFER_ZONE = vec3(120.0/255.0, 80.0/255.0, 80.0/255.0); // Dark red-brown (approximated) +// Lane line variants from config_color_geometry_laneline.json +const vec3 COLOR_LANE_LINE_WHITE = vec3(255.0/255.0, 255.0/255.0, 255.0/255.0); // White (255, 255, 255) +const vec3 COLOR_LANE_LINE_YELLOW = vec3(255.0/255.0, 255.0/255.0, 0.0/255.0); // Yellow (255, 255, 0) + +// Default polyline widths (pixels at reference resolution 1280x720) +const float DEFAULT_WIDTH_POLYLINE_REGULAR = 7.0; +const float DEFAULT_WIDTH_POLYLINE_BEV = 4.0; +const float DEFAULT_WIDTH_EGO_TRAJ_REGULAR = 12.0; +const float DEFAULT_WIDTH_EGO_TRAJ_BEV = 5.0; +const float DEFAULT_WIDTH_POLE_REGULAR = 5.0; // Poles are thinner (reference: 5 vs 12) +const float DEFAULT_WIDTH_POLE_BEV = 3.0; +const float DEFAULT_WIDTH_WIREFRAME = 2.0; + +// Configurable width uniforms (set from Python, or use defaults) + +// Compute depth-based scaling factor for line width +// z_ndc is in [-1, 1] where -1 is near, +1 is far +// Returns 1.0 at near, 0.0 at far (linear fade) +float get_depth_scale(vec4 clip) { + if (pc.u_depth_scaling < 0.5) return 1.0; // Disabled + float z_ndc = clip.z / clip.w; // Convert to NDC + float depth_scale = 1.0 - z_ndc; // Map [-1,1] to [1,0] + return clamp(depth_scale, 0.0, 1.0); +} + +// Color palette buffer (optional, configured from Python) +// Declared early so get_prim_color can use it; actual buffer layout defined later +layout(std430, binding = 10) readonly buffer ColorPaletteBufferEarly { + vec4 g_color_palette[]; +}; + +// Get default color for primitive type (hardcoded fallback) +vec3 get_default_prim_color(uint prim_type_id) { + if (prim_type_id == PRIM_ROAD_BOUNDARY) return COLOR_ROAD_BOUNDARY; + if (prim_type_id == PRIM_LANE_LINE) return COLOR_LANE_LINE; + if (prim_type_id == PRIM_CROSSWALK) return COLOR_CROSSWALK; + if (prim_type_id == PRIM_STATIC_OBSTACLE) return COLOR_STATIC_OBSTACLE; + if (prim_type_id == PRIM_EGO_TRAJECTORY) return COLOR_EGO_TRAJECTORY; + if (prim_type_id == PRIM_WAIT_LINE) return COLOR_WAIT_LINE; + if (prim_type_id == PRIM_POLE) return COLOR_POLE; + if (prim_type_id == PRIM_ROAD_MARKING) return COLOR_ROAD_MARKING; + if (prim_type_id == PRIM_LANE_BOUNDARY) return COLOR_LANE_BOUNDARY; + if (prim_type_id == PRIM_TRAFFIC_LIGHT) return COLOR_TRAFFIC_LIGHT; + if (prim_type_id == PRIM_TRAFFIC_SIGN) return COLOR_TRAFFIC_SIGN; + if (prim_type_id == PRIM_INTERSECTION) return COLOR_INTERSECTION; + if (prim_type_id == PRIM_ROAD_ISLAND) return COLOR_ROAD_ISLAND; + if (prim_type_id == PRIM_BUFFER_ZONE) return COLOR_BUFFER_ZONE; + // Lane line variants + if (prim_type_id == PRIM_LANE_LINE_WHITE_SOLID) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_WHITE_DASHED) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_SOLID) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_DASHED) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_YELLOW) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_WHITE) return COLOR_LANE_LINE_WHITE; + return vec3(1.0, 1.0, 1.0); // Default white for obstacles +} + +// Get color for primitive type (checks palette first, then falls back to defaults) +vec3 get_prim_color(uint prim_type_id) { + // If color palette is configured, check if this prim_type has a custom color + // Alpha < 0 means "use default", alpha >= 0 means "use this color" + if (pc.u_color_palette_size > 0 && prim_type_id < uint(pc.u_color_palette_size)) { + vec4 palette_color = g_color_palette[prim_type_id]; + if (palette_color.a >= 0.0) { + return palette_color.rgb; + } + } + // Fall back to hardcoded defaults + return get_default_prim_color(prim_type_id); +} + +// Check if primitive is a dot type (rendered as circles at each vertex) +bool is_dot_primitive(uint prim_type_id) { + return prim_type_id == PRIM_DOT_YELLOW || prim_type_id == PRIM_DOT_WHITE; +} + +// Get polyline width for primitive type and camera type (scaled by resolution) +float get_prim_width(uint prim_type_id, uint camera_type_id) { + bool is_bev = (camera_type_id == CAMERA_TYPE_BEV); + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + + float base_width; + if (prim_type_id == PRIM_EGO_TRAJECTORY) { + float default_w = is_bev ? DEFAULT_WIDTH_EGO_TRAJ_BEV : DEFAULT_WIDTH_EGO_TRAJ_REGULAR; + float custom_w = is_bev ? pc.u_width_ego_traj_bev : pc.u_width_ego_traj_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } else if (prim_type_id == PRIM_POLE) { + // Poles use thinner lines (reference: 5 pixels vs 12 for other polylines) + base_width = is_bev ? DEFAULT_WIDTH_POLE_BEV : DEFAULT_WIDTH_POLE_REGULAR; + } else { + float default_w = is_bev ? DEFAULT_WIDTH_POLYLINE_BEV : DEFAULT_WIDTH_POLYLINE_REGULAR; + float custom_w = is_bev ? pc.u_width_polyline_bev : pc.u_width_polyline_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } + return base_width * scale; +} + +// Get wireframe edge width (scaled by resolution) +float get_wireframe_width() { + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + float base_width = (pc.u_width_wireframe > 0.0) ? pc.u_width_wireframe : DEFAULT_WIDTH_WIREFRAME; + return base_width * scale; +} + +//============================================================================= +// Data Structures (must match C++ structs) +//============================================================================= + +// TimestampedPolylinePool (64 bytes) +struct TimestampedPolylinePool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint vertices_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4, _pad5, _pad6, _pad7; // Padding to 64 bytes +}; + +// TimestampedPolygonPool (64 bytes) +struct TimestampedPolygonPool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint num_triangles; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint tri_ps_offset; + uint vertices_offset; + uint triangles_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4; // Padding to 64 bytes (16 uints) +}; + +// CubePool (64 bytes) - used for obstacles, traffic lights, traffic signs, etc. +// Renamed from ObstaclePool but keeping struct name for backward compat +struct ObstaclePool { + uint num_cubes; // Was: num_obstacles + uint num_timestamps; + uint num_track_poses; + uint prim_type_id; // Semantic type for color lookup + uint timestamps_offset; // Global timestamps for this pool + uint cube_ts_ps_offset; // Per-cube track length prefix sum (was: obstacle_ts_ps_offset) + uint track_timestamps_offset; // Per-pose timestamps in float buffer (as 2x uint for int64) + uint translations_offset; // Per-pose translations (3 floats each) + uint quaternions_offset; // Per-pose quaternions (4 floats each) + uint scales_offset; // Per-cube scales (3 floats each) + uint colors_offset; // Per-cube colors (6 floats each) + uint render_flags; // CUBE_FLAG_* bits (e.g., CUBE_FLAG_WIREFRAME) + uint _pad2, _pad3, _pad4, _pad5; // 4 padding fields for 64 bytes total +}; + +// Cube render flags +const uint CUBE_FLAG_WIREFRAME = 1u; // Draw wireframe edges in addition to solid faces + +// TimestampedScene (128 bytes) +struct TimestampedScene { + uint num_polyline_pools; + uint polyline_pools_offset; + uint num_polygon_pools; + uint polygon_pools_offset; + uint num_cube_pools; // Was: has_obstacle_pool (0/1), now supports multiple + uint cube_pools_offset; // Was: obstacle_pool_offset + uint timestamps_buffer_offset; + uint int32_buffer_offset; + uint vertex_buffer_offset; + uint triangle_buffer_offset; + uint pose_buffer_offset; + uint float_buffer_offset; + uint _pad[20]; +}; + +// RenderQuery (16 bytes) +struct RenderQuery { + uint scene_id; + uint camera_id; + int64_t timestamp_us; + uint camera_type_id; // CAMERA_TYPE_REGULAR or CAMERA_TYPE_BEV + uint _pad1, _pad2, _pad3; // Padding to 32 bytes +}; + +// FThetaCamera (72 bytes) +struct FThetaCamera { + float cx, cy; + float img_w, img_h; + float poly0, poly1, poly2, poly3, poly4, poly5; + float max_ray_angle; + float max_distortion_val; + float max_distortion_dval; + float depth_max; + float ld_c, ld_d, ld_e, ld_f; +}; + +// CameraPose (64 bytes) +struct CameraPose { + mat4 world_to_camera; +}; + +// Vertex (16 bytes) +struct Vertex { + float x, y, z; + float _pad; +}; + +//============================================================================= +// Buffer Bindings +//============================================================================= + +// Global data buffers +layout(std430, binding = 0) readonly buffer TimestampsBuffer { + int64_t g_timestamps[]; +}; + +layout(std430, binding = 1) readonly buffer Int32Buffer { + int g_int32[]; +}; + +layout(std430, binding = 2) readonly buffer VertexBuffer { + Vertex g_vertices[]; +}; + +layout(std430, binding = 3) readonly buffer TriangleBuffer { + uvec3 g_triangles[]; +}; + +layout(std430, binding = 4) readonly buffer PoseBuffer { + CameraPose g_poses[]; +}; + +layout(std430, binding = 5) readonly buffer FloatBuffer { + float g_floats[]; +}; + +// Scene metadata +layout(std430, binding = 6) readonly buffer SceneBuffer { + TimestampedScene g_scenes[]; +}; + +layout(std430, binding = 7) readonly buffer PolylinePoolBuffer { + TimestampedPolylinePool g_polyline_pools[]; +}; + +layout(std430, binding = 8) readonly buffer PolygonPoolBuffer { + TimestampedPolygonPool g_polygon_pools[]; +}; + +layout(std430, binding = 9) readonly buffer ObstaclePoolBuffer { + ObstaclePool g_obstacle_pools[]; +}; + +// Camera buffers +layout(std430, binding = 11) readonly buffer CameraIntrinsicsBuffer { + FThetaCamera g_camera_intrinsics[]; +}; + +layout(std430, binding = 12) readonly buffer CameraPoseBuffer { + CameraPose g_camera_poses[]; // One per query (dynamic viewpoints) +}; + +// Query buffer +layout(std430, binding = 13) readonly buffer QueryBuffer { + RenderQuery g_queries[]; +}; + +// Uniforms +// Spatial culling: elements beyond depth_max * scale from the camera are +// discarded in the task shader. Scale > 1 gives headroom so nothing at +// the visible boundary pops in/out. Set to 0 to disable culling. + +//============================================================================= +// GPU Binary Search +// Returns index of last element <= target, or -1 if target < all elements +//============================================================================= + +int binary_search_timestamps(uint base_offset, uint count, int64_t target) { + if (count == 0u) return -1; + + int left = 0; + int right = int(count) - 1; + int result = -1; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t val = g_timestamps[base_offset + uint(mid)]; + + if (val <= target) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + + return result; +} + +//============================================================================= +// Quaternion Math for Track Interpolation +//============================================================================= + +// Quaternion dot product +float quat_dot(vec4 a, vec4 b) { + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +// Quaternion normalize +vec4 quat_normalize(vec4 q) { + float len = length(q); + return len > 1e-10 ? q / len : vec4(0.0, 0.0, 0.0, 1.0); +} + +// Quaternion spherical linear interpolation (slerp) +vec4 quat_slerp(vec4 q0, vec4 q1, float t) { + // Ensure shortest path + float d = quat_dot(q0, q1); + if (d < 0.0) { + q1 = -q1; + d = -d; + } + + // If quaternions are very close, use linear interpolation + if (d > 0.9995) { + return quat_normalize(mix(q0, q1, t)); + } + + // Spherical interpolation + float theta_0 = acos(clamp(d, -1.0, 1.0)); + float theta = theta_0 * t; + float sin_theta = sin(theta); + float sin_theta_0 = sin(theta_0); + + float s0 = cos(theta) - d * sin_theta / sin_theta_0; + float s1 = sin_theta / sin_theta_0; + + return quat_normalize(s0 * q0 + s1 * q1); +} + +// Convert quaternion (x, y, z, w) to 3x3 rotation matrix +// GLSL mat3 is column-major: mat3(col0, col1, col2) +mat3 quat_to_matrix(vec4 q) { + float x = q.x, y = q.y, z = q.z, w = q.w; + + float x2 = x + x, y2 = y + y, z2 = z + z; + float xx = x * x2, xy = x * y2, xz = x * z2; + float yy = y * y2, yz = y * z2, zz = z * z2; + float wx = w * x2, wy = w * y2, wz = w * z2; + + // Column 0: (R00, R10, R20), Column 1: (R01, R11, R21), Column 2: (R02, R12, R22) + return mat3( + 1.0 - (yy + zz), xy + wz, xz - wy, // Column 0 + xy - wz, 1.0 - (xx + zz), yz + wx, // Column 1 + xz + wy, yz - wx, 1.0 - (xx + yy) // Column 2 + ); +} + +// Build 4x4 transform from translation and quaternion (with scale) +mat4 build_transform(vec3 translation, vec4 quaternion, vec3 scale) { + mat3 rot = quat_to_matrix(quaternion); + + // Apply scale to each column of rotation matrix + mat4 result = mat4( + vec4(rot[0] * scale.x, 0.0), + vec4(rot[1] * scale.y, 0.0), + vec4(rot[2] * scale.z, 0.0), + vec4(translation, 1.0) + ); + + return result; +} + +// Binary search for track interpolation (returns index where t0 <= target < t1) +// Returns -1 if target is outside the track range +int binary_search_track(uint base_offset, uint count, int64_t target) { + if (count < 2u) return -1; // Need at least 2 points for interpolation + + int64_t first_ts = g_timestamps[base_offset]; + int64_t last_ts = g_timestamps[base_offset + count - 1u]; + + // Check bounds + if (target < first_ts || target > last_ts) return -1; + + int left = 0; + int right = int(count) - 2; // Max valid index for interpolation start + int result = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[base_offset + uint(mid)]; + int64_t t1 = g_timestamps[base_offset + uint(mid) + 1u]; + + if (t0 <= target && target <= t1) { + return mid; + } else if (target < t0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + + return -1; // Should not reach here for valid input +} + +//============================================================================= +// Spatial Culling Helpers +//============================================================================= + +// AABB-AABB overlap test +bool cull_aabb_overlap(vec3 a_min, vec3 a_max, vec3 b_min, vec3 b_max) { + return all(lessThanEqual(a_min, b_max)) && all(greaterThanEqual(a_max, b_min)); +} + +// Sphere-AABB overlap test +bool cull_sphere_aabb_overlap(vec3 center, float radius, vec3 b_min, vec3 b_max) { + vec3 nearest = clamp(center, b_min, b_max); + vec3 d = center - nearest; + return dot(d, d) <= radius * radius; +} + +// Extract camera world position from view pose +vec3 get_camera_world_pos(CameraPose pose) { + mat3 R = mat3(pose.world_to_camera); + return -transpose(R) * pose.world_to_camera[3].xyz; +} + +//============================================================================= +// F-theta Projection +//============================================================================= + +vec3 rotate_rodrigues(vec3 v, vec3 r) { + float theta = length(r); + if (theta < 1e-8) return v; + vec3 k = r / theta; + float c = cos(theta); + float s = sin(theta); + return v * c + cross(k, v) * s + k * dot(k, v) * (1.0 - c); +} + +// F-theta projection: world point -> NDC +// Supports >180° FOV fisheye cameras where points can have negative z (behind camera plane) +vec4 ftheta_project(vec3 world_pos, CameraPose pose, FThetaCamera cam) { + vec3 cam_pt = (pose.world_to_camera * vec4(world_pos, 1.0)).xyz; + float depth = cam_pt.z; + + float ray_norm = length(cam_pt); + + // Handle points at camera origin + if (ray_norm < 1e-6) { + return vec4(0.0, 0.0, 0.0, 1.0); + } + + float half_pi = 1.5707963; // π/2 + + // For cameras with FOV <= 180° (max_ray_angle <= π/2), points behind camera should be clipped + // Use pseudo-pinhole projection to push them far away in the correct direction + if (cam.max_ray_angle <= half_pi && depth < 0.001) { + float pseudo_focal = cam.poly1; + float x_clip = cam_pt.x * pseudo_focal / (cam.img_w * 0.5); + float y_clip = -cam_pt.y * pseudo_focal / (cam.img_h * 0.5); + return vec4(x_clip * 10.0, y_clip * 10.0, 1.0, 1.0); // Scale by 10 to push far outside + } + + float xy_norm = length(cam_pt.xy); + float cos_alpha = clamp(cam_pt.z / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); // alpha in [0, π] + + // Apply polynomial projection (with linear extrapolation beyond max_ray_angle) + float a2 = alpha * alpha; + float a3 = a2 * alpha; + float a4 = a2 * a2; + float a5 = a4 * alpha; + + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * a3 + cam.poly4 * a4 + cam.poly5 * a5; + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt.xy; + + vec2 pixel_dist; + pixel_dist.x = cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y; + pixel_dist.y = cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y; + + vec2 pixel = pixel_dist + vec2(cam.cx, cam.cy); + + float x_ndc = 2.0 * pixel.x / cam.img_w - 1.0; + float y_ndc = 1.0 - 2.0 * pixel.y / cam.img_h; + + // For z-buffer depth mapping: + // - Narrow FOV (<=180°): use signed depth (cam_pt.z) + // - Wide FOV (>180°): use ray_norm for front-camera vertices (unchanged), + // but push behind-camera vertices to depth_max so they never occlude + // forward geometry. ray_norm alone can't distinguish front from behind. + float z_value; + if (cam.max_ray_angle > half_pi) { + z_value = (depth >= 0.0) ? ray_norm : cam.depth_max; + } else { + z_value = depth; + } + float z_ndc = clamp(z_value / cam.depth_max, 0.0, 1.0); + + return vec4(x_ndc, y_ndc, z_ndc, 1.0); +} + +// Inline version that takes mat4 directly +float estimate_edge_distortion_pixels_mat4(vec3 v0, vec3 v1, mat4 world_to_cam, FThetaCamera cam) { + // Transform to camera space + vec3 cam_pt0 = (world_to_cam * vec4(v0, 1.0)).xyz; + vec3 cam_pt1 = (world_to_cam * vec4(v1, 1.0)).xyz; + vec3 mid_world = (v0 + v1) * 0.5; + vec3 cam_pt_mid = (world_to_cam * vec4(mid_world, 1.0)).xyz; + + // Just clamp depths to avoid division issues + + // For segments in front of camera, compute f-theta projection error directly + // Use depth-clamped projection to handle near-plane cases + float depth0 = max(cam_pt0.z, 0.001); + float depth1 = max(cam_pt1.z, 0.001); + float depth_mid = max(cam_pt_mid.z, 0.001); + + // Compute f-theta projection for each point + // We inline the projection to avoid struct-passing issues + vec2 pixel0, pixel1, pixel_mid; + { + float xy_norm = length(cam_pt0.xy); + float ray_norm = length(vec3(cam_pt0.xy, depth0)) + 1e-10; + float cos_alpha = clamp(depth0 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt0.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel0 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt1.xy); + float ray_norm = length(vec3(cam_pt1.xy, depth1)) + 1e-10; + float cos_alpha = clamp(depth1 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt1.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel1 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt_mid.xy); + float ray_norm = length(vec3(cam_pt_mid.xy, depth_mid)) + 1e-10; + float cos_alpha = clamp(depth_mid / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt_mid.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel_mid = pixel_dist + vec2(cam.cx, cam.cy); + } + + // Compute error: distance from projected midpoint to linear interpolation + vec2 linear_pixel_mid = (pixel0 + pixel1) * 0.5; + float error_pixels = length(pixel_mid - linear_pixel_mid); + + // Clamp to reasonable range to handle edge cases + return clamp(error_pixels, 0.0, 10000.0); +} + +uint compute_subdivision_level(vec3 v0, vec3 v1, CameraPose pose, FThetaCamera cam, float threshold_pixels) { + float error = estimate_edge_distortion_pixels_mat4(v0, v1, pose.world_to_camera, cam); + + if (error < threshold_pixels) return 0u; + if (error < threshold_pixels * 2.0) return 1u; + if (error < threshold_pixels * 4.0) return 2u; + return 3u; +} + +//============================================================================= +// Barycentric Subdivision Utilities (shared with polygon/cube) +//============================================================================= + +uint bary_vertex_count(uint level) { + // Vertices = (n+1)(n+2)/2 where n = 2^level + if (level == 0u) return 3u; + if (level == 1u) return 6u; + if (level == 2u) return 15u; + return 45u; // level 3 +} + +uint bary_triangle_count(uint level) { + // Triangles = 4^level + if (level == 0u) return 1u; + if (level == 1u) return 4u; + if (level == 2u) return 16u; + return 64u; // level 3 +} + +vec2 bary_vertex_uv(uint vertex_idx, uint level) { + if (level == 0u) { + if (vertex_idx == 0u) return vec2(0.0, 0.0); + if (vertex_idx == 1u) return vec2(1.0, 0.0); + return vec2(0.0, 1.0); + } else if (level == 1u) { + vec2 uvs[6]; + uvs[0] = vec2(0.0, 0.0); + uvs[1] = vec2(1.0, 0.0); + uvs[2] = vec2(0.0, 1.0); + uvs[3] = vec2(0.5, 0.0); + uvs[4] = vec2(0.5, 0.5); + uvs[5] = vec2(0.0, 0.5); + return uvs[vertex_idx]; + } else if (level == 2u) { + uint row, col; + if (vertex_idx < 5u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 9u) { row = 1u; col = vertex_idx - 5u; } + else if (vertex_idx < 12u) { row = 2u; col = vertex_idx - 9u; } + else if (vertex_idx < 14u) { row = 3u; col = vertex_idx - 12u; } + else { row = 4u; col = 0u; } + return vec2(float(col) / 4.0, float(row) / 4.0); + } else { + // Level 3: 9 rows (0-8), row r has (9-r) vertices + uint row, col; + if (vertex_idx < 9u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 17u) { row = 1u; col = vertex_idx - 9u; } + else if (vertex_idx < 24u) { row = 2u; col = vertex_idx - 17u; } + else if (vertex_idx < 30u) { row = 3u; col = vertex_idx - 24u; } + else if (vertex_idx < 35u) { row = 4u; col = vertex_idx - 30u; } + else if (vertex_idx < 39u) { row = 5u; col = vertex_idx - 35u; } + else if (vertex_idx < 42u) { row = 6u; col = vertex_idx - 39u; } + else if (vertex_idx < 44u) { row = 7u; col = vertex_idx - 42u; } + else { row = 8u; col = 0u; } + return vec2(float(col) / 8.0, float(row) / 8.0); + } +} + +vec3 bary_interpolate(vec3 v0, vec3 v1, vec3 v2, vec2 uv) { + float w = 1.0 - uv.x - uv.y; + return v0 * w + v1 * uv.x + v2 * uv.y; +} + +uvec3 bary_triangle_indices(uint tri_idx, uint level) { + if (level == 0u) { + return uvec3(0u, 1u, 2u); + } else if (level == 1u) { + uvec3 tris[4]; + tris[0] = uvec3(0u, 3u, 5u); + tris[1] = uvec3(3u, 1u, 4u); + tris[2] = uvec3(5u, 4u, 2u); + tris[3] = uvec3(3u, 4u, 5u); + return tris[tri_idx]; + } else if (level == 2u) { + uint row_start[5] = uint[5](0u, 5u, 9u, 12u, 14u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + if (t < 7u) { + row = 0u; + if (t < 4u) { col = t; is_down = false; } + else { col = t - 4u; is_down = true; } + } else if (t < 12u) { + row = 1u; + uint lt = t - 7u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 15u) { + row = 2u; + uint lt = t - 12u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 3u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } else { + // Level 3: row_start for 9 rows + uint row_start[9] = uint[9](0u, 9u, 17u, 24u, 30u, 35u, 39u, 42u, 44u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + // Row 0: 8 up + 7 down = 15, Row 1: 7 up + 6 down = 13, etc. + if (t < 15u) { + row = 0u; + if (t < 8u) { col = t; is_down = false; } + else { col = t - 8u; is_down = true; } + } else if (t < 28u) { + row = 1u; uint lt = t - 15u; + if (lt < 7u) { col = lt; is_down = false; } + else { col = lt - 7u; is_down = true; } + } else if (t < 39u) { + row = 2u; uint lt = t - 28u; + if (lt < 6u) { col = lt; is_down = false; } + else { col = lt - 6u; is_down = true; } + } else if (t < 48u) { + row = 3u; uint lt = t - 39u; + if (lt < 5u) { col = lt; is_down = false; } + else { col = lt - 5u; is_down = true; } + } else if (t < 55u) { + row = 4u; uint lt = t - 48u; + if (lt < 4u) { col = lt; is_down = false; } + else { col = lt - 4u; is_down = true; } + } else if (t < 60u) { + row = 5u; uint lt = t - 55u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 63u) { + row = 6u; uint lt = t - 60u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 7u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } +} + + +layout(local_size_x = 32) in; +layout(triangles, max_vertices = 128, max_primitives = 126) out; + +// Task payload from task shader +struct PolylineTaskPayload { + uint query_id; + uint pool_id; + uint varray_idx; + uint total_points; + float width; + vec3 color; + uint cap_style; + float is_bev; +}; +taskPayloadSharedEXT PolylineTaskPayload payload; + +out gl_MeshPerVertexNV { + vec4 gl_Position; +} gl_MeshVerticesEXT[]; + +perprimitiveEXT out gl_MeshPerPrimitiveNV { + int gl_Layer; +} gl_MeshPrimitivesEXT[]; + +// Per-primitive color in a named block with explicit location +layout(location = 0) perprimitiveEXT out PrimColorBlock { + vec3 color; + float is_bev; // 1.0 for BEV cameras (disables fog), 0.0 otherwise +} prim_out[]; + +// Shared memory for subdivided projected points +// With 128 max vertices, we can have up to 64 effective points (2 verts each) +// Reserve indices 62, 63 for overlap vertices +shared vec4 s_clip_pos[64]; +shared vec2 s_screen_pos[64]; +shared vec3 s_world_pos[64]; + +// Shared memory indices for special values +const uint OVERLAP_BEFORE_IDX = 62u; // Overlap vertex before chunk +const uint OVERLAP_AFTER_IDX = 63u; // Overlap vertex after chunk +const uint COUNTER_IDX = 61u; // Counter and flags storage + +void main() { + uint _prim_count = 0u; + // Get chunk ID from mesh workgroup index + uint chunk_id = gl_WorkGroupID.x; + uint tid = gl_LocalInvocationID.x; + + // Read from task payload + uint total_pts = payload.total_points; + + // Load scene and pool info + RenderQuery query = g_queries[payload.query_id]; + TimestampedScene scene = g_scenes[query.scene_id]; + TimestampedPolylinePool pool = g_polyline_pools[scene.polyline_pools_offset + payload.pool_id]; + FThetaCamera cam = g_camera_intrinsics[query.camera_id]; + CameraPose pose = g_camera_poses[payload.query_id]; + uint cap_style_local = payload.cap_style; + + // Handle dot primitives - render each vertex as a circle + if (is_dot_primitive(pool.prim_type_id)) { + // Dot mode: each vertex is a separate circle + const uint DOTS_PER_CHUNK = 7u; + uint dot_start = chunk_id * DOTS_PER_CHUNK; + uint dot_end = min(dot_start + DOTS_PER_CHUNK, total_pts); + uint num_dots = dot_end - dot_start; + + if (num_dots == 0u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + // Get vertex base for this polyline + uint v_start_base = 0u; + if (payload.varray_idx > 0u) { + v_start_base = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + payload.varray_idx - 1u]); + } + uint base_v_idx = scene.vertex_buffer_offset + pool.vertices_offset + v_start_base; + + // Dot radius = same as regular line half-width + float half_width = payload.width * 0.5; + + // Each dot: 9 vertices (center + 8 ring), 8 triangles + uint total_verts = num_dots * 9u; + uint total_tris = num_dots * 8u; + + _prim_count = total_tris; SetMeshOutputsEXT(total_verts, _prim_count); + + // Generate dots (only thread 0 for simplicity, could parallelize) + if (tid == 0u) { + for (uint d = 0u; d < num_dots; d++) { + uint global_dot = dot_start + d; + uint vi = base_v_idx + global_dot; + Vertex vx = g_vertices[vi]; + vec3 world_pos = vec3(vx.x, vx.y, vx.z); + + // Project center + vec4 center_clip = ftheta_project(world_pos, pose, cam); + float w = center_clip.w; + if (abs(w) < 1e-6) w = 1e-6; + vec2 center_screen = vec2( + (center_clip.x / w * 0.5 + 0.5) * cam.img_w, + (0.5 - center_clip.y / w * 0.5) * cam.img_h + ); + + // Emit center vertex + uint base_vert = d * 9u; + gl_MeshVerticesEXT[base_vert].gl_Position = center_clip; + + // Apply depth-based radius scaling for dots + float dot_depth_scale = get_depth_scale(center_clip); + float scaled_half_width = half_width * dot_depth_scale; + + // Emit 8 ring vertices (octagon for circle approximation) + for (uint i = 0u; i < 8u; i++) { + float angle = float(i) * 0.785398; // 2*PI/8 + vec2 offset = vec2(cos(angle), sin(angle)) * scaled_half_width; + vec2 ring_screen = center_screen + offset; + + // Convert back to clip space + vec4 ring_clip; + ring_clip.x = ((ring_screen.x / cam.img_w) * 2.0 - 1.0) * w; + ring_clip.y = ((0.5 - ring_screen.y / cam.img_h) * 2.0) * w; + ring_clip.z = center_clip.z; + ring_clip.w = w; + + gl_MeshVerticesEXT[base_vert + 1u + i].gl_Position = ring_clip; + } + + // Emit 8 triangles (center -> ring[i] -> ring[i+1]) + uint base_tri = d * 8u; + for (uint i = 0u; i < 8u; i++) { + uint next_i = (i + 1u) % 8u; + gl_PrimitiveTriangleIndicesEXT[base_tri + i] = uvec3(base_vert, base_vert + 1u + i, base_vert + 1u + next_i); + gl_MeshPrimitivesEXT[base_tri + i].gl_Layer = int(payload.query_id); + prim_out[base_tri + i].color = payload.color; + prim_out[base_tri + i].is_bev = payload.is_bev; + } + } + } + return; + } + + // Regular polyline mode + // Calculate chunk range in original segment space + // 4 segments per chunk with overlap vertices for seamless miter joins (matching task shader) + const uint MAX_SEGMENTS_PER_CHUNK = 3u; + uint num_segments = total_pts - 1u; + uint seg_start = chunk_id * MAX_SEGMENTS_PER_CHUNK; + uint seg_end = min(seg_start + MAX_SEGMENTS_PER_CHUNK, num_segments); + uint num_segs_in_chunk = seg_end - seg_start; + + bool is_first_chunk = (chunk_id == 0u); + bool is_last_chunk = (seg_end >= num_segments); + + if (num_segs_in_chunk == 0u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + float half_width = payload.width * 0.5; + + // Get vertex start for this polyline + uint v_start = 0u; + if (payload.varray_idx > 0u) { + v_start = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + payload.varray_idx - 1u]); + } + uint base_v_idx = scene.vertex_buffer_offset + pool.vertices_offset + v_start; + + // Phase 1: Compute subdivision per segment and generate subdivided points + // Also load overlap vertices for chunk boundary miter calculation + uint eff_point_count = 0u; + bool has_overlap_before = false; + bool has_overlap_after = false; + + if (tid == 0u) { + // Load overlap vertex BEFORE this chunk (for first point miter) + if (!is_first_chunk && seg_start > 0u) { + uint vi_before = base_v_idx + seg_start - 1u; + Vertex vx_before = g_vertices[vi_before]; + s_world_pos[OVERLAP_BEFORE_IDX] = vec3(vx_before.x, vx_before.y, vx_before.z); + has_overlap_before = true; + } + + // Load overlap vertex AFTER this chunk (for last point miter) + if (!is_last_chunk && seg_end < num_segments) { + uint vi_after = base_v_idx + seg_end + 1u; + Vertex vx_after = g_vertices[vi_after]; + s_world_pos[OVERLAP_AFTER_IDX] = vec3(vx_after.x, vx_after.y, vx_after.z); + has_overlap_after = true; + } + + // Generate body points for this chunk's segments + for (uint seg_idx = 0u; seg_idx < num_segs_in_chunk; seg_idx++) { + uint global_seg = seg_start + seg_idx; + uint vi0 = base_v_idx + global_seg; + uint vi1 = base_v_idx + global_seg + 1u; + Vertex vx0 = g_vertices[vi0]; + Vertex vx1 = g_vertices[vi1]; + vec3 p0 = vec3(vx0.x, vx0.y, vx0.z); + vec3 p1 = vec3(vx1.x, vx1.y, vx1.z); + + // Compute distortion error for this segment + float error = estimate_edge_distortion_pixels_mat4(p0, p1, pose.world_to_camera, cam); + + // Determine subdivision level based on error threshold + // Max level 4 = 16 subsegments, 3 segs * 16 = 48 subsegments = 49 points + uint subdiv_level = 0u; + float tess_thresh = pc.u_tessellation_threshold; + if (tess_thresh > 0.0 && error > tess_thresh) subdiv_level = 1u; + if (tess_thresh > 0.0 && error > tess_thresh * 4.0) subdiv_level = 2u; + if (tess_thresh > 0.0 && error > tess_thresh * 16.0) subdiv_level = 3u; + if (tess_thresh > 0.0 && error > tess_thresh * 64.0) subdiv_level = 4u; + subdiv_level = min(subdiv_level, pc.u_max_tessellation_polyline); + + uint num_subsegments = 1u << subdiv_level; + + // First point: only if this is the first segment in chunk + if (seg_idx == 0u) { + s_world_pos[eff_point_count] = p0; + eff_point_count++; + } + + // Interior and end points + for (uint sub_i = 1u; sub_i <= num_subsegments; sub_i++) { + float t = float(sub_i) / float(num_subsegments); + vec3 world_pos = mix(p0, p1, t); + s_world_pos[eff_point_count] = world_pos; + eff_point_count++; + + if (eff_point_count >= 50u) break; // 49 segments max = 98 verts + caps < 128 + } + + if (eff_point_count >= 50u) break; + } + + // Store counts and flags via shared memory at COUNTER_IDX + s_clip_pos[COUNTER_IDX].x = float(eff_point_count); + s_clip_pos[COUNTER_IDX].y = has_overlap_before ? 1.0 : 0.0; + s_clip_pos[COUNTER_IDX].z = has_overlap_after ? 1.0 : 0.0; + } + + barrier(); + + uint num_eff_points = uint(s_clip_pos[COUNTER_IDX].x); + bool use_overlap_before = (s_clip_pos[COUNTER_IDX].y > 0.5); + bool use_overlap_after = (s_clip_pos[COUNTER_IDX].z > 0.5); + + // 128 verts / 2 verts per point = 64 points max, minus caps = ~60 points + // Use 50 for safety margin with overlap vertices + num_eff_points = min(num_eff_points, 50u); + + if (num_eff_points < 2u) { + _prim_count = 0u; SetMeshOutputsEXT(0u, _prim_count); + return; + } + + // Phase 2: Project all points - pass raw values to GPU, no clamping + // Loop to handle more points than threads (33 points, 32 threads) + for (uint pt = tid; pt < num_eff_points; pt += 32u) { + vec3 world_pos = s_world_pos[pt]; + vec4 clip = ftheta_project(world_pos, pose, cam); + s_clip_pos[pt] = clip; + + // Screen position for direction calculation + float w = clip.w; + if (abs(w) < 1e-6) w = 1e-6; // Only prevent division by zero + s_screen_pos[pt] = vec2( + (clip.x / w * 0.5 + 0.5) * cam.img_w, + (0.5 - clip.y / w * 0.5) * cam.img_h + ); + } + + barrier(); + + // SHARED MITER VERTICES: 2 vertices per point (left, right) + // Segment i uses vertices from points i and i+1 (shared at joints) + // No joint triangles needed since vertices are shared + uint num_eff_segs = num_eff_points - 1u; + + // Caps: 4-triangle semicircles for round line ends and to hide chunk seams + // Each cap: 4 new vertices (center + 3 arc points), 4 triangles + // Draw caps at ALL chunk boundaries to hide gaps between chunks + bool draw_start_cap = true; // Always draw start cap (for polyline start or chunk seam) + bool draw_end_cap = true; // Always draw end cap (for polyline end or chunk seam) + uint num_cap_verts = (draw_start_cap ? 4u : 0u) + (draw_end_cap ? 4u : 0u); + uint num_cap_tris = (draw_start_cap ? 4u : 0u) + (draw_end_cap ? 4u : 0u); + + // Vertex layout: + // [0, 2*num_eff_points-1]: point vertices (left, right per point) + // [2*num_eff_points, ...]: cap vertices (if any) + uint point_verts_end = num_eff_points * 2u; + uint start_cap_base = point_verts_end; // center, arc1, arc2, arc3 + uint end_cap_base = start_cap_base + (draw_start_cap ? 4u : 0u); + + uint num_verts = point_verts_end + num_cap_verts; + uint num_tris = num_eff_segs * 2u + num_cap_tris; + + // With 3 segs × level 4 = 49 points = 48 segs × 2 + 8 caps = 104 tris max + _prim_count = min(num_tris, 120u); SetMeshOutputsEXT(num_verts, _prim_count); + + // Phase 3: Generate point vertices (2 per point) WITH MITER JOINS + // Point i: vertices [2*i, 2*i+1] = [left, right] + // Vertices are shared between adjacent segments + // Loop to handle more points than threads + for (uint pt = tid; pt < num_eff_points; pt += 32u) { + vec4 clip = s_clip_pos[pt]; + vec2 screen = s_screen_pos[pt]; + + // For miter direction calculation, we need stable screen positions + // If an adjacent point has bad w (off-screen), use binary search to find + // a closer point with good w for direction calculation + float w_min = 1.0; + + // Get directions to adjacent points for miter calculation in SCREEN SPACE + vec2 dir_prev = vec2(0.0); + vec2 dir_next = vec2(0.0); + bool has_prev = (pt > 0u); + bool has_next = (pt < num_eff_points - 1u); + + vec2 screen_for_dir = screen; + vec4 clip_curr = clip; + + // If current point has bad w, clamp it for direction calculation + if (clip_curr.w < w_min && pt > 0u && s_clip_pos[pt - 1u].w >= w_min) { + // Binary search toward prev point to find good w + vec3 good = s_world_pos[pt - 1u]; + vec3 bad = s_world_pos[pt]; + for (int iter = 0; iter < 5; iter++) { + vec3 mid = (good + bad) * 0.5; + vec4 mid_clip = ftheta_project(mid, pose, cam); + if (mid_clip.w >= w_min) good = mid; else bad = mid; + } + vec4 clamped = ftheta_project(good, pose, cam); + float w_c = max(clamped.w, 0.001); + screen_for_dir = vec2((clamped.x / w_c * 0.5 + 0.5) * cam.img_w, + (0.5 - clamped.y / w_c * 0.5) * cam.img_h); + } else if (clip_curr.w < w_min && pt < num_eff_points - 1u && s_clip_pos[pt + 1u].w >= w_min) { + // Binary search toward next point + vec3 good = s_world_pos[pt + 1u]; + vec3 bad = s_world_pos[pt]; + for (int iter = 0; iter < 5; iter++) { + vec3 mid = (good + bad) * 0.5; + vec4 mid_clip = ftheta_project(mid, pose, cam); + if (mid_clip.w >= w_min) good = mid; else bad = mid; + } + vec4 clamped = ftheta_project(good, pose, cam); + float w_c = max(clamped.w, 0.001); + screen_for_dir = vec2((clamped.x / w_c * 0.5 + 0.5) * cam.img_w, + (0.5 - clamped.y / w_c * 0.5) * cam.img_h); + } + + if (has_prev) { + vec2 screen_prev = s_screen_pos[pt - 1u]; + // If prev point has bad w, use clamped position for direction + if (s_clip_pos[pt - 1u].w < w_min && clip_curr.w >= w_min) { + vec3 good = s_world_pos[pt]; + vec3 bad = s_world_pos[pt - 1u]; + for (int iter = 0; iter < 5; iter++) { + vec3 mid = (good + bad) * 0.5; + vec4 mid_clip = ftheta_project(mid, pose, cam); + if (mid_clip.w >= w_min) good = mid; else bad = mid; + } + vec4 clamped = ftheta_project(good, pose, cam); + float w_c = max(clamped.w, 0.001); + screen_prev = vec2((clamped.x / w_c * 0.5 + 0.5) * cam.img_w, + (0.5 - clamped.y / w_c * 0.5) * cam.img_h); + } + vec2 d = screen_for_dir - screen_prev; + float len = length(d); + if (len > 0.001) dir_prev = d / len; + } + if (has_next) { + vec2 screen_next = s_screen_pos[pt + 1u]; + // If next point has bad w, use clamped position for direction + if (s_clip_pos[pt + 1u].w < w_min && clip_curr.w >= w_min) { + vec3 good = s_world_pos[pt]; + vec3 bad = s_world_pos[pt + 1u]; + for (int iter = 0; iter < 5; iter++) { + vec3 mid = (good + bad) * 0.5; + vec4 mid_clip = ftheta_project(mid, pose, cam); + if (mid_clip.w >= w_min) good = mid; else bad = mid; + } + vec4 clamped = ftheta_project(good, pose, cam); + float w_c = max(clamped.w, 0.001); + screen_next = vec2((clamped.x / w_c * 0.5 + 0.5) * cam.img_w, + (0.5 - clamped.y / w_c * 0.5) * cam.img_h); + } + vec2 d = screen_next - screen_for_dir; + float len = length(d); + if (len > 0.001) dir_next = d / len; + } + + // Compute miter direction and scale in screen space + vec2 miter; + float miter_scale = 1.0; + + if (has_prev && has_next && length(dir_prev) > 0.001 && length(dir_next) > 0.001) { + // Interior point: average perpendiculars + vec2 perp_prev = vec2(-dir_prev.y, dir_prev.x); + vec2 perp_next = vec2(-dir_next.y, dir_next.x); + vec2 miter_sum = perp_prev + perp_next; + float miter_len = length(miter_sum); + if (miter_len > 0.001) { + miter = miter_sum / miter_len; + float cos_half = dot(miter, perp_next); + miter_scale = (cos_half > 0.5) ? (1.0 / cos_half) : 2.0; + } else { + // Nearly 180° turn, use either perpendicular + miter = perp_next; + } + } else if (has_next && length(dir_next) > 0.001) { + // First point: use next segment's perpendicular + miter = vec2(-dir_next.y, dir_next.x); + } else if (has_prev && length(dir_prev) > 0.001) { + // Last point: use prev segment's perpendicular + miter = vec2(-dir_prev.y, dir_prev.x); + } else { + // Degenerate case + miter = vec2(1.0, 0.0); + } + + // Compute offset: screen-space miter direction, scaled to clip space + // Apply distance-based width scaling (thinner lines in distance) + float depth_scale = get_depth_scale(clip); + float scaled_half_width = half_width * depth_scale; + + float off_x = miter.x * scaled_half_width * miter_scale * 2.0 / cam.img_w * clip.w; + float off_y = -miter.y * scaled_half_width * miter_scale * 2.0 / cam.img_h * clip.w; + + uint base = pt * 2u; + gl_MeshVerticesEXT[base].gl_Position = vec4(clip.x - off_x, clip.y - off_y, clip.z, clip.w); + gl_MeshVerticesEXT[base + 1u].gl_Position = vec4(clip.x + off_x, clip.y + off_y, clip.z, clip.w); + } + + // Generate cap vertices (first thread only) + // Cap is a 4-triangle semicircle fan from center through arc points + // Arc goes from right edge, around the back, to left edge + if (tid == 0u) { + // Start cap: at first point, semicircle facing backward (opposite to line direction) + if (draw_start_cap && num_eff_points >= 2u) { + vec4 clip0 = s_clip_pos[0u]; + vec2 screen0 = s_screen_pos[0u]; + vec2 screen1 = s_screen_pos[1u]; + + // Line direction and perpendicular + vec2 line_dir = normalize(screen1 - screen0); + vec2 perp = vec2(-line_dir.y, line_dir.x); + + // Cap center is at the first point (no offset) + gl_MeshVerticesEXT[start_cap_base].gl_Position = clip0; + + // Arc points at 45°, 90°, 135° from right to left (going backward) + // right = +perp, backward = -line_dir, left = -perp + // 45°: mix of +perp and -line_dir + // 90°: pure -line_dir + // 135°: mix of -perp and -line_dir + float angles[3] = float[3](0.7854, 1.5708, 2.3562); // 45°, 90°, 135° in radians + + // Apply depth-based width scaling for cap + float cap0_depth_scale = get_depth_scale(clip0); + float cap0_scaled_half_width = half_width * cap0_depth_scale; + + for (int i = 0; i < 3; i++) { + float a = angles[i]; + // Direction: rotate from +perp toward -line_dir + vec2 arc_dir = cos(a) * perp + sin(a) * (-line_dir); + + float arc_off_x = arc_dir.x * cap0_scaled_half_width * 2.0 / cam.img_w * clip0.w; + float arc_off_y = -arc_dir.y * cap0_scaled_half_width * 2.0 / cam.img_h * clip0.w; + + gl_MeshVerticesEXT[start_cap_base + 1u + uint(i)].gl_Position = + vec4(clip0.x + arc_off_x, clip0.y + arc_off_y, clip0.z, clip0.w); + } + } + + // End cap: at last point, semicircle facing forward (in line direction) + if (draw_end_cap && num_eff_points >= 2u) { + uint last_pt = num_eff_points - 1u; + vec4 clipN = s_clip_pos[last_pt]; + vec2 screenN = s_screen_pos[last_pt]; + vec2 screenN1 = s_screen_pos[last_pt - 1u]; + + // Line direction (from second-to-last toward last) + vec2 line_dir = normalize(screenN - screenN1); + vec2 perp = vec2(-line_dir.y, line_dir.x); + + // Cap center is at the last point + gl_MeshVerticesEXT[end_cap_base].gl_Position = clipN; + + // Arc points at 45°, 90°, 135° from left to right (going forward) + // left = -perp, forward = +line_dir, right = +perp + float angles[3] = float[3](0.7854, 1.5708, 2.3562); + + // Apply depth-based width scaling for cap + float capN_depth_scale = get_depth_scale(clipN); + float capN_scaled_half_width = half_width * capN_depth_scale; + + for (int i = 0; i < 3; i++) { + float a = angles[i]; + // Direction: rotate from -perp toward +line_dir + vec2 arc_dir = cos(a) * (-perp) + sin(a) * line_dir; + + float arc_off_x = arc_dir.x * capN_scaled_half_width * 2.0 / cam.img_w * clipN.w; + float arc_off_y = -arc_dir.y * capN_scaled_half_width * 2.0 / cam.img_h * clipN.w; + + gl_MeshVerticesEXT[end_cap_base + 1u + uint(i)].gl_Position = + vec4(clipN.x + arc_off_x, clipN.y + arc_off_y, clipN.z, clipN.w); + } + } + } + + // Phase 4: Set triangle indices (first thread only) + // SHARED VERTICES: segment i uses vertices from point i and point i+1 + // Point i: vertices [2*i, 2*i+1] = [left, right] + if (tid == 0u) { + uint tri_idx = 0u; + + // Segment triangles: each segment uses 4 vertices from 2 adjacent points + // Segment i (points i, i+1): left0=2*i, right0=2*i+1, left1=2*(i+1), right1=2*(i+1)+1 + for (uint seg = 0u; seg < num_eff_segs; seg++) { + uint left0 = seg * 2u; + uint right0 = seg * 2u + 1u; + uint left1 = (seg + 1u) * 2u; + uint right1 = (seg + 1u) * 2u + 1u; + + // Triangle 1: left0, right0, left1 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(left0, right0, left1); + tri_idx++; + + // Triangle 2: right0, right1, left1 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(right0, right1, left1); + tri_idx++; + } + + // No joint triangles needed - vertices are shared! + + // Start cap triangles: fan from center through arc points + // Vertices: right(1), arc1, arc2, arc3, left(0) + // center = start_cap_base, arc1/2/3 = start_cap_base + 1/2/3 + if (draw_start_cap) { + uint center = start_cap_base; + uint right_edge = 1u; // First point's right vertex + uint left_edge = 0u; // First point's left vertex + uint arc1 = start_cap_base + 1u; + uint arc2 = start_cap_base + 2u; + uint arc3 = start_cap_base + 3u; + + // Triangle 1: center, right_edge, arc1 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, right_edge, arc1); + tri_idx++; + + // Triangle 2: center, arc1, arc2 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, arc1, arc2); + tri_idx++; + + // Triangle 3: center, arc2, arc3 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, arc2, arc3); + tri_idx++; + + // Triangle 4: center, arc3, left_edge + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, arc3, left_edge); + tri_idx++; + } + + // End cap triangles: fan from center through arc points + // Vertices: left(2*(n-1)), arc1, arc2, arc3, right(2*(n-1)+1) + if (draw_end_cap) { + uint last_pt = num_eff_points - 1u; + uint center = end_cap_base; + uint left_edge = last_pt * 2u; // Last point's left vertex + uint right_edge = last_pt * 2u + 1u; // Last point's right vertex + uint arc1 = end_cap_base + 1u; + uint arc2 = end_cap_base + 2u; + uint arc3 = end_cap_base + 3u; + + // Triangle 1: center, left_edge, arc1 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, left_edge, arc1); + tri_idx++; + + // Triangle 2: center, arc1, arc2 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, arc1, arc2); + tri_idx++; + + // Triangle 3: center, arc2, arc3 + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, arc2, arc3); + tri_idx++; + + // Triangle 4: center, arc3, right_edge + gl_PrimitiveTriangleIndicesEXT[tri_idx] = uvec3(center, arc3, right_edge); + tri_idx++; + } + + // Set all primitives to layer matching query_id and uniform color + for (uint i = 0u; i < _prim_count; i++) { + gl_MeshPrimitivesEXT[i].gl_Layer = int(payload.query_id); + prim_out[i].color = payload.color; + prim_out[i].is_bev = payload.is_bev; + } + } +} diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.task.glsl b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.task.glsl new file mode 100644 index 000000000..3d596d867 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/shaders/ts_polyline.task.glsl @@ -0,0 +1,993 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 +#version 460 +#extension GL_EXT_mesh_shader : require +#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require + +layout(push_constant) uniform PushConstants { + float u_width_polyline_regular; + float u_width_polyline_bev; + float u_width_ego_traj_regular; + float u_width_ego_traj_bev; + float u_width_wireframe; + float u_resolution_scale; + float u_depth_scaling; + int u_max_extrapolation_us; + int u_color_palette_size; + uint u_num_queries; + float u_tessellation_threshold; + uint u_max_tessellation_polyline; + uint u_max_tessellation_polygon; + uint u_max_tessellation_cube; + float u_cull_radius_scale; + float u_fog_enabled; + uint u_max_obstacles; + uint u_cube_pool_index; + uint u_num_polygon_pools; + uint u_max_varrays_per_pool; + uint u_num_polyline_pools; + uint u_output_width; + uint u_output_height; +} pc; + +#define IF_ZMODIFY(x) + +// Cap styles +const uint CAP_NONE = 0u; +const uint CAP_FLAT = 1u; +const uint CAP_ROUND = 2u; + +// Primitive type IDs (must match Python PRIM_* constants in ops.py) +const uint PRIM_ROAD_BOUNDARY = 0u; +const uint PRIM_LANE_LINE = 1u; // Legacy cyan lane line +const uint PRIM_CROSSWALK = 2u; +const uint PRIM_STATIC_OBSTACLE = 3u; // Legacy, avoid using +const uint PRIM_EGO_TRAJECTORY = 4u; +const uint PRIM_OBSTACLE = 5u; +const uint PRIM_EGO_OBSTACLE = 6u; +const uint PRIM_WAIT_LINE = 7u; +const uint PRIM_POLE = 8u; +const uint PRIM_ROAD_MARKING = 9u; +const uint PRIM_LANE_BOUNDARY = 10u; +const uint PRIM_TRAFFIC_LIGHT = 11u; +const uint PRIM_TRAFFIC_SIGN = 12u; +const uint PRIM_INTERSECTION = 13u; +const uint PRIM_ROAD_ISLAND = 14u; +const uint PRIM_BUFFER_ZONE = 15u; +// Lane line variants by color/style +const uint PRIM_LANE_LINE_WHITE_SOLID = 16u; +const uint PRIM_LANE_LINE_WHITE_DASHED = 17u; +const uint PRIM_LANE_LINE_YELLOW_SOLID = 18u; +const uint PRIM_LANE_LINE_YELLOW_DASHED = 19u; +// Dot primitives - each vertex is rendered as a circle +const uint PRIM_DOT_YELLOW = 20u; +const uint PRIM_DOT_WHITE = 21u; + +// Camera type IDs +const uint CAMERA_TYPE_REGULAR = 0u; +const uint CAMERA_TYPE_BEV = 1u; + +//============================================================================= +// Hardcoded Primitive Styles (matching wm-render colorscheme v3) +//============================================================================= + +// Colors (RGB normalized) - matching imaginaire4 v3 colorscheme +// Source: imaginaire4/imaginaire/auxiliary/world_scenario/color_scheme/config_color_hdmap.json +const vec3 COLOR_ROAD_BOUNDARY = vec3(253.0/255.0, 1.0/255.0, 232.0/255.0); // Magenta (253, 1, 232) +const vec3 COLOR_LANE_LINE = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (98, 183, 249) - "lanelines" (legacy) +const vec3 COLOR_CROSSWALK = vec3(139.0/255.0, 93.0/255.0, 255.0/255.0); // Purple (139, 93, 255) +const vec3 COLOR_STATIC_OBSTACLE = vec3(255.0/255.0, 100.0/255.0, 0.0/255.0); // Orange (legacy) +const vec3 COLOR_EGO_TRAJECTORY = vec3(0.0/255.0, 255.0/255.0, 0.0/255.0); // Green (0, 255, 0) +const vec3 COLOR_WAIT_LINE = vec3(108.0/255.0, 179.0/255.0, 59.0/255.0); // Yellow-green (108, 179, 59) +const vec3 COLOR_POLE = vec3(183.0/255.0, 69.0/255.0, 177.0/255.0); // Purple-magenta (183, 69, 177) +const vec3 COLOR_ROAD_MARKING = vec3(20.0/255.0, 254.0/255.0, 185.0/255.0); // Cyan-green (20, 254, 185) +const vec3 COLOR_LANE_BOUNDARY = vec3(98.0/255.0, 183.0/255.0, 249.0/255.0); // Cyan (same as lane line) +const vec3 COLOR_TRAFFIC_LIGHT = vec3(100.0/255.0, 100.0/255.0, 100.0/255.0); // Gray (100, 100, 100) +const vec3 COLOR_TRAFFIC_SIGN = vec3(8.0/255.0, 2.0/255.0, 255.0/255.0); // Blue (8, 2, 255) +const vec3 COLOR_INTERSECTION = vec3(80.0/255.0, 80.0/255.0, 120.0/255.0); // Dark blue-gray (approximated) +const vec3 COLOR_ROAD_ISLAND = vec3(60.0/255.0, 120.0/255.0, 60.0/255.0); // Dark green (approximated) +const vec3 COLOR_BUFFER_ZONE = vec3(120.0/255.0, 80.0/255.0, 80.0/255.0); // Dark red-brown (approximated) +// Lane line variants from config_color_geometry_laneline.json +const vec3 COLOR_LANE_LINE_WHITE = vec3(255.0/255.0, 255.0/255.0, 255.0/255.0); // White (255, 255, 255) +const vec3 COLOR_LANE_LINE_YELLOW = vec3(255.0/255.0, 255.0/255.0, 0.0/255.0); // Yellow (255, 255, 0) + +// Default polyline widths (pixels at reference resolution 1280x720) +const float DEFAULT_WIDTH_POLYLINE_REGULAR = 7.0; +const float DEFAULT_WIDTH_POLYLINE_BEV = 4.0; +const float DEFAULT_WIDTH_EGO_TRAJ_REGULAR = 12.0; +const float DEFAULT_WIDTH_EGO_TRAJ_BEV = 5.0; +const float DEFAULT_WIDTH_POLE_REGULAR = 5.0; // Poles are thinner (reference: 5 vs 12) +const float DEFAULT_WIDTH_POLE_BEV = 3.0; +const float DEFAULT_WIDTH_WIREFRAME = 2.0; + +// Configurable width uniforms (set from Python, or use defaults) + +// Compute depth-based scaling factor for line width +// z_ndc is in [-1, 1] where -1 is near, +1 is far +// Returns 1.0 at near, 0.0 at far (linear fade) +float get_depth_scale(vec4 clip) { + if (pc.u_depth_scaling < 0.5) return 1.0; // Disabled + float z_ndc = clip.z / clip.w; // Convert to NDC + float depth_scale = 1.0 - z_ndc; // Map [-1,1] to [1,0] + return clamp(depth_scale, 0.0, 1.0); +} + +// Color palette buffer (optional, configured from Python) +// Declared early so get_prim_color can use it; actual buffer layout defined later +layout(std430, binding = 10) readonly buffer ColorPaletteBufferEarly { + vec4 g_color_palette[]; +}; + +// Get default color for primitive type (hardcoded fallback) +vec3 get_default_prim_color(uint prim_type_id) { + if (prim_type_id == PRIM_ROAD_BOUNDARY) return COLOR_ROAD_BOUNDARY; + if (prim_type_id == PRIM_LANE_LINE) return COLOR_LANE_LINE; + if (prim_type_id == PRIM_CROSSWALK) return COLOR_CROSSWALK; + if (prim_type_id == PRIM_STATIC_OBSTACLE) return COLOR_STATIC_OBSTACLE; + if (prim_type_id == PRIM_EGO_TRAJECTORY) return COLOR_EGO_TRAJECTORY; + if (prim_type_id == PRIM_WAIT_LINE) return COLOR_WAIT_LINE; + if (prim_type_id == PRIM_POLE) return COLOR_POLE; + if (prim_type_id == PRIM_ROAD_MARKING) return COLOR_ROAD_MARKING; + if (prim_type_id == PRIM_LANE_BOUNDARY) return COLOR_LANE_BOUNDARY; + if (prim_type_id == PRIM_TRAFFIC_LIGHT) return COLOR_TRAFFIC_LIGHT; + if (prim_type_id == PRIM_TRAFFIC_SIGN) return COLOR_TRAFFIC_SIGN; + if (prim_type_id == PRIM_INTERSECTION) return COLOR_INTERSECTION; + if (prim_type_id == PRIM_ROAD_ISLAND) return COLOR_ROAD_ISLAND; + if (prim_type_id == PRIM_BUFFER_ZONE) return COLOR_BUFFER_ZONE; + // Lane line variants + if (prim_type_id == PRIM_LANE_LINE_WHITE_SOLID) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_WHITE_DASHED) return COLOR_LANE_LINE_WHITE; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_SOLID) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_LANE_LINE_YELLOW_DASHED) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_YELLOW) return COLOR_LANE_LINE_YELLOW; + if (prim_type_id == PRIM_DOT_WHITE) return COLOR_LANE_LINE_WHITE; + return vec3(1.0, 1.0, 1.0); // Default white for obstacles +} + +// Get color for primitive type (checks palette first, then falls back to defaults) +vec3 get_prim_color(uint prim_type_id) { + // If color palette is configured, check if this prim_type has a custom color + // Alpha < 0 means "use default", alpha >= 0 means "use this color" + if (pc.u_color_palette_size > 0 && prim_type_id < uint(pc.u_color_palette_size)) { + vec4 palette_color = g_color_palette[prim_type_id]; + if (palette_color.a >= 0.0) { + return palette_color.rgb; + } + } + // Fall back to hardcoded defaults + return get_default_prim_color(prim_type_id); +} + +// Check if primitive is a dot type (rendered as circles at each vertex) +bool is_dot_primitive(uint prim_type_id) { + return prim_type_id == PRIM_DOT_YELLOW || prim_type_id == PRIM_DOT_WHITE; +} + +// Get polyline width for primitive type and camera type (scaled by resolution) +float get_prim_width(uint prim_type_id, uint camera_type_id) { + bool is_bev = (camera_type_id == CAMERA_TYPE_BEV); + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + + float base_width; + if (prim_type_id == PRIM_EGO_TRAJECTORY) { + float default_w = is_bev ? DEFAULT_WIDTH_EGO_TRAJ_BEV : DEFAULT_WIDTH_EGO_TRAJ_REGULAR; + float custom_w = is_bev ? pc.u_width_ego_traj_bev : pc.u_width_ego_traj_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } else if (prim_type_id == PRIM_POLE) { + // Poles use thinner lines (reference: 5 pixels vs 12 for other polylines) + base_width = is_bev ? DEFAULT_WIDTH_POLE_BEV : DEFAULT_WIDTH_POLE_REGULAR; + } else { + float default_w = is_bev ? DEFAULT_WIDTH_POLYLINE_BEV : DEFAULT_WIDTH_POLYLINE_REGULAR; + float custom_w = is_bev ? pc.u_width_polyline_bev : pc.u_width_polyline_regular; + base_width = (custom_w > 0.0) ? custom_w : default_w; + } + return base_width * scale; +} + +// Get wireframe edge width (scaled by resolution) +float get_wireframe_width() { + float scale = (pc.u_resolution_scale > 0.0) ? pc.u_resolution_scale : 1.0; + float base_width = (pc.u_width_wireframe > 0.0) ? pc.u_width_wireframe : DEFAULT_WIDTH_WIREFRAME; + return base_width * scale; +} + +//============================================================================= +// Data Structures (must match C++ structs) +//============================================================================= + +// TimestampedPolylinePool (64 bytes) +struct TimestampedPolylinePool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint vertices_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4, _pad5, _pad6, _pad7; // Padding to 64 bytes +}; + +// TimestampedPolygonPool (64 bytes) +struct TimestampedPolygonPool { + uint num_timestamps; + uint num_varrays; + uint num_vertices; + uint num_triangles; + uint prim_type_id; // Index into PrimitiveStyle lookup table + uint timestamps_offset; + uint ts_varrays_ps_offset; + uint varrays_ps_offset; + uint tri_ps_offset; + uint vertices_offset; + uint triangles_offset; + uint aabb_offset; // Per-element AABB in float buffer (6 floats each: min xyz, max xyz) + uint _pad1, _pad2, _pad3, _pad4; // Padding to 64 bytes (16 uints) +}; + +// CubePool (64 bytes) - used for obstacles, traffic lights, traffic signs, etc. +// Renamed from ObstaclePool but keeping struct name for backward compat +struct ObstaclePool { + uint num_cubes; // Was: num_obstacles + uint num_timestamps; + uint num_track_poses; + uint prim_type_id; // Semantic type for color lookup + uint timestamps_offset; // Global timestamps for this pool + uint cube_ts_ps_offset; // Per-cube track length prefix sum (was: obstacle_ts_ps_offset) + uint track_timestamps_offset; // Per-pose timestamps in float buffer (as 2x uint for int64) + uint translations_offset; // Per-pose translations (3 floats each) + uint quaternions_offset; // Per-pose quaternions (4 floats each) + uint scales_offset; // Per-cube scales (3 floats each) + uint colors_offset; // Per-cube colors (6 floats each) + uint render_flags; // CUBE_FLAG_* bits (e.g., CUBE_FLAG_WIREFRAME) + uint _pad2, _pad3, _pad4, _pad5; // 4 padding fields for 64 bytes total +}; + +// Cube render flags +const uint CUBE_FLAG_WIREFRAME = 1u; // Draw wireframe edges in addition to solid faces + +// TimestampedScene (128 bytes) +struct TimestampedScene { + uint num_polyline_pools; + uint polyline_pools_offset; + uint num_polygon_pools; + uint polygon_pools_offset; + uint num_cube_pools; // Was: has_obstacle_pool (0/1), now supports multiple + uint cube_pools_offset; // Was: obstacle_pool_offset + uint timestamps_buffer_offset; + uint int32_buffer_offset; + uint vertex_buffer_offset; + uint triangle_buffer_offset; + uint pose_buffer_offset; + uint float_buffer_offset; + uint _pad[20]; +}; + +// RenderQuery (16 bytes) +struct RenderQuery { + uint scene_id; + uint camera_id; + int64_t timestamp_us; + uint camera_type_id; // CAMERA_TYPE_REGULAR or CAMERA_TYPE_BEV + uint _pad1, _pad2, _pad3; // Padding to 32 bytes +}; + +// FThetaCamera (72 bytes) +struct FThetaCamera { + float cx, cy; + float img_w, img_h; + float poly0, poly1, poly2, poly3, poly4, poly5; + float max_ray_angle; + float max_distortion_val; + float max_distortion_dval; + float depth_max; + float ld_c, ld_d, ld_e, ld_f; +}; + +// CameraPose (64 bytes) +struct CameraPose { + mat4 world_to_camera; +}; + +// Vertex (16 bytes) +struct Vertex { + float x, y, z; + float _pad; +}; + +//============================================================================= +// Buffer Bindings +//============================================================================= + +// Global data buffers +layout(std430, binding = 0) readonly buffer TimestampsBuffer { + int64_t g_timestamps[]; +}; + +layout(std430, binding = 1) readonly buffer Int32Buffer { + int g_int32[]; +}; + +layout(std430, binding = 2) readonly buffer VertexBuffer { + Vertex g_vertices[]; +}; + +layout(std430, binding = 3) readonly buffer TriangleBuffer { + uvec3 g_triangles[]; +}; + +layout(std430, binding = 4) readonly buffer PoseBuffer { + CameraPose g_poses[]; +}; + +layout(std430, binding = 5) readonly buffer FloatBuffer { + float g_floats[]; +}; + +// Scene metadata +layout(std430, binding = 6) readonly buffer SceneBuffer { + TimestampedScene g_scenes[]; +}; + +layout(std430, binding = 7) readonly buffer PolylinePoolBuffer { + TimestampedPolylinePool g_polyline_pools[]; +}; + +layout(std430, binding = 8) readonly buffer PolygonPoolBuffer { + TimestampedPolygonPool g_polygon_pools[]; +}; + +layout(std430, binding = 9) readonly buffer ObstaclePoolBuffer { + ObstaclePool g_obstacle_pools[]; +}; + +// Camera buffers +layout(std430, binding = 11) readonly buffer CameraIntrinsicsBuffer { + FThetaCamera g_camera_intrinsics[]; +}; + +layout(std430, binding = 12) readonly buffer CameraPoseBuffer { + CameraPose g_camera_poses[]; // One per query (dynamic viewpoints) +}; + +// Query buffer +layout(std430, binding = 13) readonly buffer QueryBuffer { + RenderQuery g_queries[]; +}; + +// Uniforms +// Spatial culling: elements beyond depth_max * scale from the camera are +// discarded in the task shader. Scale > 1 gives headroom so nothing at +// the visible boundary pops in/out. Set to 0 to disable culling. + +//============================================================================= +// GPU Binary Search +// Returns index of last element <= target, or -1 if target < all elements +//============================================================================= + +int binary_search_timestamps(uint base_offset, uint count, int64_t target) { + if (count == 0u) return -1; + + int left = 0; + int right = int(count) - 1; + int result = -1; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t val = g_timestamps[base_offset + uint(mid)]; + + if (val <= target) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + + return result; +} + +//============================================================================= +// Quaternion Math for Track Interpolation +//============================================================================= + +// Quaternion dot product +float quat_dot(vec4 a, vec4 b) { + return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; +} + +// Quaternion normalize +vec4 quat_normalize(vec4 q) { + float len = length(q); + return len > 1e-10 ? q / len : vec4(0.0, 0.0, 0.0, 1.0); +} + +// Quaternion spherical linear interpolation (slerp) +vec4 quat_slerp(vec4 q0, vec4 q1, float t) { + // Ensure shortest path + float d = quat_dot(q0, q1); + if (d < 0.0) { + q1 = -q1; + d = -d; + } + + // If quaternions are very close, use linear interpolation + if (d > 0.9995) { + return quat_normalize(mix(q0, q1, t)); + } + + // Spherical interpolation + float theta_0 = acos(clamp(d, -1.0, 1.0)); + float theta = theta_0 * t; + float sin_theta = sin(theta); + float sin_theta_0 = sin(theta_0); + + float s0 = cos(theta) - d * sin_theta / sin_theta_0; + float s1 = sin_theta / sin_theta_0; + + return quat_normalize(s0 * q0 + s1 * q1); +} + +// Convert quaternion (x, y, z, w) to 3x3 rotation matrix +// GLSL mat3 is column-major: mat3(col0, col1, col2) +mat3 quat_to_matrix(vec4 q) { + float x = q.x, y = q.y, z = q.z, w = q.w; + + float x2 = x + x, y2 = y + y, z2 = z + z; + float xx = x * x2, xy = x * y2, xz = x * z2; + float yy = y * y2, yz = y * z2, zz = z * z2; + float wx = w * x2, wy = w * y2, wz = w * z2; + + // Column 0: (R00, R10, R20), Column 1: (R01, R11, R21), Column 2: (R02, R12, R22) + return mat3( + 1.0 - (yy + zz), xy + wz, xz - wy, // Column 0 + xy - wz, 1.0 - (xx + zz), yz + wx, // Column 1 + xz + wy, yz - wx, 1.0 - (xx + yy) // Column 2 + ); +} + +// Build 4x4 transform from translation and quaternion (with scale) +mat4 build_transform(vec3 translation, vec4 quaternion, vec3 scale) { + mat3 rot = quat_to_matrix(quaternion); + + // Apply scale to each column of rotation matrix + mat4 result = mat4( + vec4(rot[0] * scale.x, 0.0), + vec4(rot[1] * scale.y, 0.0), + vec4(rot[2] * scale.z, 0.0), + vec4(translation, 1.0) + ); + + return result; +} + +// Binary search for track interpolation (returns index where t0 <= target < t1) +// Returns -1 if target is outside the track range +int binary_search_track(uint base_offset, uint count, int64_t target) { + if (count < 2u) return -1; // Need at least 2 points for interpolation + + int64_t first_ts = g_timestamps[base_offset]; + int64_t last_ts = g_timestamps[base_offset + count - 1u]; + + // Check bounds + if (target < first_ts || target > last_ts) return -1; + + int left = 0; + int right = int(count) - 2; // Max valid index for interpolation start + int result = 0; + + while (left <= right) { + int mid = (left + right) / 2; + int64_t t0 = g_timestamps[base_offset + uint(mid)]; + int64_t t1 = g_timestamps[base_offset + uint(mid) + 1u]; + + if (t0 <= target && target <= t1) { + return mid; + } else if (target < t0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + + return -1; // Should not reach here for valid input +} + +//============================================================================= +// Spatial Culling Helpers +//============================================================================= + +// AABB-AABB overlap test +bool cull_aabb_overlap(vec3 a_min, vec3 a_max, vec3 b_min, vec3 b_max) { + return all(lessThanEqual(a_min, b_max)) && all(greaterThanEqual(a_max, b_min)); +} + +// Sphere-AABB overlap test +bool cull_sphere_aabb_overlap(vec3 center, float radius, vec3 b_min, vec3 b_max) { + vec3 nearest = clamp(center, b_min, b_max); + vec3 d = center - nearest; + return dot(d, d) <= radius * radius; +} + +// Extract camera world position from view pose +vec3 get_camera_world_pos(CameraPose pose) { + mat3 R = mat3(pose.world_to_camera); + return -transpose(R) * pose.world_to_camera[3].xyz; +} + +//============================================================================= +// F-theta Projection +//============================================================================= + +vec3 rotate_rodrigues(vec3 v, vec3 r) { + float theta = length(r); + if (theta < 1e-8) return v; + vec3 k = r / theta; + float c = cos(theta); + float s = sin(theta); + return v * c + cross(k, v) * s + k * dot(k, v) * (1.0 - c); +} + +// F-theta projection: world point -> NDC +// Supports >180° FOV fisheye cameras where points can have negative z (behind camera plane) +vec4 ftheta_project(vec3 world_pos, CameraPose pose, FThetaCamera cam) { + vec3 cam_pt = (pose.world_to_camera * vec4(world_pos, 1.0)).xyz; + float depth = cam_pt.z; + + float ray_norm = length(cam_pt); + + // Handle points at camera origin + if (ray_norm < 1e-6) { + return vec4(0.0, 0.0, 0.0, 1.0); + } + + float half_pi = 1.5707963; // π/2 + + // For cameras with FOV <= 180° (max_ray_angle <= π/2), points behind camera should be clipped + // Use pseudo-pinhole projection to push them far away in the correct direction + if (cam.max_ray_angle <= half_pi && depth < 0.001) { + float pseudo_focal = cam.poly1; + float x_clip = cam_pt.x * pseudo_focal / (cam.img_w * 0.5); + float y_clip = -cam_pt.y * pseudo_focal / (cam.img_h * 0.5); + return vec4(x_clip * 10.0, y_clip * 10.0, 1.0, 1.0); // Scale by 10 to push far outside + } + + float xy_norm = length(cam_pt.xy); + float cos_alpha = clamp(cam_pt.z / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); // alpha in [0, π] + + // Apply polynomial projection (with linear extrapolation beyond max_ray_angle) + float a2 = alpha * alpha; + float a3 = a2 * alpha; + float a4 = a2 * a2; + float a5 = a4 * alpha; + + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * a3 + cam.poly4 * a4 + cam.poly5 * a5; + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt.xy; + + vec2 pixel_dist; + pixel_dist.x = cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y; + pixel_dist.y = cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y; + + vec2 pixel = pixel_dist + vec2(cam.cx, cam.cy); + + float x_ndc = 2.0 * pixel.x / cam.img_w - 1.0; + float y_ndc = 1.0 - 2.0 * pixel.y / cam.img_h; + + // For z-buffer depth mapping: + // - Narrow FOV (<=180°): use signed depth (cam_pt.z) + // - Wide FOV (>180°): use ray_norm for front-camera vertices (unchanged), + // but push behind-camera vertices to depth_max so they never occlude + // forward geometry. ray_norm alone can't distinguish front from behind. + float z_value; + if (cam.max_ray_angle > half_pi) { + z_value = (depth >= 0.0) ? ray_norm : cam.depth_max; + } else { + z_value = depth; + } + float z_ndc = clamp(z_value / cam.depth_max, 0.0, 1.0); + + return vec4(x_ndc, y_ndc, z_ndc, 1.0); +} + +// Inline version that takes mat4 directly +float estimate_edge_distortion_pixels_mat4(vec3 v0, vec3 v1, mat4 world_to_cam, FThetaCamera cam) { + // Transform to camera space + vec3 cam_pt0 = (world_to_cam * vec4(v0, 1.0)).xyz; + vec3 cam_pt1 = (world_to_cam * vec4(v1, 1.0)).xyz; + vec3 mid_world = (v0 + v1) * 0.5; + vec3 cam_pt_mid = (world_to_cam * vec4(mid_world, 1.0)).xyz; + + // Just clamp depths to avoid division issues + + // For segments in front of camera, compute f-theta projection error directly + // Use depth-clamped projection to handle near-plane cases + float depth0 = max(cam_pt0.z, 0.001); + float depth1 = max(cam_pt1.z, 0.001); + float depth_mid = max(cam_pt_mid.z, 0.001); + + // Compute f-theta projection for each point + // We inline the projection to avoid struct-passing issues + vec2 pixel0, pixel1, pixel_mid; + { + float xy_norm = length(cam_pt0.xy); + float ray_norm = length(vec3(cam_pt0.xy, depth0)) + 1e-10; + float cos_alpha = clamp(depth0 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt0.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel0 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt1.xy); + float ray_norm = length(vec3(cam_pt1.xy, depth1)) + 1e-10; + float cos_alpha = clamp(depth1 / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt1.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel1 = pixel_dist + vec2(cam.cx, cam.cy); + } + { + float xy_norm = length(cam_pt_mid.xy); + float ray_norm = length(vec3(cam_pt_mid.xy, depth_mid)) + 1e-10; + float cos_alpha = clamp(depth_mid / ray_norm, -1.0, 1.0); + float alpha = acos(cos_alpha); + float a2 = alpha * alpha; + float delta = cam.poly0 + cam.poly1 * alpha + cam.poly2 * a2 + + cam.poly3 * (a2 * alpha) + cam.poly4 * (a2 * a2) + cam.poly5 * (a2 * a2 * alpha); + if (alpha > cam.max_ray_angle) { + delta = cam.max_distortion_val + (alpha - cam.max_ray_angle) * cam.max_distortion_dval; + } + float scale = (xy_norm > 1e-6) ? (delta / xy_norm) : 0.0; + vec2 pixel_rel = scale * cam_pt_mid.xy; + vec2 pixel_dist = vec2(cam.ld_c * pixel_rel.x + cam.ld_d * pixel_rel.y, + cam.ld_e * pixel_rel.x + cam.ld_f * pixel_rel.y); + pixel_mid = pixel_dist + vec2(cam.cx, cam.cy); + } + + // Compute error: distance from projected midpoint to linear interpolation + vec2 linear_pixel_mid = (pixel0 + pixel1) * 0.5; + float error_pixels = length(pixel_mid - linear_pixel_mid); + + // Clamp to reasonable range to handle edge cases + return clamp(error_pixels, 0.0, 10000.0); +} + +uint compute_subdivision_level(vec3 v0, vec3 v1, CameraPose pose, FThetaCamera cam, float threshold_pixels) { + float error = estimate_edge_distortion_pixels_mat4(v0, v1, pose.world_to_camera, cam); + + if (error < threshold_pixels) return 0u; + if (error < threshold_pixels * 2.0) return 1u; + if (error < threshold_pixels * 4.0) return 2u; + return 3u; +} + +//============================================================================= +// Barycentric Subdivision Utilities (shared with polygon/cube) +//============================================================================= + +uint bary_vertex_count(uint level) { + // Vertices = (n+1)(n+2)/2 where n = 2^level + if (level == 0u) return 3u; + if (level == 1u) return 6u; + if (level == 2u) return 15u; + return 45u; // level 3 +} + +uint bary_triangle_count(uint level) { + // Triangles = 4^level + if (level == 0u) return 1u; + if (level == 1u) return 4u; + if (level == 2u) return 16u; + return 64u; // level 3 +} + +vec2 bary_vertex_uv(uint vertex_idx, uint level) { + if (level == 0u) { + if (vertex_idx == 0u) return vec2(0.0, 0.0); + if (vertex_idx == 1u) return vec2(1.0, 0.0); + return vec2(0.0, 1.0); + } else if (level == 1u) { + vec2 uvs[6]; + uvs[0] = vec2(0.0, 0.0); + uvs[1] = vec2(1.0, 0.0); + uvs[2] = vec2(0.0, 1.0); + uvs[3] = vec2(0.5, 0.0); + uvs[4] = vec2(0.5, 0.5); + uvs[5] = vec2(0.0, 0.5); + return uvs[vertex_idx]; + } else if (level == 2u) { + uint row, col; + if (vertex_idx < 5u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 9u) { row = 1u; col = vertex_idx - 5u; } + else if (vertex_idx < 12u) { row = 2u; col = vertex_idx - 9u; } + else if (vertex_idx < 14u) { row = 3u; col = vertex_idx - 12u; } + else { row = 4u; col = 0u; } + return vec2(float(col) / 4.0, float(row) / 4.0); + } else { + // Level 3: 9 rows (0-8), row r has (9-r) vertices + uint row, col; + if (vertex_idx < 9u) { row = 0u; col = vertex_idx; } + else if (vertex_idx < 17u) { row = 1u; col = vertex_idx - 9u; } + else if (vertex_idx < 24u) { row = 2u; col = vertex_idx - 17u; } + else if (vertex_idx < 30u) { row = 3u; col = vertex_idx - 24u; } + else if (vertex_idx < 35u) { row = 4u; col = vertex_idx - 30u; } + else if (vertex_idx < 39u) { row = 5u; col = vertex_idx - 35u; } + else if (vertex_idx < 42u) { row = 6u; col = vertex_idx - 39u; } + else if (vertex_idx < 44u) { row = 7u; col = vertex_idx - 42u; } + else { row = 8u; col = 0u; } + return vec2(float(col) / 8.0, float(row) / 8.0); + } +} + +vec3 bary_interpolate(vec3 v0, vec3 v1, vec3 v2, vec2 uv) { + float w = 1.0 - uv.x - uv.y; + return v0 * w + v1 * uv.x + v2 * uv.y; +} + +uvec3 bary_triangle_indices(uint tri_idx, uint level) { + if (level == 0u) { + return uvec3(0u, 1u, 2u); + } else if (level == 1u) { + uvec3 tris[4]; + tris[0] = uvec3(0u, 3u, 5u); + tris[1] = uvec3(3u, 1u, 4u); + tris[2] = uvec3(5u, 4u, 2u); + tris[3] = uvec3(3u, 4u, 5u); + return tris[tri_idx]; + } else if (level == 2u) { + uint row_start[5] = uint[5](0u, 5u, 9u, 12u, 14u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + if (t < 7u) { + row = 0u; + if (t < 4u) { col = t; is_down = false; } + else { col = t - 4u; is_down = true; } + } else if (t < 12u) { + row = 1u; + uint lt = t - 7u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 15u) { + row = 2u; + uint lt = t - 12u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 3u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } else { + // Level 3: row_start for 9 rows + uint row_start[9] = uint[9](0u, 9u, 17u, 24u, 30u, 35u, 39u, 42u, 44u); + uint t = tri_idx; + uint row = 0u, col = 0u; + bool is_down = false; + + // Row 0: 8 up + 7 down = 15, Row 1: 7 up + 6 down = 13, etc. + if (t < 15u) { + row = 0u; + if (t < 8u) { col = t; is_down = false; } + else { col = t - 8u; is_down = true; } + } else if (t < 28u) { + row = 1u; uint lt = t - 15u; + if (lt < 7u) { col = lt; is_down = false; } + else { col = lt - 7u; is_down = true; } + } else if (t < 39u) { + row = 2u; uint lt = t - 28u; + if (lt < 6u) { col = lt; is_down = false; } + else { col = lt - 6u; is_down = true; } + } else if (t < 48u) { + row = 3u; uint lt = t - 39u; + if (lt < 5u) { col = lt; is_down = false; } + else { col = lt - 5u; is_down = true; } + } else if (t < 55u) { + row = 4u; uint lt = t - 48u; + if (lt < 4u) { col = lt; is_down = false; } + else { col = lt - 4u; is_down = true; } + } else if (t < 60u) { + row = 5u; uint lt = t - 55u; + if (lt < 3u) { col = lt; is_down = false; } + else { col = lt - 3u; is_down = true; } + } else if (t < 63u) { + row = 6u; uint lt = t - 60u; + if (lt < 2u) { col = lt; is_down = false; } + else { col = lt - 2u; is_down = true; } + } else { + row = 7u; col = 0u; is_down = false; + } + + uint i0, i1, i2; + if (!is_down) { + i0 = row_start[row] + col; + i1 = row_start[row] + col + 1u; + i2 = row_start[row + 1u] + col; + } else { + i0 = row_start[row] + col + 1u; + i1 = row_start[row + 1u] + col + 1u; + i2 = row_start[row + 1u] + col; + } + return uvec3(i0, i1, i2); + } +} + + +layout(local_size_x = 1) in; + +// Uniforms for dispatch decoding + +// Task payload to mesh shader - matches non-timestamped version +struct PolylineTaskPayload { + uint query_id; + uint pool_id; + uint varray_idx; // Actual varray index (global in pool) + uint total_points; // Number of vertices in this polyline + float width; + vec3 color; + uint cap_style; + float is_bev; // 1.0 for BEV cameras, 0.0 otherwise +}; +taskPayloadSharedEXT PolylineTaskPayload payload; + +void main() { + uint _task_count = 0u; + uint work_id = gl_WorkGroupID.x; + + // Decode work_id into (query, pool, varray_offset) + uint varray_offset = work_id % pc.u_max_varrays_per_pool; + uint temp = work_id / pc.u_max_varrays_per_pool; + uint pool_id_local = temp % pc.u_num_polyline_pools; + uint query_id_local = temp / pc.u_num_polyline_pools; + + if (query_id_local >= pc.u_num_queries) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + // Load query + RenderQuery query = g_queries[query_id_local]; + TimestampedScene scene = g_scenes[query.scene_id]; + + if (pool_id_local >= scene.num_polyline_pools) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + // Load pool + TimestampedPolylinePool pool = g_polyline_pools[scene.polyline_pools_offset + pool_id_local]; + + // Binary search for timestamp + int ts_idx = binary_search_timestamps( + scene.timestamps_buffer_offset + pool.timestamps_offset, + pool.num_timestamps, + query.timestamp_us + ); + + if (ts_idx < 0) { + _task_count = 0u; + EmitMeshTasksEXT(_task_count, 1, 1); return; + } + + // Compute varray range for this timestamp + uint varray_start = 0u; + if (ts_idx > 0) { + varray_start = uint(g_int32[scene.int32_buffer_offset + pool.ts_varrays_ps_offset + uint(ts_idx) - 1u]); + } + uint varray_end = uint(g_int32[scene.int32_buffer_offset + pool.ts_varrays_ps_offset + uint(ts_idx)]); + uint num_varrays = varray_end - varray_start; + + bool force_zero_tasks = false; + if (varray_offset >= num_varrays) { + // Keep subsequent SSBO reads in-bounds, then force the final emit + // count to zero. This mirrors the polygon task shader guard and + // prevents over-dispatched workgroups for smaller pools from + // reading following pools' prefix sums/vertices. + force_zero_tasks = true; + varray_offset = 0u; + } + + uint actual_varray_idx = varray_start + varray_offset; + + // Spatial culling: test per-element AABB against camera-centred view volume + if (pc.u_cull_radius_scale > 0.0 && pool.aabb_offset != 0u) { + float cull_r = g_camera_intrinsics[query.camera_id].depth_max * pc.u_cull_radius_scale; + CameraPose cull_pose = g_camera_poses[query_id_local]; + vec3 cam_pos = get_camera_world_pos(cull_pose); + vec3 view_min = cam_pos - vec3(cull_r); + vec3 view_max = cam_pos + vec3(cull_r); + uint ab = scene.float_buffer_offset + pool.aabb_offset + actual_varray_idx * 6u; + vec3 e_min = vec3(g_floats[ab], g_floats[ab+1u], g_floats[ab+2u]); + vec3 e_max = vec3(g_floats[ab+3u], g_floats[ab+4u], g_floats[ab+5u]); + if (!cull_aabb_overlap(e_min, e_max, view_min, view_max)) { + force_zero_tasks = true; + } + } + + // Get vertex range for this polyline + uint v_start = 0u; + if (actual_varray_idx > 0u) { + v_start = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + actual_varray_idx - 1u]); + } + uint v_end = uint(g_int32[scene.int32_buffer_offset + pool.varrays_ps_offset + actual_varray_idx]); + uint total_pts = v_end - v_start; + + // Handle dot primitives differently - each vertex is a separate circle + bool is_dot = is_dot_primitive(pool.prim_type_id); + + if (is_dot) { + // For dots: each vertex is a dot, dispatch one mesh task per batch of dots + // Each dot uses 9 vertices (center + 8 ring) and 8 triangles + // With max 64 verts, we can do 7 dots per mesh (7*9=63) + const uint DOTS_PER_CHUNK = 7u; + uint num_chunks = (total_pts + DOTS_PER_CHUNK - 1u) / DOTS_PER_CHUNK; + num_chunks = max(num_chunks, 1u); + + _task_count = force_zero_tasks ? 0u : num_chunks; + } else { + // Regular polylines + if (total_pts < 2u) { + force_zero_tasks = true; + total_pts = 2u; + } + + // Per-segment adaptive subdivision with 128 vertex limit (per-primitive color) + // Max capacity: 128 verts - 8 cap verts = 120 body verts = 60 effective points + // Worst case 16x subdivision (level 4): 60 / 16 = 3.75 segments + // Use 3 segments per chunk for safety margin + const uint MAX_SEGMENTS_PER_CHUNK = 3u; + + uint num_segments = total_pts - 1u; + uint num_chunks = (num_segments + MAX_SEGMENTS_PER_CHUNK - 1u) / MAX_SEGMENTS_PER_CHUNK; + num_chunks = max(num_chunks, 1u); + + // Emit mesh tasks for each chunk + _task_count = force_zero_tasks ? 0u : num_chunks; + } + + // Write task payload - readable by all spawned mesh shaders + payload.query_id = query_id_local; + payload.pool_id = pool_id_local; + payload.varray_idx = actual_varray_idx; + payload.total_points = total_pts; + payload.width = get_prim_width(pool.prim_type_id, query.camera_type_id); + payload.color = get_prim_color(pool.prim_type_id); + payload.cap_style = CAP_ROUND; + payload.is_bev = (query.camera_type_id == CAMERA_TYPE_BEV) ? 1.0 : 0.0; + EmitMeshTasksEXT(_task_count, 1, 1); +} diff --git a/integrations/omnidreams/ludus-renderer/pyproject.toml b/integrations/omnidreams/ludus-renderer/pyproject.toml index c5f3fb66f..c29c71250 100644 --- a/integrations/omnidreams/ludus-renderer/pyproject.toml +++ b/integrations/omnidreams/ludus-renderer/pyproject.toml @@ -63,9 +63,13 @@ packages = [ [tool.setuptools.package-data] "ludus_renderer" = [ "_cpp/common/*.h", - "_cpp/common/common.cpp", + "_cpp/common/*.cpp", "_cpp/render/*.h", + "_cpp/render/*.cpp", "_cpp/render/*.cu", + "shaders/*.glsl", + "shaders/*.py", + "shaders/*.sh", "_cpp/cudaraster/*.hpp", "_cpp/cudaraster/*.cpp", "_cpp/cudaraster/*.cu", diff --git a/integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py b/integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py new file mode 100644 index 000000000..7b4cae426 --- /dev/null +++ b/integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py @@ -0,0 +1,149 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Cheap source-level guards for the optional Vulkan/CUDA interop path.""" + +import re +from pathlib import Path + +import pytest + +pytestmark = pytest.mark.ci_cpu + +_PACKAGE = Path(__file__).parents[1] / "ludus_renderer" + + +def _between(source: str, start: str, end: str) -> str: + return source.split(start, 1)[1].split(end, 1)[0] + + +def test_vulkan_hot_path_uses_reused_zero_copy_interop() -> None: + renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() + vkutil = (_PACKAGE / "_cpp/common/vkutil.cpp").read_text() + binding = (_PACKAGE / "_cpp/bindings/torch_rasterize_vk.cpp").read_text() + interactive = ( + Path(__file__).parents[2] / "omnidreams/interactive_drive/rasterizer.py" + ).read_text() + render = _between( + renderer, "void ludusRenderBatchVk", "void ludusCopyBatchResultsVk" + ) + torch_render = _between( + binding, + "torch::Tensor ludus_timestamped_render_batch_vk", + "std::tuple ludus_timestamped_render_to_staging_vk", + ) + + # Fixed-function color/depth ordering resolves visibility before one + # compute pass writes the exported, device-local linear allocation. + for shader in _PACKAGE.glob("shaders/*.frag.glsl"): + source = shader.read_text() + assert "layout(early_fragment_tests) in;" in source + assert "layout(location = 0) out vec4 out_color;" in source + assert "binding = 14" not in source + assert "output_pixels.rgba8[pixel_index]" not in source + export = (_PACKAGE / "shaders/ts_export.comp.glsl").read_text() + assert "binding = 14" in export + assert "binding = 15" in export + assert "imageLoad(color_image" in export + assert "output_pixels.rgba8[pixel_index]" in export + assert "subpass.colorAttachmentCount = 1" in renderer + assert ( + "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT" in renderer + ) + assert "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT" in render + assert "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT" in render + assert "vkCmdDispatch" in render + assert "resizeExternalBuffer(s.vkctx, outputBuffer, totalSize" in render + assert "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT" in render + assert "cuExternalMemoryGetMappedBuffer" in vkutil + assert "cuExternalMemoryGetMappedMipmappedArray" not in vkutil + assert "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT" in vkutil + assert "vkCmdCopyImageToBuffer" not in renderer + assert "torch::from_blob" in torch_render + assert "ludusMapBatchResultsVk" in torch_render + assert "ludusCopyBatchResultsVk" not in torch_render + assert '"vulkan": LudusVulkanTimestampedContext' in interactive + + # Output and color/depth allocations are capacity/cache reused; teardown + # synchronization remains behind those rare growth paths. + assert "target.maxLayers >= layers" in renderer + assert "externalBufferNeedsResize(outputBuffer, totalSize)" in render + assert "LUDUS_VK_OUTPUT_SLOTS" in binding + assert "cudaStreamSynchronize" not in render + assert "vkDeviceWaitIdle" not in render + + +def test_vulkan_growth_preserves_existing_scenes_and_required_features() -> None: + renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() + vkutil = (_PACKAGE / "_cpp/common/vkutil.cpp").read_text() + + assert "growCapacityGeometrically" in renderer + assert "finishSharedBufferGrowth" in renderer + assert "growth.preserveBytes" in renderer + assert "cudaMemcpyAsync" in _between( + renderer, + "static void finishSharedBufferGrowth", + "static void rebuildRenderPassAndPipelines", + ) + assert "features2.features.geometryShader = VK_TRUE" in vkutil + # Fragment shaders no longer perform storage writes, so this feature is not + # needed by the corrected graphics-plus-compute path. + assert "features2.features.fragmentStoresAndAtomics = VK_TRUE" not in vkutil + + +def test_vulkan_handoff_is_timeline_and_ownership_ordered() -> None: + renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() + vkutil = (_PACKAGE / "_cpp/common/vkutil.cpp").read_text() + vkheader = (_PACKAGE / "_cpp/common/vkutil.h").read_text() + plugin = (_PACKAGE / "_ops/_plugin_vk.py").read_text() + render = _between( + renderer, "void ludusRenderBatchVk", "void ludusCopyBatchResultsVk" + ) + mapping = _between( + renderer, "uint8_t* ludusMapBatchResultsVk", "void ludusCopyBatchResultsVk" + ) + + # Interop selects native handles at compile time. OS handles only transport + # the Vulkan allocation/semaphore into CUDA; renderer state tracks the CUDA + # import itself, so there is no Linux-fd field or Windows handle leak. + assert "VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME" in vkutil + assert "VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME" in vkutil + assert "CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" in vkutil + assert "CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" in vkutil + assert "CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32" in vkutil + assert "CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD" in vkutil + assert "CloseHandle(semaphoreHandle)" in vkutil + assert "CloseHandle(memoryHandle)" in vkutil + assert "memFd" not in vkheader + assert "VK_USE_PLATFORM_WIN32_KHR" in vkheader + assert 'ldflags = ["cuda.lib", "vulkan-1.lib", "nvjpeg.lib"]' in plugin + assert "Vulkan backend is currently only supported on Linux" not in plugin + assert "cuSignalExternalSemaphoresAsync" in vkutil + assert "cuWaitExternalSemaphoresAsync" in vkutil + assert "signalInteropTimelineFromCuda" in render + assert "waitInteropTimelineOnCuda" in mapping + assert "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO" in render + assert "VK_QUEUE_FAMILY_EXTERNAL" in render + assert "srcQueueFamilyIndex = s.vkctx.graphicsQueueFamily" in render + assert "dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL" in render + assert "VK_ACCESS_SHADER_WRITE_BIT" in render + assert "VK_ACCESS_TRANSFER_WRITE_BIT" not in render + + +def test_vulkan_push_constant_updates_cover_the_declared_stage_range() -> None: + renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() + stage_mask = _between( + renderer, + "static constexpr VkShaderStageFlags kLudusPushConstantStages =", + ";", + ) + + assert "VK_SHADER_STAGE_TASK_BIT_EXT" in stage_mask + assert "VK_SHADER_STAGE_MESH_BIT_EXT" in stage_mask + assert "VK_SHADER_STAGE_FRAGMENT_BIT" in stage_mask + assert "VK_SHADER_STAGE_COMPUTE_BIT" in stage_mask + assert "pushRange.stageFlags = kLudusPushConstantStages" in renderer + + push_calls = re.findall(r"vkCmdPushConstants\((.*?)\);", renderer, re.DOTALL) + assert push_calls + assert all("kLudusPushConstantStages" in call for call in push_calls) diff --git a/integrations/omnidreams/omnidreams/interactive_drive/README.md b/integrations/omnidreams/omnidreams/interactive_drive/README.md index 751955c22..6a7dc9aff 100644 --- a/integrations/omnidreams/omnidreams/interactive_drive/README.md +++ b/integrations/omnidreams/omnidreams/interactive_drive/README.md @@ -1,716 +1,84 @@ # interactive-drive -`interactive-drive` is an interactive demo for exploring NVIDIA OmniDreams live. +Interactive NVIDIA OmniDreams demo with keyboard or steering-wheel controls. +Run these commands from the FlashDreams workspace root. ![interactive-drive screenshot](screenshot.jpg) -Drive a single scene with the keyboard and switch between the two views that -matter most: +## Prerequisites -- the generated driving view from the world model -- the HD map view that conditions that generated output - -This sample uses the flashdreams Alpadreams pipeline for world-model inference, -uses Ludus to render the HD map view, and uses SlangPy for local windowing. - -Runs on Windows or Linux with a native host toolchain; the optional -Docker path is Linux-only. - -The implementation is intentionally narrow: - -- one scene loaded at startup -- one camera view -- fixed-step vehicle dynamics with collision-driven dynamic actors -- one UI thread and one simulation thread -- explicit WSL-safe CPU staging between Vulkan and CUDA when needed - -## Install - -### 1. Prerequisites - -`interactive-drive` lives in the -[`NVIDIA/flashdreams`](https://github.com/NVIDIA/flashdreams) monorepo as -the `omnidreams.interactive_drive` subpackage of the -`flashdreams-omnidreams` workspace member at -`integrations/omnidreams/omnidreams/interactive_drive/`. Its `flashdreams`, -`flashdreams-omnidreams`, and `ludus-renderer` deps resolve from the -workspace, so no separate SSH-keyed `git clone` of those projects is needed -beyond cloning `flashdreams` itself. - -**Hugging Face token.** Scenes and the Cosmos-Reason1 text encoder are -downloaded from Hugging Face, so `HF_TOKEN` must be set in any shell where -you run `omnidreams-prepare` or `interactive-drive`. Create a token at -[`huggingface.co/settings/tokens/new`](https://huggingface.co/settings/tokens/new) -if you don't already have one, and request access to the -[`nvidia/omni-dreams-scenes`](https://huggingface.co/datasets/nvidia/omni-dreams-scenes) -dataset before the first run. - -```bash -export HF_TOKEN= # gates nvidia/omni-dreams-scenes -``` - -On Windows, set the same value as a user or session environment variable -named `HF_TOKEN` instead of using `export`. - -If your environment uses another authorized Hugging Face org, pass -`--hf-org ` to `omnidreams-prepare` and `interactive-drive`, or set -`OMNI_DREAMS_HF_ORG=` once in your shell. OmniDreams scene URLs -read from the world-model manifest are rewritten to the selected org; -unrelated upstream repos (`lightx2v/Autoencoders`, `nvidia/Cosmos-Reason1-7B`) -stay untouched. - -### 2. Pick an environment - -Pick **one** of the two paths below, then continue to step 3. - -#### Option A — Native (host-installed toolchain) - -The simplest path if you already have `uv`, a CUDA toolkit, and SDL/Vulkan -on the host (see the [flashdreams root README](../../../../README.md) for the recommended -hardware and CUDA setup). No additional work in this step — proceed to -step 3 from the flashdreams workspace root. - -#### Option B — Docker (build a local image) - -If you'd rather skip installing CUDA, SDL, and the EGL toolchain on the -host, the bundled `docker/Dockerfile` builds an end-to-end Linux -environment locally. See [`docker/README.md`](../../../../docker/README.md) -for the full build docs; the short version is below. Additional -prerequisites: - -- Linux host (Wayland-based local windowing assumes Linux; Windows users - should use the native path above) -- Docker + `nvidia-container-toolkit` - -1. **Build the image** from the `flashdreams` repo root: - - ```bash - docker build -t flashdreams:local -f docker/Dockerfile . - ``` - -2. **Launch the container** from the same `flashdreams` repo root. The - repo bind-mount lands at `/workspace/flashdreams` and the workdir - leaves you at the flashdreams workspace root (the same place you'd - run uv from on a native host): - - ```bash - docker run --rm -it \ - --gpus all --ipc=host --network=host \ - -v "$PWD":/workspace/flashdreams \ - -v "$HOME/.cache/huggingface":/root/.cache/huggingface \ - -w /workspace/flashdreams \ - -e NVIDIA_DRIVER_CAPABILITIES=all \ - -e HF_TOKEN="$HF_TOKEN" \ - -e HF_HOME=/root/.cache/huggingface \ - -e UV_PROJECT_ENVIRONMENT=/root/.venv \ - -v /run/user/$(id -u)/wayland-0:/run/user/0/wayland-0:rw \ - --device /dev/dri \ - -e WAYLAND_DISPLAY=wayland-0 \ - -e XDG_RUNTIME_DIR=/run/user/0 \ - -e SDL_VIDEODRIVER=wayland \ - flashdreams:local \ - bash - ``` - -3. **Install EGL inside the container.** The world-model backend renders - frames via EGL on both run paths (HUD and `--no-hud` bare Vulkan - window), so this step is required regardless of which one you use: - - ```bash - apt-get update && apt-get install -y --no-install-recommends \ - libegl-dev libgl-dev && \ - mkdir -p /usr/share/glvnd/egl_vendor.d && \ - cat > /usr/share/glvnd/egl_vendor.d/10_nvidia.json <<'EOF' - { - "file_format_version": "1.0.0", - "ICD": { "library_path": "libEGL_nvidia.so.0" } - } - EOF - ``` - -> [!TIP] -> If `uv sync` in step 3 below ever appears to hang, re-run it with `-vv` — -> the most common cause is an SSH host-key prompt for a remote that isn't -> yet in `known_hosts`. - -### 3. Sync and stage assets - -Run everything from the **flashdreams workspace root** — the standard -flashdreams convention. Ludus always installs NVIDIA PhysX because simulation -has one supported physics implementation. The `interactive-drive` extra adds -only `slangpy`, the local-window presentation runtime. +Install the repository prerequisites from the +[FlashDreams README](../../../../README.md). Set `HF_TOKEN` to a token with +access to `nvidia/omni-dreams-scenes` and `nvidia/omni-dreams-models`: ```bash -uv sync --package flashdreams-omnidreams --extra interactive-drive -uv run --package flashdreams-omnidreams omnidreams-prepare \ - --scene-uuid clipgt-0d404ff7-2b66-498c-b047-1ed8cded60d4 +export HF_TOKEN= # Linux ``` -`uv sync --extra interactive-drive` installs the full demo runtime (slangpy + Ludus -front end, flashdreams + flashdreams-omnidreams pipeline). -`omnidreams-prepare` stages the requested scene USDZ from the -resolved scenes dataset -(`nvidia/omni-dreams-scenes` by default, or another authorized org when -`OMNI_DREAMS_HF_ORG` / `--hf-org` points there), pre-warms the -Cosmos-Reason1 text encoder used at runtime (~14 GB of Hugging Face cache), -and pre-downloads the world-model DiT checkpoint from -`nvidia/omni-dreams-models` (a separate gated repo) so the first launch -isn't blocked on the multi-GB fetch — and so a missing-access error surfaces -here with an actionable hint rather than mid-demo. The first setup can take a -while depending on your network. Flashdreams owns video checkpoint selection -and cache layout for the selected recipe. - -> **Tip:** You can skip the `omnidreams-prepare` step for the -> *default* scene — `interactive-drive` will auto-stage it from -> `nvidia/omni-dreams-scenes` on first launch as long as `HF_TOKEN` is -> set. Run `omnidreams-prepare` explicitly when you want to stage -> multiple scenes ahead of time or pre-warm the Cosmos-Reason1 text -> encoder (~14 GB) so the first launch isn't blocked on it. - -Common `omnidreams-prepare` flags: - -- `--scene-uuid ` — stage only one specific scene instead of - all of them (every published weather variant of it). Useful on - bandwidth-constrained links (and a good first choice inside the - container). Browse available UUIDs on the - [scenes dataset page](https://huggingface.co/datasets/nvidia/omni-dreams-scenes/tree/main/scenes). -- `--scene-variant ` — with `--scene-uuid`, stage only - that weather variant instead of all of them. -- `--skip-hf-prewarm` — skip pre-warming Hugging Face model repos; - flashdreams will pull assets lazily on first use. -- `--skip-text-encoder` — skip the ~14 GB text-encoder prewarm when you're - using a precomputed prompt embedding or want a lighter first-time setup. -- `--skip-scene` — don't stage any scene (for when you're supplying your - own USDZ via ``scenario.scene`` in a local-window launch manifest). - -If `omnidreams-prepare` fails with `401`, `403`, or a gated-repo -error, verify `HF_TOKEN` and confirm you have requested (and been granted) -access to **both** `nvidia/omni-dreams-scenes` and -`nvidia/omni-dreams-models` — access to one is not access to the other. - -Once done, you should see the scene's variant archive(s) under the shared -scenes cache, one per weather: - -- `~/.cache/flashdreams/omnidreams-scenes/clipgt-.usdz` (and - `-rain` / `-snow` siblings when published) - -That directory (`$FLASHDREAMS_CACHE_DIR/omnidreams-scenes/`) is shared -with the WebRTC server: the desktop demo keeps the archives there and -the WebRTC session pipeline extracts each scene's `clipgt/` payload -under `[-]/` next to them. Both demos go through the same -`huggingface_hub` content-addressed cache for the actual download, so -the HF round-trip happens at most once per scene UUID regardless of -which demo you launch first. Hugging Face model snapshots live in the -normal HF cache; flashdreams manages its own video checkpoint -locations. - -### First-run behavior - -The first world-model launch can spend several minutes in loading and -optimization before the view becomes interactive. In the browser stream this -shows up as `Loading world model...` followed by `Optimizing world model...`. -That phase includes checkpoint loading, torch compilation / CUDA graph setup, -and Triton autotuning. Subsequent runs are usually much faster because cached -kernels and model assets are reused. - -During Triton autotuning you may see non-fatal messages such as -`Runtime error during autotuning: permute(sparse_coo)...`. Those indicate that -an autotuner candidate was rejected for the current tensor shape; the runtime -continues with a valid candidate. - -## Run - -All commands below are run from the **flashdreams workspace root**. The -`interactive-drive` CLI's defaults for `--scene`, `--manifest`, -`--scene-dir`, and `--wheel-profiles-dir` resolve to the bundled assets in -this subpackage (via `__file__`), so you don't have to pass long -`integrations/omnidreams/omnidreams/interactive_drive/...` paths unless -you want to override them. - -There is one public entry point — `flashdreams-run` — with ``local-window`` -and ``webrtc`` modes. Local-window presentation variants are selected in the -launch manifest: - -| Mode | When to use | How | -|---|---|---| -| **HUD (default)** | You have a graphical desktop session and want the full demo: scene/variant selector, steering wheel + pedals overlay, BEV minimap, keyboard *and* wheel input. | ``local-window`` with default output settings | -| **Bare backend, local window** | You want the lightweight setup: a single Vulkan window showing the world-model output, no HUD chrome. | ``local-window`` with ``output.no_hud: true`` | -| **Bare backend, browser** | The demo machine has no graphics-capable GPU (e.g. compute-only GB300) or you want to view from a laptop browser while the model runs elsewhere. Implies no HUD. | ``local-window`` with ``output.stream_mjpeg: :8080`` | - -Collision physics and the vehicle speed limit are off by default. Add -`--game-mode` to enable the speed limit and collisions with scene actors and -static map geometry, together with the collision visual effect: - -```bash -uv run --package flashdreams-omnidreams interactive-drive --game-mode +```powershell +$env:HF_TOKEN = "" # Windows PowerShell ``` -To keep collision physics but suppress the full-screen collision flare, combine -`--game-mode` with `--disable-visual-flare`. - -For a richer remote-viewing experience with a polished frontend and lower -latency than an in-process MJPEG stream, prefer the centralized ``webrtc`` -mode (see -[`integrations/omnidreams/README.md`](../../README.md)). +For the Linux container setup, see the +[Docker README](../../../../docker/README.md). -The HUD itself uses pygame/SDL2 for rendering, which keeps the demo responsive -in fullscreen at high display resolutions (press `F11` to toggle). It supervises -the headless backend as a subprocess on `127.0.0.1:<--port>` so the world model -keeps running across scene / variant switches without restarting the entire -process. - -### HUD mode (default) +## Commands ```bash -uv run --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest configs/launch_manifest/omnidreams_local_window.yaml -``` - -The default `--scene` resolves to -`$FLASHDREAMS_CACHE_DIR/omnidreams-scenes/clipgt-0d404ff7-2b66-498c-b047-1ed8cded60d4.usdz` -(staged on first launch via the HF auto-stage flow described above); -`--manifest` resolves to the bundled `configs/example_world_model.yaml`. -Pass a different `--scene` or `--manifest` to override. - -`--cuda-visible-devices` defaults to `auto`, which leaves whatever -`CUDA_VISIBLE_DEVICES` you already exported alone (or, on hosts without -the env var set, lets CUDA see every GPU). The HUD does not auto-pick a -GPU — on multi-GPU hosts where the default-zero pick is wrong, export -`CUDA_VISIBLE_DEVICES=` before launching or pass -`--cuda-visible-devices ` directly. `--cuda-visible-devices ""` -force-unsets the env var. - -The HUD also subscribes to the backend's `/bev_stream` and shows a top-down -BEV minimap below the steering and pedal controls; pass `--no-bev` to skip -the extra rasterizer dispatch when you don't need it. - -**Steering wheel support.** Drop a profile YAML (devices, axis map, FFB -settings) into `configs/wheels/` and the HUD will pick it up at startup. With -`--wheel-profile auto` (the default), the HUD scans `/dev/input/by-id` first, -then `/dev/input/event*`, and matches detected device names against each -profile's devices. To name a specific profile use `--wheel-profile ` -(matching the YAML filename); to bind a known device path directly use -`--wheel-device /dev/input/eventX` (this names the wheel/steering device); -to disable wheel input entirely use `--no-wheel`. No profiles ship with the -repo — keyboard-only driving works fine without one. - -**Multi-device profiles.** A profile binds one or more devices, so steering, -throttle, brake, and buttons can each live on a different device — a wheel -base plus a separate-brand or separately-connected pedal set, for example. -Each device is listed under `devices` with its own `detection_patterns`, and -every axis/button is a `{device, code}` binding naming the device by index: - -```yaml -devices: - - {display_name: Base, detection_patterns: ["Fanatec CSL DD"]} - - {display_name: Pedals, detection_patterns: ["Heusinkveld"]} -axis_map: - steering: {device: 0, code: 0} # wheel base - throttle: {device: 1, code: 0} # separate pedals - brake: {device: 1, code: 1} -``` - -At launch each device is matched independently by name; the steering device -is required, while a device used only by other controls degrades gracefully -(a warning, those controls inactive) if unplugged. Older single-device -profiles (top-level `detection_patterns` + bare integer codes) still load. -Device 0 (the steering device) is the one that produces force feedback. +# installs the demo; required once. +uv sync --package flashdreams-omnidreams --extra interactive-drive -**Force feedback (multi-vendor).** A profile's `ffb.mode` selects how the -centering force is rendered, and defaults to `auto`, which inspects the -device's advertised Linux FF effects and picks the right backend: +#stages the default scene, prewarms model assets, and syncs native sources; required for +#omnidreams-perf`, otherwise optional. +uv run --package flashdreams-omnidreams omnidreams-prepare --perf --scene-uuid clipgt-0d404ff7-2b66-498c-b047-1ed8cded60d4 -- `autocenter` — a driver-managed spring written via `FF_AUTOCENTER`. - Used by Thrustmaster and Logitech wheels. -- `constant_force` — a self-rendered spring uploaded via the `FF_CONSTANT` - effect, where the app computes the force each tick. This is the universal - path and is required for Fanatec wheels, whose `hid-fanatecff` driver does - not expose `FF_AUTOCENTER`. +# launches the default interactive configuration; required to run the demo. +uv run --package flashdreams-omnidreams flashdreams-run omnidreams local-window -With `mode: auto` (or the wizard's "Auto"), a Fanatec base automatically -falls back to constant force while Thrustmaster/Logitech keep their managed -autocenter. Set `mode: constant_force` explicitly if a Logitech's in-kernel -autocenter feels too weak. Driver prerequisites: most modern Thrustmaster -wheels (T300RS, T248, TX, T-GT II, TS-PC, TS-XW, …) need the out-of-tree -[`hid-tmff2`](https://github.com/Kimplul/hid-tmff2) module plus a wheel-mode -init (`hid-tminit`, or `tmdrv` for TX/TS-XW); Fanatec needs the -[`hid-fanatecff`](https://github.com/gotzl/hid-fanatecff) module with the -base in PC mode (red LED); Logitech G29/G27/G923-PS use the in-kernel -`hid-lg4ff` or [`new-lg4ff`](https://github.com/berarma/new-lg4ff), while the -G920 and Xbox/PC G923 use the HID++ driver (kernel >= 6.3). FFB writes need -access to `/dev/input/*` (add your user to the `input` group). +# launches the prepared performance configuration; optional alternative. +uv run --package flashdreams-omnidreams flashdreams-run omnidreams-perf local-window --manifest configs/launch_manifest/omnidreams_local_window.yaml -**Generate an input profile (wheel or game controller).** Instead of -hand-writing that YAML, run the calibration wizard: +# launches the prepared performance configuration with vulkan backend; optional alternative. +uv run --package flashdreams-omnidreams flashdreams-run omnidreams-perf local-window --manifest configs/launch_manifest/omnidreams_local_window_vulkan.yaml -```bash +# configures a wheel or game controller; optional. uv run --package flashdreams-omnidreams interactive-drive-configuration -``` - -It shows a live panel -- a steering-wheel and pedal visualization plus a -per-axis activity strip -- so you can confirm the right device and watch each -control move. Ctrl+click to select more than one device when your controls -are split across devices (e.g. a wheel base plus a separate pedal set); the -wizard listens to all selected devices at once and binds each control to -whichever device it actually moved on. It then listens while you move each -control to capture the correct axes and directions (self-centering sticks and -force-feedback wheels work because it peak-holds each axis' range rather than -snapshotting after you let go), lets you bind reverse / reset / exit-scene -buttons and test force feedback, then writes the profile to -`$FLASHDREAMS_CACHE_DIR/interactive-drive/wheels/` (by default under -`~/.cache/flashdreams/`). The next `interactive-drive` launch discovers it -automatically through the same `--wheel-profile auto` detection. The wizard -supports both steering wheels (with pedals) and game controllers (analog -stick plus triggers); the generated file stays on your machine and is never -committed. It needs a graphical session and read access to `/dev/input/*` -(add your user to the `input` group if no devices are found). - -The opening screen also lists your saved profiles so you can edit their -settings (display name, steering range and deadzone, inversion, force -feedback mode and gain, detection patterns), choose which one is the -default, or delete them. Steering range and deadzone are most useful for game controllers, -whose sticks are sensitive and tend to drift -- lower the range to make -steering less twitchy and raise the deadzone to ignore a drifting stick at -rest. - -### `--no-hud`: bare backend, local Vulkan window - -This is the lighter-weight path that matches the older standalone -`interactive-drive` script: a single Vulkan window for the omnidreams -output, no HUD chrome, no scene selector. - -```bash -uv run --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest path/to/local-window-with-no-hud.yaml -``` - -You should initially see the generated driving view. Press `2` to switch to the -HD map view (conditioning input) and `1` to switch back to the photorealistic -output. - -### `--stream-mjpeg`: bare backend served over HTTP - -Use this when the demo machine has no graphics-capable GPU (e.g. a -compute-only GB300 in a DGX Station), when you're connecting over the -network, or when you want to demo from a laptop browser while the model -runs elsewhere. Implies `--no-hud` because the user is then viewing -through a browser, not a local Vulkan window — the slangpy HUD itself -is a Vulkan presenter, so it can't run on the same hosts that need -``output.stream_mjpeg`` in the launch manifest. -```bash -uv run --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest path/to/local-window-mjpeg.yaml -``` - -Open `http://:8080/` in a browser on the same network; keyboard -events posted from the page are forwarded to the demo over the same socket. -The flag accepts `8080`, `:8080`, or `0.0.0.0:8080` (all equivalent — bind -on all interfaces); pass an explicit host (`127.0.0.1:8080`) to restrict -the listener to a single interface. - -The browser viewer ships an HTML/CSS HUD overlay so the headless demo -matches the desktop modes' affordances: - -- A **scene picker** in the upper-right lists the same scenes the - slangpy HUD discovers (anything under `--scene-dir`, defaulting to - `$FLASHDREAMS_CACHE_DIR/omnidreams-scenes/`). Pick a scene and a - variant, click *Load Scene*, and the demo tears down the current - rollout and rebuilds with the new scene without dropping the - browser session — the stream pauses briefly during the rebuild and - resumes the moment the new pipeline produces its first chunk. The - picker is hidden when no scenes were discovered. -- A **speed readout** in the lower-left, rendered in MPH, polls the - server's `/state` endpoint at 10 Hz. Reads `--` until the simulation - has produced its first chunk; numeric the moment chunks start - arriving. -- **WASD chiclets** light up while the corresponding direction key is - held. The page tracks the `keydown`/`keyup` set locally so the - highlight is zero-latency (no server round-trip); arrow keys light - the same chiclets as their letter equivalents. -- **Auto-crawl**: releasing throttle keeps the ego creeping toward - ~10 mph (4.47 m/s) instead of coasting to a stop, matching the - alpasim manual-driver behaviour and the slangpy HUD's keyboard - path. The `--stream-mjpeg` presenter routes browser keypresses - through the same `KeyboardDriveState` integrator the desktop HUD - uses, so it posts `DriverCommand(manual_control=True, ...)` which - unlocks the creep branch in `EgoVehicleKinematics.integrate_vehicle`. - -If you're running on a remote box (cloud GPU, lab machine, headless -server), the demo port may not be reachable directly from your laptop. -Forward the port over SSH (or your provisioner's CLI) and open the -forwarded URL instead — for example: - -```bash -ssh -L 8080:localhost:8080 @ -``` - -Then open `http://localhost:8080/`. - -For a richer browser frontend with lower latency, prefer the centralized -``webrtc`` launch mode. - -#### Fully headless MJPEG with auto-start - -By default the streaming mode waits for the browser scene picker before it -loads anything, so a freshly launched server idles on "Select a scene to -begin" until someone opens the page. To run with no GUI/browser interaction -add `--auto-start`. It skips the scene selection and immediately loads `--scene` -(or the first scene discovered under `--scene-dir` when `--scene` is unset -or not yet staged): - -```bash -uv run --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest path/to/headless-auto-start.yaml -``` - -The interactive-drive CUDA fast path is enabled by default. HDMap raster frames -stay CUDA-backed for world-model conditioning, and both Vulkan presenters use -SlangPy CUDA interop for generated RGB frames when the model output is still on -CUDA: - -```bash -uv run --no-sync --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest configs/launch_manifest/omnidreams_local_window.yaml -``` - -The packaged interactive manifests leave the one-shot image/per-chunk HDMap -encoders and display decoder eager (`compile_encoders: false` and -`compile_decoder: false`) to reduce first-scene latency. Native DiT compilation -remains enabled for steady generation. Prewarmed deployments can enable either -wrapper when measurements justify its additional startup cost. - -Set `INTERACTIVE_DRIVE_DISABLE_CUDA_INTEROP=1` to force the conservative host -path for both HDMap raster conditioning and presenter CUDA interop. In HUD mode, -chrome is still rendered with PIL on the CPU, then uploaded as an alpha overlay; -the generated camera frame stays lazy on CUDA and is resized/composited into the -shared presentation buffer on the CUDA stream. Use `--no-hud` with the same -environment variable for the bare presenter. - -Controls (apply in all three modes): - -- `W` throttle -- `S` brake / reverse drag -- `A` steer left -- `D` steer right -- arrow keys mirror `W/A/S/D` -- `Space` stop -- `1` generated driving view -- `2` HD map view -- `3` first-person PhysX collider view (actor chassis and invisible walls) -- `R` reset rollout -- `X` exit scene (return to the scene selector; HUD mode only) -- `Esc` quit - -The browser control hint is static today, so it does not confirm every keydown -visually. If the world-model backend is still producing a chunk, input can be -accepted before the visual response arrives. - -### Interactive startup profile - -The packaged encoder/decoder policy is recommended for interactive sessions. -On an RTX PRO 6000 Blackwell (driver 596.72, CUDA 13.0, PyTorch 2.12.1), a warm -native-extension run on 2026-07-31 measured 32.0 s from process start through -one steady chunk, versus 87.3 s with compiled encoder/decoder wrappers. Model -warmup was 14.95 s, the first chunk was 5.73 s, and the next 8-frame chunk was -356.6 ms. The compiled-wrapper baseline's steady chunk was 319.7 ms, so this -trades about 37 ms per chunk for roughly 55 s less startup. - -FlashDreams stores Inductor FX-graph and Triton cubin artifacts together under -`$FLASHDREAMS_CACHE_DIR/torchinductor` (by default -`~/.cache/flashdreams/torchinductor`). Set `TORCHINDUCTOR_CACHE_DIR` to override -that location. Keep the FX-graph and `triton/` subtrees together when copying or -cleaning this cache; deleting only one side forces kernel recovery on the next -compiled run. - -```bash -uv run --no-sync --package flashdreams-omnidreams interactive-drive \ - --manifest example_world_model_perf.yaml --synthetic-model \ - --synthetic-scene --auto-start --stream-mjpeg 127.0.0.1:18765 \ - --stop-after-chunks 1 --no-bev --profile-world-model -``` - -The simulation uses fixed timesteps and a PhysX-first object graph owned by -Ludus. Interactive-drive maps typed scene tracks into that graph. Throttle and -braking preserve momentum; steering -feeds a bicycle-model yaw target and lateral tire grip; a spring-damper adds -game-style body pitch and roll. Every semantic type has a fixed mass (cars -1,550 kg, trucks 8,000 kg, buses 12,000 kg, trailers 10,000 kg). Each road -vehicle also carries dimension-derived chassis geometry and four per-instance -wheel contacts. PhysX raycasts those wheels against static geometry and applies -spring, damper, cornering, friction, and rolling-resistance forces at their -contact points. Recorded position and heading samples are controller targets: -bounded forces and torques ask each actor to follow its track, but no track pose -is written into the body after creation. Non-ego track-driving commands are -limited to 15 mph; collision impulses remain ordinary rigid-body forces rather -than being velocity-clamped. PhysX therefore owns translation, -vertical suspension travel, body attitude, rigid-body contact, and -mass-dependent momentum transfer without locking any axis. A struck actor -remains an integrated vehicle body instead of reverting to a sliding visual box. -When an impact meets the collision visual effect's 5 mph speed-change threshold, -traffic AI suppresses the struck vehicle's track-driving command so that only -its transferred momentum moves it. Driving is restored only after the body has -remained stationary for one continuous simulated second; the native physics -layer owns neither that timer nor that decision. - -Road-boundary, curb, building, house, and wall line/polygon layers are solid -barriers. The large scene AABB remains a separate last-resort respawn boundary. -The complete typed scene stays in the abstract graph for rendering; Ludus -copies a 350 m active window into PhysX and coalesces densely sampled map -strokes into roughly 2 m collision walls. This keeps long-HD-map preload cost -bounded without dropping far-away objects from RGB or BEV rendering. -For active actors, Ludus renders the authoritative per-frame PhysX poses as -oriented HD-map boxes for both RGB and BEV/model inputs. The first topology -change replaces one scene slot; subsequent chunks update the actor cube pool in -place without clearing static map or camera buffers. - -``GameEntity.to_game_engine_dict()`` and -``DynamicActorTrajectory.to_game_engine_dict()`` expose JSON-compatible -component data and timestamped transform keyframes for an external game engine. - -### Generated-frame e2e profiling - -Set `INTERACTIVE_DRIVE_PROFILE_INPUT_TO_PRESENT=1` to log generated-frame -input-to-present timing while the demo runs: +## Launch manifest -```bash -INTERACTIVE_DRIVE_PROFILE_INPUT_TO_PRESENT=1 \ - uv run --no-sync --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest path/to/auto-start-local-window.yaml -``` - -The log line is `[profile] e2e ...`. `wall_present_fps` counts only frames -consumed from the model pipeline queue, so loading-frame or hold-frame -re-presents are excluded. `avg_adj_control_to_present_ms` subtracts the -intentional per-frame spacing inside a generated chunk; the raw value is also -printed for debugging. Set -`INTERACTIVE_DRIVE_PROFILE_INPUT_TO_PRESENT_INTERVAL_S` to adjust the report -period; the default is `2`. - -### Rollout drift and resets - -OmniDreams generates video autoregressively, so long rollouts can accumulate -artifacts such as diagonal striping, color bleeding, or distorted geometry, -especially after extended driving without a reset. This does not necessarily -mean the demo is broken. Press `R` to restart from the scene's initial clean -state. For long demos, reset every 30-50 generated chunks or whenever visual -quality starts to drift. - -### Out-of-bounds warning and auto-respawn - -The demo also auto-resets when you drive off the navigable area. The -implementation mirrors alpasim's ``is_ego_off_map`` algorithm: at scene -load time the demo computes an axis-aligned bounding box of **every** -spatial layer in the scene (lane markers, drivable triangles, -polygons, vehicle tracks, ground mesh) and prints it to stderr, e.g. - -``` -[ego_vehicle_kinematics] map bounds: x=[-127.4, 218.9] (346.3 m), y=[-89.6, 142.3] (231.9 m). Adds 50 m margin + 100 m warning zone for OOB. -``` - -Each chunk, the simulation computes how far the ego is from this AABB -expanded by a 50 m margin and the loop reacts to it in two stages: - -- **Approaching the edge** (proximity ramps `0.0 → 1.0` across the - 100 m warning zone inside the AABB+margin edge): the warning text - *"Approaching map edge, turn back to avoid respawn"* is overlaid on - the current frame. Steering back into the navigable area clears it - on the next chunk. -- **Out of bounds** (proximity = `2.0`, set when the ego has actually - crossed the AABB+margin boundary): the overlay flips to - *"Respawning..."* and the loop triggers the same reset path that `R` - uses. - -Crucially, the respawn is a **binary** trigger — it fires only when -the ego is actually past the AABB+margin edge, not when it's somewhere -in the warning ramp. Driving on a sidewalk, brushing curbs, or -crossing sparse-mesh patches *inside* the navigable area never trigger -a teleport; only flying off the entire mapped area does. Because the -AABB is the union of all geometry (not just the ground mesh, which is -often a small strip representing only the road surface), it covers the -full extent of where the scene "contains" content. - -The loop logs every state transition to stderr so you can confirm the -thresholds are firing at the right time: - -``` -[loop] oob 'in-bounds' -> 'Approaching map edge…' proximity=0.620 streak=0 action=warning -[loop] oob 'Approaching map edge…' -> 'Respawning...' proximity=2.000 streak=1 action=firing respawn -``` - -Five CLI flags expose the OOB knobs: +Copy `configs/launch_manifest/omnidreams_local_window.yaml` and adjust these +basic fields: -| Flag | Default | Effect | -|---|---|---| -| `--oob-margin-m` | `50` | Margin (m) added around the geometry AABB. Bigger = more room before the boundary. | -| `--oob-warning-zone-m` | `100` | Depth (m) of the warning-ramp band inside the AABB+margin edge. Set to `0` to disable the ramp. | -| `--oob-warn-proximity` | `0.6` | Lower values warn earlier. | -| `--oob-respawn-proximity` | `2.0` | Default `2.0` matches alpasim's binary "off map" sentinel. Set to `2.5` (or any value > `2.0`) to disable auto-respawn entirely while keeping the warning overlay. | -| `--oob-respawn-debounce-chunks` | `1` | Default `1` matches alpasim. Higher values add a per-chunk buffer. | - -Both messages render through the standard `status_message` overlay, so -they look identical across the HUD, `--no-hud`, and `--stream-mjpeg` -presenters. Scenes that ship no spatial geometry report proximity -`0.0` and never auto-respawn -- you get the same behaviour as the -older builds. - -### Without HD-map data (synthetic scene) - -Use `--synthetic-scene` to skip the USDZ download entirely. interactive-drive -builds a procedural 2-lane road with a single intersection at startup and -feeds it to the same loader the regular flow uses: - -```bash -uv run --package flashdreams-omnidreams omnidreams-prepare --skip-scene -uv run --package flashdreams-omnidreams flashdreams-run \ - omnidreams-perf local-window \ - --manifest path/to/synthetic-scene-local-window.yaml -``` - -The world model is trained on natural driving frames, so passing your own -forward-facing road photo through `--synthetic-initial-rgb` makes the -generation start from a believable RGB instead of the scene_fixture's debug -gradient. Any aspect ratio works; the loader resizes to the raster -resolution. `--synthetic-prompt` similarly overrides the embedded text prompt. - -The procedural road is a **20 km** golden track lined with periodic -streetlamp-style poles (~50 m spacing), parked cars on alternating -shoulders (~150 m spacing), and traffic signs on alternating shoulders -(~200 m spacing) so the scene doesn't look empty. The centerline is a -sum-of-sines so the road varies naturally instead of feeling like the -same kilometre on repeat. There's no per-session length knob -- the -track is generous enough that no demo realistically reaches the end. - -## Develop - -Lint and type-check via the workspace-wide pre-commit hooks -([`flashdreams/.pre-commit-config.yaml`](../../../../.pre-commit-config.yaml)); -install once from the flashdreams workspace root with -`uv run pre-commit install`. - -Run the subpackage's test suite (CPU subset) from the flashdreams workspace -root: - -```bash -uv sync --package flashdreams-omnidreams --extra interactive-drive --extra dev -uv run --no-sync --package flashdreams-omnidreams pytest \ - integrations/omnidreams/tests/interactive_drive -m "not gpu and not xvfb" -``` - -Root CI's `pytest -m ci_cpu` / `pytest -m ci_gpu` also pick up these tests -automatically — the subpackage's `tests/conftest.py` auto-stamps each test -with the right workspace CI-tier marker based on its existing -`gpu` / `xvfb` markers. - -Pass `--synthetic-model` (or `synthetic_model: true` in the manifest) to run -the world model on local random-initialized weights, so latency/code-path -tests run with no checkpoint downloads. - -The hook does not auto-fix. Use `./scripts/check.sh --fix` to clean up lint and -format issues explicitly. +```yaml +schema_version: 1 +runner: omnidreams-perf +mode: local-window + +scenario: + auto_start: true + game_mode: true + preload_scenes: false + +output: + world_model_manifest_path: ../../integrations/omnidreams/omnidreams/interactive_drive/configs/example_world_model_perf.yaml + ludus_backend: vulkan # cuda (default) or vulkan + no_hud: false +``` + +Useful optional fields are `scenario.scene`, `scenario.disable_visual_flare`, +`scenario.no_wheel`, `output.stream_mjpeg`, and `output.bev`. Run +`uv run flashdreams-run omnidreams-perf local-window --help` for all model +options. + +## Controls + +- `W` / `S`: forward / reverse +- `A` / `D`: steer left / right +- Arrow keys: same as `W` / `A` / `S` / `D` +- `Space`: stop +- `1`: generated driving view +- `2`: HD-map conditioning view +- `3`: PhysX debug view +- `R`: reset rollout +- `X`: return to scene selection in HUD mode +- `Esc`: quit diff --git a/integrations/omnidreams/omnidreams/interactive_drive/cli.py b/integrations/omnidreams/omnidreams/interactive_drive/cli.py index acbcce31f..af63c5514 100644 --- a/integrations/omnidreams/omnidreams/interactive_drive/cli.py +++ b/integrations/omnidreams/omnidreams/interactive_drive/cli.py @@ -165,6 +165,15 @@ def build_parser() -> argparse.ArgumentParser: default="cuda", help="SlangPy device used for raster compute; presenter still uses Vulkan for swapchain", ) + parser.add_argument( + "--ludus-backend", + choices=("cuda", "vulkan"), + default="cuda", + help=( + "Ludus HD-map renderer backend. Vulkan uses CUDA-shared external " + "memory and a task/mesh/fragment graphics pipeline with compute export." + ), + ) parser.add_argument( "--sync-gpu-timing", action=argparse.BooleanOptionalAction, @@ -475,6 +484,7 @@ def prepare_config_and_backend( manifest_path=manifest_path, raster=RasterConfig( compute_device=args.compute_device, + ludus_backend=args.ludus_backend, sync_gpu_timing=args.sync_gpu_timing, ), world_model_profile=WorldModelProfileConfig( diff --git a/integrations/omnidreams/omnidreams/interactive_drive/config.py b/integrations/omnidreams/omnidreams/interactive_drive/config.py index c0cd3e654..e1fa299ae 100644 --- a/integrations/omnidreams/omnidreams/interactive_drive/config.py +++ b/integrations/omnidreams/omnidreams/interactive_drive/config.py @@ -12,6 +12,7 @@ BackendName = Literal["raster", "omnidreams"] ViewMode = Literal["rgb", "model_rgb", "physx"] ComputeDeviceName = Literal["automatic", "cuda", "vulkan"] +LudusBackendName = Literal["cuda", "vulkan"] @dataclass(frozen=True) @@ -34,6 +35,7 @@ class RasterConfig: width: int = 1280 height: int = 704 compute_device: ComputeDeviceName = "cuda" + ludus_backend: LudusBackendName = "cuda" sync_gpu_timing: bool = False perf_log_interval_frames: int = 20 near_plane_m: float = 0.1 diff --git a/integrations/omnidreams/omnidreams/interactive_drive/rasterizer.py b/integrations/omnidreams/omnidreams/interactive_drive/rasterizer.py index 0732f6282..d26aa57c8 100644 --- a/integrations/omnidreams/omnidreams/interactive_drive/rasterizer.py +++ b/integrations/omnidreams/omnidreams/interactive_drive/rasterizer.py @@ -21,6 +21,7 @@ from ludus_renderer import ( FThetaCamera, LudusCudaTimestampedContext, + LudusVulkanTimestampedContext, MutableObjectSceneBuffer, ) from ludus_renderer import ( @@ -114,10 +115,16 @@ def __init__(self, raster: RasterConfig, bev: BevConfig | None = None) -> None: "using host raster frames", ) - logger.info("[rasterizer] ludus_backend=cuda") - self.ctx = LudusCudaTimestampedContext(device=self._device) + context_type = { + "cuda": LudusCudaTimestampedContext, + "vulkan": LudusVulkanTimestampedContext, + }[raster.ludus_backend] + logger.info(f"[rasterizer] ludus_backend={raster.ludus_backend}") + self.ctx = context_type(device=self._device) self.ctx.set_depth_scaling(True) - self.ctx.set_msaa_samples(4) + # The Vulkan color-attachment/compute-export path is single-sample; + # the CUDA backend retains its existing 4x path. + self.ctx.set_msaa_samples(1 if raster.ludus_backend == "vulkan" else 4) # Keep adaptive cube tessellation enabled. F-theta projection curves # box faces near the image boundary; forcing level zero turns each face # into two long screen-space triangles and visibly warps edge colliders. diff --git a/integrations/omnidreams/omnidreams/launch.py b/integrations/omnidreams/omnidreams/launch.py index 531f801d3..de1234172 100644 --- a/integrations/omnidreams/omnidreams/launch.py +++ b/integrations/omnidreams/omnidreams/launch.py @@ -75,6 +75,8 @@ "synthetic_initial_rgb", "synthetic_prompt", "auto_start", + "game_mode", + "disable_visual_flare", "preload_scenes", "wheel_profile", "wheel_profiles_dir", From e221dba6442e93a9bb8ecba5e5c43af923f72289 Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 05:36:45 -0700 Subject: [PATCH 2/7] address greptile --- .../_cpp/bindings/torch_rasterize_vk.cpp | 27 ++++--- .../_cpp/render/ludus_timestamped_vk.cpp | 71 ++++++++++++------- .../ludus_renderer/_cpp/render/ludus_vk.h | 10 +-- 3 files changed, 70 insertions(+), 38 deletions(-) diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp index feb6c9628..e71f8917a 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp @@ -400,17 +400,22 @@ torch::Tensor ludus_timestamped_render_batch_vk( width, height, numQueries); auto sharedState = stateWrapper.sharedState; const int cudaDeviceIdx = stateWrapper.cudaDeviceIdx; + const cudaStream_t outputStream = stream; torch::Tensor out = torch::from_blob( sharedOutput, {numQueries, height, width, 4}, - [sharedState, outputSlot, cudaDeviceIdx](void*) { - // Record the release on the consumer's current stream. A - // future render stream waits this event before signaling the - // CUDA->Vulkan timeline value for slot reuse. + [sharedState, outputSlot, cudaDeviceIdx, outputStream](void*) { + // The deleter can run while an unrelated stream is current. + // Record release on the stream that exposed this tensor so + // same-stream consumers queued before destruction complete + // before Vulkan reuses the slot. As with ordinary CUDA + // allocations, a caller using the tensor on another stream + // must order that work back to its stream of origin before + // dropping the final reference. if (cudaSetDevice(cudaDeviceIdx) == cudaSuccess && cudaEventRecord( sharedState->releaseEvents[outputSlot], - at::cuda::getCurrentCUDAStream(cudaDeviceIdx)) + outputStream) == cudaSuccess) { sharedState->releaseRecorded[outputSlot].store( true, std::memory_order_release); @@ -476,12 +481,18 @@ torch::Tensor ludus_timestamped_get_staging_data_vk( { std::lock_guard state_lock(stateWrapper.stateMutex); LudusTimestampedVkState& s = *stateWrapper.pState; - int w = s.stagingWidth, h = s.stagingHeight, n = s.stagingNumQueries; + TORCH_CHECK(stagingIdx >= 0 && stagingIdx < 2, + "invalid Vulkan staging slot ", stagingIdx); + TORCH_CHECK(s.stagingValid[stagingIdx], + "Vulkan staging slot ", stagingIdx, " has no pending frame"); + int w = s.stagingWidth[stagingIdx]; + int h = s.stagingHeight[stagingIdx]; + int n = s.stagingNumQueries[stagingIdx]; auto opts = torch::TensorOptions().dtype(torch::kUInt8).device(torch::kCUDA, stateWrapper.cudaDeviceIdx); torch::Tensor out = torch::empty({n, h, w, 4}, opts); - ludusCopyStagingToOutputVk(NVDR_CTX_PARAMS, s, stagingIdx, - out.data_ptr(), w, h, n); + ludusCopyStagingToOutputVk( + NVDR_CTX_PARAMS, s, stagingIdx, out.data_ptr()); return out; } diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp index 4490d7066..ddff26e82 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp @@ -1385,21 +1385,23 @@ int ludusCopyBatchResultsToStagingVk( s.currentStagingIdx = 1 - idx; size_t totalSize = (size_t)width * height * 4 * numQueries; - if (totalSize > s.stagingBufferSize) { - for (int i = 0; i < 2; i++) { - if (s.stagingBuffer[i]) cudaFree(s.stagingBuffer[i]); - cudaMalloc(&s.stagingBuffer[i], totalSize); - s.stagingValid[i] = 0; - } - s.stagingBufferSize = totalSize; + if (totalSize > s.stagingBufferSize[idx]) { + // Only resize the selected slot. The other slot may still be pending + // retrieval with different dimensions and must remain untouched. + if (s.stagingValid[idx]) + cudaEventSynchronize(s.stagingReadyEvent[idx]); + if (s.stagingBuffer[idx]) cudaFree(s.stagingBuffer[idx]); + cudaMalloc(&s.stagingBuffer[idx], totalSize); + s.stagingBufferSize[idx] = totalSize; + s.stagingValid[idx] = 0; } ludusCopyBatchResultsVk(NVDR_CTX_PARAMS, s, stream, s.stagingBuffer[idx], width, height, numQueries); cudaEventRecord(s.stagingReadyEvent[idx], stream); - s.stagingWidth = width; - s.stagingHeight = height; - s.stagingNumQueries = numQueries; + s.stagingWidth[idx] = width; + s.stagingHeight[idx] = height; + s.stagingNumQueries[idx] = numQueries; s.stagingValid[idx] = 1; return idx; @@ -1407,11 +1409,17 @@ int ludusCopyBatchResultsToStagingVk( void ludusCopyStagingToOutputVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx, - uint8_t* outputPtr, int width, int height, int numQueries) + uint8_t* outputPtr) { (void)nvdr_ctx; + TORCH_CHECK(stagingIdx >= 0 && stagingIdx < 2, + "invalid Vulkan staging slot ", stagingIdx); + TORCH_CHECK(s.stagingValid[stagingIdx], + "Vulkan staging slot ", stagingIdx, " has no pending frame"); cudaEventSynchronize(s.stagingReadyEvent[stagingIdx]); - size_t size = (size_t)width * height * 4 * numQueries; + size_t size = (size_t)s.stagingWidth[stagingIdx] + * s.stagingHeight[stagingIdx] * 4 + * s.stagingNumQueries[stagingIdx]; cudaMemcpy(outputPtr, s.stagingBuffer[stagingIdx], size, cudaMemcpyDeviceToDevice); } @@ -1419,19 +1427,26 @@ int ludusStartAsyncHostTransferVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx) { (void)nvdr_ctx; + TORCH_CHECK(stagingIdx >= 0 && stagingIdx < 2, + "invalid Vulkan staging slot ", stagingIdx); if (!s.stagingValid[stagingIdx]) return -1; int pinnedIdx = s.currentPinnedIdx; s.currentPinnedIdx = 1 - pinnedIdx; - size_t size = (size_t)s.stagingWidth * s.stagingHeight * 4 * s.stagingNumQueries; - if (size > s.pinnedHostBufferSize) { - for (int i = 0; i < 2; i++) { - if (s.pinnedHostBuffer[i]) cudaFreeHost(s.pinnedHostBuffer[i]); - cudaMallocHost(&s.pinnedHostBuffer[i], size); - s.pinnedValid[i] = 0; - } - s.pinnedHostBufferSize = size; + const int width = s.stagingWidth[stagingIdx]; + const int height = s.stagingHeight[stagingIdx]; + const int numQueries = s.stagingNumQueries[stagingIdx]; + size_t size = (size_t)width * height * 4 * numQueries; + if (size > s.pinnedHostBufferSize[pinnedIdx]) { + // Preserve the other pinned result while this slot grows. + if (s.pinnedValid[pinnedIdx]) + cudaEventSynchronize(s.pinnedReadyEvent[pinnedIdx]); + if (s.pinnedHostBuffer[pinnedIdx]) + cudaFreeHost(s.pinnedHostBuffer[pinnedIdx]); + cudaMallocHost(&s.pinnedHostBuffer[pinnedIdx], size); + s.pinnedHostBufferSize[pinnedIdx] = size; + s.pinnedValid[pinnedIdx] = 0; } cudaEventSynchronize(s.stagingReadyEvent[stagingIdx]); @@ -1439,9 +1454,9 @@ int ludusStartAsyncHostTransferVk( size, cudaMemcpyDeviceToHost, s.copyStream); cudaEventRecord(s.pinnedReadyEvent[pinnedIdx], s.copyStream); - s.pinnedWidth[pinnedIdx] = s.stagingWidth; - s.pinnedHeight[pinnedIdx] = s.stagingHeight; - s.pinnedNumQueries[pinnedIdx] = s.stagingNumQueries; + s.pinnedWidth[pinnedIdx] = width; + s.pinnedHeight[pinnedIdx] = height; + s.pinnedNumQueries[pinnedIdx] = numQueries; s.pinnedValid[pinnedIdx] = 1; return pinnedIdx; @@ -1467,6 +1482,10 @@ int ludusEncodeJpegBatchStagingVk( std::vector>& outJpegs) { (void)nvdr_ctx; + TORCH_CHECK(stagingIdx >= 0 && stagingIdx < 2, + "invalid Vulkan staging slot ", stagingIdx); + TORCH_CHECK(s.stagingValid[stagingIdx], + "Vulkan staging slot ", stagingIdx, " has no pending frame"); if (!s.nvjpegInitialized) { nvjpegCreateSimple(&s.nvjpegHandle); nvjpegEncoderStateCreate(s.nvjpegHandle, &s.nvjpegEncoderState, 0); @@ -1477,9 +1496,9 @@ int ludusEncodeJpegBatchStagingVk( cudaEventSynchronize(s.stagingReadyEvent[stagingIdx]); - int w = s.stagingWidth; - int h = s.stagingHeight; - int n = s.stagingNumQueries; + int w = s.stagingWidth[stagingIdx]; + int h = s.stagingHeight[stagingIdx]; + int n = s.stagingNumQueries[stagingIdx]; size_t layerSize = (size_t)w * h * 4; size_t rgbSize = (size_t)w * h * 3; diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h index 3032dbf47..6a91f7590 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h @@ -158,15 +158,17 @@ struct LudusTimestampedVkState // ---------- Double-buffered staging for async transfer ---------- uint8_t* stagingBuffer[2]; - size_t stagingBufferSize; - int stagingWidth, stagingHeight, stagingNumQueries; + size_t stagingBufferSize[2]; + int stagingWidth[2]; + int stagingHeight[2]; + int stagingNumQueries[2]; int currentStagingIdx; int stagingValid[2]; cudaStream_t copyStream; cudaEvent_t stagingReadyEvent[2]; uint8_t* pinnedHostBuffer[2]; - size_t pinnedHostBufferSize; + size_t pinnedHostBufferSize[2]; int currentPinnedIdx; int pinnedValid[2]; int pinnedWidth[2], pinnedHeight[2], pinnedNumQueries[2]; @@ -306,7 +308,7 @@ int ludusCopyBatchResultsToStagingVk( void ludusCopyStagingToOutputVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, int stagingIdx, - uint8_t* outputPtr, int width, int height, int numQueries + uint8_t* outputPtr ); int ludusStartAsyncHostTransferVk( From 1aee22addc9eec043f0ef7aec13a36f61b45a2e5 Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 06:23:45 -0700 Subject: [PATCH 3/7] cleanup code --- .../_cpp/bindings/torch_rasterize_vk.cpp | 38 +++++++++++++++++-- .../_cpp/render/ludus_timestamped_vk.cpp | 11 +++--- .../ludus_renderer/_cpp/render/ludus_vk.h | 2 +- 3 files changed, 40 insertions(+), 11 deletions(-) diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp index e71f8917a..55a2f22d8 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp @@ -135,6 +135,26 @@ class LudusTimestampedVkStateWrapper hasLastUseEvent = true; } + int acquireStagingSlot() + { + for (int attempt = 0; attempt < 2; ++attempt) { + const int slot = (pState->currentStagingIdx + attempt) % 2; + if (!pState->stagingValid[slot]) { + // Reserve before submitting any work. stateMutex serializes + // acquisition and consumption, so no atomic is needed here. + pState->stagingValid[slot] = 1; + pState->currentStagingIdx = (slot + 1) % 2; + return slot; + } + } + return -1; + } + + void releaseStagingSlot(int slot) + { + pState->stagingValid[slot] = 0; + } + int acquireOutputSlot() { for (int attempt = 0; attempt < LUDUS_VK_OUTPUT_SLOTS; ++attempt) { @@ -455,23 +475,31 @@ std::tuple ludus_timestamped_render_to_staging_vk( int width = std::get<1>(resolution); torch::Tensor poses_rdf = flu_to_rdf(camera_poses).transpose(-2, -1).contiguous(); - const int outputSlot = stateWrapper.acquireOutputSlot(); + const int stagingIdx = stateWrapper.acquireStagingSlot(); + if (stagingIdx < 0) + return std::make_tuple(-1, false); + + int outputSlot = -1; try { + outputSlot = stateWrapper.acquireOutputSlot(); stateWrapper.waitForOutputRelease(stream, outputSlot); ludusRenderBatchVk(NVDR_CTX_PARAMS, s, stream, reinterpret_cast(queries.data_ptr()), reinterpret_cast(poses_rdf.data_ptr()), numQueries, width, height, outputSlot); - int stagingIdx = ludusCopyBatchResultsToStagingVk( - NVDR_CTX_PARAMS, s, stream, width, height, numQueries); + ludusCopyBatchResultsToStagingVk( + NVDR_CTX_PARAMS, s, stream, stagingIdx, + width, height, numQueries); stateWrapper.recordLastUse(stream); // The staging copy is ordered before lastUseEvent, so the next wrapper // call cannot reuse this slot until that copy has completed. stateWrapper.releaseOutputSlot(outputSlot); return std::make_tuple(stagingIdx, true); } catch (...) { - stateWrapper.releaseOutputSlot(outputSlot); + if (outputSlot >= 0) + stateWrapper.releaseOutputSlot(outputSlot); + stateWrapper.releaseStagingSlot(stagingIdx); throw; } } @@ -493,6 +521,7 @@ torch::Tensor ludus_timestamped_get_staging_data_vk( ludusCopyStagingToOutputVk( NVDR_CTX_PARAMS, s, stagingIdx, out.data_ptr()); + stateWrapper.releaseStagingSlot(stagingIdx); return out; } @@ -509,6 +538,7 @@ py::list ludus_timestamped_encode_jpeg_batch_staging_vk( result.append(py::bytes(reinterpret_cast(data), size)); free(data); } + stateWrapper.releaseStagingSlot(stagingIdx); return result; } diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp index ddff26e82..e7c48a808 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp @@ -1379,10 +1379,12 @@ void ludusCopyBatchResultsVk( int ludusCopyBatchResultsToStagingVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, - int width, int height, int numQueries) + int idx, int width, int height, int numQueries) { - int idx = s.currentStagingIdx; - s.currentStagingIdx = 1 - idx; + TORCH_CHECK(idx >= 0 && idx < 2, + "invalid Vulkan staging slot ", idx); + TORCH_CHECK(s.stagingValid[idx], + "Vulkan staging slot ", idx, " was not reserved"); size_t totalSize = (size_t)width * height * 4 * numQueries; if (totalSize > s.stagingBufferSize[idx]) { @@ -1393,7 +1395,6 @@ int ludusCopyBatchResultsToStagingVk( if (s.stagingBuffer[idx]) cudaFree(s.stagingBuffer[idx]); cudaMalloc(&s.stagingBuffer[idx], totalSize); s.stagingBufferSize[idx] = totalSize; - s.stagingValid[idx] = 0; } ludusCopyBatchResultsVk(NVDR_CTX_PARAMS, s, stream, s.stagingBuffer[idx], width, height, numQueries); @@ -1402,8 +1403,6 @@ int ludusCopyBatchResultsToStagingVk( s.stagingWidth[idx] = width; s.stagingHeight[idx] = height; s.stagingNumQueries[idx] = numQueries; - s.stagingValid[idx] = 1; - return idx; } diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h index 6a91f7590..7b8ce7969 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h @@ -303,7 +303,7 @@ void ludusCopyBatchResultsVk( int ludusCopyBatchResultsToStagingVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, - int width, int height, int numQueries + int stagingIdx, int width, int height, int numQueries ); void ludusCopyStagingToOutputVk( From bb26e9444498ae26eae3c1ca084fcd25e572636f Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 06:39:14 -0700 Subject: [PATCH 4/7] add webrtc manifest for vulkan... I guess... --- .../omnidreams_webrtc_vulkan.yaml | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 configs/launch_manifest/omnidreams_webrtc_vulkan.yaml diff --git a/configs/launch_manifest/omnidreams_webrtc_vulkan.yaml b/configs/launch_manifest/omnidreams_webrtc_vulkan.yaml new file mode 100644 index 000000000..2e77117bd --- /dev/null +++ b/configs/launch_manifest/omnidreams_webrtc_vulkan.yaml @@ -0,0 +1,22 @@ +schema_version: 1 +runner: omnidreams +mode: webrtc + +runner_overrides: + device: cuda:0 + +scenario: + scene_uuid: 0d404ff7-2b66-498c-b047-1ed8cded60d4 + scene_variant: default + camera_name: camera_front_wide_120fov + +output: + host: 0.0.0.0 + port: 8089 + fps: 30 + video_width: 1280 + video_height: 704 + warmup_chunks: 10 + warmup_timeout_s: 600 + client_liveness_timeout_s: 10 + ludus_backend: vulkan \ No newline at end of file From f24f967376a527e69c7243edc51c641119a63da2 Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 06:57:02 -0700 Subject: [PATCH 5/7] remove invaid manifest --- .../omnidreams_webrtc_vulkan.yaml | 22 ------------------- 1 file changed, 22 deletions(-) delete mode 100644 configs/launch_manifest/omnidreams_webrtc_vulkan.yaml diff --git a/configs/launch_manifest/omnidreams_webrtc_vulkan.yaml b/configs/launch_manifest/omnidreams_webrtc_vulkan.yaml deleted file mode 100644 index 2e77117bd..000000000 --- a/configs/launch_manifest/omnidreams_webrtc_vulkan.yaml +++ /dev/null @@ -1,22 +0,0 @@ -schema_version: 1 -runner: omnidreams -mode: webrtc - -runner_overrides: - device: cuda:0 - -scenario: - scene_uuid: 0d404ff7-2b66-498c-b047-1ed8cded60d4 - scene_variant: default - camera_name: camera_front_wide_120fov - -output: - host: 0.0.0.0 - port: 8089 - fps: 30 - video_width: 1280 - video_height: 704 - warmup_chunks: 10 - warmup_timeout_s: 600 - client_liveness_timeout_s: 10 - ludus_backend: vulkan \ No newline at end of file From 627424a54d614c34642361b852f1d8aa4de6e597 Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 07:08:53 -0700 Subject: [PATCH 6/7] precommit --- configs/launch_manifest/omnidreams_local_window.yaml | 2 +- configs/launch_manifest/omnidreams_local_window_vulkan.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/configs/launch_manifest/omnidreams_local_window.yaml b/configs/launch_manifest/omnidreams_local_window.yaml index 1a01726f7..c5b444de5 100644 --- a/configs/launch_manifest/omnidreams_local_window.yaml +++ b/configs/launch_manifest/omnidreams_local_window.yaml @@ -9,4 +9,4 @@ scenario: output: world_model_manifest_path: ../../integrations/omnidreams/omnidreams/interactive_drive/configs/example_world_model_perf.yaml - ludus_backend: vulkan \ No newline at end of file + ludus_backend: vulkan diff --git a/configs/launch_manifest/omnidreams_local_window_vulkan.yaml b/configs/launch_manifest/omnidreams_local_window_vulkan.yaml index 1a01726f7..c5b444de5 100644 --- a/configs/launch_manifest/omnidreams_local_window_vulkan.yaml +++ b/configs/launch_manifest/omnidreams_local_window_vulkan.yaml @@ -9,4 +9,4 @@ scenario: output: world_model_manifest_path: ../../integrations/omnidreams/omnidreams/interactive_drive/configs/example_world_model_perf.yaml - ludus_backend: vulkan \ No newline at end of file + ludus_backend: vulkan From 713f5ac50a119e54bf38a9ac1253d0a4ad209272 Mon Sep 17 00:00:00 2001 From: Ariel Glasroth Date: Wed, 12 Aug 2026 19:44:21 -0700 Subject: [PATCH 7/7] more robustness --- .../omnidreams/ludus-renderer/README.md | 20 +-- .../_cpp/bindings/torch_rasterize_vk.cpp | 142 ++++++++++------- .../ludus_renderer/_cpp/common/vkutil.cpp | 8 +- .../ludus_renderer/_cpp/common/vkutil.h | 15 +- .../_cpp/render/ludus_timestamped_vk.cpp | 61 ++++--- .../ludus_renderer/_cpp/render/ludus_vk.h | 42 +++-- .../tests/test_vulkan_backend_contract.py | 149 ------------------ .../omnidreams/interactive_drive/README.md | 2 +- 8 files changed, 173 insertions(+), 266 deletions(-) delete mode 100644 integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py diff --git a/integrations/omnidreams/ludus-renderer/README.md b/integrations/omnidreams/ludus-renderer/README.md index 1195bccea..ccefad969 100644 --- a/integrations/omnidreams/ludus-renderer/README.md +++ b/integrations/omnidreams/ludus-renderer/README.md @@ -3,8 +3,8 @@ GPU-native F-theta renderer and PhysX-first object graph for autonomous vehicle simulation. The default CUDA backend uses the HPG 2011 CudaRaster triangle pipeline; an optional Windows/Linux Vulkan backend uses task, mesh, -fragment, and compute shaders with zero-copy CUDA/Vulkan external-memory -handoff. +and fragment shaders to rasterize into native device-local attachments, then a +compute export pass writes a CUDA-visible linear buffer. ## Features @@ -77,13 +77,15 @@ ctx = LudusCudaTimestampedContext(device="cuda") ``` The Vulkan backend mirrors the timestamped context API. Fixed-function color -and depth attachments resolve visibility, then one compute dispatch packs RGBA8 -into a reusable exported linear SSBO. PyTorch wraps CUDA's mapping of that same -device allocation, so the handoff has no output copy or layered CUDA image -import. Timeline semaphores and external queue-family ownership barriers order -the work without a steady-state CPU wait. Attachments are cached per resolution; -the current path is single-sample. Platform-native OS handles are transient and -closed or transferred immediately after CUDA imports them. +and depth attachments resolve primitive/depth ordering in the native raster +pipeline. A separate compute dispatch then packs the resolved image into +row-major RGBA8 in a reusable exported linear SSBO. PyTorch wraps CUDA's mapping +of that buffer, so only the post-raster handoff is zero-copy; the native image +is never treated as tensor storage. Timeline semaphores and external +queue-family ownership barriers order the work without a steady-state CPU wait. +Attachments are cached per resolution; the current path is single-sample. +Platform-native OS handles are transient and closed or transferred immediately +after CUDA imports them. ```python from ludus_renderer import LudusVulkanTimestampedContext diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp index 55a2f22d8..dd303402b 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/bindings/torch_rasterize_vk.cpp @@ -50,10 +50,16 @@ static torch::Tensor flu_to_rdf(const torch::Tensor& camera_poses) struct VulkanSharedState { + enum OutputSlotState : int + { + OutputSlotFree = 0, + OutputSlotLeased, + OutputSlotPendingRelease, + OutputSlotReclaiming, + }; + LudusTimestampedVkState* pState; - std::array, LUDUS_VK_OUTPUT_SLOTS> inUse; - std::array, LUDUS_VK_OUTPUT_SLOTS> releaseRecorded; - std::array releaseEvents; + std::array, LUDUS_VK_OUTPUT_SLOTS> outputSlotStates; int cudaDeviceIdx; explicit VulkanSharedState(int deviceIdx) @@ -64,10 +70,8 @@ struct VulkanSharedState c10::Device(c10::kCUDA, cudaDeviceIdx)); memset(pState, 0, sizeof(LudusTimestampedVkState)); for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) { - inUse[i].store(false, std::memory_order_relaxed); - releaseRecorded[i].store(false, std::memory_order_relaxed); - AT_CUDA_CHECK(cudaEventCreateWithFlags( - &releaseEvents[i], cudaEventDisableTiming)); + outputSlotStates[i].store( + OutputSlotFree, std::memory_order_relaxed); } ludusTimestampedInitVk(NVDR_CTX_PARAMS, *pState, cudaDeviceIdx); } @@ -75,17 +79,12 @@ struct VulkanSharedState ~VulkanSharedState() { cudaSetDevice(cudaDeviceIdx); - // Output tensors keep this owner alive. When the final tensor releases - // it records its consumer stream here; drain those events before - // destroying CUDA's mappings or the Vulkan allocations behind them. - for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) { - if (releaseRecorded[i].load(std::memory_order_acquire)) - cudaEventSynchronize(releaseEvents[i]); - } + // Output tensors keep this owner alive. Their final references can be + // dropped before arbitrary CUDA consumer streams finish, so teardown + // must drain the device before destroying the imported allocations. + cudaDeviceSynchronize(); ludusTimestampedReleaseVk(NVDR_CTX_PARAMS, *pState); delete pState; - for (cudaEvent_t event : releaseEvents) - cudaEventDestroy(event); } }; @@ -157,33 +156,78 @@ class LudusTimestampedVkStateWrapper int acquireOutputSlot() { - for (int attempt = 0; attempt < LUDUS_VK_OUTPUT_SLOTS; ++attempt) { - int slot = (outputCursor + attempt) % LUDUS_VK_OUTPUT_SLOTS; - bool expected = false; - if (sharedState->inUse[slot].compare_exchange_strong( - expected, true, std::memory_order_acq_rel)) { - outputCursor = (slot + 1) % LUDUS_VK_OUTPUT_SLOTS; - return slot; + auto tryAcquireFreeSlot = [&]() { + for (int attempt = 0; attempt < LUDUS_VK_OUTPUT_SLOTS; ++attempt) { + int slot = (outputCursor + attempt) % LUDUS_VK_OUTPUT_SLOTS; + int expected = VulkanSharedState::OutputSlotFree; + if (sharedState->outputSlotStates[slot].compare_exchange_strong( + expected, VulkanSharedState::OutputSlotLeased, + std::memory_order_acq_rel)) { + outputCursor = (slot + 1) % LUDUS_VK_OUTPUT_SLOTS; + return slot; + } + } + return -1; + }; + + int slot = tryAcquireFreeSlot(); + if (slot >= 0) + return slot; + + // A from_blob allocation is outside PyTorch's CUDA caching allocator, + // so record_stream cannot report every stream that consumed it. Move a + // stable snapshot of dropped tensors into a reclaiming state, then one + // batched device drain makes all of those slots safe to reuse. This is + // paid only when the pool is exhausted, never once per returned frame. + std::array reclaimSlots; + int reclaimCount = 0; + for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) { + int expected = VulkanSharedState::OutputSlotPendingRelease; + if (sharedState->outputSlotStates[i].compare_exchange_strong( + expected, VulkanSharedState::OutputSlotReclaiming, + std::memory_order_acq_rel)) { + reclaimSlots[reclaimCount++] = i; } } + if (reclaimCount > 0) { + cudaError_t syncError = cudaDeviceSynchronize(); + if (syncError != cudaSuccess) { + for (int i = 0; i < reclaimCount; ++i) { + sharedState->outputSlotStates[reclaimSlots[i]].store( + VulkanSharedState::OutputSlotPendingRelease, + std::memory_order_release); + } + TORCH_CHECK(false, + "failed to reclaim Vulkan interop export slots: ", + cudaGetErrorString(syncError)); + } + for (int i = 0; i < reclaimCount; ++i) { + sharedState->outputSlotStates[reclaimSlots[i]].store( + VulkanSharedState::OutputSlotFree, + std::memory_order_release); + } + slot = tryAcquireFreeSlot(); + TORCH_INTERNAL_ASSERT(slot >= 0); + return slot; + } + TORCH_CHECK(false, - "all Vulkan zero-copy output slots are still referenced; " + "all Vulkan interop export slots are still referenced; " "release an older render tensor before submitting another batch"); return -1; } void releaseOutputSlot(int slot) { - sharedState->inUse[slot].store(false, std::memory_order_release); + sharedState->outputSlotStates[slot].store( + VulkanSharedState::OutputSlotFree, std::memory_order_release); } - void waitForOutputRelease(cudaStream_t stream, int slot) + void quarantineOutputSlot(int slot) { - if (sharedState->releaseRecorded[slot].load( - std::memory_order_acquire)) { - AT_CUDA_CHECK(cudaStreamWaitEvent( - stream, sharedState->releaseEvents[slot], 0)); - } + sharedState->outputSlotStates[slot].store( + VulkanSharedState::OutputSlotPendingRelease, + std::memory_order_release); } int uploadScene( @@ -409,7 +453,6 @@ torch::Tensor ludus_timestamped_render_batch_vk( torch::Tensor poses_rdf = flu_to_rdf(camera_poses).transpose(-2, -1).contiguous(); const int outputSlot = stateWrapper.acquireOutputSlot(); try { - stateWrapper.waitForOutputRelease(stream, outputSlot); ludusRenderBatchVk(NVDR_CTX_PARAMS, s, stream, reinterpret_cast(queries.data_ptr()), reinterpret_cast(poses_rdf.data_ptr()), @@ -419,35 +462,23 @@ torch::Tensor ludus_timestamped_render_batch_vk( NVDR_CTX_PARAMS, s, stream, outputSlot, width, height, numQueries); auto sharedState = stateWrapper.sharedState; - const int cudaDeviceIdx = stateWrapper.cudaDeviceIdx; - const cudaStream_t outputStream = stream; torch::Tensor out = torch::from_blob( sharedOutput, {numQueries, height, width, 4}, - [sharedState, outputSlot, cudaDeviceIdx, outputStream](void*) { - // The deleter can run while an unrelated stream is current. - // Record release on the stream that exposed this tensor so - // same-stream consumers queued before destruction complete - // before Vulkan reuses the slot. As with ordinary CUDA - // allocations, a caller using the tensor on another stream - // must order that work back to its stream of origin before - // dropping the final reference. - if (cudaSetDevice(cudaDeviceIdx) == cudaSuccess && - cudaEventRecord( - sharedState->releaseEvents[outputSlot], - outputStream) - == cudaSuccess) { - sharedState->releaseRecorded[outputSlot].store( - true, std::memory_order_release); - sharedState->inUse[outputSlot].store( - false, std::memory_order_release); - } + [sharedState, outputSlot](void*) { + // Final CPU ownership does not imply completion on every CUDA + // stream that may have consumed this external allocation. + // Quarantine it; acquireOutputSlot reclaims dropped slots only + // after a batched device-wide completion check. + sharedState->outputSlotStates[outputSlot].store( + VulkanSharedState::OutputSlotPendingRelease, + std::memory_order_release); }, opts); stateWrapper.recordLastUse(stream); return out; } catch (...) { - stateWrapper.releaseOutputSlot(outputSlot); + stateWrapper.quarantineOutputSlot(outputSlot); throw; } } @@ -482,14 +513,13 @@ std::tuple ludus_timestamped_render_to_staging_vk( int outputSlot = -1; try { outputSlot = stateWrapper.acquireOutputSlot(); - stateWrapper.waitForOutputRelease(stream, outputSlot); ludusRenderBatchVk(NVDR_CTX_PARAMS, s, stream, reinterpret_cast(queries.data_ptr()), reinterpret_cast(poses_rdf.data_ptr()), numQueries, width, height, outputSlot); ludusCopyBatchResultsToStagingVk( - NVDR_CTX_PARAMS, s, stream, stagingIdx, + NVDR_CTX_PARAMS, s, stream, outputSlot, stagingIdx, width, height, numQueries); stateWrapper.recordLastUse(stream); // The staging copy is ordered before lastUseEvent, so the next wrapper @@ -498,7 +528,7 @@ std::tuple ludus_timestamped_render_to_staging_vk( return std::make_tuple(stagingIdx, true); } catch (...) { if (outputSlot >= 0) - stateWrapper.releaseOutputSlot(outputSlot); + stateWrapper.quarantineOutputSlot(outputSlot); stateWrapper.releaseStagingSlot(stagingIdx); throw; } diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp index ea16503d9..e5ccdca6b 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.cpp @@ -549,17 +549,17 @@ void resizeExternalBuffer( } // --------------------------------------------------------------------------- -// Vulkan-only images. Layered CUDA image import is intentionally absent. +// Device-local native raster images. CUDA image import is intentionally absent. // --------------------------------------------------------------------------- -VkExternalImage createExternalImage( +VkDeviceImage createDeviceImage( VkContext& ctx, uint32_t width, uint32_t height, uint32_t layers, VkFormat format, VkImageUsageFlags usage, VkSampleCountFlagBits samples) { - VkExternalImage img = {}; + VkDeviceImage img = {}; img.width = width; img.height = height; img.layers = layers; @@ -609,7 +609,7 @@ VkExternalImage createExternalImage( return img; } -void destroyExternalImage(VkContext& ctx, VkExternalImage& img) +void destroyDeviceImage(VkContext& ctx, VkDeviceImage& img) { if (img.imageView) { vkDestroyImageView(ctx.device, img.imageView, nullptr); img.imageView = VK_NULL_HANDLE; } if (img.image) { vkDestroyImage(ctx.device, img.image, nullptr); img.image = VK_NULL_HANDLE; } diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h index 9774b1ad4..5105be004 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/common/vkutil.h @@ -111,9 +111,12 @@ struct VkExternalBuffer CUdeviceptr cuDevPtr; }; -// Vulkan-only image. CUDA image import is deliberately unsupported; layered -// output interop uses exported linear buffers instead. -struct VkExternalImage +// Device-local Vulkan image used by the native raster pipeline. This is not an +// interop allocation: optimal image tiling is intentionally opaque to CUDA and +// cannot be exposed as a row-major tensor. Layered output interop uses a +// separate exported linear buffer populated after fixed-function visibility +// has been resolved. +struct VkDeviceImage { VkImage image; VkDeviceMemory memory; @@ -145,15 +148,15 @@ void resizeExternalBuffer( bool cudaImportable ); -// Vulkan-only image management (currently depth attachments). -VkExternalImage createExternalImage( +// Device-local image management for native color/depth attachments. +VkDeviceImage createDeviceImage( VkContext& ctx, uint32_t width, uint32_t height, uint32_t layers, VkFormat format, VkImageUsageFlags usage, VkSampleCountFlagBits samples ); -void destroyExternalImage(VkContext& ctx, VkExternalImage& img); +void destroyDeviceImage(VkContext& ctx, VkDeviceImage& img); // Memory type helpers. uint32_t findMemoryType( diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp index e7c48a808..fe221d554 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_timestamped_vk.cpp @@ -340,16 +340,16 @@ static void updateAllInputDescriptorSets(LudusTimestampedVkState& s) updateDescriptorSet(s.vkctx.device, s.descriptorSets[i], s); } -static void updateFrameOutputDescriptors( - VkDevice device, VkDescriptorSet ds, const VkExternalBuffer& output, - VkDeviceSize bytes, const VkExternalImage& colorImage) +static void updateFrameExportDescriptors( + VkDevice device, VkDescriptorSet ds, const VkExternalBuffer& linearOutput, + VkDeviceSize bytes, const VkDeviceImage& colorAttachment) { VkDescriptorBufferInfo info = {}; - info.buffer = output.buffer; + info.buffer = linearOutput.buffer; info.offset = 0; info.range = bytes; VkDescriptorImageInfo imageInfo = {}; - imageInfo.imageView = colorImage.imageView; + imageInfo.imageView = colorAttachment.imageView; imageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL; VkWriteDescriptorSet writes[2] = {}; @@ -653,8 +653,8 @@ static void destroyRenderTarget( { if (target.framebuffer) vkDestroyFramebuffer(s.vkctx.device, target.framebuffer, nullptr); - destroyExternalImage(s.vkctx, target.colorImage); - destroyExternalImage(s.vkctx, target.depthStencilImage); + destroyDeviceImage(s.vkctx, target.colorAttachment); + destroyDeviceImage(s.vkctx, target.depthStencilAttachment); memset(&target, 0, sizeof(target)); } @@ -713,11 +713,11 @@ static void ensureFramebuffer( target.height = height; target.maxLayers = layers; target.samples = desiredSamplesInt; - target.colorImage = createExternalImage(s.vkctx, width, height, layers, + target.colorAttachment = createDeviceImage(s.vkctx, width, height, layers, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT, (VkSampleCountFlagBits)desiredSamplesInt); - target.depthStencilImage = createExternalImage(s.vkctx, width, height, layers, + target.depthStencilAttachment = createDeviceImage(s.vkctx, width, height, layers, VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, (VkSampleCountFlagBits)desiredSamplesInt); @@ -725,8 +725,8 @@ static void ensureFramebuffer( VkFramebufferCreateInfo fbCI = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO}; fbCI.renderPass = s.renderPass; VkImageView attachments[] = { - target.colorImage.imageView, - target.depthStencilImage.imageView, + target.colorAttachment.imageView, + target.depthStencilAttachment.imageView, }; fbCI.attachmentCount = 2; fbCI.pAttachments = attachments; @@ -1033,7 +1033,8 @@ void ludusRenderBatchVk( } const size_t totalSize = (size_t)width * height * 4 * numQueries; - VkExternalBuffer& outputBuffer = s.outputBuffers[outputSlot]; + LudusVkExportSlot& exportSlot = s.exportSlots[outputSlot]; + VkExternalBuffer& outputBuffer = exportSlot.linearRgba; if (externalBufferNeedsResize(outputBuffer, totalSize)) { synchronizeForResourceMutation(s, stream); resizeExternalBuffer(s.vkctx, outputBuffer, totalSize, @@ -1041,10 +1042,11 @@ void ludusRenderBatchVk( true); // Fresh allocations start in Vulkan ownership. Reused output slots // were released to CUDA by their previous render submission. - s.outputReleasedToCuda[outputSlot] = 0; + exportSlot.releasedToCuda = 0; } - s.activeOutputSlot = outputSlot; - s.activeOutputSize = totalSize; + exportSlot.width = width; + exportSlot.height = height; + exportSlot.layers = numQueries; // A single stream-ordered timeline signal publishes CUDA-written inputs // and releases a reused output lease to Vulkan. No host wait is involved. @@ -1078,9 +1080,9 @@ void ludusRenderBatchVk( // without touching the other in-flight sets. LudusVkRenderTarget& renderTarget = s.renderTargets[s.activeRenderTarget]; - updateFrameOutputDescriptors( + updateFrameExportDescriptors( s.vkctx.device, descriptorSet, outputBuffer, totalSize, - renderTarget.colorImage); + renderTarget.colorAttachment); VkCommandBuffer cmd = s.vkctx.commandBuffers[frameSlot]; VK_CHECK(vkResetCommandBuffer(cmd, 0)); VkCommandBufferBeginInfo beginCI = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; @@ -1118,7 +1120,7 @@ void ludusRenderBatchVk( addBarrier(s.cameraIntrinsicsBuffer, VK_ACCESS_SHADER_READ_BIT); addBarrier(s.cameraPoseBuffer, VK_ACCESS_SHADER_READ_BIT); addBarrier(s.queryBuffer, VK_ACCESS_SHADER_READ_BIT); - if (s.outputReleasedToCuda[outputSlot]) { + if (exportSlot.releasedToCuda) { addBarrier(outputBuffer, VK_ACCESS_SHADER_WRITE_BIT); } else { VkBufferMemoryBarrier initialOutput = { @@ -1245,7 +1247,7 @@ void ludusRenderBatchVk( colorToCompute.newLayout = VK_IMAGE_LAYOUT_GENERAL; colorToCompute.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; colorToCompute.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - colorToCompute.image = renderTarget.colorImage.image; + colorToCompute.image = renderTarget.colorAttachment.image; colorToCompute.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; colorToCompute.subresourceRange.baseMipLevel = 0; colorToCompute.subresourceRange.levelCount = 1; @@ -1335,7 +1337,7 @@ void ludusRenderBatchVk( submitInfo.pSignalSemaphores = &s.vkctx.interopTimeline; VK_CHECK(vkQueueSubmit(s.vkctx.graphicsQueue, 1, &submitInfo, frameFence)); s.lastVulkanDoneValue = vulkanDoneValue; - s.outputReleasedToCuda[outputSlot] = 1; + exportSlot.releasedToCuda = 1; } //============================================================================= @@ -1350,7 +1352,11 @@ uint8_t* ludusMapBatchResultsVk( TORCH_CHECK(outputSlot >= 0 && outputSlot < LUDUS_VK_OUTPUT_SLOTS, "invalid Vulkan output slot ", outputSlot); const size_t bytes = (size_t)width * height * 4 * numQueries; - VkExternalBuffer& output = s.outputBuffers[outputSlot]; + LudusVkExportSlot& exportSlot = s.exportSlots[outputSlot]; + TORCH_CHECK(exportSlot.width == width && + exportSlot.height == height && exportSlot.layers == numQueries, + "Vulkan export slot shape changed before mapping"); + VkExternalBuffer& output = exportSlot.linearRgba; TORCH_CHECK(output.cuDevPtr != 0 && output.size >= bytes, "Vulkan output SSBO is not CUDA-importable or is undersized"); waitInteropTimelineOnCuda(s.vkctx, stream, s.lastVulkanDoneValue); @@ -1359,11 +1365,12 @@ uint8_t* ludusMapBatchResultsVk( void ludusCopyBatchResultsVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, - uint8_t* outputPtr, int width, int height, int numQueries) + int outputSlot, uint8_t* outputPtr, + int width, int height, int numQueries) { size_t totalSize = (size_t)width * height * 4 * numQueries; uint8_t* sharedOutput = ludusMapBatchResultsVk( - NVDR_CTX_PARAMS, s, stream, s.activeOutputSlot, + NVDR_CTX_PARAMS, s, stream, outputSlot, width, height, numQueries); // Legacy staging/JPEG entry points request an owned CUDA copy. The primary // torch render binding bypasses this function and wraps sharedOutput. @@ -1379,7 +1386,7 @@ void ludusCopyBatchResultsVk( int ludusCopyBatchResultsToStagingVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, - int idx, int width, int height, int numQueries) + int outputSlot, int idx, int width, int height, int numQueries) { TORCH_CHECK(idx >= 0 && idx < 2, "invalid Vulkan staging slot ", idx); @@ -1397,7 +1404,9 @@ int ludusCopyBatchResultsToStagingVk( s.stagingBufferSize[idx] = totalSize; } - ludusCopyBatchResultsVk(NVDR_CTX_PARAMS, s, stream, s.stagingBuffer[idx], width, height, numQueries); + ludusCopyBatchResultsVk( + NVDR_CTX_PARAMS, s, stream, outputSlot, s.stagingBuffer[idx], + width, height, numQueries); cudaEventRecord(s.stagingReadyEvent[idx], stream); s.stagingWidth[idx] = width; @@ -1607,7 +1616,7 @@ void ludusTimestampedReleaseVk(NVDR_CTX_ARGS, LudusTimestampedVkState& s) destroyExternalBuffer(s.vkctx, s.cameraPoseBuffer); destroyExternalBuffer(s.vkctx, s.queryBuffer); for (int i = 0; i < LUDUS_VK_OUTPUT_SLOTS; ++i) - destroyExternalBuffer(s.vkctx, s.outputBuffers[i]); + destroyExternalBuffer(s.vkctx, s.exportSlots[i].linearRgba); destroyVkContext(s.vkctx); memset(&s, 0, sizeof(s)); diff --git a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h index 7b8ce7969..55113b236 100644 --- a/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h +++ b/integrations/omnidreams/ludus-renderer/ludus_renderer/_cpp/render/ludus_vk.h @@ -47,11 +47,24 @@ struct LudusVkRenderTarget int height; int maxLayers; int samples; - VkExternalImage colorImage; - VkExternalImage depthStencilImage; + VkDeviceImage colorAttachment; + VkDeviceImage depthStencilAttachment; VkFramebuffer framebuffer; }; +// CUDA-visible row-major presentation storage. This resource is deliberately +// separate from LudusVkRenderTarget: native raster attachments use opaque, +// implementation-defined tiling and are only converted to NHWC RGBA8 after +// fixed-function depth/primitive ordering has completed. +struct LudusVkExportSlot +{ + VkExternalBuffer linearRgba; + int width; + int height; + int layers; + int releasedToCuda; +}; + struct LudusTimestampedVkState { // ---------- Scene storage bookkeeping ---------- @@ -184,17 +197,14 @@ struct LudusTimestampedVkState uint8_t* jpegFlipBuffer; size_t jpegFlipBufferSize; - // ---------- Zero-copy compute-export output pool ---------- - // Fixed-function color/depth rendering resolves visibility into a cached, - // Vulkan-only color attachment. A compute pass then writes packed RGBA8 - // directly into one exported SSBO. CUDA maps the same allocation and the - // binding wraps its CUdeviceptr with torch::from_blob. There is no host or - // CUDA result copy, and no layered CUDA image import. Slots are leased until - // their returned tensor is released. - VkExternalBuffer outputBuffers[LUDUS_VK_OUTPUT_SLOTS]; - int outputReleasedToCuda[LUDUS_VK_OUTPUT_SLOTS]; - int activeOutputSlot; - size_t activeOutputSize; + // ---------- Post-raster linear export pool ---------- + // Hardware rasterization first resolves visibility into a device-local, + // optimally tiled render target. A compute pass then establishes explicit + // row-major NHWC order in one exported SSBO. CUDA maps that allocation and + // the binding wraps its CUdeviceptr with torch::from_blob, so the interop + // handoff remains zero-copy without pretending the native attachment has a + // tensor-compatible layout. Slots are leased until their tensor is released. + LudusVkExportSlot exportSlots[LUDUS_VK_OUTPUT_SLOTS]; // ---------- CUDA/Vulkan asynchronous ownership chain ---------- // Per render: CUDA signals inputs-ready, Vulkan signals render-done, @@ -298,12 +308,14 @@ uint8_t* ludusMapBatchResultsVk( void ludusCopyBatchResultsVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, - uint8_t* outputPtr, int width, int height, int numQueries + int outputSlot, uint8_t* outputPtr, + int width, int height, int numQueries ); int ludusCopyBatchResultsToStagingVk( NVDR_CTX_ARGS, LudusTimestampedVkState& s, cudaStream_t stream, - int stagingIdx, int width, int height, int numQueries + int outputSlot, int stagingIdx, + int width, int height, int numQueries ); void ludusCopyStagingToOutputVk( diff --git a/integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py b/integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py deleted file mode 100644 index 7b4cae426..000000000 --- a/integrations/omnidreams/ludus-renderer/tests/test_vulkan_backend_contract.py +++ /dev/null @@ -1,149 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: Apache-2.0 - -"""Cheap source-level guards for the optional Vulkan/CUDA interop path.""" - -import re -from pathlib import Path - -import pytest - -pytestmark = pytest.mark.ci_cpu - -_PACKAGE = Path(__file__).parents[1] / "ludus_renderer" - - -def _between(source: str, start: str, end: str) -> str: - return source.split(start, 1)[1].split(end, 1)[0] - - -def test_vulkan_hot_path_uses_reused_zero_copy_interop() -> None: - renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() - vkutil = (_PACKAGE / "_cpp/common/vkutil.cpp").read_text() - binding = (_PACKAGE / "_cpp/bindings/torch_rasterize_vk.cpp").read_text() - interactive = ( - Path(__file__).parents[2] / "omnidreams/interactive_drive/rasterizer.py" - ).read_text() - render = _between( - renderer, "void ludusRenderBatchVk", "void ludusCopyBatchResultsVk" - ) - torch_render = _between( - binding, - "torch::Tensor ludus_timestamped_render_batch_vk", - "std::tuple ludus_timestamped_render_to_staging_vk", - ) - - # Fixed-function color/depth ordering resolves visibility before one - # compute pass writes the exported, device-local linear allocation. - for shader in _PACKAGE.glob("shaders/*.frag.glsl"): - source = shader.read_text() - assert "layout(early_fragment_tests) in;" in source - assert "layout(location = 0) out vec4 out_color;" in source - assert "binding = 14" not in source - assert "output_pixels.rgba8[pixel_index]" not in source - export = (_PACKAGE / "shaders/ts_export.comp.glsl").read_text() - assert "binding = 14" in export - assert "binding = 15" in export - assert "imageLoad(color_image" in export - assert "output_pixels.rgba8[pixel_index]" in export - assert "subpass.colorAttachmentCount = 1" in renderer - assert ( - "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT" in renderer - ) - assert "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT" in render - assert "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT" in render - assert "vkCmdDispatch" in render - assert "resizeExternalBuffer(s.vkctx, outputBuffer, totalSize" in render - assert "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT" in render - assert "cuExternalMemoryGetMappedBuffer" in vkutil - assert "cuExternalMemoryGetMappedMipmappedArray" not in vkutil - assert "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT" in vkutil - assert "vkCmdCopyImageToBuffer" not in renderer - assert "torch::from_blob" in torch_render - assert "ludusMapBatchResultsVk" in torch_render - assert "ludusCopyBatchResultsVk" not in torch_render - assert '"vulkan": LudusVulkanTimestampedContext' in interactive - - # Output and color/depth allocations are capacity/cache reused; teardown - # synchronization remains behind those rare growth paths. - assert "target.maxLayers >= layers" in renderer - assert "externalBufferNeedsResize(outputBuffer, totalSize)" in render - assert "LUDUS_VK_OUTPUT_SLOTS" in binding - assert "cudaStreamSynchronize" not in render - assert "vkDeviceWaitIdle" not in render - - -def test_vulkan_growth_preserves_existing_scenes_and_required_features() -> None: - renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() - vkutil = (_PACKAGE / "_cpp/common/vkutil.cpp").read_text() - - assert "growCapacityGeometrically" in renderer - assert "finishSharedBufferGrowth" in renderer - assert "growth.preserveBytes" in renderer - assert "cudaMemcpyAsync" in _between( - renderer, - "static void finishSharedBufferGrowth", - "static void rebuildRenderPassAndPipelines", - ) - assert "features2.features.geometryShader = VK_TRUE" in vkutil - # Fragment shaders no longer perform storage writes, so this feature is not - # needed by the corrected graphics-plus-compute path. - assert "features2.features.fragmentStoresAndAtomics = VK_TRUE" not in vkutil - - -def test_vulkan_handoff_is_timeline_and_ownership_ordered() -> None: - renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() - vkutil = (_PACKAGE / "_cpp/common/vkutil.cpp").read_text() - vkheader = (_PACKAGE / "_cpp/common/vkutil.h").read_text() - plugin = (_PACKAGE / "_ops/_plugin_vk.py").read_text() - render = _between( - renderer, "void ludusRenderBatchVk", "void ludusCopyBatchResultsVk" - ) - mapping = _between( - renderer, "uint8_t* ludusMapBatchResultsVk", "void ludusCopyBatchResultsVk" - ) - - # Interop selects native handles at compile time. OS handles only transport - # the Vulkan allocation/semaphore into CUDA; renderer state tracks the CUDA - # import itself, so there is no Linux-fd field or Windows handle leak. - assert "VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME" in vkutil - assert "VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME" in vkutil - assert "CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" in vkutil - assert "CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" in vkutil - assert "CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32" in vkutil - assert "CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD" in vkutil - assert "CloseHandle(semaphoreHandle)" in vkutil - assert "CloseHandle(memoryHandle)" in vkutil - assert "memFd" not in vkheader - assert "VK_USE_PLATFORM_WIN32_KHR" in vkheader - assert 'ldflags = ["cuda.lib", "vulkan-1.lib", "nvjpeg.lib"]' in plugin - assert "Vulkan backend is currently only supported on Linux" not in plugin - assert "cuSignalExternalSemaphoresAsync" in vkutil - assert "cuWaitExternalSemaphoresAsync" in vkutil - assert "signalInteropTimelineFromCuda" in render - assert "waitInteropTimelineOnCuda" in mapping - assert "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO" in render - assert "VK_QUEUE_FAMILY_EXTERNAL" in render - assert "srcQueueFamilyIndex = s.vkctx.graphicsQueueFamily" in render - assert "dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL" in render - assert "VK_ACCESS_SHADER_WRITE_BIT" in render - assert "VK_ACCESS_TRANSFER_WRITE_BIT" not in render - - -def test_vulkan_push_constant_updates_cover_the_declared_stage_range() -> None: - renderer = (_PACKAGE / "_cpp/render/ludus_timestamped_vk.cpp").read_text() - stage_mask = _between( - renderer, - "static constexpr VkShaderStageFlags kLudusPushConstantStages =", - ";", - ) - - assert "VK_SHADER_STAGE_TASK_BIT_EXT" in stage_mask - assert "VK_SHADER_STAGE_MESH_BIT_EXT" in stage_mask - assert "VK_SHADER_STAGE_FRAGMENT_BIT" in stage_mask - assert "VK_SHADER_STAGE_COMPUTE_BIT" in stage_mask - assert "pushRange.stageFlags = kLudusPushConstantStages" in renderer - - push_calls = re.findall(r"vkCmdPushConstants\((.*?)\);", renderer, re.DOTALL) - assert push_calls - assert all("kLudusPushConstantStages" in call for call in push_calls) diff --git a/integrations/omnidreams/omnidreams/interactive_drive/README.md b/integrations/omnidreams/omnidreams/interactive_drive/README.md index 6a7dc9aff..2db6f899f 100644 --- a/integrations/omnidreams/omnidreams/interactive_drive/README.md +++ b/integrations/omnidreams/omnidreams/interactive_drive/README.md @@ -30,7 +30,7 @@ uv sync --package flashdreams-omnidreams --extra interactive-drive #stages the default scene, prewarms model assets, and syncs native sources; required for #omnidreams-perf`, otherwise optional. -uv run --package flashdreams-omnidreams omnidreams-prepare --perf --scene-uuid clipgt-0d404ff7-2b66-498c-b047-1ed8cded60d4 +uv run --package flashdreams-omnidreams omnidreams-prepare --perf # launches the default interactive configuration; required to run the demo. uv run --package flashdreams-omnidreams flashdreams-run omnidreams local-window