From 90da4eb14aa2577afab8f69d0e6bf7d52539ba56 Mon Sep 17 00:00:00 2001 From: 4223641 Date: Thu, 3 Sep 2026 22:53:53 +0800 Subject: [PATCH 1/4] Replay matched-residual corrections and GPU game-exposure paper white onto dlss-neural-rendering. Co-authored-by: Cursor --- OptiScaler/dlssnr/DlssNrFeature_Dx12.h | 56 +- OptiScaler/dlssnr/DlssNrFeature_Vk.cpp | 20 +- OptiScaler/dlssnr/DlssNr_Exposure.h | 66 ++ OptiScaler/dlssnr/DlssNr_Menu.cpp | 55 +- OptiScaler/dlssnr/README.md | 9 +- .../2026-09-03-game-exposure-white-point.md | 959 ++++++++++++++++++ ...2026-09-03-matched-residual-corrections.md | 404 ++++++++ OptiScaler/dlssnr/tests/exposure_fixture.cpp | 47 + .../tests/white_point_decision_fixture.cpp | 32 + OptiScaler/shaders/dlssnr/DlssNr_Common.h | 21 +- OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp | 670 ++++++++---- OptiScaler/shaders/dlssnr/DlssNr_Dx12.h | 10 +- OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp | 18 +- OptiScaler/shaders/dlssnr/DlssNr_Vk.h | 24 +- .../shaders/dlssnr/precompile/dlssnr.hlsl | 159 ++- OptiScaler/upscalers/IFeature_Dx11wDx12.cpp | 16 +- OptiScaler/upscalers/IFeature_VkwDx12.cpp | 31 +- 17 files changed, 2209 insertions(+), 388 deletions(-) create mode 100644 OptiScaler/dlssnr/DlssNr_Exposure.h create mode 100644 OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md create mode 100644 OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md create mode 100644 OptiScaler/dlssnr/tests/exposure_fixture.cpp create mode 100644 OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp diff --git a/OptiScaler/dlssnr/DlssNrFeature_Dx12.h b/OptiScaler/dlssnr/DlssNrFeature_Dx12.h index 861d5e6d3..30d3f78b5 100644 --- a/OptiScaler/dlssnr/DlssNrFeature_Dx12.h +++ b/OptiScaler/dlssnr/DlssNrFeature_Dx12.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include @@ -57,51 +58,32 @@ void RetryAfterFailure(); // entry points and initialises on the game's own device, which is where a refusal would appear. void ProbeD3D11(void* d3d11Device); -// What scale this game's buffer is on, measured from the untouched copy of each frame. -// -// A suggestion only. Nothing applies it: the menu shows it and the user takes it or does not, which -// keeps the number visible and adjustable rather than a value that moved on its own. Confidence is -// how settled recent readings are -- 1 means they agree, 0 means the scene is changing under the -// measurement and no single value would serve. -struct CalibrationReading -{ - float suggestion = 0.0f; - - // How much recent readings agree. This is steadiness, not correctness: a frozen frame agrees with - // itself perfectly, so a loading screen scores full marks for a number that means nothing. Read it - // together with usable. - float steadiness = 0.0f; - - unsigned long long samples = 0; - - // Whether the scene is worth measuring at all. False when the frame is already tone mapped -- the - // divisor does nothing there and the reading would be a meaningless 0.9 -- or when too little of - // the picture is lit to say where the top of the range is. A dark cave gives a small number very - // steadily, which is the trap this exists to close. - bool usable = false; - const char* why = ""; -}; - -CalibrationReading Calibration(); - // Whether the model is loaded and running, for the overlay. bool IsRunning(); // Why it is not, if it is not. Empty while it is running or has not been tried yet. const char* FailureReason(); -// What the game offers by way of exposure. Observed every frame whether or not the setting is on, so -// the menu can say whether turning it on would do anything here. -struct ExposureStatus +// Menu queries. Read atomics only; never take g_nrMutex. +bool GameExposureCanEnable(); +bool GameExposureEffective(); +enum class GameExposureWait { - unsigned long long seenFrames = 0; // evaluates observed; 0 means nothing has run yet - bool offeredNow = false; // a texture on the most recent frame - bool everOffered = false; // a texture on any frame so far - float exposure = 0.0f; // last value read back, 0 if none - float preExposure = 1.0f; + NativeVulkan, + Waiting, + Passthrough, + Absent, + Available }; - -ExposureStatus GameExposureStatus(); +GameExposureWait GameExposureUiState(); +struct GameExposureReadout +{ + bool haveNumbers; + float e, p, s; + float gameW; + float slider; +}; +GameExposureReadout GameExposureMenuReadout(); // The white point the exposure meter has settled on, or 0 if it has not taken a reading yet. For the // overlay, so the number in use is visible rather than inferred. diff --git a/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp b/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp index 0560ddac7..718b7a34f 100644 --- a/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp +++ b/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp @@ -796,14 +796,8 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para // and encoding an already tone-mapped frame a second time looks washed out and banded. const bool linearHdr = gameSaysHdr && FormatCanHoldLinearHdr(colour->Resource.ImageViewInfo.Format); - // The same rule as the D3D12 path, deliberately spelled the same way: the game divides its frame - // by preExposure and multiplies by exposure, so undoing that is the divisor this pass wants, and - // the slider becomes a trim on top rather than the answer. - // - // The trim is bounded here, at the point of use, rather than at the slider. Someone who found 64 - // by hand on the manual path and then switches the exposure source on keeps that 64 in their ini; - // bounding it in the menu would leave the picture wrong for a reason the menu no longer showed. - // Their value stays in the config untouched, so switching back to manual restores it. + // Native Vulkan source 1 stays on the delayed courier. Do not call DecideWhitePoint; do not + // set UseGameExposure. P / E * trim, origin clamp, no S. float whitePoint = cfg.DlssNrWhitePointScale.value_or_default(); if (cfg.DlssNrWhitePointSource.value_or_default() == 1 && g_vk.gameExposure > 1e-6f) @@ -827,6 +821,7 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para encode.Width = width; encode.Height = height; encode.WhitePoint = whitePoint; + encode.UseGameExposure = 0; encode.Passthrough = linearHdr ? 0u : 1u; encode.TransferStrength = cfg.DlssNrTransferStrength.value_or_default(); encode.ColourStrength = cfg.DlssNrColourStrength.value_or_default(); @@ -922,8 +917,10 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para Transition(cmdBuffer, g_vk.meter, VK_IMAGE_LAYOUT_GENERAL); if (g_vk.pass->Dispatch(cmdBuffer, meter, kMeterSide, kMeterSide, VK_NULL_HANDLE, VK_NULL_HANDLE, - VK_NULL_HANDLE, exposure->Resource.ImageViewInfo.ImageView, g_vk.meter.view, - VK_NULL_HANDLE, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_NULL_HANDLE, VK_NULL_HANDLE, g_vk.meter.view, VK_NULL_HANDLE, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + exposure->Resource.ImageViewInfo.ImageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) { Transition(cmdBuffer, g_vk.meter, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); @@ -993,9 +990,10 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para Transition(cmdBuffer, g_vk.keep, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); Transition(cmdBuffer, *modelInput, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + Transition(cmdBuffer, g_vk.proxy, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); if (!g_vk.pass->Dispatch(cmdBuffer, resolve, width, height, modelInput->view, g_vk.output.view, g_vk.keep.view, - VK_NULL_HANDLE, colour->Resource.ImageViewInfo.ImageView, VK_NULL_HANDLE, + g_vk.proxy.view, colour->Resource.ImageViewInfo.ImageView, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) { Fail("the resolve dispatch failed"); diff --git a/OptiScaler/dlssnr/DlssNr_Exposure.h b/OptiScaler/dlssnr/DlssNr_Exposure.h new file mode 100644 index 000000000..c3f1fa01f --- /dev/null +++ b/OptiScaler/dlssnr/DlssNr_Exposure.h @@ -0,0 +1,66 @@ +#pragma once +#include +#include +#include + +inline float FoldZeroToOne(float v) { return (v > 1e-6f) ? v : 1.0f; } + +inline float SanitizeExposure(float e) +{ + if (!(e > 1e-6f && e < 1e6f)) + return 1.0f; + return e; +} + +inline float GameWhite(float e, float p, float s) +{ + e = SanitizeExposure(e); + p = (std::max)(FoldZeroToOne(p), 1e-4f); + s = (std::max)(FoldZeroToOne(s), 1e-4f); + const float gameW = p / (std::max)(e * s, 1e-4f); + // T0 invert: return e * s / p; + return (std::max)(gameW, 1e-4f); +} + +struct WhitePointDecision +{ + float whitePoint; // written to encode/resolve gWhitePoint + uint32_t useGameExposure; // 1 only for D3D12 Approach B this frame +}; + +inline WhitePointDecision DecideWhitePoint(uint32_t source, // WhitePointSource 0/1/2 + bool isHdrBuffer, // + bool usable, // ExposureUsable(gameRes) + bool heldE, // finite gameExposure > 1e-6 + float scale, // WhitePointScale + float trim, // clamp(WhitePointTrim, 0.25, 4) + float heldExposure, // last courier E + float pre, // frame.PreExposure + float exposureScale, // frame.ExposureScale + float anchoredOrZero) // ExposureScan::AnchoredWhitePoint(...) or 0 +{ + WhitePointDecision d{scale, 0}; + if (!isHdrBuffer) + return d; + if (source == 0) + return d; + if (source == 2) + { + if (anchoredOrZero > 0.0f) + d.whitePoint = anchoredOrZero; + return d; + } + // source == 1 + if (usable) + { + d.useGameExposure = 1; + d.whitePoint = trim; // PaperWhite() multiplies by GameW + return d; + } + if (heldE) + { + d.whitePoint = trim * GameWhite(heldExposure, pre, exposureScale); + return d; + } + return d; // hole without held E: Scale +} diff --git a/OptiScaler/dlssnr/DlssNr_Menu.cpp b/OptiScaler/dlssnr/DlssNr_Menu.cpp index bbda2beb0..95f7ca8b6 100644 --- a/OptiScaler/dlssnr/DlssNr_Menu.cpp +++ b/OptiScaler/dlssnr/DlssNr_Menu.cpp @@ -2,6 +2,7 @@ #include "DlssNrFeature_Vk.h" #include "DlssNr.h" +#include "DlssNrFeature_Dx12.h" #include "DlssNr_ExposureScan.h" @@ -227,7 +228,9 @@ void RenderMenu(Config* config, float menuResScale) "\nown, rescaled so its luminance sits where the original says it should. This" "\nblends between the two, so both ends are real pictures and everything between" "\nthem is one too." - "\n\n0 gives back exactly what the upscaler produced. 1 is the model's picture." + "\n\n0 gives back the keep (the upscaler frame after a clamp and one float" + "\nround-trip), not a capture 'before' and not a bit-exact upscaler copy." + "\n1 is the model's picture." "\n\nAbove 1 carries on past it in the same direction, which is not something the" "\nmodel asked for -- use it to see what it is doing, then come back down. This" "\nis the control to push if you want more effect: Intensity belongs to the model" @@ -325,9 +328,9 @@ void RenderMenu(Config* config, float menuResScale) // Each option also says whether it can actually do anything in THIS game, in colour, so the // choice is made on what is available rather than on what sounds best. { - const auto ex = DlssNr::GameExposureStatus(); const bool vk = DlssNr::IsRunningVk(); - const bool haveExposure = vk ? DlssNr::ExposureOfferedVk() : ex.everOffered; + const bool canEnable = DlssNr::GameExposureCanEnable(); + const bool haveExposure = vk ? DlssNr::ExposureOfferedVk() : canEnable; const float anchorNow = DlssNr::ExposureScan::BestValue(); const bool haveAnchor = !DlssNr::ExposureScan::Anchors().empty(); @@ -366,26 +369,44 @@ void RenderMenu(Config* config, float menuResScale) // Availability, in colour, for the option currently chosen. if (source == 1) { - if (!vk && ex.seenFrames == 0) - ImGui::TextDisabled("Waiting for a frame..."); - else if (!haveExposure) + const auto ui = DlssNr::GameExposureUiState(); + const auto readout = DlssNr::GameExposureMenuReadout(); + const ImVec4 live(0.4f, 0.85f, 0.9f, 1.0f); + + switch (ui) + { + case DlssNr::GameExposureWait::NativeVulkan: + ImGui::TextDisabled("Menu may lag; native Vulkan picture uses the delayed courier."); + break; + case DlssNr::GameExposureWait::Waiting: + ImGui::TextDisabled("Waiting for Neural Rendering."); + break; + case DlssNr::GameExposureWait::Passthrough: + ImGui::TextDisabled("This buffer is already tone-mapped. Paper white is unused."); + break; + case DlssNr::GameExposureWait::Absent: ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), "This game supplies no exposure -- paper white is in use. Try " "the scan instead."); - else if (vk) - ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), - "This game supplies an exposure and it is being read."); - else if (ex.exposure > 1e-6f) + break; + case DlssNr::GameExposureWait::Available: + if (canEnable) + ImGui::TextDisabled("Menu may lag; picture is this frame."); + break; + } + + if (readout.haveNumbers) { - const float trim = - std::clamp(config->DlssNrWhitePointTrim.value_or_default(), 0.25f, 4.0f); - ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), - "Game exposure %.4f -> white point %.2f%s", ex.exposure, - ex.preExposure / ex.exposure * trim, - ex.offeredNow ? "" : " (held: absent this frame)"); + ImGui::TextColored(live, "Exposure %.3f · pre %.2f · scale %.2f", readout.e, + readout.p, readout.s); + ImGui::TextColored(live, "game white %.1f · trim %.2f× · in use %.1f", + readout.gameW, readout.slider, readout.slider * readout.gameW); } else - ImGui::TextDisabled("Reading the exposure..."); + { + ImGui::TextColored(live, "Exposure — · pre %.2f · scale %.2f", readout.p, + readout.s); + } } else if (source == 2) { diff --git a/OptiScaler/dlssnr/README.md b/OptiScaler/dlssnr/README.md index 72e8e745c..bcc4bf244 100644 --- a/OptiScaler/dlssnr/README.md +++ b/OptiScaler/dlssnr/README.md @@ -52,7 +52,7 @@ experiment. | `forwarder/` | the caller-gate shim, built by `dlssnr_forwarder.vcxproj` into the release layout | | `shaders/dlssnr/DlssNr_Dx12.h/.cpp` | the pass: forwarder loading, feature lifetime, the evaluate path, encode/resolve orchestration, capture | | `shaders/dlssnr/DlssNr_Common.h` | the constant buffer, shared by the host and the shader | -| `shaders/dlssnr/precompile/dlssnr.hlsl` | **the live shader**: encode (scale and sRGB-encode with a soft knee), area downsample, resolve (RenoDX's two-branch composition, OkLab hue correction, AP1 clamp, the guard) | +| `shaders/dlssnr/precompile/dlssnr.hlsl` | **the live shader**: encode (scale and sRGB-encode with a soft knee), area downsample, resolve (RenoDX's two-branch composition, OkLab hue correction, AP1 clamp, the guard). D3D12 samples the game's exposure this frame when WhitePointSource is 1 and the texture is usable. Native Vulkan working scale is live; source 1 there still uses the delayed CPU courier. | | `shaders/dlssnr/precompile/DlssNr_Shader.h` | that shader compiled, as bytes | ### Editing the shader @@ -65,6 +65,13 @@ cd OptiScaler/shaders/dlssnr/precompile python ../../shader_tools/create_header.py DlssNr_Shader.cso DlssNr_Shader.h DlssNr_cso ``` +Vulkan (SPIR-V, `dlssnr_spv`): + +``` +../../shader_tools/dxc.exe -spirv -T cs_6_0 -E CSMain -O3 -Qstrip_debug -D VK_MODE -Cc -Vi dlssnr.hlsl -Fo DlssNr_Shader_Vk.spv +python ../../shader_tools/create_header.py DlssNr_Shader_Vk.spv DlssNr_Shader_Vk.h dlssnr_spv +``` + **fxc `cs_5_0`, not the dxc in `build_precompiled_shader.bat` next to it.** Only fxc reproduces the committed header byte for byte; dxc emits DXIL and would silently change what the pass runs on. Verified by recompiling the unmodified shader both ways and diffing. diff --git a/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md b/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md new file mode 100644 index 000000000..c82b23e68 --- /dev/null +++ b/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md @@ -0,0 +1,959 @@ +# Game exposure as paper white (hhkbble rewrite) + +> **Rebase note (2026-09-03):** [2026-09-03-rebase-onto-dlss-neural-rendering.md](2026-09-03-rebase-onto-dlss-neural-rendering.md) +> wins where this file conflicts. Approach B still applies on D3D12 source 1. The origin +> WhitePointSource dropdown and scan survive. `ResolveWhitePoint` stays for sources 0 and 2. + +**Status:** design for implementation. Rewritten 2026-09-03 for `dlssnr-hhkbble`; review locks +applied. Supersedes the `1c1d39e2` draft of this filename. A plan must be written from **this** +file, not from the old offsets, file list, rebuild commands, or “no native Vulkan pass” +assumption. +**Branch:** `dlssnr-hhkbble`. Line numbers are from the working tree after the matched-residual +corrections (resolve t3 = `colorCopy` / `g_vk.proxy`). +**Path:** Approach B — Encode and Resolve **sample the exposure texture on the GPU**. Zero frames of +lag on the picture. The menu number may lag; it is a readout, not the control signal. + +This is a **replacement** of the live Dx12 path (Mode 3 courier → readback → CPU +`ResolveWhitePoint` → `gWhitePoint`), not a second white-point mechanism beside it. + +The model is shown `frame / W`. Today `W` is either the Paper white slider or a CPU value +`clamp(PreExposure / gameExposure * slider, 0.01, 4096)` computed from a texel that arrived +**three frames ago**. Some games already hand DLSS an `ExposureTexture` whose job is to say what +the colour buffer’s units are. This document makes that texture the optional source of `W` +**this frame**, with the existing checkbox as a preference the user can turn off. + +`GameW` polarity is a **required acceptance gate** (§7.2, §14 T0), not a settled constant. The +starting algebra matches today’s CPU path when `Exposure.Scale` is 1 (FSR’s published +convention). The live `0.01…4096` clamp is **dropped** (§7.2). Invert only `PaperWhite()` / +`GameWhite()` if a real title shows the other way. + +This file **supersedes** the Mode 3 t3 row in `2026-09-03-matched-residual-corrections.md`. It +does **not** supersede that file’s resolve t3 row (`colorCopy` / `g_vk.proxy`). + +--- + +## 0. What changed versus the `1c1d39e2` draft + +The old draft was written against `dlssnr-pr-multipass` before this branch existed. These +assumptions are **false here** and must not be planned from: + +| Old draft | This branch | +|---|---| +| `HdrLift` at offset 72; new fields from 76 | **No `HdrLift`.** Last field is `DebugScale` at 72. New fields still start at 76, appended after `DebugScale`. | +| t3 free / vestigial; t4 = exposure | **t3 is live on resolve.** Binding exposure on resolve t3 makes Matched-at-reduced \(P\) the exposure texel. Exposure is t4. | +| Only rebuild fxc via `build_precompiled_shader.bat` | Rebuild **both** blobs with the §13 commands. Do **not** run that bat. | +| “Do not add a native Vulkan composition path” | Native Vulkan composition **already exists**. It still must **not** sample the game’s `VkImage` (§7.5). | +| Multi-pass `IFeature_Dx12` is a second NR call site | **No Multi-pass NR.** The only Dx12 entry is `EvaluateAfterUpscale`. | +| INI `UseGameExposure` | Keep **`WhitePointFromExposure`**. | +| Slider range `0.25 … 4.0` | Keep **`0.25 … 240`**, logarithmic. | +| Hairline writes `1.0` (normalised white) | Hairline is written **after** `result *= normScale` (`dlssnr.hlsl:717` then `730`). That site is in **frame units**. Today it writes `gWhitePoint` because that *is* `W`. After this change write **`PaperWhite()`** there, not `1.0` and not the slider. | +| Debug views 1–5 use `PaperWhite()` | Views 1–3 already use **`gDebugScale`**. Do not switch them to `PaperWhite()`. | +| `CopyTextureRegion` of the game resource | **Rejected.** Keep the 1×1 Mode 3 courier for the menu / held `E` only. | +| `codec::TypedFormat` / `DlssNr_Codec.h` / `area_fixture.cpp` | **None exist.** Usable helper is `TranslateTypelessFormats`. Fixture is new and standalone. | +| Checkbox “off by default” | Default is already **`true`**. Fix the comment; do not flip the default. | +| `TEXTURE1D` is usable | **2D only.** HLSL is `Texture2D`. | +| Vulkan `Dispatch` “six views or a seventh, either is fine” | **Six views.** Binding 8 is always the existing dummy inside `WriteDescriptors`. | + +What is still true from the old draft: Approach B; three predicates; picture ≠ menu clock; dummy +SRV; no `DLSSD.Exposure` alias; bridges make a **present** texture visible to NR even when +AutoExposure is on; default no barrier; polarity T0; no `g_nrMutex` on the menu. + +--- + +## 1. Why this exists + +`W` is a property of how the game stores light, not of how bright this shot is. + +A measured frame-mean (the deleted statistical probe) chases content. The live “take white point +from the game” path is the right *source* and the wrong *clock*: Mode 3 copies the 1×1 into a UAV, +a 4-slot ring maps it ~3 frames later, and `ResolveWhitePoint` writes that stale float into +`gWhitePoint`. Encode and resolve then divide by a number the game is no longer using. + +Approach B keeps the source and drops the clock. The shader `Load`s texel `(0,0).r` of this +frame’s texture. Readback stays, for the overlay and for the hole’s held `E`. + +If the game does not supply a **usable** texture, the buffer is usually already in a space where +`W = 1` is right. Cyberpunk 2077 is the working example. Those games must keep today’s look +(slider only, no dispatch that treats the frame’s top-left pixel as exposure). + +--- + +## 2. Product option + +One checkbox, one slider, the **existing** INI keys. The slider is **not** a second white point. +It is one stored float whose **meaning** changes with whether game exposure is actually in force. + +| State | Checkbox | Slider label / format | Stored float means | `W` the shader uses | +|---|---|---|---|---| +| Game exposure **effective** | on, enabled | `Paper white` `%.2f×` | multiplier on the game’s `W` | `slider × GameW` | +| Game exposure **off** (user, or not allowed) | off, or disabled | `Paper white` `%.2f` | absolute `W` | `slider` | + +The `×` in the format string is Unicode `×` (U+00D7), not ASCII `x`. + +`1.0` is identity in both columns. Toggling does **not** rewrite the stored float and does **not** +rescale it (1.25× on `GameW ≈ 80` and absolute 1.25 are different pictures; that is intended). +Range stays `0.25 … 240` in both modes, `ImGuiSliderFlags_Logarithmic`, same as today. + +Today’s slider always prints `%.2fx` while often meaning an absolute `W`. That is a lie. The `×` +appears only when the value is a multiplier. The current label split +(`Paper white (x exposure)` vs `Paper white`) goes away: one label, format carries the meaning. + +INI (keys unchanged): + +``` +[DlssNr] +WhitePointFromExposure=true +WhitePointScale=1.0 +``` + +`WhitePointFromExposure` is a **preference**. It is not a promise that this frame used the +texture. Fresh install / missing key: `true` (already `CustomOptional { true }`). A game +that cannot supply a usable exposure never becomes effective, so the default does not move +Cyberpunk. + +Comment fixes in `Config.h` (no new keys): + +- `DlssNrWhitePointFromExposure`: delete “Off by default until it has been seen to work”. +- `DlssNrWhitePointScale`: it is the slider (absolute `W` or a multiplier), not “multiplies the + auto or manual white point”. +- Delete the orphan meter-chase paragraph at `Config.h:288–298` (no field under it). + +Unknown / hand-edited bools follow the existing `CustomOptional` pattern +(`DlssNrAutoCapture` is the default-true precedent). + +The Colour menu has **no** Reset (`R`) buttons today. Do not add them. + +--- + +## 3. Non-goals + +- Do not bring back frame-mean metering. Do not revive `WhitePointForMean`, `kWhitePointBlend`, + or `kTargetEncodedMean`. Deleting those unused functions is allowed and **out of scope** unless + a plan lists them. +- Do not change Classic / Matched residual / UpgradeToneMap / Mode 2 except the source of `W`. + Do not replace residual-block `gMotion` reads (`dlssnr.hlsl:602–603`) with `gExposure`. +- Do not bind exposure on **resolve** t3. t3 on resolve is `colorCopy` / `g_vk.proxy`. +- Do not rename `gMotion`. Do not add a sixth Dx12 SRV (`kSrvCount` stays 5). +- Do not renumber Vulkan `[[vk::binding]]` 0–7. t4 is **binding 8**. +- Do not add a seventh view to `DlssNr_Vk::Dispatch`. +- Do not rebuild the NR feature, the Dx12 PSO, or scratch textures when the checkbox moves. + Next `Dispatch` is enough. Both blobs are rebuilt **once** with this change (§13). +- Do not sample the game’s native-Vulkan `ExposureTexture` image. Do not pass its `ImageView` + into the pass. +- Do not invent a `DLSSD.Exposure` alias. One key: `NVSDK_NGX_Parameter_ExposureTexture` + (`"ExposureTexture"`). Do not call `GetResource(ExposureTexture, "DLSSD.Exposure")`. +- Do not let the user tick the checkbox when the environment cannot honour it. +- Do not drive the picture from the UI readout. Readback never writes + `DlssNrConstants.WhitePoint` except the hole row in §7.3, which writes a **synthesized + absolute `W`**, not the raw texel. +- Do not change `DlssNrUseProxy`’s early return. Encode still uses `PaperWhite()` and t4 per + §7.3. The courier still runs (§7.6). Resolve does not. +- Do not change `AutoExposure()`, `ForceAutoExposure`, or how the DX12 **upscaler** consumes + that flag. The NR `Set` is **after** `dx12Feature->Evaluate` (§8.6). +- Do not invent a D3D12 resource state. Default is no barrier (§7.4). +- Do not `CopyTextureRegion` / `CopyResource` the game’s exposure texture. +- Do not throw out of `Dispatch` because an exposure pointer is unusable. +- Do not take `g_nrMutex` on the menu thread. +- Do not shrink the slider to 4.0. Do not rename the INI keys. +- Do not switch debug views 1–3 from `gDebugScale` to `PaperWhite()`. +- Do not add Multi-pass / `IFeature_Dx12.cpp` NR plumbing. +- Do not change the shared Vulkan dummy’s format, layout, or never-cleared contract. + +--- + +## 4. Enablement (the only state machine) + +Three predicates plus native Vulkan. Do not collapse them. + +``` +CanEnable = sessionHasTexture && !sessionPassthrough && haveEvaluated && !IsRunningVk() +Preference = Config.DlssNrWhitePointFromExposure // may be true while CanEnable is false +Effective = CanEnable && Preference +``` + +| Predicate | Meaning | +|---|---| +| `haveEvaluated` | `DlssNr_Dx12::Dispatch` has recorded at least one **encode**. Set only there, after the bindless restore-skip (`~1425`) and the create-hold / feature-null / `haveCodec` returns, immediately before encode is recorded. Peeking the parameter block in `EvaluateAfterUpscale` does **not** set it. Native Vulkan does **not** write this latch. | +| `sessionHasTexture` | At least one of those encodes was handed a **usable** `ExposureTexture` (§7.3). Latched for the process. A later null or unusable pointer does **not** clear it. Native Vulkan never sets this. | +| `sessionPassthrough` | The last Dx12 encode’s `isHdrBuffer` was false. Updated every Dx12 encode. | +| `IsRunningVk()` | Native Vulkan is the live path. `CanEnable` is false. Existing function; not a new latch. | + +Storage: `std::atomic` next to `g_nr` for the three Dx12 latches. `Dispatch` already holds +`g_nrMutex` when it writes them. The menu reads atomics **without** that mutex. Never hand the +game `ID3D12Resource*` to ImGui. + +Lifetime: + +- **Park / resolution rebuild:** invalidate in-flight readback slots for the overlay + (`meterExposureValid[]` / slot fences). Do **not** zero the last finite held `E`. Do **not** + clear `CanEnable` latches. Do **not** park the dummy. +- **`Shutdown`:** clear the three Dx12 latches, held `E`, dummy, and the readback ring. Today’s + `Shutdown` (`~1981`) does not zero `exposureFrames` / `gameExposure`; this change must. + +`AutoExposure` does **not** enter `CanEnable`. If a title’s texture is garbage, the user turns +the checkbox off. + +`ForceAutoExposure` / AutoExposure games that **never** publish a usable texture stay at +`CanEnable == false`. The slider remains an absolute `W`. + +### 4.1 What the user can do + +- **Checkbox interactable** iff `CanEnable`. Otherwise `BeginDisabled`. +- **Checkbox shown checked** iff `Effective`. When `CanEnable` is false, pass a `false` + temporary into `ImGui::Checkbox` so it draws unchecked even if `Preference` is still true in + the INI. Only write `Preference` when `CanEnable` and the user toggles. +- Losing `CanEnable` does **not** write `Preference = false`. + +### 4.2 What the slider means + +Follow **`Effective`**, not `Preference` alone and not per-frame holes. + +- `Effective == true` → multiplier. Format `%.2f×`. Help: multiplier. +- `Effective == false` → absolute `W`. Format `%.2f`. Help: absolute. + +A missing texture on one evaluate must not flip the slider format. See §7.3 for that frame’s +`W`. + +### 4.3 Status line (exactly one, always visible under the checkbox) + +`ImGui::Text` / `TextDisabled` / green `ImVec4(0.45f, 0.8f, 0.45f, 1.0f)` (today’s green at +`DlssNr_Menu.cpp:357`). Not a second checkbox. + +| Condition (first match) | Colour | Copy | +|---|---|---| +| `IsRunningVk()` | disabled | `This path cannot sample the game’s exposure. Paper white below is in use.` | +| `!haveEvaluated` | disabled | `Waiting for Neural Rendering.` | +| `sessionPassthrough` | disabled | `This buffer is already tone-mapped. Paper white is unused.` | +| `!sessionHasTexture` | disabled | `This game does not supply an exposure.` | +| `CanEnable && Effective` | green | `Using the game’s exposure.` | +| `CanEnable && !Effective` | green | `This game supplies an exposure.` | + +Drop today’s orange “Tick above to use it” and the orange Cyberpunk line on an interactable +box. + +When `IsRunningVk() && ExposureOfferedVk()`, **append** this sentence to the checkbox help +marker (not a second status line): `This game offered one; it is not sampled on this path.` + +### 4.4 Numeric readout + +Under the slider, only when `CanEnable`. `P` / `S` from the latest CPU `Get`. `E` / `game white` +from the last successful courier readback. + +``` +Exposure 0.012 · pre 1.00 · scale 1.00 · game white 83.3 · in use 83.3 +``` + +If `Effective` is false, replace `in use …` with `not in use`. + +`game white` is `GameWhite(e, p, s)`. `in use` is `slider × gameW`. + +Until the first successful readback: `Exposure —` and `game white —`. Never print `0` as a fake +exposure. + +Help marker: `Shown for the menu. The pass samples the texture on the GPU; this number can lag +a frame or two.` + +When `!CanEnable`, print nothing numeric. + +--- + +## 5. Menu copy + +Replace `DlssNr_Menu.cpp` ~293–403. No `R` buttons. + +**Blurb** (disabled text; fold today’s passthrough sentence in): + +``` +The model was trained on finished, sRGB-encoded frames. The upscaler’s +output is not one: it is linear and open-ended. Paper white is how that +buffer is mapped into something the model recognises. A frame the game +reports as already tone-mapped is passed over untouched and none of +this applies. +``` + +**Checkbox** label: `Take white point from the game` + +Help marker (checkbox). When `IsRunningVk() && ExposureOfferedVk()`, append the sentence in +§4.3. + +``` +When a game hands DLSS a 1×1 exposure texture, that texture is the +engine’s own scale for the colour buffer. Tick this to derive paper +white from it instead of guessing. + +The box is disabled when this session has not seen such a texture, when +the buffer is already tone-mapped, or on native Vulkan (the image +layout is not known, so it is not sampled). + +The preference is kept if the box is disabled. A later D3D12 game that +does supply an exposure will use it again. +``` + +**Slider** label: `Paper white` in both modes. + +Help when **`Effective`**: + +``` +A multiplier on the white point taken from the game. 1.00× means use +that value as-is. + +Above 1 the picture handed to the model is darker; below 1, brighter. +If a game still looks washed out after taking its exposure, this is +the bias. + +At detail strength 0 this does not move the edited picture. +``` + +Help when **not `Effective`**: + +``` +What the frame is divided by before the model sees it. + +The model was trained on finished frames where white sits at 1. The +upscaler’s output is linear and open-ended, so something has to say +where white is, and 1.0 is right for most games that do not supply +an exposure. + +Above 1 the picture handed over is darker; below 1, the opposite. +If a game looks washed out or flat, this is the first thing to move. + +At detail strength 0 this does not move the edited picture. +``` + +Drop the current slider help’s “There is no other white point”, the Monster Hunter paragraph, +and the “this was once a multiplier on a measured white point” history. + +--- + +## 6. Contracts (must hold) + +| Name | Rule | How | +|---|---|---| +| Strength 0 | Unchanged picture | Encode and Resolve use the **same** `W` this dispatch. Strength 0 still writes `hdrCopy`. Compare off, debug off. | +| Same `W` both passes | Encode and Resolve agree | Same four values on **both** constant structs: `WhitePoint`, `UseGameExposure`, `PreExposure`, `ExposureScale`. Same t4. Same `PaperWhite()`. Dx12 today builds `resolveParams` as a fresh `{}` (`~1631`): `resolveParams = encodeParams` then overwrite `Mode` / strengths / compare / debug as today. Vulkan already does `resolve = encode`. Downsample may leave the new fields zero. | +| Identity slider | `1.0` does nothing extra | Absolute: `W = 1`. Multiplier: `W = GameW`. | +| No rescale on toggle | Stored float is untouched | Do not rewrite `WhitePointScale` when the box moves. | +| Unsupported cannot enable | Checkbox not interactable | `BeginDisabled(!CanEnable)`. Drawn unchecked via a `false` temporary. | +| Slider matches Effective | Format and help follow `Effective` | Unicode `×` only when `Effective`. | +| Passthrough | No encode curve, no `W` | Existing early-return at `dlssnr.hlsl:448–451`. `normScale` stays `1.0` when `gPassthrough != 0`. `gUseGameExposure` is 0. | +| No usable texture this process | Today’s look | `Effective` false. `W = slider`. No Mode 3. | +| Picture ≠ menu clock | GPU sample is authoritative | Readback never feeds `WhitePoint` except the §7.3 hole row. | +| Typed + untyped | Bridges work | `Get` as `ID3D12Resource**` then `void**`, one name. | +| One Dx12 call site | No Multi-pass fill | `EvaluateAfterUpscale` only. Invoked from `NVNGX_DLSS_Dx12.cpp` (2), `IFeature_Dx11wDx12.cpp:421`, `IFeature_VkwDx12.cpp:2112`. | +| Bridges + AutoExposure | Present texture is visible to **NR** | §8.6. Upscaler `Evaluate` is unchanged. Missing + AE is not an error. | +| Dummy SRV (Dx12) | No empty descriptor | t4 is always a valid 2D SRV. Missing / unusable → 1×1 `R32_FLOAT` of `1.0`. **Not** `InSource`. `DispatchPass` 5th-slot null → this dummy. | +| Bindable or dummy | No throw, no device removal | §7.3. | +| Bad texel | No NaN `W` | §7.2. `Load` only after the flag check. | +| Debug stays still | Instrument ≠ live `W` | Views 1–3 keep `gDebugScale`. | +| Hairline is frame-unit white | Line stays visible when `GameW` is large | After `result *= normScale`, write `PaperWhite()`, not `1.0`, not `gWhitePoint`. | +| Default no barrier | Native path stays safe | §7.4. | +| Menu lock-free | Overlay does not hitch | Atomics only. | +| Polarity gate | Wrong `GameW` does not ship | §14 T0. | +| t3 residual contract | Unchanged | Resolve t3 remains `colorCopy` / `g_vk.proxy`. | +| Native Vulkan | Slider only | Six-view `Dispatch`. Binding 8 = existing dummy. `gUseGameExposure = 0`. | +| INI / range | Unchanged keys and travel | `WhitePointFromExposure`, `WhitePointScale`, `0.25…240` log. | +| Clamp | No `0.01…4096` | `max(W, 1e-4)` only. Intentional vs today’s CPU clamp. | + +--- + +## 7. Shader + +Live shader is `OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl`, entry `CSMain`. A stale +`DlssNr_Shader.h` / `DlssNr_Shader_Vk.h` is a silent old shader (Dx12 constructor passes +`source = nullptr`; Vulkan loads `dlssnr_spv`). + +### 7.1 Constants + +Append after `DebugScale`. Do not reorder existing fields. `Transfer` stays at 68. + +``` +offset 0 uint Mode +offset 4 float WhitePoint // slider, except the §7.3 hole row +offset 68 uint Transfer +offset 72 float DebugScale +offset 76 uint UseGameExposure // 1 only when Effective && this-frame usable +offset 80 float PreExposure // NVSDK_NGX_Parameter_DLSS_Pre_Exposure; 0 → 1 +offset 84 float ExposureScale // NVSDK_NGX_Parameter_DLSS_Exposure_Scale ("DLSS.Exposure.Scale"); 0 → 1 +``` + +```cpp +static_assert(offsetof(DlssNrConstants, Transfer) == 68, ...); +static_assert(offsetof(DlssNrConstants, DebugScale) == 72, ...); +static_assert(offsetof(DlssNrConstants, UseGameExposure) == 76, ...); +static_assert(offsetof(DlssNrConstants, PreExposure) == 80, ...); +static_assert(offsetof(DlssNrConstants, ExposureScale) == 84, ...); +static_assert(sizeof(DlssNrConstants) == 256, "CBV size is 256-aligned"); +``` + +HLSL, immediately after `gDebugScale`, same order, no extra padding: + +``` +uint gUseGameExposure; +float gPreExposure; +float gExposureScale; +``` + +There is no `HdrLift`. Do not add one. + +### 7.2 `PaperWhite()` and polarity + +Used at exactly two picture sites, plus the hairline: + +| Site | Today | After | +|---|---|---| +| Encode `dlssnr.hlsl:466` | `SoftKnee(frame / max(gWhitePoint, 1e-4))` | `SoftKnee(frame / PaperWhite())` **below** the passthrough return at 448–451. Do not call `PaperWhite()` on that early-return path. | +| Resolve `normScale` at 526 | `gPassthrough != 0 ? 1.0 : max(gWhitePoint, 1e-4)` | `gPassthrough != 0 ? 1.0 : PaperWhite()` | +| Hairline at 730 (after `result *= normScale` at 717) | `float3(gWhitePoint, …)` | `float3(PaperWhite(), PaperWhite(), PaperWhite())` | + +Not used by debug views 1–3 (`gDebugScale`). Not used by residual \(P\). + +``` +float PaperWhite() +{ + float slider = max(gWhitePoint, 1e-4); + if (gUseGameExposure == 0) + return slider; + + float e = gExposure.Load(int3(0, 0, 0)).r; + if (!(e > 1e-6 && e < 1e6)) + e = 1.0; + + float s = max(gExposureScale, 1e-4); + float p = max(gPreExposure, 1e-4); + float gameW = p / max(e * s, 1e-4); // starting polarity; see T0 + return max(slider * gameW, 1e-4); +} +``` + +Do not hoist `gExposure.Load` above the flag check. Do not reintroduce +`clamp(..., 0.01, 4096)`. + +Host mirror `GameWhite(e, p, s)` in `dlssnr/DlssNr_Exposure.h` (pch-free, no d3d12). Same +gates, same starting `p / (e * s)`, same `max(..., 1e-4)`. A commented invert line +(`// return e * s / p;`) is what T0 flips in both copies. + +\[ +\mathrm{GameW} = \frac{P}{E \cdot S}, \qquad +W = \begin{cases} +\mathrm{gWhitePoint} \times \mathrm{GameW} & gUseGameExposure = 1 \\ +\mathrm{gWhitePoint} & \text{otherwise} +\end{cases} +\] + +On a normal Effective frame `gWhitePoint` is the slider. On a hole it is already +`slider × GameWhite(heldE, thisP, thisS)` and the flag is 0, so `PaperWhite()` returns that +absolute `W` unchanged. + +**T0.** Title that publishes a usable texture (GTA V Enhanced is the known publisher on this +fork; any other publisher is fine). Same scene, strength > 0, wipe on, debug off: + +1. Box off, hand-tune the absolute slider until the edited half looks right. Note `W_abs`. +2. Box on, slider `1.00×`. The picture must match `W_abs` (same order of magnitude; not + crushed vs blown). +3. If inverse, change **only** the `gameW` line to `e * s / p` in HLSL and in `GameWhite()`. + Record the title. Do not change §4, the SRV slot, or the menu. Do not rescale the slider. + +### 7.3 t4 and a usable resource + +**t4 becomes `gExposure`.** `kSrvCount` stays 5. Dx12 root signature does not change. Rename +`DispatchPass`’s `InPrevEdit` to `InExposure` **in place** (it stays the 5th argument). Do not +swap it with `InMotion`. + +``` +#ifdef VK_MODE +[[vk::binding(8, 0)]] +#endif +Texture2D gExposure : register(t4); +``` + +Declare it immediately after `gMotion` (t0–t4 together). Do **not** give it +`[[vk::binding(5, 0)]]` — that is `gTarget`. + +`CreateShaderResourceView` **throws** on null, `DENY_SHADER_RESOURCE`, `BUFFER`, and +`UNKNOWN` (`Shader_Dx12.cpp:189–250`). It will happily build a 1D or MSAA view that does **not** +match `Texture2D`. Usable must exclude those so `Dispatch` never throws. + +**Usable** (all of these): + +1. `res != nullptr` +2. `GetDesc().Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D` +3. `DepthOrArraySize == 1` +4. `SampleDesc.Count == 1` +5. `DENY_SHADER_RESOURCE` is not set +6. Let `viewFmt = Shader_Dx12::TranslateTypelessFormats(desc.Format)`. If `viewFmt == desc.Format` + **and** `desc.Format` is a `*_TYPELESS` **resource** enum (the translate switch did not map + it), unusable. `R16_TYPELESS` is this case. Do **not** reject a *mapped* view format whose + name still contains `TYPELESS` (e.g. `R24G8_TYPELESS` → `R24_UNORM_X8_TYPELESS`). Do **not** + use `TypedGuideFormat` (`R16_TYPELESS` → `UNORM`). + +1D, 2D arrays, 3D, MSAA, buffers, DENY, leftover-typeless → dummy, no throw. Keep +`Texture2D` and `Load(int3(0,0,0)).r`. + +Only a usable resource may latch `sessionHasTexture` or be bound as encode/resolve t4 when +`Effective`. + +**`DispatchPass` 5th slot:** change the fallback **inside** `DispatchPass` +(`DlssNr_Dx12.cpp:1056`) from `InSource` to the Dx12 dummy. Other slots may keep the `InSource` +stand-in. Callers still pass the dummy or the game resource; they must not rely on “we always +pass non-null.” + +Dx12 dummy: one 1×1 `R32_FLOAT`, value `1.0`, created with the compose pass, released in +`Shutdown`. Survives park. Separate from the Vulkan dummy. + +| This frame | `gUseGameExposure` | encode/resolve t4 | `gWhitePoint` | +|---|---|---|---| +| `Effective` and usable | `1` | game resource | slider (the stored float) | +| `Effective` and hole, held `E` exists | `0` | dummy | `slider × GameWhite(heldE, thisP, thisS)` | +| `Effective` and hole, no held `E` yet | `0` | dummy | slider | +| not `Effective` | `0` | dummy | slider | + +Hole = `Effective` in the UI, this frame’s pointer null or unusable. Do **not** bind a +last-frame pointer. Do **not** run `gUseGameExposure=1` against dummy `E=1`. GTA V dropped the +texture three times in one session; the hole **keeps the user multiplier** on the held `E` +(`slider × GameWhite(...)`, not bare `GameW` and not bare `slider` when a held `E` exists). +Log the hole at most once per process. + +Held `E` is the last finite Mode 3 readback. `thisP` / `thisS` are this frame’s CPU scalars. + +SRV format for a usable game resource: `viewFmt` from the usable check. `Load` on `.r` is +enough for `R32_FLOAT`, `R16_FLOAT`, and RGBA stand-ins. + +### 7.4 Barriers (Dx12) + +Use the pointer only inside this `Dispatch`. Do not cache it. + +- **Default:** no barrier. Mode 3 already `Load`s as an SRV without a transition. +- **If `Config::ExposureResourceBarrier` has a value** (INI `[Hotfix] ExposureResourceBarrier`, + integer `D3D12_RESOURCE_STATES`; any set value is enough for the test row): + transition `(D3D12_RESOURCE_STATES)value` → `NON_PIXEL_SHADER_RESOURCE` **before the first + dispatch that binds the game resource as t4**, and restore to that same integer **after the + last** such dispatch. + + First / last this frame (game resource on t4): + - `Effective && usable` and resolve runs: first = encode, last = resolve (Mode 3 sits + between). + - `Effective && usable` and `UseProxy` returns (no resolve): first = encode, last = Mode 3. + - `!Effective && usable` (courier only): first = last = Mode 3. + - not usable: no transition. + +DX11 / Vulkan w/Dx12 copies are already in a known readable state at the hand-off. Still apply +the hotfix if set. + +### 7.5 Native Vulkan: do not sample the game image + +`DlssNrFeature_Vk.cpp:394–404` stays policy. + +Locked consequences: + +- Keep the **six-view** `Dispatch` signature. Do not add a seventh view. +- `WriteDescriptors` always writes binding 8 with the **existing** dummy + (`readInfo(VK_NULL_HANDLE)` → `_dummyView`, `VK_IMAGE_LAYOUT_GENERAL`). Same path as today’s + null t1–t3. +- Do not change the dummy’s format (`R16G16B16A16_SFLOAT`), `UNDEFINED → GENERAL` once, or + never-cleared contract. It is **not** the Dx12 `R32_FLOAT = 1.0` image. `PaperWhite()` must + not `Load` it (`gUseGameExposure` stays 0). +- Pool `COMBINED_IMAGE_SAMPLER` count `4 * kSlots` → `5 * kSlots`. Add + `CreateBinding(8, COMBINED_IMAGE_SAMPLER)`. Do not renumber 0–7. +- Update the “seven resources / four read views” comments (`DlssNr_Vk.h:12–15, 58–59`, + `DlssNr_Vk.cpp:119`) to eight resources / five reads. +- `EvaluateAfterUpscaleVk` must not pass the peeked exposure `ImageView`. `WhitePoint` = slider. +- Keep the existing peek + log of `ExposureTexture` / `DLSS.Pre.Exposure`. It does not enable + the box. + +Vulkan **w/Dx12** is not this path. + +### 7.6 Mode 3 (menu + held `E` only) + +Mode 3 is no longer the picture courier. One dispatch site, not two. + +**When:** this frame’s `frame.ExposureTexture` is usable, **independent of `Effective`**. +**Where:** after encode, before downsample, **before** the `UseProxy` return +(`DlssNr_Dx12.cpp:1547–1565`). That way proxy still fills the ring. Do not also run it after +resolve. + +**Binds (after-lines).** `DispatchPass(cmdList, constants, InSource, InModel, InOriginal, +InMotion, InExposure, OutTarget, OutKeep)`: + +| Pass | InMotion (t3) | InExposure (t4) | Notes | +|---|---|---|---| +| Meter (Mode 3) | `nullptr` (unread `InSource` stand-in) | usable game resource | 1×1. Tile 0 = `gExposure.Load`. | +| Encode | `nullptr` | §7.3 table | | +| Downsample | `nullptr` | same t4 as encode (unread) | | +| Resolve | `g_nr.colorCopy` | §7.3 table | t3 **stays** `colorCopy`. | + +Vulkan encode/resolve argument order does not change. Binding 8 is dummy inside the pass. + +HLSL tile 0: change `gMotion.Load` to `gExposure.Load`. Update comments at `dlssnr.hlsl:220` +and `339–343` so they no longer say the meter binds exposure on t3. + +Do not dispatch Mode 3 when the pointer is missing or unusable. Once per process, log when the +courier *does* run (width, height, format, `P`, `S`) so Cyberpunk “no Mode 3” is checkable. + +Today the meter sits before encode and wraps `target` UAV → SRV → UAV (`~1469–1474`). **Move +that existing pair with the courier.** Do not invent a second barrier recipe. + +The 64×64 tile-mean branch stays dead. Shrinking the meter UAV is out of scope. + +**Delete** `ResolveWhitePoint`. Do not leave a hollow function. + +--- + +## 8. CPU plumbing + +### 8.1 `DlssNrFrameInfo` + +The struct already has `ExposureTexture` and `PreExposure` (`DlssNr_Common.h:80–85`). Add: + +```cpp +float ExposureScale = 1.0f; // 0 already folded to 1 at the reader +``` + +Always write `frame.ExposureTexture`, never `frame.Exposure`. Slider stays in Config. + +### 8.2 Reader (one function, one NR call site) + +```cpp +struct NrExposure +{ + ID3D12Resource* texture = nullptr; + float pre = 1.0f; + float scale = 1.0f; +}; +NrExposure ReadNrExposure(NVSDK_NGX_Parameter* params); +``` + +- Resource: `Get` `NVSDK_NGX_Parameter_ExposureTexture` as `ID3D12Resource**`, then as + `void**`. No second name. +- `NVSDK_NGX_Parameter_DLSS_Pre_Exposure`, `NVSDK_NGX_Parameter_DLSS_Exposure_Scale`: `Get` + float; missing or `0` → `1`. +- Used only by `EvaluateAfterUpscale`. Replace `~1869–1878`. + +Usable is decided inside `Dispatch`. + +Order on a path that will record encode: + +1. `isHdrBuffer` (already here). +2. Early-outs that do not encode: do **not** write `haveEvaluated`. Do not increment + `exposureFrames` as a stand-in (that field is deleted, §8.3). +3. When encode will be recorded: + 1. `usable = ExposureUsable(frame.ExposureTexture)` + 2. `haveEvaluated = true` + 3. `sessionPassthrough = !isHdrBuffer` + 4. if `usable` → `sessionHasTexture = true` + 5. `Effective = CanEnable && Preference` using the updated latches + 6. Fill **encode and resolve** constants (`UseGameExposure` is 1 only when + `Effective && usable`; `WhitePoint` per the §7.3 table) + 7. Encode (t4 per §7.3) + 8. Mode 3 if `usable` (t4 = game resource, even when encode used dummy) + 9. Downsample if reduced + 10. `UseProxy` return, **or** evaluate + resolve (resolve t3 = `colorCopy`, t4 per §7.3) +4. Hotfix restore after the last game-t4 dispatch (§7.4) + +### 8.3 Menu queries + +Declared in `DlssNrFeature_Dx12.h`, implemented in `DlssNr_Dx12.cpp`: + +```cpp +bool GameExposureCanEnable(); +bool GameExposureEffective(); +enum class GameExposureWait { NativeVulkan, Waiting, Passthrough, Absent, Available }; +GameExposureWait GameExposureUiState(); // first match in §4.3 + +struct GameExposureReadout +{ + bool haveNumbers; + float e, p, s; + float gameW; + float slider; +}; +GameExposureReadout GameExposureMenuReadout(); +``` + +**Delete** `GameExposureStatus`, `ExposureStatus`, `exposureFrames`, `exposureOfferedNow`, +`exposureEverOffered` from the Dx12 path. The menu calls only the four functions above plus +`IsRunningVk` / `ExposureOfferedVk`. Do not leave two status machines. + +### 8.4 Readback (menu + hole `E`) + +Keep the existing 4-slot `meterReadback` ring and fence distance. Map only when the slot is +old enough. Never stall. Never write the decoded `E` into `WhitePoint` except by producing +held `E` for the §7.3 hole formula. + +Decode `R32_FLOAT` from the pass’s own meter UAV (tile 0). + +Park: §4 lifetime. Overlay shows `—` until a new slot returns; held `E` for the hole stays. + +### 8.5 Logging + +Once per process: first usable texture (width, height, format, `P`, `S`) — this is also the +Mode 3-ran log. Once: texel fails the range gate (readback, best effort). Once: UI-`Effective` +hole. Once: non-null pointer fails `ExposureUsable`. + +Existing “game exposure X -> white point would be Y” lines must not claim the CPU float is +what the encode used. + +### 8.6 Bridges: NR sees a DX12 pointer or null + +`EvaluateAfterUpscale` already runs while the DX12 copies are in the block (DX11 restore and +Vulkan null-out happen after). Keep that order around NR. + +**Do not** `mask |= Exposure` unconditionally. + +**Do not** `Set` the exposure copy before `dx12Feature->Evaluate`. That would change what the +upscaler sees on AE-on titles. Sequence in both bridges: + +1. Prepare / copy as below. +2. `dx12Feature->Evaluate` with **today’s** exposure `Set` rules (`!AutoExposure()` only). +3. **Then**, before `EvaluateAfterUpscale`: `Set(ExposureTexture, dx12Copy)` if a DX12 copy + exists this frame, else `Set(ExposureTexture, nullptr)`. +4. `EvaluateAfterUpscale`. +5. Restore the original pointer as today. + +The block at step 3 contains a DX12 resource or `nullptr`. Never a D3D11 or Vulkan handle. +`ReadNrExposure` then `GetDesc()` is safe. Do not `Set` a stale last-frame cache pointer. + +**`IFeature_Dx11wDx12` / `ProcessDx11Textures`** + +1. Peek `ExposureTexture` (existing D3D11 Get) **before** `PrepareUpscalerResources`. +2. `mask |= Exposure` if the pointer is present **or** `!AutoExposure()`. +3. If absent and `AutoExposure()`: do not add Exposure to the mask. +4. `MissingExposure` handler: `if (prepareResult.MissingExposure && !AutoExposure())` then + today’s force-AE + `changeBackend`. When AE is on, Exposure is optional; a miss skips the + NR Set (step 3 above), it does not fail Prepare or flip the backend. +5. Do not edit `with_dx12/dx11_with_dx12.cpp` cache-required semantics. + +**`IFeature_VkwDx12`** + +1. `Get` `ExposureTexture` even when `AutoExposure()` is true (today the Get is inside + `if (!AutoExposure())` at 1067). +2. If present: create `ExpCopy` the same way `1080–1081` does when AE is off, then + `CopyTextureFromVkToDx12` as today. Copy failure while AE is on: skip NR exposure (Set + nullptr), do **not** fail the whole evaluate. +3. If absent and `AutoExposure()`: do nothing (no `changeBackend`). +4. If `!AutoExposure()` and (Get failed **or** `NvVkResourceNotValid`): keep today’s warn + + force AE. Do not copy the live `Get != Success && !NvVkResourceNotValid` condition + (`1069–1076`) — failed Get leaves `nullptr`, `NvVkResourceNotValid(nullptr)` is true, so + that `&&` almost never fires. + +Do not change `AutoExposure()` itself. Native DX12 needs no bridge change. + +--- + +## 9. Data flow + +``` +NGX block ── ReadNrExposure ─► FrameInfo.ExposureTexture / PreExposure / ExposureScale + │ + ▼ +EvaluateAfterUpscale → Dispatch (encode path only) + usable? latch sessionHasTexture + haveEvaluated = true + │ + Effective && usable ── encode/resolve t4 = game, flag=1, WhitePoint=slider + Effective && hole ── encode/resolve t4 = dummy, flag=0, + WhitePoint=slider×GameWhite(heldE,thisP,thisS) or slider + otherwise ── encode/resolve t4 = dummy, flag=0, WhitePoint=slider + │ + ▼ + Encode: SoftKnee(frame / PaperWhite()) ◄── picture + Mode 3 1×1 if usable (t4 = game) ◄── menu + held E + Downsample / UseProxy return / Resolve + Resolve hairline: PaperWhite() after * normScale + debug 1–3: * gDebugScale + │ + ▼ + hotfix restore if any +``` + +w/Dx12: peek + copy happen before the upscaler; NR `Set` is after the upscaler, before this +diagram. + +Native Vulkan: skip the GPU sample; `W = slider`; binding 8 = dummy; no Mode 3. + +--- + +## 10. Interaction walkthrough (must stay true) + +1. **Cyberpunk, first launch (Dx12).** Preference default true. First encode: no usable + texture, linear HDR → status `This game does not supply an exposure.`, box disabled and + unchecked, slider `1.00` absolute. Picture = today’s (slider `W`). No Mode 3 (no first-usable + log). +2. **A title with a usable texture, first launch (Dx12).** After the first encode the box + enables and shows checked. Slider becomes `1.00×`. `W = GameW` **this frame**. Status + `Using the game’s exposure.` Readout fills when the fenced slot completes. +3. **User unticks.** Box enabled, unchecked. Status `This game supplies an exposure.` Slider + `1.00` absolute. `W = 1`. Mode 3 still runs (usable). Preference persisted false. +4. **User ticks again, drags to 1.25×.** `W = 1.25 × GameW`. Stored float `1.25`. Untick: + slider shows `1.25` (no `×`), `W = 1.25`. Tick: `1.25×` on `GameW` again. Float not + rewritten. +5. **Passthrough title.** After encode: box disabled, unchecked; tone-map status; slider + absolute; no readout. +6. **Menu opened before the first NR encode** (create-hold included). Waiting line; slider + absolute; no readout. +7. **Strength 0.** Edited pixels = `hdrCopy` (compare off, debug off). +8. **DX11 or Vulkan w/Dx12, AutoExposure on, texture present.** After the first encode the + box can enable. Upscaler `Evaluate` still ran with today’s AE-on Sets. NR saw the DX12 copy. +9. **DX11 or Vulkan w/Dx12, AutoExposure on, no texture.** Box stays disabled. No backend + change. `ExposureTexture` was `nullptr` at NR, not a D3D11/Vulkan handle. +10. **Native Vulkan.** Box disabled. Native-Vulkan status. Slider absolute. Picture = today. + Validation clean. If the game offered a texture, checkbox help says so. +11. **Unusable pointer.** Absent this frame. No throw. If one was usable earlier: hole, + `WhitePoint = slider × GameWhite(heldE, thisP, thisS)` (or slider if no held `E`), UI stays + multiplier. +12. **GTA V drops the texture for a frame.** UI stays multiplier. Picture uses + `slider × GameWhite(heldE, thisP, thisS)` once a readback has landed, not a flash to + `W ≈ slider`. +13. **Park / resolution rebuild.** Box stays in whatever `CanEnable` it had. Readout may show + `—`; held `E` for the next hole stays. +14. **`UseProxy` on.** Encode uses `PaperWhite()` and t4 per §7.3. Mode 3 still runs if + usable. Resolve does not. + +--- + +## 11. Files + +| File | Change | +|---|---| +| `shaders/dlssnr/precompile/dlssnr.hlsl` | `gExposure` t4 binding 8; three CB fields; `PaperWhite()` at 466 / 526 / 730 as §7.2; Mode 3 tile 0 + comments 220 / 339–343; rebuild §13 | +| `shaders/dlssnr/precompile/DlssNr_Shader.h` + `.cso` | Rebuild (`DlssNr_cso`) | +| `shaders/dlssnr/precompile/DlssNr_Shader_Vk.h` + `.spv` | Rebuild (`dlssnr_spv`) | +| `shaders/dlssnr/DlssNr_Common.h` | `ExposureScale` on `FrameInfo`; three fields + asserts | +| `shaders/dlssnr/DlssNr_Dx12.cpp` | reader, `ExposureUsable`, latches, dummy, `DispatchPass` 5th→dummy, four after-lines in §7.6, hotfix span, courier after encode (move today’s `target` UAV↔SRV pair with it), queries; **delete** `ResolveWhitePoint`; delete peek-machine fields | +| `shaders/dlssnr/DlssNr_Dx12.h` | 5th SRV is `InExposure` | +| `shaders/dlssnr/DlssNr_Vk.cpp` / `DlssNr_Vk.h` | binding 8 + pool count; dummy via `readInfo(VK_NULL_HANDLE)`; six-view signature unchanged; comments 7→8 / 4→5 | +| `dlssnr/DlssNrFeature_Vk.cpp` | flag 0; slider `W`; do not pass the game view | +| `dlssnr/DlssNr_Exposure.h` | pch-free `GameWhite()` | +| `dlssnr/tests/exposure_fixture.cpp` | §12 | +| `dlssnr/DlssNrFeature_Dx12.h` | new queries; delete `ExposureStatus` / `GameExposureStatus` | +| `upscalers/IFeature_Dx11wDx12.cpp` | §8.6 | +| `upscalers/IFeature_VkwDx12.cpp` | §8.6 including `ExpCopy` when AE on | +| `Config.h` | comment-only | +| `dlssnr/DlssNr_Menu.cpp` | §5 | +| `dlssnr/README.md` | one line on game exposure this-frame on D3D12; add the Vulkan blob command to “Editing the shader” | + +Do not touch NGX evaluate, guides, WorkingScale, Mode 2, residual binds, or +`with_dx12/dx11_with_dx12.cpp`. Do not edit `IFeature_Dx12.cpp`. + +--- + +## 12. Test plan + +`dlssnr/tests/exposure_fixture.cpp` is a standalone `main` with asserts. Header is pch-free. + +``` +cl /nologo /EHsc /std:c++17 /W4 /I OptiScaler OptiScaler\dlssnr\tests\exposure_fixture.cpp /Fe:exposure_fixture.exe +exposure_fixture.exe +``` + +`#include "dlssnr/DlssNr_Exposure.h"` from that compile (`/I OptiScaler`). Expected: exit 0. + +Named asserts: + +- `E` in `{NaN, +Inf, 0, 1e7}` → treated as `1` (same gate as the shader) +- `P = 0` or `S = 0` → folded to `1` before `GameWhite` +- `GameWhite(0.012, 1, 1) == 1 / 0.012` within `1e-4` +- commented invert `e * s / p` is present and not compiled in + +**T0.** GTA V Enhanced, or any other title that publishes `ExposureTexture`. Required before +done. Strength > 0, wipe on, debug off. Box off → note `W_abs`. Box on, `1.00×` → same look, +not the inverse. + +Default matrix: Dx12, `UseProxy` off, Output Scaling off, Compare off unless a row says +otherwise. + +- [ ] **T0** as above. +- [ ] Cyberpunk (or any no-texture HDR title): box disabled after first encode, picture + matches the build before this change at slider `1.00`. No first-usable / Mode 3 log. +- [ ] A publishing title: box enables, default on, slider shows `×`, readout gets a finite + `E` after the fence, not a fake `0`. Camera / exposure move: edited picture tracks this + frame, not a 3-frame lag. +- [ ] Untick / tick / drag: §10.4. Strength 0 still matches `hdrCopy`. +- [ ] DX11 w/Dx12 **and** Vulkan w/Dx12, AE **on**, texture present: box can enable; no + device removal; upscaler behaviour unchanged. AE **on**, no texture: box stays off, no + backend change. +- [ ] Native Vulkan: box disabled, native-Vulkan status, picture = slider only, validation + layers clean (binding 8 dummy). +- [ ] Passthrough / 8-bit output: box disabled, tone-map status. +- [ ] Menu before the first encode (create-hold): waiting line, no crash, no numeric `0`. +- [ ] `WhitePointFromExposure=true` in INI on a no-texture game: box stays off, slider + absolute, preference still `true` after save. +- [ ] First-unusable log fires if a non-null pointer fails `ExposureUsable` (implementer + confirms from the log when such a pointer appears; no title is required). +- [ ] Native DX12, hotfix unset: no exposure barrier, no device removal. Hotfix set to any + integer (`[Hotfix] ExposureResourceBarrier`): transition pair around the §7.4 span only. +- [ ] Wipe hairline stays visible when `Effective` and `GameW` is large (`PaperWhite()` after + `* normScale`, not `1.0`). +- [ ] Debug views 1–3 do not brighten/darken when ticking the box at slider `1.00`. +- [ ] Park / resolution rebuild: box stays enabled if it was; readout may show `—` then + recover; a subsequent hole still has held `E` if one had landed. +- [ ] Matched residual at 67%: \(P\) still from t3 `colorCopy`, not t4. Empty-model gate + unchanged. +- [ ] `UseProxy` on, publishing title: readout still gets an `E` (courier ran). +- [ ] Host fixture exit 0. + +--- + +## 13. Rebuild both blobs + +From `OptiScaler/shaders/dlssnr/precompile`. Do **not** run `build_precompiled_shader.bat`, +`build_precompiled_shader_fxc.bat`, or `build_precompiled_shader_vk.bat`. + +``` +..\..\shader_tools\fxc.exe -T cs_5_0 -E CSMain -O3 dlssnr.hlsl -Fo DlssNr_Shader.cso +python ..\..\shader_tools\create_header.py DlssNr_Shader.cso DlssNr_Shader.h DlssNr_cso + +..\..\shader_tools\dxc.exe -spirv -T cs_6_0 -E CSMain -O3 -Qstrip_debug -D VK_MODE -Cc -Vi dlssnr.hlsl -Fo DlssNr_Shader_Vk.spv +python ..\..\shader_tools\create_header.py DlssNr_Shader_Vk.spv DlssNr_Shader_Vk.h dlssnr_spv +``` + +Commit `dlssnr.hlsl` and both headers + `.cso` + `.spv` with the HLSL. Do not add a `_DX11` +header. + +--- + +## 14. Implementation order (plan input) + +1. **Host helper + fixture.** `GameWhite()` and `exposure_fixture.cpp`. No GPU. +2. **`NrExposure` + `EvaluateAfterUpscale` fill.** No bind yet. +3. **Usable check, Dx12 dummy, `InExposure` rename, `DispatchPass` 5th→dummy, latches, + hotfix span.** Four after-lines in §7.6. No throw on a bad pointer. +4. **Bridges (§8.6).** Peek / optional copy / `ExpCopy` when AE on. NR Set after upscaler + Evaluate. AE-on + missing must not flip backend. Block at NR is DX12 or null. +5. **HLSL `PaperWhite()`, t4 binding 8, sites in §7.2, Mode 3 `gExposure.Load`, both blobs + (§13).** Vulkan layout + pool; six-view `Dispatch`; native dummy t4. +6. **Delete `ResolveWhitePoint`.** Mode 3 after encode if usable (move the `target` UAV↔SRV + pair). Hole row uses `slider × GameWhite(heldE, thisP, thisS)`. +7. **Menu + atomics.** Colour block per §5. Delete `GameExposureStatus`. No `g_nrMutex` on + the overlay. +8. **T0, then the rest of §12.** Invert only the helper if needed. + +--- + +## 15. What a plan must not reopen + +- Three predicates plus `IsRunningVk()`. Box interactable iff `CanEnable`; drawn unchecked + via a `false` temporary. +- Slider format and help follow `Effective`. Range `0.25…240` log. INI keys unchanged. + Format `×` is Unicode. +- Picture samples this frame on D3D12. Readback never writes `WhitePoint` except the hole + formula `slider × GameWhite(heldE, thisP, thisS)`. +- `1.0` is identity. Toggle does not rewrite or rescale the float. +- Default preference `true` does not move a no-texture HDR title. +- Exposure is t4 / Vulkan binding 8. Resolve t3 stays `colorCopy` / `g_vk.proxy`. +- `DispatchPass` 5th null is the Dx12 dummy, never `InSource`. Rename `InPrevEdit` in place. +- Mode 3 after encode, before downsample / UseProxy, whenever **usable**, even if + `!Effective`. +- Six-view Vulkan `Dispatch`. Binding 8 = existing dummy. No game `ImageView`. No + `CopyTextureRegion` of the game resource. +- No `DLSSD.Exposure`. No `HdrLift`. No Multi-pass fill. No INI rename. +- No `build_precompiled_shader*.bat`. Both blobs, §13 commands. +- Debug views stay on `gDebugScale`. Hairline is `PaperWhite()` after `* normScale`. +- Encode 466 and resolve 526 as the exact replacements in §7.2. Passthrough ternary stays. +- Encode and resolve constants: `resolveParams = encodeParams`, then overwrite Mode / + strengths / compare / debug. Delete `ResolveWhitePoint`. +- Usable is non-MSAA non-array 2D only. +- NR Set is after the upscaler Evaluate. Upscaler AE behaviour is unchanged. +- No `0.01…4096` clamp. `max(W, 1e-4)` only. +- Delete `GameExposureStatus`. Reject today’s orange-but-safe-to-leave-on box. +- Do not change Mode 2, residual math, default `Transfer`, or Capture. +- This file supersedes the matched-residual Mode 3 t3 row only. diff --git a/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md b/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md new file mode 100644 index 000000000..65e7d7c02 --- /dev/null +++ b/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md @@ -0,0 +1,404 @@ +# Matched residual corrections: empty-model gate, P from colorCopy, strength-0 copy + +> **Rebase note (2026-09-03):** [2026-09-03-rebase-onto-dlss-neural-rendering.md](2026-09-03-rebase-onto-dlss-neural-rendering.md) +> wins where this file conflicts. Empty-model + t3 \(P\) still apply. The row that says +> “Vulkan has no working scale” is false on `dlss-neural-rendering`. + +**Status:** design for implementation. Reviewed and rewritten 2026-09-03; supersedes the earlier draft of this file. +**Branch:** `dlssnr-hhkbble`, tip `c453bbe6`. Every line number below is from that tip. +**Scope:** the resolve (Mode 1) of `precompile/dlssnr.hlsl`, both compiled blobs, the resolve bind on Dx12 and Vulkan, comments that describe the resolve, one menu string. +**Does not change:** encode, Mode 2 area kernel, Mode 3 meter, Classic compose, UpgradeToneMap, default `Transfer = 1`, WorkingScale, NGX evaluate, Config, cbuffer, descriptor layouts. + +This is a correction slice, not a second transfer. Area downsample and Matched residual stay the live path. Three things sit on top of that path and are wrong; this file locks what changes and, at least as carefully, what does not. + +The 2026-09-02 multipass brief (bilinear Classic, Classic default, rebuild \(P\) only if `colorCopy` is missing, its own compose) is a draft PR against an older state. It does not apply to this branch and is not a reference for this work. + +--- + +## 0. One-screen summary for the implementer + +| # | Defect on `c453bbe6` | Fix | +|---|---|---| +| 1 | Empty-model gate measures `luma(T)` after `model` has been replaced by the residual result (`dlssnr.hlsl:617`, `625–628`). When the model returns an empty frame under Matched at reduced scale, \(T\) is a high-pass of the frame, not empty, and the gate composes it. | Measure `luma(m)` **before** the residual block. Keep the existing `luma(model) <= 1e-5` test as well: line `648` divides by `modelLuma` and only that test keeps it safe. Gate = union. | +| 2 | Resolve rebuilds the full-res proxy as `saturate(SoftKnee(original))` (`611`) instead of reading the encode it already has. The rebuild rests on a false comment (`266–271`: the encode "only ever wrote a reduced one") and clips passthrough frames that the encode did not clip. | Bind `colorCopy` on t3 for the resolve; \(P\) = `Decode` of that texture. Remove SoftKnee from the resolve. Rebuild **both** shader blobs. | +| 3 | Detail-strength help says strength 0 "gives back exactly what the upscaler produced" (`DlssNr_Menu.cpp:221`); a Dx12 comment says the same (`DlssNr_Dx12.cpp:1628–1630`). Strength 0 returns the keep (`hdrCopy`), which is the upscaler frame with negatives clamped and one float round-trip. Capture "before" is the encode, not that frame, so the sentence sends testers to the wrong reference. | Reword both. No behaviour change. | + +Defect 1 is the only one with a visible failure mode. Defect 2 is a definitional and maintenance fix whose picture change is at quantisation level on the HDR path and real only on passthrough frames with values above 1. The test plan says so, so nobody hunts for a difference that is not there. + +--- + +## 1. The defects, from the code + +### 1.1 Gate + +`dlssnr.hlsl:595–618` replaces `proxy` and `model` when `gTransfer == 1 && modelRanSmall`. `625` then takes `modelLuma = dot(model, kLuma)` and `628` tests it. + +For an empty model (\(m = 0\)): `edit = -p` (`544`). Inside the block, `model = CubeScaleResidual(P, P - p)`. Where the frame is smooth, \(P \approx p\) and \(T \approx 0\): the gate fires, output is \(H\). Where the frame has texture, \(P \neq p\), \(T = P - \alpha p\) is a high-pass remnant with luma far above \(10^{-5}\): the gate does not fire and \(T\) is composed as if it were the model's picture. `proxyLuma` is `luma(P)`, at most `originalLuma`, so the headroom branch runs: where the knee fired, `ratio = (T_l + (H_l - P_l)) / T_l` is large and the pixel brightens toward the guard; where it did not, the result is \(T\) itself rescaled to the frame's luminance, bounded below by `1 / guard`. The output is a high-pass of the frame wearing the frame's brightness, wherever the frame has detail and the model returned nothing. Strength 0 hides this (`lerp(original, ..., 0)`); default strengths do not. + +Classic is unaffected: without the swap `model` is \(m\), and the test at `628` is already on \(m\). + +### 1.2 \(P\) + +The encode writes `colorCopy = LinearToSrgb(SoftKnee(frame / W))` at display size (`462–468`; `CreateScratch(..., width, height)` at `DlssNr_Dx12.cpp:1247`; encode dispatched with `Width = width` at `1492–1498`). Mode 2 writes the reduced copy to `colorSmall` (`1512–1523`). The comment on SoftKnee (`266–271`) says the encode "only ever wrote a reduced one" and that recomputing "costs less than the texture read it replaces". The first is false; the second is an opinion the code then depends on. + +`p` is `Decode(Sample(colorSmall))`: the stored encode, area-averaged, stored again, sampled. `P` should be the same stored encode at full resolution. Today it is a recomputation from `hdrCopy` that skips the encode's storage format and, in passthrough, applies a `saturate` the encode never applied (`274–275` return `display` unchanged; `611` saturates it). `Decode(colorCopy)` is the definition. It also means the resolve cannot drift from the encode if the curve ever changes. + +What this fix is **not**: the darker/redder 50 % picture described at `597–610` came from an unsaturated SoftKnee, and `611` already saturates. `colorCopy` is inside the unit cube for the same reason (`LinearToSrgb` saturates first, `240`). On the HDR path the two sources agree to storage precision. CubeScale still discards a residual that pushes a channel already at 1 further out; both sources share that wall. + +The resolve does not bind `colorCopy` today. t3 is `motionIn` (`1708`) and the shader reads t3 only in Mode 3 tile \((0,0)\) (`342–345`). `EditAt` (`251–263`) is dead code. + +### 1.3 Copy + +At strength 0: `upgraded = original` (`660` with `saturate(0)`, or `632`), `lumaRatio = 1` (`680`), `amplified = 1` (`693`), `boundedRatio = 1` (`714`), `result = original` (`721`), `result *= normScale` (`724`). `original` is `hdrCopy / normScale` (`527`), and `hdrCopy` is `max(source.rgb, 0)` (`441`, written at `444`). So strength 0 returns the keep: the upscaler frame with negative components clamped and one divide-multiply round trip in float. The help text's "exactly what the upscaler produced" is nearly true and points at the wrong thing: the only "before" a tester can obtain is Capture, and Capture records `colorCopy` (`1719`), the sRGB-encoded knee'd proxy. + +--- + +## 2. Facts that hold on this branch (verified; do not re-litigate) + +| Fact | Where | +|---|---| +| `colorCopy` is full resolution and in `NON_PIXEL_SHADER_RESOURCE` from the post-encode barrier until after the resolve | `DlssNr_Dx12.cpp:1247`, `1503–1504`, `1790–1791` | +| Mode 2 is always the area box; downsample constants are Mode / Width / Height only | `dlssnr.hlsl:378–435`, `DlssNr_Dx12.cpp:1514–1519` | +| t3 is read only in Mode 3 tile \((0,0)\); the meter passes the game's exposure texture there | `dlssnr.hlsl:342–345`, `DlssNr_Dx12.cpp:1471–1472` | +| `DispatchPass` substitutes `InSource` for a null 4th SRV | `DlssNr_Dx12.cpp:1051–1057` | +| `kSrvCount = 5`; the 5th (`InPrevEdit`) is vestigial and has no HLSL register | `DlssNr_Dx12.h:58–62`, `87–94` | +| Default `Transfer = 1`, default `WorkingScale = 1.0`, default `UseProxy = false` | `Config.h:286`, `333`, `355` | +| The Enlargement combo is disabled at Model resolution 100 % | `DlssNr_Menu.cpp:183–195` | +| `Transfer` is not a feature-rebuild input | `TuningMatchesFeature`, `DlssNr_Dx12.cpp:900–909` | +| `modelRanSmall` is `gSource.GetDimensions() != (gWidth, gHeight)`; guides are render-res, so `gGuideWidth` is not a substitute | `dlssnr.hlsl:591–593` | +| Non-passthrough requires a float format (`isHdrBuffer`); `_SRGB` scratch can only occur in passthrough, where `Decode` is the identity and all four SRVs share the format | `DlssNr_Dx12.cpp:829–843`, `1365` | +| Vulkan has no working scale: `proxy`, `keep`, `output` are all `width × height` FP16, evaluate runs at that size, `modelRanSmall` is false | `DlssNrFeature_Vk.cpp:555–559`, `658–663` | +| Vulkan binds a 1×1 never-cleared dummy for a `VK_NULL_HANDLE` read slot. It does **not** substitute t0 | `DlssNr_Vk.cpp:117–184`, `194–199` | +| Vulkan runs its own blob `dlssnr_spv` from `DlssNr_Shader_Vk.h`, built by dxc `-spirv -D VK_MODE`; Dx12 runs `DlssNr_cso` built by fxc `cs_5_0` | `DlssNr_Vk.cpp:5`, `89`; `DlssNr_Dx12.cpp:1025`; `shader_tools/build_precompiled_shader_vk.bat`; `dlssnr/README.md:60–70` | +| `fxc.exe`, `dxc.exe`, `create_header.py` are tracked in `OptiScaler/shaders/shader_tools/` | `git ls-files` | +| `.cso` and `.spv` are tracked alongside the headers | `git ls-files OptiScaler/shaders/dlssnr/precompile` | + +--- + +## 3. Non-goals + +- Do not change Mode 2. Area is the only shrink. Do not branch it on `gTransfer`. Do not bring back bilinear Classic. +- Do not change the default. `Transfer` stays `1`. +- Do not change UpgradeToneMap (two-sided guard, strength above 1 as `pow`, OkLab near-zero-chroma guard, `ClampAp1`). The 2026-09-02 §8.7 compose is older and worse. +- Do not touch the encode curve or `LinearToSrgb`. +- Do not add cbuffer fields, Config keys, debug views, a UAV, a sixth SRV, or a descriptor-layout entry. +- Do not use the vestigial 5th SRV slot (`InPrevEdit`) for `colorCopy`. t3 is the register. +- Do not rename `gMotion`. A rename touches HLSL, two C++ layout comments and the meter; it buys nothing functional. Fix its declaration comment instead. +- Do not add a `Decode` helper in this slice. Write \(P\)'s decode inline, exactly as `514–515` do. +- Do not add Vulkan working scale. Bind t3 on Vulkan so the shader is one program; the residual block stays dead there. +- Do not change Capture semantics (see §13). +- Do not gate on `luma(T)` **alone** or on `luma(m)` **alone** (see §4, Empty model). + +--- + +## 4. Contracts + +| Name | Rule | +|---|---| +| Area | Mode 2 is today's box: float edges, overlap weights, `acc / area`, clamp-to-edge, centre-texel alpha. | +| Default | Missing INI key: `Transfer = 1`. | +| Classic unchanged | With `gTransfer == 0`, the resolve's HLSL is unchanged from `c453bbe6`; nothing in this slice runs on that path. Identity is at the source level: the rebuilt blob may be scheduled differently by fxc and the driver, so a capture diff is a fence against visible change, not a zero-byte test. | +| Same-rate skip | `modelRanSmall == false` \(\Rightarrow\) the residual block does not run; `proxy, model` stay `p, m`. **This is what makes Classic and Matched identical at 100 %.** Without the skip, `P + (m - p)` is two float roundings away from \(m\) even when \(p = P\), and \(p\) is a filtered sample while \(P\) is a load. (CubeScale itself is the identity on a decoded \(m\), which `SrgbToLinear` keeps inside the cube; the roundings are the whole difference.) Keep the skip. | +| Strength 0 | `TransferStrength = 0`, Compare off or Wipe, Debug off: output is `hdrCopy` to storage precision (`(x / W) * W` in float). Not a claim about the upscaler UAV; not Capture "before". | +| Alpha | Unchanged. `originalSample.a`. | +| Empty model | Let `emptyModel = dot(m, kLuma) <= 1e-5`, measured on the decoded model sample **before** the residual block. Output is \(H\) when `emptyModel` **or** `dot(model, kLuma) <= 1e-5` after the block. The second clause guards the division at `648`; without it a residual that legitimately lands on black (\(P\) dark, `edit` negative, CubeScale clamps \(T\) to exactly 0 while \(m > 10^{-5}\)) divides by zero. Threshold unchanged. | +| \(P\) (Matched, reduced only) | `Decode` of `colorCopy` at this pixel: `SampleLevel(gLinear, cmpUv, 0)` when `gCompareMode == 1`, else `Load(int3(id.xy, 0))`, mirroring `originalSample` at `516–517`. `Decode(rgb) = gPassthrough != 0 ? rgb : SrgbToLinear(rgb)`. No extra `saturate`: `SrgbToLinear` already saturates, and passthrough must not clip. | +| `proxyLuma` | When \(P\) replaces `proxy`, `proxyLuma = dot(P, kLuma)`. The compose ratio at `638–648` reads it; leaving `luma(p)` there is the blur-as-headroom bug. | +| \(T\) | `CubeScaleResidual(P, P + edit)` with `edit = m - p` from the small textures, computed before the block (`544`). Unchanged helper. Passthrough returns \(T\) as computed. | +| Debug views | 1–3 stay where they are (`532–555`), on `p`, `m`, `edit`, before the block. They do not show \(P\) or \(T\). | +| t3 | One register, mode-dependent: meter = exposure texture; resolve = `colorCopy` (Dx12) / `g_vk.proxy` (Vulkan); encode / downsample = unread stand-in. | +| Blobs | `DlssNr_Shader.h` (fxc) and `DlssNr_Shader_Vk.h` (dxc SPIR-V) are rebuilt from the same `dlssnr.hlsl` in the same commit. | + +--- + +## 5. Resolve data flow (Mode 1) + +``` +encode (unchanged) colorCopy = LinearToSrgb(SoftKnee(frame / W)) or max(frame, 0) if passthrough + hdrCopy = max(frame, 0) +Mode 2 (unchanged) colorSmall = area(colorCopy) when work != colour +NGX (unchanged) output = model(colorSmall | colorCopy) + +resolve + p = Decode(gSource.Sample(cmpUv)) t0 = colorSmall | colorCopy + m = Decode(gModel.Sample(cmpUv)) t1 = output + H = original = hdrCopy / normScale t2 = hdrCopy (Sample if SBS, else Load) + proxyLuma = luma(p) + edit = m - p + debug views 1..3 (unchanged, before anything below) + + emptyModel = luma(m) <= 1e-5 BEFORE the block + modelRanSmall = dims(t0) != (gWidth, gHeight) + + if gTransfer == 1 && modelRanSmall + P = Decode(t3 at this pixel) t3 = colorCopy (Dx12) | g_vk.proxy (Vk) + proxy = P + proxyLuma = luma(P) + model = CubeScaleResidual(P, P + edit) + + modelLuma = luma(model) + if emptyModel || modelLuma <= 1e-5: upgraded = original + else: today's UpgradeToneMap(original, proxy, model) (unchanged from 634 on) + ... guard, colour blend, normScale, compare, write (unchanged) +``` + +--- + +## 6. Bindings + +### 6.1 t3 register + +| Dispatch | t3 resource | Shader use | +|---|---|---| +| Mode 3 meter | game exposure texture (`frame.ExposureTexture`) | `gMotion.Load(int3(0,0,0)).r`, unchanged | +| Mode 1 resolve | Dx12 `g_nr.colorCopy`; Vulkan `g_vk.proxy.view` | \(P\), Matched and reduced only | +| Mode 0 encode, Mode 2 downsample | stand-in (Dx12: `InSource`; Vulkan: dummy) | unread | + +HLSL identifier stays `gMotion`. Its declaration comment (`220`) must state both live uses and that nothing in the shader reads motion vectors. + +### 6.2 Dx12 call site + +`DlssNr_Dx12.cpp:1708–1709`, today: + +```cpp +DispatchPass(cmdList, resolveParams, modelInput, g_nr.output, g_nr.hdrCopy, motionIn, + nullptr, target, nullptr); +``` + +Required: + +```cpp +DispatchPass(cmdList, resolveParams, modelInput, g_nr.output, g_nr.hdrCopy, g_nr.colorCopy, + nullptr, target, nullptr); +``` + +`motionIn` is still consumed by `g_nr.evaluate` (`1571–1578`) and the proxy path; only the resolve stops receiving it. No new barrier: `colorCopy` is already `NON_PIXEL_SHADER_RESOURCE` here (§2). Nothing new about the view either: the downsample binds `colorCopy` as t0 through the same `DispatchPass`, and at 100 % the resolve already does (`modelInput` is `colorCopy` when not reduced, `1510`). + +Passing `nullptr` instead would silently bind `modelInput` (§2, null substitution). When reduced that is `colorSmall`, read with `Load(int3(id.xy, 0))` at full-resolution coordinates: the wrong texel inside the work-size region and zero (out of bounds) outside it; only the side-by-side path degrades to \(p\). A must-not-ship bind, not a fallback. + +### 6.3 Vulkan call site + +`DlssNrFeature_Vk.cpp:686–687`, today: + +```cpp +if (!g_vk.pass->Dispatch(cmdBuffer, resolve, width, height, g_vk.proxy.view, g_vk.output.view, g_vk.keep.view, + VK_NULL_HANDLE, colour->Resource.ImageViewInfo.ImageView, VK_NULL_HANDLE)) +``` + +Required: + +```cpp +if (!g_vk.pass->Dispatch(cmdBuffer, resolve, width, height, g_vk.proxy.view, g_vk.output.view, g_vk.keep.view, + g_vk.proxy.view, colour->Resource.ImageViewInfo.ImageView, VK_NULL_HANDLE)) +``` + +`g_vk.proxy` is already in `SHADER_READ_ONLY_OPTIMAL` for this dispatch (`682`); the same view in two combined-image-sampler slots with the same layout is legal. No new image, no layout change, no descriptor-layout change. + +Facts an implementer must not get backwards: a `VK_NULL_HANDLE` on Vulkan binds the 1×1 dummy, not t0; a missed bind after this slice would make \(P\) a `Load` outside a 1×1 image, not Classic's proxy. Today the residual block is dead on Vulkan (`modelRanSmall` false) so the bind changes nothing visible; it is required so the shader has one meaning for t3 on the resolve. + +--- + +## 7. Shader edits (Mode 1 only) + +All code above `544` (`edit`) and from `634` (`else` of the gate) on is unchanged; the only edits above `544` are the §8 comments. The changed region, written to compile (verified with both fxc `cs_5_0` and dxc `-spirv -D VK_MODE` against `c453bbe6`): + +```hlsl + float3 edit = model - proxy; // 544, unchanged + + // ... debug view 3, unchanged ... + + // Measured on the model's own answer, before the residual below may replace `model`. An empty + // frame from the model is "hand the frame back", whatever the residual would have made of it. + const bool emptyModel = dot(model, kLuma) <= 1e-5; + + uint proxyW, proxyH; + gSource.GetDimensions(proxyW, proxyH); + const bool modelRanSmall = proxyW != gWidth || proxyH != gHeight; + + if (gTransfer == 1 && modelRanSmall) + { + // The frame's own proxy at full resolution is the encode this pass already wrote; on the + // resolve t3 is that texture. Read the way `original` is read: sampled for side by side, + // loaded otherwise. Decoded like `proxy` and `model` above. Not saturated again: the encode + // went through LinearToSrgb, which saturates first, so this is already inside the unit + // cube, and a passthrough frame must come back exactly as it was stored. + const float4 encodeSample = gCompareMode == 1 ? gMotion.SampleLevel(gLinear, cmpUv, 0) + : gMotion.Load(int3(id.xy, 0)); + const float3 fullProxy = gPassthrough != 0 ? encodeSample.rgb : SrgbToLinear(encodeSample.rgb); + + proxy = fullProxy; + proxyLuma = dot(proxy, kLuma); + model = CubeScaleResidual(fullProxy, fullProxy + edit); + } + + float modelLuma = dot(model, kLuma); + float3 upgraded; + + // Two reasons to hand the frame back untouched. The model returned an empty frame for this + // pixel (emptyModel, measured before the residual). Or the composed model picture is black + // here, which the residual can legitimately produce on a dark pixel; the highlight branch below + // divides by modelLuma and needs it non-zero. + if (emptyModel || modelLuma <= 1e-5) + { + upgraded = original; + } + else + { + // ... 636–660 unchanged ... + } +``` + +`SoftKnee` is no longer called on the resolve. Keep the function; the encode calls it (`466`). + +--- + +## 8. Comments that must change in the same patch + +The code carries its reasoning in comments and a later reader plans on them (the resolve already did, from `266–271`). Leaving these would re-teach the defects. + +| File:lines | Today | Required | +|---|---|---| +| `dlssnr.hlsl:220` | "resolve, accumulating: the game's motion vectors." | t3 has two live uses: the meter's exposure texture (Mode 3, tile 0) and the resolve's full-resolution encode (`colorCopy` / `g_vk.proxy`). The name is the slot's history; nothing here reads motion vectors. | +| `dlssnr.hlsl:266–271` | "the resolve has to be able to reproduce it ... the encode only ever wrote a reduced one ... recomputing costs less than the texture read" | The knee is applied by the encode only. The resolve reads the encode's output back (t3) when it needs the frame's own proxy at full resolution; it does not recompute the curve. | +| `dlssnr.hlsl:341` | "The motion slot is free here: the meter has no use for motion vectors." | t3 is free here; the meter puts the game's exposure texture in it, the resolve the full-resolution encode. | +| `dlssnr.hlsl:465` | "The resolve reproduces this exactly, so the two agree on what the frame's own proxy is." | The resolve reads this texture back rather than recomputing it, so the two cannot disagree on what the frame's own proxy is. | +| `dlssnr.hlsl:569–590` | "the encode is a pure function, so SoftKnee reproduces it exactly" and the same-rate paragraph ("agree to within the proxy surface's precision") | Keep the blur-as-headroom rationale. Replace the recompute sentences with: the full-resolution proxy is the encode itself, read from t3. Same-rate paragraph: skipped because there is no residual to carry, and the skip is what keeps Classic and Matched bit-identical at 100 %. | +| `dlssnr.hlsl:597–610` | the saturate rationale | Deleted with the code it explains. The fact that survives (encode is inside the cube; CubeScale needs that; a channel at 1 still discards a residual pushing it out) goes into the short comment in §7. | +| `dlssnr.hlsl:630–631` | "The model can return an empty frame ..." | The two-reason comment in §7. | +| `DlssNr_Dx12.cpp:1628–1630` | "Resolve takes the difference ... adds that back to the frame. At strength zero the result is what the upscaler produced, exactly" | The resolve composes the model's answer against the keep (`hdrCopy`) as the shader describes; the additive description is from an older composition. At strength zero the keep comes back as stored. | + +`DlssNr_Common.h:134–144` (Transfer) is accurate and stays. The Enlargement help (`DlssNr_Menu.cpp:196–207`) is accurate and stays, attribution included. + +--- + +## 9. Menu copy + +`DlssNr_Menu.cpp:221`, today: + +> 0 gives back exactly what the upscaler produced. 1 is the model's picture. + +Replace with: + +> 0 leaves the frame as it arrived, with none of the model's picture in it. 1 is the model's picture. + +No internal names in the widget. The rest of that help block stays. + +--- + +## 10. Build: two blobs, one source + +Both from `OptiScaler/shaders/dlssnr/precompile`. Tools are tracked in `../../shader_tools/`. + +Dx12 (the README command; **not** `build_precompiled_shader_fxc.bat`, which would name the array `dlssnr_cso` and break `DlssNr_Dx12.cpp:1025`; **not** `build_precompiled_shader.bat`, which emits DXIL): + +``` +..\..\shader_tools\fxc.exe -T cs_5_0 -E CSMain -O3 dlssnr.hlsl -Fo DlssNr_Shader.cso +python ..\..\shader_tools\create_header.py DlssNr_Shader.cso DlssNr_Shader.h DlssNr_cso +``` + +Vulkan (what `build_precompiled_shader_vk.bat dlssnr` runs, spelled out so the output file names match the tracked ones): + +``` +..\..\shader_tools\dxc.exe -spirv -T cs_6_0 -E CSMain -O3 -Qstrip_debug -D VK_MODE -Cc -Vi dlssnr.hlsl -Fo DlssNr_Shader_Vk.spv +python ..\..\shader_tools\create_header.py DlssNr_Shader_Vk.spv DlssNr_Shader_Vk.h dlssnr_spv +``` + +Commit `dlssnr.hlsl`, `DlssNr_Shader.h`, `DlssNr_Shader.cso`, `DlssNr_Shader_Vk.h`, `DlssNr_Shader_Vk.spv`. `git status --short OptiScaler/shaders/dlssnr/precompile` must show exactly five ` M` lines and no `??` (the tree otherwise carries untracked build output; a case-different or `_DX11` name in that directory means the wrong command ran). Nothing includes a `_DX11` header; do not add one. + +Sanity anchor: on the unmodified `c453bbe6` source, these exact commands reproduce the tracked `.cso` and `.spv` byte for byte. If they do not on the implementer's machine before any edit, stop and find out why before trusting the rebuilt headers. + +A stale header is a silent old shader: the constructor passes `source = nullptr` (`DlssNr_Dx12.cpp:1022–1025`). + +--- + +## 11. File-level work and suggested order + +| Step | File | Change | +|---|---|---| +| 1 | `shaders/dlssnr/precompile/dlssnr.hlsl` | §7 code; §8 comments | +| 2 | `precompile/DlssNr_Shader.h`, `.cso`, `DlssNr_Shader_Vk.h`, `.spv` | §10 rebuild | +| 3 | `shaders/dlssnr/DlssNr_Dx12.cpp` | §6.2 bind; §8 comment at 1628 | +| 4 | `dlssnr/DlssNrFeature_Vk.cpp` | §6.3 bind | +| 5 | `dlssnr/DlssNr_Menu.cpp` | §9 string | +| 6 | Tests §12 | C4 and V1 first (nothing should move), then C7, then the rest | + +Steps 1–4 land in one commit. If they must be split, the binds (3, 4) go **first**: the old shader does not read t3 on the resolve, so an early bind is inert. The reverse order is not safe: the new shader with the old Dx12 bind reads \(P\) from the motion-vector texture under Matched at reduced scale and the picture is garbage until the bind lands. No Config, no cbuffer, no `DlssNr_Modes.h`, no descriptor layouts. + +--- + +## 12. Test plan + +Controls, by their live names: **Model resolution** (`DlssNrWorkingScale`, slider under "Cost"), **Enlargement** (`DlssNrTransfer`, Classic / Matched residual; disabled at 100 %), **Detail strength**, **Compare**, **Debug view**, `UseProxy` (INI only, default off). Default matrix unless a row says otherwise: NR on, `UseProxy` off, Output Scaling off, Compare off, Debug view off, Detail and Colour strength at 1, one frozen scene, one model version. "Today" means a `c453bbe6` build. + +| ID | Setup | Pass if | +|---|---|---| +| C0 | Delete `[DlssNr] Transfer` and `WorkingScale` from the INI, start | Enlargement shows Matched residual and is greyed (100 %). Picture equals today. | +| C1 | Detail strength 0, Model resolution 67 %, either Enlargement | Toggling NR on/off shows no difference (the keep is the upscaler frame with negatives clamped). Independent of \(P\) and the gate by construction; this is the identity contract, not an algorithm test. | +| C2 | Model resolution 67 %, toggle Enlargement Classic ↔ Matched | Picture changes. Log shows a new "DLSS-NR composition: ... transfer ..." line and **no** new "DLSS-NR running at" line (no feature rebuild, `1340`). No hitch. | +| C3 | Set Matched at 67 %, then Model resolution 100 % | Combo greys out; INI still says `Transfer=1`; picture equals Classic at 100 % (residual block skipped). | +| C4 | Classic at 67 % | **No visible change against today.** Nothing in this slice runs on Classic. Capture 8 frames on a paused scene with both builds if a numeric check is wanted; tolerate last-bit noise from the rebuilt blob, flag anything larger. | +| C5 | Matched at 67 %, normal scene and a saturated-channel scene (low paper white, strongly coloured light) | No visible change against today. Differences are at storage precision on the HDR path. Not darker, not redder. Halo against Classic still smaller. If C5 shows a visible change on a non-passthrough title, something other than §7 was changed. | +| C6 | Passthrough title whose buffer is FP16 with the HDR flag clear and values above 1 | Only case where \(P\) moves visibly: highlights above 1 no longer clip under Matched at 67 %. Implementer-only; not required for acceptance if no such title is at hand. 8-bit titles cannot distinguish (`saturate(hdrCopy) == colorCopy` there). | +| C7 | **Gate.** Temporary one-line shader edit: after `float3 model = ...` (`515`) insert `model = float3(0.0, 0.0, 0.0);`, rebuild the fxc header only, run Matched at 67 % | Output is the frame to storage precision, as C1 (NR looks off; no texture artefacts). fxc folds `emptyModel` to true with that line and removes the compose; expected. With today's shader plus the same temporary line, the picture degrades to a high-pass of the frame wherever it has detail (§1.1). Classic at 67 % is the frame in both. Revert the line, rebuild, confirm C4 again. Do not commit the line or ship a control for it. | +| V1 | Vulkan title, NR on, validation layers on | Pass creates, dispatches, no descriptor/layout validation errors, picture equals today (residual block is dead on Vulkan). Confirms the SPIR-V rebuild and the t3 bind. | +| G | Pass GPU time in the overlay, Matched at 67 % | Within noise of today: one full-res Load replaces a handful of ALU. | + +C7 is the acceptance test for defect 1. C4 and V1 are the regression fences. C5 is a fence, not a proof of \(P\). + +--- + +## 13. Known and parked (not this slice) + +- **Capture "before" is the encode, labelled as the upscaler frame.** `DlssNr_Dx12.cpp:1719` records `colorCopy`; `DlssNr_Capture.h:329` calls it "the frame as the upscaler produced it" and the menu help at `DlssNr_Menu.cpp:435–436` "as the upscaler produced them". True in passthrough only. Either record `g_nr.hdrCopy` (in `NON_PIXEL_SHADER_RESOURCE` at that point, `1505–1506` to `1735`) or relabel. A capture-semantics decision, one line either way; decide it separately. +- **`_SRGB` scratch formats.** `TranslateTypelessFormats` does not remap `*_UNORM_SRGB` (`Shader_Dx12.cpp:22–69`), so a passthrough game with an `_SRGB` buffer would get hardware-linearised SRVs. Pre-existing, uniform across t0–t3 (all `desc.Format`), `Decode` is the identity there, and `CreateScratch` asks for `ALLOW_UNORDERED_ACCESS`, which `_SRGB` formats do not support, so on such a buffer the scratch is never created and the pass never runs. Not introduced or worsened by this slice. +- **`EditAt`** (`dlssnr.hlsl:251–263`) is dead code. Leave it. +- **`InPrevEdit` / `kSrvCount = 5`**: vestigial. Leave it. +- **Vulkan working scale, H1 / `gHdrLift`, debug views 4–5, a `Decode` helper, renaming `gMotion`**: out of scope by decision, not by oversight. + +--- + +## 14. Decisions locked + +| Topic | Choice | Rejected, and why | +|---|---|---| +| Gate | `emptyModel (luma(m) before block) || luma(model) <= 1e-5 after block` | `luma(T)` alone: composes a high-pass when \(m\) is empty. `luma(m)` alone: divides by zero at `648` when \(T\) lands on exactly black. | +| \(P\) | `Decode(colorCopy)` from t3, no extra saturate | `saturate(SoftKnee(H))`: duplicate of the encode with a false premise, clips passthrough. A second encode UAV: nothing to gain. | +| `proxyLuma` | `luma(P)` when \(P\) replaces `proxy` | Leaving `luma(p)`: the blur-as-headroom bug returns. | +| Same-rate | Keep the skip | Forcing the residual path: not bit-identical to Classic, nothing to carry. | +| t3 | `colorCopy` / `g_vk.proxy` on resolve; exposure on meter; identifier `gMotion` kept, comment fixed | 6th SRV, 5th vestigial slot, rename: cost without function. `nullptr` on Dx12: silently `colorSmall` loaded at full-resolution coordinates (§6.2). `VK_NULL_HANDLE` on Vulkan: the 1×1 dummy. | +| Blobs | fxc `DlssNr_cso` and dxc `dlssnr_spv` rebuilt together | fxc only: Vulkan runs an older program than the source it is documented to share. | +| Shrink | Area, both Transfer values | Bilinear Classic (2026-09-02). | +| Default | Matched (`1`) | Classic default (2026-09-02). | +| Compose | This branch's UpgradeToneMap | 2026-09-02 §8.7. | +| Strength-0 copy | "leaves the frame as it arrived" | "exactly what the upscaler produced": overstates, and points at a Capture that records the encode. | +| Capture semantics | Parked, §13 | Fixing it here: a separate decision. | + +--- + +## 15. Acceptance + +Ship when all of: + +1. C4 and V1: nothing moved where nothing should. +2. C7: an empty model under Matched at reduced scale returns the frame. +3. C1 and C3: identity contracts hold. +4. C5: no visible regression on the HDR path. +5. Both headers rebuilt from the committed `dlssnr.hlsl`; `git status --short OptiScaler/shaders/dlssnr/precompile` shows the five tracked files modified and nothing untracked. +6. §8 comments and §9 string landed; no comment left that says the resolve recomputes the encode or that t3 carries motion vectors. +7. Classic path, Mode 2, default Transfer, Config, cbuffer: untouched (diff review). + +--- + +## 16. What this revision corrected in the previous draft + +For readers who saw the earlier version of this file. + +- The gate is a union, not "`luma(m)` instead of `luma(T)`". The earlier draft (and the review that followed it) missed the unguarded division at `648`. +- `saturate(SoftKnee(H))` and `Decode(colorCopy)` are the same function in exact arithmetic but not the same bits on the GPU; the "0–1e-17" figure was a float64 check of the pure functions, not of stored textures. The \(P\) change is a definitional and passthrough fix, not the 50 % colour-shift fix, which `611` already contains. +- Vulkan's null-slot stand-in is a 1×1 dummy, not the proxy and not t0. The SPIR-V blob is a second build output of the same source and must be rebuilt; "do not commit dxc outputs" referred to DXIL and was misleading. +- The same-rate skip is required for bit-identity; the earlier "no longer required" reasoning was wrong. +- The test matrix named controls that do not exist (`WorkAtNative`, "Post-process", "Multi-pass"); C0/C1/C6 were presented as algorithm tests but cannot exercise the change; C7 lacked a concrete procedure. +- `proxyLuma` was assigned in §7 but absent from §5; it is a contract now. +- `gMotion` stays; the earlier draft allowed a rename, which only adds surface. +- Comments at `DlssNr_Dx12.cpp:1628–1630` and `dlssnr.hlsl:341`, `465`, `569–590` were missing from the file list. +- Landing order was stated as free; the shader must not land before the Dx12 bind (§11). diff --git a/OptiScaler/dlssnr/tests/exposure_fixture.cpp b/OptiScaler/dlssnr/tests/exposure_fixture.cpp new file mode 100644 index 000000000..b7cea5a53 --- /dev/null +++ b/OptiScaler/dlssnr/tests/exposure_fixture.cpp @@ -0,0 +1,47 @@ +#include "dlssnr/DlssNr_Exposure.h" + +#include +#include +#include +#include +#include +#include + +int main() +{ + const float nanE = std::numeric_limits::quiet_NaN(); + const float infE = std::numeric_limits::infinity(); + + assert(SanitizeExposure(nanE) == 1.0f); + assert(SanitizeExposure(infE) == 1.0f); + assert(SanitizeExposure(0.0f) == 1.0f); + assert(SanitizeExposure(1e7f) == 1.0f); + + assert(FoldZeroToOne(0.0f) == 1.0f); + const float gwNominal = GameWhite(0.012f, 1.0f, 1.0f); + assert(std::fabs(GameWhite(0.012f, 0.0f, 1.0f) - gwNominal) <= 1e-4f); + assert(std::fabs(GameWhite(0.012f, 1.0f, 0.0f) - gwNominal) <= 1e-4f); + + assert(std::fabs(GameWhite(0.012f, 1.0f, 1.0f) - (1.0f / 0.012f)) <= 1e-4f); + + const WhitePointDecision sdr = DecideWhitePoint(0, false, true, true, 8.0f, 1.25f, 0.012f, 1.0f, 1.0f, 12.0f); + assert(sdr.useGameExposure == 0); + assert(std::fabs(sdr.whitePoint - 8.0f) <= 1e-4f); + const WhitePointDecision usable = DecideWhitePoint(1, true, true, false, 8.0f, 1.25f, 0.012f, 1.0f, 1.0f, 0.0f); + assert(usable.useGameExposure == 1); + assert(std::fabs(usable.whitePoint - 1.25f) <= 1e-4f); + + std::string headerPath(__FILE__); + const auto slash = headerPath.find_last_of("/\\"); + if (slash != std::string::npos) + headerPath = headerPath.substr(0, slash) + "/../DlssNr_Exposure.h"; + else + headerPath = "OptiScaler/dlssnr/DlssNr_Exposure.h"; + + std::ifstream in(headerPath); + assert(in && "DlssNr_Exposure.h must be readable for the invert-line check"); + const std::string text((std::istreambuf_iterator(in)), std::istreambuf_iterator()); + assert(text.find("// T0 invert: return e * s / p;") != std::string::npos); + + return 0; +} diff --git a/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp b/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp new file mode 100644 index 000000000..678f217f7 --- /dev/null +++ b/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp @@ -0,0 +1,32 @@ +#include "dlssnr/DlssNr_Exposure.h" + +#include +#include + +static void expect(const WhitePointDecision& d, float wp, uint32_t flag) +{ + assert(d.useGameExposure == flag); + assert(std::fabs(d.whitePoint - wp) <= 1e-4f); +} + +int main() +{ + const float scale = 8.0f; + const float trim = 1.25f; + const float held = 0.012f; + const float pre = 1.0f; + const float es = 1.0f; + const float anchored = 12.0f; + + expect(DecideWhitePoint(0, false, true, true, scale, trim, held, pre, es, anchored), scale, 0); + expect(DecideWhitePoint(1, false, true, true, scale, trim, held, pre, es, anchored), scale, 0); + expect(DecideWhitePoint(2, false, true, true, scale, trim, held, pre, es, 0.0f), scale, 0); + expect(DecideWhitePoint(0, true, true, true, scale, trim, held, pre, es, anchored), scale, 0); + expect(DecideWhitePoint(1, true, true, false, scale, trim, held, pre, es, 0.0f), trim, 1); + expect(DecideWhitePoint(1, true, false, true, scale, trim, held, pre, es, 0.0f), + trim * GameWhite(held, pre, es), 0); + expect(DecideWhitePoint(1, true, false, false, scale, trim, 0.012f, pre, es, 0.0f), scale, 0); + expect(DecideWhitePoint(2, true, true, true, scale, trim, held, pre, es, anchored), anchored, 0); + expect(DecideWhitePoint(2, true, true, true, scale, trim, held, pre, es, 0.0f), scale, 0); + return 0; +} diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Common.h b/OptiScaler/shaders/dlssnr/DlssNr_Common.h index 540c6fd8d..43801e179 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Common.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Common.h @@ -10,6 +10,7 @@ // do. The model itself is separate again: creating and evaluating an NGX feature is not a dispatch, // so it does not belong in a shader class. +#include #include // Which of the passes a dispatch is. One shader, because they read and write the same set of @@ -19,8 +20,7 @@ enum DlssNrMode : uint32_t DlssNrMode_Encode = 0, // the frame -> a tone-mapped proxy, plus an untouched copy DlssNrMode_Resolve = 1, // proxy + the model's answer + the untouched copy -> the edited frame DlssNrMode_Downsample = 2, // the proxy -> a smaller proxy, when the model works below full size - DlssNrMode_Meter = 3, // the exposure texture -> tile (0,0), for the white point - DlssNrMode_Calibrate = 4 // the untouched frame -> a grid of tile peak luminances + DlssNrMode_Meter = 3 // the exposure texture -> tile (0,0), for the white point }; // The meter's grid. 64 x 64 tiles over the whole frame, whatever its size. @@ -84,6 +84,10 @@ struct DlssNrFrameInfo // undo it. Usually 1. Divided out before the exposure is applied, exactly as FSR's PrepareRgb does. float PreExposure = 1.0f; + // NGX DLSS.Exposure.Scale. Missing or 0 is already 1 at the reader. The paper-white slider + // lives in Config, not on this struct. + float ExposureScale = 1.0f; + // How much of the depth and motion vector textures the game actually rendered into. // // Not the same thing as how big those textures are, and the difference is the whole point. A game @@ -164,8 +168,21 @@ struct alignas(256) DlssNrConstants // two captures at different exposures then differ by the exposure, whatever the edit did. This // is the user's own multiplier, which holds still while the meter works. float DebugScale; + + // 1 only when Effective and this frame's exposure resource is usable. The shader's PaperWhite + // then Loads t4; otherwise gWhitePoint is already the absolute W (slider, or the hole product). + uint32_t UseGameExposure; + float PreExposure; + float ExposureScale; }; +static_assert(offsetof(DlssNrConstants, Transfer) == 68); +static_assert(offsetof(DlssNrConstants, DebugScale) == 72); +static_assert(offsetof(DlssNrConstants, UseGameExposure) == 76); +static_assert(offsetof(DlssNrConstants, PreExposure) == 80); +static_assert(offsetof(DlssNrConstants, ExposureScale) == 84); +static_assert(sizeof(DlssNrConstants) == 256); + class DlssNr_Common { protected: diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp index f21fd42f6..0da9a9caa 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp +++ b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp @@ -6,8 +6,10 @@ #include +#include #include #include +#include #include "DlssNr_Dx12.h" @@ -21,6 +23,7 @@ #include #include +#include #include #include "precompile/DlssNr_Shader.h" @@ -213,6 +216,10 @@ struct NrState unsigned int workWidth = 0; unsigned int workHeight = 0; + // 1x1 R32_FLOAT = 1.0, bound on t4 when the game has no usable exposure this frame. + // Not CreateScratch: no UAV. Survives park; released only in Shutdown. + ID3D12Resource* exposureDummy = nullptr; + // The white point meter. // // A 64x64 grid of tile luminances, copied to a readback buffer and looked at a few frames later. @@ -247,11 +254,9 @@ struct NrState // Whether the frame that filled each readback slot actually had an exposure texture bound. // - // The meter writes tile 0 from whatever sits in the exposure slot, and DispatchPass substitutes - // the source picture when nothing is bound -- so without this the "exposure" read back is the red - // channel of the frame's top-left pixel. In Cyberpunk, which supplies no exposure texture, that - // pixel is scene content: it moved by up to 272x between consecutive frames and drove the white - // point from 0.18 to 74. That is the whole frame flashing in luminance. + // The meter writes tile 0 from t4. Mode 3 runs only when this frame's pointer is usable, so a + // missing texture no longer binds the source picture as a stand-in -- that is what made + // Cyberpunk's top-left pixel drive the white point from 0.18 to 74. // // The grid is read three frames after it is written, so the flag has to travel with the slot // rather than being asked of the current frame. @@ -272,16 +277,6 @@ struct NrState float gameExposure = 0.0f; float gamePreExposure = 1.0f; - // What the game OFFERS, as opposed to what has been read. Recorded from the parameter block every - // frame whether or not the setting is on, and deliberately so: the menu has to be able to answer - // "would this do anything here?" before the user turns it on, and reading a pointer for null costs - // nothing. Whether it was ever offered is kept separately from whether it was offered this frame, - // because games drop it on transitions -- GTA V dropped it three times in one session -- and one - // absent frame is not the same answer as never. - bool exposureOfferedNow = false; - bool exposureEverOffered = false; - unsigned long long exposureFrames = 0; - // Cloned unconditionally when running at present, and only for typeless formats otherwise. ID3D12Resource* depthClone = nullptr; ID3D12Resource* motionClone = nullptr; @@ -322,6 +317,15 @@ struct NrState }; NrState g_nr; +std::atomic haveEvaluated { false }; +std::atomic sessionHasTexture { false }; +std::atomic sessionPassthrough { false }; +// Menu readout. Dispatch stores P/S; ConsumeMeterReadback stores a finite E. +// Queries load these only; they never take g_nrMutex. +std::atomic haveFiniteE { false }; +std::atomic readoutE { 0.0f }; +std::atomic readoutP { 1.0f }; +std::atomic readoutS { 1.0f }; std::unique_ptr g_compose; // What the pass costs on the GPU, for the breakdown in the overlay. @@ -397,25 +401,6 @@ void CheckCaptureTrigger() } } -// The encoded mean is aimed here. Mid-grey rather than anything brighter: the model has to see both the -// shadow detail it might lift and the highlights it must not blow out. -constexpr float kTargetEncodedMean = 0.45f; - -// How fast the derived value follows the scene. Readings arrive a few times a second, and an exposure -// that lunges at every cut is worse than one that arrives a moment late. -constexpr float kWhitePointBlend = 0.25f; - -// Recomputes the white point from a measured mean. Inverting the encode for the white point that puts -// that mean at the target gives wp = mean * (1 - t^g) / t^g. -float WhitePointForMean(float meanLuma) -{ - const float encoded = powf(kTargetEncodedMean, 2.2f); - const float ratio = encoded / (1.0f - encoded); - const float wp = meanLuma / ratio; - // A black frame between scenes would otherwise drive this to zero and divide the next frame by it. - return wp < 0.01f ? 0.01f : (wp > 10000.0f ? 10000.0f : wp); -} - std::filesystem::path g_dllDir; // Loads the forwarder that owns the calls into the snippet. @@ -652,6 +637,12 @@ void ParkNrResource(ID3D12Resource*& res) g_nrRetired.push_back(r); } +void InvalidateMeterReadback() +{ + for (auto& v : g_nr.meterExposureValid) + v = false; +} + void TickNrRetired() { for (size_t i = 0; i < g_nrRetired.size();) @@ -672,18 +663,6 @@ void TickNrRetired() } } -// The inject point decides which buffer is being measured -- the upscaler's linear output or the -// finished frame in swapchain format -- so a reading taken before a change describes a different -// picture to one taken after. Everything else that depends on the format is invalidated here. -void ForgetCalibration() -{ - g_nr.calibCount = 0; - g_nr.calibSuggestion = 0.0f; - g_nr.calibSteadiness = 0.0f; - g_nr.calibUsable = false; - g_nr.calibWhy = "measuring..."; -} - void ReleaseSurfacesIfFormatChanged(DXGI_FORMAT needed) { if (g_nr.output == nullptr || g_nr.output->GetDesc().Format == needed) @@ -692,8 +671,6 @@ void ReleaseSurfacesIfFormatChanged(DXGI_FORMAT needed) LOG_INFO("DLSS-NR rebuilding surfaces: format {} -> {} (inject point changed)", (int) g_nr.output->GetDesc().Format, (int) needed); - ForgetCalibration(); - ParkNrFeature(g_nr.feature); // The extras go with it: they were built for this raster and this tuning too. @@ -704,6 +681,7 @@ void ReleaseSurfacesIfFormatChanged(DXGI_FORMAT needed) { &g_nr.output, &g_nr.colorCopy, &g_nr.hdrCopy, &g_nr.colorSmall }) ParkNrResource(*r); + InvalidateMeterReadback(); g_nr.reset = true; } @@ -911,10 +889,14 @@ void ConsumeMeterReadback() // rather than an exposure -- believing it made the white point follow the top-left corner of the // screen, which in Cyberpunk moved by up to 272x between frames and flashed the whole picture. // - // When it is not believed gameExposure keeps its last good value, or stays 0 and lets - // ResolveWhitePoint fall back to the slider, which is what a game supplying none should get. + // When it is not believed gameExposure keeps its last good value, or stays 0. Held E is + // the hole's clock only; a game that never supplied a usable exposure stays on the slider. if (g_nr.meterExposureValid[slot] && std::isfinite(src[0]) && src[0] > 0.0f) + { g_nr.gameExposure = src[0]; + readoutE.store(src[0]); + haveFiniteE.store(true); + } D3D12_RANGE nothingWritten { 0, 0 }; buffer->Unmap(0, ¬hingWritten); @@ -1005,25 +987,7 @@ float ResolveWhitePoint(const Config& cfg, bool isHdrBuffer) return w; } - if (cfg.DlssNrWhitePointSource.value_or_default() == 1 && g_nr.gameExposure > 1e-6f) - { - // Its own setting, not the manual divisor. See Config: they are different quantities with - // different units and different sensible ranges, and sharing one value meant adjusting the - // trim destroyed the divisor somebody had found by hand. - // - // Still bounded at the point of use rather than only in the menu that draws it. - // - // Bounding it at the slider would have been cosmetic: someone who found 64 by hand on the - // manual path and then switched the exposure source on keeps that 64 in their ini, and the - // composition would go on reading it until they happened to touch the control. The picture - // would be wrong for a reason the menu was no longer showing. - // - // Their value is left in the config untouched, so switching back to manual restores the - // number they arrived at. It is only what this path consumes that is limited. - const float trim = std::clamp(cfg.DlssNrWhitePointTrim.value_or_default(), 0.25f, 4.0f); - - return std::clamp(g_nr.gamePreExposure / g_nr.gameExposure * trim, 0.01f, 4096.0f); - } + // Source 1 picture and hole use DecideWhitePoint only. Do not compute P/E*trim here. // Otherwise the slider, and only the slider. // @@ -1075,6 +1039,159 @@ void Barrier(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* res, D3D12_RESO cmdList->ResourceBarrier(1, &b); } +bool IsTypelessResourceFormat(DXGI_FORMAT f) +{ + switch (f) + { + case DXGI_FORMAT_R32G32B32A32_TYPELESS: + case DXGI_FORMAT_R32G32B32_TYPELESS: + case DXGI_FORMAT_R16G16B16A16_TYPELESS: + case DXGI_FORMAT_R32G32_TYPELESS: + case DXGI_FORMAT_R32G8X24_TYPELESS: + case DXGI_FORMAT_R10G10B10A2_TYPELESS: + case DXGI_FORMAT_R8G8B8A8_TYPELESS: + case DXGI_FORMAT_R16G16_TYPELESS: + case DXGI_FORMAT_R32_TYPELESS: + case DXGI_FORMAT_R24G8_TYPELESS: + case DXGI_FORMAT_R8G8_TYPELESS: + case DXGI_FORMAT_R16_TYPELESS: + case DXGI_FORMAT_R8_TYPELESS: + case DXGI_FORMAT_BC1_TYPELESS: + case DXGI_FORMAT_BC2_TYPELESS: + case DXGI_FORMAT_BC3_TYPELESS: + case DXGI_FORMAT_BC4_TYPELESS: + case DXGI_FORMAT_BC5_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_BC6H_TYPELESS: + case DXGI_FORMAT_BC7_TYPELESS: + return true; + default: + return false; + } +} + +// 1x1 R32_FLOAT = 1.0. Not CreateScratch (no UAV). Survives park. +void EnsureExposureDummy(ID3D12Device* device, ID3D12GraphicsCommandList* cmdList) +{ + if (g_nr.exposureDummy != nullptr || device == nullptr || cmdList == nullptr) + return; + + D3D12_HEAP_PROPERTIES heap {}; + heap.Type = D3D12_HEAP_TYPE_DEFAULT; + + D3D12_RESOURCE_DESC desc {}; + desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + desc.Width = 1; + desc.Height = 1; + desc.DepthOrArraySize = 1; + desc.MipLevels = 1; + desc.Format = DXGI_FORMAT_R32_FLOAT; + desc.SampleDesc.Count = 1; + desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + desc.Flags = D3D12_RESOURCE_FLAG_NONE; + + if (FAILED(device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, + D3D12_RESOURCE_STATE_COPY_DEST, nullptr, + IID_PPV_ARGS(&g_nr.exposureDummy))) || + g_nr.exposureDummy == nullptr) + { + g_nr.exposureDummy = nullptr; + static bool logged = false; + if (!logged) + { + logged = true; + LOG_WARN("DLSS-NR: the exposure dummy could not be created; t4 dispatches that need it " + "will be skipped"); + } + return; + } + + D3D12_HEAP_PROPERTIES uploadHeap {}; + uploadHeap.Type = D3D12_HEAP_TYPE_UPLOAD; + + D3D12_RESOURCE_DESC buf {}; + buf.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + buf.Width = D3D12_TEXTURE_DATA_PITCH_ALIGNMENT; + buf.Height = 1; + buf.DepthOrArraySize = 1; + buf.MipLevels = 1; + buf.Format = DXGI_FORMAT_UNKNOWN; + buf.SampleDesc.Count = 1; + buf.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; + + ID3D12Resource* upload = nullptr; + + if (FAILED(device->CreateCommittedResource(&uploadHeap, D3D12_HEAP_FLAG_NONE, &buf, + D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, + IID_PPV_ARGS(&upload))) || + upload == nullptr) + { + g_nr.exposureDummy->Release(); + g_nr.exposureDummy = nullptr; + return; + } + + float* mapped = nullptr; + + if (SUCCEEDED(upload->Map(0, nullptr, reinterpret_cast(&mapped))) && mapped != nullptr) + { + *mapped = 1.0f; + upload->Unmap(0, nullptr); + } + + D3D12_TEXTURE_COPY_LOCATION src {}; + src.pResource = upload; + src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; + src.PlacedFootprint.Offset = 0; + src.PlacedFootprint.Footprint.Format = DXGI_FORMAT_R32_FLOAT; + src.PlacedFootprint.Footprint.Width = 1; + src.PlacedFootprint.Footprint.Height = 1; + src.PlacedFootprint.Footprint.Depth = 1; + src.PlacedFootprint.Footprint.RowPitch = D3D12_TEXTURE_DATA_PITCH_ALIGNMENT; + + D3D12_TEXTURE_COPY_LOCATION dst {}; + dst.pResource = g_nr.exposureDummy; + dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; + dst.SubresourceIndex = 0; + + cmdList->CopyTextureRegion(&dst, 0, 0, 0, &src, nullptr); + Barrier(cmdList, g_nr.exposureDummy, D3D12_RESOURCE_STATE_COPY_DEST, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + ParkNrResource(upload); +} + +struct ExposureHotfixSpan +{ + ID3D12GraphicsCommandList* cmd = nullptr; + ID3D12Resource* res = nullptr; + D3D12_RESOURCE_STATES from {}; + bool open = false; + + void Open(ID3D12GraphicsCommandList* c, ID3D12Resource* r) + { + if (open || r == nullptr || !Config::Instance()->ExposureResourceBarrier.has_value()) + return; + + cmd = c; + res = r; + from = (D3D12_RESOURCE_STATES) Config::Instance()->ExposureResourceBarrier.value(); + Barrier(cmd, res, from, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + open = true; + } + + void Close() + { + if (!open) + return; + + Barrier(cmd, res, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, from); + open = false; + } + + ~ExposureHotfixSpan() { Close(); } +}; + // A typeless resource cannot be viewed, and NGX builds its own views with nothing to tell it which // format to use. Depth is very often declared typeless, so the typed member of the same family is // substituted; CopyResource accepts that as a destination for the typeless original. @@ -1243,6 +1360,46 @@ ID3D12Resource* GetResource(NVSDK_NGX_Parameter* params, const char* a, const ch return nullptr; } +// One name, typed then untyped. Bridges Set(void*), so a typed-only Get misses them. +// Missing or 0 for the two floats becomes 1. +struct NrExposure +{ + ID3D12Resource* texture = nullptr; + float pre = 1.0f; + float scale = 1.0f; +}; + +NrExposure ReadNrExposure(NVSDK_NGX_Parameter* params) +{ + NrExposure out {}; + + ID3D12Resource* texture = nullptr; + + if (params->Get(NVSDK_NGX_Parameter_ExposureTexture, &texture) == NVSDK_NGX_Result_Success && + texture != nullptr) + { + out.texture = texture; + } + else + { + void* untyped = nullptr; + + if (params->Get(NVSDK_NGX_Parameter_ExposureTexture, &untyped) == NVSDK_NGX_Result_Success && + untyped != nullptr) + out.texture = static_cast(untyped); + } + + if (params->Get(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, &out.pre) != NVSDK_NGX_Result_Success || + out.pre == 0.0f) + out.pre = 1.0f; + + if (params->Get(NVSDK_NGX_Parameter_DLSS_Exposure_Scale, &out.scale) != NVSDK_NGX_Result_Success || + out.scale == 0.0f) + out.scale = 1.0f; + + return out; +} + // A change has to hold still before it is acted on: a slider being dragged reports a new value every // frame, and each one would otherwise mean a new model. constexpr unsigned long long kSettleFrames = 30; @@ -1318,6 +1475,30 @@ struct ScopedNrStateEnvelope } }; +// Restores the upscaler's output state on every exit, including GetDevice failure after the +// arrival → UAV transition has already been recorded. +struct ScopedOutputArrival +{ + ID3D12GraphicsCommandList* cmd = nullptr; + ID3D12Resource* target = nullptr; + D3D12_RESOURCE_STATES arrival = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; + bool armed = false; + + ScopedOutputArrival(ID3D12GraphicsCommandList* c, ID3D12Resource* t, D3D12_RESOURCE_STATES a) + : cmd(c), target(t), arrival(a), armed(true) + { + Barrier(cmd, target, arrival, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + } + + ~ScopedOutputArrival() + { + if (armed) + Barrier(cmd, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, arrival); + } + + void Disarm() { armed = false; } +}; + // Every way out of the pass before it does anything is silent on purpose -- an evaluate that carries // no depth is normal and would otherwise print every frame forever. That silence is fine until the // pass does nothing at all and the log has no opinion about why. @@ -1333,6 +1514,37 @@ void ReportSkipOnce(const char* reason) } // namespace +// Unusable → dummy, no throw. CreateShaderResourceView throws on null / DENY / BUFFER / UNKNOWN +// and will happily build a 1D or MSAA view that does not match Texture2D. This keeps those out. +// A member so it can call the protected TranslateTypelessFormats. Do not use TypedGuideFormat. +bool DlssNr_Dx12::ExposureUsable(ID3D12Resource* res) +{ + if (res == nullptr) + return false; + + const D3D12_RESOURCE_DESC desc = res->GetDesc(); + + if (desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D) + return false; + + if (desc.DepthOrArraySize != 1) + return false; + + if (desc.SampleDesc.Count != 1) + return false; + + if ((desc.Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE) != 0) + return false; + + const DXGI_FORMAT fmt = desc.Format; + const DXGI_FORMAT viewFmt = TranslateTypelessFormats(fmt); + + if (viewFmt == fmt && IsTypelessResourceFormat(fmt)) + return false; + + return true; +} + // --------------------------------------------------------------------------------------------- // The pass itself. Everything above is what it is made of; everything below is the shape the rest // of OptiScaler sees. @@ -1398,12 +1610,19 @@ DlssNr_Dx12::DlssNr_Dx12(std::string InName, ID3D12Device* InDevice) bool DlssNr_Dx12::DispatchPass(ID3D12GraphicsCommandList* InCmdList, const DlssNrConstants& InConstants, ID3D12Resource* InSource, ID3D12Resource* InModel, ID3D12Resource* InOriginal, ID3D12Resource* InMotion, - ID3D12Resource* InPrevEdit, ID3D12Resource* OutTarget, + ID3D12Resource* InExposure, ID3D12Resource* OutTarget, ID3D12Resource* OutKeep) { if (!_init || InCmdList == nullptr || _device == nullptr || InSource == nullptr || OutTarget == nullptr) return false; + // t4 must never stand in as InSource -- that is how a missing exposure became the top-left + // pixel. If the dummy is still null, skip rather than bind the picture. + ID3D12Resource* const exposureSrv = InExposure != nullptr ? InExposure : g_nr.exposureDummy; + + if (exposureSrv == nullptr) + return false; + const uint32_t slot = _heapIndex; _heapIndex = (_heapIndex + 1) % DLSSNR_NUM_OF_HEAPS; @@ -1411,13 +1630,13 @@ bool DlssNr_Dx12::DispatchPass(ID3D12GraphicsCommandList* InCmdList, const DlssN // Every slot in the table gets a view, whether the mode reads it or not. An unbound descriptor is // not an empty read; it is a read from nothing, and the source stands in wherever a mode has - // nothing of its own to put there. + // nothing of its own to put there. t4 is the exception: it falls back to the dummy, never InSource. ID3D12Resource* const srvs[kSrvCount] = { InSource, InModel != nullptr ? InModel : InSource, InOriginal != nullptr ? InOriginal : InSource, InMotion != nullptr ? InMotion : InSource, - InPrevEdit != nullptr ? InPrevEdit : InSource, + exposureSrv, }; for (uint32_t i = 0; i < kSrvCount; ++i) @@ -1491,7 +1710,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c ? (D3D12_RESOURCE_STATES) Config::Instance()->OutputResourceBarrier.value() : D3D12_RESOURCE_STATE_UNORDERED_ACCESS; - Barrier(cmdList, target, outputArrival, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + ScopedOutputArrival outputEnvelope(cmdList, target, outputArrival); ID3D12Device* device = nullptr; @@ -1501,6 +1720,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c return; } + EnsureExposureDummy(device, cmdList); + const D3D12_RESOURCE_DESC desc = target->GetDesc(); const auto width = (unsigned int) desc.Width; const auto height = desc.Height; @@ -1659,6 +1880,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c ParkNrResource(g_nr.colorCopy); ParkNrResource(g_nr.hdrCopy); ParkNrResource(g_nr.colorSmall); + InvalidateMeterReadback(); } } @@ -1865,70 +2087,103 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c if (g_gpuTime != nullptr) g_gpuTime->Start(cmdList); - // Fetch the game's exposure, where the game supplies one and the user asked for it. - // - // This used to measure the white point off the frame as well, over a 64x64 grid of tile - // luminances. That is gone: the pass writes the frame it was measuring, so the divisor chased its - // own output -- one Enshrouded session walked it from 0.010 to 97.910, and toggling NR at a fixed - // spot read 41.31 off against 0.46 on. What remains dispatches a single thread to copy the game's - // 1x1 exposure texture into tile 0. That is a courier, not a measurement, and cannot feed back. - // Gated on the source the menu actually writes. This read the retired WhitePointFromExposure - // flag while consumption keyed on WhitePointSource == 1, so choosing "the game's own exposure" - // never dispatched the meter and the white point silently fell back to the slider. - const bool exposureSettingOn = cfg.DlssNrWhitePointSource.value_or_default() == 1; - - // Nothing held from before the option was switched off may survive switching it back on. See - // InvalidateExposureMeter for what froze and why it read as a colour cast. - if (exposureSettingOn && !g_nr.exposureSettingWasOn) + ID3D12Resource* const gameRes = (ID3D12Resource*) frame.ExposureTexture; + const bool usable = ExposureUsable(gameRes); + + const uint32_t source = cfg.DlssNrWhitePointSource.value_or_default(); + if (source == 1 && !g_nr.exposureSettingWasOn) { InvalidateExposureMeter(); LOG_INFO("DLSS-NR exposure: option switched on, held reading discarded"); } + g_nr.exposureSettingWasOn = source == 1; - g_nr.exposureSettingWasOn = exposureSettingOn; + haveEvaluated.store(true); + sessionPassthrough.store(!isHdrBuffer); - const bool wantExposure = exposureSettingOn && frame.ExposureTexture != nullptr; + if (usable) + sessionHasTexture.store(true); - if (g_nr.meter != nullptr && wantExposure) + const bool heldE = std::isfinite(g_nr.gameExposure) && g_nr.gameExposure > 1e-6f; + const float scale = cfg.DlssNrWhitePointScale.value_or_default(); + const float trim = std::clamp(cfg.DlssNrWhitePointTrim.value_or_default(), 0.25f, 4.0f); + float anchored = 0.0f; + if (source == 2) { - DlssNrConstants meterParams {}; - meterParams.Mode = DlssNrMode_Meter; + anchored = DlssNr::ExposureScan::AnchoredWhitePoint( + DlssNr::ExposureScan::BestValue(), cfg.DlssNrScanInverted.value_or_default(), + cfg.DlssNrScanTrim.value_or_default()); + } + const WhitePointDecision d = + DecideWhitePoint(source, isHdrBuffer, usable, heldE, scale, trim, g_nr.gameExposure, + frame.PreExposure, frame.ExposureScale, anchored); + ID3D12Resource* encodeT4 = (d.useGameExposure == 1) ? gameRes : g_nr.exposureDummy; + const bool hole = isHdrBuffer && source == 1 && !usable; - // One pixel. Only tile (0,0) is read back, and the tile-mean branch below it in the shader is - // dead code the dispatch simply never reaches. - meterParams.Width = 1; - meterParams.Height = 1; + if (frame.ExposureTexture != nullptr && !usable) + { + static bool loggedUnusable = false; - Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - DispatchPass(cmdList, meterParams, target, nullptr, nullptr, - (ID3D12Resource*) frame.ExposureTexture, nullptr, g_nr.meter, nullptr); - Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, - D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + if (!loggedUnusable) + { + loggedUnusable = true; + LOG_WARN("DLSS-NR: ExposureTexture failed ExposureUsable (format {}, dim {}, samples {})", + (int) gameRes->GetDesc().Format, (int) gameRes->GetDesc().Dimension, + gameRes->GetDesc().SampleDesc.Count); + } + } - CopyMeterToReadback(cmdList, device, true); - ConsumeMeterReadback(); + if (usable) + { + static bool loggedUsable = false; + + if (!loggedUsable) + { + loggedUsable = true; + const D3D12_RESOURCE_DESC expDesc = gameRes->GetDesc(); + LOG_INFO("DLSS-NR exposure usable: {}x{} format {} P {} S {}", (unsigned) expDesc.Width, + expDesc.Height, (int) expDesc.Format, frame.PreExposure, frame.ExposureScale); + } + } + + if (hole) + { + static bool loggedHole = false; + + if (!loggedHole) + { + loggedHole = true; + LOG_INFO("DLSS-NR exposure hole: Effective but this frame's pointer is null or unusable" + " (held E {})", + heldE ? g_nr.gameExposure : 0.0f); + } } g_nr.gamePreExposure = frame.PreExposure; + readoutP.store(frame.PreExposure); + readoutS.store(frame.ExposureScale); - const float whitePoint = ResolveWhitePoint(cfg, isHdrBuffer); + ExposureHotfixSpan exposureHotfix; + + if (d.useGameExposure == 1) + exposureHotfix.Open(cmdList, gameRes); DlssNrConstants encodeParams {}; encodeParams.Mode = DlssNrMode_Encode; // A frame that is already display-referred is handed over untouched: the encode becomes a copy and // the resolve adds the model's edit back at full scale. encodeParams.Passthrough = isHdrBuffer ? 0u : 1u; - encodeParams.WhitePoint = whitePoint; - // Match only takes effect once a fit exists; until then the table is empty and the shader would - // read a curve of zeros, so it falls back to the plain proxy. + encodeParams.WhitePoint = d.whitePoint; encodeParams.Width = width; encodeParams.Height = height; + encodeParams.UseGameExposure = d.useGameExposure; + encodeParams.PreExposure = frame.PreExposure; + encodeParams.ExposureScale = frame.ExposureScale; Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - DispatchPass(cmdList, encodeParams, target, nullptr, nullptr, nullptr, nullptr, - g_nr.colorCopy, g_nr.hdrCopy); + DispatchPass(cmdList, encodeParams, target, nullptr, nullptr, nullptr, encodeT4, g_nr.colorCopy, + g_nr.hdrCopy); Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); @@ -1942,6 +2197,34 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c Barrier(cmdList, g_nr.hdrCopy, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + // Mode 3 whenever usable, even if !Effective (then encodeT4 is dummy and this t4 is the game + // resource). Courier for the menu and the held E, not the picture. After encode, before downsample + // / UseProxy. The target UAV↔SRV pair moved here with it. + if (usable && g_nr.meter != nullptr) + { + if (d.useGameExposure != 1) + exposureHotfix.Open(cmdList, gameRes); + + DlssNrConstants meterParams {}; + meterParams.Mode = DlssNrMode_Meter; + meterParams.Width = 1; + meterParams.Height = 1; + + Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + DispatchPass(cmdList, meterParams, target, nullptr, nullptr, nullptr, gameRes, g_nr.meter, + nullptr); + Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + + CopyMeterToReadback(cmdList, device, true); + ConsumeMeterReadback(); + + // !Effective && usable: first = last = Mode 3. + if (d.useGameExposure != 1) + exposureHotfix.Close(); + } + // Below full resolution the model is shown a filtered shrink of the proxy; the edit it returns is // enlarged during the resolve while the frame underneath stays full size and untouched. ID3D12Resource* modelInput = g_nr.colorCopy; @@ -1952,8 +2235,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c down.Mode = DlssNrMode_Downsample; down.Width = workWidth; down.Height = workHeight; - DispatchPass(cmdList, down, modelInput, nullptr, nullptr, nullptr, nullptr, - g_nr.colorSmall, nullptr); + DispatchPass(cmdList, down, modelInput, nullptr, nullptr, nullptr, nullptr, g_nr.colorSmall, + nullptr); Barrier(cmdList, g_nr.colorSmall, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); modelInput = g_nr.colorSmall; @@ -1970,7 +2253,6 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c g_nr.failed = true; g_nr.reason = "the game's depth or motion vectors could not be made readable"; LOG_ERROR("DLSS-NR unavailable: {}", g_nr.reason); - Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, outputArrival); device->Release(); return; } @@ -2004,7 +2286,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c proxyResult, NgxResultName(proxyResult)); } - Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, outputArrival); + exposureHotfix.Close(); device->Release(); return; } @@ -2071,25 +2353,23 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c if (result == NVSDK_NGX_Result_Success) { - // Resolve takes the difference between what the model returned and what it was shown, and adds - // that back to the frame. At strength zero the result is what the upscaler produced, exactly, and - // anything the model left alone is untouched rather than round-tripped through the curve. - DlssNrConstants resolveParams {}; + // The resolve composes the model's answer against the keep (hdrCopy) as the shader describes; + // the additive description is from an older composition. At strength zero the keep comes + // back as stored. + DlssNrConstants resolveParams = encodeParams; resolveParams.Mode = DlssNrMode_Resolve; - resolveParams.WhitePoint = whitePoint; - resolveParams.Width = width; - resolveParams.Height = height; resolveParams.TransferStrength = cfg.DlssNrTransferStrength.value_or_default(); resolveParams.ColourStrength = cfg.DlssNrColourStrength.value_or_default(); resolveParams.DebugView = cfg.DlssNrDebugView.value_or_default(); resolveParams.MaxRatio = cfg.DlssNrMaxRatio.value_or_default(); resolveParams.Transfer = cfg.DlssNrTransfer.value_or_default(); resolveParams.DebugScale = cfg.DlssNrWhitePointScale.value_or_default(); - resolveParams.Passthrough = isHdrBuffer ? 0u : 1u; resolveParams.CompareMode = cfg.DlssNrCompare.value_or_default(); resolveParams.CompareSplit = cfg.DlssNrCompareSplit.value_or_default(); resolveParams.CompareZoom = std::max(1.0f, cfg.DlssNrCompareZoom.value_or_default()); resolveParams.CompareSwap = cfg.DlssNrCompareSwap.value_or_default() ? 1u : 0u; + resolveParams.WhitePoint = encodeParams.WhitePoint; + resolveParams.UseGameExposure = encodeParams.UseGameExposure; // The numbers the composition actually ran with, logged when any of them changes. // @@ -2151,10 +2431,12 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c Barrier(cmdList, g_nr.output, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - DispatchPass(cmdList, resolveParams, modelInput, g_nr.output, g_nr.hdrCopy, motionIn, - nullptr, target, nullptr); + DispatchPass(cmdList, resolveParams, modelInput, g_nr.output, g_nr.hdrCopy, g_nr.colorCopy, + encodeT4, target, nullptr); Barrier(cmdList, g_nr.output, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + // Effective && usable and resolve: first = encode, last = resolve. + exposureHotfix.Close(); // On-demand capture works in this path too: the staging copy still holds the frame as the // upscaler produced it, and the edited frame is the output itself. The write happens a few @@ -2240,9 +2522,6 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c Barrier(cmdList, g_nr.colorCopy, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); - // Hand the output back in the state the upscaler and the game expect. - Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, outputArrival); - device->Release(); } @@ -2339,36 +2618,22 @@ void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Paramete if (params->Get(NVSDK_NGX_Parameter_MV_Scale_Y, &frame.MvScaleY) != NVSDK_NGX_Result_Success) frame.MvScaleY = 1.0f; - // What the game says about its own exposure. Logged, used for nothing yet. + // What the game says about its own exposure. Filled into FrameInfo; Dispatch decides + // usable / Effective / t4. The paper-white slider lives in Config. // - // The white point measured from the frame turned out to be a control loop rather than a - // measurement: the pass writes into the buffer it reads, most games adapt their exposure to the - // finished frame, and the two chase each other -- 0.01 to 97.9 in one Enshrouded session. Any - // statistic taken from a frame we modify has that problem. - // - // These do not. DLSS.Pre.Exposure is the scale the game applied before handing the buffer over, - // and ExposureTexture is a 1x1 the game fills with the exposure it is using; both are the game's - // own numbers, decided upstream of anything here. Whether either is close to the divisor the model - // actually wants is unknown, which is why this only prints them. + // DLSS.Pre.Exposure is the scale the game applied before handing the buffer over, + // DLSS.Exposure.Scale is the extra NGX scale, and ExposureTexture is a 1x1 the game fills. + // All three are the game's own numbers, decided upstream of anything here. // // The auto-exposure flag decides whether the texture means anything: with it set the game is // telling DLSS to work exposure out for itself and may supply nothing. OptiScaler forces that flag // on for eighteen games, so it is logged too -- reading a value whose flag has been overridden is // how the debug views lied earlier tonight. { - float preExposure = 0.0f; - const bool havePre = - params->Get(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, &preExposure) == NVSDK_NGX_Result_Success; - - void* exposureTex = nullptr; - params->Get(NVSDK_NGX_Parameter_ExposureTexture, &exposureTex); - - frame.ExposureTexture = exposureTex; - frame.PreExposure = havePre && preExposure > 1e-6f ? preExposure : 1.0f; - - g_nr.exposureOfferedNow = exposureTex != nullptr; - g_nr.exposureEverOffered = g_nr.exposureEverOffered || g_nr.exposureOfferedNow; - g_nr.exposureFrames++; + const NrExposure exposure = ReadNrExposure(params); + frame.ExposureTexture = exposure.texture; + frame.PreExposure = exposure.pre; + frame.ExposureScale = exposure.scale; const bool autoExposureFlag = (createFlags & NVSDK_NGX_DLSS_Feature_Flags_AutoExposure) != 0; @@ -2376,37 +2641,36 @@ void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Paramete { bool valid; float pre; - bool havePre; + float scale; bool haveTexture; bool autoFlag; }; static ExposureReport logged {}; - const ExposureReport now { true, havePre ? preExposure : 0.0f, havePre, exposureTex != nullptr, + const ExposureReport now { true, exposure.pre, exposure.scale, exposure.texture != nullptr, autoExposureFlag }; - if (!logged.valid || logged.havePre != now.havePre || logged.haveTexture != now.haveTexture || - logged.autoFlag != now.autoFlag || - std::abs(logged.pre - now.pre) > std::max(0.01f * std::abs(now.pre), 1e-4f)) + if (!logged.valid || logged.haveTexture != now.haveTexture || logged.autoFlag != now.autoFlag || + std::abs(logged.pre - now.pre) > std::max(0.01f * std::abs(now.pre), 1e-4f) || + std::abs(logged.scale - now.scale) > std::max(0.01f * std::abs(now.scale), 1e-4f)) { logged = now; - LOG_INFO("DLSS-NR exposure from the game: DLSS.Pre.Exposure {}, ExposureTexture {}, " - "auto-exposure flag {}", - now.havePre ? std::to_string(now.pre) : std::string("not supplied"), - now.haveTexture ? "supplied" : "not supplied", now.autoFlag ? "set" : "clear"); + LOG_INFO("DLSS-NR exposure from the game: DLSS.Pre.Exposure {}, DLSS.Exposure.Scale {}, " + "ExposureTexture {}, auto-exposure flag {}", + now.pre, now.scale, now.haveTexture ? "supplied" : "not supplied", + now.autoFlag ? "set" : "clear"); } - // The value itself, once it has come back off the GPU. Separate from the line above because - // that one says what the game offers and this one says what it actually reads -- and because - // the reading arrives three frames after the offer. + // Courier readback, three frames after the offer. The menu shows this; encode does not + // use this CPU float. static float loggedExposure = -1.0f; if (g_nr.gameExposure > 1e-6f && std::abs(loggedExposure - g_nr.gameExposure) > std::max(0.02f * g_nr.gameExposure, 1e-5f)) { loggedExposure = g_nr.gameExposure; - LOG_INFO("DLSS-NR game exposure {:.5f} (pre-exposure {:.3f}) -> white point would be {:.2f}", - g_nr.gameExposure, g_nr.gamePreExposure, g_nr.gamePreExposure / g_nr.gameExposure); + LOG_INFO("DLSS-NR courier readback {:.5f} (pre-exposure {:.3f}) -- not the value encode used", + g_nr.gameExposure, g_nr.gamePreExposure); } // The scan's number, on the same cadence, so one log carries both. @@ -2451,6 +2715,8 @@ void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Paramete } // The pass is the object, so the caller holds it. Built once, on the device the frame is on. + // The exposure dummy is created on the first Dispatch that has a device (same frame, under + // g_nrMutex) rather than here, so two EvaluateAfterUpscale call sites cannot race the pointer. if (g_compose == nullptr) g_compose = std::make_unique("Neural Rendering", device); @@ -2591,32 +2857,49 @@ void ProbeD3D11(void* d3d11Device) result, NgxResultName((unsigned int) result)); } -CalibrationReading Calibration() +bool IsRunning() { return g_nr.feature != nullptr && !g_nr.failed; } + +const char* FailureReason() { return g_nr.failed ? g_nr.reason : ""; } + +bool GameExposureCanEnable() { - CalibrationReading r {}; - r.suggestion = g_nr.calibSuggestion; - r.steadiness = g_nr.calibSteadiness; - r.samples = g_nr.calibCount; - r.usable = g_nr.calibUsable; - r.why = g_nr.calibWhy; - return r; + return sessionHasTexture.load() && !sessionPassthrough.load() && haveEvaluated.load() && + !IsRunningVk(); } -bool IsRunning() { return g_nr.feature != nullptr && !g_nr.failed; } +bool GameExposureEffective() +{ + return GameExposureCanEnable() && + Config::Instance()->DlssNrWhitePointSource.value_or_default() == 1; +} -const char* FailureReason() { return g_nr.failed ? g_nr.reason : ""; } +GameExposureWait GameExposureUiState() +{ + if (IsRunningVk()) + return GameExposureWait::NativeVulkan; + + if (!haveEvaluated.load()) + return GameExposureWait::Waiting; + + if (sessionPassthrough.load()) + return GameExposureWait::Passthrough; + + if (!sessionHasTexture.load()) + return GameExposureWait::Absent; + + return GameExposureWait::Available; +} -// What the game offers by way of exposure, and what has been read from it. For the menu, so a user -// can see whether this game supplies one at all without having to read a log. -ExposureStatus GameExposureStatus() +GameExposureReadout GameExposureMenuReadout() { - ExposureStatus s {}; - s.seenFrames = g_nr.exposureFrames; - s.offeredNow = g_nr.exposureOfferedNow; - s.everOffered = g_nr.exposureEverOffered; - s.exposure = g_nr.gameExposure; - s.preExposure = g_nr.gamePreExposure; - return s; + GameExposureReadout r {}; + r.haveNumbers = haveFiniteE.load(); + r.e = readoutE.load(); + r.p = readoutP.load(); + r.s = readoutS.load(); + r.gameW = r.haveNumbers ? GameWhite(r.e, r.p, r.s) : 0.0f; + r.slider = Config::Instance()->DlssNrWhitePointTrim.value_or_default(); + return r; } std::optional LastGpuTime() { return g_lastGpuTime; } @@ -2683,6 +2966,12 @@ void Shutdown() g_nr.colorSmall = nullptr; } + if (g_nr.exposureDummy != nullptr) + { + g_nr.exposureDummy->Release(); + g_nr.exposureDummy = nullptr; + } + if (g_nr.meter != nullptr) { g_nr.meter->Release(); @@ -2729,7 +3018,16 @@ void Shutdown() valid = false; g_nr.meterFrames = 0; - + InvalidateMeterReadback(); + g_nr.gameExposure = 0.0f; + g_nr.gamePreExposure = 1.0f; + haveEvaluated.store(false); + sessionHasTexture.store(false); + sessionPassthrough.store(false); + haveFiniteE.store(false); + readoutE.store(0.0f); + readoutP.store(1.0f); + readoutS.store(1.0f); if (g_nr.depthClone != nullptr) { diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h index 56fdff758..76b0c3f2a 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h @@ -65,6 +65,9 @@ class DlssNr_Dx12 : public Shader_Dx12, public DlssNr_Common static constexpr uint32_t kSrvCount = 5; static constexpr uint32_t kUavCount = 2; + // Unusable → dummy, no throw. Calls TranslateTypelessFormats (protected on Shader_Dx12). + static bool ExposureUsable(ID3D12Resource* InResource); + uint32_t _numThreadsX = 8; uint32_t _numThreadsY = 8; @@ -91,9 +94,8 @@ class DlssNr_Dx12 : public Shader_Dx12, public DlssNr_Common bool DispatchPass(ID3D12GraphicsCommandList* InCmdList, const DlssNrConstants& InConstants, ID3D12Resource* InSource, ID3D12Resource* InModel, ID3D12Resource* InOriginal, ID3D12Resource* InMotion, - // Vestigial. Fed to the slot the removed edit accumulator read its history from; - // nothing reads it now and every caller passes nullptr. Kept only so the binding - // table keeps its shape -- not evidence that temporal accumulation exists. - ID3D12Resource* InPrevEdit, ID3D12Resource* OutTarget, + // t4. The game's 1x1 exposure when it is usable and Effective, otherwise the + // 1x1 dummy (E = 1). Null falls back to the dummy; it must not fall back to InSource. + ID3D12Resource* InExposure, ID3D12Resource* OutTarget, ID3D12Resource* OutKeep); }; diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp b/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp index df42793c9..2d02feda1 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp +++ b/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp @@ -60,13 +60,14 @@ DlssNr_Vk::DlssNr_Vk(std::string InName, VkDevice InDevice, VkPhysicalDevice InP CreateBinding(5, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), // gTarget CreateBinding(6, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), // gKeep CreateBinding(7, VK_DESCRIPTOR_TYPE_SAMPLER), // gLinear + CreateBinding(8, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gExposure }; CreateLayouts(bindings); std::vector poolSizes = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, kSlots }, - { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 4 * kSlots }, + { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 5 * kSlots }, { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 2 * kSlots }, { VK_DESCRIPTOR_TYPE_SAMPLER, kSlots }, }; @@ -116,8 +117,8 @@ DlssNr_Vk::~DlssNr_Vk() // One pixel, R16G16B16A16_SFLOAT so it is legal for both a sampled read and a storage write, moved // once into GENERAL and left there. Its content is never read: it exists because Vulkan rejects a -// descriptor set with an unwritten binding, and the shader declares all seven resources at file scope -// whichever mode is running. +// descriptor set with an unwritten binding, and the shader declares all eight resources at file scope +// whichever mode is running. The fifth read (binding 8) is always this placeholder. bool DlssNr_Vk::CreateDummy(VkCommandBuffer cmdList) { if (_dummyReady) @@ -185,7 +186,8 @@ bool DlssNr_Vk::CreateDummy(VkCommandBuffer cmdList) void DlssNr_Vk::WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffset, VkImageView source, VkImageView model, VkImageView original, VkImageView motion, VkImageView target, - VkImageView keep, VkImageLayout sourceLayout, VkImageLayout motionLayout) + VkImageView keep, VkImageView exposure, VkImageLayout sourceLayout, + VkImageLayout motionLayout, VkImageLayout exposureLayout) { VkDescriptorBufferInfo bufferInfo { _constantBuffer, constantOffset, sizeof(DlssNrConstants) }; @@ -210,6 +212,7 @@ void DlssNr_Vk::WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffse VkDescriptorImageInfo targetInfo = writeInfo(target); VkDescriptorImageInfo keepInfo = writeInfo(keep); VkDescriptorImageInfo samplerInfo { _textureSampler, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_UNDEFINED }; + VkDescriptorImageInfo exposureInfo = readInfo(exposure, exposureLayout); const VkWriteDescriptorSet writes[] = { { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, set, 0, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, nullptr, @@ -228,6 +231,8 @@ void DlssNr_Vk::WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffse nullptr, nullptr }, { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, set, 7, 0, 1, VK_DESCRIPTOR_TYPE_SAMPLER, &samplerInfo, nullptr, nullptr }, + { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, set, 8, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + &exposureInfo, nullptr, nullptr }, }; vkUpdateDescriptorSets(_device, (uint32_t) (sizeof(writes) / sizeof(writes[0])), writes, 0, nullptr); @@ -236,7 +241,8 @@ void DlssNr_Vk::WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffse bool DlssNr_Vk::Dispatch(VkCommandBuffer InCmdList, const DlssNrConstants& InConstants, uint32_t InThreadsX, uint32_t InThreadsY, VkImageView InSource, VkImageView InModel, VkImageView InOriginal, VkImageView InMotion, VkImageView InTarget, VkImageView InKeep, - VkImageLayout InSourceLayout, VkImageLayout InMotionLayout) + VkImageLayout InSourceLayout, VkImageLayout InMotionLayout, VkImageView InExposure, + VkImageLayout InExposureLayout) { if (!CanRender() || InCmdList == VK_NULL_HANDLE) return false; @@ -257,7 +263,7 @@ bool DlssNr_Vk::Dispatch(VkCommandBuffer InCmdList, const DlssNrConstants& InCon std::memcpy((char*) _mappedConstantBuffer + offset, &InConstants, sizeof(DlssNrConstants)); WriteDescriptors(_descriptorSets[slot], offset, InSource, InModel, InOriginal, InMotion, InTarget, InKeep, - InSourceLayout, InMotionLayout); + InExposure, InSourceLayout, InMotionLayout, InExposureLayout); vkCmdBindPipeline(InCmdList, VK_PIPELINE_BIND_POINT_COMPUTE, _pipeline); vkCmdBindDescriptorSets(InCmdList, VK_PIPELINE_BIND_POINT_COMPUTE, _pipelineLayout, 0, 1, &_descriptorSets[slot], 0, diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Vk.h b/OptiScaler/shaders/dlssnr/DlssNr_Vk.h index 6327cd5c0..0f28dbca9 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Vk.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Vk.h @@ -9,10 +9,11 @@ // // Three things are worth knowing before reading the implementation. // -// Every binding is written every dispatch. The shader declares all seven resources at file scope and +// Every binding is written every dispatch. The shader declares all eight resources at file scope and // branches on gMode, so all of them are statically reachable from the entry point and Vulkan requires // a valid descriptor for each one whether a given mode reads it or not. Slots a mode has no use for -// get a 1x1 dummy rather than a null handle. +// get a 1x1 dummy rather than a null handle. Binding 8 (gExposure) is always that dummy: native +// Vulkan does not sample the game's exposure image. // // Constants are slotted rather than overwritten. A single mapped uniform buffer would be wrong here: // encode and resolve run in the same frame with different constants, and the second write would land @@ -48,7 +49,8 @@ class DlssNr_Vk : public Shader_Vk void WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffset, VkImageView source, VkImageView model, VkImageView original, VkImageView motion, VkImageView target, VkImageView keep, - VkImageLayout sourceLayout, VkImageLayout motionLayout); + VkImageView exposure, VkImageLayout sourceLayout, VkImageLayout motionLayout, + VkImageLayout exposureLayout); public: DlssNr_Vk(std::string InName, VkDevice InDevice, VkPhysicalDevice InPhysicalDevice); @@ -56,20 +58,18 @@ class DlssNr_Vk : public Shader_Vk // One dispatch of the composition shader. // - // Any of the four read views may be VK_NULL_HANDLE, in which case the dummy is bound; the two + // Any of the five read views may be VK_NULL_HANDLE, in which case the dummy is bound; the two // written views may not, because a mode that writes nothing has no reason to run. This records // the dispatch and the barrier that follows it, not the transitions that got them there. // - // The source and motion slots are the two that ever carry an image this pass does not own -- the - // frame the upscaler wrote, and the game's exposure -- and a descriptor has to name the layout - // its image will be in when the shader runs. Those two are therefore the caller's to state. - // Everything else is ours and is in the layout this pass put it in. - // - // The default is what a resource read by a compute shader is normally in, and is what every slot - // holding one of our own images uses. + // The source, motion, and exposure slots are the ones that ever carry an image this pass does + // not own. A descriptor has to name the layout its image will be in when the shader runs, so + // those three are the caller's to state. Everything else is ours. bool Dispatch(VkCommandBuffer InCmdList, const DlssNrConstants& InConstants, uint32_t InThreadsX, uint32_t InThreadsY, VkImageView InSource, VkImageView InModel, VkImageView InOriginal, VkImageView InMotion, VkImageView InTarget, VkImageView InKeep, VkImageLayout InSourceLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VkImageLayout InMotionLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + VkImageLayout InMotionLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VkImageView InExposure = VK_NULL_HANDLE, + VkImageLayout InExposureLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); }; diff --git a/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl b/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl index cc7b11ed2..9c692d3de 100644 --- a/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl +++ b/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl @@ -25,6 +25,9 @@ cbuffer Params : register(b0) uint gCompareSwap; // put the edited frame on the other side uint gTransfer; // 0 classic, 1 matched residual -- how a below-size model comes back float gDebugScale; // what the debug views are scaled by, held still while the meter moves + uint gUseGameExposure; + float gPreExposure; + float gExposureScale; }; // Bringing an impossible colour back into a possible one. @@ -217,7 +220,11 @@ Texture2D gOriginal : register(t2); // resolve: the untouched frame. #ifdef VK_MODE [[vk::binding(4, 0)]] #endif -Texture2D gMotion : register(t3); // resolve, accumulating: the game's motion vectors. +Texture2D gMotion : register(t3); // t3: resolve full-res encode (colorCopy / g_vk.proxy). Name is the slot's history; nothing here reads motion vectors. +#ifdef VK_MODE +[[vk::binding(8, 0)]] +#endif +Texture2D gExposure : register(t4); // t4: the game's 1x1 exposure. Mode 3 tile 0, and PaperWhite() when the flag is set. #ifdef VK_MODE [[vk::binding(5, 0)]] #endif @@ -263,12 +270,10 @@ float3 EditAt(float2 uvq) } -// The soft knee, shared by the encode and the resolve. +// The soft knee, applied by the encode only. // -// The encode applies it on the way in; the resolve has to be able to reproduce it, because the -// matched-residual path needs the frame's own proxy at full resolution and the encode only ever -// wrote a reduced one. It is a pure function of the pixel, so recomputing costs less than the -// texture read it replaces. +// The knee is applied on the way in. The resolve reads the encode's output back (t3) when it +// needs the frame's own proxy at full resolution; it does not recompute the curve. float3 SoftKnee(float3 display) { if (gPassthrough != 0) @@ -293,8 +298,7 @@ float3 SoftKnee(float3 display) // // One scalar on the whole triple cannot move hue, so the peak channel is brought to 1 that way. // Only pixels that were already being clipped are touched, so everything else is bit-identical - // to before, and the resolve's reconstruction of this proxy stays exact because it goes through - // this same function. + // to before. Encode is the only SoftKnee caller; the resolve reads that result back from t3. float peak = max(display.r, max(display.g, display.b)); if (peak > 1.0) @@ -330,6 +334,22 @@ float3 CubeScaleResidual(float3 P, float3 T) return P + saturate(alpha) * d; } +float PaperWhite() +{ + float slider = max(gWhitePoint, 1e-4); + if (gUseGameExposure == 0) + return slider; + + float e = gExposure.Load(int3(0, 0, 0)).r; + if (!(e > 1e-6 && e < 1e6)) + e = 1.0; + + float s = max(gExposureScale, 1e-4); + float p = max(gPreExposure, 1e-4); + float gameW = p / max(e * s, 1e-4); // starting polarity; see T0 + return max(slider * gameW, 1e-4); +} + [numthreads(8, 8, 1)] void CSMain(uint3 id : SV_DispatchThreadID) { @@ -347,59 +367,6 @@ void CSMain(uint3 id : SV_DispatchThreadID) // the meter this replaces measured: that reads scene brightness, and a dark scene then asks for a // small divisor and hands the model a blown picture anyway. Not the frame's maximum either, which // one specular hit decides. - // What scale is this game's buffer on? - // - // Not a taste question. The composition divides the frame by paper white to work in a normalised - // space, and the right divisor is the one that lands the picture in [0,1]. Nioh 3 needs about 240 - // because its linear buffer holds values around two hundred; GTA V's exposure yields 2.7. Below - // the correct value the frame is never normalised, the headroom branch computes ratios in the - // hundreds, and ToOkLab is handed values far outside the range its cube root was built for -- the - // green tint. - // - // Measured from the UNTOUCHED copy the encode kept, never from the frame this pass writes. That - // distinction is the whole reason this is safe where the old white point meter was not: that one - // read its own output and chased it, walking one Enshrouded session from 0.010 to 97.910. There - // is no path from what this pass writes back into what this reads. - // - // Per tile, the peak luminance rather than the mean. The mean is scene brightness and says - // nothing about scale; the peak says where the top of the range is, which is exactly what the - // divisor has to match. One specular hit cannot decide the answer because the host takes a - // percentile across tiles afterwards. - if (gMode == 4) - { - uint fullW, fullH; - gSource.GetDimensions(fullW, fullH); - - const uint tx0 = (uint) (((float) id.x * (float) fullW) / (float) gWidth); - const uint tx1 = (uint) (((float) (id.x + 1) * (float) fullW) / (float) gWidth); - const uint ty0 = (uint) (((float) id.y * (float) fullH) / (float) gHeight); - const uint ty1 = (uint) (((float) (id.y + 1) * (float) fullH) / (float) gHeight); - - // Sixteen samples a side rather than eight, and offset half a step in so the lattice does not - // sit on the tile's own corner. - // - // A fixed sample count over a growing tile means a shrinking fraction of it is read: eight per - // side covers about 17% of a tile at 1080p but only 4% at 4K, so the same scene reported a - // lower peak -- and therefore a smaller suggested divisor -- the higher the resolution. That is - // a measurement that changes with the setting rather than with the game. - const uint stepX = max((tx1 - tx0) / 16u, 1u); - const uint stepY = max((ty1 - ty0) / 16u, 1u); - - float peak = 0.0; - - for (uint ty = ty0; ty < max(ty1, ty0 + 1u); ty += stepY) - { - for (uint tx = tx0; tx < max(tx1, tx0 + 1u); tx += stepX) - { - const float3 c = max(gSource.Load(int3(min(tx, fullW - 1u), min(ty, fullH - 1u), 0)).rgb, 0.0); - peak = max(peak, dot(c, kLuma)); - } - } - - gTarget[id.xy] = float4(peak, 0.0, 0.0, 1.0); - return; - } - if (gMode == 3) { // Tile (0,0) carries the game's own exposure rather than a tile mean. @@ -409,10 +376,10 @@ void CSMain(uint3 id : SV_DispatchThreadID) // which is how a device is lost. Reading it as an SRV in a pass that is already running costs // nothing and touches no state -- and it rides back on the readback that already exists. // - // The motion slot is free here: the meter has no use for motion vectors. + // t4 carries the game's exposure; the resolve still reads the full-resolution encode from t3. if (id.x == 0 && id.y == 0) { - gTarget[id.xy] = float4(gMotion.Load(int3(0, 0, 0)).r, 0.0, 0.0, 1.0); + gTarget[id.xy] = float4(gExposure.Load(int3(0, 0, 0)).r, 0.0, 0.0, 1.0); return; } @@ -533,8 +500,9 @@ void CSMain(uint3 id : SV_DispatchThreadID) // A soft knee instead of a hard ceiling. Anything above 0.75 is rolled off rather than // clipped, so the model is never shown a field of flat white whose blown pixels flip between // frames -- unstable input is unstable output, and this is where a bright scene would produce - // it. The resolve reproduces this exactly, so the two agree on what the frame's own proxy is. - float3 display = SoftKnee(frame / max(gWhitePoint, 1e-4)); + // it. The resolve reads this texture back rather than recomputing it, so the two cannot + // disagree on what the frame's own proxy is. + float3 display = SoftKnee(frame / PaperWhite()); gTarget[id.xy] = float4(LinearToSrgb(display), source.a); return; @@ -594,7 +562,7 @@ void CSMain(uint3 id : SV_DispatchThreadID) // the shadow branch never fires, every pixel takes the highlight branch, and the clamp flattens // the result to a near-constant scale. Colour still moves, because that comes from the model's // own hue, which is what makes the failure so confusing to look at. - const float normScale = gPassthrough != 0 ? 1.0 : max(gWhitePoint, 1e-4); + const float normScale = gPassthrough != 0 ? 1.0 : PaperWhite(); float3 original = originalSample.rgb / normScale; float originalLuma = dot(original, kLuma); @@ -637,6 +605,10 @@ void CSMain(uint3 id : SV_DispatchThreadID) // Said plainly because the comment that survived the removal did not say it, and a later reader // took it for a description of live code and planned on top of machinery that is not here. + // Measured on the model's own answer, before the residual below may replace `model`. An empty + // frame from the model is "hand the frame back", whatever the residual would have made of it. + const bool emptyModel = dot(model, kLuma) <= 1e-5; + // Matched residual: put the two pictures being compared at the same resolution first. // // Classic hands the composition below a low-resolution `proxy` and a low-resolution `model` @@ -645,46 +617,33 @@ void CSMain(uint3 id : SV_DispatchThreadID) // the frame has and the model never saw, which is a term that grows as the model's raster // shrinks. That is the resolution-dependent colour shift measured at 50%. // - // Here the frame's own proxy is rebuilt at full resolution -- the encode is a pure function, so - // SoftKnee reproduces it exactly -- and only the model's *difference* is carried up from small. - // Both pictures handed to the composition are then full resolution and the only thing that came - // from the reduced raster is the edit itself, which is what was wanted from it. + // Here the full-resolution proxy is the encode itself, read from t3, and only the model's + // *difference* is carried up from small. Both pictures handed to the composition are then full + // resolution and the only thing that came from the reduced raster is the edit itself, which is + // what was wanted from it. // // The residual and its cube scaling are hhkbble's, from the multi-pass PR against this fork. // - // Taken only when the model actually worked below the frame. At the same rate the arithmetic - // collapses -- fullProxy + (model - proxy) is model, because proxy already is the frame's own - // full-resolution proxy -- but only in exact arithmetic. The one this pass reads has been through - // an sRGB encode, a texture, and a decode, while the one SoftKnee rebuilds has not, so the two - // agree to within the proxy surface's precision rather than exactly. Skipping the path when there - // is no residual to carry makes 100% bit-identical to Classic instead of nearly identical, which - // is what lets this default to on: the shipped configuration cannot be changed by it at all. + // Taken only when the model actually worked below the frame. Skipped when there is no residual + // to carry -- that skip is what keeps Classic and Matched bit-identical at 100%, which is what + // lets this default to on: the shipped configuration cannot be changed by it at all. uint proxyW, proxyH; gSource.GetDimensions(proxyW, proxyH); const bool modelRanSmall = proxyW != gWidth || proxyH != gHeight; if (gTransfer == 1 && modelRanSmall) { - // Saturated, because that is what the encode does and this has to reproduce it exactly. - // - // The encode writes LinearToSrgb(SoftKnee(frame / paperwhite)), and LinearToSrgb saturates - // before it does anything else -- so the proxy the Classic path reads back is always inside - // the unit cube. SoftKnee alone is not: it rolls luminance off above 0.75 but leaves a - // channel free to sit above 1, and with a measured white point of 0.1 in a dark red interior - // the red channel of anything lit is far above 1. - // - // CubeScaleResidual then computes (1 - P) / d to find how far the residual may travel before - // leaving the cube. With P above 1 that numerator is negative, alpha comes out negative, - // saturate(alpha) is zero, and the entire edit is discarded -- leaving the knee'd proxy as - // the answer, which is darker than the frame everywhere the knee fired. That is the darker, - // redder 50% picture: not the working scale, and not the residual idea, just a proxy that was - // never clamped the way the one it stands in for is. - float3 fullProxy = saturate(SoftKnee(original)); + // The frame's own proxy at full resolution is the encode this pass already wrote; on the + // resolve t3 is that texture. Read the way `original` is read: sampled for side by side, + // loaded otherwise. Decoded like `proxy` and `model` above. Not saturated again: the encode + // went through LinearToSrgb, which saturates first, so this is already inside the unit + // cube, and a passthrough frame must come back exactly as it was stored. + const float4 encodeSample = gCompareMode == 1 ? gMotion.SampleLevel(gLinear, cmpUv, 0) + : gMotion.Load(int3(id.xy, 0)); + const float3 fullProxy = gPassthrough != 0 ? encodeSample.rgb : SrgbToLinear(encodeSample.rgb); + proxy = fullProxy; proxyLuma = dot(proxy, kLuma); - - // At the same rate there is no residual to carry: the model's own picture is already at the - // frame's resolution, and P + (m - p) collapses to m exactly. model = CubeScaleResidual(fullProxy, fullProxy + edit); } @@ -696,10 +655,12 @@ void CSMain(uint3 id : SV_DispatchThreadID) float modelLuma = dot(model, kLuma); float3 upgraded; - if (modelLuma <= 1e-5) + // Two reasons to hand the frame back untouched. The model returned an empty frame for this + // pixel (emptyModel, measured before the residual). Or the composed model picture is black + // here, which the residual can legitimately produce on a dark pixel; the highlight branch below + // divides by modelLuma and needs it non-zero. + if (emptyModel || modelLuma <= 1e-5) { - // The model can return an empty frame for an input it cannot read. Rescaling that collapses - // the picture to black, so the frame is handed back untouched instead. upgraded = original; } else @@ -805,7 +766,7 @@ void CSMain(uint3 id : SV_DispatchThreadID) // A hairline so the two sides are never mistaken for one picture. if (onDivider) - result = float3(gWhitePoint, gWhitePoint, gWhitePoint); + result = float3(PaperWhite(), PaperWhite(), PaperWhite()); gTarget[id.xy] = float4(max(result, float3(0.0, 0.0, 0.0)), originalSample.a); } diff --git a/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp b/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp index 7f2476579..e57e537b9 100644 --- a/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp +++ b/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp @@ -114,7 +114,14 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame auto mask = Dx11WithDx12::ResourceMask::Color | Dx11WithDx12::ResourceMask::Mv | Dx11WithDx12::ResourceMask::Depth | Dx11WithDx12::ResourceMask::Output; - if (!AutoExposure()) + ID3D11Resource* peekedExposure = nullptr; + if (InParameters != nullptr) + { + if (InParameters->Get(NVSDK_NGX_Parameter_ExposureTexture, &peekedExposure) != NVSDK_NGX_Result_Success) + InParameters->Get(NVSDK_NGX_Parameter_ExposureTexture, (void**) &peekedExposure); + } + + if (peekedExposure != nullptr || !AutoExposure()) mask |= Dx11WithDx12::ResourceMask::Exposure; else LOG_DEBUG("AutoExposure enabled!"); @@ -134,7 +141,7 @@ bool IFeature_Dx11wDx12::ProcessDx11Textures(const NVSDK_NGX_Parameter* InParame if (!prepareResult.Success) { - if (prepareResult.MissingExposure) + if (prepareResult.MissingExposure && !AutoExposure()) { LOG_WARN("AutoExposure disabled but ExposureTexture does not exist, enabling auto exposure and changing " "backend"); @@ -459,6 +466,11 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG LOG_DEBUG("Dispatch!!"); dx12EvalResult = dx12Feature->Evaluate(cmdList, InParameters); + const bool nrExposureThisFrame = + dx11Exp.Dx12Resource != nullptr && dx11Exp.LastPreparedFrame == cache.frameId; + InParameters->Set(NVSDK_NGX_Parameter_ExposureTexture, + nrExposureThisFrame ? (void*) dx11Exp.Dx12Resource : nullptr); + // DLSS 5 Neural Rendering rides the bridge: at this moment the block carries the D3D12 copies // of every input, the list is still recording, and the model's edit lands on the D3D12 output // before it is copied back to the game's D3D11 texture. This one call is what makes the pass diff --git a/OptiScaler/upscalers/IFeature_VkwDx12.cpp b/OptiScaler/upscalers/IFeature_VkwDx12.cpp index edf392702..46f6a21ff 100644 --- a/OptiScaler/upscalers/IFeature_VkwDx12.cpp +++ b/OptiScaler/upscalers/IFeature_VkwDx12.cpp @@ -1063,22 +1063,25 @@ bool IFeature_VkwDx12::ProcessVulkanTextures(VkCommandBuffer InCmdList, const NV DepthCopy = std::make_unique("DepthCopy", VulkanDevice, VulkanPhysicalDevice); } + vkExp.VkSourceImage = VK_NULL_HANDLE; + vkExp.VkSourceImageView = VK_NULL_HANDLE; + NVSDK_NGX_Resource_VK* paramExposure = nullptr; - if (!AutoExposure()) + const NVSDK_NGX_Result exposureGet = + InParameters->Get(NVSDK_NGX_Parameter_ExposureTexture, (void**) ¶mExposure); + if (exposureGet == NVSDK_NGX_Result_Success && !NvVkResourceNotValid(paramExposure)) { - if (InParameters->Get(NVSDK_NGX_Parameter_ExposureTexture, (void**) ¶mExposure) != - NVSDK_NGX_Result_Success && - !NvVkResourceNotValid(paramExposure)) + if (ExpCopy == nullptr || ExpCopy.get() == nullptr) + ExpCopy = std::make_unique("ExpCopy", VulkanDevice, VulkanPhysicalDevice); + } + else + { + paramExposure = nullptr; + if (!AutoExposure()) { LOG_WARN("AutoExposure disabled but ExposureTexture is not exist, it may cause problems!!"); State::Instance().autoExposure = true; State::Instance().changeBackend[Handle()->Id] = true; - paramExposure = nullptr; - } - else - { - if (ExpCopy == nullptr || ExpCopy.get() == nullptr) - ExpCopy = std::make_unique("ExpCopy", VulkanDevice, VulkanPhysicalDevice); } } @@ -1208,7 +1211,8 @@ bool IFeature_VkwDx12::ProcessVulkanTextures(VkCommandBuffer InCmdList, const NV if (!CopyTextureFromVkToDx12(InCmdList, paramExposure, &vkExp, ExpCopy.get(), true, false)) { LOG_ERROR("Failed to copy exposure texture!"); - return false; + if (!AutoExposure()) + return false; } else { @@ -2158,6 +2162,11 @@ bool IFeature_VkwDx12::Evaluate(VkCommandBuffer InCmdBuffer, NVSDK_NGX_Parameter LOG_DEBUG("Dispatch!!"); dx12EvalResult = dx12Feature->Evaluate(cmdList, InParameters); + const bool nrExposureThisFrame = + vkExp.Dx12Resource != nullptr && vkExp.VkSourceImage != VK_NULL_HANDLE; + InParameters->Set(NVSDK_NGX_Parameter_ExposureTexture, + nrExposureThisFrame ? (void*) vkExp.Dx12Resource : nullptr); + // The parameter block still holds the D3D12 resources written above -- the Vulkan handles are // not put back until after this -- so the pass reads exactly what the upscaler just wrote. static bool reportedNrOffer = false; From 351bc6c057614b563ecd471e779ee19346510813 Mon Sep 17 00:00:00 2001 From: 4223641 Date: Thu, 3 Sep 2026 22:54:37 +0800 Subject: [PATCH 2/4] Rebuild DLSS-NR precompiled shaders after rebase compose. Co-authored-by: Cursor --- .../dlssnr/precompile/DlssNr_Shader.cso | Bin 16068 -> 16516 bytes .../shaders/dlssnr/precompile/DlssNr_Shader.h | 2325 +++++----- .../dlssnr/precompile/DlssNr_Shader_Vk.h | 4079 +++++++++-------- .../dlssnr/precompile/DlssNr_Shader_Vk.spv | Bin 24628 -> 26656 bytes 4 files changed, 3305 insertions(+), 3099 deletions(-) diff --git a/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader.cso b/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader.cso index 876104540d23b8deff338ff48706a0075433c818..ddf834f62bb7e1a49622a4570d148481f231699b 100644 GIT binary patch literal 16516 zcmb`NZH!&VS;uG3+G~5A7uRi_)P>~MI7)Ha#9o3OHSzB8+Ho8ut}U;#aZ03Q9dFiK zIbQ2}O)6C-*DeVPgg3P+F9ig}7?D(wDpIv57za!F0757YAW#tq^+U>seklGBA*u@g zzd7?iJNN88wm&e^xpU4u|L1j{d1lVNch8Z@-S_|8&U^NL{lrt>`S;#CALxDmkA^}B zzgUK_QvJQUemJ6!RUxd?^`8?V9NP2X-ZwM`?z}$MsDD6LSUI&joDJa>(GKm|wvDk{ zb#-)oT-Rn@H|U~0DZb(Aw(nEJQSLF_6uQTT6}tXcO`Wc z4s_?|=1CQZNI-qBR^!%mz zr!#$@z;HEuATIZ%XUEz7lNtwO+^H7amo>gR!?nr#s&M3h<+b7dSh#f=u1)VZh5OKT z;NBLFT)dXvcZB-?7jARHsS9oL{!2L42=>w1a6c066QUc}rgxRr z;MVKFeMmUg__gBlG2!mZaBcS8BOL4A^4f3@2v=sfHa{K~ZqIe#ri9y<;o9^*CETMK zu1)VL;SOfFHhEtV?(lWs;`$B8o?qx56Z(Uy1FZDHZA^1K_xSPo#o2=k^CuU>vnLj2 z7Q<_=Q8BN^cRcdVA6q;g=Jw6b&mC7SINY5%dHUJe?$ly;_T(It-3upFQkI_g%pN^6 zH$6Z5yh_T<=MK%Ns)V_NGpA249`7!knG?tUpPzbW=EUrg`tFG^_t2U7W3!J}y5hYR z?p}EA)J%7la)qw=Fm>w0ylhENpIKOVu6~$$e&*DYm0>Pg6V-*e$4<{aH1pi-Qh__z z%^o~lf%nfp(_J{d@a$se|u;XO7KwJ7}Fhp_^@6@7@+3o_grh)F~SM zfyVRHz6X!IqeMTb%6{)nA$)dq7tZ*!-EjCVytV@ceto`;QOkssGvXo>I9UQ^h{6o_*}AvJF4Dz$j-|jm63t!d~It z`{j;CtEP3iYJH+@O#Nu;Zx1VmeLpTyAJ)~8SmQ@~dP;4mtoH7lr=w#)uD1}T*<{~! z>HnmT5SK&f?SAaT!TO7`DNX);eqF3H+hym`4^?uM)}yA|m!eD{b*u%hscYb{n@jpeu>s$(l~$C?V%Z%J=g$0 z&3LWVdaZOt(-su=Dqq2Rt>}C)TGNUOQM&_UdcLk{wIM$Um` zgC3)9dh|e_PV(|G)*w1)=l}d|i&8hKA%{!4 zW1R(qTzc!O_^Mc#<~_o8&|?Q!({fp+iCotz)y-I^;iZOJC+pAoNAG;xB^!?>+J&{1 zJ(C*4XV#Ntd^8&)ZqOJr@AOC|UvY^w9J+BuxxD@wC)jn>Y3ff=>Z8%fp|0%V{8p6u zXf)C58c81F`&LcQrj)bT$(p1mccD|K!7{cv!=t!dJ{jB(U8TQ8l&6QnVvZJxeRogZXVlDY>1t{{t47&V(54w z1D}Y8<8@BYU`Ey32YT;o&^9L@xyM%M)jrcRJb3(S3!S95!Fa}3^{qrWua3*Mp(;q`}RF8b0?_{n55HNt)urM{=X zd;k5uL}H$!Z^qFVr9PBfOIO@qZ^RaSm%NyVj)P-G4=4KY*L$+ZtRu;Yb8>#bo&er^ z!gON~5GkI4qfFUDD@uK6k4;y65Z}nD5e=Fey6akHntN!IgZVB&Lnks_Yu%IU=%cZ2te4*F3DVaRZDe(YElQ16 z4f(W7^1J?C61$>|UMCXqQLV0L=%VGm*$(SvPY4h&hy{=;vekvB@!*J z2cH3r)7skU3y|d*M_-g7Ec|JA!k32Xnvmn#cz^eIK2rLE*EJ#M^}6;s*Y>^l`W-uc z!K?X=ei%nzl=^5{*C|$UU0bH(LJuc#!xpdW#8aQS{Y;ECw^2W_Z`NSOJO}ywUeUZF zBcES#VcGnqnh@tw*`jk|JexMpAF$Gz=fW6IvBuN;uq^LuNi&(*;x+R(`P&S)Mlis zDD{!rptGFiSQq=fb(w~ZgU)ifA6gH~_>h@mzKmv>>lJ#GC|(=Pb@V z%kl{sMcJO8j=6Dd`DvWz-+L;(RMh)wj&pwIW7yJ`pE=I?$^UGKq3vtSPvhu|QXeh( znPM8}$1pGo*Z_qGKPLoE-`+!T!QXgx--iafB!;_qgK*Hk7q;6 zq;`#}rqSy?E`IMs&igy7qSQm9fg2MKxT4fY9WU+`^F;IS?bZR_`%6y4H)ys4+N8#? zabts~-!$v*V7wOyR__IRSBSp}S|`2Ewefc~?u$|%wY}AQk@d>2_wrrl&;@-|p#v5~uG5BpCcwwS_&}_ft#qR^5 zUr4`UdoI}bupJuq(l}4No9ys8iSG;WpB^kVbW`%h`LraXH-WAA!MhlHBQ)}xoSRPn z15hNQ3~# zzgdxg*g?$k4>~cX?}!&#es1*o!arR#FE$~A9=z)`WBVHKLded~6kwWXiu~+LtmBzi z=UJb9;qjcpK4?zCZck?u?q3?N^3?SfJD4MAMcH2aeI78bt@ay7kG!_ppW|#xJ_c`F z?ay(p{oW63Ut8@rjvgKTwISB=_+1Hd6qmRjEpt%q#}?QA#1r=e$CREJv#wZsw2@vX z_T=wK`i`6R2fx<@bL+V(%H?b4_U!w1 zS0|U&xO2oka`^3yb%D)ZD?_CoB*V6Np1>DnwCS6&DP9_)hQxCab0J^r+DFWC9jqmE zfU^$r-s=(?y1edk%=*kmYz5;Uxw#)3MZ-trfiW$veT|{tH1u0Ge7XKMjP=qRgN{u} z-xl?Q^n-`irXQO1=dyDf!9c^-9K(B`{TNNODt=3OO|Zmn<}VJ#cRuFYKUz@UbDGgy4FxHm_N&H z;%`&zEl)MKt~JPk_b%l@Mvv_JO<<&(Y?bVI{zAU@EADfhuf6)}xGx0wT{_40#d<*P zU!TS1(AmewU*7V_#NVHM@lE78Hl7pL)tm15@x)ChKl;{vZ@j11f_@xxV%!_|{^J90 zKC^G)>6HgAHF4;r_7vsvImSol0`iP&&T)=oj*V;1v2oWk$H?#;yS`YiNPX>Ua}4j* z<~YfYbBuh?v31fHWeA>MdJWZcoa5T&7>w76Zxl6HD*lsTn6tPG}X9Omy@je466TUfh874MPm)P zw(x%{nm%J~v5%Y`{^kdNJN{=sdNRhAJb@3~CVl3(SGNAk#s7Kx+(qQ%IQ-3VpWpqh zi_aeTlbG+u_03PJbFOy-X=$C>UTi8#<-+2*@|AB)y>;}9CkC!N<39Q1*DmcDxwHK2 zU%&oWV(nYU*lXO>3opMp{=s`M-S(yL_SHhgx2}b*d+1lZUf{FpdoSFXCzH4wF@$tOK2(s{}DHDC<1I_Esn0z1KnE0ERoWHrp=lt-YzsXNtSikiqf61+y zW|N-|1+sX-n&9O%)H;p7Yr8U_QJyyiSP^SkCJ{Pa{+Jt^bK~9u%d3 zjmCF1e6K=Ha1Ihz&eWc7X!t?%Sd4x4pD1Xamn{j~%>8BjTC1AZ_@5|f(`P$$bzP1R z`pADrvoF?Rd-DA77&iKMH1pX;W7v00^Vk;I&$}lwiHYBXvBxrbe;G?O<{!*@kq3?E z?_$=)JPwPeCv%7gdY(2)KXY$d{yviXA_y&hr^-#9ixqG0l6)OKBzd$E z*+whMDi3sF`_v9_)&maY_+g$2Zqo zIbLhMA&3H5yJ}D%K)+NKs1S;bQDYRTYEX-Uaj>XV5JKfkAU-4%p#W0GstTUp zne)t^JA1Ef@dqCgN18b^=Y8If^Pcy8=gi#Q{l}*E?YnQwfq(qz=R2Qz^(Qxd?VqNW zhC&E`Fd4##`UiAu8C9=izmEGfeq{gqrvF()a6hHfnEHoxgprwj;amt;L_4y7#}3Bc zp`)eaJ{?-TBjV zx;nV9G{0~E8Zx z|GOH8WZc&W;J&GG*4MZ}^1dwqYkMQyupD}Oh8v{!PT{`mCU9GYBgSr|ce`-ko#6)Q z-6dQr!ws76Bf@P-ICWu=ydM^h*vCHFAl#1#_XDCEH%M<+xa~KATM~}ky^&we3HMNj z8)V-v2}eF#-XPrPg)1}Mpm}^jxcxVQ`;u@6GTb1&F@M5|=N1-E2z`h0kWA~}KBY-? zpExrn^pSvdWd5XV2~7#j7DK?|b~tVEy1|(?3)B zV^(ZelfK!ZBIteuEOy^DQel*@YmK>hYc)2yrosq63Jv_Xe!iu1)o$&>124FHLRg0m z{C(F*5sI?%6Erv50cJX3vBS182HrIEHEC~+R~Xgdk*58OHSw}*te(sI+n4tyV`hgc zISPew(><4>Odxei*Lcj_0EgWi(l>5DU@NUCSNlTpR?W@xwhXaGU(gq2wSV!mS3}{! zG&lTNlsYw<=p!5C)3_%oE277k*EZ2;+hyKi*|S;qj1!;knbWXhmN;hYXu_d0k8Nnk z&SjvNv8lwnOFhl{&ZlwgfFF6*2iE$S1Nxjd#=j@5zU4QU;omRlTY5gv;Dch|MVVMB(KL$_5-$R-PU@p*vMRL>s|7(eUD$5 zt9j7NHFJiCd2*k4#@^IDJVmKfPg`zZP_AA}b!=LB$Na%gO5crY3%I2;M3&-?%D zWED&QU3HRJ;`l#WC&wlR=GaONV}9f_ZF{Pj)G&|Jle>8hW2|4zL=H691oEAl;IYlR zW{jFZ17}_60B0Mf64o_^-Zr2IIoRO(20zXC|A{&(^=tF_P)C_7^P-NrCSoi050yF+ z&Awr7jCmfZUe?b%%fol@Alvd>s~H1_9OQA2oI_ciLpKdQ&}Wmpe2l#cI%wzs2c9O` z18b&ii}f8`QR>vw`qy_Lu5&H%yS_H}j`%dM?>AEuk#{xO&3=$}G3~**W-e2Sj^Akb zjfO5?YhG)}Dg4T_gn1&D`=ZpT(efC)X1=ty^uG2&pJyHN>jR<#~;1paj$GVo@f`>SN2S4j5(8ImhrA^48K8R%)GOsm3;Xn z?scIXSCp&wsm2L*Q~O!=aYd<9qY*=kvPYi~Ls9C~Xrk9Ok~n1U+qFEKQ_Nx~IZ03K zLT7Iama#1v&h(*D1huWAZ59sOkU=xwyQOz3$uJ-L#Piu0Yh=7Gd-jRwuJkOoe=wsV zi#5&o#xgx|?cp^You+%t_Tw9Tw^n%exA@ThLI!ifANCivgBe#39b4$}7uV3Xq&aeJ zy7l2N;t+o!gJwSbW%=f_zpxM6@t5(sjJ~uU`rKcZ1t0!0UtUv~JMZr7kFm)$MVGOD zGA6$0Q*5vd?8@f>&T}NcO+z>SVXj~%R5Q?Nf1`Ue(eOXx%8Q;Dfgjn-{VsK0Gv?dm z8P*s!(&s$7jqkJS>-tud+|`Z!blbIwQP)4$L)RZ@9&`PnhFq22oJMVEjwv>7WJi>- zRX&(V@?4|+-i#gi5Pvvk@gZ}TZ|dh%QEH&k^0g;EqKs7Uz4jM0b-z>i-3i>JT*|xC zCOuE`XR36@XBw*VXBziKsZ*onHeB-@8#XAu;`=GA%#l`O5sEVXhF9n}vh6G4;@Pzw(tg-l-UC(gYjJ#$xWS=v;1-gBd-_t#mC< z+AijMKG|lSwiSEcOm=+hw#xody=P*xK2^s2Mj!s6|LoeTXC1+~rg81sWF0xp`lubq z!GGA4&&3$8&#-Xl0b|>8n;3%zCdckbv%ua4y78eeIl);Tq7oFt{co_sEmG!F}p!@>?g))(A3Z!^E#&)18u55-xX-+ zgpd5mdtx1ZH1fu>>76T(UQV>pu?kz18m$`gX;(Dw`W*_pqKxHMBr->}_?#yf&_&DV zW;?9ceJ7F%CPJbuRc_mX69 zc(7IFlH&~?=OOzR;?r^d$&dZo9v>pnVm^33Vw`eoj}JhWXB>S|hOqFPi)|kos%t`y z8^rr7zx>Y92fVHcIj{5DdoJ7e)~j3h_<&dI8|PsheNpOE=QO#!lGn*sF|RGtexV18 z->}7bop|c~pYQRp);8+L_sts2nAad*-)mY|WaR5hEUa4JR1@M_Dq6H>iTfn(i&CdX zYwl4ZU$#d^2eD}Vjz#v-aZU-_O3z|)XIqMKu8BK(z706Hw8rs0F6v74@M8M?44JYy zz8^p*ml(UyrxrqYEzEsIEq|pLujtIhT|HtulL%6a~{x( zRLe7tz9|Cm_Bjve;gw(FJdC3+N}UGeLh@D2g+abS zAGSCb>|g8fJwA3W;QMASFlO6ZS&eSS7crWD=W={m4|4j&7xe4J7j(y$F6(a(vMJ8r zxr+SOb?gI|+c(jw_AbpB3*p!It{h&6`q>?8QZpu8y9ULleQw;K_%zPz?>bE{^Xpoj z<7`VlR+NL|GsihT$0eIJwta)*(>VH~)M-F`CZERjvCO7#(1$IK&%~o=`-&}Kh+)T) zG4%aniSg^j5_HGXy;-dI{gN6-t)z(__Z#qd-{3ut-VNd&k9sz(I!EjmrB01z+zOp% zTJ>B5YF_?Uf&CZFI_TlcX|CPd64o?qga+O;{RR}jQ)#Gv7I5unf%c#Ads(C>dD<(D z+m51yVtcFJvNf;x&WB!&EuT}5FHCPG-!j(Rr(&b|BR%PMJt0r+d$8k)?zwAd-G*#T z_slQG8rSe!e&UbzL9>0*TYv8ul`QP=TJYSn4;%|TdwHJG>Su4t7h;sgJN|SQR`h6|={I@#cx*y?pn2~3 z_jY0nKSOtHu@>C7()veQnyYgMyLHsO=CKUdV0g7oHLmi*|L$)Tn;ZVvrF-V9`n2}V zMDw?aS^bRY(x)>s}#U>rx}C^5wcwl6E-1DHbC_}is^MxPsp`j?B zXTREd@*(Z3VxC(^Z+%*sbG`?|PUP@S-@d|sVC*y7;%6iHqKr2Ewrq-rhVW_Jf23zr zZA()Jdl7VivkrWYe$&v!dUD^yupaQ^8!+4(>v_PpQ8eaZjA_^p4gIEBKeC`%KiEMS z>qnO{*1_1e>*$9zNI$e2=?BwKzw^O9p&u%BQuAH{+w!<(j*iz2g6lTcSa4oD)A{BM zrWx1hDazGx4IZp(C32A453BuF{cRPSf9tFF?i|-ViD$o?am_P`m`5k_Fc_Q2_st2< zdN5884}O`-XpEtQoT3)wH2Cl@7`6D^;yROA$F}`#y5&Yr$t9+9n&*Q~`@}YyMl71P zG4b0TW2mY40NJja_O1QxJpJOWe?EEl!FBC*zjGwMPkAlD;V3R!owPK?KMv0^<2EZ^n%rEoZ|+qG5YL7u8Z>eYljbw8?<(}Wx3DZGUh?*p|Sqh z_F3(bkmdeS#rs5}c~2@o*R{(v(=~${^K!z^>Ng=|dEccP7r&#UXEyyNbTRw;jN{@X zzFk}Ro(tA-%ym)fq<5e{{Kg+me&O36s^i#s;dvPM()Pc;{O?~qe;F>~#JH(sqj4YI z_vOn^ANq|t-obf&n1f@?y=mCwF?z7Jm+PVo;nLFi@})1%ym9+*H&lQ`_Cm(vOC|5s=i4|}>H;EN~`|`8L`HHV|8M^Ih$iR*mv#I8K-)tK# z!#!BFxHnAxsB5`-B{%M4UHAOE96ijksm^oa+P*NqZD#+qA^F13O6E$O>bZK0`M~FM zC=v!-byV*Gxh&?>l!-p#hIu*fjA=f{;csGc{%sArbAD+3`0=^*TW^~0^Y>;n>otvi zOFlR3uV}sVHeW+FzO45syJXvNAKwrw18i$Mk5W9;`PBTKUSjKSnyOEA+^~M+fPy1_ zdvL7LyJoqb<#V-ge$migAw2r)f8E@M4eClT)_IRD02a1WF zXAEmiY$R;VDXxvp~9AG{-i4=r@h;Um4~Wa)d^X(uz{2M)S8K z$&B_xCSPKo?Bkl;p~{k?mhY$U4K&(SfBWq%fINj fU&mG*8+5!~$Dn3D)4xv_n{?dcf&W6!{~Z4(QeLkR diff --git a/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader.h b/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader.h index e59d3163d..32a707585 100644 --- a/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader.h +++ b/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader.h @@ -1,229 +1,267 @@ #pragma once inline static const unsigned char DlssNr_cso[] = { - 0x44, 0x58, 0x42, 0x43, 0x43, 0x28, 0x24, 0x48, 0xe4, 0x7d, 0x7f, 0x65, - 0x92, 0xae, 0x7a, 0x1f, 0xc8, 0xe7, 0x42, 0x74, 0x01, 0x00, 0x00, 0x00, - 0xc4, 0x3e, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, - 0x24, 0x06, 0x00, 0x00, 0x34, 0x06, 0x00, 0x00, 0x44, 0x06, 0x00, 0x00, - 0x28, 0x3e, 0x00, 0x00, 0x52, 0x44, 0x45, 0x46, 0xe8, 0x05, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x7c, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x44, 0x58, 0x42, 0x43, 0x3b, 0x5b, 0x3d, 0x2f, 0x46, 0xac, 0x6c, 0x5f, + 0xd1, 0xde, 0x80, 0xd0, 0x11, 0x80, 0xe7, 0xa1, 0x01, 0x00, 0x00, 0x00, + 0x84, 0x40, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, + 0xf0, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x10, 0x07, 0x00, 0x00, + 0xe8, 0x3f, 0x00, 0x00, 0x52, 0x44, 0x45, 0x46, 0xb4, 0x06, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xa4, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x05, 0x53, 0x43, 0x00, 0x81, 0x00, 0x00, - 0xbf, 0x05, 0x00, 0x00, 0x52, 0x44, 0x31, 0x31, 0x3c, 0x00, 0x00, 0x00, + 0x8c, 0x06, 0x00, 0x00, 0x52, 0x44, 0x31, 0x31, 0x3c, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3c, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x5c, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x0d, 0x00, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x6c, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, - 0x53, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x73, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x5d, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x7d, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x0d, 0x00, 0x00, 0x00, 0x65, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, - 0x6d, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x73, 0x01, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x8f, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x97, 0x01, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x9d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x00, - 0x67, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x67, 0x4d, 0x6f, 0x64, - 0x65, 0x6c, 0x00, 0x67, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, - 0x00, 0x67, 0x4d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x67, 0x54, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x00, 0x67, 0x4b, 0x65, 0x65, 0x70, 0x00, 0x50, - 0x61, 0x72, 0x61, 0x6d, 0x73, 0x00, 0xab, 0xab, 0x73, 0x01, 0x00, 0x00, - 0x13, 0x00, 0x00, 0x00, 0x94, 0x01, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x04, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x98, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x67, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x00, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x00, 0x67, + 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x00, 0x67, 0x4d, 0x6f, + 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x67, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x75, + 0x72, 0x65, 0x00, 0x67, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0x67, + 0x4b, 0x65, 0x65, 0x70, 0x00, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x00, + 0x9d, 0x01, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0xbc, 0x01, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2c, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x5c, 0x05, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x94, 0x05, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xbc, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x9b, 0x05, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0xf4, 0x04, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x98, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa3, 0x05, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x04, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x98, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x05, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x05, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc5, 0x05, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0x15, 0x05, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xd0, 0x05, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x25, 0x05, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x98, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xda, 0x05, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x05, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe7, 0x05, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0x3a, 0x05, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x98, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf1, 0x05, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x47, 0x05, 0x00, 0x00, - 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x05, 0x00, 0x00, + 0x2c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x51, 0x05, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x07, 0x06, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0x5b, 0x05, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x67, 0x05, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x98, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x21, 0x06, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x74, 0x05, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x98, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2f, 0x06, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0x81, 0x05, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3c, 0x06, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x05, 0x00, 0x00, - 0x3c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x49, 0x06, 0x00, 0x00, + 0x44, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x9c, 0x05, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x98, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x53, 0x06, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0xa9, 0x05, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x98, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x5f, 0x06, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xb3, 0x05, 0x00, 0x00, - 0x48, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xd0, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x00, 0x64, 0x77, 0x6f, 0x72, 0x64, 0x00, - 0x00, 0x00, 0x13, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7d, 0x06, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x00, 0x64, 0x77, + 0x6f, 0x72, 0x64, 0x00, 0x00, 0x00, 0x13, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x92, 0x04, 0x00, 0x00, - 0x67, 0x57, 0x68, 0x69, 0x74, 0x65, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x00, - 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x00, 0xab, 0xab, 0x00, 0x00, 0x03, 0x00, - 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x32, 0x05, 0x00, 0x00, 0x67, 0x57, 0x68, 0x69, 0x74, 0x65, 0x50, 0x6f, + 0x69, 0x6e, 0x74, 0x00, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x00, 0xab, 0xab, + 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xc8, 0x04, 0x00, 0x00, 0x67, 0x57, 0x69, 0x64, - 0x74, 0x68, 0x00, 0x67, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x67, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, - 0x6e, 0x67, 0x74, 0x68, 0x00, 0x67, 0x43, 0x6f, 0x6c, 0x6f, 0x75, 0x72, - 0x53, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x00, 0x67, 0x44, 0x65, - 0x62, 0x75, 0x67, 0x56, 0x69, 0x65, 0x77, 0x00, 0x67, 0x4d, 0x61, 0x78, - 0x52, 0x61, 0x74, 0x69, 0x6f, 0x00, 0x67, 0x50, 0x61, 0x73, 0x73, 0x74, - 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x67, 0x4d, 0x76, 0x53, 0x63, - 0x61, 0x6c, 0x65, 0x58, 0x00, 0x67, 0x4d, 0x76, 0x53, 0x63, 0x61, 0x6c, - 0x65, 0x59, 0x00, 0x67, 0x47, 0x75, 0x69, 0x64, 0x65, 0x57, 0x69, 0x64, - 0x74, 0x68, 0x00, 0x67, 0x47, 0x75, 0x69, 0x64, 0x65, 0x48, 0x65, 0x69, - 0x67, 0x68, 0x74, 0x00, 0x67, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, - 0x4d, 0x6f, 0x64, 0x65, 0x00, 0x67, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, - 0x65, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x00, 0x67, 0x43, 0x6f, 0x6d, 0x70, - 0x61, 0x72, 0x65, 0x5a, 0x6f, 0x6f, 0x6d, 0x00, 0x67, 0x43, 0x6f, 0x6d, - 0x70, 0x61, 0x72, 0x65, 0x53, 0x77, 0x61, 0x70, 0x00, 0x67, 0x54, 0x72, - 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x00, 0x67, 0x44, 0x65, 0x62, 0x75, - 0x67, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x4d, 0x69, 0x63, 0x72, 0x6f, - 0x73, 0x6f, 0x66, 0x74, 0x20, 0x28, 0x52, 0x29, 0x20, 0x48, 0x4c, 0x53, - 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x6d, - 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x31, 0x30, 0x2e, 0x31, 0x00, 0xab, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x05, 0x00, 0x00, + 0x67, 0x57, 0x69, 0x64, 0x74, 0x68, 0x00, 0x67, 0x48, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x00, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x53, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x00, 0x67, 0x43, 0x6f, + 0x6c, 0x6f, 0x75, 0x72, 0x53, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74, 0x68, + 0x00, 0x67, 0x44, 0x65, 0x62, 0x75, 0x67, 0x56, 0x69, 0x65, 0x77, 0x00, + 0x67, 0x4d, 0x61, 0x78, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x00, 0x67, 0x50, + 0x61, 0x73, 0x73, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x67, + 0x4d, 0x76, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x58, 0x00, 0x67, 0x4d, 0x76, + 0x53, 0x63, 0x61, 0x6c, 0x65, 0x59, 0x00, 0x67, 0x47, 0x75, 0x69, 0x64, + 0x65, 0x57, 0x69, 0x64, 0x74, 0x68, 0x00, 0x67, 0x47, 0x75, 0x69, 0x64, + 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x67, 0x43, 0x6f, 0x6d, + 0x70, 0x61, 0x72, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x00, 0x67, 0x43, 0x6f, + 0x6d, 0x70, 0x61, 0x72, 0x65, 0x53, 0x70, 0x6c, 0x69, 0x74, 0x00, 0x67, + 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x5a, 0x6f, 0x6f, 0x6d, 0x00, + 0x67, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x53, 0x77, 0x61, 0x70, + 0x00, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x00, 0x67, + 0x44, 0x65, 0x62, 0x75, 0x67, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x67, + 0x55, 0x73, 0x65, 0x47, 0x61, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x6f, 0x73, + 0x75, 0x72, 0x65, 0x00, 0x67, 0x50, 0x72, 0x65, 0x45, 0x78, 0x70, 0x6f, + 0x73, 0x75, 0x72, 0x65, 0x00, 0x67, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x75, + 0x72, 0x65, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x4d, 0x69, 0x63, 0x72, + 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x28, 0x52, 0x29, 0x20, 0x48, 0x4c, + 0x53, 0x4c, 0x20, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, + 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x20, 0x31, 0x30, 0x2e, 0x31, 0x00, 0x49, 0x53, 0x47, 0x4e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4f, 0x53, 0x47, 0x4e, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x53, 0x48, 0x45, 0x58, - 0xdc, 0x37, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, 0xf7, 0x0d, 0x00, 0x00, + 0xd0, 0x38, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, 0x34, 0x0e, 0x00, 0x00, 0x6a, 0x08, 0x00, 0x01, 0x59, 0x00, 0x00, 0x04, 0x46, 0x8e, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x03, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x03, 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x18, 0x00, 0x04, 0x00, 0x70, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x58, 0x18, 0x00, 0x04, 0x00, 0x70, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x58, 0x18, 0x00, 0x04, 0x00, 0x70, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x58, 0x18, 0x00, 0x04, 0x00, 0x70, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, - 0x9c, 0x18, 0x00, 0x04, 0x00, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x58, 0x18, 0x00, 0x04, 0x00, 0x70, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x9c, 0x18, 0x00, 0x04, 0x00, 0xe0, 0x11, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x02, - 0x32, 0x00, 0x02, 0x00, 0x68, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x00, 0x00, - 0x9b, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, 0xe6, 0x8a, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x07, + 0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, 0x9c, 0x18, 0x00, 0x04, + 0x00, 0xe0, 0x11, 0x00, 0x01, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00, + 0x5f, 0x00, 0x00, 0x02, 0x32, 0x00, 0x02, 0x00, 0x68, 0x00, 0x00, 0x02, + 0x0d, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x07, + 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, + 0xe6, 0x8a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, + 0x20, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x09, + 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x08, - 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x3d, 0x10, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x04, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x56, 0x01, 0x02, 0x00, 0x56, 0x00, 0x00, 0x05, - 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x16, 0x05, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x06, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf6, 0x8b, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, - 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x09, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x16, 0x05, 0x02, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x56, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x05, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1c, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x08, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf6, 0x0b, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x01, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x8c, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x7b, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x08, 0x62, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x0a, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xe6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x0a, + 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x09, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x3d, 0x10, 0x00, 0x89, + 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0x32, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x04, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x01, 0x02, 0x00, + 0x56, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x16, 0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x56, 0x00, 0x00, 0x06, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xf6, 0x8b, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x09, 0x32, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x16, 0x05, 0x02, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0a, - 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0xe6, 0x0a, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x05, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xf6, 0x0b, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x56, 0x01, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x0a, + 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x53, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xa6, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x07, + 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x08, 0x32, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x12, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x03, - 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x36, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x42, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x54, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, + 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x04, 0x03, 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, @@ -234,1111 +272,1110 @@ inline static const unsigned char DlssNr_cso[] = { 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, - 0x36, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x16, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x08, 0xe2, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x08, - 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x09, 0x32, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, - 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x8c, - 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0x12, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x7b, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, - 0x62, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x0a, 0xf2, 0xe0, 0x11, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x09, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, - 0x15, 0x00, 0x00, 0x01, 0x3d, 0x10, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x04, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x56, 0x01, 0x02, 0x00, 0x56, 0x00, 0x00, 0x05, - 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x16, 0x05, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x06, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf6, 0x8b, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, - 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x09, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x16, 0x05, 0x02, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x56, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x05, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1c, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x08, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf6, 0x0b, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x01, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, + 0x22, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x16, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x16, 0x00, 0x00, 0x01, 0x4f, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x05, + 0x22, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x08, 0xe2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x0a, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0xa4, 0x00, 0x00, 0x06, + 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, + 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, + 0x15, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3d, 0x10, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x8e, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1f, 0x00, 0x04, 0x03, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x04, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x02, 0x00, 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0xf2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x56, 0x00, 0x00, 0x04, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x02, 0x00, + 0x56, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x56, 0x00, 0x00, 0x06, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0xe6, 0x8a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x09, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x02, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xe6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0a, + 0x56, 0x00, 0x00, 0x05, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0xa6, 0x0e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xa6, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0x32, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x05, + 0x62, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0xa6, 0x0b, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1b, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x05, + 0x62, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x56, 0x06, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, - 0x32, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x42, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x03, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x36, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x22, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x01, 0x22, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x03, - 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, - 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, - 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, - 0x36, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x22, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, - 0x4f, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, - 0xe2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, - 0x20, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, - 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x10, 0x00, 0x89, - 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0x32, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, - 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x8e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, - 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x04, - 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, - 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, - 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0xf2, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, - 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, - 0x15, 0x00, 0x00, 0x01, 0x56, 0x00, 0x00, 0x04, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x02, 0x00, 0x56, 0x00, 0x00, 0x05, - 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x06, - 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xe6, 0x8a, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x09, - 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x04, 0x02, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x05, - 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0xa6, 0x0e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, - 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xa6, 0x0e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x32, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x05, 0x62, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0xa6, 0x0b, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x42, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0xe6, 0x0a, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x05, - 0x32, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x05, 0x62, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x56, 0x06, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, - 0xc2, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x36, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x01, - 0x22, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x03, 0x2a, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x03, + 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x05, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x00, 0x05, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x33, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, - 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x01, 0x22, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x03, - 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x33, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, - 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x08, 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, + 0x82, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x01, 0x22, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, - 0x36, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x05, + 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, + 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x46, 0x0e, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x16, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x38, 0x00, 0x00, 0x07, - 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x05, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1b, 0x00, 0x00, 0x05, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x0a, + 0x82, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x16, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, + 0x38, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0xc2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x05, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x05, 0xc2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xa6, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x0a, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x08, - 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, + 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, + 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0x82, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, + 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, + 0x46, 0x0e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, + 0x15, 0x00, 0x00, 0x01, 0x1f, 0x00, 0x00, 0x04, 0x0a, 0x80, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x04, + 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, + 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, + 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0xf2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, + 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1f, 0x00, 0x04, 0x04, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, - 0x1f, 0x00, 0x00, 0x04, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x04, 0x32, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, 0x36, 0x00, 0x00, 0x08, - 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, + 0x34, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x17, 0xb7, 0xd1, 0x38, 0x1f, 0x00, 0x04, 0x04, + 0x3a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x8c, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0xf2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x16, 0x7e, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x24, 0x74, 0x49, 0x01, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x34, 0x00, 0x00, 0x0b, 0xc2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x56, 0x81, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, - 0xf2, 0xe0, 0x11, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x04, - 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x08, - 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x17, 0xb7, 0xd1, 0x38, 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, - 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, - 0x31, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3f, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0xbf, 0x38, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x3b, 0xaa, 0xb8, 0xc0, - 0x19, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x32, 0x00, 0x00, 0x09, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3e, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x3f, 0x0e, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0xe2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x96, 0x07, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x17, 0xb7, 0xd1, 0x38, 0x38, 0x00, 0x00, 0x07, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x0e, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x15, 0x00, 0x00, 0x01, 0x0e, 0x00, 0x00, 0x07, + 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, + 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3f, + 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, + 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0xbf, + 0x38, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x3b, 0xaa, 0xb8, 0xc0, 0x19, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x08, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x32, 0x00, 0x00, 0x09, + 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3e, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3f, 0x0e, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0xe2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0xf6, 0x0f, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x37, 0x20, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x06, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x52, 0xb8, 0x4e, 0x41, - 0x52, 0xb8, 0x4e, 0x41, 0x52, 0xb8, 0x4e, 0x41, 0x00, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x96, 0x07, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0xf6, 0x0f, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, + 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x37, 0x20, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x80, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x77, 0xcc, 0x2b, 0x32, 0x77, 0xcc, 0x2b, 0x32, 0x77, 0xcc, 0x2b, 0x32, - 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x52, 0xb8, 0x4e, 0x41, 0x52, 0xb8, 0x4e, 0x41, 0x52, 0xb8, 0x4e, 0x41, + 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x77, 0xcc, 0x2b, 0x32, 0x77, 0xcc, 0x2b, 0x32, + 0x77, 0xcc, 0x2b, 0x32, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x05, + 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x55, 0x55, 0xd5, 0x3e, 0x55, 0x55, 0xd5, 0x3e, 0x55, 0x55, 0xd5, 0x3e, - 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x55, 0x55, 0xd5, 0x3e, 0x55, 0x55, 0xd5, 0x3e, + 0x55, 0x55, 0xd5, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, + 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0f, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x0f, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x3d, 0x0a, 0x87, 0x3f, 0x3d, 0x0a, 0x87, 0x3f, 0x3d, 0x0a, 0x87, 0x3f, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0xbd, - 0xae, 0x47, 0x61, 0xbd, 0xae, 0x47, 0x61, 0xbd, 0x00, 0x00, 0x00, 0x00, - 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x1c, 0x2e, 0x4d, 0x3b, 0x1c, 0x2e, 0x4d, 0x3b, 0x1c, 0x2e, 0x4d, 0x3b, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0d, - 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x52, 0xb8, 0x4e, 0x41, 0x52, 0xb8, 0x4e, 0x41, 0x52, 0xb8, 0x4e, 0x41, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x56, 0x00, 0x00, 0x04, - 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, - 0x00, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x06, 0xc2, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xa6, 0x8e, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x62, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xa6, 0x0b, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, - 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x3d, 0x0a, 0x87, 0x3f, 0x3d, 0x0a, 0x87, 0x3f, + 0x3d, 0x0a, 0x87, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0xae, 0x47, 0x61, 0xbd, 0xae, 0x47, 0x61, 0xbd, 0xae, 0x47, 0x61, 0xbd, + 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x1c, 0x2e, 0x4d, 0x3b, 0x1c, 0x2e, 0x4d, 0x3b, + 0x1c, 0x2e, 0x4d, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x32, 0x00, 0x00, 0x0d, 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x52, 0xb8, 0x4e, 0x41, 0x52, 0xb8, 0x4e, 0x41, + 0x52, 0xb8, 0x4e, 0x41, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, + 0x56, 0x00, 0x00, 0x04, 0x32, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x06, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x8e, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, + 0x62, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0b, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, + 0x00, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, - 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, - 0xa2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x08, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, - 0x0e, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, - 0x00, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0a, 0xa2, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x06, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xbf, 0x0e, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x3f, 0x37, 0x00, 0x00, 0x09, 0x52, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x01, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x56, 0x06, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x8d, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x86, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x20, 0x00, 0x05, - 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, - 0x91, 0x83, 0x9e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, - 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, 0x00, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, - 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x08, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x37, 0x00, 0x00, 0x09, + 0x52, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x01, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x56, 0x06, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x8d, + 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x86, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x20, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, + 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, + 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, - 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, + 0x6f, 0xa7, 0x72, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x05, + 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0d, - 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x06, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x8d, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0xf2, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x86, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x04, - 0x32, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x00, 0x02, 0x00, - 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, + 0x02, 0x40, 0x00, 0x00, 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, + 0x9a, 0x99, 0x19, 0x40, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, + 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, + 0xe6, 0xae, 0x25, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x32, 0x00, 0x00, 0x0d, 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, + 0x91, 0x83, 0x9e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x06, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x8d, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, 0xf2, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x46, 0x7e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, - 0xf2, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, - 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x86, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x7e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x60, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x04, 0x32, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x02, 0x00, 0x36, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0xf2, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x0f, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0xf2, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x08, 0x42, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x1a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x17, 0xb7, 0xd1, 0x38, 0x1f, 0x00, 0x04, 0x04, + 0x3a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x8c, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x16, 0x7e, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x24, 0x74, 0x49, 0x01, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x34, 0x00, 0x00, 0x0b, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x56, 0x81, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x17, 0xb7, 0xd1, 0x38, 0x38, 0x00, 0x00, 0x07, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x0e, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x12, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x05, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x08, + 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0xa6, 0x8a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x36, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, + 0x46, 0x0e, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x8d, 0xc2, 0x00, 0x00, 0x80, - 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x86, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x20, 0x00, 0x05, - 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, + 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, 0x00, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0d, - 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa6, 0x8a, 0x20, 0x00, + 0x1f, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0xa6, 0x8a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x82, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, - 0x00, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, - 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x08, + 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x32, 0x20, 0x00, 0x0f, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x32, 0x20, 0x00, 0x0f, 0x72, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x41, 0x00, 0x00, 0xa0, 0x41, 0x00, 0x00, 0xa0, 0x41, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, + 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, 0x00, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x1d, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0d, - 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0xa6, 0x8a, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0xa6, 0x8a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x82, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x82, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, - 0x27, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, + 0x27, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x31, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x12, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x07, - 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x3c, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x08, - 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, + 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x08, + 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x05, 0x42, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x2a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x08, 0x22, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x80, 0x81, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x20, 0x00, 0x00, 0x08, 0x12, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x0a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x08, 0x22, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x80, 0x81, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x08, 0x42, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x08, - 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, - 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, + 0x22, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x80, 0x20, 0x80, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x08, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x80, - 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x80, + 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x17, 0xb7, 0xd1, 0x38, - 0x37, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x3a, 0x00, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, - 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, - 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0xd2, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, + 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x56, 0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, + 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0xac, 0xc5, 0x27, 0x37, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x10, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, - 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x32, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x08, 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xe6, 0x8a, 0x20, 0x00, + 0x27, 0x00, 0x00, 0x08, 0x32, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x46, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0xe6, 0x8a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x20, 0x00, 0x00, 0x08, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1f, 0x00, 0x04, 0x03, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x31, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3f, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x40, 0xbf, 0x38, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x3b, 0xaa, 0xb8, 0xc0, - 0x19, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x32, 0x00, 0x00, 0x09, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3e, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x3f, 0x0e, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0xe2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x56, 0x05, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x96, 0x07, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x37, 0x20, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x06, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, - 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, - 0x1f, 0x00, 0x00, 0x04, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, - 0xbd, 0x37, 0x86, 0x35, 0xbd, 0x37, 0x86, 0x35, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, - 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xbd, 0x37, 0x86, 0xb5, 0xbd, 0x37, 0x86, 0xb5, 0xbd, 0x37, 0x86, 0xb5, - 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, - 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, 0x82, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, 0x82, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x0a, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0xf6, 0x0f, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x12, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x01, - 0x12, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, - 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x01, - 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x1f, 0x00, 0x04, 0x03, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x00, 0x8d, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x86, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x89, 0xc2, 0x00, 0x00, 0x80, + 0x43, 0x55, 0x15, 0x00, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x46, 0x0e, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x36, 0x20, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, 0xae, 0x47, 0x61, 0x3d, + 0xae, 0x47, 0x61, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x6f, 0xa7, 0x72, 0x3f, + 0x6f, 0xa7, 0x72, 0x3f, 0x6f, 0xa7, 0x72, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x2f, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x9a, 0x99, 0x19, 0x40, + 0x9a, 0x99, 0x19, 0x40, 0x9a, 0x99, 0x19, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xe6, 0xae, 0x25, 0x3d, + 0xe6, 0xae, 0x25, 0x3d, 0xe6, 0xae, 0x25, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0d, 0x72, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, + 0x91, 0x83, 0x9e, 0x3d, 0x91, 0x83, 0x9e, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, + 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x0a, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x80, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0xac, 0xc5, 0x27, 0x37, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, - 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x04, 0x0a, 0x80, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0xbd, 0x37, 0x86, 0x35, 0xbd, 0x37, 0x86, 0x35, 0xbd, 0x37, 0x86, 0x35, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0b, 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, + 0x72, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0xb5, 0xbd, 0x37, 0x86, 0xb5, + 0xbd, 0x37, 0x86, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x08, + 0x72, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, + 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, + 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x33, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x15, 0x00, 0x00, 0x01, 0x12, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x0a, + 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, + 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x15, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, + 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0xac, 0xc5, 0x27, 0x37, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x03, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, + 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, + 0x0e, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0xbd, 0x37, 0x86, 0x35, 0x0e, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, - 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x12, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xb1, 0x0e, 0xd3, 0x3e, + 0x17, 0x4d, 0x09, 0x3f, 0x09, 0xb9, 0x52, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, + 0x22, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x3b, 0xfd, 0x58, 0x3e, 0x53, 0x42, 0x2e, 0x3f, 0xf0, 0xf2, 0xdb, 0x3d, + 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xec, 0xd7, 0xb4, 0x3d, 0x74, 0x3d, 0x90, 0x3e, + 0x49, 0x46, 0x21, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x08, 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x0e, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x05, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x06, 0x72, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x81, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0x3e, + 0xab, 0xaa, 0xaa, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, + 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, + 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x52, 0x81, 0x57, 0x3e, 0x89, 0x2a, 0x4b, 0x3f, 0xce, 0x6e, 0x85, 0xbb, + 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x0e, 0x2f, 0xfd, 0x3f, 0x0e, 0x6e, 0x1b, 0xc0, + 0x38, 0xb4, 0xe6, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xb4, 0x34, 0xd4, 0x3c, + 0xbb, 0x63, 0x48, 0x3f, 0x60, 0x05, 0x4f, 0xbf, 0x00, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, + 0x12, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xb1, 0x0e, 0xd3, 0x3e, 0x17, 0x4d, 0x09, 0x3f, 0x09, 0xb9, 0x52, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x3b, 0xfd, 0x58, 0x3e, 0x53, 0x42, 0x2e, 0x3f, 0xf0, 0xf2, 0xdb, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xec, 0xd7, 0xb4, 0x3d, + 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xec, 0xd7, 0xb4, 0x3d, 0x74, 0x3d, 0x90, 0x3e, 0x49, 0x46, 0x21, 0x3f, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x06, - 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x81, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0x3e, + 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x08, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x05, 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x06, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, + 0x81, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0x3e, 0x00, 0x00, 0x00, 0x00, - 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x52, 0x81, 0x57, 0x3e, 0x89, 0x2a, 0x4b, 0x3f, - 0xce, 0x6e, 0x85, 0xbb, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x0e, 0x2f, 0xfd, 0x3f, - 0x0e, 0x6e, 0x1b, 0xc0, 0x38, 0xb4, 0xe6, 0x3e, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x22, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xb4, 0x34, 0xd4, 0x3c, 0xbb, 0x63, 0x48, 0x3f, 0x60, 0x05, 0x4f, 0xbf, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0xb1, 0x0e, 0xd3, 0x3e, 0x17, 0x4d, 0x09, 0x3f, - 0x09, 0xb9, 0x52, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x3b, 0xfd, 0x58, 0x3e, - 0x53, 0x42, 0x2e, 0x3f, 0xf0, 0xf2, 0xdb, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x0e, 0x2f, 0xfd, 0x3f, 0x0e, 0x6e, 0x1b, 0xc0, + 0x38, 0xb4, 0xe6, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xb4, 0x34, 0xd4, 0x3c, + 0xbb, 0x63, 0x48, 0x3f, 0x60, 0x05, 0x4f, 0xbf, 0x00, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x0f, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x96, 0x05, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x96, 0x05, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x05, 0x52, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0xac, 0xc5, 0x27, 0x37, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x32, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x96, 0x05, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0xa6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, + 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x04, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0x62, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0b, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0xc9, 0xec, 0xca, 0x3e, 0xa9, 0xfb, 0x5c, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x42, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xec, 0xd7, 0xb4, 0x3d, 0x74, 0x3d, 0x90, 0x3e, 0x49, 0x46, 0x21, 0x3f, + 0x22, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x8c, 0x30, 0xd8, 0xbd, 0xfa, 0xc5, 0x82, 0xbd, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x08, - 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, - 0x41, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x2f, 0x00, 0x00, 0x06, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x80, 0x81, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0x3e, 0xab, 0xaa, 0xaa, 0x3e, - 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x0e, 0x2f, 0xfd, 0x3f, - 0x0e, 0x6e, 0x1b, 0xc0, 0x38, 0xb4, 0xe6, 0x3e, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, + 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x7b, 0x43, 0xb7, 0xbd, + 0x66, 0x4f, 0xa5, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0xab, 0x74, 0x82, 0x40, 0x8c, 0xb1, 0x53, 0xc0, + 0x62, 0x83, 0x6c, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x2d, 0x5c, 0xa2, 0xbf, + 0x44, 0x06, 0x27, 0x40, 0x6a, 0xc1, 0xae, 0xbe, 0x00, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xb4, 0x34, 0xd4, 0x3c, 0xbb, 0x63, 0x48, 0x3f, 0x60, 0x05, 0x4f, 0xbf, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0f, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x96, 0x05, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x96, 0x05, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x05, - 0x32, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0xac, 0xc5, 0x27, 0x37, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, - 0xa2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x56, 0x09, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x56, 0x05, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x07, 0x62, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x56, 0x07, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0x62, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x56, 0x06, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0xc9, 0xec, 0xca, 0x3e, 0xa9, 0xfb, 0x5c, 0x3e, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x0a, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x8c, 0x30, 0xd8, 0xbd, - 0xfa, 0xc5, 0x82, 0xbd, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x7b, 0x43, 0xb7, 0xbd, 0x66, 0x4f, 0xa5, 0xbf, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x72, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xab, 0x74, 0x82, 0x40, - 0x8c, 0xb1, 0x53, 0xc0, 0x62, 0x83, 0x6c, 0x3e, 0x00, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, - 0x22, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x2d, 0x5c, 0xa2, 0xbf, 0x44, 0x06, 0x27, 0x40, 0x6a, 0xc1, 0xae, 0xbe, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x53, 0x7f, 0x89, 0xbb, 0x3e, 0x13, 0x34, 0xbf, - 0x1e, 0x93, 0xda, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, - 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x0a, - 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, - 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, - 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x77, 0xcc, 0x2b, 0x32, 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x31, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xf6, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, - 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xf6, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0b, - 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0x77, 0xcc, 0x2b, 0x32, 0x77, 0xcc, 0x2b, 0x32, 0x77, 0xcc, 0x2b, 0x32, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x81, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x37, 0x00, 0x00, 0x0c, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x33, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, - 0x27, 0x00, 0x00, 0x07, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x7f, 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x31, 0x00, 0x00, 0x07, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x10, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x53, 0x7f, 0x89, 0xbb, 0x3e, 0x13, 0x34, 0xbf, 0x1e, 0x93, 0xda, 0x3f, + 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x0a, 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, + 0x00, 0x00, 0x80, 0x7f, 0x27, 0x00, 0x00, 0x0a, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, 0x01, 0x00, 0x00, 0x07, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x77, 0xcc, 0x2b, 0x32, + 0x3a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x0b, 0x72, 0x00, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x77, 0xcc, 0x2b, 0x32, + 0x77, 0xcc, 0x2b, 0x32, 0x77, 0xcc, 0x2b, 0x32, 0x00, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x80, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x07, 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf6, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x0c, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x33, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x33, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x27, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, + 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x31, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x10, 0x00, 0x00, 0x0a, + 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, + 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0xf6, 0x0f, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, + 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf6, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, + 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, - 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x0a, + 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, - 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0xd2, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x06, 0x09, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x56, 0x05, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x36, 0x20, 0x00, 0x06, 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x06, 0x09, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x36, 0x20, 0x00, 0x06, + 0x82, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x86, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x01, 0x1f, 0x00, 0x04, 0x03, + 0x2a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x04, 0x04, + 0x3a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x8c, 0xc2, 0x00, 0x00, 0x80, 0x43, 0x55, 0x15, 0x00, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x7e, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x24, 0x74, 0x49, 0x01, 0x00, 0x00, 0x07, + 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x09, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, + 0x34, 0x00, 0x00, 0x0b, 0xc2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x56, 0x81, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x17, 0xb7, 0xd1, 0x38, 0x38, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x0e, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x17, 0xb7, 0xd1, 0x38, 0x36, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x05, 0x32, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xa6, 0x0a, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x15, 0x00, 0x00, 0x01, 0x12, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x0a, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, + 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x0e, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x08, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x08, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x09, - 0x72, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x01, - 0x10, 0x00, 0x00, 0x0a, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, - 0xd0, 0xb3, 0x59, 0x3e, 0x59, 0x17, 0x37, 0x3f, 0x98, 0xdd, 0x93, 0x3d, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x07, - 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, - 0x0e, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, 0x00, 0x00, 0x00, 0x08, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0xbf, 0x34, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x2f, 0x00, 0x00, 0x05, 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x19, 0x00, 0x00, 0x05, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x08, - 0x22, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3a, 0x80, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, - 0x00, 0x00, 0x80, 0x3f, 0x0e, 0x00, 0x00, 0x0a, 0x42, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, - 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x07, - 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x33, 0x00, 0x00, 0x07, 0x12, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, 0x82, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x80, 0x41, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x56, 0x85, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, - 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x0c, 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xa6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0xbf, 0x34, 0x00, 0x00, 0x0a, + 0x52, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x02, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x56, 0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x85, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x10, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x2f, 0x00, 0x00, 0x05, 0x82, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x05, 0x42, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x08, 0x82, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3a, 0x80, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x0e, 0x00, 0x00, 0x0a, + 0x22, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f, + 0x00, 0x00, 0x80, 0x3f, 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x07, 0x42, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x07, + 0x12, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0xa6, 0x0a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0a, 0xd2, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x80, + 0x41, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x0a, + 0xd2, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x85, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x09, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x07, 0x72, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x56, 0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x03, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x09, 0x72, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x46, 0x02, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x0c, 0x72, 0x00, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xf6, 0x0f, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x06, - 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x02, 0x00, - 0x46, 0x0e, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, - 0x53, 0x54, 0x41, 0x54, 0x94, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, - 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0xe9, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x12, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x0a, + 0x72, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x46, 0x02, 0x10, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x06, 0xf2, 0xe0, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x05, 0x02, 0x00, 0x46, 0x0e, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x3e, 0x00, 0x00, 0x01, 0x53, 0x54, 0x41, 0x54, 0x94, 0x00, 0x00, 0x00, + 0xf6, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, + 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00 - + 0x0b, 0x00, 0x00, 0x00 }; diff --git a/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader_Vk.h b/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader_Vk.h index 71a6aef68..2278143e2 100644 --- a/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader_Vk.h +++ b/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader_Vk.h @@ -2,7 +2,7 @@ inline static const unsigned char dlssnr_spv[] = { 0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, - 0x28, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, + 0x76, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x32, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x4c, 0x53, 0x4c, 0x2e, 0x73, 0x74, 0x64, 0x2e, 0x34, 0x35, 0x30, 0x00, 0x00, 0x00, 0x00, @@ -53,26 +53,35 @@ inline static const unsigned char dlssnr_spv[] = { 0x04, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x04, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x67, 0x44, 0x65, 0x62, - 0x75, 0x67, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x05, 0x00, 0x04, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x00, 0x00, - 0x05, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0x74, 0x79, 0x70, 0x65, - 0x2e, 0x32, 0x64, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x00, 0x00, 0x00, - 0x05, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x67, 0x53, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x00, 0x05, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x67, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, - 0x6c, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, - 0x67, 0x4d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x05, 0x00, 0x06, 0x00, - 0x0b, 0x00, 0x00, 0x00, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x32, 0x64, 0x2e, + 0x75, 0x67, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x06, 0x00, 0x08, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x67, 0x55, 0x73, 0x65, + 0x47, 0x61, 0x6d, 0x65, 0x45, 0x78, 0x70, 0x6f, 0x73, 0x75, 0x72, 0x65, + 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x67, 0x50, 0x72, 0x65, 0x45, 0x78, 0x70, 0x6f, + 0x73, 0x75, 0x72, 0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x07, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x67, 0x45, 0x78, 0x70, + 0x6f, 0x73, 0x75, 0x72, 0x65, 0x53, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x00, + 0x05, 0x00, 0x04, 0x00, 0x05, 0x00, 0x00, 0x00, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x74, 0x79, 0x70, 0x65, 0x2e, 0x32, 0x64, 0x2e, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x67, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x00, 0x05, 0x00, 0x04, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x67, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x00, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x09, 0x00, 0x00, 0x00, 0x67, 0x4f, 0x72, 0x69, + 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x67, 0x4d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x00, + 0x05, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x67, 0x45, 0x78, 0x70, + 0x6f, 0x73, 0x75, 0x72, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x32, 0x64, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x67, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, - 0x05, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x67, 0x4b, 0x65, 0x65, - 0x70, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x0e, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x67, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, + 0x05, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x67, 0x4b, 0x65, 0x65, + 0x70, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, - 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x67, 0x4c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x05, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x43, 0x53, 0x4d, 0x61, 0x69, 0x6e, 0x00, 0x00, - 0x05, 0x00, 0x07, 0x00, 0x10, 0x00, 0x00, 0x00, 0x74, 0x79, 0x70, 0x65, + 0x05, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x64, 0x2e, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, @@ -89,1969 +98,2129 @@ inline static const unsigned char dlssnr_spv[] = { 0x03, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x47, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, + 0x47, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, - 0x0f, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x1c, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x28, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x0b, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x0e, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x40, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, - 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, - 0x59, 0x17, 0x37, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x14, 0x00, 0x00, 0x00, 0x98, 0xdd, 0x93, 0x3d, 0x17, 0x00, 0x04, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x12, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, - 0x15, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x14, 0x00, 0x02, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x29, 0x00, 0x03, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x17, 0x00, 0x04, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x2b, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x03, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x2a, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x2e, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x17, 0xb7, 0xd1, 0x38, - 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, - 0x0d, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x31, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, - 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, - 0x0f, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, - 0x12, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x41, 0x2c, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x47, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x0a, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x13, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0x54, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x13, 0x00, 0x00, 0x00, 0xd0, 0xb3, 0x59, 0x3e, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x59, 0x17, 0x37, 0x3f, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, + 0x98, 0xdd, 0x93, 0x3d, 0x17, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x02, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x29, 0x00, 0x03, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x1c, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x3f, 0x17, 0x00, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x05, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x1f, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x03, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x80, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x2b, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x33, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, + 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xa0, 0x41, 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x38, 0x00, 0x00, 0x00, 0xac, 0xc5, 0x27, 0x37, 0x2b, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, + 0xbd, 0x37, 0x86, 0x35, 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x3b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, + 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, + 0x07, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x3e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x17, 0xb7, 0xd1, 0x38, + 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x13, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x41, 0x00, 0x00, 0x00, 0x00, 0x24, 0x74, 0x49, 0x2b, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3f, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, + 0x52, 0xb8, 0x4e, 0x41, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x47, 0x00, 0x00, 0x00, 0x77, 0xcc, 0x2b, 0x32, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, + 0x47, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x55, 0x55, 0xd5, 0x3e, + 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, + 0x49, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, + 0x3d, 0x0a, 0x87, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x4c, 0x00, 0x00, 0x00, 0xae, 0x47, 0x61, 0x3d, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, + 0x4c, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x1c, 0x2e, 0x4d, 0x3b, + 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, + 0x4e, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x9a, 0x99, 0x19, 0x40, 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x52, 0x00, 0x00, 0x00, 0xe6, 0xae, 0x25, 0x3d, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, + 0x52, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0xbd, 0x37, 0x86, 0xb5, + 0x2c, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, - 0xac, 0xc5, 0x27, 0x37, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x3c, 0x00, 0x00, 0x00, 0xbd, 0x37, 0x86, 0x35, 0x2b, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x3b, 0x2b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x3f, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3e, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x52, 0xb8, 0x4e, 0x41, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, - 0x77, 0xcc, 0x2b, 0x32, 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x45, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, - 0x44, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x00, 0x00, 0x55, 0x55, 0xd5, 0x3e, 0x2c, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, - 0x46, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x3d, 0x0a, 0x87, 0x3f, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, - 0xae, 0x47, 0x61, 0x3d, 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x4a, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, - 0x49, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x4b, 0x00, 0x00, 0x00, 0x1c, 0x2e, 0x4d, 0x3b, 0x2c, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, - 0x4b, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x9a, 0x99, 0x19, 0x40, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, - 0x4d, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, - 0xe6, 0xae, 0x25, 0x3d, 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x00, 0x00, 0xbd, 0x37, 0x86, 0xb5, 0x2c, 0x00, 0x05, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x53, 0x00, 0x00, 0x00, 0xb1, 0x0e, 0xd3, 0x3e, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x17, 0x4d, 0x09, 0x3f, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, - 0x09, 0xb9, 0x52, 0x3d, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x56, 0x00, 0x00, 0x00, 0x3b, 0xfd, 0x58, 0x3e, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x53, 0x42, 0x2e, 0x3f, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, - 0xf0, 0xf2, 0xdb, 0x3d, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x59, 0x00, 0x00, 0x00, 0xec, 0xd7, 0xb4, 0x3d, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x74, 0x3d, 0x90, 0x3e, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, - 0x49, 0x46, 0x21, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x5c, 0x00, 0x00, 0x00, 0x52, 0x81, 0x57, 0x3e, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x89, 0x2a, 0x4b, 0x3f, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, - 0xce, 0x6e, 0x85, 0xbb, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x00, 0x00, 0x0e, 0x2f, 0xfd, 0x3f, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x0e, 0x6e, 0x1b, 0xc0, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, - 0x38, 0xb4, 0xe6, 0x3e, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x62, 0x00, 0x00, 0x00, 0xb4, 0x34, 0xd4, 0x3c, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0xbb, 0x63, 0x48, 0x3f, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, - 0x60, 0x05, 0x4f, 0xbf, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x65, 0x00, 0x00, 0x00, 0xc9, 0xec, 0xca, 0x3e, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0xa9, 0xfb, 0x5c, 0x3e, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, - 0x8c, 0x30, 0xd8, 0xbd, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x68, 0x00, 0x00, 0x00, 0xfa, 0xc5, 0x82, 0xbd, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x7b, 0x43, 0xb7, 0xbd, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, - 0x66, 0x4f, 0xa5, 0xbf, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x6b, 0x00, 0x00, 0x00, 0xab, 0x74, 0x82, 0x40, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x8c, 0xb1, 0x53, 0xc0, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, - 0x62, 0x83, 0x6c, 0x3e, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x6e, 0x00, 0x00, 0x00, 0x2d, 0x5c, 0xa2, 0xbf, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x44, 0x06, 0x27, 0x40, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, - 0x6a, 0xc1, 0xae, 0xbe, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x71, 0x00, 0x00, 0x00, 0x53, 0x7f, 0x89, 0xbb, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x3e, 0x13, 0x34, 0xbf, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, - 0x1e, 0x93, 0xda, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x74, 0x00, 0x00, 0x00, 0xec, 0x51, 0x38, 0x3e, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0xab, 0xaa, 0xaa, 0x3e, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, - 0x75, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, - 0x1e, 0x00, 0x15, 0x00, 0x04, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x20, 0x00, 0x04, 0x00, 0x77, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x78, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, - 0x0b, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0xb1, 0x0e, 0xd3, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, + 0x17, 0x4d, 0x09, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x58, 0x00, 0x00, 0x00, 0x09, 0xb9, 0x52, 0x3d, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x3b, 0xfd, 0x58, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, + 0x53, 0x42, 0x2e, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x5b, 0x00, 0x00, 0x00, 0xf0, 0xf2, 0xdb, 0x3d, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0xec, 0xd7, 0xb4, 0x3d, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, + 0x74, 0x3d, 0x90, 0x3e, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x5e, 0x00, 0x00, 0x00, 0x49, 0x46, 0x21, 0x3f, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x52, 0x81, 0x57, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, + 0x89, 0x2a, 0x4b, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x61, 0x00, 0x00, 0x00, 0xce, 0x6e, 0x85, 0xbb, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x0e, 0x2f, 0xfd, 0x3f, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, + 0x0e, 0x6e, 0x1b, 0xc0, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x64, 0x00, 0x00, 0x00, 0x38, 0xb4, 0xe6, 0x3e, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0xb4, 0x34, 0xd4, 0x3c, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, + 0xbb, 0x63, 0x48, 0x3f, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x67, 0x00, 0x00, 0x00, 0x60, 0x05, 0x4f, 0xbf, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0xc9, 0xec, 0xca, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, + 0xa9, 0xfb, 0x5c, 0x3e, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x6a, 0x00, 0x00, 0x00, 0x8c, 0x30, 0xd8, 0xbd, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0xfa, 0xc5, 0x82, 0xbd, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, + 0x7b, 0x43, 0xb7, 0xbd, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x6d, 0x00, 0x00, 0x00, 0x66, 0x4f, 0xa5, 0xbf, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, 0xab, 0x74, 0x82, 0x40, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, + 0x8c, 0xb1, 0x53, 0xc0, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x70, 0x00, 0x00, 0x00, 0x62, 0x83, 0x6c, 0x3e, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x2d, 0x5c, 0xa2, 0xbf, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, + 0x44, 0x06, 0x27, 0x40, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x73, 0x00, 0x00, 0x00, 0x6a, 0xc1, 0xae, 0xbe, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x53, 0x7f, 0x89, 0xbb, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, + 0x3e, 0x13, 0x34, 0xbf, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x76, 0x00, 0x00, 0x00, 0x1e, 0x93, 0xda, 0x3f, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0xec, 0x51, 0x38, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, + 0xab, 0xaa, 0xaa, 0x3e, 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x79, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, + 0x78, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x18, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x7a, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, - 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x02, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, - 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, - 0x17, 0x00, 0x04, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x7c, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, - 0x7d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x7e, 0x00, 0x00, 0x00, - 0x7d, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x7f, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, - 0x80, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x17, 0x00, 0x04, 0x00, 0x81, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x82, 0x00, 0x00, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, - 0x83, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x1b, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x04, 0x00, 0x84, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x77, 0x00, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, - 0x78, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3b, 0x00, 0x04, 0x00, 0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x78, 0x00, 0x00, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, - 0x78, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3b, 0x00, 0x04, 0x00, 0x79, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x79, 0x00, 0x00, 0x00, - 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, - 0x7a, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x3b, 0x00, 0x04, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x05, 0x00, 0x82, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, - 0x53, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, - 0x56, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, - 0x59, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x84, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, - 0x86, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, - 0x5c, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, - 0x62, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x84, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, - 0x8a, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x84, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, - 0x8e, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, - 0x6b, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, - 0x6e, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, - 0x71, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, - 0x2c, 0x00, 0x06, 0x00, 0x84, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, - 0x92, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, - 0xeb, 0x51, 0x38, 0x3e, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x97, 0x00, 0x00, 0x00, 0xf1, 0x51, 0x38, 0x3e, 0x2c, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, - 0x97, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, - 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, - 0x99, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, - 0x6f, 0xa7, 0x72, 0x3f, 0x2c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x9c, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, - 0x9b, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x9d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x2b, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x18, 0xc7, 0xb1, 0x40, - 0x17, 0x00, 0x04, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x7d, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x7b, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfb, 0x00, 0x03, 0x00, 0x29, 0x00, 0x00, 0x00, 0xa3, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xa3, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, - 0xa5, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, - 0xa5, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xa7, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xa7, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, - 0xa8, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa9, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, - 0xa1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, - 0x80, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x1d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xac, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xae, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, - 0xac, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa8, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xa8, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, - 0xa3, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xaf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xae, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, - 0xaf, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xb0, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xaf, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x81, 0x00, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0xb2, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, - 0xb2, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, - 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, - 0xb6, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, - 0xb8, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, - 0xb3, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, - 0x80, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xbb, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, - 0x22, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xbd, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xbc, 0x00, 0x00, 0x00, - 0xbe, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xbe, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, - 0xbf, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x67, 0x00, 0x05, 0x00, - 0x81, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xc1, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, - 0xc0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, - 0xc1, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xc5, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x00, - 0xc5, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x00, - 0x80, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, - 0xa4, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, - 0xc9, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, - 0xb4, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xcc, 0x00, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xce, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xcf, 0x00, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, - 0xce, 0x00, 0x00, 0x00, 0xcf, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, - 0xb7, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xd2, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xd4, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0xd4, 0x00, 0x00, 0x00, - 0xcf, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, + 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x09, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x04, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x02, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x04, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0f, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x7e, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, + 0x7f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, + 0x13, 0x00, 0x02, 0x00, 0x80, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, + 0x81, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x04, 0x00, 0x83, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x84, 0x00, 0x00, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x04, 0x00, 0x86, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x03, 0x00, 0x11, 0x00, 0x00, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x18, 0x00, 0x04, 0x00, 0x87, 0x00, 0x00, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, + 0x7a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x3b, 0x00, 0x04, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x7b, 0x00, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, + 0x7b, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3b, 0x00, 0x04, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x7b, 0x00, 0x00, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, + 0x7c, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3b, 0x00, 0x04, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x7d, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, + 0x7f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x05, 0x00, 0x85, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, + 0x57, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, + 0x5a, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, + 0x5d, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x87, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, + 0x8a, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, + 0x63, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, + 0x66, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x87, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, + 0x8e, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x68, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x6a, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x6c, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x87, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, + 0x92, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, + 0x6f, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, + 0x72, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, + 0x75, 0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x06, 0x00, + 0x87, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, + 0x96, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0xeb, 0x51, 0x38, 0x3e, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, + 0xf1, 0x51, 0x38, 0x3e, 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x9b, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, + 0x77, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x9c, 0x00, 0x00, 0x00, 0x91, 0x83, 0x9e, 0x3d, 0x2c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, + 0x9c, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x6f, 0xa7, 0x72, 0x3f, + 0x2c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, + 0x9e, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, + 0x18, 0xc7, 0xb1, 0x40, 0x2b, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x17, 0x00, 0x04, 0x00, + 0xa2, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x36, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xa3, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x7e, 0x00, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xa6, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xa7, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, + 0xb0, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, + 0xa7, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xab, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xaa, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xac, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, + 0xae, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0xaf, 0x00, 0x00, 0x00, + 0xae, 0x00, 0x00, 0x00, 0xae, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xb0, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0xaf, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xab, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xab, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xb1, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, + 0xb0, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xb1, 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, 0xb2, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xb3, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xa5, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xb2, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x07, 0x00, 0x84, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00, + 0xb5, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x20, 0x00, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xb7, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x83, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xb9, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, + 0xb7, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x20, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x00, + 0xbb, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, + 0xbd, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, + 0xbd, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xbf, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xbf, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x00, + 0xc0, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xc1, 0x00, 0x00, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, + 0xa7, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xc2, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xc4, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xc6, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xc3, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xc3, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xc7, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x00, + 0xc6, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xc7, 0x00, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xc9, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, + 0xca, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xcc, 0x00, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, + 0xcc, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0xce, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, + 0xce, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xcf, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x67, 0x00, 0x05, 0x00, 0x84, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, + 0xcf, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xd2, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, + 0xa7, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xd4, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, + 0xd4, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, - 0x6d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x00, - 0xd6, 0x00, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xd8, 0x00, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, - 0x86, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, - 0xd8, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x29, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, - 0xd7, 0x00, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0x86, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, - 0x24, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xdd, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xdc, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xde, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xde, 0x00, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, - 0xe1, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xe2, 0x00, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, - 0xe3, 0x00, 0x00, 0x00, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xe5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xd7, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, - 0xe5, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, 0xe7, 0x00, 0x00, 0x00, - 0xe1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xe6, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xe9, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xe9, 0x00, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, - 0xdf, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, - 0xeb, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xec, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, - 0xed, 0x00, 0x00, 0x00, 0xeb, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xee, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xef, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xcc, 0x00, 0x00, 0x00, 0xee, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xec, 0x00, 0x00, 0x00, - 0xef, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, 0xf1, 0x00, 0x00, 0x00, - 0xeb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xf0, 0x00, 0x00, 0x00, 0xeb, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xeb, 0x00, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xf3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, - 0xec, 0x00, 0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, - 0xc2, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, - 0x7c, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x00, - 0xf6, 0x00, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0x6d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x00, + 0xd6, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xd8, 0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, + 0xd8, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xda, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, 0xd4, 0x00, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, + 0xda, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, + 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, + 0xd2, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xe0, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xe1, 0x00, 0x00, 0x00, + 0xe0, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, 0xe1, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0xe3, 0x00, 0x00, 0x00, + 0xdd, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0xe3, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, + 0xe4, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, + 0xba, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xe7, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, + 0xd7, 0x00, 0x00, 0x00, 0x86, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xe9, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0xe9, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xeb, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, + 0x86, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0xec, 0x00, 0x00, 0x00, + 0xeb, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xed, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0xec, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xee, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xee, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xef, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xc8, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, + 0xe2, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, + 0xf1, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xf6, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, + 0xf6, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xfc, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xfe, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, - 0xfe, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xed, 0x00, 0x00, 0x00, 0xec, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xe9, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xf1, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xe1, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0xe3, 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, - 0xdd, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xde, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xe7, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0x00, 0x01, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xbd, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x01, 0x01, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x01, 0x01, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, - 0x02, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x03, 0x01, 0x00, 0x00, - 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, - 0xa4, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x04, 0x01, 0x00, 0x00, 0x06, 0x01, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x06, 0x01, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x08, 0x01, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x05, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x05, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x09, 0x01, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, - 0x08, 0x01, 0x00, 0x00, 0x06, 0x01, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x0a, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x09, 0x01, 0x00, 0x00, 0x0b, 0x01, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x0b, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x0d, 0x01, 0x00, 0x00, - 0x0c, 0x01, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x0e, 0x01, 0x00, 0x00, 0x0d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x0f, 0x01, 0x00, 0x00, - 0x0e, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, - 0x10, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, - 0x10, 0x01, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x0f, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x0a, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x11, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x67, 0x00, 0x05, 0x00, 0x81, 0x00, 0x00, 0x00, 0x12, 0x01, 0x00, 0x00, - 0x11, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x13, 0x01, 0x00, 0x00, 0x12, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x14, 0x01, 0x00, 0x00, 0x12, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x15, 0x01, 0x00, 0x00, - 0xa4, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x16, 0x01, 0x00, 0x00, 0x13, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x17, 0x01, 0x00, 0x00, 0x15, 0x01, 0x00, 0x00, - 0x16, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x18, 0x01, 0x00, 0x00, 0x17, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, - 0x6d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x19, 0x01, 0x00, 0x00, - 0x18, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x1a, 0x01, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x01, 0x00, 0x00, - 0x1a, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x1c, 0x01, 0x00, 0x00, 0x1b, 0x01, 0x00, 0x00, 0x16, 0x01, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1d, 0x01, 0x00, 0x00, - 0x1c, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x1d, 0x01, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, - 0xa1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, - 0x14, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x22, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x23, 0x01, 0x00, 0x00, - 0x22, 0x01, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0x23, 0x01, 0x00, 0x00, - 0x80, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, - 0x1f, 0x01, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, - 0x26, 0x01, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, - 0xb7, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x29, 0x01, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x2a, 0x01, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, - 0x19, 0x01, 0x00, 0x00, 0x86, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x2b, 0x01, 0x00, 0x00, 0x2a, 0x01, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2b, 0x01, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x2d, 0x01, 0x00, 0x00, 0x29, 0x01, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, - 0x86, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x2e, 0x01, 0x00, 0x00, - 0x2d, 0x01, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x2f, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x29, 0x00, 0x00, 0x00, 0x2e, 0x01, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x30, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x30, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x31, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, - 0x32, 0x01, 0x00, 0x00, 0x33, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0x0a, 0x01, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00, 0x33, 0x01, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, - 0x24, 0x01, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, 0x37, 0x01, 0x00, 0x00, - 0x33, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x38, 0x01, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, 0x39, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x01, 0x00, 0x00, - 0x38, 0x01, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x3a, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0x39, 0x01, 0x00, 0x00, - 0xf6, 0x00, 0x04, 0x00, 0x3b, 0x01, 0x00, 0x00, 0x33, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x3a, 0x01, 0x00, 0x00, - 0x3c, 0x01, 0x00, 0x00, 0x3b, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x3c, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x3d, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x3d, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, - 0x3c, 0x01, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x32, 0x01, 0x00, 0x00, - 0x31, 0x01, 0x00, 0x00, 0x3c, 0x01, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, - 0x3f, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x41, 0x01, 0x00, 0x00, 0x19, 0x01, 0x00, 0x00, 0x3c, 0x01, 0x00, 0x00, - 0x42, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x43, 0x01, 0x00, 0x00, 0x19, 0x01, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x44, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0x1e, 0x01, 0x00, 0x00, 0x43, 0x01, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x45, 0x01, 0x00, 0x00, 0x41, 0x01, 0x00, 0x00, - 0x44, 0x01, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, 0x46, 0x01, 0x00, 0x00, - 0x3f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x45, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, 0x46, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x3f, 0x01, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x47, 0x01, 0x00, 0x00, 0x13, 0x01, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x48, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, - 0x41, 0x01, 0x00, 0x00, 0x47, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x49, 0x01, 0x00, 0x00, 0x48, 0x01, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x4a, 0x01, 0x00, 0x00, - 0x14, 0x01, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x4b, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0x4a, 0x01, 0x00, 0x00, - 0x7c, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00, - 0x4b, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0x4d, 0x01, 0x00, 0x00, 0x49, 0x01, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, - 0x4e, 0x01, 0x00, 0x00, 0x4d, 0x01, 0x00, 0x00, 0x4d, 0x01, 0x00, 0x00, + 0xf6, 0x00, 0x04, 0x00, 0xf9, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xf8, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xfa, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xfb, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xfb, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, + 0xef, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, + 0xfd, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0xdc, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xb0, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x02, 0x01, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, 0x04, 0x01, 0x00, 0x00, + 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x03, 0x01, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xfd, 0x00, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x06, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x06, 0x01, 0x00, 0x00, + 0x82, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, + 0xd2, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x09, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x26, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, + 0x7c, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, + 0x09, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, + 0x0b, 0x01, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, + 0x0c, 0x01, 0x00, 0x00, 0x0b, 0x01, 0x00, 0x00, 0x0b, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x4f, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, - 0x4f, 0x01, 0x00, 0x00, 0x4e, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x51, 0x01, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x0d, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x0e, 0x01, 0x00, 0x00, + 0x0d, 0x01, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x0f, 0x01, 0x00, 0x00, 0x0e, 0x01, 0x00, 0x00, 0x0e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x52, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x51, 0x01, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x53, 0x01, 0x00, 0x00, 0x52, 0x01, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, - 0x32, 0x01, 0x00, 0x00, 0x53, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x42, 0x01, 0x00, 0x00, 0x41, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x3d, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x46, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x33, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x33, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x37, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, - 0x2f, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x30, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x3b, 0x01, 0x00, 0x00, 0xac, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x54, 0x01, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, - 0x29, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x55, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x54, 0x01, 0x00, 0x00, - 0x56, 0x01, 0x00, 0x00, 0x57, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x56, 0x01, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x58, 0x01, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x59, 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, - 0x58, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x55, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x57, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x55, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x55, 0x01, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5a, 0x01, 0x00, 0x00, - 0x59, 0x01, 0x00, 0x00, 0x56, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x57, 0x01, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, - 0x5b, 0x01, 0x00, 0x00, 0x5a, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x0b, 0x00, 0x00, 0x00, 0x5c, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, - 0x63, 0x00, 0x05, 0x00, 0x5c, 0x01, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, - 0x5b, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x02, 0x01, 0x00, 0x00, - 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x5d, 0x01, 0x00, 0x00, - 0xbb, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x5e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x5d, 0x01, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x5e, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x67, 0x00, 0x05, 0x00, 0x81, 0x00, 0x00, 0x00, 0x61, 0x01, 0x00, 0x00, - 0x60, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x62, 0x01, 0x00, 0x00, 0x61, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x63, 0x01, 0x00, 0x00, 0x61, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, - 0x62, 0x01, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x65, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x64, 0x01, 0x00, 0x00, 0x66, 0x01, 0x00, 0x00, 0x65, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x66, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x67, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, - 0xb6, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x65, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x65, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x68, 0x01, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, - 0x5f, 0x01, 0x00, 0x00, 0x67, 0x01, 0x00, 0x00, 0x66, 0x01, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x69, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x68, 0x01, 0x00, 0x00, 0x6a, 0x01, 0x00, 0x00, - 0x69, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x6a, 0x01, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x6b, 0x01, 0x00, 0x00, - 0xa1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x6c, 0x01, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, - 0x7c, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x6d, 0x01, 0x00, 0x00, - 0x6b, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0x6e, 0x01, 0x00, 0x00, 0x6c, 0x01, 0x00, 0x00, 0x6d, 0x01, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, - 0x6f, 0x01, 0x00, 0x00, 0x6e, 0x01, 0x00, 0x00, 0x6e, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x0f, 0x01, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x11, 0x01, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, + 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, 0x11, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xfb, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x04, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xf1, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, + 0xed, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xee, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xf9, 0x00, 0x00, 0x00, 0xac, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x12, 0x01, 0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x13, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x12, 0x01, 0x00, 0x00, + 0x14, 0x01, 0x00, 0x00, 0x15, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x14, 0x01, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x16, 0x01, 0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x17, 0x01, 0x00, 0x00, 0xef, 0x00, 0x00, 0x00, + 0x16, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x13, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x15, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x13, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x13, 0x01, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, + 0x17, 0x01, 0x00, 0x00, 0x14, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x15, 0x01, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0x19, 0x01, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x1a, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x63, 0x00, 0x05, 0x00, 0x1a, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, + 0x19, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xa5, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xc0, 0x00, 0x00, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x01, 0x00, 0x00, + 0xbe, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x1b, 0x01, 0x00, 0x00, 0x1d, 0x01, 0x00, 0x00, 0x1c, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x1d, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x67, 0x00, 0x05, 0x00, 0x84, 0x00, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, + 0x1e, 0x01, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x21, 0x01, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x22, 0x01, 0x00, 0x00, + 0x20, 0x01, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x23, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x22, 0x01, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0x23, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x24, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, + 0xb9, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x23, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x23, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, + 0x1d, 0x01, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x27, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x26, 0x01, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00, + 0x27, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x28, 0x01, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x29, 0x01, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x2a, 0x01, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, + 0x7c, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x2b, 0x01, 0x00, 0x00, + 0x29, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, + 0x2c, 0x01, 0x00, 0x00, 0x2a, 0x01, 0x00, 0x00, 0x2b, 0x01, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, + 0x2d, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x70, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, - 0x70, 0x01, 0x00, 0x00, 0x6f, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, - 0x72, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, - 0x72, 0x01, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x69, 0x01, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x73, 0x01, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x74, 0x01, 0x00, 0x00, - 0x62, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x75, 0x01, 0x00, 0x00, 0x73, 0x01, 0x00, 0x00, 0x74, 0x01, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x76, 0x01, 0x00, 0x00, - 0x75, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x77, 0x01, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x78, 0x01, 0x00, 0x00, 0x77, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x79, 0x01, 0x00, 0x00, 0x78, 0x01, 0x00, 0x00, - 0x74, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x7a, 0x01, 0x00, 0x00, 0x79, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x7b, 0x01, 0x00, 0x00, - 0xa1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x7c, 0x01, 0x00, 0x00, 0x7b, 0x01, 0x00, 0x00, - 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x7d, 0x01, 0x00, 0x00, - 0x63, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x7e, 0x01, 0x00, 0x00, 0x7c, 0x01, 0x00, 0x00, 0x7d, 0x01, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x7f, 0x01, 0x00, 0x00, - 0x7e, 0x01, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x7b, 0x01, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x81, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, - 0x7d, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x83, 0x01, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, - 0x7a, 0x01, 0x00, 0x00, 0x76, 0x01, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, - 0x7f, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x86, 0x01, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x76, 0x01, 0x00, 0x00, - 0x6e, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, - 0x87, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x89, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x7a, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x8a, 0x01, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x8b, 0x01, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, - 0x1c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x8c, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x7f, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x8d, 0x01, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, - 0x8f, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x91, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x91, 0x01, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x92, 0x01, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x69, 0x01, 0x00, 0x00, 0x93, 0x01, 0x00, 0x00, - 0x94, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x95, 0x01, 0x00, 0x00, 0x8d, 0x01, 0x00, 0x00, 0x69, 0x01, 0x00, 0x00, - 0x96, 0x01, 0x00, 0x00, 0x94, 0x01, 0x00, 0x00, 0xb3, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x97, 0x01, 0x00, 0x00, 0x95, 0x01, 0x00, 0x00, - 0x90, 0x01, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, 0x98, 0x01, 0x00, 0x00, - 0x94, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x97, 0x01, 0x00, 0x00, 0x99, 0x01, 0x00, 0x00, 0x98, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x99, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x9a, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0x9b, 0x01, 0x00, 0x00, - 0x9a, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2d, 0x00, 0x00, 0x00, 0x95, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0x9b, 0x01, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x9d, 0x01, 0x00, 0x00, 0x95, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0x7f, 0x01, 0x00, 0x00, 0x9d, 0x01, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, - 0x9d, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xa0, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xa1, 0x01, 0x00, 0x00, - 0xa0, 0x01, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xa2, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0xa1, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa3, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xa3, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x93, 0x01, 0x00, 0x00, 0x92, 0x01, 0x00, 0x00, 0x99, 0x01, 0x00, 0x00, - 0xa4, 0x01, 0x00, 0x00, 0xa5, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xa6, 0x01, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, - 0x99, 0x01, 0x00, 0x00, 0xa7, 0x01, 0x00, 0x00, 0xa5, 0x01, 0x00, 0x00, - 0xb3, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00, 0x00, - 0xa6, 0x01, 0x00, 0x00, 0x8b, 0x01, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, - 0xa9, 0x01, 0x00, 0x00, 0xa5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xa8, 0x01, 0x00, 0x00, 0xa5, 0x01, 0x00, 0x00, - 0xa9, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa5, 0x01, 0x00, 0x00, - 0x7c, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0xaa, 0x01, 0x00, 0x00, - 0x62, 0x01, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, - 0xab, 0x01, 0x00, 0x00, 0xaa, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x17, 0x00, 0x00, 0x00, 0xac, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0xa6, 0x01, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0xab, 0x01, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xad, 0x01, 0x00, 0x00, 0xa6, 0x01, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xae, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x76, 0x01, 0x00, 0x00, - 0xad, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xaf, 0x01, 0x00, 0x00, 0xad, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x7a, 0x01, 0x00, 0x00, - 0xaf, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0xb1, 0x01, 0x00, 0x00, 0xac, 0x01, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, - 0xb2, 0x01, 0x00, 0x00, 0xb1, 0x01, 0x00, 0x00, 0xb1, 0x01, 0x00, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x2e, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x2f, 0x01, 0x00, 0x00, + 0x2e, 0x01, 0x00, 0x00, 0x2d, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0x30, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, + 0x30, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x2f, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x27, 0x01, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, + 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x32, 0x01, 0x00, 0x00, + 0x20, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x33, 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x32, 0x01, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, + 0x33, 0x01, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x36, 0x01, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x37, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00, + 0x32, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x38, 0x01, 0x00, 0x00, 0x37, 0x01, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x39, 0x01, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x3a, 0x01, 0x00, 0x00, 0x39, 0x01, 0x00, 0x00, + 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3b, 0x01, 0x00, 0x00, + 0x21, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x3c, 0x01, 0x00, 0x00, 0x3a, 0x01, 0x00, 0x00, 0x3b, 0x01, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3d, 0x01, 0x00, 0x00, + 0x3c, 0x01, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00, 0x39, 0x01, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x3f, 0x01, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x00, 0x00, + 0x3b, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x41, 0x01, 0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x42, 0x01, 0x00, 0x00, + 0x38, 0x01, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x43, 0x01, 0x00, 0x00, 0x41, 0x01, 0x00, 0x00, + 0x3d, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x44, 0x01, 0x00, 0x00, 0x42, 0x01, 0x00, 0x00, 0x43, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x45, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, + 0x6e, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x46, 0x01, 0x00, 0x00, + 0x45, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x47, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x38, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x48, 0x01, 0x00, 0x00, 0x47, 0x01, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x49, 0x01, 0x00, 0x00, 0x48, 0x01, 0x00, 0x00, + 0x1d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x4a, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x3d, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x4b, 0x01, 0x00, 0x00, 0x4a, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x41, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x4d, 0x01, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00, + 0x82, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x4e, 0x01, 0x00, 0x00, + 0x4d, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x4f, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x4f, 0x01, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, 0x51, 0x01, 0x00, 0x00, + 0x52, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x53, 0x01, 0x00, 0x00, 0x4b, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x00, + 0x54, 0x01, 0x00, 0x00, 0x52, 0x01, 0x00, 0x00, 0xb3, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x55, 0x01, 0x00, 0x00, 0x53, 0x01, 0x00, 0x00, + 0x4e, 0x01, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, 0x56, 0x01, 0x00, 0x00, + 0x52, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x55, 0x01, 0x00, 0x00, 0x57, 0x01, 0x00, 0x00, 0x56, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x57, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x58, 0x01, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, + 0x82, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x59, 0x01, 0x00, 0x00, + 0x58, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x5a, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x00, 0x53, 0x01, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x59, 0x01, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x5b, 0x01, 0x00, 0x00, 0x53, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x5c, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x3d, 0x01, 0x00, 0x00, 0x5b, 0x01, 0x00, 0x00, + 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x5d, 0x01, 0x00, 0x00, + 0x5b, 0x01, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x5e, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x00, 0x00, 0x41, 0x01, 0x00, 0x00, 0x5d, 0x01, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, + 0x5e, 0x01, 0x00, 0x00, 0x5c, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x5f, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x61, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x61, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x51, 0x01, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, 0x57, 0x01, 0x00, 0x00, + 0x62, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, 0x46, 0x01, 0x00, 0x00, + 0x57, 0x01, 0x00, 0x00, 0x65, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, + 0xb3, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x66, 0x01, 0x00, 0x00, + 0x64, 0x01, 0x00, 0x00, 0x49, 0x01, 0x00, 0x00, 0xf6, 0x00, 0x04, 0x00, + 0x67, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x66, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, + 0x67, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x63, 0x01, 0x00, 0x00, + 0x7c, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x68, 0x01, 0x00, 0x00, + 0x20, 0x01, 0x00, 0x00, 0x82, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x69, 0x01, 0x00, 0x00, 0x68, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x18, 0x00, 0x00, 0x00, 0x6a, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x69, 0x01, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x6b, 0x01, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6c, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, + 0x6b, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x6d, 0x01, 0x00, 0x00, 0x6b, 0x01, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6e, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x38, 0x01, 0x00, 0x00, + 0x6d, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, + 0x6f, 0x01, 0x00, 0x00, 0x6a, 0x01, 0x00, 0x00, 0x5a, 0x01, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, + 0x70, 0x01, 0x00, 0x00, 0x6f, 0x01, 0x00, 0x00, 0x6f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0xb3, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0xb4, 0x01, 0x00, 0x00, - 0xb3, 0x01, 0x00, 0x00, 0xb2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xb5, 0x01, 0x00, 0x00, 0xb4, 0x01, 0x00, 0x00, 0xb4, 0x01, 0x00, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x72, 0x01, 0x00, 0x00, + 0x71, 0x01, 0x00, 0x00, 0x70, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x73, 0x01, 0x00, 0x00, 0x72, 0x01, 0x00, 0x00, 0x72, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb6, 0x01, 0x00, 0x00, - 0xb0, 0x01, 0x00, 0x00, 0xae, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xb7, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0xb6, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, - 0xb7, 0x01, 0x00, 0x00, 0xa2, 0x01, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xb9, 0x01, 0x00, 0x00, 0xb5, 0x01, 0x00, 0x00, - 0xb8, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xa4, 0x01, 0x00, 0x00, 0x93, 0x01, 0x00, 0x00, 0xb9, 0x01, 0x00, 0x00, - 0x80, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0xa7, 0x01, 0x00, 0x00, - 0xa6, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xa3, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa9, 0x01, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x94, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x94, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x96, 0x01, 0x00, 0x00, 0x95, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x91, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x98, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xba, 0x01, 0x00, 0x00, 0x73, 0x01, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xbb, 0x01, 0x00, 0x00, - 0xba, 0x01, 0x00, 0x00, 0x74, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xbc, 0x01, 0x00, 0x00, 0xbb, 0x01, 0x00, 0x00, - 0xb4, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xbd, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0xbc, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0xbe, 0x01, 0x00, 0x00, 0xbd, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xbf, 0x01, 0x00, 0x00, 0x62, 0x01, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, - 0xbf, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xc1, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2d, 0x00, 0x00, 0x00, 0xbe, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0xc0, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xc2, 0x01, 0x00, 0x00, 0x7c, 0x01, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xc3, 0x01, 0x00, 0x00, - 0xc2, 0x01, 0x00, 0x00, 0x7d, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xc4, 0x01, 0x00, 0x00, 0xc3, 0x01, 0x00, 0x00, - 0xb7, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xc5, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0xc4, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0xc6, 0x01, 0x00, 0x00, 0xc5, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xc7, 0x01, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, - 0x82, 0x00, 0x05, 0x00, 0x17, 0x00, 0x00, 0x00, 0xc8, 0x01, 0x00, 0x00, - 0xc7, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xc9, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2d, 0x00, 0x00, 0x00, 0xc6, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0xc8, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xca, 0x01, 0x00, 0x00, 0x86, 0x01, 0x00, 0x00, 0x86, 0x01, 0x00, 0x00, - 0x86, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xcb, 0x01, 0x00, 0x00, 0x92, 0x01, 0x00, 0x00, 0xca, 0x01, 0x00, 0x00, - 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xcc, 0x01, 0x00, 0x00, - 0xc1, 0x01, 0x00, 0x00, 0xc9, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xcd, 0x01, 0x00, 0x00, - 0xcc, 0x01, 0x00, 0x00, 0xcc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x74, 0x01, 0x00, 0x00, + 0x6e, 0x01, 0x00, 0x00, 0x6c, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x75, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x74, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x76, 0x01, 0x00, 0x00, + 0x75, 0x01, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x77, 0x01, 0x00, 0x00, 0x73, 0x01, 0x00, 0x00, + 0x76, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x62, 0x01, 0x00, 0x00, 0x51, 0x01, 0x00, 0x00, 0x77, 0x01, 0x00, 0x00, + 0x80, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x65, 0x01, 0x00, 0x00, + 0x64, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x61, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x67, 0x01, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x52, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x52, 0x01, 0x00, 0x00, 0x80, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x54, 0x01, 0x00, 0x00, 0x53, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x4f, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x56, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x78, 0x01, 0x00, 0x00, 0x31, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x79, 0x01, 0x00, 0x00, + 0x78, 0x01, 0x00, 0x00, 0x32, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x7a, 0x01, 0x00, 0x00, 0x79, 0x01, 0x00, 0x00, + 0xb7, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x7b, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x7a, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x7c, 0x01, 0x00, 0x00, 0x7b, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x7d, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, + 0x82, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x7e, 0x01, 0x00, 0x00, + 0x7d, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x7f, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x00, 0x7c, 0x01, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x7e, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x80, 0x01, 0x00, 0x00, 0x3a, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, + 0x80, 0x01, 0x00, 0x00, 0x3b, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, + 0xba, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x83, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x82, 0x01, 0x00, 0x00, 0x6e, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0x84, 0x01, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, + 0x82, 0x00, 0x05, 0x00, 0x18, 0x00, 0x00, 0x00, 0x86, 0x01, 0x00, 0x00, + 0x85, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x86, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x88, 0x01, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, + 0x44, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x89, 0x01, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, + 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, + 0x7f, 0x01, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, 0x8b, 0x01, 0x00, 0x00, + 0x8a, 0x01, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, - 0xce, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0xcf, 0x01, 0x00, 0x00, 0xce, 0x01, 0x00, 0x00, - 0xcd, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd0, 0x01, 0x00, 0x00, - 0xcf, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xd1, 0x01, 0x00, 0x00, 0xcb, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xd2, 0x01, 0x00, 0x00, 0xcb, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd3, 0x01, 0x00, 0x00, - 0xcb, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0xd4, 0x01, 0x00, 0x00, 0xd1, 0x01, 0x00, 0x00, - 0xd2, 0x01, 0x00, 0x00, 0xd3, 0x01, 0x00, 0x00, 0xd0, 0x01, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xd5, 0x01, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0xd5, 0x01, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0xd4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x5e, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xd6, 0x01, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xd7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xd6, 0x01, 0x00, 0x00, 0xd8, 0x01, 0x00, 0x00, - 0xd7, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xd8, 0x01, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xd9, 0x01, 0x00, 0x00, - 0xa1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0xda, 0x01, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, - 0x7c, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0xdb, 0x01, 0x00, 0x00, - 0xd9, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0xdc, 0x01, 0x00, 0x00, 0xda, 0x01, 0x00, 0x00, 0xdb, 0x01, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, - 0xdd, 0x01, 0x00, 0x00, 0xdc, 0x01, 0x00, 0x00, 0xdc, 0x01, 0x00, 0x00, + 0x8c, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x8d, 0x01, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, + 0x8b, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, + 0x8d, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x90, 0x01, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, + 0x89, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x92, 0x01, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, + 0x90, 0x01, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x93, 0x01, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0x93, 0x01, 0x00, 0x00, + 0xb4, 0x00, 0x00, 0x00, 0x92, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x1c, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x94, 0x01, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x95, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x94, 0x01, 0x00, 0x00, 0x96, 0x01, 0x00, 0x00, + 0x95, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x96, 0x01, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x97, 0x01, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x98, 0x01, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, + 0x7c, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x99, 0x01, 0x00, 0x00, + 0x97, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, + 0x9a, 0x01, 0x00, 0x00, 0x98, 0x01, 0x00, 0x00, 0x99, 0x01, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, + 0x9b, 0x01, 0x00, 0x00, 0x9a, 0x01, 0x00, 0x00, 0x9a, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0xde, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, - 0x5f, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0xdf, 0x01, 0x00, 0x00, - 0xde, 0x01, 0x00, 0x00, 0xdd, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xe0, 0x01, 0x00, 0x00, 0xdf, 0x01, 0x00, 0x00, 0xdf, 0x01, 0x00, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x9d, 0x01, 0x00, 0x00, + 0x9c, 0x01, 0x00, 0x00, 0x9b, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x9e, 0x01, 0x00, 0x00, 0x9d, 0x01, 0x00, 0x00, 0x9d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0xe1, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xe2, 0x01, 0x00, 0x00, 0xdf, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xe3, 0x01, 0x00, 0x00, - 0xe1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xe4, 0x01, 0x00, 0x00, 0xe1, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xe5, 0x01, 0x00, 0x00, 0xe1, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0xe6, 0x01, 0x00, 0x00, - 0xe3, 0x01, 0x00, 0x00, 0xe4, 0x01, 0x00, 0x00, 0xe5, 0x01, 0x00, 0x00, - 0xe2, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, - 0xe7, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, - 0xe7, 0x01, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0xe6, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, - 0xe8, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0xe9, 0x01, 0x00, 0x00, - 0xe8, 0x01, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xea, 0x01, 0x00, 0x00, 0xe9, 0x01, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xeb, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xea, 0x01, 0x00, 0x00, 0xec, 0x01, 0x00, 0x00, - 0xeb, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xec, 0x01, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xed, 0x01, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0xed, 0x01, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0xe6, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xeb, 0x01, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0xee, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0xef, 0x01, 0x00, 0x00, - 0xee, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf0, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0xef, 0x01, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xf1, 0x01, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, - 0xf0, 0x01, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xf2, 0x01, 0x00, 0x00, 0xe1, 0x01, 0x00, 0x00, - 0xf1, 0x01, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xf3, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xf4, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xf4, 0x01, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xf5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xea, 0x01, 0x00, 0x00, 0xf6, 0x01, 0x00, 0x00, - 0xf5, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xf6, 0x01, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xf3, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xf5, 0x01, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf7, 0x01, 0x00, 0x00, 0xf2, 0x01, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, - 0xf7, 0x01, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0xf9, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xf8, 0x01, 0x00, 0x00, 0xfa, 0x01, 0x00, 0x00, 0xf9, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xfa, 0x01, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xfb, 0x01, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, - 0xf7, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xfc, 0x01, 0x00, 0x00, 0xfb, 0x01, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0xfd, 0x01, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xfc, 0x01, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0xfd, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, - 0xfe, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x00, 0x02, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, - 0x00, 0x02, 0x00, 0x00, 0xf7, 0x01, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0xf2, 0x01, 0x00, 0x00, - 0x01, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xf9, 0x01, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xf9, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xf2, 0x01, 0x00, 0x00, - 0xf5, 0x01, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0xfa, 0x01, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, - 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x06, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x07, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, - 0x06, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x08, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0x04, 0x02, 0x00, 0x00, 0x07, 0x02, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x09, 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x0a, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x09, 0x02, 0x00, 0x00, - 0x0b, 0x02, 0x00, 0x00, 0x0a, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x0b, 0x02, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x0c, 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, - 0x08, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x0d, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x0a, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x0a, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x0e, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, 0xf9, 0x01, 0x00, 0x00, - 0x0d, 0x02, 0x00, 0x00, 0x0b, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xf3, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xf3, 0x01, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x0f, 0x02, 0x00, 0x00, - 0xf2, 0x01, 0x00, 0x00, 0xf6, 0x01, 0x00, 0x00, 0x0e, 0x02, 0x00, 0x00, - 0x0a, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x10, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0x0f, 0x02, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, - 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x11, 0x02, 0x00, 0x00, - 0x10, 0x02, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x12, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x13, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x12, 0x02, 0x00, 0x00, - 0x47, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x14, 0x02, 0x00, 0x00, 0x13, 0x02, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x02, 0x00, 0x00, - 0x14, 0x02, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x17, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x11, 0x02, 0x00, 0x00, - 0x15, 0x02, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x17, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x19, 0x02, 0x00, 0x00, 0x17, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1a, 0x02, 0x00, 0x00, - 0x17, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0x1b, 0x02, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, - 0x19, 0x02, 0x00, 0x00, 0x1a, 0x02, 0x00, 0x00, 0xe2, 0x01, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1c, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0x1c, 0x02, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xd7, 0x01, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, - 0x1d, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1e, 0x02, 0x00, 0x00, - 0x1d, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x1f, 0x02, 0x00, 0x00, 0x1e, 0x02, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x1f, 0x02, 0x00, 0x00, 0x21, 0x02, 0x00, 0x00, - 0x22, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x21, 0x02, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, - 0xb9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x24, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, - 0x25, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, - 0x25, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x27, 0x02, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xa5, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x28, 0x02, 0x00, 0x00, - 0x24, 0x02, 0x00, 0x00, 0x27, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x29, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x24, 0x02, 0x00, 0x00, 0x2a, 0x02, 0x00, 0x00, 0x2b, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x2a, 0x02, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x2c, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, - 0x32, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x29, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x2b, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x2d, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x2e, 0x02, 0x00, 0x00, 0x2d, 0x02, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x29, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x29, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x2f, 0x02, 0x00, 0x00, 0x2c, 0x02, 0x00, 0x00, 0x2a, 0x02, 0x00, 0x00, - 0x2e, 0x02, 0x00, 0x00, 0x2b, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x30, 0x02, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, - 0x31, 0x02, 0x00, 0x00, 0x2f, 0x02, 0x00, 0x00, 0x30, 0x02, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, - 0x31, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x33, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xa0, 0x01, 0x00, 0x00, 0x9d, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xa1, 0x01, 0x00, 0x00, + 0x9f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xa2, 0x01, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xa3, 0x01, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xa4, 0x01, 0x00, 0x00, + 0xa1, 0x01, 0x00, 0x00, 0xa2, 0x01, 0x00, 0x00, 0xa3, 0x01, 0x00, 0x00, + 0xa0, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0xa5, 0x01, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, + 0xa5, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xa4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0x34, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x35, 0x02, 0x00, 0x00, - 0x34, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x36, 0x02, 0x00, 0x00, 0x33, 0x02, 0x00, 0x00, 0x35, 0x02, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, - 0x1e, 0x00, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x39, 0x02, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3a, 0x02, 0x00, 0x00, - 0x39, 0x02, 0x00, 0x00, 0x35, 0x02, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, - 0x3a, 0x02, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, - 0x3c, 0x02, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00, - 0xbf, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x3d, 0x02, 0x00, 0x00, - 0x37, 0x02, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x3e, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x3d, 0x02, 0x00, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x3e, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x3f, 0x02, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x3e, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x3e, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x41, 0x02, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, - 0x29, 0x02, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x3f, 0x02, 0x00, 0x00, - 0xa8, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x42, 0x02, 0x00, 0x00, - 0x41, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x43, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x42, 0x02, 0x00, 0x00, - 0x44, 0x02, 0x00, 0x00, 0x43, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x44, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x45, 0x02, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x43, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x43, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x46, 0x02, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3e, 0x02, 0x00, 0x00, - 0x45, 0x02, 0x00, 0x00, 0x44, 0x02, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x46, 0x02, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x48, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x47, 0x02, 0x00, 0x00, 0x49, 0x02, 0x00, 0x00, - 0x48, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x49, 0x02, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x4a, 0x02, 0x00, 0x00, - 0x3b, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x48, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x48, 0x02, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x4b, 0x02, 0x00, 0x00, - 0x1b, 0x00, 0x00, 0x00, 0x43, 0x02, 0x00, 0x00, 0x4a, 0x02, 0x00, 0x00, - 0x49, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x4c, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0x4d, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x4c, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, 0x4e, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x4f, 0x02, 0x00, 0x00, 0x4e, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x50, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x4f, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x51, 0x02, 0x00, 0x00, 0x4d, 0x02, 0x00, 0x00, 0x50, 0x02, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x20, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x22, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x52, 0x02, 0x00, 0x00, 0x1e, 0x02, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x53, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x52, 0x02, 0x00, 0x00, 0x54, 0x02, 0x00, 0x00, - 0x53, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x54, 0x02, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x55, 0x02, 0x00, 0x00, - 0xb9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, - 0x83, 0x00, 0x00, 0x00, 0x56, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x34, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x57, 0x02, 0x00, 0x00, 0x56, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x58, 0x02, 0x00, 0x00, 0x55, 0x02, 0x00, 0x00, - 0x57, 0x02, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, - 0x59, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x5a, 0x02, 0x00, 0x00, - 0x59, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x5b, 0x02, 0x00, 0x00, 0x5a, 0x02, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xa5, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x5c, 0x02, 0x00, 0x00, - 0x58, 0x02, 0x00, 0x00, 0x5b, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x5d, 0x02, 0x00, 0x00, 0x55, 0x02, 0x00, 0x00, - 0x57, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x5e, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x5d, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x21, 0x00, 0x00, 0x00, - 0x5f, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xa6, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x5f, 0x02, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x61, 0x02, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x62, 0x02, 0x00, 0x00, 0x5e, 0x02, 0x00, 0x00, - 0x61, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x53, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x53, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x63, 0x02, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x00, 0x00, 0x62, 0x02, 0x00, 0x00, 0x54, 0x02, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x64, 0x02, 0x00, 0x00, - 0x2a, 0x00, 0x00, 0x00, 0x22, 0x02, 0x00, 0x00, 0x5c, 0x02, 0x00, 0x00, - 0x54, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x20, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x20, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x65, 0x02, 0x00, 0x00, 0x51, 0x02, 0x00, 0x00, - 0x48, 0x02, 0x00, 0x00, 0x63, 0x02, 0x00, 0x00, 0x53, 0x02, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x66, 0x02, 0x00, 0x00, - 0x4b, 0x02, 0x00, 0x00, 0x48, 0x02, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, - 0x53, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x67, 0x02, 0x00, 0x00, 0x28, 0x02, 0x00, 0x00, 0x48, 0x02, 0x00, 0x00, - 0x64, 0x02, 0x00, 0x00, 0x53, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0x3c, 0x02, 0x00, 0x00, - 0x48, 0x02, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0x53, 0x02, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x69, 0x02, 0x00, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, - 0x6a, 0x02, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, - 0x10, 0x00, 0x00, 0x00, 0x6b, 0x02, 0x00, 0x00, 0x69, 0x02, 0x00, 0x00, - 0x6a, 0x02, 0x00, 0x00, 0x58, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, - 0x6c, 0x02, 0x00, 0x00, 0x6b, 0x02, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x6d, 0x02, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x6e, 0x02, 0x00, 0x00, - 0x0f, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x6f, 0x02, 0x00, 0x00, 0x6d, 0x02, 0x00, 0x00, 0x6e, 0x02, 0x00, 0x00, - 0x58, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, - 0x6f, 0x02, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00, - 0x71, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x72, 0x02, 0x00, 0x00, - 0x71, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x73, 0x02, 0x00, 0x00, 0x72, 0x02, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x74, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x73, 0x02, 0x00, 0x00, 0x75, 0x02, 0x00, 0x00, - 0x76, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x75, 0x02, 0x00, 0x00, - 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, - 0x6c, 0x02, 0x00, 0x00, 0x6c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x74, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x76, 0x02, 0x00, 0x00, - 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x78, 0x02, 0x00, 0x00, - 0x6c, 0x02, 0x00, 0x00, 0x6c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x79, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x00, 0x00, 0x78, 0x02, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, - 0x39, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x7a, 0x02, 0x00, 0x00, 0x79, 0x02, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x7b, 0x02, 0x00, 0x00, - 0x79, 0x02, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x7c, 0x02, 0x00, 0x00, 0x7b, 0x02, 0x00, 0x00, - 0x9c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x7d, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x7c, 0x02, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x7e, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x30, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x79, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x7a, 0x02, 0x00, 0x00, - 0x7d, 0x02, 0x00, 0x00, 0x7e, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x74, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x74, 0x02, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, - 0x77, 0x02, 0x00, 0x00, 0x75, 0x02, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, - 0x76, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x81, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x73, 0x02, 0x00, 0x00, - 0x82, 0x02, 0x00, 0x00, 0x83, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x82, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x84, 0x02, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, + 0xa6, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0xa7, 0x01, 0x00, 0x00, + 0xa6, 0x01, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xa8, 0x01, 0x00, 0x00, 0xa7, 0x01, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xa9, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xa8, 0x01, 0x00, 0x00, 0xaa, 0x01, 0x00, 0x00, + 0xa9, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xaa, 0x01, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xab, 0x01, 0x00, 0x00, + 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0xab, 0x01, 0x00, 0x00, + 0xb4, 0x00, 0x00, 0x00, 0xa4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xa9, 0x01, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xac, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xad, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xad, 0x01, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0xae, 0x01, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xaf, 0x01, 0x00, 0x00, 0xae, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xaf, 0x01, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, + 0xb1, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0xb2, 0x01, 0x00, 0x00, + 0xb1, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xb3, 0x01, 0x00, 0x00, 0xb2, 0x01, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xb4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xb3, 0x01, 0x00, 0x00, 0xb5, 0x01, 0x00, 0x00, + 0xb4, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xb5, 0x01, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xac, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xb4, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, + 0xb6, 0x01, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0xb7, 0x01, 0x00, 0x00, 0xb6, 0x01, 0x00, 0x00, + 0x88, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, + 0xb7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xb9, 0x01, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xba, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xb9, 0x01, 0x00, 0x00, + 0xbb, 0x01, 0x00, 0x00, 0xba, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xbb, 0x01, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xbc, 0x01, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xba, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xba, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xbd, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xb4, 0x01, 0x00, 0x00, + 0xbc, 0x01, 0x00, 0x00, 0xbb, 0x01, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xbe, 0x01, 0x00, 0x00, 0xbd, 0x01, 0x00, 0x00, + 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xbf, 0x01, 0x00, 0x00, + 0xbe, 0x01, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xc1, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xc2, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xc1, 0x01, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0xc3, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0xc4, 0x01, 0x00, 0x00, + 0xc3, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xc5, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0xc4, 0x01, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xc6, 0x01, 0x00, 0x00, 0xbf, 0x01, 0x00, 0x00, + 0xc2, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xc7, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0xc6, 0x01, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xc8, 0x01, 0x00, 0x00, 0xc5, 0x01, 0x00, 0x00, + 0xc7, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xc9, 0x01, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00, 0xc8, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xca, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xc9, 0x01, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xac, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xac, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xcb, 0x01, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00, + 0xb5, 0x01, 0x00, 0x00, 0xca, 0x01, 0x00, 0x00, 0xba, 0x01, 0x00, 0x00, + 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0xcc, 0x01, 0x00, 0x00, + 0xcb, 0x01, 0x00, 0x00, 0xcb, 0x01, 0x00, 0x00, 0xcb, 0x01, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xcd, 0x01, 0x00, 0x00, + 0x9f, 0x01, 0x00, 0x00, 0xcc, 0x01, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xce, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xcf, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xcf, 0x01, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xd0, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xa8, 0x01, 0x00, 0x00, + 0xd1, 0x01, 0x00, 0x00, 0xd0, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xd1, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xce, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xd0, 0x01, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xd2, 0x01, 0x00, 0x00, 0xcd, 0x01, 0x00, 0x00, + 0x17, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xd3, 0x01, 0x00, 0x00, 0xd2, 0x01, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xd4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xd3, 0x01, 0x00, 0x00, 0xd5, 0x01, 0x00, 0x00, + 0xd4, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xd5, 0x01, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd6, 0x01, 0x00, 0x00, + 0x44, 0x00, 0x00, 0x00, 0xd2, 0x01, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xd7, 0x01, 0x00, 0x00, 0xd6, 0x01, 0x00, 0x00, + 0xa1, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xd8, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xd7, 0x01, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xd9, 0x01, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xd8, 0x01, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xda, 0x01, 0x00, 0x00, + 0x45, 0x00, 0x00, 0x00, 0xd9, 0x01, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xdb, 0x01, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, + 0xda, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xdc, 0x01, 0x00, 0x00, 0xdb, 0x01, 0x00, 0x00, 0xd2, 0x01, 0x00, 0x00, + 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xdd, 0x01, 0x00, 0x00, + 0xcd, 0x01, 0x00, 0x00, 0xdc, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xd4, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xd4, 0x01, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xde, 0x01, 0x00, 0x00, + 0xcd, 0x01, 0x00, 0x00, 0xd0, 0x01, 0x00, 0x00, 0xdd, 0x01, 0x00, 0x00, + 0xd5, 0x01, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xdf, 0x01, 0x00, 0x00, 0xde, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, + 0xde, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xe1, 0x01, 0x00, 0x00, 0xde, 0x01, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xe2, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0xe0, 0x01, 0x00, 0x00, 0xe1, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xe3, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0xdf, 0x01, 0x00, 0x00, 0xe2, 0x01, 0x00, 0x00, + 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xe4, 0x01, 0x00, 0x00, + 0xe3, 0x01, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xe5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xe4, 0x01, 0x00, 0x00, 0xe6, 0x01, 0x00, 0x00, 0xe5, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xe6, 0x01, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xe7, 0x01, 0x00, 0x00, 0xe3, 0x01, 0x00, 0x00, + 0xe3, 0x01, 0x00, 0x00, 0xe3, 0x01, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xe8, 0x01, 0x00, 0x00, 0xde, 0x01, 0x00, 0x00, + 0xe7, 0x01, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xe5, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xe5, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xe9, 0x01, 0x00, 0x00, 0xde, 0x01, 0x00, 0x00, + 0xd4, 0x01, 0x00, 0x00, 0xe8, 0x01, 0x00, 0x00, 0xe6, 0x01, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xce, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xce, 0x01, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xea, 0x01, 0x00, 0x00, 0xcd, 0x01, 0x00, 0x00, 0xd1, 0x01, 0x00, 0x00, + 0xe9, 0x01, 0x00, 0x00, 0xe5, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xeb, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0xea, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0x37, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xec, 0x01, 0x00, 0x00, 0xeb, 0x01, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xed, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xeb, 0x01, 0x00, 0x00, + 0x48, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xee, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, + 0xed, 0x01, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xef, 0x01, 0x00, 0x00, 0xee, 0x01, 0x00, 0x00, + 0x4b, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xf0, 0x01, 0x00, 0x00, 0xef, 0x01, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xf1, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, + 0xeb, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xf2, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, + 0xec, 0x01, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0xf1, 0x01, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xf3, 0x01, 0x00, 0x00, + 0xf2, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, 0xf2, 0x01, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xf5, 0x01, 0x00, 0x00, 0xf2, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xf6, 0x01, 0x00, 0x00, + 0xf3, 0x01, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, 0xf5, 0x01, 0x00, 0x00, + 0xa0, 0x01, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0xf7, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, + 0xf7, 0x01, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xf6, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x95, 0x01, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x83, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x2e, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xf9, 0x01, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xfa, 0x01, 0x00, 0x00, 0xf9, 0x01, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xfb, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xfa, 0x01, 0x00, 0x00, + 0xfc, 0x01, 0x00, 0x00, 0xfd, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xfc, 0x01, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xfe, 0x01, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, + 0xfe, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x83, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x2f, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x01, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x03, 0x02, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xff, 0x01, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, + 0x06, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x05, 0x02, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x02, 0x00, 0x00, + 0xfe, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x04, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x06, 0x02, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, + 0xfe, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x09, 0x02, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x04, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x04, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x0a, 0x02, 0x00, 0x00, 0x07, 0x02, 0x00, 0x00, + 0x05, 0x02, 0x00, 0x00, 0x09, 0x02, 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0b, 0x02, 0x00, 0x00, + 0xbc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, 0x0a, 0x02, 0x00, 0x00, + 0x0b, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x0d, 0x02, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0e, 0x02, 0x00, 0x00, + 0x0d, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x86, 0x00, 0x00, 0x00, 0x0f, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x31, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x10, 0x02, 0x00, 0x00, 0x0f, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x11, 0x02, 0x00, 0x00, 0x0e, 0x02, 0x00, 0x00, + 0x10, 0x02, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x12, 0x02, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x11, 0x02, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13, 0x02, 0x00, 0x00, + 0x0d, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x14, 0x02, 0x00, 0x00, 0x13, 0x02, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x15, 0x02, 0x00, 0x00, 0x14, 0x02, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, + 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00, + 0x1f, 0x00, 0x00, 0x00, 0x15, 0x02, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x17, 0x02, 0x00, 0x00, 0x12, 0x02, 0x00, 0x00, + 0x16, 0x02, 0x00, 0x00, 0xbf, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x18, 0x02, 0x00, 0x00, 0x12, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x19, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x18, 0x02, 0x00, 0x00, 0x1a, 0x02, 0x00, 0x00, + 0x19, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1a, 0x02, 0x00, 0x00, + 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x02, 0x00, 0x00, + 0x12, 0x02, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x19, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x19, 0x02, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1c, 0x02, 0x00, 0x00, + 0x1c, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x1b, 0x02, 0x00, 0x00, + 0x1a, 0x02, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x1d, 0x02, 0x00, 0x00, 0x1c, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x1e, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x1d, 0x02, 0x00, 0x00, 0x1f, 0x02, 0x00, 0x00, 0x1e, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x1f, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x1e, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x1e, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x21, 0x02, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0x19, 0x02, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x1f, 0x02, 0x00, 0x00, + 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x22, 0x02, 0x00, 0x00, + 0x21, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x23, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x22, 0x02, 0x00, 0x00, + 0x24, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x24, 0x02, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x25, 0x02, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x23, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x23, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x26, 0x02, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1e, 0x02, 0x00, 0x00, + 0x25, 0x02, 0x00, 0x00, 0x24, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x27, 0x02, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, + 0x1f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x28, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x27, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x29, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0xa9, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x70, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x2a, 0x02, 0x00, 0x00, 0x29, 0x02, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x2b, 0x02, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x2a, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x2c, 0x02, 0x00, 0x00, 0x28, 0x02, 0x00, 0x00, + 0x2b, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xfb, 0x01, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xfd, 0x01, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x2d, 0x02, 0x00, 0x00, 0xf9, 0x01, 0x00, 0x00, + 0x2c, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x2e, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x2d, 0x02, 0x00, 0x00, + 0x2f, 0x02, 0x00, 0x00, 0x2e, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x2f, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x30, 0x02, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x31, 0x02, 0x00, 0x00, + 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x33, 0x02, 0x00, 0x00, + 0x30, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x83, 0x00, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x2f, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x35, 0x02, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, 0x35, 0x02, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x37, 0x02, 0x00, 0x00, 0x33, 0x02, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, + 0x30, 0x02, 0x00, 0x00, 0x32, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x39, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x38, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x22, 0x00, 0x00, 0x00, 0x3a, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x70, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00, + 0x3a, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x3c, 0x02, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00, + 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3d, 0x02, 0x00, 0x00, + 0x39, 0x02, 0x00, 0x00, 0x3c, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x2e, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x2e, 0x02, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x3e, 0x02, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0xfd, 0x01, 0x00, 0x00, 0x3d, 0x02, 0x00, 0x00, + 0x2f, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x3f, 0x02, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xfd, 0x01, 0x00, 0x00, + 0x37, 0x02, 0x00, 0x00, 0x2f, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xfb, 0x01, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xfb, 0x01, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, + 0x2c, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0x3e, 0x02, 0x00, 0x00, + 0x2e, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x41, 0x02, 0x00, 0x00, 0x26, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0x2e, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x42, 0x02, 0x00, 0x00, 0x03, 0x02, 0x00, 0x00, + 0x23, 0x02, 0x00, 0x00, 0x3f, 0x02, 0x00, 0x00, 0x2e, 0x02, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x20, 0x00, 0x00, 0x00, 0x43, 0x02, 0x00, 0x00, + 0x17, 0x02, 0x00, 0x00, 0x23, 0x02, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, + 0x2e, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x44, 0x02, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x0f, 0x00, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, + 0x56, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x46, 0x02, 0x00, 0x00, + 0x44, 0x02, 0x00, 0x00, 0x45, 0x02, 0x00, 0x00, 0x58, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x46, 0x02, 0x00, 0x00, + 0x43, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x48, 0x02, 0x00, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x49, 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, + 0x11, 0x00, 0x00, 0x00, 0x4a, 0x02, 0x00, 0x00, 0x48, 0x02, 0x00, 0x00, + 0x49, 0x02, 0x00, 0x00, 0x58, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0x4b, 0x02, 0x00, 0x00, 0x4a, 0x02, 0x00, 0x00, 0x43, 0x02, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x83, 0x00, 0x00, 0x00, 0x4c, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, + 0x4d, 0x02, 0x00, 0x00, 0x4c, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x4e, 0x02, 0x00, 0x00, 0x4d, 0x02, 0x00, 0x00, + 0x24, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x4f, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x4e, 0x02, 0x00, 0x00, + 0x50, 0x02, 0x00, 0x00, 0x51, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x50, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x52, 0x02, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x81, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x83, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x85, 0x02, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x4f, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x51, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x53, 0x02, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x86, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x85, 0x02, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x87, 0x02, 0x00, 0x00, 0x86, 0x02, 0x00, 0x00, - 0x9a, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x88, 0x02, 0x00, 0x00, 0x86, 0x02, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x89, 0x02, 0x00, 0x00, - 0x88, 0x02, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x8a, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x89, 0x02, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x8b, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0x86, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x8c, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, - 0x87, 0x02, 0x00, 0x00, 0x8a, 0x02, 0x00, 0x00, 0x8b, 0x02, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x81, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x81, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x8d, 0x02, 0x00, 0x00, 0x84, 0x02, 0x00, 0x00, 0x82, 0x02, 0x00, 0x00, - 0x8c, 0x02, 0x00, 0x00, 0x83, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x8e, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x1f, 0x02, 0x00, 0x00, 0x8f, 0x02, 0x00, 0x00, 0x90, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x8f, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x91, 0x02, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x92, 0x02, 0x00, 0x00, - 0x0f, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x93, 0x02, 0x00, 0x00, 0x91, 0x02, 0x00, 0x00, 0x92, 0x02, 0x00, 0x00, - 0x58, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, - 0x93, 0x02, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x8e, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x90, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x95, 0x02, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, - 0x96, 0x02, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, - 0x17, 0x00, 0x00, 0x00, 0x97, 0x02, 0x00, 0x00, 0x95, 0x02, 0x00, 0x00, - 0x50, 0x00, 0x06, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x98, 0x02, 0x00, 0x00, - 0x96, 0x02, 0x00, 0x00, 0x97, 0x02, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x99, 0x02, 0x00, 0x00, - 0x98, 0x02, 0x00, 0x00, 0x98, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, 0x54, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x53, 0x02, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x55, 0x02, 0x00, 0x00, 0x54, 0x02, 0x00, 0x00, + 0x9d, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x56, 0x02, 0x00, 0x00, 0x54, 0x02, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x57, 0x02, 0x00, 0x00, + 0x56, 0x02, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x58, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x00, 0x00, 0x57, 0x02, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x59, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, + 0x54, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x5a, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, + 0x55, 0x02, 0x00, 0x00, 0x58, 0x02, 0x00, 0x00, 0x59, 0x02, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x4f, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x4f, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x5b, 0x02, 0x00, 0x00, 0x52, 0x02, 0x00, 0x00, 0x50, 0x02, 0x00, 0x00, + 0x5a, 0x02, 0x00, 0x00, 0x51, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x5c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x4e, 0x02, 0x00, 0x00, 0x5d, 0x02, 0x00, 0x00, 0x5e, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x5d, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x5f, 0x02, 0x00, 0x00, 0x4b, 0x02, 0x00, 0x00, + 0x4b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x5c, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x5e, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x4b, 0x02, 0x00, 0x00, + 0x4b, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x61, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0x60, 0x02, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x62, 0x02, 0x00, 0x00, + 0x61, 0x02, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x63, 0x02, 0x00, 0x00, 0x61, 0x02, 0x00, 0x00, + 0x4d, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x64, 0x02, 0x00, 0x00, 0x63, 0x02, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x65, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x64, 0x02, 0x00, 0x00, + 0x51, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x66, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, + 0x53, 0x00, 0x00, 0x00, 0x61, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x67, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2e, 0x00, 0x00, 0x00, 0x62, 0x02, 0x00, 0x00, 0x65, 0x02, 0x00, 0x00, + 0x66, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x5c, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x5c, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0x5f, 0x02, 0x00, 0x00, + 0x5d, 0x02, 0x00, 0x00, 0x67, 0x02, 0x00, 0x00, 0x5e, 0x02, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x69, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xfa, 0x01, 0x00, 0x00, 0x6a, 0x02, 0x00, 0x00, + 0x6b, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x6a, 0x02, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x6c, 0x02, 0x00, 0x00, + 0x09, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, + 0x6d, 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, + 0x11, 0x00, 0x00, 0x00, 0x6e, 0x02, 0x00, 0x00, 0x6c, 0x02, 0x00, 0x00, + 0x6d, 0x02, 0x00, 0x00, 0x58, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0x6f, 0x02, 0x00, 0x00, 0x6e, 0x02, 0x00, 0x00, 0x43, 0x02, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x69, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x6b, 0x02, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, + 0xa4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x71, 0x02, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, + 0x7c, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x72, 0x02, 0x00, 0x00, + 0x70, 0x02, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, + 0x73, 0x02, 0x00, 0x00, 0x71, 0x02, 0x00, 0x00, 0x72, 0x02, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, + 0x74, 0x02, 0x00, 0x00, 0x73, 0x02, 0x00, 0x00, 0x73, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x75, 0x02, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x76, 0x02, 0x00, 0x00, + 0x75, 0x02, 0x00, 0x00, 0x74, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x69, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x69, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, 0x6f, 0x02, 0x00, 0x00, + 0x6a, 0x02, 0x00, 0x00, 0x76, 0x02, 0x00, 0x00, 0x6b, 0x02, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x78, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x4e, 0x02, 0x00, 0x00, 0x79, 0x02, 0x00, 0x00, + 0x7a, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x79, 0x02, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x78, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x7a, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x7b, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x7c, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x7c, 0x02, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x7d, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x7e, 0x02, 0x00, 0x00, 0x7d, 0x02, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x7e, 0x02, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, + 0x80, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x00, + 0x80, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x82, 0x02, 0x00, 0x00, 0x81, 0x02, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x83, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x82, 0x02, 0x00, 0x00, 0x84, 0x02, 0x00, 0x00, + 0x83, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x84, 0x02, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x7b, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x83, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x85, 0x02, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x86, 0x02, 0x00, 0x00, 0x85, 0x02, 0x00, 0x00, + 0x88, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x87, 0x02, 0x00, 0x00, + 0x86, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x88, 0x02, 0x00, 0x00, 0x87, 0x02, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x89, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x88, 0x02, 0x00, 0x00, + 0x8a, 0x02, 0x00, 0x00, 0x89, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x8a, 0x02, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x8b, 0x02, 0x00, 0x00, 0x87, 0x02, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x89, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x89, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x8c, 0x02, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x83, 0x02, 0x00, 0x00, + 0x8b, 0x02, 0x00, 0x00, 0x8a, 0x02, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x8d, 0x02, 0x00, 0x00, 0x8c, 0x02, 0x00, 0x00, + 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x8e, 0x02, 0x00, 0x00, + 0x8d, 0x02, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x87, 0x02, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x8f, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x90, 0x02, 0x00, 0x00, 0x8f, 0x02, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x91, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x90, 0x02, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0x92, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x93, 0x02, 0x00, 0x00, + 0x92, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x94, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x93, 0x02, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x95, 0x02, 0x00, 0x00, 0x8e, 0x02, 0x00, 0x00, + 0x91, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x96, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x95, 0x02, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x97, 0x02, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, + 0x96, 0x02, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x98, 0x02, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, 0x97, 0x02, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x99, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x98, 0x02, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x7b, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x7b, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x9a, 0x02, 0x00, 0x00, 0x7f, 0x02, 0x00, 0x00, + 0x84, 0x02, 0x00, 0x00, 0x99, 0x02, 0x00, 0x00, 0x89, 0x02, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x78, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x78, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x9b, 0x02, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x79, 0x02, 0x00, 0x00, + 0x9a, 0x02, 0x00, 0x00, 0x7b, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, + 0x77, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x9d, 0x02, 0x00, 0x00, 0x9b, 0x02, 0x00, 0x00, 0x9b, 0x02, 0x00, 0x00, + 0x9b, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x9e, 0x02, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, 0x9d, 0x02, 0x00, 0x00, + 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, + 0x9e, 0x02, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xa0, 0x02, 0x00, 0x00, 0x5b, 0x02, 0x00, 0x00, + 0x17, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, + 0xa1, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0xa2, 0x02, 0x00, 0x00, + 0xa1, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xa3, 0x02, 0x00, 0x00, 0xa2, 0x02, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xa4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xa3, 0x02, 0x00, 0x00, 0xa5, 0x02, 0x00, 0x00, + 0xa4, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa5, 0x02, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, + 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00, + 0x5b, 0x02, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xa9, 0x02, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xaa, 0x02, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xab, 0x02, 0x00, 0x00, + 0xa8, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xac, 0x02, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0xad, 0x02, 0x00, 0x00, 0xaa, 0x02, 0x00, 0x00, 0xab, 0x02, 0x00, 0x00, + 0xac, 0x02, 0x00, 0x00, 0xa9, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0xae, 0x02, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x63, 0x00, 0x05, 0x00, 0xae, 0x02, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, + 0xad, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xa5, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa4, 0x02, 0x00, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xaf, 0x02, 0x00, 0x00, + 0xa2, 0x02, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xb0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xaf, 0x02, 0x00, 0x00, 0xb1, 0x02, 0x00, 0x00, 0xb0, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xb1, 0x02, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x86, 0x00, 0x00, 0x00, 0xb2, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x34, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xb3, 0x02, 0x00, 0x00, 0xb2, 0x02, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xb4, 0x02, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, + 0xb3, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xb5, 0x02, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xb6, 0x02, 0x00, 0x00, + 0xb4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xb7, 0x02, 0x00, 0x00, 0xb4, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xb8, 0x02, 0x00, 0x00, 0xb4, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xb9, 0x02, 0x00, 0x00, + 0xb6, 0x02, 0x00, 0x00, 0xb7, 0x02, 0x00, 0x00, 0xb8, 0x02, 0x00, 0x00, + 0xb5, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0xba, 0x02, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, + 0xba, 0x02, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xb9, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xb0, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xbb, 0x02, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, + 0x5b, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xbc, 0x02, 0x00, 0x00, 0xa2, 0x02, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xbd, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xbc, 0x02, 0x00, 0x00, 0xbe, 0x02, 0x00, 0x00, + 0xbd, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xbe, 0x02, 0x00, 0x00, + 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xbf, 0x02, 0x00, 0x00, + 0xbb, 0x02, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xc0, 0x02, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, + 0xbf, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xc1, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0xc0, 0x02, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, 0xc2, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xc1, 0x02, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xc3, 0x02, 0x00, 0x00, 0xc2, 0x02, 0x00, 0x00, + 0x9d, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xc4, 0x02, 0x00, 0x00, 0xc2, 0x02, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xc5, 0x02, 0x00, 0x00, + 0xc4, 0x02, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xc6, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x00, 0x00, 0xc5, 0x02, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xc7, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, + 0xc2, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xc8, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, + 0xc3, 0x02, 0x00, 0x00, 0xc6, 0x02, 0x00, 0x00, 0xc7, 0x02, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0xc9, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xca, 0x02, 0x00, 0x00, 0xc9, 0x02, 0x00, 0x00, + 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xcb, 0x02, 0x00, 0x00, + 0xc8, 0x02, 0x00, 0x00, 0xca, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xcc, 0x02, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xcd, 0x02, 0x00, 0x00, 0xcb, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xce, 0x02, 0x00, 0x00, + 0xcb, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xcf, 0x02, 0x00, 0x00, 0xcb, 0x02, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0xd0, 0x02, 0x00, 0x00, 0xcd, 0x02, 0x00, 0x00, 0xce, 0x02, 0x00, 0x00, + 0xcf, 0x02, 0x00, 0x00, 0xcc, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0xd1, 0x02, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, + 0x63, 0x00, 0x05, 0x00, 0xd1, 0x02, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, + 0xd0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xa5, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xbd, 0x02, 0x00, 0x00, + 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd2, 0x02, 0x00, 0x00, + 0x68, 0x02, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xd3, 0x02, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, + 0x67, 0x00, 0x05, 0x00, 0x84, 0x00, 0x00, 0x00, 0xd4, 0x02, 0x00, 0x00, + 0xd3, 0x02, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xd5, 0x02, 0x00, 0x00, 0xd4, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x22, 0x00, 0x00, 0x00, + 0xd6, 0x02, 0x00, 0x00, 0xd4, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xd7, 0x02, 0x00, 0x00, + 0xd5, 0x02, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xd8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xd7, 0x02, 0x00, 0x00, 0xd9, 0x02, 0x00, 0x00, 0xd8, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xd9, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xda, 0x02, 0x00, 0x00, 0xd6, 0x02, 0x00, 0x00, + 0xb9, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xd8, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xd8, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xdb, 0x02, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, + 0xbd, 0x02, 0x00, 0x00, 0xda, 0x02, 0x00, 0x00, 0xd9, 0x02, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, 0xdc, 0x02, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xdd, 0x02, 0x00, 0x00, 0xdc, 0x02, 0x00, 0x00, + 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xde, 0x02, 0x00, 0x00, + 0xdd, 0x02, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xdf, 0x02, 0x00, 0x00, 0xde, 0x02, 0x00, 0x00, + 0xdb, 0x02, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xe0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xdf, 0x02, 0x00, 0x00, 0xe1, 0x02, 0x00, 0x00, 0xe0, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xe1, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xe2, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xfa, 0x01, 0x00, 0x00, 0xe3, 0x02, 0x00, 0x00, 0xe4, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xe3, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0xe5, 0x02, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, 0xe6, 0x02, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x56, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, + 0xe7, 0x02, 0x00, 0x00, 0xe5, 0x02, 0x00, 0x00, 0xe6, 0x02, 0x00, 0x00, + 0x58, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0xe8, 0x02, 0x00, 0x00, + 0xe7, 0x02, 0x00, 0x00, 0x43, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xe2, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xe4, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x22, 0x00, 0x00, 0x00, 0xe9, 0x02, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, + 0xea, 0x02, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x04, 0x00, + 0x18, 0x00, 0x00, 0x00, 0xeb, 0x02, 0x00, 0x00, 0xe9, 0x02, 0x00, 0x00, + 0x50, 0x00, 0x06, 0x00, 0x26, 0x00, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00, + 0xea, 0x02, 0x00, 0x00, 0xeb, 0x02, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x07, 0x00, 0x85, 0x00, 0x00, 0x00, 0xed, 0x02, 0x00, 0x00, + 0xec, 0x02, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x9a, 0x02, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0x9b, 0x02, 0x00, 0x00, 0x9a, 0x02, 0x00, 0x00, - 0x99, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x8e, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x8e, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, - 0x9c, 0x02, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, 0x8f, 0x02, 0x00, 0x00, - 0x9b, 0x02, 0x00, 0x00, 0x90, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x9d, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x73, 0x02, 0x00, 0x00, 0x9e, 0x02, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x9e, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x9d, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x9f, 0x02, 0x00, 0x00, - 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, 0xa0, 0x02, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xa1, 0x02, 0x00, 0x00, 0xa0, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xa2, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xa1, 0x02, 0x00, 0x00, - 0x2f, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x9d, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x9d, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xa3, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x9e, 0x02, 0x00, 0x00, 0xa2, 0x02, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, - 0x4f, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0xa4, 0x02, 0x00, 0x00, - 0x9c, 0x02, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xa5, 0x02, 0x00, 0x00, 0xa3, 0x02, 0x00, 0x00, - 0xa3, 0x02, 0x00, 0x00, 0xa3, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, 0xa4, 0x02, 0x00, 0x00, - 0xa5, 0x02, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xa7, 0x02, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00, - 0x80, 0x02, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, - 0x80, 0x00, 0x00, 0x00, 0xa9, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x35, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xaa, 0x02, 0x00, 0x00, 0xa9, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xab, 0x02, 0x00, 0x00, 0xaa, 0x02, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xac, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xab, 0x02, 0x00, 0x00, - 0xad, 0x02, 0x00, 0x00, 0xac, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xad, 0x02, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0xae, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0xaf, 0x02, 0x00, 0x00, - 0xae, 0x02, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xb0, 0x02, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0xaf, 0x02, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb1, 0x02, 0x00, 0x00, - 0x9c, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xb2, 0x02, 0x00, 0x00, 0xb0, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xb3, 0x02, 0x00, 0x00, 0xb0, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb4, 0x02, 0x00, 0x00, - 0xb0, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0xb5, 0x02, 0x00, 0x00, 0xb2, 0x02, 0x00, 0x00, - 0xb3, 0x02, 0x00, 0x00, 0xb4, 0x02, 0x00, 0x00, 0xb1, 0x02, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xb6, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0xb6, 0x02, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0xb5, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xac, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xb7, 0x02, 0x00, 0x00, 0xaa, 0x02, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xb8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xb7, 0x02, 0x00, 0x00, 0xb9, 0x02, 0x00, 0x00, - 0xb8, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xb9, 0x02, 0x00, 0x00, - 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, 0xba, 0x02, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xbb, 0x02, 0x00, 0x00, 0xba, 0x02, 0x00, 0x00, - 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0xbc, 0x02, 0x00, 0x00, - 0x8d, 0x02, 0x00, 0x00, 0xbb, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xbd, 0x02, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xbe, 0x02, 0x00, 0x00, 0xbc, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xbf, 0x02, 0x00, 0x00, - 0xbc, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xc0, 0x02, 0x00, 0x00, 0xbc, 0x02, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, - 0xc1, 0x02, 0x00, 0x00, 0xbe, 0x02, 0x00, 0x00, 0xbf, 0x02, 0x00, 0x00, - 0xc0, 0x02, 0x00, 0x00, 0xbd, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x0b, 0x00, 0x00, 0x00, 0xc2, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, - 0x63, 0x00, 0x05, 0x00, 0xc2, 0x02, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, - 0xc1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xb8, 0x02, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0xc3, 0x02, 0x00, 0x00, - 0x8d, 0x02, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xc4, 0x02, 0x00, 0x00, 0xaa, 0x02, 0x00, 0x00, - 0x28, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xc5, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xc4, 0x02, 0x00, 0x00, - 0xc6, 0x02, 0x00, 0x00, 0xc5, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xc6, 0x02, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xc7, 0x02, 0x00, 0x00, 0xc3, 0x02, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x00, 0x00, - 0x37, 0x00, 0x00, 0x00, 0xc7, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xc9, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, - 0x39, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xca, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0xc9, 0x02, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0xcb, 0x02, 0x00, 0x00, - 0xca, 0x02, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xcc, 0x02, 0x00, 0x00, 0xca, 0x02, 0x00, 0x00, - 0x4a, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xcd, 0x02, 0x00, 0x00, 0xcc, 0x02, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0xce, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xcd, 0x02, 0x00, 0x00, - 0x4e, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xcf, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0xca, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xd0, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2e, 0x00, 0x00, 0x00, 0xcb, 0x02, 0x00, 0x00, 0xce, 0x02, 0x00, 0x00, - 0xcf, 0x02, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0xd1, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd2, 0x02, 0x00, 0x00, - 0xd1, 0x02, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xd3, 0x02, 0x00, 0x00, 0xd0, 0x02, 0x00, 0x00, 0xd2, 0x02, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd4, 0x02, 0x00, 0x00, - 0x9c, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xd5, 0x02, 0x00, 0x00, 0xd3, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xd6, 0x02, 0x00, 0x00, 0xd3, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd7, 0x02, 0x00, 0x00, - 0xd3, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, - 0x7f, 0x00, 0x00, 0x00, 0xd8, 0x02, 0x00, 0x00, 0xd5, 0x02, 0x00, 0x00, - 0xd6, 0x02, 0x00, 0x00, 0xd7, 0x02, 0x00, 0x00, 0xd4, 0x02, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xd9, 0x02, 0x00, 0x00, - 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, 0xd9, 0x02, 0x00, 0x00, - 0xb1, 0x00, 0x00, 0x00, 0xd8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xc5, 0x02, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, - 0xda, 0x02, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x67, 0x00, 0x05, 0x00, - 0x81, 0x00, 0x00, 0x00, 0xdb, 0x02, 0x00, 0x00, 0xda, 0x02, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xdc, 0x02, 0x00, 0x00, 0xdb, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdd, 0x02, 0x00, 0x00, - 0xdb, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xde, 0x02, 0x00, 0x00, 0xdc, 0x02, 0x00, 0x00, - 0xa6, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xdf, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xde, 0x02, 0x00, 0x00, - 0xe0, 0x02, 0x00, 0x00, 0xdf, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xe0, 0x02, 0x00, 0x00, 0xab, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xe1, 0x02, 0x00, 0x00, 0xdd, 0x02, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xdf, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xdf, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xe2, 0x02, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xc5, 0x02, 0x00, 0x00, - 0xe1, 0x02, 0x00, 0x00, 0xe0, 0x02, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, - 0x80, 0x00, 0x00, 0x00, 0xe3, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x3a, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, - 0xe4, 0x02, 0x00, 0x00, 0xe3, 0x02, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xe5, 0x02, 0x00, 0x00, 0xe4, 0x02, 0x00, 0x00, - 0x23, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xe6, 0x02, 0x00, 0x00, 0xe5, 0x02, 0x00, 0x00, 0xe2, 0x02, 0x00, 0x00, - 0x2a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xe7, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xe6, 0x02, 0x00, 0x00, - 0xe8, 0x02, 0x00, 0x00, 0xe7, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xe8, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xe9, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, 0x29, 0x00, 0x00, 0x00, - 0xea, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xea, 0x02, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xeb, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x73, 0x02, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00, - 0xeb, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xec, 0x02, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xe9, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xeb, 0x02, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xed, 0x02, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xee, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xed, 0x02, 0x00, 0x00, 0xef, 0x02, 0x00, 0x00, - 0xee, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xef, 0x02, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xf0, 0x02, 0x00, 0x00, - 0x41, 0x00, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xf1, 0x02, 0x00, 0x00, 0xf0, 0x02, 0x00, 0x00, - 0x9d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf2, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, - 0xf1, 0x02, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf3, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xf2, 0x02, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xf4, 0x02, 0x00, 0x00, - 0x42, 0x00, 0x00, 0x00, 0xf3, 0x02, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xf5, 0x02, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, - 0xf4, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf6, 0x02, 0x00, 0x00, 0xf5, 0x02, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, - 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0xf7, 0x02, 0x00, 0x00, - 0xa6, 0x02, 0x00, 0x00, 0xf6, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xee, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xee, 0x02, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, - 0xa6, 0x02, 0x00, 0x00, 0xeb, 0x02, 0x00, 0x00, 0xf7, 0x02, 0x00, 0x00, - 0xef, 0x02, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf9, 0x02, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xfa, 0x02, 0x00, 0x00, - 0xf8, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xfb, 0x02, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xfc, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0xfa, 0x02, 0x00, 0x00, 0xfb, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x00, 0x00, 0xf9, 0x02, 0x00, 0x00, 0xfc, 0x02, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xfe, 0x02, 0x00, 0x00, - 0xfd, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xfe, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, - 0xfd, 0x02, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, - 0x01, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xff, 0x02, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xff, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, - 0xee, 0x02, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xe9, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xe9, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x04, 0x03, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00, - 0x03, 0x03, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2b, 0x00, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, - 0x39, 0x00, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x06, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, - 0x05, 0x03, 0x00, 0x00, 0xc3, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x08, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, - 0x29, 0x00, 0x00, 0x00, 0x09, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x09, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x0a, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x73, 0x02, 0x00, 0x00, - 0x0b, 0x03, 0x00, 0x00, 0x0a, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x0b, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x08, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x0a, 0x03, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, - 0x05, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x0d, 0x03, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x0e, 0x03, 0x00, 0x00, - 0x0d, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xee, 0x02, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0xef, 0x02, 0x00, 0x00, 0xee, 0x02, 0x00, 0x00, + 0xed, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xe2, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xe2, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0xf0, 0x02, 0x00, 0x00, 0xe8, 0x02, 0x00, 0x00, 0xe3, 0x02, 0x00, 0x00, + 0xef, 0x02, 0x00, 0x00, 0xe4, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xf1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x4e, 0x02, 0x00, 0x00, 0xf2, 0x02, 0x00, 0x00, 0xf3, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xf2, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xf4, 0x02, 0x00, 0x00, 0xf0, 0x02, 0x00, 0x00, + 0xf0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xf1, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xf3, 0x02, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xf5, 0x02, 0x00, 0x00, 0xf0, 0x02, 0x00, 0x00, + 0xf0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xf6, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0xf5, 0x02, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xf7, 0x02, 0x00, 0x00, + 0xf6, 0x02, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, 0xf6, 0x02, 0x00, 0x00, + 0x4d, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xf9, 0x02, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xfa, 0x02, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xf9, 0x02, 0x00, 0x00, + 0x51, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xfb, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, + 0x53, 0x00, 0x00, 0x00, 0xf6, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xfc, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2e, 0x00, 0x00, 0x00, 0xf7, 0x02, 0x00, 0x00, 0xfa, 0x02, 0x00, 0x00, + 0xfb, 0x02, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xf1, 0x02, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xf1, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, 0xf4, 0x02, 0x00, 0x00, + 0xf2, 0x02, 0x00, 0x00, 0xfc, 0x02, 0x00, 0x00, 0xf3, 0x02, 0x00, 0x00, + 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xfe, 0x02, 0x00, 0x00, + 0xfd, 0x02, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, + 0xbb, 0x02, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x01, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x01, 0x03, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x4e, 0x02, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, + 0x02, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x03, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x02, 0x03, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x04, 0x03, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, + 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x06, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x07, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x06, 0x03, 0x00, 0x00, + 0x08, 0x03, 0x00, 0x00, 0x09, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x08, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x0a, 0x03, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0b, 0x03, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x0a, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x0b, 0x03, 0x00, 0x00, + 0x05, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x0d, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x07, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x09, 0x03, 0x00, 0x00, + 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x0e, 0x03, 0x00, 0x00, + 0x05, 0x03, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x0e, 0x03, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x11, 0x03, 0x00, 0x00, + 0x0e, 0x03, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x0f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x10, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x12, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x13, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x12, 0x03, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x14, 0x03, 0x00, 0x00, - 0x13, 0x03, 0x00, 0x00, 0x0d, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x15, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x14, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x0f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x11, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x16, 0x03, 0x00, 0x00, 0x0d, 0x03, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x17, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x16, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, - 0x17, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x18, 0x03, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x19, 0x03, 0x00, 0x00, - 0x05, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x00, 0x00, 0x19, 0x03, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1b, 0x03, 0x00, 0x00, - 0x1a, 0x03, 0x00, 0x00, 0x0d, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x1c, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x1b, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x17, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x17, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x1d, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x11, 0x03, 0x00, 0x00, - 0x1c, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x11, 0x03, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x12, 0x03, 0x00, 0x00, 0x11, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x13, 0x03, 0x00, 0x00, 0x12, 0x03, 0x00, 0x00, + 0x05, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x14, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x13, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x0f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x0f, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1e, 0x03, 0x00, 0x00, - 0x15, 0x03, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x1d, 0x03, 0x00, 0x00, - 0x17, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x1f, 0x03, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x20, 0x03, 0x00, 0x00, - 0x1f, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x20, 0x03, 0x00, 0x00, 0x22, 0x03, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x23, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0x1f, 0x03, 0x00, 0x00, - 0x51, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x25, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x24, 0x03, 0x00, 0x00, - 0x26, 0x03, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x26, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x27, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x7f, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, - 0x27, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x29, 0x03, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x1f, 0x03, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x2a, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x1e, 0x03, 0x00, 0x00, - 0x29, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x25, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x25, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x2b, 0x03, 0x00, 0x00, 0x1e, 0x03, 0x00, 0x00, - 0x23, 0x03, 0x00, 0x00, 0x2a, 0x03, 0x00, 0x00, 0x26, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x21, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x22, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x2c, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x2d, 0x03, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x2e, 0x03, 0x00, 0x00, 0x2d, 0x03, 0x00, 0x00, - 0x1f, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x2f, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, - 0x1e, 0x03, 0x00, 0x00, 0x2e, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x21, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x21, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, - 0x2f, 0x03, 0x00, 0x00, 0x22, 0x03, 0x00, 0x00, 0x2b, 0x03, 0x00, 0x00, - 0x25, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x31, 0x03, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x32, 0x03, 0x00, 0x00, - 0x31, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x33, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x32, 0x03, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x35, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, - 0x51, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x37, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x36, 0x03, 0x00, 0x00, - 0x38, 0x03, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x38, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x39, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x7f, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3a, 0x03, 0x00, 0x00, - 0x39, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x3b, 0x03, 0x00, 0x00, 0x3a, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3c, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, - 0x3b, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x37, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x37, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, - 0x35, 0x03, 0x00, 0x00, 0x3c, 0x03, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x33, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x34, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x3e, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3f, 0x03, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x3e, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x3f, 0x03, 0x00, 0x00, - 0x31, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x41, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, - 0x30, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x33, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x33, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x42, 0x03, 0x00, 0x00, - 0x41, 0x03, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x3d, 0x03, 0x00, 0x00, - 0x37, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x43, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0x42, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x44, 0x03, 0x00, 0x00, - 0x0c, 0x03, 0x00, 0x00, 0x43, 0x03, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x05, 0x03, 0x00, 0x00, - 0x44, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x08, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x08, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x46, 0x03, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, - 0x0b, 0x03, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x33, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xe7, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xe7, 0x02, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x47, 0x03, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00, 0xdf, 0x02, 0x00, 0x00, - 0x06, 0x03, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x48, 0x03, 0x00, 0x00, 0x8d, 0x02, 0x00, 0x00, - 0xdf, 0x02, 0x00, 0x00, 0x46, 0x03, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, - 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x49, 0x03, 0x00, 0x00, - 0x48, 0x03, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x4a, 0x03, 0x00, 0x00, 0x49, 0x03, 0x00, 0x00, - 0x3b, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x4b, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x15, 0x03, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x09, 0x03, 0x00, 0x00, 0x14, 0x03, 0x00, 0x00, + 0x10, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x07, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x07, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x16, 0x03, 0x00, 0x00, 0x0d, 0x03, 0x00, 0x00, + 0x08, 0x03, 0x00, 0x00, 0x15, 0x03, 0x00, 0x00, 0x0f, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, + 0x04, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x19, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x18, 0x03, 0x00, 0x00, + 0x1a, 0x03, 0x00, 0x00, 0x1b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x1b, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x1c, 0x03, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x1d, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x1c, 0x03, 0x00, 0x00, 0x1e, 0x03, 0x00, 0x00, + 0x1d, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1e, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x1f, 0x03, 0x00, 0x00, + 0xfd, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x20, 0x03, 0x00, 0x00, 0x1f, 0x03, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x21, 0x03, 0x00, 0x00, + 0x20, 0x03, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x22, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x00, 0x00, 0x16, 0x03, 0x00, 0x00, 0x21, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x1d, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x1d, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x23, 0x03, 0x00, 0x00, 0x16, 0x03, 0x00, 0x00, 0x1b, 0x03, 0x00, 0x00, + 0x22, 0x03, 0x00, 0x00, 0x1e, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x19, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1a, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, + 0xfd, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x24, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x26, 0x03, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x16, 0x03, 0x00, 0x00, + 0x26, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x19, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x19, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00, + 0x1a, 0x03, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x1d, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, + 0x04, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x2a, 0x03, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x2b, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x2a, 0x03, 0x00, 0x00, + 0x2c, 0x03, 0x00, 0x00, 0x2d, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x2d, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x2e, 0x03, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x2e, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, + 0x2f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x30, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, + 0xfd, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x32, 0x03, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x33, 0x03, 0x00, 0x00, + 0x32, 0x03, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x33, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x2f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x2f, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x35, 0x03, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x2d, 0x03, 0x00, 0x00, + 0x34, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x2b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x2c, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x36, 0x03, 0x00, 0x00, + 0xfd, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x36, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x38, 0x03, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x39, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, + 0x38, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x2b, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x2b, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x3a, 0x03, 0x00, 0x00, 0x39, 0x03, 0x00, 0x00, + 0x2c, 0x03, 0x00, 0x00, 0x35, 0x03, 0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3b, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x3a, 0x03, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x3c, 0x03, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, + 0x3b, 0x03, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x3d, 0x03, 0x00, 0x00, 0xfd, 0x02, 0x00, 0x00, 0x3c, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x00, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x3e, 0x03, 0x00, 0x00, 0xff, 0x02, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, + 0x3d, 0x03, 0x00, 0x00, 0x2b, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xe0, 0x02, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xe0, 0x02, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3f, 0x03, 0x00, 0x00, + 0xa0, 0x02, 0x00, 0x00, 0xd8, 0x02, 0x00, 0x00, 0xfe, 0x02, 0x00, 0x00, + 0x00, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x40, 0x03, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0xd8, 0x02, 0x00, 0x00, + 0x3e, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x41, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, + 0x17, 0x00, 0x00, 0x00, 0xbb, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x42, 0x03, 0x00, 0x00, 0xd2, 0x02, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x43, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x42, 0x03, 0x00, 0x00, 0x44, 0x03, 0x00, 0x00, + 0x43, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x44, 0x03, 0x00, 0x00, + 0xbc, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, + 0x41, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x43, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x43, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x46, 0x03, 0x00, 0x00, + 0x1c, 0x00, 0x00, 0x00, 0xe0, 0x02, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, + 0x44, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x47, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x46, 0x03, 0x00, 0x00, + 0x48, 0x03, 0x00, 0x00, 0x49, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x48, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x47, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x49, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x4a, 0x03, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, + 0x3f, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x4b, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x4a, 0x03, 0x00, 0x00, 0x4c, 0x03, 0x00, 0x00, 0x4d, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x4c, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x4b, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x4d, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x4e, 0x03, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, - 0x47, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x4f, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x4e, 0x03, 0x00, 0x00, - 0x50, 0x03, 0x00, 0x00, 0x51, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x50, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x52, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0x47, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x53, 0x03, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, - 0x52, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x4f, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x51, 0x03, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x54, 0x03, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, - 0x47, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x55, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x54, 0x03, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x56, 0x03, 0x00, 0x00, 0x49, 0x03, 0x00, 0x00, - 0x55, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x57, 0x03, 0x00, 0x00, 0x56, 0x03, 0x00, 0x00, 0x49, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x4f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x4f, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x58, 0x03, 0x00, 0x00, 0x53, 0x03, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00, - 0x57, 0x03, 0x00, 0x00, 0x51, 0x03, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x59, 0x03, 0x00, 0x00, 0x48, 0x03, 0x00, 0x00, - 0x58, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x5a, 0x03, 0x00, 0x00, 0x59, 0x03, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x5b, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x5a, 0x03, 0x00, 0x00, - 0x6e, 0x00, 0x04, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x5c, 0x03, 0x00, 0x00, - 0x5b, 0x03, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x5d, 0x03, 0x00, 0x00, 0x5c, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x5e, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x5a, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x5f, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x5e, 0x03, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, - 0x5d, 0x03, 0x00, 0x00, 0x5f, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x61, 0x03, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, - 0x8d, 0x00, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x62, 0x03, 0x00, 0x00, 0x48, 0x03, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x63, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x62, 0x03, 0x00, 0x00, - 0x6e, 0x00, 0x04, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x64, 0x03, 0x00, 0x00, - 0x63, 0x03, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x65, 0x03, 0x00, 0x00, 0x64, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x66, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x62, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x67, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x66, 0x03, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, - 0x65, 0x03, 0x00, 0x00, 0x67, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x69, 0x03, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, - 0x8d, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x1f, 0x00, 0x00, 0x00, - 0x6a, 0x03, 0x00, 0x00, 0x61, 0x03, 0x00, 0x00, 0x61, 0x03, 0x00, 0x00, + 0x4c, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x4e, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x3f, 0x03, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x4f, 0x03, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, + 0x4e, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x4b, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x4d, 0x03, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, + 0x3f, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x51, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x50, 0x03, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x52, 0x03, 0x00, 0x00, 0x41, 0x03, 0x00, 0x00, + 0x51, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x53, 0x03, 0x00, 0x00, 0x52, 0x03, 0x00, 0x00, 0x41, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x4b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x4b, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x54, 0x03, 0x00, 0x00, 0x4f, 0x03, 0x00, 0x00, 0x4c, 0x03, 0x00, 0x00, + 0x53, 0x03, 0x00, 0x00, 0x4d, 0x03, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x55, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, + 0x54, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x56, 0x03, 0x00, 0x00, 0x55, 0x03, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x57, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x56, 0x03, 0x00, 0x00, + 0x6e, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, 0x58, 0x03, 0x00, 0x00, + 0x57, 0x03, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x59, 0x03, 0x00, 0x00, 0x58, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x5a, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x56, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x5b, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x00, 0x00, 0x5a, 0x03, 0x00, 0x00, 0x79, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x5c, 0x03, 0x00, 0x00, + 0x59, 0x03, 0x00, 0x00, 0x5b, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x5d, 0x03, 0x00, 0x00, 0x5c, 0x03, 0x00, 0x00, + 0x90, 0x00, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x5e, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x5f, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x5e, 0x03, 0x00, 0x00, + 0x6e, 0x00, 0x04, 0x00, 0x26, 0x00, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, + 0x5f, 0x03, 0x00, 0x00, 0x6f, 0x00, 0x04, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x61, 0x03, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x62, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x5e, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x63, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x1a, 0x00, 0x00, 0x00, 0x62, 0x03, 0x00, 0x00, 0x79, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x64, 0x03, 0x00, 0x00, + 0x61, 0x03, 0x00, 0x00, 0x63, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x65, 0x03, 0x00, 0x00, 0x64, 0x03, 0x00, 0x00, + 0x90, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x66, 0x03, 0x00, 0x00, 0x5d, 0x03, 0x00, 0x00, 0x5d, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x6b, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x42, 0x00, 0x00, 0x00, 0x6a, 0x03, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0x6c, 0x03, 0x00, 0x00, 0x69, 0x03, 0x00, 0x00, - 0x69, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0x6d, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x6c, 0x03, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x6e, 0x03, 0x00, 0x00, - 0x6d, 0x03, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x6f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x6e, 0x03, 0x00, 0x00, 0x70, 0x03, 0x00, 0x00, 0x71, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x70, 0x03, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0x72, 0x03, 0x00, 0x00, 0x6d, 0x03, 0x00, 0x00, - 0x6d, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, - 0x73, 0x03, 0x00, 0x00, 0x6c, 0x03, 0x00, 0x00, 0x72, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x6f, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x71, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x6f, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x6f, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1f, 0x00, 0x00, 0x00, 0x74, 0x03, 0x00, 0x00, 0x73, 0x03, 0x00, 0x00, - 0x70, 0x03, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x71, 0x03, 0x00, 0x00, - 0x8e, 0x00, 0x05, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x75, 0x03, 0x00, 0x00, - 0x74, 0x03, 0x00, 0x00, 0x6b, 0x03, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x76, 0x03, 0x00, 0x00, 0x61, 0x03, 0x00, 0x00, - 0x75, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x77, 0x03, 0x00, 0x00, 0x76, 0x03, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0x78, 0x03, 0x00, 0x00, - 0x77, 0x03, 0x00, 0x00, 0x77, 0x03, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x79, 0x03, 0x00, 0x00, 0x78, 0x03, 0x00, 0x00, - 0x77, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x7a, 0x03, 0x00, 0x00, 0x79, 0x03, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x7b, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfb, 0x00, 0x03, 0x00, 0x29, 0x00, 0x00, 0x00, 0x7c, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x7c, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x7d, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, - 0x29, 0x00, 0x00, 0x00, 0x7e, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x7e, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x7f, 0x03, 0x00, 0x00, 0x7a, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x9c, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, - 0x7f, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x81, 0x03, 0x00, 0x00, 0x7f, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, - 0x81, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x83, 0x03, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, 0x83, 0x03, 0x00, 0x00, - 0x7f, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x85, 0x03, 0x00, 0x00, 0x7a, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x86, 0x03, 0x00, 0x00, 0x85, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, 0x85, 0x03, 0x00, 0x00, - 0xa6, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x88, 0x03, 0x00, 0x00, - 0x86, 0x03, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x89, 0x03, 0x00, 0x00, 0x88, 0x03, 0x00, 0x00, - 0xa9, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0x8a, 0x03, 0x00, 0x00, - 0x89, 0x03, 0x00, 0x00, 0x85, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x8b, 0x03, 0x00, 0x00, - 0x7a, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x04, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x8c, 0x03, 0x00, 0x00, 0x8b, 0x03, 0x00, 0x00, - 0x9d, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x8d, 0x03, 0x00, 0x00, - 0x8b, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x8e, 0x03, 0x00, 0x00, 0x8c, 0x03, 0x00, 0x00, 0x8d, 0x03, 0x00, 0x00, - 0xa8, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x8f, 0x03, 0x00, 0x00, - 0x8e, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x90, 0x03, 0x00, 0x00, 0x8f, 0x03, 0x00, 0x00, 0x8b, 0x03, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x91, 0x03, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, 0x8a, 0x03, 0x00, 0x00, - 0x90, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x92, 0x03, 0x00, 0x00, 0x91, 0x03, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0xbd, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x93, 0x03, 0x00, 0x00, - 0x92, 0x03, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0x94, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0x93, 0x03, 0x00, 0x00, 0x95, 0x03, 0x00, 0x00, 0x94, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x95, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x7d, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x94, 0x03, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x96, 0x03, 0x00, 0x00, - 0x92, 0x03, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, - 0x96, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0x98, 0x03, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x99, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x98, 0x03, 0x00, 0x00, 0x9a, 0x03, 0x00, 0x00, - 0x99, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x9a, 0x03, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x9b, 0x03, 0x00, 0x00, - 0x97, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x9c, 0x03, 0x00, 0x00, 0x9b, 0x03, 0x00, 0x00, - 0x84, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x99, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x99, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0x9d, 0x03, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, - 0x94, 0x03, 0x00, 0x00, 0x9c, 0x03, 0x00, 0x00, 0x9a, 0x03, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0x9e, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0x9d, 0x03, 0x00, 0x00, 0x9f, 0x03, 0x00, 0x00, - 0x9e, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x9f, 0x03, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xa0, 0x03, 0x00, 0x00, - 0x97, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xa1, 0x03, 0x00, 0x00, 0xa0, 0x03, 0x00, 0x00, - 0x84, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xa2, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0xa1, 0x03, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xa3, 0x03, 0x00, 0x00, 0xa2, 0x03, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xa4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xa3, 0x03, 0x00, 0x00, 0xa5, 0x03, 0x00, 0x00, - 0xa6, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa5, 0x03, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xa7, 0x03, 0x00, 0x00, - 0xa0, 0x03, 0x00, 0x00, 0xa1, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xa4, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa6, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xa4, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xa4, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xa8, 0x03, 0x00, 0x00, 0xa7, 0x03, 0x00, 0x00, 0xa5, 0x03, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0xa6, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xa9, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x4f, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xa8, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x9e, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x9e, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xaa, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x99, 0x03, 0x00, 0x00, - 0xa9, 0x03, 0x00, 0x00, 0xa4, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xab, 0x03, 0x00, 0x00, 0x8a, 0x03, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xac, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xab, 0x03, 0x00, 0x00, - 0xad, 0x03, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xad, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xae, 0x03, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xaf, 0x03, 0x00, 0x00, - 0xae, 0x03, 0x00, 0x00, 0x8a, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xac, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xac, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xb0, 0x03, 0x00, 0x00, - 0x2a, 0x00, 0x00, 0x00, 0x9e, 0x03, 0x00, 0x00, 0xaf, 0x03, 0x00, 0x00, - 0xad, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xb1, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xb0, 0x03, 0x00, 0x00, - 0xb2, 0x03, 0x00, 0x00, 0xb1, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xb2, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xb3, 0x03, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb4, 0x03, 0x00, 0x00, - 0xb3, 0x03, 0x00, 0x00, 0x8a, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0xb4, 0x03, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xb6, 0x03, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00, - 0x44, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xb7, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xb6, 0x03, 0x00, 0x00, - 0xb8, 0x03, 0x00, 0x00, 0xb9, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xb8, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xba, 0x03, 0x00, 0x00, 0xb3, 0x03, 0x00, 0x00, 0xb4, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xb7, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xb9, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xb7, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xb7, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xbb, 0x03, 0x00, 0x00, 0xba, 0x03, 0x00, 0x00, - 0xb8, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xb9, 0x03, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xbc, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0xaa, 0x03, 0x00, 0x00, - 0xbb, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xb1, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xb1, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xbd, 0x03, 0x00, 0x00, 0xaa, 0x03, 0x00, 0x00, - 0xac, 0x03, 0x00, 0x00, 0xbc, 0x03, 0x00, 0x00, 0xb7, 0x03, 0x00, 0x00, - 0xb8, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xbe, 0x03, 0x00, 0x00, - 0x90, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0xbf, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xbe, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xbf, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xc1, 0x03, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xc2, 0x03, 0x00, 0x00, 0xc1, 0x03, 0x00, 0x00, 0x90, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0xbf, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xbf, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xc3, 0x03, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0xb1, 0x03, 0x00, 0x00, - 0xc2, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0xc4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xc3, 0x03, 0x00, 0x00, 0xc5, 0x03, 0x00, 0x00, 0xc4, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xc5, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xc6, 0x03, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xc7, 0x03, 0x00, 0x00, 0xc6, 0x03, 0x00, 0x00, 0x90, 0x03, 0x00, 0x00, - 0x0c, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0xc8, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc7, 0x03, 0x00, 0x00, - 0xba, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xc9, 0x03, 0x00, 0x00, - 0xc8, 0x03, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, - 0xca, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, - 0xc9, 0x03, 0x00, 0x00, 0xcb, 0x03, 0x00, 0x00, 0xcc, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xcb, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xcd, 0x03, 0x00, 0x00, 0xc6, 0x03, 0x00, 0x00, - 0xc7, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xca, 0x03, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xcc, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xca, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xca, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xce, 0x03, 0x00, 0x00, - 0xcd, 0x03, 0x00, 0x00, 0xcb, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0xcc, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xcf, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, - 0xbd, 0x03, 0x00, 0x00, 0xce, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0xc4, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xc4, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd0, 0x03, 0x00, 0x00, - 0xbd, 0x03, 0x00, 0x00, 0xbf, 0x03, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, - 0xca, 0x03, 0x00, 0x00, 0x9c, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xd1, 0x03, 0x00, 0x00, 0xd0, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xd2, 0x03, 0x00, 0x00, 0xd0, 0x03, 0x00, 0x00, - 0xa6, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xd3, 0x03, 0x00, 0x00, - 0xd1, 0x03, 0x00, 0x00, 0xd2, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xd4, 0x03, 0x00, 0x00, 0xd3, 0x03, 0x00, 0x00, - 0xa9, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd5, 0x03, 0x00, 0x00, - 0xd4, 0x03, 0x00, 0x00, 0xd0, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd6, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xd5, 0x03, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x7d, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x7d, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0xd7, 0x03, 0x00, 0x00, - 0x27, 0x00, 0x00, 0x00, 0x95, 0x03, 0x00, 0x00, 0xd6, 0x03, 0x00, 0x00, - 0xc4, 0x03, 0x00, 0x00, 0xbe, 0x00, 0x05, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xd8, 0x03, 0x00, 0x00, 0xd7, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0xf7, 0x00, 0x03, 0x00, 0xd9, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xfa, 0x00, 0x04, 0x00, 0xd8, 0x03, 0x00, 0x00, 0xda, 0x03, 0x00, 0x00, - 0xd9, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xda, 0x03, 0x00, 0x00, - 0xf9, 0x00, 0x02, 0x00, 0x7b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0xd9, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xdb, 0x03, 0x00, 0x00, 0x7a, 0x03, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x85, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0xdc, 0x03, 0x00, 0x00, - 0xdb, 0x03, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xdd, 0x03, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, - 0xdc, 0x03, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xde, 0x03, 0x00, 0x00, 0x7a, 0x03, 0x00, 0x00, 0xdd, 0x03, 0x00, 0x00, - 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, 0xdf, 0x03, 0x00, 0x00, - 0xde, 0x03, 0x00, 0x00, 0xd7, 0x03, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xdd, 0x03, 0x00, 0x00, - 0xdf, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, - 0xe1, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0xdd, 0x03, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xe3, 0x03, 0x00, 0x00, 0xe1, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x9c, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xe4, 0x03, 0x00, 0x00, - 0xe2, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xe5, 0x03, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xe6, 0x03, 0x00, 0x00, 0xe4, 0x03, 0x00, 0x00, - 0xe5, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xe7, 0x03, 0x00, 0x00, 0xe6, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, 0xe7, 0x03, 0x00, 0x00, - 0xe2, 0x03, 0x00, 0x00, 0xe3, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xe9, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xea, 0x03, 0x00, 0x00, 0xe1, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x9c, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xeb, 0x03, 0x00, 0x00, - 0xe9, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xec, 0x03, 0x00, 0x00, 0xe9, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xed, 0x03, 0x00, 0x00, 0xeb, 0x03, 0x00, 0x00, - 0xec, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xee, 0x03, 0x00, 0x00, 0xed, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xef, 0x03, 0x00, 0x00, 0xee, 0x03, 0x00, 0x00, - 0xe9, 0x03, 0x00, 0x00, 0xea, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xf1, 0x03, 0x00, 0x00, 0xe1, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x9c, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xf2, 0x03, 0x00, 0x00, - 0xf0, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xf3, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, - 0x1a, 0x00, 0x00, 0x00, 0xf4, 0x03, 0x00, 0x00, 0xf2, 0x03, 0x00, 0x00, - 0xf3, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x00, 0x00, - 0xf5, 0x03, 0x00, 0x00, 0xf4, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, - 0x11, 0x00, 0x00, 0x00, 0xf6, 0x03, 0x00, 0x00, 0xf5, 0x03, 0x00, 0x00, - 0xf0, 0x03, 0x00, 0x00, 0xf1, 0x03, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, - 0x15, 0x00, 0x00, 0x00, 0xf7, 0x03, 0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, - 0xef, 0x03, 0x00, 0x00, 0xf6, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x7b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x7b, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, - 0x7a, 0x03, 0x00, 0x00, 0xda, 0x03, 0x00, 0x00, 0xf7, 0x03, 0x00, 0x00, - 0xd9, 0x03, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0xf9, 0x03, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0xfa, 0x03, 0x00, 0x00, - 0xf9, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xfb, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0xfa, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, - 0xfb, 0x03, 0x00, 0x00, 0xfb, 0x03, 0x00, 0x00, 0xfb, 0x03, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0xfd, 0x03, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, - 0xf8, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, - 0x4b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x4b, 0x03, 0x00, 0x00, - 0xf5, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00, - 0xa6, 0x02, 0x00, 0x00, 0x4c, 0x03, 0x00, 0x00, 0xfd, 0x03, 0x00, 0x00, - 0x7b, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0xff, 0x03, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, - 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, - 0xff, 0x03, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0xa7, 0x02, 0x00, 0x00, - 0x3e, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x02, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x67, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x00, 0x00, 0x66, 0x03, 0x00, 0x00, 0x4f, 0x00, 0x07, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, 0x65, 0x03, 0x00, 0x00, + 0x65, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x69, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, + 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x6a, 0x03, 0x00, 0x00, + 0x69, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x6b, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x6a, 0x03, 0x00, 0x00, 0x6c, 0x03, 0x00, 0x00, 0x6d, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x6c, 0x03, 0x00, 0x00, 0x50, 0x00, 0x05, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x6e, 0x03, 0x00, 0x00, 0x69, 0x03, 0x00, 0x00, + 0x69, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x6f, 0x03, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, 0x6e, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x6b, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x6d, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x6b, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x6b, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x70, 0x03, 0x00, 0x00, 0x6f, 0x03, 0x00, 0x00, + 0x6c, 0x03, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x6d, 0x03, 0x00, 0x00, + 0x8e, 0x00, 0x05, 0x00, 0x20, 0x00, 0x00, 0x00, 0x71, 0x03, 0x00, 0x00, + 0x70, 0x03, 0x00, 0x00, 0x67, 0x03, 0x00, 0x00, 0x4f, 0x00, 0x08, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x72, 0x03, 0x00, 0x00, 0x5d, 0x03, 0x00, 0x00, + 0x71, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x73, 0x03, 0x00, 0x00, 0x72, 0x03, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x74, 0x03, 0x00, 0x00, + 0x73, 0x03, 0x00, 0x00, 0x73, 0x03, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x75, 0x03, 0x00, 0x00, 0x74, 0x03, 0x00, 0x00, + 0x73, 0x03, 0x00, 0x00, 0x90, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x76, 0x03, 0x00, 0x00, 0x75, 0x03, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x77, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfb, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, 0x78, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x78, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x79, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, + 0x24, 0x00, 0x00, 0x00, 0x7a, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x7a, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x7b, 0x03, 0x00, 0x00, 0x76, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x9c, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x7c, 0x03, 0x00, 0x00, + 0x7b, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x7d, 0x03, 0x00, 0x00, 0x7b, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x7e, 0x03, 0x00, 0x00, 0x7c, 0x03, 0x00, 0x00, + 0x7d, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x7f, 0x03, 0x00, 0x00, 0x7e, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x7f, 0x03, 0x00, 0x00, + 0x7b, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x81, 0x03, 0x00, 0x00, 0x76, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x82, 0x03, 0x00, 0x00, 0x81, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x83, 0x03, 0x00, 0x00, 0x81, 0x03, 0x00, 0x00, + 0xa6, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, + 0x82, 0x03, 0x00, 0x00, 0x83, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x85, 0x03, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, + 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x86, 0x03, 0x00, 0x00, + 0x85, 0x03, 0x00, 0x00, 0x81, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, + 0x76, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x88, 0x03, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, + 0x9d, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x89, 0x03, 0x00, 0x00, + 0x87, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x8a, 0x03, 0x00, 0x00, 0x88, 0x03, 0x00, 0x00, 0x89, 0x03, 0x00, 0x00, + 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x8b, 0x03, 0x00, 0x00, + 0x8a, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x8c, 0x03, 0x00, 0x00, 0x8b, 0x03, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x8d, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x86, 0x03, 0x00, 0x00, + 0x8c, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x8e, 0x03, 0x00, 0x00, 0x8d, 0x03, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, + 0xbd, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x8f, 0x03, 0x00, 0x00, + 0x8e, 0x03, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x90, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x8f, 0x03, 0x00, 0x00, 0x91, 0x03, 0x00, 0x00, 0x90, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x91, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x79, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x90, 0x03, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x92, 0x03, 0x00, 0x00, + 0x8e, 0x03, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x93, 0x03, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, + 0x92, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x94, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x95, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x94, 0x03, 0x00, 0x00, 0x96, 0x03, 0x00, 0x00, + 0x95, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x96, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, + 0x93, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x98, 0x03, 0x00, 0x00, 0x97, 0x03, 0x00, 0x00, + 0x80, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x95, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x95, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x99, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, + 0x90, 0x03, 0x00, 0x00, 0x98, 0x03, 0x00, 0x00, 0x96, 0x03, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x9a, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x99, 0x03, 0x00, 0x00, 0x9b, 0x03, 0x00, 0x00, + 0x9a, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x9b, 0x03, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x9c, 0x03, 0x00, 0x00, + 0x93, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x9d, 0x03, 0x00, 0x00, 0x9c, 0x03, 0x00, 0x00, + 0x80, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x9e, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x9d, 0x03, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x9f, 0x03, 0x00, 0x00, 0x9e, 0x03, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xa0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x9f, 0x03, 0x00, 0x00, 0xa1, 0x03, 0x00, 0x00, + 0xa2, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa1, 0x03, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xa3, 0x03, 0x00, 0x00, + 0x9c, 0x03, 0x00, 0x00, 0x9d, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xa0, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa2, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xa0, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xa0, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xa4, 0x03, 0x00, 0x00, 0xa3, 0x03, 0x00, 0x00, 0xa1, 0x03, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0xa2, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xa5, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x4f, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xa4, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x9a, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x9a, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xa6, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x95, 0x03, 0x00, 0x00, + 0xa5, 0x03, 0x00, 0x00, 0xa0, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xa7, 0x03, 0x00, 0x00, 0x86, 0x03, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xa8, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xa7, 0x03, 0x00, 0x00, + 0xa9, 0x03, 0x00, 0x00, 0xa8, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xa9, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xaa, 0x03, 0x00, 0x00, 0x93, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xab, 0x03, 0x00, 0x00, + 0xaa, 0x03, 0x00, 0x00, 0x86, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xa8, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xa8, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xac, 0x03, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0x9a, 0x03, 0x00, 0x00, 0xab, 0x03, 0x00, 0x00, + 0xa9, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xad, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xac, 0x03, 0x00, 0x00, + 0xae, 0x03, 0x00, 0x00, 0xad, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xae, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xaf, 0x03, 0x00, 0x00, 0x93, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xb0, 0x03, 0x00, 0x00, + 0xaf, 0x03, 0x00, 0x00, 0x86, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xb1, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0xb0, 0x03, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xb2, 0x03, 0x00, 0x00, 0xb1, 0x03, 0x00, 0x00, + 0x47, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0xb3, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0xb2, 0x03, 0x00, 0x00, + 0xb4, 0x03, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xb4, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xb6, 0x03, 0x00, 0x00, 0xaf, 0x03, 0x00, 0x00, 0xb0, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xb3, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xb5, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xb3, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xb3, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xb7, 0x03, 0x00, 0x00, 0xb6, 0x03, 0x00, 0x00, + 0xb4, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xb8, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0xa6, 0x03, 0x00, 0x00, + 0xb7, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xad, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xad, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xb9, 0x03, 0x00, 0x00, 0xa6, 0x03, 0x00, 0x00, + 0xa8, 0x03, 0x00, 0x00, 0xb8, 0x03, 0x00, 0x00, 0xb3, 0x03, 0x00, 0x00, + 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xba, 0x03, 0x00, 0x00, + 0x8c, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xbb, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xba, 0x03, 0x00, 0x00, 0xbc, 0x03, 0x00, 0x00, 0xbb, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xbc, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xbd, 0x03, 0x00, 0x00, 0x93, 0x03, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xbe, 0x03, 0x00, 0x00, 0xbd, 0x03, 0x00, 0x00, 0x8c, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0xbb, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xbb, 0x03, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xbf, 0x03, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0xad, 0x03, 0x00, 0x00, + 0xbe, 0x03, 0x00, 0x00, 0xbc, 0x03, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xbf, 0x03, 0x00, 0x00, 0xc1, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xc1, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xc2, 0x03, 0x00, 0x00, 0x93, 0x03, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xc3, 0x03, 0x00, 0x00, 0xc2, 0x03, 0x00, 0x00, 0x8c, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xc4, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc3, 0x03, 0x00, 0x00, + 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xc5, 0x03, 0x00, 0x00, + 0xc4, 0x03, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0xc6, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0xc5, 0x03, 0x00, 0x00, 0xc7, 0x03, 0x00, 0x00, 0xc8, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xc7, 0x03, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xc9, 0x03, 0x00, 0x00, 0xc2, 0x03, 0x00, 0x00, + 0xc3, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xc6, 0x03, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xc8, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xc6, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xc6, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xca, 0x03, 0x00, 0x00, + 0xc9, 0x03, 0x00, 0x00, 0xc7, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0xc8, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xcb, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, + 0xb9, 0x03, 0x00, 0x00, 0xca, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0xc0, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xc0, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xcc, 0x03, 0x00, 0x00, + 0xb9, 0x03, 0x00, 0x00, 0xbb, 0x03, 0x00, 0x00, 0xcb, 0x03, 0x00, 0x00, + 0xc6, 0x03, 0x00, 0x00, 0x9c, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xcd, 0x03, 0x00, 0x00, 0xcc, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xce, 0x03, 0x00, 0x00, 0xcc, 0x03, 0x00, 0x00, + 0xa6, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, + 0xcd, 0x03, 0x00, 0x00, 0xce, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xd0, 0x03, 0x00, 0x00, 0xcf, 0x03, 0x00, 0x00, + 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd1, 0x03, 0x00, 0x00, + 0xd0, 0x03, 0x00, 0x00, 0xcc, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd2, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xd1, 0x03, 0x00, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x79, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x79, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd3, 0x03, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x91, 0x03, 0x00, 0x00, 0xd2, 0x03, 0x00, 0x00, + 0xc0, 0x03, 0x00, 0x00, 0xbe, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xd4, 0x03, 0x00, 0x00, 0xd3, 0x03, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0xd5, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0xd4, 0x03, 0x00, 0x00, 0xd6, 0x03, 0x00, 0x00, + 0xd5, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0xd6, 0x03, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x77, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0xd5, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xd7, 0x03, 0x00, 0x00, 0x76, 0x03, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xd8, 0x03, 0x00, 0x00, + 0xd7, 0x03, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xd9, 0x03, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, + 0xd8, 0x03, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xda, 0x03, 0x00, 0x00, 0x76, 0x03, 0x00, 0x00, 0xd9, 0x03, 0x00, 0x00, + 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0xdb, 0x03, 0x00, 0x00, + 0xda, 0x03, 0x00, 0x00, 0xd3, 0x03, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xdc, 0x03, 0x00, 0x00, 0xd9, 0x03, 0x00, 0x00, + 0xdb, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, + 0xdd, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0xd9, 0x03, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xde, 0x03, 0x00, 0x00, 0xdc, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xdf, 0x03, 0x00, 0x00, 0xdd, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x9c, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, + 0xde, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xe1, 0x03, 0x00, 0x00, 0xde, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, + 0xe1, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xe3, 0x03, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xe4, 0x03, 0x00, 0x00, 0xe3, 0x03, 0x00, 0x00, + 0xde, 0x03, 0x00, 0x00, 0xdf, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xe5, 0x03, 0x00, 0x00, 0xdc, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xe6, 0x03, 0x00, 0x00, 0xdd, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x9c, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xe7, 0x03, 0x00, 0x00, + 0xe5, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xe8, 0x03, 0x00, 0x00, 0xe5, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xe9, 0x03, 0x00, 0x00, 0xe7, 0x03, 0x00, 0x00, + 0xe8, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xea, 0x03, 0x00, 0x00, 0xe9, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xeb, 0x03, 0x00, 0x00, 0xea, 0x03, 0x00, 0x00, + 0xe5, 0x03, 0x00, 0x00, 0xe6, 0x03, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xec, 0x03, 0x00, 0x00, 0xdc, 0x03, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xed, 0x03, 0x00, 0x00, 0xdd, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x9c, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xee, 0x03, 0x00, 0x00, + 0xec, 0x03, 0x00, 0x00, 0x9d, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xef, 0x03, 0x00, 0x00, 0xec, 0x03, 0x00, 0x00, 0xa6, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xee, 0x03, 0x00, 0x00, + 0xef, 0x03, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0xf1, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xf2, 0x03, 0x00, 0x00, 0xf1, 0x03, 0x00, 0x00, + 0xec, 0x03, 0x00, 0x00, 0xed, 0x03, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, + 0x16, 0x00, 0x00, 0x00, 0xf3, 0x03, 0x00, 0x00, 0xe4, 0x03, 0x00, 0x00, + 0xeb, 0x03, 0x00, 0x00, 0xf2, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x77, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x77, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xf4, 0x03, 0x00, 0x00, + 0x76, 0x03, 0x00, 0x00, 0xd6, 0x03, 0x00, 0x00, 0xf3, 0x03, 0x00, 0x00, + 0xd5, 0x03, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0xf5, 0x03, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0xf6, 0x03, 0x00, 0x00, + 0xf5, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xf7, 0x03, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0xf6, 0x03, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, + 0xf7, 0x03, 0x00, 0x00, 0xf7, 0x03, 0x00, 0x00, 0xf7, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, 0xf9, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x9e, 0x02, 0x00, 0x00, + 0xf4, 0x03, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x47, 0x03, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x47, 0x03, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0xfa, 0x03, 0x00, 0x00, + 0x9e, 0x02, 0x00, 0x00, 0x48, 0x03, 0x00, 0x00, 0xf9, 0x03, 0x00, 0x00, + 0x77, 0x03, 0x00, 0x00, 0x94, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xfb, 0x03, 0x00, 0x00, 0xfa, 0x03, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, + 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, + 0xfb, 0x03, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0xfd, 0x03, 0x00, 0x00, 0x9f, 0x02, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0xfe, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xfd, 0x03, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0x00, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, + 0x00, 0x04, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x02, 0x04, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, - 0x3c, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0x04, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x05, 0x04, 0x00, 0x00, - 0x04, 0x04, 0x00, 0x00, 0x83, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x06, 0x04, 0x00, 0x00, 0x05, 0x04, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x07, 0x04, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x06, 0x04, 0x00, 0x00, - 0x25, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x08, 0x04, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x07, 0x04, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, - 0x08, 0x04, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0x0a, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0b, 0x04, 0x00, 0x00, - 0x0a, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x0c, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, - 0x0b, 0x04, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x0d, 0x04, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, - 0x0c, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x0e, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, - 0x09, 0x04, 0x00, 0x00, 0x0d, 0x04, 0x00, 0x00, 0x0c, 0x04, 0x00, 0x00, - 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0f, 0x04, 0x00, 0x00, - 0x0e, 0x04, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00, - 0x0f, 0x04, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x11, 0x04, 0x00, 0x00, 0xa6, 0x02, 0x00, 0x00, 0x0e, 0x04, 0x00, 0x00, - 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, 0x12, 0x04, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x13, 0x04, 0x00, 0x00, 0x12, 0x04, 0x00, 0x00, - 0x50, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x04, 0x00, 0x00, - 0x13, 0x04, 0x00, 0x00, 0x13, 0x04, 0x00, 0x00, 0x13, 0x04, 0x00, 0x00, - 0x0c, 0x00, 0x08, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x04, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x11, 0x04, 0x00, 0x00, - 0x10, 0x04, 0x00, 0x00, 0x14, 0x04, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x16, 0x04, 0x00, 0x00, 0x15, 0x04, 0x00, 0x00, - 0xa3, 0x02, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x9f, 0x00, 0x00, 0x00, - 0x17, 0x04, 0x00, 0x00, 0x67, 0x02, 0x00, 0x00, 0x67, 0x02, 0x00, 0x00, - 0x67, 0x02, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x18, 0x04, 0x00, 0x00, 0x17, 0x04, 0x00, 0x00, 0xa4, 0x02, 0x00, 0x00, - 0x16, 0x04, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x9f, 0x00, 0x00, 0x00, - 0x19, 0x04, 0x00, 0x00, 0x66, 0x02, 0x00, 0x00, 0x66, 0x02, 0x00, 0x00, - 0x66, 0x02, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x1a, 0x04, 0x00, 0x00, 0x19, 0x04, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, - 0x18, 0x04, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x1b, 0x04, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x65, 0x02, 0x00, 0x00, - 0x1c, 0x04, 0x00, 0x00, 0x1b, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, - 0x1c, 0x04, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, - 0x1d, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, - 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1e, 0x04, 0x00, 0x00, - 0x1d, 0x04, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x15, 0x00, 0x00, 0x00, - 0x1f, 0x04, 0x00, 0x00, 0x1e, 0x04, 0x00, 0x00, 0x1e, 0x04, 0x00, 0x00, - 0x1e, 0x04, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x1b, 0x04, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0x1b, 0x04, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x1a, 0x04, 0x00, 0x00, - 0x4b, 0x03, 0x00, 0x00, 0x1f, 0x04, 0x00, 0x00, 0x1c, 0x04, 0x00, 0x00, - 0x0c, 0x00, 0x07, 0x00, 0x15, 0x00, 0x00, 0x00, 0x21, 0x04, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, - 0x26, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x22, 0x04, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x23, 0x04, 0x00, 0x00, - 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x24, 0x04, 0x00, 0x00, 0x21, 0x04, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, - 0x25, 0x04, 0x00, 0x00, 0x21, 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x50, 0x00, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, - 0x23, 0x04, 0x00, 0x00, 0x24, 0x04, 0x00, 0x00, 0x25, 0x04, 0x00, 0x00, - 0x22, 0x04, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, - 0x27, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, - 0x27, 0x04, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, - 0xf8, 0x00, 0x02, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x01, 0x00, + 0x27, 0x00, 0x00, 0x00, 0x81, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x04, 0x04, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x05, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, + 0x04, 0x04, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0x06, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x04, 0x00, 0x00, + 0x06, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x08, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x07, 0x04, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x08, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x0a, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0x05, 0x04, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0b, 0x04, 0x00, 0x00, + 0x0a, 0x04, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x00, 0x00, 0xfa, 0x03, 0x00, 0x00, + 0x0b, 0x04, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x0d, 0x04, 0x00, 0x00, 0x9e, 0x02, 0x00, 0x00, 0x0a, 0x04, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x0e, 0x04, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x0f, 0x04, 0x00, 0x00, 0x0e, 0x04, 0x00, 0x00, + 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, + 0x0f, 0x04, 0x00, 0x00, 0x0f, 0x04, 0x00, 0x00, 0x0f, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x08, 0x00, 0x16, 0x00, 0x00, 0x00, 0x11, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x0d, 0x04, 0x00, 0x00, + 0x0c, 0x04, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x8e, 0x00, 0x05, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x12, 0x04, 0x00, 0x00, 0x11, 0x04, 0x00, 0x00, + 0x9b, 0x02, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0xa2, 0x00, 0x00, 0x00, + 0x13, 0x04, 0x00, 0x00, 0x42, 0x02, 0x00, 0x00, 0x42, 0x02, 0x00, 0x00, + 0x42, 0x02, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x14, 0x04, 0x00, 0x00, 0x13, 0x04, 0x00, 0x00, 0x9c, 0x02, 0x00, 0x00, + 0x12, 0x04, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0xa2, 0x00, 0x00, 0x00, + 0x15, 0x04, 0x00, 0x00, 0x41, 0x02, 0x00, 0x00, 0x41, 0x02, 0x00, 0x00, + 0x41, 0x02, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x16, 0x04, 0x00, 0x00, 0x15, 0x04, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, + 0x14, 0x04, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x17, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x40, 0x02, 0x00, 0x00, + 0x18, 0x04, 0x00, 0x00, 0x17, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x18, 0x04, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x19, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x1a, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x1a, 0x04, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x1b, 0x04, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x1c, 0x04, 0x00, 0x00, 0x1b, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x1d, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x1c, 0x04, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x83, 0x00, 0x00, 0x00, + 0x1e, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x22, 0x00, 0x00, 0x00, 0x1f, 0x04, 0x00, 0x00, + 0x1e, 0x04, 0x00, 0x00, 0xaa, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x20, 0x04, 0x00, 0x00, 0x1f, 0x04, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x20, 0x04, 0x00, 0x00, 0x22, 0x04, 0x00, 0x00, + 0x21, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x22, 0x04, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x19, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x21, 0x04, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x23, 0x04, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, + 0x82, 0x00, 0x00, 0x00, 0x24, 0x04, 0x00, 0x00, 0x23, 0x04, 0x00, 0x00, + 0x88, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x25, 0x04, 0x00, 0x00, + 0x24, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x26, 0x04, 0x00, 0x00, 0x25, 0x04, 0x00, 0x00, + 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x27, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x26, 0x04, 0x00, 0x00, + 0x28, 0x04, 0x00, 0x00, 0x27, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x28, 0x04, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x29, 0x04, 0x00, 0x00, 0x25, 0x04, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x27, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x27, 0x04, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x2a, 0x04, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x21, 0x04, 0x00, 0x00, + 0x29, 0x04, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x2b, 0x04, 0x00, 0x00, 0x2a, 0x04, 0x00, 0x00, + 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, 0x2c, 0x04, 0x00, 0x00, + 0x2b, 0x04, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x25, 0x04, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x2d, 0x04, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x2e, 0x04, 0x00, 0x00, 0x2d, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x2f, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x2e, 0x04, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0x30, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, + 0x30, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x32, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x31, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x33, 0x04, 0x00, 0x00, 0x2c, 0x04, 0x00, 0x00, + 0x2f, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x34, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x33, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, 0x32, 0x04, 0x00, 0x00, + 0x34, 0x04, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x36, 0x04, 0x00, 0x00, 0x1d, 0x04, 0x00, 0x00, 0x35, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x37, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x36, 0x04, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x19, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x19, 0x04, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x1d, 0x04, 0x00, 0x00, + 0x22, 0x04, 0x00, 0x00, 0x37, 0x04, 0x00, 0x00, 0x27, 0x04, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x39, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfb, 0x00, 0x03, 0x00, 0x24, 0x00, 0x00, 0x00, 0x3a, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x3a, 0x04, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x3b, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x20, 0x04, 0x00, 0x00, 0x3c, 0x04, 0x00, 0x00, 0x3b, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x3c, 0x04, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x39, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x3b, 0x04, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3d, 0x04, 0x00, 0x00, + 0x0b, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, + 0x3e, 0x04, 0x00, 0x00, 0x3d, 0x04, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x3f, 0x04, 0x00, 0x00, 0x3e, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x40, 0x04, 0x00, 0x00, 0x3f, 0x04, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, + 0xf7, 0x00, 0x03, 0x00, 0x41, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfa, 0x00, 0x04, 0x00, 0x40, 0x04, 0x00, 0x00, 0x42, 0x04, 0x00, 0x00, + 0x41, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x42, 0x04, 0x00, 0x00, + 0xb8, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x43, 0x04, 0x00, 0x00, + 0x3f, 0x04, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x41, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x41, 0x04, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x44, 0x04, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0x3b, 0x04, 0x00, 0x00, 0x43, 0x04, 0x00, 0x00, + 0x42, 0x04, 0x00, 0x00, 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, + 0x45, 0x04, 0x00, 0x00, 0x44, 0x04, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x46, 0x04, 0x00, 0x00, 0x45, 0x04, 0x00, 0x00, + 0x28, 0x00, 0x00, 0x00, 0x3f, 0x04, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x86, 0x00, 0x00, 0x00, 0x47, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x42, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x48, 0x04, 0x00, 0x00, 0x47, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x49, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x48, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, + 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, 0x4a, 0x04, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x4b, 0x04, 0x00, 0x00, 0x4a, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x4c, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x4b, 0x04, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x4d, 0x04, 0x00, 0x00, 0x46, 0x04, 0x00, 0x00, 0x49, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x4e, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x4d, 0x04, 0x00, 0x00, + 0x3f, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x4f, 0x04, 0x00, 0x00, 0x4c, 0x04, 0x00, 0x00, 0x4e, 0x04, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x50, 0x04, 0x00, 0x00, + 0x1d, 0x04, 0x00, 0x00, 0x4f, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x51, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x50, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, + 0xf9, 0x00, 0x02, 0x00, 0x39, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x39, 0x04, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x52, 0x04, 0x00, 0x00, 0x1d, 0x04, 0x00, 0x00, 0x3c, 0x04, 0x00, 0x00, + 0x51, 0x04, 0x00, 0x00, 0x41, 0x04, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x53, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x03, 0x00, + 0x24, 0x00, 0x00, 0x00, 0x54, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x54, 0x04, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, 0x55, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, 0x20, 0x04, 0x00, 0x00, + 0x56, 0x04, 0x00, 0x00, 0x55, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, + 0x56, 0x04, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x53, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x55, 0x04, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, + 0x06, 0x00, 0x00, 0x00, 0x57, 0x04, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, + 0x5f, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x58, 0x04, 0x00, 0x00, + 0x57, 0x04, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x59, 0x04, 0x00, 0x00, 0x58, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xba, 0x00, 0x05, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x5a, 0x04, 0x00, 0x00, + 0x59, 0x04, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x03, 0x00, + 0x5b, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x04, 0x00, + 0x5a, 0x04, 0x00, 0x00, 0x5c, 0x04, 0x00, 0x00, 0x5b, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x5c, 0x04, 0x00, 0x00, 0xb8, 0x00, 0x05, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x5d, 0x04, 0x00, 0x00, 0x59, 0x04, 0x00, 0x00, + 0x41, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x5b, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x5b, 0x04, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x1b, 0x00, 0x00, 0x00, 0x5e, 0x04, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, + 0x55, 0x04, 0x00, 0x00, 0x5d, 0x04, 0x00, 0x00, 0x5c, 0x04, 0x00, 0x00, + 0xa8, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x5f, 0x04, 0x00, 0x00, + 0x5e, 0x04, 0x00, 0x00, 0xa9, 0x00, 0x06, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x60, 0x04, 0x00, 0x00, 0x5f, 0x04, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, + 0x59, 0x04, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x86, 0x00, 0x00, 0x00, + 0x61, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, + 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x62, 0x04, 0x00, 0x00, + 0x61, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x63, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x62, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, + 0x86, 0x00, 0x00, 0x00, 0x64, 0x04, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, + 0x43, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x65, 0x04, 0x00, 0x00, 0x64, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x66, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x65, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x67, 0x04, 0x00, 0x00, + 0x60, 0x04, 0x00, 0x00, 0x63, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x68, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x00, 0x00, 0x67, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, + 0x88, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x69, 0x04, 0x00, 0x00, + 0x66, 0x04, 0x00, 0x00, 0x68, 0x04, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x6a, 0x04, 0x00, 0x00, 0x1d, 0x04, 0x00, 0x00, + 0x69, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x6b, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, + 0x6a, 0x04, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, + 0x53, 0x04, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x53, 0x04, 0x00, 0x00, + 0xf5, 0x00, 0x07, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6c, 0x04, 0x00, 0x00, + 0x1d, 0x04, 0x00, 0x00, 0x56, 0x04, 0x00, 0x00, 0x6b, 0x04, 0x00, 0x00, + 0x5b, 0x04, 0x00, 0x00, 0x50, 0x00, 0x06, 0x00, 0x16, 0x00, 0x00, 0x00, + 0x6d, 0x04, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x52, 0x04, 0x00, 0x00, + 0x6c, 0x04, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0x17, 0x04, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0x17, 0x04, 0x00, 0x00, 0xf5, 0x00, 0x07, 0x00, + 0x16, 0x00, 0x00, 0x00, 0x6e, 0x04, 0x00, 0x00, 0x16, 0x04, 0x00, 0x00, + 0x47, 0x03, 0x00, 0x00, 0x6d, 0x04, 0x00, 0x00, 0x53, 0x04, 0x00, 0x00, + 0x0c, 0x00, 0x07, 0x00, 0x16, 0x00, 0x00, 0x00, 0x6f, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x6e, 0x04, 0x00, 0x00, + 0x2b, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x70, 0x04, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x71, 0x04, 0x00, 0x00, + 0x6f, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, + 0x12, 0x00, 0x00, 0x00, 0x72, 0x04, 0x00, 0x00, 0x6f, 0x04, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, + 0x73, 0x04, 0x00, 0x00, 0x6f, 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x50, 0x00, 0x07, 0x00, 0x82, 0x00, 0x00, 0x00, 0x74, 0x04, 0x00, 0x00, + 0x71, 0x04, 0x00, 0x00, 0x72, 0x04, 0x00, 0x00, 0x73, 0x04, 0x00, 0x00, + 0x70, 0x04, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, + 0x75, 0x04, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x63, 0x00, 0x05, 0x00, + 0x75, 0x04, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x74, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf9, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, + 0xf8, 0x00, 0x02, 0x00, 0xa5, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00 }; diff --git a/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader_Vk.spv b/OptiScaler/shaders/dlssnr/precompile/DlssNr_Shader_Vk.spv index 3acdd0ff8ba2791c7bc57c674695b99ec1588db0..4881d4987bccf3b0e160e61cd88eac38c1ce6e89 100644 GIT binary patch literal 26656 zcmZvj380VDU|)?Rz0?l6Ec44 zq~=+3n`+k8;pNsqx>e$6o%v7yX&AfkpF=M=d0xxlDb4N8bLQ8gRp~UfPHLOcg1syM z$=Sd4pqaB4v`lH6HFrV7*Kt}8nl)p=OnvJy&9HT1%dFO!`gN=IH%9CJ?ag!NAJfu4 zbwPW}+*Z3_U#Vs{uh#Kxv)dN_uQg+L)wXNP(Fyy$+P*S{hAldYAa$n z=hi9B^XD&^+1|FW)nOQ?K97~PO*&!f^yb+u(+Yl-f zTI*Av%c|POx6PT?+}=`^u`$n{g>CA**|QcD{Z=b%hqSfLL2dL~y|7I^v3XwIR-cpW z+^B7>Pn};=zE-!|bct18i?!qrnBOv?c}~l2C(Ub{zp&kN4@cSmi_rn1V@TWWf3tt`^)`kt(<&*b)5t+VDfL)Coh zYtzOe&qeRTy;0;)^Xb~;deruEhw*A_v43-WYs-RKtXlo|YH6{6=4s7q{pL5%nK!$o z9ku3HtM}fs=C(Aq*Yxrp>%uIodC{*i$qCHS{cnyNAnMkpKjIa=UtO)~)}*wnYxkbh z-x`&6b?xS)-I|qlb?xS%-TIYwb?x4h+Re4Jt7~^0?bfigt7~^&+O276SJ&t5Bj;G*%va9+9nKu()+;#kl5_py z=Xi2`3(h*r4JbHkE4Nv}Sx>pG3eH^RwkqT@`QJXYn-kU6 zwT#b(;4;QW=#HJ-HU@KzHn+Y2b2H{v>{a!Ch(3yW^{4HNco{?8IwhvMd&FytDxZO1 z<8MmqJmTwEgAlLe<6dfNT2!l@u{K9mKr+@AVE1Qgw{3?#1Xs!0y-R+k?Hoq7MZdCwcAwP91Ia)4n6p)U6S{jo_MO2G4?BB@*hiqdXJhyN;TjS9NEGk==%c`%8Sx(t?sf0; z!($(V?jDVOEVyaFf<0m%hw9#qJ|66Tj=%RMoerFuiupfnf-WGc`?9J%U&OPhFO!~K>pMU4nM*j2Ak6tpnG2Zd$ zTOW3PqklX4u3ZN;`p-u{_VL>vNxTK?&CjW`)SBRprwk8IjnRkLp4-;J>YqdFJAnC& zK(}6=!}e9T7AqlM(Yw{vhQ4wK-S;xD`1?-grEZ;k?s-M;SyyYi^;*5qt&h1`BhMn| zb}r((h?4W}Jh11HXVA2Q{|eZ1$Fs)sCH`Lpd%k$4c#gqVS>gE*{^E-FjPP7Y z{7b;bvY$TjzZC3w(S~>~g#RYkbDwQA;@-ak z{ay6LyAoX=dC!UTy9#{Kl4}~zqpQ*7BJsNhuI;Aw(TR60x?CiFOX1dg^3KMYb{%?C z)1oon7uSROAnvCf*-MLP-RE9sARnQ9n|36=r_tVk==&l6yNuTBQ}6)V8xj3&_a#<; z+M5vjc#VZyLVGjf{j@$}T>X|K@^@e{pIZ?7$~)Grv|gX!ukAKO&hf+k_}^WMmK zw}TyTBP8Q}7c75!HQpUy`^tYz%*3{RpS#_h?nE{~oS*)VYi{48^)feo?n30uO>8`C zr7l02cxTeyjhJidW6tx4(U1K-Z#iAYu;s8`E)rLhI$Y z`aFfmIj-1wccpzA>5d%9IxeRDX~msO+X=Bo=I9zdgJ}1fQu+T3EI+7{&1j9?gZ5cu zRb)E-#qI(9y~=%LUdiX@;FXY8`kYDo93q!I`h%aZc$!B2eo=AOFZ<&K@J)sOBG|rX zRr7fXtdG3=#X0^Gk#`@>VIGe6G9teSAN5xd<8F>*tY1}pV!w(mSH^w~UA~O{YjpYS zgV(_~Amu!MgD#)3ehYTK8S4$OKJuBz@4#;$-V2$>@4@n!#~;APE$8t^bos>o6IiZ{ z{U*A68T-%Z@{6k){RQmYtlila_gAp|7Dx|P*;@V$ajxc|-8M1a0vp%76XR{Ld>P~K z=!v1-81Aos(7NAkyrBn z-jn56UE%oDe$O$kKBp3AJ@86k?djhQ?7dL-Um1>1t-p2FC;e9eYoEgDw<)&nU}MVn zM)!Gk7Hto7ZHkvo&Zt#URzlC2*%MvPKAqs}ak|ysyH|tLu6Wt#<33rJc6A83DTuyX z(q2-XMQfmI?*-?x)BWo@x~|%?Uaq_Qz#4=zsI~L{@?OZ^aShbnZ?1)H`na#Hm-kb7 z|F{otWBfj}YtldWiO-p}(7jw|ZEGXzAjTHw%vu+0zno9K(A}Hzj%6JC*tgW>v!B-k z+t0Y(!}{hq)Elf_UfB%Eb7+0|Jcq=0W7FTuv6j&~_G7ep_V&U42>Mot^W32Fcb?id zMC9xz&feGv?B2-pYh!dd_e9S4zUcB^;rdmabaLpAqVIAzbJ#>9mpNz~fXJDHIQ<5K zjdwr3&M!W;*3xy{6g-gD-1WD=V+^A8atwVoL*yJooP0M2-+&)YW!k+0t)^?Pk=bZv^4P3k!q#d_vm+Xh|EKDpPj&fCIeoyD%R{$AxeJD=>!?ZD<7 zeF(ZW&+~74us-tHyFwi}pF?KgA#&t<=PzV8m!7QYE#KDEEgIad58g0=Y^u-_hFxedYT zyC*uI+8E}OzI%bS#cyvgpV}Da9=}OoZ5d-9u$*JKpC*I7FKoT9JkO_qJ;U8&`y%^Q zHglW`c5H3?Biin&&ea3J+8x7Z=z+A_y}TE-AB4y|rZ~^EX<+w4@;n$USFc64T73>d z=TrMTh2wbt>DNYV*W*yIyw4@|!@zuM&n0W8J6}V0YdRN> zPpzizeSLD4wt*erbuG`*dFa{{FPogD$D@>IX*;@{eR7sg=5BEx&xg~lc-iQaHC+H< ze$FZLTL|V;o1b>qG-tpG=-Q7$E@00)#))9Z(PkawTwm8)n`f(Q?7CXV+;`a{uA6(t z`^5FLO&{+s_jCGqkLu(7lbW9d-VWKg$n#`$`5{Qo(Jz7JJ)?7GoPy4$cD88GnQm zSJAa8UN+gk=cAPS_iN~K_R0SB8S43U0i5>E;Ba3@Hy5vP7gn5fxQi;zn0dea2Auu% z*KYj0cU%n4dxzNf4*k8#_l^zV@{V>1*!Rl;i0@sOR{ow#+P;a%xo5@Z)*s(*f%9&V zwYv=NCT!6!N7pa4z5=X|d|B%&(X}aFHmUVhC}pj$MwhcsYMry<8aVBWmyJH23$FjQ z5ORLU(bwl=YP}TQe&sq{hi)IQ_+4Ld(&4^capgMQ0B3*wwHrU{v<%#n{?nHdOrfzzPx&O zeH1L`v$`I)z7~(cS<7)q*5YwE`K-kcz$g zAK1?t=lSpqSbHSTho8ZDziW40pQZK6zW+J8Yig_gxyqjV?Rj)LeZ=Nw40ZYZp7IN@ zWBGeZ_S6gL^1H$r`$e#qv9-N~$QetV_n%*a?PK56?q#t2b?|xqzJkuDwvV)@|F6LA zAMNS?DtI?IZF%;;26h~6S+`$<Od4oNetOBw1opD_+TKLuti3q<=+9vL zMY50n0_PmGTZ8nqO%489`B)eIja%*)_f35N2DYZ|Df=0xNA-UE7MM@%S*D-Qv|&ir z<83&7c89YTJ_rAf&Zkx%YMIc!m3S#Yu;Izv5i~yc>N0XMg>*FGW26{2S1R;5_rh zKJ)bVvhK@hUEfRL@=W>&>^W$zc_w`fC!c51Ctx{$$8hg_3ifjEX!{TH8Dea4^8YXR zp}K41`S3ZM{KoLffo`=Nwt-6yD>!K+?*W~_ay}QA;q9}cGrIA#nb(T6Ugjm=1-&a` zUgF&QD}l{nTYRmH{q)f{XGXWm$2`+-WjOhc{p_DJc@?nn9Z!E_rXJnF)`Ov0&n``U zX?wugN1J2ItqPX!2TtFf=<;6H&1cwZ=&s#%NS=YK!^!9TS_5of`J8iWf}NMP#9s?+ zd~?fu*G89jzKOREx_lXLU3BAV%e;Dl9Y@=vWa)aXS8;wccDY{hv9<2T-T=G-t!tsb{qs(-p*F-ZH=^}&O!207T9)#hK?ouw!PP@v+UAn}QwFJoLAJ_Us^V?yWo% zH-mFcS46aXe)R`$Uh&@3%hi$m-nj)f?OF3J!R92N`fMeKXtO?^3C_oJAm_%`+R*d6 z{$O-3>!58LM9zNV?8R-t-X~t!>)XM(*M}h4>qFq=lhgKK`^x8R849*vdA95TC!e!r zN3dLZwhTizp0?C?I5_cB-<{x6U+t;y&K3Vf^&Nptd+NIj*!s$6E+fIl)@FTEC)@0W zQQ(2}v*!9+!`Ma_Hs_+PTqoBnzGJYtp6)YamSc=Xch6~atkO0Pu5)E`yx98UHy+(H zz<#c!HrLJXCcA?DzN@|(?QZC+(;mo5twFmxx<2yL@LUWx0W5D^KDGNY@g_oagG;3*fRNsy@JsM7*vZm83uB_<{ zIQg=sE$FGK_OhnORJPRAF_KejWwWM^Zyf!tY368~n$84U7wcqS=Wk7C(Rx`^-`$Qy zKMt`*;@nfS!7JmJduk4Pc~8wn*GE40R2x{nyr<01F^%syp7H&OI}dyVt+mK+X~)Ce zROs#K`sKH^`CxtI%iq=(plegSjG1{XgmWJG9pnUbIs5Rb#VK<%S8KQ!+lgT3WL@lM z{?_m$TCeQOlhMC~I7hMZ^ih|$&ndKC`JR1hWw*^U?#p1$o$~jk)8OR2C;iTUI@tM5 zL9~sg&AGJ*-Tq?`=ii_93^@5blNW>Ka&9dFdpQ?vXCiXuE_N>Ft}dUto(1ksztr_? zbh&fkX#UUdOXomn_sYA@x#;rwed)Z)ZXVjcg2*|pIM2neg6%h!SmqWV+dR+C2m7ot zU;XW$_p+~nwdePx3&3(df9rAU@77<3vzFr!=WOjSgp5~|jf!#0K6611kVrVx;xyG)w zb#%U0fbH)-u%9(9_qKaHzE^^+q5I!{#>shm71(=8@p61&eq*>A#r_fJFgJ7rqUa^Bv85^aik(dr;dlM9w`Z&V70# z*w{mn?2Vh?D?U$6MxT5;AX+-()7Ykmv(4vPKt*KU0C z@wb56!TBvf>~8`3d%1?oXq}hyOFg~|wjOz3zoYWE9@_3iGJ?^VGT~m+yQS7h3cH^fW4}en-vGvg3tE`9f^L^j_ z_aNAuUB}euA+R;t1iO3YVX&7q()I`+%UTE_8gaK1lAcWmGHw3qKDPgb_Pn>a>t z`blN;-Nf;Yqks0tQ{ayK<7qhg)aR#Q-p8PM@Xz2J>5Vd1DVmH|ICNUgoU*cZi%hi}m?E zZG3zu{R8?RD<5%c`zP=!II8=-@lEvdo%GM>`pD;<^eUZX4vv#G_$#>M zJL%ux%6HPY(DlnZ>Dyp^V;$>b!_lYs|w_p6<2Y-=&?)?w28^d!* z-;U?ehj99o=g~(MSDr^7!^xND(I@D}_B_&Fo=2Znwwykk;D!@yfgX3h36+R(q$)p0(+WE~k&!yo{kP zpXbkt;Ea{Ct_z&JSKg(&qRZ!9dZo(lc-p!lDy(ied`{QRlRs(yPpSINzIs1u|-x}cLcRIelldcIT zpWN00%aysUjb7%akGW+G+q}1~12%v2wV&gc^Kd@#T^H=Ut)cyllU#d&T^GmAx~zvT zpLOXC_Hy3Z)<^mv&f7Ni+5l|7)N4a<`f1w;k+YvTIcyBJUgnT`^@Wp9z50RWjGwja z4^F+DqdwLkW7wt!n}GE(U;8<}zRt~joKx}{08T#HUjyN+x3=W8DOkSDX%KpulRo7* zj+dM^1MBbD=4ZaiVRNwS;x^B^Y=JJHb=eZ^<+^Cw3fUTQKDJqx!C?DkUA6(IpSEog zIs1u|!**cnU=CTAA#n1k!S-M|<7Zulf>Q(MsE;+s7`Caw4q$!E*M5$#uX8gW=ahVQ z1Sg-Y%P=_CMO$(j4wf%-+6lePNuP2Y$4gE-gY|c8^D|%1Xz$|@VB`3_&~Ff}aF>_|xI;Lm&D6nUy=c@kZqwgDV*1;7Q#F?apVA^Yk8uxqE!g^c5#IS?#=KG?tO$Q^`kUcS?7_uq1E3Z4em=D$1E?_jW8 z`W*tc--=Z~=c(VJ6~8`MpOb0xo$WAm}UT{mv^7pXCByo#y$XDU-y}|pguU*ema(C!sqZTkR)zuz#tt+vYiO3fQ<_SCOe_(W&V2S6BL%EB!|1 zt^G7~edP0->*-+m{N}m{EN2|=`HXi4y5p@-jJFtFKI1K^^o(~Vx<2w5?<}x<#ycA< zXPk1pbI={n{h9fli!Pt>&a3o{_Z4(~o%;i`^bN0*-f=XzZT_Hu7)y9kkUO~vj}*Hm5Jz2g1$4X|;Rf^!C5jDBTh%QN8; zICC>!$Ga5l<#^h@iO3mWoHhFv*mz#KFE2xvH=cQ=pKYFLmxKL{z+Ck=rsG~g>*cum zT#3jzt~ldf1vt2_eU5*U$X)H>T_N9a=BP)#r9Z&T+*V z_q*VXoAtW`PTp~|es_Yie%h1c_rTh+es_U0uC}|8dl1JJXZ^kpb_`=VH~Zh_t z?)QT2XB_LVZ`SWVaMsWD(bqVcvu)zs57x&z+Rrhveh+{>6S95}f-@g&4-Q+w^)o;Hjp_P5M(gGJ>GL=u=eXjG`vY*s&HDWiPTp~| zem??d{j?{?C&1dWem@3hTy0MxKS3N=?#!ZuZkh-%^)P-Jb^A&p581zFEJY zg0p_EkG{sqoNW{58L&Rq(SDAR=f=;#+Vk9aw$k(5_&K^h@_BAN2bRxs<9V>0am+K{ zm41P4j(%6t$33FmJWob<{ZZVu(U z&OgxgO%DI8^yKgkx<2yB;a#wNa(E9cXB@}K-*o>4wnpZtPq~lWPwrLs!oR`p1^1eL z++$k{p{HKXiuN+V13LbXGRZn>#i-_s$kbi z-{jj9Y`&w4d{={$&puflEEmZ>Sp&{_xKE7jnEGbCHNpB^$(Y8v9>2BF$Dv2OSKRAs z!)v<=oBiUy4tOkFB>wBdYqKWy^}Oyy>*aYphCb_|%ei00`t+`R^4)L!%5IyQ^Z{Fw z^4}V504JX{+z^~K)aJhxvHudEU0vR|{{FHFxI1nBUN!(-?p!!Z(D>V`_uW8v?Ou7;*c4sf`^Y>7Rd(~xwizPl zxZ=E%Z4S2ISo)b;d~7`z{Jy(|KD6emzx{JoZVA?&vvMo2ocBUKZvC9w8qQjdLvqdy zhLg`)Yy-|(Xv4)3c2AkF{`SwF+6}Bddun&EoO`Msx4x$)z;)bH6XE2uK6`+(KHADXwI_PVJ+&8{ zeERPVPJeCXo|=SiZjKTEeZcY8Uhb*M=*H70duj^UJ)tcz_5~+~_Ux&wv2FI$eqj5% z5A0`+-7`~Zy|SnFM|YiUwI5K~v!@P3m(xe=x*0=VK6~mQaJi?Zq04>Io;ny_yI1zq zA?WhiQ-@Y|^U!t}BImf`?5V@S_8UtqbBm8{_S6wz_muhSZ~yG6Bf;9Ur;Y;4xu@!J z>wBshuH&9M8csgzGaa1u(N^xM8R#ANR12JZ`X2*Me{JQSYDG6U$B6$-aQwBGdukTC z@$|`_Iu`7n(3Tj-ffGY}_Egr`HhXF|*#7PV`&r|>L(Bntj=Asjb1iz&x?Z-%@I7EI zcwNNzO#2w$T(q@;lZ$>n`|}Pz5B)?Qcyw!U$HUpjD}L=2XPj{JE6(R-{yo$JIQ#3b h-T3Zh|NY=XaQ;1%_-;7;y`0xFTIXf^85s{p{s;1fwN3y4 literal 24628 zcmZvj37ntP^~STvCK0=Y5E&7%#!iSxB8VlCNbFUNWQ-x3Wb9N(Z7oVsOKpjLsY>lT zZB?l%MJZKVOIzBawO9SW-*?{U*Za@M?Hu2aJvw#j+^JKi zzMa-yf{wOqr!Ey^zX^KpPTebg-1sTuhs|xDHf*!aH`1?fr>=IDZE1YEfx94Mr%Y&W zo7t(dE(0&OEYh4p4o&U)> zzIE?I+uB+DQ*hc+8yg$Z#TMCsn5VB(}uOpXl`}S-NmZ5Q`n8EEtOu?)WuBiI6GAx zC(dbWZJXH)Rrz$(a2A^}6TLfU`0Ha=wcDe4PHRhhHLj}Ht}QJt%5m1HI+t^sXUv}7 zG6%KttLihpZDvdJoJudxeK#_;M#Z?sg2u5P&!qXRil|$MH4t0$rVh2zU4Lm;*Y0zm zzx62X>e|goyY(sU>e|giyR|Cq>e_uyv|FRnuCCp@wOg~&uCCqv)NZXxySjGQu~St& z0Bvwb*WfzWoO#5rOU=2)aIV9#<`vE{a_&Po^Oakn;LK63f5DlTocoip&L=mh;H;zE zngwU=TTuR~P(0Z4q@n=-~~=+2$o27+m$%x!gmxfyeP z&YSumL?6Yxn&<~1He;x-fmomD)~$1)yYJRLa}EL9vi`Nea*_BA)v43Gs*cX%SxN5d z>masu>vgXSb{*?g{r~s%OnEkw;|5^YscvnDA+cM74Uv9#KRY~j&!6Wm`o`dLO`D+8 zM#sJ>isvu7XVo(reRHtSRP-&to`KY4OK|FLub+8&zB_fgYE1mLLbFbh#M>H9|BM>} zzU8r@TSoVpcyPE^z5PIwnbGK-T#8~vn z_v|(%{@bG;{nUD!WF0%8%SGb1Bix>QzOZfl#-Yna;^%WZa>>&h^Y4s)>$v8T8Mh0% zTqNUmge5K*< zXQuaFyrZG-hu%K&+{XBCpzpk6Q)B%8=#x+0yJ7z(`kCwQ+OQvh{`AaK?@vAlqW9hK z%ZB|R^_c@6iM<(p_#JOI;vI~B$7auO6Z=&3`={>I7(WgDpl%Z%j=cr_iT9ptj6VeZ z#xM47=&k5yZS>NE@jn#(^T$qU=xyl7kG;F0ABKL&#A_Sz4@bYb{glxeKOOz7MN=C2 z&p<%EcETW4{eN}jegjpw?343N1#tR>C8sG=Adu8{AP{ubI}K$ z|MIB#x1+ze`|!qmN21?+(@l+M<0y2w$iV8x?)VJhGwq$Jh@+Q%@Ynfe+#qg=qZ#kr zxdgH@pPIVY@jBN$UDecWjya|SR=$qujqZGlk1?*CV~(Y_>AMOudVk6vCrMNHzCWJ6 z3Gv;a{RH~Xi2U-5JCVK#>$m8|jyZ|m`CWr!=FvO1akQUYV>$Ixs=mWV|M}?Jj4^=N zz6-2Fe{A2TUlB2%5$M*-yHbC3YvEmLi|)I}7QI)8+R**HWYcb4{9I&DFiI zLbo2~VokhnT+69Q|5|dVordn6<2|z{68?0scZ>IlcS!g%z}_L=8{QT2uKi5JSdP;t z{@($6hj?#zSA_pA*t_B&q!|f+7WiOfDl)C+jej;`EXU~+|8u}Y5$}aV3jTXF-%9Tt z5dU*)-h04jU*7oVA;xl?KJouP_;AE~z-K@F`QVv|&%4if_zS>CAU@YV%ZYy>*jSF! zC(ri}!0#5%_eJO*peNqN==#We7i8Qe;Pd8R(Rk-viY^z4-w)wtT|Z}3;$4O=7m45H zaGg5MYusB`p!I)z(P*E8E5WNEo~JE1OFmDYYn#v4r)XEvkHq(Q`UQx-pYY#>^tLa+ z>(F0~=x@I}v6|?wK^$Wn12>QUTBIAYGGbi)u0!N+!(u+yBaW4Kt{doWpX0CXMnul} z#F_6Vu=90BGT+T$=UWZQe7At*Z>{J15!kWvpAj>$?LXq_Hm6&W0f_6<-+9gL$MiOH z)8{rs&fLVtvsUWz6Nz^+{UXF%6`MKFCdTUYKS8vgOn&OO*W4g_eU_!a1F=3?=bhli z*LfG5e8$`jmYY<^y$5U@`7>(nUa<3NOYHl=#_o@#hWCTzZ^B}I9zf*QK&;Dy^fv3F z?IA?YI*5(ao&I5@2hvI$>+%R9=Umy>N5PLEws1cMKZ2xg*5qf1=O*j@IoPqM5?lLY zh(7YJSMC>xymgpCPEGWWBl7d`QU4`k+`&jXSR`ZLsn5 z`IvL`4!!YgJ_FkSg2-Nd{b+CEs^Ec#OBssqaw#M52j%Z8H{{U+%bN(lK za&~|8NzU(sji-+}e?V_Mn>lM&mp5l|_Uc3MqewZ|ztEj)EyTF`oIsp@^#4Y*XZ%NC z&vZHdWAu!-milD;Ct&T9xHZM8V}A=(t1@p9LE4(@>*$bV0w{{oS7 zOc$ghPS5J|-ha@wD>mck<5^gd{>z%1M6a)FzM#HS{tMQ=5~9E7(0w$9{;wnYWZ&FJ z>*cdio(b!&{sz7Ex6hcjz}CoTp*;KVpiipT_Z2wj-)CSbVl8^pn@k_NspKqP1lHeX zyoL16`5=An_|EvJ-X-a6&Z|#vM9z7|IVXMO@yj_`3SI70 zxSSJnbYJ_zYqzEDOQXwM^Tq4F41DS?w(k1d%DS6Z@>v$_xy?IrIdnPCYihMTy1Xsi z3NfrmzaLm1`Mg{DgXQmFT;44!qs!+!t^zi$&vRlAfRj(`Rl#y) z?A6fa%h&_a<+F~}!3&5>*N8m`MLu&ifn9IrS_7<)eAY1-EPpp~vW_*;<+F|E~n;<*NW@-EsMY&?B@7mc8IE}PG*_H7V(^B23Gk+p80ccgimw?5k< zqmZoC^|@YcqmkH}m}d;Sd!ubTL|fJ~7ObsY&-Up2RO@kH^~rj602@yq*RvzN@ocU~ zySlvV5oeFbfqf>+xpqS5r+UvASD(BacLrcHgajKk^P9jqbi`%YM1o!SmWf}Fxa_moeb(Pr?z8L3xtt3&=jiR|);#aOBfTRRQH+l`26WN zi`eeR67lQez;%oQb zwx(BuU7vkwY8|bsYrY1#7SU!+uLFB#v|W#AOHFS8Yxite(;Mlv+pMW}b$RC$r=~Z7 zy$4d$o56BrO>aTxr>d#*SX2E{(;tE5v*ugD{8Vf9%xh0ge_ZQjO>cwar>d!EU!UBi zi@?tBzLt0CPtdg~HoM%Vx1*GI=^f~Dj>%n`&nY8~_3<&3y*o*ADL_s>3Ke7-!- z8RIjmkIzqPejj))GO)<=esuYEB=_h8V0rK8+!+s|^Hbd|+H+?-1lE>w^f0(QM~|S( zmFMVDbbhLH2su(ss+ICv_O z^ZrY)T$$$+==@Z9I^I0>^Gv#TPl8V?#JuEx1?TgtJ?Hl+u2x}0ND>)aKu!)aG+cKUcPxc_fJ$W^}&1o(bT zt=~jN>s8HoOjL_;4%0)Ht&`H zfaNcT&)xhbIzQFlFtum=f5EdbzNvjLuy*TU z?Uw}Gti870h@7<-=Wg!x%hxuaY5m60C)Nt++INEU z{5b!L=<>UO6MrRibJ_?Qk2pv2?N{5pOU%vj`e(2EgY~h6Te;?p8E%!D(>3p-0Vs~w zU;CR3$UU%NfQ{e6)!x%XDX?mgo=a_C(O>!85ZVnqG$zd%x`P{uj!E)Zc*VeJtMmL@| z^IC`AW?u5^BI_aMCC;H9zKk~l-FVuvu5G~1qwV2(zed*F5PaRQZP9J+ zm$p%eoO>b8-8C9)EblJ&D?awt-RF1=cmTb7p}*sAAg;FUz}lU2EWOP+<+n%VoKu{0 zx&zqU&DA;MW1l&91UsjB=&Y5+_$3AoJ3U*HO z(BJVnv*W>o5%(hR#0lu`=@N)`@2@8CZZ+@o+v4Qy)hX)5XtXSr+{tNLE9dPoa4kfi+h4|Z{)1+1?O4c49QvF8%{ns?E`kK zeD0Qg!Hz5Mmi^%5bGLj0ELYww`=c9ATk88waN?)F2f(Gi+Ed>HYyRu%dk{A5sc$pb z`pRc52ZN2R&HAQJ_Bjhv!Tv7Sn(J>3W1CjkT#L4Hp9U4aEnxT4b7stPjziErbK0D% zw6(&mUE7>5Ht(=Q(Y*s4=U!@a-@1d_z&+^I`_dnVzBK(_?9?*!hokEwzYm@#!A%Ft z8<(HzxlFtn5Ix}%Zzg&fZx*^f@`*PaEMLaUnK=U9GgE#Sm;)!DGcy+~=l=SPw}Wk- zZEZ&)Mssj#_->Z=$p?*-r;_BISx*r zOTpg%a>v)4pJ(EC0-XG1aQTdLBD%4?L$&W#*uGWU{M;}JagOA4Qf;$-&Tkz3%Qd=I z&#L*%16vpC2(9R00n)@Yxao(;Ax z*2%H1-_Zb(V>zChWTnyGnzWja0CFt4|n=!MFOW|Bc{$~3_bUDZH zQ^hHBG*@fropTx3HCY$OnZGr>oZgmmc?J5Fh-(xZPak#pyu+>nd#{w==@-Ds`^@?I zaUt0JeWtYeoxY4`T=UcSYOwDO=X9KN<&0kgHh;xtOkuv)U5n!Qi0>kw#p~c4t3BW4 zuLsNfT|V3m=<{kW_vVf0u5WY1`Zv+v1Sg-*1UHM3e3!TdY_pcyeuT(bJ8^1vE7;gu zAjWq6KZcXfcemTX<|Lob5{tmrpez32euA#AE!^!jXPv^`QFFTH``4W)j@Mti@y*A- zL*50>_b>4xIQ?zz;X-=X<@!>OyTwR8Bi#eGSr2XZB65xsrylo#7q7?taPq0g17Pm~ z`K;+d@Z$A&2u@#H{2s2kvL27roUWAMUMVy2HN=_OoODo!~3za=s7Dt%?2*=<>F3uhyLT=3M;|PT%X`yw_i= z$9S%^y^hFvuEhE5_XgN_`F9ravG;CvFW&_FJ$*YE*YzWjaehv@E?b=02m z{{s8o)1LAF25$$a&1c>B!$)A}(U$L8AA{wcJI}!<;Oh`=t~EK^=kwI3wU6u9-}U5K z_zbMw7Vh(!Gyia3)SRw)-~R_iAK&+m(I>Vq3!8K3o7(>utlc_T`>((@Yp)He;;g+m z@BPkT$3^nq?*i`{v|9t?Io3Wk=vw<&7yXS}o(<1Pe3!sxO+7!3GfwWVZs@Mr`&Pf) zr}=Er9ZnxVZ{*(YQFGqsuD2(;EoZtHy7}5`U$VC6O!r2Y(?@LH#!#2f`=<{$b7kL_ zf|IwU{(aHqw}ErMrE9zMXu^2s9SC;a*3farNv^Ad-52N0z6?T_&%QK)ZLV9} z8pvS8b=#+2Yl0n@dJO?*oVK+PImd~U!%(pGGKbV_ZFKq6YaOs$m2X{xb$8)(0n_oUaYwthcu0Gz=_X=CmPtnUg-{JkFP#HUjJK z+~#M#$zfx#`@*Bz*q2Sv<+CrFf^F`Lw#|^u5!Yj%ec1x+xa`Z8;EdBY9FcRJI5}(u zwhrcyec2jaJ~bEtmaFou_hlRO)W9|BV+}HgeQGcgtdIFR&iVCqZRX>elFzo_a z#CbnY23t?x-H!EaXCJ4a8&esz_eY<6p4kiRdiBXXdxOK5 z^Eh8>z7N=Z%w2zT$e!;Dwyye|OI_X1{lM~Pg8ejiXO;Y6i=njbFHf(apWgb1HiB)Sf)2 zfwd*i7O-6MJOrFP9hW>?Yu-HdDf2uO-8lLrr#7&>dHVm?^LOEgp_{+r92|>kUZ2Us zYi_&RFJq>|8%tSy%#31;etGxJ1Z&IlFbiz+dC)c+IRfzujfqLkznnvH@~Ag3T#cZ+3Y+gspZiS`kV)svvCZ% zyb|tMaQKWp4o?0;#`;Vj54Pp=;tA-k$6ou1i`lM1I6m{4?^JZ>bN@5nY3TBq@AO*Fd}pBRBcJ)s z1j}c>?||iuQ_lBYbm#MYX1=q~wK4hZO*6dQbf-9;_TTE!N#-Yxx5Tr-gxGfarQnto|DVLey2BA{f+6o zSJ2y>SDz~pIp-B;-mAcwH}97PaPrQZzgI2<=bqD^9IpmzOMR~aXI^dBBG)0#E6)4p zda!dC%e6U9AAL(*KJTL&z>YJHpFi}?`|n1u`Q? zmHoQ~Y_pEqeuT)Gt2lMM6>J^NA+`B2y1ensCFAU~f470%Kl9VynC{;qdYkj=^AkkQ zdBvIcc5vp+{@np5@4VT+JHgpM?aA>ju(s^q-Qdit?H=S_#CgTpzx%+>VJz3?IDPaj zb@|l&ez4<=WBv8b{yhNB{<%N;8YgSEPn-wA`dCNDIY;*IA+UEs_U~bE)}!qaM9y5r zspF&IixBUy)aIw?^2RfljI+=F{S55>nV8u(s^qliGhhp}9n?~Uid@_BE(0G2b3 zdFFe}@6gTB&!75uMzovfiRiB1K6$*a&pYcC@NtOmth{UffG%IYYhFe7U8Bu&;%DJMf*q?Z@1)nj^5&NBVy}bs(U#Ar zZ-A|Z-$AtbyR@9iH_;tq3-=bfV{F;0KcVZJz4~*lXRqEy*GE2k^$u7*d-WHvoN=5Z z^ZgZU4(1r{Z|KQ8IlK#}Z*q9A)|12E(e;r}4*vklCx?H6<&5JTneTnDId~_8`vBb> z%Fj9XRIL)&71~Gar4D!;)Zg z7=?@^c|X(lhLg|uKH$u!&0MnPrD|QD>|@{B-#gB^_0gU&OM~?>m)sf4fUUc>aLa<- zCw-Iea$xfvjU?aY;pB5pRshRIa!yu+a~+-&V>_q5nQtYqK36lRv983gA9^c##An5` z-XC7uHP{>%|CPaqz(wM}3cNP&ILCTl51_YsU$-!3RdhMet2k?34eXj%MY86BaPnF6 z>R`EuXFsv*bM^;;&Bf=zG0v0wxCxwn)~~#e*Fe9F92wTQhX%tr#+JKj&6+b#xFI#i raPsZ=_bF?^IbMJ5#&>PK@fixv-&Vzo;Pkh-u7&j0$o@+*9*+DU;0E#! From c3a0188ab3b3042260e76aefae7cf7ccabc4978a Mon Sep 17 00:00:00 2001 From: 4223641 Date: Thu, 3 Sep 2026 22:56:27 +0800 Subject: [PATCH 3/4] clang-format composed DLSS-NR rebase sources. Co-authored-by: Cursor --- OptiScaler/dlssnr/DlssNrFeature_Dx12.h | 7 - OptiScaler/dlssnr/DlssNrFeature_Vk.cpp | 40 +- OptiScaler/dlssnr/DlssNr_Exposure.h | 10 +- OptiScaler/dlssnr/DlssNr_Menu.cpp | 948 +++++++++--------- .../tests/white_point_decision_fixture.cpp | 4 +- OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp | 389 ++++--- OptiScaler/shaders/dlssnr/DlssNr_Dx12.h | 11 +- OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp | 32 +- OptiScaler/shaders/dlssnr/DlssNr_Vk.h | 4 +- OptiScaler/upscalers/IFeature_Dx11wDx12.cpp | 8 +- OptiScaler/upscalers/IFeature_VkwDx12.cpp | 7 +- 11 files changed, 694 insertions(+), 766 deletions(-) diff --git a/OptiScaler/dlssnr/DlssNrFeature_Dx12.h b/OptiScaler/dlssnr/DlssNrFeature_Dx12.h index 30d3f78b5..37e4f5d94 100644 --- a/OptiScaler/dlssnr/DlssNrFeature_Dx12.h +++ b/OptiScaler/dlssnr/DlssNrFeature_Dx12.h @@ -34,21 +34,15 @@ namespace DlssNr void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Parameter* params, ID3D12CommandQueue* timingQueue = nullptr); - - // Frame generation titles tag their UI layer through Streamline; a copy of it makes the HUD mask // exact at the finished frame. Called at tag time. - - - // The settings panel, drawn inside OptiScaler's menu. void RenderMenu(::Config* config, float menuResScale); // Clears the session failure latch, so a failure caused by transient thrash does not cost a restart. void RetryAfterFailure(); - // Asks the model whether it will work on Direct3D 11 at all, once, and logs the answer. // // The bridge exists because of a claim nobody tested: "the model refuses on DX11, it answers @@ -93,7 +87,6 @@ std::optional LastGpuTime(); // What the white point meter last settled on, or 0 when it is not running. For the menu. - // Writes a run of consecutive frames, each as the upscaler produced it and again after the model's edit. // The pair is a control: same frames, same run, one variable. void RequestCapture(unsigned int frames); diff --git a/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp b/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp index 718b7a34f..bcd128cc9 100644 --- a/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp +++ b/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp @@ -26,8 +26,8 @@ namespace // it, whichever API is being used, so these calls go through the same shim the D3D12 path does. using PFN_VkProbe = int(__cdecl*)(const wchar_t*); using PFN_VkInit = int(__cdecl*)(const wchar_t*, const wchar_t*, void*, void*, void*, int); -using PFN_VkCreate = void*(__cdecl*)(void*, void*, unsigned int, unsigned int, int, float, int, float, float, float, - int, int); +using PFN_VkCreate = void*(__cdecl*) (void*, void*, unsigned int, unsigned int, int, float, int, float, float, float, + int, int); using PFN_VkEvaluate = int(__cdecl*)(void*, void*, void*, void*, void*, void*, void*, unsigned int, unsigned int, unsigned int, unsigned int, int, int, float, int, float, float, float, int, float, float); @@ -281,8 +281,8 @@ bool CreateMeterReadback() VkMemoryAllocateInfo alloc {}; alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; alloc.allocationSize = req.size; - alloc.memoryTypeIndex = FindMemoryTypeIndex( - req.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + alloc.memoryTypeIndex = FindMemoryTypeIndex(req.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); if (alloc.memoryTypeIndex == UINT32_MAX || vkAllocateMemory(g_vk.device, &alloc, nullptr, &g_vk.meterReadbackMemory[i]) != VK_SUCCESS || @@ -511,8 +511,7 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para // number, not a lost device, and the gate on the readback throws a wrong number away. NVSDK_NGX_Resource_VK* exposure = nullptr; float preExposure = 1.0f; - const bool havePre = - params->Get(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, &preExposure) == NVSDK_NGX_Result_Success; + const bool havePre = params->Get(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, &preExposure) == NVSDK_NGX_Result_Success; params->Get(NVSDK_NGX_Parameter_ExposureTexture, (void**) &exposure); @@ -558,8 +557,8 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para std::abs(loggedExposure - g_vk.gameExposure) > std::max(0.02f * g_vk.gameExposure, 1e-5f)) { loggedExposure = g_vk.gameExposure; - LOG_INFO("DLSS-NR Vulkan: the game's exposure is {}, pre-exposure {}, so white point {}", - g_vk.gameExposure, g_vk.gamePreExposure, g_vk.gamePreExposure / g_vk.gameExposure); + LOG_INFO("DLSS-NR Vulkan: the game's exposure is {}, pre-exposure {}, so white point {}", g_vk.gameExposure, + g_vk.gamePreExposure, g_vk.gamePreExposure / g_vk.gameExposure); } if (colour == nullptr || depth == nullptr || motion == nullptr) @@ -631,9 +630,8 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para return; } - const int result = - g_vk.init(snippet->wstring().c_str(), State::Instance().NVNGX_ApplicationDataPath.c_str(), - (void*) instance, (void*) physicalDevice, (void*) device, 0x0000015); + const int result = g_vk.init(snippet->wstring().c_str(), State::Instance().NVNGX_ApplicationDataPath.c_str(), + (void*) instance, (void*) physicalDevice, (void*) device, 0x0000015); if (result != 1) { @@ -695,8 +693,7 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para // Resize. The feature is built for a size and has to be rebuilt when the frame OR the working // size changes -- moving the slider is a rebuild, which is why it is compared here. - if (g_vk.width != width || g_vk.height != height || g_vk.workWidth != workWidth || - g_vk.workHeight != workHeight) + if (g_vk.width != width || g_vk.height != height || g_vk.workWidth != workWidth || g_vk.workHeight != workHeight) { // This block releases the feature and frees the surfaces below IMMEDIATELY. A frame-size // change is already fenced by the game -- it recreates the swapchain around it -- but moving @@ -718,9 +715,9 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para // The meter is a fixed 8x8 whatever the frame is, so it is only built the once -- but it is // built alongside the rest so that a failure here is caught by the same check. - const bool meterReady = (g_vk.meter.Valid() || CreateImage(g_vk.meter, kMeterSide, kMeterSide, - VK_FORMAT_R32_SFLOAT, true)) && - CreateMeterReadback(); + const bool meterReady = + (g_vk.meter.Valid() || CreateImage(g_vk.meter, kMeterSide, kMeterSide, VK_FORMAT_R32_SFLOAT, true)) && + CreateMeterReadback(); if (!meterReady) LOG_WARN("DLSS-NR Vulkan: no exposure meter; the white point stays on the slider"); @@ -779,8 +776,7 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para { unsigned int gameReset = 0; - if (params->Get(NVSDK_NGX_Parameter_Reset, &gameReset) == NVSDK_NGX_Result_Success && - gameReset != 0) + if (params->Get(NVSDK_NGX_Parameter_Reset, &gameReset) == NVSDK_NGX_Result_Success && gameReset != 0) { g_vk.reset = true; @@ -855,9 +851,8 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para // storage image, which is only legal in GENERAL, and nothing transitions it in between. It is the // upscaler's output, a storage image the upscaler has just written, so GENERAL is what it is. // Inert on the only hardware this model runs on, wrong everywhere it is read. - if (!g_vk.pass->Dispatch(cmdBuffer, encode, width, height, colour->Resource.ImageViewInfo.ImageView, - VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, g_vk.proxy.view, g_vk.keep.view, - VK_IMAGE_LAYOUT_GENERAL)) + if (!g_vk.pass->Dispatch(cmdBuffer, encode, width, height, colour->Resource.ImageViewInfo.ImageView, VK_NULL_HANDLE, + VK_NULL_HANDLE, VK_NULL_HANDLE, g_vk.proxy.view, g_vk.keep.view, VK_IMAGE_LAYOUT_GENERAL)) { Fail("the encode dispatch failed"); return; @@ -918,8 +913,7 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para if (g_vk.pass->Dispatch(cmdBuffer, meter, kMeterSide, kMeterSide, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, g_vk.meter.view, VK_NULL_HANDLE, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, exposure->Resource.ImageViewInfo.ImageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) { diff --git a/OptiScaler/dlssnr/DlssNr_Exposure.h b/OptiScaler/dlssnr/DlssNr_Exposure.h index c3f1fa01f..1f40b2052 100644 --- a/OptiScaler/dlssnr/DlssNr_Exposure.h +++ b/OptiScaler/dlssnr/DlssNr_Exposure.h @@ -15,11 +15,11 @@ inline float SanitizeExposure(float e) inline float GameWhite(float e, float p, float s) { e = SanitizeExposure(e); - p = (std::max)(FoldZeroToOne(p), 1e-4f); - s = (std::max)(FoldZeroToOne(s), 1e-4f); - const float gameW = p / (std::max)(e * s, 1e-4f); + p = (std::max) (FoldZeroToOne(p), 1e-4f); + s = (std::max) (FoldZeroToOne(s), 1e-4f); + const float gameW = p / (std::max) (e * s, 1e-4f); // T0 invert: return e * s / p; - return (std::max)(gameW, 1e-4f); + return (std::max) (gameW, 1e-4f); } struct WhitePointDecision @@ -39,7 +39,7 @@ inline WhitePointDecision DecideWhitePoint(uint32_t source, // WhitePointSo float exposureScale, // frame.ExposureScale float anchoredOrZero) // ExposureScan::AnchoredWhitePoint(...) or 0 { - WhitePointDecision d{scale, 0}; + WhitePointDecision d { scale, 0 }; if (!isHdrBuffer) return d; if (source == 0) diff --git a/OptiScaler/dlssnr/DlssNr_Menu.cpp b/OptiScaler/dlssnr/DlssNr_Menu.cpp index 95f7ca8b6..7ea496d06 100644 --- a/OptiScaler/dlssnr/DlssNr_Menu.cpp +++ b/OptiScaler/dlssnr/DlssNr_Menu.cpp @@ -5,7 +5,6 @@ #include "DlssNrFeature_Dx12.h" #include "DlssNr_ExposureScan.h" - #include #include @@ -44,8 +43,7 @@ static void HelpMarker(const char* tip) // live under the cursor; only the commit that triggers the rebuild waits for release. Cheap controls // that are just shader constants (detail, colour, paper white) do not use this -- they can afford to // apply live. -static bool DeferredSlider(const char* label, CustomOptional* opt, float mn, float mx, - const char* fmt = "%.2f") +static bool DeferredSlider(const char* label, CustomOptional* opt, float mn, float mx, const char* fmt = "%.2f") { static std::unordered_map pending; @@ -85,10 +83,10 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrEnabled = enabled; HelpMarker("Synthesises detail in the upscaler's output, before frame generation sees it." - "\n\nNeeds two similarly named files beside OptiScaler, one character apart:" - "\n nvngx_dlssnr.dll NVIDIA's model (~165 MB) -- you supply it" - "\n nvngx.dll_dlssnr.dll the forwarder (~13 KB) -- ships in this package" - "\nUndocumented and driven directly, so none of this is officially supported."); + "\n\nNeeds two similarly named files beside OptiScaler, one character apart:" + "\n nvngx_dlssnr.dll NVIDIA's model (~165 MB) -- you supply it" + "\n nvngx.dll_dlssnr.dll the forwarder (~13 KB) -- ships in this package" + "\nUndocumented and driven directly, so none of this is officially supported."); // The toggle can be bound to a key, and nobody would think to look for it under Keybinds // unless told. Dimmed, because it is a note rather than a setting. @@ -164,9 +162,8 @@ void RenderMenu(Config* config, float menuResScale) // reads live; only the commit waits. static int pendingScale = -1; - int scalePercent = pendingScale >= 0 - ? pendingScale - : (int) lroundf(config->DlssNrWorkingScale.value_or_default() * 100.0f); + int scalePercent = + pendingScale >= 0 ? pendingScale : (int) lroundf(config->DlssNrWorkingScale.value_or_default() * 100.0f); if (ImGui::SliderInt("Model resolution", &scalePercent, 25, 100, "%d%%")) pendingScale = scalePercent; @@ -178,14 +175,14 @@ void RenderMenu(Config* config, float menuResScale) } HelpMarker("What fraction of the frame the model works at. Cost falls with the square of" - "\nthis, so half resolution is roughly a quarter of the time." - "\n\nThe frame is never reduced. Only the model's contribution is computed small" - "\nand enlarged, so the picture underneath is untouched whatever this says." - "\n\nWhat it trades: the shading the model adds is broad and survives enlargement;" - "\nthe fine structure it synthesises does not, and softens. Worth having when the" - "\npass costs more than you want to pay for the detail it returns." - "\n\nThe frame itself stays at full detail whatever this says -- only the" - "\nmodel's own work is done small."); + "\nthis, so half resolution is roughly a quarter of the time." + "\n\nThe frame is never reduced. Only the model's contribution is computed small" + "\nand enlarged, so the picture underneath is untouched whatever this says." + "\n\nWhat it trades: the shading the model adds is broad and survives enlargement;" + "\nthe fine structure it synthesises does not, and softens. Worth having when the" + "\npass costs more than you want to pay for the detail it returns." + "\n\nThe frame itself stays at full detail whatever this says -- only the" + "\nmodel's own work is done small."); // Only meaningful below 100%: at the same rate the residual collapses to the model's own // picture and the two modes are identical, so the control says so by going grey. @@ -224,30 +221,30 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrTransferStrength = transfer; HelpMarker("How far the frame moves toward the model's picture." - "\n\nThe model's answer is not added to the frame -- it is a complete picture of its" - "\nown, rescaled so its luminance sits where the original says it should. This" - "\nblends between the two, so both ends are real pictures and everything between" - "\nthem is one too." - "\n\n0 gives back the keep (the upscaler frame after a clamp and one float" - "\nround-trip), not a capture 'before' and not a bit-exact upscaler copy." - "\n1 is the model's picture." - "\n\nAbove 1 carries on past it in the same direction, which is not something the" - "\nmodel asked for -- use it to see what it is doing, then come back down. This" - "\nis the control to push if you want more effect: Intensity belongs to the model" - "\nand it decides what to do with it."); + "\n\nThe model's answer is not added to the frame -- it is a complete picture of its" + "\nown, rescaled so its luminance sits where the original says it should. This" + "\nblends between the two, so both ends are real pictures and everything between" + "\nthem is one too." + "\n\n0 gives back the keep (the upscaler frame after a clamp and one float" + "\nround-trip), not a capture 'before' and not a bit-exact upscaler copy." + "\n1 is the model's picture." + "\n\nAbove 1 carries on past it in the same direction, which is not something the" + "\nmodel asked for -- use it to see what it is doing, then come back down. This" + "\nis the control to push if you want more effect: Intensity belongs to the model" + "\nand it decides what to do with it."); float colour = config->DlssNrColourStrength.value_or_default(); if (ImGui::SliderFloat("Colour strength", &colour, 0.0f, 1.0f, "%.2f")) config->DlssNrColourStrength = colour; HelpMarker("Whether the model's colour arrives with its light." - "\n\n0 keeps the game's own hue exactly -- every pixel is the original colour with" - "\nonly its brightness carrying the model's verdict. Game-accurate colour, with" - "\nthe detail. 1 brings the model's colour as well, in its own hue, clamped into" - "\nAP1 so nothing unreachable is asked for." - "\n\nThis cannot shift hue on its own: it interpolates between two finished" - "\npictures rather than adding a colour difference to one, which is what used to" - "\nlet a warm subject come back green."); + "\n\n0 keeps the game's own hue exactly -- every pixel is the original colour with" + "\nonly its brightness carrying the model's verdict. Game-accurate colour, with" + "\nthe detail. 1 brings the model's colour as well, in its own hue, clamped into" + "\nAP1 so nothing unreachable is asked for." + "\n\nThis cannot shift hue on its own: it interpolates between two finished" + "\npictures rather than adding a colour difference to one, which is what used to" + "\nlet a warm subject come back green."); ImGui::SeparatorText("Model"); @@ -259,8 +256,8 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrPreset = (uint32_t) preset; HelpMarker("Default leaves the choice to the model." - "\n\nNot the same scale as the super resolution or ray reconstruction presets --" - "\nthe same number means something different here."); + "\n\nNot the same scale as the super resolution or ray reconstruction presets --" + "\nthe same number means something different here."); static const char* nrStyleNames[] = { "Default (standard)", "Natural", "Cinematic" }; int style = (int) config->DlssNrStyle.value_or_default(); @@ -284,17 +281,16 @@ void RenderMenu(Config* config, float menuResScale) DeferredSlider("Intensity", &config->DlssNrIntensity, 0.0f, 2.0f); HelpMarker("The model's own strength control, applied inside it. Distinct from detail" - "\nstrength above, which scales the result afterwards."); + "\nstrength above, which scales the result afterwards."); DeferredSlider("Local structure", &config->DlssNrLocalStructure, 0.0f, 2.0f); DeferredSlider("Local tone", &config->DlssNrLocalTone, 0.0f, 2.0f); - DeferredSlider("Skin structure", &config->DlssNrSkinStructure, -1.0f, 2.0f); HelpMarker("-1 means follow local structure, and is the model's own default -- it is not a" - "\nstrength of zero. 0 and above set skin independently of the rest of the frame."); + "\nstrength of zero. 0 and above set skin independently of the rest of the frame."); bool autoMask = config->DlssNrAutoMask.value_or_default(); if (ImGui::Checkbox("Auto skin mask", &autoMask)) @@ -310,49 +306,49 @@ void RenderMenu(Config* config, float menuResScale) "already tone-mapped is passed over untouched and none of this applies."); { - // Logarithmic, because the useful range is not linear. A quarter to 240: the low end because - // a frame the game already tone mapped wants roughly 1, the high end because there is no - // principled ceiling -- this is a divisor on an open-ended linear buffer, and how far up a - // given game needs to go is a property of that game's exposure, not of anything we can bound. - // One tester was still improving at 100. A linear slider over that span would spend nine - // tenths of its travel on values nobody needs and never reach the ones they do. - // One dropdown, because there is one answer. - // - // This was two checkboxes that could both be on, and every attempt to stop that was a patch - // on a shape that should not have existed. Greying deadlocked -- each disabled the other, so - // once both were set the only way out was a button the notice never mentioned. Clearing - // worked but silently undid a setting somebody had made. Both were ways to stop an illegal - // state being REACHED; a single choice cannot reach it, because there is only one value to - // be in. - // - // Each option also says whether it can actually do anything in THIS game, in colour, so the - // choice is made on what is available rather than on what sounds best. - { - const bool vk = DlssNr::IsRunningVk(); - const bool canEnable = DlssNr::GameExposureCanEnable(); - const bool haveExposure = vk ? DlssNr::ExposureOfferedVk() : canEnable; + // Logarithmic, because the useful range is not linear. A quarter to 240: the low end because + // a frame the game already tone mapped wants roughly 1, the high end because there is no + // principled ceiling -- this is a divisor on an open-ended linear buffer, and how far up a + // given game needs to go is a property of that game's exposure, not of anything we can bound. + // One tester was still improving at 100. A linear slider over that span would spend nine + // tenths of its travel on values nobody needs and never reach the ones they do. + // One dropdown, because there is one answer. + // + // This was two checkboxes that could both be on, and every attempt to stop that was a patch + // on a shape that should not have existed. Greying deadlocked -- each disabled the other, so + // once both were set the only way out was a button the notice never mentioned. Clearing + // worked but silently undid a setting somebody had made. Both were ways to stop an illegal + // state being REACHED; a single choice cannot reach it, because there is only one value to + // be in. + // + // Each option also says whether it can actually do anything in THIS game, in colour, so the + // choice is made on what is available rather than on what sounds best. + { + const bool vk = DlssNr::IsRunningVk(); + const bool canEnable = DlssNr::GameExposureCanEnable(); + const bool haveExposure = vk ? DlssNr::ExposureOfferedVk() : canEnable; - const float anchorNow = DlssNr::ExposureScan::BestValue(); - const bool haveAnchor = !DlssNr::ExposureScan::Anchors().empty(); + const float anchorNow = DlssNr::ExposureScan::BestValue(); + const bool haveAnchor = !DlssNr::ExposureScan::Anchors().empty(); - static const char* sourceNames[] = { "Paper white only", "The game's own exposure", - "A buffer the scan found" }; + static const char* sourceNames[] = { "Paper white only", "The game's own exposure", + "A buffer the scan found" }; - int source = (int) config->DlssNrWhitePointSource.value_or_default(); + int source = (int) config->DlssNrWhitePointSource.value_or_default(); - if (source < 0 || source > 2) - source = 0; + if (source < 0 || source > 2) + source = 0; - if (ImGui::Combo("White point from", &source, sourceNames, IM_ARRAYSIZE(sourceNames))) - { - config->DlssNrWhitePointSource = (uint32_t) source; + if (ImGui::Combo("White point from", &source, sourceNames, IM_ARRAYSIZE(sourceNames))) + { + config->DlssNrWhitePointSource = (uint32_t) source; - // Nothing else to set. The scan asks the source whether it is wanted, so choosing - // it here is the whole of switching it on -- there is no second flag to keep in - // step, and so no way for the two to disagree. - } + // Nothing else to set. The scan asks the source whether it is wanted, so choosing + // it here is the whole of switching it on -- there is no second flag to keep in + // step, and so no way for the two to disagree. + } - HelpMarker("Where the number that divides the frame comes from." + HelpMarker("Where the number that divides the frame comes from." "\n\nPaper white only -- the slider below and nothing else. Right for a" "\ngame whose exposure never moves, wrong the moment it does: one" "\nconstant cannot serve a cave and a field." @@ -366,215 +362,207 @@ void RenderMenu(Config* config, float menuResScale) "\nwhich the anchor's ratio cancels. Needs anchoring once, and checking" "\nafterwards."); - // Availability, in colour, for the option currently chosen. - if (source == 1) - { - const auto ui = DlssNr::GameExposureUiState(); - const auto readout = DlssNr::GameExposureMenuReadout(); - const ImVec4 live(0.4f, 0.85f, 0.9f, 1.0f); - - switch (ui) + // Availability, in colour, for the option currently chosen. + if (source == 1) { - case DlssNr::GameExposureWait::NativeVulkan: - ImGui::TextDisabled("Menu may lag; native Vulkan picture uses the delayed courier."); - break; - case DlssNr::GameExposureWait::Waiting: - ImGui::TextDisabled("Waiting for Neural Rendering."); - break; - case DlssNr::GameExposureWait::Passthrough: - ImGui::TextDisabled("This buffer is already tone-mapped. Paper white is unused."); - break; - case DlssNr::GameExposureWait::Absent: - ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), - "This game supplies no exposure -- paper white is in use. Try " - "the scan instead."); - break; - case DlssNr::GameExposureWait::Available: - if (canEnable) - ImGui::TextDisabled("Menu may lag; picture is this frame."); - break; - } + const auto ui = DlssNr::GameExposureUiState(); + const auto readout = DlssNr::GameExposureMenuReadout(); + const ImVec4 live(0.4f, 0.85f, 0.9f, 1.0f); - if (readout.haveNumbers) - { - ImGui::TextColored(live, "Exposure %.3f · pre %.2f · scale %.2f", readout.e, - readout.p, readout.s); - ImGui::TextColored(live, "game white %.1f · trim %.2f× · in use %.1f", - readout.gameW, readout.slider, readout.slider * readout.gameW); - } - else - { - ImGui::TextColored(live, "Exposure — · pre %.2f · scale %.2f", readout.p, - readout.s); + switch (ui) + { + case DlssNr::GameExposureWait::NativeVulkan: + ImGui::TextDisabled("Menu may lag; native Vulkan picture uses the delayed courier."); + break; + case DlssNr::GameExposureWait::Waiting: + ImGui::TextDisabled("Waiting for Neural Rendering."); + break; + case DlssNr::GameExposureWait::Passthrough: + ImGui::TextDisabled("This buffer is already tone-mapped. Paper white is unused."); + break; + case DlssNr::GameExposureWait::Absent: + ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), + "This game supplies no exposure -- paper white is in use. Try " + "the scan instead."); + break; + case DlssNr::GameExposureWait::Available: + if (canEnable) + ImGui::TextDisabled("Menu may lag; picture is this frame."); + break; + } + + if (readout.haveNumbers) + { + ImGui::TextColored(live, "Exposure %.3f · pre %.2f · scale %.2f", readout.e, readout.p, + readout.s); + ImGui::TextColored(live, "game white %.1f · trim %.2f× · in use %.1f", readout.gameW, + readout.slider, readout.slider * readout.gameW); + } + else + { + ImGui::TextColored(live, "Exposure — · pre %.2f · scale %.2f", readout.p, readout.s); + } } - } - else if (source == 2) - { - // "Nothing found" and "found several, none of them moving" are different states, - // and this said the first for both. In GTA V the log carried eight candidates while - // the panel claimed there were none, which reads as the scan being broken when what - // it actually needs is for the light to change. - if (anchorNow <= 0.0f) + else if (source == 2) { - const unsigned int watching = (unsigned int) DlssNr::ExposureScan::Report().size(); - - if (watching == 0) + // "Nothing found" and "found several, none of them moving" are different states, + // and this said the first for both. In GTA V the log carried eight candidates while + // the panel claimed there were none, which reads as the scan being broken when what + // it actually needs is for the light to change. + if (anchorNow <= 0.0f) + { + const unsigned int watching = (unsigned int) DlssNr::ExposureScan::Report().size(); + + if (watching == 0) + ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), + "Nothing in this game is shaped like an exposure."); + else + ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), + "Watching %u, none moving yet -- go between light and shade.", watching); + } + else if (!haveAnchor) ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), - "Nothing in this game is shaped like an exposure."); + "Found one. Set paper white below until the picture looks " + "right, then press Anchor here."); else - ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), - "Watching %u, none moving yet -- go between light and shade.", - watching); + { + const float w = DlssNr::ExposureScan::AnchoredWhitePoint( + anchorNow, config->DlssNrScanInverted.value_or_default(), + config->DlssNrScanTrim.value_or_default()); + ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), + "Anchored. Scan %.5f -> white point %.2f", anchorNow, w); + } } - else if (!haveAnchor) - ImGui::TextColored(ImVec4(0.9f, 0.6f, 0.25f, 1.0f), - "Found one. Set paper white below until the picture looks " - "right, then press Anchor here."); - else + else if (haveExposure) { - const float w = DlssNr::ExposureScan::AnchoredWhitePoint( - anchorNow, config->DlssNrScanInverted.value_or_default(), - config->DlssNrScanTrim.value_or_default()); ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), - "Anchored. Scan %.5f -> white point %.2f", anchorNow, w); + "This game supplies an exposure -- the option above would use it."); } } - else if (haveExposure) - { - ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), - "This game supplies an exposure -- the option above would use it."); - } - } - + // A measured suggestion for paper white used to sit here and has been withdrawn. + // + // It took the 90th percentile of per-tile peak luminance from the untouched frame, which is a + // statement about scene content rather than about the buffer's scale. In Nioh 3, where the + // right answer is about 240, it offered 8 -- because most tiles are shadow and the percentile + // sits wherever most tiles are. The guard meant to catch that compared each tile against the + // frame's own brightest, which is scale-free and therefore passes on a black screen: the same + // relative-threshold mistake the white point meter was removed for, made a second time. + // + // A wrong number offered confidently is worse than no number, so nothing is offered. What + // replaces it has to be a measurement of the game's own exposure rather than of its scenery: + // the exposure texture where a game supplies one, and otherwise the ratio between the + // scene-referred buffer and the finished frame, which is that exposure by definition. + // Two controls, not one control with two meanings. + // + // These are different quantities. The manual path wants an absolute divisor on an open-ended + // linear buffer -- Nioh 3 needs about 240 -- and the exposure path wants a multiplier on a + // number the game already supplied, where 1 is correct and anything far from it says the read + // is wrong rather than that somebody prefers it. + // + // They used to share one stored value, narrowed to 0.25..4 when the toggle was on. That kept + // a ruinous value unreachable but left two worse problems: moving the slider in one mode + // silently destroyed the number found in the other, and there was no way back to "just take + // the game's answer" short of knowing that the number for it was 1. Separate values fix both. + // Switching modes is now non-destructive in both directions. + // The trim belongs to both automatic sources, since both end in "the game's number times a + // little". Only the manual source gets the absolute slider. + // One slider per source, each remembering its own number. + // + // A trim on the game's exposure and a trim on a buffer the scan found are trims on different + // things, and a value found against one means nothing against the other. Sharing them meant + // changing source silently carried a number across, so a picture that had been tuned came + // back wrong for a reason nothing on screen explained. + // + // The scan before it is anchored is the exception, and it has to be: anchoring captures an + // absolute white point, so there must be an absolute slider to set. Showing a trim there + // asked people to "set paper white below" next to a control that was not paper white. + const int wpSource = (int) config->DlssNrWhitePointSource.value_or_default(); + + // Which anchor row the paper-white slider edits, or -1 for the live unanchored point. Menu- + // local and not persisted; the anchor block below sets it when a row is clicked. Declared + // here because both the slider (this block) and the table (below) read it in the same frame. + static int selectedAnchor = -1; + auto anchors = DlssNr::ExposureScan::Anchors(); + if (selectedAnchor >= (int) anchors.size()) + selectedAnchor = -1; + + if (wpSource == 2) + { + // The scanned source is calibrated by the anchor table below. The slider here is the + // paper white: it edits the selected row's white point, or -- with nothing selected -- + // the live value the next Anchor press will capture. + const bool editingRow = selectedAnchor >= 0 && selectedAnchor < (int) anchors.size(); + float pw = + editingRow ? anchors[selectedAnchor].white : config->DlssNrWhitePointScale.value_or_default(); - - // A measured suggestion for paper white used to sit here and has been withdrawn. - // - // It took the 90th percentile of per-tile peak luminance from the untouched frame, which is a - // statement about scene content rather than about the buffer's scale. In Nioh 3, where the - // right answer is about 240, it offered 8 -- because most tiles are shadow and the percentile - // sits wherever most tiles are. The guard meant to catch that compared each tile against the - // frame's own brightest, which is scale-free and therefore passes on a black screen: the same - // relative-threshold mistake the white point meter was removed for, made a second time. - // - // A wrong number offered confidently is worse than no number, so nothing is offered. What - // replaces it has to be a measurement of the game's own exposure rather than of its scenery: - // the exposure texture where a game supplies one, and otherwise the ratio between the - // scene-referred buffer and the finished frame, which is that exposure by definition. - - // Two controls, not one control with two meanings. - // - // These are different quantities. The manual path wants an absolute divisor on an open-ended - // linear buffer -- Nioh 3 needs about 240 -- and the exposure path wants a multiplier on a - // number the game already supplied, where 1 is correct and anything far from it says the read - // is wrong rather than that somebody prefers it. - // - // They used to share one stored value, narrowed to 0.25..4 when the toggle was on. That kept - // a ruinous value unreachable but left two worse problems: moving the slider in one mode - // silently destroyed the number found in the other, and there was no way back to "just take - // the game's answer" short of knowing that the number for it was 1. Separate values fix both. - // Switching modes is now non-destructive in both directions. - // The trim belongs to both automatic sources, since both end in "the game's number times a - // little". Only the manual source gets the absolute slider. - // One slider per source, each remembering its own number. - // - // A trim on the game's exposure and a trim on a buffer the scan found are trims on different - // things, and a value found against one means nothing against the other. Sharing them meant - // changing source silently carried a number across, so a picture that had been tuned came - // back wrong for a reason nothing on screen explained. - // - // The scan before it is anchored is the exception, and it has to be: anchoring captures an - // absolute white point, so there must be an absolute slider to set. Showing a trim there - // asked people to "set paper white below" next to a control that was not paper white. - const int wpSource = (int) config->DlssNrWhitePointSource.value_or_default(); - - // Which anchor row the paper-white slider edits, or -1 for the live unanchored point. Menu- - // local and not persisted; the anchor block below sets it when a row is clicked. Declared - // here because both the slider (this block) and the table (below) read it in the same frame. - static int selectedAnchor = -1; - auto anchors = DlssNr::ExposureScan::Anchors(); - if (selectedAnchor >= (int) anchors.size()) - selectedAnchor = -1; - - if (wpSource == 2) - { - // The scanned source is calibrated by the anchor table below. The slider here is the - // paper white: it edits the selected row's white point, or -- with nothing selected -- - // the live value the next Anchor press will capture. - const bool editingRow = selectedAnchor >= 0 && selectedAnchor < (int) anchors.size(); - - float pw = editingRow ? anchors[selectedAnchor].white - : config->DlssNrWhitePointScale.value_or_default(); - - char lbl[48]; - if (editingRow) - snprintf(lbl, sizeof(lbl), "Paper white (editing point %d)", selectedAnchor + 1); - else - snprintf(lbl, sizeof(lbl), "Paper white"); - - if (ImGui::SliderFloat(lbl, &pw, 0.25f, 2000.0f, "%.2fx", ImGuiSliderFlags_Logarithmic)) - { + char lbl[48]; if (editingRow) + snprintf(lbl, sizeof(lbl), "Paper white (editing point %d)", selectedAnchor + 1); + else + snprintf(lbl, sizeof(lbl), "Paper white"); + + if (ImGui::SliderFloat(lbl, &pw, 0.25f, 2000.0f, "%.2fx", ImGuiSliderFlags_Logarithmic)) { - DlssNr::ExposureScan::AnchorSetWhite(selectedAnchor, pw); - config->DlssNrScanAnchors = DlssNr::ExposureScan::SerializeAnchors(); + if (editingRow) + { + DlssNr::ExposureScan::AnchorSetWhite(selectedAnchor, pw); + config->DlssNrScanAnchors = DlssNr::ExposureScan::SerializeAnchors(); + } + else + config->DlssNrWhitePointScale = pw; } - else - config->DlssNrWhitePointScale = pw; - } - HelpMarker("The white point for the selected calibration point, or -- with no row" + HelpMarker("The white point for the selected calibration point, or -- with no row" "\nselected -- the value the next Anchor press captures." "\n\nSet it until the picture looks right here, then Anchor. Move to very" "\ndifferent light and do it again: two points fix the buffer's real" "\nrelationship and the white point holds between them. Click a row below" "\nto come back and adjust that point; click it again to let go."); - // A global multiplier on the interpolated result, kept for parity with the other - // sources. The points themselves are the real control here, so this stays near 1. - float trim = config->DlssNrScanTrim.value_or_default(); + // A global multiplier on the interpolated result, kept for parity with the other + // sources. The points themselves are the real control here, so this stays near 1. + float trim = config->DlssNrScanTrim.value_or_default(); - if (ImGui::SliderFloat("Trim (x the scan)", &trim, 0.25f, 4.0f, "%.2fx", - ImGuiSliderFlags_Logarithmic)) - config->DlssNrScanTrim = std::clamp(trim, 0.25f, 4.0f); + if (ImGui::SliderFloat("Trim (x the scan)", &trim, 0.25f, 4.0f, "%.2fx", ImGuiSliderFlags_Logarithmic)) + config->DlssNrScanTrim = std::clamp(trim, 0.25f, 4.0f); - ImGui::SameLine(); + ImGui::SameLine(); - if (ImGui::SmallButton("Reset##scantrim")) - config->DlssNrScanTrim = 1.0f; - } - else if (wpSource == 1) - { - const bool ofScan = false; + if (ImGui::SmallButton("Reset##scantrim")) + config->DlssNrScanTrim = 1.0f; + } + else if (wpSource == 1) + { + const bool ofScan = false; - float trim = ofScan ? config->DlssNrScanTrim.value_or_default() - : config->DlssNrWhitePointTrim.value_or_default(); + float trim = ofScan ? config->DlssNrScanTrim.value_or_default() + : config->DlssNrWhitePointTrim.value_or_default(); - if (ImGui::SliderFloat(ofScan ? "Trim (x the scan)" : "Trim (x the game's exposure)", &trim, - 0.25f, 4.0f, "%.2fx", ImGuiSliderFlags_Logarithmic)) - { - if (ofScan) - config->DlssNrScanTrim = std::clamp(trim, 0.25f, 4.0f); - else - config->DlssNrWhitePointTrim = std::clamp(trim, 0.25f, 4.0f); - } + if (ImGui::SliderFloat(ofScan ? "Trim (x the scan)" : "Trim (x the game's exposure)", &trim, 0.25f, + 4.0f, "%.2fx", ImGuiSliderFlags_Logarithmic)) + { + if (ofScan) + config->DlssNrScanTrim = std::clamp(trim, 0.25f, 4.0f); + else + config->DlssNrWhitePointTrim = std::clamp(trim, 0.25f, 4.0f); + } - ImGui::SameLine(); + ImGui::SameLine(); - // Deliberately always present rather than greyed at 1. The point of it is that the safe - // value is one click away without having to know what the safe value is. - if (ImGui::SmallButton("Reset##wptrim")) - { - if (ofScan) - config->DlssNrScanTrim = 1.0f; - else - config->DlssNrWhitePointTrim = 1.0f; - } + // Deliberately always present rather than greyed at 1. The point of it is that the safe + // value is one click away without having to know what the safe value is. + if (ImGui::SmallButton("Reset##wptrim")) + { + if (ofScan) + config->DlssNrScanTrim = 1.0f; + else + config->DlssNrWhitePointTrim = 1.0f; + } - HelpMarker("A multiplier on the exposure the game supplied. 1.00x takes its number" + HelpMarker("A multiplier on the exposure the game supplied. 1.00x takes its number" "\nexactly, and that is the right answer here." "\n\nThis is not a fudge factor. If a game needs the trim far from 1 to look" "\nright, that is evidence the exposure being read is wrong for that game," @@ -583,64 +571,63 @@ void RenderMenu(Config* config, float menuResScale) "\nhiding it." "\n\nYour manual paper white is kept separately and comes back untouched if" "\nyou switch the option above off."); - } - else - { - // Logarithmic, because the useful range is not linear. A quarter to 2000: the low end - // because a frame the game already tone mapped wants roughly 1, the high end because - // there is no principled ceiling -- this is a divisor on an open-ended linear buffer, and - // how far up a given game needs to go is a property of that game's exposure rather than - // of anything that can be bounded here. One tester was still improving at 100. - float wpScale = config->DlssNrWhitePointScale.value_or_default(); - - if (ImGui::SliderFloat("Paper white", &wpScale, 0.25f, 2000.0f, "%.2fx", - ImGuiSliderFlags_Logarithmic)) - config->DlssNrWhitePointScale = wpScale; - - HelpMarker("What the frame is divided by before the model sees it. There is no other white" - "\npoint; this is the whole of it." - "\n\nThe model was trained on finished frames where white sits at 1. The" - "\nupscaler's output is linear and open-ended, so something has to say where" - "\nwhite is -- and where the game's DLSS buffer is linear HDR, that number is" - "\nrarely anywhere near 1. Measured in Monster Hunter Wilds it takes 16 or more" - "\nbefore the model's detail reaches the frame at all, and the value that suits" - "\na shaded camp is still too small for the same game out in daylight." - "\n\nToo low and almost every pixel trips the soft knee: the model is shown a" - "\nflat near-white picture, its answer is scaled away, and only its hue" - "\nsurvives -- which reads as a colour cast rather than as lost detail. Too" - "\nhigh and it is shown an underexposed one, its answer degrades, and this same" - "\nnumber multiplies that error on the way out." - "\n\nRaise it until the picture stops improving. Past that point it does not" - "\nplateau, it gets worse in the other direction." - "\n\nThis was once a multiplier on a measured white point. The measurement is" - "\ngone: it read scene brightness rather than where white belongs, handed the" - "\nmodel a picture three times too dark, and left the highlight path nothing to" - "\ngive back." - "\n\nAt strength zero the frame is still bit-identical whatever this says."); - } + } + else + { + // Logarithmic, because the useful range is not linear. A quarter to 2000: the low end + // because a frame the game already tone mapped wants roughly 1, the high end because + // there is no principled ceiling -- this is a divisor on an open-ended linear buffer, and + // how far up a given game needs to go is a property of that game's exposure rather than + // of anything that can be bounded here. One tester was still improving at 100. + float wpScale = config->DlssNrWhitePointScale.value_or_default(); + + if (ImGui::SliderFloat("Paper white", &wpScale, 0.25f, 2000.0f, "%.2fx", ImGuiSliderFlags_Logarithmic)) + config->DlssNrWhitePointScale = wpScale; + + HelpMarker("What the frame is divided by before the model sees it. There is no other white" + "\npoint; this is the whole of it." + "\n\nThe model was trained on finished frames where white sits at 1. The" + "\nupscaler's output is linear and open-ended, so something has to say where" + "\nwhite is -- and where the game's DLSS buffer is linear HDR, that number is" + "\nrarely anywhere near 1. Measured in Monster Hunter Wilds it takes 16 or more" + "\nbefore the model's detail reaches the frame at all, and the value that suits" + "\na shaded camp is still too small for the same game out in daylight." + "\n\nToo low and almost every pixel trips the soft knee: the model is shown a" + "\nflat near-white picture, its answer is scaled away, and only its hue" + "\nsurvives -- which reads as a colour cast rather than as lost detail. Too" + "\nhigh and it is shown an underexposed one, its answer degrades, and this same" + "\nnumber multiplies that error on the way out." + "\n\nRaise it until the picture stops improving. Past that point it does not" + "\nplateau, it gets worse in the other direction." + "\n\nThis was once a multiplier on a measured white point. The measurement is" + "\ngone: it read scene brightness rather than where white belongs, handed the" + "\nmodel a picture three times too dark, and left the highlight path nothing to" + "\ngive back." + "\n\nAt strength zero the frame is still bit-identical whatever this says."); + } - // Directly under the white point, because that is the number it moves and the number the - // anchor captures. It used to sit under Inspect, a whole section away from the slider it - // reads, which left "Anchor here" looking like a control for something else entirely. - { - // No checkbox here any more. - // - // The dropdown above says whether the scan is the white point's source, and that is - // the only reason anybody using this would want it running. A second control could - // only agree with the dropdown or contradict it, and both were on offer: it began as - // a redundant question and became a way to switch off the thing the chosen source - // depended on. - // - // The ini key survives as a developer override for the one case a user has no reason - // to want -- running the scan in a game that supplies a REAL exposure, so the log can - // compare the two. That is validation, and validation does not need a widget. - // - // Worth keeping written down, since the panel no longer says it: the scan matches - // buffers by SHAPE, and shape is a weak filter. In GTA V -- a game that supplies a - // real exposure, so the right answer sat visible beside it -- the best candidate was - // a 1x1 R32_FLOAT that climbed in a straight line for seventeen minutes while the - // true exposure held still. Their ratio moved 14x. That is an accumulator, not an - // eye adaptation. + // Directly under the white point, because that is the number it moves and the number the + // anchor captures. It used to sit under Inspect, a whole section away from the slider it + // reads, which left "Anchor here" looking like a control for something else entirely. + { + // No checkbox here any more. + // + // The dropdown above says whether the scan is the white point's source, and that is + // the only reason anybody using this would want it running. A second control could + // only agree with the dropdown or contradict it, and both were on offer: it began as + // a redundant question and became a way to switch off the thing the chosen source + // depended on. + // + // The ini key survives as a developer override for the one case a user has no reason + // to want -- running the scan in a game that supplies a REAL exposure, so the log can + // compare the two. That is validation, and validation does not need a widget. + // + // Worth keeping written down, since the panel no longer says it: the scan matches + // buffers by SHAPE, and shape is a weak filter. In GTA V -- a game that supplies a + // real exposure, so the right answer sat visible beside it -- the best candidate was + // a 1x1 R32_FLOAT that climbed in a straight line for seventeen minutes while the + // true exposure held still. Their ratio moved 14x. That is an accumulator, not an + // eye adaptation. // Only where it means something. The lamp reads the scan, so offering it beside a // white point that comes from the game's own exposure is offering a control that @@ -652,49 +639,49 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrScanMeter = meter; HelpMarker("A lamp in the corner: red for dark, green for full light, and the" - "\nshades between, with the reading beside it." - "\n\nIt is how you see at a glance that the scan is TRACKING rather" - "\nthan merely running. Walk into shade and it should slide toward" - "\nred; step out and it should go green. If it moves the wrong way," - "\nthat is what the setting above is for." - "\n\nPurely a readout. It changes nothing."); - - // Shown when the scan is actually running, whichever way it got switched on. - if (DlssNr::ExposureScan::Scanning()) - { - // Anchoring: one press, then it never needs touching again. - // - // The absolute white point cannot come out of a buffer whose units are unknown. - // Every value AFTER the first can: only the ratio against the anchor is used, so - // whatever the number means, it cancels. That is why this is a button and not a - // measurement -- the one thing a person can supply that no amount of cleverness - // can is "this looks right to me". - int which = 0; - float low = 0.0f, high = 0.0f; - const float live = DlssNr::ExposureScan::BestValue(&which, &low, &high); - - const bool isSource = config->DlssNrWhitePointSource.value_or_default() == 2; - - // Anchor captures (currentScan, currentPaperWhite) and ADDS a row -- it does not - // replace. One row is the old single-anchor ratio law; add a second in different - // light and the white point is interpolated between the points, so it holds across - // the whole range instead of only near one anchor. Greyed unless the scan is the - // chosen source and it currently has a value to capture. - ImGui::BeginDisabled(live <= 0.0f || !isSource); - - if (ImGui::Button("Anchor here")) + "\nshades between, with the reading beside it." + "\n\nIt is how you see at a glance that the scan is TRACKING rather" + "\nthan merely running. Walk into shade and it should slide toward" + "\nred; step out and it should go green. If it moves the wrong way," + "\nthat is what the setting above is for." + "\n\nPurely a readout. It changes nothing."); + + // Shown when the scan is actually running, whichever way it got switched on. + if (DlssNr::ExposureScan::Scanning()) { - if (DlssNr::ExposureScan::AnchorAdd( - live, std::max(0.01f, config->DlssNrWhitePointScale.value_or_default()))) + // Anchoring: one press, then it never needs touching again. + // + // The absolute white point cannot come out of a buffer whose units are unknown. + // Every value AFTER the first can: only the ratio against the anchor is used, so + // whatever the number means, it cancels. That is why this is a button and not a + // measurement -- the one thing a person can supply that no amount of cleverness + // can is "this looks right to me". + int which = 0; + float low = 0.0f, high = 0.0f; + const float live = DlssNr::ExposureScan::BestValue(&which, &low, &high); + + const bool isSource = config->DlssNrWhitePointSource.value_or_default() == 2; + + // Anchor captures (currentScan, currentPaperWhite) and ADDS a row -- it does not + // replace. One row is the old single-anchor ratio law; add a second in different + // light and the white point is interpolated between the points, so it holds across + // the whole range instead of only near one anchor. Greyed unless the scan is the + // chosen source and it currently has a value to capture. + ImGui::BeginDisabled(live <= 0.0f || !isSource); + + if (ImGui::Button("Anchor here")) { - config->DlssNrScanAnchors = DlssNr::ExposureScan::SerializeAnchors(); - selectedAnchor = -1; + if (DlssNr::ExposureScan::AnchorAdd( + live, std::max(0.01f, config->DlssNrWhitePointScale.value_or_default()))) + { + config->DlssNrScanAnchors = DlssNr::ExposureScan::SerializeAnchors(); + selectedAnchor = -1; + } } - } - ImGui::EndDisabled(); + ImGui::EndDisabled(); - HelpMarker("Set the paper white above until the picture looks right, then press this." + HelpMarker("Set the paper white above until the picture looks right, then press this." "\n\nThe first press calibrates one point -- the white point then" "\nfollows the scan by ratio from there, as before. Walk into very" "\ndifferent light, set paper white again, and press it again: the" @@ -703,141 +690,137 @@ void RenderMenu(Config* config, float menuResScale) "\n\nThe table is per game and shareable: one person calibrates a game" "\nand the numbers are the same for everyone who takes the profile."); - if (!isSource) - ImGui::TextDisabled("(the scan is only watching -- the white point above comes " - "from somewhere else)"); - - if (!anchors.empty()) - { - // The row nearest the live scan value (in log space) is the one driving the - // picture right now; mark it so the user can see which calibration is in effect. - int active = 0; - float bestDist = 1e30f; - const float liveLog = std::log(std::max(live, 1e-6f)); + if (!isSource) + ImGui::TextDisabled("(the scan is only watching -- the white point above comes " + "from somewhere else)"); - for (size_t i = 0; i < anchors.size(); ++i) + if (!anchors.empty()) { - const float d = - std::fabs(std::log(std::max(anchors[i].scan, 1e-6f)) - liveLog); - if (d < bestDist) + // The row nearest the live scan value (in log space) is the one driving the + // picture right now; mark it so the user can see which calibration is in effect. + int active = 0; + float bestDist = 1e30f; + const float liveLog = std::log(std::max(live, 1e-6f)); + + for (size_t i = 0; i < anchors.size(); ++i) { - bestDist = d; - active = (int) i; + const float d = std::fabs(std::log(std::max(anchors[i].scan, 1e-6f)) - liveLog); + if (d < bestDist) + { + bestDist = d; + active = (int) i; + } } - } - for (size_t i = 0; i < anchors.size(); ++i) - { - ImGui::PushID((int) i); - - // Delete first, so its click is never swallowed by the row-wide Selectable. - if (ImGui::SmallButton("x")) + for (size_t i = 0; i < anchors.size(); ++i) { - DlssNr::ExposureScan::AnchorRemove((int) i); - config->DlssNrScanAnchors = DlssNr::ExposureScan::SerializeAnchors(); - if (selectedAnchor == (int) i) - selectedAnchor = -1; - else if (selectedAnchor > (int) i) - --selectedAnchor; - ImGui::PopID(); - continue; - } + ImGui::PushID((int) i); + + // Delete first, so its click is never swallowed by the row-wide Selectable. + if (ImGui::SmallButton("x")) + { + DlssNr::ExposureScan::AnchorRemove((int) i); + config->DlssNrScanAnchors = DlssNr::ExposureScan::SerializeAnchors(); + if (selectedAnchor == (int) i) + selectedAnchor = -1; + else if (selectedAnchor > (int) i) + --selectedAnchor; + ImGui::PopID(); + continue; + } - ImGui::SameLine(); + ImGui::SameLine(); - const bool sel = (int) i == selectedAnchor; - char row[96]; - snprintf(row, sizeof(row), "%s scan %.4f -> white %.2f%s", - ((int) i == active && isSource) ? ">" : " ", anchors[i].scan, - anchors[i].white, sel ? " [editing]" : ""); + const bool sel = (int) i == selectedAnchor; + char row[96]; + snprintf(row, sizeof(row), "%s scan %.4f -> white %.2f%s", + ((int) i == active && isSource) ? ">" : " ", anchors[i].scan, anchors[i].white, + sel ? " [editing]" : ""); - // Click selects the row (slider edits it); click again deselects (slider - // returns to the live unanchored point). - if (ImGui::Selectable(row, sel)) - selectedAnchor = sel ? -1 : (int) i; + // Click selects the row (slider edits it); click again deselects (slider + // returns to the live unanchored point). + if (ImGui::Selectable(row, sel)) + selectedAnchor = sel ? -1 : (int) i; - ImGui::PopID(); - } + ImGui::PopID(); + } - ImGui::TextDisabled("Click a row to edit it with the slider above; click it again" - " to control the live point. > is the point in use now."); - } + ImGui::TextDisabled("Click a row to edit it with the slider above; click it again" + " to control the live point. > is the point in use now."); + } - // The direction flag only means anything with a single point; with two or more the - // direction the white point moves is already fixed by the data. - if (anchors.size() == 1) - { - bool inverted = config->DlssNrScanInverted.value_or_default(); - if (ImGui::Checkbox("The number runs the other way", &inverted)) - config->DlssNrScanInverted = inverted; + // The direction flag only means anything with a single point; with two or more the + // direction the white point moves is already fixed by the data. + if (anchors.size() == 1) + { + bool inverted = config->DlssNrScanInverted.value_or_default(); + if (ImGui::Checkbox("The number runs the other way", &inverted)) + config->DlssNrScanInverted = inverted; - HelpMarker("Flip this if the picture gets worse in the direction it should be" + HelpMarker("Flip this if the picture gets worse in the direction it should be" "\ngetting better. Most engines store an exposure that falls as" "\nthe scene brightens; some store its reciprocal, and a buffer" "\nfound by shape does not say which. Add a second anchor point in" "\ndifferent light and this is decided for you, so it disappears."); - } + } - if (isSource && live > 0.0f && !anchors.empty()) - { - const float w = DlssNr::ExposureScan::AnchoredWhitePoint( - live, config->DlssNrScanInverted.value_or_default(), - config->DlssNrScanTrim.value_or_default()); + if (isSource && live > 0.0f && !anchors.empty()) + { + const float w = DlssNr::ExposureScan::AnchoredWhitePoint( + live, config->DlssNrScanInverted.value_or_default(), + config->DlssNrScanTrim.value_or_default()); - ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), - "Scan %.5f -> white point %.2f (%u point%s)", live, w, - (unsigned) anchors.size(), anchors.size() == 1 ? "" : "s"); - } + ImGui::TextColored(ImVec4(0.45f, 0.8f, 0.45f, 1.0f), + "Scan %.5f -> white point %.2f (%u point%s)", live, w, + (unsigned) anchors.size(), anchors.size() == 1 ? "" : "s"); + } - // Everything below is read-out rather than control: what the scan is looking at and - // how to tell whether it found the right thing. Folded away because the two decisions - // that matter -- anchor, and which way the number runs -- are above it. - if (ImGui::TreeNode("Advanced")) - { + // Everything below is read-out rather than control: what the scan is looking at and + // how to tell whether it found the right thing. Folded away because the two decisions + // that matter -- anchor, and which way the number runs -- are above it. + if (ImGui::TreeNode("Advanced")) + { - const auto found = DlssNr::ExposureScan::Report(); - const char* why = DlssNr::ExposureScan::Status(); + const auto found = DlssNr::ExposureScan::Report(); + const char* why = DlssNr::ExposureScan::Status(); - if (found.empty()) - { - ImGui::TextDisabled("%s", why != nullptr && why[0] != 0 - ? why - : "nothing matched yet."); - } - else - { - for (size_t i = 0; i < found.size(); ++i) + if (found.empty()) { - const auto& c = found[i]; - - if (c.reads == 0) + ImGui::TextDisabled("%s", why != nullptr && why[0] != 0 ? why : "nothing matched yet."); + } + else + { + for (size_t i = 0; i < found.size(); ++i) { - ImGui::TextDisabled("%zu. %s -- not read yet", i + 1, c.shape.c_str()); - continue; + const auto& c = found[i]; + + if (c.reads == 0) + { + ImGui::TextDisabled("%zu. %s -- not read yet", i + 1, c.shape.c_str()); + continue; + } + + // Moving is the whole signal, so it is the thing that is coloured. + ImGui::TextColored(c.moves ? ImVec4(0.45f, 0.8f, 0.45f, 1.0f) + : ImVec4(0.6f, 0.6f, 0.6f, 1.0f), + "%zu. %s = %.5f (seen %.5f..%.5f) %s", i + 1, c.shape.c_str(), + c.latest, c.lowest, c.highest, c.moves ? "MOVES" : "flat so far"); } - // Moving is the whole signal, so it is the thing that is coloured. - ImGui::TextColored(c.moves ? ImVec4(0.45f, 0.8f, 0.45f, 1.0f) - : ImVec4(0.6f, 0.6f, 0.6f, 1.0f), - "%zu. %s = %.5f (seen %.5f..%.5f) %s", i + 1, - c.shape.c_str(), c.latest, c.lowest, c.highest, - c.moves ? "MOVES" : "flat so far"); + ImGui::TextDisabled("Walk from shade into daylight. A real exposure moves."); + ImGui::TextDisabled("One that only ever climbs is a counter, not an exposure."); } - ImGui::TextDisabled("Walk from shade into daylight. A real exposure moves."); - ImGui::TextDisabled("One that only ever climbs is a counter, not an exposure."); + ImGui::TreePop(); } - - ImGui::TreePop(); } } - } - float maxRatio = config->DlssNrMaxRatio.value_or_default(); - if (ImGui::SliderFloat("Highlight guard", &maxRatio, 1.0f, 8.0f, "%.1fx")) - config->DlssNrMaxRatio = maxRatio; + float maxRatio = config->DlssNrMaxRatio.value_or_default(); + if (ImGui::SliderFloat("Highlight guard", &maxRatio, 1.0f, 8.0f, "%.1fx")) + config->DlssNrMaxRatio = maxRatio; - HelpMarker("The most the pass may move any pixel, as a multiple of what it already was --" + HelpMarker("The most the pass may move any pixel, as a multiple of what it already was --" "\nin both directions. A pixel may not be brightened past this, nor darkened" "\npast its reciprocal." "\n\nLights are where the model has least to say and where rescaling its answer" @@ -850,7 +833,6 @@ void RenderMenu(Config* config, float menuResScale) "\nsoft knee never fires, the composition reduces to the model's own picture," "\nand it collapsed the frame's red by more than half, once per frame, while an" "\nupward-only guard on an unreachable branch watched it happen."); - } ImGui::SeparatorText("Inspect"); @@ -867,7 +849,6 @@ void RenderMenu(Config* config, float menuResScale) // instrument, and the reason for keeping the code is that the depth reading was taken // while the exaggeration slider was still at 32x and deserves a clean re-run. - if (DlssNr::CaptureInProgress()) { ImGui::TextDisabled("Capturing..."); @@ -878,12 +859,12 @@ void RenderMenu(Config* config, float menuResScale) } HelpMarker("Writes eight consecutive frames twice: as the upscaler produced them, and again" - "\nonce the model's edit was applied." - "\n\nSame frames, same run, one variable -- which is what comparing two video" - "\ncaptures can never be, since they have different camera paths and a codec in" - "\nbetween that discards exactly the fine temporal detail in question." - "\n\nRaw, into a dlssnr-capture folder beside OptiScaler. Bounded to eight frames," - "\nand each run overwrites the last."); + "\nonce the model's edit was applied." + "\n\nSame frames, same run, one variable -- which is what comparing two video" + "\ncaptures can never be, since they have different camera paths and a codec in" + "\nbetween that discards exactly the fine temporal detail in question." + "\n\nRaw, into a dlssnr-capture folder beside OptiScaler. Bounded to eight frames," + "\nand each run overwrites the last."); static const char* compareNames[] = { "Off", "Side by side", "Wipe" }; int compare = (int) config->DlssNrCompare.value_or_default(); @@ -891,14 +872,14 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrCompare = (uint32_t) compare; HelpMarker("Shows the pass against itself, so the two can be seen at once rather than" - "\ntoggled and remembered." - "\n\nSide by side puts the whole frame in each half, untouched on the left and" - "\nedited on the right. Both halves are squeezed horizontally to fit, so it is" - "\nfor looking at rather than playing in." - "\n\nWipe cuts a single frame at the split and resamples nothing, so the picture" - "\nis the right shape and can be played normally. Drag the split below; it is a" - "\nstored setting and stays put once the menu is closed." - "\n\nNeither needs the menu open to keep working. A hairline marks the join."); + "\ntoggled and remembered." + "\n\nSide by side puts the whole frame in each half, untouched on the left and" + "\nedited on the right. Both halves are squeezed horizontally to fit, so it is" + "\nfor looking at rather than playing in." + "\n\nWipe cuts a single frame at the split and resamples nothing, so the picture" + "\nis the right shape and can be played normally. Drag the split below; it is a" + "\nstored setting and stays put once the menu is closed." + "\n\nNeither needs the menu open to keep working. A hairline marks the join."); if (compare != 0) { @@ -911,10 +892,10 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrCompareTags = tags; HelpMarker("Writes which side is which onto the frame itself, so a screenshot still" - "\nsays so after it has left this machine. Drawn into the picture's own" - "\nplane: in the wipe the split reveals and hides the label exactly as it" - "\ndoes the images, and there is nothing to drag. Swap sides moves the" - "\nlabels with their pictures."); + "\nsays so after it has left this machine. Drawn into the picture's own" + "\nplane: in the wipe the split reveals and hides the label exactly as it" + "\ndoes the images, and there is nothing to drag. Swap sides moves the" + "\nlabels with their pictures."); if (tags) { @@ -924,10 +905,10 @@ void RenderMenu(Config* config, float menuResScale) } HelpMarker("Puts the edited frame on the other side." - "\n\nWorth doing once you have decided which you prefer: the eye is not" - "\neven-handed about left and right, and a difference can read as an" - "\nimprovement purely from where it sits. If the same side still wins after" - "\nswapping, it is the pass you are seeing and not the placement."); + "\n\nWorth doing once you have decided which you prefer: the eye is not" + "\neven-handed about left and right, and a difference can read as an" + "\nimprovement purely from where it sits. If the same side still wins after" + "\nswapping, it is the pass you are seeing and not the placement."); } if (compare == 1) @@ -937,11 +918,11 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrCompareZoom = std::clamp(zoom, 1.0f, 2.0f); HelpMarker("How much of the frame each half shows." - "\n\nA half is half as wide as the frame and just as tall, so the frame" - "\ncannot fill it and keep its shape." - "\n\nAt 1 the whole frame is there at its right proportions, with bars above" - "\nand below. At 2 the half is filled and the sides are cropped away" - "\ninstead. Anything between trades one for the other."); + "\n\nA half is half as wide as the frame and just as tall, so the frame" + "\ncannot fill it and keep its shape." + "\n\nAt 1 the whole frame is there at its right proportions, with bars above" + "\nand below. At 2 the half is filled and the sides are cropped away" + "\ninstead. Anything between trades one for the other."); } if (compare == 2) @@ -951,7 +932,7 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrCompareSplit = std::clamp(split, 0.0f, 1.0f); HelpMarker("Where the wipe cuts. Left of it is the frame as the upscaler produced it," - "\nright of it is the frame the model edited."); + "\nright of it is the frame the model edited."); } static const char* debugNames[] = { "Off", "Proxy (what the model sees)", "Model output (raw)", @@ -961,13 +942,12 @@ void RenderMenu(Config* config, float menuResScale) config->DlssNrDebugView = (uint32_t) debugView; HelpMarker("Proxy is the picture handed to the model -- if that looks wrong, the white point" - "\nis wrong and nothing downstream can be judged." - "\n\nDifference shows what the model actually changed, amplified twenty times and" - "\ncentred on grey. A flat grey frame there means it is doing nothing."); + "\nis wrong and nothing downstream can be judged." + "\n\nDifference shows what the model actually changed, amplified twenty times and" + "\ncentred on grey. A flat grey frame there means it is doing nothing."); ImGui::PopItemWidth(); } } } // namespace DlssNr - diff --git a/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp b/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp index 678f217f7..3ac557720 100644 --- a/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp +++ b/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp @@ -23,8 +23,8 @@ int main() expect(DecideWhitePoint(2, false, true, true, scale, trim, held, pre, es, 0.0f), scale, 0); expect(DecideWhitePoint(0, true, true, true, scale, trim, held, pre, es, anchored), scale, 0); expect(DecideWhitePoint(1, true, true, false, scale, trim, held, pre, es, 0.0f), trim, 1); - expect(DecideWhitePoint(1, true, false, true, scale, trim, held, pre, es, 0.0f), - trim * GameWhite(held, pre, es), 0); + expect(DecideWhitePoint(1, true, false, true, scale, trim, held, pre, es, 0.0f), trim * GameWhite(held, pre, es), + 0); expect(DecideWhitePoint(1, true, false, false, scale, trim, 0.012f, pre, es, 0.0f), scale, 0); expect(DecideWhitePoint(2, true, true, true, scale, trim, held, pre, es, anchored), anchored, 0); expect(DecideWhitePoint(2, true, true, true, scale, trim, held, pre, es, 0.0f), scale, 0); diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp index 0da9a9caa..6eed581db 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp +++ b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp @@ -4,7 +4,6 @@ #include - #include #include #include @@ -38,26 +37,46 @@ const char* NgxResultName(unsigned int r) { switch (r) { - case 0x1: return "Success"; - case 0xBAD00001: return "FAIL_FeatureNotSupported"; - case 0xBAD00002: return "FAIL_PlatformError"; - case 0xBAD00003: return "FAIL_FeatureAlreadyExists"; - case 0xBAD00004: return "FAIL_FeatureNotFound"; - case 0xBAD00005: return "FAIL_InvalidParameter"; - case 0xBAD00006: return "FAIL_ScratchBufferTooSmall"; - case 0xBAD00007: return "FAIL_NotInitialized"; - case 0xBAD00008: return "FAIL_UnsupportedInputFormat"; - case 0xBAD00009: return "FAIL_RWFlagMissing"; - case 0xBAD0000A: return "FAIL_MissingInput"; - case 0xBAD0000B: return "FAIL_UnableToInitializeFeature"; - case 0xBAD0000C: return "FAIL_OutOfDate"; - case 0xBAD0000D: return "FAIL_OutOfGPUMemory"; - case 0xBAD0000E: return "FAIL_UnsupportedFormat"; - case 0xBAD0000F: return "FAIL_UnableToWriteToAppDataPath"; - case 0xBAD00010: return "FAIL_UnsupportedParameter"; - case 0xBAD00011: return "FAIL_Denied"; - case 0xBAD00012: return "FAIL_NotImplemented"; - default: return "unknown"; + case 0x1: + return "Success"; + case 0xBAD00001: + return "FAIL_FeatureNotSupported"; + case 0xBAD00002: + return "FAIL_PlatformError"; + case 0xBAD00003: + return "FAIL_FeatureAlreadyExists"; + case 0xBAD00004: + return "FAIL_FeatureNotFound"; + case 0xBAD00005: + return "FAIL_InvalidParameter"; + case 0xBAD00006: + return "FAIL_ScratchBufferTooSmall"; + case 0xBAD00007: + return "FAIL_NotInitialized"; + case 0xBAD00008: + return "FAIL_UnsupportedInputFormat"; + case 0xBAD00009: + return "FAIL_RWFlagMissing"; + case 0xBAD0000A: + return "FAIL_MissingInput"; + case 0xBAD0000B: + return "FAIL_UnableToInitializeFeature"; + case 0xBAD0000C: + return "FAIL_OutOfDate"; + case 0xBAD0000D: + return "FAIL_OutOfGPUMemory"; + case 0xBAD0000E: + return "FAIL_UnsupportedFormat"; + case 0xBAD0000F: + return "FAIL_UnableToWriteToAppDataPath"; + case 0xBAD00010: + return "FAIL_UnsupportedParameter"; + case 0xBAD00011: + return "FAIL_Denied"; + case 0xBAD00012: + return "FAIL_NotImplemented"; + default: + return "unknown"; } } @@ -122,17 +141,15 @@ void ProbeProxyDispatch(ID3D12GraphicsCommandList* cmdList) release(handle); NVSDK_NGX_Handle* controlHandle = nullptr; - const auto control = - (unsigned int) create(cmdList, (NVSDK_NGX_Feature) 200, params, &controlHandle); + const auto control = (unsigned int) create(cmdList, (NVSDK_NGX_Feature) 200, params, &controlHandle); if (controlHandle != nullptr && release != nullptr) release(controlHandle); - LOG_INFO("DLSS-NR proxy probe: feature 18 -> 0x{:X} ({}), control feature 200 -> 0x{:X} ({})", - result, NgxResultName(result), control, NgxResultName(control)); + LOG_INFO("DLSS-NR proxy probe: feature 18 -> 0x{:X} ({}), control feature 200 -> 0x{:X} ({})", result, + NgxResultName(result), control, NgxResultName(control)); - const bool rejectedOutright = - result == 0xBAD00004 || result == 0xBAD00001 || result == 0xBAD00012; + const bool rejectedOutright = result == 0xBAD00004 || result == 0xBAD00001 || result == 0xBAD00012; if (result == control) LOG_INFO("DLSS-NR proxy probe: both answers identical, so this says nothing about feature 18 " @@ -151,18 +168,16 @@ void ProbeProxyDispatch(ID3D12GraphicsCommandList* cmdList) // Everything the model is reached through. The snippet refuses callers whose module path does not // contain "nvngx.dll", so the calls are made from a small library named for exactly that reason and // shipped beside OptiScaler; see nvngx.dll_dlssnr.dll. -using PFN_NrCreate = void*(__cdecl*) (const wchar_t*, const wchar_t*, ID3D12Device*, - ID3D12GraphicsCommandList*, void*, unsigned int, unsigned int, int, - float, int, float, float, float, int, int); -using PFN_NrEvaluate = int(__cdecl*) (ID3D12GraphicsCommandList*, void*, void*, ID3D12Resource*, - ID3D12Resource*, ID3D12Resource*, ID3D12Resource*, unsigned int, - unsigned int, unsigned int, unsigned int, int, int, float, int, - float, float, float, int, float, float); -using PFN_NrRelease = void(__cdecl*) (void*); -using PFN_NrSetExtras = void(__cdecl*) (void*, float, ID3D12Resource*, ID3D12Resource*, ID3D12Resource*, - unsigned int, unsigned int, unsigned int, unsigned int); -using PFN_NrSetFloatSlot = void(__cdecl*) (int); -using PFN_NrProbeFloat = void(__cdecl*) (void*, const char*, float, int); +using PFN_NrCreate = void*(__cdecl*) (const wchar_t*, const wchar_t*, ID3D12Device*, ID3D12GraphicsCommandList*, void*, + unsigned int, unsigned int, int, float, int, float, float, float, int, int); +using PFN_NrEvaluate = int(__cdecl*)(ID3D12GraphicsCommandList*, void*, void*, ID3D12Resource*, ID3D12Resource*, + ID3D12Resource*, ID3D12Resource*, unsigned int, unsigned int, unsigned int, + unsigned int, int, int, float, int, float, float, float, int, float, float); +using PFN_NrRelease = void(__cdecl*)(void*); +using PFN_NrSetExtras = void(__cdecl*)(void*, float, ID3D12Resource*, ID3D12Resource*, ID3D12Resource*, unsigned int, + unsigned int, unsigned int, unsigned int); +using PFN_NrSetFloatSlot = void(__cdecl*)(int); +using PFN_NrProbeFloat = void(__cdecl*)(void*, const char*, float, int); // One per back buffer, so an allocator is never reset while its frame is still in flight. @@ -421,8 +436,7 @@ bool EnsureForwarder() if (!found.has_value()) { - LOG_ERROR("nvngx.dll_dlssnr.dll not found beside OptiScaler ({}) or the game executable", - g_dllDir.string()); + LOG_ERROR("nvngx.dll_dlssnr.dll not found beside OptiScaler ({}) or the game executable", g_dllDir.string()); g_nr.reason = "nvngx.dll_dlssnr.dll is missing"; return false; } @@ -433,8 +447,7 @@ bool EnsureForwarder() if (g_nr.forwarder == nullptr) { - LOG_ERROR("nvngx.dll_dlssnr.dll found at {} but would not load, error {}", path.string(), - GetLastError()); + LOG_ERROR("nvngx.dll_dlssnr.dll found at {} but would not load, error {}", path.string(), GetLastError()); g_nr.reason = "nvngx.dll_dlssnr.dll would not load"; return false; } @@ -526,8 +539,7 @@ void ReportScalingRatios() if (!snippet.has_value()) return; - static const char* kNames[] = { "MaxPerf", "Balanced", "MaxQuality", - "UltraPerformance", "UltraQuality", "DLAA" }; + static const char* kNames[] = { "MaxPerf", "Balanced", "MaxQuality", "UltraPerformance", "UltraQuality", "DLAA" }; char line[512] = {}; size_t used = 0; @@ -570,8 +582,7 @@ void ReportScalingRatios() // local tone and skin structure never did anything. void DiscoverFloatSlot(NVSDK_NGX_Parameter* params) { - if (g_nr.floatSlotKnown || params == nullptr || g_nr.probeFloat == nullptr || - g_nr.setFloatSlot == nullptr) + if (g_nr.floatSlotKnown || params == nullptr || g_nr.probeFloat == nullptr || g_nr.setFloatSlot == nullptr) return; g_nr.floatSlotKnown = true; @@ -668,8 +679,8 @@ void ReleaseSurfacesIfFormatChanged(DXGI_FORMAT needed) if (g_nr.output == nullptr || g_nr.output->GetDesc().Format == needed) return; - LOG_INFO("DLSS-NR rebuilding surfaces: format {} -> {} (inject point changed)", - (int) g_nr.output->GetDesc().Format, (int) needed); + LOG_INFO("DLSS-NR rebuilding surfaces: format {} -> {} (inject point changed)", (int) g_nr.output->GetDesc().Format, + (int) needed); ParkNrFeature(g_nr.feature); @@ -677,8 +688,7 @@ void ReleaseSurfacesIfFormatChanged(DXGI_FORMAT needed) for (void*& f : g_nr.passFeature) ParkNrFeature(f); - for (ID3D12Resource** r : - { &g_nr.output, &g_nr.colorCopy, &g_nr.hdrCopy, &g_nr.colorSmall }) + for (ID3D12Resource** r : { &g_nr.output, &g_nr.colorCopy, &g_nr.hdrCopy, &g_nr.colorSmall }) ParkNrResource(*r); InvalidateMeterReadback(); @@ -724,8 +734,7 @@ void CopyCalibrationToReadback(ID3D12GraphicsCommandList* cmdList) g_nr.calibFrames++; } -void CopyMeterToReadback(ID3D12GraphicsCommandList* cmdList, ID3D12Device* device, - bool exposureBound) +void CopyMeterToReadback(ID3D12GraphicsCommandList* cmdList, ID3D12Device* device, bool exposureBound) { const unsigned int slot = (unsigned int) (g_nr.meterFrames % 4); @@ -835,7 +844,8 @@ void ConsumeCalibrationReadback() const float suggestion = std::clamp(tiles[nth], 0.25f, 1990.0f); g_nr.calibUsable = !g_nr.calibPassthrough && litFraction > 0.20f; - g_nr.calibWhy = g_nr.calibPassthrough ? "this game hands over a frame it already tone mapped, so there is nothing to normalise" + g_nr.calibWhy = g_nr.calibPassthrough + ? "this game hands over a frame it already tone mapped, so there is nothing to normalise" : litFraction <= 0.20f ? "too little of this scene is lit to say where the top of the range is" : ""; @@ -979,9 +989,9 @@ float ResolveWhitePoint(const Config& cfg, bool isHdrBuffer) // Multi-point: one or more calibration points the user placed, interpolated in log space by // the current scan value. One point is the original ratio law; more fit the buffer's actual // relationship so the white point holds across the whole range, not only near one anchor. - const float w = DlssNr::ExposureScan::AnchoredWhitePoint( - DlssNr::ExposureScan::BestValue(), cfg.DlssNrScanInverted.value_or_default(), - cfg.DlssNrScanTrim.value_or_default()); + const float w = DlssNr::ExposureScan::AnchoredWhitePoint(DlssNr::ExposureScan::BestValue(), + cfg.DlssNrScanInverted.value_or_default(), + cfg.DlssNrScanTrim.value_or_default()); if (w > 0.0f) return w; @@ -1000,8 +1010,7 @@ float ResolveWhitePoint(const Config& cfg, bool isHdrBuffer) return slider; } -ID3D12Resource* CreateScratch(ID3D12Device* device, DXGI_FORMAT format, unsigned int width, - unsigned int height) +ID3D12Resource* CreateScratch(ID3D12Device* device, DXGI_FORMAT format, unsigned int width, unsigned int height) { D3D12_HEAP_PROPERTIES heap {}; heap.Type = D3D12_HEAP_TYPE_DEFAULT; @@ -1019,8 +1028,8 @@ ID3D12Resource* CreateScratch(ID3D12Device* device, DXGI_FORMAT format, unsigned desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; ID3D12Resource* res = nullptr; - device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, - D3D12_RESOURCE_STATE_UNORDERED_ACCESS, nullptr, IID_PPV_ARGS(&res)); + device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, nullptr, + IID_PPV_ARGS(&res)); return res; } @@ -1091,9 +1100,8 @@ void EnsureExposureDummy(ID3D12Device* device, ID3D12GraphicsCommandList* cmdLis desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; desc.Flags = D3D12_RESOURCE_FLAG_NONE; - if (FAILED(device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, - D3D12_RESOURCE_STATE_COPY_DEST, nullptr, - IID_PPV_ARGS(&g_nr.exposureDummy))) || + if (FAILED(device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_COPY_DEST, + nullptr, IID_PPV_ARGS(&g_nr.exposureDummy))) || g_nr.exposureDummy == nullptr) { g_nr.exposureDummy = nullptr; @@ -1123,8 +1131,7 @@ void EnsureExposureDummy(ID3D12Device* device, ID3D12GraphicsCommandList* cmdLis ID3D12Resource* upload = nullptr; if (FAILED(device->CreateCommittedResource(&uploadHeap, D3D12_HEAP_FLAG_NONE, &buf, - D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, - IID_PPV_ARGS(&upload))) || + D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&upload))) || upload == nullptr) { g_nr.exposureDummy->Release(); @@ -1233,8 +1240,8 @@ ID3D12Resource* CreateGuideClone(ID3D12Device* device, ID3D12Resource* source) heap.Type = D3D12_HEAP_TYPE_DEFAULT; ID3D12Resource* res = nullptr; - device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_COPY_DEST, - nullptr, IID_PPV_ARGS(&res)); + device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, + IID_PPV_ARGS(&res)); return res; } @@ -1253,8 +1260,8 @@ ID3D12Resource* CreateGuideClone(ID3D12Device* device, ID3D12Resource* source) // copy of it when it is not. NGX requires its inputs in NON_PIXEL_SHADER_RESOURCE at evaluate time, // which is a documented contract rather than a guess about any one game's frame graph, so that is // the state transitioned away from and back to here. -ID3D12Resource* ReadableGuide(ID3D12Device* device, ID3D12GraphicsCommandList* cmdList, - ID3D12Resource* source, ID3D12Resource** clone) +ID3D12Resource* ReadableGuide(ID3D12Device* device, ID3D12GraphicsCommandList* cmdList, ID3D12Resource* source, + ID3D12Resource** clone) { if (source == nullptr || !IsTypeless(source->GetDesc().Format)) return source; @@ -1268,8 +1275,7 @@ ID3D12Resource* ReadableGuide(ID3D12Device* device, ID3D12GraphicsCommandList* c const D3D12_RESOURCE_DESC have = (*clone)->GetDesc(); const D3D12_RESOURCE_DESC want = source->GetDesc(); - if (have.Width != want.Width || have.Height != want.Height || - have.Format != TypedGuideFormat(want.Format)) + if (have.Width != want.Width || have.Height != want.Height || have.Format != TypedGuideFormat(want.Format)) { // Retired, not released: the previous copy may still be in flight on the game's queue. ParkNrResource(*clone); @@ -1283,17 +1289,13 @@ ID3D12Resource* ReadableGuide(ID3D12Device* device, ID3D12GraphicsCommandList* c if (*clone == nullptr) return nullptr; - LOG_DEBUG("DLSS-NR cloned a typeless guide as format {}", - (int) TypedGuideFormat(source->GetDesc().Format)); + LOG_DEBUG("DLSS-NR cloned a typeless guide as format {}", (int) TypedGuideFormat(source->GetDesc().Format)); } - Barrier(cmdList, source, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, - D3D12_RESOURCE_STATE_COPY_SOURCE); + Barrier(cmdList, source, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_COPY_SOURCE); cmdList->CopyResource(*clone, source); - Barrier(cmdList, source, D3D12_RESOURCE_STATE_COPY_SOURCE, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - Barrier(cmdList, *clone, D3D12_RESOURCE_STATE_COPY_DEST, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + Barrier(cmdList, source, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + Barrier(cmdList, *clone, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); return *clone; } @@ -1375,8 +1377,7 @@ NrExposure ReadNrExposure(NVSDK_NGX_Parameter* params) ID3D12Resource* texture = nullptr; - if (params->Get(NVSDK_NGX_Parameter_ExposureTexture, &texture) == NVSDK_NGX_Result_Success && - texture != nullptr) + if (params->Get(NVSDK_NGX_Parameter_ExposureTexture, &texture) == NVSDK_NGX_Result_Success && texture != nullptr) { out.texture = texture; } @@ -1389,8 +1390,7 @@ NrExposure ReadNrExposure(NVSDK_NGX_Parameter* params) out.texture = static_cast(untyped); } - if (params->Get(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, &out.pre) != NVSDK_NGX_Result_Success || - out.pre == 0.0f) + if (params->Get(NVSDK_NGX_Parameter_DLSS_Pre_Exposure, &out.pre) != NVSDK_NGX_Result_Success || out.pre == 0.0f) out.pre = 1.0f; if (params->Get(NVSDK_NGX_Parameter_DLSS_Exposure_Scale, &out.scale) != NVSDK_NGX_Result_Success || @@ -1414,8 +1414,7 @@ void SetExtras(const Config& cfg, ID3D12Resource* ui, ID3D12Resource* backbuffer // Global tone is written at the model's own default: the control that exposed it changed nothing // that could be seen, and the block persists, so a value still has to be put there. - g_nr.setExtras(g_nr.capabilityParams, 1.0f, ui, ui, backbuffer, - uiWidth, uiHeight, bbWidth, bbHeight); + g_nr.setExtras(g_nr.capabilityParams, 1.0f, ui, ui, backbuffer, uiWidth, uiHeight, bbWidth, bbHeight); } bool TuningMatchesFeature(const Config& cfg) @@ -1550,8 +1549,7 @@ bool DlssNr_Dx12::ExposureUsable(ID3D12Resource* res) // of OptiScaler sees. // --------------------------------------------------------------------------------------------- -DlssNr_Dx12::DlssNr_Dx12(std::string InName, ID3D12Device* InDevice) - : Shader_Dx12(InName, InDevice) +DlssNr_Dx12::DlssNr_Dx12(std::string InName, ID3D12Device* InDevice) : Shader_Dx12(InName, InDevice) { if (InDevice == nullptr) { @@ -1608,10 +1606,9 @@ DlssNr_Dx12::DlssNr_Dx12(std::string InName, ID3D12Device* InDevice) } bool DlssNr_Dx12::DispatchPass(ID3D12GraphicsCommandList* InCmdList, const DlssNrConstants& InConstants, - ID3D12Resource* InSource, ID3D12Resource* InModel, - ID3D12Resource* InOriginal, ID3D12Resource* InMotion, - ID3D12Resource* InExposure, ID3D12Resource* OutTarget, - ID3D12Resource* OutKeep) + ID3D12Resource* InSource, ID3D12Resource* InModel, ID3D12Resource* InOriginal, + ID3D12Resource* InMotion, ID3D12Resource* InExposure, ID3D12Resource* OutTarget, + ID3D12Resource* OutKeep) { if (!_init || InCmdList == nullptr || _device == nullptr || InSource == nullptr || OutTarget == nullptr) return false; @@ -1683,15 +1680,15 @@ DlssNr_Dx12::~DlssNr_Dx12() } } -void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* colour, - ID3D12Resource* depth, ID3D12Resource* motion, ID3D12Resource* output, - const DlssNrFrameInfo& frame, ID3D12CommandQueue* timingQueue) +void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* colour, ID3D12Resource* depth, + ID3D12Resource* motion, ID3D12Resource* output, const DlssNrFrameInfo& frame, + ID3D12CommandQueue* timingQueue) { std::lock_guard nrLock(g_nrMutex); const Config& cfg = *Config::Instance(); - if (g_nr.failed || cmdList == nullptr || colour == nullptr || depth == nullptr || - motion == nullptr || output == nullptr) + if (g_nr.failed || cmdList == nullptr || colour == nullptr || depth == nullptr || motion == nullptr || + output == nullptr) { ReportSkipOnce(g_nr.failed ? "it already failed this session" : "a resource was missing"); return; @@ -1818,9 +1815,10 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c static GuideReport loggedGuides {}; - const GuideReport guidesNow { true, g_nr.guideDepthInverted, g_nr.guideMvScaleX, - g_nr.guideMvScaleY, guideWidth, guideHeight, - width, (unsigned int) height }; + const GuideReport guidesNow { + true, g_nr.guideDepthInverted, g_nr.guideMvScaleX, g_nr.guideMvScaleY, guideWidth, guideHeight, + width, (unsigned int) height + }; if (!loggedGuides.valid || loggedGuides.depthInverted != guidesNow.depthInverted || loggedGuides.mvScaleX != guidesNow.mvScaleX || loggedGuides.mvScaleY != guidesNow.mvScaleY || @@ -1829,8 +1827,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c { loggedGuides = guidesNow; LOG_INFO("DLSS-NR guides: depth {}, motion vector scale {} x {}, guides {}x{} for a {}x{} frame", - g_nr.guideDepthInverted ? "inverted" : "not inverted", g_nr.guideMvScaleX, - g_nr.guideMvScaleY, guideWidth, guideHeight, width, height); + g_nr.guideDepthInverted ? "inverted" : "not inverted", g_nr.guideMvScaleX, g_nr.guideMvScaleY, + guideWidth, guideHeight, width, height); } if (cfg.DlssNrProxyProbe.value_or_default()) @@ -1854,8 +1852,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c ReleaseSurfacesIfFormatChanged(desc.Format); - const bool resolutionChanged = g_nr.width != width || g_nr.height != height || - g_nr.workWidth != workWidth || g_nr.workHeight != workHeight; + const bool resolutionChanged = + g_nr.width != width || g_nr.height != height || g_nr.workWidth != workWidth || g_nr.workHeight != workHeight; // The model reads its tuning once, while the feature is built, so a changed setting only takes // effect when the feature is rebuilt. TuningMatchesFeature was written to notice that and then @@ -1916,8 +1914,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c for (auto& rb : g_nr.meterReadback) { if (FAILED(device->CreateCommittedResource(&readback, D3D12_HEAP_FLAG_NONE, &bufferDesc, - D3D12_RESOURCE_STATE_COPY_DEST, nullptr, - IID_PPV_ARGS(&rb)))) + D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&rb)))) { rb = nullptr; LOG_WARN("DLSS-NR: the white point meter could not allocate its readback; falling back " @@ -1929,8 +1926,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c LOG_INFO("DLSS-NR: white point meter up, {}x{} tiles", kDlssNrMeterGrid, kDlssNrMeterGrid); } - if (g_nr.feature == nullptr && g_nr.output != nullptr && g_nr.colorCopy != nullptr && - g_nr.hdrCopy != nullptr) + if (g_nr.feature == nullptr && g_nr.output != nullptr && g_nr.colorCopy != nullptr && g_nr.hdrCopy != nullptr) { auto snippet = Util::FindFilePath(g_dllDir, "nvngx_dlssnr.dll"); @@ -1947,17 +1943,15 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c } SetExtras(cfg, nullptr, nullptr, 0, 0, 0, 0); - g_nr.feature = - g_nr.create(snippet->wstring().c_str(), State::Instance().NVNGX_ApplicationDataPath.c_str(), - device, cmdList, g_nr.capabilityParams, workWidth, workHeight, - (int) cfg.DlssNrPreset.value_or_default(), - cfg.DlssNrIntensity.value_or_default(), (int) cfg.DlssNrStyle.value_or_default(), - cfg.DlssNrLocalStructure.value_or_default(), cfg.DlssNrLocalTone.value_or_default(), - cfg.DlssNrSkinStructure.value_or_default(), - cfg.DlssNrAutoMask.value_or_default() ? 1 : 0, - // UI correction at the model's own default: with no UI layer fed to it there - // is nothing for it to correct. - 1); + g_nr.feature = g_nr.create( + snippet->wstring().c_str(), State::Instance().NVNGX_ApplicationDataPath.c_str(), device, cmdList, + g_nr.capabilityParams, workWidth, workHeight, (int) cfg.DlssNrPreset.value_or_default(), + cfg.DlssNrIntensity.value_or_default(), (int) cfg.DlssNrStyle.value_or_default(), + cfg.DlssNrLocalStructure.value_or_default(), cfg.DlssNrLocalTone.value_or_default(), + cfg.DlssNrSkinStructure.value_or_default(), cfg.DlssNrAutoMask.value_or_default() ? 1 : 0, + // UI correction at the model's own default: with no UI layer fed to it there + // is nothing for it to correct. + 1); if (g_nr.feature == nullptr) { @@ -1978,8 +1972,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c g_nr.height = height; g_nr.reset = true; RecordBuiltTuning(cfg); - LOG_INFO("DLSS-NR running at {}x{}, guides {}x{} (preset {}, intensity {}, style {})", width, - height, guideWidth, guideHeight, g_nr.builtPreset, g_nr.builtIntensity, g_nr.builtStyle); + LOG_INFO("DLSS-NR running at {}x{}, guides {}x{} (preset {}, intensity {}, style {})", width, height, + guideWidth, guideHeight, g_nr.builtPreset, g_nr.builtIntensity, g_nr.builtStyle); // Creating and evaluating a feature in the same command list is the dice-roll that hung the // GPU (every crash died on a creation frame). The creation goes through the game's own submit @@ -2011,8 +2005,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c { reportedHdr = true; LOG_INFO("DLSS-NR: the game's DLSS buffer is {} so the colour transform is {}", - isHdrBuffer ? "linear HDR" : "already tone-mapped", - isHdrBuffer ? "on" : "off"); + isHdrBuffer ? "linear HDR" : "already tone-mapped", isHdrBuffer ? "on" : "off"); } const bool haveCodec = IsInit(); @@ -2060,8 +2053,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c // touching state was unsafe this frame, and binding the pass now would leave state the envelope // cannot clean up. So on those games, skip the frame rather than corrupt it. Ordinary games do // not require restore, so they are unaffected and the pass runs as before. - const bool restoreRequired = cfg.RestoreComputeSignature.value_or_default() || - cfg.RestoreGraphicSignature.value_or_default(); + const bool restoreRequired = + cfg.RestoreComputeSignature.value_or_default() || cfg.RestoreGraphicSignature.value_or_default(); if (restoreRequired && !D3D12Hooks::CanRestoreRootSignature(cmdList)) { @@ -2110,13 +2103,12 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c float anchored = 0.0f; if (source == 2) { - anchored = DlssNr::ExposureScan::AnchoredWhitePoint( - DlssNr::ExposureScan::BestValue(), cfg.DlssNrScanInverted.value_or_default(), - cfg.DlssNrScanTrim.value_or_default()); + anchored = DlssNr::ExposureScan::AnchoredWhitePoint(DlssNr::ExposureScan::BestValue(), + cfg.DlssNrScanInverted.value_or_default(), + cfg.DlssNrScanTrim.value_or_default()); } - const WhitePointDecision d = - DecideWhitePoint(source, isHdrBuffer, usable, heldE, scale, trim, g_nr.gameExposure, - frame.PreExposure, frame.ExposureScale, anchored); + const WhitePointDecision d = DecideWhitePoint(source, isHdrBuffer, usable, heldE, scale, trim, g_nr.gameExposure, + frame.PreExposure, frame.ExposureScale, anchored); ID3D12Resource* encodeT4 = (d.useGameExposure == 1) ? gameRes : g_nr.exposureDummy; const bool hole = isHdrBuffer && source == 1 && !usable; @@ -2141,8 +2133,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c { loggedUsable = true; const D3D12_RESOURCE_DESC expDesc = gameRes->GetDesc(); - LOG_INFO("DLSS-NR exposure usable: {}x{} format {} P {} S {}", (unsigned) expDesc.Width, - expDesc.Height, (int) expDesc.Format, frame.PreExposure, frame.ExposureScale); + LOG_INFO("DLSS-NR exposure usable: {}x{} format {} P {} S {}", (unsigned) expDesc.Width, expDesc.Height, + (int) expDesc.Format, frame.PreExposure, frame.ExposureScale); } } @@ -2180,13 +2172,10 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c encodeParams.PreExposure = frame.PreExposure; encodeParams.ExposureScale = frame.ExposureScale; - Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - DispatchPass(cmdList, encodeParams, target, nullptr, nullptr, nullptr, encodeT4, g_nr.colorCopy, - g_nr.hdrCopy); + Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + DispatchPass(cmdList, encodeParams, target, nullptr, nullptr, nullptr, encodeT4, g_nr.colorCopy, g_nr.hdrCopy); - Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, - D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); // The transitions double as the wait for the encode's writes. Barrier(cmdList, g_nr.colorCopy, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); @@ -2210,12 +2199,9 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c meterParams.Width = 1; meterParams.Height = 1; - Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - DispatchPass(cmdList, meterParams, target, nullptr, nullptr, nullptr, gameRes, g_nr.meter, - nullptr); - Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, - D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + Barrier(cmdList, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + DispatchPass(cmdList, meterParams, target, nullptr, nullptr, nullptr, gameRes, g_nr.meter, nullptr); + Barrier(cmdList, target, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); CopyMeterToReadback(cmdList, device, true); ConsumeMeterReadback(); @@ -2235,8 +2221,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c down.Mode = DlssNrMode_Downsample; down.Width = workWidth; down.Height = workHeight; - DispatchPass(cmdList, down, modelInput, nullptr, nullptr, nullptr, nullptr, g_nr.colorSmall, - nullptr); + DispatchPass(cmdList, down, modelInput, nullptr, nullptr, nullptr, nullptr, g_nr.colorSmall, nullptr); Barrier(cmdList, g_nr.colorSmall, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); modelInput = g_nr.colorSmall; @@ -2272,9 +2257,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c if (cfg.DlssNrUseProxy.value_or_default()) { const unsigned int proxyResult = DlssNr::Proxy::Run( - cmdList, device, modelInput, depthIn, motionIn, g_nr.output, workWidth, workHeight, - guideWidth, guideHeight, g_nr.guideDepthInverted, g_nr.reset, - g_nr.guideMvScaleX * mvToWork, g_nr.guideMvScaleY * mvToWork); + cmdList, device, modelInput, depthIn, motionIn, g_nr.output, workWidth, workHeight, guideWidth, guideHeight, + g_nr.guideDepthInverted, g_nr.reset, g_nr.guideMvScaleX * mvToWork, g_nr.guideMvScaleY * mvToWork); g_nr.reset = false; @@ -2282,8 +2266,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c { g_nr.failed = true; g_nr.reason = "the proxy path could not run the model"; - LOG_ERROR("DLSS-NR (proxy): evaluate returned 0x{:X} ({}), disabling for this session", - proxyResult, NgxResultName(proxyResult)); + LOG_ERROR("DLSS-NR (proxy): evaluate returned 0x{:X} ({}), disabling for this session", proxyResult, + NgxResultName(proxyResult)); } exposureHotfix.Close(); @@ -2297,13 +2281,12 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c // Multi-pass was removed: re-feeding the model its own output re-opened the same-command-list // feature-creation hang, and the colour core is not settled enough to build on. One evaluate. const int result = g_nr.evaluate( - cmdList, g_nr.feature, g_nr.capabilityParams, modelInput, depthIn, motionIn, g_nr.output, - workWidth, workHeight, guideWidth, guideHeight, g_nr.guideDepthInverted ? 1 : 0, - g_nr.reset ? 1 : 0, cfg.DlssNrIntensity.value_or_default(), - (int) cfg.DlssNrStyle.value_or_default(), cfg.DlssNrLocalStructure.value_or_default(), - cfg.DlssNrLocalTone.value_or_default(), cfg.DlssNrSkinStructure.value_or_default(), - cfg.DlssNrAutoMask.value_or_default() ? 1 : 0, g_nr.guideMvScaleX * mvToWork, - g_nr.guideMvScaleY * mvToWork); + cmdList, g_nr.feature, g_nr.capabilityParams, modelInput, depthIn, motionIn, g_nr.output, workWidth, workHeight, + guideWidth, guideHeight, g_nr.guideDepthInverted ? 1 : 0, g_nr.reset ? 1 : 0, + cfg.DlssNrIntensity.value_or_default(), (int) cfg.DlssNrStyle.value_or_default(), + cfg.DlssNrLocalStructure.value_or_default(), cfg.DlssNrLocalTone.value_or_default(), + cfg.DlssNrSkinStructure.value_or_default(), cfg.DlssNrAutoMask.value_or_default() ? 1 : 0, + g_nr.guideMvScaleX * mvToWork, g_nr.guideMvScaleY * mvToWork); if (g_ngxTime != nullptr) g_ngxTime->End(cmdList); @@ -2323,8 +2306,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c { float value = 0.0f; const NVSDK_NGX_Result r = g_nr.capabilityParams->Get(name, &value); - LOG_INFO("DLSS-NR readback {} -> {} (we wrote {}, result 0x{:X})", name, value, wrote, - (uint32_t) r); + LOG_INFO("DLSS-NR readback {} -> {} (we wrote {}, result 0x{:X})", name, value, wrote, (uint32_t) r); }; const Config& rcfg = *Config::Instance(); @@ -2340,15 +2322,14 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c // The preset is the last control whose arrival has never been checked, and three of them look // identical in play. Either it is not landing or the presets really are alike. unsigned int preset = 0; - const NVSDK_NGX_Result presetResult = - g_nr.capabilityParams->Get("DLSSNR.Hint.Render.Preset", &preset); + const NVSDK_NGX_Result presetResult = g_nr.capabilityParams->Get("DLSSNR.Hint.Render.Preset", &preset); LOG_DEBUG("DLSS-NR readback DLSSNR.Hint.Render.Preset -> {} (result 0x{:X}, we wrote {})", preset, - (uint32_t) presetResult, cfg.DlssNrPreset.value_or_default()); + (uint32_t) presetResult, cfg.DlssNrPreset.value_or_default()); LOG_DEBUG("DLSS-NR wrote intensity {}, local structure {}, local tone {}, skin {}, style {}", - cfg.DlssNrIntensity.value_or_default(), cfg.DlssNrLocalStructure.value_or_default(), - cfg.DlssNrLocalTone.value_or_default(), cfg.DlssNrSkinStructure.value_or_default(), - cfg.DlssNrStyle.value_or_default()); + cfg.DlssNrIntensity.value_or_default(), cfg.DlssNrLocalStructure.value_or_default(), + cfg.DlssNrLocalTone.value_or_default(), cfg.DlssNrSkinStructure.value_or_default(), + cfg.DlssNrStyle.value_or_default()); } if (result == NVSDK_NGX_Result_Success) @@ -2413,10 +2394,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c if (!loggedCompose.valid || loggedCompose.whitePoint != composeNow.whitePoint || loggedCompose.transfer != composeNow.transfer || loggedCompose.colour != composeNow.colour || - loggedCompose.maxRatio != composeNow.maxRatio || - loggedCompose.passthrough != composeNow.passthrough || - loggedCompose.debugView != composeNow.debugView || - loggedCompose.compareMode != composeNow.compareMode || + loggedCompose.maxRatio != composeNow.maxRatio || loggedCompose.passthrough != composeNow.passthrough || + loggedCompose.debugView != composeNow.debugView || loggedCompose.compareMode != composeNow.compareMode || loggedCompose.residual != composeNow.residual || loggedCompose.workW != composeNow.workW || loggedCompose.workH != composeNow.workH) { @@ -2425,14 +2404,14 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c "{:.1f}x, colour transform {}, transfer {}, model {}x{}, debug view {}, compare {}", composeNow.whitePoint, composeNow.transfer, composeNow.colour, composeNow.maxRatio, composeNow.passthrough != 0 ? "off (frame already tone mapped)" : "on (linear HDR)", - composeNow.residual == 1 ? "matched residual" : "classic", composeNow.workW, - composeNow.workH, composeNow.debugView, composeNow.compareMode); + composeNow.residual == 1 ? "matched residual" : "classic", composeNow.workW, composeNow.workH, + composeNow.debugView, composeNow.compareMode); } Barrier(cmdList, g_nr.output, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); - DispatchPass(cmdList, resolveParams, modelInput, g_nr.output, g_nr.hdrCopy, g_nr.colorCopy, - encodeT4, target, nullptr); + DispatchPass(cmdList, resolveParams, modelInput, g_nr.output, g_nr.hdrCopy, g_nr.colorCopy, encodeT4, target, + nullptr); Barrier(cmdList, g_nr.output, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); // Effective && usable and resolve: first = encode, last = resolve. @@ -2444,8 +2423,7 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c // own. if (g_capture.isActive()) { - g_capture.record(cmdList, device, g_nr.colorCopy, - D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, target, + g_capture.record(cmdList, device, g_nr.colorCopy, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); if (g_capture.readyToWrite() && g_captureWriteAtFrame == 0) @@ -2472,8 +2450,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c // invoked on serves. The bridges have to say, because they run on a queue of their own that // State never learns about -- a Vulkan game creates no D3D12 swapchain, so nothing ever sets // currentCommandQueue and the cost went unreported. - auto* queue = timingQueue != nullptr ? timingQueue - : (ID3D12CommandQueue*) State::Instance().currentCommandQueue; + auto* queue = + timingQueue != nullptr ? timingQueue : (ID3D12CommandQueue*) State::Instance().currentCommandQueue; if (queue != nullptr) { @@ -2495,8 +2473,8 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c lastSplitLog = g_frames; const double total = g_lastGpuTime.value(); const double ngx = g_lastNgxTime.value(); - LOG_INFO("DLSS-NR cost: {:.2f} ms total = {:.2f} ms model + {:.2f} ms ours ({:.0f}% ours)", - total, ngx, total - ngx, total > 0.0 ? 100.0 * (total - ngx) / total : 0.0); + LOG_INFO("DLSS-NR cost: {:.2f} ms total = {:.2f} ms model + {:.2f} ms ours ({:.0f}% ours)", total, ngx, + total - ngx, total > 0.0 ? 100.0 * (total - ngx) / total : 0.0); } } } @@ -2532,7 +2510,6 @@ void RetryAfterFailure() g_nr.failed = false; g_nr.reason = ""; g_nr.reset = true; - } // Reads the game's parameter block and runs the pass on what it finds. @@ -2580,9 +2557,9 @@ void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Paramete // carry none of it -- so it stays quiet and tries again next frame. if (target == nullptr || depth == nullptr || motion == nullptr) { - ReportSkipOnce(target == nullptr ? "the parameters carried no output texture" - : depth == nullptr ? "the parameters carried no depth" - : "the parameters carried no motion vectors"); + ReportSkipOnce(target == nullptr ? "the parameters carried no output texture" + : depth == nullptr ? "the parameters carried no depth" + : "the parameters carried no motion vectors"); return; } @@ -2647,8 +2624,7 @@ void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Paramete }; static ExposureReport logged {}; - const ExposureReport now { true, exposure.pre, exposure.scale, exposure.texture != nullptr, - autoExposureFlag }; + const ExposureReport now { true, exposure.pre, exposure.scale, exposure.texture != nullptr, autoExposureFlag }; if (!logged.valid || logged.haveTexture != now.haveTexture || logged.autoFlag != now.autoFlag || std::abs(logged.pre - now.pre) > std::max(0.01f * std::abs(now.pre), 1e-4f) || @@ -2657,8 +2633,7 @@ void EvaluateAfterUpscale(ID3D12GraphicsCommandList* cmdList, NVSDK_NGX_Paramete logged = now; LOG_INFO("DLSS-NR exposure from the game: DLSS.Pre.Exposure {}, DLSS.Exposure.Scale {}, " "ExposureTexture {}, auto-exposure flag {}", - now.pre, now.scale, now.haveTexture ? "supplied" : "not supplied", - now.autoFlag ? "set" : "clear"); + now.pre, now.scale, now.haveTexture ? "supplied" : "not supplied", now.autoFlag ? "set" : "clear"); } // Courier readback, three frames after the offer. The menu shows this; encode does not @@ -2755,8 +2730,8 @@ void ProbeD3D11(void* d3d11Device) return; auto probe = (int (*)(const wchar_t*)) GetProcAddress(g_nr.forwarder, "dlssnr_d3d11_probe"); - auto init = (int (*)(const wchar_t*, const wchar_t*, void*, int, int*, int*)) GetProcAddress( - g_nr.forwarder, "dlssnr_d3d11_init"); + auto init = (int (*)(const wchar_t*, const wchar_t*, void*, int, int*, int*)) GetProcAddress(g_nr.forwarder, + "dlssnr_d3d11_init"); if (probe == nullptr || init == nullptr) { @@ -2777,8 +2752,8 @@ void ProbeD3D11(void* d3d11Device) // And the question NGX has an API for. Asked first because it creates nothing: if the feature // declines D3D11 here, that is the feature's own answer rather than our reading of a failed init. - auto requirements = (int (*)(const wchar_t*, void*, unsigned int*, unsigned int*, unsigned int*)) - GetProcAddress(g_nr.forwarder, "dlssnr_d3d11_requirements"); + auto requirements = (int (*)(const wchar_t*, void*, unsigned int*, unsigned int*, unsigned int*)) GetProcAddress( + g_nr.forwarder, "dlssnr_d3d11_requirements"); if (requirements != nullptr) { @@ -2796,13 +2771,13 @@ void ProbeD3D11(void* d3d11Device) unsigned int minOs = 0; const int rc = requirements(snippet->wstring().c_str(), adapter, &supported, &minArch, &minOs); - const char* meaning = supported == 0 ? "SUPPORTED" - : (supported & 16) ? "NotImplemented -- the feature has no D3D11 path" - : (supported & 4) ? "AdapterUnsupported" - : (supported & 2) ? "DriverVersionUnsupported" - : (supported & 8) ? "OSVersionBelowMinimum" - : (supported & 1) ? "CheckNotPresent" - : "unknown"; + const char* meaning = supported == 0 ? "SUPPORTED" + : (supported & 16) ? "NotImplemented -- the feature has no D3D11 path" + : (supported & 4) ? "AdapterUnsupported" + : (supported & 2) ? "DriverVersionUnsupported" + : (supported & 8) ? "OSVersionBelowMinimum" + : (supported & 1) ? "CheckNotPresent" + : "unknown"; LOG_WARN("DLSS-NR D3D11: GetFeatureRequirements {} ({}), FeatureSupported 0x{:X} -- {}. " "minimum architecture 0x{:X}, minimum OS 0x{:X}", @@ -2815,8 +2790,8 @@ void ProbeD3D11(void* d3d11Device) factory->Release(); } - LOG_INFO("DLSS-NR D3D11: entry points resolved {}/15 (init {}, create {}, evaluate {}, release {})", - bits, (bits & 1) ? "yes" : "no", (bits & 2) ? "yes" : "no", (bits & 4) ? "yes" : "no", + LOG_INFO("DLSS-NR D3D11: entry points resolved {}/15 (init {}, create {}, evaluate {}, release {})", bits, + (bits & 1) ? "yes" : "no", (bits & 2) ? "yes" : "no", (bits & 4) ? "yes" : "no", (bits & 8) ? "yes" : "no"); if (bits != 15) @@ -2863,14 +2838,12 @@ const char* FailureReason() { return g_nr.failed ? g_nr.reason : ""; } bool GameExposureCanEnable() { - return sessionHasTexture.load() && !sessionPassthrough.load() && haveEvaluated.load() && - !IsRunningVk(); + return sessionHasTexture.load() && !sessionPassthrough.load() && haveEvaluated.load() && !IsRunningVk(); } bool GameExposureEffective() { - return GameExposureCanEnable() && - Config::Instance()->DlssNrWhitePointSource.value_or_default() == 1; + return GameExposureCanEnable() && Config::Instance()->DlssNrWhitePointSource.value_or_default() == 1; } GameExposureWait GameExposureUiState() @@ -2904,8 +2877,6 @@ GameExposureReadout GameExposureMenuReadout() std::optional LastGpuTime() { return g_lastGpuTime; } - - void RequestCapture(unsigned int frames) { ClearCaptureDirectory(); @@ -3035,8 +3006,6 @@ void Shutdown() g_nr.depthClone = nullptr; } - - if (g_nr.motionClone != nullptr) { g_nr.motionClone->Release(); diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h index 76b0c3f2a..3c8f619b2 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h @@ -92,10 +92,9 @@ class DlssNr_Dx12 : public Shader_Dx12, public DlssNr_Common // their place so every descriptor in the table is valid. // One compute pass. The public entry below drives three of these plus the model. bool DispatchPass(ID3D12GraphicsCommandList* InCmdList, const DlssNrConstants& InConstants, - ID3D12Resource* InSource, ID3D12Resource* InModel, ID3D12Resource* InOriginal, - ID3D12Resource* InMotion, - // t4. The game's 1x1 exposure when it is usable and Effective, otherwise the - // 1x1 dummy (E = 1). Null falls back to the dummy; it must not fall back to InSource. - ID3D12Resource* InExposure, ID3D12Resource* OutTarget, - ID3D12Resource* OutKeep); + ID3D12Resource* InSource, ID3D12Resource* InModel, ID3D12Resource* InOriginal, + ID3D12Resource* InMotion, + // t4. The game's 1x1 exposure when it is usable and Effective, otherwise the + // 1x1 dummy (E = 1). Null falls back to the dummy; it must not fall back to InSource. + ID3D12Resource* InExposure, ID3D12Resource* OutTarget, ID3D12Resource* OutKeep); }; diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp b/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp index 2d02feda1..bfd991695 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp +++ b/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp @@ -32,8 +32,8 @@ DlssNr_Vk::DlssNr_Vk(std::string InName, VkDevice InDevice, VkPhysicalDevice InP const VkDeviceSize alignment = std::max(props.limits.minUniformBufferOffsetAlignment, 1); _slotStride = ((sizeof(DlssNrConstants) + alignment - 1) / alignment) * alignment; - if (!CreateBufferResource(_device, _physicalDevice, &_constantBuffer, &_constantBufferMemory, - _slotStride * kSlots, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + if (!CreateBufferResource(_device, _physicalDevice, &_constantBuffer, &_constantBufferMemory, _slotStride * kSlots, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) { LOG_ERROR("DLSS-NR Vulkan pass: could not allocate the constant ring"); @@ -52,15 +52,15 @@ DlssNr_Vk::DlssNr_Vk(std::string InName, VkDevice InDevice, VkPhysicalDevice InP // samplers for the reads: the shader declares its sampler separately, and a combined descriptor // satisfies a separately declared sampled image with the sampler half simply unused. std::vector bindings = { - CreateBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER), // Params - CreateBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gSource - CreateBinding(2, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gModel - CreateBinding(3, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gOriginal - CreateBinding(4, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gMotion - CreateBinding(5, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), // gTarget - CreateBinding(6, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), // gKeep - CreateBinding(7, VK_DESCRIPTOR_TYPE_SAMPLER), // gLinear - CreateBinding(8, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gExposure + CreateBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER), // Params + CreateBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gSource + CreateBinding(2, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gModel + CreateBinding(3, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gOriginal + CreateBinding(4, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gMotion + CreateBinding(5, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), // gTarget + CreateBinding(6, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE), // gKeep + CreateBinding(7, VK_DESCRIPTOR_TYPE_SAMPLER), // gLinear + CreateBinding(8, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER), // gExposure }; CreateLayouts(bindings); @@ -200,10 +200,7 @@ void DlssNr_Vk::WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffse }; const auto writeInfo = [&](VkImageView v) - { - return VkDescriptorImageInfo { VK_NULL_HANDLE, v != VK_NULL_HANDLE ? v : _dummyView, - VK_IMAGE_LAYOUT_GENERAL }; - }; + { return VkDescriptorImageInfo { VK_NULL_HANDLE, v != VK_NULL_HANDLE ? v : _dummyView, VK_IMAGE_LAYOUT_GENERAL }; }; VkDescriptorImageInfo sourceInfo = readInfo(source, sourceLayout); VkDescriptorImageInfo modelInfo = readInfo(model, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); @@ -240,9 +237,8 @@ void DlssNr_Vk::WriteDescriptors(VkDescriptorSet set, VkDeviceSize constantOffse bool DlssNr_Vk::Dispatch(VkCommandBuffer InCmdList, const DlssNrConstants& InConstants, uint32_t InThreadsX, uint32_t InThreadsY, VkImageView InSource, VkImageView InModel, VkImageView InOriginal, - VkImageView InMotion, VkImageView InTarget, VkImageView InKeep, - VkImageLayout InSourceLayout, VkImageLayout InMotionLayout, VkImageView InExposure, - VkImageLayout InExposureLayout) + VkImageView InMotion, VkImageView InTarget, VkImageView InKeep, VkImageLayout InSourceLayout, + VkImageLayout InMotionLayout, VkImageView InExposure, VkImageLayout InExposureLayout) { if (!CanRender() || InCmdList == VK_NULL_HANDLE) return false; diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Vk.h b/OptiScaler/shaders/dlssnr/DlssNr_Vk.h index 0f28dbca9..c6f33b3c0 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Vk.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Vk.h @@ -35,8 +35,8 @@ class DlssNr_Vk : public Shader_Vk static constexpr uint32_t kFramesInFlight = 3; static constexpr uint32_t kSlots = kSlotsPerFrame * kFramesInFlight; - VkDeviceSize _slotStride = 0; // sizeof(DlssNrConstants), rounded up to the device's alignment - uint32_t _slot = 0; // next slot to hand out, wrapping + VkDeviceSize _slotStride = 0; // sizeof(DlssNrConstants), rounded up to the device's alignment + uint32_t _slot = 0; // next slot to hand out, wrapping // Stands in for a resource a given mode does not read. One pixel, never sampled for its content, // present only because Vulkan will not accept an unwritten binding. diff --git a/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp b/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp index e57e537b9..cf0e1f814 100644 --- a/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp +++ b/OptiScaler/upscalers/IFeature_Dx11wDx12.cpp @@ -466,8 +466,7 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG LOG_DEBUG("Dispatch!!"); dx12EvalResult = dx12Feature->Evaluate(cmdList, InParameters); - const bool nrExposureThisFrame = - dx11Exp.Dx12Resource != nullptr && dx11Exp.LastPreparedFrame == cache.frameId; + const bool nrExposureThisFrame = dx11Exp.Dx12Resource != nullptr && dx11Exp.LastPreparedFrame == cache.frameId; InParameters->Set(NVSDK_NGX_Parameter_ExposureTexture, nrExposureThisFrame ? (void*) dx11Exp.Dx12Resource : nullptr); @@ -480,9 +479,8 @@ bool IFeature_Dx11wDx12::Evaluate(ID3D11DeviceContext* InDeviceContext, NVSDK_NG if (!reportedNrOffer) { reportedNrOffer = true; - LOG_INFO("DLSS-NR: the D3D11 bridge reached the hand-off (upscale ok: {}, enabled: {})", - dx12EvalResult, Config::Instance()->DlssNrEnabled.value_or_default()); - + LOG_INFO("DLSS-NR: the D3D11 bridge reached the hand-off (upscale ok: {}, enabled: {})", dx12EvalResult, + Config::Instance()->DlssNrEnabled.value_or_default()); } if (dx12EvalResult && Config::Instance()->DlssNrEnabled.value_or_default()) diff --git a/OptiScaler/upscalers/IFeature_VkwDx12.cpp b/OptiScaler/upscalers/IFeature_VkwDx12.cpp index 46f6a21ff..f8296c64f 100644 --- a/OptiScaler/upscalers/IFeature_VkwDx12.cpp +++ b/OptiScaler/upscalers/IFeature_VkwDx12.cpp @@ -2162,8 +2162,7 @@ bool IFeature_VkwDx12::Evaluate(VkCommandBuffer InCmdBuffer, NVSDK_NGX_Parameter LOG_DEBUG("Dispatch!!"); dx12EvalResult = dx12Feature->Evaluate(cmdList, InParameters); - const bool nrExposureThisFrame = - vkExp.Dx12Resource != nullptr && vkExp.VkSourceImage != VK_NULL_HANDLE; + const bool nrExposureThisFrame = vkExp.Dx12Resource != nullptr && vkExp.VkSourceImage != VK_NULL_HANDLE; InParameters->Set(NVSDK_NGX_Parameter_ExposureTexture, nrExposureThisFrame ? (void*) vkExp.Dx12Resource : nullptr); @@ -2174,8 +2173,8 @@ bool IFeature_VkwDx12::Evaluate(VkCommandBuffer InCmdBuffer, NVSDK_NGX_Parameter if (!reportedNrOffer) { reportedNrOffer = true; - LOG_INFO("DLSS-NR: the Vulkan bridge reached the hand-off (upscale ok: {}, enabled: {})", - dx12EvalResult, Config::Instance()->DlssNrEnabled.value_or_default()); + LOG_INFO("DLSS-NR: the Vulkan bridge reached the hand-off (upscale ok: {}, enabled: {})", dx12EvalResult, + Config::Instance()->DlssNrEnabled.value_or_default()); } if (dx12EvalResult && Config::Instance()->DlssNrEnabled.value_or_default()) From cdac1fadb4a1393601d58a19f763ec04f6955089 Mon Sep 17 00:00:00 2001 From: 4223641 Date: Thu, 3 Sep 2026 23:16:00 +0800 Subject: [PATCH 4/4] Fix DLSS-NR rebase review leftovers and keep the warm exposure courier. Co-authored-by: Cursor --- OptiScaler/dlssnr/DlssNrFeature_Vk.cpp | 4 +- OptiScaler/dlssnr/DlssNrFeature_Vk.h | 5 +- OptiScaler/dlssnr/DlssNr_Exposure.h | 2 +- OptiScaler/dlssnr/DlssNr_Menu.cpp | 2 +- .../2026-09-03-game-exposure-white-point.md | 4 +- ...2026-09-03-matched-residual-corrections.md | 2 +- OptiScaler/dlssnr/tests/exposure_fixture.cpp | 6 + .../tests/white_point_decision_fixture.cpp | 3 + OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp | 290 +----------------- OptiScaler/shaders/dlssnr/DlssNr_Dx12.h | 7 +- OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp | 3 +- OptiScaler/shaders/dlssnr/DlssNr_Vk.h | 4 +- .../shaders/dlssnr/precompile/dlssnr.hlsl | 6 +- 13 files changed, 40 insertions(+), 298 deletions(-) diff --git a/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp b/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp index bcd128cc9..219051c98 100644 --- a/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp +++ b/OptiScaler/dlssnr/DlssNrFeature_Vk.cpp @@ -888,8 +888,8 @@ void EvaluateAfterUpscaleVk(VkCommandBuffer cmdBuffer, NVSDK_NGX_Parameter* para // The meter: the game's 1x1 exposure -> texel (0,0) of the grid -> a buffer the CPU can read // ----------------------------------------------------------------------------------------- - // The motion slot carries it, because the meter has no use for motion vectors and the shader is - // one shader with a fixed set of bindings. The source slot is left empty and gets the dummy. + // Mode 3 binds the game's exposure on binding 8. Motion (binding 4) and the other unused reads + // get the dummy. The shader is one program with a fixed set of bindings. // // Gated on the setting that consumes the answer, which is not merely tidy. This is the only place // the pass binds a resource it does not own on a guess about its layout, and the guess is good diff --git a/OptiScaler/dlssnr/DlssNrFeature_Vk.h b/OptiScaler/dlssnr/DlssNrFeature_Vk.h index 1036fb457..8028e8bf2 100644 --- a/OptiScaler/dlssnr/DlssNrFeature_Vk.h +++ b/OptiScaler/dlssnr/DlssNrFeature_Vk.h @@ -57,9 +57,8 @@ unsigned long long FramesVk(); // A timestamp pair either side of the whole pass, read three frames later so the query is retired. std::optional LastGpuTimeVk(); -// Whether the game offers an exposure texture on this path. Observed only: it is not read, because -// binding the game's image means naming a layout this side cannot know. For the menu, and to settle -// whether reading it is worth the risk on any real Vulkan game. +// Whether the game offers an exposure texture on this path. The picture never sets UseGameExposure. +// Mode 3 may bind that texture on binding 8 when WhitePointSource is 1, as a courier only. bool ExposureOfferedVk(); void ShutdownVk(bool deviceAlive = true); diff --git a/OptiScaler/dlssnr/DlssNr_Exposure.h b/OptiScaler/dlssnr/DlssNr_Exposure.h index 1f40b2052..e7f7e5324 100644 --- a/OptiScaler/dlssnr/DlssNr_Exposure.h +++ b/OptiScaler/dlssnr/DlssNr_Exposure.h @@ -42,7 +42,7 @@ inline WhitePointDecision DecideWhitePoint(uint32_t source, // WhitePointSo WhitePointDecision d { scale, 0 }; if (!isHdrBuffer) return d; - if (source == 0) + if (source != 1 && source != 2) return d; if (source == 2) { diff --git a/OptiScaler/dlssnr/DlssNr_Menu.cpp b/OptiScaler/dlssnr/DlssNr_Menu.cpp index 7ea496d06..78b47b313 100644 --- a/OptiScaler/dlssnr/DlssNr_Menu.cpp +++ b/OptiScaler/dlssnr/DlssNr_Menu.cpp @@ -395,7 +395,7 @@ void RenderMenu(Config* config, float menuResScale) { ImGui::TextColored(live, "Exposure %.3f · pre %.2f · scale %.2f", readout.e, readout.p, readout.s); - ImGui::TextColored(live, "game white %.1f · trim %.2f× · in use %.1f", readout.gameW, + ImGui::TextColored(live, "game white %.1f · trim %.2f× · courier %.1f", readout.gameW, readout.slider, readout.slider * readout.gameW); } else diff --git a/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md b/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md index c82b23e68..dd89f1bc0 100644 --- a/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md +++ b/OptiScaler/dlssnr/design/2026-09-03-game-exposure-white-point.md @@ -1,8 +1,8 @@ # Game exposure as paper white (hhkbble rewrite) -> **Rebase note (2026-09-03):** [2026-09-03-rebase-onto-dlss-neural-rendering.md](2026-09-03-rebase-onto-dlss-neural-rendering.md) +> **Rebase note (2026-09-03):** `2026-09-03-rebase-onto-dlss-neural-rendering.md` > wins where this file conflicts. Approach B still applies on D3D12 source 1. The origin -> WhitePointSource dropdown and scan survive. `ResolveWhitePoint` stays for sources 0 and 2. +> WhitePointSource dropdown and scan survive. Sources 0 and 2 live in `DecideWhitePoint`. **Status:** design for implementation. Rewritten 2026-09-03 for `dlssnr-hhkbble`; review locks applied. Supersedes the `1c1d39e2` draft of this filename. A plan must be written from **this** diff --git a/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md b/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md index 65e7d7c02..acd5fbb77 100644 --- a/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md +++ b/OptiScaler/dlssnr/design/2026-09-03-matched-residual-corrections.md @@ -1,6 +1,6 @@ # Matched residual corrections: empty-model gate, P from colorCopy, strength-0 copy -> **Rebase note (2026-09-03):** [2026-09-03-rebase-onto-dlss-neural-rendering.md](2026-09-03-rebase-onto-dlss-neural-rendering.md) +> **Rebase note (2026-09-03):** `2026-09-03-rebase-onto-dlss-neural-rendering.md` > wins where this file conflicts. Empty-model + t3 \(P\) still apply. The row that says > “Vulkan has no working scale” is false on `dlss-neural-rendering`. diff --git a/OptiScaler/dlssnr/tests/exposure_fixture.cpp b/OptiScaler/dlssnr/tests/exposure_fixture.cpp index b7cea5a53..40a7cba91 100644 --- a/OptiScaler/dlssnr/tests/exposure_fixture.cpp +++ b/OptiScaler/dlssnr/tests/exposure_fixture.cpp @@ -30,6 +30,12 @@ int main() const WhitePointDecision usable = DecideWhitePoint(1, true, true, false, 8.0f, 1.25f, 0.012f, 1.0f, 1.0f, 0.0f); assert(usable.useGameExposure == 1); assert(std::fabs(usable.whitePoint - 1.25f) <= 1e-4f); + const WhitePointDecision unknown = DecideWhitePoint(3, true, true, true, 8.0f, 1.25f, 0.012f, 1.0f, 1.0f, 12.0f); + assert(unknown.useGameExposure == 0); + assert(std::fabs(unknown.whitePoint - 8.0f) <= 1e-4f); + const WhitePointDecision holePs = DecideWhitePoint(1, true, false, true, 8.0f, 1.25f, 0.012f, 2.0f, 0.5f, 0.0f); + assert(holePs.useGameExposure == 0); + assert(std::fabs(holePs.whitePoint - 1.25f * GameWhite(0.012f, 2.0f, 0.5f)) <= 1e-4f); std::string headerPath(__FILE__); const auto slash = headerPath.find_last_of("/\\"); diff --git a/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp b/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp index 3ac557720..52f7fc749 100644 --- a/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp +++ b/OptiScaler/dlssnr/tests/white_point_decision_fixture.cpp @@ -28,5 +28,8 @@ int main() expect(DecideWhitePoint(1, true, false, false, scale, trim, 0.012f, pre, es, 0.0f), scale, 0); expect(DecideWhitePoint(2, true, true, true, scale, trim, held, pre, es, anchored), anchored, 0); expect(DecideWhitePoint(2, true, true, true, scale, trim, held, pre, es, 0.0f), scale, 0); + expect(DecideWhitePoint(3, true, true, true, scale, trim, held, pre, es, anchored), scale, 0); + expect(DecideWhitePoint(1, true, false, true, scale, trim, held, 2.0f, 0.5f, 0.0f), + trim * GameWhite(held, 2.0f, 0.5f), 0); return 0; } diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp index 6eed581db..cdac03a6f 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp +++ b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.cpp @@ -248,25 +248,6 @@ struct NrState ID3D12Resource* meter = nullptr; ID3D12Resource* meterReadback[4] = {}; - // The calibration grid: what scale the game's buffer is on, measured from the untouched copy. - // Its own surface and ring rather than sharing the meter's, because the two run at different - // sizes -- the meter fetches one texel and this reads the whole frame. - ID3D12Resource* calib = nullptr; - ID3D12Resource* calibReadback[4] = {}; - unsigned long long calibFrames = 0; - - // The last few answers, so the menu can say how settled the number is. A suggestion taken during - // a fade or a loading screen is worth less than one taken while standing still, and the spread - // across recent frames is what tells them apart. - static constexpr unsigned int kCalibHistory = 32; - float calibHistory[kCalibHistory] = {}; - unsigned int calibCount = 0; - float calibSuggestion = 0.0f; - float calibSteadiness = 0.0f; - bool calibUsable = false; - const char* calibWhy = "measuring..."; - bool calibPassthrough = false; - // Whether the frame that filled each readback slot actually had an exposure texture bound. // // The meter writes tile 0 from t4. Mode 3 runs only when this frame's pointer is usable, so a @@ -279,13 +260,6 @@ struct NrState unsigned int meterSlot = 0; unsigned long long meterFrames = 0; - // Whether the setting was on last frame, so the off->on edge can be caught. - // - // Deliberately the SETTING and not `wantExposure`: the texture itself comes and goes between - // frames and holding the last good value across those gaps is the whole point of the field below. - // Only the user turning the option back on means "anything held is from an unknown time ago". - bool exposureSettingWasOn = false; - // The game's exposure, as last read back, and the pre-exposure that goes with it. Held rather // than defaulted: the texture comes and goes between frames and a fallback to 1.0 on the gaps // would be a flicker source. @@ -703,37 +677,6 @@ void Barrier(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* res, D3D12_RESO constexpr unsigned int kMeterRowBytes = kDlssNrMeterGrid * sizeof(float); constexpr unsigned int kMeterBytes = kMeterRowBytes * kDlssNrMeterGrid; -// Records the copy of this frame's grid into whichever readback buffer is furthest from being read. -// Same shape as the meter's copy, against the calibration surface and its own ring. -void CopyCalibrationToReadback(ID3D12GraphicsCommandList* cmdList) -{ - const unsigned int slot = (unsigned int) (g_nr.calibFrames % 4); - - if (g_nr.calibReadback[slot] == nullptr || g_nr.calib == nullptr) - return; - - D3D12_TEXTURE_COPY_LOCATION srcLoc {}; - srcLoc.pResource = g_nr.calib; - srcLoc.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; - srcLoc.SubresourceIndex = 0; - - D3D12_TEXTURE_COPY_LOCATION dst {}; - dst.pResource = g_nr.calibReadback[slot]; - dst.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; - dst.PlacedFootprint.Offset = 0; - dst.PlacedFootprint.Footprint.Format = DXGI_FORMAT_R32_FLOAT; - dst.PlacedFootprint.Footprint.Width = kDlssNrMeterGrid; - dst.PlacedFootprint.Footprint.Height = kDlssNrMeterGrid; - dst.PlacedFootprint.Footprint.Depth = 1; - dst.PlacedFootprint.Footprint.RowPitch = kMeterRowBytes; - - Barrier(cmdList, g_nr.calib, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE); - cmdList->CopyTextureRegion(&dst, 0, 0, 0, &srcLoc, nullptr); - Barrier(cmdList, g_nr.calib, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); - - g_nr.calibFrames++; -} - void CopyMeterToReadback(ID3D12GraphicsCommandList* cmdList, ID3D12Device* device, bool exposureBound) { const unsigned int slot = (unsigned int) (g_nr.meterFrames % 4); @@ -772,109 +715,6 @@ void CopyMeterToReadback(ID3D12GraphicsCommandList* cmdList, ID3D12Device* devic // off a frame this pass writes is a feedback loop rather than a measurement. What is left is a // courier -- the game's exposure is a 1x1 texture in a resource state this pass did not set and must // not transition, so the shader reads it as an SRV and it rides home on a readback that exists. -// Reads the calibration grid written four frames ago and turns it into one number. -// -// A high percentile of tile peaks, not the maximum: the maximum is a sun or a specular hit and would -// normalise the whole picture into the dark. The 90th percentile is high enough to sit at the top of -// the real range and common enough that no single highlight decides it. -void ConsumeCalibrationReadback() -{ - if (g_nr.calibFrames < 4) - return; - - const unsigned int slot = (unsigned int) (g_nr.calibFrames % 4); - ID3D12Resource* buffer = g_nr.calibReadback[slot]; - - if (buffer == nullptr) - return; - - void* mapped = nullptr; - D3D12_RANGE range { 0, kMeterBytes }; - - if (FAILED(buffer->Map(0, &range, &mapped)) || mapped == nullptr) - return; - - const float* src = (const float*) mapped; - - std::vector tiles; - tiles.reserve(kDlssNrMeterGrid * kDlssNrMeterGrid); - - for (unsigned int i = 0; i < kDlssNrMeterGrid * kDlssNrMeterGrid; ++i) - { - if (std::isfinite(src[i]) && src[i] > 1e-6f) - tiles.push_back(src[i]); - } - - D3D12_RANGE nothingWritten { 0, 0 }; - buffer->Unmap(0, ¬hingWritten); - - if (tiles.size() < 16) - return; - - const size_t nth = (size_t) ((float) (tiles.size() - 1) * 0.90f); - std::nth_element(tiles.begin(), tiles.begin() + nth, tiles.end()); - - // How much of the frame carries light, measured against its own brightest tile rather than an - // absolute threshold -- the units here are the game's and there is no absolute scale. - // - // This is what separates "the buffer is scaled by 240" from "I am standing in a dark cave". A - // percentile of tile peaks is a statement about scene content; it only describes the buffer when - // enough of the picture is lit for the top of the range to actually appear in it. - float brightest = 0.0f; - - for (float v : tiles) - brightest = std::max(brightest, v); - - unsigned int lit = 0; - - for (float v : tiles) - { - if (v > brightest * 0.10f) - ++lit; - } - - const float litFraction = tiles.empty() ? 0.0f : (float) lit / (float) tiles.size(); - - // A torn readback survives isfinite and would clamp to exactly the ceiling, which since the - // ceiling became 2000 is a value the slider can hold -- so a garbage frame could be offered as a - // real answer. Reject rather than clamp. - if (!(tiles[nth] > 0.0f) || tiles[nth] >= 1999.0f) - return; - - const float suggestion = std::clamp(tiles[nth], 0.25f, 1990.0f); - - g_nr.calibUsable = !g_nr.calibPassthrough && litFraction > 0.20f; - g_nr.calibWhy = g_nr.calibPassthrough - ? "this game hands over a frame it already tone mapped, so there is nothing to normalise" - : litFraction <= 0.20f ? "too little of this scene is lit to say where the top of the range is" - : ""; - - g_nr.calibHistory[g_nr.calibCount % NrState::kCalibHistory] = suggestion; - g_nr.calibCount++; - g_nr.calibSuggestion = suggestion; - - // Confidence is the spread of recent answers, not their absolute size. A number that has held - // still for a second is one worth taking; one that is swinging means the scene is changing under - // the measurement, and no single value would serve anyway. - const unsigned int have = std::min(g_nr.calibCount, NrState::kCalibHistory); - - if (have >= 8) - { - float lo = g_nr.calibHistory[0]; - float hi = g_nr.calibHistory[0]; - - for (unsigned int i = 0; i < have; ++i) - { - lo = std::min(lo, g_nr.calibHistory[i]); - hi = std::max(hi, g_nr.calibHistory[i]); - } - - // A spread of 1.0x is perfect agreement and 2x or worse is none. - const float spread = hi / lo; - g_nr.calibSteadiness = std::clamp(1.0f - (spread - 1.0f), 0.0f, 1.0f); - } -} - void ConsumeMeterReadback() { if (g_nr.meterFrames < 4) @@ -894,10 +734,9 @@ void ConsumeMeterReadback() const float* src = (const float*) mapped; - // Only believed when the frame that wrote this grid actually had an exposure texture bound. With - // nothing bound DispatchPass substitutes the source picture, and tile 0 is then a scene pixel - // rather than an exposure -- believing it made the white point follow the top-left corner of the - // screen, which in Cyberpunk moved by up to 272x between frames and flashed the whole picture. + // Only believed when the frame that wrote this grid actually had an exposure texture bound. A + // missing t4 binds the 1x1 dummy (E = 1), never InSource -- believing a scene pixel as exposure + // is what made Cyberpunk's top-left corner drive the white point from 0.18 to 74. // // When it is not believed gameExposure keeps its last good value, or stays 0. Held E is // the hole's clock only; a game that never supplied a usable exposure stays on the slider. @@ -914,21 +753,12 @@ void ConsumeMeterReadback() // Forget everything the meter knows, so nothing read before this moment can be believed after it. // -// The exposure is written only inside the block that dispatches the meter, and that block does not -// run while the option is off. Nothing used to clear any of this when it stopped, so the reading -// simply froze: switching the option back on returned the value from whenever it was switched off, -// and ResolveWhitePoint took it as current because a held value is exactly what it expects to see. -// GTA V's exposure spans 0.127 to 0.511 in one session, so re-enabling in different light handed the -// encode a white point up to 4x wrong -- which trips the soft knee, scales the model's answer away -// and leaves its hue behind. That is the colour cast, and it looked random because it depends on the -// light at the moment of the PREVIOUS switch-off, which nothing on screen shows. -// -// The readback ring made it worse. `meterFrames` also only advances inside that block, so the four -// slots kept their contents and their valid flags across the gap, and the first frames after -// re-enabling consumed buffers written before it as though they had just arrived. +// Mode 3 now runs whenever the texture is usable, including on sources 0 and 2, so the courier stays +// warm. Do not call this when the user merely switches WhitePointSource to 1 -- that discarded the +// held E the hole path needs. Resize / rebuild still go through InvalidateMeterReadback. // -// Zero is not a fallback value here, it is the absence of one: ResolveWhitePoint's `> 1e-6f` guard -// fails and the manual slider is used, which is what a game supplying no exposure already gets. +// Zero is not a fallback value here, it is the absence of one: DecideWhitePoint's hole path then +// uses Scale, which is what a game supplying no exposure already gets. void InvalidateExposureMeter() { g_nr.gameExposure = 0.0f; @@ -941,74 +771,7 @@ void InvalidateExposureMeter() g_nr.meterFrames = 0; } -// Turns what the meter saw into the divisor the encode uses, or falls back to the slider. -// -// `cut` says the exposure may jump rather than drift, and it is the difference between this working -// and not. GTA V's character switch pulls the camera up through the sky: a linear HDR buffer's sky is -// tens of times brighter than the ground, the proxy clips to flat white, and the frame blows out until -// the camera comes back down. Easing across that at two percent a frame takes three and a half -// seconds, which is longer than the transition -- so a meter that only eases would lag through the -// whole thing and fix nothing. -// -// So a cut snaps and a drift eases. Walking out of a cave is a drift; a camera cut is not, and -// pretending otherwise to avoid pumping just moves the failure somewhere more visible. -float ResolveWhitePoint(const Config& cfg, bool isHdrBuffer) -{ - const float slider = cfg.DlssNrWhitePointScale.value_or_default(); - - // A frame the game already tone mapped is display-referred: white is at 1 by definition and there - // is nothing to measure. The slider stays available as a manual exposure on that path. - if (!isHdrBuffer) - return slider; - - // The game's own exposure, where it supplies one. - // - // Exposure is the step that makes a cave and a field comparable: the renderer works in arbitrary - // scene-referred units and multiplies by this before tone mapping, which is precisely why one - // fixed paper white cannot serve both. FSR spells the relationship out -- frame / preExposure * - // exposure -- so undoing it gives the divisor this pass wants, and paper white becomes a constant - // on top rather than a value chasing the scene. - // - // Unlike anything measured off the frame this cannot be moved by what the pass writes, which is - // what killed the statistical meter. It is the game's number, decided upstream. - // - // Held across the frames where the texture is absent -- GTA V dropped it three times in one - // session -- because falling back to a default on those frames is a flicker, not a fallback. - // The scan's anchor, where the game supplies no exposure of its own. - // - // Only ratios are used, so the units of the buffer never have to be known -- which is the whole - // reason this is anchored rather than absolute. The anchor is the user's own white point at the - // moment they pressed the button; everything after that is the scan moving it. - // - // Deliberately below the exposure texture in priority and mutually exclusive with it in the - // menu. A game that hands over a real exposure has no business being driven by a buffer found by - // its shape, and two sources fighting over one number is the class of bug worth making - // unreachable rather than merely unlikely. - if (cfg.DlssNrWhitePointSource.value_or_default() == 2) - { - // Multi-point: one or more calibration points the user placed, interpolated in log space by - // the current scan value. One point is the original ratio law; more fit the buffer's actual - // relationship so the white point holds across the whole range, not only near one anchor. - const float w = DlssNr::ExposureScan::AnchoredWhitePoint(DlssNr::ExposureScan::BestValue(), - cfg.DlssNrScanInverted.value_or_default(), - cfg.DlssNrScanTrim.value_or_default()); - - if (w > 0.0f) - return w; - } - - // Source 1 picture and hole use DecideWhitePoint only. Do not compute P/E*trim here. - - // Otherwise the slider, and only the slider. - // - // Measuring white from the frame was tried and removed. It could not be made to work because the - // pass writes the frame it measures: in Enshrouded one session walked the divisor from 0.010 to - // 97.910, and toggling NR at a fixed spot read 41.31 off and 0.46 on. Two attempts to damp it -- - // a relative lit threshold, then a rate limit with a cut snap -- both treated a coupled system as - // a noisy one and neither held. A constant cannot do that, which is the whole argument for it, - // and is what RenoDX has always done. - return slider; -} +// D3D12 picture white point for sources 0 and 2 (and source 1) lives in DecideWhitePoint only. ID3D12Resource* CreateScratch(ID3D12Device* device, DXGI_FORMAT format, unsigned int width, unsigned int height) { @@ -2084,12 +1847,6 @@ void DlssNr_Dx12::Dispatch(ID3D12GraphicsCommandList* cmdList, ID3D12Resource* c const bool usable = ExposureUsable(gameRes); const uint32_t source = cfg.DlssNrWhitePointSource.value_or_default(); - if (source == 1 && !g_nr.exposureSettingWasOn) - { - InvalidateExposureMeter(); - LOG_INFO("DLSS-NR exposure: option switched on, held reading discarded"); - } - g_nr.exposureSettingWasOn = source == 1; haveEvaluated.store(true); sessionPassthrough.store(!isHdrBuffer); @@ -2949,28 +2706,6 @@ void Shutdown() g_nr.meter = nullptr; } - if (g_nr.calib != nullptr) - { - g_nr.calib->Release(); - g_nr.calib = nullptr; - } - - for (auto& r : g_nr.calibReadback) - { - if (r != nullptr) - { - r->Release(); - r = nullptr; - } - } - - g_nr.calibFrames = 0; - g_nr.calibCount = 0; - g_nr.calibSuggestion = 0.0f; - g_nr.calibSteadiness = 0.0f; - g_nr.calibUsable = false; - g_nr.calibWhy = "measuring..."; - for (auto& rb : g_nr.meterReadback) { if (rb != nullptr) @@ -2981,10 +2716,9 @@ void Shutdown() } // The slots these flags describe have just been released, so nothing may vouch for what the next - // buffers happen to contain. gameExposure is deliberately NOT cleared here: a recreate is a - // transition within the same scene, and dropping to the slider for a few frames would be the - // flicker the held value exists to prevent. The user switching the option off is the case where - // the held value has to go, and that is handled at the edge in Dispatch. + // buffers happen to contain. gameExposure is cleared below because Shutdown tears the session + // down; a mid-session recreate goes through InvalidateMeterReadback instead. Switching + // WhitePointSource to 1 must not wipe a courier Mode 3 has been keeping warm. for (bool& valid : g_nr.meterExposureValid) valid = false; diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h index 3c8f619b2..8f374ae7b 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Dx12.h @@ -38,10 +38,9 @@ // and the constants live in an UPLOAD heap written at record time -- so a wrap while the GPU is still // reading a slot rewrites descriptors and constants underneath it. // -// A fifth dispatch has since been added -- the calibration grid -- which at thirty-two slots would -// have left six frames, spending exactly the headroom the previous note set aside. Forty-eight -// restores eight frames at five dispatches. If a sixth is ever added, raise this with it rather than -// spending the margin again. +// Live composition dispatches are encode, optional meter, optional downsample, and resolve -- four +// at most, not a fifth calibration grid. Forty-eight slots keep eight frames of coverage. If another +// dispatch is added, raise this with it rather than spending the margin again. #define DLSSNR_NUM_OF_HEAPS 48 class DlssNr_Dx12 : public Shader_Dx12, public DlssNr_Common diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp b/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp index bfd991695..5b5748ccb 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp +++ b/OptiScaler/shaders/dlssnr/DlssNr_Vk.cpp @@ -118,7 +118,8 @@ DlssNr_Vk::~DlssNr_Vk() // One pixel, R16G16B16A16_SFLOAT so it is legal for both a sampled read and a storage write, moved // once into GENERAL and left there. Its content is never read: it exists because Vulkan rejects a // descriptor set with an unwritten binding, and the shader declares all eight resources at file scope -// whichever mode is running. The fifth read (binding 8) is always this placeholder. +// whichever mode is running. The fifth read (binding 8) is this placeholder unless the caller passes +// InExposure (Mode 3 courier). bool DlssNr_Vk::CreateDummy(VkCommandBuffer cmdList) { if (_dummyReady) diff --git a/OptiScaler/shaders/dlssnr/DlssNr_Vk.h b/OptiScaler/shaders/dlssnr/DlssNr_Vk.h index c6f33b3c0..46590b682 100644 --- a/OptiScaler/shaders/dlssnr/DlssNr_Vk.h +++ b/OptiScaler/shaders/dlssnr/DlssNr_Vk.h @@ -12,8 +12,8 @@ // Every binding is written every dispatch. The shader declares all eight resources at file scope and // branches on gMode, so all of them are statically reachable from the entry point and Vulkan requires // a valid descriptor for each one whether a given mode reads it or not. Slots a mode has no use for -// get a 1x1 dummy rather than a null handle. Binding 8 (gExposure) is always that dummy: native -// Vulkan does not sample the game's exposure image. +// get a 1x1 dummy rather than a null handle. Binding 8 (gExposure) is that dummy except on Mode 3, +// which binds the game's exposure view for the courier. Encode and resolve never set UseGameExposure. // // Constants are slotted rather than overwritten. A single mapped uniform buffer would be wrong here: // encode and resolve run in the same frame with different constants, and the second write would land diff --git a/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl b/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl index 9c692d3de..6a09794ff 100644 --- a/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl +++ b/OptiScaler/shaders/dlssnr/precompile/dlssnr.hlsl @@ -359,9 +359,9 @@ void CSMain(uint3 id : SV_DispatchThreadID) // Normalised, so the source may be any size relative to this dispatch. float2 uv = (float2(id.xy) + 0.5) / float2(gWidth, gHeight); - // The meter. One thread per tile of a 64x64 grid over the frame, writing that tile's mean - // luminance. The frame is raw linear here -- this runs before the encode, on purpose, because the - // number being looked for is what the encode's divisor should be. + // The meter. Tile (0,0) is a courier Load of t4 (the game's 1x1 exposure). D3D12 runs this after + // encode; the picture white point is DecideWhitePoint / PaperWhite(), not this grid. Other tiles + // still write means when the dispatch is larger than 1x1 (native Vulkan courier). // // A mean per tile, then a percentile across tiles on the CPU. Not the frame's mean, which is what // the meter this replaces measured: that reads scene brightness, and a dark scene then asks for a