156 files changed, 70262 insertions, 0 deletions

diff --git a/SDL-3.2.8/src/render/SDL_d3dmath.c b/SDL-3.2.8/src/render/SDL_d3dmath.c
new file mode 100644
index 0000000..6a1ab59
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_d3dmath.c
@@ -0,0 +1,135 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#if defined(SDL_VIDEO_RENDER_D3D) || \
+    defined(SDL_VIDEO_RENDER_D3D11) || \
+    defined(SDL_VIDEO_RENDER_D3D12) || \
+    defined(SDL_VIDEO_RENDER_VULKAN)
+
+#include "SDL_d3dmath.h"
+
+// Direct3D matrix math functions
+
+Float4X4 MatrixIdentity(void)
+{
+    Float4X4 m;
+    SDL_zero(m);
+    m.v._11 = 1.0f;
+    m.v._22 = 1.0f;
+    m.v._33 = 1.0f;
+    m.v._44 = 1.0f;
+    return m;
+}
+
+Float4X4 MatrixMultiply(Float4X4 M1, Float4X4 M2)
+{
+    Float4X4 m;
+    m.v._11 = M1.v._11 * M2.v._11 + M1.v._12 * M2.v._21 + M1.v._13 * M2.v._31 + M1.v._14 * M2.v._41;
+    m.v._12 = M1.v._11 * M2.v._12 + M1.v._12 * M2.v._22 + M1.v._13 * M2.v._32 + M1.v._14 * M2.v._42;
+    m.v._13 = M1.v._11 * M2.v._13 + M1.v._12 * M2.v._23 + M1.v._13 * M2.v._33 + M1.v._14 * M2.v._43;
+    m.v._14 = M1.v._11 * M2.v._14 + M1.v._12 * M2.v._24 + M1.v._13 * M2.v._34 + M1.v._14 * M2.v._44;
+    m.v._21 = M1.v._21 * M2.v._11 + M1.v._22 * M2.v._21 + M1.v._23 * M2.v._31 + M1.v._24 * M2.v._41;
+    m.v._22 = M1.v._21 * M2.v._12 + M1.v._22 * M2.v._22 + M1.v._23 * M2.v._32 + M1.v._24 * M2.v._42;
+    m.v._23 = M1.v._21 * M2.v._13 + M1.v._22 * M2.v._23 + M1.v._23 * M2.v._33 + M1.v._24 * M2.v._43;
+    m.v._24 = M1.v._21 * M2.v._14 + M1.v._22 * M2.v._24 + M1.v._23 * M2.v._34 + M1.v._24 * M2.v._44;
+    m.v._31 = M1.v._31 * M2.v._11 + M1.v._32 * M2.v._21 + M1.v._33 * M2.v._31 + M1.v._34 * M2.v._41;
+    m.v._32 = M1.v._31 * M2.v._12 + M1.v._32 * M2.v._22 + M1.v._33 * M2.v._32 + M1.v._34 * M2.v._42;
+    m.v._33 = M1.v._31 * M2.v._13 + M1.v._32 * M2.v._23 + M1.v._33 * M2.v._33 + M1.v._34 * M2.v._43;
+    m.v._34 = M1.v._31 * M2.v._14 + M1.v._32 * M2.v._24 + M1.v._33 * M2.v._34 + M1.v._34 * M2.v._44;
+    m.v._41 = M1.v._41 * M2.v._11 + M1.v._42 * M2.v._21 + M1.v._43 * M2.v._31 + M1.v._44 * M2.v._41;
+    m.v._42 = M1.v._41 * M2.v._12 + M1.v._42 * M2.v._22 + M1.v._43 * M2.v._32 + M1.v._44 * M2.v._42;
+    m.v._43 = M1.v._41 * M2.v._13 + M1.v._42 * M2.v._23 + M1.v._43 * M2.v._33 + M1.v._44 * M2.v._43;
+    m.v._44 = M1.v._41 * M2.v._14 + M1.v._42 * M2.v._24 + M1.v._43 * M2.v._34 + M1.v._44 * M2.v._44;
+    return m;
+}
+
+Float4X4 MatrixScaling(float x, float y, float z)
+{
+    Float4X4 m;
+    SDL_zero(m);
+    m.v._11 = x;
+    m.v._22 = y;
+    m.v._33 = z;
+    m.v._44 = 1.0f;
+    return m;
+}
+
+Float4X4 MatrixTranslation(float x, float y, float z)
+{
+    Float4X4 m;
+    SDL_zero(m);
+    m.v._11 = 1.0f;
+    m.v._22 = 1.0f;
+    m.v._33 = 1.0f;
+    m.v._44 = 1.0f;
+    m.v._41 = x;
+    m.v._42 = y;
+    m.v._43 = z;
+    return m;
+}
+
+Float4X4 MatrixRotationX(float r)
+{
+    float sinR = SDL_sinf(r);
+    float cosR = SDL_cosf(r);
+    Float4X4 m;
+    SDL_zero(m);
+    m.v._11 = 1.0f;
+    m.v._22 = cosR;
+    m.v._23 = sinR;
+    m.v._32 = -sinR;
+    m.v._33 = cosR;
+    m.v._44 = 1.0f;
+    return m;
+}
+
+Float4X4 MatrixRotationY(float r)
+{
+    float sinR = SDL_sinf(r);
+    float cosR = SDL_cosf(r);
+    Float4X4 m;
+    SDL_zero(m);
+    m.v._11 = cosR;
+    m.v._13 = -sinR;
+    m.v._22 = 1.0f;
+    m.v._31 = sinR;
+    m.v._33 = cosR;
+    m.v._44 = 1.0f;
+    return m;
+}
+
+Float4X4 MatrixRotationZ(float r)
+{
+    float sinR = SDL_sinf(r);
+    float cosR = SDL_cosf(r);
+    Float4X4 m;
+    SDL_zero(m);
+    m.v._11 = cosR;
+    m.v._12 = sinR;
+    m.v._21 = -sinR;
+    m.v._22 = cosR;
+    m.v._33 = 1.0f;
+    m.v._44 = 1.0f;
+    return m;
+}
+
+#endif // SDL_VIDEO_RENDER_D3D || SDL_VIDEO_RENDER_D3D11 || SDL_VIDEO_RENDER_D3D12 || SDL_VIDEO_RENDER_VULKAN
diff --git a/SDL-3.2.8/src/render/SDL_d3dmath.h b/SDL-3.2.8/src/render/SDL_d3dmath.h
new file mode 100644
index 0000000..84cff9e
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_d3dmath.h
@@ -0,0 +1,85 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#if defined(SDL_VIDEO_RENDER_D3D) || \
+    defined(SDL_VIDEO_RENDER_D3D11) || \
+    defined(SDL_VIDEO_RENDER_D3D12) || \
+    defined(SDL_VIDEO_RENDER_GPU) || \
+    defined(SDL_VIDEO_RENDER_VULKAN)
+
+// Set up for C function definitions, even when using C++
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Direct3D matrix math functions
+
+typedef struct
+{
+    float x;
+    float y;
+} Float2;
+
+typedef struct
+{
+    float x;
+    float y;
+    float z;
+} Float3;
+
+typedef struct
+{
+    float x;
+    float y;
+    float z;
+    float w;
+} Float4;
+
+typedef struct
+{
+    union
+    {
+        struct
+        {
+            float _11, _12, _13, _14;
+            float _21, _22, _23, _24;
+            float _31, _32, _33, _34;
+            float _41, _42, _43, _44;
+        } v;
+        float m[4][4];
+    };
+} Float4X4;
+
+extern Float4X4 MatrixIdentity(void);
+extern Float4X4 MatrixMultiply(Float4X4 M1, Float4X4 M2);
+extern Float4X4 MatrixScaling(float x, float y, float z);
+extern Float4X4 MatrixTranslation(float x, float y, float z);
+extern Float4X4 MatrixRotationX(float r);
+extern Float4X4 MatrixRotationY(float r);
+extern Float4X4 MatrixRotationZ(float r);
+
+// Ends C function definitions when using C++
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SDL_VIDEO_RENDER_D3D || SDL_VIDEO_RENDER_D3D11 || SDL_VIDEO_RENDER_D3D12 || SDL_VIDEO_RENDER_VULKAN
diff --git a/SDL-3.2.8/src/render/SDL_render.c b/SDL-3.2.8/src/render/SDL_render.c
new file mode 100644
index 0000000..82ecb88
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_render.c
@@ -0,0 +1,5676 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// The SDL 2D rendering system
+
+#include "SDL_sysrender.h"
+#include "SDL_render_debug_font.h"
+#include "software/SDL_render_sw_c.h"
+#include "../events/SDL_windowevents_c.h"
+#include "../video/SDL_pixels_c.h"
+#include "../video/SDL_video_c.h"
+
+#ifdef SDL_PLATFORM_ANDROID
+#include "../core/android/SDL_android.h"
+#include "../video/android/SDL_androidevents.h"
+#endif
+
+/* as a courtesy to iOS apps, we don't try to draw when in the background, as
+that will crash the app. However, these apps _should_ have used
+SDL_AddEventWatch to catch SDL_EVENT_WILL_ENTER_BACKGROUND events and stopped
+drawing themselves. Other platforms still draw, as the compositor can use it,
+and more importantly: drawing to render targets isn't lost. But I still think
+this should probably be removed at some point in the future.  --ryan. */
+#if defined(SDL_PLATFORM_IOS) || defined(SDL_PLATFORM_TVOS) || defined(SDL_PLATFORM_ANDROID)
+#define DONT_DRAW_WHILE_HIDDEN 1
+#else
+#define DONT_DRAW_WHILE_HIDDEN 0
+#endif
+
+#define SDL_PROP_WINDOW_RENDERER_POINTER "SDL.internal.window.renderer"
+#define SDL_PROP_TEXTURE_PARENT_POINTER "SDL.internal.texture.parent"
+
+#define CHECK_RENDERER_MAGIC_BUT_NOT_DESTROYED_FLAG(renderer, result)   \
+    if (!SDL_ObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER)) {         \
+        SDL_InvalidParamError("renderer");                              \
+        return result;                                                  \
+    }
+
+#define CHECK_RENDERER_MAGIC(renderer, result)                  \
+    CHECK_RENDERER_MAGIC_BUT_NOT_DESTROYED_FLAG(renderer, result); \
+    if ((renderer)->destroyed) { \
+        SDL_SetError("Renderer's window has been destroyed, can't use further"); \
+        return result;                                          \
+    }
+
+#define CHECK_TEXTURE_MAGIC(texture, result)                    \
+    if (!SDL_ObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE)) {   \
+        SDL_InvalidParamError("texture");                       \
+        return result;                                          \
+    }
+
+// Predefined blend modes
+#define SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation, \
+                              srcAlphaFactor, dstAlphaFactor, alphaOperation) \
+    (SDL_BlendMode)(((Uint32)(colorOperation) << 0) |                         \
+                    ((Uint32)(srcColorFactor) << 4) |                         \
+                    ((Uint32)(dstColorFactor) << 8) |                         \
+                    ((Uint32)(alphaOperation) << 16) |                        \
+                    ((Uint32)(srcAlphaFactor) << 20) |                        \
+                    ((Uint32)(dstAlphaFactor) << 24))
+
+#define SDL_BLENDMODE_NONE_FULL                                                              \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO, SDL_BLENDOPERATION_ADD)
+
+#define SDL_BLENDMODE_BLEND_FULL                                                                                  \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD)
+
+#define SDL_BLENDMODE_BLEND_PREMULTIPLIED_FULL                                                              \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD)
+
+#define SDL_BLENDMODE_ADD_FULL                                                                    \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)
+
+#define SDL_BLENDMODE_ADD_PREMULTIPLIED_FULL                                                 \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ONE,  SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)
+
+#define SDL_BLENDMODE_MOD_FULL                                                                     \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_COLOR, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)
+
+#define SDL_BLENDMODE_MUL_FULL                                                                                    \
+    SDL_COMPOSE_BLENDMODE(SDL_BLENDFACTOR_DST_COLOR, SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, SDL_BLENDOPERATION_ADD, \
+                          SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_ADD)
+
+#ifndef SDL_RENDER_DISABLED
+static const SDL_RenderDriver *render_drivers[] = {
+#ifdef SDL_VIDEO_RENDER_D3D11
+    &D3D11_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_D3D12
+    &D3D12_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_D3D
+    &D3D_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_METAL
+    &METAL_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_OGL
+    &GL_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_OGL_ES2
+    &GLES2_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_PS2
+    &PS2_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_PSP
+    &PSP_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_VITA_GXM
+    &VITA_GXM_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_VULKAN
+    &VULKAN_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_GPU
+    &GPU_RenderDriver,
+#endif
+#ifdef SDL_VIDEO_RENDER_SW
+    &SW_RenderDriver,
+#endif
+    NULL
+};
+#endif // !SDL_RENDER_DISABLED
+
+static SDL_Renderer *SDL_renderers;
+
+static const int rect_index_order[] = { 0, 1, 2, 0, 2, 3 };
+
+void SDL_QuitRender(void)
+{
+    while (SDL_renderers) {
+        SDL_DestroyRenderer(SDL_renderers);
+    }
+}
+
+bool SDL_AddSupportedTextureFormat(SDL_Renderer *renderer, SDL_PixelFormat format)
+{
+    SDL_PixelFormat *texture_formats = (SDL_PixelFormat *)SDL_realloc((void *)renderer->texture_formats, (renderer->num_texture_formats + 2) * sizeof(SDL_PixelFormat));
+    if (!texture_formats) {
+        return false;
+    }
+    texture_formats[renderer->num_texture_formats++] = format;
+    texture_formats[renderer->num_texture_formats] = SDL_PIXELFORMAT_UNKNOWN;
+    renderer->texture_formats = texture_formats;
+    SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, texture_formats);
+    return true;
+}
+
+void SDL_SetupRendererColorspace(SDL_Renderer *renderer, SDL_PropertiesID props)
+{
+    renderer->output_colorspace = (SDL_Colorspace)SDL_GetNumberProperty(props, SDL_PROP_RENDERER_CREATE_OUTPUT_COLORSPACE_NUMBER, SDL_COLORSPACE_SRGB);
+}
+
+bool SDL_RenderingLinearSpace(SDL_Renderer *renderer)
+{
+    SDL_Colorspace colorspace;
+
+    if (renderer->target) {
+        colorspace = renderer->target->colorspace;
+    } else {
+        colorspace = renderer->output_colorspace;
+    }
+    if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+        return true;
+    }
+    return false;
+}
+
+void SDL_ConvertToLinear(SDL_FColor *color)
+{
+    color->r = SDL_sRGBtoLinear(color->r);
+    color->g = SDL_sRGBtoLinear(color->g);
+    color->b = SDL_sRGBtoLinear(color->b);
+}
+
+void SDL_ConvertFromLinear(SDL_FColor *color)
+{
+    color->r = SDL_sRGBfromLinear(color->r);
+    color->g = SDL_sRGBfromLinear(color->g);
+    color->b = SDL_sRGBfromLinear(color->b);
+}
+
+static SDL_INLINE void DebugLogRenderCommands(const SDL_RenderCommand *cmd)
+{
+#if 0
+    unsigned int i = 1;
+    SDL_Log("Render commands to flush:");
+    while (cmd) {
+        switch (cmd->command) {
+            case SDL_RENDERCMD_NO_OP:
+                SDL_Log(" %u. no-op", i++);
+                break;
+
+            case SDL_RENDERCMD_SETVIEWPORT:
+                SDL_Log(" %u. set viewport (first=%u, rect={(%d, %d), %dx%d})", i++,
+                        (unsigned int) cmd->data.viewport.first,
+                        cmd->data.viewport.rect.x, cmd->data.viewport.rect.y,
+                        cmd->data.viewport.rect.w, cmd->data.viewport.rect.h);
+                break;
+
+            case SDL_RENDERCMD_SETCLIPRECT:
+                SDL_Log(" %u. set cliprect (enabled=%s, rect={(%d, %d), %dx%d})", i++,
+                        cmd->data.cliprect.enabled ? "true" : "false",
+                        cmd->data.cliprect.rect.x, cmd->data.cliprect.rect.y,
+                        cmd->data.cliprect.rect.w, cmd->data.cliprect.rect.h);
+                break;
+
+            case SDL_RENDERCMD_SETDRAWCOLOR:
+                SDL_Log(" %u. set draw color (first=%u, r=%d, g=%d, b=%d, a=%d, color_scale=%g)", i++,
+                        (unsigned int) cmd->data.color.first,
+                        (int) cmd->data.color.color.r, (int) cmd->data.color.color.g,
+                        (int) cmd->data.color.color.b, (int) cmd->data.color.color.a, cmd->data.color.color_scale);
+                break;
+
+            case SDL_RENDERCMD_CLEAR:
+                SDL_Log(" %u. clear (first=%u, r=%d, g=%d, b=%d, a=%d, color_scale=%g)", i++,
+                        (unsigned int) cmd->data.color.first,
+                        (int) cmd->data.color.color.r, (int) cmd->data.color.color.g,
+                        (int) cmd->data.color.color.b, (int) cmd->data.color.color.a, cmd->data.color.color_scale);
+                break;
+
+            case SDL_RENDERCMD_DRAW_POINTS:
+                SDL_Log(" %u. draw points (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g,
+                        (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.color_scale);
+                break;
+
+            case SDL_RENDERCMD_DRAW_LINES:
+                SDL_Log(" %u. draw lines (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g,
+                        (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.color_scale);
+                break;
+
+            case SDL_RENDERCMD_FILL_RECTS:
+                SDL_Log(" %u. fill rects (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g,
+                        (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.color_scale);
+                break;
+
+            case SDL_RENDERCMD_COPY:
+                SDL_Log(" %u. copy (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g, tex=%p)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g,
+                        (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.color_scale, cmd->data.draw.texture);
+                break;
+
+
+            case SDL_RENDERCMD_COPY_EX:
+                SDL_Log(" %u. copyex (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g, tex=%p)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g,
+                        (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.color_scale, cmd->data.draw.texture);
+                break;
+
+            case SDL_RENDERCMD_GEOMETRY:
+                SDL_Log(" %u. geometry (first=%u, count=%u, r=%d, g=%d, b=%d, a=%d, blend=%d, color_scale=%g, tex=%p)", i++,
+                        (unsigned int) cmd->data.draw.first,
+                        (unsigned int) cmd->data.draw.count,
+                        (int) cmd->data.draw.color.r, (int) cmd->data.draw.color.g,
+                        (int) cmd->data.draw.color.b, (int) cmd->data.draw.color.a,
+                        (int) cmd->data.draw.blend, cmd->data.draw.color_scale, cmd->data.draw.texture);
+                break;
+
+        }
+        cmd = cmd->next;
+    }
+#endif
+}
+
+static bool FlushRenderCommands(SDL_Renderer *renderer)
+{
+    bool result;
+
+    SDL_assert((renderer->render_commands == NULL) == (renderer->render_commands_tail == NULL));
+
+    if (!renderer->render_commands) { // nothing to do!
+        SDL_assert(renderer->vertex_data_used == 0);
+        return true;
+    }
+
+    DebugLogRenderCommands(renderer->render_commands);
+
+    result = renderer->RunCommandQueue(renderer, renderer->render_commands, renderer->vertex_data, renderer->vertex_data_used);
+
+    // Move the whole render command queue to the unused pool so we can reuse them next time.
+    if (renderer->render_commands_tail) {
+        renderer->render_commands_tail->next = renderer->render_commands_pool;
+        renderer->render_commands_pool = renderer->render_commands;
+        renderer->render_commands_tail = NULL;
+        renderer->render_commands = NULL;
+    }
+    renderer->vertex_data_used = 0;
+    renderer->render_command_generation++;
+    renderer->color_queued = false;
+    renderer->viewport_queued = false;
+    renderer->cliprect_queued = false;
+    return result;
+}
+
+static bool FlushRenderCommandsIfTextureNeeded(SDL_Texture *texture)
+{
+    SDL_Renderer *renderer = texture->renderer;
+    if (texture->last_command_generation == renderer->render_command_generation) {
+        // the current command queue depends on this texture, flush the queue now before it changes
+        return FlushRenderCommands(renderer);
+    }
+    return true;
+}
+
+bool SDL_FlushRenderer(SDL_Renderer *renderer)
+{
+    if (!FlushRenderCommands(renderer)) {
+        return false;
+    }
+    renderer->InvalidateCachedState(renderer);
+    return true;
+}
+
+void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, size_t numbytes, size_t alignment, size_t *offset)
+{
+    const size_t needed = renderer->vertex_data_used + numbytes + alignment;
+    const size_t current_offset = renderer->vertex_data_used;
+
+    const size_t aligner = (alignment && ((current_offset & (alignment - 1)) != 0)) ? (alignment - (current_offset & (alignment - 1))) : 0;
+    const size_t aligned = current_offset + aligner;
+
+    if (renderer->vertex_data_allocation < needed) {
+        const size_t current_allocation = renderer->vertex_data ? renderer->vertex_data_allocation : 1024;
+        size_t newsize = current_allocation * 2;
+        void *ptr;
+        while (newsize < needed) {
+            newsize *= 2;
+        }
+
+        ptr = SDL_realloc(renderer->vertex_data, newsize);
+
+        if (!ptr) {
+            return NULL;
+        }
+        renderer->vertex_data = ptr;
+        renderer->vertex_data_allocation = newsize;
+    }
+
+    if (offset) {
+        *offset = aligned;
+    }
+
+    renderer->vertex_data_used += aligner + numbytes;
+
+    return ((Uint8 *)renderer->vertex_data) + aligned;
+}
+
+static SDL_RenderCommand *AllocateRenderCommand(SDL_Renderer *renderer)
+{
+    SDL_RenderCommand *result = NULL;
+
+    result = renderer->render_commands_pool;
+    if (result) {
+        renderer->render_commands_pool = result->next;
+        result->next = NULL;
+    } else {
+        result = (SDL_RenderCommand *)SDL_calloc(1, sizeof(*result));
+        if (!result) {
+            return NULL;
+        }
+    }
+
+    SDL_assert((renderer->render_commands == NULL) == (renderer->render_commands_tail == NULL));
+    if (renderer->render_commands_tail) {
+        renderer->render_commands_tail->next = result;
+    } else {
+        renderer->render_commands = result;
+    }
+    renderer->render_commands_tail = result;
+
+    return result;
+}
+
+static void UpdatePixelViewport(SDL_Renderer *renderer, SDL_RenderViewState *view)
+{
+    view->pixel_viewport.x = (int)SDL_floorf((view->viewport.x * view->current_scale.x) + view->logical_offset.x);
+    view->pixel_viewport.y = (int)SDL_floorf((view->viewport.y * view->current_scale.y) + view->logical_offset.y);
+    if (view->viewport.w >= 0) {
+        view->pixel_viewport.w = (int)SDL_ceilf(view->viewport.w * view->current_scale.x);
+    } else {
+        view->pixel_viewport.w = view->pixel_w;
+    }
+    if (view->viewport.h >= 0) {
+        view->pixel_viewport.h = (int)SDL_ceilf(view->viewport.h * view->current_scale.y);
+    } else {
+        view->pixel_viewport.h = view->pixel_h;
+    }
+}
+
+static bool QueueCmdSetViewport(SDL_Renderer *renderer)
+{
+    bool result = true;
+
+    SDL_Rect viewport = renderer->view->pixel_viewport;
+
+    if (!renderer->viewport_queued ||
+        SDL_memcmp(&viewport, &renderer->last_queued_viewport, sizeof(viewport)) != 0) {
+        SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
+        if (cmd) {
+            cmd->command = SDL_RENDERCMD_SETVIEWPORT;
+            cmd->data.viewport.first = 0; // render backend will fill this in.
+            SDL_copyp(&cmd->data.viewport.rect, &viewport);
+            result = renderer->QueueSetViewport(renderer, cmd);
+            if (!result) {
+                cmd->command = SDL_RENDERCMD_NO_OP;
+            } else {
+                SDL_copyp(&renderer->last_queued_viewport, &viewport);
+                renderer->viewport_queued = true;
+            }
+        } else {
+            result = false;
+        }
+    }
+    return result;
+}
+
+static void UpdatePixelClipRect(SDL_Renderer *renderer, SDL_RenderViewState *view)
+{
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+    view->pixel_clip_rect.x = (int)SDL_floorf(view->clip_rect.x * scale_x);
+    view->pixel_clip_rect.y = (int)SDL_floorf(view->clip_rect.y * scale_y);
+    view->pixel_clip_rect.w = (int)SDL_ceilf(view->clip_rect.w * scale_x);
+    view->pixel_clip_rect.h = (int)SDL_ceilf(view->clip_rect.h * scale_y);
+}
+
+static bool QueueCmdSetClipRect(SDL_Renderer *renderer)
+{
+    bool result = true;
+
+    const SDL_RenderViewState *view = renderer->view;
+    SDL_Rect clip_rect = view->pixel_clip_rect;
+    if (!renderer->cliprect_queued ||
+        view->clipping_enabled != renderer->last_queued_cliprect_enabled ||
+        SDL_memcmp(&clip_rect, &renderer->last_queued_cliprect, sizeof(clip_rect)) != 0) {
+        SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
+        if (cmd) {
+            cmd->command = SDL_RENDERCMD_SETCLIPRECT;
+            cmd->data.cliprect.enabled = view->clipping_enabled;
+            SDL_copyp(&cmd->data.cliprect.rect, &clip_rect);
+            SDL_copyp(&renderer->last_queued_cliprect, &clip_rect);
+            renderer->last_queued_cliprect_enabled = view->clipping_enabled;
+            renderer->cliprect_queued = true;
+        } else {
+            result = false;
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdSetDrawColor(SDL_Renderer *renderer, SDL_FColor *color)
+{
+    bool result = true;
+
+    if (!renderer->color_queued ||
+        color->r != renderer->last_queued_color.r ||
+        color->g != renderer->last_queued_color.g ||
+        color->b != renderer->last_queued_color.b ||
+        color->a != renderer->last_queued_color.a) {
+        SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
+        result = false;
+
+        if (cmd) {
+            cmd->command = SDL_RENDERCMD_SETDRAWCOLOR;
+            cmd->data.color.first = 0; // render backend will fill this in.
+            cmd->data.color.color_scale = renderer->color_scale;
+            cmd->data.color.color = *color;
+            result = renderer->QueueSetDrawColor(renderer, cmd);
+            if (!result) {
+                cmd->command = SDL_RENDERCMD_NO_OP;
+            } else {
+                renderer->last_queued_color = *color;
+                renderer->color_queued = true;
+            }
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdClear(SDL_Renderer *renderer)
+{
+    SDL_RenderCommand *cmd = AllocateRenderCommand(renderer);
+    if (!cmd) {
+        return false;
+    }
+
+    cmd->command = SDL_RENDERCMD_CLEAR;
+    cmd->data.color.first = 0;
+    cmd->data.color.color_scale = renderer->color_scale;
+    cmd->data.color.color = renderer->color;
+    return true;
+}
+
+static SDL_RenderCommand *PrepQueueCmdDraw(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype, SDL_Texture *texture)
+{
+    SDL_RenderCommand *cmd = NULL;
+    bool result = true;
+    SDL_FColor *color;
+    SDL_BlendMode blendMode;
+
+    if (texture) {
+        color = &texture->color;
+        blendMode = texture->blendMode;
+    } else {
+        color = &renderer->color;
+        blendMode = renderer->blendMode;
+    }
+
+    if (cmdtype != SDL_RENDERCMD_GEOMETRY) {
+        result = QueueCmdSetDrawColor(renderer, color);
+    }
+
+    /* Set the viewport and clip rect directly before draws, so the backends
+     * don't have to worry about that state not being valid at draw time. */
+    if (result && !renderer->viewport_queued) {
+        result = QueueCmdSetViewport(renderer);
+    }
+    if (result && !renderer->cliprect_queued) {
+        result = QueueCmdSetClipRect(renderer);
+    }
+
+    if (result) {
+        cmd = AllocateRenderCommand(renderer);
+        if (cmd) {
+            cmd->command = cmdtype;
+            cmd->data.draw.first = 0; // render backend will fill this in.
+            cmd->data.draw.count = 0; // render backend will fill this in.
+            cmd->data.draw.color_scale = renderer->color_scale;
+            cmd->data.draw.color = *color;
+            cmd->data.draw.blend = blendMode;
+            cmd->data.draw.texture = texture;
+            cmd->data.draw.texture_address_mode = SDL_TEXTURE_ADDRESS_CLAMP;
+        }
+    }
+    return cmd;
+}
+
+static bool QueueCmdDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
+{
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_DRAW_POINTS, NULL);
+    bool result = false;
+    if (cmd) {
+        result = renderer->QueueDrawPoints(renderer, cmd, points, count);
+        if (!result) {
+            cmd->command = SDL_RENDERCMD_NO_OP;
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
+{
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_DRAW_LINES, NULL);
+    bool result = false;
+    if (cmd) {
+        result = renderer->QueueDrawLines(renderer, cmd, points, count);
+        if (!result) {
+            cmd->command = SDL_RENDERCMD_NO_OP;
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, const int count)
+{
+    SDL_RenderCommand *cmd;
+    bool result = false;
+    const int use_rendergeometry = (!renderer->QueueFillRects);
+
+    cmd = PrepQueueCmdDraw(renderer, (use_rendergeometry ? SDL_RENDERCMD_GEOMETRY : SDL_RENDERCMD_FILL_RECTS), NULL);
+
+    if (cmd) {
+        if (use_rendergeometry) {
+            bool isstack1;
+            bool isstack2;
+            float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1);
+            int *indices = SDL_small_alloc(int, 6 * count, &isstack2);
+
+            if (xy && indices) {
+                int i;
+                float *ptr_xy = xy;
+                int *ptr_indices = indices;
+                const int xy_stride = 2 * sizeof(float);
+                const int num_vertices = 4 * count;
+                const int num_indices = 6 * count;
+                const int size_indices = 4;
+                int cur_index = 0;
+
+                for (i = 0; i < count; ++i) {
+                    float minx, miny, maxx, maxy;
+
+                    minx = rects[i].x;
+                    miny = rects[i].y;
+                    maxx = rects[i].x + rects[i].w;
+                    maxy = rects[i].y + rects[i].h;
+
+                    *ptr_xy++ = minx;
+                    *ptr_xy++ = miny;
+                    *ptr_xy++ = maxx;
+                    *ptr_xy++ = miny;
+                    *ptr_xy++ = maxx;
+                    *ptr_xy++ = maxy;
+                    *ptr_xy++ = minx;
+                    *ptr_xy++ = maxy;
+
+                    *ptr_indices++ = cur_index + rect_index_order[0];
+                    *ptr_indices++ = cur_index + rect_index_order[1];
+                    *ptr_indices++ = cur_index + rect_index_order[2];
+                    *ptr_indices++ = cur_index + rect_index_order[3];
+                    *ptr_indices++ = cur_index + rect_index_order[4];
+                    *ptr_indices++ = cur_index + rect_index_order[5];
+                    cur_index += 4;
+                }
+
+                result = renderer->QueueGeometry(renderer, cmd, NULL,
+                                                 xy, xy_stride, &renderer->color, 0 /* color_stride */, NULL, 0,
+                                                 num_vertices, indices, num_indices, size_indices,
+                                                 1.0f, 1.0f);
+
+                if (!result) {
+                    cmd->command = SDL_RENDERCMD_NO_OP;
+                }
+            }
+            SDL_small_free(xy, isstack1);
+            SDL_small_free(indices, isstack2);
+
+        } else {
+            result = renderer->QueueFillRects(renderer, cmd, rects, count);
+            if (!result) {
+                cmd->command = SDL_RENDERCMD_NO_OP;
+            }
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect)
+{
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_COPY, texture);
+    bool result = false;
+    if (cmd) {
+        result = renderer->QueueCopy(renderer, cmd, texture, srcrect, dstrect);
+        if (!result) {
+            cmd->command = SDL_RENDERCMD_NO_OP;
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdCopyEx(SDL_Renderer *renderer, SDL_Texture *texture,
+                          const SDL_FRect *srcquad, const SDL_FRect *dstrect,
+                          const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y)
+{
+    SDL_RenderCommand *cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_COPY_EX, texture);
+    bool result = false;
+    if (cmd) {
+        result = renderer->QueueCopyEx(renderer, cmd, texture, srcquad, dstrect, angle, center, flip, scale_x, scale_y);
+        if (!result) {
+            cmd->command = SDL_RENDERCMD_NO_OP;
+        }
+    }
+    return result;
+}
+
+static bool QueueCmdGeometry(SDL_Renderer *renderer, SDL_Texture *texture,
+                            const float *xy, int xy_stride,
+                            const SDL_FColor *color, int color_stride,
+                            const float *uv, int uv_stride,
+                            int num_vertices,
+                            const void *indices, int num_indices, int size_indices,
+                            float scale_x, float scale_y, SDL_TextureAddressMode texture_address_mode)
+{
+    SDL_RenderCommand *cmd;
+    bool result = false;
+    cmd = PrepQueueCmdDraw(renderer, SDL_RENDERCMD_GEOMETRY, texture);
+    if (cmd) {
+        cmd->data.draw.texture_address_mode = texture_address_mode;
+        result = renderer->QueueGeometry(renderer, cmd, texture,
+                                         xy, xy_stride,
+                                         color, color_stride, uv, uv_stride,
+                                         num_vertices, indices, num_indices, size_indices,
+                                         scale_x, scale_y);
+        if (!result) {
+            cmd->command = SDL_RENDERCMD_NO_OP;
+        }
+    }
+    return result;
+}
+
+static void UpdateMainViewDimensions(SDL_Renderer *renderer)
+{
+    int window_w = 0, window_h = 0;
+
+    if (renderer->window) {
+        SDL_GetWindowSize(renderer->window, &window_w, &window_h);
+    }
+
+    SDL_GetRenderOutputSize(renderer, &renderer->main_view.pixel_w, &renderer->main_view.pixel_h);
+
+    if (window_w > 0 && window_h > 0) {
+        renderer->dpi_scale.x = (float)renderer->main_view.pixel_w / window_w;
+        renderer->dpi_scale.y = (float)renderer->main_view.pixel_h / window_h;
+    } else {
+        renderer->dpi_scale.x = 1.0f;
+        renderer->dpi_scale.y = 1.0f;
+    }
+    UpdatePixelViewport(renderer, &renderer->main_view);
+}
+
+static void UpdateColorScale(SDL_Renderer *renderer)
+{
+    float SDR_white_point;
+    if (renderer->target) {
+        SDR_white_point = renderer->target->SDR_white_point;
+    } else {
+        SDR_white_point = renderer->SDR_white_point;
+    }
+    renderer->color_scale = renderer->desired_color_scale * SDR_white_point;
+}
+
+static void UpdateHDRProperties(SDL_Renderer *renderer)
+{
+    SDL_PropertiesID window_props;
+    SDL_PropertiesID renderer_props;
+
+    window_props = SDL_GetWindowProperties(renderer->window);
+    if (!window_props) {
+        return;
+    }
+
+    renderer_props = SDL_GetRendererProperties(renderer);
+    if (!renderer_props) {
+        return;
+    }
+
+    if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+        renderer->SDR_white_point = SDL_GetFloatProperty(window_props, SDL_PROP_WINDOW_SDR_WHITE_LEVEL_FLOAT, 1.0f);
+        renderer->HDR_headroom = SDL_GetFloatProperty(window_props, SDL_PROP_WINDOW_HDR_HEADROOM_FLOAT, 1.0f);
+    } else {
+        renderer->SDR_white_point = 1.0f;
+        renderer->HDR_headroom = 1.0f;
+    }
+
+    if (renderer->HDR_headroom > 1.0f) {
+        SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, true);
+    } else {
+        SDL_SetBooleanProperty(renderer_props, SDL_PROP_RENDERER_HDR_ENABLED_BOOLEAN, false);
+    }
+    SDL_SetFloatProperty(renderer_props, SDL_PROP_RENDERER_SDR_WHITE_POINT_FLOAT, renderer->SDR_white_point);
+    SDL_SetFloatProperty(renderer_props, SDL_PROP_RENDERER_HDR_HEADROOM_FLOAT, renderer->HDR_headroom);
+
+    UpdateColorScale(renderer);
+}
+
+static void UpdateLogicalPresentation(SDL_Renderer *renderer);
+
+
+int SDL_GetNumRenderDrivers(void)
+{
+#ifndef SDL_RENDER_DISABLED
+    return SDL_arraysize(render_drivers) - 1;
+#else
+    return 0;
+#endif
+}
+
+const char *SDL_GetRenderDriver(int index)
+{
+#ifndef SDL_RENDER_DISABLED
+    if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
+        SDL_InvalidParamError("index");
+        return NULL;
+    }
+    return render_drivers[index]->name;
+#else
+    SDL_SetError("SDL not built with rendering support");
+    return NULL;
+#endif
+}
+
+static bool SDL_RendererEventWatch(void *userdata, SDL_Event *event)
+{
+    SDL_Renderer *renderer = (SDL_Renderer *)userdata;
+    SDL_Window *window = renderer->window;
+
+    if (renderer->WindowEvent) {
+        renderer->WindowEvent(renderer, &event->window);
+    }
+
+    if (event->type == SDL_EVENT_WINDOW_RESIZED ||
+        event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED ||
+        event->type == SDL_EVENT_WINDOW_METAL_VIEW_RESIZED) {
+            SDL_RenderViewState *view = renderer->view;
+            renderer->view = &renderer->main_view;  // only update the main_view (the window framebuffer) for window changes.
+            UpdateLogicalPresentation(renderer);
+            renderer->view = view;  // put us back on whatever the current render target's actual view is.
+    } else if (event->type == SDL_EVENT_WINDOW_HIDDEN) {
+        renderer->hidden = true;
+    } else if (event->type == SDL_EVENT_WINDOW_SHOWN) {
+        if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) {
+            renderer->hidden = false;
+        }
+    } else if (event->type == SDL_EVENT_WINDOW_MINIMIZED) {
+        renderer->hidden = true;
+    } else if (event->type == SDL_EVENT_WINDOW_RESTORED ||
+               event->type == SDL_EVENT_WINDOW_MAXIMIZED) {
+        if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
+            renderer->hidden = false;
+        }
+    } else if (event->type == SDL_EVENT_WINDOW_DISPLAY_CHANGED ||
+               event->type == SDL_EVENT_WINDOW_HDR_STATE_CHANGED) {
+        UpdateHDRProperties(renderer);
+    }
+    return true;
+}
+
+bool SDL_CreateWindowAndRenderer(const char *title, int width, int height, SDL_WindowFlags window_flags, SDL_Window **window, SDL_Renderer **renderer)
+{
+    bool hidden = (window_flags & SDL_WINDOW_HIDDEN) != 0;
+
+    if (!window) {
+        return SDL_InvalidParamError("window");
+    }
+
+    if (!renderer) {
+        return SDL_InvalidParamError("renderer");
+    }
+
+    // Hide the window so if the renderer recreates it, we don't get a visual flash on screen
+    window_flags |= SDL_WINDOW_HIDDEN;
+    *window = SDL_CreateWindow(title, width, height, window_flags);
+    if (!*window) {
+        *renderer = NULL;
+        return false;
+    }
+
+    *renderer = SDL_CreateRenderer(*window, NULL);
+    if (!*renderer) {
+        SDL_DestroyWindow(*window);
+        *window = NULL;
+        return false;
+    }
+
+    if (!hidden) {
+        SDL_ShowWindow(*window);
+    }
+
+    return true;
+}
+
+#ifndef SDL_RENDER_DISABLED
+static SDL_INLINE void VerifyDrawQueueFunctions(const SDL_Renderer *renderer)
+{
+    /* all of these functions are required to be implemented, even as no-ops, so we don't
+        have to check that they aren't NULL over and over. */
+    SDL_assert(renderer->QueueSetViewport != NULL);
+    SDL_assert(renderer->QueueSetDrawColor != NULL);
+    SDL_assert(renderer->QueueDrawPoints != NULL);
+    SDL_assert(renderer->QueueDrawLines != NULL || renderer->QueueGeometry != NULL);
+    SDL_assert(renderer->QueueFillRects != NULL || renderer->QueueGeometry != NULL);
+    SDL_assert(renderer->QueueCopy != NULL || renderer->QueueGeometry != NULL);
+    SDL_assert(renderer->RunCommandQueue != NULL);
+}
+
+static SDL_RenderLineMethod SDL_GetRenderLineMethod(void)
+{
+    const char *hint = SDL_GetHint(SDL_HINT_RENDER_LINE_METHOD);
+
+    int method = 0;
+    if (hint) {
+        method = SDL_atoi(hint);
+    }
+    switch (method) {
+    case 1:
+        return SDL_RENDERLINEMETHOD_POINTS;
+    case 2:
+        return SDL_RENDERLINEMETHOD_LINES;
+    case 3:
+        return SDL_RENDERLINEMETHOD_GEOMETRY;
+    default:
+        return SDL_RENDERLINEMETHOD_POINTS;
+    }
+}
+
+static void SDL_CalculateSimulatedVSyncInterval(SDL_Renderer *renderer, SDL_Window *window)
+{
+    SDL_DisplayID displayID = SDL_GetDisplayForWindow(window);
+    const SDL_DisplayMode *mode;
+    int refresh_num, refresh_den;
+
+    if (displayID == 0) {
+        displayID = SDL_GetPrimaryDisplay();
+    }
+    mode = SDL_GetDesktopDisplayMode(displayID);
+    if (mode && mode->refresh_rate_numerator > 0 && mode->refresh_rate_denominator > 0) {
+        refresh_num = mode->refresh_rate_numerator;
+        refresh_den = mode->refresh_rate_denominator;
+    } else {
+        // Pick a good default refresh rate
+        refresh_num = 60;
+        refresh_den = 1;
+    }
+    // Flip numerator and denominator to change from framerate to interval
+    renderer->simulate_vsync_interval_ns = (SDL_NS_PER_SECOND * refresh_den) / refresh_num;
+}
+
+#endif // !SDL_RENDER_DISABLED
+
+
+SDL_Renderer *SDL_CreateRendererWithProperties(SDL_PropertiesID props)
+{
+#ifndef SDL_RENDER_DISABLED
+    SDL_Window *window = (SDL_Window *)SDL_GetPointerProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, NULL);
+    SDL_Surface *surface = (SDL_Surface *)SDL_GetPointerProperty(props, SDL_PROP_RENDERER_CREATE_SURFACE_POINTER, NULL);
+    const char *driver_name = SDL_GetStringProperty(props, SDL_PROP_RENDERER_CREATE_NAME_STRING, NULL);
+    const char *hint;
+    SDL_PropertiesID new_props;
+
+#ifdef SDL_PLATFORM_ANDROID
+    if (!Android_WaitActiveAndLockActivity()) {
+        return NULL;
+    }
+#endif
+
+    SDL_Renderer *renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(*renderer));
+    if (!renderer) {
+        goto error;
+    }
+
+    SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, true);
+
+    if ((!window && !surface) || (window && surface)) {
+        SDL_InvalidParamError("window");
+        goto error;
+    }
+
+    if (window && SDL_WindowHasSurface(window)) {
+        SDL_SetError("Surface already associated with window");
+        goto error;
+    }
+
+    if (window && SDL_GetRenderer(window)) {
+        SDL_SetError("Renderer already associated with window");
+        goto error;
+    }
+
+    hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
+    if (hint && *hint) {
+        SDL_SetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, true));
+    }
+
+    if (surface) {
+#ifdef SDL_VIDEO_RENDER_SW
+        const bool rc = SW_CreateRendererForSurface(renderer, surface, props);
+#else
+        const bool rc = SDL_SetError("SDL not built with software renderer");
+#endif
+        if (!rc) {
+            goto error;
+        }
+    } else {
+        bool rc = false;
+        if (!driver_name) {
+            driver_name = SDL_GetHint(SDL_HINT_RENDER_DRIVER);
+        }
+
+        if (driver_name && *driver_name != 0) {
+            const char *driver_attempt = driver_name;
+            while (driver_attempt && *driver_attempt != 0 && !rc) {
+                const char *driver_attempt_end = SDL_strchr(driver_attempt, ',');
+                const size_t driver_attempt_len = (driver_attempt_end) ? (driver_attempt_end - driver_attempt) : SDL_strlen(driver_attempt);
+
+                for (int i = 0; render_drivers[i]; i++) {
+                    const SDL_RenderDriver *driver = render_drivers[i];
+                    if ((driver_attempt_len == SDL_strlen(driver->name)) && (SDL_strncasecmp(driver->name, driver_attempt, driver_attempt_len) == 0)) {
+                        rc = driver->CreateRenderer(renderer, window, props);
+                        if (rc) {
+                            break;
+                        }
+                    }
+                }
+
+                driver_attempt = (driver_attempt_end) ? (driver_attempt_end + 1) : NULL;
+            }
+        } else {
+            for (int i = 0; render_drivers[i]; i++) {
+                const SDL_RenderDriver *driver = render_drivers[i];
+                rc = driver->CreateRenderer(renderer, window, props);
+                if (rc) {
+                    break;
+                }
+                SDL_DestroyRendererWithoutFreeing(renderer);
+                SDL_zerop(renderer);  // make sure we don't leave function pointers from a previous CreateRenderer() in this struct.
+            }
+        }
+
+        if (!rc) {
+            if (driver_name) {
+                SDL_SetError("%s not available", driver_name);
+            } else {
+                SDL_SetError("Couldn't find matching render driver");
+            }
+            goto error;
+        }
+    }
+
+    VerifyDrawQueueFunctions(renderer);
+
+    renderer->window = window;
+    renderer->target_mutex = SDL_CreateMutex();
+    if (surface) {
+        renderer->main_view.pixel_w = surface->w;
+        renderer->main_view.pixel_h = surface->h;
+    }
+    renderer->main_view.viewport.w = -1;
+    renderer->main_view.viewport.h = -1;
+    renderer->main_view.scale.x = 1.0f;
+    renderer->main_view.scale.y = 1.0f;
+    renderer->main_view.logical_scale.x = 1.0f;
+    renderer->main_view.logical_scale.y = 1.0f;
+    renderer->main_view.current_scale.x = 1.0f;
+    renderer->main_view.current_scale.y = 1.0f;
+    renderer->view = &renderer->main_view;
+    renderer->dpi_scale.x = 1.0f;
+    renderer->dpi_scale.y = 1.0f;
+    UpdatePixelViewport(renderer, &renderer->main_view);
+    UpdatePixelClipRect(renderer, &renderer->main_view);
+    UpdateMainViewDimensions(renderer);
+
+    // new textures start at zero, so we start at 1 so first render doesn't flush by accident.
+    renderer->render_command_generation = 1;
+
+    if (renderer->software) {
+        // Software renderer always uses line method, for speed
+        renderer->line_method = SDL_RENDERLINEMETHOD_LINES;
+    } else {
+        renderer->line_method = SDL_GetRenderLineMethod();
+    }
+
+    renderer->SDR_white_point = 1.0f;
+    renderer->HDR_headroom = 1.0f;
+    renderer->desired_color_scale = 1.0f;
+    renderer->color_scale = 1.0f;
+
+    if (window) {
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_TRANSPARENT) {
+            renderer->transparent_window = true;
+        }
+
+        if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN | SDL_WINDOW_MINIMIZED)) {
+            renderer->hidden = true;
+        }
+    }
+
+    new_props = SDL_GetRendererProperties(renderer);
+    SDL_SetStringProperty(new_props, SDL_PROP_RENDERER_NAME_STRING, renderer->name);
+    if (window) {
+        SDL_SetPointerProperty(new_props, SDL_PROP_RENDERER_WINDOW_POINTER, window);
+    }
+    if (surface) {
+        SDL_SetPointerProperty(new_props, SDL_PROP_RENDERER_SURFACE_POINTER, surface);
+    }
+    SDL_SetNumberProperty(new_props, SDL_PROP_RENDERER_OUTPUT_COLORSPACE_NUMBER, renderer->output_colorspace);
+    UpdateHDRProperties(renderer);
+
+    if (window) {
+        SDL_SetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_RENDERER_POINTER, renderer);
+        SDL_AddWindowRenderer(window, renderer);
+    }
+
+    SDL_SetRenderViewport(renderer, NULL);
+
+    if (window) {
+        SDL_AddWindowEventWatch(SDL_WINDOW_EVENT_WATCH_NORMAL, SDL_RendererEventWatch, renderer);
+    }
+
+    int vsync = (int)SDL_GetNumberProperty(props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0);
+    if (!SDL_SetRenderVSync(renderer, vsync)) {
+        if (vsync == 0) {
+            // Some renderers require vsync enabled
+            SDL_SetRenderVSync(renderer, 1);
+        }
+    }
+    SDL_CalculateSimulatedVSyncInterval(renderer, window);
+
+    SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,
+                "Created renderer: %s", renderer->name);
+
+    renderer->next = SDL_renderers;
+    SDL_renderers = renderer;
+
+#ifdef SDL_PLATFORM_ANDROID
+    Android_UnlockActivityMutex();
+#endif
+
+    SDL_ClearError();
+
+    return renderer;
+
+error:
+#ifdef SDL_PLATFORM_ANDROID
+    Android_UnlockActivityMutex();
+#endif
+
+    if (renderer) {
+        SDL_DestroyRenderer(renderer);
+    }
+    return NULL;
+
+#else
+    SDL_SetError("SDL not built with rendering support");
+    return NULL;
+#endif
+}
+
+SDL_Renderer *SDL_CreateRenderer(SDL_Window *window, const char *name)
+{
+    SDL_Renderer *renderer;
+    SDL_PropertiesID props = SDL_CreateProperties();
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window);
+    SDL_SetStringProperty(props, SDL_PROP_RENDERER_CREATE_NAME_STRING, name);
+    renderer = SDL_CreateRendererWithProperties(props);
+    SDL_DestroyProperties(props);
+    return renderer;
+}
+
+SDL_Renderer *SDL_CreateSoftwareRenderer(SDL_Surface *surface)
+{
+#ifdef SDL_VIDEO_RENDER_SW
+    SDL_Renderer *renderer;
+
+    if (!surface) {
+        SDL_InvalidParamError("surface");
+        return NULL;
+    }
+
+    SDL_PropertiesID props = SDL_CreateProperties();
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_CREATE_SURFACE_POINTER, surface);
+    renderer = SDL_CreateRendererWithProperties(props);
+    SDL_DestroyProperties(props);
+    return renderer;
+#else
+    SDL_SetError("SDL not built with rendering support");
+    return NULL;
+#endif // !SDL_RENDER_DISABLED
+}
+
+SDL_Renderer *SDL_GetRenderer(SDL_Window *window)
+{
+    return (SDL_Renderer *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_RENDERER_POINTER, NULL);
+}
+
+SDL_Window *SDL_GetRenderWindow(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+    return renderer->window;
+}
+
+const char *SDL_GetRendererName(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
+    return SDL_GetPersistentString(renderer->name);
+}
+
+SDL_PropertiesID SDL_GetRendererProperties(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, 0);
+
+    if (renderer->props == 0) {
+        renderer->props = SDL_CreateProperties();
+    }
+    return renderer->props;
+}
+
+bool SDL_GetRenderOutputSize(SDL_Renderer *renderer, int *w, int *h)
+{
+    if (w) {
+        *w = 0;
+    }
+    if (h) {
+        *h = 0;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (renderer->GetOutputSize) {
+        return renderer->GetOutputSize(renderer, w, h);
+    } else if (renderer->window) {
+        return SDL_GetWindowSizeInPixels(renderer->window, w, h);
+    } else {
+        SDL_assert(!"This should never happen");
+        return SDL_SetError("Renderer doesn't support querying output size");
+    }
+}
+
+bool SDL_GetCurrentRenderOutputSize(SDL_Renderer *renderer, int *w, int *h)
+{
+    if (w) {
+        *w = 0;
+    }
+    if (h) {
+        *h = 0;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    const SDL_RenderViewState *view = renderer->view;
+    if (w) {
+        *w = view->pixel_w;
+    }
+    if (h) {
+        *h = view->pixel_h;
+    }
+    return true;
+}
+
+static bool IsSupportedBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    switch (blendMode) {
+    // These are required to be supported by all renderers
+    case SDL_BLENDMODE_NONE:
+    case SDL_BLENDMODE_BLEND:
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+    case SDL_BLENDMODE_MOD:
+    case SDL_BLENDMODE_MUL:
+        return true;
+
+    default:
+        return renderer->SupportsBlendMode && renderer->SupportsBlendMode(renderer, blendMode);
+    }
+}
+
+static bool IsSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format)
+{
+    int i;
+
+    for (i = 0; i < renderer->num_texture_formats; ++i) {
+        if (renderer->texture_formats[i] == format) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static SDL_PixelFormat GetClosestSupportedFormat(SDL_Renderer *renderer, SDL_PixelFormat format)
+{
+    int i;
+
+    if (format == SDL_PIXELFORMAT_MJPG) {
+        // We'll decode to SDL_PIXELFORMAT_NV12 or SDL_PIXELFORMAT_RGBA32
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (renderer->texture_formats[i] == SDL_PIXELFORMAT_NV12) {
+                return renderer->texture_formats[i];
+            }
+        }
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (renderer->texture_formats[i] == SDL_PIXELFORMAT_RGBA32) {
+                return renderer->texture_formats[i];
+            }
+        }
+    } else if (SDL_ISPIXELFORMAT_FOURCC(format)) {
+        // Look for an exact match
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (renderer->texture_formats[i] == format) {
+                return renderer->texture_formats[i];
+            }
+        }
+    } else if (SDL_ISPIXELFORMAT_10BIT(format) || SDL_ISPIXELFORMAT_FLOAT(format)) {
+        if (SDL_ISPIXELFORMAT_10BIT(format)) {
+            for (i = 0; i < renderer->num_texture_formats; ++i) {
+                if (SDL_ISPIXELFORMAT_10BIT(renderer->texture_formats[i])) {
+                    return renderer->texture_formats[i];
+                }
+            }
+        }
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (SDL_ISPIXELFORMAT_FLOAT(renderer->texture_formats[i])) {
+                return renderer->texture_formats[i];
+            }
+        }
+    } else {
+        bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);
+
+        // We just want to match the first format that has the same channels
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->texture_formats[i]) &&
+                SDL_ISPIXELFORMAT_ALPHA(renderer->texture_formats[i]) == hasAlpha) {
+                return renderer->texture_formats[i];
+            }
+        }
+    }
+    return renderer->texture_formats[0];
+}
+
+SDL_Texture *SDL_CreateTextureWithProperties(SDL_Renderer *renderer, SDL_PropertiesID props)
+{
+    SDL_Texture *texture;
+    SDL_PixelFormat format = (SDL_PixelFormat)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, SDL_PIXELFORMAT_UNKNOWN);
+    SDL_TextureAccess access = (SDL_TextureAccess)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, SDL_TEXTUREACCESS_STATIC);
+    int w = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, 0);
+    int h = (int)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, 0);
+    SDL_Colorspace default_colorspace;
+    bool texture_is_fourcc_and_target;
+
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
+    if (!format) {
+        format = renderer->texture_formats[0];
+    }
+    if (SDL_BYTESPERPIXEL(format) == 0) {
+        SDL_SetError("Invalid texture format");
+        return NULL;
+    }
+    if (SDL_ISPIXELFORMAT_INDEXED(format)) {
+        if (!IsSupportedFormat(renderer, format)) {
+            SDL_SetError("Palettized textures are not supported");
+            return NULL;
+        }
+    }
+    if (w <= 0 || h <= 0) {
+        SDL_SetError("Texture dimensions can't be 0");
+        return NULL;
+    }
+    int max_texture_size = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 0);
+    if (max_texture_size && (w > max_texture_size || h > max_texture_size)) {
+        SDL_SetError("Texture dimensions are limited to %dx%d", max_texture_size, max_texture_size);
+        return NULL;
+    }
+
+    default_colorspace = SDL_GetDefaultColorspaceForFormat(format);
+
+    texture = (SDL_Texture *)SDL_calloc(1, sizeof(*texture));
+    if (!texture) {
+        return NULL;
+    }
+    texture->refcount = 1;
+    SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, true);
+    texture->colorspace = (SDL_Colorspace)SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, default_colorspace);
+    texture->format = format;
+    texture->access = access;
+    texture->w = w;
+    texture->h = h;
+    texture->color.r = 1.0f;
+    texture->color.g = 1.0f;
+    texture->color.b = 1.0f;
+    texture->color.a = 1.0f;
+    texture->blendMode = SDL_ISPIXELFORMAT_ALPHA(format) ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE;
+    texture->scaleMode = SDL_SCALEMODE_LINEAR;
+    texture->view.pixel_w = w;
+    texture->view.pixel_h = h;
+    texture->view.viewport.w = -1;
+    texture->view.viewport.h = -1;
+    texture->view.scale.x = 1.0f;
+    texture->view.scale.y = 1.0f;
+    texture->view.logical_scale.x = 1.0f;
+    texture->view.logical_scale.y = 1.0f;
+    texture->view.current_scale.x = 1.0f;
+    texture->view.current_scale.y = 1.0f;
+    texture->renderer = renderer;
+    texture->next = renderer->textures;
+    if (renderer->textures) {
+        renderer->textures->prev = texture;
+    }
+    renderer->textures = texture;
+
+    UpdatePixelViewport(renderer, &texture->view);
+    UpdatePixelClipRect(renderer, &texture->view);
+
+    texture->SDR_white_point = SDL_GetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT, SDL_GetDefaultSDRWhitePoint(texture->colorspace));
+    texture->HDR_headroom = SDL_GetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT, SDL_GetDefaultHDRHeadroom(texture->colorspace));
+
+    // FOURCC format cannot be used directly by renderer back-ends for target texture
+    texture_is_fourcc_and_target = (access == SDL_TEXTUREACCESS_TARGET && SDL_ISPIXELFORMAT_FOURCC(format));
+
+    if (!texture_is_fourcc_and_target && IsSupportedFormat(renderer, format)) {
+        if (!renderer->CreateTexture(renderer, texture, props)) {
+            SDL_DestroyTexture(texture);
+            return NULL;
+        }
+    } else {
+        SDL_PixelFormat closest_format;
+        SDL_PropertiesID native_props = SDL_CreateProperties();
+
+        if (!texture_is_fourcc_and_target) {
+            closest_format = GetClosestSupportedFormat(renderer, format);
+        } else {
+            closest_format = renderer->texture_formats[0];
+        }
+
+        if (format == SDL_PIXELFORMAT_MJPG && closest_format == SDL_PIXELFORMAT_NV12) {
+            SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, SDL_COLORSPACE_JPEG);
+        } else {
+            default_colorspace = SDL_GetDefaultColorspaceForFormat(closest_format);
+            if (SDL_COLORSPACETYPE(texture->colorspace) == SDL_COLORSPACETYPE(default_colorspace)) {
+                SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, texture->colorspace);
+            } else {
+                SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, default_colorspace);
+            }
+        }
+        SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, closest_format);
+        SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, texture->access);
+        SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, texture->w);
+        SDL_SetNumberProperty(native_props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, texture->h);
+
+        texture->native = SDL_CreateTextureWithProperties(renderer, native_props);
+        SDL_DestroyProperties(native_props);
+        if (!texture->native) {
+            SDL_DestroyTexture(texture);
+            return NULL;
+        }
+
+        SDL_SetPointerProperty(SDL_GetTextureProperties(texture->native), SDL_PROP_TEXTURE_PARENT_POINTER, texture);
+
+        // Swap textures to have texture before texture->native in the list
+        texture->native->next = texture->next;
+        if (texture->native->next) {
+            texture->native->next->prev = texture->native;
+        }
+        texture->prev = texture->native->prev;
+        if (texture->prev) {
+            texture->prev->next = texture;
+        }
+        texture->native->prev = texture;
+        texture->next = texture->native;
+        renderer->textures = texture;
+
+        if (texture->format == SDL_PIXELFORMAT_MJPG) {
+            // We have a custom decode + upload path for this
+        } else if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
+#ifdef SDL_HAVE_YUV
+            texture->yuv = SDL_SW_CreateYUVTexture(texture->format, texture->colorspace, w, h);
+#else
+            SDL_SetError("SDL not built with YUV support");
+#endif
+            if (!texture->yuv) {
+                SDL_DestroyTexture(texture);
+                return NULL;
+            }
+        } else if (access == SDL_TEXTUREACCESS_STREAMING) {
+            // The pitch is 4 byte aligned
+            texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);
+            texture->pixels = SDL_calloc(1, (size_t)texture->pitch * h);
+            if (!texture->pixels) {
+                SDL_DestroyTexture(texture);
+                return NULL;
+            }
+        }
+    }
+
+    // Now set the properties for the new texture
+    props = SDL_GetTextureProperties(texture);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_COLORSPACE_NUMBER, texture->colorspace);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_FORMAT_NUMBER, texture->format);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, texture->access);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_WIDTH_NUMBER, texture->w);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_HEIGHT_NUMBER, texture->h);
+    SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_SDR_WHITE_POINT_FLOAT, texture->SDR_white_point);
+    if (texture->HDR_headroom > 0.0f) {
+        SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_HDR_HEADROOM_FLOAT, texture->HDR_headroom);
+    }
+    return texture;
+}
+
+SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer, SDL_PixelFormat format, SDL_TextureAccess access, int w, int h)
+{
+    SDL_Texture *texture;
+    SDL_PropertiesID props = SDL_CreateProperties();
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, format);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, access);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, w);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, h);
+    texture = SDL_CreateTextureWithProperties(renderer, props);
+    SDL_DestroyProperties(props);
+    return texture;
+}
+
+static bool SDL_UpdateTextureFromSurface(SDL_Texture *texture, SDL_Rect *rect, SDL_Surface *surface)
+{
+    SDL_TextureAccess access;
+    bool direct_update;
+    SDL_PixelFormat tex_format;
+    SDL_PropertiesID surface_props;
+    SDL_PropertiesID tex_props;
+    SDL_Colorspace surface_colorspace = SDL_COLORSPACE_UNKNOWN;
+    SDL_Colorspace texture_colorspace = SDL_COLORSPACE_UNKNOWN;
+
+    if (texture == NULL || surface == NULL) {
+        return false;
+    }
+
+    tex_props = SDL_GetTextureProperties(texture);
+    if (!tex_props) {
+        return false;
+    }
+
+    surface_props = SDL_GetSurfaceProperties(surface);
+    if (!surface_props) {
+        return false;
+    }
+
+    tex_format = (SDL_PixelFormat)SDL_GetNumberProperty(tex_props, SDL_PROP_TEXTURE_FORMAT_NUMBER, 0);
+    access = (SDL_TextureAccess)SDL_GetNumberProperty(tex_props, SDL_PROP_TEXTURE_ACCESS_NUMBER, 0);
+
+    if (access != SDL_TEXTUREACCESS_STATIC && access != SDL_TEXTUREACCESS_STREAMING) {
+        return false;
+    }
+
+    surface_colorspace = SDL_GetSurfaceColorspace(surface);
+    texture_colorspace = surface_colorspace;
+
+    if (surface_colorspace == SDL_COLORSPACE_SRGB_LINEAR ||
+        SDL_COLORSPACETRANSFER(surface_colorspace) == SDL_TRANSFER_CHARACTERISTICS_PQ) {
+        if (SDL_ISPIXELFORMAT_FLOAT(tex_format)) {
+            texture_colorspace = SDL_COLORSPACE_SRGB_LINEAR;
+        } else if (SDL_ISPIXELFORMAT_10BIT(tex_format)) {
+            texture_colorspace = SDL_COLORSPACE_HDR10;
+        } else {
+            texture_colorspace = SDL_COLORSPACE_SRGB;
+        }
+    }
+
+    if (tex_format == surface->format && texture_colorspace == surface_colorspace) {
+        if (SDL_ISPIXELFORMAT_ALPHA(surface->format) && SDL_SurfaceHasColorKey(surface)) {
+            /* Surface and Renderer formats are identical.
+             * Intermediate conversion is needed to convert color key to alpha (SDL_ConvertColorkeyToAlpha()). */
+            direct_update = false;
+        } else {
+            // Update Texture directly
+            direct_update = true;
+        }
+    } else {
+        // Surface and Renderer formats are different, it needs an intermediate conversion.
+        direct_update = false;
+    }
+
+    if (direct_update) {
+        if (SDL_MUSTLOCK(surface)) {
+            SDL_LockSurface(surface);
+            SDL_UpdateTexture(texture, rect, surface->pixels, surface->pitch);
+            SDL_UnlockSurface(surface);
+        } else {
+            SDL_UpdateTexture(texture, rect, surface->pixels, surface->pitch);
+        }
+    } else {
+        SDL_Surface *temp = NULL;
+
+        // Set up a destination surface for the texture update
+        temp = SDL_ConvertSurfaceAndColorspace(surface, tex_format, NULL, texture_colorspace, surface_props);
+        if (temp) {
+            SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
+            SDL_DestroySurface(temp);
+        } else {
+            return false;
+        }
+    }
+
+    {
+        Uint8 r, g, b, a;
+        SDL_BlendMode blendMode;
+
+        SDL_GetSurfaceColorMod(surface, &r, &g, &b);
+        SDL_SetTextureColorMod(texture, r, g, b);
+
+        SDL_GetSurfaceAlphaMod(surface, &a);
+        SDL_SetTextureAlphaMod(texture, a);
+
+        if (SDL_SurfaceHasColorKey(surface)) {
+            // We converted to a texture with alpha format
+            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+        } else {
+            SDL_GetSurfaceBlendMode(surface, &blendMode);
+            SDL_SetTextureBlendMode(texture, blendMode);
+        }
+    }
+
+    return true;
+}
+
+SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer, SDL_Surface *surface)
+{
+    bool needAlpha;
+    int i;
+    SDL_PixelFormat format = SDL_PIXELFORMAT_UNKNOWN;
+    SDL_Palette *palette;
+    SDL_Texture *texture;
+    SDL_PropertiesID props;
+    SDL_Colorspace surface_colorspace = SDL_COLORSPACE_UNKNOWN;
+    SDL_Colorspace texture_colorspace = SDL_COLORSPACE_UNKNOWN;
+
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
+    if (!SDL_SurfaceValid(surface)) {
+        SDL_InvalidParamError("SDL_CreateTextureFromSurface(): surface");
+        return NULL;
+    }
+
+    // See what the best texture format is
+    if (SDL_ISPIXELFORMAT_ALPHA(surface->format) || SDL_SurfaceHasColorKey(surface)) {
+        needAlpha = true;
+    } else {
+        needAlpha = false;
+    }
+
+    // If Palette contains alpha values, promotes to alpha format
+    palette = SDL_GetSurfacePalette(surface);
+    if (palette) {
+        bool is_opaque, has_alpha_channel;
+        SDL_DetectPalette(palette, &is_opaque, &has_alpha_channel);
+        if (!is_opaque) {
+            needAlpha = true;
+        }
+    }
+
+    surface_colorspace = SDL_GetSurfaceColorspace(surface);
+
+    // Try to have the best pixel format for the texture
+    // No alpha, but a colorkey => promote to alpha
+    if (!SDL_ISPIXELFORMAT_ALPHA(surface->format) && SDL_SurfaceHasColorKey(surface)) {
+        if (surface->format == SDL_PIXELFORMAT_XRGB8888) {
+            for (i = 0; i < renderer->num_texture_formats; ++i) {
+                if (renderer->texture_formats[i] == SDL_PIXELFORMAT_ARGB8888) {
+                    format = SDL_PIXELFORMAT_ARGB8888;
+                    break;
+                }
+            }
+        } else if (surface->format == SDL_PIXELFORMAT_XBGR8888) {
+            for (i = 0; i < renderer->num_texture_formats; ++i) {
+                if (renderer->texture_formats[i] == SDL_PIXELFORMAT_ABGR8888) {
+                    format = SDL_PIXELFORMAT_ABGR8888;
+                    break;
+                }
+            }
+        }
+    } else {
+        // Exact match would be fine
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (renderer->texture_formats[i] == surface->format) {
+                format = surface->format;
+                break;
+            }
+        }
+    }
+
+    // Look for 10-bit pixel formats if needed
+    if (format == SDL_PIXELFORMAT_UNKNOWN && SDL_ISPIXELFORMAT_10BIT(surface->format)) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (SDL_ISPIXELFORMAT_10BIT(renderer->texture_formats[i])) {
+                format = renderer->texture_formats[i];
+                break;
+            }
+        }
+    }
+
+    // Look for floating point pixel formats if needed
+    if (format == SDL_PIXELFORMAT_UNKNOWN &&
+        (SDL_ISPIXELFORMAT_10BIT(surface->format) || SDL_ISPIXELFORMAT_FLOAT(surface->format))) {
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (SDL_ISPIXELFORMAT_FLOAT(renderer->texture_formats[i])) {
+                format = renderer->texture_formats[i];
+                break;
+            }
+        }
+    }
+
+    // Fallback, choose a valid pixel format
+    if (format == SDL_PIXELFORMAT_UNKNOWN) {
+        format = renderer->texture_formats[0];
+        for (i = 0; i < renderer->num_texture_formats; ++i) {
+            if (!SDL_ISPIXELFORMAT_FOURCC(renderer->texture_formats[i]) &&
+                SDL_ISPIXELFORMAT_ALPHA(renderer->texture_formats[i]) == needAlpha) {
+                format = renderer->texture_formats[i];
+                break;
+            }
+        }
+    }
+
+    if (surface_colorspace == SDL_COLORSPACE_SRGB_LINEAR ||
+        SDL_COLORSPACETRANSFER(surface_colorspace) == SDL_TRANSFER_CHARACTERISTICS_PQ) {
+        if (SDL_ISPIXELFORMAT_FLOAT(format)) {
+            texture_colorspace = SDL_COLORSPACE_SRGB_LINEAR;
+        } else if (SDL_ISPIXELFORMAT_10BIT(format)) {
+            texture_colorspace = SDL_COLORSPACE_HDR10;
+        } else {
+            texture_colorspace = SDL_COLORSPACE_SRGB;
+        }
+    }
+
+    props = SDL_CreateProperties();
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER, texture_colorspace);
+    if (surface_colorspace == texture_colorspace) {
+        SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_SDR_WHITE_POINT_FLOAT,
+                             SDL_GetSurfaceSDRWhitePoint(surface, surface_colorspace));
+    }
+    SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_CREATE_HDR_HEADROOM_FLOAT,
+                         SDL_GetSurfaceHDRHeadroom(surface, surface_colorspace));
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER, format);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_ACCESS_NUMBER, SDL_TEXTUREACCESS_STATIC);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER, surface->w);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER, surface->h);
+    texture = SDL_CreateTextureWithProperties(renderer, props);
+    SDL_DestroyProperties(props);
+    if (!texture) {
+        return NULL;
+    }
+
+    if (!SDL_UpdateTextureFromSurface(texture, NULL, surface)) {
+        SDL_DestroyTexture(texture);
+        return NULL;
+    }
+
+    return texture;
+}
+
+SDL_Renderer *SDL_GetRendererFromTexture(SDL_Texture *texture)
+{
+    CHECK_TEXTURE_MAGIC(texture, NULL);
+
+    return texture->renderer;
+}
+
+SDL_PropertiesID SDL_GetTextureProperties(SDL_Texture *texture)
+{
+    CHECK_TEXTURE_MAGIC(texture, 0);
+
+    if (texture->props == 0) {
+        texture->props = SDL_CreateProperties();
+    }
+    return texture->props;
+}
+
+bool SDL_GetTextureSize(SDL_Texture *texture, float *w, float *h)
+{
+    if (w) {
+        *w = 0;
+    }
+    if (h) {
+        *h = 0;
+    }
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (w) {
+        *w = (float)texture->w;
+    }
+    if (h) {
+        *h = (float)texture->h;
+    }
+    return true;
+}
+
+bool SDL_SetTextureColorMod(SDL_Texture *texture, Uint8 r, Uint8 g, Uint8 b)
+{
+    const float fR = (float)r / 255.0f;
+    const float fG = (float)g / 255.0f;
+    const float fB = (float)b / 255.0f;
+
+    return SDL_SetTextureColorModFloat(texture, fR, fG, fB);
+}
+
+bool SDL_SetTextureColorModFloat(SDL_Texture *texture, float r, float g, float b)
+{
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    texture->color.r = r;
+    texture->color.g = g;
+    texture->color.b = b;
+    if (texture->native) {
+        return SDL_SetTextureColorModFloat(texture->native, r, g, b);
+    }
+    return true;
+}
+
+bool SDL_GetTextureColorMod(SDL_Texture *texture, Uint8 *r, Uint8 *g, Uint8 *b)
+{
+    float fR = 1.0f, fG = 1.0f, fB = 1.0f;
+
+    if (!SDL_GetTextureColorModFloat(texture, &fR, &fG, &fB)) {
+        if (r) {
+            *r = 255;
+        }
+        if (g) {
+            *g = 255;
+        }
+        if (b) {
+            *b = 255;
+        }
+        return false;
+    }
+
+    if (r) {
+        *r = (Uint8)SDL_roundf(SDL_clamp(fR, 0.0f, 1.0f) * 255.0f);
+    }
+    if (g) {
+        *g = (Uint8)SDL_roundf(SDL_clamp(fG, 0.0f, 1.0f) * 255.0f);
+    }
+    if (b) {
+        *b = (Uint8)SDL_roundf(SDL_clamp(fB, 0.0f, 1.0f) * 255.0f);
+    }
+    return true;
+}
+
+bool SDL_GetTextureColorModFloat(SDL_Texture *texture, float *r, float *g, float *b)
+{
+    SDL_FColor color;
+
+    if (r) {
+        *r = 1.0f;
+    }
+    if (g) {
+        *g = 1.0f;
+    }
+    if (b) {
+        *b = 1.0f;
+    }
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    color = texture->color;
+
+    if (r) {
+        *r = color.r;
+    }
+    if (g) {
+        *g = color.g;
+    }
+    if (b) {
+        *b = color.b;
+    }
+    return true;
+}
+
+bool SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha)
+{
+    const float fA = (float)alpha / 255.0f;
+
+    return SDL_SetTextureAlphaModFloat(texture, fA);
+}
+
+bool SDL_SetTextureAlphaModFloat(SDL_Texture *texture, float alpha)
+{
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    texture->color.a = alpha;
+    if (texture->native) {
+        return SDL_SetTextureAlphaModFloat(texture->native, alpha);
+    }
+    return true;
+}
+
+bool SDL_GetTextureAlphaMod(SDL_Texture *texture, Uint8 *alpha)
+{
+    float fA = 1.0f;
+
+    if (!SDL_GetTextureAlphaModFloat(texture, &fA)) {
+        if (alpha) {
+            *alpha = 255;
+        }
+        return false;
+    }
+
+    if (alpha) {
+        *alpha = (Uint8)SDL_roundf(SDL_clamp(fA, 0.0f, 1.0f) * 255.0f);
+    }
+    return true;
+}
+
+bool SDL_GetTextureAlphaModFloat(SDL_Texture *texture, float *alpha)
+{
+    if (alpha) {
+        *alpha = 1.0f;
+    }
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (alpha) {
+        *alpha = texture->color.a;
+    }
+    return true;
+}
+
+bool SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode)
+{
+    SDL_Renderer *renderer;
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (blendMode == SDL_BLENDMODE_INVALID) {
+        return SDL_InvalidParamError("blendMode");
+    }
+
+    renderer = texture->renderer;
+    if (!IsSupportedBlendMode(renderer, blendMode)) {
+        return SDL_Unsupported();
+    }
+    texture->blendMode = blendMode;
+    if (texture->native) {
+        return SDL_SetTextureBlendMode(texture->native, blendMode);
+    }
+    return true;
+}
+
+bool SDL_GetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode *blendMode)
+{
+    if (blendMode) {
+        *blendMode = SDL_BLENDMODE_INVALID;
+    }
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (blendMode) {
+        *blendMode = texture->blendMode;
+    }
+    return true;
+}
+
+bool SDL_SetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    SDL_Renderer *renderer;
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (scaleMode != SDL_SCALEMODE_NEAREST &&
+        scaleMode != SDL_SCALEMODE_LINEAR) {
+        return SDL_InvalidParamError("scaleMode");
+    }
+
+    renderer = texture->renderer;
+    texture->scaleMode = scaleMode;
+    if (texture->native) {
+        return SDL_SetTextureScaleMode(texture->native, scaleMode);
+    } else {
+        renderer->SetTextureScaleMode(renderer, texture, scaleMode);
+    }
+    return true;
+}
+
+bool SDL_GetTextureScaleMode(SDL_Texture *texture, SDL_ScaleMode *scaleMode)
+{
+    if (scaleMode) {
+        *scaleMode = SDL_SCALEMODE_LINEAR;
+    }
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (scaleMode) {
+        *scaleMode = texture->scaleMode;
+    }
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool SDL_UpdateTextureYUV(SDL_Texture *texture, const SDL_Rect *rect,
+                                const void *pixels, int pitch)
+{
+    SDL_Texture *native = texture->native;
+    SDL_Rect full_rect;
+
+    if (!SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch)) {
+        return false;
+    }
+
+    full_rect.x = 0;
+    full_rect.y = 0;
+    full_rect.w = texture->w;
+    full_rect.h = texture->h;
+    rect = &full_rect;
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        // We can lock the texture and copy to it
+        void *native_pixels = NULL;
+        int native_pitch = 0;
+
+        if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) {
+            return false;
+        }
+        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                            rect->w, rect->h, native_pixels, native_pitch);
+        SDL_UnlockTexture(native);
+    } else {
+        // Use a temporary buffer for updating
+        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
+        const size_t alloclen = (size_t)rect->h * temp_pitch;
+        if (alloclen > 0) {
+            void *temp_pixels = SDL_malloc(alloclen);
+            if (!temp_pixels) {
+                return false;
+            }
+            SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                                rect->w, rect->h, temp_pixels, temp_pitch);
+            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
+            SDL_free(temp_pixels);
+        }
+    }
+    return true;
+}
+#endif // SDL_HAVE_YUV
+
+static bool SDL_UpdateTextureNative(SDL_Texture *texture, const SDL_Rect *rect,
+                                   const void *pixels, int pitch)
+{
+    SDL_Texture *native = texture->native;
+
+    if (!rect->w || !rect->h) {
+        return true; // nothing to do.
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        // We can lock the texture and copy to it
+        void *native_pixels = NULL;
+        int native_pitch = 0;
+
+        if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) {
+            return false;
+        }
+        SDL_ConvertPixelsAndColorspace(rect->w, rect->h,
+                                       texture->format, texture->colorspace, 0, pixels, pitch,
+                                       native->format, native->colorspace, 0, native_pixels, native_pitch);
+        SDL_UnlockTexture(native);
+    } else {
+        // Use a temporary buffer for updating
+        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
+        const size_t alloclen = (size_t)rect->h * temp_pitch;
+        if (alloclen > 0) {
+            void *temp_pixels = SDL_malloc(alloclen);
+            if (!temp_pixels) {
+                return false;
+            }
+            SDL_ConvertPixelsAndColorspace(rect->w, rect->h,
+                                           texture->format, texture->colorspace, 0, pixels, pitch,
+                                           native->format, native->colorspace, 0, temp_pixels, temp_pitch);
+            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
+            SDL_free(temp_pixels);
+        }
+    }
+    return true;
+}
+
+bool SDL_UpdateTexture(SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    SDL_Rect real_rect;
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (!pixels) {
+        return SDL_InvalidParamError("pixels");
+    }
+    if (!pitch) {
+        return SDL_InvalidParamError("pitch");
+    }
+
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        if (!SDL_GetRectIntersection(rect, &real_rect, &real_rect)) {
+            return true;
+        }
+    }
+
+    if (real_rect.w == 0 || real_rect.h == 0) {
+        return true; // nothing to do.
+#ifdef SDL_HAVE_YUV
+    } else if (texture->yuv) {
+        return SDL_UpdateTextureYUV(texture, &real_rect, pixels, pitch);
+#endif
+    } else if (texture->native) {
+        return SDL_UpdateTextureNative(texture, &real_rect, pixels, pitch);
+    } else {
+        SDL_Renderer *renderer = texture->renderer;
+        if (!FlushRenderCommandsIfTextureNeeded(texture)) {
+            return false;
+        }
+        return renderer->UpdateTexture(renderer, texture, &real_rect, pixels, pitch);
+    }
+}
+
+#ifdef SDL_HAVE_YUV
+static bool SDL_UpdateTextureYUVPlanar(SDL_Texture *texture, const SDL_Rect *rect,
+                                      const Uint8 *Yplane, int Ypitch,
+                                      const Uint8 *Uplane, int Upitch,
+                                      const Uint8 *Vplane, int Vpitch)
+{
+    SDL_Texture *native = texture->native;
+    SDL_Rect full_rect;
+
+    if (!SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch)) {
+        return false;
+    }
+
+    full_rect.x = 0;
+    full_rect.y = 0;
+    full_rect.w = texture->w;
+    full_rect.h = texture->h;
+    rect = &full_rect;
+
+    if (!rect->w || !rect->h) {
+        return true; // nothing to do.
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        // We can lock the texture and copy to it
+        void *native_pixels = NULL;
+        int native_pitch = 0;
+
+        if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) {
+            return false;
+        }
+        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                            rect->w, rect->h, native_pixels, native_pitch);
+        SDL_UnlockTexture(native);
+    } else {
+        // Use a temporary buffer for updating
+        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
+        const size_t alloclen = (size_t)rect->h * temp_pitch;
+        if (alloclen > 0) {
+            void *temp_pixels = SDL_malloc(alloclen);
+            if (!temp_pixels) {
+                return false;
+            }
+            SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                                rect->w, rect->h, temp_pixels, temp_pitch);
+            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
+            SDL_free(temp_pixels);
+        }
+    }
+    return true;
+}
+
+static bool SDL_UpdateTextureNVPlanar(SDL_Texture *texture, const SDL_Rect *rect,
+                                     const Uint8 *Yplane, int Ypitch,
+                                     const Uint8 *UVplane, int UVpitch)
+{
+    SDL_Texture *native = texture->native;
+    SDL_Rect full_rect;
+
+    if (!SDL_SW_UpdateNVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, UVplane, UVpitch)) {
+        return false;
+    }
+
+    full_rect.x = 0;
+    full_rect.y = 0;
+    full_rect.w = texture->w;
+    full_rect.h = texture->h;
+    rect = &full_rect;
+
+    if (!rect->w || !rect->h) {
+        return true; // nothing to do.
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        // We can lock the texture and copy to it
+        void *native_pixels = NULL;
+        int native_pitch = 0;
+
+        if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) {
+            return false;
+        }
+        SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                            rect->w, rect->h, native_pixels, native_pitch);
+        SDL_UnlockTexture(native);
+    } else {
+        // Use a temporary buffer for updating
+        const int temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
+        const size_t alloclen = (size_t)rect->h * temp_pitch;
+        if (alloclen > 0) {
+            void *temp_pixels = SDL_malloc(alloclen);
+            if (!temp_pixels) {
+                return false;
+            }
+            SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
+                                rect->w, rect->h, temp_pixels, temp_pitch);
+            SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
+            SDL_free(temp_pixels);
+        }
+    }
+    return true;
+}
+
+#endif // SDL_HAVE_YUV
+
+bool SDL_UpdateYUVTexture(SDL_Texture *texture, const SDL_Rect *rect,
+                         const Uint8 *Yplane, int Ypitch,
+                         const Uint8 *Uplane, int Upitch,
+                         const Uint8 *Vplane, int Vpitch)
+{
+#ifdef SDL_HAVE_YUV
+    SDL_Renderer *renderer;
+    SDL_Rect real_rect;
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (!Yplane) {
+        return SDL_InvalidParamError("Yplane");
+    }
+    if (!Ypitch) {
+        return SDL_InvalidParamError("Ypitch");
+    }
+    if (!Uplane) {
+        return SDL_InvalidParamError("Uplane");
+    }
+    if (!Upitch) {
+        return SDL_InvalidParamError("Upitch");
+    }
+    if (!Vplane) {
+        return SDL_InvalidParamError("Vplane");
+    }
+    if (!Vpitch) {
+        return SDL_InvalidParamError("Vpitch");
+    }
+
+    if (texture->format != SDL_PIXELFORMAT_YV12 &&
+        texture->format != SDL_PIXELFORMAT_IYUV) {
+        return SDL_SetError("Texture format must by YV12 or IYUV");
+    }
+
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        SDL_GetRectIntersection(rect, &real_rect, &real_rect);
+    }
+
+    if (real_rect.w == 0 || real_rect.h == 0) {
+        return true; // nothing to do.
+    }
+
+    if (texture->yuv) {
+        return SDL_UpdateTextureYUVPlanar(texture, &real_rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
+    } else {
+        SDL_assert(!texture->native);
+        renderer = texture->renderer;
+        SDL_assert(renderer->UpdateTextureYUV);
+        if (renderer->UpdateTextureYUV) {
+            if (!FlushRenderCommandsIfTextureNeeded(texture)) {
+                return false;
+            }
+            return renderer->UpdateTextureYUV(renderer, texture, &real_rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
+        } else {
+            return SDL_Unsupported();
+        }
+    }
+#else
+    return false;
+#endif
+}
+
+bool SDL_UpdateNVTexture(SDL_Texture *texture, const SDL_Rect *rect,
+                        const Uint8 *Yplane, int Ypitch,
+                        const Uint8 *UVplane, int UVpitch)
+{
+#ifdef SDL_HAVE_YUV
+    SDL_Renderer *renderer;
+    SDL_Rect real_rect;
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (!Yplane) {
+        return SDL_InvalidParamError("Yplane");
+    }
+    if (!Ypitch) {
+        return SDL_InvalidParamError("Ypitch");
+    }
+    if (!UVplane) {
+        return SDL_InvalidParamError("UVplane");
+    }
+    if (!UVpitch) {
+        return SDL_InvalidParamError("UVpitch");
+    }
+
+    if (texture->format != SDL_PIXELFORMAT_NV12 &&
+        texture->format != SDL_PIXELFORMAT_NV21) {
+        return SDL_SetError("Texture format must by NV12 or NV21");
+    }
+
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        SDL_GetRectIntersection(rect, &real_rect, &real_rect);
+    }
+
+    if (real_rect.w == 0 || real_rect.h == 0) {
+        return true; // nothing to do.
+    }
+
+    if (texture->yuv) {
+        return SDL_UpdateTextureNVPlanar(texture, &real_rect, Yplane, Ypitch, UVplane, UVpitch);
+    } else {
+        SDL_assert(!texture->native);
+        renderer = texture->renderer;
+        SDL_assert(renderer->UpdateTextureNV);
+        if (renderer->UpdateTextureNV) {
+            if (!FlushRenderCommandsIfTextureNeeded(texture)) {
+                return false;
+            }
+            return renderer->UpdateTextureNV(renderer, texture, &real_rect, Yplane, Ypitch, UVplane, UVpitch);
+        } else {
+            return SDL_Unsupported();
+        }
+    }
+#else
+    return false;
+#endif
+}
+
+#ifdef SDL_HAVE_YUV
+static bool SDL_LockTextureYUV(SDL_Texture *texture, const SDL_Rect *rect,
+                              void **pixels, int *pitch)
+{
+    return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
+}
+#endif // SDL_HAVE_YUV
+
+static bool SDL_LockTextureNative(SDL_Texture *texture, const SDL_Rect *rect,
+                                 void **pixels, int *pitch)
+{
+    texture->locked_rect = *rect;
+    *pixels = (void *)((Uint8 *)texture->pixels +
+                       rect->y * texture->pitch +
+                       rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = texture->pitch;
+    return true;
+}
+
+bool SDL_LockTexture(SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    SDL_Rect full_rect;
+
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
+        return SDL_SetError("SDL_LockTexture(): texture must be streaming");
+    }
+
+    if (!rect) {
+        full_rect.x = 0;
+        full_rect.y = 0;
+        full_rect.w = texture->w;
+        full_rect.h = texture->h;
+        rect = &full_rect;
+    }
+
+#ifdef SDL_HAVE_YUV
+    if (texture->yuv) {
+        if (!FlushRenderCommandsIfTextureNeeded(texture)) {
+            return false;
+        }
+        return SDL_LockTextureYUV(texture, rect, pixels, pitch);
+    } else
+#endif
+        if (texture->native) {
+        // Calls a real SDL_LockTexture/SDL_UnlockTexture on unlock, flushing then.
+        return SDL_LockTextureNative(texture, rect, pixels, pitch);
+    } else {
+        SDL_Renderer *renderer = texture->renderer;
+        if (!FlushRenderCommandsIfTextureNeeded(texture)) {
+            return false;
+        }
+        return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
+    }
+}
+
+bool SDL_LockTextureToSurface(SDL_Texture *texture, const SDL_Rect *rect, SDL_Surface **surface)
+{
+    SDL_Rect real_rect;
+    void *pixels = NULL;
+    int pitch = 0; // fix static analysis
+
+    if (!texture || !surface) {
+        return false;
+    }
+
+    real_rect.x = 0;
+    real_rect.y = 0;
+    real_rect.w = texture->w;
+    real_rect.h = texture->h;
+    if (rect) {
+        SDL_GetRectIntersection(rect, &real_rect, &real_rect);
+    }
+
+    if (!SDL_LockTexture(texture, &real_rect, &pixels, &pitch)) {
+        return false;
+    }
+
+    texture->locked_surface = SDL_CreateSurfaceFrom(real_rect.w, real_rect.h, texture->format, pixels, pitch);
+    if (!texture->locked_surface) {
+        SDL_UnlockTexture(texture);
+        return false;
+    }
+
+    *surface = texture->locked_surface;
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static void SDL_UnlockTextureYUV(SDL_Texture *texture)
+{
+    SDL_Texture *native = texture->native;
+    void *native_pixels = NULL;
+    int native_pitch = 0;
+    SDL_Rect rect;
+
+    rect.x = 0;
+    rect.y = 0;
+    rect.w = texture->w;
+    rect.h = texture->h;
+
+    if (!SDL_LockTexture(native, &rect, &native_pixels, &native_pitch)) {
+        return;
+    }
+    SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
+                        rect.w, rect.h, native_pixels, native_pitch);
+    SDL_UnlockTexture(native);
+}
+#endif // SDL_HAVE_YUV
+
+static void SDL_UnlockTextureNative(SDL_Texture *texture)
+{
+    SDL_Texture *native = texture->native;
+    void *native_pixels = NULL;
+    int native_pitch = 0;
+    const SDL_Rect *rect = &texture->locked_rect;
+    const void *pixels = (void *)((Uint8 *)texture->pixels +
+                                  rect->y * texture->pitch +
+                                  rect->x * SDL_BYTESPERPIXEL(texture->format));
+    int pitch = texture->pitch;
+
+    if (!SDL_LockTexture(native, rect, &native_pixels, &native_pitch)) {
+        return;
+    }
+    SDL_ConvertPixels(rect->w, rect->h,
+                      texture->format, pixels, pitch,
+                      native->format, native_pixels, native_pitch);
+    SDL_UnlockTexture(native);
+}
+
+void SDL_UnlockTexture(SDL_Texture *texture)
+{
+    CHECK_TEXTURE_MAGIC(texture,);
+
+    if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
+        return;
+    }
+#ifdef SDL_HAVE_YUV
+    if (texture->yuv) {
+        SDL_UnlockTextureYUV(texture);
+    } else
+#endif
+        if (texture->native) {
+        SDL_UnlockTextureNative(texture);
+    } else {
+        SDL_Renderer *renderer = texture->renderer;
+        renderer->UnlockTexture(renderer, texture);
+    }
+
+    SDL_DestroySurface(texture->locked_surface);
+    texture->locked_surface = NULL;
+}
+
+bool SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    // texture == NULL is valid and means reset the target to the window
+    if (texture) {
+        CHECK_TEXTURE_MAGIC(texture, false);
+        if (renderer != texture->renderer) {
+            return SDL_SetError("Texture was not created with this renderer");
+        }
+        if (texture->access != SDL_TEXTUREACCESS_TARGET) {
+            return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
+        }
+        if (texture->native) {
+            // Always render to the native texture
+            texture = texture->native;
+        }
+    }
+
+    if (texture == renderer->target) {
+        // Nothing to do!
+        return true;
+    }
+
+    FlushRenderCommands(renderer); // time to send everything to the GPU!
+
+    SDL_LockMutex(renderer->target_mutex);
+
+    renderer->target = texture;
+    if (texture) {
+        renderer->view = &texture->view;
+    } else {
+        renderer->view = &renderer->main_view;
+    }
+    UpdateColorScale(renderer);
+
+    if (!renderer->SetRenderTarget(renderer, texture)) {
+        SDL_UnlockMutex(renderer->target_mutex);
+        return false;
+    }
+
+    SDL_UnlockMutex(renderer->target_mutex);
+
+    if (!QueueCmdSetViewport(renderer)) {
+        return false;
+    }
+    if (!QueueCmdSetClipRect(renderer)) {
+        return false;
+    }
+
+    // All set!
+    return true;
+}
+
+SDL_Texture *SDL_GetRenderTarget(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+    if (!renderer->target) {
+        return NULL;
+    }
+    return (SDL_Texture *) SDL_GetPointerProperty(SDL_GetTextureProperties(renderer->target), SDL_PROP_TEXTURE_PARENT_POINTER, renderer->target);
+}
+
+static void UpdateLogicalPresentation(SDL_Renderer *renderer)
+{
+    SDL_RenderViewState *view = renderer->view;
+    const bool is_main_view = (view == &renderer->main_view);
+    const float logical_w = view->logical_w;
+    const float logical_h = view->logical_h;
+    int iwidth, iheight;
+
+    if (renderer->target) {
+        iwidth = (int)renderer->target->w;
+        iheight = (int)renderer->target->h;
+    } else {
+        SDL_GetRenderOutputSize(renderer, &iwidth, &iheight);
+    }
+
+    view->logical_src_rect.x = 0.0f;
+    view->logical_src_rect.y = 0.0f;
+    view->logical_src_rect.w = logical_w;
+    view->logical_src_rect.h = logical_h;
+
+    if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_DISABLED) {
+        view->logical_dst_rect.x = 0.0f;
+        view->logical_dst_rect.y = 0.0f;
+        view->logical_dst_rect.w = iwidth;
+        view->logical_dst_rect.h = iheight;
+        view->logical_offset.x = view->logical_offset.y = 0.0f;
+        view->logical_scale.x = view->logical_scale.y = 1.0f;
+        view->current_scale.x = view->scale.x;  // skip the multiplications against 1.0f.
+        view->current_scale.y = view->scale.y;
+    } else {
+        const float output_w = (float)iwidth;
+        const float output_h = (float)iheight;
+        const float want_aspect = logical_w / logical_h;
+        const float real_aspect = output_w / output_h;
+
+        if ((logical_w <= 0.0f) || (logical_h <= 0.0f)) {
+            view->logical_dst_rect.x = 0.0f;
+            view->logical_dst_rect.y = 0.0f;
+            view->logical_dst_rect.w = output_w;
+            view->logical_dst_rect.h = output_h;
+        } else if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_INTEGER_SCALE) {
+            float scale;
+            if (want_aspect > real_aspect) {
+                scale = (float)((int)output_w / (int)logical_w); // This an integer division!
+            } else {
+                scale = (float)((int)output_h / (int)logical_h); // This an integer division!
+            }
+
+            if (scale < 1.0f) {
+                scale = 1.0f;
+            }
+
+            view->logical_dst_rect.w = SDL_floorf(logical_w * scale);
+            view->logical_dst_rect.x = (output_w - view->logical_dst_rect.w) / 2.0f;
+            view->logical_dst_rect.h = SDL_floorf(logical_h * scale);
+            view->logical_dst_rect.y = (output_h - view->logical_dst_rect.h) / 2.0f;
+
+        } else if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_STRETCH || SDL_fabsf(want_aspect - real_aspect) < 0.0001f) {
+            view->logical_dst_rect.x = 0.0f;
+            view->logical_dst_rect.y = 0.0f;
+            view->logical_dst_rect.w = output_w;
+            view->logical_dst_rect.h = output_h;
+
+        } else if (want_aspect > real_aspect) {
+            if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) {
+                // We want a wider aspect ratio than is available - letterbox it
+                const float scale = output_w / logical_w;
+                view->logical_dst_rect.x = 0.0f;
+                view->logical_dst_rect.w = output_w;
+                view->logical_dst_rect.h = SDL_floorf(logical_h * scale);
+                view->logical_dst_rect.y = (output_h - view->logical_dst_rect.h) / 2.0f;
+            } else { // view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_OVERSCAN
+                /* We want a wider aspect ratio than is available -
+                   zoom so logical height matches the real height
+                   and the width will grow off the screen
+                 */
+                const float scale = output_h / logical_h;
+                view->logical_dst_rect.y = 0.0f;
+                view->logical_dst_rect.h = output_h;
+                view->logical_dst_rect.w = SDL_floorf(logical_w * scale);
+                view->logical_dst_rect.x = (output_w - view->logical_dst_rect.w) / 2.0f;
+            }
+        } else {
+            if (view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) {
+                // We want a narrower aspect ratio than is available - use side-bars
+                const float scale = output_h / logical_h;
+                view->logical_dst_rect.y = 0.0f;
+                view->logical_dst_rect.h = output_h;
+                view->logical_dst_rect.w = SDL_floorf(logical_w * scale);
+                view->logical_dst_rect.x = (output_w - view->logical_dst_rect.w) / 2.0f;
+            } else { // view->logical_presentation_mode == SDL_LOGICAL_PRESENTATION_OVERSCAN
+                /* We want a narrower aspect ratio than is available -
+                   zoom so logical width matches the real width
+                   and the height will grow off the screen
+                 */
+                const float scale = output_w / logical_w;
+                view->logical_dst_rect.x = 0.0f;
+                view->logical_dst_rect.w = output_w;
+                view->logical_dst_rect.h = SDL_floorf(logical_h * scale);
+                view->logical_dst_rect.y = (output_h - view->logical_dst_rect.h) / 2.0f;
+            }
+        }
+
+        view->logical_scale.x = (logical_w > 0.0f) ? view->logical_dst_rect.w / logical_w : 0.0f;
+        view->logical_scale.y = (logical_h > 0.0f) ? view->logical_dst_rect.h / logical_h : 0.0f;
+        view->current_scale.x = view->scale.x * view->logical_scale.x;
+        view->current_scale.y = view->scale.y * view->logical_scale.y;
+        view->logical_offset.x = view->logical_dst_rect.x;
+        view->logical_offset.y = view->logical_dst_rect.y;
+    }
+
+    if (is_main_view) {
+        // This makes sure the dpi_scale is right. It also sets pixel_w and pixel_h, but we're going to change them directly below here.
+        UpdateMainViewDimensions(renderer);
+    }
+
+    view->pixel_w = (int) view->logical_dst_rect.w;
+    view->pixel_h = (int) view->logical_dst_rect.h;
+    UpdatePixelViewport(renderer, view);
+    UpdatePixelClipRect(renderer, view);
+}
+
+bool SDL_SetRenderLogicalPresentation(SDL_Renderer *renderer, int w, int h, SDL_RendererLogicalPresentation mode)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    SDL_RenderViewState *view = renderer->view;
+    view->logical_presentation_mode = mode;
+    view->logical_w = w;
+    view->logical_h = h;
+
+    UpdateLogicalPresentation(renderer);
+
+    return true;
+}
+
+bool SDL_GetRenderLogicalPresentation(SDL_Renderer *renderer, int *w, int *h, SDL_RendererLogicalPresentation *mode)
+{
+    #define SETVAL(ptr, val) if (ptr) { *ptr = val; }
+
+    SETVAL(w, 0);
+    SETVAL(h, 0);
+    SETVAL(mode, SDL_LOGICAL_PRESENTATION_DISABLED);
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    const SDL_RenderViewState *view = renderer->view;
+    SETVAL(w, view->logical_w);
+    SETVAL(h, view->logical_h);
+    SETVAL(mode, view->logical_presentation_mode);
+
+    #undef SETVAL
+
+    return true;
+}
+
+bool SDL_GetRenderLogicalPresentationRect(SDL_Renderer *renderer, SDL_FRect *rect)
+{
+    if (rect) {
+        SDL_zerop(rect);
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (rect) {
+        SDL_copyp(rect, &renderer->view->logical_dst_rect);
+    }
+    return true;
+}
+
+static void SDL_RenderLogicalBorders(SDL_Renderer *renderer, const SDL_FRect *dst)
+{
+    const SDL_RenderViewState *view = renderer->view;
+
+    if (dst->x > 0.0f || dst->y > 0.0f) {
+        SDL_BlendMode saved_blend_mode = renderer->blendMode;
+        SDL_FColor saved_color = renderer->color;
+
+        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
+        SDL_SetRenderDrawColorFloat(renderer, 0.0f, 0.0f, 0.0f, 1.0f);
+
+        if (dst->x > 0.0f) {
+            SDL_FRect rect;
+
+            rect.x = 0.0f;
+            rect.y = 0.0f;
+            rect.w = dst->x;
+            rect.h = (float)view->pixel_h;
+            SDL_RenderFillRect(renderer, &rect);
+
+            rect.x = dst->x + dst->w;
+            rect.w = (float)view->pixel_w - rect.x;
+            SDL_RenderFillRect(renderer, &rect);
+        }
+
+        if (dst->y > 0.0f) {
+            SDL_FRect rect;
+
+            rect.x = 0.0f;
+            rect.y = 0.0f;
+            rect.w = (float)view->pixel_w;
+            rect.h = dst->y;
+            SDL_RenderFillRect(renderer, &rect);
+
+            rect.y = dst->y + dst->h;
+            rect.h = (float)view->pixel_h - rect.y;
+            SDL_RenderFillRect(renderer, &rect);
+        }
+
+        SDL_SetRenderDrawBlendMode(renderer, saved_blend_mode);
+        SDL_SetRenderDrawColorFloat(renderer, saved_color.r, saved_color.g, saved_color.b, saved_color.a);
+    }
+}
+
+static void SDL_RenderLogicalPresentation(SDL_Renderer *renderer)
+{
+    SDL_assert(renderer->view == &renderer->main_view);
+
+    SDL_RenderViewState *view = &renderer->main_view;
+    const SDL_RendererLogicalPresentation mode = view->logical_presentation_mode;
+    if (mode == SDL_LOGICAL_PRESENTATION_LETTERBOX) {
+        // save off some state we're going to trample.
+        const int logical_w = view->logical_w;
+        const int logical_h = view->logical_h;
+        const float scale_x = view->scale.x;
+        const float scale_y = view->scale.y;
+        const bool clipping_enabled = view->clipping_enabled;
+        SDL_Rect orig_viewport, orig_cliprect;
+        const SDL_FRect logical_dst_rect = view->logical_dst_rect;
+
+        SDL_copyp(&orig_viewport, &view->viewport);
+        if (clipping_enabled) {
+            SDL_copyp(&orig_cliprect, &view->clip_rect);
+        }
+
+        // trample some state.
+        SDL_SetRenderLogicalPresentation(renderer, logical_w, logical_h, SDL_LOGICAL_PRESENTATION_DISABLED);
+        SDL_SetRenderViewport(renderer, NULL);
+        if (clipping_enabled) {
+            SDL_SetRenderClipRect(renderer, NULL);
+        }
+        SDL_SetRenderScale(renderer, 1.0f, 1.0f);
+
+        // draw the borders.
+        SDL_RenderLogicalBorders(renderer, &logical_dst_rect);
+
+        // now set everything back.
+        view->logical_presentation_mode = mode;
+        SDL_SetRenderViewport(renderer, &orig_viewport);
+        if (clipping_enabled) {
+            SDL_SetRenderClipRect(renderer, &orig_cliprect);
+        }
+        SDL_SetRenderScale(renderer, scale_x, scale_y);
+
+        SDL_SetRenderLogicalPresentation(renderer, logical_w, logical_h, mode);
+    }
+}
+
+static bool SDL_RenderVectorFromWindow(SDL_Renderer *renderer, float window_dx, float window_dy, float *dx, float *dy)
+{
+    // Convert from window coordinates to pixels within the window
+    window_dx *= renderer->dpi_scale.x;
+    window_dy *= renderer->dpi_scale.y;
+
+    // Convert from pixels within the window to pixels within the view
+    const SDL_RenderViewState *view = &renderer->main_view;
+    if (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        const SDL_FRect *src = &view->logical_src_rect;
+        const SDL_FRect *dst = &view->logical_dst_rect;
+        window_dx = (window_dx * src->w) / dst->w;
+        window_dy = (window_dy * src->h) / dst->h;
+    }
+
+    window_dx /= view->scale.x;
+    window_dy /= view->scale.y;
+
+    *dx = window_dx;
+    *dy = window_dy;
+    return true;
+}
+
+bool SDL_RenderCoordinatesFromWindow(SDL_Renderer *renderer, float window_x, float window_y, float *x, float *y)
+{
+    float render_x, render_y;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    // Convert from window coordinates to pixels within the window
+    render_x = window_x * renderer->dpi_scale.x;
+    render_y = window_y * renderer->dpi_scale.y;
+
+    // Convert from pixels within the window to pixels within the view
+    const SDL_RenderViewState *view = &renderer->main_view;
+    if (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        const SDL_FRect *src = &view->logical_src_rect;
+        const SDL_FRect *dst = &view->logical_dst_rect;
+        render_x = ((render_x - dst->x) * src->w) / dst->w;
+        render_y = ((render_y - dst->y) * src->h) / dst->h;
+    }
+
+    render_x = (render_x / view->scale.x) - view->viewport.x;
+    render_y = (render_y / view->scale.y) - view->viewport.y;
+
+    if (x) {
+        *x = render_x;
+    }
+    if (y) {
+        *y = render_y;
+    }
+    return true;
+}
+
+bool SDL_RenderCoordinatesToWindow(SDL_Renderer *renderer, float x, float y, float *window_x, float *window_y)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    const SDL_RenderViewState *view = &renderer->main_view;
+    x = (view->viewport.x + x) * view->scale.x;
+    y = (view->viewport.y + y) * view->scale.y;
+
+    // Convert from render coordinates to pixels within the window
+    if (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED) {
+        const SDL_FRect *src = &view->logical_src_rect;
+        const SDL_FRect *dst = &view->logical_dst_rect;
+        x = dst->x + ((x * dst->w) / src->w);
+        y = dst->y + ((y * dst->h) / src->h);
+    }
+
+    // Convert from pixels within the window to window coordinates
+    x /= renderer->dpi_scale.x;
+    y /= renderer->dpi_scale.y;
+
+    if (window_x) {
+        *window_x = x;
+    }
+    if (window_y) {
+        *window_y = y;
+    }
+    return true;
+}
+
+bool SDL_ConvertEventToRenderCoordinates(SDL_Renderer *renderer, SDL_Event *event)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (event->type == SDL_EVENT_MOUSE_MOTION) {
+        SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->motion.x, event->motion.y, &event->motion.x, &event->motion.y);
+            SDL_RenderVectorFromWindow(renderer, event->motion.xrel, event->motion.yrel, &event->motion.xrel, &event->motion.yrel);
+        }
+    } else if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
+               event->type == SDL_EVENT_MOUSE_BUTTON_UP) {
+        SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->button.x, event->button.y, &event->button.x, &event->button.y);
+        }
+    } else if (event->type == SDL_EVENT_MOUSE_WHEEL) {
+        SDL_Window *window = SDL_GetWindowFromID(event->wheel.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->wheel.mouse_x,
+                                            event->wheel.mouse_y,
+                                            &event->wheel.mouse_x,
+                                            &event->wheel.mouse_y);
+        }
+    } else if (event->type == SDL_EVENT_FINGER_DOWN ||
+               event->type == SDL_EVENT_FINGER_UP ||
+               event->type == SDL_EVENT_FINGER_CANCELED ||
+               event->type == SDL_EVENT_FINGER_MOTION) {
+        // FIXME: Are these events guaranteed to be window relative?
+        if (renderer->window) {
+            int w, h;
+            if (!SDL_GetWindowSize(renderer->window, &w, &h)) {
+                return false;
+            }
+            SDL_RenderCoordinatesFromWindow(renderer, event->tfinger.x * w, event->tfinger.y * h, &event->tfinger.x, &event->tfinger.y);
+            SDL_RenderVectorFromWindow(renderer, event->tfinger.dx * w, event->tfinger.dy * h, &event->tfinger.dx, &event->tfinger.dy);
+        }
+    } else if (event->type == SDL_EVENT_PEN_MOTION) {
+        SDL_Window *window = SDL_GetWindowFromID(event->pmotion.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->pmotion.x, event->pmotion.y, &event->pmotion.x, &event->pmotion.y);
+        }
+    } else if ((event->type == SDL_EVENT_PEN_DOWN) || (event->type == SDL_EVENT_PEN_UP)) {
+        SDL_Window *window = SDL_GetWindowFromID(event->ptouch.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->ptouch.x, event->ptouch.y, &event->ptouch.x, &event->ptouch.y);
+        }
+    } else if ((event->type == SDL_EVENT_PEN_BUTTON_DOWN) || (event->type == SDL_EVENT_PEN_BUTTON_UP)) {
+        SDL_Window *window = SDL_GetWindowFromID(event->pbutton.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->pbutton.x, event->pbutton.y, &event->pbutton.x, &event->pbutton.y);
+        }
+    } else if (event->type == SDL_EVENT_PEN_AXIS) {
+        SDL_Window *window = SDL_GetWindowFromID(event->paxis.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->paxis.x, event->paxis.y, &event->paxis.x, &event->paxis.y);
+        }
+    } else if (event->type == SDL_EVENT_DROP_POSITION ||
+               event->type == SDL_EVENT_DROP_FILE ||
+               event->type == SDL_EVENT_DROP_TEXT ||
+               event->type == SDL_EVENT_DROP_COMPLETE) {
+        SDL_Window *window = SDL_GetWindowFromID(event->drop.windowID);
+        if (window == renderer->window) {
+            SDL_RenderCoordinatesFromWindow(renderer, event->drop.x, event->drop.y, &event->drop.x, &event->drop.y);
+        }
+    }
+    return true;
+}
+
+bool SDL_SetRenderViewport(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    SDL_RenderViewState *view = renderer->view;
+    if (rect) {
+        if ((rect->w < 0) || (rect->h < 0)) {
+            return SDL_SetError("rect has a negative size");
+        }
+        SDL_copyp(&view->viewport, rect);
+    } else {
+        view->viewport.x = view->viewport.y = 0;
+        view->viewport.w = view->viewport.h = -1;
+    }
+    UpdatePixelViewport(renderer, view);
+
+    return QueueCmdSetViewport(renderer);
+}
+
+bool SDL_GetRenderViewport(SDL_Renderer *renderer, SDL_Rect *rect)
+{
+    if (rect) {
+        SDL_zerop(rect);
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (rect) {
+        const SDL_RenderViewState *view = renderer->view;
+        rect->x = view->viewport.x;
+        rect->y = view->viewport.y;
+        if (view->viewport.w >= 0) {
+            rect->w = view->viewport.w;
+        } else {
+            rect->w = (int)SDL_ceilf(view->pixel_w / view->current_scale.x);
+        }
+        if (view->viewport.h >= 0) {
+            rect->h = view->viewport.h;
+        } else {
+            rect->h = (int)SDL_ceilf(view->pixel_h / view->current_scale.y);
+        }
+    }
+    return true;
+}
+
+bool SDL_RenderViewportSet(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    const SDL_RenderViewState *view = renderer->view;
+    return (view->viewport.w >= 0 && view->viewport.h >= 0);
+}
+
+static void GetRenderViewportSize(SDL_Renderer *renderer, SDL_FRect *rect)
+{
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+
+    rect->x = 0.0f;
+    rect->y = 0.0f;
+
+    if (view->viewport.w >= 0) {
+        rect->w = (float)view->viewport.w;
+    } else {
+        rect->w = view->pixel_w / scale_x;
+    }
+
+    if (view->viewport.h >= 0) {
+        rect->h = (float)view->viewport.h;
+    } else {
+        rect->h = view->pixel_h / scale_y;
+    }
+}
+
+bool SDL_GetRenderSafeArea(SDL_Renderer *renderer, SDL_Rect *rect)
+{
+    if (rect) {
+        SDL_zerop(rect);
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (renderer->target || !renderer->window) {
+        // The entire viewport is safe for rendering
+        return SDL_GetRenderViewport(renderer, rect);
+    }
+
+    if (rect) {
+        // Get the window safe rect
+        SDL_Rect safe;
+        if (!SDL_GetWindowSafeArea(renderer->window, &safe)) {
+            return false;
+        }
+
+        // Convert the coordinates into the render space
+        float minx = (float)safe.x;
+        float miny = (float)safe.y;
+        float maxx = (float)safe.x + safe.w;
+        float maxy = (float)safe.y + safe.h;
+        if (!SDL_RenderCoordinatesFromWindow(renderer, minx, miny, &minx, &miny) ||
+            !SDL_RenderCoordinatesFromWindow(renderer, maxx, maxy, &maxx, &maxy)) {
+            return false;
+        }
+
+        rect->x = (int)SDL_ceilf(minx);
+        rect->y = (int)SDL_ceilf(miny);
+        rect->w = (int)SDL_ceilf(maxx - minx);
+        rect->h = (int)SDL_ceilf(maxy - miny);
+
+        // Clip with the viewport
+        SDL_Rect viewport;
+        if (!SDL_GetRenderViewport(renderer, &viewport)) {
+            return false;
+        }
+        if (!SDL_GetRectIntersection(rect, &viewport, rect)) {
+            return SDL_SetError("No safe area within viewport");
+        }
+    }
+    return true;
+}
+
+bool SDL_SetRenderClipRect(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    CHECK_RENDERER_MAGIC(renderer, false)
+
+    SDL_RenderViewState *view = renderer->view;
+    if (rect && rect->w >= 0 && rect->h >= 0) {
+        view->clipping_enabled = true;
+        SDL_copyp(&view->clip_rect, rect);
+    } else {
+        view->clipping_enabled = false;
+        SDL_zero(view->clip_rect);
+    }
+    UpdatePixelClipRect(renderer, view);
+
+    return QueueCmdSetClipRect(renderer);
+}
+
+bool SDL_GetRenderClipRect(SDL_Renderer *renderer, SDL_Rect *rect)
+{
+    if (rect) {
+        SDL_zerop(rect);
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false)
+
+    if (rect) {
+        SDL_copyp(rect, &renderer->view->clip_rect);
+    }
+    return true;
+}
+
+bool SDL_RenderClipEnabled(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, false)
+    return renderer->view->clipping_enabled;
+}
+
+bool SDL_SetRenderScale(SDL_Renderer *renderer, float scaleX, float scaleY)
+{
+    bool result = true;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    SDL_RenderViewState *view = renderer->view;
+
+    if ((view->scale.x == scaleX) && (view->scale.y == scaleY)) {
+        return true;
+    }
+
+    view->scale.x = scaleX;
+    view->scale.y = scaleY;
+    view->current_scale.x = scaleX * view->logical_scale.x;
+    view->current_scale.y = scaleY * view->logical_scale.y;
+    UpdatePixelViewport(renderer, view);
+    UpdatePixelClipRect(renderer, view);
+
+    // The scale affects the existing viewport and clip rectangle
+    result &= QueueCmdSetViewport(renderer);
+    result &= QueueCmdSetClipRect(renderer);
+    return result;
+}
+
+bool SDL_GetRenderScale(SDL_Renderer *renderer, float *scaleX, float *scaleY)
+{
+    if (scaleX) {
+        *scaleX = 1.0f;
+    }
+    if (scaleY) {
+        *scaleY = 1.0f;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    const SDL_RenderViewState *view = renderer->view;
+
+    if (scaleX) {
+        *scaleX = view->scale.x;
+    }
+    if (scaleY) {
+        *scaleY = view->scale.y;
+    }
+    return true;
+}
+
+bool SDL_SetRenderDrawColor(SDL_Renderer *renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    const float fR = (float)r / 255.0f;
+    const float fG = (float)g / 255.0f;
+    const float fB = (float)b / 255.0f;
+    const float fA = (float)a / 255.0f;
+
+    return SDL_SetRenderDrawColorFloat(renderer, fR, fG, fB, fA);
+}
+
+bool SDL_SetRenderDrawColorFloat(SDL_Renderer *renderer, float r, float g, float b, float a)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    renderer->color.r = r;
+    renderer->color.g = g;
+    renderer->color.b = b;
+    renderer->color.a = a;
+    return true;
+}
+
+bool SDL_GetRenderDrawColor(SDL_Renderer *renderer, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a)
+{
+    float fR, fG, fB, fA;
+
+    if (!SDL_GetRenderDrawColorFloat(renderer, &fR, &fG, &fB, &fA)) {
+        if (r) {
+            *r = 0;
+        }
+        if (g) {
+            *g = 0;
+        }
+        if (b) {
+            *b = 0;
+        }
+        if (a) {
+            *a = 0;
+        }
+        return false;
+    }
+
+    if (r) {
+        *r = (Uint8)(fR * 255.0f);
+    }
+    if (g) {
+        *g = (Uint8)(fG * 255.0f);
+    }
+    if (b) {
+        *b = (Uint8)(fB * 255.0f);
+    }
+    if (a) {
+        *a = (Uint8)(fA * 255.0f);
+    }
+    return true;
+}
+
+bool SDL_GetRenderDrawColorFloat(SDL_Renderer *renderer, float *r, float *g, float *b, float *a)
+{
+    SDL_FColor color;
+
+    if (r) {
+        *r = 0.0f;
+    }
+    if (g) {
+        *g = 0.0f;
+    }
+    if (b) {
+        *b = 0.0f;
+    }
+    if (a) {
+        *a = 0.0f;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    color = renderer->color;
+
+    if (r) {
+        *r = color.r;
+    }
+    if (g) {
+        *g = color.g;
+    }
+    if (b) {
+        *b = color.b;
+    }
+    if (a) {
+        *a = color.a;
+    }
+    return true;
+}
+
+bool SDL_SetRenderColorScale(SDL_Renderer *renderer, float scale)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    renderer->desired_color_scale = scale;
+    UpdateColorScale(renderer);
+    return true;
+}
+
+bool SDL_GetRenderColorScale(SDL_Renderer *renderer, float *scale)
+{
+    if (scale) {
+        *scale = 1.0f;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (scale) {
+        *scale = renderer->desired_color_scale;
+    }
+    return true;
+}
+
+bool SDL_SetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (blendMode == SDL_BLENDMODE_INVALID) {
+        return SDL_InvalidParamError("blendMode");
+    }
+
+    if (blendMode == SDL_BLENDMODE_INVALID) {
+        return SDL_InvalidParamError("blendMode");
+    }
+
+    if (!IsSupportedBlendMode(renderer, blendMode)) {
+        return SDL_Unsupported();
+    }
+
+    renderer->blendMode = blendMode;
+    return true;
+}
+
+bool SDL_GetRenderDrawBlendMode(SDL_Renderer *renderer, SDL_BlendMode *blendMode)
+{
+    if (blendMode) {
+        *blendMode = SDL_BLENDMODE_INVALID;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (blendMode) {
+        *blendMode = renderer->blendMode;
+    }
+    return true;
+}
+
+bool SDL_RenderClear(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    return QueueCmdClear(renderer);
+}
+
+bool SDL_RenderPoint(SDL_Renderer *renderer, float x, float y)
+{
+    SDL_FPoint fpoint;
+    fpoint.x = x;
+    fpoint.y = y;
+    return SDL_RenderPoints(renderer, &fpoint, 1);
+}
+
+static bool RenderPointsWithRects(SDL_Renderer *renderer, const SDL_FPoint *fpoints, const int count)
+{
+    bool result;
+    bool isstack;
+    SDL_FRect *frects;
+    int i;
+
+    if (count < 1) {
+        return true;
+    }
+
+    frects = SDL_small_alloc(SDL_FRect, count, &isstack);
+    if (!frects) {
+        return false;
+    }
+
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+    for (i = 0; i < count; ++i) {
+        frects[i].x = fpoints[i].x * scale_x;
+        frects[i].y = fpoints[i].y * scale_y;
+        frects[i].w = scale_x;
+        frects[i].h = scale_y;
+    }
+
+    result = QueueCmdFillRects(renderer, frects, count);
+
+    SDL_small_free(frects, isstack);
+
+    return result;
+}
+
+bool SDL_RenderPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
+{
+    bool result;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (!points) {
+        return SDL_InvalidParamError("SDL_RenderPoints(): points");
+    }
+    if (count < 1) {
+        return true;
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    const SDL_RenderViewState *view = renderer->view;
+    if ((view->current_scale.x != 1.0f) || (view->current_scale.y != 1.0f)) {
+        result = RenderPointsWithRects(renderer, points, count);
+    } else {
+        result = QueueCmdDrawPoints(renderer, points, count);
+    }
+    return result;
+}
+
+bool SDL_RenderLine(SDL_Renderer *renderer, float x1, float y1, float x2, float y2)
+{
+    SDL_FPoint points[2];
+    points[0].x = x1;
+    points[0].y = y1;
+    points[1].x = x2;
+    points[1].y = y2;
+    return SDL_RenderLines(renderer, points, 2);
+}
+
+static bool RenderLineBresenham(SDL_Renderer *renderer, int x1, int y1, int x2, int y2, bool draw_last)
+{
+    const SDL_RenderViewState *view = renderer->view;
+    const int MAX_PIXELS = SDL_max(view->pixel_w, view->pixel_h) * 4;
+    int i, deltax, deltay, numpixels;
+    int d, dinc1, dinc2;
+    int x, xinc1, xinc2;
+    int y, yinc1, yinc2;
+    bool result;
+    bool isstack;
+    SDL_FPoint *points;
+    SDL_Rect viewport;
+
+    /* the backend might clip this further to the clipping rect, but we
+       just want a basic safety against generating millions of points for
+       massive lines. */
+    viewport = view->pixel_viewport;
+    viewport.x = 0;
+    viewport.y = 0;
+    if (!SDL_GetRectAndLineIntersection(&viewport, &x1, &y1, &x2, &y2)) {
+        return true;
+    }
+
+    deltax = SDL_abs(x2 - x1);
+    deltay = SDL_abs(y2 - y1);
+
+    if (deltax >= deltay) {
+        numpixels = deltax + 1;
+        d = (2 * deltay) - deltax;
+        dinc1 = deltay * 2;
+        dinc2 = (deltay - deltax) * 2;
+        xinc1 = 1;
+        xinc2 = 1;
+        yinc1 = 0;
+        yinc2 = 1;
+    } else {
+        numpixels = deltay + 1;
+        d = (2 * deltax) - deltay;
+        dinc1 = deltax * 2;
+        dinc2 = (deltax - deltay) * 2;
+        xinc1 = 0;
+        xinc2 = 1;
+        yinc1 = 1;
+        yinc2 = 1;
+    }
+
+    if (x1 > x2) {
+        xinc1 = -xinc1;
+        xinc2 = -xinc2;
+    }
+    if (y1 > y2) {
+        yinc1 = -yinc1;
+        yinc2 = -yinc2;
+    }
+
+    x = x1;
+    y = y1;
+
+    if (!draw_last) {
+        --numpixels;
+    }
+
+    if (numpixels > MAX_PIXELS) {
+        return SDL_SetError("Line too long (tried to draw %d pixels, max %d)", numpixels, MAX_PIXELS);
+    }
+
+    points = SDL_small_alloc(SDL_FPoint, numpixels, &isstack);
+    if (!points) {
+        return false;
+    }
+    for (i = 0; i < numpixels; ++i) {
+        points[i].x = (float)x;
+        points[i].y = (float)y;
+
+        if (d < 0) {
+            d += dinc1;
+            x += xinc1;
+            y += yinc1;
+        } else {
+            d += dinc2;
+            x += xinc2;
+            y += yinc2;
+        }
+    }
+
+    if ((view->current_scale.x != 1.0f) || (view->current_scale.y != 1.0f)) {
+        result = RenderPointsWithRects(renderer, points, numpixels);
+    } else {
+        result = QueueCmdDrawPoints(renderer, points, numpixels);
+    }
+
+    SDL_small_free(points, isstack);
+
+    return result;
+}
+
+static bool RenderLinesWithRectsF(SDL_Renderer *renderer, const SDL_FPoint *points, const int count)
+{
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+    SDL_FRect *frect;
+    SDL_FRect *frects;
+    int i, nrects = 0;
+    bool result = true;
+    bool isstack;
+    bool drew_line = false;
+    bool draw_last = false;
+
+    frects = SDL_small_alloc(SDL_FRect, count - 1, &isstack);
+    if (!frects) {
+        return false;
+    }
+
+    for (i = 0; i < count - 1; ++i) {
+        bool same_x = (points[i].x == points[i + 1].x);
+        bool same_y = (points[i].y == points[i + 1].y);
+
+        if (i == (count - 2)) {
+            if (!drew_line || points[i + 1].x != points[0].x || points[i + 1].y != points[0].y) {
+                draw_last = true;
+            }
+        } else {
+            if (same_x && same_y) {
+                continue;
+            }
+        }
+        if (same_x) {
+            const float minY = SDL_min(points[i].y, points[i + 1].y);
+            const float maxY = SDL_max(points[i].y, points[i + 1].y);
+
+            frect = &frects[nrects++];
+            frect->x = points[i].x * scale_x;
+            frect->y = minY * scale_y;
+            frect->w = scale_x;
+            frect->h = (maxY - minY + draw_last) * scale_y;
+            if (!draw_last && points[i + 1].y < points[i].y) {
+                frect->y += scale_y;
+            }
+        } else if (same_y) {
+            const float minX = SDL_min(points[i].x, points[i + 1].x);
+            const float maxX = SDL_max(points[i].x, points[i + 1].x);
+
+            frect = &frects[nrects++];
+            frect->x = minX * scale_x;
+            frect->y = points[i].y * scale_y;
+            frect->w = (maxX - minX + draw_last) * scale_x;
+            frect->h = scale_y;
+            if (!draw_last && points[i + 1].x < points[i].x) {
+                frect->x += scale_x;
+            }
+        } else {
+            result &= RenderLineBresenham(renderer, (int)SDL_roundf(points[i].x), (int)SDL_roundf(points[i].y),
+                                              (int)SDL_roundf(points[i + 1].x), (int)SDL_roundf(points[i + 1].y), draw_last);
+        }
+        drew_line = true;
+    }
+
+    if (nrects) {
+        result &= QueueCmdFillRects(renderer, frects, nrects);
+    }
+
+    SDL_small_free(frects, isstack);
+
+    return result;
+}
+
+bool SDL_RenderLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
+{
+    bool result = true;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (!points) {
+        return SDL_InvalidParamError("SDL_RenderLines(): points");
+    }
+    if (count < 2) {
+        return true;
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    SDL_RenderViewState *view = renderer->view;
+    const bool islogical = ((view == &renderer->main_view) && (view->logical_presentation_mode != SDL_LOGICAL_PRESENTATION_DISABLED));
+
+    if (islogical || (renderer->line_method == SDL_RENDERLINEMETHOD_GEOMETRY)) {
+        const float scale_x = view->current_scale.x;
+        const float scale_y = view->current_scale.y;
+        bool isstack1;
+        bool isstack2;
+        float *xy = SDL_small_alloc(float, 4 * 2 * count, &isstack1);
+        int *indices = SDL_small_alloc(int, (4) * 3 * (count - 1) + (2) * 3 * (count), &isstack2);
+
+        if (xy && indices) {
+            int i;
+            float *ptr_xy = xy;
+            int *ptr_indices = indices;
+            const int xy_stride = 2 * sizeof(float);
+            int num_vertices = 4 * count;
+            int num_indices = 0;
+            const int size_indices = 4;
+            int cur_index = -4;
+            const int is_looping = (points[0].x == points[count - 1].x && points[0].y == points[count - 1].y);
+            SDL_FPoint p; // previous point
+            p.x = p.y = 0.0f;
+            /*       p            q
+
+                    0----1------ 4----5
+                    | \  |``\    | \  |
+                    |  \ |   ` `\|  \ |
+                    3----2-------7----6
+            */
+            for (i = 0; i < count; ++i) {
+                SDL_FPoint q = points[i]; // current point
+
+                q.x *= scale_x;
+                q.y *= scale_y;
+
+                *ptr_xy++ = q.x;
+                *ptr_xy++ = q.y;
+                *ptr_xy++ = q.x + scale_x;
+                *ptr_xy++ = q.y;
+                *ptr_xy++ = q.x + scale_x;
+                *ptr_xy++ = q.y + scale_y;
+                *ptr_xy++ = q.x;
+                *ptr_xy++ = q.y + scale_y;
+
+#define ADD_TRIANGLE(i1, i2, i3)        \
+    *ptr_indices++ = cur_index + (i1);  \
+    *ptr_indices++ = cur_index + (i2);  \
+    *ptr_indices++ = cur_index + (i3);  \
+    num_indices += 3;
+
+                // closed polyline, don´t draw twice the point
+                if (i || is_looping == 0) {
+                    ADD_TRIANGLE(4, 5, 6)
+                    ADD_TRIANGLE(4, 6, 7)
+                }
+
+                // first point only, no segment
+                if (i == 0) {
+                    p = q;
+                    cur_index += 4;
+                    continue;
+                }
+
+                // draw segment
+                if (p.y == q.y) {
+                    if (p.x < q.x) {
+                        ADD_TRIANGLE(1, 4, 7)
+                        ADD_TRIANGLE(1, 7, 2)
+                    } else {
+                        ADD_TRIANGLE(5, 0, 3)
+                        ADD_TRIANGLE(5, 3, 6)
+                    }
+                } else if (p.x == q.x) {
+                    if (p.y < q.y) {
+                        ADD_TRIANGLE(2, 5, 4)
+                        ADD_TRIANGLE(2, 4, 3)
+                    } else {
+                        ADD_TRIANGLE(6, 1, 0)
+                        ADD_TRIANGLE(6, 0, 7)
+                    }
+                } else {
+                    if (p.y < q.y) {
+                        if (p.x < q.x) {
+                            ADD_TRIANGLE(1, 5, 4)
+                            ADD_TRIANGLE(1, 4, 2)
+                            ADD_TRIANGLE(2, 4, 7)
+                            ADD_TRIANGLE(2, 7, 3)
+                        } else {
+                            ADD_TRIANGLE(4, 0, 5)
+                            ADD_TRIANGLE(5, 0, 3)
+                            ADD_TRIANGLE(5, 3, 6)
+                            ADD_TRIANGLE(6, 3, 2)
+                        }
+                    } else {
+                        if (p.x < q.x) {
+                            ADD_TRIANGLE(0, 4, 7)
+                            ADD_TRIANGLE(0, 7, 1)
+                            ADD_TRIANGLE(1, 7, 6)
+                            ADD_TRIANGLE(1, 6, 2)
+                        } else {
+                            ADD_TRIANGLE(6, 5, 1)
+                            ADD_TRIANGLE(6, 1, 0)
+                            ADD_TRIANGLE(7, 6, 0)
+                            ADD_TRIANGLE(7, 0, 3)
+                        }
+                    }
+                }
+
+                p = q;
+                cur_index += 4;
+            }
+
+            result = QueueCmdGeometry(renderer, NULL,
+                                      xy, xy_stride, &renderer->color, 0 /* color_stride */, NULL, 0,
+                                      num_vertices, indices, num_indices, size_indices,
+                                      1.0f, 1.0f, SDL_TEXTURE_ADDRESS_CLAMP);
+        }
+
+        SDL_small_free(xy, isstack1);
+        SDL_small_free(indices, isstack2);
+
+    } else if (renderer->line_method == SDL_RENDERLINEMETHOD_POINTS) {
+        result = RenderLinesWithRectsF(renderer, points, count);
+    } else if (view->scale.x != 1.0f || view->scale.y != 1.0f) {  /* we checked for logical scale elsewhere. */
+        result = RenderLinesWithRectsF(renderer, points, count);
+    } else {
+        result = QueueCmdDrawLines(renderer, points, count);
+    }
+
+    return result;
+}
+
+bool SDL_RenderRect(SDL_Renderer *renderer, const SDL_FRect *rect)
+{
+    SDL_FRect frect;
+    SDL_FPoint points[5];
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    // If 'rect' == NULL, then outline the whole surface
+    if (!rect) {
+        GetRenderViewportSize(renderer, &frect);
+        rect = &frect;
+    }
+
+    points[0].x = rect->x;
+    points[0].y = rect->y;
+    points[1].x = rect->x + rect->w - 1;
+    points[1].y = rect->y;
+    points[2].x = rect->x + rect->w - 1;
+    points[2].y = rect->y + rect->h - 1;
+    points[3].x = rect->x;
+    points[3].y = rect->y + rect->h - 1;
+    points[4].x = rect->x;
+    points[4].y = rect->y;
+    return SDL_RenderLines(renderer, points, 5);
+}
+
+bool SDL_RenderRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
+{
+    int i;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (!rects) {
+        return SDL_InvalidParamError("SDL_RenderRects(): rects");
+    }
+    if (count < 1) {
+        return true;
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    for (i = 0; i < count; ++i) {
+        if (!SDL_RenderRect(renderer, &rects[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_FRect *rect)
+{
+    SDL_FRect frect;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    // If 'rect' == NULL, then fill the whole surface
+    if (!rect) {
+        GetRenderViewportSize(renderer, &frect);
+        rect = &frect;
+    }
+    return SDL_RenderFillRects(renderer, rect, 1);
+}
+
+bool SDL_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
+{
+    SDL_FRect *frects;
+    int i;
+    bool result;
+    bool isstack;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (!rects) {
+        return SDL_InvalidParamError("SDL_RenderFillRects(): rects");
+    }
+    if (count < 1) {
+        return true;
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    frects = SDL_small_alloc(SDL_FRect, count, &isstack);
+    if (!frects) {
+        return false;
+    }
+
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+    for (i = 0; i < count; ++i) {
+        frects[i].x = rects[i].x * scale_x;
+        frects[i].y = rects[i].y * scale_y;
+        frects[i].w = rects[i].w * scale_x;
+        frects[i].h = rects[i].h * scale_y;
+    }
+
+    result = QueueCmdFillRects(renderer, frects, count);
+
+    SDL_small_free(frects, isstack);
+
+    return result;
+}
+
+static bool SDL_RenderTextureInternal(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect)
+{
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+    const bool use_rendergeometry = (!renderer->QueueCopy);
+    bool result;
+
+    if (use_rendergeometry) {
+        float xy[8];
+        const int xy_stride = 2 * sizeof(float);
+        float uv[8];
+        const int uv_stride = 2 * sizeof(float);
+        const int num_vertices = 4;
+        const int *indices = rect_index_order;
+        const int num_indices = 6;
+        const int size_indices = 4;
+        float minu, minv, maxu, maxv;
+        float minx, miny, maxx, maxy;
+
+        minu = srcrect->x / texture->w;
+        minv = srcrect->y / texture->h;
+        maxu = (srcrect->x + srcrect->w) / texture->w;
+        maxv = (srcrect->y + srcrect->h) / texture->h;
+
+        minx = dstrect->x;
+        miny = dstrect->y;
+        maxx = dstrect->x + dstrect->w;
+        maxy = dstrect->y + dstrect->h;
+
+        uv[0] = minu;
+        uv[1] = minv;
+        uv[2] = maxu;
+        uv[3] = minv;
+        uv[4] = maxu;
+        uv[5] = maxv;
+        uv[6] = minu;
+        uv[7] = maxv;
+
+        xy[0] = minx;
+        xy[1] = miny;
+        xy[2] = maxx;
+        xy[3] = miny;
+        xy[4] = maxx;
+        xy[5] = maxy;
+        xy[6] = minx;
+        xy[7] = maxy;
+
+        result = QueueCmdGeometry(renderer, texture,
+                                  xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride,
+                                  num_vertices, indices, num_indices, size_indices,
+                                  scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP);
+    } else {
+        const SDL_FRect rect = { dstrect->x * scale_x, dstrect->y * scale_y, dstrect->w * scale_x, dstrect->h * scale_y };
+        result = QueueCmdCopy(renderer, texture, srcrect, &rect);
+    }
+    return result;
+}
+
+bool SDL_RenderTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, const SDL_FRect *dstrect)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (renderer != texture->renderer) {
+        return SDL_SetError("Texture was not created with this renderer");
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    SDL_FRect real_srcrect;
+    real_srcrect.x = 0.0f;
+    real_srcrect.y = 0.0f;
+    real_srcrect.w = (float)texture->w;
+    real_srcrect.h = (float)texture->h;
+    if (srcrect) {
+        if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect) ||
+            real_srcrect.w == 0.0f || real_srcrect.h == 0.0f) {
+            return true;
+        }
+    }
+
+    SDL_FRect full_dstrect;
+    if (!dstrect) {
+        GetRenderViewportSize(renderer, &full_dstrect);
+        dstrect = &full_dstrect;
+    }
+
+    if (texture->native) {
+        texture = texture->native;
+    }
+
+    texture->last_command_generation = renderer->render_command_generation;
+
+    return SDL_RenderTextureInternal(renderer, texture, &real_srcrect, dstrect);
+}
+
+bool SDL_RenderTextureAffine(SDL_Renderer *renderer, SDL_Texture *texture,
+    const SDL_FRect *srcrect, const SDL_FPoint *origin, const SDL_FPoint *right, const SDL_FPoint *down)
+{
+    SDL_FRect real_srcrect;
+    SDL_FRect real_dstrect;
+    bool result;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (renderer != texture->renderer) {
+        return SDL_SetError("Texture was not created with this renderer");
+    }
+    if (!renderer->QueueCopyEx && !renderer->QueueGeometry) {
+        return SDL_SetError("Renderer does not support RenderCopyEx");
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    real_srcrect.x = 0.0f;
+    real_srcrect.y = 0.0f;
+    real_srcrect.w = (float)texture->w;
+    real_srcrect.h = (float)texture->h;
+    if (srcrect) {
+        if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect)) {
+            return true;
+        }
+    }
+
+    GetRenderViewportSize(renderer, &real_dstrect);
+
+    if (texture->native) {
+        texture = texture->native;
+    }
+
+    texture->last_command_generation = renderer->render_command_generation;
+
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+
+    {
+        float xy[8];
+        const int xy_stride = 2 * sizeof(float);
+        float uv[8];
+        const int uv_stride = 2 * sizeof(float);
+        const int num_vertices = 4;
+        const int *indices = rect_index_order;
+        const int num_indices = 6;
+        const int size_indices = 4;
+
+        float minu = real_srcrect.x / texture->w;
+        float minv = real_srcrect.y / texture->h;
+        float maxu = (real_srcrect.x + real_srcrect.w) / texture->w;
+        float maxv = (real_srcrect.y + real_srcrect.h) / texture->h;
+
+        uv[0] = minu;
+        uv[1] = minv;
+        uv[2] = maxu;
+        uv[3] = minv;
+        uv[4] = maxu;
+        uv[5] = maxv;
+        uv[6] = minu;
+        uv[7] = maxv;
+
+        // (minx, miny)
+        if (origin) {
+            xy[0] = origin->x;
+            xy[1] = origin->y;
+        } else {
+            xy[0] = real_dstrect.x;
+            xy[1] = real_dstrect.y;
+        }
+
+        // (maxx, miny)
+        if (right) {
+            xy[2] = right->x;
+            xy[3] = right->y;
+        } else {
+            xy[2] = real_dstrect.x + real_dstrect.w;
+            xy[3] = real_dstrect.y;
+        }
+
+        // (minx, maxy)
+        if (down) {
+            xy[6] = down->x;
+            xy[7] = down->y;
+        } else {
+            xy[6] = real_dstrect.x;
+            xy[7] = real_dstrect.y + real_dstrect.h;
+        }
+
+        // (maxx, maxy)
+        if (origin || right || down) {
+            xy[4] = xy[2] + xy[6] - xy[0];
+            xy[5] = xy[3] + xy[7] - xy[1];
+        } else {
+            xy[4] = real_dstrect.x + real_dstrect.w;
+            xy[5] = real_dstrect.y + real_dstrect.h;
+        }
+
+        result = QueueCmdGeometry(
+            renderer, texture,
+            xy, xy_stride,
+            &texture->color, 0 /* color_stride */,
+            uv, uv_stride,
+            num_vertices, indices, num_indices, size_indices,
+            scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP
+        );
+    }
+    return result;
+}
+
+bool SDL_RenderTextureRotated(SDL_Renderer *renderer, SDL_Texture *texture,
+                      const SDL_FRect *srcrect, const SDL_FRect *dstrect,
+                      const double angle, const SDL_FPoint *center, const SDL_FlipMode flip)
+{
+    SDL_FRect real_srcrect;
+    SDL_FPoint real_center;
+    bool result;
+
+    if (flip == SDL_FLIP_NONE && (int)(angle / 360) == angle / 360) { // fast path when we don't need rotation or flipping
+        return SDL_RenderTexture(renderer, texture, srcrect, dstrect);
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (renderer != texture->renderer) {
+        return SDL_SetError("Texture was not created with this renderer");
+    }
+    if (!renderer->QueueCopyEx && !renderer->QueueGeometry) {
+        return SDL_SetError("Renderer does not support RenderCopyEx");
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    real_srcrect.x = 0.0f;
+    real_srcrect.y = 0.0f;
+    real_srcrect.w = (float)texture->w;
+    real_srcrect.h = (float)texture->h;
+    if (srcrect) {
+        if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect)) {
+            return true;
+        }
+    }
+
+    // We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we?
+    SDL_FRect full_dstrect;
+    if (!dstrect) {
+        GetRenderViewportSize(renderer, &full_dstrect);
+        dstrect = &full_dstrect;
+    }
+
+    if (texture->native) {
+        texture = texture->native;
+    }
+
+    if (center) {
+        real_center = *center;
+    } else {
+        real_center.x = dstrect->w / 2.0f;
+        real_center.y = dstrect->h / 2.0f;
+    }
+
+    texture->last_command_generation = renderer->render_command_generation;
+
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+
+    const bool use_rendergeometry = (!renderer->QueueCopyEx);
+    if (use_rendergeometry) {
+        float xy[8];
+        const int xy_stride = 2 * sizeof(float);
+        float uv[8];
+        const int uv_stride = 2 * sizeof(float);
+        const int num_vertices = 4;
+        const int *indices = rect_index_order;
+        const int num_indices = 6;
+        const int size_indices = 4;
+        float minu, minv, maxu, maxv;
+        float minx, miny, maxx, maxy;
+        float centerx, centery;
+
+        float s_minx, s_miny, s_maxx, s_maxy;
+        float c_minx, c_miny, c_maxx, c_maxy;
+
+        const float radian_angle = (float)((SDL_PI_D * angle) / 180.0);
+        const float s = SDL_sinf(radian_angle);
+        const float c = SDL_cosf(radian_angle);
+
+        minu = real_srcrect.x / texture->w;
+        minv = real_srcrect.y / texture->h;
+        maxu = (real_srcrect.x + real_srcrect.w) / texture->w;
+        maxv = (real_srcrect.y + real_srcrect.h) / texture->h;
+
+        centerx = real_center.x + dstrect->x;
+        centery = real_center.y + dstrect->y;
+
+        if (flip & SDL_FLIP_HORIZONTAL) {
+            minx = dstrect->x + dstrect->w;
+            maxx = dstrect->x;
+        } else {
+            minx = dstrect->x;
+            maxx = dstrect->x + dstrect->w;
+        }
+
+        if (flip & SDL_FLIP_VERTICAL) {
+            miny = dstrect->y + dstrect->h;
+            maxy = dstrect->y;
+        } else {
+            miny = dstrect->y;
+            maxy = dstrect->y + dstrect->h;
+        }
+
+        uv[0] = minu;
+        uv[1] = minv;
+        uv[2] = maxu;
+        uv[3] = minv;
+        uv[4] = maxu;
+        uv[5] = maxv;
+        uv[6] = minu;
+        uv[7] = maxv;
+
+        /* apply rotation with 2x2 matrix ( c -s )
+         *                                ( s  c ) */
+        s_minx = s * (minx - centerx);
+        s_miny = s * (miny - centery);
+        s_maxx = s * (maxx - centerx);
+        s_maxy = s * (maxy - centery);
+        c_minx = c * (minx - centerx);
+        c_miny = c * (miny - centery);
+        c_maxx = c * (maxx - centerx);
+        c_maxy = c * (maxy - centery);
+
+        // (minx, miny)
+        xy[0] = (c_minx - s_miny) + centerx;
+        xy[1] = (s_minx + c_miny) + centery;
+        // (maxx, miny)
+        xy[2] = (c_maxx - s_miny) + centerx;
+        xy[3] = (s_maxx + c_miny) + centery;
+        // (maxx, maxy)
+        xy[4] = (c_maxx - s_maxy) + centerx;
+        xy[5] = (s_maxx + c_maxy) + centery;
+        // (minx, maxy)
+        xy[6] = (c_minx - s_maxy) + centerx;
+        xy[7] = (s_minx + c_maxy) + centery;
+
+        result = QueueCmdGeometry(renderer, texture,
+                                  xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride,
+                                  num_vertices, indices, num_indices, size_indices,
+                                  scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP);
+    } else {
+        result = QueueCmdCopyEx(renderer, texture, &real_srcrect, dstrect, angle, &real_center, flip, scale_x, scale_y);
+    }
+    return result;
+}
+
+static bool SDL_RenderTextureTiled_Wrap(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float scale, const SDL_FRect *dstrect)
+{
+    float xy[8];
+    const int xy_stride = 2 * sizeof(float);
+    float uv[8];
+    const int uv_stride = 2 * sizeof(float);
+    const int num_vertices = 4;
+    const int *indices = rect_index_order;
+    const int num_indices = 6;
+    const int size_indices = 4;
+    float minu, minv, maxu, maxv;
+    float minx, miny, maxx, maxy;
+
+    minu = 0.0f;
+    minv = 0.0f;
+    maxu = dstrect->w / (srcrect->w * scale);
+    maxv = dstrect->h / (srcrect->h * scale);
+
+    minx = dstrect->x;
+    miny = dstrect->y;
+    maxx = dstrect->x + dstrect->w;
+    maxy = dstrect->y + dstrect->h;
+
+    uv[0] = minu;
+    uv[1] = minv;
+    uv[2] = maxu;
+    uv[3] = minv;
+    uv[4] = maxu;
+    uv[5] = maxv;
+    uv[6] = minu;
+    uv[7] = maxv;
+
+    xy[0] = minx;
+    xy[1] = miny;
+    xy[2] = maxx;
+    xy[3] = miny;
+    xy[4] = maxx;
+    xy[5] = maxy;
+    xy[6] = minx;
+    xy[7] = maxy;
+
+    const SDL_RenderViewState *view = renderer->view;
+    return QueueCmdGeometry(renderer, texture,
+                            xy, xy_stride, &texture->color, 0 /* color_stride */, uv, uv_stride,
+                            num_vertices, indices, num_indices, size_indices,
+                            view->current_scale.x, view->current_scale.y, SDL_TEXTURE_ADDRESS_WRAP);
+}
+
+static bool SDL_RenderTextureTiled_Iterate(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float scale, const SDL_FRect *dstrect)
+{
+    float tile_width = srcrect->w * scale;
+    float tile_height = srcrect->h * scale;
+    float float_rows, float_cols;
+    float remaining_w = SDL_modff(dstrect->w / tile_width, &float_cols);
+    float remaining_h = SDL_modff(dstrect->h / tile_height, &float_rows);
+    float remaining_src_w = remaining_w * srcrect->w;
+    float remaining_src_h = remaining_h * srcrect->h;
+    float remaining_dst_w = remaining_w * tile_width;
+    float remaining_dst_h = remaining_h * tile_height;
+    int rows = (int)float_rows;
+    int cols = (int)float_cols;
+    SDL_FRect curr_src, curr_dst;
+
+    SDL_copyp(&curr_src, srcrect);
+    curr_dst.y = dstrect->y;
+    curr_dst.w = tile_width;
+    curr_dst.h = tile_height;
+    for (int y = 0; y < rows; ++y) {
+        curr_dst.x = dstrect->x;
+        for (int x = 0; x < cols; ++x) {
+            if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) {
+                return false;
+            }
+            curr_dst.x += curr_dst.w;
+        }
+        if (remaining_dst_w > 0.0f) {
+            curr_src.w = remaining_src_w;
+            curr_dst.w = remaining_dst_w;
+            if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) {
+                return false;
+            }
+            curr_src.w = srcrect->w;
+            curr_dst.w = tile_width;
+        }
+        curr_dst.y += curr_dst.h;
+    }
+    if (remaining_dst_h > 0.0f) {
+        curr_src.h = remaining_src_h;
+        curr_dst.h = remaining_dst_h;
+        curr_dst.x = dstrect->x;
+        for (int x = 0; x < cols; ++x) {
+            if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) {
+                return false;
+            }
+            curr_dst.x += curr_dst.w;
+        }
+        if (remaining_dst_w > 0.0f) {
+            curr_src.w = remaining_src_w;
+            curr_dst.w = remaining_dst_w;
+            if (!SDL_RenderTextureInternal(renderer, texture, &curr_src, &curr_dst)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool SDL_RenderTextureTiled(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float scale, const SDL_FRect *dstrect)
+{
+    SDL_FRect real_srcrect;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (renderer != texture->renderer) {
+        return SDL_SetError("Texture was not created with this renderer");
+    }
+
+    if (scale <= 0.0f) {
+        return SDL_InvalidParamError("scale");
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    real_srcrect.x = 0.0f;
+    real_srcrect.y = 0.0f;
+    real_srcrect.w = (float)texture->w;
+    real_srcrect.h = (float)texture->h;
+    if (srcrect) {
+        if (!SDL_GetRectIntersectionFloat(srcrect, &real_srcrect, &real_srcrect)) {
+            return true;
+        }
+    }
+
+    SDL_FRect full_dstrect;
+    if (!dstrect) {
+        GetRenderViewportSize(renderer, &full_dstrect);
+        dstrect = &full_dstrect;
+    }
+
+    if (texture->native) {
+        texture = texture->native;
+    }
+
+    texture->last_command_generation = renderer->render_command_generation;
+
+    // See if we can use geometry with repeating texture coordinates
+    if (!renderer->software &&
+        (!srcrect ||
+         (real_srcrect.x == 0.0f && real_srcrect.y == 0.0f &&
+          real_srcrect.w == (float)texture->w && real_srcrect.h == (float)texture->h))) {
+        return SDL_RenderTextureTiled_Wrap(renderer, texture, &real_srcrect, scale, dstrect);
+    } else {
+        return SDL_RenderTextureTiled_Iterate(renderer, texture, &real_srcrect, scale, dstrect);
+    }
+}
+
+bool SDL_RenderTexture9Grid(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_FRect *srcrect, float left_width, float right_width, float top_height, float bottom_height, float scale, const SDL_FRect *dstrect)
+{
+    SDL_FRect full_src, full_dst;
+    SDL_FRect curr_src, curr_dst;
+    float dst_left_width;
+    float dst_right_width;
+    float dst_top_height;
+    float dst_bottom_height;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+    CHECK_TEXTURE_MAGIC(texture, false);
+
+    if (renderer != texture->renderer) {
+        return SDL_SetError("Texture was not created with this renderer");
+    }
+
+    if (!srcrect) {
+        full_src.x = 0;
+        full_src.y = 0;
+        full_src.w = (float)texture->w;
+        full_src.h = (float)texture->h;
+        srcrect = &full_src;
+    }
+
+    if (!dstrect) {
+        GetRenderViewportSize(renderer, &full_dst);
+        dstrect = &full_dst;
+    }
+
+    if (scale <= 0.0f || scale == 1.0f) {
+        dst_left_width = SDL_ceilf(left_width);
+        dst_right_width = SDL_ceilf(right_width);
+        dst_top_height = SDL_ceilf(top_height);
+        dst_bottom_height = SDL_ceilf(bottom_height);
+    } else {
+        dst_left_width = SDL_ceilf(left_width * scale);
+        dst_right_width = SDL_ceilf(right_width * scale);
+        dst_top_height = SDL_ceilf(top_height * scale);
+        dst_bottom_height = SDL_ceilf(bottom_height * scale);
+    }
+
+    // Center
+    curr_src.x = srcrect->x + left_width;
+    curr_src.y = srcrect->y + top_height;
+    curr_src.w = srcrect->w - left_width - right_width;
+    curr_src.h = srcrect->h - top_height - bottom_height;
+    curr_dst.x = dstrect->x + dst_left_width;
+    curr_dst.y = dstrect->y + dst_top_height;
+    curr_dst.w = dstrect->w - dst_left_width - dst_right_width;
+    curr_dst.h = dstrect->h - dst_top_height - dst_bottom_height;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Upper-left corner
+    curr_src.x = srcrect->x;
+    curr_src.y = srcrect->y;
+    curr_src.w = left_width;
+    curr_src.h = top_height;
+    curr_dst.x = dstrect->x;
+    curr_dst.y = dstrect->y;
+    curr_dst.w = dst_left_width;
+    curr_dst.h = dst_top_height;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Upper-right corner
+    curr_src.x = srcrect->x + srcrect->w - right_width;
+    curr_src.w = right_width;
+    curr_dst.x = dstrect->x + dstrect->w - dst_right_width;
+    curr_dst.w = dst_right_width;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Lower-right corner
+    curr_src.y = srcrect->y + srcrect->h - bottom_height;
+    curr_src.h = bottom_height;
+    curr_dst.y = dstrect->y + dstrect->h - dst_bottom_height;
+    curr_dst.h = dst_bottom_height;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Lower-left corner
+    curr_src.x = srcrect->x;
+    curr_src.w = left_width;
+    curr_dst.x = dstrect->x;
+    curr_dst.w = dst_left_width;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Left
+    curr_src.y = srcrect->y + top_height;
+    curr_src.h = srcrect->h - top_height - bottom_height;
+    curr_dst.y = dstrect->y + dst_top_height;
+    curr_dst.h = dstrect->h - dst_top_height - dst_bottom_height;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Right
+    curr_src.x = srcrect->x + srcrect->w - right_width;
+    curr_src.w = right_width;
+    curr_dst.x = dstrect->x + dstrect->w - dst_right_width;
+    curr_dst.w = dst_right_width;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Top
+    curr_src.x = srcrect->x + left_width;
+    curr_src.y = srcrect->y;
+    curr_src.w = srcrect->w - left_width - right_width;
+    curr_src.h = top_height;
+    curr_dst.x = dstrect->x + dst_left_width;
+    curr_dst.y = dstrect->y;
+    curr_dst.w = dstrect->w - dst_left_width - dst_right_width;
+    curr_dst.h = dst_top_height;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    // Bottom
+    curr_src.y = srcrect->y + srcrect->h - bottom_height;
+    curr_src.h = bottom_height;
+    curr_dst.y = dstrect->y + dstrect->h - dst_bottom_height;
+    curr_dst.h = dst_bottom_height;
+    if (!SDL_RenderTexture(renderer, texture, &curr_src, &curr_dst)) {
+        return false;
+    }
+
+    return true;
+}
+
+bool SDL_RenderGeometry(SDL_Renderer *renderer,
+                       SDL_Texture *texture,
+                       const SDL_Vertex *vertices, int num_vertices,
+                       const int *indices, int num_indices)
+{
+    if (vertices) {
+        const float *xy = &vertices->position.x;
+        int xy_stride = sizeof(SDL_Vertex);
+        const SDL_FColor *color = &vertices->color;
+        int color_stride = sizeof(SDL_Vertex);
+        const float *uv = &vertices->tex_coord.x;
+        int uv_stride = sizeof(SDL_Vertex);
+        int size_indices = 4;
+        return SDL_RenderGeometryRaw(renderer, texture, xy, xy_stride, color, color_stride, uv, uv_stride, num_vertices, indices, num_indices, size_indices);
+    } else {
+        return SDL_InvalidParamError("vertices");
+    }
+}
+
+#ifdef SDL_VIDEO_RENDER_SW
+static int remap_one_indice(
+    int prev,
+    int k,
+    SDL_Texture *texture,
+    const float *xy, int xy_stride,
+    const SDL_FColor *color, int color_stride,
+    const float *uv, int uv_stride)
+{
+    const float *xy0_, *xy1_, *uv0_, *uv1_;
+    const SDL_FColor *col0_, *col1_;
+    xy0_ = (const float *)((const char *)xy + prev * xy_stride);
+    xy1_ = (const float *)((const char *)xy + k * xy_stride);
+    if (xy0_[0] != xy1_[0]) {
+        return k;
+    }
+    if (xy0_[1] != xy1_[1]) {
+        return k;
+    }
+    if (texture) {
+        uv0_ = (const float *)((const char *)uv + prev * uv_stride);
+        uv1_ = (const float *)((const char *)uv + k * uv_stride);
+        if (uv0_[0] != uv1_[0]) {
+            return k;
+        }
+        if (uv0_[1] != uv1_[1]) {
+            return k;
+        }
+    }
+    col0_ = (const SDL_FColor *)((const char *)color + prev * color_stride);
+    col1_ = (const SDL_FColor *)((const char *)color + k * color_stride);
+
+    if (SDL_memcmp(col0_, col1_, sizeof(*col0_)) != 0) {
+        return k;
+    }
+
+    return prev;
+}
+
+static int remap_indices(
+    int prev[3],
+    int k,
+    SDL_Texture *texture,
+    const float *xy, int xy_stride,
+    const SDL_FColor *color, int color_stride,
+    const float *uv, int uv_stride)
+{
+    int i;
+    if (prev[0] == -1) {
+        return k;
+    }
+
+    for (i = 0; i < 3; i++) {
+        int new_k = remap_one_indice(prev[i], k, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+        if (new_k != k) {
+            return new_k;
+        }
+    }
+    return k;
+}
+
+#define DEBUG_SW_RENDER_GEOMETRY 0
+// For the software renderer, try to reinterpret triangles as SDL_Rect
+static bool SDLCALL SDL_SW_RenderGeometryRaw(SDL_Renderer *renderer,
+                                            SDL_Texture *texture,
+                                            const float *xy, int xy_stride,
+                                            const SDL_FColor *color, int color_stride,
+                                            const float *uv, int uv_stride,
+                                            int num_vertices,
+                                            const void *indices, int num_indices, int size_indices)
+{
+    int i;
+    bool result = true;
+    int count = indices ? num_indices : num_vertices;
+    int prev[3]; // Previous triangle vertex indices
+    float texw = 0.0f, texh = 0.0f;
+    SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
+    float r = 0, g = 0, b = 0, a = 0;
+    const SDL_RenderViewState *view = renderer->view;
+    const float scale_x = view->current_scale.x;
+    const float scale_y = view->current_scale.y;
+
+    // Save
+    SDL_GetRenderDrawBlendMode(renderer, &blendMode);
+    SDL_GetRenderDrawColorFloat(renderer, &r, &g, &b, &a);
+
+    if (texture) {
+        SDL_GetTextureSize(texture, &texw, &texh);
+    }
+
+    prev[0] = -1;
+    prev[1] = -1;
+    prev[2] = -1;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i += 3) {
+        int k0, k1, k2; // Current triangle indices
+        int is_quad = 1;
+#if DEBUG_SW_RENDER_GEOMETRY
+        int is_uniform = 1;
+        int is_rectangle = 1;
+#endif
+        int A = -1;  // Top left vertex
+        int B = -1;  // Bottom right vertex
+        int C = -1;  // Third vertex of current triangle
+        int C2 = -1; // Last, vertex of previous triangle
+
+        if (size_indices == 4) {
+            k0 = ((const Uint32 *)indices)[i];
+            k1 = ((const Uint32 *)indices)[i + 1];
+            k2 = ((const Uint32 *)indices)[i + 2];
+        } else if (size_indices == 2) {
+            k0 = ((const Uint16 *)indices)[i];
+            k1 = ((const Uint16 *)indices)[i + 1];
+            k2 = ((const Uint16 *)indices)[i + 2];
+        } else if (size_indices == 1) {
+            k0 = ((const Uint8 *)indices)[i];
+            k1 = ((const Uint8 *)indices)[i + 1];
+            k2 = ((const Uint8 *)indices)[i + 2];
+        } else {
+            /* Vertices were not provided by indices. Maybe some are duplicated.
+             * We try to indentificate the duplicates by comparing with the previous three vertices */
+            k0 = remap_indices(prev, i, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+            k1 = remap_indices(prev, i + 1, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+            k2 = remap_indices(prev, i + 2, texture, xy, xy_stride, color, color_stride, uv, uv_stride);
+        }
+
+        if (prev[0] == -1) {
+            prev[0] = k0;
+            prev[1] = k1;
+            prev[2] = k2;
+            continue;
+        }
+
+        /* Two triangles forming a quadialateral,
+         * prev and current triangles must have exactly 2 common vertices */
+        {
+            int cnt = 0, j = 3;
+            while (j--) {
+                int p = prev[j];
+                if (p == k0 || p == k1 || p == k2) {
+                    cnt++;
+                }
+            }
+            is_quad = (cnt == 2);
+        }
+
+        // Identify vertices
+        if (is_quad) {
+            const float *xy0_, *xy1_, *xy2_;
+            float x0, x1, x2;
+            float y0, y1, y2;
+            xy0_ = (const float *)((const char *)xy + k0 * xy_stride);
+            xy1_ = (const float *)((const char *)xy + k1 * xy_stride);
+            xy2_ = (const float *)((const char *)xy + k2 * xy_stride);
+            x0 = xy0_[0];
+            y0 = xy0_[1];
+            x1 = xy1_[0];
+            y1 = xy1_[1];
+            x2 = xy2_[0];
+            y2 = xy2_[1];
+
+            // Find top-left
+            if (x0 <= x1 && y0 <= y1) {
+                if (x0 <= x2 && y0 <= y2) {
+                    A = k0;
+                } else {
+                    A = k2;
+                }
+            } else {
+                if (x1 <= x2 && y1 <= y2) {
+                    A = k1;
+                } else {
+                    A = k2;
+                }
+            }
+
+            // Find bottom-right
+            if (x0 >= x1 && y0 >= y1) {
+                if (x0 >= x2 && y0 >= y2) {
+                    B = k0;
+                } else {
+                    B = k2;
+                }
+            } else {
+                if (x1 >= x2 && y1 >= y2) {
+                    B = k1;
+                } else {
+                    B = k2;
+                }
+            }
+
+            // Find C
+            if (k0 != A && k0 != B) {
+                C = k0;
+            } else if (k1 != A && k1 != B) {
+                C = k1;
+            } else {
+                C = k2;
+            }
+
+            // Find C2
+            if (prev[0] != A && prev[0] != B) {
+                C2 = prev[0];
+            } else if (prev[1] != A && prev[1] != B) {
+                C2 = prev[1];
+            } else {
+                C2 = prev[2];
+            }
+
+            xy0_ = (const float *)((const char *)xy + A * xy_stride);
+            xy1_ = (const float *)((const char *)xy + B * xy_stride);
+            xy2_ = (const float *)((const char *)xy + C * xy_stride);
+            x0 = xy0_[0];
+            y0 = xy0_[1];
+            x1 = xy1_[0];
+            y1 = xy1_[1];
+            x2 = xy2_[0];
+            y2 = xy2_[1];
+
+            // Check if triangle A B C is rectangle
+            if ((x0 == x2 && y1 == y2) || (y0 == y2 && x1 == x2)) {
+                // ok
+            } else {
+                is_quad = 0;
+#if DEBUG_SW_RENDER_GEOMETRY
+                is_rectangle = 0;
+#endif
+            }
+
+            xy2_ = (const float *)((const char *)xy + C2 * xy_stride);
+            x2 = xy2_[0];
+            y2 = xy2_[1];
+
+            // Check if triangle A B C2 is rectangle
+            if ((x0 == x2 && y1 == y2) || (y0 == y2 && x1 == x2)) {
+                // ok
+            } else {
+                is_quad = 0;
+#if DEBUG_SW_RENDER_GEOMETRY
+                is_rectangle = 0;
+#endif
+            }
+        }
+
+        // Check if uniformly colored
+        if (is_quad) {
+            const SDL_FColor *col0_ = (const SDL_FColor *)((const char *)color + A * color_stride);
+            const SDL_FColor *col1_ = (const SDL_FColor *)((const char *)color + B * color_stride);
+            const SDL_FColor *col2_ = (const SDL_FColor *)((const char *)color + C * color_stride);
+            const SDL_FColor *col3_ = (const SDL_FColor *)((const char *)color + C2 * color_stride);
+            if (SDL_memcmp(col0_, col1_, sizeof(*col0_)) == 0 &&
+                SDL_memcmp(col0_, col2_, sizeof(*col0_)) == 0 &&
+                SDL_memcmp(col0_, col3_, sizeof(*col0_)) == 0) {
+                // ok
+            } else {
+                is_quad = 0;
+#if DEBUG_SW_RENDER_GEOMETRY
+                is_uniform = 0;
+#endif
+            }
+        }
+
+        // Start rendering rect
+        if (is_quad) {
+            SDL_FRect s;
+            SDL_FRect d;
+            const float *xy0_, *xy1_, *uv0_, *uv1_;
+            const SDL_FColor *col0_ = (const SDL_FColor *)((const char *)color + k0 * color_stride);
+
+            xy0_ = (const float *)((const char *)xy + A * xy_stride);
+            xy1_ = (const float *)((const char *)xy + B * xy_stride);
+
+            if (texture) {
+                uv0_ = (const float *)((const char *)uv + A * uv_stride);
+                uv1_ = (const float *)((const char *)uv + B * uv_stride);
+                s.x = uv0_[0] * texw;
+                s.y = uv0_[1] * texh;
+                s.w = uv1_[0] * texw - s.x;
+                s.h = uv1_[1] * texh - s.y;
+            } else {
+                s.x = s.y = s.w = s.h = 0;
+            }
+
+            d.x = xy0_[0];
+            d.y = xy0_[1];
+            d.w = xy1_[0] - d.x;
+            d.h = xy1_[1] - d.y;
+
+            // Rect + texture
+            if (texture && s.w != 0 && s.h != 0) {
+                SDL_SetTextureAlphaModFloat(texture, col0_->a);
+                SDL_SetTextureColorModFloat(texture, col0_->r, col0_->g, col0_->b);
+                if (s.w > 0 && s.h > 0) {
+                    SDL_RenderTexture(renderer, texture, &s, &d);
+                } else {
+                    int flags = 0;
+                    if (s.w < 0) {
+                        flags |= SDL_FLIP_HORIZONTAL;
+                        s.w *= -1;
+                        s.x -= s.w;
+                    }
+                    if (s.h < 0) {
+                        flags |= SDL_FLIP_VERTICAL;
+                        s.h *= -1;
+                        s.y -= s.h;
+                    }
+                    SDL_RenderTextureRotated(renderer, texture, &s, &d, 0, NULL, (SDL_FlipMode)flags);
+                }
+
+#if DEBUG_SW_RENDER_GEOMETRY
+                SDL_Log("Rect-COPY: RGB %f %f %f - Alpha:%f - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_->r, col0_->g, col0_->b, col0_->a,
+                        (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h);
+#endif
+            } else if (d.w != 0.0f && d.h != 0.0f) { // Rect, no texture
+                SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+                SDL_SetRenderDrawColorFloat(renderer, col0_->r, col0_->g, col0_->b, col0_->a);
+                SDL_RenderFillRect(renderer, &d);
+#if DEBUG_SW_RENDER_GEOMETRY
+                SDL_Log("Rect-FILL: RGB %f %f %f - Alpha:%f - texture=%p: dst (%f, %f, %f x %f)", col0_->r, col0_->g, col0_->b, col0_->a,
+                        (void *)texture, d.x, d.y, d.w, d.h);
+            } else {
+                SDL_Log("Rect-DISMISS: RGB %f %f %f - Alpha:%f - texture=%p: src=(%d,%d, %d x %d) dst (%f, %f, %f x %f)", col0_->r, col0_->g, col0_->b, col0_->a,
+                        (void *)texture, s.x, s.y, s.w, s.h, d.x, d.y, d.w, d.h);
+#endif
+            }
+
+            prev[0] = -1;
+        } else {
+            // Render triangles
+            if (prev[0] != -1) {
+#if DEBUG_SW_RENDER_GEOMETRY
+                SDL_Log("Triangle %d %d %d - is_uniform:%d is_rectangle:%d", prev[0], prev[1], prev[2], is_uniform, is_rectangle);
+#endif
+                result = QueueCmdGeometry(renderer, texture,
+                                          xy, xy_stride, color, color_stride, uv, uv_stride,
+                                          num_vertices, prev, 3, 4,
+                                          scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP);
+                if (!result) {
+                    goto end;
+                }
+            }
+
+            prev[0] = k0;
+            prev[1] = k1;
+            prev[2] = k2;
+        }
+    } // End for (), next triangle
+
+    if (prev[0] != -1) {
+        // flush the last triangle
+#if DEBUG_SW_RENDER_GEOMETRY
+        SDL_Log("Last triangle %d %d %d", prev[0], prev[1], prev[2]);
+#endif
+        result = QueueCmdGeometry(renderer, texture,
+                                  xy, xy_stride, color, color_stride, uv, uv_stride,
+                                  num_vertices, prev, 3, 4,
+                                  scale_x, scale_y, SDL_TEXTURE_ADDRESS_CLAMP);
+        if (!result) {
+            goto end;
+        }
+    }
+
+end:
+    // Restore
+    SDL_SetRenderDrawBlendMode(renderer, blendMode);
+    SDL_SetRenderDrawColorFloat(renderer, r, g, b, a);
+
+    return result;
+}
+#endif // SDL_VIDEO_RENDER_SW
+
+bool SDL_RenderGeometryRaw(SDL_Renderer *renderer,
+                          SDL_Texture *texture,
+                          const float *xy, int xy_stride,
+                          const SDL_FColor *color, int color_stride,
+                          const float *uv, int uv_stride,
+                          int num_vertices,
+                          const void *indices, int num_indices, int size_indices)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    SDL_TextureAddressMode texture_address_mode;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (!renderer->QueueGeometry) {
+        return SDL_Unsupported();
+    }
+
+    if (texture) {
+        CHECK_TEXTURE_MAGIC(texture, false);
+
+        if (renderer != texture->renderer) {
+            return SDL_SetError("Texture was not created with this renderer");
+        }
+    }
+
+    if (!xy) {
+        return SDL_InvalidParamError("xy");
+    }
+
+    if (!color) {
+        return SDL_InvalidParamError("color");
+    }
+
+    if (texture && !uv) {
+        return SDL_InvalidParamError("uv");
+    }
+
+    if (count % 3 != 0) {
+        return SDL_InvalidParamError(indices ? "num_indices" : "num_vertices");
+    }
+
+    if (indices) {
+        if (size_indices != 1 && size_indices != 2 && size_indices != 4) {
+            return SDL_InvalidParamError("size_indices");
+        }
+    } else {
+        size_indices = 0;
+    }
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't draw while we're hidden
+    if (renderer->hidden) {
+        return true;
+    }
+#endif
+
+    if (num_vertices < 3) {
+        return true;
+    }
+
+    if (texture && texture->native) {
+        texture = texture->native;
+    }
+
+    texture_address_mode = renderer->texture_address_mode;
+    if (texture_address_mode == SDL_TEXTURE_ADDRESS_AUTO && texture) {
+        texture_address_mode = SDL_TEXTURE_ADDRESS_CLAMP;
+        for (i = 0; i < num_vertices; ++i) {
+            const float *uv_ = (const float *)((const char *)uv + i * uv_stride);
+            float u = uv_[0];
+            float v = uv_[1];
+            if (u < 0.0f || v < 0.0f || u > 1.0f || v > 1.0f) {
+                texture_address_mode = SDL_TEXTURE_ADDRESS_WRAP;
+                break;
+            }
+        }
+    }
+
+    if (indices) {
+        for (i = 0; i < num_indices; ++i) {
+            int j;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else {
+                j = ((const Uint8 *)indices)[i];
+            }
+            if (j < 0 || j >= num_vertices) {
+                return SDL_SetError("Values of 'indices' out of bounds");
+            }
+        }
+    }
+
+    if (texture) {
+        texture->last_command_generation = renderer->render_command_generation;
+    }
+
+    // For the software renderer, try to reinterpret triangles as SDL_Rect
+#ifdef SDL_VIDEO_RENDER_SW
+    if (renderer->software && texture_address_mode == SDL_TEXTURE_ADDRESS_CLAMP) {
+        return SDL_SW_RenderGeometryRaw(renderer, texture,
+                                        xy, xy_stride, color, color_stride, uv, uv_stride, num_vertices,
+                                        indices, num_indices, size_indices);
+    }
+#endif
+
+    const SDL_RenderViewState *view = renderer->view;
+    return QueueCmdGeometry(renderer, texture,
+                            xy, xy_stride, color, color_stride, uv, uv_stride,
+                            num_vertices, indices, num_indices, size_indices,
+                            view->current_scale.x, view->current_scale.y,
+                            texture_address_mode);
+}
+
+SDL_Surface *SDL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
+    if (!renderer->RenderReadPixels) {
+        SDL_Unsupported();
+        return NULL;
+    }
+
+    FlushRenderCommands(renderer); // we need to render before we read the results.
+
+    SDL_Rect real_rect = renderer->view->pixel_viewport;
+
+    if (rect) {
+        if (!SDL_GetRectIntersection(rect, &real_rect, &real_rect)) {
+            SDL_SetError("Can't read outside the current viewport");
+            return NULL;
+        }
+    }
+
+    SDL_Surface *surface = renderer->RenderReadPixels(renderer, &real_rect);
+    if (surface) {
+        SDL_PropertiesID props = SDL_GetSurfaceProperties(surface);
+
+        if (renderer->target) {
+            SDL_Texture *target = renderer->target;
+            SDL_Texture *parent = SDL_GetPointerProperty(SDL_GetTextureProperties(target), SDL_PROP_TEXTURE_PARENT_POINTER, NULL);
+            SDL_PixelFormat expected_format = (parent ? parent->format : target->format);
+
+            SDL_SetFloatProperty(props, SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT, target->SDR_white_point);
+            SDL_SetFloatProperty(props, SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT, target->HDR_headroom);
+
+            // Set the expected surface format
+            if ((surface->format == SDL_PIXELFORMAT_ARGB8888 && expected_format == SDL_PIXELFORMAT_XRGB8888) ||
+                (surface->format == SDL_PIXELFORMAT_RGBA8888 && expected_format == SDL_PIXELFORMAT_RGBX8888) ||
+                (surface->format == SDL_PIXELFORMAT_ABGR8888 && expected_format == SDL_PIXELFORMAT_XBGR8888) ||
+                (surface->format == SDL_PIXELFORMAT_BGRA8888 && expected_format == SDL_PIXELFORMAT_BGRX8888)) {
+                surface->format = expected_format;
+                surface->fmt = SDL_GetPixelFormatDetails(expected_format);
+            }
+        } else {
+            SDL_SetFloatProperty(props, SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT, renderer->SDR_white_point);
+            SDL_SetFloatProperty(props, SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT, renderer->HDR_headroom);
+        }
+    }
+    return surface;
+}
+
+static void SDL_RenderApplyWindowShape(SDL_Renderer *renderer)
+{
+    SDL_Surface *shape = (SDL_Surface *)SDL_GetPointerProperty(SDL_GetWindowProperties(renderer->window), SDL_PROP_WINDOW_SHAPE_POINTER, NULL);
+    if (shape != renderer->shape_surface) {
+        if (renderer->shape_texture) {
+            SDL_DestroyTexture(renderer->shape_texture);
+            renderer->shape_texture = NULL;
+        }
+
+        if (shape) {
+            // There's nothing we can do if this fails, so just keep on going
+            renderer->shape_texture = SDL_CreateTextureFromSurface(renderer, shape);
+
+            SDL_SetTextureBlendMode(renderer->shape_texture,
+                SDL_ComposeCustomBlendMode(
+                    SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD,
+                    SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD));
+        }
+        renderer->shape_surface = shape;
+    }
+
+    if (renderer->shape_texture) {
+        SDL_RenderTexture(renderer, renderer->shape_texture, NULL, NULL);
+    }
+}
+
+static void SDL_SimulateRenderVSync(SDL_Renderer *renderer)
+{
+    Uint64 now, elapsed;
+    const Uint64 interval = renderer->simulate_vsync_interval_ns;
+
+    if (!interval) {
+        // We can't do sub-ns delay, so just return here
+        return;
+    }
+
+    now = SDL_GetTicksNS();
+    elapsed = (now - renderer->last_present);
+    if (elapsed < interval) {
+        Uint64 duration = (interval - elapsed);
+        SDL_DelayPrecise(duration);
+        now = SDL_GetTicksNS();
+    }
+
+    elapsed = (now - renderer->last_present);
+    if (!renderer->last_present || elapsed > SDL_MS_TO_NS(1000)) {
+        // It's been too long, reset the presentation timeline
+        renderer->last_present = now;
+    } else {
+        renderer->last_present += (elapsed / interval) * interval;
+    }
+}
+
+bool SDL_RenderPresent(SDL_Renderer *renderer)
+{
+    bool presented = true;
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    SDL_Texture *target = renderer->target;
+    if (target) {
+        SDL_SetRenderTarget(renderer, NULL);
+    }
+
+    SDL_RenderLogicalPresentation(renderer);
+
+    if (renderer->transparent_window) {
+        SDL_RenderApplyWindowShape(renderer);
+    }
+
+    FlushRenderCommands(renderer); // time to send everything to the GPU!
+
+#if DONT_DRAW_WHILE_HIDDEN
+    // Don't present while we're hidden
+    if (renderer->hidden) {
+        presented = false;
+    } else
+#endif
+    if (!renderer->RenderPresent(renderer)) {
+        presented = false;
+    }
+
+    if (target) {
+        SDL_SetRenderTarget(renderer, target);
+    }
+
+    if (renderer->simulate_vsync ||
+        (!presented && renderer->wanted_vsync)) {
+        SDL_SimulateRenderVSync(renderer);
+    }
+    return true;
+}
+
+static void SDL_DestroyTextureInternal(SDL_Texture *texture, bool is_destroying)
+{
+    SDL_Renderer *renderer;
+
+    SDL_DestroyProperties(texture->props);
+
+    renderer = texture->renderer;
+    if (is_destroying) {
+        // Renderer get destroyed, avoid to queue more commands
+    } else {
+        if (texture == renderer->target) {
+            SDL_SetRenderTarget(renderer, NULL); // implies command queue flush
+        } else {
+            FlushRenderCommandsIfTextureNeeded(texture);
+        }
+    }
+
+    SDL_SetObjectValid(texture, SDL_OBJECT_TYPE_TEXTURE, false);
+
+    if (texture->next) {
+        texture->next->prev = texture->prev;
+    }
+    if (texture->prev) {
+        texture->prev->next = texture->next;
+    } else {
+        renderer->textures = texture->next;
+    }
+
+    if (texture->native) {
+        SDL_DestroyTextureInternal(texture->native, is_destroying);
+    }
+#ifdef SDL_HAVE_YUV
+    if (texture->yuv) {
+        SDL_SW_DestroyYUVTexture(texture->yuv);
+    }
+#endif
+    SDL_free(texture->pixels);
+
+    renderer->DestroyTexture(renderer, texture);
+
+    SDL_DestroySurface(texture->locked_surface);
+    texture->locked_surface = NULL;
+
+    SDL_free(texture);
+}
+
+void SDL_DestroyTexture(SDL_Texture *texture)
+{
+    CHECK_TEXTURE_MAGIC(texture, );
+
+    if (--texture->refcount > 0) {
+        return;
+    }
+
+    SDL_DestroyTextureInternal(texture, false /* is_destroying */);
+}
+
+static void SDL_DiscardAllCommands(SDL_Renderer *renderer)
+{
+    SDL_RenderCommand *cmd;
+
+    if (renderer->render_commands_tail) {
+        renderer->render_commands_tail->next = renderer->render_commands_pool;
+        cmd = renderer->render_commands;
+    } else {
+        cmd = renderer->render_commands_pool;
+    }
+
+    renderer->render_commands_pool = NULL;
+    renderer->render_commands_tail = NULL;
+    renderer->render_commands = NULL;
+    renderer->vertex_data_used = 0;
+
+    while (cmd) {
+        SDL_RenderCommand *next = cmd->next;
+        SDL_free(cmd);
+        cmd = next;
+    }
+}
+
+void SDL_DestroyRendererWithoutFreeing(SDL_Renderer *renderer)
+{
+    SDL_assert(renderer != NULL);
+    SDL_assert(!renderer->destroyed);
+
+    renderer->destroyed = true;
+
+    SDL_RemoveWindowEventWatch(SDL_WINDOW_EVENT_WATCH_NORMAL, SDL_RendererEventWatch, renderer);
+
+    if (renderer->window) {
+        SDL_PropertiesID props = SDL_GetWindowProperties(renderer->window);
+        if (SDL_GetPointerProperty(props, SDL_PROP_WINDOW_RENDERER_POINTER, NULL) == renderer) {
+            SDL_ClearProperty(props, SDL_PROP_WINDOW_RENDERER_POINTER);
+        }
+        SDL_RemoveWindowRenderer(renderer->window, renderer);
+    }
+
+    if (renderer->software) {
+        // Make sure all drawing to a surface is complete
+        FlushRenderCommands(renderer);
+    }
+    SDL_DiscardAllCommands(renderer);
+
+    if (renderer->debug_char_texture_atlas) {
+        SDL_DestroyTexture(renderer->debug_char_texture_atlas);
+        renderer->debug_char_texture_atlas = NULL;
+    }
+
+    // Free existing textures for this renderer
+    while (renderer->textures) {
+        SDL_Texture *tex = renderer->textures;
+        SDL_DestroyTextureInternal(renderer->textures, true /* is_destroying */);
+        SDL_assert(tex != renderer->textures); // satisfy static analysis.
+    }
+
+    // Clean up renderer-specific resources
+    if (renderer->DestroyRenderer) {
+        renderer->DestroyRenderer(renderer);
+    }
+
+    if (renderer->target_mutex) {
+        SDL_DestroyMutex(renderer->target_mutex);
+        renderer->target_mutex = NULL;
+    }
+    if (renderer->vertex_data) {
+        SDL_free(renderer->vertex_data);
+        renderer->vertex_data = NULL;
+    }
+    if (renderer->texture_formats) {
+        SDL_free(renderer->texture_formats);
+        renderer->texture_formats = NULL;
+    }
+    if (renderer->props) {
+        SDL_DestroyProperties(renderer->props);
+        renderer->props = 0;
+    }
+}
+
+void SDL_DestroyRenderer(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC_BUT_NOT_DESTROYED_FLAG(renderer,);
+
+    // if we've already destroyed the renderer through SDL_DestroyWindow, we just need
+    // to free the renderer pointer. This lets apps destroy the window and renderer
+    // in either order.
+    if (!renderer->destroyed) {
+        SDL_DestroyRendererWithoutFreeing(renderer);
+    }
+
+    SDL_Renderer *curr = SDL_renderers;
+    SDL_Renderer *prev = NULL;
+    while (curr) {
+        if (curr == renderer) {
+            if (prev) {
+                prev->next = renderer->next;
+            } else {
+                SDL_renderers = renderer->next;
+            }
+            break;
+        }
+        prev = curr;
+        curr = curr->next;
+    }
+
+    SDL_SetObjectValid(renderer, SDL_OBJECT_TYPE_RENDERER, false);  // It's no longer magical...
+
+    SDL_free(renderer);
+}
+
+void *SDL_GetRenderMetalLayer(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
+    if (renderer->GetMetalLayer) {
+        FlushRenderCommands(renderer); // in case the app is going to mess with it.
+        return renderer->GetMetalLayer(renderer);
+    }
+    return NULL;
+}
+
+void *SDL_GetRenderMetalCommandEncoder(SDL_Renderer *renderer)
+{
+    CHECK_RENDERER_MAGIC(renderer, NULL);
+
+    if (renderer->GetMetalCommandEncoder) {
+        FlushRenderCommands(renderer); // in case the app is going to mess with it.
+        return renderer->GetMetalCommandEncoder(renderer);
+    }
+    return NULL;
+}
+
+bool SDL_AddVulkanRenderSemaphores(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (!renderer->AddVulkanRenderSemaphores) {
+        return SDL_Unsupported();
+    }
+    return renderer->AddVulkanRenderSemaphores(renderer, wait_stage_mask, wait_semaphore, signal_semaphore);
+}
+
+static SDL_BlendMode SDL_GetShortBlendMode(SDL_BlendMode blendMode)
+{
+    if (blendMode == SDL_BLENDMODE_NONE_FULL) {
+        return SDL_BLENDMODE_NONE;
+    }
+    if (blendMode == SDL_BLENDMODE_BLEND_FULL) {
+        return SDL_BLENDMODE_BLEND;
+    }
+    if (blendMode == SDL_BLENDMODE_BLEND_PREMULTIPLIED_FULL) {
+        return SDL_BLENDMODE_BLEND_PREMULTIPLIED;
+    }
+    if (blendMode == SDL_BLENDMODE_ADD_FULL) {
+        return SDL_BLENDMODE_ADD;
+    }
+    if (blendMode == SDL_BLENDMODE_ADD_PREMULTIPLIED_FULL) {
+        return SDL_BLENDMODE_ADD_PREMULTIPLIED;
+    }
+    if (blendMode == SDL_BLENDMODE_MOD_FULL) {
+        return SDL_BLENDMODE_MOD;
+    }
+    if (blendMode == SDL_BLENDMODE_MUL_FULL) {
+        return SDL_BLENDMODE_MUL;
+    }
+    return blendMode;
+}
+
+static SDL_BlendMode SDL_GetLongBlendMode(SDL_BlendMode blendMode)
+{
+    if (blendMode == SDL_BLENDMODE_NONE) {
+        return SDL_BLENDMODE_NONE_FULL;
+    }
+    if (blendMode == SDL_BLENDMODE_BLEND) {
+        return SDL_BLENDMODE_BLEND_FULL;
+    }
+    if (blendMode == SDL_BLENDMODE_BLEND_PREMULTIPLIED) {
+        return SDL_BLENDMODE_BLEND_PREMULTIPLIED_FULL;
+    }
+    if (blendMode == SDL_BLENDMODE_ADD) {
+        return SDL_BLENDMODE_ADD_FULL;
+    }
+    if (blendMode == SDL_BLENDMODE_ADD_PREMULTIPLIED) {
+        return SDL_BLENDMODE_ADD_PREMULTIPLIED_FULL;
+    }
+    if (blendMode == SDL_BLENDMODE_MOD) {
+        return SDL_BLENDMODE_MOD_FULL;
+    }
+    if (blendMode == SDL_BLENDMODE_MUL) {
+        return SDL_BLENDMODE_MUL_FULL;
+    }
+    return blendMode;
+}
+
+SDL_BlendMode SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor, SDL_BlendFactor dstColorFactor,
+                                         SDL_BlendOperation colorOperation,
+                                         SDL_BlendFactor srcAlphaFactor, SDL_BlendFactor dstAlphaFactor,
+                                         SDL_BlendOperation alphaOperation)
+{
+    SDL_BlendMode blendMode = SDL_COMPOSE_BLENDMODE(srcColorFactor, dstColorFactor, colorOperation,
+                                                    srcAlphaFactor, dstAlphaFactor, alphaOperation);
+    return SDL_GetShortBlendMode(blendMode);
+}
+
+SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
+{
+    blendMode = SDL_GetLongBlendMode(blendMode);
+    return (SDL_BlendFactor)(((Uint32)blendMode >> 4) & 0xF);
+}
+
+SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
+{
+    blendMode = SDL_GetLongBlendMode(blendMode);
+    return (SDL_BlendFactor)(((Uint32)blendMode >> 8) & 0xF);
+}
+
+SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
+{
+    blendMode = SDL_GetLongBlendMode(blendMode);
+    return (SDL_BlendOperation)(((Uint32)blendMode >> 0) & 0xF);
+}
+
+SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
+{
+    blendMode = SDL_GetLongBlendMode(blendMode);
+    return (SDL_BlendFactor)(((Uint32)blendMode >> 20) & 0xF);
+}
+
+SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
+{
+    blendMode = SDL_GetLongBlendMode(blendMode);
+    return (SDL_BlendFactor)(((Uint32)blendMode >> 24) & 0xF);
+}
+
+SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
+{
+    blendMode = SDL_GetLongBlendMode(blendMode);
+    return (SDL_BlendOperation)(((Uint32)blendMode >> 16) & 0xF);
+}
+
+bool SDL_SetRenderVSync(SDL_Renderer *renderer, int vsync)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    renderer->wanted_vsync = vsync ? true : false;
+
+    // for the software renderer, forward the call to the WindowTexture renderer
+#ifdef SDL_VIDEO_RENDER_SW
+    if (renderer->software) {
+        if (!renderer->window) {
+            if (!vsync) {
+                return true;
+            } else {
+                return SDL_Unsupported();
+            }
+        }
+        if (SDL_SetWindowTextureVSync(NULL, renderer->window, vsync)) {
+            renderer->simulate_vsync = false;
+            return true;
+        }
+    }
+#endif
+
+    if (!renderer->SetVSync) {
+        switch (vsync) {
+        case 0:
+            renderer->simulate_vsync = false;
+            break;
+        case 1:
+            renderer->simulate_vsync = true;
+            break;
+        default:
+            return SDL_Unsupported();
+        }
+    } else if (!renderer->SetVSync(renderer, vsync)) {
+        if (vsync == 1) {
+            renderer->simulate_vsync = true;
+        } else {
+            return false;
+        }
+    }
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, vsync);
+    return true;
+}
+
+bool SDL_GetRenderVSync(SDL_Renderer *renderer, int *vsync)
+{
+    if (vsync) {
+        *vsync = 0;
+    }
+
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    if (vsync) {
+        *vsync = (int)SDL_GetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_VSYNC_NUMBER, 0);
+    }
+    return true;
+}
+
+
+#define SDL_DEBUG_FONT_GLYPHS_PER_ROW 14
+
+static bool CreateDebugTextAtlas(SDL_Renderer *renderer)
+{
+    SDL_assert(renderer->debug_char_texture_atlas == NULL);  // don't double-create it!
+
+    const int charWidth = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
+    const int charHeight = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
+
+    // actually make each glyph two pixels taller/wider, to prevent scaling artifacts.
+    const int rows = (SDL_DEBUG_FONT_NUM_GLYPHS / SDL_DEBUG_FONT_GLYPHS_PER_ROW) + 1;
+    SDL_Surface *atlas = SDL_CreateSurface((charWidth + 2) * SDL_DEBUG_FONT_GLYPHS_PER_ROW, rows * (charHeight + 2), SDL_PIXELFORMAT_RGBA8888);
+    if (!atlas) {
+        return false;
+    }
+
+    const int pitch = atlas->pitch;
+    SDL_memset(atlas->pixels, '\0', atlas->h * atlas->pitch);
+
+    int column = 0;
+    int row = 0;
+    for (int glyph = 0; glyph < SDL_DEBUG_FONT_NUM_GLYPHS; glyph++) {
+        // find top-left of this glyph in destination surface. The +2's account for glyph padding.
+        Uint8 *linepos = (((Uint8 *)atlas->pixels) + ((row * (charHeight + 2) + 1) * pitch)) + ((column * (charWidth + 2) + 1) * sizeof (Uint32));
+        const Uint8 *charpos = SDL_RenderDebugTextFontData + (glyph * 8);
+
+        // Draw the glyph to the surface...
+        for (int iy = 0; iy < charHeight; iy++) {
+            Uint32 *curpos = (Uint32 *)linepos;
+            for (int ix = 0; ix < charWidth; ix++) {
+                if ((*charpos) & (1 << ix)) {
+                    *curpos = 0xffffffff;
+                } else {
+                    *curpos = 0;
+                }
+                ++curpos;
+            }
+            linepos += pitch;
+            ++charpos;
+        }
+
+        // move to next position (and if too far, start the next row).
+        column++;
+        if (column >= SDL_DEBUG_FONT_GLYPHS_PER_ROW) {
+            row++;
+            column = 0;
+        }
+    }
+
+    SDL_assert((row < rows) || ((row == rows) && (column == 0)));  // make sure we didn't overflow the surface.
+
+    // Convert temp surface into texture
+    SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, atlas);
+    if (texture) {
+        SDL_SetTextureScaleMode(texture, SDL_SCALEMODE_NEAREST);
+        renderer->debug_char_texture_atlas = texture;
+    }
+    SDL_DestroySurface(atlas);
+
+    return texture != NULL;
+}
+
+static bool DrawDebugCharacter(SDL_Renderer *renderer, float x, float y, Uint32 c)
+{
+    SDL_assert(renderer->debug_char_texture_atlas != NULL);   // should have been created by now!
+
+    const int charWidth = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
+    const int charHeight = SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
+
+    // Character index in cache
+    Uint32 ci = c;
+    if ((ci <= 32) || ((ci >= 127) && (ci <= 160))) {
+        return true;  // these are just completely blank chars, don't bother doing anything.
+    } else if (ci >= SDL_DEBUG_FONT_NUM_GLYPHS) {
+        ci = SDL_DEBUG_FONT_NUM_GLYPHS - 1;  // use our "not a valid/supported character" glyph.
+    } else if (ci < 127) {
+        ci -= 33;     // adjust for the 33 blank glyphs at the start
+    } else {
+        ci -= 67;     // adjust for the 33 blank glyphs at the start AND the 34 gap in the middle.
+    }
+
+    const float src_x = (float) (((ci % SDL_DEBUG_FONT_GLYPHS_PER_ROW) * (charWidth + 2)) + 1);
+    const float src_y = (float) (((ci / SDL_DEBUG_FONT_GLYPHS_PER_ROW) * (charHeight + 2)) + 1);
+
+    // Draw texture onto destination
+    const SDL_FRect srect = { src_x, src_y, (float) charWidth, (float) charHeight };
+    const SDL_FRect drect = { x, y, (float) charWidth, (float) charHeight };
+    return SDL_RenderTexture(renderer, renderer->debug_char_texture_atlas, &srect, &drect);
+}
+
+bool SDL_RenderDebugText(SDL_Renderer *renderer, float x, float y, const char *s)
+{
+    CHECK_RENDERER_MAGIC(renderer, false);
+
+    // Allocate a texture atlas for this renderer if needed.
+    if (!renderer->debug_char_texture_atlas) {
+        if (!CreateDebugTextAtlas(renderer)) {
+            return false;
+        }
+    }
+
+    bool result = true;
+
+    Uint8 r, g, b, a;
+    result &= SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a);
+    result &= SDL_SetTextureColorMod(renderer->debug_char_texture_atlas, r, g, b);
+    result &= SDL_SetTextureAlphaMod(renderer->debug_char_texture_atlas, a);
+
+    float curx = x;
+    Uint32 ch;
+
+    while (result && ((ch = SDL_StepUTF8(&s, NULL)) != 0)) {
+        result &= DrawDebugCharacter(renderer, curx, y, ch);
+        curx += SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE;
+    }
+
+    return result;
+}
+
+bool SDL_RenderDebugTextFormat(SDL_Renderer *renderer, float x, float y, SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+
+    // fast path to avoid unnecessary allocation and copy. If you're going through the dynapi, there's a good chance
+    // you _always_ hit this path, since it probably had to process varargs before calling into the jumptable.
+    if (SDL_strcmp(fmt, "%s") == 0) {
+        const char *str = va_arg(ap, const char *);
+        va_end(ap);
+        return SDL_RenderDebugText(renderer, x, y, str);
+    }
+
+    char *str = NULL;
+    const int rc = SDL_vasprintf(&str, fmt, ap);
+    va_end(ap);
+
+    if (rc == -1) {
+        return false;
+    }
+
+    const bool retval = SDL_RenderDebugText(renderer, x, y, str);
+    SDL_free(str);
+    return retval;
+}
diff --git a/SDL-3.2.8/src/render/SDL_render_debug_font.h b/SDL-3.2.8/src/render/SDL_render_debug_font.h
new file mode 100644
index 0000000..ca296e8
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_render_debug_font.h
@@ -0,0 +1,2331 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_render_debug_font_h_
+#define SDL_render_debug_font_h_
+
+/* ---- 8x8 font definition ---- */
+
+/*
+; Summary: font8_8.asm
+; 8x8 monochrome bitmap fonts for rendering
+;
+; Author:
+;     Marcel Sondaar
+;     International Business Machines (public domain VGA fonts)
+;
+; License:
+;     Public Domain
+;
+*/
+
+#define SDL_DEBUG_FONT_NUM_GLYPHS 190
+
+static const Uint8 SDL_RenderDebugTextFontData[] = {
+    // there's a gap at the start.
+
+    /*
+     * 33 0x21 '!'
+     */
+    0x18, /* 00011000 */
+    0x3c, /* 00111100 */
+    0x3c, /* 00111100 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 34 0x22 '"'
+     */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 35 0x23 '#'
+     */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x7f, /* 11111110 */
+    0x36, /* 01101100 */
+    0x7f, /* 11111110 */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 36 0x24 '$'
+     */
+    0x0c, /* 00110000 */
+    0x3e, /* 01111100 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x1f, /* 11111000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 37 0x25 '%'
+     */
+    0x00, /* 00000000 */
+    0x63, /* 11000110 */
+    0x33, /* 11001100 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x66, /* 01100110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 38 0x26 '&'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x6e, /* 01110110 */
+    0x3b, /* 11011100 */
+    0x33, /* 11001100 */
+    0x6e, /* 01110110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 39 0x27 '''
+     */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x03, /* 11000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 40 0x28 '('
+     */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x0c, /* 00110000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 41 0x29 ')'
+     */
+    0x06, /* 01100000 */
+    0x0c, /* 00110000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 42 0x2a '*'
+     */
+    0x00, /* 00000000 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0xff, /* 11111111 */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 43 0x2b '+'
+     */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x3f, /* 11111100 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 44 0x2c ','
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+
+    /*
+     * 45 0x2d '-'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 46 0x2e '.'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 47 0x2f '/'
+     */
+    0x60, /* 00000110 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+    0x03, /* 11000000 */
+    0x01, /* 10000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 48 0x30 '0'
+     */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x73, /* 11001110 */
+    0x7b, /* 11011110 */
+    0x6f, /* 11110110 */
+    0x67, /* 11100110 */
+    0x3e, /* 01111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 49 0x31 '1'
+     */
+    0x0c, /* 00110000 */
+    0x0e, /* 01110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 50 0x32 '2'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x30, /* 00001100 */
+    0x1c, /* 00111000 */
+    0x06, /* 01100000 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 51 0x33 '3'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x30, /* 00001100 */
+    0x1c, /* 00111000 */
+    0x30, /* 00001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 52 0x34 '4'
+     */
+    0x38, /* 00011100 */
+    0x3c, /* 00111100 */
+    0x36, /* 01101100 */
+    0x33, /* 11001100 */
+    0x7f, /* 11111110 */
+    0x30, /* 00001100 */
+    0x78, /* 00011110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 53 0x35 '5'
+     */
+    0x3f, /* 11111100 */
+    0x03, /* 11000000 */
+    0x1f, /* 11111000 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 54 0x36 '6'
+     */
+    0x1c, /* 00111000 */
+    0x06, /* 01100000 */
+    0x03, /* 11000000 */
+    0x1f, /* 11111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 55 0x37 '7'
+     */
+    0x3f, /* 11111100 */
+    0x33, /* 11001100 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 56 0x38 '8'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 57 0x39 '9'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3e, /* 01111100 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x0e, /* 01110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 58 0x3a ':'
+     */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 59 0x3b ';'
+     */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+
+    /*
+     * 60 0x3c '<'
+     */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+    0x03, /* 11000000 */
+    0x06, /* 01100000 */
+    0x0c, /* 00110000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 61 0x3d '='
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 62 0x3e '>'
+     */
+    0x06, /* 01100000 */
+    0x0c, /* 00110000 */
+    0x18, /* 00011000 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 63 0x3f '?'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 64 0x40 '@'
+     */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x7b, /* 11011110 */
+    0x7b, /* 11011110 */
+    0x7b, /* 11011110 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 65 0x41 'A'
+     */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 66 0x42 'B'
+     */
+    0x3f, /* 11111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 67 0x43 'C'
+     */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x03, /* 11000000 */
+    0x03, /* 11000000 */
+    0x03, /* 11000000 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 68 0x44 'D'
+     */
+    0x1f, /* 11111000 */
+    0x36, /* 01101100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x36, /* 01101100 */
+    0x1f, /* 11111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 69 0x45 'E'
+     */
+    0x7f, /* 11111110 */
+    0x46, /* 01100010 */
+    0x16, /* 01101000 */
+    0x1e, /* 01111000 */
+    0x16, /* 01101000 */
+    0x46, /* 01100010 */
+    0x7f, /* 11111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 70 0x46 'F'
+     */
+    0x7f, /* 11111110 */
+    0x46, /* 01100010 */
+    0x16, /* 01101000 */
+    0x1e, /* 01111000 */
+    0x16, /* 01101000 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 71 0x47 'G'
+     */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x03, /* 11000000 */
+    0x03, /* 11000000 */
+    0x73, /* 11001110 */
+    0x66, /* 01100110 */
+    0x7c, /* 00111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 72 0x48 'H'
+     */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 73 0x49 'I'
+     */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 74 0x4a 'J'
+     */
+    0x78, /* 00011110 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 75 0x4b 'K'
+     */
+    0x67, /* 11100110 */
+    0x66, /* 01100110 */
+    0x36, /* 01101100 */
+    0x1e, /* 01111000 */
+    0x36, /* 01101100 */
+    0x66, /* 01100110 */
+    0x67, /* 11100110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 76 0x4c 'L'
+     */
+    0x0f, /* 11110000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x46, /* 01100010 */
+    0x66, /* 01100110 */
+    0x7f, /* 11111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 77 0x4d 'M'
+     */
+    0x63, /* 11000110 */
+    0x77, /* 11101110 */
+    0x7f, /* 11111110 */
+    0x7f, /* 11111110 */
+    0x6b, /* 11010110 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 78 0x4e 'N'
+     */
+    0x63, /* 11000110 */
+    0x67, /* 11100110 */
+    0x6f, /* 11110110 */
+    0x7b, /* 11011110 */
+    0x73, /* 11001110 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 79 0x4f 'O'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 80 0x50 'P'
+     */
+    0x3f, /* 11111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 81 0x51 'Q'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3b, /* 11011100 */
+    0x1e, /* 01111000 */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 82 0x52 'R'
+     */
+    0x3f, /* 11111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x36, /* 01101100 */
+    0x66, /* 01100110 */
+    0x67, /* 11100110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 83 0x53 'S'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x07, /* 11100000 */
+    0x0e, /* 01110000 */
+    0x38, /* 00011100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 84 0x54 'T'
+     */
+    0x3f, /* 11111100 */
+    0x2d, /* 10110100 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 85 0x55 'U'
+     */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 86 0x56 'V'
+     */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 87 0x57 'W'
+     */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x6b, /* 11010110 */
+    0x7f, /* 11111110 */
+    0x77, /* 11101110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 88 0x58 'X'
+     */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 89 0x59 'Y'
+     */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 90 0x5a 'Z'
+     */
+    0x7f, /* 11111110 */
+    0x63, /* 11000110 */
+    0x31, /* 10001100 */
+    0x18, /* 00011000 */
+    0x4c, /* 00110010 */
+    0x66, /* 01100110 */
+    0x7f, /* 11111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 91 0x5b '['
+     */
+    0x1e, /* 01111000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 92 0x5c '\'
+     */
+    0x03, /* 11000000 */
+    0x06, /* 01100000 */
+    0x0c, /* 00110000 */
+    0x18, /* 00011000 */
+    0x30, /* 00001100 */
+    0x60, /* 00000110 */
+    0x40, /* 00000010 */
+    0x00, /* 00000000 */
+
+    /*
+     * 93 0x5d ']'
+     */
+    0x1e, /* 01111000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 94 0x5e '^'
+     */
+    0x08, /* 00010000 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 95 0x5f '_'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0xff, /* 11111111 */
+
+    /*
+     * 96 0x60 '`'
+     */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 97 0x61 'a'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x6e, /* 01110110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 98 0x62 'b'
+     */
+    0x07, /* 11100000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x3e, /* 01111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3b, /* 11011100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 99 0x63 'c'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x03, /* 11000000 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 100 0x64 'd'
+     */
+    0x38, /* 00011100 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x6e, /* 01110110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 101 0x65 'e'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 102 0x66 'f'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+    0x06, /* 01100000 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 103 0x67 'g'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x6e, /* 01110110 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3e, /* 01111100 */
+    0x30, /* 00001100 */
+    0x1f, /* 11111000 */
+
+    /*
+     * 104 0x68 'h'
+     */
+    0x07, /* 11100000 */
+    0x06, /* 01100000 */
+    0x36, /* 01101100 */
+    0x6e, /* 01110110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x67, /* 11100110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 105 0x69 'i'
+     */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x0e, /* 01110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 106 0x6a 'j'
+     */
+    0x30, /* 00001100 */
+    0x00, /* 00000000 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+
+    /*
+     * 107 0x6b 'k'
+     */
+    0x07, /* 11100000 */
+    0x06, /* 01100000 */
+    0x66, /* 01100110 */
+    0x36, /* 01101100 */
+    0x1e, /* 01111000 */
+    0x36, /* 01101100 */
+    0x67, /* 11100110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 108 0x6c 'l'
+     */
+    0x0e, /* 01110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 109 0x6d 'm'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x7f, /* 11111110 */
+    0x7f, /* 11111110 */
+    0x6b, /* 11010110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 110 0x6e 'n'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x1f, /* 11111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 111 0x6f 'o'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 112 0x70 'p'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3b, /* 11011100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+
+    /*
+     * 113 0x71 'q'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x6e, /* 01110110 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3e, /* 01111100 */
+    0x30, /* 00001100 */
+    0x78, /* 00011110 */
+
+    /*
+     * 114 0x72 'r'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3b, /* 11011100 */
+    0x6e, /* 01110110 */
+    0x66, /* 01100110 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 115 0x73 's'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3e, /* 01111100 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x1f, /* 11111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 116 0x74 't'
+     */
+    0x08, /* 00010000 */
+    0x0c, /* 00110000 */
+    0x3e, /* 01111100 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x2c, /* 00110100 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 117 0x75 'u'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x6e, /* 01110110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 118 0x76 'v'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 119 0x77 'w'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x63, /* 11000110 */
+    0x6b, /* 11010110 */
+    0x7f, /* 11111110 */
+    0x7f, /* 11111110 */
+    0x36, /* 01101100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 120 0x78 'x'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x63, /* 11000110 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 121 0x79 'y'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3e, /* 01111100 */
+    0x30, /* 00001100 */
+    0x1f, /* 11111000 */
+
+    /*
+     * 122 0x7a 'z'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x19, /* 10011000 */
+    0x0c, /* 00110000 */
+    0x26, /* 01100100 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 123 0x7b '{'
+     */
+    0x38, /* 00011100 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x07, /* 11100000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 124 0x7c '|'
+     */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 125 0x7d '}'
+     */
+    0x07, /* 11100000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x38, /* 00011100 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 126 0x7e '~'
+     */
+    0x6e, /* 01110110 */
+    0x3b, /* 11011100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    // there's a gap here.
+
+    /*
+     * 161 0xa1 '¡'
+     */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 162 0xa2 '¢'
+     */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x7e, /* 01111110 */
+    0x03, /* 11000000 */
+    0x03, /* 11000000 */
+    0x7e, /* 01111110 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+
+    /*
+     * 163 0xa3 '£'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x26, /* 01100100 */
+    0x0f, /* 11110000 */
+    0x06, /* 01100000 */
+    0x67, /* 11100110 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 164 0xa4 '¤'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x63, /* 11000110 */
+    0x3e, /* 01111100 */
+    0x36, /* 01101100 */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 165 0xa5 'Â¥'
+     */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x3f, /* 11111100 */
+    0x0c, /* 00110000 */
+    0x3f, /* 11111100 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+
+    /*
+     * 166 0xa6 '¦'
+     */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 167 0xa7 '§'
+     */
+    0x7c, /* 00111110 */
+    0xc6, /* 01100011 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+
+    /*
+     * 168 0xa8 '¨'
+     */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 169 0xa9 '©'
+     */
+    0x3c, /* 00111100 */
+    0x42, /* 01000010 */
+    0x99, /* 10011001 */
+    0x85, /* 10100001 */
+    0x85, /* 10100001 */
+    0x99, /* 10011001 */
+    0x42, /* 01000010 */
+    0x3c, /* 00111100 */
+
+    /*
+     * 170 0xaa 'ª'
+     */
+    0x3c, /* 00111100 */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x7c, /* 00111110 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 171 0xab '«'
+     */
+    0x00, /* 00000000 */
+    0xcc, /* 00110011 */
+    0x66, /* 01100110 */
+    0x33, /* 11001100 */
+    0x66, /* 01100110 */
+    0xcc, /* 00110011 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 172 0xac '¬'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x30, /* 00001100 */
+    0x30, /* 00001100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 173 0xad '­'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 174 0xae '®'
+     */
+    0x3c, /* 00111100 */
+    0x42, /* 01000010 */
+    0x9d, /* 10111001 */
+    0xa5, /* 10100101 */
+    0x9d, /* 10111001 */
+    0xa5, /* 10100101 */
+    0x42, /* 01000010 */
+    0x3c, /* 00111100 */
+
+    /*
+     * 175 0xaf '¯'
+     */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 176 0xb0 '°'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 177 0xb1 '±'
+     */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x7e, /* 01111110 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 178 0xb2 '²'
+     */
+    0x1c, /* 00111000 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 179 0xb3 '³'
+     */
+    0x1c, /* 00111000 */
+    0x30, /* 00001100 */
+    0x18, /* 00011000 */
+    0x30, /* 00001100 */
+    0x1c, /* 00111000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 180 0xb4 '´'
+     */
+    0x18, /* 00011000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 181 0xb5 'µ'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x06, /* 01100000 */
+    0x03, /* 11000000 */
+
+    /*
+     * 182 0xb6 '¶'
+     */
+    0xfe, /* 01111111 */
+    0xdb, /* 11011011 */
+    0xdb, /* 11011011 */
+    0xde, /* 01111011 */
+    0xd8, /* 00011011 */
+    0xd8, /* 00011011 */
+    0xd8, /* 00011011 */
+    0x00, /* 00000000 */
+
+    /*
+     * 183 0xb7 '·'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 184 0xb8 '¸'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x30, /* 00001100 */
+    0x1e, /* 01111000 */
+
+    /*
+     * 185 0xb9 '¹'
+     */
+    0x08, /* 00010000 */
+    0x0c, /* 00110000 */
+    0x08, /* 00010000 */
+    0x1c, /* 00111000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 186 0xba 'º'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 187 0xbb '»'
+     */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x66, /* 01100110 */
+    0xcc, /* 00110011 */
+    0x66, /* 01100110 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 188 0xbc '¼'
+     */
+    0xc3, /* 11000011 */
+    0x63, /* 11000110 */
+    0x33, /* 11001100 */
+    0xbd, /* 10111101 */
+    0xec, /* 00110111 */
+    0xf6, /* 01101111 */
+    0xf3, /* 11001111 */
+    0x03, /* 11000000 */
+
+    /*
+     * 189 0xbd '½'
+     */
+    0xc3, /* 11000011 */
+    0x63, /* 11000110 */
+    0x33, /* 11001100 */
+    0x7b, /* 11011110 */
+    0xcc, /* 00110011 */
+    0x66, /* 01100110 */
+    0x33, /* 11001100 */
+    0xf0, /* 00001111 */
+
+    /*
+     * 190 0xbe '¾'
+     */
+    0x03, /* 11000000 */
+    0xc4, /* 00100011 */
+    0x63, /* 11000110 */
+    0xb4, /* 00101101 */
+    0xdb, /* 11011011 */
+    0xac, /* 00110101 */
+    0xe6, /* 01100111 */
+    0x80, /* 00000001 */
+
+    /*
+     * 191 0xbf '¿'
+     */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x0c, /* 00110000 */
+    0x06, /* 01100000 */
+    0x03, /* 11000000 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 192 0xc0 'À'
+     */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x7f, /* 11111110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 193 0xc1 'Á'
+     */
+    0x70, /* 00001110 */
+    0x00, /* 00000000 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x7f, /* 11111110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 194 0xc2 'Â'
+     */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x00, /* 00000000 */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x7f, /* 11111110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 195 0xc3 'Ã'
+     */
+    0x6e, /* 01110110 */
+    0x3b, /* 11011100 */
+    0x00, /* 00000000 */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x7f, /* 11111110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 196 0xc4 'Ä'
+     */
+    0x63, /* 11000110 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x63, /* 11000110 */
+    0x7f, /* 11111110 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 197 0xc5 'Å'
+     */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 198 0xc6 'Æ'
+     */
+    0x7c, /* 00111110 */
+    0x36, /* 01101100 */
+    0x33, /* 11001100 */
+    0x7f, /* 11111110 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x73, /* 11001110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 199 0xc7 'Ç'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x03, /* 11000000 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x18, /* 00011000 */
+    0x30, /* 00001100 */
+    0x1e, /* 01111000 */
+
+    /*
+     * 200 0xc8 'È'
+     */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x06, /* 01100000 */
+    0x1e, /* 01111000 */
+    0x06, /* 01100000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 201 0xc9 'É'
+     */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x06, /* 01100000 */
+    0x1e, /* 01111000 */
+    0x06, /* 01100000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 202 0xca 'Ê'
+     */
+    0x0c, /* 00110000 */
+    0x12, /* 01001000 */
+    0x3f, /* 11111100 */
+    0x06, /* 01100000 */
+    0x1e, /* 01111000 */
+    0x06, /* 01100000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 203 0xcb 'Ë'
+     */
+    0x36, /* 01101100 */
+    0x00, /* 00000000 */
+    0x3f, /* 11111100 */
+    0x06, /* 01100000 */
+    0x1e, /* 01111000 */
+    0x06, /* 01100000 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 204 0xcc 'Ì'
+     */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 205 0xcd 'Í'
+     */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 206 0xce 'Î'
+     */
+    0x0c, /* 00110000 */
+    0x12, /* 01001000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 207 0xcf 'Ï'
+     */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 208 0xd0 'Ð'
+     */
+    0x3f, /* 11111100 */
+    0x66, /* 01100110 */
+    0x6f, /* 11110110 */
+    0x6f, /* 11110110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 209 0xd1 'Ñ'
+     */
+    0x3f, /* 11111100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x37, /* 11101100 */
+    0x3f, /* 11111100 */
+    0x3b, /* 11011100 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 210 0xd2 'Ò'
+     */
+    0x0e, /* 01110000 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 211 0xd3 'Ó'
+     */
+    0x70, /* 00001110 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 212 0xd4 'Ô'
+     */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x18, /* 00011000 */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 213 0xd5 'Õ'
+     */
+    0x6e, /* 01110110 */
+    0x3b, /* 11011100 */
+    0x00, /* 00000000 */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x63, /* 11000110 */
+    0x3e, /* 01111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 214 0xd6 'Ö'
+     */
+    0xc3, /* 11000011 */
+    0x18, /* 00011000 */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 215 0xd7 '×'
+     */
+    0x00, /* 00000000 */
+    0x36, /* 01101100 */
+    0x1c, /* 00111000 */
+    0x08, /* 00010000 */
+    0x1c, /* 00111000 */
+    0x36, /* 01101100 */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 216 0xd8 'Ø'
+     */
+    0x5c, /* 00111010 */
+    0x36, /* 01101100 */
+    0x73, /* 11001110 */
+    0x7b, /* 11011110 */
+    0x6f, /* 11110110 */
+    0x36, /* 01101100 */
+    0x1d, /* 10111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 217 0xd9 'Ù'
+     */
+    0x0e, /* 01110000 */
+    0x00, /* 00000000 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 218 0xda 'Ú'
+     */
+    0x70, /* 00001110 */
+    0x00, /* 00000000 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 219 0xdb 'Û'
+     */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x00, /* 00000000 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 220 0xdc 'Ü'
+     */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 221 0xdd 'Ý'
+     */
+    0x70, /* 00001110 */
+    0x00, /* 00000000 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3c, /* 00111100 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 222 0xde 'Þ'
+     */
+    0x0f, /* 11110000 */
+    0x06, /* 01100000 */
+    0x3e, /* 01111100 */
+    0x66, /* 01100110 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x06, /* 01100000 */
+    0x0f, /* 11110000 */
+
+    /*
+     * 223 0xdf 'ß'
+     */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x1f, /* 11111000 */
+    0x33, /* 11001100 */
+    0x1f, /* 11111000 */
+    0x03, /* 11000000 */
+    0x03, /* 11000000 */
+
+    /*
+     * 224 0xe0 'à'
+     */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 225 0xe1 'á'
+     */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 226 0xe2 'â'
+     */
+    0x7e, /* 01111110 */
+    0xc3, /* 11000011 */
+    0x3c, /* 00111100 */
+    0x60, /* 00000110 */
+    0x7c, /* 00111110 */
+    0x66, /* 01100110 */
+    0xfc, /* 00111111 */
+    0x00, /* 00000000 */
+
+    /*
+     * 227 0xe3 'ã'
+     */
+    0x6e, /* 01110110 */
+    0x3b, /* 11011100 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 228 0xe4 'ä'
+     */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 229 0xe5 'Ã¥'
+     */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 230 0xe6 'æ'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0xfe, /* 01111111 */
+    0x30, /* 00001100 */
+    0xfe, /* 01111111 */
+    0x33, /* 11001100 */
+    0xfe, /* 01111111 */
+    0x00, /* 00000000 */
+
+    /*
+     * 231 0xe7 'ç'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x03, /* 11000000 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x30, /* 00001100 */
+    0x1c, /* 00111000 */
+
+    /*
+     * 232 0xe8 'è'
+     */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 233 0xe9 'é'
+     */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 234 0xea 'ê'
+     */
+    0x7e, /* 01111110 */
+    0xc3, /* 11000011 */
+    0x3c, /* 00111100 */
+    0x66, /* 01100110 */
+    0x7e, /* 01111110 */
+    0x06, /* 01100000 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 235 0xeb 'ë'
+     */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x3f, /* 11111100 */
+    0x03, /* 11000000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 236 0xec 'ì'
+     */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x0e, /* 01110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 237 0xed 'í'
+     */
+    0x1c, /* 00111000 */
+    0x00, /* 00000000 */
+    0x0e, /* 01110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 238 0xee 'î'
+     */
+    0x3e, /* 01111100 */
+    0x63, /* 11000110 */
+    0x1c, /* 00111000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x3c, /* 00111100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 239 0xef 'ï'
+     */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x0e, /* 01110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x0c, /* 00110000 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 240 0xf0 'ð'
+     */
+    0x1b, /* 11011000 */
+    0x0e, /* 01110000 */
+    0x1b, /* 11011000 */
+    0x30, /* 00001100 */
+    0x3e, /* 01111100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 241 0xf1 'ñ'
+     */
+    0x00, /* 00000000 */
+    0x1f, /* 11111000 */
+    0x00, /* 00000000 */
+    0x1f, /* 11111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+
+    /*
+     * 242 0xf2 'ò'
+     */
+    0x00, /* 00000000 */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 243 0xf3 'ó'
+     */
+    0x00, /* 00000000 */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 244 0xf4 'ô'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 245 0xf5 'õ'
+     */
+    0x6e, /* 01110110 */
+    0x3b, /* 11011100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 246 0xf6 'ö'
+     */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x1e, /* 01111000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 247 0xf7 '÷'
+     */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+    0x18, /* 00011000 */
+    0x18, /* 00011000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 248 0xf8 'ø'
+     */
+    0x00, /* 00000000 */
+    0x60, /* 00000110 */
+    0x3c, /* 00111100 */
+    0x76, /* 01101110 */
+    0x7e, /* 01111110 */
+    0x6e, /* 01110110 */
+    0x3c, /* 00111100 */
+    0x06, /* 01100000 */
+
+    /*
+     * 249 0xf9 'ù'
+     */
+    0x00, /* 00000000 */
+    0x07, /* 11100000 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 250 0xfa 'ú'
+     */
+    0x00, /* 00000000 */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 251 0xfb 'û'
+     */
+    0x1e, /* 01111000 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 252 0xfc 'ü'
+     */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x7e, /* 01111110 */
+    0x00, /* 00000000 */
+
+    /*
+     * 253 0xfd 'ý'
+     */
+    0x00, /* 00000000 */
+    0x38, /* 00011100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3e, /* 01111100 */
+    0x30, /* 00001100 */
+    0x1f, /* 11111000 */
+
+    /*
+     * 254 0xfe 'þ'
+     */
+    0x00, /* 00000000 */
+    0x00, /* 00000000 */
+    0x06, /* 01100000 */
+    0x3e, /* 01111100 */
+    0x66, /* 01100110 */
+    0x3e, /* 01111100 */
+    0x06, /* 01100000 */
+    0x00, /* 00000000 */
+
+    /*
+     * 255 0xff 'ÿ'
+     */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x00, /* 00000000 */
+    0x33, /* 11001100 */
+    0x33, /* 11001100 */
+    0x3e, /* 01111100 */
+    0x30, /* 00001100 */
+    0x1f, /* 11111000 */
+
+    /*
+     * 256 0x100 - missing character
+     */
+    0x55, /* 01010101 */
+    0xAA, /* 10101010 */
+    0x55, /* 01010101 */
+    0xAA, /* 10101010 */
+    0x55, /* 01010101 */
+    0xAA, /* 10101010 */
+    0x55, /* 01010101 */
+    0xAA, /* 10101010 */
+};
+
+SDL_COMPILE_TIME_ASSERT(SDL_RenderDebugTextFontDataSize, SDL_arraysize(SDL_RenderDebugTextFontData) == SDL_DEBUG_FONT_NUM_GLYPHS * 8);
+
+#endif
+
diff --git a/SDL-3.2.8/src/render/SDL_render_unsupported.c b/SDL-3.2.8/src/render/SDL_render_unsupported.c
new file mode 100644
index 0000000..5369fb4
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_render_unsupported.c
@@ -0,0 +1,22 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
diff --git a/SDL-3.2.8/src/render/SDL_sysrender.h b/SDL-3.2.8/src/render/SDL_sysrender.h
new file mode 100644
index 0000000..9d39dfd
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_sysrender.h
@@ -0,0 +1,372 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_sysrender_h_
+#define SDL_sysrender_h_
+
+#include "../video/SDL_surface_c.h"
+
+#include "SDL_yuv_sw_c.h"
+
+// Set up for C function definitions, even when using C++
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum SDL_TextureAddressMode
+{
+    SDL_TEXTURE_ADDRESS_AUTO,
+    SDL_TEXTURE_ADDRESS_CLAMP,
+    SDL_TEXTURE_ADDRESS_WRAP,
+} SDL_TextureAddressMode;
+
+/**
+ * A rectangle, with the origin at the upper left (double precision).
+ */
+typedef struct SDL_DRect
+{
+    double x;
+    double y;
+    double w;
+    double h;
+} SDL_DRect;
+
+// The SDL 2D rendering system
+
+typedef struct SDL_RenderDriver SDL_RenderDriver;
+
+// Rendering view state
+typedef struct SDL_RenderViewState
+{
+    int pixel_w;
+    int pixel_h;
+    SDL_Rect viewport;
+    SDL_Rect pixel_viewport;
+    SDL_Rect clip_rect;
+    SDL_Rect pixel_clip_rect;
+    bool clipping_enabled;
+    SDL_FPoint scale;
+
+    // Support for logical output coordinates
+    SDL_RendererLogicalPresentation logical_presentation_mode;
+    int logical_w, logical_h;
+    SDL_FRect logical_src_rect;
+    SDL_FRect logical_dst_rect;
+    SDL_FPoint logical_scale;
+    SDL_FPoint logical_offset;
+
+    SDL_FPoint current_scale;  // this is just `scale * logical_scale`, precalculated, since we use it a lot.
+} SDL_RenderViewState;
+
+// Define the SDL texture structure
+struct SDL_Texture
+{
+    // Public API definition
+    SDL_PixelFormat format;     /**< The format of the texture, read-only */
+    int w;                      /**< The width of the texture, read-only. */
+    int h;                      /**< The height of the texture, read-only. */
+
+    int refcount;               /**< Application reference count, used when freeing texture */
+
+    // Private API definition
+    SDL_Colorspace colorspace;  // The colorspace of the texture
+    float SDR_white_point;      // The SDR white point for this content
+    float HDR_headroom;         // The HDR headroom needed by this content
+    SDL_TextureAccess access;   // The texture access mode
+    SDL_BlendMode blendMode;    // The texture blend mode
+    SDL_ScaleMode scaleMode;    // The texture scale mode
+    SDL_FColor color;           // Texture modulation values
+    SDL_RenderViewState view;   // Target texture view state
+
+    SDL_Renderer *renderer;
+
+    // Support for formats not supported directly by the renderer
+    SDL_Texture *native;
+    SDL_SW_YUVTexture *yuv;
+    void *pixels;
+    int pitch;
+    SDL_Rect locked_rect;
+    SDL_Surface *locked_surface; // Locked region exposed as a SDL surface
+
+    Uint32 last_command_generation; // last command queue generation this texture was in.
+
+    SDL_PropertiesID props;
+
+    void *internal;             // Driver specific texture representation
+
+    SDL_Texture *prev;
+    SDL_Texture *next;
+};
+
+typedef enum
+{
+    SDL_RENDERCMD_NO_OP,
+    SDL_RENDERCMD_SETVIEWPORT,
+    SDL_RENDERCMD_SETCLIPRECT,
+    SDL_RENDERCMD_SETDRAWCOLOR,
+    SDL_RENDERCMD_CLEAR,
+    SDL_RENDERCMD_DRAW_POINTS,
+    SDL_RENDERCMD_DRAW_LINES,
+    SDL_RENDERCMD_FILL_RECTS,
+    SDL_RENDERCMD_COPY,
+    SDL_RENDERCMD_COPY_EX,
+    SDL_RENDERCMD_GEOMETRY
+} SDL_RenderCommandType;
+
+typedef struct SDL_RenderCommand
+{
+    SDL_RenderCommandType command;
+    union
+    {
+        struct
+        {
+            size_t first;
+            SDL_Rect rect;
+        } viewport;
+        struct
+        {
+            bool enabled;
+            SDL_Rect rect;
+        } cliprect;
+        struct
+        {
+            size_t first;
+            size_t count;
+            float color_scale;
+            SDL_FColor color;
+            SDL_BlendMode blend;
+            SDL_Texture *texture;
+            SDL_TextureAddressMode texture_address_mode;
+        } draw;
+        struct
+        {
+            size_t first;
+            float color_scale;
+            SDL_FColor color;
+        } color;
+    } data;
+    struct SDL_RenderCommand *next;
+} SDL_RenderCommand;
+
+typedef struct SDL_VertexSolid
+{
+    SDL_FPoint position;
+    SDL_FColor color;
+} SDL_VertexSolid;
+
+typedef enum
+{
+    SDL_RENDERLINEMETHOD_POINTS,
+    SDL_RENDERLINEMETHOD_LINES,
+    SDL_RENDERLINEMETHOD_GEOMETRY,
+} SDL_RenderLineMethod;
+
+// Define the SDL renderer structure
+struct SDL_Renderer
+{
+    void (*WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event);
+    bool (*GetOutputSize)(SDL_Renderer *renderer, int *w, int *h);
+    bool (*SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode);
+    bool (*CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props);
+    bool (*QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+    bool (*QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+    bool (*QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points,
+                           int count);
+    bool (*QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points,
+                          int count);
+    bool (*QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects,
+                          int count);
+    bool (*QueueCopy)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                     const SDL_FRect *srcrect, const SDL_FRect *dstrect);
+    bool (*QueueCopyEx)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                       const SDL_FRect *srcquad, const SDL_FRect *dstrect,
+                       const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y);
+    bool (*QueueGeometry)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                         const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                         int num_vertices, const void *indices, int num_indices, int size_indices,
+                         float scale_x, float scale_y);
+
+    void (*InvalidateCachedState)(SDL_Renderer *renderer);
+    bool (*RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize);
+    bool (*UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture,
+                         const SDL_Rect *rect, const void *pixels,
+                         int pitch);
+#ifdef SDL_HAVE_YUV
+    bool (*UpdateTextureYUV)(SDL_Renderer *renderer, SDL_Texture *texture,
+                            const SDL_Rect *rect,
+                            const Uint8 *Yplane, int Ypitch,
+                            const Uint8 *Uplane, int Upitch,
+                            const Uint8 *Vplane, int Vpitch);
+    bool (*UpdateTextureNV)(SDL_Renderer *renderer, SDL_Texture *texture,
+                           const SDL_Rect *rect,
+                           const Uint8 *Yplane, int Ypitch,
+                           const Uint8 *UVplane, int UVpitch);
+#endif
+    bool (*LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture,
+                       const SDL_Rect *rect, void **pixels, int *pitch);
+    void (*UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture);
+    void (*SetTextureScaleMode)(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode);
+    bool (*SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture);
+    SDL_Surface *(*RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect);
+    bool (*RenderPresent)(SDL_Renderer *renderer);
+    void (*DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture);
+
+    void (*DestroyRenderer)(SDL_Renderer *renderer);
+
+    bool (*SetVSync)(SDL_Renderer *renderer, int vsync);
+
+    void *(*GetMetalLayer)(SDL_Renderer *renderer);
+    void *(*GetMetalCommandEncoder)(SDL_Renderer *renderer);
+
+    bool (*AddVulkanRenderSemaphores)(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore);
+
+    // The current renderer info
+    const char *name;
+    SDL_PixelFormat *texture_formats;
+    int num_texture_formats;
+    bool software;
+
+    // The window associated with the renderer
+    SDL_Window *window;
+    bool hidden;
+
+    // Whether we should simulate vsync
+    bool wanted_vsync;
+    bool simulate_vsync;
+    Uint64 simulate_vsync_interval_ns;
+    Uint64 last_present;
+
+    SDL_RenderViewState *view;
+    SDL_RenderViewState main_view;
+
+    // The window pixel to point coordinate scale
+    SDL_FPoint dpi_scale;
+
+    // The method of drawing lines
+    SDL_RenderLineMethod line_method;
+
+    // The list of textures
+    SDL_Texture *textures;
+    SDL_Texture *target;
+    SDL_Mutex *target_mutex;
+
+    SDL_Colorspace output_colorspace;
+    float SDR_white_point;
+    float HDR_headroom;
+
+    float desired_color_scale;
+    float color_scale;
+    SDL_FColor color;        /**< Color for drawing operations values */
+    SDL_BlendMode blendMode; /**< The drawing blend mode */
+    SDL_TextureAddressMode texture_address_mode;
+
+    SDL_RenderCommand *render_commands;
+    SDL_RenderCommand *render_commands_tail;
+    SDL_RenderCommand *render_commands_pool;
+    Uint32 render_command_generation;
+    SDL_FColor last_queued_color;
+    float last_queued_color_scale;
+    SDL_Rect last_queued_viewport;
+    SDL_Rect last_queued_cliprect;
+    bool last_queued_cliprect_enabled;
+    bool color_queued;
+    bool viewport_queued;
+    bool cliprect_queued;
+
+    void *vertex_data;
+    size_t vertex_data_used;
+    size_t vertex_data_allocation;
+
+    // Shaped window support
+    bool transparent_window;
+    SDL_Surface *shape_surface;
+    SDL_Texture *shape_texture;
+
+    SDL_PropertiesID props;
+
+    SDL_Texture *debug_char_texture_atlas;
+
+    bool destroyed;   // already destroyed by SDL_DestroyWindow; just free this struct in SDL_DestroyRenderer.
+
+    void *internal;
+
+    SDL_Renderer *next;
+};
+
+// Define the SDL render driver structure
+struct SDL_RenderDriver
+{
+    bool (*CreateRenderer)(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID props);
+
+    const char *name;
+};
+
+// Not all of these are available in a given build. Use #ifdefs, etc.
+extern SDL_RenderDriver D3D_RenderDriver;
+extern SDL_RenderDriver D3D11_RenderDriver;
+extern SDL_RenderDriver D3D12_RenderDriver;
+extern SDL_RenderDriver GL_RenderDriver;
+extern SDL_RenderDriver GLES2_RenderDriver;
+extern SDL_RenderDriver METAL_RenderDriver;
+extern SDL_RenderDriver VULKAN_RenderDriver;
+extern SDL_RenderDriver PS2_RenderDriver;
+extern SDL_RenderDriver PSP_RenderDriver;
+extern SDL_RenderDriver SW_RenderDriver;
+extern SDL_RenderDriver VITA_GXM_RenderDriver;
+extern SDL_RenderDriver GPU_RenderDriver;
+
+// Clean up any renderers at shutdown
+extern void SDL_QuitRender(void);
+
+// Add a supported texture format to a renderer
+extern bool SDL_AddSupportedTextureFormat(SDL_Renderer *renderer, SDL_PixelFormat format);
+
+// Setup colorspace conversion
+extern void SDL_SetupRendererColorspace(SDL_Renderer *renderer, SDL_PropertiesID props);
+
+// Colorspace conversion functions
+extern bool SDL_RenderingLinearSpace(SDL_Renderer *renderer);
+extern void SDL_ConvertToLinear(SDL_FColor *color);
+extern void SDL_ConvertFromLinear(SDL_FColor *color);
+
+// Blend mode functions
+extern SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode);
+extern SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode);
+extern SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode);
+extern SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode);
+extern SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode);
+extern SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode);
+
+/* drivers call this during their Queue*() methods to make space in a array that are used
+   for a vertex buffer during RunCommandQueue(). Pointers returned here are only valid until
+   the next call, because it might be in an array that gets realloc()'d. */
+extern void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, size_t numbytes, size_t alignment, size_t *offset);
+
+// Let the video subsystem destroy a renderer without making its pointer invalid.
+extern void SDL_DestroyRendererWithoutFreeing(SDL_Renderer *renderer);
+
+// Ends C function definitions when using C++
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SDL_sysrender_h_
diff --git a/SDL-3.2.8/src/render/SDL_yuv_sw.c b/SDL-3.2.8/src/render/SDL_yuv_sw.c
new file mode 100644
index 0000000..abe9e16
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_yuv_sw.c
@@ -0,0 +1,404 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// This is the software implementation of the YUV texture support
+
+#ifdef SDL_HAVE_YUV
+
+#include "SDL_yuv_sw_c.h"
+#include "../video/SDL_surface_c.h"
+#include "../video/SDL_yuv_c.h"
+
+SDL_SW_YUVTexture *SDL_SW_CreateYUVTexture(SDL_PixelFormat format, SDL_Colorspace colorspace, int w, int h)
+{
+    SDL_SW_YUVTexture *swdata;
+
+    switch (format) {
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_YUY2:
+    case SDL_PIXELFORMAT_UYVY:
+    case SDL_PIXELFORMAT_YVYU:
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        break;
+    default:
+        SDL_SetError("Unsupported YUV format");
+        return NULL;
+    }
+
+    swdata = (SDL_SW_YUVTexture *)SDL_calloc(1, sizeof(*swdata));
+    if (!swdata) {
+        return NULL;
+    }
+
+    swdata->format = format;
+    swdata->colorspace = colorspace;
+    swdata->target_format = SDL_PIXELFORMAT_UNKNOWN;
+    swdata->w = w;
+    swdata->h = h;
+    {
+        size_t dst_size;
+        if (!SDL_CalculateYUVSize(format, w, h, &dst_size, NULL)) {
+            SDL_SW_DestroyYUVTexture(swdata);
+            return NULL;
+        }
+        swdata->pixels = (Uint8 *)SDL_aligned_alloc(SDL_GetSIMDAlignment(), dst_size);
+        if (!swdata->pixels) {
+            SDL_SW_DestroyYUVTexture(swdata);
+            return NULL;
+        }
+    }
+
+    // Find the pitch and offset values for the texture
+    switch (format) {
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+        swdata->pitches[0] = w;
+        swdata->pitches[1] = (swdata->pitches[0] + 1) / 2;
+        swdata->pitches[2] = (swdata->pitches[0] + 1) / 2;
+        swdata->planes[0] = swdata->pixels;
+        swdata->planes[1] = swdata->planes[0] + swdata->pitches[0] * h;
+        swdata->planes[2] = swdata->planes[1] + swdata->pitches[1] * ((h + 1) / 2);
+        break;
+    case SDL_PIXELFORMAT_YUY2:
+    case SDL_PIXELFORMAT_UYVY:
+    case SDL_PIXELFORMAT_YVYU:
+        swdata->pitches[0] = ((w + 1) / 2) * 4;
+        swdata->planes[0] = swdata->pixels;
+        break;
+
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        swdata->pitches[0] = w;
+        swdata->pitches[1] = 2 * ((swdata->pitches[0] + 1) / 2);
+        swdata->planes[0] = swdata->pixels;
+        swdata->planes[1] = swdata->planes[0] + swdata->pitches[0] * h;
+        break;
+
+    default:
+        SDL_assert(!"We should never get here (caught above)");
+        break;
+    }
+
+    // We're all done..
+    return swdata;
+}
+
+bool SDL_SW_QueryYUVTexturePixels(SDL_SW_YUVTexture *swdata, void **pixels,
+                                 int *pitch)
+{
+    *pixels = swdata->planes[0];
+    *pitch = swdata->pitches[0];
+    return true;
+}
+
+bool SDL_SW_UpdateYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect,
+                            const void *pixels, int pitch)
+{
+    switch (swdata->format) {
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+        if (rect->x == 0 && rect->y == 0 &&
+            rect->w == swdata->w && rect->h == swdata->h) {
+            SDL_memcpy(swdata->pixels, pixels,
+                       (size_t)(swdata->h * swdata->w) + 2 * ((swdata->h + 1) / 2) * ((swdata->w + 1) / 2));
+        } else {
+            Uint8 *src, *dst;
+            int row;
+            size_t length;
+
+            // Copy the Y plane
+            src = (Uint8 *)pixels;
+            dst = swdata->pixels + rect->y * swdata->w + rect->x;
+            length = rect->w;
+            for (row = 0; row < rect->h; ++row) {
+                SDL_memcpy(dst, src, length);
+                src += pitch;
+                dst += swdata->w;
+            }
+
+            // Copy the next plane
+            src = (Uint8 *)pixels + rect->h * pitch;
+            dst = swdata->pixels + swdata->h * swdata->w;
+            dst += rect->y / 2 * ((swdata->w + 1) / 2) + rect->x / 2;
+            length = (rect->w + 1) / 2;
+            for (row = 0; row < (rect->h + 1) / 2; ++row) {
+                SDL_memcpy(dst, src, length);
+                src += (pitch + 1) / 2;
+                dst += (swdata->w + 1) / 2;
+            }
+
+            // Copy the next plane
+            src = (Uint8 *)pixels + rect->h * pitch + ((rect->h + 1) / 2) * ((pitch + 1) / 2);
+            dst = swdata->pixels + swdata->h * swdata->w +
+                  ((swdata->h + 1) / 2) * ((swdata->w + 1) / 2);
+            dst += rect->y / 2 * ((swdata->w + 1) / 2) + rect->x / 2;
+            length = (rect->w + 1) / 2;
+            for (row = 0; row < (rect->h + 1) / 2; ++row) {
+                SDL_memcpy(dst, src, length);
+                src += (pitch + 1) / 2;
+                dst += (swdata->w + 1) / 2;
+            }
+        }
+        break;
+    case SDL_PIXELFORMAT_YUY2:
+    case SDL_PIXELFORMAT_UYVY:
+    case SDL_PIXELFORMAT_YVYU:
+    {
+        Uint8 *src, *dst;
+        int row;
+        size_t length;
+
+        src = (Uint8 *)pixels;
+        dst =
+            swdata->planes[0] + rect->y * swdata->pitches[0] +
+            rect->x * 2;
+        length = 4 * (((size_t)rect->w + 1) / 2);
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += swdata->pitches[0];
+        }
+    } break;
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+    {
+        if (rect->x == 0 && rect->y == 0 && rect->w == swdata->w && rect->h == swdata->h) {
+            SDL_memcpy(swdata->pixels, pixels,
+                       (size_t)(swdata->h * swdata->w) + 2 * ((swdata->h + 1) / 2) * ((swdata->w + 1) / 2));
+        } else {
+
+            Uint8 *src, *dst;
+            int row;
+            size_t length;
+
+            // Copy the Y plane
+            src = (Uint8 *)pixels;
+            dst = swdata->pixels + rect->y * swdata->w + rect->x;
+            length = rect->w;
+            for (row = 0; row < rect->h; ++row) {
+                SDL_memcpy(dst, src, length);
+                src += pitch;
+                dst += swdata->w;
+            }
+
+            // Copy the next plane
+            src = (Uint8 *)pixels + rect->h * pitch;
+            dst = swdata->pixels + swdata->h * swdata->w;
+            dst += 2 * ((rect->y + 1) / 2) * ((swdata->w + 1) / 2) + 2 * (rect->x / 2);
+            length = 2 * (((size_t)rect->w + 1) / 2);
+            for (row = 0; row < (rect->h + 1) / 2; ++row) {
+                SDL_memcpy(dst, src, length);
+                src += 2 * ((pitch + 1) / 2);
+                dst += 2 * ((swdata->w + 1) / 2);
+            }
+        }
+    } break;
+    default:
+        return SDL_SetError("Unsupported YUV format");
+    }
+    return true;
+}
+
+bool SDL_SW_UpdateYUVTexturePlanar(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch)
+{
+    const Uint8 *src;
+    Uint8 *dst;
+    int row;
+    size_t length;
+
+    // Copy the Y plane
+    src = Yplane;
+    dst = swdata->pixels + rect->y * swdata->w + rect->x;
+    length = rect->w;
+    for (row = 0; row < rect->h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += Ypitch;
+        dst += swdata->w;
+    }
+
+    // Copy the U plane
+    src = Uplane;
+    if (swdata->format == SDL_PIXELFORMAT_IYUV) {
+        dst = swdata->pixels + swdata->h * swdata->w;
+    } else {
+        dst = swdata->pixels + swdata->h * swdata->w +
+              ((swdata->h + 1) / 2) * ((swdata->w + 1) / 2);
+    }
+    dst += rect->y / 2 * ((swdata->w + 1) / 2) + rect->x / 2;
+    length = (rect->w + 1) / 2;
+    for (row = 0; row < (rect->h + 1) / 2; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += Upitch;
+        dst += (swdata->w + 1) / 2;
+    }
+
+    // Copy the V plane
+    src = Vplane;
+    if (swdata->format == SDL_PIXELFORMAT_YV12) {
+        dst = swdata->pixels + swdata->h * swdata->w;
+    } else {
+        dst = swdata->pixels + swdata->h * swdata->w +
+              ((swdata->h + 1) / 2) * ((swdata->w + 1) / 2);
+    }
+    dst += rect->y / 2 * ((swdata->w + 1) / 2) + rect->x / 2;
+    length = (rect->w + 1) / 2;
+    for (row = 0; row < (rect->h + 1) / 2; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += Vpitch;
+        dst += (swdata->w + 1) / 2;
+    }
+    return true;
+}
+
+bool SDL_SW_UpdateNVTexturePlanar(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch)
+{
+    const Uint8 *src;
+    Uint8 *dst;
+    int row;
+    size_t length;
+
+    // Copy the Y plane
+    src = Yplane;
+    dst = swdata->pixels + rect->y * swdata->w + rect->x;
+    length = rect->w;
+    for (row = 0; row < rect->h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += Ypitch;
+        dst += swdata->w;
+    }
+
+    // Copy the UV or VU plane
+    src = UVplane;
+    dst = swdata->pixels + swdata->h * swdata->w;
+    dst += rect->y * ((swdata->w + 1) / 2) + rect->x;
+    length = (rect->w + 1) / 2;
+    length *= 2;
+    for (row = 0; row < (rect->h + 1) / 2; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += UVpitch;
+        dst += 2 * ((swdata->w + 1) / 2);
+    }
+
+    return true;
+}
+
+bool SDL_SW_LockYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect,
+                          void **pixels, int *pitch)
+{
+    switch (swdata->format) {
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        if (rect && (rect->x != 0 || rect->y != 0 || rect->w != swdata->w || rect->h != swdata->h)) {
+            return SDL_SetError("YV12, IYUV, NV12, NV21 textures only support full surface locks");
+        }
+        break;
+    default:
+        return SDL_SetError("Unsupported YUV format");
+    }
+
+    if (rect) {
+        *pixels = swdata->planes[0] + rect->y * swdata->pitches[0] + rect->x * 2;
+    } else {
+        *pixels = swdata->planes[0];
+    }
+    *pitch = swdata->pitches[0];
+    return true;
+}
+
+void SDL_SW_UnlockYUVTexture(SDL_SW_YUVTexture *swdata)
+{
+}
+
+bool SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture *swdata, const SDL_Rect *srcrect, SDL_PixelFormat target_format, int w, int h, void *pixels, int pitch)
+{
+    int stretch;
+
+    // Make sure we're set up to display in the desired format
+    if (target_format != swdata->target_format && swdata->display) {
+        SDL_DestroySurface(swdata->display);
+        swdata->display = NULL;
+    }
+
+    stretch = 0;
+    if (srcrect->x || srcrect->y || srcrect->w < swdata->w || srcrect->h < swdata->h) {
+        /* The source rectangle has been clipped.
+           Using a scratch surface is easier than adding clipped
+           source support to all the blitters, plus that would
+           slow them down in the general unclipped case.
+         */
+        stretch = 1;
+    } else if ((srcrect->w != w) || (srcrect->h != h)) {
+        stretch = 1;
+    }
+    if (stretch) {
+        if (swdata->display) {
+            swdata->display->w = w;
+            swdata->display->h = h;
+            swdata->display->pixels = pixels;
+            swdata->display->pitch = pitch;
+        } else {
+            swdata->display = SDL_CreateSurfaceFrom(w, h, target_format, pixels, pitch);
+            if (!swdata->display) {
+                return false;
+            }
+            swdata->target_format = target_format;
+        }
+        if (!swdata->stretch) {
+            swdata->stretch = SDL_CreateSurface(swdata->w, swdata->h, target_format);
+            if (!swdata->stretch) {
+                return false;
+            }
+        }
+        pixels = swdata->stretch->pixels;
+        pitch = swdata->stretch->pitch;
+    }
+    if (!SDL_ConvertPixelsAndColorspace(swdata->w, swdata->h, swdata->format, swdata->colorspace, 0, swdata->planes[0], swdata->pitches[0], target_format, SDL_COLORSPACE_SRGB, 0, pixels, pitch)) {
+        return false;
+    }
+    if (stretch) {
+        SDL_Rect rect = *srcrect;
+        return SDL_StretchSurface(swdata->stretch, &rect, swdata->display, NULL, SDL_SCALEMODE_NEAREST);
+    } else {
+        return true;
+    }
+}
+
+void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture *swdata)
+{
+    if (swdata) {
+        SDL_aligned_free(swdata->pixels);
+        SDL_DestroySurface(swdata->stretch);
+        SDL_DestroySurface(swdata->display);
+        SDL_free(swdata);
+    }
+}
+
+#endif // SDL_HAVE_YUV
diff --git a/SDL-3.2.8/src/render/SDL_yuv_sw_c.h b/SDL-3.2.8/src/render/SDL_yuv_sw_c.h
new file mode 100644
index 0000000..807c44c
--- /dev/null
+++ b/SDL-3.2.8/src/render/SDL_yuv_sw_c.h
@@ -0,0 +1,63 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_yuv_sw_c_h_
+#define SDL_yuv_sw_c_h_
+
+#include "SDL_internal.h"
+
+// This is the software implementation of the YUV texture support
+
+struct SDL_SW_YUVTexture
+{
+    SDL_PixelFormat format;
+    SDL_Colorspace colorspace;
+    SDL_PixelFormat target_format;
+    int w, h;
+    Uint8 *pixels;
+
+    // These are just so we don't have to allocate them separately
+    int pitches[3];
+    Uint8 *planes[3];
+
+    // This is a temporary surface in case we have to stretch copy
+    SDL_Surface *stretch;
+    SDL_Surface *display;
+};
+
+typedef struct SDL_SW_YUVTexture SDL_SW_YUVTexture;
+
+extern SDL_SW_YUVTexture *SDL_SW_CreateYUVTexture(SDL_PixelFormat format, SDL_Colorspace colorspace, int w, int h);
+extern bool SDL_SW_QueryYUVTexturePixels(SDL_SW_YUVTexture *swdata, void **pixels, int *pitch);
+extern bool SDL_SW_UpdateYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, const void *pixels, int pitch);
+extern bool SDL_SW_UpdateYUVTexturePlanar(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect,
+                                         const Uint8 *Yplane, int Ypitch,
+                                         const Uint8 *Uplane, int Upitch,
+                                         const Uint8 *Vplane, int Vpitch);
+extern bool SDL_SW_UpdateNVTexturePlanar(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect,
+                                         const Uint8 *Yplane, int Ypitch,
+                                         const Uint8 *UVplane, int UVpitch);
+extern bool SDL_SW_LockYUVTexture(SDL_SW_YUVTexture *swdata, const SDL_Rect *rect, void **pixels, int *pitch);
+extern void SDL_SW_UnlockYUVTexture(SDL_SW_YUVTexture *swdata);
+extern bool SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture *swdata, const SDL_Rect *srcrect, SDL_PixelFormat target_format, int w, int h, void *pixels, int pitch);
+extern void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture *swdata);
+
+#endif // SDL_yuv_sw_c_h_
diff --git a/SDL-3.2.8/src/render/direct3d/D3D9_PixelShader_YUV.h b/SDL-3.2.8/src/render/direct3d/D3D9_PixelShader_YUV.h
new file mode 100644
index 0000000..e6d9130
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d/D3D9_PixelShader_YUV.h
@@ -0,0 +1,164 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 10.1
+//
+// Parameters:
+//
+//   float4 Bcoeff;
+//   float4 Gcoeff;
+//   float4 Rcoeff;
+//   float4 Yoffset;
+//   Texture2D theSampler+theTextureU;
+//   Texture2D theSampler+theTextureV;
+//   Texture2D theSampler+theTextureY;
+//
+//
+// Registers:
+//
+//   Name                   Reg   Size
+//   ---------------------- ----- ----
+//   Yoffset                c0       1
+//   Rcoeff                 c1       1
+//   Gcoeff                 c2       1
+//   Bcoeff                 c3       1
+//   theSampler+theTextureY s0       1
+//   theSampler+theTextureU s1       1
+//   theSampler+theTextureV s2       1
+//
+
+    ps_2_0
+    def c4, 1, 0, 0, 0
+    dcl t0.xy
+    dcl v0
+    dcl_2d s0
+    dcl_2d s1
+    dcl_2d s2
+    texld r0, t0, s0
+    texld r1, t0, s1
+    texld r2, t0, s2
+    mov r0.y, r1.x
+    mov r0.z, r2.x
+    add r0.xyz, r0, c0
+    dp3 r1.x, r0, c1
+    dp3 r1.y, r0, c2
+    dp3 r1.z, r0, c3
+    mov r1.w, c4.x
+    mul r0, r1, v0
+    mov oC0, r0
+
+// approximately 12 instruction slots used (3 texture, 9 arithmetic)
+#endif
+
+const BYTE g_ps20_main[] =
+{
+      0,   2, 255, 255, 254, 255, 
+     97,   0,  67,  84,  65,  66, 
+     28,   0,   0,   0,  87,   1, 
+      0,   0,   0,   2, 255, 255, 
+      7,   0,   0,   0,  28,   0, 
+      0,   0,   0,   1,   0,   0, 
+     80,   1,   0,   0, 168,   0, 
+      0,   0,   2,   0,   3,   0, 
+      1,   0,   0,   0, 176,   0, 
+      0,   0,   0,   0,   0,   0, 
+    192,   0,   0,   0,   2,   0, 
+      2,   0,   1,   0,   0,   0, 
+    176,   0,   0,   0,   0,   0, 
+      0,   0, 199,   0,   0,   0, 
+      2,   0,   1,   0,   1,   0, 
+      0,   0, 176,   0,   0,   0, 
+      0,   0,   0,   0, 206,   0, 
+      0,   0,   2,   0,   0,   0, 
+      1,   0,   0,   0, 176,   0, 
+      0,   0,   0,   0,   0,   0, 
+    214,   0,   0,   0,   3,   0, 
+      1,   0,   1,   0,   0,   0, 
+    240,   0,   0,   0,   0,   0, 
+      0,   0,   0,   1,   0,   0, 
+      3,   0,   2,   0,   1,   0, 
+      0,   0,  24,   1,   0,   0, 
+      0,   0,   0,   0,  40,   1, 
+      0,   0,   3,   0,   0,   0, 
+      1,   0,   0,   0,  64,   1, 
+      0,   0,   0,   0,   0,   0, 
+     66,  99, 111, 101, 102, 102, 
+      0, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+     71,  99, 111, 101, 102, 102, 
+      0,  82,  99, 111, 101, 102, 
+    102,   0,  89, 111, 102, 102, 
+    115, 101, 116,   0, 116, 104, 
+    101,  83,  97, 109, 112, 108, 
+    101, 114,  43, 116, 104, 101, 
+     84, 101, 120, 116, 117, 114, 
+    101,  85,   0, 171, 171, 171, 
+      4,   0,   7,   0,   1,   0, 
+      4,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0, 116, 104, 
+    101,  83,  97, 109, 112, 108, 
+    101, 114,  43, 116, 104, 101, 
+     84, 101, 120, 116, 117, 114, 
+    101,  86,   0, 171,   4,   0, 
+      7,   0,   1,   0,   4,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0, 116, 104, 101,  83, 
+     97, 109, 112, 108, 101, 114, 
+     43, 116, 104, 101,  84, 101, 
+    120, 116, 117, 114, 101,  89, 
+      0, 171,   4,   0,   7,   0, 
+      1,   0,   4,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+    112, 115,  95,  50,  95,  48, 
+      0,  77, 105,  99, 114, 111, 
+    115, 111, 102, 116,  32,  40, 
+     82,  41,  32,  72,  76,  83, 
+     76,  32,  83, 104,  97, 100, 
+    101, 114,  32,  67, 111, 109, 
+    112, 105, 108, 101, 114,  32, 
+     49,  48,  46,  49,   0, 171, 
+     81,   0,   0,   5,   4,   0, 
+     15, 160,   0,   0, 128,  63, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,   3, 176, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,  15, 144, 
+     31,   0,   0,   2,   0,   0, 
+      0, 144,   0,   8,  15, 160, 
+     31,   0,   0,   2,   0,   0, 
+      0, 144,   1,   8,  15, 160, 
+     31,   0,   0,   2,   0,   0, 
+      0, 144,   2,   8,  15, 160, 
+     66,   0,   0,   3,   0,   0, 
+     15, 128,   0,   0, 228, 176, 
+      0,   8, 228, 160,  66,   0, 
+      0,   3,   1,   0,  15, 128, 
+      0,   0, 228, 176,   1,   8, 
+    228, 160,  66,   0,   0,   3, 
+      2,   0,  15, 128,   0,   0, 
+    228, 176,   2,   8, 228, 160, 
+      1,   0,   0,   2,   0,   0, 
+      2, 128,   1,   0,   0, 128, 
+      1,   0,   0,   2,   0,   0, 
+      4, 128,   2,   0,   0, 128, 
+      2,   0,   0,   3,   0,   0, 
+      7, 128,   0,   0, 228, 128, 
+      0,   0, 228, 160,   8,   0, 
+      0,   3,   1,   0,   1, 128, 
+      0,   0, 228, 128,   1,   0, 
+    228, 160,   8,   0,   0,   3, 
+      1,   0,   2, 128,   0,   0, 
+    228, 128,   2,   0, 228, 160, 
+      8,   0,   0,   3,   1,   0, 
+      4, 128,   0,   0, 228, 128, 
+      3,   0, 228, 160,   1,   0, 
+      0,   2,   1,   0,   8, 128, 
+      4,   0,   0, 160,   5,   0, 
+      0,   3,   0,   0,  15, 128, 
+      1,   0, 228, 128,   0,   0, 
+    228, 144,   1,   0,   0,   2, 
+      0,   8,  15, 128,   0,   0, 
+    228, 128, 255, 255,   0,   0
+};
diff --git a/SDL-3.2.8/src/render/direct3d/D3D9_PixelShader_YUV.hlsl b/SDL-3.2.8/src/render/direct3d/D3D9_PixelShader_YUV.hlsl
new file mode 100644
index 0000000..8804848
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d/D3D9_PixelShader_YUV.hlsl
@@ -0,0 +1,47 @@
+
+Texture2D theTextureY : register(t0);
+Texture2D theTextureU : register(t1);
+Texture2D theTextureV : register(t2);
+
+SamplerState theSampler = sampler_state
+{
+    addressU = Clamp;
+    addressV = Clamp;
+    mipfilter = NONE;
+    minfilter = LINEAR;
+    magfilter = LINEAR;
+};
+
+struct PixelShaderInput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+cbuffer Constants : register(b0)
+{
+    float4 Yoffset;
+    float4 Rcoeff;
+    float4 Gcoeff;
+    float4 Bcoeff;
+};
+
+
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    float4 Output;
+
+    float3 yuv;
+    yuv.x = theTextureY.Sample(theSampler, input.tex).r;
+    yuv.y = theTextureU.Sample(theSampler, input.tex).r;
+    yuv.z = theTextureV.Sample(theSampler, input.tex).r;
+
+    yuv += Yoffset.xyz;
+    Output.r = dot(yuv, Rcoeff.xyz);
+    Output.g = dot(yuv, Gcoeff.xyz);
+    Output.b = dot(yuv, Bcoeff.xyz);
+    Output.a = 1.0f;
+
+    return Output * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d/SDL_render_d3d.c b/SDL-3.2.8/src/render/direct3d/SDL_render_d3d.c
new file mode 100644
index 0000000..ccb5b3c
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d/SDL_render_d3d.c
@@ -0,0 +1,1778 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_D3D
+
+#include "../../core/windows/SDL_windows.h"
+
+#include "../SDL_sysrender.h"
+#include "../SDL_d3dmath.h"
+#include "../../video/windows/SDL_windowsvideo.h"
+#include "../../video/SDL_pixels_c.h"
+
+#define D3D_DEBUG_INFO
+#include <d3d9.h>
+
+#include "SDL_shaders_d3d.h"
+
+typedef struct
+{
+    SDL_Rect viewport;
+    bool viewport_dirty;
+    SDL_Texture *texture;
+    SDL_BlendMode blend;
+    bool cliprect_enabled;
+    bool cliprect_enabled_dirty;
+    SDL_Rect cliprect;
+    bool cliprect_dirty;
+    D3D9_Shader shader;
+    const float *shader_params;
+} D3D_DrawStateCache;
+
+// Direct3D renderer implementation
+
+typedef struct
+{
+    void *d3dDLL;
+    IDirect3D9 *d3d;
+    IDirect3DDevice9 *device;
+    UINT adapter;
+    D3DPRESENT_PARAMETERS pparams;
+    bool updateSize;
+    bool beginScene;
+    bool enableSeparateAlphaBlend;
+    D3DTEXTUREFILTERTYPE scaleMode[3];
+    SDL_TextureAddressMode addressMode[3];
+    IDirect3DSurface9 *defaultRenderTarget;
+    IDirect3DSurface9 *currentRenderTarget;
+    void *d3dxDLL;
+#ifdef SDL_HAVE_YUV
+    LPDIRECT3DPIXELSHADER9 shaders[NUM_SHADERS];
+#endif
+    LPDIRECT3DVERTEXBUFFER9 vertexBuffers[8];
+    size_t vertexBufferSize[8];
+    int currentVertexBuffer;
+    bool reportedVboProblem;
+    D3D_DrawStateCache drawstate;
+} D3D_RenderData;
+
+typedef struct
+{
+    bool dirty;
+    int w, h;
+    DWORD usage;
+    Uint32 format;
+    D3DFORMAT d3dfmt;
+    IDirect3DTexture9 *texture;
+    IDirect3DTexture9 *staging;
+} D3D_TextureRep;
+
+typedef struct
+{
+    D3D_TextureRep texture;
+    D3DTEXTUREFILTERTYPE scaleMode;
+    D3D9_Shader shader;
+    const float *shader_params;
+
+#ifdef SDL_HAVE_YUV
+    // YV12 texture support
+    bool yuv;
+    D3D_TextureRep utexture;
+    D3D_TextureRep vtexture;
+    Uint8 *pixels;
+    int pitch;
+    SDL_Rect locked_rect;
+#endif
+} D3D_TextureData;
+
+typedef struct
+{
+    float x, y, z;
+    DWORD color;
+    float u, v;
+} Vertex;
+
+static bool D3D_SetError(const char *prefix, HRESULT result)
+{
+    const char *error;
+
+    switch (result) {
+    case D3DERR_WRONGTEXTUREFORMAT:
+        error = "WRONGTEXTUREFORMAT";
+        break;
+    case D3DERR_UNSUPPORTEDCOLOROPERATION:
+        error = "UNSUPPORTEDCOLOROPERATION";
+        break;
+    case D3DERR_UNSUPPORTEDCOLORARG:
+        error = "UNSUPPORTEDCOLORARG";
+        break;
+    case D3DERR_UNSUPPORTEDALPHAOPERATION:
+        error = "UNSUPPORTEDALPHAOPERATION";
+        break;
+    case D3DERR_UNSUPPORTEDALPHAARG:
+        error = "UNSUPPORTEDALPHAARG";
+        break;
+    case D3DERR_TOOMANYOPERATIONS:
+        error = "TOOMANYOPERATIONS";
+        break;
+    case D3DERR_CONFLICTINGTEXTUREFILTER:
+        error = "CONFLICTINGTEXTUREFILTER";
+        break;
+    case D3DERR_UNSUPPORTEDFACTORVALUE:
+        error = "UNSUPPORTEDFACTORVALUE";
+        break;
+    case D3DERR_CONFLICTINGRENDERSTATE:
+        error = "CONFLICTINGRENDERSTATE";
+        break;
+    case D3DERR_UNSUPPORTEDTEXTUREFILTER:
+        error = "UNSUPPORTEDTEXTUREFILTER";
+        break;
+    case D3DERR_CONFLICTINGTEXTUREPALETTE:
+        error = "CONFLICTINGTEXTUREPALETTE";
+        break;
+    case D3DERR_DRIVERINTERNALERROR:
+        error = "DRIVERINTERNALERROR";
+        break;
+    case D3DERR_NOTFOUND:
+        error = "NOTFOUND";
+        break;
+    case D3DERR_MOREDATA:
+        error = "MOREDATA";
+        break;
+    case D3DERR_DEVICELOST:
+        error = "DEVICELOST";
+        break;
+    case D3DERR_DEVICENOTRESET:
+        error = "DEVICENOTRESET";
+        break;
+    case D3DERR_NOTAVAILABLE:
+        error = "NOTAVAILABLE";
+        break;
+    case D3DERR_OUTOFVIDEOMEMORY:
+        error = "OUTOFVIDEOMEMORY";
+        break;
+    case D3DERR_INVALIDDEVICE:
+        error = "INVALIDDEVICE";
+        break;
+    case D3DERR_INVALIDCALL:
+        error = "INVALIDCALL";
+        break;
+    case D3DERR_DRIVERINVALIDCALL:
+        error = "DRIVERINVALIDCALL";
+        break;
+    case D3DERR_WASSTILLDRAWING:
+        error = "WASSTILLDRAWING";
+        break;
+    default:
+        error = "UNKNOWN";
+        break;
+    }
+    return SDL_SetError("%s: %s", prefix, error);
+}
+
+static D3DFORMAT PixelFormatToD3DFMT(Uint32 format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_RGB565:
+        return D3DFMT_R5G6B5;
+    case SDL_PIXELFORMAT_XRGB8888:
+        return D3DFMT_X8R8G8B8;
+    case SDL_PIXELFORMAT_ARGB8888:
+        return D3DFMT_A8R8G8B8;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        return D3DFMT_L8;
+    default:
+        return D3DFMT_UNKNOWN;
+    }
+}
+
+static SDL_PixelFormat D3DFMTToPixelFormat(D3DFORMAT format)
+{
+    switch (format) {
+    case D3DFMT_R5G6B5:
+        return SDL_PIXELFORMAT_RGB565;
+    case D3DFMT_X8R8G8B8:
+        return SDL_PIXELFORMAT_XRGB8888;
+    case D3DFMT_A8R8G8B8:
+        return SDL_PIXELFORMAT_ARGB8888;
+    default:
+        return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static void D3D_InitRenderState(D3D_RenderData *data)
+{
+    D3DMATRIX matrix;
+
+    IDirect3DDevice9 *device = data->device;
+    IDirect3DDevice9_SetPixelShader(device, NULL);
+    IDirect3DDevice9_SetTexture(device, 0, NULL);
+    IDirect3DDevice9_SetTexture(device, 1, NULL);
+    IDirect3DDevice9_SetTexture(device, 2, NULL);
+    IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
+    IDirect3DDevice9_SetVertexShader(device, NULL);
+    IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
+    IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
+    IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
+
+    // Enable color modulation by diffuse color
+    IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP,
+                                          D3DTOP_MODULATE);
+    IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1,
+                                          D3DTA_TEXTURE);
+    IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2,
+                                          D3DTA_DIFFUSE);
+
+    // Enable alpha modulation by diffuse alpha
+    IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP,
+                                          D3DTOP_MODULATE);
+    IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG1,
+                                          D3DTA_TEXTURE);
+    IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG2,
+                                          D3DTA_DIFFUSE);
+
+    // Enable separate alpha blend function, if possible
+    if (data->enableSeparateAlphaBlend) {
+        IDirect3DDevice9_SetRenderState(device, D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
+    }
+
+    // Disable second texture stage, since we're done
+    IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP,
+                                          D3DTOP_DISABLE);
+    IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_ALPHAOP,
+                                          D3DTOP_DISABLE);
+
+    // Set an identity world and view matrix
+    SDL_zero(matrix);
+    matrix.m[0][0] = 1.0f;
+    matrix.m[1][1] = 1.0f;
+    matrix.m[2][2] = 1.0f;
+    matrix.m[3][3] = 1.0f;
+    IDirect3DDevice9_SetTransform(device, D3DTS_WORLD, &matrix);
+    IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, &matrix);
+
+    // Reset our current scale mode
+    SDL_memset(data->scaleMode, 0xFF, sizeof(data->scaleMode));
+
+    // Reset our current address mode
+    SDL_zeroa(data->addressMode);
+
+    // Start the render with beginScene
+    data->beginScene = true;
+}
+
+static bool D3D_Reset(SDL_Renderer *renderer);
+
+static bool D3D_ActivateRenderer(SDL_Renderer *renderer)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    HRESULT result;
+
+    if (data->updateSize) {
+        SDL_Window *window = renderer->window;
+        int w, h;
+        const SDL_DisplayMode *fullscreen_mode = NULL;
+
+        SDL_GetWindowSizeInPixels(window, &w, &h);
+        data->pparams.BackBufferWidth = w;
+        data->pparams.BackBufferHeight = h;
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) {
+            fullscreen_mode = SDL_GetWindowFullscreenMode(window);
+        }
+        if (fullscreen_mode) {
+            data->pparams.Windowed = FALSE;
+            data->pparams.BackBufferFormat = PixelFormatToD3DFMT(fullscreen_mode->format);
+            data->pparams.FullScreen_RefreshRateInHz = (UINT)SDL_ceilf(fullscreen_mode->refresh_rate);
+        } else {
+            data->pparams.Windowed = TRUE;
+            data->pparams.BackBufferFormat = D3DFMT_UNKNOWN;
+            data->pparams.FullScreen_RefreshRateInHz = 0;
+        }
+        if (!D3D_Reset(renderer)) {
+            return false;
+        }
+
+        data->updateSize = false;
+    }
+    if (data->beginScene) {
+        result = IDirect3DDevice9_BeginScene(data->device);
+        if (result == D3DERR_DEVICELOST) {
+            if (!D3D_Reset(renderer)) {
+                return false;
+            }
+            result = IDirect3DDevice9_BeginScene(data->device);
+        }
+        if (FAILED(result)) {
+            return D3D_SetError("BeginScene()", result);
+        }
+        data->beginScene = false;
+    }
+    return true;
+}
+
+static void D3D_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+
+    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
+        data->updateSize = true;
+    }
+}
+
+static D3DBLEND GetBlendFunc(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return D3DBLEND_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return D3DBLEND_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return D3DBLEND_SRCCOLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return D3DBLEND_INVSRCCOLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return D3DBLEND_SRCALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return D3DBLEND_INVSRCALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return D3DBLEND_DESTCOLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return D3DBLEND_INVDESTCOLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return D3DBLEND_DESTALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return D3DBLEND_INVDESTALPHA;
+    default:
+        break;
+    }
+    return (D3DBLEND)0;
+}
+
+static D3DBLENDOP GetBlendEquation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return D3DBLENDOP_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return D3DBLENDOP_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return D3DBLENDOP_REVSUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return D3DBLENDOP_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return D3DBLENDOP_MAX;
+    default:
+        break;
+    }
+    return (D3DBLENDOP)0;
+}
+
+static bool D3D_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
+        !GetBlendEquation(colorOperation) ||
+        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
+        !GetBlendEquation(alphaOperation)) {
+        return false;
+    }
+
+    if (!data->enableSeparateAlphaBlend) {
+        if ((srcColorFactor != srcAlphaFactor) || (dstColorFactor != dstAlphaFactor) || (colorOperation != alphaOperation)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool D3D_CreateTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *texture, DWORD usage, Uint32 format, D3DFORMAT d3dfmt, int w, int h)
+{
+    HRESULT result;
+
+    texture->dirty = false;
+    texture->w = w;
+    texture->h = h;
+    texture->usage = usage;
+    texture->format = format;
+    texture->d3dfmt = d3dfmt;
+
+    result = IDirect3DDevice9_CreateTexture(device, w, h, 1, usage,
+                                            PixelFormatToD3DFMT(format),
+                                            D3DPOOL_DEFAULT, &texture->texture, NULL);
+    if (FAILED(result)) {
+        return D3D_SetError("CreateTexture(D3DPOOL_DEFAULT)", result);
+    }
+    return true;
+}
+
+static bool D3D_CreateStagingTexture(IDirect3DDevice9 *device, D3D_TextureRep *texture)
+{
+    HRESULT result;
+
+    if (!texture->staging) {
+        result = IDirect3DDevice9_CreateTexture(device, texture->w, texture->h, 1, 0,
+                                                texture->d3dfmt, D3DPOOL_SYSTEMMEM, &texture->staging, NULL);
+        if (FAILED(result)) {
+            return D3D_SetError("CreateTexture(D3DPOOL_SYSTEMMEM)", result);
+        }
+    }
+    return true;
+}
+
+static bool D3D_RecreateTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *texture)
+{
+    if (texture->texture) {
+        IDirect3DTexture9_Release(texture->texture);
+        texture->texture = NULL;
+    }
+    if (texture->staging) {
+        IDirect3DTexture9_AddDirtyRect(texture->staging, NULL);
+        texture->dirty = true;
+    }
+    return true;
+}
+
+static bool D3D_UpdateTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *texture, int x, int y, int w, int h, const void *pixels, int pitch)
+{
+    RECT d3drect;
+    D3DLOCKED_RECT locked;
+    const Uint8 *src;
+    Uint8 *dst;
+    int row, length;
+    HRESULT result;
+
+    if (!D3D_CreateStagingTexture(device, texture)) {
+        return false;
+    }
+
+    d3drect.left = x;
+    d3drect.right = (LONG)x + w;
+    d3drect.top = y;
+    d3drect.bottom = (LONG)y + h;
+
+    result = IDirect3DTexture9_LockRect(texture->staging, 0, &locked, &d3drect, 0);
+    if (FAILED(result)) {
+        return D3D_SetError("LockRect()", result);
+    }
+
+    src = (const Uint8 *)pixels;
+    dst = (Uint8 *)locked.pBits;
+    length = w * SDL_BYTESPERPIXEL(texture->format);
+    if (length == pitch && length == locked.Pitch) {
+        SDL_memcpy(dst, src, (size_t)length * h);
+    } else {
+        if (length > pitch) {
+            length = pitch;
+        }
+        if (length > locked.Pitch) {
+            length = locked.Pitch;
+        }
+        for (row = 0; row < h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += locked.Pitch;
+        }
+    }
+    result = IDirect3DTexture9_UnlockRect(texture->staging, 0);
+    if (FAILED(result)) {
+        return D3D_SetError("UnlockRect()", result);
+    }
+    texture->dirty = true;
+
+    return true;
+}
+
+static void D3D_DestroyTextureRep(D3D_TextureRep *texture)
+{
+    if (texture->texture) {
+        IDirect3DTexture9_Release(texture->texture);
+        texture->texture = NULL;
+    }
+    if (texture->staging) {
+        IDirect3DTexture9_Release(texture->staging);
+        texture->staging = NULL;
+    }
+}
+
+static bool D3D_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata;
+    DWORD usage;
+
+    texturedata = (D3D_TextureData *)SDL_calloc(1, sizeof(*texturedata));
+    if (!texturedata) {
+        return false;
+    }
+    texturedata->scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? D3DTEXF_POINT : D3DTEXF_LINEAR;
+
+    texture->internal = texturedata;
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        usage = D3DUSAGE_RENDERTARGET;
+    } else {
+        usage = 0;
+    }
+
+    if (!D3D_CreateTextureRep(data->device, &texturedata->texture, usage, texture->format, PixelFormatToD3DFMT(texture->format), texture->w, texture->h)) {
+        return false;
+    }
+#ifdef SDL_HAVE_YUV
+    if (texture->format == SDL_PIXELFORMAT_YV12 ||
+        texture->format == SDL_PIXELFORMAT_IYUV) {
+        texturedata->yuv = true;
+
+        if (!D3D_CreateTextureRep(data->device, &texturedata->utexture, usage, texture->format, PixelFormatToD3DFMT(texture->format), (texture->w + 1) / 2, (texture->h + 1) / 2)) {
+            return false;
+        }
+
+        if (!D3D_CreateTextureRep(data->device, &texturedata->vtexture, usage, texture->format, PixelFormatToD3DFMT(texture->format), (texture->w + 1) / 2, (texture->h + 1) / 2)) {
+            return false;
+        }
+
+        texturedata->shader = SHADER_YUV;
+        texturedata->shader_params = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8);
+        if (texturedata->shader_params == NULL) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+#endif
+    return true;
+}
+
+static bool D3D_RecreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+
+    if (!texturedata) {
+        return true;
+    }
+
+    if (!D3D_RecreateTextureRep(data->device, &texturedata->texture)) {
+        return false;
+    }
+#ifdef SDL_HAVE_YUV
+    if (texturedata->yuv) {
+        if (!D3D_RecreateTextureRep(data->device, &texturedata->utexture)) {
+            return false;
+        }
+
+        if (!D3D_RecreateTextureRep(data->device, &texturedata->vtexture)) {
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
+static bool D3D_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+
+    if (!texturedata) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!D3D_UpdateTextureRep(data->device, &texturedata->texture, rect->x, rect->y, rect->w, rect->h, pixels, pitch)) {
+        return false;
+    }
+#ifdef SDL_HAVE_YUV
+    if (texturedata->yuv) {
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+
+        if (!D3D_UpdateTextureRep(data->device, texture->format == SDL_PIXELFORMAT_YV12 ? &texturedata->vtexture : &texturedata->utexture, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, pixels, (pitch + 1) / 2)) {
+            return false;
+        }
+
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + ((rect->h + 1) / 2) * ((pitch + 1) / 2));
+        if (!D3D_UpdateTextureRep(data->device, texture->format == SDL_PIXELFORMAT_YV12 ? &texturedata->utexture : &texturedata->vtexture, rect->x / 2, (rect->y + 1) / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, pixels, (pitch + 1) / 2)) {
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool D3D_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                const SDL_Rect *rect,
+                                const Uint8 *Yplane, int Ypitch,
+                                const Uint8 *Uplane, int Upitch,
+                                const Uint8 *Vplane, int Vpitch)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+
+    if (!texturedata) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!D3D_UpdateTextureRep(data->device, &texturedata->texture, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch)) {
+        return false;
+    }
+    if (!D3D_UpdateTextureRep(data->device, &texturedata->utexture, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Uplane, Upitch)) {
+        return false;
+    }
+    if (!D3D_UpdateTextureRep(data->device, &texturedata->vtexture, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Vplane, Vpitch)) {
+        return false;
+    }
+    return true;
+}
+#endif
+
+static bool D3D_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                           const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+    IDirect3DDevice9 *device = data->device;
+
+    if (!texturedata) {
+        return SDL_SetError("Texture is not currently available");
+    }
+#ifdef SDL_HAVE_YUV
+    texturedata->locked_rect = *rect;
+
+    if (texturedata->yuv) {
+        // It's more efficient to upload directly...
+        if (!texturedata->pixels) {
+            texturedata->pitch = texture->w;
+            texturedata->pixels = (Uint8 *)SDL_malloc((texture->h * texturedata->pitch * 3) / 2);
+            if (!texturedata->pixels) {
+                return false;
+            }
+        }
+        *pixels =
+            (void *)(texturedata->pixels + rect->y * texturedata->pitch +
+                     rect->x * SDL_BYTESPERPIXEL(texture->format));
+        *pitch = texturedata->pitch;
+    } else
+#endif
+    {
+        RECT d3drect;
+        D3DLOCKED_RECT locked;
+        HRESULT result;
+
+        if (!D3D_CreateStagingTexture(device, &texturedata->texture)) {
+            return false;
+        }
+
+        d3drect.left = rect->x;
+        d3drect.right = (LONG)rect->x + rect->w;
+        d3drect.top = rect->y;
+        d3drect.bottom = (LONG)rect->y + rect->h;
+
+        result = IDirect3DTexture9_LockRect(texturedata->texture.staging, 0, &locked, &d3drect, 0);
+        if (FAILED(result)) {
+            return D3D_SetError("LockRect()", result);
+        }
+        *pixels = locked.pBits;
+        *pitch = locked.Pitch;
+    }
+    return true;
+}
+
+static void D3D_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+
+    if (!texturedata) {
+        return;
+    }
+#ifdef SDL_HAVE_YUV
+    if (texturedata->yuv) {
+        const SDL_Rect *rect = &texturedata->locked_rect;
+        void *pixels =
+            (void *)(texturedata->pixels + rect->y * texturedata->pitch +
+                     rect->x * SDL_BYTESPERPIXEL(texture->format));
+        D3D_UpdateTexture(renderer, texture, rect, pixels, texturedata->pitch);
+    } else
+#endif
+    {
+        IDirect3DTexture9_UnlockRect(texturedata->texture.staging, 0);
+        texturedata->texture.dirty = true;
+        if (data->drawstate.texture == texture) {
+            data->drawstate.texture = NULL;
+            data->drawstate.shader = SHADER_NONE;
+            data->drawstate.shader_params = NULL;
+            IDirect3DDevice9_SetPixelShader(data->device, NULL);
+            IDirect3DDevice9_SetTexture(data->device, 0, NULL);
+        }
+    }
+}
+
+static void D3D_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+
+    if (!texturedata) {
+        return;
+    }
+
+    texturedata->scaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? D3DTEXF_POINT : D3DTEXF_LINEAR;
+}
+
+static bool D3D_SetRenderTargetInternal(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *texturedata;
+    D3D_TextureRep *texturerep;
+    HRESULT result;
+    IDirect3DDevice9 *device = data->device;
+
+    // Release the previous render target if it wasn't the default one
+    if (data->currentRenderTarget) {
+        IDirect3DSurface9_Release(data->currentRenderTarget);
+        data->currentRenderTarget = NULL;
+    }
+
+    if (!texture) {
+        IDirect3DDevice9_SetRenderTarget(data->device, 0, data->defaultRenderTarget);
+        return true;
+    }
+
+    texturedata = (D3D_TextureData *)texture->internal;
+    if (!texturedata) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    // Make sure the render target is updated if it was locked and written to
+    texturerep = &texturedata->texture;
+    if (texturerep->dirty && texturerep->staging) {
+        if (!texturerep->texture) {
+            result = IDirect3DDevice9_CreateTexture(device, texturerep->w, texturerep->h, 1, texturerep->usage,
+                                                    PixelFormatToD3DFMT(texturerep->format), D3DPOOL_DEFAULT, &texturerep->texture, NULL);
+            if (FAILED(result)) {
+                return D3D_SetError("CreateTexture(D3DPOOL_DEFAULT)", result);
+            }
+        }
+
+        result = IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)texturerep->staging, (IDirect3DBaseTexture9 *)texturerep->texture);
+        if (FAILED(result)) {
+            return D3D_SetError("UpdateTexture()", result);
+        }
+        texturerep->dirty = false;
+    }
+
+    result = IDirect3DTexture9_GetSurfaceLevel(texturedata->texture.texture, 0, &data->currentRenderTarget);
+    if (FAILED(result)) {
+        return D3D_SetError("GetSurfaceLevel()", result);
+    }
+    result = IDirect3DDevice9_SetRenderTarget(data->device, 0, data->currentRenderTarget);
+    if (FAILED(result)) {
+        return D3D_SetError("SetRenderTarget()", result);
+    }
+
+    return true;
+}
+
+static bool D3D_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    if (!D3D_ActivateRenderer(renderer)) {
+        return false;
+    }
+
+    return D3D_SetRenderTargetInternal(renderer, texture);
+}
+
+static bool D3D_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool D3D_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    const DWORD color = D3DCOLOR_COLORVALUE(cmd->data.draw.color.r * cmd->data.draw.color_scale,
+                                            cmd->data.draw.color.g * cmd->data.draw.color_scale,
+                                            cmd->data.draw.color.b * cmd->data.draw.color_scale,
+                                            cmd->data.draw.color.a);
+    const size_t vertslen = count * sizeof(Vertex);
+    Vertex *verts = (Vertex *)SDL_AllocateRenderVertices(renderer, vertslen, 0, &cmd->data.draw.first);
+    int i;
+
+    if (!verts) {
+        return false;
+    }
+
+    SDL_memset(verts, '\0', vertslen);
+    cmd->data.draw.count = count;
+
+    for (i = 0; i < count; i++, verts++, points++) {
+        verts->x = points->x;
+        verts->y = points->y;
+        verts->color = color;
+    }
+
+    return true;
+}
+
+static bool D3D_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                             const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                             int num_vertices, const void *indices, int num_indices, int size_indices,
+                             float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    Vertex *verts = (Vertex *)SDL_AllocateRenderVertices(renderer, count * sizeof(Vertex), 0, &cmd->data.draw.first);
+    const float color_scale = cmd->data.draw.color_scale;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        SDL_FColor *col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+        col_ = (SDL_FColor *)((char *)color + j * color_stride);
+
+        verts->x = xy_[0] * scale_x - 0.5f;
+        verts->y = xy_[1] * scale_y - 0.5f;
+        verts->z = 0.0f;
+        verts->color = D3DCOLOR_COLORVALUE(col_->r * color_scale, col_->g * color_scale, col_->b * color_scale, col_->a);
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            verts->u = uv_[0];
+            verts->v = uv_[1];
+        } else {
+            verts->u = 0.0f;
+            verts->v = 0.0f;
+        }
+
+        verts += 1;
+    }
+    return true;
+}
+
+static bool UpdateDirtyTexture(IDirect3DDevice9 *device, D3D_TextureRep *texture)
+{
+    if (texture->dirty && texture->staging) {
+        HRESULT result;
+        if (!texture->texture) {
+            result = IDirect3DDevice9_CreateTexture(device, texture->w, texture->h, 1, texture->usage,
+                                                    PixelFormatToD3DFMT(texture->format), D3DPOOL_DEFAULT, &texture->texture, NULL);
+            if (FAILED(result)) {
+                return D3D_SetError("CreateTexture(D3DPOOL_DEFAULT)", result);
+            }
+        }
+
+        result = IDirect3DDevice9_UpdateTexture(device, (IDirect3DBaseTexture9 *)texture->staging, (IDirect3DBaseTexture9 *)texture->texture);
+        if (FAILED(result)) {
+            return D3D_SetError("UpdateTexture()", result);
+        }
+        texture->dirty = false;
+    }
+    return true;
+}
+
+static bool BindTextureRep(IDirect3DDevice9 *device, D3D_TextureRep *texture, DWORD sampler)
+{
+    HRESULT result;
+    UpdateDirtyTexture(device, texture);
+    result = IDirect3DDevice9_SetTexture(device, sampler, (IDirect3DBaseTexture9 *)texture->texture);
+    if (FAILED(result)) {
+        return D3D_SetError("SetTexture()", result);
+    }
+    return true;
+}
+
+static void UpdateTextureScaleMode(D3D_RenderData *data, D3D_TextureData *texturedata, unsigned index)
+{
+    if (texturedata->scaleMode != data->scaleMode[index]) {
+        IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MINFILTER, texturedata->scaleMode);
+        IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_MAGFILTER, texturedata->scaleMode);
+        data->scaleMode[index] = texturedata->scaleMode;
+    }
+}
+
+static void UpdateTextureAddressMode(D3D_RenderData *data, SDL_TextureAddressMode addressMode, unsigned index)
+{
+    if (addressMode != data->addressMode[index]) {
+        switch (addressMode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
+            IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
+            IDirect3DDevice9_SetSamplerState(data->device, index, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
+            break;
+        default:
+            break;
+        }
+        data->addressMode[index] = addressMode;
+    }
+}
+
+static bool SetupTextureState(D3D_RenderData *data, SDL_Texture *texture, SDL_TextureAddressMode addressMode, D3D9_Shader *shader, const float **shader_params)
+{
+    D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+
+    if (!texturedata) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    UpdateTextureScaleMode(data, texturedata, 0);
+    UpdateTextureAddressMode(data, addressMode, 0);
+
+    *shader = texturedata->shader;
+    *shader_params = texturedata->shader_params;
+
+    if (!BindTextureRep(data->device, &texturedata->texture, 0)) {
+        return false;
+    }
+#ifdef SDL_HAVE_YUV
+    if (texturedata->yuv) {
+        UpdateTextureScaleMode(data, texturedata, 1);
+        UpdateTextureScaleMode(data, texturedata, 2);
+        UpdateTextureAddressMode(data, addressMode, 1);
+        UpdateTextureAddressMode(data, addressMode, 2);
+
+        if (!BindTextureRep(data->device, &texturedata->utexture, 1)) {
+            return false;
+        }
+        if (!BindTextureRep(data->device, &texturedata->vtexture, 2)) {
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
+static bool SetDrawState(D3D_RenderData *data, const SDL_RenderCommand *cmd)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+
+    if (texture != data->drawstate.texture) {
+#ifdef SDL_HAVE_YUV
+        D3D_TextureData *oldtexturedata = data->drawstate.texture ? (D3D_TextureData *)data->drawstate.texture->internal : NULL;
+        D3D_TextureData *newtexturedata = texture ? (D3D_TextureData *)texture->internal : NULL;
+#endif
+        D3D9_Shader shader = SHADER_NONE;
+        const float *shader_params = NULL;
+
+        // disable any enabled textures we aren't going to use, let SetupTextureState() do the rest.
+        if (!texture) {
+            IDirect3DDevice9_SetTexture(data->device, 0, NULL);
+        }
+#ifdef SDL_HAVE_YUV
+        if ((!newtexturedata || !newtexturedata->yuv) && (oldtexturedata && oldtexturedata->yuv)) {
+            IDirect3DDevice9_SetTexture(data->device, 1, NULL);
+            IDirect3DDevice9_SetTexture(data->device, 2, NULL);
+        }
+#endif
+        if (texture && !SetupTextureState(data, texture, cmd->data.draw.texture_address_mode, &shader, &shader_params)) {
+            return false;
+        }
+
+#ifdef SDL_HAVE_YUV
+        if (shader != data->drawstate.shader) {
+            const HRESULT result = IDirect3DDevice9_SetPixelShader(data->device, data->shaders[shader]);
+            if (FAILED(result)) {
+                return D3D_SetError("IDirect3DDevice9_SetPixelShader()", result);
+            }
+            data->drawstate.shader = shader;
+        }
+
+        if (shader_params != data->drawstate.shader_params) {
+            if (shader_params) {
+                const UINT shader_params_length = 4; // The YUV shader takes 4 float4 parameters
+                const HRESULT result = IDirect3DDevice9_SetPixelShaderConstantF(data->device, 0, shader_params, shader_params_length);
+                if (FAILED(result)) {
+                    return D3D_SetError("IDirect3DDevice9_SetPixelShaderConstantF()", result);
+                }
+            }
+            data->drawstate.shader_params = shader_params;
+        }
+#endif // SDL_HAVE_YUV
+
+        data->drawstate.texture = texture;
+    } else if (texture) {
+        D3D_TextureData *texturedata = (D3D_TextureData *)texture->internal;
+        UpdateDirtyTexture(data->device, &texturedata->texture);
+#ifdef SDL_HAVE_YUV
+        if (texturedata->yuv) {
+            UpdateDirtyTexture(data->device, &texturedata->utexture);
+            UpdateDirtyTexture(data->device, &texturedata->vtexture);
+        }
+#endif
+    }
+
+    if (blend != data->drawstate.blend) {
+        if (blend == SDL_BLENDMODE_NONE) {
+            IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE, FALSE);
+        } else {
+            IDirect3DDevice9_SetRenderState(data->device, D3DRS_ALPHABLENDENABLE, TRUE);
+            IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLEND,
+                                            GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)));
+            IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLEND,
+                                            GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)));
+            IDirect3DDevice9_SetRenderState(data->device, D3DRS_BLENDOP,
+                                            GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
+            if (data->enableSeparateAlphaBlend) {
+                IDirect3DDevice9_SetRenderState(data->device, D3DRS_SRCBLENDALPHA,
+                                                GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)));
+                IDirect3DDevice9_SetRenderState(data->device, D3DRS_DESTBLENDALPHA,
+                                                GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
+                IDirect3DDevice9_SetRenderState(data->device, D3DRS_BLENDOPALPHA,
+                                                GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend)));
+            }
+        }
+
+        data->drawstate.blend = blend;
+    }
+
+    if (data->drawstate.viewport_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+        D3DVIEWPORT9 d3dviewport;
+        d3dviewport.X = viewport->x;
+        d3dviewport.Y = viewport->y;
+        d3dviewport.Width = viewport->w;
+        d3dviewport.Height = viewport->h;
+        d3dviewport.MinZ = 0.0f;
+        d3dviewport.MaxZ = 1.0f;
+        IDirect3DDevice9_SetViewport(data->device, &d3dviewport);
+
+        // Set an orthographic projection matrix
+        if (viewport->w && viewport->h) {
+            D3DMATRIX d3dmatrix;
+            SDL_zero(d3dmatrix);
+            d3dmatrix.m[0][0] = 2.0f / viewport->w;
+            d3dmatrix.m[1][1] = -2.0f / viewport->h;
+            d3dmatrix.m[2][2] = 1.0f;
+            d3dmatrix.m[3][0] = -1.0f;
+            d3dmatrix.m[3][1] = 1.0f;
+            d3dmatrix.m[3][3] = 1.0f;
+            IDirect3DDevice9_SetTransform(data->device, D3DTS_PROJECTION, &d3dmatrix);
+        }
+
+        data->drawstate.viewport_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled_dirty) {
+        IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, data->drawstate.cliprect_enabled ? TRUE : FALSE);
+        data->drawstate.cliprect_enabled_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+        const SDL_Rect *rect = &data->drawstate.cliprect;
+        RECT d3drect;
+        d3drect.left = (LONG)viewport->x + rect->x;
+        d3drect.top = (LONG)viewport->y + rect->y;
+        d3drect.right = (LONG)viewport->x + rect->x + rect->w;
+        d3drect.bottom = (LONG)viewport->y + rect->y + rect->h;
+        IDirect3DDevice9_SetScissorRect(data->device, &d3drect);
+        data->drawstate.cliprect_dirty = false;
+    }
+
+    return true;
+}
+
+static void D3D_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    data->drawstate.viewport_dirty = true;
+    data->drawstate.cliprect_enabled_dirty = true;
+    data->drawstate.cliprect_dirty = true;
+    data->drawstate.blend = SDL_BLENDMODE_INVALID;
+    data->drawstate.texture = NULL;
+    data->drawstate.shader = SHADER_NONE;
+    data->drawstate.shader_params = NULL;
+}
+
+static bool D3D_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    const int vboidx = data->currentVertexBuffer;
+    IDirect3DVertexBuffer9 *vbo = NULL;
+    const bool istarget = renderer->target != NULL;
+
+    if (!D3D_ActivateRenderer(renderer)) {
+        return false;
+    }
+
+    if (vertsize > 0) {
+        // upload the new VBO data for this set of commands.
+        vbo = data->vertexBuffers[vboidx];
+        if (data->vertexBufferSize[vboidx] < vertsize) {
+            const DWORD usage = D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY;
+            const DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;
+            if (vbo) {
+                IDirect3DVertexBuffer9_Release(vbo);
+            }
+
+            if (FAILED(IDirect3DDevice9_CreateVertexBuffer(data->device, (UINT)vertsize, usage, fvf, D3DPOOL_DEFAULT, &vbo, NULL))) {
+                vbo = NULL;
+            }
+            data->vertexBuffers[vboidx] = vbo;
+            data->vertexBufferSize[vboidx] = vbo ? vertsize : 0;
+        }
+
+        if (vbo) {
+            void *ptr;
+            if (FAILED(IDirect3DVertexBuffer9_Lock(vbo, 0, (UINT)vertsize, &ptr, D3DLOCK_DISCARD))) {
+                vbo = NULL; // oh well, we'll do immediate mode drawing.  :(
+            } else {
+                SDL_memcpy(ptr, vertices, vertsize);
+                if (FAILED(IDirect3DVertexBuffer9_Unlock(vbo))) {
+                    vbo = NULL; // oh well, we'll do immediate mode drawing.  :(
+                }
+            }
+        }
+
+        // cycle through a few VBOs so D3D has some time with the data before we replace it.
+        if (vbo) {
+            data->currentVertexBuffer++;
+            if (data->currentVertexBuffer >= SDL_arraysize(data->vertexBuffers)) {
+                data->currentVertexBuffer = 0;
+            }
+        } else if (!data->reportedVboProblem) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "SDL failed to get a vertex buffer for this Direct3D 9 rendering batch!");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Dropping back to a slower method.");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This might be a brief hiccup, but if performance is bad, this is probably why.");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "This error will not be logged again for this renderer.");
+            data->reportedVboProblem = true;
+        }
+    }
+
+    IDirect3DDevice9_SetStreamSource(data->device, 0, vbo, 0, sizeof(Vertex));
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            /* currently this is sent with each vertex, but if we move to
+               shaders, we can put this in a uniform here and reduce vertex
+               buffer bandwidth */
+            break;
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &data->drawstate.viewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
+                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
+                data->drawstate.cliprect_enabled_dirty = true;
+            }
+
+            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&data->drawstate.cliprect, rect);
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            const DWORD color = D3DCOLOR_COLORVALUE(cmd->data.color.color.r * cmd->data.color.color_scale,
+                                                    cmd->data.color.color.g * cmd->data.color.color_scale,
+                                                    cmd->data.color.color.b * cmd->data.color.color_scale,
+                                                    cmd->data.color.color.a);
+            const SDL_Rect *viewport = &data->drawstate.viewport;
+            const int backw = istarget ? renderer->target->w : data->pparams.BackBufferWidth;
+            const int backh = istarget ? renderer->target->h : data->pparams.BackBufferHeight;
+            const bool viewport_equal = ((viewport->x == 0) && (viewport->y == 0) && (viewport->w == backw) && (viewport->h == backh));
+
+            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
+                IDirect3DDevice9_SetRenderState(data->device, D3DRS_SCISSORTESTENABLE, FALSE);
+                data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
+            }
+
+            // Don't reset the viewport if we don't have to!
+            if (!data->drawstate.viewport_dirty && viewport_equal) {
+                IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
+            } else {
+                // Clear is defined to clear the entire render target
+                D3DVIEWPORT9 wholeviewport = { 0, 0, 0, 0, 0.0f, 1.0f };
+                wholeviewport.Width = backw;
+                wholeviewport.Height = backh;
+                IDirect3DDevice9_SetViewport(data->device, &wholeviewport);
+                data->drawstate.viewport_dirty = true; // we still need to (re)set orthographic projection, so always mark it dirty.
+                IDirect3DDevice9_Clear(data->device, 0, NULL, D3DCLEAR_TARGET, color, 0.0f, 0);
+            }
+
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            SetDrawState(data, cmd);
+            if (vbo) {
+                IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_POINTLIST, (UINT)(first / sizeof(Vertex)), (UINT)count);
+            } else {
+                const Vertex *verts = (Vertex *)(((Uint8 *)vertices) + first);
+                IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, (UINT)count, verts, sizeof(Vertex));
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const Vertex *verts = (Vertex *)(((Uint8 *)vertices) + first);
+
+            /* DirectX 9 has the same line rasterization semantics as GDI,
+               so we need to close the endpoint of the line with a second draw call.
+               NOLINTNEXTLINE(clang-analyzer-core.NullDereference): FIXME: Can verts truly not be NULL ? */
+            const bool close_endpoint = ((count == 2) || (verts[0].x != verts[count - 1].x) || (verts[0].y != verts[count - 1].y));
+
+            SetDrawState(data, cmd);
+
+            if (vbo) {
+                IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_LINESTRIP, (UINT)(first / sizeof(Vertex)), (UINT)(count - 1));
+                if (close_endpoint) {
+                    IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_POINTLIST, (UINT)((first / sizeof(Vertex)) + (count - 1)), 1);
+                }
+            } else {
+                IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_LINESTRIP, (UINT)(count - 1), verts, sizeof(Vertex));
+                if (close_endpoint) {
+                    IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_POINTLIST, 1, &verts[count - 1], sizeof(Vertex));
+                }
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            SetDrawState(data, cmd);
+            if (vbo) {
+                IDirect3DDevice9_DrawPrimitive(data->device, D3DPT_TRIANGLELIST, (UINT)(first / sizeof(Vertex)), (UINT)count / 3);
+            } else {
+                const Vertex *verts = (Vertex *)(((Uint8 *)vertices) + first);
+                IDirect3DDevice9_DrawPrimitiveUP(data->device, D3DPT_TRIANGLELIST, (UINT)count / 3, verts, sizeof(Vertex));
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    return true;
+}
+
+static SDL_Surface *D3D_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    D3DSURFACE_DESC desc;
+    LPDIRECT3DSURFACE9 backBuffer;
+    LPDIRECT3DSURFACE9 surface;
+    RECT d3drect;
+    D3DLOCKED_RECT locked;
+    HRESULT result;
+    SDL_Surface *output;
+
+    if (data->currentRenderTarget) {
+        backBuffer = data->currentRenderTarget;
+    } else {
+        backBuffer = data->defaultRenderTarget;
+    }
+
+    result = IDirect3DSurface9_GetDesc(backBuffer, &desc);
+    if (FAILED(result)) {
+        D3D_SetError("GetDesc()", result);
+        return NULL;
+    }
+
+    result = IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surface, NULL);
+    if (FAILED(result)) {
+        D3D_SetError("CreateOffscreenPlainSurface()", result);
+        return NULL;
+    }
+
+    result = IDirect3DDevice9_GetRenderTargetData(data->device, backBuffer, surface);
+    if (FAILED(result)) {
+        IDirect3DSurface9_Release(surface);
+        D3D_SetError("GetRenderTargetData()", result);
+        return NULL;
+    }
+
+    d3drect.left = rect->x;
+    d3drect.right = (LONG)rect->x + rect->w;
+    d3drect.top = rect->y;
+    d3drect.bottom = (LONG)rect->y + rect->h;
+
+    result = IDirect3DSurface9_LockRect(surface, &locked, &d3drect, D3DLOCK_READONLY);
+    if (FAILED(result)) {
+        IDirect3DSurface9_Release(surface);
+        D3D_SetError("LockRect()", result);
+        return NULL;
+    }
+
+    output = SDL_DuplicatePixels(rect->w, rect->h, D3DFMTToPixelFormat(desc.Format), SDL_COLORSPACE_SRGB, locked.pBits, locked.Pitch);
+
+    IDirect3DSurface9_UnlockRect(surface);
+
+    IDirect3DSurface9_Release(surface);
+
+    return output;
+}
+
+static bool D3D_RenderPresent(SDL_Renderer *renderer)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    HRESULT result;
+
+    if (!data->beginScene) {
+        IDirect3DDevice9_EndScene(data->device);
+        data->beginScene = true;
+    }
+
+    result = IDirect3DDevice9_TestCooperativeLevel(data->device);
+    if (result == D3DERR_DEVICELOST) {
+        // We'll reset later
+        return false;
+    }
+    if (result == D3DERR_DEVICENOTRESET) {
+        D3D_Reset(renderer);
+    }
+    result = IDirect3DDevice9_Present(data->device, NULL, NULL, NULL, NULL);
+    if (FAILED(result)) {
+        return D3D_SetError("Present()", result);
+    }
+    return true;
+}
+
+static void D3D_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D_RenderData *renderdata = (D3D_RenderData *)renderer->internal;
+    D3D_TextureData *data = (D3D_TextureData *)texture->internal;
+
+    if (renderdata->drawstate.texture == texture) {
+        renderdata->drawstate.texture = NULL;
+        renderdata->drawstate.shader = SHADER_NONE;
+        renderdata->drawstate.shader_params = NULL;
+        IDirect3DDevice9_SetPixelShader(renderdata->device, NULL);
+        IDirect3DDevice9_SetTexture(renderdata->device, 0, NULL);
+#ifdef SDL_HAVE_YUV
+        if (data->yuv) {
+            IDirect3DDevice9_SetTexture(renderdata->device, 1, NULL);
+            IDirect3DDevice9_SetTexture(renderdata->device, 2, NULL);
+        }
+#endif
+    }
+
+    if (!data) {
+        return;
+    }
+
+    D3D_DestroyTextureRep(&data->texture);
+#ifdef SDL_HAVE_YUV
+    D3D_DestroyTextureRep(&data->utexture);
+    D3D_DestroyTextureRep(&data->vtexture);
+    SDL_free(data->pixels);
+#endif
+    SDL_free(data);
+    texture->internal = NULL;
+}
+
+static void D3D_DestroyRenderer(SDL_Renderer *renderer)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+
+    if (data) {
+        int i;
+
+        // Release the render target
+        if (data->defaultRenderTarget) {
+            IDirect3DSurface9_Release(data->defaultRenderTarget);
+            data->defaultRenderTarget = NULL;
+        }
+        if (data->currentRenderTarget) {
+            IDirect3DSurface9_Release(data->currentRenderTarget);
+            data->currentRenderTarget = NULL;
+        }
+#ifdef SDL_HAVE_YUV
+        for (i = 0; i < SDL_arraysize(data->shaders); ++i) {
+            if (data->shaders[i]) {
+                IDirect3DPixelShader9_Release(data->shaders[i]);
+                data->shaders[i] = NULL;
+            }
+        }
+#endif
+        // Release all vertex buffers
+        for (i = 0; i < SDL_arraysize(data->vertexBuffers); ++i) {
+            if (data->vertexBuffers[i]) {
+                IDirect3DVertexBuffer9_Release(data->vertexBuffers[i]);
+            }
+            data->vertexBuffers[i] = NULL;
+        }
+        if (data->device) {
+            IDirect3DDevice9_Release(data->device);
+            data->device = NULL;
+        }
+        if (data->d3d) {
+            IDirect3D9_Release(data->d3d);
+            SDL_UnloadObject(data->d3dDLL);
+        }
+        SDL_free(data);
+    }
+}
+
+static bool D3D_Reset(SDL_Renderer *renderer)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+    const Float4X4 d3dmatrix = MatrixIdentity();
+    HRESULT result;
+    SDL_Texture *texture;
+    int i;
+
+    // Cancel any scene that we've started
+    if (!data->beginScene) {
+        IDirect3DDevice9_EndScene(data->device);
+        data->beginScene = true;
+    }
+
+    // Release the default render target before reset
+    if (data->defaultRenderTarget) {
+        IDirect3DSurface9_Release(data->defaultRenderTarget);
+        data->defaultRenderTarget = NULL;
+    }
+    if (data->currentRenderTarget) {
+        IDirect3DSurface9_Release(data->currentRenderTarget);
+        data->currentRenderTarget = NULL;
+    }
+
+    // Release application render targets
+    for (texture = renderer->textures; texture; texture = texture->next) {
+        if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+            D3D_DestroyTexture(renderer, texture);
+        } else {
+            D3D_RecreateTexture(renderer, texture);
+        }
+    }
+
+    // Release all vertex buffers
+    for (i = 0; i < SDL_arraysize(data->vertexBuffers); ++i) {
+        if (data->vertexBuffers[i]) {
+            IDirect3DVertexBuffer9_Release(data->vertexBuffers[i]);
+        }
+        data->vertexBuffers[i] = NULL;
+        data->vertexBufferSize[i] = 0;
+    }
+
+    result = IDirect3DDevice9_Reset(data->device, &data->pparams);
+    if (FAILED(result)) {
+        if (result == D3DERR_DEVICELOST) {
+            // Don't worry about it, we'll reset later...
+            return true;
+        } else {
+            return D3D_SetError("Reset()", result);
+        }
+    }
+
+    // Allocate application render targets
+    for (texture = renderer->textures; texture; texture = texture->next) {
+        if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+            D3D_CreateTexture(renderer, texture, 0);
+        }
+    }
+
+    IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
+    D3D_InitRenderState(data);
+    D3D_SetRenderTargetInternal(renderer, renderer->target);
+
+    D3D_InvalidateCachedState(renderer);
+
+    IDirect3DDevice9_SetTransform(data->device, D3DTS_VIEW, (D3DMATRIX *)&d3dmatrix);
+
+    // Let the application know that render targets were reset
+    {
+        SDL_Event event;
+        SDL_zero(event);
+        event.type = SDL_EVENT_RENDER_TARGETS_RESET;
+        event.render.windowID = SDL_GetWindowID(SDL_GetRenderWindow(renderer));
+        SDL_PushEvent(&event);
+    }
+
+    return true;
+}
+
+static bool D3D_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    D3D_RenderData *data = (D3D_RenderData *)renderer->internal;
+
+    DWORD PresentationInterval;
+    switch (vsync) {
+    case 0:
+        PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+        break;
+    case 1:
+        PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+        break;
+    case 2:
+        PresentationInterval = D3DPRESENT_INTERVAL_TWO;
+        break;
+    case 3:
+        PresentationInterval = D3DPRESENT_INTERVAL_THREE;
+        break;
+    case 4:
+        PresentationInterval = D3DPRESENT_INTERVAL_FOUR;
+        break;
+    default:
+        return SDL_Unsupported();
+    }
+
+    D3DCAPS9 caps;
+    HRESULT result = IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
+    if (FAILED(result)) {
+        return D3D_SetError("GetDeviceCaps()", result);
+    }
+    if (!(caps.PresentationIntervals & PresentationInterval)) {
+        return SDL_Unsupported();
+    }
+    data->pparams.PresentationInterval = PresentationInterval;
+
+    if (!D3D_Reset(renderer)) {
+        // D3D_Reset will call SDL_SetError()
+        return false;
+    }
+    return true;
+}
+
+static bool D3D_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    D3D_RenderData *data;
+    HRESULT result;
+    HWND hwnd;
+    D3DPRESENT_PARAMETERS pparams;
+    IDirect3DSwapChain9 *chain;
+    D3DCAPS9 caps;
+    DWORD device_flags;
+    int w, h;
+    SDL_DisplayID displayID;
+    const SDL_DisplayMode *fullscreen_mode = NULL;
+
+    hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+    if (!hwnd) {
+        return SDL_SetError("Couldn't get window handle");
+    }
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (D3D_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    if (!D3D_LoadDLL(&data->d3dDLL, &data->d3d)) {
+        SDL_free(data);
+        return SDL_SetError("Unable to create Direct3D interface");
+    }
+
+    renderer->WindowEvent = D3D_WindowEvent;
+    renderer->SupportsBlendMode = D3D_SupportsBlendMode;
+    renderer->CreateTexture = D3D_CreateTexture;
+    renderer->UpdateTexture = D3D_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = D3D_UpdateTextureYUV;
+#endif
+    renderer->LockTexture = D3D_LockTexture;
+    renderer->UnlockTexture = D3D_UnlockTexture;
+    renderer->SetTextureScaleMode = D3D_SetTextureScaleMode;
+    renderer->SetRenderTarget = D3D_SetRenderTarget;
+    renderer->QueueSetViewport = D3D_QueueNoOp;
+    renderer->QueueSetDrawColor = D3D_QueueNoOp;
+    renderer->QueueDrawPoints = D3D_QueueDrawPoints;
+    renderer->QueueDrawLines = D3D_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueGeometry = D3D_QueueGeometry;
+    renderer->InvalidateCachedState = D3D_InvalidateCachedState;
+    renderer->RunCommandQueue = D3D_RunCommandQueue;
+    renderer->RenderReadPixels = D3D_RenderReadPixels;
+    renderer->RenderPresent = D3D_RenderPresent;
+    renderer->DestroyTexture = D3D_DestroyTexture;
+    renderer->DestroyRenderer = D3D_DestroyRenderer;
+    renderer->SetVSync = D3D_SetVSync;
+    renderer->internal = data;
+    D3D_InvalidateCachedState(renderer);
+
+    renderer->name = D3D_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+
+    SDL_GetWindowSizeInPixels(window, &w, &h);
+    if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) {
+        fullscreen_mode = SDL_GetWindowFullscreenMode(window);
+    }
+
+    SDL_zero(pparams);
+    pparams.hDeviceWindow = hwnd;
+    pparams.BackBufferWidth = w;
+    pparams.BackBufferHeight = h;
+    pparams.BackBufferCount = 1;
+    pparams.SwapEffect = D3DSWAPEFFECT_DISCARD;
+
+    if (fullscreen_mode) {
+        pparams.Windowed = FALSE;
+        pparams.BackBufferFormat = PixelFormatToD3DFMT(fullscreen_mode->format);
+        pparams.FullScreen_RefreshRateInHz = (UINT)SDL_ceilf(fullscreen_mode->refresh_rate);
+    } else {
+        pparams.Windowed = TRUE;
+        pparams.BackBufferFormat = D3DFMT_UNKNOWN;
+        pparams.FullScreen_RefreshRateInHz = 0;
+    }
+    pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+
+    // Get the adapter for the display that the window is on
+    displayID = SDL_GetDisplayForWindow(window);
+    data->adapter = SDL_GetDirect3D9AdapterIndex(displayID);
+
+    result = IDirect3D9_GetDeviceCaps(data->d3d, data->adapter, D3DDEVTYPE_HAL, &caps);
+    if (FAILED(result)) {
+        return D3D_SetError("GetDeviceCaps()", result);
+    }
+
+    device_flags = D3DCREATE_FPU_PRESERVE;
+    if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) {
+        device_flags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
+    } else {
+        device_flags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
+    }
+
+    if (SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, false)) {
+        device_flags |= D3DCREATE_MULTITHREADED;
+    }
+
+    result = IDirect3D9_CreateDevice(data->d3d, data->adapter,
+                                     D3DDEVTYPE_HAL,
+                                     pparams.hDeviceWindow,
+                                     device_flags,
+                                     &pparams, &data->device);
+    if (FAILED(result)) {
+        return D3D_SetError("CreateDevice()", result);
+    }
+
+    // Get presentation parameters to fill info
+    result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
+    if (FAILED(result)) {
+        return D3D_SetError("GetSwapChain()", result);
+    }
+    result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
+    if (FAILED(result)) {
+        IDirect3DSwapChain9_Release(chain);
+        return D3D_SetError("GetPresentParameters()", result);
+    }
+    IDirect3DSwapChain9_Release(chain);
+    data->pparams = pparams;
+
+    IDirect3DDevice9_GetDeviceCaps(data->device, &caps);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, SDL_min(caps.MaxTextureWidth, caps.MaxTextureHeight));
+
+    if (caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) {
+        data->enableSeparateAlphaBlend = true;
+    }
+
+    // Store the default render target
+    IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
+    data->currentRenderTarget = NULL;
+
+    // Set up parameters for rendering
+    D3D_InitRenderState(data);
+#ifdef SDL_HAVE_YUV
+    if (caps.MaxSimultaneousTextures >= 3) {
+        int i;
+        for (i = SHADER_NONE + 1; i < SDL_arraysize(data->shaders); ++i) {
+            result = D3D9_CreatePixelShader(data->device, (D3D9_Shader)i, &data->shaders[i]);
+            if (FAILED(result)) {
+                D3D_SetError("CreatePixelShader()", result);
+            }
+        }
+        if (data->shaders[SHADER_YUV]) {
+            SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+            SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+        }
+    }
+#endif
+
+    SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_D3D9_DEVICE_POINTER, data->device);
+
+    return true;
+}
+
+SDL_RenderDriver D3D_RenderDriver = {
+    D3D_CreateRenderer, "direct3d"
+};
+#endif // SDL_VIDEO_RENDER_D3D
diff --git a/SDL-3.2.8/src/render/direct3d/SDL_shaders_d3d.c b/SDL-3.2.8/src/render/direct3d/SDL_shaders_d3d.c
new file mode 100644
index 0000000..9b1b4b5
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d/SDL_shaders_d3d.c
@@ -0,0 +1,48 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_D3D
+
+#include "../../core/windows/SDL_windows.h"
+
+#include <d3d9.h>
+
+#include "SDL_shaders_d3d.h"
+
+// The shaders here were compiled with compile_shaders.bat
+
+#define g_ps20_main D3D9_PixelShader_YUV
+#include "D3D9_PixelShader_YUV.h"
+#undef g_ps20_main
+
+static const BYTE *D3D9_shaders[] = {
+    NULL,
+    D3D9_PixelShader_YUV
+};
+SDL_COMPILE_TIME_ASSERT(D3D9_shaders, SDL_arraysize(D3D9_shaders) == NUM_SHADERS);
+
+HRESULT D3D9_CreatePixelShader(IDirect3DDevice9 *d3dDevice, D3D9_Shader shader, IDirect3DPixelShader9 **pixelShader)
+{
+    return IDirect3DDevice9_CreatePixelShader(d3dDevice, (const DWORD *)D3D9_shaders[shader], pixelShader);
+}
+
+#endif // SDL_VIDEO_RENDER_D3D
diff --git a/SDL-3.2.8/src/render/direct3d/SDL_shaders_d3d.h b/SDL-3.2.8/src/render/direct3d/SDL_shaders_d3d.h
new file mode 100644
index 0000000..90ef7a9
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d/SDL_shaders_d3d.h
@@ -0,0 +1,32 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// D3D9 shader implementation
+
+typedef enum
+{
+    SHADER_NONE,
+    SHADER_YUV,
+    NUM_SHADERS
+} D3D9_Shader;
+
+extern HRESULT D3D9_CreatePixelShader(IDirect3DDevice9 *d3dDevice, D3D9_Shader shader, IDirect3DPixelShader9 **pixelShader);
diff --git a/SDL-3.2.8/src/render/direct3d/compile_shaders.bat b/SDL-3.2.8/src/render/direct3d/compile_shaders.bat
new file mode 100644
index 0000000..81d513e
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d/compile_shaders.bat
@@ -0,0 +1 @@
+fxc /T ps_2_0 /Fh D3D9_PixelShader_YUV.h D3D9_PixelShader_YUV.hlsl

diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Advanced.h b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Advanced.h
new file mode 100644
index 0000000..a1297c9
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Advanced.h
@@ -0,0 +1,1060 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 10.1
+//
+//
+// Buffer Definitions: 
+//
+// cbuffer Constants
+// {
+//
+//   float scRGB_output;                // Offset:    0 Size:     4
+//   float texture_type;                // Offset:    4 Size:     4
+//   float input_type;                  // Offset:    8 Size:     4
+//   float color_scale;                 // Offset:   12 Size:     4
+//   float tonemap_method;              // Offset:   16 Size:     4
+//   float tonemap_factor1;             // Offset:   20 Size:     4
+//   float tonemap_factor2;             // Offset:   24 Size:     4
+//   float sdr_white_point;             // Offset:   28 Size:     4
+//   float4 Yoffset;                    // Offset:   32 Size:    16
+//   float4 Rcoeff;                     // Offset:   48 Size:    16
+//   float4 Gcoeff;                     // Offset:   64 Size:    16
+//   float4 Bcoeff;                     // Offset:   80 Size:    16
+//
+// }
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim      HLSL Bind  Count
+// ------------------------------ ---------- ------- ----------- -------------- ------
+// sampler0                          sampler      NA          NA             s0      1 
+// texture0                          texture  float4          2d             t0      1 
+// texture1                          texture  float4          2d             t1      1 
+// texture2                          texture  float4          2d             t2      1 
+// Constants                         cbuffer      NA          NA            cb0      1 
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float       
+// TEXCOORD                 0   xy          1     NONE   float   xy  
+// COLOR                    0   xyzw        2     NONE   float   xyzw
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+ps_5_0
+dcl_globalFlags refactoringAllowed
+dcl_constantbuffer CB0[6], immediateIndexed
+dcl_sampler s0, mode_default
+dcl_resource_texture2d (float,float,float,float) t0
+dcl_resource_texture2d (float,float,float,float) t1
+dcl_resource_texture2d (float,float,float,float) t2
+dcl_input_ps linear v1.xy
+dcl_input_ps linear v2.xyzw
+dcl_output o0.xyzw
+dcl_temps 7
+eq r0.xyzw, cb0[0].yzzz, l(0.000000, 3.000000, 2.000000, 1.000000)
+if_nz r0.x
+  mov r1.xyzw, l(1.000000,1.000000,1.000000,1.000000)
+else 
+  eq r0.x, cb0[0].y, l(1.000000)
+  if_nz r0.x
+    sample_indexable(texture2d)(float,float,float,float) r1.xyzw, v1.xyxx, t0.xyzw, s0
+  else 
+    eq r0.x, cb0[0].y, l(2.000000)
+    if_nz r0.x
+      sample_indexable(texture2d)(float,float,float,float) r2.x, v1.xyxx, t0.xyzw, s0
+      sample_indexable(texture2d)(float,float,float,float) r2.yz, v1.xyxx, t1.zxyw, s0
+      add r2.xyz, r2.xyzx, cb0[2].xyzx
+      dp3 r1.x, r2.xyzx, cb0[3].xyzx
+      dp3 r1.y, r2.xyzx, cb0[4].xyzx
+      dp3 r1.z, r2.xyzx, cb0[5].xyzx
+    else 
+      eq r0.x, cb0[0].y, l(3.000000)
+      if_nz r0.x
+        sample_indexable(texture2d)(float,float,float,float) r2.x, v1.xyxx, t0.xyzw, s0
+        sample_indexable(texture2d)(float,float,float,float) r2.yz, v1.xyxx, t1.zyxw, s0
+        add r2.xyz, r2.xyzx, cb0[2].xyzx
+        dp3 r1.x, r2.xyzx, cb0[3].xyzx
+        dp3 r1.y, r2.xyzx, cb0[4].xyzx
+        dp3 r1.z, r2.xyzx, cb0[5].xyzx
+      else 
+        eq r0.x, cb0[0].y, l(4.000000)
+        if_nz r0.x
+          sample_indexable(texture2d)(float,float,float,float) r2.x, v1.xyxx, t0.xyzw, s0
+          sample_indexable(texture2d)(float,float,float,float) r2.y, v1.xyxx, t1.yxzw, s0
+          sample_indexable(texture2d)(float,float,float,float) r2.z, v1.xyxx, t2.yzxw, s0
+          add r2.xyz, r2.xyzx, cb0[2].xyzx
+          dp3 r1.x, r2.xyzx, cb0[3].xyzx
+          dp3 r1.y, r2.xyzx, cb0[4].xyzx
+          dp3 r1.z, r2.xyzx, cb0[5].xyzx
+        else 
+          mov r1.xyz, l(1.000000,0,0,0)
+        endif 
+      endif 
+    endif 
+    mov r1.w, l(1.000000)
+  endif 
+endif 
+log r2.xyz, |r1.xyzx|
+mul r2.xyz, r2.xyzx, l(0.012683, 0.012683, 0.012683, 0.000000)
+exp r2.xyz, r2.xyzx
+add r3.xyz, r2.xyzx, l(-0.835938, -0.835938, -0.835938, 0.000000)
+max r3.xyz, r3.xyzx, l(0.000000, 0.000000, 0.000000, 0.000000)
+mad r2.xyz, -r2.xyzx, l(18.687500, 18.687500, 18.687500, 0.000000), l(18.851562, 18.851562, 18.851562, 0.000000)
+div r2.xyz, r3.xyzx, r2.xyzx
+log r2.xyz, |r2.xyzx|
+mul r2.xyz, r2.xyzx, l(6.277395, 6.277395, 6.277395, 0.000000)
+exp r2.xyz, r2.xyzx
+mul r2.xyz, r2.xyzx, l(10000.000000, 10000.000000, 10000.000000, 0.000000)
+div r2.xyz, r2.xyzx, cb0[1].wwww
+movc r2.xyz, r0.yyyy, r2.xyzx, r1.xyzx
+ne r0.x, cb0[1].x, l(0.000000)
+mul r3.xyz, r2.xyzx, cb0[1].yyyy
+eq r4.xy, cb0[1].xxxx, l(1.000000, 2.000000, 0.000000, 0.000000)
+dp3 r5.x, l(0.627404, 0.329283, 0.043313, 0.000000), r2.xyzx
+dp3 r5.y, l(0.069097, 0.919541, 0.011362, 0.000000), r2.xyzx
+dp3 r5.z, l(0.016391, 0.088013, 0.895595, 0.000000), r2.xyzx
+movc r5.xyz, r0.zzzz, r5.xyzx, r2.xyzx
+max r2.w, r5.z, r5.y
+max r2.w, r2.w, r5.x
+lt r3.w, l(0.000000), r2.w
+mad r4.zw, cb0[1].yyyz, r2.wwww, l(0.000000, 0.000000, 1.000000, 1.000000)
+div r2.w, r4.z, r4.w
+mul r6.xyz, r2.wwww, r5.xyzx
+movc r5.xyz, r3.wwww, r6.xyzx, r5.xyzx
+dp3 r6.x, l(1.660496, -0.587656, -0.072840, 0.000000), r5.xyzx
+dp3 r6.y, l(-0.124547, 1.132895, -0.008348, 0.000000), r5.xyzx
+dp3 r6.z, l(-0.018154, -0.100597, 1.118751, 0.000000), r5.xyzx
+movc r5.xyz, r0.zzzz, r6.xyzx, r5.xyzx
+movc r4.yzw, r4.yyyy, r5.xxyz, r2.xxyz
+movc r3.xyz, r4.xxxx, r3.xyzx, r4.yzwy
+movc r2.xyz, r0.xxxx, r3.xyzx, r2.xyzx
+if_nz r0.w
+  ne r0.x, l(0.000000, 0.000000, 0.000000, 0.000000), cb0[0].x
+  if_nz r0.x
+    ge r3.xyz, l(0.040450, 0.040450, 0.040450, 0.000000), r2.xyzx
+    mul r4.xyz, r2.xyzx, l(0.077399, 0.077399, 0.077399, 0.000000)
+    add r5.xyz, r2.xyzx, l(0.055000, 0.055000, 0.055000, 0.000000)
+    mul r5.xyz, |r5.xyzx|, l(0.947867, 0.947867, 0.947867, 0.000000)
+    log r5.xyz, r5.xyzx
+    mul r5.xyz, r5.xyzx, l(2.400000, 2.400000, 2.400000, 0.000000)
+    exp r5.xyz, r5.xyzx
+    movc r2.xyz, r3.xyzx, r4.xyzx, r5.xyzx
+  endif 
+  mul r1.xyz, r2.xyzx, cb0[0].wwww
+else 
+  if_nz r0.z
+    mul r1.xyz, r2.xyzx, cb0[0].wwww
+    ne r0.x, l(0.000000, 0.000000, 0.000000, 0.000000), cb0[0].x
+    if_z r0.x
+      ge r0.xzw, l(0.003131, 0.000000, 0.003131, 0.003131), r1.xxyz
+      mul r3.xyz, r1.xyzx, l(12.920000, 12.920000, 12.920000, 0.000000)
+      log r4.xyz, |r1.xyzx|
+      mul r4.xyz, r4.xyzx, l(0.416667, 0.416667, 0.416667, 0.000000)
+      exp r4.xyz, r4.xyzx
+      mad r4.xyz, r4.xyzx, l(1.055000, 1.055000, 1.055000, 0.000000), l(-0.055000, -0.055000, -0.055000, 0.000000)
+      movc_sat r1.xyz, r0.xzwx, r3.xyzx, r4.xyzx
+    endif 
+  else 
+    if_nz r0.y
+      dp3 r0.x, l(1.660496, -0.587656, -0.072840, 0.000000), r2.xyzx
+      dp3 r0.y, l(-0.124547, 1.132895, -0.008348, 0.000000), r2.xyzx
+      dp3 r0.z, l(-0.018154, -0.100597, 1.118751, 0.000000), r2.xyzx
+      mul r1.xyz, r0.xyzx, cb0[0].wwww
+      ne r0.x, l(0.000000, 0.000000, 0.000000, 0.000000), cb0[0].x
+      if_z r0.x
+        ge r0.xyz, l(0.003131, 0.003131, 0.003131, 0.000000), r1.xyzx
+        mul r3.xyz, r1.xyzx, l(12.920000, 12.920000, 12.920000, 0.000000)
+        log r4.xyz, |r1.xyzx|
+        mul r4.xyz, r4.xyzx, l(0.416667, 0.416667, 0.416667, 0.000000)
+        exp r4.xyz, r4.xyzx
+        mad r4.xyz, r4.xyzx, l(1.055000, 1.055000, 1.055000, 0.000000), l(-0.055000, -0.055000, -0.055000, 0.000000)
+        movc_sat r1.xyz, r0.xyzx, r3.xyzx, r4.xyzx
+      endif 
+    else 
+      mul r1.xyz, r2.xyzx, cb0[0].wwww
+    endif 
+  endif 
+endif 
+mul o0.xyzw, r1.xyzw, v2.xyzw
+ret 
+// Approximately 126 instruction slots used
+#endif
+
+const BYTE g_main[] =
+{
+     68,  88,  66,  67, 154, 200, 
+     28,  25,  30, 140,   0, 183, 
+    251,  32,   6, 185, 210,  29, 
+    251, 110,   1,   0,   0,   0, 
+     64,  20,   0,   0,   5,   0, 
+      0,   0,  52,   0,   0,   0, 
+     80,   4,   0,   0, 196,   4, 
+      0,   0, 248,   4,   0,   0, 
+    164,  19,   0,   0,  82,  68, 
+     69,  70,  20,   4,   0,   0, 
+      1,   0,   0,   0,  12,   1, 
+      0,   0,   5,   0,   0,   0, 
+     60,   0,   0,   0,   0,   5, 
+    255, 255,   0,   1,   0,   0, 
+    233,   3,   0,   0,  82,  68, 
+     49,  49,  60,   0,   0,   0, 
+     24,   0,   0,   0,  32,   0, 
+      0,   0,  40,   0,   0,   0, 
+     36,   0,   0,   0,  12,   0, 
+      0,   0,   0,   0,   0,   0, 
+    220,   0,   0,   0,   3,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   1,   0, 
+      0,   0, 229,   0,   0,   0, 
+      2,   0,   0,   0,   5,   0, 
+      0,   0,   4,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+     13,   0,   0,   0, 238,   0, 
+      0,   0,   2,   0,   0,   0, 
+      5,   0,   0,   0,   4,   0, 
+      0,   0, 255, 255, 255, 255, 
+      1,   0,   0,   0,   1,   0, 
+      0,   0,  13,   0,   0,   0, 
+    247,   0,   0,   0,   2,   0, 
+      0,   0,   5,   0,   0,   0, 
+      4,   0,   0,   0, 255, 255, 
+    255, 255,   2,   0,   0,   0, 
+      1,   0,   0,   0,  13,   0, 
+      0,   0,   0,   1,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      1,   0,   0,   0, 115,  97, 
+    109, 112, 108, 101, 114,  48, 
+      0, 116, 101, 120, 116, 117, 
+    114, 101,  48,   0, 116, 101, 
+    120, 116, 117, 114, 101,  49, 
+      0, 116, 101, 120, 116, 117, 
+    114, 101,  50,   0,  67, 111, 
+    110, 115, 116,  97, 110, 116, 
+    115,   0, 171, 171,   0,   1, 
+      0,   0,  12,   0,   0,   0, 
+     36,   1,   0,   0,  96,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   4,   3, 
+      0,   0,   0,   0,   0,   0, 
+      4,   0,   0,   0,   2,   0, 
+      0,   0,  24,   3,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0,  60,   3,   0,   0, 
+      4,   0,   0,   0,   4,   0, 
+      0,   0,   2,   0,   0,   0, 
+     24,   3,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+     73,   3,   0,   0,   8,   0, 
+      0,   0,   4,   0,   0,   0, 
+      2,   0,   0,   0,  24,   3, 
+      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0,  84,   3, 
+      0,   0,  12,   0,   0,   0, 
+      4,   0,   0,   0,   2,   0, 
+      0,   0,  24,   3,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0,  96,   3,   0,   0, 
+     16,   0,   0,   0,   4,   0, 
+      0,   0,   2,   0,   0,   0, 
+     24,   3,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    111,   3,   0,   0,  20,   0, 
+      0,   0,   4,   0,   0,   0, 
+      2,   0,   0,   0,  24,   3, 
+      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 127,   3, 
+      0,   0,  24,   0,   0,   0, 
+      4,   0,   0,   0,   2,   0, 
+      0,   0,  24,   3,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 143,   3,   0,   0, 
+     28,   0,   0,   0,   4,   0, 
+      0,   0,   2,   0,   0,   0, 
+     24,   3,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    159,   3,   0,   0,  32,   0, 
+      0,   0,  16,   0,   0,   0, 
+      2,   0,   0,   0, 176,   3, 
+      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 212,   3, 
+      0,   0,  48,   0,   0,   0, 
+     16,   0,   0,   0,   2,   0, 
+      0,   0, 176,   3,   0,   0, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 219,   3,   0,   0, 
+     64,   0,   0,   0,  16,   0, 
+      0,   0,   2,   0,   0,   0, 
+    176,   3,   0,   0,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 255, 255, 
+    255, 255,   0,   0,   0,   0, 
+    226,   3,   0,   0,  80,   0, 
+      0,   0,  16,   0,   0,   0, 
+      2,   0,   0,   0, 176,   3, 
+      0,   0,   0,   0,   0,   0, 
+    255, 255, 255, 255,   0,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0, 115,  99, 
+     82,  71,  66,  95, 111, 117, 
+    116, 112, 117, 116,   0, 102, 
+    108, 111,  97, 116,   0, 171, 
+      0,   0,   3,   0,   1,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  17,   3,   0,   0, 
+    116, 101, 120, 116, 117, 114, 
+    101,  95, 116, 121, 112, 101, 
+      0, 105, 110, 112, 117, 116, 
+     95, 116, 121, 112, 101,   0, 
+     99, 111, 108, 111, 114,  95, 
+    115,  99,  97, 108, 101,   0, 
+    116, 111, 110, 101, 109,  97, 
+    112,  95, 109, 101, 116, 104, 
+    111, 100,   0, 116, 111, 110, 
+    101, 109,  97, 112,  95, 102, 
+     97,  99, 116, 111, 114,  49, 
+      0, 116, 111, 110, 101, 109, 
+     97, 112,  95, 102,  97,  99, 
+    116, 111, 114,  50,   0, 115, 
+    100, 114,  95, 119, 104, 105, 
+    116, 101,  95, 112, 111, 105, 
+    110, 116,   0,  89, 111, 102, 
+    102, 115, 101, 116,   0, 102, 
+    108, 111,  97, 116,  52,   0, 
+    171, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 167,   3, 
+      0,   0,  82,  99, 111, 101, 
+    102, 102,   0,  71,  99, 111, 
+    101, 102, 102,   0,  66,  99, 
+    111, 101, 102, 102,   0,  77, 
+    105,  99, 114, 111, 115, 111, 
+    102, 116,  32,  40,  82,  41, 
+     32,  72,  76,  83,  76,  32, 
+     83, 104,  97, 100, 101, 114, 
+     32,  67, 111, 109, 112, 105, 
+    108, 101, 114,  32,  49,  48, 
+     46,  49,   0, 171, 171, 171, 
+     73,  83,  71,  78, 108,   0, 
+      0,   0,   3,   0,   0,   0, 
+      8,   0,   0,   0,  80,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   3,   0, 
+      0,   0,   0,   0,   0,   0, 
+     15,   0,   0,   0,  92,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   3,   0, 
+      0,   0,   1,   0,   0,   0, 
+      3,   3,   0,   0, 101,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   3,   0, 
+      0,   0,   2,   0,   0,   0, 
+     15,  15,   0,   0,  83,  86, 
+     95,  80,  79,  83,  73,  84, 
+     73,  79,  78,   0,  84,  69, 
+     88,  67,  79,  79,  82,  68, 
+      0,  67,  79,  76,  79,  82, 
+      0, 171,  79,  83,  71,  78, 
+     44,   0,   0,   0,   1,   0, 
+      0,   0,   8,   0,   0,   0, 
+     32,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   0,   0, 
+      0,   0,  15,   0,   0,   0, 
+     83,  86,  95,  84,  65,  82, 
+     71,  69,  84,   0, 171, 171, 
+     83,  72,  69,  88, 164,  14, 
+      0,   0,  80,   0,   0,   0, 
+    169,   3,   0,   0, 106,   8, 
+      0,   1,  89,   0,   0,   4, 
+     70, 142,  32,   0,   0,   0, 
+      0,   0,   6,   0,   0,   0, 
+     90,   0,   0,   3,   0,  96, 
+     16,   0,   0,   0,   0,   0, 
+     88,  24,   0,   4,   0, 112, 
+     16,   0,   0,   0,   0,   0, 
+     85,  85,   0,   0,  88,  24, 
+      0,   4,   0, 112,  16,   0, 
+      1,   0,   0,   0,  85,  85, 
+      0,   0,  88,  24,   0,   4, 
+      0, 112,  16,   0,   2,   0, 
+      0,   0,  85,  85,   0,   0, 
+     98,  16,   0,   3,  50,  16, 
+     16,   0,   1,   0,   0,   0, 
+     98,  16,   0,   3, 242,  16, 
+     16,   0,   2,   0,   0,   0, 
+    101,   0,   0,   3, 242,  32, 
+     16,   0,   0,   0,   0,   0, 
+    104,   0,   0,   2,   7,   0, 
+      0,   0,  24,   0,   0,  11, 
+    242,   0,  16,   0,   0,   0, 
+      0,   0, 150, 138,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   2,  64,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     64,  64,   0,   0,   0,  64, 
+      0,   0, 128,  63,  31,   0, 
+      4,   3,  10,   0,  16,   0, 
+      0,   0,   0,   0,  54,   0, 
+      0,   8, 242,   0,  16,   0, 
+      1,   0,   0,   0,   2,  64, 
+      0,   0,   0,   0, 128,  63, 
+      0,   0, 128,  63,   0,   0, 
+    128,  63,   0,   0, 128,  63, 
+     18,   0,   0,   1,  24,   0, 
+      0,   8,  18,   0,  16,   0, 
+      0,   0,   0,   0,  26, 128, 
+     32,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,  64, 
+      0,   0,   0,   0, 128,  63, 
+     31,   0,   4,   3,  10,   0, 
+     16,   0,   0,   0,   0,   0, 
+     69,   0,   0, 139, 194,   0, 
+      0, 128,  67,  85,  21,   0, 
+    242,   0,  16,   0,   1,   0, 
+      0,   0,  70,  16,  16,   0, 
+      1,   0,   0,   0,  70, 126, 
+     16,   0,   0,   0,   0,   0, 
+      0,  96,  16,   0,   0,   0, 
+      0,   0,  18,   0,   0,   1, 
+     24,   0,   0,   8,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+     26, 128,  32,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,  64,   0,   0,   0,   0, 
+      0,  64,  31,   0,   4,   3, 
+     10,   0,  16,   0,   0,   0, 
+      0,   0,  69,   0,   0, 139, 
+    194,   0,   0, 128,  67,  85, 
+     21,   0,  18,   0,  16,   0, 
+      2,   0,   0,   0,  70,  16, 
+     16,   0,   1,   0,   0,   0, 
+     70, 126,  16,   0,   0,   0, 
+      0,   0,   0,  96,  16,   0, 
+      0,   0,   0,   0,  69,   0, 
+      0, 139, 194,   0,   0, 128, 
+     67,  85,  21,   0,  98,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,  16,  16,   0,   1,   0, 
+      0,   0,  38, 125,  16,   0, 
+      1,   0,   0,   0,   0,  96, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,   0,   8, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  70, 130,  32,   0, 
+      0,   0,   0,   0,   2,   0, 
+      0,   0,  16,   0,   0,   8, 
+     18,   0,  16,   0,   1,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  70, 130, 
+     32,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,  16,   0, 
+      0,   8,  34,   0,  16,   0, 
+      1,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     70, 130,  32,   0,   0,   0, 
+      0,   0,   4,   0,   0,   0, 
+     16,   0,   0,   8,  66,   0, 
+     16,   0,   1,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  70, 130,  32,   0, 
+      0,   0,   0,   0,   5,   0, 
+      0,   0,  18,   0,   0,   1, 
+     24,   0,   0,   8,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+     26, 128,  32,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,  64,   0,   0,   0,   0, 
+     64,  64,  31,   0,   4,   3, 
+     10,   0,  16,   0,   0,   0, 
+      0,   0,  69,   0,   0, 139, 
+    194,   0,   0, 128,  67,  85, 
+     21,   0,  18,   0,  16,   0, 
+      2,   0,   0,   0,  70,  16, 
+     16,   0,   1,   0,   0,   0, 
+     70, 126,  16,   0,   0,   0, 
+      0,   0,   0,  96,  16,   0, 
+      0,   0,   0,   0,  69,   0, 
+      0, 139, 194,   0,   0, 128, 
+     67,  85,  21,   0,  98,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,  16,  16,   0,   1,   0, 
+      0,   0, 102, 124,  16,   0, 
+      1,   0,   0,   0,   0,  96, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,   0,   8, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  70, 130,  32,   0, 
+      0,   0,   0,   0,   2,   0, 
+      0,   0,  16,   0,   0,   8, 
+     18,   0,  16,   0,   1,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  70, 130, 
+     32,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,  16,   0, 
+      0,   8,  34,   0,  16,   0, 
+      1,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     70, 130,  32,   0,   0,   0, 
+      0,   0,   4,   0,   0,   0, 
+     16,   0,   0,   8,  66,   0, 
+     16,   0,   1,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  70, 130,  32,   0, 
+      0,   0,   0,   0,   5,   0, 
+      0,   0,  18,   0,   0,   1, 
+     24,   0,   0,   8,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+     26, 128,  32,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,  64,   0,   0,   0,   0, 
+    128,  64,  31,   0,   4,   3, 
+     10,   0,  16,   0,   0,   0, 
+      0,   0,  69,   0,   0, 139, 
+    194,   0,   0, 128,  67,  85, 
+     21,   0,  18,   0,  16,   0, 
+      2,   0,   0,   0,  70,  16, 
+     16,   0,   1,   0,   0,   0, 
+     70, 126,  16,   0,   0,   0, 
+      0,   0,   0,  96,  16,   0, 
+      0,   0,   0,   0,  69,   0, 
+      0, 139, 194,   0,   0, 128, 
+     67,  85,  21,   0,  34,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,  16,  16,   0,   1,   0, 
+      0,   0,  22, 126,  16,   0, 
+      1,   0,   0,   0,   0,  96, 
+     16,   0,   0,   0,   0,   0, 
+     69,   0,   0, 139, 194,   0, 
+      0, 128,  67,  85,  21,   0, 
+     66,   0,  16,   0,   2,   0, 
+      0,   0,  70,  16,  16,   0, 
+      1,   0,   0,   0, 150, 124, 
+     16,   0,   2,   0,   0,   0, 
+      0,  96,  16,   0,   0,   0, 
+      0,   0,   0,   0,   0,   8, 
+    114,   0,  16,   0,   2,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  70, 130, 
+     32,   0,   0,   0,   0,   0, 
+      2,   0,   0,   0,  16,   0, 
+      0,   8,  18,   0,  16,   0, 
+      1,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     70, 130,  32,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+     16,   0,   0,   8,  34,   0, 
+     16,   0,   1,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  70, 130,  32,   0, 
+      0,   0,   0,   0,   4,   0, 
+      0,   0,  16,   0,   0,   8, 
+     66,   0,  16,   0,   1,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  70, 130, 
+     32,   0,   0,   0,   0,   0, 
+      5,   0,   0,   0,  18,   0, 
+      0,   1,  54,   0,   0,   8, 
+    114,   0,  16,   0,   1,   0, 
+      0,   0,   2,  64,   0,   0, 
+      0,   0, 128,  63,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  21,   0, 
+      0,   1,  21,   0,   0,   1, 
+     21,   0,   0,   1,  54,   0, 
+      0,   5, 130,   0,  16,   0, 
+      1,   0,   0,   0,   1,  64, 
+      0,   0,   0,   0, 128,  63, 
+     21,   0,   0,   1,  21,   0, 
+      0,   1,  47,   0,   0,   6, 
+    114,   0,  16,   0,   2,   0, 
+      0,   0,  70,   2,  16, 128, 
+    129,   0,   0,   0,   1,   0, 
+      0,   0,  56,   0,   0,  10, 
+    114,   0,  16,   0,   2,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,   2,  64, 
+      0,   0, 172, 205,  79,  60, 
+    172, 205,  79,  60, 172, 205, 
+     79,  60,   0,   0,   0,   0, 
+     25,   0,   0,   5, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,   0,   0,   0,  10, 
+    114,   0,  16,   0,   3,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,   2,  64, 
+      0,   0,   0,   0,  86, 191, 
+      0,   0,  86, 191,   0,   0, 
+     86, 191,   0,   0,   0,   0, 
+     52,   0,   0,  10, 114,   0, 
+     16,   0,   3,   0,   0,   0, 
+     70,   2,  16,   0,   3,   0, 
+      0,   0,   2,  64,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  50,   0, 
+      0,  16, 114,   0,  16,   0, 
+      2,   0,   0,   0,  70,   2, 
+     16, 128,  65,   0,   0,   0, 
+      2,   0,   0,   0,   2,  64, 
+      0,   0,   0, 128, 149,  65, 
+      0, 128, 149,  65,   0, 128, 
+    149,  65,   0,   0,   0,   0, 
+      2,  64,   0,   0,   0, 208, 
+    150,  65,   0, 208, 150,  65, 
+      0, 208, 150,  65,   0,   0, 
+      0,   0,  14,   0,   0,   7, 
+    114,   0,  16,   0,   2,   0, 
+      0,   0,  70,   2,  16,   0, 
+      3,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     47,   0,   0,   6, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16, 128, 129,   0, 
+      0,   0,   2,   0,   0,   0, 
+     56,   0,   0,  10, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,   2,  64,   0,   0, 
+    107, 224, 200,  64, 107, 224, 
+    200,  64, 107, 224, 200,  64, 
+      0,   0,   0,   0,  25,   0, 
+      0,   5, 114,   0,  16,   0, 
+      2,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     56,   0,   0,  10, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,   2,  64,   0,   0, 
+      0,  64,  28,  70,   0,  64, 
+     28,  70,   0,  64,  28,  70, 
+      0,   0,   0,   0,  14,   0, 
+      0,   8, 114,   0,  16,   0, 
+      2,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+    246, 143,  32,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     86,   5,  16,   0,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  70,   2, 
+     16,   0,   1,   0,   0,   0, 
+     57,   0,   0,   8,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+     10, 128,  32,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      1,  64,   0,   0,   0,   0, 
+      0,   0,  56,   0,   0,   8, 
+    114,   0,  16,   0,   3,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  86, 133, 
+     32,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,  24,   0, 
+      0,  11,  50,   0,  16,   0, 
+      4,   0,   0,   0,   6, 128, 
+     32,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   2,  64, 
+      0,   0,   0,   0, 128,  63, 
+      0,   0,   0,  64,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     16,   0,   0,  10,  18,   0, 
+     16,   0,   5,   0,   0,   0, 
+      2,  64,   0,   0, 140, 157, 
+     32,  63, 200, 151, 168,  62, 
+    249, 104,  49,  61,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  16,   0, 
+      0,  10,  34,   0,  16,   0, 
+      5,   0,   0,   0,   2,  64, 
+      0,   0, 186, 130, 141,  61, 
+     10, 103, 107,  63, 175,  39, 
+     58,  60,   0,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  16,   0,   0,  10, 
+     66,   0,  16,   0,   5,   0, 
+      0,   0,   2,  64,   0,   0, 
+    107,  70, 134,  60,  41,  64, 
+    180,  61, 183,  69, 101,  63, 
+      0,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   5,   0,   0,   0, 
+    166,  10,  16,   0,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      5,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     52,   0,   0,   7, 130,   0, 
+     16,   0,   2,   0,   0,   0, 
+     42,   0,  16,   0,   5,   0, 
+      0,   0,  26,   0,  16,   0, 
+      5,   0,   0,   0,  52,   0, 
+      0,   7, 130,   0,  16,   0, 
+      2,   0,   0,   0,  58,   0, 
+     16,   0,   2,   0,   0,   0, 
+     10,   0,  16,   0,   5,   0, 
+      0,   0,  49,   0,   0,   7, 
+    130,   0,  16,   0,   3,   0, 
+      0,   0,   1,  64,   0,   0, 
+      0,   0,   0,   0,  58,   0, 
+     16,   0,   2,   0,   0,   0, 
+     50,   0,   0,  13, 194,   0, 
+     16,   0,   4,   0,   0,   0, 
+     86, 137,  32,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+    246,  15,  16,   0,   2,   0, 
+      0,   0,   2,  64,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 128,  63, 
+      0,   0, 128,  63,  14,   0, 
+      0,   7, 130,   0,  16,   0, 
+      2,   0,   0,   0,  42,   0, 
+     16,   0,   4,   0,   0,   0, 
+     58,   0,  16,   0,   4,   0, 
+      0,   0,  56,   0,   0,   7, 
+    114,   0,  16,   0,   6,   0, 
+      0,   0, 246,  15,  16,   0, 
+      2,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   5,   0,   0,   0, 
+    246,  15,  16,   0,   3,   0, 
+      0,   0,  70,   2,  16,   0, 
+      6,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     16,   0,   0,  10,  18,   0, 
+     16,   0,   6,   0,   0,   0, 
+      2,  64,   0,   0,  34, 139, 
+    212,  63, 160, 112,  22, 191, 
+     35,  45, 149, 189,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      5,   0,   0,   0,  16,   0, 
+      0,  10,  34,   0,  16,   0, 
+      6,   0,   0,   0,   2,  64, 
+      0,   0, 127,  18, 255, 189, 
+    180,   2, 145,  63,  13, 198, 
+      8, 188,   0,   0,   0,   0, 
+     70,   2,  16,   0,   5,   0, 
+      0,   0,  16,   0,   0,  10, 
+     66,   0,  16,   0,   6,   0, 
+      0,   0,   2,  64,   0,   0, 
+    179, 183, 148, 188, 205,   5, 
+    206, 189,  60,  51, 143,  63, 
+      0,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   5,   0,   0,   0, 
+    166,  10,  16,   0,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      6,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     55,   0,   0,   9, 226,   0, 
+     16,   0,   4,   0,   0,   0, 
+     86,   5,  16,   0,   4,   0, 
+      0,   0,   6,   9,  16,   0, 
+      5,   0,   0,   0,   6,   9, 
+     16,   0,   2,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   3,   0,   0,   0, 
+      6,   0,  16,   0,   4,   0, 
+      0,   0,  70,   2,  16,   0, 
+      3,   0,   0,   0, 150,   7, 
+     16,   0,   4,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+      6,   0,  16,   0,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      3,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     31,   0,   4,   3,  58,   0, 
+     16,   0,   0,   0,   0,   0, 
+     57,   0,   0,  11,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+      2,  64,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  10, 128,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  31,   0,   4,   3, 
+     10,   0,  16,   0,   0,   0, 
+      0,   0,  29,   0,   0,  10, 
+    114,   0,  16,   0,   3,   0, 
+      0,   0,   2,  64,   0,   0, 
+    230, 174,  37,  61, 230, 174, 
+     37,  61, 230, 174,  37,  61, 
+      0,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     56,   0,   0,  10, 114,   0, 
+     16,   0,   4,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,   2,  64,   0,   0, 
+    145, 131, 158,  61, 145, 131, 
+    158,  61, 145, 131, 158,  61, 
+      0,   0,   0,   0,   0,   0, 
+      0,  10, 114,   0,  16,   0, 
+      5,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+      2,  64,   0,   0, 174,  71, 
+     97,  61, 174,  71,  97,  61, 
+    174,  71,  97,  61,   0,   0, 
+      0,   0,  56,   0,   0,  11, 
+    114,   0,  16,   0,   5,   0, 
+      0,   0,  70,   2,  16, 128, 
+    129,   0,   0,   0,   5,   0, 
+      0,   0,   2,  64,   0,   0, 
+    111, 167, 114,  63, 111, 167, 
+    114,  63, 111, 167, 114,  63, 
+      0,   0,   0,   0,  47,   0, 
+      0,   5, 114,   0,  16,   0, 
+      5,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     56,   0,   0,  10, 114,   0, 
+     16,   0,   5,   0,   0,   0, 
+     70,   2,  16,   0,   5,   0, 
+      0,   0,   2,  64,   0,   0, 
+    154, 153,  25,  64, 154, 153, 
+     25,  64, 154, 153,  25,  64, 
+      0,   0,   0,   0,  25,   0, 
+      0,   5, 114,   0,  16,   0, 
+      5,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     55,   0,   0,   9, 114,   0, 
+     16,   0,   2,   0,   0,   0, 
+     70,   2,  16,   0,   3,   0, 
+      0,   0,  70,   2,  16,   0, 
+      4,   0,   0,   0,  70,   2, 
+     16,   0,   5,   0,   0,   0, 
+     21,   0,   0,   1,  56,   0, 
+      0,   8, 114,   0,  16,   0, 
+      1,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+    246, 143,  32,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     18,   0,   0,   1,  31,   0, 
+      4,   3,  42,   0,  16,   0, 
+      0,   0,   0,   0,  56,   0, 
+      0,   8, 114,   0,  16,   0, 
+      1,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+    246, 143,  32,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     57,   0,   0,  11,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+      2,  64,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  10, 128,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  31,   0,   0,   3, 
+     10,   0,  16,   0,   0,   0, 
+      0,   0,  29,   0,   0,  10, 
+    210,   0,  16,   0,   0,   0, 
+      0,   0,   2,  64,   0,   0, 
+     28,  46,  77,  59,   0,   0, 
+      0,   0,  28,  46,  77,  59, 
+     28,  46,  77,  59,   6,   9, 
+     16,   0,   1,   0,   0,   0, 
+     56,   0,   0,  10, 114,   0, 
+     16,   0,   3,   0,   0,   0, 
+     70,   2,  16,   0,   1,   0, 
+      0,   0,   2,  64,   0,   0, 
+     82, 184,  78,  65,  82, 184, 
+     78,  65,  82, 184,  78,  65, 
+      0,   0,   0,   0,  47,   0, 
+      0,   6, 114,   0,  16,   0, 
+      4,   0,   0,   0,  70,   2, 
+     16, 128, 129,   0,   0,   0, 
+      1,   0,   0,   0,  56,   0, 
+      0,  10, 114,   0,  16,   0, 
+      4,   0,   0,   0,  70,   2, 
+     16,   0,   4,   0,   0,   0, 
+      2,  64,   0,   0,  85,  85, 
+    213,  62,  85,  85, 213,  62, 
+     85,  85, 213,  62,   0,   0, 
+      0,   0,  25,   0,   0,   5, 
+    114,   0,  16,   0,   4,   0, 
+      0,   0,  70,   2,  16,   0, 
+      4,   0,   0,   0,  50,   0, 
+      0,  15, 114,   0,  16,   0, 
+      4,   0,   0,   0,  70,   2, 
+     16,   0,   4,   0,   0,   0, 
+      2,  64,   0,   0,  61,  10, 
+    135,  63,  61,  10, 135,  63, 
+     61,  10, 135,  63,   0,   0, 
+      0,   0,   2,  64,   0,   0, 
+    174,  71,  97, 189, 174,  71, 
+     97, 189, 174,  71,  97, 189, 
+      0,   0,   0,   0,  55,  32, 
+      0,   9, 114,   0,  16,   0, 
+      1,   0,   0,   0, 134,   3, 
+     16,   0,   0,   0,   0,   0, 
+     70,   2,  16,   0,   3,   0, 
+      0,   0,  70,   2,  16,   0, 
+      4,   0,   0,   0,  21,   0, 
+      0,   1,  18,   0,   0,   1, 
+     31,   0,   4,   3,  26,   0, 
+     16,   0,   0,   0,   0,   0, 
+     16,   0,   0,  10,  18,   0, 
+     16,   0,   0,   0,   0,   0, 
+      2,  64,   0,   0,  34, 139, 
+    212,  63, 160, 112,  22, 191, 
+     35,  45, 149, 189,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0,  16,   0, 
+      0,  10,  34,   0,  16,   0, 
+      0,   0,   0,   0,   2,  64, 
+      0,   0, 127,  18, 255, 189, 
+    180,   2, 145,  63,  13, 198, 
+      8, 188,   0,   0,   0,   0, 
+     70,   2,  16,   0,   2,   0, 
+      0,   0,  16,   0,   0,  10, 
+     66,   0,  16,   0,   0,   0, 
+      0,   0,   2,  64,   0,   0, 
+    179, 183, 148, 188, 205,   5, 
+    206, 189,  60,  51, 143,  63, 
+      0,   0,   0,   0,  70,   2, 
+     16,   0,   2,   0,   0,   0, 
+     56,   0,   0,   8, 114,   0, 
+     16,   0,   1,   0,   0,   0, 
+     70,   2,  16,   0,   0,   0, 
+      0,   0, 246, 143,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  57,   0,   0,  11, 
+     18,   0,  16,   0,   0,   0, 
+      0,   0,   2,  64,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  10, 128, 
+     32,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  31,   0, 
+      0,   3,  10,   0,  16,   0, 
+      0,   0,   0,   0,  29,   0, 
+      0,  10, 114,   0,  16,   0, 
+      0,   0,   0,   0,   2,  64, 
+      0,   0,  28,  46,  77,  59, 
+     28,  46,  77,  59,  28,  46, 
+     77,  59,   0,   0,   0,   0, 
+     70,   2,  16,   0,   1,   0, 
+      0,   0,  56,   0,   0,  10, 
+    114,   0,  16,   0,   3,   0, 
+      0,   0,  70,   2,  16,   0, 
+      1,   0,   0,   0,   2,  64, 
+      0,   0,  82, 184,  78,  65, 
+     82, 184,  78,  65,  82, 184, 
+     78,  65,   0,   0,   0,   0, 
+     47,   0,   0,   6, 114,   0, 
+     16,   0,   4,   0,   0,   0, 
+     70,   2,  16, 128, 129,   0, 
+      0,   0,   1,   0,   0,   0, 
+     56,   0,   0,  10, 114,   0, 
+     16,   0,   4,   0,   0,   0, 
+     70,   2,  16,   0,   4,   0, 
+      0,   0,   2,  64,   0,   0, 
+     85,  85, 213,  62,  85,  85, 
+    213,  62,  85,  85, 213,  62, 
+      0,   0,   0,   0,  25,   0, 
+      0,   5, 114,   0,  16,   0, 
+      4,   0,   0,   0,  70,   2, 
+     16,   0,   4,   0,   0,   0, 
+     50,   0,   0,  15, 114,   0, 
+     16,   0,   4,   0,   0,   0, 
+     70,   2,  16,   0,   4,   0, 
+      0,   0,   2,  64,   0,   0, 
+     61,  10, 135,  63,  61,  10, 
+    135,  63,  61,  10, 135,  63, 
+      0,   0,   0,   0,   2,  64, 
+      0,   0, 174,  71,  97, 189, 
+    174,  71,  97, 189, 174,  71, 
+     97, 189,   0,   0,   0,   0, 
+     55,  32,   0,   9, 114,   0, 
+     16,   0,   1,   0,   0,   0, 
+     70,   2,  16,   0,   0,   0, 
+      0,   0,  70,   2,  16,   0, 
+      3,   0,   0,   0,  70,   2, 
+     16,   0,   4,   0,   0,   0, 
+     21,   0,   0,   1,  18,   0, 
+      0,   1,  56,   0,   0,   8, 
+    114,   0,  16,   0,   1,   0, 
+      0,   0,  70,   2,  16,   0, 
+      2,   0,   0,   0, 246, 143, 
+     32,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  21,   0, 
+      0,   1,  21,   0,   0,   1, 
+     21,   0,   0,   1,  56,   0, 
+      0,   7, 242,  32,  16,   0, 
+      0,   0,   0,   0,  70,  14, 
+     16,   0,   1,   0,   0,   0, 
+     70,  30,  16,   0,   2,   0, 
+      0,   0,  62,   0,   0,   1, 
+     83,  84,  65,  84, 148,   0, 
+      0,   0, 126,   0,   0,   0, 
+      7,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+     71,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      9,   0,   0,   0,  11,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   8,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,  10,   0, 
+      0,   0,   3,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0
+};
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Advanced.hlsl b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Advanced.hlsl
new file mode 100644
index 0000000..aad7b77
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Advanced.hlsl
@@ -0,0 +1,7 @@
+
+#include "D3D11_PixelShader_Common.hlsli"
+
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    return AdvancedPixelShader(input);
+}
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Colors.h b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Colors.h
new file mode 100644
index 0000000..6658e4d
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Colors.h
@@ -0,0 +1,284 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 10.1
+//
+//
+// Buffer Definitions: 
+//
+// cbuffer Constants
+// {
+//
+//   float scRGB_output;                // Offset:    0 Size:     4 [unused]
+//   float texture_type;                // Offset:    4 Size:     4 [unused]
+//   float input_type;                  // Offset:    8 Size:     4 [unused]
+//   float color_scale;                 // Offset:   12 Size:     4
+//   float tonemap_method;              // Offset:   16 Size:     4 [unused]
+//   float tonemap_factor1;             // Offset:   20 Size:     4 [unused]
+//   float tonemap_factor2;             // Offset:   24 Size:     4 [unused]
+//   float sdr_white_point;             // Offset:   28 Size:     4 [unused]
+//   float4 Yoffset;                    // Offset:   32 Size:    16 [unused]
+//   float4 Rcoeff;                     // Offset:   48 Size:    16 [unused]
+//   float4 Gcoeff;                     // Offset:   64 Size:    16 [unused]
+//   float4 Bcoeff;                     // Offset:   80 Size:    16 [unused]
+//
+// }
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim      HLSL Bind  Count
+// ------------------------------ ---------- ------- ----------- -------------- ------
+// Constants                         cbuffer      NA          NA            cb0      1 
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float       
+// TEXCOORD                 0   xy          1     NONE   float       
+// COLOR                    0   xyzw        2     NONE   float   xyzw
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+//
+// Constant buffer to DX9 shader constant mappings:
+//
+// Target Reg Buffer  Start Reg # of Regs        Data Conversion
+// ---------- ------- --------- --------- ----------------------
+// c0         cb0             0         1  ( FLT, FLT, FLT, FLT)
+//
+//
+// Level9 shader bytecode:
+//
+    ps_2_0
+    dcl t1
+    mul r0.xyz, t1, c0.w
+    mov r0.w, t1.w
+    mov oC0, r0
+
+// approximately 3 instruction slots used
+ps_4_0
+dcl_constantbuffer CB0[1], immediateIndexed
+dcl_input_ps linear v2.xyzw
+dcl_output o0.xyzw
+dcl_temps 1
+mov r0.x, cb0[0].w
+mov r0.w, l(1.000000)
+mul o0.xyzw, r0.xxxw, v2.xyzw
+ret 
+// Approximately 4 instruction slots used
+#endif
+
+const BYTE g_main[] =
+{
+     68,  88,  66,  67,  78, 223, 
+     23,  23,  93, 184, 255,  26, 
+    153,   0, 220, 179,  25, 194, 
+     30, 249,   1,   0,   0,   0, 
+    192,   4,   0,   0,   6,   0, 
+      0,   0,  56,   0,   0,   0, 
+    172,   0,   0,   0,  56,   1, 
+      0,   0, 180,   1,   0,   0, 
+     24,   4,   0,   0, 140,   4, 
+      0,   0,  65, 111, 110,  57, 
+    108,   0,   0,   0, 108,   0, 
+      0,   0,   0,   2, 255, 255, 
+     60,   0,   0,   0,  48,   0, 
+      0,   0,   1,   0,  36,   0, 
+      0,   0,  48,   0,   0,   0, 
+     48,   0,   0,   0,  36,   0, 
+      0,   0,  48,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0,   0,   2, 
+    255, 255,  31,   0,   0,   2, 
+      0,   0,   0, 128,   1,   0, 
+     15, 176,   5,   0,   0,   3, 
+      0,   0,   7, 128,   1,   0, 
+    228, 176,   0,   0, 255, 160, 
+      1,   0,   0,   2,   0,   0, 
+      8, 128,   1,   0, 255, 176, 
+      1,   0,   0,   2,   0,   8, 
+     15, 128,   0,   0, 228, 128, 
+    255, 255,   0,   0,  83,  72, 
+     68,  82, 132,   0,   0,   0, 
+     64,   0,   0,   0,  33,   0, 
+      0,   0,  89,   0,   0,   4, 
+     70, 142,  32,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+     98,  16,   0,   3, 242,  16, 
+     16,   0,   2,   0,   0,   0, 
+    101,   0,   0,   3, 242,  32, 
+     16,   0,   0,   0,   0,   0, 
+    104,   0,   0,   2,   1,   0, 
+      0,   0,  54,   0,   0,   6, 
+     18,   0,  16,   0,   0,   0, 
+      0,   0,  58, 128,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  54,   0,   0,   5, 
+    130,   0,  16,   0,   0,   0, 
+      0,   0,   1,  64,   0,   0, 
+      0,   0, 128,  63,  56,   0, 
+      0,   7, 242,  32,  16,   0, 
+      0,   0,   0,   0,   6,  12, 
+     16,   0,   0,   0,   0,   0, 
+     70,  30,  16,   0,   2,   0, 
+      0,   0,  62,   0,   0,   1, 
+     83,  84,  65,  84, 116,   0, 
+      0,   0,   4,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0,   2,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      2,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  82,  68, 
+     69,  70,  92,   2,   0,   0, 
+      1,   0,   0,   0,  72,   0, 
+      0,   0,   1,   0,   0,   0, 
+     28,   0,   0,   0,   0,   4, 
+    255, 255,   0,   1,   0,   0, 
+     49,   2,   0,   0,  60,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   1,   0,   0,   0, 
+     67, 111, 110, 115, 116,  97, 
+    110, 116, 115,   0, 171, 171, 
+     60,   0,   0,   0,  12,   0, 
+      0,   0,  96,   0,   0,   0, 
+     96,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+    128,   1,   0,   0,   0,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    160,   1,   0,   0,   4,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    173,   1,   0,   0,   8,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    184,   1,   0,   0,  12,   0, 
+      0,   0,   4,   0,   0,   0, 
+      2,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    196,   1,   0,   0,  16,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    211,   1,   0,   0,  20,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    227,   1,   0,   0,  24,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+    243,   1,   0,   0,  28,   0, 
+      0,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0, 144,   1, 
+      0,   0,   0,   0,   0,   0, 
+      3,   2,   0,   0,  32,   0, 
+      0,   0,  16,   0,   0,   0, 
+      0,   0,   0,   0,  12,   2, 
+      0,   0,   0,   0,   0,   0, 
+     28,   2,   0,   0,  48,   0, 
+      0,   0,  16,   0,   0,   0, 
+      0,   0,   0,   0,  12,   2, 
+      0,   0,   0,   0,   0,   0, 
+     35,   2,   0,   0,  64,   0, 
+      0,   0,  16,   0,   0,   0, 
+      0,   0,   0,   0,  12,   2, 
+      0,   0,   0,   0,   0,   0, 
+     42,   2,   0,   0,  80,   0, 
+      0,   0,  16,   0,   0,   0, 
+      0,   0,   0,   0,  12,   2, 
+      0,   0,   0,   0,   0,   0, 
+    115,  99,  82,  71,  66,  95, 
+    111, 117, 116, 112, 117, 116, 
+      0, 171, 171, 171,   0,   0, 
+      3,   0,   1,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0, 116, 101, 120, 116, 
+    117, 114, 101,  95, 116, 121, 
+    112, 101,   0, 105, 110, 112, 
+    117, 116,  95, 116, 121, 112, 
+    101,   0,  99, 111, 108, 111, 
+    114,  95, 115,  99,  97, 108, 
+    101,   0, 116, 111, 110, 101, 
+    109,  97, 112,  95, 109, 101, 
+    116, 104, 111, 100,   0, 116, 
+    111, 110, 101, 109,  97, 112, 
+     95, 102,  97,  99, 116, 111, 
+    114,  49,   0, 116, 111, 110, 
+    101, 109,  97, 112,  95, 102, 
+     97,  99, 116, 111, 114,  50, 
+      0, 115, 100, 114,  95, 119, 
+    104, 105, 116, 101,  95, 112, 
+    111, 105, 110, 116,   0,  89, 
+    111, 102, 102, 115, 101, 116, 
+      0, 171,   1,   0,   3,   0, 
+      1,   0,   4,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+     82,  99, 111, 101, 102, 102, 
+      0,  71,  99, 111, 101, 102, 
+    102,   0,  66,  99, 111, 101, 
+    102, 102,   0,  77, 105,  99, 
+    114, 111, 115, 111, 102, 116, 
+     32,  40,  82,  41,  32,  72, 
+     76,  83,  76,  32,  83, 104, 
+     97, 100, 101, 114,  32,  67, 
+    111, 109, 112, 105, 108, 101, 
+    114,  32,  49,  48,  46,  49, 
+      0, 171, 171, 171,  73,  83, 
+     71,  78, 108,   0,   0,   0, 
+      3,   0,   0,   0,   8,   0, 
+      0,   0,  80,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   3,   0,   0,   0, 
+      0,   0,   0,   0,  15,   0, 
+      0,   0,  92,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+      1,   0,   0,   0,   3,   0, 
+      0,   0, 101,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+      2,   0,   0,   0,  15,  15, 
+      0,   0,  83,  86,  95,  80, 
+     79,  83,  73,  84,  73,  79, 
+     78,   0,  84,  69,  88,  67, 
+     79,  79,  82,  68,   0,  67, 
+     79,  76,  79,  82,   0, 171, 
+     79,  83,  71,  78,  44,   0, 
+      0,   0,   1,   0,   0,   0, 
+      8,   0,   0,   0,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   3,   0, 
+      0,   0,   0,   0,   0,   0, 
+     15,   0,   0,   0,  83,  86, 
+     95,  84,  65,  82,  71,  69, 
+     84,   0, 171, 171
+};
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Colors.hlsl b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Colors.hlsl
new file mode 100644
index 0000000..5757491
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Colors.hlsl
@@ -0,0 +1,7 @@
+
+#include "D3D11_PixelShader_Common.hlsli"
+
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    return GetOutputColor(1.0) * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Common.hlsli b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Common.hlsli
new file mode 100644
index 0000000..b940c0c
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Common.hlsli
@@ -0,0 +1,235 @@
+
+Texture2D texture0 : register(t0);
+Texture2D texture1 : register(t1);
+Texture2D texture2 : register(t2);
+SamplerState sampler0 : register(s0);
+
+struct PixelShaderInput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+// These should mirror the definitions in SDL_render_d3d11.c
+static const float TONEMAP_NONE = 0;
+static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+static const float TEXTURETYPE_NONE = 0;
+static const float TEXTURETYPE_RGB = 1;
+static const float TEXTURETYPE_NV12 = 2;
+static const float TEXTURETYPE_NV21 = 3;
+static const float TEXTURETYPE_YUV = 4;
+
+static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+cbuffer Constants : register(b0)
+{
+    float scRGB_output;
+    float texture_type;
+    float input_type;
+    float color_scale;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+
+    float4 Yoffset;
+    float4 Rcoeff;
+    float4 Gcoeff;
+    float4 Bcoeff;
+};
+
+static const float3x3 mat709to2020 = {
+    { 0.627404, 0.329283, 0.043313 },
+    { 0.069097, 0.919541, 0.011362 },
+    { 0.016391, 0.088013, 0.895595 }
+};
+
+static const float3x3 mat2020to709 = {
+    { 1.660496, -0.587656, -0.072840 },
+    { -0.124547, 1.132895, -0.008348 },
+    { -0.018154, -0.100597, 1.118751 }
+};
+
+float sRGBtoLinear(float v)
+{
+    if (v <= 0.04045) {
+        v = (v / 12.92);
+    } else {
+        v = pow(abs(v + 0.055) / 1.055, 2.4);
+    }
+    return v;
+}
+
+float sRGBfromLinear(float v)
+{
+    if (v <= 0.0031308) {
+        v = (v * 12.92);
+    } else {
+        v = (pow(abs(v), 1.0 / 2.4) * 1.055 - 0.055);
+    }
+    return v;
+}
+
+float3 PQtoLinear(float3 v)
+{
+    const float c1 = 0.8359375;
+    const float c2 = 18.8515625;
+    const float c3 = 18.6875;
+    const float oo_m1 = 1.0 / 0.1593017578125;
+    const float oo_m2 = 1.0 / 78.84375;
+
+    float3 num = max(pow(abs(v), oo_m2) - c1, 0.0);
+    float3 den = c2 - c3 * pow(abs(v), oo_m2);
+    return (10000.0 * pow(abs(num / den), oo_m1) / sdr_white_point);
+}
+
+float3 ApplyTonemap(float3 v)
+{
+    if (tonemap_method == TONEMAP_LINEAR) {
+        v *= tonemap_factor1;
+    } else if (tonemap_method == TONEMAP_CHROME) {
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.2020 colorspace for tone mapping
+            v = mul(mat709to2020, v);
+        }
+
+        float vmax = max(v.r, max(v.g, v.b));
+        if (vmax > 0.0) {
+            float scale = (1.0 + tonemap_factor1 * vmax) / (1.0 + tonemap_factor2 * vmax);
+            v *= scale;
+        }
+
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.709 colorspace after tone mapping
+            v = mul(mat2020to709, v);
+        }
+    }
+    return v;
+}
+
+float4 GetInputColor(PixelShaderInput input)
+{
+    float4 rgba;
+
+    if (texture_type == TEXTURETYPE_NONE) {
+        rgba = 1.0;
+    } else if (texture_type == TEXTURETYPE_RGB) {
+        rgba = texture0.Sample(sampler0, input.tex);
+    } else if (texture_type == TEXTURETYPE_NV12) {
+        float3 yuv;
+        yuv.x = texture0.Sample(sampler0, input.tex).r;
+        yuv.yz = texture1.Sample(sampler0, input.tex).rg;
+
+        yuv += Yoffset.xyz;
+        rgba.r = dot(yuv, Rcoeff.xyz);
+        rgba.g = dot(yuv, Gcoeff.xyz);
+        rgba.b = dot(yuv, Bcoeff.xyz);
+        rgba.a = 1.0;
+    } else if (texture_type == TEXTURETYPE_NV21) {
+        float3 yuv;
+        yuv.x = texture0.Sample(sampler0, input.tex).r;
+        yuv.yz = texture1.Sample(sampler0, input.tex).gr;
+
+        yuv += Yoffset.xyz;
+        rgba.r = dot(yuv, Rcoeff.xyz);
+        rgba.g = dot(yuv, Gcoeff.xyz);
+        rgba.b = dot(yuv, Bcoeff.xyz);
+        rgba.a = 1.0;
+    } else if (texture_type == TEXTURETYPE_YUV) {
+        float3 yuv;
+        yuv.x = texture0.Sample(sampler0, input.tex).r;
+        yuv.y = texture1.Sample(sampler0, input.tex).r;
+        yuv.z = texture2.Sample(sampler0, input.tex).r;
+
+        yuv += Yoffset.xyz;
+        rgba.r = dot(yuv, Rcoeff.xyz);
+        rgba.g = dot(yuv, Gcoeff.xyz);
+        rgba.b = dot(yuv, Bcoeff.xyz);
+        rgba.a = 1.0;
+    } else {
+        // Error!
+        rgba.r = 1.0;
+        rgba.g = 0.0;
+        rgba.b = 0.0;
+        rgba.a = 1.0;
+    }
+    return rgba;
+}
+
+float4 GetOutputColor(float4 rgba)
+{
+    float4 output;
+
+    output.rgb = rgba.rgb * color_scale;
+    output.a = rgba.a;
+
+    return output;
+}
+
+float3 GetOutputColorFromSRGB(float3 rgb)
+{
+    float3 output;
+
+    if (scRGB_output) {
+        rgb.r = sRGBtoLinear(rgb.r);
+        rgb.g = sRGBtoLinear(rgb.g);
+        rgb.b = sRGBtoLinear(rgb.b);
+    }
+
+    output.rgb = rgb * color_scale;
+
+    return output;
+}
+
+float3 GetOutputColorFromLinear(float3 rgb)
+{
+    float3 output;
+
+    output.rgb = rgb * color_scale;
+
+    if (!scRGB_output) {
+        output.r = sRGBfromLinear(output.r);
+        output.g = sRGBfromLinear(output.g);
+        output.b = sRGBfromLinear(output.b);
+        output.rgb = saturate(output.rgb);
+    }
+
+    return output;
+}
+
+float4 AdvancedPixelShader(PixelShaderInput input)
+{
+    float4 rgba = GetInputColor(input);
+    float4 output;
+
+    if (input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = PQtoLinear(rgba.rgb);
+    }
+
+    if (tonemap_method != TONEMAP_NONE) {
+        rgba.rgb = ApplyTonemap(rgba.rgb);
+    }
+
+    if (input_type == INPUTTYPE_SRGB) {
+        output.rgb = GetOutputColorFromSRGB(rgba.rgb);
+        output.a = rgba.a;
+    } else if (input_type == INPUTTYPE_SCRGB) {
+        output.rgb = GetOutputColorFromLinear(rgba.rgb);
+        output.a = rgba.a;
+    } else if (input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = mul(mat2020to709, rgba.rgb);
+        output.rgb = GetOutputColorFromLinear(rgba.rgb);
+        output.a = rgba.a;
+    } else {
+        output = GetOutputColor(rgba);
+    }
+
+    return output * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Textures.h b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Textures.h
new file mode 100644
index 0000000..996cac6
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Textures.h
@@ -0,0 +1,332 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 10.1
+//
+//
+// Buffer Definitions: 
+//
+// cbuffer Constants
+// {
+//
+//   float scRGB_output;                // Offset:    0 Size:     4 [unused]
+//   float texture_type;                // Offset:    4 Size:     4 [unused]
+//   float input_type;                  // Offset:    8 Size:     4 [unused]
+//   float color_scale;                 // Offset:   12 Size:     4
+//   float tonemap_method;              // Offset:   16 Size:     4 [unused]
+//   float tonemap_factor1;             // Offset:   20 Size:     4 [unused]
+//   float tonemap_factor2;             // Offset:   24 Size:     4 [unused]
+//   float sdr_white_point;             // Offset:   28 Size:     4 [unused]
+//   float4 Yoffset;                    // Offset:   32 Size:    16 [unused]
+//   float4 Rcoeff;                     // Offset:   48 Size:    16 [unused]
+//   float4 Gcoeff;                     // Offset:   64 Size:    16 [unused]
+//   float4 Bcoeff;                     // Offset:   80 Size:    16 [unused]
+//
+// }
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim      HLSL Bind  Count
+// ------------------------------ ---------- ------- ----------- -------------- ------
+// theSampler                        sampler      NA          NA             s0      1 
+// theTexture                        texture  float4          2d             t0      1 
+// Constants                         cbuffer      NA          NA            cb0      1 
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float       
+// TEXCOORD                 0   xy          1     NONE   float   xy  
+// COLOR                    0   xyzw        2     NONE   float   xyzw
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_TARGET                0   xyzw        0   TARGET   float   xyzw
+//
+//
+// Constant buffer to DX9 shader constant mappings:
+//
+// Target Reg Buffer  Start Reg # of Regs        Data Conversion
+// ---------- ------- --------- --------- ----------------------
+// c0         cb0             0         1  ( FLT, FLT, FLT, FLT)
+//
+//
+// Sampler/Resource to DX9 shader sampler mappings:
+//
+// Target Sampler Source Sampler  Source Resource
+// -------------- --------------- ----------------
+// s0             s0              t0               
+//
+//
+// Level9 shader bytecode:
+//
+    ps_2_0
+    dcl t0.xy
+    dcl t1
+    dcl_2d s0
+    texld r0, t0, s0
+    mul r0.xyz, r0, c0.w
+    mul r0, r0, t1
+    mov oC0, r0
+
+// approximately 4 instruction slots used (1 texture, 3 arithmetic)
+ps_4_0
+dcl_constantbuffer CB0[1], immediateIndexed
+dcl_sampler s0, mode_default
+dcl_resource_texture2d (float,float,float,float) t0
+dcl_input_ps linear v1.xy
+dcl_input_ps linear v2.xyzw
+dcl_output o0.xyzw
+dcl_temps 1
+sample r0.xyzw, v1.xyxx, t0.xyzw, s0
+mul r0.xyz, r0.xyzx, cb0[0].wwww
+mul o0.xyzw, r0.xyzw, v2.xyzw
+ret 
+// Approximately 4 instruction slots used
+#endif
+
+const BYTE g_main[] =
+{
+     68,  88,  66,  67,   8, 152, 
+    224, 210, 182, 254,  37,  89, 
+     68, 213,  13, 174,  95,  42, 
+      2,  11,   1,   0,   0,   0, 
+    132,   5,   0,   0,   6,   0, 
+      0,   0,  56,   0,   0,   0, 
+    220,   0,   0,   0, 168,   1, 
+      0,   0,  36,   2,   0,   0, 
+    220,   4,   0,   0,  80,   5, 
+      0,   0,  65, 111, 110,  57, 
+    156,   0,   0,   0, 156,   0, 
+      0,   0,   0,   2, 255, 255, 
+    104,   0,   0,   0,  52,   0, 
+      0,   0,   1,   0,  40,   0, 
+      0,   0,  52,   0,   0,   0, 
+     52,   0,   1,   0,  36,   0, 
+      0,   0,  52,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   0,   0, 
+      0,   0,   0,   2, 255, 255, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   0,   0,   3, 176, 
+     31,   0,   0,   2,   0,   0, 
+      0, 128,   1,   0,  15, 176, 
+     31,   0,   0,   2,   0,   0, 
+      0, 144,   0,   8,  15, 160, 
+     66,   0,   0,   3,   0,   0, 
+     15, 128,   0,   0, 228, 176, 
+      0,   8, 228, 160,   5,   0, 
+      0,   3,   0,   0,   7, 128, 
+      0,   0, 228, 128,   0,   0, 
+    255, 160,   5,   0,   0,   3, 
+      0,   0,  15, 128,   0,   0, 
+    228, 128,   1,   0, 228, 176, 
+      1,   0,   0,   2,   0,   8, 
+     15, 128,   0,   0, 228, 128, 
+    255, 255,   0,   0,  83,  72, 
+     68,  82, 196,   0,   0,   0, 
+     64,   0,   0,   0,  49,   0, 
+      0,   0,  89,   0,   0,   4, 
+     70, 142,  32,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+     90,   0,   0,   3,   0,  96, 
+     16,   0,   0,   0,   0,   0, 
+     88,  24,   0,   4,   0, 112, 
+     16,   0,   0,   0,   0,   0, 
+     85,  85,   0,   0,  98,  16, 
+      0,   3,  50,  16,  16,   0, 
+      1,   0,   0,   0,  98,  16, 
+      0,   3, 242,  16,  16,   0, 
+      2,   0,   0,   0, 101,   0, 
+      0,   3, 242,  32,  16,   0, 
+      0,   0,   0,   0, 104,   0, 
+      0,   2,   1,   0,   0,   0, 
+     69,   0,   0,   9, 242,   0, 
+     16,   0,   0,   0,   0,   0, 
+     70,  16,  16,   0,   1,   0, 
+      0,   0,  70, 126,  16,   0, 
+      0,   0,   0,   0,   0,  96, 
+     16,   0,   0,   0,   0,   0, 
+     56,   0,   0,   8, 114,   0, 
+     16,   0,   0,   0,   0,   0, 
+     70,   2,  16,   0,   0,   0, 
+      0,   0, 246, 143,  32,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  56,   0,   0,   7, 
+    242,  32,  16,   0,   0,   0, 
+      0,   0,  70,  14,  16,   0, 
+      0,   0,   0,   0,  70,  30, 
+     16,   0,   2,   0,   0,   0, 
+     62,   0,   0,   1,  83,  84, 
+     65,  84, 116,   0,   0,   0, 
+      4,   0,   0,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   2,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  82,  68,  69,  70, 
+    176,   2,   0,   0,   1,   0, 
+      0,   0, 156,   0,   0,   0, 
+      3,   0,   0,   0,  28,   0, 
+      0,   0,   0,   4, 255, 255, 
+      0,   1,   0,   0, 133,   2, 
+      0,   0, 124,   0,   0,   0, 
+      3,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      1,   0,   0,   0, 135,   0, 
+      0,   0,   2,   0,   0,   0, 
+      5,   0,   0,   0,   4,   0, 
+      0,   0, 255, 255, 255, 255, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,  13,   0,   0,   0, 
+    146,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0,   1,   0, 
+      0,   0, 116, 104, 101,  83, 
+     97, 109, 112, 108, 101, 114, 
+      0, 116, 104, 101,  84, 101, 
+    120, 116, 117, 114, 101,   0, 
+     67, 111, 110, 115, 116,  97, 
+    110, 116, 115,   0, 146,   0, 
+      0,   0,  12,   0,   0,   0, 
+    180,   0,   0,   0,  96,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 212,   1, 
+      0,   0,   0,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0, 244,   1, 
+      0,   0,   4,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,   1,   2, 
+      0,   0,   8,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,  12,   2, 
+      0,   0,  12,   0,   0,   0, 
+      4,   0,   0,   0,   2,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,  24,   2, 
+      0,   0,  16,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,  39,   2, 
+      0,   0,  20,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,  55,   2, 
+      0,   0,  24,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,  71,   2, 
+      0,   0,  28,   0,   0,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0, 228,   1,   0,   0, 
+      0,   0,   0,   0,  87,   2, 
+      0,   0,  32,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,  96,   2,   0,   0, 
+      0,   0,   0,   0, 112,   2, 
+      0,   0,  48,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,  96,   2,   0,   0, 
+      0,   0,   0,   0, 119,   2, 
+      0,   0,  64,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,  96,   2,   0,   0, 
+      0,   0,   0,   0, 126,   2, 
+      0,   0,  80,   0,   0,   0, 
+     16,   0,   0,   0,   0,   0, 
+      0,   0,  96,   2,   0,   0, 
+      0,   0,   0,   0, 115,  99, 
+     82,  71,  66,  95, 111, 117, 
+    116, 112, 117, 116,   0, 171, 
+    171, 171,   0,   0,   3,   0, 
+      1,   0,   1,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+    116, 101, 120, 116, 117, 114, 
+    101,  95, 116, 121, 112, 101, 
+      0, 105, 110, 112, 117, 116, 
+     95, 116, 121, 112, 101,   0, 
+     99, 111, 108, 111, 114,  95, 
+    115,  99,  97, 108, 101,   0, 
+    116, 111, 110, 101, 109,  97, 
+    112,  95, 109, 101, 116, 104, 
+    111, 100,   0, 116, 111, 110, 
+    101, 109,  97, 112,  95, 102, 
+     97,  99, 116, 111, 114,  49, 
+      0, 116, 111, 110, 101, 109, 
+     97, 112,  95, 102,  97,  99, 
+    116, 111, 114,  50,   0, 115, 
+    100, 114,  95, 119, 104, 105, 
+    116, 101,  95, 112, 111, 105, 
+    110, 116,   0,  89, 111, 102, 
+    102, 115, 101, 116,   0, 171, 
+      1,   0,   3,   0,   1,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  82,  99, 
+    111, 101, 102, 102,   0,  71, 
+     99, 111, 101, 102, 102,   0, 
+     66,  99, 111, 101, 102, 102, 
+      0,  77, 105,  99, 114, 111, 
+    115, 111, 102, 116,  32,  40, 
+     82,  41,  32,  72,  76,  83, 
+     76,  32,  83, 104,  97, 100, 
+    101, 114,  32,  67, 111, 109, 
+    112, 105, 108, 101, 114,  32, 
+     49,  48,  46,  49,   0, 171, 
+    171, 171,  73,  83,  71,  78, 
+    108,   0,   0,   0,   3,   0, 
+      0,   0,   8,   0,   0,   0, 
+     80,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      3,   0,   0,   0,   0,   0, 
+      0,   0,  15,   0,   0,   0, 
+     92,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   1,   0, 
+      0,   0,   3,   3,   0,   0, 
+    101,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   2,   0, 
+      0,   0,  15,  15,   0,   0, 
+     83,  86,  95,  80,  79,  83, 
+     73,  84,  73,  79,  78,   0, 
+     84,  69,  88,  67,  79,  79, 
+     82,  68,   0,  67,  79,  76, 
+     79,  82,   0, 171,  79,  83, 
+     71,  78,  44,   0,   0,   0, 
+      1,   0,   0,   0,   8,   0, 
+      0,   0,  32,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+      0,   0,   0,   0,  15,   0, 
+      0,   0,  83,  86,  95,  84, 
+     65,  82,  71,  69,  84,   0, 
+    171, 171
+};
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Textures.hlsl b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Textures.hlsl
new file mode 100644
index 0000000..f2ecf18
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_PixelShader_Textures.hlsl
@@ -0,0 +1,9 @@
+Texture2D theTexture : register(t0);
+SamplerState theSampler : register(s0);
+
+#include "D3D11_PixelShader_Common.hlsli"
+
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    return GetOutputColor(theTexture.Sample(theSampler, input.tex)) * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_VertexShader.h b/SDL-3.2.8/src/render/direct3d11/D3D11_VertexShader.h
new file mode 100644
index 0000000..97beaa3
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_VertexShader.h
@@ -0,0 +1,339 @@
+#if 0
+//
+// Generated by Microsoft (R) HLSL Shader Compiler 10.1
+//
+//
+// Buffer Definitions: 
+//
+// cbuffer VertexShaderConstants
+// {
+//
+//   row_major float4x4 model;          // Offset:    0 Size:    64
+//   row_major float4x4 projectionAndView;// Offset:   64 Size:    64
+//
+// }
+//
+//
+// Resource Bindings:
+//
+// Name                                 Type  Format         Dim      HLSL Bind  Count
+// ------------------------------ ---------- ------- ----------- -------------- ------
+// VertexShaderConstants             cbuffer      NA          NA            cb0      1 
+//
+//
+//
+// Input signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// POSITION                 0   xyz         0     NONE   float   xyz 
+// TEXCOORD                 0   xy          1     NONE   float   xy  
+// COLOR                    0   xyzw        2     NONE   float   xyzw
+//
+//
+// Output signature:
+//
+// Name                 Index   Mask Register SysValue  Format   Used
+// -------------------- ----- ------ -------- -------- ------- ------
+// SV_POSITION              0   xyzw        0      POS   float   xyzw
+// TEXCOORD                 0   xy          1     NONE   float   xy  
+// COLOR                    0   xyzw        2     NONE   float   xyzw
+//
+//
+// Constant buffer to DX9 shader constant mappings:
+//
+// Target Reg Buffer  Start Reg # of Regs        Data Conversion
+// ---------- ------- --------- --------- ----------------------
+// c1         cb0             0         8  ( FLT, FLT, FLT, FLT)
+//
+//
+// Runtime generated constant mappings:
+//
+// Target Reg                               Constant Description
+// ---------- --------------------------------------------------
+// c0                              Vertex Shader position offset
+//
+//
+// Level9 shader bytecode:
+//
+    vs_2_0
+    dcl_texcoord v0
+    dcl_texcoord1 v1
+    dcl_texcoord2 v2
+    mul r0, v0.y, c2
+    mad r0, v0.x, c1, r0
+    mad r0, v0.z, c3, r0
+    add r0, r0, c4
+    mul r1, r0.y, c6
+    mad r1, r0.x, c5, r1
+    mad r1, r0.z, c7, r1
+    mad r0, r0.w, c8, r1
+    mad oPos.xy, r0.w, c0, r0
+    mov oPos.zw, r0
+    mov oT0.xy, v1
+    mov oT1, v2
+
+// approximately 12 instruction slots used
+vs_4_0
+dcl_constantbuffer CB0[8], immediateIndexed
+dcl_input v0.xyz
+dcl_input v1.xy
+dcl_input v2.xyzw
+dcl_output_siv o0.xyzw, position
+dcl_output o1.xy
+dcl_output o2.xyzw
+dcl_temps 2
+mul r0.xyzw, v0.yyyy, cb0[1].xyzw
+mad r0.xyzw, v0.xxxx, cb0[0].xyzw, r0.xyzw
+mad r0.xyzw, v0.zzzz, cb0[2].xyzw, r0.xyzw
+add r0.xyzw, r0.xyzw, cb0[3].xyzw
+mul r1.xyzw, r0.yyyy, cb0[5].xyzw
+mad r1.xyzw, r0.xxxx, cb0[4].xyzw, r1.xyzw
+mad r1.xyzw, r0.zzzz, cb0[6].xyzw, r1.xyzw
+mad o0.xyzw, r0.wwww, cb0[7].xyzw, r1.xyzw
+mov o1.xy, v1.xyxx
+mov o2.xyzw, v2.xyzw
+ret 
+// Approximately 11 instruction slots used
+#endif
+
+const BYTE g_main[] =
+{
+     68,  88,  66,  67, 152, 172, 
+     81,  45, 198, 200,  12,  38, 
+    143,   4, 178, 228, 158, 175, 
+    169,  64,   1,   0,   0,   0, 
+    140,   5,   0,   0,   6,   0, 
+      0,   0,  56,   0,   0,   0, 
+    108,   1,   0,   0,  52,   3, 
+      0,   0, 176,   3,   0,   0, 
+    168,   4,   0,   0,  24,   5, 
+      0,   0,  65, 111, 110,  57, 
+     44,   1,   0,   0,  44,   1, 
+      0,   0,   0,   2, 254, 255, 
+    248,   0,   0,   0,  52,   0, 
+      0,   0,   1,   0,  36,   0, 
+      0,   0,  48,   0,   0,   0, 
+     48,   0,   0,   0,  36,   0, 
+      1,   0,  48,   0,   0,   0, 
+      0,   0,   8,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   2, 254, 255, 
+     31,   0,   0,   2,   5,   0, 
+      0, 128,   0,   0,  15, 144, 
+     31,   0,   0,   2,   5,   0, 
+      1, 128,   1,   0,  15, 144, 
+     31,   0,   0,   2,   5,   0, 
+      2, 128,   2,   0,  15, 144, 
+      5,   0,   0,   3,   0,   0, 
+     15, 128,   0,   0,  85, 144, 
+      2,   0, 228, 160,   4,   0, 
+      0,   4,   0,   0,  15, 128, 
+      0,   0,   0, 144,   1,   0, 
+    228, 160,   0,   0, 228, 128, 
+      4,   0,   0,   4,   0,   0, 
+     15, 128,   0,   0, 170, 144, 
+      3,   0, 228, 160,   0,   0, 
+    228, 128,   2,   0,   0,   3, 
+      0,   0,  15, 128,   0,   0, 
+    228, 128,   4,   0, 228, 160, 
+      5,   0,   0,   3,   1,   0, 
+     15, 128,   0,   0,  85, 128, 
+      6,   0, 228, 160,   4,   0, 
+      0,   4,   1,   0,  15, 128, 
+      0,   0,   0, 128,   5,   0, 
+    228, 160,   1,   0, 228, 128, 
+      4,   0,   0,   4,   1,   0, 
+     15, 128,   0,   0, 170, 128, 
+      7,   0, 228, 160,   1,   0, 
+    228, 128,   4,   0,   0,   4, 
+      0,   0,  15, 128,   0,   0, 
+    255, 128,   8,   0, 228, 160, 
+      1,   0, 228, 128,   4,   0, 
+      0,   4,   0,   0,   3, 192, 
+      0,   0, 255, 128,   0,   0, 
+    228, 160,   0,   0, 228, 128, 
+      1,   0,   0,   2,   0,   0, 
+     12, 192,   0,   0, 228, 128, 
+      1,   0,   0,   2,   0,   0, 
+      3, 224,   1,   0, 228, 144, 
+      1,   0,   0,   2,   1,   0, 
+     15, 224,   2,   0, 228, 144, 
+    255, 255,   0,   0,  83,  72, 
+     68,  82, 192,   1,   0,   0, 
+     64,   0,   1,   0, 112,   0, 
+      0,   0,  89,   0,   0,   4, 
+     70, 142,  32,   0,   0,   0, 
+      0,   0,   8,   0,   0,   0, 
+     95,   0,   0,   3, 114,  16, 
+     16,   0,   0,   0,   0,   0, 
+     95,   0,   0,   3,  50,  16, 
+     16,   0,   1,   0,   0,   0, 
+     95,   0,   0,   3, 242,  16, 
+     16,   0,   2,   0,   0,   0, 
+    103,   0,   0,   4, 242,  32, 
+     16,   0,   0,   0,   0,   0, 
+      1,   0,   0,   0, 101,   0, 
+      0,   3,  50,  32,  16,   0, 
+      1,   0,   0,   0, 101,   0, 
+      0,   3, 242,  32,  16,   0, 
+      2,   0,   0,   0, 104,   0, 
+      0,   2,   2,   0,   0,   0, 
+     56,   0,   0,   8, 242,   0, 
+     16,   0,   0,   0,   0,   0, 
+     86,  21,  16,   0,   0,   0, 
+      0,   0,  70, 142,  32,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,  50,   0,   0,  10, 
+    242,   0,  16,   0,   0,   0, 
+      0,   0,   6,  16,  16,   0, 
+      0,   0,   0,   0,  70, 142, 
+     32,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,  70,  14, 
+     16,   0,   0,   0,   0,   0, 
+     50,   0,   0,  10, 242,   0, 
+     16,   0,   0,   0,   0,   0, 
+    166,  26,  16,   0,   0,   0, 
+      0,   0,  70, 142,  32,   0, 
+      0,   0,   0,   0,   2,   0, 
+      0,   0,  70,  14,  16,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   8, 242,   0,  16,   0, 
+      0,   0,   0,   0,  70,  14, 
+     16,   0,   0,   0,   0,   0, 
+     70, 142,  32,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+     56,   0,   0,   8, 242,   0, 
+     16,   0,   1,   0,   0,   0, 
+     86,   5,  16,   0,   0,   0, 
+      0,   0,  70, 142,  32,   0, 
+      0,   0,   0,   0,   5,   0, 
+      0,   0,  50,   0,   0,  10, 
+    242,   0,  16,   0,   1,   0, 
+      0,   0,   6,   0,  16,   0, 
+      0,   0,   0,   0,  70, 142, 
+     32,   0,   0,   0,   0,   0, 
+      4,   0,   0,   0,  70,  14, 
+     16,   0,   1,   0,   0,   0, 
+     50,   0,   0,  10, 242,   0, 
+     16,   0,   1,   0,   0,   0, 
+    166,  10,  16,   0,   0,   0, 
+      0,   0,  70, 142,  32,   0, 
+      0,   0,   0,   0,   6,   0, 
+      0,   0,  70,  14,  16,   0, 
+      1,   0,   0,   0,  50,   0, 
+      0,  10, 242,  32,  16,   0, 
+      0,   0,   0,   0, 246,  15, 
+     16,   0,   0,   0,   0,   0, 
+     70, 142,  32,   0,   0,   0, 
+      0,   0,   7,   0,   0,   0, 
+     70,  14,  16,   0,   1,   0, 
+      0,   0,  54,   0,   0,   5, 
+     50,  32,  16,   0,   1,   0, 
+      0,   0,  70,  16,  16,   0, 
+      1,   0,   0,   0,  54,   0, 
+      0,   5, 242,  32,  16,   0, 
+      2,   0,   0,   0,  70,  30, 
+     16,   0,   2,   0,   0,   0, 
+     62,   0,   0,   1,  83,  84, 
+     65,  84, 116,   0,   0,   0, 
+     11,   0,   0,   0,   2,   0, 
+      0,   0,   0,   0,   0,   0, 
+      6,   0,   0,   0,   8,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   1,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   2,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,  82,  68,  69,  70, 
+    240,   0,   0,   0,   1,   0, 
+      0,   0,  84,   0,   0,   0, 
+      1,   0,   0,   0,  28,   0, 
+      0,   0,   0,   4, 254, 255, 
+      0,   1,   0,   0, 198,   0, 
+      0,   0,  60,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      1,   0,   0,   0,  86, 101, 
+    114, 116, 101, 120,  83, 104, 
+     97, 100, 101, 114,  67, 111, 
+    110, 115, 116,  97, 110, 116, 
+    115,   0, 171, 171,  60,   0, 
+      0,   0,   2,   0,   0,   0, 
+    108,   0,   0,   0, 128,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 156,   0, 
+      0,   0,   0,   0,   0,   0, 
+     64,   0,   0,   0,   2,   0, 
+      0,   0, 164,   0,   0,   0, 
+      0,   0,   0,   0, 180,   0, 
+      0,   0,  64,   0,   0,   0, 
+     64,   0,   0,   0,   2,   0, 
+      0,   0, 164,   0,   0,   0, 
+      0,   0,   0,   0, 109, 111, 
+    100, 101, 108,   0, 171, 171, 
+      2,   0,   3,   0,   4,   0, 
+      4,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0, 112, 114, 
+    111, 106, 101,  99, 116, 105, 
+    111, 110,  65, 110, 100,  86, 
+    105, 101, 119,   0,  77, 105, 
+     99, 114, 111, 115, 111, 102, 
+    116,  32,  40,  82,  41,  32, 
+     72,  76,  83,  76,  32,  83, 
+    104,  97, 100, 101, 114,  32, 
+     67, 111, 109, 112, 105, 108, 
+    101, 114,  32,  49,  48,  46, 
+     49,   0, 171, 171,  73,  83, 
+     71,  78, 104,   0,   0,   0, 
+      3,   0,   0,   0,   8,   0, 
+      0,   0,  80,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+      0,   0,   0,   0,   7,   7, 
+      0,   0,  89,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+      1,   0,   0,   0,   3,   3, 
+      0,   0,  98,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      0,   0,   3,   0,   0,   0, 
+      2,   0,   0,   0,  15,  15, 
+      0,   0,  80,  79,  83,  73, 
+     84,  73,  79,  78,   0,  84, 
+     69,  88,  67,  79,  79,  82, 
+     68,   0,  67,  79,  76,  79, 
+     82,   0,  79,  83,  71,  78, 
+    108,   0,   0,   0,   3,   0, 
+      0,   0,   8,   0,   0,   0, 
+     80,   0,   0,   0,   0,   0, 
+      0,   0,   1,   0,   0,   0, 
+      3,   0,   0,   0,   0,   0, 
+      0,   0,  15,   0,   0,   0, 
+     92,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   1,   0, 
+      0,   0,   3,  12,   0,   0, 
+    101,   0,   0,   0,   0,   0, 
+      0,   0,   0,   0,   0,   0, 
+      3,   0,   0,   0,   2,   0, 
+      0,   0,  15,   0,   0,   0, 
+     83,  86,  95,  80,  79,  83, 
+     73,  84,  73,  79,  78,   0, 
+     84,  69,  88,  67,  79,  79, 
+     82,  68,   0,  67,  79,  76, 
+     79,  82,   0, 171
+};
diff --git a/SDL-3.2.8/src/render/direct3d11/D3D11_VertexShader.hlsl b/SDL-3.2.8/src/render/direct3d11/D3D11_VertexShader.hlsl
new file mode 100644
index 0000000..63e5172
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/D3D11_VertexShader.hlsl
@@ -0,0 +1,38 @@
+#pragma pack_matrix( row_major )
+
+cbuffer VertexShaderConstants : register(b0)
+{
+    matrix model;
+    matrix projectionAndView;
+};
+
+struct VertexShaderInput
+{
+    float3 pos : POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+struct VertexShaderOutput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+VertexShaderOutput main(VertexShaderInput input)
+{
+    VertexShaderOutput output;
+    float4 pos = float4(input.pos, 1.0f);
+
+    // Transform the vertex position into projected space.
+    pos = mul(pos, model);
+    pos = mul(pos, projectionAndView);
+    output.pos = pos;
+
+    // Pass through texture coordinates and color values without transformation
+    output.tex = input.tex;
+    output.color = input.color;
+
+    return output;
+}
diff --git a/SDL-3.2.8/src/render/direct3d11/SDL_render_d3d11.c b/SDL-3.2.8/src/render/direct3d11/SDL_render_d3d11.c
new file mode 100644
index 0000000..dc1a722
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/SDL_render_d3d11.c
@@ -0,0 +1,2767 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_D3D11
+
+#define COBJMACROS
+#include "../../core/windows/SDL_windows.h"
+#include "../../video/windows/SDL_windowswindow.h"
+#include "../SDL_sysrender.h"
+#include "../SDL_d3dmath.h"
+#include "../../video/SDL_pixels_c.h"
+
+#include <d3d11_1.h>
+#include <dxgi1_4.h>
+#include <dxgidebug.h>
+
+#include "SDL_shaders_d3d11.h"
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SDL_COMPOSE_ERROR(str) __FUNCTION__ ", " str
+#else
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+#endif
+
+#define SAFE_RELEASE(X)                                   \
+    if ((X)) {                                            \
+        IUnknown_Release(SDL_static_cast(IUnknown *, X)); \
+        X = NULL;                                         \
+    }
+
+/* !!! FIXME: vertex buffer bandwidth could be lower; only use UV coords when
+   !!! FIXME:  textures are needed. */
+
+// Sampler types
+typedef enum
+{
+    D3D11_SAMPLER_NEAREST_CLAMP,
+    D3D11_SAMPLER_NEAREST_WRAP,
+    D3D11_SAMPLER_LINEAR_CLAMP,
+    D3D11_SAMPLER_LINEAR_WRAP,
+    D3D11_SAMPLER_COUNT
+} D3D11_Sampler;
+
+// Vertex shader, common values
+typedef struct
+{
+    Float4X4 model;
+    Float4X4 projectionAndView;
+} D3D11_VertexShaderConstants;
+
+// These should mirror the definitions in D3D11_PixelShader_Common.hlsli
+//static const float TONEMAP_NONE = 0;
+//static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+//static const float TEXTURETYPE_NONE = 0;
+static const float TEXTURETYPE_RGB = 1;
+static const float TEXTURETYPE_NV12 = 2;
+static const float TEXTURETYPE_NV21 = 3;
+static const float TEXTURETYPE_YUV = 4;
+
+static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+typedef struct
+{
+    float scRGB_output;
+    float texture_type;
+    float input_type;
+    float color_scale;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+
+    float YCbCr_matrix[16];
+} D3D11_PixelShaderConstants;
+
+typedef struct
+{
+    ID3D11Buffer *constants;
+    D3D11_PixelShaderConstants shader_constants;
+} D3D11_PixelShaderState;
+
+// Per-vertex data
+typedef struct
+{
+    Float2 pos;
+    Float2 tex;
+    SDL_FColor color;
+} D3D11_VertexPositionColor;
+
+// Per-texture data
+typedef struct
+{
+    int w, h;
+    ID3D11Texture2D *mainTexture;
+    ID3D11ShaderResourceView *mainTextureResourceView;
+    ID3D11RenderTargetView *mainTextureRenderTargetView;
+    ID3D11Texture2D *stagingTexture;
+    int lockedTexturePositionX;
+    int lockedTexturePositionY;
+    D3D11_FILTER scaleMode;
+    D3D11_Shader shader;
+    const float *YCbCr_matrix;
+#ifdef SDL_HAVE_YUV
+    // YV12 texture support
+    bool yuv;
+    ID3D11Texture2D *mainTextureU;
+    ID3D11ShaderResourceView *mainTextureResourceViewU;
+    ID3D11Texture2D *mainTextureV;
+    ID3D11ShaderResourceView *mainTextureResourceViewV;
+
+    // NV12 texture support
+    bool nv12;
+    ID3D11ShaderResourceView *mainTextureResourceViewNV;
+
+    Uint8 *pixels;
+    int pitch;
+    SDL_Rect locked_rect;
+#endif
+} D3D11_TextureData;
+
+// Blend mode data
+typedef struct
+{
+    SDL_BlendMode blendMode;
+    ID3D11BlendState *blendState;
+} D3D11_BlendMode;
+
+// Private renderer data
+typedef struct
+{
+    SDL_SharedObject *hDXGIMod;
+    SDL_SharedObject *hD3D11Mod;
+    IDXGIFactory2 *dxgiFactory;
+    IDXGIAdapter *dxgiAdapter;
+    IDXGIDebug *dxgiDebug;
+    ID3D11Device1 *d3dDevice;
+    ID3D11DeviceContext1 *d3dContext;
+    IDXGISwapChain1 *swapChain;
+    DXGI_SWAP_EFFECT swapEffect;
+    UINT syncInterval;
+    UINT presentFlags;
+    ID3D11RenderTargetView *mainRenderTargetView;
+    ID3D11RenderTargetView *currentOffscreenRenderTargetView;
+    ID3D11InputLayout *inputLayout;
+    ID3D11Buffer *vertexBuffers[8];
+    size_t vertexBufferSizes[8];
+    ID3D11VertexShader *vertexShader;
+    ID3D11PixelShader *pixelShaders[NUM_SHADERS];
+    int blendModesCount;
+    D3D11_BlendMode *blendModes;
+    ID3D11SamplerState *samplers[D3D11_SAMPLER_COUNT];
+    D3D_FEATURE_LEVEL featureLevel;
+    bool pixelSizeChanged;
+
+    // Rasterizers
+    ID3D11RasterizerState *mainRasterizer;
+    ID3D11RasterizerState *clippedRasterizer;
+
+    // Vertex buffer constants
+    D3D11_VertexShaderConstants vertexShaderConstantsData;
+    ID3D11Buffer *vertexShaderConstants;
+
+    // Cached renderer properties
+    DXGI_MODE_ROTATION rotation;
+    ID3D11RenderTargetView *currentRenderTargetView;
+    ID3D11RasterizerState *currentRasterizerState;
+    ID3D11BlendState *currentBlendState;
+    D3D11_Shader currentShader;
+    D3D11_PixelShaderState currentShaderState[NUM_SHADERS];
+    ID3D11ShaderResourceView *currentShaderResource;
+    ID3D11SamplerState *currentSampler;
+    bool cliprectDirty;
+    bool currentCliprectEnabled;
+    SDL_Rect currentCliprect;
+    SDL_Rect currentViewport;
+    int currentViewportRotation;
+    bool viewportDirty;
+    Float4X4 identity;
+    int currentVertexBuffer;
+} D3D11_RenderData;
+
+// Define D3D GUIDs here so we don't have to include uuid.lib.
+
+#ifdef HAVE_GCC_DIAGNOSTIC_PRAGMA
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-const-variable"
+#endif
+
+static const GUID SDL_IID_IDXGIFactory2 = { 0x50c83a1c, 0xe072, 0x4c48, { 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0 } };
+static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };
+static const GUID SDL_IID_ID3D11Texture2D = { 0x6f15aaf2, 0xd208, 0x4e89, { 0x9a, 0xb4, 0x48, 0x95, 0x35, 0xd3, 0x4f, 0x9c } };
+static const GUID SDL_IID_ID3D11Device1 = { 0xa04bfb29, 0x08ef, 0x43d6, { 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86 } };
+static const GUID SDL_IID_ID3D11DeviceContext1 = { 0xbb2c6faa, 0xb5fb, 0x4082, { 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1 } };
+static const GUID SDL_IID_IDXGISwapChain2 = { 0x94d99bdb, 0xf1f8, 0x4ab0, { 0xb2, 0x36, 0x7d, 0xa0, 0x17, 0x0e, 0xda, 0xb1 } };
+static const GUID SDL_IID_IDXGIDebug1 = { 0xc5a05f0c, 0x16f2, 0x4adf, { 0x9f, 0x4d, 0xa8, 0xc4, 0xd5, 0x8a, 0xc5, 0x50 } };
+static const GUID SDL_IID_IDXGIInfoQueue = { 0xD67441C7, 0x672A, 0x476f, { 0x9E, 0x82, 0xCD, 0x55, 0xB4, 0x49, 0x49, 0xCE } };
+static const GUID SDL_DXGI_DEBUG_ALL = { 0xe48ae283, 0xda80, 0x490b, { 0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8 } };
+
+#ifdef HAVE_GCC_DIAGNOSTIC_PRAGMA
+#pragma GCC diagnostic pop
+#endif
+
+SDL_PixelFormat D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
+{
+    switch (dxgiFormat) {
+    case DXGI_FORMAT_B8G8R8A8_UNORM:
+    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_ARGB8888;
+    case DXGI_FORMAT_R8G8B8A8_UNORM:
+    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_ABGR8888;
+    case DXGI_FORMAT_B8G8R8X8_UNORM:
+    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_XRGB8888;
+    case DXGI_FORMAT_R10G10B10A2_UNORM:
+        return SDL_PIXELFORMAT_ABGR2101010;
+    case DXGI_FORMAT_R16G16B16A16_FLOAT:
+        return SDL_PIXELFORMAT_RGBA64_FLOAT;
+    default:
+        return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static DXGI_FORMAT SDLPixelFormatToDXGITextureFormat(Uint32 format, Uint32 output_colorspace)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_RGBA64_FLOAT:
+        return DXGI_FORMAT_R16G16B16A16_FLOAT;
+    case SDL_PIXELFORMAT_ABGR2101010:
+        return DXGI_FORMAT_R10G10B10A2_UNORM;
+    case SDL_PIXELFORMAT_ARGB8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8A8_UNORM;
+    case SDL_PIXELFORMAT_ABGR8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_R8G8B8A8_UNORM;
+    case SDL_PIXELFORMAT_XRGB8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8X8_UNORM;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+        return DXGI_FORMAT_R8_UNORM;
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        return DXGI_FORMAT_NV12;
+    case SDL_PIXELFORMAT_P010:
+        return DXGI_FORMAT_P010;
+    default:
+        return DXGI_FORMAT_UNKNOWN;
+    }
+}
+
+static DXGI_FORMAT SDLPixelFormatToDXGIMainResourceViewFormat(Uint32 format, Uint32 colorspace)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_RGBA64_FLOAT:
+        return DXGI_FORMAT_R16G16B16A16_FLOAT;
+    case SDL_PIXELFORMAT_ABGR2101010:
+        return DXGI_FORMAT_R10G10B10A2_UNORM;
+    case SDL_PIXELFORMAT_ARGB8888:
+        if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8A8_UNORM;
+    case SDL_PIXELFORMAT_ABGR8888:
+        if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_R8G8B8A8_UNORM;
+    case SDL_PIXELFORMAT_XRGB8888:
+        if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8X8_UNORM;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_NV12:  // For the Y texture
+    case SDL_PIXELFORMAT_NV21:  // For the Y texture
+        return DXGI_FORMAT_R8_UNORM;
+    case SDL_PIXELFORMAT_P010:  // For the Y texture
+        return DXGI_FORMAT_R16_UNORM;
+    default:
+        return DXGI_FORMAT_UNKNOWN;
+    }
+}
+
+static void D3D11_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+
+static void D3D11_ReleaseAll(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+
+    // Release all textures
+    for (SDL_Texture *texture = renderer->textures; texture; texture = texture->next) {
+        D3D11_DestroyTexture(renderer, texture);
+    }
+
+    // Release/reset everything else
+    if (data) {
+        int i;
+
+        // Make sure the swap chain is fully released
+        if (data->d3dContext) {
+            ID3D11DeviceContext_ClearState(data->d3dContext);
+            ID3D11DeviceContext_Flush(data->d3dContext);
+        }
+
+        SAFE_RELEASE(data->vertexShaderConstants);
+        SAFE_RELEASE(data->clippedRasterizer);
+        SAFE_RELEASE(data->mainRasterizer);
+        for (i = 0; i < SDL_arraysize(data->samplers); ++i) {
+            SAFE_RELEASE(data->samplers[i]);
+        }
+
+        if (data->blendModesCount > 0) {
+            for (i = 0; i < data->blendModesCount; ++i) {
+                SAFE_RELEASE(data->blendModes[i].blendState);
+            }
+            SDL_free(data->blendModes);
+            data->blendModes = NULL;
+            data->blendModesCount = 0;
+        }
+        for (i = 0; i < SDL_arraysize(data->pixelShaders); ++i) {
+            SAFE_RELEASE(data->pixelShaders[i]);
+        }
+        for (i = 0; i < SDL_arraysize(data->currentShaderState); ++i) {
+            SAFE_RELEASE(data->currentShaderState[i].constants);
+        }
+        SAFE_RELEASE(data->vertexShader);
+        for (i = 0; i < SDL_arraysize(data->vertexBuffers); ++i) {
+            SAFE_RELEASE(data->vertexBuffers[i]);
+        }
+        SAFE_RELEASE(data->inputLayout);
+        SAFE_RELEASE(data->mainRenderTargetView);
+        SAFE_RELEASE(data->swapChain);
+
+        SAFE_RELEASE(data->d3dContext);
+        SAFE_RELEASE(data->d3dDevice);
+        SAFE_RELEASE(data->dxgiAdapter);
+        SAFE_RELEASE(data->dxgiFactory);
+
+        data->swapEffect = (DXGI_SWAP_EFFECT)0;
+        data->rotation = DXGI_MODE_ROTATION_UNSPECIFIED;
+        data->currentOffscreenRenderTargetView = NULL;
+        data->currentRenderTargetView = NULL;
+        data->currentRasterizerState = NULL;
+        data->currentBlendState = NULL;
+        data->currentShader = SHADER_NONE;
+        SDL_zero(data->currentShaderState);
+        data->currentShaderResource = NULL;
+        data->currentSampler = NULL;
+
+        // Check for any leaks if in debug mode
+        if (data->dxgiDebug) {
+            DXGI_DEBUG_RLO_FLAGS rloFlags = (DXGI_DEBUG_RLO_FLAGS)(DXGI_DEBUG_RLO_DETAIL | DXGI_DEBUG_RLO_IGNORE_INTERNAL);
+            IDXGIDebug_ReportLiveObjects(data->dxgiDebug, SDL_DXGI_DEBUG_ALL, rloFlags);
+            SAFE_RELEASE(data->dxgiDebug);
+        }
+
+        /* Unload the D3D libraries.  This should be done last, in order
+         * to prevent IUnknown::Release() calls from crashing.
+         */
+        if (data->hD3D11Mod) {
+            SDL_UnloadObject(data->hD3D11Mod);
+            data->hD3D11Mod = NULL;
+        }
+        if (data->hDXGIMod) {
+            SDL_UnloadObject(data->hDXGIMod);
+            data->hDXGIMod = NULL;
+        }
+    }
+}
+
+static void D3D11_DestroyRenderer(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    if (data) {
+        D3D11_ReleaseAll(renderer);
+        SDL_free(data);
+    }
+}
+
+static D3D11_BLEND GetBlendFunc(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return D3D11_BLEND_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return D3D11_BLEND_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return D3D11_BLEND_SRC_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return D3D11_BLEND_INV_SRC_COLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return D3D11_BLEND_SRC_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return D3D11_BLEND_INV_SRC_ALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return D3D11_BLEND_DEST_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return D3D11_BLEND_INV_DEST_COLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return D3D11_BLEND_DEST_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return D3D11_BLEND_INV_DEST_ALPHA;
+    default:
+        return (D3D11_BLEND)0;
+    }
+}
+
+static D3D11_BLEND_OP GetBlendEquation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return D3D11_BLEND_OP_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return D3D11_BLEND_OP_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return D3D11_BLEND_OP_REV_SUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return D3D11_BLEND_OP_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return D3D11_BLEND_OP_MAX;
+    default:
+        return (D3D11_BLEND_OP)0;
+    }
+}
+
+static ID3D11BlendState *D3D11_CreateBlendState(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+    ID3D11BlendState *blendState = NULL;
+    D3D11_BlendMode *blendModes;
+    HRESULT result = S_OK;
+
+    D3D11_BLEND_DESC blendDesc;
+    SDL_zero(blendDesc);
+    blendDesc.AlphaToCoverageEnable = FALSE;
+    blendDesc.IndependentBlendEnable = FALSE;
+    blendDesc.RenderTarget[0].BlendEnable = TRUE;
+    blendDesc.RenderTarget[0].SrcBlend = GetBlendFunc(srcColorFactor);
+    blendDesc.RenderTarget[0].DestBlend = GetBlendFunc(dstColorFactor);
+    blendDesc.RenderTarget[0].BlendOp = GetBlendEquation(colorOperation);
+    blendDesc.RenderTarget[0].SrcBlendAlpha = GetBlendFunc(srcAlphaFactor);
+    blendDesc.RenderTarget[0].DestBlendAlpha = GetBlendFunc(dstAlphaFactor);
+    blendDesc.RenderTarget[0].BlendOpAlpha = GetBlendEquation(alphaOperation);
+    blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
+    result = ID3D11Device_CreateBlendState(data->d3dDevice, &blendDesc, &blendState);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateBlendState"), result);
+        return NULL;
+    }
+
+    blendModes = (D3D11_BlendMode *)SDL_realloc(data->blendModes, (data->blendModesCount + 1) * sizeof(*blendModes));
+    if (!blendModes) {
+        SAFE_RELEASE(blendState);
+        return NULL;
+    }
+    blendModes[data->blendModesCount].blendMode = blendMode;
+    blendModes[data->blendModesCount].blendState = blendState;
+    data->blendModes = blendModes;
+    ++data->blendModesCount;
+
+    return blendState;
+}
+
+// Create resources that depend on the device.
+static HRESULT D3D11_CreateDeviceResources(SDL_Renderer *renderer)
+{
+    typedef HRESULT(WINAPI * PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
+    typedef HRESULT(WINAPI * PFN_CREATE_DXGI_FACTORY2)(UINT flags, REFIID riid, void **ppFactory);
+    PFN_CREATE_DXGI_FACTORY CreateDXGIFactoryFunc = NULL;
+    PFN_CREATE_DXGI_FACTORY2 CreateDXGIFactory2Func = NULL;
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    PFN_D3D11_CREATE_DEVICE D3D11CreateDeviceFunc;
+    ID3D11Device *d3dDevice = NULL;
+    ID3D11DeviceContext *d3dContext = NULL;
+    IDXGIDevice1 *dxgiDevice = NULL;
+    HRESULT result = S_OK;
+    UINT creationFlags = 0;
+    bool createDebug;
+
+    /* This array defines the set of DirectX hardware feature levels this app will support.
+     * Note the ordering should be preserved.
+     * Don't forget to declare your application's minimum required feature level in its
+     * description.  All applications are assumed to support 9.1 unless otherwise stated.
+     */
+    D3D_FEATURE_LEVEL featureLevels[] = {
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_3,
+        D3D_FEATURE_LEVEL_9_2,
+        D3D_FEATURE_LEVEL_9_1
+    };
+
+    D3D11_BUFFER_DESC constantBufferDesc;
+    D3D11_SAMPLER_DESC samplerDesc;
+    D3D11_RASTERIZER_DESC rasterDesc;
+
+    // See if we need debug interfaces
+    createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D11_DEBUG, false);
+
+    data->hDXGIMod = SDL_LoadObject("dxgi.dll");
+    if (!data->hDXGIMod) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    CreateDXGIFactory2Func = (PFN_CREATE_DXGI_FACTORY2)SDL_LoadFunction(data->hDXGIMod, "CreateDXGIFactory2");
+    if (!CreateDXGIFactory2Func) {
+        CreateDXGIFactoryFunc = (PFN_CREATE_DXGI_FACTORY)SDL_LoadFunction(data->hDXGIMod, "CreateDXGIFactory");
+        if (!CreateDXGIFactoryFunc) {
+            result = E_FAIL;
+            goto done;
+        }
+    }
+
+    data->hD3D11Mod = SDL_LoadObject("d3d11.dll");
+    if (!data->hD3D11Mod) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    D3D11CreateDeviceFunc = (PFN_D3D11_CREATE_DEVICE)SDL_LoadFunction(data->hD3D11Mod, "D3D11CreateDevice");
+    if (!D3D11CreateDeviceFunc) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    if (createDebug) {
+#ifdef __IDXGIInfoQueue_INTERFACE_DEFINED__
+        IDXGIInfoQueue *dxgiInfoQueue = NULL;
+        PFN_CREATE_DXGI_FACTORY2 DXGIGetDebugInterfaceFunc;
+
+        // If the debug hint is set, also create the DXGI factory in debug mode
+        DXGIGetDebugInterfaceFunc = (PFN_CREATE_DXGI_FACTORY2)SDL_LoadFunction(data->hDXGIMod, "DXGIGetDebugInterface1");
+        if (!DXGIGetDebugInterfaceFunc) {
+            result = E_FAIL;
+            goto done;
+        }
+
+        result = DXGIGetDebugInterfaceFunc(0, &SDL_IID_IDXGIDebug1, (void **)&data->dxgiDebug);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("DXGIGetDebugInterface1"), result);
+            goto done;
+        }
+
+        result = DXGIGetDebugInterfaceFunc(0, &SDL_IID_IDXGIInfoQueue, (void **)&dxgiInfoQueue);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("DXGIGetDebugInterface1"), result);
+            goto done;
+        }
+
+        IDXGIInfoQueue_SetBreakOnSeverity(dxgiInfoQueue, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, TRUE);
+        IDXGIInfoQueue_SetBreakOnSeverity(dxgiInfoQueue, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, TRUE);
+        SAFE_RELEASE(dxgiInfoQueue);
+#endif // __IDXGIInfoQueue_INTERFACE_DEFINED__
+        creationFlags = DXGI_CREATE_FACTORY_DEBUG;
+    }
+
+    if (CreateDXGIFactory2Func) {
+        result = CreateDXGIFactory2Func(creationFlags, &SDL_IID_IDXGIFactory2, (void **)&data->dxgiFactory);
+    } else {
+        result = CreateDXGIFactoryFunc(&SDL_IID_IDXGIFactory2, (void **)&data->dxgiFactory);
+    }
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("CreateDXGIFactory"), result);
+        goto done;
+    }
+
+    // FIXME: Should we use the default adapter?
+    result = IDXGIFactory2_EnumAdapters(data->dxgiFactory, 0, &data->dxgiAdapter);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("D3D11CreateDevice"), result);
+        goto done;
+    }
+
+    /* This flag adds support for surfaces with a different color channel ordering
+     * than the API default. It is required for compatibility with Direct2D.
+     */
+    creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+
+    // Make sure Direct3D's debugging feature gets used, if the app requests it.
+    if (createDebug) {
+        creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
+    }
+
+    // Create a single-threaded device unless the app requests otherwise.
+    if (!SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, false)) {
+        creationFlags |= D3D11_CREATE_DEVICE_SINGLETHREADED;
+    }
+
+    // Create the Direct3D 11 API device object and a corresponding context.
+    result = D3D11CreateDeviceFunc(
+        data->dxgiAdapter,
+        D3D_DRIVER_TYPE_UNKNOWN,
+        NULL,
+        creationFlags, // Set set debug and Direct2D compatibility flags.
+        featureLevels, // List of feature levels this app can support.
+        SDL_arraysize(featureLevels),
+        D3D11_SDK_VERSION,   // Always set this to D3D11_SDK_VERSION for Windows Store apps.
+        &d3dDevice,          // Returns the Direct3D device created.
+        &data->featureLevel, // Returns feature level of device created.
+        &d3dContext          // Returns the device immediate context.
+    );
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("D3D11CreateDevice"), result);
+        goto done;
+    }
+
+    result = ID3D11Device_QueryInterface(d3dDevice, &SDL_IID_ID3D11Device1, (void **)&data->d3dDevice);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device to ID3D11Device1"), result);
+        goto done;
+    }
+
+    result = ID3D11DeviceContext_QueryInterface(d3dContext, &SDL_IID_ID3D11DeviceContext1, (void **)&data->d3dContext);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext to ID3D11DeviceContext1"), result);
+        goto done;
+    }
+
+    result = ID3D11Device_QueryInterface(d3dDevice, &SDL_IID_IDXGIDevice1, (void **)&dxgiDevice);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device to IDXGIDevice1"), result);
+        goto done;
+    }
+
+    /* Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and
+     * ensures that the application will only render after each VSync, minimizing power consumption.
+     */
+    result = IDXGIDevice1_SetMaximumFrameLatency(dxgiDevice, 1);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGIDevice1::SetMaximumFrameLatency"), result);
+        goto done;
+    }
+
+    /* Make note of the maximum texture size
+     * Max texture sizes are documented on MSDN, at:
+     * http://msdn.microsoft.com/en-us/library/windows/apps/ff476876.aspx
+     */
+    switch (data->featureLevel) {
+    case D3D_FEATURE_LEVEL_11_1:
+    case D3D_FEATURE_LEVEL_11_0:
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
+        break;
+
+    case D3D_FEATURE_LEVEL_10_1:
+    case D3D_FEATURE_LEVEL_10_0:
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 8192);
+        break;
+
+    case D3D_FEATURE_LEVEL_9_3:
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 4096);
+        break;
+
+    case D3D_FEATURE_LEVEL_9_2:
+    case D3D_FEATURE_LEVEL_9_1:
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 2048);
+        break;
+
+    default:
+        SDL_SetError("%s, Unexpected feature level: %d", __FUNCTION__, data->featureLevel);
+        result = E_FAIL;
+        goto done;
+    }
+
+    if (!D3D11_CreateVertexShader(data->d3dDevice, &data->vertexShader, &data->inputLayout)) {
+        goto done;
+    }
+
+    // Setup space to hold vertex shader constants:
+    SDL_zero(constantBufferDesc);
+    constantBufferDesc.ByteWidth = sizeof(D3D11_VertexShaderConstants);
+    constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;
+    constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    result = ID3D11Device_CreateBuffer(data->d3dDevice,
+                                       &constantBufferDesc,
+                                       NULL,
+                                       &data->vertexShaderConstants);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateBuffer [vertex shader constants]"), result);
+        goto done;
+    }
+
+    // Create samplers to use when drawing textures:
+    static struct
+    {
+        D3D11_FILTER filter;
+        D3D11_TEXTURE_ADDRESS_MODE address;
+    } samplerParams[] = {
+        { D3D11_FILTER_MIN_MAG_MIP_POINT, D3D11_TEXTURE_ADDRESS_CLAMP },
+        { D3D11_FILTER_MIN_MAG_MIP_POINT, D3D11_TEXTURE_ADDRESS_WRAP },
+        { D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_TEXTURE_ADDRESS_CLAMP },
+        { D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_TEXTURE_ADDRESS_WRAP },
+    };
+    SDL_COMPILE_TIME_ASSERT(samplerParams_SIZE, SDL_arraysize(samplerParams) == D3D11_SAMPLER_COUNT);
+    SDL_zero(samplerDesc);
+    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
+    samplerDesc.MipLODBias = 0.0f;
+    samplerDesc.MaxAnisotropy = 1;
+    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
+    samplerDesc.MinLOD = 0.0f;
+    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
+    for (int i = 0; i < SDL_arraysize(samplerParams); ++i) {
+        samplerDesc.Filter = samplerParams[i].filter;
+        samplerDesc.AddressU = samplerParams[i].address;
+        samplerDesc.AddressV = samplerParams[i].address;
+        result = ID3D11Device_CreateSamplerState(data->d3dDevice,
+                                                 &samplerDesc,
+                                                 &data->samplers[i]);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateSamplerState [nearest-pixel filter]"), result);
+            goto done;
+        }
+    }
+
+    // Setup Direct3D rasterizer states
+    SDL_zero(rasterDesc);
+    rasterDesc.AntialiasedLineEnable = FALSE;
+    rasterDesc.CullMode = D3D11_CULL_NONE;
+    rasterDesc.DepthBias = 0;
+    rasterDesc.DepthBiasClamp = 0.0f;
+    rasterDesc.DepthClipEnable = TRUE;
+    rasterDesc.FillMode = D3D11_FILL_SOLID;
+    rasterDesc.FrontCounterClockwise = FALSE;
+    rasterDesc.MultisampleEnable = FALSE;
+    rasterDesc.ScissorEnable = FALSE;
+    rasterDesc.SlopeScaledDepthBias = 0.0f;
+    result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->mainRasterizer);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateRasterizerState [main rasterizer]"), result);
+        goto done;
+    }
+
+    rasterDesc.ScissorEnable = TRUE;
+    result = ID3D11Device_CreateRasterizerState(data->d3dDevice, &rasterDesc, &data->clippedRasterizer);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateRasterizerState [clipped rasterizer]"), result);
+        goto done;
+    }
+
+    // Create blending states:
+    if (!D3D11_CreateBlendState(renderer, SDL_BLENDMODE_BLEND)) {
+        // D3D11_CreateBlendState will set the SDL error, if it fails
+        goto done;
+    }
+
+    // Setup render state that doesn't change
+    ID3D11DeviceContext_IASetInputLayout(data->d3dContext, data->inputLayout);
+    ID3D11DeviceContext_VSSetShader(data->d3dContext, data->vertexShader, NULL, 0);
+    ID3D11DeviceContext_VSSetConstantBuffers(data->d3dContext, 0, 1, &data->vertexShaderConstants);
+
+    SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_D3D11_DEVICE_POINTER, data->d3dDevice);
+
+done:
+    SAFE_RELEASE(d3dDevice);
+    SAFE_RELEASE(d3dContext);
+    SAFE_RELEASE(dxgiDevice);
+    return result;
+}
+
+static DXGI_MODE_ROTATION D3D11_GetCurrentRotation(void)
+{
+    // FIXME
+    return DXGI_MODE_ROTATION_IDENTITY;
+}
+
+static BOOL D3D11_IsDisplayRotated90Degrees(DXGI_MODE_ROTATION rotation)
+{
+    switch (rotation) {
+    case DXGI_MODE_ROTATION_ROTATE90:
+    case DXGI_MODE_ROTATION_ROTATE270:
+        return TRUE;
+    default:
+        return FALSE;
+    }
+}
+
+static int D3D11_GetRotationForCurrentRenderTarget(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    if (data->currentOffscreenRenderTargetView) {
+        return DXGI_MODE_ROTATION_IDENTITY;
+    } else {
+        return data->rotation;
+    }
+}
+
+static bool D3D11_GetViewportAlignedD3DRect(SDL_Renderer *renderer, const SDL_Rect *sdlRect, D3D11_RECT *outRect, BOOL includeViewportOffset)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
+    const SDL_Rect *viewport = &data->currentViewport;
+
+    switch (rotation) {
+    case DXGI_MODE_ROTATION_IDENTITY:
+        outRect->left = sdlRect->x;
+        outRect->right = (LONG)sdlRect->x + sdlRect->w;
+        outRect->top = sdlRect->y;
+        outRect->bottom = (LONG)sdlRect->y + sdlRect->h;
+        if (includeViewportOffset) {
+            outRect->left += viewport->x;
+            outRect->right += viewport->x;
+            outRect->top += viewport->y;
+            outRect->bottom += viewport->y;
+        }
+        break;
+    case DXGI_MODE_ROTATION_ROTATE270:
+        outRect->left = sdlRect->y;
+        outRect->right = (LONG)sdlRect->y + sdlRect->h;
+        outRect->top = viewport->w - sdlRect->x - sdlRect->w;
+        outRect->bottom = viewport->w - sdlRect->x;
+        break;
+    case DXGI_MODE_ROTATION_ROTATE180:
+        outRect->left = viewport->w - sdlRect->x - sdlRect->w;
+        outRect->right = viewport->w - sdlRect->x;
+        outRect->top = viewport->h - sdlRect->y - sdlRect->h;
+        outRect->bottom = viewport->h - sdlRect->y;
+        break;
+    case DXGI_MODE_ROTATION_ROTATE90:
+        outRect->left = viewport->h - sdlRect->y - sdlRect->h;
+        outRect->right = viewport->h - sdlRect->y;
+        outRect->top = sdlRect->x;
+        outRect->bottom = (LONG)sdlRect->x + sdlRect->h;
+        break;
+    default:
+        return SDL_SetError("The physical display is in an unknown or unsupported rotation");
+    }
+    return true;
+}
+
+static HRESULT D3D11_CreateSwapChain(SDL_Renderer *renderer, int w, int h)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    IUnknown *coreWindow = NULL;
+    IDXGISwapChain3 *swapChain3 = NULL;
+    HRESULT result = S_OK;
+
+    // Create a swap chain using the same adapter as the existing Direct3D device.
+    DXGI_SWAP_CHAIN_DESC1 swapChainDesc;
+    SDL_zero(swapChainDesc);
+    swapChainDesc.Width = w;
+    swapChainDesc.Height = h;
+    switch (renderer->output_colorspace) {
+    case SDL_COLORSPACE_SRGB_LINEAR:
+        swapChainDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        break;
+    case SDL_COLORSPACE_HDR10:
+        swapChainDesc.Format = DXGI_FORMAT_R10G10B10A2_UNORM;
+        break;
+    default:
+        swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swap chain format.
+        break;
+    }
+    swapChainDesc.Stereo = FALSE;
+    swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling.
+    swapChainDesc.SampleDesc.Quality = 0;
+    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    swapChainDesc.BufferCount = 2; // Use double-buffering to minimize latency.
+    if (WIN_IsWindows8OrGreater()) {
+        swapChainDesc.Scaling = DXGI_SCALING_NONE;
+    } else {
+        swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
+    }
+    if (SDL_GetWindowFlags(renderer->window) & SDL_WINDOW_TRANSPARENT) {
+        swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
+        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+    } else {
+        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Windows Store apps must use this SwapEffect.
+    }
+    swapChainDesc.Flags = 0;
+
+    if (coreWindow) {
+        result = IDXGIFactory2_CreateSwapChainForCoreWindow(data->dxgiFactory,
+                                                            (IUnknown *)data->d3dDevice,
+                                                            coreWindow,
+                                                            &swapChainDesc,
+                                                            NULL, // Allow on all displays.
+                                                            &data->swapChain);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGIFactory2::CreateSwapChainForCoreWindow"), result);
+            goto done;
+        }
+    } else {
+#if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK)
+        HWND hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(renderer->window), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+        if (!hwnd) {
+            SDL_SetError("Couldn't get window handle");
+            result = E_FAIL;
+            goto done;
+        }
+
+        result = IDXGIFactory2_CreateSwapChainForHwnd(data->dxgiFactory,
+                                                      (IUnknown *)data->d3dDevice,
+                                                      hwnd,
+                                                      &swapChainDesc,
+                                                      NULL,
+                                                      NULL, // Allow on all displays.
+                                                      &data->swapChain);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGIFactory2::CreateSwapChainForHwnd"), result);
+            goto done;
+        }
+
+        IDXGIFactory_MakeWindowAssociation(data->dxgiFactory, hwnd, DXGI_MWA_NO_WINDOW_CHANGES);
+#else
+        SDL_SetError(__FUNCTION__ ", Unable to find something to attach a swap chain to");
+        goto done;
+#endif // defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK) / else
+    }
+    data->swapEffect = swapChainDesc.SwapEffect;
+
+    if (SUCCEEDED(IDXGISwapChain1_QueryInterface(data->swapChain, &SDL_IID_IDXGISwapChain2, (void **)&swapChain3))) {
+        UINT colorspace_support = 0;
+        DXGI_COLOR_SPACE_TYPE colorspace;
+        switch (renderer->output_colorspace) {
+        case SDL_COLORSPACE_SRGB_LINEAR:
+            colorspace = DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709;
+            break;
+        case SDL_COLORSPACE_HDR10:
+            colorspace = DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
+            break;
+        default:
+            // sRGB
+            colorspace = DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
+            break;
+        }
+        if (SUCCEEDED(IDXGISwapChain3_CheckColorSpaceSupport(swapChain3, colorspace, &colorspace_support)) &&
+            (colorspace_support & DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT)) {
+            result = IDXGISwapChain3_SetColorSpace1(swapChain3, colorspace);
+            if (FAILED(result)) {
+                WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain3::SetColorSpace1"), result);
+                goto done;
+            }
+        } else if (colorspace != DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709) {
+            // Not the default, we're not going to be able to present in this colorspace
+            SDL_SetError("Unsupported output colorspace");
+            result = DXGI_ERROR_UNSUPPORTED;
+        }
+    }
+
+    SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_D3D11_SWAPCHAIN_POINTER, data->swapChain);
+
+done:
+    SAFE_RELEASE(swapChain3);
+    SAFE_RELEASE(coreWindow);
+    return result;
+}
+
+static void D3D11_ReleaseMainRenderTargetView(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    ID3D11DeviceContext_OMSetRenderTargets(data->d3dContext, 0, NULL, NULL);
+    SAFE_RELEASE(data->mainRenderTargetView);
+}
+
+// Initialize all resources that change when the window's size changes.
+static HRESULT D3D11_CreateWindowSizeDependentResources(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    ID3D11Texture2D *backBuffer = NULL;
+    HRESULT result = S_OK;
+    int w, h;
+
+    // Release the previous render target view
+    D3D11_ReleaseMainRenderTargetView(renderer);
+
+    /* The width and height of the swap chain must be based on the display's
+     * non-rotated size.
+     */
+    SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
+    data->rotation = D3D11_GetCurrentRotation();
+    // SDL_Log("%s: windowSize={%d,%d}, orientation=%d", __FUNCTION__, w, h, (int)data->rotation);
+    if (D3D11_IsDisplayRotated90Degrees(data->rotation)) {
+        int tmp = w;
+        w = h;
+        h = tmp;
+    }
+
+    if (data->swapChain) {
+        // If the swap chain already exists, resize it.
+        result = IDXGISwapChain_ResizeBuffers(data->swapChain,
+                                              0,
+                                              w, h,
+                                              DXGI_FORMAT_UNKNOWN,
+                                              0);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::ResizeBuffers"), result);
+            goto done;
+        }
+    } else {
+        result = D3D11_CreateSwapChain(renderer, w, h);
+        if (FAILED(result) || !data->swapChain) {
+            goto done;
+        }
+    }
+
+    // Set the proper rotation for the swap chain.
+    if (WIN_IsWindows8OrGreater()) {
+        if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
+            result = IDXGISwapChain1_SetRotation(data->swapChain, data->rotation);
+            if (FAILED(result)) {
+                WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain1::SetRotation"), result);
+                goto done;
+            }
+        }
+    }
+
+    result = IDXGISwapChain_GetBuffer(data->swapChain,
+                                      0,
+                                      &SDL_IID_ID3D11Texture2D,
+                                      (void **)&backBuffer);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::GetBuffer [back-buffer]"), result);
+        goto done;
+    }
+
+    // Create a render target view of the swap chain back buffer.
+    result = ID3D11Device_CreateRenderTargetView(data->d3dDevice,
+                                                 (ID3D11Resource *)backBuffer,
+                                                 NULL,
+                                                 &data->mainRenderTargetView);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device::CreateRenderTargetView"), result);
+        goto done;
+    }
+
+    /* Set the swap chain target immediately, so that a target is always set
+     * even before we get to SetDrawState. Without this it's possible to hit
+     * null references in places like ReadPixels!
+     */
+    ID3D11DeviceContext_OMSetRenderTargets(data->d3dContext,
+                                           1,
+                                           &data->mainRenderTargetView,
+                                           NULL);
+
+    data->viewportDirty = true;
+
+done:
+    SAFE_RELEASE(backBuffer);
+    return result;
+}
+
+static bool D3D11_HandleDeviceLost(SDL_Renderer *renderer)
+{
+    bool recovered = false;
+
+    D3D11_ReleaseAll(renderer);
+
+    if (SUCCEEDED(D3D11_CreateDeviceResources(renderer)) &&
+        SUCCEEDED(D3D11_CreateWindowSizeDependentResources(renderer))) {
+        recovered = true;
+    } else {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Renderer couldn't recover from device lost: %s", SDL_GetError());
+        D3D11_ReleaseAll(renderer);
+    }
+
+    // Let the application know that the device has been reset or lost
+    SDL_Event event;
+    SDL_zero(event);
+    event.type = recovered ? SDL_EVENT_RENDER_DEVICE_RESET : SDL_EVENT_RENDER_DEVICE_LOST;
+    event.render.windowID = SDL_GetWindowID(SDL_GetRenderWindow(renderer));
+    SDL_PushEvent(&event);
+
+    return recovered;
+}
+
+// This method is called when the window's size changes.
+static HRESULT D3D11_UpdateForWindowSizeChange(SDL_Renderer *renderer)
+{
+    return D3D11_CreateWindowSizeDependentResources(renderer);
+}
+
+static void D3D11_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+
+    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
+        data->pixelSizeChanged = true;
+    }
+}
+
+static bool D3D11_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
+        !GetBlendEquation(colorOperation) ||
+        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
+        !GetBlendEquation(alphaOperation)) {
+        return false;
+    }
+    return true;
+}
+
+static bool GetTextureProperty(SDL_PropertiesID props, const char *name, ID3D11Texture2D **texture)
+{
+    IUnknown *unknown = SDL_GetPointerProperty(props, name, NULL);
+    if (unknown) {
+        HRESULT result = IUnknown_QueryInterface(unknown, &SDL_IID_ID3D11Texture2D, (void **)texture);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(name, result);
+        }
+    }
+    return true;
+}
+
+static bool D3D11_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData;
+    HRESULT result;
+    DXGI_FORMAT textureFormat = SDLPixelFormatToDXGITextureFormat(texture->format, renderer->output_colorspace);
+    D3D11_TEXTURE2D_DESC textureDesc;
+    D3D11_SHADER_RESOURCE_VIEW_DESC resourceViewDesc;
+
+    if (!rendererData->d3dDevice) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if (textureFormat == DXGI_FORMAT_UNKNOWN) {
+        return SDL_SetError("%s, An unsupported SDL pixel format (0x%x) was specified",
+                            __FUNCTION__, texture->format);
+    }
+
+    textureData = (D3D11_TextureData *)SDL_calloc(1, sizeof(*textureData));
+    if (!textureData) {
+        return false;
+    }
+    textureData->scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? D3D11_FILTER_MIN_MAG_MIP_POINT : D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+
+    texture->internal = textureData;
+
+    SDL_zero(textureDesc);
+    textureDesc.Width = texture->w;
+    textureDesc.Height = texture->h;
+    textureDesc.MipLevels = 1;
+    textureDesc.ArraySize = 1;
+    textureDesc.Format = textureFormat;
+    textureDesc.SampleDesc.Count = 1;
+    textureDesc.SampleDesc.Quality = 0;
+    textureDesc.MiscFlags = 0;
+
+    // NV12 textures must have even width and height
+    if (texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21 ||
+        texture->format == SDL_PIXELFORMAT_P010) {
+        textureDesc.Width = (textureDesc.Width + 1) & ~1;
+        textureDesc.Height = (textureDesc.Height + 1) & ~1;
+    }
+    textureData->w = (int)textureDesc.Width;
+    textureData->h = (int)textureDesc.Height;
+    if (SDL_COLORSPACETRANSFER(texture->colorspace) == SDL_TRANSFER_CHARACTERISTICS_SRGB) {
+        textureData->shader = SHADER_RGB;
+    } else {
+        textureData->shader = SHADER_ADVANCED;
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        textureDesc.Usage = D3D11_USAGE_DYNAMIC;
+        textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    } else {
+        textureDesc.Usage = D3D11_USAGE_DEFAULT;
+        textureDesc.CPUAccessFlags = 0;
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
+    } else {
+        textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+    }
+
+    if (!GetTextureProperty(create_props, SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_POINTER, &textureData->mainTexture)) {
+        return false;
+    }
+    if (!textureData->mainTexture) {
+        result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
+                                              &textureDesc,
+                                              NULL,
+                                              &textureData->mainTexture);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
+        }
+    }
+    SDL_SetPointerProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_D3D11_TEXTURE_POINTER, textureData->mainTexture);
+#ifdef SDL_HAVE_YUV
+    if (texture->format == SDL_PIXELFORMAT_YV12 ||
+        texture->format == SDL_PIXELFORMAT_IYUV) {
+        textureData->yuv = true;
+
+        textureDesc.Width = (textureDesc.Width + 1) / 2;
+        textureDesc.Height = (textureDesc.Height + 1) / 2;
+
+        if (!GetTextureProperty(create_props, SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_U_POINTER, &textureData->mainTextureU)) {
+            return false;
+        }
+        if (!textureData->mainTextureU) {
+            result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
+                                                  &textureDesc,
+                                                  NULL,
+                                                  &textureData->mainTextureU);
+            if (FAILED(result)) {
+                return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
+            }
+        }
+        SDL_SetPointerProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_D3D11_TEXTURE_U_POINTER, textureData->mainTextureU);
+
+        if (!GetTextureProperty(create_props, SDL_PROP_TEXTURE_CREATE_D3D11_TEXTURE_V_POINTER, &textureData->mainTextureV)) {
+            return false;
+        }
+        if (!textureData->mainTextureV) {
+            result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
+                                                  &textureDesc,
+                                                  NULL,
+                                                  &textureData->mainTextureV);
+            if (FAILED(result)) {
+                return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D"), result);
+            }
+        }
+        SDL_SetPointerProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_D3D11_TEXTURE_V_POINTER, textureData->mainTextureV);
+
+        textureData->YCbCr_matrix = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8);
+        if (!textureData->YCbCr_matrix) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+    if (texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21 ||
+        texture->format == SDL_PIXELFORMAT_P010) {
+        int bits_per_pixel;
+
+        textureData->nv12 = true;
+
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_P010:
+            bits_per_pixel = 10;
+            break;
+        default:
+            bits_per_pixel = 8;
+            break;
+        }
+        textureData->YCbCr_matrix = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, bits_per_pixel);
+        if (!textureData->YCbCr_matrix) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+#endif // SDL_HAVE_YUV
+    SDL_zero(resourceViewDesc);
+    resourceViewDesc.Format = SDLPixelFormatToDXGIMainResourceViewFormat(texture->format, renderer->output_colorspace);
+    resourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+    resourceViewDesc.Texture2D.MostDetailedMip = 0;
+    resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
+    result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
+                                                   (ID3D11Resource *)textureData->mainTexture,
+                                                   &resourceViewDesc,
+                                                   &textureData->mainTextureResourceView);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv) {
+        result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
+                                                       (ID3D11Resource *)textureData->mainTextureU,
+                                                       &resourceViewDesc,
+                                                       &textureData->mainTextureResourceViewU);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
+        }
+        result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
+                                                       (ID3D11Resource *)textureData->mainTextureV,
+                                                       &resourceViewDesc,
+                                                       &textureData->mainTextureResourceViewV);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
+        }
+    }
+
+    if (textureData->nv12) {
+        D3D11_SHADER_RESOURCE_VIEW_DESC nvResourceViewDesc = resourceViewDesc;
+
+        if (texture->format == SDL_PIXELFORMAT_NV12 || texture->format == SDL_PIXELFORMAT_NV21) {
+            nvResourceViewDesc.Format = DXGI_FORMAT_R8G8_UNORM;
+        } else if (texture->format == SDL_PIXELFORMAT_P010) {
+            nvResourceViewDesc.Format = DXGI_FORMAT_R16G16_UNORM;
+        }
+
+        result = ID3D11Device_CreateShaderResourceView(rendererData->d3dDevice,
+                                                       (ID3D11Resource *)textureData->mainTexture,
+                                                       &nvResourceViewDesc,
+                                                       &textureData->mainTextureResourceViewNV);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateShaderResourceView"), result);
+        }
+    }
+#endif // SDL_HAVE_YUV
+
+    if (texture->access & SDL_TEXTUREACCESS_TARGET) {
+        D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
+        SDL_zero(renderTargetViewDesc);
+        renderTargetViewDesc.Format = textureDesc.Format;
+        renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
+        renderTargetViewDesc.Texture2D.MipSlice = 0;
+
+        result = ID3D11Device_CreateRenderTargetView(rendererData->d3dDevice,
+                                                     (ID3D11Resource *)textureData->mainTexture,
+                                                     &renderTargetViewDesc,
+                                                     &textureData->mainTextureRenderTargetView);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateRenderTargetView"), result);
+        }
+    }
+
+    return true;
+}
+
+static void D3D11_DestroyTexture(SDL_Renderer *renderer,
+                                 SDL_Texture *texture)
+{
+    D3D11_TextureData *data = (D3D11_TextureData *)texture->internal;
+
+    if (!data) {
+        return;
+    }
+
+    SAFE_RELEASE(data->mainTexture);
+    SAFE_RELEASE(data->mainTextureResourceView);
+    SAFE_RELEASE(data->mainTextureRenderTargetView);
+    SAFE_RELEASE(data->stagingTexture);
+#ifdef SDL_HAVE_YUV
+    SAFE_RELEASE(data->mainTextureU);
+    SAFE_RELEASE(data->mainTextureResourceViewU);
+    SAFE_RELEASE(data->mainTextureV);
+    SAFE_RELEASE(data->mainTextureResourceViewV);
+    SAFE_RELEASE(data->mainTextureResourceViewNV);
+    SDL_free(data->pixels);
+#endif
+    SDL_free(data);
+    texture->internal = NULL;
+}
+
+static bool D3D11_UpdateTextureInternal(D3D11_RenderData *rendererData, ID3D11Texture2D *texture, int bpp, int x, int y, int w, int h, const void *pixels, int pitch)
+{
+    ID3D11Texture2D *stagingTexture;
+    const Uint8 *src;
+    Uint8 *dst;
+    int row;
+    UINT length;
+    HRESULT result;
+    D3D11_TEXTURE2D_DESC stagingTextureDesc;
+    D3D11_MAPPED_SUBRESOURCE textureMemory;
+
+    // Create a 'staging' texture, which will be used to write to a portion of the main texture.
+    ID3D11Texture2D_GetDesc(texture, &stagingTextureDesc);
+    stagingTextureDesc.Width = w;
+    stagingTextureDesc.Height = h;
+    stagingTextureDesc.BindFlags = 0;
+    stagingTextureDesc.MiscFlags = 0;
+    stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
+    if (stagingTextureDesc.Format == DXGI_FORMAT_NV12 ||
+        stagingTextureDesc.Format == DXGI_FORMAT_P010) {
+        stagingTextureDesc.Width = (stagingTextureDesc.Width + 1) & ~1;
+        stagingTextureDesc.Height = (stagingTextureDesc.Height + 1) & ~1;
+    }
+    result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
+                                          &stagingTextureDesc,
+                                          NULL,
+                                          &stagingTexture);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
+    }
+
+    // Get a write-only pointer to data in the staging texture:
+    result = ID3D11DeviceContext_Map(rendererData->d3dContext,
+                                     (ID3D11Resource *)stagingTexture,
+                                     0,
+                                     D3D11_MAP_WRITE,
+                                     0,
+                                     &textureMemory);
+    if (FAILED(result)) {
+        SAFE_RELEASE(stagingTexture);
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
+    }
+
+    src = (const Uint8 *)pixels;
+    dst = (Uint8 *)textureMemory.pData;
+    length = w * bpp;
+    if (length == (UINT)pitch && length == textureMemory.RowPitch) {
+        SDL_memcpy(dst, src, (size_t)length * h);
+    } else {
+        if (length > (UINT)pitch) {
+            length = pitch;
+        }
+        if (length > textureMemory.RowPitch) {
+            length = textureMemory.RowPitch;
+        }
+        for (row = 0; row < h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += textureMemory.RowPitch;
+        }
+    }
+
+    if (stagingTextureDesc.Format == DXGI_FORMAT_NV12 ||
+        stagingTextureDesc.Format == DXGI_FORMAT_P010) {
+        // Copy the UV plane as well
+        h = (h + 1) / 2;
+        if (stagingTextureDesc.Format == DXGI_FORMAT_P010) {
+            length = (length + 3) & ~3;
+            pitch = (pitch + 3) & ~3;
+        } else {
+            length = (length + 1) & ~1;
+            pitch = (pitch + 1) & ~1;
+        }
+        dst = (Uint8 *)textureMemory.pData + stagingTextureDesc.Height * textureMemory.RowPitch;
+        for (row = 0; row < h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += textureMemory.RowPitch;
+        }
+    }
+
+    // Commit the pixel buffer's changes back to the staging texture:
+    ID3D11DeviceContext_Unmap(rendererData->d3dContext,
+                              (ID3D11Resource *)stagingTexture,
+                              0);
+
+    // Copy the staging texture's contents back to the texture:
+    ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
+                                              (ID3D11Resource *)texture,
+                                              0,
+                                              x,
+                                              y,
+                                              0,
+                                              (ID3D11Resource *)stagingTexture,
+                                              0,
+                                              NULL);
+
+    SAFE_RELEASE(stagingTexture);
+
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool D3D11_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                 const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch);
+
+static bool D3D11_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch);
+#endif
+
+static bool D3D11_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                               const SDL_Rect *rect, const void *srcPixels,
+                               int srcPitch)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+#ifdef SDL_HAVE_YUV
+    if (textureData->nv12) {
+        const Uint8 *Yplane = (const Uint8 *)srcPixels;
+        const Uint8 *UVplane = Yplane + rect->h * srcPitch;
+
+        return D3D11_UpdateTextureNV(renderer, texture, rect, Yplane, srcPitch, UVplane, srcPitch);
+
+    } else if (textureData->yuv) {
+        int Ypitch = srcPitch;
+        int UVpitch = ((Ypitch + 1) / 2);
+        const Uint8 *Yplane = (const Uint8 *)srcPixels;
+        const Uint8 *Uplane = Yplane + rect->h * Ypitch;
+        const Uint8 *Vplane = Uplane + ((rect->h + 1) / 2) * UVpitch;
+
+        if (texture->format == SDL_PIXELFORMAT_YV12) {
+            return D3D11_UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Vplane, UVpitch, Uplane, UVpitch);
+        } else {
+            return D3D11_UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, UVpitch, Vplane, UVpitch);
+        }
+    }
+#endif
+
+    if (!D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture, SDL_BYTESPERPIXEL(texture->format), rect->x, rect->y, rect->w, rect->h, srcPixels, srcPitch)) {
+        return false;
+    }
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool D3D11_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!D3D11_UpdateTextureInternal(rendererData, textureData->mainTexture, SDL_BYTESPERPIXEL(texture->format), rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch)) {
+        return false;
+    }
+    if (!D3D11_UpdateTextureInternal(rendererData, textureData->mainTextureU, SDL_BYTESPERPIXEL(texture->format), rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Uplane, Upitch)) {
+        return false;
+    }
+    if (!D3D11_UpdateTextureInternal(rendererData, textureData->mainTextureV, SDL_BYTESPERPIXEL(texture->format), rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Vplane, Vpitch)) {
+        return false;
+    }
+    return true;
+}
+
+static bool D3D11_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                 const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+    ID3D11Texture2D *stagingTexture;
+    const Uint8 *src;
+    Uint8 *dst;
+    int w, h, row;
+    UINT length;
+    HRESULT result;
+    D3D11_TEXTURE2D_DESC stagingTextureDesc;
+    D3D11_MAPPED_SUBRESOURCE textureMemory;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    w = rect->w;
+    h = rect->h;
+
+    // Create a 'staging' texture, which will be used to write to a portion of the main texture.
+    ID3D11Texture2D_GetDesc(textureData->mainTexture, &stagingTextureDesc);
+    stagingTextureDesc.Width = w;
+    stagingTextureDesc.Height = h;
+    stagingTextureDesc.BindFlags = 0;
+    stagingTextureDesc.MiscFlags = 0;
+    stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
+    if (stagingTextureDesc.Format == DXGI_FORMAT_NV12 ||
+        stagingTextureDesc.Format == DXGI_FORMAT_P010) {
+        stagingTextureDesc.Width = (stagingTextureDesc.Width + 1) & ~1;
+        stagingTextureDesc.Height = (stagingTextureDesc.Height + 1) & ~1;
+    }
+    result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
+                                          &stagingTextureDesc,
+                                          NULL,
+                                          &stagingTexture);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
+    }
+
+    // Get a write-only pointer to data in the staging texture:
+    result = ID3D11DeviceContext_Map(rendererData->d3dContext,
+                                     (ID3D11Resource *)stagingTexture,
+                                     0,
+                                     D3D11_MAP_WRITE,
+                                     0,
+                                     &textureMemory);
+    if (FAILED(result)) {
+        SAFE_RELEASE(stagingTexture);
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
+    }
+
+    src = Yplane;
+    dst = (Uint8 *)textureMemory.pData;
+    length = w;
+    if (length == (UINT)Ypitch && length == textureMemory.RowPitch) {
+        SDL_memcpy(dst, src, (size_t)length * h);
+    } else {
+        if (length > (UINT)Ypitch) {
+            length = Ypitch;
+        }
+        if (length > textureMemory.RowPitch) {
+            length = textureMemory.RowPitch;
+        }
+        for (row = 0; row < h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += Ypitch;
+            dst += textureMemory.RowPitch;
+        }
+    }
+
+    src = UVplane;
+    length = w;
+    h = (h + 1) / 2;
+    if (stagingTextureDesc.Format == DXGI_FORMAT_P010) {
+        length = (length + 3) & ~3;
+        UVpitch = (UVpitch + 3) & ~3;
+    } else {
+        length = (length + 1) & ~1;
+        UVpitch = (UVpitch + 1) & ~1;
+    }
+    dst = (Uint8 *)textureMemory.pData + stagingTextureDesc.Height * textureMemory.RowPitch;
+    for (row = 0; row < h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += UVpitch;
+        dst += textureMemory.RowPitch;
+    }
+
+    // Commit the pixel buffer's changes back to the staging texture:
+    ID3D11DeviceContext_Unmap(rendererData->d3dContext,
+                              (ID3D11Resource *)stagingTexture,
+                              0);
+
+    // Copy the staging texture's contents back to the texture:
+    ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
+                                              (ID3D11Resource *)textureData->mainTexture,
+                                              0,
+                                              rect->x,
+                                              rect->y,
+                                              0,
+                                              (ID3D11Resource *)stagingTexture,
+                                              0,
+                                              NULL);
+
+    SAFE_RELEASE(stagingTexture);
+
+    return true;
+}
+#endif
+
+static bool D3D11_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+    HRESULT result = S_OK;
+    D3D11_TEXTURE2D_DESC stagingTextureDesc;
+    D3D11_MAPPED_SUBRESOURCE textureMemory;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv || textureData->nv12) {
+        // It's more efficient to upload directly...
+        if (!textureData->pixels) {
+            textureData->pitch = texture->w;
+            textureData->pixels = (Uint8 *)SDL_malloc((texture->h * textureData->pitch * 3) / 2);
+            if (!textureData->pixels) {
+                return false;
+            }
+        }
+        textureData->locked_rect = *rect;
+        *pixels =
+            (void *)(textureData->pixels + rect->y * textureData->pitch +
+                     rect->x * SDL_BYTESPERPIXEL(texture->format));
+        *pitch = textureData->pitch;
+        return true;
+    }
+#endif
+    if (textureData->stagingTexture) {
+        return SDL_SetError("texture is already locked");
+    }
+
+    /* Create a 'staging' texture, which will be used to write to a portion
+     * of the main texture.  This is necessary, as Direct3D 11.1 does not
+     * have the ability to write a CPU-bound pixel buffer to a rectangular
+     * subrect of a texture.  Direct3D 11.1 can, however, write a pixel
+     * buffer to an entire texture, hence the use of a staging texture.
+     */
+    ID3D11Texture2D_GetDesc(textureData->mainTexture, &stagingTextureDesc);
+    stagingTextureDesc.Width = rect->w;
+    stagingTextureDesc.Height = rect->h;
+    stagingTextureDesc.BindFlags = 0;
+    stagingTextureDesc.MiscFlags = 0;
+    stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
+    result = ID3D11Device_CreateTexture2D(rendererData->d3dDevice,
+                                          &stagingTextureDesc,
+                                          NULL,
+                                          &textureData->stagingTexture);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
+    }
+
+    // Get a write-only pointer to data in the staging texture:
+    result = ID3D11DeviceContext_Map(rendererData->d3dContext,
+                                     (ID3D11Resource *)textureData->stagingTexture,
+                                     0,
+                                     D3D11_MAP_WRITE,
+                                     0,
+                                     &textureMemory);
+    if (FAILED(result)) {
+        SAFE_RELEASE(textureData->stagingTexture);
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
+    }
+
+    /* Make note of where the staging texture will be written to
+     * (on a call to SDL_UnlockTexture):
+     */
+    textureData->lockedTexturePositionX = rect->x;
+    textureData->lockedTexturePositionY = rect->y;
+
+    /* Make sure the caller has information on the texture's pixel buffer,
+     * then return:
+     */
+    *pixels = textureMemory.pData;
+    *pitch = textureMemory.RowPitch;
+    return true;
+}
+
+static void D3D11_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv || textureData->nv12) {
+        const SDL_Rect *rect = &textureData->locked_rect;
+        void *pixels =
+            (void *)(textureData->pixels + rect->y * textureData->pitch +
+                     rect->x * SDL_BYTESPERPIXEL(texture->format));
+        D3D11_UpdateTexture(renderer, texture, rect, pixels, textureData->pitch);
+        return;
+    }
+#endif
+    // Commit the pixel buffer's changes back to the staging texture:
+    ID3D11DeviceContext_Unmap(rendererData->d3dContext,
+                              (ID3D11Resource *)textureData->stagingTexture,
+                              0);
+
+    // Copy the staging texture's contents back to the main texture:
+    ID3D11DeviceContext_CopySubresourceRegion(rendererData->d3dContext,
+                                              (ID3D11Resource *)textureData->mainTexture,
+                                              0,
+                                              textureData->lockedTexturePositionX,
+                                              textureData->lockedTexturePositionY,
+                                              0,
+                                              (ID3D11Resource *)textureData->stagingTexture,
+                                              0,
+                                              NULL);
+
+    SAFE_RELEASE(textureData->stagingTexture);
+}
+
+static void D3D11_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+
+    textureData->scaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? D3D11_FILTER_MIN_MAG_MIP_POINT : D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+}
+
+static bool D3D11_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = NULL;
+
+    if (!texture) {
+        rendererData->currentOffscreenRenderTargetView = NULL;
+        return true;
+    }
+
+    textureData = (D3D11_TextureData *)texture->internal;
+
+    if (!textureData->mainTextureRenderTargetView) {
+        return SDL_SetError("specified texture is not a render target");
+    }
+
+    rendererData->currentOffscreenRenderTargetView = textureData->mainTextureRenderTargetView;
+
+    return true;
+}
+
+static bool D3D11_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool D3D11_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    D3D11_VertexPositionColor *verts = (D3D11_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(D3D11_VertexPositionColor), 0, &cmd->data.draw.first);
+    int i;
+    SDL_FColor color = cmd->data.draw.color;
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    if (convert_color) {
+        SDL_ConvertToLinear(&color);
+    }
+
+    for (i = 0; i < count; i++) {
+        verts->pos.x = points[i].x + 0.5f;
+        verts->pos.y = points[i].y + 0.5f;
+        verts->tex.x = 0.0f;
+        verts->tex.y = 0.0f;
+        verts->color = color;
+        verts++;
+    }
+
+    return true;
+}
+
+static bool D3D11_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                               const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                               int num_vertices, const void *indices, int num_indices, int size_indices,
+                               float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    D3D11_VertexPositionColor *verts = (D3D11_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(D3D11_VertexPositionColor), 0, &cmd->data.draw.first);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+    D3D11_TextureData *textureData = texture ? (D3D11_TextureData *)texture->internal : NULL;
+    float u_scale = textureData ? (float)texture->w / textureData->w : 0.0f;
+    float v_scale = textureData ? (float)texture->h / textureData->h : 0.0f;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+
+        verts->pos.x = xy_[0] * scale_x;
+        verts->pos.y = xy_[1] * scale_y;
+        verts->color = *(SDL_FColor *)((char *)color + j * color_stride);
+        if (convert_color) {
+            SDL_ConvertToLinear(&verts->color);
+        }
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            verts->tex.x = uv_[0] * u_scale;
+            verts->tex.y = uv_[1] * v_scale;
+        } else {
+            verts->tex.x = 0.0f;
+            verts->tex.y = 0.0f;
+        }
+
+        verts += 1;
+    }
+    return true;
+}
+
+static bool D3D11_UpdateVertexBuffer(SDL_Renderer *renderer,
+                                    const void *vertexData, size_t dataSizeInBytes)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    HRESULT result = S_OK;
+    const int vbidx = rendererData->currentVertexBuffer;
+    const UINT stride = sizeof(D3D11_VertexPositionColor);
+    const UINT offset = 0;
+
+    if (dataSizeInBytes == 0) {
+        return true; // nothing to do.
+    }
+
+    if (rendererData->vertexBuffers[vbidx] && rendererData->vertexBufferSizes[vbidx] >= dataSizeInBytes) {
+        D3D11_MAPPED_SUBRESOURCE mappedResource;
+        result = ID3D11DeviceContext_Map(rendererData->d3dContext,
+                                         (ID3D11Resource *)rendererData->vertexBuffers[vbidx],
+                                         0,
+                                         D3D11_MAP_WRITE_DISCARD,
+                                         0,
+                                         &mappedResource);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [vertex buffer]"), result);
+        }
+        SDL_memcpy(mappedResource.pData, vertexData, dataSizeInBytes);
+        ID3D11DeviceContext_Unmap(rendererData->d3dContext, (ID3D11Resource *)rendererData->vertexBuffers[vbidx], 0);
+    } else {
+        D3D11_BUFFER_DESC vertexBufferDesc;
+        D3D11_SUBRESOURCE_DATA vertexBufferData;
+
+        SAFE_RELEASE(rendererData->vertexBuffers[vbidx]);
+
+        SDL_zero(vertexBufferDesc);
+        vertexBufferDesc.ByteWidth = (UINT)dataSizeInBytes;
+        vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+        vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+        vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+
+        SDL_zero(vertexBufferData);
+        vertexBufferData.pSysMem = vertexData;
+        vertexBufferData.SysMemPitch = 0;
+        vertexBufferData.SysMemSlicePitch = 0;
+
+        result = ID3D11Device_CreateBuffer(rendererData->d3dDevice,
+                                           &vertexBufferDesc,
+                                           &vertexBufferData,
+                                           &rendererData->vertexBuffers[vbidx]);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateBuffer [vertex buffer]"), result);
+        }
+
+        rendererData->vertexBufferSizes[vbidx] = dataSizeInBytes;
+    }
+
+    ID3D11DeviceContext_IASetVertexBuffers(rendererData->d3dContext,
+                                           0,
+                                           1,
+                                           &rendererData->vertexBuffers[vbidx],
+                                           &stride,
+                                           &offset);
+
+    rendererData->currentVertexBuffer++;
+    if (rendererData->currentVertexBuffer >= SDL_arraysize(rendererData->vertexBuffers)) {
+        rendererData->currentVertexBuffer = 0;
+    }
+
+    return true;
+}
+
+static bool D3D11_UpdateViewport(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    const SDL_Rect *viewport = &data->currentViewport;
+    Float4X4 projection;
+    Float4X4 view;
+    SDL_FRect orientationAlignedViewport;
+    BOOL swapDimensions;
+    D3D11_VIEWPORT d3dviewport;
+    const int rotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
+
+    if (viewport->w == 0 || viewport->h == 0) {
+        /* If the viewport is empty, assume that it is because
+         * SDL_CreateRenderer is calling it, and will call it again later
+         * with a non-empty viewport.
+         */
+        // SDL_Log("%s, no viewport was set!", __FUNCTION__);
+        return false;
+    }
+
+    /* Make sure the SDL viewport gets rotated to that of the physical display's rotation.
+     * Keep in mind here that the Y-axis will be been inverted (from Direct3D's
+     * default coordinate system) so rotations will be done in the opposite
+     * direction of the DXGI_MODE_ROTATION enumeration.
+     */
+    switch (rotation) {
+    case DXGI_MODE_ROTATION_IDENTITY:
+        projection = MatrixIdentity();
+        break;
+    case DXGI_MODE_ROTATION_ROTATE270:
+        projection = MatrixRotationZ(SDL_PI_F * 0.5f);
+        break;
+    case DXGI_MODE_ROTATION_ROTATE180:
+        projection = MatrixRotationZ(SDL_PI_F);
+        break;
+    case DXGI_MODE_ROTATION_ROTATE90:
+        projection = MatrixRotationZ(-SDL_PI_F * 0.5f);
+        break;
+    default:
+        return SDL_SetError("An unknown DisplayOrientation is being used");
+    }
+
+    // Update the view matrix
+    SDL_zero(view);
+    view.m[0][0] = 2.0f / viewport->w;
+    view.m[1][1] = -2.0f / viewport->h;
+    view.m[2][2] = 1.0f;
+    view.m[3][0] = -1.0f;
+    view.m[3][1] = 1.0f;
+    view.m[3][3] = 1.0f;
+
+    /* Combine the projection + view matrix together now, as both only get
+     * set here (as of this writing, on Dec 26, 2013).  When done, store it
+     * for eventual transfer to the GPU.
+     */
+    data->vertexShaderConstantsData.projectionAndView = MatrixMultiply(
+        view,
+        projection);
+
+    /* Update the Direct3D viewport, which seems to be aligned to the
+     * swap buffer's coordinate space, which is always in either
+     * a landscape mode, for all Windows 8/RT devices, or a portrait mode,
+     * for Windows Phone devices.
+     */
+    swapDimensions = D3D11_IsDisplayRotated90Degrees(rotation);
+    if (swapDimensions) {
+        orientationAlignedViewport.x = (float)viewport->y;
+        orientationAlignedViewport.y = (float)viewport->x;
+        orientationAlignedViewport.w = (float)viewport->h;
+        orientationAlignedViewport.h = (float)viewport->w;
+    } else {
+        orientationAlignedViewport.x = (float)viewport->x;
+        orientationAlignedViewport.y = (float)viewport->y;
+        orientationAlignedViewport.w = (float)viewport->w;
+        orientationAlignedViewport.h = (float)viewport->h;
+    }
+
+    d3dviewport.TopLeftX = orientationAlignedViewport.x;
+    d3dviewport.TopLeftY = orientationAlignedViewport.y;
+    d3dviewport.Width = orientationAlignedViewport.w;
+    d3dviewport.Height = orientationAlignedViewport.h;
+    d3dviewport.MinDepth = 0.0f;
+    d3dviewport.MaxDepth = 1.0f;
+    // SDL_Log("%s: D3D viewport = {%f,%f,%f,%f}", __FUNCTION__, d3dviewport.TopLeftX, d3dviewport.TopLeftY, d3dviewport.Width, d3dviewport.Height);
+    ID3D11DeviceContext_RSSetViewports(data->d3dContext, 1, &d3dviewport);
+
+    data->viewportDirty = false;
+
+    return true;
+}
+
+static ID3D11RenderTargetView *D3D11_GetCurrentRenderTargetView(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    if (data->currentOffscreenRenderTargetView) {
+        return data->currentOffscreenRenderTargetView;
+    } else {
+        return data->mainRenderTargetView;
+    }
+}
+
+static void D3D11_SetupShaderConstants(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Texture *texture, D3D11_PixelShaderConstants *constants)
+{
+    float output_headroom;
+
+    SDL_zerop(constants);
+
+    constants->scRGB_output = (float)SDL_RenderingLinearSpace(renderer);
+    constants->color_scale = cmd->data.draw.color_scale;
+
+    if (texture) {
+        D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_YV12:
+        case SDL_PIXELFORMAT_IYUV:
+            constants->texture_type = TEXTURETYPE_YUV;
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_NV12:
+            constants->texture_type = TEXTURETYPE_NV12;
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_NV21:
+            constants->texture_type = TEXTURETYPE_NV21;
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_P010:
+            constants->texture_type = TEXTURETYPE_NV12;
+            constants->input_type = INPUTTYPE_HDR10;
+            break;
+        default:
+            constants->texture_type = TEXTURETYPE_RGB;
+            if (texture->colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+                constants->input_type = INPUTTYPE_SCRGB;
+            } else if (texture->colorspace == SDL_COLORSPACE_HDR10) {
+                constants->input_type = INPUTTYPE_HDR10;
+            } else {
+                // The sampler will convert from sRGB to linear on load if working in linear colorspace
+                constants->input_type = INPUTTYPE_UNSPECIFIED;
+            }
+            break;
+        }
+
+        constants->sdr_white_point = texture->SDR_white_point;
+
+        if (renderer->target) {
+            output_headroom = renderer->target->HDR_headroom;
+        } else {
+            output_headroom = renderer->HDR_headroom;
+        }
+
+        if (texture->HDR_headroom > output_headroom) {
+            constants->tonemap_method = TONEMAP_CHROME;
+            constants->tonemap_factor1 = (output_headroom / (texture->HDR_headroom * texture->HDR_headroom));
+            constants->tonemap_factor2 = (1.0f / output_headroom);
+        }
+
+        if (textureData->YCbCr_matrix) {
+            SDL_memcpy(constants->YCbCr_matrix, textureData->YCbCr_matrix, sizeof(constants->YCbCr_matrix));
+        }
+    }
+}
+
+static bool D3D11_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd,
+                              D3D11_Shader shader, const D3D11_PixelShaderConstants *shader_constants,
+                              const int numShaderResources, ID3D11ShaderResourceView **shaderResources,
+                              ID3D11SamplerState *sampler, const Float4X4 *matrix)
+
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
+    ID3D11RasterizerState *rasterizerState;
+    ID3D11RenderTargetView *renderTargetView = D3D11_GetCurrentRenderTargetView(renderer);
+    ID3D11ShaderResourceView *shaderResource;
+    const SDL_BlendMode blendMode = cmd->data.draw.blend;
+    ID3D11BlendState *blendState = NULL;
+    bool updateSubresource = false;
+    D3D11_PixelShaderState *shader_state = &rendererData->currentShaderState[shader];
+    D3D11_PixelShaderConstants solid_constants;
+
+    if (numShaderResources > 0) {
+        shaderResource = shaderResources[0];
+    } else {
+        shaderResource = NULL;
+    }
+
+    // Make sure the render target isn't bound to a shader
+    if (shaderResource != rendererData->currentShaderResource) {
+        ID3D11ShaderResourceView *pNullResource = NULL;
+        ID3D11DeviceContext_PSSetShaderResources(rendererData->d3dContext, 0, 1, &pNullResource);
+        rendererData->currentShaderResource = NULL;
+    }
+
+    if (renderTargetView != rendererData->currentRenderTargetView) {
+        ID3D11DeviceContext_OMSetRenderTargets(rendererData->d3dContext,
+                                               1,
+                                               &renderTargetView,
+                                               NULL);
+        rendererData->currentRenderTargetView = renderTargetView;
+    }
+
+    if (rendererData->viewportDirty) {
+        if (D3D11_UpdateViewport(renderer)) {
+            // vertexShaderConstantsData.projectionAndView has changed
+            updateSubresource = true;
+        }
+    }
+
+    if (rendererData->cliprectDirty) {
+        if (!rendererData->currentCliprectEnabled) {
+            ID3D11DeviceContext_RSSetScissorRects(rendererData->d3dContext, 0, NULL);
+        } else {
+            D3D11_RECT scissorRect;
+            if (!D3D11_GetViewportAlignedD3DRect(renderer, &rendererData->currentCliprect, &scissorRect, TRUE)) {
+                // D3D11_GetViewportAlignedD3DRect will have set the SDL error
+                return false;
+            }
+            ID3D11DeviceContext_RSSetScissorRects(rendererData->d3dContext, 1, &scissorRect);
+        }
+        rendererData->cliprectDirty = false;
+    }
+
+    if (!rendererData->currentCliprectEnabled) {
+        rasterizerState = rendererData->mainRasterizer;
+    } else {
+        rasterizerState = rendererData->clippedRasterizer;
+    }
+    if (rasterizerState != rendererData->currentRasterizerState) {
+        ID3D11DeviceContext_RSSetState(rendererData->d3dContext, rasterizerState);
+        rendererData->currentRasterizerState = rasterizerState;
+    }
+
+    if (blendMode != SDL_BLENDMODE_NONE) {
+        int i;
+        for (i = 0; i < rendererData->blendModesCount; ++i) {
+            if (blendMode == rendererData->blendModes[i].blendMode) {
+                blendState = rendererData->blendModes[i].blendState;
+                break;
+            }
+        }
+        if (!blendState) {
+            blendState = D3D11_CreateBlendState(renderer, blendMode);
+            if (!blendState) {
+                return false;
+            }
+        }
+    }
+    if (blendState != rendererData->currentBlendState) {
+        ID3D11DeviceContext_OMSetBlendState(rendererData->d3dContext, blendState, 0, 0xFFFFFFFF);
+        rendererData->currentBlendState = blendState;
+    }
+
+    if (!shader_constants) {
+        D3D11_SetupShaderConstants(renderer, cmd, NULL, &solid_constants);
+        shader_constants = &solid_constants;
+    }
+
+    if (!shader_state->constants ||
+        SDL_memcmp(shader_constants, &shader_state->shader_constants, sizeof(*shader_constants)) != 0) {
+        SAFE_RELEASE(shader_state->constants);
+
+        D3D11_BUFFER_DESC desc;
+        SDL_zero(desc);
+        desc.Usage = D3D11_USAGE_DEFAULT;
+        desc.ByteWidth = sizeof(*shader_constants);
+        desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+
+        D3D11_SUBRESOURCE_DATA data;
+        SDL_zero(data);
+        data.pSysMem = shader_constants;
+
+        HRESULT result = ID3D11Device_CreateBuffer(rendererData->d3dDevice, &desc, &data, &shader_state->constants);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device::CreateBuffer [create shader constants]"), result);
+            return false;
+        }
+        SDL_memcpy(&shader_state->shader_constants, shader_constants, sizeof(*shader_constants));
+
+        // Force the shader parameters to be re-set
+        rendererData->currentShader = SHADER_NONE;
+    }
+    if (shader != rendererData->currentShader) {
+        if (!rendererData->pixelShaders[shader]) {
+            if (!D3D11_CreatePixelShader(rendererData->d3dDevice, shader, &rendererData->pixelShaders[shader])) {
+                return false;
+            }
+        }
+        ID3D11DeviceContext_PSSetShader(rendererData->d3dContext, rendererData->pixelShaders[shader], NULL, 0);
+        if (shader_state->constants) {
+            ID3D11DeviceContext_PSSetConstantBuffers(rendererData->d3dContext, 0, 1, &shader_state->constants);
+        }
+        rendererData->currentShader = shader;
+    }
+    if (shaderResource != rendererData->currentShaderResource) {
+        ID3D11DeviceContext_PSSetShaderResources(rendererData->d3dContext, 0, numShaderResources, shaderResources);
+        rendererData->currentShaderResource = shaderResource;
+    }
+    if (sampler != rendererData->currentSampler) {
+        ID3D11DeviceContext_PSSetSamplers(rendererData->d3dContext, 0, 1, &sampler);
+        rendererData->currentSampler = sampler;
+    }
+
+    if (updateSubresource == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
+        SDL_copyp(&rendererData->vertexShaderConstantsData.model, newmatrix);
+        ID3D11DeviceContext_UpdateSubresource(rendererData->d3dContext,
+                                              (ID3D11Resource *)rendererData->vertexShaderConstants,
+                                              0,
+                                              NULL,
+                                              &rendererData->vertexShaderConstantsData,
+                                              0,
+                                              0);
+    }
+
+    return true;
+}
+
+static bool D3D11_SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const Float4X4 *matrix)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    D3D11_TextureData *textureData = (D3D11_TextureData *)texture->internal;
+    ID3D11SamplerState *textureSampler;
+    D3D11_PixelShaderConstants constants;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    D3D11_SetupShaderConstants(renderer, cmd, texture, &constants);
+
+    switch (textureData->scaleMode) {
+    case D3D11_FILTER_MIN_MAG_MIP_POINT:
+        switch (cmd->data.draw.texture_address_mode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            textureSampler = rendererData->samplers[D3D11_SAMPLER_NEAREST_CLAMP];
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            textureSampler = rendererData->samplers[D3D11_SAMPLER_NEAREST_WRAP];
+            break;
+        default:
+            return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+        }
+        break;
+    case D3D11_FILTER_MIN_MAG_MIP_LINEAR:
+        switch (cmd->data.draw.texture_address_mode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            textureSampler = rendererData->samplers[D3D11_SAMPLER_LINEAR_CLAMP];
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            textureSampler = rendererData->samplers[D3D11_SAMPLER_LINEAR_WRAP];
+            break;
+        default:
+            return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+        }
+        break;
+    default:
+        return SDL_SetError("Unknown scale mode: %d", textureData->scaleMode);
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv) {
+        ID3D11ShaderResourceView *shaderResources[3];
+
+        shaderResources[0] = textureData->mainTextureResourceView;
+        shaderResources[1] = textureData->mainTextureResourceViewU;
+        shaderResources[2] = textureData->mainTextureResourceViewV;
+
+        return D3D11_SetDrawState(renderer, cmd, textureData->shader, &constants,
+                                  SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
+
+    } else if (textureData->nv12) {
+        ID3D11ShaderResourceView *shaderResources[2];
+
+        shaderResources[0] = textureData->mainTextureResourceView;
+        shaderResources[1] = textureData->mainTextureResourceViewNV;
+
+        return D3D11_SetDrawState(renderer, cmd, textureData->shader, &constants,
+                                  SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
+    }
+#endif // SDL_HAVE_YUV
+    return D3D11_SetDrawState(renderer, cmd, textureData->shader, &constants,
+                              1, &textureData->mainTextureResourceView, textureSampler, matrix);
+}
+
+static void D3D11_DrawPrimitives(SDL_Renderer *renderer, D3D11_PRIMITIVE_TOPOLOGY primitiveTopology, const size_t vertexStart, const size_t vertexCount)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    ID3D11DeviceContext_IASetPrimitiveTopology(rendererData->d3dContext, primitiveTopology);
+    ID3D11DeviceContext_Draw(rendererData->d3dContext, (UINT)vertexCount, (UINT)vertexStart);
+}
+
+static void D3D11_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    data->currentRenderTargetView = NULL;
+    data->currentRasterizerState = NULL;
+    data->currentBlendState = NULL;
+    data->currentShader = SHADER_NONE;
+    data->currentShaderResource = NULL;
+    data->currentSampler = NULL;
+    data->cliprectDirty = true;
+    data->viewportDirty = true;
+}
+
+static bool D3D11_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    D3D11_RenderData *rendererData = (D3D11_RenderData *)renderer->internal;
+    const int viewportRotation = D3D11_GetRotationForCurrentRenderTarget(renderer);
+
+    if (!rendererData->d3dDevice) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if (rendererData->pixelSizeChanged) {
+        D3D11_UpdateForWindowSizeChange(renderer);
+        rendererData->pixelSizeChanged = false;
+    }
+
+    if (rendererData->currentViewportRotation != viewportRotation) {
+        rendererData->currentViewportRotation = viewportRotation;
+        rendererData->viewportDirty = true;
+    }
+
+    if (!D3D11_UpdateVertexBuffer(renderer, vertices, vertsize)) {
+        return false;
+    }
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            break; // this isn't currently used in this render backend.
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &rendererData->currentViewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                rendererData->viewportDirty = true;
+                rendererData->cliprectDirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
+                rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
+                rendererData->cliprectDirty = true;
+            }
+            if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&rendererData->currentCliprect, rect);
+                rendererData->cliprectDirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            bool convert_color = SDL_RenderingLinearSpace(renderer);
+            SDL_FColor color = cmd->data.color.color;
+            if (convert_color) {
+                SDL_ConvertToLinear(&color);
+            }
+            color.r *= cmd->data.color.color_scale;
+            color.g *= cmd->data.color.color_scale;
+            color.b *= cmd->data.color.color_scale;
+            ID3D11DeviceContext_ClearRenderTargetView(rendererData->d3dContext, D3D11_GetCurrentRenderTargetView(renderer), &color.r);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(D3D11_VertexPositionColor);
+            D3D11_SetDrawState(renderer, cmd, SHADER_SOLID, NULL, 0, NULL, NULL, NULL);
+            D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, start, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(D3D11_VertexPositionColor);
+            const D3D11_VertexPositionColor *verts = (D3D11_VertexPositionColor *)(((Uint8 *)vertices) + first);
+            D3D11_SetDrawState(renderer, cmd, SHADER_SOLID, NULL, 0, NULL, NULL, NULL);
+            D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP, start, count);
+            if (verts[0].pos.x != verts[count - 1].pos.x || verts[0].pos.y != verts[count - 1].pos.y) {
+                D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_POINTLIST, start + (count - 1), 1);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            SDL_Texture *texture = cmd->data.draw.texture;
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(D3D11_VertexPositionColor);
+
+            if (texture) {
+                D3D11_SetCopyState(renderer, cmd, NULL);
+            } else {
+                D3D11_SetDrawState(renderer, cmd, SHADER_SOLID, NULL, 0, NULL, NULL, NULL);
+            }
+
+            D3D11_DrawPrimitives(renderer, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, start, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    return true;
+}
+
+static SDL_Surface *D3D11_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    ID3D11RenderTargetView *renderTargetView = NULL;
+    ID3D11Texture2D *backBuffer = NULL;
+    ID3D11Texture2D *stagingTexture = NULL;
+    HRESULT result;
+    D3D11_TEXTURE2D_DESC stagingTextureDesc;
+    D3D11_RECT srcRect = { 0, 0, 0, 0 };
+    D3D11_BOX srcBox;
+    D3D11_MAPPED_SUBRESOURCE textureMemory;
+    SDL_Surface *output = NULL;
+
+    renderTargetView = D3D11_GetCurrentRenderTargetView(renderer);
+    if (!renderTargetView) {
+        SDL_SetError("%s, ID3D11DeviceContext::OMGetRenderTargets failed", __FUNCTION__);
+        goto done;
+    }
+
+    ID3D11View_GetResource(renderTargetView, (ID3D11Resource **)&backBuffer);
+    if (!backBuffer) {
+        SDL_SetError("%s, ID3D11View::GetResource failed", __FUNCTION__);
+        goto done;
+    }
+
+    // Create a staging texture to copy the screen's data to:
+    ID3D11Texture2D_GetDesc(backBuffer, &stagingTextureDesc);
+    stagingTextureDesc.Width = rect->w;
+    stagingTextureDesc.Height = rect->h;
+    stagingTextureDesc.BindFlags = 0;
+    stagingTextureDesc.MiscFlags = 0;
+    stagingTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+    stagingTextureDesc.Usage = D3D11_USAGE_STAGING;
+    result = ID3D11Device_CreateTexture2D(data->d3dDevice,
+                                          &stagingTextureDesc,
+                                          NULL,
+                                          &stagingTexture);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateTexture2D [create staging texture]"), result);
+        goto done;
+    }
+
+    // Copy the desired portion of the back buffer to the staging texture:
+    if (!D3D11_GetViewportAlignedD3DRect(renderer, rect, &srcRect, FALSE)) {
+        // D3D11_GetViewportAlignedD3DRect will have set the SDL error
+        goto done;
+    }
+
+    srcBox.left = srcRect.left;
+    srcBox.right = srcRect.right;
+    srcBox.top = srcRect.top;
+    srcBox.bottom = srcRect.bottom;
+    srcBox.front = 0;
+    srcBox.back = 1;
+    ID3D11DeviceContext_CopySubresourceRegion(data->d3dContext,
+                                              (ID3D11Resource *)stagingTexture,
+                                              0,
+                                              0, 0, 0,
+                                              (ID3D11Resource *)backBuffer,
+                                              0,
+                                              &srcBox);
+
+    // Map the staging texture's data to CPU-accessible memory:
+    result = ID3D11DeviceContext_Map(data->d3dContext,
+                                     (ID3D11Resource *)stagingTexture,
+                                     0,
+                                     D3D11_MAP_READ,
+                                     0,
+                                     &textureMemory);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11DeviceContext1::Map [map staging texture]"), result);
+        goto done;
+    }
+
+    output = SDL_DuplicatePixels(
+        rect->w, rect->h,
+        D3D11_DXGIFormatToSDLPixelFormat(stagingTextureDesc.Format),
+        renderer->target ? renderer->target->colorspace : renderer->output_colorspace,
+        textureMemory.pData,
+        textureMemory.RowPitch);
+
+    // Unmap the texture:
+    ID3D11DeviceContext_Unmap(data->d3dContext,
+                              (ID3D11Resource *)stagingTexture,
+                              0);
+
+done:
+    SAFE_RELEASE(backBuffer);
+    SAFE_RELEASE(stagingTexture);
+    return output;
+}
+
+static bool D3D11_RenderPresent(SDL_Renderer *renderer)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+    HRESULT result;
+    DXGI_PRESENT_PARAMETERS parameters;
+
+    if (!data->d3dDevice) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    SDL_zero(parameters);
+
+    /* The application may optionally specify "dirty" or "scroll"
+     * rects to improve efficiency in certain scenarios.
+     */
+    result = IDXGISwapChain1_Present1(data->swapChain, data->syncInterval, data->presentFlags, &parameters);
+
+    /* Discard the contents of the render target.
+     * This is a valid operation only when the existing contents will be entirely
+     * overwritten. If dirty or scroll rects are used, this call should be removed.
+     */
+    ID3D11DeviceContext1_DiscardView(data->d3dContext, (ID3D11View *)data->mainRenderTargetView);
+
+    // When the present flips, it unbinds the current view, so bind it again on the next draw call
+    data->currentRenderTargetView = NULL;
+
+    if (FAILED(result) && result != DXGI_ERROR_WAS_STILL_DRAWING) {
+        /* If the device was removed either by a disconnect or a driver upgrade, we
+         * must recreate all device resources.
+         */
+        if (result == DXGI_ERROR_DEVICE_REMOVED) {
+            if (D3D11_HandleDeviceLost(renderer)) {
+                SDL_SetError("Present failed, device lost");
+            } else {
+                // Recovering from device lost failed, error is already set
+            }
+        } else if (result == DXGI_ERROR_INVALID_CALL) {
+            // We probably went through a fullscreen <-> windowed transition
+            D3D11_CreateWindowSizeDependentResources(renderer);
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::Present"), result);
+        } else {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::Present"), result);
+        }
+        return false;
+    }
+    return true;
+}
+
+static bool D3D11_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    D3D11_RenderData *data = (D3D11_RenderData *)renderer->internal;
+
+    if (vsync < 0) {
+        return SDL_Unsupported();
+    }
+
+    if (vsync > 0) {
+        data->syncInterval = vsync;
+        data->presentFlags = 0;
+    } else {
+        data->syncInterval = 0;
+        data->presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
+    }
+    return true;
+}
+
+static bool D3D11_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    D3D11_RenderData *data;
+
+    HWND hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+    if (!hwnd) {
+        return SDL_SetError("Couldn't get window handle");
+    }
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB &&
+        renderer->output_colorspace != SDL_COLORSPACE_SRGB_LINEAR
+        /*&& renderer->output_colorspace != SDL_COLORSPACE_HDR10*/) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (D3D11_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    data->identity = MatrixIdentity();
+
+    renderer->WindowEvent = D3D11_WindowEvent;
+    renderer->SupportsBlendMode = D3D11_SupportsBlendMode;
+    renderer->CreateTexture = D3D11_CreateTexture;
+    renderer->UpdateTexture = D3D11_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = D3D11_UpdateTextureYUV;
+    renderer->UpdateTextureNV = D3D11_UpdateTextureNV;
+#endif
+    renderer->LockTexture = D3D11_LockTexture;
+    renderer->UnlockTexture = D3D11_UnlockTexture;
+    renderer->SetTextureScaleMode = D3D11_SetTextureScaleMode;
+    renderer->SetRenderTarget = D3D11_SetRenderTarget;
+    renderer->QueueSetViewport = D3D11_QueueNoOp;
+    renderer->QueueSetDrawColor = D3D11_QueueNoOp;
+    renderer->QueueDrawPoints = D3D11_QueueDrawPoints;
+    renderer->QueueDrawLines = D3D11_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueGeometry = D3D11_QueueGeometry;
+    renderer->InvalidateCachedState = D3D11_InvalidateCachedState;
+    renderer->RunCommandQueue = D3D11_RunCommandQueue;
+    renderer->RenderReadPixels = D3D11_RenderReadPixels;
+    renderer->RenderPresent = D3D11_RenderPresent;
+    renderer->DestroyTexture = D3D11_DestroyTexture;
+    renderer->DestroyRenderer = D3D11_DestroyRenderer;
+    renderer->SetVSync = D3D11_SetVSync;
+    renderer->internal = data;
+    D3D11_InvalidateCachedState(renderer);
+
+    renderer->name = D3D11_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR2101010);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA64_FLOAT);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_P010);
+
+    data->syncInterval = 0;
+    data->presentFlags = DXGI_PRESENT_DO_NOT_WAIT;
+
+    /* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
+     * order to give init functions access to the underlying window handle:
+     */
+    renderer->window = window;
+
+    // Initialize Direct3D resources
+    if (FAILED(D3D11_CreateDeviceResources(renderer))) {
+        return false;
+    }
+    if (FAILED(D3D11_CreateWindowSizeDependentResources(renderer))) {
+        return false;
+    }
+
+    return true;
+}
+
+SDL_RenderDriver D3D11_RenderDriver = {
+    D3D11_CreateRenderer, "direct3d11"
+};
+
+#endif // SDL_VIDEO_RENDER_D3D11
diff --git a/SDL-3.2.8/src/render/direct3d11/SDL_shaders_d3d11.c b/SDL-3.2.8/src/render/direct3d11/SDL_shaders_d3d11.c
new file mode 100644
index 0000000..18965e2
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/SDL_shaders_d3d11.c
@@ -0,0 +1,116 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_D3D11
+
+#define COBJMACROS
+#include "../../core/windows/SDL_windows.h"
+#include <d3d11_1.h>
+
+#include "SDL_shaders_d3d11.h"
+
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+
+#if SDL_WINAPI_FAMILY_PHONE
+#error Need to build shaders with level_9_3
+#endif
+
+// The shaders here were compiled with compile_shaders.bat
+
+#define g_main D3D11_PixelShader_Colors
+#include "D3D11_PixelShader_Colors.h"
+#undef g_main
+
+#define g_main D3D11_PixelShader_Textures
+#include "D3D11_PixelShader_Textures.h"
+#undef g_main
+
+#define g_main D3D11_PixelShader_Advanced
+#include "D3D11_PixelShader_Advanced.h"
+#undef g_main
+
+#define g_main D3D11_VertexShader
+#include "D3D11_VertexShader.h"
+#undef g_main
+
+
+static struct
+{
+    const void *shader_data;
+    SIZE_T shader_size;
+} D3D11_shaders[] = {
+    { NULL, 0 },
+    { D3D11_PixelShader_Colors, sizeof(D3D11_PixelShader_Colors) },
+    { D3D11_PixelShader_Textures, sizeof(D3D11_PixelShader_Textures) },
+    { D3D11_PixelShader_Advanced, sizeof(D3D11_PixelShader_Advanced) },
+};
+SDL_COMPILE_TIME_ASSERT(D3D11_shaders, SDL_arraysize(D3D11_shaders) == NUM_SHADERS);
+
+bool D3D11_CreateVertexShader(ID3D11Device1 *d3dDevice, ID3D11VertexShader **vertexShader, ID3D11InputLayout **inputLayout)
+{
+    // Declare how the input layout for SDL's vertex shader will be setup:
+    const D3D11_INPUT_ELEMENT_DESC vertexDesc[] = {
+        { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+    };
+    HRESULT result;
+
+    // Load in SDL's one and only vertex shader:
+    result = ID3D11Device_CreateVertexShader(d3dDevice,
+                                             D3D11_VertexShader,
+                                             sizeof(D3D11_VertexShader),
+                                             NULL,
+                                             vertexShader);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateVertexShader"), result);
+    }
+
+    // Create an input layout for SDL's vertex shader:
+    result = ID3D11Device_CreateInputLayout(d3dDevice,
+                                            vertexDesc,
+                                            ARRAYSIZE(vertexDesc),
+                                            D3D11_VertexShader,
+                                            sizeof(D3D11_VertexShader),
+                                            inputLayout);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreateInputLayout"), result);
+    }
+    return true;
+}
+
+bool D3D11_CreatePixelShader(ID3D11Device1 *d3dDevice, D3D11_Shader shader, ID3D11PixelShader **pixelShader)
+{
+    HRESULT result;
+
+    result = ID3D11Device_CreatePixelShader(d3dDevice,
+                                            D3D11_shaders[shader].shader_data,
+                                            D3D11_shaders[shader].shader_size,
+                                            NULL,
+                                            pixelShader);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D11Device1::CreatePixelShader"), result);
+    }
+    return true;
+}
+
+#endif // SDL_VIDEO_RENDER_D3D11
diff --git a/SDL-3.2.8/src/render/direct3d11/SDL_shaders_d3d11.h b/SDL-3.2.8/src/render/direct3d11/SDL_shaders_d3d11.h
new file mode 100644
index 0000000..2279fb0
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/SDL_shaders_d3d11.h
@@ -0,0 +1,35 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// D3D11 shader implementation
+
+typedef enum
+{
+    SHADER_NONE,
+    SHADER_SOLID,
+    SHADER_RGB,
+    SHADER_ADVANCED,
+    NUM_SHADERS
+} D3D11_Shader;
+
+extern bool D3D11_CreateVertexShader(ID3D11Device1 *d3dDevice, ID3D11VertexShader **vertexShader, ID3D11InputLayout **inputLayout);
+extern bool D3D11_CreatePixelShader(ID3D11Device1 *d3dDevice, D3D11_Shader shader, ID3D11PixelShader **pixelShader);
diff --git a/SDL-3.2.8/src/render/direct3d11/compile_shaders.bat b/SDL-3.2.8/src/render/direct3d11/compile_shaders.bat
new file mode 100644
index 0000000..51d2a34
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d11/compile_shaders.bat
@@ -0,0 +1,4 @@
+fxc /T ps_4_0_level_9_1 /Fh D3D11_PixelShader_Colors.h D3D11_PixelShader_Colors.hlsl

+fxc /T ps_4_0_level_9_1 /Fh D3D11_PixelShader_Textures.h D3D11_PixelShader_Textures.hlsl

+fxc /T ps_5_0 /Fh D3D11_PixelShader_Advanced.h D3D11_PixelShader_Advanced.hlsl

+fxc /T vs_4_0_level_9_1 /Fh D3D11_VertexShader.h D3D11_VertexShader.hlsl

diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Advanced.h b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Advanced.h
new file mode 100644
index 0000000..b8f40fe
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Advanced.h
@@ -0,0 +1,1389 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Position              0   xyzw        0      POS   float       
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Target                0   xyzw        0   TARGET   float   xyzw
+;
+; shader hash: f6874446eaee41c102142c02d5bb3ab7
+;
+; Pipeline Runtime Information: 
+;
+; Pixel Shader
+; DepthOutput=0
+; SampleFrequency=0
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Position              0          noperspective       
+; TEXCOORD                 0                 linear       
+; COLOR                    0                 linear       
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Target                0                              
+;
+; Buffer Definitions:
+;
+; cbuffer Constants
+; {
+;
+;   struct Constants
+;   {
+;
+;       float scRGB_output;                           ; Offset:    0
+;       float texture_type;                           ; Offset:    4
+;       float input_type;                             ; Offset:    8
+;       float color_scale;                            ; Offset:   12
+;       float tonemap_method;                         ; Offset:   16
+;       float tonemap_factor1;                        ; Offset:   20
+;       float tonemap_factor2;                        ; Offset:   24
+;       float sdr_white_point;                        ; Offset:   28
+;       float4 Yoffset;                               ; Offset:   32
+;       float4 Rcoeff;                                ; Offset:   48
+;       float4 Gcoeff;                                ; Offset:   64
+;       float4 Bcoeff;                                ; Offset:   80
+;   
+;   } Constants;                                      ; Offset:    0 Size:    96
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; Constants                         cbuffer      NA          NA     CB0            cb1     1
+; sampler0                          sampler      NA          NA      S0             s0     1
+; texture0                          texture     f32          2d      T0             t0     1
+; texture1                          texture     f32          2d      T1             t1     1
+; texture2                          texture     f32          2d      T2             t2     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 12, outputs: 4
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 4, 5, 8 }
+;   output 1 depends on inputs: { 4, 5, 9 }
+;   output 2 depends on inputs: { 4, 5, 10 }
+;   output 3 depends on inputs: { 4, 5, 11 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%dx.types.ResRet.f32 = type { float, float, float, float, i32 }
+%"class.Texture2D<vector<float, 4> >" = type { <4 x float>, %"class.Texture2D<vector<float, 4> >::mips_type" }
+%"class.Texture2D<vector<float, 4> >::mips_type" = type { i32 }
+%Constants = type { float, float, float, float, float, float, float, float, <4 x float>, <4 x float>, <4 x float>, <4 x float> }
+%struct.SamplerState = type { i32 }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 0, i32 2, i32 2, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 0, i32 1, i32 1, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %3 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 0, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %4 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 3, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %5 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 1, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %10 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %11 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %12 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %13 = extractvalue %dx.types.CBufRet.f32 %12, 1
+  %14 = fcmp fast oeq float %13, 0.000000e+00
+  br i1 %14, label %114, label %15
+
+; <label>:15                                      ; preds = %0
+  %16 = fcmp fast oeq float %13, 1.000000e+00
+  br i1 %16, label %17, label %23
+
+; <label>:17                                      ; preds = %15
+  %18 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %3, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %19 = extractvalue %dx.types.ResRet.f32 %18, 0
+  %20 = extractvalue %dx.types.ResRet.f32 %18, 1
+  %21 = extractvalue %dx.types.ResRet.f32 %18, 2
+  %22 = extractvalue %dx.types.ResRet.f32 %18, 3
+  br label %114
+
+; <label>:23                                      ; preds = %15
+  %24 = fcmp fast oeq float %13, 2.000000e+00
+  br i1 %24, label %25, label %53
+
+; <label>:25                                      ; preds = %23
+  %26 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %3, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %27 = extractvalue %dx.types.ResRet.f32 %26, 0
+  %28 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %2, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %29 = extractvalue %dx.types.ResRet.f32 %28, 0
+  %30 = extractvalue %dx.types.ResRet.f32 %28, 1
+  %31 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 2)  ; CBufferLoadLegacy(handle,regIndex)
+  %32 = extractvalue %dx.types.CBufRet.f32 %31, 0
+  %33 = extractvalue %dx.types.CBufRet.f32 %31, 1
+  %34 = extractvalue %dx.types.CBufRet.f32 %31, 2
+  %35 = fadd fast float %32, %27
+  %36 = fadd fast float %33, %29
+  %37 = fadd fast float %34, %30
+  %38 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %39 = extractvalue %dx.types.CBufRet.f32 %38, 0
+  %40 = extractvalue %dx.types.CBufRet.f32 %38, 1
+  %41 = extractvalue %dx.types.CBufRet.f32 %38, 2
+  %42 = call float @dx.op.dot3.f32(i32 55, float %35, float %36, float %37, float %39, float %40, float %41)  ; Dot3(ax,ay,az,bx,by,bz)
+  %43 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %44 = extractvalue %dx.types.CBufRet.f32 %43, 0
+  %45 = extractvalue %dx.types.CBufRet.f32 %43, 1
+  %46 = extractvalue %dx.types.CBufRet.f32 %43, 2
+  %47 = call float @dx.op.dot3.f32(i32 55, float %35, float %36, float %37, float %44, float %45, float %46)  ; Dot3(ax,ay,az,bx,by,bz)
+  %48 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %49 = extractvalue %dx.types.CBufRet.f32 %48, 0
+  %50 = extractvalue %dx.types.CBufRet.f32 %48, 1
+  %51 = extractvalue %dx.types.CBufRet.f32 %48, 2
+  %52 = call float @dx.op.dot3.f32(i32 55, float %35, float %36, float %37, float %49, float %50, float %51)  ; Dot3(ax,ay,az,bx,by,bz)
+  br label %114
+
+; <label>:53                                      ; preds = %23
+  %54 = fcmp fast oeq float %13, 3.000000e+00
+  br i1 %54, label %55, label %83
+
+; <label>:55                                      ; preds = %53
+  %56 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %3, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %57 = extractvalue %dx.types.ResRet.f32 %56, 0
+  %58 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %2, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %59 = extractvalue %dx.types.ResRet.f32 %58, 0
+  %60 = extractvalue %dx.types.ResRet.f32 %58, 1
+  %61 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 2)  ; CBufferLoadLegacy(handle,regIndex)
+  %62 = extractvalue %dx.types.CBufRet.f32 %61, 0
+  %63 = extractvalue %dx.types.CBufRet.f32 %61, 1
+  %64 = extractvalue %dx.types.CBufRet.f32 %61, 2
+  %65 = fadd fast float %62, %57
+  %66 = fadd fast float %63, %60
+  %67 = fadd fast float %64, %59
+  %68 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %69 = extractvalue %dx.types.CBufRet.f32 %68, 0
+  %70 = extractvalue %dx.types.CBufRet.f32 %68, 1
+  %71 = extractvalue %dx.types.CBufRet.f32 %68, 2
+  %72 = call float @dx.op.dot3.f32(i32 55, float %65, float %66, float %67, float %69, float %70, float %71)  ; Dot3(ax,ay,az,bx,by,bz)
+  %73 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %74 = extractvalue %dx.types.CBufRet.f32 %73, 0
+  %75 = extractvalue %dx.types.CBufRet.f32 %73, 1
+  %76 = extractvalue %dx.types.CBufRet.f32 %73, 2
+  %77 = call float @dx.op.dot3.f32(i32 55, float %65, float %66, float %67, float %74, float %75, float %76)  ; Dot3(ax,ay,az,bx,by,bz)
+  %78 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %79 = extractvalue %dx.types.CBufRet.f32 %78, 0
+  %80 = extractvalue %dx.types.CBufRet.f32 %78, 1
+  %81 = extractvalue %dx.types.CBufRet.f32 %78, 2
+  %82 = call float @dx.op.dot3.f32(i32 55, float %65, float %66, float %67, float %79, float %80, float %81)  ; Dot3(ax,ay,az,bx,by,bz)
+  br label %114
+
+; <label>:83                                      ; preds = %53
+  %84 = fcmp fast oeq float %13, 4.000000e+00
+  br i1 %84, label %85, label %114
+
+; <label>:85                                      ; preds = %83
+  %86 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %3, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %87 = extractvalue %dx.types.ResRet.f32 %86, 0
+  %88 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %2, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %89 = extractvalue %dx.types.ResRet.f32 %88, 0
+  %90 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %1, %dx.types.Handle %4, float %10, float %11, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %91 = extractvalue %dx.types.ResRet.f32 %90, 0
+  %92 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 2)  ; CBufferLoadLegacy(handle,regIndex)
+  %93 = extractvalue %dx.types.CBufRet.f32 %92, 0
+  %94 = extractvalue %dx.types.CBufRet.f32 %92, 1
+  %95 = extractvalue %dx.types.CBufRet.f32 %92, 2
+  %96 = fadd fast float %93, %87
+  %97 = fadd fast float %94, %89
+  %98 = fadd fast float %95, %91
+  %99 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %100 = extractvalue %dx.types.CBufRet.f32 %99, 0
+  %101 = extractvalue %dx.types.CBufRet.f32 %99, 1
+  %102 = extractvalue %dx.types.CBufRet.f32 %99, 2
+  %103 = call float @dx.op.dot3.f32(i32 55, float %96, float %97, float %98, float %100, float %101, float %102)  ; Dot3(ax,ay,az,bx,by,bz)
+  %104 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %105 = extractvalue %dx.types.CBufRet.f32 %104, 0
+  %106 = extractvalue %dx.types.CBufRet.f32 %104, 1
+  %107 = extractvalue %dx.types.CBufRet.f32 %104, 2
+  %108 = call float @dx.op.dot3.f32(i32 55, float %96, float %97, float %98, float %105, float %106, float %107)  ; Dot3(ax,ay,az,bx,by,bz)
+  %109 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %110 = extractvalue %dx.types.CBufRet.f32 %109, 0
+  %111 = extractvalue %dx.types.CBufRet.f32 %109, 1
+  %112 = extractvalue %dx.types.CBufRet.f32 %109, 2
+  %113 = call float @dx.op.dot3.f32(i32 55, float %96, float %97, float %98, float %110, float %111, float %112)  ; Dot3(ax,ay,az,bx,by,bz)
+  br label %114
+
+; <label>:114                                     ; preds = %85, %83, %55, %25, %17, %0
+  %115 = phi float [ %19, %17 ], [ %42, %25 ], [ %72, %55 ], [ %103, %85 ], [ 1.000000e+00, %0 ], [ 1.000000e+00, %83 ]
+  %116 = phi float [ %20, %17 ], [ %47, %25 ], [ %77, %55 ], [ %108, %85 ], [ 1.000000e+00, %0 ], [ 0.000000e+00, %83 ]
+  %117 = phi float [ %21, %17 ], [ %52, %25 ], [ %82, %55 ], [ %113, %85 ], [ 1.000000e+00, %0 ], [ 0.000000e+00, %83 ]
+  %118 = phi float [ %22, %17 ], [ 1.000000e+00, %25 ], [ 1.000000e+00, %55 ], [ 1.000000e+00, %85 ], [ 1.000000e+00, %0 ], [ 1.000000e+00, %83 ]
+  %119 = extractvalue %dx.types.CBufRet.f32 %12, 2
+  %120 = fcmp fast oeq float %119, 3.000000e+00
+  br i1 %120, label %121, label %169
+
+; <label>:121                                     ; preds = %114
+  %122 = call float @dx.op.unary.f32(i32 6, float %115)  ; FAbs(value)
+  %123 = call float @dx.op.unary.f32(i32 6, float %116)  ; FAbs(value)
+  %124 = call float @dx.op.unary.f32(i32 6, float %117)  ; FAbs(value)
+  %125 = call float @dx.op.unary.f32(i32 23, float %122)  ; Log(value)
+  %126 = call float @dx.op.unary.f32(i32 23, float %123)  ; Log(value)
+  %127 = call float @dx.op.unary.f32(i32 23, float %124)  ; Log(value)
+  %128 = fmul fast float %125, 0x3F89F9B580000000
+  %129 = fmul fast float %126, 0x3F89F9B580000000
+  %130 = fmul fast float %127, 0x3F89F9B580000000
+  %131 = call float @dx.op.unary.f32(i32 21, float %128)  ; Exp(value)
+  %132 = call float @dx.op.unary.f32(i32 21, float %129)  ; Exp(value)
+  %133 = call float @dx.op.unary.f32(i32 21, float %130)  ; Exp(value)
+  %134 = fadd fast float %131, -8.359375e-01
+  %135 = fadd fast float %132, -8.359375e-01
+  %136 = fadd fast float %133, -8.359375e-01
+  %137 = call float @dx.op.binary.f32(i32 35, float %134, float 0.000000e+00)  ; FMax(a,b)
+  %138 = call float @dx.op.binary.f32(i32 35, float %135, float 0.000000e+00)  ; FMax(a,b)
+  %139 = call float @dx.op.binary.f32(i32 35, float %136, float 0.000000e+00)  ; FMax(a,b)
+  %140 = fmul fast float %131, 1.868750e+01
+  %141 = fmul fast float %132, 1.868750e+01
+  %142 = fmul fast float %133, 1.868750e+01
+  %143 = fsub fast float 0x4032DA0000000000, %140
+  %144 = fsub fast float 0x4032DA0000000000, %141
+  %145 = fsub fast float 0x4032DA0000000000, %142
+  %146 = fdiv fast float %137, %143
+  %147 = fdiv fast float %138, %144
+  %148 = fdiv fast float %139, %145
+  %149 = call float @dx.op.unary.f32(i32 6, float %146)  ; FAbs(value)
+  %150 = call float @dx.op.unary.f32(i32 6, float %147)  ; FAbs(value)
+  %151 = call float @dx.op.unary.f32(i32 6, float %148)  ; FAbs(value)
+  %152 = call float @dx.op.unary.f32(i32 23, float %149)  ; Log(value)
+  %153 = call float @dx.op.unary.f32(i32 23, float %150)  ; Log(value)
+  %154 = call float @dx.op.unary.f32(i32 23, float %151)  ; Log(value)
+  %155 = fmul fast float %152, 0x40191C0D60000000
+  %156 = fmul fast float %153, 0x40191C0D60000000
+  %157 = fmul fast float %154, 0x40191C0D60000000
+  %158 = call float @dx.op.unary.f32(i32 21, float %155)  ; Exp(value)
+  %159 = call float @dx.op.unary.f32(i32 21, float %156)  ; Exp(value)
+  %160 = call float @dx.op.unary.f32(i32 21, float %157)  ; Exp(value)
+  %161 = fmul fast float %158, 1.000000e+04
+  %162 = fmul fast float %159, 1.000000e+04
+  %163 = fmul fast float %160, 1.000000e+04
+  %164 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %165 = extractvalue %dx.types.CBufRet.f32 %164, 3
+  %166 = fdiv fast float %161, %165
+  %167 = fdiv fast float %162, %165
+  %168 = fdiv fast float %163, %165
+  br label %169
+
+; <label>:169                                     ; preds = %121, %114
+  %170 = phi float [ %166, %121 ], [ %115, %114 ]
+  %171 = phi float [ %167, %121 ], [ %116, %114 ]
+  %172 = phi float [ %168, %121 ], [ %117, %114 ]
+  %173 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %5, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %174 = extractvalue %dx.types.CBufRet.f32 %173, 0
+  %175 = fcmp fast une float %174, 0.000000e+00
+  br i1 %175, label %176, label %229
+
+; <label>:176                                     ; preds = %169
+  %177 = fcmp fast oeq float %174, 1.000000e+00
+  br i1 %177, label %178, label %183
+
+; <label>:178                                     ; preds = %176
+  %179 = extractvalue %dx.types.CBufRet.f32 %173, 1
+  %180 = fmul fast float %179, %170
+  %181 = fmul fast float %179, %171
+  %182 = fmul fast float %179, %172
+  br label %229
+
+; <label>:183                                     ; preds = %176
+  %184 = fcmp fast oeq float %174, 2.000000e+00
+  br i1 %184, label %185, label %229
+
+; <label>:185                                     ; preds = %183
+  %186 = fcmp fast oeq float %119, 2.000000e+00
+  br i1 %186, label %187, label %197
+
+; <label>:187                                     ; preds = %185
+  %188 = fmul fast float %170, 0x3FE413B180000000
+  %189 = call float @dx.op.tertiary.f32(i32 46, float 0x3FD512F900000000, float %171, float %188)  ; FMad(a,b,c)
+  %190 = call float @dx.op.tertiary.f32(i32 46, float 0x3FA62D1F20000000, float %172, float %189)  ; FMad(a,b,c)
+  %191 = fmul fast float %170, 0x3FB1B05740000000
+  %192 = call float @dx.op.tertiary.f32(i32 46, float 0x3FED6CE140000000, float %171, float %191)  ; FMad(a,b,c)
+  %193 = call float @dx.op.tertiary.f32(i32 46, float 0x3F8744F5E0000000, float %172, float %192)  ; FMad(a,b,c)
+  %194 = fmul fast float %170, 0x3F90C8CD60000000
+  %195 = call float @dx.op.tertiary.f32(i32 46, float 0x3FB6880520000000, float %171, float %194)  ; FMad(a,b,c)
+  %196 = call float @dx.op.tertiary.f32(i32 46, float 0x3FECA8B6E0000000, float %172, float %195)  ; FMad(a,b,c)
+  br label %197
+
+; <label>:197                                     ; preds = %187, %185
+  %198 = phi float [ %190, %187 ], [ %170, %185 ]
+  %199 = phi float [ %193, %187 ], [ %171, %185 ]
+  %200 = phi float [ %196, %187 ], [ %172, %185 ]
+  %201 = call float @dx.op.binary.f32(i32 35, float %199, float %200)  ; FMax(a,b)
+  %202 = call float @dx.op.binary.f32(i32 35, float %198, float %201)  ; FMax(a,b)
+  %203 = fcmp fast ogt float %202, 0.000000e+00
+  br i1 %203, label %204, label %215
+
+; <label>:204                                     ; preds = %197
+  %205 = extractvalue %dx.types.CBufRet.f32 %173, 1
+  %206 = fmul fast float %205, %202
+  %207 = fadd fast float %206, 1.000000e+00
+  %208 = extractvalue %dx.types.CBufRet.f32 %173, 2
+  %209 = fmul fast float %208, %202
+  %210 = fadd fast float %209, 1.000000e+00
+  %211 = fdiv fast float %207, %210
+  %212 = fmul fast float %211, %198
+  %213 = fmul fast float %211, %199
+  %214 = fmul fast float %211, %200
+  br label %215
+
+; <label>:215                                     ; preds = %204, %197
+  %216 = phi float [ %212, %204 ], [ %198, %197 ]
+  %217 = phi float [ %213, %204 ], [ %199, %197 ]
+  %218 = phi float [ %214, %204 ], [ %200, %197 ]
+  br i1 %186, label %219, label %229
+
+; <label>:219                                     ; preds = %215
+  %220 = fmul fast float %216, 0x3FFA916440000000
+  %221 = call float @dx.op.tertiary.f32(i32 46, float 0xBFE2CE1400000000, float %217, float %220)  ; FMad(a,b,c)
+  %222 = call float @dx.op.tertiary.f32(i32 46, float 0xBFB2A5A460000000, float %218, float %221)  ; FMad(a,b,c)
+  %223 = fmul fast float %216, 0xBFBFE24FE0000000
+  %224 = call float @dx.op.tertiary.f32(i32 46, float 0x3FF2205680000000, float %217, float %223)  ; FMad(a,b,c)
+  %225 = call float @dx.op.tertiary.f32(i32 46, float 0xBF8118C1A0000000, float %218, float %224)  ; FMad(a,b,c)
+  %226 = fmul fast float %216, 0xBF9296F660000000
+  %227 = call float @dx.op.tertiary.f32(i32 46, float 0xBFB9C0B9A0000000, float %217, float %226)  ; FMad(a,b,c)
+  %228 = call float @dx.op.tertiary.f32(i32 46, float 0x3FF1E66780000000, float %218, float %227)  ; FMad(a,b,c)
+  br label %229
+
+; <label>:229                                     ; preds = %219, %215, %183, %178, %169
+  %230 = phi float [ %170, %169 ], [ %180, %178 ], [ %222, %219 ], [ %216, %215 ], [ %170, %183 ]
+  %231 = phi float [ %171, %169 ], [ %181, %178 ], [ %225, %219 ], [ %217, %215 ], [ %171, %183 ]
+  %232 = phi float [ %172, %169 ], [ %182, %178 ], [ %228, %219 ], [ %218, %215 ], [ %172, %183 ]
+  %233 = fcmp fast oeq float %119, 1.000000e+00
+  br i1 %233, label %234, label %280
+
+; <label>:234                                     ; preds = %229
+  %235 = extractvalue %dx.types.CBufRet.f32 %12, 0
+  %236 = fcmp fast une float %235, 0.000000e+00
+  br i1 %236, label %237, label %272
+
+; <label>:237                                     ; preds = %234
+  %238 = fcmp fast ugt float %230, 0x3FA4B5DCC0000000
+  br i1 %238, label %241, label %239
+
+; <label>:239                                     ; preds = %237
+  %240 = fmul fast float %230, 0x3FB3D07220000000
+  br label %248
+
+; <label>:241                                     ; preds = %237
+  %242 = fadd fast float %230, 0x3FAC28F5C0000000
+  %243 = call float @dx.op.unary.f32(i32 6, float %242)  ; FAbs(value)
+  %244 = fmul fast float %243, 0x3FEE54EDE0000000
+  %245 = call float @dx.op.unary.f32(i32 23, float %244)  ; Log(value)
+  %246 = fmul fast float %245, 0x4003333340000000
+  %247 = call float @dx.op.unary.f32(i32 21, float %246)  ; Exp(value)
+  br label %248
+
+; <label>:248                                     ; preds = %241, %239
+  %249 = phi float [ %240, %239 ], [ %247, %241 ]
+  %250 = fcmp fast ugt float %231, 0x3FA4B5DCC0000000
+  br i1 %250, label %253, label %251
+
+; <label>:251                                     ; preds = %248
+  %252 = fmul fast float %231, 0x3FB3D07220000000
+  br label %260
+
+; <label>:253                                     ; preds = %248
+  %254 = fadd fast float %231, 0x3FAC28F5C0000000
+  %255 = call float @dx.op.unary.f32(i32 6, float %254)  ; FAbs(value)
+  %256 = fmul fast float %255, 0x3FEE54EDE0000000
+  %257 = call float @dx.op.unary.f32(i32 23, float %256)  ; Log(value)
+  %258 = fmul fast float %257, 0x4003333340000000
+  %259 = call float @dx.op.unary.f32(i32 21, float %258)  ; Exp(value)
+  br label %260
+
+; <label>:260                                     ; preds = %253, %251
+  %261 = phi float [ %252, %251 ], [ %259, %253 ]
+  %262 = fcmp fast ugt float %232, 0x3FA4B5DCC0000000
+  br i1 %262, label %265, label %263
+
+; <label>:263                                     ; preds = %260
+  %264 = fmul fast float %232, 0x3FB3D07220000000
+  br label %272
+
+; <label>:265                                     ; preds = %260
+  %266 = fadd fast float %232, 0x3FAC28F5C0000000
+  %267 = call float @dx.op.unary.f32(i32 6, float %266)  ; FAbs(value)
+  %268 = fmul fast float %267, 0x3FEE54EDE0000000
+  %269 = call float @dx.op.unary.f32(i32 23, float %268)  ; Log(value)
+  %270 = fmul fast float %269, 0x4003333340000000
+  %271 = call float @dx.op.unary.f32(i32 21, float %270)  ; Exp(value)
+  br label %272
+
+; <label>:272                                     ; preds = %265, %263, %234
+  %273 = phi float [ %230, %234 ], [ %249, %265 ], [ %249, %263 ]
+  %274 = phi float [ %231, %234 ], [ %261, %265 ], [ %261, %263 ]
+  %275 = phi float [ %232, %234 ], [ %271, %265 ], [ %264, %263 ]
+  %276 = extractvalue %dx.types.CBufRet.f32 %12, 3
+  %277 = fmul fast float %276, %273
+  %278 = fmul fast float %276, %274
+  %279 = fmul fast float %276, %275
+  br label %389
+
+; <label>:280                                     ; preds = %229
+  %281 = fcmp fast oeq float %119, 2.000000e+00
+  %282 = extractvalue %dx.types.CBufRet.f32 %12, 3
+  br i1 %281, label %283, label %329
+
+; <label>:283                                     ; preds = %280
+  %284 = fmul fast float %282, %230
+  %285 = fmul fast float %282, %231
+  %286 = fmul fast float %282, %232
+  %287 = extractvalue %dx.types.CBufRet.f32 %12, 0
+  %288 = fcmp fast une float %287, 0.000000e+00
+  br i1 %288, label %389, label %289
+
+; <label>:289                                     ; preds = %283
+  %290 = fcmp fast ugt float %284, 0x3F69A5C380000000
+  br i1 %290, label %293, label %291
+
+; <label>:291                                     ; preds = %289
+  %292 = fmul fast float %284, 0x4029D70A40000000
+  br label %300
+
+; <label>:293                                     ; preds = %289
+  %294 = call float @dx.op.unary.f32(i32 6, float %284)  ; FAbs(value)
+  %295 = call float @dx.op.unary.f32(i32 23, float %294)  ; Log(value)
+  %296 = fmul fast float %295, 0x3FDAAAAAA0000000
+  %297 = call float @dx.op.unary.f32(i32 21, float %296)  ; Exp(value)
+  %298 = fmul fast float %297, 0x3FF0E147A0000000
+  %299 = fadd fast float %298, 0xBFAC28F5C0000000
+  br label %300
+
+; <label>:300                                     ; preds = %293, %291
+  %301 = phi float [ %292, %291 ], [ %299, %293 ]
+  %302 = fcmp fast ugt float %285, 0x3F69A5C380000000
+  br i1 %302, label %305, label %303
+
+; <label>:303                                     ; preds = %300
+  %304 = fmul fast float %285, 0x4029D70A40000000
+  br label %312
+
+; <label>:305                                     ; preds = %300
+  %306 = call float @dx.op.unary.f32(i32 6, float %285)  ; FAbs(value)
+  %307 = call float @dx.op.unary.f32(i32 23, float %306)  ; Log(value)
+  %308 = fmul fast float %307, 0x3FDAAAAAA0000000
+  %309 = call float @dx.op.unary.f32(i32 21, float %308)  ; Exp(value)
+  %310 = fmul fast float %309, 0x3FF0E147A0000000
+  %311 = fadd fast float %310, 0xBFAC28F5C0000000
+  br label %312
+
+; <label>:312                                     ; preds = %305, %303
+  %313 = phi float [ %304, %303 ], [ %311, %305 ]
+  %314 = fcmp fast ugt float %286, 0x3F69A5C380000000
+  br i1 %314, label %317, label %315
+
+; <label>:315                                     ; preds = %312
+  %316 = fmul fast float %286, 0x4029D70A40000000
+  br label %324
+
+; <label>:317                                     ; preds = %312
+  %318 = call float @dx.op.unary.f32(i32 6, float %286)  ; FAbs(value)
+  %319 = call float @dx.op.unary.f32(i32 23, float %318)  ; Log(value)
+  %320 = fmul fast float %319, 0x3FDAAAAAA0000000
+  %321 = call float @dx.op.unary.f32(i32 21, float %320)  ; Exp(value)
+  %322 = fmul fast float %321, 0x3FF0E147A0000000
+  %323 = fadd fast float %322, 0xBFAC28F5C0000000
+  br label %324
+
+; <label>:324                                     ; preds = %317, %315
+  %325 = phi float [ %316, %315 ], [ %323, %317 ]
+  %326 = call float @dx.op.unary.f32(i32 7, float %301)  ; Saturate(value)
+  %327 = call float @dx.op.unary.f32(i32 7, float %313)  ; Saturate(value)
+  %328 = call float @dx.op.unary.f32(i32 7, float %325)  ; Saturate(value)
+  br label %389
+
+; <label>:329                                     ; preds = %280
+  br i1 %120, label %330, label %385
+
+; <label>:330                                     ; preds = %329
+  %331 = fmul fast float %230, 0x3FFA916440000000
+  %332 = call float @dx.op.tertiary.f32(i32 46, float 0xBFE2CE1400000000, float %231, float %331)  ; FMad(a,b,c)
+  %333 = call float @dx.op.tertiary.f32(i32 46, float 0xBFB2A5A460000000, float %232, float %332)  ; FMad(a,b,c)
+  %334 = fmul fast float %230, 0xBFBFE24FE0000000
+  %335 = call float @dx.op.tertiary.f32(i32 46, float 0x3FF2205680000000, float %231, float %334)  ; FMad(a,b,c)
+  %336 = call float @dx.op.tertiary.f32(i32 46, float 0xBF8118C1A0000000, float %232, float %335)  ; FMad(a,b,c)
+  %337 = fmul fast float %230, 0xBF9296F660000000
+  %338 = call float @dx.op.tertiary.f32(i32 46, float 0xBFB9C0B9A0000000, float %231, float %337)  ; FMad(a,b,c)
+  %339 = call float @dx.op.tertiary.f32(i32 46, float 0x3FF1E66780000000, float %232, float %338)  ; FMad(a,b,c)
+  %340 = fmul fast float %282, %333
+  %341 = fmul fast float %282, %336
+  %342 = fmul fast float %282, %339
+  %343 = extractvalue %dx.types.CBufRet.f32 %12, 0
+  %344 = fcmp fast une float %343, 0.000000e+00
+  br i1 %344, label %389, label %345
+
+; <label>:345                                     ; preds = %330
+  %346 = fcmp fast ugt float %340, 0x3F69A5C380000000
+  br i1 %346, label %349, label %347
+
+; <label>:347                                     ; preds = %345
+  %348 = fmul fast float %340, 0x4029D70A40000000
+  br label %356
+
+; <label>:349                                     ; preds = %345
+  %350 = call float @dx.op.unary.f32(i32 6, float %340)  ; FAbs(value)
+  %351 = call float @dx.op.unary.f32(i32 23, float %350)  ; Log(value)
+  %352 = fmul fast float %351, 0x3FDAAAAAA0000000
+  %353 = call float @dx.op.unary.f32(i32 21, float %352)  ; Exp(value)
+  %354 = fmul fast float %353, 0x3FF0E147A0000000
+  %355 = fadd fast float %354, 0xBFAC28F5C0000000
+  br label %356
+
+; <label>:356                                     ; preds = %349, %347
+  %357 = phi float [ %348, %347 ], [ %355, %349 ]
+  %358 = fcmp fast ugt float %341, 0x3F69A5C380000000
+  br i1 %358, label %361, label %359
+
+; <label>:359                                     ; preds = %356
+  %360 = fmul fast float %341, 0x4029D70A40000000
+  br label %368
+
+; <label>:361                                     ; preds = %356
+  %362 = call float @dx.op.unary.f32(i32 6, float %341)  ; FAbs(value)
+  %363 = call float @dx.op.unary.f32(i32 23, float %362)  ; Log(value)
+  %364 = fmul fast float %363, 0x3FDAAAAAA0000000
+  %365 = call float @dx.op.unary.f32(i32 21, float %364)  ; Exp(value)
+  %366 = fmul fast float %365, 0x3FF0E147A0000000
+  %367 = fadd fast float %366, 0xBFAC28F5C0000000
+  br label %368
+
+; <label>:368                                     ; preds = %361, %359
+  %369 = phi float [ %360, %359 ], [ %367, %361 ]
+  %370 = fcmp fast ugt float %342, 0x3F69A5C380000000
+  br i1 %370, label %373, label %371
+
+; <label>:371                                     ; preds = %368
+  %372 = fmul fast float %342, 0x4029D70A40000000
+  br label %380
+
+; <label>:373                                     ; preds = %368
+  %374 = call float @dx.op.unary.f32(i32 6, float %342)  ; FAbs(value)
+  %375 = call float @dx.op.unary.f32(i32 23, float %374)  ; Log(value)
+  %376 = fmul fast float %375, 0x3FDAAAAAA0000000
+  %377 = call float @dx.op.unary.f32(i32 21, float %376)  ; Exp(value)
+  %378 = fmul fast float %377, 0x3FF0E147A0000000
+  %379 = fadd fast float %378, 0xBFAC28F5C0000000
+  br label %380
+
+; <label>:380                                     ; preds = %373, %371
+  %381 = phi float [ %372, %371 ], [ %379, %373 ]
+  %382 = call float @dx.op.unary.f32(i32 7, float %357)  ; Saturate(value)
+  %383 = call float @dx.op.unary.f32(i32 7, float %369)  ; Saturate(value)
+  %384 = call float @dx.op.unary.f32(i32 7, float %381)  ; Saturate(value)
+  br label %389
+
+; <label>:385                                     ; preds = %329
+  %386 = fmul fast float %282, %230
+  %387 = fmul fast float %282, %231
+  %388 = fmul fast float %282, %232
+  br label %389
+
+; <label>:389                                     ; preds = %385, %380, %330, %324, %283, %272
+  %390 = phi float [ %277, %272 ], [ %386, %385 ], [ %284, %283 ], [ %326, %324 ], [ %340, %330 ], [ %382, %380 ]
+  %391 = phi float [ %278, %272 ], [ %387, %385 ], [ %285, %283 ], [ %327, %324 ], [ %341, %330 ], [ %383, %380 ]
+  %392 = phi float [ %279, %272 ], [ %388, %385 ], [ %286, %283 ], [ %328, %324 ], [ %342, %330 ], [ %384, %380 ]
+  %393 = fmul fast float %390, %6
+  %394 = fmul fast float %391, %7
+  %395 = fmul fast float %392, %8
+  %396 = fmul fast float %118, %9
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %393)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %394)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %395)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %396)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.ResRet.f32 @dx.op.sample.f32(i32, %dx.types.Handle, %dx.types.Handle, float, float, float, float, i32, i32, i32, float) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.dot3.f32(i32, float, float, float, float, float, float) #0
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.unary.f32(i32, float) #0
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.binary.f32(i32, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!14}
+!dx.entryPoints = !{!15}
+
+!0 = !{!"clang version 3.7 (tags/RELEASE_370/final)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 6}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{!5, null, !10, !12}
+!5 = !{!6, !8, !9}
+!6 = !{i32 0, %"class.Texture2D<vector<float, 4> >"* undef, !"", i32 0, i32 0, i32 1, i32 2, i32 0, !7}
+!7 = !{i32 0, i32 9}
+!8 = !{i32 1, %"class.Texture2D<vector<float, 4> >"* undef, !"", i32 0, i32 1, i32 1, i32 2, i32 0, !7}
+!9 = !{i32 2, %"class.Texture2D<vector<float, 4> >"* undef, !"", i32 0, i32 2, i32 1, i32 2, i32 0, !7}
+!10 = !{!11}
+!11 = !{i32 0, %Constants* undef, !"", i32 0, i32 1, i32 1, i32 96, null}
+!12 = !{!13}
+!13 = !{i32 0, %struct.SamplerState* undef, !"", i32 0, i32 0, i32 1, i32 0, null}
+!14 = !{[14 x i32] [i32 12, i32 4, i32 0, i32 0, i32 0, i32 0, i32 15, i32 15, i32 0, i32 0, i32 1, i32 2, i32 4, i32 8]}
+!15 = !{void ()* @main, !"main", !16, !4, null}
+!16 = !{!17, !24, null}
+!17 = !{!18, !20, !22}
+!18 = !{i32 0, !"SV_Position", i8 9, i8 3, !19, i8 4, i32 1, i8 4, i32 0, i8 0, null}
+!19 = !{i32 0}
+!20 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !19, i8 2, i32 1, i8 2, i32 1, i8 0, !21}
+!21 = !{i32 3, i32 3}
+!22 = !{i32 2, !"COLOR", i8 9, i8 0, !19, i8 2, i32 1, i8 4, i32 2, i8 0, !23}
+!23 = !{i32 3, i32 15}
+!24 = !{!25}
+!25 = !{i32 0, !"SV_Target", i8 9, i8 16, !19, i8 0, i32 1, i8 4, i32 0, i8 0, !23}
+
+#endif
+
+const unsigned char g_main[] = {
+  0x44, 0x58, 0x42, 0x43, 0x78, 0xad, 0xb4, 0x13, 0x3d, 0x52, 0x26, 0xa9,
+  0x43, 0x6f, 0x29, 0xd4, 0x3d, 0xe5, 0x45, 0x27, 0x01, 0x00, 0x00, 0x00,
+  0xd9, 0x20, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x15, 0x01, 0x00, 0x00,
+  0x61, 0x02, 0x00, 0x00, 0x61, 0x03, 0x00, 0x00, 0xd9, 0x0c, 0x00, 0x00,
+  0xf5, 0x0c, 0x00, 0x00, 0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31,
+  0x83, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c,
+  0x4f, 0x52, 0x00, 0x4f, 0x53, 0x47, 0x31, 0x32, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74,
+  0x00, 0x50, 0x53, 0x56, 0x30, 0x44, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x03, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x05, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43,
+  0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x44, 0x03, 0x03, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x42, 0x00, 0x03, 0x02, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x44,
+  0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x44, 0x10, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x52, 0x54, 0x53,
+  0x30, 0xf8, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00,
+  0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x60, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00,
+  0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x53, 0x54, 0x41, 0x54, 0x70, 0x09, 0x00, 0x00, 0x60, 0x00, 0x00,
+  0x00, 0x5c, 0x02, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x58, 0x09, 0x00, 0x00, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x53, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x11, 0x23, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x31, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff,
+  0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff,
+  0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4,
+  0x4c, 0x10, 0x9c, 0xc1, 0x08, 0x40, 0x09, 0x00, 0x0a, 0x66, 0x00, 0xe6,
+  0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x40, 0x10, 0x44, 0x41, 0x90,
+  0x51, 0x0c, 0x80, 0x20, 0x88, 0x62, 0x20, 0xe4, 0xa6, 0xe1, 0xf2, 0x27,
+  0xec, 0x21, 0x24, 0x7f, 0x25, 0xa4, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x51,
+  0x31, 0x0c, 0xc3, 0x40, 0x50, 0x71, 0xcf, 0x70, 0xf9, 0x13, 0xf6, 0x10,
+  0x92, 0x1f, 0x02, 0xcd, 0xb0, 0x10, 0x28, 0x58, 0x0a, 0xa3, 0x10, 0x0c,
+  0x33, 0x0c, 0xc3, 0x40, 0x10, 0xc4, 0x40, 0x4d, 0x41, 0x06, 0x62, 0x18,
+  0x86, 0x61, 0x18, 0xe8, 0x29, 0xc3, 0x40, 0x0c, 0x14, 0x15, 0x62, 0x20,
+  0x86, 0x81, 0xa6, 0xa3, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e,
+  0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11, 0x31, 0x0c, 0xc3, 0x50,
+  0x88, 0x8a, 0x60, 0x08, 0xb2, 0x4a, 0x31, 0x10, 0xc3, 0x30, 0x10, 0x36,
+  0x47, 0x10, 0x14, 0x83, 0x21, 0x0a, 0x82, 0xd0, 0x68, 0x1b, 0x08, 0x18,
+  0x46, 0x20, 0x86, 0x99, 0xda, 0x60, 0x1c, 0xd8, 0x21, 0x1c, 0xe6, 0x61,
+  0x1e, 0xdc, 0x80, 0x16, 0xca, 0x01, 0x1f, 0xe8, 0xa1, 0x1e, 0xe4, 0xa1,
+  0x1c, 0xe4, 0x80, 0x14, 0xf8, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1,
+  0x1d, 0xe4, 0x81, 0x0f, 0xcc, 0x81, 0x1d, 0xde, 0x21, 0x1c, 0xe8, 0x81,
+  0x0d, 0xc0, 0x80, 0x0e, 0xfc, 0x00, 0x0c, 0xfc, 0x40, 0x0f, 0xf4, 0xa0,
+  0x1d, 0xd2, 0x01, 0x1e, 0xe6, 0xe1, 0x17, 0xe8, 0x21, 0x1f, 0xe0, 0xa1,
+  0x1c, 0x50, 0x40, 0xcc, 0x24, 0x06, 0xe3, 0xc0, 0x0e, 0xe1, 0x30, 0x0f,
+  0xf3, 0xe0, 0x06, 0xb4, 0x50, 0x0e, 0xf8, 0x40, 0x0f, 0xf5, 0x20, 0x0f,
+  0xe5, 0x20, 0x07, 0xa4, 0xc0, 0x07, 0xf6, 0x50, 0x0e, 0xe3, 0x40, 0x0f,
+  0xef, 0x20, 0x0f, 0x7c, 0x60, 0x0e, 0xec, 0xf0, 0x0e, 0xe1, 0x40, 0x0f,
+  0x6c, 0x00, 0x06, 0x74, 0xe0, 0x07, 0x60, 0xe0, 0x07, 0x48, 0xf0, 0x3e,
+  0x02, 0x2f, 0xe1, 0x9c, 0x46, 0x9a, 0x80, 0x66, 0x92, 0x10, 0x33, 0x0c,
+  0xc3, 0x30, 0x0c, 0xc3, 0xe0, 0x79, 0x9e, 0x47, 0xe2, 0x4d, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x00, 0xf3, 0x2c, 0x44, 0xc4, 0x4e, 0xc0, 0x44,
+  0xa0, 0x80, 0x20, 0x32, 0x1d, 0x08, 0x00, 0x00, 0x00, 0x13, 0x14, 0x72,
+  0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72,
+  0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e,
+  0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e,
+  0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x79, 0x80, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc8, 0x13, 0x01,
+  0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x90, 0x67,
+  0x02, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21,
+  0x8f, 0x05, 0x04, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x43, 0x1e, 0x0c, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x86, 0x3c, 0x1b, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x64, 0x81, 0x00, 0x19, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0x22, 0x4a, 0x60, 0x04, 0xa0, 0x18, 0x8a, 0xa0, 0x24, 0x0a, 0x38, 0xa0,
+  0x0c, 0xca, 0xa1, 0x10, 0x0a, 0xa2, 0x30, 0x0a, 0xa4, 0x50, 0x0a, 0xa6,
+  0x70, 0x0a, 0xa8, 0xc0, 0x0a, 0x30, 0xa0, 0x40, 0x03, 0xca, 0xa3, 0x6c,
+  0xca, 0x70, 0xa0, 0x44, 0x0d, 0xa8, 0x28, 0x89, 0x32, 0x28, 0x84, 0x11,
+  0x80, 0x22, 0x28, 0x10, 0xd2, 0x6a, 0x80, 0xc2, 0x19, 0x00, 0x12, 0x67,
+  0x00, 0x68, 0x9c, 0x01, 0xa0, 0x72, 0x06, 0x80, 0xcc, 0xb1, 0x1c, 0x86,
+  0x00, 0x00, 0x00, 0x78, 0x1e, 0x00, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x90, 0x46, 0x02, 0x13, 0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03,
+  0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01,
+  0x41, 0xa1, 0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a,
+  0x2a, 0xfa, 0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b,
+  0xd9, 0x10, 0x04, 0x13, 0x04, 0x42, 0x99, 0x20, 0x10, 0xcb, 0x06, 0x61,
+  0x20, 0x36, 0x08, 0x04, 0x41, 0x01, 0x6e, 0x6e, 0x82, 0x40, 0x30, 0x1b,
+  0x86, 0x03, 0x21, 0x26, 0x08, 0x61, 0x80, 0x06, 0x44, 0xe8, 0xca, 0xf0,
+  0xe8, 0xea, 0xe4, 0xca, 0x60, 0x26, 0x08, 0x44, 0x33, 0x41, 0x20, 0x9c,
+  0x0d, 0x02, 0xd1, 0x6c, 0x48, 0x08, 0x65, 0x21, 0x88, 0x81, 0x21, 0x1c,
+  0x22, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x31, 0x1b, 0x92, 0x41,
+  0x81, 0x88, 0x61, 0x60, 0x08, 0x87, 0x08, 0x5d, 0x19, 0x1e, 0x5d, 0x9d,
+  0x5c, 0x99, 0xcc, 0x86, 0x84, 0x51, 0x24, 0x82, 0x19, 0x18, 0xc2, 0xd9,
+  0x30, 0x3c, 0xd1, 0x34, 0x41, 0x18, 0x03, 0x35, 0x60, 0x32, 0xf4, 0xe6,
+  0x36, 0x47, 0x17, 0xe6, 0x46, 0x37, 0x37, 0x41, 0x20, 0x9e, 0x0d, 0x08,
+  0x51, 0x59, 0xc4, 0x30, 0x5c, 0xc0, 0x86, 0x00, 0x9b, 0x20, 0x94, 0xc1,
+  0x1a, 0x10, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0x83, 0xd9, 0x80,
+  0x10, 0xda, 0x46, 0x10, 0x03, 0x01, 0x6c, 0x08, 0xb8, 0x0d, 0x04, 0x05,
+  0x64, 0xdd, 0x04, 0x41, 0x0c, 0xd2, 0x80, 0xcc, 0xdc, 0x98, 0xd4, 0x91,
+  0xd0, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0xdd, 0x04, 0x81, 0x80, 0x26,
+  0x08, 0x44, 0x34, 0x41, 0xd0, 0xce, 0x60, 0x03, 0x82, 0x80, 0x41, 0x18,
+  0x10, 0x62, 0xd0, 0x34, 0x63, 0x40, 0x86, 0xae, 0x0c, 0x8f, 0xae, 0x4e,
+  0xae, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0x6c, 0x82, 0x40, 0x48, 0x1b, 0x10,
+  0xa4, 0x0c, 0xc2, 0xc0, 0x0c, 0xc4, 0xa0, 0x69, 0xc6, 0x80, 0x4a, 0x9a,
+  0x1b, 0x5c, 0x1d, 0xdd, 0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x04, 0x81, 0x98,
+  0x36, 0x20, 0x08, 0x1a, 0x84, 0x41, 0x1a, 0x88, 0x41, 0xd3, 0x8c, 0x01,
+  0x97, 0xb1, 0x37, 0xb6, 0x37, 0xb9, 0xaf, 0xb9, 0xb1, 0x30, 0xb6, 0xb2,
+  0x09, 0x02, 0x41, 0x6d, 0x40, 0x90, 0x35, 0x08, 0x03, 0x36, 0x10, 0x83,
+  0xa6, 0x19, 0x03, 0x3a, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f,
+  0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x13, 0x04, 0xa2, 0xda, 0x80, 0x20,
+  0x6e, 0x10, 0x06, 0x6f, 0x20, 0x06, 0x4d, 0x33, 0x06, 0x7c, 0xe8, 0xde,
+  0xdc, 0xca, 0xda, 0xc2, 0xe0, 0xbe, 0xcc, 0xc2, 0xc6, 0xe8, 0xde, 0xe4,
+  0x62, 0x26, 0x08, 0x84, 0xb5, 0x01, 0x41, 0xe2, 0x20, 0x0c, 0xe4, 0x40,
+  0x0c, 0x9a, 0x66, 0x0c, 0xf8, 0xd0, 0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1,
+  0x7d, 0x99, 0x85, 0x8d, 0xd1, 0xbd, 0xc9, 0xc9, 0x4c, 0x10, 0x88, 0x6b,
+  0x03, 0x82, 0xd0, 0x41, 0x18, 0xd4, 0x81, 0x18, 0x34, 0xcd, 0x18, 0xf0,
+  0x99, 0x23, 0x93, 0xfb, 0xba, 0x43, 0x4b, 0xa3, 0x2b, 0xfb, 0x82, 0x7b,
+  0x4b, 0x73, 0xa3, 0x9b, 0x20, 0x10, 0xd8, 0x06, 0x04, 0xb9, 0x83, 0x30,
+  0xc0, 0x03, 0x31, 0x68, 0x9a, 0x31, 0xe0, 0x91, 0xf5, 0x66, 0x66, 0x36,
+  0x57, 0x46, 0x37, 0x41, 0x20, 0xb2, 0x0d, 0x08, 0xa2, 0x07, 0x61, 0xb0,
+  0x07, 0x62, 0xd0, 0x34, 0x63, 0x40, 0x43, 0x6a, 0xec, 0xad, 0xcc, 0xcc,
+  0x6c, 0x82, 0x40, 0x68, 0x1b, 0x10, 0xa4, 0x0f, 0xc2, 0xc0, 0x0f, 0xc4,
+  0xa0, 0x69, 0xc6, 0x80, 0xc6, 0xd1, 0xd8, 0x5b, 0x99, 0x99, 0xd9, 0x04,
+  0x81, 0xd8, 0x36, 0x20, 0x08, 0x28, 0x84, 0x41, 0x28, 0x88, 0x41, 0xd3,
+  0x8c, 0x01, 0x0d, 0xa1, 0xb1, 0xb7, 0x32, 0x33, 0xb3, 0x09, 0x02, 0xc1,
+  0x6d, 0x40, 0x90, 0x51, 0x08, 0x03, 0x52, 0x10, 0x83, 0xa6, 0x19, 0x83,
+  0x0d, 0xcd, 0x45, 0x06, 0x67, 0xa0, 0x06, 0x6d, 0x00, 0x07, 0x73, 0x60,
+  0x07, 0x79, 0xc0, 0x07, 0x7f, 0x20, 0x0a, 0xa5, 0xb0, 0x61, 0x20, 0x3e,
+  0x53, 0x98, 0x20, 0x08, 0xc0, 0x06, 0x60, 0xc3, 0x40, 0xa4, 0x42, 0x2a,
+  0x6c, 0x08, 0x54, 0x61, 0xc3, 0x30, 0xa0, 0xc2, 0x2a, 0x4c, 0x10, 0xcc,
+  0x80, 0x0d, 0x36, 0x04, 0xad, 0x40, 0xa2, 0x2d, 0x2c, 0xcd, 0x8d, 0xcb,
+  0x94, 0xd5, 0x17, 0xd4, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0xdb, 0x04,
+  0xa1, 0x08, 0x83, 0x09, 0x42, 0x21, 0x06, 0x1b, 0x02, 0x62, 0x82, 0x50,
+  0x8c, 0xc1, 0x04, 0xa1, 0x20, 0x83, 0x0d, 0x0b, 0x01, 0x0b, 0xb1, 0x20,
+  0x0b, 0xb3, 0x40, 0x0b, 0x03, 0x2d, 0x10, 0xb5, 0x00, 0x10, 0xa1, 0x2a,
+  0xc2, 0x1a, 0x7a, 0x7a, 0x92, 0x22, 0x9a, 0x20, 0x14, 0x65, 0xb0, 0x41,
+  0x08, 0x83, 0x30, 0xd8, 0xb0, 0x0c, 0xb7, 0x10, 0x0b, 0xb5, 0x30, 0x0b,
+  0xb8, 0x30, 0xe0, 0xc2, 0x50, 0x0b, 0xb9, 0xc0, 0x62, 0xe8, 0x89, 0xe9,
+  0x49, 0x6a, 0x82, 0x40, 0x74, 0x1b, 0x84, 0x30, 0xe0, 0x85, 0x0d, 0x0b,
+  0xb3, 0x0b, 0xb1, 0x50, 0x0b, 0xb3, 0x80, 0x0b, 0x03, 0x2d, 0x30, 0xb5,
+  0xd0, 0x0b, 0x1b, 0x06, 0x5b, 0xd0, 0x05, 0x5f, 0x60, 0x32, 0x65, 0xf5,
+  0x45, 0x15, 0x26, 0x77, 0x56, 0x46, 0x37, 0x41, 0x28, 0xcc, 0x60, 0xc3,
+  0x42, 0x80, 0x43, 0x2c, 0x84, 0xc3, 0x2c, 0xd4, 0xc2, 0x40, 0x0b, 0x44,
+  0x2d, 0xf4, 0xc2, 0x86, 0x40, 0x1c, 0x36, 0x0c, 0xbf, 0x30, 0x0e, 0xc0,
+  0x86, 0x02, 0x15, 0x5e, 0x81, 0x1c, 0x3c, 0x80, 0x88, 0x98, 0x5c, 0x98,
+  0xdb, 0x18, 0x5a, 0xd9, 0xdc, 0x04, 0x81, 0xf0, 0x68, 0x98, 0xb1, 0xbd,
+  0x85, 0xd1, 0xcd, 0x4d, 0x10, 0x88, 0x8f, 0x45, 0x9a, 0xdb, 0x1c, 0xdd,
+  0xdc, 0x04, 0x81, 0x00, 0x03, 0x1a, 0x73, 0x69, 0x67, 0x5f, 0x6c, 0x64,
+  0x34, 0xe6, 0xd2, 0xce, 0xbe, 0xe6, 0xe8, 0x88, 0xd0, 0x95, 0xe1, 0x7d,
+  0xb9, 0xbd, 0xc9, 0xb5, 0x6d, 0x60, 0xcc, 0xe1, 0x1c, 0xd0, 0x21, 0x1d,
+  0xd4, 0x61, 0x1d, 0xd8, 0x01, 0x69, 0x07, 0x33, 0x70, 0x87, 0x34, 0xa8,
+  0xc2, 0xc6, 0x66, 0xd7, 0xe6, 0x92, 0x46, 0x56, 0xe6, 0x46, 0x37, 0x25,
+  0x08, 0xaa, 0x90, 0xe1, 0xb9, 0xd8, 0x95, 0xc9, 0xcd, 0xa5, 0xbd, 0xb9,
+  0x4d, 0x09, 0x88, 0x26, 0x64, 0x78, 0x2e, 0x76, 0x61, 0x6c, 0x76, 0x65,
+  0x72, 0x53, 0x82, 0xa2, 0x0e, 0x19, 0x9e, 0xcb, 0x1c, 0x5a, 0x18, 0x59,
+  0x99, 0x5c, 0xd3, 0x1b, 0x59, 0x19, 0xdb, 0x94, 0x00, 0x29, 0x43, 0x86,
+  0xe7, 0x22, 0x57, 0x36, 0xf7, 0x56, 0x27, 0x37, 0x56, 0x36, 0x37, 0x25,
+  0xe8, 0x2a, 0x91, 0xe1, 0xb9, 0xd0, 0xe5, 0xc1, 0x95, 0x05, 0xb9, 0xb9,
+  0xbd, 0xd1, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0xcd, 0x4d, 0x11, 0x4c, 0x61,
+  0x15, 0xea, 0x90, 0xe1, 0xb9, 0xd8, 0xa5, 0x95, 0xdd, 0x25, 0x91, 0x4d,
+  0xd1, 0x85, 0xd1, 0x95, 0x4d, 0x09, 0x5a, 0xa1, 0x0e, 0x19, 0x9e, 0x4b,
+  0x99, 0x1b, 0x9d, 0x5c, 0x1e, 0xd4, 0x5b, 0x9a, 0x1b, 0xdd, 0xdc, 0x94,
+  0x80, 0x1c, 0xba, 0x90, 0xe1, 0xb9, 0x8c, 0xbd, 0xd5, 0xb9, 0xd1, 0x95,
+  0xc9, 0xcd, 0x4d, 0x09, 0xdc, 0x01, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x51, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc4, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x7a, 0x28,
+  0x87, 0x76, 0x80, 0x87, 0x19, 0xd1, 0x43, 0x0e, 0xf8, 0xe0, 0x06, 0xe4,
+  0x20, 0x0e, 0xe7, 0xe0, 0x06, 0xf6, 0x10, 0x0e, 0xf2, 0xc0, 0x0e, 0xe1,
+  0x90, 0x0f, 0xef, 0x50, 0x0f, 0xf4, 0x30, 0x83, 0x81, 0xc8, 0x01, 0x1f,
+  0xdc, 0x40, 0x1c, 0xe4, 0xa1, 0x1c, 0xc2, 0x61, 0x1d, 0xdc, 0x40, 0x1c,
+  0xe4, 0x01, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x26, 0x00, 0x00,
+  0x00, 0x66, 0x00, 0x0d, 0x97, 0xef, 0x3c, 0x7e, 0x80, 0x34, 0x40, 0x84,
+  0xf9, 0xc5, 0x6d, 0xdb, 0xc1, 0x36, 0x5c, 0xbe, 0xf3, 0xf8, 0x42, 0x40,
+  0x15, 0x05, 0x11, 0x95, 0x0e, 0x30, 0x94, 0x84, 0x01, 0x08, 0x98, 0x5f,
+  0xdc, 0xb6, 0x25, 0x48, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x44, 0x04, 0x30,
+  0x11, 0x21, 0xd0, 0x0c, 0x0b, 0x61, 0x04, 0xce, 0x70, 0xf9, 0xce, 0xe3,
+  0x0f, 0xce, 0x74, 0xfb, 0xc5, 0x6d, 0x5b, 0xc0, 0x34, 0x5c, 0xbe, 0xf3,
+  0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x0d,
+  0x40, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x01, 0xcc, 0xb3, 0x10, 0x7e, 0x71,
+  0xdb, 0x26, 0x50, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x34, 0x39, 0x11, 0x81,
+  0x52, 0xd3, 0x43, 0x4d, 0x7e, 0x71, 0xdb, 0x86, 0x20, 0x0d, 0x97, 0xef,
+  0x3c, 0xfe, 0x44, 0x44, 0x13, 0x02, 0x44, 0x98, 0x5f, 0xdc, 0xb6, 0x15,
+  0x3c, 0xc3, 0xe5, 0x3b, 0x8f, 0x4f, 0x35, 0x40, 0x84, 0xf9, 0xc5, 0x6d,
+  0x1b, 0x00, 0xc1, 0x00, 0x48, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xf6, 0x87, 0x44, 0x46, 0xea, 0xee, 0x41, 0xc1, 0x02, 0x14, 0x2c,
+  0x02, 0xd5, 0xbb, 0x3a, 0xb7, 0x44, 0x58, 0x49, 0x4c, 0xdc, 0x13, 0x00,
+  0x00, 0x60, 0x00, 0x00, 0x00, 0xf7, 0x04, 0x00, 0x00, 0x44, 0x58, 0x49,
+  0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xc4, 0x13, 0x00,
+  0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xee, 0x04, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e,
+  0x90, 0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8,
+  0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08,
+  0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x57, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4,
+  0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c,
+  0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xa0, 0xc1, 0x08, 0x40, 0x09, 0x00,
+  0x0a, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x40,
+  0x10, 0x44, 0x41, 0x90, 0x51, 0x0c, 0x80, 0x20, 0x88, 0x62, 0x20, 0xe4,
+  0xa6, 0xe1, 0xf2, 0x27, 0xec, 0x21, 0x24, 0x7f, 0x25, 0xa4, 0x95, 0x98,
+  0xfc, 0xe2, 0xb6, 0x51, 0x31, 0x0c, 0xc3, 0x40, 0x50, 0x71, 0xcf, 0x70,
+  0xf9, 0x13, 0xf6, 0x10, 0x92, 0x1f, 0x02, 0xcd, 0xb0, 0x10, 0x28, 0x58,
+  0x0a, 0xa3, 0x10, 0x0c, 0x33, 0x0c, 0xc3, 0x40, 0x10, 0xc4, 0x40, 0x4d,
+  0x41, 0x06, 0x62, 0x18, 0x86, 0x61, 0x18, 0xe8, 0x29, 0xc3, 0x40, 0x0c,
+  0x14, 0x15, 0x62, 0x20, 0x86, 0x81, 0xa6, 0xa3, 0x86, 0xcb, 0x9f, 0xb0,
+  0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11,
+  0x31, 0x0c, 0xc3, 0x50, 0x88, 0x8a, 0x60, 0x08, 0xb2, 0x4a, 0x31, 0x10,
+  0xc3, 0x30, 0x10, 0x36, 0x47, 0x10, 0x14, 0x83, 0x21, 0x0a, 0x82, 0xd0,
+  0x68, 0x1b, 0x08, 0x18, 0x46, 0x20, 0x86, 0x99, 0xda, 0x60, 0x1c, 0xd8,
+  0x21, 0x1c, 0xe6, 0x61, 0x1e, 0xdc, 0x80, 0x16, 0xca, 0x01, 0x1f, 0xe8,
+  0xa1, 0x1e, 0xe4, 0xa1, 0x1c, 0xe4, 0x80, 0x14, 0xf8, 0xc0, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x81, 0x0f, 0xcc, 0x81, 0x1d, 0xde,
+  0x21, 0x1c, 0xe8, 0x81, 0x0d, 0xc0, 0x80, 0x0e, 0xfc, 0x00, 0x0c, 0xfc,
+  0x40, 0x0f, 0xf4, 0xa0, 0x1d, 0xd2, 0x01, 0x1e, 0xe6, 0xe1, 0x17, 0xe8,
+  0x21, 0x1f, 0xe0, 0xa1, 0x1c, 0x50, 0x40, 0xcc, 0x24, 0x06, 0xe3, 0xc0,
+  0x0e, 0xe1, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xb4, 0x50, 0x0e, 0xf8, 0x40,
+  0x0f, 0xf5, 0x20, 0x0f, 0xe5, 0x20, 0x07, 0xa4, 0xc0, 0x07, 0xf6, 0x50,
+  0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x7c, 0x60, 0x0e, 0xec, 0xf0,
+  0x0e, 0xe1, 0x40, 0x0f, 0x6c, 0x00, 0x06, 0x74, 0xe0, 0x07, 0x60, 0xe0,
+  0x07, 0x48, 0xf0, 0x3e, 0x02, 0x2f, 0xe1, 0x9c, 0x46, 0x9a, 0x80, 0x66,
+  0x92, 0x10, 0x33, 0x0c, 0xc3, 0x30, 0x0c, 0xc3, 0xe0, 0x79, 0x9e, 0x47,
+  0xe2, 0x4d, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x00, 0xf3, 0x2c, 0x44,
+  0xc4, 0x4e, 0xc0, 0x44, 0xa0, 0x80, 0x20, 0x32, 0x1d, 0x88, 0x29, 0x00,
+  0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87,
+  0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0,
+  0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10,
+  0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2,
+  0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
+  0xe4, 0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x60, 0xc8, 0x13, 0x01, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xc0, 0x90, 0x67, 0x02, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x80, 0x21, 0x8f, 0x05, 0x04, 0xc0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x43, 0x1e, 0x0c, 0x08, 0x80, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x1b, 0x10, 0x00, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x81, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x22, 0x4a, 0x60, 0x04, 0xa0, 0x18, 0x8a, 0xa0,
+  0x24, 0x0a, 0x38, 0xa0, 0x0c, 0xca, 0x83, 0x8a, 0x92, 0x28, 0x83, 0x42,
+  0x18, 0x01, 0x28, 0x82, 0x02, 0xa1, 0x70, 0x06, 0x80, 0xc6, 0x19, 0x00,
+  0x2a, 0x67, 0x00, 0xc8, 0x1c, 0xcb, 0x61, 0x08, 0x00, 0x00, 0x80, 0xe7,
+  0x01, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x71, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13,
+  0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b,
+  0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b,
+  0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9,
+  0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0x42, 0x99, 0x20, 0x10, 0xcb, 0x06, 0x61, 0x20, 0x26, 0x08, 0x04,
+  0xb3, 0x41, 0x18, 0x0c, 0x0a, 0x70, 0x73, 0x1b, 0x06, 0xc4, 0x20, 0x26,
+  0x08, 0x61, 0x80, 0x11, 0x98, 0x20, 0x10, 0xcd, 0x04, 0x81, 0x70, 0x36,
+  0x08, 0x44, 0xb3, 0x21, 0x21, 0x94, 0x85, 0x20, 0x06, 0x86, 0x70, 0x36,
+  0x24, 0x83, 0xb2, 0x10, 0xc3, 0xc0, 0x10, 0xce, 0x86, 0x84, 0x51, 0x16,
+  0x82, 0x19, 0x18, 0xc2, 0xd9, 0x30, 0x3c, 0x50, 0x34, 0x41, 0x18, 0x83,
+  0x6c, 0x82, 0x40, 0x3c, 0x1b, 0x10, 0x62, 0x5a, 0x88, 0x61, 0xa0, 0x80,
+  0x0d, 0x41, 0x35, 0x41, 0x28, 0x03, 0x6d, 0x03, 0x42, 0x5c, 0x0b, 0x41,
+  0x0c, 0x04, 0xb0, 0x21, 0xc0, 0x36, 0x10, 0x12, 0x60, 0x65, 0x13, 0x04,
+  0x33, 0xd8, 0x36, 0x04, 0xdb, 0x04, 0x41, 0x00, 0x48, 0xb4, 0x85, 0xa5,
+  0xb9, 0x71, 0x99, 0xb2, 0xfa, 0x82, 0x7a, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b,
+  0x73, 0x9b, 0x20, 0x14, 0xd2, 0x04, 0xa1, 0x98, 0x36, 0x04, 0xc4, 0x04,
+  0xa1, 0xa0, 0x26, 0x08, 0x45, 0xb5, 0x61, 0x21, 0x3e, 0x30, 0x08, 0x03,
+  0x31, 0x18, 0x83, 0x61, 0x0c, 0x08, 0x32, 0x00, 0x88, 0x50, 0x15, 0x61,
+  0x0d, 0x3d, 0x3d, 0x49, 0x11, 0x4d, 0x10, 0x0a, 0x6b, 0x82, 0x40, 0x40,
+  0x1b, 0x04, 0x34, 0x40, 0x83, 0x0d, 0xcb, 0x60, 0x06, 0x60, 0x40, 0x06,
+  0x62, 0x70, 0x06, 0xc3, 0x19, 0x0c, 0x64, 0x90, 0x06, 0x2c, 0x86, 0x9e,
+  0x98, 0x9e, 0xa4, 0x26, 0x08, 0x44, 0xb4, 0x41, 0x40, 0x03, 0x36, 0xd8,
+  0xb0, 0x30, 0x6b, 0x00, 0x06, 0x64, 0x20, 0x06, 0x67, 0x30, 0x8c, 0x01,
+  0x43, 0x06, 0x6d, 0xb0, 0x61, 0x28, 0x03, 0x35, 0x70, 0x03, 0x26, 0x53,
+  0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x13, 0x84, 0xe2, 0xda,
+  0xb0, 0x10, 0x70, 0x00, 0x06, 0x71, 0x20, 0x06, 0x64, 0x30, 0x8c, 0x01,
+  0x41, 0x06, 0x6d, 0xb0, 0x21, 0x90, 0x83, 0x0d, 0xc3, 0x1b, 0xcc, 0x01,
+  0xb0, 0xa1, 0xe8, 0x3c, 0x3a, 0xd0, 0x80, 0x2a, 0x6c, 0x6c, 0x76, 0x6d,
+  0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x53, 0x82, 0xa0, 0x0a, 0x19, 0x9e,
+  0x8b, 0x5d, 0x99, 0xdc, 0x5c, 0xda, 0x9b, 0xdb, 0x94, 0x80, 0x68, 0x42,
+  0x86, 0xe7, 0x62, 0x17, 0xc6, 0x66, 0x57, 0x26, 0x37, 0x25, 0x30, 0xea,
+  0x90, 0xe1, 0xb9, 0xcc, 0xa1, 0x85, 0x91, 0x95, 0xc9, 0x35, 0xbd, 0x91,
+  0x95, 0xb1, 0x4d, 0x09, 0x90, 0x32, 0x64, 0x78, 0x2e, 0x72, 0x65, 0x73,
+  0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x53, 0x82, 0xac, 0x0e, 0x19, 0x9e,
+  0x8b, 0x5d, 0x5a, 0xd9, 0x5d, 0x12, 0xd9, 0x14, 0x5d, 0x18, 0x5d, 0xd9,
+  0x94, 0x60, 0xab, 0x43, 0x86, 0xe7, 0x52, 0xe6, 0x46, 0x27, 0x97, 0x07,
+  0xf5, 0x96, 0xe6, 0x46, 0x37, 0x37, 0x25, 0xa0, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc4, 0x21, 0x07, 0x7c,
+  0x70, 0x03, 0x7a, 0x28, 0x87, 0x76, 0x80, 0x87, 0x19, 0xd1, 0x43, 0x0e,
+  0xf8, 0xe0, 0x06, 0xe4, 0x20, 0x0e, 0xe7, 0xe0, 0x06, 0xf6, 0x10, 0x0e,
+  0xf2, 0xc0, 0x0e, 0xe1, 0x90, 0x0f, 0xef, 0x50, 0x0f, 0xf4, 0x30, 0x83,
+  0x81, 0xc8, 0x01, 0x1f, 0xdc, 0x40, 0x1c, 0xe4, 0xa1, 0x1c, 0xc2, 0x61,
+  0x1d, 0xdc, 0x40, 0x1c, 0xe4, 0x01, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x26, 0x00, 0x00, 0x00, 0x66, 0x00, 0x0d, 0x97, 0xef, 0x3c, 0x7e,
+  0x80, 0x34, 0x40, 0x84, 0xf9, 0xc5, 0x6d, 0xdb, 0xc1, 0x36, 0x5c, 0xbe,
+  0xf3, 0xf8, 0x42, 0x40, 0x15, 0x05, 0x11, 0x95, 0x0e, 0x30, 0x94, 0x84,
+  0x01, 0x08, 0x98, 0x5f, 0xdc, 0xb6, 0x25, 0x48, 0xc3, 0xe5, 0x3b, 0x8f,
+  0x2f, 0x44, 0x04, 0x30, 0x11, 0x21, 0xd0, 0x0c, 0x0b, 0x61, 0x04, 0xce,
+  0x70, 0xf9, 0xce, 0xe3, 0x0f, 0xce, 0x74, 0xfb, 0xc5, 0x6d, 0x5b, 0xc0,
+  0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93,
+  0x5f, 0xdc, 0xb6, 0x0d, 0x40, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x01, 0xcc,
+  0xb3, 0x10, 0x7e, 0x71, 0xdb, 0x26, 0x50, 0x0d, 0x97, 0xef, 0x3c, 0xbe,
+  0x34, 0x39, 0x11, 0x81, 0x52, 0xd3, 0x43, 0x4d, 0x7e, 0x71, 0xdb, 0x86,
+  0x20, 0x0d, 0x97, 0xef, 0x3c, 0xfe, 0x44, 0x44, 0x13, 0x02, 0x44, 0x98,
+  0x5f, 0xdc, 0xb6, 0x15, 0x3c, 0xc3, 0xe5, 0x3b, 0x8f, 0x4f, 0x35, 0x40,
+  0x84, 0xf9, 0xc5, 0x6d, 0x1b, 0x00, 0xc1, 0x00, 0x48, 0x03, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x13, 0x04, 0x7b,
+  0x10, 0x0b, 0x04, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0xa4, 0x8d, 0x00,
+  0x50, 0x51, 0x02, 0x44, 0x94, 0x51, 0xc9, 0x95, 0x43, 0x29, 0x14, 0x5e,
+  0xb9, 0x15, 0xc2, 0x0c, 0x40, 0xa9, 0x94, 0x4b, 0xd9, 0x15, 0x17, 0x0d,
+  0x63, 0x04, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x8c, 0x11, 0x98, 0xf7, 0xba,
+  0xca, 0xde, 0x18, 0x41, 0xcc, 0x83, 0x7d, 0xee, 0x8d, 0x11, 0xb8, 0x7d,
+  0x2c, 0xda, 0xde, 0x18, 0xc1, 0xbb, 0xa7, 0xe5, 0xfd, 0x8d, 0x11, 0xe8,
+  0xac, 0x39, 0x87, 0x60, 0x30, 0x46, 0x00, 0x82, 0x20, 0x48, 0x82, 0xc1,
+  0x18, 0x81, 0x98, 0x8b, 0x69, 0xff, 0x8d, 0x11, 0x80, 0x25, 0xcf, 0xc6,
+  0xbf, 0x30, 0x46, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x18, 0xc1, 0x3f,
+  0x93, 0xfe, 0xef, 0x0b, 0x63, 0x04, 0x74, 0x0d, 0x8a, 0xf9, 0x37, 0x46,
+  0xd0, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x18, 0xc1, 0xdc, 0xb7, 0x69, 0xea,
+  0x0b, 0x63, 0x04, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0x8c, 0x11, 0xf0, 0x39,
+  0xeb, 0xe3, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20, 0x0a, 0x06, 0x63, 0x04,
+  0x2c, 0x7b, 0x86, 0xf2, 0x37, 0x46, 0x80, 0xfa, 0x65, 0xac, 0x7e, 0x63,
+  0x04, 0xf9, 0xa9, 0x8b, 0xb3, 0x37, 0x46, 0xa0, 0xd7, 0xe0, 0x8e, 0x7b,
+  0x63, 0x04, 0x2a, 0x9e, 0xdb, 0xf6, 0x37, 0x46, 0xf0, 0xf6, 0x29, 0x3d,
+  0x7a, 0x63, 0x04, 0xeb, 0x1c, 0xb3, 0xa8, 0x37, 0x46, 0x90, 0x86, 0x30,
+  0xba, 0x7b, 0x63, 0x04, 0x77, 0x1b, 0xab, 0xf6, 0x37, 0x46, 0xb0, 0x8e,
+  0x78, 0xcc, 0x82, 0xc1, 0x18, 0x01, 0x08, 0xd2, 0x6d, 0x0e, 0x06, 0x63,
+  0x04, 0x20, 0x08, 0xae, 0x39, 0x18, 0x8c, 0x11, 0x80, 0x20, 0xc8, 0xd6,
+  0xbf, 0x30, 0x46, 0xc0, 0xb6, 0xf3, 0x4f, 0x7a, 0x63, 0x04, 0x20, 0x08,
+  0x82, 0x20, 0x18, 0x8c, 0x11, 0xb8, 0x7d, 0x2c, 0xda, 0xbe, 0x30, 0x46,
+  0xd0, 0xc7, 0xa2, 0x8b, 0x7f, 0x63, 0x04, 0xb5, 0x5a, 0xab, 0xed, 0x37,
+  0x46, 0x20, 0x8b, 0x6e, 0x4f, 0x83, 0xc1, 0x18, 0x01, 0x0f, 0xaf, 0x3a,
+  0xdd, 0x8d, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x0c, 0x00,
+  0x00, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0xb0, 0xa5, 0xc2, 0x1c, 0xf4,
+  0x41, 0x29, 0x94, 0x82, 0x1d, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0xc1,
+  0xa6, 0x0a, 0x74, 0xe0, 0x07, 0xa9, 0x90, 0x0a, 0x77, 0x30, 0x62, 0x90,
+  0x00, 0x20, 0x08, 0x06, 0xdb, 0x2a, 0xd4, 0xc1, 0x1f, 0xa4, 0x42, 0x2a,
+  0xe0, 0xc1, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x6c, 0xac, 0x60, 0x07,
+  0xa2, 0xa0, 0x0a, 0xaa, 0x90, 0x07, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60,
+  0xb0, 0xb5, 0xc2, 0x1d, 0x80, 0xc2, 0x2a, 0xb0, 0x82, 0x1e, 0x8c, 0x18,
+  0x24, 0x00, 0x08, 0x82, 0x81, 0x61, 0x0b, 0x73, 0xa0, 0x0a, 0xac, 0x20,
+  0x0a, 0x72, 0x30, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0xc6, 0x2d, 0xd0,
+  0xc1, 0x2a, 0xb4, 0xc2, 0x1e, 0xcc, 0xc1, 0x88, 0x41, 0x02, 0x80, 0x20,
+  0x18, 0x18, 0xb8, 0x50, 0x07, 0xac, 0xe0, 0x0a, 0xa3, 0x40, 0x07, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0xe4, 0x82, 0x1d, 0xb4, 0xc2, 0x2b,
+  0x9c, 0x42, 0x1d, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x81, 0xa1, 0x0b,
+  0x77, 0x10, 0x0b, 0xb0, 0x60, 0x0a, 0x76, 0x30, 0x62, 0x90, 0x00, 0x20,
+  0x08, 0x06, 0xc6, 0x2e, 0xe0, 0x81, 0x2c, 0xc4, 0xc2, 0x1f, 0xdc, 0xc1,
+  0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x58, 0xb6, 0x50, 0x07, 0x87, 0x2c,
+  0x8c, 0x26, 0x04, 0xc1, 0x70, 0x44, 0x00, 0x05, 0xdf, 0x2c, 0x43, 0x12,
+  0x04, 0xc3, 0x11, 0x02, 0x14, 0x7c, 0xb3, 0x0c, 0xc2, 0x10, 0x8c, 0x18,
+  0x3c, 0x00, 0x08, 0x82, 0x41, 0xe3, 0x0b, 0x7f, 0xd0, 0x30, 0x46, 0x01,
+  0x41, 0xb6, 0x60, 0x0b, 0x7c, 0x00, 0x8d, 0x26, 0x04, 0xc0, 0x68, 0x82,
+  0x10, 0x8c, 0x26, 0x0c, 0xc2, 0x68, 0x02, 0x31, 0xcc, 0x12, 0x24, 0xc3,
+  0x11, 0x48, 0x17, 0x7c, 0xb3, 0x0c, 0x44, 0x11, 0x8c, 0x18, 0x3c, 0x00,
+  0x08, 0x82, 0x41, 0x43, 0x0e, 0xa5, 0x30, 0x49, 0xcc, 0x62, 0x59, 0xbc,
+  0xc0, 0x0b, 0xa2, 0x60, 0x8d, 0x26, 0x04, 0xc0, 0x88, 0xc1, 0x03, 0x80,
+  0x20, 0x18, 0x34, 0xe6, 0x70, 0x0a, 0x16, 0xe5, 0x34, 0x18, 0xe6, 0x0b,
+  0xbe, 0x40, 0x0a, 0xd8, 0x68, 0x42, 0x00, 0x8c, 0x26, 0x08, 0xc1, 0x88,
+  0xc1, 0x01, 0x80, 0x20, 0x18, 0x58, 0xe5, 0x40, 0x0a, 0xd6, 0x2f, 0x8c,
+  0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c, 0x26, 0x0c, 0x82, 0x0d, 0x08,
+  0x7c, 0x6c, 0x38, 0xe0, 0x63, 0xc3, 0x01, 0x9f, 0x11, 0x83, 0x03, 0x00,
+  0x41, 0x30, 0xb0, 0xd8, 0x61, 0x15, 0xba, 0x71, 0x18, 0x4d, 0x08, 0x80,
+  0xd1, 0x04, 0x21, 0x18, 0x4d, 0x18, 0x84, 0x11, 0x83, 0x05, 0x00, 0x41,
+  0x30, 0x78, 0xe6, 0x81, 0x16, 0x0e, 0xa3, 0x18, 0x84, 0x60, 0xc4, 0xe0,
+  0x00, 0x40, 0x10, 0x0c, 0xac, 0x78, 0x80, 0x05, 0x31, 0xa0, 0x85, 0xd1,
+  0x84, 0x00, 0x18, 0x4d, 0x10, 0x82, 0xd1, 0x84, 0x41, 0x18, 0x31, 0x58,
+  0x00, 0x10, 0x04, 0x83, 0x07, 0x1f, 0x72, 0x81, 0x59, 0x94, 0x41, 0x08,
+  0x46, 0x0c, 0x0e, 0x00, 0x04, 0xc1, 0xc0, 0xb2, 0x87, 0x5a, 0x38, 0x03,
+  0x5e, 0x18, 0x4d, 0x08, 0x80, 0xd1, 0x04, 0x21, 0x18, 0x4d, 0x18, 0x84,
+  0x11, 0x83, 0x05, 0x00, 0x41, 0x30, 0x78, 0xfa, 0xc1, 0x17, 0x22, 0xe8,
+  0x19, 0x84, 0x60, 0x96, 0x20, 0x19, 0x8e, 0x20, 0x03, 0x59, 0x08, 0xbe,
+  0x59, 0x06, 0xe3, 0x08, 0x46, 0x0c, 0x1e, 0x00, 0x04, 0xc1, 0xa0, 0x01,
+  0x89, 0x70, 0x78, 0x03, 0x37, 0x40, 0x83, 0x33, 0x90, 0x03, 0x39, 0xc0,
+  0x07, 0x7c, 0xf0, 0x05, 0x39, 0x18, 0x4d, 0x08, 0x80, 0x11, 0x83, 0x07,
+  0x00, 0x41, 0x30, 0x68, 0x44, 0x62, 0x1c, 0xe4, 0x00, 0x0e, 0xd4, 0x20,
+  0x0d, 0xe8, 0x80, 0x0e, 0xf4, 0x41, 0x1f, 0xc0, 0x81, 0x0e, 0x46, 0x13,
+  0x02, 0x60, 0x34, 0x41, 0x08, 0x46, 0x0c, 0x0e, 0x00, 0x04, 0xc1, 0xc0,
+  0x0a, 0x09, 0x70, 0x90, 0x83, 0x7d, 0x18, 0x4d, 0x08, 0x80, 0xd1, 0x04,
+  0x21, 0x18, 0x4d, 0x18, 0x04, 0x1b, 0x10, 0xf8, 0xd8, 0x60, 0xc0, 0xc7,
+  0x06, 0x04, 0x3e, 0x23, 0x06, 0x07, 0x00, 0x82, 0x60, 0x60, 0xa1, 0xc4,
+  0x39, 0xe4, 0xc1, 0x3f, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0xc2, 0x88, 0xc1, 0x02, 0x80, 0x20, 0x18, 0x3c, 0x2f, 0x01,
+  0x0f, 0x87, 0x51, 0x0c, 0x42, 0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06,
+  0x56, 0x4b, 0xb0, 0x83, 0x1f, 0xc0, 0xc3, 0x68, 0x42, 0x00, 0x8c, 0x26,
+  0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c, 0x18, 0x2c, 0x00, 0x08, 0x82, 0xc1,
+  0x43, 0x13, 0xf5, 0xc0, 0x2c, 0xca, 0x20, 0x04, 0x23, 0x06, 0x07, 0x00,
+  0x82, 0x60, 0x60, 0xc9, 0x44, 0x3c, 0x8c, 0x02, 0x3e, 0x8c, 0x26, 0x04,
+  0xc0, 0x68, 0x82, 0x10, 0x8c, 0x26, 0x0c, 0xc2, 0x88, 0xc1, 0x02, 0x80,
+  0x20, 0x18, 0x3c, 0x39, 0xa1, 0x0f, 0x11, 0xf4, 0x0c, 0x42, 0x30, 0x4b,
+  0x90, 0x0c, 0x47, 0x80, 0x02, 0x39, 0x04, 0xdf, 0x2c, 0x03, 0x92, 0x04,
+  0x23, 0x06, 0x0f, 0x00, 0x82, 0x60, 0xd0, 0xf0, 0x44, 0x3f, 0xac, 0x82,
+  0x2a, 0x90, 0xc2, 0x28, 0xb8, 0x82, 0x2b, 0xd0, 0x04, 0x4d, 0xe8, 0x83,
+  0x2b, 0x8c, 0x26, 0x04, 0xc0, 0x88, 0xc1, 0x03, 0x80, 0x20, 0x18, 0x34,
+  0x3e, 0xf1, 0x0f, 0xae, 0xc0, 0x0a, 0xa6, 0x50, 0x0a, 0xb0, 0x00, 0x0b,
+  0x36, 0x61, 0x13, 0xfc, 0x00, 0x0b, 0xa3, 0x09, 0x01, 0x30, 0x62, 0xf0,
+  0x00, 0x20, 0x08, 0x06, 0x0d, 0x58, 0x84, 0x44, 0x2c, 0xb8, 0x02, 0x2a,
+  0x9c, 0x82, 0x2c, 0xc8, 0x02, 0x4e, 0xe0, 0x84, 0x3f, 0xc8, 0xc2, 0x68,
+  0x42, 0x00, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x81, 0xe5, 0x13, 0xfd,
+  0xf0, 0x0a, 0x38, 0x31, 0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a,
+  0x30, 0x08, 0x36, 0x24, 0xf0, 0xb1, 0x01, 0x81, 0x8f, 0x0d, 0x07, 0x7c,
+  0x46, 0x0c, 0x0e, 0x00, 0x04, 0xc1, 0xc0, 0x2a, 0x0b, 0x92, 0xb0, 0x05,
+  0x9e, 0x18, 0x4d, 0x08, 0x80, 0xd1, 0x04, 0x21, 0x18, 0x4d, 0x18, 0x84,
+  0x11, 0x83, 0x05, 0x00, 0x41, 0x30, 0x78, 0xd8, 0xa2, 0x25, 0x0e, 0xa3,
+  0x18, 0x84, 0x60, 0xc4, 0xe0, 0x00, 0x40, 0x10, 0x0c, 0x2c, 0xb5, 0x48,
+  0x89, 0x5d, 0x68, 0x89, 0xd1, 0x84, 0x00, 0x18, 0x4d, 0x10, 0x82, 0xd1,
+  0x84, 0x41, 0x18, 0x31, 0x58, 0x00, 0x10, 0x04, 0x83, 0x27, 0x2e, 0x64,
+  0x82, 0x59, 0x94, 0x41, 0x08, 0x46, 0x0c, 0x0e, 0x00, 0x04, 0xc1, 0xc0,
+  0x7a, 0x0b, 0x97, 0x00, 0x87, 0x9a, 0x18, 0x4d, 0x08, 0x80, 0xd1, 0x04,
+  0x21, 0x18, 0x4d, 0x18, 0x84, 0x11, 0x83, 0x05, 0x00, 0x41, 0x30, 0x78,
+  0xec, 0xe2, 0x26, 0x22, 0xe8, 0x19, 0x84, 0x60, 0x96, 0x20, 0x19, 0xa8,
+  0x19, 0xe4, 0x42, 0x40, 0x09, 0x02, 0x16, 0x0c, 0x0b, 0xb1, 0x0d, 0xc0,
+  0x36, 0x8e, 0x81, 0x9a, 0x41, 0x2e, 0x04, 0x90, 0x20, 0x50, 0xc1, 0x70,
+  0x10, 0xdc, 0x00, 0x74, 0xe3, 0x18, 0xa8, 0x19, 0xe4, 0x42, 0xc0, 0x07,
+  0x02, 0x14, 0x0c, 0x03, 0xd1, 0x0d, 0x80, 0x37, 0x8e, 0x81, 0x9a, 0x41,
+  0x2e, 0x04, 0xde, 0x20, 0x78, 0xc3, 0xe0, 0x0d, 0x84, 0x37, 0x00, 0xde,
+  0x38, 0x46, 0x13, 0xc4, 0x41, 0x18, 0x8e, 0x08, 0x60, 0x22, 0xf8, 0x66,
+  0x19, 0x94, 0x25, 0x18, 0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0x88, 0x2f,
+  0xea, 0xc2, 0x18, 0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0xa8, 0x2f, 0xec,
+  0xc2, 0x18, 0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0xc8, 0x2f, 0xee, 0xc2,
+  0x18, 0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0xe8, 0x2f, 0x7a, 0x62, 0x18,
+  0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0x08, 0x34, 0x7c, 0x62, 0x18, 0x31,
+  0x30, 0x00, 0x10, 0x04, 0x83, 0x28, 0x34, 0x7e, 0x62, 0xb0, 0xe1, 0x1f,
+  0xe4, 0x63, 0x03, 0x48, 0xc8, 0xc7, 0x86, 0x90, 0x90, 0xcf, 0x88, 0x81,
+  0x01, 0x80, 0x20, 0x18, 0x44, 0xa5, 0x41, 0x16, 0xc3, 0x88, 0x81, 0x01,
+  0x80, 0x20, 0x18, 0x44, 0xa6, 0x51, 0x16, 0xc3, 0x88, 0x81, 0x01, 0x80,
+  0x20, 0x18, 0x44, 0xa7, 0x61, 0x16, 0x83, 0x0d, 0x26, 0x01, 0x1f, 0x1b,
+  0x4e, 0x02, 0x3e, 0x36, 0xa0, 0x04, 0x7c, 0x46, 0x0c, 0x0e, 0x00, 0x04,
+  0xc1, 0x60, 0x52, 0x0d, 0xb9, 0x18, 0x42, 0x62, 0xc4, 0xe0, 0x00, 0x40,
+  0x10, 0x0c, 0xa6, 0xd5, 0x98, 0x8b, 0x41, 0x24, 0x46, 0x0c, 0x0e, 0x00,
+  0x04, 0xc1, 0x60, 0x62, 0x0d, 0xba, 0x18, 0x46, 0xc2, 0x92, 0x96, 0x90,
+  0x8f, 0x25, 0x2e, 0x21, 0x1f, 0x4b, 0x5e, 0x42, 0x3e, 0x16, 0x13, 0x43,
+  0x7c, 0x4c, 0x26, 0x86, 0xf8, 0xd8, 0x4c, 0x0c, 0xf1, 0xb1, 0x64, 0xa0,
+  0x8f, 0x25, 0x03, 0x7d, 0x2c, 0x19, 0xe8, 0x33, 0x62, 0x60, 0x00, 0x20,
+  0x08, 0x06, 0xd1, 0x6d, 0xc0, 0xc6, 0x30, 0x62, 0x60, 0x00, 0x20, 0x08,
+  0x06, 0x11, 0x6e, 0xc4, 0xc6, 0x30, 0x62, 0x60, 0x00, 0x20, 0x08, 0x06,
+  0x51, 0x6e, 0xc8, 0xc6, 0x30, 0x62, 0x60, 0x00, 0x20, 0x08, 0x06, 0x91,
+  0x6e, 0xe0, 0xc5, 0x30, 0x62, 0x60, 0x00, 0x20, 0x08, 0x06, 0xd1, 0x6e,
+  0xe4, 0xc5, 0x30, 0x62, 0x60, 0x00, 0x20, 0x08, 0x06, 0x11, 0x6f, 0xe8,
+  0xc5, 0x60, 0x83, 0x4f, 0xc8, 0xc7, 0x86, 0x9f, 0x90, 0x8f, 0x0d, 0x60,
+  0x21, 0x9f, 0x11, 0x03, 0x03, 0x00, 0x41, 0x30, 0x88, 0xc0, 0xe3, 0x2f,
+  0x86, 0x11, 0x03, 0x03, 0x00, 0x41, 0x30, 0x88, 0xc2, 0x03, 0x34, 0x86,
+  0x11, 0x03, 0x03, 0x00, 0x41, 0x30, 0x88, 0xc4, 0x23, 0x34, 0x06, 0x1b,
+  0xfc, 0x42, 0x3e, 0x36, 0xfc, 0x85, 0x7c, 0x6c, 0x00, 0x0d, 0xf9, 0x8c,
+  0x18, 0x1c, 0x00, 0x08, 0x82, 0x81, 0x45, 0x1e, 0xa3, 0x51, 0x13, 0xe1,
+  0x31, 0x9a, 0x10, 0x0c, 0x56, 0x04, 0xf4, 0xb1, 0x42, 0xa0, 0x8f, 0x15,
+  0x03, 0x7d, 0x66, 0x09, 0x96, 0x81, 0x8a, 0xc1, 0x50, 0xd4, 0x21, 0x19,
+  0xa8, 0x18, 0x0c, 0x45, 0x1d, 0x92, 0x81, 0x8a, 0xc1, 0x50, 0xd4, 0x21,
+  0x19, 0x31, 0x38, 0x00, 0x10, 0x04, 0x03, 0x8b, 0x3d, 0x56, 0xa3, 0x27,
+  0xd2, 0x63, 0x34, 0x21, 0x00, 0x86, 0x23, 0x02, 0xb3, 0x70, 0xbe, 0x59,
+  0x06, 0xa6, 0x0a, 0x86, 0x23, 0x04, 0xb3, 0x08, 0xbe, 0x59, 0x86, 0xc6,
+  0x09, 0x46, 0x13, 0x88, 0xc0, 0x02, 0x44, 0x3e, 0x26, 0x20, 0xf2, 0xb1,
+  0x01, 0x91, 0xcf, 0x2c, 0x41, 0x35, 0x1c, 0x71, 0xc8, 0x45, 0xf0, 0xcd,
+  0x32, 0x3c, 0x55, 0x30, 0x1c, 0xd1, 0x07, 0x73, 0x11, 0x7c, 0xb3, 0x0c,
+  0x50, 0x14, 0x58, 0x23, 0x1a, 0xf2, 0x19, 0x31, 0x40, 0x00, 0x10, 0x04,
+  0x03, 0xcc, 0x3e, 0x6a, 0x43, 0x34, 0x9a, 0x60, 0xc4, 0x00, 0x01, 0x40,
+  0x10, 0x0c, 0xb0, 0xfb, 0xb0, 0x0d, 0xd1, 0x68, 0x02, 0x83, 0x44, 0x43,
+  0x3e, 0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0x80, 0xe5, 0x07, 0x6e, 0x88,
+  0x06, 0x14, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0x01, 0xa6, 0x1f, 0xb9,
+  0x21, 0x1a, 0x50, 0x60, 0x93, 0x68, 0xc8, 0x67, 0xc4, 0x00, 0x01, 0x40,
+  0x10, 0x0c, 0x30, 0xfe, 0xd8, 0x0d, 0xd1, 0x98, 0x82, 0x11, 0x03, 0x04,
+  0x00, 0x41, 0x30, 0xc0, 0xfa, 0x83, 0x37, 0x44, 0x63, 0x0a, 0x66, 0x09,
+  0xa2, 0x81, 0x8a, 0xc1, 0x81, 0xd8, 0xe0, 0x19, 0xa8, 0x18, 0x14, 0x88,
+  0x0d, 0x9e, 0x81, 0x8a, 0xc1, 0x80, 0xd8, 0xe0, 0x19, 0x31, 0x38, 0x00,
+  0x10, 0x04, 0x83, 0x69, 0x44, 0xd6, 0x43, 0x08, 0x46, 0x0c, 0x0e, 0x00,
+  0x04, 0xc1, 0x60, 0x22, 0x11, 0xf6, 0x20, 0x82, 0xe1, 0x88, 0x80, 0x2f,
+  0x84, 0x6f, 0x96, 0x41, 0x9a, 0x82, 0xd1, 0x84, 0x2c, 0xb0, 0x60, 0x90,
+  0x8f, 0x05, 0x7e, 0x01, 0x9f, 0xd1, 0x04, 0x4e, 0xb0, 0xc0, 0x90, 0x8f,
+  0x05, 0xa1, 0x01, 0x1f, 0x23, 0x02, 0xfa, 0x58, 0xd0, 0xc8, 0xc7, 0x84,
+  0x46, 0x3e, 0x36, 0x34, 0xf2, 0x99, 0x25, 0x98, 0x06, 0x2a, 0x06, 0x43,
+  0x02, 0x83, 0x68, 0xa0, 0x62, 0x30, 0x24, 0x30, 0x88, 0x06, 0x2a, 0x06,
+  0x43, 0x02, 0x83, 0x68, 0x96, 0x81, 0xaa, 0x3a, 0x1b, 0xd0, 0x43, 0x3e,
+  0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0x80, 0xc9, 0x48, 0x7c, 0xa0, 0xc7,
+  0x10, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0x01, 0x36, 0x23, 0xf2, 0x81,
+  0x1e, 0x43, 0x60, 0x06, 0x7a, 0xc8, 0x67, 0xc4, 0x00, 0x01, 0x40, 0x10,
+  0x0c, 0xb0, 0x1a, 0xa1, 0x0f, 0xf4, 0x30, 0x82, 0x11, 0x03, 0x04, 0x00,
+  0x41, 0x30, 0xc0, 0x6c, 0xa4, 0x3e, 0xd0, 0xc3, 0x08, 0x2c, 0x41, 0x0f,
+  0xf9, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0x01, 0x86, 0x23, 0xf7, 0x81,
+  0x1e, 0x49, 0x30, 0x62, 0x80, 0x00, 0x20, 0x08, 0x06, 0x58, 0x8e, 0xe0,
+  0x07, 0x7a, 0x24, 0xc1, 0x2c, 0x41, 0x35, 0xd0, 0x32, 0x90, 0xc3, 0x42,
+  0x0b, 0x8d, 0x43, 0x61, 0x13, 0x39, 0x38, 0x03, 0x2d, 0x03, 0x39, 0x2c,
+  0xb4, 0xd0, 0x28, 0x14, 0x36, 0x91, 0x83, 0x33, 0xd0, 0x32, 0x90, 0xc3,
+  0x42, 0x0b, 0x8d, 0x41, 0x61, 0x13, 0x39, 0x38, 0xc3, 0x11, 0xe6, 0x50,
+  0x1b, 0xc1, 0x37, 0xcb, 0x60, 0x85, 0x41, 0x30, 0x9a, 0x90, 0x1a, 0xc0,
+  0x70, 0x44, 0x80, 0x1b, 0xce, 0x37, 0xcb, 0x70, 0x81, 0x41, 0x30, 0x1c,
+  0x61, 0xf4, 0x87, 0xf2, 0xcd, 0x32, 0x64, 0x58, 0x60, 0x47, 0x7f, 0xc8,
+  0x67, 0x96, 0x40, 0x33, 0xa4, 0x3f, 0xe0, 0x33, 0x62, 0x60, 0x00, 0x20,
+  0x08, 0x06, 0x91, 0x99, 0xfc, 0x48, 0x60, 0x81, 0x7f, 0xc8, 0x67, 0xc4,
+  0xc0, 0x00, 0x40, 0x10, 0x0c, 0x22, 0x34, 0x31, 0x91, 0xc0, 0x82, 0xff,
+  0x90, 0xcf, 0x88, 0x81, 0x01, 0x80, 0x20, 0x18, 0x44, 0x6a, 0x92, 0x22,
+  0xc1, 0x2c, 0x81, 0x36, 0x50, 0x31, 0x38, 0x98, 0x90, 0x0d, 0x47, 0x38,
+  0x26, 0xa2, 0x7c, 0xb3, 0x0c, 0xdc, 0x16, 0xd8, 0x63, 0x22, 0xf2, 0x99,
+  0x25, 0xe8, 0x0c, 0x32, 0x11, 0xf8, 0x8c, 0x18, 0x18, 0x00, 0x08, 0x82,
+  0x41, 0xf4, 0x26, 0x68, 0x12, 0x58, 0x70, 0x22, 0xf2, 0x19, 0x31, 0x30,
+  0x00, 0x10, 0x04, 0x83, 0x28, 0x4e, 0x5e, 0x24, 0xb0, 0x00, 0x45, 0xe4,
+  0x33, 0x62, 0x60, 0x00, 0x20, 0x08, 0x06, 0xd1, 0x9c, 0xc8, 0x48, 0x30,
+  0x4b, 0xd0, 0x0d, 0x54, 0x0c, 0xce, 0x26, 0x70, 0xc3, 0x11, 0xd6, 0x8b,
+  0x28, 0xdf, 0x2c, 0xc3, 0xe7, 0x05, 0x76, 0xbd, 0x88, 0x7c, 0x66, 0x09,
+  0xc0, 0xc0, 0xb0, 0x17, 0x81, 0xcf, 0x88, 0x81, 0x01, 0x80, 0x20, 0x18,
+  0x44, 0x78, 0x12, 0x27, 0x81, 0x05, 0x30, 0x22, 0x9f, 0x11, 0x03, 0x03,
+  0x00, 0x41, 0x30, 0x88, 0xf4, 0x04, 0x47, 0x02, 0x0b, 0x62, 0x44, 0x3e,
+  0x23, 0x06, 0x06, 0x00, 0x82, 0x60, 0x10, 0xf1, 0xc9, 0x8e, 0x04, 0xb3,
+  0x04, 0x60, 0x30, 0xd0, 0x31, 0x80, 0x82, 0x45, 0x06, 0x1f, 0x19, 0x78,
+  0x03, 0x1d, 0x03, 0x28, 0x58, 0xd4, 0x47, 0x79, 0x03, 0x1d, 0x03, 0x28,
+  0x58, 0xc6, 0x27, 0x79, 0xa3, 0x09, 0xe8, 0x31, 0x58, 0x40, 0xc8, 0xc7,
+  0x04, 0x42, 0x3e, 0x36, 0x10, 0xf2, 0x99, 0x25, 0xd0, 0x83, 0xe1, 0x08,
+  0x95, 0x00, 0x91, 0xe0, 0x1b, 0x4d, 0x68, 0x8f, 0x61, 0x96, 0x41, 0x0c,
+  0xda, 0x40, 0xb0, 0x20, 0x0d, 0xe4, 0x63, 0x42, 0x1a, 0xc8, 0xc7, 0x86,
+  0x34, 0x90, 0xcf, 0x68, 0x42, 0x7c, 0x00, 0xc3, 0x11, 0x01, 0x88, 0x38,
+  0xdf, 0x2c, 0x83, 0x1e, 0x8c, 0x41, 0x30, 0x1c, 0x51, 0x88, 0x88, 0xf2,
+  0xcd, 0x32, 0x94, 0x01, 0x19, 0x04, 0x66, 0x90, 0x88, 0x7c, 0x66, 0x09,
+  0xcc, 0x60, 0xc4, 0xc0, 0x00, 0x40, 0x10, 0x0c, 0xa2, 0x56, 0x31, 0x95,
+  0x63, 0xc4, 0xc0, 0x00, 0x40, 0x10, 0x0c, 0x22, 0x57, 0x61, 0x93, 0xc0,
+  0x02, 0x14, 0x91, 0xcf, 0x88, 0x81, 0x01, 0x80, 0x20, 0x18, 0x44, 0xb0,
+  0xf2, 0x26, 0x81, 0x05, 0x2b, 0x22, 0x1f, 0x0b, 0x5a, 0x04, 0x3e, 0xb3,
+  0x04, 0x66, 0x30, 0x50, 0x31, 0x38, 0x64, 0x20, 0x94, 0xc1, 0x70, 0x44,
+  0xb3, 0x22, 0xca, 0x37, 0xcb, 0x80, 0x06, 0x67, 0x10, 0x98, 0xd3, 0x22,
+  0xf2, 0x99, 0x25, 0x48, 0x83, 0x11, 0x03, 0x03, 0x00, 0x41, 0x30, 0x88,
+  0x6c, 0xe5, 0x55, 0x9e, 0x11, 0x03, 0x03, 0x00, 0x41, 0x30, 0x88, 0x6e,
+  0xa5, 0x4e, 0x02, 0x0b, 0x62, 0x44, 0x3e, 0x23, 0x06, 0x06, 0x00, 0x82,
+  0x60, 0x10, 0xe5, 0x0a, 0x9e, 0x04, 0x16, 0xd0, 0x88, 0x7c, 0x2c, 0xb0,
+  0x11, 0xf8, 0xcc, 0x12, 0xa4, 0xc1, 0x40, 0xc5, 0xe0, 0x9c, 0x81, 0x80,
+  0x06, 0xc3, 0x11, 0x15, 0x8d, 0x28, 0xdf, 0x2c, 0xc3, 0x1a, 0xa8, 0x41,
+  0x60, 0x96, 0x8d, 0xc8, 0x67, 0x96, 0x80, 0x0d, 0x46, 0x0c, 0x0c, 0x00,
+  0x04, 0xc1, 0x20, 0xfa, 0x15, 0x5c, 0xb9, 0x46, 0x0c, 0x0c, 0x00, 0x04,
+  0xc1, 0x20, 0x02, 0x17, 0x3f, 0x09, 0x2c, 0xd0, 0x11, 0xf9, 0x8c, 0x18,
+  0x18, 0x00, 0x08, 0x82, 0x41, 0x24, 0x2e, 0xa1, 0x12, 0x58, 0xd0, 0x23,
+  0xf2, 0xb1, 0xe0, 0x47, 0xe0, 0x33, 0x4b, 0xc0, 0x06, 0x03, 0x15, 0x83,
+  0xa3, 0x06, 0xc2, 0x1a, 0x8c, 0x18, 0x18, 0x00, 0x08, 0x82, 0x41, 0x64,
+  0x2e, 0xab, 0x32, 0x8d, 0x18, 0x18, 0x00, 0x08, 0x82, 0x41, 0x74, 0x2e,
+  0xac, 0xb2, 0x8c, 0x18, 0x18, 0x00, 0x08, 0x82, 0x41, 0x84, 0x2e, 0xad,
+  0x32, 0xcc, 0x12, 0xe8, 0xc1, 0x2c, 0x83, 0x1b, 0xe4, 0x81, 0x5b, 0x18,
+  0x2b, 0xf4, 0x89, 0x7c, 0x46, 0x0c, 0x10, 0x00, 0x04, 0xc1, 0x00, 0x3b,
+  0x17, 0x53, 0xe9, 0x13, 0x56, 0x08, 0x46, 0x0c, 0x10, 0x00, 0x04, 0xc1,
+  0x00, 0x43, 0x97, 0x53, 0xe9, 0x13, 0x56, 0x08, 0xec, 0x15, 0xfa, 0x44,
+  0x3e, 0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0x80, 0xa9, 0x4b, 0xaa, 0xf4,
+  0xc9, 0x2b, 0x04, 0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0x80, 0xad, 0x8b,
+  0xaa, 0xf4, 0xc9, 0x2b, 0x04, 0x26, 0x0b, 0x7d, 0x22, 0x9f, 0x11, 0x03,
+  0x04, 0x00, 0x41, 0x30, 0xc0, 0xda, 0x85, 0x55, 0xfa, 0x44, 0x16, 0x82,
+  0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0xc0, 0xdc, 0xa5, 0x55, 0xfa, 0x44,
+  0x16, 0x02, 0x6b, 0x83, 0x43, 0x3e, 0xe6, 0x06, 0x85, 0x7c, 0xec, 0x0d,
+  0x06, 0xf9, 0x8c, 0x26, 0xf4, 0x08, 0x30, 0x1c, 0x11, 0xb0, 0x89, 0xf3,
+  0xcd, 0x32, 0xe8, 0xc1, 0x1b, 0x04, 0xc3, 0x11, 0x85, 0x9b, 0x28, 0xdf,
+  0x2c, 0x43, 0x1c, 0xc0, 0x41, 0x60, 0x06, 0x9c, 0xc8, 0x67, 0x96, 0x40,
+  0x0e, 0x46, 0x0c, 0x0c, 0x00, 0x04, 0xc1, 0x20, 0xca, 0x17, 0x79, 0x39,
+  0x46, 0x0c, 0x0c, 0x00, 0x04, 0xc1, 0x20, 0xd2, 0x17, 0x5c, 0x09, 0x2c,
+  0xa0, 0x13, 0xf9, 0x8c, 0x18, 0x18, 0x00, 0x08, 0x82, 0x41, 0xc4, 0x2f,
+  0xbb, 0x12, 0x58, 0x70, 0x27, 0xf2, 0xb1, 0x20, 0x4f, 0xe0, 0x33, 0x4b,
+  0x20, 0x07, 0x03, 0x15, 0x83, 0x03, 0x07, 0x42, 0x1c, 0x0c, 0x47, 0x34,
+  0x77, 0xa2, 0x7c, 0xb3, 0x0c, 0x74, 0x30, 0x07, 0x81, 0x39, 0x79, 0x22,
+  0x9f, 0x59, 0x82, 0x3a, 0x18, 0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0x48,
+  0x64, 0xf6, 0xe5, 0x19, 0x31, 0x30, 0x00, 0x10, 0x04, 0x83, 0x68, 0x64,
+  0xc2, 0x25, 0xb0, 0xa0, 0x4f, 0xe4, 0x33, 0x62, 0x60, 0x00, 0x20, 0x08,
+  0x06, 0x51, 0xc9, 0x90, 0x4b, 0x60, 0x01, 0xa8, 0xc8, 0xc7, 0x02, 0x51,
+  0x81, 0xcf, 0x2c, 0x41, 0x1d, 0x0c, 0x54, 0x0c, 0xce, 0x1c, 0x08, 0x74,
+  0x30, 0x1c, 0x51, 0x81, 0x8a, 0xf2, 0xcd, 0x32, 0xdc, 0x81, 0x1d, 0x04,
+  0x66, 0x89, 0x8a, 0x7c, 0x66, 0x09, 0xf0, 0x60, 0xc4, 0xc0, 0x00, 0x40,
+  0x10, 0x0c, 0xa2, 0x95, 0x21, 0x99, 0x6b, 0xc4, 0xc0, 0x00, 0x40, 0x10,
+  0x0c, 0x22, 0x96, 0x51, 0x97, 0xc0, 0x02, 0x53, 0x91, 0xcf, 0x88, 0x81,
+  0x01, 0x80, 0x20, 0x18, 0x44, 0x2e, 0xd3, 0x2e, 0x81, 0x05, 0xa9, 0x22,
+  0x1f, 0x0b, 0x56, 0x05, 0x3e, 0xb3, 0x04, 0x78, 0x30, 0x50, 0x31, 0x38,
+  0x76, 0x20, 0xdc, 0xc1, 0x88, 0x81, 0x01, 0x80, 0x20, 0x18, 0x44, 0x32,
+  0x73, 0x2f, 0xd3, 0x88, 0x81, 0x01, 0x80, 0x20, 0x18, 0x44, 0x33, 0x83,
+  0x2f, 0xcb, 0x88, 0x81, 0x01, 0x80, 0x20, 0x18, 0x44, 0x34, 0x93, 0x2f,
+  0xc3, 0x2c, 0x81, 0x1e, 0x18, 0x2c, 0xe0, 0x83, 0x7c, 0x2c, 0x16, 0xf0,
+  0x41, 0x3e, 0x26, 0x0b, 0xf8, 0x20, 0x9f, 0x59, 0x02, 0x3d, 0x18, 0xa8,
+  0x19, 0xdc, 0x02, 0x0c, 0x8c, 0x3c, 0x20, 0x0b, 0x31, 0x20, 0x07, 0x36,
+  0x60, 0x05, 0x37, 0x60, 0xf0, 0x60, 0xa0, 0x66, 0x70, 0x0b, 0x30, 0x30,
+  0xf2, 0x80, 0x2c, 0xc4, 0x80, 0x1c, 0xd8, 0x80, 0x15, 0xdc, 0x80, 0xc1,
+  0x83, 0x81, 0x9a, 0xc1, 0x2d, 0xc0, 0xc0, 0xc8, 0x03, 0xb2, 0x10, 0x03,
+  0x72, 0x60, 0x03, 0x56, 0x70, 0x03, 0x06, 0x0f, 0x6c, 0x48, 0x15, 0xf9,
+  0xd8, 0x90, 0x2a, 0xf2, 0xb1, 0x21, 0x55, 0xe4, 0x63, 0xe5, 0x91, 0x2a,
+  0xf2, 0x19, 0x31, 0x48, 0x00, 0x10, 0x04, 0x03, 0x44, 0x6c, 0x46, 0x26,
+  0x67, 0x72, 0xe6, 0x65, 0x88, 0x11, 0x83, 0x04, 0x00, 0x41, 0x30, 0x40,
+  0xc4, 0x66, 0x64, 0x72, 0x26, 0x67, 0x4e, 0x66, 0x18, 0x31, 0x48, 0x00,
+  0x10, 0x04, 0x03, 0x44, 0x6c, 0x46, 0x26, 0x67, 0x72, 0xc6, 0x65, 0x84,
+  0x11, 0x83, 0x04, 0x00, 0x41, 0x30, 0x40, 0xc4, 0x66, 0x64, 0x72, 0x26,
+  0x67, 0x62, 0x26, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Advanced.hlsl b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Advanced.hlsl
new file mode 100644
index 0000000..1c869b8
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Advanced.hlsl
@@ -0,0 +1,8 @@
+
+#include "D3D12_PixelShader_Common.hlsli"
+
+[RootSignature(AdvancedRS)]
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    return AdvancedPixelShader(input);
+}
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Colors.h b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Colors.h
new file mode 100644
index 0000000..7b1a917
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Colors.h
@@ -0,0 +1,490 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Position              0   xyzw        0      POS   float       
+; TEXCOORD                 0   xy          1     NONE   float       
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Target                0   xyzw        0   TARGET   float   xyzw
+;
+; shader hash: cef595d746206d54840a8f4fa9597d19
+;
+; Pipeline Runtime Information: 
+;
+; Pixel Shader
+; DepthOutput=0
+; SampleFrequency=0
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Position              0          noperspective       
+; TEXCOORD                 0                 linear       
+; COLOR                    0                 linear       
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Target                0                              
+;
+; Buffer Definitions:
+;
+; cbuffer Constants
+; {
+;
+;   struct Constants
+;   {
+;
+;       float scRGB_output;                           ; Offset:    0
+;       float texture_type;                           ; Offset:    4
+;       float input_type;                             ; Offset:    8
+;       float color_scale;                            ; Offset:   12
+;       float tonemap_method;                         ; Offset:   16
+;       float tonemap_factor1;                        ; Offset:   20
+;       float tonemap_factor2;                        ; Offset:   24
+;       float sdr_white_point;                        ; Offset:   28
+;       float4 Yoffset;                               ; Offset:   32
+;       float4 Rcoeff;                                ; Offset:   48
+;       float4 Gcoeff;                                ; Offset:   64
+;       float4 Bcoeff;                                ; Offset:   80
+;   
+;   } Constants;                                      ; Offset:    0 Size:    96
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; Constants                         cbuffer      NA          NA     CB0            cb1     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 12, outputs: 4
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 8 }
+;   output 1 depends on inputs: { 9 }
+;   output 2 depends on inputs: { 10 }
+;   output 3 depends on inputs: { 11 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%Constants = type { float, float, float, float, float, float, float, float, <4 x float>, <4 x float>, <4 x float>, <4 x float> }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 1, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %7 = extractvalue %dx.types.CBufRet.f32 %6, 3
+  %8 = fmul fast float %7, %2
+  %9 = fmul fast float %7, %3
+  %10 = fmul fast float %7, %4
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %8)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %9)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %10)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %5)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"clang version 3.7 (tags/RELEASE_370/final)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 6}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %Constants* undef, !"", i32 0, i32 1, i32 1, i32 96, null}
+!7 = !{[14 x i32] [i32 12, i32 4, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 1, i32 2, i32 4, i32 8]}
+!8 = !{void ()* @main, !"main", !9, !4, null}
+!9 = !{!10, !16, null}
+!10 = !{!11, !13, !14}
+!11 = !{i32 0, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 0, i8 0, null}
+!12 = !{i32 0}
+!13 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 2, i32 1, i8 0, null}
+!14 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 2, i8 0, !15}
+!15 = !{i32 3, i32 15}
+!16 = !{!17}
+!17 = !{i32 0, !"SV_Target", i8 9, i8 16, !12, i8 0, i32 1, i8 4, i32 0, i8 0, !15}
+
+#endif
+
+const unsigned char g_main[] = {
+  0x44, 0x58, 0x42, 0x43, 0xe0, 0x6a, 0x51, 0x4c, 0x14, 0x1a, 0x6a, 0x67,
+  0x04, 0x23, 0x10, 0x54, 0xf8, 0xe3, 0xa6, 0x1a, 0x01, 0x00, 0x00, 0x00,
+  0xb1, 0x0f, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x15, 0x01, 0x00, 0x00,
+  0x01, 0x02, 0x00, 0x00, 0x51, 0x02, 0x00, 0x00, 0x85, 0x09, 0x00, 0x00,
+  0xa1, 0x09, 0x00, 0x00, 0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31,
+  0x83, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c,
+  0x4f, 0x52, 0x00, 0x4f, 0x53, 0x47, 0x31, 0x32, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74,
+  0x00, 0x50, 0x53, 0x56, 0x30, 0xe4, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x03, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43,
+  0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x44, 0x03, 0x03, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x42, 0x00, 0x03, 0x02, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x44,
+  0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x44, 0x10, 0x03, 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, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x52, 0x54, 0x53,
+  0x30, 0x48, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00,
+  0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54, 0x2c, 0x07, 0x00,
+  0x00, 0x60, 0x00, 0x00, 0x00, 0xcb, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49,
+  0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x14, 0x07, 0x00,
+  0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xc2, 0x01, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e,
+  0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8,
+  0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08,
+  0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x21, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4,
+  0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a,
+  0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x5c, 0x23, 0x00, 0x25, 0x00, 0x14,
+  0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84,
+  0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb,
+  0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2,
+  0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e,
+  0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30,
+  0x42, 0x6d, 0x8e, 0x20, 0x28, 0x06, 0x23, 0x85, 0x90, 0x47, 0x70, 0x20,
+  0x60, 0x18, 0x81, 0x18, 0x2e, 0xe1, 0x9c, 0x46, 0x9a, 0x80, 0x66, 0x92,
+  0x10, 0x33, 0xc6, 0x18, 0x63, 0x8c, 0x31, 0xe7, 0x9c, 0x44, 0xd3, 0x81,
+  0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87,
+  0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0,
+  0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10,
+  0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2,
+  0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
+  0xe4, 0x81, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x0b, 0x04, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x1c, 0x50, 0x06, 0xe5, 0x50,
+  0x12, 0x85, 0x50, 0x10, 0x85, 0x51, 0x20, 0x85, 0x52, 0x30, 0x85, 0x53,
+  0x40, 0x05, 0x56, 0x80, 0x01, 0x05, 0x1a, 0x50, 0x04, 0xe5, 0x41, 0xa5,
+  0x24, 0xca, 0xa0, 0x10, 0x46, 0x00, 0x8a, 0xa0, 0x40, 0xe8, 0xd5, 0x00,
+  0xd1, 0x19, 0x00, 0xaa, 0x33, 0x00, 0x64, 0xc7, 0x72, 0x18, 0x02, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xc9, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13,
+  0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b,
+  0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b,
+  0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9,
+  0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0xa2, 0x98, 0x20, 0x10, 0xc6, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04,
+  0x41, 0x01, 0x6e, 0x6e, 0x82, 0x40, 0x1c, 0x1b, 0x86, 0x03, 0x21, 0x26,
+  0x08, 0x55, 0x18, 0x30, 0x19, 0x7a, 0x73, 0x9b, 0xa3, 0x0b, 0x73, 0xa3,
+  0x9b, 0x9b, 0x20, 0x10, 0xc8, 0x06, 0x84, 0x50, 0x16, 0x62, 0x18, 0x18,
+  0x60, 0x43, 0xd0, 0x6c, 0x20, 0x00, 0xc0, 0x01, 0x26, 0x08, 0x14, 0x18,
+  0x90, 0x99, 0x1b, 0x93, 0x3a, 0x12, 0xfa, 0x7a, 0xab, 0xa3, 0x83, 0xab,
+  0xa3, 0x9b, 0x20, 0x10, 0xc9, 0x04, 0x81, 0x50, 0x26, 0x08, 0xc4, 0xb2,
+  0xc1, 0x40, 0x22, 0x89, 0x98, 0x28, 0x32, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x13, 0x04, 0x82, 0xd9, 0x60,
+  0x20, 0x96, 0x74, 0x4d, 0x14, 0x95, 0x34, 0x37, 0xb8, 0x3a, 0xba, 0x2f,
+  0xba, 0x3c, 0xb8, 0xb2, 0x09, 0x02, 0xd1, 0x6c, 0x30, 0x90, 0x4c, 0xd2,
+  0x26, 0x8a, 0xcb, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0xd7, 0xdc, 0x58, 0x18,
+  0x5b, 0xd9, 0x04, 0x81, 0x70, 0x26, 0x08, 0xcf, 0xb7, 0x01, 0x41, 0x38,
+  0xa9, 0x9b, 0x28, 0xca, 0xa3, 0x43, 0xf7, 0xe6, 0x56, 0xd6, 0x16, 0x06,
+  0xf7, 0xd5, 0x56, 0x46, 0x87, 0xf6, 0x46, 0x36, 0x41, 0x20, 0x9e, 0x0d,
+  0x06, 0x02, 0x06, 0x52, 0x18, 0x4c, 0x14, 0x1f, 0xba, 0x37, 0xb7, 0xb2,
+  0xb6, 0x30, 0xb8, 0x2f, 0xb3, 0xb0, 0x31, 0xba, 0x37, 0xb9, 0x98, 0x09,
+  0x02, 0x01, 0x6d, 0x30, 0x90, 0x31, 0x90, 0xc8, 0x60, 0xa2, 0xf8, 0xd0,
+  0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1, 0x7d, 0x99, 0x85, 0x8d, 0xd1, 0xbd,
+  0xc9, 0xc9, 0x4c, 0x10, 0x88, 0x68, 0x83, 0x81, 0x98, 0x81, 0x74, 0x06,
+  0x13, 0xc5, 0x67, 0x8e, 0x4c, 0xee, 0xeb, 0x0e, 0x2d, 0x8d, 0xae, 0xec,
+  0x0b, 0xee, 0x2d, 0xcd, 0x8d, 0x6e, 0x82, 0x40, 0x48, 0x1b, 0x0c, 0x24,
+  0x0d, 0x24, 0x35, 0x98, 0x28, 0x1e, 0x59, 0x6f, 0x66, 0x66, 0x73, 0x65,
+  0x74, 0x13, 0x04, 0x62, 0xda, 0x60, 0x20, 0x6c, 0x20, 0xb5, 0xc1, 0x44,
+  0xd1, 0x90, 0x1a, 0x7b, 0x2b, 0x33, 0x33, 0x9b, 0x20, 0x10, 0xd4, 0x06,
+  0x03, 0x79, 0x03, 0x09, 0x0e, 0x26, 0x8a, 0xc6, 0xd1, 0xd8, 0x5b, 0x99,
+  0x99, 0xd9, 0x04, 0x81, 0xa8, 0x36, 0x18, 0x88, 0x1c, 0x48, 0x73, 0x30,
+  0x51, 0x34, 0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x26, 0x08, 0x84, 0xb5,
+  0xc1, 0x40, 0xea, 0x40, 0xb2, 0x83, 0x89, 0xda, 0xd0, 0x30, 0x15, 0xb6,
+  0x7d, 0x62, 0x50, 0x06, 0x68, 0xb0, 0x06, 0x6e, 0x10, 0x07, 0x74, 0x70,
+  0x07, 0x1b, 0x06, 0x02, 0xc2, 0x83, 0x09, 0x82, 0x00, 0x6c, 0x00, 0x36,
+  0x0c, 0xc4, 0x1e, 0xec, 0xc1, 0x86, 0x80, 0x0f, 0x36, 0x0c, 0x83, 0x1e,
+  0xf4, 0xc1, 0x04, 0xc1, 0x12, 0x83, 0x0d, 0xc1, 0x1f, 0x90, 0x68, 0x0b,
+  0x4b, 0x73, 0xe3, 0x32, 0x65, 0xf5, 0x05, 0xf5, 0x36, 0x97, 0x46, 0x97,
+  0xf6, 0xe6, 0x36, 0x41, 0x28, 0xb2, 0x09, 0x42, 0xa1, 0x6d, 0x08, 0x88,
+  0x09, 0x42, 0xb1, 0x4d, 0x10, 0x0a, 0x6e, 0xc3, 0x42, 0x88, 0xc2, 0x28,
+  0x90, 0x42, 0x29, 0x98, 0xc2, 0x60, 0x0a, 0xc4, 0x29, 0x00, 0x44, 0xa8,
+  0x8a, 0xb0, 0x86, 0x9e, 0x9e, 0xa4, 0x88, 0x26, 0x08, 0x45, 0xb7, 0x61,
+  0x19, 0x52, 0x61, 0x14, 0x4e, 0xa1, 0x14, 0x54, 0x61, 0x50, 0x85, 0xe1,
+  0x14, 0x80, 0x09, 0x02, 0x71, 0xb1, 0x18, 0x7a, 0x62, 0x7a, 0x92, 0x9a,
+  0x20, 0x10, 0xd8, 0x06, 0x41, 0x72, 0x85, 0x0d, 0x0b, 0x2b, 0xb4, 0xc2,
+  0x28, 0x9c, 0x42, 0x29, 0xa8, 0xc2, 0x60, 0x0a, 0xac, 0x70, 0x0a, 0xaf,
+  0xb0, 0x61, 0x40, 0x85, 0x55, 0x80, 0x05, 0x26, 0x53, 0x56, 0x5f, 0x54,
+  0x61, 0x72, 0x67, 0x65, 0x74, 0x13, 0x84, 0xc2, 0xdb, 0xb0, 0x10, 0xb2,
+  0x30, 0x0a, 0xb3, 0x50, 0x0a, 0xa7, 0x30, 0x98, 0x02, 0x71, 0x0a, 0xaf,
+  0xb0, 0x21, 0xa0, 0x85, 0x0d, 0x43, 0x2c, 0xd4, 0x02, 0xb0, 0xa1, 0xd0,
+  0x83, 0x50, 0xb0, 0x85, 0x07, 0xa0, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x37,
+  0xc7, 0x22, 0xcd, 0x6d, 0x8e, 0x6e, 0x8e, 0xc6, 0x5c, 0xda, 0xd9, 0x17,
+  0x1b, 0x19, 0x8d, 0xb9, 0xb4, 0xb3, 0xaf, 0x39, 0xba, 0x0d, 0x08, 0x2e,
+  0x48, 0xb9, 0xe0, 0x0a, 0xba, 0x70, 0xed, 0xc2, 0x55, 0x85, 0x8d, 0xcd,
+  0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x4a, 0x10, 0x54, 0x21,
+  0xc3, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x9b, 0x12, 0x10,
+  0x4d, 0xc8, 0xf0, 0x5c, 0xec, 0xc2, 0xd8, 0xec, 0xca, 0xe4, 0xa6, 0x04,
+  0x45, 0x1d, 0x32, 0x3c, 0x97, 0x39, 0xb4, 0x30, 0xb2, 0x32, 0xb9, 0xa6,
+  0x37, 0xb2, 0x32, 0xb6, 0x29, 0x01, 0x52, 0x86, 0x0c, 0xcf, 0x45, 0xae,
+  0x6c, 0xee, 0xad, 0x4e, 0x6e, 0xac, 0x6c, 0x6e, 0x4a, 0xe0, 0x54, 0x22,
+  0xc3, 0x73, 0xa1, 0xcb, 0x83, 0x2b, 0x0b, 0x72, 0x73, 0x7b, 0xa3, 0x0b,
+  0xa3, 0x4b, 0x7b, 0x73, 0x9b, 0x9b, 0x22, 0xe0, 0x41, 0x1f, 0xd4, 0x21,
+  0xc3, 0x73, 0xb1, 0x4b, 0x2b, 0xbb, 0x4b, 0x22, 0x9b, 0xa2, 0x0b, 0xa3,
+  0x2b, 0x9b, 0x12, 0xfc, 0x41, 0x1d, 0x32, 0x3c, 0x97, 0x32, 0x37, 0x3a,
+  0xb9, 0x3c, 0xa8, 0xb7, 0x34, 0x37, 0xba, 0xb9, 0x29, 0x81, 0x2d, 0x74,
+  0x21, 0xc3, 0x73, 0x19, 0x7b, 0xab, 0x73, 0xa3, 0x2b, 0x93, 0x9b, 0x9b,
+  0x12, 0xec, 0x02, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc4, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x7a, 0x28, 0x87, 0x76, 0x80, 0x87,
+  0x19, 0xd1, 0x43, 0x0e, 0xf8, 0xe0, 0x06, 0xe4, 0x20, 0x0e, 0xe7, 0xe0,
+  0x06, 0xf6, 0x10, 0x0e, 0xf2, 0xc0, 0x0e, 0xe1, 0x90, 0x0f, 0xef, 0x50,
+  0x0f, 0xf4, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x36, 0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41,
+  0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d,
+  0x04, 0xd2, 0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08,
+  0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03,
+  0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5,
+  0x3b, 0x8f, 0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f,
+  0xdc, 0xb6, 0x01, 0x10, 0x0c, 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xce, 0xf5, 0x95, 0xd7, 0x46, 0x20, 0x6d, 0x54, 0x84, 0x0a, 0x8f,
+  0x4f, 0xa9, 0x59, 0x7d, 0x19, 0x44, 0x58, 0x49, 0x4c, 0x08, 0x06, 0x00,
+  0x00, 0x60, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49,
+  0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xf0, 0x05, 0x00,
+  0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x79, 0x01, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e,
+  0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8,
+  0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08,
+  0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x21, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4,
+  0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a,
+  0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x5c, 0x23, 0x00, 0x25, 0x00, 0x14,
+  0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84,
+  0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb,
+  0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2,
+  0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e,
+  0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30,
+  0x42, 0x6d, 0x8e, 0x20, 0x28, 0x06, 0x23, 0x85, 0x90, 0x47, 0x70, 0x20,
+  0x60, 0x18, 0x81, 0x18, 0x2e, 0xe1, 0x9c, 0x46, 0x9a, 0x80, 0x66, 0x92,
+  0x10, 0x33, 0xc6, 0x18, 0x63, 0x8c, 0x31, 0xe7, 0x9c, 0x44, 0xd3, 0x81,
+  0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87,
+  0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0,
+  0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10,
+  0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2,
+  0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
+  0xe4, 0x81, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x0b, 0x04, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x1c, 0x50, 0x04, 0x65, 0x50,
+  0x1e, 0x54, 0x4a, 0xa2, 0x0c, 0x0a, 0x61, 0x04, 0xa0, 0x08, 0x0a, 0x84,
+  0xea, 0x0c, 0x00, 0xd9, 0xb1, 0x1c, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x04, 0x02, 0x01, 0x79, 0x18, 0x00, 0x00, 0x5c, 0x00, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0x44, 0x35, 0x18, 0x63,
+  0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03,
+  0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a,
+  0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b,
+  0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xa2, 0x98, 0x20,
+  0x10, 0xc6, 0x06, 0x61, 0x20, 0x26, 0x08, 0xc4, 0xb1, 0x41, 0x18, 0x0c,
+  0x0a, 0x70, 0x73, 0x1b, 0x06, 0xc4, 0x20, 0x26, 0x08, 0x95, 0x44, 0x60,
+  0x82, 0x40, 0x20, 0x1b, 0x10, 0x42, 0x59, 0x88, 0x61, 0x60, 0x80, 0x0d,
+  0x41, 0xb3, 0x81, 0x00, 0x00, 0x07, 0x98, 0x20, 0x58, 0xd3, 0x86, 0x00,
+  0x9a, 0x20, 0x08, 0x00, 0x89, 0xb6, 0xb0, 0x34, 0x37, 0x2e, 0x53, 0x56,
+  0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x13, 0x84, 0x82,
+  0x99, 0x20, 0x14, 0xcd, 0x86, 0x80, 0x98, 0x20, 0x14, 0xce, 0x04, 0xa1,
+  0x78, 0x36, 0x2c, 0x04, 0x55, 0x59, 0x17, 0x36, 0x60, 0x44, 0x06, 0x10,
+  0xa1, 0x2a, 0xc2, 0x1a, 0x7a, 0x7a, 0x92, 0x22, 0x9a, 0x20, 0x14, 0xd0,
+  0x86, 0x65, 0xd8, 0xaa, 0xec, 0xe2, 0x06, 0x6e, 0xc8, 0x80, 0x09, 0x02,
+  0x91, 0xb0, 0x18, 0x7a, 0x62, 0x7a, 0x92, 0x9a, 0x20, 0x10, 0xca, 0x04,
+  0x81, 0x58, 0x36, 0x08, 0x60, 0x10, 0x06, 0x1b, 0x16, 0xef, 0xab, 0xb2,
+  0x8b, 0x1b, 0x30, 0x2f, 0x13, 0x83, 0x0d, 0x83, 0xd6, 0x8d, 0x01, 0x93,
+  0x29, 0xab, 0x2f, 0xaa, 0x30, 0xb9, 0xb3, 0x32, 0xba, 0x09, 0x42, 0x11,
+  0x6d, 0x58, 0x88, 0x32, 0xa8, 0xcc, 0xe0, 0xca, 0x06, 0x8c, 0xc8, 0xc4,
+  0x60, 0x43, 0x70, 0x06, 0x1b, 0x06, 0x32, 0x40, 0x03, 0x60, 0x43, 0x21,
+  0x4d, 0x69, 0xf0, 0x00, 0x55, 0xd8, 0xd8, 0xec, 0xda, 0x5c, 0xd2, 0xc8,
+  0xca, 0xdc, 0xe8, 0xa6, 0x04, 0x41, 0x15, 0x32, 0x3c, 0x17, 0xbb, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x29, 0x01, 0xd1, 0x84, 0x0c, 0xcf, 0xc5,
+  0x2e, 0x8c, 0xcd, 0xae, 0x4c, 0x6e, 0x4a, 0x60, 0xd4, 0x21, 0xc3, 0x73,
+  0x99, 0x43, 0x0b, 0x23, 0x2b, 0x93, 0x6b, 0x7a, 0x23, 0x2b, 0x63, 0x9b,
+  0x12, 0x20, 0x65, 0xc8, 0xf0, 0x5c, 0xe4, 0xca, 0xe6, 0xde, 0xea, 0xe4,
+  0xc6, 0xca, 0xe6, 0xa6, 0x04, 0x4e, 0x1d, 0x32, 0x3c, 0x17, 0xbb, 0xb4,
+  0xb2, 0xbb, 0x24, 0xb2, 0x29, 0xba, 0x30, 0xba, 0xb2, 0x29, 0x01, 0x54,
+  0x87, 0x0c, 0xcf, 0xa5, 0xcc, 0x8d, 0x4e, 0x2e, 0x0f, 0xea, 0x2d, 0xcd,
+  0x8d, 0x6e, 0x6e, 0x4a, 0x90, 0x06, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc4, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x7a, 0x28,
+  0x87, 0x76, 0x80, 0x87, 0x19, 0xd1, 0x43, 0x0e, 0xf8, 0xe0, 0x06, 0xe4,
+  0x20, 0x0e, 0xe7, 0xe0, 0x06, 0xf6, 0x10, 0x0e, 0xf2, 0xc0, 0x0e, 0xe1,
+  0x90, 0x0f, 0xef, 0x50, 0x0f, 0xf4, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe,
+  0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61, 0x00, 0x02,
+  0xe6, 0x17, 0xb7, 0x6d, 0x04, 0xd2, 0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11,
+  0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe,
+  0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6,
+  0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4,
+  0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x01, 0x10, 0x0c, 0x80, 0x34, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x44, 0x0a, 0x61,
+  0x06, 0xa0, 0x14, 0x4a, 0xae, 0xec, 0xa8, 0x94, 0x00, 0xbd, 0x11, 0x00,
+  0x00, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x00, 0x5d, 0xc4, 0x52, 0x59,
+  0xc1, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0x1b, 0x32, 0x59, 0xcd,
+  0x31, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x06, 0x97, 0x50, 0x17, 0x81,
+  0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x81, 0xd1, 0x29, 0x15, 0xe6, 0x24,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x78, 0x8b, 0x95, 0x49, 0xca,
+  0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0x1d, 0x52, 0x68, 0xa3, 0x09,
+  0xc1, 0x60, 0x81, 0x21, 0x1f, 0x13, 0x0c, 0xf9, 0xd8, 0x60, 0xc8, 0x67,
+  0xc4, 0x20, 0x01, 0x40, 0x10, 0x0c, 0x90, 0x31, 0x78, 0xbe, 0xcf, 0x1a,
+  0x46, 0x0c, 0x12, 0x00, 0x04, 0xc1, 0x00, 0x19, 0x83, 0xe7, 0xfb, 0x18,
+  0x61, 0xc4, 0x20, 0x01, 0x40, 0x10, 0x0c, 0x90, 0x31, 0x78, 0xbe, 0xaf,
+  0x0a, 0x46, 0x0c, 0x12, 0x00, 0x04, 0xc1, 0x00, 0x19, 0x83, 0xe7, 0xfb,
+  0x30, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Colors.hlsl b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Colors.hlsl
new file mode 100644
index 0000000..834d629
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Colors.hlsl
@@ -0,0 +1,8 @@
+
+#include "D3D12_PixelShader_Common.hlsli"
+
+[RootSignature(ColorRS)]
+float4 main(PixelShaderInput input) : SV_TARGET0
+{
+    return GetOutputColor(1.0) * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Common.hlsli b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Common.hlsli
new file mode 100644
index 0000000..ba32e0c
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Common.hlsli
@@ -0,0 +1,236 @@
+#include "D3D12_Shader_Common.hlsli"
+
+Texture2D texture0 : register(t0);
+Texture2D texture1 : register(t1);
+Texture2D texture2 : register(t2);
+SamplerState sampler0 : register(s0);
+
+struct PixelShaderInput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+// These should mirror the definitions in SDL_render_d3d12.c
+static const float TONEMAP_NONE = 0;
+static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+static const float TEXTURETYPE_NONE = 0;
+static const float TEXTURETYPE_RGB = 1;
+static const float TEXTURETYPE_NV12 = 2;
+static const float TEXTURETYPE_NV21 = 3;
+static const float TEXTURETYPE_YUV = 4;
+
+static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+cbuffer Constants : register(b1)
+{
+    float scRGB_output;
+    float texture_type;
+    float input_type;
+    float color_scale;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+
+    float4 Yoffset;
+    float4 Rcoeff;
+    float4 Gcoeff;
+    float4 Bcoeff;
+};
+
+static const float3x3 mat709to2020 = {
+    { 0.627404, 0.329283, 0.043313 },
+    { 0.069097, 0.919541, 0.011362 },
+    { 0.016391, 0.088013, 0.895595 }
+};
+
+static const float3x3 mat2020to709 = {
+    { 1.660496, -0.587656, -0.072840 },
+    { -0.124547, 1.132895, -0.008348 },
+    { -0.018154, -0.100597, 1.118751 }
+};
+
+float sRGBtoLinear(float v)
+{
+    if (v <= 0.04045) {
+        v = (v / 12.92);
+    } else {
+        v = pow(abs(v + 0.055) / 1.055, 2.4);
+    }
+    return v;
+}
+
+float sRGBfromLinear(float v)
+{
+    if (v <= 0.0031308) {
+        v = (v * 12.92);
+    } else {
+        v = (pow(abs(v), 1.0 / 2.4) * 1.055 - 0.055);
+    }
+    return v;
+}
+
+float3 PQtoLinear(float3 v)
+{
+    const float c1 = 0.8359375;
+    const float c2 = 18.8515625;
+    const float c3 = 18.6875;
+    const float oo_m1 = 1.0 / 0.1593017578125;
+    const float oo_m2 = 1.0 / 78.84375;
+
+    float3 num = max(pow(abs(v), oo_m2) - c1, 0.0);
+    float3 den = c2 - c3 * pow(abs(v), oo_m2);
+    return (10000.0 * pow(abs(num / den), oo_m1) / sdr_white_point);
+}
+
+float3 ApplyTonemap(float3 v)
+{
+    if (tonemap_method == TONEMAP_LINEAR) {
+        v *= tonemap_factor1;
+    } else if (tonemap_method == TONEMAP_CHROME) {
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.2020 colorspace for tone mapping
+            v = mul(mat709to2020, v);
+        }
+
+        float vmax = max(v.r, max(v.g, v.b));
+        if (vmax > 0.0) {
+            float scale = (1.0 + tonemap_factor1 * vmax) / (1.0 + tonemap_factor2 * vmax);
+            v *= scale;
+        }
+
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.709 colorspace after tone mapping
+            v = mul(mat2020to709, v);
+        }
+    }
+    return v;
+}
+
+float4 GetInputColor(PixelShaderInput input)
+{
+    float4 rgba;
+
+    if (texture_type == TEXTURETYPE_NONE) {
+        rgba = 1.0;
+    } else if (texture_type == TEXTURETYPE_RGB) {
+        rgba = texture0.Sample(sampler0, input.tex);
+    } else if (texture_type == TEXTURETYPE_NV12) {
+        float3 yuv;
+        yuv.x = texture0.Sample(sampler0, input.tex).r;
+        yuv.yz = texture1.Sample(sampler0, input.tex).rg;
+
+        yuv += Yoffset.xyz;
+        rgba.r = dot(yuv, Rcoeff.xyz);
+        rgba.g = dot(yuv, Gcoeff.xyz);
+        rgba.b = dot(yuv, Bcoeff.xyz);
+        rgba.a = 1.0;
+    } else if (texture_type == TEXTURETYPE_NV21) {
+        float3 yuv;
+        yuv.x = texture0.Sample(sampler0, input.tex).r;
+        yuv.yz = texture1.Sample(sampler0, input.tex).gr;
+
+        yuv += Yoffset.xyz;
+        rgba.r = dot(yuv, Rcoeff.xyz);
+        rgba.g = dot(yuv, Gcoeff.xyz);
+        rgba.b = dot(yuv, Bcoeff.xyz);
+        rgba.a = 1.0;
+    } else if (texture_type == TEXTURETYPE_YUV) {
+        float3 yuv;
+        yuv.x = texture0.Sample(sampler0, input.tex).r;
+        yuv.y = texture1.Sample(sampler0, input.tex).r;
+        yuv.z = texture2.Sample(sampler0, input.tex).r;
+
+        yuv += Yoffset.xyz;
+        rgba.r = dot(yuv, Rcoeff.xyz);
+        rgba.g = dot(yuv, Gcoeff.xyz);
+        rgba.b = dot(yuv, Bcoeff.xyz);
+        rgba.a = 1.0;
+    } else {
+        // Error!
+        rgba.r = 1.0;
+        rgba.g = 0.0;
+        rgba.b = 0.0;
+        rgba.a = 1.0;
+    }
+    return rgba;
+}
+
+float4 GetOutputColor(float4 rgba)
+{
+    float4 output;
+
+    output.rgb = rgba.rgb * color_scale;
+    output.a = rgba.a;
+
+    return output;
+}
+
+float3 GetOutputColorFromSRGB(float3 rgb)
+{
+    float3 output;
+
+    if (scRGB_output) {
+        rgb.r = sRGBtoLinear(rgb.r);
+        rgb.g = sRGBtoLinear(rgb.g);
+        rgb.b = sRGBtoLinear(rgb.b);
+    }
+
+    output.rgb = rgb * color_scale;
+
+    return output;
+}
+
+float3 GetOutputColorFromLinear(float3 rgb)
+{
+    float3 output;
+
+    output.rgb = rgb * color_scale;
+
+    if (!scRGB_output) {
+        output.r = sRGBfromLinear(output.r);
+        output.g = sRGBfromLinear(output.g);
+        output.b = sRGBfromLinear(output.b);
+        output.rgb = saturate(output.rgb);
+    }
+
+    return output;
+}
+
+float4 AdvancedPixelShader(PixelShaderInput input)
+{
+    float4 rgba = GetInputColor(input);
+    float4 output;
+
+    if (input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = PQtoLinear(rgba.rgb);
+    }
+
+    if (tonemap_method != TONEMAP_NONE) {
+        rgba.rgb = ApplyTonemap(rgba.rgb);
+    }
+
+    if (input_type == INPUTTYPE_SRGB) {
+        output.rgb = GetOutputColorFromSRGB(rgba.rgb);
+        output.a = rgba.a;
+    } else if (input_type == INPUTTYPE_SCRGB) {
+        output.rgb = GetOutputColorFromLinear(rgba.rgb);
+        output.a = rgba.a;
+    } else if (input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = mul(mat2020to709, rgba.rgb);
+        output.rgb = GetOutputColorFromLinear(rgba.rgb);
+        output.a = rgba.a;
+    } else {
+        output = GetOutputColor(rgba);
+    }
+
+    return output * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Textures.h b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Textures.h
new file mode 100644
index 0000000..4aa8ef0
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Textures.h
@@ -0,0 +1,586 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Position              0   xyzw        0      POS   float       
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Target                0   xyzw        0   TARGET   float   xyzw
+;
+; shader hash: 7a58efcd6cfa5eef872e7cbc3b5f38b8
+;
+; Pipeline Runtime Information: 
+;
+; Pixel Shader
+; DepthOutput=0
+; SampleFrequency=0
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Position              0          noperspective       
+; TEXCOORD                 0                 linear       
+; COLOR                    0                 linear       
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Target                0                              
+;
+; Buffer Definitions:
+;
+; cbuffer Constants
+; {
+;
+;   struct Constants
+;   {
+;
+;       float scRGB_output;                           ; Offset:    0
+;       float texture_type;                           ; Offset:    4
+;       float input_type;                             ; Offset:    8
+;       float color_scale;                            ; Offset:   12
+;       float tonemap_method;                         ; Offset:   16
+;       float tonemap_factor1;                        ; Offset:   20
+;       float tonemap_factor2;                        ; Offset:   24
+;       float sdr_white_point;                        ; Offset:   28
+;       float4 Yoffset;                               ; Offset:   32
+;       float4 Rcoeff;                                ; Offset:   48
+;       float4 Gcoeff;                                ; Offset:   64
+;       float4 Bcoeff;                                ; Offset:   80
+;   
+;   } Constants;                                      ; Offset:    0 Size:    96
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; Constants                         cbuffer      NA          NA     CB0            cb1     1
+; sampler0                          sampler      NA          NA      S0             s0     1
+; texture0                          texture     f32          2d      T0             t0     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 12, outputs: 4
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 4, 5, 8 }
+;   output 1 depends on inputs: { 4, 5, 9 }
+;   output 2 depends on inputs: { 4, 5, 10 }
+;   output 3 depends on inputs: { 4, 5, 11 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.ResRet.f32 = type { float, float, float, float, i32 }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%"class.Texture2D<vector<float, 4> >" = type { <4 x float>, %"class.Texture2D<vector<float, 4> >::mips_type" }
+%"class.Texture2D<vector<float, 4> >::mips_type" = type { i32 }
+%Constants = type { float, float, float, float, float, float, float, float, <4 x float>, <4 x float>, <4 x float>, <4 x float> }
+%struct.SamplerState = type { i32 }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 0, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 3, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %3 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 1, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %10 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %1, %dx.types.Handle %2, float %8, float %9, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %11 = extractvalue %dx.types.ResRet.f32 %10, 0
+  %12 = extractvalue %dx.types.ResRet.f32 %10, 1
+  %13 = extractvalue %dx.types.ResRet.f32 %10, 2
+  %14 = extractvalue %dx.types.ResRet.f32 %10, 3
+  %15 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %3, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %16 = extractvalue %dx.types.CBufRet.f32 %15, 3
+  %17 = fmul fast float %11, %4
+  %18 = fmul fast float %17, %16
+  %19 = fmul fast float %12, %5
+  %20 = fmul fast float %19, %16
+  %21 = fmul fast float %13, %6
+  %22 = fmul fast float %21, %16
+  %23 = fmul fast float %14, %7
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %18)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %20)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %22)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %23)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.ResRet.f32 @dx.op.sample.f32(i32, %dx.types.Handle, %dx.types.Handle, float, float, float, float, i32, i32, i32, float) #2
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!12}
+!dx.entryPoints = !{!13}
+
+!0 = !{!"clang version 3.7 (tags/RELEASE_370/final)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 6}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{!5, null, !8, !10}
+!5 = !{!6}
+!6 = !{i32 0, %"class.Texture2D<vector<float, 4> >"* undef, !"", i32 0, i32 0, i32 1, i32 2, i32 0, !7}
+!7 = !{i32 0, i32 9}
+!8 = !{!9}
+!9 = !{i32 0, %Constants* undef, !"", i32 0, i32 1, i32 1, i32 96, null}
+!10 = !{!11}
+!11 = !{i32 0, %struct.SamplerState* undef, !"", i32 0, i32 0, i32 1, i32 0, null}
+!12 = !{[14 x i32] [i32 12, i32 4, i32 0, i32 0, i32 0, i32 0, i32 15, i32 15, i32 0, i32 0, i32 1, i32 2, i32 4, i32 8]}
+!13 = !{void ()* @main, !"main", !14, !4, null}
+!14 = !{!15, !22, null}
+!15 = !{!16, !18, !20}
+!16 = !{i32 0, !"SV_Position", i8 9, i8 3, !17, i8 4, i32 1, i8 4, i32 0, i8 0, null}
+!17 = !{i32 0}
+!18 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !17, i8 2, i32 1, i8 2, i32 1, i8 0, !19}
+!19 = !{i32 3, i32 3}
+!20 = !{i32 2, !"COLOR", i8 9, i8 0, !17, i8 2, i32 1, i8 4, i32 2, i8 0, !21}
+!21 = !{i32 3, i32 15}
+!22 = !{!23}
+!23 = !{i32 0, !"SV_Target", i8 9, i8 16, !17, i8 0, i32 1, i8 4, i32 0, i8 0, !21}
+
+#endif
+
+const unsigned char g_main[] = {
+  0x44, 0x58, 0x42, 0x43, 0xb2, 0xdd, 0x4e, 0x8d, 0x7f, 0x3c, 0x1f, 0x5e,
+  0x6f, 0x0e, 0x03, 0xe7, 0x8c, 0xce, 0x62, 0x95, 0x01, 0x00, 0x00, 0x00,
+  0xe1, 0x12, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x15, 0x01, 0x00, 0x00,
+  0x31, 0x02, 0x00, 0x00, 0xd9, 0x02, 0x00, 0x00, 0x31, 0x0b, 0x00, 0x00,
+  0x4d, 0x0b, 0x00, 0x00, 0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31,
+  0x83, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c,
+  0x4f, 0x52, 0x00, 0x4f, 0x53, 0x47, 0x31, 0x32, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74,
+  0x00, 0x50, 0x53, 0x56, 0x30, 0x14, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x03, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43,
+  0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x44, 0x03, 0x03, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x42, 0x00, 0x03, 0x02, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x44,
+  0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x44, 0x10, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x52, 0x54, 0x53,
+  0x30, 0xa0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00,
+  0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x53, 0x54, 0x41,
+  0x54, 0x50, 0x08, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x14, 0x02, 0x00,
+  0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x38, 0x08, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00,
+  0x00, 0x0b, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04,
+  0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08,
+  0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b,
+  0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52,
+  0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32,
+  0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81,
+  0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03,
+  0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60,
+  0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x4e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x7c, 0x23,
+  0x00, 0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00,
+  0x29, 0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06,
+  0xa1, 0x9b, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0xfc, 0x95, 0x90, 0x56,
+  0x62, 0xf2, 0x8b, 0xdb, 0x46, 0xc5, 0x18, 0x63, 0x10, 0x2a, 0xf7, 0x0c,
+  0x97, 0x3f, 0x61, 0x0f, 0x21, 0xf9, 0x21, 0xd0, 0x0c, 0x0b, 0x81, 0x82,
+  0x55, 0x18, 0x45, 0x18, 0x1b, 0x63, 0x0c, 0x42, 0xc8, 0xa0, 0x76, 0xd4,
+  0x70, 0xf9, 0x13, 0xf6, 0x10, 0x92, 0xcf, 0x6d, 0x54, 0xb1, 0x12, 0x93,
+  0x5f, 0xdc, 0x36, 0x22, 0xc6, 0x18, 0xa3, 0x10, 0x8f, 0x30, 0x42, 0x70,
+  0x8e, 0x20, 0x28, 0x06, 0x23, 0x85, 0x10, 0x49, 0x73, 0x20, 0x60, 0x18,
+  0x81, 0x18, 0x66, 0x6a, 0x83, 0x71, 0x60, 0x87, 0x70, 0x98, 0x87, 0x79,
+  0x70, 0x03, 0x5a, 0x28, 0x07, 0x7c, 0xa0, 0x87, 0x7a, 0x90, 0x87, 0x72,
+  0x90, 0x03, 0x52, 0xe0, 0x03, 0x7b, 0x28, 0x87, 0x71, 0xa0, 0x87, 0x77,
+  0x90, 0x07, 0x3e, 0x30, 0x07, 0x76, 0x78, 0x87, 0x70, 0xa0, 0x07, 0x36,
+  0x00, 0x03, 0x3a, 0xf0, 0x03, 0x30, 0xf0, 0x03, 0x3d, 0xd0, 0x83, 0x76,
+  0x48, 0x07, 0x78, 0x98, 0x87, 0x5f, 0xa0, 0x87, 0x7c, 0x80, 0x87, 0x72,
+  0x40, 0x01, 0x99, 0x49, 0x0c, 0xc6, 0x81, 0x1d, 0xc2, 0x61, 0x1e, 0xe6,
+  0xc1, 0x0d, 0x68, 0xa1, 0x1c, 0xf0, 0x81, 0x1e, 0xea, 0x41, 0x1e, 0xca,
+  0x41, 0x0e, 0x48, 0x81, 0x0f, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xf8, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d, 0xc2, 0x81, 0x1e, 0xd8,
+  0x00, 0x0c, 0xe8, 0xc0, 0x0f, 0xc0, 0xc0, 0x0f, 0x90, 0x60, 0x2f, 0xe1,
+  0x4b, 0x38, 0xa7, 0x91, 0x26, 0xa0, 0x99, 0x24, 0xc4, 0x8c, 0x31, 0xc6,
+  0x18, 0x63, 0x58, 0x6b, 0x2d, 0xe9, 0x9b, 0xa4, 0x29, 0xa2, 0x84, 0xc9,
+  0x67, 0x01, 0xe6, 0x59, 0x88, 0x88, 0x9d, 0x80, 0x89, 0x40, 0x01, 0x21,
+  0x9e, 0x0e, 0x04, 0x00, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60,
+  0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf,
+  0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6,
+  0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43,
+  0x9e, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x30, 0xe4, 0x81, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x60, 0xc8, 0x33, 0x01, 0x01, 0x30, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x17, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x45, 0x50,
+  0x12, 0x05, 0x1c, 0x50, 0x06, 0xe5, 0x50, 0x08, 0x05, 0x51, 0x18, 0x05,
+  0x52, 0x28, 0x05, 0x53, 0x38, 0x05, 0x54, 0x60, 0x05, 0x18, 0x50, 0xa0,
+  0x01, 0xe5, 0x41, 0xa5, 0x24, 0xca, 0xa0, 0x10, 0x46, 0x00, 0x8a, 0xa0,
+  0x40, 0x48, 0xd6, 0x00, 0xe5, 0x19, 0x00, 0xd2, 0x33, 0x00, 0xb4, 0x67,
+  0x00, 0xa8, 0xcf, 0x00, 0x90, 0x1f, 0xcb, 0x61, 0x08, 0x00, 0x00, 0x80,
+  0xe7, 0x01, 0x80, 0x40, 0x20, 0x10, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xdc, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13,
+  0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b,
+  0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b,
+  0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9,
+  0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04,
+  0x41, 0x01, 0x6e, 0x6e, 0x82, 0x40, 0x20, 0x1b, 0x86, 0x03, 0x21, 0x26,
+  0x08, 0x59, 0x18, 0x10, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0x83,
+  0x99, 0x20, 0x10, 0xc9, 0x04, 0x81, 0x50, 0x36, 0x08, 0x44, 0xb3, 0x21,
+  0x21, 0x94, 0x85, 0x20, 0x06, 0x86, 0x70, 0x36, 0x04, 0xcf, 0x04, 0x61,
+  0x1b, 0x03, 0x26, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73,
+  0x13, 0x04, 0x62, 0xd9, 0x80, 0x10, 0x91, 0x44, 0x0c, 0xc3, 0x04, 0x6c,
+  0x08, 0xa8, 0x09, 0x42, 0x47, 0x06, 0x44, 0xe6, 0xc2, 0xda, 0xe0, 0xd8,
+  0xca, 0xe4, 0x60, 0x36, 0x20, 0x84, 0x75, 0x11, 0xc4, 0x40, 0x00, 0x1b,
+  0x02, 0x6c, 0x03, 0x01, 0x01, 0x55, 0x36, 0x41, 0xd0, 0xc4, 0x80, 0xcc,
+  0xdc, 0x98, 0xd4, 0x91, 0xd0, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0xdd,
+  0x04, 0x81, 0x60, 0x26, 0x08, 0x44, 0xb3, 0xc1, 0x40, 0xb8, 0x8e, 0xf0,
+  0x1a, 0x32, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x13, 0x04, 0xc2, 0xd9, 0x60, 0x20, 0x60, 0xd0, 0x85, 0x81,
+  0xd7, 0x50, 0x49, 0x73, 0x83, 0xab, 0xa3, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0x9b, 0x20, 0x10, 0xcf, 0x06, 0x03, 0x19, 0x83, 0x8e, 0x0c, 0xbc, 0x86,
+  0xcb, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0xd7, 0xdc, 0x58, 0x18, 0x5b, 0xd9,
+  0x04, 0x81, 0x80, 0x26, 0x08, 0x12, 0x18, 0x6c, 0x40, 0x10, 0x33, 0xe8,
+  0xce, 0xc0, 0x6b, 0x1a, 0x34, 0xa0, 0x43, 0xf7, 0xe6, 0x56, 0xd6, 0x16,
+  0x06, 0xf7, 0xd5, 0x56, 0x46, 0x87, 0xf6, 0x46, 0x36, 0x41, 0x20, 0xa2,
+  0x0d, 0x06, 0xa2, 0x06, 0xdd, 0x1a, 0x78, 0x0d, 0x1f, 0xba, 0x37, 0xb7,
+  0xb2, 0xb6, 0x30, 0xb8, 0x2f, 0xb3, 0xb0, 0x31, 0xba, 0x37, 0xb9, 0x98,
+  0x09, 0x02, 0x21, 0x6d, 0x30, 0x90, 0x36, 0xe8, 0xdc, 0xc0, 0x6b, 0xf8,
+  0xd0, 0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1, 0x7d, 0x99, 0x85, 0x8d, 0xd1,
+  0xbd, 0xc9, 0xc9, 0x4c, 0x10, 0x88, 0x69, 0x83, 0x81, 0xc0, 0x41, 0x17,
+  0x07, 0x5e, 0xc3, 0x67, 0x8e, 0x4c, 0xee, 0xeb, 0x0e, 0x2d, 0x8d, 0xae,
+  0xec, 0x0b, 0xee, 0x2d, 0xcd, 0x8d, 0x6e, 0x82, 0x40, 0x50, 0x1b, 0x0c,
+  0x64, 0x0e, 0x3a, 0x3a, 0xf0, 0x1a, 0x1e, 0x59, 0x6f, 0x66, 0x66, 0x73,
+  0x65, 0x74, 0x13, 0x04, 0xa2, 0xda, 0x60, 0x20, 0x76, 0xd0, 0xdd, 0x81,
+  0xd7, 0xd0, 0x90, 0x1a, 0x7b, 0x2b, 0x33, 0x33, 0x9b, 0x20, 0x10, 0xd6,
+  0x06, 0x03, 0xc9, 0x83, 0x4e, 0x0f, 0xbc, 0x86, 0xc6, 0xd1, 0xd8, 0x5b,
+  0x99, 0x99, 0xd9, 0x04, 0x81, 0xb8, 0x36, 0x18, 0x08, 0x1f, 0x74, 0x7d,
+  0xe0, 0x35, 0x34, 0x84, 0xc6, 0xde, 0xca, 0xcc, 0xcc, 0x26, 0x08, 0x04,
+  0xb6, 0xc1, 0x40, 0xfe, 0xa0, 0x03, 0x05, 0xaf, 0xd9, 0xd0, 0x4c, 0x9f,
+  0x18, 0x94, 0x41, 0x1a, 0xb0, 0xc1, 0x1b, 0xc8, 0x41, 0x1d, 0xe0, 0xc1,
+  0x1e, 0xf8, 0x41, 0x28, 0x6c, 0x18, 0x88, 0x4d, 0x14, 0x26, 0x08, 0x02,
+  0xb0, 0x01, 0xd8, 0x30, 0x10, 0xa5, 0x50, 0x0a, 0x1b, 0x02, 0x53, 0xd8,
+  0x30, 0x0c, 0xa4, 0x70, 0x0a, 0x13, 0x04, 0xaf, 0x0c, 0x36, 0x04, 0xa9,
+  0x40, 0xa2, 0x2d, 0x2c, 0xcd, 0x8d, 0xcb, 0x94, 0xd5, 0x17, 0xd4, 0xdb,
+  0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0xdb, 0x04, 0xa1, 0xd0, 0x26, 0x08, 0xc5,
+  0xb6, 0x21, 0x20, 0x26, 0x08, 0x05, 0x37, 0x41, 0x28, 0xba, 0x0d, 0x0b,
+  0xc1, 0x0a, 0xad, 0xe0, 0x0a, 0xaf, 0x00, 0x0b, 0x03, 0x2c, 0x10, 0xb1,
+  0x00, 0x10, 0xa1, 0x2a, 0xc2, 0x1a, 0x7a, 0x7a, 0x92, 0x22, 0x9a, 0x20,
+  0x14, 0xde, 0x06, 0xa1, 0xeb, 0x36, 0x2c, 0xc3, 0x2c, 0xb4, 0x42, 0x2c,
+  0xbc, 0x02, 0x2d, 0x0c, 0xb4, 0x30, 0xc4, 0x42, 0x2d, 0xb0, 0x18, 0x7a,
+  0x62, 0x7a, 0x92, 0x9a, 0x20, 0x10, 0xd9, 0x06, 0xa1, 0xc3, 0x85, 0x0d,
+  0x0b, 0x73, 0x0b, 0xad, 0x10, 0x0b, 0xaf, 0x40, 0x0b, 0x03, 0x2c, 0x30,
+  0xb1, 0x90, 0x0b, 0x1b, 0x06, 0x59, 0xb0, 0x05, 0x5d, 0x60, 0x32, 0x65,
+  0xf5, 0x45, 0x15, 0x26, 0x77, 0x56, 0x46, 0x37, 0x41, 0x28, 0xbe, 0x0d,
+  0x0b, 0xc1, 0x0b, 0xad, 0xd0, 0x0b, 0xaf, 0x10, 0x0b, 0x03, 0x2c, 0x10,
+  0xb1, 0x90, 0x0b, 0x1b, 0x02, 0x5f, 0xd8, 0x30, 0xec, 0xc2, 0x2f, 0x00,
+  0x1b, 0x0a, 0x52, 0x58, 0x05, 0x70, 0xd0, 0x00, 0x1a, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x73, 0x2c, 0xd2, 0xdc, 0xe6, 0xe8, 0xe6, 0x68, 0xcc, 0xa5,
+  0x9d, 0x7d, 0xb1, 0x91, 0xd1, 0x98, 0x4b, 0x3b, 0xfb, 0x9a, 0xa3, 0x23,
+  0x42, 0x57, 0x86, 0xf7, 0xe5, 0xf6, 0x26, 0xd7, 0xb6, 0x41, 0x11, 0x07,
+  0x6f, 0x1c, 0xe8, 0x80, 0x1c, 0x90, 0x72, 0x08, 0x03, 0x73, 0x18, 0xaa,
+  0xb0, 0xb1, 0xd9, 0xb5, 0xb9, 0xa4, 0x91, 0x95, 0xb9, 0xd1, 0x4d, 0x09,
+  0x82, 0x2a, 0x64, 0x78, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x53, 0x02, 0xa2, 0x09, 0x19, 0x9e, 0x8b, 0x5d, 0x18, 0x9b, 0x5d, 0x99,
+  0xdc, 0x94, 0xa0, 0xa8, 0x43, 0x86, 0xe7, 0x32, 0x87, 0x16, 0x46, 0x56,
+  0x26, 0xd7, 0xf4, 0x46, 0x56, 0xc6, 0x36, 0x25, 0x40, 0xca, 0x90, 0xe1,
+  0xb9, 0xc8, 0x95, 0xcd, 0xbd, 0xd5, 0xc9, 0x8d, 0x95, 0xcd, 0x4d, 0x09,
+  0xb2, 0x4a, 0x64, 0x78, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x41, 0x6e, 0x6e,
+  0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x04, 0x51, 0x38,
+  0x85, 0x3a, 0x64, 0x78, 0x2e, 0x76, 0x69, 0x65, 0x77, 0x49, 0x64, 0x53,
+  0x74, 0x61, 0x74, 0x65, 0x53, 0x82, 0x54, 0xa8, 0x43, 0x86, 0xe7, 0x52,
+  0xe6, 0x46, 0x27, 0x97, 0x07, 0xf5, 0x96, 0xe6, 0x46, 0x37, 0x37, 0x25,
+  0x00, 0x87, 0x2e, 0x64, 0x78, 0x2e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65,
+  0x72, 0x73, 0x53, 0x02, 0x73, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc4, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x7a, 0x28,
+  0x87, 0x76, 0x80, 0x87, 0x19, 0xd1, 0x43, 0x0e, 0xf8, 0xe0, 0x06, 0xe4,
+  0x20, 0x0e, 0xe7, 0xe0, 0x06, 0xf6, 0x10, 0x0e, 0xf2, 0xc0, 0x0e, 0xe1,
+  0x90, 0x0f, 0xef, 0x50, 0x0f, 0xf4, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x46, 0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe,
+  0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61, 0x00, 0x02,
+  0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11,
+  0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe,
+  0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6,
+  0x0d, 0x40, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x01, 0xcc, 0xb3, 0x10, 0x7e,
+  0x71, 0xdb, 0x26, 0x50, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x34, 0x39, 0x11,
+  0x81, 0x52, 0xd3, 0x43, 0x4d, 0x7e, 0x71, 0xdb, 0x06, 0x40, 0x30, 0x00,
+  0xd2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53,
+  0x48, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x58, 0xef,
+  0xcd, 0x6c, 0xfa, 0x5e, 0xef, 0x87, 0x2e, 0x7c, 0xbc, 0x3b, 0x5f, 0x38,
+  0xb8, 0x44, 0x58, 0x49, 0x4c, 0x8c, 0x07, 0x00, 0x00, 0x60, 0x00, 0x00,
+  0x00, 0xe3, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x74, 0x07, 0x00, 0x00, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0xda, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff,
+  0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff,
+  0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x7c, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08,
+  0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18,
+  0x80, 0x10, 0x52, 0x06, 0xa1, 0x9b, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90,
+  0xfc, 0x95, 0x90, 0x56, 0x62, 0xf2, 0x8b, 0xdb, 0x46, 0xc5, 0x18, 0x63,
+  0x10, 0x2a, 0xf7, 0x0c, 0x97, 0x3f, 0x61, 0x0f, 0x21, 0xf9, 0x21, 0xd0,
+  0x0c, 0x0b, 0x81, 0x82, 0x55, 0x18, 0x45, 0x18, 0x1b, 0x63, 0x0c, 0x42,
+  0xc8, 0xa0, 0x76, 0xd4, 0x70, 0xf9, 0x13, 0xf6, 0x10, 0x92, 0xcf, 0x6d,
+  0x54, 0xb1, 0x12, 0x93, 0x5f, 0xdc, 0x36, 0x22, 0xc6, 0x18, 0xa3, 0x10,
+  0x8f, 0x30, 0x42, 0x70, 0x8e, 0x20, 0x28, 0x06, 0x23, 0x85, 0x10, 0x49,
+  0x73, 0x20, 0x60, 0x18, 0x81, 0x18, 0x66, 0x6a, 0x83, 0x71, 0x60, 0x87,
+  0x70, 0x98, 0x87, 0x79, 0x70, 0x03, 0x5a, 0x28, 0x07, 0x7c, 0xa0, 0x87,
+  0x7a, 0x90, 0x87, 0x72, 0x90, 0x03, 0x52, 0xe0, 0x03, 0x7b, 0x28, 0x87,
+  0x71, 0xa0, 0x87, 0x77, 0x90, 0x07, 0x3e, 0x30, 0x07, 0x76, 0x78, 0x87,
+  0x70, 0xa0, 0x07, 0x36, 0x00, 0x03, 0x3a, 0xf0, 0x03, 0x30, 0xf0, 0x03,
+  0x3d, 0xd0, 0x83, 0x76, 0x48, 0x07, 0x78, 0x98, 0x87, 0x5f, 0xa0, 0x87,
+  0x7c, 0x80, 0x87, 0x72, 0x40, 0x01, 0x99, 0x49, 0x0c, 0xc6, 0x81, 0x1d,
+  0xc2, 0x61, 0x1e, 0xe6, 0xc1, 0x0d, 0x68, 0xa1, 0x1c, 0xf0, 0x81, 0x1e,
+  0xea, 0x41, 0x1e, 0xca, 0x41, 0x0e, 0x48, 0x81, 0x0f, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xf8, 0xc0, 0x1c, 0xd8, 0xe1, 0x1d,
+  0xc2, 0x81, 0x1e, 0xd8, 0x00, 0x0c, 0xe8, 0xc0, 0x0f, 0xc0, 0xc0, 0x0f,
+  0x90, 0x60, 0x2f, 0xe1, 0x4b, 0x38, 0xa7, 0x91, 0x26, 0xa0, 0x99, 0x24,
+  0xc4, 0x8c, 0x31, 0xc6, 0x18, 0x63, 0x58, 0x6b, 0x2d, 0xe9, 0x9b, 0xa4,
+  0x29, 0xa2, 0x84, 0xc9, 0x67, 0x01, 0xe6, 0x59, 0x88, 0x88, 0x9d, 0x80,
+  0x89, 0x40, 0x01, 0x21, 0x9e, 0x0e, 0x04, 0x00, 0x00, 0x13, 0x14, 0x72,
+  0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72,
+  0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e,
+  0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e,
+  0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x81, 0x80, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc8, 0x33, 0x01,
+  0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02,
+  0x50, 0x0c, 0x45, 0x50, 0x12, 0x05, 0x1c, 0x50, 0x06, 0xe5, 0x41, 0xa5,
+  0x24, 0xca, 0xa0, 0x10, 0x46, 0x00, 0x8a, 0xa0, 0x40, 0x28, 0xcf, 0x00,
+  0xd0, 0x9e, 0x01, 0xa0, 0x3e, 0x03, 0x40, 0x7e, 0x2c, 0x87, 0x21, 0x00,
+  0x00, 0x00, 0x9e, 0x07, 0x00, 0x02, 0x81, 0x40, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x6a, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13,
+  0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b,
+  0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b,
+  0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9,
+  0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x26, 0x08, 0x04,
+  0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x70, 0x73, 0x1b, 0x06, 0xc4, 0x20, 0x26,
+  0x08, 0x19, 0x45, 0x60, 0x82, 0x40, 0x24, 0x13, 0x04, 0x42, 0xd9, 0x20,
+  0x10, 0xcd, 0x86, 0x84, 0x50, 0x16, 0x82, 0x18, 0x18, 0xc2, 0xd9, 0x10,
+  0x3c, 0x13, 0x84, 0xad, 0x9a, 0x20, 0x10, 0xcb, 0x06, 0x84, 0x88, 0x16,
+  0x62, 0x18, 0x24, 0x60, 0x43, 0x30, 0x4d, 0x10, 0x3a, 0x6b, 0x03, 0x42,
+  0x54, 0x0b, 0x41, 0x0c, 0x04, 0xb0, 0x21, 0xb0, 0x36, 0x10, 0x10, 0x40,
+  0x5d, 0x13, 0x04, 0xef, 0xda, 0x10, 0x64, 0x13, 0x04, 0x01, 0x20, 0xd1,
+  0x16, 0x96, 0xe6, 0xc6, 0x65, 0xca, 0xea, 0x0b, 0xea, 0x6d, 0x2e, 0x8d,
+  0x2e, 0xed, 0xcd, 0x6d, 0x82, 0x50, 0x38, 0x13, 0x84, 0xe2, 0xd9, 0x10,
+  0x10, 0x13, 0x84, 0x02, 0x9a, 0x20, 0x14, 0xd1, 0x86, 0x85, 0xe8, 0xbc,
+  0x0f, 0x0c, 0xc2, 0x60, 0x08, 0x03, 0x42, 0x0c, 0x00, 0x22, 0x54, 0x45,
+  0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x13, 0x84, 0x42, 0x9a, 0x20, 0x10,
+  0xcc, 0x06, 0xc1, 0x0c, 0xcc, 0x60, 0xc3, 0x32, 0x90, 0x81, 0x27, 0x06,
+  0x60, 0x50, 0x06, 0x43, 0x19, 0x0c, 0x62, 0x70, 0x06, 0x2c, 0x86, 0x9e,
+  0x98, 0x9e, 0xa4, 0x26, 0x08, 0x44, 0xb3, 0x41, 0x30, 0x03, 0x35, 0xd8,
+  0xb0, 0x30, 0x69, 0xe0, 0x89, 0x01, 0x18, 0x94, 0xc1, 0x10, 0x06, 0x8c,
+  0x18, 0xac, 0xc1, 0x86, 0x61, 0x0c, 0xd0, 0x80, 0x0d, 0x98, 0x4c, 0x59,
+  0x7d, 0x51, 0x85, 0xc9, 0x9d, 0x95, 0xd1, 0x4d, 0x10, 0x8a, 0x69, 0xc3,
+  0x42, 0xb8, 0x81, 0xf7, 0x06, 0x60, 0x20, 0x06, 0x43, 0x18, 0x10, 0x62,
+  0xb0, 0x06, 0x1b, 0x02, 0x38, 0xd8, 0x30, 0xb4, 0x41, 0x1c, 0x00, 0x1b,
+  0x8a, 0x8d, 0x93, 0x03, 0x0c, 0xa8, 0xc2, 0xc6, 0x66, 0xd7, 0xe6, 0x92,
+  0x46, 0x56, 0xe6, 0x46, 0x37, 0x25, 0x08, 0xaa, 0x90, 0xe1, 0xb9, 0xd8,
+  0x95, 0xc9, 0xcd, 0xa5, 0xbd, 0xb9, 0x4d, 0x09, 0x88, 0x26, 0x64, 0x78,
+  0x2e, 0x76, 0x61, 0x6c, 0x76, 0x65, 0x72, 0x53, 0x02, 0xa3, 0x0e, 0x19,
+  0x9e, 0xcb, 0x1c, 0x5a, 0x18, 0x59, 0x99, 0x5c, 0xd3, 0x1b, 0x59, 0x19,
+  0xdb, 0x94, 0x00, 0x29, 0x43, 0x86, 0xe7, 0x22, 0x57, 0x36, 0xf7, 0x56,
+  0x27, 0x37, 0x56, 0x36, 0x37, 0x25, 0xb8, 0xea, 0x90, 0xe1, 0xb9, 0xd8,
+  0xa5, 0x95, 0xdd, 0x25, 0x91, 0x4d, 0xd1, 0x85, 0xd1, 0x95, 0x4d, 0x09,
+  0xb2, 0x3a, 0x64, 0x78, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x50, 0x6f,
+  0x69, 0x6e, 0x74, 0x73, 0x53, 0x02, 0x39, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc4, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x7a, 0x28,
+  0x87, 0x76, 0x80, 0x87, 0x19, 0xd1, 0x43, 0x0e, 0xf8, 0xe0, 0x06, 0xe4,
+  0x20, 0x0e, 0xe7, 0xe0, 0x06, 0xf6, 0x10, 0x0e, 0xf2, 0xc0, 0x0e, 0xe1,
+  0x90, 0x0f, 0xef, 0x50, 0x0f, 0xf4, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x46, 0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe,
+  0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61, 0x00, 0x02,
+  0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11,
+  0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe,
+  0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6,
+  0x0d, 0x40, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x01, 0xcc, 0xb3, 0x10, 0x7e,
+  0x71, 0xdb, 0x26, 0x50, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x34, 0x39, 0x11,
+  0x81, 0x52, 0xd3, 0x43, 0x4d, 0x7e, 0x71, 0xdb, 0x06, 0x40, 0x30, 0x00,
+  0xd2, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x46, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0x24, 0x47, 0x00, 0x88, 0xcc, 0x00, 0x14, 0x42, 0x29, 0x94, 0x5c,
+  0xe1, 0x95, 0x1d, 0x95, 0x12, 0xa0, 0x31, 0x03, 0x00, 0x23, 0x06, 0x09,
+  0x00, 0x82, 0x60, 0x30, 0x71, 0x05, 0xa4, 0x69, 0xc9, 0x88, 0x41, 0x02,
+  0x80, 0x20, 0x18, 0x4c, 0x9d, 0x31, 0x6d, 0x9b, 0x32, 0x62, 0x90, 0x00,
+  0x20, 0x08, 0x06, 0x93, 0x77, 0x44, 0x5c, 0xb7, 0x8c, 0x18, 0x24, 0x00,
+  0x08, 0x82, 0x81, 0x31, 0x06, 0xca, 0xd6, 0x4d, 0xcb, 0x88, 0x41, 0x02,
+  0x80, 0x20, 0x18, 0x18, 0x64, 0xb0, 0x70, 0x9e, 0xc1, 0x8c, 0x18, 0x24,
+  0x00, 0x08, 0x82, 0x81, 0x51, 0x06, 0x4c, 0xf7, 0x51, 0xcd, 0x88, 0x41,
+  0x02, 0x80, 0x20, 0x18, 0x18, 0x66, 0xd0, 0x78, 0x60, 0x80, 0x39, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x9c, 0x81, 0x23, 0x06, 0x61, 0x70,
+  0x3d, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0xa0, 0xc1, 0x33, 0x06,
+  0x62, 0xa0, 0x40, 0x23, 0x06, 0x0f, 0x00, 0x82, 0x60, 0xd0, 0x9c, 0x41,
+  0x93, 0x20, 0x42, 0xa0, 0x28, 0x63, 0x30, 0x06, 0x91, 0x32, 0x9a, 0x10,
+  0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09, 0xc4, 0x30,
+  0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0xd0, 0x1a, 0x44, 0x0c, 0x1a, 0x8c,
+  0x26, 0x04, 0x83, 0x19, 0x8d, 0x7c, 0x2c, 0x10, 0xe4, 0x63, 0x87, 0x23,
+  0x1f, 0x0b, 0x08, 0xf9, 0x18, 0xf2, 0xc8, 0xc7, 0x02, 0x43, 0x3e, 0x96,
+  0x40, 0xf2, 0x19, 0x31, 0x48, 0x00, 0x10, 0x04, 0x03, 0xc4, 0x0e, 0xba,
+  0x38, 0x88, 0x83, 0x33, 0x30, 0x46, 0x0c, 0x12, 0x00, 0x04, 0xc1, 0x00,
+  0xb1, 0x83, 0x2e, 0x0e, 0xe2, 0x20, 0x23, 0x46, 0x0c, 0x12, 0x00, 0x04,
+  0xc1, 0x00, 0xb1, 0x83, 0x2e, 0x0e, 0xe2, 0xc0, 0x0c, 0x84, 0x11, 0x83,
+  0x04, 0x00, 0x41, 0x30, 0x40, 0xec, 0xa0, 0x8b, 0x83, 0x38, 0x48, 0x83,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Textures.hlsl b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Textures.hlsl
new file mode 100644
index 0000000..f705742
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_PixelShader_Textures.hlsl
@@ -0,0 +1,8 @@
+
+#include "D3D12_PixelShader_Common.hlsli"
+
+[RootSignature(TextureRS)]
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    return GetOutputColor(texture0.Sample(sampler0, input.tex)) * input.color;
+}
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Advanced.h b/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Advanced.h
new file mode 100644
index 0000000..ac88cbb
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Advanced.h
@@ -0,0 +1,31 @@
+#if 0
+Disassembly failed
+#endif
+
+const unsigned char g_AdvancedRS[] = {
+  0x44, 0x58, 0x42, 0x43, 0x61, 0xd8, 0x65, 0x6e, 0x1d, 0x30, 0x64, 0x8a,
+  0x54, 0x75, 0xb7, 0x59, 0xea, 0x11, 0x73, 0xec, 0x01, 0x00, 0x00, 0x00,
+  0x24, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x52, 0x54, 0x53, 0x30, 0xf8, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xf8, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
+  0xe0, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Color.h b/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Color.h
new file mode 100644
index 0000000..e47eb5c
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Color.h
@@ -0,0 +1,16 @@
+#if 0
+Disassembly failed
+#endif
+
+const unsigned char g_ColorRS[] = {
+  0x44, 0x58, 0x42, 0x43, 0x1a, 0x67, 0x3b, 0x20, 0xac, 0xdc, 0xbb, 0xa0,
+  0x3c, 0x72, 0xa7, 0xdf, 0x14, 0xa5, 0x3a, 0x2e, 0x01, 0x00, 0x00, 0x00,
+  0x74, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x52, 0x54, 0x53, 0x30, 0x48, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Texture.h b/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Texture.h
new file mode 100644
index 0000000..2675b98
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_RootSig_Texture.h
@@ -0,0 +1,23 @@
+#if 0
+Disassembly failed
+#endif
+
+const unsigned char g_TextureRS[] = {
+  0x44, 0x58, 0x42, 0x43, 0xbc, 0x46, 0x63, 0x56, 0xe3, 0xea, 0x41, 0x4c,
+  0xf7, 0x90, 0x24, 0xc2, 0x14, 0x4d, 0x79, 0xdd, 0x01, 0x00, 0x00, 0x00,
+  0xcc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x52, 0x54, 0x53, 0x30, 0xa0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xa0, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_Shader_Common.hlsli b/SDL-3.2.8/src/render/direct3d12/D3D12_Shader_Common.hlsli
new file mode 100644
index 0000000..4bf8074
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_Shader_Common.hlsli
@@ -0,0 +1,37 @@
+#pragma pack_matrix( row_major )
+
+cbuffer VertexShaderConstants : register(b0)
+{
+    matrix model;
+    matrix projectionAndView;
+};
+
+#define ColorRS \
+    "RootFlags ( ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT |" \
+    "DENY_DOMAIN_SHADER_ROOT_ACCESS |" \
+    "DENY_GEOMETRY_SHADER_ROOT_ACCESS |" \
+    "DENY_HULL_SHADER_ROOT_ACCESS )," \
+    "RootConstants(num32BitConstants=32, b0)," \
+    "RootConstants(num32BitConstants=24, b1)"\
+
+#define TextureRS \
+    "RootFlags ( ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT |" \
+    "            DENY_DOMAIN_SHADER_ROOT_ACCESS |" \
+    "            DENY_GEOMETRY_SHADER_ROOT_ACCESS |" \
+    "            DENY_HULL_SHADER_ROOT_ACCESS )," \
+    "RootConstants(num32BitConstants=32, b0),"\
+    "RootConstants(num32BitConstants=24, b1),"\
+    "DescriptorTable ( SRV(t0), visibility = SHADER_VISIBILITY_PIXEL ),"\
+    "DescriptorTable ( Sampler(s0), visibility = SHADER_VISIBILITY_PIXEL )"
+
+#define AdvancedRS \
+    "RootFlags ( ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT |" \
+    "            DENY_DOMAIN_SHADER_ROOT_ACCESS |" \
+    "            DENY_GEOMETRY_SHADER_ROOT_ACCESS |" \
+    "            DENY_HULL_SHADER_ROOT_ACCESS )," \
+    "RootConstants(num32BitConstants=32, b0),"\
+    "RootConstants(num32BitConstants=24, b1),"\
+    "DescriptorTable ( SRV(t0), visibility = SHADER_VISIBILITY_PIXEL ),"\
+    "DescriptorTable ( SRV(t1), visibility = SHADER_VISIBILITY_PIXEL ),"\
+    "DescriptorTable ( SRV(t2), visibility = SHADER_VISIBILITY_PIXEL ),"\
+    "DescriptorTable ( Sampler(s0), visibility = SHADER_VISIBILITY_PIXEL )"
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader.hlsl b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader.hlsl
new file mode 100644
index 0000000..c7d2433
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader.hlsl
@@ -0,0 +1,45 @@
+#include "D3D12_Shader_Common.hlsli"
+
+struct VertexShaderInput
+{
+    float3 pos : POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+struct VertexShaderOutput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+[RootSignature(ColorRS)]
+VertexShaderOutput mainColor(VertexShaderInput input)
+{
+    VertexShaderOutput output;
+    float4 pos = float4(input.pos, 1.0f);
+
+    // Transform the vertex position into projected space.
+    pos = mul(pos, model);
+    pos = mul(pos, projectionAndView);
+    output.pos = pos;
+
+    // Pass through texture coordinates and color values without transformation
+    output.tex = input.tex;
+    output.color = input.color;
+
+    return output;
+}
+
+[RootSignature(TextureRS)]
+VertexShaderOutput mainTexture(VertexShaderInput input)
+{
+    return mainColor(input);
+}
+
+[RootSignature(AdvancedRS)]
+VertexShaderOutput mainAdvanced(VertexShaderInput input)
+{
+    return mainColor(input);
+}
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Advanced.h b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Advanced.h
new file mode 100644
index 0000000..5c358d5
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Advanced.h
@@ -0,0 +1,653 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; POSITION                 0   xyz         0     NONE   float   xyz 
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Position              0   xyzw        0      POS   float   xyzw
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+; shader hash: c170d994513745a8e268b8d54da903ed
+;
+; Pipeline Runtime Information: 
+;
+; Vertex Shader
+; OutputPositionPresent=1
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; POSITION                 0                              
+; TEXCOORD                 0                              
+; COLOR                    0                              
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Position              0          noperspective       
+; TEXCOORD                 0                 linear       
+; COLOR                    0                 linear       
+;
+; Buffer Definitions:
+;
+; cbuffer VertexShaderConstants
+; {
+;
+;   struct hostlayout.VertexShaderConstants
+;   {
+;
+;       row_major float4x4 model;                     ; Offset:    0
+;       row_major float4x4 projectionAndView;         ; Offset:   64
+;   
+;   } VertexShaderConstants;                          ; Offset:    0 Size:   128
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; VertexShaderConstants             cbuffer      NA          NA     CB0            cb0     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 12, outputs: 12
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 0, 1, 2 }
+;   output 1 depends on inputs: { 0, 1, 2 }
+;   output 2 depends on inputs: { 0, 1, 2 }
+;   output 3 depends on inputs: { 0, 1, 2 }
+;   output 4 depends on inputs: { 4 }
+;   output 5 depends on inputs: { 5 }
+;   output 8 depends on inputs: { 8 }
+;   output 9 depends on inputs: { 9 }
+;   output 10 depends on inputs: { 10 }
+;   output 11 depends on inputs: { 11 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%hostlayout.VertexShaderConstants = type { [4 x <4 x float>], [4 x <4 x float>] }
+
+define void @mainAdvanced() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %10 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %11 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %12 = extractvalue %dx.types.CBufRet.f32 %11, 0
+  %13 = extractvalue %dx.types.CBufRet.f32 %11, 1
+  %14 = extractvalue %dx.types.CBufRet.f32 %11, 2
+  %15 = extractvalue %dx.types.CBufRet.f32 %11, 3
+  %16 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %17 = extractvalue %dx.types.CBufRet.f32 %16, 0
+  %18 = extractvalue %dx.types.CBufRet.f32 %16, 1
+  %19 = extractvalue %dx.types.CBufRet.f32 %16, 2
+  %20 = extractvalue %dx.types.CBufRet.f32 %16, 3
+  %21 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 2)  ; CBufferLoadLegacy(handle,regIndex)
+  %22 = extractvalue %dx.types.CBufRet.f32 %21, 0
+  %23 = extractvalue %dx.types.CBufRet.f32 %21, 1
+  %24 = extractvalue %dx.types.CBufRet.f32 %21, 2
+  %25 = extractvalue %dx.types.CBufRet.f32 %21, 3
+  %26 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %27 = extractvalue %dx.types.CBufRet.f32 %26, 0
+  %28 = extractvalue %dx.types.CBufRet.f32 %26, 1
+  %29 = extractvalue %dx.types.CBufRet.f32 %26, 2
+  %30 = extractvalue %dx.types.CBufRet.f32 %26, 3
+  %31 = fmul fast float %12, %8
+  %32 = call float @dx.op.tertiary.f32(i32 46, float %9, float %17, float %31)  ; FMad(a,b,c)
+  %33 = call float @dx.op.tertiary.f32(i32 46, float %10, float %22, float %32)  ; FMad(a,b,c)
+  %34 = fadd fast float %33, %27
+  %35 = fmul fast float %13, %8
+  %36 = call float @dx.op.tertiary.f32(i32 46, float %9, float %18, float %35)  ; FMad(a,b,c)
+  %37 = call float @dx.op.tertiary.f32(i32 46, float %10, float %23, float %36)  ; FMad(a,b,c)
+  %38 = fadd fast float %37, %28
+  %39 = fmul fast float %14, %8
+  %40 = call float @dx.op.tertiary.f32(i32 46, float %9, float %19, float %39)  ; FMad(a,b,c)
+  %41 = call float @dx.op.tertiary.f32(i32 46, float %10, float %24, float %40)  ; FMad(a,b,c)
+  %42 = fadd fast float %41, %29
+  %43 = fmul fast float %15, %8
+  %44 = call float @dx.op.tertiary.f32(i32 46, float %9, float %20, float %43)  ; FMad(a,b,c)
+  %45 = call float @dx.op.tertiary.f32(i32 46, float %10, float %25, float %44)  ; FMad(a,b,c)
+  %46 = fadd fast float %45, %30
+  %47 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %48 = extractvalue %dx.types.CBufRet.f32 %47, 0
+  %49 = extractvalue %dx.types.CBufRet.f32 %47, 1
+  %50 = extractvalue %dx.types.CBufRet.f32 %47, 2
+  %51 = extractvalue %dx.types.CBufRet.f32 %47, 3
+  %52 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %53 = extractvalue %dx.types.CBufRet.f32 %52, 0
+  %54 = extractvalue %dx.types.CBufRet.f32 %52, 1
+  %55 = extractvalue %dx.types.CBufRet.f32 %52, 2
+  %56 = extractvalue %dx.types.CBufRet.f32 %52, 3
+  %57 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 6)  ; CBufferLoadLegacy(handle,regIndex)
+  %58 = extractvalue %dx.types.CBufRet.f32 %57, 0
+  %59 = extractvalue %dx.types.CBufRet.f32 %57, 1
+  %60 = extractvalue %dx.types.CBufRet.f32 %57, 2
+  %61 = extractvalue %dx.types.CBufRet.f32 %57, 3
+  %62 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 7)  ; CBufferLoadLegacy(handle,regIndex)
+  %63 = extractvalue %dx.types.CBufRet.f32 %62, 0
+  %64 = extractvalue %dx.types.CBufRet.f32 %62, 1
+  %65 = extractvalue %dx.types.CBufRet.f32 %62, 2
+  %66 = extractvalue %dx.types.CBufRet.f32 %62, 3
+  %67 = fmul fast float %48, %34
+  %68 = call float @dx.op.tertiary.f32(i32 46, float %38, float %53, float %67)  ; FMad(a,b,c)
+  %69 = call float @dx.op.tertiary.f32(i32 46, float %42, float %58, float %68)  ; FMad(a,b,c)
+  %70 = call float @dx.op.tertiary.f32(i32 46, float %46, float %63, float %69)  ; FMad(a,b,c)
+  %71 = fmul fast float %49, %34
+  %72 = call float @dx.op.tertiary.f32(i32 46, float %38, float %54, float %71)  ; FMad(a,b,c)
+  %73 = call float @dx.op.tertiary.f32(i32 46, float %42, float %59, float %72)  ; FMad(a,b,c)
+  %74 = call float @dx.op.tertiary.f32(i32 46, float %46, float %64, float %73)  ; FMad(a,b,c)
+  %75 = fmul fast float %50, %34
+  %76 = call float @dx.op.tertiary.f32(i32 46, float %38, float %55, float %75)  ; FMad(a,b,c)
+  %77 = call float @dx.op.tertiary.f32(i32 46, float %42, float %60, float %76)  ; FMad(a,b,c)
+  %78 = call float @dx.op.tertiary.f32(i32 46, float %46, float %65, float %77)  ; FMad(a,b,c)
+  %79 = fmul fast float %51, %34
+  %80 = call float @dx.op.tertiary.f32(i32 46, float %38, float %56, float %79)  ; FMad(a,b,c)
+  %81 = call float @dx.op.tertiary.f32(i32 46, float %42, float %61, float %80)  ; FMad(a,b,c)
+  %82 = call float @dx.op.tertiary.f32(i32 46, float %46, float %66, float %81)  ; FMad(a,b,c)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %70)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %74)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %78)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %82)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 0, float %6)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 1, float %7)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 0, float %2)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 1, float %3)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 2, float %4)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 3, float %5)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"clang version 3.7 (tags/RELEASE_370/final)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 6}
+!3 = !{!"vs", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %hostlayout.VertexShaderConstants* undef, !"", i32 0, i32 0, i32 1, i32 128, null}
+!7 = !{[14 x i32] [i32 12, i32 12, i32 15, i32 15, i32 15, i32 0, i32 16, i32 32, i32 0, i32 0, i32 256, i32 512, i32 1024, i32 2048]}
+!8 = !{void ()* @mainAdvanced, !"mainAdvanced", !9, !4, null}
+!9 = !{!10, !18, null}
+!10 = !{!11, !14, !16}
+!11 = !{i32 0, !"POSITION", i8 9, i8 0, !12, i8 0, i32 1, i8 3, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 7}
+!14 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 0, i32 1, i8 2, i32 1, i8 0, !15}
+!15 = !{i32 3, i32 3}
+!16 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 0, i32 1, i8 4, i32 2, i8 0, !17}
+!17 = !{i32 3, i32 15}
+!18 = !{!19, !20, !21}
+!19 = !{i32 0, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 0, i8 0, !17}
+!20 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 2, i32 1, i8 0, !15}
+!21 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 2, i8 0, !17}
+
+#endif
+
+const unsigned char g_mainAdvanced[] = {
+  0x44, 0x58, 0x42, 0x43, 0xff, 0x5d, 0x02, 0x19, 0xed, 0x89, 0xe9, 0x33,
+  0xf6, 0x5b, 0x76, 0x8c, 0x9f, 0x8b, 0x4d, 0xf1, 0x01, 0x00, 0x00, 0x00,
+  0x63, 0x13, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00,
+  0x87, 0x02, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, 0x3f, 0x0a, 0x00, 0x00,
+  0x5b, 0x0a, 0x00, 0x00, 0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31,
+  0x80, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x4f, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x54, 0x45, 0x58,
+  0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00,
+  0x4f, 0x53, 0x47, 0x31, 0x83, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x03, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x7d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44,
+  0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x50, 0x53, 0x56, 0x30, 0x1c,
+  0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x03,
+  0x03, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4f, 0x53, 0x49,
+  0x54, 0x49, 0x4f, 0x4e, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x54, 0x45, 0x58, 0x43,
+  0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x43, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x01, 0x42, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x03, 0x03,
+  0x04, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x01, 0x42, 0x00, 0x03, 0x02, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00, 0x0f,
+  0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x52,
+  0x54, 0x53, 0x30, 0xf8, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+  0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8,
+  0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01,
+  0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xe0,
+  0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0xff, 0x53, 0x54, 0x41, 0x54, 0xb0, 0x06, 0x00, 0x00, 0x60,
+  0x00, 0x01, 0x00, 0xac, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00,
+  0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x98, 0x06, 0x00, 0x00, 0x42,
+  0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xa3, 0x01, 0x00, 0x00, 0x0b,
+  0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07,
+  0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92,
+  0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80,
+  0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38,
+  0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43,
+  0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91,
+  0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04,
+  0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b,
+  0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84,
+  0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff,
+  0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00,
+  0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x32,
+  0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04,
+  0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b,
+  0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66, 0x00,
+  0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14, 0x42,
+  0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f, 0xb0,
+  0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11,
+  0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42, 0xf2,
+  0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42, 0xad,
+  0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4, 0x10,
+  0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x03, 0x83,
+  0xc3, 0x91, 0xa6, 0x05, 0xc0, 0x1c, 0x6a, 0xf2, 0x5f, 0x22, 0x9a, 0x88,
+  0x8b, 0x3d, 0x80, 0x81, 0x88, 0x38, 0xa7, 0x91, 0x26, 0xa0, 0x99, 0x24,
+  0x24, 0x58, 0x4b, 0x37, 0x1d, 0x08, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87,
+  0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87,
+  0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00,
+  0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x43, 0x9e, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x79, 0x80, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc8, 0x23, 0x01, 0x01, 0x30,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x14,
+  0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c,
+  0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c,
+  0x05, 0x28, 0x50, 0x04, 0x85, 0x50, 0x06, 0xe5, 0x50, 0x12, 0x05, 0x18,
+  0x50, 0x1e, 0x85, 0x51, 0xba, 0x01, 0x45, 0x41, 0xa5, 0x24, 0x46, 0x00,
+  0xca, 0xa0, 0x08, 0x0a, 0x81, 0x62, 0x0d, 0xd0, 0x9d, 0x01, 0x20, 0x3c,
+  0x03, 0x40, 0x79, 0x2c, 0x87, 0x61, 0x9e, 0xe7, 0x01, 0x20, 0x30, 0x00,
+  0x00, 0x10, 0x01, 0x21, 0x10, 0x0c, 0x40, 0x50, 0x00, 0x00, 0x00, 0x79,
+  0x18, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46,
+  0x02, 0x13, 0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b,
+  0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1,
+  0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa,
+  0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10,
+  0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x36,
+  0x08, 0x04, 0x41, 0xc1, 0x6e, 0x6e, 0x82, 0x40, 0x20, 0x1b, 0x86, 0x03,
+  0x21, 0x26, 0x08, 0xd8, 0xc6, 0xca, 0xaa, 0x4c, 0x8e, 0xae, 0x0c, 0x6f,
+  0x0a, 0x2d, 0x8c, 0xac, 0x4c, 0x6e, 0xe8, 0xcd, 0x6d, 0x8e, 0x2e, 0xcc,
+  0x8d, 0x6e, 0x6e, 0x82, 0x40, 0x24, 0x1b, 0x10, 0x42, 0x59, 0x08, 0x62,
+  0x60, 0x80, 0x0d, 0x41, 0xb3, 0x81, 0x00, 0x00, 0x07, 0x98, 0x20, 0x5c,
+  0x1a, 0x8b, 0xb6, 0x37, 0xb2, 0x32, 0xb6, 0x09, 0x02, 0xa1, 0x4c, 0x10,
+  0x88, 0x65, 0xc3, 0x30, 0x4d, 0xc3, 0x04, 0x81, 0x60, 0x26, 0x08, 0x44,
+  0x33, 0x41, 0x20, 0x9c, 0x09, 0x42, 0x94, 0x6d, 0x50, 0x90, 0x48, 0xa2,
+  0x2a, 0xc2, 0xba, 0x2e, 0x8c, 0x11, 0x9c, 0xdc, 0x9b, 0x5a, 0xd9, 0x18,
+  0x5d, 0xda, 0x9b, 0x5b, 0x90, 0x1b, 0x99, 0x55, 0x5a, 0xd9, 0xdd, 0x04,
+  0x81, 0x78, 0x36, 0x28, 0x88, 0x26, 0x51, 0xd5, 0x66, 0x5d, 0x17, 0xb6,
+  0x61, 0x60, 0x32, 0x6e, 0xc3, 0x40, 0x40, 0xdd, 0x04, 0x41, 0x00, 0x36,
+  0x00, 0x1b, 0x06, 0x02, 0x0c, 0xc0, 0x60, 0x43, 0x10, 0x06, 0x1b, 0x86,
+  0xe1, 0x13, 0x83, 0x09, 0x42, 0xc6, 0x6d, 0x08, 0xc8, 0x80, 0x4c, 0x5b,
+  0x58, 0x9a, 0x5b, 0x10, 0x99, 0x5d, 0x98, 0xdb, 0x58, 0x19, 0x19, 0x11,
+  0xa8, 0xa7, 0xa9, 0x24, 0xaa, 0xa4, 0x27, 0xa7, 0x09, 0x42, 0x41, 0x4d,
+  0x10, 0x8a, 0x6a, 0x43, 0x40, 0x4c, 0x10, 0x0a, 0x6b, 0x83, 0x50, 0x59,
+  0x1b, 0x16, 0xe2, 0x0c, 0xd0, 0x20, 0x0d, 0xd4, 0x20, 0x0d, 0x86, 0x35,
+  0x20, 0xd2, 0x80, 0x0d, 0x88, 0x50, 0x15, 0x61, 0x0d, 0x3d, 0x3d, 0x49,
+  0x11, 0x4d, 0x10, 0x8a, 0x6b, 0x83, 0x50, 0x55, 0x1b, 0x96, 0xc1, 0x0d,
+  0xd0, 0x20, 0x0d, 0xd4, 0x20, 0x0d, 0x86, 0x37, 0x18, 0xd2, 0x00, 0x0e,
+  0x58, 0x0c, 0x3d, 0x31, 0x3d, 0x49, 0x4d, 0x10, 0x0a, 0x6c, 0x82, 0x40,
+  0x40, 0x1b, 0x84, 0x8a, 0x0e, 0x36, 0x2c, 0x92, 0x1c, 0xa0, 0x41, 0x1a,
+  0xa8, 0x41, 0x1a, 0x0c, 0x73, 0x20, 0xa5, 0x41, 0x1d, 0x6c, 0x18, 0xda,
+  0x20, 0x0e, 0xec, 0x80, 0xcb, 0x94, 0xd5, 0x17, 0xd4, 0xdb, 0x5c, 0x1a,
+  0x5d, 0xda, 0x9b, 0xdb, 0x86, 0x85, 0xc0, 0x03, 0x34, 0x58, 0x03, 0x35,
+  0x98, 0x83, 0x61, 0x0e, 0x88, 0x34, 0xa8, 0x83, 0x0d, 0xcb, 0xe0, 0x06,
+  0x68, 0x90, 0x06, 0x6a, 0xf0, 0x06, 0xc3, 0x1b, 0x0c, 0x69, 0x00, 0x07,
+  0x1b, 0x16, 0x49, 0x0e, 0xd0, 0x20, 0x0d, 0xd4, 0xe0, 0x0d, 0x86, 0x39,
+  0x90, 0xd2, 0xa0, 0x0e, 0x36, 0x0c, 0x79, 0xa0, 0x07, 0x7b, 0xb0, 0x61,
+  0xb8, 0x03, 0x3e, 0x00, 0x36, 0x14, 0x9f, 0x19, 0xf4, 0xc1, 0x03, 0xd0,
+  0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x9b, 0x9b, 0x20, 0x10, 0x11, 0x8b, 0x34,
+  0xb7, 0x39, 0xba, 0xb9, 0x09, 0x02, 0x21, 0xd1, 0x98, 0x4b, 0x3b, 0xfb,
+  0x62, 0x23, 0xa3, 0x31, 0x97, 0x76, 0xf6, 0x35, 0x47, 0x37, 0x41, 0x20,
+  0xa6, 0x0d, 0xc8, 0x1f, 0x80, 0x42, 0x28, 0x88, 0xc2, 0x28, 0x5c, 0xa4,
+  0x50, 0x0a, 0x55, 0xd8, 0xd8, 0xec, 0xda, 0x5c, 0xd2, 0xc8, 0xca, 0xdc,
+  0xe8, 0xa6, 0x04, 0x41, 0x15, 0x32, 0x3c, 0x17, 0xbb, 0x32, 0xb9, 0xb9,
+  0xb4, 0x37, 0xb7, 0x29, 0x01, 0xd1, 0x84, 0x0c, 0xcf, 0xc5, 0x2e, 0x8c,
+  0xcd, 0xae, 0x4c, 0x6e, 0x4a, 0x50, 0xd4, 0x21, 0xc3, 0x73, 0x99, 0x43,
+  0x0b, 0x23, 0x2b, 0x93, 0x6b, 0x7a, 0x23, 0x2b, 0x63, 0x9b, 0x12, 0x20,
+  0x65, 0xc8, 0xf0, 0x5c, 0xe4, 0xca, 0xe6, 0xde, 0xea, 0xe4, 0xc6, 0xca,
+  0xe6, 0xa6, 0x04, 0x4e, 0x25, 0x32, 0x3c, 0x17, 0xba, 0x3c, 0xb8, 0xb2,
+  0x20, 0x37, 0xb7, 0x37, 0xba, 0x30, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x29,
+  0x42, 0x27, 0x06, 0x75, 0xc8, 0xf0, 0x5c, 0xec, 0xd2, 0xca, 0xee, 0x92,
+  0xc8, 0xa6, 0xe8, 0xc2, 0xe8, 0xca, 0xa6, 0x04, 0x64, 0x50, 0x87, 0x0c,
+  0xcf, 0xa5, 0xcc, 0x8d, 0x4e, 0x2e, 0x0f, 0xea, 0x2d, 0xcd, 0x8d, 0x6e,
+  0x6e, 0x4a, 0xd0, 0x07, 0x5d, 0xc8, 0xf0, 0x5c, 0xc6, 0xde, 0xea, 0xdc,
+  0xe8, 0xca, 0xe4, 0xe6, 0xa6, 0x04, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x79,
+  0x18, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4,
+  0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c,
+  0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00,
+  0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2,
+  0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d,
+  0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87,
+  0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87,
+  0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30,
+  0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde,
+  0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b,
+  0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c,
+  0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87,
+  0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87,
+  0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87,
+  0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0,
+  0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38,
+  0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b,
+  0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03,
+  0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87,
+  0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x71,
+  0x20, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97, 0xef,
+  0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61,
+  0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce, 0xe3,
+  0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34,
+  0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f,
+  0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e, 0x44,
+  0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3, 0xe5,
+  0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7, 0x6d,
+  0x00, 0x0c, 0x03, 0x20, 0x8d, 0x36, 0x54, 0x40, 0x23, 0x10, 0x03, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x14,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x70, 0xd9, 0x94, 0x51,
+  0x37, 0x45, 0xa8, 0xe2, 0x68, 0xb8, 0xd5, 0x4d, 0xa9, 0x03, 0xed, 0x44,
+  0x58, 0x49, 0x4c, 0x00, 0x09, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0x40,
+  0x02, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0xe8, 0x08, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21,
+  0x0c, 0x00, 0x00, 0x37, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41,
+  0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25,
+  0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42,
+  0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a,
+  0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00,
+  0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41,
+  0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51,
+  0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff,
+  0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff,
+  0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00,
+  0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13,
+  0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89,
+  0x20, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20,
+  0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84,
+  0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10,
+  0x68, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60,
+  0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10,
+  0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e,
+  0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54,
+  0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16,
+  0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c, 0x31,
+  0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e, 0x04,
+  0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x03, 0x83, 0xc3, 0x91, 0xa6, 0x05,
+  0xc0, 0x1c, 0x6a, 0xf2, 0x5f, 0x22, 0x9a, 0x88, 0x8b, 0x3d, 0x80, 0x81,
+  0x88, 0x38, 0xa7, 0x91, 0x26, 0xa0, 0x99, 0x24, 0x24, 0x58, 0x4b, 0x37,
+  0x1d, 0x08, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36,
+  0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e,
+  0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c,
+  0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+  0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0xe4, 0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x60, 0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x32,
+  0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6,
+  0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x28, 0x50, 0x06,
+  0xe5, 0x50, 0x04, 0xe5, 0x41, 0xa5, 0x24, 0x46, 0x00, 0xca, 0xa0, 0x08,
+  0x0a, 0x81, 0xf0, 0x0c, 0x00, 0xe5, 0xb1, 0x1c, 0x86, 0x79, 0x9e, 0x07,
+  0x80, 0xc0, 0x00, 0x00, 0x40, 0x04, 0x84, 0x40, 0x30, 0x00, 0x41, 0x01,
+  0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x1a,
+  0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0x44, 0x35, 0x18, 0x63, 0x0b, 0x73,
+  0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71,
+  0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a,
+  0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b,
+  0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7,
+  0x06, 0x61, 0x20, 0x26, 0x08, 0x04, 0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x76,
+  0x73, 0x1b, 0x06, 0xc4, 0x20, 0x26, 0x08, 0xd8, 0x44, 0x60, 0x82, 0x40,
+  0x24, 0x1b, 0x10, 0x42, 0x59, 0x08, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3,
+  0x81, 0x00, 0x00, 0x07, 0x98, 0x20, 0x64, 0xd4, 0x86, 0x00, 0x9a, 0x20,
+  0x08, 0x00, 0x99, 0xb6, 0xb0, 0x34, 0xb7, 0x20, 0x32, 0xbb, 0x30, 0xb7,
+  0xb1, 0x32, 0x32, 0x22, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e,
+  0x13, 0x84, 0xc2, 0x99, 0x20, 0x14, 0xcf, 0x86, 0x80, 0x98, 0x20, 0x14,
+  0xd0, 0x04, 0x81, 0x50, 0x26, 0x08, 0xc4, 0xb2, 0x41, 0xc8, 0xb4, 0x0d,
+  0x0b, 0x41, 0x55, 0xd6, 0x65, 0x0d, 0x18, 0x61, 0x6d, 0x44, 0xa8, 0x8a,
+  0xb0, 0x86, 0x9e, 0x9e, 0xa4, 0x88, 0x26, 0x08, 0x45, 0xb4, 0x41, 0xc8,
+  0xb2, 0x0d, 0xcb, 0xd0, 0x55, 0xd6, 0x65, 0x0d, 0xde, 0x60, 0x7d, 0x13,
+  0x04, 0x82, 0x61, 0x31, 0xf4, 0xc4, 0xf4, 0x24, 0x35, 0x41, 0x28, 0xa4,
+  0x09, 0x02, 0xd1, 0x6c, 0x10, 0x32, 0x32, 0xd8, 0xb0, 0x84, 0x81, 0x18,
+  0x54, 0xd6, 0x65, 0x0d, 0x63, 0x10, 0x06, 0x56, 0x19, 0x6c, 0x18, 0x38,
+  0x30, 0x30, 0x03, 0x2e, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x1b, 0x16, 0x02, 0x0d, 0x2a, 0xec, 0x1a, 0x83, 0x61,
+  0x0c, 0x08, 0xab, 0x0c, 0x36, 0x2c, 0x43, 0x57, 0x59, 0x97, 0x37, 0x78,
+  0x83, 0xf5, 0x6d, 0x58, 0xc2, 0x40, 0x0c, 0x2a, 0xeb, 0xf2, 0x86, 0x31,
+  0x08, 0x03, 0xab, 0x0c, 0x36, 0x0c, 0x69, 0xa0, 0x06, 0x6b, 0xb0, 0x61,
+  0x38, 0x03, 0x36, 0x00, 0x36, 0x14, 0xd2, 0xd4, 0x06, 0x0f, 0x50, 0x85,
+  0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x4a, 0x10,
+  0x54, 0x21, 0xc3, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x9b,
+  0x12, 0x10, 0x4d, 0xc8, 0xf0, 0x5c, 0xec, 0xc2, 0xd8, 0xec, 0xca, 0xe4,
+  0xa6, 0x04, 0x46, 0x1d, 0x32, 0x3c, 0x97, 0x39, 0xb4, 0x30, 0xb2, 0x32,
+  0xb9, 0xa6, 0x37, 0xb2, 0x32, 0xb6, 0x29, 0x01, 0x52, 0x86, 0x0c, 0xcf,
+  0x45, 0xae, 0x6c, 0xee, 0xad, 0x4e, 0x6e, 0xac, 0x6c, 0x6e, 0x4a, 0xe0,
+  0xd4, 0x21, 0xc3, 0x73, 0xb1, 0x4b, 0x2b, 0xbb, 0x4b, 0x22, 0x9b, 0xa2,
+  0x0b, 0xa3, 0x2b, 0x9b, 0x12, 0x40, 0x75, 0xc8, 0xf0, 0x5c, 0xca, 0xdc,
+  0xe8, 0xe4, 0xf2, 0xa0, 0xde, 0xd2, 0xdc, 0xe8, 0xe6, 0xa6, 0x04, 0x6d,
+  0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x33,
+  0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98,
+  0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33,
+  0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43,
+  0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08,
+  0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78,
+  0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1,
+  0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33,
+  0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e,
+  0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03,
+  0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80,
+  0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8,
+  0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18,
+  0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee,
+  0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c,
+  0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3,
+  0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83,
+  0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21,
+  0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08,
+  0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x00,
+  0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x36,
+  0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5,
+  0x03, 0x0c, 0x25, 0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2,
+  0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3,
+  0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62,
+  0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f,
+  0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6,
+  0x11, 0x48, 0xc3, 0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11,
+  0xe6, 0x17, 0xb7, 0x6d, 0x00, 0x0c, 0x03, 0x20, 0x8d, 0x36, 0x54, 0x40,
+  0x23, 0x10, 0x03, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0xcf,
+  0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x44, 0x8a, 0xab, 0x14, 0x0a, 0x61, 0x06, 0xa0, 0xec,
+  0x4a, 0x8e, 0x4a, 0x09, 0x50, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x20, 0x61, 0x03, 0x63, 0x59, 0xc1, 0x88,
+  0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0xdd, 0x21, 0x5d, 0x8f, 0x31, 0x62,
+  0x90, 0x00, 0x20, 0x08, 0x06, 0x86, 0x87, 0x4c, 0x18, 0x71, 0x8c, 0x18,
+  0x24, 0x00, 0x08, 0x82, 0x81, 0xf1, 0x25, 0x54, 0xf6, 0x20, 0x23, 0x06,
+  0x09, 0x00, 0x82, 0x60, 0x60, 0x80, 0x81, 0x52, 0x69, 0x51, 0x32, 0x62,
+  0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x18, 0x2c, 0xdc, 0x36, 0x29, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x88, 0x01, 0xd3, 0x71, 0xc8, 0x32,
+  0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0xc6, 0x18, 0x34, 0x5d, 0x57, 0x31,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x90, 0x81, 0xe3, 0x79, 0x4a,
+  0x33, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x19, 0x3c, 0xdf, 0x57,
+  0x39, 0x23, 0x06, 0x07, 0x00, 0x82, 0x60, 0xd0, 0x90, 0x81, 0xa3, 0x80,
+  0xc1, 0x68, 0x42, 0x00, 0x8c, 0x26, 0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c,
+  0x26, 0x10, 0xc3, 0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0x69, 0x30,
+  0x3d, 0x66, 0x30, 0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30,
+  0x08, 0xa3, 0x09, 0xc4, 0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x8d,
+  0x1b, 0x60, 0x54, 0x19, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0xc2, 0x68, 0x02, 0x31, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82,
+  0x41, 0x33, 0x07, 0x5d, 0xc6, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x9a, 0x20,
+  0x04, 0xa3, 0x09, 0x83, 0x30, 0x9a, 0x40, 0x0c, 0x36, 0x5d, 0xf2, 0x19,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x07, 0x0f, 0xce, 0xe0, 0x7a, 0x82,
+  0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0xf2, 0x00, 0x0d, 0xae, 0x25,
+  0xb0, 0xe0, 0x80, 0x8e, 0x59, 0x9b, 0x7c, 0x46, 0x0c, 0x10, 0x00, 0x04,
+  0xc1, 0xe0, 0xe1, 0x83, 0x35, 0xd8, 0xa4, 0x60, 0xc4, 0x00, 0x01, 0x40,
+  0x10, 0x0c, 0x9e, 0x3e, 0x60, 0x83, 0xcd, 0x09, 0x2c, 0x50, 0xa0, 0x63,
+  0xd9, 0x27, 0x9f, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0x40, 0xe1,
+  0x0d, 0xbe, 0x2a, 0x18, 0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x27, 0x14,
+  0xe0, 0xe0, 0x8b, 0x02, 0x0b, 0x1a, 0xe8, 0x18, 0x37, 0x06, 0xf2, 0x19,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x14, 0xe6, 0x60, 0x0c, 0xb0,
+  0x60, 0xc4, 0x00, 0x01, 0x40, 0x10, 0x0c, 0x9e, 0x52, 0xa0, 0x83, 0x31,
+  0xa0, 0x02, 0x0b, 0x20, 0xe8, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x41,
+  0x83, 0x0a, 0x72, 0xe0, 0x06, 0x74, 0x30, 0x9a, 0x10, 0x00, 0xa3, 0x09,
+  0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09, 0xc4, 0x30, 0x62, 0x70, 0x00,
+  0x20, 0x08, 0x06, 0x4d, 0x2b, 0xdc, 0xc1, 0x1c, 0xe8, 0xc1, 0x68, 0x42,
+  0x00, 0x8c, 0x26, 0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c, 0x26, 0x10, 0xc3,
+  0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0xb2, 0xc0, 0x07, 0x78, 0xd0,
+  0x0a, 0xa3, 0x09, 0x01, 0x30, 0x9a, 0x20, 0x04, 0xa3, 0x09, 0x83, 0x30,
+  0x9a, 0x40, 0x0c, 0x23, 0x06, 0x07, 0x00, 0x82, 0x60, 0xd0, 0xdc, 0x42,
+  0x28, 0xf4, 0xc1, 0x2b, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0xc2, 0x68, 0x02, 0x31, 0xd8, 0x14, 0x06, 0xf2, 0x19, 0x31,
+  0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x17, 0x56, 0xc1, 0x7b, 0x82, 0x11,
+  0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0x7a, 0x81, 0x15, 0xb6, 0x25, 0x18,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0xc7, 0x17, 0x5a, 0x01, 0x3b, 0x02,
+  0xb3, 0xca, 0x40, 0x3e, 0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0xf0, 0x80,
+  0xc3, 0x2b, 0x88, 0x81, 0x14, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0xc1,
+  0x13, 0x0e, 0xb0, 0xf0, 0x39, 0xc1, 0x88, 0x01, 0x02, 0x80, 0x20, 0x18,
+  0x3c, 0xe2, 0x10, 0x0b, 0x9c, 0x12, 0x58, 0x96, 0x06, 0xf2, 0x19, 0x31,
+  0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x1c, 0x66, 0xc1, 0x0c, 0xaa, 0x60,
+  0xc4, 0x00, 0x01, 0x40, 0x10, 0x0c, 0x9e, 0x72, 0xa0, 0x85, 0x31, 0x88,
+  0x82, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0xcc, 0xa1, 0x16, 0xc0,
+  0xa0, 0x09, 0x8c, 0x6b, 0x03, 0xf9, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82,
+  0xc1, 0x83, 0x0e, 0xb7, 0xa0, 0x06, 0x58, 0x30, 0x62, 0x80, 0x00, 0x20,
+  0x08, 0x06, 0x4f, 0x3a, 0xe0, 0xc2, 0x19, 0x50, 0xc1, 0x88, 0x01, 0x02,
+  0x80, 0x20, 0x18, 0x3c, 0xea, 0x90, 0x0b, 0x64, 0x00, 0x05, 0x23, 0x06,
+  0x09, 0x00, 0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0xa0, 0x03, 0x3a, 0x80,
+  0x43, 0x33, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0x02,
+  0x3a, 0xa0, 0x03, 0x2d, 0x24, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80,
+  0xb4, 0x43, 0x2e, 0xa0, 0x03, 0x3a, 0xf8, 0x42, 0x31, 0x62, 0x90, 0x00,
+  0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0x02, 0x3a, 0xa0, 0xc3, 0x2f, 0x04,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0xa4, 0x03,
+  0x3a, 0x80, 0x43, 0x2b, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xd2,
+  0x0e, 0xb9, 0x90, 0x0e, 0xe8, 0x40, 0x0b, 0xac, 0x30, 0x62, 0x90, 0x00,
+  0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0xc2, 0x38, 0xa0, 0x03, 0x38, 0xc4,
+  0xc2, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0xed, 0x90, 0x0b, 0xe3,
+  0x80, 0x0e, 0xb4, 0x00, 0x0b, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80,
+  0xb4, 0x43, 0x2e, 0x8c, 0x03, 0x3a, 0xf8, 0xc2, 0x2b, 0x8c, 0x18, 0x24,
+  0x00, 0x08, 0x82, 0x01, 0xd2, 0x0e, 0xb9, 0x30, 0x0e, 0xe8, 0xf0, 0x0b,
+  0xae, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Color.h b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Color.h
new file mode 100644
index 0000000..36909c1
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Color.h
@@ -0,0 +1,637 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; POSITION                 0   xyz         0     NONE   float   xyz 
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Position              0   xyzw        0      POS   float   xyzw
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+; shader hash: 466968c79e75899fd3e9065346b2df1c
+;
+; Pipeline Runtime Information: 
+;
+; Vertex Shader
+; OutputPositionPresent=1
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; POSITION                 0                              
+; TEXCOORD                 0                              
+; COLOR                    0                              
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Position              0          noperspective       
+; TEXCOORD                 0                 linear       
+; COLOR                    0                 linear       
+;
+; Buffer Definitions:
+;
+; cbuffer VertexShaderConstants
+; {
+;
+;   struct hostlayout.VertexShaderConstants
+;   {
+;
+;       row_major float4x4 model;                     ; Offset:    0
+;       row_major float4x4 projectionAndView;         ; Offset:   64
+;   
+;   } VertexShaderConstants;                          ; Offset:    0 Size:   128
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; VertexShaderConstants             cbuffer      NA          NA     CB0            cb0     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 12, outputs: 12
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 0, 1, 2 }
+;   output 1 depends on inputs: { 0, 1, 2 }
+;   output 2 depends on inputs: { 0, 1, 2 }
+;   output 3 depends on inputs: { 0, 1, 2 }
+;   output 4 depends on inputs: { 4 }
+;   output 5 depends on inputs: { 5 }
+;   output 8 depends on inputs: { 8 }
+;   output 9 depends on inputs: { 9 }
+;   output 10 depends on inputs: { 10 }
+;   output 11 depends on inputs: { 11 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%hostlayout.VertexShaderConstants = type { [4 x <4 x float>], [4 x <4 x float>] }
+
+define void @mainColor() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %10 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %11 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %12 = extractvalue %dx.types.CBufRet.f32 %11, 0
+  %13 = extractvalue %dx.types.CBufRet.f32 %11, 1
+  %14 = extractvalue %dx.types.CBufRet.f32 %11, 2
+  %15 = extractvalue %dx.types.CBufRet.f32 %11, 3
+  %16 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %17 = extractvalue %dx.types.CBufRet.f32 %16, 0
+  %18 = extractvalue %dx.types.CBufRet.f32 %16, 1
+  %19 = extractvalue %dx.types.CBufRet.f32 %16, 2
+  %20 = extractvalue %dx.types.CBufRet.f32 %16, 3
+  %21 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 2)  ; CBufferLoadLegacy(handle,regIndex)
+  %22 = extractvalue %dx.types.CBufRet.f32 %21, 0
+  %23 = extractvalue %dx.types.CBufRet.f32 %21, 1
+  %24 = extractvalue %dx.types.CBufRet.f32 %21, 2
+  %25 = extractvalue %dx.types.CBufRet.f32 %21, 3
+  %26 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %27 = extractvalue %dx.types.CBufRet.f32 %26, 0
+  %28 = extractvalue %dx.types.CBufRet.f32 %26, 1
+  %29 = extractvalue %dx.types.CBufRet.f32 %26, 2
+  %30 = extractvalue %dx.types.CBufRet.f32 %26, 3
+  %31 = fmul fast float %12, %8
+  %32 = call float @dx.op.tertiary.f32(i32 46, float %9, float %17, float %31)  ; FMad(a,b,c)
+  %33 = call float @dx.op.tertiary.f32(i32 46, float %10, float %22, float %32)  ; FMad(a,b,c)
+  %34 = fadd fast float %33, %27
+  %35 = fmul fast float %13, %8
+  %36 = call float @dx.op.tertiary.f32(i32 46, float %9, float %18, float %35)  ; FMad(a,b,c)
+  %37 = call float @dx.op.tertiary.f32(i32 46, float %10, float %23, float %36)  ; FMad(a,b,c)
+  %38 = fadd fast float %37, %28
+  %39 = fmul fast float %14, %8
+  %40 = call float @dx.op.tertiary.f32(i32 46, float %9, float %19, float %39)  ; FMad(a,b,c)
+  %41 = call float @dx.op.tertiary.f32(i32 46, float %10, float %24, float %40)  ; FMad(a,b,c)
+  %42 = fadd fast float %41, %29
+  %43 = fmul fast float %15, %8
+  %44 = call float @dx.op.tertiary.f32(i32 46, float %9, float %20, float %43)  ; FMad(a,b,c)
+  %45 = call float @dx.op.tertiary.f32(i32 46, float %10, float %25, float %44)  ; FMad(a,b,c)
+  %46 = fadd fast float %45, %30
+  %47 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %48 = extractvalue %dx.types.CBufRet.f32 %47, 0
+  %49 = extractvalue %dx.types.CBufRet.f32 %47, 1
+  %50 = extractvalue %dx.types.CBufRet.f32 %47, 2
+  %51 = extractvalue %dx.types.CBufRet.f32 %47, 3
+  %52 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %53 = extractvalue %dx.types.CBufRet.f32 %52, 0
+  %54 = extractvalue %dx.types.CBufRet.f32 %52, 1
+  %55 = extractvalue %dx.types.CBufRet.f32 %52, 2
+  %56 = extractvalue %dx.types.CBufRet.f32 %52, 3
+  %57 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 6)  ; CBufferLoadLegacy(handle,regIndex)
+  %58 = extractvalue %dx.types.CBufRet.f32 %57, 0
+  %59 = extractvalue %dx.types.CBufRet.f32 %57, 1
+  %60 = extractvalue %dx.types.CBufRet.f32 %57, 2
+  %61 = extractvalue %dx.types.CBufRet.f32 %57, 3
+  %62 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 7)  ; CBufferLoadLegacy(handle,regIndex)
+  %63 = extractvalue %dx.types.CBufRet.f32 %62, 0
+  %64 = extractvalue %dx.types.CBufRet.f32 %62, 1
+  %65 = extractvalue %dx.types.CBufRet.f32 %62, 2
+  %66 = extractvalue %dx.types.CBufRet.f32 %62, 3
+  %67 = fmul fast float %48, %34
+  %68 = call float @dx.op.tertiary.f32(i32 46, float %38, float %53, float %67)  ; FMad(a,b,c)
+  %69 = call float @dx.op.tertiary.f32(i32 46, float %42, float %58, float %68)  ; FMad(a,b,c)
+  %70 = call float @dx.op.tertiary.f32(i32 46, float %46, float %63, float %69)  ; FMad(a,b,c)
+  %71 = fmul fast float %49, %34
+  %72 = call float @dx.op.tertiary.f32(i32 46, float %38, float %54, float %71)  ; FMad(a,b,c)
+  %73 = call float @dx.op.tertiary.f32(i32 46, float %42, float %59, float %72)  ; FMad(a,b,c)
+  %74 = call float @dx.op.tertiary.f32(i32 46, float %46, float %64, float %73)  ; FMad(a,b,c)
+  %75 = fmul fast float %50, %34
+  %76 = call float @dx.op.tertiary.f32(i32 46, float %38, float %55, float %75)  ; FMad(a,b,c)
+  %77 = call float @dx.op.tertiary.f32(i32 46, float %42, float %60, float %76)  ; FMad(a,b,c)
+  %78 = call float @dx.op.tertiary.f32(i32 46, float %46, float %65, float %77)  ; FMad(a,b,c)
+  %79 = fmul fast float %51, %34
+  %80 = call float @dx.op.tertiary.f32(i32 46, float %38, float %56, float %79)  ; FMad(a,b,c)
+  %81 = call float @dx.op.tertiary.f32(i32 46, float %42, float %61, float %80)  ; FMad(a,b,c)
+  %82 = call float @dx.op.tertiary.f32(i32 46, float %46, float %66, float %81)  ; FMad(a,b,c)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %70)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %74)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %78)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %82)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 0, float %6)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 1, float %7)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 0, float %2)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 1, float %3)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 2, float %4)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 3, float %5)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"clang version 3.7 (tags/RELEASE_370/final)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 6}
+!3 = !{!"vs", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %hostlayout.VertexShaderConstants* undef, !"", i32 0, i32 0, i32 1, i32 128, null}
+!7 = !{[14 x i32] [i32 12, i32 12, i32 15, i32 15, i32 15, i32 0, i32 16, i32 32, i32 0, i32 0, i32 256, i32 512, i32 1024, i32 2048]}
+!8 = !{void ()* @mainColor, !"mainColor", !9, !4, null}
+!9 = !{!10, !18, null}
+!10 = !{!11, !14, !16}
+!11 = !{i32 0, !"POSITION", i8 9, i8 0, !12, i8 0, i32 1, i8 3, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 7}
+!14 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 0, i32 1, i8 2, i32 1, i8 0, !15}
+!15 = !{i32 3, i32 3}
+!16 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 0, i32 1, i8 4, i32 2, i8 0, !17}
+!17 = !{i32 3, i32 15}
+!18 = !{!19, !20, !21}
+!19 = !{i32 0, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 0, i8 0, !17}
+!20 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 2, i32 1, i8 0, !15}
+!21 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 2, i8 0, !17}
+
+#endif
+
+const unsigned char g_mainColor[] = {
+  0x44, 0x58, 0x42, 0x43, 0x28, 0x20, 0xca, 0xe8, 0xab, 0xe5, 0x24, 0x7a,
+  0x5d, 0x2b, 0x6f, 0xa4, 0x2c, 0x10, 0xa8, 0xb6, 0x01, 0x00, 0x00, 0x00,
+  0xa3, 0x12, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00,
+  0x87, 0x02, 0x00, 0x00, 0xd7, 0x02, 0x00, 0x00, 0x87, 0x09, 0x00, 0x00,
+  0xa3, 0x09, 0x00, 0x00, 0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31,
+  0x80, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x4f, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x54, 0x45, 0x58,
+  0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00,
+  0x4f, 0x53, 0x47, 0x31, 0x83, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x03, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x7d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44,
+  0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x50, 0x53, 0x56, 0x30, 0x1c,
+  0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x03,
+  0x03, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4f, 0x53, 0x49,
+  0x54, 0x49, 0x4f, 0x4e, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x54, 0x45, 0x58, 0x43,
+  0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x43, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x01, 0x42, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x03, 0x03,
+  0x04, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x01, 0x42, 0x00, 0x03, 0x02, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00, 0x0f,
+  0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x52,
+  0x54, 0x53, 0x30, 0x48, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48,
+  0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54, 0xa8,
+  0x06, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0xaa, 0x01, 0x00, 0x00, 0x44,
+  0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x90,
+  0x06, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xa1,
+  0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+  0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06,
+  0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e,
+  0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4,
+  0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48,
+  0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4,
+  0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1,
+  0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40,
+  0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d,
+  0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49,
+  0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20,
+  0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x26,
+  0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93,
+  0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12,
+  0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00, 0x25,
+  0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6,
+  0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3,
+  0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98,
+  0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f,
+  0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10,
+  0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04,
+  0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43,
+  0x12, 0xd4, 0x03, 0x83, 0xc3, 0x91, 0xa6, 0x05, 0xc0, 0x1c, 0x6a, 0xf2,
+  0x5f, 0x22, 0x9a, 0x88, 0x8b, 0x3d, 0x80, 0x81, 0x88, 0x38, 0xa7, 0x91,
+  0x26, 0xa0, 0x99, 0x24, 0x24, 0x58, 0x4b, 0x37, 0x1d, 0x08, 0x00, 0x13,
+  0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68,
+  0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a,
+  0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
+  0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40,
+  0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x79,
+  0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc8,
+  0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+  0x16, 0x08, 0x00, 0x14, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19,
+  0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25,
+  0x30, 0x02, 0x50, 0x0c, 0x05, 0x28, 0x50, 0x04, 0x85, 0x50, 0x06, 0xe5,
+  0x50, 0x12, 0x05, 0x18, 0x50, 0x1e, 0x85, 0x51, 0xba, 0x01, 0x45, 0x41,
+  0xa5, 0x24, 0x46, 0x00, 0xca, 0xa0, 0x08, 0x0a, 0x81, 0x62, 0x0d, 0xd0,
+  0x9d, 0x01, 0x20, 0x3c, 0x03, 0x40, 0x79, 0x2c, 0x87, 0x61, 0x9e, 0xe7,
+  0x01, 0x20, 0x30, 0x00, 0x00, 0x10, 0x01, 0x21, 0x10, 0x0c, 0x40, 0x50,
+  0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x1a,
+  0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0x44, 0x35, 0x18, 0x63, 0x0b, 0x73,
+  0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71,
+  0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a,
+  0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b,
+  0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7,
+  0x06, 0x61, 0x20, 0x36, 0x08, 0x04, 0x41, 0xc1, 0x6e, 0x6e, 0x82, 0x40,
+  0x20, 0x1b, 0x86, 0x03, 0x21, 0x26, 0x08, 0xd8, 0xc6, 0xca, 0xaa, 0x4c,
+  0x8e, 0xae, 0x0c, 0x6f, 0x0a, 0x2d, 0x8c, 0xac, 0x4c, 0x6e, 0xe8, 0xcd,
+  0x6d, 0x8e, 0x2e, 0xcc, 0x8d, 0x6e, 0x6e, 0x82, 0x40, 0x24, 0x1b, 0x10,
+  0x42, 0x59, 0x08, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3, 0x81, 0x00, 0x00,
+  0x07, 0x98, 0x20, 0x5c, 0x1a, 0x8b, 0xb6, 0x37, 0xb2, 0x32, 0xb6, 0x09,
+  0x02, 0xa1, 0x4c, 0x10, 0x88, 0x65, 0xc3, 0x30, 0x4d, 0xc3, 0x04, 0x81,
+  0x60, 0x26, 0x08, 0x44, 0x33, 0x41, 0x20, 0x9c, 0x09, 0x42, 0x94, 0x6d,
+  0x50, 0x90, 0x48, 0xa2, 0x2a, 0xc2, 0xba, 0x2e, 0x8c, 0x11, 0x9c, 0xdc,
+  0x9b, 0x5a, 0xd9, 0x18, 0x5d, 0xda, 0x9b, 0x5b, 0x90, 0x1b, 0x99, 0x55,
+  0x5a, 0xd9, 0xdd, 0x04, 0x81, 0x78, 0x36, 0x28, 0x88, 0x26, 0x51, 0xd5,
+  0x66, 0x5d, 0x17, 0xb6, 0x61, 0x60, 0x32, 0x6e, 0xc3, 0x40, 0x40, 0xdd,
+  0x04, 0x41, 0x00, 0x36, 0x00, 0x1b, 0x06, 0x02, 0x0c, 0xc0, 0x60, 0x43,
+  0x10, 0x06, 0x1b, 0x86, 0xe1, 0x13, 0x83, 0x09, 0x42, 0xc6, 0x6d, 0x08,
+  0xc8, 0x80, 0x49, 0x5b, 0x58, 0x9a, 0xdb, 0xd0, 0x1b, 0xdb, 0x9b, 0x1c,
+  0x11, 0xa8, 0xa7, 0xa9, 0x24, 0xaa, 0xa4, 0x27, 0xa7, 0x09, 0x42, 0x41,
+  0x4d, 0x10, 0x8a, 0x6a, 0x43, 0x40, 0x4c, 0x10, 0x0a, 0x6b, 0x83, 0x50,
+  0x59, 0x1b, 0x16, 0xe2, 0x0c, 0xd0, 0x20, 0x0d, 0xd4, 0x20, 0x0d, 0x86,
+  0x35, 0x20, 0xd2, 0x80, 0x0d, 0x88, 0x50, 0x15, 0x61, 0x0d, 0x3d, 0x3d,
+  0x49, 0x11, 0x4d, 0x10, 0x8a, 0x6b, 0x83, 0x50, 0x55, 0x1b, 0x96, 0xc1,
+  0x0d, 0xd0, 0x20, 0x0d, 0xd4, 0x20, 0x0d, 0x86, 0x37, 0x18, 0xd2, 0x00,
+  0x0e, 0x58, 0x0c, 0x3d, 0x31, 0x3d, 0x49, 0x4d, 0x10, 0x0a, 0x6c, 0x82,
+  0x40, 0x40, 0x1b, 0x84, 0x8a, 0x0e, 0x36, 0x2c, 0x92, 0x1c, 0xa0, 0x41,
+  0x1a, 0xa8, 0x41, 0x1a, 0x0c, 0x73, 0x20, 0xa5, 0x41, 0x1d, 0x6c, 0x18,
+  0xda, 0x20, 0x0e, 0xec, 0x80, 0xcb, 0x94, 0xd5, 0x17, 0xd4, 0xdb, 0x5c,
+  0x1a, 0x5d, 0xda, 0x9b, 0xdb, 0x86, 0x85, 0xc0, 0x03, 0x34, 0x58, 0x03,
+  0x35, 0x98, 0x83, 0x61, 0x0e, 0x88, 0x34, 0xa8, 0x83, 0x0d, 0xcb, 0xe0,
+  0x06, 0x68, 0x90, 0x06, 0x6a, 0xf0, 0x06, 0xc3, 0x1b, 0x0c, 0x69, 0x00,
+  0x07, 0x1b, 0x16, 0x49, 0x0e, 0xd0, 0x20, 0x0d, 0xd4, 0xe0, 0x0d, 0x86,
+  0x39, 0x90, 0xd2, 0xa0, 0x0e, 0x36, 0x0c, 0x79, 0xa0, 0x07, 0x7b, 0xb0,
+  0x61, 0xb8, 0x03, 0x3e, 0x00, 0x36, 0x14, 0x9f, 0x19, 0xf4, 0xc1, 0x03,
+  0xd0, 0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x9b, 0x9b, 0x20, 0x10, 0x11, 0x8b,
+  0x34, 0xb7, 0x39, 0xba, 0xb9, 0x09, 0x02, 0x21, 0xd1, 0x98, 0x4b, 0x3b,
+  0xfb, 0x62, 0x23, 0xa3, 0x31, 0x97, 0x76, 0xf6, 0x35, 0x47, 0x37, 0x41,
+  0x20, 0xa6, 0x0d, 0xc8, 0x1f, 0x80, 0x42, 0x28, 0x88, 0xc2, 0x28, 0x5c,
+  0xa4, 0x50, 0x0a, 0x55, 0xd8, 0xd8, 0xec, 0xda, 0x5c, 0xd2, 0xc8, 0xca,
+  0xdc, 0xe8, 0xa6, 0x04, 0x41, 0x15, 0x32, 0x3c, 0x17, 0xbb, 0x32, 0xb9,
+  0xb9, 0xb4, 0x37, 0xb7, 0x29, 0x01, 0xd1, 0x84, 0x0c, 0xcf, 0xc5, 0x2e,
+  0x8c, 0xcd, 0xae, 0x4c, 0x6e, 0x4a, 0x50, 0xd4, 0x21, 0xc3, 0x73, 0x99,
+  0x43, 0x0b, 0x23, 0x2b, 0x93, 0x6b, 0x7a, 0x23, 0x2b, 0x63, 0x9b, 0x12,
+  0x20, 0x65, 0xc8, 0xf0, 0x5c, 0xe4, 0xca, 0xe6, 0xde, 0xea, 0xe4, 0xc6,
+  0xca, 0xe6, 0xa6, 0x04, 0x4e, 0x25, 0x32, 0x3c, 0x17, 0xba, 0x3c, 0xb8,
+  0xb2, 0x20, 0x37, 0xb7, 0x37, 0xba, 0x30, 0xba, 0xb4, 0x37, 0xb7, 0xb9,
+  0x29, 0x42, 0x27, 0x06, 0x75, 0xc8, 0xf0, 0x5c, 0xec, 0xd2, 0xca, 0xee,
+  0x92, 0xc8, 0xa6, 0xe8, 0xc2, 0xe8, 0xca, 0xa6, 0x04, 0x64, 0x50, 0x87,
+  0x0c, 0xcf, 0xa5, 0xcc, 0x8d, 0x4e, 0x2e, 0x0f, 0xea, 0x2d, 0xcd, 0x8d,
+  0x6e, 0x6e, 0x4a, 0xd0, 0x07, 0x5d, 0xc8, 0xf0, 0x5c, 0xc6, 0xde, 0xea,
+  0xdc, 0xe8, 0xca, 0xe4, 0xe6, 0xa6, 0x04, 0xa5, 0x00, 0x00, 0x00, 0x79,
+  0x18, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4,
+  0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c,
+  0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00,
+  0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2,
+  0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38,
+  0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d,
+  0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87,
+  0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87,
+  0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30,
+  0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde,
+  0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b,
+  0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c,
+  0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07,
+  0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87,
+  0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87,
+  0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87,
+  0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0,
+  0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4,
+  0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38,
+  0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b,
+  0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03,
+  0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87,
+  0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x71,
+  0x20, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97, 0xef,
+  0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61,
+  0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce, 0xe3,
+  0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34,
+  0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f,
+  0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e, 0x44,
+  0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3, 0xe5,
+  0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7, 0x6d,
+  0x00, 0x09, 0x03, 0x20, 0x0d, 0xe7, 0x2c, 0x4e, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x46, 0x69, 0x68, 0xc7, 0x9e, 0x75, 0x89, 0x9f, 0xd3,
+  0xe9, 0x06, 0x53, 0x46, 0xb2, 0xdf, 0x1c, 0x44, 0x58, 0x49, 0x4c, 0xf8,
+  0x08, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0x3e, 0x02, 0x00, 0x00, 0x44,
+  0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xe0,
+  0x08, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x35,
+  0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+  0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06,
+  0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e,
+  0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4,
+  0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48,
+  0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4,
+  0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1,
+  0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40,
+  0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d,
+  0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49,
+  0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20,
+  0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x26,
+  0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93,
+  0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12,
+  0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00, 0x25,
+  0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6,
+  0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3,
+  0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98,
+  0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f,
+  0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10,
+  0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04,
+  0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43,
+  0x12, 0xd4, 0x03, 0x83, 0xc3, 0x91, 0xa6, 0x05, 0xc0, 0x1c, 0x6a, 0xf2,
+  0x5f, 0x22, 0x9a, 0x88, 0x8b, 0x3d, 0x80, 0x81, 0x88, 0x38, 0xa7, 0x91,
+  0x26, 0xa0, 0x99, 0x24, 0x24, 0x58, 0x4b, 0x37, 0x1d, 0x08, 0x00, 0x13,
+  0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68,
+  0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a,
+  0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
+  0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40,
+  0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x79,
+  0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc8,
+  0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+  0x16, 0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19,
+  0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25,
+  0x30, 0x02, 0x50, 0x0c, 0x05, 0x28, 0x50, 0x06, 0xe5, 0x50, 0x04, 0xe5,
+  0x41, 0xa5, 0x24, 0x46, 0x00, 0xca, 0xa0, 0x08, 0x0a, 0x81, 0xf0, 0x0c,
+  0x00, 0xe5, 0xb1, 0x1c, 0x86, 0x79, 0x9e, 0x07, 0x80, 0xc0, 0x00, 0x00,
+  0x40, 0x04, 0x84, 0x40, 0x30, 0x00, 0x41, 0x01, 0x00, 0x00, 0x00, 0x79,
+  0x18, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46,
+  0x02, 0x13, 0x44, 0x35, 0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b,
+  0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1,
+  0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa,
+  0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10,
+  0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x26,
+  0x08, 0x04, 0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x76, 0x73, 0x1b, 0x06, 0xc4,
+  0x20, 0x26, 0x08, 0xd8, 0x44, 0x60, 0x82, 0x40, 0x24, 0x1b, 0x10, 0x42,
+  0x59, 0x08, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3, 0x81, 0x00, 0x00, 0x07,
+  0x98, 0x20, 0x64, 0xd4, 0x86, 0x00, 0x9a, 0x20, 0x08, 0x00, 0x93, 0xb6,
+  0xb0, 0x34, 0xb7, 0xa1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x50, 0x4f, 0x53,
+  0x49, 0x54, 0x49, 0x4f, 0x4e, 0x13, 0x84, 0xc2, 0x99, 0x20, 0x14, 0xcf,
+  0x86, 0x80, 0x98, 0x20, 0x14, 0xd0, 0x04, 0x81, 0x50, 0x26, 0x08, 0xc4,
+  0xb2, 0x41, 0xc8, 0xb4, 0x0d, 0x0b, 0x41, 0x55, 0xd6, 0x65, 0x0d, 0x18,
+  0x61, 0x6d, 0x44, 0xa8, 0x8a, 0xb0, 0x86, 0x9e, 0x9e, 0xa4, 0x88, 0x26,
+  0x08, 0x45, 0xb4, 0x41, 0xc8, 0xb2, 0x0d, 0xcb, 0xd0, 0x55, 0xd6, 0x65,
+  0x0d, 0xde, 0x60, 0x7d, 0x13, 0x04, 0x82, 0x61, 0x31, 0xf4, 0xc4, 0xf4,
+  0x24, 0x35, 0x41, 0x28, 0xa4, 0x09, 0x02, 0xd1, 0x6c, 0x10, 0x32, 0x32,
+  0xd8, 0xb0, 0x84, 0x81, 0x18, 0x54, 0xd6, 0x65, 0x0d, 0x63, 0x10, 0x06,
+  0x56, 0x19, 0x6c, 0x18, 0x38, 0x30, 0x30, 0x03, 0x2e, 0x53, 0x56, 0x5f,
+  0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x1b, 0x16, 0x02, 0x0d,
+  0x2a, 0xec, 0x1a, 0x83, 0x61, 0x0c, 0x08, 0xab, 0x0c, 0x36, 0x2c, 0x43,
+  0x57, 0x59, 0x97, 0x37, 0x78, 0x83, 0xf5, 0x6d, 0x58, 0xc2, 0x40, 0x0c,
+  0x2a, 0xeb, 0xf2, 0x86, 0x31, 0x08, 0x03, 0xab, 0x0c, 0x36, 0x0c, 0x69,
+  0xa0, 0x06, 0x6b, 0xb0, 0x61, 0x38, 0x03, 0x36, 0x00, 0x36, 0x14, 0xd2,
+  0xd4, 0x06, 0x0f, 0x50, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac,
+  0xcc, 0x8d, 0x6e, 0x4a, 0x10, 0x54, 0x21, 0xc3, 0x73, 0xb1, 0x2b, 0x93,
+  0x9b, 0x4b, 0x7b, 0x73, 0x9b, 0x12, 0x10, 0x4d, 0xc8, 0xf0, 0x5c, 0xec,
+  0xc2, 0xd8, 0xec, 0xca, 0xe4, 0xa6, 0x04, 0x46, 0x1d, 0x32, 0x3c, 0x97,
+  0x39, 0xb4, 0x30, 0xb2, 0x32, 0xb9, 0xa6, 0x37, 0xb2, 0x32, 0xb6, 0x29,
+  0x01, 0x52, 0x86, 0x0c, 0xcf, 0x45, 0xae, 0x6c, 0xee, 0xad, 0x4e, 0x6e,
+  0xac, 0x6c, 0x6e, 0x4a, 0xe0, 0xd4, 0x21, 0xc3, 0x73, 0xb1, 0x4b, 0x2b,
+  0xbb, 0x4b, 0x22, 0x9b, 0xa2, 0x0b, 0xa3, 0x2b, 0x9b, 0x12, 0x40, 0x75,
+  0xc8, 0xf0, 0x5c, 0xca, 0xdc, 0xe8, 0xe4, 0xf2, 0xa0, 0xde, 0xd2, 0xdc,
+  0xe8, 0xe6, 0xa6, 0x04, 0x6d, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x49,
+  0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14,
+  0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79,
+  0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e,
+  0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1,
+  0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc,
+  0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74,
+  0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a,
+  0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e,
+  0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e,
+  0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21,
+  0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0,
+  0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc,
+  0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72,
+  0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76,
+  0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f,
+  0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c,
+  0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03,
+  0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61,
+  0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94,
+  0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0,
+  0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73,
+  0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77,
+  0xa8, 0x07, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x19,
+  0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x50,
+  0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61, 0x00, 0x02, 0xe6, 0x17,
+  0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11, 0x01, 0x4c,
+  0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe, 0xf3, 0xf8,
+  0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x09, 0x54,
+  0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4, 0xf4, 0x50,
+  0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3, 0xe5, 0x3b, 0x8f, 0x3f, 0x11,
+  0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7, 0x6d, 0x00, 0x09, 0x03, 0x20,
+  0x0d, 0xe7, 0x2c, 0x4e, 0x04, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0xcf,
+  0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x44, 0x8a, 0xab, 0x14, 0x0a, 0x61, 0x06, 0xa0, 0xec,
+  0x4a, 0x8e, 0x4a, 0x09, 0x50, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x20, 0x61, 0x03, 0x63, 0x59, 0xc1, 0x88,
+  0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0xdd, 0x21, 0x5d, 0x8f, 0x31, 0x62,
+  0x90, 0x00, 0x20, 0x08, 0x06, 0x86, 0x87, 0x4c, 0x18, 0x71, 0x8c, 0x18,
+  0x24, 0x00, 0x08, 0x82, 0x81, 0xf1, 0x25, 0x54, 0xf6, 0x20, 0x23, 0x06,
+  0x09, 0x00, 0x82, 0x60, 0x60, 0x80, 0x81, 0x52, 0x69, 0x51, 0x32, 0x62,
+  0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x18, 0x2c, 0xdc, 0x36, 0x29, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x88, 0x01, 0xd3, 0x71, 0xc8, 0x32,
+  0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0xc6, 0x18, 0x34, 0x5d, 0x57, 0x31,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x90, 0x81, 0xe3, 0x79, 0x4a,
+  0x33, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x19, 0x3c, 0xdf, 0x57,
+  0x39, 0x23, 0x06, 0x07, 0x00, 0x82, 0x60, 0xd0, 0x90, 0x81, 0xa3, 0x80,
+  0xc1, 0x68, 0x42, 0x00, 0x8c, 0x26, 0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c,
+  0x26, 0x10, 0xc3, 0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0x69, 0x30,
+  0x3d, 0x66, 0x30, 0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30,
+  0x08, 0xa3, 0x09, 0xc4, 0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x8d,
+  0x1b, 0x60, 0x54, 0x19, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0xc2, 0x68, 0x02, 0x31, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82,
+  0x41, 0x33, 0x07, 0x5d, 0xc6, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x9a, 0x20,
+  0x04, 0xa3, 0x09, 0x83, 0x30, 0x9a, 0x40, 0x0c, 0x36, 0x5d, 0xf2, 0x19,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x07, 0x0f, 0xce, 0xe0, 0x7a, 0x82,
+  0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0xf2, 0x00, 0x0d, 0xae, 0x25,
+  0xb0, 0xe0, 0x80, 0x8e, 0x59, 0x9b, 0x7c, 0x46, 0x0c, 0x10, 0x00, 0x04,
+  0xc1, 0xe0, 0xe1, 0x83, 0x35, 0xd8, 0xa4, 0x60, 0xc4, 0x00, 0x01, 0x40,
+  0x10, 0x0c, 0x9e, 0x3e, 0x60, 0x83, 0xcd, 0x09, 0x2c, 0x50, 0xa0, 0x63,
+  0xd9, 0x27, 0x9f, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0x40, 0xe1,
+  0x0d, 0xbe, 0x2a, 0x18, 0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x27, 0x14,
+  0xe0, 0xe0, 0x8b, 0x02, 0x0b, 0x1a, 0xe8, 0x18, 0x37, 0x06, 0xf2, 0x19,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x14, 0xe6, 0x60, 0x0c, 0xb0,
+  0x60, 0xc4, 0x00, 0x01, 0x40, 0x10, 0x0c, 0x9e, 0x52, 0xa0, 0x83, 0x31,
+  0xa0, 0x02, 0x0b, 0x20, 0xe8, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x41,
+  0x83, 0x0a, 0x72, 0xe0, 0x06, 0x74, 0x30, 0x9a, 0x10, 0x00, 0xa3, 0x09,
+  0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09, 0xc4, 0x30, 0x62, 0x70, 0x00,
+  0x20, 0x08, 0x06, 0x4d, 0x2b, 0xdc, 0xc1, 0x1c, 0xe8, 0xc1, 0x68, 0x42,
+  0x00, 0x8c, 0x26, 0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c, 0x26, 0x10, 0xc3,
+  0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0xb2, 0xc0, 0x07, 0x78, 0xd0,
+  0x0a, 0xa3, 0x09, 0x01, 0x30, 0x9a, 0x20, 0x04, 0xa3, 0x09, 0x83, 0x30,
+  0x9a, 0x40, 0x0c, 0x23, 0x06, 0x07, 0x00, 0x82, 0x60, 0xd0, 0xdc, 0x42,
+  0x28, 0xf4, 0xc1, 0x2b, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0xc2, 0x68, 0x02, 0x31, 0xd8, 0x14, 0x06, 0xf2, 0x19, 0x31,
+  0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x17, 0x56, 0xc1, 0x7b, 0x82, 0x11,
+  0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0x7a, 0x81, 0x15, 0xb6, 0x25, 0x18,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0xc7, 0x17, 0x5a, 0x01, 0x3b, 0x02,
+  0xb3, 0xca, 0x40, 0x3e, 0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0xf0, 0x80,
+  0xc3, 0x2b, 0x88, 0x81, 0x14, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0xc1,
+  0x13, 0x0e, 0xb0, 0xf0, 0x39, 0xc1, 0x88, 0x01, 0x02, 0x80, 0x20, 0x18,
+  0x3c, 0xe2, 0x10, 0x0b, 0x9c, 0x12, 0x58, 0x96, 0x06, 0xf2, 0x19, 0x31,
+  0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x1c, 0x66, 0xc1, 0x0c, 0xaa, 0x60,
+  0xc4, 0x00, 0x01, 0x40, 0x10, 0x0c, 0x9e, 0x72, 0xa0, 0x85, 0x31, 0x88,
+  0x82, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0xcc, 0xa1, 0x16, 0xc0,
+  0xa0, 0x09, 0x8c, 0x6b, 0x03, 0xf9, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82,
+  0xc1, 0x83, 0x0e, 0xb7, 0xa0, 0x06, 0x58, 0x30, 0x62, 0x80, 0x00, 0x20,
+  0x08, 0x06, 0x4f, 0x3a, 0xe0, 0xc2, 0x19, 0x50, 0xc1, 0x88, 0x01, 0x02,
+  0x80, 0x20, 0x18, 0x3c, 0xea, 0x90, 0x0b, 0x64, 0x00, 0x05, 0x23, 0x06,
+  0x09, 0x00, 0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0xa0, 0x03, 0x3a, 0x80,
+  0x43, 0x33, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0x02,
+  0x3a, 0xa0, 0x03, 0x2d, 0x24, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80,
+  0xb4, 0x43, 0x2e, 0xa0, 0x03, 0x3a, 0xf8, 0x42, 0x31, 0x62, 0x90, 0x00,
+  0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0x02, 0x3a, 0xa0, 0xc3, 0x2f, 0x04,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0xa4, 0x03,
+  0x3a, 0x80, 0x43, 0x2b, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xd2,
+  0x0e, 0xb9, 0x90, 0x0e, 0xe8, 0x40, 0x0b, 0xac, 0x30, 0x62, 0x90, 0x00,
+  0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0xc2, 0x38, 0xa0, 0x03, 0x38, 0xc4,
+  0xc2, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0xed, 0x90, 0x0b, 0xe3,
+  0x80, 0x0e, 0xb4, 0x00, 0x0b, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80,
+  0xb4, 0x43, 0x2e, 0x8c, 0x03, 0x3a, 0xf8, 0xc2, 0x2b, 0x8c, 0x18, 0x24,
+  0x00, 0x08, 0x82, 0x01, 0xd2, 0x0e, 0xb9, 0x30, 0x0e, 0xe8, 0xf0, 0x0b,
+  0xae, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Texture.h b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Texture.h
new file mode 100644
index 0000000..ac68e32
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/D3D12_VertexShader_Texture.h
@@ -0,0 +1,645 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; POSITION                 0   xyz         0     NONE   float   xyz 
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Position              0   xyzw        0      POS   float   xyzw
+; TEXCOORD                 0   xy          1     NONE   float   xy  
+; COLOR                    0   xyzw        2     NONE   float   xyzw
+;
+; shader hash: 6b5daf1892267550d482ef06f687d614
+;
+; Pipeline Runtime Information: 
+;
+; Vertex Shader
+; OutputPositionPresent=1
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; POSITION                 0                              
+; TEXCOORD                 0                              
+; COLOR                    0                              
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Position              0          noperspective       
+; TEXCOORD                 0                 linear       
+; COLOR                    0                 linear       
+;
+; Buffer Definitions:
+;
+; cbuffer VertexShaderConstants
+; {
+;
+;   struct hostlayout.VertexShaderConstants
+;   {
+;
+;       row_major float4x4 model;                     ; Offset:    0
+;       row_major float4x4 projectionAndView;         ; Offset:   64
+;   
+;   } VertexShaderConstants;                          ; Offset:    0 Size:   128
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; VertexShaderConstants             cbuffer      NA          NA     CB0            cb0     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 12, outputs: 12
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 0, 1, 2 }
+;   output 1 depends on inputs: { 0, 1, 2 }
+;   output 2 depends on inputs: { 0, 1, 2 }
+;   output 3 depends on inputs: { 0, 1, 2 }
+;   output 4 depends on inputs: { 4 }
+;   output 5 depends on inputs: { 5 }
+;   output 8 depends on inputs: { 8 }
+;   output 9 depends on inputs: { 9 }
+;   output 10 depends on inputs: { 10 }
+;   output 11 depends on inputs: { 11 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%hostlayout.VertexShaderConstants = type { [4 x <4 x float>], [4 x <4 x float>] }
+
+define void @mainTexture() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %10 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %11 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %12 = extractvalue %dx.types.CBufRet.f32 %11, 0
+  %13 = extractvalue %dx.types.CBufRet.f32 %11, 1
+  %14 = extractvalue %dx.types.CBufRet.f32 %11, 2
+  %15 = extractvalue %dx.types.CBufRet.f32 %11, 3
+  %16 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %17 = extractvalue %dx.types.CBufRet.f32 %16, 0
+  %18 = extractvalue %dx.types.CBufRet.f32 %16, 1
+  %19 = extractvalue %dx.types.CBufRet.f32 %16, 2
+  %20 = extractvalue %dx.types.CBufRet.f32 %16, 3
+  %21 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 2)  ; CBufferLoadLegacy(handle,regIndex)
+  %22 = extractvalue %dx.types.CBufRet.f32 %21, 0
+  %23 = extractvalue %dx.types.CBufRet.f32 %21, 1
+  %24 = extractvalue %dx.types.CBufRet.f32 %21, 2
+  %25 = extractvalue %dx.types.CBufRet.f32 %21, 3
+  %26 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %27 = extractvalue %dx.types.CBufRet.f32 %26, 0
+  %28 = extractvalue %dx.types.CBufRet.f32 %26, 1
+  %29 = extractvalue %dx.types.CBufRet.f32 %26, 2
+  %30 = extractvalue %dx.types.CBufRet.f32 %26, 3
+  %31 = fmul fast float %12, %8
+  %32 = call float @dx.op.tertiary.f32(i32 46, float %9, float %17, float %31)  ; FMad(a,b,c)
+  %33 = call float @dx.op.tertiary.f32(i32 46, float %10, float %22, float %32)  ; FMad(a,b,c)
+  %34 = fadd fast float %33, %27
+  %35 = fmul fast float %13, %8
+  %36 = call float @dx.op.tertiary.f32(i32 46, float %9, float %18, float %35)  ; FMad(a,b,c)
+  %37 = call float @dx.op.tertiary.f32(i32 46, float %10, float %23, float %36)  ; FMad(a,b,c)
+  %38 = fadd fast float %37, %28
+  %39 = fmul fast float %14, %8
+  %40 = call float @dx.op.tertiary.f32(i32 46, float %9, float %19, float %39)  ; FMad(a,b,c)
+  %41 = call float @dx.op.tertiary.f32(i32 46, float %10, float %24, float %40)  ; FMad(a,b,c)
+  %42 = fadd fast float %41, %29
+  %43 = fmul fast float %15, %8
+  %44 = call float @dx.op.tertiary.f32(i32 46, float %9, float %20, float %43)  ; FMad(a,b,c)
+  %45 = call float @dx.op.tertiary.f32(i32 46, float %10, float %25, float %44)  ; FMad(a,b,c)
+  %46 = fadd fast float %45, %30
+  %47 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %48 = extractvalue %dx.types.CBufRet.f32 %47, 0
+  %49 = extractvalue %dx.types.CBufRet.f32 %47, 1
+  %50 = extractvalue %dx.types.CBufRet.f32 %47, 2
+  %51 = extractvalue %dx.types.CBufRet.f32 %47, 3
+  %52 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %53 = extractvalue %dx.types.CBufRet.f32 %52, 0
+  %54 = extractvalue %dx.types.CBufRet.f32 %52, 1
+  %55 = extractvalue %dx.types.CBufRet.f32 %52, 2
+  %56 = extractvalue %dx.types.CBufRet.f32 %52, 3
+  %57 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 6)  ; CBufferLoadLegacy(handle,regIndex)
+  %58 = extractvalue %dx.types.CBufRet.f32 %57, 0
+  %59 = extractvalue %dx.types.CBufRet.f32 %57, 1
+  %60 = extractvalue %dx.types.CBufRet.f32 %57, 2
+  %61 = extractvalue %dx.types.CBufRet.f32 %57, 3
+  %62 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 7)  ; CBufferLoadLegacy(handle,regIndex)
+  %63 = extractvalue %dx.types.CBufRet.f32 %62, 0
+  %64 = extractvalue %dx.types.CBufRet.f32 %62, 1
+  %65 = extractvalue %dx.types.CBufRet.f32 %62, 2
+  %66 = extractvalue %dx.types.CBufRet.f32 %62, 3
+  %67 = fmul fast float %48, %34
+  %68 = call float @dx.op.tertiary.f32(i32 46, float %38, float %53, float %67)  ; FMad(a,b,c)
+  %69 = call float @dx.op.tertiary.f32(i32 46, float %42, float %58, float %68)  ; FMad(a,b,c)
+  %70 = call float @dx.op.tertiary.f32(i32 46, float %46, float %63, float %69)  ; FMad(a,b,c)
+  %71 = fmul fast float %49, %34
+  %72 = call float @dx.op.tertiary.f32(i32 46, float %38, float %54, float %71)  ; FMad(a,b,c)
+  %73 = call float @dx.op.tertiary.f32(i32 46, float %42, float %59, float %72)  ; FMad(a,b,c)
+  %74 = call float @dx.op.tertiary.f32(i32 46, float %46, float %64, float %73)  ; FMad(a,b,c)
+  %75 = fmul fast float %50, %34
+  %76 = call float @dx.op.tertiary.f32(i32 46, float %38, float %55, float %75)  ; FMad(a,b,c)
+  %77 = call float @dx.op.tertiary.f32(i32 46, float %42, float %60, float %76)  ; FMad(a,b,c)
+  %78 = call float @dx.op.tertiary.f32(i32 46, float %46, float %65, float %77)  ; FMad(a,b,c)
+  %79 = fmul fast float %51, %34
+  %80 = call float @dx.op.tertiary.f32(i32 46, float %38, float %56, float %79)  ; FMad(a,b,c)
+  %81 = call float @dx.op.tertiary.f32(i32 46, float %42, float %61, float %80)  ; FMad(a,b,c)
+  %82 = call float @dx.op.tertiary.f32(i32 46, float %46, float %66, float %81)  ; FMad(a,b,c)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %70)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %74)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %78)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %82)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 0, float %6)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 1, float %7)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 0, float %2)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 1, float %3)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 2, float %4)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 3, float %5)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"clang version 3.7 (tags/RELEASE_370/final)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 6}
+!3 = !{!"vs", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %hostlayout.VertexShaderConstants* undef, !"", i32 0, i32 0, i32 1, i32 128, null}
+!7 = !{[14 x i32] [i32 12, i32 12, i32 15, i32 15, i32 15, i32 0, i32 16, i32 32, i32 0, i32 0, i32 256, i32 512, i32 1024, i32 2048]}
+!8 = !{void ()* @mainTexture, !"mainTexture", !9, !4, null}
+!9 = !{!10, !18, null}
+!10 = !{!11, !14, !16}
+!11 = !{i32 0, !"POSITION", i8 9, i8 0, !12, i8 0, i32 1, i8 3, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 7}
+!14 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 0, i32 1, i8 2, i32 1, i8 0, !15}
+!15 = !{i32 3, i32 3}
+!16 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 0, i32 1, i8 4, i32 2, i8 0, !17}
+!17 = !{i32 3, i32 15}
+!18 = !{!19, !20, !21}
+!19 = !{i32 0, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 0, i8 0, !17}
+!20 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 2, i32 1, i8 0, !15}
+!21 = !{i32 2, !"COLOR", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 2, i8 0, !17}
+
+#endif
+
+const unsigned char g_mainTexture[] = {
+  0x44, 0x58, 0x42, 0x43, 0xda, 0xc9, 0x75, 0xea, 0x0d, 0x18, 0xc7, 0xf5,
+  0xb4, 0x80, 0x10, 0xd9, 0xd7, 0x88, 0x5a, 0x23, 0x01, 0x00, 0x00, 0x00,
+  0xff, 0x12, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00,
+  0x87, 0x02, 0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0xdf, 0x09, 0x00, 0x00,
+  0xfb, 0x09, 0x00, 0x00, 0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31,
+  0x80, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x4f, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x54, 0x45, 0x58,
+  0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00,
+  0x4f, 0x53, 0x47, 0x31, 0x83, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x03, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x7d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44,
+  0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x50, 0x53, 0x56, 0x30, 0x1c,
+  0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x03,
+  0x03, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x50, 0x4f, 0x53, 0x49,
+  0x54, 0x49, 0x4f, 0x4e, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x54, 0x45, 0x58, 0x43,
+  0x4f, 0x4f, 0x52, 0x44, 0x00, 0x43, 0x4f, 0x4c, 0x4f, 0x52, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x43, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x01, 0x42, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x03, 0x03,
+  0x04, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x01, 0x42, 0x00, 0x03, 0x02, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00, 0x0f,
+  0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x52,
+  0x54, 0x53, 0x30, 0xa0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0,
+  0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+  0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x03,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x53,
+  0x54, 0x41, 0x54, 0xa8, 0x06, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0xaa,
+  0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x90, 0x06, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21,
+  0x0c, 0x00, 0x00, 0xa1, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41,
+  0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25,
+  0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42,
+  0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a,
+  0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00,
+  0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41,
+  0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51,
+  0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff,
+  0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff,
+  0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00,
+  0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13,
+  0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89,
+  0x20, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20,
+  0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84,
+  0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10,
+  0x68, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60,
+  0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10,
+  0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e,
+  0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54,
+  0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16,
+  0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c, 0x31,
+  0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e, 0x04,
+  0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x03, 0x83, 0xc3, 0x91, 0xa6, 0x05,
+  0xc0, 0x1c, 0x6a, 0xf2, 0x5f, 0x22, 0x9a, 0x88, 0x8b, 0x3d, 0x80, 0x81,
+  0x88, 0x38, 0xa7, 0x91, 0x26, 0xa0, 0x99, 0x24, 0x24, 0x58, 0x4b, 0x37,
+  0x1d, 0x08, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36,
+  0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e,
+  0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c,
+  0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+  0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0xe4, 0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x60, 0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x14, 0x00, 0x00, 0x00, 0x32,
+  0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6,
+  0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x28, 0x50, 0x04,
+  0x85, 0x50, 0x06, 0xe5, 0x50, 0x12, 0x05, 0x18, 0x50, 0x1e, 0x85, 0x51,
+  0xba, 0x01, 0x45, 0x41, 0xa5, 0x24, 0x46, 0x00, 0xca, 0xa0, 0x08, 0x0a,
+  0x81, 0x62, 0x0d, 0xd0, 0x9d, 0x01, 0x20, 0x3c, 0x03, 0x40, 0x79, 0x2c,
+  0x87, 0x61, 0x9e, 0xe7, 0x01, 0x20, 0x30, 0x00, 0x00, 0x10, 0x01, 0x21,
+  0x10, 0x0c, 0x40, 0x50, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x9f,
+  0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0x44, 0x35,
+  0x18, 0x63, 0x0b, 0x73, 0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b,
+  0x73, 0x03, 0x99, 0x71, 0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b, 0x9b, 0x7b,
+  0x91, 0x2a, 0x62, 0x2a, 0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9, 0x81, 0x79,
+  0x31, 0x4b, 0x73, 0x0b, 0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2,
+  0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04, 0x41, 0xc1,
+  0x6e, 0x6e, 0x82, 0x40, 0x20, 0x1b, 0x86, 0x03, 0x21, 0x26, 0x08, 0xd8,
+  0xc6, 0xca, 0xaa, 0x4c, 0x8e, 0xae, 0x0c, 0x6f, 0x0a, 0x2d, 0x8c, 0xac,
+  0x4c, 0x6e, 0xe8, 0xcd, 0x6d, 0x8e, 0x2e, 0xcc, 0x8d, 0x6e, 0x6e, 0x82,
+  0x40, 0x24, 0x1b, 0x10, 0x42, 0x59, 0x08, 0x62, 0x60, 0x80, 0x0d, 0x41,
+  0xb3, 0x81, 0x00, 0x00, 0x07, 0x98, 0x20, 0x5c, 0x1a, 0x8b, 0xb6, 0x37,
+  0xb2, 0x32, 0xb6, 0x09, 0x02, 0xa1, 0x4c, 0x10, 0x88, 0x65, 0xc3, 0x30,
+  0x4d, 0xc3, 0x04, 0x81, 0x60, 0x26, 0x08, 0x44, 0x33, 0x41, 0x20, 0x9c,
+  0x09, 0x42, 0x94, 0x6d, 0x50, 0x90, 0x48, 0xa2, 0x2a, 0xc2, 0xba, 0x2e,
+  0x8c, 0x11, 0x9c, 0xdc, 0x9b, 0x5a, 0xd9, 0x18, 0x5d, 0xda, 0x9b, 0x5b,
+  0x90, 0x1b, 0x99, 0x55, 0x5a, 0xd9, 0xdd, 0x04, 0x81, 0x78, 0x36, 0x28,
+  0x88, 0x26, 0x51, 0xd5, 0x66, 0x5d, 0x17, 0xb6, 0x61, 0x60, 0x32, 0x6e,
+  0xc3, 0x40, 0x40, 0xdd, 0x04, 0x41, 0x00, 0x36, 0x00, 0x1b, 0x06, 0x02,
+  0x0c, 0xc0, 0x60, 0x43, 0x10, 0x06, 0x1b, 0x86, 0xe1, 0x13, 0x83, 0x09,
+  0x42, 0xc6, 0x6d, 0x08, 0xc8, 0x80, 0x4b, 0x5b, 0x58, 0x9a, 0x1b, 0x55,
+  0x19, 0x1e, 0x5d, 0x9d, 0x5c, 0x19, 0x11, 0xa8, 0xa7, 0xa9, 0x24, 0xaa,
+  0xa4, 0x27, 0xa7, 0x09, 0x42, 0x41, 0x4d, 0x10, 0x8a, 0x6a, 0x43, 0x40,
+  0x4c, 0x10, 0x0a, 0x6b, 0x83, 0x50, 0x59, 0x1b, 0x16, 0xe2, 0x0c, 0xd0,
+  0x20, 0x0d, 0xd4, 0x20, 0x0d, 0x86, 0x35, 0x20, 0xd2, 0x80, 0x0d, 0x88,
+  0x50, 0x15, 0x61, 0x0d, 0x3d, 0x3d, 0x49, 0x11, 0x4d, 0x10, 0x8a, 0x6b,
+  0x83, 0x50, 0x55, 0x1b, 0x96, 0xc1, 0x0d, 0xd0, 0x20, 0x0d, 0xd4, 0x20,
+  0x0d, 0x86, 0x37, 0x18, 0xd2, 0x00, 0x0e, 0x58, 0x0c, 0x3d, 0x31, 0x3d,
+  0x49, 0x4d, 0x10, 0x0a, 0x6c, 0x82, 0x40, 0x40, 0x1b, 0x84, 0x8a, 0x0e,
+  0x36, 0x2c, 0x92, 0x1c, 0xa0, 0x41, 0x1a, 0xa8, 0x41, 0x1a, 0x0c, 0x73,
+  0x20, 0xa5, 0x41, 0x1d, 0x6c, 0x18, 0xda, 0x20, 0x0e, 0xec, 0x80, 0xcb,
+  0x94, 0xd5, 0x17, 0xd4, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0xdb, 0x86,
+  0x85, 0xc0, 0x03, 0x34, 0x58, 0x03, 0x35, 0x98, 0x83, 0x61, 0x0e, 0x88,
+  0x34, 0xa8, 0x83, 0x0d, 0xcb, 0xe0, 0x06, 0x68, 0x90, 0x06, 0x6a, 0xf0,
+  0x06, 0xc3, 0x1b, 0x0c, 0x69, 0x00, 0x07, 0x1b, 0x16, 0x49, 0x0e, 0xd0,
+  0x20, 0x0d, 0xd4, 0xe0, 0x0d, 0x86, 0x39, 0x90, 0xd2, 0xa0, 0x0e, 0x36,
+  0x0c, 0x79, 0xa0, 0x07, 0x7b, 0xb0, 0x61, 0xb8, 0x03, 0x3e, 0x00, 0x36,
+  0x14, 0x9f, 0x19, 0xf4, 0xc1, 0x03, 0xd0, 0x30, 0x63, 0x7b, 0x0b, 0xa3,
+  0x9b, 0x9b, 0x20, 0x10, 0x11, 0x8b, 0x34, 0xb7, 0x39, 0xba, 0xb9, 0x09,
+  0x02, 0x21, 0xd1, 0x98, 0x4b, 0x3b, 0xfb, 0x62, 0x23, 0xa3, 0x31, 0x97,
+  0x76, 0xf6, 0x35, 0x47, 0x37, 0x41, 0x20, 0xa6, 0x0d, 0xc8, 0x1f, 0x80,
+  0x42, 0x28, 0x88, 0xc2, 0x28, 0x5c, 0xa4, 0x50, 0x0a, 0x55, 0xd8, 0xd8,
+  0xec, 0xda, 0x5c, 0xd2, 0xc8, 0xca, 0xdc, 0xe8, 0xa6, 0x04, 0x41, 0x15,
+  0x32, 0x3c, 0x17, 0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x29, 0x01,
+  0xd1, 0x84, 0x0c, 0xcf, 0xc5, 0x2e, 0x8c, 0xcd, 0xae, 0x4c, 0x6e, 0x4a,
+  0x50, 0xd4, 0x21, 0xc3, 0x73, 0x99, 0x43, 0x0b, 0x23, 0x2b, 0x93, 0x6b,
+  0x7a, 0x23, 0x2b, 0x63, 0x9b, 0x12, 0x20, 0x65, 0xc8, 0xf0, 0x5c, 0xe4,
+  0xca, 0xe6, 0xde, 0xea, 0xe4, 0xc6, 0xca, 0xe6, 0xa6, 0x04, 0x4e, 0x25,
+  0x32, 0x3c, 0x17, 0xba, 0x3c, 0xb8, 0xb2, 0x20, 0x37, 0xb7, 0x37, 0xba,
+  0x30, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x29, 0x42, 0x27, 0x06, 0x75, 0xc8,
+  0xf0, 0x5c, 0xec, 0xd2, 0xca, 0xee, 0x92, 0xc8, 0xa6, 0xe8, 0xc2, 0xe8,
+  0xca, 0xa6, 0x04, 0x64, 0x50, 0x87, 0x0c, 0xcf, 0xa5, 0xcc, 0x8d, 0x4e,
+  0x2e, 0x0f, 0xea, 0x2d, 0xcd, 0x8d, 0x6e, 0x6e, 0x4a, 0xd0, 0x07, 0x5d,
+  0xc8, 0xf0, 0x5c, 0xc6, 0xde, 0xea, 0xdc, 0xe8, 0xca, 0xe4, 0xe6, 0xa6,
+  0x04, 0xa5, 0x00, 0x79, 0x18, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x33,
+  0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98,
+  0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33,
+  0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43,
+  0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08,
+  0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78,
+  0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1,
+  0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33,
+  0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e,
+  0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03,
+  0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80,
+  0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8,
+  0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18,
+  0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee,
+  0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c,
+  0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3,
+  0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83,
+  0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21,
+  0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08,
+  0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x00,
+  0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x36,
+  0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5,
+  0x03, 0x0c, 0x25, 0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2,
+  0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3,
+  0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62,
+  0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f,
+  0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6,
+  0x11, 0x48, 0xc3, 0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11,
+  0xe6, 0x17, 0xb7, 0x6d, 0x00, 0x0b, 0x03, 0x20, 0x4d, 0x4b, 0x5c, 0x13,
+  0x15, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x14,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x5d, 0xaf, 0x18, 0x92,
+  0x26, 0x75, 0x50, 0xd4, 0x82, 0xef, 0x06, 0xf6, 0x87, 0xd6, 0x14, 0x44,
+  0x58, 0x49, 0x4c, 0xfc, 0x08, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0x3f,
+  0x02, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0xe4, 0x08, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21,
+  0x0c, 0x00, 0x00, 0x36, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41,
+  0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25,
+  0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42,
+  0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a,
+  0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00,
+  0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41,
+  0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51,
+  0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff,
+  0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff,
+  0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00,
+  0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13,
+  0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89,
+  0x20, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20,
+  0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84,
+  0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10,
+  0x68, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60,
+  0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10,
+  0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e,
+  0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54,
+  0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16,
+  0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c, 0x31,
+  0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e, 0x04,
+  0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x03, 0x83, 0xc3, 0x91, 0xa6, 0x05,
+  0xc0, 0x1c, 0x6a, 0xf2, 0x5f, 0x22, 0x9a, 0x88, 0x8b, 0x3d, 0x80, 0x81,
+  0x88, 0x38, 0xa7, 0x91, 0x26, 0xa0, 0x99, 0x24, 0x24, 0x58, 0x4b, 0x37,
+  0x1d, 0x08, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36,
+  0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e,
+  0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c,
+  0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+  0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0xe4, 0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x60, 0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x32,
+  0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6,
+  0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x28, 0x50, 0x06,
+  0xe5, 0x50, 0x04, 0xe5, 0x41, 0xa5, 0x24, 0x46, 0x00, 0xca, 0xa0, 0x08,
+  0x0a, 0x81, 0xf0, 0x0c, 0x00, 0xe5, 0xb1, 0x1c, 0x86, 0x79, 0x9e, 0x07,
+  0x80, 0xc0, 0x00, 0x00, 0x40, 0x04, 0x84, 0x40, 0x30, 0x00, 0x41, 0x01,
+  0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x1a,
+  0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0x44, 0x35, 0x18, 0x63, 0x0b, 0x73,
+  0x3b, 0x03, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x03, 0x99, 0x71,
+  0xb9, 0x01, 0x41, 0xa1, 0x0b, 0x3b, 0x9b, 0x7b, 0x91, 0x2a, 0x62, 0x2a,
+  0x0a, 0x9a, 0x2a, 0xfa, 0x9a, 0xb9, 0x81, 0x79, 0x31, 0x4b, 0x73, 0x0b,
+  0x63, 0x4b, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7,
+  0x06, 0x61, 0x20, 0x26, 0x08, 0x04, 0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x76,
+  0x73, 0x1b, 0x06, 0xc4, 0x20, 0x26, 0x08, 0xd8, 0x44, 0x60, 0x82, 0x40,
+  0x24, 0x1b, 0x10, 0x42, 0x59, 0x08, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3,
+  0x81, 0x00, 0x00, 0x07, 0x98, 0x20, 0x64, 0xd4, 0x86, 0x00, 0x9a, 0x20,
+  0x08, 0x00, 0x97, 0xb6, 0xb0, 0x34, 0x37, 0xaa, 0x32, 0x3c, 0xba, 0x3a,
+  0xb9, 0x32, 0x22, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x13,
+  0x84, 0xc2, 0x99, 0x20, 0x14, 0xcf, 0x86, 0x80, 0x98, 0x20, 0x14, 0xd0,
+  0x04, 0x81, 0x50, 0x26, 0x08, 0xc4, 0xb2, 0x41, 0xc8, 0xb4, 0x0d, 0x0b,
+  0x41, 0x55, 0xd6, 0x65, 0x0d, 0x18, 0x61, 0x6d, 0x44, 0xa8, 0x8a, 0xb0,
+  0x86, 0x9e, 0x9e, 0xa4, 0x88, 0x26, 0x08, 0x45, 0xb4, 0x41, 0xc8, 0xb2,
+  0x0d, 0xcb, 0xd0, 0x55, 0xd6, 0x65, 0x0d, 0xde, 0x60, 0x7d, 0x13, 0x04,
+  0x82, 0x61, 0x31, 0xf4, 0xc4, 0xf4, 0x24, 0x35, 0x41, 0x28, 0xa4, 0x09,
+  0x02, 0xd1, 0x6c, 0x10, 0x32, 0x32, 0xd8, 0xb0, 0x84, 0x81, 0x18, 0x54,
+  0xd6, 0x65, 0x0d, 0x63, 0x10, 0x06, 0x56, 0x19, 0x6c, 0x18, 0x38, 0x30,
+  0x30, 0x03, 0x2e, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69,
+  0x6f, 0x6e, 0x1b, 0x16, 0x02, 0x0d, 0x2a, 0xec, 0x1a, 0x83, 0x61, 0x0c,
+  0x08, 0xab, 0x0c, 0x36, 0x2c, 0x43, 0x57, 0x59, 0x97, 0x37, 0x78, 0x83,
+  0xf5, 0x6d, 0x58, 0xc2, 0x40, 0x0c, 0x2a, 0xeb, 0xf2, 0x86, 0x31, 0x08,
+  0x03, 0xab, 0x0c, 0x36, 0x0c, 0x69, 0xa0, 0x06, 0x6b, 0xb0, 0x61, 0x38,
+  0x03, 0x36, 0x00, 0x36, 0x14, 0xd2, 0xd4, 0x06, 0x0f, 0x50, 0x85, 0x8d,
+  0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x4a, 0x10, 0x54,
+  0x21, 0xc3, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x9b, 0x12,
+  0x10, 0x4d, 0xc8, 0xf0, 0x5c, 0xec, 0xc2, 0xd8, 0xec, 0xca, 0xe4, 0xa6,
+  0x04, 0x46, 0x1d, 0x32, 0x3c, 0x97, 0x39, 0xb4, 0x30, 0xb2, 0x32, 0xb9,
+  0xa6, 0x37, 0xb2, 0x32, 0xb6, 0x29, 0x01, 0x52, 0x86, 0x0c, 0xcf, 0x45,
+  0xae, 0x6c, 0xee, 0xad, 0x4e, 0x6e, 0xac, 0x6c, 0x6e, 0x4a, 0xe0, 0xd4,
+  0x21, 0xc3, 0x73, 0xb1, 0x4b, 0x2b, 0xbb, 0x4b, 0x22, 0x9b, 0xa2, 0x0b,
+  0xa3, 0x2b, 0x9b, 0x12, 0x40, 0x75, 0xc8, 0xf0, 0x5c, 0xca, 0xdc, 0xe8,
+  0xe4, 0xf2, 0xa0, 0xde, 0xd2, 0xdc, 0xe8, 0xe6, 0xa6, 0x04, 0x6d, 0x00,
+  0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x33,
+  0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98,
+  0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33,
+  0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05,
+  0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43,
+  0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08,
+  0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78,
+  0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1,
+  0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33,
+  0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e,
+  0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03,
+  0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80,
+  0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8,
+  0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18,
+  0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee,
+  0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c,
+  0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3,
+  0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83,
+  0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21,
+  0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08,
+  0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x00,
+  0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x36,
+  0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5,
+  0x03, 0x0c, 0x25, 0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2,
+  0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3,
+  0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62,
+  0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f,
+  0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6,
+  0x11, 0x48, 0xc3, 0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11,
+  0xe6, 0x17, 0xb7, 0x6d, 0x00, 0x0b, 0x03, 0x20, 0x4d, 0x4b, 0x5c, 0x13,
+  0x15, 0x11, 0x00, 0x61, 0x20, 0x00, 0x00, 0xcf, 0x00, 0x00, 0x00, 0x13,
+  0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x44,
+  0x8a, 0xab, 0x14, 0x0a, 0x61, 0x06, 0xa0, 0xec, 0x4a, 0x8e, 0x4a, 0x09,
+  0x50, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x23, 0x06, 0x09, 0x00, 0x82,
+  0x60, 0x20, 0x61, 0x03, 0x63, 0x59, 0xc1, 0x88, 0x41, 0x02, 0x80, 0x20,
+  0x18, 0x18, 0xdd, 0x21, 0x5d, 0x8f, 0x31, 0x62, 0x90, 0x00, 0x20, 0x08,
+  0x06, 0x86, 0x87, 0x4c, 0x18, 0x71, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82,
+  0x81, 0xf1, 0x25, 0x54, 0xf6, 0x20, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60,
+  0x60, 0x80, 0x81, 0x52, 0x69, 0x51, 0x32, 0x62, 0x90, 0x00, 0x20, 0x08,
+  0x06, 0x46, 0x18, 0x2c, 0xdc, 0x36, 0x29, 0x23, 0x06, 0x09, 0x00, 0x82,
+  0x60, 0x60, 0x88, 0x01, 0xd3, 0x71, 0xc8, 0x32, 0x62, 0x90, 0x00, 0x20,
+  0x08, 0x06, 0xc6, 0x18, 0x34, 0x5d, 0x57, 0x31, 0x23, 0x06, 0x09, 0x00,
+  0x82, 0x60, 0x60, 0x90, 0x81, 0xe3, 0x79, 0x4a, 0x33, 0x62, 0x90, 0x00,
+  0x20, 0x08, 0x06, 0x46, 0x19, 0x3c, 0xdf, 0x57, 0x39, 0x23, 0x06, 0x07,
+  0x00, 0x82, 0x60, 0xd0, 0x90, 0x81, 0xa3, 0x80, 0xc1, 0x68, 0x42, 0x00,
+  0x8c, 0x26, 0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c, 0x26, 0x10, 0xc3, 0x88,
+  0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0x69, 0x30, 0x3d, 0x66, 0x30, 0x9a,
+  0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09, 0xc4,
+  0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x8d, 0x1b, 0x60, 0x54, 0x19,
+  0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c, 0x26, 0x0c, 0xc2, 0x68,
+  0x02, 0x31, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x41, 0x33, 0x07, 0x5d,
+  0xc6, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x9a, 0x20, 0x04, 0xa3, 0x09, 0x83,
+  0x30, 0x9a, 0x40, 0x0c, 0x36, 0x5d, 0xf2, 0x19, 0x31, 0x40, 0x00, 0x10,
+  0x04, 0x83, 0x07, 0x0f, 0xce, 0xe0, 0x7a, 0x82, 0x11, 0x03, 0x04, 0x00,
+  0x41, 0x30, 0x78, 0xf2, 0x00, 0x0d, 0xae, 0x25, 0xb0, 0xe0, 0x80, 0x8e,
+  0x59, 0x9b, 0x7c, 0x46, 0x0c, 0x10, 0x00, 0x04, 0xc1, 0xe0, 0xe1, 0x83,
+  0x35, 0xd8, 0xa4, 0x60, 0xc4, 0x00, 0x01, 0x40, 0x10, 0x0c, 0x9e, 0x3e,
+  0x60, 0x83, 0xcd, 0x09, 0x2c, 0x50, 0xa0, 0x63, 0xd9, 0x27, 0x9f, 0x11,
+  0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0x40, 0xe1, 0x0d, 0xbe, 0x2a, 0x18,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x27, 0x14, 0xe0, 0xe0, 0x8b, 0x02,
+  0x0b, 0x1a, 0xe8, 0x18, 0x37, 0x06, 0xf2, 0x19, 0x31, 0x40, 0x00, 0x10,
+  0x04, 0x83, 0x87, 0x14, 0xe6, 0x60, 0x0c, 0xb0, 0x60, 0xc4, 0x00, 0x01,
+  0x40, 0x10, 0x0c, 0x9e, 0x52, 0xa0, 0x83, 0x31, 0xa0, 0x02, 0x0b, 0x20,
+  0xe8, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x41, 0x83, 0x0a, 0x72, 0xe0,
+  0x06, 0x74, 0x30, 0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30,
+  0x08, 0xa3, 0x09, 0xc4, 0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x4d,
+  0x2b, 0xdc, 0xc1, 0x1c, 0xe8, 0xc1, 0x68, 0x42, 0x00, 0x8c, 0x26, 0x08,
+  0xc1, 0x68, 0xc2, 0x20, 0x8c, 0x26, 0x10, 0xc3, 0x88, 0xc1, 0x01, 0x80,
+  0x20, 0x18, 0x34, 0xb2, 0xc0, 0x07, 0x78, 0xd0, 0x0a, 0xa3, 0x09, 0x01,
+  0x30, 0x9a, 0x20, 0x04, 0xa3, 0x09, 0x83, 0x30, 0x9a, 0x40, 0x0c, 0x23,
+  0x06, 0x07, 0x00, 0x82, 0x60, 0xd0, 0xdc, 0x42, 0x28, 0xf4, 0xc1, 0x2b,
+  0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c, 0x26, 0x0c, 0xc2, 0x68,
+  0x02, 0x31, 0xd8, 0x14, 0x06, 0xf2, 0x19, 0x31, 0x40, 0x00, 0x10, 0x04,
+  0x83, 0x87, 0x17, 0x56, 0xc1, 0x7b, 0x82, 0x11, 0x03, 0x04, 0x00, 0x41,
+  0x30, 0x78, 0x7a, 0x81, 0x15, 0xb6, 0x25, 0x18, 0x31, 0x40, 0x00, 0x10,
+  0x04, 0x83, 0xc7, 0x17, 0x5a, 0x01, 0x3b, 0x02, 0xb3, 0xca, 0x40, 0x3e,
+  0x23, 0x06, 0x08, 0x00, 0x82, 0x60, 0xf0, 0x80, 0xc3, 0x2b, 0x88, 0x81,
+  0x14, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0xc1, 0x13, 0x0e, 0xb0, 0xf0,
+  0x39, 0xc1, 0x88, 0x01, 0x02, 0x80, 0x20, 0x18, 0x3c, 0xe2, 0x10, 0x0b,
+  0x9c, 0x12, 0x58, 0x96, 0x06, 0xf2, 0x19, 0x31, 0x40, 0x00, 0x10, 0x04,
+  0x83, 0x87, 0x1c, 0x66, 0xc1, 0x0c, 0xaa, 0x60, 0xc4, 0x00, 0x01, 0x40,
+  0x10, 0x0c, 0x9e, 0x72, 0xa0, 0x85, 0x31, 0x88, 0x82, 0x11, 0x03, 0x04,
+  0x00, 0x41, 0x30, 0x78, 0xcc, 0xa1, 0x16, 0xc0, 0xa0, 0x09, 0x8c, 0x6b,
+  0x03, 0xf9, 0x8c, 0x18, 0x20, 0x00, 0x08, 0x82, 0xc1, 0x83, 0x0e, 0xb7,
+  0xa0, 0x06, 0x58, 0x30, 0x62, 0x80, 0x00, 0x20, 0x08, 0x06, 0x4f, 0x3a,
+  0xe0, 0xc2, 0x19, 0x50, 0xc1, 0x88, 0x01, 0x02, 0x80, 0x20, 0x18, 0x3c,
+  0xea, 0x90, 0x0b, 0x64, 0x00, 0x05, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60,
+  0x80, 0xb4, 0x43, 0x2e, 0xa0, 0x03, 0x3a, 0x80, 0x43, 0x33, 0x62, 0x90,
+  0x00, 0x20, 0x08, 0x06, 0x48, 0x3b, 0xe4, 0x02, 0x3a, 0xa0, 0x03, 0x2d,
+  0x24, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0xa0,
+  0x03, 0x3a, 0xf8, 0x42, 0x31, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x48,
+  0x3b, 0xe4, 0x02, 0x3a, 0xa0, 0xc3, 0x2f, 0x04, 0x23, 0x06, 0x09, 0x00,
+  0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0xa4, 0x03, 0x3a, 0x80, 0x43, 0x2b,
+  0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xd2, 0x0e, 0xb9, 0x90, 0x0e,
+  0xe8, 0x40, 0x0b, 0xac, 0x30, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x48,
+  0x3b, 0xe4, 0xc2, 0x38, 0xa0, 0x03, 0x38, 0xc4, 0xc2, 0x88, 0x41, 0x02,
+  0x80, 0x20, 0x18, 0x20, 0xed, 0x90, 0x0b, 0xe3, 0x80, 0x0e, 0xb4, 0x00,
+  0x0b, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80, 0xb4, 0x43, 0x2e, 0x8c,
+  0x03, 0x3a, 0xf8, 0xc2, 0x2b, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01,
+  0xd2, 0x0e, 0xb9, 0x30, 0x0e, 0xe8, 0xf0, 0x0b, 0xae, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12.c b/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12.c
new file mode 100644
index 0000000..06535f0
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12.c
@@ -0,0 +1,3309 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_D3D12
+
+#define SDL_D3D12_NUM_BUFFERS        2
+#define SDL_D3D12_NUM_VERTEX_BUFFERS 256
+#define SDL_D3D12_MAX_NUM_TEXTURES   16384
+#define SDL_D3D12_NUM_UPLOAD_BUFFERS 32
+
+#include "../../core/windows/SDL_windows.h"
+#include "../../video/windows/SDL_windowswindow.h"
+#include "../SDL_sysrender.h"
+#include "../SDL_d3dmath.h"
+#include "../../video/directx/SDL_d3d12.h"
+
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+#include "SDL_render_d3d12_xbox.h"
+#endif
+
+#include "SDL_shaders_d3d12.h"
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SDL_COMPOSE_ERROR(str) __FUNCTION__ ", " str
+#else
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+#endif
+
+// Set up for C function definitions, even when using C++
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This must be included here as the function definitions in SDL_pixels.c/_c.h are C, not C++
+#include "../../video/SDL_pixels_c.h"
+
+/* !!! FIXME: vertex buffer bandwidth could be lower; only use UV coords when
+   !!! FIXME:  textures are needed. */
+
+// Sampler types
+typedef enum
+{
+    D3D12_SAMPLER_NEAREST_CLAMP,
+    D3D12_SAMPLER_NEAREST_WRAP,
+    D3D12_SAMPLER_LINEAR_CLAMP,
+    D3D12_SAMPLER_LINEAR_WRAP,
+    D3D12_SAMPLER_COUNT
+} D3D12_Sampler;
+
+// Vertex shader, common values
+typedef struct
+{
+    Float4X4 model;
+    Float4X4 projectionAndView;
+} D3D12_VertexShaderConstants;
+
+// These should mirror the definitions in D3D12_PixelShader_Common.hlsli
+//static const float TONEMAP_NONE = 0;
+//static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+//static const float TEXTURETYPE_NONE = 0;
+static const float TEXTURETYPE_RGB = 1;
+static const float TEXTURETYPE_NV12 = 2;
+static const float TEXTURETYPE_NV21 = 3;
+static const float TEXTURETYPE_YUV = 4;
+
+static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+typedef struct
+{
+    float scRGB_output;
+    float texture_type;
+    float input_type;
+    float color_scale;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+
+    float YCbCr_matrix[16];
+} D3D12_PixelShaderConstants;
+
+// Per-vertex data
+typedef struct
+{
+    Float2 pos;
+    Float2 tex;
+    SDL_FColor color;
+} D3D12_VertexPositionColor;
+
+// Per-texture data
+typedef struct
+{
+    int w, h;
+    ID3D12Resource *mainTexture;
+    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureResourceView;
+    D3D12_RESOURCE_STATES mainResourceState;
+    SIZE_T mainSRVIndex;
+    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureRenderTargetView;
+    DXGI_FORMAT mainTextureFormat;
+    ID3D12Resource *stagingBuffer;
+    D3D12_RESOURCE_STATES stagingResourceState;
+    D3D12_FILTER scaleMode;
+    D3D12_Shader shader;
+    const float *YCbCr_matrix;
+#ifdef SDL_HAVE_YUV
+    // YV12 texture support
+    bool yuv;
+    ID3D12Resource *mainTextureU;
+    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureResourceViewU;
+    D3D12_RESOURCE_STATES mainResourceStateU;
+    SIZE_T mainSRVIndexU;
+    ID3D12Resource *mainTextureV;
+    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureResourceViewV;
+    D3D12_RESOURCE_STATES mainResourceStateV;
+    SIZE_T mainSRVIndexV;
+
+    // NV12 texture support
+    bool nv12;
+    D3D12_CPU_DESCRIPTOR_HANDLE mainTextureResourceViewNV;
+    SIZE_T mainSRVIndexNV;
+
+    Uint8 *pixels;
+    int pitch;
+#endif
+    SDL_Rect lockedRect;
+} D3D12_TextureData;
+
+// Pipeline State Object data
+typedef struct
+{
+    D3D12_Shader shader;
+    D3D12_PixelShaderConstants shader_constants;
+    SDL_BlendMode blendMode;
+    D3D12_PRIMITIVE_TOPOLOGY_TYPE topology;
+    DXGI_FORMAT rtvFormat;
+    ID3D12PipelineState *pipelineState;
+} D3D12_PipelineState;
+
+// Vertex Buffer
+typedef struct
+{
+    ID3D12Resource *resource;
+    D3D12_VERTEX_BUFFER_VIEW view;
+    size_t size;
+} D3D12_VertexBuffer;
+
+// For SRV pool allocator
+typedef struct
+{
+    SIZE_T index;
+    void *next;
+} D3D12_SRVPoolNode;
+
+// Private renderer data
+typedef struct
+{
+    SDL_SharedObject *hDXGIMod;
+    SDL_SharedObject *hD3D12Mod;
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+    UINT64 frameToken;
+#else
+    IDXGIFactory6 *dxgiFactory;
+    IDXGIAdapter4 *dxgiAdapter;
+    IDXGIDebug *dxgiDebug;
+    IDXGISwapChain4 *swapChain;
+#endif
+    ID3D12Device1 *d3dDevice;
+    ID3D12Debug *debugInterface;
+    ID3D12CommandQueue *commandQueue;
+    ID3D12GraphicsCommandList2 *commandList;
+    DXGI_SWAP_EFFECT swapEffect;
+    UINT swapFlags;
+    UINT syncInterval;
+    UINT presentFlags;
+    DXGI_FORMAT renderTargetFormat;
+    bool pixelSizeChanged;
+
+    // Descriptor heaps
+    ID3D12DescriptorHeap *rtvDescriptorHeap;
+    UINT rtvDescriptorSize;
+    ID3D12DescriptorHeap *textureRTVDescriptorHeap;
+    ID3D12DescriptorHeap *srvDescriptorHeap;
+    UINT srvDescriptorSize;
+    ID3D12DescriptorHeap *samplerDescriptorHeap;
+    UINT samplerDescriptorSize;
+
+    // Data needed per backbuffer
+    ID3D12CommandAllocator *commandAllocators[SDL_D3D12_NUM_BUFFERS];
+    ID3D12Resource *renderTargets[SDL_D3D12_NUM_BUFFERS];
+    UINT64 fenceValue;
+    int currentBackBufferIndex;
+
+    // Fences
+    ID3D12Fence *fence;
+    HANDLE fenceEvent;
+
+    // Root signature and pipeline state data
+    ID3D12RootSignature *rootSignatures[NUM_ROOTSIGS];
+    int pipelineStateCount;
+    D3D12_PipelineState *pipelineStates;
+    D3D12_PipelineState *currentPipelineState;
+
+    D3D12_VertexBuffer vertexBuffers[SDL_D3D12_NUM_VERTEX_BUFFERS];
+    D3D12_CPU_DESCRIPTOR_HANDLE samplers[D3D12_SAMPLER_COUNT];
+
+    // Data for staging/allocating textures
+    ID3D12Resource *uploadBuffers[SDL_D3D12_NUM_UPLOAD_BUFFERS];
+    int currentUploadBuffer;
+
+    // Pool allocator to handle reusing SRV heap indices
+    D3D12_SRVPoolNode *srvPoolHead;
+    D3D12_SRVPoolNode srvPoolNodes[SDL_D3D12_MAX_NUM_TEXTURES];
+
+    // Vertex buffer constants
+    D3D12_VertexShaderConstants vertexShaderConstantsData;
+
+    // Cached renderer properties
+    DXGI_MODE_ROTATION rotation;
+    D3D12_TextureData *textureRenderTarget;
+    D3D12_CPU_DESCRIPTOR_HANDLE currentRenderTargetView;
+    D3D12_CPU_DESCRIPTOR_HANDLE currentShaderResource;
+    D3D12_CPU_DESCRIPTOR_HANDLE currentSampler;
+    bool cliprectDirty;
+    bool currentCliprectEnabled;
+    SDL_Rect currentCliprect;
+    SDL_Rect currentViewport;
+    int currentViewportRotation;
+    bool viewportDirty;
+    Float4X4 identity;
+    int currentVertexBuffer;
+    bool issueBatch;
+} D3D12_RenderData;
+
+// Define D3D GUIDs here so we don't have to include uuid.lib.
+
+#ifdef HAVE_GCC_DIAGNOSTIC_PRAGMA
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-const-variable"
+#endif
+
+static const GUID SDL_IID_IDXGIFactory6 = { 0xc1b6694f, 0xff09, 0x44a9, { 0xb0, 0x3c, 0x77, 0x90, 0x0a, 0x0a, 0x1d, 0x17 } };
+static const GUID SDL_IID_IDXGIAdapter4 = { 0x3c8d99d1, 0x4fbf, 0x4181, { 0xa8, 0x2c, 0xaf, 0x66, 0xbf, 0x7b, 0xd2, 0x4e } };
+static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };
+static const GUID SDL_IID_ID3D12Device1 = { 0x77acce80, 0x638e, 0x4e65, { 0x88, 0x95, 0xc1, 0xf2, 0x33, 0x86, 0x86, 0x3e } };
+static const GUID SDL_IID_IDXGISwapChain4 = { 0x3D585D5A, 0xBD4A, 0x489E, { 0xB1, 0xF4, 0x3D, 0xBC, 0xB6, 0x45, 0x2F, 0xFB } };
+static const GUID SDL_IID_IDXGIDebug1 = { 0xc5a05f0c, 0x16f2, 0x4adf, { 0x9f, 0x4d, 0xa8, 0xc4, 0xd5, 0x8a, 0xc5, 0x50 } };
+static const GUID SDL_IID_IDXGIInfoQueue = { 0xD67441C7, 0x672A, 0x476f, { 0x9E, 0x82, 0xCD, 0x55, 0xB4, 0x49, 0x49, 0xCE } };
+static const GUID SDL_IID_ID3D12Debug = { 0x344488b7, 0x6846, 0x474b, { 0xb9, 0x89, 0xf0, 0x27, 0x44, 0x82, 0x45, 0xe0 } };
+static const GUID SDL_DXGI_DEBUG_ALL = { 0xe48ae283, 0xda80, 0x490b, { 0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8 } };
+static const GUID SDL_IID_ID3D12CommandQueue = { 0x0ec870a6, 0x5d7e, 0x4c22, { 0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed } };
+static const GUID SDL_IID_ID3D12DescriptorHeap = { 0x8efb471d, 0x616c, 0x4f49, { 0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51 } };
+static const GUID SDL_IID_ID3D12CommandAllocator = { 0x6102dee4, 0xaf59, 0x4b09, { 0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24 } };
+static const GUID SDL_IID_ID3D12GraphicsCommandList2 = { 0x38C3E585, 0xFF17, 0x412C, { 0x91, 0x50, 0x4F, 0xC6, 0xF9, 0xD7, 0x2A, 0x28 } };
+static const GUID SDL_IID_ID3D12Fence = { 0x0a753dcf, 0xc4d8, 0x4b91, { 0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76 } };
+static const GUID SDL_IID_ID3D12Resource = { 0x696442be, 0xa72e, 0x4059, { 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad } };
+static const GUID SDL_IID_ID3D12RootSignature = { 0xc54a6b66, 0x72df, 0x4ee8, { 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14 } };
+static const GUID SDL_IID_ID3D12PipelineState = { 0x765a30f3, 0xf624, 0x4c6f, { 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45 } };
+static const GUID SDL_IID_ID3D12Heap = { 0x6b3b2502, 0x6e51, 0x45b3, { 0x90, 0xee, 0x98, 0x84, 0x26, 0x5e, 0x8d, 0xf3 } };
+static const GUID SDL_IID_ID3D12InfoQueue = { 0x0742a90b, 0xc387, 0x483f, { 0xb9, 0x46, 0x30, 0xa7, 0xe4, 0xe6, 0x14, 0x58 } };
+
+#ifdef HAVE_GCC_DIAGNOSTIC_PRAGMA
+#pragma GCC diagnostic pop
+#endif
+
+static UINT D3D12_Align(UINT location, UINT alignment)
+{
+    return (location + (alignment - 1)) & ~(alignment - 1);
+}
+
+static SDL_PixelFormat D3D12_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat)
+{
+    switch (dxgiFormat) {
+    case DXGI_FORMAT_B8G8R8A8_UNORM:
+    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_ARGB8888;
+    case DXGI_FORMAT_R8G8B8A8_UNORM:
+    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_ABGR8888;
+    case DXGI_FORMAT_B8G8R8X8_UNORM:
+    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_XRGB8888;
+    case DXGI_FORMAT_R10G10B10A2_UNORM:
+        return SDL_PIXELFORMAT_ABGR2101010;
+    case DXGI_FORMAT_R16G16B16A16_FLOAT:
+        return SDL_PIXELFORMAT_RGBA64_FLOAT;
+    default:
+        return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static DXGI_FORMAT SDLPixelFormatToDXGITextureFormat(Uint32 format, Uint32 output_colorspace)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_RGBA64_FLOAT:
+        return DXGI_FORMAT_R16G16B16A16_FLOAT;
+    case SDL_PIXELFORMAT_ABGR2101010:
+        return DXGI_FORMAT_R10G10B10A2_UNORM;
+    case SDL_PIXELFORMAT_ARGB8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8A8_UNORM;
+    case SDL_PIXELFORMAT_ABGR8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_R8G8B8A8_UNORM;
+    case SDL_PIXELFORMAT_XRGB8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8X8_UNORM;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+        return DXGI_FORMAT_R8_UNORM;
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        return DXGI_FORMAT_NV12;
+    case SDL_PIXELFORMAT_P010:
+        return DXGI_FORMAT_P010;
+    default:
+        return DXGI_FORMAT_UNKNOWN;
+    }
+}
+
+static DXGI_FORMAT SDLPixelFormatToDXGIMainResourceViewFormat(Uint32 format, Uint32 colorspace)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_RGBA64_FLOAT:
+        return DXGI_FORMAT_R16G16B16A16_FLOAT;
+    case SDL_PIXELFORMAT_ABGR2101010:
+        return DXGI_FORMAT_R10G10B10A2_UNORM;
+    case SDL_PIXELFORMAT_ARGB8888:
+        if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8A8_UNORM;
+    case SDL_PIXELFORMAT_ABGR8888:
+        if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_R8G8B8A8_UNORM;
+    case SDL_PIXELFORMAT_XRGB8888:
+        if (colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+        }
+        return DXGI_FORMAT_B8G8R8X8_UNORM;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_NV12: // For the Y texture
+    case SDL_PIXELFORMAT_NV21: // For the Y texture
+        return DXGI_FORMAT_R8_UNORM;
+    case SDL_PIXELFORMAT_P010:  // For the Y texture
+        return DXGI_FORMAT_R16_UNORM;
+    default:
+        return DXGI_FORMAT_UNKNOWN;
+    }
+}
+
+static void D3D12_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+
+static void D3D12_ReleaseAll(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+
+    SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_D3D12_DEVICE_POINTER, NULL);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_D3D12_COMMAND_QUEUE_POINTER, NULL);
+
+    // Release all textures
+    for (SDL_Texture *texture = renderer->textures; texture; texture = texture->next) {
+        D3D12_DestroyTexture(renderer, texture);
+    }
+
+    // Release/reset everything else
+    if (data) {
+        int i;
+
+#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+        D3D_SAFE_RELEASE(data->dxgiFactory);
+        D3D_SAFE_RELEASE(data->dxgiAdapter);
+        D3D_SAFE_RELEASE(data->swapChain);
+#endif
+        D3D_SAFE_RELEASE(data->d3dDevice);
+        D3D_SAFE_RELEASE(data->debugInterface);
+        D3D_SAFE_RELEASE(data->commandQueue);
+        D3D_SAFE_RELEASE(data->commandList);
+        D3D_SAFE_RELEASE(data->rtvDescriptorHeap);
+        D3D_SAFE_RELEASE(data->textureRTVDescriptorHeap);
+        D3D_SAFE_RELEASE(data->srvDescriptorHeap);
+        D3D_SAFE_RELEASE(data->samplerDescriptorHeap);
+        D3D_SAFE_RELEASE(data->fence);
+
+        for (i = 0; i < SDL_D3D12_NUM_BUFFERS; ++i) {
+            D3D_SAFE_RELEASE(data->commandAllocators[i]);
+            D3D_SAFE_RELEASE(data->renderTargets[i]);
+        }
+
+        if (data->pipelineStateCount > 0) {
+            for (i = 0; i < data->pipelineStateCount; ++i) {
+                D3D_SAFE_RELEASE(data->pipelineStates[i].pipelineState);
+            }
+            SDL_free(data->pipelineStates);
+            data->pipelineStates = NULL;
+            data->pipelineStateCount = 0;
+        }
+
+        for (i = 0; i < NUM_ROOTSIGS; ++i) {
+            D3D_SAFE_RELEASE(data->rootSignatures[i]);
+        }
+
+        for (i = 0; i < SDL_D3D12_NUM_VERTEX_BUFFERS; ++i) {
+            D3D_SAFE_RELEASE(data->vertexBuffers[i].resource);
+            data->vertexBuffers[i].size = 0;
+        }
+
+        data->swapEffect = (DXGI_SWAP_EFFECT)0;
+        data->swapFlags = 0;
+        data->currentRenderTargetView.ptr = 0;
+        data->currentSampler.ptr = 0;
+
+#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+        // Check for any leaks if in debug mode
+        if (data->dxgiDebug) {
+            DXGI_DEBUG_RLO_FLAGS rloFlags = (DXGI_DEBUG_RLO_FLAGS)(DXGI_DEBUG_RLO_DETAIL | DXGI_DEBUG_RLO_IGNORE_INTERNAL);
+            IDXGIDebug_ReportLiveObjects(data->dxgiDebug, SDL_DXGI_DEBUG_ALL, rloFlags);
+            D3D_SAFE_RELEASE(data->dxgiDebug);
+        }
+#endif
+
+        /* Unload the D3D libraries.  This should be done last, in order
+         * to prevent IUnknown::Release() calls from crashing.
+         */
+        if (data->hD3D12Mod) {
+            SDL_UnloadObject(data->hD3D12Mod);
+            data->hD3D12Mod = NULL;
+        }
+        if (data->hDXGIMod) {
+            SDL_UnloadObject(data->hDXGIMod);
+            data->hDXGIMod = NULL;
+        }
+    }
+}
+
+static D3D12_GPU_DESCRIPTOR_HANDLE D3D12_CPUtoGPUHandle(ID3D12DescriptorHeap *heap, D3D12_CPU_DESCRIPTOR_HANDLE CPUHandle)
+{
+    D3D12_CPU_DESCRIPTOR_HANDLE CPUHeapStart;
+    D3D12_GPU_DESCRIPTOR_HANDLE GPUHandle;
+    SIZE_T offset;
+
+    // Calculate the correct offset into the heap
+    D3D_CALL_RET(heap, GetCPUDescriptorHandleForHeapStart, &CPUHeapStart);
+    offset = CPUHandle.ptr - CPUHeapStart.ptr;
+
+    D3D_CALL_RET(heap, GetGPUDescriptorHandleForHeapStart, &GPUHandle);
+    GPUHandle.ptr += offset;
+
+    return GPUHandle;
+}
+
+static void D3D12_WaitForGPU(D3D12_RenderData *data)
+{
+    if (data->commandQueue && data->fence && data->fenceEvent) {
+        ID3D12CommandQueue_Signal(data->commandQueue, data->fence, data->fenceValue);
+        if (ID3D12Fence_GetCompletedValue(data->fence) < data->fenceValue) {
+            ID3D12Fence_SetEventOnCompletion(data->fence,
+                     data->fenceValue,
+                     data->fenceEvent);
+            WaitForSingleObjectEx(data->fenceEvent, INFINITE, FALSE);
+        }
+
+        data->fenceValue++;
+    }
+}
+
+static D3D12_CPU_DESCRIPTOR_HANDLE D3D12_GetCurrentRenderTargetView(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor;
+
+    if (data->textureRenderTarget) {
+        return data->textureRenderTarget->mainTextureRenderTargetView;
+    }
+
+    SDL_zero(rtvDescriptor);
+    D3D_CALL_RET(data->rtvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &rtvDescriptor);
+    rtvDescriptor.ptr += data->currentBackBufferIndex * data->rtvDescriptorSize;
+    return rtvDescriptor;
+}
+
+static void D3D12_TransitionResource(D3D12_RenderData *data,
+                                     ID3D12Resource *resource,
+                                     D3D12_RESOURCE_STATES beforeState,
+                                     D3D12_RESOURCE_STATES afterState)
+{
+    D3D12_RESOURCE_BARRIER barrier;
+
+    if (beforeState != afterState) {
+        SDL_zero(barrier);
+        barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+        barrier.Transition.pResource = resource;
+        barrier.Transition.StateBefore = beforeState;
+        barrier.Transition.StateAfter = afterState;
+        barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
+
+        ID3D12GraphicsCommandList2_ResourceBarrier(data->commandList, 1, &barrier);
+    }
+}
+
+static void D3D12_ResetCommandList(D3D12_RenderData *data)
+{
+    int i;
+    ID3D12DescriptorHeap *rootDescriptorHeaps[] = { data->srvDescriptorHeap, data->samplerDescriptorHeap };
+    ID3D12CommandAllocator *commandAllocator = data->commandAllocators[data->currentBackBufferIndex];
+
+    ID3D12CommandAllocator_Reset(commandAllocator);
+    ID3D12GraphicsCommandList2_Reset(data->commandList, commandAllocator, NULL);
+    data->currentPipelineState = NULL;
+    data->currentVertexBuffer = 0;
+    data->issueBatch = false;
+    data->cliprectDirty = true;
+    data->viewportDirty = true;
+    data->currentRenderTargetView.ptr = 0;
+    // FIXME should we also clear currentSampler.ptr and currentRenderTargetView.ptr ? (and use D3D12_InvalidateCachedState() instead)
+
+    // Release any upload buffers that were inflight
+    for (i = 0; i < data->currentUploadBuffer; ++i) {
+        D3D_SAFE_RELEASE(data->uploadBuffers[i]);
+    }
+    data->currentUploadBuffer = 0;
+
+    ID3D12GraphicsCommandList2_SetDescriptorHeaps(data->commandList, 2, rootDescriptorHeaps);
+}
+
+static HRESULT D3D12_IssueBatch(D3D12_RenderData *data)
+{
+    HRESULT result = S_OK;
+
+    // Issue the command list
+    result = ID3D12GraphicsCommandList2_Close(data->commandList);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("D3D12_IssueBatch"), result);
+        return result;
+    }
+    ID3D12CommandQueue_ExecuteCommandLists(data->commandQueue, 1, (ID3D12CommandList *const *)&data->commandList);
+
+    D3D12_WaitForGPU(data);
+
+    D3D12_ResetCommandList(data);
+
+    return result;
+}
+
+static void D3D12_DestroyRenderer(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    if (data) {
+        D3D12_WaitForGPU(data);
+        D3D12_ReleaseAll(renderer);
+        SDL_free(data);
+    }
+}
+
+static D3D12_BLEND GetBlendFunc(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return D3D12_BLEND_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return D3D12_BLEND_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return D3D12_BLEND_SRC_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return D3D12_BLEND_INV_SRC_COLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return D3D12_BLEND_SRC_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return D3D12_BLEND_INV_SRC_ALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return D3D12_BLEND_DEST_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return D3D12_BLEND_INV_DEST_COLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return D3D12_BLEND_DEST_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return D3D12_BLEND_INV_DEST_ALPHA;
+    default:
+        return (D3D12_BLEND)0;
+    }
+}
+
+static D3D12_BLEND_OP GetBlendEquation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return D3D12_BLEND_OP_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return D3D12_BLEND_OP_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return D3D12_BLEND_OP_REV_SUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return D3D12_BLEND_OP_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return D3D12_BLEND_OP_MAX;
+    default:
+        return (D3D12_BLEND_OP)0;
+    }
+}
+
+static void D3D12_CreateBlendState(SDL_Renderer *renderer, SDL_BlendMode blendMode, D3D12_BLEND_DESC *outBlendDesc)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    SDL_zerop(outBlendDesc);
+    outBlendDesc->AlphaToCoverageEnable = FALSE;
+    outBlendDesc->IndependentBlendEnable = FALSE;
+    outBlendDesc->RenderTarget[0].BlendEnable = TRUE;
+    outBlendDesc->RenderTarget[0].SrcBlend = GetBlendFunc(srcColorFactor);
+    outBlendDesc->RenderTarget[0].DestBlend = GetBlendFunc(dstColorFactor);
+    outBlendDesc->RenderTarget[0].BlendOp = GetBlendEquation(colorOperation);
+    outBlendDesc->RenderTarget[0].SrcBlendAlpha = GetBlendFunc(srcAlphaFactor);
+    outBlendDesc->RenderTarget[0].DestBlendAlpha = GetBlendFunc(dstAlphaFactor);
+    outBlendDesc->RenderTarget[0].BlendOpAlpha = GetBlendEquation(alphaOperation);
+    outBlendDesc->RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
+}
+
+static D3D12_PipelineState *D3D12_CreatePipelineState(SDL_Renderer *renderer,
+                                                      D3D12_Shader shader,
+                                                      SDL_BlendMode blendMode,
+                                                      D3D12_PRIMITIVE_TOPOLOGY_TYPE topology,
+                                                      DXGI_FORMAT rtvFormat)
+{
+    const D3D12_INPUT_ELEMENT_DESC vertexDesc[] = {
+        { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
+    };
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    D3D12_GRAPHICS_PIPELINE_STATE_DESC pipelineDesc;
+    ID3D12PipelineState *pipelineState = NULL;
+    D3D12_PipelineState *pipelineStates;
+    HRESULT result = S_OK;
+
+    SDL_zero(pipelineDesc);
+    pipelineDesc.pRootSignature = data->rootSignatures[D3D12_GetRootSignatureType(shader)];
+    D3D12_GetVertexShader(shader, &pipelineDesc.VS);
+    D3D12_GetPixelShader(shader, &pipelineDesc.PS);
+    D3D12_CreateBlendState(renderer, blendMode, &pipelineDesc.BlendState);
+    pipelineDesc.SampleMask = 0xffffffff;
+
+    pipelineDesc.RasterizerState.AntialiasedLineEnable = FALSE;
+    pipelineDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
+    pipelineDesc.RasterizerState.DepthBias = 0;
+    pipelineDesc.RasterizerState.DepthBiasClamp = 0.0f;
+    pipelineDesc.RasterizerState.DepthClipEnable = TRUE;
+    pipelineDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
+    pipelineDesc.RasterizerState.FrontCounterClockwise = FALSE;
+    pipelineDesc.RasterizerState.MultisampleEnable = FALSE;
+    pipelineDesc.RasterizerState.SlopeScaledDepthBias = 0.0f;
+
+    pipelineDesc.InputLayout.pInputElementDescs = vertexDesc;
+    pipelineDesc.InputLayout.NumElements = 3;
+
+    pipelineDesc.PrimitiveTopologyType = topology;
+
+    pipelineDesc.NumRenderTargets = 1;
+    pipelineDesc.RTVFormats[0] = rtvFormat;
+    pipelineDesc.SampleDesc.Count = 1;
+    pipelineDesc.SampleDesc.Quality = 0;
+
+    result = ID3D12Device1_CreateGraphicsPipelineState(data->d3dDevice,
+                      &pipelineDesc,
+                      D3D_GUID(SDL_IID_ID3D12PipelineState),
+                      (void **)&pipelineState);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateGraphicsPipelineState"), result);
+        return NULL;
+    }
+
+    pipelineStates = (D3D12_PipelineState *)SDL_realloc(data->pipelineStates, (data->pipelineStateCount + 1) * sizeof(*pipelineStates));
+    if (!pipelineStates) {
+        D3D_SAFE_RELEASE(pipelineState);
+        return NULL;
+    }
+
+    pipelineStates[data->pipelineStateCount].shader = shader;
+    pipelineStates[data->pipelineStateCount].blendMode = blendMode;
+    pipelineStates[data->pipelineStateCount].topology = topology;
+    pipelineStates[data->pipelineStateCount].rtvFormat = rtvFormat;
+    pipelineStates[data->pipelineStateCount].pipelineState = pipelineState;
+    data->pipelineStates = pipelineStates;
+    ++data->pipelineStateCount;
+
+    return &pipelineStates[data->pipelineStateCount - 1];
+}
+
+static HRESULT D3D12_CreateVertexBuffer(D3D12_RenderData *data, size_t vbidx, size_t size)
+{
+    D3D12_HEAP_PROPERTIES vbufferHeapProps;
+    D3D12_RESOURCE_DESC vbufferDesc;
+    HRESULT result;
+
+    D3D_SAFE_RELEASE(data->vertexBuffers[vbidx].resource);
+
+    SDL_zero(vbufferHeapProps);
+    vbufferHeapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
+    vbufferHeapProps.CreationNodeMask = 1;
+    vbufferHeapProps.VisibleNodeMask = 1;
+
+    SDL_zero(vbufferDesc);
+    vbufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+    vbufferDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+    vbufferDesc.Width = size;
+    vbufferDesc.Height = 1;
+    vbufferDesc.DepthOrArraySize = 1;
+    vbufferDesc.MipLevels = 1;
+    vbufferDesc.Format = DXGI_FORMAT_UNKNOWN;
+    vbufferDesc.SampleDesc.Count = 1;
+    vbufferDesc.SampleDesc.Quality = 0;
+    vbufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+    vbufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+    result = ID3D12Device1_CreateCommittedResource(data->d3dDevice,
+                      &vbufferHeapProps,
+                      D3D12_HEAP_FLAG_NONE,
+                      &vbufferDesc,
+                      D3D12_RESOURCE_STATE_GENERIC_READ,
+                      NULL,
+                      D3D_GUID(SDL_IID_ID3D12Resource),
+                      (void **)&data->vertexBuffers[vbidx].resource);
+
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreatePlacedResource [vertex buffer]"), result);
+        return result;
+    }
+
+    data->vertexBuffers[vbidx].view.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(data->vertexBuffers[vbidx].resource);
+    data->vertexBuffers[vbidx].view.StrideInBytes = sizeof(D3D12_VertexPositionColor);
+    data->vertexBuffers[vbidx].size = size;
+
+    return result;
+}
+
+// Create resources that depend on the device.
+static HRESULT D3D12_CreateDeviceResources(SDL_Renderer *renderer)
+{
+#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+    typedef HRESULT(WINAPI * PFN_CREATE_DXGI_FACTORY)(UINT flags, REFIID riid, void **ppFactory);
+    PFN_CREATE_DXGI_FACTORY CreateDXGIFactoryFunc;
+    PFN_D3D12_CREATE_DEVICE D3D12CreateDeviceFunc;
+#endif
+    typedef HANDLE(WINAPI * PFN_CREATE_EVENT_EX)(LPSECURITY_ATTRIBUTES lpEventAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess);
+    PFN_CREATE_EVENT_EX CreateEventExFunc;
+
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    ID3D12Device *d3dDevice = NULL;
+    HRESULT result = S_OK;
+    UINT creationFlags = 0;
+    int i;
+    bool createDebug;
+
+    D3D12_COMMAND_QUEUE_DESC queueDesc;
+    D3D12_DESCRIPTOR_HEAP_DESC descriptorHeapDesc;
+    D3D12_SAMPLER_DESC samplerDesc;
+    ID3D12DescriptorHeap *rootDescriptorHeaps[2];
+
+    // See if we need debug interfaces
+    createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_DIRECT3D11_DEBUG, false);
+
+#ifdef SDL_PLATFORM_GDK
+    CreateEventExFunc = CreateEventExW;
+#else
+    // CreateEventEx() arrived in Vista, so we need to load it with GetProcAddress for XP.
+    {
+        HMODULE kernel32 = GetModuleHandle(TEXT("kernel32.dll"));
+        CreateEventExFunc = NULL;
+        if (kernel32) {
+            CreateEventExFunc = (PFN_CREATE_EVENT_EX)GetProcAddress(kernel32, "CreateEventExW");
+        }
+    }
+#endif
+    if (!CreateEventExFunc) {
+        result = E_FAIL;
+        goto done;
+    }
+
+#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+    data->hDXGIMod = SDL_LoadObject("dxgi.dll");
+    if (!data->hDXGIMod) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    CreateDXGIFactoryFunc = (PFN_CREATE_DXGI_FACTORY)SDL_LoadFunction(data->hDXGIMod, "CreateDXGIFactory2");
+    if (!CreateDXGIFactoryFunc) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    data->hD3D12Mod = SDL_LoadObject("D3D12.dll");
+    if (!data->hD3D12Mod) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    D3D12CreateDeviceFunc = (PFN_D3D12_CREATE_DEVICE)SDL_LoadFunction(data->hD3D12Mod, "D3D12CreateDevice");
+    if (!D3D12CreateDeviceFunc) {
+        result = E_FAIL;
+        goto done;
+    }
+
+    if (createDebug) {
+        PFN_D3D12_GET_DEBUG_INTERFACE D3D12GetDebugInterfaceFunc;
+
+        D3D12GetDebugInterfaceFunc = (PFN_D3D12_GET_DEBUG_INTERFACE)SDL_LoadFunction(data->hD3D12Mod, "D3D12GetDebugInterface");
+        if (!D3D12GetDebugInterfaceFunc) {
+            result = E_FAIL;
+            goto done;
+        }
+        if (SUCCEEDED(D3D12GetDebugInterfaceFunc(D3D_GUID(SDL_IID_ID3D12Debug), (void **)&data->debugInterface))) {
+            ID3D12Debug_EnableDebugLayer(data->debugInterface);
+        }
+    }
+#endif // !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+    result = D3D12_XBOX_CreateDevice(&d3dDevice, createDebug);
+    if (FAILED(result)) {
+        // SDL Error is set by D3D12_XBOX_CreateDevice
+        goto done;
+    }
+#else
+    if (createDebug) {
+#ifdef __IDXGIInfoQueue_INTERFACE_DEFINED__
+        IDXGIInfoQueue *dxgiInfoQueue = NULL;
+        PFN_CREATE_DXGI_FACTORY DXGIGetDebugInterfaceFunc;
+
+        // If the debug hint is set, also create the DXGI factory in debug mode
+        DXGIGetDebugInterfaceFunc = (PFN_CREATE_DXGI_FACTORY)SDL_LoadFunction(data->hDXGIMod, "DXGIGetDebugInterface1");
+        if (!DXGIGetDebugInterfaceFunc) {
+            result = E_FAIL;
+            goto done;
+        }
+
+        result = DXGIGetDebugInterfaceFunc(0, D3D_GUID(SDL_IID_IDXGIDebug1), (void **)&data->dxgiDebug);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("DXGIGetDebugInterface1"), result);
+            goto done;
+        }
+
+        result = DXGIGetDebugInterfaceFunc(0, D3D_GUID(SDL_IID_IDXGIInfoQueue), (void **)&dxgiInfoQueue);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("DXGIGetDebugInterface1"), result);
+            goto done;
+        }
+
+        IDXGIInfoQueue_SetBreakOnSeverity(dxgiInfoQueue, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, TRUE);
+        IDXGIInfoQueue_SetBreakOnSeverity(dxgiInfoQueue, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, TRUE);
+        D3D_SAFE_RELEASE(dxgiInfoQueue);
+#endif // __IDXGIInfoQueue_INTERFACE_DEFINED__
+        creationFlags = DXGI_CREATE_FACTORY_DEBUG;
+    }
+
+    result = CreateDXGIFactoryFunc(creationFlags, D3D_GUID(SDL_IID_IDXGIFactory6), (void **)&data->dxgiFactory);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("CreateDXGIFactory"), result);
+        goto done;
+    }
+
+    // Prefer a high performance adapter if there are multiple choices
+    result = IDXGIFactory6_EnumAdapterByGpuPreference(data->dxgiFactory,
+                      0,
+                      DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE,
+                      D3D_GUID(SDL_IID_IDXGIAdapter4),
+                      (void **)&data->dxgiAdapter);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGIFactory6::EnumAdapterByGPUPreference"), result);
+        goto done;
+    }
+
+    result = D3D12CreateDeviceFunc((IUnknown *)data->dxgiAdapter,
+                                   D3D_FEATURE_LEVEL_11_0, // Request minimum feature level 11.0 for maximum compatibility
+                                   D3D_GUID(SDL_IID_ID3D12Device1),
+                                   (void **)&d3dDevice);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("D3D12CreateDevice"), result);
+        goto done;
+    }
+
+    // Setup the info queue if in debug mode
+    if (createDebug) {
+        ID3D12InfoQueue *infoQueue = NULL;
+        D3D12_MESSAGE_SEVERITY severities[] = { D3D12_MESSAGE_SEVERITY_INFO };
+        D3D12_INFO_QUEUE_FILTER filter;
+
+        result = ID3D12Device1_QueryInterface(d3dDevice, D3D_GUID(SDL_IID_ID3D12InfoQueue), (void **)&infoQueue);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device to ID3D12InfoQueue"), result);
+            goto done;
+        }
+
+        SDL_zero(filter);
+        filter.DenyList.NumSeverities = 1;
+        filter.DenyList.pSeverityList = severities;
+        ID3D12InfoQueue_PushStorageFilter(infoQueue, &filter);
+
+        ID3D12InfoQueue_SetBreakOnSeverity(infoQueue, D3D12_MESSAGE_SEVERITY_ERROR, TRUE);
+        ID3D12InfoQueue_SetBreakOnSeverity(infoQueue, D3D12_MESSAGE_SEVERITY_CORRUPTION, TRUE);
+
+        D3D_SAFE_RELEASE(infoQueue);
+    }
+#endif // !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+
+    result = ID3D12Device_QueryInterface(d3dDevice, D3D_GUID(SDL_IID_ID3D12Device1), (void **)&data->d3dDevice);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device to ID3D12Device1"), result);
+        goto done;
+    }
+
+    // Create a command queue
+    SDL_zero(queueDesc);
+    queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+    queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+
+    result = ID3D12Device1_CreateCommandQueue(data->d3dDevice,
+                      &queueDesc,
+                      D3D_GUID(SDL_IID_ID3D12CommandQueue),
+                      (void **)&data->commandQueue);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommandQueue"), result);
+        goto done;
+    }
+
+    // Create the descriptor heaps for the render target view, texture SRVs, and samplers
+    SDL_zero(descriptorHeapDesc);
+    descriptorHeapDesc.NumDescriptors = SDL_D3D12_NUM_BUFFERS;
+    descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+    result = ID3D12Device1_CreateDescriptorHeap(data->d3dDevice,
+                      &descriptorHeapDesc,
+                      D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
+                      (void **)&data->rtvDescriptorHeap);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateDescriptorHeap [rtv]"), result);
+        goto done;
+    }
+    data->rtvDescriptorSize = ID3D12Device1_GetDescriptorHandleIncrementSize(d3dDevice, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+
+    descriptorHeapDesc.NumDescriptors = SDL_D3D12_MAX_NUM_TEXTURES;
+    result = ID3D12Device1_CreateDescriptorHeap(data->d3dDevice,
+                      &descriptorHeapDesc,
+                      D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
+                      (void **)&data->textureRTVDescriptorHeap);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateDescriptorHeap [texture rtv]"), result);
+        goto done;
+    }
+
+    SDL_zero(descriptorHeapDesc);
+    descriptorHeapDesc.NumDescriptors = SDL_D3D12_MAX_NUM_TEXTURES;
+    descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
+    descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+    result = ID3D12Device1_CreateDescriptorHeap(data->d3dDevice,
+                      &descriptorHeapDesc,
+                      D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
+                      (void **)&data->srvDescriptorHeap);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateDescriptorHeap  [srv]"), result);
+        goto done;
+    }
+    rootDescriptorHeaps[0] = data->srvDescriptorHeap;
+    data->srvDescriptorSize = ID3D12Device1_GetDescriptorHandleIncrementSize(d3dDevice, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+
+    SDL_zero(descriptorHeapDesc);
+    descriptorHeapDesc.NumDescriptors = 4;
+    descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
+    descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+    result = ID3D12Device1_CreateDescriptorHeap(data->d3dDevice,
+                      &descriptorHeapDesc,
+                      D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
+                      (void **)&data->samplerDescriptorHeap);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateDescriptorHeap  [sampler]"), result);
+        goto done;
+    }
+    rootDescriptorHeaps[1] = data->samplerDescriptorHeap;
+    data->samplerDescriptorSize = ID3D12Device1_GetDescriptorHandleIncrementSize(d3dDevice, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+
+    // Create a command allocator for each back buffer
+    for (i = 0; i < SDL_D3D12_NUM_BUFFERS; ++i) {
+        result = ID3D12Device1_CreateCommandAllocator(data->d3dDevice,
+                          D3D12_COMMAND_LIST_TYPE_DIRECT,
+                          D3D_GUID(SDL_IID_ID3D12CommandAllocator),
+                          (void **)&data->commandAllocators[i]);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommandAllocator"), result);
+            goto done;
+        }
+    }
+
+    // Create the command list
+    result = ID3D12Device1_CreateCommandList(data->d3dDevice,
+                      0,
+                      D3D12_COMMAND_LIST_TYPE_DIRECT,
+                      data->commandAllocators[0],
+                      NULL,
+                      D3D_GUID(SDL_IID_ID3D12GraphicsCommandList2),
+                      (void **)&data->commandList);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommandList"), result);
+        goto done;
+    }
+
+    // Set the descriptor heaps to the correct initial value
+    ID3D12GraphicsCommandList2_SetDescriptorHeaps(data->commandList, 2, rootDescriptorHeaps);
+
+    // Create the fence and fence event
+    result = ID3D12Device_CreateFence(data->d3dDevice,
+                      data->fenceValue,
+                      D3D12_FENCE_FLAG_NONE,
+                      D3D_GUID(SDL_IID_ID3D12Fence),
+                      (void **)&data->fence);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateFence"), result);
+        goto done;
+    }
+
+    data->fenceValue++;
+
+    data->fenceEvent = CreateEventExFunc(NULL, NULL, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
+    if (!data->fenceEvent) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("CreateEventEx"), result);
+        goto done;
+    }
+
+    // Create all the root signatures
+    for (i = 0; i < NUM_ROOTSIGS; ++i) {
+        D3D12_SHADER_BYTECODE rootSigData;
+        D3D12_GetRootSignatureData((D3D12_RootSignature)i, &rootSigData);
+        result = ID3D12Device1_CreateRootSignature(data->d3dDevice,
+                          0,
+                          rootSigData.pShaderBytecode,
+                          rootSigData.BytecodeLength,
+                          D3D_GUID(SDL_IID_ID3D12RootSignature),
+                          (void **)&data->rootSignatures[i]);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateRootSignature"), result);
+            goto done;
+        }
+    }
+
+    {
+        const SDL_BlendMode defaultBlendModes[] = {
+            SDL_BLENDMODE_BLEND,
+        };
+        const DXGI_FORMAT defaultRTVFormats[] = {
+            DXGI_FORMAT_B8G8R8A8_UNORM,
+        };
+        int j, k, l;
+
+        // Create a few default pipeline state objects, to verify that this renderer will work
+        for (i = 0; i < NUM_SHADERS; ++i) {
+            for (j = 0; j < SDL_arraysize(defaultBlendModes); ++j) {
+                for (k = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT; k < D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH; ++k) {
+                    for (l = 0; l < SDL_arraysize(defaultRTVFormats); ++l) {
+                        if (!D3D12_CreatePipelineState(renderer, (D3D12_Shader)i, defaultBlendModes[j], (D3D12_PRIMITIVE_TOPOLOGY_TYPE)k, defaultRTVFormats[l])) {
+                            // D3D12_CreatePipelineState will set the SDL error, if it fails
+                            result = E_FAIL;
+                            goto done;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Create default vertex buffers
+    for (i = 0; i < SDL_D3D12_NUM_VERTEX_BUFFERS; ++i) {
+        D3D12_CreateVertexBuffer(data, i, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT);
+    }
+
+    // Create samplers to use when drawing textures:
+    static struct
+    {
+        D3D12_FILTER filter;
+        D3D12_TEXTURE_ADDRESS_MODE address;
+    } samplerParams[] = {
+        { D3D12_FILTER_MIN_MAG_MIP_POINT, D3D12_TEXTURE_ADDRESS_MODE_CLAMP },
+        { D3D12_FILTER_MIN_MAG_MIP_POINT, D3D12_TEXTURE_ADDRESS_MODE_WRAP },
+        { D3D12_FILTER_MIN_MAG_MIP_LINEAR, D3D12_TEXTURE_ADDRESS_MODE_CLAMP },
+        { D3D12_FILTER_MIN_MAG_MIP_LINEAR, D3D12_TEXTURE_ADDRESS_MODE_WRAP },
+    };
+    SDL_COMPILE_TIME_ASSERT(samplerParams_SIZE, SDL_arraysize(samplerParams) == D3D12_SAMPLER_COUNT);
+    SDL_zero(samplerDesc);
+    samplerDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
+    samplerDesc.MipLODBias = 0.0f;
+    samplerDesc.MaxAnisotropy = 1;
+    samplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
+    samplerDesc.MinLOD = 0.0f;
+    samplerDesc.MaxLOD = D3D12_FLOAT32_MAX;
+    D3D_CALL_RET(data->samplerDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &data->samplers[0]);
+    for (i = 0; i < SDL_arraysize(samplerParams); ++i) {
+        samplerDesc.Filter = samplerParams[i].filter;
+        samplerDesc.AddressU = samplerParams[i].address;
+        samplerDesc.AddressV = samplerParams[i].address;
+        data->samplers[i].ptr = data->samplers[0].ptr + i * data->samplerDescriptorSize;
+        ID3D12Device1_CreateSampler(data->d3dDevice, &samplerDesc, data->samplers[i]);
+    }
+
+    // Initialize the pool allocator for SRVs
+    for (i = 0; i < SDL_D3D12_MAX_NUM_TEXTURES; ++i) {
+        data->srvPoolNodes[i].index = (SIZE_T)i;
+        if (i != SDL_D3D12_MAX_NUM_TEXTURES - 1) {
+            data->srvPoolNodes[i].next = &data->srvPoolNodes[i + 1];
+        }
+    }
+    data->srvPoolHead = &data->srvPoolNodes[0];
+
+    SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_D3D12_DEVICE_POINTER, data->d3dDevice);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_D3D12_COMMAND_QUEUE_POINTER, data->commandQueue);
+
+done:
+    D3D_SAFE_RELEASE(d3dDevice);
+    return result;
+}
+
+static DXGI_MODE_ROTATION D3D12_GetCurrentRotation(void)
+{
+    // FIXME
+    return DXGI_MODE_ROTATION_IDENTITY;
+}
+
+static BOOL D3D12_IsDisplayRotated90Degrees(DXGI_MODE_ROTATION rotation)
+{
+    switch (rotation) {
+    case DXGI_MODE_ROTATION_ROTATE90:
+    case DXGI_MODE_ROTATION_ROTATE270:
+        return TRUE;
+    default:
+        return FALSE;
+    }
+}
+
+static int D3D12_GetRotationForCurrentRenderTarget(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    if (data->textureRenderTarget) {
+        return DXGI_MODE_ROTATION_IDENTITY;
+    } else {
+        return data->rotation;
+    }
+}
+
+static bool D3D12_GetViewportAlignedD3DRect(SDL_Renderer *renderer, const SDL_Rect *sdlRect, D3D12_RECT *outRect, BOOL includeViewportOffset)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    const int rotation = D3D12_GetRotationForCurrentRenderTarget(renderer);
+    const SDL_Rect *viewport = &data->currentViewport;
+
+    switch (rotation) {
+    case DXGI_MODE_ROTATION_IDENTITY:
+        outRect->left = sdlRect->x;
+        outRect->right = (LONG)sdlRect->x + sdlRect->w;
+        outRect->top = sdlRect->y;
+        outRect->bottom = (LONG)sdlRect->y + sdlRect->h;
+        if (includeViewportOffset) {
+            outRect->left += viewport->x;
+            outRect->right += viewport->x;
+            outRect->top += viewport->y;
+            outRect->bottom += viewport->y;
+        }
+        break;
+    case DXGI_MODE_ROTATION_ROTATE270:
+        outRect->left = sdlRect->y;
+        outRect->right = (LONG)sdlRect->y + sdlRect->h;
+        outRect->top = viewport->w - sdlRect->x - sdlRect->w;
+        outRect->bottom = viewport->w - sdlRect->x;
+        break;
+    case DXGI_MODE_ROTATION_ROTATE180:
+        outRect->left = viewport->w - sdlRect->x - sdlRect->w;
+        outRect->right = viewport->w - sdlRect->x;
+        outRect->top = viewport->h - sdlRect->y - sdlRect->h;
+        outRect->bottom = viewport->h - sdlRect->y;
+        break;
+    case DXGI_MODE_ROTATION_ROTATE90:
+        outRect->left = viewport->h - sdlRect->y - sdlRect->h;
+        outRect->right = viewport->h - sdlRect->y;
+        outRect->top = sdlRect->x;
+        outRect->bottom = (LONG)sdlRect->x + sdlRect->h;
+        break;
+    default:
+        return SDL_SetError("The physical display is in an unknown or unsupported rotation");
+    }
+    return true;
+}
+
+#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+static HRESULT D3D12_CreateSwapChain(SDL_Renderer *renderer, int w, int h)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    IDXGISwapChain1 *swapChain = NULL;
+    HRESULT result = S_OK;
+
+    // Create a swap chain using the same adapter as the existing Direct3D device.
+    DXGI_SWAP_CHAIN_DESC1 swapChainDesc;
+    SDL_zero(swapChainDesc);
+    swapChainDesc.Width = w;
+    swapChainDesc.Height = h;
+    switch (renderer->output_colorspace) {
+    case SDL_COLORSPACE_SRGB_LINEAR:
+        swapChainDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        data->renderTargetFormat = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        break;
+    case SDL_COLORSPACE_HDR10:
+        swapChainDesc.Format = DXGI_FORMAT_R10G10B10A2_UNORM;
+        data->renderTargetFormat = DXGI_FORMAT_R10G10B10A2_UNORM;
+        break;
+    default:
+        swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swap chain format.
+        data->renderTargetFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
+        break;
+    }
+    swapChainDesc.Stereo = FALSE;
+    swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling.
+    swapChainDesc.SampleDesc.Quality = 0;
+    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    swapChainDesc.BufferCount = 2; // Use double-buffering to minimize latency.
+    if (WIN_IsWindows8OrGreater()) {
+        swapChainDesc.Scaling = DXGI_SCALING_NONE;
+    } else {
+        swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
+    }
+    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;               // All Windows Store apps must use this SwapEffect.
+    swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT | // To support SetMaximumFrameLatency
+                          DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;                  // To support presenting with allow tearing on
+
+    HWND hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(renderer->window), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+    if (!hwnd) {
+        SDL_SetError("Couldn't get window handle");
+        result = E_FAIL;
+        goto done;
+    }
+
+    result = IDXGIFactory2_CreateSwapChainForHwnd(data->dxgiFactory,
+                      (IUnknown *)data->commandQueue,
+                      hwnd,
+                      &swapChainDesc,
+                      NULL,
+                      NULL, // Allow on all displays.
+                      &swapChain);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGIFactory2::CreateSwapChainForHwnd"), result);
+        goto done;
+    }
+
+    IDXGIFactory6_MakeWindowAssociation(data->dxgiFactory, hwnd, DXGI_MWA_NO_WINDOW_CHANGES);
+
+    result = IDXGISwapChain1_QueryInterface(swapChain, D3D_GUID(SDL_IID_IDXGISwapChain4), (void **)&data->swapChain);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain1::QueryInterface"), result);
+        goto done;
+    }
+
+    /* Ensure that the swapchain does not queue more than one frame at a time. This both reduces latency
+     * and ensures that the application will only render after each VSync, minimizing power consumption.
+     */
+    result = IDXGISwapChain4_SetMaximumFrameLatency(data->swapChain, 1);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain4::SetMaximumFrameLatency"), result);
+        goto done;
+    }
+
+    data->swapEffect = swapChainDesc.SwapEffect;
+    data->swapFlags = swapChainDesc.Flags;
+
+    UINT colorspace_support = 0;
+    DXGI_COLOR_SPACE_TYPE colorspace;
+    switch (renderer->output_colorspace) {
+    case SDL_COLORSPACE_SRGB_LINEAR:
+        colorspace = DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709;
+        break;
+    case SDL_COLORSPACE_HDR10:
+        colorspace = DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020;
+        break;
+    default:
+        // sRGB
+        colorspace = DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
+        break;
+    }
+    if (SUCCEEDED(IDXGISwapChain3_CheckColorSpaceSupport(data->swapChain, colorspace, &colorspace_support)) &&
+        (colorspace_support & DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT)) {
+        result = IDXGISwapChain3_SetColorSpace1(data->swapChain, colorspace);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain3::SetColorSpace1"), result);
+            goto done;
+        }
+    } else {
+        // Not the default, we're not going to be able to present in this colorspace
+        SDL_SetError("Unsupported output colorspace");
+        result = DXGI_ERROR_UNSUPPORTED;
+    }
+
+    SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_D3D12_SWAPCHAIN_POINTER, data->swapChain);
+
+done:
+    D3D_SAFE_RELEASE(swapChain);
+    return result;
+}
+#endif
+
+// Initialize all resources that change when the window's size changes.
+static HRESULT D3D12_CreateWindowSizeDependentResources(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    HRESULT result = S_OK;
+    int i, w, h;
+
+    D3D12_RENDER_TARGET_VIEW_DESC rtvDesc;
+    D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor;
+
+    // Release resources in the current command list
+    D3D12_IssueBatch(data);
+    ID3D12GraphicsCommandList2_OMSetRenderTargets(data->commandList, 0, NULL, FALSE, NULL);
+
+    // Release render targets
+    for (i = 0; i < SDL_D3D12_NUM_BUFFERS; ++i) {
+        D3D_SAFE_RELEASE(data->renderTargets[i]);
+    }
+
+    /* The width and height of the swap chain must be based on the display's
+     * non-rotated size.
+     */
+    SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
+    data->rotation = D3D12_GetCurrentRotation();
+    if (D3D12_IsDisplayRotated90Degrees(data->rotation)) {
+        int tmp = w;
+        w = h;
+        h = tmp;
+    }
+
+#if !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+    if (data->swapChain) {
+        // If the swap chain already exists, resize it.
+        result = IDXGISwapChain_ResizeBuffers(data->swapChain,
+                          0,
+                          w, h,
+                          DXGI_FORMAT_UNKNOWN,
+                          data->swapFlags);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::ResizeBuffers"), result);
+            goto done;
+        }
+    } else {
+        result = D3D12_CreateSwapChain(renderer, w, h);
+        if (FAILED(result) || !data->swapChain) {
+            goto done;
+        }
+    }
+
+    // Set the proper rotation for the swap chain.
+    if (WIN_IsWindows8OrGreater()) {
+        if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
+            result = IDXGISwapChain4_SetRotation(data->swapChain, data->rotation); // NOLINT(clang-analyzer-core.NullDereference)
+            if (FAILED(result)) {
+                WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain4::SetRotation"), result);
+                goto done;
+            }
+        }
+    }
+#endif // !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+
+    // Get each back buffer render target and create render target views
+    for (i = 0; i < SDL_D3D12_NUM_BUFFERS; ++i) {
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+        result = D3D12_XBOX_CreateBackBufferTarget(data->d3dDevice, renderer->window->w, renderer->window->h, (void **)&data->renderTargets[i]);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("D3D12_XBOX_CreateBackBufferTarget"), result);
+            goto done;
+        }
+#else
+        result = IDXGISwapChain4_GetBuffer(data->swapChain, // NOLINT(clang-analyzer-core.NullDereference)
+                          i,
+                          D3D_GUID(SDL_IID_ID3D12Resource),
+                          (void **)&data->renderTargets[i]);
+        if (FAILED(result)) {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain4::GetBuffer"), result);
+            goto done;
+        }
+#endif
+
+        SDL_zero(rtvDesc);
+        rtvDesc.Format = data->renderTargetFormat;
+        rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
+
+        SDL_zero(rtvDescriptor);
+        D3D_CALL_RET(data->rtvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &rtvDescriptor);
+        rtvDescriptor.ptr += i * data->rtvDescriptorSize;
+        ID3D12Device1_CreateRenderTargetView(data->d3dDevice, data->renderTargets[i], &rtvDesc, rtvDescriptor);
+    }
+
+    // Set back buffer index to current buffer
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+    data->currentBackBufferIndex = 0;
+#else
+    data->currentBackBufferIndex = IDXGISwapChain4_GetCurrentBackBufferIndex(data->swapChain);
+#endif
+
+    /* Set the swap chain target immediately, so that a target is always set
+     * even before we get to SetDrawState. Without this it's possible to hit
+     * null references in places like ReadPixels!
+     */
+    data->currentRenderTargetView = D3D12_GetCurrentRenderTargetView(renderer);
+    ID3D12GraphicsCommandList2_OMSetRenderTargets(data->commandList, 1, &data->currentRenderTargetView, FALSE, NULL);
+    D3D12_TransitionResource(data,
+                             data->renderTargets[data->currentBackBufferIndex],
+                             D3D12_RESOURCE_STATE_PRESENT,
+                             D3D12_RESOURCE_STATE_RENDER_TARGET);
+
+    data->viewportDirty = true;
+
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+    D3D12_XBOX_StartFrame(data->d3dDevice, &data->frameToken);
+#endif
+
+done:
+    return result;
+}
+
+static bool D3D12_HandleDeviceLost(SDL_Renderer *renderer)
+{
+    bool recovered = false;
+
+    D3D12_ReleaseAll(renderer);
+
+    if (SUCCEEDED(D3D12_CreateDeviceResources(renderer)) &&
+        SUCCEEDED(D3D12_CreateWindowSizeDependentResources(renderer))) {
+        recovered = true;
+    } else {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Renderer couldn't recover from device lost: %s", SDL_GetError());
+        D3D12_ReleaseAll(renderer);
+    }
+
+    // Let the application know that the device has been reset or lost
+    SDL_Event event;
+    SDL_zero(event);
+    event.type = recovered ? SDL_EVENT_RENDER_DEVICE_RESET : SDL_EVENT_RENDER_DEVICE_LOST;
+    event.render.windowID = SDL_GetWindowID(SDL_GetRenderWindow(renderer));
+    SDL_PushEvent(&event);
+
+    return recovered;
+}
+
+// This method is called when the window's size changes.
+static HRESULT D3D12_UpdateForWindowSizeChange(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    // If the GPU has previous work, wait for it to be done first
+    D3D12_WaitForGPU(data);
+    return D3D12_CreateWindowSizeDependentResources(renderer);
+}
+
+static void D3D12_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+
+    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
+        data->pixelSizeChanged = true;
+    }
+}
+
+static bool D3D12_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (!GetBlendFunc(srcColorFactor) || !GetBlendFunc(srcAlphaFactor) ||
+        !GetBlendEquation(colorOperation) ||
+        !GetBlendFunc(dstColorFactor) || !GetBlendFunc(dstAlphaFactor) ||
+        !GetBlendEquation(alphaOperation)) {
+        return false;
+    }
+    return true;
+}
+
+static SIZE_T D3D12_GetAvailableSRVIndex(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    if (rendererData->srvPoolHead) {
+        SIZE_T index = rendererData->srvPoolHead->index;
+        rendererData->srvPoolHead = (D3D12_SRVPoolNode *)(rendererData->srvPoolHead->next);
+        return index;
+    } else {
+        SDL_SetError("[d3d12] Cannot allocate more than %d textures!", SDL_D3D12_MAX_NUM_TEXTURES);
+        return SDL_D3D12_MAX_NUM_TEXTURES + 1;
+    }
+}
+
+static void D3D12_FreeSRVIndex(SDL_Renderer *renderer, SIZE_T index)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    rendererData->srvPoolNodes[index].next = rendererData->srvPoolHead;
+    rendererData->srvPoolHead = &rendererData->srvPoolNodes[index];
+}
+
+static bool GetTextureProperty(SDL_PropertiesID props, const char *name, ID3D12Resource **texture)
+{
+    IUnknown *unknown = (IUnknown*)SDL_GetPointerProperty(props, name, NULL);
+    if (unknown) {
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+        HRESULT result = unknown->QueryInterface(D3D_GUID(SDL_IID_ID3D12Resource), (void **)texture);
+#else
+        HRESULT result = IUnknown_QueryInterface(unknown, D3D_GUID(SDL_IID_ID3D12Resource), (void **)texture);
+#endif
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(name, result);
+        }
+    }
+    return true;
+}
+
+static bool D3D12_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData;
+    HRESULT result;
+    DXGI_FORMAT textureFormat = SDLPixelFormatToDXGITextureFormat(texture->format, renderer->output_colorspace);
+    D3D12_RESOURCE_DESC textureDesc;
+    D3D12_HEAP_PROPERTIES heapProps;
+    D3D12_SHADER_RESOURCE_VIEW_DESC resourceViewDesc;
+
+    if (!rendererData->d3dDevice) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if (textureFormat == DXGI_FORMAT_UNKNOWN) {
+        return SDL_SetError("%s, An unsupported SDL pixel format (0x%x) was specified", __FUNCTION__, texture->format);
+    }
+
+    textureData = (D3D12_TextureData *)SDL_calloc(1, sizeof(*textureData));
+    if (!textureData) {
+        return false;
+    }
+    textureData->scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? D3D12_FILTER_MIN_MAG_MIP_POINT : D3D12_FILTER_MIN_MAG_MIP_LINEAR;
+
+    texture->internal = textureData;
+    textureData->mainTextureFormat = textureFormat;
+
+    SDL_zero(textureDesc);
+    textureDesc.Width = texture->w;
+    textureDesc.Height = texture->h;
+    textureDesc.MipLevels = 1;
+    textureDesc.DepthOrArraySize = 1;
+    textureDesc.Format = textureFormat;
+    textureDesc.SampleDesc.Count = 1;
+    textureDesc.SampleDesc.Quality = 0;
+    textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+    textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+    // NV12 textures must have even width and height
+    if (texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21 ||
+        texture->format == SDL_PIXELFORMAT_P010) {
+        textureDesc.Width = (textureDesc.Width + 1) & ~1;
+        textureDesc.Height = (textureDesc.Height + 1) & ~1;
+    }
+    textureData->w = (int)textureDesc.Width;
+    textureData->h = (int)textureDesc.Height;
+    if (SDL_COLORSPACETRANSFER(texture->colorspace) == SDL_TRANSFER_CHARACTERISTICS_SRGB) {
+        textureData->shader = SHADER_RGB;
+    } else {
+        textureData->shader = SHADER_ADVANCED;
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        textureDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+    }
+
+    SDL_zero(heapProps);
+    heapProps.Type = D3D12_HEAP_TYPE_DEFAULT;
+    heapProps.CreationNodeMask = 1;
+    heapProps.VisibleNodeMask = 1;
+
+    if (!GetTextureProperty(create_props, SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_POINTER, &textureData->mainTexture)) {
+        return false;
+    }
+    if (!textureData->mainTexture) {
+        result = ID3D12Device1_CreateCommittedResource(rendererData->d3dDevice,
+                          &heapProps,
+                          D3D12_HEAP_FLAG_NONE,
+                          &textureDesc,
+                          D3D12_RESOURCE_STATE_COPY_DEST,
+                          NULL,
+                          D3D_GUID(SDL_IID_ID3D12Resource),
+                          (void **)&textureData->mainTexture);
+        if (FAILED(result)) {
+            return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommittedResource [texture]"), result);
+        }
+    }
+    textureData->mainResourceState = D3D12_RESOURCE_STATE_COPY_DEST;
+    SDL_SetPointerProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_D3D12_TEXTURE_POINTER, textureData->mainTexture);
+#ifdef SDL_HAVE_YUV
+    if (texture->format == SDL_PIXELFORMAT_YV12 ||
+        texture->format == SDL_PIXELFORMAT_IYUV) {
+        textureData->yuv = true;
+
+        textureDesc.Width = (textureDesc.Width + 1) / 2;
+        textureDesc.Height = (textureDesc.Height + 1) / 2;
+
+        if (!GetTextureProperty(create_props, SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_U_POINTER, &textureData->mainTextureU)) {
+            return false;
+        }
+        if (!textureData->mainTextureU) {
+            result = ID3D12Device1_CreateCommittedResource(rendererData->d3dDevice,
+                              &heapProps,
+                              D3D12_HEAP_FLAG_NONE,
+                              &textureDesc,
+                              D3D12_RESOURCE_STATE_COPY_DEST,
+                              NULL,
+                              D3D_GUID(SDL_IID_ID3D12Resource),
+                              (void **)&textureData->mainTextureU);
+            if (FAILED(result)) {
+                return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommittedResource [texture]"), result);
+            }
+        }
+        textureData->mainResourceStateU = D3D12_RESOURCE_STATE_COPY_DEST;
+        SDL_SetPointerProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_D3D12_TEXTURE_U_POINTER, textureData->mainTextureU);
+
+        if (!GetTextureProperty(create_props, SDL_PROP_TEXTURE_CREATE_D3D12_TEXTURE_V_POINTER, &textureData->mainTextureV)) {
+            return false;
+        }
+        if (!textureData->mainTextureV) {
+            result = ID3D12Device1_CreateCommittedResource(rendererData->d3dDevice,
+                              &heapProps,
+                              D3D12_HEAP_FLAG_NONE,
+                              &textureDesc,
+                              D3D12_RESOURCE_STATE_COPY_DEST,
+                              NULL,
+                              D3D_GUID(SDL_IID_ID3D12Resource),
+                              (void **)&textureData->mainTextureV);
+            if (FAILED(result)) {
+                return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommittedResource [texture]"), result);
+            }
+        }
+        textureData->mainResourceStateV = D3D12_RESOURCE_STATE_COPY_DEST;
+        SDL_SetPointerProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_D3D12_TEXTURE_V_POINTER, textureData->mainTextureV);
+
+        textureData->YCbCr_matrix = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8);
+        if (!textureData->YCbCr_matrix) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+
+    if (texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21 ||
+        texture->format == SDL_PIXELFORMAT_P010) {
+        int bits_per_pixel;
+
+        textureData->nv12 = true;
+
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_P010:
+            bits_per_pixel = 10;
+            break;
+        default:
+            bits_per_pixel = 8;
+            break;
+        }
+        textureData->YCbCr_matrix = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, bits_per_pixel);
+        if (!textureData->YCbCr_matrix) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+#endif // SDL_HAVE_YUV
+    SDL_zero(resourceViewDesc);
+    resourceViewDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+    resourceViewDesc.Format = SDLPixelFormatToDXGIMainResourceViewFormat(texture->format, renderer->output_colorspace);
+    resourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
+    resourceViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
+
+    textureData->mainSRVIndex = D3D12_GetAvailableSRVIndex(renderer);
+    D3D_CALL_RET(rendererData->srvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &textureData->mainTextureResourceView);
+    textureData->mainTextureResourceView.ptr += textureData->mainSRVIndex * rendererData->srvDescriptorSize;
+
+    ID3D12Device1_CreateShaderResourceView(rendererData->d3dDevice,
+             textureData->mainTexture,
+             &resourceViewDesc,
+             textureData->mainTextureResourceView);
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv) {
+        D3D_CALL_RET(rendererData->srvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &textureData->mainTextureResourceViewU);
+        textureData->mainSRVIndexU = D3D12_GetAvailableSRVIndex(renderer);
+        textureData->mainTextureResourceViewU.ptr += textureData->mainSRVIndexU * rendererData->srvDescriptorSize;
+        ID3D12Device1_CreateShaderResourceView(rendererData->d3dDevice,
+                 textureData->mainTextureU,
+                 &resourceViewDesc,
+                 textureData->mainTextureResourceViewU);
+
+        D3D_CALL_RET(rendererData->srvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &textureData->mainTextureResourceViewV);
+        textureData->mainSRVIndexV = D3D12_GetAvailableSRVIndex(renderer);
+        textureData->mainTextureResourceViewV.ptr += textureData->mainSRVIndexV * rendererData->srvDescriptorSize;
+        ID3D12Device1_CreateShaderResourceView(rendererData->d3dDevice,
+                 textureData->mainTextureV,
+                 &resourceViewDesc,
+                 textureData->mainTextureResourceViewV);
+    }
+
+    if (textureData->nv12) {
+        D3D12_SHADER_RESOURCE_VIEW_DESC nvResourceViewDesc = resourceViewDesc;
+
+        if (texture->format == SDL_PIXELFORMAT_NV12 || texture->format == SDL_PIXELFORMAT_NV21) {
+            nvResourceViewDesc.Format = DXGI_FORMAT_R8G8_UNORM;
+        } else if (texture->format == SDL_PIXELFORMAT_P010) {
+            nvResourceViewDesc.Format = DXGI_FORMAT_R16G16_UNORM;
+        }
+        nvResourceViewDesc.Texture2D.PlaneSlice = 1;
+
+        D3D_CALL_RET(rendererData->srvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &textureData->mainTextureResourceViewNV);
+        textureData->mainSRVIndexNV = D3D12_GetAvailableSRVIndex(renderer);
+        textureData->mainTextureResourceViewNV.ptr += textureData->mainSRVIndexNV * rendererData->srvDescriptorSize;
+        ID3D12Device1_CreateShaderResourceView(rendererData->d3dDevice,
+                 textureData->mainTexture,
+                 &nvResourceViewDesc,
+                 textureData->mainTextureResourceViewNV);
+    }
+#endif // SDL_HAVE_YUV
+
+    if (texture->access & SDL_TEXTUREACCESS_TARGET) {
+        D3D12_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
+        SDL_zero(renderTargetViewDesc);
+        renderTargetViewDesc.Format = textureDesc.Format;
+        renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
+        renderTargetViewDesc.Texture2D.MipSlice = 0;
+
+        D3D_CALL_RET(rendererData->textureRTVDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &textureData->mainTextureRenderTargetView);
+        textureData->mainTextureRenderTargetView.ptr += textureData->mainSRVIndex * rendererData->rtvDescriptorSize;
+
+        ID3D12Device1_CreateRenderTargetView(rendererData->d3dDevice,
+                 (ID3D12Resource *)textureData->mainTexture,
+                 &renderTargetViewDesc,
+                 textureData->mainTextureRenderTargetView);
+    }
+
+    return true;
+}
+
+static void D3D12_DestroyTexture(SDL_Renderer *renderer,
+                                 SDL_Texture *texture)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+
+    /* Because SDL_DestroyTexture might be called while the data is in-flight, we need to issue the batch first
+       Unfortunately, this means that deleting a lot of textures mid-frame will have poor performance. */
+    D3D12_IssueBatch(rendererData);
+
+    D3D_SAFE_RELEASE(textureData->mainTexture);
+    D3D_SAFE_RELEASE(textureData->stagingBuffer);
+    D3D12_FreeSRVIndex(renderer, textureData->mainSRVIndex);
+#ifdef SDL_HAVE_YUV
+    D3D_SAFE_RELEASE(textureData->mainTextureU);
+    D3D_SAFE_RELEASE(textureData->mainTextureV);
+    if (textureData->yuv) {
+        D3D12_FreeSRVIndex(renderer, textureData->mainSRVIndexU);
+        D3D12_FreeSRVIndex(renderer, textureData->mainSRVIndexV);
+    }
+    if (textureData->nv12) {
+        D3D12_FreeSRVIndex(renderer, textureData->mainSRVIndexNV);
+    }
+    SDL_free(textureData->pixels);
+#endif
+    SDL_free(textureData);
+    texture->internal = NULL;
+}
+
+static bool D3D12_UpdateTextureInternal(D3D12_RenderData *rendererData, ID3D12Resource *texture, int plane, int x, int y, int w, int h, const void *pixels, int pitch, D3D12_RESOURCE_STATES *resourceState)
+{
+    const Uint8 *src;
+    Uint8 *dst;
+    UINT length;
+    HRESULT result;
+    D3D12_RESOURCE_DESC textureDesc;
+    D3D12_RESOURCE_DESC uploadDesc;
+    D3D12_HEAP_PROPERTIES heapProps;
+    D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedTextureDesc;
+    D3D12_TEXTURE_COPY_LOCATION srcLocation;
+    D3D12_TEXTURE_COPY_LOCATION dstLocation;
+    BYTE *textureMemory;
+    ID3D12Resource *uploadBuffer;
+    UINT row, NumRows, RowPitch;
+    UINT64 RowLength;
+
+    // Create an upload buffer, which will be used to write to the main texture.
+    SDL_zero(textureDesc);
+    D3D_CALL_RET(texture, GetDesc, &textureDesc);
+    textureDesc.Width = w;
+    textureDesc.Height = h;
+    if (textureDesc.Format == DXGI_FORMAT_NV12 ||
+        textureDesc.Format == DXGI_FORMAT_P010) {
+        textureDesc.Width = (textureDesc.Width + 1) & ~1;
+        textureDesc.Height = (textureDesc.Height + 1) & ~1;
+    }
+
+    SDL_zero(uploadDesc);
+    uploadDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+    uploadDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+    uploadDesc.Height = 1;
+    uploadDesc.DepthOrArraySize = 1;
+    uploadDesc.MipLevels = 1;
+    uploadDesc.Format = DXGI_FORMAT_UNKNOWN;
+    uploadDesc.SampleDesc.Count = 1;
+    uploadDesc.SampleDesc.Quality = 0;
+    uploadDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+    uploadDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+    // Figure out how much we need to allocate for the upload buffer
+    ID3D12Device1_GetCopyableFootprints(rendererData->d3dDevice,
+             &textureDesc,
+             plane,
+             1,
+             0,
+             &placedTextureDesc,
+             &NumRows,
+             &RowLength,
+             &uploadDesc.Width);
+    RowPitch = placedTextureDesc.Footprint.RowPitch;
+
+    SDL_zero(heapProps);
+    heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
+    heapProps.CreationNodeMask = 1;
+    heapProps.VisibleNodeMask = 1;
+
+    // Create the upload buffer
+    result = ID3D12Device1_CreateCommittedResource(rendererData->d3dDevice,
+                      &heapProps,
+                      D3D12_HEAP_FLAG_NONE,
+                      &uploadDesc,
+                      D3D12_RESOURCE_STATE_GENERIC_READ,
+                      NULL,
+                      D3D_GUID(SDL_IID_ID3D12Resource),
+                      (void **)&rendererData->uploadBuffers[rendererData->currentUploadBuffer]);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommittedResource [create upload buffer]"), result);
+    }
+
+    // Get a write-only pointer to data in the upload buffer:
+    uploadBuffer = rendererData->uploadBuffers[rendererData->currentUploadBuffer];
+    result = ID3D12Resource_Map(uploadBuffer,
+                      0,
+                      NULL,
+                      (void **)&textureMemory);
+    if (FAILED(result)) {
+        D3D_SAFE_RELEASE(rendererData->uploadBuffers[rendererData->currentUploadBuffer]);
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Resource::Map [map staging texture]"), result);
+    }
+
+    src = (const Uint8 *)pixels;
+    dst = textureMemory;
+    length = (UINT)RowLength;
+    if (length == (UINT)pitch && length == RowPitch) {
+        SDL_memcpy(dst, src, (size_t)length * NumRows);
+    } else {
+        if (length > (UINT)pitch) {
+            length = pitch;
+        }
+        if (length > RowPitch) {
+            length = RowPitch;
+        }
+        for (row = NumRows; row--; ) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += RowPitch;
+        }
+    }
+
+    // Commit the changes back to the upload buffer:
+    ID3D12Resource_Unmap(uploadBuffer, 0, NULL);
+
+    // Make sure the destination is in the correct resource state
+    D3D12_TransitionResource(rendererData, texture, *resourceState, D3D12_RESOURCE_STATE_COPY_DEST);
+    *resourceState = D3D12_RESOURCE_STATE_COPY_DEST;
+
+    SDL_zero(dstLocation);
+    dstLocation.pResource = texture;
+    dstLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+    dstLocation.SubresourceIndex = plane;
+
+    SDL_zero(srcLocation);
+    srcLocation.pResource = rendererData->uploadBuffers[rendererData->currentUploadBuffer];
+    srcLocation.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+    srcLocation.PlacedFootprint = placedTextureDesc;
+
+    ID3D12GraphicsCommandList2_CopyTextureRegion(rendererData->commandList,
+             &dstLocation,
+             x,
+             y,
+             0,
+             &srcLocation,
+             NULL);
+
+    // Transition the texture to be shader accessible
+    D3D12_TransitionResource(rendererData, texture, *resourceState, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+    *resourceState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+
+    rendererData->currentUploadBuffer++;
+    // If we've used up all the upload buffers, we need to issue the batch
+    if (rendererData->currentUploadBuffer == SDL_D3D12_NUM_UPLOAD_BUFFERS) {
+        D3D12_IssueBatch(rendererData);
+    }
+
+    return true;
+}
+
+static bool D3D12_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                               const SDL_Rect *rect, const void *srcPixels,
+                               int srcPitch)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTexture, 0, rect->x, rect->y, rect->w, rect->h, srcPixels, srcPitch, &textureData->mainResourceState)) {
+        return false;
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv) {
+        // Skip to the correct offset into the next texture
+        srcPixels = (const void *)((const Uint8 *)srcPixels + rect->h * srcPitch);
+
+        if (!D3D12_UpdateTextureInternal(rendererData, texture->format == SDL_PIXELFORMAT_YV12 ? textureData->mainTextureV : textureData->mainTextureU, 0, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, srcPixels, (srcPitch + 1) / 2, texture->format == SDL_PIXELFORMAT_YV12 ? &textureData->mainResourceStateV : &textureData->mainResourceStateU)) {
+            return false;
+        }
+
+        // Skip to the correct offset into the next texture
+        srcPixels = (const void *)((const Uint8 *)srcPixels + ((rect->h + 1) / 2) * ((srcPitch + 1) / 2));
+        if (!D3D12_UpdateTextureInternal(rendererData, texture->format == SDL_PIXELFORMAT_YV12 ? textureData->mainTextureU : textureData->mainTextureV, 0, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, srcPixels, (srcPitch + 1) / 2, texture->format == SDL_PIXELFORMAT_YV12 ? &textureData->mainResourceStateU : &textureData->mainResourceStateV)) {
+            return false;
+        }
+    }
+
+    if (textureData->nv12) {
+        // Skip to the correct offset into the next texture
+        srcPixels = (const void *)((const Uint8 *)srcPixels + rect->h * srcPitch);
+
+        if (texture->format == SDL_PIXELFORMAT_P010) {
+            srcPitch = (srcPitch + 3) & ~3;
+        } else {
+            srcPitch = (srcPitch + 1) & ~1;
+        }
+        if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTexture, 1, rect->x, rect->y, (rect->w + 1) & ~1, (rect->h + 1) & ~1, srcPixels, srcPitch, &textureData->mainResourceState)) {
+            return false;
+        }
+    }
+#endif // SDL_HAVE_YUV
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool D3D12_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTexture, 0, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch, &textureData->mainResourceState)) {
+        return false;
+    }
+    if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTextureU, 0, rect->x / 2, rect->y / 2, rect->w / 2, rect->h / 2, Uplane, Upitch, &textureData->mainResourceStateU)) {
+        return false;
+    }
+    if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTextureV, 0, rect->x / 2, rect->y / 2, rect->w / 2, rect->h / 2, Vplane, Vpitch, &textureData->mainResourceStateV)) {
+        return false;
+    }
+    return true;
+}
+
+static bool D3D12_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                 const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTexture, 0, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch, &textureData->mainResourceState)) {
+        return false;
+    }
+
+    if (!D3D12_UpdateTextureInternal(rendererData, textureData->mainTexture, 1, rect->x, rect->y, rect->w, rect->h, UVplane, UVpitch, &textureData->mainResourceState)) {
+        return false;
+    }
+    return true;
+}
+#endif
+
+static bool D3D12_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+    HRESULT result = S_OK;
+
+    D3D12_RESOURCE_DESC textureDesc;
+    D3D12_RESOURCE_DESC uploadDesc;
+    D3D12_HEAP_PROPERTIES heapProps;
+    D3D12_SUBRESOURCE_FOOTPRINT pitchedDesc;
+    BYTE *textureMemory;
+    int bpp;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv || textureData->nv12) {
+        // It's more efficient to upload directly...
+        if (!textureData->pixels) {
+            textureData->pitch = texture->w;
+            textureData->pixels = (Uint8 *)SDL_malloc((texture->h * textureData->pitch * 3) / 2);
+            if (!textureData->pixels) {
+                return false;
+            }
+        }
+        textureData->lockedRect = *rect;
+        *pixels =
+            (void *)(textureData->pixels + rect->y * textureData->pitch +
+                     rect->x * SDL_BYTESPERPIXEL(texture->format));
+        *pitch = textureData->pitch;
+        return true;
+    }
+#endif
+    if (textureData->stagingBuffer) {
+        return SDL_SetError("texture is already locked");
+    }
+
+    // Create an upload buffer, which will be used to write to the main texture.
+    SDL_zero(textureDesc);
+    D3D_CALL_RET(textureData->mainTexture, GetDesc, &textureDesc);
+    textureDesc.Width = rect->w;
+    textureDesc.Height = rect->h;
+
+    SDL_zero(uploadDesc);
+    uploadDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+    uploadDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+    uploadDesc.Height = 1;
+    uploadDesc.DepthOrArraySize = 1;
+    uploadDesc.MipLevels = 1;
+    uploadDesc.Format = DXGI_FORMAT_UNKNOWN;
+    uploadDesc.SampleDesc.Count = 1;
+    uploadDesc.SampleDesc.Quality = 0;
+    uploadDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+    uploadDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+    // Figure out how much we need to allocate for the upload buffer
+    ID3D12Device1_GetCopyableFootprints(rendererData->d3dDevice,
+             &textureDesc,
+             0,
+             1,
+             0,
+             NULL,
+             NULL,
+             NULL,
+             &uploadDesc.Width);
+
+    SDL_zero(heapProps);
+    heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
+    heapProps.CreationNodeMask = 1;
+    heapProps.VisibleNodeMask = 1;
+
+    // Create the upload buffer
+    result = ID3D12Device1_CreateCommittedResource(rendererData->d3dDevice,
+                      &heapProps,
+                      D3D12_HEAP_FLAG_NONE,
+                      &uploadDesc,
+                      D3D12_RESOURCE_STATE_GENERIC_READ,
+                      NULL,
+                      D3D_GUID(SDL_IID_ID3D12Resource),
+                      (void **)&textureData->stagingBuffer);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateCommittedResource [create upload buffer]"), result);
+    }
+
+    // Get a write-only pointer to data in the upload buffer:
+    result = ID3D12Resource_Map(textureData->stagingBuffer,
+                      0,
+                      NULL,
+                      (void **)&textureMemory);
+    if (FAILED(result)) {
+        D3D_SAFE_RELEASE(rendererData->uploadBuffers[rendererData->currentUploadBuffer]);
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Resource::Map [map staging texture]"), result);
+    }
+
+    SDL_zero(pitchedDesc);
+    pitchedDesc.Format = textureDesc.Format;
+    pitchedDesc.Width = rect->w;
+    pitchedDesc.Height = rect->h;
+    pitchedDesc.Depth = 1;
+    if (pitchedDesc.Format == DXGI_FORMAT_R8_UNORM) {
+        bpp = 1;
+    } else {
+        bpp = 4;
+    }
+    pitchedDesc.RowPitch = D3D12_Align(rect->w * bpp, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+
+    /* Make note of where the staging texture will be written to
+     * (on a call to SDL_UnlockTexture):
+     */
+    textureData->lockedRect = *rect;
+
+    /* Make sure the caller has information on the texture's pixel buffer,
+     * then return:
+     */
+    *pixels = textureMemory;
+    *pitch = pitchedDesc.RowPitch;
+    return true;
+}
+
+static void D3D12_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+    D3D12_RESOURCE_DESC textureDesc;
+    D3D12_SUBRESOURCE_FOOTPRINT pitchedDesc;
+    D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedTextureDesc;
+    D3D12_TEXTURE_COPY_LOCATION srcLocation;
+    D3D12_TEXTURE_COPY_LOCATION dstLocation;
+    int bpp;
+
+    if (!textureData) {
+        return;
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv || textureData->nv12) {
+        const SDL_Rect *rect = &textureData->lockedRect;
+        void *pixels =
+            (void *)(textureData->pixels + rect->y * textureData->pitch +
+                     rect->x * SDL_BYTESPERPIXEL(texture->format));
+        D3D12_UpdateTexture(renderer, texture, rect, pixels, textureData->pitch);
+        return;
+    }
+#endif
+    // Commit the pixel buffer's changes back to the staging texture:
+    ID3D12Resource_Unmap(textureData->stagingBuffer, 0, NULL);
+
+    SDL_zero(textureDesc);
+    D3D_CALL_RET(textureData->mainTexture, GetDesc, &textureDesc);
+    textureDesc.Width = textureData->lockedRect.w;
+    textureDesc.Height = textureData->lockedRect.h;
+
+    SDL_zero(pitchedDesc);
+    pitchedDesc.Format = textureDesc.Format;
+    pitchedDesc.Width = (UINT)textureDesc.Width;
+    pitchedDesc.Height = textureDesc.Height;
+    pitchedDesc.Depth = 1;
+    if (pitchedDesc.Format == DXGI_FORMAT_R8_UNORM) {
+        bpp = 1;
+    } else {
+        bpp = 4;
+    }
+    pitchedDesc.RowPitch = D3D12_Align(textureData->lockedRect.w * bpp, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+
+    SDL_zero(placedTextureDesc);
+    placedTextureDesc.Offset = 0;
+    placedTextureDesc.Footprint = pitchedDesc;
+
+    D3D12_TransitionResource(rendererData, textureData->mainTexture, textureData->mainResourceState, D3D12_RESOURCE_STATE_COPY_DEST);
+    textureData->mainResourceState = D3D12_RESOURCE_STATE_COPY_DEST;
+
+    SDL_zero(dstLocation);
+    dstLocation.pResource = textureData->mainTexture;
+    dstLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+    dstLocation.SubresourceIndex = 0;
+
+    SDL_zero(srcLocation);
+    srcLocation.pResource = textureData->stagingBuffer;
+    srcLocation.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+    srcLocation.PlacedFootprint = placedTextureDesc;
+
+    ID3D12GraphicsCommandList2_CopyTextureRegion(rendererData->commandList,
+             &dstLocation,
+             textureData->lockedRect.x,
+             textureData->lockedRect.y,
+             0,
+             &srcLocation,
+             NULL);
+
+    // Transition the texture to be shader accessible
+    D3D12_TransitionResource(rendererData, textureData->mainTexture, textureData->mainResourceState, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+    textureData->mainResourceState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+
+    // Execute the command list before releasing the staging buffer
+    D3D12_IssueBatch(rendererData);
+    D3D_SAFE_RELEASE(textureData->stagingBuffer);
+}
+
+static void D3D12_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+
+    textureData->scaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? D3D12_FILTER_MIN_MAG_MIP_POINT : D3D12_FILTER_MIN_MAG_MIP_LINEAR;
+}
+
+static bool D3D12_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = NULL;
+
+    if (!texture) {
+        if (rendererData->textureRenderTarget) {
+            D3D12_TransitionResource(rendererData,
+                                     rendererData->textureRenderTarget->mainTexture,
+                                     rendererData->textureRenderTarget->mainResourceState,
+                                     D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+            rendererData->textureRenderTarget->mainResourceState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+        }
+        rendererData->textureRenderTarget = NULL;
+        return true;
+    }
+
+    textureData = (D3D12_TextureData *)texture->internal;
+
+    if (!textureData->mainTextureRenderTargetView.ptr) {
+        return SDL_SetError("specified texture is not a render target");
+    }
+
+    rendererData->textureRenderTarget = textureData;
+    D3D12_TransitionResource(rendererData,
+                             rendererData->textureRenderTarget->mainTexture,
+                             rendererData->textureRenderTarget->mainResourceState,
+                             D3D12_RESOURCE_STATE_RENDER_TARGET);
+    rendererData->textureRenderTarget->mainResourceState = D3D12_RESOURCE_STATE_RENDER_TARGET;
+
+    return true;
+}
+
+static bool D3D12_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool D3D12_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    D3D12_VertexPositionColor *verts = (D3D12_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(D3D12_VertexPositionColor), 0, &cmd->data.draw.first);
+    int i;
+    SDL_FColor color = cmd->data.draw.color;
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    if (convert_color) {
+        SDL_ConvertToLinear(&color);
+    }
+
+    for (i = 0; i < count; i++) {
+        verts->pos.x = points[i].x + 0.5f;
+        verts->pos.y = points[i].y + 0.5f;
+        verts->tex.x = 0.0f;
+        verts->tex.y = 0.0f;
+        verts->color = color;
+        verts++;
+    }
+
+    return true;
+}
+
+static bool D3D12_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                               const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                               int num_vertices, const void *indices, int num_indices, int size_indices,
+                               float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    D3D12_VertexPositionColor *verts = (D3D12_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(D3D12_VertexPositionColor), 0, &cmd->data.draw.first);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+    D3D12_TextureData *textureData = texture ? (D3D12_TextureData *)texture->internal : NULL;
+    float u_scale = textureData ? (float)texture->w / textureData->w : 0.0f;
+    float v_scale = textureData ? (float)texture->h / textureData->h : 0.0f;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+
+        verts->pos.x = xy_[0] * scale_x;
+        verts->pos.y = xy_[1] * scale_y;
+        verts->color = *(SDL_FColor *)((char *)color + j * color_stride);
+        if (convert_color) {
+            SDL_ConvertToLinear(&verts->color);
+        }
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            verts->tex.x = uv_[0] * u_scale;
+            verts->tex.y = uv_[1] * v_scale;
+        } else {
+            verts->tex.x = 0.0f;
+            verts->tex.y = 0.0f;
+        }
+
+        verts += 1;
+    }
+    return true;
+}
+
+static bool D3D12_UpdateVertexBuffer(SDL_Renderer *renderer,
+                                    const void *vertexData, size_t dataSizeInBytes)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    HRESULT result = S_OK;
+    const int vbidx = rendererData->currentVertexBuffer;
+    UINT8 *vertexBufferData = NULL;
+    D3D12_RANGE range;
+    ID3D12Resource *vertexBuffer;
+
+    range.Begin = 0;
+    range.End = 0;
+
+    if (dataSizeInBytes == 0) {
+        return true; // nothing to do.
+    }
+
+    if (rendererData->issueBatch) {
+        if (FAILED(D3D12_IssueBatch(rendererData))) {
+            return SDL_SetError("Failed to issue intermediate batch");
+        }
+    }
+
+    // If the existing vertex buffer isn't big enough, we need to recreate a big enough one
+    if (dataSizeInBytes > rendererData->vertexBuffers[vbidx].size) {
+        D3D12_CreateVertexBuffer(rendererData, vbidx, dataSizeInBytes);
+    }
+
+    vertexBuffer = rendererData->vertexBuffers[vbidx].resource;
+    result = ID3D12Resource_Map(vertexBuffer, 0, &range, (void **)&vertexBufferData);
+    if (FAILED(result)) {
+        return WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Resource::Map [vertex buffer]"), result);
+    }
+    SDL_memcpy(vertexBufferData, vertexData, dataSizeInBytes);
+    ID3D12Resource_Unmap(vertexBuffer, 0, NULL);
+
+    rendererData->vertexBuffers[vbidx].view.SizeInBytes = (UINT)dataSizeInBytes;
+
+    ID3D12GraphicsCommandList2_IASetVertexBuffers(rendererData->commandList, 0, 1, &rendererData->vertexBuffers[vbidx].view);
+
+    rendererData->currentVertexBuffer++;
+    if (rendererData->currentVertexBuffer >= SDL_D3D12_NUM_VERTEX_BUFFERS) {
+        rendererData->currentVertexBuffer = 0;
+        rendererData->issueBatch = true;
+    }
+
+    return true;
+}
+
+static bool D3D12_UpdateViewport(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    const SDL_Rect *viewport = &data->currentViewport;
+    Float4X4 projection;
+    Float4X4 view;
+    SDL_FRect orientationAlignedViewport;
+    BOOL swapDimensions;
+    D3D12_VIEWPORT d3dviewport;
+    const int rotation = D3D12_GetRotationForCurrentRenderTarget(renderer);
+
+    if (viewport->w == 0 || viewport->h == 0) {
+        /* If the viewport is empty, assume that it is because
+         * SDL_CreateRenderer is calling it, and will call it again later
+         * with a non-empty viewport.
+         */
+        // SDL_Log("%s, no viewport was set!", __FUNCTION__);
+        return false;
+    }
+
+    /* Make sure the SDL viewport gets rotated to that of the physical display's rotation.
+     * Keep in mind here that the Y-axis will be been inverted (from Direct3D's
+     * default coordinate system) so rotations will be done in the opposite
+     * direction of the DXGI_MODE_ROTATION enumeration.
+     */
+    switch (rotation) {
+    case DXGI_MODE_ROTATION_IDENTITY:
+        projection = MatrixIdentity();
+        break;
+    case DXGI_MODE_ROTATION_ROTATE270:
+        projection = MatrixRotationZ(SDL_PI_F * 0.5f);
+        break;
+    case DXGI_MODE_ROTATION_ROTATE180:
+        projection = MatrixRotationZ(SDL_PI_F);
+        break;
+    case DXGI_MODE_ROTATION_ROTATE90:
+        projection = MatrixRotationZ(-SDL_PI_F * 0.5f);
+        break;
+    default:
+        return SDL_SetError("An unknown DisplayOrientation is being used");
+    }
+
+    // Update the view matrix
+    SDL_zero(view);
+    view.m[0][0] = 2.0f / viewport->w;
+    view.m[1][1] = -2.0f / viewport->h;
+    view.m[2][2] = 1.0f;
+    view.m[3][0] = -1.0f;
+    view.m[3][1] = 1.0f;
+    view.m[3][3] = 1.0f;
+
+    /* Combine the projection + view matrix together now, as both only get
+     * set here (as of this writing, on Dec 26, 2013).  When done, store it
+     * for eventual transfer to the GPU.
+     */
+    data->vertexShaderConstantsData.projectionAndView = MatrixMultiply(
+        view,
+        projection);
+
+    /* Update the Direct3D viewport, which seems to be aligned to the
+     * swap buffer's coordinate space, which is always in either
+     * a landscape mode, for all Windows 8/RT devices, or a portrait mode,
+     * for Windows Phone devices.
+     */
+    swapDimensions = D3D12_IsDisplayRotated90Degrees((DXGI_MODE_ROTATION)rotation);
+    if (swapDimensions) {
+        orientationAlignedViewport.x = (float)viewport->y;
+        orientationAlignedViewport.y = (float)viewport->x;
+        orientationAlignedViewport.w = (float)viewport->h;
+        orientationAlignedViewport.h = (float)viewport->w;
+    } else {
+        orientationAlignedViewport.x = (float)viewport->x;
+        orientationAlignedViewport.y = (float)viewport->y;
+        orientationAlignedViewport.w = (float)viewport->w;
+        orientationAlignedViewport.h = (float)viewport->h;
+    }
+
+    d3dviewport.TopLeftX = orientationAlignedViewport.x;
+    d3dviewport.TopLeftY = orientationAlignedViewport.y;
+    d3dviewport.Width = orientationAlignedViewport.w;
+    d3dviewport.Height = orientationAlignedViewport.h;
+    d3dviewport.MinDepth = 0.0f;
+    d3dviewport.MaxDepth = 1.0f;
+    // SDL_Log("%s: D3D viewport = {%f,%f,%f,%f}", __FUNCTION__, d3dviewport.TopLeftX, d3dviewport.TopLeftY, d3dviewport.Width, d3dviewport.Height);
+    ID3D12GraphicsCommandList_RSSetViewports(data->commandList, 1, &d3dviewport);
+
+    data->viewportDirty = false;
+
+    return true;
+}
+
+static void D3D12_SetupShaderConstants(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Texture *texture, D3D12_PixelShaderConstants *constants)
+{
+    float output_headroom;
+
+    SDL_zerop(constants);
+
+    constants->scRGB_output = (float)SDL_RenderingLinearSpace(renderer);
+    constants->color_scale = cmd->data.draw.color_scale;
+
+    if (texture) {
+        D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_YV12:
+        case SDL_PIXELFORMAT_IYUV:
+            constants->texture_type = TEXTURETYPE_YUV;
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_NV12:
+            constants->texture_type = TEXTURETYPE_NV12;
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_NV21:
+            constants->texture_type = TEXTURETYPE_NV21;
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_P010:
+            constants->texture_type = TEXTURETYPE_NV12;
+            constants->input_type = INPUTTYPE_HDR10;
+            break;
+        default:
+            constants->texture_type = TEXTURETYPE_RGB;
+            if (texture->colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+                constants->input_type = INPUTTYPE_SCRGB;
+            } else if (texture->colorspace == SDL_COLORSPACE_HDR10) {
+                constants->input_type = INPUTTYPE_HDR10;
+            } else {
+                // The sampler will convert from sRGB to linear on load if working in linear colorspace
+                constants->input_type = INPUTTYPE_UNSPECIFIED;
+            }
+            break;
+        }
+
+        constants->sdr_white_point = texture->SDR_white_point;
+
+        if (renderer->target) {
+            output_headroom = renderer->target->HDR_headroom;
+        } else {
+            output_headroom = renderer->HDR_headroom;
+        }
+
+        if (texture->HDR_headroom > output_headroom) {
+            constants->tonemap_method = TONEMAP_CHROME;
+            constants->tonemap_factor1 = (output_headroom / (texture->HDR_headroom * texture->HDR_headroom));
+            constants->tonemap_factor2 = (1.0f / output_headroom);
+        }
+
+        if (textureData->YCbCr_matrix) {
+            SDL_memcpy(constants->YCbCr_matrix, textureData->YCbCr_matrix, sizeof(constants->YCbCr_matrix));
+        }
+    }
+}
+
+static bool D3D12_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, D3D12_Shader shader, const D3D12_PixelShaderConstants *shader_constants,
+                              D3D12_PRIMITIVE_TOPOLOGY_TYPE topology,
+                              const int numShaderResources, D3D12_CPU_DESCRIPTOR_HANDLE *shaderResources,
+                              D3D12_CPU_DESCRIPTOR_HANDLE *sampler, const Float4X4 *matrix)
+
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
+    D3D12_CPU_DESCRIPTOR_HANDLE renderTargetView = D3D12_GetCurrentRenderTargetView(renderer);
+    const SDL_BlendMode blendMode = cmd->data.draw.blend;
+    bool updateSubresource = false;
+    int i;
+    D3D12_CPU_DESCRIPTOR_HANDLE firstShaderResource;
+    DXGI_FORMAT rtvFormat = rendererData->renderTargetFormat;
+    D3D12_PipelineState *currentPipelineState = rendererData->currentPipelineState;;
+    D3D12_PixelShaderConstants solid_constants;
+
+    if (rendererData->textureRenderTarget) {
+        rtvFormat = rendererData->textureRenderTarget->mainTextureFormat;
+    }
+
+    // See if we need to change the pipeline state
+    if (!currentPipelineState ||
+        currentPipelineState->shader != shader ||
+        currentPipelineState->blendMode != blendMode ||
+        currentPipelineState->topology != topology ||
+        currentPipelineState->rtvFormat != rtvFormat) {
+
+        /* Find the matching pipeline.
+           NOTE: Although it may seem inefficient to linearly search through ~450 pipelines
+           to find the correct one, in profiling this doesn't come up at all.
+           It's unlikely that using a hash table would affect performance a measurable amount unless
+           it's a degenerate case that's changing the pipeline state dozens of times per frame.
+        */
+        currentPipelineState = NULL;
+        for (i = 0; i < rendererData->pipelineStateCount; ++i) {
+            D3D12_PipelineState *candidatePiplineState = &rendererData->pipelineStates[i];
+            if (candidatePiplineState->shader == shader &&
+                candidatePiplineState->blendMode == blendMode &&
+                candidatePiplineState->topology == topology &&
+                candidatePiplineState->rtvFormat == rtvFormat) {
+                currentPipelineState = candidatePiplineState;
+                break;
+            }
+        }
+
+        // If we didn't find a match, create a new one -- it must mean the blend mode is non-standard
+        if (!currentPipelineState) {
+            currentPipelineState = D3D12_CreatePipelineState(renderer, shader, blendMode, topology, rtvFormat);
+        }
+
+        if (!currentPipelineState) {
+            // The error has been set inside D3D12_CreatePipelineState()
+            return false;
+        }
+
+        ID3D12GraphicsCommandList2_SetPipelineState(rendererData->commandList, currentPipelineState->pipelineState);
+        ID3D12GraphicsCommandList2_SetGraphicsRootSignature(rendererData->commandList,
+                 rendererData->rootSignatures[D3D12_GetRootSignatureType(currentPipelineState->shader)]);
+        // When we change these we will need to re-upload the constant buffer and reset any descriptors
+        updateSubresource = true;
+        rendererData->currentSampler.ptr = 0;
+        rendererData->currentShaderResource.ptr = 0;
+        rendererData->currentPipelineState = currentPipelineState;
+    }
+
+    if (renderTargetView.ptr != rendererData->currentRenderTargetView.ptr) {
+        ID3D12GraphicsCommandList2_OMSetRenderTargets(rendererData->commandList, 1, &renderTargetView, FALSE, NULL);
+        rendererData->currentRenderTargetView = renderTargetView;
+    }
+
+    if (rendererData->viewportDirty) {
+        if (D3D12_UpdateViewport(renderer)) {
+            // vertexShaderConstantsData.projectionAndView has changed
+            updateSubresource = true;
+        }
+    }
+
+    if (rendererData->cliprectDirty) {
+        D3D12_RECT scissorRect;
+        if (!D3D12_GetViewportAlignedD3DRect(renderer, &rendererData->currentCliprect, &scissorRect, TRUE)) {
+            // D3D12_GetViewportAlignedD3DRect will have set the SDL error
+            return false;
+        }
+        ID3D12GraphicsCommandList2_RSSetScissorRects(rendererData->commandList, 1, &scissorRect);
+        rendererData->cliprectDirty = false;
+    }
+
+    if (numShaderResources > 0) {
+        firstShaderResource = shaderResources[0];
+    } else {
+        firstShaderResource.ptr = 0;
+    }
+    if (firstShaderResource.ptr != rendererData->currentShaderResource.ptr) {
+        for (i = 0; i < numShaderResources; ++i) {
+            D3D12_GPU_DESCRIPTOR_HANDLE GPUHandle = D3D12_CPUtoGPUHandle(rendererData->srvDescriptorHeap, shaderResources[i]);
+            ID3D12GraphicsCommandList2_SetGraphicsRootDescriptorTable(rendererData->commandList, i + 2, GPUHandle);
+        }
+        rendererData->currentShaderResource.ptr = firstShaderResource.ptr;
+    }
+
+    if (sampler && sampler->ptr != rendererData->currentSampler.ptr) {
+        D3D12_GPU_DESCRIPTOR_HANDLE GPUHandle = D3D12_CPUtoGPUHandle(rendererData->samplerDescriptorHeap, *sampler);
+        UINT tableIndex = 0;
+
+        // Figure out the correct sampler descriptor table index based on the type of shader
+        switch (shader) {
+        case SHADER_RGB:
+            tableIndex = 3;
+            break;
+        case SHADER_ADVANCED:
+            tableIndex = 5;
+            break;
+        default:
+            return SDL_SetError("[direct3d12] Trying to set a sampler for a shader which doesn't have one");
+            break;
+        }
+
+        ID3D12GraphicsCommandList2_SetGraphicsRootDescriptorTable(rendererData->commandList, tableIndex, GPUHandle);
+        rendererData->currentSampler = *sampler;
+    }
+
+    if (updateSubresource == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
+        SDL_memcpy(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix));
+        ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(rendererData->commandList,
+                 0,
+                 32,
+                 &rendererData->vertexShaderConstantsData,
+                 0);
+    }
+
+    if (!shader_constants) {
+        D3D12_SetupShaderConstants(renderer, cmd, NULL, &solid_constants);
+        shader_constants = &solid_constants;
+    }
+
+    if (updateSubresource == true ||
+        SDL_memcmp(shader_constants, &currentPipelineState->shader_constants, sizeof(*shader_constants)) != 0) {
+        ID3D12GraphicsCommandList2_SetGraphicsRoot32BitConstants(rendererData->commandList,
+                 1,
+                 sizeof(*shader_constants) / sizeof(float),
+                 shader_constants,
+                 0);
+
+        SDL_memcpy(&currentPipelineState->shader_constants, shader_constants, sizeof(*shader_constants));
+    }
+
+    return true;
+}
+
+static bool D3D12_SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const Float4X4 *matrix)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    D3D12_TextureData *textureData = (D3D12_TextureData *)texture->internal;
+    D3D12_CPU_DESCRIPTOR_HANDLE *textureSampler;
+    D3D12_PixelShaderConstants constants;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    D3D12_SetupShaderConstants(renderer, cmd, texture, &constants);
+
+    switch (textureData->scaleMode) {
+    case D3D12_FILTER_MIN_MAG_MIP_POINT:
+        switch (cmd->data.draw.texture_address_mode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            textureSampler = &rendererData->samplers[D3D12_SAMPLER_NEAREST_CLAMP];
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            textureSampler = &rendererData->samplers[D3D12_SAMPLER_NEAREST_WRAP];
+            break;
+        default:
+            return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+        }
+        break;
+    case D3D12_FILTER_MIN_MAG_MIP_LINEAR:
+        switch (cmd->data.draw.texture_address_mode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            textureSampler = &rendererData->samplers[D3D12_SAMPLER_LINEAR_CLAMP];
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            textureSampler = &rendererData->samplers[D3D12_SAMPLER_LINEAR_WRAP];
+            break;
+        default:
+            return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+        }
+        break;
+    default:
+        return SDL_SetError("Unknown scale mode: %d", textureData->scaleMode);
+    }
+#ifdef SDL_HAVE_YUV
+    if (textureData->yuv) {
+        D3D12_CPU_DESCRIPTOR_HANDLE shaderResources[3];
+
+        shaderResources[0] = textureData->mainTextureResourceView;
+        shaderResources[1] = textureData->mainTextureResourceViewU;
+        shaderResources[2] = textureData->mainTextureResourceViewV;
+
+        // Make sure each texture is in the correct state to be accessed by the pixel shader.
+        D3D12_TransitionResource(rendererData, textureData->mainTexture, textureData->mainResourceState, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+        textureData->mainResourceState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+        D3D12_TransitionResource(rendererData, textureData->mainTextureU, textureData->mainResourceStateU, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+        textureData->mainResourceStateU = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+        D3D12_TransitionResource(rendererData, textureData->mainTextureV, textureData->mainResourceStateV, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+        textureData->mainResourceStateV = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+
+        return D3D12_SetDrawState(renderer, cmd, textureData->shader, &constants, D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
+    } else if (textureData->nv12) {
+        D3D12_CPU_DESCRIPTOR_HANDLE shaderResources[2];
+
+        shaderResources[0] = textureData->mainTextureResourceView;
+        shaderResources[1] = textureData->mainTextureResourceViewNV;
+
+        // Make sure each texture is in the correct state to be accessed by the pixel shader.
+        D3D12_TransitionResource(rendererData, textureData->mainTexture, textureData->mainResourceState, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+        textureData->mainResourceState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+
+        return D3D12_SetDrawState(renderer, cmd, textureData->shader, &constants, D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, SDL_arraysize(shaderResources), shaderResources, textureSampler, matrix);
+    }
+#endif // SDL_HAVE_YUV
+    D3D12_TransitionResource(rendererData, textureData->mainTexture, textureData->mainResourceState, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
+    textureData->mainResourceState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+    return D3D12_SetDrawState(renderer, cmd, textureData->shader, &constants, D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, 1, &textureData->mainTextureResourceView, textureSampler, matrix);
+}
+
+static void D3D12_DrawPrimitives(SDL_Renderer *renderer, D3D12_PRIMITIVE_TOPOLOGY primitiveTopology, const size_t vertexStart, const size_t vertexCount)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    ID3D12GraphicsCommandList2_IASetPrimitiveTopology(rendererData->commandList, primitiveTopology);
+    ID3D12GraphicsCommandList2_DrawInstanced(rendererData->commandList, (UINT)vertexCount, 1, (UINT)vertexStart, 0);
+}
+
+static void D3D12_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    data->currentRenderTargetView.ptr = 0;
+    data->currentShaderResource.ptr = 0;
+    data->currentSampler.ptr = 0;
+    data->cliprectDirty = true;
+    data->viewportDirty = true;
+}
+
+static bool D3D12_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    D3D12_RenderData *rendererData = (D3D12_RenderData *)renderer->internal;
+    const int viewportRotation = D3D12_GetRotationForCurrentRenderTarget(renderer);
+
+    if (!rendererData->d3dDevice) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if (rendererData->pixelSizeChanged) {
+        D3D12_UpdateForWindowSizeChange(renderer);
+        rendererData->pixelSizeChanged = false;
+    }
+
+    if (rendererData->currentViewportRotation != viewportRotation) {
+        rendererData->currentViewportRotation = viewportRotation;
+        rendererData->viewportDirty = true;
+    }
+
+    if (!D3D12_UpdateVertexBuffer(renderer, vertices, vertsize)) {
+        return false;
+    }
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            break; // this isn't currently used in this render backend.
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &rendererData->currentViewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                rendererData->viewportDirty = true;
+                rendererData->cliprectDirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            SDL_Rect viewport_cliprect;
+            if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
+                rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
+                rendererData->cliprectDirty = true;
+            }
+            if (!rendererData->currentCliprectEnabled) {
+                /* If the clip rect is disabled, then the scissor rect should be the whole viewport,
+                   since direct3d12 doesn't allow disabling the scissor rectangle */
+                viewport_cliprect.x = 0;
+                viewport_cliprect.y = 0;
+                viewport_cliprect.w = rendererData->currentViewport.w;
+                viewport_cliprect.h = rendererData->currentViewport.h;
+                rect = &viewport_cliprect;
+            }
+            if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&rendererData->currentCliprect, rect);
+                rendererData->cliprectDirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = D3D12_GetCurrentRenderTargetView(renderer);
+            bool convert_color = SDL_RenderingLinearSpace(renderer);
+            SDL_FColor color = cmd->data.color.color;
+            if (convert_color) {
+                SDL_ConvertToLinear(&color);
+            }
+            color.r *= cmd->data.color.color_scale;
+            color.g *= cmd->data.color.color_scale;
+            color.b *= cmd->data.color.color_scale;
+            ID3D12GraphicsCommandList2_ClearRenderTargetView(rendererData->commandList, rtvDescriptor, &color.r, 0, NULL);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(D3D12_VertexPositionColor);
+            D3D12_SetDrawState(renderer, cmd, SHADER_SOLID, NULL, D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT, 0, NULL, NULL, NULL);
+            D3D12_DrawPrimitives(renderer, D3D_PRIMITIVE_TOPOLOGY_POINTLIST, start, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(D3D12_VertexPositionColor);
+            const D3D12_VertexPositionColor *verts = (D3D12_VertexPositionColor *)(((Uint8 *)vertices) + first);
+            D3D12_SetDrawState(renderer, cmd, SHADER_SOLID, NULL, D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE, 0, NULL, NULL, NULL);
+            D3D12_DrawPrimitives(renderer, D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, start, count);
+            if (verts[0].pos.x != verts[count - 1].pos.x || verts[0].pos.y != verts[count - 1].pos.y) {
+                D3D12_DrawPrimitives(renderer, D3D_PRIMITIVE_TOPOLOGY_POINTLIST, start + (count - 1), 1);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            SDL_Texture *texture = cmd->data.draw.texture;
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(D3D12_VertexPositionColor);
+
+            if (texture) {
+                D3D12_SetCopyState(renderer, cmd, NULL);
+            } else {
+                D3D12_SetDrawState(renderer, cmd, SHADER_SOLID, NULL, D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, 0, NULL, NULL, NULL);
+            }
+
+            D3D12_DrawPrimitives(renderer, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, start, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    return true;
+}
+
+static SDL_Surface *D3D12_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    ID3D12Resource *backBuffer = NULL;
+    ID3D12Resource *readbackBuffer = NULL;
+    HRESULT result;
+    D3D12_RESOURCE_DESC textureDesc;
+    D3D12_RESOURCE_DESC readbackDesc;
+    D3D12_HEAP_PROPERTIES heapProps;
+    D3D12_RECT srcRect = { 0, 0, 0, 0 };
+    D3D12_BOX srcBox;
+    D3D12_TEXTURE_COPY_LOCATION dstLocation;
+    D3D12_TEXTURE_COPY_LOCATION srcLocation;
+    D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedTextureDesc;
+    D3D12_SUBRESOURCE_FOOTPRINT pitchedDesc;
+    BYTE *textureMemory;
+    int bpp;
+    SDL_Surface *output = NULL;
+
+    if (data->textureRenderTarget) {
+        backBuffer = data->textureRenderTarget->mainTexture;
+    } else {
+        backBuffer = data->renderTargets[data->currentBackBufferIndex];
+    }
+
+    // Create a staging texture to copy the screen's data to:
+    SDL_zero(textureDesc);
+    D3D_CALL_RET(backBuffer, GetDesc, &textureDesc);
+    textureDesc.Width = rect->w;
+    textureDesc.Height = rect->h;
+
+    SDL_zero(readbackDesc);
+    readbackDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+    readbackDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
+    readbackDesc.Height = 1;
+    readbackDesc.DepthOrArraySize = 1;
+    readbackDesc.MipLevels = 1;
+    readbackDesc.Format = DXGI_FORMAT_UNKNOWN;
+    readbackDesc.SampleDesc.Count = 1;
+    readbackDesc.SampleDesc.Quality = 0;
+    readbackDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+    readbackDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+
+    // Figure out how much we need to allocate for the upload buffer
+    ID3D12Device1_GetCopyableFootprints(data->d3dDevice,
+             &textureDesc,
+             0,
+             1,
+             0,
+             NULL,
+             NULL,
+             NULL,
+             &readbackDesc.Width);
+
+    SDL_zero(heapProps);
+    heapProps.Type = D3D12_HEAP_TYPE_READBACK;
+    heapProps.CreationNodeMask = 1;
+    heapProps.VisibleNodeMask = 1;
+
+    result = ID3D12Device1_CreateCommittedResource(data->d3dDevice,
+                      &heapProps,
+                      D3D12_HEAP_FLAG_NONE,
+                      &readbackDesc,
+                      D3D12_RESOURCE_STATE_COPY_DEST,
+                      NULL,
+                      D3D_GUID(SDL_IID_ID3D12Resource),
+                      (void **)&readbackBuffer);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateTexture2D [create staging texture]"), result);
+        goto done;
+    }
+
+    // Transition the render target to be copyable from
+    D3D12_TransitionResource(data, backBuffer, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE);
+
+    // Copy the desired portion of the back buffer to the staging texture:
+    if (!D3D12_GetViewportAlignedD3DRect(renderer, rect, &srcRect, FALSE)) {
+        // D3D12_GetViewportAlignedD3DRect will have set the SDL error
+        goto done;
+    }
+    srcBox.left = srcRect.left;
+    srcBox.right = srcRect.right;
+    srcBox.top = srcRect.top;
+    srcBox.bottom = srcRect.bottom;
+    srcBox.front = 0;
+    srcBox.back = 1;
+
+    // Issue the copy texture region
+    SDL_zero(pitchedDesc);
+    pitchedDesc.Format = textureDesc.Format;
+    pitchedDesc.Width = (UINT)textureDesc.Width;
+    pitchedDesc.Height = textureDesc.Height;
+    pitchedDesc.Depth = 1;
+    bpp = SDL_BYTESPERPIXEL(D3D12_DXGIFormatToSDLPixelFormat(pitchedDesc.Format));
+    pitchedDesc.RowPitch = D3D12_Align(pitchedDesc.Width * bpp, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+
+    SDL_zero(placedTextureDesc);
+    placedTextureDesc.Offset = 0;
+    placedTextureDesc.Footprint = pitchedDesc;
+
+    SDL_zero(dstLocation);
+    dstLocation.pResource = readbackBuffer;
+    dstLocation.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+    dstLocation.PlacedFootprint = placedTextureDesc;
+
+    SDL_zero(srcLocation);
+    srcLocation.pResource = backBuffer;
+    srcLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+    srcLocation.SubresourceIndex = 0;
+
+    ID3D12GraphicsCommandList2_CopyTextureRegion(data->commandList,
+             &dstLocation,
+             0, 0, 0,
+             &srcLocation,
+             &srcBox);
+
+    // We need to issue the command list for the copy to finish
+    D3D12_IssueBatch(data);
+
+    // Transition the render target back to a render target
+    D3D12_TransitionResource(data, backBuffer, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET);
+
+    // Map the staging texture's data to CPU-accessible memory:
+    result = ID3D12Resource_Map(readbackBuffer,
+                      0,
+                      NULL,
+                      (void **)&textureMemory);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Resource::Map [map staging texture]"), result);
+        goto done;
+    }
+
+    output = SDL_DuplicatePixels(
+        rect->w, rect->h,
+        D3D12_DXGIFormatToSDLPixelFormat(textureDesc.Format),
+        renderer->target ? renderer->target->colorspace : renderer->output_colorspace,
+        textureMemory,
+        pitchedDesc.RowPitch);
+
+    // Unmap the texture:
+    ID3D12Resource_Unmap(readbackBuffer, 0, NULL);
+
+done:
+    D3D_SAFE_RELEASE(readbackBuffer);
+    return output;
+}
+
+static bool D3D12_RenderPresent(SDL_Renderer *renderer)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+    HRESULT result;
+
+    if (!data->d3dDevice) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    // Transition the render target to present state
+    D3D12_TransitionResource(data,
+                             data->renderTargets[data->currentBackBufferIndex],
+                             D3D12_RESOURCE_STATE_RENDER_TARGET,
+                             D3D12_RESOURCE_STATE_PRESENT);
+
+    // Issue the command list
+    result = ID3D12GraphicsCommandList2_Close(data->commandList);
+    ID3D12CommandQueue_ExecuteCommandLists(data->commandQueue, 1, (ID3D12CommandList *const *)&data->commandList);
+
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+    result = D3D12_XBOX_PresentFrame(data->commandQueue, data->frameToken, data->renderTargets[data->currentBackBufferIndex]);
+#else
+    /* The application may optionally specify "dirty" or "scroll"
+     * rects to improve efficiency in certain scenarios.
+     */
+    result = IDXGISwapChain_Present(data->swapChain, data->syncInterval, data->presentFlags);
+#endif
+
+    if (FAILED(result) && result != DXGI_ERROR_WAS_STILL_DRAWING) {
+        /* If the device was removed either by a disconnect or a driver upgrade, we
+         * must recreate all device resources.
+         */
+        if (result == DXGI_ERROR_DEVICE_REMOVED) {
+            if (D3D12_HandleDeviceLost(renderer)) {
+                SDL_SetError("Present failed, device lost");
+            } else {
+                // Recovering from device lost failed, error is already set
+            }
+        } else if (result == DXGI_ERROR_INVALID_CALL) {
+            // We probably went through a fullscreen <-> windowed transition
+            D3D12_CreateWindowSizeDependentResources(renderer);
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::Present"), result);
+        } else {
+            WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain::Present"), result);
+        }
+        return false;
+    } else {
+        // Wait for the GPU and move to the next frame
+        result = ID3D12CommandQueue_Signal(data->commandQueue, data->fence, data->fenceValue);
+
+        if (ID3D12Fence_GetCompletedValue(data->fence) < data->fenceValue) {
+            result = ID3D12Fence_SetEventOnCompletion(data->fence,
+                              data->fenceValue,
+                              data->fenceEvent);
+            WaitForSingleObjectEx(data->fenceEvent, INFINITE, FALSE);
+        }
+
+        data->fenceValue++;
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+        data->currentBackBufferIndex++;
+        data->currentBackBufferIndex %= SDL_D3D12_NUM_BUFFERS;
+#else
+        data->currentBackBufferIndex = IDXGISwapChain4_GetCurrentBackBufferIndex(data->swapChain);
+#endif
+
+        // Reset the command allocator and command list, and transition back to render target
+        D3D12_ResetCommandList(data);
+        D3D12_TransitionResource(data,
+                                 data->renderTargets[data->currentBackBufferIndex],
+                                 D3D12_RESOURCE_STATE_PRESENT,
+                                 D3D12_RESOURCE_STATE_RENDER_TARGET);
+
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+        D3D12_XBOX_StartFrame(data->d3dDevice, &data->frameToken);
+#endif
+        return true;
+    }
+}
+
+static bool D3D12_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    D3D12_RenderData *data = (D3D12_RenderData *)renderer->internal;
+
+    if (vsync < 0) {
+        return SDL_Unsupported();
+    }
+
+    if (vsync > 0) {
+        data->syncInterval = vsync;
+        data->presentFlags = 0;
+    } else {
+        data->syncInterval = 0;
+        data->presentFlags = DXGI_PRESENT_ALLOW_TEARING;
+    }
+    return true;
+}
+
+bool D3D12_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    D3D12_RenderData *data;
+
+    HWND hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+    if (!hwnd) {
+        return SDL_SetError("Couldn't get window handle");
+    }
+
+    if (SDL_GetWindowFlags(window) & SDL_WINDOW_TRANSPARENT) {
+                // D3D12 removed the swap effect needed to support transparent windows, use D3D11 instead
+                return SDL_SetError("The direct3d12 renderer doesn't work with transparent windows");
+        }
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB &&
+        renderer->output_colorspace != SDL_COLORSPACE_SRGB_LINEAR
+        /*&& renderer->output_colorspace != SDL_COLORSPACE_HDR10*/) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (D3D12_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    data->identity = MatrixIdentity();
+
+    renderer->WindowEvent = D3D12_WindowEvent;
+    renderer->SupportsBlendMode = D3D12_SupportsBlendMode;
+    renderer->CreateTexture = D3D12_CreateTexture;
+    renderer->UpdateTexture = D3D12_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = D3D12_UpdateTextureYUV;
+    renderer->UpdateTextureNV = D3D12_UpdateTextureNV;
+#endif
+    renderer->LockTexture = D3D12_LockTexture;
+    renderer->UnlockTexture = D3D12_UnlockTexture;
+    renderer->SetTextureScaleMode = D3D12_SetTextureScaleMode;
+    renderer->SetRenderTarget = D3D12_SetRenderTarget;
+    renderer->QueueSetViewport = D3D12_QueueNoOp;
+    renderer->QueueSetDrawColor = D3D12_QueueNoOp;
+    renderer->QueueDrawPoints = D3D12_QueueDrawPoints;
+    renderer->QueueDrawLines = D3D12_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueGeometry = D3D12_QueueGeometry;
+    renderer->InvalidateCachedState = D3D12_InvalidateCachedState;
+    renderer->RunCommandQueue = D3D12_RunCommandQueue;
+    renderer->RenderReadPixels = D3D12_RenderReadPixels;
+    renderer->RenderPresent = D3D12_RenderPresent;
+    renderer->DestroyTexture = D3D12_DestroyTexture;
+    renderer->DestroyRenderer = D3D12_DestroyRenderer;
+    renderer->SetVSync = D3D12_SetVSync;
+    renderer->internal = data;
+    D3D12_InvalidateCachedState(renderer);
+
+    renderer->name = D3D12_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR2101010);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA64_FLOAT);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_P010);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
+
+    data->syncInterval = 0;
+    data->presentFlags = DXGI_PRESENT_ALLOW_TEARING;
+
+    /* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
+     * order to give init functions access to the underlying window handle:
+     */
+    renderer->window = window;
+
+    // Initialize Direct3D resources
+    if (FAILED(D3D12_CreateDeviceResources(renderer))) {
+        return false;
+    }
+    if (FAILED(D3D12_CreateWindowSizeDependentResources(renderer))) {
+        return false;
+    }
+
+    return true;
+}
+
+SDL_RenderDriver D3D12_RenderDriver = {
+    D3D12_CreateRenderer, "direct3d12"
+};
+
+// Ends C function definitions when using C++
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SDL_VIDEO_RENDER_D3D12
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12_xbox.cpp b/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12_xbox.cpp
new file mode 100644
index 0000000..2ea3cf1
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12_xbox.cpp
@@ -0,0 +1,174 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "../../SDL_internal.h"
+#if defined(SDL_VIDEO_RENDER_D3D12) && (defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES))
+#include "SDL_render_d3d12_xbox.h"
+#include "../../core/windows/SDL_windows.h"
+#include <XGameRuntime.h>
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SDL_COMPOSE_ERROR(str) __FUNCTION__ ", " str
+#else
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+#endif
+
+static const GUID SDL_IID_ID3D12Device1 = { 0x77acce80, 0x638e, 0x4e65, { 0x88, 0x95, 0xc1, 0xf2, 0x33, 0x86, 0x86, 0x3e } };
+static const GUID SDL_IID_ID3D12Resource = { 0x696442be, 0xa72e, 0x4059, { 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad } };
+static const GUID SDL_IID_IDXGIDevice1 = { 0x77db970f, 0x6276, 0x48ba, { 0xba, 0x28, 0x07, 0x01, 0x43, 0xb4, 0x39, 0x2c } };
+
+extern "C"
+HRESULT D3D12_XBOX_CreateDevice(ID3D12Device **device, bool createDebug)
+{
+    HRESULT result;
+    D3D12XBOX_CREATE_DEVICE_PARAMETERS params;
+    IDXGIDevice1 *dxgiDevice;
+    IDXGIAdapter *dxgiAdapter;
+    IDXGIOutput *dxgiOutput;
+    SDL_zero(params);
+
+    params.Version = D3D12_SDK_VERSION;
+    params.ProcessDebugFlags = createDebug ? D3D12_PROCESS_DEBUG_FLAG_DEBUG_LAYER_ENABLED : D3D12XBOX_PROCESS_DEBUG_FLAG_NONE;
+    params.GraphicsCommandQueueRingSizeBytes = D3D12XBOX_DEFAULT_SIZE_BYTES;
+    params.GraphicsScratchMemorySizeBytes = D3D12XBOX_DEFAULT_SIZE_BYTES;
+    params.ComputeScratchMemorySizeBytes = D3D12XBOX_DEFAULT_SIZE_BYTES;
+
+    result = D3D12XboxCreateDevice(NULL, &params, SDL_IID_ID3D12Device1, (void **) device);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("[xbox] D3D12XboxCreateDevice"), result);
+        goto done;
+    }
+
+    result = (*device)->QueryInterface(SDL_IID_IDXGIDevice1, (void **) &dxgiDevice);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("[xbox] ID3D12Device to IDXGIDevice1"), result);
+        goto done;
+    }
+
+    result = dxgiDevice->GetAdapter(&dxgiAdapter);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("[xbox] dxgiDevice->GetAdapter"), result);
+        goto done;
+    }
+
+    result = dxgiAdapter->EnumOutputs(0, &dxgiOutput);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("[xbox] dxgiAdapter->EnumOutputs"), result);
+        goto done;
+    }
+
+    // Set frame interval
+    result = (*device)->SetFrameIntervalX(dxgiOutput, D3D12XBOX_FRAME_INTERVAL_60_HZ, 1, D3D12XBOX_FRAME_INTERVAL_FLAG_NONE);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("[xbox] SetFrameIntervalX"), result);
+        goto done;
+    }
+
+    result = (*device)->ScheduleFrameEventX(D3D12XBOX_FRAME_EVENT_ORIGIN, 0, NULL, D3D12XBOX_SCHEDULE_FRAME_EVENT_FLAG_NONE);
+    if (FAILED(result)) {
+        WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("[xbox] ScheduleFrameEventX"), result);
+        goto done;
+    }
+
+done:
+    return result;
+}
+
+extern "C"
+HRESULT D3D12_XBOX_CreateBackBufferTarget(ID3D12Device1 *device, int width, int height, void **resource)
+{
+
+    D3D12_HEAP_PROPERTIES heapProps;
+    D3D12_RESOURCE_DESC resourceDesc;
+
+    SDL_zero(heapProps);
+    heapProps.Type = D3D12_HEAP_TYPE_DEFAULT;
+    heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
+    heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
+    heapProps.CreationNodeMask = 1;
+    heapProps.VisibleNodeMask = 1;
+
+    SDL_zero(resourceDesc);
+    resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+    resourceDesc.Alignment = 0;
+    resourceDesc.Width = width;
+    resourceDesc.Height = height;
+    resourceDesc.DepthOrArraySize = 1;
+    resourceDesc.MipLevels = 1;
+    resourceDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+    resourceDesc.SampleDesc.Count = 1;
+    resourceDesc.SampleDesc.Quality = 0;
+    resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+    resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+
+    return device->CreateCommittedResource(&heapProps,
+        D3D12_HEAP_FLAG_ALLOW_DISPLAY,
+        &resourceDesc,
+        D3D12_RESOURCE_STATE_PRESENT,
+        NULL,
+        SDL_IID_ID3D12Resource,
+        resource
+        );
+}
+
+extern "C"
+HRESULT D3D12_XBOX_StartFrame(ID3D12Device1 *device, UINT64 *outToken)
+{
+    *outToken = D3D12XBOX_FRAME_PIPELINE_TOKEN_NULL;
+    return device->WaitFrameEventX(D3D12XBOX_FRAME_EVENT_ORIGIN, INFINITE, NULL, D3D12XBOX_WAIT_FRAME_EVENT_FLAG_NONE, outToken);
+}
+
+extern "C"
+HRESULT D3D12_XBOX_PresentFrame(ID3D12CommandQueue *commandQueue, UINT64 token, ID3D12Resource *renderTarget)
+{
+    D3D12XBOX_PRESENT_PLANE_PARAMETERS planeParameters;
+    SDL_zero(planeParameters);
+    planeParameters.Token = token;
+    planeParameters.ResourceCount = 1;
+    planeParameters.ppResources = &renderTarget;
+    return commandQueue->PresentX(1, &planeParameters, NULL);
+}
+
+extern "C"
+void D3D12_XBOX_GetResolution(Uint32 *width, Uint32 *height)
+{
+    switch (XSystemGetDeviceType()) {
+    case XSystemDeviceType::XboxScarlettLockhart:
+        *width = 2560;
+        *height = 1440;
+        break;
+
+    case XSystemDeviceType::XboxOneX:
+    case XSystemDeviceType::XboxScarlettAnaconda:
+    case XSystemDeviceType::XboxOneXDevkit:
+    case XSystemDeviceType::XboxScarlettDevkit:
+        *width = 3840;
+        *height = 2160;
+        break;
+
+    default:
+        *width = 1920;
+        *height = 1080;
+        break;
+    }
+}
+
+#endif // SDL_VIDEO_RENDER_D3D12 && (SDL_PLATFORM_XBOXONE || SDL_PLATFORM_XBOXSERIES)
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12_xbox.h b/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12_xbox.h
new file mode 100644
index 0000000..947148e
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_render_d3d12_xbox.h
@@ -0,0 +1,44 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_render_d3d12_xbox_h_
+#define SDL_render_d3d12_xbox_h_
+
+#include "../../SDL_internal.h"
+#include "../../video/directx/SDL_d3d12.h"
+
+// Set up for C function definitions, even when using C++
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern HRESULT D3D12_XBOX_CreateDevice(ID3D12Device **device, bool createDebug);
+extern HRESULT D3D12_XBOX_CreateBackBufferTarget(ID3D12Device1 *device, int width, int height, void **resource);
+extern HRESULT D3D12_XBOX_StartFrame(ID3D12Device1 *device, UINT64 *outToken);
+extern HRESULT D3D12_XBOX_PresentFrame(ID3D12CommandQueue *commandQueue, UINT64 token, ID3D12Resource *renderTarget);
+extern void D3D12_XBOX_GetResolution(Uint32 *width, Uint32 *height);
+
+// Ends C function definitions when using C++
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12.c b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12.c
new file mode 100644
index 0000000..8d06db0
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12.c
@@ -0,0 +1,125 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#if defined(SDL_VIDEO_RENDER_D3D12) && !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES)
+
+#include "../../core/windows/SDL_windows.h"
+#include "../../video/directx/SDL_d3d12.h"
+
+#include "SDL_shaders_d3d12.h"
+
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+
+// The shaders here were compiled with compile_shaders.bat
+
+#define g_main D3D12_PixelShader_Colors
+#include "D3D12_PixelShader_Colors.h"
+#undef g_main
+
+#define g_main D3D12_PixelShader_Textures
+#include "D3D12_PixelShader_Textures.h"
+#undef g_main
+
+#define g_main D3D12_PixelShader_Advanced
+#include "D3D12_PixelShader_Advanced.h"
+#undef g_main
+
+
+#define g_mainColor D3D12_VertexShader_Colors
+#include "D3D12_VertexShader_Color.h"
+#undef g_mainColor
+
+#define g_mainTexture D3D12_VertexShader_Textures
+#include "D3D12_VertexShader_Texture.h"
+#undef g_mainTexture
+
+#define g_mainAdvanced D3D12_VertexShader_Advanced
+#include "D3D12_VertexShader_Advanced.h"
+#undef g_mainAdvanced
+
+
+#define g_ColorRS D3D12_RootSig_Color
+#include "D3D12_RootSig_Color.h"
+#undef g_ColorRS
+
+#define g_TextureRS D3D12_RootSig_Texture
+#include "D3D12_RootSig_Texture.h"
+#undef g_TextureRS
+
+#define g_AdvancedRS D3D12_RootSig_Advanced
+#include "D3D12_RootSig_Advanced.h"
+#undef g_AdvancedRS
+
+
+static struct
+{
+    const void *ps_shader_data;
+    SIZE_T ps_shader_size;
+    const void *vs_shader_data;
+    SIZE_T vs_shader_size;
+    D3D12_RootSignature root_sig;
+} D3D12_shaders[NUM_SHADERS] = {
+    { D3D12_PixelShader_Colors, sizeof(D3D12_PixelShader_Colors),
+      D3D12_VertexShader_Colors, sizeof(D3D12_VertexShader_Colors),
+      ROOTSIG_COLOR },
+    { D3D12_PixelShader_Textures, sizeof(D3D12_PixelShader_Textures),
+      D3D12_VertexShader_Textures, sizeof(D3D12_VertexShader_Textures),
+      ROOTSIG_TEXTURE },
+    { D3D12_PixelShader_Advanced, sizeof(D3D12_PixelShader_Advanced),
+      D3D12_VertexShader_Advanced, sizeof(D3D12_VertexShader_Advanced),
+      ROOTSIG_ADVANCED },
+};
+
+static struct
+{
+    const void *rs_shader_data;
+    SIZE_T rs_shader_size;
+} D3D12_rootsigs[NUM_ROOTSIGS] = {
+    { D3D12_RootSig_Color, sizeof(D3D12_RootSig_Color) },
+    { D3D12_RootSig_Texture, sizeof(D3D12_RootSig_Texture) },
+    { D3D12_RootSig_Advanced, sizeof(D3D12_RootSig_Advanced) },
+};
+
+void D3D12_GetVertexShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_shaders[shader].vs_shader_data;
+    outBytecode->BytecodeLength = D3D12_shaders[shader].vs_shader_size;
+}
+
+void D3D12_GetPixelShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_shaders[shader].ps_shader_data;
+    outBytecode->BytecodeLength = D3D12_shaders[shader].ps_shader_size;
+}
+
+D3D12_RootSignature D3D12_GetRootSignatureType(D3D12_Shader shader)
+{
+    return D3D12_shaders[shader].root_sig;
+}
+
+void D3D12_GetRootSignatureData(D3D12_RootSignature rootSig, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_rootsigs[rootSig].rs_shader_data;
+    outBytecode->BytecodeLength = D3D12_rootsigs[rootSig].rs_shader_size;
+}
+
+#endif // SDL_VIDEO_RENDER_D3D12 && !SDL_PLATFORM_XBOXONE && !SDL_PLATFORM_XBOXSERIES
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12.h b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12.h
new file mode 100644
index 0000000..0250b97
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12.h
@@ -0,0 +1,54 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// D3D12 shader implementation
+
+// Set up for C function definitions, even when using C++
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum
+{
+    SHADER_SOLID,
+    SHADER_RGB,
+    SHADER_ADVANCED,
+    NUM_SHADERS
+} D3D12_Shader;
+
+typedef enum
+{
+    ROOTSIG_COLOR,
+    ROOTSIG_TEXTURE,
+    ROOTSIG_ADVANCED,
+    NUM_ROOTSIGS
+} D3D12_RootSignature;
+
+extern void D3D12_GetVertexShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode);
+extern void D3D12_GetPixelShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode);
+extern D3D12_RootSignature D3D12_GetRootSignatureType(D3D12_Shader shader);
+extern void D3D12_GetRootSignatureData(D3D12_RootSignature rootSig, D3D12_SHADER_BYTECODE *outBytecode);
+
+// Ends C function definitions when using C++
+#ifdef __cplusplus
+}
+#endif
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12_xboxone.cpp b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12_xboxone.cpp
new file mode 100644
index 0000000..bc6146b
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12_xboxone.cpp
@@ -0,0 +1,132 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if defined(SDL_VIDEO_RENDER_D3D12) && defined(SDL_PLATFORM_XBOXONE)
+
+#include <SDL3/SDL_stdinc.h>
+
+#include "../../core/windows/SDL_windows.h"
+#include "../../video/directx/SDL_d3d12.h"
+
+#include "SDL_shaders_d3d12.h"
+
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+
+// Shader blob headers are generated with a pre-build step using compile_shaders_xbox.bat
+
+#define g_main D3D12_PixelShader_Colors
+#include "D3D12_PixelShader_Colors_One.h"
+#undef g_main
+
+#define g_main D3D12_PixelShader_Textures
+#include "D3D12_PixelShader_Textures_One.h"
+#undef g_main
+
+#define g_main D3D12_PixelShader_Advanced
+#include "D3D12_PixelShader_Advanced_One.h"
+#undef g_main
+
+
+#define g_mainColor D3D12_VertexShader_Colors
+#include "D3D12_VertexShader_Color_One.h"
+#undef g_mainColor
+
+#define g_mainTexture D3D12_VertexShader_Textures
+#include "D3D12_VertexShader_Texture_One.h"
+#undef g_mainTexture
+
+#define g_mainAdvanced D3D12_VertexShader_Advanced
+#include "D3D12_VertexShader_Advanced_One.h"
+#undef g_mainAdvanced
+
+
+#define g_ColorRS D3D12_RootSig_Color
+#include "D3D12_RootSig_Color_One.h"
+#undef g_ColorRS
+
+#define g_TextureRS D3D12_RootSig_Texture
+#include "D3D12_RootSig_Texture_One.h"
+#undef g_TextureRS
+
+#define g_AdvancedRS D3D12_RootSig_Advanced
+#include "D3D12_RootSig_Advanced_One.h"
+#undef g_AdvancedRS
+
+
+static struct
+{
+    const void *ps_shader_data;
+    SIZE_T ps_shader_size;
+    const void *vs_shader_data;
+    SIZE_T vs_shader_size;
+    D3D12_RootSignature root_sig;
+} D3D12_shaders[NUM_SHADERS] = {
+    { D3D12_PixelShader_Colors, sizeof(D3D12_PixelShader_Colors),
+      D3D12_VertexShader_Colors, sizeof(D3D12_VertexShader_Colors),
+      ROOTSIG_COLOR },
+    { D3D12_PixelShader_Textures, sizeof(D3D12_PixelShader_Textures),
+      D3D12_VertexShader_Textures, sizeof(D3D12_VertexShader_Textures),
+      ROOTSIG_TEXTURE },
+    { D3D12_PixelShader_Advanced, sizeof(D3D12_PixelShader_Advanced),
+      D3D12_VertexShader_Advanced, sizeof(D3D12_VertexShader_Advanced),
+      ROOTSIG_ADVANCED },
+};
+
+static struct
+{
+    const void *rs_shader_data;
+    SIZE_T rs_shader_size;
+} D3D12_rootsigs[NUM_ROOTSIGS] = {
+    { D3D12_RootSig_Color, sizeof(D3D12_RootSig_Color) },
+    { D3D12_RootSig_Texture, sizeof(D3D12_RootSig_Texture) },
+    { D3D12_RootSig_Advanced, sizeof(D3D12_RootSig_Advanced) },
+};
+
+extern "C"
+void D3D12_GetVertexShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_shaders[shader].vs_shader_data;
+    outBytecode->BytecodeLength = D3D12_shaders[shader].vs_shader_size;
+}
+
+extern "C"
+void D3D12_GetPixelShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_shaders[shader].ps_shader_data;
+    outBytecode->BytecodeLength = D3D12_shaders[shader].ps_shader_size;
+}
+
+extern "C"
+D3D12_RootSignature D3D12_GetRootSignatureType(D3D12_Shader shader)
+{
+    return D3D12_shaders[shader].root_sig;
+}
+
+extern "C"
+void D3D12_GetRootSignatureData(D3D12_RootSignature rootSig, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_rootsigs[rootSig].rs_shader_data;
+    outBytecode->BytecodeLength = D3D12_rootsigs[rootSig].rs_shader_size;
+}
+
+#endif  // SDL_VIDEO_RENDER_D3D12 && SDL_PLATFORM_XBOXONE
+
diff --git a/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12_xboxseries.cpp b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12_xboxseries.cpp
new file mode 100644
index 0000000..6c1c037
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/SDL_shaders_d3d12_xboxseries.cpp
@@ -0,0 +1,133 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if defined(SDL_VIDEO_RENDER_D3D12) && defined(SDL_PLATFORM_XBOXSERIES)
+
+#include <SDL3/SDL_stdinc.h>
+
+#include "../../core/windows/SDL_windows.h"
+#include "../../video/directx/SDL_d3d12.h"
+
+#include "SDL_shaders_d3d12.h"
+
+#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
+
+
+// Shader blob headers are generated with a pre-build step using compile_shaders_xbox.bat
+
+#define g_main D3D12_PixelShader_Colors
+#include "D3D12_PixelShader_Colors_Series.h"
+#undef g_main
+
+#define g_main D3D12_PixelShader_Textures
+#include "D3D12_PixelShader_Textures_Series.h"
+#undef g_main
+
+#define g_main D3D12_PixelShader_Advanced
+#include "D3D12_PixelShader_Advanced_Series.h"
+#undef g_main
+
+
+#define g_mainColor D3D12_VertexShader_Colors
+#include "D3D12_VertexShader_Color_Series.h"
+#undef g_mainColor
+
+#define g_mainTexture D3D12_VertexShader_Textures
+#include "D3D12_VertexShader_Texture_Series.h"
+#undef g_mainTexture
+
+#define g_mainAdvanced D3D12_VertexShader_Advanced
+#include "D3D12_VertexShader_Advanced_Series.h"
+#undef g_mainAdvanced
+
+
+#define g_ColorRS D3D12_RootSig_Color
+#include "D3D12_RootSig_Color_Series.h"
+#undef g_ColorRS
+
+#define g_TextureRS D3D12_RootSig_Texture
+#include "D3D12_RootSig_Texture_Series.h"
+#undef g_TextureRS
+
+#define g_AdvancedRS D3D12_RootSig_Advanced
+#include "D3D12_RootSig_Advanced_Series.h"
+#undef g_AdvancedRS
+
+
+static struct
+{
+    const void *ps_shader_data;
+    SIZE_T ps_shader_size;
+    const void *vs_shader_data;
+    SIZE_T vs_shader_size;
+    D3D12_RootSignature root_sig;
+} D3D12_shaders[NUM_SHADERS] = {
+    { D3D12_PixelShader_Colors, sizeof(D3D12_PixelShader_Colors),
+      D3D12_VertexShader_Colors, sizeof(D3D12_VertexShader_Colors),
+      ROOTSIG_COLOR },
+    { D3D12_PixelShader_Textures, sizeof(D3D12_PixelShader_Textures),
+      D3D12_VertexShader_Textures, sizeof(D3D12_VertexShader_Textures),
+      ROOTSIG_TEXTURE },
+    { D3D12_PixelShader_Advanced, sizeof(D3D12_PixelShader_Advanced),
+      D3D12_VertexShader_Advanced, sizeof(D3D12_VertexShader_Advanced),
+      ROOTSIG_ADVANCED },
+};
+
+static struct
+{
+    const void *rs_shader_data;
+    SIZE_T rs_shader_size;
+} D3D12_rootsigs[NUM_ROOTSIGS] = {
+    { D3D12_RootSig_Color, sizeof(D3D12_RootSig_Color) },
+    { D3D12_RootSig_Texture, sizeof(D3D12_RootSig_Texture) },
+    { D3D12_RootSig_Advanced, sizeof(D3D12_RootSig_Advanced) },
+};
+
+extern "C"
+void D3D12_GetVertexShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_shaders[shader].vs_shader_data;
+    outBytecode->BytecodeLength = D3D12_shaders[shader].vs_shader_size;
+}
+
+extern "C"
+void D3D12_GetPixelShader(D3D12_Shader shader, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_shaders[shader].ps_shader_data;
+    outBytecode->BytecodeLength = D3D12_shaders[shader].ps_shader_size;
+}
+
+extern "C"
+D3D12_RootSignature D3D12_GetRootSignatureType(D3D12_Shader shader)
+{
+    return D3D12_shaders[shader].root_sig;
+}
+
+extern "C"
+void D3D12_GetRootSignatureData(D3D12_RootSignature rootSig, D3D12_SHADER_BYTECODE *outBytecode)
+{
+    outBytecode->pShaderBytecode = D3D12_rootsigs[rootSig].rs_shader_data;
+    outBytecode->BytecodeLength = D3D12_rootsigs[rootSig].rs_shader_size;
+}
+
+#endif // SDL_VIDEO_RENDER_D3D12 && SDL_PLATFORM_XBOXSERIES
+
diff --git a/SDL-3.2.8/src/render/direct3d12/compile_shaders.bat b/SDL-3.2.8/src/render/direct3d12/compile_shaders.bat
new file mode 100644
index 0000000..699fdf3
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/compile_shaders.bat
@@ -0,0 +1,21 @@
+rem This script runs for the Windows build, but also via the _xbox variant with these vars set.

+rem Make sure to default to building for Windows if they're not set.

+if %DXC%.==. set DXC=dxc

+if %SUFFIX%.==. set SUFFIX=.h

+

+echo Building with %DXC%

+echo Suffix %SUFFIX%

+

+cd "%~dp0"

+

+%DXC% -E main -T ps_6_0 -Fh D3D12_PixelShader_Colors%SUFFIX% D3D12_PixelShader_Colors.hlsl

+%DXC% -E main -T ps_6_0 -Fh D3D12_PixelShader_Textures%SUFFIX% D3D12_PixelShader_Textures.hlsl

+%DXC% -E main -T ps_6_0 -Fh D3D12_PixelShader_Advanced%SUFFIX% D3D12_PixelShader_Advanced.hlsl

+

+%DXC% -E mainColor -T vs_6_0 -Fh D3D12_VertexShader_Color%SUFFIX% D3D12_VertexShader.hlsl

+%DXC% -E mainTexture -T vs_6_0 -Fh D3D12_VertexShader_Texture%SUFFIX% D3D12_VertexShader.hlsl

+%DXC% -E mainAdvanced -T vs_6_0 -Fh D3D12_VertexShader_Advanced%SUFFIX% D3D12_VertexShader.hlsl

+

+%DXC% -E ColorRS -T rootsig_1_1 -rootsig-define ColorRS -Fh D3D12_RootSig_Color%SUFFIX% D3D12_VertexShader.hlsl

+%DXC% -E TextureRS -T rootsig_1_1 -rootsig-define TextureRS -Fh D3D12_RootSig_Texture%SUFFIX% D3D12_VertexShader.hlsl

+%DXC% -E AdvancedRS -T rootsig_1_1 -rootsig-define AdvancedRS -Fh D3D12_RootSig_Advanced%SUFFIX% D3D12_VertexShader.hlsl

diff --git a/SDL-3.2.8/src/render/direct3d12/compile_shaders_xbox.bat b/SDL-3.2.8/src/render/direct3d12/compile_shaders_xbox.bat
new file mode 100644
index 0000000..311b172
--- /dev/null
+++ b/SDL-3.2.8/src/render/direct3d12/compile_shaders_xbox.bat
@@ -0,0 +1,13 @@
+if %2.==one. goto setxboxone
+rem Xbox Series compile
+set DXC="%GameDKLatest%\GXDK\bin\Scarlett\DXC.exe"
+set SUFFIX=_Series.h
+goto startbuild
+
+:setxboxone
+set DXC="%GameDKLatest%\GXDK\bin\XboxOne\DXC.exe"
+set SUFFIX=_One.h
+
+:startbuild
+
+call "%~dp0\compile_shaders.bat"
diff --git a/SDL-3.2.8/src/render/gpu/SDL_gpu_util.h b/SDL-3.2.8/src/render/gpu/SDL_gpu_util.h
new file mode 100644
index 0000000..ca32ce0
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/SDL_gpu_util.h
@@ -0,0 +1,74 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_gpu_util_h_
+#define SDL_gpu_util_h_
+
+#define SDL_GPU_BLENDOP_INVALID     ((SDL_GPUBlendOp)0x7fffffff)
+#define SDL_GPU_BLENDFACTOR_INVALID ((SDL_GPUBlendFactor)0x7fffffff)
+
+static SDL_INLINE SDL_GPUBlendFactor GPU_ConvertBlendFactor(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return SDL_GPU_BLENDFACTOR_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return SDL_GPU_BLENDFACTOR_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return SDL_GPU_BLENDFACTOR_SRC_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_COLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return SDL_GPU_BLENDFACTOR_SRC_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return SDL_GPU_BLENDFACTOR_DST_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_COLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return SDL_GPU_BLENDFACTOR_DST_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_ALPHA;
+    default:
+        return SDL_GPU_BLENDFACTOR_INVALID;
+    }
+}
+
+static SDL_INLINE SDL_GPUBlendOp GPU_ConvertBlendOperation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return SDL_GPU_BLENDOP_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return SDL_GPU_BLENDOP_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return SDL_GPU_BLENDOP_REVERSE_SUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return SDL_GPU_BLENDOP_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return SDL_GPU_BLENDOP_MAX;
+    default:
+        return SDL_GPU_BLENDOP_INVALID;
+    }
+}
+
+#endif // SDL_gpu_util_h
diff --git a/SDL-3.2.8/src/render/gpu/SDL_pipeline_gpu.c b/SDL-3.2.8/src/render/gpu/SDL_pipeline_gpu.c
new file mode 100644
index 0000000..0783374
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/SDL_pipeline_gpu.c
@@ -0,0 +1,202 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_GPU
+
+#include "SDL_gpu_util.h"
+#include "SDL_pipeline_gpu.h"
+
+#include "../SDL_sysrender.h"
+
+struct GPU_PipelineCacheKeyStruct
+{
+    Uint64 blend_mode : 28;
+    Uint64 frag_shader : 4;
+    Uint64 vert_shader : 4;
+    Uint64 attachment_format : 6;
+    Uint64 primitive_type : 3;
+};
+
+typedef union GPU_PipelineCacheKeyConverter
+{
+    struct GPU_PipelineCacheKeyStruct as_struct;
+    Uint64 as_uint64;
+} GPU_PipelineCacheKeyConverter;
+
+SDL_COMPILE_TIME_ASSERT(GPU_PipelineCacheKeyConverter_Size, sizeof(GPU_PipelineCacheKeyConverter) <= sizeof(Uint64));
+
+static Uint32 SDLCALL HashPipelineCacheKey(void *userdata, const void *key)
+{
+    const GPU_PipelineParameters *params = (const GPU_PipelineParameters *) key;
+    GPU_PipelineCacheKeyConverter cvt;
+    cvt.as_uint64 = 0;
+    cvt.as_struct.blend_mode = params->blend_mode;
+    cvt.as_struct.frag_shader = params->frag_shader;
+    cvt.as_struct.vert_shader = params->vert_shader;
+    cvt.as_struct.attachment_format = params->attachment_format;
+    cvt.as_struct.primitive_type = params->primitive_type;
+
+    // 64-bit uint hash function stolen from taisei (which stole it from somewhere else)
+    Uint64 x = cvt.as_uint64;
+    x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
+    x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
+    x = x ^ (x >> 31);
+    return (Uint32)(x & 0xffffffff);
+}
+
+static bool SDLCALL MatchPipelineCacheKey(void *userdata, const void *a, const void *b)
+{
+    return (SDL_memcmp(a, b, sizeof (GPU_PipelineParameters)) == 0);
+}
+
+static void SDLCALL DestroyPipelineCacheHashItem(void *userdata, const void *key, const void *value)
+{
+    SDL_GPUGraphicsPipeline *pipeline = (SDL_GPUGraphicsPipeline *) value;
+    SDL_GPUDevice *device = (SDL_GPUDevice *) userdata;
+    SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
+    SDL_free((GPU_PipelineParameters *) key);
+}
+
+bool GPU_InitPipelineCache(GPU_PipelineCache *cache, SDL_GPUDevice *device)
+{
+    cache->table = SDL_CreateHashTable(0, false, HashPipelineCacheKey, MatchPipelineCacheKey, DestroyPipelineCacheHashItem, device);
+    return (cache->table != NULL);
+}
+
+void GPU_DestroyPipelineCache(GPU_PipelineCache *cache)
+{
+    SDL_DestroyHashTable(cache->table);
+}
+
+static SDL_GPUGraphicsPipeline *MakePipeline(SDL_GPUDevice *device, GPU_Shaders *shaders, const GPU_PipelineParameters *params)
+{
+    SDL_GPUColorTargetDescription ad;
+    SDL_zero(ad);
+    ad.format = params->attachment_format;
+
+    SDL_BlendMode blend = params->blend_mode;
+    ad.blend_state.enable_blend = blend != 0;
+    ad.blend_state.color_write_mask = 0xF;
+    ad.blend_state.alpha_blend_op = GPU_ConvertBlendOperation(SDL_GetBlendModeAlphaOperation(blend));
+    ad.blend_state.dst_alpha_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeDstAlphaFactor(blend));
+    ad.blend_state.src_alpha_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeSrcAlphaFactor(blend));
+    ad.blend_state.color_blend_op = GPU_ConvertBlendOperation(SDL_GetBlendModeColorOperation(blend));
+    ad.blend_state.dst_color_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeDstColorFactor(blend));
+    ad.blend_state.src_color_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeSrcColorFactor(blend));
+
+    SDL_GPUGraphicsPipelineCreateInfo pci;
+    SDL_zero(pci);
+    pci.target_info.has_depth_stencil_target = false;
+    pci.target_info.num_color_targets = 1;
+    pci.target_info.color_target_descriptions = &ad;
+    pci.vertex_shader = GPU_GetVertexShader(shaders, params->vert_shader);
+    pci.fragment_shader = GPU_GetFragmentShader(shaders, params->frag_shader);
+    pci.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1;
+    pci.multisample_state.enable_mask = false;
+    pci.primitive_type = params->primitive_type;
+
+    pci.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;
+    pci.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL;
+    pci.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
+
+    SDL_GPUVertexBufferDescription vertex_buffer_desc;
+    SDL_zero(vertex_buffer_desc);
+
+    Uint32 num_attribs = 0;
+    SDL_GPUVertexAttribute attribs[4];
+    SDL_zero(attribs);
+
+    bool have_attr_color = false;
+    bool have_attr_uv = false;
+
+    switch (params->vert_shader) {
+    case VERT_SHADER_TRI_TEXTURE:
+        have_attr_uv = true;
+        SDL_FALLTHROUGH;
+    case VERT_SHADER_TRI_COLOR:
+        have_attr_color = true;
+        SDL_FALLTHROUGH;
+    default:
+        break;
+    }
+
+    // Position
+    attribs[num_attribs].location = num_attribs;
+    attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
+    attribs[num_attribs].offset = vertex_buffer_desc.pitch;
+    vertex_buffer_desc.pitch += 2 * sizeof(float);
+    num_attribs++;
+
+    if (have_attr_color) {
+        // Color
+        attribs[num_attribs].location = num_attribs;
+        attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4;
+        attribs[num_attribs].offset = vertex_buffer_desc.pitch;
+        vertex_buffer_desc.pitch += 4 * sizeof(float);
+        num_attribs++;
+    }
+
+    if (have_attr_uv) {
+        // UVs
+        attribs[num_attribs].location = num_attribs;
+        attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
+        attribs[num_attribs].offset = vertex_buffer_desc.pitch;
+        vertex_buffer_desc.pitch += 2 * sizeof(float);
+        num_attribs++;
+    }
+
+    pci.vertex_input_state.num_vertex_attributes = num_attribs;
+    pci.vertex_input_state.vertex_attributes = attribs;
+    pci.vertex_input_state.num_vertex_buffers = 1;
+    pci.vertex_input_state.vertex_buffer_descriptions = &vertex_buffer_desc;
+
+    return SDL_CreateGPUGraphicsPipeline(device, &pci);
+}
+
+SDL_GPUGraphicsPipeline *GPU_GetPipeline(GPU_PipelineCache *cache, GPU_Shaders *shaders, SDL_GPUDevice *device, const GPU_PipelineParameters *params)
+{
+    SDL_GPUGraphicsPipeline *pipeline = NULL;
+    if (!SDL_FindInHashTable(cache->table, params, (const void **) &pipeline)) {
+        bool inserted = false;
+        // !!! FIXME: why don't we have an SDL_alloc_copy function/macro?
+        GPU_PipelineParameters *paramscpy = (GPU_PipelineParameters *) SDL_malloc(sizeof (*paramscpy));
+        if (paramscpy) {
+            SDL_copyp(paramscpy, params);
+            pipeline = MakePipeline(device, shaders, params);
+            if (pipeline) {
+                inserted = SDL_InsertIntoHashTable(cache->table, paramscpy, pipeline, false);
+            }
+        }
+
+        if (!inserted) {
+            SDL_free(paramscpy);
+            if (pipeline) {
+                SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
+                pipeline = NULL;
+            }
+        }
+    }
+
+    return pipeline;
+}
+
+#endif // SDL_VIDEO_RENDER_GPU
diff --git a/SDL-3.2.8/src/render/gpu/SDL_pipeline_gpu.h b/SDL-3.2.8/src/render/gpu/SDL_pipeline_gpu.h
new file mode 100644
index 0000000..c3fc39b
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/SDL_pipeline_gpu.h
@@ -0,0 +1,47 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_pipeline_gpu_h_
+#define SDL_pipeline_gpu_h_
+
+#include "SDL_internal.h"
+
+#include "SDL_shaders_gpu.h"
+
+typedef struct GPU_PipelineParameters
+{
+    SDL_BlendMode blend_mode;
+    GPU_FragmentShaderID frag_shader;
+    GPU_VertexShaderID vert_shader;
+    SDL_GPUTextureFormat attachment_format;
+    SDL_GPUPrimitiveType primitive_type;
+} GPU_PipelineParameters;
+
+typedef struct GPU_PipelineCache
+{
+    SDL_HashTable *table;
+} GPU_PipelineCache;
+
+extern bool GPU_InitPipelineCache(GPU_PipelineCache *cache, SDL_GPUDevice *device);
+extern void GPU_DestroyPipelineCache(GPU_PipelineCache *cache);
+extern SDL_GPUGraphicsPipeline *GPU_GetPipeline(GPU_PipelineCache *cache, GPU_Shaders *shaders, SDL_GPUDevice *device, const GPU_PipelineParameters *params);
+
+#endif // SDL_pipeline_gpu_h_
diff --git a/SDL-3.2.8/src/render/gpu/SDL_render_gpu.c b/SDL-3.2.8/src/render/gpu/SDL_render_gpu.c
new file mode 100644
index 0000000..73c1dbe
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/SDL_render_gpu.c
@@ -0,0 +1,1276 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_GPU
+
+#include "../../video/SDL_pixels_c.h"
+#include "../SDL_d3dmath.h"
+#include "../SDL_sysrender.h"
+#include "SDL_gpu_util.h"
+#include "SDL_pipeline_gpu.h"
+#include "SDL_shaders_gpu.h"
+
+typedef struct GPU_ShaderUniformData
+{
+    Float4X4 mvp;
+    SDL_FColor color;
+    float texture_size[2];
+} GPU_ShaderUniformData;
+
+typedef struct GPU_RenderData
+{
+    SDL_GPUDevice *device;
+    GPU_Shaders shaders;
+    GPU_PipelineCache pipeline_cache;
+
+    struct
+    {
+        SDL_GPUTexture *texture;
+        SDL_GPUTextureFormat format;
+        Uint32 width;
+        Uint32 height;
+    } backbuffer;
+
+    struct
+    {
+        SDL_GPUSwapchainComposition composition;
+        SDL_GPUPresentMode present_mode;
+    } swapchain;
+
+    struct
+    {
+        SDL_GPUTransferBuffer *transfer_buf;
+        SDL_GPUBuffer *buffer;
+        Uint32 buffer_size;
+    } vertices;
+
+    struct
+    {
+        SDL_GPURenderPass *render_pass;
+        SDL_Texture *render_target;
+        SDL_GPUCommandBuffer *command_buffer;
+        SDL_GPUColorTargetInfo color_attachment;
+        SDL_GPUViewport viewport;
+        SDL_Rect scissor;
+        SDL_FColor draw_color;
+        bool scissor_enabled;
+        bool scissor_was_enabled;
+        GPU_ShaderUniformData shader_data;
+    } state;
+
+    SDL_GPUSampler *samplers[2][2];
+} GPU_RenderData;
+
+typedef struct GPU_TextureData
+{
+    SDL_GPUTexture *texture;
+    SDL_GPUTextureFormat format;
+    GPU_FragmentShaderID shader;
+    void *pixels;
+    int pitch;
+    SDL_Rect locked_rect;
+} GPU_TextureData;
+
+static bool GPU_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (GPU_ConvertBlendFactor(srcColorFactor) == SDL_GPU_BLENDFACTOR_INVALID ||
+        GPU_ConvertBlendFactor(srcAlphaFactor) == SDL_GPU_BLENDFACTOR_INVALID ||
+        GPU_ConvertBlendOperation(colorOperation) == SDL_GPU_BLENDOP_INVALID ||
+        GPU_ConvertBlendFactor(dstColorFactor) == SDL_GPU_BLENDFACTOR_INVALID ||
+        GPU_ConvertBlendFactor(dstAlphaFactor) == SDL_GPU_BLENDFACTOR_INVALID ||
+        GPU_ConvertBlendOperation(alphaOperation) == SDL_GPU_BLENDOP_INVALID) {
+        return false;
+    }
+
+    return true;
+}
+
+static SDL_GPUTextureFormat PixFormatToTexFormat(SDL_PixelFormat pixel_format)
+{
+    switch (pixel_format) {
+    case SDL_PIXELFORMAT_BGRA32:
+    case SDL_PIXELFORMAT_BGRX32:
+        return SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM;
+    case SDL_PIXELFORMAT_RGBA32:
+    case SDL_PIXELFORMAT_RGBX32:
+        return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+
+    // YUV TODO
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+    case SDL_PIXELFORMAT_UYVY:
+    default:
+        return SDL_GPU_TEXTUREFORMAT_INVALID;
+    }
+}
+
+static SDL_PixelFormat TexFormatToPixFormat(SDL_GPUTextureFormat tex_format)
+{
+    switch (tex_format) {
+    case SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM:
+        return SDL_PIXELFORMAT_RGBA32;
+    case SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM:
+        return SDL_PIXELFORMAT_BGRA32;
+    case SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM:
+        return SDL_PIXELFORMAT_BGR565;
+    case SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM:
+        return SDL_PIXELFORMAT_BGRA5551;
+    case SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM:
+        return SDL_PIXELFORMAT_BGRA4444;
+    case SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM:
+        return SDL_PIXELFORMAT_ABGR2101010;
+    case SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UNORM:
+        return SDL_PIXELFORMAT_RGBA64;
+    case SDL_GPU_TEXTUREFORMAT_R8G8B8A8_SNORM:
+        return SDL_PIXELFORMAT_RGBA32;
+    case SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT:
+        return SDL_PIXELFORMAT_RGBA64_FLOAT;
+    case SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT:
+        return SDL_PIXELFORMAT_RGBA128_FLOAT;
+    case SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UINT:
+        return SDL_PIXELFORMAT_RGBA32;
+    case SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UINT:
+        return SDL_PIXELFORMAT_RGBA64;
+    case SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_RGBA32;
+    case SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM_SRGB:
+        return SDL_PIXELFORMAT_BGRA32;
+    default:
+        return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static bool GPU_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    GPU_RenderData *renderdata = (GPU_RenderData *)renderer->internal;
+    GPU_TextureData *data;
+    SDL_GPUTextureFormat format;
+    SDL_GPUTextureUsageFlags usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
+
+    format = PixFormatToTexFormat(texture->format);
+
+    if (format == SDL_GPU_TEXTUREFORMAT_INVALID) {
+        return SDL_SetError("Texture format %s not supported by SDL_GPU",
+                            SDL_GetPixelFormatName(texture->format));
+    }
+
+    data = (GPU_TextureData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        size_t size;
+        data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
+        size = (size_t)texture->h * data->pitch;
+        if (texture->format == SDL_PIXELFORMAT_YV12 ||
+            texture->format == SDL_PIXELFORMAT_IYUV) {
+            // Need to add size for the U and V planes
+            size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
+        }
+        if (texture->format == SDL_PIXELFORMAT_NV12 ||
+            texture->format == SDL_PIXELFORMAT_NV21) {
+            // Need to add size for the U/V plane
+            size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
+        }
+        data->pixels = SDL_calloc(1, size);
+        if (!data->pixels) {
+            SDL_free(data);
+            return false;
+        }
+
+        // TODO allocate a persistent transfer buffer
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        usage |= SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
+    }
+
+    texture->internal = data;
+    SDL_GPUTextureCreateInfo tci;
+    SDL_zero(tci);
+    tci.format = format;
+    tci.layer_count_or_depth = 1;
+    tci.num_levels = 1;
+    tci.usage = usage;
+    tci.width = texture->w;
+    tci.height = texture->h;
+    tci.sample_count = SDL_GPU_SAMPLECOUNT_1;
+
+    data->format = format;
+    data->texture = SDL_CreateGPUTexture(renderdata->device, &tci);
+
+    if (!data->texture) {
+        return false;
+    }
+
+    if (texture->format == SDL_PIXELFORMAT_RGBA32 || texture->format == SDL_PIXELFORMAT_BGRA32) {
+        data->shader = FRAG_SHADER_TEXTURE_RGBA;
+    } else {
+        data->shader = FRAG_SHADER_TEXTURE_RGB;
+    }
+
+    return true;
+}
+
+static bool GPU_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                              const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    GPU_RenderData *renderdata = (GPU_RenderData *)renderer->internal;
+    GPU_TextureData *data = (GPU_TextureData *)texture->internal;
+    const Uint32 texturebpp = SDL_BYTESPERPIXEL(texture->format);
+
+    size_t row_size, data_size;
+
+    if (!SDL_size_mul_check_overflow(rect->w, texturebpp, &row_size) ||
+        !SDL_size_mul_check_overflow(rect->h, row_size, &data_size)) {
+        return SDL_SetError("update size overflow");
+    }
+
+    SDL_GPUTransferBufferCreateInfo tbci;
+    SDL_zero(tbci);
+    tbci.size = (Uint32)data_size;
+    tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+
+    SDL_GPUTransferBuffer *tbuf = SDL_CreateGPUTransferBuffer(renderdata->device, &tbci);
+
+    if (tbuf == NULL) {
+        return false;
+    }
+
+    Uint8 *output = SDL_MapGPUTransferBuffer(renderdata->device, tbuf, false);
+
+    if ((size_t)pitch == row_size) {
+        SDL_memcpy(output, pixels, data_size);
+    } else {
+        // FIXME is negative pitch supposed to work?
+        // If not, maybe use SDL_GPUTextureTransferInfo::pixels_per_row instead of this
+        const Uint8 *input = pixels;
+
+        for (int i = 0; i < rect->h; ++i) {
+            SDL_memcpy(output, input, row_size);
+            output += row_size;
+            input += pitch;
+        }
+    }
+
+    SDL_UnmapGPUTransferBuffer(renderdata->device, tbuf);
+
+    SDL_GPUCommandBuffer *cbuf = renderdata->state.command_buffer;
+    SDL_GPUCopyPass *cpass = SDL_BeginGPUCopyPass(cbuf);
+
+    SDL_GPUTextureTransferInfo tex_src;
+    SDL_zero(tex_src);
+    tex_src.transfer_buffer = tbuf;
+    tex_src.rows_per_layer = rect->h;
+    tex_src.pixels_per_row = rect->w;
+
+    SDL_GPUTextureRegion tex_dst;
+    SDL_zero(tex_dst);
+    tex_dst.texture = data->texture;
+    tex_dst.x = rect->x;
+    tex_dst.y = rect->y;
+    tex_dst.w = rect->w;
+    tex_dst.h = rect->h;
+    tex_dst.d = 1;
+
+    SDL_UploadToGPUTexture(cpass, &tex_src, &tex_dst, false);
+    SDL_EndGPUCopyPass(cpass);
+    SDL_ReleaseGPUTransferBuffer(renderdata->device, tbuf);
+
+    return true;
+}
+
+static bool GPU_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                            const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    GPU_TextureData *data = (GPU_TextureData *)texture->internal;
+
+    data->locked_rect = *rect;
+    *pixels =
+        (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
+                 rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = data->pitch;
+    return true;
+}
+
+static void GPU_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GPU_TextureData *data = (GPU_TextureData *)texture->internal;
+    const SDL_Rect *rect;
+    void *pixels;
+
+    rect = &data->locked_rect;
+    pixels =
+        (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
+                 rect->x * SDL_BYTESPERPIXEL(texture->format));
+    GPU_UpdateTexture(renderer, texture, rect, pixels, data->pitch);
+}
+
+static void GPU_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scale_mode)
+{
+    // nothing to do in this backend.
+}
+
+static bool GPU_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+
+    data->state.render_target = texture;
+
+    return true;
+}
+
+static bool GPU_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static SDL_FColor GetDrawCmdColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    SDL_FColor color = cmd->data.color.color;
+
+    if (SDL_RenderingLinearSpace(renderer)) {
+        SDL_ConvertToLinear(&color);
+    }
+
+    color.r *= cmd->data.color.color_scale;
+    color.g *= cmd->data.color.color_scale;
+    color.b *= cmd->data.color.color_scale;
+
+    return color;
+}
+
+static bool GPU_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    float *verts = (float *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(float), 0, &cmd->data.draw.first);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    for (int i = 0; i < count; i++) {
+        *(verts++) = 0.5f + points[i].x;
+        *(verts++) = 0.5f + points[i].y;
+    }
+
+    return true;
+}
+
+static bool GPU_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                              const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                              int num_vertices, const void *indices, int num_indices, int size_indices,
+                              float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    float *verts;
+    size_t sz = 2 * sizeof(float) + 4 * sizeof(float) + (texture ? 2 : 0) * sizeof(float);
+    const float color_scale = cmd->data.draw.color_scale;
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+
+    verts = (float *)SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        SDL_FColor col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+        if (convert_color) {
+            SDL_ConvertToLinear(&col_);
+        }
+
+        // FIXME: The Vulkan backend doesn't multiply by color_scale. GL does. I'm not sure which one is wrong.
+        // ANSWER: The color scale should be applied in linear space when using the scRGB colorspace. This is done in shaders in the Vulkan backend.
+        *(verts++) = col_.r * color_scale;
+        *(verts++) = col_.g * color_scale;
+        *(verts++) = col_.b * color_scale;
+        *(verts++) = col_.a;
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            *(verts++) = uv_[0] * texture->w;
+            *(verts++) = uv_[1] * texture->h;
+        }
+    }
+    return true;
+}
+
+static void GPU_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+
+    data->state.render_target = NULL;
+    data->state.scissor_enabled = false;
+}
+
+static SDL_GPURenderPass *RestartRenderPass(GPU_RenderData *data)
+{
+    if (data->state.render_pass) {
+        SDL_EndGPURenderPass(data->state.render_pass);
+    }
+
+    data->state.render_pass = SDL_BeginGPURenderPass(
+        data->state.command_buffer, &data->state.color_attachment, 1, NULL);
+
+    // *** FIXME ***
+    // This is busted. We should be able to know which load op to use.
+    // LOAD is incorrect behavior most of the time, unless we had to break a render pass.
+    // -cosmonaut
+    data->state.color_attachment.load_op = SDL_GPU_LOADOP_LOAD;
+    data->state.scissor_was_enabled = false;
+
+    return data->state.render_pass;
+}
+
+static void PushUniforms(GPU_RenderData *data, SDL_RenderCommand *cmd)
+{
+    GPU_ShaderUniformData uniforms;
+    SDL_zero(uniforms);
+    uniforms.mvp.m[0][0] = 2.0f / data->state.viewport.w;
+    uniforms.mvp.m[1][1] = -2.0f / data->state.viewport.h;
+    uniforms.mvp.m[2][2] = 1.0f;
+    uniforms.mvp.m[3][0] = -1.0f;
+    uniforms.mvp.m[3][1] = 1.0f;
+    uniforms.mvp.m[3][3] = 1.0f;
+
+    uniforms.color = data->state.draw_color;
+
+    if (cmd->data.draw.texture) {
+        uniforms.texture_size[0] = cmd->data.draw.texture->w;
+        uniforms.texture_size[1] = cmd->data.draw.texture->h;
+    }
+
+    SDL_PushGPUVertexUniformData(data->state.command_buffer, 0, &uniforms, sizeof(uniforms));
+}
+
+static SDL_GPUSampler **SamplerPointer(
+    GPU_RenderData *data, SDL_TextureAddressMode address_mode, SDL_ScaleMode scale_mode)
+{
+    return &data->samplers[scale_mode][address_mode - 1];
+}
+
+static void SetViewportAndScissor(GPU_RenderData *data)
+{
+    SDL_SetGPUViewport(data->state.render_pass, &data->state.viewport);
+
+    if (data->state.scissor_enabled) {
+        SDL_SetGPUScissor(data->state.render_pass, &data->state.scissor);
+        data->state.scissor_was_enabled = true;
+    } else if (data->state.scissor_was_enabled) {
+        SDL_Rect r;
+        r.x = (int)data->state.viewport.x;
+        r.y = (int)data->state.viewport.y;
+        r.w = (int)data->state.viewport.w;
+        r.h = (int)data->state.viewport.h;
+        SDL_SetGPUScissor(data->state.render_pass, &r);
+        data->state.scissor_was_enabled = false;
+    }
+}
+
+static void Draw(
+    GPU_RenderData *data, SDL_RenderCommand *cmd,
+    Uint32 num_verts,
+    Uint32 offset,
+    SDL_GPUPrimitiveType prim)
+{
+    if (!data->state.render_pass || data->state.color_attachment.load_op == SDL_GPU_LOADOP_CLEAR) {
+        RestartRenderPass(data);
+    }
+
+    GPU_VertexShaderID v_shader;
+    GPU_FragmentShaderID f_shader;
+    SDL_GPURenderPass *pass = data->state.render_pass;
+    GPU_TextureData *tdata = NULL;
+
+    if (cmd->data.draw.texture) {
+        tdata = (GPU_TextureData *)cmd->data.draw.texture->internal;
+    }
+
+    if (prim == SDL_GPU_PRIMITIVETYPE_TRIANGLELIST) {
+        if (cmd->data.draw.texture) {
+            v_shader = VERT_SHADER_TRI_TEXTURE;
+            f_shader = tdata->shader;
+        } else {
+            v_shader = VERT_SHADER_TRI_COLOR;
+            f_shader = FRAG_SHADER_COLOR;
+        }
+    } else {
+        v_shader = VERT_SHADER_LINEPOINT;
+        f_shader = FRAG_SHADER_COLOR;
+    }
+
+    GPU_PipelineParameters pipe_params;
+    SDL_zero(pipe_params);
+    pipe_params.blend_mode = cmd->data.draw.blend;
+    pipe_params.vert_shader = v_shader;
+    pipe_params.frag_shader = f_shader;
+    pipe_params.primitive_type = prim;
+
+    if (data->state.render_target) {
+        pipe_params.attachment_format = ((GPU_TextureData *)data->state.render_target->internal)->format;
+    } else {
+        pipe_params.attachment_format = data->backbuffer.format;
+    }
+
+    SDL_GPUGraphicsPipeline *pipe = GPU_GetPipeline(&data->pipeline_cache, &data->shaders, data->device, &pipe_params);
+
+    if (!pipe) {
+        return;
+    }
+
+    SetViewportAndScissor(data);
+    SDL_BindGPUGraphicsPipeline(data->state.render_pass, pipe);
+
+    if (tdata) {
+        SDL_GPUTextureSamplerBinding sampler_bind;
+        SDL_zero(sampler_bind);
+        sampler_bind.sampler = *SamplerPointer(data, cmd->data.draw.texture_address_mode, cmd->data.draw.texture->scaleMode);
+        sampler_bind.texture = tdata->texture;
+        SDL_BindGPUFragmentSamplers(pass, 0, &sampler_bind, 1);
+    }
+
+    SDL_GPUBufferBinding buffer_bind;
+    SDL_zero(buffer_bind);
+    buffer_bind.buffer = data->vertices.buffer;
+    buffer_bind.offset = offset;
+
+    SDL_BindGPUVertexBuffers(pass, 0, &buffer_bind, 1);
+    PushUniforms(data, cmd);
+    SDL_DrawGPUPrimitives(data->state.render_pass, num_verts, 1, 0, 0);
+}
+
+static void ReleaseVertexBuffer(GPU_RenderData *data)
+{
+    if (data->vertices.buffer) {
+        SDL_ReleaseGPUBuffer(data->device, data->vertices.buffer);
+    }
+
+    if (data->vertices.transfer_buf) {
+        SDL_ReleaseGPUTransferBuffer(data->device, data->vertices.transfer_buf);
+    }
+
+    data->vertices.buffer_size = 0;
+}
+
+static bool InitVertexBuffer(GPU_RenderData *data, Uint32 size)
+{
+    SDL_GPUBufferCreateInfo bci;
+    SDL_zero(bci);
+    bci.size = size;
+    bci.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
+
+    data->vertices.buffer = SDL_CreateGPUBuffer(data->device, &bci);
+
+    if (!data->vertices.buffer) {
+        return false;
+    }
+
+    SDL_GPUTransferBufferCreateInfo tbci;
+    SDL_zero(tbci);
+    tbci.size = size;
+    tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+
+    data->vertices.transfer_buf = SDL_CreateGPUTransferBuffer(data->device, &tbci);
+
+    if (!data->vertices.transfer_buf) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool UploadVertices(GPU_RenderData *data, void *vertices, size_t vertsize)
+{
+    if (vertsize == 0) {
+        return true;
+    }
+
+    if (vertsize > data->vertices.buffer_size) {
+        ReleaseVertexBuffer(data);
+        if (!InitVertexBuffer(data, (Uint32)vertsize)) {
+            return false;
+        }
+    }
+
+    void *staging_buf = SDL_MapGPUTransferBuffer(data->device, data->vertices.transfer_buf, true);
+    SDL_memcpy(staging_buf, vertices, vertsize);
+    SDL_UnmapGPUTransferBuffer(data->device, data->vertices.transfer_buf);
+
+    SDL_GPUCopyPass *pass = SDL_BeginGPUCopyPass(data->state.command_buffer);
+
+    if (!pass) {
+        return false;
+    }
+
+    SDL_GPUTransferBufferLocation src;
+    SDL_zero(src);
+    src.transfer_buffer = data->vertices.transfer_buf;
+
+    SDL_GPUBufferRegion dst;
+    SDL_zero(dst);
+    dst.buffer = data->vertices.buffer;
+    dst.size = (Uint32)vertsize;
+
+    SDL_UploadToGPUBuffer(pass, &src, &dst, true);
+    SDL_EndGPUCopyPass(pass);
+
+    return true;
+}
+
+// *** FIXME ***
+// We might be able to run these data uploads on a separate command buffer
+// which would allow us to avoid breaking render passes.
+// Honestly I'm a little skeptical of this entire approach,
+// we already have a command buffer structure
+// so it feels weird to be deferring the operations manually.
+// We could also fairly easily run the geometry transformations
+// on compute shaders instead of the CPU, which would be a HUGE performance win.
+// -cosmonaut
+static bool GPU_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+
+    if (!UploadVertices(data, vertices, vertsize)) {
+        return false;
+    }
+
+    data->state.color_attachment.load_op = SDL_GPU_LOADOP_LOAD;
+
+    if (renderer->target) {
+        GPU_TextureData *tdata = renderer->target->internal;
+        data->state.color_attachment.texture = tdata->texture;
+    } else {
+        data->state.color_attachment.texture = data->backbuffer.texture;
+    }
+
+    if (!data->state.color_attachment.texture) {
+        return SDL_SetError("Render target texture is NULL");
+    }
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            data->state.draw_color = GetDrawCmdColor(renderer, cmd);
+            break;
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &cmd->data.viewport.rect;
+            data->state.viewport.x = viewport->x;
+            data->state.viewport.y = viewport->y;
+            data->state.viewport.w = viewport->w;
+            data->state.viewport.h = viewport->h;
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            data->state.scissor.x = (int)data->state.viewport.x + rect->x;
+            data->state.scissor.y = (int)data->state.viewport.y + rect->y;
+            data->state.scissor.w = rect->w;
+            data->state.scissor.h = rect->h;
+            data->state.scissor_enabled = cmd->data.cliprect.enabled;
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            data->state.color_attachment.clear_color = GetDrawCmdColor(renderer, cmd);
+            data->state.color_attachment.load_op = SDL_GPU_LOADOP_CLEAR;
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            Uint32 count = (Uint32)cmd->data.draw.count;
+            Uint32 offset = (Uint32)cmd->data.draw.first;
+
+            if (count > 2) {
+                // joined lines cannot be grouped
+                Draw(data, cmd, count, offset, SDL_GPU_PRIMITIVETYPE_LINESTRIP);
+            } else {
+                // let's group non joined lines
+                SDL_RenderCommand *finalcmd = cmd;
+                SDL_RenderCommand *nextcmd = cmd->next;
+                SDL_BlendMode thisblend = cmd->data.draw.blend;
+
+                while (nextcmd) {
+                    const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                    if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
+                        break; // can't go any further on this draw call, different render command up next.
+                    } else if (nextcmd->data.draw.count != 2) {
+                        break; // can't go any further on this draw call, those are joined lines
+                    } else if (nextcmd->data.draw.blend != thisblend) {
+                        break; // can't go any further on this draw call, different blendmode copy up next.
+                    } else {
+                        finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                        count += (Uint32)nextcmd->data.draw.count;
+                    }
+                    nextcmd = nextcmd->next;
+                }
+
+                Draw(data, cmd, count, offset, SDL_GPU_PRIMITIVETYPE_LINELIST);
+                cmd = finalcmd; // skip any copy commands we just combined in here.
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            /* as long as we have the same copy command in a row, with the
+               same texture, we can combine them all into a single draw call. */
+            SDL_Texture *thistexture = cmd->data.draw.texture;
+            SDL_BlendMode thisblend = cmd->data.draw.blend;
+            const SDL_RenderCommandType thiscmdtype = cmd->command;
+            SDL_RenderCommand *finalcmd = cmd;
+            SDL_RenderCommand *nextcmd = cmd->next;
+            Uint32 count = (Uint32)cmd->data.draw.count;
+            Uint32 offset = (Uint32)cmd->data.draw.first;
+
+            while (nextcmd) {
+                const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                if (nextcmdtype != thiscmdtype) {
+                    break; // can't go any further on this draw call, different render command up next.
+                } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                    // FIXME should we check address mode too?
+                    break; // can't go any further on this draw call, different texture/blendmode copy up next.
+                } else {
+                    finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                    count += (Uint32)nextcmd->data.draw.count;
+                }
+                nextcmd = nextcmd->next;
+            }
+
+            SDL_GPUPrimitiveType prim = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; // SDL_RENDERCMD_GEOMETRY
+            if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                prim = SDL_GPU_PRIMITIVETYPE_POINTLIST;
+            }
+
+            Draw(data, cmd, count, offset, prim);
+
+            cmd = finalcmd; // skip any copy commands we just combined in here.
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    if (data->state.color_attachment.load_op == SDL_GPU_LOADOP_CLEAR) {
+        RestartRenderPass(data);
+    }
+
+    if (data->state.render_pass) {
+        SDL_EndGPURenderPass(data->state.render_pass);
+        data->state.render_pass = NULL;
+    }
+
+    return true;
+}
+
+static SDL_Surface *GPU_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+    SDL_GPUTexture *gpu_tex;
+    SDL_PixelFormat pixfmt;
+
+    if (data->state.render_target) {
+        SDL_Texture *texture = data->state.render_target;
+        GPU_TextureData *texdata = texture->internal;
+        gpu_tex = texdata->texture;
+        pixfmt = texture->format;
+    } else {
+        gpu_tex = data->backbuffer.texture;
+        pixfmt = TexFormatToPixFormat(data->backbuffer.format);
+
+        if (pixfmt == SDL_PIXELFORMAT_UNKNOWN) {
+            SDL_SetError("Unsupported backbuffer format");
+            return NULL;
+        }
+    }
+
+    Uint32 bpp = SDL_BYTESPERPIXEL(pixfmt);
+    size_t row_size, image_size;
+
+    if (!SDL_size_mul_check_overflow(rect->w, bpp, &row_size) ||
+        !SDL_size_mul_check_overflow(rect->h, row_size, &image_size)) {
+        SDL_SetError("read size overflow");
+        return NULL;
+    }
+
+    SDL_Surface *surface = SDL_CreateSurface(rect->w, rect->h, pixfmt);
+
+    if (!surface) {
+        return NULL;
+    }
+
+    SDL_GPUTransferBufferCreateInfo tbci;
+    SDL_zero(tbci);
+    tbci.size = (Uint32)image_size;
+    tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD;
+
+    SDL_GPUTransferBuffer *tbuf = SDL_CreateGPUTransferBuffer(data->device, &tbci);
+
+    if (!tbuf) {
+        return NULL;
+    }
+
+    SDL_GPUCopyPass *pass = SDL_BeginGPUCopyPass(data->state.command_buffer);
+
+    SDL_GPUTextureRegion src;
+    SDL_zero(src);
+    src.texture = gpu_tex;
+    src.x = rect->x;
+    src.y = rect->y;
+    src.w = rect->w;
+    src.h = rect->h;
+    src.d = 1;
+
+    SDL_GPUTextureTransferInfo dst;
+    SDL_zero(dst);
+    dst.transfer_buffer = tbuf;
+    dst.rows_per_layer = rect->h;
+    dst.pixels_per_row = rect->w;
+
+    SDL_DownloadFromGPUTexture(pass, &src, &dst);
+    SDL_EndGPUCopyPass(pass);
+
+    SDL_GPUFence *fence = SDL_SubmitGPUCommandBufferAndAcquireFence(data->state.command_buffer);
+    SDL_WaitForGPUFences(data->device, true, &fence, 1);
+    SDL_ReleaseGPUFence(data->device, fence);
+    data->state.command_buffer = SDL_AcquireGPUCommandBuffer(data->device);
+
+    void *mapped_tbuf = SDL_MapGPUTransferBuffer(data->device, tbuf, false);
+
+    if ((size_t)surface->pitch == row_size) {
+        SDL_memcpy(surface->pixels, mapped_tbuf, image_size);
+    } else {
+        Uint8 *input = mapped_tbuf;
+        Uint8 *output = surface->pixels;
+
+        for (int row = 0; row < rect->h; ++row) {
+            SDL_memcpy(output, input, row_size);
+            output += surface->pitch;
+            input += row_size;
+        }
+    }
+
+    SDL_UnmapGPUTransferBuffer(data->device, tbuf);
+    SDL_ReleaseGPUTransferBuffer(data->device, tbuf);
+
+    return surface;
+}
+
+static bool CreateBackbuffer(GPU_RenderData *data, Uint32 w, Uint32 h, SDL_GPUTextureFormat fmt)
+{
+    SDL_GPUTextureCreateInfo tci;
+    SDL_zero(tci);
+    tci.width = w;
+    tci.height = h;
+    tci.format = fmt;
+    tci.layer_count_or_depth = 1;
+    tci.num_levels = 1;
+    tci.sample_count = SDL_GPU_SAMPLECOUNT_1;
+    tci.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER;
+
+    data->backbuffer.texture = SDL_CreateGPUTexture(data->device, &tci);
+    data->backbuffer.width = w;
+    data->backbuffer.height = h;
+    data->backbuffer.format = fmt;
+
+    if (!data->backbuffer.texture) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool GPU_RenderPresent(SDL_Renderer *renderer)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+
+    SDL_GPUTexture *swapchain;
+    Uint32 swapchain_texture_width, swapchain_texture_height;
+    bool result = SDL_WaitAndAcquireGPUSwapchainTexture(data->state.command_buffer, renderer->window, &swapchain, &swapchain_texture_width, &swapchain_texture_height);
+
+    if (!result) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Failed to acquire swapchain texture: %s", SDL_GetError());
+    }
+
+    if (swapchain != NULL) {
+        SDL_GPUBlitInfo blit_info;
+        SDL_zero(blit_info);
+
+        blit_info.source.texture = data->backbuffer.texture;
+        blit_info.source.w = data->backbuffer.width;
+        blit_info.source.h = data->backbuffer.height;
+        blit_info.destination.texture = swapchain;
+        blit_info.destination.w = swapchain_texture_width;
+        blit_info.destination.h = swapchain_texture_height;
+        blit_info.load_op = SDL_GPU_LOADOP_DONT_CARE;
+        blit_info.filter = SDL_GPU_FILTER_LINEAR;
+
+        SDL_BlitGPUTexture(data->state.command_buffer, &blit_info);
+
+        SDL_SubmitGPUCommandBuffer(data->state.command_buffer);
+
+        if (swapchain_texture_width != data->backbuffer.width || swapchain_texture_height != data->backbuffer.height) {
+            SDL_ReleaseGPUTexture(data->device, data->backbuffer.texture);
+            CreateBackbuffer(data, swapchain_texture_width, swapchain_texture_height, SDL_GetGPUSwapchainTextureFormat(data->device, renderer->window));
+        }
+    } else {
+        SDL_SubmitGPUCommandBuffer(data->state.command_buffer);
+    }
+
+    data->state.command_buffer = SDL_AcquireGPUCommandBuffer(data->device);
+
+    return true;
+}
+
+static void GPU_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GPU_RenderData *renderdata = (GPU_RenderData *)renderer->internal;
+    GPU_TextureData *data = (GPU_TextureData *)texture->internal;
+
+    if (renderdata->state.render_target == texture) {
+        renderdata->state.render_target = NULL;
+    }
+
+    if (!data) {
+        return;
+    }
+
+    SDL_ReleaseGPUTexture(renderdata->device, data->texture);
+    SDL_free(data->pixels);
+    SDL_free(data);
+    texture->internal = NULL;
+}
+
+static void GPU_DestroyRenderer(SDL_Renderer *renderer)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+
+    if (!data) {
+        return;
+    }
+
+    if (data->state.command_buffer) {
+        SDL_SubmitGPUCommandBuffer(data->state.command_buffer);
+        data->state.command_buffer = NULL;
+    }
+
+    for (Uint32 i = 0; i < sizeof(data->samplers) / sizeof(SDL_GPUSampler *); ++i) {
+        SDL_ReleaseGPUSampler(data->device, ((SDL_GPUSampler **)data->samplers)[i]);
+    }
+
+    if (data->backbuffer.texture) {
+        SDL_ReleaseGPUTexture(data->device, data->backbuffer.texture);
+    }
+
+    if (renderer->window) {
+        SDL_ReleaseWindowFromGPUDevice(data->device, renderer->window);
+    }
+
+    ReleaseVertexBuffer(data);
+    GPU_DestroyPipelineCache(&data->pipeline_cache);
+    GPU_ReleaseShaders(&data->shaders, data->device);
+    SDL_DestroyGPUDevice(data->device);
+
+    SDL_free(data);
+}
+
+static bool ChoosePresentMode(SDL_GPUDevice *device, SDL_Window *window, const int vsync, SDL_GPUPresentMode *out_mode)
+{
+    SDL_GPUPresentMode mode;
+
+    switch (vsync) {
+    case 0:
+        mode = SDL_GPU_PRESENTMODE_MAILBOX;
+
+        if (!SDL_WindowSupportsGPUPresentMode(device, window, mode)) {
+            mode = SDL_GPU_PRESENTMODE_IMMEDIATE;
+
+            if (!SDL_WindowSupportsGPUPresentMode(device, window, mode)) {
+                mode = SDL_GPU_PRESENTMODE_VSYNC;
+            }
+        }
+
+        // FIXME should we return an error if both mailbox and immediate fail?
+        break;
+
+    case 1:
+        mode = SDL_GPU_PRESENTMODE_VSYNC;
+        break;
+
+    default:
+        return SDL_Unsupported();
+    }
+
+    *out_mode = mode;
+    return true;
+}
+
+static bool GPU_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    GPU_RenderData *data = (GPU_RenderData *)renderer->internal;
+    SDL_GPUPresentMode mode = SDL_GPU_PRESENTMODE_VSYNC;
+
+    if (!ChoosePresentMode(data->device, renderer->window, vsync, &mode)) {
+        return false;
+    }
+
+    if (mode != data->swapchain.present_mode) {
+        // XXX returns bool instead of SDL-style error code
+        if (SDL_SetGPUSwapchainParameters(data->device, renderer->window, data->swapchain.composition, mode)) {
+            data->swapchain.present_mode = mode;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool InitSamplers(GPU_RenderData *data)
+{
+    struct
+    {
+        struct
+        {
+            SDL_TextureAddressMode address_mode;
+            SDL_ScaleMode scale_mode;
+        } sdl;
+        struct
+        {
+            SDL_GPUSamplerAddressMode address_mode;
+            SDL_GPUFilter filter;
+            SDL_GPUSamplerMipmapMode mipmap_mode;
+            Uint32 anisotropy;
+        } gpu;
+    } configs[] = {
+        {
+            { SDL_TEXTURE_ADDRESS_CLAMP, SDL_SCALEMODE_NEAREST },
+            { SDL_GPU_SAMPLERADDRESSMODE_REPEAT, SDL_GPU_FILTER_NEAREST, SDL_GPU_SAMPLERMIPMAPMODE_NEAREST, 0 },
+        },
+        {
+            { SDL_TEXTURE_ADDRESS_CLAMP, SDL_SCALEMODE_LINEAR },
+            { SDL_GPU_SAMPLERADDRESSMODE_REPEAT, SDL_GPU_FILTER_LINEAR, SDL_GPU_SAMPLERMIPMAPMODE_LINEAR, 0 },
+        },
+        {
+            { SDL_TEXTURE_ADDRESS_WRAP, SDL_SCALEMODE_NEAREST },
+            { SDL_GPU_SAMPLERADDRESSMODE_REPEAT, SDL_GPU_FILTER_NEAREST, SDL_GPU_SAMPLERMIPMAPMODE_NEAREST, 0 },
+        },
+        {
+            { SDL_TEXTURE_ADDRESS_WRAP, SDL_SCALEMODE_LINEAR },
+            { SDL_GPU_SAMPLERADDRESSMODE_REPEAT, SDL_GPU_FILTER_LINEAR, SDL_GPU_SAMPLERMIPMAPMODE_LINEAR, 0 },
+        },
+    };
+
+    for (Uint32 i = 0; i < SDL_arraysize(configs); ++i) {
+        SDL_GPUSamplerCreateInfo sci;
+        SDL_zero(sci);
+        sci.max_anisotropy = configs[i].gpu.anisotropy;
+        sci.enable_anisotropy = configs[i].gpu.anisotropy > 0;
+        sci.address_mode_u = sci.address_mode_v = sci.address_mode_w = configs[i].gpu.address_mode;
+        sci.min_filter = sci.mag_filter = configs[i].gpu.filter;
+        sci.mipmap_mode = configs[i].gpu.mipmap_mode;
+
+        SDL_GPUSampler *sampler = SDL_CreateGPUSampler(data->device, &sci);
+
+        if (sampler == NULL) {
+            return false;
+        }
+
+        *SamplerPointer(data, configs[i].sdl.address_mode, configs[i].sdl.scale_mode) = sampler;
+    }
+
+    return true;
+}
+
+static bool GPU_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    GPU_RenderData *data = NULL;
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        // TODO
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (GPU_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    renderer->SupportsBlendMode = GPU_SupportsBlendMode;
+    renderer->CreateTexture = GPU_CreateTexture;
+    renderer->UpdateTexture = GPU_UpdateTexture;
+    renderer->LockTexture = GPU_LockTexture;
+    renderer->UnlockTexture = GPU_UnlockTexture;
+    renderer->SetTextureScaleMode = GPU_SetTextureScaleMode;
+    renderer->SetRenderTarget = GPU_SetRenderTarget;
+    renderer->QueueSetViewport = GPU_QueueNoOp;
+    renderer->QueueSetDrawColor = GPU_QueueNoOp;
+    renderer->QueueDrawPoints = GPU_QueueDrawPoints;
+    renderer->QueueDrawLines = GPU_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueGeometry = GPU_QueueGeometry;
+    renderer->InvalidateCachedState = GPU_InvalidateCachedState;
+    renderer->RunCommandQueue = GPU_RunCommandQueue;
+    renderer->RenderReadPixels = GPU_RenderReadPixels;
+    renderer->RenderPresent = GPU_RenderPresent;
+    renderer->DestroyTexture = GPU_DestroyTexture;
+    renderer->DestroyRenderer = GPU_DestroyRenderer;
+    renderer->SetVSync = GPU_SetVSync;
+    renderer->internal = data;
+    renderer->window = window;
+    renderer->name = GPU_RenderDriver.name;
+
+    bool debug = SDL_GetBooleanProperty(create_props, SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN, false);
+    bool lowpower = SDL_GetBooleanProperty(create_props, SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN, false);
+
+    // Prefer environment variables/hints if they exist, otherwise defer to properties
+    debug = SDL_GetHintBoolean(SDL_HINT_RENDER_GPU_DEBUG, debug);
+    lowpower = SDL_GetHintBoolean(SDL_HINT_RENDER_GPU_LOW_POWER, lowpower);
+
+    SDL_SetBooleanProperty(create_props, SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN, debug);
+    SDL_SetBooleanProperty(create_props, SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN, lowpower);
+
+    GPU_FillSupportedShaderFormats(create_props);
+    data->device = SDL_CreateGPUDeviceWithProperties(create_props);
+
+    if (!data->device) {
+        return false;
+    }
+
+    if (!GPU_InitShaders(&data->shaders, data->device)) {
+        return false;
+    }
+
+    if (!GPU_InitPipelineCache(&data->pipeline_cache, data->device)) {
+        return false;
+    }
+
+    // XXX what's a good initial size?
+    if (!InitVertexBuffer(data, 1 << 16)) {
+        return false;
+    }
+
+    if (!InitSamplers(data)) {
+        return false;
+    }
+
+    if (!SDL_ClaimWindowForGPUDevice(data->device, window)) {
+        return false;
+    }
+
+    data->swapchain.composition = SDL_GPU_SWAPCHAINCOMPOSITION_SDR;
+    data->swapchain.present_mode = SDL_GPU_PRESENTMODE_VSYNC;
+
+    int vsync = (int)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0);
+    ChoosePresentMode(data->device, window, vsync, &data->swapchain.present_mode);
+
+    SDL_SetGPUSwapchainParameters(data->device, window, data->swapchain.composition, data->swapchain.present_mode);
+
+    SDL_SetGPUAllowedFramesInFlight(data->device, 1);
+
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRA32);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA32);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRX32);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBX32);
+
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
+
+    data->state.draw_color.r = 1.0f;
+    data->state.draw_color.g = 1.0f;
+    data->state.draw_color.b = 1.0f;
+    data->state.draw_color.a = 1.0f;
+    data->state.viewport.min_depth = 0;
+    data->state.viewport.max_depth = 1;
+    data->state.command_buffer = SDL_AcquireGPUCommandBuffer(data->device);
+
+    int w, h;
+    SDL_GetWindowSizeInPixels(window, &w, &h);
+
+    if (!CreateBackbuffer(data, w, h, SDL_GetGPUSwapchainTextureFormat(data->device, window))) {
+        return false;
+    }
+
+    SDL_SetPointerProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_GPU_DEVICE_POINTER, data->device);
+
+    return true;
+}
+
+SDL_RenderDriver GPU_RenderDriver = {
+    GPU_CreateRenderer, "gpu"
+};
+
+#endif // SDL_VIDEO_RENDER_GPU
diff --git a/SDL-3.2.8/src/render/gpu/SDL_shaders_gpu.c b/SDL-3.2.8/src/render/gpu/SDL_shaders_gpu.c
new file mode 100644
index 0000000..a56fb0c
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/SDL_shaders_gpu.c
@@ -0,0 +1,232 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_GPU
+
+#include "SDL_shaders_gpu.h"
+
+// SDL_GPU shader implementation
+
+typedef struct GPU_ShaderModuleSource
+{
+    const unsigned char *code;
+    unsigned int code_len;
+    SDL_GPUShaderFormat format;
+} GPU_ShaderModuleSource;
+
+#if defined(SDL_GPU_VULKAN) && SDL_GPU_VULKAN
+#define IF_VULKAN(...)     __VA_ARGS__
+#define HAVE_SPIRV_SHADERS 1
+#include "shaders/spir-v.h"
+#else
+#define IF_VULKAN(...)
+#define HAVE_SPIRV_SHADERS 0
+#endif
+
+#ifdef SDL_GPU_D3D12
+#define IF_D3D12(...)       __VA_ARGS__
+#define HAVE_DXIL60_SHADERS 1
+#include "shaders/dxil60.h"
+#else
+#define IF_D3D12(...)
+#define HAVE_DXIL60_SHADERS 0
+#endif
+
+#ifdef SDL_GPU_METAL
+#define IF_METAL(...)      __VA_ARGS__
+#define HAVE_METAL_SHADERS 1
+#include "shaders/metal.h"
+#else
+#define IF_METAL(...)
+#define HAVE_METAL_SHADERS 0
+#endif
+
+typedef struct GPU_ShaderSources
+{
+    IF_VULKAN(GPU_ShaderModuleSource spirv;)
+    IF_D3D12(GPU_ShaderModuleSource dxil60;)
+    IF_METAL(GPU_ShaderModuleSource msl;)
+    unsigned int num_samplers;
+    unsigned int num_uniform_buffers;
+} GPU_ShaderSources;
+
+#define SHADER_SPIRV(code) \
+    IF_VULKAN(.spirv = { code, sizeof(code), SDL_GPU_SHADERFORMAT_SPIRV }, )
+
+#define SHADER_DXIL60(code) \
+    IF_D3D12(.dxil60 = { code, sizeof(code), SDL_GPU_SHADERFORMAT_DXIL }, )
+
+#define SHADER_METAL(code) \
+    IF_METAL(.msl = { code, sizeof(code), SDL_GPU_SHADERFORMAT_MSL }, )
+
+// clang-format off
+static const GPU_ShaderSources vert_shader_sources[NUM_VERT_SHADERS] = {
+    [VERT_SHADER_LINEPOINT] = {
+        .num_samplers = 0,
+        .num_uniform_buffers = 1,
+        SHADER_SPIRV(linepoint_vert_spv)
+        SHADER_DXIL60(linepoint_vert_sm60_dxil)
+        SHADER_METAL(linepoint_vert_metal)
+    },
+    [VERT_SHADER_TRI_COLOR] = {
+        .num_samplers = 0,
+        .num_uniform_buffers = 1,
+        SHADER_SPIRV(tri_color_vert_spv)
+        SHADER_DXIL60(tri_color_vert_sm60_dxil)
+        SHADER_METAL(tri_color_vert_metal)
+    },
+    [VERT_SHADER_TRI_TEXTURE] = {
+        .num_samplers = 0,
+        .num_uniform_buffers = 1,
+        SHADER_SPIRV(tri_texture_vert_spv)
+        SHADER_DXIL60(tri_texture_vert_sm60_dxil)
+        SHADER_METAL(tri_texture_vert_metal)
+    },
+};
+
+static const GPU_ShaderSources frag_shader_sources[NUM_FRAG_SHADERS] = {
+    [FRAG_SHADER_COLOR] = {
+        .num_samplers = 0,
+        .num_uniform_buffers = 0,
+        SHADER_SPIRV(color_frag_spv)
+        SHADER_DXIL60(color_frag_sm60_dxil)
+        SHADER_METAL(color_frag_metal)
+    },
+    [FRAG_SHADER_TEXTURE_RGB] = {
+        .num_samplers = 1,
+        .num_uniform_buffers = 0,
+        SHADER_SPIRV(texture_rgb_frag_spv)
+        SHADER_DXIL60(texture_rgb_frag_sm60_dxil)
+        SHADER_METAL(texture_rgb_frag_metal)
+    },
+    [FRAG_SHADER_TEXTURE_RGBA] = {
+        .num_samplers = 1,
+        .num_uniform_buffers = 0,
+        SHADER_SPIRV(texture_rgba_frag_spv)
+        SHADER_DXIL60(texture_rgba_frag_sm60_dxil)
+        SHADER_METAL(texture_rgba_frag_metal)
+    },
+};
+// clang-format on
+
+static SDL_GPUShader *CompileShader(const GPU_ShaderSources *sources, SDL_GPUDevice *device, SDL_GPUShaderStage stage)
+{
+    const GPU_ShaderModuleSource *sms = NULL;
+    SDL_GPUShaderFormat formats = SDL_GetGPUShaderFormats(device);
+
+    if (formats == SDL_GPU_SHADERFORMAT_INVALID) {
+        // SDL_GetGPUShaderFormats already set the error
+        return NULL;
+#if HAVE_SPIRV_SHADERS
+    } else if (formats & SDL_GPU_SHADERFORMAT_SPIRV) {
+        sms = &sources->spirv;
+#endif // HAVE_SPIRV_SHADERS
+#if HAVE_DXIL60_SHADERS
+    } else if (formats & SDL_GPU_SHADERFORMAT_DXIL) {
+        sms = &sources->dxil60;
+#endif // HAVE_DXIL60_SHADERS
+#if HAVE_METAL_SHADERS
+    } else if (formats & SDL_GPU_SHADERFORMAT_MSL) {
+        sms = &sources->msl;
+#endif // HAVE_METAL_SHADERS
+    } else {
+        SDL_SetError("Unsupported GPU backend");
+        return NULL;
+    }
+
+    SDL_GPUShaderCreateInfo sci = { 0 };
+    sci.code = sms->code;
+    sci.code_size = sms->code_len;
+    sci.format = sms->format;
+    // FIXME not sure if this is correct
+    sci.entrypoint =
+#if HAVE_METAL_SHADERS
+        (sms == &sources->msl) ? "main0" :
+#endif // HAVE_METAL_SHADERS
+        "main";
+    sci.num_samplers = sources->num_samplers;
+    sci.num_uniform_buffers = sources->num_uniform_buffers;
+    sci.stage = stage;
+
+    return SDL_CreateGPUShader(device, &sci);
+}
+
+bool GPU_InitShaders(GPU_Shaders *shaders, SDL_GPUDevice *device)
+{
+    for (int i = 0; i < SDL_arraysize(vert_shader_sources); ++i) {
+        shaders->vert_shaders[i] = CompileShader(
+            &vert_shader_sources[i], device, SDL_GPU_SHADERSTAGE_VERTEX);
+        if (shaders->vert_shaders[i] == NULL) {
+            GPU_ReleaseShaders(shaders, device);
+            return false;
+        }
+    }
+
+    for (int i = 0; i < SDL_arraysize(frag_shader_sources); ++i) {
+        shaders->frag_shaders[i] = CompileShader(
+            &frag_shader_sources[i], device, SDL_GPU_SHADERSTAGE_FRAGMENT);
+        if (shaders->frag_shaders[i] == NULL) {
+            GPU_ReleaseShaders(shaders, device);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void GPU_ReleaseShaders(GPU_Shaders *shaders, SDL_GPUDevice *device)
+{
+    for (int i = 0; i < SDL_arraysize(shaders->vert_shaders); ++i) {
+        SDL_ReleaseGPUShader(device, shaders->vert_shaders[i]);
+        shaders->vert_shaders[i] = NULL;
+    }
+
+    for (int i = 0; i < SDL_arraysize(shaders->frag_shaders); ++i) {
+        SDL_ReleaseGPUShader(device, shaders->frag_shaders[i]);
+        shaders->frag_shaders[i] = NULL;
+    }
+}
+
+SDL_GPUShader *GPU_GetVertexShader(GPU_Shaders *shaders, GPU_VertexShaderID id)
+{
+    SDL_assert((unsigned int)id < SDL_arraysize(shaders->vert_shaders));
+    SDL_GPUShader *shader = shaders->vert_shaders[id];
+    SDL_assert(shader != NULL);
+    return shader;
+}
+
+SDL_GPUShader *GPU_GetFragmentShader(GPU_Shaders *shaders, GPU_FragmentShaderID id)
+{
+    SDL_assert((unsigned int)id < SDL_arraysize(shaders->frag_shaders));
+    SDL_GPUShader *shader = shaders->frag_shaders[id];
+    SDL_assert(shader != NULL);
+    return shader;
+}
+
+void GPU_FillSupportedShaderFormats(SDL_PropertiesID props)
+{
+    SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN, HAVE_SPIRV_SHADERS);
+    SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN, HAVE_DXIL60_SHADERS);
+    SDL_SetBooleanProperty(props, SDL_PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN, HAVE_METAL_SHADERS);
+}
+
+#endif // SDL_VIDEO_RENDER_GPU
diff --git a/SDL-3.2.8/src/render/gpu/SDL_shaders_gpu.h b/SDL-3.2.8/src/render/gpu/SDL_shaders_gpu.h
new file mode 100644
index 0000000..16b5a11
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/SDL_shaders_gpu.h
@@ -0,0 +1,63 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_shaders_gpu_h_
+#define SDL_shaders_gpu_h_
+
+#include "SDL_internal.h"
+
+// SDL_GPU shader implementation
+
+typedef enum
+{
+    VERT_SHADER_INVALID = -1,
+    VERT_SHADER_LINEPOINT,
+    VERT_SHADER_TRI_COLOR,
+    VERT_SHADER_TRI_TEXTURE,
+
+    NUM_VERT_SHADERS,
+} GPU_VertexShaderID;
+
+typedef enum
+{
+    FRAG_SHADER_INVALID = -1,
+    FRAG_SHADER_COLOR,
+    FRAG_SHADER_TEXTURE_RGB,
+    FRAG_SHADER_TEXTURE_RGBA,
+
+    NUM_FRAG_SHADERS,
+} GPU_FragmentShaderID;
+
+struct GPU_Shaders
+{
+    SDL_GPUShader *vert_shaders[NUM_VERT_SHADERS];
+    SDL_GPUShader *frag_shaders[NUM_FRAG_SHADERS];
+};
+
+typedef struct GPU_Shaders GPU_Shaders;
+
+void GPU_FillSupportedShaderFormats(SDL_PropertiesID props);
+extern bool GPU_InitShaders(GPU_Shaders *shaders, SDL_GPUDevice *device);
+extern void GPU_ReleaseShaders(GPU_Shaders *shaders, SDL_GPUDevice *device);
+extern SDL_GPUShader *GPU_GetVertexShader(GPU_Shaders *shaders, GPU_VertexShaderID id);
+extern SDL_GPUShader *GPU_GetFragmentShader(GPU_Shaders *shaders, GPU_FragmentShaderID id);
+
+#endif // SDL_shaders_gpu_h_
diff --git a/SDL-3.2.8/src/render/gpu/shaders/.gitattributes b/SDL-3.2.8/src/render/gpu/shaders/.gitattributes
new file mode 100644
index 0000000..4689bbb
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/.gitattributes
@@ -0,0 +1 @@
+*.h linguist-generated
diff --git a/SDL-3.2.8/src/render/gpu/shaders/.gitignore b/SDL-3.2.8/src/render/gpu/shaders/.gitignore
new file mode 100644
index 0000000..2741428
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/.gitignore
@@ -0,0 +1,4 @@
+*.hlsl
+*.metal
+*.spv
+*.tmp.h
diff --git a/SDL-3.2.8/src/render/gpu/shaders/build-shaders.sh b/SDL-3.2.8/src/render/gpu/shaders/build-shaders.sh
new file mode 100755
index 0000000..9b019e5
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/build-shaders.sh
@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+
+set -e
+
+# NOTE: fxc is tested on Linux with https://github.com/mozilla/fxc2
+
+which fxc &>/dev/null && HAVE_FXC=1 || HAVE_FXC=0
+which dxc &>/dev/null && HAVE_DXC=1 || HAVE_DXC=0
+which spirv-cross &>/dev/null && HAVE_SPIRV_CROSS=1 || HAVE_SPIRV_CROSS=0
+
+[ "$HAVE_FXC" != 0 ] || echo "fxc not in PATH; D3D11 shaders will not be rebuilt"
+[ "$HAVE_DXC" != 0 ] || echo "dxc not in PATH; D3D12 shaders will not be rebuilt"
+[ "$HAVE_SPIRV_CROSS" != 0 ] || echo "spirv-cross not in PATH; D3D11, D3D12, Metal shaders will not be rebuilt"
+
+USE_FXC=${USE_FXC:-$HAVE_FXC}
+USE_DXC=${USE_DXC:-$HAVE_DXC}
+USE_SPIRV_CROSS=${USE_SPIRV_CROSS:-$HAVE_SPIRV_CROSS}
+
+spirv_bundle="spir-v.h"
+dxbc50_bundle="dxbc50.h"
+dxil60_bundle="dxil60.h"
+metal_bundle="metal.h"
+
+rm -f "$spirv_bundle"
+[ "$USE_SPIRV_CROSS" != 0 ] && rm -f "$metal_bundle"
+[ "$USE_SPIRV_CROSS" != 0 ] && [ "$USE_FXC" != 0 ] && rm -f "$dxbc50_bundle"
+[ "$USE_SPIRV_CROSS" != 0 ] && [ "$USE_DXC" != 0 ] && rm -f "$dxil60_bundle"
+
+make-header() {
+    xxd -i "$1" | sed \
+        -e 's/^unsigned /const unsigned /g' \
+        -e 's,^const,static const,' \
+        > "$1.h"
+}
+
+compile-hlsl-dxbc() {
+    local src="$1"
+    local profile="$2"
+    local output_basename="$3"
+    local var_name="$(echo "$output_basename" | sed -e 's/\./_/g')"
+
+    fxc "$src" /E main /T $2 /Fh "$output_basename.tmp.h" || exit $?
+    sed \
+        -e "s/g_main/$var_name/;s/\r//g" \
+        -e 's,^const,static const,' \
+        -e 's,const unsigned,const signed,' \
+        < "$output_basename.tmp.h" \
+        > "$output_basename.h"
+    rm -f "$output_basename.tmp.h"
+}
+
+compile-hlsl-dxil() {
+    local src="$1"
+    local profile="$2"
+    local output_basename="$3"
+    local var_name="$(echo "$output_basename" | sed -e 's/\./_/g')"
+
+    dxc "$src" -E main -T $2 -Fh "$output_basename.tmp.h" -O3 || exit $?
+    sed \
+        -e "s/g_main/$var_name/;s/\r//g" \
+        -e 's,^const,static const,' \
+        < "$output_basename.tmp.h" \
+        > "$output_basename.h"
+    rm -f "$output_basename.tmp.h"
+}
+
+for i in *.vert *.frag; do
+    spv="$i.spv"
+    metal="$i.metal"
+    hlsl50="$i.sm50.hlsl"
+    dxbc50="$i.sm50.dxbc"
+    hlsl60="$i.sm60.hlsl"
+    dxil60="$i.sm60.dxil"
+
+    glslangValidator -g0 -Os "$i" -V -o "$spv" --quiet
+
+    make-header "$spv"
+    echo "#include \"$spv.h\"" >> "$spirv_bundle"
+
+    if [ "$USE_SPIRV_CROSS" = "0" ]; then
+        continue
+    fi
+
+    spirv-cross "$spv" --hlsl --shader-model 50 --hlsl-enable-compat --output "$hlsl50"
+    spirv-cross "$spv" --hlsl --shader-model 60 --hlsl-enable-compat --output "$hlsl60"
+
+    if [ "${i##*.}" == "frag" ]; then
+        hlsl_stage="ps"
+    else
+        hlsl_stage="vs"
+    fi
+
+    if [ "$USE_FXC" != "0" ]; then
+        compile-hlsl-dxbc "$hlsl50" ${hlsl_stage}_5_0 "$dxbc50"
+        echo "#include \"$dxbc50.h\"" >> "$dxbc50_bundle"
+    fi
+
+    if [ "$USE_DXC" != "0" ]; then
+        compile-hlsl-dxil "$hlsl60" ${hlsl_stage}_6_0 "$dxil60"
+        echo "#include \"$dxil60.h\"" >> "$dxil60_bundle"
+    fi
+
+    spirv-cross "$spv" --msl --output "$metal"
+    make-header "$metal"
+    echo "#include \"$metal.h\"" >> "$metal_bundle"
+done
diff --git a/SDL-3.2.8/src/render/gpu/shaders/color.frag b/SDL-3.2.8/src/render/gpu/shaders/color.frag
new file mode 100644
index 0000000..8ce1e6b
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/color.frag
@@ -0,0 +1,9 @@
+#version 450
+
+layout(location = 0) in vec4 v_color;
+
+layout(location = 0) out vec4 o_color;
+
+void main() {
+    o_color = v_color;
+}
diff --git a/SDL-3.2.8/src/render/gpu/shaders/color.frag.metal.h b/SDL-3.2.8/src/render/gpu/shaders/color.frag.metal.h
new file mode 100644
index 0000000..a5f9899
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/color.frag.metal.h
@@ -0,0 +1,28 @@
+static const unsigned char color_frag_metal[] = {
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x3e, 0x0a,
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x69,
+  0x6d, 0x64, 0x2f, 0x73, 0x69, 0x6d, 0x64, 0x2e, 0x68, 0x3e, 0x0a, 0x0a,
+  0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x3b, 0x0a, 0x0a,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30,
+  0x5f, 0x6f, 0x75, 0x74, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x39, 0x20, 0x5b, 0x5b,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a,
+  0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d,
+  0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x0a, 0x7b, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x31,
+  0x31, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72, 0x28, 0x6c, 0x6f, 0x63,
+  0x6e, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e,
+  0x30, 0x5f, 0x6f, 0x75, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x28,
+  0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x20, 0x69, 0x6e, 0x20,
+  0x5b, 0x5b, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x5d, 0x5d,
+  0x29, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x61, 0x69, 0x6e,
+  0x30, 0x5f, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20,
+  0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e,
+  0x6d, 0x5f, 0x39, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x2e, 0x6d, 0x5f, 0x31,
+  0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
+  0x6e, 0x20, 0x6f, 0x75, 0x74, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a
+};
+static const unsigned int color_frag_metal_len = 298;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/color.frag.sm50.dxbc.h b/SDL-3.2.8/src/render/gpu/shaders/color.frag.sm50.dxbc.h
new file mode 100644
index 0000000..ddd8012
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/color.frag.sm50.dxbc.h
@@ -0,0 +1,85 @@
+static const signed char color_frag_sm50_dxbc[] =
+{
+  68,  88,  66,  67, 114,-117,
+-124,  82, -97,  76, -66, -74,
+  70, 116,  14, -14,  95,-122,
+  65,  73,   1,   0,   0,   0,
+ -24,   1,   0,   0,   5,   0,
+   0,   0,  52,   0,   0,   0,
+ -96,   0,   0,   0, -44,   0,
+   0,   0,   8,   1,   0,   0,
+  76,   1,   0,   0,  82,  68,
+  69,  70, 100,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+  60,   0,   0,   0,   0,   5,
+  -1,  -1,   0,   1,   0,   0,
+  60,   0,   0,   0,  82,  68,
+  49,  49,  60,   0,   0,   0,
+  24,   0,   0,   0,  32,   0,
+   0,   0,  40,   0,   0,   0,
+  36,   0,   0,   0,  12,   0,
+   0,   0,   0,   0,   0,   0,
+  77, 105,  99, 114, 111, 115,
+ 111, 102, 116,  32,  40,  82,
+  41,  32,  72,  76,  83,  76,
+  32,  83, 104,  97, 100, 101,
+ 114,  32,  67, 111, 109, 112,
+ 105, 108, 101, 114,  32,  49,
+  48,  46,  49,   0,  73,  83,
+  71,  78,  44,   0,   0,   0,
+   1,   0,   0,   0,   8,   0,
+   0,   0,  32,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+   0,   0,   0,   0,  15,  15,
+   0,   0,  84,  69,  88,  67,
+  79,  79,  82,  68,   0, -85,
+ -85, -85,  79,  83,  71,  78,
+  44,   0,   0,   0,   1,   0,
+   0,   0,   8,   0,   0,   0,
+  32,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,  15,   0,   0,   0,
+  83,  86,  95,  84,  97, 114,
+ 103, 101, 116,   0, -85, -85,
+  83,  72,  69,  88,  60,   0,
+   0,   0,  80,   0,   0,   0,
+  15,   0,   0,   0, 106,   8,
+   0,   1,  98,  16,   0,   3,
+ -14,  16,  16,   0,   0,   0,
+   0,   0, 101,   0,   0,   3,
+ -14,  32,  16,   0,   0,   0,
+   0,   0,  54,   0,   0,   5,
+ -14,  32,  16,   0,   0,   0,
+   0,   0,  70,  30,  16,   0,
+   0,   0,   0,   0,  62,   0,
+   0,   1,  83,  84,  65,  84,
+-108,   0,   0,   0,   2,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   2,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/color.frag.sm60.dxil.h b/SDL-3.2.8/src/render/gpu/shaders/color.frag.sm60.dxil.h
new file mode 100644
index 0000000..f8d2a1c
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/color.frag.sm60.dxil.h
@@ -0,0 +1,340 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xyzw        0     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Target                0   xyzw        0   TARGET   float   xyzw
+;
+; shader hash: 79268435b7929fdbc9f529459f44b878
+;
+; Pipeline Runtime Information: 
+;
+; Pixel Shader
+; DepthOutput=0
+; SampleFrequency=0
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                 linear       
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Target                0                              
+;
+; Buffer Definitions:
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+;
+;
+; ViewId state:
+;
+; Number of inputs: 4, outputs: 4
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 0 }
+;   output 1 depends on inputs: { 1 }
+;   output 2 depends on inputs: { 2 }
+;   output 3 depends on inputs: { 3 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+define void @main() {
+  %1 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %1)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %2)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %3)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %4)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.viewIdState = !{!4}
+!dx.entryPoints = !{!5}
+
+!0 = !{!"dxc(private) 1.8.0.4662 (416fab6b5)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 8}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{[6 x i32] [i32 4, i32 4, i32 1, i32 2, i32 4, i32 8]}
+!5 = !{void ()* @main, !"main", !6, null, null}
+!6 = !{!7, !11, null}
+!7 = !{!8}
+!8 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !9, i8 2, i32 1, i8 4, i32 0, i8 0, !10}
+!9 = !{i32 0}
+!10 = !{i32 3, i32 15}
+!11 = !{!12}
+!12 = !{i32 0, !"SV_Target", i8 9, i8 16, !9, i8 0, i32 1, i8 4, i32 0, i8 0, !10}
+
+#endif
+
+static const unsigned char color_frag_sm60_dxil[] = {
+  0x44, 0x58, 0x42, 0x43, 0x33, 0x91, 0x9f, 0xec, 0x78, 0x7d, 0xbb, 0xfa,
+  0xeb, 0x8d, 0xfb, 0x1b, 0x79, 0x47, 0x1d, 0xb2, 0x01, 0x00, 0x00, 0x00,
+  0x0c, 0x0b, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00,
+  0x58, 0x01, 0x00, 0x00, 0x10, 0x06, 0x00, 0x00, 0x2c, 0x06, 0x00, 0x00,
+  0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31, 0x34, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44,
+  0x00, 0x00, 0x00, 0x00, 0x4f, 0x53, 0x47, 0x31, 0x34, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65,
+  0x74, 0x00, 0x00, 0x00, 0x50, 0x53, 0x56, 0x30, 0x8c, 0x00, 0x00, 0x00,
+  0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x10,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54,
+  0xb0, 0x04, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
+  0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x98, 0x04, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
+  0x23, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0x84, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0xe4, 0x48, 0x0e, 0x90, 0x11, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x21, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x01, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x82, 0x60, 0x42, 0x20, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x30, 0x23, 0x00,
+  0x25, 0x00, 0x8a, 0x19, 0x80, 0x39, 0x02, 0x30, 0x98, 0x23, 0x40, 0x8a,
+  0x31, 0x44, 0x54, 0x44, 0x56, 0x0c, 0x20, 0xa2, 0x1a, 0xc2, 0x81, 0x80,
+  0x34, 0x20, 0x00, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87,
+  0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50,
+  0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86,
+  0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xc8, 0x02, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xa2,
+  0x12, 0x18, 0x01, 0x28, 0x86, 0x32, 0x28, 0x8f, 0x92, 0x28, 0x04, 0xaa,
+  0x92, 0x18, 0x01, 0x28, 0x82, 0x42, 0x28, 0x10, 0xda, 0xb1, 0x0c, 0x82,
+  0x08, 0x04, 0x02, 0x01, 0x79, 0x18, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00,
+  0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b,
+  0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71,
+  0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89,
+  0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0x62, 0x98, 0x20, 0x10, 0xc4, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04,
+  0x41, 0x01, 0x6e, 0x6e, 0x82, 0x40, 0x14, 0x1b, 0x86, 0x03, 0x21, 0x26,
+  0x08, 0x02, 0xb0, 0x01, 0xd8, 0x30, 0x10, 0xcb, 0xb2, 0x21, 0x60, 0x36,
+  0x0c, 0x83, 0xd2, 0x4c, 0x10, 0x96, 0x67, 0x43, 0xf0, 0x90, 0x68, 0x0b,
+  0x4b, 0x73, 0x23, 0x42, 0x55, 0x84, 0x35, 0xf4, 0xf4, 0x24, 0x45, 0x34,
+  0x41, 0x28, 0x94, 0x09, 0x42, 0xb1, 0x6c, 0x08, 0x88, 0x09, 0x42, 0xc1,
+  0x4c, 0x10, 0x8a, 0x66, 0x82, 0x40, 0x18, 0x13, 0x04, 0xe2, 0xd8, 0x20,
+  0x60, 0xd9, 0x86, 0x85, 0x90, 0x26, 0xaa, 0xb2, 0x86, 0x8b, 0xa0, 0xb4,
+  0x0d, 0xc1, 0xc6, 0x64, 0xca, 0xea, 0x8b, 0x2a, 0x4c, 0xee, 0xac, 0x8c,
+  0x6e, 0x82, 0x50, 0x38, 0x1b, 0x16, 0xa2, 0x9b, 0xbc, 0x8a, 0x1a, 0x2e,
+  0x82, 0xd2, 0x36, 0x04, 0xdf, 0x86, 0x81, 0x03, 0x03, 0x60, 0x43, 0xa1,
+  0x44, 0x61, 0x00, 0x00, 0x2c, 0xd2, 0xdc, 0xe6, 0xe8, 0xe6, 0x26, 0x08,
+  0x04, 0x42, 0x63, 0x2e, 0xed, 0xec, 0x8b, 0x8d, 0x6c, 0x82, 0x40, 0x24,
+  0x34, 0xe6, 0xd2, 0xce, 0xbe, 0xe6, 0xe8, 0x36, 0x18, 0x63, 0x40, 0x06,
+  0x65, 0x60, 0x06, 0x67, 0x60, 0x06, 0x55, 0xd8, 0xd8, 0xec, 0xda, 0x5c,
+  0xd2, 0xc8, 0xca, 0xdc, 0xe8, 0xa6, 0x04, 0x41, 0x15, 0x32, 0x3c, 0x17,
+  0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x29, 0x01, 0xd1, 0x84, 0x0c,
+  0xcf, 0xc5, 0x2e, 0x8c, 0xcd, 0xae, 0x4c, 0x6e, 0x4a, 0x50, 0xd4, 0x21,
+  0xc3, 0x73, 0x99, 0x43, 0x0b, 0x23, 0x2b, 0x93, 0x6b, 0x7a, 0x23, 0x2b,
+  0x63, 0x9b, 0x12, 0x20, 0x95, 0xc8, 0xf0, 0x5c, 0xe8, 0xf2, 0xe0, 0xca,
+  0x82, 0xdc, 0xdc, 0xde, 0xe8, 0xc2, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0xa6,
+  0x04, 0x4d, 0x1d, 0x32, 0x3c, 0x17, 0xbb, 0xb4, 0xb2, 0xbb, 0x24, 0xb2,
+  0x29, 0xba, 0x30, 0xba, 0xb2, 0x29, 0xc1, 0x53, 0x87, 0x0c, 0xcf, 0xa5,
+  0xcc, 0x8d, 0x4e, 0x2e, 0x0f, 0xea, 0x2d, 0xcd, 0x8d, 0x6e, 0x6e, 0x4a,
+  0x10, 0x06, 0x5d, 0xc8, 0xf0, 0x5c, 0xc6, 0xde, 0xea, 0xdc, 0xe8, 0xca,
+  0xe4, 0xe6, 0xa6, 0x04, 0x67, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87,
+  0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87,
+  0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40,
+  0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x16, 0x30, 0x0d, 0x97, 0xef, 0x3c, 0xfe, 0xe2,
+  0x00, 0x83, 0xd8, 0x3c, 0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x02, 0xd5, 0x70,
+  0xf9, 0xce, 0xe3, 0x4b, 0x93, 0x13, 0x11, 0x28, 0x35, 0x3d, 0xd4, 0xe4,
+  0x17, 0xb7, 0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x79, 0x26, 0x84, 0x35, 0xb7, 0x92, 0x9f, 0xdb,
+  0xc9, 0xf5, 0x29, 0x45, 0x9f, 0x44, 0xb8, 0x78, 0x44, 0x58, 0x49, 0x4c,
+  0xd8, 0x04, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00,
+  0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0xc0, 0x04, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
+  0x2d, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0x84, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0xe4, 0x48, 0x0e, 0x90, 0x11, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x21, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x01, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x82, 0x60, 0x42, 0x20, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x30, 0x23, 0x00,
+  0x25, 0x00, 0x8a, 0x19, 0x80, 0x39, 0x02, 0x30, 0x98, 0x23, 0x40, 0x8a,
+  0x31, 0x44, 0x54, 0x44, 0x56, 0x0c, 0x20, 0xa2, 0x1a, 0xc2, 0x81, 0x80,
+  0x34, 0x20, 0x00, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87,
+  0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50,
+  0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86,
+  0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xc8, 0x02, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xa2,
+  0x12, 0x18, 0x01, 0x28, 0x88, 0x62, 0x28, 0x83, 0xf2, 0xa0, 0x2a, 0x89,
+  0x11, 0x80, 0x22, 0x28, 0x84, 0x02, 0xa1, 0x1d, 0xcb, 0x20, 0x88, 0x40,
+  0x20, 0x10, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+  0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b,
+  0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71,
+  0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89,
+  0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0x62, 0x98, 0x20, 0x10, 0xc4, 0x06, 0x61, 0x20, 0x26, 0x08, 0x44,
+  0xb1, 0x41, 0x18, 0x0c, 0x0a, 0x70, 0x73, 0x13, 0x04, 0xc2, 0xd8, 0x30,
+  0x20, 0x09, 0x31, 0x41, 0x58, 0x9c, 0x0d, 0xc1, 0x32, 0x41, 0x10, 0x00,
+  0x12, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0xa8, 0x8a, 0xb0, 0x86, 0x9e, 0x9e,
+  0xa4, 0x88, 0x26, 0x08, 0x45, 0x32, 0x41, 0x28, 0x94, 0x0d, 0x01, 0x31,
+  0x41, 0x28, 0x96, 0x09, 0x42, 0xc1, 0x4c, 0x10, 0x88, 0x63, 0x82, 0x40,
+  0x20, 0x1b, 0x84, 0xca, 0xda, 0xb0, 0x10, 0x0f, 0x14, 0x49, 0xd3, 0x40,
+  0x11, 0xd1, 0xb5, 0x21, 0xc0, 0x98, 0x4c, 0x59, 0x7d, 0x51, 0x85, 0xc9,
+  0x9d, 0x95, 0xd1, 0x4d, 0x10, 0x8a, 0x66, 0xc3, 0x42, 0x68, 0xd0, 0x26,
+  0x45, 0x03, 0x45, 0x44, 0xd7, 0x86, 0x80, 0xdb, 0x30, 0x64, 0x1d, 0xb0,
+  0xa1, 0x68, 0x1c, 0x0f, 0x00, 0xaa, 0xb0, 0xb1, 0xd9, 0xb5, 0xb9, 0xa4,
+  0x91, 0x95, 0xb9, 0xd1, 0x4d, 0x09, 0x82, 0x2a, 0x64, 0x78, 0x2e, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x02, 0xa2, 0x09, 0x19, 0x9e,
+  0x8b, 0x5d, 0x18, 0x9b, 0x5d, 0x99, 0xdc, 0x94, 0xc0, 0xa8, 0x43, 0x86,
+  0xe7, 0x32, 0x87, 0x16, 0x46, 0x56, 0x26, 0xd7, 0xf4, 0x46, 0x56, 0xc6,
+  0x36, 0x25, 0x48, 0xea, 0x90, 0xe1, 0xb9, 0xd8, 0xa5, 0x95, 0xdd, 0x25,
+  0x91, 0x4d, 0xd1, 0x85, 0xd1, 0x95, 0x4d, 0x09, 0x96, 0x3a, 0x64, 0x78,
+  0x2e, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73,
+  0x53, 0x02, 0x0f, 0x00, 0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8,
+  0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b,
+  0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a,
+  0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e,
+  0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x16, 0x30, 0x0d, 0x97, 0xef, 0x3c, 0xfe, 0xe2, 0x00, 0x83, 0xd8, 0x3c,
+  0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x02, 0xd5, 0x70, 0xf9, 0xce, 0xe3, 0x4b,
+  0x93, 0x13, 0x11, 0x28, 0x35, 0x3d, 0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x00,
+  0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x44, 0x85, 0x30, 0x03, 0x50, 0x0a, 0x54, 0x25,
+  0x50, 0x06, 0x00, 0x00, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x4c,
+  0x05, 0x04, 0x29, 0xc4, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0x94,
+  0x11, 0x45, 0x43, 0x31, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x75,
+  0x48, 0xd2, 0x62, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x81, 0x61, 0x21,
+  0xd3, 0x44, 0x1c, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80, 0x58, 0x07,
+  0x45, 0x39, 0xc4, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0xd6, 0x41,
+  0x51, 0xc6, 0x30, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x88, 0x75, 0x50,
+  0x54, 0x23, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0x62, 0x1d, 0x14,
+  0x55, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/color.frag.spv.h b/SDL-3.2.8/src/render/gpu/shaders/color.frag.spv.h
new file mode 100644
index 0000000..51e02de
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/color.frag.spv.h
@@ -0,0 +1,29 @@
+static const unsigned char color_frag_spv[] = {
+  0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x08, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+  0x01, 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, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x07, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x09, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x10, 0x00, 0x03, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x09, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x0c, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+};
+static const unsigned int color_frag_spv_len = 312;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/dxbc50.h b/SDL-3.2.8/src/render/gpu/shaders/dxbc50.h
new file mode 100644
index 0000000..1c01126
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/dxbc50.h
@@ -0,0 +1,6 @@
+#include "linepoint.vert.sm50.dxbc.h"
+#include "tri_color.vert.sm50.dxbc.h"
+#include "tri_texture.vert.sm50.dxbc.h"
+#include "color.frag.sm50.dxbc.h"
+#include "texture_rgba.frag.sm50.dxbc.h"
+#include "texture_rgb.frag.sm50.dxbc.h"
diff --git a/SDL-3.2.8/src/render/gpu/shaders/dxil60.h b/SDL-3.2.8/src/render/gpu/shaders/dxil60.h
new file mode 100644
index 0000000..88489f9
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/dxil60.h
@@ -0,0 +1,6 @@
+#include "linepoint.vert.sm60.dxil.h"
+#include "tri_color.vert.sm60.dxil.h"
+#include "tri_texture.vert.sm60.dxil.h"
+#include "color.frag.sm60.dxil.h"
+#include "texture_rgba.frag.sm60.dxil.h"
+#include "texture_rgb.frag.sm60.dxil.h"
diff --git a/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert
new file mode 100644
index 0000000..34596d5
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert
@@ -0,0 +1,17 @@
+#version 450
+
+layout(location = 0) in vec2 a_position;
+
+layout(location = 0) out vec4 v_color;
+
+layout(set = 1, binding = 0) uniform Context {
+    mat4 mvp;
+    vec4 color;
+    vec2 texture_size;  /* XXX unused */
+} u_context;
+
+void main() {
+    gl_PointSize = 1.0;  /* FIXME: D3D11 pls */
+    gl_Position = u_context.mvp * vec4(a_position, 0, 1);
+    v_color = u_context.color;
+}
diff --git a/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.metal.h b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.metal.h
new file mode 100644
index 0000000..96b1c37
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.metal.h
@@ -0,0 +1,51 @@
+static const unsigned char linepoint_vert_metal[] = {
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x3e, 0x0a,
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x69,
+  0x6d, 0x64, 0x2f, 0x73, 0x69, 0x6d, 0x64, 0x2e, 0x68, 0x3e, 0x0a, 0x0a,
+  0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x3b, 0x0a, 0x0a,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x5f, 0x32, 0x32, 0x0a, 0x7b,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78,
+  0x34, 0x20, 0x5f, 0x6d, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x5f, 0x6d, 0x31, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x5f, 0x6d,
+  0x32, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x0a,
+  0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x20, 0x6d, 0x5f, 0x33, 0x38, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72,
+  0x28, 0x6c, 0x6f, 0x63, 0x6e, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x67, 0x6c,
+  0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x5b, 0x5b,
+  0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5d, 0x5d, 0x3b, 0x0a,
+  0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x67, 0x6c,
+  0x5f, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x20, 0x5b,
+  0x5b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5d,
+  0x5d, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x0a, 0x7b,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20,
+  0x6d, 0x5f, 0x32, 0x39, 0x20, 0x5b, 0x5b, 0x61, 0x74, 0x74, 0x72, 0x69,
+  0x62, 0x75, 0x74, 0x65, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x7d,
+  0x3b, 0x0a, 0x0a, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x20, 0x6d, 0x61,
+  0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e,
+  0x30, 0x28, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x20, 0x69,
+  0x6e, 0x20, 0x5b, 0x5b, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e,
+  0x5d, 0x5d, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,
+  0x20, 0x5f, 0x32, 0x32, 0x26, 0x20, 0x5f, 0x32, 0x34, 0x20, 0x5b, 0x5b,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x29,
+  0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30,
+  0x5f, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x7b,
+  0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e, 0x67,
+  0x6c, 0x5f, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x20,
+  0x3d, 0x20, 0x31, 0x2e, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f,
+  0x75, 0x74, 0x2e, 0x67, 0x6c, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69,
+  0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x5f, 0x32, 0x34, 0x2e, 0x5f, 0x6d, 0x30,
+  0x20, 0x2a, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x28, 0x69, 0x6e,
+  0x2e, 0x6d, 0x5f, 0x32, 0x39, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20,
+  0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75,
+  0x74, 0x2e, 0x6d, 0x5f, 0x33, 0x38, 0x20, 0x3d, 0x20, 0x5f, 0x32, 0x34,
+  0x2e, 0x5f, 0x6d, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
+  0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x3b, 0x0a, 0x7d, 0x0a,
+  0x0a
+};
+static const unsigned int linepoint_vert_metal_len = 565;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.sm50.dxbc.h b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.sm50.dxbc.h
new file mode 100644
index 0000000..c626676
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.sm50.dxbc.h
@@ -0,0 +1,172 @@
+static const signed char linepoint_vert_sm50_dxbc[] =
+{
+  68,  88,  66,  67,   0, 119,
+ 101, -18, 103, 113,  34,  52,
+ -82,  96,  17,   4, -92,  11,
+ -67,  71,   1,   0,   0,   0,
+ -12,   3,   0,   0,   5,   0,
+   0,   0,  52,   0,   0,   0,
+ -12,   1,   0,   0,  40,   2,
+   0,   0,-128,   2,   0,   0,
+  88,   3,   0,   0,  82,  68,
+  69,  70, -72,   1,   0,   0,
+   1,   0,   0,   0, 100,   0,
+   0,   0,   1,   0,   0,   0,
+  60,   0,   0,   0,   0,   5,
+  -2,  -1,   0,   1,   0,   0,
+-112,   1,   0,   0,  82,  68,
+  49,  49,  60,   0,   0,   0,
+  24,   0,   0,   0,  32,   0,
+   0,   0,  40,   0,   0,   0,
+  36,   0,   0,   0,  12,   0,
+   0,   0,   0,   0,   0,   0,
+  92,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0,  95,  50,  50,  95,
+  50,  52,   0, -85,  92,   0,
+   0,   0,   3,   0,   0,   0,
+ 124,   0,   0,   0,  96,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0, -12,   0,
+   0,   0,   0,   0,   0,   0,
+  64,   0,   0,   0,   2,   0,
+   0,   0,   4,   1,   0,   0,
+   0,   0,   0,   0,  -1,  -1,
+  -1,  -1,   0,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,  40,   1,   0,   0,
+  64,   0,   0,   0,  16,   0,
+   0,   0,   2,   0,   0,   0,
+  56,   1,   0,   0,   0,   0,
+   0,   0,  -1,  -1,  -1,  -1,
+   0,   0,   0,   0,  -1,  -1,
+  -1,  -1,   0,   0,   0,   0,
+  92,   1,   0,   0,  80,   0,
+   0,   0,   8,   0,   0,   0,
+   0,   0,   0,   0, 108,   1,
+   0,   0,   0,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,  -1,  -1,  -1,  -1,
+   0,   0,   0,   0,  95,  50,
+  52,  95, 109,  48,   0, 102,
+ 108, 111,  97, 116,  52, 120,
+  52,   0,   2,   0,   3,   0,
+   4,   0,   4,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,  -5,   0,
+   0,   0,  95,  50,  52,  95,
+ 109,  49,   0, 102, 108, 111,
+  97, 116,  52,   0, -85, -85,
+   1,   0,   3,   0,   1,   0,
+   4,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,  47,   1,   0,   0,
+  95,  50,  52,  95, 109,  50,
+   0, 102, 108, 111,  97, 116,
+  50,   0, -85, -85,   1,   0,
+   3,   0,   1,   0,   2,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+  99,   1,   0,   0,  77, 105,
+  99, 114, 111, 115, 111, 102,
+ 116,  32,  40,  82,  41,  32,
+  72,  76,  83,  76,  32,  83,
+ 104,  97, 100, 101, 114,  32,
+  67, 111, 109, 112, 105, 108,
+ 101, 114,  32,  49,  48,  46,
+  49,   0,  73,  83,  71,  78,
+  44,   0,   0,   0,   1,   0,
+   0,   0,   8,   0,   0,   0,
+  32,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,   3,   3,   0,   0,
+  84,  69,  88,  67,  79,  79,
+  82,  68,   0, -85, -85, -85,
+  79,  83,  71,  78,  80,   0,
+   0,   0,   2,   0,   0,   0,
+   8,   0,   0,   0,  56,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   3,   0,
+   0,   0,   0,   0,   0,   0,
+  15,   0,   0,   0,  65,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   3,   0,
+   0,   0,   1,   0,   0,   0,
+  15,   0,   0,   0,  84,  69,
+  88,  67,  79,  79,  82,  68,
+   0,  83,  86,  95,  80, 111,
+ 115, 105, 116, 105, 111, 110,
+   0, -85, -85, -85,  83,  72,
+  69,  88, -48,   0,   0,   0,
+  80,   0,   1,   0,  52,   0,
+   0,   0, 106,   8,   0,   1,
+  89,   0,   0,   4,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   5,   0,   0,   0,  95,   0,
+   0,   3,  50,  16,  16,   0,
+   0,   0,   0,   0, 101,   0,
+   0,   3, -14,  32,  16,   0,
+   0,   0,   0,   0, 103,   0,
+   0,   4, -14,  32,  16,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0, 104,   0,   0,   2,
+   1,   0,   0,   0,  54,   0,
+   0,   6, -14,  32,  16,   0,
+   0,   0,   0,   0,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   4,   0,   0,   0,  56,   0,
+   0,   8, -14,   0,  16,   0,
+   0,   0,   0,   0,  86,  21,
+  16,   0,   0,   0,   0,   0,
+  70,-114,  32,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+  50,   0,   0,  10, -14,   0,
+  16,   0,   0,   0,   0,   0,
+   6,  16,  16,   0,   0,   0,
+   0,   0,  70,-114,  32,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,  70,  14,  16,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   8, -14,  32,  16,   0,
+   1,   0,   0,   0,  70,  14,
+  16,   0,   0,   0,   0,   0,
+  70,-114,  32,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+  62,   0,   0,   1,  83,  84,
+  65,  84,-108,   0,   0,   0,
+   5,   0,   0,   0,   1,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   3,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   1,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   1,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.sm60.dxil.h b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.sm60.dxil.h
new file mode 100644
index 0000000..8320325
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.sm60.dxil.h
@@ -0,0 +1,496 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xy          0     NONE   float   xy  
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xyzw        0     NONE   float   xyzw
+; SV_Position              0   xyzw        1      POS   float   xyzw
+;
+; shader hash: 28e70f2da15e5a0c84402943a6b12723
+;
+; Pipeline Runtime Information: 
+;
+; Vertex Shader
+; OutputPositionPresent=1
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                              
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                 linear       
+; SV_Position              0          noperspective       
+;
+; Buffer Definitions:
+;
+; cbuffer _22_24
+; {
+;
+;   struct hostlayout._22_24
+;   {
+;
+;       row_major float4x4 _24_m0;                    ; Offset:    0
+;       float4 _24_m1;                                ; Offset:   64
+;       float2 _24_m2;                                ; Offset:   80
+;   
+;   } _22_24;                                         ; Offset:    0 Size:    88
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; _22_24                            cbuffer      NA          NA     CB0     cb0,space1     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 2, outputs: 8
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 4 depends on inputs: { 0, 1 }
+;   output 5 depends on inputs: { 0, 1 }
+;   output 6 depends on inputs: { 0, 1 }
+;   output 7 depends on inputs: { 0, 1 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%hostlayout._22_24 = type { [4 x <4 x float>], <4 x float>, <2 x float> }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %5 = extractvalue %dx.types.CBufRet.f32 %4, 0
+  %6 = extractvalue %dx.types.CBufRet.f32 %4, 1
+  %7 = extractvalue %dx.types.CBufRet.f32 %4, 2
+  %8 = extractvalue %dx.types.CBufRet.f32 %4, 3
+  %9 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %10 = extractvalue %dx.types.CBufRet.f32 %9, 0
+  %11 = extractvalue %dx.types.CBufRet.f32 %9, 1
+  %12 = extractvalue %dx.types.CBufRet.f32 %9, 2
+  %13 = extractvalue %dx.types.CBufRet.f32 %9, 3
+  %14 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %15 = extractvalue %dx.types.CBufRet.f32 %14, 0
+  %16 = extractvalue %dx.types.CBufRet.f32 %14, 1
+  %17 = extractvalue %dx.types.CBufRet.f32 %14, 2
+  %18 = extractvalue %dx.types.CBufRet.f32 %14, 3
+  %19 = fmul fast float %5, %2
+  %20 = call float @dx.op.tertiary.f32(i32 46, float %3, float %10, float %19)  ; FMad(a,b,c)
+  %21 = fadd fast float %15, %20
+  %22 = fmul fast float %6, %2
+  %23 = call float @dx.op.tertiary.f32(i32 46, float %3, float %11, float %22)  ; FMad(a,b,c)
+  %24 = fadd fast float %23, %16
+  %25 = fmul fast float %7, %2
+  %26 = call float @dx.op.tertiary.f32(i32 46, float %3, float %12, float %25)  ; FMad(a,b,c)
+  %27 = fadd fast float %26, %17
+  %28 = fmul fast float %8, %2
+  %29 = call float @dx.op.tertiary.f32(i32 46, float %3, float %13, float %28)  ; FMad(a,b,c)
+  %30 = fadd fast float %29, %18
+  %31 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 4)  ; CBufferLoadLegacy(handle,regIndex)
+  %32 = extractvalue %dx.types.CBufRet.f32 %31, 0
+  %33 = extractvalue %dx.types.CBufRet.f32 %31, 1
+  %34 = extractvalue %dx.types.CBufRet.f32 %31, 2
+  %35 = extractvalue %dx.types.CBufRet.f32 %31, 3
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %32)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %33)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %34)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %35)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 0, float %21)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 1, float %24)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 2, float %27)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 3, float %30)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"dxc(private) 1.8.0.4662 (416fab6b5)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 8}
+!3 = !{!"vs", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %hostlayout._22_24* undef, !"", i32 1, i32 0, i32 1, i32 88, null}
+!7 = !{[4 x i32] [i32 2, i32 8, i32 240, i32 240]}
+!8 = !{void ()* @main, !"main", !9, !4, null}
+!9 = !{!10, !14, null}
+!10 = !{!11}
+!11 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !12, i8 0, i32 1, i8 2, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 3}
+!14 = !{!15, !17}
+!15 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 0, i8 0, !16}
+!16 = !{i32 3, i32 15}
+!17 = !{i32 1, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 1, i8 0, !16}
+
+#endif
+
+static const unsigned char linepoint_vert_sm60_dxil[] = {
+  0x44, 0x58, 0x42, 0x43, 0x07, 0x97, 0x68, 0xde, 0x5f, 0x50, 0x0b, 0x5d,
+  0x22, 0x1b, 0xe5, 0xb4, 0xe8, 0xdb, 0x02, 0xea, 0x01, 0x00, 0x00, 0x00,
+  0x04, 0x0f, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
+  0xb8, 0x01, 0x00, 0x00, 0x0c, 0x08, 0x00, 0x00, 0x28, 0x08, 0x00, 0x00,
+  0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31, 0x34, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44,
+  0x00, 0x00, 0x00, 0x00, 0x4f, 0x53, 0x47, 0x31, 0x60, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x53, 0x56, 0x5f,
+  0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x53, 0x56, 0x30, 0xc0, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x6d,
+  0x61, 0x69, 0x6e, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x42, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x44, 0x03,
+  0x03, 0x04, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54,
+  0x4c, 0x06, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00, 0x93, 0x01, 0x00, 0x00,
+  0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x34, 0x06, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
+  0x8a, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00,
+  0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42,
+  0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x24, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x23, 0x00,
+  0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29,
+  0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1,
+  0xa3, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95,
+  0x98, 0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e,
+  0x7f, 0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab,
+  0x10, 0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11,
+  0x04, 0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10,
+  0x43, 0x12, 0xd4, 0x61, 0x04, 0x61, 0xb8, 0xe8, 0x70, 0xa4, 0x69, 0x01,
+  0x30, 0x87, 0x9a, 0xfc, 0xdf, 0xb6, 0x7f, 0x1b, 0x47, 0x83, 0xad, 0x97,
+  0x70, 0x12, 0x10, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87,
+  0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50,
+  0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86,
+  0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x30, 0xe4, 0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x60, 0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x1b, 0x50,
+  0x04, 0x85, 0x50, 0x06, 0xe5, 0x50, 0x12, 0x05, 0x18, 0x50, 0x1a, 0x05,
+  0x1a, 0x50, 0x1e, 0x05, 0x51, 0x58, 0x54, 0x4a, 0x62, 0x04, 0xa0, 0x08,
+  0x0a, 0xa1, 0x0c, 0x28, 0xd6, 0x00, 0xe1, 0x19, 0x00, 0xca, 0x33, 0x00,
+  0xa4, 0xc7, 0x22, 0x04, 0x04, 0x3e, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90,
+  0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b,
+  0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71,
+  0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13,
+  0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20,
+  0x10, 0xc7, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04, 0x41, 0xc1, 0x6e, 0x6e,
+  0x82, 0x40, 0x20, 0x1b, 0x86, 0x03, 0x21, 0x26, 0x08, 0x19, 0x47, 0xe3,
+  0x4b, 0x46, 0xe6, 0x4b, 0x86, 0x66, 0x82, 0x40, 0x24, 0x1b, 0x10, 0x42,
+  0x59, 0x06, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3, 0x81, 0x00, 0x00, 0x07,
+  0x98, 0x20, 0x60, 0x1b, 0x8d, 0x2f, 0x19, 0x9a, 0xaf, 0x36, 0x98, 0x09,
+  0x02, 0xa1, 0x4c, 0x10, 0x88, 0x65, 0xc3, 0x30, 0x4d, 0xc3, 0x04, 0x81,
+  0x60, 0x26, 0x08, 0x44, 0x33, 0x41, 0x20, 0x9c, 0x09, 0x42, 0xa4, 0x6d,
+  0x50, 0x90, 0x48, 0xa2, 0x2a, 0xc2, 0xba, 0x2e, 0x8c, 0xc6, 0x97, 0x0c,
+  0xcd, 0x57, 0x5b, 0xcc, 0x04, 0x81, 0x78, 0x26, 0x08, 0x04, 0xb4, 0x41,
+  0x41, 0xb4, 0x6a, 0xb3, 0xae, 0x0b, 0xe3, 0x26, 0x1a, 0x5f, 0x32, 0x34,
+  0x5f, 0x6d, 0x32, 0x13, 0x04, 0x22, 0xda, 0x80, 0x20, 0x5e, 0xf5, 0x59,
+  0x17, 0x27, 0x6d, 0x20, 0x98, 0xac, 0x03, 0x83, 0x0d, 0x03, 0x01, 0x85,
+  0xc1, 0x04, 0x41, 0x00, 0x36, 0x00, 0x1b, 0x06, 0x82, 0x0c, 0xc8, 0x60,
+  0x43, 0x50, 0x06, 0x1b, 0x86, 0x61, 0x0c, 0xcc, 0x60, 0x82, 0xa0, 0x75,
+  0x1b, 0x02, 0x34, 0x20, 0xd1, 0x16, 0x96, 0xe6, 0x46, 0x84, 0xaa, 0x08,
+  0x6b, 0xe8, 0xe9, 0x49, 0x8a, 0x68, 0x82, 0x50, 0x54, 0x13, 0x84, 0xc2,
+  0xda, 0x10, 0x10, 0x13, 0x84, 0xe2, 0xda, 0x20, 0x54, 0xd5, 0x86, 0x85,
+  0x58, 0x03, 0x36, 0x68, 0x03, 0x37, 0x68, 0x83, 0xe1, 0x0d, 0x88, 0x36,
+  0x80, 0x83, 0x0d, 0x41, 0x1c, 0x4c, 0x10, 0x0a, 0x6c, 0x82, 0x40, 0x48,
+  0x1b, 0x84, 0x8a, 0x0e, 0x36, 0x2c, 0xc4, 0x1a, 0xb0, 0x41, 0x1b, 0xb8,
+  0xc1, 0x1b, 0x0c, 0x73, 0x40, 0xb4, 0x41, 0x1d, 0x70, 0x99, 0xb2, 0xfa,
+  0x82, 0x7a, 0x9b, 0x4b, 0xa3, 0x4b, 0x7b, 0x73, 0x9b, 0x20, 0x14, 0xd9,
+  0x86, 0x65, 0xb8, 0x03, 0x36, 0xc0, 0x03, 0x37, 0x98, 0x83, 0x61, 0x0e,
+  0x86, 0x36, 0xa8, 0x83, 0x0d, 0x82, 0x1d, 0xe4, 0xc1, 0x86, 0x41, 0x0e,
+  0xf4, 0x00, 0xd8, 0x50, 0x8c, 0x81, 0x1a, 0xec, 0xc1, 0x03, 0xd0, 0x30,
+  0x63, 0x7b, 0x0b, 0xa3, 0x9b, 0x9b, 0x20, 0x10, 0x13, 0x8b, 0x34, 0xb7,
+  0x39, 0xba, 0xb9, 0x09, 0x02, 0x41, 0xd1, 0x98, 0x4b, 0x3b, 0xfb, 0x62,
+  0x23, 0xa3, 0x31, 0x97, 0x76, 0xf6, 0x35, 0x47, 0xb7, 0x01, 0xe9, 0x03,
+  0x3f, 0xf8, 0x03, 0x50, 0x08, 0x05, 0x49, 0x14, 0xfc, 0xa0, 0x0a, 0x1b,
+  0x9b, 0x5d, 0x9b, 0x4b, 0x1a, 0x59, 0x99, 0x1b, 0xdd, 0x94, 0x20, 0xa8,
+  0x42, 0x86, 0xe7, 0x62, 0x57, 0x26, 0x37, 0x97, 0xf6, 0xe6, 0x36, 0x25,
+  0x20, 0x9a, 0x90, 0xe1, 0xb9, 0xd8, 0x85, 0xb1, 0xd9, 0x95, 0xc9, 0x4d,
+  0x09, 0x8a, 0x3a, 0x64, 0x78, 0x2e, 0x73, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x53, 0x02, 0xa4, 0x0c, 0x19, 0x9e, 0x8b,
+  0x5c, 0xd9, 0xdc, 0x5b, 0x9d, 0xdc, 0x58, 0xd9, 0xdc, 0x94, 0xc0, 0xa9,
+  0x44, 0x86, 0xe7, 0x42, 0x97, 0x07, 0x57, 0x16, 0xe4, 0xe6, 0xf6, 0x46,
+  0x17, 0x46, 0x97, 0xf6, 0xe6, 0x36, 0x37, 0x45, 0x08, 0x03, 0x33, 0xa8,
+  0x43, 0x86, 0xe7, 0x62, 0x97, 0x56, 0x76, 0x97, 0x44, 0x36, 0x45, 0x17,
+  0x46, 0x57, 0x36, 0x25, 0x40, 0x83, 0x3a, 0x64, 0x78, 0x2e, 0x65, 0x6e,
+  0x74, 0x72, 0x79, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x53, 0x82, 0x3d,
+  0xe8, 0x42, 0x86, 0xe7, 0x32, 0xf6, 0x56, 0xe7, 0x46, 0x57, 0x26, 0x37,
+  0x37, 0x25, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87,
+  0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87,
+  0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40,
+  0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10,
+  0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25, 0x61, 0x00, 0x02, 0xe6,
+  0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce, 0xe3, 0x0b, 0x11, 0x01,
+  0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0, 0x34, 0x5c, 0xbe, 0xf3,
+  0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x09,
+  0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e, 0x44, 0xa0, 0xd4, 0xf4,
+  0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3, 0xe5, 0x3b, 0x8f, 0x3f,
+  0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7, 0x6d, 0x00, 0x04, 0x03,
+  0x20, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48,
+  0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xe7, 0x0f, 0x2d,
+  0xa1, 0x5e, 0x5a, 0x0c, 0x84, 0x40, 0x29, 0x43, 0xa6, 0xb1, 0x27, 0x23,
+  0x44, 0x58, 0x49, 0x4c, 0xd4, 0x06, 0x00, 0x00, 0x60, 0x00, 0x01, 0x00,
+  0xb5, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0xbc, 0x06, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde,
+  0x21, 0x0c, 0x00, 0x00, 0xac, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91,
+  0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c,
+  0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02,
+  0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b,
+  0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5,
+  0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50,
+  0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06,
+  0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff,
+  0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff,
+  0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f,
+  0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00,
+  0x89, 0x20, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09,
+  0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3,
+  0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c,
+  0x10, 0x6c, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0,
+  0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80,
+  0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0x7c,
+  0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6, 0x11, 0x31, 0xc6, 0x18,
+  0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42, 0xf2, 0x43, 0xa0, 0x19,
+  0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42, 0xad, 0x14, 0x83, 0x8c,
+  0x31, 0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4, 0x10, 0x12, 0x49, 0x0e,
+  0x04, 0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x61, 0x04, 0x61, 0xb8, 0xe8,
+  0x70, 0xa4, 0x69, 0x01, 0x30, 0x87, 0x9a, 0xfc, 0xdf, 0xb6, 0x7f, 0x1b,
+  0x47, 0x83, 0xad, 0x97, 0x70, 0x12, 0x10, 0x00, 0x13, 0x14, 0x72, 0xc0,
+  0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0,
+  0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d,
+  0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x79, 0x80, 0x00, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc8, 0x23, 0x01, 0x01,
+  0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0x08, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50,
+  0x10, 0xc5, 0x50, 0xb0, 0x01, 0x65, 0x50, 0x1e, 0x54, 0x4a, 0x62, 0x04,
+  0xa0, 0x08, 0x0a, 0xa1, 0x0c, 0x28, 0xcf, 0x00, 0x90, 0x1e, 0x8b, 0x10,
+  0x10, 0xf8, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x53, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4,
+  0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b,
+  0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91,
+  0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49,
+  0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61,
+  0x20, 0x26, 0x08, 0x04, 0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x76, 0x73, 0x13,
+  0x04, 0x22, 0xd9, 0x30, 0x20, 0x09, 0x31, 0x41, 0xc8, 0x24, 0x02, 0x13,
+  0x04, 0x42, 0xd9, 0x80, 0x10, 0x0b, 0x33, 0x10, 0x43, 0x03, 0x6c, 0x08,
+  0x9c, 0x0d, 0x04, 0x00, 0x3c, 0xc0, 0x04, 0x41, 0x9b, 0x36, 0x04, 0xd1,
+  0x04, 0x41, 0x00, 0x48, 0xb4, 0x85, 0xa5, 0xb9, 0x11, 0xa1, 0x2a, 0xc2,
+  0x1a, 0x7a, 0x7a, 0x92, 0x22, 0x9a, 0x20, 0x14, 0xcd, 0x04, 0xa1, 0x70,
+  0x36, 0x04, 0xc4, 0x04, 0xa1, 0x78, 0x26, 0x08, 0xc4, 0xb2, 0x41, 0xd0,
+  0xb4, 0x0d, 0x0b, 0x51, 0x59, 0x17, 0x76, 0x0d, 0x19, 0x71, 0x6d, 0x1b,
+  0x02, 0x6e, 0x82, 0x50, 0x40, 0x13, 0x04, 0x82, 0xd9, 0x20, 0x68, 0xdf,
+  0x86, 0x85, 0xa8, 0xac, 0x0b, 0xcb, 0x06, 0x8f, 0xb8, 0xc0, 0x80, 0xcb,
+  0x94, 0xd5, 0x17, 0xd4, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0xdb, 0x04,
+  0xa1, 0x88, 0x36, 0x2c, 0x83, 0x18, 0x58, 0x63, 0x80, 0x79, 0x83, 0x37,
+  0x5c, 0x60, 0xb0, 0x41, 0x08, 0x03, 0x32, 0xd8, 0x30, 0x74, 0x65, 0x00,
+  0x6c, 0x28, 0x26, 0xca, 0x0c, 0x20, 0xa0, 0x0a, 0x1b, 0x9b, 0x5d, 0x9b,
+  0x4b, 0x1a, 0x59, 0x99, 0x1b, 0xdd, 0x94, 0x20, 0xa8, 0x42, 0x86, 0xe7,
+  0x62, 0x57, 0x26, 0x37, 0x97, 0xf6, 0xe6, 0x36, 0x25, 0x20, 0x9a, 0x90,
+  0xe1, 0xb9, 0xd8, 0x85, 0xb1, 0xd9, 0x95, 0xc9, 0x4d, 0x09, 0x8c, 0x3a,
+  0x64, 0x78, 0x2e, 0x73, 0x68, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x6f, 0x64,
+  0x65, 0x6c, 0x53, 0x82, 0xa4, 0x0c, 0x19, 0x9e, 0x8b, 0x5c, 0xd9, 0xdc,
+  0x5b, 0x9d, 0xdc, 0x58, 0xd9, 0xdc, 0x94, 0xe0, 0xa9, 0x43, 0x86, 0xe7,
+  0x62, 0x97, 0x56, 0x76, 0x97, 0x44, 0x36, 0x45, 0x17, 0x46, 0x57, 0x36,
+  0x25, 0x88, 0xea, 0x90, 0xe1, 0xb9, 0x94, 0xb9, 0xd1, 0xc9, 0xe5, 0x41,
+  0xbd, 0xa5, 0xb9, 0xd1, 0xcd, 0x4d, 0x09, 0xcc, 0x00, 0x00, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70,
+  0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60,
+  0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4,
+  0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97,
+  0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25,
+  0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce,
+  0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0,
+  0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93,
+  0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e,
+  0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3,
+  0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7,
+  0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x5c, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x44, 0x4a, 0xa1, 0xec, 0x8a, 0xab, 0x10, 0x66,
+  0x00, 0x4a, 0x8e, 0x4a, 0x09, 0x50, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x20, 0x5d, 0x43, 0x53, 0x55, 0xc1,
+  0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0x9c, 0x61, 0x59, 0x4f, 0x31,
+  0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x77, 0x5c, 0x17, 0x61, 0x8c,
+  0x18, 0x1c, 0x00, 0x08, 0x82, 0x41, 0xc3, 0x29, 0x03, 0x36, 0x9a, 0x10,
+  0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09, 0xc4, 0x30,
+  0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x4d, 0x18, 0x3c, 0x88, 0x37, 0x9a,
+  0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09, 0xc4,
+  0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x8d, 0x19, 0x50, 0x8d, 0x37,
+  0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3, 0x09,
+  0xc4, 0x60, 0x4e, 0x24, 0x9f, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78,
+  0xd6, 0x20, 0x8b, 0x94, 0xc0, 0x8c, 0x00, 0x3a, 0x06, 0x51, 0xf2, 0x19,
+  0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0xc7, 0x0d, 0x38, 0x8a, 0x09, 0x2c,
+  0x40, 0xa0, 0x63, 0xd2, 0x25, 0x9f, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30,
+  0x78, 0xe2, 0xe0, 0xbb, 0x9c, 0xc0, 0x02, 0x05, 0x3a, 0x46, 0x69, 0xf2,
+  0x19, 0x31, 0x40, 0x00, 0x10, 0x04, 0x83, 0x87, 0x0e, 0xc4, 0x40, 0x83,
+  0x02, 0x0b, 0x18, 0xe8, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x41, 0x73,
+  0x07, 0x65, 0xe0, 0x8d, 0xc1, 0x68, 0x42, 0x00, 0x8c, 0x26, 0x08, 0xc1,
+  0x68, 0xc2, 0x20, 0x8c, 0x26, 0x10, 0xc3, 0x88, 0x41, 0x02, 0x80, 0x20,
+  0x18, 0x20, 0x7d, 0xb0, 0x06, 0x78, 0x80, 0x07, 0x71, 0x40, 0x8c, 0x18,
+  0x24, 0x00, 0x08, 0x82, 0x01, 0xd2, 0x07, 0x6b, 0x80, 0x07, 0x78, 0x50,
+  0x06, 0xc3, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0x7d, 0xb0, 0x06,
+  0x78, 0x80, 0x07, 0x70, 0x20, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01,
+  0xd2, 0x07, 0x6b, 0x80, 0x07, 0x78, 0xe0, 0x06, 0xc1, 0x88, 0x41, 0x02,
+  0x80, 0x20, 0x18, 0x20, 0x7d, 0xb0, 0x06, 0x79, 0x80, 0x07, 0x71, 0xf0,
+  0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xd2, 0x07, 0x6b, 0x90, 0x07,
+  0x78, 0x50, 0x06, 0xcc, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0x7d,
+  0xb0, 0x06, 0x79, 0x80, 0x07, 0x70, 0x90, 0x8c, 0x18, 0x24, 0x00, 0x08,
+  0x82, 0x01, 0xd2, 0x07, 0x6b, 0x90, 0x07, 0x78, 0xe0, 0x06, 0x06, 0x02,
+  0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.spv.h b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.spv.h
new file mode 100644
index 0000000..449e8dd
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/linepoint.vert.spv.h
@@ -0,0 +1,93 @@
+static const unsigned char linepoint_vert_spv[] = {
+  0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x08, 0x00,
+  0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+  0x01, 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, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x04, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x26, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x15, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x04, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x06, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x20, 0x00, 0x04, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+  0x15, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x05, 0x00, 0x16, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x17, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x24, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0x41, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+  0x19, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+  0x15, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+  0x1f, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x91, 0x00, 0x05, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x22, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x25, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x03, 0x00, 0x25, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+  0x41, 0x00, 0x05, 0x00, 0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x03, 0x00, 0x26, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+  0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+};
+static const unsigned int linepoint_vert_spv_len = 1076;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/metal.h b/SDL-3.2.8/src/render/gpu/shaders/metal.h
new file mode 100644
index 0000000..1841a69
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/metal.h
@@ -0,0 +1,6 @@
+#include "linepoint.vert.metal.h"
+#include "tri_color.vert.metal.h"
+#include "tri_texture.vert.metal.h"
+#include "color.frag.metal.h"
+#include "texture_rgba.frag.metal.h"
+#include "texture_rgb.frag.metal.h"
diff --git a/SDL-3.2.8/src/render/gpu/shaders/spir-v.h b/SDL-3.2.8/src/render/gpu/shaders/spir-v.h
new file mode 100644
index 0000000..85aa3c2
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/spir-v.h
@@ -0,0 +1,6 @@
+#include "linepoint.vert.spv.h"
+#include "tri_color.vert.spv.h"
+#include "tri_texture.vert.spv.h"
+#include "color.frag.spv.h"
+#include "texture_rgba.frag.spv.h"
+#include "texture_rgb.frag.spv.h"
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag
new file mode 100644
index 0000000..9a9ada8
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag
@@ -0,0 +1,12 @@
+#version 450
+
+layout(location = 0) in vec4 v_color;
+layout(location = 1) in vec2 v_uv;
+
+layout(set = 2, binding = 0) uniform sampler2D u_texture;
+
+layout(location = 0) out vec4 o_color;
+
+void main() {
+    o_color = vec4(texture(u_texture, v_uv).rgb, 1) * v_color;
+}
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.metal.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.metal.h
new file mode 100644
index 0000000..fbde876
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.metal.h
@@ -0,0 +1,41 @@
+static const unsigned char texture_rgb_frag_metal[] = {
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x3e, 0x0a,
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x69,
+  0x6d, 0x64, 0x2f, 0x73, 0x69, 0x6d, 0x64, 0x2e, 0x68, 0x3e, 0x0a, 0x0a,
+  0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x3b, 0x0a, 0x0a,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30,
+  0x5f, 0x6f, 0x75, 0x74, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x39, 0x20, 0x5b, 0x5b,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a,
+  0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d,
+  0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x0a, 0x7b, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x32,
+  0x38, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72, 0x28, 0x6c, 0x6f, 0x63,
+  0x6e, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x6d, 0x5f, 0x31, 0x37, 0x20, 0x5b,
+  0x5b, 0x75, 0x73, 0x65, 0x72, 0x28, 0x6c, 0x6f, 0x63, 0x6e, 0x31, 0x29,
+  0x5d, 0x5d, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x66, 0x72, 0x61, 0x67,
+  0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f,
+  0x75, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x28, 0x6d, 0x61, 0x69,
+  0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x5b, 0x5b, 0x73,
+  0x74, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x5d, 0x5d, 0x2c, 0x20, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x3e, 0x20, 0x5f, 0x31, 0x33, 0x20, 0x5b, 0x5b, 0x74, 0x65,
+  0x78, 0x74, 0x75, 0x72, 0x65, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x2c, 0x20,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x20, 0x5f, 0x31, 0x33, 0x53,
+  0x6d, 0x70, 0x6c, 0x72, 0x20, 0x5b, 0x5b, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x29, 0x0a, 0x7b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74,
+  0x20, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e, 0x6d, 0x5f, 0x39, 0x20, 0x3d,
+  0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x28, 0x5f, 0x31, 0x33, 0x2e,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x28, 0x5f, 0x31, 0x33, 0x53, 0x6d,
+  0x70, 0x6c, 0x72, 0x2c, 0x20, 0x69, 0x6e, 0x2e, 0x6d, 0x5f, 0x31, 0x37,
+  0x29, 0x2e, 0x78, 0x79, 0x7a, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x29, 0x20,
+  0x2a, 0x20, 0x69, 0x6e, 0x2e, 0x6d, 0x5f, 0x32, 0x38, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x75,
+  0x74, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a
+};
+static const unsigned int texture_rgb_frag_metal_len = 450;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.sm50.dxbc.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.sm50.dxbc.h
new file mode 100644
index 0000000..183103a
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.sm50.dxbc.h
@@ -0,0 +1,123 @@
+static const signed char texture_rgb_frag_sm50_dxbc[] =
+{
+  68,  88,  66,  67, -22, -54,
+ -48,  73, -47, -40, -92, -21,
+ -43, -46,  13,-120, -20, 126,
+ 110,  46,   1,   0,   0,   0,
+ -52,   2,   0,   0,   5,   0,
+   0,   0,  52,   0,   0,   0,
+ -12,   0,   0,   0,  64,   1,
+   0,   0, 116,   1,   0,   0,
+  48,   2,   0,   0,  82,  68,
+  69,  70, -72,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   2,   0,   0,   0,
+  60,   0,   0,   0,   0,   5,
+  -1,  -1,   0,   1,   0,   0,
+-115,   0,   0,   0,  82,  68,
+  49,  49,  60,   0,   0,   0,
+  24,   0,   0,   0,  32,   0,
+   0,   0,  40,   0,   0,   0,
+  36,   0,   0,   0,  12,   0,
+   0,   0,   0,   0,   0,   0,
+ 124,   0,   0,   0,   3,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0,-119,   0,   0,   0,
+   2,   0,   0,   0,   5,   0,
+   0,   0,   4,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,   1,   0,   0,   0,
+  13,   0,   0,   0,  95,  95,
+  49,  51,  95, 115,  97, 109,
+ 112, 108, 101, 114,   0,  95,
+  49,  51,   0,  77, 105,  99,
+ 114, 111, 115, 111, 102, 116,
+  32,  40,  82,  41,  32,  72,
+  76,  83,  76,  32,  83, 104,
+  97, 100, 101, 114,  32,  67,
+ 111, 109, 112, 105, 108, 101,
+ 114,  32,  49,  48,  46,  49,
+   0, -85, -85, -85,  73,  83,
+  71,  78,  68,   0,   0,   0,
+   2,   0,   0,   0,   8,   0,
+   0,   0,  56,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+   0,   0,   0,   0,  15,  15,
+   0,   0,  56,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+   1,   0,   0,   0,   3,   3,
+   0,   0,  84,  69,  88,  67,
+  79,  79,  82,  68,   0, -85,
+ -85, -85,  79,  83,  71,  78,
+  44,   0,   0,   0,   1,   0,
+   0,   0,   8,   0,   0,   0,
+  32,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,  15,   0,   0,   0,
+  83,  86,  95,  84,  97, 114,
+ 103, 101, 116,   0, -85, -85,
+  83,  72,  69,  88, -76,   0,
+   0,   0,  80,   0,   0,   0,
+  45,   0,   0,   0, 106,   8,
+   0,   1,  90,   0,   0,   3,
+   0,  96,  16,   0,   0,   0,
+   0,   0,  88,  24,   0,   4,
+   0, 112,  16,   0,   0,   0,
+   0,   0,  85,  85,   0,   0,
+  98,  16,   0,   3, -14,  16,
+  16,   0,   0,   0,   0,   0,
+  98,  16,   0,   3,  50,  16,
+  16,   0,   1,   0,   0,   0,
+ 101,   0,   0,   3, -14,  32,
+  16,   0,   0,   0,   0,   0,
+ 104,   0,   0,   2,   1,   0,
+   0,   0,  69,   0,   0,-117,
+ -62,   0,   0,-128,  67,  85,
+  21,   0, 114,   0,  16,   0,
+   0,   0,   0,   0,  70,  16,
+  16,   0,   1,   0,   0,   0,
+  70, 126,  16,   0,   0,   0,
+   0,   0,   0,  96,  16,   0,
+   0,   0,   0,   0,  54,   0,
+   0,   5,-126,   0,  16,   0,
+   0,   0,   0,   0,   1,  64,
+   0,   0,   0,   0,-128,  63,
+  56,   0,   0,   7, -14,  32,
+  16,   0,   0,   0,   0,   0,
+  70,  14,  16,   0,   0,   0,
+   0,   0,  70,  30,  16,   0,
+   0,   0,   0,   0,  62,   0,
+   0,   1,  83,  84,  65,  84,
+-108,   0,   0,   0,   4,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   3,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.sm60.dxil.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.sm60.dxil.h
new file mode 100644
index 0000000..e07e135
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.sm60.dxil.h
@@ -0,0 +1,465 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xyzw        0     NONE   float   xyzw
+; TEXCOORD                 1   xy          1     NONE   float   xy  
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Target                0   xyzw        0   TARGET   float   xyzw
+;
+; shader hash: 6899b843a76b999aab785570052af6a1
+;
+; Pipeline Runtime Information: 
+;
+; Pixel Shader
+; DepthOutput=0
+; SampleFrequency=0
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                 linear       
+; TEXCOORD                 1                 linear       
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Target                0                              
+;
+; Buffer Definitions:
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; __13_sampler                      sampler      NA          NA      S0      s0,space2     1
+; _13                               texture     f32          2d      T0      t0,space2     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 6, outputs: 4
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 0, 4, 5 }
+;   output 1 depends on inputs: { 1, 4, 5 }
+;   output 2 depends on inputs: { 2, 4, 5 }
+;   output 3 depends on inputs: { 3 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.ResRet.f32 = type { float, float, float, float, i32 }
+%"class.Texture2D<vector<float, 4> >" = type { <4 x float>, %"class.Texture2D<vector<float, 4> >::mips_type" }
+%"class.Texture2D<vector<float, 4> >::mips_type" = type { i32 }
+%struct.SamplerState = type { i32 }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 0, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 3, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %1, %dx.types.Handle %2, float %3, float %4, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %10 = extractvalue %dx.types.ResRet.f32 %9, 0
+  %11 = extractvalue %dx.types.ResRet.f32 %9, 1
+  %12 = extractvalue %dx.types.ResRet.f32 %9, 2
+  %13 = fmul fast float %10, %5
+  %14 = fmul fast float %11, %6
+  %15 = fmul fast float %12, %7
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %13)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %14)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %15)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %8)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.ResRet.f32 @dx.op.sample.f32(i32, %dx.types.Handle, %dx.types.Handle, float, float, float, float, i32, i32, i32, float) #2
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!10}
+!dx.entryPoints = !{!11}
+
+!0 = !{!"dxc(private) 1.8.0.4662 (416fab6b5)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 8}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{!5, null, null, !8}
+!5 = !{!6}
+!6 = !{i32 0, %"class.Texture2D<vector<float, 4> >"* undef, !"", i32 2, i32 0, i32 1, i32 2, i32 0, !7}
+!7 = !{i32 0, i32 9}
+!8 = !{!9}
+!9 = !{i32 0, %struct.SamplerState* undef, !"", i32 2, i32 0, i32 1, i32 0, null}
+!10 = !{[8 x i32] [i32 6, i32 4, i32 1, i32 2, i32 4, i32 8, i32 7, i32 7]}
+!11 = !{void ()* @main, !"main", !12, !4, null}
+!12 = !{!13, !20, null}
+!13 = !{!14, !17}
+!14 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !15, i8 2, i32 1, i8 4, i32 0, i8 0, !16}
+!15 = !{i32 0}
+!16 = !{i32 3, i32 15}
+!17 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !18, i8 2, i32 1, i8 2, i32 1, i8 0, !19}
+!18 = !{i32 1}
+!19 = !{i32 3, i32 3}
+!20 = !{!21}
+!21 = !{i32 0, !"SV_Target", i8 9, i8 16, !15, i8 0, i32 1, i8 4, i32 0, i8 0, !16}
+
+#endif
+
+static const unsigned char texture_rgb_frag_sm60_dxil[] = {
+  0x44, 0x58, 0x42, 0x43, 0x80, 0x0c, 0x49, 0xdc, 0x1e, 0x21, 0x6f, 0xab,
+  0x8e, 0x0c, 0x74, 0xde, 0x47, 0xb3, 0x50, 0xf3, 0x01, 0x00, 0x00, 0x00,
+  0x1c, 0x0f, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00,
+  0xd8, 0x01, 0x00, 0x00, 0x38, 0x08, 0x00, 0x00, 0x54, 0x08, 0x00, 0x00,
+  0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31, 0x54, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x00, 0x00, 0x00,
+  0x4f, 0x53, 0x47, 0x31, 0x34, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0x00, 0x00,
+  0x50, 0x53, 0x56, 0x30, 0xec, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x6d,
+  0x61, 0x69, 0x6e, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x42, 0x00,
+  0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x44, 0x10, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54, 0x58, 0x06, 0x00, 0x00,
+  0x60, 0x00, 0x00, 0x00, 0x96, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+  0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00,
+  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x8d, 0x01, 0x00, 0x00,
+  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d,
+  0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff,
+  0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66,
+  0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14,
+  0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0x9b, 0x86, 0xcb, 0x9f,
+  0xb0, 0x87, 0x90, 0xfc, 0x95, 0x90, 0x56, 0x62, 0xf2, 0x8b, 0xdb, 0x46,
+  0xc5, 0x18, 0x63, 0x10, 0x2a, 0xf7, 0x0c, 0x97, 0x3f, 0x61, 0x0f, 0x21,
+  0xf9, 0x21, 0xd0, 0x0c, 0x0b, 0x81, 0x82, 0x55, 0x18, 0x45, 0x18, 0x1b,
+  0x63, 0x0c, 0x42, 0xc8, 0xa0, 0x36, 0x47, 0x10, 0x14, 0x83, 0x91, 0x42,
+  0xc8, 0x23, 0x38, 0x10, 0x30, 0x8c, 0x40, 0x0c, 0x33, 0xb5, 0xc1, 0x38,
+  0xb0, 0x43, 0x38, 0xcc, 0xc3, 0x3c, 0xb8, 0x01, 0x2d, 0x94, 0x03, 0x3e,
+  0xd0, 0x43, 0x3d, 0xc8, 0x43, 0x39, 0xc8, 0x01, 0x29, 0xf0, 0x81, 0x3d,
+  0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x03, 0x1f, 0x98, 0x03, 0x3b,
+  0xbc, 0x43, 0x38, 0xd0, 0x03, 0x1b, 0x80, 0x01, 0x1d, 0xf8, 0x01, 0x18,
+  0xf8, 0x81, 0x1e, 0xe8, 0x41, 0x3b, 0xa4, 0x03, 0x3c, 0xcc, 0xc3, 0x2f,
+  0xd0, 0x43, 0x3e, 0xc0, 0x43, 0x39, 0xa0, 0x80, 0xcc, 0x24, 0x06, 0xe3,
+  0xc0, 0x0e, 0xe1, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xb4, 0x50, 0x0e, 0xf8,
+  0x40, 0x0f, 0xf5, 0x20, 0x0f, 0xe5, 0x20, 0x07, 0xa4, 0xc0, 0x07, 0xf6,
+  0x50, 0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x7c, 0x60, 0x0e, 0xec,
+  0xf0, 0x0e, 0xe1, 0x40, 0x0f, 0x6c, 0x00, 0x06, 0x74, 0xe0, 0x07, 0x60,
+  0xe0, 0x07, 0x48, 0x98, 0x94, 0xea, 0x4d, 0xd2, 0x14, 0x51, 0xc2, 0xe4,
+  0xb3, 0x00, 0xf3, 0x2c, 0x44, 0xc4, 0x4e, 0xc0, 0x44, 0xa0, 0x80, 0xd0,
+  0x4d, 0x04, 0x02, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87,
+  0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50,
+  0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86,
+  0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x30, 0xe4, 0x81, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x45, 0x50, 0x12,
+  0x65, 0x50, 0x1e, 0x85, 0x52, 0x08, 0x54, 0x4a, 0x62, 0x04, 0xa0, 0x08,
+  0x0a, 0xa1, 0x40, 0xc8, 0xce, 0x00, 0x10, 0x9e, 0x01, 0xa0, 0x3c, 0x16,
+  0x62, 0x10, 0x81, 0x40, 0x20, 0xc7, 0x01, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x7b, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4,
+  0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b,
+  0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91,
+  0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49,
+  0xd9, 0x10, 0x04, 0x13, 0x04, 0xa2, 0x98, 0x20, 0x10, 0xc6, 0x06, 0x61,
+  0x20, 0x36, 0x08, 0x04, 0x41, 0x01, 0x6e, 0x6e, 0x82, 0x40, 0x1c, 0x1b,
+  0x86, 0x03, 0x21, 0x26, 0x08, 0xd6, 0xc4, 0xe1, 0x2b, 0x66, 0x66, 0x82,
+  0x40, 0x20, 0x13, 0x04, 0x22, 0xd9, 0x20, 0x10, 0xcd, 0x86, 0x84, 0x50,
+  0x16, 0x86, 0x18, 0x18, 0xc2, 0xd9, 0x10, 0x3c, 0x13, 0x04, 0x8c, 0x22,
+  0xf3, 0xf5, 0x15, 0x33, 0xf3, 0x35, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26,
+  0xb7, 0x01, 0x21, 0x22, 0x89, 0x21, 0x06, 0x02, 0xd8, 0x10, 0x4c, 0x1b,
+  0x08, 0x08, 0x00, 0xa8, 0x09, 0x82, 0x00, 0x6c, 0x00, 0x36, 0x0c, 0xc4,
+  0x75, 0x6d, 0x08, 0xb0, 0x0d, 0xc3, 0x60, 0x65, 0x13, 0x84, 0xac, 0xda,
+  0x10, 0x6c, 0x24, 0xda, 0xc2, 0xd2, 0xdc, 0x88, 0x50, 0x15, 0x61, 0x0d,
+  0x3d, 0x3d, 0x49, 0x11, 0x4d, 0x10, 0x0a, 0x67, 0x82, 0x50, 0x3c, 0x1b,
+  0x02, 0x62, 0x82, 0x50, 0x40, 0x13, 0x84, 0x22, 0x9a, 0x20, 0x10, 0xca,
+  0x04, 0x81, 0x58, 0x36, 0x08, 0x64, 0x50, 0x06, 0x1b, 0x16, 0xc2, 0xfb,
+  0xc0, 0x20, 0x0c, 0xc4, 0x60, 0x18, 0x03, 0x02, 0x0c, 0xcc, 0x60, 0x43,
+  0x30, 0x6c, 0x10, 0xc8, 0x80, 0x0c, 0x36, 0x2c, 0x83, 0xf7, 0x81, 0x01,
+  0x1a, 0x88, 0xc1, 0x20, 0x06, 0x03, 0x18, 0xa4, 0xc1, 0x06, 0xe1, 0x0c,
+  0xd4, 0x80, 0xc9, 0x94, 0xd5, 0x17, 0x55, 0x98, 0xdc, 0x59, 0x19, 0xdd,
+  0x04, 0xa1, 0x90, 0x36, 0x2c, 0x04, 0x1b, 0x7c, 0x6d, 0x10, 0x06, 0x60,
+  0x30, 0x8c, 0x01, 0x01, 0x06, 0x66, 0xb0, 0x21, 0x70, 0x83, 0x0d, 0xc3,
+  0x1a, 0xbc, 0x01, 0xb0, 0xa1, 0xb0, 0x3a, 0x38, 0xa8, 0x00, 0x1a, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x73, 0x2c, 0xd2, 0xdc, 0xe6, 0xe8, 0xe6, 0x26,
+  0x08, 0x04, 0x43, 0x63, 0x2e, 0xed, 0xec, 0x8b, 0x8d, 0x8c, 0xc6, 0x5c,
+  0xda, 0xd9, 0xd7, 0x1c, 0xdd, 0x04, 0x81, 0x68, 0x88, 0xd0, 0x95, 0xe1,
+  0x7d, 0xb9, 0xbd, 0xc9, 0xb5, 0x6d, 0x50, 0xe4, 0x80, 0x0c, 0xe6, 0x80,
+  0x0e, 0xea, 0x00, 0xb1, 0x83, 0x3b, 0xc0, 0x83, 0xa1, 0x0a, 0x1b, 0x9b,
+  0x5d, 0x9b, 0x4b, 0x1a, 0x59, 0x99, 0x1b, 0xdd, 0x94, 0x20, 0xa8, 0x42,
+  0x86, 0xe7, 0x62, 0x57, 0x26, 0x37, 0x97, 0xf6, 0xe6, 0x36, 0x25, 0x20,
+  0x9a, 0x90, 0xe1, 0xb9, 0xd8, 0x85, 0xb1, 0xd9, 0x95, 0xc9, 0x4d, 0x09,
+  0x8a, 0x3a, 0x64, 0x78, 0x2e, 0x73, 0x68, 0x61, 0x64, 0x65, 0x72, 0x4d,
+  0x6f, 0x64, 0x65, 0x6c, 0x53, 0x02, 0xa4, 0x0c, 0x19, 0x9e, 0x8b, 0x5c,
+  0xd9, 0xdc, 0x5b, 0x9d, 0xdc, 0x58, 0xd9, 0xdc, 0x94, 0x80, 0xaa, 0x44,
+  0x86, 0xe7, 0x42, 0x97, 0x07, 0x57, 0x16, 0xe4, 0xe6, 0xf6, 0x46, 0x17,
+  0x46, 0x97, 0xf6, 0xe6, 0x36, 0x37, 0x25, 0xc8, 0xea, 0x90, 0xe1, 0xb9,
+  0xd8, 0xa5, 0x95, 0xdd, 0x25, 0x91, 0x4d, 0xd1, 0x85, 0xd1, 0x95, 0x4d,
+  0x09, 0xb6, 0x3a, 0x64, 0x78, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x50,
+  0x6f, 0x69, 0x6e, 0x74, 0x73, 0x53, 0x02, 0x38, 0xe8, 0x42, 0x86, 0xe7,
+  0x32, 0xf6, 0x56, 0xe7, 0x46, 0x57, 0x26, 0x37, 0x37, 0x25, 0xc0, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8,
+  0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b,
+  0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a,
+  0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e,
+  0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x46, 0x20, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x11, 0xc0, 0x44, 0x84,
+  0x40, 0x33, 0x2c, 0x84, 0x05, 0x4c, 0xc3, 0xe5, 0x3b, 0x8f, 0xbf, 0x38,
+  0xc0, 0x20, 0x36, 0x0f, 0x35, 0xf9, 0xc5, 0x6d, 0xdb, 0x00, 0x34, 0x5c,
+  0xbe, 0xf3, 0xf8, 0x12, 0xc0, 0x3c, 0x0b, 0xe1, 0x17, 0xb7, 0x6d, 0x02,
+  0xd5, 0x70, 0xf9, 0xce, 0xe3, 0x4b, 0x93, 0x13, 0x11, 0x28, 0x35, 0x3d,
+  0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x99, 0xb8, 0x43, 0xa7, 0x6b, 0x99, 0x9a,
+  0xab, 0x78, 0x55, 0x70, 0x05, 0x2a, 0xf6, 0xa1, 0x44, 0x58, 0x49, 0x4c,
+  0xc0, 0x06, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00,
+  0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0xa8, 0x06, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
+  0xa7, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00,
+  0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42,
+  0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x43, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00,
+  0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29,
+  0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1,
+  0x9b, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0xfc, 0x95, 0x90, 0x56, 0x62,
+  0xf2, 0x8b, 0xdb, 0x46, 0xc5, 0x18, 0x63, 0x10, 0x2a, 0xf7, 0x0c, 0x97,
+  0x3f, 0x61, 0x0f, 0x21, 0xf9, 0x21, 0xd0, 0x0c, 0x0b, 0x81, 0x82, 0x55,
+  0x18, 0x45, 0x18, 0x1b, 0x63, 0x0c, 0x42, 0xc8, 0xa0, 0x36, 0x47, 0x10,
+  0x14, 0x83, 0x91, 0x42, 0xc8, 0x23, 0x38, 0x10, 0x30, 0x8c, 0x40, 0x0c,
+  0x33, 0xb5, 0xc1, 0x38, 0xb0, 0x43, 0x38, 0xcc, 0xc3, 0x3c, 0xb8, 0x01,
+  0x2d, 0x94, 0x03, 0x3e, 0xd0, 0x43, 0x3d, 0xc8, 0x43, 0x39, 0xc8, 0x01,
+  0x29, 0xf0, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x03,
+  0x1f, 0x98, 0x03, 0x3b, 0xbc, 0x43, 0x38, 0xd0, 0x03, 0x1b, 0x80, 0x01,
+  0x1d, 0xf8, 0x01, 0x18, 0xf8, 0x81, 0x1e, 0xe8, 0x41, 0x3b, 0xa4, 0x03,
+  0x3c, 0xcc, 0xc3, 0x2f, 0xd0, 0x43, 0x3e, 0xc0, 0x43, 0x39, 0xa0, 0x80,
+  0xcc, 0x24, 0x06, 0xe3, 0xc0, 0x0e, 0xe1, 0x30, 0x0f, 0xf3, 0xe0, 0x06,
+  0xb4, 0x50, 0x0e, 0xf8, 0x40, 0x0f, 0xf5, 0x20, 0x0f, 0xe5, 0x20, 0x07,
+  0xa4, 0xc0, 0x07, 0xf6, 0x50, 0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f,
+  0x7c, 0x60, 0x0e, 0xec, 0xf0, 0x0e, 0xe1, 0x40, 0x0f, 0x6c, 0x00, 0x06,
+  0x74, 0xe0, 0x07, 0x60, 0xe0, 0x07, 0x48, 0x98, 0x94, 0xea, 0x4d, 0xd2,
+  0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x00, 0xf3, 0x2c, 0x44, 0xc4, 0x4e, 0xc0,
+  0x44, 0xa0, 0x80, 0xd0, 0x4d, 0x04, 0x02, 0x00, 0x13, 0x14, 0x72, 0xc0,
+  0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0,
+  0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d,
+  0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x81, 0x80, 0x00, 0x18,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50,
+  0x10, 0xc5, 0x50, 0x04, 0x25, 0x51, 0x06, 0xe5, 0x41, 0xa5, 0x24, 0x46,
+  0x00, 0x8a, 0xa0, 0x10, 0x0a, 0x84, 0xec, 0x0c, 0x00, 0xe1, 0x19, 0x00,
+  0xca, 0x63, 0x21, 0x06, 0x11, 0x08, 0x04, 0x72, 0x1c, 0x00, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90,
+  0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b,
+  0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71,
+  0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13,
+  0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xa2, 0x98, 0x20,
+  0x10, 0xc6, 0x06, 0x61, 0x20, 0x26, 0x08, 0xc4, 0xb1, 0x41, 0x18, 0x0c,
+  0x0a, 0x70, 0x73, 0x13, 0x04, 0x02, 0xd9, 0x30, 0x20, 0x09, 0x31, 0x41,
+  0xb0, 0x24, 0x02, 0x13, 0x04, 0x22, 0x99, 0x20, 0x10, 0xca, 0x06, 0x81,
+  0x70, 0x36, 0x24, 0xc4, 0xc2, 0x34, 0xc4, 0xd0, 0x10, 0xcf, 0x86, 0x00,
+  0x9a, 0x20, 0x60, 0xd3, 0x06, 0x84, 0x90, 0x98, 0x86, 0x18, 0x08, 0x60,
+  0x43, 0x30, 0x6d, 0x20, 0x22, 0x00, 0xa0, 0x26, 0x08, 0x19, 0xb5, 0x21,
+  0xb0, 0x26, 0x08, 0x02, 0x40, 0xa2, 0x2d, 0x2c, 0xcd, 0x8d, 0x08, 0x55,
+  0x11, 0xd6, 0xd0, 0xd3, 0x93, 0x14, 0xd1, 0x04, 0xa1, 0x68, 0x26, 0x08,
+  0x85, 0xb3, 0x21, 0x20, 0x26, 0x08, 0xc5, 0x33, 0x41, 0x28, 0xa0, 0x09,
+  0x02, 0xb1, 0x4c, 0x10, 0x08, 0x66, 0x83, 0x00, 0x06, 0x61, 0xb0, 0x61,
+  0x21, 0xb4, 0x8d, 0xeb, 0xbc, 0xe1, 0x23, 0x38, 0x31, 0xd8, 0x10, 0x0c,
+  0x1b, 0x04, 0x30, 0x00, 0x83, 0x0d, 0xcb, 0xa0, 0x6d, 0x1c, 0x19, 0x78,
+  0x83, 0x37, 0x70, 0x65, 0xb0, 0x41, 0x18, 0x03, 0x33, 0x60, 0x32, 0x65,
+  0xf5, 0x45, 0x15, 0x26, 0x77, 0x56, 0x46, 0x37, 0x41, 0x28, 0xa2, 0x0d,
+  0x0b, 0x81, 0x06, 0x5b, 0x1a, 0x74, 0xdc, 0xf0, 0x11, 0x9c, 0x18, 0x6c,
+  0x08, 0xd4, 0x60, 0xc3, 0x70, 0x06, 0x6b, 0x00, 0x6c, 0x28, 0xb0, 0x8c,
+  0x0d, 0x2a, 0xa0, 0x0a, 0x1b, 0x9b, 0x5d, 0x9b, 0x4b, 0x1a, 0x59, 0x99,
+  0x1b, 0xdd, 0x94, 0x20, 0xa8, 0x42, 0x86, 0xe7, 0x62, 0x57, 0x26, 0x37,
+  0x97, 0xf6, 0xe6, 0x36, 0x25, 0x20, 0x9a, 0x90, 0xe1, 0xb9, 0xd8, 0x85,
+  0xb1, 0xd9, 0x95, 0xc9, 0x4d, 0x09, 0x8c, 0x3a, 0x64, 0x78, 0x2e, 0x73,
+  0x68, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x53, 0x82,
+  0xa4, 0x0c, 0x19, 0x9e, 0x8b, 0x5c, 0xd9, 0xdc, 0x5b, 0x9d, 0xdc, 0x58,
+  0xd9, 0xdc, 0x94, 0x80, 0xaa, 0x43, 0x86, 0xe7, 0x62, 0x97, 0x56, 0x76,
+  0x97, 0x44, 0x36, 0x45, 0x17, 0x46, 0x57, 0x36, 0x25, 0xb0, 0xea, 0x90,
+  0xe1, 0xb9, 0x94, 0xb9, 0xd1, 0xc9, 0xe5, 0x41, 0xbd, 0xa5, 0xb9, 0xd1,
+  0xcd, 0x4d, 0x09, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87,
+  0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87,
+  0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40,
+  0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x46, 0x20, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10,
+  0x11, 0xc0, 0x44, 0x84, 0x40, 0x33, 0x2c, 0x84, 0x05, 0x4c, 0xc3, 0xe5,
+  0x3b, 0x8f, 0xbf, 0x38, 0xc0, 0x20, 0x36, 0x0f, 0x35, 0xf9, 0xc5, 0x6d,
+  0xdb, 0x00, 0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x12, 0xc0, 0x3c, 0x0b, 0xe1,
+  0x17, 0xb7, 0x6d, 0x02, 0xd5, 0x70, 0xf9, 0xce, 0xe3, 0x4b, 0x93, 0x13,
+  0x11, 0x28, 0x35, 0x3d, 0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x00, 0x04, 0x03,
+  0x20, 0x0d, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0xf4, 0x46, 0x00, 0x88, 0xcc, 0x00, 0x14, 0x42, 0x29, 0x94, 0x5c, 0xe1,
+  0x51, 0x29, 0x83, 0x12, 0xa0, 0x31, 0x03, 0x00, 0x23, 0x06, 0x09, 0x00,
+  0x82, 0x60, 0x00, 0x69, 0x05, 0x84, 0x61, 0xc9, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x40, 0x9b, 0x41, 0x64, 0x99, 0x32, 0x62, 0x90, 0x00, 0x20,
+  0x08, 0x06, 0xc6, 0x97, 0x6c, 0x9a, 0xa4, 0x8c, 0x18, 0x24, 0x00, 0x08,
+  0x82, 0x81, 0x01, 0x06, 0x0a, 0xb7, 0x15, 0xcb, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x18, 0x61, 0xb0, 0x70, 0x1c, 0xc5, 0x8c, 0x18, 0x24, 0x00,
+  0x08, 0x82, 0x81, 0x21, 0x06, 0x4c, 0xd7, 0x1d, 0xcd, 0x88, 0x41, 0x02,
+  0x80, 0x20, 0x18, 0x18, 0x63, 0xd0, 0x78, 0x5e, 0xe5, 0x8c, 0x18, 0x24,
+  0x00, 0x08, 0x82, 0x81, 0x41, 0x06, 0xce, 0xf7, 0x29, 0xcf, 0x88, 0xc1,
+  0x03, 0x80, 0x20, 0x18, 0x34, 0x63, 0xc0, 0x20, 0x87, 0x51, 0x24, 0x09,
+  0x18, 0x80, 0x01, 0x94, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0x82, 0x0d, 0x88, 0x7c, 0x6c, 0x40, 0xe4, 0x63, 0x03, 0x22,
+  0x9f, 0x11, 0x83, 0x04, 0x00, 0x41, 0x30, 0x40, 0xd6, 0xa0, 0x3a, 0x83,
+  0x33, 0xf8, 0x86, 0x11, 0x83, 0x04, 0x00, 0x41, 0x30, 0x40, 0xd6, 0xa0,
+  0x3a, 0x83, 0x33, 0x88, 0x84, 0x11, 0x83, 0x04, 0x00, 0x41, 0x30, 0x40,
+  0xd6, 0xa0, 0x3a, 0x83, 0x33, 0xf0, 0x82, 0x11, 0x83, 0x04, 0x00, 0x41,
+  0x30, 0x40, 0xd6, 0xa0, 0x3a, 0x83, 0x33, 0x90, 0x10, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.spv.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.spv.h
new file mode 100644
index 0000000..3ba7d55
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgb.frag.spv.h
@@ -0,0 +1,59 @@
+static const unsigned char texture_rgb_frag_spv[] = {
+  0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x08, 0x00,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+  0x01, 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, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0x22, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x1c, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x0c, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x17, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x80, 0x3f, 0x20, 0x00, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x57, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x07, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+};
+static const unsigned int texture_rgb_frag_spv_len = 668;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag
new file mode 100644
index 0000000..05fd18c
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag
@@ -0,0 +1,12 @@
+#version 450
+
+layout(location = 0) in vec4 v_color;
+layout(location = 1) in vec2 v_uv;
+
+layout(set = 2, binding = 0) uniform sampler2D u_texture;
+
+layout(location = 0) out vec4 o_color;
+
+void main() {
+    o_color = texture(u_texture, v_uv) * v_color;
+}
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.metal.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.metal.h
new file mode 100644
index 0000000..9c8f150
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.metal.h
@@ -0,0 +1,40 @@
+static const unsigned char texture_rgba_frag_metal[] = {
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x3e, 0x0a,
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x69,
+  0x6d, 0x64, 0x2f, 0x73, 0x69, 0x6d, 0x64, 0x2e, 0x68, 0x3e, 0x0a, 0x0a,
+  0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x3b, 0x0a, 0x0a,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30,
+  0x5f, 0x6f, 0x75, 0x74, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x39, 0x20, 0x5b, 0x5b,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a,
+  0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d,
+  0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x0a, 0x7b, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x32,
+  0x31, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72, 0x28, 0x6c, 0x6f, 0x63,
+  0x6e, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x6d, 0x5f, 0x31, 0x37, 0x20, 0x5b,
+  0x5b, 0x75, 0x73, 0x65, 0x72, 0x28, 0x6c, 0x6f, 0x63, 0x6e, 0x31, 0x29,
+  0x5d, 0x5d, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x66, 0x72, 0x61, 0x67,
+  0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f,
+  0x75, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x28, 0x6d, 0x61, 0x69,
+  0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x5b, 0x5b, 0x73,
+  0x74, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x5d, 0x5d, 0x2c, 0x20, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x3e, 0x20, 0x5f, 0x31, 0x33, 0x20, 0x5b, 0x5b, 0x74, 0x65,
+  0x78, 0x74, 0x75, 0x72, 0x65, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x2c, 0x20,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x20, 0x5f, 0x31, 0x33, 0x53,
+  0x6d, 0x70, 0x6c, 0x72, 0x20, 0x5b, 0x5b, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x29, 0x0a, 0x7b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74,
+  0x20, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e, 0x6d, 0x5f, 0x39, 0x20, 0x3d,
+  0x20, 0x5f, 0x31, 0x33, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x28,
+  0x5f, 0x31, 0x33, 0x53, 0x6d, 0x70, 0x6c, 0x72, 0x2c, 0x20, 0x69, 0x6e,
+  0x2e, 0x6d, 0x5f, 0x31, 0x37, 0x29, 0x20, 0x2a, 0x20, 0x69, 0x6e, 0x2e,
+  0x6d, 0x5f, 0x32, 0x31, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
+  0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x3b, 0x0a, 0x7d, 0x0a,
+  0x0a
+};
+static const unsigned int texture_rgba_frag_metal_len = 433;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.sm50.dxbc.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.sm50.dxbc.h
new file mode 100644
index 0000000..d240991
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.sm50.dxbc.h
@@ -0,0 +1,120 @@
+static const signed char texture_rgba_frag_sm50_dxbc[] =
+{
+  68,  88,  66,  67, -83, 124,
+  -3, -84,-102, 126,  29, -62,
+-107,  79, -74,  72,  -7,  33,
+ 124,-103,   1,   0,   0,   0,
+ -72,   2,   0,   0,   5,   0,
+   0,   0,  52,   0,   0,   0,
+ -12,   0,   0,   0,  64,   1,
+   0,   0, 116,   1,   0,   0,
+  28,   2,   0,   0,  82,  68,
+  69,  70, -72,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   2,   0,   0,   0,
+  60,   0,   0,   0,   0,   5,
+  -1,  -1,   0,   1,   0,   0,
+-115,   0,   0,   0,  82,  68,
+  49,  49,  60,   0,   0,   0,
+  24,   0,   0,   0,  32,   0,
+   0,   0,  40,   0,   0,   0,
+  36,   0,   0,   0,  12,   0,
+   0,   0,   0,   0,   0,   0,
+ 124,   0,   0,   0,   3,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0,-119,   0,   0,   0,
+   2,   0,   0,   0,   5,   0,
+   0,   0,   4,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,   1,   0,   0,   0,
+  13,   0,   0,   0,  95,  95,
+  49,  51,  95, 115,  97, 109,
+ 112, 108, 101, 114,   0,  95,
+  49,  51,   0,  77, 105,  99,
+ 114, 111, 115, 111, 102, 116,
+  32,  40,  82,  41,  32,  72,
+  76,  83,  76,  32,  83, 104,
+  97, 100, 101, 114,  32,  67,
+ 111, 109, 112, 105, 108, 101,
+ 114,  32,  49,  48,  46,  49,
+   0, -85, -85, -85,  73,  83,
+  71,  78,  68,   0,   0,   0,
+   2,   0,   0,   0,   8,   0,
+   0,   0,  56,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+   0,   0,   0,   0,  15,  15,
+   0,   0,  56,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+   1,   0,   0,   0,   3,   3,
+   0,   0,  84,  69,  88,  67,
+  79,  79,  82,  68,   0, -85,
+ -85, -85,  79,  83,  71,  78,
+  44,   0,   0,   0,   1,   0,
+   0,   0,   8,   0,   0,   0,
+  32,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,  15,   0,   0,   0,
+  83,  86,  95,  84,  97, 114,
+ 103, 101, 116,   0, -85, -85,
+  83,  72,  69,  88, -96,   0,
+   0,   0,  80,   0,   0,   0,
+  40,   0,   0,   0, 106,   8,
+   0,   1,  90,   0,   0,   3,
+   0,  96,  16,   0,   0,   0,
+   0,   0,  88,  24,   0,   4,
+   0, 112,  16,   0,   0,   0,
+   0,   0,  85,  85,   0,   0,
+  98,  16,   0,   3, -14,  16,
+  16,   0,   0,   0,   0,   0,
+  98,  16,   0,   3,  50,  16,
+  16,   0,   1,   0,   0,   0,
+ 101,   0,   0,   3, -14,  32,
+  16,   0,   0,   0,   0,   0,
+ 104,   0,   0,   2,   1,   0,
+   0,   0,  69,   0,   0,-117,
+ -62,   0,   0,-128,  67,  85,
+  21,   0, -14,   0,  16,   0,
+   0,   0,   0,   0,  70,  16,
+  16,   0,   1,   0,   0,   0,
+  70, 126,  16,   0,   0,   0,
+   0,   0,   0,  96,  16,   0,
+   0,   0,   0,   0,  56,   0,
+   0,   7, -14,  32,  16,   0,
+   0,   0,   0,   0,  70,  14,
+  16,   0,   0,   0,   0,   0,
+  70,  30,  16,   0,   0,   0,
+   0,   0,  62,   0,   0,   1,
+  83,  84,  65,  84,-108,   0,
+   0,   0,   3,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   3,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   1,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0
+
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.sm60.dxil.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.sm60.dxil.h
new file mode 100644
index 0000000..eba7080
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.sm60.dxil.h
@@ -0,0 +1,467 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xyzw        0     NONE   float   xyzw
+; TEXCOORD                 1   xy          1     NONE   float   xy  
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; SV_Target                0   xyzw        0   TARGET   float   xyzw
+;
+; shader hash: ab99026f3068b3314341ba15eaf626a8
+;
+; Pipeline Runtime Information: 
+;
+; Pixel Shader
+; DepthOutput=0
+; SampleFrequency=0
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                 linear       
+; TEXCOORD                 1                 linear       
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; SV_Target                0                              
+;
+; Buffer Definitions:
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; __13_sampler                      sampler      NA          NA      S0      s0,space2     1
+; _13                               texture     f32          2d      T0      t0,space2     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 6, outputs: 4
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 0, 4, 5 }
+;   output 1 depends on inputs: { 1, 4, 5 }
+;   output 2 depends on inputs: { 2, 4, 5 }
+;   output 3 depends on inputs: { 3, 4, 5 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.ResRet.f32 = type { float, float, float, float, i32 }
+%"class.Texture2D<vector<float, 4> >" = type { <4 x float>, %"class.Texture2D<vector<float, 4> >::mips_type" }
+%"class.Texture2D<vector<float, 4> >::mips_type" = type { i32 }
+%struct.SamplerState = type { i32 }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 0, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 3, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call %dx.types.ResRet.f32 @dx.op.sample.f32(i32 60, %dx.types.Handle %1, %dx.types.Handle %2, float %3, float %4, float undef, float undef, i32 0, i32 0, i32 undef, float undef)  ; Sample(srv,sampler,coord0,coord1,coord2,coord3,offset0,offset1,offset2,clamp)
+  %10 = extractvalue %dx.types.ResRet.f32 %9, 0
+  %11 = extractvalue %dx.types.ResRet.f32 %9, 1
+  %12 = extractvalue %dx.types.ResRet.f32 %9, 2
+  %13 = extractvalue %dx.types.ResRet.f32 %9, 3
+  %14 = fmul fast float %10, %5
+  %15 = fmul fast float %11, %6
+  %16 = fmul fast float %12, %7
+  %17 = fmul fast float %13, %8
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %14)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %15)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %16)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %17)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.ResRet.f32 @dx.op.sample.f32(i32, %dx.types.Handle, %dx.types.Handle, float, float, float, float, i32, i32, i32, float) #2
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!10}
+!dx.entryPoints = !{!11}
+
+!0 = !{!"dxc(private) 1.8.0.4662 (416fab6b5)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 8}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{!5, null, null, !8}
+!5 = !{!6}
+!6 = !{i32 0, %"class.Texture2D<vector<float, 4> >"* undef, !"", i32 2, i32 0, i32 1, i32 2, i32 0, !7}
+!7 = !{i32 0, i32 9}
+!8 = !{!9}
+!9 = !{i32 0, %struct.SamplerState* undef, !"", i32 2, i32 0, i32 1, i32 0, null}
+!10 = !{[8 x i32] [i32 6, i32 4, i32 1, i32 2, i32 4, i32 8, i32 15, i32 15]}
+!11 = !{void ()* @main, !"main", !12, !4, null}
+!12 = !{!13, !20, null}
+!13 = !{!14, !17}
+!14 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !15, i8 2, i32 1, i8 4, i32 0, i8 0, !16}
+!15 = !{i32 0}
+!16 = !{i32 3, i32 15}
+!17 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !18, i8 2, i32 1, i8 2, i32 1, i8 0, !19}
+!18 = !{i32 1}
+!19 = !{i32 3, i32 3}
+!20 = !{!21}
+!21 = !{i32 0, !"SV_Target", i8 9, i8 16, !15, i8 0, i32 1, i8 4, i32 0, i8 0, !16}
+
+#endif
+
+static const unsigned char texture_rgba_frag_sm60_dxil[] = {
+  0x44, 0x58, 0x42, 0x43, 0x5c, 0x82, 0x6d, 0x45, 0x43, 0x35, 0xdf, 0xf5,
+  0xad, 0xf7, 0x1b, 0x5e, 0xc0, 0x65, 0x38, 0x3f, 0x01, 0x00, 0x00, 0x00,
+  0x24, 0x0f, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00,
+  0xd8, 0x01, 0x00, 0x00, 0x38, 0x08, 0x00, 0x00, 0x54, 0x08, 0x00, 0x00,
+  0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31, 0x54, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x00, 0x00, 0x00,
+  0x4f, 0x53, 0x47, 0x31, 0x34, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x56, 0x5f, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x00, 0x00, 0x00,
+  0x50, 0x53, 0x56, 0x30, 0xec, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x6d,
+  0x61, 0x69, 0x6e, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x42, 0x00,
+  0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x44, 0x10, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54, 0x58, 0x06, 0x00, 0x00,
+  0x60, 0x00, 0x00, 0x00, 0x96, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+  0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00,
+  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x8d, 0x01, 0x00, 0x00,
+  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d,
+  0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff,
+  0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66,
+  0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14,
+  0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0x9b, 0x86, 0xcb, 0x9f,
+  0xb0, 0x87, 0x90, 0xfc, 0x95, 0x90, 0x56, 0x62, 0xf2, 0x8b, 0xdb, 0x46,
+  0xc5, 0x18, 0x63, 0x10, 0x2a, 0xf7, 0x0c, 0x97, 0x3f, 0x61, 0x0f, 0x21,
+  0xf9, 0x21, 0xd0, 0x0c, 0x0b, 0x81, 0x82, 0x55, 0x18, 0x45, 0x18, 0x1b,
+  0x63, 0x0c, 0x42, 0xc8, 0xa0, 0x36, 0x47, 0x10, 0x14, 0x83, 0x91, 0x42,
+  0xc8, 0x23, 0x38, 0x10, 0x30, 0x8c, 0x40, 0x0c, 0x33, 0xb5, 0xc1, 0x38,
+  0xb0, 0x43, 0x38, 0xcc, 0xc3, 0x3c, 0xb8, 0x01, 0x2d, 0x94, 0x03, 0x3e,
+  0xd0, 0x43, 0x3d, 0xc8, 0x43, 0x39, 0xc8, 0x01, 0x29, 0xf0, 0x81, 0x3d,
+  0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x03, 0x1f, 0x98, 0x03, 0x3b,
+  0xbc, 0x43, 0x38, 0xd0, 0x03, 0x1b, 0x80, 0x01, 0x1d, 0xf8, 0x01, 0x18,
+  0xf8, 0x81, 0x1e, 0xe8, 0x41, 0x3b, 0xa4, 0x03, 0x3c, 0xcc, 0xc3, 0x2f,
+  0xd0, 0x43, 0x3e, 0xc0, 0x43, 0x39, 0xa0, 0x80, 0xcc, 0x24, 0x06, 0xe3,
+  0xc0, 0x0e, 0xe1, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xb4, 0x50, 0x0e, 0xf8,
+  0x40, 0x0f, 0xf5, 0x20, 0x0f, 0xe5, 0x20, 0x07, 0xa4, 0xc0, 0x07, 0xf6,
+  0x50, 0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x7c, 0x60, 0x0e, 0xec,
+  0xf0, 0x0e, 0xe1, 0x40, 0x0f, 0x6c, 0x00, 0x06, 0x74, 0xe0, 0x07, 0x60,
+  0xe0, 0x07, 0x48, 0x98, 0x94, 0xea, 0x4d, 0xd2, 0x14, 0x51, 0xc2, 0xe4,
+  0xb3, 0x00, 0xf3, 0x2c, 0x44, 0xc4, 0x4e, 0xc0, 0x44, 0xa0, 0x80, 0xd0,
+  0x4d, 0x04, 0x02, 0x00, 0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87,
+  0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50,
+  0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10,
+  0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86,
+  0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x30, 0xe4, 0x81, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47,
+  0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50, 0x0c, 0x45, 0x50, 0x12,
+  0x65, 0x50, 0x1e, 0x85, 0x50, 0x2c, 0x54, 0x4a, 0x62, 0x04, 0xa0, 0x08,
+  0x0a, 0xa1, 0x40, 0xc8, 0xce, 0x00, 0x10, 0x9e, 0x01, 0xa0, 0x3c, 0x16,
+  0x62, 0x10, 0x81, 0x40, 0x20, 0xcf, 0x03, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x7b, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4,
+  0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b,
+  0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91,
+  0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49,
+  0xd9, 0x10, 0x04, 0x13, 0x04, 0xa2, 0x98, 0x20, 0x10, 0xc6, 0x06, 0x61,
+  0x20, 0x36, 0x08, 0x04, 0x41, 0x01, 0x6e, 0x6e, 0x82, 0x40, 0x1c, 0x1b,
+  0x86, 0x03, 0x21, 0x26, 0x08, 0xd6, 0xc4, 0xe1, 0x2b, 0x66, 0x66, 0x82,
+  0x40, 0x20, 0x13, 0x04, 0x22, 0xd9, 0x20, 0x10, 0xcd, 0x86, 0x84, 0x50,
+  0x16, 0x86, 0x18, 0x18, 0xc2, 0xd9, 0x10, 0x3c, 0x13, 0x04, 0x8c, 0x22,
+  0xf3, 0xf5, 0x15, 0x33, 0xf3, 0x35, 0x17, 0xd6, 0x06, 0xc7, 0x56, 0x26,
+  0xb7, 0x01, 0x21, 0x22, 0x89, 0x21, 0x06, 0x02, 0xd8, 0x10, 0x4c, 0x1b,
+  0x08, 0x08, 0x00, 0xa8, 0x09, 0x82, 0x00, 0x6c, 0x00, 0x36, 0x0c, 0xc4,
+  0x75, 0x6d, 0x08, 0xb0, 0x0d, 0xc3, 0x60, 0x65, 0x13, 0x84, 0xac, 0xda,
+  0x10, 0x6c, 0x24, 0xda, 0xc2, 0xd2, 0xdc, 0x88, 0x50, 0x15, 0x61, 0x0d,
+  0x3d, 0x3d, 0x49, 0x11, 0x4d, 0x10, 0x0a, 0x67, 0x82, 0x50, 0x3c, 0x1b,
+  0x02, 0x62, 0x82, 0x50, 0x40, 0x13, 0x84, 0x22, 0x9a, 0x20, 0x10, 0xca,
+  0x04, 0x81, 0x58, 0x36, 0x08, 0x64, 0x50, 0x06, 0x1b, 0x16, 0xc2, 0xfb,
+  0xc0, 0x20, 0x0c, 0xc4, 0x60, 0x18, 0x03, 0x02, 0x0c, 0xcc, 0x60, 0x43,
+  0x30, 0x6c, 0x10, 0xc8, 0x80, 0x0c, 0x36, 0x2c, 0x83, 0xf7, 0x81, 0x01,
+  0x1a, 0x88, 0xc1, 0x20, 0x06, 0x03, 0x18, 0xa4, 0xc1, 0x06, 0xe1, 0x0c,
+  0xd4, 0x80, 0xc9, 0x94, 0xd5, 0x17, 0x55, 0x98, 0xdc, 0x59, 0x19, 0xdd,
+  0x04, 0xa1, 0x90, 0x36, 0x2c, 0x04, 0x1b, 0x7c, 0x6d, 0x10, 0x06, 0x60,
+  0x30, 0x8c, 0x01, 0x01, 0x06, 0x66, 0xb0, 0x21, 0x70, 0x83, 0x0d, 0xc3,
+  0x1a, 0xbc, 0x01, 0xb0, 0xa1, 0xb0, 0x3a, 0x38, 0xa8, 0x00, 0x1a, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x73, 0x13, 0x04, 0x82, 0x61, 0x91, 0xe6, 0x36,
+  0x47, 0x37, 0x37, 0x41, 0x20, 0x1a, 0x1a, 0x73, 0x69, 0x67, 0x5f, 0x6c,
+  0x64, 0x34, 0xe6, 0xd2, 0xce, 0xbe, 0xe6, 0xe8, 0x88, 0xd0, 0x95, 0xe1,
+  0x7d, 0xb9, 0xbd, 0xc9, 0xb5, 0x6d, 0x50, 0xe4, 0x60, 0x0e, 0xe8, 0xa0,
+  0x0e, 0xec, 0x00, 0xb9, 0x83, 0x39, 0xc0, 0x83, 0xa1, 0x0a, 0x1b, 0x9b,
+  0x5d, 0x9b, 0x4b, 0x1a, 0x59, 0x99, 0x1b, 0xdd, 0x94, 0x20, 0xa8, 0x42,
+  0x86, 0xe7, 0x62, 0x57, 0x26, 0x37, 0x97, 0xf6, 0xe6, 0x36, 0x25, 0x20,
+  0x9a, 0x90, 0xe1, 0xb9, 0xd8, 0x85, 0xb1, 0xd9, 0x95, 0xc9, 0x4d, 0x09,
+  0x8a, 0x3a, 0x64, 0x78, 0x2e, 0x73, 0x68, 0x61, 0x64, 0x65, 0x72, 0x4d,
+  0x6f, 0x64, 0x65, 0x6c, 0x53, 0x02, 0xa4, 0x0c, 0x19, 0x9e, 0x8b, 0x5c,
+  0xd9, 0xdc, 0x5b, 0x9d, 0xdc, 0x58, 0xd9, 0xdc, 0x94, 0x80, 0xaa, 0x44,
+  0x86, 0xe7, 0x42, 0x97, 0x07, 0x57, 0x16, 0xe4, 0xe6, 0xf6, 0x46, 0x17,
+  0x46, 0x97, 0xf6, 0xe6, 0x36, 0x37, 0x25, 0xc8, 0xea, 0x90, 0xe1, 0xb9,
+  0xd8, 0xa5, 0x95, 0xdd, 0x25, 0x91, 0x4d, 0xd1, 0x85, 0xd1, 0x95, 0x4d,
+  0x09, 0xb6, 0x3a, 0x64, 0x78, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x50,
+  0x6f, 0x69, 0x6e, 0x74, 0x73, 0x53, 0x02, 0x38, 0xe8, 0x42, 0x86, 0xe7,
+  0x32, 0xf6, 0x56, 0xe7, 0x46, 0x57, 0x26, 0x37, 0x37, 0x25, 0xc0, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
+  0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73,
+  0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e,
+  0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30,
+  0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8,
+  0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b,
+  0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76,
+  0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e,
+  0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e,
+  0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61,
+  0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4,
+  0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37,
+  0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76,
+  0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71,
+  0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e,
+  0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61,
+  0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90,
+  0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8,
+  0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc,
+  0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8,
+  0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b,
+  0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a,
+  0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e,
+  0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x46, 0x20, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10, 0x11, 0xc0, 0x44, 0x84,
+  0x40, 0x33, 0x2c, 0x84, 0x05, 0x4c, 0xc3, 0xe5, 0x3b, 0x8f, 0xbf, 0x38,
+  0xc0, 0x20, 0x36, 0x0f, 0x35, 0xf9, 0xc5, 0x6d, 0xdb, 0x00, 0x34, 0x5c,
+  0xbe, 0xf3, 0xf8, 0x12, 0xc0, 0x3c, 0x0b, 0xe1, 0x17, 0xb7, 0x6d, 0x02,
+  0xd5, 0x70, 0xf9, 0xce, 0xe3, 0x4b, 0x93, 0x13, 0x11, 0x28, 0x35, 0x3d,
+  0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xab, 0x99, 0x02, 0x6f, 0x30, 0x68, 0xb3, 0x31,
+  0x43, 0x41, 0xba, 0x15, 0xea, 0xf6, 0x26, 0xa8, 0x44, 0x58, 0x49, 0x4c,
+  0xc8, 0x06, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xb2, 0x01, 0x00, 0x00,
+  0x44, 0x58, 0x49, 0x4c, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0xb0, 0x06, 0x00, 0x00, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00,
+  0xa9, 0x01, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49,
+  0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19,
+  0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42,
+  0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88,
+  0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42,
+  0xe4, 0x48, 0x0e, 0x90, 0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c,
+  0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07,
+  0x40, 0x02, 0xa8, 0x0d, 0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x6d, 0x30, 0x86, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00,
+  0x49, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42,
+  0x20, 0x4c, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00,
+  0x43, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04,
+  0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14,
+  0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x68, 0x23, 0x00,
+  0x25, 0x00, 0x14, 0x66, 0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29,
+  0xc6, 0x20, 0x84, 0x14, 0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1,
+  0x9b, 0x86, 0xcb, 0x9f, 0xb0, 0x87, 0x90, 0xfc, 0x95, 0x90, 0x56, 0x62,
+  0xf2, 0x8b, 0xdb, 0x46, 0xc5, 0x18, 0x63, 0x10, 0x2a, 0xf7, 0x0c, 0x97,
+  0x3f, 0x61, 0x0f, 0x21, 0xf9, 0x21, 0xd0, 0x0c, 0x0b, 0x81, 0x82, 0x55,
+  0x18, 0x45, 0x18, 0x1b, 0x63, 0x0c, 0x42, 0xc8, 0xa0, 0x36, 0x47, 0x10,
+  0x14, 0x83, 0x91, 0x42, 0xc8, 0x23, 0x38, 0x10, 0x30, 0x8c, 0x40, 0x0c,
+  0x33, 0xb5, 0xc1, 0x38, 0xb0, 0x43, 0x38, 0xcc, 0xc3, 0x3c, 0xb8, 0x01,
+  0x2d, 0x94, 0x03, 0x3e, 0xd0, 0x43, 0x3d, 0xc8, 0x43, 0x39, 0xc8, 0x01,
+  0x29, 0xf0, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x03,
+  0x1f, 0x98, 0x03, 0x3b, 0xbc, 0x43, 0x38, 0xd0, 0x03, 0x1b, 0x80, 0x01,
+  0x1d, 0xf8, 0x01, 0x18, 0xf8, 0x81, 0x1e, 0xe8, 0x41, 0x3b, 0xa4, 0x03,
+  0x3c, 0xcc, 0xc3, 0x2f, 0xd0, 0x43, 0x3e, 0xc0, 0x43, 0x39, 0xa0, 0x80,
+  0xcc, 0x24, 0x06, 0xe3, 0xc0, 0x0e, 0xe1, 0x30, 0x0f, 0xf3, 0xe0, 0x06,
+  0xb4, 0x50, 0x0e, 0xf8, 0x40, 0x0f, 0xf5, 0x20, 0x0f, 0xe5, 0x20, 0x07,
+  0xa4, 0xc0, 0x07, 0xf6, 0x50, 0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f,
+  0x7c, 0x60, 0x0e, 0xec, 0xf0, 0x0e, 0xe1, 0x40, 0x0f, 0x6c, 0x00, 0x06,
+  0x74, 0xe0, 0x07, 0x60, 0xe0, 0x07, 0x48, 0x98, 0x94, 0xea, 0x4d, 0xd2,
+  0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x00, 0xf3, 0x2c, 0x44, 0xc4, 0x4e, 0xc0,
+  0x44, 0xa0, 0x80, 0xd0, 0x4d, 0x04, 0x02, 0x00, 0x13, 0x14, 0x72, 0xc0,
+  0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79, 0x68, 0x03, 0x72, 0xc0,
+  0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e, 0x7a, 0x50, 0x0e, 0x6d,
+  0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x78,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34, 0x40, 0x00, 0x0c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4, 0x81, 0x80, 0x00, 0x18,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90,
+  0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22, 0x25, 0x30, 0x02, 0x50,
+  0x10, 0xc5, 0x50, 0x04, 0x25, 0x51, 0x06, 0xe5, 0x41, 0xa5, 0x24, 0x46,
+  0x00, 0x8a, 0xa0, 0x10, 0x0a, 0x84, 0xec, 0x0c, 0x00, 0xe1, 0x19, 0x00,
+  0xca, 0x63, 0x21, 0x06, 0x11, 0x08, 0x04, 0xf2, 0x3c, 0x00, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90,
+  0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b,
+  0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71,
+  0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13,
+  0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xa2, 0x98, 0x20,
+  0x10, 0xc6, 0x06, 0x61, 0x20, 0x26, 0x08, 0xc4, 0xb1, 0x41, 0x18, 0x0c,
+  0x0a, 0x70, 0x73, 0x13, 0x04, 0x02, 0xd9, 0x30, 0x20, 0x09, 0x31, 0x41,
+  0xb0, 0x24, 0x02, 0x13, 0x04, 0x22, 0x99, 0x20, 0x10, 0xca, 0x06, 0x81,
+  0x70, 0x36, 0x24, 0xc4, 0xc2, 0x34, 0xc4, 0xd0, 0x10, 0xcf, 0x86, 0x00,
+  0x9a, 0x20, 0x60, 0xd3, 0x06, 0x84, 0x90, 0x98, 0x86, 0x18, 0x08, 0x60,
+  0x43, 0x30, 0x6d, 0x20, 0x22, 0x00, 0xa0, 0x26, 0x08, 0x19, 0xb5, 0x21,
+  0xb0, 0x26, 0x08, 0x02, 0x40, 0xa2, 0x2d, 0x2c, 0xcd, 0x8d, 0x08, 0x55,
+  0x11, 0xd6, 0xd0, 0xd3, 0x93, 0x14, 0xd1, 0x04, 0xa1, 0x68, 0x26, 0x08,
+  0x85, 0xb3, 0x21, 0x20, 0x26, 0x08, 0xc5, 0x33, 0x41, 0x28, 0xa0, 0x09,
+  0x02, 0xb1, 0x4c, 0x10, 0x08, 0x66, 0x83, 0x00, 0x06, 0x61, 0xb0, 0x61,
+  0x21, 0xb4, 0x8d, 0xeb, 0xbc, 0xe1, 0x23, 0x38, 0x31, 0xd8, 0x10, 0x0c,
+  0x1b, 0x04, 0x30, 0x00, 0x83, 0x0d, 0xcb, 0xa0, 0x6d, 0x1c, 0x19, 0x78,
+  0x83, 0x37, 0x70, 0x65, 0xb0, 0x41, 0x18, 0x03, 0x33, 0x60, 0x32, 0x65,
+  0xf5, 0x45, 0x15, 0x26, 0x77, 0x56, 0x46, 0x37, 0x41, 0x28, 0xa2, 0x0d,
+  0x0b, 0x81, 0x06, 0x5b, 0x1a, 0x74, 0xdc, 0xf0, 0x11, 0x9c, 0x18, 0x6c,
+  0x08, 0xd4, 0x60, 0xc3, 0x70, 0x06, 0x6b, 0x00, 0x6c, 0x28, 0xb0, 0x8c,
+  0x0d, 0x2a, 0xa0, 0x0a, 0x1b, 0x9b, 0x5d, 0x9b, 0x4b, 0x1a, 0x59, 0x99,
+  0x1b, 0xdd, 0x94, 0x20, 0xa8, 0x42, 0x86, 0xe7, 0x62, 0x57, 0x26, 0x37,
+  0x97, 0xf6, 0xe6, 0x36, 0x25, 0x20, 0x9a, 0x90, 0xe1, 0xb9, 0xd8, 0x85,
+  0xb1, 0xd9, 0x95, 0xc9, 0x4d, 0x09, 0x8c, 0x3a, 0x64, 0x78, 0x2e, 0x73,
+  0x68, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x53, 0x82,
+  0xa4, 0x0c, 0x19, 0x9e, 0x8b, 0x5c, 0xd9, 0xdc, 0x5b, 0x9d, 0xdc, 0x58,
+  0xd9, 0xdc, 0x94, 0x80, 0xaa, 0x43, 0x86, 0xe7, 0x62, 0x97, 0x56, 0x76,
+  0x97, 0x44, 0x36, 0x45, 0x17, 0x46, 0x57, 0x36, 0x25, 0xb0, 0xea, 0x90,
+  0xe1, 0xb9, 0x94, 0xb9, 0xd1, 0xc9, 0xe5, 0x41, 0xbd, 0xa5, 0xb9, 0xd1,
+  0xcd, 0x4d, 0x09, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66,
+  0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07,
+  0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce,
+  0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b,
+  0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c,
+  0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07,
+  0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11,
+  0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0,
+  0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8,
+  0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b,
+  0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b,
+  0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87,
+  0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07,
+  0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87,
+  0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81,
+  0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30,
+  0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca,
+  0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39,
+  0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b,
+  0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b,
+  0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70, 0x03, 0x72, 0x10, 0x87,
+  0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60, 0x87, 0x70, 0xc8, 0x87,
+  0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4, 0x80, 0x0f, 0x6e, 0x40,
+  0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x46, 0x20, 0x0d, 0x97, 0xef, 0x3c, 0xbe, 0x10,
+  0x11, 0xc0, 0x44, 0x84, 0x40, 0x33, 0x2c, 0x84, 0x05, 0x4c, 0xc3, 0xe5,
+  0x3b, 0x8f, 0xbf, 0x38, 0xc0, 0x20, 0x36, 0x0f, 0x35, 0xf9, 0xc5, 0x6d,
+  0xdb, 0x00, 0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x12, 0xc0, 0x3c, 0x0b, 0xe1,
+  0x17, 0xb7, 0x6d, 0x02, 0xd5, 0x70, 0xf9, 0xce, 0xe3, 0x4b, 0x93, 0x13,
+  0x11, 0x28, 0x35, 0x3d, 0xd4, 0xe4, 0x17, 0xb7, 0x6d, 0x00, 0x04, 0x03,
+  0x20, 0x0d, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00,
+  0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0xf4, 0x46, 0x00, 0x88, 0xcc, 0x00, 0x14, 0x42, 0x29, 0x94, 0x5c, 0xe1,
+  0x51, 0x29, 0x83, 0x12, 0xa0, 0x31, 0x03, 0x00, 0x23, 0x06, 0x09, 0x00,
+  0x82, 0x60, 0x00, 0x69, 0x05, 0x84, 0x61, 0xc9, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x40, 0x9b, 0x41, 0x64, 0x99, 0x32, 0x62, 0x90, 0x00, 0x20,
+  0x08, 0x06, 0xc6, 0x97, 0x6c, 0x9a, 0xa4, 0x8c, 0x18, 0x24, 0x00, 0x08,
+  0x82, 0x81, 0x01, 0x06, 0x0a, 0xb7, 0x15, 0xcb, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x18, 0x61, 0xb0, 0x70, 0x1c, 0xc5, 0x8c, 0x18, 0x24, 0x00,
+  0x08, 0x82, 0x81, 0x21, 0x06, 0x4c, 0xd7, 0x1d, 0xcd, 0x88, 0x41, 0x02,
+  0x80, 0x20, 0x18, 0x18, 0x63, 0xd0, 0x78, 0x5e, 0xe5, 0x8c, 0x18, 0x24,
+  0x00, 0x08, 0x82, 0x81, 0x41, 0x06, 0xce, 0xf7, 0x29, 0xcf, 0x88, 0xc1,
+  0x03, 0x80, 0x20, 0x18, 0x34, 0x63, 0xc0, 0x20, 0x87, 0x51, 0x24, 0x09,
+  0x18, 0x80, 0x01, 0x94, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c,
+  0x26, 0x0c, 0xc2, 0x68, 0x02, 0x31, 0x18, 0x91, 0xc8, 0xc7, 0x88, 0x44,
+  0x3e, 0x46, 0x24, 0xf2, 0x31, 0x22, 0x91, 0xcf, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x20, 0x6d, 0x70, 0xa5, 0x41, 0x1a, 0x84, 0x01, 0x31, 0x62,
+  0x90, 0x00, 0x20, 0x08, 0x06, 0x48, 0x1b, 0x5c, 0x69, 0x90, 0x06, 0xd3,
+  0x30, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x48, 0x1b, 0x5c, 0x69, 0x90,
+  0x06, 0x60, 0x20, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xd2, 0x06,
+  0x57, 0x1a, 0xa4, 0x01, 0x15, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.spv.h b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.spv.h
new file mode 100644
index 0000000..1210023
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/texture_rgba.frag.spv.h
@@ -0,0 +1,50 @@
+static const unsigned char texture_rgba_frag_spv[] = {
+  0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x08, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+  0x01, 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, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0x22, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x0c, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x17, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x15, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x57, 0x00, 0x05, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x85, 0x00, 0x05, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x17, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+};
+static const unsigned int texture_rgba_frag_spv_len = 564;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert
new file mode 100644
index 0000000..d9ad22e
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert
@@ -0,0 +1,17 @@
+#version 450
+
+layout(location = 0) in vec2 a_position;
+layout(location = 1) in vec4 a_color;
+
+layout(location = 0) out vec4 v_color;
+
+layout(set = 1, binding = 0) uniform Context {
+    mat4 mvp;
+    vec4 color;  /* XXX unused */
+    vec2 texture_size;  /* XXX unused */
+} u_context;
+
+void main() {
+    gl_Position = u_context.mvp * vec4(a_position, 0, 1);
+    v_color = a_color;
+}
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.metal.h b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.metal.h
new file mode 100644
index 0000000..b2993e5
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.metal.h
@@ -0,0 +1,48 @@
+static const unsigned char tri_color_vert_metal[] = {
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x3e, 0x0a,
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x69,
+  0x6d, 0x64, 0x2f, 0x73, 0x69, 0x6d, 0x64, 0x2e, 0x68, 0x3e, 0x0a, 0x0a,
+  0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x3b, 0x0a, 0x0a,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x5f, 0x31, 0x38, 0x0a, 0x7b,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78,
+  0x34, 0x20, 0x5f, 0x6d, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x5f, 0x6d, 0x31, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x5f, 0x6d,
+  0x32, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x0a,
+  0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x20, 0x6d, 0x5f, 0x33, 0x35, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72,
+  0x28, 0x6c, 0x6f, 0x63, 0x6e, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x67, 0x6c,
+  0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x5b, 0x5b,
+  0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5d, 0x5d, 0x3b, 0x0a,
+  0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d,
+  0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x0a, 0x7b, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x6d, 0x5f, 0x32,
+  0x35, 0x20, 0x5b, 0x5b, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
+  0x65, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x33, 0x37, 0x20,
+  0x5b, 0x5b, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x28,
+  0x31, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x76, 0x65,
+  0x72, 0x74, 0x65, 0x78, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f,
+  0x75, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x28, 0x6d, 0x61, 0x69,
+  0x6e, 0x30, 0x5f, 0x69, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x5b, 0x5b, 0x73,
+  0x74, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x6e, 0x5d, 0x5d, 0x2c, 0x20, 0x63,
+  0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x20, 0x5f, 0x31, 0x38, 0x26,
+  0x20, 0x5f, 0x32, 0x30, 0x20, 0x5b, 0x5b, 0x62, 0x75, 0x66, 0x66, 0x65,
+  0x72, 0x28, 0x30, 0x29, 0x5d, 0x5d, 0x29, 0x0a, 0x7b, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x20,
+  0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e, 0x67, 0x6c, 0x5f, 0x50, 0x6f, 0x73,
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x5f, 0x32, 0x30, 0x2e,
+  0x5f, 0x6d, 0x30, 0x20, 0x2a, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x28, 0x69, 0x6e, 0x2e, 0x6d, 0x5f, 0x32, 0x35, 0x2c, 0x20, 0x30, 0x2e,
+  0x30, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x6f, 0x75, 0x74, 0x2e, 0x6d, 0x5f, 0x33, 0x35, 0x20, 0x3d, 0x20,
+  0x69, 0x6e, 0x2e, 0x6d, 0x5f, 0x33, 0x37, 0x3b, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x3b,
+  0x0a, 0x7d, 0x0a, 0x0a
+};
+static const unsigned int tri_color_vert_metal_len = 532;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.sm50.dxbc.h b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.sm50.dxbc.h
new file mode 100644
index 0000000..0819d8a
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.sm50.dxbc.h
@@ -0,0 +1,178 @@
+static const signed char tri_color_vert_sm50_dxbc[] =
+{
+  68,  88,  66,  67, -99,  -1,
+ -83, -50,  75, -96,  -1,  28,
+-104, -33, 121,   1,-117, -87,
+  -7,-107,   1,   0,   0,   0,
+  20,   4,   0,   0,   5,   0,
+   0,   0,  52,   0,   0,   0,
+ -12,   1,   0,   0,  64,   2,
+   0,   0,-104,   2,   0,   0,
+ 120,   3,   0,   0,  82,  68,
+  69,  70, -72,   1,   0,   0,
+   1,   0,   0,   0, 100,   0,
+   0,   0,   1,   0,   0,   0,
+  60,   0,   0,   0,   0,   5,
+  -2,  -1,   0,   1,   0,   0,
+-112,   1,   0,   0,  82,  68,
+  49,  49,  60,   0,   0,   0,
+  24,   0,   0,   0,  32,   0,
+   0,   0,  40,   0,   0,   0,
+  36,   0,   0,   0,  12,   0,
+   0,   0,   0,   0,   0,   0,
+  92,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0,  95,  49,  56,  95,
+  50,  48,   0, -85,  92,   0,
+   0,   0,   3,   0,   0,   0,
+ 124,   0,   0,   0,  96,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0, -12,   0,
+   0,   0,   0,   0,   0,   0,
+  64,   0,   0,   0,   2,   0,
+   0,   0,   4,   1,   0,   0,
+   0,   0,   0,   0,  -1,  -1,
+  -1,  -1,   0,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,  40,   1,   0,   0,
+  64,   0,   0,   0,  16,   0,
+   0,   0,   0,   0,   0,   0,
+  56,   1,   0,   0,   0,   0,
+   0,   0,  -1,  -1,  -1,  -1,
+   0,   0,   0,   0,  -1,  -1,
+  -1,  -1,   0,   0,   0,   0,
+  92,   1,   0,   0,  80,   0,
+   0,   0,   8,   0,   0,   0,
+   0,   0,   0,   0, 108,   1,
+   0,   0,   0,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,  -1,  -1,  -1,  -1,
+   0,   0,   0,   0,  95,  50,
+  48,  95, 109,  48,   0, 102,
+ 108, 111,  97, 116,  52, 120,
+  52,   0,   2,   0,   3,   0,
+   4,   0,   4,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,  -5,   0,
+   0,   0,  95,  50,  48,  95,
+ 109,  49,   0, 102, 108, 111,
+  97, 116,  52,   0, -85, -85,
+   1,   0,   3,   0,   1,   0,
+   4,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,  47,   1,   0,   0,
+  95,  50,  48,  95, 109,  50,
+   0, 102, 108, 111,  97, 116,
+  50,   0, -85, -85,   1,   0,
+   3,   0,   1,   0,   2,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+  99,   1,   0,   0,  77, 105,
+  99, 114, 111, 115, 111, 102,
+ 116,  32,  40,  82,  41,  32,
+  72,  76,  83,  76,  32,  83,
+ 104,  97, 100, 101, 114,  32,
+  67, 111, 109, 112, 105, 108,
+ 101, 114,  32,  49,  48,  46,
+  49,   0,  73,  83,  71,  78,
+  68,   0,   0,   0,   2,   0,
+   0,   0,   8,   0,   0,   0,
+  56,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,   3,   3,   0,   0,
+  56,   0,   0,   0,   1,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   1,   0,
+   0,   0,  15,  15,   0,   0,
+  84,  69,  88,  67,  79,  79,
+  82,  68,   0, -85, -85, -85,
+  79,  83,  71,  78,  80,   0,
+   0,   0,   2,   0,   0,   0,
+   8,   0,   0,   0,  56,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   3,   0,
+   0,   0,   0,   0,   0,   0,
+  15,   0,   0,   0,  65,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   3,   0,
+   0,   0,   1,   0,   0,   0,
+  15,   0,   0,   0,  84,  69,
+  88,  67,  79,  79,  82,  68,
+   0,  83,  86,  95,  80, 111,
+ 115, 105, 116, 105, 111, 110,
+   0, -85, -85, -85,  83,  72,
+  69,  88, -40,   0,   0,   0,
+  80,   0,   1,   0,  54,   0,
+   0,   0, 106,   8,   0,   1,
+  89,   0,   0,   4,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   4,   0,   0,   0,  95,   0,
+   0,   3,  50,  16,  16,   0,
+   0,   0,   0,   0,  95,   0,
+   0,   3, -14,  16,  16,   0,
+   1,   0,   0,   0, 101,   0,
+   0,   3, -14,  32,  16,   0,
+   0,   0,   0,   0, 103,   0,
+   0,   4, -14,  32,  16,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0, 104,   0,   0,   2,
+   1,   0,   0,   0,  54,   0,
+   0,   5, -14,  32,  16,   0,
+   0,   0,   0,   0,  70,  30,
+  16,   0,   1,   0,   0,   0,
+  56,   0,   0,   8, -14,   0,
+  16,   0,   0,   0,   0,   0,
+  86,  21,  16,   0,   0,   0,
+   0,   0,  70,-114,  32,   0,
+   0,   0,   0,   0,   1,   0,
+   0,   0,  50,   0,   0,  10,
+ -14,   0,  16,   0,   0,   0,
+   0,   0,   6,  16,  16,   0,
+   0,   0,   0,   0,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,  70,  14,
+  16,   0,   0,   0,   0,   0,
+   0,   0,   0,   8, -14,  32,
+  16,   0,   1,   0,   0,   0,
+  70,  14,  16,   0,   0,   0,
+   0,   0,  70,-114,  32,   0,
+   0,   0,   0,   0,   3,   0,
+   0,   0,  62,   0,   0,   1,
+  83,  84,  65,  84,-108,   0,
+   0,   0,   5,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   4,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0
+
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.sm60.dxil.h b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.sm60.dxil.h
new file mode 100644
index 0000000..0bb9325
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.sm60.dxil.h
@@ -0,0 +1,515 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xy          0     NONE   float   xy  
+; TEXCOORD                 1   xyzw        1     NONE   float   xyzw
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xyzw        0     NONE   float   xyzw
+; SV_Position              0   xyzw        1      POS   float   xyzw
+;
+; shader hash: f13b1cc9b87e560da744659dd5d39dcb
+;
+; Pipeline Runtime Information: 
+;
+; Vertex Shader
+; OutputPositionPresent=1
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                              
+; TEXCOORD                 1                              
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                 linear       
+; SV_Position              0          noperspective       
+;
+; Buffer Definitions:
+;
+; cbuffer _18_20
+; {
+;
+;   struct hostlayout._18_20
+;   {
+;
+;       row_major float4x4 _20_m0;                    ; Offset:    0
+;       float4 _20_m1;                                ; Offset:   64
+;       float2 _20_m2;                                ; Offset:   80
+;   
+;   } _18_20;                                         ; Offset:    0 Size:    88
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; _18_20                            cbuffer      NA          NA     CB0     cb0,space1     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 8, outputs: 8
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 4 }
+;   output 1 depends on inputs: { 5 }
+;   output 2 depends on inputs: { 6 }
+;   output 3 depends on inputs: { 7 }
+;   output 4 depends on inputs: { 0, 1 }
+;   output 5 depends on inputs: { 0, 1 }
+;   output 6 depends on inputs: { 0, 1 }
+;   output 7 depends on inputs: { 0, 1 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%hostlayout._18_20 = type { [4 x <4 x float>], <4 x float>, <2 x float> }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %9 = extractvalue %dx.types.CBufRet.f32 %8, 0
+  %10 = extractvalue %dx.types.CBufRet.f32 %8, 1
+  %11 = extractvalue %dx.types.CBufRet.f32 %8, 2
+  %12 = extractvalue %dx.types.CBufRet.f32 %8, 3
+  %13 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %14 = extractvalue %dx.types.CBufRet.f32 %13, 0
+  %15 = extractvalue %dx.types.CBufRet.f32 %13, 1
+  %16 = extractvalue %dx.types.CBufRet.f32 %13, 2
+  %17 = extractvalue %dx.types.CBufRet.f32 %13, 3
+  %18 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %19 = extractvalue %dx.types.CBufRet.f32 %18, 0
+  %20 = extractvalue %dx.types.CBufRet.f32 %18, 1
+  %21 = extractvalue %dx.types.CBufRet.f32 %18, 2
+  %22 = extractvalue %dx.types.CBufRet.f32 %18, 3
+  %23 = fmul fast float %9, %6
+  %24 = call float @dx.op.tertiary.f32(i32 46, float %7, float %14, float %23)  ; FMad(a,b,c)
+  %25 = fadd fast float %19, %24
+  %26 = fmul fast float %10, %6
+  %27 = call float @dx.op.tertiary.f32(i32 46, float %7, float %15, float %26)  ; FMad(a,b,c)
+  %28 = fadd fast float %27, %20
+  %29 = fmul fast float %11, %6
+  %30 = call float @dx.op.tertiary.f32(i32 46, float %7, float %16, float %29)  ; FMad(a,b,c)
+  %31 = fadd fast float %30, %21
+  %32 = fmul fast float %12, %6
+  %33 = call float @dx.op.tertiary.f32(i32 46, float %7, float %17, float %32)  ; FMad(a,b,c)
+  %34 = fadd fast float %33, %22
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %2)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %3)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %4)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %5)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 0, float %25)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 1, float %28)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 2, float %31)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 3, float %34)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"dxc(private) 1.8.0.4662 (416fab6b5)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 8}
+!3 = !{!"vs", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %hostlayout._18_20* undef, !"", i32 1, i32 0, i32 1, i32 88, null}
+!7 = !{[10 x i32] [i32 8, i32 8, i32 240, i32 240, i32 0, i32 0, i32 1, i32 2, i32 4, i32 8]}
+!8 = !{void ()* @main, !"main", !9, !4, null}
+!9 = !{!10, !17, null}
+!10 = !{!11, !14}
+!11 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !12, i8 0, i32 1, i8 2, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 3}
+!14 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !15, i8 0, i32 1, i8 4, i32 1, i8 0, !16}
+!15 = !{i32 1}
+!16 = !{i32 3, i32 15}
+!17 = !{!18, !19}
+!18 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 0, i8 0, !16}
+!19 = !{i32 1, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 1, i8 0, !16}
+
+#endif
+
+static const unsigned char tri_color_vert_sm60_dxil[] = {
+  0x44, 0x58, 0x42, 0x43, 0xeb, 0x11, 0xa0, 0x76, 0xea, 0x69, 0xbc, 0x28,
+  0xcd, 0xbc, 0x0c, 0xab, 0x14, 0x5d, 0xfa, 0x53, 0x01, 0x00, 0x00, 0x00,
+  0x98, 0x0f, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
+  0x08, 0x02, 0x00, 0x00, 0x70, 0x08, 0x00, 0x00, 0x8c, 0x08, 0x00, 0x00,
+  0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31, 0x54, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x00, 0x00, 0x00,
+  0x4f, 0x53, 0x47, 0x31, 0x60, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43,
+  0x4f, 0x4f, 0x52, 0x44, 0x00, 0x53, 0x56, 0x5f, 0x50, 0x6f, 0x73, 0x69,
+  0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x50, 0x53, 0x56, 0x30,
+  0xf0, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x02, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x54, 0x45,
+  0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f,
+  0x4f, 0x52, 0x44, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x42, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x44, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x44, 0x00,
+  0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x01, 0x44, 0x03, 0x03, 0x04, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
+  0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54, 0x60, 0x06, 0x00, 0x00,
+  0x60, 0x00, 0x01, 0x00, 0x98, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+  0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x48, 0x06, 0x00, 0x00,
+  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00,
+  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d,
+  0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff,
+  0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66,
+  0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14,
+  0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f,
+  0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6,
+  0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42,
+  0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42,
+  0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4,
+  0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x61,
+  0x04, 0x61, 0xb8, 0xe8, 0x70, 0xa4, 0x69, 0x01, 0x30, 0x87, 0x9a, 0xfc,
+  0xbf, 0xe6, 0x7f, 0x9b, 0x46, 0x83, 0xad, 0x97, 0x70, 0x2a, 0x10, 0x00,
+  0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79,
+  0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e,
+  0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34,
+  0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4,
+  0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
+  0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x16, 0x08, 0x00, 0x13, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22,
+  0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x1b, 0x50, 0x04, 0x85, 0x50, 0x06,
+  0xe5, 0x50, 0x12, 0x05, 0x18, 0x50, 0x1a, 0x05, 0x1a, 0x50, 0x1e, 0x05,
+  0x51, 0x56, 0x54, 0x4a, 0x62, 0x04, 0xa0, 0x08, 0x0a, 0xa1, 0x0c, 0x28,
+  0xd6, 0x00, 0xe1, 0x19, 0x00, 0xca, 0x33, 0x00, 0xa4, 0xc7, 0x52, 0x10,
+  0x04, 0x3e, 0xe0, 0x03, 0x00, 0x02, 0x81, 0x40, 0x00, 0x00, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90,
+  0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b,
+  0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71,
+  0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13,
+  0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20,
+  0x10, 0xc7, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04, 0x41, 0xc1, 0x6e, 0x6e,
+  0x82, 0x40, 0x20, 0x1b, 0x86, 0x03, 0x21, 0x26, 0x08, 0x19, 0x47, 0xe3,
+  0x2b, 0x06, 0xe7, 0x4b, 0x06, 0x66, 0x82, 0x40, 0x24, 0x1b, 0x10, 0x42,
+  0x59, 0x06, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3, 0x81, 0x00, 0x00, 0x07,
+  0x98, 0x20, 0x60, 0x1b, 0x8d, 0x2f, 0x19, 0x98, 0xaf, 0x36, 0x98, 0x09,
+  0x02, 0xa1, 0x4c, 0x10, 0x88, 0x65, 0xc3, 0x30, 0x4d, 0xc3, 0x04, 0x81,
+  0x60, 0x26, 0x08, 0x44, 0x33, 0x41, 0x20, 0x9c, 0x09, 0x42, 0xa4, 0x6d,
+  0x50, 0x90, 0x48, 0xa2, 0x2a, 0xc2, 0xba, 0x2e, 0x8c, 0xc6, 0x97, 0x0c,
+  0xcc, 0x57, 0x5b, 0xcc, 0x04, 0x81, 0x78, 0x26, 0x08, 0x04, 0xb4, 0x01,
+  0x41, 0xb4, 0x6a, 0xb3, 0x2e, 0x6e, 0xa2, 0xf1, 0x25, 0x03, 0xf3, 0xd5,
+  0x26, 0x33, 0x41, 0x20, 0xa2, 0x0d, 0x08, 0xe2, 0x55, 0x9f, 0x75, 0x71,
+  0xd2, 0x06, 0x82, 0xc9, 0x3a, 0x30, 0xd8, 0x30, 0x10, 0x50, 0x18, 0x4c,
+  0x10, 0x04, 0x60, 0x03, 0xb0, 0x61, 0x20, 0xc8, 0x80, 0x0c, 0x36, 0x04,
+  0x65, 0xb0, 0x61, 0x18, 0xc6, 0xc0, 0x0c, 0x26, 0x08, 0x5a, 0xb7, 0x21,
+  0x40, 0x03, 0x12, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0xa8, 0x8a, 0xb0, 0x86,
+  0x9e, 0x9e, 0xa4, 0x88, 0x26, 0x08, 0x45, 0x35, 0x41, 0x28, 0xac, 0x0d,
+  0x01, 0x31, 0x41, 0x28, 0xae, 0x0d, 0x42, 0x55, 0x6d, 0x58, 0x88, 0x35,
+  0x60, 0x83, 0x36, 0x70, 0x83, 0x36, 0x18, 0xde, 0x80, 0x68, 0x03, 0x38,
+  0xd8, 0x10, 0x0c, 0x13, 0x84, 0x02, 0x9b, 0x20, 0x10, 0xd2, 0x06, 0xa1,
+  0xa2, 0x83, 0x0d, 0xcb, 0xb0, 0x06, 0x6c, 0xd0, 0x06, 0x72, 0xd0, 0x06,
+  0xc3, 0x1c, 0x0c, 0x6d, 0x50, 0x07, 0x1b, 0x84, 0x38, 0xb0, 0x83, 0x0d,
+  0x0b, 0xb1, 0x06, 0x6c, 0xd0, 0x06, 0x6e, 0xf0, 0x06, 0xc3, 0x1c, 0x10,
+  0x6d, 0x50, 0x07, 0x5c, 0xa6, 0xac, 0xbe, 0xa0, 0xde, 0xe6, 0xd2, 0xe8,
+  0xd2, 0xde, 0xdc, 0x26, 0x08, 0x45, 0xb6, 0x61, 0x19, 0xf2, 0x80, 0x0d,
+  0xf4, 0xc0, 0x0d, 0xe6, 0x60, 0x98, 0x83, 0xa1, 0x0d, 0xea, 0x60, 0x83,
+  0x80, 0x07, 0x7b, 0xb0, 0x61, 0xb8, 0x03, 0x3e, 0x00, 0x36, 0x14, 0x63,
+  0xa0, 0x06, 0x7d, 0xf0, 0x00, 0x34, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0xe6,
+  0x26, 0x08, 0xc4, 0xc4, 0x22, 0xcd, 0x6d, 0x8e, 0x6e, 0x6e, 0x82, 0x40,
+  0x50, 0x34, 0xe6, 0xd2, 0xce, 0xbe, 0xd8, 0xc8, 0x68, 0xcc, 0xa5, 0x9d,
+  0x7d, 0xcd, 0xd1, 0x6d, 0x40, 0xfe, 0x00, 0x14, 0x42, 0x41, 0x14, 0x46,
+  0x01, 0x21, 0x05, 0x50, 0xa8, 0xc2, 0xc6, 0x66, 0xd7, 0xe6, 0x92, 0x46,
+  0x56, 0xe6, 0x46, 0x37, 0x25, 0x08, 0xaa, 0x90, 0xe1, 0xb9, 0xd8, 0x95,
+  0xc9, 0xcd, 0xa5, 0xbd, 0xb9, 0x4d, 0x09, 0x88, 0x26, 0x64, 0x78, 0x2e,
+  0x76, 0x61, 0x6c, 0x76, 0x65, 0x72, 0x53, 0x82, 0xa2, 0x0e, 0x19, 0x9e,
+  0xcb, 0x1c, 0x5a, 0x18, 0x59, 0x99, 0x5c, 0xd3, 0x1b, 0x59, 0x19, 0xdb,
+  0x94, 0x00, 0x29, 0x43, 0x86, 0xe7, 0x22, 0x57, 0x36, 0xf7, 0x56, 0x27,
+  0x37, 0x56, 0x36, 0x37, 0x25, 0x70, 0x2a, 0x91, 0xe1, 0xb9, 0xd0, 0xe5,
+  0xc1, 0x95, 0x05, 0xb9, 0xb9, 0xbd, 0xd1, 0x85, 0xd1, 0xa5, 0xbd, 0xb9,
+  0xcd, 0x4d, 0x11, 0xc2, 0xc0, 0x0c, 0xea, 0x90, 0xe1, 0xb9, 0xd8, 0xa5,
+  0x95, 0xdd, 0x25, 0x91, 0x4d, 0xd1, 0x85, 0xd1, 0x95, 0x4d, 0x09, 0xd0,
+  0xa0, 0x0e, 0x19, 0x9e, 0x4b, 0x99, 0x1b, 0x9d, 0x5c, 0x1e, 0xd4, 0x5b,
+  0x9a, 0x1b, 0xdd, 0xdc, 0x94, 0xa0, 0x0f, 0xba, 0x90, 0xe1, 0xb9, 0x8c,
+  0xbd, 0xd5, 0xb9, 0xd1, 0x95, 0xc9, 0xcd, 0x4d, 0x09, 0x48, 0x01, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70,
+  0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60,
+  0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4,
+  0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97,
+  0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25,
+  0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce,
+  0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0,
+  0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93,
+  0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e,
+  0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3,
+  0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7,
+  0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xf1, 0x3b, 0x1c, 0xc9, 0xb8, 0x7e, 0x56, 0x0d, 0xa7, 0x44, 0x65, 0x9d,
+  0xd5, 0xd3, 0x9d, 0xcb, 0x44, 0x58, 0x49, 0x4c, 0x04, 0x07, 0x00, 0x00,
+  0x60, 0x00, 0x01, 0x00, 0xc1, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+  0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xec, 0x06, 0x00, 0x00,
+  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00,
+  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d,
+  0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff,
+  0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66,
+  0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14,
+  0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f,
+  0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6,
+  0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42,
+  0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42,
+  0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4,
+  0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x61,
+  0x04, 0x61, 0xb8, 0xe8, 0x70, 0xa4, 0x69, 0x01, 0x30, 0x87, 0x9a, 0xfc,
+  0xbf, 0xe6, 0x7f, 0x9b, 0x46, 0x83, 0xad, 0x97, 0x70, 0x2a, 0x10, 0x00,
+  0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79,
+  0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e,
+  0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34,
+  0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4,
+  0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
+  0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x16, 0x08, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22,
+  0x25, 0x30, 0x02, 0x50, 0x10, 0xc5, 0x50, 0xb0, 0x01, 0x65, 0x50, 0x1e,
+  0x54, 0x4a, 0x62, 0x04, 0xa0, 0x08, 0x0a, 0xa1, 0x0c, 0x28, 0xcf, 0x00,
+  0x90, 0x1e, 0x4b, 0x41, 0x10, 0xf8, 0x80, 0x0f, 0x00, 0x08, 0x04, 0x02,
+  0x01, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00,
+  0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b,
+  0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71,
+  0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89,
+  0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x26, 0x08, 0x04,
+  0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x76, 0x73, 0x13, 0x04, 0x22, 0xd9, 0x30,
+  0x20, 0x09, 0x31, 0x41, 0xc8, 0x24, 0x02, 0x13, 0x04, 0x42, 0xd9, 0x80,
+  0x10, 0x0b, 0x33, 0x10, 0x43, 0x03, 0x6c, 0x08, 0x9c, 0x0d, 0x04, 0x00,
+  0x3c, 0xc0, 0x04, 0x41, 0x9b, 0x36, 0x04, 0xd1, 0x04, 0x41, 0x00, 0x48,
+  0xb4, 0x85, 0xa5, 0xb9, 0x11, 0xa1, 0x2a, 0xc2, 0x1a, 0x7a, 0x7a, 0x92,
+  0x22, 0x9a, 0x20, 0x14, 0xcd, 0x04, 0xa1, 0x70, 0x36, 0x04, 0xc4, 0x04,
+  0xa1, 0x78, 0x26, 0x08, 0xc4, 0xb2, 0x41, 0xd0, 0xb4, 0x0d, 0x0b, 0x51,
+  0x59, 0x17, 0x76, 0x0d, 0x19, 0x71, 0x6d, 0x1b, 0x82, 0x61, 0x82, 0x50,
+  0x40, 0x13, 0x04, 0x82, 0xd9, 0x20, 0x68, 0xdf, 0x86, 0x65, 0xa8, 0xac,
+  0xab, 0xbb, 0x06, 0x6f, 0xb8, 0xc0, 0x60, 0x83, 0xc0, 0x85, 0xc1, 0x86,
+  0x85, 0xa8, 0xac, 0x0b, 0xcb, 0x06, 0x8f, 0xb8, 0xc0, 0x80, 0xcb, 0x94,
+  0xd5, 0x17, 0xd4, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0xdb, 0x04, 0xa1,
+  0x88, 0x36, 0x2c, 0x03, 0x19, 0x58, 0x65, 0x80, 0x79, 0x83, 0x37, 0x5c,
+  0x60, 0xb0, 0x41, 0x18, 0x03, 0x33, 0xd8, 0x30, 0x88, 0xc1, 0x19, 0x00,
+  0x1b, 0x8a, 0x89, 0x42, 0x03, 0x08, 0xa8, 0xc2, 0xc6, 0x66, 0xd7, 0xe6,
+  0x92, 0x46, 0x56, 0xe6, 0x46, 0x37, 0x25, 0x08, 0xaa, 0x90, 0xe1, 0xb9,
+  0xd8, 0x95, 0xc9, 0xcd, 0xa5, 0xbd, 0xb9, 0x4d, 0x09, 0x88, 0x26, 0x64,
+  0x78, 0x2e, 0x76, 0x61, 0x6c, 0x76, 0x65, 0x72, 0x53, 0x02, 0xa3, 0x0e,
+  0x19, 0x9e, 0xcb, 0x1c, 0x5a, 0x18, 0x59, 0x99, 0x5c, 0xd3, 0x1b, 0x59,
+  0x19, 0xdb, 0x94, 0x20, 0x29, 0x43, 0x86, 0xe7, 0x22, 0x57, 0x36, 0xf7,
+  0x56, 0x27, 0x37, 0x56, 0x36, 0x37, 0x25, 0x78, 0xea, 0x90, 0xe1, 0xb9,
+  0xd8, 0xa5, 0x95, 0xdd, 0x25, 0x91, 0x4d, 0xd1, 0x85, 0xd1, 0x95, 0x4d,
+  0x09, 0xa2, 0x3a, 0x64, 0x78, 0x2e, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x50,
+  0x6f, 0x69, 0x6e, 0x74, 0x73, 0x53, 0x02, 0x34, 0x00, 0x00, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70,
+  0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60,
+  0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4,
+  0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97,
+  0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25,
+  0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce,
+  0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0,
+  0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93,
+  0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e,
+  0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3,
+  0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7,
+  0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x63, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x44, 0x4a, 0xa1, 0x10, 0x66, 0x00, 0x8a, 0xab,
+  0xec, 0x4a, 0x8e, 0x4a, 0x09, 0x50, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x20, 0x5d, 0x43, 0x53, 0x55, 0xc1,
+  0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0x1c, 0x72, 0x59, 0xcf, 0x31,
+  0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x97, 0x60, 0x17, 0x81, 0x8c,
+  0x18, 0x24, 0x00, 0x08, 0x82, 0x81, 0xe1, 0x29, 0x19, 0x06, 0x25, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x7c, 0x8b, 0x96, 0x3d, 0xca, 0x88,
+  0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0x60, 0xc0, 0x68, 0xda, 0xb4, 0x8c,
+  0x18, 0x24, 0x00, 0x08, 0x82, 0x81, 0x11, 0x06, 0xcd, 0xb6, 0x21, 0xcc,
+  0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0x60, 0xb0, 0x1c, 0xdc, 0x68,
+  0x42, 0x00, 0x8c, 0x26, 0x08, 0xc1, 0x68, 0xc2, 0x20, 0x8c, 0x26, 0x10,
+  0xc3, 0x88, 0xc1, 0x01, 0x80, 0x20, 0x18, 0x34, 0x65, 0x00, 0x31, 0x62,
+  0x30, 0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3,
+  0x09, 0xc4, 0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x8d, 0x1a, 0x54,
+  0x91, 0x18, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c, 0x26, 0x0c,
+  0xc2, 0x68, 0x02, 0x31, 0x98, 0x13, 0xc9, 0x67, 0xc4, 0x00, 0x01, 0x40,
+  0x10, 0x0c, 0x9e, 0x37, 0xe0, 0x22, 0x25, 0x30, 0x23, 0x80, 0x8e, 0x41,
+  0x94, 0x7c, 0x46, 0x0c, 0x10, 0x00, 0x04, 0xc1, 0xe0, 0x91, 0x83, 0x8f,
+  0x62, 0x02, 0x0b, 0x10, 0xe8, 0x98, 0x74, 0xc9, 0x67, 0xc4, 0x00, 0x01,
+  0x40, 0x10, 0x0c, 0x9e, 0x3a, 0x10, 0x83, 0xcb, 0x09, 0x2c, 0x50, 0xa0,
+  0x63, 0x94, 0x26, 0x9f, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0xf0,
+  0xa0, 0x0c, 0x34, 0x28, 0xb0, 0x80, 0x81, 0xce, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x20, 0x7c, 0xa0, 0x06, 0x77, 0x70, 0x07, 0x70, 0x10, 0x06,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x80, 0xf0, 0x81, 0x1a, 0xdc, 0xc1,
+  0x1d, 0x90, 0x01, 0x18, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xc2,
+  0x07, 0x6a, 0x70, 0x07, 0x77, 0xf0, 0x06, 0xdf, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x20, 0x7c, 0xa0, 0x06, 0x77, 0x70, 0x07, 0x6d, 0xe0, 0x8d,
+  0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0xc2, 0x07, 0x6a, 0x80, 0x07, 0x77,
+  0x00, 0x07, 0xca, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0x7c, 0xa0,
+  0x06, 0x78, 0x70, 0x07, 0x64, 0x70, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82,
+  0x01, 0xc2, 0x07, 0x6a, 0x80, 0x07, 0x77, 0xf0, 0x06, 0xc4, 0x88, 0x41,
+  0x02, 0x80, 0x20, 0x18, 0x20, 0x7c, 0xa0, 0x06, 0x78, 0x70, 0x07, 0x6d,
+  0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.spv.h b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.spv.h
new file mode 100644
index 0000000..6570ab4
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_color.vert.spv.h
@@ -0,0 +1,89 @@
+static const unsigned char tri_color_vert_spv[] = {
+  0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x08, 0x00,
+  0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+  0x01, 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, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+  0x25, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x03, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x04, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+  0x40, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x03, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x19, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x23, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x25, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x06, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x0c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x05, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x20, 0x00, 0x04, 0x00,
+  0x21, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x1a, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+  0x1d, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x91, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+  0x41, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+  0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+  0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+};
+static const unsigned int tri_color_vert_spv_len = 1028;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert
new file mode 100644
index 0000000..bdf4366
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert
@@ -0,0 +1,20 @@
+#version 450
+
+layout(location = 0) in vec2 a_position;
+layout(location = 1) in vec4 a_color;
+layout(location = 2) in vec2 a_uv;
+
+layout(location = 0) out vec4 v_color;
+layout(location = 1) out vec2 v_uv;
+
+layout(set = 1, binding = 0) uniform Context {
+    mat4 mvp;
+    vec4 color;  /* XXX unused */
+    vec2 texture_size;
+} u_context;
+
+void main() {
+    gl_Position = u_context.mvp * vec4(a_position, 0, 1);
+    v_color = a_color;
+    v_uv = a_uv / u_context.texture_size;
+}
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.metal.h b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.metal.h
new file mode 100644
index 0000000..a5019fc
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.metal.h
@@ -0,0 +1,56 @@
+static const unsigned char tri_texture_vert_metal[] = {
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x6d, 0x65,
+  0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x64, 0x6c, 0x69, 0x62, 0x3e, 0x0a,
+  0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x69,
+  0x6d, 0x64, 0x2f, 0x73, 0x69, 0x6d, 0x64, 0x2e, 0x68, 0x3e, 0x0a, 0x0a,
+  0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x3b, 0x0a, 0x0a,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x5f, 0x31, 0x38, 0x0a, 0x7b,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78,
+  0x34, 0x20, 0x5f, 0x6d, 0x30, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x5f, 0x6d, 0x31, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x5f, 0x6d,
+  0x32, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x0a,
+  0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x20, 0x6d, 0x5f, 0x33, 0x35, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72,
+  0x28, 0x6c, 0x6f, 0x63, 0x6e, 0x30, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x6d, 0x5f,
+  0x34, 0x30, 0x20, 0x5b, 0x5b, 0x75, 0x73, 0x65, 0x72, 0x28, 0x6c, 0x6f,
+  0x63, 0x6e, 0x31, 0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x20, 0x67, 0x6c, 0x5f, 0x50, 0x6f,
+  0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x5b, 0x5b, 0x70, 0x6f, 0x73,
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5d, 0x5d, 0x3b, 0x0a, 0x7d, 0x3b, 0x0a,
+  0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e,
+  0x30, 0x5f, 0x69, 0x6e, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x32, 0x20, 0x6d, 0x5f, 0x32, 0x35, 0x20, 0x5b,
+  0x5b, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x28, 0x30,
+  0x29, 0x5d, 0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x34, 0x20, 0x6d, 0x5f, 0x33, 0x37, 0x20, 0x5b, 0x5b, 0x61,
+  0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x28, 0x31, 0x29, 0x5d,
+  0x5d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x32, 0x20, 0x6d, 0x5f, 0x34, 0x31, 0x20, 0x5b, 0x5b, 0x61, 0x74, 0x74,
+  0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x28, 0x32, 0x29, 0x5d, 0x5d, 0x3b,
+  0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x20,
+  0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x20, 0x6d, 0x61,
+  0x69, 0x6e, 0x30, 0x28, 0x6d, 0x61, 0x69, 0x6e, 0x30, 0x5f, 0x69, 0x6e,
+  0x20, 0x69, 0x6e, 0x20, 0x5b, 0x5b, 0x73, 0x74, 0x61, 0x67, 0x65, 0x5f,
+  0x69, 0x6e, 0x5d, 0x5d, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61,
+  0x6e, 0x74, 0x20, 0x5f, 0x31, 0x38, 0x26, 0x20, 0x5f, 0x32, 0x30, 0x20,
+  0x5b, 0x5b, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x28, 0x30, 0x29, 0x5d,
+  0x5d, 0x29, 0x0a, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6d, 0x61, 0x69,
+  0x6e, 0x30, 0x5f, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x75, 0x74, 0x20, 0x3d,
+  0x20, 0x7b, 0x7d, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74,
+  0x2e, 0x67, 0x6c, 0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+  0x20, 0x3d, 0x20, 0x5f, 0x32, 0x30, 0x2e, 0x5f, 0x6d, 0x30, 0x20, 0x2a,
+  0x20, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x28, 0x69, 0x6e, 0x2e, 0x6d,
+  0x5f, 0x32, 0x35, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e,
+  0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e,
+  0x6d, 0x5f, 0x33, 0x35, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x2e, 0x6d, 0x5f,
+  0x33, 0x37, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x2e,
+  0x6d, 0x5f, 0x34, 0x30, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x2e, 0x6d, 0x5f,
+  0x34, 0x31, 0x20, 0x2f, 0x20, 0x5f, 0x32, 0x30, 0x2e, 0x5f, 0x6d, 0x32,
+  0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
+  0x20, 0x6f, 0x75, 0x74, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a
+};
+static const unsigned int tri_texture_vert_metal_len = 633;
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.sm50.dxbc.h b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.sm50.dxbc.h
new file mode 100644
index 0000000..f34d45d
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.sm50.dxbc.h
@@ -0,0 +1,195 @@
+static const signed char tri_texture_vert_sm50_dxbc[] =
+{
+  68,  88,  66,  67, 108, 113,
+-108,  81,  -2,  27,  41,  94,
+ -47,  10, -97, -76, -86, -88,
+  -2,  29,   1,   0,   0,   0,
+ 124,   4,   0,   0,   5,   0,
+   0,   0,  52,   0,   0,   0,
+ -12,   1,   0,   0,  88,   2,
+   0,   0, -56,   2,   0,   0,
+ -32,   3,   0,   0,  82,  68,
+  69,  70, -72,   1,   0,   0,
+   1,   0,   0,   0, 100,   0,
+   0,   0,   1,   0,   0,   0,
+  60,   0,   0,   0,   0,   5,
+  -2,  -1,   0,   1,   0,   0,
+-112,   1,   0,   0,  82,  68,
+  49,  49,  60,   0,   0,   0,
+  24,   0,   0,   0,  32,   0,
+   0,   0,  40,   0,   0,   0,
+  36,   0,   0,   0,  12,   0,
+   0,   0,   0,   0,   0,   0,
+  92,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   1,   0,
+   0,   0,  95,  49,  56,  95,
+  50,  48,   0, -85,  92,   0,
+   0,   0,   3,   0,   0,   0,
+ 124,   0,   0,   0,  96,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0, -12,   0,
+   0,   0,   0,   0,   0,   0,
+  64,   0,   0,   0,   2,   0,
+   0,   0,   4,   1,   0,   0,
+   0,   0,   0,   0,  -1,  -1,
+  -1,  -1,   0,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,  40,   1,   0,   0,
+  64,   0,   0,   0,  16,   0,
+   0,   0,   0,   0,   0,   0,
+  56,   1,   0,   0,   0,   0,
+   0,   0,  -1,  -1,  -1,  -1,
+   0,   0,   0,   0,  -1,  -1,
+  -1,  -1,   0,   0,   0,   0,
+  92,   1,   0,   0,  80,   0,
+   0,   0,   8,   0,   0,   0,
+   2,   0,   0,   0, 108,   1,
+   0,   0,   0,   0,   0,   0,
+  -1,  -1,  -1,  -1,   0,   0,
+   0,   0,  -1,  -1,  -1,  -1,
+   0,   0,   0,   0,  95,  50,
+  48,  95, 109,  48,   0, 102,
+ 108, 111,  97, 116,  52, 120,
+  52,   0,   2,   0,   3,   0,
+   4,   0,   4,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,  -5,   0,
+   0,   0,  95,  50,  48,  95,
+ 109,  49,   0, 102, 108, 111,
+  97, 116,  52,   0, -85, -85,
+   1,   0,   3,   0,   1,   0,
+   4,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,  47,   1,   0,   0,
+  95,  50,  48,  95, 109,  50,
+   0, 102, 108, 111,  97, 116,
+  50,   0, -85, -85,   1,   0,
+   3,   0,   1,   0,   2,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+  99,   1,   0,   0,  77, 105,
+  99, 114, 111, 115, 111, 102,
+ 116,  32,  40,  82,  41,  32,
+  72,  76,  83,  76,  32,  83,
+ 104,  97, 100, 101, 114,  32,
+  67, 111, 109, 112, 105, 108,
+ 101, 114,  32,  49,  48,  46,
+  49,   0,  73,  83,  71,  78,
+  92,   0,   0,   0,   3,   0,
+   0,   0,   8,   0,   0,   0,
+  80,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   0,   0,
+   0,   0,   3,   3,   0,   0,
+  80,   0,   0,   0,   1,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   1,   0,
+   0,   0,  15,  15,   0,   0,
+  80,   0,   0,   0,   2,   0,
+   0,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,   2,   0,
+   0,   0,   3,   3,   0,   0,
+  84,  69,  88,  67,  79,  79,
+  82,  68,   0, -85, -85, -85,
+  79,  83,  71,  78, 104,   0,
+   0,   0,   3,   0,   0,   0,
+   8,   0,   0,   0,  80,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   3,   0,
+   0,   0,   0,   0,   0,   0,
+  15,   0,   0,   0,  80,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   3,   0,
+   0,   0,   1,   0,   0,   0,
+   3,  12,   0,   0,  89,   0,
+   0,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,   3,   0,
+   0,   0,   2,   0,   0,   0,
+  15,   0,   0,   0,  84,  69,
+  88,  67,  79,  79,  82,  68,
+   0,  83,  86,  95,  80, 111,
+ 115, 105, 116, 105, 111, 110,
+   0, -85, -85, -85,  83,  72,
+  69,  88,  16,   1,   0,   0,
+  80,   0,   1,   0,  68,   0,
+   0,   0, 106,   8,   0,   1,
+  89,   0,   0,   4,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   6,   0,   0,   0,  95,   0,
+   0,   3,  50,  16,  16,   0,
+   0,   0,   0,   0,  95,   0,
+   0,   3, -14,  16,  16,   0,
+   1,   0,   0,   0,  95,   0,
+   0,   3,  50,  16,  16,   0,
+   2,   0,   0,   0, 101,   0,
+   0,   3, -14,  32,  16,   0,
+   0,   0,   0,   0, 101,   0,
+   0,   3,  50,  32,  16,   0,
+   1,   0,   0,   0, 103,   0,
+   0,   4, -14,  32,  16,   0,
+   2,   0,   0,   0,   1,   0,
+   0,   0, 104,   0,   0,   2,
+   1,   0,   0,   0,  54,   0,
+   0,   5, -14,  32,  16,   0,
+   0,   0,   0,   0,  70,  30,
+  16,   0,   1,   0,   0,   0,
+  14,   0,   0,   8,  50,  32,
+  16,   0,   1,   0,   0,   0,
+  70,  16,  16,   0,   2,   0,
+   0,   0,  70,-128,  32,   0,
+   0,   0,   0,   0,   5,   0,
+   0,   0,  56,   0,   0,   8,
+ -14,   0,  16,   0,   0,   0,
+   0,   0,  86,  21,  16,   0,
+   0,   0,   0,   0,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   1,   0,   0,   0,  50,   0,
+   0,  10, -14,   0,  16,   0,
+   0,   0,   0,   0,   6,  16,
+  16,   0,   0,   0,   0,   0,
+  70,-114,  32,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+  70,  14,  16,   0,   0,   0,
+   0,   0,   0,   0,   0,   8,
+ -14,  32,  16,   0,   2,   0,
+   0,   0,  70,  14,  16,   0,
+   0,   0,   0,   0,  70,-114,
+  32,   0,   0,   0,   0,   0,
+   3,   0,   0,   0,  62,   0,
+   0,   1,  83,  84,  65,  84,
+-108,   0,   0,   0,   6,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   6,   0,
+   0,   0,   4,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   1,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,
+   0,   0
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.sm60.dxil.h b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.sm60.dxil.h
new file mode 100644
index 0000000..4324106
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.sm60.dxil.h
@@ -0,0 +1,558 @@
+#if 0
+;
+; Input signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xy          0     NONE   float   xy  
+; TEXCOORD                 1   xyzw        1     NONE   float   xyzw
+; TEXCOORD                 2   xy          2     NONE   float   xy  
+;
+;
+; Output signature:
+;
+; Name                 Index   Mask Register SysValue  Format   Used
+; -------------------- ----- ------ -------- -------- ------- ------
+; TEXCOORD                 0   xyzw        0     NONE   float   xyzw
+; TEXCOORD                 1   xy          1     NONE   float   xy  
+; SV_Position              0   xyzw        2      POS   float   xyzw
+;
+; shader hash: c10d07e0100207069cb29b72a35d05b6
+;
+; Pipeline Runtime Information: 
+;
+; Vertex Shader
+; OutputPositionPresent=1
+;
+;
+; Input signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                              
+; TEXCOORD                 1                              
+; TEXCOORD                 2                              
+;
+; Output signature:
+;
+; Name                 Index             InterpMode DynIdx
+; -------------------- ----- ---------------------- ------
+; TEXCOORD                 0                 linear       
+; TEXCOORD                 1                 linear       
+; SV_Position              0          noperspective       
+;
+; Buffer Definitions:
+;
+; cbuffer _18_20
+; {
+;
+;   struct hostlayout._18_20
+;   {
+;
+;       row_major float4x4 _20_m0;                    ; Offset:    0
+;       float4 _20_m1;                                ; Offset:   64
+;       float2 _20_m2;                                ; Offset:   80
+;   
+;   } _18_20;                                         ; Offset:    0 Size:    88
+;
+; }
+;
+;
+; Resource Bindings:
+;
+; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
+; ------------------------------ ---------- ------- ----------- ------- -------------- ------
+; _18_20                            cbuffer      NA          NA     CB0     cb0,space1     1
+;
+;
+; ViewId state:
+;
+; Number of inputs: 10, outputs: 12
+; Outputs dependent on ViewId: {  }
+; Inputs contributing to computation of Outputs:
+;   output 0 depends on inputs: { 4 }
+;   output 1 depends on inputs: { 5 }
+;   output 2 depends on inputs: { 6 }
+;   output 3 depends on inputs: { 7 }
+;   output 4 depends on inputs: { 8 }
+;   output 5 depends on inputs: { 9 }
+;   output 8 depends on inputs: { 0, 1 }
+;   output 9 depends on inputs: { 0, 1 }
+;   output 10 depends on inputs: { 0, 1 }
+;   output 11 depends on inputs: { 0, 1 }
+;
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.f32 = type { float, float, float, float }
+%hostlayout._18_20 = type { [4 x <4 x float>], <4 x float>, <2 x float> }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %3 = call float @dx.op.loadInput.f32(i32 4, i32 2, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %4 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %5 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %6 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 2, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %7 = call float @dx.op.loadInput.f32(i32 4, i32 1, i32 0, i8 3, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %8 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 0, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %9 = call float @dx.op.loadInput.f32(i32 4, i32 0, i32 0, i8 1, i32 undef)  ; LoadInput(inputSigId,rowIndex,colIndex,gsVertexAxis)
+  %10 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %11 = extractvalue %dx.types.CBufRet.f32 %10, 0
+  %12 = extractvalue %dx.types.CBufRet.f32 %10, 1
+  %13 = extractvalue %dx.types.CBufRet.f32 %10, 2
+  %14 = extractvalue %dx.types.CBufRet.f32 %10, 3
+  %15 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 1)  ; CBufferLoadLegacy(handle,regIndex)
+  %16 = extractvalue %dx.types.CBufRet.f32 %15, 0
+  %17 = extractvalue %dx.types.CBufRet.f32 %15, 1
+  %18 = extractvalue %dx.types.CBufRet.f32 %15, 2
+  %19 = extractvalue %dx.types.CBufRet.f32 %15, 3
+  %20 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 3)  ; CBufferLoadLegacy(handle,regIndex)
+  %21 = extractvalue %dx.types.CBufRet.f32 %20, 0
+  %22 = extractvalue %dx.types.CBufRet.f32 %20, 1
+  %23 = extractvalue %dx.types.CBufRet.f32 %20, 2
+  %24 = extractvalue %dx.types.CBufRet.f32 %20, 3
+  %25 = fmul fast float %11, %8
+  %26 = call float @dx.op.tertiary.f32(i32 46, float %9, float %16, float %25)  ; FMad(a,b,c)
+  %27 = fadd fast float %21, %26
+  %28 = fmul fast float %12, %8
+  %29 = call float @dx.op.tertiary.f32(i32 46, float %9, float %17, float %28)  ; FMad(a,b,c)
+  %30 = fadd fast float %29, %22
+  %31 = fmul fast float %13, %8
+  %32 = call float @dx.op.tertiary.f32(i32 46, float %9, float %18, float %31)  ; FMad(a,b,c)
+  %33 = fadd fast float %32, %23
+  %34 = fmul fast float %14, %8
+  %35 = call float @dx.op.tertiary.f32(i32 46, float %9, float %19, float %34)  ; FMad(a,b,c)
+  %36 = fadd fast float %35, %24
+  %37 = call %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32 59, %dx.types.Handle %1, i32 5)  ; CBufferLoadLegacy(handle,regIndex)
+  %38 = extractvalue %dx.types.CBufRet.f32 %37, 0
+  %39 = extractvalue %dx.types.CBufRet.f32 %37, 1
+  %40 = fdiv fast float %2, %38
+  %41 = fdiv fast float %3, %39
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %4)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %5)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %6)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %7)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 0, float %40)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 1, i32 0, i8 1, float %41)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 0, float %27)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 1, float %30)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 2, float %33)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 2, i32 0, i8 3, float %36)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.loadInput.f32(i32, i32, i32, i8, i32) #0
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.f32 @dx.op.cbufferLoadLegacy.f32(i32, %dx.types.Handle, i32) #2
+
+; Function Attrs: nounwind readnone
+declare float @dx.op.tertiary.f32(i32, float, float, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #2
+
+attributes #0 = { nounwind readnone }
+attributes #1 = { nounwind }
+attributes #2 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"dxc(private) 1.8.0.4662 (416fab6b5)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 8}
+!3 = !{!"vs", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %hostlayout._18_20* undef, !"", i32 1, i32 0, i32 1, i32 88, null}
+!7 = !{[12 x i32] [i32 10, i32 12, i32 3840, i32 3840, i32 0, i32 0, i32 1, i32 2, i32 4, i32 8, i32 16, i32 32]}
+!8 = !{void ()* @main, !"main", !9, !4, null}
+!9 = !{!10, !19, null}
+!10 = !{!11, !14, !17}
+!11 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !12, i8 0, i32 1, i8 2, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 3}
+!14 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !15, i8 0, i32 1, i8 4, i32 1, i8 0, !16}
+!15 = !{i32 1}
+!16 = !{i32 3, i32 15}
+!17 = !{i32 2, !"TEXCOORD", i8 9, i8 0, !18, i8 0, i32 1, i8 2, i32 2, i8 0, !13}
+!18 = !{i32 2}
+!19 = !{!20, !21, !22}
+!20 = !{i32 0, !"TEXCOORD", i8 9, i8 0, !12, i8 2, i32 1, i8 4, i32 0, i8 0, !16}
+!21 = !{i32 1, !"TEXCOORD", i8 9, i8 0, !15, i8 2, i32 1, i8 2, i32 1, i8 0, !13}
+!22 = !{i32 2, !"SV_Position", i8 9, i8 3, !12, i8 4, i32 1, i8 4, i32 2, i8 0, !16}
+
+#endif
+
+static const unsigned char tri_texture_vert_sm60_dxil[] = {
+  0x44, 0x58, 0x42, 0x43, 0x1d, 0x39, 0x3a, 0xc6, 0x32, 0xb6, 0x8e, 0x58,
+  0x41, 0xa6, 0x3b, 0x02, 0xc5, 0x3c, 0xcc, 0x94, 0x01, 0x00, 0x00, 0x00,
+  0xc8, 0x10, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+  0x4c, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00,
+  0x8c, 0x02, 0x00, 0x00, 0x24, 0x09, 0x00, 0x00, 0x40, 0x09, 0x00, 0x00,
+  0x53, 0x46, 0x49, 0x30, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0x53, 0x47, 0x31, 0x74, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43,
+  0x4f, 0x4f, 0x52, 0x44, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x53, 0x47, 0x31,
+  0x80, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x68, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x0c, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x53, 0x56, 0x5f,
+  0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x53, 0x56, 0x30, 0x34, 0x01, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x2e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x34, 0x00, 0x00, 0x00, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x54,
+  0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52, 0x44, 0x00, 0x54, 0x45, 0x58, 0x43,
+  0x4f, 0x4f, 0x52, 0x44, 0x00, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x4f, 0x52,
+  0x44, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x42, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x44, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x42, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x44, 0x00, 0x03, 0x02, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x42, 0x00, 0x03, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x44, 0x03,
+  0x03, 0x04, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x54, 0x41, 0x54, 0x90, 0x06, 0x00, 0x00,
+  0x60, 0x00, 0x01, 0x00, 0xa4, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+  0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x78, 0x06, 0x00, 0x00,
+  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0x9b, 0x01, 0x00, 0x00,
+  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d,
+  0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff,
+  0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66,
+  0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14,
+  0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f,
+  0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6,
+  0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42,
+  0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42,
+  0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4,
+  0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x61,
+  0x04, 0x61, 0xb8, 0xe8, 0x70, 0xa4, 0x69, 0x01, 0x30, 0x87, 0x9a, 0xfc,
+  0xbf, 0xe6, 0x7f, 0x9b, 0x46, 0x83, 0xad, 0x97, 0x70, 0x32, 0x10, 0x00,
+  0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79,
+  0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e,
+  0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34,
+  0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4,
+  0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
+  0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x16, 0x08, 0x00, 0x14, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22,
+  0x25, 0x30, 0x02, 0x50, 0x0c, 0x05, 0x1b, 0x50, 0x04, 0x85, 0x50, 0x06,
+  0xe5, 0x50, 0x12, 0x05, 0x18, 0x50, 0x1a, 0x05, 0x1a, 0x50, 0x1e, 0x45,
+  0x51, 0x68, 0x05, 0x41, 0xa5, 0x24, 0x46, 0x00, 0x8a, 0xa0, 0x10, 0xca,
+  0x80, 0x62, 0x0d, 0x10, 0x9e, 0x01, 0xa0, 0x3c, 0x03, 0x40, 0x7a, 0x2c,
+  0x46, 0x61, 0x40, 0x7c, 0x00, 0xf1, 0x01, 0x00, 0x02, 0x81, 0x40, 0x20,
+  0x30, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00,
+  0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4, 0x31, 0x20, 0xc3, 0x1b,
+  0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b, 0x4b, 0x01, 0x89, 0x71,
+  0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91, 0x01, 0x41, 0xa1, 0x89,
+  0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49, 0xd9, 0x10, 0x04, 0x13,
+  0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61, 0x20, 0x36, 0x08, 0x04,
+  0x41, 0xc1, 0x6e, 0x6e, 0x82, 0x40, 0x20, 0x1b, 0x86, 0x03, 0x21, 0x26,
+  0x08, 0x59, 0x47, 0xe3, 0x2b, 0x06, 0xe7, 0x4b, 0x06, 0x66, 0x82, 0x40,
+  0x24, 0x1b, 0x10, 0x42, 0x59, 0x06, 0x62, 0x60, 0x80, 0x0d, 0x41, 0xb3,
+  0x81, 0x00, 0x00, 0x07, 0x98, 0x20, 0x60, 0x1c, 0x8d, 0x2f, 0x19, 0x98,
+  0xaf, 0x36, 0x98, 0x09, 0x02, 0xa1, 0x4c, 0x10, 0x88, 0x65, 0xc3, 0x30,
+  0x4d, 0xc3, 0x04, 0x81, 0x60, 0x26, 0x08, 0x44, 0x33, 0x41, 0x20, 0x9c,
+  0x09, 0x42, 0xb4, 0x6d, 0x50, 0x90, 0x48, 0xa2, 0x2a, 0xc2, 0xba, 0x2e,
+  0x8c, 0xc6, 0x97, 0x0c, 0xcc, 0x57, 0x5b, 0xcc, 0x04, 0x81, 0x78, 0x26,
+  0x08, 0x04, 0xb4, 0x01, 0x41, 0xb4, 0x6a, 0xb3, 0x2e, 0x6e, 0xa2, 0xf1,
+  0x25, 0x03, 0xf3, 0xd5, 0x26, 0x33, 0x41, 0x20, 0xa2, 0x0d, 0x0a, 0xe2,
+  0x55, 0x9f, 0x75, 0x5d, 0x18, 0x27, 0x6d, 0x20, 0x98, 0xac, 0x03, 0x83,
+  0x0d, 0x03, 0x01, 0x85, 0xc1, 0x04, 0x41, 0x00, 0x36, 0x00, 0x1b, 0x06,
+  0x82, 0x0c, 0xc8, 0x60, 0x43, 0x50, 0x06, 0x1b, 0x86, 0x61, 0x0c, 0xcc,
+  0x60, 0x82, 0xa0, 0x79, 0x1b, 0x02, 0x34, 0x20, 0xd1, 0x16, 0x96, 0xe6,
+  0x46, 0x84, 0xaa, 0x08, 0x6b, 0xe8, 0xe9, 0x49, 0x8a, 0x68, 0x82, 0x50,
+  0x58, 0x13, 0x84, 0xe2, 0xda, 0x10, 0x10, 0x13, 0x84, 0x02, 0xdb, 0x20,
+  0x54, 0xd5, 0x86, 0x85, 0x58, 0x03, 0x36, 0x68, 0x03, 0x37, 0x68, 0x83,
+  0xe1, 0x0d, 0x88, 0x36, 0x80, 0x83, 0x0d, 0xc1, 0x30, 0x41, 0x28, 0xb2,
+  0x09, 0x02, 0x21, 0x6d, 0x10, 0x2a, 0x3a, 0xd8, 0xb0, 0x0c, 0x6b, 0xc0,
+  0x06, 0x6d, 0x20, 0x07, 0x6d, 0x30, 0xcc, 0xc1, 0xd0, 0x06, 0x75, 0xb0,
+  0x21, 0x90, 0x36, 0x2c, 0xd2, 0x1a, 0xb0, 0x41, 0x1b, 0xdc, 0x41, 0x1b,
+  0x0c, 0x6f, 0x20, 0xb5, 0x01, 0x1c, 0x6c, 0x18, 0xe2, 0xc0, 0x0e, 0xf0,
+  0x60, 0xc3, 0x42, 0xac, 0x01, 0x1b, 0xb4, 0x81, 0x1b, 0xbc, 0xc1, 0x30,
+  0x07, 0x44, 0x1b, 0xd4, 0xc1, 0x86, 0x65, 0x58, 0x03, 0x36, 0x68, 0x03,
+  0x39, 0x78, 0x83, 0xe1, 0x0d, 0x86, 0x36, 0x80, 0x03, 0x2e, 0x53, 0x56,
+  0x5f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x13, 0x84, 0x42,
+  0xdb, 0xb0, 0x48, 0x7c, 0xc0, 0x06, 0x7d, 0xe0, 0x06, 0x73, 0x30, 0xcc,
+  0x81, 0xd4, 0x06, 0x75, 0xb0, 0x61, 0xd0, 0x83, 0x3d, 0xf0, 0x83, 0x0d,
+  0x43, 0x1e, 0xfc, 0x01, 0xb0, 0xa1, 0x18, 0x03, 0x35, 0x00, 0x85, 0x07,
+  0xa0, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x37, 0x37, 0x41, 0x20, 0x26, 0x16,
+  0x69, 0x6e, 0x73, 0x74, 0x73, 0x13, 0x04, 0x82, 0xa2, 0x31, 0x97, 0x76,
+  0xf6, 0xc5, 0x46, 0x36, 0x41, 0x20, 0x2a, 0x1a, 0x73, 0x69, 0x67, 0x5f,
+  0x73, 0x74, 0x1b, 0x10, 0x51, 0x18, 0x05, 0x52, 0x28, 0x05, 0x53, 0x38,
+  0x05, 0x54, 0x18, 0x85, 0x2a, 0x6c, 0x6c, 0x76, 0x6d, 0x2e, 0x69, 0x64,
+  0x65, 0x6e, 0x74, 0x53, 0x82, 0xa0, 0x0a, 0x19, 0x9e, 0x8b, 0x5d, 0x99,
+  0xdc, 0x5c, 0xda, 0x9b, 0xdb, 0x94, 0x80, 0x68, 0x42, 0x86, 0xe7, 0x62,
+  0x17, 0xc6, 0x66, 0x57, 0x26, 0x37, 0x25, 0x28, 0xea, 0x90, 0xe1, 0xb9,
+  0xcc, 0xa1, 0x85, 0x91, 0x95, 0xc9, 0x35, 0xbd, 0x91, 0x95, 0xb1, 0x4d,
+  0x09, 0x90, 0x32, 0x64, 0x78, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72,
+  0x63, 0x65, 0x73, 0x53, 0x02, 0xa7, 0x12, 0x19, 0x9e, 0x0b, 0x5d, 0x1e,
+  0x5c, 0x59, 0x90, 0x9b, 0xdb, 0x1b, 0x5d, 0x18, 0x5d, 0xda, 0x9b, 0xdb,
+  0xdc, 0x14, 0x21, 0x0c, 0xcc, 0xa0, 0x0e, 0x19, 0x9e, 0x8b, 0x5d, 0x5a,
+  0xd9, 0x5d, 0x12, 0xd9, 0x14, 0x5d, 0x18, 0x5d, 0xd9, 0x94, 0x00, 0x0d,
+  0xea, 0x90, 0xe1, 0xb9, 0x94, 0xb9, 0xd1, 0xc9, 0xe5, 0x41, 0xbd, 0xa5,
+  0xb9, 0xd1, 0xcd, 0x4d, 0x09, 0x40, 0xa1, 0x0b, 0x19, 0x9e, 0xcb, 0xd8,
+  0x5b, 0x9d, 0x1b, 0x5d, 0x99, 0xdc, 0xdc, 0x94, 0x00, 0x15, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70,
+  0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60,
+  0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4,
+  0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97,
+  0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25,
+  0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce,
+  0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0,
+  0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93,
+  0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e,
+  0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3,
+  0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7,
+  0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x48, 0x41, 0x53, 0x48, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xc1, 0x0d, 0x07, 0xe0, 0x10, 0x02, 0x07, 0x06, 0x9c, 0xb2, 0x9b, 0x72,
+  0xa3, 0x5d, 0x05, 0xb6, 0x44, 0x58, 0x49, 0x4c, 0x80, 0x07, 0x00, 0x00,
+  0x60, 0x00, 0x01, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+  0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x68, 0x07, 0x00, 0x00,
+  0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xd7, 0x01, 0x00, 0x00,
+  0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+  0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39,
+  0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62,
+  0x80, 0x14, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14,
+  0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20,
+  0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0xe4, 0x48, 0x0e, 0x90,
+  0x91, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a,
+  0x04, 0x29, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x1b, 0x8c, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x02, 0xa8, 0x0d,
+  0x84, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x6d, 0x30, 0x86, 0xff,
+  0xff, 0xff, 0xff, 0x1f, 0x00, 0x09, 0xa8, 0x00, 0x49, 0x18, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x13, 0x82, 0x60, 0x42, 0x20, 0x4c, 0x08, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+  0x32, 0x22, 0x48, 0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84,
+  0x04, 0x93, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c,
+  0x0b, 0x84, 0xa4, 0x4c, 0x10, 0x6c, 0x23, 0x00, 0x25, 0x00, 0x14, 0x66,
+  0x00, 0xe6, 0x08, 0xc0, 0x60, 0x8e, 0x00, 0x29, 0xc6, 0x20, 0x84, 0x14,
+  0x42, 0xa6, 0x18, 0x80, 0x10, 0x52, 0x06, 0xa1, 0xa3, 0x86, 0xcb, 0x9f,
+  0xb0, 0x87, 0x90, 0x7c, 0x6e, 0xa3, 0x8a, 0x95, 0x98, 0xfc, 0xe2, 0xb6,
+  0x11, 0x31, 0xc6, 0x18, 0x54, 0xee, 0x19, 0x2e, 0x7f, 0xc2, 0x1e, 0x42,
+  0xf2, 0x43, 0xa0, 0x19, 0x16, 0x02, 0x05, 0xab, 0x10, 0x8a, 0x30, 0x42,
+  0xad, 0x14, 0x83, 0x8c, 0x31, 0xe8, 0xcd, 0x11, 0x04, 0xc5, 0x60, 0xa4,
+  0x10, 0x12, 0x49, 0x0e, 0x04, 0x0c, 0x23, 0x10, 0x43, 0x12, 0xd4, 0x61,
+  0x04, 0x61, 0xb8, 0xe8, 0x70, 0xa4, 0x69, 0x01, 0x30, 0x87, 0x9a, 0xfc,
+  0xbf, 0xe6, 0x7f, 0x9b, 0x46, 0x83, 0xad, 0x97, 0x70, 0x32, 0x10, 0x00,
+  0x13, 0x14, 0x72, 0xc0, 0x87, 0x74, 0x60, 0x87, 0x36, 0x68, 0x87, 0x79,
+  0x68, 0x03, 0x72, 0xc0, 0x87, 0x0d, 0xaf, 0x50, 0x0e, 0x6d, 0xd0, 0x0e,
+  0x7a, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x10, 0x07, 0x76, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x43, 0x9e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x3c, 0x06, 0x10, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x79, 0x10, 0x20,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf2, 0x34,
+  0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe4,
+  0x79, 0x80, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
+  0xc8, 0x23, 0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x16, 0x08, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14,
+  0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x22,
+  0x25, 0x30, 0x02, 0x50, 0x10, 0xc5, 0x50, 0xb0, 0x01, 0x65, 0x50, 0x1e,
+  0x45, 0x40, 0xa5, 0x24, 0x46, 0x00, 0x8a, 0xa0, 0x10, 0xca, 0x80, 0xf2,
+  0x0c, 0x00, 0xe9, 0xb1, 0x18, 0x85, 0x01, 0xf1, 0x01, 0xc4, 0x07, 0x00,
+  0x08, 0x04, 0x02, 0x81, 0xc0, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00,
+  0x5f, 0x00, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x90, 0x46, 0x02, 0x13, 0xc4,
+  0x31, 0x20, 0xc3, 0x1b, 0x43, 0x81, 0x93, 0x4b, 0xb3, 0x0b, 0xa3, 0x2b,
+  0x4b, 0x01, 0x89, 0x71, 0xc1, 0x71, 0x81, 0x71, 0xa1, 0xb1, 0xb1, 0x91,
+  0x01, 0x41, 0xa1, 0x89, 0xb1, 0x31, 0x0b, 0x13, 0xb3, 0x11, 0xab, 0x49,
+  0xd9, 0x10, 0x04, 0x13, 0x04, 0xc2, 0x98, 0x20, 0x10, 0xc7, 0x06, 0x61,
+  0x20, 0x26, 0x08, 0x04, 0xb2, 0x41, 0x18, 0x0c, 0x0a, 0x76, 0x73, 0x13,
+  0x04, 0x22, 0xd9, 0x30, 0x20, 0x09, 0x31, 0x41, 0xc8, 0x26, 0x02, 0x13,
+  0x04, 0x42, 0xd9, 0x80, 0x10, 0x0b, 0x33, 0x10, 0x43, 0x03, 0x6c, 0x08,
+  0x9c, 0x0d, 0x04, 0x00, 0x3c, 0xc0, 0x04, 0x41, 0xa3, 0x36, 0x04, 0xd1,
+  0x04, 0x41, 0x00, 0x48, 0xb4, 0x85, 0xa5, 0xb9, 0x11, 0xa1, 0x2a, 0xc2,
+  0x1a, 0x7a, 0x7a, 0x92, 0x22, 0x9a, 0x20, 0x14, 0xce, 0x04, 0xa1, 0x78,
+  0x36, 0x04, 0xc4, 0x04, 0xa1, 0x80, 0x26, 0x08, 0xc4, 0xb2, 0x41, 0xd0,
+  0xb4, 0x0d, 0x0b, 0x51, 0x59, 0x17, 0x76, 0x0d, 0x19, 0x71, 0x6d, 0x1b,
+  0x82, 0x61, 0x82, 0x50, 0x44, 0x13, 0x04, 0x82, 0xd9, 0x20, 0x68, 0xdf,
+  0x86, 0x65, 0xa8, 0xac, 0xab, 0xbb, 0x06, 0x6f, 0xb8, 0xc0, 0x60, 0x82,
+  0x40, 0x34, 0x1b, 0x02, 0x31, 0xd8, 0xb0, 0x88, 0x41, 0x65, 0x5d, 0x63,
+  0x70, 0x0d, 0x99, 0x18, 0x5c, 0xdb, 0x86, 0x81, 0x0b, 0x03, 0x32, 0xd8,
+  0xb0, 0x10, 0x95, 0x75, 0x61, 0xd9, 0xe0, 0x11, 0x17, 0x18, 0x6c, 0x58,
+  0x86, 0xca, 0xba, 0xba, 0x6c, 0xc8, 0x86, 0x6b, 0xe3, 0x32, 0x65, 0xf5,
+  0x05, 0xf5, 0x36, 0x97, 0x46, 0x97, 0xf6, 0xe6, 0x36, 0x41, 0x28, 0xa4,
+  0x0d, 0x8b, 0x18, 0xa0, 0x81, 0x95, 0x06, 0x98, 0x37, 0x78, 0x62, 0x70,
+  0x81, 0xc1, 0x86, 0xc1, 0x0c, 0xce, 0x40, 0x0d, 0x36, 0x0c, 0x65, 0xb0,
+  0x06, 0xc0, 0x86, 0x62, 0xa2, 0xd8, 0x00, 0x02, 0xaa, 0xb0, 0xb1, 0xd9,
+  0xb5, 0xb9, 0xa4, 0x91, 0x95, 0xb9, 0xd1, 0x4d, 0x09, 0x82, 0x2a, 0x64,
+  0x78, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x02, 0xa2,
+  0x09, 0x19, 0x9e, 0x8b, 0x5d, 0x18, 0x9b, 0x5d, 0x99, 0xdc, 0x94, 0xc0,
+  0xa8, 0x43, 0x86, 0xe7, 0x32, 0x87, 0x16, 0x46, 0x56, 0x26, 0xd7, 0xf4,
+  0x46, 0x56, 0xc6, 0x36, 0x25, 0x48, 0xca, 0x90, 0xe1, 0xb9, 0xc8, 0x95,
+  0xcd, 0xbd, 0xd5, 0xc9, 0x8d, 0x95, 0xcd, 0x4d, 0x09, 0x9e, 0x3a, 0x64,
+  0x78, 0x2e, 0x76, 0x69, 0x65, 0x77, 0x49, 0x64, 0x53, 0x74, 0x61, 0x74,
+  0x65, 0x53, 0x82, 0xa8, 0x0e, 0x19, 0x9e, 0x4b, 0x99, 0x1b, 0x9d, 0x5c,
+  0x1e, 0xd4, 0x5b, 0x9a, 0x1b, 0xdd, 0xdc, 0x94, 0x80, 0x0d, 0x00, 0x00,
+  0x79, 0x18, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c,
+  0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3,
+  0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6,
+  0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43,
+  0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03,
+  0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48,
+  0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20,
+  0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e,
+  0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d,
+  0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89,
+  0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83,
+  0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68,
+  0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90,
+  0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78,
+  0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98,
+  0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5,
+  0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c,
+  0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43,
+  0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82,
+  0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x8c, 0xc8, 0x21, 0x07, 0x7c, 0x70,
+  0x03, 0x72, 0x10, 0x87, 0x73, 0x70, 0x03, 0x7b, 0x08, 0x07, 0x79, 0x60,
+  0x87, 0x70, 0xc8, 0x87, 0x77, 0xa8, 0x07, 0x7a, 0x98, 0x81, 0x3c, 0xe4,
+  0x80, 0x0f, 0x6e, 0x40, 0x0f, 0xe5, 0xd0, 0x0e, 0xf0, 0x00, 0x00, 0x00,
+  0x71, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x36, 0xb0, 0x0d, 0x97,
+  0xef, 0x3c, 0xbe, 0x10, 0x50, 0x45, 0x41, 0x44, 0xa5, 0x03, 0x0c, 0x25,
+  0x61, 0x00, 0x02, 0xe6, 0x17, 0xb7, 0x6d, 0x05, 0xd2, 0x70, 0xf9, 0xce,
+  0xe3, 0x0b, 0x11, 0x01, 0x4c, 0x44, 0x08, 0x34, 0xc3, 0x42, 0x58, 0xc0,
+  0x34, 0x5c, 0xbe, 0xf3, 0xf8, 0x8b, 0x03, 0x0c, 0x62, 0xf3, 0x50, 0x93,
+  0x5f, 0xdc, 0xb6, 0x09, 0x54, 0xc3, 0xe5, 0x3b, 0x8f, 0x2f, 0x4d, 0x4e,
+  0x44, 0xa0, 0xd4, 0xf4, 0x50, 0x93, 0x5f, 0xdc, 0xb6, 0x11, 0x48, 0xc3,
+  0xe5, 0x3b, 0x8f, 0x3f, 0x11, 0xd1, 0x84, 0x00, 0x11, 0xe6, 0x17, 0xb7,
+  0x6d, 0x00, 0x04, 0x03, 0x20, 0x0d, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00,
+  0x79, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x44, 0x4a, 0xa1, 0x10, 0x66, 0x00, 0xca, 0xae,
+  0xb8, 0x4a, 0x8e, 0x4a, 0x09, 0x50, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x20, 0x61, 0x43, 0x63, 0x59, 0xc1,
+  0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x18, 0x1d, 0x12, 0x5d, 0xcf, 0x31,
+  0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x86, 0x97, 0x48, 0x18, 0x81, 0x8c,
+  0x18, 0x24, 0x00, 0x08, 0x82, 0x81, 0xf1, 0x29, 0x5a, 0x16, 0x25, 0x23,
+  0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x80, 0xc1, 0xb2, 0x69, 0x86, 0x32,
+  0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x46, 0x18, 0x30, 0xdc, 0x26, 0x2d,
+  0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x88, 0x41, 0xd3, 0x71, 0x11,
+  0x33, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0xc6, 0x18, 0x38, 0x5d, 0x57,
+  0x35, 0x23, 0x06, 0x09, 0x00, 0x82, 0x60, 0x60, 0x90, 0xc1, 0xe3, 0x79,
+  0x8a, 0x33, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0xcd, 0x18, 0x38, 0xc9,
+  0x37, 0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x30, 0x9a, 0x30, 0x08, 0xa3,
+  0x09, 0xc4, 0x30, 0x62, 0x70, 0x00, 0x20, 0x08, 0x06, 0x0d, 0x1a, 0x4c,
+  0x4e, 0x19, 0x8c, 0x26, 0x04, 0xc0, 0x68, 0x82, 0x10, 0x8c, 0x26, 0x0c,
+  0xc2, 0x68, 0x02, 0x31, 0x8c, 0x18, 0x1c, 0x00, 0x08, 0x82, 0x41, 0xd3,
+  0x06, 0xd8, 0x54, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x9a, 0x20, 0x04, 0xa3,
+  0x09, 0x83, 0x30, 0x9a, 0x40, 0x0c, 0xe6, 0x44, 0xf2, 0x19, 0x31, 0x40,
+  0x00, 0x10, 0x04, 0x83, 0x47, 0x0e, 0xba, 0x48, 0x09, 0xcc, 0x08, 0xa0,
+  0x63, 0x10, 0x25, 0x9f, 0x11, 0x03, 0x04, 0x00, 0x41, 0x30, 0x78, 0xea,
+  0x00, 0x0c, 0x28, 0x26, 0xb0, 0x00, 0x81, 0x8e, 0x49, 0x97, 0x7c, 0x46,
+  0x0c, 0x10, 0x00, 0x04, 0xc1, 0xe0, 0xc1, 0x83, 0x31, 0xb8, 0x9c, 0xc0,
+  0x02, 0x05, 0x3a, 0x46, 0x69, 0xf2, 0x19, 0x31, 0x40, 0x00, 0x10, 0x04,
+  0x83, 0x67, 0x0f, 0xcc, 0x40, 0x83, 0x02, 0x0b, 0x18, 0xe8, 0x8c, 0x18,
+  0x1c, 0x00, 0x08, 0x82, 0x41, 0xe3, 0x07, 0x69, 0x40, 0x06, 0x6c, 0x30,
+  0x9a, 0x10, 0x00, 0xa3, 0x09, 0x42, 0x60, 0x66, 0x20, 0xd0, 0xc7, 0xcc,
+  0x40, 0xa0, 0xcf, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0xa4, 0x10,
+  0x07, 0x7f, 0xf0, 0x07, 0x77, 0x60, 0x06, 0x23, 0x06, 0x09, 0x00, 0x82,
+  0x60, 0x80, 0x90, 0x42, 0x1c, 0xfc, 0xc1, 0x1f, 0xac, 0x41, 0x19, 0x8c,
+  0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0x42, 0x0a, 0x71, 0xf0, 0x07, 0x7f,
+  0x60, 0x07, 0x64, 0x30, 0x62, 0x90, 0x00, 0x20, 0x08, 0x06, 0x08, 0x29,
+  0xc4, 0xc1, 0x1f, 0xfc, 0x01, 0x1d, 0x8c, 0xc1, 0x88, 0x41, 0x02, 0x80,
+  0x20, 0x18, 0x20, 0xa4, 0x10, 0x07, 0xa0, 0xf0, 0x07, 0x77, 0x20, 0x8c,
+  0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0x42, 0x0a, 0x71, 0x00, 0x0a, 0x7f,
+  0xb0, 0x06, 0xc1, 0x88, 0x41, 0x02, 0x80, 0x20, 0x18, 0x20, 0xa4, 0x10,
+  0x07, 0x79, 0xf0, 0x07, 0x77, 0xf0, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82,
+  0x01, 0x42, 0x0a, 0x71, 0x90, 0x07, 0x7f, 0xb0, 0x06, 0xcc, 0x88, 0x41,
+  0x02, 0x80, 0x20, 0x18, 0x20, 0xa4, 0x10, 0x07, 0x79, 0xf0, 0x07, 0x76,
+  0x90, 0x8c, 0x18, 0x24, 0x00, 0x08, 0x82, 0x01, 0x42, 0x0a, 0x71, 0x90,
+  0x07, 0x7f, 0x40, 0x07, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
diff --git a/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.spv.h b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.spv.h
new file mode 100644
index 0000000..862dc79
--- /dev/null
+++ b/SDL-3.2.8/src/render/gpu/shaders/tri_texture.vert.spv.h
@@ -0,0 +1,106 @@
+static const unsigned char tri_texture_vert_spv[] = {
+  0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x00, 0x08, 0x00,
+  0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
+  0x01, 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, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+  0x25, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x48, 0x00, 0x04, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x48, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x48, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x47, 0x00, 0x03, 0x00,
+  0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x14, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x47, 0x00, 0x04, 0x00, 0x25, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00, 0x28, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47, 0x00, 0x04, 0x00,
+  0x29, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x03, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x15, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x04, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x06, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x0b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15, 0x00, 0x04, 0x00,
+  0x0e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x17, 0x00, 0x04, 0x00,
+  0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x05, 0x00, 0x12, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x15, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f,
+  0x20, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00, 0x21, 0x00, 0x00, 0x00,
+  0x23, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x24, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00, 0x27, 0x00, 0x00, 0x00,
+  0x03, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x04, 0x00,
+  0x27, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+  0x3b, 0x00, 0x04, 0x00, 0x18, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x04, 0x00, 0x0e, 0x00, 0x00, 0x00,
+  0x2b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, 0x00,
+  0x2c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00,
+  0x05, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x15, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+  0x16, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x1a, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00,
+  0x1e, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x50, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+  0x1d, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+  0x1c, 0x00, 0x00, 0x00, 0x91, 0x00, 0x05, 0x00, 0x07, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+  0x41, 0x00, 0x05, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+  0x0d, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x03, 0x00,
+  0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x04, 0x00,
+  0x07, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x03, 0x00, 0x23, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+  0x29, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00, 0x2c, 0x00, 0x00, 0x00,
+  0x2d, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00,
+  0x3d, 0x00, 0x04, 0x00, 0x11, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
+  0x2d, 0x00, 0x00, 0x00, 0x88, 0x00, 0x05, 0x00, 0x11, 0x00, 0x00, 0x00,
+  0x2f, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x03, 0x00, 0x28, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+  0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00
+};
+static const unsigned int tri_texture_vert_spv_len = 1232;
diff --git a/SDL-3.2.8/src/render/metal/SDL_render_metal.m b/SDL-3.2.8/src/render/metal/SDL_render_metal.m
new file mode 100644
index 0000000..63d9770
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_render_metal.m
@@ -0,0 +1,2196 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_METAL
+
+#include "../SDL_sysrender.h"
+#include "../../video/SDL_pixels_c.h"
+
+#import <CoreVideo/CoreVideo.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#ifdef SDL_VIDEO_DRIVER_COCOA
+#import <AppKit/NSWindow.h>
+#import <AppKit/NSView.h>
+#endif
+#ifdef SDL_VIDEO_DRIVER_UIKIT
+#import <UIKit/UIKit.h>
+#endif
+
+// Regenerate these with build-metal-shaders.sh
+#ifdef SDL_PLATFORM_MACOS
+#include "SDL_shaders_metal_macos.h"
+#elif defined(SDL_PLATFORM_TVOS)
+#if TARGET_OS_SIMULATOR
+#include "SDL_shaders_metal_tvsimulator.h"
+#else
+#include "SDL_shaders_metal_tvos.h"
+#endif
+#else
+#if TARGET_OS_SIMULATOR
+#include "SDL_shaders_metal_iphonesimulator.h"
+#else
+#include "SDL_shaders_metal_ios.h"
+#endif
+#endif
+
+// Apple Metal renderer implementation
+
+// macOS requires constants in a buffer to have a 256 byte alignment.
+// Use native type alignments from https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
+#if defined(SDL_PLATFORM_MACOS) || TARGET_OS_SIMULATOR || TARGET_OS_MACCATALYST
+#define CONSTANT_ALIGN(x) (256)
+#else
+#define CONSTANT_ALIGN(x) (x < 4 ? 4 : x)
+#endif
+
+#define DEVICE_ALIGN(x) (x < 4 ? 4 : x)
+
+#define ALIGN_CONSTANTS(align, size) ((size + CONSTANT_ALIGN(align) - 1) & (~(CONSTANT_ALIGN(align) - 1)))
+
+static const size_t CONSTANTS_OFFSET_INVALID = 0xFFFFFFFF;
+static const size_t CONSTANTS_OFFSET_IDENTITY = 0;
+static const size_t CONSTANTS_OFFSET_HALF_PIXEL_TRANSFORM = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_IDENTITY + sizeof(float) * 16);
+static const size_t CONSTANTS_OFFSET_DECODE_BT601_LIMITED = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_HALF_PIXEL_TRANSFORM + sizeof(float) * 16);
+static const size_t CONSTANTS_OFFSET_DECODE_BT601_FULL = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_DECODE_BT601_LIMITED + sizeof(float) * 4 * 4);
+static const size_t CONSTANTS_OFFSET_DECODE_BT709_LIMITED = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_DECODE_BT601_FULL + sizeof(float) * 4 * 4);
+static const size_t CONSTANTS_OFFSET_DECODE_BT709_FULL = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_DECODE_BT709_LIMITED + sizeof(float) * 4 * 4);
+static const size_t CONSTANTS_OFFSET_DECODE_BT2020_LIMITED = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_DECODE_BT709_FULL + sizeof(float) * 4 * 4);
+static const size_t CONSTANTS_OFFSET_DECODE_BT2020_FULL = ALIGN_CONSTANTS(16, CONSTANTS_OFFSET_DECODE_BT2020_LIMITED + sizeof(float) * 4 * 4);
+static const size_t CONSTANTS_LENGTH = CONSTANTS_OFFSET_DECODE_BT2020_FULL + sizeof(float) * 4 * 4;
+
+// Sampler types
+typedef enum
+{
+    SDL_METAL_SAMPLER_NEAREST_CLAMP,
+    SDL_METAL_SAMPLER_NEAREST_WRAP,
+    SDL_METAL_SAMPLER_LINEAR_CLAMP,
+    SDL_METAL_SAMPLER_LINEAR_WRAP,
+    SDL_NUM_METAL_SAMPLERS
+} SDL_METAL_sampler_type;
+
+typedef enum SDL_MetalVertexFunction
+{
+    SDL_METAL_VERTEX_SOLID,
+    SDL_METAL_VERTEX_COPY,
+} SDL_MetalVertexFunction;
+
+typedef enum SDL_MetalFragmentFunction
+{
+    SDL_METAL_FRAGMENT_SOLID = 0,
+    SDL_METAL_FRAGMENT_COPY,
+    SDL_METAL_FRAGMENT_YUV,
+    SDL_METAL_FRAGMENT_NV12,
+    SDL_METAL_FRAGMENT_COUNT,
+} SDL_MetalFragmentFunction;
+
+typedef struct METAL_PipelineState
+{
+    SDL_BlendMode blendMode;
+    void *pipe;
+} METAL_PipelineState;
+
+typedef struct METAL_PipelineCache
+{
+    METAL_PipelineState *states;
+    int count;
+    SDL_MetalVertexFunction vertexFunction;
+    SDL_MetalFragmentFunction fragmentFunction;
+    MTLPixelFormat renderTargetFormat;
+    const char *label;
+} METAL_PipelineCache;
+
+/* Each shader combination used by drawing functions has a separate pipeline
+ * cache, and we have a separate list of caches for each render target pixel
+ * format. This is more efficient than iterating over a global cache to find
+ * the pipeline based on the specified shader combination and RT pixel format,
+ * since we know what the RT pixel format is when we set the render target, and
+ * we know what the shader combination is inside each drawing function's code. */
+typedef struct METAL_ShaderPipelines
+{
+    MTLPixelFormat renderTargetFormat;
+    METAL_PipelineCache caches[SDL_METAL_FRAGMENT_COUNT];
+} METAL_ShaderPipelines;
+
+@interface SDL3METAL_RenderData : NSObject
+@property(nonatomic, retain) id<MTLDevice> mtldevice;
+@property(nonatomic, retain) id<MTLCommandQueue> mtlcmdqueue;
+@property(nonatomic, retain) id<MTLCommandBuffer> mtlcmdbuffer;
+@property(nonatomic, retain) id<MTLRenderCommandEncoder> mtlcmdencoder;
+@property(nonatomic, retain) id<MTLLibrary> mtllibrary;
+@property(nonatomic, retain) id<CAMetalDrawable> mtlbackbuffer;
+@property(nonatomic, retain) NSMutableArray<id<MTLSamplerState>> *mtlsamplers;
+@property(nonatomic, retain) id<MTLBuffer> mtlbufconstants;
+@property(nonatomic, retain) id<MTLBuffer> mtlbufquadindices;
+@property(nonatomic, assign) SDL_MetalView mtlview;
+@property(nonatomic, retain) CAMetalLayer *mtllayer;
+@property(nonatomic, retain) MTLRenderPassDescriptor *mtlpassdesc;
+@property(nonatomic, assign) METAL_ShaderPipelines *activepipelines;
+@property(nonatomic, assign) METAL_ShaderPipelines *allpipelines;
+@property(nonatomic, assign) int pipelinescount;
+@end
+
+@implementation SDL3METAL_RenderData
+@end
+
+@interface SDL3METAL_TextureData : NSObject
+@property(nonatomic, retain) id<MTLTexture> mtltexture;
+@property(nonatomic, retain) id<MTLTexture> mtltextureUv;
+@property(nonatomic, assign) SDL_MetalFragmentFunction fragmentFunction;
+#ifdef SDL_HAVE_YUV
+@property(nonatomic, assign) BOOL yuv;
+@property(nonatomic, assign) BOOL nv12;
+@property(nonatomic, assign) size_t conversionBufferOffset;
+#endif
+@property(nonatomic, assign) BOOL hasdata;
+@property(nonatomic, retain) id<MTLBuffer> lockedbuffer;
+@property(nonatomic, assign) SDL_Rect lockedrect;
+@end
+
+@implementation SDL3METAL_TextureData
+@end
+
+static const MTLBlendOperation invalidBlendOperation = (MTLBlendOperation)0xFFFFFFFF;
+static const MTLBlendFactor invalidBlendFactor = (MTLBlendFactor)0xFFFFFFFF;
+
+static MTLBlendOperation GetBlendOperation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return MTLBlendOperationAdd;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return MTLBlendOperationSubtract;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return MTLBlendOperationReverseSubtract;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return MTLBlendOperationMin;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return MTLBlendOperationMax;
+    default:
+        return invalidBlendOperation;
+    }
+}
+
+static MTLBlendFactor GetBlendFactor(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return MTLBlendFactorZero;
+    case SDL_BLENDFACTOR_ONE:
+        return MTLBlendFactorOne;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return MTLBlendFactorSourceColor;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return MTLBlendFactorOneMinusSourceColor;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return MTLBlendFactorSourceAlpha;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return MTLBlendFactorOneMinusSourceAlpha;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return MTLBlendFactorDestinationColor;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return MTLBlendFactorOneMinusDestinationColor;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return MTLBlendFactorDestinationAlpha;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return MTLBlendFactorOneMinusDestinationAlpha;
+    default:
+        return invalidBlendFactor;
+    }
+}
+
+static NSString *GetVertexFunctionName(SDL_MetalVertexFunction function)
+{
+    switch (function) {
+    case SDL_METAL_VERTEX_SOLID:
+        return @"SDL_Solid_vertex";
+    case SDL_METAL_VERTEX_COPY:
+        return @"SDL_Copy_vertex";
+    default:
+        return nil;
+    }
+}
+
+static NSString *GetFragmentFunctionName(SDL_MetalFragmentFunction function)
+{
+    switch (function) {
+    case SDL_METAL_FRAGMENT_SOLID:
+        return @"SDL_Solid_fragment";
+    case SDL_METAL_FRAGMENT_COPY:
+        return @"SDL_Copy_fragment";
+    case SDL_METAL_FRAGMENT_YUV:
+        return @"SDL_YUV_fragment";
+    case SDL_METAL_FRAGMENT_NV12:
+        return @"SDL_NV12_fragment";
+    default:
+        return nil;
+    }
+}
+
+static id<MTLRenderPipelineState> MakePipelineState(SDL3METAL_RenderData *data, METAL_PipelineCache *cache,
+                                                    NSString *blendlabel, SDL_BlendMode blendmode)
+{
+    MTLRenderPipelineDescriptor *mtlpipedesc;
+    MTLVertexDescriptor *vertdesc;
+    MTLRenderPipelineColorAttachmentDescriptor *rtdesc;
+    NSError *err = nil;
+    id<MTLRenderPipelineState> state;
+    METAL_PipelineState pipeline;
+    METAL_PipelineState *states;
+
+    id<MTLFunction> mtlvertfn = [data.mtllibrary newFunctionWithName:GetVertexFunctionName(cache->vertexFunction)];
+    id<MTLFunction> mtlfragfn = [data.mtllibrary newFunctionWithName:GetFragmentFunctionName(cache->fragmentFunction)];
+    SDL_assert(mtlvertfn != nil);
+    SDL_assert(mtlfragfn != nil);
+
+    mtlpipedesc = [[MTLRenderPipelineDescriptor alloc] init];
+    mtlpipedesc.vertexFunction = mtlvertfn;
+    mtlpipedesc.fragmentFunction = mtlfragfn;
+
+    vertdesc = [MTLVertexDescriptor vertexDescriptor];
+
+    switch (cache->vertexFunction) {
+    case SDL_METAL_VERTEX_SOLID:
+        // position (float2), color (float4)
+        vertdesc.layouts[0].stride = sizeof(float) * 2 + sizeof(float) * 4;
+        vertdesc.layouts[0].stepFunction = MTLVertexStepFunctionPerVertex;
+
+        vertdesc.attributes[0].format = MTLVertexFormatFloat2;
+        vertdesc.attributes[0].offset = 0;
+        vertdesc.attributes[0].bufferIndex = 0;
+
+        vertdesc.attributes[1].format = MTLVertexFormatFloat4;
+        vertdesc.attributes[1].offset = sizeof(float) * 2;
+        vertdesc.attributes[1].bufferIndex = 0;
+
+        break;
+    case SDL_METAL_VERTEX_COPY:
+        // position (float2), color (float4), texcoord (float2)
+        vertdesc.layouts[0].stride = sizeof(float) * 2 + sizeof(float) * 4 + sizeof(float) * 2;
+        vertdesc.layouts[0].stepFunction = MTLVertexStepFunctionPerVertex;
+
+        vertdesc.attributes[0].format = MTLVertexFormatFloat2;
+        vertdesc.attributes[0].offset = 0;
+        vertdesc.attributes[0].bufferIndex = 0;
+
+        vertdesc.attributes[1].format = MTLVertexFormatFloat4;
+        vertdesc.attributes[1].offset = sizeof(float) * 2;
+        vertdesc.attributes[1].bufferIndex = 0;
+
+        vertdesc.attributes[2].format = MTLVertexFormatFloat2;
+        vertdesc.attributes[2].offset = sizeof(float) * 2 + sizeof(float) * 4;
+        vertdesc.attributes[2].bufferIndex = 0;
+        break;
+    }
+
+    mtlpipedesc.vertexDescriptor = vertdesc;
+
+    rtdesc = mtlpipedesc.colorAttachments[0];
+    rtdesc.pixelFormat = cache->renderTargetFormat;
+
+    if (blendmode != SDL_BLENDMODE_NONE) {
+        rtdesc.blendingEnabled = YES;
+        rtdesc.sourceRGBBlendFactor = GetBlendFactor(SDL_GetBlendModeSrcColorFactor(blendmode));
+        rtdesc.destinationRGBBlendFactor = GetBlendFactor(SDL_GetBlendModeDstColorFactor(blendmode));
+        rtdesc.rgbBlendOperation = GetBlendOperation(SDL_GetBlendModeColorOperation(blendmode));
+        rtdesc.sourceAlphaBlendFactor = GetBlendFactor(SDL_GetBlendModeSrcAlphaFactor(blendmode));
+        rtdesc.destinationAlphaBlendFactor = GetBlendFactor(SDL_GetBlendModeDstAlphaFactor(blendmode));
+        rtdesc.alphaBlendOperation = GetBlendOperation(SDL_GetBlendModeAlphaOperation(blendmode));
+    } else {
+        rtdesc.blendingEnabled = NO;
+    }
+
+    mtlpipedesc.label = [@(cache->label) stringByAppendingString:blendlabel];
+
+    state = [data.mtldevice newRenderPipelineStateWithDescriptor:mtlpipedesc error:&err];
+    SDL_assert(err == nil);
+
+    pipeline.blendMode = blendmode;
+    pipeline.pipe = (void *)CFBridgingRetain(state);
+
+    states = SDL_realloc(cache->states, (cache->count + 1) * sizeof(pipeline));
+
+    if (states) {
+        states[cache->count++] = pipeline;
+        cache->states = states;
+        return (__bridge id<MTLRenderPipelineState>)pipeline.pipe;
+    } else {
+        CFBridgingRelease(pipeline.pipe);
+        return NULL;
+    }
+}
+
+static void MakePipelineCache(SDL3METAL_RenderData *data, METAL_PipelineCache *cache, const char *label,
+                              MTLPixelFormat rtformat, SDL_MetalVertexFunction vertfn, SDL_MetalFragmentFunction fragfn)
+{
+    SDL_zerop(cache);
+
+    cache->vertexFunction = vertfn;
+    cache->fragmentFunction = fragfn;
+    cache->renderTargetFormat = rtformat;
+    cache->label = label;
+
+    /* Create pipeline states for the default blend modes. Custom blend modes
+     * will be added to the cache on-demand. */
+    MakePipelineState(data, cache, @" (blend=none)", SDL_BLENDMODE_NONE);
+    MakePipelineState(data, cache, @" (blend=blend)", SDL_BLENDMODE_BLEND);
+    MakePipelineState(data, cache, @" (blend=add)", SDL_BLENDMODE_ADD);
+    MakePipelineState(data, cache, @" (blend=mod)", SDL_BLENDMODE_MOD);
+    MakePipelineState(data, cache, @" (blend=mul)", SDL_BLENDMODE_MUL);
+}
+
+static void DestroyPipelineCache(METAL_PipelineCache *cache)
+{
+    if (cache != NULL) {
+        for (int i = 0; i < cache->count; i++) {
+            CFBridgingRelease(cache->states[i].pipe);
+        }
+
+        SDL_free(cache->states);
+    }
+}
+
+void MakeShaderPipelines(SDL3METAL_RenderData *data, METAL_ShaderPipelines *pipelines, MTLPixelFormat rtformat)
+{
+    SDL_zerop(pipelines);
+
+    pipelines->renderTargetFormat = rtformat;
+
+    MakePipelineCache(data, &pipelines->caches[SDL_METAL_FRAGMENT_SOLID], "SDL primitives pipeline", rtformat, SDL_METAL_VERTEX_SOLID, SDL_METAL_FRAGMENT_SOLID);
+    MakePipelineCache(data, &pipelines->caches[SDL_METAL_FRAGMENT_COPY], "SDL copy pipeline", rtformat, SDL_METAL_VERTEX_COPY, SDL_METAL_FRAGMENT_COPY);
+    MakePipelineCache(data, &pipelines->caches[SDL_METAL_FRAGMENT_YUV], "SDL YUV pipeline", rtformat, SDL_METAL_VERTEX_COPY, SDL_METAL_FRAGMENT_YUV);
+    MakePipelineCache(data, &pipelines->caches[SDL_METAL_FRAGMENT_NV12], "SDL NV12 pipeline", rtformat, SDL_METAL_VERTEX_COPY, SDL_METAL_FRAGMENT_NV12);
+}
+
+static METAL_ShaderPipelines *ChooseShaderPipelines(SDL3METAL_RenderData *data, MTLPixelFormat rtformat)
+{
+    METAL_ShaderPipelines *allpipelines = data.allpipelines;
+    int count = data.pipelinescount;
+
+    for (int i = 0; i < count; i++) {
+        if (allpipelines[i].renderTargetFormat == rtformat) {
+            return &allpipelines[i];
+        }
+    }
+
+    allpipelines = SDL_realloc(allpipelines, (count + 1) * sizeof(METAL_ShaderPipelines));
+
+    if (allpipelines == NULL) {
+        return NULL;
+    }
+
+    MakeShaderPipelines(data, &allpipelines[count], rtformat);
+
+    data.allpipelines = allpipelines;
+    data.pipelinescount = count + 1;
+
+    return &data.allpipelines[count];
+}
+
+static void DestroyAllPipelines(METAL_ShaderPipelines *allpipelines, int count)
+{
+    if (allpipelines != NULL) {
+        for (int i = 0; i < count; i++) {
+            for (int cache = 0; cache < SDL_METAL_FRAGMENT_COUNT; cache++) {
+                DestroyPipelineCache(&allpipelines[i].caches[cache]);
+            }
+        }
+
+        SDL_free(allpipelines);
+    }
+}
+
+static inline id<MTLRenderPipelineState> ChoosePipelineState(SDL3METAL_RenderData *data, METAL_ShaderPipelines *pipelines, SDL_MetalFragmentFunction fragfn, SDL_BlendMode blendmode)
+{
+    METAL_PipelineCache *cache = &pipelines->caches[fragfn];
+
+    for (int i = 0; i < cache->count; i++) {
+        if (cache->states[i].blendMode == blendmode) {
+            return (__bridge id<MTLRenderPipelineState>)cache->states[i].pipe;
+        }
+    }
+
+    return MakePipelineState(data, cache, [NSString stringWithFormat:@" (blend=custom 0x%x)", blendmode], blendmode);
+}
+
+static bool METAL_ActivateRenderCommandEncoder(SDL_Renderer *renderer, MTLLoadAction load, MTLClearColor *clear_color, id<MTLBuffer> vertex_buffer)
+{
+    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+
+    /* Our SetRenderTarget just signals that the next render operation should
+     * set up a new render pass. This is where that work happens. */
+    if (data.mtlcmdencoder == nil) {
+        id<MTLTexture> mtltexture = nil;
+
+        if (renderer->target != NULL) {
+            SDL3METAL_TextureData *texdata = (__bridge SDL3METAL_TextureData *)renderer->target->internal;
+            mtltexture = texdata.mtltexture;
+        } else {
+            if (data.mtlbackbuffer == nil) {
+                /* The backbuffer's contents aren't guaranteed to persist after
+                 * presenting, so we can leave it undefined when loading it. */
+                data.mtlbackbuffer = [data.mtllayer nextDrawable];
+                if (load == MTLLoadActionLoad) {
+                    load = MTLLoadActionDontCare;
+                }
+            }
+            if (data.mtlbackbuffer != nil) {
+                mtltexture = data.mtlbackbuffer.texture;
+            }
+        }
+
+        /* mtltexture can be nil here if macOS refused to give us a drawable,
+           which apparently can happen for minimized windows, etc. */
+        if (mtltexture == nil) {
+            return false;
+        }
+
+        if (load == MTLLoadActionClear) {
+            SDL_assert(clear_color != NULL);
+            data.mtlpassdesc.colorAttachments[0].clearColor = *clear_color;
+        }
+
+        data.mtlpassdesc.colorAttachments[0].loadAction = load;
+        data.mtlpassdesc.colorAttachments[0].texture = mtltexture;
+
+        data.mtlcmdbuffer = [data.mtlcmdqueue commandBuffer];
+        data.mtlcmdencoder = [data.mtlcmdbuffer renderCommandEncoderWithDescriptor:data.mtlpassdesc];
+
+        if (data.mtlbackbuffer != nil && mtltexture == data.mtlbackbuffer.texture) {
+            data.mtlcmdencoder.label = @"SDL metal renderer backbuffer";
+        } else {
+            data.mtlcmdencoder.label = @"SDL metal renderer render target";
+        }
+
+        /* Set up buffer bindings for positions, texcoords, and color once here,
+         * the offsets are adjusted in the code that uses them. */
+        if (vertex_buffer != nil) {
+            [data.mtlcmdencoder setVertexBuffer:vertex_buffer offset:0 atIndex:0];
+            [data.mtlcmdencoder setFragmentBuffer:vertex_buffer offset:0 atIndex:0];
+        }
+
+        data.activepipelines = ChooseShaderPipelines(data, mtltexture.pixelFormat);
+
+        // make sure this has a definite place in the queue. This way it will
+        //  execute reliably whether the app tries to make its own command buffers
+        //  or whatever. This means we can _always_ batch rendering commands!
+        [data.mtlcmdbuffer enqueue];
+    }
+
+    return true;
+}
+
+static void METAL_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+}
+
+static bool METAL_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        if (w) {
+            *w = (int)data.mtllayer.drawableSize.width;
+        }
+        if (h) {
+            *h = (int)data.mtllayer.drawableSize.height;
+        }
+        return true;
+    }
+}
+
+static bool METAL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (GetBlendFactor(srcColorFactor) == invalidBlendFactor ||
+        GetBlendFactor(srcAlphaFactor) == invalidBlendFactor ||
+        GetBlendOperation(colorOperation) == invalidBlendOperation ||
+        GetBlendFactor(dstColorFactor) == invalidBlendFactor ||
+        GetBlendFactor(dstAlphaFactor) == invalidBlendFactor ||
+        GetBlendOperation(alphaOperation) == invalidBlendOperation) {
+        return false;
+    }
+    return true;
+}
+
+size_t GetBT601ConversionMatrix(SDL_Colorspace colorspace)
+{
+    switch (SDL_COLORSPACERANGE(colorspace)) {
+    case SDL_COLOR_RANGE_LIMITED:
+    case SDL_COLOR_RANGE_UNKNOWN:
+        return CONSTANTS_OFFSET_DECODE_BT601_LIMITED;
+    case SDL_COLOR_RANGE_FULL:
+        return CONSTANTS_OFFSET_DECODE_BT601_FULL;
+    default:
+        break;
+    }
+    return 0;
+}
+
+size_t GetBT709ConversionMatrix(SDL_Colorspace colorspace)
+{
+    switch (SDL_COLORSPACERANGE(colorspace)) {
+    case SDL_COLOR_RANGE_LIMITED:
+    case SDL_COLOR_RANGE_UNKNOWN:
+        return CONSTANTS_OFFSET_DECODE_BT709_LIMITED;
+    case SDL_COLOR_RANGE_FULL:
+        return CONSTANTS_OFFSET_DECODE_BT709_FULL;
+    default:
+        break;
+    }
+    return 0;
+}
+
+size_t GetBT2020ConversionMatrix(SDL_Colorspace colorspace)
+{
+    switch (SDL_COLORSPACERANGE(colorspace)) {
+    case SDL_COLOR_RANGE_LIMITED:
+    case SDL_COLOR_RANGE_UNKNOWN:
+        return CONSTANTS_OFFSET_DECODE_BT2020_LIMITED;
+    case SDL_COLOR_RANGE_FULL:
+        return CONSTANTS_OFFSET_DECODE_BT2020_FULL;
+    default:
+        break;
+    }
+    return 0;
+}
+
+size_t GetYCbCRtoRGBConversionMatrix(SDL_Colorspace colorspace, int w, int h, int bits_per_pixel)
+{
+    const int YUV_SD_THRESHOLD = 576;
+
+    switch (SDL_COLORSPACEMATRIX(colorspace)) {
+    case SDL_MATRIX_COEFFICIENTS_BT470BG:
+    case SDL_MATRIX_COEFFICIENTS_BT601:
+        return GetBT601ConversionMatrix(colorspace);
+
+    case SDL_MATRIX_COEFFICIENTS_BT709:
+        return GetBT709ConversionMatrix(colorspace);
+
+    case SDL_MATRIX_COEFFICIENTS_BT2020_NCL:
+        return GetBT2020ConversionMatrix(colorspace);
+
+    case SDL_MATRIX_COEFFICIENTS_UNSPECIFIED:
+        switch (bits_per_pixel) {
+        case 8:
+            if (h <= YUV_SD_THRESHOLD) {
+                return GetBT601ConversionMatrix(colorspace);
+            } else {
+                return GetBT709ConversionMatrix(colorspace);
+            }
+        case 10:
+        case 16:
+            return GetBT2020ConversionMatrix(colorspace);
+        default:
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+    return 0;
+}
+
+static bool METAL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        MTLPixelFormat pixfmt;
+        MTLTextureDescriptor *mtltexdesc;
+        id<MTLTexture> mtltexture = nil, mtltextureUv = nil;
+        SDL3METAL_TextureData *texturedata;
+        CVPixelBufferRef pixelbuffer = nil;
+        IOSurfaceRef surface = nil;
+
+        pixelbuffer = SDL_GetPointerProperty(create_props, SDL_PROP_TEXTURE_CREATE_METAL_PIXELBUFFER_POINTER, nil);
+        if (pixelbuffer) {
+            surface = CVPixelBufferGetIOSurface(pixelbuffer);
+            if (!surface) {
+                return SDL_SetError("CVPixelBufferGetIOSurface() failed");
+            }
+        }
+
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_ABGR8888:
+            if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+                pixfmt = MTLPixelFormatRGBA8Unorm_sRGB;
+            } else {
+                pixfmt = MTLPixelFormatRGBA8Unorm;
+            }
+            break;
+        case SDL_PIXELFORMAT_ARGB8888:
+            if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+                pixfmt = MTLPixelFormatBGRA8Unorm_sRGB;
+            } else {
+                pixfmt = MTLPixelFormatBGRA8Unorm;
+            }
+            break;
+        case SDL_PIXELFORMAT_ABGR2101010:
+            pixfmt = MTLPixelFormatRGB10A2Unorm;
+            break;
+        case SDL_PIXELFORMAT_IYUV:
+        case SDL_PIXELFORMAT_YV12:
+        case SDL_PIXELFORMAT_NV12:
+        case SDL_PIXELFORMAT_NV21:
+            pixfmt = MTLPixelFormatR8Unorm;
+            break;
+        case SDL_PIXELFORMAT_P010:
+            pixfmt = MTLPixelFormatR16Unorm;
+            break;
+        case SDL_PIXELFORMAT_RGBA64_FLOAT:
+            pixfmt = MTLPixelFormatRGBA16Float;
+            break;
+        case SDL_PIXELFORMAT_RGBA128_FLOAT:
+            pixfmt = MTLPixelFormatRGBA32Float;
+            break;
+        default:
+            return SDL_SetError("Texture format %s not supported by Metal", SDL_GetPixelFormatName(texture->format));
+        }
+
+        mtltexdesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:pixfmt
+                                                                        width:(NSUInteger)texture->w
+                                                                       height:(NSUInteger)texture->h
+                                                                    mipmapped:NO];
+
+        if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+            mtltexdesc.usage = MTLTextureUsageShaderRead | MTLTextureUsageRenderTarget;
+        } else {
+            mtltexdesc.usage = MTLTextureUsageShaderRead;
+        }
+
+        if (surface) {
+            mtltexture = [data.mtldevice newTextureWithDescriptor:mtltexdesc iosurface:surface plane:0];
+        } else {
+            mtltexture = [data.mtldevice newTextureWithDescriptor:mtltexdesc];
+        }
+        if (mtltexture == nil) {
+            return SDL_SetError("Texture allocation failed");
+        }
+
+        mtltextureUv = nil;
+#ifdef SDL_HAVE_YUV
+        BOOL yuv = (texture->format == SDL_PIXELFORMAT_IYUV || texture->format == SDL_PIXELFORMAT_YV12);
+        BOOL nv12 = (texture->format == SDL_PIXELFORMAT_NV12 || texture->format == SDL_PIXELFORMAT_NV21 || texture->format == SDL_PIXELFORMAT_P010);
+
+        if (yuv) {
+            mtltexdesc.pixelFormat = MTLPixelFormatR8Unorm;
+            mtltexdesc.width = (texture->w + 1) / 2;
+            mtltexdesc.height = (texture->h + 1) / 2;
+            mtltexdesc.textureType = MTLTextureType2DArray;
+            mtltexdesc.arrayLength = 2;
+        } else if (texture->format == SDL_PIXELFORMAT_P010) {
+            mtltexdesc.pixelFormat = MTLPixelFormatRG16Unorm;
+            mtltexdesc.width = (texture->w + 1) / 2;
+            mtltexdesc.height = (texture->h + 1) / 2;
+        } else if (nv12) {
+            mtltexdesc.pixelFormat = MTLPixelFormatRG8Unorm;
+            mtltexdesc.width = (texture->w + 1) / 2;
+            mtltexdesc.height = (texture->h + 1) / 2;
+        }
+
+        if (yuv || nv12) {
+            if (surface) {
+                mtltextureUv = [data.mtldevice newTextureWithDescriptor:mtltexdesc iosurface:surface plane:1];
+            } else {
+                mtltextureUv = [data.mtldevice newTextureWithDescriptor:mtltexdesc];
+            }
+            if (mtltextureUv == nil) {
+                return SDL_SetError("Texture allocation failed");
+            }
+        }
+#endif // SDL_HAVE_YUV
+        texturedata = [[SDL3METAL_TextureData alloc] init];
+#ifdef SDL_HAVE_YUV
+        if (yuv) {
+            texturedata.fragmentFunction = SDL_METAL_FRAGMENT_YUV;
+        } else if (nv12) {
+            texturedata.fragmentFunction = SDL_METAL_FRAGMENT_NV12;
+        } else
+#endif
+        {
+            texturedata.fragmentFunction = SDL_METAL_FRAGMENT_COPY;
+        }
+        texturedata.mtltexture = mtltexture;
+        texturedata.mtltextureUv = mtltextureUv;
+#ifdef SDL_HAVE_YUV
+        texturedata.yuv = yuv;
+        texturedata.nv12 = nv12;
+        if (yuv || nv12) {
+            size_t offset = GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8);
+            if (offset == 0) {
+                return SDL_SetError("Unsupported YUV colorspace");
+            }
+            texturedata.conversionBufferOffset = offset;
+        }
+#endif
+        texture->internal = (void *)CFBridgingRetain(texturedata);
+
+        return true;
+    }
+}
+
+static void METAL_UploadTextureData(id<MTLTexture> texture, SDL_Rect rect, int slice,
+                                    const void *pixels, int pitch)
+{
+    [texture replaceRegion:MTLRegionMake2D(rect.x, rect.y, rect.w, rect.h)
+               mipmapLevel:0
+                     slice:slice
+                 withBytes:pixels
+               bytesPerRow:pitch
+             bytesPerImage:0];
+}
+
+static MTLStorageMode METAL_GetStorageMode(id<MTLResource> resource)
+{
+    return resource.storageMode;
+}
+
+static bool METAL_UpdateTextureInternal(SDL_Renderer *renderer, SDL3METAL_TextureData *texturedata,
+                                       id<MTLTexture> texture, SDL_Rect rect, int slice,
+                                       const void *pixels, int pitch)
+{
+    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+    SDL_Rect stagingrect = { 0, 0, rect.w, rect.h };
+    MTLTextureDescriptor *desc;
+    id<MTLTexture> stagingtex;
+    id<MTLBlitCommandEncoder> blitcmd;
+
+    /* If the texture is managed or shared and this is the first upload, we can
+     * use replaceRegion to upload to it directly. Otherwise we upload the data
+     * to a staging texture and copy that over. */
+    if (!texturedata.hasdata && METAL_GetStorageMode(texture) != MTLStorageModePrivate) {
+        METAL_UploadTextureData(texture, rect, slice, pixels, pitch);
+        return true;
+    }
+
+    desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:texture.pixelFormat
+                                                              width:rect.w
+                                                             height:rect.h
+                                                          mipmapped:NO];
+
+    if (desc == nil) {
+        return SDL_OutOfMemory();
+    }
+
+    /* TODO: We could have a pool of textures or a MTLHeap we allocate from,
+     * and release a staging texture back to the pool in the command buffer's
+     * completion handler. */
+    stagingtex = [data.mtldevice newTextureWithDescriptor:desc];
+    if (stagingtex == nil) {
+        return SDL_OutOfMemory();
+    }
+
+    METAL_UploadTextureData(stagingtex, stagingrect, 0, pixels, pitch);
+
+    if (data.mtlcmdencoder != nil) {
+        [data.mtlcmdencoder endEncoding];
+        data.mtlcmdencoder = nil;
+    }
+
+    if (data.mtlcmdbuffer == nil) {
+        data.mtlcmdbuffer = [data.mtlcmdqueue commandBuffer];
+    }
+
+    blitcmd = [data.mtlcmdbuffer blitCommandEncoder];
+
+    [blitcmd copyFromTexture:stagingtex
+                 sourceSlice:0
+                 sourceLevel:0
+                sourceOrigin:MTLOriginMake(0, 0, 0)
+                  sourceSize:MTLSizeMake(rect.w, rect.h, 1)
+                   toTexture:texture
+            destinationSlice:slice
+            destinationLevel:0
+           destinationOrigin:MTLOriginMake(rect.x, rect.y, 0)];
+
+    [blitcmd endEncoding];
+
+    /* TODO: This isn't very efficient for the YUV formats, which call
+     * UpdateTextureInternal multiple times in a row. */
+    [data.mtlcmdbuffer commit];
+    data.mtlcmdbuffer = nil;
+
+    return true;
+}
+
+static bool METAL_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                               const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    @autoreleasepool {
+        SDL3METAL_TextureData *texturedata = (__bridge SDL3METAL_TextureData *)texture->internal;
+
+        if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltexture, *rect, 0, pixels, pitch)) {
+            return false;
+        }
+#ifdef SDL_HAVE_YUV
+        if (texturedata.yuv) {
+            int Uslice = texture->format == SDL_PIXELFORMAT_YV12 ? 1 : 0;
+            int Vslice = texture->format == SDL_PIXELFORMAT_YV12 ? 0 : 1;
+            int UVpitch = (pitch + 1) / 2;
+            SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+            // Skip to the correct offset into the next texture
+            pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+            if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltextureUv, UVrect, Uslice, pixels, UVpitch)) {
+                return false;
+            }
+
+            // Skip to the correct offset into the next texture
+            pixels = (const void *)((const Uint8 *)pixels + UVrect.h * UVpitch);
+            if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltextureUv, UVrect, Vslice, pixels, UVpitch)) {
+                return false;
+            }
+        }
+
+        if (texturedata.nv12) {
+            SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+            int UVpitch = 2 * ((pitch + 1) / 2);
+
+            // Skip to the correct offset into the next texture
+            pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+            if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltextureUv, UVrect, 0, pixels, UVpitch)) {
+                return false;
+            }
+        }
+#endif
+        texturedata.hasdata = YES;
+
+        return true;
+    }
+}
+
+#ifdef SDL_HAVE_YUV
+static bool METAL_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch)
+{
+    @autoreleasepool {
+        SDL3METAL_TextureData *texturedata = (__bridge SDL3METAL_TextureData *)texture->internal;
+        const int Uslice = 0;
+        const int Vslice = 1;
+        SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+        // Bail out if we're supposed to update an empty rectangle
+        if (rect->w <= 0 || rect->h <= 0) {
+            return true;
+        }
+
+        if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltexture, *rect, 0, Yplane, Ypitch)) {
+            return false;
+        }
+        if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltextureUv, UVrect, Uslice, Uplane, Upitch)) {
+            return false;
+        }
+        if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltextureUv, UVrect, Vslice, Vplane, Vpitch)) {
+            return false;
+        }
+
+        texturedata.hasdata = YES;
+
+        return true;
+    }
+}
+
+static bool METAL_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                 const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch)
+{
+    @autoreleasepool {
+        SDL3METAL_TextureData *texturedata = (__bridge SDL3METAL_TextureData *)texture->internal;
+        SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+        // Bail out if we're supposed to update an empty rectangle
+        if (rect->w <= 0 || rect->h <= 0) {
+            return true;
+        }
+
+        if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltexture, *rect, 0, Yplane, Ypitch)) {
+            return false;
+        }
+
+        if (!METAL_UpdateTextureInternal(renderer, texturedata, texturedata.mtltextureUv, UVrect, 0, UVplane, UVpitch)) {
+            return false;
+        }
+
+        texturedata.hasdata = YES;
+
+        return true;
+    }
+}
+#endif
+
+static bool METAL_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        SDL3METAL_TextureData *texturedata = (__bridge SDL3METAL_TextureData *)texture->internal;
+        int buffersize = 0;
+        id<MTLBuffer> lockedbuffer = nil;
+
+        if (rect->w <= 0 || rect->h <= 0) {
+            return SDL_SetError("Invalid rectangle dimensions for LockTexture.");
+        }
+
+        *pitch = SDL_BYTESPERPIXEL(texture->format) * rect->w;
+#ifdef SDL_HAVE_YUV
+        if (texturedata.yuv || texturedata.nv12) {
+            buffersize = ((*pitch) * rect->h) + (2 * (*pitch + 1) / 2) * ((rect->h + 1) / 2);
+        } else
+#endif
+        {
+            buffersize = (*pitch) * rect->h;
+        }
+
+        lockedbuffer = [data.mtldevice newBufferWithLength:buffersize options:MTLResourceStorageModeShared];
+        if (lockedbuffer == nil) {
+            return SDL_OutOfMemory();
+        }
+
+        texturedata.lockedrect = *rect;
+        texturedata.lockedbuffer = lockedbuffer;
+        *pixels = [lockedbuffer contents];
+
+        return true;
+    }
+}
+
+static void METAL_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        SDL3METAL_TextureData *texturedata = (__bridge SDL3METAL_TextureData *)texture->internal;
+        id<MTLBlitCommandEncoder> blitcmd;
+        SDL_Rect rect = texturedata.lockedrect;
+        int pitch = SDL_BYTESPERPIXEL(texture->format) * rect.w;
+#ifdef SDL_HAVE_YUV
+        SDL_Rect UVrect = { rect.x / 2, rect.y / 2, (rect.w + 1) / 2, (rect.h + 1) / 2 };
+#endif
+
+        if (texturedata.lockedbuffer == nil) {
+            return;
+        }
+
+        if (data.mtlcmdencoder != nil) {
+            [data.mtlcmdencoder endEncoding];
+            data.mtlcmdencoder = nil;
+        }
+
+        if (data.mtlcmdbuffer == nil) {
+            data.mtlcmdbuffer = [data.mtlcmdqueue commandBuffer];
+        }
+
+        blitcmd = [data.mtlcmdbuffer blitCommandEncoder];
+
+        [blitcmd copyFromBuffer:texturedata.lockedbuffer
+                   sourceOffset:0
+              sourceBytesPerRow:pitch
+            sourceBytesPerImage:0
+                     sourceSize:MTLSizeMake(rect.w, rect.h, 1)
+                      toTexture:texturedata.mtltexture
+               destinationSlice:0
+               destinationLevel:0
+              destinationOrigin:MTLOriginMake(rect.x, rect.y, 0)];
+#ifdef SDL_HAVE_YUV
+        if (texturedata.yuv) {
+            int Uslice = texture->format == SDL_PIXELFORMAT_YV12 ? 1 : 0;
+            int Vslice = texture->format == SDL_PIXELFORMAT_YV12 ? 0 : 1;
+            int UVpitch = (pitch + 1) / 2;
+
+            [blitcmd copyFromBuffer:texturedata.lockedbuffer
+                       sourceOffset:rect.h * pitch
+                  sourceBytesPerRow:UVpitch
+                sourceBytesPerImage:UVpitch * UVrect.h
+                         sourceSize:MTLSizeMake(UVrect.w, UVrect.h, 1)
+                          toTexture:texturedata.mtltextureUv
+                   destinationSlice:Uslice
+                   destinationLevel:0
+                  destinationOrigin:MTLOriginMake(UVrect.x, UVrect.y, 0)];
+
+            [blitcmd copyFromBuffer:texturedata.lockedbuffer
+                       sourceOffset:(rect.h * pitch) + UVrect.h * UVpitch
+                  sourceBytesPerRow:UVpitch
+                sourceBytesPerImage:UVpitch * UVrect.h
+                         sourceSize:MTLSizeMake(UVrect.w, UVrect.h, 1)
+                          toTexture:texturedata.mtltextureUv
+                   destinationSlice:Vslice
+                   destinationLevel:0
+                  destinationOrigin:MTLOriginMake(UVrect.x, UVrect.y, 0)];
+        }
+
+        if (texturedata.nv12) {
+            int UVpitch = 2 * ((pitch + 1) / 2);
+
+            [blitcmd copyFromBuffer:texturedata.lockedbuffer
+                       sourceOffset:rect.h * pitch
+                  sourceBytesPerRow:UVpitch
+                sourceBytesPerImage:0
+                         sourceSize:MTLSizeMake(UVrect.w, UVrect.h, 1)
+                          toTexture:texturedata.mtltextureUv
+                   destinationSlice:0
+                   destinationLevel:0
+                  destinationOrigin:MTLOriginMake(UVrect.x, UVrect.y, 0)];
+        }
+#endif
+        [blitcmd endEncoding];
+
+        [data.mtlcmdbuffer commit];
+        data.mtlcmdbuffer = nil;
+
+        texturedata.lockedbuffer = nil; // Retained property, so it calls release.
+        texturedata.hasdata = YES;
+    }
+}
+
+static void METAL_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+}
+
+static bool METAL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+
+        if (data.mtlcmdencoder) {
+            /* End encoding for the previous render target so we can set up a new
+             * render pass for this one. */
+            [data.mtlcmdencoder endEncoding];
+            [data.mtlcmdbuffer commit];
+
+            data.mtlcmdencoder = nil;
+            data.mtlcmdbuffer = nil;
+        }
+
+        /* We don't begin a new render pass right away - we delay it until an actual
+         * draw or clear happens. That way we can use hardware clears when possible,
+         * which are only available when beginning a new render pass. */
+        return true;
+    }
+}
+
+static bool METAL_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    float projection[4][4]; // Prepare an orthographic projection
+    const int w = cmd->data.viewport.rect.w;
+    const int h = cmd->data.viewport.rect.h;
+    const size_t matrixlen = sizeof(projection);
+    float *matrix = (float *)SDL_AllocateRenderVertices(renderer, matrixlen, CONSTANT_ALIGN(16), &cmd->data.viewport.first);
+    if (!matrix) {
+        return false;
+    }
+
+    SDL_memset(projection, '\0', matrixlen);
+    if (w && h) {
+        projection[0][0] = 2.0f / w;
+        projection[1][1] = -2.0f / h;
+        projection[3][0] = -1.0f;
+        projection[3][1] = 1.0f;
+        projection[3][3] = 1.0f;
+    }
+    SDL_memcpy(matrix, projection, matrixlen);
+
+    return true;
+}
+
+static bool METAL_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool METAL_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    SDL_FColor color = cmd->data.draw.color;
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+
+    const size_t vertlen = (2 * sizeof(float) + 4 * sizeof(float)) * count;
+    float *verts = (float *)SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+    cmd->data.draw.count = count;
+
+    if (convert_color) {
+        SDL_ConvertToLinear(&color);
+    }
+
+    for (int i = 0; i < count; i++, points++) {
+        *(verts++) = points->x;
+        *(verts++) = points->y;
+        *(verts++) = color.r;
+        *(verts++) = color.g;
+        *(verts++) = color.b;
+        *(verts++) = color.a;
+    }
+    return true;
+}
+
+static bool METAL_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    SDL_FColor color = cmd->data.draw.color;
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+    size_t vertlen;
+    float *verts;
+
+    SDL_assert(count >= 2); // should have been checked at the higher level.
+
+    vertlen = (2 * sizeof(float) + 4 * sizeof(float)) * count;
+    verts = (float *)SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+    cmd->data.draw.count = count;
+
+    if (convert_color) {
+        SDL_ConvertToLinear(&color);
+    }
+
+    for (int i = 0; i < count; i++, points++) {
+        *(verts++) = points->x;
+        *(verts++) = points->y;
+        *(verts++) = color.r;
+        *(verts++) = color.g;
+        *(verts++) = color.b;
+        *(verts++) = color.a;
+    }
+
+    /* If the line segment is completely horizontal or vertical,
+       make it one pixel longer, to satisfy the diamond-exit rule.
+       We should probably do this for diagonal lines too, but we'd have to
+       do some trigonometry to figure out the correct pixel and generally
+       when we have problems with pixel perfection, it's for straight lines
+       that are missing a pixel that frames something and not arbitrary
+       angles. Maybe !!! FIXME for later, though. */
+
+    points -= 2; // update the last line.
+    verts -= 2 + 1;
+
+    {
+        const float xstart = points[0].x;
+        const float ystart = points[0].y;
+        const float xend = points[1].x;
+        const float yend = points[1].y;
+
+        if (ystart == yend) { // horizontal line
+            verts[0] += (xend > xstart) ? 1.0f : -1.0f;
+        } else if (xstart == xend) { // vertical line
+            verts[1] += (yend > ystart) ? 1.0f : -1.0f;
+        }
+    }
+
+    return true;
+}
+
+static bool METAL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                               const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                               int num_vertices, const void *indices, int num_indices, int size_indices,
+                               float scale_x, float scale_y)
+{
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+    int count = indices ? num_indices : num_vertices;
+    const size_t vertlen = (2 * sizeof(float) + 4 * sizeof(float) + (texture ? 2 : 0) * sizeof(float)) * count;
+    float *verts = (float *)SDL_AllocateRenderVertices(renderer, vertlen, DEVICE_ALIGN(8), &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (int i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        SDL_FColor col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+
+        if (convert_color) {
+            SDL_ConvertToLinear(&col_);
+        }
+
+        *(verts++) = col_.r;
+        *(verts++) = col_.g;
+        *(verts++) = col_.b;
+        *(verts++) = col_.a;
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            *(verts++) = uv_[0];
+            *(verts++) = uv_[1];
+        }
+    }
+
+    return true;
+}
+
+// These should mirror the definitions in SDL_shaders_metal.metal
+//static const float TONEMAP_NONE = 0;
+//static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+//static const float TEXTURETYPE_NONE = 0;
+static const float TEXTURETYPE_RGB = 1;
+static const float TEXTURETYPE_NV12 = 2;
+static const float TEXTURETYPE_NV21 = 3;
+static const float TEXTURETYPE_YUV = 4;
+
+//static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+typedef struct
+{
+    float scRGB_output;
+    float texture_type;
+    float input_type;
+    float color_scale;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+} PixelShaderConstants;
+
+typedef struct
+{
+    __unsafe_unretained id<MTLRenderPipelineState> pipeline;
+    __unsafe_unretained id<MTLBuffer> vertex_buffer;
+    size_t constants_offset;
+    SDL_Texture *texture;
+    bool cliprect_dirty;
+    bool cliprect_enabled;
+    SDL_Rect cliprect;
+    bool viewport_dirty;
+    SDL_Rect viewport;
+    size_t projection_offset;
+    bool shader_constants_dirty;
+    PixelShaderConstants shader_constants;
+} METAL_DrawStateCache;
+
+static void SetupShaderConstants(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Texture *texture, PixelShaderConstants *constants)
+{
+    float output_headroom;
+
+    SDL_zerop(constants);
+
+    constants->scRGB_output = (float)SDL_RenderingLinearSpace(renderer);
+    constants->color_scale = cmd->data.draw.color_scale;
+
+    if (texture) {
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_YV12:
+        case SDL_PIXELFORMAT_IYUV:
+            constants->texture_type = TEXTURETYPE_YUV;
+            break;
+        case SDL_PIXELFORMAT_NV12:
+            constants->texture_type = TEXTURETYPE_NV12;
+            break;
+        case SDL_PIXELFORMAT_NV21:
+            constants->texture_type = TEXTURETYPE_NV21;
+            break;
+        case SDL_PIXELFORMAT_P010:
+            constants->texture_type = TEXTURETYPE_NV12;
+            break;
+        default:
+            constants->texture_type = TEXTURETYPE_RGB;
+        }
+
+        switch (SDL_COLORSPACETRANSFER(texture->colorspace)) {
+        case SDL_TRANSFER_CHARACTERISTICS_LINEAR:
+            constants->input_type = INPUTTYPE_SCRGB;
+            break;
+        case SDL_TRANSFER_CHARACTERISTICS_PQ:
+            constants->input_type = INPUTTYPE_HDR10;
+            break;
+        default:
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        }
+
+        constants->sdr_white_point = texture->SDR_white_point;
+
+        if (renderer->target) {
+            output_headroom = renderer->target->HDR_headroom;
+        } else {
+            output_headroom = renderer->HDR_headroom;
+        }
+
+        if (texture->HDR_headroom > output_headroom) {
+            constants->tonemap_method = TONEMAP_CHROME;
+            constants->tonemap_factor1 = (output_headroom / (texture->HDR_headroom * texture->HDR_headroom));
+            constants->tonemap_factor2 = (1.0f / output_headroom);
+        }
+    }
+}
+
+static bool SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_MetalFragmentFunction shader, PixelShaderConstants *shader_constants, const size_t constants_offset, id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
+{
+    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+    size_t first = cmd->data.draw.first;
+    id<MTLRenderPipelineState> newpipeline;
+    PixelShaderConstants solid_constants;
+
+    if (!METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, statecache->vertex_buffer)) {
+        return false;
+    }
+
+    if (statecache->viewport_dirty) {
+        MTLViewport viewport;
+        viewport.originX = statecache->viewport.x;
+        viewport.originY = statecache->viewport.y;
+        viewport.width = statecache->viewport.w;
+        viewport.height = statecache->viewport.h;
+        viewport.znear = 0.0;
+        viewport.zfar = 1.0;
+        [data.mtlcmdencoder setViewport:viewport];
+        [data.mtlcmdencoder setVertexBuffer:mtlbufvertex offset:statecache->projection_offset atIndex:2]; // projection
+        statecache->viewport_dirty = false;
+    }
+
+    if (statecache->cliprect_dirty) {
+        SDL_Rect output;
+        SDL_Rect clip;
+        if (statecache->cliprect_enabled) {
+            clip = statecache->cliprect;
+            clip.x += statecache->viewport.x;
+            clip.y += statecache->viewport.y;
+        } else {
+            clip = statecache->viewport;
+        }
+
+        // Set Scissor Rect Validation: w/h must be <= render pass
+        SDL_zero(output);
+
+        if (renderer->target) {
+            output.w = renderer->target->w;
+            output.h = renderer->target->h;
+        } else {
+            METAL_GetOutputSize(renderer, &output.w, &output.h);
+        }
+
+        if (SDL_GetRectIntersection(&output, &clip, &clip)) {
+            MTLScissorRect mtlrect;
+            mtlrect.x = clip.x;
+            mtlrect.y = clip.y;
+            mtlrect.width = clip.w;
+            mtlrect.height = clip.h;
+            [data.mtlcmdencoder setScissorRect:mtlrect];
+        }
+
+        statecache->cliprect_dirty = false;
+    }
+
+    newpipeline = ChoosePipelineState(data, data.activepipelines, shader, blend);
+    if (newpipeline != statecache->pipeline) {
+        [data.mtlcmdencoder setRenderPipelineState:newpipeline];
+        statecache->pipeline = newpipeline;
+    }
+
+    if (!shader_constants) {
+        SetupShaderConstants(renderer, cmd, NULL, &solid_constants);
+        shader_constants = &solid_constants;
+    }
+
+    if (statecache->shader_constants_dirty ||
+        SDL_memcmp(shader_constants, &statecache->shader_constants, sizeof(*shader_constants)) != 0) {
+        id<MTLBuffer> mtlbufconstants = [data.mtldevice newBufferWithLength:sizeof(*shader_constants) options:MTLResourceStorageModeShared];
+        mtlbufconstants.label = @"SDL shader constants data";
+        SDL_memcpy([mtlbufconstants contents], shader_constants, sizeof(*shader_constants));
+        [data.mtlcmdencoder setFragmentBuffer:mtlbufconstants offset:0 atIndex:0];
+
+        SDL_memcpy(&statecache->shader_constants, shader_constants, sizeof(*shader_constants));
+        statecache->shader_constants_dirty = false;
+    }
+
+    if (constants_offset != statecache->constants_offset) {
+        if (constants_offset != CONSTANTS_OFFSET_INVALID) {
+            [data.mtlcmdencoder setVertexBuffer:data.mtlbufconstants offset:constants_offset atIndex:3];
+        }
+        statecache->constants_offset = constants_offset;
+    }
+
+    [data.mtlcmdencoder setVertexBufferOffset:first atIndex:0]; // position/texcoords
+    return true;
+}
+
+static bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const size_t constants_offset,
+                             id<MTLBuffer> mtlbufvertex, METAL_DrawStateCache *statecache)
+{
+    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+    SDL_Texture *texture = cmd->data.draw.texture;
+    SDL3METAL_TextureData *texturedata = (__bridge SDL3METAL_TextureData *)texture->internal;
+    PixelShaderConstants constants;
+
+    SetupShaderConstants(renderer, cmd, texture, &constants);
+
+    if (!SetDrawState(renderer, cmd, texturedata.fragmentFunction, &constants, constants_offset, mtlbufvertex, statecache)) {
+        return false;
+    }
+
+    if (texture != statecache->texture) {
+        id<MTLSamplerState> mtlsampler;
+
+        if (texture->scaleMode == SDL_SCALEMODE_NEAREST) {
+            switch (cmd->data.draw.texture_address_mode) {
+            case SDL_TEXTURE_ADDRESS_CLAMP:
+                mtlsampler = data.mtlsamplers[SDL_METAL_SAMPLER_NEAREST_CLAMP];
+                break;
+            case SDL_TEXTURE_ADDRESS_WRAP:
+                mtlsampler = data.mtlsamplers[SDL_METAL_SAMPLER_NEAREST_WRAP];
+                break;
+            default:
+                return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+            }
+        } else {
+            switch (cmd->data.draw.texture_address_mode) {
+            case SDL_TEXTURE_ADDRESS_CLAMP:
+                mtlsampler = data.mtlsamplers[SDL_METAL_SAMPLER_LINEAR_CLAMP];
+                break;
+            case SDL_TEXTURE_ADDRESS_WRAP:
+                mtlsampler = data.mtlsamplers[SDL_METAL_SAMPLER_LINEAR_WRAP];
+                break;
+            default:
+                return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+            }
+        }
+        [data.mtlcmdencoder setFragmentSamplerState:mtlsampler atIndex:0];
+
+        [data.mtlcmdencoder setFragmentTexture:texturedata.mtltexture atIndex:0];
+#ifdef SDL_HAVE_YUV
+        if (texturedata.yuv || texturedata.nv12) {
+            [data.mtlcmdencoder setFragmentTexture:texturedata.mtltextureUv atIndex:1];
+            [data.mtlcmdencoder setFragmentBuffer:data.mtlbufconstants offset:texturedata.conversionBufferOffset atIndex:1];
+        }
+#endif
+        statecache->texture = texture;
+    }
+    return true;
+}
+
+static void METAL_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    // METAL_DrawStateCache only exists during a run of METAL_RunCommandQueue, so there's nothing to invalidate!
+}
+
+static bool METAL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        id<MTLBuffer> mtlbufvertex = nil;
+        METAL_DrawStateCache statecache;
+        SDL_zero(statecache);
+
+        statecache.pipeline = nil;
+        statecache.vertex_buffer = nil;
+        statecache.constants_offset = CONSTANTS_OFFSET_INVALID;
+        statecache.texture = NULL;
+        statecache.shader_constants_dirty = true;
+        statecache.cliprect_dirty = true;
+        statecache.viewport_dirty = true;
+        statecache.projection_offset = 0;
+
+        // !!! FIXME: have a ring of pre-made MTLBuffers we cycle through? How expensive is creation?
+        if (vertsize > 0) {
+            /* We can memcpy to a shared buffer from the CPU and read it from the GPU
+             * without any extra copying. It's a bit slower on macOS to read shared
+             * data from the GPU than to read managed/private data, but we avoid the
+             * cost of copying the data and the code's simpler. Apple's best
+             * practices guide recommends this approach for streamed vertex data.
+             */
+            mtlbufvertex = [data.mtldevice newBufferWithLength:vertsize options:MTLResourceStorageModeShared];
+            mtlbufvertex.label = @"SDL vertex data";
+            SDL_memcpy([mtlbufvertex contents], vertices, vertsize);
+
+            statecache.vertex_buffer = mtlbufvertex;
+        }
+
+        // If there's a command buffer here unexpectedly (app requested one?). Commit it so we can start fresh.
+        [data.mtlcmdencoder endEncoding];
+        [data.mtlcmdbuffer commit];
+        data.mtlcmdencoder = nil;
+        data.mtlcmdbuffer = nil;
+
+        while (cmd) {
+            switch (cmd->command) {
+            case SDL_RENDERCMD_SETVIEWPORT:
+            {
+                SDL_memcpy(&statecache.viewport, &cmd->data.viewport.rect, sizeof(statecache.viewport));
+                statecache.projection_offset = cmd->data.viewport.first;
+                statecache.viewport_dirty = true;
+                statecache.cliprect_dirty = true;
+                break;
+            }
+
+            case SDL_RENDERCMD_SETCLIPRECT:
+            {
+                SDL_memcpy(&statecache.cliprect, &cmd->data.cliprect.rect, sizeof(statecache.cliprect));
+                statecache.cliprect_enabled = cmd->data.cliprect.enabled;
+                statecache.cliprect_dirty = true;
+                break;
+            }
+
+            case SDL_RENDERCMD_SETDRAWCOLOR:
+            {
+                break;
+            }
+
+            case SDL_RENDERCMD_CLEAR:
+            {
+                /* If we're already encoding a command buffer, dump it without committing it. We'd just
+                    clear all its work anyhow, and starting a new encoder will let us use a hardware clear
+                    operation via MTLLoadActionClear. */
+                if (data.mtlcmdencoder != nil) {
+                    [data.mtlcmdencoder endEncoding];
+
+                    // !!! FIXME: have to commit, or an uncommitted but enqueued buffer will prevent the frame from finishing.
+                    [data.mtlcmdbuffer commit];
+                    data.mtlcmdencoder = nil;
+                    data.mtlcmdbuffer = nil;
+                }
+
+                // force all this state to be reconfigured on next command buffer.
+                statecache.pipeline = nil;
+                statecache.constants_offset = CONSTANTS_OFFSET_INVALID;
+                statecache.texture = NULL;
+                statecache.shader_constants_dirty = true;
+                statecache.cliprect_dirty = true;
+                statecache.viewport_dirty = true;
+
+                {
+                    bool convert_color = SDL_RenderingLinearSpace(renderer);
+                    SDL_FColor color = cmd->data.color.color;
+                    if (convert_color) {
+                        SDL_ConvertToLinear(&color);
+                    }
+                    color.r *= cmd->data.color.color_scale;
+                    color.g *= cmd->data.color.color_scale;
+                    color.b *= cmd->data.color.color_scale;
+                    MTLClearColor mtlcolor = MTLClearColorMake(color.r, color.g, color.b, color.a);
+
+                    // get new command encoder, set up with an initial clear operation.
+                    // (this might fail, and future draw operations will notice.)
+                    METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionClear, &mtlcolor, mtlbufvertex);
+                }
+                break;
+            }
+
+            case SDL_RENDERCMD_DRAW_POINTS:
+            case SDL_RENDERCMD_DRAW_LINES:
+            {
+                const size_t count = cmd->data.draw.count;
+                const MTLPrimitiveType primtype = (cmd->command == SDL_RENDERCMD_DRAW_POINTS) ? MTLPrimitiveTypePoint : MTLPrimitiveTypeLineStrip;
+                if (SetDrawState(renderer, cmd, SDL_METAL_FRAGMENT_SOLID, NULL, CONSTANTS_OFFSET_HALF_PIXEL_TRANSFORM, mtlbufvertex, &statecache)) {
+                    [data.mtlcmdencoder drawPrimitives:primtype vertexStart:0 vertexCount:count];
+                }
+                break;
+            }
+
+            case SDL_RENDERCMD_FILL_RECTS: // unused
+                break;
+
+            case SDL_RENDERCMD_COPY: // unused
+                break;
+
+            case SDL_RENDERCMD_COPY_EX: // unused
+                break;
+
+            case SDL_RENDERCMD_GEOMETRY:
+            {
+                const size_t count = cmd->data.draw.count;
+                SDL_Texture *texture = cmd->data.draw.texture;
+
+                if (texture) {
+                    if (SetCopyState(renderer, cmd, CONSTANTS_OFFSET_IDENTITY, mtlbufvertex, &statecache)) {
+                        [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:count];
+                    }
+                } else {
+                    if (SetDrawState(renderer, cmd, SDL_METAL_FRAGMENT_SOLID, NULL, CONSTANTS_OFFSET_IDENTITY, mtlbufvertex, &statecache)) {
+                        [data.mtlcmdencoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:count];
+                    }
+                }
+                break;
+            }
+
+            case SDL_RENDERCMD_NO_OP:
+                break;
+            }
+            cmd = cmd->next;
+        }
+
+        return true;
+    }
+}
+
+static SDL_Surface *METAL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        id<MTLTexture> mtltexture;
+        MTLRegion mtlregion;
+        Uint32 format;
+        SDL_Surface *surface;
+
+        if (!METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil)) {
+            SDL_SetError("Failed to activate render command encoder (is your window in the background?");
+            return NULL;
+        }
+
+        [data.mtlcmdencoder endEncoding];
+        mtltexture = data.mtlpassdesc.colorAttachments[0].texture;
+
+#ifdef SDL_PLATFORM_MACOS
+        /* on macOS with managed-storage textures, we need to tell the driver to
+         * update the CPU-side copy of the texture data.
+         * NOTE: Currently all of our textures are managed on macOS. We'll need some
+         * extra copying for any private textures. */
+        if (METAL_GetStorageMode(mtltexture) == MTLStorageModeManaged) {
+            id<MTLBlitCommandEncoder> blit = [data.mtlcmdbuffer blitCommandEncoder];
+            [blit synchronizeResource:mtltexture];
+            [blit endEncoding];
+        }
+#endif
+
+        /* Commit the current command buffer and wait until it's completed, to make
+         * sure the GPU has finished rendering to it by the time we read it. */
+        [data.mtlcmdbuffer commit];
+        [data.mtlcmdbuffer waitUntilCompleted];
+        data.mtlcmdencoder = nil;
+        data.mtlcmdbuffer = nil;
+
+        mtlregion = MTLRegionMake2D(rect->x, rect->y, rect->w, rect->h);
+
+        switch (mtltexture.pixelFormat) {
+        case MTLPixelFormatBGRA8Unorm:
+        case MTLPixelFormatBGRA8Unorm_sRGB:
+            format = SDL_PIXELFORMAT_ARGB8888;
+            break;
+        case MTLPixelFormatRGBA8Unorm:
+        case MTLPixelFormatRGBA8Unorm_sRGB:
+            format = SDL_PIXELFORMAT_ABGR8888;
+            break;
+        case MTLPixelFormatRGB10A2Unorm:
+            format = SDL_PIXELFORMAT_ABGR2101010;
+            break;
+        case MTLPixelFormatRGBA16Float:
+            format = SDL_PIXELFORMAT_RGBA64_FLOAT;
+            break;
+        default:
+            SDL_SetError("Unknown framebuffer pixel format");
+            return NULL;
+        }
+        surface = SDL_CreateSurface(rect->w, rect->h, format);
+        if (surface) {
+            [mtltexture getBytes:surface->pixels bytesPerRow:surface->pitch fromRegion:mtlregion mipmapLevel:0];
+        }
+        return surface;
+    }
+}
+
+static bool METAL_RenderPresent(SDL_Renderer *renderer)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        bool ready = true;
+
+        // If we don't have a command buffer, we can't present, so activate to get one.
+        if (data.mtlcmdencoder == nil) {
+            // We haven't even gotten a backbuffer yet? Load and clear it. Otherwise, load the existing data.
+            if (data.mtlbackbuffer == nil) {
+                float alpha = (SDL_GetWindowFlags(renderer->window) & SDL_WINDOW_TRANSPARENT) ? 0.0f : 1.0f;
+                MTLClearColor color = MTLClearColorMake(0.0f, 0.0f, 0.0f, alpha);
+                ready = METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionClear, &color, nil);
+            } else {
+                ready = METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
+            }
+        }
+
+        [data.mtlcmdencoder endEncoding];
+
+        // If we don't have a drawable to present, don't try to present it.
+        //  But we'll still try to commit the command buffer in case it was already enqueued.
+        if (ready) {
+            SDL_assert(data.mtlbackbuffer != nil);
+            [data.mtlcmdbuffer presentDrawable:data.mtlbackbuffer];
+        }
+
+        [data.mtlcmdbuffer commit];
+
+        data.mtlcmdencoder = nil;
+        data.mtlcmdbuffer = nil;
+        data.mtlbackbuffer = nil;
+
+        if (renderer->hidden || !ready) {
+            return false;
+        }
+        return true;
+    }
+}
+
+static void METAL_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    @autoreleasepool {
+        CFBridgingRelease(texture->internal);
+        texture->internal = NULL;
+    }
+}
+
+static void METAL_DestroyRenderer(SDL_Renderer *renderer)
+{
+    @autoreleasepool {
+        if (renderer->internal) {
+            SDL3METAL_RenderData *data = CFBridgingRelease(renderer->internal);
+
+            if (data.mtlcmdencoder != nil) {
+                [data.mtlcmdencoder endEncoding];
+            }
+
+            DestroyAllPipelines(data.allpipelines, data.pipelinescount);
+
+            /* Release the metal view instead of destroying it,
+               in case we want to use it later (recreating the renderer)
+             */
+            // SDL_Metal_DestroyView(data.mtlview);
+            CFBridgingRelease(data.mtlview);
+        }
+    }
+}
+
+static void *METAL_GetMetalLayer(SDL_Renderer *renderer)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        return (__bridge void *)data.mtllayer;
+    }
+}
+
+static void *METAL_GetMetalCommandEncoder(SDL_Renderer *renderer)
+{
+    @autoreleasepool {
+        // note that data.mtlcmdencoder can be nil if METAL_ActivateRenderCommandEncoder fails.
+        //  Before SDL 2.0.18, it might have returned a non-nil encoding that might not have been
+        //  usable for presentation. Check your return values!
+        SDL3METAL_RenderData *data;
+        METAL_ActivateRenderCommandEncoder(renderer, MTLLoadActionLoad, NULL, nil);
+        data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+        return (__bridge void *)data.mtlcmdencoder;
+    }
+}
+
+static bool METAL_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+#if defined(SDL_PLATFORM_MACOS) || TARGET_OS_MACCATALYST
+    SDL3METAL_RenderData *data = (__bridge SDL3METAL_RenderData *)renderer->internal;
+    switch (vsync) {
+    case 0:
+        data.mtllayer.displaySyncEnabled = NO;
+        break;
+    case 1:
+        data.mtllayer.displaySyncEnabled = YES;
+        break;
+    default:
+        return SDL_Unsupported();
+    }
+    return true;
+#else
+    switch (vsync) {
+    case 1:
+        return true;
+    default:
+        return SDL_Unsupported();
+    }
+#endif
+}
+
+static SDL_MetalView GetWindowView(SDL_Window *window)
+{
+#ifdef SDL_VIDEO_DRIVER_COCOA
+    NSWindow *nswindow = (__bridge NSWindow *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, NULL);
+    NSInteger tag = (NSInteger)SDL_GetNumberProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER, 0);
+    if (nswindow && tag) {
+        NSView *view = nswindow.contentView;
+        if (view.subviews.count > 0) {
+            view = view.subviews[0];
+            if (view.tag == tag) {
+                return (SDL_MetalView)CFBridgingRetain(view);
+            }
+        }
+    }
+#endif
+
+#ifdef SDL_VIDEO_DRIVER_UIKIT
+    UIWindow *uiwindow = (__bridge UIWindow *)SDL_GetPointerProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER, NULL);
+    NSInteger tag = (NSInteger)SDL_GetNumberProperty(SDL_GetWindowProperties(window), SDL_PROP_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER, 0);
+    if (uiwindow && tag) {
+        UIView *view = uiwindow.rootViewController.view;
+        if (view.tag == tag) {
+            return (SDL_MetalView)CFBridgingRetain(view);
+        }
+    }
+#endif
+
+    return nil;
+}
+
+static bool METAL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    @autoreleasepool {
+        SDL3METAL_RenderData *data = NULL;
+        id<MTLDevice> mtldevice = nil;
+        SDL_MetalView view = NULL;
+        CAMetalLayer *layer = nil;
+        NSError *err = nil;
+        dispatch_data_t mtllibdata;
+        char *constantdata;
+        int maxtexsize, quadcount = UINT16_MAX / 4;
+        UInt16 *indexdata;
+        size_t indicessize = sizeof(UInt16) * quadcount * 6;
+        MTLSamplerDescriptor *samplerdesc;
+        id<MTLCommandQueue> mtlcmdqueue;
+        id<MTLLibrary> mtllibrary;
+        id<MTLBuffer> mtlbufconstantstaging, mtlbufquadindicesstaging, mtlbufconstants, mtlbufquadindices;
+        id<MTLCommandBuffer> cmdbuffer;
+        id<MTLBlitCommandEncoder> blitcmd;
+        bool scRGB_supported = false;
+
+        // Note: matrices are column major.
+        float identitytransform[16] = {
+            1.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            1.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            1.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            1.0f,
+        };
+
+        float halfpixeltransform[16] = {
+            1.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            1.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            0.0f,
+            1.0f,
+            0.0f,
+            0.5f,
+            0.5f,
+            0.0f,
+            1.0f,
+        };
+
+        const size_t YCbCr_shader_matrix_size = 4 * 4 * sizeof(float);
+
+        SDL_SetupRendererColorspace(renderer, create_props);
+
+#ifndef SDL_PLATFORM_TVOS
+        if (@available(macos 10.11, iOS 16.0, *)) {
+            scRGB_supported = true;
+        }
+#endif
+        if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+            if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR && scRGB_supported) {
+                // This colorspace is supported
+            } else {
+                return SDL_SetError("Unsupported output colorspace");
+            }
+        }
+
+#ifdef SDL_PLATFORM_MACOS
+        if (SDL_GetHintBoolean(SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE, true)) {
+            NSArray<id<MTLDevice>> *devices = MTLCopyAllDevices();
+
+            for (id<MTLDevice> device in devices) {
+                if (device.isLowPower) {
+                    mtldevice = device;
+                    break;
+                }
+            }
+        }
+#endif
+
+        if (mtldevice == nil) {
+            mtldevice = MTLCreateSystemDefaultDevice();
+        }
+
+        if (mtldevice == nil) {
+            return SDL_SetError("Failed to obtain Metal device");
+        }
+
+        view = GetWindowView(window);
+        if (view == nil) {
+            view = SDL_Metal_CreateView(window);
+        }
+
+        if (view == NULL) {
+            return false;
+        }
+
+        // !!! FIXME: error checking on all of this.
+        data = [[SDL3METAL_RenderData alloc] init];
+
+        if (data == nil) {
+            /* Release the metal view instead of destroying it,
+               in case we want to use it later (recreating the renderer)
+             */
+            // SDL_Metal_DestroyView(view);
+            CFBridgingRelease(view);
+            return SDL_SetError("SDL3METAL_RenderData alloc/init failed");
+        }
+
+        renderer->internal = (void *)CFBridgingRetain(data);
+        METAL_InvalidateCachedState(renderer);
+        renderer->window = window;
+
+        data.mtlview = view;
+
+#ifdef SDL_PLATFORM_MACOS
+        layer = (CAMetalLayer *)[(__bridge NSView *)view layer];
+#else
+        layer = (CAMetalLayer *)[(__bridge UIView *)view layer];
+#endif
+
+#ifndef SDL_PLATFORM_TVOS
+        if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            if (@available(macos 10.11, iOS 16.0, *)) {
+                layer.wantsExtendedDynamicRangeContent = YES;
+            } else {
+                SDL_assert(!"Logic error, scRGB is not actually supported");
+            }
+            layer.pixelFormat = MTLPixelFormatRGBA16Float;
+
+            const CFStringRef name = kCGColorSpaceExtendedLinearSRGB;
+            CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(name);
+            layer.colorspace = colorspace;
+            CGColorSpaceRelease(colorspace);
+        }
+#endif // !SDL_PLATFORM_TVOS
+
+        layer.device = mtldevice;
+
+        // Necessary for RenderReadPixels.
+        layer.framebufferOnly = NO;
+
+        data.mtldevice = layer.device;
+        data.mtllayer = layer;
+        mtlcmdqueue = [data.mtldevice newCommandQueue];
+        data.mtlcmdqueue = mtlcmdqueue;
+        data.mtlcmdqueue.label = @"SDL Metal Renderer";
+        data.mtlpassdesc = [MTLRenderPassDescriptor renderPassDescriptor];
+
+        // The compiled .metallib is embedded in a static array in a header file
+        // but the original shader source code is in SDL_shaders_metal.metal.
+        mtllibdata = dispatch_data_create(sdl_metallib, sdl_metallib_len, dispatch_get_global_queue(0, 0), ^{
+                                                                          });
+        mtllibrary = [data.mtldevice newLibraryWithData:mtllibdata error:&err];
+        data.mtllibrary = mtllibrary;
+        SDL_assert(err == nil);
+        data.mtllibrary.label = @"SDL Metal renderer shader library";
+
+        // Do some shader pipeline state loading up-front rather than on demand.
+        data.pipelinescount = 0;
+        data.allpipelines = NULL;
+        ChooseShaderPipelines(data, MTLPixelFormatBGRA8Unorm);
+
+        static struct
+        {
+            MTLSamplerMinMagFilter filter;
+            MTLSamplerAddressMode address;
+        } samplerParams[] = {
+            { MTLSamplerMinMagFilterNearest, MTLSamplerAddressModeClampToEdge },
+            { MTLSamplerMinMagFilterNearest, MTLSamplerAddressModeRepeat },
+            { MTLSamplerMinMagFilterLinear, MTLSamplerAddressModeClampToEdge },
+            { MTLSamplerMinMagFilterLinear, MTLSamplerAddressModeRepeat },
+        };
+        SDL_COMPILE_TIME_ASSERT(samplerParams_SIZE, SDL_arraysize(samplerParams) == SDL_NUM_METAL_SAMPLERS);
+
+        data.mtlsamplers = [[NSMutableArray<id<MTLSamplerState>> alloc] init];
+        samplerdesc = [[MTLSamplerDescriptor alloc] init];
+        for (int i = 0; i < SDL_arraysize(samplerParams); ++i) {
+            samplerdesc.minFilter = samplerParams[i].filter;
+            samplerdesc.magFilter = samplerParams[i].filter;
+            samplerdesc.sAddressMode = samplerParams[i].address;
+            samplerdesc.tAddressMode = samplerParams[i].address;
+            [data.mtlsamplers addObject:[data.mtldevice newSamplerStateWithDescriptor:samplerdesc]];
+        }
+
+        mtlbufconstantstaging = [data.mtldevice newBufferWithLength:CONSTANTS_LENGTH options:MTLResourceStorageModeShared];
+
+        constantdata = [mtlbufconstantstaging contents];
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_IDENTITY, identitytransform, sizeof(identitytransform));
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_HALF_PIXEL_TRANSFORM, halfpixeltransform, sizeof(halfpixeltransform));
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_DECODE_BT601_LIMITED, SDL_GetYCbCRtoRGBConversionMatrix(SDL_COLORSPACE_BT601_LIMITED, 0, 0, 8), YCbCr_shader_matrix_size);
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_DECODE_BT601_FULL, SDL_GetYCbCRtoRGBConversionMatrix(SDL_COLORSPACE_BT601_FULL, 0, 0, 8), YCbCr_shader_matrix_size);
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_DECODE_BT709_LIMITED, SDL_GetYCbCRtoRGBConversionMatrix(SDL_COLORSPACE_BT709_LIMITED, 0, 0, 8), YCbCr_shader_matrix_size);
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_DECODE_BT709_FULL, SDL_GetYCbCRtoRGBConversionMatrix(SDL_COLORSPACE_BT709_FULL, 0, 0, 8), YCbCr_shader_matrix_size);
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_DECODE_BT2020_LIMITED, SDL_GetYCbCRtoRGBConversionMatrix(SDL_COLORSPACE_BT2020_LIMITED, 0, 0, 10), YCbCr_shader_matrix_size);
+        SDL_memcpy(constantdata + CONSTANTS_OFFSET_DECODE_BT2020_FULL, SDL_GetYCbCRtoRGBConversionMatrix(SDL_COLORSPACE_BT2020_FULL, 0, 0, 10), YCbCr_shader_matrix_size);
+
+        mtlbufquadindicesstaging = [data.mtldevice newBufferWithLength:indicessize options:MTLResourceStorageModeShared];
+
+        /* Quads in the following vertex order (matches the FillRects vertices):
+         * 1---3
+         * | \ |
+         * 0---2
+         */
+        indexdata = [mtlbufquadindicesstaging contents];
+        for (int i = 0; i < quadcount; i++) {
+            indexdata[i * 6 + 0] = i * 4 + 0;
+            indexdata[i * 6 + 1] = i * 4 + 1;
+            indexdata[i * 6 + 2] = i * 4 + 2;
+
+            indexdata[i * 6 + 3] = i * 4 + 2;
+            indexdata[i * 6 + 4] = i * 4 + 1;
+            indexdata[i * 6 + 5] = i * 4 + 3;
+        }
+
+        mtlbufconstants = [data.mtldevice newBufferWithLength:CONSTANTS_LENGTH options:MTLResourceStorageModePrivate];
+        data.mtlbufconstants = mtlbufconstants;
+        data.mtlbufconstants.label = @"SDL constant data";
+
+        mtlbufquadindices = [data.mtldevice newBufferWithLength:indicessize options:MTLResourceStorageModePrivate];
+        data.mtlbufquadindices = mtlbufquadindices;
+        data.mtlbufquadindices.label = @"SDL quad index buffer";
+
+        cmdbuffer = [data.mtlcmdqueue commandBuffer];
+        blitcmd = [cmdbuffer blitCommandEncoder];
+
+        [blitcmd copyFromBuffer:mtlbufconstantstaging sourceOffset:0 toBuffer:mtlbufconstants destinationOffset:0 size:CONSTANTS_LENGTH];
+        [blitcmd copyFromBuffer:mtlbufquadindicesstaging sourceOffset:0 toBuffer:mtlbufquadindices destinationOffset:0 size:indicessize];
+
+        [blitcmd endEncoding];
+        [cmdbuffer commit];
+
+        // !!! FIXME: force more clears here so all the drawables are sane to start, and our static buffers are definitely flushed.
+
+        renderer->WindowEvent = METAL_WindowEvent;
+        renderer->GetOutputSize = METAL_GetOutputSize;
+        renderer->SupportsBlendMode = METAL_SupportsBlendMode;
+        renderer->CreateTexture = METAL_CreateTexture;
+        renderer->UpdateTexture = METAL_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+        renderer->UpdateTextureYUV = METAL_UpdateTextureYUV;
+        renderer->UpdateTextureNV = METAL_UpdateTextureNV;
+#endif
+        renderer->LockTexture = METAL_LockTexture;
+        renderer->UnlockTexture = METAL_UnlockTexture;
+        renderer->SetTextureScaleMode = METAL_SetTextureScaleMode;
+        renderer->SetRenderTarget = METAL_SetRenderTarget;
+        renderer->QueueSetViewport = METAL_QueueSetViewport;
+        renderer->QueueSetDrawColor = METAL_QueueNoOp;
+        renderer->QueueDrawPoints = METAL_QueueDrawPoints;
+        renderer->QueueDrawLines = METAL_QueueDrawLines;
+        renderer->QueueGeometry = METAL_QueueGeometry;
+        renderer->InvalidateCachedState = METAL_InvalidateCachedState;
+        renderer->RunCommandQueue = METAL_RunCommandQueue;
+        renderer->RenderReadPixels = METAL_RenderReadPixels;
+        renderer->RenderPresent = METAL_RenderPresent;
+        renderer->DestroyTexture = METAL_DestroyTexture;
+        renderer->DestroyRenderer = METAL_DestroyRenderer;
+        renderer->SetVSync = METAL_SetVSync;
+        renderer->GetMetalLayer = METAL_GetMetalLayer;
+        renderer->GetMetalCommandEncoder = METAL_GetMetalCommandEncoder;
+
+        renderer->name = METAL_RenderDriver.name;
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR2101010);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA64_FLOAT);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA128_FLOAT);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_P010);
+
+#if defined(SDL_PLATFORM_MACOS) || TARGET_OS_MACCATALYST
+        data.mtllayer.displaySyncEnabled = NO;
+#endif
+
+        // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
+        maxtexsize = 4096;
+#if defined(SDL_PLATFORM_MACOS) || TARGET_OS_MACCATALYST
+        maxtexsize = 16384;
+#elif defined(SDL_PLATFORM_TVOS)
+        maxtexsize = 8192;
+        if ([mtldevice supportsFeatureSet:MTLFeatureSet_tvOS_GPUFamily2_v1]) {
+            maxtexsize = 16384;
+        }
+#else
+        if ([mtldevice supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily4_v1]) {
+            maxtexsize = 16384;
+        } else if ([mtldevice supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily3_v1]) {
+            maxtexsize = 16384;
+        } else if ([mtldevice supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily2_v2] || [mtldevice supportsFeatureSet:MTLFeatureSet_iOS_GPUFamily1_v2]) {
+            maxtexsize = 8192;
+        } else {
+            maxtexsize = 4096;
+        }
+#endif
+
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, maxtexsize);
+
+        return true;
+    }
+}
+
+SDL_RenderDriver METAL_RenderDriver = {
+    METAL_CreateRenderer, "metal"
+};
+
+#endif // SDL_VIDEO_RENDER_METAL
diff --git a/SDL-3.2.8/src/render/metal/SDL_shaders_metal.metal b/SDL-3.2.8/src/render/metal/SDL_shaders_metal.metal
new file mode 100644
index 0000000..c266670
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_shaders_metal.metal
@@ -0,0 +1,299 @@
+#include <metal_common>
+#include <metal_texture>
+#include <metal_matrix>
+
+using namespace metal;
+
+// These should mirror the definitions in SDL_render_metal.m
+#define TONEMAP_NONE            0
+#define TONEMAP_LINEAR          1
+#define TONEMAP_CHROME          2
+
+#define TEXTURETYPE_NONE        0
+#define TEXTURETYPE_RGB         1
+#define TEXTURETYPE_NV12        2
+#define TEXTURETYPE_NV21        3
+#define TEXTURETYPE_YUV         4
+
+#define INPUTTYPE_UNSPECIFIED   0
+#define INPUTTYPE_SRGB          1
+#define INPUTTYPE_SCRGB         2
+#define INPUTTYPE_HDR10         3
+
+struct ShaderConstants
+{
+    float scRGB_output;
+    float texture_type;
+    float input_type;
+    float color_scale;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+};
+
+struct YUVDecode
+{
+    float3 offset;
+    float3x3 matrix;
+};
+
+float sRGBtoLinear(float v)
+{
+    if (v <= 0.04045) {
+        v = (v / 12.92);
+    } else {
+        v = pow(abs(v + 0.055) / 1.055, 2.4);
+    }
+    return v;
+}
+
+float sRGBfromLinear(float v)
+{
+    if (v <= 0.0031308) {
+        v = (v * 12.92);
+    } else {
+        v = (pow(abs(v), 1.0 / 2.4) * 1.055 - 0.055);
+    }
+    return v;
+}
+
+float3 PQtoLinear(float3 v, float sdr_white_point)
+{
+    const float c1 = 0.8359375;
+    const float c2 = 18.8515625;
+    const float c3 = 18.6875;
+    const float oo_m1 = 1.0 / 0.1593017578125;
+    const float oo_m2 = 1.0 / 78.84375;
+
+    float3 num = max(pow(abs(v), oo_m2) - c1, 0.0);
+    float3 den = c2 - c3 * pow(abs(v), oo_m2);
+    return (10000.0 * pow(abs(num / den), oo_m1) / sdr_white_point);
+}
+
+float3 ApplyTonemap(float3 v, float input_type, float tonemap_method, float tonemap_factor1, float tonemap_factor2)
+{
+    const float3x3 mat709to2020 = {
+        { 0.627404, 0.329283, 0.043313 },
+        { 0.069097, 0.919541, 0.011362 },
+        { 0.016391, 0.088013, 0.895595 }
+    };
+    const float3x3 mat2020to709 = {
+        { 1.660496, -0.587656, -0.072840 },
+        { -0.124547, 1.132895, -0.008348 },
+        { -0.018154, -0.100597, 1.118751 }
+    };
+
+    if (tonemap_method == TONEMAP_LINEAR) {
+        v *= tonemap_factor1;
+    } else if (tonemap_method == TONEMAP_CHROME) {
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.2020 colorspace for tone mapping
+            v = v * mat709to2020;
+        }
+
+        float vmax = max(v.r, max(v.g, v.b));
+        if (vmax > 0.0) {
+            float scale = (1.0 + tonemap_factor1 * vmax) / (1.0 + tonemap_factor2 * vmax);
+            v *= scale;
+        }
+
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.709 colorspace after tone mapping
+            v = v * mat2020to709;
+        }
+    }
+    return v;
+}
+
+float4 GetOutputColorSimple(float4 rgba, float color_scale)
+{
+    float4 output;
+
+    output.rgb = rgba.rgb * color_scale;
+    output.a = rgba.a;
+
+    return output;
+}
+
+float3 GetOutputColorFromSRGB(float3 rgb, float scRGB_output, float color_scale)
+{
+    float3 output;
+
+    if (scRGB_output) {
+        rgb.r = sRGBtoLinear(rgb.r);
+        rgb.g = sRGBtoLinear(rgb.g);
+        rgb.b = sRGBtoLinear(rgb.b);
+    }
+
+    output = rgb * color_scale;
+
+    return output;
+}
+
+float3 GetOutputColorFromLinear(float3 rgb, float scRGB_output, float color_scale)
+{
+    float3 output;
+
+    output = rgb * color_scale;
+
+    if (!scRGB_output) {
+        output.r = sRGBfromLinear(output.r);
+        output.g = sRGBfromLinear(output.g);
+        output.b = sRGBfromLinear(output.b);
+        output = clamp(output, 0.0, 1.0);
+    }
+
+    return output;
+}
+
+float4 GetOutputColor(float4 rgba, constant ShaderConstants &c)
+{
+    const float3x3 mat2020to709 = {
+        { 1.660496, -0.587656, -0.072840 },
+        { -0.124547, 1.132895, -0.008348 },
+        { -0.018154, -0.100597, 1.118751 }
+    };
+    float4 output;
+
+    if (c.input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = PQtoLinear(rgba.rgb, c.sdr_white_point);
+    }
+
+    if (c.tonemap_method != TONEMAP_NONE) {
+        rgba.rgb = ApplyTonemap(rgba.rgb, c.input_type, c.tonemap_method, c.tonemap_factor1, c.tonemap_factor2);
+    }
+
+    if (c.input_type == INPUTTYPE_SRGB) {
+        if (c.texture_type == TEXTURETYPE_RGB) {
+            // The sampler has already converted to linear if necessary
+            output.rgb = rgba.rgb * c.color_scale;
+        } else {
+            output.rgb = GetOutputColorFromSRGB(rgba.rgb, c.scRGB_output, c.color_scale);
+        }
+    } else if (c.input_type == INPUTTYPE_SCRGB) {
+        output.rgb = GetOutputColorFromLinear(rgba.rgb, c.scRGB_output, c.color_scale);
+    } else if (c.input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = rgba.rgb * mat2020to709;
+        output.rgb = GetOutputColorFromLinear(rgba.rgb, c.scRGB_output, c.color_scale);
+    } else {
+        // Unexpected input type, use magenta error color
+        output.rgb = float3(1.0, 0.0, 1.0);
+    }
+    output.a = rgba.a;
+
+    return output;
+}
+
+struct SolidVertexInput
+{
+    float2 position [[attribute(0)]];
+    float4 color    [[attribute(1)]];
+};
+
+struct SolidVertexOutput
+{
+    float4 position [[position]];
+    float4 color;
+    float pointSize [[point_size]];
+};
+
+vertex SolidVertexOutput SDL_Solid_vertex(SolidVertexInput in [[stage_in]],
+                                          constant float4x4 &projection [[buffer(2)]],
+                                          constant float4x4 &transform [[buffer(3)]])
+{
+    SolidVertexOutput v;
+    v.position = (projection * transform) * float4(in.position, 0.0f, 1.0f);
+    v.color = in.color;
+    v.pointSize = 1.0f;
+    return v;
+}
+
+fragment float4 SDL_Solid_fragment(SolidVertexInput in [[stage_in]],
+                                   constant ShaderConstants &c [[buffer(0)]])
+{
+    return GetOutputColorSimple(1.0, c.color_scale) * in.color;
+}
+
+struct CopyVertexInput
+{
+    float2 position [[attribute(0)]];
+    float4 color    [[attribute(1)]];
+    float2 texcoord [[attribute(2)]];
+};
+
+struct CopyVertexOutput
+{
+    float4 position [[position]];
+    float4 color;
+    float2 texcoord;
+};
+
+vertex CopyVertexOutput SDL_Copy_vertex(CopyVertexInput in [[stage_in]],
+                                        constant float4x4 &projection [[buffer(2)]],
+                                        constant float4x4 &transform [[buffer(3)]])
+{
+    CopyVertexOutput v;
+    v.position = (projection * transform) * float4(in.position, 0.0f, 1.0f);
+    v.color = in.color;
+    v.texcoord = in.texcoord;
+    return v;
+}
+
+fragment float4 SDL_Copy_fragment(CopyVertexOutput vert [[stage_in]],
+                                  constant ShaderConstants &c [[buffer(0)]],
+                                  texture2d<float> tex [[texture(0)]],
+                                  sampler s [[sampler(0)]])
+{
+    float4 rgba = tex.sample(s, vert.texcoord);
+    return GetOutputColor(rgba, c) * vert.color;
+}
+
+fragment float4 SDL_YUV_fragment(CopyVertexOutput vert [[stage_in]],
+                                 constant ShaderConstants &c [[buffer(0)]],
+                                 constant YUVDecode &decode [[buffer(1)]],
+                                 texture2d<float> texY [[texture(0)]],
+                                 texture2d_array<float> texUV [[texture(1)]],
+                                 sampler s [[sampler(0)]])
+{
+    float3 yuv;
+    yuv.x = texY.sample(s, vert.texcoord).r;
+    yuv.y = texUV.sample(s, vert.texcoord, 0).r;
+    yuv.z = texUV.sample(s, vert.texcoord, 1).r;
+
+    float4 rgba;
+    rgba.rgb = (yuv + decode.offset) * decode.matrix;
+    rgba.a = 1.0;
+
+    return GetOutputColor(rgba, c) * vert.color;
+}
+
+fragment float4 SDL_NV12_fragment(CopyVertexOutput vert [[stage_in]],
+                                  constant ShaderConstants &c [[buffer(0)]],
+                                  constant YUVDecode &decode [[buffer(1)]],
+                                  texture2d<float> texY [[texture(0)]],
+                                  texture2d<float> texUV [[texture(1)]],
+                                  sampler s [[sampler(0)]])
+{
+    float4 rgba;
+    if (c.texture_type == TEXTURETYPE_NV12) {
+        float3 yuv;
+        yuv.x = texY.sample(s, vert.texcoord).r;
+        yuv.yz = texUV.sample(s, vert.texcoord).rg;
+
+        rgba.rgb = (yuv + decode.offset) * decode.matrix;
+    } else if (c.texture_type == TEXTURETYPE_NV21) {
+        float3 yuv;
+        yuv.x = texY.sample(s, vert.texcoord).r;
+        yuv.yz = texUV.sample(s, vert.texcoord).gr;
+
+        rgba.rgb = (yuv + decode.offset) * decode.matrix;
+    } else {
+        // Unexpected texture type, use magenta error color
+        rgba.rgb = float3(1.0, 0.0, 1.0);
+    }
+    rgba.a = 1.0;
+
+    return GetOutputColor(rgba, c) * vert.color;
+}
diff --git a/SDL-3.2.8/src/render/metal/SDL_shaders_metal_ios.h b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_ios.h
new file mode 100644
index 0000000..5d04118
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_ios.h
@@ -0,0 +1,2612 @@
+const unsigned char sdl_metallib[] = {
+  0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x45, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xe5, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x76, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
+  0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
+  0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
+  0x60, 0x7a, 0x81, 0x65, 0xda, 0xf6, 0x14, 0xc4, 0x56, 0x47, 0x0b, 0x7a,
+  0x77, 0x81, 0xf4, 0xc0, 0x01, 0xee, 0xcd, 0x26, 0x7c, 0x2d, 0x8d, 0x7b,
+  0x28, 0x66, 0x63, 0x5c, 0x85, 0xe9, 0xdd, 0xb9, 0x4f, 0x46, 0x46, 0x54,
+  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, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00,
+  0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x77, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
+  0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54, 0x59,
+  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x6e,
+  0xc3, 0x21, 0x35, 0x82, 0x00, 0x01, 0xe8, 0xa4, 0x27, 0xe1, 0xec, 0x73,
+  0xf1, 0xe9, 0x58, 0x2e, 0x4a, 0x0d, 0xc0, 0x5a, 0x63, 0x1e, 0x7f, 0x35,
+  0xf1, 0x6e, 0x35, 0x4e, 0xbf, 0x18, 0xae, 0x4f, 0x46, 0x46, 0x54, 0x18,
+  0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
+  0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x7a, 0x00, 0x00, 0x00, 0x4e,
+  0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
+  0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x6a, 0x1d, 0x1d, 0x45, 0x2a, 0x6b, 0x07, 0x82, 0x0a, 0x87, 0xce,
+  0x97, 0xa1, 0xfe, 0x31, 0x9c, 0x83, 0x91, 0x37, 0x14, 0x18, 0x48, 0x21,
+  0x09, 0xd8, 0x88, 0xe6, 0x6a, 0xd7, 0xa1, 0x43, 0x12, 0x4f, 0x46, 0x46,
+  0x54, 0x18, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x19, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08,
+  0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00, 0x00,
+  0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43,
+  0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
+  0x20, 0x00, 0xc3, 0xd6, 0x7b, 0x88, 0x85, 0xf9, 0x2a, 0x82, 0x3a, 0xbd,
+  0x11, 0xe6, 0x1e, 0x52, 0xa3, 0x10, 0xbc, 0xf6, 0x87, 0xcf, 0x2b, 0x30,
+  0xb1, 0x9a, 0xa7, 0x8c, 0xf0, 0x69, 0xee, 0x5a, 0x25, 0x8c, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x25, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
+  0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x78, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
+  0x20, 0x00, 0x9f, 0x6c, 0xde, 0x3a, 0x59, 0x77, 0x6a, 0xd2, 0x35, 0x5f,
+  0x27, 0x58, 0x9c, 0x4b, 0xdb, 0x9c, 0x88, 0xf7, 0xdf, 0x70, 0x9e, 0x17,
+  0x60, 0xc0, 0xe8, 0x92, 0xf3, 0x9d, 0xc8, 0x6a, 0x12, 0x45, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x3e, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
+  0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53,
+  0x48, 0x20, 0x00, 0xa0, 0xfa, 0x0c, 0x39, 0x0e, 0x54, 0xa2, 0xb2, 0x34,
+  0x03, 0x53, 0x34, 0x18, 0x63, 0x46, 0x2e, 0x1a, 0x02, 0x79, 0x8d, 0x88,
+  0x29, 0x32, 0xb9, 0xcc, 0xcd, 0x6b, 0xaa, 0xd8, 0x7a, 0x01, 0xd6, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x5a, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01,
+  0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x29,
+  0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x15, 0x00, 0x02, 0x00, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00,
+  0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44, 0x54, 0x35, 0x00, 0x00, 0x00,
+  0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03, 0x00, 0x70, 0x6f, 0x73, 0x69,
+  0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
+  0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00,
+  0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05, 0x00, 0x03, 0x00, 0x04, 0x06,
+  0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xac, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0x79, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c,
+  0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c, 0x00, 0x06, 0x77, 0x78,
+  0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76, 0xa0, 0x87, 0x74, 0x70,
+  0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08,
+  0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d,
+  0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d,
+  0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1, 0x1d, 0xda, 0x80, 0x1d,
+  0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79, 0x48, 0x87, 0x73, 0x70,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72, 0x90, 0x87, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01, 0x1e, 0xd2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90,
+  0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a, 0x08, 0x87, 0x71, 0x58,
+  0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a, 0x28, 0x87, 0x71, 0xa0,
+  0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d, 0x28, 0x07, 0x00, 0x0f,
+  0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1, 0x1c, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x6c, 0xc2, 0x00, 0x2c, 0x40,
+  0x35, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83,
+  0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b, 0x84, 0x03,
+  0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0x61, 0x1b, 0x08, 0x60, 0x01,
+  0xaa, 0x21, 0x1c, 0xd2, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xda, 0x20, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0,
+  0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88,
+  0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6,
+  0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18,
+  0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02,
+  0x50, 0x80, 0x01, 0x45, 0x50, 0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c,
+  0x04, 0x80, 0xd6, 0x58, 0x82, 0x24, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2,
+  0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42,
+  0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b,
+  0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x07, 0xe3, 0x20, 0x08,
+  0x0e, 0x8e, 0xad, 0x0c, 0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6,
+  0x85, 0x06, 0x86, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65,
+  0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x45, 0x60, 0xd1, 0x54,
+  0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0,
+  0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6,
+  0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17,
+  0x26, 0xc6, 0x56, 0x36, 0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x64, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95,
+  0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a,
+  0x9c, 0x0b, 0xdc, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0,
+  0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
+  0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca,
+  0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92,
+  0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b,
+  0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94,
+  0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14,
+  0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04,
+  0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x3a, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f,
+  0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x2c, 0xcc, 0xd8, 0xde,
+  0xc2, 0xe8, 0x98, 0xc0, 0xbd, 0xa5, 0xb9, 0xd1, 0x4d, 0xa5, 0xe9, 0x95,
+  0x0d, 0x51, 0x92, 0x2c, 0x81, 0x12, 0x2d, 0x91, 0x92, 0x6d, 0x88, 0x91,
+  0x50, 0x09, 0x96, 0x70, 0x84, 0xc2, 0xd2, 0xe4, 0x5c, 0xec, 0xca, 0xe4,
+  0xe8, 0xca, 0xf0, 0xbe, 0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x28, 0x85, 0xa5,
+  0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5,
+  0xb9, 0x91, 0x95, 0xe1, 0xd1, 0x3b, 0x2b, 0x73, 0x2b, 0x93, 0x0b, 0xa3,
+  0x2b, 0x23, 0x43, 0xf9, 0xfa, 0x0a, 0x4b, 0x93, 0xfb, 0x82, 0x63, 0x0b,
+  0x1b, 0x2b, 0x43, 0x7b, 0x63, 0x23, 0x2b, 0x93, 0xfb, 0xfa, 0x4a, 0xa1,
+  0x61, 0xc6, 0xf6, 0x16, 0x46, 0x27, 0x33, 0x84, 0x52, 0x84, 0xc4, 0x4b,
+  0x3e, 0x45, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x09, 0x83, 0x44, 0x4a,
+  0xa6, 0x21, 0x94, 0x12, 0x24, 0x5e, 0xf2, 0x29, 0x81, 0x12, 0x24, 0x60,
+  0x90, 0x40, 0x49, 0x94, 0x48, 0xc9, 0x45, 0x25, 0x2c, 0x4d, 0xce, 0x45,
+  0xac, 0xce, 0xcc, 0xac, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x8b, 0x58,
+  0x9d, 0x99, 0x59, 0x99, 0xdc, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x91, 0xb0,
+  0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x46, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0xbc, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2,
+  0xe0, 0xca, 0xbe, 0xc2, 0xd8, 0xd2, 0xce, 0xdc, 0xbe, 0xe6, 0xd2, 0xf4,
+  0xca, 0x88, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xd1, 0xe0, 0xd1, 0x50, 0x81,
+  0x93, 0x7b, 0x53, 0x2b, 0x1b, 0xa3, 0x4b, 0x7b, 0x73, 0x1b, 0x02, 0x06,
+  0x0a, 0x91, 0x90, 0x41, 0x52, 0x06, 0xca, 0x90, 0x7c, 0x0a, 0xa1, 0x04,
+  0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28, 0x45, 0x02, 0x25,
+  0x69, 0x90, 0x48, 0x89, 0x1a, 0x30, 0xa1, 0x93, 0x0b, 0x73, 0x9b, 0x33,
+  0x7b, 0x93, 0x6b, 0x1b, 0x02, 0x06, 0x8a, 0x91, 0x90, 0x41, 0x52, 0x06,
+  0xca, 0x90, 0x7c, 0x8a, 0xa1, 0x04, 0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c,
+  0x09, 0x1a, 0x28, 0x45, 0x02, 0x25, 0x69, 0x90, 0x48, 0x09, 0x1b, 0x0c,
+  0x41, 0x12, 0x31, 0x48, 0xc6, 0x20, 0x59, 0x83, 0xa4, 0x0d, 0x86, 0x18,
+  0x08, 0x90, 0x74, 0x89, 0x1b, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83, 0x7b,
+  0xa3, 0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33, 0x95,
+  0xd6, 0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25, 0x14,
+  0x14, 0x34, 0x44, 0x48, 0xe2, 0x60, 0x88, 0x91, 0xc0, 0x41, 0x22, 0x07,
+  0x4c, 0x32, 0xc4, 0x48, 0xe6, 0x20, 0x99, 0x03, 0x26, 0xa1, 0x18, 0x84,
+  0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd,
+  0xc1, 0x95, 0xcd, 0xa1, 0x4c, 0x11, 0x31, 0x7d, 0x4d, 0xbd, 0xb1, 0xa5,
+  0x91, 0x7d, 0xd9, 0x95, 0xc9, 0xd1, 0x95, 0xe1, 0xa5, 0x0c, 0x21, 0x12,
+  0x3b, 0x48, 0xea, 0x80, 0x56, 0x58, 0x9a, 0x5c, 0x4b, 0x18, 0x5b, 0x5a,
+  0xd8, 0x5c, 0xcb, 0xdc, 0xd8, 0x1b, 0x5c, 0x59, 0x4b, 0x98, 0xdc, 0x19,
+  0xca, 0x4c, 0xca, 0x10, 0x23, 0xc1, 0x83, 0xc4, 0x0e, 0x92, 0x3b, 0x18,
+  0x22, 0x24, 0x78, 0x40, 0x2b, 0x2c, 0x4d, 0xae, 0x25, 0x8c, 0x2d, 0x2d,
+  0x6c, 0xae, 0x65, 0x6e, 0xec, 0x0d, 0xae, 0xac, 0x25, 0x4c, 0xee, 0x0c,
+  0x45, 0x26, 0x65, 0x88, 0x91, 0xec, 0x41, 0x62, 0x07, 0x89, 0x1e, 0x0c,
+  0x11, 0x92, 0x3d, 0x18, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8,
+  0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98,
+  0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28,
+  0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e,
+  0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f,
+  0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e,
+  0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e,
+  0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b,
+  0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25,
+  0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e,
+  0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f,
+  0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67,
+  0x84, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f,
+  0xf4, 0x50, 0x0e, 0xf8, 0x30, 0x25, 0x78, 0x03, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x45,
+  0x44, 0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00, 0x00, 0x5c, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+  0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10,
+  0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x15, 0x41, 0x09, 0x94,
+  0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x66, 0x00,
+  0x08, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00, 0xe3, 0x11, 0x8d,
+  0x94, 0x49, 0x14, 0x94, 0xf1, 0x08, 0x88, 0xda, 0x28, 0x0a, 0xca, 0x20,
+  0xc3, 0x70, 0x34, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0xa0, 0xb0, 0xaf, 0xa1,
+  0xa0, 0x0c, 0x32, 0x1c, 0x8a, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a, 0xf8,
+  0x8c, 0x47, 0x64, 0x1d, 0x19, 0x4c, 0x14, 0x94, 0x41, 0x06, 0xe6, 0xc1,
+  0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08, 0x4f, 0x0c, 0xd2,
+  0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x94, 0x67, 0x42, 0x20, 0x1f, 0x2b,
+  0x02, 0xf8, 0x8c, 0x47, 0x88, 0xc1, 0x19, 0xb8, 0x01, 0x47, 0x41, 0x19,
+  0x64, 0x08, 0x34, 0x30, 0xb0, 0xa0, 0x92, 0xcf, 0x20, 0xc3, 0xb0, 0x8d,
+  0x81, 0x05, 0x93, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x60, 0x78, 0x67,
+  0x60, 0x41, 0x24, 0x1f, 0x1b, 0x02, 0xf8, 0x0c, 0x32, 0x24, 0x61, 0xb0,
+  0x06, 0x16, 0x3c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x78, 0xc4, 0x1b, 0xd0,
+  0xc1, 0x1e, 0xa0, 0x01, 0x05, 0x65, 0x90, 0x21, 0x38, 0x83, 0x36, 0xb0,
+  0x40, 0x0c, 0xe4, 0x33, 0xc8, 0x30, 0xa0, 0x01, 0x1c, 0x58, 0x00, 0x06,
+  0xf2, 0x19, 0x64, 0x28, 0xd4, 0x60, 0x0e, 0x2c, 0xe8, 0xe4, 0x33, 0xc8,
+  0x70, 0xb0, 0x81, 0x1d, 0x58, 0xa0, 0xc9, 0x67, 0x90, 0x81, 0x0f, 0xe2,
+  0xa0, 0x0e, 0x2c, 0x0b, 0xe4, 0x33, 0xc8, 0xe0, 0x07, 0x73, 0x80, 0x07,
+  0xe6, 0x04, 0xf2, 0xb1, 0x64, 0x80, 0x8f, 0x05, 0x0c, 0x7c, 0x2c, 0x48,
+  0xe0, 0x63, 0x01, 0x02, 0x1f, 0x0b, 0x0a, 0xf8, 0xcc, 0x36, 0xe4, 0x41,
+  0x00, 0xcc, 0x36, 0x04, 0xa5, 0x10, 0xcc, 0x36, 0x04, 0x78, 0x20, 0x64,
+  0x10, 0x10, 0x03, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20,
+  0xa0, 0x83, 0x23, 0x0f, 0x10, 0x3e, 0xd8, 0x72, 0x0c, 0x01, 0x1d, 0x1c,
+  0x7c, 0x80, 0xe4, 0xc1, 0x96, 0xe3, 0x08, 0xe8, 0xe0, 0xe0, 0x03, 0x24,
+  0x0f, 0xb6, 0x1c, 0x4c, 0x40, 0x07, 0x07, 0x1f, 0x20, 0x79, 0xb0, 0xe5,
+  0x88, 0x02, 0x3a, 0x38, 0xf8, 0x00, 0xc9, 0x83, 0x2d, 0x87, 0x15, 0xd0,
+  0xc1, 0x91, 0x07, 0x08, 0x1f, 0x6c, 0x39, 0xc6, 0x20, 0xa0, 0x83, 0x23,
+  0x0f, 0x10, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xbc, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0x79, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c,
+  0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c, 0x00, 0x06, 0x77, 0x78,
+  0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76, 0xa0, 0x87, 0x74, 0x70,
+  0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08,
+  0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d,
+  0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d,
+  0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1, 0x1d, 0xda, 0x80, 0x1d,
+  0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79, 0x48, 0x87, 0x73, 0x70,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72, 0x90, 0x87, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01, 0x1e, 0xd2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90,
+  0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a, 0x08, 0x87, 0x71, 0x58,
+  0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a, 0x28, 0x87, 0x71, 0xa0,
+  0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d, 0x28, 0x07, 0x00, 0x0f,
+  0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1, 0x1c, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x6c, 0x02, 0x01, 0x2c, 0x40,
+  0x35, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83,
+  0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b, 0x84, 0x03,
+  0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0x61, 0x1b, 0x0a, 0x60, 0x01,
+  0xaa, 0x21, 0x1c, 0xd2, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xda, 0x20, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c,
+  0x11, 0x84, 0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18,
+  0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x50, 0x04,
+  0x23, 0x00, 0x05, 0x18, 0x50, 0x08, 0x65, 0x50, 0x20, 0x05, 0x41, 0x6c,
+  0x04, 0x80, 0xd6, 0x58, 0x82, 0x24, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x06, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2,
+  0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x22,
+  0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b,
+  0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x05, 0xe3, 0x20, 0x08,
+  0x0e, 0x8e, 0xad, 0x0c, 0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6,
+  0x85, 0x06, 0x86, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65,
+  0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x65, 0x60, 0xd1, 0x54,
+  0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x65, 0xe0,
+  0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6,
+  0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17,
+  0x26, 0xc6, 0x56, 0x36, 0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x64, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95,
+  0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a,
+  0x9c, 0x0b, 0xdc, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0,
+  0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
+  0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca,
+  0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92,
+  0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b,
+  0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94,
+  0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14,
+  0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04,
+  0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
+  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x34, 0xcc, 0xd8, 0xde, 0xc2,
+  0xe8, 0x64, 0x88, 0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x0d,
+  0x61, 0x92, 0x2a, 0xc9, 0x12, 0x28, 0xd1, 0x12, 0x29, 0xd9, 0x86, 0x18,
+  0x09, 0x95, 0x60, 0x09, 0x47, 0x28, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c,
+  0x8e, 0xae, 0x0c, 0xef, 0x2b, 0xcd, 0x0d, 0xae, 0x8e, 0x8e, 0x52, 0x58,
+  0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58, 0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57,
+  0x9a, 0x1b, 0x59, 0x19, 0x1e, 0xbd, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30,
+  0xba, 0x32, 0x32, 0x94, 0xaf, 0xaf, 0xb0, 0x34, 0xb9, 0x2f, 0x38, 0xb6,
+  0xb0, 0xb1, 0x32, 0xb4, 0x37, 0x36, 0xb2, 0x32, 0xb9, 0xaf, 0xaf, 0x94,
+  0x21, 0x94, 0x32, 0x24, 0x5e, 0xf2, 0x29, 0x83, 0x12, 0x24, 0x60, 0x90,
+  0x40, 0x89, 0x96, 0x48, 0xc9, 0x34, 0x84, 0x52, 0x82, 0xc4, 0x4b, 0x3e,
+  0x25, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x89, 0x12, 0x29, 0xb9, 0x86,
+  0x50, 0x8a, 0x90, 0x78, 0xc9, 0xa7, 0x08, 0x4a, 0x90, 0x80, 0x41, 0x02,
+  0x25, 0x5a, 0x22, 0x25, 0x1b, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a,
+  0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
+  0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x44, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xe4, 0xca, 0xc2, 0xc8, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9,
+  0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1,
+  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0xfb, 0x0a, 0x63, 0x4b, 0x3b, 0x73, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x23,
+  0x62, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x83, 0x47, 0x43, 0x05, 0x4e, 0xee,
+  0x4d, 0xad, 0x6c, 0x8c, 0x2e, 0xed, 0xcd, 0x6d, 0x08, 0x18, 0x28, 0x46,
+  0x42, 0x06, 0x49, 0x19, 0x28, 0x44, 0xf2, 0x29, 0x82, 0x12, 0x24, 0x66,
+  0x90, 0x9c, 0x81, 0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41,
+  0x22, 0x25, 0x6a, 0xc0, 0x84, 0x4e, 0x2e, 0xcc, 0x6d, 0xce, 0xec, 0x4d,
+  0xae, 0x6d, 0x08, 0x18, 0x28, 0x45, 0x42, 0x06, 0x49, 0x19, 0x28, 0x44,
+  0xf2, 0x29, 0x86, 0x12, 0x24, 0x66, 0x90, 0x9c, 0x81, 0x42, 0x24, 0x68,
+  0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41, 0x22, 0x25, 0x6c, 0x30, 0x44, 0x49,
+  0xc2, 0x20, 0x11, 0x83, 0x64, 0x0c, 0x92, 0x35, 0x48, 0xda, 0x60, 0x88,
+  0x81, 0x00, 0x49, 0x97, 0xb8, 0x01, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8,
+  0x37, 0xba, 0x32, 0x37, 0x3a, 0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53,
+  0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42,
+  0x41, 0x41, 0x43, 0x84, 0x24, 0x0e, 0x86, 0x18, 0x09, 0x1c, 0x24, 0x72,
+  0xc0, 0x24, 0x43, 0x8c, 0x64, 0x0e, 0x92, 0x39, 0x60, 0x12, 0x86, 0x41,
+  0x58, 0x9a, 0x5c, 0x4b, 0x18, 0x5b, 0x5a, 0xd8, 0x5c, 0xcb, 0xdc, 0xd8,
+  0x1b, 0x5c, 0xd9, 0x1c, 0xca, 0x14, 0x11, 0xd3, 0xd7, 0xd0, 0x1b, 0x5c,
+  0xde, 0x97, 0x5d, 0x99, 0x1c, 0x5d, 0x19, 0x5e, 0xca, 0x10, 0x22, 0xb1,
+  0x83, 0xa4, 0x0e, 0x68, 0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85,
+  0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0x84, 0xc9, 0x9d, 0xa1,
+  0xd0, 0xa4, 0x0c, 0x31, 0x12, 0x3c, 0x48, 0xec, 0x20, 0xb9, 0x83, 0x21,
+  0x42, 0x82, 0x07, 0xb4, 0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8, 0xd2, 0xc2,
+  0xe6, 0x5a, 0xe6, 0xc6, 0xde, 0xe0, 0xca, 0x5a, 0xc2, 0xe4, 0xce, 0x50,
+  0x66, 0x52, 0x86, 0x18, 0xc9, 0x1e, 0x24, 0x76, 0x90, 0xe8, 0xc1, 0x10,
+  0x21, 0xd9, 0x83, 0x11, 0x11, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b,
+  0xb4, 0xc3, 0x3b, 0x90, 0x43, 0x3d, 0xb0, 0x43, 0x39, 0xb8, 0x81, 0x39,
+  0xb0, 0x43, 0x38, 0x9c, 0xc3, 0x3c, 0x4c, 0x11, 0x82, 0x61, 0x84, 0xc2,
+  0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xe9, 0x40, 0x0e, 0xe5, 0xe0,
+  0x0e, 0xf4, 0x30, 0x25, 0x28, 0x46, 0x2c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0,
+  0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30,
+  0x25, 0x30, 0x46, 0x50, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xec, 0x10,
+  0x0e, 0xee, 0x70, 0x0e, 0xf5, 0x10, 0x0e, 0xe7, 0x50, 0x0e, 0xbf, 0x60,
+  0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02,
+  0x64, 0xc4, 0x14, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x30, 0x0e, 0xef, 0xd0,
+  0x0e, 0xf0, 0x90, 0x0e, 0xec, 0x50, 0x0e, 0xbf, 0xf0, 0x0e, 0xf0, 0x40,
+  0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x0f, 0x53, 0x06, 0x85, 0x71, 0x46,
+  0x28, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x40,
+  0x0f, 0xe5, 0x80, 0x0f, 0x53, 0x82, 0x37, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11,
+  0x4d, 0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x5a, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10,
+  0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x95, 0x40, 0x19, 0x14,
+  0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x66, 0x00,
+  0x00, 0xe3, 0x11, 0x8c, 0x84, 0x49, 0x14, 0x94, 0xf1, 0x88, 0x87, 0xd2,
+  0x28, 0x0a, 0xca, 0x20, 0xc3, 0x60, 0x30, 0x26, 0x04, 0xf2, 0x19, 0x8f,
+  0x98, 0x30, 0xaf, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x49, 0x64, 0x42, 0x20,
+  0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x60, 0xdd, 0x18, 0x40, 0x14, 0x94,
+  0x41, 0x06, 0xc6, 0xb9, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1,
+  0x88, 0x4e, 0x0c, 0xd0, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x53, 0x67,
+  0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x84, 0xc1, 0x19, 0xb4,
+  0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e, 0x83,
+  0x0c, 0x83, 0x26, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20,
+  0x83, 0xd1, 0x99, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8,
+  0x90, 0x80, 0x81, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3,
+  0x11, 0x6e, 0x40, 0x07, 0x7a, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xc0,
+  0x0c, 0xd8, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6f,
+  0x60, 0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48, 0x03, 0x39, 0xb0, 0xa0,
+  0x93, 0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x75, 0x60, 0x81, 0x26, 0x9f, 0x41,
+  0x06, 0x3e, 0x78, 0x03, 0x3a, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x83, 0x1f,
+  0xc4, 0xc1, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30,
+  0xf0, 0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33,
+  0xdb, 0x90, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x94, 0x42, 0x30, 0xdb, 0x10,
+  0x94, 0x82, 0x90, 0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x5b, 0x8e, 0x20, 0xa0, 0x83, 0x23, 0x0f, 0x10, 0x3e, 0xd8, 0x72,
+  0x0c, 0x01, 0x1d, 0x1c, 0x7c, 0x80, 0xe4, 0xc1, 0x96, 0xe3, 0x08, 0xe8,
+  0xe0, 0xe0, 0x03, 0x24, 0x0f, 0xb6, 0x1c, 0x4c, 0x40, 0x07, 0x07, 0x1f,
+  0x20, 0x79, 0xb0, 0xe5, 0x88, 0x02, 0x3a, 0x38, 0xf8, 0x00, 0xc9, 0x83,
+  0x2d, 0x87, 0x15, 0xd0, 0xc1, 0x91, 0x07, 0x08, 0x1f, 0x6c, 0x39, 0xc6,
+  0x20, 0xa0, 0x83, 0x23, 0x0f, 0x10, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xfd, 0x02, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90,
+  0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8,
+  0x08, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00,
+  0x00, 0x51, 0x18, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x6c,
+  0xc2, 0x00, 0x2c, 0x40, 0x35, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88,
+  0x43, 0x3d, 0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc,
+  0x43, 0x1b, 0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0x00, 0x00,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84,
+  0x4c, 0x10, 0x3c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x67, 0x49, 0x53, 0x44, 0x09, 0x93, 0xcf, 0x1e, 0xc0, 0x40, 0x44, 0x9c,
+  0xd3, 0x48, 0x13, 0xd0, 0x4c, 0x12, 0x42, 0x00, 0x00, 0x00, 0x00, 0x06,
+  0x11, 0x06, 0xa1, 0x10, 0x21, 0x41, 0x54, 0x03, 0x01, 0x73, 0x04, 0x60,
+  0x90, 0x02, 0x38, 0x47, 0x00, 0x0a, 0x83, 0x08, 0x80, 0x30, 0x8c, 0x30,
+  0x00, 0xc3, 0x08, 0x04, 0x32, 0x02, 0x00, 0x00, 0x00, 0x13, 0xa8, 0x70,
+  0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78,
+  0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37,
+  0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07,
+  0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06,
+  0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07,
+  0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
+  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07,
+  0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07,
+  0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07,
+  0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07,
+  0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x03, 0x00, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0xc2, 0x11, 0x80, 0x42, 0x28, 0x81, 0x22, 0x28,
+  0x88, 0x02, 0x2a, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0xd2, 0xc2,
+  0x19, 0x01, 0x28, 0x8c, 0x42, 0x28, 0x88, 0x02, 0x29, 0x94, 0x82, 0xa1,
+  0x1c, 0x4b, 0x90, 0x04, 0x00, 0x79, 0x18, 0x00, 0x00, 0x27, 0x01, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x42, 0x1c, 0x40, 0x42, 0x51,
+  0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62,
+  0x20, 0xc3, 0x21, 0x20, 0x02, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c,
+  0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06,
+  0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x70, 0x10, 0x43,
+  0x0c, 0x64, 0x40, 0x0a, 0x24, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x39, 0x0e, 0x64, 0x40, 0x06, 0x24, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x38, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x63, 0x21,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0x8e, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
+  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
+  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
+  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x43, 0x90, 0xe3, 0x41, 0x82, 0x03, 0x3a, 0xa2, 0x21, 0xc2, 0x21, 0x51,
+  0x0a, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3,
+  0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3, 0x63, 0x76, 0x56, 0xe6, 0x56, 0x26,
+  0x17, 0x46, 0x57, 0x46, 0x86, 0x82, 0x03, 0xf7, 0x36, 0x97, 0x46, 0x97,
+  0xf6, 0xe6, 0x46, 0x64, 0x27, 0xf3, 0x65, 0x96, 0x42, 0x25, 0x2c, 0x4d,
+  0xce, 0x65, 0xac, 0xcc, 0x8d, 0xae, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c,
+  0x0b, 0x5c, 0x99, 0xdc, 0x1c, 0x5c, 0xd9, 0x18, 0x5d, 0x9a, 0x5d, 0x19,
+  0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x32, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6,
+  0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0x86, 0x48, 0x48, 0x70, 0x50, 0x47, 0x75,
+  0x58, 0xc7, 0x75, 0x40, 0x07, 0x76, 0x64, 0x87, 0x46, 0xeb, 0xac, 0xcc,
+  0xad, 0x4c, 0x2e, 0x8c, 0xae, 0x8c, 0x0c, 0xa5, 0x66, 0xec, 0x8d, 0xed,
+  0x4d, 0x8e, 0xc8, 0x8e, 0xe6, 0xcb, 0x2c, 0x85, 0xc5, 0xd8, 0x1b, 0xdb,
+  0x9b, 0xdc, 0x10, 0x09, 0x19, 0x0e, 0xea, 0xe0, 0x0e, 0xeb, 0xb8, 0x0e,
+  0xe8, 0x88, 0x8e, 0xec, 0xe8, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0x88, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0xf1, 0x09, 0x4b, 0x93, 0x73, 0x11, 0xab, 0x33,
+  0x33, 0x2b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xa3, 0x14, 0x96, 0x26,
+  0xe7, 0xc2, 0xf6, 0x36, 0x16, 0x46, 0x97, 0xf6, 0xe6, 0xf6, 0x95, 0xe6,
+  0x46, 0x56, 0x86, 0x47, 0x24, 0x2c, 0x4d, 0xce, 0x45, 0xae, 0x2c, 0x8c,
+  0x8c, 0x54, 0x58, 0x9a, 0x9c, 0xcb, 0x1c, 0x9d, 0x5c, 0xdd, 0x18, 0xdd,
+  0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x57, 0x9a, 0x9b, 0xd9, 0x1b, 0x0b, 0x33,
+  0xb6, 0xb7, 0x30, 0x3a, 0x32, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f,
+  0x75, 0x74, 0x70, 0x75, 0x74, 0x64, 0xe8, 0xca, 0xf0, 0xe8, 0xea, 0xe4,
+  0xca, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xa8, 0xa4, 0xb9, 0xc1, 0xd5, 0xd1,
+  0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x71, 0x19, 0x7b, 0x63, 0x7b, 0x93, 0xfb,
+  0x9a, 0x1b, 0x0b, 0x63, 0x2b, 0xa3, 0x43, 0xf7, 0xe6, 0x56, 0xd6, 0x16,
+  0x06, 0xf7, 0xd5, 0x56, 0x46, 0x87, 0xf6, 0x46, 0xc6, 0x87, 0xee, 0xcd,
+  0xad, 0xac, 0x2d, 0x0c, 0xee, 0xcb, 0x2c, 0x6c, 0x8c, 0xee, 0x4d, 0x2e,
+  0x86, 0x0f, 0xdd, 0x9b, 0x5b, 0x59, 0x5b, 0x18, 0xdc, 0x97, 0x59, 0xd8,
+  0x18, 0xdd, 0x9b, 0x9c, 0x0c, 0x9f, 0x39, 0x32, 0xb9, 0xaf, 0x3b, 0xb4,
+  0x34, 0xba, 0xb2, 0x2f, 0xb8, 0xb7, 0x34, 0x37, 0xba, 0x21, 0xb0, 0x80,
+  0x04, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x65, 0x80, 0x08, 0x88, 0x80,
+  0x04, 0x07, 0x19, 0x1c, 0x66, 0x80, 0x14, 0x88, 0x80, 0x04, 0x07, 0x19,
+  0x1c, 0x67, 0x80, 0x1c, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x68, 0x80,
+  0x20, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x69, 0x80, 0x24, 0x88, 0x80,
+  0x04, 0x07, 0x19, 0x1c, 0x6a, 0x80, 0x28, 0x88, 0x80, 0x04, 0x07, 0x19,
+  0x1c, 0x6b, 0x80, 0x2c, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x6c, 0xc0,
+  0x28, 0x2c, 0x4d, 0xce, 0x25, 0x4c, 0xee, 0xec, 0x8b, 0x2e, 0x0f, 0xae,
+  0xec, 0x6b, 0x2e, 0x4d, 0xaf, 0x8c, 0x57, 0x58, 0x9a, 0x9c, 0x4b, 0x98,
+  0xdc, 0xd9, 0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x57, 0x18, 0x5b, 0xda, 0x99,
+  0xdb, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x9f, 0x29, 0xb4, 0x30, 0xb2, 0x32,
+  0xb9, 0xa1, 0x37, 0xb7, 0x39, 0xba, 0x30, 0x37, 0xba, 0x39, 0x06, 0x63,
+  0x43, 0xc8, 0x00, 0x21, 0x8e, 0xef, 0x00, 0x03, 0xc4, 0x38, 0xc2, 0x00,
+  0x09, 0x90, 0xe1, 0x10, 0x83, 0x63, 0x0c, 0x8e, 0x36, 0x38, 0xdc, 0x00,
+  0x31, 0x8e, 0x37, 0x40, 0x84, 0x03, 0x3a, 0xe0, 0xe0, 0xc8, 0x8e, 0x38,
+  0x18, 0x62, 0x1c, 0xdb, 0xe1, 0x1d, 0x72, 0x30, 0xc4, 0x30, 0x80, 0x63,
+  0x3a, 0xe6, 0x80, 0xd5, 0x97, 0x16, 0xd5, 0x54, 0x4c, 0xcd, 0x14, 0x5a,
+  0x18, 0x59, 0x99, 0xdc, 0xd0, 0x9b, 0xdb, 0x1c, 0x5d, 0x98, 0x1b, 0xdd,
+  0x1c, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32, 0x37, 0x3a,
+  0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65,
+  0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43, 0x84, 0xe3,
+  0x0e, 0x86, 0x18, 0x87, 0x1d, 0x1c, 0x78, 0xa0, 0x34, 0x43, 0x8c, 0x83,
+  0x0c, 0x8e, 0x3c, 0x50, 0x9a, 0x21, 0x62, 0x70, 0xd4, 0xc1, 0xa1, 0x07,
+  0x4a, 0x73, 0xe8, 0x81, 0xf2, 0x1c, 0x7a, 0xa0, 0x40, 0x87, 0x1e, 0x28,
+  0xce, 0xa1, 0x07, 0x4a, 0x74, 0xe8, 0x81, 0x22, 0x1d, 0x7a, 0xa0, 0x4c,
+  0x87, 0x1e, 0x28, 0xcc, 0x10, 0xe3, 0xd8, 0x83, 0x43, 0x0f, 0x14, 0x87,
+  0x64, 0x10, 0x96, 0x26, 0xd7, 0x12, 0xc6, 0x96, 0x16, 0x36, 0xd7, 0x32,
+  0x37, 0xf6, 0x06, 0x57, 0x36, 0x87, 0x32, 0x45, 0xc4, 0xf4, 0x35, 0xf5,
+  0xc6, 0x96, 0x46, 0xf6, 0x65, 0x26, 0x17, 0x76, 0xd6, 0x56, 0xe6, 0x46,
+  0x97, 0x32, 0x84, 0x38, 0xfc, 0xe0, 0xe8, 0x03, 0x5a, 0x61, 0x69, 0x72,
+  0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65,
+  0x2d, 0x61, 0x72, 0x67, 0x28, 0x32, 0x29, 0x43, 0x8c, 0x03, 0x14, 0x0e,
+  0x3f, 0x38, 0xfe, 0x60, 0x88, 0x70, 0x80, 0xc2, 0x88, 0x88, 0x1d, 0xd8,
+  0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xda, 0xe1, 0x1d, 0xc8, 0xa1, 0x1e, 0xd8,
+  0xa1, 0x1c, 0xdc, 0xc0, 0x1c, 0xd8, 0x21, 0x1c, 0xce, 0x61, 0x1e, 0xa6,
+  0x08, 0xc1, 0x30, 0x42, 0x61, 0x07, 0x76, 0xb0, 0x87, 0x76, 0x70, 0x83,
+  0x74, 0x20, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0x14, 0x23, 0x96,
+  0x70, 0x48, 0x07, 0x79, 0x70, 0x03, 0x7b, 0x28, 0x07, 0x79, 0x98, 0x87,
+  0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x18, 0x23, 0xa8, 0x70, 0x48, 0x07,
+  0x79, 0x70, 0x03, 0x76, 0x08, 0x07, 0x77, 0x38, 0x87, 0x7a, 0x08, 0x87,
+  0x73, 0x28, 0x87, 0x5f, 0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x29, 0x01, 0x32, 0x62, 0x0a, 0x87, 0x74, 0x90, 0x07,
+  0x37, 0x18, 0x87, 0x77, 0x68, 0x07, 0x78, 0x48, 0x07, 0x76, 0x28, 0x87,
+  0x5f, 0x78, 0x07, 0x78, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x87,
+  0x29, 0x83, 0xc2, 0x38, 0x23, 0x98, 0x70, 0x48, 0x07, 0x79, 0x70, 0x03,
+  0x73, 0x90, 0x87, 0x70, 0x38, 0x87, 0x76, 0x28, 0x07, 0x77, 0xa0, 0x87,
+  0x29, 0x01, 0x1d, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x71, 0x20, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x20, 0xb1,
+  0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34,
+  0x13, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0xd4, 0x73, 0x10, 0x41, 0x10, 0x68, 0x84, 0x65, 0x30, 0x03, 0x40,
+  0x3c, 0x03, 0x40, 0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x00, 0x00,
+  0x00, 0xe3, 0x0d, 0x06, 0x44, 0x50, 0x30, 0xe6, 0x18, 0x88, 0xc0, 0x1b,
+  0x64, 0x08, 0x0a, 0x64, 0x8e, 0x21, 0x28, 0x10, 0x0b, 0x18, 0xf9, 0x64,
+  0x10, 0x10, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x8a, 0x20,
+  0xe0, 0x83, 0x23, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x88, 0x18, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x1f, 0x06, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0xef, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90,
+  0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d,
+  0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d,
+  0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70,
+  0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48,
+  0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0xc3, 0x26, 0x10, 0xc0,
+  0x02, 0x54, 0x43, 0x38, 0xa4, 0x83, 0x3c, 0xb4, 0x81, 0x38, 0xd4, 0x83,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0xb8, 0xc3, 0x3b, 0xb4, 0x41,
+  0x38, 0xb0, 0x43, 0x3a, 0x84, 0xc3, 0x3c, 0x00, 0x1b, 0x8c, 0xa1, 0x00,
+  0x16, 0xa0, 0xda, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x8f, 0x18, 0xff,
+  0xff, 0xff, 0xff, 0x3f, 0x00, 0x12, 0x50, 0x11, 0xe1, 0x00, 0x0f, 0xf0,
+  0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0, 0x0e, 0xe3,
+  0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8,
+  0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b, 0xa4, 0x83,
+  0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b, 0xb4, 0x81,
+  0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b, 0xdc, 0x43,
+  0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03, 0x90, 0x07, 0x76, 0x00, 0x0c, 0xee,
+  0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5, 0x90, 0x0e, 0xec, 0x40, 0x0f, 0xe9,
+  0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x60, 0x0e, 0xf2,
+  0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0xef, 0x90, 0x0e, 0xee,
+  0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d, 0x50, 0x0e, 0xec, 0x90, 0x0e, 0xed,
+  0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43,
+  0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94, 0x43, 0x1b, 0xc0, 0xc3,
+  0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0x94, 0x03,
+  0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81, 0x3b, 0xbc, 0x83, 0x3b, 0xb4, 0x01,
+  0x3b, 0x94, 0x43, 0x38, 0x98, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5,
+  0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x90, 0x0e, 0xee, 0x60, 0x0e, 0xf3,
+  0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8,
+  0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43,
+  0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3, 0x3c, 0xb4, 0x81, 0x39, 0xc0, 0x43,
+  0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f, 0xf5,
+  0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xe7,
+  0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d, 0xa0, 0x0f, 0xe5, 0x20, 0x0f, 0xef,
+  0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10, 0x0e, 0xf4,
+  0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3,
+  0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43, 0x38, 0xc0, 0x03, 0x3c, 0xa4, 0x83,
+  0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4,
+  0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0x31, 0x0f, 0xf4, 0x10, 0x0e, 0xe3,
+  0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2, 0xf0, 0x0e, 0xf4, 0x50, 0x0e, 0xe3,
+  0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d, 0x20, 0x0e, 0xf5, 0x60, 0x0e, 0xe6,
+  0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xfa, 0x50, 0x0e, 0x00,
+  0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3, 0x3c, 0x84, 0x83, 0x39, 0x94, 0x43,
+  0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03,
+  0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x6c, 0x40, 0x8e, 0xff, 0xff,
+  0xff, 0xff, 0x1f, 0x00, 0x06, 0x90, 0x80, 0x6a, 0x83, 0x81, 0x04, 0xc0,
+  0x02, 0x54, 0x1b, 0x8c, 0x44, 0x00, 0x16, 0xa0, 0xda, 0x80, 0x28, 0xff,
+  0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0x63, 0xf9,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0xc3, 0xc4, 0xfc, 0xff,
+  0xff, 0xff, 0xff, 0x00, 0x28, 0x80, 0x34, 0xb8, 0xc3, 0x3b, 0xb4, 0x81,
+  0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03, 0x3d, 0xa4, 0x83, 0x3b, 0xcc, 0x03,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40,
+  0x18, 0x88, 0x09, 0x41, 0x31, 0x21, 0x30, 0x26, 0x0c, 0x07, 0x92, 0x4c,
+  0x18, 0x14, 0x24, 0x99, 0x10, 0x2c, 0x13, 0x02, 0x06, 0x89, 0x20, 0x00,
+  0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0x9c, 0xc1,
+  0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04,
+  0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84,
+  0x41, 0x38, 0x4a, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89,
+  0x8a, 0x88, 0xdf, 0x1e, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x28, 0x82,
+  0x8b, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x25, 0x80, 0x79, 0x16, 0x22,
+  0xfa, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x10, 0xca, 0x11, 0x04, 0x81,
+  0x40, 0x18, 0x08, 0x25, 0xc3, 0x08, 0x03, 0x50, 0x88, 0x65, 0x59, 0x16,
+  0x62, 0xca, 0x00, 0x00, 0x00, 0x39, 0x45, 0x00, 0x00, 0x82, 0xca, 0x00,
+  0x2c, 0x0b, 0x49, 0xc5, 0x58, 0x16, 0x00, 0x00, 0x00, 0xa2, 0xca, 0xb0,
+  0x2c, 0x0b, 0x59, 0x45, 0x58, 0x16, 0xc2, 0xe6, 0x08, 0x82, 0x39, 0x02,
+  0x30, 0x18, 0x46, 0x10, 0xb6, 0x82, 0x04, 0x06, 0x22, 0x68, 0x9c, 0x06,
+  0x50, 0x37, 0x10, 0x90, 0x02, 0xdb, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x00,
+  0xc2, 0x14, 0xc0, 0x08, 0xc0, 0x30, 0xc2, 0xb0, 0x0d, 0x23, 0x10, 0x1b,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18,
+  0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x4c, 0x03,
+  0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0xe6, 0x01, 0x02,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0x13, 0x01, 0x01, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0x99, 0x80, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x54, 0x08, 0x30, 0x0c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x0c, 0x61, 0x1e, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x30, 0x17, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x43, 0x98, 0x0c, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0x21, 0xcc, 0x05, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10,
+  0xc6, 0x03, 0x02, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04,
+  0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xda, 0x46, 0x00, 0x0a,
+  0xa1, 0x04, 0x8a, 0xa0, 0x20, 0x0a, 0xa8, 0x0c, 0x0a, 0xa3, 0x40, 0x0a,
+  0xa5, 0x60, 0x0a, 0xa7, 0x14, 0x28, 0x2c, 0x9c, 0x11, 0x80, 0x42, 0x28,
+  0x88, 0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x02, 0xc7, 0x12, 0x24, 0x01,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0x77, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
+  0xb7, 0x21, 0xc6, 0xe6, 0x7c, 0x00, 0x18, 0x80, 0x01, 0x95, 0xbb, 0x31,
+  0xb4, 0x30, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0xb2, 0x21, 0xc6, 0xd6, 0x7c,
+  0xc2, 0xc6, 0x30, 0x0e, 0x82, 0xe0, 0xe0, 0xd8, 0xca, 0x40, 0xda, 0xca,
+  0xe8, 0xc2, 0xd8, 0x40, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x40,
+  0x66, 0x64, 0x60, 0x64, 0x66, 0x5c, 0x68, 0x60, 0x68, 0x40, 0x50, 0xda,
+  0xca, 0xe8, 0xc2, 0xd8, 0xcc, 0xca, 0x5a, 0x66, 0x64, 0x60, 0x64, 0x66,
+  0x5c, 0x68, 0x60, 0x68, 0x52, 0x86, 0x08, 0x1f, 0x31, 0xc4, 0xd8, 0x9a,
+  0xed, 0xd9, 0x16, 0x16, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x43, 0x90, 0xef,
+  0xd8, 0x9a, 0xad, 0xd9, 0x16, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x2f,
+  0x21, 0x17, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56,
+  0xe6, 0x62, 0x16, 0x36, 0x47, 0xf7, 0xd5, 0x16, 0x46, 0x87, 0xf6, 0x55,
+  0xe6, 0x16, 0x26, 0xc6, 0x56, 0x36, 0x44, 0xf8, 0x16, 0x92, 0x41, 0x58,
+  0x9a, 0x9c, 0xcb, 0xd8, 0x5b, 0x1b, 0x5c, 0x1a, 0x5b, 0x99, 0x8b, 0x99,
+  0x5c, 0x58, 0x5b, 0x99, 0x58, 0x9d, 0x99, 0x59, 0x99, 0xdc, 0x97, 0x59,
+  0x19, 0xdd, 0x18, 0xda, 0x57, 0x99, 0x5b, 0x98, 0x18, 0x5b, 0xd9, 0x10,
+  0xe1, 0x6b, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0xb9, 0x91, 0x95,
+  0xc9, 0x7d, 0xd1, 0x85, 0xc9, 0x9d, 0x95, 0xd1, 0x31, 0x0a, 0x4b, 0x93,
+  0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x72, 0x0b,
+  0x6b, 0x2b, 0xa3, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x33, 0x04, 0xf9,
+  0x9e, 0x6d, 0xf9, 0xa0, 0x2f, 0x1a, 0x22, 0x7c, 0x12, 0x99, 0xb0, 0x34,
+  0x39, 0x17, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0x37, 0x2a, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x94, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xdc, 0xde, 0xbe, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
+  0xe8, 0xd2, 0xec, 0xca, 0xc8, 0x84, 0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d,
+  0x7d, 0xb9, 0x85, 0xb5, 0x95, 0x11, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b,
+  0x7b, 0x73, 0x1b, 0x02, 0x6d, 0xcb, 0x47, 0x7d, 0xd5, 0x67, 0x7d, 0xd0,
+  0x17, 0x7d, 0xd7, 0x87, 0x51, 0x0a, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b,
+  0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3, 0xa3,
+  0x75, 0x56, 0xe6, 0x56, 0x26, 0x17, 0x46, 0x57, 0x46, 0x86, 0x52, 0x33,
+  0xf6, 0xc6, 0xf6, 0x26, 0x47, 0x64, 0x47, 0xf3, 0x65, 0x96, 0xc2, 0x27,
+  0x2c, 0x4d, 0xce, 0x05, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e,
+  0xcd, 0xae, 0x8c, 0xc5, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0x10, 0x69, 0x6b,
+  0x3e, 0xed, 0xdb, 0xbe, 0xea, 0xe3, 0x3e, 0xe8, 0x8b, 0xbe, 0xeb, 0xeb,
+  0x98, 0x9d, 0x95, 0xb9, 0x95, 0xc9, 0x85, 0xd1, 0x95, 0x91, 0xa1, 0xe0,
+  0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x11, 0xd9, 0xc9, 0x7c,
+  0x99, 0xa5, 0xd0, 0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x93, 0x21, 0x42, 0x57,
+  0x86, 0x37, 0xf6, 0xf6, 0x26, 0x47, 0x36, 0x44, 0xda, 0x9c, 0x4f, 0xfb,
+  0xbe, 0xaf, 0xfa, 0xb8, 0x0f, 0xfa, 0xc0, 0xe0, 0xbb, 0xbe, 0x30, 0xa0,
+  0x12, 0x96, 0x26, 0xe7, 0x22, 0x56, 0x67, 0x66, 0x56, 0x26, 0xc7, 0x27,
+  0x2c, 0x4d, 0xce, 0x45, 0xac, 0xce, 0xcc, 0xac, 0x4c, 0xee, 0x6b, 0x2e,
+  0x4d, 0xaf, 0x8c, 0x52, 0x58, 0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58, 0x18,
+  0x5d, 0xda, 0x9b, 0xdb, 0x57, 0x9a, 0x1b, 0x59, 0x19, 0x1e, 0x91, 0xb0,
+  0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x52, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f,
+  0x69, 0x6e, 0x66, 0x6f, 0x2c, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0xc8, 0xcc,
+  0x8d, 0x49, 0x1d, 0x09, 0x7d, 0xbd, 0xd5, 0xd1, 0xc1, 0xd5, 0xd1, 0x91,
+  0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0xa3, 0x92, 0xe6, 0x06, 0x57, 0x47, 0xf7, 0x45, 0x97, 0x07, 0x57, 0xc6,
+  0x65, 0xec, 0x8d, 0xed, 0x4d, 0xee, 0x6b, 0x6e, 0x2c, 0x8c, 0xad, 0x8c,
+  0x0e, 0xdd, 0x9b, 0x5b, 0x59, 0x5b, 0x18, 0xdc, 0x57, 0x5b, 0x19, 0x1d,
+  0xda, 0x1b, 0x19, 0x1f, 0xba, 0x37, 0xb7, 0xb2, 0xb6, 0x30, 0xb8, 0x2f,
+  0xb3, 0xb0, 0x31, 0xba, 0x37, 0xb9, 0x18, 0x3e, 0x74, 0x6f, 0x6e, 0x65,
+  0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x7c,
+  0xe6, 0xc8, 0xe4, 0xbe, 0xee, 0xd0, 0xd2, 0xe8, 0xca, 0xbe, 0xe0, 0xde,
+  0xd2, 0xdc, 0xe8, 0x86, 0xc0, 0xc2, 0xb6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68,
+  0xf0, 0xa5, 0xc1, 0xc6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xa9, 0xc1,
+  0xf6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xad, 0xc1, 0x26, 0x6d, 0xcc,
+  0xb6, 0x7c, 0x68, 0xf0, 0xb1, 0xc1, 0x36, 0x6d, 0xcc, 0xb6, 0x7c, 0x68,
+  0xf0, 0xb5, 0xc1, 0x46, 0x6d, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xb9, 0xc1,
+  0x56, 0x6d, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xbd, 0xc1, 0x66, 0x6d, 0xcc,
+  0xb6, 0x7c, 0x68, 0xf0, 0xc1, 0x01, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
+  0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32,
+  0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x7c, 0xa6, 0xd0, 0xc2, 0xc8, 0xca, 0xe4, 0x86, 0xde, 0xdc, 0xe6, 0xe8,
+  0xc2, 0xdc, 0xe8, 0xe6, 0x18, 0x8c, 0x0d, 0x21, 0x83, 0x2d, 0xfa, 0xc6,
+  0xe0, 0x23, 0x83, 0x0d, 0xfa, 0xca, 0x60, 0x5b, 0xb6, 0xe6, 0x33, 0x83,
+  0xef, 0x0c, 0xbe, 0x38, 0xf8, 0xe4, 0x60, 0x83, 0xbe, 0x39, 0xd8, 0x98,
+  0x0f, 0xfa, 0xe8, 0xe0, 0xbb, 0xbe, 0x3a, 0xe0, 0x12, 0x96, 0x26, 0xe7,
+  0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d, 0xce,
+  0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e, 0x5d,
+  0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d, 0x0b,
+  0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x07, 0xba, 0x32, 0xbc,
+  0x21, 0xd4, 0xc6, 0x7c, 0x77, 0xf0, 0x95, 0xc1, 0xb6, 0x6c, 0xcd, 0x87,
+  0x07, 0x1f, 0xf4, 0xe5, 0xc1, 0x77, 0x7d, 0x7a, 0xc0, 0x25, 0x2c, 0x4d,
+  0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x4c, 0x8e, 0xc7, 0x5c, 0x58,
+  0x1b, 0x1c, 0x5b, 0x99, 0x1c, 0x83, 0xb9, 0x21, 0xd2, 0x76, 0x7d, 0x7c,
+  0xf0, 0x95, 0xc1, 0xb6, 0x6c, 0xcd, 0x07, 0x7d, 0x7d, 0xf0, 0x5d, 0x9f,
+  0x1f, 0x0c, 0x61, 0xbe, 0xec, 0xf3, 0x3e, 0x31, 0xf8, 0xec, 0xe0, 0xdb,
+  0x83, 0xef, 0x0f, 0x86, 0x18, 0x0a, 0xf0, 0x4d, 0x1f, 0x28, 0x70, 0x0c,
+  0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8, 0xd2, 0xc2, 0xe6, 0x5a, 0xe6, 0xc6,
+  0xde, 0xe0, 0xca, 0xe6, 0x50, 0xa6, 0x88, 0x98, 0xbe, 0x86, 0xde, 0xe0,
+  0xf2, 0xbe, 0xcc, 0xe4, 0xc2, 0xce, 0xda, 0xca, 0xdc, 0xe8, 0x52, 0x86,
+  0x10, 0xdf, 0x28, 0x7c, 0xa2, 0x40, 0x2c, 0x2c, 0x4d, 0xae, 0x25, 0x8c,
+  0x2d, 0x2d, 0x6c, 0xae, 0x65, 0x6e, 0xec, 0x0d, 0xae, 0xac, 0x85, 0xae,
+  0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x6c, 0x6e, 0x88, 0xf1, 0x95, 0xc2, 0x37,
+  0x0a, 0x1f, 0x29, 0x10, 0x0b, 0x4b, 0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b,
+  0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83, 0x2b, 0x6b, 0x99, 0x0b, 0x6b, 0x83,
+  0x63, 0x2b, 0x93, 0x9b, 0x1b, 0x62, 0x7c, 0xa7, 0xf0, 0x8d, 0xc2, 0x67,
+  0x0a, 0x43, 0x88, 0xaf, 0x14, 0xbe, 0x53, 0xa0, 0x15, 0x96, 0x26, 0xd7,
+  0x12, 0xc6, 0x96, 0x16, 0x36, 0xd7, 0x32, 0x37, 0xf6, 0x06, 0x57, 0xd6,
+  0x12, 0x26, 0x77, 0x86, 0x32, 0x93, 0x32, 0xc4, 0xf8, 0x54, 0xe1, 0x1b,
+  0x85, 0x2f, 0x15, 0x86, 0x08, 0x9f, 0x2a, 0xb0, 0xfa, 0xd2, 0xa2, 0x9a,
+  0x8a, 0xa9, 0x99, 0x42, 0x0b, 0x23, 0x2b, 0x93, 0x1b, 0x7a, 0x73, 0x9b,
+  0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0xe3, 0xf3, 0xd6, 0xe6, 0x96, 0x06, 0xf7,
+  0x46, 0x57, 0xe6, 0x46, 0x07, 0x32, 0x86, 0x16, 0x26, 0xc7, 0x67, 0x2a,
+  0xad, 0x0d, 0x8e, 0xad, 0x0c, 0x64, 0x68, 0x65, 0x05, 0x84, 0x4a, 0x28,
+  0x28, 0x68, 0x88, 0xf0, 0xb9, 0xc2, 0x10, 0xe3, 0x6b, 0x85, 0xef, 0x15,
+  0xc2, 0x20, 0x1b, 0x62, 0x7c, 0x68, 0xf0, 0xc1, 0x42, 0x18, 0x64, 0x43,
+  0xc4, 0xe0, 0x63, 0x85, 0x2f, 0x16, 0xc2, 0x20, 0xfb, 0x62, 0x21, 0x0c,
+  0xb4, 0x2f, 0x16, 0xc2, 0x60, 0xfb, 0x62, 0x21, 0x0c, 0xb8, 0x2f, 0x16,
+  0xc2, 0xa0, 0xfb, 0x62, 0x21, 0x0c, 0xbc, 0x2f, 0x16, 0xc2, 0xe0, 0xfb,
+  0x62, 0x21, 0x0c, 0xb0, 0x21, 0xc6, 0x27, 0x0b, 0x5f, 0x2c, 0x84, 0xc1,
+  0x36, 0xc4, 0xf8, 0x64, 0xe1, 0x8b, 0x85, 0x30, 0xc0, 0x86, 0x18, 0x9f,
+  0x2c, 0x7c, 0xb1, 0x10, 0x06, 0xdd, 0x10, 0xe3, 0x93, 0x85, 0x2f, 0x16,
+  0xc2, 0xc0, 0x1b, 0x62, 0x7c, 0xb2, 0xf0, 0xc5, 0x42, 0x18, 0x7c, 0x43,
+  0x8c, 0x4f, 0x16, 0xbe, 0x58, 0x08, 0x03, 0x6d, 0x88, 0xf1, 0xc9, 0xc2,
+  0x17, 0x0b, 0x61, 0xc0, 0x0d, 0x31, 0x3e, 0x59, 0xf8, 0x62, 0x21, 0x0c,
+  0xb2, 0x11, 0x11, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0xb4, 0xc3,
+  0x3b, 0x90, 0x43, 0x3d, 0xb0, 0x43, 0x39, 0xb8, 0x81, 0x39, 0xb0, 0x43,
+  0x38, 0x9c, 0xc3, 0x3c, 0x4c, 0x11, 0x82, 0x61, 0x84, 0xc2, 0x0e, 0xec,
+  0x60, 0x0f, 0xed, 0xe0, 0x06, 0xe9, 0x40, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4,
+  0x30, 0x25, 0x28, 0x46, 0x2c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6,
+  0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x30,
+  0x46, 0x50, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xec, 0x10, 0x0e, 0xee,
+  0x70, 0x0e, 0xf5, 0x10, 0x0e, 0xe7, 0x50, 0x0e, 0xbf, 0x60, 0x0f, 0xe5,
+  0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x64, 0xc4,
+  0x14, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x30, 0x0e, 0xef, 0xd0, 0x0e, 0xf0,
+  0x90, 0x0e, 0xec, 0x50, 0x0e, 0xbf, 0xf0, 0x0e, 0xf0, 0x40, 0x0f, 0xe9,
+  0xf0, 0x0e, 0xee, 0x30, 0x0f, 0x53, 0x06, 0x85, 0x71, 0x46, 0x30, 0xe1,
+  0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe6, 0x20, 0x0f, 0xe1, 0x70, 0x0e, 0xed,
+  0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x50, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x2e, 0x00, 0x00,
+  0x00, 0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x45, 0x04,
+  0x18, 0x0c, 0xd1, 0x4c, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf, 0xb3,
+  0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45, 0x51,
+  0x14, 0x46, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4, 0x57, 0x77, 0x71,
+  0xdb, 0xa6, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f,
+  0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x6d,
+  0x08, 0x13, 0x80, 0x44, 0x7e, 0x01, 0x48, 0xd3, 0x5f, 0x00, 0x81, 0xe4,
+  0x57, 0x77, 0x71, 0xdb, 0x16, 0x40, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34,
+  0xfd, 0xc2, 0x02, 0x30, 0x8f, 0x5f, 0xdd, 0xc5, 0x6d, 0x5b, 0xc2, 0x04,
+  0x20, 0x91, 0x5f, 0x00, 0xd2, 0xf4, 0x17, 0x0c, 0x70, 0xf9, 0xd5, 0x5d,
+  0xdc, 0xb6, 0x09, 0x40, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0xff, 0xe3,
+  0x58, 0x7e, 0x71, 0xdb, 0x36, 0x10, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34,
+  0xfd, 0x05, 0x10, 0x48, 0x7e, 0x71, 0xdb, 0x66, 0x10, 0x01, 0x48, 0xe4,
+  0x17, 0x80, 0x34, 0xfd, 0x05, 0x03, 0x5c, 0x7e, 0x71, 0xdb, 0x76, 0x20,
+  0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x8f, 0x63, 0xf9, 0xd5, 0x5d,
+  0xdc, 0x36, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x9a, 0x01, 0x00,
+  0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00, 0x00, 0x51, 0x00, 0x00,
+  0x00, 0x64, 0x8e, 0x45, 0x00, 0x81, 0x70, 0xcc, 0x41, 0x2c, 0x8d, 0xd3,
+  0x06, 0x54, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xdc, 0x08, 0x00,
+  0x6d, 0xc5, 0x30, 0x03, 0x50, 0x0e, 0xa4, 0x8d, 0x00, 0xd4, 0x00, 0x01,
+  0x63, 0x04, 0xef, 0x9e, 0x96, 0xf7, 0x37, 0x46, 0xa0, 0xb3, 0xe6, 0x1c,
+  0x82, 0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x09, 0x06, 0x63, 0x04, 0x20,
+  0x08, 0x82, 0x20, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03, 0x30, 0x03, 0x30,
+  0x07, 0x91, 0x0a, 0xaf, 0x90, 0x0a, 0x75, 0x40, 0xcb, 0x0c, 0xc0, 0x08,
+  0xc0, 0x0c, 0xc0, 0x58, 0x03, 0x08, 0x82, 0x20, 0xfe, 0x81, 0x20, 0x08,
+  0xe2, 0x1f, 0x08, 0x82, 0x20, 0xfe, 0x8d, 0x35, 0xb0, 0xed, 0xfc, 0x93,
+  0x1e, 0xdb, 0xce, 0x3f, 0xe9, 0xb1, 0xed, 0xfc, 0x93, 0xde, 0x58, 0x03,
+  0x08, 0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20,
+  0xc8, 0xd6, 0xbf, 0x30, 0xd6, 0x00, 0x82, 0xe0, 0x9a, 0x83, 0x01, 0x08,
+  0x82, 0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x8c, 0x35, 0x80,
+  0x20, 0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2,
+  0x6d, 0x0e, 0x06, 0x63, 0x0d, 0xeb, 0x88, 0xc7, 0x2c, 0x18, 0xac, 0x23,
+  0x1e, 0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x58, 0x03, 0x08,
+  0xc2, 0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c,
+  0x87, 0x63, 0x30, 0xd6, 0x20, 0xe6, 0x62, 0xda, 0x7f, 0x60, 0xc9, 0xb3,
+  0xf1, 0x2f, 0x8c, 0xe9, 0xaa, 0xe6, 0xbe, 0x30, 0xd6, 0xf0, 0xcf, 0xa4,
+  0xff, 0xfb, 0x02, 0x5d, 0x83, 0x62, 0xfe, 0xb5, 0x70, 0x1c, 0x83, 0xbe,
+  0x30, 0xd6, 0x30, 0xf7, 0x6d, 0x9a, 0xfa, 0x42, 0xeb, 0x86, 0x3c, 0xef,
+  0x0b, 0x7c, 0xce, 0xfa, 0xf8, 0x47, 0xc0, 0x18, 0x81, 0xdb, 0xc7, 0xa2,
+  0xed, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0x79, 0xaf,
+  0xab, 0xec, 0x8d, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0xdb,
+  0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba, 0xf8, 0x37, 0x46,
+  0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8, 0xf6, 0x34, 0x18,
+  0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x23, 0x06, 0x4a, 0x11, 0x98, 0xc2, 0x1a, 0xa8, 0x41, 0x1b, 0x80,
+  0x41, 0x19, 0x84, 0x41, 0x30, 0xde, 0xd0, 0x06, 0x78, 0x30, 0x0a, 0x14,
+  0x8c, 0xe1, 0x86, 0x00, 0x0c, 0x82, 0x59, 0x86, 0x40, 0x08, 0x06, 0x19,
+  0x08, 0x4f, 0x0d, 0xc6, 0x1b, 0xe2, 0x80, 0x0f, 0xce, 0x80, 0x82, 0x31,
+  0x62, 0x40, 0x18, 0xc1, 0x2b, 0x0c, 0x23, 0x06, 0x85, 0x11, 0xc4, 0x42,
+  0xb0, 0x59, 0xb0, 0xc1, 0x67, 0xc4, 0xa0, 0x30, 0x82, 0x58, 0x08, 0xc0,
+  0xc0, 0x06, 0x4e, 0x3e, 0xc6, 0x05, 0xf1, 0xb1, 0x21, 0xa0, 0xcf, 0x88,
+  0x01, 0x61, 0x04, 0xb6, 0x10, 0x8c, 0x18, 0x14, 0x46, 0x80, 0x0b, 0x81,
+  0x67, 0x81, 0x27, 0x9f, 0x39, 0x06, 0x34, 0x58, 0x6c, 0x61, 0x90, 0x21,
+  0x48, 0x83, 0x3c, 0xb0, 0x21, 0xa0, 0xcf, 0x20, 0x43, 0xb0, 0x06, 0x7c,
+  0x30, 0xc8, 0x10, 0x54, 0x7e, 0x30, 0x4b, 0x20, 0x0c, 0x54, 0x04, 0x42,
+  0xc0, 0x06, 0xc0, 0x78, 0xc3, 0x28, 0xb8, 0xc2, 0x2e, 0x50, 0x30, 0x86,
+  0x1b, 0x02, 0xcd, 0x99, 0x65, 0x18, 0x88, 0x60, 0x90, 0x81, 0xa0, 0x03,
+  0x50, 0x18, 0x6f, 0x38, 0x05, 0x59, 0xa0, 0x05, 0x0a, 0xc6, 0x78, 0x43,
+  0x2a, 0xd0, 0x42, 0x28, 0x50, 0x30, 0x46, 0x0c, 0x90, 0x23, 0x52, 0x87,
+  0xa2, 0x3b, 0x86, 0x60, 0x90, 0x21, 0xb8, 0x03, 0x54, 0x18, 0x64, 0x08,
+  0x16, 0x55, 0x98, 0x25, 0x20, 0x06, 0x2a, 0x02, 0x61, 0xc0, 0x84, 0xe1,
+  0x86, 0x30, 0x50, 0x83, 0x60, 0x96, 0xa1, 0x98, 0x82, 0xf1, 0x06, 0x58,
+  0xd8, 0x85, 0x73, 0xa0, 0x60, 0x0c, 0x37, 0x04, 0x6d, 0x10, 0xcc, 0x32,
+  0x18, 0x47, 0x30, 0xc8, 0x50, 0x84, 0x42, 0x2b, 0x8c, 0x37, 0xd0, 0xc2,
+  0x2f, 0x9c, 0x03, 0x05, 0x63, 0x8e, 0x21, 0x14, 0x82, 0x77, 0x18, 0x64,
+  0x08, 0x44, 0x41, 0x16, 0x2c, 0x28, 0xe4, 0x33, 0xc8, 0x10, 0x90, 0x42,
+  0x2d, 0xcc, 0x12, 0xb4, 0xc1, 0x78, 0x83, 0x2e, 0x94, 0xc3, 0x3c, 0x50,
+  0x30, 0xc6, 0x1b, 0x78, 0xe1, 0x1c, 0xde, 0x81, 0x82, 0x31, 0xc8, 0x00,
+  0xb1, 0x82, 0x2e, 0x0c, 0x37, 0x10, 0x74, 0xe0, 0xcc, 0x32, 0x20, 0x52,
+  0x30, 0x86, 0x20, 0xe5, 0xc3, 0x70, 0x43, 0xd0, 0x07, 0xca, 0x2c, 0x83,
+  0x92, 0x04, 0x26, 0xfc, 0x81, 0x7c, 0x66, 0x09, 0x16, 0x1b, 0x42, 0x01,
+  0x3e, 0x23, 0x06, 0x84, 0x11, 0x94, 0x44, 0x60, 0x01, 0x2e, 0xc8, 0x67,
+  0xc4, 0xa0, 0x30, 0x02, 0x94, 0x08, 0x70, 0x61, 0x96, 0x60, 0x19, 0xa8,
+  0x00, 0x94, 0x44, 0x50, 0xe6, 0x18, 0x6a, 0x21, 0x08, 0x89, 0x31, 0x84,
+  0x0d, 0x24, 0x86, 0x1b, 0x02, 0x53, 0x50, 0x66, 0x19, 0x1a, 0x26, 0x30,
+  0x01, 0x15, 0xe4, 0x33, 0x4b, 0xe0, 0xd8, 0xa0, 0x0a, 0xf0, 0x19, 0x31,
+  0x20, 0x8c, 0xc0, 0x25, 0x02, 0x0b, 0xc2, 0x41, 0x3e, 0x23, 0x06, 0x85,
+  0x11, 0xc4, 0x44, 0x10, 0x0e, 0xb3, 0x04, 0xce, 0x40, 0x05, 0xa0, 0x30,
+  0x42, 0x33, 0xc7, 0x90, 0x04, 0x28, 0x31, 0x86, 0x40, 0x06, 0x28, 0x31,
+  0xdc, 0x10, 0xbc, 0x82, 0x32, 0xcb, 0x00, 0x3d, 0x81, 0x09, 0xb1, 0x20,
+  0x9f, 0x59, 0x82, 0xc8, 0x86, 0x59, 0x80, 0xcf, 0x88, 0x01, 0x61, 0x04,
+  0x37, 0x11, 0x58, 0xa0, 0x0e, 0xf2, 0x19, 0x31, 0x28, 0x8c, 0x40, 0x27,
+  0x02, 0x75, 0x98, 0x25, 0x88, 0x06, 0x2a, 0x00, 0xe5, 0x11, 0xa0, 0x39,
+  0x86, 0x24, 0x80, 0x89, 0x59, 0x02, 0x69, 0xa0, 0x22, 0x10, 0x22, 0x3d,
+  0x38, 0x06, 0x19, 0x02, 0x75, 0xb0, 0x87, 0x39, 0x06, 0x74, 0x00, 0x03,
+  0x9b, 0x18, 0x64, 0x08, 0xd2, 0x21, 0x1f, 0x6c, 0x08, 0xe4, 0x33, 0xc8,
+  0x10, 0xac, 0x03, 0x3f, 0xcc, 0x12, 0xb4, 0xc1, 0x70, 0xc3, 0x2c, 0xc4,
+  0x43, 0x30, 0xcb, 0x40, 0x81, 0x41, 0x30, 0xc8, 0x40, 0x07, 0xf0, 0xc0,
+  0x0f, 0xe3, 0x0d, 0x23, 0xe1, 0x12, 0x3c, 0x41, 0xc1, 0x18, 0x6f, 0x28,
+  0x09, 0x98, 0xc0, 0x09, 0x0a, 0xc6, 0x1c, 0x83, 0x3c, 0x04, 0x60, 0x31,
+  0xc8, 0x10, 0xcc, 0xc3, 0x48, 0x58, 0x70, 0xc8, 0x67, 0x90, 0x21, 0xa8,
+  0x07, 0x93, 0x18, 0x6e, 0x38, 0xc0, 0xc1, 0x99, 0x65, 0xf8, 0xaa, 0x60,
+  0x0c, 0x61, 0x28, 0x8b, 0xe1, 0x86, 0x60, 0x1c, 0x94, 0x59, 0x86, 0xcb,
+  0x0a, 0x4c, 0x28, 0x07, 0xf9, 0xcc, 0x12, 0x60, 0x23, 0x06, 0x84, 0x11,
+  0xc0, 0xc5, 0x30, 0x62, 0x50, 0x18, 0x81, 0x5c, 0x04, 0xe8, 0x60, 0x81,
+  0x3a, 0xc8, 0xc7, 0x02, 0x76, 0x80, 0xcf, 0x2c, 0x01, 0x36, 0x50, 0x01,
+  0x28, 0x96, 0x70, 0xcd, 0x31, 0xf4, 0x43, 0xd0, 0x16, 0x63, 0x08, 0x0c,
+  0x5b, 0x0c, 0x37, 0x04, 0xec, 0xa0, 0xcc, 0x32, 0x68, 0x59, 0x60, 0x82,
+  0x3b, 0xc8, 0x67, 0x96, 0x60, 0x1b, 0x31, 0x20, 0x8c, 0x20, 0x2f, 0x86,
+  0x11, 0x83, 0xc2, 0x08, 0xf6, 0x22, 0x88, 0x07, 0x0b, 0xe6, 0x41, 0x3e,
+  0x16, 0xd4, 0x03, 0x7c, 0x66, 0x09, 0xb6, 0x81, 0x0a, 0x40, 0xc9, 0x04,
+  0x6d, 0x8e, 0x21, 0x09, 0xe8, 0x62, 0x0c, 0xa1, 0xa2, 0x8b, 0xe1, 0x86,
+  0xa0, 0x1e, 0x94, 0x59, 0x86, 0x8e, 0x0b, 0x4c, 0xb8, 0x07, 0xf9, 0xcc,
+  0x12, 0x78, 0x23, 0x06, 0x84, 0x11, 0x88, 0xc6, 0x30, 0x62, 0x50, 0x18,
+  0x01, 0x69, 0x04, 0xfa, 0x60, 0x01, 0x3f, 0xc8, 0xc7, 0x02, 0x7f, 0x80,
+  0xcf, 0x2c, 0x81, 0x37, 0x50, 0x01, 0x28, 0x9c, 0xd0, 0xcd, 0x31, 0x24,
+  0x01, 0x5f, 0x8c, 0x18, 0x18, 0x46, 0xa0, 0x1a, 0x41, 0x4c, 0xbc, 0xc4,
+  0x20, 0x43, 0x30, 0x13, 0x64, 0x31, 0x4b, 0xf0, 0x0d, 0x54, 0x04, 0x7e,
+  0x40, 0x09, 0xde, 0x20, 0x43, 0x80, 0x13, 0x66, 0x31, 0x4b, 0xd0, 0x06,
+  0xb3, 0x0c, 0x61, 0xd0, 0x06, 0xfc, 0x30, 0xc8, 0xd0, 0x0b, 0x39, 0x51,
+  0x16, 0x23, 0x06, 0x85, 0x11, 0xb0, 0x46, 0xd0, 0x12, 0x73, 0x0c, 0x36,
+  0x11, 0x98, 0xc6, 0x88, 0x41, 0x61, 0x04, 0xae, 0x31, 0xb8, 0xc4, 0x1c,
+  0x83, 0x10, 0x98, 0xc6, 0x88, 0x41, 0x61, 0x04, 0xb0, 0x51, 0xbc, 0xc4,
+  0x1c, 0x83, 0x10, 0x9c, 0xc6, 0x20, 0x43, 0xd0, 0x13, 0x6e, 0x31, 0xc8,
+  0x10, 0x94, 0x03, 0x5c, 0x8c, 0x37, 0xd0, 0xc5, 0x5f, 0xb4, 0x06, 0x05,
+  0x63, 0xbc, 0xc1, 0x2e, 0x42, 0x23, 0x35, 0x28, 0x18, 0x73, 0x0c, 0x63,
+  0x11, 0xc4, 0xc6, 0x20, 0x43, 0x40, 0x16, 0x74, 0x61, 0x41, 0x22, 0x9f,
+  0x41, 0x86, 0xc0, 0x2c, 0xee, 0x62, 0xb8, 0xe1, 0x88, 0x09, 0x67, 0x96,
+  0x81, 0x0d, 0xc4, 0x20, 0x18, 0x43, 0x18, 0x6c, 0x63, 0xb8, 0x21, 0xa0,
+  0x09, 0x65, 0x96, 0x81, 0x0c, 0xc6, 0x20, 0x30, 0xc1, 0x26, 0xe4, 0x33,
+  0x4b, 0x50, 0x06, 0x23, 0x06, 0x84, 0x11, 0x84, 0xc7, 0x30, 0x62, 0x50,
+  0x18, 0xc1, 0x78, 0x04, 0x39, 0x61, 0xc1, 0x4e, 0xc8, 0xc7, 0x82, 0x9e,
+  0x80, 0xcf, 0x2c, 0x41, 0x19, 0x0c, 0x54, 0x00, 0xca, 0x18, 0x08, 0x64,
+  0x30, 0xc7, 0xe0, 0x16, 0x81, 0x6f, 0x8c, 0x21, 0x30, 0xbd, 0x31, 0xdc,
+  0x10, 0xf4, 0x84, 0x32, 0xcb, 0x70, 0x06, 0x66, 0x10, 0x98, 0xf0, 0x13,
+  0xf2, 0x99, 0x25, 0x40, 0x83, 0x11, 0x03, 0xc2, 0x08, 0xd4, 0x63, 0x18,
+  0x31, 0x28, 0x8c, 0x80, 0x3d, 0x02, 0xb1, 0xb0, 0x80, 0x2c, 0xe4, 0x63,
+  0x81, 0x59, 0xc0, 0x67, 0x96, 0x00, 0x0d, 0x06, 0x2a, 0x00, 0xc5, 0x0c,
+  0x84, 0x33, 0x98, 0x63, 0x48, 0x82, 0xf2, 0x18, 0x43, 0xa8, 0xca, 0x63,
+  0xb8, 0x21, 0x30, 0x0b, 0x65, 0x96, 0x41, 0x0d, 0xd2, 0x20, 0x30, 0x01,
+  0x2d, 0xe4, 0x33, 0x4b, 0xb0, 0x06, 0x23, 0x06, 0x84, 0x11, 0xcc, 0xc7,
+  0x30, 0x62, 0x50, 0x18, 0x41, 0x7d, 0x04, 0x6b, 0x61, 0x41, 0x5b, 0xc8,
+  0xc7, 0x82, 0xb7, 0x80, 0xcf, 0x2c, 0xc1, 0x1a, 0x0c, 0x54, 0x00, 0x4a,
+  0x1a, 0x08, 0x6a, 0x30, 0xc7, 0x90, 0x04, 0xed, 0x31, 0x62, 0x60, 0x18,
+  0xc1, 0x7e, 0x04, 0xa2, 0x01, 0x1a, 0x83, 0x0c, 0x01, 0x69, 0xd4, 0xc6,
+  0x2c, 0x01, 0x1b, 0x0c, 0x54, 0x04, 0x7e, 0x10, 0x06, 0xc2, 0x1a, 0x0c,
+  0x32, 0x04, 0xa9, 0x71, 0x1b, 0xb3, 0x04, 0x6d, 0x30, 0xd0, 0x12, 0xf0,
+  0x88, 0xc1, 0x23, 0x12, 0x8f, 0x7c, 0xb2, 0xc0, 0x06, 0x3c, 0x02, 0x06,
+  0x03, 0x2d, 0x01, 0x8a, 0x18, 0x7a, 0x21, 0x99, 0xc3, 0x47, 0xb0, 0x81,
+  0xcc, 0x80, 0xc1, 0x20, 0x43, 0x20, 0xec, 0x86, 0x05, 0xe1, 0x21, 0x9f,
+  0x0c, 0xc2, 0x81, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xd7, 0xd2, 0x07,
+  0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4, 0x50, 0x13, 0xe7, 0x2c,
+  0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d, 0x9b, 0x6d, 0x29, 0x38,
+  0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b, 0x00, 0x03, 0x11, 0x71,
+  0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71, 0x21, 0x13, 0x00, 0x00,
+  0x00, 0x01, 0x31, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x5b, 0x0a, 0xe0,
+  0x40, 0x05, 0x64, 0x15, 0xb6, 0x0c, 0x42, 0x30, 0x0b, 0x5b, 0x86, 0x23,
+  0xa0, 0x85, 0x2d, 0x83, 0x16, 0xd4, 0xc2, 0x96, 0xe1, 0x0b, 0x6c, 0x61,
+  0xcb, 0x10, 0x06, 0xc1, 0x2d, 0x6c, 0x19, 0xd4, 0x20, 0xc0, 0x85, 0x2d,
+  0xc3, 0x1b, 0x04, 0xb9, 0xb0, 0x65, 0xb0, 0x83, 0x40, 0x17, 0xb6, 0x0c,
+  0x78, 0x10, 0xe4, 0xc2, 0x96, 0x81, 0x1d, 0x02, 0x5d, 0xd8, 0x32, 0xb8,
+  0x43, 0x90, 0x0b, 0x5b, 0x06, 0xb5, 0x08, 0x74, 0x61, 0xcb, 0xc0, 0x16,
+  0x41, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x24, 0x00, 0x00, 0x00, 0x64, 0xce, 0x41, 0x2c, 0x8d, 0x93, 0x06,
+  0x54, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xdb, 0x0c, 0x00, 0x05,
+  0x33, 0x00, 0xb4, 0xcc, 0x00, 0x8c, 0x35, 0xb0, 0xec, 0x19, 0xca, 0x1f,
+  0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce, 0xde, 0x58, 0x83, 0x5e,
+  0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf, 0xdb, 0xa7, 0xf4, 0xe8,
+  0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a, 0xc2, 0xe8, 0xee, 0xdd,
+  0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25,
+  0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f,
+  0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c,
+  0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2,
+  0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05, 0x33, 0x00, 0x04, 0x8c,
+  0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x46, 0x00, 0x82,
+  0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5, 0x02, 0x0d, 0x37, 0x50,
+  0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43, 0x43, 0xb5, 0xc1, 0x20,
+  0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64, 0x08, 0xa0, 0x6a, 0x96,
+  0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61, 0x48, 0x82, 0xe1, 0x86,
+  0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31, 0x28, 0x8c, 0x40, 0x0f,
+  0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xe8, 0x60, 0xc4, 0xa0, 0x30, 0x02, 0x3e,
+  0xf8, 0xa6, 0x39, 0x06, 0x21, 0xa0, 0x83, 0x11, 0x83, 0xc2, 0x08, 0xfc,
+  0x20, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xa8, 0x83, 0x59, 0x82, 0x62, 0xa0,
+  0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xf4, 0x60, 0x0c, 0x41, 0xc8,
+  0x83, 0x31, 0x84, 0x21, 0x0f, 0x46, 0x0c, 0x0a, 0x23, 0x10, 0x05, 0x21,
+  0x18, 0x31, 0x28, 0x8c, 0x60, 0x14, 0x88, 0x60, 0xb8, 0x21, 0xb8, 0x84,
+  0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c, 0x0c, 0x6c, 0x40, 0x03,
+  0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90, 0x8f, 0x05, 0x1a, 0x7c,
+  0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81, 0x29, 0x0c, 0x32, 0x04,
+  0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64, 0x08, 0xd2, 0xc0, 0x0d,
+  0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4, 0xa0, 0x98, 0x65, 0x40,
+  0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18, 0x31, 0x28, 0x8c, 0x60,
+  0x16, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0xa0, 0x15, 0x46, 0x0c, 0x0a,
+  0x23, 0xa8, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84, 0xa0, 0x15, 0x46, 0x0c,
+  0x0a, 0x23, 0xb8, 0x85, 0x42, 0x0d, 0xe6, 0x18, 0x84, 0xc0, 0x15, 0x66,
+  0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57, 0x10, 0x04, 0x04, 0x3a,
+  0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0xc0, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xed, 0x06, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90,
+  0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8,
+  0x88, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00,
+  0x00, 0x51, 0x18, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70,
+  0x80, 0x07, 0x78, 0x90, 0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a,
+  0x70, 0x87, 0x71, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2,
+  0x1d, 0xd2, 0xc1, 0x1d, 0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81,
+  0x1d, 0xda, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1,
+  0x0d, 0xee, 0x21, 0x1d, 0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39,
+  0xc0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74,
+  0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74,
+  0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
+  0xc3, 0x26, 0x10, 0xc0, 0x02, 0x54, 0x43, 0x38, 0xa4, 0x83, 0x3c, 0xb4,
+  0x81, 0x38, 0xd4, 0x83, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0xb8,
+  0xc3, 0x3b, 0xb4, 0x41, 0x38, 0xb0, 0x43, 0x3a, 0x84, 0xc3, 0x3c, 0x00,
+  0x1b, 0xb6, 0xa1, 0x00, 0x16, 0xa0, 0x1a, 0xc2, 0x21, 0x1d, 0xe4, 0xa1,
+  0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0,
+  0x1d, 0xde, 0xa1, 0x0d, 0xc2, 0x81, 0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01,
+  0xd8, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x40, 0x80, 0x05,
+  0xa8, 0x36, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50,
+  0x1b, 0x7c, 0xe4, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a,
+  0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73,
+  0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21,
+  0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41,
+  0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x3c,
+  0xb0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74,
+  0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74,
+  0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
+  0x03, 0x82, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x80, 0x04, 0x54,
+  0x1b, 0x8c, 0x24, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x28, 0x02, 0xb0, 0x00,
+  0xd5, 0x06, 0x64, 0xf9, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09,
+  0xa8, 0x36, 0x18, 0xcc, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50,
+  0x1b, 0xa6, 0xe6, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x01, 0xa4, 0xc1,
+  0x1d, 0xde, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xd2, 0x81, 0x1d, 0xe8, 0x21,
+  0x1d, 0xdc, 0x61, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x07, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42,
+  0x60, 0x4c, 0x08, 0x8e, 0x09, 0x03, 0x92, 0x28, 0x13, 0x86, 0x25, 0x51,
+  0x26, 0x04, 0xcc, 0x84, 0xa0, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x4d, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xc8, 0xc1,
+  0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04,
+  0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84,
+  0x41, 0x18, 0x46, 0x18, 0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xc6, 0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e,
+  0xc2, 0x81, 0x1d, 0xf4, 0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e,
+  0xd2, 0x01, 0x1f, 0x50, 0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe,
+  0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40,
+  0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8,
+  0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0x38,
+  0x4d, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88,
+  0xdf, 0x1e, 0x7e, 0x20, 0x8a, 0x00, 0xec, 0x9f, 0xc6, 0x08, 0x80, 0x41,
+  0x04, 0x26, 0xb8, 0x48, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98,
+  0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x1c, 0xa1, 0x24,
+  0x41, 0x10, 0x08, 0x44, 0xb2, 0x34, 0x0f, 0x41, 0x85, 0x28, 0x8a, 0xa2,
+  0x20, 0xa9, 0x0c, 0x00, 0x00, 0x10, 0x55, 0x04, 0x00, 0x20, 0xab, 0x0c,
+  0x40, 0x51, 0x10, 0x56, 0x8c, 0xa2, 0x00, 0x00, 0x00, 0x20, 0xad, 0x0c,
+  0x45, 0x51, 0x10, 0x57, 0x84, 0xa2, 0x20, 0x6f, 0x8e, 0x00, 0x0c, 0xe6,
+  0x08, 0x82, 0x61, 0x04, 0x01, 0x0c, 0x4a, 0x12, 0x34, 0x8f, 0x00, 0x86,
+  0x62, 0x08, 0xd0, 0x58, 0x90, 0x60, 0x79, 0x84, 0x50, 0x0c, 0x01, 0x2a,
+  0x07, 0x02, 0x52, 0x00, 0x1c, 0x46, 0x18, 0xc0, 0x60, 0x10, 0x21, 0x10,
+  0xe6, 0x08, 0x40, 0x61, 0x10, 0xe1, 0x10, 0x06, 0x11, 0x0a, 0x61, 0x10,
+  0x01, 0x10, 0xa6, 0x00, 0x46, 0x00, 0x86, 0x11, 0x08, 0x30, 0x00, 0x00,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98,
+  0x08, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x04,
+  0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0xa6, 0x02, 0x02,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0x73, 0x01, 0x01, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0xc9, 0x80, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x6c, 0x08, 0x30, 0x0c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x0c, 0x61, 0x2a, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x30, 0x1d, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x43, 0x98, 0x0f, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0x21, 0x4c, 0x07, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10,
+  0x86, 0x0c, 0x80, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2,
+  0x98, 0x01, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x20,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x02, 0x47, 0x00, 0x4a,
+  0xa0, 0x10, 0x0a, 0xa4, 0x08, 0x0a, 0xa2, 0x80, 0x0a, 0x30, 0xa0, 0x0c,
+  0x0a, 0xa3, 0x50, 0x0a, 0xa6, 0x70, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c,
+  0x68, 0x2d, 0x9c, 0x11, 0x80, 0x42, 0x28, 0x88, 0xc2, 0x28, 0x90, 0x42,
+  0x29, 0x18, 0x42, 0xc7, 0x12, 0x24, 0x01, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xd9, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2,
+  0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x18,
+  0x40, 0x67, 0x00, 0xa0, 0x41, 0x19, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93,
+  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x80, 0x41, 0x73, 0x06, 0x02,
+  0x18, 0x38, 0x8c, 0x83, 0x20, 0x38, 0x38, 0xb6, 0x32, 0x90, 0xb6, 0x32,
+  0xba, 0x30, 0x36, 0x10, 0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0x37, 0x90,
+  0x19, 0x19, 0x18, 0x99, 0x19, 0x17, 0x1a, 0x18, 0x1a, 0x10, 0x94, 0xb6,
+  0x32, 0xba, 0x30, 0x36, 0xb3, 0xb2, 0x96, 0x19, 0x19, 0x18, 0x99, 0x19,
+  0x17, 0x1a, 0x18, 0x9a, 0x94, 0x21, 0xc2, 0x19, 0x10, 0x43, 0x0c, 0x30,
+  0x68, 0xc0, 0x20, 0x02, 0x03, 0x86, 0x45, 0x53, 0x19, 0x5d, 0x18, 0xdb,
+  0x10, 0xe4, 0x0c, 0x0e, 0x30, 0x68, 0xc0, 0xa0, 0x01, 0x03, 0x86, 0x5b,
+  0x58, 0x9a, 0x9c, 0xcb, 0xd8, 0x5b, 0x1b, 0x5c, 0x1a, 0x5b, 0x99, 0x0b,
+  0x59, 0x99, 0xdb, 0x9b, 0x5c, 0xdb, 0xdc, 0x17, 0x59, 0xda, 0x5c, 0x98,
+  0x18, 0x5b, 0xd9, 0x10, 0xe1, 0x0c, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x33, 0x58, 0x48, 0x06, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62,
+  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f,
+  0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x33, 0x68, 0x18, 0x85,
+  0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0xb9, 0x91, 0x95, 0xc9, 0x7d, 0xd1, 0x85,
+  0xc9, 0x9d, 0x95, 0xd1, 0x31, 0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b,
+  0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x72, 0x0b, 0x6b, 0x2b, 0xa3, 0x61,
+  0xc6, 0xf6, 0x16, 0x46, 0x47, 0x33, 0x04, 0x39, 0x83, 0x07, 0x0c, 0x98,
+  0x33, 0x80, 0xce, 0x20, 0x1a, 0x22, 0x9c, 0x81, 0x44, 0x26, 0x2c, 0x4d,
+  0xce, 0x05, 0xee, 0x6d, 0x2e, 0x8d, 0x2e, 0xed, 0xcd, 0x8d, 0x4a, 0x58,
+  0x9a, 0x9c, 0xcb, 0x58, 0x99, 0x1b, 0x5d, 0x99, 0x1c, 0xa5, 0xb0, 0x34,
+  0x39, 0x17, 0xb7, 0xb7, 0x2f, 0xb8, 0x32, 0xb9, 0x39, 0xb8, 0xb2, 0x31,
+  0xba, 0x34, 0xbb, 0x32, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6, 0xd2, 0xe8, 0xd2,
+  0xde, 0xdc, 0x86, 0x40, 0x60, 0xc0, 0x9c, 0x01, 0x75, 0x06, 0xd5, 0x19,
+  0x58, 0x67, 0x00, 0x9d, 0x41, 0x74, 0x06, 0xd7, 0x19, 0x60, 0x94, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xcc, 0xe4, 0xc2, 0xce, 0xda, 0xca, 0xdc, 0xe8, 0xbe,
+  0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x68, 0x9d, 0x95, 0xb9, 0x95, 0xc9, 0x85,
+  0xd1, 0x95, 0x91, 0xa1, 0xd4, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x11, 0xd9,
+  0xd1, 0x7c, 0x99, 0xa5, 0xf0, 0x09, 0x4b, 0x93, 0x73, 0x81, 0x2b, 0x93,
+  0x9b, 0x83, 0x2b, 0x1b, 0xa3, 0x4b, 0xb3, 0x2b, 0x63, 0x31, 0xf6, 0xc6,
+  0xf6, 0x26, 0x37, 0x44, 0x02, 0x83, 0xe6, 0x0c, 0xb4, 0x33, 0xd8, 0xce,
+  0xa0, 0x3a, 0x03, 0xee, 0x0c, 0xa0, 0x33, 0x88, 0xce, 0xe0, 0x3a, 0x83,
+  0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a,
+  0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc,
+  0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74,
+  0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0x30, 0x80, 0xce,
+  0x40, 0x3b, 0x83, 0xef, 0x0c, 0xaa, 0x33, 0xe0, 0xce, 0x00, 0x3a, 0x03,
+  0x30, 0x38, 0x83, 0xeb, 0x0c, 0xc2, 0x80, 0x4a, 0x58, 0x9a, 0x9c, 0x8b,
+  0x58, 0x9d, 0x99, 0x59, 0x99, 0x1c, 0x9f, 0xb0, 0x34, 0x39, 0x17, 0xb1,
+  0x3a, 0x33, 0xb3, 0x32, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x4a, 0x61,
+  0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x44, 0xc2, 0xd2, 0xe4, 0x5c, 0xe4, 0xca,
+  0xc2, 0xc8, 0x48, 0x85, 0xa5, 0xc9, 0xb9, 0xcc, 0xd1, 0xc9, 0xd5, 0x8d,
+  0xd1, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0xa5, 0xb9, 0x99, 0xbd, 0xb1,
+  0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x23, 0x33, 0x37, 0x26, 0x75, 0x24, 0xf4,
+  0xf5, 0x56, 0x47, 0x07, 0x57, 0x47, 0x47, 0x86, 0xae, 0x0c, 0x8f, 0xae,
+  0x4e, 0xae, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0x8c, 0x4a, 0x9a, 0x1b, 0x5c,
+  0x1d, 0xdd, 0x17, 0x5d, 0x1e, 0x5c, 0x19, 0x97, 0xb1, 0x37, 0xb6, 0x37,
+  0xb9, 0xaf, 0xb9, 0xb1, 0x30, 0xb6, 0x32, 0x3a, 0x74, 0x6f, 0x6e, 0x65,
+  0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x7c, 0xe8,
+  0xde, 0xdc, 0xca, 0xda, 0xc2, 0xe0, 0xbe, 0xcc, 0xc2, 0xc6, 0xe8, 0xde,
+  0xe4, 0x62, 0xf8, 0xd0, 0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1, 0x7d, 0x99,
+  0x85, 0x8d, 0xd1, 0xbd, 0xc9, 0xc9, 0xf0, 0x99, 0x23, 0x93, 0xfb, 0xba,
+  0x43, 0x4b, 0xa3, 0x2b, 0xfb, 0x82, 0x7b, 0x4b, 0x73, 0xa3, 0x1b, 0x02,
+  0x0b, 0x60, 0xc0, 0x80, 0x81, 0x03, 0x06, 0xcc, 0x19, 0xa0, 0xc1, 0x19,
+  0xa4, 0x01, 0x18, 0x38, 0x60, 0xe0, 0x80, 0x01, 0x73, 0x06, 0x68, 0x70,
+  0x06, 0x6a, 0x00, 0x06, 0x11, 0x18, 0x38, 0x60, 0xc0, 0x9c, 0x01, 0x1a,
+  0x9c, 0xc1, 0x1a, 0x80, 0x41, 0x05, 0x06, 0x0e, 0x18, 0x30, 0x67, 0x80,
+  0x06, 0x67, 0xc0, 0x06, 0x60, 0xf0, 0x80, 0x81, 0x03, 0x06, 0xcc, 0x19,
+  0xa0, 0xc1, 0x19, 0xb4, 0x01, 0x18, 0x58, 0x60, 0xe0, 0x80, 0x01, 0x73,
+  0x06, 0x68, 0x70, 0x06, 0x6e, 0x00, 0x06, 0x17, 0x18, 0x38, 0x60, 0xc0,
+  0x9c, 0x01, 0x1a, 0x9c, 0xc1, 0x1b, 0x80, 0x01, 0x06, 0x06, 0x0e, 0x18,
+  0x30, 0x67, 0x80, 0x06, 0x67, 0x00, 0x07, 0x8c, 0xc2, 0xd2, 0xe4, 0x5c,
+  0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe, 0xe6, 0xd2, 0xf4,
+  0xca, 0x78, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d, 0x7d, 0xd1, 0xe5,
+  0xc1, 0x95, 0x7d, 0x85, 0xb1, 0xa5, 0x9d, 0xb9, 0x7d, 0xcd, 0xa5, 0xe9,
+  0x95, 0xf1, 0x99, 0x42, 0x0b, 0x23, 0x2b, 0x93, 0x1b, 0x7a, 0x73, 0x9b,
+  0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0x63, 0x30, 0x36, 0x84, 0x0c, 0xc0, 0x80,
+  0x3a, 0x83, 0x31, 0x38, 0x03, 0x32, 0x00, 0x03, 0xe9, 0x0c, 0xca, 0x00,
+  0x0c, 0x18, 0x30, 0x68, 0xce, 0xc0, 0x0c, 0xce, 0xe0, 0x0c, 0xce, 0x20,
+  0x0e, 0xce, 0x40, 0x0e, 0xc0, 0x40, 0x3a, 0x83, 0x39, 0x00, 0x03, 0xe7,
+  0x0c, 0xa0, 0x33, 0xa0, 0x83, 0x33, 0xb8, 0xce, 0xa0, 0x0e, 0x68, 0x98,
+  0xb1, 0xbd, 0x85, 0xd1, 0xcd, 0xd0, 0x78, 0x33, 0x33, 0x9b, 0x2b, 0xa3,
+  0x23, 0x62, 0xc6, 0xf6, 0x16, 0x46, 0x37, 0x83, 0x37, 0x43, 0xa3, 0x2d,
+  0x8c, 0x4e, 0x2e, 0x0d, 0x6f, 0x08, 0x05, 0x06, 0x0c, 0x18, 0x3c, 0x60,
+  0xc0, 0x9c, 0xc1, 0x1d, 0x9c, 0x01, 0x1e, 0x80, 0xc1, 0x03, 0x06, 0x19,
+  0x18, 0x30, 0x67, 0x90, 0x07, 0x67, 0xa0, 0x07, 0x4c, 0xb2, 0xaa, 0xac,
+  0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91,
+  0x95, 0x0d, 0x21, 0x03, 0x30, 0x70, 0xce, 0x60, 0x0c, 0xce, 0x80, 0x0c,
+  0xc0, 0x60, 0x3a, 0x83, 0x32, 0x00, 0x83, 0x06, 0x0c, 0x9a, 0x33, 0x30,
+  0x83, 0x33, 0x38, 0x83, 0x33, 0xd8, 0x83, 0x33, 0x90, 0x03, 0x30, 0x98,
+  0xce, 0x60, 0x0e, 0xc0, 0xe0, 0x39, 0x03, 0xe8, 0x0c, 0xf8, 0xe0, 0x0c,
+  0xae, 0x33, 0xe8, 0x03, 0x2e, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78,
+  0x74, 0x75, 0x72, 0x65, 0x54, 0xc2, 0xd2, 0xe4, 0x5c, 0xe6, 0xc2, 0xda,
+  0xe0, 0xd8, 0xca, 0x88, 0xd1, 0x95, 0xe1, 0xd1, 0xd5, 0xc9, 0x95, 0xc9,
+  0x90, 0xf1, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xb1, 0x80, 0xcc, 0x85, 0xb5,
+  0xc1, 0xb1, 0x95, 0xf9, 0x90, 0xa0, 0x2b, 0xc3, 0xcb, 0x1a, 0x42, 0x81,
+  0x81, 0x76, 0x06, 0x7f, 0x70, 0x06, 0x65, 0x00, 0x06, 0x0c, 0x18, 0x34,
+  0x67, 0x00, 0x0a, 0x67, 0x00, 0x9d, 0x41, 0x28, 0x9c, 0xc1, 0x75, 0x06,
+  0xa2, 0x40, 0x8f, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0xec,
+  0x2b, 0x4c, 0x4e, 0x2e, 0x2c, 0x8f, 0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e,
+  0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87, 0x05, 0x5d, 0x19,
+  0x5e, 0x95, 0xd5, 0x10, 0x0a, 0x0c, 0xb6, 0x33, 0xf8, 0x83, 0x33, 0x28,
+  0x03, 0x30, 0x68, 0xc0, 0xa0, 0x39, 0x03, 0x50, 0x38, 0x03, 0xe8, 0x0c,
+  0x48, 0xe1, 0x0c, 0xae, 0x33, 0x28, 0x05, 0x2e, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x3c, 0xe6, 0xc2, 0xda, 0xe0,
+  0xd8, 0xca, 0xe4, 0x18, 0xcc, 0x0d, 0x91, 0xc0, 0x80, 0x3b, 0x83, 0x53,
+  0x38, 0x83, 0x32, 0x00, 0x03, 0x06, 0x0c, 0x9a, 0x33, 0x80, 0xce, 0x00,
+  0x15, 0xce, 0xe0, 0x3a, 0x83, 0x54, 0x18, 0x02, 0x9d, 0x41, 0x76, 0x06,
+  0xde, 0x19, 0x88, 0xc1, 0x19, 0xd8, 0xc1, 0x19, 0xf8, 0xc1, 0x19, 0x8c,
+  0xc2, 0x19, 0x98, 0xc2, 0x19, 0xa8, 0xc2, 0x10, 0x23, 0x02, 0xce, 0x60,
+  0x3a, 0x83, 0x55, 0xa0, 0x18, 0x84, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5,
+  0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xcd, 0xa1, 0x4c, 0x11,
+  0x31, 0x7d, 0x65, 0x55, 0x59, 0x7d, 0x99, 0xc9, 0x85, 0x9d, 0xb5, 0x95,
+  0xb9, 0xd1, 0xa5, 0x0c, 0x21, 0xce, 0xc0, 0x15, 0xce, 0xa0, 0x15, 0x88,
+  0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d,
+  0xbd, 0xc1, 0x95, 0xb5, 0xd0, 0x95, 0xe1, 0xd1, 0xd5, 0xc9, 0x95, 0xcd,
+  0x0d, 0x31, 0xce, 0x00, 0x16, 0xce, 0xc0, 0x15, 0xce, 0xe0, 0x15, 0x88,
+  0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d,
+  0xbd, 0xc1, 0x95, 0xb5, 0xcc, 0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xcd,
+  0x0d, 0x31, 0xce, 0x40, 0x16, 0xce, 0xc0, 0x15, 0xce, 0x20, 0x16, 0x86,
+  0x10, 0x67, 0x00, 0x0b, 0x67, 0x20, 0x0b, 0xb4, 0xc2, 0xd2, 0xe4, 0x5a,
+  0xc2, 0xd8, 0xd2, 0xc2, 0xe6, 0x5a, 0xe6, 0xc6, 0xde, 0xe0, 0xca, 0x5a,
+  0xc2, 0xe4, 0xce, 0x50, 0x66, 0x52, 0x86, 0x18, 0x67, 0x50, 0x0b, 0x67,
+  0xe0, 0x0a, 0x67, 0x40, 0x0b, 0xb4, 0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8,
+  0xd2, 0xc2, 0xe6, 0x5a, 0xe6, 0xc6, 0xde, 0xe0, 0xca, 0x5a, 0xc2, 0xe4,
+  0xce, 0x50, 0x68, 0x52, 0x86, 0x18, 0x67, 0x70, 0x0b, 0x67, 0xe0, 0x0a,
+  0x67, 0x60, 0x0b, 0x43, 0x88, 0x33, 0xa8, 0x85, 0x33, 0xb8, 0x85, 0x21,
+  0xc2, 0x19, 0xdc, 0xc2, 0x10, 0xe3, 0x0c, 0x6a, 0xe1, 0x0c, 0x60, 0xe1,
+  0x0c, 0x64, 0x81, 0xd5, 0x97, 0x16, 0xd5, 0x54, 0x4c, 0xcd, 0x14, 0x5a,
+  0x18, 0x59, 0x99, 0xdc, 0xd0, 0x9b, 0xdb, 0x1c, 0x5d, 0x98, 0x1b, 0xdd,
+  0x1c, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32, 0x37, 0x3a,
+  0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65,
+  0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43, 0x84, 0x33,
+  0xe8, 0x85, 0x21, 0xc6, 0x19, 0xf0, 0xc2, 0x19, 0xf8, 0xc2, 0x1a, 0x78,
+  0x43, 0x8c, 0x33, 0x40, 0x83, 0x33, 0xf8, 0x85, 0x35, 0xf0, 0x86, 0x88,
+  0xc1, 0x19, 0xec, 0xc2, 0x19, 0x80, 0xc3, 0x1a, 0x78, 0x67, 0x00, 0x0e,
+  0x6b, 0xf0, 0x9d, 0x01, 0x38, 0xac, 0x01, 0x18, 0x9c, 0x01, 0x38, 0xac,
+  0x41, 0x18, 0x9c, 0x01, 0x38, 0xac, 0x81, 0x18, 0x9c, 0x01, 0x38, 0xac,
+  0xc1, 0x18, 0x9c, 0x01, 0x38, 0xac, 0x01, 0x19, 0x9c, 0x01, 0x38, 0xac,
+  0x41, 0x37, 0xc4, 0x38, 0x83, 0x70, 0x38, 0x03, 0x70, 0x58, 0x03, 0x30,
+  0x18, 0x62, 0x9c, 0x41, 0x38, 0x9c, 0x01, 0x38, 0xac, 0x41, 0x37, 0xc4,
+  0x38, 0x83, 0x70, 0x38, 0x03, 0x70, 0x58, 0x03, 0x31, 0x18, 0x62, 0x9c,
+  0x41, 0x38, 0x9c, 0x01, 0x38, 0xac, 0xc1, 0x18, 0x0c, 0x31, 0xce, 0x20,
+  0x1c, 0xce, 0x00, 0x1c, 0xd6, 0x80, 0x0c, 0x86, 0x18, 0x67, 0x10, 0x0e,
+  0x67, 0x00, 0x0e, 0x6b, 0xf0, 0x0d, 0x31, 0xce, 0x20, 0x1c, 0xce, 0x00,
+  0x1c, 0xd6, 0x20, 0x0c, 0x86, 0x18, 0x67, 0x10, 0x0e, 0x67, 0x00, 0x0e,
+  0x6b, 0xe0, 0x8d, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0,
+  0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81,
+  0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77,
+  0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37,
+  0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29,
+  0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70,
+  0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b,
+  0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20,
+  0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76,
+  0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a,
+  0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82,
+  0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73,
+  0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xb0, 0x02, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x35, 0x00, 0x00, 0x00, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf,
+  0xb3, 0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45,
+  0x51, 0x14, 0x96, 0x30, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05,
+  0x03, 0x5c, 0x7e, 0x75, 0x17, 0xb7, 0x6d, 0x01, 0x14, 0x80, 0x44, 0x7e,
+  0x01, 0x48, 0xd3, 0x2f, 0x2c, 0x00, 0xf3, 0xf8, 0xd5, 0x5d, 0xdc, 0xb6,
+  0x09, 0x40, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0xff, 0xe3, 0x58, 0x7e,
+  0x71, 0xdb, 0x36, 0x10, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05,
+  0x10, 0x48, 0x7e, 0x71, 0xdb, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17, 0x80,
+  0x34, 0xfd, 0x8f, 0x63, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x29, 0x84, 0x01,
+  0x80, 0x44, 0xbe, 0x04, 0x30, 0xcf, 0x42, 0xfc, 0x13, 0x71, 0x4d, 0x54,
+  0x44, 0xfc, 0xf6, 0xf0, 0x03, 0x51, 0x04, 0x60, 0x7e, 0x85, 0x17, 0xb7,
+  0x6d, 0x04, 0x0d, 0x80, 0x44, 0xfe, 0xe0, 0x4c, 0x7e, 0x75, 0x17, 0xb7,
+  0x6d, 0x0b, 0x1b, 0x80, 0x44, 0xbe, 0x04, 0x30, 0xcf, 0x42, 0xfc, 0x13,
+  0x71, 0x4d, 0x54, 0x44, 0xfc, 0xf6, 0xe0, 0x57, 0x78, 0x71, 0xdb, 0x86,
+  0x30, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05, 0x10, 0x48, 0x7e,
+  0x75, 0x17, 0xb7, 0x6d, 0x00, 0x10, 0xdb, 0x95, 0xbf, 0xec, 0xbe, 0x7f,
+  0x11, 0x01, 0x06, 0x43, 0x34, 0x93, 0x19, 0x44, 0x00, 0x12, 0xf9, 0x05,
+  0x20, 0x4d, 0x7f, 0xc1, 0x00, 0x97, 0x5f, 0xdc, 0x36, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0xd4, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e,
+  0x10, 0x0b, 0x04, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x14, 0x8f, 0x45,
+  0x00, 0x81, 0x70, 0xcc, 0x41, 0x30, 0x0d, 0x84, 0x07, 0xb4, 0x16, 0x41,
+  0x09, 0x50, 0x3a, 0xc7, 0xc0, 0xe0, 0x01, 0x1e, 0x8c, 0x00, 0x8c, 0x35,
+  0x00, 0x81, 0x40, 0xe2, 0x08, 0x00, 0x85, 0x23, 0x00, 0x35, 0x40, 0xe0,
+  0x0c, 0x00, 0x01, 0x63, 0x04, 0xef, 0x9e, 0x96, 0xf7, 0x37, 0x46, 0xa0,
+  0xb3, 0xe6, 0x1c, 0x82, 0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x09, 0x06,
+  0x63, 0x04, 0x20, 0x08, 0x82, 0x20, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03,
+  0x30, 0x03, 0x30, 0x07, 0x21, 0x0b, 0xb2, 0x20, 0x0b, 0xb3, 0x30, 0x07,
+  0x31, 0x0b, 0xb9, 0x30, 0x0b, 0x7d, 0x40, 0xc5, 0x0c, 0xc0, 0x08, 0xc0,
+  0x0c, 0xc0, 0x58, 0x03, 0x08, 0x82, 0x20, 0xfe, 0x81, 0x20, 0x08, 0xe2,
+  0x1f, 0x08, 0x82, 0x20, 0xfe, 0x8d, 0x35, 0xb0, 0xed, 0xfc, 0x93, 0x1e,
+  0xdb, 0xce, 0x3f, 0xe9, 0xb1, 0xed, 0xfc, 0x93, 0xde, 0x58, 0x03, 0x08,
+  0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8,
+  0xd6, 0xbf, 0x30, 0xd6, 0x00, 0x82, 0xe0, 0x9a, 0x83, 0x01, 0x08, 0x82,
+  0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x8c, 0x35, 0x80, 0x20,
+  0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d,
+  0x0e, 0x06, 0x63, 0x0d, 0xeb, 0x88, 0xc7, 0x2c, 0x18, 0xac, 0x23, 0x1e,
+  0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x58, 0x03, 0x08, 0xc2,
+  0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87,
+  0x63, 0x30, 0xd6, 0x20, 0xe6, 0x62, 0xda, 0x7f, 0x60, 0xc9, 0xb3, 0xf1,
+  0x2f, 0x8c, 0xe9, 0xaa, 0xe6, 0xbe, 0x30, 0xd6, 0xf0, 0xcf, 0xa4, 0xff,
+  0xfb, 0x02, 0x5d, 0x83, 0x62, 0xfe, 0xb5, 0x70, 0x1c, 0x83, 0xbe, 0x30,
+  0xd6, 0x30, 0xf7, 0x6d, 0x9a, 0xfa, 0x42, 0xeb, 0x86, 0x3c, 0xef, 0x0b,
+  0x7c, 0xce, 0xfa, 0xf8, 0x47, 0xc0, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed,
+  0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0x79, 0xaf, 0xab,
+  0xec, 0xcd, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81,
+  0xdb, 0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba, 0xf8, 0x37,
+  0x46, 0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8, 0xf6, 0x34,
+  0x18, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x23, 0x06, 0x4a, 0x11, 0xbc, 0xc2, 0x1b, 0xb4, 0x81, 0x1c, 0x8c,
+  0x41, 0x19, 0x90, 0x41, 0x30, 0x62, 0xb0, 0x14, 0x41, 0x2c, 0xbc, 0x81,
+  0x1b, 0xcc, 0xc1, 0x2b, 0x90, 0x81, 0x19, 0x94, 0x81, 0x30, 0x86, 0x10,
+  0xc0, 0xc2, 0x20, 0xc3, 0xe0, 0xad, 0xc1, 0x1c, 0x43, 0x20, 0xc4, 0xc2,
+  0x88, 0xc1, 0x52, 0x04, 0xb5, 0x30, 0x07, 0x72, 0x70, 0x07, 0xb2, 0x80,
+  0x06, 0x6a, 0x90, 0x06, 0xc6, 0x18, 0x42, 0x40, 0x0b, 0x73, 0x0c, 0x43,
+  0x10, 0x0b, 0x87, 0x07, 0xea, 0x52, 0x50, 0x06, 0x19, 0x02, 0x33, 0x80,
+  0x03, 0x23, 0x02, 0xf8, 0x8c, 0x37, 0xf0, 0x01, 0x2a, 0xe4, 0xc2, 0x05,
+  0xea, 0x52, 0x50, 0x06, 0x19, 0x82, 0x35, 0xa8, 0x83, 0x11, 0x83, 0xc2,
+  0x08, 0xcc, 0xa1, 0x08, 0xc6, 0x2b, 0x42, 0xa1, 0x15, 0x7c, 0xe1, 0x17,
+  0xf4, 0xe0, 0x02, 0x75, 0x29, 0x28, 0x83, 0x0c, 0x01, 0x1c, 0xe8, 0xc1,
+  0x88, 0x41, 0x61, 0x04, 0xeb, 0xa0, 0x04, 0xe3, 0x15, 0xa6, 0x20, 0x0b,
+  0xe3, 0x40, 0x0e, 0xa0, 0x70, 0x81, 0xba, 0x14, 0x94, 0x41, 0x86, 0xa0,
+  0x0e, 0xfe, 0x60, 0xc4, 0xa0, 0x30, 0x02, 0x78, 0x78, 0x82, 0x39, 0x86,
+  0x3a, 0x58, 0xd2, 0x61, 0x8e, 0x21, 0x38, 0xd2, 0x61, 0x8e, 0x21, 0x18,
+  0xce, 0x61, 0xbc, 0xe1, 0x15, 0x74, 0x01, 0x1d, 0x28, 0x18, 0xc3, 0x0d,
+  0xc1, 0x1f, 0x04, 0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0x10, 0x7d, 0x70,
+  0x0a, 0xe3, 0x0d, 0xb3, 0xe0, 0x0b, 0xe0, 0x40, 0xc1, 0x18, 0x31, 0x20,
+  0x8c, 0xc0, 0x1e, 0x86, 0x11, 0x83, 0xc2, 0x08, 0xf0, 0x21, 0xc8, 0x03,
+  0x0b, 0xf2, 0x00, 0x3e, 0x23, 0x06, 0x85, 0x11, 0xe0, 0x43, 0xe0, 0x07,
+  0x36, 0xe8, 0x81, 0x7c, 0x4c, 0x0f, 0x82, 0xf8, 0xd8, 0x10, 0xd0, 0x67,
+  0xc4, 0x80, 0x30, 0x82, 0x7e, 0x08, 0x46, 0x0c, 0x0a, 0x23, 0xf8, 0x87,
+  0x80, 0x0f, 0x2c, 0xe0, 0x03, 0xf9, 0xcc, 0x31, 0x98, 0xc2, 0xc2, 0x0f,
+  0x83, 0x0c, 0xc1, 0x29, 0xd8, 0x82, 0x0d, 0x01, 0x7d, 0x06, 0x19, 0x82,
+  0x54, 0xe0, 0x85, 0x41, 0x86, 0xa0, 0xf2, 0x85, 0x59, 0x02, 0x61, 0xa0,
+  0x22, 0x10, 0x02, 0x36, 0x00, 0xc6, 0x1b, 0xca, 0x01, 0x1e, 0x40, 0x82,
+  0x82, 0x31, 0xdc, 0x10, 0xdc, 0x81, 0x33, 0xcb, 0x30, 0x10, 0xc1, 0x20,
+  0x03, 0x31, 0x0b, 0xbd, 0x30, 0xde, 0x90, 0x0e, 0xf4, 0x80, 0x0f, 0x14,
+  0x8c, 0xf1, 0x86, 0x75, 0xb0, 0x87, 0x7c, 0xa0, 0x60, 0x8c, 0x18, 0x20,
+  0x47, 0x14, 0x13, 0x45, 0x77, 0x0c, 0xc1, 0x20, 0x43, 0x50, 0x0b, 0xe8,
+  0x30, 0xc8, 0x10, 0x2c, 0xea, 0x30, 0x4b, 0x40, 0x0c, 0x54, 0x04, 0xc2,
+  0x80, 0x09, 0xc3, 0x0d, 0x61, 0x70, 0x0a, 0xc1, 0x2c, 0x43, 0x31, 0x05,
+  0xe3, 0x0d, 0xf2, 0xd0, 0x0f, 0x2e, 0x41, 0xc1, 0x18, 0x6e, 0x08, 0x54,
+  0x21, 0x98, 0x65, 0x30, 0x8e, 0x60, 0x90, 0xa1, 0x00, 0x07, 0x75, 0x18,
+  0x6f, 0xb0, 0x87, 0x90, 0x58, 0x09, 0x0a, 0xc6, 0x1c, 0xc3, 0x2f, 0x04,
+  0x35, 0x31, 0xc8, 0x10, 0x80, 0xc3, 0x3b, 0x58, 0x50, 0xc8, 0x67, 0x90,
+  0x21, 0x10, 0x87, 0x7a, 0x98, 0x25, 0x68, 0x83, 0xf1, 0x06, 0x7e, 0x38,
+  0x89, 0x9c, 0xa0, 0x60, 0x8c, 0x37, 0xf8, 0x43, 0x4a, 0xcc, 0x04, 0x05,
+  0x63, 0x90, 0x01, 0x5a, 0x07, 0x7d, 0x18, 0x6e, 0x20, 0x62, 0xc1, 0x99,
+  0x65, 0x40, 0xa4, 0x60, 0x0c, 0x41, 0xfa, 0x89, 0xe1, 0x86, 0x60, 0x17,
+  0x94, 0x59, 0x06, 0x25, 0x09, 0x4c, 0xe8, 0x05, 0xf9, 0xcc, 0x12, 0x2c,
+  0x36, 0xfc, 0x02, 0x7c, 0x46, 0x0c, 0x08, 0x23, 0x60, 0x8b, 0xc0, 0x82,
+  0x7b, 0x90, 0xcf, 0x88, 0x41, 0x61, 0x04, 0x6f, 0x11, 0xdc, 0xc3, 0x2c,
+  0xc1, 0x32, 0x50, 0x01, 0x28, 0x89, 0xa0, 0xcc, 0x31, 0xd0, 0x43, 0x70,
+  0x16, 0x63, 0x08, 0xdb, 0x59, 0x0c, 0x37, 0x04, 0xe4, 0xa0, 0xcc, 0x32,
+  0x34, 0x4c, 0x60, 0x82, 0x39, 0xc8, 0x67, 0x96, 0xc0, 0xb1, 0x01, 0x1d,
+  0xe0, 0x33, 0x62, 0x40, 0x18, 0x41, 0x5d, 0x04, 0x16, 0x80, 0x84, 0x7c,
+  0x46, 0x0c, 0x0a, 0x23, 0xc0, 0x8b, 0x00, 0x24, 0x66, 0x09, 0x9c, 0x81,
+  0x0a, 0x40, 0x61, 0x84, 0x66, 0x8e, 0x21, 0x09, 0xde, 0x62, 0x0c, 0x81,
+  0x0c, 0xda, 0x62, 0xb8, 0x21, 0x68, 0x07, 0x65, 0x96, 0x01, 0x7a, 0x02,
+  0x13, 0xde, 0x41, 0x3e, 0xb3, 0x04, 0x91, 0x0d, 0xf1, 0x00, 0x9f, 0x11,
+  0x03, 0xc2, 0x08, 0xfc, 0x22, 0xb0, 0x20, 0x25, 0xe4, 0x33, 0x62, 0x50,
+  0x18, 0x41, 0x68, 0x04, 0x29, 0x31, 0x4b, 0x10, 0x0d, 0x54, 0x00, 0xca,
+  0x23, 0x40, 0x73, 0x0c, 0x49, 0x50, 0x17, 0xb3, 0x04, 0xd2, 0x40, 0x45,
+  0x20, 0x44, 0x7a, 0x70, 0x0c, 0x32, 0x04, 0x29, 0x31, 0x13, 0x73, 0x0c,
+  0x26, 0x01, 0x06, 0x7c, 0x31, 0xc8, 0x10, 0x9c, 0x84, 0x4d, 0xd8, 0x10,
+  0xc8, 0x67, 0x90, 0x21, 0x48, 0x09, 0x9e, 0x98, 0x25, 0x68, 0x83, 0xe1,
+  0x86, 0x59, 0x80, 0x89, 0x60, 0x96, 0x81, 0x02, 0x83, 0x60, 0x90, 0x81,
+  0x0e, 0x5e, 0x22, 0x27, 0xc6, 0x1b, 0xca, 0x02, 0x2e, 0x44, 0x83, 0x82,
+  0x31, 0xde, 0x70, 0x16, 0x72, 0xc1, 0x17, 0x14, 0x8c, 0x39, 0x06, 0x98,
+  0x08, 0x4c, 0x63, 0x90, 0x21, 0x88, 0x09, 0xb0, 0xb0, 0xe0, 0x90, 0xcf,
+  0x20, 0x43, 0x30, 0x13, 0x66, 0x31, 0xdc, 0x70, 0xf4, 0x83, 0x33, 0xcb,
+  0xf0, 0x55, 0xc1, 0x18, 0xc2, 0xb0, 0x1a, 0xc3, 0x0d, 0x01, 0x48, 0x28,
+  0xb3, 0x0c, 0x97, 0x15, 0x98, 0x20, 0x12, 0xf2, 0x99, 0x25, 0xc0, 0x46,
+  0x0c, 0x08, 0x23, 0xb8, 0x8d, 0x61, 0xc4, 0xa0, 0x30, 0x82, 0xdc, 0x08,
+  0x4a, 0xc2, 0x82, 0x93, 0x90, 0x8f, 0x05, 0x29, 0x01, 0x9f, 0x59, 0x02,
+  0x6c, 0xa0, 0x02, 0x50, 0x2c, 0xe1, 0x9a, 0x63, 0xd8, 0x89, 0x60, 0x36,
+  0xc6, 0x10, 0x98, 0xd9, 0x18, 0x6e, 0x08, 0x52, 0x42, 0x99, 0x65, 0xd0,
+  0xb2, 0xc0, 0x84, 0x95, 0x90, 0xcf, 0x2c, 0xc1, 0x36, 0x62, 0x40, 0x18,
+  0x01, 0x78, 0x0c, 0x23, 0x06, 0x85, 0x11, 0x88, 0x47, 0xe0, 0x12, 0x16,
+  0xc0, 0x84, 0x7c, 0x2c, 0x90, 0x09, 0xf8, 0xcc, 0x12, 0x6c, 0x03, 0x15,
+  0x80, 0x92, 0x09, 0xda, 0x1c, 0x43, 0x12, 0xec, 0xc6, 0x18, 0x42, 0x95,
+  0x1b, 0xc3, 0x0d, 0x81, 0x4c, 0x28, 0xb3, 0x0c, 0x1d, 0x17, 0x98, 0x40,
+  0x13, 0xf2, 0x99, 0x25, 0xf0, 0x46, 0x0c, 0x08, 0x23, 0x48, 0x8f, 0x61,
+  0xc4, 0xa0, 0x30, 0x82, 0xf5, 0x08, 0x6e, 0xc2, 0x82, 0x9c, 0x90, 0x8f,
+  0x05, 0x3b, 0x01, 0x9f, 0x59, 0x02, 0x6f, 0xa0, 0x02, 0x50, 0x38, 0xa1,
+  0x9b, 0x63, 0x48, 0x82, 0xf0, 0x18, 0x31, 0x30, 0x8c, 0x20, 0x3e, 0x82,
+  0xb7, 0x68, 0x8b, 0x41, 0x86, 0x20, 0x2e, 0x48, 0x63, 0x96, 0xe0, 0x1b,
+  0xa8, 0x08, 0xfc, 0x80, 0x12, 0xbc, 0x41, 0x86, 0xe0, 0x2e, 0x4c, 0x63,
+  0x96, 0xa0, 0x0d, 0x66, 0x19, 0xc2, 0xa0, 0x0d, 0xf8, 0x61, 0x90, 0xa1,
+  0x17, 0xf0, 0x42, 0x34, 0x46, 0x0c, 0x0a, 0x23, 0x98, 0x8f, 0x60, 0x2d,
+  0xe6, 0x18, 0xe8, 0x22, 0x60, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0xea, 0x63,
+  0x60, 0x8b, 0x39, 0x06, 0x21, 0x68, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0xee,
+  0xa3, 0x68, 0x8b, 0x39, 0x06, 0x21, 0x60, 0x8f, 0x41, 0x86, 0x60, 0x2f,
+  0x5c, 0x63, 0x90, 0x21, 0x28, 0x07, 0xd8, 0x18, 0x6f, 0xb0, 0x8d, 0xf0,
+  0x98, 0x0f, 0x0a, 0xc6, 0x78, 0x03, 0x6e, 0x8c, 0x47, 0x7b, 0x50, 0x30,
+  0xe6, 0x18, 0x42, 0x23, 0xb8, 0x8f, 0x41, 0x86, 0x40, 0x34, 0x62, 0xc3,
+  0x82, 0x44, 0x3e, 0x83, 0x0c, 0x01, 0x69, 0xdc, 0xc6, 0x70, 0xc3, 0xe1,
+  0x16, 0xce, 0x2c, 0x03, 0x1b, 0x88, 0x41, 0x30, 0x86, 0x30, 0xf0, 0xc7,
+  0x70, 0x43, 0x10, 0x17, 0xca, 0x2c, 0x03, 0x19, 0x8c, 0x41, 0x60, 0xc2,
+  0x5c, 0xc8, 0x67, 0x96, 0xa0, 0x0c, 0x46, 0x0c, 0x08, 0x23, 0x40, 0x91,
+  0x61, 0xc4, 0xa0, 0x30, 0x02, 0x15, 0x09, 0xec, 0xc2, 0x02, 0xbc, 0x90,
+  0x8f, 0x05, 0x7a, 0x01, 0x9f, 0x59, 0x82, 0x32, 0x18, 0xa8, 0x00, 0x94,
+  0x31, 0x10, 0xc8, 0x60, 0x8e, 0x81, 0x35, 0x02, 0x12, 0x19, 0x43, 0x60,
+  0x48, 0x64, 0xb8, 0x21, 0xd0, 0x0b, 0x65, 0x96, 0xe1, 0x0c, 0xcc, 0x20,
+  0x30, 0x81, 0x2f, 0xe4, 0x33, 0x4b, 0x80, 0x06, 0x23, 0x06, 0x84, 0x11,
+  0xc4, 0xc8, 0x30, 0x62, 0x50, 0x18, 0xc1, 0x8c, 0x04, 0x7f, 0x61, 0x41,
+  0x68, 0xc8, 0xc7, 0x82, 0xd1, 0x80, 0xcf, 0x2c, 0x01, 0x1a, 0x0c, 0x54,
+  0x00, 0x8a, 0x19, 0x08, 0x67, 0x30, 0xc7, 0x90, 0x04, 0x2c, 0x32, 0x86,
+  0x50, 0xa9, 0xc8, 0x70, 0x43, 0x30, 0x1a, 0xca, 0x2c, 0x83, 0x1a, 0xa4,
+  0x41, 0x60, 0x42, 0x69, 0xc8, 0x67, 0x96, 0x60, 0x0d, 0x46, 0x0c, 0x08,
+  0x23, 0xd0, 0x91, 0x61, 0xc4, 0xa0, 0x30, 0x02, 0x1e, 0x09, 0x50, 0xc3,
+  0x02, 0xd5, 0x90, 0x8f, 0x05, 0xac, 0x01, 0x9f, 0x59, 0x82, 0x35, 0x18,
+  0xa8, 0x00, 0x94, 0x34, 0x10, 0xd4, 0x60, 0x8e, 0x21, 0x09, 0x64, 0x64,
+  0xc4, 0xc0, 0x30, 0x02, 0x31, 0x09, 0xc0, 0xc3, 0x37, 0x06, 0x19, 0x02,
+  0xf1, 0xa8, 0x8f, 0x59, 0x02, 0x36, 0x18, 0xa8, 0x08, 0xfc, 0x20, 0x0c,
+  0x84, 0x35, 0x18, 0x64, 0x08, 0xd0, 0xe3, 0x3e, 0x66, 0x09, 0xda, 0x60,
+  0xa0, 0x25, 0xe0, 0x11, 0x83, 0x47, 0x24, 0x1e, 0xf9, 0x64, 0x81, 0x0d,
+  0x78, 0x04, 0x0c, 0x06, 0x5a, 0x02, 0x14, 0x31, 0xf4, 0x42, 0x32, 0x87,
+  0x8f, 0x60, 0x03, 0xd7, 0x01, 0x83, 0x41, 0x86, 0x40, 0xd8, 0x0f, 0x0b,
+  0x46, 0x44, 0x3e, 0x19, 0x84, 0x03, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0xd7, 0xd2, 0x07, 0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4,
+  0x50, 0x13, 0xe7, 0x2c, 0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d,
+  0x9b, 0x6d, 0x29, 0x38, 0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b,
+  0x00, 0x03, 0x11, 0x71, 0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71,
+  0x21, 0x13, 0x00, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x5b, 0x0a, 0xe0, 0x98, 0x05, 0x04, 0x17, 0xb6, 0x14, 0xc1, 0x31,
+  0x0b, 0x08, 0x2e, 0x6c, 0x29, 0x8a, 0x63, 0x16, 0x10, 0x5c, 0xd8, 0x52,
+  0x24, 0x47, 0x2e, 0x20, 0xba, 0xb0, 0xa5, 0x70, 0x8e, 0x5c, 0x40, 0x74,
+  0x61, 0x4b, 0x31, 0x1d, 0xb9, 0x80, 0xe8, 0xc2, 0x96, 0x02, 0x3b, 0x72,
+  0x01, 0xd1, 0x85, 0x2d, 0xc3, 0x17, 0x88, 0xc3, 0x96, 0x81, 0x0c, 0x82,
+  0x71, 0xd8, 0x32, 0xdc, 0x41, 0x40, 0x0e, 0x5b, 0x06, 0x3e, 0x08, 0xca,
+  0x61, 0xcb, 0xe0, 0x07, 0x81, 0x39, 0x6c, 0x19, 0x4e, 0x21, 0x38, 0x87,
+  0x2d, 0x03, 0x2b, 0x04, 0xe8, 0xb0, 0x65, 0x98, 0x85, 0x20, 0x1d, 0xb6,
+  0x0c, 0xb5, 0x10, 0xa0, 0xc3, 0x96, 0x21, 0x25, 0x82, 0x74, 0xd8, 0x32,
+  0xac, 0x44, 0x80, 0x0e, 0x5b, 0x86, 0xd3, 0x08, 0xd2, 0x61, 0xcb, 0x90,
+  0x1a, 0x01, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x24, 0x00, 0x00, 0x00, 0x14, 0xcf, 0x41, 0x30, 0x0d, 0xe4, 0x06,
+  0x94, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xe0, 0x0c, 0x00, 0x05,
+  0x33, 0x00, 0x54, 0xcc, 0x00, 0x8c, 0x35, 0xb0, 0xec, 0x19, 0xca, 0x1f,
+  0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce, 0xde, 0x58, 0x83, 0x5e,
+  0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf, 0xdb, 0xa7, 0xf4, 0xe8,
+  0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a, 0xc2, 0xe8, 0xee, 0xdd,
+  0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25,
+  0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f,
+  0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c,
+  0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2,
+  0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05, 0x33, 0x00, 0x04, 0x8c,
+  0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x46, 0x00, 0x82,
+  0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5, 0x02, 0x0d, 0x37, 0x50,
+  0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43, 0x43, 0xc5, 0xc1, 0x20,
+  0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64, 0x08, 0xa0, 0x6a, 0x96,
+  0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61, 0x48, 0x82, 0xe1, 0x86,
+  0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31, 0x28, 0x8c, 0xe0, 0x0f,
+  0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xf0, 0x60, 0xc4, 0xa0, 0x30, 0x82, 0x50,
+  0xf8, 0xa6, 0x39, 0x06, 0x21, 0xc8, 0x83, 0x11, 0x83, 0xc2, 0x08, 0x46,
+  0x21, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xc0, 0x83, 0x59, 0x82, 0x62, 0xa0,
+  0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xfc, 0x60, 0x0c, 0x41, 0xf0,
+  0x83, 0x31, 0x84, 0x81, 0x0f, 0x46, 0x0c, 0x0a, 0x23, 0x38, 0x05, 0x21,
+  0x18, 0x31, 0x28, 0x8c, 0x00, 0x15, 0x88, 0x60, 0xb8, 0x21, 0xb8, 0x84,
+  0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c, 0x0c, 0x6c, 0x40, 0x03,
+  0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90, 0x8f, 0x05, 0x1a, 0x7c,
+  0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81, 0x2a, 0x0c, 0x32, 0x04,
+  0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64, 0x08, 0xd2, 0xc0, 0x0d,
+  0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4, 0xa0, 0x98, 0x65, 0x40,
+  0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18, 0x31, 0x28, 0x8c, 0x00,
+  0x17, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0x20, 0x16, 0x46, 0x0c, 0x0a,
+  0x23, 0xd0, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84, 0x40, 0x16, 0x46, 0x0c,
+  0x0a, 0x23, 0xe0, 0x85, 0x42, 0x0d, 0xe6, 0x18, 0x84, 0x20, 0x16, 0x66,
+  0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57, 0x10, 0x04, 0x04, 0x3a,
+  0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x1c, 0x1c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0xf7, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90,
+  0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d,
+  0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d,
+  0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70,
+  0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48,
+  0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0xc3, 0x26, 0x10, 0xc0,
+  0x02, 0x54, 0x43, 0x38, 0xa4, 0x83, 0x3c, 0xb4, 0x81, 0x38, 0xd4, 0x83,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0xb8, 0xc3, 0x3b, 0xb4, 0x41,
+  0x38, 0xb0, 0x43, 0x3a, 0x84, 0xc3, 0x3c, 0x00, 0x1b, 0xb6, 0xa1, 0x00,
+  0x16, 0xa0, 0x1a, 0xc2, 0x21, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e,
+  0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0, 0x1d, 0xde, 0xa1, 0x0d,
+  0xc2, 0x81, 0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01, 0xd8, 0x60, 0x10, 0x08,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x00, 0x6a, 0x83, 0x8f, 0x18, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x12,
+  0x50, 0x11, 0xe1, 0x00, 0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d,
+  0x60, 0x0e, 0xf5, 0xe0, 0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d,
+  0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43,
+  0x39, 0x00, 0x44, 0x3b, 0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3,
+  0x39, 0x84, 0x03, 0x3b, 0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3,
+  0x3b, 0xc8, 0x43, 0x1b, 0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03,
+  0x90, 0x07, 0x76, 0x00, 0x0c, 0xee, 0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5,
+  0x90, 0x0e, 0xec, 0x40, 0x0f, 0xe9, 0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee,
+  0xf0, 0x0e, 0x6d, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d,
+  0x00, 0x0f, 0xef, 0x90, 0x0e, 0xee, 0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d,
+  0x50, 0x0e, 0xec, 0x90, 0x0e, 0xed, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43,
+  0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43,
+  0x3b, 0x94, 0x43, 0x1b, 0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43,
+  0x39, 0xc8, 0x43, 0x1b, 0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81,
+  0x3b, 0xbc, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0x43, 0x38, 0x98, 0x03,
+  0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d,
+  0x90, 0x0e, 0xee, 0x60, 0x0e, 0xf3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d,
+  0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43,
+  0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43, 0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3,
+  0x3c, 0xb4, 0x81, 0x39, 0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03,
+  0x3a, 0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef,
+  0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xe7, 0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d,
+  0xa0, 0x0f, 0xe5, 0x20, 0x0f, 0xef, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0,
+  0xd0, 0x06, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43,
+  0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3, 0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43,
+  0x38, 0xc0, 0x03, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43,
+  0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00,
+  0x31, 0x0f, 0xf4, 0x10, 0x0e, 0xe3, 0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2,
+  0xf0, 0x0e, 0xf4, 0x50, 0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d,
+  0x20, 0x0e, 0xf5, 0x60, 0x0e, 0xe6, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3,
+  0x90, 0x0e, 0xfa, 0x50, 0x0e, 0x00, 0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3,
+  0x3c, 0x84, 0x83, 0x39, 0x94, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41,
+  0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5,
+  0x00, 0x6c, 0x40, 0x8e, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x06, 0x90,
+  0x80, 0x6a, 0x83, 0x81, 0x04, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x44, 0x00,
+  0x16, 0xa0, 0xda, 0x80, 0x28, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c,
+  0x20, 0x01, 0xd5, 0x06, 0x63, 0xf9, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x00, 0x6a, 0xc3, 0xc4, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x28, 0x80,
+  0x34, 0xb8, 0xc3, 0x3b, 0xb4, 0x81, 0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03,
+  0x3d, 0xa4, 0x83, 0x3b, 0xcc, 0x03, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41,
+  0x31, 0x21, 0x30, 0x26, 0x0c, 0x07, 0x92, 0x4c, 0x18, 0x14, 0x24, 0x99,
+  0x10, 0x2c, 0x13, 0x02, 0x06, 0x89, 0x20, 0x00, 0x00, 0x43, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4,
+  0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c,
+  0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xb8, 0xc1, 0x0c, 0xc0, 0x30, 0x02,
+  0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3,
+  0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84, 0x41, 0x18, 0x46, 0x18,
+  0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e, 0xe4, 0xa1, 0x1e, 0xc6,
+  0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e, 0xc2, 0x81, 0x1d, 0xf4,
+  0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e, 0xd2, 0x01, 0x1f, 0x50,
+  0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21,
+  0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40, 0x84, 0xa3, 0xa4, 0x29,
+  0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1,
+  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0xb8, 0x48, 0x9a, 0x22, 0x4a,
+  0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00,
+  0x06, 0x11, 0x18, 0xa1, 0x24, 0x41, 0x10, 0x08, 0x44, 0xb2, 0x2c, 0x0d,
+  0x39, 0x85, 0x28, 0x8a, 0xa2, 0x20, 0xa8, 0x0c, 0x00, 0x00, 0x90, 0x54,
+  0x04, 0x00, 0x20, 0xaa, 0x0c, 0x40, 0x51, 0x90, 0x55, 0x8c, 0xa2, 0x00,
+  0x00, 0x00, 0x20, 0xac, 0x0c, 0x45, 0x51, 0x90, 0x56, 0x84, 0xa2, 0x20,
+  0x6e, 0x8e, 0x20, 0x98, 0x23, 0x00, 0x83, 0x61, 0x04, 0xe1, 0x2b, 0x48,
+  0xb0, 0x34, 0x82, 0x07, 0x7a, 0x00, 0x85, 0x03, 0x01, 0x29, 0xf0, 0xcd,
+  0x11, 0x80, 0xc2, 0x20, 0x02, 0x20, 0x4c, 0x01, 0x8c, 0x00, 0x0c, 0x23,
+  0x0c, 0xdf, 0x20, 0x42, 0x20, 0x0c, 0x22, 0x1c, 0xc2, 0x20, 0x42, 0x21,
+  0x0c, 0x23, 0x10, 0x1f, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0,
+  0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68,
+  0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80,
+  0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9,
+  0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78,
+  0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72,
+  0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a,
+  0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72,
+  0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74,
+  0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x43, 0x98, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x80, 0x21, 0x4c, 0x04, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
+  0x10, 0x66, 0x02, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08,
+  0x53, 0x01, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0xb9,
+  0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x64, 0x08,
+  0x30, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x61, 0x26, 0x20, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x30, 0x1b, 0x10, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x98, 0x0e, 0x08, 0x00, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x06, 0x04, 0x80, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xc0, 0x10, 0x46, 0x0c, 0x80, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xc8, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0xfa, 0x46, 0x00, 0x4a, 0xa0, 0x10, 0x0a, 0xa4, 0x08, 0x0a, 0xa2, 0x80,
+  0x0a, 0x30, 0xa0, 0x0c, 0x0a, 0xa3, 0x50, 0x0a, 0xa6, 0x70, 0x0a, 0xac,
+  0x14, 0x8a, 0xa1, 0x1c, 0xa8, 0x2c, 0x9c, 0x11, 0x80, 0x42, 0x28, 0x88,
+  0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x22, 0xc7, 0x12, 0x24, 0x01, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xc9, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
+  0xb7, 0x21, 0xc6, 0xf7, 0x8c, 0x01, 0x40, 0x06, 0x64, 0x40, 0xe5, 0x6e,
+  0x0c, 0x2d, 0x4c, 0xee, 0x6b, 0x2e, 0x4d, 0xaf, 0x6c, 0x88, 0xf1, 0x31,
+  0x63, 0x20, 0x7c, 0x0d, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0xa4,
+  0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd,
+  0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06, 0x04,
+  0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06, 0x46,
+  0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x30, 0x06, 0xc4, 0x10,
+  0xe3, 0x63, 0x3e, 0xe8, 0x5b, 0x58, 0x34, 0x95, 0xd1, 0x85, 0xb1, 0x0d,
+  0x41, 0xc6, 0xe0, 0xf8, 0x98, 0x8f, 0xf9, 0x16, 0x6e, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e,
+  0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x31, 0x48, 0xc8, 0x85, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0x85, 0xcd, 0xd1, 0x7d, 0xb5, 0x85,
+  0xd1, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xc6,
+  0x60, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5,
+  0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99,
+  0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85,
+  0x89, 0xb1, 0x95, 0x0d, 0x11, 0xc6, 0xa0, 0x61, 0x14, 0x96, 0x26, 0xe7,
+  0x22, 0x57, 0xe6, 0x46, 0x56, 0x26, 0xf7, 0x45, 0x17, 0x26, 0x77, 0x56,
+  0x46, 0xc7, 0x28, 0x2c, 0x4d, 0xce, 0x25, 0x4c, 0xee, 0xec, 0x8b, 0x2e,
+  0x0f, 0xae, 0xec, 0xcb, 0x2d, 0xac, 0xad, 0x8c, 0x86, 0x19, 0xdb, 0x5b,
+  0x18, 0x1d, 0xcd, 0x10, 0x64, 0x0c, 0x9e, 0x6f, 0x19, 0x03, 0x68, 0x0c,
+  0xa2, 0x21, 0xc2, 0x18, 0x48, 0x64, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xde,
+  0xe6, 0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0x8c,
+  0x95, 0xb9, 0xd1, 0x95, 0xc9, 0x51, 0x0a, 0x4b, 0x93, 0x73, 0x71, 0x7b,
+  0xfb, 0x82, 0x2b, 0x93, 0x9b, 0x83, 0x2b, 0x1b, 0xa3, 0x4b, 0xb3, 0x2b,
+  0x23, 0x13, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0xe5, 0x16, 0xd6,
+  0x56, 0x46, 0x04, 0xee, 0x6d, 0x2e, 0x8d, 0x2e, 0xed, 0xcd, 0x6d, 0x08,
+  0xf4, 0x2d, 0x63, 0x40, 0x8d, 0x41, 0x35, 0x06, 0xd6, 0x18, 0x40, 0x63,
+  0x10, 0x8d, 0xc1, 0x35, 0x06, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33,
+  0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a,
+  0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28,
+  0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29,
+  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
+  0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91,
+  0x3e, 0x66, 0x0c, 0xb4, 0x31, 0xd8, 0xc6, 0xa0, 0x1a, 0x03, 0x6e, 0x0c,
+  0xa0, 0x31, 0x88, 0xc6, 0xe0, 0x1a, 0x83, 0x8e, 0xd9, 0x59, 0x99, 0x5b,
+  0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8,
+  0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33,
+  0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x43, 0xa4, 0xef, 0x19, 0x03, 0x6d, 0x0c, 0xbe, 0x31, 0xa8,
+  0xc6, 0x80, 0x1b, 0x03, 0x68, 0x0c, 0xc0, 0x60, 0x0c, 0xae, 0x31, 0x08,
+  0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xbe,
+  0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d,
+  0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0x11,
+  0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96, 0x26,
+  0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07, 0x57,
+  0xf6, 0x95, 0xe6, 0x66, 0xf6, 0xc6, 0xc2, 0x8c, 0xed, 0x2d, 0x8c, 0x8e,
+  0xcc, 0xdc, 0x98, 0xd4, 0x91, 0xd0, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0x19, 0xba, 0x32, 0x3c, 0xba, 0x3a, 0xb9, 0xb2, 0x2f, 0xba, 0x3c,
+  0xb8, 0x32, 0x2a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5c, 0xc6, 0xde, 0xd8, 0xde, 0xe4, 0xbe, 0xe6, 0xc6, 0xc2, 0xd8,
+  0xca, 0xe8, 0xd0, 0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1, 0x7d, 0xb5, 0x95,
+  0xd1, 0xa1, 0xbd, 0x91, 0xf1, 0xa1, 0x7b, 0x73, 0x2b, 0x6b, 0x0b, 0x83,
+  0xfb, 0x32, 0x0b, 0x1b, 0xa3, 0x7b, 0x93, 0x8b, 0xe1, 0x43, 0xf7, 0xe6,
+  0x56, 0xd6, 0x16, 0x06, 0xf7, 0x65, 0x16, 0x36, 0x46, 0xf7, 0x26, 0x27,
+  0xc3, 0x67, 0x8e, 0x4c, 0xee, 0xeb, 0x0e, 0x2d, 0x8d, 0xae, 0xec, 0x0b,
+  0xee, 0x2d, 0xcd, 0x8d, 0x6e, 0x08, 0x2c, 0x7c, 0xcb, 0xd7, 0x7c, 0xcb,
+  0x18, 0xa0, 0xc1, 0x18, 0xa4, 0xc1, 0xd7, 0x7c, 0xcd, 0xb7, 0x8c, 0x01,
+  0x1a, 0x8c, 0x81, 0x1a, 0x7c, 0xd0, 0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1,
+  0x18, 0xac, 0xc1, 0x47, 0x7d, 0xcd, 0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x01,
+  0x1b, 0x7c, 0xce, 0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18, 0xb4, 0xc1,
+  0x57, 0x7d, 0xcd, 0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x81, 0x1b, 0x7c, 0xd6,
+  0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18, 0xbc, 0xc1, 0x77, 0x7d, 0xcd,
+  0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x01, 0x1c, 0x30, 0x0a, 0x4b, 0x93, 0x73,
+  0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3,
+  0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97,
+  0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6,
+  0x57, 0xc6, 0x67, 0x0a, 0x2d, 0x8c, 0xac, 0x4c, 0x6e, 0xe8, 0xcd, 0x6d,
+  0x8e, 0x2e, 0xcc, 0x8d, 0x6e, 0x8e, 0xc1, 0xd8, 0x10, 0x32, 0xf8, 0xa6,
+  0x31, 0x18, 0x83, 0x31, 0x20, 0x83, 0x2f, 0x1a, 0x83, 0x32, 0xf8, 0x96,
+  0x8f, 0x19, 0x03, 0x33, 0x18, 0x83, 0x33, 0x18, 0x83, 0x38, 0x18, 0x03,
+  0x39, 0xf8, 0xa2, 0x31, 0x98, 0x83, 0xaf, 0x19, 0x03, 0x68, 0x0c, 0xe8,
+  0x60, 0x0c, 0xae, 0x31, 0xa8, 0x03, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x33, 0x34, 0xde, 0xcc, 0xcc, 0xe6, 0xca, 0xe8, 0x88, 0x98, 0xb1, 0xbd,
+  0x85, 0xd1, 0xcd, 0xe0, 0xcd, 0xd0, 0x68, 0x0b, 0xa3, 0x93, 0x4b, 0xc3,
+  0x1b, 0x42, 0x7d, 0xcb, 0xe7, 0x7c, 0xcb, 0x18, 0xdc, 0xc1, 0x18, 0xe0,
+  0xc1, 0xe7, 0x7c, 0xd8, 0xb7, 0x8c, 0x41, 0x1e, 0x8c, 0x81, 0x1e, 0x30,
+  0xc9, 0xaa, 0xb2, 0x22, 0x2a, 0x1b, 0x7b, 0x23, 0x2b, 0xa3, 0x41, 0x56,
+  0x36, 0xf6, 0x46, 0x56, 0x36, 0x84, 0x0c, 0xbe, 0x66, 0x0c, 0xc6, 0x60,
+  0x0c, 0xc8, 0xe0, 0x93, 0xc6, 0xa0, 0x0c, 0x3e, 0xe6, 0x63, 0xc6, 0xc0,
+  0x0c, 0xc6, 0xe0, 0x0c, 0xc6, 0x60, 0x0f, 0xc6, 0x40, 0x0e, 0x3e, 0x69,
+  0x0c, 0xe6, 0xe0, 0x73, 0xc6, 0x00, 0x1a, 0x03, 0x3e, 0x18, 0x83, 0x6b,
+  0x0c, 0xfa, 0x80, 0x4b, 0x58, 0x9a, 0x9c, 0x0b, 0x5d, 0x19, 0x1e, 0x5d,
+  0x9d, 0x5c, 0x19, 0x95, 0xb0, 0x34, 0x39, 0x97, 0xb9, 0xb0, 0x36, 0x38,
+  0xb6, 0x32, 0x62, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64,
+  0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70,
+  0x6c, 0x65, 0x3e, 0x24, 0xe8, 0xca, 0xf0, 0xb2, 0x86, 0x50, 0x5f, 0x36,
+  0x06, 0x7f, 0x30, 0x06, 0x65, 0xf0, 0x2d, 0x1f, 0x33, 0x06, 0xa0, 0x30,
+  0x06, 0xd0, 0x18, 0x84, 0xc2, 0x18, 0x5c, 0x63, 0x20, 0x0a, 0x2c, 0xe8,
+  0xca, 0xf0, 0xaa, 0xac, 0x86, 0x50, 0x9f, 0x36, 0x06, 0x7f, 0x30, 0x06,
+  0x65, 0xf0, 0x31, 0x1f, 0x33, 0x06, 0xa0, 0x30, 0x06, 0xd0, 0x18, 0x84,
+  0xc2, 0x18, 0x5c, 0x63, 0x40, 0x0a, 0x5c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe6,
+  0xc2, 0xda, 0xe0, 0xd8, 0xca, 0xe4, 0x78, 0xcc, 0x85, 0xb5, 0xc1, 0xb1,
+  0x95, 0xc9, 0x31, 0x98, 0x1b, 0x22, 0x7d, 0xdb, 0x18, 0x98, 0xc2, 0x18,
+  0x94, 0xc1, 0xb7, 0x7c, 0xcc, 0x18, 0x40, 0x63, 0x70, 0x0a, 0x63, 0x70,
+  0x8d, 0x01, 0x2a, 0x0c, 0x81, 0xc6, 0x20, 0x1b, 0x03, 0x6f, 0x0c, 0xc4,
+  0x60, 0x0c, 0xec, 0x60, 0x0c, 0xfc, 0x60, 0x0c, 0x46, 0x61, 0x0c, 0x4a,
+  0x61, 0x0c, 0x52, 0x61, 0x88, 0xf1, 0x00, 0x63, 0x30, 0x8d, 0x81, 0x2a,
+  0xb0, 0xfa, 0xd2, 0xa2, 0x9a, 0x8a, 0xa9, 0x99, 0x42, 0x0b, 0x23, 0x2b,
+  0x93, 0x1b, 0x7a, 0x73, 0x9b, 0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0xe3, 0xf3,
+  0xd6, 0xe6, 0x96, 0x06, 0xf7, 0x46, 0x57, 0xe6, 0x46, 0x07, 0x32, 0x86,
+  0x16, 0x26, 0xc7, 0x67, 0x2a, 0xad, 0x0d, 0x8e, 0xad, 0x0c, 0x64, 0x68,
+  0x65, 0x05, 0x84, 0x4a, 0x28, 0x28, 0x68, 0x88, 0x30, 0x06, 0xae, 0x30,
+  0xc4, 0x18, 0x83, 0x56, 0x18, 0x83, 0x57, 0x28, 0x83, 0x6e, 0x88, 0x31,
+  0x06, 0x68, 0x30, 0x06, 0xb0, 0x50, 0x06, 0xdd, 0x10, 0x31, 0x18, 0x03,
+  0x56, 0x18, 0x83, 0x58, 0x28, 0x83, 0x6e, 0x0c, 0x62, 0xa1, 0x0c, 0xbc,
+  0x31, 0x88, 0x85, 0x32, 0xf8, 0xc6, 0x20, 0x16, 0xca, 0x00, 0x0c, 0xc6,
+  0x20, 0x16, 0xca, 0x20, 0x0c, 0xc6, 0x20, 0x16, 0xca, 0x40, 0x0c, 0xc6,
+  0x20, 0x16, 0xca, 0x60, 0x0c, 0xc6, 0x20, 0x16, 0xca, 0x80, 0x1b, 0x62,
+  0x8c, 0x81, 0x2c, 0x8c, 0x41, 0x2c, 0x94, 0x81, 0xc7, 0x31, 0x08, 0x4b,
+  0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83,
+  0x2b, 0x9b, 0x43, 0x99, 0x22, 0x62, 0xfa, 0x72, 0xb2, 0x8a, 0x91, 0xf9,
+  0x32, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0x4b, 0x19, 0x42, 0x8c,
+  0x41, 0x2d, 0x8c, 0x01, 0x2d, 0xd0, 0x0a, 0x4b, 0x93, 0x6b, 0x09, 0x63,
+  0x4b, 0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83, 0x2b, 0x6b, 0x09, 0x93,
+  0x3b, 0x43, 0x99, 0x49, 0x19, 0x62, 0x8c, 0xc1, 0x2d, 0x8c, 0x41, 0x2d,
+  0x8c, 0x81, 0x2d, 0x0c, 0x11, 0xc6, 0xe0, 0x16, 0x68, 0x85, 0xa5, 0xc9,
+  0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95,
+  0xb5, 0x84, 0xc9, 0x9d, 0xa1, 0xd0, 0xa4, 0x0c, 0x31, 0xc6, 0x40, 0x17,
+  0xc6, 0xa0, 0x16, 0xc6, 0x20, 0x17, 0x88, 0x85, 0xa5, 0xc9, 0xb5, 0x84,
+  0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0xd0,
+  0x95, 0xe1, 0xd1, 0xd5, 0xc9, 0x95, 0xcd, 0x0d, 0x31, 0xc6, 0x80, 0x17,
+  0xc6, 0xa0, 0x16, 0xc6, 0x60, 0x17, 0x88, 0x85, 0xa5, 0xc9, 0xb5, 0x84,
+  0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0xcc,
+  0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xcd, 0x0d, 0x31, 0xc6, 0xc0, 0x17,
+  0xc6, 0xa0, 0x16, 0xc6, 0xa0, 0x17, 0x86, 0x18, 0x63, 0xa0, 0x0b, 0x63,
+  0xc0, 0x0b, 0x63, 0xe0, 0x0b, 0x43, 0x88, 0x31, 0xe0, 0x85, 0x31, 0xf0,
+  0x85, 0x21, 0xc4, 0x18, 0xdc, 0xc2, 0x18, 0xe8, 0xc2, 0x10, 0x61, 0x0c,
+  0x74, 0x61, 0x88, 0x31, 0x06, 0xb7, 0x30, 0x06, 0xbc, 0x30, 0x06, 0xbe,
+  0x30, 0xc4, 0x18, 0x03, 0x59, 0x18, 0x83, 0x58, 0x28, 0x83, 0x6f, 0x88,
+  0x31, 0x06, 0xb2, 0x30, 0x06, 0xb1, 0x50, 0x06, 0xdc, 0x10, 0x63, 0x0c,
+  0x64, 0x61, 0x0c, 0x62, 0xa1, 0x0c, 0xc2, 0x60, 0x88, 0x31, 0x06, 0xb2,
+  0x30, 0x06, 0xb1, 0x50, 0x06, 0x62, 0x30, 0xc4, 0x18, 0x03, 0x59, 0x18,
+  0x83, 0x58, 0x28, 0x83, 0x31, 0x18, 0x62, 0x8c, 0x81, 0x2c, 0x8c, 0x41,
+  0x2c, 0x94, 0x01, 0x18, 0x0c, 0x31, 0xc6, 0x40, 0x16, 0xc6, 0x20, 0x16,
+  0xca, 0xa0, 0x1b, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41,
+  0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03,
+  0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec,
+  0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee,
+  0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e,
+  0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53,
+  0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1,
+  0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6,
+  0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40,
+  0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed,
+  0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4,
+  0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04,
+  0x13, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7,
+  0xd0, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x58, 0x05, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x2e, 0x00, 0x00, 0x00, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf,
+  0xb3, 0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45,
+  0x51, 0x14, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x8f,
+  0x63, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x11, 0x34, 0x00, 0x12, 0xf9, 0x83,
+  0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x29, 0x6c, 0x00, 0x12, 0xf9, 0x12,
+  0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83,
+  0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0xc2, 0x04, 0x20, 0x91, 0x5f, 0x00, 0xd2,
+  0xf4, 0x17, 0x40, 0x20, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x05, 0x50, 0x00,
+  0x12, 0xf9, 0x05, 0x20, 0x4d, 0xbf, 0xb0, 0x00, 0xcc, 0xe3, 0x57, 0x77,
+  0x71, 0xdb, 0x96, 0x30, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05,
+  0x03, 0x5c, 0x7e, 0x75, 0x17, 0xb7, 0x6d, 0x02, 0x10, 0x80, 0x44, 0x7e,
+  0x01, 0x48, 0xd3, 0xff, 0x38, 0x96, 0x5f, 0xdc, 0xb6, 0x01, 0x44, 0x6c,
+  0x57, 0xfe, 0xe7, 0x5b, 0xdb, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0x93,
+  0x0d, 0x44, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0x7f, 0x01, 0x04, 0x92,
+  0x5f, 0xdc, 0xb6, 0x19, 0x44, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0x7f,
+  0xc1, 0x00, 0x97, 0x5f, 0xdc, 0x36, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x12, 0x02, 0x00, 0x00, 0x13, 0x04, 0x72, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x56, 0x00, 0x00, 0x00, 0xd4, 0x8e, 0x45, 0x00, 0x81, 0x70, 0xcc,
+  0x41, 0x2c, 0xcc, 0x83, 0x07, 0x94, 0x8e, 0x35, 0x00, 0x03, 0x31, 0xc7,
+  0xb0, 0x30, 0x78, 0x30, 0xc7, 0xb0, 0xe0, 0x01, 0x1e, 0x8c, 0x00, 0x8c,
+  0x35, 0x00, 0x81, 0x40, 0x65, 0x11, 0x94, 0x00, 0x81, 0x63, 0x09, 0x01,
+  0x30, 0x02, 0x40, 0xdf, 0x0c, 0x00, 0x79, 0x23, 0x00, 0x35, 0x40, 0xc0,
+  0x0c, 0x00, 0x05, 0x33, 0x00, 0x33, 0x00, 0x73, 0x10, 0xb4, 0xa0, 0x0b,
+  0xb4, 0xb0, 0x07, 0x24, 0xcc, 0x00, 0x50, 0x31, 0x03, 0x30, 0x02, 0x30,
+  0x03, 0x30, 0xd6, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82, 0xf8,
+  0x07, 0x82, 0x20, 0x88, 0x7f, 0x63, 0x0d, 0x6c, 0x3b, 0xff, 0xa4, 0xc7,
+  0xb6, 0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4, 0x37, 0xd6, 0x00, 0x82,
+  0x20, 0x5b, 0xff, 0x02, 0x08, 0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2,
+  0xf5, 0x2f, 0x8c, 0x35, 0x80, 0x20, 0xb8, 0xe6, 0x60, 0x00, 0x82, 0xe0,
+  0x9a, 0x83, 0x01, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x63, 0x0d, 0x20, 0x48,
+  0xb7, 0x39, 0x18, 0x80, 0x20, 0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b,
+  0x83, 0xc1, 0x58, 0xc3, 0x3a, 0xe2, 0x31, 0x0b, 0x06, 0xeb, 0x88, 0xc7,
+  0x2c, 0x18, 0xac, 0x23, 0x1e, 0xb3, 0x60, 0x30, 0xd6, 0x00, 0x82, 0x30,
+  0x1e, 0x8e, 0x01, 0x08, 0xc2, 0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1,
+  0x18, 0x8c, 0x35, 0x88, 0xb9, 0x98, 0xf6, 0x1f, 0x58, 0xf2, 0x6c, 0xfc,
+  0x0b, 0x63, 0xba, 0xaa, 0xb9, 0x2f, 0x8c, 0x35, 0xfc, 0x33, 0xe9, 0xff,
+  0xbe, 0x40, 0xd7, 0xa0, 0x98, 0x7f, 0x2d, 0x1c, 0xc7, 0xa0, 0x2f, 0x8c,
+  0x35, 0xcc, 0x7d, 0x9b, 0xa6, 0xbe, 0xd0, 0xba, 0x21, 0xcf, 0xfb, 0x02,
+  0x9f, 0xb3, 0x3e, 0xfe, 0x11, 0x30, 0x46, 0x00, 0x82, 0x20, 0x48, 0x82,
+  0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x63, 0x04, 0x3a, 0x6b,
+  0xce, 0x21, 0x18, 0x8c, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf, 0x18, 0x81,
+  0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18,
+  0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf,
+  0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba,
+  0xf8, 0x37, 0x46, 0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8,
+  0xf6, 0x34, 0x18, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00,
+  0x00, 0xe3, 0x0d, 0x73, 0xe0, 0x07, 0xaf, 0x40, 0xc1, 0x18, 0x6e, 0x08,
+  0x9e, 0x60, 0x96, 0x21, 0x10, 0x82, 0x11, 0x03, 0xa5, 0x08, 0x68, 0x81,
+  0x0e, 0xe4, 0xe0, 0x0e, 0xc8, 0xe0, 0x0c, 0xca, 0x80, 0x18, 0x31, 0x50,
+  0x8a, 0xa0, 0x16, 0xe8, 0x60, 0x0e, 0xf0, 0xa0, 0x0c, 0xd0, 0xc0, 0x0c,
+  0x8a, 0x41, 0x06, 0x61, 0x0c, 0xde, 0x60, 0x90, 0x41, 0x28, 0x83, 0x38,
+  0x18, 0x64, 0x10, 0x82, 0x39, 0x38, 0x3d, 0x50, 0x97, 0x82, 0x32, 0xc8,
+  0x10, 0xa4, 0x81, 0x1c, 0x18, 0x11, 0xc0, 0x67, 0xbc, 0xc1, 0x0f, 0x54,
+  0x61, 0x17, 0x2e, 0x50, 0x97, 0x82, 0x32, 0xc8, 0x10, 0xb8, 0xc1, 0x1d,
+  0x8c, 0x18, 0x14, 0x46, 0x70, 0x0e, 0x45, 0x30, 0xc7, 0xf0, 0x06, 0x41,
+  0x38, 0x8c, 0x57, 0x90, 0x02, 0x2c, 0x84, 0x83, 0x38, 0xe0, 0xc1, 0x05,
+  0xea, 0x52, 0x50, 0x06, 0x19, 0x02, 0x3a, 0xe8, 0x83, 0x11, 0x83, 0xc2,
+  0x08, 0xda, 0x61, 0x09, 0xe6, 0x18, 0x8c, 0xc0, 0x1c, 0xc6, 0x2b, 0x54,
+  0xc1, 0x16, 0xce, 0x01, 0x1d, 0xfe, 0xe0, 0x02, 0x75, 0x29, 0x28, 0x83,
+  0x0c, 0x81, 0x1e, 0x8c, 0xc2, 0x88, 0x41, 0x61, 0x04, 0xf3, 0x10, 0x05,
+  0x73, 0x0c, 0x46, 0x90, 0x0e, 0xb3, 0x04, 0xc4, 0x70, 0x43, 0xc7, 0x06,
+  0xc1, 0x2c, 0xc3, 0x40, 0x04, 0x23, 0x06, 0x4a, 0x11, 0xc0, 0x03, 0x2c,
+  0xb8, 0xc2, 0x2c, 0x80, 0xc2, 0x28, 0x84, 0x02, 0x18, 0x8c, 0x18, 0x28,
+  0x45, 0x10, 0x0f, 0xb0, 0xf0, 0x0a, 0xb4, 0x10, 0x0a, 0xa4, 0x20, 0x0a,
+  0x61, 0x30, 0xc8, 0x10, 0x80, 0x82, 0x29, 0x0c, 0x32, 0x0c, 0xa0, 0xc0,
+  0x0a, 0x83, 0x0c, 0xc2, 0x1f, 0xb8, 0xc2, 0x20, 0x83, 0x10, 0xc0, 0xc2,
+  0xdd, 0x82, 0xba, 0x14, 0x94, 0x41, 0x86, 0xc0, 0x14, 0x5e, 0xc1, 0x88,
+  0x00, 0x3e, 0xe3, 0x0d, 0xbb, 0x70, 0x0e, 0xf8, 0x70, 0x81, 0xba, 0x14,
+  0x94, 0x41, 0x86, 0x60, 0x15, 0x68, 0x61, 0xc4, 0xa0, 0x30, 0x02, 0x92,
+  0x28, 0x82, 0x39, 0x06, 0x56, 0x08, 0xfc, 0x61, 0xbc, 0x22, 0x1c, 0xda,
+  0xc1, 0x1f, 0xfe, 0xa1, 0x16, 0x2e, 0x50, 0x97, 0x82, 0x32, 0xc8, 0x10,
+  0xc4, 0x82, 0x2e, 0x8c, 0x18, 0x14, 0x46, 0xa0, 0x12, 0x4b, 0x30, 0xc7,
+  0x60, 0x04, 0x23, 0x31, 0x5e, 0x71, 0x0e, 0xf3, 0x40, 0x12, 0x25, 0xc1,
+  0x0b, 0x17, 0xa8, 0x4b, 0x41, 0x19, 0x64, 0x08, 0x6e, 0x01, 0x1c, 0x46,
+  0x0c, 0x0a, 0x23, 0x80, 0x89, 0x28, 0x98, 0x63, 0x30, 0x02, 0x93, 0x98,
+  0x25, 0x20, 0x06, 0x3a, 0x02, 0x3e, 0x08, 0x84, 0x01, 0x2e, 0x84, 0x39,
+  0x86, 0x60, 0x14, 0x48, 0x62, 0xbc, 0x01, 0x1e, 0xf6, 0x21, 0x25, 0x28,
+  0x18, 0xc3, 0x0d, 0x41, 0x2b, 0x04, 0xb3, 0x0c, 0x85, 0x11, 0x0c, 0x32,
+  0x10, 0xbf, 0x80, 0x0e, 0xe3, 0x0d, 0xf4, 0xf0, 0x0f, 0x21, 0x41, 0xc1,
+  0x18, 0x31, 0x20, 0x8c, 0xc0, 0x26, 0x86, 0x11, 0x83, 0xc2, 0x08, 0x70,
+  0x22, 0xd8, 0x05, 0x0b, 0x76, 0x01, 0x3e, 0x23, 0x06, 0x85, 0x11, 0xe0,
+  0x44, 0x00, 0x0e, 0x36, 0xf0, 0x82, 0x7c, 0x8c, 0x17, 0x82, 0xf8, 0xd8,
+  0x10, 0xd0, 0x67, 0xc4, 0x80, 0x30, 0x82, 0x9e, 0x08, 0x46, 0x0c, 0x0a,
+  0x23, 0xf8, 0x89, 0xc0, 0x17, 0x2c, 0xf0, 0x05, 0xf9, 0xcc, 0x31, 0xa0,
+  0xc3, 0xd2, 0x13, 0x83, 0x0c, 0x41, 0x3a, 0xdc, 0x83, 0x0d, 0x01, 0x7d,
+  0x06, 0x19, 0x82, 0x75, 0xe8, 0x87, 0x41, 0x86, 0xa0, 0xfa, 0x87, 0x59,
+  0x02, 0x63, 0xa0, 0x22, 0x10, 0x0a, 0x36, 0x20, 0xc6, 0x1b, 0x4c, 0x22,
+  0x26, 0xc2, 0x82, 0x82, 0x31, 0xdc, 0x10, 0xd8, 0x82, 0x33, 0xcb, 0x70,
+  0x20, 0xc1, 0x20, 0x03, 0x51, 0x0f, 0xfe, 0x30, 0xde, 0xa0, 0x12, 0x35,
+  0x91, 0x13, 0x14, 0x8c, 0xf1, 0x06, 0x96, 0xb8, 0x09, 0x9d, 0xa0, 0x60,
+  0x8c, 0x18, 0x20, 0x47, 0x14, 0x17, 0x45, 0x77, 0x0c, 0xc1, 0x20, 0x43,
+  0x70, 0x0f, 0x29, 0x31, 0xc8, 0x10, 0x2c, 0x2b, 0x31, 0x4b, 0x80, 0x0c,
+  0x54, 0x04, 0xc2, 0x81, 0x19, 0xc3, 0x0d, 0x61, 0x60, 0x0e, 0xc1, 0x2c,
+  0x43, 0x72, 0x05, 0xe3, 0x0d, 0x33, 0xe1, 0x13, 0x6f, 0x41, 0xc1, 0x18,
+  0x6e, 0x08, 0xd2, 0x21, 0x98, 0x65, 0x50, 0x96, 0x60, 0x90, 0xa1, 0x10,
+  0x89, 0x95, 0x18, 0x6f, 0xb8, 0x09, 0xb1, 0x60, 0x0b, 0x0a, 0xc6, 0x1c,
+  0x43, 0x48, 0x04, 0x76, 0x31, 0xc8, 0x10, 0x88, 0x04, 0x4c, 0x58, 0x50,
+  0xc8, 0x67, 0x90, 0x21, 0x20, 0x09, 0x9b, 0x98, 0x25, 0x88, 0x83, 0xf1,
+  0x86, 0x9e, 0x40, 0x0b, 0xbd, 0xa0, 0x60, 0x8c, 0x37, 0xfc, 0x84, 0x5a,
+  0xd0, 0x05, 0x05, 0x63, 0x90, 0x01, 0x6a, 0x89, 0x9d, 0x18, 0x6e, 0x20,
+  0xe0, 0xc1, 0x99, 0x65, 0x60, 0xac, 0x60, 0x0c, 0x41, 0x02, 0x8d, 0xe1,
+  0x86, 0x20, 0x1f, 0x94, 0x59, 0x06, 0xa7, 0x09, 0x4c, 0xd8, 0x07, 0xf9,
+  0xcc, 0x12, 0x3c, 0x36, 0xf4, 0x03, 0x7c, 0x46, 0x0c, 0x08, 0x23, 0x60,
+  0x8d, 0xc0, 0x02, 0x90, 0x90, 0xcf, 0x88, 0x41, 0x61, 0x04, 0xaf, 0x11,
+  0x88, 0xc4, 0x2c, 0xc1, 0x33, 0x50, 0x01, 0x28, 0x8d, 0xe0, 0xcc, 0x31,
+  0xd8, 0x44, 0x80, 0x1a, 0x63, 0x08, 0x1b, 0x6a, 0x0c, 0x37, 0x04, 0x22,
+  0xa1, 0xcc, 0x32, 0x44, 0x50, 0x60, 0x02, 0x49, 0xc8, 0x67, 0x96, 0x40,
+  0xb2, 0xc1, 0x24, 0xe0, 0x33, 0x62, 0x40, 0x18, 0x41, 0x6d, 0x04, 0x16,
+  0xa4, 0x84, 0x7c, 0x46, 0x0c, 0x0a, 0x23, 0xc0, 0x8d, 0x60, 0x25, 0x66,
+  0x09, 0xa4, 0x81, 0x0a, 0x40, 0x81, 0x84, 0x68, 0x8e, 0x21, 0x09, 0x60,
+  0x63, 0x0c, 0x81, 0x0c, 0x5c, 0x63, 0xb8, 0x21, 0x58, 0x09, 0x65, 0x96,
+  0x81, 0x9a, 0x02, 0x13, 0x5a, 0x42, 0x3e, 0xb3, 0x04, 0x95, 0x0d, 0x2f,
+  0x01, 0x9f, 0x11, 0x03, 0xc2, 0x08, 0x7c, 0x23, 0xb0, 0x40, 0x26, 0xe4,
+  0x33, 0x62, 0x50, 0x18, 0x41, 0x78, 0x04, 0x34, 0x31, 0x4b, 0x50, 0x0d,
+  0x54, 0x00, 0xca, 0x24, 0x50, 0x73, 0x0c, 0x49, 0x60, 0x1b, 0xb3, 0x04,
+  0xd6, 0x40, 0x45, 0x20, 0x54, 0x7a, 0xb0, 0x0c, 0x32, 0x04, 0x6b, 0x41,
+  0x17, 0x73, 0x0c, 0x68, 0x01, 0x06, 0xbd, 0x31, 0xc8, 0x10, 0xa4, 0xc5,
+  0x5d, 0xd8, 0x10, 0xc8, 0x67, 0x90, 0x21, 0x58, 0x8b, 0xbe, 0x98, 0x25,
+  0x88, 0x83, 0xe1, 0x86, 0x59, 0xf0, 0x89, 0x60, 0x96, 0x01, 0x23, 0x83,
+  0x60, 0x90, 0x81, 0x0e, 0xe2, 0x42, 0x2f, 0xc6, 0x1b, 0x4c, 0x23, 0x36,
+  0xc6, 0x83, 0x82, 0x31, 0xde, 0x80, 0x1a, 0xb3, 0xd1, 0x1b, 0x14, 0x8c,
+  0x39, 0x06, 0xb9, 0x08, 0xce, 0x63, 0x90, 0x21, 0x98, 0x8b, 0xd0, 0xb0,
+  0xe0, 0x90, 0xcf, 0x20, 0x43, 0x50, 0x17, 0xa7, 0x31, 0xdc, 0x70, 0xf0,
+  0x84, 0x33, 0xcb, 0x30, 0x06, 0x59, 0x30, 0x86, 0x30, 0xb0, 0xc7, 0x70,
+  0x43, 0xf0, 0x13, 0xca, 0x2c, 0xc3, 0xa6, 0x05, 0x26, 0x84, 0x85, 0x7c,
+  0x66, 0x09, 0xb8, 0x11, 0x03, 0xc2, 0x08, 0xee, 0x63, 0x18, 0x31, 0x28,
+  0x8c, 0x20, 0x3f, 0x02, 0xb2, 0xb0, 0xc0, 0x2c, 0xe4, 0x63, 0x01, 0x5a,
+  0xc0, 0x67, 0x96, 0x80, 0x1b, 0xa8, 0x00, 0x14, 0x4d, 0xd8, 0xe6, 0x18,
+  0xfa, 0x22, 0xa0, 0x8f, 0x31, 0x04, 0x86, 0x3e, 0x86, 0x1b, 0x02, 0xb4,
+  0x50, 0x66, 0x19, 0xbc, 0x2e, 0x30, 0x41, 0x2d, 0xe4, 0x33, 0x4b, 0xf0,
+  0x8d, 0x18, 0x10, 0x46, 0x00, 0x22, 0xc3, 0x88, 0x41, 0x61, 0x04, 0x22,
+  0x12, 0xb4, 0x85, 0x05, 0x6f, 0x21, 0x1f, 0x0b, 0xe2, 0x02, 0x3e, 0xb3,
+  0x04, 0xdf, 0x40, 0x05, 0xa0, 0x74, 0x82, 0x37, 0xc7, 0x90, 0x04, 0xfc,
+  0x31, 0x86, 0x50, 0xe9, 0xc7, 0x70, 0x43, 0x10, 0x17, 0xca, 0x2c, 0x43,
+  0x18, 0x80, 0x41, 0x60, 0xc2, 0x5c, 0xc8, 0x67, 0x96, 0x40, 0x0c, 0x46,
+  0x0c, 0x08, 0x23, 0x48, 0x91, 0x61, 0xc4, 0xa0, 0x30, 0x82, 0x15, 0x09,
+  0xec, 0xc2, 0x02, 0xbc, 0x90, 0x8f, 0x05, 0x7a, 0x01, 0x9f, 0x59, 0x02,
+  0x31, 0x18, 0xa8, 0x00, 0x14, 0x30, 0x10, 0xc2, 0x60, 0x8e, 0x21, 0x09,
+  0x44, 0x64, 0xc4, 0xc0, 0x30, 0x82, 0x18, 0x09, 0x62, 0xe3, 0x35, 0x06,
+  0x19, 0x82, 0xd9, 0x28, 0x8f, 0x59, 0x82, 0x31, 0x18, 0xa8, 0x08, 0xfc,
+  0x00, 0x13, 0xc4, 0x60, 0x90, 0x21, 0xc8, 0x8d, 0xf3, 0x98, 0x25, 0x88,
+  0x83, 0x59, 0x86, 0x32, 0x88, 0x03, 0x7e, 0x18, 0x64, 0xe8, 0x05, 0xdd,
+  0x18, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0x66, 0x24, 0x68, 0x8d, 0x39, 0x06,
+  0xdb, 0x08, 0x5a, 0x64, 0xc4, 0xa0, 0x30, 0x82, 0x1a, 0x19, 0x5c, 0x63,
+  0x8e, 0x41, 0x08, 0x5c, 0x64, 0xc4, 0xa0, 0x30, 0x82, 0x1b, 0x29, 0x5e,
+  0x63, 0x8e, 0x41, 0x08, 0x5a, 0x64, 0x90, 0x21, 0xe8, 0x8d, 0xf7, 0x18,
+  0x64, 0x08, 0xca, 0x21, 0x3e, 0xc6, 0x1b, 0xee, 0x43, 0x44, 0x68, 0x84,
+  0x82, 0x31, 0xde, 0x90, 0x1f, 0x24, 0xe2, 0x22, 0x14, 0x8c, 0x39, 0x86,
+  0xf1, 0x08, 0x70, 0x64, 0x90, 0x21, 0x20, 0x0f, 0xf9, 0xb0, 0x20, 0x91,
+  0xcf, 0x20, 0x43, 0x60, 0x1e, 0xf8, 0x31, 0xdc, 0x70, 0xb4, 0x86, 0x33,
+  0xcb, 0x00, 0x07, 0x66, 0x10, 0x8c, 0x21, 0x0c, 0x3d, 0x32, 0xdc, 0x10,
+  0xc0, 0x86, 0x32, 0xcb, 0x80, 0x06, 0x67, 0x10, 0x98, 0x20, 0x1b, 0xf2,
+  0x99, 0x25, 0x48, 0x83, 0x11, 0x03, 0xc2, 0x08, 0xd0, 0x64, 0x18, 0x31,
+  0x28, 0x8c, 0x40, 0x4d, 0x82, 0xda, 0xb0, 0xe0, 0x36, 0xe4, 0x63, 0x41,
+  0x6e, 0xc0, 0x67, 0x96, 0x20, 0x0d, 0x06, 0x2a, 0x00, 0xe5, 0x0c, 0x04,
+  0x34, 0x98, 0x63, 0x70, 0x8f, 0xa0, 0x4c, 0xc6, 0x10, 0x98, 0x32, 0x19,
+  0x6e, 0x08, 0x72, 0x43, 0x99, 0x65, 0x58, 0x03, 0x35, 0x08, 0x4c, 0xd8,
+  0x0d, 0xf9, 0xcc, 0x12, 0xb0, 0xc1, 0x88, 0x01, 0x61, 0x04, 0x71, 0x32,
+  0x8c, 0x18, 0x14, 0x46, 0x30, 0x27, 0x81, 0x6f, 0x58, 0x00, 0x1e, 0xf2,
+  0xb1, 0x40, 0x3c, 0xe0, 0x33, 0x4b, 0xc0, 0x06, 0x03, 0x15, 0x80, 0xa2,
+  0x06, 0xc2, 0x1a, 0xcc, 0x31, 0x24, 0x41, 0x9b, 0x8c, 0x21, 0x54, 0x6b,
+  0x32, 0xdc, 0x10, 0x88, 0x87, 0x32, 0xcb, 0xe0, 0x06, 0x6d, 0x10, 0x98,
+  0x40, 0x1e, 0xf2, 0x99, 0x25, 0x78, 0x83, 0x11, 0x03, 0xc2, 0x08, 0xf4,
+  0x64, 0x18, 0x31, 0x28, 0x8c, 0x80, 0x4f, 0x82, 0xf3, 0xb0, 0x20, 0x3d,
+  0xe4, 0x63, 0xc1, 0x7a, 0xc0, 0x67, 0x96, 0xe0, 0x0d, 0x06, 0x2a, 0x00,
+  0xa5, 0x0d, 0x04, 0x37, 0x98, 0x63, 0x48, 0x82, 0x39, 0x19, 0x31, 0x30,
+  0x8c, 0x40, 0x54, 0x02, 0x11, 0x01, 0x91, 0x41, 0x86, 0x80, 0x44, 0x6c,
+  0x64, 0x96, 0x00, 0x0e, 0x06, 0x2a, 0x02, 0x3f, 0x28, 0x03, 0xe1, 0x0d,
+  0x06, 0x19, 0x02, 0x15, 0xc1, 0x91, 0x59, 0x82, 0x38, 0x18, 0x68, 0x09,
+  0x78, 0x44, 0xe1, 0x11, 0x8b, 0x47, 0xc6, 0x40, 0x16, 0xe0, 0x80, 0x47,
+  0xc8, 0x60, 0xa0, 0x25, 0x40, 0x11, 0x45, 0x2f, 0x2c, 0x73, 0x18, 0x03,
+  0x02, 0x0e, 0x68, 0x88, 0x0c, 0x06, 0x19, 0x02, 0x81, 0x47, 0x2c, 0x20,
+  0x13, 0xf9, 0x64, 0x10, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x17, 0xd3, 0x07, 0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4,
+  0x50, 0x13, 0xe7, 0x2c, 0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d,
+  0x9b, 0x6d, 0x29, 0x38, 0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b,
+  0x00, 0x03, 0x11, 0x71, 0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71,
+  0x21, 0x13, 0x00, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x2c, 0x00, 0x00,
+  0x00, 0x5b, 0x8e, 0x20, 0x98, 0x85, 0x03, 0x17, 0x90, 0x5f, 0xd8, 0x52,
+  0x10, 0x07, 0x38, 0x20, 0xe1, 0xb0, 0xa5, 0x28, 0x0e, 0x70, 0x40, 0xc2,
+  0x61, 0x4b, 0xa1, 0x1c, 0xe2, 0x80, 0x8c, 0xc3, 0x96, 0xe2, 0x39, 0xc4,
+  0x01, 0x19, 0x87, 0x2d, 0x45, 0x75, 0x88, 0x03, 0x32, 0x0e, 0x5b, 0x8a,
+  0xed, 0x10, 0x07, 0x64, 0x1c, 0xb6, 0x14, 0x62, 0x70, 0x80, 0x03, 0x12,
+  0x0e, 0x5b, 0x8a, 0x31, 0x38, 0xc0, 0x01, 0x09, 0x87, 0x2d, 0x45, 0x1a,
+  0x1c, 0xe2, 0x80, 0x8c, 0xc3, 0x96, 0xc2, 0x0d, 0x0e, 0x71, 0x40, 0xc6,
+  0x61, 0x4b, 0x41, 0x07, 0x87, 0x38, 0x20, 0xe3, 0xb0, 0xa5, 0xd0, 0x83,
+  0x43, 0x1c, 0x90, 0x71, 0xd8, 0x32, 0x88, 0x42, 0x40, 0x0e, 0x5b, 0x86,
+  0x53, 0x08, 0xca, 0x61, 0xcb, 0xa0, 0x0b, 0x81, 0x39, 0x6c, 0x19, 0x7e,
+  0x21, 0x38, 0x87, 0x2d, 0x43, 0x38, 0x04, 0xe8, 0xb0, 0x65, 0x50, 0x87,
+  0x60, 0x16, 0xb6, 0x0c, 0xef, 0x10, 0xa4, 0xc3, 0x96, 0xc1, 0x1e, 0x02,
+  0x75, 0xd8, 0x32, 0xe0, 0x43, 0x90, 0x0e, 0x5b, 0x06, 0xb6, 0x08, 0xd4,
+  0x61, 0xcb, 0xe0, 0x16, 0x41, 0x3a, 0x6c, 0x19, 0xd4, 0x23, 0x50, 0x87,
+  0x2d, 0x03, 0x7b, 0x04, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0xd4, 0xce, 0x41,
+  0x2c, 0xcc, 0xd3, 0x06, 0x94, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40,
+  0xdf, 0x0c, 0x00, 0x05, 0x33, 0x00, 0x54, 0xcc, 0x00, 0x8c, 0x35, 0xb0,
+  0xec, 0x19, 0xca, 0x1f, 0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce,
+  0xde, 0x58, 0x83, 0x5e, 0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf,
+  0xdb, 0xa7, 0xf4, 0xe8, 0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a,
+  0xc2, 0xe8, 0xee, 0xdd, 0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b,
+  0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb,
+  0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9,
+  0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea,
+  0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05,
+  0x33, 0x00, 0x04, 0x8c, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60,
+  0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5,
+  0x02, 0x0d, 0x37, 0x50, 0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43,
+  0x43, 0xc5, 0xc1, 0x20, 0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64,
+  0x08, 0xa0, 0x6a, 0x96, 0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61,
+  0x48, 0x82, 0xe1, 0x86, 0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31,
+  0x28, 0x8c, 0xc0, 0x0f, 0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xf0, 0x60, 0xc4,
+  0xa0, 0x30, 0x02, 0x50, 0xf8, 0xa6, 0x39, 0x06, 0x21, 0xc8, 0x83, 0x11,
+  0x83, 0xc2, 0x08, 0x44, 0x21, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xc0, 0x83,
+  0x59, 0x82, 0x62, 0xa0, 0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xfc,
+  0x60, 0x0c, 0x41, 0xf0, 0x83, 0x31, 0x84, 0x81, 0x0f, 0x46, 0x0c, 0x0a,
+  0x23, 0x30, 0x05, 0x21, 0x18, 0x31, 0x28, 0x8c, 0xe0, 0x14, 0x88, 0x60,
+  0xb8, 0x21, 0xb8, 0x84, 0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c,
+  0x0c, 0x6c, 0x40, 0x03, 0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90,
+  0x8f, 0x05, 0x1a, 0x7c, 0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81,
+  0x2a, 0x0c, 0x32, 0x04, 0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64,
+  0x08, 0xd2, 0xc0, 0x0d, 0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4,
+  0xa0, 0x98, 0x65, 0x40, 0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18,
+  0x31, 0x28, 0x8c, 0xe0, 0x16, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0x20,
+  0x16, 0x46, 0x0c, 0x0a, 0x23, 0xc8, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84,
+  0x40, 0x16, 0x46, 0x0c, 0x0a, 0x23, 0xd8, 0x85, 0x42, 0x0d, 0xe6, 0x18,
+  0x84, 0x20, 0x16, 0x66, 0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57,
+  0x10, 0x04, 0x04, 0x3a, 0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00
+};
+const unsigned int sdl_metallib_len = 31301;
diff --git a/SDL-3.2.8/src/render/metal/SDL_shaders_metal_iphonesimulator.h b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_iphonesimulator.h
new file mode 100644
index 0000000..962d3d0
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_iphonesimulator.h
@@ -0,0 +1,3155 @@
+const unsigned char sdl_metallib[] = {
+  0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xbd, 0x93, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x8f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
+  0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
+  0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
+  0x40, 0x16, 0x1e, 0x80, 0x6f, 0x65, 0x1c, 0x60, 0x4b, 0xe5, 0x3e, 0x52,
+  0xbd, 0x45, 0x4b, 0x73, 0x3d, 0xb1, 0x9c, 0xfa, 0xfe, 0xc3, 0x69, 0x80,
+  0x87, 0x85, 0xc7, 0x21, 0xed, 0x04, 0x6d, 0xba, 0x4d, 0x44, 0x53, 0x5a,
+  0x08, 0x00, 0xa0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46,
+  0x46, 0x54, 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, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00,
+  0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x85, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x4f, 0x3e, 0x88, 0xf6, 0xd4, 0xa3, 0x24, 0xb7, 0xdd, 0x38, 0xe0,
+  0x22, 0x3d, 0x83, 0x1f, 0x22, 0x68, 0x86, 0x1c, 0x9f, 0x44, 0x3b, 0x7a,
+  0x75, 0x43, 0x0b, 0xd5, 0x0c, 0xbf, 0x6a, 0xaf, 0x7a, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0xb0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x0e, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
+  0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x88,
+  0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
+  0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48,
+  0x41, 0x53, 0x48, 0x20, 0x00, 0x69, 0x0c, 0xc0, 0x72, 0x21, 0x01, 0x36,
+  0xf4, 0x14, 0xe1, 0x4d, 0xa4, 0x88, 0x9b, 0xe6, 0x99, 0x4b, 0x81, 0x66,
+  0x0a, 0xe3, 0x36, 0x1a, 0x3b, 0xb2, 0xa9, 0x82, 0x63, 0x0e, 0xec, 0x2c,
+  0x58, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x10, 0x0e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x66, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x50, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52,
+  0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45,
+  0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72,
+  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01,
+  0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x66, 0x5d, 0xb4, 0x98,
+  0xcf, 0x81, 0x8b, 0x13, 0x13, 0xaf, 0x83, 0xd1, 0x40, 0x24, 0xf0, 0x52,
+  0x05, 0xac, 0x7a, 0x64, 0x96, 0xa7, 0xa3, 0x59, 0x4c, 0x41, 0x3c, 0xf3,
+  0xe6, 0xe4, 0xf5, 0xf2, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x50, 0x1f,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00,
+  0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x60, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00,
+  0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x86, 0x00, 0x00, 0x00, 0x4e, 0x41,
+  0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f,
+  0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50,
+  0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x63, 0x82,
+  0xe4, 0xf4, 0x29, 0x67, 0x41, 0x9b, 0x27, 0xdf, 0xce, 0x83, 0x4e, 0x78,
+  0x01, 0xd6, 0xf3, 0xc5, 0x34, 0x38, 0x15, 0x0a, 0x0b, 0x3a, 0x6e, 0xc6,
+  0x9a, 0xb7, 0x3b, 0x8f, 0x19, 0x4f, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00,
+  0x10, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54,
+  0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x4a, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00,
+  0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56,
+  0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x54, 0x3f, 0x4e, 0x00, 0xe4, 0xb5, 0x11, 0x83, 0x07, 0xe1, 0x16,
+  0xbd, 0xe2, 0x4a, 0x65, 0xc1, 0xb1, 0xf2, 0x03, 0x91, 0x7d, 0xa1, 0x48,
+  0xf1, 0x9b, 0x1f, 0xe7, 0xa0, 0xe0, 0x46, 0xa5, 0xcc, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0xc0, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x6c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
+  0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x45,
+  0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x15,
+  0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56, 0x41,
+  0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44, 0x54,
+  0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03, 0x00,
+  0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63,
+  0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f,
+  0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05, 0x00,
+  0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x84, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00,
+  0x00, 0x21, 0x0c, 0x00, 0x00, 0x65, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x78,
+  0xc2, 0x00, 0x2c, 0x40, 0x15, 0xa4, 0x01, 0x28, 0x0c, 0xe1, 0x90, 0x0e,
+  0xf2, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe6, 0x60, 0x0e, 0xe5, 0x20, 0x0f,
+  0x6d, 0xe0, 0x0e, 0xef, 0xd0, 0x06, 0xe1, 0xc0, 0x0e, 0xe9, 0x10, 0x0e,
+  0xf3, 0x00, 0x6c, 0xf0, 0x06, 0x02, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50,
+  0x18, 0xc2, 0x21, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1,
+  0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0, 0x1d, 0xde, 0xa1, 0x0d, 0xc2, 0x81,
+  0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0,
+  0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88,
+  0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6,
+  0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00,
+  0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83,
+  0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90,
+  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20,
+  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x10, 0xdb, 0x95, 0x3f, 0xeb, 0x2c,
+  0xc8, 0xf0, 0x57, 0x44, 0x34, 0x11, 0xd7, 0x90, 0x08, 0x80, 0x0e, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8, 0x20,
+  0x50, 0xf4, 0x6c, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x00, 0x0a, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50,
+  0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46, 0x00, 0x68, 0x8d, 0x25, 0x48,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0x3c, 0xec, 0x7c, 0x00, 0x00, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x01,
+  0x13, 0x19, 0x0c, 0x12, 0x59, 0x85, 0x53, 0x24, 0x90, 0xe4, 0x19, 0xca,
+  0x83, 0x44, 0x17, 0xa2, 0x24, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61,
+  0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69,
+  0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f, 0x75, 0x74,
+  0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f,
+  0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70,
+  0x75, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
+  0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e, 0x65,
+  0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f,
+  0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f,
+  0x5f, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61,
+  0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74,
+  0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d,
+  0x00, 0xc4, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0xa0,
+  0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08, 0x23, 0x08, 0xca, 0x30,
+  0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82, 0xa0, 0x14, 0x23, 0x08,
+  0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5f, 0x00, 0x06, 0x33, 0x0c,
+  0x61, 0x20, 0x88, 0xc1, 0x0c, 0xc1, 0x30, 0xc3, 0xf0, 0x7d, 0x63, 0x30,
+  0x03, 0x41, 0x84, 0x41, 0x18, 0x8c, 0xc1, 0x0c, 0x41, 0x31, 0x43, 0x60,
+  0xcc, 0x10, 0x1c, 0x33, 0x14, 0x48, 0xa2, 0x2c, 0xcc, 0x0c, 0x46, 0xe3,
+  0x24, 0xca, 0xf2, 0xcc, 0x50, 0x40, 0x49, 0xb4, 0x48, 0x33, 0x0c, 0x70,
+  0x10, 0x07, 0x72, 0x30, 0x83, 0x32, 0x06, 0x13, 0x35, 0x06, 0x61, 0x50,
+  0x25, 0xd6, 0xc2, 0xcc, 0xa0, 0x84, 0xc1, 0x44, 0x85, 0x41, 0x18, 0x54,
+  0x89, 0xb2, 0x3c, 0x33, 0x40, 0xdf, 0x85, 0x95, 0x01, 0xf5, 0x85, 0x41,
+  0xa6, 0x95, 0xc1, 0x66, 0x06, 0x09, 0xb7, 0x74, 0x33, 0x40, 0x67, 0x70,
+  0x61, 0x65, 0x40, 0x9d, 0x41, 0x18, 0x64, 0x5a, 0x19, 0x6c, 0x66, 0x90,
+  0x70, 0x8b, 0x37, 0x03, 0x41, 0x07, 0x75, 0x60, 0x07, 0x77, 0x30, 0xc3,
+  0x40, 0x06, 0x73, 0x80, 0x07, 0xb5, 0x01, 0x1c, 0xc7, 0x71, 0x1c, 0xc7,
+  0x71, 0x1c, 0x1a, 0xb8, 0x81, 0x85, 0x06, 0x7a, 0x60, 0x59, 0x96, 0x1b,
+  0xd0, 0x81, 0x1b, 0xd0, 0x81, 0x2f, 0xf8, 0x02, 0x4a, 0xd0, 0x04, 0x28,
+  0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b,
+  0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45,
+  0x38, 0x03, 0x34, 0x38, 0x85, 0x8d, 0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac,
+  0xcc, 0x8d, 0x6e, 0x94, 0x20, 0x0d, 0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1,
+  0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x50, 0x83, 0xa3, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe,
+  0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46, 0x09, 0xd6, 0xe0, 0xa6,
+  0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf,
+  0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51, 0x06, 0x36, 0x68, 0x03,
+  0x37, 0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c,
+  0x6f, 0x94, 0x00, 0x0f, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x25, 0x00, 0x00,
+  0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70,
+  0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82,
+  0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6,
+  0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x16, 0x34, 0xe3, 0x60,
+  0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4, 0x40, 0x0f, 0xe1, 0x20,
+  0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81, 0x07, 0x79, 0x28, 0x87,
+  0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01, 0x3b, 0xa4, 0x83, 0x3d,
+  0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xdc,
+  0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c, 0xe8, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
+  0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1, 0x50, 0x0f, 0xf4, 0x80,
+  0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03,
+  0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xc4, 0x4a, 0xa0,
+  0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1, 0x58,
+  0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30, 0x0c, 0x03, 0x81, 0x31, 0x02,
+  0x10, 0x04, 0x41, 0xfc, 0xa3, 0x30, 0x03, 0x30, 0x03, 0x40, 0x62, 0x06,
+  0x80, 0xc6, 0x0c, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x2c, 0x00, 0x00,
+  0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0x08, 0x3d, 0x00, 0x00, 0x00,
+  0x00, 0xcf, 0x23, 0x06, 0x96, 0x05, 0x00, 0x00, 0x00, 0x6f, 0x6d, 0x6e,
+  0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72,
+  0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54,
+  0x42, 0x41, 0x41, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f,
+  0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78,
+  0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73,
+  0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x61,
+  0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f,
+  0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x32, 0x29, 0x13, 0x04, 0x06,
+  0x59, 0x21, 0x80, 0x02, 0x1f, 0xac, 0x18, 0x42, 0x01, 0x14, 0xfa, 0x60,
+  0xc5, 0x20, 0x0a, 0xa0, 0xe0, 0x07, 0x1b, 0x82, 0x3d, 0xd8, 0x30, 0xe8,
+  0xc1, 0x28, 0xfc, 0xc1, 0x86, 0x81, 0x14, 0x48, 0xe1, 0x0f, 0x36, 0x04,
+  0xa1, 0xb0, 0x21, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0xbb, 0x10, 0x8d,
+  0x64, 0x49, 0x14, 0x84, 0xb2, 0x0b, 0x01, 0x51, 0x18, 0x45, 0x41, 0x28,
+  0x83, 0x0c, 0xc3, 0xd1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0x04, 0x85, 0x71,
+  0x12, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0x0c, 0x64, 0x42, 0x20, 0xfe, 0x16,
+  0x14, 0xe0, 0xbf, 0x0b, 0x91, 0x75, 0x61, 0x50, 0x51, 0x10, 0xca, 0x20,
+  0x03, 0x13, 0x51, 0x26, 0x04, 0xe2, 0x6f, 0x45, 0x00, 0xfe, 0xbb, 0x10,
+  0x9e, 0x18, 0x98, 0xc1, 0x46, 0x41, 0x28, 0x83, 0x0c, 0x91, 0x85, 0x99,
+  0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x88, 0xc1, 0x19, 0xac,
+  0x41, 0x18, 0x50, 0x10, 0xca, 0x20, 0x43, 0xa0, 0x81, 0x81, 0x05, 0x95,
+  0xf8, 0x0f, 0x32, 0x0c, 0x5d, 0x18, 0x58, 0x30, 0x89, 0xbf, 0x0d, 0x01,
+  0xf8, 0x0f, 0x32, 0x18, 0x60, 0x30, 0x06, 0x16, 0x44, 0xe2, 0x6f, 0x43,
+  0x00, 0xfe, 0x83, 0x0c, 0xc9, 0x18, 0x94, 0x81, 0x05, 0x8f, 0xf8, 0xdb,
+  0x10, 0x80, 0xff, 0x2e, 0xc4, 0x1b, 0xd0, 0x01, 0x1e, 0xb4, 0x01, 0x05,
+  0xa1, 0x0c, 0x32, 0x04, 0x67, 0xd0, 0x06, 0x16, 0x88, 0x81, 0xf8, 0x0f,
+  0x32, 0x0c, 0x6a, 0xe0, 0x06, 0x16, 0x80, 0x81, 0xf8, 0x0f, 0x32, 0x14,
+  0x6c, 0xf0, 0x06, 0x16, 0x74, 0xe2, 0x3f, 0xc8, 0x70, 0xb8, 0x01, 0x1c,
+  0x58, 0xa0, 0x89, 0xff, 0x20, 0x03, 0x1f, 0xb4, 0x41, 0x1d, 0x58, 0x16,
+  0x88, 0xff, 0x20, 0x83, 0x1f, 0xbc, 0x81, 0x1d, 0x98, 0x13, 0x88, 0xbf,
+  0x25, 0x03, 0xf8, 0x5b, 0xc0, 0x80, 0xbf, 0x05, 0x09, 0xf8, 0x5b, 0x80,
+  0x80, 0xbf, 0x05, 0x05, 0xf8, 0xcf, 0x36, 0xdc, 0x41, 0x00, 0xcc, 0x36,
+  0x04, 0xa5, 0x10, 0xcc, 0x36, 0x04, 0x7c, 0x20, 0x64, 0x10, 0x10, 0x03,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20, 0x20, 0x85, 0xa3, 0x14,
+  0x10, 0x53, 0xd8, 0x72, 0x0c, 0x01, 0x29, 0x1c, 0xa6, 0x80, 0x94, 0xc2,
+  0x96, 0xe3, 0x08, 0x48, 0xe1, 0x30, 0x05, 0xa4, 0x14, 0xb6, 0x1c, 0x4c,
+  0x40, 0x0a, 0x87, 0x29, 0x20, 0xa5, 0xb0, 0xe5, 0x88, 0x02, 0x52, 0x38,
+  0x4c, 0x01, 0x29, 0x85, 0x2d, 0x87, 0x15, 0x90, 0xc2, 0x51, 0x0a, 0x88,
+  0x29, 0x6c, 0x39, 0xc6, 0x20, 0x20, 0x85, 0xa3, 0x14, 0x10, 0x53, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xd9, 0x05, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0x78, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65,
+  0x78, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x61, 0x69,
+  0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f,
+  0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75,
+  0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x90, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00,
+  0x00, 0x21, 0x0c, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x78,
+  0x02, 0x01, 0x2c, 0x40, 0x15, 0xa4, 0x01, 0x28, 0x0c, 0xe1, 0x90, 0x0e,
+  0xf2, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe6, 0x60, 0x0e, 0xe5, 0x20, 0x0f,
+  0x6d, 0xe0, 0x0e, 0xef, 0xd0, 0x06, 0xe1, 0xc0, 0x0e, 0xe9, 0x10, 0x0e,
+  0xf3, 0x00, 0x6c, 0xf0, 0x86, 0x02, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50,
+  0x18, 0xc2, 0x21, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1,
+  0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0, 0x1d, 0xde, 0xa1, 0x0d, 0xc2, 0x81,
+  0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c,
+  0x11, 0x84, 0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00,
+  0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83,
+  0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90,
+  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20,
+  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x0f, 0xdb, 0x95, 0x3f, 0xe7, 0x3c,
+  0xd8, 0x5f, 0x11, 0xd1, 0x44, 0x5c, 0x43, 0x22, 0xe0, 0x39, 0x00, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x40, 0x62, 0x83, 0x40,
+  0x51, 0xb5, 0x01, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0a, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50,
+  0x06, 0x05, 0x18, 0x50, 0x20, 0xc4, 0x46, 0x00, 0x68, 0x8d, 0x25, 0x48,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0x3a, 0x8c, 0x7d, 0x00, 0x00, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x01,
+  0x13, 0x19, 0x0c, 0x12, 0x59, 0x45, 0x66, 0x20, 0x90, 0xe4, 0x29, 0x0f,
+  0x12, 0x5d, 0x88, 0x92, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61,
+  0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69,
+  0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f, 0x75, 0x74,
+  0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
+  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72,
+  0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f, 0x70,
+  0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x5f,
+  0x29, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61,
+  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72,
+  0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e,
+  0x73, 0x66, 0x6f, 0x72, 0x6d, 0x04, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08,
+  0x23, 0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82,
+  0xa0, 0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5e,
+  0xf0, 0xcd, 0x30, 0x80, 0x81, 0x10, 0x06, 0x33, 0x04, 0xc3, 0x0c, 0x83,
+  0xe7, 0x89, 0xc1, 0x0c, 0x04, 0x01, 0x06, 0x60, 0x20, 0x06, 0x33, 0x04,
+  0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x89, 0xb2, 0x30,
+  0x33, 0x18, 0x8d, 0x93, 0x28, 0xcb, 0x33, 0x83, 0xd1, 0x40, 0x49, 0xb4,
+  0x48, 0x33, 0x0c, 0x6f, 0x00, 0x07, 0x71, 0x30, 0x83, 0x22, 0x06, 0x13,
+  0x25, 0x06, 0x60, 0x50, 0x25, 0xd1, 0xc2, 0xcc, 0xa0, 0x80, 0xc1, 0x44,
+  0x81, 0x01, 0x18, 0x54, 0x89, 0xb2, 0x3c, 0x33, 0x28, 0xde, 0x44, 0x79,
+  0x60, 0x50, 0x25, 0xd1, 0x22, 0xcd, 0x00, 0x91, 0x81, 0x75, 0x95, 0x01,
+  0xe5, 0x81, 0x01, 0x96, 0x95, 0x81, 0x66, 0x06, 0xc9, 0xb6, 0x70, 0x33,
+  0x40, 0x61, 0x60, 0x5d, 0x65, 0x40, 0x91, 0x01, 0x18, 0x60, 0x59, 0x19,
+  0x68, 0x66, 0x90, 0x6c, 0x4b, 0x37, 0x43, 0x31, 0x07, 0x74, 0x50, 0x07,
+  0x76, 0x70, 0x07, 0x33, 0x0c, 0x63, 0x20, 0x07, 0x78, 0x50, 0x1c, 0xc0,
+  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x89, 0x81, 0x1b, 0x58, 0x68, 0xa0,
+  0x07, 0x96, 0x65, 0xb9, 0x01, 0x1d, 0xd0, 0x01, 0x1d, 0xf8, 0x82, 0x2f,
+  0xc8, 0x82, 0x4b, 0xd0, 0x04, 0x2b, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62,
+  0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31,
+  0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0x30, 0x83, 0x33, 0x38, 0x85, 0x8d,
+  0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x00, 0x0d,
+  0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
+  0x1b, 0x25, 0x48, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc,
+  0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde,
+  0xdc, 0x46, 0x09, 0xd4, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7,
+  0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7,
+  0xb9, 0x51, 0x86, 0x35, 0x60, 0x83, 0x36, 0x38, 0x25, 0x2c, 0x4d, 0xce,
+  0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c, 0x6f, 0x94, 0x00, 0x0f, 0x00, 0x00,
+  0x00, 0xa9, 0x18, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72,
+  0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8,
+  0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1,
+  0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f,
+  0xe1, 0x20, 0x0f, 0xe4, 0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e,
+  0xf4, 0xb0, 0x80, 0x81, 0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76,
+  0x78, 0x87, 0x71, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c,
+  0xc3, 0x38, 0xb4, 0x01, 0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b,
+  0x1c, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61,
+  0x1c, 0xdc, 0x20, 0x1c, 0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1,
+  0x1c, 0xc8, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f,
+  0xf4, 0x20, 0x0f, 0xe1, 0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00,
+  0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c,
+  0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x8a, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x09, 0x00, 0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc,
+  0x08, 0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2,
+  0x58, 0xc4, 0x30, 0x0c, 0x03, 0x85, 0x19, 0x80, 0x19, 0x00, 0x12, 0x33,
+  0x00, 0x34, 0x66, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x2c, 0x00, 0x00,
+  0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0xc8, 0x3c, 0x00, 0x00, 0x00,
+  0x00, 0xcf, 0x13, 0x06, 0x96, 0x05, 0x00, 0x00, 0x00, 0x6f, 0x6d, 0x6e,
+  0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72,
+  0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54,
+  0x42, 0x41, 0x41, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f,
+  0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x29,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x34, 0x29, 0x61, 0x69,
+  0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70,
+  0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x00, 0x13, 0x04, 0x06,
+  0x59, 0x21, 0x80, 0x02, 0x1f, 0xac, 0x18, 0x42, 0x01, 0x14, 0xfa, 0x60,
+  0xc5, 0x20, 0x0a, 0xa0, 0xe0, 0x07, 0x1b, 0x82, 0x3d, 0xd8, 0x30, 0xe8,
+  0xc1, 0x28, 0xfc, 0xc1, 0x86, 0x81, 0x14, 0x48, 0xe1, 0x0f, 0x36, 0x04,
+  0xa1, 0xb0, 0x21, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0xbb, 0x10, 0x8c,
+  0x64, 0x49, 0x14, 0x84, 0xb2, 0x0b, 0xf1, 0x50, 0x18, 0x45, 0x41, 0x28,
+  0x83, 0x0c, 0xc3, 0xc1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0xc4, 0x84, 0x71,
+  0x11, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0xcc, 0x63, 0x42, 0x20, 0xfe, 0x16,
+  0x14, 0xe0, 0xbf, 0x0b, 0x81, 0x75, 0x61, 0x40, 0x51, 0x10, 0xca, 0x20,
+  0x03, 0x13, 0x4d, 0x26, 0x04, 0xe2, 0x6f, 0x45, 0x00, 0xfe, 0xbb, 0x10,
+  0x9d, 0x18, 0x98, 0x81, 0x46, 0x41, 0x28, 0x83, 0x0c, 0x91, 0x75, 0x99,
+  0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x84, 0xc1, 0x19, 0xac,
+  0x01, 0x18, 0x50, 0x10, 0xca, 0x20, 0x43, 0xa0, 0x7d, 0x16, 0x54, 0xe2,
+  0x3f, 0xc8, 0x30, 0x74, 0x60, 0x60, 0xc1, 0x24, 0xfe, 0x36, 0x04, 0xe0,
+  0x3f, 0xc8, 0x60, 0x80, 0x81, 0x18, 0x58, 0x10, 0x89, 0xbf, 0x0d, 0x01,
+  0xf8, 0x0f, 0x32, 0x24, 0x63, 0x40, 0x06, 0x16, 0x3c, 0xe2, 0x6f, 0x43,
+  0x00, 0xfe, 0xbb, 0x10, 0x6e, 0x40, 0x07, 0x78, 0xc0, 0x06, 0x14, 0x84,
+  0x32, 0xc8, 0x10, 0x9c, 0x01, 0x1b, 0x58, 0x20, 0x06, 0xe2, 0x3f, 0xc8,
+  0x30, 0xa8, 0x41, 0x1b, 0x58, 0x00, 0x06, 0xe2, 0x3f, 0xc8, 0x50, 0xb0,
+  0x81, 0x1b, 0x58, 0xd0, 0x89, 0xff, 0x20, 0xc3, 0xe1, 0x06, 0x6f, 0x60,
+  0x81, 0x26, 0xfe, 0x83, 0x0c, 0x7c, 0xe0, 0x06, 0x74, 0x60, 0x59, 0x20,
+  0xfe, 0x83, 0x0c, 0x7e, 0x00, 0x07, 0x75, 0x60, 0x4e, 0x20, 0xfe, 0x96,
+  0x0c, 0xe0, 0x6f, 0x01, 0x03, 0xfe, 0x16, 0x24, 0xe0, 0x6f, 0x01, 0x02,
+  0xfe, 0x16, 0x14, 0xe0, 0x3f, 0xdb, 0x60, 0x07, 0x01, 0x30, 0xdb, 0x10,
+  0x94, 0x42, 0x30, 0xdb, 0x10, 0x94, 0x82, 0x90, 0x41, 0x40, 0x0c, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20, 0x20, 0x85, 0xa3, 0x14,
+  0x10, 0x53, 0xd8, 0x72, 0x0c, 0x01, 0x29, 0x1c, 0xa6, 0x80, 0x94, 0xc2,
+  0x96, 0xe3, 0x08, 0x48, 0xe1, 0x30, 0x05, 0xa4, 0x14, 0xb6, 0x1c, 0x4c,
+  0x40, 0x0a, 0x87, 0x29, 0x20, 0xa5, 0xb0, 0xe5, 0x88, 0x02, 0x52, 0x38,
+  0x4c, 0x01, 0x29, 0x85, 0x2d, 0x87, 0x15, 0x90, 0xc2, 0x51, 0x0a, 0x88,
+  0x29, 0x6c, 0x39, 0xc6, 0x20, 0x20, 0x85, 0xa3, 0x14, 0x10, 0x53, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xde, 0x05, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x0f, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0x77, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78,
+  0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x61, 0x69, 0x72,
+  0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73,
+  0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c,
+  0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xf4, 0x0d, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05,
+  0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x40, 0x03, 0x00,
+  0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e,
+  0x90, 0x11, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x21, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x71, 0x00, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0x03,
+  0x40, 0x02, 0x28, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0,
+  0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87,
+  0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07,
+  0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07,
+  0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07,
+  0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87,
+  0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc,
+  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87,
+  0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca,
+  0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda,
+  0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda,
+  0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88,
+  0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0xd8, 0xe0, 0x09, 0x03, 0xb0, 0x00, 0x55, 0x90,
+  0x06, 0x60, 0x30, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d,
+  0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b,
+  0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x3c, 0x33,
+  0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x67, 0x49, 0x53, 0x44,
+  0x09, 0x93, 0xcf, 0x1e, 0xc0, 0x40, 0x44, 0x9c, 0xd3, 0x48, 0x13, 0xd0,
+  0x4c, 0x12, 0x42, 0x00, 0x00, 0x00, 0x00, 0x06, 0x11, 0x06, 0xa1, 0x10,
+  0x21, 0x41, 0x54, 0x03, 0x01, 0x73, 0x04, 0x60, 0x90, 0x02, 0x38, 0x47,
+  0x00, 0x0a, 0x83, 0x08, 0x80, 0x30, 0x8c, 0x30, 0x00, 0xc3, 0x08, 0x04,
+  0x32, 0x02, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0,
+  0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68,
+  0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70,
+  0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78,
+  0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79,
+  0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x12, 0xdb,
+  0x95, 0x3f, 0xeb, 0x2c, 0xc8, 0xf0, 0x17, 0x11, 0x60, 0x30, 0x44, 0x33,
+  0x0d, 0x89, 0x00, 0xa9, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x00, 0x89, 0x0d, 0x02, 0x45, 0x85, 0x06, 0x00, 0x00, 0xb2,
+  0x40, 0x0d, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xc2, 0x22, 0x28, 0x81,
+  0x42, 0x18, 0x01, 0x28, 0xa0, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82,
+  0x29, 0x1c, 0xd2, 0x11, 0x80, 0x42, 0x28, 0x88, 0xc2, 0x28, 0x90, 0x42,
+  0x29, 0x98, 0xc2, 0xa1, 0x1c, 0x4b, 0x90, 0x04, 0x00, 0xb1, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x79, 0x20, 0x00, 0x00, 0xf6, 0x00, 0x00,
+  0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8,
+  0x11, 0x32, 0x64, 0xd4, 0xca, 0x00, 0x0c, 0x66, 0x09, 0x8b, 0x12, 0x07,
+  0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x52, 0xa6, 0x3c, 0x06, 0x83, 0x58,
+  0x85, 0xf2, 0x48, 0x08, 0x55, 0x30, 0x8c, 0xb2, 0x38, 0xcf, 0xf3, 0x44,
+  0xd7, 0x13, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65,
+  0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
+  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38,
+  0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x76, 0x32, 0x5f,
+  0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74,
+  0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73,
+  0x69, 0x74, 0x69, 0x6f, 0x6e, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34,
+  0x5f, 0x66, 0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e,
+  0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61,
+  0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74,
+  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x74, 0x6f, 0x6e,
+  0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x74,
+  0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f,
+  0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61,
+  0x63, 0x74, 0x6f, 0x72, 0x32, 0x73, 0x64, 0x72, 0x5f, 0x77, 0x68, 0x69,
+  0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61,
+  0x6e, 0x74, 0x73, 0x63, 0x00, 0x44, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0x80, 0x04, 0x23, 0x08, 0x09, 0x35, 0x82, 0x80, 0x08,
+  0x23, 0x08, 0xc8, 0x30, 0x82, 0x80, 0x10, 0x23, 0x08, 0x06, 0x30, 0x82,
+  0x80, 0x14, 0x23, 0x08, 0x88, 0x31, 0x82, 0x80, 0x1c, 0x23, 0x08, 0x08,
+  0x32, 0x82, 0x80, 0x24, 0x23, 0x08, 0x88, 0x32, 0x82, 0x80, 0x2c, 0x33,
+  0x0c, 0x66, 0x10, 0x9c, 0xc1, 0x0c, 0x03, 0x1a, 0x08, 0x69, 0x30, 0x43,
+  0x30, 0xcc, 0x30, 0x98, 0x81, 0x19, 0xa8, 0xc1, 0x0c, 0x04, 0x81, 0x06,
+  0x68, 0xa0, 0x06, 0x33, 0x04, 0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc,
+  0x50, 0x20, 0x6a, 0xa0, 0x06, 0x89, 0x32, 0x43, 0xb0, 0x07, 0x33, 0x24,
+  0x6a, 0xb0, 0x30, 0x8d, 0x93, 0x3c, 0x50, 0x34, 0x43, 0x82, 0x06, 0x8b,
+  0xd4, 0x38, 0x89, 0x02, 0x4d, 0x33, 0xa0, 0x81, 0x1a, 0xa4, 0x81, 0x1a,
+  0x64, 0x5a, 0x1a, 0xa4, 0x81, 0x1a, 0x64, 0x5b, 0x1b, 0xa4, 0x81, 0x1a,
+  0x64, 0x9c, 0x1b, 0xa4, 0x81, 0x1a, 0x64, 0xdd, 0x1b, 0xa4, 0x81, 0x1a,
+  0x64, 0x1e, 0x1c, 0xa4, 0x81, 0x1a, 0x64, 0x5f, 0x1c, 0xa4, 0x81, 0x1a,
+  0x64, 0x60, 0x20, 0x07, 0x69, 0xa0, 0x06, 0x59, 0x18, 0xcc, 0x20, 0x99,
+  0x01, 0x55, 0xb1, 0x81, 0xa5, 0x06, 0x68, 0x70, 0x61, 0x7f, 0x20, 0x06,
+  0x6c, 0x30, 0x06, 0x69, 0x90, 0x90, 0x01, 0x54, 0x06, 0x33, 0x0c, 0x7d,
+  0xe0, 0x07, 0xa0, 0x30, 0xc3, 0xb0, 0x06, 0x7c, 0x10, 0x0a, 0xd5, 0x01,
+  0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x9c, 0x1b, 0xb8,
+  0x81, 0x45, 0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xac, 0xc0, 0x0a,
+  0x62, 0xe3, 0x17, 0x74, 0x20, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd,
+  0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d,
+  0xec, 0x6c, 0x6e, 0x14, 0x41, 0x0e, 0xe6, 0xe0, 0x14, 0x36, 0x36, 0xbb,
+  0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51, 0x02, 0x3a, 0xb8, 0x25,
+  0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94,
+  0xa0, 0x0e, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab,
+  0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b,
+  0x25, 0xb0, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0,
+  0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46,
+  0x19, 0xee, 0x00, 0x0f, 0xf2, 0xe0, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33,
+  0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51, 0x82, 0x50, 0x00, 0x00,
+  0x00, 0xa9, 0x18, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72,
+  0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8,
+  0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1,
+  0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f,
+  0xe1, 0x20, 0x0f, 0xe4, 0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e,
+  0xf4, 0xb0, 0x80, 0x81, 0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76,
+  0x78, 0x87, 0x71, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c,
+  0xc3, 0x38, 0xb4, 0x01, 0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b,
+  0x1c, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61,
+  0x1c, 0xdc, 0x20, 0x1c, 0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1,
+  0x1c, 0xc8, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f,
+  0xf4, 0x20, 0x0f, 0xe1, 0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00,
+  0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c,
+  0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x4e, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x84, 0x65, 0x30, 0x03, 0x40, 0x5a, 0x06,
+  0xd4, 0x73, 0x10, 0x04, 0x41, 0x64, 0x04, 0x63, 0x04, 0x20, 0x08, 0x82,
+  0xf8, 0x47, 0x3c, 0x03, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0x48, 0x3d, 0x00, 0x00, 0x00,
+  0x00, 0xd5, 0xf3, 0x90, 0x81, 0x05, 0x00, 0x00, 0x00, 0x5f, 0x5a, 0x54,
+  0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
+  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
+  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
+  0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x29,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x32, 0x29, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x85, 0x99, 0x20, 0x28, 0xcd, 0x04, 0x41, 0x71, 0x26,
+  0x08, 0xca, 0x33, 0x41, 0x50, 0xa0, 0x09, 0x82, 0x12, 0x4d, 0x10, 0x14,
+  0x69, 0x82, 0xa0, 0x4c, 0x2b, 0x04, 0x58, 0x30, 0x85, 0x15, 0x43, 0x2c,
+  0xc0, 0xc2, 0x29, 0x6c, 0x08, 0x4a, 0x61, 0xc3, 0x40, 0x0a, 0xb2, 0x80,
+  0x0a, 0x1b, 0x86, 0x6c, 0x16, 0x50, 0x61, 0x43, 0x34, 0x0a, 0xb4, 0x80,
+  0x0a, 0xb4, 0x90, 0x0a, 0xb4, 0xa0, 0x0a, 0xb4, 0xb0, 0x0a, 0xb4, 0xc0,
+  0x0a, 0xb4, 0xd0, 0x0a, 0xb4, 0xe0, 0x0a, 0xb4, 0xf0, 0x0a, 0x1b, 0x86,
+  0x5a, 0xa0, 0x85, 0x55, 0xd8, 0x10, 0xc4, 0x02, 0x00, 0x7b, 0x86, 0x43,
+  0x32, 0x28, 0x80, 0x31, 0xc7, 0x30, 0x04, 0xd4, 0x20, 0x43, 0x40, 0x18,
+  0x73, 0x0c, 0x81, 0x81, 0x58, 0xd0, 0x88, 0x7f, 0x06, 0x01, 0x31, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x8a, 0x20, 0xa8, 0x85, 0xc3, 0x16,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xf2, 0x05, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
+  0x65, 0x6e, 0x74, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34,
+  0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d,
+  0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69,
+  0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x30, 0x1f, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05,
+  0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x04, 0x07, 0x00,
+  0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e,
+  0x90, 0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x64, 0x01, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03,
+  0x40, 0x02, 0x2a, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0,
+  0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87,
+  0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07,
+  0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07,
+  0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07,
+  0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87,
+  0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc,
+  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87,
+  0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca,
+  0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda,
+  0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda,
+  0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88,
+  0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0xd8, 0xe0, 0x09, 0x04, 0xb0, 0x00, 0x55, 0x90,
+  0x06, 0x60, 0x30, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d,
+  0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b,
+  0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0xc1, 0x18, 0x0a,
+  0x60, 0x01, 0xaa, 0x0d, 0x06, 0x61, 0x00, 0x0b, 0x50, 0x6d, 0x08, 0x93,
+  0xe2, 0xff, 0xff, 0xff, 0xff, 0x07, 0x60, 0x0d, 0x00, 0x09, 0xa8, 0x88,
+  0x70, 0x80, 0x07, 0x78, 0x90, 0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xa2, 0x1d, 0xd2, 0xc1, 0x1d, 0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2,
+  0x81, 0x1d, 0xda, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
+  0xa1, 0x0d, 0xee, 0x21, 0x1d, 0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03,
+  0x39, 0xc0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87,
+  0x74, 0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc,
+  0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6,
+  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03,
+  0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2,
+  0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88,
+  0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87,
+  0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03,
+  0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87,
+  0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6,
+  0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda,
+  0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07,
+  0x60, 0x43, 0x62, 0x08, 0xc0, 0x02, 0x54, 0x41, 0x1a, 0x80, 0xc1, 0x06,
+  0xe3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x8f,
+  0x20, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x12, 0x50, 0x11, 0xe1, 0x00,
+  0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0,
+  0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b,
+  0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b,
+  0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b,
+  0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03, 0x90, 0x07, 0x76, 0x00,
+  0x0c, 0xee, 0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5, 0x90, 0x0e, 0xec, 0x40,
+  0x0f, 0xe9, 0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x60,
+  0x0e, 0xf2, 0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0xef, 0x90,
+  0x0e, 0xee, 0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d, 0x50, 0x0e, 0xec, 0x90,
+  0x0e, 0xed, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94, 0x43, 0x1b,
+  0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8, 0x43, 0x1b,
+  0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81, 0x3b, 0xbc, 0x83, 0x3b,
+  0xb4, 0x01, 0x3b, 0x94, 0x43, 0x38, 0x98, 0x03, 0x40, 0x0f, 0xf2, 0x50,
+  0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x90, 0x0e, 0xee, 0x60,
+  0x0e, 0xf3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3, 0x3c, 0xb4, 0x81, 0x39,
+  0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20,
+  0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xf3, 0x90,
+  0x0e, 0xe7, 0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d, 0xa0, 0x0f, 0xe5, 0x20,
+  0x0f, 0xef, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40,
+  0xb8, 0xc3, 0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43, 0x38, 0xc0, 0x03, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a,
+  0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0x31, 0x0f, 0xf4, 0x10,
+  0x0e, 0xe3, 0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2, 0xf0, 0x0e, 0xf4, 0x50,
+  0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d, 0x20, 0x0e, 0xf5, 0x60,
+  0x0e, 0xe6, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xfa, 0x50,
+  0x0e, 0x00, 0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3, 0x3c, 0x84, 0x83, 0x39,
+  0x94, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d,
+  0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x6c, 0x50, 0x92,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x80, 0x36, 0x00, 0xd6, 0x00, 0x90, 0x80,
+  0x6a, 0x83, 0xa1, 0x04, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x45, 0x00, 0x16,
+  0xa0, 0xda, 0xa0, 0x30, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x6d, 0x00,
+  0xac, 0x01, 0x20, 0x01, 0xd5, 0x86, 0xa9, 0xf9, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x58, 0x03, 0x40, 0x19, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1c, 0xea,
+  0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6, 0x01, 0xd8, 0x50,
+  0x38, 0x42, 0x90, 0x06, 0x60, 0xb0, 0xc1, 0x78, 0xfe, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0x24, 0x80, 0xda, 0x10, 0x41, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x00, 0xca, 0xe0, 0x0e, 0xef, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe9, 0xc0,
+  0x0e, 0xf4, 0x90, 0x0e, 0xee, 0x30, 0x0f, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x42,
+  0x61, 0x4c, 0x08, 0x8e, 0x09, 0x01, 0x32, 0x61, 0x48, 0x94, 0x65, 0xc2,
+  0xc0, 0x28, 0xcb, 0x04, 0xa1, 0x71, 0x26, 0x04, 0xcf, 0x84, 0x00, 0x02,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4,
+  0x4c, 0x10, 0xb4, 0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08,
+  0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11,
+  0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x41, 0x84, 0x41, 0x38, 0x4a, 0x9a, 0x22, 0x4a, 0x98, 0xfc,
+  0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0xfe, 0x69, 0x8c, 0x00,
+  0x18, 0x44, 0x28, 0x82, 0x8b, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x25,
+  0x80, 0x79, 0x16, 0x22, 0xfa, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x10,
+  0xca, 0x11, 0x04, 0x81, 0x40, 0x18, 0x08, 0x25, 0x65, 0x08, 0x02, 0x82,
+  0x96, 0x61, 0x84, 0x01, 0x28, 0x44, 0xd3, 0x34, 0x0d, 0x39, 0x65, 0x00,
+  0x00, 0x80, 0xa0, 0x22, 0x00, 0x00, 0x49, 0x73, 0x04, 0x41, 0x11, 0x28,
+  0x80, 0xaa, 0x32, 0x00, 0x4d, 0x43, 0x57, 0x31, 0x9a, 0x06, 0x00, 0x00,
+  0x80, 0xb2, 0x32, 0x34, 0x4d, 0x43, 0x5b, 0x11, 0x9a, 0x86, 0xba, 0x39,
+  0x02, 0xc4, 0x08, 0xc1, 0x37, 0x47, 0x00, 0x06, 0xc3, 0x08, 0x42, 0x18,
+  0x14, 0x05, 0x34, 0x10, 0x81, 0x12, 0x29, 0x00, 0x08, 0x69, 0x1c, 0x08,
+  0x48, 0x81, 0x70, 0x04, 0x60, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x00, 0x61,
+  0x0a, 0x60, 0x18, 0x61, 0x08, 0x83, 0x61, 0x04, 0x22, 0x0c, 0x00, 0x00,
+  0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83,
+  0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90,
+  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20,
+  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x11, 0xdb, 0x95, 0x3f, 0xe7, 0x3c,
+  0xd8, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x34, 0x24, 0x02, 0xa2, 0x04,
+  0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x86, 0x44,
+  0x11, 0x1e, 0x2c, 0x08, 0x30, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x30, 0x24, 0x4a, 0x05, 0xca, 0x01, 0x02, 0x60, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0x00, 0x00, 0x80, 0x21, 0x51, 0x2f, 0x40, 0x10, 0x10, 0x00,
+  0x03, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x89, 0xda, 0x21,
+  0x92, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60,
+  0x48, 0xe4, 0x0f, 0x56, 0x05, 0x04, 0xc0, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x43, 0x22, 0x9a, 0x68, 0x2e, 0x20, 0x00, 0x06, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0x85, 0x45, 0x96, 0x21,
+  0xc0, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc0, 0x90, 0x48,
+  0x2f, 0x22, 0x08, 0x08, 0x80, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x00, 0x86, 0x44, 0xab, 0x21, 0x6d, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x30, 0x24, 0xea, 0x8d, 0xa9, 0x03, 0x02, 0x60,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21, 0x11, 0x7c, 0x4c,
+  0x1b, 0x10, 0x00, 0x03, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0c,
+  0x89, 0x46, 0x64, 0x1b, 0x03, 0x20, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x90, 0xd8, 0x20, 0x50, 0xb4, 0xe0, 0x00, 0x00, 0x20,
+  0x0b, 0x04, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0x0a, 0x8b, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0, 0x0c, 0x0a, 0xa8, 0x20,
+  0x0a, 0xa3, 0x40, 0x0a, 0xa5, 0x60, 0x0a, 0xa7, 0x14, 0x08, 0x1d, 0x01,
+  0x28, 0x84, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0x32,
+  0xc7, 0x12, 0x24, 0x01, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0xde, 0x00, 0x0d, 0x48, 0x0b, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x41,
+  0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca,
+  0x23, 0x21, 0x54, 0xc1, 0x30, 0xca, 0xe2, 0x3c, 0xcf, 0x13, 0x5d, 0x4f,
+  0xb0, 0x28, 0xd8, 0xb0, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4b,
+  0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61,
+  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20,
+  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x20, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20,
+  0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30,
+  0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61,
+  0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72,
+  0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74,
+  0x69, 0x76, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e,
+  0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+  0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f,
+  0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34,
+  0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70,
+  0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
+  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74,
+  0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72,
+  0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72,
+  0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66,
+  0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f,
+  0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72,
+  0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63,
+  0x61, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d,
+  0x65, 0x74, 0x68, 0x6f, 0x64, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70,
+  0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65,
+  0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x73,
+  0x64, 0x72, 0x5f, 0x77, 0x68, 0x69, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69,
+  0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67,
+  0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x63, 0x61, 0x69,
+  0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x72, 0x73, 0x24, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0x10, 0x06, 0xcd, 0x08, 0x82, 0x19, 0x88, 0xc1, 0x08,
+  0x42, 0x18, 0x38, 0x23, 0x08, 0x61, 0xf0, 0x8c, 0x20, 0x84, 0x01, 0x34,
+  0x82, 0xa0, 0x00, 0x23, 0x08, 0x61, 0x10, 0x8d, 0x20, 0x84, 0x81, 0x34,
+  0x82, 0x10, 0x06, 0xd3, 0x08, 0x42, 0x18, 0x50, 0x23, 0x08, 0x61, 0x50,
+  0x8d, 0x20, 0x84, 0x81, 0x35, 0x82, 0x10, 0x06, 0xd7, 0x08, 0x42, 0x18,
+  0x60, 0x23, 0x08, 0x61, 0x90, 0xcd, 0x30, 0xc0, 0x41, 0x10, 0x07, 0x33,
+  0x0c, 0x72, 0x20, 0xcc, 0xc1, 0x0c, 0xc1, 0x30, 0xc3, 0x00, 0x07, 0x70,
+  0x40, 0x07, 0x33, 0x10, 0x84, 0x1c, 0xc8, 0x01, 0x1d, 0xcc, 0x10, 0x14,
+  0x33, 0x04, 0xc6, 0x0c, 0xc1, 0x31, 0x43, 0x81, 0xd0, 0x01, 0x1d, 0x24,
+  0xca, 0x0c, 0xc1, 0x29, 0xcc, 0x80, 0xd0, 0xc1, 0xc2, 0x34, 0x89, 0xe2,
+  0x3c, 0x33, 0x24, 0x72, 0x00, 0x45, 0x8c, 0x94, 0x28, 0xce, 0x34, 0x43,
+  0x02, 0x07, 0x10, 0xc5, 0x48, 0x49, 0xe5, 0x58, 0x33, 0xa0, 0x01, 0x1d,
+  0xcc, 0x01, 0x1d, 0x70, 0xdd, 0x1c, 0xcc, 0x01, 0x1d, 0x70, 0x1e, 0x1e,
+  0xcc, 0x01, 0x1d, 0x70, 0x5f, 0x1e, 0xcc, 0x01, 0x1d, 0x70, 0x60, 0xa0,
+  0x07, 0x73, 0x40, 0x07, 0x5c, 0x18, 0xec, 0xc1, 0x1c, 0xd0, 0x01, 0x27,
+  0x06, 0x7c, 0x30, 0x07, 0x74, 0xc0, 0x8d, 0x41, 0x1f, 0xcc, 0x01, 0x1d,
+  0x70, 0x64, 0x30, 0x83, 0x64, 0x07, 0x17, 0x76, 0x07, 0x19, 0x1d, 0xc8,
+  0x81, 0xb6, 0xb1, 0x42, 0x19, 0xdc, 0x81, 0x19, 0xcc, 0x41, 0x72, 0x06,
+  0x0e, 0x1a, 0xcc, 0xa0, 0xcc, 0x41, 0x1a, 0x64, 0x74, 0x20, 0x07, 0x6a,
+  0x90, 0xac, 0x81, 0xc3, 0x06, 0x33, 0x24, 0x7e, 0xd0, 0x06, 0x19, 0x1d,
+  0xc8, 0x41, 0xe2, 0x06, 0xce, 0x1b, 0xcc, 0x60, 0xa4, 0x82, 0x2a, 0xac,
+  0x42, 0x2b, 0xb8, 0xc2, 0x2b, 0xcc, 0x30, 0xd4, 0x01, 0x2a, 0xc0, 0x42,
+  0x89, 0x01, 0x20, 0x06, 0x68, 0x20, 0x06, 0x62, 0x20, 0x06, 0x9c, 0x18,
+  0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18,
+  0xb8, 0x81, 0x1b, 0x58, 0x74, 0xa0, 0x07, 0x96, 0x65, 0xe9, 0x01, 0x67,
+  0x0a, 0xac, 0xc0, 0x0a, 0x74, 0xe3, 0x17, 0xf6, 0xa0, 0x0e, 0xb8, 0x20,
+  0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d,
+  0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0xc1,
+  0x0f, 0xfe, 0xe0, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32,
+  0x37, 0xba, 0x51, 0x02, 0x50, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0x20, 0x14, 0x8e, 0x0a, 0x4b,
+  0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2,
+  0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x10, 0x85, 0x9b, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde,
+  0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0x46, 0x81, 0x14, 0x4a,
+  0xe1, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32,
+  0x37, 0xba, 0x51, 0x02, 0x58, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80,
+  0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43,
+  0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4,
+  0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81,
+  0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01,
+  0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c,
+  0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c,
+  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1,
+  0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c,
+  0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90,
+  0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3e, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x44, 0xd5, 0xc0, 0x08, 0x00, 0x89, 0x23, 0x00, 0x04, 0x8c, 0x00,
+  0x00, 0xf1, 0x30, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8,
+  0x90, 0x51, 0x12, 0x44, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x63, 0x80, 0x61,
+  0x16, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73,
+  0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
+  0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x29,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x73,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x00, 0x00,
+  0x00, 0x2b, 0x04, 0x5b, 0x90, 0x85, 0x15, 0xc3, 0x2d, 0xd8, 0xc2, 0x2c,
+  0xac, 0x18, 0x70, 0xc1, 0x16, 0x68, 0x61, 0xc5, 0x90, 0x0b, 0xb6, 0x50,
+  0x0b, 0x1b, 0x04, 0x5c, 0xb8, 0x85, 0x0d, 0x41, 0x2e, 0x00, 0x00, 0x00,
+  0x00, 0x23, 0x06, 0x8d, 0x11, 0x82, 0x60, 0x30, 0x06, 0x61, 0x60, 0x14,
+  0x08, 0x21, 0x0c, 0x41, 0xd0, 0x8d, 0x26, 0x04, 0xc0, 0x88, 0xc1, 0x71,
+  0xc4, 0x20, 0x58, 0xf8, 0xc7, 0xe2, 0x06, 0x41, 0x62, 0x01, 0x23, 0xfe,
+  0x19, 0x04, 0xc4, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x0a, 0xe0,
+  0xc8, 0x05, 0x44, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0xe3, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x4f, 0x00, 0x00, 0x00, 0x14, 0x96, 0xc3, 0x0c, 0x40, 0x31, 0x10,
+  0x5a, 0x02, 0x45, 0x40, 0xeb, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00, 0xc4,
+  0xce, 0x41, 0x40, 0x4e, 0x63, 0x06, 0x63, 0x11, 0x40, 0x20, 0x1c, 0x04,
+  0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x18, 0x81, 0x2c, 0xba, 0x3d,
+  0x0d, 0x06, 0x63, 0x04, 0xb5, 0x5a, 0xab, 0xed, 0x37, 0x46, 0xd0, 0xc7,
+  0xa2, 0x8b, 0x7f, 0x63, 0x04, 0x6e, 0x1f, 0x8b, 0xb6, 0x2f, 0x8c, 0x11,
+  0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d,
+  0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed,
+  0x8d, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf, 0x18, 0x81, 0xce, 0x9a, 0x73,
+  0x08, 0x06, 0x23, 0x00, 0x63, 0x04, 0x20, 0x08, 0x82, 0x24, 0x18, 0x8c,
+  0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x03, 0x40, 0xc1, 0x0c, 0xc0,
+  0x0c, 0xc0, 0x1c, 0xc4, 0x1c, 0xe4, 0xc1, 0x1c, 0xf0, 0x01, 0x35, 0x33,
+  0x00, 0x23, 0x00, 0x33, 0x00, 0x63, 0x0d, 0x20, 0x08, 0x82, 0xf8, 0x07,
+  0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82, 0xf8, 0x37, 0xd6, 0xc0, 0xb6,
+  0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4, 0xc7, 0xb6, 0xf3, 0x4f, 0x7a,
+  0x63, 0x0d, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8, 0xd6, 0xbf,
+  0x00, 0x82, 0x20, 0x5b, 0xff, 0xc2, 0x58, 0x03, 0x08, 0x82, 0x6b, 0x0e,
+  0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x80, 0x20, 0xb8, 0xe6, 0x60, 0x30,
+  0xd6, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d, 0x0e, 0x06,
+  0x20, 0x48, 0xb7, 0x39, 0x18, 0x8c, 0x35, 0xac, 0x23, 0x1e, 0xb3, 0x60,
+  0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x3a, 0xe2, 0x31, 0x0b, 0x06, 0x63,
+  0x0d, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87, 0x63, 0x00,
+  0x82, 0x30, 0x1e, 0x8e, 0xc1, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81,
+  0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3,
+  0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71,
+  0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b,
+  0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x00, 0xf1, 0x30, 0x00,
+  0x00, 0x32, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0e, 0xc4,
+  0x1d, 0x00, 0x00, 0x00, 0x00, 0xd5, 0xf3, 0x00, 0x00, 0x5f, 0x5a, 0x54,
+  0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
+  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
+  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
+  0x00, 0x13, 0x04, 0x34, 0xd0, 0x26, 0x08, 0x68, 0xb0, 0x4d, 0x10, 0xd0,
+  0x80, 0x9b, 0x20, 0xa0, 0x41, 0x37, 0x41, 0x40, 0x03, 0x6f, 0x82, 0x80,
+  0x06, 0xdf, 0x04, 0x01, 0x0d, 0xc0, 0x60, 0x82, 0x80, 0x06, 0x61, 0xb0,
+  0x21, 0xa0, 0x85, 0x0d, 0xc3, 0x2c, 0xf4, 0x42, 0x2d, 0x6c, 0x18, 0x38,
+  0x5f, 0xa8, 0x85, 0x0d, 0x91, 0x2c, 0xfc, 0x42, 0x2d, 0xfc, 0x82, 0x2d,
+  0xfc, 0xc2, 0x2d, 0xfc, 0x02, 0x2e, 0xfc, 0x42, 0x2e, 0xfc, 0x82, 0x2e,
+  0xfc, 0xc2, 0x2e, 0xfc, 0x02, 0x2f, 0x6c, 0x18, 0xc0, 0xe1, 0x17, 0x6e,
+  0x61, 0xc3, 0x00, 0x0e, 0xbf, 0xc0, 0x0b, 0x1b, 0x06, 0x70, 0xf8, 0x85,
+  0x5c, 0xd8, 0x30, 0x80, 0xc3, 0x2f, 0xe8, 0xc2, 0x86, 0x01, 0x1c, 0x7e,
+  0x61, 0x17, 0x36, 0x0c, 0xe0, 0xf0, 0x0b, 0xb6, 0xb0, 0x61, 0x00, 0x87,
+  0x5f, 0xc0, 0x85, 0x0d, 0x03, 0x38, 0xfc, 0x42, 0x2d, 0x00, 0x00, 0x00,
+  0x00, 0x7b, 0x18, 0xd2, 0x60, 0x0e, 0x40, 0x81, 0x02, 0x60, 0x0c, 0x47,
+  0x04, 0x55, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0xb4, 0xc1,
+  0x64, 0x06, 0x7b, 0x18, 0xda, 0xe0, 0x0e, 0xd8, 0x80, 0x02, 0x60, 0x8c,
+  0x18, 0x18, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x74, 0xa9, 0x30, 0x8c, 0x18,
+  0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x6c, 0xab, 0x10, 0x40, 0x16, 0x40,
+  0xe0, 0x3f, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0xb1, 0xad, 0x42,
+  0x50, 0xd9, 0x10, 0x89, 0xbf, 0x45, 0x41, 0xf8, 0xdb, 0x10, 0x90, 0xff,
+  0x88, 0x81, 0x81, 0x84, 0x20, 0x58, 0xf8, 0x47, 0x07, 0x0b, 0xc1, 0x88,
+  0xc1, 0x81, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0x26, 0x0b, 0xc1, 0x64, 0xc1,
+  0x24, 0xfe, 0x73, 0x0c, 0xdd, 0x32, 0x0a, 0x83, 0x0c, 0x81, 0x37, 0x07,
+  0x36, 0x04, 0xe4, 0x3f, 0xc8, 0x10, 0x80, 0x01, 0x1d, 0x0c, 0x32, 0x04,
+  0x7e, 0x40, 0x07, 0xb3, 0x04, 0xc2, 0x40, 0x45, 0x20, 0x04, 0xfe, 0x00,
+  0xec, 0x61, 0xf8, 0x83, 0x54, 0xa0, 0x05, 0x0a, 0x80, 0x31, 0x1c, 0x11,
+  0xb0, 0x81, 0xe3, 0x1f, 0xb3, 0x0c, 0x03, 0x11, 0x0c, 0x32, 0x10, 0x69,
+  0xc0, 0x07, 0x7b, 0x18, 0x46, 0xa1, 0x15, 0x5c, 0x81, 0x02, 0x60, 0xec,
+  0x61, 0x28, 0x85, 0x57, 0x10, 0x05, 0x0a, 0x80, 0x31, 0x62, 0xa0, 0x24,
+  0x31, 0x08, 0x16, 0xfe, 0x91, 0x91, 0x43, 0xd1, 0x1d, 0x43, 0x30, 0xc8,
+  0x10, 0xb0, 0x01, 0x28, 0x0c, 0x32, 0x04, 0x0b, 0x28, 0xcc, 0x12, 0x10,
+  0x03, 0x15, 0x81, 0x30, 0x60, 0xc2, 0x70, 0x44, 0x18, 0xf0, 0x41, 0xe0,
+  0x1f, 0xb3, 0x0c, 0xc5, 0x14, 0xec, 0x61, 0x60, 0x05, 0x5b, 0x10, 0x07,
+  0x0a, 0x80, 0x31, 0x1c, 0x11, 0xfc, 0x41, 0xe0, 0x1f, 0xb3, 0x0c, 0xc6,
+  0x11, 0x0c, 0x32, 0x14, 0x76, 0x90, 0x0a, 0x7b, 0x18, 0x60, 0x41, 0x17,
+  0xc6, 0x81, 0x02, 0x60, 0xcc, 0x31, 0xd8, 0x41, 0xc0, 0x0b, 0x83, 0x0c,
+  0xc1, 0x1d, 0xb0, 0x82, 0x05, 0x85, 0xf8, 0x0f, 0x32, 0x04, 0x79, 0xd0,
+  0x0a, 0xb3, 0x04, 0x6d, 0xb0, 0x87, 0xc1, 0x16, 0xc0, 0x41, 0x1d, 0x28,
+  0x00, 0xc6, 0x1e, 0x06, 0x5c, 0x10, 0x87, 0x75, 0xa0, 0x00, 0x18, 0x83,
+  0x0c, 0x50, 0x28, 0xc8, 0xc2, 0x88, 0x41, 0x81, 0x84, 0x20, 0x18, 0x54,
+  0xfa, 0x40, 0xcc, 0x32, 0x20, 0x52, 0x30, 0x86, 0x20, 0x99, 0xc3, 0x70,
+  0x44, 0xd0, 0x0a, 0x8a, 0x7f, 0xcc, 0x32, 0x28, 0x49, 0x60, 0x42, 0x2b,
+  0x88, 0xff, 0x2c, 0xc1, 0x62, 0x43, 0x2b, 0x80, 0xff, 0x88, 0x81, 0x81,
+  0x84, 0x20, 0x58, 0xf8, 0x87, 0x04, 0x12, 0x81, 0x05, 0xae, 0x20, 0xfe,
+  0x23, 0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0xd0, 0x48, 0x04, 0xae,
+  0x30, 0x4b, 0xb0, 0x0c, 0x54, 0x00, 0x4a, 0x22, 0x28, 0x73, 0x0c, 0xaa,
+  0x10, 0xb8, 0xc3, 0x18, 0xc2, 0x16, 0x0e, 0xc3, 0x11, 0x81, 0x2d, 0x28,
+  0xfe, 0x31, 0xcb, 0xd0, 0x30, 0x81, 0x09, 0xb6, 0x20, 0xfe, 0xb3, 0x04,
+  0x8e, 0x0d, 0xb6, 0x00, 0xfe, 0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1,
+  0x1f, 0x52, 0x4a, 0x04, 0x16, 0xdc, 0x82, 0xf8, 0x8f, 0x18, 0x1c, 0x48,
+  0x08, 0x82, 0x85, 0x7f, 0x40, 0x2c, 0x11, 0xdc, 0xc2, 0x2c, 0x81, 0x33,
+  0x50, 0x01, 0x28, 0x8c, 0xd0, 0xcc, 0x31, 0x24, 0x41, 0x3a, 0x8c, 0x21,
+  0x90, 0x41, 0x3a, 0x0c, 0x47, 0x04, 0xbf, 0xa0, 0xf8, 0xc7, 0x2c, 0x03,
+  0xf4, 0x04, 0x26, 0xfc, 0x82, 0xf8, 0xcf, 0x12, 0x44, 0x36, 0xfc, 0x02,
+  0xf8, 0x8f, 0x18, 0x18, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x48, 0x32, 0x11,
+  0x58, 0x00, 0x0e, 0xe2, 0x3f, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe,
+  0x01, 0xd5, 0x44, 0x00, 0x0e, 0xb3, 0x04, 0xd1, 0x40, 0x05, 0xa0, 0x3c,
+  0x02, 0x34, 0xc7, 0x90, 0x04, 0xf1, 0x30, 0x4b, 0x20, 0x0d, 0x54, 0x04,
+  0x42, 0xa4, 0x07, 0xc7, 0x20, 0x43, 0xf0, 0x0b, 0xf2, 0x30, 0xc7, 0xd0,
+  0x0b, 0x60, 0x30, 0x12, 0x83, 0x0c, 0x81, 0x2f, 0xcc, 0x83, 0x0d, 0x81,
+  0xf8, 0x0f, 0x32, 0x04, 0xe0, 0x40, 0x0f, 0xb3, 0x04, 0x6d, 0x30, 0x1c,
+  0x31, 0x0b, 0xe6, 0x10, 0xf8, 0xc7, 0x2c, 0x03, 0x05, 0x06, 0xc1, 0x20,
+  0x03, 0x1d, 0x94, 0x03, 0x3e, 0xec, 0x61, 0xf8, 0x87, 0x94, 0x98, 0x09,
+  0x0a, 0x80, 0xb1, 0x87, 0x21, 0x24, 0x56, 0x82, 0x26, 0x28, 0x00, 0xc6,
+  0x1c, 0xc3, 0x39, 0x04, 0x2d, 0x31, 0xc8, 0x10, 0xa0, 0x43, 0x3f, 0x58,
+  0x70, 0x88, 0xff, 0x20, 0x43, 0xa0, 0x0e, 0xfe, 0x30, 0x62, 0x50, 0x20,
+  0x21, 0x08, 0x06, 0x95, 0x59, 0x1c, 0xb3, 0x0c, 0x5f, 0x15, 0x8c, 0x21,
+  0x0c, 0x32, 0x31, 0x1c, 0x11, 0xfc, 0x83, 0xe2, 0x1f, 0xb3, 0x0c, 0x97,
+  0x15, 0x98, 0xf0, 0x0f, 0xe2, 0x3f, 0x4b, 0x80, 0x8d, 0x18, 0x18, 0x48,
+  0x08, 0x82, 0x85, 0x7f, 0x48, 0x6b, 0x31, 0x8c, 0x18, 0x1c, 0x48, 0x08,
+  0x82, 0x85, 0x7f, 0x40, 0x6d, 0x11, 0x80, 0x84, 0x05, 0x20, 0x21, 0xfe,
+  0x16, 0x80, 0x04, 0xf8, 0xcf, 0x12, 0x60, 0x03, 0x15, 0x80, 0x62, 0x09,
+  0xd7, 0x1c, 0x83, 0x3c, 0x04, 0x3a, 0x31, 0x86, 0xc0, 0xb4, 0xc4, 0x70,
+  0x44, 0x80, 0x12, 0x8a, 0x7f, 0xcc, 0x32, 0x68, 0x59, 0x60, 0x02, 0x4a,
+  0x88, 0xff, 0x2c, 0xc1, 0x36, 0x62, 0x60, 0x20, 0x21, 0x08, 0x16, 0xfe,
+  0x21, 0xd1, 0xc5, 0x30, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x01,
+  0xd9, 0x45, 0x90, 0x12, 0x16, 0xa4, 0x84, 0xf8, 0x5b, 0x90, 0x12, 0xe0,
+  0x3f, 0x4b, 0xb0, 0x0d, 0x54, 0x00, 0x4a, 0x26, 0x68, 0x73, 0x0c, 0x49,
+  0x50, 0x13, 0x63, 0x08, 0x55, 0x4d, 0x0c, 0x47, 0x04, 0x31, 0xa1, 0xf8,
+  0xc7, 0x2c, 0x43, 0xc7, 0x05, 0x26, 0xc4, 0x84, 0xf8, 0xcf, 0x12, 0x78,
+  0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x52, 0x5f, 0x0c, 0x23,
+  0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0xd0, 0x5f, 0x04, 0x32, 0x61,
+  0x81, 0x4c, 0x88, 0xbf, 0x05, 0x32, 0x01, 0xfe, 0xb3, 0x04, 0xde, 0x40,
+  0x05, 0xa0, 0x70, 0x42, 0x37, 0xc7, 0x90, 0x04, 0x3d, 0x31, 0x62, 0x80,
+  0x20, 0x21, 0x08, 0x16, 0xfe, 0xe1, 0x94, 0x46, 0x60, 0x12, 0x24, 0x31,
+  0xc8, 0x10, 0xa0, 0x04, 0x4f, 0xcc, 0x12, 0x7c, 0x03, 0x15, 0x81, 0x1f,
+  0x50, 0x82, 0x37, 0xc8, 0x10, 0xb4, 0x84, 0x4f, 0xcc, 0x12, 0xb4, 0xc1,
+  0x2c, 0x43, 0x18, 0xb4, 0x01, 0x3f, 0x0c, 0x32, 0xf4, 0x82, 0x4b, 0x84,
+  0xc5, 0x88, 0xc1, 0x81, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0x65, 0x1a, 0x81,
+  0x48, 0xcc, 0x31, 0xac, 0x44, 0x30, 0x17, 0x23, 0x06, 0x07, 0x12, 0x82,
+  0x60, 0xe1, 0x1f, 0x17, 0x6a, 0x0c, 0x23, 0x31, 0xc7, 0x20, 0x04, 0x67,
+  0x31, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x71, 0xa9, 0x46, 0x41,
+  0x12, 0x73, 0x0c, 0x42, 0x80, 0x16, 0x83, 0x0c, 0x81, 0x4c, 0x98, 0xc5,
+  0x20, 0x43, 0x50, 0x0e, 0x66, 0xb1, 0x87, 0x01, 0x2e, 0xf4, 0x82, 0x34,
+  0x28, 0x00, 0xc6, 0x1e, 0x06, 0xb9, 0xe0, 0x8b, 0xd2, 0xa0, 0x00, 0x18,
+  0x73, 0x0c, 0x38, 0x11, 0xf8, 0xc5, 0x20, 0x43, 0x90, 0x13, 0x6e, 0x61,
+  0x41, 0x22, 0xfe, 0x83, 0x0c, 0xc1, 0x4e, 0xbc, 0xc5, 0x88, 0x41, 0x81,
+  0x84, 0x20, 0x18, 0x54, 0xb7, 0x71, 0xcc, 0x32, 0xb0, 0x81, 0x18, 0x04,
+  0x63, 0x08, 0xc3, 0x68, 0x0c, 0x47, 0x04, 0x70, 0xa1, 0xf8, 0xc7, 0x2c,
+  0x03, 0x19, 0x8c, 0x41, 0x60, 0x02, 0x5c, 0x88, 0xff, 0x2c, 0x41, 0x19,
+  0x8c, 0x18, 0x18, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x48, 0xbc, 0x31, 0x8c,
+  0x18, 0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x40, 0xbe, 0x11, 0xc4, 0x85,
+  0x05, 0x71, 0x21, 0xfe, 0x16, 0xc4, 0x05, 0xf8, 0xcf, 0x12, 0x94, 0xc1,
+  0x40, 0x05, 0xa0, 0x8c, 0x81, 0x40, 0x06, 0x73, 0x0c, 0x63, 0x11, 0xac,
+  0xc6, 0x18, 0x02, 0xe3, 0x17, 0xc3, 0x11, 0x41, 0x5e, 0x28, 0xfe, 0x31,
+  0xcb, 0x70, 0x06, 0x66, 0x10, 0x98, 0x90, 0x17, 0xe2, 0x3f, 0x4b, 0x80,
+  0x06, 0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x52, 0x79, 0x0c,
+  0x23, 0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0xd0, 0x79, 0x04, 0x7a,
+  0x61, 0x81, 0x5e, 0x88, 0xbf, 0x05, 0x7a, 0x01, 0xfe, 0xb3, 0x04, 0x68,
+  0x30, 0x50, 0x01, 0x28, 0x66, 0x20, 0x9c, 0xc1, 0x1c, 0x43, 0x12, 0x98,
+  0xc6, 0x18, 0x42, 0x65, 0x1a, 0xc3, 0x11, 0x81, 0x68, 0x28, 0xfe, 0x31,
+  0xcb, 0xa0, 0x06, 0x69, 0x10, 0x98, 0x20, 0x1a, 0xe2, 0x3f, 0x4b, 0xb0,
+  0x06, 0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x92, 0x7b, 0x0c,
+  0x23, 0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x10, 0x7c, 0x04, 0xa3,
+  0x61, 0xc1, 0x68, 0x88, 0xbf, 0x05, 0xa3, 0x01, 0xfe, 0xb3, 0x04, 0x6b,
+  0x30, 0x50, 0x01, 0x28, 0x69, 0x20, 0xa8, 0xc1, 0x1c, 0x43, 0x12, 0xb8,
+  0xc6, 0x88, 0x01, 0x82, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x63, 0x1f, 0xc1,
+  0x5d, 0xd4, 0xc5, 0x20, 0x43, 0x90, 0x17, 0xad, 0x31, 0x4b, 0xc0, 0x06,
+  0x03, 0x15, 0x81, 0x1f, 0x84, 0x81, 0xb0, 0x06, 0x83, 0x0c, 0x81, 0x5f,
+  0xbc, 0xc6, 0x2c, 0x41, 0x1b, 0x0c, 0xb4, 0x04, 0x3c, 0x62, 0xf0, 0x88,
+  0xc4, 0x23, 0x9f, 0x2c, 0xb0, 0x01, 0x8f, 0x80, 0xc1, 0x40, 0x4b, 0x80,
+  0x22, 0x86, 0x5e, 0x48, 0xe6, 0xf0, 0x11, 0x6c, 0xc0, 0x2f, 0x60, 0x30,
+  0xc8, 0x10, 0x08, 0xb1, 0x91, 0x41, 0x40, 0x0c, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x5b, 0x86, 0x20, 0x00, 0x87, 0x2d, 0x83, 0x11, 0x84, 0xc3, 0x96,
+  0x21, 0x0b, 0xc4, 0x61, 0xcb, 0xe0, 0x05, 0xe3, 0xb0, 0x65, 0x00, 0x83,
+  0x80, 0x1c, 0xb6, 0x0c, 0x69, 0x10, 0x94, 0xc3, 0x96, 0xc1, 0x0d, 0x02,
+  0x73, 0xd8, 0x32, 0xd4, 0x41, 0x70, 0x0e, 0x5b, 0x86, 0x3b, 0x08, 0xcc,
+  0x61, 0xcb, 0xb0, 0x0e, 0xc1, 0x39, 0x6c, 0x19, 0xda, 0x21, 0x30, 0x87,
+  0x2d, 0x43, 0x5a, 0x04, 0xe7, 0xb0, 0x65, 0x58, 0x8b, 0xc0, 0x1c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x73, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00,
+  0x00, 0x14, 0xce, 0x00, 0x10, 0x5a, 0x02, 0x45, 0x40, 0xeb, 0x58, 0x03,
+  0x10, 0x08, 0x23, 0x00, 0xc4, 0xce, 0x41, 0x40, 0x4e, 0x83, 0x06, 0x04,
+  0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20,
+  0x08, 0x06, 0x23, 0x00, 0x14, 0xcc, 0x00, 0xcc, 0x00, 0x50, 0x33, 0x03,
+  0x30, 0xd6, 0xc0, 0xb2, 0x67, 0x28, 0x7f, 0xa8, 0x5f, 0xc6, 0xea, 0x97,
+  0x9f, 0xba, 0x38, 0x7b, 0x63, 0x0d, 0x7a, 0x0d, 0xee, 0xb8, 0xa7, 0xe2,
+  0xb9, 0x6d, 0x7f, 0x6f, 0x9f, 0xd2, 0xa3, 0x37, 0xd6, 0xb0, 0xce, 0x31,
+  0x8b, 0x7a, 0x69, 0x08, 0xa3, 0xbb, 0x77, 0xb7, 0xb1, 0x6a, 0x7f, 0x63,
+  0x0d, 0x62, 0x2e, 0xa6, 0xfd, 0x07, 0x96, 0x3c, 0x1b, 0xff, 0xc2, 0x98,
+  0xae, 0x6a, 0xee, 0x0b, 0x63, 0x0d, 0xff, 0x4c, 0xfa, 0xbf, 0x2f, 0xd0,
+  0x35, 0x28, 0xe6, 0x5f, 0x0b, 0xc7, 0x31, 0xe8, 0x0b, 0x63, 0x0d, 0x73,
+  0xdf, 0xa6, 0xa9, 0x2f, 0xb4, 0x6e, 0xc8, 0xf3, 0xbe, 0xc0, 0xe7, 0xac,
+  0x8f, 0x7f, 0x00, 0x00, 0x00, 0x83, 0x0c, 0xd7, 0xd1, 0x0c, 0x47, 0x58,
+  0x4d, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0xcc, 0x31, 0x24, 0x96, 0x18,
+  0x0c, 0x32, 0x04, 0x4a, 0x64, 0xc1, 0x26, 0xfe, 0x83, 0x0c, 0x01, 0x23,
+  0xcd, 0x12, 0x24, 0xc3, 0x11, 0x5b, 0x14, 0xf8, 0xc7, 0x2c, 0xc3, 0x90,
+  0x04, 0xc3, 0x11, 0x9d, 0x14, 0xf8, 0xc7, 0x2c, 0x03, 0x51, 0x04, 0x23,
+  0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x17, 0x1f, 0x7c, 0xce, 0x1c,
+  0x43, 0x14, 0xa4, 0xc1, 0x88, 0xc1, 0x81, 0x84, 0x20, 0x58, 0xf8, 0xc7,
+  0xe5, 0x07, 0x61, 0xf0, 0xcc, 0x31, 0x08, 0x01, 0x37, 0x62, 0x70, 0x20,
+  0x21, 0x08, 0x16, 0xfe, 0x71, 0x81, 0xc2, 0x18, 0x40, 0x73, 0x0c, 0x42,
+  0xd0, 0xcd, 0x12, 0x14, 0x03, 0x15, 0x81, 0x40, 0x70, 0xc3, 0x18, 0x42,
+  0xf0, 0x06, 0x63, 0x08, 0x42, 0x18, 0x8c, 0x21, 0x0c, 0x61, 0x30, 0x62,
+  0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x01, 0x91, 0x82, 0x10, 0x8c, 0x18,
+  0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x40, 0xa5, 0x40, 0x04, 0xc3, 0x11,
+  0x81, 0x27, 0xf8, 0xc7, 0x2c, 0x83, 0x71, 0x04, 0x83, 0x0c, 0x87, 0x47,
+  0x06, 0x36, 0xa8, 0x81, 0xf8, 0x5b, 0x30, 0x06, 0xe0, 0x6f, 0xc5, 0x1a,
+  0x88, 0xbf, 0x05, 0x65, 0x00, 0xfe, 0x36, 0x04, 0xe4, 0x3f, 0xc7, 0x20,
+  0x06, 0xc1, 0x1e, 0x0c, 0x32, 0x04, 0x63, 0xa0, 0x06, 0x16, 0x20, 0xe2,
+  0x3f, 0xc8, 0x10, 0x94, 0xc1, 0x1a, 0xcc, 0x12, 0x1c, 0x03, 0x15, 0x81,
+  0x60, 0x88, 0x41, 0x31, 0xcb, 0x80, 0x24, 0xd9, 0x20, 0x43, 0x90, 0x06,
+  0x6f, 0x30, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x71, 0xd5, 0x42,
+  0x40, 0x06, 0x73, 0x0c, 0x6a, 0x10, 0x88, 0xc2, 0x88, 0xc1, 0x81, 0x84,
+  0x20, 0x58, 0xf8, 0xc7, 0x75, 0x0b, 0x43, 0x19, 0xcc, 0x31, 0x08, 0x41,
+  0x1d, 0x8c, 0x18, 0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x5c, 0xb9, 0x50,
+  0x98, 0xc1, 0x1c, 0x83, 0x10, 0xd8, 0xc1, 0x2c, 0x41, 0x32, 0x50, 0x12,
+  0x90, 0x42, 0xe0, 0x0a, 0x82, 0x80, 0x40, 0xc7, 0x20, 0x43, 0x10, 0x07,
+  0x77, 0x90, 0x01, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xeb, 0x08, 0x18, 0xb0, 0x9a,
+  0x80, 0x07, 0x90, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x30, 0x03, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00,
+  0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x5d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0x7e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x94, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+  0x00, 0xa1, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xba, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0xcb, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xdd, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xf0, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00,
+  0x00, 0x03, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00,
+  0x00, 0x55, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xa6, 0x02, 0x00, 0x00,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72,
+  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x5a, 0x31, 0x34, 0x47, 0x65,
+  0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
+  0x44, 0x76, 0x34, 0x5f, 0x66, 0x52, 0x55, 0x31, 0x31, 0x4d, 0x54, 0x4c,
+  0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x4b, 0x31, 0x35, 0x53,
+  0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e,
+  0x74, 0x73, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x63,
+  0x6c, 0x61, 0x6d, 0x70, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x66,
+  0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66,
+  0x61, 0x62, 0x73, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x2e, 0x75, 0x2e, 0x69, 0x31, 0x2e,
+  0x66, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74,
+  0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x5f, 0x5a, 0x31, 0x32, 0x41, 0x70,
+  0x70, 0x6c, 0x79, 0x54, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x44, 0x76,
+  0x33, 0x5f, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78, 0x2e, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77,
+  0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e, 0x76, 0x33, 0x66, 0x33,
+  0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d,
+  0x61, 0x78, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33,
+  0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x61, 0x69, 0x72, 0x36,
+  0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x69, 0x6f, 0x73, 0x31,
+  0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61,
+  0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xf8, 0x21, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05,
+  0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xa8, 0x07, 0x00,
+  0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e,
+  0x90, 0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x6e, 0x01, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03,
+  0x40, 0x02, 0x2a, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0,
+  0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87,
+  0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07,
+  0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07,
+  0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07,
+  0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87,
+  0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc,
+  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87,
+  0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca,
+  0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda,
+  0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda,
+  0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88,
+  0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0xd8, 0xe0, 0x09, 0x04, 0xb0, 0x00, 0x55, 0x90,
+  0x06, 0x60, 0x30, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d,
+  0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b,
+  0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0xc1, 0x1b, 0x0a,
+  0x60, 0x01, 0xaa, 0x20, 0x0d, 0x40, 0x61, 0x08, 0x87, 0x74, 0x90, 0x87,
+  0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x03,
+  0x77, 0x78, 0x87, 0x36, 0x08, 0x07, 0x76, 0x48, 0x87, 0x70, 0x98, 0x07,
+  0x60, 0x83, 0x41, 0x18, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x02, 0x01, 0x16,
+  0xa0, 0xda, 0x10, 0x26, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xc0, 0x1a,
+  0x00, 0x12, 0x50, 0x11, 0xe1, 0x00, 0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80,
+  0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0, 0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00,
+  0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c,
+  0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b, 0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b,
+  0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b, 0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38,
+  0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b, 0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d,
+  0xa0, 0x03, 0x10, 0x07, 0x72, 0x80, 0x07, 0xc0, 0xe0, 0x0e, 0xef, 0xd0,
+  0x06, 0xe2, 0x50, 0x0f, 0xe9, 0xc0, 0x0e, 0xf4, 0x90, 0x0e, 0xee, 0x30,
+  0x0f, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xe6, 0x20, 0x0f, 0xe1, 0xd0,
+  0x0e, 0xe5, 0xd0, 0x06, 0xf0, 0xf0, 0x0e, 0xe9, 0xe0, 0x0e, 0xf4, 0x50,
+  0x0e, 0xf2, 0xd0, 0x06, 0xe5, 0xc0, 0x0e, 0xe9, 0xd0, 0x0e, 0x00, 0x3d,
+  0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3, 0x3b, 0xb4, 0x81, 0x39,
+  0xc8, 0x43, 0x38, 0xb4, 0x43, 0x39, 0xb4, 0x01, 0x3c, 0xbc, 0x43, 0x3a,
+  0xb8, 0x03, 0x3d, 0x94, 0x83, 0x3c, 0xb4, 0x41, 0x39, 0xb0, 0x43, 0x3a,
+  0xb4, 0x43, 0x1b, 0xb8, 0xc3, 0x3b, 0xb8, 0x43, 0x1b, 0xb0, 0x43, 0x39,
+  0x84, 0x83, 0x39, 0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1,
+  0x0e, 0xef, 0xd0, 0x06, 0xe9, 0xe0, 0x0e, 0xe6, 0x30, 0x0f, 0x6d, 0x60,
+  0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d,
+  0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3, 0x3b, 0xb4, 0x81, 0x3b,
+  0x84, 0x83, 0x3b, 0xcc, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b,
+  0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00,
+  0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x30, 0x0f, 0xe9, 0x70, 0x0e, 0xee, 0x50,
+  0x0e, 0xe4, 0xd0, 0x06, 0xfa, 0x50, 0x0e, 0xf2, 0xf0, 0x0e, 0xf3, 0xd0,
+  0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00,
+  0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43, 0x1b,
+  0xd0, 0x83, 0x3c, 0x84, 0x03, 0x3c, 0xc0, 0x43, 0x3a, 0xb8, 0xc3, 0x39,
+  0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50,
+  0x0f, 0xe5, 0x00, 0x10, 0xf3, 0x40, 0x0f, 0xe1, 0x30, 0x0e, 0xeb, 0xd0,
+  0x06, 0xf0, 0x20, 0x0f, 0xef, 0x40, 0x0f, 0xe5, 0x30, 0x0e, 0xf4, 0xf0,
+  0x0e, 0xf2, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe6, 0x60, 0x0e, 0xe5, 0x20,
+  0x0f, 0x6d, 0x30, 0x0f, 0xe9, 0xa0, 0x0f, 0xe5, 0x00, 0xe0, 0x01, 0x40,
+  0xd4, 0x83, 0x3b, 0xcc, 0x43, 0x38, 0x98, 0x43, 0x39, 0xb4, 0x81, 0x39,
+  0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20,
+  0x0f, 0xf5, 0x50, 0x0e, 0xc0, 0x86, 0xe4, 0x10, 0x80, 0x05, 0xa8, 0x82,
+  0x34, 0x00, 0x83, 0x0d, 0x06, 0xf2, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x01, 0xd4, 0x06, 0x1f, 0x49, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x24,
+  0xa0, 0x22, 0xc2, 0x01, 0x1e, 0xe0, 0x41, 0x1e, 0xde, 0x01, 0x1f, 0xda,
+  0xc0, 0x1c, 0xea, 0xc1, 0x1d, 0xc6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x88, 0x76, 0x48, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x73, 0x08, 0x07, 0x76, 0x68, 0x03, 0x7b, 0x28, 0x87, 0x71, 0xa0, 0x87,
+  0x77, 0x90, 0x87, 0x36, 0xb8, 0x87, 0x74, 0x20, 0x07, 0x7a, 0x40, 0x07,
+  0x20, 0x0f, 0xec, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1c, 0xea,
+  0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
+  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
+  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
+  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
+  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
+  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
+  0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
+  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
+  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
+  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
+  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
+  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
+  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
+  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0xd8, 0xa0, 0x28, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x6d, 0x00,
+  0xac, 0x01, 0x20, 0x01, 0xd5, 0x06, 0x63, 0x09, 0x80, 0x05, 0xa8, 0x36,
+  0x18, 0x8c, 0x00, 0x2c, 0x40, 0xb5, 0x41, 0x69, 0xfe, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0xda, 0x00, 0x58, 0x03, 0x40, 0x02, 0xaa, 0x0d, 0x86, 0xf3,
+  0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x01, 0xd4, 0x86, 0xe9, 0xf9, 0xff,
+  0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x19, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0xd8, 0x50, 0x40, 0x42, 0x90, 0x06, 0x60, 0xb0, 0x21, 0x8a, 0xfe,
+  0xff, 0xff, 0xff, 0x7f, 0x00, 0x94, 0xc1, 0x1d, 0xde, 0xa1, 0x0d, 0xc4,
+  0xa1, 0x1e, 0xd2, 0x81, 0x1d, 0xe8, 0x21, 0x1d, 0xdc, 0x61, 0x1e, 0x00,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40,
+  0x18, 0x88, 0x62, 0x82, 0x60, 0x1c, 0x13, 0x02, 0x64, 0x42, 0x90, 0x4c,
+  0x18, 0x94, 0x85, 0x99, 0x30, 0x34, 0x0b, 0x33, 0x21, 0x70, 0x26, 0x08,
+  0x0f, 0x34, 0x21, 0x88, 0x00, 0x89, 0x20, 0x00, 0x00, 0x51, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4,
+  0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c,
+  0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xe0, 0xc1, 0x0c, 0xc0, 0x30, 0x02,
+  0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3,
+  0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84, 0x41, 0x18, 0x46, 0x18,
+  0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e, 0xe4, 0xa1, 0x1e, 0xc6,
+  0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e, 0xc2, 0x81, 0x1d, 0xf4,
+  0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e, 0xd2, 0x01, 0x1f, 0x50,
+  0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21,
+  0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40, 0x84, 0xa3, 0xa4, 0x29,
+  0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1,
+  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0x38, 0x4d, 0x9a, 0x22, 0x4a,
+  0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0x7e, 0x20,
+  0x8a, 0x00, 0xec, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x26, 0xb8, 0x48,
+  0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2, 0x7f,
+  0x1a, 0x23, 0x00, 0x06, 0x11, 0x1c, 0xa1, 0x24, 0x41, 0x10, 0x08, 0x44,
+  0xb2, 0x34, 0x0f, 0x41, 0x65, 0x08, 0x02, 0x82, 0xa4, 0x42, 0x14, 0x45,
+  0x51, 0x10, 0x55, 0x06, 0x00, 0x00, 0xc8, 0x2a, 0x02, 0x00, 0x10, 0x36,
+  0x47, 0x10, 0x14, 0x41, 0x03, 0x68, 0x2b, 0x03, 0x50, 0x14, 0xd4, 0x15,
+  0xa3, 0x28, 0x00, 0x00, 0x00, 0xe8, 0x2b, 0x43, 0x51, 0x14, 0x14, 0x16,
+  0xa1, 0x28, 0x68, 0x9c, 0x23, 0x40, 0x8c, 0x10, 0x94, 0x73, 0x04, 0x60,
+  0x30, 0x8c, 0x20, 0x9c, 0x41, 0x59, 0xcc, 0xe6, 0x11, 0x4e, 0x0d, 0xd5,
+  0x00, 0xe0, 0xa4, 0xb4, 0x28, 0xe6, 0xf2, 0x08, 0x1a, 0xaa, 0x01, 0xc0,
+  0x49, 0xeb, 0x40, 0x40, 0x0a, 0x9c, 0x73, 0x04, 0xa0, 0x30, 0x8c, 0x30,
+  0x9c, 0xc1, 0x20, 0x42, 0x20, 0x0c, 0x22, 0x1c, 0xc2, 0x20, 0x42, 0x21,
+  0x8c, 0x00, 0x0c, 0x22, 0x00, 0xc2, 0x14, 0xc0, 0x30, 0x02, 0x71, 0x06,
+  0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70, 0x03, 0x38, 0x68, 0x83,
+  0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90,
+  0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20,
+  0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60,
+  0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20,
+  0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20,
+  0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60,
+  0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x10, 0xdb, 0x95, 0xbf, 0xec, 0xbe,
+  0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08, 0x80, 0x20, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0x41,
+  0x78, 0x20, 0x21, 0xc0, 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0xc0, 0x90, 0x08, 0x15, 0x28, 0x0a, 0x08, 0x80, 0x01, 0x00, 0x00, 0x40,
+  0x00, 0x00, 0x00, 0x00, 0x86, 0x44, 0xbc, 0x00, 0x59, 0x40, 0x00, 0x0c,
+  0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x30, 0x24, 0x62, 0x87, 0x08,
+  0x03, 0x02, 0x60, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21,
+  0x51, 0x3f, 0x58, 0x1b, 0x10, 0x00, 0x03, 0x00, 0x00, 0x80, 0x00, 0x00,
+  0x00, 0x00, 0x0c, 0x89, 0x66, 0xa2, 0xe9, 0x80, 0x00, 0x18, 0x00, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0x48, 0x04, 0x16, 0xd9, 0x87, 0x00,
+  0x03, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x43, 0xa2, 0xbc,
+  0x88, 0x2c, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x18, 0x12, 0xa9, 0x86, 0x14, 0x06, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x30, 0x24, 0xe2, 0x8d, 0x69, 0x0c, 0x80, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0x48, 0xf4, 0x1e,
+  0x53, 0x18, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0xc0, 0x90, 0x48, 0x44, 0xc2, 0x20, 0x0d, 0x80, 0x00, 0x28, 0x00, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0x48, 0x34, 0x26, 0xdb, 0x1a, 0x00,
+  0x01, 0x50, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0xc4, 0x06,
+  0x81, 0xa2, 0xa9, 0x07, 0x00, 0x00, 0x59, 0x20, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x3a, 0x8b, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0,
+  0x0c, 0x0a, 0xa8, 0x20, 0x0a, 0xa3, 0x40, 0x0a, 0xa5, 0x60, 0x0a, 0xa7,
+  0x00, 0x03, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c, 0xe8, 0x1d, 0x01, 0x28,
+  0x84, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0x72, 0xc7,
+  0x12, 0x24, 0x01, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0xee, 0x80, 0x0d, 0x6a, 0x0c, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x41,
+  0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca,
+  0x23, 0x21, 0x54, 0xc1, 0x30, 0xca, 0xe2, 0x3c, 0xcf, 0x13, 0x5d, 0x4f,
+  0x60, 0x18, 0x88, 0x91, 0x18, 0x8b, 0x82, 0x11, 0x5e, 0xb1, 0x1c, 0x01,
+  0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70,
+  0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x20, 0x76, 0x65,
+  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e,
+  0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65,
+  0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x29, 0x4d,
+  0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f,
+  0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f,
+  0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66,
+  0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61,
+  0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65,
+  0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73,
+  0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d,
+  0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e,
+  0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70,
+  0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
+  0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65,
+  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75,
+  0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c,
+  0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65,
+  0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x73, 0x63,
+  0x52, 0x47, 0x42, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x74, 0x65,
+  0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x69, 0x6e,
+  0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x65, 0x6d,
+  0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x74, 0x6f, 0x6e,
+  0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x31,
+  0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74,
+  0x6f, 0x72, 0x32, 0x73, 0x64, 0x72, 0x5f, 0x77, 0x68, 0x69, 0x74, 0x65,
+  0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
+  0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f,
+  0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x53, 0x68,
+  0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,
+  0x73, 0x63, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x6f, 0x66, 0x66, 0x73,
+  0x65, 0x74, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x78, 0x33, 0x6d, 0x61,
+  0x74, 0x72, 0x69, 0x78, 0x59, 0x55, 0x56, 0x44, 0x65, 0x63, 0x6f, 0x64,
+  0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32,
+  0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3c,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x3e, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73,
+  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+  0x72, 0x73, 0x00, 0x00, 0x00, 0xe4, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0x70, 0x06, 0xce, 0x08, 0x82, 0x1b, 0x9c, 0xc1, 0x08,
+  0xc2, 0x19, 0x3c, 0x23, 0x08, 0x67, 0x00, 0x8d, 0x20, 0x9c, 0x41, 0x34,
+  0x82, 0x10, 0x01, 0x23, 0x08, 0x67, 0x20, 0x8d, 0x20, 0x9c, 0xc1, 0x34,
+  0x82, 0x70, 0x06, 0xd4, 0x08, 0xc2, 0x19, 0x54, 0x23, 0x08, 0x67, 0x60,
+  0x8d, 0x20, 0x9c, 0xc1, 0x35, 0x82, 0x70, 0x06, 0xd8, 0x08, 0xc2, 0x19,
+  0x64, 0x23, 0x08, 0x67, 0xa0, 0x8d, 0x20, 0x9c, 0xc1, 0x36, 0x82, 0x70,
+  0x06, 0xdc, 0x08, 0xc2, 0x19, 0x74, 0x23, 0x08, 0x67, 0xe0, 0xcd, 0x30,
+  0xe0, 0x41, 0x90, 0x07, 0x33, 0x0c, 0x7a, 0x20, 0xec, 0xc1, 0x0c, 0xc1,
+  0x30, 0xc3, 0x80, 0x07, 0x78, 0xc0, 0x07, 0x33, 0x10, 0x84, 0x1e, 0xe8,
+  0x01, 0x1f, 0xcc, 0x10, 0x14, 0x33, 0x04, 0xc6, 0x0c, 0xc1, 0x31, 0x43,
+  0x81, 0xf0, 0x01, 0x1f, 0x24, 0xca, 0x0c, 0xc1, 0x2c, 0xcc, 0x80, 0xf0,
+  0xc1, 0xc2, 0x34, 0x89, 0xe2, 0x3c, 0x33, 0x24, 0x7a, 0x00, 0x45, 0x8c,
+  0x94, 0x28, 0xce, 0x34, 0x43, 0x82, 0x07, 0x10, 0xc5, 0x48, 0x49, 0xe5,
+  0x58, 0x33, 0xa0, 0x01, 0x1f, 0xec, 0x01, 0x1f, 0x70, 0xdd, 0x1e, 0xec,
+  0x01, 0x1f, 0x70, 0x1e, 0x28, 0xec, 0x01, 0x1f, 0x70, 0x5f, 0x28, 0xec,
+  0x01, 0x1f, 0x70, 0x60, 0x20, 0x0a, 0x7b, 0xc0, 0x07, 0x5c, 0x18, 0x8c,
+  0xc2, 0x1e, 0xf0, 0x01, 0x27, 0x06, 0xa4, 0xb0, 0x07, 0x7c, 0xc0, 0x8d,
+  0x41, 0x29, 0xec, 0x01, 0x1f, 0x70, 0x64, 0x30, 0x83, 0xe4, 0x07, 0x17,
+  0xf6, 0x07, 0x19, 0x1f, 0xe8, 0x81, 0xb6, 0xe1, 0x42, 0x19, 0xfc, 0x81,
+  0x19, 0xec, 0x41, 0x72, 0x06, 0x0e, 0x1a, 0xcc, 0xa0, 0xf0, 0x81, 0x28,
+  0xf0, 0x41, 0x1a, 0xa8, 0x81, 0x28, 0x9c, 0x02, 0x1f, 0xac, 0x01, 0x1b,
+  0xcc, 0x20, 0xed, 0xc1, 0x85, 0x99, 0x42, 0xa6, 0x07, 0x7a, 0xa0, 0x6d,
+  0xba, 0x50, 0x06, 0xa6, 0x60, 0x06, 0xa2, 0x90, 0xb4, 0x81, 0xe3, 0x06,
+  0x33, 0x28, 0xa8, 0xf0, 0x06, 0x19, 0x1f, 0xe8, 0x01, 0x1c, 0x24, 0x71,
+  0xe0, 0xc8, 0xc1, 0x0c, 0x4a, 0x2a, 0xbc, 0x41, 0xa6, 0x07, 0x7a, 0x00,
+  0x07, 0xc9, 0x1c, 0x38, 0x74, 0x30, 0x43, 0xa2, 0x0a, 0x75, 0x90, 0xf1,
+  0x81, 0x1e, 0x24, 0x76, 0xe0, 0xdc, 0xc1, 0x0c, 0x48, 0x2d, 0xd8, 0xc2,
+  0x2d, 0xe4, 0xc2, 0x2e, 0xf0, 0x42, 0x2f, 0xf8, 0xc2, 0x0c, 0x43, 0x1f,
+  0xd0, 0xc2, 0x2f, 0x54, 0x1a, 0x00, 0x62, 0x80, 0x06, 0x62, 0x20, 0x06,
+  0x62, 0xc0, 0x89, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88,
+  0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x1b, 0xb8,
+  0x81, 0x45, 0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e, 0x70, 0xa6, 0xc0, 0x0a,
+  0xac, 0x40, 0x37, 0x7e, 0x81, 0x12, 0x7e, 0x61, 0x0f, 0xf6, 0xa0, 0x0e,
+  0xf0, 0x20, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5,
+  0xed, 0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e,
+  0x14, 0x41, 0x15, 0x56, 0xe1, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34,
+  0xb2, 0x32, 0x37, 0xba, 0x51, 0x02, 0x56, 0xb8, 0x25, 0x2c, 0x4d, 0xce,
+  0xc5, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xa0, 0x15, 0x8e,
+  0x0a, 0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b,
+  0xfb, 0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x70, 0x85,
+  0x9b, 0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca,
+  0xbe, 0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0x5e, 0x01,
+  0x16, 0x62, 0xe1, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3,
+  0xb6, 0x32, 0x37, 0xba, 0x51, 0x82, 0x5f, 0x00, 0x00, 0xa9, 0x18, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80,
+  0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43,
+  0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4,
+  0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81,
+  0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01,
+  0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c,
+  0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c,
+  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1,
+  0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c,
+  0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90,
+  0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x8c, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+  0x00, 0xa4, 0xd5, 0xc0, 0x08, 0x00, 0x9d, 0x33, 0x00, 0x84, 0x8e, 0x00,
+  0xd0, 0x5b, 0x02, 0x45, 0x40, 0xf0, 0x58, 0x03, 0x10, 0x08, 0x73, 0x0c,
+  0x91, 0x1c, 0xc8, 0x01, 0x01, 0x23, 0x00, 0x33, 0x00, 0x63, 0x04, 0x20,
+  0x08, 0x82, 0xf8, 0x47, 0xc1, 0x0c, 0xc0, 0x0c, 0xc0, 0x1c, 0x44, 0x1e,
+  0xe4, 0x41, 0x1e, 0xe8, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00,
+  0x00, 0x32, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0x88,
+  0x49, 0x00, 0x00, 0x00, 0x00, 0x62, 0x80, 0x61, 0x96, 0x05, 0x00, 0x00,
+  0x00, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73,
+  0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55,
+  0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x29, 0x61,
+  0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f,
+  0x70, 0x65, 0x2d, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61,
+  0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f,
+  0x70, 0x65, 0x2d, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x73, 0x61,
+  0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f,
+  0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x34, 0x29, 0x61, 0x69, 0x72,
+  0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65,
+  0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x00, 0x00, 0x2b, 0x04, 0x73,
+  0x08, 0x87, 0x15, 0xc3, 0x39, 0x98, 0x83, 0x38, 0xac, 0x18, 0xd0, 0xc1,
+  0x1c, 0xc6, 0x61, 0xc5, 0x90, 0x0e, 0xe6, 0x40, 0x0e, 0x2b, 0x06, 0x75,
+  0x30, 0x87, 0x72, 0xd8, 0x20, 0xa0, 0xc3, 0x39, 0x6c, 0x10, 0xd4, 0x21,
+  0x1d, 0x36, 0x04, 0xe9, 0xb0, 0x61, 0x50, 0x07, 0x74, 0x38, 0x07, 0x00,
+  0x00, 0x23, 0x06, 0x8d, 0x11, 0x82, 0x60, 0xb0, 0x06, 0x71, 0x10, 0x3d,
+  0x94, 0xb3, 0x34, 0x86, 0xd1, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x62, 0xe0,
+  0x18, 0x21, 0x08, 0x06, 0x69, 0x40, 0x07, 0x52, 0x64, 0xbd, 0x01, 0xd4,
+  0x3c, 0x08, 0xf2, 0x06, 0xa3, 0x09, 0x01, 0x30, 0x86, 0x10, 0x8c, 0xc1,
+  0x20, 0x03, 0x71, 0x30, 0x73, 0x0c, 0x81, 0x00, 0x8d, 0x18, 0x38, 0x46,
+  0x08, 0x82, 0x41, 0x1a, 0xe4, 0xc1, 0x65, 0x6d, 0x76, 0x50, 0x49, 0x54,
+  0xd3, 0xd0, 0xc1, 0x68, 0x42, 0x00, 0x8c, 0x21, 0x04, 0x68, 0x30, 0xc7,
+  0x40, 0x04, 0xd3, 0x75, 0xf1, 0x52, 0x10, 0x94, 0x41, 0x86, 0x00, 0xaa,
+  0x8c, 0x08, 0xc0, 0x7f, 0x23, 0x43, 0x18, 0xb8, 0x81, 0x1f, 0x5c, 0x10,
+  0x2f, 0x05, 0x41, 0x19, 0x64, 0x08, 0x2a, 0x6d, 0xc4, 0xe0, 0x38, 0x42,
+  0x10, 0x2c, 0xfc, 0xa3, 0x5b, 0x85, 0x22, 0xd8, 0x48, 0x61, 0x06, 0x73,
+  0x30, 0x0a, 0xa1, 0xe0, 0x5d, 0x10, 0x2f, 0x05, 0x41, 0x19, 0x64, 0x08,
+  0xb4, 0x6f, 0xc4, 0xe0, 0x38, 0x42, 0x10, 0x2c, 0xfc, 0xa3, 0x83, 0x05,
+  0x25, 0xd8, 0x48, 0xb1, 0x06, 0x78, 0x80, 0x0a, 0xa6, 0x20, 0x06, 0x17,
+  0xc4, 0x4b, 0x41, 0x50, 0x06, 0x19, 0x82, 0x8f, 0x0c, 0x46, 0x0c, 0x8e,
+  0x23, 0x04, 0xc1, 0xc2, 0x3f, 0xba, 0x5a, 0x78, 0x82, 0x39, 0x86, 0x6f,
+  0xe9, 0x83, 0x39, 0x86, 0xe0, 0x48, 0x83, 0x39, 0x86, 0x60, 0x48, 0x83,
+  0x11, 0x83, 0x03, 0x89, 0x41, 0xb0, 0xf0, 0x0f, 0xc9, 0x17, 0x02, 0x3a,
+  0xb0, 0xe0, 0x0e, 0xc4, 0x3f, 0x83, 0x80, 0x18, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x5b, 0x0a, 0xe0, 0x50, 0x07, 0x64, 0x1d, 0xb6, 0x14, 0xc2, 0xa1,
+  0x0e, 0xc8, 0x3a, 0x6c, 0x29, 0x8e, 0x43, 0x1d, 0x90, 0x75, 0xd8, 0x52,
+  0x30, 0x07, 0x3b, 0x20, 0xed, 0xb0, 0xa5, 0x88, 0x0e, 0x76, 0x40, 0xda,
+  0x61, 0x4b, 0x61, 0x1d, 0xec, 0x80, 0xb4, 0xc3, 0x96, 0x62, 0x3b, 0xd8,
+  0x01, 0x69, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0xe5, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x4f, 0x00, 0x00, 0x00, 0x74, 0xce, 0x00, 0xd0, 0x5b, 0x02, 0x45,
+  0x40, 0xf0, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00, 0x74, 0xcf, 0x41, 0x44,
+  0x8f, 0xa3, 0x06, 0x63, 0x11, 0x40, 0x20, 0x1c, 0x04, 0x8c, 0x11, 0xf0,
+  0xf0, 0xaa, 0xd3, 0xdd, 0x18, 0x81, 0x2c, 0xba, 0x3d, 0x0d, 0x06, 0x63,
+  0x04, 0xb5, 0x5a, 0xab, 0xed, 0x37, 0x46, 0xd0, 0xc7, 0xa2, 0x8b, 0x7f,
+  0x63, 0x04, 0x6e, 0x1f, 0x8b, 0xb6, 0x2f, 0x8c, 0x11, 0x80, 0x20, 0x08,
+  0xe2, 0xdf, 0x18, 0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0xc4, 0x3c,
+  0xd8, 0xe7, 0xde, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xbc,
+  0x7b, 0x5a, 0xde, 0xdf, 0x18, 0x81, 0xce, 0x9a, 0x73, 0x08, 0x06, 0x23,
+  0x00, 0x63, 0x04, 0x20, 0x08, 0x82, 0x24, 0x18, 0x8c, 0x11, 0x80, 0x20,
+  0x08, 0x82, 0x60, 0x30, 0x03, 0x40, 0xc1, 0x0c, 0xc0, 0x0c, 0xc0, 0x1c,
+  0x84, 0x1d, 0xf0, 0x81, 0x1d, 0xfc, 0x01, 0x15, 0x33, 0x00, 0x23, 0x00,
+  0x33, 0x00, 0x63, 0x0d, 0x20, 0x08, 0x82, 0xf8, 0x07, 0x82, 0x20, 0x88,
+  0x7f, 0x20, 0x08, 0x82, 0xf8, 0x37, 0xd6, 0xc0, 0xb6, 0xf3, 0x4f, 0x7a,
+  0x6c, 0x3b, 0xff, 0xa4, 0xc7, 0xb6, 0xf3, 0x4f, 0x7a, 0x63, 0x0d, 0x20,
+  0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8, 0xd6, 0xbf, 0x00, 0x82, 0x20,
+  0x5b, 0xff, 0xc2, 0x58, 0x03, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x20, 0x08,
+  0xae, 0x39, 0x18, 0x80, 0x20, 0xb8, 0xe6, 0x60, 0x30, 0xd6, 0x00, 0x82,
+  0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d, 0x0e, 0x06, 0x20, 0x48, 0xb7,
+  0x39, 0x18, 0x8c, 0x35, 0xac, 0x23, 0x1e, 0xb3, 0x60, 0xb0, 0x8e, 0x78,
+  0xcc, 0x82, 0xc1, 0x3a, 0xe2, 0x31, 0x0b, 0x06, 0x63, 0x0d, 0x20, 0x08,
+  0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87, 0x63, 0x00, 0x82, 0x30, 0x1e,
+  0x8e, 0xc1, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6,
+  0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe,
+  0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2,
+  0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f,
+  0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00,
+  0x00, 0x33, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0e, 0xc4,
+  0x1d, 0x00, 0x00, 0x00, 0x00, 0xd5, 0xf3, 0x00, 0x00, 0x5f, 0x5a, 0x54,
+  0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
+  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
+  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
+  0x00, 0x13, 0x84, 0x37, 0xf8, 0x26, 0x08, 0x6f, 0x00, 0x06, 0x13, 0x84,
+  0x37, 0x08, 0x83, 0x09, 0xc2, 0x1b, 0x88, 0xc1, 0x04, 0xe1, 0x0d, 0xc6,
+  0x60, 0x82, 0xf0, 0x06, 0x64, 0x30, 0x41, 0x78, 0x83, 0x32, 0x98, 0x20,
+  0xbc, 0x81, 0x19, 0x6c, 0x08, 0xc6, 0x61, 0xc3, 0x20, 0x0e, 0xec, 0x40,
+  0x0e, 0x1b, 0x06, 0xae, 0x1d, 0xc8, 0x61, 0x43, 0x14, 0x0e, 0xee, 0x40,
+  0x0e, 0xee, 0x50, 0x0e, 0xee, 0x60, 0x0e, 0xee, 0x70, 0x0e, 0xee, 0x80,
+  0x0e, 0xee, 0x90, 0x0e, 0xee, 0xa0, 0x0e, 0xee, 0xb0, 0x0e, 0x1b, 0x86,
+  0x77, 0x70, 0x07, 0x73, 0xd8, 0x30, 0xbc, 0x83, 0x3b, 0xac, 0xc3, 0x86,
+  0xe1, 0x1d, 0xdc, 0x01, 0x1d, 0x36, 0x0c, 0xef, 0xe0, 0x0e, 0xe9, 0xb0,
+  0x61, 0x78, 0x07, 0x77, 0x50, 0x87, 0x0d, 0xc3, 0x3b, 0xb8, 0x43, 0x39,
+  0x6c, 0x18, 0xde, 0xc1, 0x1d, 0xce, 0x61, 0xc3, 0xf0, 0x0e, 0xee, 0x40,
+  0x0e, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x18, 0xce, 0x20, 0x0e, 0x44, 0x81,
+  0x02, 0x60, 0x0c, 0x47, 0x04, 0x55, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10,
+  0x0c, 0x32, 0xac, 0xc1, 0x64, 0x06, 0x7b, 0x18, 0xd6, 0xa0, 0x0e, 0xec,
+  0x80, 0x02, 0x60, 0x8c, 0x18, 0x18, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x8c,
+  0x01, 0x2b, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x61,
+  0xe0, 0x0a, 0x01, 0x64, 0x01, 0x04, 0xfe, 0x23, 0x06, 0xc7, 0x11, 0x82,
+  0x60, 0xe1, 0x1f, 0x61, 0xe0, 0x0a, 0x41, 0x65, 0x43, 0x24, 0xfe, 0x16,
+  0x05, 0xe1, 0x6f, 0x43, 0x40, 0xfe, 0x23, 0x06, 0xc6, 0x11, 0x82, 0x60,
+  0xe1, 0x1f, 0x63, 0x30, 0x0b, 0xc1, 0x88, 0xc1, 0x71, 0x84, 0x20, 0x58,
+  0xf8, 0x47, 0x18, 0xd4, 0x42, 0x30, 0x59, 0x30, 0x89, 0xff, 0x1c, 0x43,
+  0xb7, 0x84, 0xc2, 0x20, 0x43, 0xe0, 0xcd, 0x81, 0x0d, 0x01, 0xf9, 0x0f,
+  0x32, 0x04, 0x60, 0x40, 0x07, 0x83, 0x0c, 0x01, 0x1f, 0xd0, 0xc1, 0x2c,
+  0x81, 0x30, 0x50, 0x11, 0x08, 0x81, 0x3e, 0x00, 0x7b, 0x18, 0xfa, 0xe0,
+  0x14, 0x6c, 0x81, 0x02, 0x60, 0x0c, 0x47, 0x04, 0x6c, 0xe0, 0xf8, 0xc7,
+  0x2c, 0xc3, 0x40, 0x04, 0x83, 0x0c, 0x44, 0x1a, 0xf0, 0xc1, 0x1e, 0x86,
+  0x50, 0x58, 0x05, 0x57, 0xa0, 0x00, 0x18, 0x7b, 0x18, 0x46, 0xa1, 0x15,
+  0x5e, 0x81, 0x02, 0x60, 0x8c, 0x18, 0x28, 0x49, 0x0c, 0x82, 0x85, 0x7f,
+  0x7c, 0xe7, 0x50, 0x74, 0xc7, 0x10, 0x0c, 0x32, 0x04, 0x6c, 0x00, 0x0a,
+  0x83, 0x0c, 0xc1, 0x02, 0x0a, 0xb3, 0x04, 0xc4, 0x40, 0x45, 0x20, 0x0c,
+  0x98, 0x30, 0x1c, 0x11, 0x06, 0x7c, 0x10, 0xf8, 0xc7, 0x2c, 0x43, 0x31,
+  0x05, 0x7b, 0x18, 0x54, 0x81, 0x16, 0xc8, 0x81, 0x02, 0x60, 0x0c, 0x47,
+  0x04, 0x7f, 0x10, 0xf8, 0xc7, 0x2c, 0x83, 0x71, 0x04, 0x83, 0x0c, 0x85,
+  0x1d, 0xa4, 0xc2, 0x1e, 0x06, 0x57, 0xc0, 0x85, 0x72, 0xa0, 0x00, 0x18,
+  0x73, 0x0c, 0x76, 0x10, 0xe8, 0xc2, 0x20, 0x43, 0x70, 0x07, 0xac, 0x60,
+  0x41, 0x21, 0xfe, 0x83, 0x0c, 0x41, 0x1e, 0xb4, 0xc2, 0x2c, 0x41, 0x1b,
+  0xec, 0x61, 0xa0, 0x05, 0x5f, 0x60, 0x07, 0x0a, 0x80, 0xb1, 0x87, 0xc1,
+  0x16, 0xc0, 0xa1, 0x1d, 0x28, 0x00, 0xc6, 0x20, 0x03, 0x14, 0x0a, 0xb2,
+  0x30, 0x62, 0x50, 0x1c, 0x21, 0x08, 0x06, 0x5b, 0x3f, 0x10, 0xb3, 0x0c,
+  0x88, 0x14, 0x8c, 0x21, 0x48, 0xe4, 0x30, 0x1c, 0x11, 0xb4, 0x82, 0xe2,
+  0x1f, 0xb3, 0x0c, 0x4a, 0x12, 0x98, 0xd0, 0x0a, 0xe2, 0x3f, 0x4b, 0xb0,
+  0xd8, 0xd0, 0x0a, 0xe0, 0x3f, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe,
+  0x81, 0x8d, 0x44, 0x60, 0x81, 0x2b, 0x88, 0xff, 0x88, 0xc1, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0x87, 0x65, 0x12, 0x81, 0x2b, 0xcc, 0x12, 0x2c, 0x03,
+  0x15, 0x80, 0x92, 0x08, 0xca, 0x1c, 0x83, 0x2a, 0x04, 0xec, 0x30, 0x86,
+  0xb0, 0x85, 0xc3, 0x70, 0x44, 0x60, 0x0b, 0x8a, 0x7f, 0xcc, 0x32, 0x34,
+  0x4c, 0x60, 0x82, 0x2d, 0x88, 0xff, 0x2c, 0x81, 0x63, 0x83, 0x2d, 0x80,
+  0xff, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0xc6, 0x12, 0x81,
+  0x05, 0xb7, 0x20, 0xfe, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f,
+  0xd6, 0x4b, 0x04, 0xb7, 0x30, 0x4b, 0xe0, 0x0c, 0x54, 0x00, 0x0a, 0x23,
+  0x34, 0x73, 0x0c, 0x49, 0x90, 0x0e, 0x63, 0x08, 0x64, 0x90, 0x0e, 0xc3,
+  0x11, 0xc1, 0x2f, 0x28, 0xfe, 0x31, 0xcb, 0x00, 0x3d, 0x81, 0x09, 0xbf,
+  0x20, 0xfe, 0xb3, 0x04, 0x91, 0x0d, 0xbf, 0x00, 0xfe, 0x23, 0x06, 0xc6,
+  0x11, 0x82, 0x60, 0xe1, 0x1f, 0x58, 0x4d, 0x04, 0x16, 0x80, 0x83, 0xf8,
+  0x8f, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x58, 0x38, 0x11, 0x80,
+  0xc3, 0x2c, 0x41, 0x34, 0x50, 0x01, 0x28, 0x8f, 0x00, 0xcd, 0x31, 0x24,
+  0x41, 0x3c, 0xcc, 0x12, 0x48, 0x03, 0x15, 0x81, 0x10, 0xe9, 0xc1, 0x31,
+  0xc8, 0x10, 0xfc, 0x82, 0x3c, 0xcc, 0x31, 0xf4, 0x02, 0x18, 0x84, 0xc4,
+  0x20, 0x43, 0xe0, 0x0b, 0xf3, 0x60, 0x43, 0x20, 0xfe, 0x83, 0x0c, 0x01,
+  0x38, 0xd0, 0xc3, 0x2c, 0x41, 0x1b, 0x0c, 0x47, 0xcc, 0x82, 0x39, 0x04,
+  0xfe, 0x31, 0xcb, 0x40, 0x81, 0x41, 0x30, 0xc8, 0x40, 0x07, 0xe5, 0x80,
+  0x0f, 0x7b, 0x18, 0xfa, 0xe1, 0x24, 0x6a, 0x82, 0x02, 0x60, 0xec, 0x61,
+  0xf8, 0x87, 0x94, 0xb0, 0x09, 0x0a, 0x80, 0x31, 0xc7, 0x70, 0x0e, 0xc1,
+  0x4a, 0x0c, 0x32, 0x04, 0xe8, 0xd0, 0x0f, 0x16, 0x1c, 0xe2, 0x3f, 0xc8,
+  0x10, 0xa8, 0x83, 0x3f, 0x8c, 0x18, 0x14, 0x47, 0x08, 0x82, 0xc1, 0x96,
+  0x16, 0xc7, 0x2c, 0xc3, 0x57, 0x05, 0x63, 0x08, 0x03, 0x4c, 0x0c, 0x47,
+  0x04, 0xff, 0xa0, 0xf8, 0xc7, 0x2c, 0xc3, 0x65, 0x05, 0x26, 0xfc, 0x83,
+  0xf8, 0xcf, 0x12, 0x60, 0x23, 0x06, 0xc6, 0x11, 0x82, 0x60, 0xe1, 0x1f,
+  0x98, 0x5b, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x16,
+  0x5c, 0x04, 0x20, 0x61, 0x01, 0x48, 0x88, 0xbf, 0x05, 0x20, 0x01, 0xfe,
+  0xb3, 0x04, 0xd8, 0x40, 0x05, 0xa0, 0x58, 0xc2, 0x35, 0xc7, 0x20, 0x0f,
+  0x01, 0x4e, 0x8c, 0x21, 0x30, 0x2d, 0x31, 0x1c, 0x11, 0xa0, 0x84, 0xe2,
+  0x1f, 0xb3, 0x0c, 0x5a, 0x16, 0x98, 0x80, 0x12, 0xe2, 0x3f, 0x4b, 0xb0,
+  0x8d, 0x18, 0x18, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x60, 0x77, 0x31, 0x8c,
+  0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x58, 0x79, 0x11, 0xa4, 0x84,
+  0x05, 0x29, 0x21, 0xfe, 0x16, 0xa4, 0x04, 0xf8, 0xcf, 0x12, 0x6c, 0x03,
+  0x15, 0x80, 0x92, 0x09, 0xda, 0x1c, 0x43, 0x12, 0xd4, 0xc4, 0x18, 0x42,
+  0x55, 0x13, 0xc3, 0x11, 0x41, 0x4c, 0x28, 0xfe, 0x31, 0xcb, 0xd0, 0x71,
+  0x81, 0x09, 0x31, 0x21, 0xfe, 0xb3, 0x04, 0xde, 0x88, 0x81, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0x07, 0x06, 0x1a, 0xc3, 0x88, 0xc1, 0x71, 0x84, 0x20,
+  0x58, 0xf8, 0x87, 0x25, 0x1a, 0x81, 0x4c, 0x58, 0x20, 0x13, 0xe2, 0x6f,
+  0x81, 0x4c, 0x80, 0xff, 0x2c, 0x81, 0x37, 0x50, 0x01, 0x28, 0x9c, 0xd0,
+  0xcd, 0x31, 0x24, 0x41, 0x4f, 0x8c, 0x18, 0x20, 0x47, 0x08, 0x82, 0x85,
+  0x7f, 0x50, 0xa8, 0x11, 0x98, 0x04, 0x49, 0x0c, 0x32, 0x04, 0x28, 0xc1,
+  0x13, 0xb3, 0x04, 0xdf, 0x40, 0x45, 0xe0, 0x07, 0x94, 0xe0, 0x0d, 0x32,
+  0x04, 0x2d, 0xe1, 0x13, 0xb3, 0x04, 0x6d, 0x30, 0xcb, 0x10, 0x06, 0x6d,
+  0xc0, 0x0f, 0x83, 0x0c, 0xbd, 0xe0, 0x12, 0x61, 0x31, 0x62, 0x70, 0x1c,
+  0x21, 0x08, 0x16, 0xfe, 0xd1, 0xa5, 0x46, 0x20, 0x12, 0x73, 0x0c, 0x2b,
+  0x11, 0xc4, 0xc5, 0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x47, 0xb7,
+  0x1a, 0xc3, 0x48, 0xcc, 0x31, 0x08, 0xc1, 0x59, 0x8c, 0x18, 0x1c, 0x47,
+  0x08, 0x82, 0x85, 0x7f, 0x74, 0xad, 0x51, 0x90, 0xc4, 0x1c, 0x83, 0x10,
+  0xa0, 0xc5, 0x20, 0x43, 0x20, 0x13, 0x66, 0x31, 0xc8, 0x10, 0x94, 0x83,
+  0x59, 0xec, 0x61, 0x70, 0x0b, 0xbc, 0x30, 0x0d, 0x0a, 0x80, 0xb1, 0x87,
+  0x01, 0x2e, 0xf4, 0xe2, 0x34, 0x28, 0x00, 0xc6, 0x1c, 0x03, 0x4e, 0x04,
+  0x7c, 0x31, 0xc8, 0x10, 0xe4, 0x84, 0x5b, 0x58, 0x90, 0x88, 0xff, 0x20,
+  0x43, 0xb0, 0x13, 0x6f, 0x31, 0x62, 0x50, 0x1c, 0x21, 0x08, 0x06, 0x9b,
+  0x6e, 0x1c, 0xb3, 0x0c, 0x6c, 0x20, 0x06, 0xc1, 0x18, 0xc2, 0x10, 0x1a,
+  0xc3, 0x11, 0x01, 0x5c, 0x28, 0xfe, 0x31, 0xcb, 0x40, 0x06, 0x63, 0x10,
+  0x98, 0x00, 0x17, 0xe2, 0x3f, 0x4b, 0x50, 0x06, 0x23, 0x06, 0xc6, 0x11,
+  0x82, 0x60, 0xe1, 0x1f, 0xd8, 0x6f, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82,
+  0x60, 0xe1, 0x1f, 0x56, 0x78, 0x04, 0x71, 0x61, 0x41, 0x5c, 0x88, 0xbf,
+  0x05, 0x71, 0x01, 0xfe, 0xb3, 0x04, 0x65, 0x30, 0x50, 0x01, 0x28, 0x63,
+  0x20, 0x90, 0xc1, 0x1c, 0xc3, 0x58, 0x04, 0xa9, 0x31, 0x86, 0xc0, 0xf8,
+  0xc5, 0x70, 0x44, 0x90, 0x17, 0x8a, 0x7f, 0xcc, 0x32, 0x9c, 0x81, 0x19,
+  0x04, 0x26, 0xe4, 0x85, 0xf8, 0xcf, 0x12, 0xa0, 0xc1, 0x88, 0x81, 0x71,
+  0x84, 0x20, 0x58, 0xf8, 0x07, 0x86, 0x1e, 0xc3, 0x88, 0xc1, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0x87, 0xa5, 0x1e, 0x81, 0x5e, 0x58, 0xa0, 0x17, 0xe2,
+  0x6f, 0x81, 0x5e, 0x80, 0xff, 0x2c, 0x01, 0x1a, 0x0c, 0x54, 0x00, 0x8a,
+  0x19, 0x08, 0x67, 0x30, 0xc7, 0x90, 0x04, 0xa6, 0x31, 0x86, 0x50, 0x99,
+  0xc6, 0x70, 0x44, 0x20, 0x1a, 0x8a, 0x7f, 0xcc, 0x32, 0xa8, 0x41, 0x1a,
+  0x04, 0x26, 0x88, 0x86, 0xf8, 0xcf, 0x12, 0xac, 0xc1, 0x88, 0x81, 0x71,
+  0x84, 0x20, 0x58, 0xf8, 0x07, 0x16, 0x1f, 0xc3, 0x88, 0xc1, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0x87, 0x35, 0x1f, 0xc1, 0x68, 0x58, 0x30, 0x1a, 0xe2,
+  0x6f, 0xc1, 0x68, 0x80, 0xff, 0x2c, 0xc1, 0x1a, 0x0c, 0x54, 0x00, 0x4a,
+  0x1a, 0x08, 0x6a, 0x30, 0xc7, 0x90, 0x04, 0xae, 0x31, 0x62, 0x80, 0x1c,
+  0x21, 0x08, 0x16, 0xfe, 0x41, 0xe5, 0x47, 0x70, 0x17, 0x75, 0x31, 0xc8,
+  0x10, 0xe4, 0x45, 0x6b, 0xcc, 0x12, 0xb0, 0xc1, 0x40, 0x45, 0xe0, 0x07,
+  0x61, 0x20, 0xac, 0xc1, 0x20, 0x43, 0xe0, 0x17, 0xaf, 0x31, 0x4b, 0xd0,
+  0x06, 0x03, 0x2d, 0x01, 0x8f, 0x18, 0x3c, 0x22, 0xf1, 0xc8, 0x27, 0x0b,
+  0x6c, 0xc0, 0x23, 0x60, 0x30, 0xd0, 0x12, 0xa0, 0x88, 0xa1, 0x17, 0x92,
+  0x39, 0x7c, 0x04, 0x1b, 0xf0, 0x0b, 0x18, 0x0c, 0x32, 0x04, 0x42, 0x6c,
+  0x64, 0x10, 0x10, 0x03, 0x00, 0x12, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20,
+  0x78, 0x87, 0x2d, 0x83, 0x11, 0xc0, 0xc3, 0x96, 0x21, 0x0b, 0xe2, 0x61,
+  0xcb, 0xe0, 0x05, 0xf2, 0xb0, 0x65, 0x00, 0x83, 0x60, 0x1e, 0xb6, 0x0c,
+  0x69, 0x10, 0xd0, 0xc3, 0x96, 0xc1, 0x0d, 0x82, 0x7a, 0xd8, 0x32, 0xd4,
+  0x41, 0x60, 0x0f, 0x5b, 0x86, 0x3b, 0x08, 0xea, 0x61, 0xcb, 0xb0, 0x0e,
+  0x81, 0x3d, 0x6c, 0x19, 0xda, 0x21, 0xa8, 0x87, 0x2d, 0x43, 0x5a, 0x04,
+  0xf6, 0xb0, 0x65, 0x58, 0x8b, 0xa0, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x74, 0xce, 0x00,
+  0xd0, 0x5b, 0x02, 0x45, 0x40, 0xf0, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00,
+  0x74, 0xcf, 0x41, 0x44, 0x8f, 0xd3, 0x06, 0x04, 0x8c, 0x11, 0x80, 0x20,
+  0x08, 0xe2, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x23, 0x00,
+  0x14, 0xcc, 0x00, 0xcc, 0x00, 0x50, 0x31, 0x03, 0x30, 0xd6, 0xc0, 0xb2,
+  0x67, 0x28, 0x7f, 0xa8, 0x5f, 0xc6, 0xea, 0x97, 0x9f, 0xba, 0x38, 0x7b,
+  0x63, 0x0d, 0x7a, 0x0d, 0xee, 0xb8, 0xa7, 0xe2, 0xb9, 0x6d, 0x7f, 0x6f,
+  0x9f, 0xd2, 0xa3, 0x37, 0xd6, 0xb0, 0xce, 0x31, 0x8b, 0x7a, 0x69, 0x08,
+  0xa3, 0xbb, 0x77, 0xb7, 0xb1, 0x6a, 0x7f, 0x63, 0x0d, 0x62, 0x2e, 0xa6,
+  0xfd, 0x07, 0x96, 0x3c, 0x1b, 0xff, 0xc2, 0x98, 0xae, 0x6a, 0xee, 0x0b,
+  0x63, 0x0d, 0xff, 0x4c, 0xfa, 0xbf, 0x2f, 0xd0, 0x35, 0x28, 0xe6, 0x5f,
+  0x0b, 0xc7, 0x31, 0xe8, 0x0b, 0x63, 0x0d, 0x73, 0xdf, 0xa6, 0xa9, 0x2f,
+  0xb4, 0x6e, 0xc8, 0xf3, 0xbe, 0xc0, 0xe7, 0xac, 0x8f, 0x7f, 0x00, 0x00,
+  0x00, 0x83, 0x0c, 0xd7, 0xd1, 0x0c, 0x47, 0x58, 0x4d, 0xe0, 0x1f, 0xb3,
+  0x0c, 0x81, 0x10, 0xcc, 0x31, 0x24, 0x96, 0x18, 0x0c, 0x32, 0x04, 0x4a,
+  0x64, 0xc1, 0x26, 0xfe, 0x83, 0x0c, 0x01, 0x23, 0xcd, 0x12, 0x24, 0xc3,
+  0x11, 0x5b, 0x14, 0xf8, 0xc7, 0x2c, 0xc3, 0x90, 0x04, 0xc3, 0x11, 0x9d,
+  0x14, 0xf8, 0xc7, 0x2c, 0x03, 0x51, 0x04, 0x23, 0x06, 0xc7, 0x11, 0x82,
+  0x60, 0xe1, 0x1f, 0x5d, 0x28, 0x7c, 0xce, 0x1c, 0x43, 0x14, 0xa4, 0xc1,
+  0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x47, 0x37, 0x0a, 0x61, 0xf0,
+  0xcc, 0x31, 0x08, 0x01, 0x37, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe,
+  0xd1, 0x95, 0xc2, 0x18, 0x40, 0x73, 0x0c, 0x42, 0xd0, 0xcd, 0x12, 0x14,
+  0x03, 0x15, 0x81, 0x40, 0x70, 0xc3, 0x18, 0x42, 0xf0, 0x06, 0x63, 0x08,
+  0x42, 0x18, 0x8c, 0x21, 0x0c, 0x61, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08,
+  0x16, 0xfe, 0x61, 0xa5, 0x82, 0x10, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82,
+  0x85, 0x7f, 0x58, 0xaa, 0x40, 0x04, 0xc3, 0x11, 0x81, 0x27, 0xf8, 0xc7,
+  0x2c, 0x83, 0x71, 0x04, 0x83, 0x0c, 0x87, 0x47, 0x06, 0x36, 0xa8, 0x81,
+  0xf8, 0x5b, 0x30, 0x06, 0xe0, 0x6f, 0xc5, 0x1a, 0x88, 0xbf, 0x05, 0x65,
+  0x00, 0xfe, 0x36, 0x04, 0xe4, 0x3f, 0xc7, 0x20, 0x06, 0xc1, 0x1e, 0x0c,
+  0x32, 0x04, 0x63, 0xa0, 0x06, 0x16, 0x20, 0xe2, 0x3f, 0xc8, 0x10, 0x94,
+  0xc1, 0x1a, 0xcc, 0x12, 0x1c, 0x03, 0x15, 0x81, 0x60, 0x88, 0x41, 0x31,
+  0xcb, 0x80, 0x24, 0xd9, 0x20, 0x43, 0x90, 0x06, 0x6f, 0x30, 0x62, 0x70,
+  0x1c, 0x21, 0x08, 0x16, 0xfe, 0xd1, 0xe9, 0x42, 0x40, 0x06, 0x73, 0x0c,
+  0x6a, 0x10, 0x88, 0xc2, 0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x47,
+  0xc7, 0x0b, 0x43, 0x19, 0xcc, 0x31, 0x08, 0x41, 0x1d, 0x8c, 0x18, 0x1c,
+  0x47, 0x08, 0x82, 0x85, 0x7f, 0x74, 0xbe, 0x50, 0x98, 0xc1, 0x1c, 0x83,
+  0x10, 0xd8, 0xc1, 0x2c, 0x41, 0x32, 0x50, 0x12, 0x90, 0x42, 0xe0, 0x0a,
+  0x82, 0x80, 0x40, 0xc7, 0x20, 0x43, 0x10, 0x07, 0x77, 0x90, 0x01, 0x00,
+  0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10,
+  0x22, 0x84, 0x00, 0xbf, 0x09, 0x18, 0xd0, 0xac, 0x80, 0x07, 0xb4, 0x0e,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x6d, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0x68, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x3e, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x66, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x38, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x00,
+  0x00, 0x48, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x5c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x6c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x7d, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00,
+  0x00, 0x16, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x93, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0xa0, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00,
+  0x00, 0x19, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x00,
+  0x00, 0xb9, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0xca, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xca, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0xdc, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0xef, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xef, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x02, 0x01, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
+  0x00, 0x21, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x23, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x23, 0x01, 0x00,
+  0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x5d, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0xe6, 0x02, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x5f, 0x5a, 0x31, 0x34, 0x47, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x70,
+  0x75, 0x74, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x52, 0x55, 0x31, 0x31, 0x4d, 0x54, 0x4c, 0x63, 0x6f, 0x6e, 0x73, 0x74,
+  0x61, 0x6e, 0x74, 0x4b, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x61, 0x69, 0x72,
+  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x2e,
+  0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e, 0x66,
+  0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72,
+  0x74, 0x2e, 0x75, 0x2e, 0x69, 0x31, 0x2e, 0x66, 0x2e, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33,
+  0x32, 0x5f, 0x5a, 0x31, 0x32, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x54, 0x6f,
+  0x6e, 0x65, 0x6d, 0x61, 0x70, 0x44, 0x76, 0x33, 0x5f, 0x66, 0x66, 0x66,
+  0x66, 0x66, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66,
+  0x6d, 0x61, 0x78, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x76, 0x33, 0x66, 0x33,
+  0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x61,
+  0x62, 0x73, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e,
+  0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78, 0x2e, 0x76, 0x33,
+  0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64,
+  0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34,
+  0x66, 0x33, 0x32, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34,
+  0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d,
+  0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69,
+  0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0xa4, 0x22, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00,
+  0x00, 0x21, 0x0c, 0x00, 0x00, 0xe1, 0x07, 0x00, 0x00, 0x0b, 0x02, 0x21,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x23, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x31, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x6d, 0x01, 0x00, 0x00, 0x1b, 0xc2, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x22,
+  0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0, 0xa1, 0x0d, 0xcc, 0xa1,
+  0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
+  0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x38, 0x87, 0x70,
+  0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79,
+  0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07, 0x74, 0x00, 0xe2, 0x40,
+  0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1c, 0xea, 0x21,
+  0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6, 0x01, 0x20, 0xdc, 0xe1,
+  0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00,
+  0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0,
+  0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
+  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76,
+  0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72,
+  0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77,
+  0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80,
+  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x20,
+  0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
+  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
+  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79,
+  0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74,
+  0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
+  0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40,
+  0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1,
+  0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a,
+  0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70,
+  0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62,
+  0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1,
+  0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40,
+  0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21,
+  0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79,
+  0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0xd8, 0xe0, 0x09, 0x04, 0xb0, 0x00, 0x55, 0x90, 0x06, 0x60, 0x30, 0x84,
+  0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83, 0x39, 0x94,
+  0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b, 0x84, 0x03, 0x3b, 0xa4,
+  0x43, 0x38, 0xcc, 0x03, 0xb0, 0xc1, 0x1b, 0x0a, 0x60, 0x01, 0xaa, 0x20,
+  0x0d, 0x40, 0x61, 0x08, 0x87, 0x74, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x03, 0x77, 0x78, 0x87, 0x36,
+  0x08, 0x07, 0x76, 0x48, 0x87, 0x70, 0x98, 0x07, 0x60, 0x83, 0x41, 0x20,
+  0xc0, 0x02, 0x54, 0x1b, 0xc2, 0xa4, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01,
+  0x58, 0x03, 0x40, 0x02, 0x2a, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1,
+  0x1d, 0xf0, 0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36,
+  0x60, 0x87, 0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72,
+  0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72,
+  0xa0, 0x07, 0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1,
+  0x1d, 0xda, 0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1,
+  0x1d, 0xe6, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21,
+  0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81,
+  0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76,
+  0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1,
+  0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61,
+  0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77,
+  0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
+  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61,
+  0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81,
+  0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c,
+  0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36,
+  0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80,
+  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0xd8, 0x90, 0x18, 0x02, 0xb0, 0x00,
+  0x55, 0x90, 0x06, 0x60, 0xb0, 0xc1, 0x38, 0xfe, 0xff, 0xff, 0xff, 0x7f,
+  0x00, 0x24, 0x80, 0xda, 0xe0, 0x23, 0xc8, 0xff, 0xff, 0xff, 0xff, 0x0f,
+  0x80, 0x04, 0x54, 0x44, 0x38, 0xc0, 0x03, 0x3c, 0xc8, 0xc3, 0x3b, 0xe0,
+  0x43, 0x1b, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb4, 0x81, 0x39, 0xc0,
+  0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f,
+  0xf5, 0x50, 0x0e, 0x00, 0xd1, 0x0e, 0xe9, 0xe0, 0x0e, 0x6d, 0xc0, 0x0e,
+  0xe5, 0x70, 0x0e, 0xe1, 0xc0, 0x0e, 0x6d, 0x60, 0x0f, 0xe5, 0x30, 0x0e,
+  0xf4, 0xf0, 0x0e, 0xf2, 0xd0, 0x06, 0xf7, 0x90, 0x0e, 0xe4, 0x40, 0x0f,
+  0xe8, 0x00, 0xe4, 0x81, 0x1d, 0x00, 0x83, 0x3b, 0xbc, 0x43, 0x1b, 0x88,
+  0x43, 0x3d, 0xa4, 0x03, 0x3b, 0xd0, 0x43, 0x3a, 0xb8, 0xc3, 0x3c, 0x00,
+  0x84, 0x3b, 0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94,
+  0x43, 0x1b, 0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8,
+  0x43, 0x1b, 0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0x00, 0xf4, 0x20, 0x0f,
+  0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xe6, 0x20, 0x0f,
+  0xe1, 0xd0, 0x0e, 0xe5, 0xd0, 0x06, 0xf0, 0xf0, 0x0e, 0xe9, 0xe0, 0x0e,
+  0xf4, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xe5, 0xc0, 0x0e, 0xe9, 0xd0, 0x0e,
+  0x6d, 0xe0, 0x0e, 0xef, 0xe0, 0x0e, 0x6d, 0xc0, 0x0e, 0xe5, 0x10, 0x0e,
+  0xe6, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc,
+  0x43, 0x1b, 0xa4, 0x83, 0x3b, 0x98, 0xc3, 0x3c, 0xb4, 0x81, 0x39, 0xc0,
+  0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f,
+  0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xee, 0x10, 0x0e,
+  0xee, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10, 0x0e,
+  0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8,
+  0xc3, 0x3b, 0xb4, 0xc1, 0x3c, 0xa4, 0xc3, 0x39, 0xb8, 0x43, 0x39, 0x90,
+  0x43, 0x1b, 0xe8, 0x43, 0x39, 0xc8, 0xc3, 0x3b, 0xcc, 0x43, 0x1b, 0x98,
+  0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f,
+  0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x40, 0x0f,
+  0xf2, 0x10, 0x0e, 0xf0, 0x00, 0x0f, 0xe9, 0xe0, 0x0e, 0xe7, 0xd0, 0x06,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94,
+  0x03, 0x40, 0xcc, 0x03, 0x3d, 0x84, 0xc3, 0x38, 0xac, 0x43, 0x1b, 0xc0,
+  0x83, 0x3c, 0xbc, 0x03, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8,
+  0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4,
+  0xc1, 0x3c, 0xa4, 0x83, 0x3e, 0x94, 0x03, 0x80, 0x07, 0x00, 0x51, 0x0f,
+  0xee, 0x30, 0x0f, 0xe1, 0x60, 0x0e, 0xe5, 0xd0, 0x06, 0xe6, 0x00, 0x0f,
+  0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4,
+  0x43, 0x39, 0x00, 0x1b, 0x94, 0xe4, 0xff, 0xff, 0xff, 0xff, 0x07, 0xa0,
+  0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda, 0x60, 0x28, 0x01, 0xb0, 0x00,
+  0xd5, 0x06, 0x63, 0x11, 0x80, 0x05, 0xa8, 0x36, 0x28, 0xcc, 0xff, 0xff,
+  0xff, 0xff, 0x0f, 0x40, 0x1b, 0x00, 0x6b, 0x00, 0x48, 0x40, 0xb5, 0xc1,
+  0x68, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80, 0xda, 0x30, 0x39,
+  0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x6b, 0x00, 0x28, 0x83, 0x3b, 0xbc,
+  0x43, 0x1b, 0x88, 0x43, 0x3d, 0xa4, 0x03, 0x3b, 0xd0, 0x43, 0x3a, 0xb8,
+  0xc3, 0x3c, 0x00, 0x1b, 0x8a, 0x47, 0x08, 0xd2, 0x00, 0x0c, 0x36, 0x44,
+  0xd0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x32, 0xb8, 0xc3, 0x3b, 0xb4,
+  0x81, 0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03, 0x3d, 0xa4, 0x83, 0x3b, 0xcc,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x42, 0x61, 0x4c, 0x08, 0x8e,
+  0x09, 0x01, 0x32, 0x61, 0x48, 0x94, 0x65, 0xc2, 0xc0, 0x28, 0xcb, 0x84,
+  0xa0, 0x99, 0x20, 0x38, 0xcf, 0x84, 0x00, 0x02, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x48, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xd0, 0xc1,
+  0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04,
+  0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84,
+  0x41, 0x18, 0x46, 0x18, 0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xc6, 0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e,
+  0xc2, 0x81, 0x1d, 0xf4, 0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e,
+  0xd2, 0x01, 0x1f, 0x50, 0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe,
+  0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40,
+  0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8,
+  0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0xb8,
+  0x48, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2,
+  0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x18, 0xa1, 0x24, 0x41, 0x10, 0x08,
+  0x44, 0xb2, 0x2c, 0x0d, 0x39, 0x65, 0x08, 0x02, 0x82, 0xa0, 0x42, 0x14,
+  0x45, 0x51, 0x90, 0x54, 0x06, 0x00, 0x00, 0x88, 0x2a, 0x02, 0x00, 0x90,
+  0x35, 0x47, 0x10, 0x14, 0x01, 0x03, 0x28, 0x2b, 0x03, 0x50, 0x14, 0xb4,
+  0x15, 0xa3, 0x28, 0x00, 0x00, 0x00, 0xa8, 0x2b, 0x43, 0x51, 0x14, 0xf4,
+  0x15, 0xa1, 0x28, 0x28, 0x9c, 0x23, 0x40, 0x8c, 0x10, 0x8c, 0x73, 0x04,
+  0x60, 0x30, 0x8c, 0x20, 0x94, 0x41, 0x51, 0xc8, 0xa5, 0x11, 0x30, 0x13,
+  0x03, 0x80, 0x92, 0xce, 0x81, 0x80, 0x14, 0x28, 0xe7, 0x08, 0x40, 0x61,
+  0x10, 0x01, 0x10, 0xa6, 0x00, 0x46, 0x00, 0x86, 0x11, 0x86, 0x32, 0x18,
+  0x44, 0x08, 0x84, 0x41, 0x84, 0x43, 0x18, 0x44, 0x28, 0x84, 0x61, 0x04,
+  0xa2, 0x0c, 0x00, 0x00, 0x00, 0x13, 0xbe, 0x70, 0x48, 0x07, 0x79, 0xb0,
+  0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68,
+  0x83, 0x74, 0x78, 0x87, 0x79, 0x88, 0x83, 0x39, 0x70, 0x03, 0x38, 0x70,
+  0x03, 0x38, 0x68, 0x83, 0x79, 0x48, 0x87, 0x76, 0xa8, 0x07, 0x76, 0x08,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78,
+  0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d,
+  0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76,
+  0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d,
+  0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79,
+  0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75,
+  0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a,
+  0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72,
+  0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71,
+  0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x11, 0xc2, 0x90, 0x11, 0xdb,
+  0x95, 0xff, 0xf9, 0xd6, 0xf6, 0x5f, 0x44, 0x80, 0xc1, 0x10, 0xcd, 0x34,
+  0x24, 0x02, 0x22, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x44, 0x11, 0x1e, 0x40, 0x08, 0x30, 0x08, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x24, 0x4a, 0x05, 0x4a, 0x02, 0x02,
+  0x60, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21, 0x51, 0x2f,
+  0x40, 0x14, 0x10, 0x00, 0x03, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0x89, 0xda, 0x21, 0xb2, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0x60, 0x48, 0xe4, 0x0f, 0x56, 0x06, 0x04, 0xc0, 0x00,
+  0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x43, 0x22, 0x9a, 0x68, 0x36,
+  0x20, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12,
+  0x85, 0x45, 0xd6, 0x21, 0xc0, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0xc0, 0x90, 0x48, 0x2f, 0x22, 0x0a, 0x08, 0x80, 0x01, 0x00, 0x00,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x86, 0x44, 0xab, 0x21, 0x7d, 0x40, 0x00,
+  0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x30, 0x24, 0xea, 0x8d,
+  0x29, 0x0c, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x60, 0x48, 0x04, 0x1f, 0xd3, 0x07, 0x04, 0xc0, 0x00, 0x00, 0x00, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x43, 0xa2, 0x11, 0xd9, 0xce, 0x00, 0x08, 0x80,
+  0x02, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x24, 0x36, 0x08, 0x14,
+  0x15, 0x3f, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x2a, 0x8b, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0,
+  0x0c, 0x0a, 0xa8, 0x20, 0x0a, 0xa3, 0x40, 0x0a, 0xa5, 0x60, 0x0a, 0xa7,
+  0x00, 0x03, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c, 0x68, 0x1d, 0x01, 0x28,
+  0x84, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0x52, 0xc7,
+  0x12, 0x24, 0x01, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0xf2, 0x00, 0x0e, 0xdc, 0x0c, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x41,
+  0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca,
+  0x23, 0x21, 0x54, 0xc1, 0x30, 0xca, 0xe2, 0x3c, 0xcf, 0x13, 0x5d, 0x4f,
+  0x60, 0x18, 0x88, 0x91, 0x18, 0x8b, 0x82, 0x11, 0xc5, 0x72, 0x04, 0xd5,
+  0xf3, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65,
+  0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
+  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f,
+  0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61,
+  0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69,
+  0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61,
+  0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f, 0x75, 0x74, 0x70,
+  0x75, 0x74, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x74,
+  0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f,
+  0x64, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63,
+  0x74, 0x6f, 0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f,
+  0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x73, 0x64, 0x72, 0x5f, 0x77,
+  0x68, 0x69, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x74, 0x73, 0x63, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33,
+  0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33,
+  0x78, 0x33, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x59, 0x55, 0x56, 0x44,
+  0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c,
+  0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59,
+  0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73,
+  0x5f, 0x5a, 0x54, 0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x6e,
+  0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72,
+  0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54,
+  0x42, 0x41, 0x41, 0x00, 0x00, 0x04, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0x50, 0x06, 0xcd, 0x08, 0x82, 0x1a, 0x98, 0xc1, 0x08,
+  0x42, 0x19, 0x38, 0x23, 0x08, 0x65, 0xf0, 0x8c, 0x20, 0x94, 0x01, 0x34,
+  0x82, 0xf0, 0x00, 0x23, 0x08, 0x65, 0x10, 0x8d, 0x20, 0x94, 0x81, 0x34,
+  0x82, 0x50, 0x06, 0xd3, 0x08, 0x42, 0x19, 0x50, 0x23, 0x08, 0x65, 0x50,
+  0x8d, 0x20, 0x94, 0x81, 0x35, 0x82, 0x50, 0x06, 0xd7, 0x08, 0x42, 0x19,
+  0x60, 0x23, 0x08, 0x65, 0x90, 0x8d, 0x20, 0x94, 0x81, 0x36, 0x82, 0x50,
+  0x06, 0xdb, 0x08, 0x42, 0x19, 0x70, 0x23, 0x08, 0x65, 0xd0, 0x8d, 0x20,
+  0xac, 0x81, 0x37, 0x82, 0xb0, 0x06, 0xdf, 0x08, 0xc2, 0x1a, 0x80, 0xc1,
+  0x08, 0xc2, 0x1a, 0x84, 0xc1, 0x08, 0xc2, 0x1a, 0x88, 0xc1, 0x08, 0xc2,
+  0x1a, 0x8c, 0xc1, 0x08, 0xc2, 0x1a, 0x90, 0xc1, 0x08, 0xc2, 0x1a, 0x94,
+  0xc1, 0x0c, 0x83, 0x1e, 0x04, 0x7b, 0x30, 0xc3, 0xc0, 0x07, 0x42, 0x1f,
+  0xcc, 0x10, 0x0c, 0x33, 0x0c, 0x7a, 0xa0, 0x07, 0x7e, 0x30, 0x03, 0x41,
+  0xf0, 0x01, 0x1f, 0xf8, 0xc1, 0x0c, 0x41, 0x31, 0x43, 0x60, 0xcc, 0x10,
+  0x1c, 0x33, 0x14, 0x88, 0x1f, 0xf8, 0x41, 0xa2, 0xcc, 0x10, 0xf4, 0xc2,
+  0x0c, 0x88, 0x1f, 0x2c, 0x4c, 0x93, 0x28, 0xce, 0x33, 0x43, 0xc2, 0x07,
+  0x50, 0xc4, 0x48, 0x89, 0xe2, 0x4c, 0x33, 0x24, 0x7a, 0x00, 0x51, 0x8c,
+  0x94, 0x54, 0x8e, 0x35, 0x03, 0x1a, 0xf8, 0x41, 0x1f, 0xf8, 0x01, 0xd7,
+  0xf5, 0x41, 0x1f, 0xf8, 0x01, 0xe7, 0x89, 0x42, 0x1f, 0xf8, 0x01, 0xf7,
+  0x8d, 0x42, 0x1f, 0xf8, 0x01, 0x07, 0x06, 0xa4, 0xd0, 0x07, 0x7e, 0xc0,
+  0x85, 0x41, 0x29, 0xf4, 0x81, 0x1f, 0x70, 0x62, 0x60, 0x0a, 0x7d, 0xe0,
+  0x07, 0xdc, 0x18, 0x9c, 0x42, 0x1f, 0xf8, 0x01, 0x47, 0x06, 0x33, 0x48,
+  0xa0, 0x70, 0x61, 0xa1, 0x90, 0xf9, 0x01, 0x1f, 0x68, 0x9b, 0x38, 0x94,
+  0x41, 0x28, 0x98, 0x41, 0x1f, 0x24, 0x67, 0xe0, 0xa0, 0xc1, 0x0c, 0x8a,
+  0x1f, 0x90, 0x82, 0x1f, 0xa4, 0x81, 0x1a, 0x90, 0x42, 0x2a, 0xf8, 0xc1,
+  0x1a, 0xb0, 0xc1, 0x0c, 0x52, 0x1f, 0x5c, 0x18, 0x2a, 0x64, 0x7c, 0xc0,
+  0x07, 0xda, 0x46, 0x0e, 0x65, 0x80, 0x0a, 0x66, 0x40, 0x0a, 0x49, 0x1b,
+  0x38, 0x6e, 0x30, 0x83, 0xa2, 0x0a, 0x6f, 0x90, 0xf9, 0x01, 0x1f, 0xc0,
+  0x41, 0x12, 0x07, 0x8e, 0x1c, 0xcc, 0xa0, 0xac, 0xc2, 0x1b, 0x64, 0x7c,
+  0xc0, 0x07, 0x70, 0x90, 0xc4, 0x81, 0x33, 0x07, 0x33, 0x24, 0xac, 0x40,
+  0x07, 0x99, 0x1f, 0xf0, 0x41, 0x52, 0x07, 0x8e, 0x1d, 0xcc, 0x80, 0xfc,
+  0x02, 0x38, 0x84, 0xc3, 0x38, 0x94, 0x83, 0x39, 0x9c, 0x03, 0x3a, 0xcc,
+  0x30, 0xfc, 0x81, 0x2f, 0xa4, 0xc3, 0x0c, 0x41, 0x1e, 0xcc, 0x30, 0xe0,
+  0xc1, 0x3a, 0xb4, 0xc2, 0x0c, 0x03, 0xc7, 0x0e, 0xad, 0x30, 0x43, 0x74,
+  0x07, 0xed, 0xd0, 0x0a, 0xed, 0xe0, 0x0a, 0xed, 0xf0, 0x0a, 0xed, 0x00,
+  0x0b, 0xed, 0x10, 0x0b, 0xed, 0x20, 0x0b, 0xed, 0x30, 0x0b, 0xed, 0x40,
+  0x0b, 0x33, 0x0c, 0xee, 0xd0, 0x0e, 0xae, 0x50, 0x76, 0x00, 0x88, 0x01,
+  0x1a, 0x88, 0x81, 0x18, 0x88, 0x01, 0x27, 0x06, 0x62, 0x20, 0x06, 0x62,
+  0x20, 0x06, 0x62, 0x20, 0x06, 0x62, 0x20, 0x06, 0x62, 0x20, 0x06, 0x62,
+  0x20, 0x06, 0x62, 0x20, 0x06, 0x68, 0x80, 0x06, 0x68, 0x80, 0x06, 0x68,
+  0x80, 0x06, 0x6e, 0xe0, 0x06, 0x16, 0x1d, 0xe8, 0x81, 0x65, 0x59, 0x7a,
+  0xc0, 0x99, 0x02, 0x2b, 0xb0, 0x02, 0xdd, 0xf8, 0x05, 0x4a, 0xf8, 0x85,
+  0x3d, 0xd8, 0x83, 0x3a, 0xc0, 0x03, 0x1d, 0x70, 0x74, 0xe0, 0x06, 0xbc,
+  0x21, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed,
+  0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14,
+  0x81, 0x16, 0x6a, 0xe1, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2,
+  0x32, 0x37, 0xba, 0x51, 0x02, 0x5b, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5,
+  0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xe0, 0x16, 0x8e, 0x0a,
+  0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb,
+  0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xc0, 0x85, 0x9b,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe,
+  0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0x72, 0x41, 0x17,
+  0x76, 0xe1, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6,
+  0x32, 0x37, 0xba, 0x51, 0x82, 0x74, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80,
+  0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43,
+  0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4,
+  0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81,
+  0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01,
+  0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c,
+  0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c,
+  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1,
+  0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c,
+  0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90,
+  0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0xd9, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x45, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0x84, 0xd5, 0xc0, 0x08, 0x00, 0x95, 0x33, 0x00, 0x64, 0x8e, 0x00,
+  0x8c, 0x25, 0x04, 0x00, 0xad, 0x25, 0x50, 0x04, 0x65, 0x40, 0xef, 0x58,
+  0x03, 0x10, 0x08, 0x73, 0x0c, 0x50, 0x1c, 0xc4, 0xc1, 0x1c, 0x03, 0xe4,
+  0xc4, 0xc1, 0x58, 0x03, 0x30, 0x10, 0x04, 0x8c, 0x00, 0x8c, 0x11, 0x80,
+  0x20, 0x08, 0xe2, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x63,
+  0x04, 0x20, 0x08, 0x82, 0x24, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03, 0x30,
+  0x03, 0x30, 0x07, 0xc1, 0x07, 0x7b, 0xc0, 0x07, 0x7f, 0x40, 0xc2, 0x0c,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x34, 0x00, 0x00,
+  0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0xc8, 0x49, 0x00, 0x00, 0x00,
+  0x00, 0x63, 0x60, 0x61, 0x98, 0x05, 0x00, 0x00, 0x00, 0x61, 0x69, 0x72,
+  0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65,
+  0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x29, 0x61, 0x69, 0x72, 0x2d,
+  0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d,
+  0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c,
+  0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c,
+  0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x74, 0x65,
+  0x78, 0x74, 0x75, 0x72, 0x65, 0x73, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c,
+  0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72,
+  0x67, 0x28, 0x34, 0x29, 0x00, 0x2b, 0x84, 0x7a, 0x80, 0x87, 0x15, 0x83,
+  0x3d, 0xd4, 0x43, 0x3c, 0xac, 0x18, 0xee, 0xa1, 0x1e, 0xe4, 0x61, 0xc5,
+  0x80, 0x0f, 0xf5, 0x30, 0x0f, 0x2b, 0x86, 0x7c, 0xa8, 0x07, 0x7a, 0xd8,
+  0x10, 0xd8, 0xc3, 0x86, 0x21, 0x1f, 0xf0, 0xe1, 0x1e, 0x36, 0x08, 0xf8,
+  0x70, 0x0f, 0x1b, 0x04, 0x7b, 0xc8, 0x87, 0x0d, 0x41, 0x3e, 0x6c, 0x18,
+  0xec, 0x01, 0x1f, 0xee, 0x01, 0x7b, 0x18, 0x34, 0x33, 0xb0, 0x03, 0x0a,
+  0x80, 0x31, 0x1c, 0x11, 0x24, 0x81, 0x7f, 0xcc, 0x32, 0x04, 0x42, 0x30,
+  0x62, 0xd0, 0x18, 0x21, 0x08, 0x06, 0x67, 0xb0, 0x07, 0x5b, 0xe6, 0x61,
+  0xd5, 0xc5, 0x30, 0x77, 0x30, 0x9a, 0x10, 0x00, 0x23, 0x06, 0x8d, 0x11,
+  0x82, 0x60, 0x70, 0x06, 0x7d, 0xc0, 0x6d, 0x60, 0xa0, 0x5d, 0x99, 0xe3,
+  0xe4, 0xc1, 0x68, 0x42, 0x00, 0x0c, 0x32, 0x0c, 0xca, 0x34, 0xc8, 0x20,
+  0x30, 0xd3, 0x20, 0x83, 0x10, 0x4c, 0x37, 0x06, 0xf0, 0x52, 0x10, 0x94,
+  0x41, 0x86, 0x00, 0xca, 0x8c, 0x08, 0xc0, 0x7f, 0x23, 0xc3, 0x19, 0xd0,
+  0x01, 0x29, 0x5c, 0x00, 0x2f, 0x05, 0x41, 0x19, 0x64, 0x08, 0x2a, 0x6f,
+  0xc4, 0xe0, 0x38, 0x42, 0x10, 0x2c, 0xfc, 0x63, 0x83, 0x85, 0x22, 0x98,
+  0x63, 0xb0, 0x82, 0x3c, 0xd8, 0x48, 0xd1, 0x06, 0x7a, 0xa0, 0x0a, 0xa8,
+  0x40, 0x06, 0x17, 0xc0, 0x4b, 0x41, 0x50, 0x06, 0x19, 0x82, 0x8d, 0x0c,
+  0x46, 0x0c, 0x8e, 0x23, 0x04, 0xc1, 0xc2, 0x3f, 0x36, 0x5b, 0x58, 0x82,
+  0x39, 0x06, 0x23, 0x48, 0x83, 0x8d, 0x14, 0x73, 0x00, 0x0a, 0xb0, 0xe0,
+  0x0a, 0x69, 0x70, 0x01, 0xbc, 0x14, 0x04, 0x65, 0x90, 0x21, 0x08, 0x03,
+  0x35, 0x18, 0x31, 0x38, 0x8e, 0x10, 0x04, 0x0b, 0xff, 0xd8, 0x78, 0x21,
+  0x0a, 0xe6, 0x18, 0x8c, 0xc0, 0x0d, 0x66, 0x09, 0x88, 0xe1, 0x88, 0xcf,
+  0x0c, 0x02, 0xff, 0x98, 0x65, 0x18, 0x88, 0x60, 0xc4, 0xa0, 0x31, 0x42,
+  0x10, 0x0c, 0xce, 0x20, 0x17, 0xf2, 0xe0, 0x0e, 0xf8, 0xc0, 0x0e, 0xe6,
+  0xa0, 0x0e, 0xd4, 0x40, 0x0d, 0x6a, 0x61, 0x34, 0x21, 0x00, 0x46, 0x0c,
+  0x1a, 0x23, 0x04, 0xc1, 0xe0, 0x0c, 0x76, 0x41, 0x0f, 0xf2, 0xc0, 0x0f,
+  0xf0, 0xa0, 0x0e, 0xee, 0x80, 0x0d, 0xd8, 0xe0, 0x16, 0x46, 0x13, 0x02,
+  0x60, 0x90, 0x21, 0x48, 0x03, 0x3b, 0x18, 0x64, 0x20, 0xd2, 0x40, 0x0e,
+  0x06, 0x19, 0x04, 0x34, 0x90, 0x83, 0x41, 0x06, 0x21, 0x90, 0x83, 0x13,
+  0x05, 0x78, 0x29, 0x08, 0xca, 0x20, 0x43, 0xf0, 0x06, 0x78, 0x60, 0x44,
+  0x00, 0xfe, 0x1b, 0x19, 0x4c, 0x61, 0x16, 0xc6, 0xe1, 0x02, 0x78, 0x29,
+  0x08, 0xca, 0x20, 0x43, 0x40, 0x07, 0x7d, 0x30, 0x62, 0x70, 0x1c, 0x21,
+  0x08, 0x16, 0xfe, 0xb1, 0xbd, 0x43, 0x11, 0xcc, 0x31, 0xd4, 0x41, 0x80,
+  0x0b, 0x1b, 0x29, 0x58, 0x21, 0x17, 0xd2, 0xe1, 0x1c, 0x46, 0xe1, 0x02,
+  0x78, 0x29, 0x08, 0xca, 0x20, 0x43, 0xa0, 0x07, 0xa3, 0x30, 0x62, 0x70,
+  0x1c, 0x21, 0x08, 0x16, 0xfe, 0xb1, 0xd5, 0xc3, 0x12, 0xcc, 0x31, 0x18,
+  0x01, 0x2a, 0x6c, 0xa4, 0x90, 0x85, 0x5f, 0x78, 0x87, 0x76, 0x40, 0x85,
+  0x0b, 0xe0, 0xa5, 0x20, 0x28, 0x83, 0x0c, 0x01, 0x28, 0xa4, 0xc2, 0x88,
+  0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0xb6, 0x0f, 0x51, 0x30, 0xc7,
+  0x60, 0x04, 0xad, 0x30, 0x4b, 0x40, 0x0c, 0x74, 0x04, 0xa0, 0x10, 0x08,
+  0x83, 0x48, 0x08, 0x73, 0x0c, 0x01, 0x2a, 0xb8, 0xc2, 0x88, 0xc1, 0x81,
+  0xc4, 0x20, 0x58, 0xf8, 0x07, 0x44, 0x12, 0xc1, 0x2e, 0x58, 0xe0, 0x0b,
+  0xe2, 0x9f, 0x41, 0x40, 0x0c, 0x19, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20,
+  0x70, 0x87, 0x23, 0x1f, 0x10, 0x7d, 0xd8, 0x52, 0x10, 0xc7, 0x3e, 0x20,
+  0xfc, 0xb0, 0xa5, 0x30, 0x8e, 0x7d, 0x40, 0xf8, 0x61, 0x4b, 0xc1, 0x1c,
+  0xfd, 0x80, 0xf8, 0xc3, 0x96, 0x22, 0x3a, 0xfa, 0x01, 0xf1, 0x87, 0x2d,
+  0xc5, 0x75, 0xf4, 0x03, 0xe2, 0x0f, 0x5b, 0x8a, 0xee, 0xe8, 0x07, 0xc4,
+  0x1f, 0xb6, 0x14, 0x64, 0x70, 0xec, 0x03, 0xc2, 0x0f, 0x5b, 0x0a, 0x33,
+  0x38, 0xf6, 0x01, 0xe1, 0x87, 0x2d, 0x45, 0x1b, 0x1c, 0xfd, 0x80, 0xf8,
+  0xc3, 0x96, 0x42, 0x0e, 0x8e, 0x7e, 0x40, 0xfc, 0x61, 0x4b, 0x81, 0x07,
+  0x47, 0x3f, 0x20, 0xfe, 0xb0, 0xa5, 0xf0, 0x83, 0xa3, 0x1f, 0x10, 0x7f,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0xbe, 0x01, 0x00,
+  0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00, 0x00, 0x4f, 0x00, 0x00,
+  0x00, 0x54, 0xce, 0x00, 0xd0, 0x5a, 0x02, 0x45, 0x40, 0xef, 0x58, 0x03,
+  0x10, 0x08, 0x23, 0x00, 0x34, 0xcf, 0x41, 0x40, 0x4e, 0x93, 0x06, 0x63,
+  0x11, 0x40, 0x20, 0x1c, 0x04, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd,
+  0x18, 0x81, 0x2c, 0xba, 0x3d, 0x0d, 0x06, 0x63, 0x04, 0xb5, 0x5a, 0xab,
+  0xed, 0x37, 0x46, 0xd0, 0xc7, 0xa2, 0x8b, 0x7f, 0x63, 0x04, 0x6e, 0x1f,
+  0x8b, 0xb6, 0x2f, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81,
+  0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18,
+  0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf,
+  0x18, 0x81, 0xce, 0x9a, 0x73, 0x08, 0x06, 0x23, 0x00, 0x63, 0x04, 0x20,
+  0x08, 0x82, 0x24, 0x18, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30,
+  0x03, 0x40, 0xc1, 0x0c, 0xc0, 0x0c, 0xc0, 0x1c, 0x44, 0x1d, 0xec, 0x41,
+  0x1d, 0xf8, 0x01, 0x15, 0x33, 0x00, 0x23, 0x00, 0x33, 0x00, 0x63, 0x0d,
+  0x20, 0x08, 0x82, 0xf8, 0x07, 0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82,
+  0xf8, 0x37, 0xd6, 0xc0, 0xb6, 0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4,
+  0xc7, 0xb6, 0xf3, 0x4f, 0x7a, 0x63, 0x0d, 0x20, 0x08, 0xb2, 0xf5, 0x2f,
+  0x80, 0x20, 0xc8, 0xd6, 0xbf, 0x00, 0x82, 0x20, 0x5b, 0xff, 0xc2, 0x58,
+  0x03, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x80,
+  0x20, 0xb8, 0xe6, 0x60, 0x30, 0xd6, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01,
+  0x08, 0xd2, 0x6d, 0x0e, 0x06, 0x20, 0x48, 0xb7, 0x39, 0x18, 0x8c, 0x35,
+  0xac, 0x23, 0x1e, 0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x3a,
+  0xe2, 0x31, 0x0b, 0x06, 0x63, 0x0d, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80,
+  0x20, 0x8c, 0x87, 0x63, 0x00, 0x82, 0x30, 0x1e, 0x8e, 0xc1, 0x58, 0x83,
+  0x98, 0x8b, 0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab,
+  0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d,
+  0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7,
+  0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x0c, 0x00, 0x00,
+  0x00, 0x1b, 0x06, 0x77, 0x68, 0x87, 0x57, 0xd8, 0x30, 0xb8, 0x43, 0x3b,
+  0xd0, 0xc2, 0x86, 0xc1, 0x1d, 0xda, 0x21, 0x16, 0x36, 0x0c, 0xee, 0xd0,
+  0x0e, 0xb2, 0xb0, 0x61, 0x70, 0x87, 0x76, 0x98, 0x85, 0x0d, 0x83, 0x3b,
+  0xb4, 0x03, 0x2c, 0x6c, 0x18, 0xdc, 0xa1, 0x1d, 0x5a, 0x01, 0x00, 0x00,
+  0x00, 0x7b, 0x18, 0xce, 0x20, 0x0e, 0x44, 0x81, 0x02, 0x60, 0x0c, 0x47,
+  0x04, 0x55, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0xac, 0xc1,
+  0x64, 0x06, 0x7b, 0x18, 0xd6, 0xa0, 0x0e, 0xec, 0x80, 0x02, 0x60, 0x8c,
+  0x18, 0x18, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x84, 0xc1, 0x2a, 0x0c, 0x23,
+  0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x5f, 0x2b, 0x04, 0x90, 0x05,
+  0x10, 0xf8, 0x8f, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x7c, 0xad,
+  0x10, 0x54, 0x36, 0x44, 0xe2, 0x6f, 0x51, 0x10, 0xfe, 0x36, 0x04, 0xe4,
+  0x3f, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x11, 0x06, 0xb2, 0x10,
+  0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x7c, 0xb4, 0x10, 0x4c,
+  0x16, 0x4c, 0xe2, 0x3f, 0xc7, 0xd0, 0x2d, 0xa1, 0x30, 0xc8, 0x10, 0x78,
+  0x73, 0x60, 0x43, 0x40, 0xfe, 0x83, 0x0c, 0x01, 0x18, 0xd0, 0xc1, 0x20,
+  0x43, 0xc0, 0x07, 0x74, 0x30, 0x4b, 0x20, 0x0c, 0x54, 0x04, 0x42, 0xa0,
+  0x0f, 0xc0, 0x1e, 0x86, 0x3e, 0x38, 0x05, 0x5b, 0xa0, 0x00, 0x18, 0xc3,
+  0x11, 0x01, 0x1b, 0x38, 0xfe, 0x31, 0xcb, 0x30, 0x10, 0xc1, 0x20, 0x03,
+  0x91, 0x06, 0x7c, 0xb0, 0x87, 0x21, 0x14, 0x56, 0xc1, 0x15, 0x28, 0x00,
+  0xc6, 0x1e, 0x86, 0x51, 0x68, 0x85, 0x57, 0xa0, 0x00, 0x18, 0x23, 0x06,
+  0x4a, 0x12, 0x83, 0x60, 0xe1, 0x1f, 0x9d, 0x39, 0x14, 0xdd, 0x31, 0x04,
+  0x83, 0x0c, 0x01, 0x1b, 0x80, 0xc2, 0x20, 0x43, 0xb0, 0x80, 0xc2, 0x2c,
+  0x01, 0x31, 0x50, 0x11, 0x08, 0x03, 0x26, 0x0c, 0x47, 0x84, 0x01, 0x1f,
+  0x04, 0xfe, 0x31, 0xcb, 0x50, 0x4c, 0xc1, 0x1e, 0x06, 0x55, 0xa0, 0x05,
+  0x72, 0xa0, 0x00, 0x18, 0xc3, 0x11, 0xc1, 0x1f, 0x04, 0xfe, 0x31, 0xcb,
+  0x60, 0x1c, 0xc1, 0x20, 0x43, 0x61, 0x07, 0xa9, 0xb0, 0x87, 0xc1, 0x15,
+  0x70, 0xa1, 0x1c, 0x28, 0x00, 0xc6, 0x1c, 0x83, 0x1d, 0x04, 0xba, 0x30,
+  0xc8, 0x10, 0xdc, 0x01, 0x2b, 0x58, 0x50, 0x88, 0xff, 0x20, 0x43, 0x90,
+  0x07, 0xad, 0x30, 0x4b, 0xd0, 0x06, 0x7b, 0x18, 0x68, 0xc1, 0x17, 0xd8,
+  0x81, 0x02, 0x60, 0xec, 0x61, 0xb0, 0x05, 0x70, 0x68, 0x07, 0x0a, 0x80,
+  0x31, 0xc8, 0x00, 0x85, 0x82, 0x2c, 0x8c, 0x18, 0x14, 0x47, 0x08, 0x82,
+  0x41, 0xc6, 0x0f, 0xc4, 0x2c, 0x03, 0x22, 0x05, 0x63, 0x08, 0x12, 0x39,
+  0x0c, 0x47, 0x04, 0xad, 0xa0, 0xf8, 0xc7, 0x2c, 0x83, 0x92, 0x04, 0x26,
+  0xb4, 0x82, 0xf8, 0xcf, 0x12, 0x2c, 0x36, 0xb4, 0x02, 0xf8, 0x8f, 0x18,
+  0x18, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x58, 0x22, 0x11, 0x58, 0xe0, 0x0a,
+  0xe2, 0x3f, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0x95, 0x44,
+  0xe0, 0x0a, 0xb3, 0x04, 0xcb, 0x40, 0x05, 0xa0, 0x24, 0x82, 0x32, 0xc7,
+  0xa0, 0x0a, 0x01, 0x3b, 0x8c, 0x21, 0x6c, 0xe1, 0x30, 0x1c, 0x11, 0xd8,
+  0x82, 0xe2, 0x1f, 0xb3, 0x0c, 0x0d, 0x13, 0x98, 0x60, 0x0b, 0xe2, 0x3f,
+  0x4b, 0xe0, 0xd8, 0x60, 0x0b, 0xe0, 0x3f, 0x62, 0x60, 0x1c, 0x21, 0x08,
+  0x16, 0xfe, 0x61, 0xad, 0x44, 0x60, 0xc1, 0x2d, 0x88, 0xff, 0x88, 0xc1,
+  0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0xe5, 0x12, 0xc1, 0x2d, 0xcc, 0x12,
+  0x38, 0x03, 0x15, 0x80, 0xc2, 0x08, 0xcd, 0x1c, 0x43, 0x12, 0xa4, 0xc3,
+  0x18, 0x02, 0x19, 0xa4, 0xc3, 0x70, 0x44, 0xf0, 0x0b, 0x8a, 0x7f, 0xcc,
+  0x32, 0x40, 0x4f, 0x60, 0xc2, 0x2f, 0x88, 0xff, 0x2c, 0x41, 0x64, 0xc3,
+  0x2f, 0x80, 0xff, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x45,
+  0x13, 0x81, 0x05, 0xe0, 0x20, 0xfe, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60,
+  0xe1, 0x1f, 0xd4, 0x4d, 0x04, 0xe0, 0x30, 0x4b, 0x10, 0x0d, 0x54, 0x00,
+  0xca, 0x23, 0x40, 0x73, 0x0c, 0x49, 0x10, 0x0f, 0xb3, 0x04, 0xd2, 0x40,
+  0x45, 0x20, 0x44, 0x7a, 0x70, 0x0c, 0x32, 0x04, 0xbf, 0x20, 0x0f, 0x73,
+  0x0c, 0xbd, 0x00, 0x06, 0x21, 0x31, 0xc8, 0x10, 0xf8, 0xc2, 0x3c, 0xd8,
+  0x10, 0x88, 0xff, 0x20, 0x43, 0x00, 0x0e, 0xf4, 0x30, 0x4b, 0xd0, 0x06,
+  0xc3, 0x11, 0xb3, 0x60, 0x0e, 0x81, 0x7f, 0xcc, 0x32, 0x50, 0x60, 0x10,
+  0x0c, 0x32, 0xd0, 0x41, 0x39, 0xe0, 0xc3, 0x1e, 0x86, 0x7e, 0x38, 0x89,
+  0x9a, 0xa0, 0x00, 0x18, 0x7b, 0x18, 0xfe, 0x21, 0x25, 0x6c, 0x82, 0x02,
+  0x60, 0xcc, 0x31, 0x9c, 0x43, 0xb0, 0x12, 0x83, 0x0c, 0x01, 0x3a, 0xf4,
+  0x83, 0x05, 0x87, 0xf8, 0x0f, 0x32, 0x04, 0xea, 0xe0, 0x0f, 0x23, 0x06,
+  0xc5, 0x11, 0x82, 0x60, 0x90, 0xa1, 0xc5, 0x31, 0xcb, 0xf0, 0x55, 0xc1,
+  0x18, 0xc2, 0x00, 0x13, 0xc3, 0x11, 0xc1, 0x3f, 0x28, 0xfe, 0x31, 0xcb,
+  0x70, 0x59, 0x81, 0x09, 0xff, 0x20, 0xfe, 0xb3, 0x04, 0xd8, 0x88, 0x81,
+  0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0xd5, 0x16, 0xc3, 0x88, 0xc1, 0x71,
+  0x84, 0x20, 0x58, 0xf8, 0x07, 0xf5, 0x16, 0x01, 0x48, 0x58, 0x00, 0x12,
+  0xe2, 0x6f, 0x01, 0x48, 0x80, 0xff, 0x2c, 0x01, 0x36, 0x50, 0x01, 0x28,
+  0x96, 0x70, 0xcd, 0x31, 0xc8, 0x43, 0x80, 0x13, 0x63, 0x08, 0x4c, 0x4b,
+  0x0c, 0x47, 0x04, 0x28, 0xa1, 0xf8, 0xc7, 0x2c, 0x83, 0x96, 0x05, 0x26,
+  0xa0, 0x84, 0xf8, 0xcf, 0x12, 0x6c, 0x23, 0x06, 0xc6, 0x11, 0x82, 0x60,
+  0xe1, 0x1f, 0x96, 0x5d, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1,
+  0x1f, 0x14, 0x5e, 0x04, 0x29, 0x61, 0x41, 0x4a, 0x88, 0xbf, 0x05, 0x29,
+  0x01, 0xfe, 0xb3, 0x04, 0xdb, 0x40, 0x05, 0xa0, 0x64, 0x82, 0x36, 0xc7,
+  0x90, 0x04, 0x35, 0x31, 0x86, 0x50, 0xd5, 0xc4, 0x70, 0x44, 0x10, 0x13,
+  0x8a, 0x7f, 0xcc, 0x32, 0x74, 0x5c, 0x60, 0x42, 0x4c, 0x88, 0xff, 0x2c,
+  0x81, 0x37, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0xfd, 0xc5,
+  0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0x85, 0x46, 0x20,
+  0x13, 0x16, 0xc8, 0x84, 0xf8, 0x5b, 0x20, 0x13, 0xe0, 0x3f, 0x4b, 0xe0,
+  0x0d, 0x54, 0x00, 0x0a, 0x27, 0x74, 0x73, 0x0c, 0x49, 0xd0, 0x13, 0x23,
+  0x06, 0xc8, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0xd2, 0x69, 0x04, 0x26, 0x41,
+  0x12, 0x83, 0x0c, 0x01, 0x4a, 0xf0, 0xc4, 0x2c, 0xc1, 0x37, 0x50, 0x11,
+  0xf8, 0x01, 0x25, 0x78, 0x83, 0x0c, 0x41, 0x4b, 0xf8, 0xc4, 0x2c, 0x41,
+  0x1b, 0xcc, 0x32, 0x84, 0x41, 0x1b, 0xf0, 0xc3, 0x20, 0x43, 0x2f, 0xb8,
+  0x44, 0x58, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x6c, 0xa8,
+  0x11, 0x88, 0xc4, 0x1c, 0xc3, 0x4a, 0x04, 0x71, 0x31, 0x62, 0x70, 0x1c,
+  0x21, 0x08, 0x16, 0xfe, 0xb1, 0xa9, 0xc6, 0x30, 0x12, 0x73, 0x0c, 0x42,
+  0x70, 0x16, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x1b, 0x6b,
+  0x14, 0x24, 0x31, 0xc7, 0x20, 0x04, 0x68, 0x31, 0xc8, 0x10, 0xc8, 0x84,
+  0x59, 0x0c, 0x32, 0x04, 0xe5, 0x60, 0x16, 0x7b, 0x18, 0xdc, 0x02, 0x2f,
+  0x4c, 0x83, 0x02, 0x60, 0xec, 0x61, 0x80, 0x0b, 0xbd, 0x38, 0x0d, 0x0a,
+  0x80, 0x31, 0xc7, 0x80, 0x13, 0x01, 0x5f, 0x0c, 0x32, 0x04, 0x39, 0xe1,
+  0x16, 0x16, 0x24, 0xe2, 0x3f, 0xc8, 0x10, 0xec, 0xc4, 0x5b, 0x8c, 0x18,
+  0x14, 0x47, 0x08, 0x82, 0x41, 0x96, 0x1b, 0xc7, 0x2c, 0x03, 0x1b, 0x88,
+  0x41, 0x30, 0x86, 0x30, 0x84, 0xc6, 0x70, 0x44, 0x00, 0x17, 0x8a, 0x7f,
+  0xcc, 0x32, 0x90, 0xc1, 0x18, 0x04, 0x26, 0xc0, 0x85, 0xf8, 0xcf, 0x12,
+  0x94, 0xc1, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0xe5, 0x1b,
+  0xc3, 0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0x05, 0x1e, 0x41,
+  0x5c, 0x58, 0x10, 0x17, 0xe2, 0x6f, 0x41, 0x5c, 0x80, 0xff, 0x2c, 0x41,
+  0x19, 0x0c, 0x54, 0x00, 0xca, 0x18, 0x08, 0x64, 0x30, 0xc7, 0x30, 0x16,
+  0x41, 0x6a, 0x8c, 0x21, 0x30, 0x7e, 0x31, 0x1c, 0x11, 0xe4, 0x85, 0xe2,
+  0x1f, 0xb3, 0x0c, 0x67, 0x60, 0x06, 0x81, 0x09, 0x79, 0x21, 0xfe, 0xb3,
+  0x04, 0x68, 0x30, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0x9d,
+  0xc7, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xa5, 0x47,
+  0xa0, 0x17, 0x16, 0xe8, 0x85, 0xf8, 0x5b, 0xa0, 0x17, 0xe0, 0x3f, 0x4b,
+  0x80, 0x06, 0x03, 0x15, 0x80, 0x62, 0x06, 0xc2, 0x19, 0xcc, 0x31, 0x24,
+  0x81, 0x69, 0x8c, 0x21, 0x54, 0xa6, 0x31, 0x1c, 0x11, 0x88, 0x86, 0xe2,
+  0x1f, 0xb3, 0x0c, 0x6a, 0x90, 0x06, 0x81, 0x09, 0xa2, 0x21, 0xfe, 0xb3,
+  0x04, 0x6b, 0x30, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0xc1,
+  0xc7, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xc9, 0x47,
+  0x30, 0x1a, 0x16, 0x8c, 0x86, 0xf8, 0x5b, 0x30, 0x1a, 0xe0, 0x3f, 0x4b,
+  0xb0, 0x06, 0x03, 0x15, 0x80, 0x92, 0x06, 0x82, 0x1a, 0xcc, 0x31, 0x24,
+  0x81, 0x6b, 0x8c, 0x18, 0x20, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x48, 0xf8,
+  0x11, 0xdc, 0x45, 0x5d, 0x0c, 0x32, 0x04, 0x79, 0xd1, 0x1a, 0xb3, 0x04,
+  0x6c, 0x30, 0x50, 0x11, 0xf8, 0x41, 0x18, 0x08, 0x6b, 0x30, 0xc8, 0x10,
+  0xf8, 0xc5, 0x6b, 0xcc, 0x12, 0xb4, 0xc1, 0x40, 0x4b, 0xc0, 0x23, 0x06,
+  0x8f, 0x48, 0x3c, 0xf2, 0xc9, 0x02, 0x1b, 0xf0, 0x08, 0x18, 0x0c, 0xb4,
+  0x04, 0x28, 0x62, 0xe8, 0x85, 0x64, 0x0e, 0x1f, 0xc1, 0x06, 0xfc, 0x02,
+  0x06, 0x83, 0x0c, 0x81, 0x10, 0x1b, 0x19, 0x04, 0xc4, 0x00, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x78, 0x87, 0x2d, 0x83,
+  0x11, 0xc0, 0xc3, 0x96, 0x21, 0x0b, 0xe2, 0x61, 0xcb, 0xe0, 0x05, 0xf2,
+  0xb0, 0x65, 0x00, 0x83, 0x60, 0x1e, 0xb6, 0x0c, 0x69, 0x10, 0xb8, 0xc3,
+  0x96, 0xc1, 0x0d, 0x02, 0x7a, 0xd8, 0x32, 0xd4, 0x41, 0x50, 0x0f, 0x5b,
+  0x86, 0x3b, 0x08, 0xe8, 0x61, 0xcb, 0xb0, 0x0e, 0x41, 0x3d, 0x6c, 0x19,
+  0xda, 0x21, 0xa0, 0x87, 0x2d, 0x43, 0x5a, 0x04, 0xf5, 0xb0, 0x65, 0x58,
+  0x8b, 0x80, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x73, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x54, 0xce, 0x00, 0xd0, 0x5a, 0x02, 0x45,
+  0x40, 0xef, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00, 0x34, 0xcf, 0x41, 0x40,
+  0x4e, 0xc3, 0x06, 0x04, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18,
+  0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x23, 0x00, 0x14, 0xcc, 0x00, 0xcc,
+  0x00, 0x50, 0x31, 0x03, 0x30, 0xd6, 0xc0, 0xb2, 0x67, 0x28, 0x7f, 0xa8,
+  0x5f, 0xc6, 0xea, 0x97, 0x9f, 0xba, 0x38, 0x7b, 0x63, 0x0d, 0x7a, 0x0d,
+  0xee, 0xb8, 0xa7, 0xe2, 0xb9, 0x6d, 0x7f, 0x6f, 0x9f, 0xd2, 0xa3, 0x37,
+  0xd6, 0xb0, 0xce, 0x31, 0x8b, 0x7a, 0x69, 0x08, 0xa3, 0xbb, 0x77, 0xb7,
+  0xb1, 0x6a, 0x7f, 0x63, 0x0d, 0x62, 0x2e, 0xa6, 0xfd, 0x07, 0x96, 0x3c,
+  0x1b, 0xff, 0xc2, 0x98, 0xae, 0x6a, 0xee, 0x0b, 0x63, 0x0d, 0xff, 0x4c,
+  0xfa, 0xbf, 0x2f, 0xd0, 0x35, 0x28, 0xe6, 0x5f, 0x0b, 0xc7, 0x31, 0xe8,
+  0x0b, 0x63, 0x0d, 0x73, 0xdf, 0xa6, 0xa9, 0x2f, 0xb4, 0x6e, 0xc8, 0xf3,
+  0xbe, 0xc0, 0xe7, 0xac, 0x8f, 0x7f, 0x00, 0x00, 0x00, 0x83, 0x0c, 0xd7,
+  0xd1, 0x0c, 0x47, 0x58, 0x4d, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0xcc,
+  0x31, 0x24, 0x96, 0x18, 0x0c, 0x32, 0x04, 0x4a, 0x64, 0xc1, 0x26, 0xfe,
+  0x83, 0x0c, 0x01, 0x23, 0xcd, 0x12, 0x24, 0xc3, 0x11, 0x5b, 0x14, 0xf8,
+  0xc7, 0x2c, 0xc3, 0x90, 0x04, 0xc3, 0x11, 0x9d, 0x14, 0xf8, 0xc7, 0x2c,
+  0x03, 0x51, 0x04, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x1b,
+  0x28, 0x7c, 0xce, 0x1c, 0x43, 0x14, 0xa4, 0xc1, 0x88, 0xc1, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0xc7, 0x26, 0x0a, 0x61, 0xf0, 0xcc, 0x31, 0x08, 0x01,
+  0x37, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0xb1, 0x91, 0xc2, 0x18,
+  0x40, 0x73, 0x0c, 0x42, 0xd0, 0xcd, 0x12, 0x14, 0x03, 0x15, 0x81, 0x40,
+  0x70, 0xc3, 0x18, 0x42, 0xf0, 0x06, 0x63, 0x08, 0x42, 0x18, 0x8c, 0x21,
+  0x0c, 0x61, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xa1,
+  0x82, 0x10, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x50, 0xa9,
+  0x40, 0x04, 0xc3, 0x11, 0x81, 0x27, 0xf8, 0xc7, 0x2c, 0x83, 0x71, 0x04,
+  0x83, 0x0c, 0x87, 0x47, 0x06, 0x36, 0xa8, 0x81, 0xf8, 0x5b, 0x30, 0x06,
+  0xe0, 0x6f, 0xc5, 0x1a, 0x88, 0xbf, 0x05, 0x65, 0x00, 0xfe, 0x36, 0x04,
+  0xe4, 0x3f, 0xc7, 0x20, 0x06, 0xc1, 0x1e, 0x0c, 0x32, 0x04, 0x63, 0xa0,
+  0x06, 0x16, 0x20, 0xe2, 0x3f, 0xc8, 0x10, 0x94, 0xc1, 0x1a, 0xcc, 0x12,
+  0x1c, 0x03, 0x15, 0x81, 0x60, 0x88, 0x41, 0x31, 0xcb, 0x80, 0x24, 0xd9,
+  0x20, 0x43, 0x90, 0x06, 0x6f, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16,
+  0xfe, 0xb1, 0xe5, 0x42, 0x40, 0x06, 0x73, 0x0c, 0x6a, 0x10, 0x88, 0xc2,
+  0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0xb6, 0x0b, 0x43, 0x19,
+  0xcc, 0x31, 0x08, 0x41, 0x1d, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85,
+  0x7f, 0x6c, 0xbd, 0x50, 0x98, 0xc1, 0x1c, 0x83, 0x10, 0xd8, 0xc1, 0x2c,
+  0x41, 0x32, 0x50, 0x12, 0x90, 0x42, 0xe0, 0x0a, 0x82, 0x80, 0x40, 0xc7,
+  0x20, 0x43, 0x10, 0x07, 0x77, 0x90, 0x01, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xd2,
+  0x09, 0x18, 0xd0, 0xba, 0x80, 0x07, 0xed, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x65, 0x0c, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94,
+  0x30, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00,
+  0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x27, 0x01, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x46, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x38, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x00, 0x00, 0x49, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x5d, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x6d, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x7e, 0x00, 0x00,
+  0x00, 0x16, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x94, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xa1, 0x00, 0x00,
+  0x00, 0x19, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x00, 0x00, 0xba, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xcb, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xdd, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xf0, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x03, 0x01, 0x00,
+  0x00, 0x1b, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x5d, 0x0c, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94,
+  0xa6, 0x02, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x31,
+  0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x5a,
+  0x31, 0x34, 0x47, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x43,
+  0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x52, 0x55, 0x31,
+  0x31, 0x4d, 0x54, 0x4c, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,
+  0x4b, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x2e, 0x76, 0x33, 0x66,
+  0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70,
+  0x6f, 0x77, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e, 0x66, 0x33, 0x32, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x2e, 0x75,
+  0x2e, 0x69, 0x31, 0x2e, 0x66, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x5f, 0x5a,
+  0x31, 0x32, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x54, 0x6f, 0x6e, 0x65, 0x6d,
+  0x61, 0x70, 0x44, 0x76, 0x33, 0x5f, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61,
+  0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78,
+  0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e,
+  0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34,
+  0x66, 0x33, 0x32, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34,
+  0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d,
+  0x69, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69,
+  0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+const unsigned int sdl_metallib_len = 37821;
diff --git a/SDL-3.2.8/src/render/metal/SDL_shaders_metal_macos.h b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_macos.h
new file mode 100644
index 0000000..e3c4230
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_macos.h
@@ -0,0 +1,2532 @@
+const unsigned char sdl_metallib[] = {
+  0x4d, 0x54, 0x4c, 0x42, 0x01, 0x80, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x85, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xe5, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x72, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
+  0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
+  0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
+  0x50, 0x0f, 0x81, 0xd3, 0x48, 0x9a, 0xd9, 0x04, 0x20, 0xa9, 0x3e, 0x02,
+  0x8a, 0x68, 0xb0, 0x30, 0x34, 0x06, 0x99, 0x69, 0x0c, 0x03, 0x74, 0x35,
+  0xb5, 0x66, 0x90, 0x7b, 0x6c, 0x3a, 0x14, 0x62, 0x4f, 0x46, 0x46, 0x54,
+  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, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00,
+  0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x77, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
+  0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54, 0x59,
+  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0xf0,
+  0x2e, 0x14, 0xc5, 0xee, 0x9f, 0xd5, 0xcc, 0x21, 0x55, 0xa5, 0x5b, 0xe0,
+  0x3c, 0xdf, 0x01, 0x52, 0xa7, 0x30, 0x4a, 0x99, 0xd1, 0xa8, 0x5f, 0x13,
+  0xe2, 0xf0, 0x62, 0x6a, 0x80, 0x37, 0xb7, 0x4f, 0x46, 0x46, 0x54, 0x18,
+  0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
+  0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x7a, 0x00, 0x00, 0x00, 0x4e,
+  0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
+  0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x74, 0x71, 0x0b, 0x57, 0x4b, 0xa1, 0xa5, 0xee, 0x31, 0x5f, 0xf7,
+  0x98, 0x90, 0x9f, 0xc4, 0x0b, 0x72, 0x5f, 0x4b, 0xd5, 0x4b, 0xce, 0x85,
+  0x2b, 0x45, 0x6c, 0x7e, 0xdd, 0xa5, 0x54, 0x8e, 0xb0, 0x4f, 0x46, 0x46,
+  0x54, 0x18, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08,
+  0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00, 0x00,
+  0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43,
+  0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
+  0x20, 0x00, 0x83, 0x74, 0xe0, 0x68, 0x12, 0xd5, 0x8c, 0xd4, 0x71, 0xdb,
+  0xb9, 0x4c, 0x41, 0x85, 0x0e, 0x4d, 0x36, 0xf9, 0x66, 0x8d, 0x70, 0x81,
+  0x5b, 0xbb, 0xe9, 0x81, 0x42, 0xc5, 0x56, 0x6f, 0x27, 0xa3, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x23, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
+  0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x78, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
+  0x20, 0x00, 0x3a, 0x25, 0xd4, 0xcc, 0x66, 0x7c, 0x15, 0x7f, 0xc4, 0x37,
+  0x91, 0x2a, 0xc4, 0x81, 0x61, 0xee, 0xdc, 0xcf, 0xd6, 0x25, 0x51, 0xcf,
+  0x14, 0x26, 0xf5, 0xe3, 0xb9, 0xd9, 0x21, 0x42, 0x05, 0x8e, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x3c, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
+  0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53,
+  0x48, 0x20, 0x00, 0x22, 0x61, 0x99, 0x75, 0x7e, 0x79, 0xc7, 0x29, 0xce,
+  0x24, 0x1e, 0x6f, 0x01, 0x62, 0x29, 0x3a, 0x12, 0xe8, 0xf8, 0xd8, 0xa5,
+  0xf2, 0x5e, 0x21, 0xb5, 0x28, 0x04, 0xc8, 0xf3, 0x8d, 0x60, 0xfb, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x57, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01,
+  0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x29,
+  0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x15, 0x00, 0x02, 0x00, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00,
+  0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44, 0x54, 0x35, 0x00, 0x00, 0x00,
+  0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03, 0x00, 0x70, 0x6f, 0x73, 0x69,
+  0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
+  0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00,
+  0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05, 0x00, 0x03, 0x00, 0x04, 0x06,
+  0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xe8, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0xf7, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0x6a, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c,
+  0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c, 0x00, 0x06, 0x77, 0x78,
+  0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76, 0xa0, 0x87, 0x74, 0x70,
+  0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08,
+  0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d,
+  0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d,
+  0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1, 0x1d, 0xda, 0x80, 0x1d,
+  0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79, 0x48, 0x87, 0x73, 0x70,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72, 0x90, 0x87, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01, 0x1e, 0xd2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90,
+  0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a, 0x08, 0x87, 0x71, 0x58,
+  0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a, 0x28, 0x87, 0x71, 0xa0,
+  0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d, 0x28, 0x07, 0x00, 0x0f,
+  0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1, 0x1c, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x18, 0xc2, 0x00, 0x2c, 0x40,
+  0xb5, 0xc1, 0x18, 0x08, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0,
+  0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88,
+  0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6,
+  0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00,
+  0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87,
+  0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83,
+  0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x41, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02, 0x50, 0x80, 0x01, 0x45,
+  0x50, 0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6, 0x58,
+  0xc2, 0x23, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xe4, 0x00, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42, 0x24, 0xc0, 0xa2, 0x50,
+  0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62,
+  0x28, 0x41, 0x22, 0x28, 0x07, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c,
+  0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06,
+  0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43,
+  0x0c, 0x25, 0x50, 0x10, 0x45, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x64, 0x61,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89,
+  0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a, 0x9c, 0x0b, 0xdc,
+  0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0, 0x34, 0x39, 0x97,
+  0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
+  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd,
+  0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92,
+  0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c,
+  0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xad, 0xb3,
+  0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94, 0x9a, 0xb1, 0x37,
+  0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14, 0x16, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04, 0x4a, 0xa2, 0x44,
+  0x4a, 0x2e, 0x3a, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x69, 0x6e, 0x74,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x2c, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0x98,
+  0xc0, 0xbd, 0xa5, 0xb9, 0xd1, 0x4d, 0xa5, 0xe9, 0x95, 0x0d, 0x51, 0x92,
+  0x2c, 0x81, 0x12, 0x2d, 0x91, 0x92, 0x6d, 0x88, 0x91, 0x50, 0x09, 0x96,
+  0x70, 0x84, 0xc2, 0xd2, 0xe4, 0x5c, 0xec, 0xca, 0xe4, 0xe8, 0xca, 0xf0,
+  0xbe, 0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0,
+  0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95,
+  0xe1, 0xd1, 0x3b, 0x2b, 0x73, 0x2b, 0x93, 0x0b, 0xa3, 0x2b, 0x23, 0x43,
+  0xf9, 0xfa, 0x0a, 0x4b, 0x93, 0xfb, 0x82, 0x63, 0x0b, 0x1b, 0x2b, 0x43,
+  0x7b, 0x63, 0x23, 0x2b, 0x93, 0xfb, 0xfa, 0x4a, 0xa1, 0x61, 0xc6, 0xf6,
+  0x16, 0x46, 0x27, 0x33, 0x84, 0x52, 0x84, 0xc4, 0x4b, 0x3e, 0x45, 0x50,
+  0x82, 0x04, 0x0c, 0x12, 0x28, 0x09, 0x83, 0x44, 0x4a, 0xa6, 0x21, 0x94,
+  0x12, 0x24, 0x5e, 0xf2, 0x29, 0x81, 0x12, 0x24, 0x60, 0x90, 0x40, 0x49,
+  0x94, 0x48, 0xc9, 0x45, 0x25, 0x2c, 0x4d, 0xce, 0x45, 0xac, 0xce, 0xcc,
+  0xac, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99, 0x59,
+  0x99, 0xdc, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x91, 0xb0, 0x34, 0x39, 0x17,
+  0xb9, 0xb2, 0x30, 0x32, 0x46, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0xbc, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe,
+  0xc2, 0xd8, 0xd2, 0xce, 0xdc, 0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x88, 0x98,
+  0xb1, 0xbd, 0x85, 0xd1, 0xd1, 0xe0, 0xd1, 0x50, 0x81, 0x93, 0x7b, 0x53,
+  0x2b, 0x1b, 0xa3, 0x4b, 0x7b, 0x73, 0x1b, 0x02, 0x06, 0x0a, 0x91, 0x90,
+  0x41, 0x52, 0x06, 0xca, 0x90, 0x7c, 0x0a, 0xa1, 0x04, 0x89, 0x19, 0x24,
+  0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28, 0x45, 0x02, 0x25, 0x69, 0x90, 0x48,
+  0x89, 0x1a, 0x30, 0xa1, 0x93, 0x0b, 0x73, 0x9b, 0x33, 0x7b, 0x93, 0x6b,
+  0x1b, 0x02, 0x06, 0x8a, 0x91, 0x90, 0x41, 0x52, 0x06, 0xca, 0x90, 0x7c,
+  0x8a, 0xa1, 0x04, 0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28,
+  0x45, 0x02, 0x25, 0x69, 0x90, 0x48, 0x09, 0x1b, 0x0c, 0x41, 0x12, 0x31,
+  0x48, 0xc6, 0x20, 0x59, 0x83, 0xa4, 0x0d, 0x86, 0x18, 0x08, 0x90, 0x74,
+  0x89, 0x1b, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83, 0x7b, 0xa3, 0x2b, 0x73,
+  0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33, 0x95, 0xd6, 0x06, 0xc7,
+  0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25, 0x14, 0x14, 0x34, 0x44,
+  0x48, 0xe2, 0x60, 0x88, 0x91, 0xc0, 0x41, 0x22, 0x07, 0x4c, 0x32, 0xc4,
+  0x48, 0xe6, 0x20, 0x99, 0x03, 0x26, 0x19, 0x11, 0xb1, 0x03, 0x3b, 0xd8,
+  0x43, 0x3b, 0xb8, 0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94,
+  0x83, 0x1b, 0x98, 0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21,
+  0x18, 0x46, 0x28, 0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e,
+  0xe4, 0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e,
+  0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e,
+  0xef, 0xe0, 0x0e, 0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f,
+  0x6e, 0xc0, 0x0e, 0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e,
+  0xe5, 0xf0, 0x0b, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e,
+  0xee, 0x30, 0x25, 0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06,
+  0xe3, 0xf0, 0x0e, 0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b,
+  0xef, 0x00, 0x0f, 0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65,
+  0x50, 0x18, 0x67, 0x84, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf4, 0x50, 0x0e, 0xf8, 0x30, 0x25, 0x78, 0x03, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce,
+  0x82, 0x0c, 0x7f, 0x45, 0x44, 0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x54, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x0b, 0x00, 0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6,
+  0x22, 0x04, 0x41, 0x10, 0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88,
+  0x15, 0x41, 0x09, 0x94, 0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14,
+  0x66, 0x00, 0x66, 0x00, 0x08, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f,
+  0x00, 0xe3, 0x11, 0x8d, 0x94, 0x49, 0x14, 0x94, 0xf1, 0x08, 0x88, 0xda,
+  0x28, 0x0a, 0xca, 0x20, 0xc3, 0x70, 0x34, 0x26, 0x04, 0xf2, 0x19, 0x8f,
+  0xa0, 0xb0, 0xaf, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x8a, 0x64, 0x42, 0x20,
+  0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x64, 0x1d, 0x19, 0x4c, 0x14, 0x94,
+  0x41, 0x06, 0xe6, 0xc1, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1,
+  0x08, 0x4f, 0x0c, 0xd2, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x94, 0x67,
+  0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x88, 0xc1, 0x19, 0xb8,
+  0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0x34, 0x30, 0xb0, 0xa0, 0x92, 0xcf,
+  0x20, 0xc3, 0xb0, 0x8d, 0x81, 0x05, 0x93, 0x7c, 0x6c, 0x08, 0xe0, 0x33,
+  0xc8, 0x60, 0x78, 0x67, 0x60, 0x41, 0x24, 0x1f, 0x1b, 0x02, 0xf8, 0x0c,
+  0x32, 0x24, 0x61, 0xb0, 0x06, 0x16, 0x3c, 0xf2, 0xb1, 0x21, 0x80, 0xcf,
+  0x78, 0xc4, 0x1b, 0xd0, 0xc1, 0x1e, 0xa0, 0x01, 0x05, 0x65, 0x90, 0x21,
+  0x38, 0x83, 0x36, 0xb0, 0x40, 0x0c, 0xe4, 0x33, 0xc8, 0x30, 0xa0, 0x01,
+  0x1c, 0x58, 0x00, 0x06, 0xf2, 0x19, 0x64, 0x28, 0xd4, 0x60, 0x0e, 0x2c,
+  0xe8, 0xe4, 0x33, 0xc8, 0x70, 0xb0, 0x81, 0x1d, 0x58, 0xa0, 0xc9, 0x67,
+  0x90, 0x81, 0x0f, 0xe2, 0xa0, 0x0e, 0x2c, 0x0b, 0xe4, 0x33, 0xc8, 0xe0,
+  0x07, 0x73, 0x80, 0x07, 0xe6, 0x04, 0xf2, 0xb1, 0x64, 0x80, 0x8f, 0x05,
+  0x0c, 0x7c, 0x2c, 0x48, 0xe0, 0x63, 0x01, 0x02, 0x1f, 0x0b, 0x0a, 0xf8,
+  0xcc, 0x36, 0xe4, 0x41, 0x00, 0xcc, 0x36, 0x04, 0xa5, 0x10, 0xcc, 0x36,
+  0x04, 0x78, 0x20, 0x64, 0x10, 0x10, 0x03, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0x5b, 0x86, 0x20, 0xa0, 0x83, 0x2d, 0xc3, 0x10, 0xd0, 0xc1, 0x96,
+  0xe1, 0x08, 0xe8, 0x60, 0xcb, 0xc0, 0x04, 0x74, 0xb0, 0x65, 0x88, 0x02,
+  0x3a, 0xd8, 0x32, 0x58, 0x01, 0x1d, 0x6c, 0x19, 0xc6, 0x20, 0xa0, 0x03,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xf8, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0xfb, 0x02, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0x6a, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c,
+  0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c, 0x00, 0x06, 0x77, 0x78,
+  0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76, 0xa0, 0x87, 0x74, 0x70,
+  0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08,
+  0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d,
+  0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d,
+  0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1, 0x1d, 0xda, 0x80, 0x1d,
+  0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79, 0x48, 0x87, 0x73, 0x70,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72, 0x90, 0x87, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01, 0x1e, 0xd2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90,
+  0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a, 0x08, 0x87, 0x71, 0x58,
+  0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a, 0x28, 0x87, 0x71, 0xa0,
+  0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d, 0x28, 0x07, 0x00, 0x0f,
+  0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1, 0x1c, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x18, 0x02, 0x01, 0x2c, 0x40,
+  0xb5, 0xc1, 0x18, 0x0a, 0x60, 0x01, 0x2a, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c,
+  0x11, 0x84, 0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00,
+  0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87,
+  0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83,
+  0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x41, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x50, 0x04, 0x23, 0x00, 0x05, 0x18,
+  0x50, 0x08, 0x65, 0x50, 0x20, 0x05, 0x41, 0x6c, 0x04, 0x80, 0xd6, 0x58,
+  0xc2, 0x23, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xea, 0x00, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x22, 0x24, 0xc0, 0xa2, 0x50,
+  0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62,
+  0x28, 0x41, 0x22, 0x28, 0x05, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c,
+  0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06,
+  0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x90, 0x10, 0x43,
+  0x0c, 0x25, 0x50, 0x10, 0x65, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x65, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x64, 0x61,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89,
+  0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a, 0x9c, 0x0b, 0xdc,
+  0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0, 0x34, 0x39, 0x97,
+  0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f, 0xb7, 0xb0, 0xb6,
+  0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca, 0x88, 0xc0, 0xbd,
+  0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92, 0x27, 0x81, 0x92,
+  0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5d, 0x99, 0x1c,
+  0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0xad, 0xb3,
+  0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94, 0x9a, 0xb1, 0x37,
+  0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14, 0x16, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04, 0x4a, 0xa2, 0x44,
+  0x4a, 0x2e, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76,
+  0x32, 0x5f, 0x66, 0x29, 0x34, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0x64, 0x88,
+  0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x0d, 0x61, 0x92, 0x2a,
+  0xc9, 0x12, 0x28, 0xd1, 0x12, 0x29, 0xd9, 0x86, 0x18, 0x09, 0x95, 0x60,
+  0x09, 0x47, 0x28, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c,
+  0xef, 0x2b, 0xcd, 0x0d, 0xae, 0x8e, 0x8e, 0x52, 0x58, 0x9a, 0x9c, 0x0b,
+  0xdb, 0xdb, 0x58, 0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57, 0x9a, 0x1b, 0x59,
+  0x19, 0x1e, 0xbd, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32,
+  0x94, 0xaf, 0xaf, 0xb0, 0x34, 0xb9, 0x2f, 0x38, 0xb6, 0xb0, 0xb1, 0x32,
+  0xb4, 0x37, 0x36, 0xb2, 0x32, 0xb9, 0xaf, 0xaf, 0x94, 0x21, 0x94, 0x32,
+  0x24, 0x5e, 0xf2, 0x29, 0x83, 0x12, 0x24, 0x60, 0x90, 0x40, 0x89, 0x96,
+  0x48, 0xc9, 0x34, 0x84, 0x52, 0x82, 0xc4, 0x4b, 0x3e, 0x25, 0x50, 0x82,
+  0x04, 0x0c, 0x12, 0x28, 0x89, 0x12, 0x29, 0xb9, 0x86, 0x50, 0x8a, 0x90,
+  0x78, 0xc9, 0xa7, 0x08, 0x4a, 0x90, 0x80, 0x41, 0x02, 0x25, 0x5a, 0x22,
+  0x25, 0x1b, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3, 0x32,
+  0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x44, 0xc2, 0xd2, 0xe4, 0x5c, 0xe4, 0xca,
+  0xc2, 0xc8, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d, 0x7d, 0xd1,
+  0xe5, 0xc1, 0x95, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1, 0x0a, 0x4b, 0x93,
+  0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x0a, 0x63,
+  0x4b, 0x3b, 0x73, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x23, 0x62, 0xc6, 0xf6,
+  0x16, 0x46, 0x47, 0x83, 0x47, 0x43, 0x05, 0x4e, 0xee, 0x4d, 0xad, 0x6c,
+  0x8c, 0x2e, 0xed, 0xcd, 0x6d, 0x08, 0x18, 0x28, 0x46, 0x42, 0x06, 0x49,
+  0x19, 0x28, 0x44, 0xf2, 0x29, 0x82, 0x12, 0x24, 0x66, 0x90, 0x9c, 0x81,
+  0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41, 0x22, 0x25, 0x6a,
+  0xc0, 0x84, 0x4e, 0x2e, 0xcc, 0x6d, 0xce, 0xec, 0x4d, 0xae, 0x6d, 0x08,
+  0x18, 0x28, 0x45, 0x42, 0x06, 0x49, 0x19, 0x28, 0x44, 0xf2, 0x29, 0x86,
+  0x12, 0x24, 0x66, 0x90, 0x9c, 0x81, 0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09,
+  0x94, 0xa4, 0x41, 0x22, 0x25, 0x6c, 0x30, 0x44, 0x49, 0xc2, 0x20, 0x11,
+  0x83, 0x64, 0x0c, 0x92, 0x35, 0x48, 0xda, 0x60, 0x88, 0x81, 0x00, 0x49,
+  0x97, 0xb8, 0x01, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32,
+  0x37, 0x3a, 0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70,
+  0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43,
+  0x84, 0x24, 0x0e, 0x86, 0x18, 0x09, 0x1c, 0x24, 0x72, 0xc0, 0x24, 0x43,
+  0x8c, 0x64, 0x0e, 0x92, 0x39, 0x60, 0x92, 0x11, 0x11, 0x3b, 0xb0, 0x83,
+  0x3d, 0xb4, 0x83, 0x1b, 0xb4, 0xc3, 0x3b, 0x90, 0x43, 0x3d, 0xb0, 0x43,
+  0x39, 0xb8, 0x81, 0x39, 0xb0, 0x43, 0x38, 0x9c, 0xc3, 0x3c, 0x4c, 0x11,
+  0x82, 0x61, 0x84, 0xc2, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xe9,
+  0x40, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x28, 0x46, 0x2c, 0xe1,
+  0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9,
+  0xf0, 0x0e, 0xee, 0x30, 0x25, 0x30, 0x46, 0x50, 0xe1, 0x90, 0x0e, 0xf2,
+  0xe0, 0x06, 0xec, 0x10, 0x0e, 0xee, 0x70, 0x0e, 0xf5, 0x10, 0x0e, 0xe7,
+  0x50, 0x0e, 0xbf, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef,
+  0xe0, 0x0e, 0x53, 0x02, 0x64, 0xc4, 0x14, 0x0e, 0xe9, 0x20, 0x0f, 0x6e,
+  0x30, 0x0e, 0xef, 0xd0, 0x0e, 0xf0, 0x90, 0x0e, 0xec, 0x50, 0x0e, 0xbf,
+  0xf0, 0x0e, 0xf0, 0x40, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x0f, 0x53,
+  0x06, 0x85, 0x71, 0x46, 0x28, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6,
+  0x50, 0x0e, 0xf2, 0x40, 0x0f, 0xe5, 0x80, 0x0f, 0x53, 0x82, 0x37, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce,
+  0x83, 0xfd, 0x15, 0x11, 0x4d, 0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x52, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x09, 0x00, 0x00, 0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6,
+  0x22, 0x04, 0x41, 0x10, 0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88,
+  0x95, 0x40, 0x19, 0x14, 0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14,
+  0x66, 0x00, 0x66, 0x00, 0x00, 0xe3, 0x11, 0x8c, 0x84, 0x49, 0x14, 0x94,
+  0xf1, 0x88, 0x87, 0xd2, 0x28, 0x0a, 0xca, 0x20, 0xc3, 0x60, 0x30, 0x26,
+  0x04, 0xf2, 0x19, 0x8f, 0x98, 0x30, 0xaf, 0xa1, 0xa0, 0x0c, 0x32, 0x1c,
+  0x49, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x60, 0xdd,
+  0x18, 0x40, 0x14, 0x94, 0x41, 0x06, 0xc6, 0xb9, 0x4c, 0x08, 0xe4, 0x63,
+  0x45, 0x00, 0x9f, 0xf1, 0x88, 0x4e, 0x0c, 0xd0, 0xc0, 0xa2, 0xa0, 0x0c,
+  0x32, 0x44, 0x53, 0x67, 0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47,
+  0x84, 0xc1, 0x19, 0xb4, 0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0xb2, 0xcf,
+  0x82, 0x4a, 0x3e, 0x83, 0x0c, 0x83, 0x26, 0x06, 0x16, 0x4c, 0xf2, 0xb1,
+  0x21, 0x80, 0xcf, 0x20, 0x83, 0xd1, 0x99, 0x81, 0x05, 0x91, 0x7c, 0x6c,
+  0x08, 0xe0, 0x33, 0xc8, 0x90, 0x80, 0x81, 0x1a, 0x58, 0xf0, 0xc8, 0xc7,
+  0x86, 0x00, 0x3e, 0xe3, 0x11, 0x6e, 0x40, 0x07, 0x7a, 0x80, 0x06, 0x14,
+  0x94, 0x41, 0x86, 0xc0, 0x0c, 0xd8, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20,
+  0xc3, 0x70, 0x06, 0x6f, 0x60, 0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48,
+  0x03, 0x39, 0xb0, 0xa0, 0x93, 0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x75, 0x60,
+  0x81, 0x26, 0x9f, 0x41, 0x06, 0x3e, 0x78, 0x03, 0x3a, 0xb0, 0x2c, 0x90,
+  0xcf, 0x20, 0x83, 0x1f, 0xc4, 0xc1, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92,
+  0x01, 0x3e, 0x16, 0x30, 0xf0, 0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c,
+  0x2c, 0x28, 0xe0, 0x33, 0xdb, 0x90, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x94,
+  0x42, 0x30, 0xdb, 0x10, 0x94, 0x82, 0x90, 0x41, 0x40, 0x0c, 0x00, 0x00,
+  0x00, 0x09, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0xa0, 0x83, 0x2d, 0xc3,
+  0x10, 0xd0, 0xc1, 0x96, 0xe1, 0x08, 0xe8, 0x60, 0xcb, 0xc0, 0x04, 0x74,
+  0xb0, 0x65, 0x88, 0x02, 0x3a, 0xd8, 0x32, 0x58, 0x01, 0x1d, 0x6c, 0x19,
+  0xc6, 0x20, 0xa0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x98, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xe3, 0x02, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90,
+  0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8,
+  0x08, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00,
+  0x00, 0x51, 0x18, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x18,
+  0xc2, 0x00, 0x2c, 0x40, 0x05, 0x49, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x22, 0xa4,
+  0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x88,
+  0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x3c, 0x33, 0x00, 0xc3, 0x08, 0x04,
+  0x30, 0x8c, 0x20, 0x00, 0x67, 0x49, 0x53, 0x44, 0x09, 0x93, 0xcf, 0x1e,
+  0xc0, 0x40, 0x44, 0x9c, 0xd3, 0x48, 0x13, 0xd0, 0x4c, 0x12, 0x42, 0x00,
+  0x00, 0x00, 0x00, 0x06, 0x11, 0x06, 0xa1, 0x10, 0x21, 0x41, 0x54, 0x03,
+  0x01, 0x73, 0x04, 0x60, 0x90, 0x02, 0x38, 0x47, 0x00, 0x0a, 0x83, 0x08,
+  0x80, 0x30, 0x8c, 0x30, 0x00, 0xc3, 0x08, 0x04, 0x32, 0x02, 0x00, 0x00,
+  0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87,
+  0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83,
+  0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x31, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xc8, 0x02, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0xc2, 0x11, 0x80, 0x42, 0x28, 0x81, 0x22, 0x28,
+  0x88, 0x02, 0x2a, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0xd2, 0xc2,
+  0x19, 0x01, 0x28, 0x8c, 0x42, 0x28, 0x88, 0x02, 0x29, 0x94, 0x82, 0xa1,
+  0x1c, 0x4b, 0x78, 0x04, 0x00, 0x79, 0x18, 0x00, 0x00, 0x13, 0x01, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x42, 0x1c, 0x40, 0x42, 0x51,
+  0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62,
+  0x20, 0xc3, 0x21, 0x20, 0x02, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c,
+  0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06,
+  0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x70, 0x10, 0x43,
+  0x0c, 0x64, 0x40, 0x0a, 0x24, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x39, 0x0e, 0x64, 0x40, 0x06, 0x24, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x38, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x63, 0x61,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89,
+  0xb1, 0x95, 0x0d, 0x11, 0x8e, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c,
+  0x99, 0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d,
+  0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8,
+  0xb2, 0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x34, 0x43, 0x90, 0xe3, 0x41, 0x82, 0x03, 0x3a, 0xa2, 0x21, 0xc2, 0x21,
+  0x51, 0x0a, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73,
+  0xa3, 0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3, 0x63, 0x76, 0x56, 0xe6, 0x56,
+  0x26, 0x17, 0x46, 0x57, 0x46, 0x86, 0x82, 0x03, 0xf7, 0x36, 0x97, 0x46,
+  0x97, 0xf6, 0xe6, 0x46, 0x64, 0x27, 0xf3, 0x65, 0x96, 0x42, 0x25, 0x2c,
+  0x4d, 0xce, 0x65, 0xac, 0xcc, 0x8d, 0xae, 0x4c, 0x8e, 0x4f, 0x58, 0x9a,
+  0x9c, 0x0b, 0x5c, 0x99, 0xdc, 0x1c, 0x5c, 0xd9, 0x18, 0x5d, 0x9a, 0x5d,
+  0x19, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde,
+  0xe6, 0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0x86, 0x48, 0x48, 0x70, 0x50, 0x47,
+  0x75, 0x58, 0xc7, 0x75, 0x40, 0x07, 0x76, 0x64, 0x87, 0x46, 0xeb, 0xac,
+  0xcc, 0xad, 0x4c, 0x2e, 0x8c, 0xae, 0x8c, 0x0c, 0xa5, 0x66, 0xec, 0x8d,
+  0xed, 0x4d, 0x8e, 0xc8, 0x8e, 0xe6, 0xcb, 0x2c, 0x85, 0xc5, 0xd8, 0x1b,
+  0xdb, 0x9b, 0xdc, 0x10, 0x09, 0x19, 0x0e, 0xea, 0xe0, 0x0e, 0xeb, 0xb8,
+  0x0e, 0xe8, 0x88, 0x8e, 0xec, 0xe8, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0x88,
+  0xd5, 0x99, 0x99, 0x95, 0xc9, 0xf1, 0x09, 0x4b, 0x93, 0x73, 0x11, 0xab,
+  0x33, 0x33, 0x2b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xa3, 0x14, 0x96,
+  0x26, 0xe7, 0xc2, 0xf6, 0x36, 0x16, 0x46, 0x97, 0xf6, 0xe6, 0xf6, 0x95,
+  0xe6, 0x46, 0x56, 0x86, 0x47, 0x24, 0x2c, 0x4d, 0xce, 0x45, 0xae, 0x2c,
+  0x8c, 0x8c, 0x54, 0x58, 0x9a, 0x9c, 0xcb, 0x1c, 0x9d, 0x5c, 0xdd, 0x18,
+  0xdd, 0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x57, 0x9a, 0x9b, 0xd9, 0x1b, 0x0b,
+  0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x32, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f,
+  0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x64, 0xe8, 0xca, 0xf0, 0xe8, 0xea,
+  0xe4, 0xca, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xa8, 0xa4, 0xb9, 0xc1, 0xd5,
+  0xd1, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x71, 0x19, 0x7b, 0x63, 0x7b, 0x93,
+  0xfb, 0x9a, 0x1b, 0x0b, 0x63, 0x2b, 0xa3, 0x43, 0xf7, 0xe6, 0x56, 0xd6,
+  0x16, 0x06, 0xf7, 0xd5, 0x56, 0x46, 0x87, 0xf6, 0x46, 0xc6, 0x87, 0xee,
+  0xcd, 0xad, 0xac, 0x2d, 0x0c, 0xee, 0xcb, 0x2c, 0x6c, 0x8c, 0xee, 0x4d,
+  0x2e, 0x86, 0x0f, 0xdd, 0x9b, 0x5b, 0x59, 0x5b, 0x18, 0xdc, 0x97, 0x59,
+  0xd8, 0x18, 0xdd, 0x9b, 0x9c, 0x0c, 0x9f, 0x39, 0x32, 0xb9, 0xaf, 0x3b,
+  0xb4, 0x34, 0xba, 0xb2, 0x2f, 0xb8, 0xb7, 0x34, 0x37, 0xba, 0x21, 0xb0,
+  0x80, 0x04, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x65, 0x80, 0x08, 0x88,
+  0x80, 0x04, 0x07, 0x19, 0x1c, 0x66, 0x80, 0x14, 0x88, 0x80, 0x04, 0x07,
+  0x19, 0x1c, 0x67, 0x80, 0x1c, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x68,
+  0x80, 0x20, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x69, 0x80, 0x24, 0x88,
+  0x80, 0x04, 0x07, 0x19, 0x1c, 0x6a, 0x80, 0x28, 0x88, 0x80, 0x04, 0x07,
+  0x19, 0x1c, 0x6b, 0x80, 0x2c, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x6c,
+  0xc0, 0x28, 0x2c, 0x4d, 0xce, 0x25, 0x4c, 0xee, 0xec, 0x8b, 0x2e, 0x0f,
+  0xae, 0xec, 0x6b, 0x2e, 0x4d, 0xaf, 0x8c, 0x57, 0x58, 0x9a, 0x9c, 0x4b,
+  0x98, 0xdc, 0xd9, 0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x57, 0x18, 0x5b, 0xda,
+  0x99, 0xdb, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x9f, 0x29, 0xb4, 0x30, 0xb2,
+  0x32, 0xb9, 0xa1, 0x37, 0xb7, 0x39, 0xba, 0x30, 0x37, 0xba, 0x39, 0x06,
+  0x63, 0x43, 0xc8, 0x00, 0x21, 0x8e, 0xef, 0x00, 0x03, 0xc4, 0x38, 0xc2,
+  0x00, 0x09, 0x90, 0xe1, 0x10, 0x83, 0x63, 0x0c, 0x8e, 0x36, 0x38, 0xdc,
+  0x00, 0x31, 0x8e, 0x37, 0x40, 0x84, 0x03, 0x3a, 0xe0, 0xe0, 0xc8, 0x8e,
+  0x38, 0x18, 0x62, 0x1c, 0xdb, 0xe1, 0x1d, 0x72, 0x30, 0xc4, 0x30, 0x80,
+  0x63, 0x3a, 0xe6, 0x80, 0xd5, 0x97, 0x16, 0xd5, 0x54, 0x4c, 0xcd, 0x14,
+  0x5a, 0x18, 0x59, 0x99, 0xdc, 0xd0, 0x9b, 0xdb, 0x1c, 0x5d, 0x98, 0x1b,
+  0xdd, 0x1c, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32, 0x37,
+  0x3a, 0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70, 0x6c,
+  0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43, 0x84,
+  0xe3, 0x0e, 0x86, 0x18, 0x87, 0x1d, 0x1c, 0x78, 0xa0, 0x34, 0x43, 0x8c,
+  0x83, 0x0c, 0x8e, 0x3c, 0x50, 0x9a, 0x21, 0x62, 0x70, 0xd4, 0xc1, 0xa1,
+  0x07, 0x4a, 0x73, 0xe8, 0x81, 0xf2, 0x1c, 0x7a, 0xa0, 0x40, 0x87, 0x1e,
+  0x28, 0xce, 0xa1, 0x07, 0x4a, 0x74, 0xe8, 0x81, 0x22, 0x1d, 0x7a, 0xa0,
+  0x4c, 0x87, 0x1e, 0x28, 0xcc, 0x10, 0xe3, 0xd8, 0x83, 0x43, 0x0f, 0x14,
+  0x67, 0x44, 0xc4, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xed, 0xf0,
+  0x0e, 0xe4, 0x50, 0x0f, 0xec, 0x50, 0x0e, 0x6e, 0x60, 0x0e, 0xec, 0x10,
+  0x0e, 0xe7, 0x30, 0x0f, 0x53, 0x84, 0x60, 0x18, 0xa1, 0xb0, 0x03, 0x3b,
+  0xd8, 0x43, 0x3b, 0xb8, 0x41, 0x3a, 0x90, 0x43, 0x39, 0xb8, 0x03, 0x3d,
+  0x4c, 0x09, 0x8a, 0x11, 0x4b, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x3d,
+  0x94, 0x83, 0x3c, 0xcc, 0x43, 0x3a, 0xbc, 0x83, 0x3b, 0x4c, 0x09, 0x8c,
+  0x11, 0x54, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x01, 0x3b, 0x84, 0x83, 0x3b,
+  0x9c, 0x43, 0x3d, 0x84, 0xc3, 0x39, 0x94, 0xc3, 0x2f, 0xd8, 0x43, 0x39,
+  0xc8, 0xc3, 0x3c, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x94, 0x00, 0x19, 0x31,
+  0x85, 0x43, 0x3a, 0xc8, 0x83, 0x1b, 0x8c, 0xc3, 0x3b, 0xb4, 0x03, 0x3c,
+  0xa4, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x03, 0x3c, 0xd0, 0x43, 0x3a,
+  0xbc, 0x83, 0x3b, 0xcc, 0xc3, 0x94, 0x41, 0x61, 0x9c, 0x11, 0x4c, 0x38,
+  0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x39, 0xc8, 0x43, 0x38, 0x9c, 0x43, 0x3b,
+  0x94, 0x83, 0x3b, 0xd0, 0xc3, 0x94, 0x80, 0x0e, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x05, 0x00, 0x00,
+  0x00, 0x06, 0x20, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x11,
+  0x01, 0x06, 0x43, 0x34, 0x13, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0xd4, 0x73, 0x10, 0x41, 0x10, 0x68, 0x84,
+  0x65, 0x30, 0x03, 0x40, 0x3c, 0x03, 0x40, 0x30, 0x46, 0x00, 0x82, 0x20,
+  0x88, 0x7f, 0x00, 0x00, 0x00, 0xe3, 0x0d, 0x06, 0x44, 0x50, 0x30, 0xe6,
+  0x18, 0x88, 0xc0, 0x1b, 0x64, 0x08, 0x0a, 0x64, 0x8e, 0x21, 0x28, 0x10,
+  0x0b, 0x18, 0xf9, 0x64, 0x10, 0x10, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x5b, 0x86, 0x20, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x50, 0x18, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00,
+  0x00, 0x11, 0x06, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04,
+  0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08,
+  0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b,
+  0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44,
+  0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21,
+  0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6,
+  0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0xe8, 0x00, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00,
+  0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90, 0x87, 0x77, 0xc0, 0x87,
+  0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d, 0xda, 0x80, 0x1d, 0xca,
+  0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d, 0xc8, 0x81, 0x1e, 0xd0,
+  0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87,
+  0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07,
+  0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2,
+  0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2,
+  0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8,
+  0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87,
+  0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c,
+  0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06,
+  0xa3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x8f,
+  0x18, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x12, 0x50, 0x11, 0xe1, 0x00,
+  0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0,
+  0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b,
+  0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b,
+  0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b,
+  0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03, 0x90, 0x07, 0x76, 0x00,
+  0x0c, 0xee, 0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5, 0x90, 0x0e, 0xec, 0x40,
+  0x0f, 0xe9, 0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x60,
+  0x0e, 0xf2, 0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0xef, 0x90,
+  0x0e, 0xee, 0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d, 0x50, 0x0e, 0xec, 0x90,
+  0x0e, 0xed, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94, 0x43, 0x1b,
+  0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8, 0x43, 0x1b,
+  0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81, 0x3b, 0xbc, 0x83, 0x3b,
+  0xb4, 0x01, 0x3b, 0x94, 0x43, 0x38, 0x98, 0x03, 0x40, 0x0f, 0xf2, 0x50,
+  0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x90, 0x0e, 0xee, 0x60,
+  0x0e, 0xf3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3, 0x3c, 0xb4, 0x81, 0x39,
+  0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20,
+  0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xf3, 0x90,
+  0x0e, 0xe7, 0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d, 0xa0, 0x0f, 0xe5, 0x20,
+  0x0f, 0xef, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40,
+  0xb8, 0xc3, 0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43, 0x38, 0xc0, 0x03, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a,
+  0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0x31, 0x0f, 0xf4, 0x10,
+  0x0e, 0xe3, 0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2, 0xf0, 0x0e, 0xf4, 0x50,
+  0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d, 0x20, 0x0e, 0xf5, 0x60,
+  0x0e, 0xe6, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xfa, 0x50,
+  0x0e, 0x00, 0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3, 0x3c, 0x84, 0x83, 0x39,
+  0x94, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d,
+  0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x6c, 0x40, 0x8e,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x06, 0x90, 0x80, 0x6a, 0x83, 0x81,
+  0x04, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x44, 0x00, 0x16, 0xa0, 0xda, 0x80,
+  0x28, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06,
+  0x63, 0xf9, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0xc3, 0xc4,
+  0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x28, 0x80, 0x34, 0xb8, 0xc3, 0x3b,
+  0xb4, 0x81, 0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03, 0x3d, 0xa4, 0x83, 0x3b,
+  0xcc, 0x03, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41, 0x31, 0x21, 0x30, 0x26,
+  0x0c, 0x07, 0x92, 0x4c, 0x18, 0x14, 0x24, 0x99, 0x10, 0x2c, 0x13, 0x02,
+  0x06, 0x89, 0x20, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4,
+  0x4c, 0x10, 0x9c, 0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08,
+  0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11,
+  0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x41, 0x84, 0x41, 0x38, 0x4a, 0x9a, 0x22, 0x4a, 0x98, 0xfc,
+  0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0xfe, 0x69, 0x8c, 0x00,
+  0x18, 0x44, 0x28, 0x82, 0x8b, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x25,
+  0x80, 0x79, 0x16, 0x22, 0xfa, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x10,
+  0xca, 0x11, 0x04, 0x81, 0x40, 0x18, 0x08, 0x25, 0xc3, 0x08, 0x03, 0x50,
+  0x88, 0x65, 0x59, 0x16, 0x62, 0xca, 0x00, 0x00, 0x00, 0x39, 0x45, 0x00,
+  0x00, 0x82, 0xca, 0x00, 0x2c, 0x0b, 0x49, 0xc5, 0x58, 0x16, 0x00, 0x00,
+  0x00, 0xa2, 0xca, 0xb0, 0x2c, 0x0b, 0x59, 0x45, 0x58, 0x16, 0xc2, 0xe6,
+  0x08, 0x82, 0x39, 0x02, 0x30, 0x18, 0x46, 0x10, 0xb6, 0x82, 0x04, 0x06,
+  0x22, 0x68, 0x9c, 0x06, 0x50, 0x37, 0x10, 0x90, 0x02, 0xdb, 0x1c, 0x01,
+  0x28, 0x0c, 0x22, 0x00, 0xc2, 0x14, 0xc0, 0x08, 0xc0, 0x30, 0xc2, 0xb0,
+  0x0d, 0x23, 0x10, 0x1b, 0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0,
+  0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68,
+  0x83, 0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80,
+  0x03, 0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5,
+  0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78,
+  0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a,
+  0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76,
+  0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d,
+  0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a,
+  0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72,
+  0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d,
+  0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79,
+  0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72,
+  0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71,
+  0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a,
+  0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76,
+  0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76,
+  0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71,
+  0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74,
+  0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x51,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x34, 0x40,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0x1e, 0x20, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x30, 0x11, 0x10, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x98, 0x09, 0x08, 0x00, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x80, 0x21, 0x4c, 0x85, 0x00, 0xc3, 0x00, 0x00, 0x00,
+  0x10, 0x00, 0xc0, 0x10, 0xe6, 0x01, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x60, 0x08, 0x73, 0x01, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x84, 0xc9, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+  0xc2, 0x5c, 0x40, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61,
+  0x3c, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x40, 0x00,
+  0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xda, 0x46, 0x00, 0x0a,
+  0xa1, 0x04, 0x8a, 0xa0, 0x20, 0x0a, 0xa8, 0x0c, 0x0a, 0xa3, 0x40, 0x0a,
+  0xa5, 0x60, 0x0a, 0xa7, 0x14, 0x28, 0x2c, 0x9c, 0x11, 0x80, 0x42, 0x28,
+  0x88, 0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x02, 0xc7, 0x12, 0x1e, 0x01,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0x6f, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
+  0xb7, 0x21, 0xc6, 0xe6, 0x7c, 0x00, 0x18, 0x80, 0x01, 0x95, 0xbb, 0x31,
+  0xb4, 0x30, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0xb2, 0x21, 0xc6, 0xd6, 0x7c,
+  0xc2, 0xc6, 0x30, 0x0e, 0x82, 0xe0, 0xe0, 0xd8, 0xca, 0x40, 0xda, 0xca,
+  0xe8, 0xc2, 0xd8, 0x40, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x40,
+  0x66, 0x64, 0x60, 0x64, 0x66, 0x5c, 0x68, 0x60, 0x68, 0x40, 0x50, 0xda,
+  0xca, 0xe8, 0xc2, 0xd8, 0xcc, 0xca, 0x5a, 0x66, 0x64, 0x60, 0x64, 0x66,
+  0x5c, 0x68, 0x60, 0x68, 0x52, 0x86, 0x08, 0x1f, 0x31, 0xc4, 0xd8, 0x9a,
+  0xed, 0xd9, 0x16, 0x16, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x43, 0x90, 0xef,
+  0xd8, 0x9a, 0xad, 0xd9, 0x16, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x2f,
+  0x21, 0x17, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56,
+  0xe6, 0x62, 0x16, 0x36, 0x47, 0xf7, 0xd5, 0x16, 0x46, 0x87, 0xf6, 0x55,
+  0xe6, 0x16, 0x26, 0xc6, 0x56, 0x36, 0x44, 0xf8, 0x16, 0x96, 0x41, 0x58,
+  0x9a, 0x9c, 0xcb, 0xd8, 0x5b, 0x1b, 0x5c, 0x1a, 0x5b, 0x99, 0x8b, 0x99,
+  0x5c, 0x58, 0x5b, 0x99, 0x58, 0x9d, 0x99, 0x59, 0x99, 0xdc, 0x97, 0x59,
+  0x19, 0xdd, 0x18, 0xda, 0x17, 0x59, 0xda, 0x5c, 0x98, 0x18, 0x5b, 0xd9,
+  0x10, 0xe1, 0x6b, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0xb9, 0x91,
+  0x95, 0xc9, 0x7d, 0xd1, 0x85, 0xc9, 0x9d, 0x95, 0xd1, 0x31, 0x0a, 0x4b,
+  0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x72,
+  0x0b, 0x6b, 0x2b, 0xa3, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x33, 0x04,
+  0xf9, 0x9e, 0x6d, 0xf9, 0xa0, 0x2f, 0x1a, 0x22, 0x7c, 0x12, 0x99, 0xb0,
+  0x34, 0x39, 0x17, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0x37, 0x2a,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x94, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xdc, 0xde, 0xbe, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca,
+  0xc6, 0xe8, 0xd2, 0xec, 0xca, 0xc8, 0x84, 0xa5, 0xc9, 0xb9, 0x84, 0xc9,
+  0x9d, 0x7d, 0xb9, 0x85, 0xb5, 0x95, 0x11, 0x81, 0x7b, 0x9b, 0x4b, 0xa3,
+  0x4b, 0x7b, 0x73, 0x1b, 0x02, 0x6d, 0xcb, 0x47, 0x7d, 0xd5, 0x67, 0x7d,
+  0xd0, 0x17, 0x7d, 0xd7, 0x87, 0x51, 0x0a, 0x4b, 0x93, 0x73, 0x31, 0x93,
+  0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3,
+  0xa3, 0x75, 0x56, 0xe6, 0x56, 0x26, 0x17, 0x46, 0x57, 0x46, 0x86, 0x52,
+  0x33, 0xf6, 0xc6, 0xf6, 0x26, 0x47, 0x64, 0x47, 0xf3, 0x65, 0x96, 0xc2,
+  0x27, 0x2c, 0x4d, 0xce, 0x05, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c,
+  0x2e, 0xcd, 0xae, 0x8c, 0xc5, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0x10, 0x69,
+  0x6b, 0x3e, 0xed, 0xdb, 0xbe, 0xea, 0xe3, 0x3e, 0xe8, 0x8b, 0xbe, 0xeb,
+  0xeb, 0x98, 0x9d, 0x95, 0xb9, 0x95, 0xc9, 0x85, 0xd1, 0x95, 0x91, 0xa1,
+  0xe0, 0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x11, 0xd9, 0xc9,
+  0x7c, 0x99, 0xa5, 0xd0, 0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x93, 0x21, 0x42,
+  0x57, 0x86, 0x37, 0xf6, 0xf6, 0x26, 0x47, 0x36, 0x44, 0xda, 0x9c, 0x4f,
+  0xfb, 0xbe, 0xaf, 0xfa, 0xb8, 0x0f, 0xfa, 0xc0, 0xe0, 0xbb, 0xbe, 0x30,
+  0xa0, 0x12, 0x96, 0x26, 0xe7, 0x22, 0x56, 0x67, 0x66, 0x56, 0x26, 0xc7,
+  0x27, 0x2c, 0x4d, 0xce, 0x45, 0xac, 0xce, 0xcc, 0xac, 0x4c, 0xee, 0x6b,
+  0x2e, 0x4d, 0xaf, 0x8c, 0x52, 0x58, 0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58,
+  0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57, 0x9a, 0x1b, 0x59, 0x19, 0x1e, 0x91,
+  0xb0, 0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x52, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x2c, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0xc8,
+  0xcc, 0x8d, 0x49, 0x1d, 0x09, 0x7d, 0xbd, 0xd5, 0xd1, 0xc1, 0xd5, 0xd1,
+  0x91, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xfb, 0xa2, 0xcb, 0x83,
+  0x2b, 0xa3, 0x92, 0xe6, 0x06, 0x57, 0x47, 0xf7, 0x45, 0x97, 0x07, 0x57,
+  0xc6, 0x65, 0xec, 0x8d, 0xed, 0x4d, 0xee, 0x6b, 0x6e, 0x2c, 0x8c, 0xad,
+  0x8c, 0x0e, 0xdd, 0x9b, 0x5b, 0x59, 0x5b, 0x18, 0xdc, 0x57, 0x5b, 0x19,
+  0x1d, 0xda, 0x1b, 0x19, 0x1f, 0xba, 0x37, 0xb7, 0xb2, 0xb6, 0x30, 0xb8,
+  0x2f, 0xb3, 0xb0, 0x31, 0xba, 0x37, 0xb9, 0x18, 0x3e, 0x74, 0x6f, 0x6e,
+  0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32,
+  0x7c, 0xe6, 0xc8, 0xe4, 0xbe, 0xee, 0xd0, 0xd2, 0xe8, 0xca, 0xbe, 0xe0,
+  0xde, 0xd2, 0xdc, 0xe8, 0x86, 0xc0, 0xc2, 0xb6, 0x6c, 0xcc, 0xb6, 0x7c,
+  0x68, 0xf0, 0xa5, 0xc1, 0xc6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xa9,
+  0xc1, 0xf6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xad, 0xc1, 0x26, 0x6d,
+  0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xb1, 0xc1, 0x36, 0x6d, 0xcc, 0xb6, 0x7c,
+  0x68, 0xf0, 0xb5, 0xc1, 0x46, 0x6d, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xb9,
+  0xc1, 0x56, 0x6d, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xbd, 0xc1, 0x66, 0x6d,
+  0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xc1, 0x01, 0xa3, 0xb0, 0x34, 0x39, 0x97,
+  0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd,
+  0x32, 0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x7c, 0xa6, 0xd0, 0xc2, 0xc8, 0xca, 0xe4, 0x86, 0xde, 0xdc, 0xe6,
+  0xe8, 0xc2, 0xdc, 0xe8, 0xe6, 0x18, 0x8c, 0x0d, 0x21, 0x83, 0x2d, 0xfa,
+  0xc6, 0xe0, 0x23, 0x83, 0x0d, 0xfa, 0xca, 0x60, 0x5b, 0xb6, 0xe6, 0x33,
+  0x83, 0xef, 0x0c, 0xbe, 0x38, 0xf8, 0xe4, 0x60, 0x83, 0xbe, 0x39, 0xd8,
+  0x98, 0x0f, 0xfa, 0xe8, 0xe0, 0xbb, 0xbe, 0x3a, 0xe0, 0x12, 0x96, 0x26,
+  0xe7, 0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d,
+  0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e,
+  0x5d, 0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d,
+  0x0b, 0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x07, 0xba, 0x32,
+  0xbc, 0x21, 0xd4, 0xc6, 0x7c, 0x77, 0xf0, 0x95, 0xc1, 0xb6, 0x6c, 0xcd,
+  0x87, 0x07, 0x1f, 0xf4, 0xe5, 0xc1, 0x77, 0x7d, 0x7a, 0xc0, 0x25, 0x2c,
+  0x4d, 0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x4c, 0x8e, 0xc7, 0x5c,
+  0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x1c, 0x83, 0xb9, 0x21, 0xd2, 0x76, 0x7d,
+  0x7c, 0xf0, 0x95, 0xc1, 0xb6, 0x6c, 0xcd, 0x07, 0x7d, 0x7d, 0xf0, 0x5d,
+  0x9f, 0x1f, 0x0c, 0x61, 0xbe, 0xec, 0xf3, 0x3e, 0x31, 0xf8, 0xec, 0xe0,
+  0xdb, 0x83, 0xef, 0x0f, 0x86, 0x18, 0x0a, 0xf0, 0x4d, 0x1f, 0x28, 0x70,
+  0x0c, 0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8, 0xd2, 0xc2, 0xe6, 0x5a, 0xe6,
+  0xc6, 0xde, 0xe0, 0xca, 0xe6, 0x50, 0xa6, 0x88, 0x98, 0xbe, 0x86, 0xde,
+  0xe0, 0xf2, 0xbe, 0xcc, 0xe4, 0xc2, 0xce, 0xda, 0xca, 0xdc, 0xe8, 0x52,
+  0x86, 0x10, 0xdf, 0x28, 0x7c, 0xa2, 0x40, 0x2c, 0x2c, 0x4d, 0xae, 0x25,
+  0x8c, 0x2d, 0x2d, 0x6c, 0xae, 0x65, 0x6e, 0xec, 0x0d, 0xae, 0xac, 0x85,
+  0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x6c, 0x6e, 0x88, 0xf1, 0x95, 0xc2,
+  0x37, 0x0a, 0x1f, 0x29, 0x10, 0x0b, 0x4b, 0x93, 0x6b, 0x09, 0x63, 0x4b,
+  0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83, 0x2b, 0x6b, 0x99, 0x0b, 0x6b,
+  0x83, 0x63, 0x2b, 0x93, 0x9b, 0x1b, 0x62, 0x7c, 0xa7, 0xf0, 0x8d, 0xc2,
+  0x67, 0x0a, 0x43, 0x88, 0xaf, 0x14, 0xbe, 0x53, 0x60, 0xf5, 0xa5, 0x45,
+  0x35, 0x15, 0x53, 0x33, 0x85, 0x16, 0x46, 0x56, 0x26, 0x37, 0xf4, 0xe6,
+  0x36, 0x47, 0x17, 0xe6, 0x46, 0x37, 0xc7, 0xe7, 0xad, 0xcd, 0x2d, 0x0d,
+  0xee, 0x8d, 0xae, 0xcc, 0x8d, 0x0e, 0x64, 0x0c, 0x2d, 0x4c, 0x8e, 0xcf,
+  0x54, 0x5a, 0x1b, 0x1c, 0x5b, 0x19, 0xc8, 0xd0, 0xca, 0x0a, 0x08, 0x95,
+  0x50, 0x50, 0xd0, 0x10, 0xe1, 0x5b, 0x85, 0x21, 0xc6, 0xa7, 0x0a, 0x1f,
+  0x2b, 0x84, 0x41, 0x36, 0xc4, 0xf8, 0xd0, 0xe0, 0x6b, 0x85, 0x30, 0xc8,
+  0x86, 0x88, 0xc1, 0x97, 0x0a, 0x9f, 0x2b, 0x84, 0x41, 0xf6, 0xb9, 0x42,
+  0x18, 0x68, 0x9f, 0x2b, 0x84, 0xc1, 0xf6, 0xb9, 0x42, 0x18, 0x70, 0x9f,
+  0x2b, 0x84, 0x41, 0xf7, 0xb9, 0x42, 0x18, 0x78, 0x9f, 0x2b, 0x84, 0xc1,
+  0xf7, 0xb9, 0x42, 0x18, 0x60, 0x43, 0x8c, 0xef, 0x15, 0x3e, 0x57, 0x08,
+  0x83, 0x6d, 0x88, 0xf1, 0xbd, 0xc2, 0xe7, 0x0a, 0x61, 0x80, 0x0d, 0x31,
+  0xbe, 0x57, 0xf8, 0x5c, 0x21, 0x0c, 0xba, 0x21, 0xc6, 0xf7, 0x0a, 0x9f,
+  0x2b, 0x84, 0x81, 0x37, 0xc4, 0xf8, 0x5e, 0xe1, 0x73, 0x85, 0x30, 0xf8,
+  0x86, 0x18, 0xdf, 0x2b, 0x7c, 0xae, 0x10, 0x06, 0xda, 0x10, 0xe3, 0x7b,
+  0x85, 0xcf, 0x15, 0xc2, 0x80, 0x1b, 0x62, 0x7c, 0xaf, 0xf0, 0xb9, 0x42,
+  0x18, 0x64, 0x23, 0x22, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x77, 0x20, 0x87, 0x7a, 0x60, 0x87, 0x72, 0x70, 0x03, 0x73, 0x60,
+  0x87, 0x70, 0x38, 0x87, 0x79, 0x98, 0x22, 0x04, 0xc3, 0x08, 0x85, 0x1d,
+  0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xd2, 0x81, 0x1c, 0xca, 0xc1, 0x1d,
+  0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d,
+  0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x4a,
+  0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c, 0xce, 0xa1, 0x1c, 0x7e, 0xc1, 0x1e,
+  0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0xa6, 0x04, 0xc8,
+  0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e, 0xdc, 0x60, 0x1c, 0xde, 0xa1, 0x1d,
+  0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c, 0x7e, 0xe1, 0x1d, 0xe0, 0x81, 0x1e,
+  0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e, 0xa6, 0x0c, 0x0a, 0xe3, 0x8c, 0x60,
+  0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xe1, 0x1c,
+  0xda, 0xa1, 0x1c, 0xdc, 0x81, 0x1e, 0xa6, 0x04, 0xa1, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x2e, 0x00, 0x00, 0x00, 0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73, 0xce,
+  0x83, 0xfd, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x56, 0x90, 0xfd, 0x73,
+  0x6d, 0x6b, 0xcf, 0xb3, 0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5,
+  0xfd, 0x17, 0x45, 0x51, 0x14, 0x46, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce,
+  0xe4, 0x57, 0x77, 0x71, 0xdb, 0xa6, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00,
+  0xf3, 0x2c, 0xc4, 0x3f, 0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e,
+  0x85, 0x17, 0xb7, 0x6d, 0x08, 0x13, 0x80, 0x44, 0x7e, 0x01, 0x48, 0xd3,
+  0x5f, 0x00, 0x81, 0xe4, 0x57, 0x77, 0x71, 0xdb, 0x16, 0x40, 0x01, 0x48,
+  0xe4, 0x17, 0x80, 0x34, 0xfd, 0xc2, 0x02, 0x30, 0x8f, 0x5f, 0xdd, 0xc5,
+  0x6d, 0x5b, 0xc2, 0x04, 0x20, 0x91, 0x5f, 0x00, 0xd2, 0xf4, 0x17, 0x0c,
+  0x70, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x09, 0x40, 0x00, 0x12, 0xf9, 0x05,
+  0x20, 0x4d, 0xff, 0xe3, 0x58, 0x7e, 0x71, 0xdb, 0x36, 0x10, 0x01, 0x48,
+  0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05, 0x10, 0x48, 0x7e, 0x71, 0xdb, 0x66,
+  0x10, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05, 0x03, 0x5c, 0x7e,
+  0x71, 0xdb, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x8f,
+  0x63, 0xf9, 0xd5, 0x5d, 0xdc, 0x36, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x99, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x51, 0x00, 0x00, 0x00, 0x64, 0x8e, 0x45, 0x00, 0x81, 0x70, 0xcc,
+  0x41, 0x2c, 0x8d, 0xd3, 0x06, 0x54, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81,
+  0x40, 0xdc, 0x08, 0x00, 0x6d, 0xc5, 0x30, 0x03, 0x50, 0x0e, 0xa4, 0x8d,
+  0x00, 0xd4, 0x00, 0x01, 0x63, 0x04, 0xef, 0x9e, 0x96, 0xf7, 0x37, 0x46,
+  0xa0, 0xb3, 0xe6, 0x1c, 0x82, 0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x09,
+  0x06, 0x63, 0x04, 0x20, 0x08, 0x82, 0x20, 0x18, 0xcc, 0x00, 0x50, 0x30,
+  0x03, 0x30, 0x03, 0x30, 0x07, 0x91, 0x0a, 0xaf, 0x90, 0x0a, 0x75, 0x40,
+  0xcb, 0x0c, 0xc0, 0x08, 0xc0, 0x0c, 0xc0, 0x58, 0x03, 0x08, 0x82, 0x20,
+  0xfe, 0x81, 0x20, 0x08, 0xe2, 0x1f, 0x08, 0x82, 0x20, 0xfe, 0x8d, 0x35,
+  0xb0, 0xed, 0xfc, 0x93, 0x1e, 0xdb, 0xce, 0x3f, 0xe9, 0xb1, 0xed, 0xfc,
+  0x93, 0xde, 0x58, 0x03, 0x08, 0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2,
+  0xf5, 0x2f, 0x80, 0x20, 0xc8, 0xd6, 0xbf, 0x30, 0xd6, 0x00, 0x82, 0xe0,
+  0x9a, 0x83, 0x01, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39,
+  0x18, 0x8c, 0x35, 0x80, 0x20, 0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b,
+  0x83, 0x01, 0x08, 0xd2, 0x6d, 0x0e, 0x06, 0x63, 0x0d, 0xeb, 0x88, 0xc7,
+  0x2c, 0x18, 0xac, 0x23, 0x1e, 0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82,
+  0xc1, 0x58, 0x03, 0x08, 0xc2, 0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1,
+  0x18, 0x80, 0x20, 0x8c, 0x87, 0x63, 0x30, 0xd6, 0x20, 0xe6, 0x62, 0xda,
+  0x7f, 0x60, 0xc9, 0xb3, 0xf1, 0x2f, 0x8c, 0xe9, 0xaa, 0xe6, 0xbe, 0x30,
+  0xd6, 0xf0, 0xcf, 0xa4, 0xff, 0xfb, 0x02, 0x5d, 0x83, 0x62, 0xfe, 0xb5,
+  0x70, 0x1c, 0x83, 0xbe, 0x30, 0xd6, 0x30, 0xf7, 0x6d, 0x9a, 0xfa, 0x42,
+  0xeb, 0x86, 0x3c, 0xef, 0x0b, 0x7c, 0xce, 0xfa, 0xf8, 0x47, 0xc0, 0x18,
+  0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde,
+  0x18, 0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0x80, 0x20, 0x08, 0xe2,
+  0xdf, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c,
+  0xba, 0xf8, 0x37, 0x46, 0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2,
+  0xe8, 0xf6, 0x34, 0x18, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x06, 0x4a, 0x11, 0x98, 0xc2, 0x1a,
+  0xa8, 0x41, 0x1b, 0x80, 0x41, 0x19, 0x84, 0x41, 0x30, 0xde, 0xd0, 0x06,
+  0x78, 0x30, 0x0a, 0x14, 0x8c, 0xe1, 0x86, 0x00, 0x0c, 0x82, 0x59, 0x86,
+  0x40, 0x08, 0x06, 0x19, 0x08, 0x4f, 0x0d, 0xc6, 0x1b, 0xe2, 0x80, 0x0f,
+  0xce, 0x80, 0x82, 0x31, 0x62, 0x40, 0x18, 0xc1, 0x2b, 0x0c, 0x23, 0x06,
+  0x85, 0x11, 0xc4, 0x42, 0xb0, 0x59, 0xb0, 0xc1, 0x67, 0xc4, 0xa0, 0x30,
+  0x82, 0x58, 0x08, 0xc0, 0xc0, 0x06, 0x4e, 0x3e, 0xc6, 0x05, 0xf1, 0xb1,
+  0x21, 0xa0, 0xcf, 0x88, 0x01, 0x61, 0x04, 0xb6, 0x10, 0x8c, 0x18, 0x14,
+  0x46, 0x80, 0x0b, 0x81, 0x67, 0x81, 0x27, 0x9f, 0x39, 0x06, 0x34, 0x58,
+  0x6c, 0x61, 0x90, 0x21, 0x48, 0x83, 0x3c, 0xb0, 0x21, 0xa0, 0xcf, 0x20,
+  0x43, 0xb0, 0x06, 0x7c, 0x30, 0xc8, 0x10, 0x54, 0x7e, 0x30, 0x4b, 0x20,
+  0x0c, 0x54, 0x04, 0x42, 0xc0, 0x06, 0xc0, 0x78, 0xc3, 0x28, 0xb8, 0xc2,
+  0x2e, 0x50, 0x30, 0x86, 0x1b, 0x02, 0xcd, 0x99, 0x65, 0x18, 0x88, 0x60,
+  0x90, 0x81, 0xa0, 0x03, 0x50, 0x18, 0x6f, 0x38, 0x05, 0x59, 0xa0, 0x05,
+  0x0a, 0xc6, 0x78, 0x43, 0x2a, 0xd0, 0x42, 0x28, 0x50, 0x30, 0x46, 0x0c,
+  0x90, 0x23, 0x52, 0x87, 0xa2, 0x3b, 0x86, 0x60, 0x90, 0x21, 0xb8, 0x03,
+  0x54, 0x18, 0x64, 0x08, 0x16, 0x55, 0x98, 0x25, 0x20, 0x06, 0x2a, 0x02,
+  0x61, 0xc0, 0x84, 0xe1, 0x86, 0x30, 0x50, 0x83, 0x60, 0x96, 0xa1, 0x98,
+  0x82, 0xf1, 0x06, 0x58, 0xd8, 0x85, 0x73, 0xa0, 0x60, 0x0c, 0x37, 0x04,
+  0x6d, 0x10, 0xcc, 0x32, 0x18, 0x47, 0x30, 0xc8, 0x50, 0x84, 0x42, 0x2b,
+  0x8c, 0x37, 0xd0, 0xc2, 0x2f, 0x9c, 0x03, 0x05, 0x63, 0x8e, 0x21, 0x14,
+  0x82, 0x77, 0x18, 0x64, 0x08, 0x44, 0x41, 0x16, 0x2c, 0x28, 0xe4, 0x33,
+  0xc8, 0x10, 0x90, 0x42, 0x2d, 0xcc, 0x12, 0xb4, 0xc1, 0x78, 0x83, 0x2e,
+  0x94, 0xc3, 0x3c, 0x50, 0x30, 0xc6, 0x1b, 0x78, 0xe1, 0x1c, 0xde, 0x81,
+  0x82, 0x31, 0xc8, 0x00, 0xb1, 0x82, 0x2e, 0x0c, 0x37, 0x10, 0x74, 0xe0,
+  0xcc, 0x32, 0x20, 0x52, 0x30, 0x86, 0x20, 0xe5, 0xc3, 0x70, 0x43, 0xd0,
+  0x07, 0xca, 0x2c, 0x83, 0x92, 0x04, 0x26, 0xfc, 0x81, 0x7c, 0x66, 0x09,
+  0x16, 0x1b, 0x42, 0x01, 0x3e, 0x23, 0x06, 0x84, 0x11, 0x94, 0x44, 0x60,
+  0x01, 0x2e, 0xc8, 0x67, 0xc4, 0xa0, 0x30, 0x02, 0x94, 0x08, 0x70, 0x61,
+  0x96, 0x60, 0x19, 0xa8, 0x00, 0x94, 0x44, 0x50, 0xe6, 0x18, 0x6a, 0x21,
+  0x08, 0x89, 0x31, 0x84, 0x0d, 0x24, 0x86, 0x1b, 0x02, 0x53, 0x50, 0x66,
+  0x19, 0x1a, 0x26, 0x30, 0x01, 0x15, 0xe4, 0x33, 0x4b, 0xe0, 0xd8, 0xa0,
+  0x0a, 0xf0, 0x19, 0x31, 0x20, 0x8c, 0xc0, 0x25, 0x02, 0x0b, 0xc2, 0x41,
+  0x3e, 0x23, 0x06, 0x85, 0x11, 0xc4, 0x44, 0x10, 0x0e, 0xb3, 0x04, 0xce,
+  0x40, 0x05, 0xa0, 0x30, 0x42, 0x33, 0xc7, 0x90, 0x04, 0x28, 0x31, 0x86,
+  0x40, 0x06, 0x28, 0x31, 0xdc, 0x10, 0xbc, 0x82, 0x32, 0xcb, 0x00, 0x3d,
+  0x81, 0x09, 0xb1, 0x20, 0x9f, 0x59, 0x82, 0xc8, 0x86, 0x59, 0x80, 0xcf,
+  0x88, 0x01, 0x61, 0x04, 0x37, 0x11, 0x58, 0xa0, 0x0e, 0xf2, 0x19, 0x31,
+  0x28, 0x8c, 0x40, 0x27, 0x02, 0x75, 0x98, 0x25, 0x88, 0x06, 0x2a, 0x00,
+  0xe5, 0x11, 0xa0, 0x39, 0x86, 0x24, 0x80, 0x89, 0x59, 0x02, 0x69, 0xa0,
+  0x22, 0x10, 0x22, 0x3d, 0x38, 0x06, 0x19, 0x02, 0x75, 0xb0, 0x87, 0x39,
+  0x06, 0x74, 0x00, 0x03, 0x9b, 0x18, 0x64, 0x08, 0xd2, 0x21, 0x1f, 0x6c,
+  0x08, 0xe4, 0x33, 0xc8, 0x10, 0xac, 0x03, 0x3f, 0xcc, 0x12, 0xb4, 0xc1,
+  0x70, 0xc3, 0x2c, 0xc4, 0x43, 0x30, 0xcb, 0x40, 0x81, 0x41, 0x30, 0xc8,
+  0x40, 0x07, 0xf0, 0xc0, 0x0f, 0xe3, 0x0d, 0x23, 0xe1, 0x12, 0x3c, 0x41,
+  0xc1, 0x18, 0x6f, 0x28, 0x09, 0x98, 0xc0, 0x09, 0x0a, 0xc6, 0x1c, 0x83,
+  0x3c, 0x04, 0x60, 0x31, 0xc8, 0x10, 0xcc, 0xc3, 0x48, 0x58, 0x70, 0xc8,
+  0x67, 0x90, 0x21, 0xa8, 0x07, 0x93, 0x18, 0x6e, 0x38, 0xc0, 0xc1, 0x99,
+  0x65, 0xf8, 0xaa, 0x60, 0x0c, 0x61, 0x28, 0x8b, 0xe1, 0x86, 0x60, 0x1c,
+  0x94, 0x59, 0x86, 0xcb, 0x0a, 0x4c, 0x28, 0x07, 0xf9, 0xcc, 0x12, 0x60,
+  0x23, 0x06, 0x84, 0x11, 0xc0, 0xc5, 0x30, 0x62, 0x50, 0x18, 0x81, 0x5c,
+  0x04, 0xe8, 0x60, 0x81, 0x3a, 0xc8, 0xc7, 0x02, 0x76, 0x80, 0xcf, 0x2c,
+  0x01, 0x36, 0x50, 0x01, 0x28, 0x96, 0x70, 0xcd, 0x31, 0xf4, 0x43, 0xd0,
+  0x16, 0x63, 0x08, 0x0c, 0x5b, 0x0c, 0x37, 0x04, 0xec, 0xa0, 0xcc, 0x32,
+  0x68, 0x59, 0x60, 0x82, 0x3b, 0xc8, 0x67, 0x96, 0x60, 0x1b, 0x31, 0x20,
+  0x8c, 0x20, 0x2f, 0x86, 0x11, 0x83, 0xc2, 0x08, 0xf6, 0x22, 0x88, 0x07,
+  0x0b, 0xe6, 0x41, 0x3e, 0x16, 0xd4, 0x03, 0x7c, 0x66, 0x09, 0xb6, 0x81,
+  0x0a, 0x40, 0xc9, 0x04, 0x6d, 0x8e, 0x21, 0x09, 0xe8, 0x62, 0x0c, 0xa1,
+  0xa2, 0x8b, 0xe1, 0x86, 0xa0, 0x1e, 0x94, 0x59, 0x86, 0x8e, 0x0b, 0x4c,
+  0xb8, 0x07, 0xf9, 0xcc, 0x12, 0x78, 0x23, 0x06, 0x84, 0x11, 0x88, 0xc6,
+  0x30, 0x62, 0x50, 0x18, 0x01, 0x69, 0x04, 0xfa, 0x60, 0x01, 0x3f, 0xc8,
+  0xc7, 0x02, 0x7f, 0x80, 0xcf, 0x2c, 0x81, 0x37, 0x50, 0x01, 0x28, 0x9c,
+  0xd0, 0xcd, 0x31, 0x24, 0x01, 0x5f, 0x8c, 0x18, 0x18, 0x46, 0xa0, 0x1a,
+  0x41, 0x4c, 0xbc, 0xc4, 0x20, 0x43, 0x30, 0x13, 0x64, 0x31, 0x4b, 0xf0,
+  0x0d, 0x54, 0x04, 0x7e, 0x40, 0x09, 0xde, 0x20, 0x43, 0x80, 0x13, 0x66,
+  0x31, 0x4b, 0xd0, 0x06, 0xb3, 0x0c, 0x61, 0xd0, 0x06, 0xfc, 0x30, 0xc8,
+  0xd0, 0x0b, 0x39, 0x51, 0x16, 0x23, 0x06, 0x85, 0x11, 0xb0, 0x46, 0xd0,
+  0x12, 0x73, 0x0c, 0x36, 0x11, 0x98, 0xc6, 0x88, 0x41, 0x61, 0x04, 0xae,
+  0x31, 0xb8, 0xc4, 0x1c, 0x83, 0x10, 0x98, 0xc6, 0x88, 0x41, 0x61, 0x04,
+  0xb0, 0x51, 0xbc, 0xc4, 0x1c, 0x83, 0x10, 0x9c, 0xc6, 0x20, 0x43, 0xd0,
+  0x13, 0x6e, 0x31, 0xc8, 0x10, 0x94, 0x03, 0x5c, 0x8c, 0x37, 0xd0, 0xc5,
+  0x5f, 0xb4, 0x06, 0x05, 0x63, 0xbc, 0xc1, 0x2e, 0x42, 0x23, 0x35, 0x28,
+  0x18, 0x73, 0x0c, 0x63, 0x11, 0xc4, 0xc6, 0x20, 0x43, 0x40, 0x16, 0x74,
+  0x61, 0x41, 0x22, 0x9f, 0x41, 0x86, 0xc0, 0x2c, 0xee, 0x62, 0xb8, 0xe1,
+  0x88, 0x09, 0x67, 0x96, 0x81, 0x0d, 0xc4, 0x20, 0x18, 0x43, 0x18, 0x6c,
+  0x63, 0xb8, 0x21, 0xa0, 0x09, 0x65, 0x96, 0x81, 0x0c, 0xc6, 0x20, 0x30,
+  0xc1, 0x26, 0xe4, 0x33, 0x4b, 0x50, 0x06, 0x23, 0x06, 0x84, 0x11, 0x84,
+  0xc7, 0x30, 0x62, 0x50, 0x18, 0xc1, 0x78, 0x04, 0x39, 0x61, 0xc1, 0x4e,
+  0xc8, 0xc7, 0x82, 0x9e, 0x80, 0xcf, 0x2c, 0x41, 0x19, 0x0c, 0x54, 0x00,
+  0xca, 0x18, 0x08, 0x64, 0x30, 0xc7, 0xe0, 0x16, 0x81, 0x6f, 0x8c, 0x21,
+  0x30, 0xbd, 0x31, 0xdc, 0x10, 0xf4, 0x84, 0x32, 0xcb, 0x70, 0x06, 0x66,
+  0x10, 0x98, 0xf0, 0x13, 0xf2, 0x99, 0x25, 0x40, 0x83, 0x11, 0x03, 0xc2,
+  0x08, 0xd4, 0x63, 0x18, 0x31, 0x28, 0x8c, 0x80, 0x3d, 0x02, 0xb1, 0xb0,
+  0x80, 0x2c, 0xe4, 0x63, 0x81, 0x59, 0xc0, 0x67, 0x96, 0x00, 0x0d, 0x06,
+  0x2a, 0x00, 0xc5, 0x0c, 0x84, 0x33, 0x98, 0x63, 0x48, 0x82, 0xf2, 0x18,
+  0x43, 0xa8, 0xca, 0x63, 0xb8, 0x21, 0x30, 0x0b, 0x65, 0x96, 0x41, 0x0d,
+  0xd2, 0x20, 0x30, 0x01, 0x2d, 0xe4, 0x33, 0x4b, 0xb0, 0x06, 0x23, 0x06,
+  0x84, 0x11, 0xcc, 0xc7, 0x30, 0x62, 0x50, 0x18, 0x41, 0x7d, 0x04, 0x6b,
+  0x61, 0x41, 0x5b, 0xc8, 0xc7, 0x82, 0xb7, 0x80, 0xcf, 0x2c, 0xc1, 0x1a,
+  0x0c, 0x54, 0x00, 0x4a, 0x1a, 0x08, 0x6a, 0x30, 0xc7, 0x90, 0x04, 0xed,
+  0x31, 0x62, 0x60, 0x18, 0xc1, 0x7e, 0x04, 0xa2, 0x01, 0x1a, 0x83, 0x0c,
+  0x01, 0x69, 0xd4, 0xc6, 0x2c, 0x01, 0x1b, 0x0c, 0x54, 0x04, 0x7e, 0x10,
+  0x06, 0xc2, 0x1a, 0x0c, 0x32, 0x04, 0xa9, 0x71, 0x1b, 0xb3, 0x04, 0x6d,
+  0x30, 0xd0, 0x12, 0xf0, 0x88, 0xc1, 0x23, 0x12, 0x8f, 0x7c, 0xb2, 0xc0,
+  0x06, 0x3c, 0x02, 0x06, 0x03, 0x2d, 0x01, 0x8a, 0x18, 0x7a, 0x21, 0x99,
+  0xc3, 0x47, 0xb0, 0x81, 0xcc, 0x80, 0xc1, 0x20, 0x43, 0x20, 0xec, 0x86,
+  0x05, 0xe1, 0x21, 0x9f, 0x0c, 0xc2, 0x81, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0xd7, 0xd2, 0x07, 0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4,
+  0x50, 0x13, 0xe7, 0x2c, 0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d,
+  0x9b, 0x6d, 0x29, 0x38, 0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b,
+  0x00, 0x03, 0x11, 0x71, 0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71,
+  0x21, 0x13, 0x00, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x5b, 0x06, 0xe0, 0x40, 0x85, 0x2d, 0x83, 0x10, 0xc0, 0xc2, 0x96,
+  0xe1, 0x08, 0x62, 0x61, 0xcb, 0xa0, 0x05, 0xb2, 0xb0, 0x65, 0xf8, 0x82,
+  0x59, 0xd8, 0x32, 0x84, 0x41, 0x40, 0x0b, 0x5b, 0x06, 0x35, 0x08, 0x6a,
+  0x61, 0xcb, 0xf0, 0x06, 0x81, 0x2d, 0x6c, 0x19, 0xec, 0x20, 0xb8, 0x85,
+  0x2d, 0x03, 0x1e, 0x04, 0xb6, 0xb0, 0x65, 0x60, 0x87, 0xe0, 0x16, 0xb6,
+  0x0c, 0xee, 0x10, 0xd8, 0xc2, 0x96, 0x41, 0x2d, 0x82, 0x5b, 0xd8, 0x32,
+  0xb0, 0x45, 0x60, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x24, 0x00, 0x00, 0x00, 0x64, 0xce, 0x41, 0x2c, 0x8d, 0x93, 0x06,
+  0x54, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xdb, 0x0c, 0x00, 0x05,
+  0x33, 0x00, 0xb4, 0xcc, 0x00, 0x8c, 0x35, 0xb0, 0xec, 0x19, 0xca, 0x1f,
+  0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce, 0xde, 0x58, 0x83, 0x5e,
+  0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf, 0xdb, 0xa7, 0xf4, 0xe8,
+  0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a, 0xc2, 0xe8, 0xee, 0xdd,
+  0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25,
+  0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f,
+  0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c,
+  0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2,
+  0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05, 0x33, 0x00, 0x04, 0x8c,
+  0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x46, 0x00, 0x82,
+  0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5, 0x02, 0x0d, 0x37, 0x50,
+  0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43, 0x43, 0xb5, 0xc1, 0x20,
+  0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64, 0x08, 0xa0, 0x6a, 0x96,
+  0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61, 0x48, 0x82, 0xe1, 0x86,
+  0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31, 0x28, 0x8c, 0x40, 0x0f,
+  0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xe8, 0x60, 0xc4, 0xa0, 0x30, 0x02, 0x3e,
+  0xf8, 0xa6, 0x39, 0x06, 0x21, 0xa0, 0x83, 0x11, 0x83, 0xc2, 0x08, 0xfc,
+  0x20, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xa8, 0x83, 0x59, 0x82, 0x62, 0xa0,
+  0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xf4, 0x60, 0x0c, 0x41, 0xc8,
+  0x83, 0x31, 0x84, 0x21, 0x0f, 0x46, 0x0c, 0x0a, 0x23, 0x10, 0x05, 0x21,
+  0x18, 0x31, 0x28, 0x8c, 0x60, 0x14, 0x88, 0x60, 0xb8, 0x21, 0xb8, 0x84,
+  0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c, 0x0c, 0x6c, 0x40, 0x03,
+  0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90, 0x8f, 0x05, 0x1a, 0x7c,
+  0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81, 0x29, 0x0c, 0x32, 0x04,
+  0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64, 0x08, 0xd2, 0xc0, 0x0d,
+  0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4, 0xa0, 0x98, 0x65, 0x40,
+  0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18, 0x31, 0x28, 0x8c, 0x60,
+  0x16, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0xa0, 0x15, 0x46, 0x0c, 0x0a,
+  0x23, 0xa8, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84, 0xa0, 0x15, 0x46, 0x0c,
+  0x0a, 0x23, 0xb8, 0x85, 0x42, 0x0d, 0xe6, 0x18, 0x84, 0xc0, 0x15, 0x66,
+  0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57, 0x10, 0x04, 0x04, 0x3a,
+  0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x0c, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0xc0, 0x06, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0xea, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90,
+  0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d,
+  0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d,
+  0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70,
+  0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48,
+  0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0,
+  0x02, 0x54, 0x1b, 0x8c, 0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x06,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x40, 0x80, 0x05, 0xa8, 0x36, 0x18, 0xc6,
+  0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0x7c, 0xe4, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d,
+  0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d,
+  0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e,
+  0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x3c, 0xb0, 0x03, 0x60, 0x70,
+  0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48,
+  0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0x03, 0x82, 0xfc, 0xff,
+  0xff, 0xff, 0xff, 0x00, 0x30, 0x80, 0x04, 0x54, 0x1b, 0x8c, 0x24, 0x00,
+  0x16, 0xa0, 0xda, 0x60, 0x28, 0x02, 0xb0, 0x00, 0xd5, 0x06, 0x64, 0xf9,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x36, 0x18, 0xcc,
+  0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50, 0x1b, 0xa6, 0xe6, 0xff,
+  0xff, 0xff, 0xff, 0x07, 0x40, 0x01, 0xa4, 0xc1, 0x1d, 0xde, 0xa1, 0x0d,
+  0xc4, 0xa1, 0x1e, 0xd2, 0x81, 0x1d, 0xe8, 0x21, 0x1d, 0xdc, 0x61, 0x1e,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x07, 0x00, 0x00,
+  0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42, 0x60, 0x4c, 0x08, 0x8e,
+  0x09, 0x03, 0x92, 0x28, 0x13, 0x86, 0x25, 0x51, 0x26, 0x04, 0xcc, 0x84,
+  0xa0, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00, 0x00, 0x4d, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4,
+  0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c,
+  0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xc8, 0xc1, 0x0c, 0xc0, 0x30, 0x02,
+  0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3,
+  0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84, 0x41, 0x18, 0x46, 0x18,
+  0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e, 0xe4, 0xa1, 0x1e, 0xc6,
+  0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e, 0xc2, 0x81, 0x1d, 0xf4,
+  0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e, 0xd2, 0x01, 0x1f, 0x50,
+  0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21,
+  0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40, 0x84, 0xa3, 0xa4, 0x29,
+  0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1,
+  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0x38, 0x4d, 0x9a, 0x22, 0x4a,
+  0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0x7e, 0x20,
+  0x8a, 0x00, 0xec, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x26, 0xb8, 0x48,
+  0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2, 0x7f,
+  0x1a, 0x23, 0x00, 0x06, 0x11, 0x1c, 0xa1, 0x24, 0x41, 0x10, 0x08, 0x44,
+  0xb2, 0x34, 0x0f, 0x41, 0x85, 0x28, 0x8a, 0xa2, 0x20, 0xa9, 0x0c, 0x00,
+  0x00, 0x10, 0x55, 0x04, 0x00, 0x20, 0xab, 0x0c, 0x40, 0x51, 0x10, 0x56,
+  0x8c, 0xa2, 0x00, 0x00, 0x00, 0x20, 0xad, 0x0c, 0x45, 0x51, 0x10, 0x57,
+  0x84, 0xa2, 0x20, 0x6f, 0x8e, 0x00, 0x0c, 0xe6, 0x08, 0x82, 0x61, 0x04,
+  0x01, 0x0c, 0x4a, 0x12, 0x34, 0x8f, 0x00, 0x86, 0x62, 0x08, 0xd0, 0x58,
+  0x90, 0x60, 0x79, 0x84, 0x50, 0x0c, 0x01, 0x2a, 0x07, 0x02, 0x52, 0x00,
+  0x1c, 0x46, 0x18, 0xc0, 0x60, 0x10, 0x21, 0x10, 0xe6, 0x08, 0x40, 0x61,
+  0x10, 0xe1, 0x10, 0x06, 0x11, 0x0a, 0x61, 0x10, 0x01, 0x10, 0xa6, 0x00,
+  0x46, 0x00, 0x86, 0x11, 0x08, 0x30, 0x00, 0x00, 0x00, 0x13, 0xb2, 0x70,
+  0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78,
+  0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87, 0x71, 0x78, 0x87, 0x79,
+  0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83, 0x38, 0x70, 0x03, 0x38,
+  0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x90, 0x0e,
+  0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x80, 0x07,
+  0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x6d, 0x90, 0x0e,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0e, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x74, 0x80, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
+  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x20, 0x07,
+  0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07,
+  0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20, 0x07, 0x7a, 0x20, 0x07,
+  0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07,
+  0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07,
+  0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07,
+  0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07,
+  0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x30, 0x07,
+  0x72, 0x30, 0x84, 0x89, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0xc2, 0x4c, 0x40, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+  0x61, 0x2a, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x30,
+  0x17, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x98, 0x0c,
+  0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x86, 0x00,
+  0xc3, 0x00, 0x00, 0x00, 0x10, 0x00, 0xc0, 0x10, 0xa6, 0x02, 0x02, 0x40,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0xd3, 0x01, 0x01, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0xf9, 0x80, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x18, 0xc2, 0x74, 0x40, 0x00, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x0c, 0x61, 0xc8, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x21, 0x8c, 0x19, 0x00, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x90, 0x05, 0x02, 0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0x02, 0x47, 0x00, 0x4a, 0xa0, 0x10, 0x0a, 0xa4, 0x08, 0x0a, 0xa2, 0x80,
+  0x0a, 0x30, 0xa0, 0x0c, 0x0a, 0xa3, 0x50, 0x0a, 0xa6, 0x70, 0x0a, 0xac,
+  0x14, 0x8a, 0xa1, 0x1c, 0x68, 0x2d, 0x9c, 0x11, 0x80, 0x42, 0x28, 0x88,
+  0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x42, 0xc7, 0x12, 0x1e, 0x01, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xc2, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
+  0xb7, 0x21, 0x06, 0x18, 0x40, 0x67, 0x00, 0xa0, 0x41, 0x19, 0x50, 0xb9,
+  0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x80,
+  0x41, 0x73, 0x06, 0x02, 0x18, 0x38, 0x8c, 0x83, 0x20, 0x38, 0x38, 0xb6,
+  0x32, 0x90, 0xb6, 0x32, 0xba, 0x30, 0x36, 0x10, 0xbb, 0x32, 0xb9, 0xb9,
+  0xb4, 0x37, 0x37, 0x90, 0x19, 0x19, 0x18, 0x99, 0x19, 0x17, 0x1a, 0x18,
+  0x1a, 0x10, 0x94, 0xb6, 0x32, 0xba, 0x30, 0x36, 0xb3, 0xb2, 0x96, 0x19,
+  0x19, 0x18, 0x99, 0x19, 0x17, 0x1a, 0x18, 0x9a, 0x94, 0x21, 0xc2, 0x19,
+  0x10, 0x43, 0x0c, 0x30, 0x68, 0xc0, 0x20, 0x02, 0x03, 0x86, 0x45, 0x53,
+  0x19, 0x5d, 0x18, 0xdb, 0x10, 0xe4, 0x0c, 0x0e, 0x30, 0x68, 0xc0, 0xa0,
+  0x01, 0x03, 0x86, 0x5b, 0x58, 0x9a, 0x9c, 0xcb, 0xd8, 0x5b, 0x1b, 0x5c,
+  0x1a, 0x5b, 0x99, 0x0b, 0x59, 0x99, 0xdb, 0x9b, 0x5c, 0xdb, 0xdc, 0x17,
+  0x59, 0xda, 0x5c, 0x98, 0x18, 0x5b, 0xd9, 0x10, 0xe1, 0x0c, 0x12, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e,
+  0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x33, 0x58, 0x58, 0x06, 0x61, 0x69,
+  0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72,
+  0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65,
+  0x74, 0x63, 0x68, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x43,
+  0x84, 0x33, 0x68, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0xb9, 0x91,
+  0x95, 0xc9, 0x7d, 0xd1, 0x85, 0xc9, 0x9d, 0x95, 0xd1, 0x31, 0x0a, 0x4b,
+  0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x72,
+  0x0b, 0x6b, 0x2b, 0xa3, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x33, 0x04,
+  0x39, 0x83, 0x07, 0x0c, 0x98, 0x33, 0x80, 0xce, 0x20, 0x1a, 0x22, 0x9c,
+  0x81, 0x44, 0x26, 0x2c, 0x4d, 0xce, 0x05, 0xee, 0x6d, 0x2e, 0x8d, 0x2e,
+  0xed, 0xcd, 0x8d, 0x4a, 0x58, 0x9a, 0x9c, 0xcb, 0x58, 0x99, 0x1b, 0x5d,
+  0x99, 0x1c, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0xb7, 0xb7, 0x2f, 0xb8, 0x32,
+  0xb9, 0x39, 0xb8, 0xb2, 0x31, 0xba, 0x34, 0xbb, 0x32, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0,
+  0xde, 0xe6, 0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0x86, 0x40, 0x60, 0xc0, 0x9c,
+  0x01, 0x75, 0x06, 0xd5, 0x19, 0x58, 0x67, 0x00, 0x9d, 0x41, 0x74, 0x06,
+  0xd7, 0x19, 0x60, 0x94, 0xc2, 0xd2, 0xe4, 0x5c, 0xcc, 0xe4, 0xc2, 0xce,
+  0xda, 0xca, 0xdc, 0xe8, 0xbe, 0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x68, 0x9d,
+  0x95, 0xb9, 0x95, 0xc9, 0x85, 0xd1, 0x95, 0x91, 0xa1, 0xd4, 0x8c, 0xbd,
+  0xb1, 0xbd, 0xc9, 0x11, 0xd9, 0xd1, 0x7c, 0x99, 0xa5, 0xf0, 0x09, 0x4b,
+  0x93, 0x73, 0x81, 0x2b, 0x93, 0x9b, 0x83, 0x2b, 0x1b, 0xa3, 0x4b, 0xb3,
+  0x2b, 0x63, 0x31, 0xf6, 0xc6, 0xf6, 0x26, 0x37, 0x44, 0x02, 0x83, 0xe6,
+  0x0c, 0xb4, 0x33, 0xd8, 0xce, 0xa0, 0x3a, 0x03, 0xee, 0x0c, 0xa0, 0x33,
+  0x88, 0xce, 0xe0, 0x3a, 0x83, 0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c,
+  0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b,
+  0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7,
+  0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64,
+  0x43, 0x24, 0x30, 0x80, 0xce, 0x40, 0x3b, 0x83, 0xef, 0x0c, 0xaa, 0x33,
+  0xe0, 0xce, 0x00, 0x3a, 0x03, 0x30, 0x38, 0x83, 0xeb, 0x0c, 0xc2, 0x80,
+  0x4a, 0x58, 0x9a, 0x9c, 0x8b, 0x58, 0x9d, 0x99, 0x59, 0x99, 0x1c, 0x9f,
+  0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a, 0x33, 0xb3, 0x32, 0xb9, 0xaf, 0xb9,
+  0x34, 0xbd, 0x32, 0x4a, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61,
+  0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x44, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xe4, 0xca, 0xc2, 0xc8, 0x48, 0x85, 0xa5, 0xc9, 0xb9,
+  0xcc, 0xd1, 0xc9, 0xd5, 0x8d, 0xd1, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d,
+  0xa5, 0xb9, 0x99, 0xbd, 0xb1, 0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x23, 0x33,
+  0x37, 0x26, 0x75, 0x24, 0xf4, 0xf5, 0x56, 0x47, 0x07, 0x57, 0x47, 0x47,
+  0x86, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0xec, 0x8b, 0x2e, 0x0f, 0xae,
+  0x8c, 0x4a, 0x9a, 0x1b, 0x5c, 0x1d, 0xdd, 0x17, 0x5d, 0x1e, 0x5c, 0x19,
+  0x97, 0xb1, 0x37, 0xb6, 0x37, 0xb9, 0xaf, 0xb9, 0xb1, 0x30, 0xb6, 0x32,
+  0x3a, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74,
+  0x68, 0x6f, 0x64, 0x7c, 0xe8, 0xde, 0xdc, 0xca, 0xda, 0xc2, 0xe0, 0xbe,
+  0xcc, 0xc2, 0xc6, 0xe8, 0xde, 0xe4, 0x62, 0xf8, 0xd0, 0xbd, 0xb9, 0x95,
+  0xb5, 0x85, 0xc1, 0x7d, 0x99, 0x85, 0x8d, 0xd1, 0xbd, 0xc9, 0xc9, 0xf0,
+  0x99, 0x23, 0x93, 0xfb, 0xba, 0x43, 0x4b, 0xa3, 0x2b, 0xfb, 0x82, 0x7b,
+  0x4b, 0x73, 0xa3, 0x1b, 0x02, 0x0b, 0x60, 0xc0, 0x80, 0x81, 0x03, 0x06,
+  0xcc, 0x19, 0xa0, 0xc1, 0x19, 0xa4, 0x01, 0x18, 0x38, 0x60, 0xe0, 0x80,
+  0x01, 0x73, 0x06, 0x68, 0x70, 0x06, 0x6a, 0x00, 0x06, 0x11, 0x18, 0x38,
+  0x60, 0xc0, 0x9c, 0x01, 0x1a, 0x9c, 0xc1, 0x1a, 0x80, 0x41, 0x05, 0x06,
+  0x0e, 0x18, 0x30, 0x67, 0x80, 0x06, 0x67, 0xc0, 0x06, 0x60, 0xf0, 0x80,
+  0x81, 0x03, 0x06, 0xcc, 0x19, 0xa0, 0xc1, 0x19, 0xb4, 0x01, 0x18, 0x58,
+  0x60, 0xe0, 0x80, 0x01, 0x73, 0x06, 0x68, 0x70, 0x06, 0x6e, 0x00, 0x06,
+  0x17, 0x18, 0x38, 0x60, 0xc0, 0x9c, 0x01, 0x1a, 0x9c, 0xc1, 0x1b, 0x80,
+  0x01, 0x06, 0x06, 0x0e, 0x18, 0x30, 0x67, 0x80, 0x06, 0x67, 0x00, 0x07,
+  0x8c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2, 0xe0,
+  0xca, 0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x78, 0x85, 0xa5, 0xc9, 0xb9, 0x84,
+  0xc9, 0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0x85, 0xb1, 0xa5, 0x9d,
+  0xb9, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1, 0x99, 0x42, 0x0b, 0x23, 0x2b,
+  0x93, 0x1b, 0x7a, 0x73, 0x9b, 0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0x63, 0x30,
+  0x36, 0x84, 0x0c, 0xc0, 0x80, 0x3a, 0x83, 0x31, 0x38, 0x03, 0x32, 0x00,
+  0x03, 0xe9, 0x0c, 0xca, 0x00, 0x0c, 0x18, 0x30, 0x68, 0xce, 0xc0, 0x0c,
+  0xce, 0xe0, 0x0c, 0xce, 0x20, 0x0e, 0xce, 0x40, 0x0e, 0xc0, 0x40, 0x3a,
+  0x83, 0x39, 0x00, 0x03, 0xe7, 0x0c, 0xa0, 0x33, 0xa0, 0x83, 0x33, 0xb8,
+  0xce, 0xa0, 0x0e, 0x68, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xcd, 0xd0, 0x78,
+  0x33, 0x33, 0x9b, 0x2b, 0xa3, 0x23, 0x62, 0xc6, 0xf6, 0x16, 0x46, 0x37,
+  0x83, 0x37, 0x43, 0xa3, 0x2d, 0x8c, 0x4e, 0x2e, 0x0d, 0x6f, 0x08, 0x05,
+  0x06, 0x0c, 0x18, 0x3c, 0x60, 0xc0, 0x9c, 0xc1, 0x1d, 0x9c, 0x01, 0x1e,
+  0x80, 0xc1, 0x03, 0x06, 0x19, 0x18, 0x30, 0x67, 0x90, 0x07, 0x67, 0xa0,
+  0x07, 0x4c, 0xb2, 0xaa, 0xac, 0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x68,
+  0x90, 0x95, 0x8d, 0xbd, 0x91, 0x95, 0x0d, 0x21, 0x03, 0x30, 0x70, 0xce,
+  0x60, 0x0c, 0xce, 0x80, 0x0c, 0xc0, 0x60, 0x3a, 0x83, 0x32, 0x00, 0x83,
+  0x06, 0x0c, 0x9a, 0x33, 0x30, 0x83, 0x33, 0x38, 0x83, 0x33, 0xd8, 0x83,
+  0x33, 0x90, 0x03, 0x30, 0x98, 0xce, 0x60, 0x0e, 0xc0, 0xe0, 0x39, 0x03,
+  0xe8, 0x0c, 0xf8, 0xe0, 0x0c, 0xae, 0x33, 0xe8, 0x03, 0x2e, 0x61, 0x69,
+  0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x54, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xe6, 0xc2, 0xda, 0xe0, 0xd8, 0xca, 0x88, 0xd1, 0x95, 0xe1,
+  0xd1, 0xd5, 0xc9, 0x95, 0xc9, 0x90, 0xf1, 0x98, 0xb1, 0xbd, 0x85, 0xd1,
+  0xb1, 0x80, 0xcc, 0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xf9, 0x90, 0xa0, 0x2b,
+  0xc3, 0xcb, 0x1a, 0x42, 0x81, 0x81, 0x76, 0x06, 0x7f, 0x70, 0x06, 0x65,
+  0x00, 0x06, 0x0c, 0x18, 0x34, 0x67, 0x00, 0x0a, 0x67, 0x00, 0x9d, 0x41,
+  0x28, 0x9c, 0xc1, 0x75, 0x06, 0xa2, 0x40, 0x8f, 0xae, 0x0c, 0x8f, 0xae,
+  0x4e, 0xae, 0x4c, 0x86, 0xec, 0x2b, 0x4c, 0x4e, 0x2e, 0x2c, 0x8f, 0xc7,
+  0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad,
+  0xcc, 0x87, 0x05, 0x5d, 0x19, 0x5e, 0x95, 0xd5, 0x10, 0x0a, 0x0c, 0xb6,
+  0x33, 0xf8, 0x83, 0x33, 0x28, 0x03, 0x30, 0x68, 0xc0, 0xa0, 0x39, 0x03,
+  0x50, 0x38, 0x03, 0xe8, 0x0c, 0x48, 0xe1, 0x0c, 0xae, 0x33, 0x28, 0x05,
+  0x2e, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72,
+  0x3c, 0xe6, 0xc2, 0xda, 0xe0, 0xd8, 0xca, 0xe4, 0x18, 0xcc, 0x0d, 0x91,
+  0xc0, 0x80, 0x3b, 0x83, 0x53, 0x38, 0x83, 0x32, 0x00, 0x03, 0x06, 0x0c,
+  0x9a, 0x33, 0x80, 0xce, 0x00, 0x15, 0xce, 0xe0, 0x3a, 0x83, 0x54, 0x18,
+  0x02, 0x9d, 0x41, 0x76, 0x06, 0xde, 0x19, 0x88, 0xc1, 0x19, 0xd8, 0xc1,
+  0x19, 0xf8, 0xc1, 0x19, 0x8c, 0xc2, 0x19, 0x98, 0xc2, 0x19, 0xa8, 0xc2,
+  0x10, 0x23, 0x02, 0xce, 0x60, 0x3a, 0x83, 0x55, 0xa0, 0x18, 0x84, 0xa5,
+  0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1,
+  0x95, 0xcd, 0xa1, 0x4c, 0x11, 0x31, 0x7d, 0x65, 0x55, 0x59, 0x7d, 0x99,
+  0xc9, 0x85, 0x9d, 0xb5, 0x95, 0xb9, 0xd1, 0xa5, 0x0c, 0x21, 0xce, 0xc0,
+  0x15, 0xce, 0xa0, 0x15, 0x88, 0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5,
+  0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0xd0, 0x95, 0xe1,
+  0xd1, 0xd5, 0xc9, 0x95, 0xcd, 0x0d, 0x31, 0xce, 0x00, 0x16, 0xce, 0xc0,
+  0x15, 0xce, 0xe0, 0x15, 0x88, 0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5,
+  0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0xcc, 0x85, 0xb5,
+  0xc1, 0xb1, 0x95, 0xc9, 0xcd, 0x0d, 0x31, 0xce, 0x40, 0x16, 0xce, 0xc0,
+  0x15, 0xce, 0x20, 0x16, 0x86, 0x10, 0x67, 0x00, 0x0b, 0x67, 0x20, 0x0b,
+  0xac, 0xbe, 0xb4, 0xa8, 0xa6, 0x62, 0x6a, 0xa6, 0xd0, 0xc2, 0xc8, 0xca,
+  0xe4, 0x86, 0xde, 0xdc, 0xe6, 0xe8, 0xc2, 0xdc, 0xe8, 0xe6, 0xf8, 0xbc,
+  0xb5, 0xb9, 0xa5, 0xc1, 0xbd, 0xd1, 0x95, 0xb9, 0xd1, 0x81, 0x8c, 0xa1,
+  0x85, 0xc9, 0xf1, 0x99, 0x4a, 0x6b, 0x83, 0x63, 0x2b, 0x03, 0x19, 0x5a,
+  0x59, 0x01, 0xa1, 0x12, 0x0a, 0x0a, 0x1a, 0x22, 0x9c, 0x81, 0x2d, 0x0c,
+  0x31, 0xce, 0xa0, 0x16, 0xce, 0xe0, 0x16, 0xd6, 0xc0, 0x1b, 0x62, 0x9c,
+  0x01, 0x1a, 0x9c, 0x01, 0x2e, 0xac, 0x81, 0x37, 0x44, 0x0c, 0xce, 0x80,
+  0x16, 0xce, 0x20, 0x17, 0xd6, 0xc0, 0x3b, 0x83, 0x5c, 0x58, 0x83, 0xef,
+  0x0c, 0x72, 0x61, 0x0d, 0xc0, 0xe0, 0x0c, 0x72, 0x61, 0x0d, 0xc2, 0xe0,
+  0x0c, 0x72, 0x61, 0x0d, 0xc4, 0xe0, 0x0c, 0x72, 0x61, 0x0d, 0xc6, 0xe0,
+  0x0c, 0x72, 0x61, 0x0d, 0xc8, 0xe0, 0x0c, 0x72, 0x61, 0x0d, 0xba, 0x21,
+  0xc6, 0x19, 0xe8, 0xc2, 0x19, 0xe4, 0xc2, 0x1a, 0x80, 0xc1, 0x10, 0xe3,
+  0x0c, 0x74, 0xe1, 0x0c, 0x72, 0x61, 0x0d, 0xba, 0x21, 0xc6, 0x19, 0xe8,
+  0xc2, 0x19, 0xe4, 0xc2, 0x1a, 0x88, 0xc1, 0x10, 0xe3, 0x0c, 0x74, 0xe1,
+  0x0c, 0x72, 0x61, 0x0d, 0xc6, 0x60, 0x88, 0x71, 0x06, 0xba, 0x70, 0x06,
+  0xb9, 0xb0, 0x06, 0x64, 0x30, 0xc4, 0x38, 0x03, 0x5d, 0x38, 0x83, 0x5c,
+  0x58, 0x83, 0x6f, 0x88, 0x71, 0x06, 0xba, 0x70, 0x06, 0xb9, 0xb0, 0x06,
+  0x61, 0x30, 0xc4, 0x38, 0x03, 0x5d, 0x38, 0x83, 0x5c, 0x58, 0x03, 0x6f,
+  0x44, 0xc4, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xed, 0xf0, 0x0e,
+  0xe4, 0x50, 0x0f, 0xec, 0x50, 0x0e, 0x6e, 0x60, 0x0e, 0xec, 0x10, 0x0e,
+  0xe7, 0x30, 0x0f, 0x53, 0x84, 0x60, 0x18, 0xa1, 0xb0, 0x03, 0x3b, 0xd8,
+  0x43, 0x3b, 0xb8, 0x41, 0x3a, 0x90, 0x43, 0x39, 0xb8, 0x03, 0x3d, 0x4c,
+  0x09, 0x8a, 0x11, 0x4b, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x81, 0x3d, 0x94,
+  0x83, 0x3c, 0xcc, 0x43, 0x3a, 0xbc, 0x83, 0x3b, 0x4c, 0x09, 0x8c, 0x11,
+  0x54, 0x38, 0xa4, 0x83, 0x3c, 0xb8, 0x01, 0x3b, 0x84, 0x83, 0x3b, 0x9c,
+  0x43, 0x3d, 0x84, 0xc3, 0x39, 0x94, 0xc3, 0x2f, 0xd8, 0x43, 0x39, 0xc8,
+  0xc3, 0x3c, 0xa4, 0xc3, 0x3b, 0xb8, 0xc3, 0x94, 0x00, 0x19, 0x31, 0x85,
+  0x43, 0x3a, 0xc8, 0x83, 0x1b, 0x8c, 0xc3, 0x3b, 0xb4, 0x03, 0x3c, 0xa4,
+  0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x03, 0x3c, 0xd0, 0x43, 0x3a, 0xbc,
+  0x83, 0x3b, 0xcc, 0xc3, 0x94, 0x41, 0x61, 0x9c, 0x11, 0x4c, 0x38, 0xa4,
+  0x83, 0x3c, 0xb8, 0x81, 0x39, 0xc8, 0x43, 0x38, 0x9c, 0x43, 0x3b, 0x94,
+  0x83, 0x3b, 0xd0, 0xc3, 0x94, 0x80, 0x15, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x35, 0x00, 0x00,
+  0x00, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf, 0xb3, 0x60, 0xad, 0xd3,
+  0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45, 0x51, 0x14, 0x96, 0x30,
+  0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05, 0x03, 0x5c, 0x7e, 0x75,
+  0x17, 0xb7, 0x6d, 0x01, 0x14, 0x80, 0x44, 0x7e, 0x01, 0x48, 0xd3, 0x2f,
+  0x2c, 0x00, 0xf3, 0xf8, 0xd5, 0x5d, 0xdc, 0xb6, 0x09, 0x40, 0x00, 0x12,
+  0xf9, 0x05, 0x20, 0x4d, 0xff, 0xe3, 0x58, 0x7e, 0x71, 0xdb, 0x36, 0x10,
+  0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05, 0x10, 0x48, 0x7e, 0x71,
+  0xdb, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x8f, 0x63,
+  0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x29, 0x84, 0x01, 0x80, 0x44, 0xbe, 0x04,
+  0x30, 0xcf, 0x42, 0xfc, 0x13, 0x71, 0x4d, 0x54, 0x44, 0xfc, 0xf6, 0xf0,
+  0x03, 0x51, 0x04, 0x60, 0x7e, 0x85, 0x17, 0xb7, 0x6d, 0x04, 0x0d, 0x80,
+  0x44, 0xfe, 0xe0, 0x4c, 0x7e, 0x75, 0x17, 0xb7, 0x6d, 0x0b, 0x1b, 0x80,
+  0x44, 0xbe, 0x04, 0x30, 0xcf, 0x42, 0xfc, 0x13, 0x71, 0x4d, 0x54, 0x44,
+  0xfc, 0xf6, 0xe0, 0x57, 0x78, 0x71, 0xdb, 0x86, 0x30, 0x01, 0x48, 0xe4,
+  0x17, 0x80, 0x34, 0xfd, 0x05, 0x10, 0x48, 0x7e, 0x75, 0x17, 0xb7, 0x6d,
+  0x00, 0x10, 0xdb, 0x95, 0xbf, 0xec, 0xbe, 0x7f, 0x11, 0x01, 0x06, 0x43,
+  0x34, 0x93, 0x19, 0x44, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0x7f, 0xc1,
+  0x00, 0x97, 0x5f, 0xdc, 0x36, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0xcb, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x55, 0x00, 0x00, 0x00, 0x14, 0x8f, 0x45, 0x00, 0x81, 0x70, 0xcc,
+  0x41, 0x30, 0x0d, 0x84, 0x07, 0xb4, 0x16, 0x41, 0x09, 0x50, 0x3a, 0xc7,
+  0xc0, 0xe0, 0x01, 0x1e, 0x8c, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xe2,
+  0x08, 0x00, 0x85, 0x23, 0x00, 0x35, 0x40, 0xe0, 0x0c, 0x00, 0x01, 0x63,
+  0x04, 0xef, 0x9e, 0x96, 0xf7, 0x37, 0x46, 0xa0, 0xb3, 0xe6, 0x1c, 0x82,
+  0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x09, 0x06, 0x63, 0x04, 0x20, 0x08,
+  0x82, 0x20, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07,
+  0x21, 0x0b, 0xb2, 0x20, 0x0b, 0xb3, 0x30, 0x07, 0x31, 0x0b, 0xb9, 0x30,
+  0x0b, 0x7d, 0x40, 0xc5, 0x0c, 0xc0, 0x08, 0xc0, 0x0c, 0xc0, 0x58, 0x03,
+  0x08, 0x82, 0x20, 0xfe, 0x81, 0x20, 0x08, 0xe2, 0x1f, 0x08, 0x82, 0x20,
+  0xfe, 0x8d, 0x35, 0xb0, 0xed, 0xfc, 0x93, 0x1e, 0xdb, 0xce, 0x3f, 0xe9,
+  0xb1, 0xed, 0xfc, 0x93, 0xde, 0x58, 0x03, 0x08, 0x82, 0x6c, 0xfd, 0x0b,
+  0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8, 0xd6, 0xbf, 0x30, 0xd6,
+  0x00, 0x82, 0xe0, 0x9a, 0x83, 0x01, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x20,
+  0x08, 0xae, 0x39, 0x18, 0x8c, 0x35, 0x80, 0x20, 0xdd, 0xe6, 0x60, 0x00,
+  0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d, 0x0e, 0x06, 0x63, 0x0d,
+  0xeb, 0x88, 0xc7, 0x2c, 0x18, 0xac, 0x23, 0x1e, 0xb3, 0x60, 0xb0, 0x8e,
+  0x78, 0xcc, 0x82, 0xc1, 0x58, 0x03, 0x08, 0xc2, 0x78, 0x38, 0x06, 0x20,
+  0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87, 0x63, 0x30, 0xd6, 0x20,
+  0xe6, 0x62, 0xda, 0x7f, 0x60, 0xc9, 0xb3, 0xf1, 0x2f, 0x8c, 0xe9, 0xaa,
+  0xe6, 0xbe, 0x30, 0xd6, 0xf0, 0xcf, 0xa4, 0xff, 0xfb, 0x02, 0x5d, 0x83,
+  0x62, 0xfe, 0xb5, 0x70, 0x1c, 0x83, 0xbe, 0x30, 0xd6, 0x30, 0xf7, 0x6d,
+  0x9a, 0xfa, 0x42, 0xeb, 0x86, 0x3c, 0xef, 0x0b, 0x7c, 0xce, 0xfa, 0xf8,
+  0x47, 0xc0, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xc4, 0x3c,
+  0xd8, 0xe7, 0xde, 0x18, 0x81, 0x79, 0xaf, 0xab, 0xec, 0xcd, 0x00, 0x8c,
+  0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed,
+  0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba, 0xf8, 0x37, 0x46, 0x50, 0xab, 0xb5,
+  0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8, 0xf6, 0x34, 0x18, 0x8c, 0x11, 0xf0,
+  0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00, 0x00, 0x00, 0x00, 0x23, 0x06, 0x4a,
+  0x11, 0xbc, 0xc2, 0x1b, 0xb4, 0x81, 0x1c, 0x8c, 0x41, 0x19, 0x90, 0x41,
+  0x30, 0x62, 0xb0, 0x14, 0x41, 0x2c, 0xbc, 0x81, 0x1b, 0xcc, 0xc1, 0x2b,
+  0x90, 0x81, 0x19, 0x94, 0x81, 0x30, 0x86, 0x10, 0xc0, 0xc2, 0x20, 0xc3,
+  0xe0, 0xad, 0xc1, 0x1c, 0x43, 0x20, 0xc4, 0xc2, 0x88, 0xc1, 0x52, 0x04,
+  0xb5, 0x30, 0x07, 0x72, 0x70, 0x07, 0xb2, 0x80, 0x06, 0x6a, 0x90, 0x06,
+  0xc6, 0x18, 0x42, 0x40, 0x0b, 0x73, 0x0c, 0x43, 0x10, 0x0b, 0x87, 0x07,
+  0xea, 0x52, 0x50, 0x06, 0x19, 0x02, 0x33, 0x80, 0x03, 0x23, 0x02, 0xf8,
+  0x8c, 0x37, 0xf0, 0x01, 0x2a, 0xe4, 0xc2, 0x05, 0xea, 0x52, 0x50, 0x06,
+  0x19, 0x82, 0x35, 0xa8, 0x83, 0x11, 0x83, 0xc2, 0x08, 0xcc, 0xa1, 0x08,
+  0xc6, 0x2b, 0x42, 0xa1, 0x15, 0x7c, 0xe1, 0x17, 0xf4, 0xe0, 0x02, 0x75,
+  0x29, 0x28, 0x83, 0x0c, 0x01, 0x1c, 0xe8, 0xc1, 0x88, 0x41, 0x61, 0x04,
+  0xeb, 0xa0, 0x04, 0xe3, 0x15, 0xa6, 0x20, 0x0b, 0xe3, 0x40, 0x0e, 0xa0,
+  0x70, 0x81, 0xba, 0x14, 0x94, 0x41, 0x86, 0xa0, 0x0e, 0xfe, 0x60, 0xc4,
+  0xa0, 0x30, 0x02, 0x78, 0x78, 0x82, 0x39, 0x86, 0x3a, 0x58, 0xd2, 0x61,
+  0x8e, 0x21, 0x38, 0xd2, 0x61, 0x8e, 0x21, 0x18, 0xce, 0x61, 0xbc, 0xe1,
+  0x15, 0x74, 0x01, 0x1d, 0x28, 0x18, 0xc3, 0x0d, 0xc1, 0x1f, 0x04, 0xb3,
+  0x0c, 0x81, 0x10, 0x0c, 0x32, 0x10, 0x7d, 0x70, 0x0a, 0xe3, 0x0d, 0xb3,
+  0xe0, 0x0b, 0xe0, 0x40, 0xc1, 0x18, 0x31, 0x20, 0x8c, 0xc0, 0x1e, 0x86,
+  0x11, 0x83, 0xc2, 0x08, 0xf0, 0x21, 0xc8, 0x03, 0x0b, 0xf2, 0x00, 0x3e,
+  0x23, 0x06, 0x85, 0x11, 0xe0, 0x43, 0xe0, 0x07, 0x36, 0xe8, 0x81, 0x7c,
+  0x4c, 0x0f, 0x82, 0xf8, 0xd8, 0x10, 0xd0, 0x67, 0xc4, 0x80, 0x30, 0x82,
+  0x7e, 0x08, 0x46, 0x0c, 0x0a, 0x23, 0xf8, 0x87, 0x80, 0x0f, 0x2c, 0xe0,
+  0x03, 0xf9, 0xcc, 0x31, 0x98, 0xc2, 0xc2, 0x0f, 0x83, 0x0c, 0xc1, 0x29,
+  0xd8, 0x82, 0x0d, 0x01, 0x7d, 0x06, 0x19, 0x82, 0x54, 0xe0, 0x85, 0x41,
+  0x86, 0xa0, 0xf2, 0x85, 0x59, 0x02, 0x61, 0xa0, 0x22, 0x10, 0x02, 0x36,
+  0x00, 0xc6, 0x1b, 0xca, 0x01, 0x1e, 0x40, 0x82, 0x82, 0x31, 0xdc, 0x10,
+  0xdc, 0x81, 0x33, 0xcb, 0x30, 0x10, 0xc1, 0x20, 0x03, 0x31, 0x0b, 0xbd,
+  0x30, 0xde, 0x90, 0x0e, 0xf4, 0x80, 0x0f, 0x14, 0x8c, 0xf1, 0x86, 0x75,
+  0xb0, 0x87, 0x7c, 0xa0, 0x60, 0x8c, 0x18, 0x20, 0x47, 0x14, 0x13, 0x45,
+  0x77, 0x0c, 0xc1, 0x20, 0x43, 0x50, 0x0b, 0xe8, 0x30, 0xc8, 0x10, 0x2c,
+  0xea, 0x30, 0x4b, 0x40, 0x0c, 0x54, 0x04, 0xc2, 0x80, 0x09, 0xc3, 0x0d,
+  0x61, 0x70, 0x0a, 0xc1, 0x2c, 0x43, 0x31, 0x05, 0xe3, 0x0d, 0xf2, 0xd0,
+  0x0f, 0x2e, 0x41, 0xc1, 0x18, 0x6e, 0x08, 0x54, 0x21, 0x98, 0x65, 0x30,
+  0x8e, 0x60, 0x90, 0xa1, 0x00, 0x07, 0x75, 0x18, 0x6f, 0xb0, 0x87, 0x90,
+  0x58, 0x09, 0x0a, 0xc6, 0x1c, 0xc3, 0x2f, 0x04, 0x35, 0x31, 0xc8, 0x10,
+  0x80, 0xc3, 0x3b, 0x58, 0x50, 0xc8, 0x67, 0x90, 0x21, 0x10, 0x87, 0x7a,
+  0x98, 0x25, 0x68, 0x83, 0xf1, 0x06, 0x7e, 0x38, 0x89, 0x9c, 0xa0, 0x60,
+  0x8c, 0x37, 0xf8, 0x43, 0x4a, 0xcc, 0x04, 0x05, 0x63, 0x90, 0x01, 0x5a,
+  0x07, 0x7d, 0x18, 0x6e, 0x20, 0x62, 0xc1, 0x99, 0x65, 0x40, 0xa4, 0x60,
+  0x0c, 0x41, 0xfa, 0x89, 0xe1, 0x86, 0x60, 0x17, 0x94, 0x59, 0x06, 0x25,
+  0x09, 0x4c, 0xe8, 0x05, 0xf9, 0xcc, 0x12, 0x2c, 0x36, 0xfc, 0x02, 0x7c,
+  0x46, 0x0c, 0x08, 0x23, 0x60, 0x8b, 0xc0, 0x82, 0x7b, 0x90, 0xcf, 0x88,
+  0x41, 0x61, 0x04, 0x6f, 0x11, 0xdc, 0xc3, 0x2c, 0xc1, 0x32, 0x50, 0x01,
+  0x28, 0x89, 0xa0, 0xcc, 0x31, 0xd0, 0x43, 0x70, 0x16, 0x63, 0x08, 0xdb,
+  0x59, 0x0c, 0x37, 0x04, 0xe4, 0xa0, 0xcc, 0x32, 0x34, 0x4c, 0x60, 0x82,
+  0x39, 0xc8, 0x67, 0x96, 0xc0, 0xb1, 0x01, 0x1d, 0xe0, 0x33, 0x62, 0x40,
+  0x18, 0x41, 0x5d, 0x04, 0x16, 0x80, 0x84, 0x7c, 0x46, 0x0c, 0x0a, 0x23,
+  0xc0, 0x8b, 0x00, 0x24, 0x66, 0x09, 0x9c, 0x81, 0x0a, 0x40, 0x61, 0x84,
+  0x66, 0x8e, 0x21, 0x09, 0xde, 0x62, 0x0c, 0x81, 0x0c, 0xda, 0x62, 0xb8,
+  0x21, 0x68, 0x07, 0x65, 0x96, 0x01, 0x7a, 0x02, 0x13, 0xde, 0x41, 0x3e,
+  0xb3, 0x04, 0x91, 0x0d, 0xf1, 0x00, 0x9f, 0x11, 0x03, 0xc2, 0x08, 0xfc,
+  0x22, 0xb0, 0x20, 0x25, 0xe4, 0x33, 0x62, 0x50, 0x18, 0x41, 0x68, 0x04,
+  0x29, 0x31, 0x4b, 0x10, 0x0d, 0x54, 0x00, 0xca, 0x23, 0x40, 0x73, 0x0c,
+  0x49, 0x50, 0x17, 0xb3, 0x04, 0xd2, 0x40, 0x45, 0x20, 0x44, 0x7a, 0x70,
+  0x0c, 0x32, 0x04, 0x29, 0x31, 0x13, 0x73, 0x0c, 0x26, 0x01, 0x06, 0x7c,
+  0x31, 0xc8, 0x10, 0x9c, 0x84, 0x4d, 0xd8, 0x10, 0xc8, 0x67, 0x90, 0x21,
+  0x48, 0x09, 0x9e, 0x98, 0x25, 0x68, 0x83, 0xe1, 0x86, 0x59, 0x80, 0x89,
+  0x60, 0x96, 0x81, 0x02, 0x83, 0x60, 0x90, 0x81, 0x0e, 0x5e, 0x22, 0x27,
+  0xc6, 0x1b, 0xca, 0x02, 0x2e, 0x44, 0x83, 0x82, 0x31, 0xde, 0x70, 0x16,
+  0x72, 0xc1, 0x17, 0x14, 0x8c, 0x39, 0x06, 0x98, 0x08, 0x4c, 0x63, 0x90,
+  0x21, 0x88, 0x09, 0xb0, 0xb0, 0xe0, 0x90, 0xcf, 0x20, 0x43, 0x30, 0x13,
+  0x66, 0x31, 0xdc, 0x70, 0xf4, 0x83, 0x33, 0xcb, 0xf0, 0x55, 0xc1, 0x18,
+  0xc2, 0xb0, 0x1a, 0xc3, 0x0d, 0x01, 0x48, 0x28, 0xb3, 0x0c, 0x97, 0x15,
+  0x98, 0x20, 0x12, 0xf2, 0x99, 0x25, 0xc0, 0x46, 0x0c, 0x08, 0x23, 0xb8,
+  0x8d, 0x61, 0xc4, 0xa0, 0x30, 0x82, 0xdc, 0x08, 0x4a, 0xc2, 0x82, 0x93,
+  0x90, 0x8f, 0x05, 0x29, 0x01, 0x9f, 0x59, 0x02, 0x6c, 0xa0, 0x02, 0x50,
+  0x2c, 0xe1, 0x9a, 0x63, 0xd8, 0x89, 0x60, 0x36, 0xc6, 0x10, 0x98, 0xd9,
+  0x18, 0x6e, 0x08, 0x52, 0x42, 0x99, 0x65, 0xd0, 0xb2, 0xc0, 0x84, 0x95,
+  0x90, 0xcf, 0x2c, 0xc1, 0x36, 0x62, 0x40, 0x18, 0x01, 0x78, 0x0c, 0x23,
+  0x06, 0x85, 0x11, 0x88, 0x47, 0xe0, 0x12, 0x16, 0xc0, 0x84, 0x7c, 0x2c,
+  0x90, 0x09, 0xf8, 0xcc, 0x12, 0x6c, 0x03, 0x15, 0x80, 0x92, 0x09, 0xda,
+  0x1c, 0x43, 0x12, 0xec, 0xc6, 0x18, 0x42, 0x95, 0x1b, 0xc3, 0x0d, 0x81,
+  0x4c, 0x28, 0xb3, 0x0c, 0x1d, 0x17, 0x98, 0x40, 0x13, 0xf2, 0x99, 0x25,
+  0xf0, 0x46, 0x0c, 0x08, 0x23, 0x48, 0x8f, 0x61, 0xc4, 0xa0, 0x30, 0x82,
+  0xf5, 0x08, 0x6e, 0xc2, 0x82, 0x9c, 0x90, 0x8f, 0x05, 0x3b, 0x01, 0x9f,
+  0x59, 0x02, 0x6f, 0xa0, 0x02, 0x50, 0x38, 0xa1, 0x9b, 0x63, 0x48, 0x82,
+  0xf0, 0x18, 0x31, 0x30, 0x8c, 0x20, 0x3e, 0x82, 0xb7, 0x68, 0x8b, 0x41,
+  0x86, 0x20, 0x2e, 0x48, 0x63, 0x96, 0xe0, 0x1b, 0xa8, 0x08, 0xfc, 0x80,
+  0x12, 0xbc, 0x41, 0x86, 0xe0, 0x2e, 0x4c, 0x63, 0x96, 0xa0, 0x0d, 0x66,
+  0x19, 0xc2, 0xa0, 0x0d, 0xf8, 0x61, 0x90, 0xa1, 0x17, 0xf0, 0x42, 0x34,
+  0x46, 0x0c, 0x0a, 0x23, 0x98, 0x8f, 0x60, 0x2d, 0xe6, 0x18, 0xe8, 0x22,
+  0x60, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0xea, 0x63, 0x60, 0x8b, 0x39, 0x06,
+  0x21, 0x68, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0xee, 0xa3, 0x68, 0x8b, 0x39,
+  0x06, 0x21, 0x60, 0x8f, 0x41, 0x86, 0x60, 0x2f, 0x5c, 0x63, 0x90, 0x21,
+  0x28, 0x07, 0xd8, 0x18, 0x6f, 0xb0, 0x8d, 0xf0, 0x98, 0x0f, 0x0a, 0xc6,
+  0x78, 0x03, 0x6e, 0x8c, 0x47, 0x7b, 0x50, 0x30, 0xe6, 0x18, 0x42, 0x23,
+  0xb8, 0x8f, 0x41, 0x86, 0x40, 0x34, 0x62, 0xc3, 0x82, 0x44, 0x3e, 0x83,
+  0x0c, 0x01, 0x69, 0xdc, 0xc6, 0x70, 0xc3, 0xe1, 0x16, 0xce, 0x2c, 0x03,
+  0x1b, 0x88, 0x41, 0x30, 0x86, 0x30, 0xf0, 0xc7, 0x70, 0x43, 0x10, 0x17,
+  0xca, 0x2c, 0x03, 0x19, 0x8c, 0x41, 0x60, 0xc2, 0x5c, 0xc8, 0x67, 0x96,
+  0xa0, 0x0c, 0x46, 0x0c, 0x08, 0x23, 0x40, 0x91, 0x61, 0xc4, 0xa0, 0x30,
+  0x02, 0x15, 0x09, 0xec, 0xc2, 0x02, 0xbc, 0x90, 0x8f, 0x05, 0x7a, 0x01,
+  0x9f, 0x59, 0x82, 0x32, 0x18, 0xa8, 0x00, 0x94, 0x31, 0x10, 0xc8, 0x60,
+  0x8e, 0x81, 0x35, 0x02, 0x12, 0x19, 0x43, 0x60, 0x48, 0x64, 0xb8, 0x21,
+  0xd0, 0x0b, 0x65, 0x96, 0xe1, 0x0c, 0xcc, 0x20, 0x30, 0x81, 0x2f, 0xe4,
+  0x33, 0x4b, 0x80, 0x06, 0x23, 0x06, 0x84, 0x11, 0xc4, 0xc8, 0x30, 0x62,
+  0x50, 0x18, 0xc1, 0x8c, 0x04, 0x7f, 0x61, 0x41, 0x68, 0xc8, 0xc7, 0x82,
+  0xd1, 0x80, 0xcf, 0x2c, 0x01, 0x1a, 0x0c, 0x54, 0x00, 0x8a, 0x19, 0x08,
+  0x67, 0x30, 0xc7, 0x90, 0x04, 0x2c, 0x32, 0x86, 0x50, 0xa9, 0xc8, 0x70,
+  0x43, 0x30, 0x1a, 0xca, 0x2c, 0x83, 0x1a, 0xa4, 0x41, 0x60, 0x42, 0x69,
+  0xc8, 0x67, 0x96, 0x60, 0x0d, 0x46, 0x0c, 0x08, 0x23, 0xd0, 0x91, 0x61,
+  0xc4, 0xa0, 0x30, 0x02, 0x1e, 0x09, 0x50, 0xc3, 0x02, 0xd5, 0x90, 0x8f,
+  0x05, 0xac, 0x01, 0x9f, 0x59, 0x82, 0x35, 0x18, 0xa8, 0x00, 0x94, 0x34,
+  0x10, 0xd4, 0x60, 0x8e, 0x21, 0x09, 0x64, 0x64, 0xc4, 0xc0, 0x30, 0x02,
+  0x31, 0x09, 0xc0, 0xc3, 0x37, 0x06, 0x19, 0x02, 0xf1, 0xa8, 0x8f, 0x59,
+  0x02, 0x36, 0x18, 0xa8, 0x08, 0xfc, 0x20, 0x0c, 0x84, 0x35, 0x18, 0x64,
+  0x08, 0xd0, 0xe3, 0x3e, 0x66, 0x09, 0xda, 0x60, 0xa0, 0x25, 0xe0, 0x11,
+  0x83, 0x47, 0x24, 0x1e, 0xf9, 0x64, 0x81, 0x0d, 0x78, 0x04, 0x0c, 0x06,
+  0x5a, 0x02, 0x14, 0x31, 0xf4, 0x42, 0x32, 0x87, 0x8f, 0x60, 0x03, 0xd7,
+  0x01, 0x83, 0x41, 0x86, 0x40, 0xd8, 0x0f, 0x0b, 0x46, 0x44, 0x3e, 0x19,
+  0x84, 0x03, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xd7, 0xd2, 0x07,
+  0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4, 0x50, 0x13, 0xe7, 0x2c,
+  0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d, 0x9b, 0x6d, 0x29, 0x38,
+  0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b, 0x00, 0x03, 0x11, 0x71,
+  0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71, 0x21, 0x13, 0x00, 0x00,
+  0x00, 0x01, 0x31, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x5b, 0x06, 0xe0,
+  0x98, 0x85, 0x2d, 0x43, 0x70, 0xcc, 0xc2, 0x96, 0xa1, 0x38, 0x66, 0x61,
+  0xcb, 0xf0, 0x05, 0xbb, 0xb0, 0x65, 0x20, 0x83, 0x80, 0x17, 0xb6, 0x0c,
+  0x77, 0x10, 0xf4, 0xc2, 0x96, 0x81, 0x0f, 0x02, 0x5f, 0xd8, 0x32, 0xf8,
+  0x41, 0xf0, 0x0b, 0x5b, 0x86, 0x53, 0x08, 0xc0, 0x61, 0xcb, 0xc0, 0x0a,
+  0x41, 0x38, 0x6c, 0x19, 0x66, 0x21, 0x10, 0x87, 0x2d, 0x43, 0x2d, 0x04,
+  0xe1, 0xb0, 0x65, 0x48, 0x89, 0x40, 0x1c, 0xb6, 0x0c, 0x2b, 0x11, 0x84,
+  0xc3, 0x96, 0xe1, 0x34, 0x02, 0x71, 0xd8, 0x32, 0xa4, 0x46, 0x10, 0x0e,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x67, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
+  0x00, 0x14, 0xcf, 0x41, 0x30, 0x0d, 0xe4, 0x06, 0x94, 0x8e, 0x00, 0x8c,
+  0x35, 0x00, 0x81, 0x40, 0xe0, 0x0c, 0x00, 0x05, 0x33, 0x00, 0x54, 0xcc,
+  0x00, 0x8c, 0x35, 0xb0, 0xec, 0x19, 0xca, 0x1f, 0xea, 0x97, 0xb1, 0xfa,
+  0xe5, 0xa7, 0x2e, 0xce, 0xde, 0x58, 0x83, 0x5e, 0x83, 0x3b, 0xee, 0xa9,
+  0x78, 0x6e, 0xdb, 0xdf, 0xdb, 0xa7, 0xf4, 0xe8, 0x8d, 0x35, 0xac, 0x73,
+  0xcc, 0xa2, 0x5e, 0x1a, 0xc2, 0xe8, 0xee, 0xdd, 0x6d, 0xac, 0xda, 0xdf,
+  0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30,
+  0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b,
+  0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3,
+  0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39,
+  0xeb, 0xe3, 0x1f, 0x05, 0x33, 0x00, 0x04, 0x8c, 0x00, 0x8c, 0x11, 0x80,
+  0x20, 0x08, 0x82, 0x60, 0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x00,
+  0x00, 0x83, 0x0c, 0xd5, 0x02, 0x0d, 0x37, 0x50, 0x42, 0x30, 0xcb, 0x10,
+  0x08, 0xc1, 0x1c, 0x43, 0x43, 0xc5, 0xc1, 0x20, 0x43, 0xe0, 0x48, 0x16,
+  0x64, 0xf2, 0x19, 0x64, 0x08, 0xa0, 0x6a, 0x96, 0x20, 0x19, 0x6e, 0xc8,
+  0x90, 0x60, 0x96, 0x61, 0x48, 0x82, 0xe1, 0x86, 0x2d, 0x09, 0x66, 0x19,
+  0x88, 0x22, 0x18, 0x31, 0x28, 0x8c, 0xe0, 0x0f, 0x3a, 0x69, 0x8e, 0xa1,
+  0x0a, 0xf0, 0x60, 0xc4, 0xa0, 0x30, 0x82, 0x50, 0xf8, 0xa6, 0x39, 0x06,
+  0x21, 0xc8, 0x83, 0x11, 0x83, 0xc2, 0x08, 0x46, 0x21, 0x0c, 0xa8, 0x39,
+  0x06, 0x21, 0xc0, 0x83, 0x59, 0x82, 0x62, 0xa0, 0x22, 0x10, 0x08, 0x6e,
+  0x18, 0x43, 0x08, 0xfc, 0x60, 0x0c, 0x41, 0xf0, 0x83, 0x31, 0x84, 0x81,
+  0x0f, 0x46, 0x0c, 0x0a, 0x23, 0x38, 0x05, 0x21, 0x18, 0x31, 0x28, 0x8c,
+  0x00, 0x15, 0x88, 0x60, 0xb8, 0x21, 0xb8, 0x84, 0x59, 0x06, 0xe3, 0x08,
+  0x06, 0x19, 0x8e, 0x6c, 0x0c, 0x6c, 0x40, 0x03, 0xf9, 0x58, 0x80, 0xc1,
+  0xc7, 0x8a, 0x34, 0x90, 0x8f, 0x05, 0x1a, 0x7c, 0x6c, 0x08, 0xe8, 0x33,
+  0xc7, 0x60, 0x06, 0x81, 0x2a, 0x0c, 0x32, 0x04, 0x67, 0xb0, 0x06, 0x16,
+  0x20, 0xf2, 0x19, 0x64, 0x08, 0xd2, 0xc0, 0x0d, 0x66, 0x09, 0x8e, 0x81,
+  0x8a, 0x40, 0x30, 0xc4, 0xa0, 0x98, 0x65, 0x40, 0x92, 0x6c, 0x90, 0x21,
+  0x20, 0x03, 0x37, 0x18, 0x31, 0x28, 0x8c, 0x00, 0x17, 0x02, 0x34, 0x98,
+  0x63, 0x70, 0x83, 0x20, 0x16, 0x46, 0x0c, 0x0a, 0x23, 0xd0, 0x85, 0x21,
+  0x0d, 0xe6, 0x18, 0x84, 0x40, 0x16, 0x46, 0x0c, 0x0a, 0x23, 0xe0, 0x85,
+  0x42, 0x0d, 0xe6, 0x18, 0x84, 0x20, 0x16, 0x66, 0x09, 0x92, 0x81, 0x92,
+  0x80, 0x14, 0x02, 0x57, 0x10, 0x04, 0x04, 0x3a, 0x06, 0x19, 0x02, 0x36,
+  0xb0, 0x83, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x30, 0x1b, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00,
+  0x00, 0xc9, 0x06, 0x00, 0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04,
+  0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08,
+  0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b,
+  0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44,
+  0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21,
+  0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6,
+  0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00, 0x00, 0xe8, 0x00, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00,
+  0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90, 0x87, 0x77, 0xc0, 0x87,
+  0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d, 0xda, 0x80, 0x1d, 0xca,
+  0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8,
+  0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d, 0xc8, 0x81, 0x1e, 0xd0,
+  0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07,
+  0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87,
+  0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07,
+  0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4,
+  0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc,
+  0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda,
+  0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2,
+  0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2,
+  0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08,
+  0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07,
+  0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03,
+  0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8,
+  0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8,
+  0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03,
+  0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07,
+  0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87,
+  0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea,
+  0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x60, 0x83, 0x21, 0x10, 0xc0, 0x02, 0x54, 0x1b, 0x8c,
+  0xa1, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x10, 0x08, 0xb0, 0x00, 0xd5, 0x06,
+  0xa3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x8f,
+  0x18, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x12, 0x50, 0x11, 0xe1, 0x00,
+  0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0,
+  0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b,
+  0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b,
+  0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b,
+  0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03, 0x90, 0x07, 0x76, 0x00,
+  0x0c, 0xee, 0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5, 0x90, 0x0e, 0xec, 0x40,
+  0x0f, 0xe9, 0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x60,
+  0x0e, 0xf2, 0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0xef, 0x90,
+  0x0e, 0xee, 0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d, 0x50, 0x0e, 0xec, 0x90,
+  0x0e, 0xed, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94, 0x43, 0x1b,
+  0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8, 0x43, 0x1b,
+  0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81, 0x3b, 0xbc, 0x83, 0x3b,
+  0xb4, 0x01, 0x3b, 0x94, 0x43, 0x38, 0x98, 0x03, 0x40, 0x0f, 0xf2, 0x50,
+  0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x90, 0x0e, 0xee, 0x60,
+  0x0e, 0xf3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3, 0x3c, 0xb4, 0x81, 0x39,
+  0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20,
+  0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xf3, 0x90,
+  0x0e, 0xe7, 0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d, 0xa0, 0x0f, 0xe5, 0x20,
+  0x0f, 0xef, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40,
+  0xb8, 0xc3, 0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43, 0x38, 0xc0, 0x03, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a,
+  0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0x31, 0x0f, 0xf4, 0x10,
+  0x0e, 0xe3, 0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2, 0xf0, 0x0e, 0xf4, 0x50,
+  0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d, 0x20, 0x0e, 0xf5, 0x60,
+  0x0e, 0xe6, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xfa, 0x50,
+  0x0e, 0x00, 0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3, 0x3c, 0x84, 0x83, 0x39,
+  0x94, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d,
+  0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x6c, 0x40, 0x8e,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x06, 0x90, 0x80, 0x6a, 0x83, 0x81,
+  0x04, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x44, 0x00, 0x16, 0xa0, 0xda, 0x80,
+  0x28, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06,
+  0x63, 0xf9, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0xc3, 0xc4,
+  0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x28, 0x80, 0x34, 0xb8, 0xc3, 0x3b,
+  0xb4, 0x81, 0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03, 0x3d, 0xa4, 0x83, 0x3b,
+  0xcc, 0x03, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41, 0x31, 0x21, 0x30, 0x26,
+  0x0c, 0x07, 0x92, 0x4c, 0x18, 0x14, 0x24, 0x99, 0x10, 0x2c, 0x13, 0x02,
+  0x06, 0x89, 0x20, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4,
+  0x4c, 0x10, 0xb8, 0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08,
+  0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11,
+  0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x41, 0x84, 0x41, 0x18, 0x46, 0x18, 0x80, 0x1c, 0x28, 0x66,
+  0xa2, 0xe6, 0x81, 0x1e, 0xe4, 0xa1, 0x1e, 0xc6, 0x81, 0x1e, 0xdc, 0xa0,
+  0x1d, 0xca, 0x81, 0x1e, 0xc2, 0x81, 0x1d, 0xf4, 0x40, 0x0f, 0xda, 0x21,
+  0x1c, 0xe8, 0x41, 0x1e, 0xd2, 0x01, 0x1f, 0x50, 0x60, 0x1c, 0x24, 0x4d,
+  0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03, 0x81, 0x84,
+  0xe2, 0x18, 0x44, 0x40, 0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff,
+  0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08, 0x80,
+  0x41, 0x04, 0x25, 0xb8, 0x48, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02,
+  0x98, 0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x18, 0xa1,
+  0x24, 0x41, 0x10, 0x08, 0x44, 0xb2, 0x2c, 0x0d, 0x39, 0x85, 0x28, 0x8a,
+  0xa2, 0x20, 0xa8, 0x0c, 0x00, 0x00, 0x90, 0x54, 0x04, 0x00, 0x20, 0xaa,
+  0x0c, 0x40, 0x51, 0x90, 0x55, 0x8c, 0xa2, 0x00, 0x00, 0x00, 0x20, 0xac,
+  0x0c, 0x45, 0x51, 0x90, 0x56, 0x84, 0xa2, 0x20, 0x6e, 0x8e, 0x20, 0x98,
+  0x23, 0x00, 0x83, 0x61, 0x04, 0xe1, 0x2b, 0x48, 0xb0, 0x34, 0x82, 0x07,
+  0x7a, 0x00, 0x85, 0x03, 0x01, 0x29, 0xf0, 0xcd, 0x11, 0x80, 0xc2, 0x20,
+  0x02, 0x20, 0x4c, 0x01, 0x8c, 0x00, 0x0c, 0x23, 0x0c, 0xdf, 0x20, 0x42,
+  0x20, 0x0c, 0x22, 0x1c, 0xc2, 0x20, 0x42, 0x21, 0x0c, 0x23, 0x10, 0x1f,
+  0x00, 0x13, 0xb2, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x76, 0x08, 0x87,
+  0x71, 0x78, 0x87, 0x79, 0xc0, 0x87, 0x38, 0x80, 0x03, 0x37, 0x88, 0x83,
+  0x38, 0x70, 0x03, 0x38, 0xd8, 0x70, 0x1b, 0xe5, 0xd0, 0x06, 0xf0, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x90, 0x0e, 0x71, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0,
+  0x06, 0xe9, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90,
+  0x0e, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x6d, 0x90, 0x0e, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x6d, 0x90, 0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0e, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0e, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x72, 0x40, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x73, 0x20,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x6d, 0x60,
+  0x0f, 0x74, 0x80, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x6d, 0x60, 0x0f, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x6d, 0x60, 0x0f, 0x79, 0x60, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0,
+  0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x79, 0x20,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50,
+  0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x7a, 0x50, 0x07, 0x71, 0x20, 0x07, 0x7a, 0x50,
+  0x07, 0x71, 0x20, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00,
+  0x07, 0x72, 0x40, 0x07, 0x6d, 0xe0, 0x0e, 0x78, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x30, 0x07, 0x72, 0x30, 0x84, 0x79, 0x00, 0x00, 0x08, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x44, 0x40, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x0c, 0x61, 0x26, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x30, 0x15, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x43, 0x98, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0x21, 0x4c, 0x86, 0x00, 0xc3, 0x00, 0x00, 0x00, 0x10, 0x00, 0xc0, 0x10,
+  0x66, 0x02, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0xb3,
+  0x01, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0xe9, 0x80,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x6c, 0x40, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x61, 0xc4, 0x00, 0x08, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0xfa, 0x46, 0x00, 0x4a, 0xa0, 0x10, 0x0a, 0xa4,
+  0x08, 0x0a, 0xa2, 0x80, 0x0a, 0x30, 0xa0, 0x0c, 0x0a, 0xa3, 0x50, 0x0a,
+  0xa6, 0x70, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c, 0xa8, 0x2c, 0x9c, 0x11,
+  0x80, 0x42, 0x28, 0x88, 0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x22, 0xc7,
+  0x12, 0x1e, 0x01, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xae, 0x01, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0xc6, 0xf7, 0x8c, 0x01, 0x40, 0x06,
+  0x64, 0x40, 0xe5, 0x6e, 0x0c, 0x2d, 0x4c, 0xee, 0x6b, 0x2e, 0x4d, 0xaf,
+  0x6c, 0x88, 0xf1, 0x31, 0x63, 0x20, 0x7c, 0x0d, 0xe3, 0x20, 0x08, 0x0e,
+  0x8e, 0xad, 0x0c, 0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c,
+  0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85,
+  0x06, 0x86, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac,
+  0x65, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88,
+  0x30, 0x06, 0xc4, 0x10, 0xe3, 0x63, 0x3e, 0xe8, 0x5b, 0x58, 0x34, 0x95,
+  0xd1, 0x85, 0xb1, 0x0d, 0x41, 0xc6, 0xe0, 0xf8, 0x98, 0x8f, 0xf9, 0x16,
+  0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65,
+  0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73,
+  0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x31, 0x48, 0xc8, 0x85, 0xa5, 0xc9,
+  0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0x85, 0xcd,
+  0xd1, 0x7d, 0xb5, 0x85, 0xd1, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0xc6, 0x60, 0x61, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c,
+  0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95,
+  0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1,
+  0x7d, 0x91, 0xa5, 0xcd, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xc6, 0xa0,
+  0x61, 0x14, 0x96, 0x26, 0xe7, 0x22, 0x57, 0xe6, 0x46, 0x56, 0x26, 0xf7,
+  0x45, 0x17, 0x26, 0x77, 0x56, 0x46, 0xc7, 0x28, 0x2c, 0x4d, 0xce, 0x25,
+  0x4c, 0xee, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0xec, 0xcb, 0x2d, 0xac, 0xad,
+  0x8c, 0x86, 0x19, 0xdb, 0x5b, 0x18, 0x1d, 0xcd, 0x10, 0x64, 0x0c, 0x9e,
+  0x6f, 0x19, 0x03, 0x68, 0x0c, 0xa2, 0x21, 0xc2, 0x18, 0x48, 0x64, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xe0, 0xde, 0xe6, 0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0xa8,
+  0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0x95, 0xb9, 0xd1, 0x95, 0xc9, 0x51, 0x0a,
+  0x4b, 0x93, 0x73, 0x71, 0x7b, 0xfb, 0x82, 0x2b, 0x93, 0x9b, 0x83, 0x2b,
+  0x1b, 0xa3, 0x4b, 0xb3, 0x2b, 0x23, 0x13, 0x96, 0x26, 0xe7, 0x12, 0x26,
+  0x77, 0xf6, 0xe5, 0x16, 0xd6, 0x56, 0x46, 0x04, 0xee, 0x6d, 0x2e, 0x8d,
+  0x2e, 0xed, 0xcd, 0x6d, 0x08, 0xf4, 0x2d, 0x63, 0x40, 0x8d, 0x41, 0x35,
+  0x06, 0xd6, 0x18, 0x40, 0x63, 0x10, 0x8d, 0xc1, 0x35, 0x06, 0x18, 0xa5,
+  0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba,
+  0xaf, 0x34, 0x37, 0xb8, 0x3a, 0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x29, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca,
+  0xe4, 0xe6, 0xe0, 0xca, 0xc6, 0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd,
+  0xb1, 0xbd, 0xc9, 0x0d, 0x91, 0x3e, 0x66, 0x0c, 0xb4, 0x31, 0xd8, 0xc6,
+  0xa0, 0x1a, 0x03, 0x6e, 0x0c, 0xa0, 0x31, 0x88, 0xc6, 0xe0, 0x1a, 0x83,
+  0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a,
+  0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc,
+  0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74,
+  0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0xa4, 0xef, 0x19, 0x03,
+  0x6d, 0x0c, 0xbe, 0x31, 0xa8, 0xc6, 0x80, 0x1b, 0x03, 0x68, 0x0c, 0xc0,
+  0x60, 0x0c, 0xae, 0x31, 0x08, 0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62,
+  0x75, 0x66, 0x66, 0x65, 0x72, 0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea,
+  0xcc, 0xcc, 0xca, 0xe4, 0xbe, 0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5,
+  0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5,
+  0xb9, 0x91, 0x95, 0xe1, 0x11, 0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b,
+  0x23, 0x23, 0x15, 0x96, 0x26, 0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46,
+  0xf7, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x95, 0xe6, 0x66, 0xf6, 0xc6, 0xc2,
+  0x8c, 0xed, 0x2d, 0x8c, 0x8e, 0xcc, 0xdc, 0x98, 0xd4, 0x91, 0xd0, 0xd7,
+  0x5b, 0x1d, 0x1d, 0x5c, 0x1d, 0x1d, 0x19, 0xba, 0x32, 0x3c, 0xba, 0x3a,
+  0xb9, 0xb2, 0x2f, 0xba, 0x3c, 0xb8, 0x32, 0x2a, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5c, 0xc6, 0xde, 0xd8, 0xde, 0xe4,
+  0xbe, 0xe6, 0xc6, 0xc2, 0xd8, 0xca, 0xe8, 0xd0, 0xbd, 0xb9, 0x95, 0xb5,
+  0x85, 0xc1, 0x7d, 0xb5, 0x95, 0xd1, 0xa1, 0xbd, 0x91, 0xf1, 0xa1, 0x7b,
+  0x73, 0x2b, 0x6b, 0x0b, 0x83, 0xfb, 0x32, 0x0b, 0x1b, 0xa3, 0x7b, 0x93,
+  0x8b, 0xe1, 0x43, 0xf7, 0xe6, 0x56, 0xd6, 0x16, 0x06, 0xf7, 0x65, 0x16,
+  0x36, 0x46, 0xf7, 0x26, 0x27, 0xc3, 0x67, 0x8e, 0x4c, 0xee, 0xeb, 0x0e,
+  0x2d, 0x8d, 0xae, 0xec, 0x0b, 0xee, 0x2d, 0xcd, 0x8d, 0x6e, 0x08, 0x2c,
+  0x7c, 0xcb, 0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18, 0xa4, 0xc1, 0xd7,
+  0x7c, 0xcd, 0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x81, 0x1a, 0x7c, 0xd0, 0xd7,
+  0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18, 0xac, 0xc1, 0x47, 0x7d, 0xcd, 0xb7,
+  0x8c, 0x01, 0x1a, 0x8c, 0x01, 0x1b, 0x7c, 0xce, 0xd7, 0x7c, 0xcb, 0x18,
+  0xa0, 0xc1, 0x18, 0xb4, 0xc1, 0x57, 0x7d, 0xcd, 0xb7, 0x8c, 0x01, 0x1a,
+  0x8c, 0x81, 0x1b, 0x7c, 0xd6, 0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18,
+  0xbc, 0xc1, 0x77, 0x7d, 0xcd, 0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x01, 0x1c,
+  0x30, 0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83,
+  0x2b, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12,
+  0x26, 0x77, 0xf6, 0x45, 0x97, 0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76,
+  0xe6, 0xf6, 0x35, 0x97, 0xa6, 0x57, 0xc6, 0x67, 0x0a, 0x2d, 0x8c, 0xac,
+  0x4c, 0x6e, 0xe8, 0xcd, 0x6d, 0x8e, 0x2e, 0xcc, 0x8d, 0x6e, 0x8e, 0xc1,
+  0xd8, 0x10, 0x32, 0xf8, 0xa6, 0x31, 0x18, 0x83, 0x31, 0x20, 0x83, 0x2f,
+  0x1a, 0x83, 0x32, 0xf8, 0x96, 0x8f, 0x19, 0x03, 0x33, 0x18, 0x83, 0x33,
+  0x18, 0x83, 0x38, 0x18, 0x03, 0x39, 0xf8, 0xa2, 0x31, 0x98, 0x83, 0xaf,
+  0x19, 0x03, 0x68, 0x0c, 0xe8, 0x60, 0x0c, 0xae, 0x31, 0xa8, 0x03, 0x1a,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x34, 0xde, 0xcc, 0xcc, 0xe6, 0xca,
+  0xe8, 0x88, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xcd, 0xe0, 0xcd, 0xd0, 0x68,
+  0x0b, 0xa3, 0x93, 0x4b, 0xc3, 0x1b, 0x42, 0x7d, 0xcb, 0xe7, 0x7c, 0xcb,
+  0x18, 0xdc, 0xc1, 0x18, 0xe0, 0xc1, 0xe7, 0x7c, 0xd8, 0xb7, 0x8c, 0x41,
+  0x1e, 0x8c, 0x81, 0x1e, 0x30, 0xc9, 0xaa, 0xb2, 0x22, 0x2a, 0x1b, 0x7b,
+  0x23, 0x2b, 0xa3, 0x41, 0x56, 0x36, 0xf6, 0x46, 0x56, 0x36, 0x84, 0x0c,
+  0xbe, 0x66, 0x0c, 0xc6, 0x60, 0x0c, 0xc8, 0xe0, 0x93, 0xc6, 0xa0, 0x0c,
+  0x3e, 0xe6, 0x63, 0xc6, 0xc0, 0x0c, 0xc6, 0xe0, 0x0c, 0xc6, 0x60, 0x0f,
+  0xc6, 0x40, 0x0e, 0x3e, 0x69, 0x0c, 0xe6, 0xe0, 0x73, 0xc6, 0x00, 0x1a,
+  0x03, 0x3e, 0x18, 0x83, 0x6b, 0x0c, 0xfa, 0x80, 0x4b, 0x58, 0x9a, 0x9c,
+  0x0b, 0x5d, 0x19, 0x1e, 0x5d, 0x9d, 0x5c, 0x19, 0x95, 0xb0, 0x34, 0x39,
+  0x97, 0xb9, 0xb0, 0x36, 0x38, 0xb6, 0x32, 0x62, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c,
+  0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x24, 0xe8, 0xca, 0xf0,
+  0xb2, 0x86, 0x50, 0x5f, 0x36, 0x06, 0x7f, 0x30, 0x06, 0x65, 0xf0, 0x2d,
+  0x1f, 0x33, 0x06, 0xa0, 0x30, 0x06, 0xd0, 0x18, 0x84, 0xc2, 0x18, 0x5c,
+  0x63, 0x20, 0x0a, 0x2c, 0xe8, 0xca, 0xf0, 0xaa, 0xac, 0x86, 0x50, 0x9f,
+  0x36, 0x06, 0x7f, 0x30, 0x06, 0x65, 0xf0, 0x31, 0x1f, 0x33, 0x06, 0xa0,
+  0x30, 0x06, 0xd0, 0x18, 0x84, 0xc2, 0x18, 0x5c, 0x63, 0x40, 0x0a, 0x5c,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xe6, 0xc2, 0xda, 0xe0, 0xd8, 0xca, 0xe4, 0x78,
+  0xcc, 0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0x31, 0x98, 0x1b, 0x22, 0x7d,
+  0xdb, 0x18, 0x98, 0xc2, 0x18, 0x94, 0xc1, 0xb7, 0x7c, 0xcc, 0x18, 0x40,
+  0x63, 0x70, 0x0a, 0x63, 0x70, 0x8d, 0x01, 0x2a, 0x0c, 0x81, 0xc6, 0x20,
+  0x1b, 0x03, 0x6f, 0x0c, 0xc4, 0x60, 0x0c, 0xec, 0x60, 0x0c, 0xfc, 0x60,
+  0x0c, 0x46, 0x61, 0x0c, 0x4a, 0x61, 0x0c, 0x52, 0x61, 0x88, 0xf1, 0x00,
+  0x63, 0x30, 0x8d, 0x81, 0x2a, 0xb0, 0xfa, 0xd2, 0xa2, 0x9a, 0x8a, 0xa9,
+  0x99, 0x42, 0x0b, 0x23, 0x2b, 0x93, 0x1b, 0x7a, 0x73, 0x9b, 0xa3, 0x0b,
+  0x73, 0xa3, 0x9b, 0xe3, 0xf3, 0xd6, 0xe6, 0x96, 0x06, 0xf7, 0x46, 0x57,
+  0xe6, 0x46, 0x07, 0x32, 0x86, 0x16, 0x26, 0xc7, 0x67, 0x2a, 0xad, 0x0d,
+  0x8e, 0xad, 0x0c, 0x64, 0x68, 0x65, 0x05, 0x84, 0x4a, 0x28, 0x28, 0x68,
+  0x88, 0x30, 0x06, 0xae, 0x30, 0xc4, 0x18, 0x83, 0x56, 0x18, 0x83, 0x57,
+  0x28, 0x83, 0x6e, 0x88, 0x31, 0x06, 0x68, 0x30, 0x06, 0xb0, 0x50, 0x06,
+  0xdd, 0x10, 0x31, 0x18, 0x03, 0x56, 0x18, 0x83, 0x58, 0x28, 0x83, 0x6e,
+  0x0c, 0x62, 0xa1, 0x0c, 0xbc, 0x31, 0x88, 0x85, 0x32, 0xf8, 0xc6, 0x20,
+  0x16, 0xca, 0x00, 0x0c, 0xc6, 0x20, 0x16, 0xca, 0x20, 0x0c, 0xc6, 0x20,
+  0x16, 0xca, 0x40, 0x0c, 0xc6, 0x20, 0x16, 0xca, 0x60, 0x0c, 0xc6, 0x20,
+  0x16, 0xca, 0x80, 0x1b, 0x62, 0x8c, 0x81, 0x2c, 0x8c, 0x41, 0x2c, 0x94,
+  0x81, 0xc7, 0x31, 0x08, 0x4b, 0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b, 0x9b,
+  0x6b, 0x99, 0x1b, 0x7b, 0x83, 0x2b, 0x9b, 0x43, 0x99, 0x22, 0x62, 0xfa,
+  0x72, 0xb2, 0x8a, 0x91, 0xf9, 0x32, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73,
+  0xa3, 0x4b, 0x19, 0x42, 0x8c, 0x41, 0x2d, 0x8c, 0x01, 0x2d, 0x10, 0x0b,
+  0x4b, 0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b,
+  0x83, 0x2b, 0x6b, 0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0x9b, 0x1b,
+  0x62, 0x8c, 0xc1, 0x2d, 0x8c, 0x41, 0x2d, 0x8c, 0x81, 0x2d, 0x10, 0x0b,
+  0x4b, 0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b,
+  0x83, 0x2b, 0x6b, 0x99, 0x0b, 0x6b, 0x83, 0x63, 0x2b, 0x93, 0x9b, 0x1b,
+  0x62, 0x8c, 0x41, 0x2e, 0x8c, 0x41, 0x2d, 0x8c, 0x01, 0x2e, 0x0c, 0x21,
+  0xc6, 0xe0, 0x16, 0xc6, 0x20, 0x17, 0x86, 0x18, 0x63, 0x20, 0x0b, 0x63,
+  0x10, 0x0b, 0x65, 0xf0, 0x0d, 0x31, 0xc6, 0x40, 0x16, 0xc6, 0x20, 0x16,
+  0xca, 0x80, 0x1b, 0x62, 0x8c, 0x81, 0x2c, 0x8c, 0x41, 0x2c, 0x94, 0x41,
+  0x18, 0x0c, 0x31, 0xc6, 0x40, 0x16, 0xc6, 0x20, 0x16, 0xca, 0x40, 0x0c,
+  0x86, 0x18, 0x63, 0x20, 0x0b, 0x63, 0x10, 0x0b, 0x65, 0x30, 0x06, 0x43,
+  0x8c, 0x31, 0x90, 0x85, 0x31, 0x88, 0x85, 0x32, 0x00, 0x83, 0x21, 0xc6,
+  0x18, 0xc8, 0xc2, 0x18, 0xc4, 0x42, 0x19, 0x74, 0x23, 0x22, 0x76, 0x60,
+  0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x77, 0x20, 0x87, 0x7a, 0x60,
+  0x87, 0x72, 0x70, 0x03, 0x73, 0x60, 0x87, 0x70, 0x38, 0x87, 0x79, 0x98,
+  0x22, 0x04, 0xc3, 0x08, 0x85, 0x1d, 0xd8, 0xc1, 0x1e, 0xda, 0xc1, 0x0d,
+  0xd2, 0x81, 0x1c, 0xca, 0xc1, 0x1d, 0xe8, 0x61, 0x4a, 0x50, 0x8c, 0x58,
+  0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d, 0xec, 0xa1, 0x1c, 0xe4, 0x61, 0x1e,
+  0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x4a, 0x60, 0x8c, 0xa0, 0xc2, 0x21, 0x1d,
+  0xe4, 0xc1, 0x0d, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xea, 0x21, 0x1c,
+  0xce, 0xa1, 0x1c, 0x7e, 0xc1, 0x1e, 0xca, 0x41, 0x1e, 0xe6, 0x21, 0x1d,
+  0xde, 0xc1, 0x1d, 0xa6, 0x04, 0xc8, 0x88, 0x29, 0x1c, 0xd2, 0x41, 0x1e,
+  0xdc, 0x60, 0x1c, 0xde, 0xa1, 0x1d, 0xe0, 0x21, 0x1d, 0xd8, 0xa1, 0x1c,
+  0x7e, 0xe1, 0x1d, 0xe0, 0x81, 0x1e, 0xd2, 0xe1, 0x1d, 0xdc, 0x61, 0x1e,
+  0xa6, 0x0c, 0x0a, 0xe3, 0x8c, 0x60, 0xc2, 0x21, 0x1d, 0xe4, 0xc1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xe1, 0x1c, 0xda, 0xa1, 0x1c, 0xdc, 0x81, 0x1e,
+  0xa6, 0x04, 0xab, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x71, 0x20, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x56, 0x90, 0xfd,
+  0x73, 0x6d, 0x6b, 0xcf, 0xb3, 0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74,
+  0xd5, 0xfd, 0x17, 0x45, 0x51, 0x14, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17,
+  0x80, 0x34, 0xfd, 0x8f, 0x63, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x11, 0x34,
+  0x00, 0x12, 0xf9, 0x83, 0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x29, 0x6c,
+  0x00, 0x12, 0xf9, 0x12, 0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51,
+  0x11, 0xf1, 0xdb, 0x83, 0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0xc2, 0x04, 0x20,
+  0x91, 0x5f, 0x00, 0xd2, 0xf4, 0x17, 0x40, 0x20, 0xf9, 0xd5, 0x5d, 0xdc,
+  0xb6, 0x05, 0x50, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0xbf, 0xb0, 0x00,
+  0xcc, 0xe3, 0x57, 0x77, 0x71, 0xdb, 0x96, 0x30, 0x01, 0x48, 0xe4, 0x17,
+  0x80, 0x34, 0xfd, 0x05, 0x03, 0x5c, 0x7e, 0x75, 0x17, 0xb7, 0x6d, 0x02,
+  0x10, 0x80, 0x44, 0x7e, 0x01, 0x48, 0xd3, 0xff, 0x38, 0x96, 0x5f, 0xdc,
+  0xb6, 0x01, 0x44, 0x6c, 0x57, 0xfe, 0xe7, 0x5b, 0xdb, 0x7f, 0x11, 0x01,
+  0x06, 0x43, 0x34, 0x93, 0x0d, 0x44, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d,
+  0x7f, 0x01, 0x04, 0x92, 0x5f, 0xdc, 0xb6, 0x19, 0x44, 0x00, 0x12, 0xf9,
+  0x05, 0x20, 0x4d, 0x7f, 0xc1, 0x00, 0x97, 0x5f, 0xdc, 0x36, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x13, 0x04, 0x72,
+  0x10, 0x0b, 0x04, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0xd4, 0x8e, 0x45,
+  0x00, 0x81, 0x70, 0xcc, 0x41, 0x2c, 0xcc, 0x83, 0x07, 0x94, 0x8e, 0x35,
+  0x00, 0x03, 0x31, 0xc7, 0xb0, 0x30, 0x78, 0x30, 0xc7, 0xb0, 0xe0, 0x01,
+  0x1e, 0x8c, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0x65, 0x11, 0x94, 0x00,
+  0x81, 0x63, 0x09, 0x01, 0x30, 0x02, 0x40, 0xdf, 0x0c, 0x00, 0x79, 0x23,
+  0x00, 0x35, 0x40, 0xc0, 0x0c, 0x00, 0x05, 0x33, 0x00, 0x33, 0x00, 0x73,
+  0x10, 0xb4, 0xa0, 0x0b, 0xb4, 0xb0, 0x07, 0x24, 0xcc, 0x00, 0x50, 0x31,
+  0x03, 0x30, 0x02, 0x30, 0x03, 0x30, 0xd6, 0x00, 0x82, 0x20, 0x88, 0x7f,
+  0x20, 0x08, 0x82, 0xf8, 0x07, 0x82, 0x20, 0x88, 0x7f, 0x63, 0x0d, 0x6c,
+  0x3b, 0xff, 0xa4, 0xc7, 0xb6, 0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4,
+  0x37, 0xd6, 0x00, 0x82, 0x20, 0x5b, 0xff, 0x02, 0x08, 0x82, 0x6c, 0xfd,
+  0x0b, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x8c, 0x35, 0x80, 0x20, 0xb8, 0xe6,
+  0x60, 0x00, 0x82, 0xe0, 0x9a, 0x83, 0x01, 0x08, 0x82, 0x6b, 0x0e, 0x06,
+  0x63, 0x0d, 0x20, 0x48, 0xb7, 0x39, 0x18, 0x80, 0x20, 0xdd, 0xe6, 0x60,
+  0x00, 0x82, 0x74, 0x9b, 0x83, 0xc1, 0x58, 0xc3, 0x3a, 0xe2, 0x31, 0x0b,
+  0x06, 0xeb, 0x88, 0xc7, 0x2c, 0x18, 0xac, 0x23, 0x1e, 0xb3, 0x60, 0x30,
+  0xd6, 0x00, 0x82, 0x30, 0x1e, 0x8e, 0x01, 0x08, 0xc2, 0x78, 0x38, 0x06,
+  0x20, 0x08, 0xe3, 0xe1, 0x18, 0x8c, 0x35, 0x88, 0xb9, 0x98, 0xf6, 0x1f,
+  0x58, 0xf2, 0x6c, 0xfc, 0x0b, 0x63, 0xba, 0xaa, 0xb9, 0x2f, 0x8c, 0x35,
+  0xfc, 0x33, 0xe9, 0xff, 0xbe, 0x40, 0xd7, 0xa0, 0x98, 0x7f, 0x2d, 0x1c,
+  0xc7, 0xa0, 0x2f, 0x8c, 0x35, 0xcc, 0x7d, 0x9b, 0xa6, 0xbe, 0xd0, 0xba,
+  0x21, 0xcf, 0xfb, 0x02, 0x9f, 0xb3, 0x3e, 0xfe, 0x11, 0x30, 0x46, 0x00,
+  0x82, 0x20, 0x48, 0x82, 0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x08, 0x06,
+  0x63, 0x04, 0x3a, 0x6b, 0xce, 0x21, 0x18, 0x8c, 0x11, 0xbc, 0x7b, 0x5a,
+  0xde, 0xdf, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xc4, 0x3c,
+  0xd8, 0xe7, 0xde, 0x18, 0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0x80,
+  0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x0b, 0x63,
+  0x04, 0x7d, 0x2c, 0xba, 0xf8, 0x37, 0x46, 0x50, 0xab, 0xb5, 0xda, 0x7e,
+  0x63, 0x04, 0xb2, 0xe8, 0xf6, 0x34, 0x18, 0x8c, 0x11, 0xf0, 0xf0, 0xaa,
+  0xd3, 0xdd, 0x08, 0x00, 0x00, 0xe3, 0x0d, 0x73, 0xe0, 0x07, 0xaf, 0x40,
+  0xc1, 0x18, 0x6e, 0x08, 0x9e, 0x60, 0x96, 0x21, 0x10, 0x82, 0x11, 0x03,
+  0xa5, 0x08, 0x68, 0x81, 0x0e, 0xe4, 0xe0, 0x0e, 0xc8, 0xe0, 0x0c, 0xca,
+  0x80, 0x18, 0x31, 0x50, 0x8a, 0xa0, 0x16, 0xe8, 0x60, 0x0e, 0xf0, 0xa0,
+  0x0c, 0xd0, 0xc0, 0x0c, 0x8a, 0x41, 0x06, 0x61, 0x0c, 0xde, 0x60, 0x90,
+  0x41, 0x28, 0x83, 0x38, 0x18, 0x64, 0x10, 0x82, 0x39, 0x38, 0x3d, 0x50,
+  0x97, 0x82, 0x32, 0xc8, 0x10, 0xa4, 0x81, 0x1c, 0x18, 0x11, 0xc0, 0x67,
+  0xbc, 0xc1, 0x0f, 0x54, 0x61, 0x17, 0x2e, 0x50, 0x97, 0x82, 0x32, 0xc8,
+  0x10, 0xb8, 0xc1, 0x1d, 0x8c, 0x18, 0x14, 0x46, 0x70, 0x0e, 0x45, 0x30,
+  0xc7, 0xf0, 0x06, 0x41, 0x38, 0x8c, 0x57, 0x90, 0x02, 0x2c, 0x84, 0x83,
+  0x38, 0xe0, 0xc1, 0x05, 0xea, 0x52, 0x50, 0x06, 0x19, 0x02, 0x3a, 0xe8,
+  0x83, 0x11, 0x83, 0xc2, 0x08, 0xda, 0x61, 0x09, 0xe6, 0x18, 0x8c, 0xc0,
+  0x1c, 0xc6, 0x2b, 0x54, 0xc1, 0x16, 0xce, 0x01, 0x1d, 0xfe, 0xe0, 0x02,
+  0x75, 0x29, 0x28, 0x83, 0x0c, 0x81, 0x1e, 0x8c, 0xc2, 0x88, 0x41, 0x61,
+  0x04, 0xf3, 0x10, 0x05, 0x73, 0x0c, 0x46, 0x90, 0x0e, 0xb3, 0x04, 0xc4,
+  0x70, 0x43, 0xc7, 0x06, 0xc1, 0x2c, 0xc3, 0x40, 0x04, 0x23, 0x06, 0x4a,
+  0x11, 0xc0, 0x03, 0x2c, 0xb8, 0xc2, 0x2c, 0x80, 0xc2, 0x28, 0x84, 0x02,
+  0x18, 0x8c, 0x18, 0x28, 0x45, 0x10, 0x0f, 0xb0, 0xf0, 0x0a, 0xb4, 0x10,
+  0x0a, 0xa4, 0x20, 0x0a, 0x61, 0x30, 0xc8, 0x10, 0x80, 0x82, 0x29, 0x0c,
+  0x32, 0x0c, 0xa0, 0xc0, 0x0a, 0x83, 0x0c, 0xc2, 0x1f, 0xb8, 0xc2, 0x20,
+  0x83, 0x10, 0xc0, 0xc2, 0xdd, 0x82, 0xba, 0x14, 0x94, 0x41, 0x86, 0xc0,
+  0x14, 0x5e, 0xc1, 0x88, 0x00, 0x3e, 0xe3, 0x0d, 0xbb, 0x70, 0x0e, 0xf8,
+  0x70, 0x81, 0xba, 0x14, 0x94, 0x41, 0x86, 0x60, 0x15, 0x68, 0x61, 0xc4,
+  0xa0, 0x30, 0x02, 0x92, 0x28, 0x82, 0x39, 0x06, 0x56, 0x08, 0xfc, 0x61,
+  0xbc, 0x22, 0x1c, 0xda, 0xc1, 0x1f, 0xfe, 0xa1, 0x16, 0x2e, 0x50, 0x97,
+  0x82, 0x32, 0xc8, 0x10, 0xc4, 0x82, 0x2e, 0x8c, 0x18, 0x14, 0x46, 0xa0,
+  0x12, 0x4b, 0x30, 0xc7, 0x60, 0x04, 0x23, 0x31, 0x5e, 0x71, 0x0e, 0xf3,
+  0x40, 0x12, 0x25, 0xc1, 0x0b, 0x17, 0xa8, 0x4b, 0x41, 0x19, 0x64, 0x08,
+  0x6e, 0x01, 0x1c, 0x46, 0x0c, 0x0a, 0x23, 0x80, 0x89, 0x28, 0x98, 0x63,
+  0x30, 0x02, 0x93, 0x98, 0x25, 0x20, 0x06, 0x3a, 0x02, 0x3e, 0x08, 0x84,
+  0x01, 0x2e, 0x84, 0x39, 0x86, 0x60, 0x14, 0x48, 0x62, 0xbc, 0x01, 0x1e,
+  0xf6, 0x21, 0x25, 0x28, 0x18, 0xc3, 0x0d, 0x41, 0x2b, 0x04, 0xb3, 0x0c,
+  0x85, 0x11, 0x0c, 0x32, 0x10, 0xbf, 0x80, 0x0e, 0xe3, 0x0d, 0xf4, 0xf0,
+  0x0f, 0x21, 0x41, 0xc1, 0x18, 0x31, 0x20, 0x8c, 0xc0, 0x26, 0x86, 0x11,
+  0x83, 0xc2, 0x08, 0x70, 0x22, 0xd8, 0x05, 0x0b, 0x76, 0x01, 0x3e, 0x23,
+  0x06, 0x85, 0x11, 0xe0, 0x44, 0x00, 0x0e, 0x36, 0xf0, 0x82, 0x7c, 0x8c,
+  0x17, 0x82, 0xf8, 0xd8, 0x10, 0xd0, 0x67, 0xc4, 0x80, 0x30, 0x82, 0x9e,
+  0x08, 0x46, 0x0c, 0x0a, 0x23, 0xf8, 0x89, 0xc0, 0x17, 0x2c, 0xf0, 0x05,
+  0xf9, 0xcc, 0x31, 0xa0, 0xc3, 0xd2, 0x13, 0x83, 0x0c, 0x41, 0x3a, 0xdc,
+  0x83, 0x0d, 0x01, 0x7d, 0x06, 0x19, 0x82, 0x75, 0xe8, 0x87, 0x41, 0x86,
+  0xa0, 0xfa, 0x87, 0x59, 0x02, 0x63, 0xa0, 0x22, 0x10, 0x0a, 0x36, 0x20,
+  0xc6, 0x1b, 0x4c, 0x22, 0x26, 0xc2, 0x82, 0x82, 0x31, 0xdc, 0x10, 0xd8,
+  0x82, 0x33, 0xcb, 0x70, 0x20, 0xc1, 0x20, 0x03, 0x51, 0x0f, 0xfe, 0x30,
+  0xde, 0xa0, 0x12, 0x35, 0x91, 0x13, 0x14, 0x8c, 0xf1, 0x06, 0x96, 0xb8,
+  0x09, 0x9d, 0xa0, 0x60, 0x8c, 0x18, 0x20, 0x47, 0x14, 0x17, 0x45, 0x77,
+  0x0c, 0xc1, 0x20, 0x43, 0x70, 0x0f, 0x29, 0x31, 0xc8, 0x10, 0x2c, 0x2b,
+  0x31, 0x4b, 0x80, 0x0c, 0x54, 0x04, 0xc2, 0x81, 0x19, 0xc3, 0x0d, 0x61,
+  0x60, 0x0e, 0xc1, 0x2c, 0x43, 0x72, 0x05, 0xe3, 0x0d, 0x33, 0xe1, 0x13,
+  0x6f, 0x41, 0xc1, 0x18, 0x6e, 0x08, 0xd2, 0x21, 0x98, 0x65, 0x50, 0x96,
+  0x60, 0x90, 0xa1, 0x10, 0x89, 0x95, 0x18, 0x6f, 0xb8, 0x09, 0xb1, 0x60,
+  0x0b, 0x0a, 0xc6, 0x1c, 0x43, 0x48, 0x04, 0x76, 0x31, 0xc8, 0x10, 0x88,
+  0x04, 0x4c, 0x58, 0x50, 0xc8, 0x67, 0x90, 0x21, 0x20, 0x09, 0x9b, 0x98,
+  0x25, 0x88, 0x83, 0xf1, 0x86, 0x9e, 0x40, 0x0b, 0xbd, 0xa0, 0x60, 0x8c,
+  0x37, 0xfc, 0x84, 0x5a, 0xd0, 0x05, 0x05, 0x63, 0x90, 0x01, 0x6a, 0x89,
+  0x9d, 0x18, 0x6e, 0x20, 0xe0, 0xc1, 0x99, 0x65, 0x60, 0xac, 0x60, 0x0c,
+  0x41, 0x02, 0x8d, 0xe1, 0x86, 0x20, 0x1f, 0x94, 0x59, 0x06, 0xa7, 0x09,
+  0x4c, 0xd8, 0x07, 0xf9, 0xcc, 0x12, 0x3c, 0x36, 0xf4, 0x03, 0x7c, 0x46,
+  0x0c, 0x08, 0x23, 0x60, 0x8d, 0xc0, 0x02, 0x90, 0x90, 0xcf, 0x88, 0x41,
+  0x61, 0x04, 0xaf, 0x11, 0x88, 0xc4, 0x2c, 0xc1, 0x33, 0x50, 0x01, 0x28,
+  0x8d, 0xe0, 0xcc, 0x31, 0xd8, 0x44, 0x80, 0x1a, 0x63, 0x08, 0x1b, 0x6a,
+  0x0c, 0x37, 0x04, 0x22, 0xa1, 0xcc, 0x32, 0x44, 0x50, 0x60, 0x02, 0x49,
+  0xc8, 0x67, 0x96, 0x40, 0xb2, 0xc1, 0x24, 0xe0, 0x33, 0x62, 0x40, 0x18,
+  0x41, 0x6d, 0x04, 0x16, 0xa4, 0x84, 0x7c, 0x46, 0x0c, 0x0a, 0x23, 0xc0,
+  0x8d, 0x60, 0x25, 0x66, 0x09, 0xa4, 0x81, 0x0a, 0x40, 0x81, 0x84, 0x68,
+  0x8e, 0x21, 0x09, 0x60, 0x63, 0x0c, 0x81, 0x0c, 0x5c, 0x63, 0xb8, 0x21,
+  0x58, 0x09, 0x65, 0x96, 0x81, 0x9a, 0x02, 0x13, 0x5a, 0x42, 0x3e, 0xb3,
+  0x04, 0x95, 0x0d, 0x2f, 0x01, 0x9f, 0x11, 0x03, 0xc2, 0x08, 0x7c, 0x23,
+  0xb0, 0x40, 0x26, 0xe4, 0x33, 0x62, 0x50, 0x18, 0x41, 0x78, 0x04, 0x34,
+  0x31, 0x4b, 0x50, 0x0d, 0x54, 0x00, 0xca, 0x24, 0x50, 0x73, 0x0c, 0x49,
+  0x60, 0x1b, 0xb3, 0x04, 0xd6, 0x40, 0x45, 0x20, 0x54, 0x7a, 0xb0, 0x0c,
+  0x32, 0x04, 0x6b, 0x41, 0x17, 0x73, 0x0c, 0x68, 0x01, 0x06, 0xbd, 0x31,
+  0xc8, 0x10, 0xa4, 0xc5, 0x5d, 0xd8, 0x10, 0xc8, 0x67, 0x90, 0x21, 0x58,
+  0x8b, 0xbe, 0x98, 0x25, 0x88, 0x83, 0xe1, 0x86, 0x59, 0xf0, 0x89, 0x60,
+  0x96, 0x01, 0x23, 0x83, 0x60, 0x90, 0x81, 0x0e, 0xe2, 0x42, 0x2f, 0xc6,
+  0x1b, 0x4c, 0x23, 0x36, 0xc6, 0x83, 0x82, 0x31, 0xde, 0x80, 0x1a, 0xb3,
+  0xd1, 0x1b, 0x14, 0x8c, 0x39, 0x06, 0xb9, 0x08, 0xce, 0x63, 0x90, 0x21,
+  0x98, 0x8b, 0xd0, 0xb0, 0xe0, 0x90, 0xcf, 0x20, 0x43, 0x50, 0x17, 0xa7,
+  0x31, 0xdc, 0x70, 0xf0, 0x84, 0x33, 0xcb, 0x30, 0x06, 0x59, 0x30, 0x86,
+  0x30, 0xb0, 0xc7, 0x70, 0x43, 0xf0, 0x13, 0xca, 0x2c, 0xc3, 0xa6, 0x05,
+  0x26, 0x84, 0x85, 0x7c, 0x66, 0x09, 0xb8, 0x11, 0x03, 0xc2, 0x08, 0xee,
+  0x63, 0x18, 0x31, 0x28, 0x8c, 0x20, 0x3f, 0x02, 0xb2, 0xb0, 0xc0, 0x2c,
+  0xe4, 0x63, 0x01, 0x5a, 0xc0, 0x67, 0x96, 0x80, 0x1b, 0xa8, 0x00, 0x14,
+  0x4d, 0xd8, 0xe6, 0x18, 0xfa, 0x22, 0xa0, 0x8f, 0x31, 0x04, 0x86, 0x3e,
+  0x86, 0x1b, 0x02, 0xb4, 0x50, 0x66, 0x19, 0xbc, 0x2e, 0x30, 0x41, 0x2d,
+  0xe4, 0x33, 0x4b, 0xf0, 0x8d, 0x18, 0x10, 0x46, 0x00, 0x22, 0xc3, 0x88,
+  0x41, 0x61, 0x04, 0x22, 0x12, 0xb4, 0x85, 0x05, 0x6f, 0x21, 0x1f, 0x0b,
+  0xe2, 0x02, 0x3e, 0xb3, 0x04, 0xdf, 0x40, 0x05, 0xa0, 0x74, 0x82, 0x37,
+  0xc7, 0x90, 0x04, 0xfc, 0x31, 0x86, 0x50, 0xe9, 0xc7, 0x70, 0x43, 0x10,
+  0x17, 0xca, 0x2c, 0x43, 0x18, 0x80, 0x41, 0x60, 0xc2, 0x5c, 0xc8, 0x67,
+  0x96, 0x40, 0x0c, 0x46, 0x0c, 0x08, 0x23, 0x48, 0x91, 0x61, 0xc4, 0xa0,
+  0x30, 0x82, 0x15, 0x09, 0xec, 0xc2, 0x02, 0xbc, 0x90, 0x8f, 0x05, 0x7a,
+  0x01, 0x9f, 0x59, 0x02, 0x31, 0x18, 0xa8, 0x00, 0x14, 0x30, 0x10, 0xc2,
+  0x60, 0x8e, 0x21, 0x09, 0x44, 0x64, 0xc4, 0xc0, 0x30, 0x82, 0x18, 0x09,
+  0x62, 0xe3, 0x35, 0x06, 0x19, 0x82, 0xd9, 0x28, 0x8f, 0x59, 0x82, 0x31,
+  0x18, 0xa8, 0x08, 0xfc, 0x00, 0x13, 0xc4, 0x60, 0x90, 0x21, 0xc8, 0x8d,
+  0xf3, 0x98, 0x25, 0x88, 0x83, 0x59, 0x86, 0x32, 0x88, 0x03, 0x7e, 0x18,
+  0x64, 0xe8, 0x05, 0xdd, 0x18, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0x66, 0x24,
+  0x68, 0x8d, 0x39, 0x06, 0xdb, 0x08, 0x5a, 0x64, 0xc4, 0xa0, 0x30, 0x82,
+  0x1a, 0x19, 0x5c, 0x63, 0x8e, 0x41, 0x08, 0x5c, 0x64, 0xc4, 0xa0, 0x30,
+  0x82, 0x1b, 0x29, 0x5e, 0x63, 0x8e, 0x41, 0x08, 0x5a, 0x64, 0x90, 0x21,
+  0xe8, 0x8d, 0xf7, 0x18, 0x64, 0x08, 0xca, 0x21, 0x3e, 0xc6, 0x1b, 0xee,
+  0x43, 0x44, 0x68, 0x84, 0x82, 0x31, 0xde, 0x90, 0x1f, 0x24, 0xe2, 0x22,
+  0x14, 0x8c, 0x39, 0x86, 0xf1, 0x08, 0x70, 0x64, 0x90, 0x21, 0x20, 0x0f,
+  0xf9, 0xb0, 0x20, 0x91, 0xcf, 0x20, 0x43, 0x60, 0x1e, 0xf8, 0x31, 0xdc,
+  0x70, 0xb4, 0x86, 0x33, 0xcb, 0x00, 0x07, 0x66, 0x10, 0x8c, 0x21, 0x0c,
+  0x3d, 0x32, 0xdc, 0x10, 0xc0, 0x86, 0x32, 0xcb, 0x80, 0x06, 0x67, 0x10,
+  0x98, 0x20, 0x1b, 0xf2, 0x99, 0x25, 0x48, 0x83, 0x11, 0x03, 0xc2, 0x08,
+  0xd0, 0x64, 0x18, 0x31, 0x28, 0x8c, 0x40, 0x4d, 0x82, 0xda, 0xb0, 0xe0,
+  0x36, 0xe4, 0x63, 0x41, 0x6e, 0xc0, 0x67, 0x96, 0x20, 0x0d, 0x06, 0x2a,
+  0x00, 0xe5, 0x0c, 0x04, 0x34, 0x98, 0x63, 0x70, 0x8f, 0xa0, 0x4c, 0xc6,
+  0x10, 0x98, 0x32, 0x19, 0x6e, 0x08, 0x72, 0x43, 0x99, 0x65, 0x58, 0x03,
+  0x35, 0x08, 0x4c, 0xd8, 0x0d, 0xf9, 0xcc, 0x12, 0xb0, 0xc1, 0x88, 0x01,
+  0x61, 0x04, 0x71, 0x32, 0x8c, 0x18, 0x14, 0x46, 0x30, 0x27, 0x81, 0x6f,
+  0x58, 0x00, 0x1e, 0xf2, 0xb1, 0x40, 0x3c, 0xe0, 0x33, 0x4b, 0xc0, 0x06,
+  0x03, 0x15, 0x80, 0xa2, 0x06, 0xc2, 0x1a, 0xcc, 0x31, 0x24, 0x41, 0x9b,
+  0x8c, 0x21, 0x54, 0x6b, 0x32, 0xdc, 0x10, 0x88, 0x87, 0x32, 0xcb, 0xe0,
+  0x06, 0x6d, 0x10, 0x98, 0x40, 0x1e, 0xf2, 0x99, 0x25, 0x78, 0x83, 0x11,
+  0x03, 0xc2, 0x08, 0xf4, 0x64, 0x18, 0x31, 0x28, 0x8c, 0x80, 0x4f, 0x82,
+  0xf3, 0xb0, 0x20, 0x3d, 0xe4, 0x63, 0xc1, 0x7a, 0xc0, 0x67, 0x96, 0xe0,
+  0x0d, 0x06, 0x2a, 0x00, 0xa5, 0x0d, 0x04, 0x37, 0x98, 0x63, 0x48, 0x82,
+  0x39, 0x19, 0x31, 0x30, 0x8c, 0x40, 0x54, 0x02, 0x11, 0x01, 0x91, 0x41,
+  0x86, 0x80, 0x44, 0x6c, 0x64, 0x96, 0x00, 0x0e, 0x06, 0x2a, 0x02, 0x3f,
+  0x28, 0x03, 0xe1, 0x0d, 0x06, 0x19, 0x02, 0x15, 0xc1, 0x91, 0x59, 0x82,
+  0x38, 0x18, 0x68, 0x09, 0x78, 0x44, 0xe1, 0x11, 0x8b, 0x47, 0xc6, 0x40,
+  0x16, 0xe0, 0x80, 0x47, 0xc8, 0x60, 0xa0, 0x25, 0x40, 0x11, 0x45, 0x2f,
+  0x2c, 0x73, 0x18, 0x03, 0x02, 0x0e, 0x68, 0x88, 0x0c, 0x06, 0x19, 0x02,
+  0x81, 0x47, 0x2c, 0x20, 0x13, 0xf9, 0x64, 0x10, 0x0e, 0x04, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x17, 0xd3, 0x07, 0xff, 0x5c, 0xe3, 0x20,
+  0x31, 0xa1, 0xd4, 0xf4, 0x50, 0x13, 0xe7, 0x2c, 0x4e, 0xd4, 0x55, 0xf8,
+  0x5f, 0xac, 0x6e, 0x5d, 0x9b, 0x6d, 0x29, 0x38, 0x8d, 0x34, 0x01, 0xcd,
+  0x44, 0xd6, 0x39, 0x7b, 0x00, 0x03, 0x11, 0x71, 0x4e, 0x23, 0x4d, 0x40,
+  0x33, 0x49, 0x3e, 0x71, 0x21, 0x13, 0x00, 0x00, 0x00, 0x01, 0x31, 0x00,
+  0x00, 0x19, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x98, 0x85, 0x2d, 0x03,
+  0x71, 0xe8, 0xc2, 0x96, 0xa1, 0x38, 0x74, 0x61, 0xcb, 0x20, 0x06, 0x87,
+  0x2e, 0x6c, 0x19, 0xc6, 0xe0, 0xd0, 0x85, 0x2d, 0x83, 0x28, 0x04, 0xbb,
+  0xb0, 0x65, 0x38, 0x85, 0x80, 0x17, 0xb6, 0x0c, 0xba, 0x10, 0xf4, 0xc2,
+  0x96, 0xe1, 0x17, 0x02, 0x5f, 0xd8, 0x32, 0x84, 0x43, 0xf0, 0x0b, 0x5b,
+  0x06, 0x75, 0x08, 0x66, 0x61, 0xcb, 0xf0, 0x0e, 0x01, 0x38, 0x6c, 0x19,
+  0xec, 0x21, 0x08, 0x87, 0x2d, 0x03, 0x3e, 0x04, 0xe0, 0xb0, 0x65, 0x60,
+  0x8b, 0x20, 0x1c, 0xb6, 0x0c, 0x6e, 0x11, 0x80, 0xc3, 0x96, 0x41, 0x3d,
+  0x82, 0x70, 0xd8, 0x32, 0xb0, 0x47, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0xd4, 0xce, 0x41,
+  0x2c, 0xcc, 0xd3, 0x06, 0x94, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40,
+  0xdf, 0x0c, 0x00, 0x05, 0x33, 0x00, 0x54, 0xcc, 0x00, 0x8c, 0x35, 0xb0,
+  0xec, 0x19, 0xca, 0x1f, 0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce,
+  0xde, 0x58, 0x83, 0x5e, 0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf,
+  0xdb, 0xa7, 0xf4, 0xe8, 0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a,
+  0xc2, 0xe8, 0xee, 0xdd, 0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b,
+  0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb,
+  0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9,
+  0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea,
+  0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05,
+  0x33, 0x00, 0x04, 0x8c, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60,
+  0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5,
+  0x02, 0x0d, 0x37, 0x50, 0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43,
+  0x43, 0xc5, 0xc1, 0x20, 0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64,
+  0x08, 0xa0, 0x6a, 0x96, 0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61,
+  0x48, 0x82, 0xe1, 0x86, 0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31,
+  0x28, 0x8c, 0xc0, 0x0f, 0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xf0, 0x60, 0xc4,
+  0xa0, 0x30, 0x02, 0x50, 0xf8, 0xa6, 0x39, 0x06, 0x21, 0xc8, 0x83, 0x11,
+  0x83, 0xc2, 0x08, 0x44, 0x21, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xc0, 0x83,
+  0x59, 0x82, 0x62, 0xa0, 0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xfc,
+  0x60, 0x0c, 0x41, 0xf0, 0x83, 0x31, 0x84, 0x81, 0x0f, 0x46, 0x0c, 0x0a,
+  0x23, 0x30, 0x05, 0x21, 0x18, 0x31, 0x28, 0x8c, 0xe0, 0x14, 0x88, 0x60,
+  0xb8, 0x21, 0xb8, 0x84, 0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c,
+  0x0c, 0x6c, 0x40, 0x03, 0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90,
+  0x8f, 0x05, 0x1a, 0x7c, 0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81,
+  0x2a, 0x0c, 0x32, 0x04, 0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64,
+  0x08, 0xd2, 0xc0, 0x0d, 0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4,
+  0xa0, 0x98, 0x65, 0x40, 0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18,
+  0x31, 0x28, 0x8c, 0xe0, 0x16, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0x20,
+  0x16, 0x46, 0x0c, 0x0a, 0x23, 0xc8, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84,
+  0x40, 0x16, 0x46, 0x0c, 0x0a, 0x23, 0xd8, 0x85, 0x42, 0x0d, 0xe6, 0x18,
+  0x84, 0x20, 0x16, 0x66, 0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57,
+  0x10, 0x04, 0x04, 0x3a, 0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00
+};
+const unsigned int sdl_metallib_len = 30341;
diff --git a/SDL-3.2.8/src/render/metal/SDL_shaders_metal_tvos.h b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_tvos.h
new file mode 100644
index 0000000..5d04118
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_tvos.h
@@ -0,0 +1,2612 @@
+const unsigned char sdl_metallib[] = {
+  0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x45, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x02, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xe5, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x76, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
+  0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
+  0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
+  0x60, 0x7a, 0x81, 0x65, 0xda, 0xf6, 0x14, 0xc4, 0x56, 0x47, 0x0b, 0x7a,
+  0x77, 0x81, 0xf4, 0xc0, 0x01, 0xee, 0xcd, 0x26, 0x7c, 0x2d, 0x8d, 0x7b,
+  0x28, 0x66, 0x63, 0x5c, 0x85, 0xe9, 0xdd, 0xb9, 0x4f, 0x46, 0x46, 0x54,
+  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, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00,
+  0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x77, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
+  0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54, 0x59,
+  0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x6e,
+  0xc3, 0x21, 0x35, 0x82, 0x00, 0x01, 0xe8, 0xa4, 0x27, 0xe1, 0xec, 0x73,
+  0xf1, 0xe9, 0x58, 0x2e, 0x4a, 0x0d, 0xc0, 0x5a, 0x63, 0x1e, 0x7f, 0x35,
+  0xf1, 0x6e, 0x35, 0x4e, 0xbf, 0x18, 0xae, 0x4f, 0x46, 0x46, 0x54, 0x18,
+  0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
+  0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x7a, 0x00, 0x00, 0x00, 0x4e,
+  0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c,
+  0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x6a, 0x1d, 0x1d, 0x45, 0x2a, 0x6b, 0x07, 0x82, 0x0a, 0x87, 0xce,
+  0x97, 0xa1, 0xfe, 0x31, 0x9c, 0x83, 0x91, 0x37, 0x14, 0x18, 0x48, 0x21,
+  0x09, 0xd8, 0x88, 0xe6, 0x6a, 0xd7, 0xa1, 0x43, 0x12, 0x4f, 0x46, 0x46,
+  0x54, 0x18, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x19, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00, 0x08,
+  0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00, 0x00,
+  0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43,
+  0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
+  0x20, 0x00, 0xc3, 0xd6, 0x7b, 0x88, 0x85, 0xf9, 0x2a, 0x82, 0x3a, 0xbd,
+  0x11, 0xe6, 0x1e, 0x52, 0xa3, 0x10, 0xbc, 0xf6, 0x87, 0xcf, 0x2b, 0x30,
+  0xb1, 0x9a, 0xa7, 0x8c, 0xf0, 0x69, 0xee, 0x5a, 0x25, 0x8c, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x25, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
+  0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x78, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+  0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48,
+  0x20, 0x00, 0x9f, 0x6c, 0xde, 0x3a, 0x59, 0x77, 0x6a, 0xd2, 0x35, 0x5f,
+  0x27, 0x58, 0x9c, 0x4b, 0xdb, 0x9c, 0x88, 0xf7, 0xdf, 0x70, 0x9e, 0x17,
+  0x60, 0xc0, 0xe8, 0x92, 0xf3, 0x9d, 0xc8, 0x6a, 0x12, 0x45, 0x4f, 0x46,
+  0x46, 0x54, 0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x3e, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01, 0x00,
+  0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x79, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e,
+  0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53,
+  0x48, 0x20, 0x00, 0xa0, 0xfa, 0x0c, 0x39, 0x0e, 0x54, 0xa2, 0xb2, 0x34,
+  0x03, 0x53, 0x34, 0x18, 0x63, 0x46, 0x2e, 0x1a, 0x02, 0x79, 0x8d, 0x88,
+  0x29, 0x32, 0xb9, 0xcc, 0xcd, 0x6b, 0xaa, 0xd8, 0x7a, 0x01, 0xd6, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x5a, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x01,
+  0x00, 0x08, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x29,
+  0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x15, 0x00, 0x02, 0x00, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f,
+  0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56, 0x41, 0x54, 0x59, 0x04, 0x00,
+  0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44, 0x54, 0x35, 0x00, 0x00, 0x00,
+  0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03, 0x00, 0x70, 0x6f, 0x73, 0x69,
+  0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
+  0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00,
+  0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05, 0x00, 0x03, 0x00, 0x04, 0x06,
+  0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xac, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0x79, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c,
+  0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c, 0x00, 0x06, 0x77, 0x78,
+  0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76, 0xa0, 0x87, 0x74, 0x70,
+  0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08,
+  0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d,
+  0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d,
+  0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1, 0x1d, 0xda, 0x80, 0x1d,
+  0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79, 0x48, 0x87, 0x73, 0x70,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72, 0x90, 0x87, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01, 0x1e, 0xd2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90,
+  0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a, 0x08, 0x87, 0x71, 0x58,
+  0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a, 0x28, 0x87, 0x71, 0xa0,
+  0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d, 0x28, 0x07, 0x00, 0x0f,
+  0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1, 0x1c, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x6c, 0xc2, 0x00, 0x2c, 0x40,
+  0x35, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83,
+  0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b, 0x84, 0x03,
+  0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0x61, 0x1b, 0x08, 0x60, 0x01,
+  0xaa, 0x21, 0x1c, 0xd2, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xda, 0x20, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0,
+  0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88,
+  0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6,
+  0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18,
+  0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x30, 0x02,
+  0x50, 0x80, 0x01, 0x45, 0x50, 0x20, 0x65, 0x50, 0x08, 0x05, 0x41, 0x6c,
+  0x04, 0x80, 0xd6, 0x58, 0x82, 0x24, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2,
+  0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x42,
+  0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b,
+  0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x07, 0xe3, 0x20, 0x08,
+  0x0e, 0x8e, 0xad, 0x0c, 0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6,
+  0x85, 0x06, 0x86, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65,
+  0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x45, 0x60, 0xd1, 0x54,
+  0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x45, 0xe0,
+  0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6,
+  0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17,
+  0x26, 0xc6, 0x56, 0x36, 0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x64, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95,
+  0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a,
+  0x9c, 0x0b, 0xdc, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0,
+  0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
+  0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca,
+  0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92,
+  0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b,
+  0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94,
+  0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14,
+  0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04,
+  0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x3a, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f,
+  0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x2c, 0xcc, 0xd8, 0xde,
+  0xc2, 0xe8, 0x98, 0xc0, 0xbd, 0xa5, 0xb9, 0xd1, 0x4d, 0xa5, 0xe9, 0x95,
+  0x0d, 0x51, 0x92, 0x2c, 0x81, 0x12, 0x2d, 0x91, 0x92, 0x6d, 0x88, 0x91,
+  0x50, 0x09, 0x96, 0x70, 0x84, 0xc2, 0xd2, 0xe4, 0x5c, 0xec, 0xca, 0xe4,
+  0xe8, 0xca, 0xf0, 0xbe, 0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x28, 0x85, 0xa5,
+  0xc9, 0xb9, 0xb0, 0xbd, 0x8d, 0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5,
+  0xb9, 0x91, 0x95, 0xe1, 0xd1, 0x3b, 0x2b, 0x73, 0x2b, 0x93, 0x0b, 0xa3,
+  0x2b, 0x23, 0x43, 0xf9, 0xfa, 0x0a, 0x4b, 0x93, 0xfb, 0x82, 0x63, 0x0b,
+  0x1b, 0x2b, 0x43, 0x7b, 0x63, 0x23, 0x2b, 0x93, 0xfb, 0xfa, 0x4a, 0xa1,
+  0x61, 0xc6, 0xf6, 0x16, 0x46, 0x27, 0x33, 0x84, 0x52, 0x84, 0xc4, 0x4b,
+  0x3e, 0x45, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x09, 0x83, 0x44, 0x4a,
+  0xa6, 0x21, 0x94, 0x12, 0x24, 0x5e, 0xf2, 0x29, 0x81, 0x12, 0x24, 0x60,
+  0x90, 0x40, 0x49, 0x94, 0x48, 0xc9, 0x45, 0x25, 0x2c, 0x4d, 0xce, 0x45,
+  0xac, 0xce, 0xcc, 0xac, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c, 0x8b, 0x58,
+  0x9d, 0x99, 0x59, 0x99, 0xdc, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x91, 0xb0,
+  0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x46, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0xbc, 0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2,
+  0xe0, 0xca, 0xbe, 0xc2, 0xd8, 0xd2, 0xce, 0xdc, 0xbe, 0xe6, 0xd2, 0xf4,
+  0xca, 0x88, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xd1, 0xe0, 0xd1, 0x50, 0x81,
+  0x93, 0x7b, 0x53, 0x2b, 0x1b, 0xa3, 0x4b, 0x7b, 0x73, 0x1b, 0x02, 0x06,
+  0x0a, 0x91, 0x90, 0x41, 0x52, 0x06, 0xca, 0x90, 0x7c, 0x0a, 0xa1, 0x04,
+  0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c, 0x09, 0x1a, 0x28, 0x45, 0x02, 0x25,
+  0x69, 0x90, 0x48, 0x89, 0x1a, 0x30, 0xa1, 0x93, 0x0b, 0x73, 0x9b, 0x33,
+  0x7b, 0x93, 0x6b, 0x1b, 0x02, 0x06, 0x8a, 0x91, 0x90, 0x41, 0x52, 0x06,
+  0xca, 0x90, 0x7c, 0x8a, 0xa1, 0x04, 0x89, 0x19, 0x24, 0x67, 0xa0, 0x0c,
+  0x09, 0x1a, 0x28, 0x45, 0x02, 0x25, 0x69, 0x90, 0x48, 0x09, 0x1b, 0x0c,
+  0x41, 0x12, 0x31, 0x48, 0xc6, 0x20, 0x59, 0x83, 0xa4, 0x0d, 0x86, 0x18,
+  0x08, 0x90, 0x74, 0x89, 0x1b, 0xf0, 0x79, 0x6b, 0x73, 0x4b, 0x83, 0x7b,
+  0xa3, 0x2b, 0x73, 0xa3, 0x03, 0x19, 0x43, 0x0b, 0x93, 0xe3, 0x33, 0x95,
+  0xd6, 0x06, 0xc7, 0x56, 0x06, 0x32, 0xb4, 0xb2, 0x02, 0x42, 0x25, 0x14,
+  0x14, 0x34, 0x44, 0x48, 0xe2, 0x60, 0x88, 0x91, 0xc0, 0x41, 0x22, 0x07,
+  0x4c, 0x32, 0xc4, 0x48, 0xe6, 0x20, 0x99, 0x03, 0x26, 0xa1, 0x18, 0x84,
+  0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd,
+  0xc1, 0x95, 0xcd, 0xa1, 0x4c, 0x11, 0x31, 0x7d, 0x4d, 0xbd, 0xb1, 0xa5,
+  0x91, 0x7d, 0xd9, 0x95, 0xc9, 0xd1, 0x95, 0xe1, 0xa5, 0x0c, 0x21, 0x12,
+  0x3b, 0x48, 0xea, 0x80, 0x56, 0x58, 0x9a, 0x5c, 0x4b, 0x18, 0x5b, 0x5a,
+  0xd8, 0x5c, 0xcb, 0xdc, 0xd8, 0x1b, 0x5c, 0x59, 0x4b, 0x98, 0xdc, 0x19,
+  0xca, 0x4c, 0xca, 0x10, 0x23, 0xc1, 0x83, 0xc4, 0x0e, 0x92, 0x3b, 0x18,
+  0x22, 0x24, 0x78, 0x40, 0x2b, 0x2c, 0x4d, 0xae, 0x25, 0x8c, 0x2d, 0x2d,
+  0x6c, 0xae, 0x65, 0x6e, 0xec, 0x0d, 0xae, 0xac, 0x25, 0x4c, 0xee, 0x0c,
+  0x45, 0x26, 0x65, 0x88, 0x91, 0xec, 0x41, 0x62, 0x07, 0x89, 0x1e, 0x0c,
+  0x11, 0x92, 0x3d, 0x18, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8,
+  0x41, 0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98,
+  0x03, 0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28,
+  0xec, 0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e,
+  0xee, 0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f,
+  0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e,
+  0x53, 0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e,
+  0xe1, 0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b,
+  0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25,
+  0x40, 0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e,
+  0xed, 0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f,
+  0xf4, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67,
+  0x84, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0f, 0xe5, 0x20, 0x0f,
+  0xf4, 0x50, 0x0e, 0xf8, 0x30, 0x25, 0x78, 0x03, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x06, 0x00, 0xb1, 0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x45,
+  0x44, 0x13, 0x71, 0x01, 0x00, 0x61, 0x20, 0x00, 0x00, 0x5c, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+  0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10,
+  0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x15, 0x41, 0x09, 0x94,
+  0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x66, 0x00,
+  0x08, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0x1f, 0x00, 0xe3, 0x11, 0x8d,
+  0x94, 0x49, 0x14, 0x94, 0xf1, 0x08, 0x88, 0xda, 0x28, 0x0a, 0xca, 0x20,
+  0xc3, 0x70, 0x34, 0x26, 0x04, 0xf2, 0x19, 0x8f, 0xa0, 0xb0, 0xaf, 0xa1,
+  0xa0, 0x0c, 0x32, 0x1c, 0x8a, 0x64, 0x42, 0x20, 0x1f, 0x0b, 0x0a, 0xf8,
+  0x8c, 0x47, 0x64, 0x1d, 0x19, 0x4c, 0x14, 0x94, 0x41, 0x06, 0xe6, 0xc1,
+  0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1, 0x08, 0x4f, 0x0c, 0xd2,
+  0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x94, 0x67, 0x42, 0x20, 0x1f, 0x2b,
+  0x02, 0xf8, 0x8c, 0x47, 0x88, 0xc1, 0x19, 0xb8, 0x01, 0x47, 0x41, 0x19,
+  0x64, 0x08, 0x34, 0x30, 0xb0, 0xa0, 0x92, 0xcf, 0x20, 0xc3, 0xb0, 0x8d,
+  0x81, 0x05, 0x93, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8, 0x60, 0x78, 0x67,
+  0x60, 0x41, 0x24, 0x1f, 0x1b, 0x02, 0xf8, 0x0c, 0x32, 0x24, 0x61, 0xb0,
+  0x06, 0x16, 0x3c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x78, 0xc4, 0x1b, 0xd0,
+  0xc1, 0x1e, 0xa0, 0x01, 0x05, 0x65, 0x90, 0x21, 0x38, 0x83, 0x36, 0xb0,
+  0x40, 0x0c, 0xe4, 0x33, 0xc8, 0x30, 0xa0, 0x01, 0x1c, 0x58, 0x00, 0x06,
+  0xf2, 0x19, 0x64, 0x28, 0xd4, 0x60, 0x0e, 0x2c, 0xe8, 0xe4, 0x33, 0xc8,
+  0x70, 0xb0, 0x81, 0x1d, 0x58, 0xa0, 0xc9, 0x67, 0x90, 0x81, 0x0f, 0xe2,
+  0xa0, 0x0e, 0x2c, 0x0b, 0xe4, 0x33, 0xc8, 0xe0, 0x07, 0x73, 0x80, 0x07,
+  0xe6, 0x04, 0xf2, 0xb1, 0x64, 0x80, 0x8f, 0x05, 0x0c, 0x7c, 0x2c, 0x48,
+  0xe0, 0x63, 0x01, 0x02, 0x1f, 0x0b, 0x0a, 0xf8, 0xcc, 0x36, 0xe4, 0x41,
+  0x00, 0xcc, 0x36, 0x04, 0xa5, 0x10, 0xcc, 0x36, 0x04, 0x78, 0x20, 0x64,
+  0x10, 0x10, 0x03, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20,
+  0xa0, 0x83, 0x23, 0x0f, 0x10, 0x3e, 0xd8, 0x72, 0x0c, 0x01, 0x1d, 0x1c,
+  0x7c, 0x80, 0xe4, 0xc1, 0x96, 0xe3, 0x08, 0xe8, 0xe0, 0xe0, 0x03, 0x24,
+  0x0f, 0xb6, 0x1c, 0x4c, 0x40, 0x07, 0x07, 0x1f, 0x20, 0x79, 0xb0, 0xe5,
+  0x88, 0x02, 0x3a, 0x38, 0xf8, 0x00, 0xc9, 0x83, 0x2d, 0x87, 0x15, 0xd0,
+  0xc1, 0x91, 0x07, 0x08, 0x1f, 0x6c, 0x39, 0xc6, 0x20, 0xa0, 0x83, 0x23,
+  0x0f, 0x10, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xbc, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x48, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0x79, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78,
+  0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30,
+  0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c,
+  0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c,
+  0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c, 0x00, 0x06, 0x77, 0x78,
+  0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76, 0xa0, 0x87, 0x74, 0x70,
+  0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08,
+  0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1, 0x0d, 0xe0, 0xe1, 0x1d,
+  0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xca, 0x81, 0x1d,
+  0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1, 0x1d, 0xda, 0x80, 0x1d,
+  0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00,
+  0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77, 0x30, 0x87, 0x79, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d,
+  0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d,
+  0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79, 0x48, 0x87, 0x73, 0x70,
+  0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72, 0x90, 0x87, 0x77, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01, 0x1e, 0xd2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90,
+  0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a, 0x08, 0x87, 0x71, 0x58,
+  0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a, 0x28, 0x87, 0x71, 0xa0,
+  0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28,
+  0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d, 0x28, 0x07, 0x00, 0x0f,
+  0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1, 0x1c, 0xca, 0xa1, 0x0d,
+  0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x6c, 0x02, 0x01, 0x2c, 0x40,
+  0x35, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83,
+  0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b, 0x84, 0x03,
+  0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0x61, 0x1b, 0x0a, 0x60, 0x01,
+  0xaa, 0x21, 0x1c, 0xd2, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c,
+  0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xda, 0x20, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c,
+  0x11, 0x84, 0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18,
+  0x04, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x25, 0x50, 0x04,
+  0x23, 0x00, 0x05, 0x18, 0x50, 0x08, 0x65, 0x50, 0x20, 0x05, 0x41, 0x6c,
+  0x04, 0x80, 0xd6, 0x58, 0x82, 0x24, 0x00, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0x06, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2,
+  0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x86, 0x22,
+  0x24, 0xc0, 0xa2, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b,
+  0xd3, 0x2b, 0x1b, 0x62, 0x28, 0x41, 0x22, 0x28, 0x05, 0xe3, 0x20, 0x08,
+  0x0e, 0x8e, 0xad, 0x0c, 0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6,
+  0x85, 0x06, 0x86, 0x06, 0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac,
+  0xac, 0x65, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65,
+  0x88, 0x90, 0x10, 0x43, 0x0c, 0x25, 0x50, 0x10, 0x65, 0x60, 0xd1, 0x54,
+  0x46, 0x17, 0xc6, 0x36, 0x04, 0x49, 0x0e, 0x25, 0x50, 0x02, 0x65, 0xe0,
+  0x16, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6,
+  0x42, 0x56, 0xe6, 0xf6, 0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17,
+  0x26, 0xc6, 0x56, 0x36, 0x44, 0x48, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x64, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95,
+  0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0x92, 0x86, 0x4c, 0x58, 0x9a,
+  0x9c, 0x0b, 0xdc, 0xdb, 0x5c, 0x1a, 0x5d, 0xda, 0x9b, 0x1b, 0xa3, 0xb0,
+  0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0x2f,
+  0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x64,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc2, 0xe4, 0xce, 0xbe, 0xdc, 0xc2, 0xda, 0xca,
+  0x88, 0xc0, 0xbd, 0xcd, 0xa5, 0xd1, 0xa5, 0xbd, 0xb9, 0x0d, 0x51, 0x92,
+  0x27, 0x81, 0x92, 0x28, 0x91, 0x92, 0x89, 0x51, 0x58, 0x9a, 0x9c, 0x8b,
+  0x5d, 0x99, 0x1c, 0x5d, 0x19, 0xde, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0xad, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30, 0xba, 0x32, 0x32, 0x94,
+  0x9a, 0xb1, 0x37, 0xb6, 0x37, 0x39, 0x22, 0x3b, 0x9a, 0x2f, 0xb3, 0x14,
+  0x16, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x43, 0x98, 0xa4, 0x4a, 0xac, 0x04,
+  0x4a, 0xa2, 0x44, 0x4a, 0x2e, 0x66, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
+  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x34, 0xcc, 0xd8, 0xde, 0xc2,
+  0xe8, 0x64, 0x88, 0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x0d,
+  0x61, 0x92, 0x2a, 0xc9, 0x12, 0x28, 0xd1, 0x12, 0x29, 0xd9, 0x86, 0x18,
+  0x09, 0x95, 0x60, 0x09, 0x47, 0x28, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c,
+  0x8e, 0xae, 0x0c, 0xef, 0x2b, 0xcd, 0x0d, 0xae, 0x8e, 0x8e, 0x52, 0x58,
+  0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58, 0x18, 0x5d, 0xda, 0x9b, 0xdb, 0x57,
+  0x9a, 0x1b, 0x59, 0x19, 0x1e, 0xbd, 0xb3, 0x32, 0xb7, 0x32, 0xb9, 0x30,
+  0xba, 0x32, 0x32, 0x94, 0xaf, 0xaf, 0xb0, 0x34, 0xb9, 0x2f, 0x38, 0xb6,
+  0xb0, 0xb1, 0x32, 0xb4, 0x37, 0x36, 0xb2, 0x32, 0xb9, 0xaf, 0xaf, 0x94,
+  0x21, 0x94, 0x32, 0x24, 0x5e, 0xf2, 0x29, 0x83, 0x12, 0x24, 0x60, 0x90,
+  0x40, 0x89, 0x96, 0x48, 0xc9, 0x34, 0x84, 0x52, 0x82, 0xc4, 0x4b, 0x3e,
+  0x25, 0x50, 0x82, 0x04, 0x0c, 0x12, 0x28, 0x89, 0x12, 0x29, 0xb9, 0x86,
+  0x50, 0x8a, 0x90, 0x78, 0xc9, 0xa7, 0x08, 0x4a, 0x90, 0x80, 0x41, 0x02,
+  0x25, 0x5a, 0x22, 0x25, 0x1b, 0x95, 0xb0, 0x34, 0x39, 0x17, 0xb1, 0x3a,
+  0x33, 0xb3, 0x32, 0x39, 0x3e, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66,
+  0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x44, 0xc2, 0xd2, 0xe4,
+  0x5c, 0xe4, 0xca, 0xc2, 0xc8, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9,
+  0x9d, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0xcd, 0xa5, 0xe9, 0x95, 0xf1,
+  0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0xfb, 0x0a, 0x63, 0x4b, 0x3b, 0x73, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x23,
+  0x62, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x83, 0x47, 0x43, 0x05, 0x4e, 0xee,
+  0x4d, 0xad, 0x6c, 0x8c, 0x2e, 0xed, 0xcd, 0x6d, 0x08, 0x18, 0x28, 0x46,
+  0x42, 0x06, 0x49, 0x19, 0x28, 0x44, 0xf2, 0x29, 0x82, 0x12, 0x24, 0x66,
+  0x90, 0x9c, 0x81, 0x42, 0x24, 0x68, 0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41,
+  0x22, 0x25, 0x6a, 0xc0, 0x84, 0x4e, 0x2e, 0xcc, 0x6d, 0xce, 0xec, 0x4d,
+  0xae, 0x6d, 0x08, 0x18, 0x28, 0x45, 0x42, 0x06, 0x49, 0x19, 0x28, 0x44,
+  0xf2, 0x29, 0x86, 0x12, 0x24, 0x66, 0x90, 0x9c, 0x81, 0x42, 0x24, 0x68,
+  0xa0, 0x1c, 0x09, 0x94, 0xa4, 0x41, 0x22, 0x25, 0x6c, 0x30, 0x44, 0x49,
+  0xc2, 0x20, 0x11, 0x83, 0x64, 0x0c, 0x92, 0x35, 0x48, 0xda, 0x60, 0x88,
+  0x81, 0x00, 0x49, 0x97, 0xb8, 0x01, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8,
+  0x37, 0xba, 0x32, 0x37, 0x3a, 0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53,
+  0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42,
+  0x41, 0x41, 0x43, 0x84, 0x24, 0x0e, 0x86, 0x18, 0x09, 0x1c, 0x24, 0x72,
+  0xc0, 0x24, 0x43, 0x8c, 0x64, 0x0e, 0x92, 0x39, 0x60, 0x12, 0x86, 0x41,
+  0x58, 0x9a, 0x5c, 0x4b, 0x18, 0x5b, 0x5a, 0xd8, 0x5c, 0xcb, 0xdc, 0xd8,
+  0x1b, 0x5c, 0xd9, 0x1c, 0xca, 0x14, 0x11, 0xd3, 0xd7, 0xd0, 0x1b, 0x5c,
+  0xde, 0x97, 0x5d, 0x99, 0x1c, 0x5d, 0x19, 0x5e, 0xca, 0x10, 0x22, 0xb1,
+  0x83, 0xa4, 0x0e, 0x68, 0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85,
+  0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0x84, 0xc9, 0x9d, 0xa1,
+  0xd0, 0xa4, 0x0c, 0x31, 0x12, 0x3c, 0x48, 0xec, 0x20, 0xb9, 0x83, 0x21,
+  0x42, 0x82, 0x07, 0xb4, 0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8, 0xd2, 0xc2,
+  0xe6, 0x5a, 0xe6, 0xc6, 0xde, 0xe0, 0xca, 0x5a, 0xc2, 0xe4, 0xce, 0x50,
+  0x66, 0x52, 0x86, 0x18, 0xc9, 0x1e, 0x24, 0x76, 0x90, 0xe8, 0xc1, 0x10,
+  0x21, 0xd9, 0x83, 0x11, 0x11, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b,
+  0xb4, 0xc3, 0x3b, 0x90, 0x43, 0x3d, 0xb0, 0x43, 0x39, 0xb8, 0x81, 0x39,
+  0xb0, 0x43, 0x38, 0x9c, 0xc3, 0x3c, 0x4c, 0x11, 0x82, 0x61, 0x84, 0xc2,
+  0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xe9, 0x40, 0x0e, 0xe5, 0xe0,
+  0x0e, 0xf4, 0x30, 0x25, 0x28, 0x46, 0x2c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0,
+  0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30,
+  0x25, 0x30, 0x46, 0x50, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xec, 0x10,
+  0x0e, 0xee, 0x70, 0x0e, 0xf5, 0x10, 0x0e, 0xe7, 0x50, 0x0e, 0xbf, 0x60,
+  0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02,
+  0x64, 0xc4, 0x14, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x30, 0x0e, 0xef, 0xd0,
+  0x0e, 0xf0, 0x90, 0x0e, 0xec, 0x50, 0x0e, 0xbf, 0xf0, 0x0e, 0xf0, 0x40,
+  0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x0f, 0x53, 0x06, 0x85, 0x71, 0x46,
+  0x28, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6, 0x50, 0x0e, 0xf2, 0x40,
+  0x0f, 0xe5, 0x80, 0x0f, 0x53, 0x82, 0x37, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x06, 0xf0, 0xb0, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x15, 0x11,
+  0x4d, 0xc4, 0x05, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x5a, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0xe4, 0xc6, 0x22, 0x86, 0x61, 0x18, 0xc6, 0x22, 0x04, 0x41, 0x10,
+  0xc6, 0x22, 0x82, 0x20, 0x08, 0x46, 0x00, 0x88, 0x95, 0x40, 0x19, 0x14,
+  0x01, 0x8d, 0x19, 0x00, 0x12, 0x33, 0x00, 0x14, 0x66, 0x00, 0x66, 0x00,
+  0x00, 0xe3, 0x11, 0x8c, 0x84, 0x49, 0x14, 0x94, 0xf1, 0x88, 0x87, 0xd2,
+  0x28, 0x0a, 0xca, 0x20, 0xc3, 0x60, 0x30, 0x26, 0x04, 0xf2, 0x19, 0x8f,
+  0x98, 0x30, 0xaf, 0xa1, 0xa0, 0x0c, 0x32, 0x1c, 0x49, 0x64, 0x42, 0x20,
+  0x1f, 0x0b, 0x0a, 0xf8, 0x8c, 0x47, 0x60, 0xdd, 0x18, 0x40, 0x14, 0x94,
+  0x41, 0x06, 0xc6, 0xb9, 0x4c, 0x08, 0xe4, 0x63, 0x45, 0x00, 0x9f, 0xf1,
+  0x88, 0x4e, 0x0c, 0xd0, 0xc0, 0xa2, 0xa0, 0x0c, 0x32, 0x44, 0x53, 0x67,
+  0x42, 0x20, 0x1f, 0x2b, 0x02, 0xf8, 0x8c, 0x47, 0x84, 0xc1, 0x19, 0xb4,
+  0x01, 0x47, 0x41, 0x19, 0x64, 0x08, 0xb2, 0xcf, 0x82, 0x4a, 0x3e, 0x83,
+  0x0c, 0x83, 0x26, 0x06, 0x16, 0x4c, 0xf2, 0xb1, 0x21, 0x80, 0xcf, 0x20,
+  0x83, 0xd1, 0x99, 0x81, 0x05, 0x91, 0x7c, 0x6c, 0x08, 0xe0, 0x33, 0xc8,
+  0x90, 0x80, 0x81, 0x1a, 0x58, 0xf0, 0xc8, 0xc7, 0x86, 0x00, 0x3e, 0xe3,
+  0x11, 0x6e, 0x40, 0x07, 0x7a, 0x80, 0x06, 0x14, 0x94, 0x41, 0x86, 0xc0,
+  0x0c, 0xd8, 0xc0, 0x02, 0x31, 0x90, 0xcf, 0x20, 0xc3, 0x70, 0x06, 0x6f,
+  0x60, 0x01, 0x18, 0xc8, 0x67, 0x90, 0xa1, 0x48, 0x03, 0x39, 0xb0, 0xa0,
+  0x93, 0xcf, 0x20, 0xc3, 0xb1, 0x06, 0x75, 0x60, 0x81, 0x26, 0x9f, 0x41,
+  0x06, 0x3e, 0x78, 0x03, 0x3a, 0xb0, 0x2c, 0x90, 0xcf, 0x20, 0x83, 0x1f,
+  0xc4, 0xc1, 0x1d, 0x98, 0x13, 0xc8, 0xc7, 0x92, 0x01, 0x3e, 0x16, 0x30,
+  0xf0, 0xb1, 0x20, 0x81, 0x8f, 0x05, 0x08, 0x7c, 0x2c, 0x28, 0xe0, 0x33,
+  0xdb, 0x90, 0x07, 0x01, 0x30, 0xdb, 0x10, 0x94, 0x42, 0x30, 0xdb, 0x10,
+  0x94, 0x82, 0x90, 0x41, 0x40, 0x0c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x5b, 0x8e, 0x20, 0xa0, 0x83, 0x23, 0x0f, 0x10, 0x3e, 0xd8, 0x72,
+  0x0c, 0x01, 0x1d, 0x1c, 0x7c, 0x80, 0xe4, 0xc1, 0x96, 0xe3, 0x08, 0xe8,
+  0xe0, 0xe0, 0x03, 0x24, 0x0f, 0xb6, 0x1c, 0x4c, 0x40, 0x07, 0x07, 0x1f,
+  0x20, 0x79, 0xb0, 0xe5, 0x88, 0x02, 0x3a, 0x38, 0xf8, 0x00, 0xc9, 0x83,
+  0x2d, 0x87, 0x15, 0xd0, 0xc1, 0x91, 0x07, 0x08, 0x1f, 0x6c, 0x39, 0xc6,
+  0x20, 0xa0, 0x83, 0x23, 0x0f, 0x10, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xfd, 0x02, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90,
+  0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8,
+  0x08, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00,
+  0x00, 0x51, 0x18, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x6c,
+  0xc2, 0x00, 0x2c, 0x40, 0x35, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88,
+  0x43, 0x3d, 0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc,
+  0x43, 0x1b, 0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0x00, 0x00,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84,
+  0x4c, 0x10, 0x3c, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x67, 0x49, 0x53, 0x44, 0x09, 0x93, 0xcf, 0x1e, 0xc0, 0x40, 0x44, 0x9c,
+  0xd3, 0x48, 0x13, 0xd0, 0x4c, 0x12, 0x42, 0x00, 0x00, 0x00, 0x00, 0x06,
+  0x11, 0x06, 0xa1, 0x10, 0x21, 0x41, 0x54, 0x03, 0x01, 0x73, 0x04, 0x60,
+  0x90, 0x02, 0x38, 0x47, 0x00, 0x0a, 0x83, 0x08, 0x80, 0x30, 0x8c, 0x30,
+  0x00, 0xc3, 0x08, 0x04, 0x32, 0x02, 0x00, 0x00, 0x00, 0x13, 0xa8, 0x70,
+  0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78,
+  0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37,
+  0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f,
+  0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07,
+  0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06,
+  0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07,
+  0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07,
+  0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07,
+  0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07,
+  0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07,
+  0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06,
+  0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07,
+  0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07,
+  0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07,
+  0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06,
+  0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07,
+  0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07,
+  0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07,
+  0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07,
+  0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f,
+  0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07,
+  0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07,
+  0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07,
+  0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07,
+  0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18, 0x03, 0x00, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0xc2, 0x11, 0x80, 0x42, 0x28, 0x81, 0x22, 0x28,
+  0x88, 0x02, 0x2a, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0xd2, 0xc2,
+  0x19, 0x01, 0x28, 0x8c, 0x42, 0x28, 0x88, 0x02, 0x29, 0x94, 0x82, 0xa1,
+  0x1c, 0x4b, 0x90, 0x04, 0x00, 0x79, 0x18, 0x00, 0x00, 0x27, 0x01, 0x00,
+  0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32,
+  0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x42, 0x1c, 0x40, 0x42, 0x51,
+  0xb9, 0x1b, 0x43, 0x0b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62,
+  0x20, 0xc3, 0x21, 0x20, 0x02, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c,
+  0xa4, 0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed,
+  0xcd, 0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06,
+  0x04, 0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06,
+  0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x70, 0x10, 0x43,
+  0x0c, 0x64, 0x40, 0x0a, 0x24, 0x60, 0xd1, 0x54, 0x46, 0x17, 0xc6, 0x36,
+  0x04, 0x39, 0x0e, 0x64, 0x40, 0x06, 0x24, 0xe0, 0x16, 0x96, 0x26, 0xe7,
+  0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56, 0xe6, 0x42, 0x56, 0xe6, 0xf6,
+  0x26, 0xd7, 0x36, 0xf7, 0x45, 0x96, 0x36, 0x17, 0x26, 0xc6, 0x56, 0x36,
+  0x44, 0x38, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
+  0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74,
+  0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x63, 0x21,
+  0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5, 0xb1, 0x95,
+  0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99, 0x95, 0xc9,
+  0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1,
+  0x95, 0x0d, 0x11, 0x8e, 0x86, 0x51, 0x58, 0x9a, 0x9c, 0x8b, 0x5c, 0x99,
+  0x1b, 0x59, 0x99, 0xdc, 0x17, 0x5d, 0x98, 0xdc, 0x59, 0x19, 0x1d, 0xa3,
+  0xb0, 0x34, 0x39, 0x97, 0x30, 0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2,
+  0x2f, 0xb7, 0xb0, 0xb6, 0x32, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34,
+  0x43, 0x90, 0xe3, 0x41, 0x82, 0x03, 0x3a, 0xa2, 0x21, 0xc2, 0x21, 0x51,
+  0x0a, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3,
+  0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3, 0x63, 0x76, 0x56, 0xe6, 0x56, 0x26,
+  0x17, 0x46, 0x57, 0x46, 0x86, 0x82, 0x03, 0xf7, 0x36, 0x97, 0x46, 0x97,
+  0xf6, 0xe6, 0x46, 0x64, 0x27, 0xf3, 0x65, 0x96, 0x42, 0x25, 0x2c, 0x4d,
+  0xce, 0x65, 0xac, 0xcc, 0x8d, 0xae, 0x4c, 0x8e, 0x4f, 0x58, 0x9a, 0x9c,
+  0x0b, 0x5c, 0x99, 0xdc, 0x1c, 0x5c, 0xd9, 0x18, 0x5d, 0x9a, 0x5d, 0x19,
+  0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x32, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6,
+  0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0x86, 0x48, 0x48, 0x70, 0x50, 0x47, 0x75,
+  0x58, 0xc7, 0x75, 0x40, 0x07, 0x76, 0x64, 0x87, 0x46, 0xeb, 0xac, 0xcc,
+  0xad, 0x4c, 0x2e, 0x8c, 0xae, 0x8c, 0x0c, 0xa5, 0x66, 0xec, 0x8d, 0xed,
+  0x4d, 0x8e, 0xc8, 0x8e, 0xe6, 0xcb, 0x2c, 0x85, 0xc5, 0xd8, 0x1b, 0xdb,
+  0x9b, 0xdc, 0x10, 0x09, 0x19, 0x0e, 0xea, 0xe0, 0x0e, 0xeb, 0xb8, 0x0e,
+  0xe8, 0x88, 0x8e, 0xec, 0xe8, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0x88, 0xd5,
+  0x99, 0x99, 0x95, 0xc9, 0xf1, 0x09, 0x4b, 0x93, 0x73, 0x11, 0xab, 0x33,
+  0x33, 0x2b, 0x93, 0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0xa3, 0x14, 0x96, 0x26,
+  0xe7, 0xc2, 0xf6, 0x36, 0x16, 0x46, 0x97, 0xf6, 0xe6, 0xf6, 0x95, 0xe6,
+  0x46, 0x56, 0x86, 0x47, 0x24, 0x2c, 0x4d, 0xce, 0x45, 0xae, 0x2c, 0x8c,
+  0x8c, 0x54, 0x58, 0x9a, 0x9c, 0xcb, 0x1c, 0x9d, 0x5c, 0xdd, 0x18, 0xdd,
+  0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x57, 0x9a, 0x9b, 0xd9, 0x1b, 0x0b, 0x33,
+  0xb6, 0xb7, 0x30, 0x3a, 0x32, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f,
+  0x75, 0x74, 0x70, 0x75, 0x74, 0x64, 0xe8, 0xca, 0xf0, 0xe8, 0xea, 0xe4,
+  0xca, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xa8, 0xa4, 0xb9, 0xc1, 0xd5, 0xd1,
+  0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x71, 0x19, 0x7b, 0x63, 0x7b, 0x93, 0xfb,
+  0x9a, 0x1b, 0x0b, 0x63, 0x2b, 0xa3, 0x43, 0xf7, 0xe6, 0x56, 0xd6, 0x16,
+  0x06, 0xf7, 0xd5, 0x56, 0x46, 0x87, 0xf6, 0x46, 0xc6, 0x87, 0xee, 0xcd,
+  0xad, 0xac, 0x2d, 0x0c, 0xee, 0xcb, 0x2c, 0x6c, 0x8c, 0xee, 0x4d, 0x2e,
+  0x86, 0x0f, 0xdd, 0x9b, 0x5b, 0x59, 0x5b, 0x18, 0xdc, 0x97, 0x59, 0xd8,
+  0x18, 0xdd, 0x9b, 0x9c, 0x0c, 0x9f, 0x39, 0x32, 0xb9, 0xaf, 0x3b, 0xb4,
+  0x34, 0xba, 0xb2, 0x2f, 0xb8, 0xb7, 0x34, 0x37, 0xba, 0x21, 0xb0, 0x80,
+  0x04, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x65, 0x80, 0x08, 0x88, 0x80,
+  0x04, 0x07, 0x19, 0x1c, 0x66, 0x80, 0x14, 0x88, 0x80, 0x04, 0x07, 0x19,
+  0x1c, 0x67, 0x80, 0x1c, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x68, 0x80,
+  0x20, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x69, 0x80, 0x24, 0x88, 0x80,
+  0x04, 0x07, 0x19, 0x1c, 0x6a, 0x80, 0x28, 0x88, 0x80, 0x04, 0x07, 0x19,
+  0x1c, 0x6b, 0x80, 0x2c, 0x88, 0x80, 0x04, 0x07, 0x19, 0x1c, 0x6c, 0xc0,
+  0x28, 0x2c, 0x4d, 0xce, 0x25, 0x4c, 0xee, 0xec, 0x8b, 0x2e, 0x0f, 0xae,
+  0xec, 0x6b, 0x2e, 0x4d, 0xaf, 0x8c, 0x57, 0x58, 0x9a, 0x9c, 0x4b, 0x98,
+  0xdc, 0xd9, 0x17, 0x5d, 0x1e, 0x5c, 0xd9, 0x57, 0x18, 0x5b, 0xda, 0x99,
+  0xdb, 0xd7, 0x5c, 0x9a, 0x5e, 0x19, 0x9f, 0x29, 0xb4, 0x30, 0xb2, 0x32,
+  0xb9, 0xa1, 0x37, 0xb7, 0x39, 0xba, 0x30, 0x37, 0xba, 0x39, 0x06, 0x63,
+  0x43, 0xc8, 0x00, 0x21, 0x8e, 0xef, 0x00, 0x03, 0xc4, 0x38, 0xc2, 0x00,
+  0x09, 0x90, 0xe1, 0x10, 0x83, 0x63, 0x0c, 0x8e, 0x36, 0x38, 0xdc, 0x00,
+  0x31, 0x8e, 0x37, 0x40, 0x84, 0x03, 0x3a, 0xe0, 0xe0, 0xc8, 0x8e, 0x38,
+  0x18, 0x62, 0x1c, 0xdb, 0xe1, 0x1d, 0x72, 0x30, 0xc4, 0x30, 0x80, 0x63,
+  0x3a, 0xe6, 0x80, 0xd5, 0x97, 0x16, 0xd5, 0x54, 0x4c, 0xcd, 0x14, 0x5a,
+  0x18, 0x59, 0x99, 0xdc, 0xd0, 0x9b, 0xdb, 0x1c, 0x5d, 0x98, 0x1b, 0xdd,
+  0x1c, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32, 0x37, 0x3a,
+  0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65,
+  0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43, 0x84, 0xe3,
+  0x0e, 0x86, 0x18, 0x87, 0x1d, 0x1c, 0x78, 0xa0, 0x34, 0x43, 0x8c, 0x83,
+  0x0c, 0x8e, 0x3c, 0x50, 0x9a, 0x21, 0x62, 0x70, 0xd4, 0xc1, 0xa1, 0x07,
+  0x4a, 0x73, 0xe8, 0x81, 0xf2, 0x1c, 0x7a, 0xa0, 0x40, 0x87, 0x1e, 0x28,
+  0xce, 0xa1, 0x07, 0x4a, 0x74, 0xe8, 0x81, 0x22, 0x1d, 0x7a, 0xa0, 0x4c,
+  0x87, 0x1e, 0x28, 0xcc, 0x10, 0xe3, 0xd8, 0x83, 0x43, 0x0f, 0x14, 0x87,
+  0x64, 0x10, 0x96, 0x26, 0xd7, 0x12, 0xc6, 0x96, 0x16, 0x36, 0xd7, 0x32,
+  0x37, 0xf6, 0x06, 0x57, 0x36, 0x87, 0x32, 0x45, 0xc4, 0xf4, 0x35, 0xf5,
+  0xc6, 0x96, 0x46, 0xf6, 0x65, 0x26, 0x17, 0x76, 0xd6, 0x56, 0xe6, 0x46,
+  0x97, 0x32, 0x84, 0x38, 0xfc, 0xe0, 0xe8, 0x03, 0x5a, 0x61, 0x69, 0x72,
+  0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65,
+  0x2d, 0x61, 0x72, 0x67, 0x28, 0x32, 0x29, 0x43, 0x8c, 0x03, 0x14, 0x0e,
+  0x3f, 0x38, 0xfe, 0x60, 0x88, 0x70, 0x80, 0xc2, 0x88, 0x88, 0x1d, 0xd8,
+  0xc1, 0x1e, 0xda, 0xc1, 0x0d, 0xda, 0xe1, 0x1d, 0xc8, 0xa1, 0x1e, 0xd8,
+  0xa1, 0x1c, 0xdc, 0xc0, 0x1c, 0xd8, 0x21, 0x1c, 0xce, 0x61, 0x1e, 0xa6,
+  0x08, 0xc1, 0x30, 0x42, 0x61, 0x07, 0x76, 0xb0, 0x87, 0x76, 0x70, 0x83,
+  0x74, 0x20, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0x14, 0x23, 0x96,
+  0x70, 0x48, 0x07, 0x79, 0x70, 0x03, 0x7b, 0x28, 0x07, 0x79, 0x98, 0x87,
+  0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x18, 0x23, 0xa8, 0x70, 0x48, 0x07,
+  0x79, 0x70, 0x03, 0x76, 0x08, 0x07, 0x77, 0x38, 0x87, 0x7a, 0x08, 0x87,
+  0x73, 0x28, 0x87, 0x5f, 0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x29, 0x01, 0x32, 0x62, 0x0a, 0x87, 0x74, 0x90, 0x07,
+  0x37, 0x18, 0x87, 0x77, 0x68, 0x07, 0x78, 0x48, 0x07, 0x76, 0x28, 0x87,
+  0x5f, 0x78, 0x07, 0x78, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x87,
+  0x29, 0x83, 0xc2, 0x38, 0x23, 0x98, 0x70, 0x48, 0x07, 0x79, 0x70, 0x03,
+  0x73, 0x90, 0x87, 0x70, 0x38, 0x87, 0x76, 0x28, 0x07, 0x77, 0xa0, 0x87,
+  0x29, 0x01, 0x1d, 0x00, 0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x71, 0x20, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x20, 0xb1,
+  0x5d, 0xf9, 0xb3, 0xce, 0x82, 0x0c, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34,
+  0x13, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0xd4, 0x73, 0x10, 0x41, 0x10, 0x68, 0x84, 0x65, 0x30, 0x03, 0x40,
+  0x3c, 0x03, 0x40, 0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x00, 0x00,
+  0x00, 0xe3, 0x0d, 0x06, 0x44, 0x50, 0x30, 0xe6, 0x18, 0x88, 0xc0, 0x1b,
+  0x64, 0x08, 0x0a, 0x64, 0x8e, 0x21, 0x28, 0x10, 0x0b, 0x18, 0xf9, 0x64,
+  0x10, 0x10, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x8a, 0x20,
+  0xe0, 0x83, 0x23, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x88, 0x18, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x1f, 0x06, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0xef, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90,
+  0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d,
+  0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d,
+  0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70,
+  0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48,
+  0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0xc3, 0x26, 0x10, 0xc0,
+  0x02, 0x54, 0x43, 0x38, 0xa4, 0x83, 0x3c, 0xb4, 0x81, 0x38, 0xd4, 0x83,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0xb8, 0xc3, 0x3b, 0xb4, 0x41,
+  0x38, 0xb0, 0x43, 0x3a, 0x84, 0xc3, 0x3c, 0x00, 0x1b, 0x8c, 0xa1, 0x00,
+  0x16, 0xa0, 0xda, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x8f, 0x18, 0xff,
+  0xff, 0xff, 0xff, 0x3f, 0x00, 0x12, 0x50, 0x11, 0xe1, 0x00, 0x0f, 0xf0,
+  0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0, 0x0e, 0xe3,
+  0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8,
+  0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b, 0xa4, 0x83,
+  0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b, 0xb4, 0x81,
+  0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b, 0xdc, 0x43,
+  0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03, 0x90, 0x07, 0x76, 0x00, 0x0c, 0xee,
+  0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5, 0x90, 0x0e, 0xec, 0x40, 0x0f, 0xe9,
+  0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x60, 0x0e, 0xf2,
+  0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0xef, 0x90, 0x0e, 0xee,
+  0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d, 0x50, 0x0e, 0xec, 0x90, 0x0e, 0xed,
+  0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43,
+  0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94, 0x43, 0x1b, 0xc0, 0xc3,
+  0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0x94, 0x03,
+  0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81, 0x3b, 0xbc, 0x83, 0x3b, 0xb4, 0x01,
+  0x3b, 0x94, 0x43, 0x38, 0x98, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5,
+  0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x90, 0x0e, 0xee, 0x60, 0x0e, 0xf3,
+  0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8,
+  0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43,
+  0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3, 0x3c, 0xb4, 0x81, 0x39, 0xc0, 0x43,
+  0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f, 0xf5,
+  0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xe7,
+  0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d, 0xa0, 0x0f, 0xe5, 0x20, 0x0f, 0xef,
+  0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10, 0x0e, 0xf4,
+  0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3,
+  0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43, 0x38, 0xc0, 0x03, 0x3c, 0xa4, 0x83,
+  0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4,
+  0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0x31, 0x0f, 0xf4, 0x10, 0x0e, 0xe3,
+  0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2, 0xf0, 0x0e, 0xf4, 0x50, 0x0e, 0xe3,
+  0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d, 0x20, 0x0e, 0xf5, 0x60, 0x0e, 0xe6,
+  0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xfa, 0x50, 0x0e, 0x00,
+  0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3, 0x3c, 0x84, 0x83, 0x39, 0x94, 0x43,
+  0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03,
+  0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x6c, 0x40, 0x8e, 0xff, 0xff,
+  0xff, 0xff, 0x1f, 0x00, 0x06, 0x90, 0x80, 0x6a, 0x83, 0x81, 0x04, 0xc0,
+  0x02, 0x54, 0x1b, 0x8c, 0x44, 0x00, 0x16, 0xa0, 0xda, 0x80, 0x28, 0xff,
+  0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c, 0x20, 0x01, 0xd5, 0x06, 0x63, 0xf9,
+  0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0xc3, 0xc4, 0xfc, 0xff,
+  0xff, 0xff, 0xff, 0x00, 0x28, 0x80, 0x34, 0xb8, 0xc3, 0x3b, 0xb4, 0x81,
+  0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03, 0x3d, 0xa4, 0x83, 0x3b, 0xcc, 0x03,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40,
+  0x18, 0x88, 0x09, 0x41, 0x31, 0x21, 0x30, 0x26, 0x0c, 0x07, 0x92, 0x4c,
+  0x18, 0x14, 0x24, 0x99, 0x10, 0x2c, 0x13, 0x02, 0x06, 0x89, 0x20, 0x00,
+  0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0x9c, 0xc1,
+  0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04,
+  0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84,
+  0x41, 0x38, 0x4a, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89,
+  0x8a, 0x88, 0xdf, 0x1e, 0xfe, 0x69, 0x8c, 0x00, 0x18, 0x44, 0x28, 0x82,
+  0x8b, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x25, 0x80, 0x79, 0x16, 0x22,
+  0xfa, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x10, 0xca, 0x11, 0x04, 0x81,
+  0x40, 0x18, 0x08, 0x25, 0xc3, 0x08, 0x03, 0x50, 0x88, 0x65, 0x59, 0x16,
+  0x62, 0xca, 0x00, 0x00, 0x00, 0x39, 0x45, 0x00, 0x00, 0x82, 0xca, 0x00,
+  0x2c, 0x0b, 0x49, 0xc5, 0x58, 0x16, 0x00, 0x00, 0x00, 0xa2, 0xca, 0xb0,
+  0x2c, 0x0b, 0x59, 0x45, 0x58, 0x16, 0xc2, 0xe6, 0x08, 0x82, 0x39, 0x02,
+  0x30, 0x18, 0x46, 0x10, 0xb6, 0x82, 0x04, 0x06, 0x22, 0x68, 0x9c, 0x06,
+  0x50, 0x37, 0x10, 0x90, 0x02, 0xdb, 0x1c, 0x01, 0x28, 0x0c, 0x22, 0x00,
+  0xc2, 0x14, 0xc0, 0x08, 0xc0, 0x30, 0xc2, 0xb0, 0x0d, 0x23, 0x10, 0x1b,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x18,
+  0x05, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0x4c, 0x03,
+  0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0xe6, 0x01, 0x02,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0x13, 0x01, 0x01, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0x99, 0x80, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x54, 0x08, 0x30, 0x0c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x0c, 0x61, 0x1e, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x30, 0x17, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x43, 0x98, 0x0c, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0x21, 0xcc, 0x05, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10,
+  0xc6, 0x03, 0x02, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0b, 0x04,
+  0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0xda, 0x46, 0x00, 0x0a,
+  0xa1, 0x04, 0x8a, 0xa0, 0x20, 0x0a, 0xa8, 0x0c, 0x0a, 0xa3, 0x40, 0x0a,
+  0xa5, 0x60, 0x0a, 0xa7, 0x14, 0x28, 0x2c, 0x9c, 0x11, 0x80, 0x42, 0x28,
+  0x88, 0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x02, 0xc7, 0x12, 0x24, 0x01,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0x77, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
+  0xb7, 0x21, 0xc6, 0xe6, 0x7c, 0x00, 0x18, 0x80, 0x01, 0x95, 0xbb, 0x31,
+  0xb4, 0x30, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0xb2, 0x21, 0xc6, 0xd6, 0x7c,
+  0xc2, 0xc6, 0x30, 0x0e, 0x82, 0xe0, 0xe0, 0xd8, 0xca, 0x40, 0xda, 0xca,
+  0xe8, 0xc2, 0xd8, 0x40, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x40,
+  0x66, 0x64, 0x60, 0x64, 0x66, 0x5c, 0x68, 0x60, 0x68, 0x40, 0x50, 0xda,
+  0xca, 0xe8, 0xc2, 0xd8, 0xcc, 0xca, 0x5a, 0x66, 0x64, 0x60, 0x64, 0x66,
+  0x5c, 0x68, 0x60, 0x68, 0x52, 0x86, 0x08, 0x1f, 0x31, 0xc4, 0xd8, 0x9a,
+  0xed, 0xd9, 0x16, 0x16, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x43, 0x90, 0xef,
+  0xd8, 0x9a, 0xad, 0xd9, 0x16, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+  0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x2f,
+  0x21, 0x17, 0x96, 0x26, 0xe7, 0x32, 0xf6, 0xd6, 0x06, 0x97, 0xc6, 0x56,
+  0xe6, 0x62, 0x16, 0x36, 0x47, 0xf7, 0xd5, 0x16, 0x46, 0x87, 0xf6, 0x55,
+  0xe6, 0x16, 0x26, 0xc6, 0x56, 0x36, 0x44, 0xf8, 0x16, 0x92, 0x41, 0x58,
+  0x9a, 0x9c, 0xcb, 0xd8, 0x5b, 0x1b, 0x5c, 0x1a, 0x5b, 0x99, 0x8b, 0x99,
+  0x5c, 0x58, 0x5b, 0x99, 0x58, 0x9d, 0x99, 0x59, 0x99, 0xdc, 0x97, 0x59,
+  0x19, 0xdd, 0x18, 0xda, 0x57, 0x99, 0x5b, 0x98, 0x18, 0x5b, 0xd9, 0x10,
+  0xe1, 0x6b, 0x18, 0x85, 0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0xb9, 0x91, 0x95,
+  0xc9, 0x7d, 0xd1, 0x85, 0xc9, 0x9d, 0x95, 0xd1, 0x31, 0x0a, 0x4b, 0x93,
+  0x73, 0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x72, 0x0b,
+  0x6b, 0x2b, 0xa3, 0x61, 0xc6, 0xf6, 0x16, 0x46, 0x47, 0x33, 0x04, 0xf9,
+  0x9e, 0x6d, 0xf9, 0xa0, 0x2f, 0x1a, 0x22, 0x7c, 0x12, 0x99, 0xb0, 0x34,
+  0x39, 0x17, 0xb8, 0xb7, 0xb9, 0x34, 0xba, 0xb4, 0x37, 0x37, 0x2a, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x94, 0xc2, 0xd2,
+  0xe4, 0x5c, 0xdc, 0xde, 0xbe, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
+  0xe8, 0xd2, 0xec, 0xca, 0xc8, 0x84, 0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d,
+  0x7d, 0xb9, 0x85, 0xb5, 0x95, 0x11, 0x81, 0x7b, 0x9b, 0x4b, 0xa3, 0x4b,
+  0x7b, 0x73, 0x1b, 0x02, 0x6d, 0xcb, 0x47, 0x7d, 0xd5, 0x67, 0x7d, 0xd0,
+  0x17, 0x7d, 0xd7, 0x87, 0x51, 0x0a, 0x4b, 0x93, 0x73, 0x31, 0x93, 0x0b,
+  0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0xfb, 0x4a, 0x73, 0x83, 0xab, 0xa3, 0xa3,
+  0x75, 0x56, 0xe6, 0x56, 0x26, 0x17, 0x46, 0x57, 0x46, 0x86, 0x52, 0x33,
+  0xf6, 0xc6, 0xf6, 0x26, 0x47, 0x64, 0x47, 0xf3, 0x65, 0x96, 0xc2, 0x27,
+  0x2c, 0x4d, 0xce, 0x05, 0xae, 0x4c, 0x6e, 0x0e, 0xae, 0x6c, 0x8c, 0x2e,
+  0xcd, 0xae, 0x8c, 0xc5, 0xd8, 0x1b, 0xdb, 0x9b, 0xdc, 0x10, 0x69, 0x6b,
+  0x3e, 0xed, 0xdb, 0xbe, 0xea, 0xe3, 0x3e, 0xe8, 0x8b, 0xbe, 0xeb, 0xeb,
+  0x98, 0x9d, 0x95, 0xb9, 0x95, 0xc9, 0x85, 0xd1, 0x95, 0x91, 0xa1, 0xe0,
+  0xd0, 0x95, 0xe1, 0x8d, 0xbd, 0xbd, 0xc9, 0x91, 0x11, 0xd9, 0xc9, 0x7c,
+  0x99, 0xa5, 0xd0, 0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x93, 0x21, 0x42, 0x57,
+  0x86, 0x37, 0xf6, 0xf6, 0x26, 0x47, 0x36, 0x44, 0xda, 0x9c, 0x4f, 0xfb,
+  0xbe, 0xaf, 0xfa, 0xb8, 0x0f, 0xfa, 0xc0, 0xe0, 0xbb, 0xbe, 0x30, 0xa0,
+  0x12, 0x96, 0x26, 0xe7, 0x22, 0x56, 0x67, 0x66, 0x56, 0x26, 0xc7, 0x27,
+  0x2c, 0x4d, 0xce, 0x45, 0xac, 0xce, 0xcc, 0xac, 0x4c, 0xee, 0x6b, 0x2e,
+  0x4d, 0xaf, 0x8c, 0x52, 0x58, 0x9a, 0x9c, 0x0b, 0xdb, 0xdb, 0x58, 0x18,
+  0x5d, 0xda, 0x9b, 0xdb, 0x57, 0x9a, 0x1b, 0x59, 0x19, 0x1e, 0x91, 0xb0,
+  0x34, 0x39, 0x17, 0xb9, 0xb2, 0x30, 0x32, 0x52, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f,
+  0x69, 0x6e, 0x66, 0x6f, 0x2c, 0xcc, 0xd8, 0xde, 0xc2, 0xe8, 0xc8, 0xcc,
+  0x8d, 0x49, 0x1d, 0x09, 0x7d, 0xbd, 0xd5, 0xd1, 0xc1, 0xd5, 0xd1, 0x91,
+  0xa1, 0x2b, 0xc3, 0xa3, 0xab, 0x93, 0x2b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b,
+  0xa3, 0x92, 0xe6, 0x06, 0x57, 0x47, 0xf7, 0x45, 0x97, 0x07, 0x57, 0xc6,
+  0x65, 0xec, 0x8d, 0xed, 0x4d, 0xee, 0x6b, 0x6e, 0x2c, 0x8c, 0xad, 0x8c,
+  0x0e, 0xdd, 0x9b, 0x5b, 0x59, 0x5b, 0x18, 0xdc, 0x57, 0x5b, 0x19, 0x1d,
+  0xda, 0x1b, 0x19, 0x1f, 0xba, 0x37, 0xb7, 0xb2, 0xb6, 0x30, 0xb8, 0x2f,
+  0xb3, 0xb0, 0x31, 0xba, 0x37, 0xb9, 0x18, 0x3e, 0x74, 0x6f, 0x6e, 0x65,
+  0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x7c,
+  0xe6, 0xc8, 0xe4, 0xbe, 0xee, 0xd0, 0xd2, 0xe8, 0xca, 0xbe, 0xe0, 0xde,
+  0xd2, 0xdc, 0xe8, 0x86, 0xc0, 0xc2, 0xb6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68,
+  0xf0, 0xa5, 0xc1, 0xc6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xa9, 0xc1,
+  0xf6, 0x6c, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xad, 0xc1, 0x26, 0x6d, 0xcc,
+  0xb6, 0x7c, 0x68, 0xf0, 0xb1, 0xc1, 0x36, 0x6d, 0xcc, 0xb6, 0x7c, 0x68,
+  0xf0, 0xb5, 0xc1, 0x46, 0x6d, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xb9, 0xc1,
+  0x56, 0x6d, 0xcc, 0xb6, 0x7c, 0x68, 0xf0, 0xbd, 0xc1, 0x66, 0x6d, 0xcc,
+  0xb6, 0x7c, 0x68, 0xf0, 0xc1, 0x01, 0xa3, 0xb0, 0x34, 0x39, 0x97, 0x30,
+  0xb9, 0xb3, 0x2f, 0xba, 0x3c, 0xb8, 0xb2, 0xaf, 0xb9, 0x34, 0xbd, 0x32,
+  0x5e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x7c, 0xa6, 0xd0, 0xc2, 0xc8, 0xca, 0xe4, 0x86, 0xde, 0xdc, 0xe6, 0xe8,
+  0xc2, 0xdc, 0xe8, 0xe6, 0x18, 0x8c, 0x0d, 0x21, 0x83, 0x2d, 0xfa, 0xc6,
+  0xe0, 0x23, 0x83, 0x0d, 0xfa, 0xca, 0x60, 0x5b, 0xb6, 0xe6, 0x33, 0x83,
+  0xef, 0x0c, 0xbe, 0x38, 0xf8, 0xe4, 0x60, 0x83, 0xbe, 0x39, 0xd8, 0x98,
+  0x0f, 0xfa, 0xe8, 0xe0, 0xbb, 0xbe, 0x3a, 0xe0, 0x12, 0x96, 0x26, 0xe7,
+  0x42, 0x57, 0x86, 0x47, 0x57, 0x27, 0x57, 0x46, 0x25, 0x2c, 0x4d, 0xce,
+  0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x8c, 0x18, 0x5d, 0x19, 0x1e, 0x5d,
+  0x9d, 0x5c, 0x99, 0x0c, 0x19, 0x8f, 0x19, 0xdb, 0x5b, 0x18, 0x1d, 0x0b,
+  0xc8, 0x5c, 0x58, 0x1b, 0x1c, 0x5b, 0x99, 0x0f, 0x07, 0xba, 0x32, 0xbc,
+  0x21, 0xd4, 0xc6, 0x7c, 0x77, 0xf0, 0x95, 0xc1, 0xb6, 0x6c, 0xcd, 0x87,
+  0x07, 0x1f, 0xf4, 0xe5, 0xc1, 0x77, 0x7d, 0x7a, 0xc0, 0x25, 0x2c, 0x4d,
+  0xce, 0x65, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0x4c, 0x8e, 0xc7, 0x5c, 0x58,
+  0x1b, 0x1c, 0x5b, 0x99, 0x1c, 0x83, 0xb9, 0x21, 0xd2, 0x76, 0x7d, 0x7c,
+  0xf0, 0x95, 0xc1, 0xb6, 0x6c, 0xcd, 0x07, 0x7d, 0x7d, 0xf0, 0x5d, 0x9f,
+  0x1f, 0x0c, 0x61, 0xbe, 0xec, 0xf3, 0x3e, 0x31, 0xf8, 0xec, 0xe0, 0xdb,
+  0x83, 0xef, 0x0f, 0x86, 0x18, 0x0a, 0xf0, 0x4d, 0x1f, 0x28, 0x70, 0x0c,
+  0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8, 0xd2, 0xc2, 0xe6, 0x5a, 0xe6, 0xc6,
+  0xde, 0xe0, 0xca, 0xe6, 0x50, 0xa6, 0x88, 0x98, 0xbe, 0x86, 0xde, 0xe0,
+  0xf2, 0xbe, 0xcc, 0xe4, 0xc2, 0xce, 0xda, 0xca, 0xdc, 0xe8, 0x52, 0x86,
+  0x10, 0xdf, 0x28, 0x7c, 0xa2, 0x40, 0x2c, 0x2c, 0x4d, 0xae, 0x25, 0x8c,
+  0x2d, 0x2d, 0x6c, 0xae, 0x65, 0x6e, 0xec, 0x0d, 0xae, 0xac, 0x85, 0xae,
+  0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x6c, 0x6e, 0x88, 0xf1, 0x95, 0xc2, 0x37,
+  0x0a, 0x1f, 0x29, 0x10, 0x0b, 0x4b, 0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b,
+  0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83, 0x2b, 0x6b, 0x99, 0x0b, 0x6b, 0x83,
+  0x63, 0x2b, 0x93, 0x9b, 0x1b, 0x62, 0x7c, 0xa7, 0xf0, 0x8d, 0xc2, 0x67,
+  0x0a, 0x43, 0x88, 0xaf, 0x14, 0xbe, 0x53, 0xa0, 0x15, 0x96, 0x26, 0xd7,
+  0x12, 0xc6, 0x96, 0x16, 0x36, 0xd7, 0x32, 0x37, 0xf6, 0x06, 0x57, 0xd6,
+  0x12, 0x26, 0x77, 0x86, 0x32, 0x93, 0x32, 0xc4, 0xf8, 0x54, 0xe1, 0x1b,
+  0x85, 0x2f, 0x15, 0x86, 0x08, 0x9f, 0x2a, 0xb0, 0xfa, 0xd2, 0xa2, 0x9a,
+  0x8a, 0xa9, 0x99, 0x42, 0x0b, 0x23, 0x2b, 0x93, 0x1b, 0x7a, 0x73, 0x9b,
+  0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0xe3, 0xf3, 0xd6, 0xe6, 0x96, 0x06, 0xf7,
+  0x46, 0x57, 0xe6, 0x46, 0x07, 0x32, 0x86, 0x16, 0x26, 0xc7, 0x67, 0x2a,
+  0xad, 0x0d, 0x8e, 0xad, 0x0c, 0x64, 0x68, 0x65, 0x05, 0x84, 0x4a, 0x28,
+  0x28, 0x68, 0x88, 0xf0, 0xb9, 0xc2, 0x10, 0xe3, 0x6b, 0x85, 0xef, 0x15,
+  0xc2, 0x20, 0x1b, 0x62, 0x7c, 0x68, 0xf0, 0xc1, 0x42, 0x18, 0x64, 0x43,
+  0xc4, 0xe0, 0x63, 0x85, 0x2f, 0x16, 0xc2, 0x20, 0xfb, 0x62, 0x21, 0x0c,
+  0xb4, 0x2f, 0x16, 0xc2, 0x60, 0xfb, 0x62, 0x21, 0x0c, 0xb8, 0x2f, 0x16,
+  0xc2, 0xa0, 0xfb, 0x62, 0x21, 0x0c, 0xbc, 0x2f, 0x16, 0xc2, 0xe0, 0xfb,
+  0x62, 0x21, 0x0c, 0xb0, 0x21, 0xc6, 0x27, 0x0b, 0x5f, 0x2c, 0x84, 0xc1,
+  0x36, 0xc4, 0xf8, 0x64, 0xe1, 0x8b, 0x85, 0x30, 0xc0, 0x86, 0x18, 0x9f,
+  0x2c, 0x7c, 0xb1, 0x10, 0x06, 0xdd, 0x10, 0xe3, 0x93, 0x85, 0x2f, 0x16,
+  0xc2, 0xc0, 0x1b, 0x62, 0x7c, 0xb2, 0xf0, 0xc5, 0x42, 0x18, 0x7c, 0x43,
+  0x8c, 0x4f, 0x16, 0xbe, 0x58, 0x08, 0x03, 0x6d, 0x88, 0xf1, 0xc9, 0xc2,
+  0x17, 0x0b, 0x61, 0xc0, 0x0d, 0x31, 0x3e, 0x59, 0xf8, 0x62, 0x21, 0x0c,
+  0xb2, 0x11, 0x11, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0xb4, 0xc3,
+  0x3b, 0x90, 0x43, 0x3d, 0xb0, 0x43, 0x39, 0xb8, 0x81, 0x39, 0xb0, 0x43,
+  0x38, 0x9c, 0xc3, 0x3c, 0x4c, 0x11, 0x82, 0x61, 0x84, 0xc2, 0x0e, 0xec,
+  0x60, 0x0f, 0xed, 0xe0, 0x06, 0xe9, 0x40, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4,
+  0x30, 0x25, 0x28, 0x46, 0x2c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xf6,
+  0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x30,
+  0x46, 0x50, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xec, 0x10, 0x0e, 0xee,
+  0x70, 0x0e, 0xf5, 0x10, 0x0e, 0xe7, 0x50, 0x0e, 0xbf, 0x60, 0x0f, 0xe5,
+  0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53, 0x02, 0x64, 0xc4,
+  0x14, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x30, 0x0e, 0xef, 0xd0, 0x0e, 0xf0,
+  0x90, 0x0e, 0xec, 0x50, 0x0e, 0xbf, 0xf0, 0x0e, 0xf0, 0x40, 0x0f, 0xe9,
+  0xf0, 0x0e, 0xee, 0x30, 0x0f, 0x53, 0x06, 0x85, 0x71, 0x46, 0x30, 0xe1,
+  0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe6, 0x20, 0x0f, 0xe1, 0x70, 0x0e, 0xed,
+  0x50, 0x0e, 0xee, 0x40, 0x0f, 0x53, 0x82, 0x50, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x2e, 0x00, 0x00,
+  0x00, 0x06, 0x10, 0xb1, 0x5d, 0xf9, 0x73, 0xce, 0x83, 0xfd, 0x45, 0x04,
+  0x18, 0x0c, 0xd1, 0x4c, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf, 0xb3,
+  0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45, 0x51,
+  0x14, 0x46, 0xd0, 0x00, 0x48, 0xe4, 0x0f, 0xce, 0xe4, 0x57, 0x77, 0x71,
+  0xdb, 0xa6, 0xb0, 0x01, 0x48, 0xe4, 0x4b, 0x00, 0xf3, 0x2c, 0xc4, 0x3f,
+  0x11, 0xd7, 0x44, 0x45, 0xc4, 0x6f, 0x0f, 0x7e, 0x85, 0x17, 0xb7, 0x6d,
+  0x08, 0x13, 0x80, 0x44, 0x7e, 0x01, 0x48, 0xd3, 0x5f, 0x00, 0x81, 0xe4,
+  0x57, 0x77, 0x71, 0xdb, 0x16, 0x40, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34,
+  0xfd, 0xc2, 0x02, 0x30, 0x8f, 0x5f, 0xdd, 0xc5, 0x6d, 0x5b, 0xc2, 0x04,
+  0x20, 0x91, 0x5f, 0x00, 0xd2, 0xf4, 0x17, 0x0c, 0x70, 0xf9, 0xd5, 0x5d,
+  0xdc, 0xb6, 0x09, 0x40, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0xff, 0xe3,
+  0x58, 0x7e, 0x71, 0xdb, 0x36, 0x10, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34,
+  0xfd, 0x05, 0x10, 0x48, 0x7e, 0x71, 0xdb, 0x66, 0x10, 0x01, 0x48, 0xe4,
+  0x17, 0x80, 0x34, 0xfd, 0x05, 0x03, 0x5c, 0x7e, 0x71, 0xdb, 0x76, 0x20,
+  0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x8f, 0x63, 0xf9, 0xd5, 0x5d,
+  0xdc, 0x36, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x9a, 0x01, 0x00,
+  0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00, 0x00, 0x51, 0x00, 0x00,
+  0x00, 0x64, 0x8e, 0x45, 0x00, 0x81, 0x70, 0xcc, 0x41, 0x2c, 0x8d, 0xd3,
+  0x06, 0x54, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xdc, 0x08, 0x00,
+  0x6d, 0xc5, 0x30, 0x03, 0x50, 0x0e, 0xa4, 0x8d, 0x00, 0xd4, 0x00, 0x01,
+  0x63, 0x04, 0xef, 0x9e, 0x96, 0xf7, 0x37, 0x46, 0xa0, 0xb3, 0xe6, 0x1c,
+  0x82, 0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x09, 0x06, 0x63, 0x04, 0x20,
+  0x08, 0x82, 0x20, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03, 0x30, 0x03, 0x30,
+  0x07, 0x91, 0x0a, 0xaf, 0x90, 0x0a, 0x75, 0x40, 0xcb, 0x0c, 0xc0, 0x08,
+  0xc0, 0x0c, 0xc0, 0x58, 0x03, 0x08, 0x82, 0x20, 0xfe, 0x81, 0x20, 0x08,
+  0xe2, 0x1f, 0x08, 0x82, 0x20, 0xfe, 0x8d, 0x35, 0xb0, 0xed, 0xfc, 0x93,
+  0x1e, 0xdb, 0xce, 0x3f, 0xe9, 0xb1, 0xed, 0xfc, 0x93, 0xde, 0x58, 0x03,
+  0x08, 0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20,
+  0xc8, 0xd6, 0xbf, 0x30, 0xd6, 0x00, 0x82, 0xe0, 0x9a, 0x83, 0x01, 0x08,
+  0x82, 0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x8c, 0x35, 0x80,
+  0x20, 0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2,
+  0x6d, 0x0e, 0x06, 0x63, 0x0d, 0xeb, 0x88, 0xc7, 0x2c, 0x18, 0xac, 0x23,
+  0x1e, 0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x58, 0x03, 0x08,
+  0xc2, 0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c,
+  0x87, 0x63, 0x30, 0xd6, 0x20, 0xe6, 0x62, 0xda, 0x7f, 0x60, 0xc9, 0xb3,
+  0xf1, 0x2f, 0x8c, 0xe9, 0xaa, 0xe6, 0xbe, 0x30, 0xd6, 0xf0, 0xcf, 0xa4,
+  0xff, 0xfb, 0x02, 0x5d, 0x83, 0x62, 0xfe, 0xb5, 0x70, 0x1c, 0x83, 0xbe,
+  0x30, 0xd6, 0x30, 0xf7, 0x6d, 0x9a, 0xfa, 0x42, 0xeb, 0x86, 0x3c, 0xef,
+  0x0b, 0x7c, 0xce, 0xfa, 0xf8, 0x47, 0xc0, 0x18, 0x81, 0xdb, 0xc7, 0xa2,
+  0xed, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0x79, 0xaf,
+  0xab, 0xec, 0x8d, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0xdb,
+  0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba, 0xf8, 0x37, 0x46,
+  0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8, 0xf6, 0x34, 0x18,
+  0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x23, 0x06, 0x4a, 0x11, 0x98, 0xc2, 0x1a, 0xa8, 0x41, 0x1b, 0x80,
+  0x41, 0x19, 0x84, 0x41, 0x30, 0xde, 0xd0, 0x06, 0x78, 0x30, 0x0a, 0x14,
+  0x8c, 0xe1, 0x86, 0x00, 0x0c, 0x82, 0x59, 0x86, 0x40, 0x08, 0x06, 0x19,
+  0x08, 0x4f, 0x0d, 0xc6, 0x1b, 0xe2, 0x80, 0x0f, 0xce, 0x80, 0x82, 0x31,
+  0x62, 0x40, 0x18, 0xc1, 0x2b, 0x0c, 0x23, 0x06, 0x85, 0x11, 0xc4, 0x42,
+  0xb0, 0x59, 0xb0, 0xc1, 0x67, 0xc4, 0xa0, 0x30, 0x82, 0x58, 0x08, 0xc0,
+  0xc0, 0x06, 0x4e, 0x3e, 0xc6, 0x05, 0xf1, 0xb1, 0x21, 0xa0, 0xcf, 0x88,
+  0x01, 0x61, 0x04, 0xb6, 0x10, 0x8c, 0x18, 0x14, 0x46, 0x80, 0x0b, 0x81,
+  0x67, 0x81, 0x27, 0x9f, 0x39, 0x06, 0x34, 0x58, 0x6c, 0x61, 0x90, 0x21,
+  0x48, 0x83, 0x3c, 0xb0, 0x21, 0xa0, 0xcf, 0x20, 0x43, 0xb0, 0x06, 0x7c,
+  0x30, 0xc8, 0x10, 0x54, 0x7e, 0x30, 0x4b, 0x20, 0x0c, 0x54, 0x04, 0x42,
+  0xc0, 0x06, 0xc0, 0x78, 0xc3, 0x28, 0xb8, 0xc2, 0x2e, 0x50, 0x30, 0x86,
+  0x1b, 0x02, 0xcd, 0x99, 0x65, 0x18, 0x88, 0x60, 0x90, 0x81, 0xa0, 0x03,
+  0x50, 0x18, 0x6f, 0x38, 0x05, 0x59, 0xa0, 0x05, 0x0a, 0xc6, 0x78, 0x43,
+  0x2a, 0xd0, 0x42, 0x28, 0x50, 0x30, 0x46, 0x0c, 0x90, 0x23, 0x52, 0x87,
+  0xa2, 0x3b, 0x86, 0x60, 0x90, 0x21, 0xb8, 0x03, 0x54, 0x18, 0x64, 0x08,
+  0x16, 0x55, 0x98, 0x25, 0x20, 0x06, 0x2a, 0x02, 0x61, 0xc0, 0x84, 0xe1,
+  0x86, 0x30, 0x50, 0x83, 0x60, 0x96, 0xa1, 0x98, 0x82, 0xf1, 0x06, 0x58,
+  0xd8, 0x85, 0x73, 0xa0, 0x60, 0x0c, 0x37, 0x04, 0x6d, 0x10, 0xcc, 0x32,
+  0x18, 0x47, 0x30, 0xc8, 0x50, 0x84, 0x42, 0x2b, 0x8c, 0x37, 0xd0, 0xc2,
+  0x2f, 0x9c, 0x03, 0x05, 0x63, 0x8e, 0x21, 0x14, 0x82, 0x77, 0x18, 0x64,
+  0x08, 0x44, 0x41, 0x16, 0x2c, 0x28, 0xe4, 0x33, 0xc8, 0x10, 0x90, 0x42,
+  0x2d, 0xcc, 0x12, 0xb4, 0xc1, 0x78, 0x83, 0x2e, 0x94, 0xc3, 0x3c, 0x50,
+  0x30, 0xc6, 0x1b, 0x78, 0xe1, 0x1c, 0xde, 0x81, 0x82, 0x31, 0xc8, 0x00,
+  0xb1, 0x82, 0x2e, 0x0c, 0x37, 0x10, 0x74, 0xe0, 0xcc, 0x32, 0x20, 0x52,
+  0x30, 0x86, 0x20, 0xe5, 0xc3, 0x70, 0x43, 0xd0, 0x07, 0xca, 0x2c, 0x83,
+  0x92, 0x04, 0x26, 0xfc, 0x81, 0x7c, 0x66, 0x09, 0x16, 0x1b, 0x42, 0x01,
+  0x3e, 0x23, 0x06, 0x84, 0x11, 0x94, 0x44, 0x60, 0x01, 0x2e, 0xc8, 0x67,
+  0xc4, 0xa0, 0x30, 0x02, 0x94, 0x08, 0x70, 0x61, 0x96, 0x60, 0x19, 0xa8,
+  0x00, 0x94, 0x44, 0x50, 0xe6, 0x18, 0x6a, 0x21, 0x08, 0x89, 0x31, 0x84,
+  0x0d, 0x24, 0x86, 0x1b, 0x02, 0x53, 0x50, 0x66, 0x19, 0x1a, 0x26, 0x30,
+  0x01, 0x15, 0xe4, 0x33, 0x4b, 0xe0, 0xd8, 0xa0, 0x0a, 0xf0, 0x19, 0x31,
+  0x20, 0x8c, 0xc0, 0x25, 0x02, 0x0b, 0xc2, 0x41, 0x3e, 0x23, 0x06, 0x85,
+  0x11, 0xc4, 0x44, 0x10, 0x0e, 0xb3, 0x04, 0xce, 0x40, 0x05, 0xa0, 0x30,
+  0x42, 0x33, 0xc7, 0x90, 0x04, 0x28, 0x31, 0x86, 0x40, 0x06, 0x28, 0x31,
+  0xdc, 0x10, 0xbc, 0x82, 0x32, 0xcb, 0x00, 0x3d, 0x81, 0x09, 0xb1, 0x20,
+  0x9f, 0x59, 0x82, 0xc8, 0x86, 0x59, 0x80, 0xcf, 0x88, 0x01, 0x61, 0x04,
+  0x37, 0x11, 0x58, 0xa0, 0x0e, 0xf2, 0x19, 0x31, 0x28, 0x8c, 0x40, 0x27,
+  0x02, 0x75, 0x98, 0x25, 0x88, 0x06, 0x2a, 0x00, 0xe5, 0x11, 0xa0, 0x39,
+  0x86, 0x24, 0x80, 0x89, 0x59, 0x02, 0x69, 0xa0, 0x22, 0x10, 0x22, 0x3d,
+  0x38, 0x06, 0x19, 0x02, 0x75, 0xb0, 0x87, 0x39, 0x06, 0x74, 0x00, 0x03,
+  0x9b, 0x18, 0x64, 0x08, 0xd2, 0x21, 0x1f, 0x6c, 0x08, 0xe4, 0x33, 0xc8,
+  0x10, 0xac, 0x03, 0x3f, 0xcc, 0x12, 0xb4, 0xc1, 0x70, 0xc3, 0x2c, 0xc4,
+  0x43, 0x30, 0xcb, 0x40, 0x81, 0x41, 0x30, 0xc8, 0x40, 0x07, 0xf0, 0xc0,
+  0x0f, 0xe3, 0x0d, 0x23, 0xe1, 0x12, 0x3c, 0x41, 0xc1, 0x18, 0x6f, 0x28,
+  0x09, 0x98, 0xc0, 0x09, 0x0a, 0xc6, 0x1c, 0x83, 0x3c, 0x04, 0x60, 0x31,
+  0xc8, 0x10, 0xcc, 0xc3, 0x48, 0x58, 0x70, 0xc8, 0x67, 0x90, 0x21, 0xa8,
+  0x07, 0x93, 0x18, 0x6e, 0x38, 0xc0, 0xc1, 0x99, 0x65, 0xf8, 0xaa, 0x60,
+  0x0c, 0x61, 0x28, 0x8b, 0xe1, 0x86, 0x60, 0x1c, 0x94, 0x59, 0x86, 0xcb,
+  0x0a, 0x4c, 0x28, 0x07, 0xf9, 0xcc, 0x12, 0x60, 0x23, 0x06, 0x84, 0x11,
+  0xc0, 0xc5, 0x30, 0x62, 0x50, 0x18, 0x81, 0x5c, 0x04, 0xe8, 0x60, 0x81,
+  0x3a, 0xc8, 0xc7, 0x02, 0x76, 0x80, 0xcf, 0x2c, 0x01, 0x36, 0x50, 0x01,
+  0x28, 0x96, 0x70, 0xcd, 0x31, 0xf4, 0x43, 0xd0, 0x16, 0x63, 0x08, 0x0c,
+  0x5b, 0x0c, 0x37, 0x04, 0xec, 0xa0, 0xcc, 0x32, 0x68, 0x59, 0x60, 0x82,
+  0x3b, 0xc8, 0x67, 0x96, 0x60, 0x1b, 0x31, 0x20, 0x8c, 0x20, 0x2f, 0x86,
+  0x11, 0x83, 0xc2, 0x08, 0xf6, 0x22, 0x88, 0x07, 0x0b, 0xe6, 0x41, 0x3e,
+  0x16, 0xd4, 0x03, 0x7c, 0x66, 0x09, 0xb6, 0x81, 0x0a, 0x40, 0xc9, 0x04,
+  0x6d, 0x8e, 0x21, 0x09, 0xe8, 0x62, 0x0c, 0xa1, 0xa2, 0x8b, 0xe1, 0x86,
+  0xa0, 0x1e, 0x94, 0x59, 0x86, 0x8e, 0x0b, 0x4c, 0xb8, 0x07, 0xf9, 0xcc,
+  0x12, 0x78, 0x23, 0x06, 0x84, 0x11, 0x88, 0xc6, 0x30, 0x62, 0x50, 0x18,
+  0x01, 0x69, 0x04, 0xfa, 0x60, 0x01, 0x3f, 0xc8, 0xc7, 0x02, 0x7f, 0x80,
+  0xcf, 0x2c, 0x81, 0x37, 0x50, 0x01, 0x28, 0x9c, 0xd0, 0xcd, 0x31, 0x24,
+  0x01, 0x5f, 0x8c, 0x18, 0x18, 0x46, 0xa0, 0x1a, 0x41, 0x4c, 0xbc, 0xc4,
+  0x20, 0x43, 0x30, 0x13, 0x64, 0x31, 0x4b, 0xf0, 0x0d, 0x54, 0x04, 0x7e,
+  0x40, 0x09, 0xde, 0x20, 0x43, 0x80, 0x13, 0x66, 0x31, 0x4b, 0xd0, 0x06,
+  0xb3, 0x0c, 0x61, 0xd0, 0x06, 0xfc, 0x30, 0xc8, 0xd0, 0x0b, 0x39, 0x51,
+  0x16, 0x23, 0x06, 0x85, 0x11, 0xb0, 0x46, 0xd0, 0x12, 0x73, 0x0c, 0x36,
+  0x11, 0x98, 0xc6, 0x88, 0x41, 0x61, 0x04, 0xae, 0x31, 0xb8, 0xc4, 0x1c,
+  0x83, 0x10, 0x98, 0xc6, 0x88, 0x41, 0x61, 0x04, 0xb0, 0x51, 0xbc, 0xc4,
+  0x1c, 0x83, 0x10, 0x9c, 0xc6, 0x20, 0x43, 0xd0, 0x13, 0x6e, 0x31, 0xc8,
+  0x10, 0x94, 0x03, 0x5c, 0x8c, 0x37, 0xd0, 0xc5, 0x5f, 0xb4, 0x06, 0x05,
+  0x63, 0xbc, 0xc1, 0x2e, 0x42, 0x23, 0x35, 0x28, 0x18, 0x73, 0x0c, 0x63,
+  0x11, 0xc4, 0xc6, 0x20, 0x43, 0x40, 0x16, 0x74, 0x61, 0x41, 0x22, 0x9f,
+  0x41, 0x86, 0xc0, 0x2c, 0xee, 0x62, 0xb8, 0xe1, 0x88, 0x09, 0x67, 0x96,
+  0x81, 0x0d, 0xc4, 0x20, 0x18, 0x43, 0x18, 0x6c, 0x63, 0xb8, 0x21, 0xa0,
+  0x09, 0x65, 0x96, 0x81, 0x0c, 0xc6, 0x20, 0x30, 0xc1, 0x26, 0xe4, 0x33,
+  0x4b, 0x50, 0x06, 0x23, 0x06, 0x84, 0x11, 0x84, 0xc7, 0x30, 0x62, 0x50,
+  0x18, 0xc1, 0x78, 0x04, 0x39, 0x61, 0xc1, 0x4e, 0xc8, 0xc7, 0x82, 0x9e,
+  0x80, 0xcf, 0x2c, 0x41, 0x19, 0x0c, 0x54, 0x00, 0xca, 0x18, 0x08, 0x64,
+  0x30, 0xc7, 0xe0, 0x16, 0x81, 0x6f, 0x8c, 0x21, 0x30, 0xbd, 0x31, 0xdc,
+  0x10, 0xf4, 0x84, 0x32, 0xcb, 0x70, 0x06, 0x66, 0x10, 0x98, 0xf0, 0x13,
+  0xf2, 0x99, 0x25, 0x40, 0x83, 0x11, 0x03, 0xc2, 0x08, 0xd4, 0x63, 0x18,
+  0x31, 0x28, 0x8c, 0x80, 0x3d, 0x02, 0xb1, 0xb0, 0x80, 0x2c, 0xe4, 0x63,
+  0x81, 0x59, 0xc0, 0x67, 0x96, 0x00, 0x0d, 0x06, 0x2a, 0x00, 0xc5, 0x0c,
+  0x84, 0x33, 0x98, 0x63, 0x48, 0x82, 0xf2, 0x18, 0x43, 0xa8, 0xca, 0x63,
+  0xb8, 0x21, 0x30, 0x0b, 0x65, 0x96, 0x41, 0x0d, 0xd2, 0x20, 0x30, 0x01,
+  0x2d, 0xe4, 0x33, 0x4b, 0xb0, 0x06, 0x23, 0x06, 0x84, 0x11, 0xcc, 0xc7,
+  0x30, 0x62, 0x50, 0x18, 0x41, 0x7d, 0x04, 0x6b, 0x61, 0x41, 0x5b, 0xc8,
+  0xc7, 0x82, 0xb7, 0x80, 0xcf, 0x2c, 0xc1, 0x1a, 0x0c, 0x54, 0x00, 0x4a,
+  0x1a, 0x08, 0x6a, 0x30, 0xc7, 0x90, 0x04, 0xed, 0x31, 0x62, 0x60, 0x18,
+  0xc1, 0x7e, 0x04, 0xa2, 0x01, 0x1a, 0x83, 0x0c, 0x01, 0x69, 0xd4, 0xc6,
+  0x2c, 0x01, 0x1b, 0x0c, 0x54, 0x04, 0x7e, 0x10, 0x06, 0xc2, 0x1a, 0x0c,
+  0x32, 0x04, 0xa9, 0x71, 0x1b, 0xb3, 0x04, 0x6d, 0x30, 0xd0, 0x12, 0xf0,
+  0x88, 0xc1, 0x23, 0x12, 0x8f, 0x7c, 0xb2, 0xc0, 0x06, 0x3c, 0x02, 0x06,
+  0x03, 0x2d, 0x01, 0x8a, 0x18, 0x7a, 0x21, 0x99, 0xc3, 0x47, 0xb0, 0x81,
+  0xcc, 0x80, 0xc1, 0x20, 0x43, 0x20, 0xec, 0x86, 0x05, 0xe1, 0x21, 0x9f,
+  0x0c, 0xc2, 0x81, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xd7, 0xd2, 0x07,
+  0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4, 0x50, 0x13, 0xe7, 0x2c,
+  0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d, 0x9b, 0x6d, 0x29, 0x38,
+  0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b, 0x00, 0x03, 0x11, 0x71,
+  0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71, 0x21, 0x13, 0x00, 0x00,
+  0x00, 0x01, 0x31, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x5b, 0x0a, 0xe0,
+  0x40, 0x05, 0x64, 0x15, 0xb6, 0x0c, 0x42, 0x30, 0x0b, 0x5b, 0x86, 0x23,
+  0xa0, 0x85, 0x2d, 0x83, 0x16, 0xd4, 0xc2, 0x96, 0xe1, 0x0b, 0x6c, 0x61,
+  0xcb, 0x10, 0x06, 0xc1, 0x2d, 0x6c, 0x19, 0xd4, 0x20, 0xc0, 0x85, 0x2d,
+  0xc3, 0x1b, 0x04, 0xb9, 0xb0, 0x65, 0xb0, 0x83, 0x40, 0x17, 0xb6, 0x0c,
+  0x78, 0x10, 0xe4, 0xc2, 0x96, 0x81, 0x1d, 0x02, 0x5d, 0xd8, 0x32, 0xb8,
+  0x43, 0x90, 0x0b, 0x5b, 0x06, 0xb5, 0x08, 0x74, 0x61, 0xcb, 0xc0, 0x16,
+  0x41, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x24, 0x00, 0x00, 0x00, 0x64, 0xce, 0x41, 0x2c, 0x8d, 0x93, 0x06,
+  0x54, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xdb, 0x0c, 0x00, 0x05,
+  0x33, 0x00, 0xb4, 0xcc, 0x00, 0x8c, 0x35, 0xb0, 0xec, 0x19, 0xca, 0x1f,
+  0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce, 0xde, 0x58, 0x83, 0x5e,
+  0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf, 0xdb, 0xa7, 0xf4, 0xe8,
+  0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a, 0xc2, 0xe8, 0xee, 0xdd,
+  0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25,
+  0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f,
+  0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c,
+  0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2,
+  0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05, 0x33, 0x00, 0x04, 0x8c,
+  0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x46, 0x00, 0x82,
+  0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5, 0x02, 0x0d, 0x37, 0x50,
+  0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43, 0x43, 0xb5, 0xc1, 0x20,
+  0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64, 0x08, 0xa0, 0x6a, 0x96,
+  0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61, 0x48, 0x82, 0xe1, 0x86,
+  0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31, 0x28, 0x8c, 0x40, 0x0f,
+  0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xe8, 0x60, 0xc4, 0xa0, 0x30, 0x02, 0x3e,
+  0xf8, 0xa6, 0x39, 0x06, 0x21, 0xa0, 0x83, 0x11, 0x83, 0xc2, 0x08, 0xfc,
+  0x20, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xa8, 0x83, 0x59, 0x82, 0x62, 0xa0,
+  0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xf4, 0x60, 0x0c, 0x41, 0xc8,
+  0x83, 0x31, 0x84, 0x21, 0x0f, 0x46, 0x0c, 0x0a, 0x23, 0x10, 0x05, 0x21,
+  0x18, 0x31, 0x28, 0x8c, 0x60, 0x14, 0x88, 0x60, 0xb8, 0x21, 0xb8, 0x84,
+  0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c, 0x0c, 0x6c, 0x40, 0x03,
+  0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90, 0x8f, 0x05, 0x1a, 0x7c,
+  0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81, 0x29, 0x0c, 0x32, 0x04,
+  0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64, 0x08, 0xd2, 0xc0, 0x0d,
+  0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4, 0xa0, 0x98, 0x65, 0x40,
+  0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18, 0x31, 0x28, 0x8c, 0x60,
+  0x16, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0xa0, 0x15, 0x46, 0x0c, 0x0a,
+  0x23, 0xa8, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84, 0xa0, 0x15, 0x46, 0x0c,
+  0x0a, 0x23, 0xb8, 0x85, 0x42, 0x0d, 0xe6, 0x18, 0x84, 0xc0, 0x15, 0x66,
+  0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57, 0x10, 0x04, 0x04, 0x3a,
+  0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0xc0, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x21, 0x0c, 0x00, 0x00, 0xed, 0x06, 0x00,
+  0x00, 0x0b, 0x82, 0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90,
+  0x21, 0x23, 0xc4, 0x52, 0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8,
+  0x88, 0x11, 0x62, 0xa8, 0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00,
+  0x00, 0x51, 0x18, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70,
+  0x80, 0x07, 0x78, 0x90, 0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a,
+  0x70, 0x87, 0x71, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2,
+  0x1d, 0xd2, 0xc1, 0x1d, 0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81,
+  0x1d, 0xda, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1,
+  0x0d, 0xee, 0x21, 0x1d, 0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39,
+  0xc0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74,
+  0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74,
+  0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
+  0xc3, 0x26, 0x10, 0xc0, 0x02, 0x54, 0x43, 0x38, 0xa4, 0x83, 0x3c, 0xb4,
+  0x81, 0x38, 0xd4, 0x83, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0xb8,
+  0xc3, 0x3b, 0xb4, 0x41, 0x38, 0xb0, 0x43, 0x3a, 0x84, 0xc3, 0x3c, 0x00,
+  0x1b, 0xb6, 0xa1, 0x00, 0x16, 0xa0, 0x1a, 0xc2, 0x21, 0x1d, 0xe4, 0xa1,
+  0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0,
+  0x1d, 0xde, 0xa1, 0x0d, 0xc2, 0x81, 0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01,
+  0xd8, 0x60, 0x10, 0x06, 0xb0, 0x00, 0xd5, 0x06, 0xa3, 0x40, 0x80, 0x05,
+  0xa8, 0x36, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50,
+  0x1b, 0x7c, 0xe4, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a,
+  0x08, 0x07, 0x78, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73,
+  0xa8, 0x07, 0x77, 0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xda, 0x21, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21,
+  0x1c, 0xd8, 0xa1, 0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41,
+  0x1e, 0xda, 0xe0, 0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x3c,
+  0xb0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74,
+  0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78,
+  0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72,
+  0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1,
+  0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41,
+  0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74,
+  0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d,
+  0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01,
+  0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79,
+  0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77,
+  0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71,
+  0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74,
+  0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60,
+  0x03, 0x82, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x80, 0x04, 0x54,
+  0x1b, 0x8c, 0x24, 0x00, 0x16, 0xa0, 0xda, 0x60, 0x28, 0x02, 0xb0, 0x00,
+  0xd5, 0x06, 0x64, 0xf9, 0xff, 0xff, 0xff, 0xff, 0x01, 0x60, 0x00, 0x09,
+  0xa8, 0x36, 0x18, 0xcc, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x04, 0x50,
+  0x1b, 0xa6, 0xe6, 0xff, 0xff, 0xff, 0xff, 0x07, 0x40, 0x01, 0xa4, 0xc1,
+  0x1d, 0xde, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xd2, 0x81, 0x1d, 0xe8, 0x21,
+  0x1d, 0xdc, 0x61, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x07, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40, 0x18, 0x88, 0x62, 0x42,
+  0x60, 0x4c, 0x08, 0x8e, 0x09, 0x03, 0x92, 0x28, 0x13, 0x86, 0x25, 0x51,
+  0x26, 0x04, 0xcc, 0x84, 0xa0, 0x01, 0x00, 0x00, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x4d, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xc8, 0xc1,
+  0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04,
+  0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84,
+  0x41, 0x18, 0x46, 0x18, 0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xc6, 0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e,
+  0xc2, 0x81, 0x1d, 0xf4, 0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e,
+  0xd2, 0x01, 0x1f, 0x50, 0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe,
+  0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40,
+  0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8,
+  0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0x38,
+  0x4d, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88,
+  0xdf, 0x1e, 0x7e, 0x20, 0x8a, 0x00, 0xec, 0x9f, 0xc6, 0x08, 0x80, 0x41,
+  0x04, 0x26, 0xb8, 0x48, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98,
+  0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x1c, 0xa1, 0x24,
+  0x41, 0x10, 0x08, 0x44, 0xb2, 0x34, 0x0f, 0x41, 0x85, 0x28, 0x8a, 0xa2,
+  0x20, 0xa9, 0x0c, 0x00, 0x00, 0x10, 0x55, 0x04, 0x00, 0x20, 0xab, 0x0c,
+  0x40, 0x51, 0x10, 0x56, 0x8c, 0xa2, 0x00, 0x00, 0x00, 0x20, 0xad, 0x0c,
+  0x45, 0x51, 0x10, 0x57, 0x84, 0xa2, 0x20, 0x6f, 0x8e, 0x00, 0x0c, 0xe6,
+  0x08, 0x82, 0x61, 0x04, 0x01, 0x0c, 0x4a, 0x12, 0x34, 0x8f, 0x00, 0x86,
+  0x62, 0x08, 0xd0, 0x58, 0x90, 0x60, 0x79, 0x84, 0x50, 0x0c, 0x01, 0x2a,
+  0x07, 0x02, 0x52, 0x00, 0x1c, 0x46, 0x18, 0xc0, 0x60, 0x10, 0x21, 0x10,
+  0xe6, 0x08, 0x40, 0x61, 0x10, 0xe1, 0x10, 0x06, 0x11, 0x0a, 0x61, 0x10,
+  0x01, 0x10, 0xa6, 0x00, 0x46, 0x00, 0x86, 0x11, 0x08, 0x30, 0x00, 0x00,
+  0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0, 0x03, 0x3a, 0x68, 0x83,
+  0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68, 0x83, 0x74, 0x78, 0x87,
+  0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80, 0x83, 0x0d, 0xb7, 0x51,
+  0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x7a, 0x80,
+  0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78, 0xa0, 0x07, 0x78, 0xa0,
+  0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9, 0x30, 0x07, 0x72, 0xa0,
+  0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe9, 0x60,
+  0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0,
+  0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x76, 0xa0,
+  0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20,
+  0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0,
+  0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30,
+  0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78, 0xa0, 0x07, 0x76, 0x40,
+  0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x60, 0x07, 0x74, 0xa0,
+  0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6, 0x90,
+  0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xa0, 0x07, 0x71, 0x20,
+  0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10,
+  0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x6d, 0x60,
+  0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xa0,
+  0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60,
+  0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10,
+  0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x10,
+  0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71, 0x00, 0x07, 0x72, 0x40,
+  0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xd0, 0x06, 0xee, 0x80,
+  0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x43, 0x98,
+  0x08, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x04,
+  0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10, 0xa6, 0x02, 0x02,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08, 0x73, 0x01, 0x01, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0xc9, 0x80, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x6c, 0x08, 0x30, 0x0c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x0c, 0x61, 0x2a, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x86, 0x30, 0x1d, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x43, 0x98, 0x0f, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0x21, 0x4c, 0x07, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x10,
+  0x86, 0x0c, 0x80, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2,
+  0x98, 0x01, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x20,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x02, 0x47, 0x00, 0x4a,
+  0xa0, 0x10, 0x0a, 0xa4, 0x08, 0x0a, 0xa2, 0x80, 0x0a, 0x30, 0xa0, 0x0c,
+  0x0a, 0xa3, 0x50, 0x0a, 0xa6, 0x70, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c,
+  0x68, 0x2d, 0x9c, 0x11, 0x80, 0x42, 0x28, 0x88, 0xc2, 0x28, 0x90, 0x42,
+  0x29, 0x18, 0x42, 0xc7, 0x12, 0x24, 0x01, 0x00, 0x00, 0x79, 0x18, 0x00,
+  0x00, 0xd9, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c, 0x10, 0x97, 0x29, 0xa2,
+  0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0xb7, 0x21, 0x06, 0x18,
+  0x40, 0x67, 0x00, 0xa0, 0x41, 0x19, 0x50, 0xb9, 0x1b, 0x43, 0x0b, 0x93,
+  0xfb, 0x9a, 0x4b, 0xd3, 0x2b, 0x1b, 0x62, 0x80, 0x41, 0x73, 0x06, 0x02,
+  0x18, 0x38, 0x8c, 0x83, 0x20, 0x38, 0x38, 0xb6, 0x32, 0x90, 0xb6, 0x32,
+  0xba, 0x30, 0x36, 0x10, 0xbb, 0x32, 0xb9, 0xb9, 0xb4, 0x37, 0x37, 0x90,
+  0x19, 0x19, 0x18, 0x99, 0x19, 0x17, 0x1a, 0x18, 0x1a, 0x10, 0x94, 0xb6,
+  0x32, 0xba, 0x30, 0x36, 0xb3, 0xb2, 0x96, 0x19, 0x19, 0x18, 0x99, 0x19,
+  0x17, 0x1a, 0x18, 0x9a, 0x94, 0x21, 0xc2, 0x19, 0x10, 0x43, 0x0c, 0x30,
+  0x68, 0xc0, 0x20, 0x02, 0x03, 0x86, 0x45, 0x53, 0x19, 0x5d, 0x18, 0xdb,
+  0x10, 0xe4, 0x0c, 0x0e, 0x30, 0x68, 0xc0, 0xa0, 0x01, 0x03, 0x86, 0x5b,
+  0x58, 0x9a, 0x9c, 0xcb, 0xd8, 0x5b, 0x1b, 0x5c, 0x1a, 0x5b, 0x99, 0x0b,
+  0x59, 0x99, 0xdb, 0x9b, 0x5c, 0xdb, 0xdc, 0x17, 0x59, 0xda, 0x5c, 0x98,
+  0x18, 0x5b, 0xd9, 0x10, 0xe1, 0x0c, 0x12, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x33, 0x58, 0x48, 0x06, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62,
+  0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f,
+  0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x43, 0x84, 0x33, 0x68, 0x18, 0x85,
+  0xa5, 0xc9, 0xb9, 0xc8, 0x95, 0xb9, 0x91, 0x95, 0xc9, 0x7d, 0xd1, 0x85,
+  0xc9, 0x9d, 0x95, 0xd1, 0x31, 0x0a, 0x4b, 0x93, 0x73, 0x09, 0x93, 0x3b,
+  0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x72, 0x0b, 0x6b, 0x2b, 0xa3, 0x61,
+  0xc6, 0xf6, 0x16, 0x46, 0x47, 0x33, 0x04, 0x39, 0x83, 0x07, 0x0c, 0x98,
+  0x33, 0x80, 0xce, 0x20, 0x1a, 0x22, 0x9c, 0x81, 0x44, 0x26, 0x2c, 0x4d,
+  0xce, 0x05, 0xee, 0x6d, 0x2e, 0x8d, 0x2e, 0xed, 0xcd, 0x8d, 0x4a, 0x58,
+  0x9a, 0x9c, 0xcb, 0x58, 0x99, 0x1b, 0x5d, 0x99, 0x1c, 0xa5, 0xb0, 0x34,
+  0x39, 0x17, 0xb7, 0xb7, 0x2f, 0xb8, 0x32, 0xb9, 0x39, 0xb8, 0xb2, 0x31,
+  0xba, 0x34, 0xbb, 0x32, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x44, 0xe0, 0xde, 0xe6, 0xd2, 0xe8, 0xd2,
+  0xde, 0xdc, 0x86, 0x40, 0x60, 0xc0, 0x9c, 0x01, 0x75, 0x06, 0xd5, 0x19,
+  0x58, 0x67, 0x00, 0x9d, 0x41, 0x74, 0x06, 0xd7, 0x19, 0x60, 0x94, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xcc, 0xe4, 0xc2, 0xce, 0xda, 0xca, 0xdc, 0xe8, 0xbe,
+  0xd2, 0xdc, 0xe0, 0xea, 0xe8, 0x68, 0x9d, 0x95, 0xb9, 0x95, 0xc9, 0x85,
+  0xd1, 0x95, 0x91, 0xa1, 0xd4, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x11, 0xd9,
+  0xd1, 0x7c, 0x99, 0xa5, 0xf0, 0x09, 0x4b, 0x93, 0x73, 0x81, 0x2b, 0x93,
+  0x9b, 0x83, 0x2b, 0x1b, 0xa3, 0x4b, 0xb3, 0x2b, 0x63, 0x31, 0xf6, 0xc6,
+  0xf6, 0x26, 0x37, 0x44, 0x02, 0x83, 0xe6, 0x0c, 0xb4, 0x33, 0xd8, 0xce,
+  0xa0, 0x3a, 0x03, 0xee, 0x0c, 0xa0, 0x33, 0x88, 0xce, 0xe0, 0x3a, 0x83,
+  0x8e, 0xd9, 0x59, 0x99, 0x5b, 0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a,
+  0x0e, 0x5d, 0x19, 0xde, 0xd8, 0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc,
+  0x97, 0x59, 0x0a, 0x0d, 0x33, 0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74,
+  0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x43, 0x24, 0x30, 0x80, 0xce,
+  0x40, 0x3b, 0x83, 0xef, 0x0c, 0xaa, 0x33, 0xe0, 0xce, 0x00, 0x3a, 0x03,
+  0x30, 0x38, 0x83, 0xeb, 0x0c, 0xc2, 0x80, 0x4a, 0x58, 0x9a, 0x9c, 0x8b,
+  0x58, 0x9d, 0x99, 0x59, 0x99, 0x1c, 0x9f, 0xb0, 0x34, 0x39, 0x17, 0xb1,
+  0x3a, 0x33, 0xb3, 0x32, 0xb9, 0xaf, 0xb9, 0x34, 0xbd, 0x32, 0x4a, 0x61,
+  0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x44, 0xc2, 0xd2, 0xe4, 0x5c, 0xe4, 0xca,
+  0xc2, 0xc8, 0x48, 0x85, 0xa5, 0xc9, 0xb9, 0xcc, 0xd1, 0xc9, 0xd5, 0x8d,
+  0xd1, 0x7d, 0xd1, 0xe5, 0xc1, 0x95, 0x7d, 0xa5, 0xb9, 0x99, 0xbd, 0xb1,
+  0x30, 0x63, 0x7b, 0x0b, 0xa3, 0x23, 0x33, 0x37, 0x26, 0x75, 0x24, 0xf4,
+  0xf5, 0x56, 0x47, 0x07, 0x57, 0x47, 0x47, 0x86, 0xae, 0x0c, 0x8f, 0xae,
+  0x4e, 0xae, 0xec, 0x8b, 0x2e, 0x0f, 0xae, 0x8c, 0x4a, 0x9a, 0x1b, 0x5c,
+  0x1d, 0xdd, 0x17, 0x5d, 0x1e, 0x5c, 0x19, 0x97, 0xb1, 0x37, 0xb6, 0x37,
+  0xb9, 0xaf, 0xb9, 0xb1, 0x30, 0xb6, 0x32, 0x3a, 0x74, 0x6f, 0x6e, 0x65,
+  0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x7c, 0xe8,
+  0xde, 0xdc, 0xca, 0xda, 0xc2, 0xe0, 0xbe, 0xcc, 0xc2, 0xc6, 0xe8, 0xde,
+  0xe4, 0x62, 0xf8, 0xd0, 0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1, 0x7d, 0x99,
+  0x85, 0x8d, 0xd1, 0xbd, 0xc9, 0xc9, 0xf0, 0x99, 0x23, 0x93, 0xfb, 0xba,
+  0x43, 0x4b, 0xa3, 0x2b, 0xfb, 0x82, 0x7b, 0x4b, 0x73, 0xa3, 0x1b, 0x02,
+  0x0b, 0x60, 0xc0, 0x80, 0x81, 0x03, 0x06, 0xcc, 0x19, 0xa0, 0xc1, 0x19,
+  0xa4, 0x01, 0x18, 0x38, 0x60, 0xe0, 0x80, 0x01, 0x73, 0x06, 0x68, 0x70,
+  0x06, 0x6a, 0x00, 0x06, 0x11, 0x18, 0x38, 0x60, 0xc0, 0x9c, 0x01, 0x1a,
+  0x9c, 0xc1, 0x1a, 0x80, 0x41, 0x05, 0x06, 0x0e, 0x18, 0x30, 0x67, 0x80,
+  0x06, 0x67, 0xc0, 0x06, 0x60, 0xf0, 0x80, 0x81, 0x03, 0x06, 0xcc, 0x19,
+  0xa0, 0xc1, 0x19, 0xb4, 0x01, 0x18, 0x58, 0x60, 0xe0, 0x80, 0x01, 0x73,
+  0x06, 0x68, 0x70, 0x06, 0x6e, 0x00, 0x06, 0x17, 0x18, 0x38, 0x60, 0xc0,
+  0x9c, 0x01, 0x1a, 0x9c, 0xc1, 0x1b, 0x80, 0x01, 0x06, 0x06, 0x0e, 0x18,
+  0x30, 0x67, 0x80, 0x06, 0x67, 0x00, 0x07, 0x8c, 0xc2, 0xd2, 0xe4, 0x5c,
+  0xc2, 0xe4, 0xce, 0xbe, 0xe8, 0xf2, 0xe0, 0xca, 0xbe, 0xe6, 0xd2, 0xf4,
+  0xca, 0x78, 0x85, 0xa5, 0xc9, 0xb9, 0x84, 0xc9, 0x9d, 0x7d, 0xd1, 0xe5,
+  0xc1, 0x95, 0x7d, 0x85, 0xb1, 0xa5, 0x9d, 0xb9, 0x7d, 0xcd, 0xa5, 0xe9,
+  0x95, 0xf1, 0x99, 0x42, 0x0b, 0x23, 0x2b, 0x93, 0x1b, 0x7a, 0x73, 0x9b,
+  0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0x63, 0x30, 0x36, 0x84, 0x0c, 0xc0, 0x80,
+  0x3a, 0x83, 0x31, 0x38, 0x03, 0x32, 0x00, 0x03, 0xe9, 0x0c, 0xca, 0x00,
+  0x0c, 0x18, 0x30, 0x68, 0xce, 0xc0, 0x0c, 0xce, 0xe0, 0x0c, 0xce, 0x20,
+  0x0e, 0xce, 0x40, 0x0e, 0xc0, 0x40, 0x3a, 0x83, 0x39, 0x00, 0x03, 0xe7,
+  0x0c, 0xa0, 0x33, 0xa0, 0x83, 0x33, 0xb8, 0xce, 0xa0, 0x0e, 0x68, 0x98,
+  0xb1, 0xbd, 0x85, 0xd1, 0xcd, 0xd0, 0x78, 0x33, 0x33, 0x9b, 0x2b, 0xa3,
+  0x23, 0x62, 0xc6, 0xf6, 0x16, 0x46, 0x37, 0x83, 0x37, 0x43, 0xa3, 0x2d,
+  0x8c, 0x4e, 0x2e, 0x0d, 0x6f, 0x08, 0x05, 0x06, 0x0c, 0x18, 0x3c, 0x60,
+  0xc0, 0x9c, 0xc1, 0x1d, 0x9c, 0x01, 0x1e, 0x80, 0xc1, 0x03, 0x06, 0x19,
+  0x18, 0x30, 0x67, 0x90, 0x07, 0x67, 0xa0, 0x07, 0x4c, 0xb2, 0xaa, 0xac,
+  0x88, 0xca, 0xc6, 0xde, 0xc8, 0xca, 0x68, 0x90, 0x95, 0x8d, 0xbd, 0x91,
+  0x95, 0x0d, 0x21, 0x03, 0x30, 0x70, 0xce, 0x60, 0x0c, 0xce, 0x80, 0x0c,
+  0xc0, 0x60, 0x3a, 0x83, 0x32, 0x00, 0x83, 0x06, 0x0c, 0x9a, 0x33, 0x30,
+  0x83, 0x33, 0x38, 0x83, 0x33, 0xd8, 0x83, 0x33, 0x90, 0x03, 0x30, 0x98,
+  0xce, 0x60, 0x0e, 0xc0, 0xe0, 0x39, 0x03, 0xe8, 0x0c, 0xf8, 0xe0, 0x0c,
+  0xae, 0x33, 0xe8, 0x03, 0x2e, 0x61, 0x69, 0x72, 0x2e, 0x74, 0x65, 0x78,
+  0x74, 0x75, 0x72, 0x65, 0x54, 0xc2, 0xd2, 0xe4, 0x5c, 0xe6, 0xc2, 0xda,
+  0xe0, 0xd8, 0xca, 0x88, 0xd1, 0x95, 0xe1, 0xd1, 0xd5, 0xc9, 0x95, 0xc9,
+  0x90, 0xf1, 0x98, 0xb1, 0xbd, 0x85, 0xd1, 0xb1, 0x80, 0xcc, 0x85, 0xb5,
+  0xc1, 0xb1, 0x95, 0xf9, 0x90, 0xa0, 0x2b, 0xc3, 0xcb, 0x1a, 0x42, 0x81,
+  0x81, 0x76, 0x06, 0x7f, 0x70, 0x06, 0x65, 0x00, 0x06, 0x0c, 0x18, 0x34,
+  0x67, 0x00, 0x0a, 0x67, 0x00, 0x9d, 0x41, 0x28, 0x9c, 0xc1, 0x75, 0x06,
+  0xa2, 0x40, 0x8f, 0xae, 0x0c, 0x8f, 0xae, 0x4e, 0xae, 0x4c, 0x86, 0xec,
+  0x2b, 0x4c, 0x4e, 0x2e, 0x2c, 0x8f, 0xc7, 0x8c, 0xed, 0x2d, 0x8c, 0x8e,
+  0x05, 0x64, 0x2e, 0xac, 0x0d, 0x8e, 0xad, 0xcc, 0x87, 0x05, 0x5d, 0x19,
+  0x5e, 0x95, 0xd5, 0x10, 0x0a, 0x0c, 0xb6, 0x33, 0xf8, 0x83, 0x33, 0x28,
+  0x03, 0x30, 0x68, 0xc0, 0xa0, 0x39, 0x03, 0x50, 0x38, 0x03, 0xe8, 0x0c,
+  0x48, 0xe1, 0x0c, 0xae, 0x33, 0x28, 0x05, 0x2e, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x3c, 0xe6, 0xc2, 0xda, 0xe0,
+  0xd8, 0xca, 0xe4, 0x18, 0xcc, 0x0d, 0x91, 0xc0, 0x80, 0x3b, 0x83, 0x53,
+  0x38, 0x83, 0x32, 0x00, 0x03, 0x06, 0x0c, 0x9a, 0x33, 0x80, 0xce, 0x00,
+  0x15, 0xce, 0xe0, 0x3a, 0x83, 0x54, 0x18, 0x02, 0x9d, 0x41, 0x76, 0x06,
+  0xde, 0x19, 0x88, 0xc1, 0x19, 0xd8, 0xc1, 0x19, 0xf8, 0xc1, 0x19, 0x8c,
+  0xc2, 0x19, 0x98, 0xc2, 0x19, 0xa8, 0xc2, 0x10, 0x23, 0x02, 0xce, 0x60,
+  0x3a, 0x83, 0x55, 0xa0, 0x18, 0x84, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5,
+  0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xcd, 0xa1, 0x4c, 0x11,
+  0x31, 0x7d, 0x65, 0x55, 0x59, 0x7d, 0x99, 0xc9, 0x85, 0x9d, 0xb5, 0x95,
+  0xb9, 0xd1, 0xa5, 0x0c, 0x21, 0xce, 0xc0, 0x15, 0xce, 0xa0, 0x15, 0x88,
+  0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d,
+  0xbd, 0xc1, 0x95, 0xb5, 0xd0, 0x95, 0xe1, 0xd1, 0xd5, 0xc9, 0x95, 0xcd,
+  0x0d, 0x31, 0xce, 0x00, 0x16, 0xce, 0xc0, 0x15, 0xce, 0xe0, 0x15, 0x88,
+  0x85, 0xa5, 0xc9, 0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d,
+  0xbd, 0xc1, 0x95, 0xb5, 0xcc, 0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xcd,
+  0x0d, 0x31, 0xce, 0x40, 0x16, 0xce, 0xc0, 0x15, 0xce, 0x20, 0x16, 0x86,
+  0x10, 0x67, 0x00, 0x0b, 0x67, 0x20, 0x0b, 0xb4, 0xc2, 0xd2, 0xe4, 0x5a,
+  0xc2, 0xd8, 0xd2, 0xc2, 0xe6, 0x5a, 0xe6, 0xc6, 0xde, 0xe0, 0xca, 0x5a,
+  0xc2, 0xe4, 0xce, 0x50, 0x66, 0x52, 0x86, 0x18, 0x67, 0x50, 0x0b, 0x67,
+  0xe0, 0x0a, 0x67, 0x40, 0x0b, 0xb4, 0xc2, 0xd2, 0xe4, 0x5a, 0xc2, 0xd8,
+  0xd2, 0xc2, 0xe6, 0x5a, 0xe6, 0xc6, 0xde, 0xe0, 0xca, 0x5a, 0xc2, 0xe4,
+  0xce, 0x50, 0x68, 0x52, 0x86, 0x18, 0x67, 0x70, 0x0b, 0x67, 0xe0, 0x0a,
+  0x67, 0x60, 0x0b, 0x43, 0x88, 0x33, 0xa8, 0x85, 0x33, 0xb8, 0x85, 0x21,
+  0xc2, 0x19, 0xdc, 0xc2, 0x10, 0xe3, 0x0c, 0x6a, 0xe1, 0x0c, 0x60, 0xe1,
+  0x0c, 0x64, 0x81, 0xd5, 0x97, 0x16, 0xd5, 0x54, 0x4c, 0xcd, 0x14, 0x5a,
+  0x18, 0x59, 0x99, 0xdc, 0xd0, 0x9b, 0xdb, 0x1c, 0x5d, 0x98, 0x1b, 0xdd,
+  0x1c, 0x9f, 0xb7, 0x36, 0xb7, 0x34, 0xb8, 0x37, 0xba, 0x32, 0x37, 0x3a,
+  0x90, 0x31, 0xb4, 0x30, 0x39, 0x3e, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65,
+  0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x43, 0x84, 0x33,
+  0xe8, 0x85, 0x21, 0xc6, 0x19, 0xf0, 0xc2, 0x19, 0xf8, 0xc2, 0x1a, 0x78,
+  0x43, 0x8c, 0x33, 0x40, 0x83, 0x33, 0xf8, 0x85, 0x35, 0xf0, 0x86, 0x88,
+  0xc1, 0x19, 0xec, 0xc2, 0x19, 0x80, 0xc3, 0x1a, 0x78, 0x67, 0x00, 0x0e,
+  0x6b, 0xf0, 0x9d, 0x01, 0x38, 0xac, 0x01, 0x18, 0x9c, 0x01, 0x38, 0xac,
+  0x41, 0x18, 0x9c, 0x01, 0x38, 0xac, 0x81, 0x18, 0x9c, 0x01, 0x38, 0xac,
+  0xc1, 0x18, 0x9c, 0x01, 0x38, 0xac, 0x01, 0x19, 0x9c, 0x01, 0x38, 0xac,
+  0x41, 0x37, 0xc4, 0x38, 0x83, 0x70, 0x38, 0x03, 0x70, 0x58, 0x03, 0x30,
+  0x18, 0x62, 0x9c, 0x41, 0x38, 0x9c, 0x01, 0x38, 0xac, 0x41, 0x37, 0xc4,
+  0x38, 0x83, 0x70, 0x38, 0x03, 0x70, 0x58, 0x03, 0x31, 0x18, 0x62, 0x9c,
+  0x41, 0x38, 0x9c, 0x01, 0x38, 0xac, 0xc1, 0x18, 0x0c, 0x31, 0xce, 0x20,
+  0x1c, 0xce, 0x00, 0x1c, 0xd6, 0x80, 0x0c, 0x86, 0x18, 0x67, 0x10, 0x0e,
+  0x67, 0x00, 0x0e, 0x6b, 0xf0, 0x0d, 0x31, 0xce, 0x20, 0x1c, 0xce, 0x00,
+  0x1c, 0xd6, 0x20, 0x0c, 0x86, 0x18, 0x67, 0x10, 0x0e, 0x67, 0x00, 0x0e,
+  0x6b, 0xe0, 0x8d, 0x88, 0xd8, 0x81, 0x1d, 0xec, 0xa1, 0x1d, 0xdc, 0xa0,
+  0x1d, 0xde, 0x81, 0x1c, 0xea, 0x81, 0x1d, 0xca, 0xc1, 0x0d, 0xcc, 0x81,
+  0x1d, 0xc2, 0xe1, 0x1c, 0xe6, 0x61, 0x8a, 0x10, 0x0c, 0x23, 0x14, 0x76,
+  0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x48, 0x07, 0x72, 0x28, 0x07, 0x77,
+  0xa0, 0x87, 0x29, 0x41, 0x31, 0x62, 0x09, 0x87, 0x74, 0x90, 0x07, 0x37,
+  0xb0, 0x87, 0x72, 0x90, 0x87, 0x79, 0x48, 0x87, 0x77, 0x70, 0x87, 0x29,
+  0x81, 0x31, 0x82, 0x0a, 0x87, 0x74, 0x90, 0x07, 0x37, 0x60, 0x87, 0x70,
+  0x70, 0x87, 0x73, 0xa8, 0x87, 0x70, 0x38, 0x87, 0x72, 0xf8, 0x05, 0x7b,
+  0x28, 0x07, 0x79, 0x98, 0x87, 0x74, 0x78, 0x07, 0x77, 0x98, 0x12, 0x20,
+  0x23, 0xa6, 0x70, 0x48, 0x07, 0x79, 0x70, 0x83, 0x71, 0x78, 0x87, 0x76,
+  0x80, 0x87, 0x74, 0x60, 0x87, 0x72, 0xf8, 0x85, 0x77, 0x80, 0x07, 0x7a,
+  0x48, 0x87, 0x77, 0x70, 0x87, 0x79, 0x98, 0x32, 0x28, 0x8c, 0x33, 0x82,
+  0x09, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x07, 0x79, 0x08, 0x87, 0x73,
+  0x68, 0x87, 0x72, 0x70, 0x07, 0x7a, 0x98, 0x12, 0xb0, 0x02, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x35, 0x00, 0x00, 0x00, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf,
+  0xb3, 0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45,
+  0x51, 0x14, 0x96, 0x30, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05,
+  0x03, 0x5c, 0x7e, 0x75, 0x17, 0xb7, 0x6d, 0x01, 0x14, 0x80, 0x44, 0x7e,
+  0x01, 0x48, 0xd3, 0x2f, 0x2c, 0x00, 0xf3, 0xf8, 0xd5, 0x5d, 0xdc, 0xb6,
+  0x09, 0x40, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0xff, 0xe3, 0x58, 0x7e,
+  0x71, 0xdb, 0x36, 0x10, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05,
+  0x10, 0x48, 0x7e, 0x71, 0xdb, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17, 0x80,
+  0x34, 0xfd, 0x8f, 0x63, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x29, 0x84, 0x01,
+  0x80, 0x44, 0xbe, 0x04, 0x30, 0xcf, 0x42, 0xfc, 0x13, 0x71, 0x4d, 0x54,
+  0x44, 0xfc, 0xf6, 0xf0, 0x03, 0x51, 0x04, 0x60, 0x7e, 0x85, 0x17, 0xb7,
+  0x6d, 0x04, 0x0d, 0x80, 0x44, 0xfe, 0xe0, 0x4c, 0x7e, 0x75, 0x17, 0xb7,
+  0x6d, 0x0b, 0x1b, 0x80, 0x44, 0xbe, 0x04, 0x30, 0xcf, 0x42, 0xfc, 0x13,
+  0x71, 0x4d, 0x54, 0x44, 0xfc, 0xf6, 0xe0, 0x57, 0x78, 0x71, 0xdb, 0x86,
+  0x30, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05, 0x10, 0x48, 0x7e,
+  0x75, 0x17, 0xb7, 0x6d, 0x00, 0x10, 0xdb, 0x95, 0xbf, 0xec, 0xbe, 0x7f,
+  0x11, 0x01, 0x06, 0x43, 0x34, 0x93, 0x19, 0x44, 0x00, 0x12, 0xf9, 0x05,
+  0x20, 0x4d, 0x7f, 0xc1, 0x00, 0x97, 0x5f, 0xdc, 0x36, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0xd4, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e,
+  0x10, 0x0b, 0x04, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x14, 0x8f, 0x45,
+  0x00, 0x81, 0x70, 0xcc, 0x41, 0x30, 0x0d, 0x84, 0x07, 0xb4, 0x16, 0x41,
+  0x09, 0x50, 0x3a, 0xc7, 0xc0, 0xe0, 0x01, 0x1e, 0x8c, 0x00, 0x8c, 0x35,
+  0x00, 0x81, 0x40, 0xe2, 0x08, 0x00, 0x85, 0x23, 0x00, 0x35, 0x40, 0xe0,
+  0x0c, 0x00, 0x01, 0x63, 0x04, 0xef, 0x9e, 0x96, 0xf7, 0x37, 0x46, 0xa0,
+  0xb3, 0xe6, 0x1c, 0x82, 0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x09, 0x06,
+  0x63, 0x04, 0x20, 0x08, 0x82, 0x20, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03,
+  0x30, 0x03, 0x30, 0x07, 0x21, 0x0b, 0xb2, 0x20, 0x0b, 0xb3, 0x30, 0x07,
+  0x31, 0x0b, 0xb9, 0x30, 0x0b, 0x7d, 0x40, 0xc5, 0x0c, 0xc0, 0x08, 0xc0,
+  0x0c, 0xc0, 0x58, 0x03, 0x08, 0x82, 0x20, 0xfe, 0x81, 0x20, 0x08, 0xe2,
+  0x1f, 0x08, 0x82, 0x20, 0xfe, 0x8d, 0x35, 0xb0, 0xed, 0xfc, 0x93, 0x1e,
+  0xdb, 0xce, 0x3f, 0xe9, 0xb1, 0xed, 0xfc, 0x93, 0xde, 0x58, 0x03, 0x08,
+  0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8,
+  0xd6, 0xbf, 0x30, 0xd6, 0x00, 0x82, 0xe0, 0x9a, 0x83, 0x01, 0x08, 0x82,
+  0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x8c, 0x35, 0x80, 0x20,
+  0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d,
+  0x0e, 0x06, 0x63, 0x0d, 0xeb, 0x88, 0xc7, 0x2c, 0x18, 0xac, 0x23, 0x1e,
+  0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x58, 0x03, 0x08, 0xc2,
+  0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87,
+  0x63, 0x30, 0xd6, 0x20, 0xe6, 0x62, 0xda, 0x7f, 0x60, 0xc9, 0xb3, 0xf1,
+  0x2f, 0x8c, 0xe9, 0xaa, 0xe6, 0xbe, 0x30, 0xd6, 0xf0, 0xcf, 0xa4, 0xff,
+  0xfb, 0x02, 0x5d, 0x83, 0x62, 0xfe, 0xb5, 0x70, 0x1c, 0x83, 0xbe, 0x30,
+  0xd6, 0x30, 0xf7, 0x6d, 0x9a, 0xfa, 0x42, 0xeb, 0x86, 0x3c, 0xef, 0x0b,
+  0x7c, 0xce, 0xfa, 0xf8, 0x47, 0xc0, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed,
+  0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0x79, 0xaf, 0xab,
+  0xec, 0xcd, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81,
+  0xdb, 0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba, 0xf8, 0x37,
+  0x46, 0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8, 0xf6, 0x34,
+  0x18, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00, 0x00, 0x00,
+  0x00, 0x23, 0x06, 0x4a, 0x11, 0xbc, 0xc2, 0x1b, 0xb4, 0x81, 0x1c, 0x8c,
+  0x41, 0x19, 0x90, 0x41, 0x30, 0x62, 0xb0, 0x14, 0x41, 0x2c, 0xbc, 0x81,
+  0x1b, 0xcc, 0xc1, 0x2b, 0x90, 0x81, 0x19, 0x94, 0x81, 0x30, 0x86, 0x10,
+  0xc0, 0xc2, 0x20, 0xc3, 0xe0, 0xad, 0xc1, 0x1c, 0x43, 0x20, 0xc4, 0xc2,
+  0x88, 0xc1, 0x52, 0x04, 0xb5, 0x30, 0x07, 0x72, 0x70, 0x07, 0xb2, 0x80,
+  0x06, 0x6a, 0x90, 0x06, 0xc6, 0x18, 0x42, 0x40, 0x0b, 0x73, 0x0c, 0x43,
+  0x10, 0x0b, 0x87, 0x07, 0xea, 0x52, 0x50, 0x06, 0x19, 0x02, 0x33, 0x80,
+  0x03, 0x23, 0x02, 0xf8, 0x8c, 0x37, 0xf0, 0x01, 0x2a, 0xe4, 0xc2, 0x05,
+  0xea, 0x52, 0x50, 0x06, 0x19, 0x82, 0x35, 0xa8, 0x83, 0x11, 0x83, 0xc2,
+  0x08, 0xcc, 0xa1, 0x08, 0xc6, 0x2b, 0x42, 0xa1, 0x15, 0x7c, 0xe1, 0x17,
+  0xf4, 0xe0, 0x02, 0x75, 0x29, 0x28, 0x83, 0x0c, 0x01, 0x1c, 0xe8, 0xc1,
+  0x88, 0x41, 0x61, 0x04, 0xeb, 0xa0, 0x04, 0xe3, 0x15, 0xa6, 0x20, 0x0b,
+  0xe3, 0x40, 0x0e, 0xa0, 0x70, 0x81, 0xba, 0x14, 0x94, 0x41, 0x86, 0xa0,
+  0x0e, 0xfe, 0x60, 0xc4, 0xa0, 0x30, 0x02, 0x78, 0x78, 0x82, 0x39, 0x86,
+  0x3a, 0x58, 0xd2, 0x61, 0x8e, 0x21, 0x38, 0xd2, 0x61, 0x8e, 0x21, 0x18,
+  0xce, 0x61, 0xbc, 0xe1, 0x15, 0x74, 0x01, 0x1d, 0x28, 0x18, 0xc3, 0x0d,
+  0xc1, 0x1f, 0x04, 0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0x10, 0x7d, 0x70,
+  0x0a, 0xe3, 0x0d, 0xb3, 0xe0, 0x0b, 0xe0, 0x40, 0xc1, 0x18, 0x31, 0x20,
+  0x8c, 0xc0, 0x1e, 0x86, 0x11, 0x83, 0xc2, 0x08, 0xf0, 0x21, 0xc8, 0x03,
+  0x0b, 0xf2, 0x00, 0x3e, 0x23, 0x06, 0x85, 0x11, 0xe0, 0x43, 0xe0, 0x07,
+  0x36, 0xe8, 0x81, 0x7c, 0x4c, 0x0f, 0x82, 0xf8, 0xd8, 0x10, 0xd0, 0x67,
+  0xc4, 0x80, 0x30, 0x82, 0x7e, 0x08, 0x46, 0x0c, 0x0a, 0x23, 0xf8, 0x87,
+  0x80, 0x0f, 0x2c, 0xe0, 0x03, 0xf9, 0xcc, 0x31, 0x98, 0xc2, 0xc2, 0x0f,
+  0x83, 0x0c, 0xc1, 0x29, 0xd8, 0x82, 0x0d, 0x01, 0x7d, 0x06, 0x19, 0x82,
+  0x54, 0xe0, 0x85, 0x41, 0x86, 0xa0, 0xf2, 0x85, 0x59, 0x02, 0x61, 0xa0,
+  0x22, 0x10, 0x02, 0x36, 0x00, 0xc6, 0x1b, 0xca, 0x01, 0x1e, 0x40, 0x82,
+  0x82, 0x31, 0xdc, 0x10, 0xdc, 0x81, 0x33, 0xcb, 0x30, 0x10, 0xc1, 0x20,
+  0x03, 0x31, 0x0b, 0xbd, 0x30, 0xde, 0x90, 0x0e, 0xf4, 0x80, 0x0f, 0x14,
+  0x8c, 0xf1, 0x86, 0x75, 0xb0, 0x87, 0x7c, 0xa0, 0x60, 0x8c, 0x18, 0x20,
+  0x47, 0x14, 0x13, 0x45, 0x77, 0x0c, 0xc1, 0x20, 0x43, 0x50, 0x0b, 0xe8,
+  0x30, 0xc8, 0x10, 0x2c, 0xea, 0x30, 0x4b, 0x40, 0x0c, 0x54, 0x04, 0xc2,
+  0x80, 0x09, 0xc3, 0x0d, 0x61, 0x70, 0x0a, 0xc1, 0x2c, 0x43, 0x31, 0x05,
+  0xe3, 0x0d, 0xf2, 0xd0, 0x0f, 0x2e, 0x41, 0xc1, 0x18, 0x6e, 0x08, 0x54,
+  0x21, 0x98, 0x65, 0x30, 0x8e, 0x60, 0x90, 0xa1, 0x00, 0x07, 0x75, 0x18,
+  0x6f, 0xb0, 0x87, 0x90, 0x58, 0x09, 0x0a, 0xc6, 0x1c, 0xc3, 0x2f, 0x04,
+  0x35, 0x31, 0xc8, 0x10, 0x80, 0xc3, 0x3b, 0x58, 0x50, 0xc8, 0x67, 0x90,
+  0x21, 0x10, 0x87, 0x7a, 0x98, 0x25, 0x68, 0x83, 0xf1, 0x06, 0x7e, 0x38,
+  0x89, 0x9c, 0xa0, 0x60, 0x8c, 0x37, 0xf8, 0x43, 0x4a, 0xcc, 0x04, 0x05,
+  0x63, 0x90, 0x01, 0x5a, 0x07, 0x7d, 0x18, 0x6e, 0x20, 0x62, 0xc1, 0x99,
+  0x65, 0x40, 0xa4, 0x60, 0x0c, 0x41, 0xfa, 0x89, 0xe1, 0x86, 0x60, 0x17,
+  0x94, 0x59, 0x06, 0x25, 0x09, 0x4c, 0xe8, 0x05, 0xf9, 0xcc, 0x12, 0x2c,
+  0x36, 0xfc, 0x02, 0x7c, 0x46, 0x0c, 0x08, 0x23, 0x60, 0x8b, 0xc0, 0x82,
+  0x7b, 0x90, 0xcf, 0x88, 0x41, 0x61, 0x04, 0x6f, 0x11, 0xdc, 0xc3, 0x2c,
+  0xc1, 0x32, 0x50, 0x01, 0x28, 0x89, 0xa0, 0xcc, 0x31, 0xd0, 0x43, 0x70,
+  0x16, 0x63, 0x08, 0xdb, 0x59, 0x0c, 0x37, 0x04, 0xe4, 0xa0, 0xcc, 0x32,
+  0x34, 0x4c, 0x60, 0x82, 0x39, 0xc8, 0x67, 0x96, 0xc0, 0xb1, 0x01, 0x1d,
+  0xe0, 0x33, 0x62, 0x40, 0x18, 0x41, 0x5d, 0x04, 0x16, 0x80, 0x84, 0x7c,
+  0x46, 0x0c, 0x0a, 0x23, 0xc0, 0x8b, 0x00, 0x24, 0x66, 0x09, 0x9c, 0x81,
+  0x0a, 0x40, 0x61, 0x84, 0x66, 0x8e, 0x21, 0x09, 0xde, 0x62, 0x0c, 0x81,
+  0x0c, 0xda, 0x62, 0xb8, 0x21, 0x68, 0x07, 0x65, 0x96, 0x01, 0x7a, 0x02,
+  0x13, 0xde, 0x41, 0x3e, 0xb3, 0x04, 0x91, 0x0d, 0xf1, 0x00, 0x9f, 0x11,
+  0x03, 0xc2, 0x08, 0xfc, 0x22, 0xb0, 0x20, 0x25, 0xe4, 0x33, 0x62, 0x50,
+  0x18, 0x41, 0x68, 0x04, 0x29, 0x31, 0x4b, 0x10, 0x0d, 0x54, 0x00, 0xca,
+  0x23, 0x40, 0x73, 0x0c, 0x49, 0x50, 0x17, 0xb3, 0x04, 0xd2, 0x40, 0x45,
+  0x20, 0x44, 0x7a, 0x70, 0x0c, 0x32, 0x04, 0x29, 0x31, 0x13, 0x73, 0x0c,
+  0x26, 0x01, 0x06, 0x7c, 0x31, 0xc8, 0x10, 0x9c, 0x84, 0x4d, 0xd8, 0x10,
+  0xc8, 0x67, 0x90, 0x21, 0x48, 0x09, 0x9e, 0x98, 0x25, 0x68, 0x83, 0xe1,
+  0x86, 0x59, 0x80, 0x89, 0x60, 0x96, 0x81, 0x02, 0x83, 0x60, 0x90, 0x81,
+  0x0e, 0x5e, 0x22, 0x27, 0xc6, 0x1b, 0xca, 0x02, 0x2e, 0x44, 0x83, 0x82,
+  0x31, 0xde, 0x70, 0x16, 0x72, 0xc1, 0x17, 0x14, 0x8c, 0x39, 0x06, 0x98,
+  0x08, 0x4c, 0x63, 0x90, 0x21, 0x88, 0x09, 0xb0, 0xb0, 0xe0, 0x90, 0xcf,
+  0x20, 0x43, 0x30, 0x13, 0x66, 0x31, 0xdc, 0x70, 0xf4, 0x83, 0x33, 0xcb,
+  0xf0, 0x55, 0xc1, 0x18, 0xc2, 0xb0, 0x1a, 0xc3, 0x0d, 0x01, 0x48, 0x28,
+  0xb3, 0x0c, 0x97, 0x15, 0x98, 0x20, 0x12, 0xf2, 0x99, 0x25, 0xc0, 0x46,
+  0x0c, 0x08, 0x23, 0xb8, 0x8d, 0x61, 0xc4, 0xa0, 0x30, 0x82, 0xdc, 0x08,
+  0x4a, 0xc2, 0x82, 0x93, 0x90, 0x8f, 0x05, 0x29, 0x01, 0x9f, 0x59, 0x02,
+  0x6c, 0xa0, 0x02, 0x50, 0x2c, 0xe1, 0x9a, 0x63, 0xd8, 0x89, 0x60, 0x36,
+  0xc6, 0x10, 0x98, 0xd9, 0x18, 0x6e, 0x08, 0x52, 0x42, 0x99, 0x65, 0xd0,
+  0xb2, 0xc0, 0x84, 0x95, 0x90, 0xcf, 0x2c, 0xc1, 0x36, 0x62, 0x40, 0x18,
+  0x01, 0x78, 0x0c, 0x23, 0x06, 0x85, 0x11, 0x88, 0x47, 0xe0, 0x12, 0x16,
+  0xc0, 0x84, 0x7c, 0x2c, 0x90, 0x09, 0xf8, 0xcc, 0x12, 0x6c, 0x03, 0x15,
+  0x80, 0x92, 0x09, 0xda, 0x1c, 0x43, 0x12, 0xec, 0xc6, 0x18, 0x42, 0x95,
+  0x1b, 0xc3, 0x0d, 0x81, 0x4c, 0x28, 0xb3, 0x0c, 0x1d, 0x17, 0x98, 0x40,
+  0x13, 0xf2, 0x99, 0x25, 0xf0, 0x46, 0x0c, 0x08, 0x23, 0x48, 0x8f, 0x61,
+  0xc4, 0xa0, 0x30, 0x82, 0xf5, 0x08, 0x6e, 0xc2, 0x82, 0x9c, 0x90, 0x8f,
+  0x05, 0x3b, 0x01, 0x9f, 0x59, 0x02, 0x6f, 0xa0, 0x02, 0x50, 0x38, 0xa1,
+  0x9b, 0x63, 0x48, 0x82, 0xf0, 0x18, 0x31, 0x30, 0x8c, 0x20, 0x3e, 0x82,
+  0xb7, 0x68, 0x8b, 0x41, 0x86, 0x20, 0x2e, 0x48, 0x63, 0x96, 0xe0, 0x1b,
+  0xa8, 0x08, 0xfc, 0x80, 0x12, 0xbc, 0x41, 0x86, 0xe0, 0x2e, 0x4c, 0x63,
+  0x96, 0xa0, 0x0d, 0x66, 0x19, 0xc2, 0xa0, 0x0d, 0xf8, 0x61, 0x90, 0xa1,
+  0x17, 0xf0, 0x42, 0x34, 0x46, 0x0c, 0x0a, 0x23, 0x98, 0x8f, 0x60, 0x2d,
+  0xe6, 0x18, 0xe8, 0x22, 0x60, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0xea, 0x63,
+  0x60, 0x8b, 0x39, 0x06, 0x21, 0x68, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0xee,
+  0xa3, 0x68, 0x8b, 0x39, 0x06, 0x21, 0x60, 0x8f, 0x41, 0x86, 0x60, 0x2f,
+  0x5c, 0x63, 0x90, 0x21, 0x28, 0x07, 0xd8, 0x18, 0x6f, 0xb0, 0x8d, 0xf0,
+  0x98, 0x0f, 0x0a, 0xc6, 0x78, 0x03, 0x6e, 0x8c, 0x47, 0x7b, 0x50, 0x30,
+  0xe6, 0x18, 0x42, 0x23, 0xb8, 0x8f, 0x41, 0x86, 0x40, 0x34, 0x62, 0xc3,
+  0x82, 0x44, 0x3e, 0x83, 0x0c, 0x01, 0x69, 0xdc, 0xc6, 0x70, 0xc3, 0xe1,
+  0x16, 0xce, 0x2c, 0x03, 0x1b, 0x88, 0x41, 0x30, 0x86, 0x30, 0xf0, 0xc7,
+  0x70, 0x43, 0x10, 0x17, 0xca, 0x2c, 0x03, 0x19, 0x8c, 0x41, 0x60, 0xc2,
+  0x5c, 0xc8, 0x67, 0x96, 0xa0, 0x0c, 0x46, 0x0c, 0x08, 0x23, 0x40, 0x91,
+  0x61, 0xc4, 0xa0, 0x30, 0x02, 0x15, 0x09, 0xec, 0xc2, 0x02, 0xbc, 0x90,
+  0x8f, 0x05, 0x7a, 0x01, 0x9f, 0x59, 0x82, 0x32, 0x18, 0xa8, 0x00, 0x94,
+  0x31, 0x10, 0xc8, 0x60, 0x8e, 0x81, 0x35, 0x02, 0x12, 0x19, 0x43, 0x60,
+  0x48, 0x64, 0xb8, 0x21, 0xd0, 0x0b, 0x65, 0x96, 0xe1, 0x0c, 0xcc, 0x20,
+  0x30, 0x81, 0x2f, 0xe4, 0x33, 0x4b, 0x80, 0x06, 0x23, 0x06, 0x84, 0x11,
+  0xc4, 0xc8, 0x30, 0x62, 0x50, 0x18, 0xc1, 0x8c, 0x04, 0x7f, 0x61, 0x41,
+  0x68, 0xc8, 0xc7, 0x82, 0xd1, 0x80, 0xcf, 0x2c, 0x01, 0x1a, 0x0c, 0x54,
+  0x00, 0x8a, 0x19, 0x08, 0x67, 0x30, 0xc7, 0x90, 0x04, 0x2c, 0x32, 0x86,
+  0x50, 0xa9, 0xc8, 0x70, 0x43, 0x30, 0x1a, 0xca, 0x2c, 0x83, 0x1a, 0xa4,
+  0x41, 0x60, 0x42, 0x69, 0xc8, 0x67, 0x96, 0x60, 0x0d, 0x46, 0x0c, 0x08,
+  0x23, 0xd0, 0x91, 0x61, 0xc4, 0xa0, 0x30, 0x02, 0x1e, 0x09, 0x50, 0xc3,
+  0x02, 0xd5, 0x90, 0x8f, 0x05, 0xac, 0x01, 0x9f, 0x59, 0x82, 0x35, 0x18,
+  0xa8, 0x00, 0x94, 0x34, 0x10, 0xd4, 0x60, 0x8e, 0x21, 0x09, 0x64, 0x64,
+  0xc4, 0xc0, 0x30, 0x02, 0x31, 0x09, 0xc0, 0xc3, 0x37, 0x06, 0x19, 0x02,
+  0xf1, 0xa8, 0x8f, 0x59, 0x02, 0x36, 0x18, 0xa8, 0x08, 0xfc, 0x20, 0x0c,
+  0x84, 0x35, 0x18, 0x64, 0x08, 0xd0, 0xe3, 0x3e, 0x66, 0x09, 0xda, 0x60,
+  0xa0, 0x25, 0xe0, 0x11, 0x83, 0x47, 0x24, 0x1e, 0xf9, 0x64, 0x81, 0x0d,
+  0x78, 0x04, 0x0c, 0x06, 0x5a, 0x02, 0x14, 0x31, 0xf4, 0x42, 0x32, 0x87,
+  0x8f, 0x60, 0x03, 0xd7, 0x01, 0x83, 0x41, 0x86, 0x40, 0xd8, 0x0f, 0x0b,
+  0x46, 0x44, 0x3e, 0x19, 0x84, 0x03, 0x01, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0xd7, 0xd2, 0x07, 0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4,
+  0x50, 0x13, 0xe7, 0x2c, 0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d,
+  0x9b, 0x6d, 0x29, 0x38, 0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b,
+  0x00, 0x03, 0x11, 0x71, 0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71,
+  0x21, 0x13, 0x00, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x5b, 0x0a, 0xe0, 0x98, 0x05, 0x04, 0x17, 0xb6, 0x14, 0xc1, 0x31,
+  0x0b, 0x08, 0x2e, 0x6c, 0x29, 0x8a, 0x63, 0x16, 0x10, 0x5c, 0xd8, 0x52,
+  0x24, 0x47, 0x2e, 0x20, 0xba, 0xb0, 0xa5, 0x70, 0x8e, 0x5c, 0x40, 0x74,
+  0x61, 0x4b, 0x31, 0x1d, 0xb9, 0x80, 0xe8, 0xc2, 0x96, 0x02, 0x3b, 0x72,
+  0x01, 0xd1, 0x85, 0x2d, 0xc3, 0x17, 0x88, 0xc3, 0x96, 0x81, 0x0c, 0x82,
+  0x71, 0xd8, 0x32, 0xdc, 0x41, 0x40, 0x0e, 0x5b, 0x06, 0x3e, 0x08, 0xca,
+  0x61, 0xcb, 0xe0, 0x07, 0x81, 0x39, 0x6c, 0x19, 0x4e, 0x21, 0x38, 0x87,
+  0x2d, 0x03, 0x2b, 0x04, 0xe8, 0xb0, 0x65, 0x98, 0x85, 0x20, 0x1d, 0xb6,
+  0x0c, 0xb5, 0x10, 0xa0, 0xc3, 0x96, 0x21, 0x25, 0x82, 0x74, 0xd8, 0x32,
+  0xac, 0x44, 0x80, 0x0e, 0x5b, 0x86, 0xd3, 0x08, 0xd2, 0x61, 0xcb, 0x90,
+  0x1a, 0x01, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x24, 0x00, 0x00, 0x00, 0x14, 0xcf, 0x41, 0x30, 0x0d, 0xe4, 0x06,
+  0x94, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40, 0xe0, 0x0c, 0x00, 0x05,
+  0x33, 0x00, 0x54, 0xcc, 0x00, 0x8c, 0x35, 0xb0, 0xec, 0x19, 0xca, 0x1f,
+  0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce, 0xde, 0x58, 0x83, 0x5e,
+  0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf, 0xdb, 0xa7, 0xf4, 0xe8,
+  0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a, 0xc2, 0xe8, 0xee, 0xdd,
+  0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81, 0x25,
+  0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f,
+  0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c,
+  0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2,
+  0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05, 0x33, 0x00, 0x04, 0x8c,
+  0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x46, 0x00, 0x82,
+  0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5, 0x02, 0x0d, 0x37, 0x50,
+  0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43, 0x43, 0xc5, 0xc1, 0x20,
+  0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64, 0x08, 0xa0, 0x6a, 0x96,
+  0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61, 0x48, 0x82, 0xe1, 0x86,
+  0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31, 0x28, 0x8c, 0xe0, 0x0f,
+  0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xf0, 0x60, 0xc4, 0xa0, 0x30, 0x82, 0x50,
+  0xf8, 0xa6, 0x39, 0x06, 0x21, 0xc8, 0x83, 0x11, 0x83, 0xc2, 0x08, 0x46,
+  0x21, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xc0, 0x83, 0x59, 0x82, 0x62, 0xa0,
+  0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xfc, 0x60, 0x0c, 0x41, 0xf0,
+  0x83, 0x31, 0x84, 0x81, 0x0f, 0x46, 0x0c, 0x0a, 0x23, 0x38, 0x05, 0x21,
+  0x18, 0x31, 0x28, 0x8c, 0x00, 0x15, 0x88, 0x60, 0xb8, 0x21, 0xb8, 0x84,
+  0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c, 0x0c, 0x6c, 0x40, 0x03,
+  0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90, 0x8f, 0x05, 0x1a, 0x7c,
+  0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81, 0x2a, 0x0c, 0x32, 0x04,
+  0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64, 0x08, 0xd2, 0xc0, 0x0d,
+  0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4, 0xa0, 0x98, 0x65, 0x40,
+  0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18, 0x31, 0x28, 0x8c, 0x00,
+  0x17, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0x20, 0x16, 0x46, 0x0c, 0x0a,
+  0x23, 0xd0, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84, 0x40, 0x16, 0x46, 0x0c,
+  0x0a, 0x23, 0xe0, 0x85, 0x42, 0x0d, 0xe6, 0x18, 0x84, 0x20, 0x16, 0x66,
+  0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57, 0x10, 0x04, 0x04, 0x3a,
+  0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x1c, 0x1c, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0,
+  0xde, 0x21, 0x0c, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, 0x0b, 0x82, 0x20,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x49, 0x0a, 0x32, 0x44, 0x24, 0x48, 0x0a, 0x90, 0x21, 0x23, 0xc4, 0x52,
+  0x80, 0x0c, 0x19, 0x21, 0x72, 0x24, 0x07, 0xc8, 0x88, 0x11, 0x62, 0xa8,
+  0xa0, 0xa8, 0x40, 0xc6, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x51, 0x18, 0x00,
+  0x00, 0xf7, 0x00, 0x00, 0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff,
+  0xff, 0x01, 0x60, 0x00, 0x09, 0xa8, 0x88, 0x70, 0x80, 0x07, 0x78, 0x90,
+  0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0x68,
+  0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00,
+  0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xa2, 0x1d, 0xd2, 0xc1, 0x1d,
+  0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2, 0x81, 0x1d, 0xda, 0xc0, 0x1e,
+  0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0xa1, 0x0d, 0xee, 0x21, 0x1d,
+  0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03, 0x39, 0xc0, 0x03, 0x60, 0x70,
+  0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87, 0x74, 0x60, 0x07, 0x7a, 0x48,
+  0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x73, 0x90,
+  0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03, 0x78, 0x78, 0x87, 0x74, 0x70,
+  0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83, 0x72, 0x60, 0x87, 0x74, 0x68,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e,
+  0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c,
+  0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc, 0xe1, 0x1d, 0xdc, 0xa1, 0x0d,
+  0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28,
+  0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x74, 0x70, 0x07, 0x73, 0x98,
+  0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40,
+  0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d,
+  0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e,
+  0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8,
+  0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x98, 0x87, 0x74, 0x38,
+  0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03, 0x7d, 0x28, 0x07, 0x79, 0x78,
+  0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0,
+  0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d,
+  0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0x01, 0x1e, 0xe0, 0x21, 0x1d,
+  0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0,
+  0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88, 0x79, 0xa0, 0x87, 0x70, 0x18,
+  0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87, 0x77, 0xa0, 0x87, 0x72, 0x18,
+  0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03, 0x71, 0xa8, 0x07, 0x73, 0x30,
+  0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87, 0x74, 0xd0, 0x87, 0x72, 0x00,
+  0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6, 0x21, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d,
+  0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x60, 0xc3, 0x26, 0x10, 0xc0,
+  0x02, 0x54, 0x43, 0x38, 0xa4, 0x83, 0x3c, 0xb4, 0x81, 0x38, 0xd4, 0x83,
+  0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x1b, 0xb8, 0xc3, 0x3b, 0xb4, 0x41,
+  0x38, 0xb0, 0x43, 0x3a, 0x84, 0xc3, 0x3c, 0x00, 0x1b, 0xb6, 0xa1, 0x00,
+  0x16, 0xa0, 0x1a, 0xc2, 0x21, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e,
+  0xcc, 0xc1, 0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0, 0x1d, 0xde, 0xa1, 0x0d,
+  0xc2, 0x81, 0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01, 0xd8, 0x60, 0x10, 0x08,
+  0xb0, 0x00, 0xd5, 0x06, 0xa3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x00, 0x6a, 0x83, 0x8f, 0x18, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x12,
+  0x50, 0x11, 0xe1, 0x00, 0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d,
+  0x60, 0x0e, 0xf5, 0xe0, 0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d,
+  0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43,
+  0x39, 0x00, 0x44, 0x3b, 0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3,
+  0x39, 0x84, 0x03, 0x3b, 0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3,
+  0x3b, 0xc8, 0x43, 0x1b, 0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03,
+  0x90, 0x07, 0x76, 0x00, 0x0c, 0xee, 0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5,
+  0x90, 0x0e, 0xec, 0x40, 0x0f, 0xe9, 0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee,
+  0xf0, 0x0e, 0x6d, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d,
+  0x00, 0x0f, 0xef, 0x90, 0x0e, 0xee, 0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d,
+  0x50, 0x0e, 0xec, 0x90, 0x0e, 0xed, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43,
+  0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43,
+  0x3b, 0x94, 0x43, 0x1b, 0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43,
+  0x39, 0xc8, 0x43, 0x1b, 0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81,
+  0x3b, 0xbc, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0x43, 0x38, 0x98, 0x03,
+  0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d,
+  0x90, 0x0e, 0xee, 0x60, 0x0e, 0xf3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d,
+  0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43,
+  0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43, 0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3,
+  0x3c, 0xb4, 0x81, 0x39, 0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03,
+  0x3a, 0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef,
+  0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xe7, 0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d,
+  0xa0, 0x0f, 0xe5, 0x20, 0x0f, 0xef, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0,
+  0xd0, 0x06, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43,
+  0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3, 0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43,
+  0x38, 0xc0, 0x03, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43,
+  0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00,
+  0x31, 0x0f, 0xf4, 0x10, 0x0e, 0xe3, 0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2,
+  0xf0, 0x0e, 0xf4, 0x50, 0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d,
+  0x20, 0x0e, 0xf5, 0x60, 0x0e, 0xe6, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3,
+  0x90, 0x0e, 0xfa, 0x50, 0x0e, 0x00, 0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3,
+  0x3c, 0x84, 0x83, 0x39, 0x94, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41,
+  0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5,
+  0x00, 0x6c, 0x40, 0x8e, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x06, 0x90,
+  0x80, 0x6a, 0x83, 0x81, 0x04, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x44, 0x00,
+  0x16, 0xa0, 0xda, 0x80, 0x28, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0c,
+  0x20, 0x01, 0xd5, 0x06, 0x63, 0xf9, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90,
+  0x00, 0x6a, 0xc3, 0xc4, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x28, 0x80,
+  0x34, 0xb8, 0xc3, 0x3b, 0xb4, 0x81, 0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03,
+  0x3d, 0xa4, 0x83, 0x3b, 0xcc, 0x03, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x41,
+  0x31, 0x21, 0x30, 0x26, 0x0c, 0x07, 0x92, 0x4c, 0x18, 0x14, 0x24, 0x99,
+  0x10, 0x2c, 0x13, 0x02, 0x06, 0x89, 0x20, 0x00, 0x00, 0x43, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4,
+  0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c,
+  0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xb8, 0xc1, 0x0c, 0xc0, 0x30, 0x02,
+  0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3,
+  0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84, 0x41, 0x18, 0x46, 0x18,
+  0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e, 0xe4, 0xa1, 0x1e, 0xc6,
+  0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e, 0xc2, 0x81, 0x1d, 0xf4,
+  0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e, 0xd2, 0x01, 0x1f, 0x50,
+  0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21,
+  0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40, 0x84, 0xa3, 0xa4, 0x29,
+  0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1,
+  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0xb8, 0x48, 0x9a, 0x22, 0x4a,
+  0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2, 0x7f, 0x1a, 0x23, 0x00,
+  0x06, 0x11, 0x18, 0xa1, 0x24, 0x41, 0x10, 0x08, 0x44, 0xb2, 0x2c, 0x0d,
+  0x39, 0x85, 0x28, 0x8a, 0xa2, 0x20, 0xa8, 0x0c, 0x00, 0x00, 0x90, 0x54,
+  0x04, 0x00, 0x20, 0xaa, 0x0c, 0x40, 0x51, 0x90, 0x55, 0x8c, 0xa2, 0x00,
+  0x00, 0x00, 0x20, 0xac, 0x0c, 0x45, 0x51, 0x90, 0x56, 0x84, 0xa2, 0x20,
+  0x6e, 0x8e, 0x20, 0x98, 0x23, 0x00, 0x83, 0x61, 0x04, 0xe1, 0x2b, 0x48,
+  0xb0, 0x34, 0x82, 0x07, 0x7a, 0x00, 0x85, 0x03, 0x01, 0x29, 0xf0, 0xcd,
+  0x11, 0x80, 0xc2, 0x20, 0x02, 0x20, 0x4c, 0x01, 0x8c, 0x00, 0x0c, 0x23,
+  0x0c, 0xdf, 0x20, 0x42, 0x20, 0x0c, 0x22, 0x1c, 0xc2, 0x20, 0x42, 0x21,
+  0x0c, 0x23, 0x10, 0x1f, 0x00, 0x13, 0xa8, 0x70, 0x48, 0x07, 0x79, 0xb0,
+  0x03, 0x3a, 0x68, 0x83, 0x70, 0x80, 0x07, 0x78, 0x60, 0x87, 0x72, 0x68,
+  0x83, 0x74, 0x78, 0x87, 0x79, 0xc8, 0x03, 0x37, 0x80, 0x03, 0x37, 0x80,
+  0x83, 0x0d, 0xb7, 0x51, 0x0e, 0x6d, 0x00, 0x0f, 0x7a, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xe9,
+  0x10, 0x07, 0x7a, 0x80, 0x07, 0x7a, 0x80, 0x07, 0x6d, 0x90, 0x0e, 0x78,
+  0xa0, 0x07, 0x78, 0xa0, 0x07, 0x78, 0xd0, 0x06, 0xe9, 0x10, 0x07, 0x76,
+  0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xd0, 0x06, 0xe9,
+  0x30, 0x07, 0x72, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a, 0x30, 0x07, 0x72,
+  0xd0, 0x06, 0xe9, 0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a,
+  0x60, 0x07, 0x74, 0xd0, 0x06, 0xe6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xe6, 0x60, 0x07, 0x74,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x10, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x60, 0x07, 0x7a, 0x10, 0x07, 0x76,
+  0xd0, 0x06, 0xf6, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x73, 0x20, 0x07, 0x7a,
+  0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x30, 0x07, 0x72, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x7a, 0x30, 0x07, 0x72, 0xd0, 0x06, 0xf6, 0x40, 0x07, 0x78,
+  0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74, 0xd0, 0x06, 0xf6,
+  0x60, 0x07, 0x74, 0xa0, 0x07, 0x76, 0x40, 0x07, 0x7a, 0x60, 0x07, 0x74,
+  0xd0, 0x06, 0xf6, 0x90, 0x07, 0x76, 0xa0, 0x07, 0x71, 0x20, 0x07, 0x78,
+  0xa0, 0x07, 0x71, 0x20, 0x07, 0x78, 0xd0, 0x06, 0xf6, 0x10, 0x07, 0x72,
+  0x80, 0x07, 0x7a, 0x10, 0x07, 0x72, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x72,
+  0x80, 0x07, 0x6d, 0x60, 0x0f, 0x71, 0x90, 0x07, 0x72, 0xa0, 0x07, 0x72,
+  0x50, 0x07, 0x76, 0xa0, 0x07, 0x72, 0x50, 0x07, 0x76, 0xd0, 0x06, 0xf6,
+  0x20, 0x07, 0x75, 0x60, 0x07, 0x7a, 0x20, 0x07, 0x75, 0x60, 0x07, 0x7a,
+  0x20, 0x07, 0x75, 0x60, 0x07, 0x6d, 0x60, 0x0f, 0x75, 0x10, 0x07, 0x72,
+  0xa0, 0x07, 0x75, 0x10, 0x07, 0x72, 0xa0, 0x07, 0x75, 0x10, 0x07, 0x72,
+  0xd0, 0x06, 0xf6, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74, 0xa0, 0x07, 0x71,
+  0x00, 0x07, 0x72, 0x40, 0x07, 0x7a, 0x10, 0x07, 0x70, 0x20, 0x07, 0x74,
+  0xd0, 0x06, 0xee, 0x80, 0x07, 0x7a, 0x10, 0x07, 0x76, 0xa0, 0x07, 0x73,
+  0x20, 0x07, 0x43, 0x98, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x80, 0x21, 0x4c, 0x04, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
+  0x10, 0x66, 0x02, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x08,
+  0x53, 0x01, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x84, 0xb9,
+  0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc2, 0x64, 0x08,
+  0x30, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x61, 0x26, 0x20, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x30, 0x1b, 0x10, 0x00, 0x02,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x98, 0x0e, 0x08, 0x00, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x80, 0x21, 0xcc, 0x06, 0x04, 0x80, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xc0, 0x10, 0x46, 0x0c, 0x80, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xc8, 0x02, 0x01, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0xfa, 0x46, 0x00, 0x4a, 0xa0, 0x10, 0x0a, 0xa4, 0x08, 0x0a, 0xa2, 0x80,
+  0x0a, 0x30, 0xa0, 0x0c, 0x0a, 0xa3, 0x50, 0x0a, 0xa6, 0x70, 0x0a, 0xac,
+  0x14, 0x8a, 0xa1, 0x1c, 0xa8, 0x2c, 0x9c, 0x11, 0x80, 0x42, 0x28, 0x88,
+  0xc2, 0x28, 0x90, 0x42, 0x29, 0x18, 0x22, 0xc7, 0x12, 0x24, 0x01, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xc9, 0x01, 0x00, 0x00, 0x1a, 0x03, 0x4c,
+  0x10, 0x97, 0x29, 0xa2, 0x25, 0x10, 0xab, 0x32, 0xb9, 0xb9, 0xb4, 0x37,
+  0xb7, 0x21, 0xc6, 0xf7, 0x8c, 0x01, 0x40, 0x06, 0x64, 0x40, 0xe5, 0x6e,
+  0x0c, 0x2d, 0x4c, 0xee, 0x6b, 0x2e, 0x4d, 0xaf, 0x6c, 0x88, 0xf1, 0x31,
+  0x63, 0x20, 0x7c, 0x0d, 0xe3, 0x20, 0x08, 0x0e, 0x8e, 0xad, 0x0c, 0xa4,
+  0xad, 0x8c, 0x2e, 0x8c, 0x0d, 0xc4, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd,
+  0x0d, 0x64, 0x46, 0x06, 0x46, 0x66, 0xc6, 0x85, 0x06, 0x86, 0x06, 0x04,
+  0xa5, 0xad, 0x8c, 0x2e, 0x8c, 0xcd, 0xac, 0xac, 0x65, 0x46, 0x06, 0x46,
+  0x66, 0xc6, 0x85, 0x06, 0x86, 0x26, 0x65, 0x88, 0x30, 0x06, 0xc4, 0x10,
+  0xe3, 0x63, 0x3e, 0xe8, 0x5b, 0x58, 0x34, 0x95, 0xd1, 0x85, 0xb1, 0x0d,
+  0x41, 0xc6, 0xe0, 0xf8, 0x98, 0x8f, 0xf9, 0x16, 0x6e, 0x61, 0x69, 0x72,
+  0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e,
+  0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65,
+  0x43, 0x84, 0x31, 0x48, 0xc8, 0x85, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5,
+  0xc1, 0xa5, 0xb1, 0x95, 0xb9, 0x98, 0x85, 0xcd, 0xd1, 0x7d, 0xb5, 0x85,
+  0xd1, 0xa1, 0x7d, 0x95, 0xb9, 0x85, 0x89, 0xb1, 0x95, 0x0d, 0x11, 0xc6,
+  0x60, 0x21, 0x19, 0x84, 0xa5, 0xc9, 0xb9, 0x8c, 0xbd, 0xb5, 0xc1, 0xa5,
+  0xb1, 0x95, 0xb9, 0x98, 0xc9, 0x85, 0xb5, 0x95, 0x89, 0xd5, 0x99, 0x99,
+  0x95, 0xc9, 0x7d, 0x99, 0x95, 0xd1, 0x8d, 0xa1, 0x7d, 0x95, 0xb9, 0x85,
+  0x89, 0xb1, 0x95, 0x0d, 0x11, 0xc6, 0xa0, 0x61, 0x14, 0x96, 0x26, 0xe7,
+  0x22, 0x57, 0xe6, 0x46, 0x56, 0x26, 0xf7, 0x45, 0x17, 0x26, 0x77, 0x56,
+  0x46, 0xc7, 0x28, 0x2c, 0x4d, 0xce, 0x25, 0x4c, 0xee, 0xec, 0x8b, 0x2e,
+  0x0f, 0xae, 0xec, 0xcb, 0x2d, 0xac, 0xad, 0x8c, 0x86, 0x19, 0xdb, 0x5b,
+  0x18, 0x1d, 0xcd, 0x10, 0x64, 0x0c, 0x9e, 0x6f, 0x19, 0x03, 0x68, 0x0c,
+  0xa2, 0x21, 0xc2, 0x18, 0x48, 0x64, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xde,
+  0xe6, 0xd2, 0xe8, 0xd2, 0xde, 0xdc, 0xa8, 0x84, 0xa5, 0xc9, 0xb9, 0x8c,
+  0x95, 0xb9, 0xd1, 0x95, 0xc9, 0x51, 0x0a, 0x4b, 0x93, 0x73, 0x71, 0x7b,
+  0xfb, 0x82, 0x2b, 0x93, 0x9b, 0x83, 0x2b, 0x1b, 0xa3, 0x4b, 0xb3, 0x2b,
+  0x23, 0x13, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0xe5, 0x16, 0xd6,
+  0x56, 0x46, 0x04, 0xee, 0x6d, 0x2e, 0x8d, 0x2e, 0xed, 0xcd, 0x6d, 0x08,
+  0xf4, 0x2d, 0x63, 0x40, 0x8d, 0x41, 0x35, 0x06, 0xd6, 0x18, 0x40, 0x63,
+  0x10, 0x8d, 0xc1, 0x35, 0x06, 0x18, 0xa5, 0xb0, 0x34, 0x39, 0x17, 0x33,
+  0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0xaf, 0x34, 0x37, 0xb8, 0x3a,
+  0x3a, 0x5a, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28,
+  0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29,
+  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe0, 0xca, 0xe4, 0xe6, 0xe0, 0xca, 0xc6,
+  0xe8, 0xd2, 0xec, 0xca, 0x58, 0x8c, 0xbd, 0xb1, 0xbd, 0xc9, 0x0d, 0x91,
+  0x3e, 0x66, 0x0c, 0xb4, 0x31, 0xd8, 0xc6, 0xa0, 0x1a, 0x03, 0x6e, 0x0c,
+  0xa0, 0x31, 0x88, 0xc6, 0xe0, 0x1a, 0x83, 0x8e, 0xd9, 0x59, 0x99, 0x5b,
+  0x99, 0x5c, 0x18, 0x5d, 0x19, 0x19, 0x0a, 0x0e, 0x5d, 0x19, 0xde, 0xd8,
+  0xdb, 0x9b, 0x1c, 0x19, 0x91, 0x9d, 0xcc, 0x97, 0x59, 0x0a, 0x0d, 0x33,
+  0xb6, 0xb7, 0x30, 0x3a, 0x19, 0x22, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x43, 0xa4, 0xef, 0x19, 0x03, 0x6d, 0x0c, 0xbe, 0x31, 0xa8,
+  0xc6, 0x80, 0x1b, 0x03, 0x68, 0x0c, 0xc0, 0x60, 0x0c, 0xae, 0x31, 0x08,
+  0x03, 0x2a, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x7c, 0xc2, 0xd2, 0xe4, 0x5c, 0xc4, 0xea, 0xcc, 0xcc, 0xca, 0xe4, 0xbe,
+  0xe6, 0xd2, 0xf4, 0xca, 0x28, 0x85, 0xa5, 0xc9, 0xb9, 0xb0, 0xbd, 0x8d,
+  0x85, 0xd1, 0xa5, 0xbd, 0xb9, 0x7d, 0xa5, 0xb9, 0x91, 0x95, 0xe1, 0x11,
+  0x09, 0x4b, 0x93, 0x73, 0x91, 0x2b, 0x0b, 0x23, 0x23, 0x15, 0x96, 0x26,
+  0xe7, 0x32, 0x47, 0x27, 0x57, 0x37, 0x46, 0xf7, 0x45, 0x97, 0x07, 0x57,
+  0xf6, 0x95, 0xe6, 0x66, 0xf6, 0xc6, 0xc2, 0x8c, 0xed, 0x2d, 0x8c, 0x8e,
+  0xcc, 0xdc, 0x98, 0xd4, 0x91, 0xd0, 0xd7, 0x5b, 0x1d, 0x1d, 0x5c, 0x1d,
+  0x1d, 0x19, 0xba, 0x32, 0x3c, 0xba, 0x3a, 0xb9, 0xb2, 0x2f, 0xba, 0x3c,
+  0xb8, 0x32, 0x2a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70,
+  0x65, 0x5c, 0xc6, 0xde, 0xd8, 0xde, 0xe4, 0xbe, 0xe6, 0xc6, 0xc2, 0xd8,
+  0xca, 0xe8, 0xd0, 0xbd, 0xb9, 0x95, 0xb5, 0x85, 0xc1, 0x7d, 0xb5, 0x95,
+  0xd1, 0xa1, 0xbd, 0x91, 0xf1, 0xa1, 0x7b, 0x73, 0x2b, 0x6b, 0x0b, 0x83,
+  0xfb, 0x32, 0x0b, 0x1b, 0xa3, 0x7b, 0x93, 0x8b, 0xe1, 0x43, 0xf7, 0xe6,
+  0x56, 0xd6, 0x16, 0x06, 0xf7, 0x65, 0x16, 0x36, 0x46, 0xf7, 0x26, 0x27,
+  0xc3, 0x67, 0x8e, 0x4c, 0xee, 0xeb, 0x0e, 0x2d, 0x8d, 0xae, 0xec, 0x0b,
+  0xee, 0x2d, 0xcd, 0x8d, 0x6e, 0x08, 0x2c, 0x7c, 0xcb, 0xd7, 0x7c, 0xcb,
+  0x18, 0xa0, 0xc1, 0x18, 0xa4, 0xc1, 0xd7, 0x7c, 0xcd, 0xb7, 0x8c, 0x01,
+  0x1a, 0x8c, 0x81, 0x1a, 0x7c, 0xd0, 0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1,
+  0x18, 0xac, 0xc1, 0x47, 0x7d, 0xcd, 0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x01,
+  0x1b, 0x7c, 0xce, 0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18, 0xb4, 0xc1,
+  0x57, 0x7d, 0xcd, 0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x81, 0x1b, 0x7c, 0xd6,
+  0xd7, 0x7c, 0xcb, 0x18, 0xa0, 0xc1, 0x18, 0xbc, 0xc1, 0x77, 0x7d, 0xcd,
+  0xb7, 0x8c, 0x01, 0x1a, 0x8c, 0x01, 0x1c, 0x30, 0x0a, 0x4b, 0x93, 0x73,
+  0x09, 0x93, 0x3b, 0xfb, 0xa2, 0xcb, 0x83, 0x2b, 0xfb, 0x9a, 0x4b, 0xd3,
+  0x2b, 0xe3, 0x15, 0x96, 0x26, 0xe7, 0x12, 0x26, 0x77, 0xf6, 0x45, 0x97,
+  0x07, 0x57, 0xf6, 0x15, 0xc6, 0x96, 0x76, 0xe6, 0xf6, 0x35, 0x97, 0xa6,
+  0x57, 0xc6, 0x67, 0x0a, 0x2d, 0x8c, 0xac, 0x4c, 0x6e, 0xe8, 0xcd, 0x6d,
+  0x8e, 0x2e, 0xcc, 0x8d, 0x6e, 0x8e, 0xc1, 0xd8, 0x10, 0x32, 0xf8, 0xa6,
+  0x31, 0x18, 0x83, 0x31, 0x20, 0x83, 0x2f, 0x1a, 0x83, 0x32, 0xf8, 0x96,
+  0x8f, 0x19, 0x03, 0x33, 0x18, 0x83, 0x33, 0x18, 0x83, 0x38, 0x18, 0x03,
+  0x39, 0xf8, 0xa2, 0x31, 0x98, 0x83, 0xaf, 0x19, 0x03, 0x68, 0x0c, 0xe8,
+  0x60, 0x0c, 0xae, 0x31, 0xa8, 0x03, 0x1a, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x33, 0x34, 0xde, 0xcc, 0xcc, 0xe6, 0xca, 0xe8, 0x88, 0x98, 0xb1, 0xbd,
+  0x85, 0xd1, 0xcd, 0xe0, 0xcd, 0xd0, 0x68, 0x0b, 0xa3, 0x93, 0x4b, 0xc3,
+  0x1b, 0x42, 0x7d, 0xcb, 0xe7, 0x7c, 0xcb, 0x18, 0xdc, 0xc1, 0x18, 0xe0,
+  0xc1, 0xe7, 0x7c, 0xd8, 0xb7, 0x8c, 0x41, 0x1e, 0x8c, 0x81, 0x1e, 0x30,
+  0xc9, 0xaa, 0xb2, 0x22, 0x2a, 0x1b, 0x7b, 0x23, 0x2b, 0xa3, 0x41, 0x56,
+  0x36, 0xf6, 0x46, 0x56, 0x36, 0x84, 0x0c, 0xbe, 0x66, 0x0c, 0xc6, 0x60,
+  0x0c, 0xc8, 0xe0, 0x93, 0xc6, 0xa0, 0x0c, 0x3e, 0xe6, 0x63, 0xc6, 0xc0,
+  0x0c, 0xc6, 0xe0, 0x0c, 0xc6, 0x60, 0x0f, 0xc6, 0x40, 0x0e, 0x3e, 0x69,
+  0x0c, 0xe6, 0xe0, 0x73, 0xc6, 0x00, 0x1a, 0x03, 0x3e, 0x18, 0x83, 0x6b,
+  0x0c, 0xfa, 0x80, 0x4b, 0x58, 0x9a, 0x9c, 0x0b, 0x5d, 0x19, 0x1e, 0x5d,
+  0x9d, 0x5c, 0x19, 0x95, 0xb0, 0x34, 0x39, 0x97, 0xb9, 0xb0, 0x36, 0x38,
+  0xb6, 0x32, 0x62, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64,
+  0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73, 0x61, 0x6d, 0x70,
+  0x6c, 0x65, 0x3e, 0x24, 0xe8, 0xca, 0xf0, 0xb2, 0x86, 0x50, 0x5f, 0x36,
+  0x06, 0x7f, 0x30, 0x06, 0x65, 0xf0, 0x2d, 0x1f, 0x33, 0x06, 0xa0, 0x30,
+  0x06, 0xd0, 0x18, 0x84, 0xc2, 0x18, 0x5c, 0x63, 0x20, 0x0a, 0x2c, 0xe8,
+  0xca, 0xf0, 0xaa, 0xac, 0x86, 0x50, 0x9f, 0x36, 0x06, 0x7f, 0x30, 0x06,
+  0x65, 0xf0, 0x31, 0x1f, 0x33, 0x06, 0xa0, 0x30, 0x06, 0xd0, 0x18, 0x84,
+  0xc2, 0x18, 0x5c, 0x63, 0x40, 0x0a, 0x5c, 0xc2, 0xd2, 0xe4, 0x5c, 0xe6,
+  0xc2, 0xda, 0xe0, 0xd8, 0xca, 0xe4, 0x78, 0xcc, 0x85, 0xb5, 0xc1, 0xb1,
+  0x95, 0xc9, 0x31, 0x98, 0x1b, 0x22, 0x7d, 0xdb, 0x18, 0x98, 0xc2, 0x18,
+  0x94, 0xc1, 0xb7, 0x7c, 0xcc, 0x18, 0x40, 0x63, 0x70, 0x0a, 0x63, 0x70,
+  0x8d, 0x01, 0x2a, 0x0c, 0x81, 0xc6, 0x20, 0x1b, 0x03, 0x6f, 0x0c, 0xc4,
+  0x60, 0x0c, 0xec, 0x60, 0x0c, 0xfc, 0x60, 0x0c, 0x46, 0x61, 0x0c, 0x4a,
+  0x61, 0x0c, 0x52, 0x61, 0x88, 0xf1, 0x00, 0x63, 0x30, 0x8d, 0x81, 0x2a,
+  0xb0, 0xfa, 0xd2, 0xa2, 0x9a, 0x8a, 0xa9, 0x99, 0x42, 0x0b, 0x23, 0x2b,
+  0x93, 0x1b, 0x7a, 0x73, 0x9b, 0xa3, 0x0b, 0x73, 0xa3, 0x9b, 0xe3, 0xf3,
+  0xd6, 0xe6, 0x96, 0x06, 0xf7, 0x46, 0x57, 0xe6, 0x46, 0x07, 0x32, 0x86,
+  0x16, 0x26, 0xc7, 0x67, 0x2a, 0xad, 0x0d, 0x8e, 0xad, 0x0c, 0x64, 0x68,
+  0x65, 0x05, 0x84, 0x4a, 0x28, 0x28, 0x68, 0x88, 0x30, 0x06, 0xae, 0x30,
+  0xc4, 0x18, 0x83, 0x56, 0x18, 0x83, 0x57, 0x28, 0x83, 0x6e, 0x88, 0x31,
+  0x06, 0x68, 0x30, 0x06, 0xb0, 0x50, 0x06, 0xdd, 0x10, 0x31, 0x18, 0x03,
+  0x56, 0x18, 0x83, 0x58, 0x28, 0x83, 0x6e, 0x0c, 0x62, 0xa1, 0x0c, 0xbc,
+  0x31, 0x88, 0x85, 0x32, 0xf8, 0xc6, 0x20, 0x16, 0xca, 0x00, 0x0c, 0xc6,
+  0x20, 0x16, 0xca, 0x20, 0x0c, 0xc6, 0x20, 0x16, 0xca, 0x40, 0x0c, 0xc6,
+  0x20, 0x16, 0xca, 0x60, 0x0c, 0xc6, 0x20, 0x16, 0xca, 0x80, 0x1b, 0x62,
+  0x8c, 0x81, 0x2c, 0x8c, 0x41, 0x2c, 0x94, 0x81, 0xc7, 0x31, 0x08, 0x4b,
+  0x93, 0x6b, 0x09, 0x63, 0x4b, 0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83,
+  0x2b, 0x9b, 0x43, 0x99, 0x22, 0x62, 0xfa, 0x72, 0xb2, 0x8a, 0x91, 0xf9,
+  0x32, 0x93, 0x0b, 0x3b, 0x6b, 0x2b, 0x73, 0xa3, 0x4b, 0x19, 0x42, 0x8c,
+  0x41, 0x2d, 0x8c, 0x01, 0x2d, 0xd0, 0x0a, 0x4b, 0x93, 0x6b, 0x09, 0x63,
+  0x4b, 0x0b, 0x9b, 0x6b, 0x99, 0x1b, 0x7b, 0x83, 0x2b, 0x6b, 0x09, 0x93,
+  0x3b, 0x43, 0x99, 0x49, 0x19, 0x62, 0x8c, 0xc1, 0x2d, 0x8c, 0x41, 0x2d,
+  0x8c, 0x81, 0x2d, 0x0c, 0x11, 0xc6, 0xe0, 0x16, 0x68, 0x85, 0xa5, 0xc9,
+  0xb5, 0x84, 0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95,
+  0xb5, 0x84, 0xc9, 0x9d, 0xa1, 0xd0, 0xa4, 0x0c, 0x31, 0xc6, 0x40, 0x17,
+  0xc6, 0xa0, 0x16, 0xc6, 0x20, 0x17, 0x88, 0x85, 0xa5, 0xc9, 0xb5, 0x84,
+  0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0xd0,
+  0x95, 0xe1, 0xd1, 0xd5, 0xc9, 0x95, 0xcd, 0x0d, 0x31, 0xc6, 0x80, 0x17,
+  0xc6, 0xa0, 0x16, 0xc6, 0x60, 0x17, 0x88, 0x85, 0xa5, 0xc9, 0xb5, 0x84,
+  0xb1, 0xa5, 0x85, 0xcd, 0xb5, 0xcc, 0x8d, 0xbd, 0xc1, 0x95, 0xb5, 0xcc,
+  0x85, 0xb5, 0xc1, 0xb1, 0x95, 0xc9, 0xcd, 0x0d, 0x31, 0xc6, 0xc0, 0x17,
+  0xc6, 0xa0, 0x16, 0xc6, 0xa0, 0x17, 0x86, 0x18, 0x63, 0xa0, 0x0b, 0x63,
+  0xc0, 0x0b, 0x63, 0xe0, 0x0b, 0x43, 0x88, 0x31, 0xe0, 0x85, 0x31, 0xf0,
+  0x85, 0x21, 0xc4, 0x18, 0xdc, 0xc2, 0x18, 0xe8, 0xc2, 0x10, 0x61, 0x0c,
+  0x74, 0x61, 0x88, 0x31, 0x06, 0xb7, 0x30, 0x06, 0xbc, 0x30, 0x06, 0xbe,
+  0x30, 0xc4, 0x18, 0x03, 0x59, 0x18, 0x83, 0x58, 0x28, 0x83, 0x6f, 0x88,
+  0x31, 0x06, 0xb2, 0x30, 0x06, 0xb1, 0x50, 0x06, 0xdc, 0x10, 0x63, 0x0c,
+  0x64, 0x61, 0x0c, 0x62, 0xa1, 0x0c, 0xc2, 0x60, 0x88, 0x31, 0x06, 0xb2,
+  0x30, 0x06, 0xb1, 0x50, 0x06, 0x62, 0x30, 0xc4, 0x18, 0x03, 0x59, 0x18,
+  0x83, 0x58, 0x28, 0x83, 0x31, 0x18, 0x62, 0x8c, 0x81, 0x2c, 0x8c, 0x41,
+  0x2c, 0x94, 0x01, 0x18, 0x0c, 0x31, 0xc6, 0x40, 0x16, 0xc6, 0x20, 0x16,
+  0xca, 0xa0, 0x1b, 0x11, 0xb1, 0x03, 0x3b, 0xd8, 0x43, 0x3b, 0xb8, 0x41,
+  0x3b, 0xbc, 0x03, 0x39, 0xd4, 0x03, 0x3b, 0x94, 0x83, 0x1b, 0x98, 0x03,
+  0x3b, 0x84, 0xc3, 0x39, 0xcc, 0xc3, 0x14, 0x21, 0x18, 0x46, 0x28, 0xec,
+  0xc0, 0x0e, 0xf6, 0xd0, 0x0e, 0x6e, 0x90, 0x0e, 0xe4, 0x50, 0x0e, 0xee,
+  0x40, 0x0f, 0x53, 0x82, 0x62, 0xc4, 0x12, 0x0e, 0xe9, 0x20, 0x0f, 0x6e,
+  0x60, 0x0f, 0xe5, 0x20, 0x0f, 0xf3, 0x90, 0x0e, 0xef, 0xe0, 0x0e, 0x53,
+  0x02, 0x63, 0x04, 0x15, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0xc0, 0x0e, 0xe1,
+  0xe0, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x70, 0x0e, 0xe5, 0xf0, 0x0b, 0xf6,
+  0x50, 0x0e, 0xf2, 0x30, 0x0f, 0xe9, 0xf0, 0x0e, 0xee, 0x30, 0x25, 0x40,
+  0x46, 0x4c, 0xe1, 0x90, 0x0e, 0xf2, 0xe0, 0x06, 0xe3, 0xf0, 0x0e, 0xed,
+  0x00, 0x0f, 0xe9, 0xc0, 0x0e, 0xe5, 0xf0, 0x0b, 0xef, 0x00, 0x0f, 0xf4,
+  0x90, 0x0e, 0xef, 0xe0, 0x0e, 0xf3, 0x30, 0x65, 0x50, 0x18, 0x67, 0x04,
+  0x13, 0x0e, 0xe9, 0x20, 0x0f, 0x6e, 0x60, 0x0e, 0xf2, 0x10, 0x0e, 0xe7,
+  0xd0, 0x0e, 0xe5, 0xe0, 0x0e, 0xf4, 0x30, 0x25, 0x58, 0x05, 0x00, 0x00,
+  0x00, 0x79, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x2e, 0x00, 0x00, 0x00, 0x56, 0x90, 0xfd, 0x73, 0x6d, 0x6b, 0xcf,
+  0xb3, 0x60, 0xad, 0xd3, 0x10, 0x0c, 0xf0, 0x74, 0xd5, 0xfd, 0x17, 0x45,
+  0x51, 0x14, 0x76, 0x20, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x8f,
+  0x63, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x11, 0x34, 0x00, 0x12, 0xf9, 0x83,
+  0x33, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x29, 0x6c, 0x00, 0x12, 0xf9, 0x12,
+  0xc0, 0x3c, 0x0b, 0xf1, 0x4f, 0xc4, 0x35, 0x51, 0x11, 0xf1, 0xdb, 0x83,
+  0x5f, 0xe1, 0xc5, 0x6d, 0x1b, 0xc2, 0x04, 0x20, 0x91, 0x5f, 0x00, 0xd2,
+  0xf4, 0x17, 0x40, 0x20, 0xf9, 0xd5, 0x5d, 0xdc, 0xb6, 0x05, 0x50, 0x00,
+  0x12, 0xf9, 0x05, 0x20, 0x4d, 0xbf, 0xb0, 0x00, 0xcc, 0xe3, 0x57, 0x77,
+  0x71, 0xdb, 0x96, 0x30, 0x01, 0x48, 0xe4, 0x17, 0x80, 0x34, 0xfd, 0x05,
+  0x03, 0x5c, 0x7e, 0x75, 0x17, 0xb7, 0x6d, 0x02, 0x10, 0x80, 0x44, 0x7e,
+  0x01, 0x48, 0xd3, 0xff, 0x38, 0x96, 0x5f, 0xdc, 0xb6, 0x01, 0x44, 0x6c,
+  0x57, 0xfe, 0xe7, 0x5b, 0xdb, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0x93,
+  0x0d, 0x44, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0x7f, 0x01, 0x04, 0x92,
+  0x5f, 0xdc, 0xb6, 0x19, 0x44, 0x00, 0x12, 0xf9, 0x05, 0x20, 0x4d, 0x7f,
+  0xc1, 0x00, 0x97, 0x5f, 0xdc, 0x36, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x12, 0x02, 0x00, 0x00, 0x13, 0x04, 0x72, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x56, 0x00, 0x00, 0x00, 0xd4, 0x8e, 0x45, 0x00, 0x81, 0x70, 0xcc,
+  0x41, 0x2c, 0xcc, 0x83, 0x07, 0x94, 0x8e, 0x35, 0x00, 0x03, 0x31, 0xc7,
+  0xb0, 0x30, 0x78, 0x30, 0xc7, 0xb0, 0xe0, 0x01, 0x1e, 0x8c, 0x00, 0x8c,
+  0x35, 0x00, 0x81, 0x40, 0x65, 0x11, 0x94, 0x00, 0x81, 0x63, 0x09, 0x01,
+  0x30, 0x02, 0x40, 0xdf, 0x0c, 0x00, 0x79, 0x23, 0x00, 0x35, 0x40, 0xc0,
+  0x0c, 0x00, 0x05, 0x33, 0x00, 0x33, 0x00, 0x73, 0x10, 0xb4, 0xa0, 0x0b,
+  0xb4, 0xb0, 0x07, 0x24, 0xcc, 0x00, 0x50, 0x31, 0x03, 0x30, 0x02, 0x30,
+  0x03, 0x30, 0xd6, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82, 0xf8,
+  0x07, 0x82, 0x20, 0x88, 0x7f, 0x63, 0x0d, 0x6c, 0x3b, 0xff, 0xa4, 0xc7,
+  0xb6, 0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4, 0x37, 0xd6, 0x00, 0x82,
+  0x20, 0x5b, 0xff, 0x02, 0x08, 0x82, 0x6c, 0xfd, 0x0b, 0x20, 0x08, 0xb2,
+  0xf5, 0x2f, 0x8c, 0x35, 0x80, 0x20, 0xb8, 0xe6, 0x60, 0x00, 0x82, 0xe0,
+  0x9a, 0x83, 0x01, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x63, 0x0d, 0x20, 0x48,
+  0xb7, 0x39, 0x18, 0x80, 0x20, 0xdd, 0xe6, 0x60, 0x00, 0x82, 0x74, 0x9b,
+  0x83, 0xc1, 0x58, 0xc3, 0x3a, 0xe2, 0x31, 0x0b, 0x06, 0xeb, 0x88, 0xc7,
+  0x2c, 0x18, 0xac, 0x23, 0x1e, 0xb3, 0x60, 0x30, 0xd6, 0x00, 0x82, 0x30,
+  0x1e, 0x8e, 0x01, 0x08, 0xc2, 0x78, 0x38, 0x06, 0x20, 0x08, 0xe3, 0xe1,
+  0x18, 0x8c, 0x35, 0x88, 0xb9, 0x98, 0xf6, 0x1f, 0x58, 0xf2, 0x6c, 0xfc,
+  0x0b, 0x63, 0xba, 0xaa, 0xb9, 0x2f, 0x8c, 0x35, 0xfc, 0x33, 0xe9, 0xff,
+  0xbe, 0x40, 0xd7, 0xa0, 0x98, 0x7f, 0x2d, 0x1c, 0xc7, 0xa0, 0x2f, 0x8c,
+  0x35, 0xcc, 0x7d, 0x9b, 0xa6, 0xbe, 0xd0, 0xba, 0x21, 0xcf, 0xfb, 0x02,
+  0x9f, 0xb3, 0x3e, 0xfe, 0x11, 0x30, 0x46, 0x00, 0x82, 0x20, 0x48, 0x82,
+  0xc1, 0x18, 0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x63, 0x04, 0x3a, 0x6b,
+  0xce, 0x21, 0x18, 0x8c, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf, 0x18, 0x81,
+  0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18,
+  0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf,
+  0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x0b, 0x63, 0x04, 0x7d, 0x2c, 0xba,
+  0xf8, 0x37, 0x46, 0x50, 0xab, 0xb5, 0xda, 0x7e, 0x63, 0x04, 0xb2, 0xe8,
+  0xf6, 0x34, 0x18, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x08, 0x00,
+  0x00, 0xe3, 0x0d, 0x73, 0xe0, 0x07, 0xaf, 0x40, 0xc1, 0x18, 0x6e, 0x08,
+  0x9e, 0x60, 0x96, 0x21, 0x10, 0x82, 0x11, 0x03, 0xa5, 0x08, 0x68, 0x81,
+  0x0e, 0xe4, 0xe0, 0x0e, 0xc8, 0xe0, 0x0c, 0xca, 0x80, 0x18, 0x31, 0x50,
+  0x8a, 0xa0, 0x16, 0xe8, 0x60, 0x0e, 0xf0, 0xa0, 0x0c, 0xd0, 0xc0, 0x0c,
+  0x8a, 0x41, 0x06, 0x61, 0x0c, 0xde, 0x60, 0x90, 0x41, 0x28, 0x83, 0x38,
+  0x18, 0x64, 0x10, 0x82, 0x39, 0x38, 0x3d, 0x50, 0x97, 0x82, 0x32, 0xc8,
+  0x10, 0xa4, 0x81, 0x1c, 0x18, 0x11, 0xc0, 0x67, 0xbc, 0xc1, 0x0f, 0x54,
+  0x61, 0x17, 0x2e, 0x50, 0x97, 0x82, 0x32, 0xc8, 0x10, 0xb8, 0xc1, 0x1d,
+  0x8c, 0x18, 0x14, 0x46, 0x70, 0x0e, 0x45, 0x30, 0xc7, 0xf0, 0x06, 0x41,
+  0x38, 0x8c, 0x57, 0x90, 0x02, 0x2c, 0x84, 0x83, 0x38, 0xe0, 0xc1, 0x05,
+  0xea, 0x52, 0x50, 0x06, 0x19, 0x02, 0x3a, 0xe8, 0x83, 0x11, 0x83, 0xc2,
+  0x08, 0xda, 0x61, 0x09, 0xe6, 0x18, 0x8c, 0xc0, 0x1c, 0xc6, 0x2b, 0x54,
+  0xc1, 0x16, 0xce, 0x01, 0x1d, 0xfe, 0xe0, 0x02, 0x75, 0x29, 0x28, 0x83,
+  0x0c, 0x81, 0x1e, 0x8c, 0xc2, 0x88, 0x41, 0x61, 0x04, 0xf3, 0x10, 0x05,
+  0x73, 0x0c, 0x46, 0x90, 0x0e, 0xb3, 0x04, 0xc4, 0x70, 0x43, 0xc7, 0x06,
+  0xc1, 0x2c, 0xc3, 0x40, 0x04, 0x23, 0x06, 0x4a, 0x11, 0xc0, 0x03, 0x2c,
+  0xb8, 0xc2, 0x2c, 0x80, 0xc2, 0x28, 0x84, 0x02, 0x18, 0x8c, 0x18, 0x28,
+  0x45, 0x10, 0x0f, 0xb0, 0xf0, 0x0a, 0xb4, 0x10, 0x0a, 0xa4, 0x20, 0x0a,
+  0x61, 0x30, 0xc8, 0x10, 0x80, 0x82, 0x29, 0x0c, 0x32, 0x0c, 0xa0, 0xc0,
+  0x0a, 0x83, 0x0c, 0xc2, 0x1f, 0xb8, 0xc2, 0x20, 0x83, 0x10, 0xc0, 0xc2,
+  0xdd, 0x82, 0xba, 0x14, 0x94, 0x41, 0x86, 0xc0, 0x14, 0x5e, 0xc1, 0x88,
+  0x00, 0x3e, 0xe3, 0x0d, 0xbb, 0x70, 0x0e, 0xf8, 0x70, 0x81, 0xba, 0x14,
+  0x94, 0x41, 0x86, 0x60, 0x15, 0x68, 0x61, 0xc4, 0xa0, 0x30, 0x02, 0x92,
+  0x28, 0x82, 0x39, 0x06, 0x56, 0x08, 0xfc, 0x61, 0xbc, 0x22, 0x1c, 0xda,
+  0xc1, 0x1f, 0xfe, 0xa1, 0x16, 0x2e, 0x50, 0x97, 0x82, 0x32, 0xc8, 0x10,
+  0xc4, 0x82, 0x2e, 0x8c, 0x18, 0x14, 0x46, 0xa0, 0x12, 0x4b, 0x30, 0xc7,
+  0x60, 0x04, 0x23, 0x31, 0x5e, 0x71, 0x0e, 0xf3, 0x40, 0x12, 0x25, 0xc1,
+  0x0b, 0x17, 0xa8, 0x4b, 0x41, 0x19, 0x64, 0x08, 0x6e, 0x01, 0x1c, 0x46,
+  0x0c, 0x0a, 0x23, 0x80, 0x89, 0x28, 0x98, 0x63, 0x30, 0x02, 0x93, 0x98,
+  0x25, 0x20, 0x06, 0x3a, 0x02, 0x3e, 0x08, 0x84, 0x01, 0x2e, 0x84, 0x39,
+  0x86, 0x60, 0x14, 0x48, 0x62, 0xbc, 0x01, 0x1e, 0xf6, 0x21, 0x25, 0x28,
+  0x18, 0xc3, 0x0d, 0x41, 0x2b, 0x04, 0xb3, 0x0c, 0x85, 0x11, 0x0c, 0x32,
+  0x10, 0xbf, 0x80, 0x0e, 0xe3, 0x0d, 0xf4, 0xf0, 0x0f, 0x21, 0x41, 0xc1,
+  0x18, 0x31, 0x20, 0x8c, 0xc0, 0x26, 0x86, 0x11, 0x83, 0xc2, 0x08, 0x70,
+  0x22, 0xd8, 0x05, 0x0b, 0x76, 0x01, 0x3e, 0x23, 0x06, 0x85, 0x11, 0xe0,
+  0x44, 0x00, 0x0e, 0x36, 0xf0, 0x82, 0x7c, 0x8c, 0x17, 0x82, 0xf8, 0xd8,
+  0x10, 0xd0, 0x67, 0xc4, 0x80, 0x30, 0x82, 0x9e, 0x08, 0x46, 0x0c, 0x0a,
+  0x23, 0xf8, 0x89, 0xc0, 0x17, 0x2c, 0xf0, 0x05, 0xf9, 0xcc, 0x31, 0xa0,
+  0xc3, 0xd2, 0x13, 0x83, 0x0c, 0x41, 0x3a, 0xdc, 0x83, 0x0d, 0x01, 0x7d,
+  0x06, 0x19, 0x82, 0x75, 0xe8, 0x87, 0x41, 0x86, 0xa0, 0xfa, 0x87, 0x59,
+  0x02, 0x63, 0xa0, 0x22, 0x10, 0x0a, 0x36, 0x20, 0xc6, 0x1b, 0x4c, 0x22,
+  0x26, 0xc2, 0x82, 0x82, 0x31, 0xdc, 0x10, 0xd8, 0x82, 0x33, 0xcb, 0x70,
+  0x20, 0xc1, 0x20, 0x03, 0x51, 0x0f, 0xfe, 0x30, 0xde, 0xa0, 0x12, 0x35,
+  0x91, 0x13, 0x14, 0x8c, 0xf1, 0x06, 0x96, 0xb8, 0x09, 0x9d, 0xa0, 0x60,
+  0x8c, 0x18, 0x20, 0x47, 0x14, 0x17, 0x45, 0x77, 0x0c, 0xc1, 0x20, 0x43,
+  0x70, 0x0f, 0x29, 0x31, 0xc8, 0x10, 0x2c, 0x2b, 0x31, 0x4b, 0x80, 0x0c,
+  0x54, 0x04, 0xc2, 0x81, 0x19, 0xc3, 0x0d, 0x61, 0x60, 0x0e, 0xc1, 0x2c,
+  0x43, 0x72, 0x05, 0xe3, 0x0d, 0x33, 0xe1, 0x13, 0x6f, 0x41, 0xc1, 0x18,
+  0x6e, 0x08, 0xd2, 0x21, 0x98, 0x65, 0x50, 0x96, 0x60, 0x90, 0xa1, 0x10,
+  0x89, 0x95, 0x18, 0x6f, 0xb8, 0x09, 0xb1, 0x60, 0x0b, 0x0a, 0xc6, 0x1c,
+  0x43, 0x48, 0x04, 0x76, 0x31, 0xc8, 0x10, 0x88, 0x04, 0x4c, 0x58, 0x50,
+  0xc8, 0x67, 0x90, 0x21, 0x20, 0x09, 0x9b, 0x98, 0x25, 0x88, 0x83, 0xf1,
+  0x86, 0x9e, 0x40, 0x0b, 0xbd, 0xa0, 0x60, 0x8c, 0x37, 0xfc, 0x84, 0x5a,
+  0xd0, 0x05, 0x05, 0x63, 0x90, 0x01, 0x6a, 0x89, 0x9d, 0x18, 0x6e, 0x20,
+  0xe0, 0xc1, 0x99, 0x65, 0x60, 0xac, 0x60, 0x0c, 0x41, 0x02, 0x8d, 0xe1,
+  0x86, 0x20, 0x1f, 0x94, 0x59, 0x06, 0xa7, 0x09, 0x4c, 0xd8, 0x07, 0xf9,
+  0xcc, 0x12, 0x3c, 0x36, 0xf4, 0x03, 0x7c, 0x46, 0x0c, 0x08, 0x23, 0x60,
+  0x8d, 0xc0, 0x02, 0x90, 0x90, 0xcf, 0x88, 0x41, 0x61, 0x04, 0xaf, 0x11,
+  0x88, 0xc4, 0x2c, 0xc1, 0x33, 0x50, 0x01, 0x28, 0x8d, 0xe0, 0xcc, 0x31,
+  0xd8, 0x44, 0x80, 0x1a, 0x63, 0x08, 0x1b, 0x6a, 0x0c, 0x37, 0x04, 0x22,
+  0xa1, 0xcc, 0x32, 0x44, 0x50, 0x60, 0x02, 0x49, 0xc8, 0x67, 0x96, 0x40,
+  0xb2, 0xc1, 0x24, 0xe0, 0x33, 0x62, 0x40, 0x18, 0x41, 0x6d, 0x04, 0x16,
+  0xa4, 0x84, 0x7c, 0x46, 0x0c, 0x0a, 0x23, 0xc0, 0x8d, 0x60, 0x25, 0x66,
+  0x09, 0xa4, 0x81, 0x0a, 0x40, 0x81, 0x84, 0x68, 0x8e, 0x21, 0x09, 0x60,
+  0x63, 0x0c, 0x81, 0x0c, 0x5c, 0x63, 0xb8, 0x21, 0x58, 0x09, 0x65, 0x96,
+  0x81, 0x9a, 0x02, 0x13, 0x5a, 0x42, 0x3e, 0xb3, 0x04, 0x95, 0x0d, 0x2f,
+  0x01, 0x9f, 0x11, 0x03, 0xc2, 0x08, 0x7c, 0x23, 0xb0, 0x40, 0x26, 0xe4,
+  0x33, 0x62, 0x50, 0x18, 0x41, 0x78, 0x04, 0x34, 0x31, 0x4b, 0x50, 0x0d,
+  0x54, 0x00, 0xca, 0x24, 0x50, 0x73, 0x0c, 0x49, 0x60, 0x1b, 0xb3, 0x04,
+  0xd6, 0x40, 0x45, 0x20, 0x54, 0x7a, 0xb0, 0x0c, 0x32, 0x04, 0x6b, 0x41,
+  0x17, 0x73, 0x0c, 0x68, 0x01, 0x06, 0xbd, 0x31, 0xc8, 0x10, 0xa4, 0xc5,
+  0x5d, 0xd8, 0x10, 0xc8, 0x67, 0x90, 0x21, 0x58, 0x8b, 0xbe, 0x98, 0x25,
+  0x88, 0x83, 0xe1, 0x86, 0x59, 0xf0, 0x89, 0x60, 0x96, 0x01, 0x23, 0x83,
+  0x60, 0x90, 0x81, 0x0e, 0xe2, 0x42, 0x2f, 0xc6, 0x1b, 0x4c, 0x23, 0x36,
+  0xc6, 0x83, 0x82, 0x31, 0xde, 0x80, 0x1a, 0xb3, 0xd1, 0x1b, 0x14, 0x8c,
+  0x39, 0x06, 0xb9, 0x08, 0xce, 0x63, 0x90, 0x21, 0x98, 0x8b, 0xd0, 0xb0,
+  0xe0, 0x90, 0xcf, 0x20, 0x43, 0x50, 0x17, 0xa7, 0x31, 0xdc, 0x70, 0xf0,
+  0x84, 0x33, 0xcb, 0x30, 0x06, 0x59, 0x30, 0x86, 0x30, 0xb0, 0xc7, 0x70,
+  0x43, 0xf0, 0x13, 0xca, 0x2c, 0xc3, 0xa6, 0x05, 0x26, 0x84, 0x85, 0x7c,
+  0x66, 0x09, 0xb8, 0x11, 0x03, 0xc2, 0x08, 0xee, 0x63, 0x18, 0x31, 0x28,
+  0x8c, 0x20, 0x3f, 0x02, 0xb2, 0xb0, 0xc0, 0x2c, 0xe4, 0x63, 0x01, 0x5a,
+  0xc0, 0x67, 0x96, 0x80, 0x1b, 0xa8, 0x00, 0x14, 0x4d, 0xd8, 0xe6, 0x18,
+  0xfa, 0x22, 0xa0, 0x8f, 0x31, 0x04, 0x86, 0x3e, 0x86, 0x1b, 0x02, 0xb4,
+  0x50, 0x66, 0x19, 0xbc, 0x2e, 0x30, 0x41, 0x2d, 0xe4, 0x33, 0x4b, 0xf0,
+  0x8d, 0x18, 0x10, 0x46, 0x00, 0x22, 0xc3, 0x88, 0x41, 0x61, 0x04, 0x22,
+  0x12, 0xb4, 0x85, 0x05, 0x6f, 0x21, 0x1f, 0x0b, 0xe2, 0x02, 0x3e, 0xb3,
+  0x04, 0xdf, 0x40, 0x05, 0xa0, 0x74, 0x82, 0x37, 0xc7, 0x90, 0x04, 0xfc,
+  0x31, 0x86, 0x50, 0xe9, 0xc7, 0x70, 0x43, 0x10, 0x17, 0xca, 0x2c, 0x43,
+  0x18, 0x80, 0x41, 0x60, 0xc2, 0x5c, 0xc8, 0x67, 0x96, 0x40, 0x0c, 0x46,
+  0x0c, 0x08, 0x23, 0x48, 0x91, 0x61, 0xc4, 0xa0, 0x30, 0x82, 0x15, 0x09,
+  0xec, 0xc2, 0x02, 0xbc, 0x90, 0x8f, 0x05, 0x7a, 0x01, 0x9f, 0x59, 0x02,
+  0x31, 0x18, 0xa8, 0x00, 0x14, 0x30, 0x10, 0xc2, 0x60, 0x8e, 0x21, 0x09,
+  0x44, 0x64, 0xc4, 0xc0, 0x30, 0x82, 0x18, 0x09, 0x62, 0xe3, 0x35, 0x06,
+  0x19, 0x82, 0xd9, 0x28, 0x8f, 0x59, 0x82, 0x31, 0x18, 0xa8, 0x08, 0xfc,
+  0x00, 0x13, 0xc4, 0x60, 0x90, 0x21, 0xc8, 0x8d, 0xf3, 0x98, 0x25, 0x88,
+  0x83, 0x59, 0x86, 0x32, 0x88, 0x03, 0x7e, 0x18, 0x64, 0xe8, 0x05, 0xdd,
+  0x18, 0x8f, 0x11, 0x83, 0xc2, 0x08, 0x66, 0x24, 0x68, 0x8d, 0x39, 0x06,
+  0xdb, 0x08, 0x5a, 0x64, 0xc4, 0xa0, 0x30, 0x82, 0x1a, 0x19, 0x5c, 0x63,
+  0x8e, 0x41, 0x08, 0x5c, 0x64, 0xc4, 0xa0, 0x30, 0x82, 0x1b, 0x29, 0x5e,
+  0x63, 0x8e, 0x41, 0x08, 0x5a, 0x64, 0x90, 0x21, 0xe8, 0x8d, 0xf7, 0x18,
+  0x64, 0x08, 0xca, 0x21, 0x3e, 0xc6, 0x1b, 0xee, 0x43, 0x44, 0x68, 0x84,
+  0x82, 0x31, 0xde, 0x90, 0x1f, 0x24, 0xe2, 0x22, 0x14, 0x8c, 0x39, 0x86,
+  0xf1, 0x08, 0x70, 0x64, 0x90, 0x21, 0x20, 0x0f, 0xf9, 0xb0, 0x20, 0x91,
+  0xcf, 0x20, 0x43, 0x60, 0x1e, 0xf8, 0x31, 0xdc, 0x70, 0xb4, 0x86, 0x33,
+  0xcb, 0x00, 0x07, 0x66, 0x10, 0x8c, 0x21, 0x0c, 0x3d, 0x32, 0xdc, 0x10,
+  0xc0, 0x86, 0x32, 0xcb, 0x80, 0x06, 0x67, 0x10, 0x98, 0x20, 0x1b, 0xf2,
+  0x99, 0x25, 0x48, 0x83, 0x11, 0x03, 0xc2, 0x08, 0xd0, 0x64, 0x18, 0x31,
+  0x28, 0x8c, 0x40, 0x4d, 0x82, 0xda, 0xb0, 0xe0, 0x36, 0xe4, 0x63, 0x41,
+  0x6e, 0xc0, 0x67, 0x96, 0x20, 0x0d, 0x06, 0x2a, 0x00, 0xe5, 0x0c, 0x04,
+  0x34, 0x98, 0x63, 0x70, 0x8f, 0xa0, 0x4c, 0xc6, 0x10, 0x98, 0x32, 0x19,
+  0x6e, 0x08, 0x72, 0x43, 0x99, 0x65, 0x58, 0x03, 0x35, 0x08, 0x4c, 0xd8,
+  0x0d, 0xf9, 0xcc, 0x12, 0xb0, 0xc1, 0x88, 0x01, 0x61, 0x04, 0x71, 0x32,
+  0x8c, 0x18, 0x14, 0x46, 0x30, 0x27, 0x81, 0x6f, 0x58, 0x00, 0x1e, 0xf2,
+  0xb1, 0x40, 0x3c, 0xe0, 0x33, 0x4b, 0xc0, 0x06, 0x03, 0x15, 0x80, 0xa2,
+  0x06, 0xc2, 0x1a, 0xcc, 0x31, 0x24, 0x41, 0x9b, 0x8c, 0x21, 0x54, 0x6b,
+  0x32, 0xdc, 0x10, 0x88, 0x87, 0x32, 0xcb, 0xe0, 0x06, 0x6d, 0x10, 0x98,
+  0x40, 0x1e, 0xf2, 0x99, 0x25, 0x78, 0x83, 0x11, 0x03, 0xc2, 0x08, 0xf4,
+  0x64, 0x18, 0x31, 0x28, 0x8c, 0x80, 0x4f, 0x82, 0xf3, 0xb0, 0x20, 0x3d,
+  0xe4, 0x63, 0xc1, 0x7a, 0xc0, 0x67, 0x96, 0xe0, 0x0d, 0x06, 0x2a, 0x00,
+  0xa5, 0x0d, 0x04, 0x37, 0x98, 0x63, 0x48, 0x82, 0x39, 0x19, 0x31, 0x30,
+  0x8c, 0x40, 0x54, 0x02, 0x11, 0x01, 0x91, 0x41, 0x86, 0x80, 0x44, 0x6c,
+  0x64, 0x96, 0x00, 0x0e, 0x06, 0x2a, 0x02, 0x3f, 0x28, 0x03, 0xe1, 0x0d,
+  0x06, 0x19, 0x02, 0x15, 0xc1, 0x91, 0x59, 0x82, 0x38, 0x18, 0x68, 0x09,
+  0x78, 0x44, 0xe1, 0x11, 0x8b, 0x47, 0xc6, 0x40, 0x16, 0xe0, 0x80, 0x47,
+  0xc8, 0x60, 0xa0, 0x25, 0x40, 0x11, 0x45, 0x2f, 0x2c, 0x73, 0x18, 0x03,
+  0x02, 0x0e, 0x68, 0x88, 0x0c, 0x06, 0x19, 0x02, 0x81, 0x47, 0x2c, 0x20,
+  0x13, 0xf9, 0x64, 0x10, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x17, 0xd3, 0x07, 0xff, 0x5c, 0xe3, 0x20, 0x31, 0xa1, 0xd4, 0xf4,
+  0x50, 0x13, 0xe7, 0x2c, 0x4e, 0xd4, 0x55, 0xf8, 0x5f, 0xac, 0x6e, 0x5d,
+  0x9b, 0x6d, 0x29, 0x38, 0x8d, 0x34, 0x01, 0xcd, 0x44, 0xd6, 0x39, 0x7b,
+  0x00, 0x03, 0x11, 0x71, 0x4e, 0x23, 0x4d, 0x40, 0x33, 0x49, 0x3e, 0x71,
+  0x21, 0x13, 0x00, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x2c, 0x00, 0x00,
+  0x00, 0x5b, 0x8e, 0x20, 0x98, 0x85, 0x03, 0x17, 0x90, 0x5f, 0xd8, 0x52,
+  0x10, 0x07, 0x38, 0x20, 0xe1, 0xb0, 0xa5, 0x28, 0x0e, 0x70, 0x40, 0xc2,
+  0x61, 0x4b, 0xa1, 0x1c, 0xe2, 0x80, 0x8c, 0xc3, 0x96, 0xe2, 0x39, 0xc4,
+  0x01, 0x19, 0x87, 0x2d, 0x45, 0x75, 0x88, 0x03, 0x32, 0x0e, 0x5b, 0x8a,
+  0xed, 0x10, 0x07, 0x64, 0x1c, 0xb6, 0x14, 0x62, 0x70, 0x80, 0x03, 0x12,
+  0x0e, 0x5b, 0x8a, 0x31, 0x38, 0xc0, 0x01, 0x09, 0x87, 0x2d, 0x45, 0x1a,
+  0x1c, 0xe2, 0x80, 0x8c, 0xc3, 0x96, 0xc2, 0x0d, 0x0e, 0x71, 0x40, 0xc6,
+  0x61, 0x4b, 0x41, 0x07, 0x87, 0x38, 0x20, 0xe3, 0xb0, 0xa5, 0xd0, 0x83,
+  0x43, 0x1c, 0x90, 0x71, 0xd8, 0x32, 0x88, 0x42, 0x40, 0x0e, 0x5b, 0x86,
+  0x53, 0x08, 0xca, 0x61, 0xcb, 0xa0, 0x0b, 0x81, 0x39, 0x6c, 0x19, 0x7e,
+  0x21, 0x38, 0x87, 0x2d, 0x43, 0x38, 0x04, 0xe8, 0xb0, 0x65, 0x50, 0x87,
+  0x60, 0x16, 0xb6, 0x0c, 0xef, 0x10, 0xa4, 0xc3, 0x96, 0xc1, 0x1e, 0x02,
+  0x75, 0xd8, 0x32, 0xe0, 0x43, 0x90, 0x0e, 0x5b, 0x06, 0xb6, 0x08, 0xd4,
+  0x61, 0xcb, 0xe0, 0x16, 0x41, 0x3a, 0x6c, 0x19, 0xd4, 0x23, 0x50, 0x87,
+  0x2d, 0x03, 0x7b, 0x04, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0xd4, 0xce, 0x41,
+  0x2c, 0xcc, 0xd3, 0x06, 0x94, 0x8e, 0x00, 0x8c, 0x35, 0x00, 0x81, 0x40,
+  0xdf, 0x0c, 0x00, 0x05, 0x33, 0x00, 0x54, 0xcc, 0x00, 0x8c, 0x35, 0xb0,
+  0xec, 0x19, 0xca, 0x1f, 0xea, 0x97, 0xb1, 0xfa, 0xe5, 0xa7, 0x2e, 0xce,
+  0xde, 0x58, 0x83, 0x5e, 0x83, 0x3b, 0xee, 0xa9, 0x78, 0x6e, 0xdb, 0xdf,
+  0xdb, 0xa7, 0xf4, 0xe8, 0x8d, 0x35, 0xac, 0x73, 0xcc, 0xa2, 0x5e, 0x1a,
+  0xc2, 0xe8, 0xee, 0xdd, 0x6d, 0xac, 0xda, 0xdf, 0x58, 0x83, 0x98, 0x8b,
+  0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb,
+  0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9,
+  0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea,
+  0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x05,
+  0x33, 0x00, 0x04, 0x8c, 0x00, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60,
+  0x30, 0x46, 0x00, 0x82, 0x20, 0x88, 0x7f, 0x00, 0x00, 0x83, 0x0c, 0xd5,
+  0x02, 0x0d, 0x37, 0x50, 0x42, 0x30, 0xcb, 0x10, 0x08, 0xc1, 0x1c, 0x43,
+  0x43, 0xc5, 0xc1, 0x20, 0x43, 0xe0, 0x48, 0x16, 0x64, 0xf2, 0x19, 0x64,
+  0x08, 0xa0, 0x6a, 0x96, 0x20, 0x19, 0x6e, 0xc8, 0x90, 0x60, 0x96, 0x61,
+  0x48, 0x82, 0xe1, 0x86, 0x2d, 0x09, 0x66, 0x19, 0x88, 0x22, 0x18, 0x31,
+  0x28, 0x8c, 0xc0, 0x0f, 0x3a, 0x69, 0x8e, 0xa1, 0x0a, 0xf0, 0x60, 0xc4,
+  0xa0, 0x30, 0x02, 0x50, 0xf8, 0xa6, 0x39, 0x06, 0x21, 0xc8, 0x83, 0x11,
+  0x83, 0xc2, 0x08, 0x44, 0x21, 0x0c, 0xa8, 0x39, 0x06, 0x21, 0xc0, 0x83,
+  0x59, 0x82, 0x62, 0xa0, 0x22, 0x10, 0x08, 0x6e, 0x18, 0x43, 0x08, 0xfc,
+  0x60, 0x0c, 0x41, 0xf0, 0x83, 0x31, 0x84, 0x81, 0x0f, 0x46, 0x0c, 0x0a,
+  0x23, 0x30, 0x05, 0x21, 0x18, 0x31, 0x28, 0x8c, 0xe0, 0x14, 0x88, 0x60,
+  0xb8, 0x21, 0xb8, 0x84, 0x59, 0x06, 0xe3, 0x08, 0x06, 0x19, 0x8e, 0x6c,
+  0x0c, 0x6c, 0x40, 0x03, 0xf9, 0x58, 0x80, 0xc1, 0xc7, 0x8a, 0x34, 0x90,
+  0x8f, 0x05, 0x1a, 0x7c, 0x6c, 0x08, 0xe8, 0x33, 0xc7, 0x60, 0x06, 0x81,
+  0x2a, 0x0c, 0x32, 0x04, 0x67, 0xb0, 0x06, 0x16, 0x20, 0xf2, 0x19, 0x64,
+  0x08, 0xd2, 0xc0, 0x0d, 0x66, 0x09, 0x8e, 0x81, 0x8a, 0x40, 0x30, 0xc4,
+  0xa0, 0x98, 0x65, 0x40, 0x92, 0x6c, 0x90, 0x21, 0x20, 0x03, 0x37, 0x18,
+  0x31, 0x28, 0x8c, 0xe0, 0x16, 0x02, 0x34, 0x98, 0x63, 0x70, 0x83, 0x20,
+  0x16, 0x46, 0x0c, 0x0a, 0x23, 0xc8, 0x85, 0x21, 0x0d, 0xe6, 0x18, 0x84,
+  0x40, 0x16, 0x46, 0x0c, 0x0a, 0x23, 0xd8, 0x85, 0x42, 0x0d, 0xe6, 0x18,
+  0x84, 0x20, 0x16, 0x66, 0x09, 0x92, 0x81, 0x92, 0x80, 0x14, 0x02, 0x57,
+  0x10, 0x04, 0x04, 0x3a, 0x06, 0x19, 0x02, 0x36, 0xb0, 0x83, 0x0c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00
+};
+const unsigned int sdl_metallib_len = 31301;
diff --git a/SDL-3.2.8/src/render/metal/SDL_shaders_metal_tvsimulator.h b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_tvsimulator.h
new file mode 100644
index 0000000..f152da3
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/SDL_shaders_metal_tvsimulator.h
@@ -0,0 +1,3155 @@
+const unsigned char sdl_metallib[] = {
+  0x4d, 0x54, 0x4c, 0x42, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xbd, 0x93, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x03, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x87, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x04, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x8f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f,
+  0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00, 0x54,
+  0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00,
+  0x15, 0xf9, 0x4d, 0x6f, 0xe5, 0x9c, 0xb5, 0x9e, 0xfb, 0x24, 0xc0, 0x2a,
+  0x04, 0x12, 0xb6, 0x3d, 0xce, 0x01, 0xe2, 0xef, 0x83, 0xef, 0x5c, 0xac,
+  0x5a, 0xb2, 0xc9, 0xf0, 0xc8, 0xba, 0xc9, 0x2b, 0x4d, 0x44, 0x53, 0x5a,
+  0x08, 0x00, 0xa0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46,
+  0x46, 0x54, 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, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00,
+  0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x85, 0x00,
+  0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x10, 0x00, 0x53, 0x44, 0x4c, 0x5f,
+  0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x00, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x52, 0xb6, 0xb7, 0xe5, 0x86, 0x26, 0xb7, 0x1a, 0x21, 0xaf, 0xe3,
+  0x79, 0x7a, 0x10, 0xe2, 0x0b, 0xc0, 0x31, 0xb4, 0x53, 0x24, 0xfd, 0x59,
+  0xdf, 0x13, 0x54, 0xe6, 0x9f, 0x33, 0x99, 0x7a, 0x96, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0xb0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x0e, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
+  0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x88,
+  0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x13, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
+  0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48,
+  0x41, 0x53, 0x48, 0x20, 0x00, 0x52, 0x06, 0xe9, 0x1b, 0x32, 0x0a, 0xb5,
+  0xca, 0xb9, 0x78, 0x6c, 0x25, 0x2c, 0xfe, 0x03, 0x5b, 0x15, 0xc9, 0x22,
+  0xfe, 0xf9, 0x65, 0x38, 0x46, 0x53, 0x98, 0xa9, 0x8a, 0xea, 0xbd, 0x05,
+  0x56, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x10, 0x0e, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00, 0x66, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x50, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52,
+  0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45,
+  0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00, 0x4e, 0x41, 0x4d, 0x45, 0x12,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72,
+  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50, 0x45, 0x01,
+  0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0x35, 0x0e, 0x3c, 0xe0,
+  0xce, 0x53, 0x67, 0x6e, 0xfb, 0xaf, 0x12, 0x13, 0x2f, 0x9a, 0x35, 0x08,
+  0x2a, 0x4e, 0xd6, 0xe8, 0xa9, 0xff, 0xce, 0xe6, 0x90, 0x33, 0xa6, 0x4b,
+  0xb3, 0xc1, 0x2d, 0x79, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00, 0x50, 0x1f,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54, 0x18, 0x00,
+  0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x60, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0x00,
+  0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x86, 0x00, 0x00, 0x00, 0x4e, 0x41,
+  0x4d, 0x45, 0x11, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f,
+  0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x54, 0x59, 0x50,
+  0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20, 0x00, 0xa7, 0x01,
+  0x7b, 0x12, 0xea, 0xf0, 0xa5, 0x6a, 0x6b, 0x4f, 0xc0, 0x6d, 0xb6, 0xea,
+  0x5f, 0xd2, 0x67, 0xf6, 0x0d, 0xb4, 0x84, 0x9a, 0x83, 0xef, 0xdf, 0x35,
+  0x42, 0x30, 0xb3, 0x5b, 0x2f, 0x4a, 0x4d, 0x44, 0x53, 0x5a, 0x08, 0x00,
+  0x10, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x46, 0x46, 0x54,
+  0x18, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x4a, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02, 0x00, 0x02, 0x00,
+  0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x87, 0x00, 0x00, 0x00,
+  0x4e, 0x41, 0x4d, 0x45, 0x12, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56,
+  0x31, 0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x00,
+  0x54, 0x59, 0x50, 0x45, 0x01, 0x00, 0x01, 0x48, 0x41, 0x53, 0x48, 0x20,
+  0x00, 0x01, 0x40, 0xa0, 0xf0, 0xd1, 0x67, 0x2d, 0x43, 0x1e, 0xf0, 0x7f,
+  0xf2, 0x38, 0xda, 0xd8, 0x27, 0x85, 0xad, 0x09, 0xbf, 0x29, 0x25, 0x29,
+  0x69, 0xde, 0x09, 0xb7, 0x80, 0xe9, 0x50, 0xc7, 0x35, 0x4d, 0x44, 0x53,
+  0x5a, 0x08, 0x00, 0xc0, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+  0x46, 0x46, 0x54, 0x18, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x6c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x45, 0x52, 0x53, 0x08, 0x00, 0x02,
+  0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x45,
+  0x4e, 0x44, 0x54, 0x29, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x15,
+  0x00, 0x02, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x00, 0x80, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x56, 0x41,
+  0x54, 0x59, 0x04, 0x00, 0x02, 0x00, 0x04, 0x06, 0x45, 0x4e, 0x44, 0x54,
+  0x35, 0x00, 0x00, 0x00, 0x56, 0x41, 0x54, 0x54, 0x20, 0x00, 0x03, 0x00,
+  0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x80, 0x63,
+  0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x01, 0x80, 0x74, 0x65, 0x78, 0x63, 0x6f,
+  0x6f, 0x72, 0x64, 0x00, 0x02, 0x80, 0x56, 0x41, 0x54, 0x59, 0x05, 0x00,
+  0x03, 0x00, 0x04, 0x06, 0x04, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44,
+  0x54, 0x04, 0x00, 0x00, 0x00, 0x45, 0x4e, 0x44, 0x54, 0x04, 0x00, 0x00,
+  0x00, 0x45, 0x4e, 0x44, 0x54, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x8c, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00,
+  0x00, 0x21, 0x0c, 0x00, 0x00, 0x66, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x78,
+  0xc2, 0x00, 0x2c, 0x40, 0x15, 0xa4, 0x01, 0x28, 0x0c, 0xe1, 0x90, 0x0e,
+  0xf2, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe6, 0x60, 0x0e, 0xe5, 0x20, 0x0f,
+  0x6d, 0xe0, 0x0e, 0xef, 0xd0, 0x06, 0xe1, 0xc0, 0x0e, 0xe9, 0x10, 0x0e,
+  0xf3, 0x00, 0x6c, 0xf0, 0x06, 0x02, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50,
+  0x18, 0xc2, 0x21, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1,
+  0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0, 0x1d, 0xde, 0xa1, 0x0d, 0xc2, 0x81,
+  0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x60, 0x87, 0x10, 0xc0,
+  0x30, 0x82, 0x00, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x52, 0x88,
+  0x11, 0x8c, 0xa1, 0x33, 0x10, 0x30, 0x47, 0x00, 0x06, 0x29, 0xa0, 0xe6,
+  0x08, 0x40, 0x61, 0x10, 0x21, 0x10, 0x86, 0x11, 0x08, 0x65, 0x04, 0x00,
+  0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda,
+  0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec,
+  0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0,
+  0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8,
+  0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b,
+  0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a,
+  0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e,
+  0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d,
+  0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c,
+  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d,
+  0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c,
+  0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d,
+  0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e,
+  0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c,
+  0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d,
+  0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d,
+  0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d,
+  0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d,
+  0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c,
+  0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x42, 0x6c, 0x57, 0xfe,
+  0xac, 0xb3, 0x20, 0xc3, 0x5f, 0x11, 0xd1, 0x44, 0x5c, 0x43, 0x22, 0x00,
+  0x3a, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x40,
+  0x62, 0x83, 0x40, 0x51, 0xb4, 0x01, 0x00, 0x80, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02,
+  0x85, 0x30, 0x02, 0x50, 0x80, 0x01, 0x05, 0x52, 0x06, 0xc4, 0x46, 0x00,
+  0x68, 0x8d, 0x25, 0x48, 0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x79, 0x20, 0x00, 0x00, 0xd1, 0x00, 0x00,
+  0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8,
+  0x11, 0x32, 0x64, 0xd4, 0x3c, 0xec, 0x7c, 0x00, 0x00, 0x8b, 0x12, 0x07,
+  0xc5, 0xc6, 0x91, 0x01, 0x13, 0x19, 0x0c, 0x12, 0x59, 0x85, 0x53, 0x24,
+  0x90, 0xe4, 0x19, 0xca, 0x83, 0x44, 0x17, 0xa2, 0x24, 0x53, 0x44, 0x4b,
+  0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61,
+  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20,
+  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x20, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20,
+  0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30,
+  0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72,
+  0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
+  0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78,
+  0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x69, 0x7a, 0x65,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x69,
+  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78,
+  0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f,
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78,
+  0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f,
+  0x61, 0x69, 0x72, 0x5f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c,
+  0x64, 0x65, 0x72, 0x5f, 0x5f, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72,
+  0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72, 0x6f,
+  0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x73,
+  0x66, 0x6f, 0x72, 0x6d, 0x00, 0xc4, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08,
+  0x23, 0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82,
+  0xa0, 0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5f,
+  0x00, 0x06, 0x33, 0x0c, 0x61, 0x20, 0x88, 0xc1, 0x0c, 0xc1, 0x30, 0xc3,
+  0xf0, 0x7d, 0x63, 0x30, 0x03, 0x41, 0x84, 0x41, 0x18, 0x8c, 0xc1, 0x0c,
+  0x41, 0x31, 0x43, 0x60, 0xcc, 0x10, 0x1c, 0x33, 0x14, 0x48, 0xa2, 0x2c,
+  0xcc, 0x0c, 0x46, 0xe3, 0x24, 0xca, 0xf2, 0xcc, 0x50, 0x40, 0x49, 0xb4,
+  0x48, 0x33, 0x0c, 0x70, 0x10, 0x07, 0x72, 0x30, 0x83, 0x32, 0x06, 0x13,
+  0x35, 0x06, 0x61, 0x50, 0x25, 0xd6, 0xc2, 0xcc, 0xa0, 0x84, 0xc1, 0x44,
+  0x85, 0x41, 0x18, 0x54, 0x89, 0xb2, 0x3c, 0x33, 0x40, 0xdf, 0x85, 0x95,
+  0x01, 0xf5, 0x85, 0x41, 0xa6, 0x95, 0xc1, 0x66, 0x06, 0x09, 0xb7, 0x74,
+  0x33, 0x40, 0x67, 0x70, 0x61, 0x65, 0x40, 0x9d, 0x41, 0x18, 0x64, 0x5a,
+  0x19, 0x6c, 0x66, 0x90, 0x70, 0x8b, 0x37, 0x03, 0x41, 0x07, 0x75, 0x60,
+  0x07, 0x77, 0x30, 0xc3, 0x40, 0x06, 0x73, 0x80, 0x07, 0xb5, 0x01, 0x1c,
+  0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0x1a, 0xb8, 0x81, 0x85, 0x06, 0x7a,
+  0x60, 0x59, 0x96, 0x1b, 0xd0, 0x81, 0x1b, 0xd0, 0x81, 0x2f, 0xf8, 0x02,
+  0x4a, 0xd0, 0x04, 0x28, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62, 0x63, 0xb3,
+  0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31, 0x63, 0x0b,
+  0x3b, 0x9b, 0x1b, 0x45, 0x38, 0x03, 0x34, 0x38, 0x85, 0x8d, 0xcd, 0xae,
+  0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x20, 0x0d, 0x6e, 0x09,
+  0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25,
+  0x50, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc, 0xce, 0xea,
+  0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde, 0xdc, 0x46,
+  0x09, 0xd6, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7, 0x36, 0xb8,
+  0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7, 0xb9, 0x51,
+  0x06, 0x36, 0x68, 0x03, 0x37, 0x38, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae,
+  0x4c, 0x8e, 0xae, 0x0c, 0x6f, 0x94, 0x00, 0x0f, 0x00, 0xa9, 0x18, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80,
+  0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43,
+  0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4,
+  0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81,
+  0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01,
+  0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c,
+  0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c,
+  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1,
+  0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c,
+  0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90,
+  0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x8c, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+  0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc, 0x08, 0xc0, 0x58, 0x44,
+  0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2, 0x58, 0xc4, 0x30, 0x0c,
+  0x03, 0x81, 0x31, 0x02, 0x10, 0x04, 0x41, 0xfc, 0xa3, 0x30, 0x03, 0x30,
+  0x03, 0x40, 0x62, 0x06, 0x80, 0xc6, 0x0c, 0x00, 0x00, 0xf1, 0x30, 0x00,
+  0x00, 0x2c, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0x08,
+  0x3d, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x23, 0x06, 0x96, 0x05, 0x00, 0x00,
+  0x00, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20,
+  0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43,
+  0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41, 0x61, 0x69, 0x72, 0x2d, 0x61,
+  0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x28,
+  0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76, 0x65,
+  0x72, 0x74, 0x65, 0x78, 0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69,
+  0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67,
+  0x28, 0x33, 0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x32,
+  0x29, 0x13, 0x04, 0x06, 0x59, 0x21, 0x80, 0x02, 0x1f, 0xac, 0x18, 0x42,
+  0x01, 0x14, 0xfa, 0x60, 0xc5, 0x20, 0x0a, 0xa0, 0xe0, 0x07, 0x1b, 0x82,
+  0x3d, 0xd8, 0x30, 0xe8, 0xc1, 0x28, 0xfc, 0xc1, 0x86, 0x81, 0x14, 0x48,
+  0xe1, 0x0f, 0x36, 0x04, 0xa1, 0xb0, 0x21, 0x10, 0x05, 0x00, 0x00, 0x00,
+  0x00, 0xbb, 0x10, 0x8d, 0x64, 0x49, 0x14, 0x84, 0xb2, 0x0b, 0x01, 0x51,
+  0x18, 0x45, 0x41, 0x28, 0x83, 0x0c, 0xc3, 0xd1, 0x98, 0x10, 0x88, 0xff,
+  0x2e, 0x04, 0x85, 0x71, 0x12, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0x0c, 0x64,
+  0x42, 0x20, 0xfe, 0x16, 0x14, 0xe0, 0xbf, 0x0b, 0x91, 0x75, 0x61, 0x50,
+  0x51, 0x10, 0xca, 0x20, 0x03, 0x13, 0x51, 0x26, 0x04, 0xe2, 0x6f, 0x45,
+  0x00, 0xfe, 0xbb, 0x10, 0x9e, 0x18, 0x98, 0xc1, 0x46, 0x41, 0x28, 0x83,
+  0x0c, 0x91, 0x85, 0x99, 0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42,
+  0x88, 0xc1, 0x19, 0xac, 0x41, 0x18, 0x50, 0x10, 0xca, 0x20, 0x43, 0xa0,
+  0x81, 0x81, 0x05, 0x95, 0xf8, 0x0f, 0x32, 0x0c, 0x5d, 0x18, 0x58, 0x30,
+  0x89, 0xbf, 0x0d, 0x01, 0xf8, 0x0f, 0x32, 0x18, 0x60, 0x30, 0x06, 0x16,
+  0x44, 0xe2, 0x6f, 0x43, 0x00, 0xfe, 0x83, 0x0c, 0xc9, 0x18, 0x94, 0x81,
+  0x05, 0x8f, 0xf8, 0xdb, 0x10, 0x80, 0xff, 0x2e, 0xc4, 0x1b, 0xd0, 0x01,
+  0x1e, 0xb4, 0x01, 0x05, 0xa1, 0x0c, 0x32, 0x04, 0x67, 0xd0, 0x06, 0x16,
+  0x88, 0x81, 0xf8, 0x0f, 0x32, 0x0c, 0x6a, 0xe0, 0x06, 0x16, 0x80, 0x81,
+  0xf8, 0x0f, 0x32, 0x14, 0x6c, 0xf0, 0x06, 0x16, 0x74, 0xe2, 0x3f, 0xc8,
+  0x70, 0xb8, 0x01, 0x1c, 0x58, 0xa0, 0x89, 0xff, 0x20, 0x03, 0x1f, 0xb4,
+  0x41, 0x1d, 0x58, 0x16, 0x88, 0xff, 0x20, 0x83, 0x1f, 0xbc, 0x81, 0x1d,
+  0x98, 0x13, 0x88, 0xbf, 0x25, 0x03, 0xf8, 0x5b, 0xc0, 0x80, 0xbf, 0x05,
+  0x09, 0xf8, 0x5b, 0x80, 0x80, 0xbf, 0x05, 0x05, 0xf8, 0xcf, 0x36, 0xdc,
+  0x41, 0x00, 0xcc, 0x36, 0x04, 0xa5, 0x10, 0xcc, 0x36, 0x04, 0x7c, 0x20,
+  0x64, 0x10, 0x10, 0x03, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20,
+  0x20, 0x85, 0xa3, 0x14, 0x10, 0x53, 0xd8, 0x72, 0x0c, 0x01, 0x29, 0x1c,
+  0xa6, 0x80, 0x94, 0xc2, 0x96, 0xe3, 0x08, 0x48, 0xe1, 0x30, 0x05, 0xa4,
+  0x14, 0xb6, 0x1c, 0x4c, 0x40, 0x0a, 0x87, 0x29, 0x20, 0xa5, 0xb0, 0xe5,
+  0x88, 0x02, 0x52, 0x38, 0x4c, 0x01, 0x29, 0x85, 0x2d, 0x87, 0x15, 0x90,
+  0xc2, 0x51, 0x0a, 0x88, 0x29, 0x6c, 0x39, 0xc6, 0x20, 0x20, 0x85, 0xa3,
+  0x14, 0x10, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xda,
+  0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00,
+  0x00, 0x1f, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xf0, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x79, 0x00, 0x00, 0x00,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x76,
+  0x65, 0x72, 0x74, 0x65, 0x78, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c,
+  0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30,
+  0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x90, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00,
+  0x00, 0x21, 0x0c, 0x00, 0x00, 0x68, 0x03, 0x00, 0x00, 0x0b, 0x02, 0x21,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x14, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xa4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x52, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x91, 0x22, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x29, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x1b, 0x7e, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x80, 0x8a, 0x08, 0x07, 0x78,
+  0x80, 0x07, 0x79, 0x78, 0x07, 0x7c, 0x68, 0x03, 0x73, 0xa8, 0x07, 0x77,
+  0x18, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a,
+  0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xda, 0x21,
+  0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xce, 0x21, 0x1c, 0xd8, 0xa1,
+  0x0d, 0xec, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0xe0,
+  0x1e, 0xd2, 0x81, 0x1c, 0xe8, 0x01, 0x1d, 0x80, 0x38, 0x90, 0x03, 0x3c,
+  0x00, 0x06, 0x77, 0x78, 0x87, 0x36, 0x10, 0x87, 0x7a, 0x48, 0x07, 0x76,
+  0xa0, 0x87, 0x74, 0x70, 0x87, 0x79, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xcc, 0x41, 0x1e, 0xc2, 0xa1, 0x1d, 0xca, 0xa1,
+  0x0d, 0xe0, 0xe1, 0x1d, 0xd2, 0xc1, 0x1d, 0xe8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x0d, 0xca, 0x81, 0x1d, 0xd2, 0xa1, 0x1d, 0xda, 0xc0, 0x1d, 0xde, 0xc1,
+  0x1d, 0xda, 0x80, 0x1d, 0xca, 0x21, 0x1c, 0xcc, 0x01, 0xa0, 0x07, 0x79,
+  0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x48, 0x07, 0x77,
+  0x30, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2,
+  0x1d, 0xde, 0xa1, 0x0d, 0xdc, 0x21, 0x1c, 0xdc, 0x61, 0x1e, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83, 0x79,
+  0x48, 0x87, 0x73, 0x70, 0x87, 0x72, 0x20, 0x87, 0x36, 0xd0, 0x87, 0x72,
+  0x90, 0x87, 0x77, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x80, 0x1e, 0xe4, 0x21, 0x1c, 0xe0, 0x01,
+  0x1e, 0xd2, 0xc1, 0x1d, 0xce, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x98, 0x07, 0x7a,
+  0x08, 0x87, 0x71, 0x58, 0x87, 0x36, 0x80, 0x07, 0x79, 0x78, 0x07, 0x7a,
+  0x28, 0x87, 0x71, 0xa0, 0x87, 0x77, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x83, 0x79, 0x48, 0x07, 0x7d,
+  0x28, 0x07, 0x00, 0x0f, 0x00, 0xa2, 0x1e, 0xdc, 0x61, 0x1e, 0xc2, 0xc1,
+  0x1c, 0xca, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81,
+  0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x36, 0x78,
+  0x02, 0x01, 0x2c, 0x40, 0x15, 0xa4, 0x01, 0x28, 0x0c, 0xe1, 0x90, 0x0e,
+  0xf2, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe6, 0x60, 0x0e, 0xe5, 0x20, 0x0f,
+  0x6d, 0xe0, 0x0e, 0xef, 0xd0, 0x06, 0xe1, 0xc0, 0x0e, 0xe9, 0x10, 0x0e,
+  0xf3, 0x00, 0x6c, 0xf0, 0x86, 0x02, 0x58, 0x80, 0x2a, 0x48, 0x03, 0x50,
+  0x18, 0xc2, 0x21, 0x1d, 0xe4, 0xa1, 0x0d, 0xc4, 0xa1, 0x1e, 0xcc, 0xc1,
+  0x1c, 0xca, 0x41, 0x1e, 0xda, 0xc0, 0x1d, 0xde, 0xa1, 0x0d, 0xc2, 0x81,
+  0x1d, 0xd2, 0x21, 0x1c, 0xe6, 0x01, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x86, 0x40, 0x18, 0x00, 0x00, 0x00,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x32, 0x22, 0x48,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x93, 0x22, 0xa4, 0x84, 0x04, 0x93, 0x22,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8a, 0x8c, 0x0b, 0x84, 0xa4,
+  0x4c, 0x10, 0x40, 0x33, 0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00,
+  0x76, 0x08, 0x41, 0x24, 0x41, 0x98, 0xc9, 0x9a, 0x07, 0x7a, 0x90, 0x87,
+  0x7a, 0x18, 0x07, 0x7a, 0x70, 0x83, 0x76, 0x28, 0x07, 0x7a, 0x08, 0x07,
+  0x76, 0xd0, 0x03, 0x3d, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x79, 0x48, 0x07,
+  0x7c, 0x70, 0x03, 0x38, 0x40, 0x01, 0x19, 0x44, 0x28, 0x84, 0x62, 0x0c,
+  0x11, 0x84, 0x31, 0x74, 0x06, 0x02, 0xe6, 0x08, 0xc0, 0x20, 0x05, 0xd4,
+  0x1c, 0x01, 0x28, 0x0c, 0x22, 0x04, 0xc2, 0x30, 0x02, 0xa1, 0x8c, 0x00,
+  0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda,
+  0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec,
+  0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0,
+  0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8,
+  0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b,
+  0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a,
+  0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e,
+  0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d,
+  0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c,
+  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d,
+  0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c,
+  0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d,
+  0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e,
+  0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c,
+  0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d,
+  0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d,
+  0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d,
+  0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d,
+  0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c,
+  0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x3e, 0x6c, 0x57, 0xfe,
+  0x9c, 0xf3, 0x60, 0x7f, 0x45, 0x44, 0x13, 0x71, 0x0d, 0x89, 0x80, 0xe7,
+  0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x89,
+  0x0d, 0x02, 0x45, 0xd5, 0x06, 0x00, 0x00, 0xb2, 0x40, 0x0a, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x10, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x52, 0x45, 0x50, 0x02, 0x85, 0x30, 0x02, 0x50,
+  0x06, 0x05, 0x18, 0x50, 0x20, 0xc4, 0x46, 0x00, 0x68, 0x8d, 0x25, 0x48,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0x3a, 0x8c, 0x7d, 0x00, 0x00, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x01,
+  0x13, 0x19, 0x0c, 0x12, 0x59, 0x45, 0x66, 0x20, 0x90, 0xe4, 0x29, 0x0f,
+  0x12, 0x5d, 0x88, 0x92, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74,
+  0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61,
+  0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69,
+  0x72, 0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x6f, 0x75, 0x74,
+  0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64,
+  0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66,
+  0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61,
+  0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72,
+  0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69, 0x72,
+  0x2e, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x5f, 0x5f, 0x61, 0x69, 0x72, 0x5f, 0x70,
+  0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x5f, 0x5f,
+  0x29, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61,
+  0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x78, 0x34, 0x70, 0x72,
+  0x6f, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x6e,
+  0x73, 0x66, 0x6f, 0x72, 0x6d, 0x04, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0xa0, 0x04, 0x23, 0x08, 0x4b, 0x32, 0x82, 0xa0, 0x08,
+  0x23, 0x08, 0xca, 0x30, 0x82, 0xa0, 0x10, 0x23, 0x08, 0x08, 0x30, 0x82,
+  0xa0, 0x14, 0x23, 0x08, 0x8a, 0x31, 0x82, 0xa0, 0x1c, 0x33, 0x0c, 0x5e,
+  0xf0, 0xcd, 0x30, 0x80, 0x81, 0x10, 0x06, 0x33, 0x04, 0xc3, 0x0c, 0x83,
+  0xe7, 0x89, 0xc1, 0x0c, 0x04, 0x01, 0x06, 0x60, 0x20, 0x06, 0x33, 0x04,
+  0xc5, 0x0c, 0x81, 0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x89, 0xb2, 0x30,
+  0x33, 0x18, 0x8d, 0x93, 0x28, 0xcb, 0x33, 0x83, 0xd1, 0x40, 0x49, 0xb4,
+  0x48, 0x33, 0x0c, 0x6f, 0x00, 0x07, 0x71, 0x30, 0x83, 0x22, 0x06, 0x13,
+  0x25, 0x06, 0x60, 0x50, 0x25, 0xd1, 0xc2, 0xcc, 0xa0, 0x80, 0xc1, 0x44,
+  0x81, 0x01, 0x18, 0x54, 0x89, 0xb2, 0x3c, 0x33, 0x28, 0xde, 0x44, 0x79,
+  0x60, 0x50, 0x25, 0xd1, 0x22, 0xcd, 0x00, 0x91, 0x81, 0x75, 0x95, 0x01,
+  0xe5, 0x81, 0x01, 0x96, 0x95, 0x81, 0x66, 0x06, 0xc9, 0xb6, 0x70, 0x33,
+  0x40, 0x61, 0x60, 0x5d, 0x65, 0x40, 0x91, 0x01, 0x18, 0x60, 0x59, 0x19,
+  0x68, 0x66, 0x90, 0x6c, 0x4b, 0x37, 0x43, 0x31, 0x07, 0x74, 0x50, 0x07,
+  0x76, 0x70, 0x07, 0x33, 0x0c, 0x63, 0x20, 0x07, 0x78, 0x50, 0x1c, 0xc0,
+  0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x89, 0x81, 0x1b, 0x58, 0x68, 0xa0,
+  0x07, 0x96, 0x65, 0xb9, 0x01, 0x1d, 0xd0, 0x01, 0x1d, 0xf8, 0x82, 0x2f,
+  0xc8, 0x82, 0x4b, 0xd0, 0x04, 0x2b, 0xc8, 0x48, 0x60, 0x82, 0x2e, 0x62,
+  0x63, 0xb3, 0x6b, 0x73, 0x69, 0x7b, 0x23, 0xab, 0x63, 0x2b, 0x73, 0x31,
+  0x63, 0x0b, 0x3b, 0x9b, 0x1b, 0x45, 0x30, 0x83, 0x33, 0x38, 0x85, 0x8d,
+  0xcd, 0xae, 0xcd, 0x25, 0x8d, 0xac, 0xcc, 0x8d, 0x6e, 0x94, 0x00, 0x0d,
+  0x6e, 0x09, 0x4b, 0x93, 0x73, 0xb1, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
+  0x1b, 0x25, 0x48, 0x83, 0xa3, 0xc2, 0xd2, 0xe4, 0x5c, 0xd8, 0xc2, 0xdc,
+  0xce, 0xea, 0xc2, 0xce, 0xca, 0xbe, 0xec, 0xca, 0xe4, 0xe6, 0xd2, 0xde,
+  0xdc, 0x46, 0x09, 0xd4, 0xe0, 0xa6, 0xb0, 0x34, 0x39, 0x97, 0xb1, 0xb7,
+  0x36, 0xb8, 0x34, 0xb6, 0xb2, 0xaf, 0x37, 0x38, 0xba, 0xb4, 0x37, 0xb7,
+  0xb9, 0x51, 0x86, 0x35, 0x60, 0x83, 0x36, 0x38, 0x25, 0x2c, 0x4d, 0xce,
+  0xc5, 0xae, 0x4c, 0x8e, 0xae, 0x0c, 0x6f, 0x94, 0x00, 0x0f, 0x00, 0x00,
+  0x00, 0xa9, 0x18, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72,
+  0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8,
+  0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1,
+  0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f,
+  0xe1, 0x20, 0x0f, 0xe4, 0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e,
+  0xf4, 0xb0, 0x80, 0x81, 0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76,
+  0x78, 0x87, 0x71, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c,
+  0xc3, 0x38, 0xb4, 0x01, 0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b,
+  0x1c, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61,
+  0x1c, 0xdc, 0x20, 0x1c, 0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1,
+  0x1c, 0xc8, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f,
+  0xf4, 0x20, 0x0f, 0xe1, 0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00,
+  0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c,
+  0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x8a, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x09, 0x00, 0x00, 0x00, 0xc4, 0x4a, 0xa0, 0x0c, 0x8a, 0x80, 0xdc,
+  0x08, 0xc0, 0x58, 0x44, 0x10, 0x04, 0xc1, 0x58, 0x84, 0x20, 0x08, 0xc2,
+  0x58, 0xc4, 0x30, 0x0c, 0x03, 0x85, 0x19, 0x80, 0x19, 0x00, 0x12, 0x33,
+  0x00, 0x34, 0x66, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x2c, 0x00, 0x00,
+  0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0xc8, 0x3c, 0x00, 0x00, 0x00,
+  0x00, 0xcf, 0x13, 0x06, 0x96, 0x05, 0x00, 0x00, 0x00, 0x6f, 0x6d, 0x6e,
+  0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72,
+  0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54,
+  0x42, 0x41, 0x41, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f,
+  0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78, 0x29,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x34, 0x29, 0x61, 0x69,
+  0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70,
+  0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x00, 0x13, 0x04, 0x06,
+  0x59, 0x21, 0x80, 0x02, 0x1f, 0xac, 0x18, 0x42, 0x01, 0x14, 0xfa, 0x60,
+  0xc5, 0x20, 0x0a, 0xa0, 0xe0, 0x07, 0x1b, 0x82, 0x3d, 0xd8, 0x30, 0xe8,
+  0xc1, 0x28, 0xfc, 0xc1, 0x86, 0x81, 0x14, 0x48, 0xe1, 0x0f, 0x36, 0x04,
+  0xa1, 0xb0, 0x21, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0xbb, 0x10, 0x8c,
+  0x64, 0x49, 0x14, 0x84, 0xb2, 0x0b, 0xf1, 0x50, 0x18, 0x45, 0x41, 0x28,
+  0x83, 0x0c, 0xc3, 0xc1, 0x98, 0x10, 0x88, 0xff, 0x2e, 0xc4, 0x84, 0x71,
+  0x11, 0x05, 0xa1, 0x0c, 0x32, 0x1c, 0xcc, 0x63, 0x42, 0x20, 0xfe, 0x16,
+  0x14, 0xe0, 0xbf, 0x0b, 0x81, 0x75, 0x61, 0x40, 0x51, 0x10, 0xca, 0x20,
+  0x03, 0x13, 0x4d, 0x26, 0x04, 0xe2, 0x6f, 0x45, 0x00, 0xfe, 0xbb, 0x10,
+  0x9d, 0x18, 0x98, 0x81, 0x46, 0x41, 0x28, 0x83, 0x0c, 0x91, 0x75, 0x99,
+  0x10, 0x88, 0xbf, 0x15, 0x01, 0xf8, 0xef, 0x42, 0x84, 0xc1, 0x19, 0xac,
+  0x01, 0x18, 0x50, 0x10, 0xca, 0x20, 0x43, 0xa0, 0x7d, 0x16, 0x54, 0xe2,
+  0x3f, 0xc8, 0x30, 0x74, 0x60, 0x60, 0xc1, 0x24, 0xfe, 0x36, 0x04, 0xe0,
+  0x3f, 0xc8, 0x60, 0x80, 0x81, 0x18, 0x58, 0x10, 0x89, 0xbf, 0x0d, 0x01,
+  0xf8, 0x0f, 0x32, 0x24, 0x63, 0x40, 0x06, 0x16, 0x3c, 0xe2, 0x6f, 0x43,
+  0x00, 0xfe, 0xbb, 0x10, 0x6e, 0x40, 0x07, 0x78, 0xc0, 0x06, 0x14, 0x84,
+  0x32, 0xc8, 0x10, 0x9c, 0x01, 0x1b, 0x58, 0x20, 0x06, 0xe2, 0x3f, 0xc8,
+  0x30, 0xa8, 0x41, 0x1b, 0x58, 0x00, 0x06, 0xe2, 0x3f, 0xc8, 0x50, 0xb0,
+  0x81, 0x1b, 0x58, 0xd0, 0x89, 0xff, 0x20, 0xc3, 0xe1, 0x06, 0x6f, 0x60,
+  0x81, 0x26, 0xfe, 0x83, 0x0c, 0x7c, 0xe0, 0x06, 0x74, 0x60, 0x59, 0x20,
+  0xfe, 0x83, 0x0c, 0x7e, 0x00, 0x07, 0x75, 0x60, 0x4e, 0x20, 0xfe, 0x96,
+  0x0c, 0xe0, 0x6f, 0x01, 0x03, 0xfe, 0x16, 0x24, 0xe0, 0x6f, 0x01, 0x02,
+  0xfe, 0x16, 0x14, 0xe0, 0x3f, 0xdb, 0x60, 0x07, 0x01, 0x30, 0xdb, 0x10,
+  0x94, 0x42, 0x30, 0xdb, 0x10, 0x94, 0x82, 0x90, 0x41, 0x40, 0x0c, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20, 0x20, 0x85, 0xa3, 0x14,
+  0x10, 0x53, 0xd8, 0x72, 0x0c, 0x01, 0x29, 0x1c, 0xa6, 0x80, 0x94, 0xc2,
+  0x96, 0xe3, 0x08, 0x48, 0xe1, 0x30, 0x05, 0xa4, 0x14, 0xb6, 0x1c, 0x4c,
+  0x40, 0x0a, 0x87, 0x29, 0x20, 0xa5, 0xb0, 0xe5, 0x88, 0x02, 0x52, 0x38,
+  0x4c, 0x01, 0x29, 0x85, 0x2d, 0x87, 0x15, 0x90, 0xc2, 0x51, 0x0a, 0x88,
+  0x29, 0x6c, 0x39, 0xc6, 0x20, 0x20, 0x85, 0xa3, 0x14, 0x10, 0x53, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xde, 0x05, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00, 0x00, 0x1f, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x0f, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x12, 0x03, 0x94, 0x78, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c,
+  0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x74, 0x65, 0x78,
+  0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x61, 0x69, 0x72,
+  0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f,
+  0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75,
+  0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xf8, 0x0d, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05,
+  0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x41, 0x03, 0x00,
+  0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x10, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0x84, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x42, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e,
+  0x90, 0x11, 0x22, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x21, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x71, 0x00, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0x03,
+  0x40, 0x02, 0x28, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0,
+  0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87,
+  0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07,
+  0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07,
+  0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07,
+  0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87,
+  0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc,
+  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87,
+  0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca,
+  0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda,
+  0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda,
+  0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88,
+  0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0xd8, 0xe0, 0x09, 0x03, 0xb0, 0x00, 0x55, 0x90,
+  0x06, 0x60, 0x30, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d,
+  0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b,
+  0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x84, 0x40, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x18, 0x00, 0x00, 0x00, 0x32, 0x22, 0x08, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x22, 0xa4, 0x84, 0x04, 0x13, 0x22, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x88, 0x8c, 0x0b, 0x84, 0x84, 0x4c, 0x10, 0x3c, 0x33,
+  0x00, 0xc3, 0x08, 0x04, 0x30, 0x8c, 0x20, 0x00, 0x67, 0x49, 0x53, 0x44,
+  0x09, 0x93, 0xcf, 0x1e, 0xc0, 0x40, 0x44, 0x9c, 0xd3, 0x48, 0x13, 0xd0,
+  0x4c, 0x12, 0x42, 0x00, 0x00, 0x00, 0x00, 0x06, 0x11, 0x06, 0xa1, 0x10,
+  0x21, 0x41, 0x54, 0x03, 0x01, 0x73, 0x04, 0x60, 0x90, 0x02, 0x38, 0x47,
+  0x00, 0x0a, 0x83, 0x08, 0x80, 0x30, 0x8c, 0x30, 0x00, 0xc3, 0x08, 0x04,
+  0x32, 0x02, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e,
+  0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c,
+  0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d,
+  0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e,
+  0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43,
+  0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
+  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81,
+  0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01,
+  0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81,
+  0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1,
+  0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01,
+  0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81,
+  0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
+  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41,
+  0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01,
+  0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
+  0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
+  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81,
+  0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01,
+  0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81,
+  0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43,
+  0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81,
+  0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81,
+  0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41,
+  0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81,
+  0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01,
+  0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81,
+  0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81,
+  0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43,
+  0x4a, 0x6c, 0x57, 0xfe, 0xac, 0xb3, 0x20, 0xc3, 0x5f, 0x44, 0x80, 0xc1,
+  0x10, 0xcd, 0x34, 0x24, 0x02, 0xa4, 0x02, 0x00, 0x80, 0x00, 0x00, 0x00,
+  0x40, 0x00, 0x00, 0x00, 0x00, 0x24, 0x36, 0x08, 0x14, 0x1d, 0x1a, 0x00,
+  0x00, 0xc8, 0x02, 0x01, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x14, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0xc2, 0x22, 0x28, 0x81, 0x42, 0x18, 0x01, 0x28, 0xa0, 0x82, 0x28, 0x8c,
+  0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0xd2, 0x11, 0x80, 0x42, 0x28, 0x88,
+  0xc2, 0x28, 0x90, 0x42, 0x29, 0x98, 0xc2, 0xa1, 0x1c, 0x4b, 0x90, 0x04,
+  0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80,
+  0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84,
+  0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c,
+  0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42,
+  0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88,
+  0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c,
+  0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79,
+  0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70,
+  0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f,
+  0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4,
+  0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30,
+  0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc,
+  0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b,
+  0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70,
+  0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76,
+  0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72,
+  0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e,
+  0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1,
+  0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21,
+  0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8,
+  0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94,
+  0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc,
+  0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70,
+  0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74,
+  0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f,
+  0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e,
+  0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41,
+  0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1,
+  0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c,
+  0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37,
+  0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f,
+  0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21,
+  0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0,
+  0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88,
+  0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77,
+  0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c,
+  0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23,
+  0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01,
+  0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84,
+  0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8,
+  0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76,
+  0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e,
+  0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f,
+  0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e,
+  0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e,
+  0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1,
+  0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21,
+  0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8,
+  0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77,
+  0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19,
+  0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e,
+  0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30,
+  0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71,
+  0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77,
+  0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x79, 0x20, 0x00,
+  0x00, 0xf6, 0x00, 0x00, 0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c,
+  0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4, 0xca, 0x00, 0x0c, 0x66,
+  0x09, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x52, 0xa6,
+  0x3c, 0x06, 0x83, 0x58, 0x85, 0xf2, 0x48, 0x08, 0x55, 0x30, 0x8c, 0xb2,
+  0x38, 0xcf, 0xf3, 0x44, 0xd7, 0x13, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4b,
+  0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61,
+  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20,
+  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x20, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20,
+  0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30,
+  0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61,
+  0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f,
+  0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x38, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+  0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x65,
+  0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73,
+  0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74,
+  0x32, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d,
+  0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x67, 0x65, 0x6e,
+  0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f,
+  0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a,
+  0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63,
+  0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66,
+  0x6c, 0x6f, 0x61, 0x74, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f, 0x75,
+  0x74, 0x70, 0x75, 0x74, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63, 0x61, 0x6c,
+  0x65, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74,
+  0x68, 0x6f, 0x64, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66,
+  0x61, 0x63, 0x74, 0x6f, 0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61,
+  0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x73, 0x64, 0x72,
+  0x5f, 0x77, 0x68, 0x69, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67,
+  0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f,
+  0x73, 0x69, 0x7a, 0x65, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f,
+  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x63, 0x00, 0x44, 0x64, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x80, 0x04, 0x23, 0x08, 0x09,
+  0x35, 0x82, 0x80, 0x08, 0x23, 0x08, 0xc8, 0x30, 0x82, 0x80, 0x10, 0x23,
+  0x08, 0x06, 0x30, 0x82, 0x80, 0x14, 0x23, 0x08, 0x88, 0x31, 0x82, 0x80,
+  0x1c, 0x23, 0x08, 0x08, 0x32, 0x82, 0x80, 0x24, 0x23, 0x08, 0x88, 0x32,
+  0x82, 0x80, 0x2c, 0x33, 0x0c, 0x66, 0x10, 0x9c, 0xc1, 0x0c, 0x03, 0x1a,
+  0x08, 0x69, 0x30, 0x43, 0x30, 0xcc, 0x30, 0x98, 0x81, 0x19, 0xa8, 0xc1,
+  0x0c, 0x04, 0x81, 0x06, 0x68, 0xa0, 0x06, 0x33, 0x04, 0xc5, 0x0c, 0x81,
+  0x31, 0x43, 0x70, 0xcc, 0x50, 0x20, 0x6a, 0xa0, 0x06, 0x89, 0x32, 0x43,
+  0xb0, 0x07, 0x33, 0x24, 0x6a, 0xb0, 0x30, 0x8d, 0x93, 0x3c, 0x50, 0x34,
+  0x43, 0x82, 0x06, 0x8b, 0xd4, 0x38, 0x89, 0x02, 0x4d, 0x33, 0xa0, 0x81,
+  0x1a, 0xa4, 0x81, 0x1a, 0x64, 0x5a, 0x1a, 0xa4, 0x81, 0x1a, 0x64, 0x5b,
+  0x1b, 0xa4, 0x81, 0x1a, 0x64, 0x9c, 0x1b, 0xa4, 0x81, 0x1a, 0x64, 0xdd,
+  0x1b, 0xa4, 0x81, 0x1a, 0x64, 0x1e, 0x1c, 0xa4, 0x81, 0x1a, 0x64, 0x5f,
+  0x1c, 0xa4, 0x81, 0x1a, 0x64, 0x60, 0x20, 0x07, 0x69, 0xa0, 0x06, 0x59,
+  0x18, 0xcc, 0x20, 0x99, 0x01, 0x55, 0xb1, 0x81, 0xa5, 0x06, 0x68, 0x70,
+  0x61, 0x7f, 0x20, 0x06, 0x6c, 0x30, 0x06, 0x69, 0x90, 0x90, 0x01, 0x54,
+  0x06, 0x33, 0x0c, 0x7d, 0xe0, 0x07, 0xa0, 0x30, 0xc3, 0xb0, 0x06, 0x7c,
+  0x10, 0x0a, 0xd5, 0x01, 0x1c, 0xc7, 0x71, 0x1c, 0xc7, 0x71, 0x1c, 0xc7,
+  0x71, 0x9c, 0x1b, 0xb8, 0x81, 0x45, 0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e,
+  0x70, 0xac, 0xc0, 0x0a, 0x62, 0xe3, 0x17, 0x74, 0x20, 0x23, 0x81, 0x09,
+  0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad,
+  0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x41, 0x0e, 0xe6, 0xe0,
+  0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51,
+  0x02, 0x3a, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e,
+  0xed, 0xcd, 0x6d, 0x94, 0xa0, 0x0e, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61,
+  0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b,
+  0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xb0, 0x83, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c,
+  0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2,
+  0xde, 0xdc, 0xe6, 0x46, 0x19, 0xee, 0x00, 0x0f, 0xf2, 0xe0, 0x98, 0xb0,
+  0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51,
+  0x82, 0x50, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00, 0x00, 0x25, 0x00, 0x00,
+  0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70,
+  0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82,
+  0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6,
+  0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x16, 0x34, 0xe3, 0x60,
+  0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4, 0x40, 0x0f, 0xe1, 0x20,
+  0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81, 0x07, 0x79, 0x28, 0x87,
+  0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01, 0x3b, 0xa4, 0x83, 0x3d,
+  0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xdc,
+  0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c, 0xe8, 0x81, 0x1e, 0xc2,
+  0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8,
+  0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1, 0x50, 0x0f, 0xf4, 0x80,
+  0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03,
+  0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41,
+  0x2c, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x84, 0x65, 0x30,
+  0x03, 0x40, 0x5a, 0x06, 0xd4, 0x73, 0x10, 0x04, 0x41, 0x64, 0x04, 0x63,
+  0x04, 0x20, 0x08, 0x82, 0xf8, 0x47, 0x3c, 0x03, 0x00, 0xf1, 0x30, 0x00,
+  0x00, 0x38, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0x48,
+  0x3d, 0x00, 0x00, 0x00, 0x00, 0xd5, 0xf3, 0x90, 0x81, 0x05, 0x00, 0x00,
+  0x00, 0x5f, 0x5a, 0x54, 0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65,
+  0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d,
+  0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61,
+  0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20,
+  0x54, 0x42, 0x41, 0x41, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61,
+  0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c,
+  0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d,
+  0x65, 0x6e, 0x74, 0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61,
+  0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28,
+  0x32, 0x29, 0x00, 0x00, 0x00, 0x13, 0x04, 0x85, 0x99, 0x20, 0x28, 0xcd,
+  0x04, 0x41, 0x71, 0x26, 0x08, 0xca, 0x33, 0x41, 0x50, 0xa0, 0x09, 0x82,
+  0x12, 0x4d, 0x10, 0x14, 0x69, 0x82, 0xa0, 0x4c, 0x2b, 0x04, 0x58, 0x30,
+  0x85, 0x15, 0x43, 0x2c, 0xc0, 0xc2, 0x29, 0x6c, 0x08, 0x4a, 0x61, 0xc3,
+  0x40, 0x0a, 0xb2, 0x80, 0x0a, 0x1b, 0x86, 0x6c, 0x16, 0x50, 0x61, 0x43,
+  0x34, 0x0a, 0xb4, 0x80, 0x0a, 0xb4, 0x90, 0x0a, 0xb4, 0xa0, 0x0a, 0xb4,
+  0xb0, 0x0a, 0xb4, 0xc0, 0x0a, 0xb4, 0xd0, 0x0a, 0xb4, 0xe0, 0x0a, 0xb4,
+  0xf0, 0x0a, 0x1b, 0x86, 0x5a, 0xa0, 0x85, 0x55, 0xd8, 0x10, 0xc4, 0x02,
+  0x00, 0x7b, 0x86, 0x43, 0x32, 0x28, 0x80, 0x31, 0xc7, 0x30, 0x04, 0xd4,
+  0x20, 0x43, 0x40, 0x18, 0x73, 0x0c, 0x81, 0x81, 0x58, 0xd0, 0x88, 0x7f,
+  0x06, 0x01, 0x31, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x8a, 0x20,
+  0xa8, 0x85, 0xc3, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xf3,
+  0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00,
+  0x00, 0x1f, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xf0, 0x00, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x7b, 0x00, 0x00, 0x00,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x53, 0x6f, 0x6c, 0x69, 0x64, 0x5f, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x33, 0x32, 0x30, 0x32, 0x33,
+  0x2e, 0x34, 0x30, 0x34, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70,
+  0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30,
+  0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x30, 0x1f, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05,
+  0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0x04, 0x07, 0x00,
+  0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e,
+  0x90, 0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x64, 0x01, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03,
+  0x40, 0x02, 0x2a, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0,
+  0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87,
+  0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07,
+  0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07,
+  0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07,
+  0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87,
+  0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc,
+  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87,
+  0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca,
+  0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda,
+  0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda,
+  0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88,
+  0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0xd8, 0xe0, 0x09, 0x04, 0xb0, 0x00, 0x55, 0x90,
+  0x06, 0x60, 0x30, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d,
+  0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b,
+  0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0xc1, 0x18, 0x0a,
+  0x60, 0x01, 0xaa, 0x0d, 0x06, 0x61, 0x00, 0x0b, 0x50, 0x6d, 0x08, 0x93,
+  0xe2, 0xff, 0xff, 0xff, 0xff, 0x07, 0x60, 0x0d, 0x00, 0x09, 0xa8, 0x88,
+  0x70, 0x80, 0x07, 0x78, 0x90, 0x87, 0x77, 0xc0, 0x87, 0x36, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xa2, 0x1d, 0xd2, 0xc1, 0x1d, 0xda, 0x80, 0x1d, 0xca, 0xe1, 0x1c, 0xc2,
+  0x81, 0x1d, 0xda, 0xc0, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4,
+  0xa1, 0x0d, 0xee, 0x21, 0x1d, 0xc8, 0x81, 0x1e, 0xd0, 0x01, 0x88, 0x03,
+  0x39, 0xc0, 0x03, 0x60, 0x70, 0x87, 0x77, 0x68, 0x03, 0x71, 0xa8, 0x87,
+  0x74, 0x60, 0x07, 0x7a, 0x48, 0x07, 0x77, 0x98, 0x07, 0x80, 0x70, 0x87,
+  0x77, 0x68, 0x03, 0x73, 0x90, 0x87, 0x70, 0x68, 0x87, 0x72, 0x68, 0x03,
+  0x78, 0x78, 0x87, 0x74, 0x70, 0x07, 0x7a, 0x28, 0x07, 0x79, 0x68, 0x83,
+  0x72, 0x60, 0x87, 0x74, 0x68, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0xa1, 0x0d, 0xdc,
+  0xe1, 0x1d, 0xdc, 0xa1, 0x0d, 0xd8, 0xa1, 0x1c, 0xc2, 0xc1, 0x1c, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x83,
+  0x74, 0x70, 0x07, 0x73, 0x98, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1d, 0xc2, 0xc1, 0x1d, 0xe6,
+  0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0,
+  0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87,
+  0x36, 0x98, 0x87, 0x74, 0x38, 0x07, 0x77, 0x28, 0x07, 0x72, 0x68, 0x03,
+  0x7d, 0x28, 0x07, 0x79, 0x78, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe8, 0x41, 0x1e, 0xc2,
+  0x01, 0x1e, 0xe0, 0x21, 0x1d, 0xdc, 0xe1, 0x1c, 0xda, 0xa0, 0x1d, 0xc2,
+  0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x88,
+  0x79, 0xa0, 0x87, 0x70, 0x18, 0x87, 0x75, 0x68, 0x03, 0x78, 0x90, 0x87,
+  0x77, 0xa0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x03,
+  0x71, 0xa8, 0x07, 0x73, 0x30, 0x87, 0x72, 0x90, 0x87, 0x36, 0x98, 0x87,
+  0x74, 0xd0, 0x87, 0x72, 0x00, 0xf0, 0x00, 0x20, 0xea, 0xc1, 0x1d, 0xe6,
+  0x21, 0x1c, 0xcc, 0xa1, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda,
+  0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07,
+  0x60, 0x43, 0x62, 0x08, 0xc0, 0x02, 0x54, 0x41, 0x1a, 0x80, 0xc1, 0x06,
+  0xe3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x90, 0x00, 0x6a, 0x83, 0x8f,
+  0x20, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x12, 0x50, 0x11, 0xe1, 0x00,
+  0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80, 0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0,
+  0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b,
+  0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b, 0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b,
+  0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b,
+  0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d, 0xa0, 0x03, 0x90, 0x07, 0x76, 0x00,
+  0x0c, 0xee, 0xf0, 0x0e, 0x6d, 0x20, 0x0e, 0xf5, 0x90, 0x0e, 0xec, 0x40,
+  0x0f, 0xe9, 0xe0, 0x0e, 0xf3, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x60,
+  0x0e, 0xf2, 0x10, 0x0e, 0xed, 0x50, 0x0e, 0x6d, 0x00, 0x0f, 0xef, 0x90,
+  0x0e, 0xee, 0x40, 0x0f, 0xe5, 0x20, 0x0f, 0x6d, 0x50, 0x0e, 0xec, 0x90,
+  0x0e, 0xed, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94, 0x43, 0x1b,
+  0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8, 0x43, 0x1b,
+  0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0xb4, 0x81, 0x3b, 0xbc, 0x83, 0x3b,
+  0xb4, 0x01, 0x3b, 0x94, 0x43, 0x38, 0x98, 0x03, 0x40, 0x0f, 0xf2, 0x50,
+  0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x90, 0x0e, 0xee, 0x60,
+  0x0e, 0xf3, 0xd0, 0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40,
+  0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b,
+  0xbc, 0x43, 0x1b, 0xb8, 0x43, 0x38, 0xb8, 0xc3, 0x3c, 0xb4, 0x81, 0x39,
+  0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20,
+  0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xf3, 0x90,
+  0x0e, 0xe7, 0xe0, 0x0e, 0xe5, 0x40, 0x0e, 0x6d, 0xa0, 0x0f, 0xe5, 0x20,
+  0x0f, 0xef, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10,
+  0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40,
+  0xb8, 0xc3, 0x3b, 0xb4, 0x01, 0x3d, 0xc8, 0x43, 0x38, 0xc0, 0x03, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a,
+  0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0x31, 0x0f, 0xf4, 0x10,
+  0x0e, 0xe3, 0xb0, 0x0e, 0x6d, 0x00, 0x0f, 0xf2, 0xf0, 0x0e, 0xf4, 0x50,
+  0x0e, 0xe3, 0x40, 0x0f, 0xef, 0x20, 0x0f, 0x6d, 0x20, 0x0e, 0xf5, 0x60,
+  0x0e, 0xe6, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xf3, 0x90, 0x0e, 0xfa, 0x50,
+  0x0e, 0x00, 0x1e, 0x00, 0x44, 0x3d, 0xb8, 0xc3, 0x3c, 0x84, 0x83, 0x39,
+  0x94, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d,
+  0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x6c, 0x50, 0x92,
+  0xff, 0xff, 0xff, 0xff, 0x1f, 0x80, 0x36, 0x00, 0xd6, 0x00, 0x90, 0x80,
+  0x6a, 0x83, 0xa1, 0x04, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x45, 0x00, 0x16,
+  0xa0, 0xda, 0xa0, 0x30, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x6d, 0x00,
+  0xac, 0x01, 0x20, 0x01, 0xd5, 0x86, 0xa9, 0xf9, 0xff, 0xff, 0xff, 0xff,
+  0x01, 0x58, 0x03, 0x40, 0x19, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1c, 0xea,
+  0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6, 0x01, 0xd8, 0x50,
+  0x38, 0x42, 0x90, 0x06, 0x60, 0xb0, 0xc1, 0x78, 0xfe, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0x24, 0x80, 0xda, 0x10, 0x41, 0xff, 0xff, 0xff, 0xff, 0x3f,
+  0x00, 0xca, 0xe0, 0x0e, 0xef, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe9, 0xc0,
+  0x0e, 0xf4, 0x90, 0x0e, 0xee, 0x30, 0x0f, 0x00, 0x00, 0x49, 0x18, 0x00,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x42,
+  0x61, 0x4c, 0x08, 0x8e, 0x09, 0x01, 0x32, 0x61, 0x48, 0x94, 0x65, 0xc2,
+  0xc0, 0x28, 0xcb, 0x04, 0xa1, 0x71, 0x26, 0x04, 0xcf, 0x84, 0x00, 0x02,
+  0x00, 0x89, 0x20, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88,
+  0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23,
+  0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4,
+  0x4c, 0x10, 0xb4, 0xc1, 0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08,
+  0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11,
+  0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x80, 0x41, 0x84, 0x41, 0x38, 0x4a, 0x9a, 0x22, 0x4a, 0x98, 0xfc,
+  0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0xfe, 0x69, 0x8c, 0x00,
+  0x18, 0x44, 0x28, 0x82, 0x8b, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x25,
+  0x80, 0x79, 0x16, 0x22, 0xfa, 0xa7, 0x31, 0x02, 0x60, 0x10, 0xe1, 0x10,
+  0xca, 0x11, 0x04, 0x81, 0x40, 0x18, 0x08, 0x25, 0x65, 0x08, 0x02, 0x82,
+  0x96, 0x61, 0x84, 0x01, 0x28, 0x44, 0xd3, 0x34, 0x0d, 0x39, 0x65, 0x00,
+  0x00, 0x80, 0xa0, 0x22, 0x00, 0x00, 0x49, 0x73, 0x04, 0x41, 0x11, 0x28,
+  0x80, 0xaa, 0x32, 0x00, 0x4d, 0x43, 0x57, 0x31, 0x9a, 0x06, 0x00, 0x00,
+  0x80, 0xb2, 0x32, 0x34, 0x4d, 0x43, 0x5b, 0x11, 0x9a, 0x86, 0xba, 0x39,
+  0x02, 0xc4, 0x08, 0xc1, 0x37, 0x47, 0x00, 0x06, 0xc3, 0x08, 0x42, 0x18,
+  0x14, 0x05, 0x34, 0x10, 0x81, 0x12, 0x29, 0x00, 0x08, 0x69, 0x1c, 0x08,
+  0x48, 0x81, 0x70, 0x04, 0x60, 0x8e, 0x00, 0x14, 0x06, 0x11, 0x00, 0x61,
+  0x0a, 0x60, 0x18, 0x61, 0x08, 0x83, 0x61, 0x04, 0x22, 0x0c, 0x00, 0x00,
+  0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda,
+  0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec,
+  0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0,
+  0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8,
+  0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b,
+  0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a,
+  0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e,
+  0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d,
+  0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c,
+  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d,
+  0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c,
+  0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d,
+  0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e,
+  0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c,
+  0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d,
+  0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d,
+  0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d,
+  0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d,
+  0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c,
+  0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x46, 0x6c, 0x57, 0xfe,
+  0x9c, 0xf3, 0x60, 0x7f, 0x11, 0x01, 0x06, 0x43, 0x34, 0xd3, 0x90, 0x08,
+  0x88, 0x12, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x18, 0x12, 0x45, 0x78, 0xb0, 0x20, 0xc0, 0x20, 0x00, 0x00, 0x00, 0x04,
+  0x00, 0x00, 0x00, 0xc0, 0x90, 0x28, 0x15, 0x28, 0x07, 0x08, 0x80, 0x01,
+  0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x86, 0x44, 0xbd, 0x00, 0x41,
+  0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x30, 0x24,
+  0x6a, 0x87, 0x48, 0x02, 0x02, 0x60, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x80, 0x21, 0x91, 0x3f, 0x58, 0x15, 0x10, 0x00, 0x03, 0x00, 0x00,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x89, 0x68, 0xa2, 0xb9, 0x80, 0x00,
+  0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60, 0x48, 0x14, 0x16,
+  0x59, 0x86, 0x00, 0x03, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
+  0x43, 0x22, 0xbd, 0x88, 0x20, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x18, 0x12, 0xad, 0x86, 0xb4, 0x01, 0x01, 0x30, 0x00,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xc0, 0x90, 0xa8, 0x37, 0xa6, 0x0e,
+  0x08, 0x80, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x86, 0x44,
+  0xf0, 0x31, 0x6d, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+  0x00, 0x30, 0x24, 0x1a, 0x91, 0x6d, 0x0c, 0x80, 0x00, 0x28, 0x00, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x40, 0x62, 0x83, 0x40, 0xd1, 0x82, 0x03,
+  0x00, 0x80, 0x2c, 0x10, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98,
+  0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43,
+  0x0a, 0x8b, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0, 0x0c, 0x0a, 0xa8, 0x20,
+  0x0a, 0xa3, 0x40, 0x0a, 0xa5, 0x60, 0x0a, 0xa7, 0x14, 0x08, 0x1d, 0x01,
+  0x28, 0x84, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0x32,
+  0xc7, 0x12, 0x24, 0x01, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0xde, 0x00, 0x0d, 0x48, 0x0b, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x41,
+  0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca,
+  0x23, 0x21, 0x54, 0xc1, 0x30, 0xca, 0xe2, 0x3c, 0xcf, 0x13, 0x5d, 0x4f,
+  0xb0, 0x28, 0xd8, 0xb0, 0x1c, 0x01, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4b,
+  0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61,
+  0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20,
+  0x6d, 0x65, 0x74, 0x61, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x20, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20,
+  0x28, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30,
+  0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c,
+  0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e,
+  0x64, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68,
+  0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72,
+  0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74,
+  0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61,
+  0x69, 0x72, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72,
+  0x2e, 0x6e, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74,
+  0x69, 0x76, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e,
+  0x61, 0x6d, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+  0x69, 0x72, 0x2e, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f,
+  0x69, 0x6e, 0x70, 0x75, 0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
+  0x65, 0x64, 0x28, 0x35, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34,
+  0x5f, 0x66, 0x29, 0x61, 0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70,
+  0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67,
+  0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65,
+  0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29,
+  0x66, 0x6c, 0x6f, 0x61, 0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72,
+  0x61, 0x69, 0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74,
+  0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72,
+  0x2e, 0x72, 0x65, 0x61, 0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72,
+  0x75, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66,
+  0x6f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f,
+  0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72,
+  0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63,
+  0x61, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d,
+  0x65, 0x74, 0x68, 0x6f, 0x64, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70,
+  0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65,
+  0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x73,
+  0x64, 0x72, 0x5f, 0x77, 0x68, 0x69, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69,
+  0x6e, 0x74, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61,
+  0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67,
+  0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x63, 0x61, 0x69,
+  0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69, 0x72,
+  0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x72, 0x73, 0x24, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0x10, 0x06, 0xcd, 0x08, 0x82, 0x19, 0x88, 0xc1, 0x08,
+  0x42, 0x18, 0x38, 0x23, 0x08, 0x61, 0xf0, 0x8c, 0x20, 0x84, 0x01, 0x34,
+  0x82, 0xa0, 0x00, 0x23, 0x08, 0x61, 0x10, 0x8d, 0x20, 0x84, 0x81, 0x34,
+  0x82, 0x10, 0x06, 0xd3, 0x08, 0x42, 0x18, 0x50, 0x23, 0x08, 0x61, 0x50,
+  0x8d, 0x20, 0x84, 0x81, 0x35, 0x82, 0x10, 0x06, 0xd7, 0x08, 0x42, 0x18,
+  0x60, 0x23, 0x08, 0x61, 0x90, 0xcd, 0x30, 0xc0, 0x41, 0x10, 0x07, 0x33,
+  0x0c, 0x72, 0x20, 0xcc, 0xc1, 0x0c, 0xc1, 0x30, 0xc3, 0x00, 0x07, 0x70,
+  0x40, 0x07, 0x33, 0x10, 0x84, 0x1c, 0xc8, 0x01, 0x1d, 0xcc, 0x10, 0x14,
+  0x33, 0x04, 0xc6, 0x0c, 0xc1, 0x31, 0x43, 0x81, 0xd0, 0x01, 0x1d, 0x24,
+  0xca, 0x0c, 0xc1, 0x29, 0xcc, 0x80, 0xd0, 0xc1, 0xc2, 0x34, 0x89, 0xe2,
+  0x3c, 0x33, 0x24, 0x72, 0x00, 0x45, 0x8c, 0x94, 0x28, 0xce, 0x34, 0x43,
+  0x02, 0x07, 0x10, 0xc5, 0x48, 0x49, 0xe5, 0x58, 0x33, 0xa0, 0x01, 0x1d,
+  0xcc, 0x01, 0x1d, 0x70, 0xdd, 0x1c, 0xcc, 0x01, 0x1d, 0x70, 0x1e, 0x1e,
+  0xcc, 0x01, 0x1d, 0x70, 0x5f, 0x1e, 0xcc, 0x01, 0x1d, 0x70, 0x60, 0xa0,
+  0x07, 0x73, 0x40, 0x07, 0x5c, 0x18, 0xec, 0xc1, 0x1c, 0xd0, 0x01, 0x27,
+  0x06, 0x7c, 0x30, 0x07, 0x74, 0xc0, 0x8d, 0x41, 0x1f, 0xcc, 0x01, 0x1d,
+  0x70, 0x64, 0x30, 0x83, 0x64, 0x07, 0x17, 0x76, 0x07, 0x19, 0x1d, 0xc8,
+  0x81, 0xb6, 0xb1, 0x42, 0x19, 0xdc, 0x81, 0x19, 0xcc, 0x41, 0x72, 0x06,
+  0x0e, 0x1a, 0xcc, 0xa0, 0xcc, 0x41, 0x1a, 0x64, 0x74, 0x20, 0x07, 0x6a,
+  0x90, 0xac, 0x81, 0xc3, 0x06, 0x33, 0x24, 0x7e, 0xd0, 0x06, 0x19, 0x1d,
+  0xc8, 0x41, 0xe2, 0x06, 0xce, 0x1b, 0xcc, 0x60, 0xa4, 0x82, 0x2a, 0xac,
+  0x42, 0x2b, 0xb8, 0xc2, 0x2b, 0xcc, 0x30, 0xd4, 0x01, 0x2a, 0xc0, 0x42,
+  0x89, 0x01, 0x20, 0x06, 0x68, 0x20, 0x06, 0x62, 0x20, 0x06, 0x9c, 0x18,
+  0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18,
+  0xb8, 0x81, 0x1b, 0x58, 0x74, 0xa0, 0x07, 0x96, 0x65, 0xe9, 0x01, 0x67,
+  0x0a, 0xac, 0xc0, 0x0a, 0x74, 0xe3, 0x17, 0xf6, 0xa0, 0x0e, 0xb8, 0x20,
+  0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d,
+  0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14, 0xc1,
+  0x0f, 0xfe, 0xe0, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32,
+  0x37, 0xba, 0x51, 0x02, 0x50, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae,
+  0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0x20, 0x14, 0x8e, 0x0a, 0x4b,
+  0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2,
+  0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0x10, 0x85, 0x9b, 0xc2,
+  0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde,
+  0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0x46, 0x81, 0x14, 0x4a,
+  0xe1, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32,
+  0x37, 0xba, 0x51, 0x02, 0x58, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80,
+  0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43,
+  0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4,
+  0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81,
+  0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01,
+  0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c,
+  0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c,
+  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1,
+  0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c,
+  0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90,
+  0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x3e, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x44, 0xd5, 0xc0, 0x08, 0x00, 0x89, 0x23, 0x00, 0x04, 0x8c, 0x00,
+  0x00, 0xf1, 0x30, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8,
+  0x90, 0x51, 0x12, 0x44, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x63, 0x80, 0x61,
+  0x16, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73,
+  0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f,
+  0x70, 0x79, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x29,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x73,
+  0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63,
+  0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x00, 0x00,
+  0x00, 0x2b, 0x04, 0x5b, 0x90, 0x85, 0x15, 0xc3, 0x2d, 0xd8, 0xc2, 0x2c,
+  0xac, 0x18, 0x70, 0xc1, 0x16, 0x68, 0x61, 0xc5, 0x90, 0x0b, 0xb6, 0x50,
+  0x0b, 0x1b, 0x04, 0x5c, 0xb8, 0x85, 0x0d, 0x41, 0x2e, 0x00, 0x00, 0x00,
+  0x00, 0x23, 0x06, 0x8d, 0x11, 0x82, 0x60, 0x30, 0x06, 0x61, 0x60, 0x14,
+  0x08, 0x21, 0x0c, 0x41, 0xd0, 0x8d, 0x26, 0x04, 0xc0, 0x88, 0xc1, 0x71,
+  0xc4, 0x20, 0x58, 0xf8, 0xc7, 0xe2, 0x06, 0x41, 0x62, 0x01, 0x23, 0xfe,
+  0x19, 0x04, 0xc4, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5b, 0x0a, 0xe0,
+  0xc8, 0x05, 0x44, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0xe3, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00,
+  0x00, 0x4f, 0x00, 0x00, 0x00, 0x14, 0x96, 0xc3, 0x0c, 0x40, 0x31, 0x10,
+  0x5a, 0x02, 0x45, 0x40, 0xeb, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00, 0xc4,
+  0xce, 0x41, 0x40, 0x4e, 0x63, 0x06, 0x63, 0x11, 0x40, 0x20, 0x1c, 0x04,
+  0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x18, 0x81, 0x2c, 0xba, 0x3d,
+  0x0d, 0x06, 0x63, 0x04, 0xb5, 0x5a, 0xab, 0xed, 0x37, 0x46, 0xd0, 0xc7,
+  0xa2, 0x8b, 0x7f, 0x63, 0x04, 0x6e, 0x1f, 0x8b, 0xb6, 0x2f, 0x8c, 0x11,
+  0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0x79, 0xaf, 0xab, 0xec, 0x8d,
+  0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0xdb, 0xc7, 0xa2, 0xed,
+  0x8d, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf, 0x18, 0x81, 0xce, 0x9a, 0x73,
+  0x08, 0x06, 0x23, 0x00, 0x63, 0x04, 0x20, 0x08, 0x82, 0x24, 0x18, 0x8c,
+  0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x03, 0x40, 0xc1, 0x0c, 0xc0,
+  0x0c, 0xc0, 0x1c, 0xc4, 0x1c, 0xe4, 0xc1, 0x1c, 0xf0, 0x01, 0x35, 0x33,
+  0x00, 0x23, 0x00, 0x33, 0x00, 0x63, 0x0d, 0x20, 0x08, 0x82, 0xf8, 0x07,
+  0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82, 0xf8, 0x37, 0xd6, 0xc0, 0xb6,
+  0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4, 0xc7, 0xb6, 0xf3, 0x4f, 0x7a,
+  0x63, 0x0d, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8, 0xd6, 0xbf,
+  0x00, 0x82, 0x20, 0x5b, 0xff, 0xc2, 0x58, 0x03, 0x08, 0x82, 0x6b, 0x0e,
+  0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x80, 0x20, 0xb8, 0xe6, 0x60, 0x30,
+  0xd6, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d, 0x0e, 0x06,
+  0x20, 0x48, 0xb7, 0x39, 0x18, 0x8c, 0x35, 0xac, 0x23, 0x1e, 0xb3, 0x60,
+  0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x3a, 0xe2, 0x31, 0x0b, 0x06, 0x63,
+  0x0d, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87, 0x63, 0x00,
+  0x82, 0x30, 0x1e, 0x8e, 0xc1, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff, 0x81,
+  0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58, 0xc3,
+  0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2, 0x71,
+  0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad, 0x1b,
+  0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x00, 0xf1, 0x30, 0x00,
+  0x00, 0x32, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x0e, 0xc4,
+  0x1d, 0x00, 0x00, 0x00, 0x00, 0xd5, 0xf3, 0x00, 0x00, 0x5f, 0x5a, 0x54,
+  0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x6e, 0x69, 0x70, 0x6f,
+  0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72, 0x53, 0x69, 0x6d,
+  0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54, 0x42, 0x41, 0x41,
+  0x00, 0x13, 0x04, 0x34, 0xd0, 0x26, 0x08, 0x68, 0xb0, 0x4d, 0x10, 0xd0,
+  0x80, 0x9b, 0x20, 0xa0, 0x41, 0x37, 0x41, 0x40, 0x03, 0x6f, 0x82, 0x80,
+  0x06, 0xdf, 0x04, 0x01, 0x0d, 0xc0, 0x60, 0x82, 0x80, 0x06, 0x61, 0xb0,
+  0x21, 0xa0, 0x85, 0x0d, 0xc3, 0x2c, 0xf4, 0x42, 0x2d, 0x6c, 0x18, 0x38,
+  0x5f, 0xa8, 0x85, 0x0d, 0x91, 0x2c, 0xfc, 0x42, 0x2d, 0xfc, 0x82, 0x2d,
+  0xfc, 0xc2, 0x2d, 0xfc, 0x02, 0x2e, 0xfc, 0x42, 0x2e, 0xfc, 0x82, 0x2e,
+  0xfc, 0xc2, 0x2e, 0xfc, 0x02, 0x2f, 0x6c, 0x18, 0xc0, 0xe1, 0x17, 0x6e,
+  0x61, 0xc3, 0x00, 0x0e, 0xbf, 0xc0, 0x0b, 0x1b, 0x06, 0x70, 0xf8, 0x85,
+  0x5c, 0xd8, 0x30, 0x80, 0xc3, 0x2f, 0xe8, 0xc2, 0x86, 0x01, 0x1c, 0x7e,
+  0x61, 0x17, 0x36, 0x0c, 0xe0, 0xf0, 0x0b, 0xb6, 0xb0, 0x61, 0x00, 0x87,
+  0x5f, 0xc0, 0x85, 0x0d, 0x03, 0x38, 0xfc, 0x42, 0x2d, 0x00, 0x00, 0x00,
+  0x00, 0x7b, 0x18, 0xd2, 0x60, 0x0e, 0x40, 0x81, 0x02, 0x60, 0x0c, 0x47,
+  0x04, 0x55, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0xb4, 0xc1,
+  0x64, 0x06, 0x7b, 0x18, 0xda, 0xe0, 0x0e, 0xd8, 0x80, 0x02, 0x60, 0x8c,
+  0x18, 0x18, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x74, 0xa9, 0x30, 0x8c, 0x18,
+  0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x6c, 0xab, 0x10, 0x40, 0x16, 0x40,
+  0xe0, 0x3f, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0xb1, 0xad, 0x42,
+  0x50, 0xd9, 0x10, 0x89, 0xbf, 0x45, 0x41, 0xf8, 0xdb, 0x10, 0x90, 0xff,
+  0x88, 0x81, 0x81, 0x84, 0x20, 0x58, 0xf8, 0x47, 0x07, 0x0b, 0xc1, 0x88,
+  0xc1, 0x81, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0x26, 0x0b, 0xc1, 0x64, 0xc1,
+  0x24, 0xfe, 0x73, 0x0c, 0xdd, 0x32, 0x0a, 0x83, 0x0c, 0x81, 0x37, 0x07,
+  0x36, 0x04, 0xe4, 0x3f, 0xc8, 0x10, 0x80, 0x01, 0x1d, 0x0c, 0x32, 0x04,
+  0x7e, 0x40, 0x07, 0xb3, 0x04, 0xc2, 0x40, 0x45, 0x20, 0x04, 0xfe, 0x00,
+  0xec, 0x61, 0xf8, 0x83, 0x54, 0xa0, 0x05, 0x0a, 0x80, 0x31, 0x1c, 0x11,
+  0xb0, 0x81, 0xe3, 0x1f, 0xb3, 0x0c, 0x03, 0x11, 0x0c, 0x32, 0x10, 0x69,
+  0xc0, 0x07, 0x7b, 0x18, 0x46, 0xa1, 0x15, 0x5c, 0x81, 0x02, 0x60, 0xec,
+  0x61, 0x28, 0x85, 0x57, 0x10, 0x05, 0x0a, 0x80, 0x31, 0x62, 0xa0, 0x24,
+  0x31, 0x08, 0x16, 0xfe, 0x91, 0x91, 0x43, 0xd1, 0x1d, 0x43, 0x30, 0xc8,
+  0x10, 0xb0, 0x01, 0x28, 0x0c, 0x32, 0x04, 0x0b, 0x28, 0xcc, 0x12, 0x10,
+  0x03, 0x15, 0x81, 0x30, 0x60, 0xc2, 0x70, 0x44, 0x18, 0xf0, 0x41, 0xe0,
+  0x1f, 0xb3, 0x0c, 0xc5, 0x14, 0xec, 0x61, 0x60, 0x05, 0x5b, 0x10, 0x07,
+  0x0a, 0x80, 0x31, 0x1c, 0x11, 0xfc, 0x41, 0xe0, 0x1f, 0xb3, 0x0c, 0xc6,
+  0x11, 0x0c, 0x32, 0x14, 0x76, 0x90, 0x0a, 0x7b, 0x18, 0x60, 0x41, 0x17,
+  0xc6, 0x81, 0x02, 0x60, 0xcc, 0x31, 0xd8, 0x41, 0xc0, 0x0b, 0x83, 0x0c,
+  0xc1, 0x1d, 0xb0, 0x82, 0x05, 0x85, 0xf8, 0x0f, 0x32, 0x04, 0x79, 0xd0,
+  0x0a, 0xb3, 0x04, 0x6d, 0xb0, 0x87, 0xc1, 0x16, 0xc0, 0x41, 0x1d, 0x28,
+  0x00, 0xc6, 0x1e, 0x06, 0x5c, 0x10, 0x87, 0x75, 0xa0, 0x00, 0x18, 0x83,
+  0x0c, 0x50, 0x28, 0xc8, 0xc2, 0x88, 0x41, 0x81, 0x84, 0x20, 0x18, 0x54,
+  0xfa, 0x40, 0xcc, 0x32, 0x20, 0x52, 0x30, 0x86, 0x20, 0x99, 0xc3, 0x70,
+  0x44, 0xd0, 0x0a, 0x8a, 0x7f, 0xcc, 0x32, 0x28, 0x49, 0x60, 0x42, 0x2b,
+  0x88, 0xff, 0x2c, 0xc1, 0x62, 0x43, 0x2b, 0x80, 0xff, 0x88, 0x81, 0x81,
+  0x84, 0x20, 0x58, 0xf8, 0x87, 0x04, 0x12, 0x81, 0x05, 0xae, 0x20, 0xfe,
+  0x23, 0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0xd0, 0x48, 0x04, 0xae,
+  0x30, 0x4b, 0xb0, 0x0c, 0x54, 0x00, 0x4a, 0x22, 0x28, 0x73, 0x0c, 0xaa,
+  0x10, 0xb8, 0xc3, 0x18, 0xc2, 0x16, 0x0e, 0xc3, 0x11, 0x81, 0x2d, 0x28,
+  0xfe, 0x31, 0xcb, 0xd0, 0x30, 0x81, 0x09, 0xb6, 0x20, 0xfe, 0xb3, 0x04,
+  0x8e, 0x0d, 0xb6, 0x00, 0xfe, 0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1,
+  0x1f, 0x52, 0x4a, 0x04, 0x16, 0xdc, 0x82, 0xf8, 0x8f, 0x18, 0x1c, 0x48,
+  0x08, 0x82, 0x85, 0x7f, 0x40, 0x2c, 0x11, 0xdc, 0xc2, 0x2c, 0x81, 0x33,
+  0x50, 0x01, 0x28, 0x8c, 0xd0, 0xcc, 0x31, 0x24, 0x41, 0x3a, 0x8c, 0x21,
+  0x90, 0x41, 0x3a, 0x0c, 0x47, 0x04, 0xbf, 0xa0, 0xf8, 0xc7, 0x2c, 0x03,
+  0xf4, 0x04, 0x26, 0xfc, 0x82, 0xf8, 0xcf, 0x12, 0x44, 0x36, 0xfc, 0x02,
+  0xf8, 0x8f, 0x18, 0x18, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x48, 0x32, 0x11,
+  0x58, 0x00, 0x0e, 0xe2, 0x3f, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe,
+  0x01, 0xd5, 0x44, 0x00, 0x0e, 0xb3, 0x04, 0xd1, 0x40, 0x05, 0xa0, 0x3c,
+  0x02, 0x34, 0xc7, 0x90, 0x04, 0xf1, 0x30, 0x4b, 0x20, 0x0d, 0x54, 0x04,
+  0x42, 0xa4, 0x07, 0xc7, 0x20, 0x43, 0xf0, 0x0b, 0xf2, 0x30, 0xc7, 0xd0,
+  0x0b, 0x60, 0x30, 0x12, 0x83, 0x0c, 0x81, 0x2f, 0xcc, 0x83, 0x0d, 0x81,
+  0xf8, 0x0f, 0x32, 0x04, 0xe0, 0x40, 0x0f, 0xb3, 0x04, 0x6d, 0x30, 0x1c,
+  0x31, 0x0b, 0xe6, 0x10, 0xf8, 0xc7, 0x2c, 0x03, 0x05, 0x06, 0xc1, 0x20,
+  0x03, 0x1d, 0x94, 0x03, 0x3e, 0xec, 0x61, 0xf8, 0x87, 0x94, 0x98, 0x09,
+  0x0a, 0x80, 0xb1, 0x87, 0x21, 0x24, 0x56, 0x82, 0x26, 0x28, 0x00, 0xc6,
+  0x1c, 0xc3, 0x39, 0x04, 0x2d, 0x31, 0xc8, 0x10, 0xa0, 0x43, 0x3f, 0x58,
+  0x70, 0x88, 0xff, 0x20, 0x43, 0xa0, 0x0e, 0xfe, 0x30, 0x62, 0x50, 0x20,
+  0x21, 0x08, 0x06, 0x95, 0x59, 0x1c, 0xb3, 0x0c, 0x5f, 0x15, 0x8c, 0x21,
+  0x0c, 0x32, 0x31, 0x1c, 0x11, 0xfc, 0x83, 0xe2, 0x1f, 0xb3, 0x0c, 0x97,
+  0x15, 0x98, 0xf0, 0x0f, 0xe2, 0x3f, 0x4b, 0x80, 0x8d, 0x18, 0x18, 0x48,
+  0x08, 0x82, 0x85, 0x7f, 0x48, 0x6b, 0x31, 0x8c, 0x18, 0x1c, 0x48, 0x08,
+  0x82, 0x85, 0x7f, 0x40, 0x6d, 0x11, 0x80, 0x84, 0x05, 0x20, 0x21, 0xfe,
+  0x16, 0x80, 0x04, 0xf8, 0xcf, 0x12, 0x60, 0x03, 0x15, 0x80, 0x62, 0x09,
+  0xd7, 0x1c, 0x83, 0x3c, 0x04, 0x3a, 0x31, 0x86, 0xc0, 0xb4, 0xc4, 0x70,
+  0x44, 0x80, 0x12, 0x8a, 0x7f, 0xcc, 0x32, 0x68, 0x59, 0x60, 0x02, 0x4a,
+  0x88, 0xff, 0x2c, 0xc1, 0x36, 0x62, 0x60, 0x20, 0x21, 0x08, 0x16, 0xfe,
+  0x21, 0xd1, 0xc5, 0x30, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x01,
+  0xd9, 0x45, 0x90, 0x12, 0x16, 0xa4, 0x84, 0xf8, 0x5b, 0x90, 0x12, 0xe0,
+  0x3f, 0x4b, 0xb0, 0x0d, 0x54, 0x00, 0x4a, 0x26, 0x68, 0x73, 0x0c, 0x49,
+  0x50, 0x13, 0x63, 0x08, 0x55, 0x4d, 0x0c, 0x47, 0x04, 0x31, 0xa1, 0xf8,
+  0xc7, 0x2c, 0x43, 0xc7, 0x05, 0x26, 0xc4, 0x84, 0xf8, 0xcf, 0x12, 0x78,
+  0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x52, 0x5f, 0x0c, 0x23,
+  0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0xd0, 0x5f, 0x04, 0x32, 0x61,
+  0x81, 0x4c, 0x88, 0xbf, 0x05, 0x32, 0x01, 0xfe, 0xb3, 0x04, 0xde, 0x40,
+  0x05, 0xa0, 0x70, 0x42, 0x37, 0xc7, 0x90, 0x04, 0x3d, 0x31, 0x62, 0x80,
+  0x20, 0x21, 0x08, 0x16, 0xfe, 0xe1, 0x94, 0x46, 0x60, 0x12, 0x24, 0x31,
+  0xc8, 0x10, 0xa0, 0x04, 0x4f, 0xcc, 0x12, 0x7c, 0x03, 0x15, 0x81, 0x1f,
+  0x50, 0x82, 0x37, 0xc8, 0x10, 0xb4, 0x84, 0x4f, 0xcc, 0x12, 0xb4, 0xc1,
+  0x2c, 0x43, 0x18, 0xb4, 0x01, 0x3f, 0x0c, 0x32, 0xf4, 0x82, 0x4b, 0x84,
+  0xc5, 0x88, 0xc1, 0x81, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0x65, 0x1a, 0x81,
+  0x48, 0xcc, 0x31, 0xac, 0x44, 0x30, 0x17, 0x23, 0x06, 0x07, 0x12, 0x82,
+  0x60, 0xe1, 0x1f, 0x17, 0x6a, 0x0c, 0x23, 0x31, 0xc7, 0x20, 0x04, 0x67,
+  0x31, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x71, 0xa9, 0x46, 0x41,
+  0x12, 0x73, 0x0c, 0x42, 0x80, 0x16, 0x83, 0x0c, 0x81, 0x4c, 0x98, 0xc5,
+  0x20, 0x43, 0x50, 0x0e, 0x66, 0xb1, 0x87, 0x01, 0x2e, 0xf4, 0x82, 0x34,
+  0x28, 0x00, 0xc6, 0x1e, 0x06, 0xb9, 0xe0, 0x8b, 0xd2, 0xa0, 0x00, 0x18,
+  0x73, 0x0c, 0x38, 0x11, 0xf8, 0xc5, 0x20, 0x43, 0x90, 0x13, 0x6e, 0x61,
+  0x41, 0x22, 0xfe, 0x83, 0x0c, 0xc1, 0x4e, 0xbc, 0xc5, 0x88, 0x41, 0x81,
+  0x84, 0x20, 0x18, 0x54, 0xb7, 0x71, 0xcc, 0x32, 0xb0, 0x81, 0x18, 0x04,
+  0x63, 0x08, 0xc3, 0x68, 0x0c, 0x47, 0x04, 0x70, 0xa1, 0xf8, 0xc7, 0x2c,
+  0x03, 0x19, 0x8c, 0x41, 0x60, 0x02, 0x5c, 0x88, 0xff, 0x2c, 0x41, 0x19,
+  0x8c, 0x18, 0x18, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x48, 0xbc, 0x31, 0x8c,
+  0x18, 0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x40, 0xbe, 0x11, 0xc4, 0x85,
+  0x05, 0x71, 0x21, 0xfe, 0x16, 0xc4, 0x05, 0xf8, 0xcf, 0x12, 0x94, 0xc1,
+  0x40, 0x05, 0xa0, 0x8c, 0x81, 0x40, 0x06, 0x73, 0x0c, 0x63, 0x11, 0xac,
+  0xc6, 0x18, 0x02, 0xe3, 0x17, 0xc3, 0x11, 0x41, 0x5e, 0x28, 0xfe, 0x31,
+  0xcb, 0x70, 0x06, 0x66, 0x10, 0x98, 0x90, 0x17, 0xe2, 0x3f, 0x4b, 0x80,
+  0x06, 0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x52, 0x79, 0x0c,
+  0x23, 0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0xd0, 0x79, 0x04, 0x7a,
+  0x61, 0x81, 0x5e, 0x88, 0xbf, 0x05, 0x7a, 0x01, 0xfe, 0xb3, 0x04, 0x68,
+  0x30, 0x50, 0x01, 0x28, 0x66, 0x20, 0x9c, 0xc1, 0x1c, 0x43, 0x12, 0x98,
+  0xc6, 0x18, 0x42, 0x65, 0x1a, 0xc3, 0x11, 0x81, 0x68, 0x28, 0xfe, 0x31,
+  0xcb, 0xa0, 0x06, 0x69, 0x10, 0x98, 0x20, 0x1a, 0xe2, 0x3f, 0x4b, 0xb0,
+  0x06, 0x23, 0x06, 0x06, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x92, 0x7b, 0x0c,
+  0x23, 0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x10, 0x7c, 0x04, 0xa3,
+  0x61, 0xc1, 0x68, 0x88, 0xbf, 0x05, 0xa3, 0x01, 0xfe, 0xb3, 0x04, 0x6b,
+  0x30, 0x50, 0x01, 0x28, 0x69, 0x20, 0xa8, 0xc1, 0x1c, 0x43, 0x12, 0xb8,
+  0xc6, 0x88, 0x01, 0x82, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x63, 0x1f, 0xc1,
+  0x5d, 0xd4, 0xc5, 0x20, 0x43, 0x90, 0x17, 0xad, 0x31, 0x4b, 0xc0, 0x06,
+  0x03, 0x15, 0x81, 0x1f, 0x84, 0x81, 0xb0, 0x06, 0x83, 0x0c, 0x81, 0x5f,
+  0xbc, 0xc6, 0x2c, 0x41, 0x1b, 0x0c, 0xb4, 0x04, 0x3c, 0x62, 0xf0, 0x88,
+  0xc4, 0x23, 0x9f, 0x2c, 0xb0, 0x01, 0x8f, 0x80, 0xc1, 0x40, 0x4b, 0x80,
+  0x22, 0x86, 0x5e, 0x48, 0xe6, 0xf0, 0x11, 0x6c, 0xc0, 0x2f, 0x60, 0x30,
+  0xc8, 0x10, 0x08, 0xb1, 0x91, 0x41, 0x40, 0x0c, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x5b, 0x86, 0x20, 0x00, 0x87, 0x2d, 0x83, 0x11, 0x84, 0xc3, 0x96,
+  0x21, 0x0b, 0xc4, 0x61, 0xcb, 0xe0, 0x05, 0xe3, 0xb0, 0x65, 0x00, 0x83,
+  0x80, 0x1c, 0xb6, 0x0c, 0x69, 0x10, 0x94, 0xc3, 0x96, 0xc1, 0x0d, 0x02,
+  0x73, 0xd8, 0x32, 0xd4, 0x41, 0x70, 0x0e, 0x5b, 0x86, 0x3b, 0x08, 0xcc,
+  0x61, 0xcb, 0xb0, 0x0e, 0xc1, 0x39, 0x6c, 0x19, 0xda, 0x21, 0x30, 0x87,
+  0x2d, 0x43, 0x5a, 0x04, 0xe7, 0xb0, 0x65, 0x58, 0x8b, 0xc0, 0x1c, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x73, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00,
+  0x00, 0x14, 0xce, 0x00, 0x10, 0x5a, 0x02, 0x45, 0x40, 0xeb, 0x58, 0x03,
+  0x10, 0x08, 0x23, 0x00, 0xc4, 0xce, 0x41, 0x40, 0x4e, 0x83, 0x06, 0x04,
+  0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20,
+  0x08, 0x06, 0x23, 0x00, 0x14, 0xcc, 0x00, 0xcc, 0x00, 0x50, 0x33, 0x03,
+  0x30, 0xd6, 0xc0, 0xb2, 0x67, 0x28, 0x7f, 0xa8, 0x5f, 0xc6, 0xea, 0x97,
+  0x9f, 0xba, 0x38, 0x7b, 0x63, 0x0d, 0x7a, 0x0d, 0xee, 0xb8, 0xa7, 0xe2,
+  0xb9, 0x6d, 0x7f, 0x6f, 0x9f, 0xd2, 0xa3, 0x37, 0xd6, 0xb0, 0xce, 0x31,
+  0x8b, 0x7a, 0x69, 0x08, 0xa3, 0xbb, 0x77, 0xb7, 0xb1, 0x6a, 0x7f, 0x63,
+  0x0d, 0x62, 0x2e, 0xa6, 0xfd, 0x07, 0x96, 0x3c, 0x1b, 0xff, 0xc2, 0x98,
+  0xae, 0x6a, 0xee, 0x0b, 0x63, 0x0d, 0xff, 0x4c, 0xfa, 0xbf, 0x2f, 0xd0,
+  0x35, 0x28, 0xe6, 0x5f, 0x0b, 0xc7, 0x31, 0xe8, 0x0b, 0x63, 0x0d, 0x73,
+  0xdf, 0xa6, 0xa9, 0x2f, 0xb4, 0x6e, 0xc8, 0xf3, 0xbe, 0xc0, 0xe7, 0xac,
+  0x8f, 0x7f, 0x00, 0x00, 0x00, 0x83, 0x0c, 0xd7, 0xd1, 0x0c, 0x47, 0x58,
+  0x4d, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0xcc, 0x31, 0x24, 0x96, 0x18,
+  0x0c, 0x32, 0x04, 0x4a, 0x64, 0xc1, 0x26, 0xfe, 0x83, 0x0c, 0x01, 0x23,
+  0xcd, 0x12, 0x24, 0xc3, 0x11, 0x5b, 0x14, 0xf8, 0xc7, 0x2c, 0xc3, 0x90,
+  0x04, 0xc3, 0x11, 0x9d, 0x14, 0xf8, 0xc7, 0x2c, 0x03, 0x51, 0x04, 0x23,
+  0x06, 0x07, 0x12, 0x82, 0x60, 0xe1, 0x1f, 0x17, 0x1f, 0x7c, 0xce, 0x1c,
+  0x43, 0x14, 0xa4, 0xc1, 0x88, 0xc1, 0x81, 0x84, 0x20, 0x58, 0xf8, 0xc7,
+  0xe5, 0x07, 0x61, 0xf0, 0xcc, 0x31, 0x08, 0x01, 0x37, 0x62, 0x70, 0x20,
+  0x21, 0x08, 0x16, 0xfe, 0x71, 0x81, 0xc2, 0x18, 0x40, 0x73, 0x0c, 0x42,
+  0xd0, 0xcd, 0x12, 0x14, 0x03, 0x15, 0x81, 0x40, 0x70, 0xc3, 0x18, 0x42,
+  0xf0, 0x06, 0x63, 0x08, 0x42, 0x18, 0x8c, 0x21, 0x0c, 0x61, 0x30, 0x62,
+  0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x01, 0x91, 0x82, 0x10, 0x8c, 0x18,
+  0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x40, 0xa5, 0x40, 0x04, 0xc3, 0x11,
+  0x81, 0x27, 0xf8, 0xc7, 0x2c, 0x83, 0x71, 0x04, 0x83, 0x0c, 0x87, 0x47,
+  0x06, 0x36, 0xa8, 0x81, 0xf8, 0x5b, 0x30, 0x06, 0xe0, 0x6f, 0xc5, 0x1a,
+  0x88, 0xbf, 0x05, 0x65, 0x00, 0xfe, 0x36, 0x04, 0xe4, 0x3f, 0xc7, 0x20,
+  0x06, 0xc1, 0x1e, 0x0c, 0x32, 0x04, 0x63, 0xa0, 0x06, 0x16, 0x20, 0xe2,
+  0x3f, 0xc8, 0x10, 0x94, 0xc1, 0x1a, 0xcc, 0x12, 0x1c, 0x03, 0x15, 0x81,
+  0x60, 0x88, 0x41, 0x31, 0xcb, 0x80, 0x24, 0xd9, 0x20, 0x43, 0x90, 0x06,
+  0x6f, 0x30, 0x62, 0x70, 0x20, 0x21, 0x08, 0x16, 0xfe, 0x71, 0xd5, 0x42,
+  0x40, 0x06, 0x73, 0x0c, 0x6a, 0x10, 0x88, 0xc2, 0x88, 0xc1, 0x81, 0x84,
+  0x20, 0x58, 0xf8, 0xc7, 0x75, 0x0b, 0x43, 0x19, 0xcc, 0x31, 0x08, 0x41,
+  0x1d, 0x8c, 0x18, 0x1c, 0x48, 0x08, 0x82, 0x85, 0x7f, 0x5c, 0xb9, 0x50,
+  0x98, 0xc1, 0x1c, 0x83, 0x10, 0xd8, 0xc1, 0x2c, 0x41, 0x32, 0x50, 0x12,
+  0x90, 0x42, 0xe0, 0x0a, 0x82, 0x80, 0x40, 0xc7, 0x20, 0x43, 0x10, 0x07,
+  0x77, 0x90, 0x01, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xeb, 0x08, 0x18, 0xb0, 0x9a,
+  0x80, 0x07, 0x90, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00,
+  0x00, 0x67, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x30, 0x03, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x01, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x5d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0x7e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x94, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+  0x00, 0xa1, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xba, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0xcb, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xdd, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xf0, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00,
+  0x00, 0x03, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00,
+  0x00, 0x55, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xa7, 0x02, 0x00, 0x00,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x43, 0x6f, 0x70, 0x79, 0x5f, 0x66, 0x72,
+  0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x5a, 0x31, 0x34, 0x47, 0x65,
+  0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
+  0x44, 0x76, 0x34, 0x5f, 0x66, 0x52, 0x55, 0x31, 0x31, 0x4d, 0x54, 0x4c,
+  0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x4b, 0x31, 0x35, 0x53,
+  0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e,
+  0x74, 0x73, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x63,
+  0x6c, 0x61, 0x6d, 0x70, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x66,
+  0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66,
+  0x61, 0x62, 0x73, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x2e, 0x75, 0x2e, 0x69, 0x31, 0x2e,
+  0x66, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74,
+  0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x5f, 0x5a, 0x31, 0x32, 0x41, 0x70,
+  0x70, 0x6c, 0x79, 0x54, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x44, 0x76,
+  0x33, 0x5f, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78, 0x2e, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77,
+  0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e, 0x76, 0x33, 0x66, 0x33,
+  0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d,
+  0x61, 0x78, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e,
+  0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33,
+  0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x61, 0x69, 0x72, 0x36,
+  0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73,
+  0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c,
+  0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17,
+  0x0b, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xfc, 0x21, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05,
+  0xc8, 0x14, 0x00, 0x00, 0x00, 0x21, 0x0c, 0x00, 0x00, 0xa9, 0x07, 0x00,
+  0x00, 0x0b, 0x02, 0x21, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0x07, 0x81, 0x23, 0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32,
+  0x39, 0x92, 0x01, 0x84, 0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b,
+  0x62, 0x80, 0x18, 0x45, 0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32,
+  0x14, 0x38, 0x08, 0x18, 0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14,
+  0x20, 0x43, 0x46, 0x88, 0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e,
+  0x90, 0x11, 0x23, 0xc4, 0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5,
+  0x8a, 0x04, 0x31, 0x46, 0x06, 0x51, 0x18, 0x00, 0x00, 0x6e, 0x01, 0x00,
+  0x00, 0x1b, 0xc2, 0x24, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03,
+  0x40, 0x02, 0x2a, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0,
+  0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87,
+  0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07,
+  0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07,
+  0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda,
+  0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca,
+  0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07,
+  0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07,
+  0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87,
+  0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc,
+  0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07,
+  0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87,
+  0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca,
+  0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda,
+  0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00,
+  0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03,
+  0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87,
+  0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea,
+  0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda,
+  0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde,
+  0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88,
+  0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07,
+  0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4,
+  0xa1, 0x1e, 0xca, 0x01, 0xd8, 0xe0, 0x09, 0x04, 0xb0, 0x00, 0x55, 0x90,
+  0x06, 0x60, 0x30, 0x84, 0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d,
+  0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b,
+  0x84, 0x03, 0x3b, 0xa4, 0x43, 0x38, 0xcc, 0x03, 0xb0, 0xc1, 0x1b, 0x0a,
+  0x60, 0x01, 0xaa, 0x20, 0x0d, 0x40, 0x61, 0x08, 0x87, 0x74, 0x90, 0x87,
+  0x36, 0x10, 0x87, 0x7a, 0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x03,
+  0x77, 0x78, 0x87, 0x36, 0x08, 0x07, 0x76, 0x48, 0x87, 0x70, 0x98, 0x07,
+  0x60, 0x83, 0x41, 0x18, 0xc0, 0x02, 0x54, 0x1b, 0x8c, 0x02, 0x01, 0x16,
+  0xa0, 0xda, 0x10, 0x26, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xc0, 0x1a,
+  0x00, 0x12, 0x50, 0x11, 0xe1, 0x00, 0x0f, 0xf0, 0x20, 0x0f, 0xef, 0x80,
+  0x0f, 0x6d, 0x60, 0x0e, 0xf5, 0xe0, 0x0e, 0xe3, 0xd0, 0x06, 0xe6, 0x00,
+  0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c,
+  0xd4, 0x43, 0x39, 0x00, 0x44, 0x3b, 0xa4, 0x83, 0x3b, 0xb4, 0x01, 0x3b,
+  0x94, 0xc3, 0x39, 0x84, 0x03, 0x3b, 0xb4, 0x81, 0x3d, 0x94, 0xc3, 0x38,
+  0xd0, 0xc3, 0x3b, 0xc8, 0x43, 0x1b, 0xdc, 0x43, 0x3a, 0x90, 0x03, 0x3d,
+  0xa0, 0x03, 0x10, 0x07, 0x72, 0x80, 0x07, 0xc0, 0xe0, 0x0e, 0xef, 0xd0,
+  0x06, 0xe2, 0x50, 0x0f, 0xe9, 0xc0, 0x0e, 0xf4, 0x90, 0x0e, 0xee, 0x30,
+  0x0f, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xe6, 0x20, 0x0f, 0xe1, 0xd0,
+  0x0e, 0xe5, 0xd0, 0x06, 0xf0, 0xf0, 0x0e, 0xe9, 0xe0, 0x0e, 0xf4, 0x50,
+  0x0e, 0xf2, 0xd0, 0x06, 0xe5, 0xc0, 0x0e, 0xe9, 0xd0, 0x0e, 0x00, 0x3d,
+  0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3, 0x3b, 0xb4, 0x81, 0x39,
+  0xc8, 0x43, 0x38, 0xb4, 0x43, 0x39, 0xb4, 0x01, 0x3c, 0xbc, 0x43, 0x3a,
+  0xb8, 0x03, 0x3d, 0x94, 0x83, 0x3c, 0xb4, 0x41, 0x39, 0xb0, 0x43, 0x3a,
+  0xb4, 0x43, 0x1b, 0xb8, 0xc3, 0x3b, 0xb8, 0x43, 0x1b, 0xb0, 0x43, 0x39,
+  0x84, 0x83, 0x39, 0x00, 0xf4, 0x20, 0x0f, 0xf5, 0x50, 0x0e, 0x00, 0xe1,
+  0x0e, 0xef, 0xd0, 0x06, 0xe9, 0xe0, 0x0e, 0xe6, 0x30, 0x0f, 0x6d, 0x60,
+  0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d,
+  0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8, 0xc3, 0x3b, 0xb4, 0x81, 0x3b,
+  0x84, 0x83, 0x3b, 0xcc, 0x43, 0x1b, 0x98, 0x03, 0x3c, 0xb4, 0x41, 0x3b,
+  0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50, 0x0f, 0xe5, 0x00,
+  0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x30, 0x0f, 0xe9, 0x70, 0x0e, 0xee, 0x50,
+  0x0e, 0xe4, 0xd0, 0x06, 0xfa, 0x50, 0x0e, 0xf2, 0xf0, 0x0e, 0xf3, 0xd0,
+  0x06, 0xe6, 0x00, 0x0f, 0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00,
+  0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc, 0x43, 0x1b,
+  0xd0, 0x83, 0x3c, 0x84, 0x03, 0x3c, 0xc0, 0x43, 0x3a, 0xb8, 0xc3, 0x39,
+  0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f, 0xf2, 0x50,
+  0x0f, 0xe5, 0x00, 0x10, 0xf3, 0x40, 0x0f, 0xe1, 0x30, 0x0e, 0xeb, 0xd0,
+  0x06, 0xf0, 0x20, 0x0f, 0xef, 0x40, 0x0f, 0xe5, 0x30, 0x0e, 0xf4, 0xf0,
+  0x0e, 0xf2, 0xd0, 0x06, 0xe2, 0x50, 0x0f, 0xe6, 0x60, 0x0e, 0xe5, 0x20,
+  0x0f, 0x6d, 0x30, 0x0f, 0xe9, 0xa0, 0x0f, 0xe5, 0x00, 0xe0, 0x01, 0x40,
+  0xd4, 0x83, 0x3b, 0xcc, 0x43, 0x38, 0x98, 0x43, 0x39, 0xb4, 0x81, 0x39,
+  0xc0, 0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20,
+  0x0f, 0xf5, 0x50, 0x0e, 0xc0, 0x86, 0xe4, 0x10, 0x80, 0x05, 0xa8, 0x82,
+  0x34, 0x00, 0x83, 0x0d, 0x06, 0xf2, 0xff, 0xff, 0xff, 0xff, 0x03, 0x20,
+  0x01, 0xd4, 0x06, 0x1f, 0x49, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x24,
+  0xa0, 0x22, 0xc2, 0x01, 0x1e, 0xe0, 0x41, 0x1e, 0xde, 0x01, 0x1f, 0xda,
+  0xc0, 0x1c, 0xea, 0xc1, 0x1d, 0xc6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x88, 0x76, 0x48, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87,
+  0x73, 0x08, 0x07, 0x76, 0x68, 0x03, 0x7b, 0x28, 0x87, 0x71, 0xa0, 0x87,
+  0x77, 0x90, 0x87, 0x36, 0xb8, 0x87, 0x74, 0x20, 0x07, 0x7a, 0x40, 0x07,
+  0x20, 0x0f, 0xec, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1c, 0xea,
+  0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6, 0x01, 0x20, 0xdc,
+  0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda,
+  0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda,
+  0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87,
+  0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87,
+  0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03,
+  0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07,
+  0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda,
+  0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda,
+  0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87,
+  0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87,
+  0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07,
+  0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde,
+  0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda,
+  0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0,
+  0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87,
+  0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87,
+  0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87,
+  0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00,
+  0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4,
+  0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda,
+  0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6,
+  0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87,
+  0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83,
+  0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca,
+  0x01, 0xd8, 0xa0, 0x28, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x6d, 0x00,
+  0xac, 0x01, 0x20, 0x01, 0xd5, 0x06, 0x63, 0x09, 0x80, 0x05, 0xa8, 0x36,
+  0x18, 0x8c, 0x00, 0x2c, 0x40, 0xb5, 0x41, 0x69, 0xfe, 0xff, 0xff, 0xff,
+  0x7f, 0x00, 0xda, 0x00, 0x58, 0x03, 0x40, 0x02, 0xaa, 0x0d, 0x86, 0xf3,
+  0xff, 0xff, 0xff, 0xff, 0x03, 0x20, 0x01, 0xd4, 0x86, 0xe9, 0xf9, 0xff,
+  0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x19, 0xdc, 0xe1, 0x1d, 0xda,
+  0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6,
+  0x01, 0xd8, 0x50, 0x40, 0x42, 0x90, 0x06, 0x60, 0xb0, 0x21, 0x8a, 0xfe,
+  0xff, 0xff, 0xff, 0x7f, 0x00, 0x94, 0xc1, 0x1d, 0xde, 0xa1, 0x0d, 0xc4,
+  0xa1, 0x1e, 0xd2, 0x81, 0x1d, 0xe8, 0x21, 0x1d, 0xdc, 0x61, 0x1e, 0x00,
+  0x00, 0x49, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x13, 0x8a, 0x40,
+  0x18, 0x88, 0x62, 0x82, 0x60, 0x1c, 0x13, 0x02, 0x64, 0x42, 0x90, 0x4c,
+  0x18, 0x94, 0x85, 0x99, 0x30, 0x34, 0x0b, 0x33, 0x21, 0x70, 0x26, 0x08,
+  0x0f, 0x34, 0x21, 0x88, 0x00, 0x89, 0x20, 0x00, 0x00, 0x51, 0x00, 0x00,
+  0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85, 0x04, 0x13, 0x23, 0xa4,
+  0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90, 0x14, 0x12, 0x4c, 0x8c,
+  0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xe0, 0xc1, 0x0c, 0xc0, 0x30, 0x02,
+  0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14, 0x51, 0xc2, 0xe4, 0xb3,
+  0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04, 0x34, 0x93, 0x84, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84, 0x41, 0x18, 0x46, 0x18,
+  0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e, 0xe4, 0xa1, 0x1e, 0xc6,
+  0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e, 0xc2, 0x81, 0x1d, 0xf4,
+  0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e, 0xd2, 0x01, 0x1f, 0x50,
+  0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe, 0xec, 0xbe, 0x1d, 0x21,
+  0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40, 0x84, 0xa3, 0xa4, 0x29,
+  0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8, 0x88, 0xf8, 0xed, 0xe1,
+  0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0x38, 0x4d, 0x9a, 0x22, 0x4a,
+  0x98, 0xfc, 0x7f, 0x22, 0xae, 0x89, 0x8a, 0x88, 0xdf, 0x1e, 0x7e, 0x20,
+  0x8a, 0x00, 0xec, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x26, 0xb8, 0x48,
+  0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2, 0x7f,
+  0x1a, 0x23, 0x00, 0x06, 0x11, 0x1c, 0xa1, 0x24, 0x41, 0x10, 0x08, 0x44,
+  0xb2, 0x34, 0x0f, 0x41, 0x65, 0x08, 0x02, 0x82, 0xa4, 0x42, 0x14, 0x45,
+  0x51, 0x10, 0x55, 0x06, 0x00, 0x00, 0xc8, 0x2a, 0x02, 0x00, 0x10, 0x36,
+  0x47, 0x10, 0x14, 0x41, 0x03, 0x68, 0x2b, 0x03, 0x50, 0x14, 0xd4, 0x15,
+  0xa3, 0x28, 0x00, 0x00, 0x00, 0xe8, 0x2b, 0x43, 0x51, 0x14, 0x14, 0x16,
+  0xa1, 0x28, 0x68, 0x9c, 0x23, 0x40, 0x8c, 0x10, 0x94, 0x73, 0x04, 0x60,
+  0x30, 0x8c, 0x20, 0x9c, 0x41, 0x59, 0xcc, 0xe6, 0x11, 0x4e, 0x0d, 0xd5,
+  0x00, 0xe0, 0xa4, 0xb4, 0x28, 0xe6, 0xf2, 0x08, 0x1a, 0xaa, 0x01, 0xc0,
+  0x49, 0xeb, 0x40, 0x40, 0x0a, 0x9c, 0x73, 0x04, 0xa0, 0x30, 0x8c, 0x30,
+  0x9c, 0xc1, 0x20, 0x42, 0x20, 0x0c, 0x22, 0x1c, 0xc2, 0x20, 0x42, 0x21,
+  0x8c, 0x00, 0x0c, 0x22, 0x00, 0xc2, 0x14, 0xc0, 0x30, 0x02, 0x71, 0x06,
+  0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e, 0xec, 0x80, 0x0e, 0xda,
+  0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c, 0xda, 0x80, 0x1e, 0xec,
+  0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d, 0xe0, 0xc0, 0x0d, 0xe0,
+  0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e, 0xd8, 0x21, 0x1c, 0xe8,
+  0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43, 0x1b, 0xc0, 0x83, 0x1e,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81, 0x1e, 0xe0, 0x41, 0x1b,
+  0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01, 0x1e, 0xb4, 0x41, 0x3a,
+  0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e,
+  0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d,
+  0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x39, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x39,
+  0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81, 0x1e,
+  0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01, 0x1d, 0xe8, 0xc1, 0x1c,
+  0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xcc, 0x81, 0x1c,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81, 0x3d,
+  0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d,
+  0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e,
+  0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81, 0x1d, 0xe8, 0x41, 0x1c,
+  0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xb4, 0x81, 0x3d,
+  0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e,
+  0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43, 0x1c, 0xe4, 0x81, 0x1c,
+  0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d,
+  0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d,
+  0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41, 0x1b, 0xd8, 0x43, 0x1d,
+  0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d,
+  0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d,
+  0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81, 0x1e, 0xc4, 0x01, 0x1c,
+  0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1d,
+  0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43, 0x42, 0x6c, 0x57, 0xfe,
+  0xb2, 0xfb, 0xfe, 0x45, 0x04, 0x18, 0x0c, 0xd1, 0x4c, 0x43, 0x22, 0x00,
+  0x82, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x60,
+  0x48, 0x04, 0xe1, 0x81, 0x84, 0x00, 0x83, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x00, 0x43, 0x22, 0x54, 0xa0, 0x28, 0x20, 0x00, 0x06, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0xf1, 0x02, 0x64, 0x01,
+  0x01, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xc0, 0x90, 0x88,
+  0x1d, 0x22, 0x0c, 0x08, 0x80, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+  0x00, 0x86, 0x44, 0xfd, 0x60, 0x6d, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x30, 0x24, 0x9a, 0x89, 0xa6, 0x03, 0x02, 0x60,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21, 0x11, 0x58, 0x64,
+  0x1f, 0x02, 0x0c, 0x04, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x0c,
+  0x89, 0xf2, 0x22, 0xb2, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00,
+  0x00, 0x00, 0x60, 0x48, 0xa4, 0x1a, 0x52, 0x18, 0x00, 0x01, 0x30, 0x00,
+  0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xc0, 0x90, 0x88, 0x37, 0xa6, 0x31,
+  0x00, 0x02, 0x60, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21,
+  0xd1, 0x7b, 0x4c, 0x61, 0x00, 0x04, 0xc0, 0x00, 0x00, 0x00, 0x20, 0x00,
+  0x00, 0x00, 0x00, 0x43, 0x22, 0x11, 0x09, 0x83, 0x34, 0x00, 0x02, 0xa0,
+  0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21, 0xd1, 0x98, 0x6c,
+  0x6b, 0x00, 0x04, 0x40, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+  0x12, 0x1b, 0x04, 0x8a, 0xaa, 0x1e, 0x00, 0x00, 0x64, 0x81, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c,
+  0x90, 0x8c, 0x09, 0x26, 0x47, 0xc6, 0x04, 0x43, 0x3a, 0x8b, 0xa0, 0x04,
+  0x0a, 0x61, 0x04, 0xa0, 0x0c, 0x0a, 0xa8, 0x20, 0x0a, 0xa3, 0x40, 0x0a,
+  0xa5, 0x60, 0x0a, 0xa7, 0x00, 0x03, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c,
+  0xe8, 0x1d, 0x01, 0x28, 0x84, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82,
+  0x29, 0x1c, 0x72, 0xc7, 0x12, 0x24, 0x01, 0x00, 0x00, 0xb1, 0x18, 0x00,
+  0x00, 0xa5, 0x00, 0x00, 0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c,
+  0x66, 0x14, 0x01, 0x3d, 0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80,
+  0x07, 0x79, 0x78, 0x07, 0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed,
+  0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d,
+  0xce, 0xa1, 0x1c, 0x66, 0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83,
+  0x1b, 0xcc, 0x03, 0x3d, 0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78,
+  0x8c, 0x74, 0x70, 0x07, 0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70,
+  0x07, 0x7a, 0x70, 0x03, 0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc,
+  0x11, 0x0e, 0xec, 0x90, 0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3,
+  0xf0, 0x0e, 0xf0, 0x50, 0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c,
+  0xd8, 0x21, 0x1d, 0xc2, 0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83,
+  0x3b, 0xd0, 0x43, 0x39, 0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03,
+  0x3b, 0xcc, 0xf0, 0x14, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68,
+  0x87, 0x72, 0x68, 0x07, 0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60,
+  0x07, 0x76, 0x28, 0x07, 0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80,
+  0x87, 0x5f, 0x08, 0x87, 0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98,
+  0x81, 0x2c, 0xee, 0xf0, 0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec,
+  0x30, 0x03, 0x62, 0xc8, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c,
+  0xe4, 0xa1, 0x1c, 0xdc, 0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d,
+  0xca, 0x61, 0x06, 0xd6, 0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43,
+  0x39, 0xc8, 0x43, 0x39, 0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03,
+  0x3b, 0x94, 0xc3, 0x2f, 0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03,
+  0x3b, 0xb0, 0xc3, 0x0c, 0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70,
+  0x83, 0x74, 0x68, 0x07, 0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0,
+  0x87, 0x19, 0xce, 0x53, 0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4,
+  0x90, 0x0e, 0xe3, 0x40, 0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33,
+  0x20, 0x28, 0x1d, 0xdc, 0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c,
+  0xdc, 0x81, 0x1e, 0xdc, 0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e,
+  0x66, 0x18, 0x51, 0x38, 0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50,
+  0x24, 0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78,
+  0x07, 0x78, 0x98, 0x51, 0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33,
+  0x1e, 0x6a, 0x1e, 0xca, 0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x7e, 0x01, 0x1e, 0xe4, 0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06,
+  0x54, 0x85, 0x83, 0x38, 0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43,
+  0x39, 0xfc, 0xc2, 0x3c, 0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3,
+  0x8c, 0xc5, 0x0a, 0x87, 0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec,
+  0xc0, 0x0e, 0xe5, 0x50, 0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e,
+  0xe4, 0xe1, 0x17, 0xd8, 0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19,
+  0x3b, 0xb0, 0x83, 0x3d, 0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43,
+  0x39, 0xcc, 0xc3, 0x3c, 0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03,
+  0x3c, 0xcc, 0x48, 0xb4, 0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08,
+  0x87, 0x71, 0x58, 0x87, 0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed,
+  0xe0, 0x06, 0xf0, 0x20, 0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6,
+  0x50, 0x0e, 0x6e, 0x10, 0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3,
+  0xe0, 0x06, 0xe9, 0xe0, 0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2,
+  0xec, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d,
+  0xe6, 0x21, 0x1d, 0xc4, 0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f,
+  0x66, 0x20, 0x9d, 0x3b, 0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83,
+  0x39, 0xcc, 0x58, 0xbc, 0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08,
+  0x07, 0x7a, 0x48, 0x87, 0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5,
+  0x10, 0x0e, 0xf0, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3,
+  0x90, 0x0e, 0xf4, 0x50, 0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90,
+  0x07, 0x37, 0x30, 0x87, 0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78,
+  0x07, 0x77, 0xf8, 0x85, 0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98,
+  0x07, 0x00, 0x00, 0x00, 0x00, 0x79, 0x20, 0x00, 0x00, 0x50, 0x01, 0x00,
+  0x00, 0x32, 0x9a, 0x08, 0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8,
+  0x11, 0x32, 0x64, 0xd4, 0xee, 0x80, 0x0d, 0x6a, 0x0c, 0x8b, 0x12, 0x07,
+  0xc5, 0xc6, 0x91, 0x41, 0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d,
+  0x45, 0x66, 0x20, 0xca, 0x23, 0x21, 0x54, 0xc1, 0x30, 0xca, 0xe2, 0x3c,
+  0xcf, 0x13, 0x5d, 0x4f, 0x60, 0x18, 0x88, 0x91, 0x18, 0x8b, 0x82, 0x11,
+  0x5e, 0xb1, 0x1c, 0x01, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65,
+  0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
+  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f,
+  0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61,
+  0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69,
+  0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61,
+  0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f, 0x75, 0x74, 0x70,
+  0x75, 0x74, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x74,
+  0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f,
+  0x64, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63,
+  0x74, 0x6f, 0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f,
+  0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x73, 0x64, 0x72, 0x5f, 0x77,
+  0x68, 0x69, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x74, 0x73, 0x63, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33,
+  0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33,
+  0x78, 0x33, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x59, 0x55, 0x56, 0x44,
+  0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c,
+  0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59,
+  0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x32, 0x64, 0x5f, 0x61, 0x72,
+  0x72, 0x61, 0x79, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c, 0x20, 0x73,
+  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x55, 0x56, 0x61,
+  0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x00, 0x00, 0xe4, 0xa8, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x82, 0x70, 0x06, 0xce, 0x08, 0x82,
+  0x1b, 0x9c, 0xc1, 0x08, 0xc2, 0x19, 0x3c, 0x23, 0x08, 0x67, 0x00, 0x8d,
+  0x20, 0x9c, 0x41, 0x34, 0x82, 0x10, 0x01, 0x23, 0x08, 0x67, 0x20, 0x8d,
+  0x20, 0x9c, 0xc1, 0x34, 0x82, 0x70, 0x06, 0xd4, 0x08, 0xc2, 0x19, 0x54,
+  0x23, 0x08, 0x67, 0x60, 0x8d, 0x20, 0x9c, 0xc1, 0x35, 0x82, 0x70, 0x06,
+  0xd8, 0x08, 0xc2, 0x19, 0x64, 0x23, 0x08, 0x67, 0xa0, 0x8d, 0x20, 0x9c,
+  0xc1, 0x36, 0x82, 0x70, 0x06, 0xdc, 0x08, 0xc2, 0x19, 0x74, 0x23, 0x08,
+  0x67, 0xe0, 0xcd, 0x30, 0xe0, 0x41, 0x90, 0x07, 0x33, 0x0c, 0x7a, 0x20,
+  0xec, 0xc1, 0x0c, 0xc1, 0x30, 0xc3, 0x80, 0x07, 0x78, 0xc0, 0x07, 0x33,
+  0x10, 0x84, 0x1e, 0xe8, 0x01, 0x1f, 0xcc, 0x10, 0x14, 0x33, 0x04, 0xc6,
+  0x0c, 0xc1, 0x31, 0x43, 0x81, 0xf0, 0x01, 0x1f, 0x24, 0xca, 0x0c, 0xc1,
+  0x2c, 0xcc, 0x80, 0xf0, 0xc1, 0xc2, 0x34, 0x89, 0xe2, 0x3c, 0x33, 0x24,
+  0x7a, 0x00, 0x45, 0x8c, 0x94, 0x28, 0xce, 0x34, 0x43, 0x82, 0x07, 0x10,
+  0xc5, 0x48, 0x49, 0xe5, 0x58, 0x33, 0xa0, 0x01, 0x1f, 0xec, 0x01, 0x1f,
+  0x70, 0xdd, 0x1e, 0xec, 0x01, 0x1f, 0x70, 0x1e, 0x28, 0xec, 0x01, 0x1f,
+  0x70, 0x5f, 0x28, 0xec, 0x01, 0x1f, 0x70, 0x60, 0x20, 0x0a, 0x7b, 0xc0,
+  0x07, 0x5c, 0x18, 0x8c, 0xc2, 0x1e, 0xf0, 0x01, 0x27, 0x06, 0xa4, 0xb0,
+  0x07, 0x7c, 0xc0, 0x8d, 0x41, 0x29, 0xec, 0x01, 0x1f, 0x70, 0x64, 0x30,
+  0x83, 0xe4, 0x07, 0x17, 0xf6, 0x07, 0x19, 0x1f, 0xe8, 0x81, 0xb6, 0xe1,
+  0x42, 0x19, 0xfc, 0x81, 0x19, 0xec, 0x41, 0x72, 0x06, 0x0e, 0x1a, 0xcc,
+  0xa0, 0xf0, 0x81, 0x28, 0xf0, 0x41, 0x1a, 0xa8, 0x81, 0x28, 0x9c, 0x02,
+  0x1f, 0xac, 0x01, 0x1b, 0xcc, 0x20, 0xed, 0xc1, 0x85, 0x99, 0x42, 0xa6,
+  0x07, 0x7a, 0xa0, 0x6d, 0xba, 0x50, 0x06, 0xa6, 0x60, 0x06, 0xa2, 0x90,
+  0xb4, 0x81, 0xe3, 0x06, 0x33, 0x28, 0xa8, 0xf0, 0x06, 0x19, 0x1f, 0xe8,
+  0x01, 0x1c, 0x24, 0x71, 0xe0, 0xc8, 0xc1, 0x0c, 0x4a, 0x2a, 0xbc, 0x41,
+  0xa6, 0x07, 0x7a, 0x00, 0x07, 0xc9, 0x1c, 0x38, 0x74, 0x30, 0x43, 0xa2,
+  0x0a, 0x75, 0x90, 0xf1, 0x81, 0x1e, 0x24, 0x76, 0xe0, 0xdc, 0xc1, 0x0c,
+  0x48, 0x2d, 0xd8, 0xc2, 0x2d, 0xe4, 0xc2, 0x2e, 0xf0, 0x42, 0x2f, 0xf8,
+  0xc2, 0x0c, 0x43, 0x1f, 0xd0, 0xc2, 0x2f, 0x54, 0x1a, 0x00, 0x62, 0x80,
+  0x06, 0x62, 0x20, 0x06, 0x62, 0xc0, 0x89, 0x81, 0x18, 0x88, 0x81, 0x18,
+  0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18, 0x88, 0x81, 0x18,
+  0x88, 0x81, 0x1b, 0xb8, 0x81, 0x45, 0x07, 0x7a, 0x60, 0x59, 0x96, 0x1e,
+  0x70, 0xa6, 0xc0, 0x0a, 0xac, 0x40, 0x37, 0x7e, 0x81, 0x12, 0x7e, 0x61,
+  0x0f, 0xf6, 0xa0, 0x0e, 0xf0, 0x20, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d,
+  0xcd, 0xae, 0xcd, 0xa5, 0xed, 0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c,
+  0x2d, 0xec, 0x6c, 0x6e, 0x14, 0x41, 0x15, 0x56, 0xe1, 0x14, 0x36, 0x36,
+  0xbb, 0x36, 0x97, 0x34, 0xb2, 0x32, 0x37, 0xba, 0x51, 0x02, 0x56, 0xb8,
+  0x25, 0x2c, 0x4d, 0xce, 0xc5, 0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d,
+  0x94, 0xa0, 0x15, 0x8e, 0x0a, 0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b,
+  0xab, 0x0b, 0x3b, 0x2b, 0xfb, 0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73,
+  0x1b, 0x25, 0x70, 0x85, 0x9b, 0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda,
+  0xe0, 0xd2, 0xd8, 0xca, 0xbe, 0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6,
+  0x46, 0x19, 0x5e, 0x01, 0x16, 0x62, 0xe1, 0x98, 0xb0, 0x34, 0x39, 0x17,
+  0x33, 0xb9, 0xb0, 0xb3, 0xb6, 0x32, 0x37, 0xba, 0x51, 0x82, 0x5f, 0x00,
+  0x00, 0xa9, 0x18, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72,
+  0x28, 0x87, 0x77, 0x80, 0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8,
+  0xc3, 0x38, 0xb0, 0x43, 0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1,
+  0x0d, 0xe8, 0x41, 0x1e, 0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21,
+  0x1d, 0xde, 0xc1, 0x1d, 0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f,
+  0xe1, 0x20, 0x0f, 0xe4, 0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e,
+  0xf4, 0xb0, 0x80, 0x81, 0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76,
+  0x78, 0x87, 0x71, 0x08, 0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c,
+  0xc3, 0x38, 0xb4, 0x01, 0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b,
+  0x1c, 0xd8, 0x21, 0x1c, 0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61,
+  0x1c, 0xdc, 0x20, 0x1c, 0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1,
+  0x1c, 0xc8, 0x61, 0x1c, 0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f,
+  0xf4, 0x20, 0x0f, 0xe1, 0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00,
+  0x00, 0xd1, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c,
+  0xa4, 0x83, 0x3b, 0x9c, 0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c,
+  0x94, 0x43, 0x38, 0x90, 0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x8c, 0x00, 0x00, 0x00, 0x13, 0x04, 0x41, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x0e, 0x00, 0x00, 0x00, 0xa4, 0xd5, 0xc0, 0x08, 0x00, 0x9d, 0x33,
+  0x00, 0x84, 0x8e, 0x00, 0xd0, 0x5b, 0x02, 0x45, 0x40, 0xf0, 0x58, 0x03,
+  0x10, 0x08, 0x73, 0x0c, 0x91, 0x1c, 0xc8, 0x01, 0x01, 0x23, 0x00, 0x33,
+  0x00, 0x63, 0x04, 0x20, 0x08, 0x82, 0xf8, 0x47, 0xc1, 0x0c, 0xc0, 0x0c,
+  0xc0, 0x1c, 0x44, 0x1e, 0xe4, 0x41, 0x1e, 0xe8, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0xf1, 0x30, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8,
+  0x90, 0x51, 0x16, 0x88, 0x49, 0x00, 0x00, 0x00, 0x00, 0x62, 0x80, 0x61,
+  0x96, 0x05, 0x00, 0x00, 0x00, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69,
+  0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x28, 0x53, 0x44,
+  0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65,
+  0x6e, 0x74, 0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+  0x65, 0x72, 0x73, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x74, 0x65, 0x78, 0x74, 0x75,
+  0x72, 0x65, 0x73, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73,
+  0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x34,
+  0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73,
+  0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x00,
+  0x00, 0x2b, 0x04, 0x73, 0x08, 0x87, 0x15, 0xc3, 0x39, 0x98, 0x83, 0x38,
+  0xac, 0x18, 0xd0, 0xc1, 0x1c, 0xc6, 0x61, 0xc5, 0x90, 0x0e, 0xe6, 0x40,
+  0x0e, 0x2b, 0x06, 0x75, 0x30, 0x87, 0x72, 0xd8, 0x20, 0xa0, 0xc3, 0x39,
+  0x6c, 0x10, 0xd4, 0x21, 0x1d, 0x36, 0x04, 0xe9, 0xb0, 0x61, 0x50, 0x07,
+  0x74, 0x38, 0x07, 0x00, 0x00, 0x23, 0x06, 0x8d, 0x11, 0x82, 0x60, 0xb0,
+  0x06, 0x71, 0x10, 0x3d, 0x94, 0xb3, 0x34, 0x86, 0xd1, 0x06, 0xa3, 0x09,
+  0x01, 0x30, 0x62, 0xe0, 0x18, 0x21, 0x08, 0x06, 0x69, 0x40, 0x07, 0x52,
+  0x64, 0xbd, 0x01, 0xd4, 0x3c, 0x08, 0xf2, 0x06, 0xa3, 0x09, 0x01, 0x30,
+  0x86, 0x10, 0x8c, 0xc1, 0x20, 0x03, 0x71, 0x30, 0x73, 0x0c, 0x81, 0x00,
+  0x8d, 0x18, 0x38, 0x46, 0x08, 0x82, 0x41, 0x1a, 0xe4, 0xc1, 0x65, 0x6d,
+  0x76, 0x50, 0x49, 0x54, 0xd3, 0xd0, 0xc1, 0x68, 0x42, 0x00, 0x8c, 0x21,
+  0x04, 0x68, 0x30, 0xc7, 0x40, 0x04, 0xd3, 0x75, 0xf1, 0x52, 0x10, 0x94,
+  0x41, 0x86, 0x00, 0xaa, 0x8c, 0x08, 0xc0, 0x7f, 0x23, 0x43, 0x18, 0xb8,
+  0x81, 0x1f, 0x5c, 0x10, 0x2f, 0x05, 0x41, 0x19, 0x64, 0x08, 0x2a, 0x6d,
+  0xc4, 0xe0, 0x38, 0x42, 0x10, 0x2c, 0xfc, 0xa3, 0x5b, 0x85, 0x22, 0xd8,
+  0x48, 0x61, 0x06, 0x73, 0x30, 0x0a, 0xa1, 0xe0, 0x5d, 0x10, 0x2f, 0x05,
+  0x41, 0x19, 0x64, 0x08, 0xb4, 0x6f, 0xc4, 0xe0, 0x38, 0x42, 0x10, 0x2c,
+  0xfc, 0xa3, 0x83, 0x05, 0x25, 0xd8, 0x48, 0xb1, 0x06, 0x78, 0x80, 0x0a,
+  0xa6, 0x20, 0x06, 0x17, 0xc4, 0x4b, 0x41, 0x50, 0x06, 0x19, 0x82, 0x8f,
+  0x0c, 0x46, 0x0c, 0x8e, 0x23, 0x04, 0xc1, 0xc2, 0x3f, 0xba, 0x5a, 0x78,
+  0x82, 0x39, 0x86, 0x6f, 0xe9, 0x83, 0x39, 0x86, 0xe0, 0x48, 0x83, 0x39,
+  0x86, 0x60, 0x48, 0x83, 0x11, 0x83, 0x03, 0x89, 0x41, 0xb0, 0xf0, 0x0f,
+  0xc9, 0x17, 0x02, 0x3a, 0xb0, 0xe0, 0x0e, 0xc4, 0x3f, 0x83, 0x80, 0x18,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x5b, 0x0a, 0xe0, 0x50, 0x07, 0x64, 0x1d,
+  0xb6, 0x14, 0xc2, 0xa1, 0x0e, 0xc8, 0x3a, 0x6c, 0x29, 0x8e, 0x43, 0x1d,
+  0x90, 0x75, 0xd8, 0x52, 0x30, 0x07, 0x3b, 0x20, 0xed, 0xb0, 0xa5, 0x88,
+  0x0e, 0x76, 0x40, 0xda, 0x61, 0x4b, 0x61, 0x1d, 0xec, 0x80, 0xb4, 0xc3,
+  0x96, 0x62, 0x3b, 0xd8, 0x01, 0x69, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x61, 0x20, 0x00, 0x00, 0xe5, 0x01, 0x00, 0x00, 0x13, 0x04, 0x6e,
+  0x10, 0x0b, 0x04, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x74, 0xce, 0x00,
+  0xd0, 0x5b, 0x02, 0x45, 0x40, 0xf0, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00,
+  0x74, 0xcf, 0x41, 0x44, 0x8f, 0xa3, 0x06, 0x63, 0x11, 0x40, 0x20, 0x1c,
+  0x04, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd, 0x18, 0x81, 0x2c, 0xba,
+  0x3d, 0x0d, 0x06, 0x63, 0x04, 0xb5, 0x5a, 0xab, 0xed, 0x37, 0x46, 0xd0,
+  0xc7, 0xa2, 0x8b, 0x7f, 0x63, 0x04, 0x6e, 0x1f, 0x8b, 0xb6, 0x2f, 0x8c,
+  0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81, 0x79, 0xaf, 0xab, 0xec,
+  0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18, 0x81, 0xdb, 0xc7, 0xa2,
+  0xed, 0x8d, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf, 0x18, 0x81, 0xce, 0x9a,
+  0x73, 0x08, 0x06, 0x23, 0x00, 0x63, 0x04, 0x20, 0x08, 0x82, 0x24, 0x18,
+  0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30, 0x03, 0x40, 0xc1, 0x0c,
+  0xc0, 0x0c, 0xc0, 0x1c, 0x84, 0x1d, 0xf0, 0x81, 0x1d, 0xfc, 0x01, 0x15,
+  0x33, 0x00, 0x23, 0x00, 0x33, 0x00, 0x63, 0x0d, 0x20, 0x08, 0x82, 0xf8,
+  0x07, 0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82, 0xf8, 0x37, 0xd6, 0xc0,
+  0xb6, 0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4, 0xc7, 0xb6, 0xf3, 0x4f,
+  0x7a, 0x63, 0x0d, 0x20, 0x08, 0xb2, 0xf5, 0x2f, 0x80, 0x20, 0xc8, 0xd6,
+  0xbf, 0x00, 0x82, 0x20, 0x5b, 0xff, 0xc2, 0x58, 0x03, 0x08, 0x82, 0x6b,
+  0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x80, 0x20, 0xb8, 0xe6, 0x60,
+  0x30, 0xd6, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01, 0x08, 0xd2, 0x6d, 0x0e,
+  0x06, 0x20, 0x48, 0xb7, 0x39, 0x18, 0x8c, 0x35, 0xac, 0x23, 0x1e, 0xb3,
+  0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x3a, 0xe2, 0x31, 0x0b, 0x06,
+  0x63, 0x0d, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80, 0x20, 0x8c, 0x87, 0x63,
+  0x00, 0x82, 0x30, 0x1e, 0x8e, 0xc1, 0x58, 0x83, 0x98, 0x8b, 0x69, 0xff,
+  0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab, 0x9a, 0xfb, 0xc2, 0x58,
+  0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d, 0x8a, 0xf9, 0xd7, 0xc2,
+  0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7, 0x69, 0xea, 0x0b, 0xad,
+  0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3, 0x1f, 0x00, 0x00, 0x00,
+  0x00, 0xf1, 0x30, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x22, 0x47, 0xc8,
+  0x90, 0x51, 0x0e, 0xc4, 0x1d, 0x00, 0x00, 0x00, 0x00, 0xd5, 0xf3, 0x00,
+  0x00, 0x5f, 0x5a, 0x54, 0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65,
+  0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d,
+  0x6e, 0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61,
+  0x72, 0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20,
+  0x54, 0x42, 0x41, 0x41, 0x00, 0x13, 0x84, 0x37, 0xf8, 0x26, 0x08, 0x6f,
+  0x00, 0x06, 0x13, 0x84, 0x37, 0x08, 0x83, 0x09, 0xc2, 0x1b, 0x88, 0xc1,
+  0x04, 0xe1, 0x0d, 0xc6, 0x60, 0x82, 0xf0, 0x06, 0x64, 0x30, 0x41, 0x78,
+  0x83, 0x32, 0x98, 0x20, 0xbc, 0x81, 0x19, 0x6c, 0x08, 0xc6, 0x61, 0xc3,
+  0x20, 0x0e, 0xec, 0x40, 0x0e, 0x1b, 0x06, 0xae, 0x1d, 0xc8, 0x61, 0x43,
+  0x14, 0x0e, 0xee, 0x40, 0x0e, 0xee, 0x50, 0x0e, 0xee, 0x60, 0x0e, 0xee,
+  0x70, 0x0e, 0xee, 0x80, 0x0e, 0xee, 0x90, 0x0e, 0xee, 0xa0, 0x0e, 0xee,
+  0xb0, 0x0e, 0x1b, 0x86, 0x77, 0x70, 0x07, 0x73, 0xd8, 0x30, 0xbc, 0x83,
+  0x3b, 0xac, 0xc3, 0x86, 0xe1, 0x1d, 0xdc, 0x01, 0x1d, 0x36, 0x0c, 0xef,
+  0xe0, 0x0e, 0xe9, 0xb0, 0x61, 0x78, 0x07, 0x77, 0x50, 0x87, 0x0d, 0xc3,
+  0x3b, 0xb8, 0x43, 0x39, 0x6c, 0x18, 0xde, 0xc1, 0x1d, 0xce, 0x61, 0xc3,
+  0xf0, 0x0e, 0xee, 0x40, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x18, 0xce,
+  0x20, 0x0e, 0x44, 0x81, 0x02, 0x60, 0x0c, 0x47, 0x04, 0x55, 0xe0, 0x1f,
+  0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0xac, 0xc1, 0x64, 0x06, 0x7b, 0x18,
+  0xd6, 0xa0, 0x0e, 0xec, 0x80, 0x02, 0x60, 0x8c, 0x18, 0x18, 0x47, 0x08,
+  0x82, 0x85, 0x7f, 0x8c, 0x01, 0x2b, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82,
+  0x60, 0xe1, 0x1f, 0x61, 0xe0, 0x0a, 0x01, 0x64, 0x01, 0x04, 0xfe, 0x23,
+  0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x61, 0xe0, 0x0a, 0x41, 0x65,
+  0x43, 0x24, 0xfe, 0x16, 0x05, 0xe1, 0x6f, 0x43, 0x40, 0xfe, 0x23, 0x06,
+  0xc6, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x63, 0x30, 0x0b, 0xc1, 0x88, 0xc1,
+  0x71, 0x84, 0x20, 0x58, 0xf8, 0x47, 0x18, 0xd4, 0x42, 0x30, 0x59, 0x30,
+  0x89, 0xff, 0x1c, 0x43, 0xb7, 0x84, 0xc2, 0x20, 0x43, 0xe0, 0xcd, 0x81,
+  0x0d, 0x01, 0xf9, 0x0f, 0x32, 0x04, 0x60, 0x40, 0x07, 0x83, 0x0c, 0x01,
+  0x1f, 0xd0, 0xc1, 0x2c, 0x81, 0x30, 0x50, 0x11, 0x08, 0x81, 0x3e, 0x00,
+  0x7b, 0x18, 0xfa, 0xe0, 0x14, 0x6c, 0x81, 0x02, 0x60, 0x0c, 0x47, 0x04,
+  0x6c, 0xe0, 0xf8, 0xc7, 0x2c, 0xc3, 0x40, 0x04, 0x83, 0x0c, 0x44, 0x1a,
+  0xf0, 0xc1, 0x1e, 0x86, 0x50, 0x58, 0x05, 0x57, 0xa0, 0x00, 0x18, 0x7b,
+  0x18, 0x46, 0xa1, 0x15, 0x5e, 0x81, 0x02, 0x60, 0x8c, 0x18, 0x28, 0x49,
+  0x0c, 0x82, 0x85, 0x7f, 0x7c, 0xe7, 0x50, 0x74, 0xc7, 0x10, 0x0c, 0x32,
+  0x04, 0x6c, 0x00, 0x0a, 0x83, 0x0c, 0xc1, 0x02, 0x0a, 0xb3, 0x04, 0xc4,
+  0x40, 0x45, 0x20, 0x0c, 0x98, 0x30, 0x1c, 0x11, 0x06, 0x7c, 0x10, 0xf8,
+  0xc7, 0x2c, 0x43, 0x31, 0x05, 0x7b, 0x18, 0x54, 0x81, 0x16, 0xc8, 0x81,
+  0x02, 0x60, 0x0c, 0x47, 0x04, 0x7f, 0x10, 0xf8, 0xc7, 0x2c, 0x83, 0x71,
+  0x04, 0x83, 0x0c, 0x85, 0x1d, 0xa4, 0xc2, 0x1e, 0x06, 0x57, 0xc0, 0x85,
+  0x72, 0xa0, 0x00, 0x18, 0x73, 0x0c, 0x76, 0x10, 0xe8, 0xc2, 0x20, 0x43,
+  0x70, 0x07, 0xac, 0x60, 0x41, 0x21, 0xfe, 0x83, 0x0c, 0x41, 0x1e, 0xb4,
+  0xc2, 0x2c, 0x41, 0x1b, 0xec, 0x61, 0xa0, 0x05, 0x5f, 0x60, 0x07, 0x0a,
+  0x80, 0xb1, 0x87, 0xc1, 0x16, 0xc0, 0xa1, 0x1d, 0x28, 0x00, 0xc6, 0x20,
+  0x03, 0x14, 0x0a, 0xb2, 0x30, 0x62, 0x50, 0x1c, 0x21, 0x08, 0x06, 0x5b,
+  0x3f, 0x10, 0xb3, 0x0c, 0x88, 0x14, 0x8c, 0x21, 0x48, 0xe4, 0x30, 0x1c,
+  0x11, 0xb4, 0x82, 0xe2, 0x1f, 0xb3, 0x0c, 0x4a, 0x12, 0x98, 0xd0, 0x0a,
+  0xe2, 0x3f, 0x4b, 0xb0, 0xd8, 0xd0, 0x0a, 0xe0, 0x3f, 0x62, 0x60, 0x1c,
+  0x21, 0x08, 0x16, 0xfe, 0x81, 0x8d, 0x44, 0x60, 0x81, 0x2b, 0x88, 0xff,
+  0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x65, 0x12, 0x81, 0x2b,
+  0xcc, 0x12, 0x2c, 0x03, 0x15, 0x80, 0x92, 0x08, 0xca, 0x1c, 0x83, 0x2a,
+  0x04, 0xec, 0x30, 0x86, 0xb0, 0x85, 0xc3, 0x70, 0x44, 0x60, 0x0b, 0x8a,
+  0x7f, 0xcc, 0x32, 0x34, 0x4c, 0x60, 0x82, 0x2d, 0x88, 0xff, 0x2c, 0x81,
+  0x63, 0x83, 0x2d, 0x80, 0xff, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8,
+  0x07, 0xc6, 0x12, 0x81, 0x05, 0xb7, 0x20, 0xfe, 0x23, 0x06, 0xc7, 0x11,
+  0x82, 0x60, 0xe1, 0x1f, 0xd6, 0x4b, 0x04, 0xb7, 0x30, 0x4b, 0xe0, 0x0c,
+  0x54, 0x00, 0x0a, 0x23, 0x34, 0x73, 0x0c, 0x49, 0x90, 0x0e, 0x63, 0x08,
+  0x64, 0x90, 0x0e, 0xc3, 0x11, 0xc1, 0x2f, 0x28, 0xfe, 0x31, 0xcb, 0x00,
+  0x3d, 0x81, 0x09, 0xbf, 0x20, 0xfe, 0xb3, 0x04, 0x91, 0x0d, 0xbf, 0x00,
+  0xfe, 0x23, 0x06, 0xc6, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x58, 0x4d, 0x04,
+  0x16, 0x80, 0x83, 0xf8, 0x8f, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f,
+  0x58, 0x38, 0x11, 0x80, 0xc3, 0x2c, 0x41, 0x34, 0x50, 0x01, 0x28, 0x8f,
+  0x00, 0xcd, 0x31, 0x24, 0x41, 0x3c, 0xcc, 0x12, 0x48, 0x03, 0x15, 0x81,
+  0x10, 0xe9, 0xc1, 0x31, 0xc8, 0x10, 0xfc, 0x82, 0x3c, 0xcc, 0x31, 0xf4,
+  0x02, 0x18, 0x84, 0xc4, 0x20, 0x43, 0xe0, 0x0b, 0xf3, 0x60, 0x43, 0x20,
+  0xfe, 0x83, 0x0c, 0x01, 0x38, 0xd0, 0xc3, 0x2c, 0x41, 0x1b, 0x0c, 0x47,
+  0xcc, 0x82, 0x39, 0x04, 0xfe, 0x31, 0xcb, 0x40, 0x81, 0x41, 0x30, 0xc8,
+  0x40, 0x07, 0xe5, 0x80, 0x0f, 0x7b, 0x18, 0xfa, 0xe1, 0x24, 0x6a, 0x82,
+  0x02, 0x60, 0xec, 0x61, 0xf8, 0x87, 0x94, 0xb0, 0x09, 0x0a, 0x80, 0x31,
+  0xc7, 0x70, 0x0e, 0xc1, 0x4a, 0x0c, 0x32, 0x04, 0xe8, 0xd0, 0x0f, 0x16,
+  0x1c, 0xe2, 0x3f, 0xc8, 0x10, 0xa8, 0x83, 0x3f, 0x8c, 0x18, 0x14, 0x47,
+  0x08, 0x82, 0xc1, 0x96, 0x16, 0xc7, 0x2c, 0xc3, 0x57, 0x05, 0x63, 0x08,
+  0x03, 0x4c, 0x0c, 0x47, 0x04, 0xff, 0xa0, 0xf8, 0xc7, 0x2c, 0xc3, 0x65,
+  0x05, 0x26, 0xfc, 0x83, 0xf8, 0xcf, 0x12, 0x60, 0x23, 0x06, 0xc6, 0x11,
+  0x82, 0x60, 0xe1, 0x1f, 0x98, 0x5b, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82,
+  0x60, 0xe1, 0x1f, 0x16, 0x5c, 0x04, 0x20, 0x61, 0x01, 0x48, 0x88, 0xbf,
+  0x05, 0x20, 0x01, 0xfe, 0xb3, 0x04, 0xd8, 0x40, 0x05, 0xa0, 0x58, 0xc2,
+  0x35, 0xc7, 0x20, 0x0f, 0x01, 0x4e, 0x8c, 0x21, 0x30, 0x2d, 0x31, 0x1c,
+  0x11, 0xa0, 0x84, 0xe2, 0x1f, 0xb3, 0x0c, 0x5a, 0x16, 0x98, 0x80, 0x12,
+  0xe2, 0x3f, 0x4b, 0xb0, 0x8d, 0x18, 0x18, 0x47, 0x08, 0x82, 0x85, 0x7f,
+  0x60, 0x77, 0x31, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x58,
+  0x79, 0x11, 0xa4, 0x84, 0x05, 0x29, 0x21, 0xfe, 0x16, 0xa4, 0x04, 0xf8,
+  0xcf, 0x12, 0x6c, 0x03, 0x15, 0x80, 0x92, 0x09, 0xda, 0x1c, 0x43, 0x12,
+  0xd4, 0xc4, 0x18, 0x42, 0x55, 0x13, 0xc3, 0x11, 0x41, 0x4c, 0x28, 0xfe,
+  0x31, 0xcb, 0xd0, 0x71, 0x81, 0x09, 0x31, 0x21, 0xfe, 0xb3, 0x04, 0xde,
+  0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0x06, 0x1a, 0xc3, 0x88,
+  0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x25, 0x1a, 0x81, 0x4c, 0x58,
+  0x20, 0x13, 0xe2, 0x6f, 0x81, 0x4c, 0x80, 0xff, 0x2c, 0x81, 0x37, 0x50,
+  0x01, 0x28, 0x9c, 0xd0, 0xcd, 0x31, 0x24, 0x41, 0x4f, 0x8c, 0x18, 0x20,
+  0x47, 0x08, 0x82, 0x85, 0x7f, 0x50, 0xa8, 0x11, 0x98, 0x04, 0x49, 0x0c,
+  0x32, 0x04, 0x28, 0xc1, 0x13, 0xb3, 0x04, 0xdf, 0x40, 0x45, 0xe0, 0x07,
+  0x94, 0xe0, 0x0d, 0x32, 0x04, 0x2d, 0xe1, 0x13, 0xb3, 0x04, 0x6d, 0x30,
+  0xcb, 0x10, 0x06, 0x6d, 0xc0, 0x0f, 0x83, 0x0c, 0xbd, 0xe0, 0x12, 0x61,
+  0x31, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0xd1, 0xa5, 0x46, 0x20,
+  0x12, 0x73, 0x0c, 0x2b, 0x11, 0xc4, 0xc5, 0x88, 0xc1, 0x71, 0x84, 0x20,
+  0x58, 0xf8, 0x47, 0xb7, 0x1a, 0xc3, 0x48, 0xcc, 0x31, 0x08, 0xc1, 0x59,
+  0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x74, 0xad, 0x51, 0x90,
+  0xc4, 0x1c, 0x83, 0x10, 0xa0, 0xc5, 0x20, 0x43, 0x20, 0x13, 0x66, 0x31,
+  0xc8, 0x10, 0x94, 0x83, 0x59, 0xec, 0x61, 0x70, 0x0b, 0xbc, 0x30, 0x0d,
+  0x0a, 0x80, 0xb1, 0x87, 0x01, 0x2e, 0xf4, 0xe2, 0x34, 0x28, 0x00, 0xc6,
+  0x1c, 0x03, 0x4e, 0x04, 0x7c, 0x31, 0xc8, 0x10, 0xe4, 0x84, 0x5b, 0x58,
+  0x90, 0x88, 0xff, 0x20, 0x43, 0xb0, 0x13, 0x6f, 0x31, 0x62, 0x50, 0x1c,
+  0x21, 0x08, 0x06, 0x9b, 0x6e, 0x1c, 0xb3, 0x0c, 0x6c, 0x20, 0x06, 0xc1,
+  0x18, 0xc2, 0x10, 0x1a, 0xc3, 0x11, 0x01, 0x5c, 0x28, 0xfe, 0x31, 0xcb,
+  0x40, 0x06, 0x63, 0x10, 0x98, 0x00, 0x17, 0xe2, 0x3f, 0x4b, 0x50, 0x06,
+  0x23, 0x06, 0xc6, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0xd8, 0x6f, 0x0c, 0x23,
+  0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x56, 0x78, 0x04, 0x71, 0x61,
+  0x41, 0x5c, 0x88, 0xbf, 0x05, 0x71, 0x01, 0xfe, 0xb3, 0x04, 0x65, 0x30,
+  0x50, 0x01, 0x28, 0x63, 0x20, 0x90, 0xc1, 0x1c, 0xc3, 0x58, 0x04, 0xa9,
+  0x31, 0x86, 0xc0, 0xf8, 0xc5, 0x70, 0x44, 0x90, 0x17, 0x8a, 0x7f, 0xcc,
+  0x32, 0x9c, 0x81, 0x19, 0x04, 0x26, 0xe4, 0x85, 0xf8, 0xcf, 0x12, 0xa0,
+  0xc1, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0x86, 0x1e, 0xc3,
+  0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0xa5, 0x1e, 0x81, 0x5e,
+  0x58, 0xa0, 0x17, 0xe2, 0x6f, 0x81, 0x5e, 0x80, 0xff, 0x2c, 0x01, 0x1a,
+  0x0c, 0x54, 0x00, 0x8a, 0x19, 0x08, 0x67, 0x30, 0xc7, 0x90, 0x04, 0xa6,
+  0x31, 0x86, 0x50, 0x99, 0xc6, 0x70, 0x44, 0x20, 0x1a, 0x8a, 0x7f, 0xcc,
+  0x32, 0xa8, 0x41, 0x1a, 0x04, 0x26, 0x88, 0x86, 0xf8, 0xcf, 0x12, 0xac,
+  0xc1, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0x16, 0x1f, 0xc3,
+  0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x35, 0x1f, 0xc1, 0x68,
+  0x58, 0x30, 0x1a, 0xe2, 0x6f, 0xc1, 0x68, 0x80, 0xff, 0x2c, 0xc1, 0x1a,
+  0x0c, 0x54, 0x00, 0x4a, 0x1a, 0x08, 0x6a, 0x30, 0xc7, 0x90, 0x04, 0xae,
+  0x31, 0x62, 0x80, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xe5, 0x47, 0x70,
+  0x17, 0x75, 0x31, 0xc8, 0x10, 0xe4, 0x45, 0x6b, 0xcc, 0x12, 0xb0, 0xc1,
+  0x40, 0x45, 0xe0, 0x07, 0x61, 0x20, 0xac, 0xc1, 0x20, 0x43, 0xe0, 0x17,
+  0xaf, 0x31, 0x4b, 0xd0, 0x06, 0x03, 0x2d, 0x01, 0x8f, 0x18, 0x3c, 0x22,
+  0xf1, 0xc8, 0x27, 0x0b, 0x6c, 0xc0, 0x23, 0x60, 0x30, 0xd0, 0x12, 0xa0,
+  0x88, 0xa1, 0x17, 0x92, 0x39, 0x7c, 0x04, 0x1b, 0xf0, 0x0b, 0x18, 0x0c,
+  0x32, 0x04, 0x42, 0x6c, 0x64, 0x10, 0x10, 0x03, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0x5b, 0x86, 0x20, 0x78, 0x87, 0x2d, 0x83, 0x11, 0xc0, 0xc3, 0x96,
+  0x21, 0x0b, 0xe2, 0x61, 0xcb, 0xe0, 0x05, 0xf2, 0xb0, 0x65, 0x00, 0x83,
+  0x60, 0x1e, 0xb6, 0x0c, 0x69, 0x10, 0xd0, 0xc3, 0x96, 0xc1, 0x0d, 0x82,
+  0x7a, 0xd8, 0x32, 0xd4, 0x41, 0x60, 0x0f, 0x5b, 0x86, 0x3b, 0x08, 0xea,
+  0x61, 0xcb, 0xb0, 0x0e, 0x81, 0x3d, 0x6c, 0x19, 0xda, 0x21, 0xa8, 0x87,
+  0x2d, 0x43, 0x5a, 0x04, 0xf6, 0xb0, 0x65, 0x58, 0x8b, 0xa0, 0x1e, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0x73, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00,
+  0x00, 0x74, 0xce, 0x00, 0xd0, 0x5b, 0x02, 0x45, 0x40, 0xf0, 0x58, 0x03,
+  0x10, 0x08, 0x23, 0x00, 0x74, 0xcf, 0x41, 0x44, 0x8f, 0xd3, 0x06, 0x04,
+  0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20,
+  0x08, 0x06, 0x23, 0x00, 0x14, 0xcc, 0x00, 0xcc, 0x00, 0x50, 0x31, 0x03,
+  0x30, 0xd6, 0xc0, 0xb2, 0x67, 0x28, 0x7f, 0xa8, 0x5f, 0xc6, 0xea, 0x97,
+  0x9f, 0xba, 0x38, 0x7b, 0x63, 0x0d, 0x7a, 0x0d, 0xee, 0xb8, 0xa7, 0xe2,
+  0xb9, 0x6d, 0x7f, 0x6f, 0x9f, 0xd2, 0xa3, 0x37, 0xd6, 0xb0, 0xce, 0x31,
+  0x8b, 0x7a, 0x69, 0x08, 0xa3, 0xbb, 0x77, 0xb7, 0xb1, 0x6a, 0x7f, 0x63,
+  0x0d, 0x62, 0x2e, 0xa6, 0xfd, 0x07, 0x96, 0x3c, 0x1b, 0xff, 0xc2, 0x98,
+  0xae, 0x6a, 0xee, 0x0b, 0x63, 0x0d, 0xff, 0x4c, 0xfa, 0xbf, 0x2f, 0xd0,
+  0x35, 0x28, 0xe6, 0x5f, 0x0b, 0xc7, 0x31, 0xe8, 0x0b, 0x63, 0x0d, 0x73,
+  0xdf, 0xa6, 0xa9, 0x2f, 0xb4, 0x6e, 0xc8, 0xf3, 0xbe, 0xc0, 0xe7, 0xac,
+  0x8f, 0x7f, 0x00, 0x00, 0x00, 0x83, 0x0c, 0xd7, 0xd1, 0x0c, 0x47, 0x58,
+  0x4d, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0xcc, 0x31, 0x24, 0x96, 0x18,
+  0x0c, 0x32, 0x04, 0x4a, 0x64, 0xc1, 0x26, 0xfe, 0x83, 0x0c, 0x01, 0x23,
+  0xcd, 0x12, 0x24, 0xc3, 0x11, 0x5b, 0x14, 0xf8, 0xc7, 0x2c, 0xc3, 0x90,
+  0x04, 0xc3, 0x11, 0x9d, 0x14, 0xf8, 0xc7, 0x2c, 0x03, 0x51, 0x04, 0x23,
+  0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x5d, 0x28, 0x7c, 0xce, 0x1c,
+  0x43, 0x14, 0xa4, 0xc1, 0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x47,
+  0x37, 0x0a, 0x61, 0xf0, 0xcc, 0x31, 0x08, 0x01, 0x37, 0x62, 0x70, 0x1c,
+  0x21, 0x08, 0x16, 0xfe, 0xd1, 0x95, 0xc2, 0x18, 0x40, 0x73, 0x0c, 0x42,
+  0xd0, 0xcd, 0x12, 0x14, 0x03, 0x15, 0x81, 0x40, 0x70, 0xc3, 0x18, 0x42,
+  0xf0, 0x06, 0x63, 0x08, 0x42, 0x18, 0x8c, 0x21, 0x0c, 0x61, 0x30, 0x62,
+  0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0xa5, 0x82, 0x10, 0x8c, 0x18,
+  0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x58, 0xaa, 0x40, 0x04, 0xc3, 0x11,
+  0x81, 0x27, 0xf8, 0xc7, 0x2c, 0x83, 0x71, 0x04, 0x83, 0x0c, 0x87, 0x47,
+  0x06, 0x36, 0xa8, 0x81, 0xf8, 0x5b, 0x30, 0x06, 0xe0, 0x6f, 0xc5, 0x1a,
+  0x88, 0xbf, 0x05, 0x65, 0x00, 0xfe, 0x36, 0x04, 0xe4, 0x3f, 0xc7, 0x20,
+  0x06, 0xc1, 0x1e, 0x0c, 0x32, 0x04, 0x63, 0xa0, 0x06, 0x16, 0x20, 0xe2,
+  0x3f, 0xc8, 0x10, 0x94, 0xc1, 0x1a, 0xcc, 0x12, 0x1c, 0x03, 0x15, 0x81,
+  0x60, 0x88, 0x41, 0x31, 0xcb, 0x80, 0x24, 0xd9, 0x20, 0x43, 0x90, 0x06,
+  0x6f, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0xd1, 0xe9, 0x42,
+  0x40, 0x06, 0x73, 0x0c, 0x6a, 0x10, 0x88, 0xc2, 0x88, 0xc1, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0x47, 0xc7, 0x0b, 0x43, 0x19, 0xcc, 0x31, 0x08, 0x41,
+  0x1d, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x74, 0xbe, 0x50,
+  0x98, 0xc1, 0x1c, 0x83, 0x10, 0xd8, 0xc1, 0x2c, 0x41, 0x32, 0x50, 0x12,
+  0x90, 0x42, 0xe0, 0x0a, 0x82, 0x80, 0x40, 0xc7, 0x20, 0x43, 0x10, 0x07,
+  0x77, 0x90, 0x01, 0x00, 0x00, 0x71, 0x20, 0x00, 0x00, 0x04, 0x00, 0x00,
+  0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xc0, 0x09, 0x18, 0xe0, 0xac,
+  0x80, 0x07, 0xb5, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x0c, 0x00,
+  0x00, 0x6d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0x68, 0x03, 0x00, 0x00,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00,
+  0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+  0x00, 0xa8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x01, 0x00,
+  0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x67, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x24, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0x48, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0x5c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x6c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0x7d, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0x93, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+  0x00, 0xa0, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x30, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xb9, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0xca, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xdc, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0xef, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xef, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x21, 0x00, 0x00,
+  0x00, 0x02, 0x01, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x23, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00,
+  0x00, 0x23, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x0c, 0x00,
+  0x00, 0x5d, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94, 0xe7, 0x02, 0x00, 0x00,
+  0x00, 0x53, 0x44, 0x4c, 0x5f, 0x59, 0x55, 0x56, 0x5f, 0x66, 0x72, 0x61,
+  0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x5a, 0x31, 0x34, 0x47, 0x65, 0x74,
+  0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x44,
+  0x76, 0x34, 0x5f, 0x66, 0x52, 0x55, 0x31, 0x31, 0x4d, 0x54, 0x4c, 0x63,
+  0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x4b, 0x31, 0x35, 0x53, 0x68,
+  0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,
+  0x73, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6c,
+  0x61, 0x6d, 0x70, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x66, 0x33,
+  0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x61,
+  0x62, 0x73, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f,
+  0x6e, 0x76, 0x65, 0x72, 0x74, 0x2e, 0x75, 0x2e, 0x69, 0x31, 0x2e, 0x66,
+  0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x64, 0x6f, 0x74, 0x2e,
+  0x76, 0x33, 0x66, 0x33, 0x32, 0x5f, 0x5a, 0x31, 0x32, 0x41, 0x70, 0x70,
+  0x6c, 0x79, 0x54, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x44, 0x76, 0x33,
+  0x5f, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78, 0x2e, 0x66, 0x33, 0x32, 0x61,
+  0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x6f, 0x77, 0x2e,
+  0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61,
+  0x78, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73,
+  0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72,
+  0x65, 0x5f, 0x32, 0x64, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x2e, 0x76,
+  0x34, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70,
+  0x6c, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32,
+  0x64, 0x2e, 0x76, 0x34, 0x66, 0x33, 0x32, 0x33, 0x32, 0x30, 0x32, 0x33,
+  0x2e, 0x34, 0x30, 0x34, 0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70,
+  0x70, 0x6c, 0x65, 0x2d, 0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30,
+  0x2e, 0x30, 0x2d, 0x73, 0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xc0, 0x17, 0x0b, 0x00, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0xa4, 0x22, 0x00, 0x00, 0xff, 0xff, 0xff,
+  0xff, 0x42, 0x43, 0xc0, 0xde, 0x35, 0x14, 0x00, 0x00, 0x03, 0x00, 0x00,
+  0x00, 0x62, 0x0c, 0x30, 0x24, 0x80, 0x10, 0x05, 0xc8, 0x14, 0x00, 0x00,
+  0x00, 0x21, 0x0c, 0x00, 0x00, 0xe1, 0x07, 0x00, 0x00, 0x0b, 0x02, 0x21,
+  0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x07, 0x81, 0x23,
+  0x91, 0x41, 0xc8, 0x04, 0x49, 0x06, 0x10, 0x32, 0x39, 0x92, 0x01, 0x84,
+  0x0c, 0x25, 0x05, 0x08, 0x19, 0x1e, 0x04, 0x8b, 0x62, 0x80, 0x18, 0x45,
+  0x02, 0x42, 0x92, 0x0b, 0x42, 0xc4, 0x10, 0x32, 0x14, 0x38, 0x08, 0x18,
+  0x4b, 0x0a, 0x32, 0x62, 0x88, 0x48, 0x90, 0x14, 0x20, 0x43, 0x46, 0x88,
+  0xa5, 0x00, 0x19, 0x32, 0x42, 0x04, 0x49, 0x0e, 0x90, 0x11, 0x23, 0xc4,
+  0x50, 0x41, 0x51, 0x81, 0x8c, 0xe1, 0x83, 0xe5, 0x8a, 0x04, 0x31, 0x46,
+  0x06, 0x51, 0x18, 0x00, 0x00, 0x6d, 0x01, 0x00, 0x00, 0x1b, 0xc2, 0x24,
+  0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x58, 0x03, 0x40, 0x02, 0x2a, 0x22,
+  0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1, 0x1d, 0xf0, 0xa1, 0x0d, 0xcc, 0xa1,
+  0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21,
+  0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80,
+  0x68, 0x87, 0x74, 0x70, 0x87, 0x36, 0x60, 0x87, 0x72, 0x38, 0x87, 0x70,
+  0x60, 0x87, 0x36, 0xb0, 0x87, 0x72, 0x18, 0x07, 0x7a, 0x78, 0x07, 0x79,
+  0x68, 0x83, 0x7b, 0x48, 0x07, 0x72, 0xa0, 0x07, 0x74, 0x00, 0xe2, 0x40,
+  0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1, 0x1d, 0xda, 0x40, 0x1c, 0xea, 0x21,
+  0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1, 0x1d, 0xe6, 0x01, 0x20, 0xdc, 0xe1,
+  0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21, 0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00,
+  0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81, 0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0,
+  0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
+  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x30, 0x07, 0x79, 0x08, 0x87, 0x76,
+  0x28, 0x87, 0x36, 0x80, 0x87, 0x77, 0x48, 0x07, 0x77, 0xa0, 0x87, 0x72,
+  0x90, 0x87, 0x36, 0x28, 0x07, 0x76, 0x48, 0x87, 0x76, 0x68, 0x03, 0x77,
+  0x78, 0x07, 0x77, 0x68, 0x03, 0x76, 0x28, 0x87, 0x70, 0x30, 0x07, 0x80,
+  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x20,
+  0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1, 0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0,
+  0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01, 0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72,
+  0x00, 0x08, 0x77, 0x78, 0x87, 0x36, 0x70, 0x87, 0x70, 0x70, 0x87, 0x79,
+  0x68, 0x03, 0x73, 0x80, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74,
+  0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1,
+  0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1, 0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40,
+  0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61, 0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1,
+  0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a,
+  0x28, 0x07, 0x80, 0x70, 0x87, 0x77, 0x68, 0x03, 0x7a, 0x90, 0x87, 0x70,
+  0x80, 0x07, 0x78, 0x48, 0x07, 0x77, 0x38, 0x87, 0x36, 0x68, 0x87, 0x70,
+  0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62,
+  0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61, 0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1,
+  0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81, 0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40,
+  0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21,
+  0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c, 0x00, 0x88, 0x7a, 0x70, 0x87, 0x79,
+  0x08, 0x07, 0x73, 0x28, 0x87, 0x36, 0x30, 0x07, 0x78, 0x68, 0x83, 0x76,
+  0x08, 0x07, 0x7a, 0x40, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0xd8, 0xe0, 0x09, 0x04, 0xb0, 0x00, 0x55, 0x90, 0x06, 0x60, 0x30, 0x84,
+  0x43, 0x3a, 0xc8, 0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83, 0x39, 0x94,
+  0x83, 0x3c, 0xb4, 0x81, 0x3b, 0xbc, 0x43, 0x1b, 0x84, 0x03, 0x3b, 0xa4,
+  0x43, 0x38, 0xcc, 0x03, 0xb0, 0xc1, 0x1b, 0x0a, 0x60, 0x01, 0xaa, 0x20,
+  0x0d, 0x40, 0x61, 0x08, 0x87, 0x74, 0x90, 0x87, 0x36, 0x10, 0x87, 0x7a,
+  0x30, 0x07, 0x73, 0x28, 0x07, 0x79, 0x68, 0x03, 0x77, 0x78, 0x87, 0x36,
+  0x08, 0x07, 0x76, 0x48, 0x87, 0x70, 0x98, 0x07, 0x60, 0x83, 0x41, 0x20,
+  0xc0, 0x02, 0x54, 0x1b, 0xc2, 0xa4, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01,
+  0x58, 0x03, 0x40, 0x02, 0x2a, 0x22, 0x1c, 0xe0, 0x01, 0x1e, 0xe4, 0xe1,
+  0x1d, 0xf0, 0xa1, 0x0d, 0xcc, 0xa1, 0x1e, 0xdc, 0x61, 0x1c, 0xda, 0xc0,
+  0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01, 0x1d, 0x00, 0x7a,
+  0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x68, 0x87, 0x74, 0x70, 0x87, 0x36,
+  0x60, 0x87, 0x72, 0x38, 0x87, 0x70, 0x60, 0x87, 0x36, 0xb0, 0x87, 0x72,
+  0x18, 0x07, 0x7a, 0x78, 0x07, 0x79, 0x68, 0x83, 0x7b, 0x48, 0x07, 0x72,
+  0xa0, 0x07, 0x74, 0x00, 0xe2, 0x40, 0x0e, 0xf0, 0x00, 0x18, 0xdc, 0xe1,
+  0x1d, 0xda, 0x40, 0x1c, 0xea, 0x21, 0x1d, 0xd8, 0x81, 0x1e, 0xd2, 0xc1,
+  0x1d, 0xe6, 0x01, 0x20, 0xdc, 0xe1, 0x1d, 0xda, 0xc0, 0x1c, 0xe4, 0x21,
+  0x1c, 0xda, 0xa1, 0x1c, 0xda, 0x00, 0x1e, 0xde, 0x21, 0x1d, 0xdc, 0x81,
+  0x1e, 0xca, 0x41, 0x1e, 0xda, 0xa0, 0x1c, 0xd8, 0x21, 0x1d, 0xda, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x30, 0x07, 0x79, 0x08, 0x87, 0x76, 0x28, 0x87, 0x36, 0x80, 0x87, 0x77,
+  0x48, 0x07, 0x77, 0xa0, 0x87, 0x72, 0x90, 0x87, 0x36, 0x28, 0x07, 0x76,
+  0x48, 0x87, 0x76, 0x68, 0x03, 0x77, 0x78, 0x07, 0x77, 0x68, 0x03, 0x76,
+  0x28, 0x87, 0x70, 0x30, 0x07, 0x80, 0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01,
+  0x20, 0xdc, 0xe1, 0x1d, 0xda, 0x20, 0x1d, 0xdc, 0xc1, 0x1c, 0xe6, 0xa1,
+  0x0d, 0xcc, 0x01, 0x1e, 0xda, 0xa0, 0x1d, 0xc2, 0x81, 0x1e, 0xd0, 0x01,
+  0xa0, 0x07, 0x79, 0xa8, 0x87, 0x72, 0x00, 0x08, 0x77, 0x78, 0x87, 0x36,
+  0x70, 0x87, 0x70, 0x70, 0x87, 0x79, 0x68, 0x03, 0x73, 0x80, 0x87, 0x36,
+  0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41, 0x1e, 0xea, 0xa1,
+  0x1c, 0x00, 0xc2, 0x1d, 0xde, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xce, 0xc1,
+  0x1d, 0xca, 0x81, 0x1c, 0xda, 0x40, 0x1f, 0xca, 0x41, 0x1e, 0xde, 0x61,
+  0x1e, 0xda, 0xc0, 0x1c, 0xe0, 0xa1, 0x0d, 0xda, 0x21, 0x1c, 0xe8, 0x01,
+  0x1d, 0x00, 0x7a, 0x90, 0x87, 0x7a, 0x28, 0x07, 0x80, 0x70, 0x87, 0x77,
+  0x68, 0x03, 0x7a, 0x90, 0x87, 0x70, 0x80, 0x07, 0x78, 0x48, 0x07, 0x77,
+  0x38, 0x87, 0x36, 0x68, 0x87, 0x70, 0xa0, 0x07, 0x74, 0x00, 0xe8, 0x41,
+  0x1e, 0xea, 0xa1, 0x1c, 0x00, 0x62, 0x1e, 0xe8, 0x21, 0x1c, 0xc6, 0x61,
+  0x1d, 0xda, 0x00, 0x1e, 0xe4, 0xe1, 0x1d, 0xe8, 0xa1, 0x1c, 0xc6, 0x81,
+  0x1e, 0xde, 0x41, 0x1e, 0xda, 0x40, 0x1c, 0xea, 0xc1, 0x1c, 0xcc, 0xa1,
+  0x1c, 0xe4, 0xa1, 0x0d, 0xe6, 0x21, 0x1d, 0xf4, 0xa1, 0x1c, 0x00, 0x3c,
+  0x00, 0x88, 0x7a, 0x70, 0x87, 0x79, 0x08, 0x07, 0x73, 0x28, 0x87, 0x36,
+  0x30, 0x07, 0x78, 0x68, 0x83, 0x76, 0x08, 0x07, 0x7a, 0x40, 0x07, 0x80,
+  0x1e, 0xe4, 0xa1, 0x1e, 0xca, 0x01, 0xd8, 0x90, 0x18, 0x02, 0xb0, 0x00,
+  0x55, 0x90, 0x06, 0x60, 0xb0, 0xc1, 0x38, 0xfe, 0xff, 0xff, 0xff, 0x7f,
+  0x00, 0x24, 0x80, 0xda, 0xe0, 0x23, 0xc8, 0xff, 0xff, 0xff, 0xff, 0x0f,
+  0x80, 0x04, 0x54, 0x44, 0x38, 0xc0, 0x03, 0x3c, 0xc8, 0xc3, 0x3b, 0xe0,
+  0x43, 0x1b, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb4, 0x81, 0x39, 0xc0,
+  0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f,
+  0xf5, 0x50, 0x0e, 0x00, 0xd1, 0x0e, 0xe9, 0xe0, 0x0e, 0x6d, 0xc0, 0x0e,
+  0xe5, 0x70, 0x0e, 0xe1, 0xc0, 0x0e, 0x6d, 0x60, 0x0f, 0xe5, 0x30, 0x0e,
+  0xf4, 0xf0, 0x0e, 0xf2, 0xd0, 0x06, 0xf7, 0x90, 0x0e, 0xe4, 0x40, 0x0f,
+  0xe8, 0x00, 0xe4, 0x81, 0x1d, 0x00, 0x83, 0x3b, 0xbc, 0x43, 0x1b, 0x88,
+  0x43, 0x3d, 0xa4, 0x03, 0x3b, 0xd0, 0x43, 0x3a, 0xb8, 0xc3, 0x3c, 0x00,
+  0x84, 0x3b, 0xbc, 0x43, 0x1b, 0x98, 0x83, 0x3c, 0x84, 0x43, 0x3b, 0x94,
+  0x43, 0x1b, 0xc0, 0xc3, 0x3b, 0xa4, 0x83, 0x3b, 0xd0, 0x43, 0x39, 0xc8,
+  0x43, 0x1b, 0x94, 0x03, 0x3b, 0xa4, 0x43, 0x3b, 0x00, 0xf4, 0x20, 0x0f,
+  0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xe6, 0x20, 0x0f,
+  0xe1, 0xd0, 0x0e, 0xe5, 0xd0, 0x06, 0xf0, 0xf0, 0x0e, 0xe9, 0xe0, 0x0e,
+  0xf4, 0x50, 0x0e, 0xf2, 0xd0, 0x06, 0xe5, 0xc0, 0x0e, 0xe9, 0xd0, 0x0e,
+  0x6d, 0xe0, 0x0e, 0xef, 0xe0, 0x0e, 0x6d, 0xc0, 0x0e, 0xe5, 0x10, 0x0e,
+  0xe6, 0x00, 0xd0, 0x83, 0x3c, 0xd4, 0x43, 0x39, 0x00, 0x84, 0x3b, 0xbc,
+  0x43, 0x1b, 0xa4, 0x83, 0x3b, 0x98, 0xc3, 0x3c, 0xb4, 0x81, 0x39, 0xc0,
+  0x43, 0x1b, 0xb4, 0x43, 0x38, 0xd0, 0x03, 0x3a, 0x00, 0xf4, 0x20, 0x0f,
+  0xf5, 0x50, 0x0e, 0x00, 0xe1, 0x0e, 0xef, 0xd0, 0x06, 0xee, 0x10, 0x0e,
+  0xee, 0x30, 0x0f, 0x6d, 0x60, 0x0e, 0xf0, 0xd0, 0x06, 0xed, 0x10, 0x0e,
+  0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94, 0x03, 0x40, 0xb8,
+  0xc3, 0x3b, 0xb4, 0xc1, 0x3c, 0xa4, 0xc3, 0x39, 0xb8, 0x43, 0x39, 0x90,
+  0x43, 0x1b, 0xe8, 0x43, 0x39, 0xc8, 0xc3, 0x3b, 0xcc, 0x43, 0x1b, 0x98,
+  0x03, 0x3c, 0xb4, 0x41, 0x3b, 0x84, 0x03, 0x3d, 0xa0, 0x03, 0x40, 0x0f,
+  0xf2, 0x50, 0x0f, 0xe5, 0x00, 0x10, 0xee, 0xf0, 0x0e, 0x6d, 0x40, 0x0f,
+  0xf2, 0x10, 0x0e, 0xf0, 0x00, 0x0f, 0xe9, 0xe0, 0x0e, 0xe7, 0xd0, 0x06,
+  0xed, 0x10, 0x0e, 0xf4, 0x80, 0x0e, 0x00, 0x3d, 0xc8, 0x43, 0x3d, 0x94,
+  0x03, 0x40, 0xcc, 0x03, 0x3d, 0x84, 0xc3, 0x38, 0xac, 0x43, 0x1b, 0xc0,
+  0x83, 0x3c, 0xbc, 0x03, 0x3d, 0x94, 0xc3, 0x38, 0xd0, 0xc3, 0x3b, 0xc8,
+  0x43, 0x1b, 0x88, 0x43, 0x3d, 0x98, 0x83, 0x39, 0x94, 0x83, 0x3c, 0xb4,
+  0xc1, 0x3c, 0xa4, 0x83, 0x3e, 0x94, 0x03, 0x80, 0x07, 0x00, 0x51, 0x0f,
+  0xee, 0x30, 0x0f, 0xe1, 0x60, 0x0e, 0xe5, 0xd0, 0x06, 0xe6, 0x00, 0x0f,
+  0x6d, 0xd0, 0x0e, 0xe1, 0x40, 0x0f, 0xe8, 0x00, 0xd0, 0x83, 0x3c, 0xd4,
+  0x43, 0x39, 0x00, 0x1b, 0x94, 0xe4, 0xff, 0xff, 0xff, 0xff, 0x07, 0xa0,
+  0x0d, 0x80, 0x35, 0x00, 0x24, 0xa0, 0xda, 0x60, 0x28, 0x01, 0xb0, 0x00,
+  0xd5, 0x06, 0x63, 0x11, 0x80, 0x05, 0xa8, 0x36, 0x28, 0xcc, 0xff, 0xff,
+  0xff, 0xff, 0x0f, 0x40, 0x1b, 0x00, 0x6b, 0x00, 0x48, 0x40, 0xb5, 0xc1,
+  0x68, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x24, 0x80, 0xda, 0x30, 0x39,
+  0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x6b, 0x00, 0x28, 0x83, 0x3b, 0xbc,
+  0x43, 0x1b, 0x88, 0x43, 0x3d, 0xa4, 0x03, 0x3b, 0xd0, 0x43, 0x3a, 0xb8,
+  0xc3, 0x3c, 0x00, 0x1b, 0x8a, 0x47, 0x08, 0xd2, 0x00, 0x0c, 0x36, 0x44,
+  0xd0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0x32, 0xb8, 0xc3, 0x3b, 0xb4,
+  0x81, 0x38, 0xd4, 0x43, 0x3a, 0xb0, 0x03, 0x3d, 0xa4, 0x83, 0x3b, 0xcc,
+  0x03, 0x00, 0x00, 0x00, 0x00, 0x49, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00,
+  0x00, 0x13, 0x88, 0x40, 0x18, 0x88, 0x09, 0x42, 0x61, 0x4c, 0x08, 0x8e,
+  0x09, 0x01, 0x32, 0x61, 0x48, 0x94, 0x65, 0xc2, 0xc0, 0x28, 0xcb, 0x84,
+  0xa0, 0x99, 0x20, 0x38, 0xcf, 0x84, 0x00, 0x02, 0x00, 0x89, 0x20, 0x00,
+  0x00, 0x48, 0x00, 0x00, 0x00, 0x32, 0x22, 0x88, 0x09, 0x20, 0x64, 0x85,
+  0x04, 0x13, 0x23, 0xa4, 0x84, 0x04, 0x13, 0x23, 0xe3, 0x84, 0xa1, 0x90,
+  0x14, 0x12, 0x4c, 0x8c, 0x8c, 0x0b, 0x84, 0xc4, 0x4c, 0x10, 0xd0, 0xc1,
+  0x0c, 0xc0, 0x30, 0x02, 0x01, 0x0c, 0x23, 0x08, 0xc0, 0x59, 0xd2, 0x14,
+  0x51, 0xc2, 0xe4, 0xb3, 0x07, 0x30, 0x10, 0x11, 0xe7, 0x34, 0xd2, 0x04,
+  0x34, 0x93, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x84,
+  0x41, 0x18, 0x46, 0x18, 0x80, 0x1c, 0x28, 0x66, 0xa2, 0xe6, 0x81, 0x1e,
+  0xe4, 0xa1, 0x1e, 0xc6, 0x81, 0x1e, 0xdc, 0xa0, 0x1d, 0xca, 0x81, 0x1e,
+  0xc2, 0x81, 0x1d, 0xf4, 0x40, 0x0f, 0xda, 0x21, 0x1c, 0xe8, 0x41, 0x1e,
+  0xd2, 0x01, 0x1f, 0x50, 0x60, 0x1c, 0x24, 0x4d, 0x11, 0x25, 0x4c, 0xbe,
+  0xec, 0xbe, 0x1d, 0x21, 0x38, 0x03, 0x81, 0x84, 0xe2, 0x18, 0x44, 0x40,
+  0x84, 0xa3, 0xa4, 0x29, 0xa2, 0x84, 0xc9, 0xff, 0x27, 0xe2, 0x9a, 0xa8,
+  0x88, 0xf8, 0xed, 0xe1, 0x9f, 0xc6, 0x08, 0x80, 0x41, 0x04, 0x25, 0xb8,
+  0x48, 0x9a, 0x22, 0x4a, 0x98, 0xfc, 0x5f, 0x02, 0x98, 0x67, 0x21, 0xa2,
+  0x7f, 0x1a, 0x23, 0x00, 0x06, 0x11, 0x18, 0xa1, 0x24, 0x41, 0x10, 0x08,
+  0x44, 0xb2, 0x2c, 0x0d, 0x39, 0x65, 0x08, 0x02, 0x82, 0xa0, 0x42, 0x14,
+  0x45, 0x51, 0x90, 0x54, 0x06, 0x00, 0x00, 0x88, 0x2a, 0x02, 0x00, 0x90,
+  0x35, 0x47, 0x10, 0x14, 0x01, 0x03, 0x28, 0x2b, 0x03, 0x50, 0x14, 0xb4,
+  0x15, 0xa3, 0x28, 0x00, 0x00, 0x00, 0xa8, 0x2b, 0x43, 0x51, 0x14, 0xf4,
+  0x15, 0xa1, 0x28, 0x28, 0x9c, 0x23, 0x40, 0x8c, 0x10, 0x8c, 0x73, 0x04,
+  0x60, 0x30, 0x8c, 0x20, 0x94, 0x41, 0x51, 0xc8, 0xa5, 0x11, 0x30, 0x13,
+  0x03, 0x80, 0x92, 0xce, 0x81, 0x80, 0x14, 0x28, 0xe7, 0x08, 0x40, 0x61,
+  0x10, 0x01, 0x10, 0xa6, 0x00, 0x46, 0x00, 0x86, 0x11, 0x86, 0x32, 0x18,
+  0x44, 0x08, 0x84, 0x41, 0x84, 0x43, 0x18, 0x44, 0x28, 0x84, 0x61, 0x04,
+  0xa2, 0x0c, 0x00, 0x00, 0x00, 0x13, 0xc0, 0x20, 0x1c, 0xd2, 0x41, 0x1e,
+  0xec, 0x80, 0x0e, 0xda, 0x20, 0x1c, 0xe0, 0x01, 0x1e, 0xd8, 0xa1, 0x1c,
+  0xda, 0x80, 0x1e, 0xec, 0xe1, 0x1d, 0xe6, 0x21, 0x0e, 0xe6, 0xc0, 0x0d,
+  0xe0, 0xc0, 0x0d, 0xe0, 0xa0, 0x0d, 0xe6, 0x21, 0x1d, 0xda, 0xa1, 0x1e,
+  0xd8, 0x21, 0x1c, 0xe8, 0xe1, 0x1d, 0xe4, 0x61, 0xc3, 0x6d, 0x94, 0x43,
+  0x1b, 0xc0, 0x83, 0x1e, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
+  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1e, 0xe0, 0x81,
+  0x1e, 0xe0, 0x41, 0x1b, 0xa4, 0x03, 0x1e, 0xe8, 0x01, 0x1e, 0xe8, 0x01,
+  0x1e, 0xb4, 0x41, 0x3a, 0xc4, 0x81, 0x1d, 0xe8, 0x41, 0x1c, 0xd8, 0x81,
+  0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x41, 0x3a, 0xcc, 0x81, 0x1c, 0xe8, 0xc1,
+  0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x41, 0x3a, 0xd8, 0x01,
+  0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81,
+  0x39, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x39, 0xd8, 0x01, 0x1d, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
+  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1d, 0xe8, 0x41,
+  0x1c, 0xd8, 0x81, 0x1e, 0xc4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x01,
+  0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81, 0x1c, 0xb4, 0x81,
+  0x3d, 0xcc, 0x81, 0x1c, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x1e, 0xcc, 0x81,
+  0x1c, 0xb4, 0x81, 0x3d, 0xd0, 0x01, 0x1e, 0xe8, 0x81, 0x1d, 0xd0, 0x81,
+  0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xd8, 0x01, 0x1d, 0xe8, 0x81,
+  0x1d, 0xd0, 0x81, 0x1e, 0xd8, 0x01, 0x1d, 0xb4, 0x81, 0x3d, 0xe4, 0x81,
+  0x1d, 0xe8, 0x41, 0x1c, 0xc8, 0x01, 0x1e, 0xe8, 0x41, 0x1c, 0xc8, 0x01,
+  0x1e, 0xb4, 0x81, 0x3d, 0xc4, 0x81, 0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81,
+  0x1c, 0xe0, 0x81, 0x1e, 0xc4, 0x81, 0x1c, 0xe0, 0x41, 0x1b, 0xd8, 0x43,
+  0x1c, 0xe4, 0x81, 0x1c, 0xe8, 0x81, 0x1c, 0xd4, 0x81, 0x1d, 0xe8, 0x81,
+  0x1c, 0xd4, 0x81, 0x1d, 0xb4, 0x81, 0x3d, 0xc8, 0x41, 0x1d, 0xd8, 0x81,
+  0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x81, 0x1e, 0xc8, 0x41, 0x1d, 0xd8, 0x41,
+  0x1b, 0xd8, 0x43, 0x1d, 0xc4, 0x81, 0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81,
+  0x1c, 0xe8, 0x41, 0x1d, 0xc4, 0x81, 0x1c, 0xb4, 0x81, 0x3d, 0xc4, 0x01,
+  0x1c, 0xc8, 0x01, 0x1d, 0xe8, 0x41, 0x1c, 0xc0, 0x81, 0x1c, 0xd0, 0x81,
+  0x1e, 0xc4, 0x01, 0x1c, 0xc8, 0x01, 0x1d, 0xb4, 0x81, 0x3b, 0xe0, 0x81,
+  0x1e, 0xc4, 0x81, 0x1d, 0xe8, 0xc1, 0x1c, 0xc8, 0x81, 0x46, 0x08, 0x43,
+  0x46, 0x6c, 0x57, 0xfe, 0xe7, 0x5b, 0xdb, 0x7f, 0x11, 0x01, 0x06, 0x43,
+  0x34, 0xd3, 0x90, 0x08, 0x88, 0x1c, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0x45, 0x78, 0x00, 0x21, 0xc0, 0x20,
+  0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc0, 0x90, 0x28, 0x15, 0x28,
+  0x09, 0x08, 0x80, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x86,
+  0x44, 0xbd, 0x00, 0x51, 0x40, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00,
+  0x00, 0x00, 0x30, 0x24, 0x6a, 0x87, 0xc8, 0x02, 0x02, 0x60, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x80, 0x21, 0x91, 0x3f, 0x58, 0x19, 0x10,
+  0x00, 0x03, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x89, 0x68,
+  0xa2, 0xd9, 0x80, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x60, 0x48, 0x14, 0x16, 0x59, 0x87, 0x00, 0x03, 0x01, 0x00, 0x00, 0x10,
+  0x00, 0x00, 0x00, 0x00, 0x43, 0x22, 0xbd, 0x88, 0x28, 0x20, 0x00, 0x06,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x12, 0xad, 0x86, 0xf4,
+  0x01, 0x01, 0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xc0, 0x90,
+  0xa8, 0x37, 0xa6, 0x30, 0x00, 0x02, 0x60, 0x00, 0x00, 0x00, 0x10, 0x00,
+  0x00, 0x00, 0x80, 0x21, 0x11, 0x7c, 0x4c, 0x1f, 0x10, 0x00, 0x03, 0x00,
+  0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x89, 0x46, 0x64, 0x3b, 0x03,
+  0x20, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x90, 0xd8,
+  0x20, 0x50, 0x54, 0xfc, 0x00, 0x00, 0x20, 0x0b, 0x04, 0x10, 0x00, 0x00,
+  0x00, 0x32, 0x1e, 0x98, 0x18, 0x19, 0x11, 0x4c, 0x90, 0x8c, 0x09, 0x26,
+  0x47, 0xc6, 0x04, 0x43, 0x2a, 0x8b, 0xa0, 0x04, 0x0a, 0x61, 0x04, 0xa0,
+  0x0c, 0x0a, 0xa8, 0x20, 0x0a, 0xa3, 0x40, 0x0a, 0xa5, 0x60, 0x0a, 0xa7,
+  0x00, 0x03, 0x0a, 0xac, 0x14, 0x8a, 0xa1, 0x1c, 0x68, 0x1d, 0x01, 0x28,
+  0x84, 0x82, 0x28, 0x8c, 0x02, 0x29, 0x94, 0x82, 0x29, 0x1c, 0x52, 0xc7,
+  0x12, 0x24, 0x01, 0x00, 0x00, 0xb1, 0x18, 0x00, 0x00, 0xa5, 0x00, 0x00,
+  0x00, 0x33, 0x08, 0x80, 0x1c, 0xc4, 0xe1, 0x1c, 0x66, 0x14, 0x01, 0x3d,
+  0x88, 0x43, 0x38, 0x84, 0xc3, 0x8c, 0x42, 0x80, 0x07, 0x79, 0x78, 0x07,
+  0x73, 0x98, 0x71, 0x0c, 0xe6, 0x00, 0x0f, 0xed, 0x10, 0x0e, 0xf4, 0x80,
+  0x0e, 0x33, 0x0c, 0x42, 0x1e, 0xc2, 0xc1, 0x1d, 0xce, 0xa1, 0x1c, 0x66,
+  0x30, 0x05, 0x3d, 0x88, 0x43, 0x38, 0x84, 0x83, 0x1b, 0xcc, 0x03, 0x3d,
+  0xc8, 0x43, 0x3d, 0x8c, 0x03, 0x3d, 0xcc, 0x78, 0x8c, 0x74, 0x70, 0x07,
+  0x7b, 0x08, 0x07, 0x79, 0x48, 0x87, 0x70, 0x70, 0x07, 0x7a, 0x70, 0x03,
+  0x76, 0x78, 0x87, 0x70, 0x20, 0x87, 0x19, 0xcc, 0x11, 0x0e, 0xec, 0x90,
+  0x0e, 0xe1, 0x30, 0x0f, 0x6e, 0x30, 0x0f, 0xe3, 0xf0, 0x0e, 0xf0, 0x50,
+  0x0e, 0x33, 0x10, 0xc4, 0x1d, 0xde, 0x21, 0x1c, 0xd8, 0x21, 0x1d, 0xc2,
+  0x61, 0x1e, 0x66, 0x30, 0x89, 0x3b, 0xbc, 0x83, 0x3b, 0xd0, 0x43, 0x39,
+  0xb4, 0x03, 0x3c, 0xbc, 0x83, 0x3c, 0x84, 0x03, 0x3b, 0xcc, 0xf0, 0x14,
+  0x76, 0x60, 0x07, 0x7b, 0x68, 0x07, 0x37, 0x68, 0x87, 0x72, 0x68, 0x07,
+  0x37, 0x80, 0x87, 0x70, 0x90, 0x87, 0x70, 0x60, 0x07, 0x76, 0x28, 0x07,
+  0x76, 0xf8, 0x05, 0x76, 0x78, 0x87, 0x77, 0x80, 0x87, 0x5f, 0x08, 0x87,
+  0x71, 0x18, 0x87, 0x72, 0x98, 0x87, 0x79, 0x98, 0x81, 0x2c, 0xee, 0xf0,
+  0x0e, 0xee, 0xe0, 0x0e, 0xf5, 0xc0, 0x0e, 0xec, 0x30, 0x03, 0x62, 0xc8,
+  0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xcc, 0xa1, 0x1c, 0xe4, 0xa1, 0x1c, 0xdc,
+  0x61, 0x1c, 0xca, 0x21, 0x1c, 0xc4, 0x81, 0x1d, 0xca, 0x61, 0x06, 0xd6,
+  0x90, 0x43, 0x39, 0xc8, 0x43, 0x39, 0x98, 0x43, 0x39, 0xc8, 0x43, 0x39,
+  0xb8, 0xc3, 0x38, 0x94, 0x43, 0x38, 0x88, 0x03, 0x3b, 0x94, 0xc3, 0x2f,
+  0xbc, 0x83, 0x3c, 0xfc, 0x82, 0x3b, 0xd4, 0x03, 0x3b, 0xb0, 0xc3, 0x0c,
+  0xc7, 0x69, 0x87, 0x70, 0x58, 0x87, 0x72, 0x70, 0x83, 0x74, 0x68, 0x07,
+  0x78, 0x60, 0x87, 0x74, 0x18, 0x87, 0x74, 0xa0, 0x87, 0x19, 0xce, 0x53,
+  0x0f, 0xee, 0x00, 0x0f, 0xf2, 0x50, 0x0e, 0xe4, 0x90, 0x0e, 0xe3, 0x40,
+  0x0f, 0xe1, 0x20, 0x0e, 0xec, 0x50, 0x0e, 0x33, 0x20, 0x28, 0x1d, 0xdc,
+  0xc1, 0x1e, 0xc2, 0x41, 0x1e, 0xd2, 0x21, 0x1c, 0xdc, 0x81, 0x1e, 0xdc,
+  0xe0, 0x1c, 0xe4, 0xe1, 0x1d, 0xea, 0x01, 0x1e, 0x66, 0x18, 0x51, 0x38,
+  0xb0, 0x43, 0x3a, 0x9c, 0x83, 0x3b, 0xcc, 0x50, 0x24, 0x76, 0x60, 0x07,
+  0x7b, 0x68, 0x07, 0x37, 0x60, 0x87, 0x77, 0x78, 0x07, 0x78, 0x98, 0x51,
+  0x4c, 0xf4, 0x90, 0x0f, 0xf0, 0x50, 0x0e, 0x33, 0x1e, 0x6a, 0x1e, 0xca,
+  0x61, 0x1c, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d, 0x7e, 0x01, 0x1e, 0xe4,
+  0xa1, 0x1c, 0xcc, 0x21, 0x1d, 0xf0, 0x61, 0x06, 0x54, 0x85, 0x83, 0x38,
+  0xcc, 0xc3, 0x3b, 0xb0, 0x43, 0x3d, 0xd0, 0x43, 0x39, 0xfc, 0xc2, 0x3c,
+  0xe4, 0x43, 0x3b, 0x88, 0xc3, 0x3b, 0xb0, 0xc3, 0x8c, 0xc5, 0x0a, 0x87,
+  0x79, 0x98, 0x87, 0x77, 0x18, 0x87, 0x74, 0x08, 0x07, 0x7a, 0x28, 0x07,
+  0x72, 0x98, 0x81, 0x5c, 0xe3, 0x10, 0x0e, 0xec, 0xc0, 0x0e, 0xe5, 0x50,
+  0x0e, 0xf3, 0x30, 0x23, 0xc1, 0xd2, 0x41, 0x1e, 0xe4, 0xe1, 0x17, 0xd8,
+  0xe1, 0x1d, 0xde, 0x01, 0x1e, 0x66, 0x48, 0x19, 0x3b, 0xb0, 0x83, 0x3d,
+  0xb4, 0x83, 0x1b, 0x84, 0xc3, 0x38, 0x8c, 0x43, 0x39, 0xcc, 0xc3, 0x3c,
+  0xb8, 0xc1, 0x39, 0xc8, 0xc3, 0x3b, 0xd4, 0x03, 0x3c, 0xcc, 0x48, 0xb4,
+  0x71, 0x08, 0x07, 0x76, 0x60, 0x07, 0x71, 0x08, 0x87, 0x71, 0x58, 0x87,
+  0x19, 0xdb, 0xc6, 0x0e, 0xec, 0x60, 0x0f, 0xed, 0xe0, 0x06, 0xf0, 0x20,
+  0x0f, 0xe5, 0x30, 0x0f, 0xe5, 0x20, 0x0f, 0xf6, 0x50, 0x0e, 0x6e, 0x10,
+  0x0e, 0xe3, 0x30, 0x0e, 0xe5, 0x30, 0x0f, 0xf3, 0xe0, 0x06, 0xe9, 0xe0,
+  0x0e, 0xe4, 0x50, 0x0e, 0xf8, 0x30, 0x23, 0xe2, 0xec, 0x61, 0x1c, 0xc2,
+  0x81, 0x1d, 0xd8, 0xe1, 0x17, 0xec, 0x21, 0x1d, 0xe6, 0x21, 0x1d, 0xc4,
+  0x21, 0x1d, 0xd8, 0x21, 0x1d, 0xe8, 0x21, 0x1f, 0x66, 0x20, 0x9d, 0x3b,
+  0xbc, 0x43, 0x3d, 0xb8, 0x03, 0x39, 0x94, 0x83, 0x39, 0xcc, 0x58, 0xbc,
+  0x70, 0x70, 0x07, 0x77, 0x78, 0x07, 0x7a, 0x08, 0x07, 0x7a, 0x48, 0x87,
+  0x77, 0x70, 0x87, 0x19, 0xce, 0x87, 0x0e, 0xe5, 0x10, 0x0e, 0xf0, 0x10,
+  0x0e, 0xec, 0xc0, 0x0e, 0xef, 0x30, 0x0e, 0xf3, 0x90, 0x0e, 0xf4, 0x50,
+  0x0e, 0x33, 0x28, 0x30, 0x08, 0x87, 0x74, 0x90, 0x07, 0x37, 0x30, 0x87,
+  0x7a, 0x70, 0x87, 0x71, 0xa0, 0x87, 0x74, 0x78, 0x07, 0x77, 0xf8, 0x85,
+  0x73, 0x90, 0x87, 0x77, 0xa8, 0x07, 0x78, 0x98, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x79, 0x20, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, 0x32, 0x9a, 0x08,
+  0x14, 0x02, 0x85, 0x8c, 0x27, 0x46, 0x46, 0xc8, 0x11, 0x32, 0x64, 0xd4,
+  0xf2, 0x00, 0x0e, 0xdc, 0x0c, 0x8b, 0x12, 0x07, 0xc5, 0xc6, 0x91, 0x41,
+  0x14, 0x19, 0x8c, 0x22, 0x31, 0x88, 0x64, 0x3d, 0x45, 0x66, 0x20, 0xca,
+  0x23, 0x21, 0x54, 0xc1, 0x30, 0xca, 0xe2, 0x3c, 0xcf, 0x13, 0x5d, 0x4f,
+  0x60, 0x18, 0x88, 0x91, 0x18, 0x8b, 0x82, 0x11, 0xc5, 0x72, 0x04, 0xd5,
+  0xf3, 0x00, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4b, 0x20, 0x56, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x77, 0x63, 0x68, 0x61, 0x72, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61,
+  0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x33, 0x32,
+  0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34, 0x20, 0x28, 0x6d, 0x65, 0x74,
+  0x61, 0x6c, 0x66, 0x65, 0x2d, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34,
+  0x30, 0x34, 0x29, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x61, 0x69, 0x72, 0x2e,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x64, 0x65, 0x6e, 0x6f,
+  0x72, 0x6d, 0x73, 0x5f, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x2e, 0x66,
+  0x61, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+  0x6c, 0x65, 0x2e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x62, 0x75, 0x66, 0x66,
+  0x65, 0x72, 0x5f, 0x66, 0x65, 0x74, 0x63, 0x68, 0x5f, 0x65, 0x6e, 0x61,
+  0x62, 0x6c, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x6e, 0x64, 0x65,
+  0x72, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x61, 0x69, 0x72, 0x2e,
+  0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
+  0x65, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x34, 0x61, 0x69, 0x72, 0x2e, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x63,
+  0x65, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e, 0x6e, 0x6f, 0x5f,
+  0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x69, 0x72, 0x2e, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x70, 0x75,
+  0x74, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x28, 0x35,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x29, 0x61,
+  0x69, 0x72, 0x2e, 0x70, 0x65, 0x72, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69,
+  0x76, 0x65, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x65, 0x72,
+  0x61, 0x74, 0x65, 0x64, 0x28, 0x38, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f,
+  0x72, 0x64, 0x44, 0x76, 0x32, 0x5f, 0x66, 0x29, 0x66, 0x6c, 0x6f, 0x61,
+  0x74, 0x32, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x61, 0x69,
+  0x72, 0x2e, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x61, 0x69, 0x72, 0x2e,
+  0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x61, 0x69, 0x72, 0x2e, 0x72, 0x65, 0x61,
+  0x64, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x5f,
+  0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x66, 0x6c, 0x6f,
+  0x61, 0x74, 0x73, 0x63, 0x52, 0x47, 0x42, 0x5f, 0x6f, 0x75, 0x74, 0x70,
+  0x75, 0x74, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x79,
+  0x70, 0x65, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+  0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x74,
+  0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x68, 0x6f,
+  0x64, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x61, 0x63,
+  0x74, 0x6f, 0x72, 0x31, 0x74, 0x6f, 0x6e, 0x65, 0x6d, 0x61, 0x70, 0x5f,
+  0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x32, 0x73, 0x64, 0x72, 0x5f, 0x77,
+  0x68, 0x69, 0x74, 0x65, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x61, 0x69,
+  0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x73,
+  0x69, 0x7a, 0x65, 0x61, 0x69, 0x72, 0x2e, 0x61, 0x72, 0x67, 0x5f, 0x74,
+  0x79, 0x70, 0x65, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x5f, 0x73, 0x69,
+  0x7a, 0x65, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x73,
+  0x74, 0x61, 0x6e, 0x74, 0x73, 0x63, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33,
+  0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x33,
+  0x78, 0x33, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x59, 0x55, 0x56, 0x44,
+  0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x61,
+  0x69, 0x72, 0x2e, 0x74, 0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x61, 0x69,
+  0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x78, 0x74,
+  0x75, 0x72, 0x65, 0x32, 0x64, 0x3c, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x2c,
+  0x20, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x3e, 0x74, 0x65, 0x78, 0x59,
+  0x74, 0x65, 0x78, 0x55, 0x56, 0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d,
+  0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73,
+  0x5f, 0x5a, 0x54, 0x53, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72,
+  0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x6f, 0x6d, 0x6e,
+  0x69, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x68, 0x61, 0x72,
+  0x53, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x20, 0x43, 0x2b, 0x2b, 0x20, 0x54,
+  0x42, 0x41, 0x41, 0x00, 0x00, 0x04, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x30, 0x82, 0x50, 0x06, 0xcd, 0x08, 0x82, 0x1a, 0x98, 0xc1, 0x08,
+  0x42, 0x19, 0x38, 0x23, 0x08, 0x65, 0xf0, 0x8c, 0x20, 0x94, 0x01, 0x34,
+  0x82, 0xf0, 0x00, 0x23, 0x08, 0x65, 0x10, 0x8d, 0x20, 0x94, 0x81, 0x34,
+  0x82, 0x50, 0x06, 0xd3, 0x08, 0x42, 0x19, 0x50, 0x23, 0x08, 0x65, 0x50,
+  0x8d, 0x20, 0x94, 0x81, 0x35, 0x82, 0x50, 0x06, 0xd7, 0x08, 0x42, 0x19,
+  0x60, 0x23, 0x08, 0x65, 0x90, 0x8d, 0x20, 0x94, 0x81, 0x36, 0x82, 0x50,
+  0x06, 0xdb, 0x08, 0x42, 0x19, 0x70, 0x23, 0x08, 0x65, 0xd0, 0x8d, 0x20,
+  0xac, 0x81, 0x37, 0x82, 0xb0, 0x06, 0xdf, 0x08, 0xc2, 0x1a, 0x80, 0xc1,
+  0x08, 0xc2, 0x1a, 0x84, 0xc1, 0x08, 0xc2, 0x1a, 0x88, 0xc1, 0x08, 0xc2,
+  0x1a, 0x8c, 0xc1, 0x08, 0xc2, 0x1a, 0x90, 0xc1, 0x08, 0xc2, 0x1a, 0x94,
+  0xc1, 0x0c, 0x83, 0x1e, 0x04, 0x7b, 0x30, 0xc3, 0xc0, 0x07, 0x42, 0x1f,
+  0xcc, 0x10, 0x0c, 0x33, 0x0c, 0x7a, 0xa0, 0x07, 0x7e, 0x30, 0x03, 0x41,
+  0xf0, 0x01, 0x1f, 0xf8, 0xc1, 0x0c, 0x41, 0x31, 0x43, 0x60, 0xcc, 0x10,
+  0x1c, 0x33, 0x14, 0x88, 0x1f, 0xf8, 0x41, 0xa2, 0xcc, 0x10, 0xf4, 0xc2,
+  0x0c, 0x88, 0x1f, 0x2c, 0x4c, 0x93, 0x28, 0xce, 0x33, 0x43, 0xc2, 0x07,
+  0x50, 0xc4, 0x48, 0x89, 0xe2, 0x4c, 0x33, 0x24, 0x7a, 0x00, 0x51, 0x8c,
+  0x94, 0x54, 0x8e, 0x35, 0x03, 0x1a, 0xf8, 0x41, 0x1f, 0xf8, 0x01, 0xd7,
+  0xf5, 0x41, 0x1f, 0xf8, 0x01, 0xe7, 0x89, 0x42, 0x1f, 0xf8, 0x01, 0xf7,
+  0x8d, 0x42, 0x1f, 0xf8, 0x01, 0x07, 0x06, 0xa4, 0xd0, 0x07, 0x7e, 0xc0,
+  0x85, 0x41, 0x29, 0xf4, 0x81, 0x1f, 0x70, 0x62, 0x60, 0x0a, 0x7d, 0xe0,
+  0x07, 0xdc, 0x18, 0x9c, 0x42, 0x1f, 0xf8, 0x01, 0x47, 0x06, 0x33, 0x48,
+  0xa0, 0x70, 0x61, 0xa1, 0x90, 0xf9, 0x01, 0x1f, 0x68, 0x9b, 0x38, 0x94,
+  0x41, 0x28, 0x98, 0x41, 0x1f, 0x24, 0x67, 0xe0, 0xa0, 0xc1, 0x0c, 0x8a,
+  0x1f, 0x90, 0x82, 0x1f, 0xa4, 0x81, 0x1a, 0x90, 0x42, 0x2a, 0xf8, 0xc1,
+  0x1a, 0xb0, 0xc1, 0x0c, 0x52, 0x1f, 0x5c, 0x18, 0x2a, 0x64, 0x7c, 0xc0,
+  0x07, 0xda, 0x46, 0x0e, 0x65, 0x80, 0x0a, 0x66, 0x40, 0x0a, 0x49, 0x1b,
+  0x38, 0x6e, 0x30, 0x83, 0xa2, 0x0a, 0x6f, 0x90, 0xf9, 0x01, 0x1f, 0xc0,
+  0x41, 0x12, 0x07, 0x8e, 0x1c, 0xcc, 0xa0, 0xac, 0xc2, 0x1b, 0x64, 0x7c,
+  0xc0, 0x07, 0x70, 0x90, 0xc4, 0x81, 0x33, 0x07, 0x33, 0x24, 0xac, 0x40,
+  0x07, 0x99, 0x1f, 0xf0, 0x41, 0x52, 0x07, 0x8e, 0x1d, 0xcc, 0x80, 0xfc,
+  0x02, 0x38, 0x84, 0xc3, 0x38, 0x94, 0x83, 0x39, 0x9c, 0x03, 0x3a, 0xcc,
+  0x30, 0xfc, 0x81, 0x2f, 0xa4, 0xc3, 0x0c, 0x41, 0x1e, 0xcc, 0x30, 0xe0,
+  0xc1, 0x3a, 0xb4, 0xc2, 0x0c, 0x03, 0xc7, 0x0e, 0xad, 0x30, 0x43, 0x74,
+  0x07, 0xed, 0xd0, 0x0a, 0xed, 0xe0, 0x0a, 0xed, 0xf0, 0x0a, 0xed, 0x00,
+  0x0b, 0xed, 0x10, 0x0b, 0xed, 0x20, 0x0b, 0xed, 0x30, 0x0b, 0xed, 0x40,
+  0x0b, 0x33, 0x0c, 0xee, 0xd0, 0x0e, 0xae, 0x50, 0x76, 0x00, 0x88, 0x01,
+  0x1a, 0x88, 0x81, 0x18, 0x88, 0x01, 0x27, 0x06, 0x62, 0x20, 0x06, 0x62,
+  0x20, 0x06, 0x62, 0x20, 0x06, 0x62, 0x20, 0x06, 0x62, 0x20, 0x06, 0x62,
+  0x20, 0x06, 0x62, 0x20, 0x06, 0x68, 0x80, 0x06, 0x68, 0x80, 0x06, 0x68,
+  0x80, 0x06, 0x6e, 0xe0, 0x06, 0x16, 0x1d, 0xe8, 0x81, 0x65, 0x59, 0x7a,
+  0xc0, 0x99, 0x02, 0x2b, 0xb0, 0x02, 0xdd, 0xf8, 0x05, 0x4a, 0xf8, 0x85,
+  0x3d, 0xd8, 0x83, 0x3a, 0xc0, 0x03, 0x1d, 0x70, 0x74, 0xe0, 0x06, 0xbc,
+  0x21, 0x23, 0x81, 0x09, 0xba, 0x88, 0x8d, 0xcd, 0xae, 0xcd, 0xa5, 0xed,
+  0x8d, 0xac, 0x8e, 0xad, 0xcc, 0xc5, 0x8c, 0x2d, 0xec, 0x6c, 0x6e, 0x14,
+  0x81, 0x16, 0x6a, 0xe1, 0x14, 0x36, 0x36, 0xbb, 0x36, 0x97, 0x34, 0xb2,
+  0x32, 0x37, 0xba, 0x51, 0x02, 0x5b, 0xb8, 0x25, 0x2c, 0x4d, 0xce, 0xc5,
+  0xae, 0x4c, 0x6e, 0x2e, 0xed, 0xcd, 0x6d, 0x94, 0xe0, 0x16, 0x8e, 0x0a,
+  0x4b, 0x93, 0x73, 0x61, 0x0b, 0x73, 0x3b, 0xab, 0x0b, 0x3b, 0x2b, 0xfb,
+  0xb2, 0x2b, 0x93, 0x9b, 0x4b, 0x7b, 0x73, 0x1b, 0x25, 0xc0, 0x85, 0x9b,
+  0xc2, 0xd2, 0xe4, 0x5c, 0xc6, 0xde, 0xda, 0xe0, 0xd2, 0xd8, 0xca, 0xbe,
+  0xde, 0xe0, 0xe8, 0xd2, 0xde, 0xdc, 0xe6, 0x46, 0x19, 0x72, 0x41, 0x17,
+  0x76, 0xe1, 0x98, 0xb0, 0x34, 0x39, 0x17, 0x33, 0xb9, 0xb0, 0xb3, 0xb6,
+  0x32, 0x37, 0xba, 0x51, 0x82, 0x74, 0x00, 0x00, 0x00, 0xa9, 0x18, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x0b, 0x0a, 0x72, 0x28, 0x87, 0x77, 0x80,
+  0x07, 0x7a, 0x58, 0x70, 0x98, 0x43, 0x3d, 0xb8, 0xc3, 0x38, 0xb0, 0x43,
+  0x39, 0xd0, 0xc3, 0x82, 0xe6, 0x1c, 0xc6, 0xa1, 0x0d, 0xe8, 0x41, 0x1e,
+  0xc2, 0xc1, 0x1d, 0xe6, 0x21, 0x1d, 0xe8, 0x21, 0x1d, 0xde, 0xc1, 0x1d,
+  0x16, 0x34, 0xe3, 0x60, 0x0e, 0xe7, 0x50, 0x0f, 0xe1, 0x20, 0x0f, 0xe4,
+  0x40, 0x0f, 0xe1, 0x20, 0x0f, 0xe7, 0x50, 0x0e, 0xf4, 0xb0, 0x80, 0x81,
+  0x07, 0x79, 0x28, 0x87, 0x70, 0x60, 0x07, 0x76, 0x78, 0x87, 0x71, 0x08,
+  0x07, 0x7a, 0x28, 0x07, 0x72, 0x58, 0x70, 0x9c, 0xc3, 0x38, 0xb4, 0x01,
+  0x3b, 0xa4, 0x83, 0x3d, 0x94, 0xc3, 0x02, 0x6b, 0x1c, 0xd8, 0x21, 0x1c,
+  0xdc, 0xe1, 0x1c, 0xdc, 0x20, 0x1c, 0xe4, 0x61, 0x1c, 0xdc, 0x20, 0x1c,
+  0xe8, 0x81, 0x1e, 0xc2, 0x61, 0x1c, 0xd0, 0xa1, 0x1c, 0xc8, 0x61, 0x1c,
+  0xc2, 0x81, 0x1d, 0xd8, 0x61, 0xc1, 0x01, 0x0f, 0xf4, 0x20, 0x0f, 0xe1,
+  0x50, 0x0f, 0xf4, 0x80, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xd1, 0x10, 0x00,
+  0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0xcc, 0x3c, 0xa4, 0x83, 0x3b, 0x9c,
+  0x03, 0x3b, 0x94, 0x03, 0x3d, 0xa0, 0x83, 0x3c, 0x94, 0x43, 0x38, 0x90,
+  0xc3, 0x01, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0xd9, 0x00, 0x00,
+  0x00, 0x13, 0x04, 0x45, 0x2c, 0x10, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0x84, 0xd5, 0xc0, 0x08, 0x00, 0x95, 0x33, 0x00, 0x64, 0x8e, 0x00,
+  0x8c, 0x25, 0x04, 0x00, 0xad, 0x25, 0x50, 0x04, 0x65, 0x40, 0xef, 0x58,
+  0x03, 0x10, 0x08, 0x73, 0x0c, 0x50, 0x1c, 0xc4, 0xc1, 0x1c, 0x03, 0xe4,
+  0xc4, 0xc1, 0x58, 0x03, 0x30, 0x10, 0x04, 0x8c, 0x00, 0x8c, 0x11, 0x80,
+  0x20, 0x08, 0xe2, 0xdf, 0x18, 0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x63,
+  0x04, 0x20, 0x08, 0x82, 0x24, 0x18, 0xcc, 0x00, 0x50, 0x30, 0x03, 0x30,
+  0x03, 0x30, 0x07, 0xc1, 0x07, 0x7b, 0xc0, 0x07, 0x7f, 0x40, 0xc2, 0x0c,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x34, 0x00, 0x00,
+  0x00, 0x22, 0x47, 0xc8, 0x90, 0x51, 0x16, 0xc8, 0x49, 0x00, 0x00, 0x00,
+  0x00, 0x63, 0x60, 0x61, 0x98, 0x05, 0x00, 0x00, 0x00, 0x61, 0x69, 0x72,
+  0x2d, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65,
+  0x73, 0x28, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x31, 0x32, 0x5f, 0x66,
+  0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x29, 0x61, 0x69, 0x72, 0x2d,
+  0x61, 0x6c, 0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d,
+  0x61, 0x72, 0x67, 0x28, 0x33, 0x29, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c,
+  0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x73, 0x61,
+  0x6d, 0x70, 0x6c, 0x65, 0x72, 0x73, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c,
+  0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x74, 0x65,
+  0x78, 0x74, 0x75, 0x72, 0x65, 0x73, 0x61, 0x69, 0x72, 0x2d, 0x61, 0x6c,
+  0x69, 0x61, 0x73, 0x2d, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2d, 0x61, 0x72,
+  0x67, 0x28, 0x34, 0x29, 0x00, 0x2b, 0x84, 0x7a, 0x80, 0x87, 0x15, 0x83,
+  0x3d, 0xd4, 0x43, 0x3c, 0xac, 0x18, 0xee, 0xa1, 0x1e, 0xe4, 0x61, 0xc5,
+  0x80, 0x0f, 0xf5, 0x30, 0x0f, 0x2b, 0x86, 0x7c, 0xa8, 0x07, 0x7a, 0xd8,
+  0x10, 0xd8, 0xc3, 0x86, 0x21, 0x1f, 0xf0, 0xe1, 0x1e, 0x36, 0x08, 0xf8,
+  0x70, 0x0f, 0x1b, 0x04, 0x7b, 0xc8, 0x87, 0x0d, 0x41, 0x3e, 0x6c, 0x18,
+  0xec, 0x01, 0x1f, 0xee, 0x01, 0x7b, 0x18, 0x34, 0x33, 0xb0, 0x03, 0x0a,
+  0x80, 0x31, 0x1c, 0x11, 0x24, 0x81, 0x7f, 0xcc, 0x32, 0x04, 0x42, 0x30,
+  0x62, 0xd0, 0x18, 0x21, 0x08, 0x06, 0x67, 0xb0, 0x07, 0x5b, 0xe6, 0x61,
+  0xd5, 0xc5, 0x30, 0x77, 0x30, 0x9a, 0x10, 0x00, 0x23, 0x06, 0x8d, 0x11,
+  0x82, 0x60, 0x70, 0x06, 0x7d, 0xc0, 0x6d, 0x60, 0xa0, 0x5d, 0x99, 0xe3,
+  0xe4, 0xc1, 0x68, 0x42, 0x00, 0x0c, 0x32, 0x0c, 0xca, 0x34, 0xc8, 0x20,
+  0x30, 0xd3, 0x20, 0x83, 0x10, 0x4c, 0x37, 0x06, 0xf0, 0x52, 0x10, 0x94,
+  0x41, 0x86, 0x00, 0xca, 0x8c, 0x08, 0xc0, 0x7f, 0x23, 0xc3, 0x19, 0xd0,
+  0x01, 0x29, 0x5c, 0x00, 0x2f, 0x05, 0x41, 0x19, 0x64, 0x08, 0x2a, 0x6f,
+  0xc4, 0xe0, 0x38, 0x42, 0x10, 0x2c, 0xfc, 0x63, 0x83, 0x85, 0x22, 0x98,
+  0x63, 0xb0, 0x82, 0x3c, 0xd8, 0x48, 0xd1, 0x06, 0x7a, 0xa0, 0x0a, 0xa8,
+  0x40, 0x06, 0x17, 0xc0, 0x4b, 0x41, 0x50, 0x06, 0x19, 0x82, 0x8d, 0x0c,
+  0x46, 0x0c, 0x8e, 0x23, 0x04, 0xc1, 0xc2, 0x3f, 0x36, 0x5b, 0x58, 0x82,
+  0x39, 0x06, 0x23, 0x48, 0x83, 0x8d, 0x14, 0x73, 0x00, 0x0a, 0xb0, 0xe0,
+  0x0a, 0x69, 0x70, 0x01, 0xbc, 0x14, 0x04, 0x65, 0x90, 0x21, 0x08, 0x03,
+  0x35, 0x18, 0x31, 0x38, 0x8e, 0x10, 0x04, 0x0b, 0xff, 0xd8, 0x78, 0x21,
+  0x0a, 0xe6, 0x18, 0x8c, 0xc0, 0x0d, 0x66, 0x09, 0x88, 0xe1, 0x88, 0xcf,
+  0x0c, 0x02, 0xff, 0x98, 0x65, 0x18, 0x88, 0x60, 0xc4, 0xa0, 0x31, 0x42,
+  0x10, 0x0c, 0xce, 0x20, 0x17, 0xf2, 0xe0, 0x0e, 0xf8, 0xc0, 0x0e, 0xe6,
+  0xa0, 0x0e, 0xd4, 0x40, 0x0d, 0x6a, 0x61, 0x34, 0x21, 0x00, 0x46, 0x0c,
+  0x1a, 0x23, 0x04, 0xc1, 0xe0, 0x0c, 0x76, 0x41, 0x0f, 0xf2, 0xc0, 0x0f,
+  0xf0, 0xa0, 0x0e, 0xee, 0x80, 0x0d, 0xd8, 0xe0, 0x16, 0x46, 0x13, 0x02,
+  0x60, 0x90, 0x21, 0x48, 0x03, 0x3b, 0x18, 0x64, 0x20, 0xd2, 0x40, 0x0e,
+  0x06, 0x19, 0x04, 0x34, 0x90, 0x83, 0x41, 0x06, 0x21, 0x90, 0x83, 0x13,
+  0x05, 0x78, 0x29, 0x08, 0xca, 0x20, 0x43, 0xf0, 0x06, 0x78, 0x60, 0x44,
+  0x00, 0xfe, 0x1b, 0x19, 0x4c, 0x61, 0x16, 0xc6, 0xe1, 0x02, 0x78, 0x29,
+  0x08, 0xca, 0x20, 0x43, 0x40, 0x07, 0x7d, 0x30, 0x62, 0x70, 0x1c, 0x21,
+  0x08, 0x16, 0xfe, 0xb1, 0xbd, 0x43, 0x11, 0xcc, 0x31, 0xd4, 0x41, 0x80,
+  0x0b, 0x1b, 0x29, 0x58, 0x21, 0x17, 0xd2, 0xe1, 0x1c, 0x46, 0xe1, 0x02,
+  0x78, 0x29, 0x08, 0xca, 0x20, 0x43, 0xa0, 0x07, 0xa3, 0x30, 0x62, 0x70,
+  0x1c, 0x21, 0x08, 0x16, 0xfe, 0xb1, 0xd5, 0xc3, 0x12, 0xcc, 0x31, 0x18,
+  0x01, 0x2a, 0x6c, 0xa4, 0x90, 0x85, 0x5f, 0x78, 0x87, 0x76, 0x40, 0x85,
+  0x0b, 0xe0, 0xa5, 0x20, 0x28, 0x83, 0x0c, 0x01, 0x28, 0xa4, 0xc2, 0x88,
+  0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0xb6, 0x0f, 0x51, 0x30, 0xc7,
+  0x60, 0x04, 0xad, 0x30, 0x4b, 0x40, 0x0c, 0x74, 0x04, 0xa0, 0x10, 0x08,
+  0x83, 0x48, 0x08, 0x73, 0x0c, 0x01, 0x2a, 0xb8, 0xc2, 0x88, 0xc1, 0x81,
+  0xc4, 0x20, 0x58, 0xf8, 0x07, 0x44, 0x12, 0xc1, 0x2e, 0x58, 0xe0, 0x0b,
+  0xe2, 0x9f, 0x41, 0x40, 0x0c, 0x19, 0x00, 0x00, 0x00, 0x5b, 0x8e, 0x20,
+  0x70, 0x87, 0x23, 0x1f, 0x10, 0x7d, 0xd8, 0x52, 0x10, 0xc7, 0x3e, 0x20,
+  0xfc, 0xb0, 0xa5, 0x30, 0x8e, 0x7d, 0x40, 0xf8, 0x61, 0x4b, 0xc1, 0x1c,
+  0xfd, 0x80, 0xf8, 0xc3, 0x96, 0x22, 0x3a, 0xfa, 0x01, 0xf1, 0x87, 0x2d,
+  0xc5, 0x75, 0xf4, 0x03, 0xe2, 0x0f, 0x5b, 0x8a, 0xee, 0xe8, 0x07, 0xc4,
+  0x1f, 0xb6, 0x14, 0x64, 0x70, 0xec, 0x03, 0xc2, 0x0f, 0x5b, 0x0a, 0x33,
+  0x38, 0xf6, 0x01, 0xe1, 0x87, 0x2d, 0x45, 0x1b, 0x1c, 0xfd, 0x80, 0xf8,
+  0xc3, 0x96, 0x42, 0x0e, 0x8e, 0x7e, 0x40, 0xfc, 0x61, 0x4b, 0x81, 0x07,
+  0x47, 0x3f, 0x20, 0xfe, 0xb0, 0xa5, 0xf0, 0x83, 0xa3, 0x1f, 0x10, 0x7f,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00, 0x00, 0xbe, 0x01, 0x00,
+  0x00, 0x13, 0x04, 0x6e, 0x10, 0x0b, 0x04, 0x00, 0x00, 0x4f, 0x00, 0x00,
+  0x00, 0x54, 0xce, 0x00, 0xd0, 0x5a, 0x02, 0x45, 0x40, 0xef, 0x58, 0x03,
+  0x10, 0x08, 0x23, 0x00, 0x34, 0xcf, 0x41, 0x40, 0x4e, 0x93, 0x06, 0x63,
+  0x11, 0x40, 0x20, 0x1c, 0x04, 0x8c, 0x11, 0xf0, 0xf0, 0xaa, 0xd3, 0xdd,
+  0x18, 0x81, 0x2c, 0xba, 0x3d, 0x0d, 0x06, 0x63, 0x04, 0xb5, 0x5a, 0xab,
+  0xed, 0x37, 0x46, 0xd0, 0xc7, 0xa2, 0x8b, 0x7f, 0x63, 0x04, 0x6e, 0x1f,
+  0x8b, 0xb6, 0x2f, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18, 0x81,
+  0x79, 0xaf, 0xab, 0xec, 0x8d, 0x11, 0xc4, 0x3c, 0xd8, 0xe7, 0xde, 0x18,
+  0x81, 0xdb, 0xc7, 0xa2, 0xed, 0x8d, 0x11, 0xbc, 0x7b, 0x5a, 0xde, 0xdf,
+  0x18, 0x81, 0xce, 0x9a, 0x73, 0x08, 0x06, 0x23, 0x00, 0x63, 0x04, 0x20,
+  0x08, 0x82, 0x24, 0x18, 0x8c, 0x11, 0x80, 0x20, 0x08, 0x82, 0x60, 0x30,
+  0x03, 0x40, 0xc1, 0x0c, 0xc0, 0x0c, 0xc0, 0x1c, 0x44, 0x1d, 0xec, 0x41,
+  0x1d, 0xf8, 0x01, 0x15, 0x33, 0x00, 0x23, 0x00, 0x33, 0x00, 0x63, 0x0d,
+  0x20, 0x08, 0x82, 0xf8, 0x07, 0x82, 0x20, 0x88, 0x7f, 0x20, 0x08, 0x82,
+  0xf8, 0x37, 0xd6, 0xc0, 0xb6, 0xf3, 0x4f, 0x7a, 0x6c, 0x3b, 0xff, 0xa4,
+  0xc7, 0xb6, 0xf3, 0x4f, 0x7a, 0x63, 0x0d, 0x20, 0x08, 0xb2, 0xf5, 0x2f,
+  0x80, 0x20, 0xc8, 0xd6, 0xbf, 0x00, 0x82, 0x20, 0x5b, 0xff, 0xc2, 0x58,
+  0x03, 0x08, 0x82, 0x6b, 0x0e, 0x06, 0x20, 0x08, 0xae, 0x39, 0x18, 0x80,
+  0x20, 0xb8, 0xe6, 0x60, 0x30, 0xd6, 0x00, 0x82, 0x74, 0x9b, 0x83, 0x01,
+  0x08, 0xd2, 0x6d, 0x0e, 0x06, 0x20, 0x48, 0xb7, 0x39, 0x18, 0x8c, 0x35,
+  0xac, 0x23, 0x1e, 0xb3, 0x60, 0xb0, 0x8e, 0x78, 0xcc, 0x82, 0xc1, 0x3a,
+  0xe2, 0x31, 0x0b, 0x06, 0x63, 0x0d, 0x20, 0x08, 0xe3, 0xe1, 0x18, 0x80,
+  0x20, 0x8c, 0x87, 0x63, 0x00, 0x82, 0x30, 0x1e, 0x8e, 0xc1, 0x58, 0x83,
+  0x98, 0x8b, 0x69, 0xff, 0x81, 0x25, 0xcf, 0xc6, 0xbf, 0x30, 0xa6, 0xab,
+  0x9a, 0xfb, 0xc2, 0x58, 0xc3, 0x3f, 0x93, 0xfe, 0xef, 0x0b, 0x74, 0x0d,
+  0x8a, 0xf9, 0xd7, 0xc2, 0x71, 0x0c, 0xfa, 0xc2, 0x58, 0xc3, 0xdc, 0xb7,
+  0x69, 0xea, 0x0b, 0xad, 0x1b, 0xf2, 0xbc, 0x2f, 0xf0, 0x39, 0xeb, 0xe3,
+  0x1f, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x0c, 0x00, 0x00,
+  0x00, 0x1b, 0x06, 0x77, 0x68, 0x87, 0x57, 0xd8, 0x30, 0xb8, 0x43, 0x3b,
+  0xd0, 0xc2, 0x86, 0xc1, 0x1d, 0xda, 0x21, 0x16, 0x36, 0x0c, 0xee, 0xd0,
+  0x0e, 0xb2, 0xb0, 0x61, 0x70, 0x87, 0x76, 0x98, 0x85, 0x0d, 0x83, 0x3b,
+  0xb4, 0x03, 0x2c, 0x6c, 0x18, 0xdc, 0xa1, 0x1d, 0x5a, 0x01, 0x00, 0x00,
+  0x00, 0x7b, 0x18, 0xce, 0x20, 0x0e, 0x44, 0x81, 0x02, 0x60, 0x0c, 0x47,
+  0x04, 0x55, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0x0c, 0x32, 0xac, 0xc1,
+  0x64, 0x06, 0x7b, 0x18, 0xd6, 0xa0, 0x0e, 0xec, 0x80, 0x02, 0x60, 0x8c,
+  0x18, 0x18, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x84, 0xc1, 0x2a, 0x0c, 0x23,
+  0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x5f, 0x2b, 0x04, 0x90, 0x05,
+  0x10, 0xf8, 0x8f, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x7c, 0xad,
+  0x10, 0x54, 0x36, 0x44, 0xe2, 0x6f, 0x51, 0x10, 0xfe, 0x36, 0x04, 0xe4,
+  0x3f, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x11, 0x06, 0xb2, 0x10,
+  0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x7c, 0xb4, 0x10, 0x4c,
+  0x16, 0x4c, 0xe2, 0x3f, 0xc7, 0xd0, 0x2d, 0xa1, 0x30, 0xc8, 0x10, 0x78,
+  0x73, 0x60, 0x43, 0x40, 0xfe, 0x83, 0x0c, 0x01, 0x18, 0xd0, 0xc1, 0x20,
+  0x43, 0xc0, 0x07, 0x74, 0x30, 0x4b, 0x20, 0x0c, 0x54, 0x04, 0x42, 0xa0,
+  0x0f, 0xc0, 0x1e, 0x86, 0x3e, 0x38, 0x05, 0x5b, 0xa0, 0x00, 0x18, 0xc3,
+  0x11, 0x01, 0x1b, 0x38, 0xfe, 0x31, 0xcb, 0x30, 0x10, 0xc1, 0x20, 0x03,
+  0x91, 0x06, 0x7c, 0xb0, 0x87, 0x21, 0x14, 0x56, 0xc1, 0x15, 0x28, 0x00,
+  0xc6, 0x1e, 0x86, 0x51, 0x68, 0x85, 0x57, 0xa0, 0x00, 0x18, 0x23, 0x06,
+  0x4a, 0x12, 0x83, 0x60, 0xe1, 0x1f, 0x9d, 0x39, 0x14, 0xdd, 0x31, 0x04,
+  0x83, 0x0c, 0x01, 0x1b, 0x80, 0xc2, 0x20, 0x43, 0xb0, 0x80, 0xc2, 0x2c,
+  0x01, 0x31, 0x50, 0x11, 0x08, 0x03, 0x26, 0x0c, 0x47, 0x84, 0x01, 0x1f,
+  0x04, 0xfe, 0x31, 0xcb, 0x50, 0x4c, 0xc1, 0x1e, 0x06, 0x55, 0xa0, 0x05,
+  0x72, 0xa0, 0x00, 0x18, 0xc3, 0x11, 0xc1, 0x1f, 0x04, 0xfe, 0x31, 0xcb,
+  0x60, 0x1c, 0xc1, 0x20, 0x43, 0x61, 0x07, 0xa9, 0xb0, 0x87, 0xc1, 0x15,
+  0x70, 0xa1, 0x1c, 0x28, 0x00, 0xc6, 0x1c, 0x83, 0x1d, 0x04, 0xba, 0x30,
+  0xc8, 0x10, 0xdc, 0x01, 0x2b, 0x58, 0x50, 0x88, 0xff, 0x20, 0x43, 0x90,
+  0x07, 0xad, 0x30, 0x4b, 0xd0, 0x06, 0x7b, 0x18, 0x68, 0xc1, 0x17, 0xd8,
+  0x81, 0x02, 0x60, 0xec, 0x61, 0xb0, 0x05, 0x70, 0x68, 0x07, 0x0a, 0x80,
+  0x31, 0xc8, 0x00, 0x85, 0x82, 0x2c, 0x8c, 0x18, 0x14, 0x47, 0x08, 0x82,
+  0x41, 0xc6, 0x0f, 0xc4, 0x2c, 0x03, 0x22, 0x05, 0x63, 0x08, 0x12, 0x39,
+  0x0c, 0x47, 0x04, 0xad, 0xa0, 0xf8, 0xc7, 0x2c, 0x83, 0x92, 0x04, 0x26,
+  0xb4, 0x82, 0xf8, 0xcf, 0x12, 0x2c, 0x36, 0xb4, 0x02, 0xf8, 0x8f, 0x18,
+  0x18, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x58, 0x22, 0x11, 0x58, 0xe0, 0x0a,
+  0xe2, 0x3f, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0x95, 0x44,
+  0xe0, 0x0a, 0xb3, 0x04, 0xcb, 0x40, 0x05, 0xa0, 0x24, 0x82, 0x32, 0xc7,
+  0xa0, 0x0a, 0x01, 0x3b, 0x8c, 0x21, 0x6c, 0xe1, 0x30, 0x1c, 0x11, 0xd8,
+  0x82, 0xe2, 0x1f, 0xb3, 0x0c, 0x0d, 0x13, 0x98, 0x60, 0x0b, 0xe2, 0x3f,
+  0x4b, 0xe0, 0xd8, 0x60, 0x0b, 0xe0, 0x3f, 0x62, 0x60, 0x1c, 0x21, 0x08,
+  0x16, 0xfe, 0x61, 0xad, 0x44, 0x60, 0xc1, 0x2d, 0x88, 0xff, 0x88, 0xc1,
+  0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0xe5, 0x12, 0xc1, 0x2d, 0xcc, 0x12,
+  0x38, 0x03, 0x15, 0x80, 0xc2, 0x08, 0xcd, 0x1c, 0x43, 0x12, 0xa4, 0xc3,
+  0x18, 0x02, 0x19, 0xa4, 0xc3, 0x70, 0x44, 0xf0, 0x0b, 0x8a, 0x7f, 0xcc,
+  0x32, 0x40, 0x4f, 0x60, 0xc2, 0x2f, 0x88, 0xff, 0x2c, 0x41, 0x64, 0xc3,
+  0x2f, 0x80, 0xff, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0x45,
+  0x13, 0x81, 0x05, 0xe0, 0x20, 0xfe, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60,
+  0xe1, 0x1f, 0xd4, 0x4d, 0x04, 0xe0, 0x30, 0x4b, 0x10, 0x0d, 0x54, 0x00,
+  0xca, 0x23, 0x40, 0x73, 0x0c, 0x49, 0x10, 0x0f, 0xb3, 0x04, 0xd2, 0x40,
+  0x45, 0x20, 0x44, 0x7a, 0x70, 0x0c, 0x32, 0x04, 0xbf, 0x20, 0x0f, 0x73,
+  0x0c, 0xbd, 0x00, 0x06, 0x21, 0x31, 0xc8, 0x10, 0xf8, 0xc2, 0x3c, 0xd8,
+  0x10, 0x88, 0xff, 0x20, 0x43, 0x00, 0x0e, 0xf4, 0x30, 0x4b, 0xd0, 0x06,
+  0xc3, 0x11, 0xb3, 0x60, 0x0e, 0x81, 0x7f, 0xcc, 0x32, 0x50, 0x60, 0x10,
+  0x0c, 0x32, 0xd0, 0x41, 0x39, 0xe0, 0xc3, 0x1e, 0x86, 0x7e, 0x38, 0x89,
+  0x9a, 0xa0, 0x00, 0x18, 0x7b, 0x18, 0xfe, 0x21, 0x25, 0x6c, 0x82, 0x02,
+  0x60, 0xcc, 0x31, 0x9c, 0x43, 0xb0, 0x12, 0x83, 0x0c, 0x01, 0x3a, 0xf4,
+  0x83, 0x05, 0x87, 0xf8, 0x0f, 0x32, 0x04, 0xea, 0xe0, 0x0f, 0x23, 0x06,
+  0xc5, 0x11, 0x82, 0x60, 0x90, 0xa1, 0xc5, 0x31, 0xcb, 0xf0, 0x55, 0xc1,
+  0x18, 0xc2, 0x00, 0x13, 0xc3, 0x11, 0xc1, 0x3f, 0x28, 0xfe, 0x31, 0xcb,
+  0x70, 0x59, 0x81, 0x09, 0xff, 0x20, 0xfe, 0xb3, 0x04, 0xd8, 0x88, 0x81,
+  0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0xd5, 0x16, 0xc3, 0x88, 0xc1, 0x71,
+  0x84, 0x20, 0x58, 0xf8, 0x07, 0xf5, 0x16, 0x01, 0x48, 0x58, 0x00, 0x12,
+  0xe2, 0x6f, 0x01, 0x48, 0x80, 0xff, 0x2c, 0x01, 0x36, 0x50, 0x01, 0x28,
+  0x96, 0x70, 0xcd, 0x31, 0xc8, 0x43, 0x80, 0x13, 0x63, 0x08, 0x4c, 0x4b,
+  0x0c, 0x47, 0x04, 0x28, 0xa1, 0xf8, 0xc7, 0x2c, 0x83, 0x96, 0x05, 0x26,
+  0xa0, 0x84, 0xf8, 0xcf, 0x12, 0x6c, 0x23, 0x06, 0xc6, 0x11, 0x82, 0x60,
+  0xe1, 0x1f, 0x96, 0x5d, 0x0c, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1,
+  0x1f, 0x14, 0x5e, 0x04, 0x29, 0x61, 0x41, 0x4a, 0x88, 0xbf, 0x05, 0x29,
+  0x01, 0xfe, 0xb3, 0x04, 0xdb, 0x40, 0x05, 0xa0, 0x64, 0x82, 0x36, 0xc7,
+  0x90, 0x04, 0x35, 0x31, 0x86, 0x50, 0xd5, 0xc4, 0x70, 0x44, 0x10, 0x13,
+  0x8a, 0x7f, 0xcc, 0x32, 0x74, 0x5c, 0x60, 0x42, 0x4c, 0x88, 0xff, 0x2c,
+  0x81, 0x37, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0xfd, 0xc5,
+  0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0x85, 0x46, 0x20,
+  0x13, 0x16, 0xc8, 0x84, 0xf8, 0x5b, 0x20, 0x13, 0xe0, 0x3f, 0x4b, 0xe0,
+  0x0d, 0x54, 0x00, 0x0a, 0x27, 0x74, 0x73, 0x0c, 0x49, 0xd0, 0x13, 0x23,
+  0x06, 0xc8, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0xd2, 0x69, 0x04, 0x26, 0x41,
+  0x12, 0x83, 0x0c, 0x01, 0x4a, 0xf0, 0xc4, 0x2c, 0xc1, 0x37, 0x50, 0x11,
+  0xf8, 0x01, 0x25, 0x78, 0x83, 0x0c, 0x41, 0x4b, 0xf8, 0xc4, 0x2c, 0x41,
+  0x1b, 0xcc, 0x32, 0x84, 0x41, 0x1b, 0xf0, 0xc3, 0x20, 0x43, 0x2f, 0xb8,
+  0x44, 0x58, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x6c, 0xa8,
+  0x11, 0x88, 0xc4, 0x1c, 0xc3, 0x4a, 0x04, 0x71, 0x31, 0x62, 0x70, 0x1c,
+  0x21, 0x08, 0x16, 0xfe, 0xb1, 0xa9, 0xc6, 0x30, 0x12, 0x73, 0x0c, 0x42,
+  0x70, 0x16, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x1b, 0x6b,
+  0x14, 0x24, 0x31, 0xc7, 0x20, 0x04, 0x68, 0x31, 0xc8, 0x10, 0xc8, 0x84,
+  0x59, 0x0c, 0x32, 0x04, 0xe5, 0x60, 0x16, 0x7b, 0x18, 0xdc, 0x02, 0x2f,
+  0x4c, 0x83, 0x02, 0x60, 0xec, 0x61, 0x80, 0x0b, 0xbd, 0x38, 0x0d, 0x0a,
+  0x80, 0x31, 0xc7, 0x80, 0x13, 0x01, 0x5f, 0x0c, 0x32, 0x04, 0x39, 0xe1,
+  0x16, 0x16, 0x24, 0xe2, 0x3f, 0xc8, 0x10, 0xec, 0xc4, 0x5b, 0x8c, 0x18,
+  0x14, 0x47, 0x08, 0x82, 0x41, 0x96, 0x1b, 0xc7, 0x2c, 0x03, 0x1b, 0x88,
+  0x41, 0x30, 0x86, 0x30, 0x84, 0xc6, 0x70, 0x44, 0x00, 0x17, 0x8a, 0x7f,
+  0xcc, 0x32, 0x90, 0xc1, 0x18, 0x04, 0x26, 0xc0, 0x85, 0xf8, 0xcf, 0x12,
+  0x94, 0xc1, 0x88, 0x81, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x87, 0xe5, 0x1b,
+  0xc3, 0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0x07, 0x05, 0x1e, 0x41,
+  0x5c, 0x58, 0x10, 0x17, 0xe2, 0x6f, 0x41, 0x5c, 0x80, 0xff, 0x2c, 0x41,
+  0x19, 0x0c, 0x54, 0x00, 0xca, 0x18, 0x08, 0x64, 0x30, 0xc7, 0x30, 0x16,
+  0x41, 0x6a, 0x8c, 0x21, 0x30, 0x7e, 0x31, 0x1c, 0x11, 0xe4, 0x85, 0xe2,
+  0x1f, 0xb3, 0x0c, 0x67, 0x60, 0x06, 0x81, 0x09, 0x79, 0x21, 0xfe, 0xb3,
+  0x04, 0x68, 0x30, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0x9d,
+  0xc7, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xa5, 0x47,
+  0xa0, 0x17, 0x16, 0xe8, 0x85, 0xf8, 0x5b, 0xa0, 0x17, 0xe0, 0x3f, 0x4b,
+  0x80, 0x06, 0x03, 0x15, 0x80, 0x62, 0x06, 0xc2, 0x19, 0xcc, 0x31, 0x24,
+  0x81, 0x69, 0x8c, 0x21, 0x54, 0xa6, 0x31, 0x1c, 0x11, 0x88, 0x86, 0xe2,
+  0x1f, 0xb3, 0x0c, 0x6a, 0x90, 0x06, 0x81, 0x09, 0xa2, 0x21, 0xfe, 0xb3,
+  0x04, 0x6b, 0x30, 0x62, 0x60, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x61, 0xc1,
+  0xc7, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xc9, 0x47,
+  0x30, 0x1a, 0x16, 0x8c, 0x86, 0xf8, 0x5b, 0x30, 0x1a, 0xe0, 0x3f, 0x4b,
+  0xb0, 0x06, 0x03, 0x15, 0x80, 0x92, 0x06, 0x82, 0x1a, 0xcc, 0x31, 0x24,
+  0x81, 0x6b, 0x8c, 0x18, 0x20, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x48, 0xf8,
+  0x11, 0xdc, 0x45, 0x5d, 0x0c, 0x32, 0x04, 0x79, 0xd1, 0x1a, 0xb3, 0x04,
+  0x6c, 0x30, 0x50, 0x11, 0xf8, 0x41, 0x18, 0x08, 0x6b, 0x30, 0xc8, 0x10,
+  0xf8, 0xc5, 0x6b, 0xcc, 0x12, 0xb4, 0xc1, 0x40, 0x4b, 0xc0, 0x23, 0x06,
+  0x8f, 0x48, 0x3c, 0xf2, 0xc9, 0x02, 0x1b, 0xf0, 0x08, 0x18, 0x0c, 0xb4,
+  0x04, 0x28, 0x62, 0xe8, 0x85, 0x64, 0x0e, 0x1f, 0xc1, 0x06, 0xfc, 0x02,
+  0x06, 0x83, 0x0c, 0x81, 0x10, 0x1b, 0x19, 0x04, 0xc4, 0x00, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0x5b, 0x86, 0x20, 0x78, 0x87, 0x2d, 0x83,
+  0x11, 0xc0, 0xc3, 0x96, 0x21, 0x0b, 0xe2, 0x61, 0xcb, 0xe0, 0x05, 0xf2,
+  0xb0, 0x65, 0x00, 0x83, 0x60, 0x1e, 0xb6, 0x0c, 0x69, 0x10, 0xb8, 0xc3,
+  0x96, 0xc1, 0x0d, 0x02, 0x7a, 0xd8, 0x32, 0xd4, 0x41, 0x50, 0x0f, 0x5b,
+  0x86, 0x3b, 0x08, 0xe8, 0x61, 0xcb, 0xb0, 0x0e, 0x41, 0x3d, 0x6c, 0x19,
+  0xda, 0x21, 0xa0, 0x87, 0x2d, 0x43, 0x5a, 0x04, 0xf5, 0xb0, 0x65, 0x58,
+  0x8b, 0x80, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x20, 0x00,
+  0x00, 0x73, 0x00, 0x00, 0x00, 0x13, 0x04, 0x4a, 0x2c, 0x10, 0x00, 0x00,
+  0x00, 0x25, 0x00, 0x00, 0x00, 0x54, 0xce, 0x00, 0xd0, 0x5a, 0x02, 0x45,
+  0x40, 0xef, 0x58, 0x03, 0x10, 0x08, 0x23, 0x00, 0x34, 0xcf, 0x41, 0x40,
+  0x4e, 0xc3, 0x06, 0x04, 0x8c, 0x11, 0x80, 0x20, 0x08, 0xe2, 0xdf, 0x18,
+  0x01, 0x08, 0x82, 0x20, 0x08, 0x06, 0x23, 0x00, 0x14, 0xcc, 0x00, 0xcc,
+  0x00, 0x50, 0x31, 0x03, 0x30, 0xd6, 0xc0, 0xb2, 0x67, 0x28, 0x7f, 0xa8,
+  0x5f, 0xc6, 0xea, 0x97, 0x9f, 0xba, 0x38, 0x7b, 0x63, 0x0d, 0x7a, 0x0d,
+  0xee, 0xb8, 0xa7, 0xe2, 0xb9, 0x6d, 0x7f, 0x6f, 0x9f, 0xd2, 0xa3, 0x37,
+  0xd6, 0xb0, 0xce, 0x31, 0x8b, 0x7a, 0x69, 0x08, 0xa3, 0xbb, 0x77, 0xb7,
+  0xb1, 0x6a, 0x7f, 0x63, 0x0d, 0x62, 0x2e, 0xa6, 0xfd, 0x07, 0x96, 0x3c,
+  0x1b, 0xff, 0xc2, 0x98, 0xae, 0x6a, 0xee, 0x0b, 0x63, 0x0d, 0xff, 0x4c,
+  0xfa, 0xbf, 0x2f, 0xd0, 0x35, 0x28, 0xe6, 0x5f, 0x0b, 0xc7, 0x31, 0xe8,
+  0x0b, 0x63, 0x0d, 0x73, 0xdf, 0xa6, 0xa9, 0x2f, 0xb4, 0x6e, 0xc8, 0xf3,
+  0xbe, 0xc0, 0xe7, 0xac, 0x8f, 0x7f, 0x00, 0x00, 0x00, 0x83, 0x0c, 0xd7,
+  0xd1, 0x0c, 0x47, 0x58, 0x4d, 0xe0, 0x1f, 0xb3, 0x0c, 0x81, 0x10, 0xcc,
+  0x31, 0x24, 0x96, 0x18, 0x0c, 0x32, 0x04, 0x4a, 0x64, 0xc1, 0x26, 0xfe,
+  0x83, 0x0c, 0x01, 0x23, 0xcd, 0x12, 0x24, 0xc3, 0x11, 0x5b, 0x14, 0xf8,
+  0xc7, 0x2c, 0xc3, 0x90, 0x04, 0xc3, 0x11, 0x9d, 0x14, 0xf8, 0xc7, 0x2c,
+  0x03, 0x51, 0x04, 0x23, 0x06, 0xc7, 0x11, 0x82, 0x60, 0xe1, 0x1f, 0x1b,
+  0x28, 0x7c, 0xce, 0x1c, 0x43, 0x14, 0xa4, 0xc1, 0x88, 0xc1, 0x71, 0x84,
+  0x20, 0x58, 0xf8, 0xc7, 0x26, 0x0a, 0x61, 0xf0, 0xcc, 0x31, 0x08, 0x01,
+  0x37, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0xb1, 0x91, 0xc2, 0x18,
+  0x40, 0x73, 0x0c, 0x42, 0xd0, 0xcd, 0x12, 0x14, 0x03, 0x15, 0x81, 0x40,
+  0x70, 0xc3, 0x18, 0x42, 0xf0, 0x06, 0x63, 0x08, 0x42, 0x18, 0x8c, 0x21,
+  0x0c, 0x61, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16, 0xfe, 0x41, 0xa1,
+  0x82, 0x10, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85, 0x7f, 0x50, 0xa9,
+  0x40, 0x04, 0xc3, 0x11, 0x81, 0x27, 0xf8, 0xc7, 0x2c, 0x83, 0x71, 0x04,
+  0x83, 0x0c, 0x87, 0x47, 0x06, 0x36, 0xa8, 0x81, 0xf8, 0x5b, 0x30, 0x06,
+  0xe0, 0x6f, 0xc5, 0x1a, 0x88, 0xbf, 0x05, 0x65, 0x00, 0xfe, 0x36, 0x04,
+  0xe4, 0x3f, 0xc7, 0x20, 0x06, 0xc1, 0x1e, 0x0c, 0x32, 0x04, 0x63, 0xa0,
+  0x06, 0x16, 0x20, 0xe2, 0x3f, 0xc8, 0x10, 0x94, 0xc1, 0x1a, 0xcc, 0x12,
+  0x1c, 0x03, 0x15, 0x81, 0x60, 0x88, 0x41, 0x31, 0xcb, 0x80, 0x24, 0xd9,
+  0x20, 0x43, 0x90, 0x06, 0x6f, 0x30, 0x62, 0x70, 0x1c, 0x21, 0x08, 0x16,
+  0xfe, 0xb1, 0xe5, 0x42, 0x40, 0x06, 0x73, 0x0c, 0x6a, 0x10, 0x88, 0xc2,
+  0x88, 0xc1, 0x71, 0x84, 0x20, 0x58, 0xf8, 0xc7, 0xb6, 0x0b, 0x43, 0x19,
+  0xcc, 0x31, 0x08, 0x41, 0x1d, 0x8c, 0x18, 0x1c, 0x47, 0x08, 0x82, 0x85,
+  0x7f, 0x6c, 0xbd, 0x50, 0x98, 0xc1, 0x1c, 0x83, 0x10, 0xd8, 0xc1, 0x2c,
+  0x41, 0x32, 0x50, 0x12, 0x90, 0x42, 0xe0, 0x0a, 0x82, 0x80, 0x40, 0xc7,
+  0x20, 0x43, 0x10, 0x07, 0x77, 0x90, 0x01, 0x00, 0x00, 0x71, 0x20, 0x00,
+  0x00, 0x04, 0x00, 0x00, 0x00, 0x32, 0x0e, 0x10, 0x22, 0x84, 0x00, 0xd2,
+  0x09, 0x18, 0xd0, 0xba, 0x80, 0x07, 0xed, 0x0e, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x65, 0x0c, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94,
+  0x30, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1e, 0x01, 0x00,
+  0x00, 0x09, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x27, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x47, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0x38, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x00, 0x00, 0x49, 0x00, 0x00,
+  0x00, 0x14, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x5d, 0x00, 0x00,
+  0x00, 0x10, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x6d, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x7e, 0x00, 0x00,
+  0x00, 0x16, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x94, 0x00, 0x00,
+  0x00, 0x0d, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xa1, 0x00, 0x00,
+  0x00, 0x19, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x00, 0x00, 0xba, 0x00, 0x00,
+  0x00, 0x11, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xcb, 0x00, 0x00,
+  0x00, 0x12, 0x00, 0x00, 0x00, 0xcb, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xdd, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0xf0, 0x00, 0x00,
+  0x00, 0x13, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x03, 0x01, 0x00,
+  0x00, 0x1b, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x1b, 0x00, 0x00,
+  0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x5d, 0x0c, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x12, 0x03, 0x94,
+  0xa7, 0x02, 0x00, 0x00, 0x00, 0x53, 0x44, 0x4c, 0x5f, 0x4e, 0x56, 0x31,
+  0x32, 0x5f, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x5a,
+  0x31, 0x34, 0x47, 0x65, 0x74, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x43,
+  0x6f, 0x6c, 0x6f, 0x72, 0x44, 0x76, 0x34, 0x5f, 0x66, 0x52, 0x55, 0x31,
+  0x31, 0x4d, 0x54, 0x4c, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74,
+  0x4b, 0x31, 0x35, 0x53, 0x68, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x6e,
+  0x73, 0x74, 0x61, 0x6e, 0x74, 0x73, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x2e, 0x76, 0x33, 0x66,
+  0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70,
+  0x6f, 0x77, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61,
+  0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e, 0x66, 0x33, 0x32, 0x61,
+  0x69, 0x72, 0x2e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x2e, 0x75,
+  0x2e, 0x69, 0x31, 0x2e, 0x66, 0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72,
+  0x2e, 0x64, 0x6f, 0x74, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x5f, 0x5a,
+  0x31, 0x32, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x54, 0x6f, 0x6e, 0x65, 0x6d,
+  0x61, 0x70, 0x44, 0x76, 0x33, 0x5f, 0x66, 0x66, 0x66, 0x66, 0x66, 0x61,
+  0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78,
+  0x2e, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73, 0x74,
+  0x5f, 0x70, 0x6f, 0x77, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69,
+  0x72, 0x2e, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x61, 0x62, 0x73, 0x2e,
+  0x76, 0x33, 0x66, 0x33, 0x32, 0x61, 0x69, 0x72, 0x2e, 0x66, 0x61, 0x73,
+  0x74, 0x5f, 0x66, 0x6d, 0x61, 0x78, 0x2e, 0x76, 0x33, 0x66, 0x33, 0x32,
+  0x61, 0x69, 0x72, 0x2e, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x74,
+  0x65, 0x78, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x32, 0x64, 0x2e, 0x76, 0x34,
+  0x66, 0x33, 0x32, 0x33, 0x32, 0x30, 0x32, 0x33, 0x2e, 0x34, 0x30, 0x34,
+  0x61, 0x69, 0x72, 0x36, 0x34, 0x2d, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x2d,
+  0x74, 0x76, 0x6f, 0x73, 0x31, 0x33, 0x2e, 0x30, 0x2e, 0x30, 0x2d, 0x73,
+  0x69, 0x6d, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+const unsigned int sdl_metallib_len = 37821;
diff --git a/SDL-3.2.8/src/render/metal/build-metal-shaders.sh b/SDL-3.2.8/src/render/metal/build-metal-shaders.sh
new file mode 100755
index 0000000..e00235c
--- /dev/null
+++ b/SDL-3.2.8/src/render/metal/build-metal-shaders.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+set -x
+set -e
+cd `dirname "$0"`
+
+generate_shaders()
+{
+    fileplatform=$1
+    compileplatform=$2
+    sdkplatform=$3
+    minversion=$4
+    xcrun -sdk $sdkplatform metal -c -std=$compileplatform-metal1.1 -m$sdkplatform-version-min=$minversion -Wall -O3 -o ./sdl.air ./SDL_shaders_metal.metal || exit $?
+    xcrun -sdk $sdkplatform metal-ar rc sdl.metalar sdl.air || exit $?
+    xcrun -sdk $sdkplatform metallib -o sdl.metallib sdl.metalar || exit $?
+    xxd -i sdl.metallib | perl -w -p -e 's/\Aunsigned /const unsigned /;' >./SDL_shaders_metal_$fileplatform.h
+    rm -f sdl.air sdl.metalar sdl.metallib
+}
+
+generate_shaders macos macos macosx 10.11
+generate_shaders ios ios iphoneos 8.0
+generate_shaders iphonesimulator ios iphonesimulator 8.0
+generate_shaders tvos ios appletvos 9.0
+generate_shaders tvsimulator ios appletvsimulator 9.0
diff --git a/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h b/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h
new file mode 100644
index 0000000..7e9f265
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengl/SDL_glfuncs.h
@@ -0,0 +1,476 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* list of OpenGL functions sorted alphabetically
+   If you need to use a GL function from the SDL video subsystem,
+   change its entry from SDL_PROC_UNUSED to SDL_PROC and rebuild.
+*/
+#define SDL_PROC_UNUSED(ret, func, params)
+
+SDL_PROC_UNUSED(void, glAccum, (GLenum, GLfloat))
+SDL_PROC_UNUSED(void, glAlphaFunc, (GLenum, GLclampf))
+SDL_PROC_UNUSED(GLboolean, glAreTexturesResident,
+                (GLsizei, const GLuint *, GLboolean *))
+SDL_PROC_UNUSED(void, glArrayElement, (GLint))
+SDL_PROC(void, glBegin, (GLenum))
+SDL_PROC(void, glBindTexture, (GLenum, GLuint))
+SDL_PROC_UNUSED(void, glBitmap,
+                (GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat,
+                 const GLubyte *))
+SDL_PROC(void, glBlendEquation, (GLenum))
+SDL_PROC_UNUSED(void, glBlendFunc, (GLenum, GLenum))
+SDL_PROC(void, glBlendFuncSeparate, (GLenum, GLenum, GLenum, GLenum))
+SDL_PROC_UNUSED(void, glCallList, (GLuint))
+SDL_PROC_UNUSED(void, glCallLists, (GLsizei, GLenum, const GLvoid *))
+SDL_PROC(void, glClear, (GLbitfield))
+SDL_PROC_UNUSED(void, glClearAccum, (GLfloat, GLfloat, GLfloat, GLfloat))
+SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
+SDL_PROC_UNUSED(void, glClearDepth, (GLclampd))
+SDL_PROC_UNUSED(void, glClearIndex, (GLfloat))
+SDL_PROC_UNUSED(void, glClearStencil, (GLint))
+SDL_PROC_UNUSED(void, glClipPlane, (GLenum, const GLdouble *))
+SDL_PROC_UNUSED(void, glColor3b, (GLbyte, GLbyte, GLbyte))
+SDL_PROC_UNUSED(void, glColor3bv, (const GLbyte *))
+SDL_PROC_UNUSED(void, glColor3d, (GLdouble, GLdouble, GLdouble))
+SDL_PROC_UNUSED(void, glColor3dv, (const GLdouble *))
+SDL_PROC_UNUSED(void, glColor3f, (GLfloat, GLfloat, GLfloat))
+SDL_PROC(void, glColor3fv, (const GLfloat *))
+SDL_PROC_UNUSED(void, glColor3i, (GLint, GLint, GLint))
+SDL_PROC_UNUSED(void, glColor3iv, (const GLint *))
+SDL_PROC_UNUSED(void, glColor3s, (GLshort, GLshort, GLshort))
+SDL_PROC_UNUSED(void, glColor3sv, (const GLshort *))
+SDL_PROC_UNUSED(void, glColor3ub, (GLubyte, GLubyte, GLubyte))
+SDL_PROC_UNUSED(void, glColor3ubv, (const GLubyte *))
+SDL_PROC_UNUSED(void, glColor3ui, (GLuint, GLuint, GLuint))
+SDL_PROC_UNUSED(void, glColor3uiv, (const GLuint *))
+SDL_PROC_UNUSED(void, glColor3us, (GLushort, GLushort, GLushort))
+SDL_PROC_UNUSED(void, glColor3usv, (const GLushort *))
+SDL_PROC_UNUSED(void, glColor4b, (GLbyte, GLbyte, GLbyte, GLbyte))
+SDL_PROC_UNUSED(void, glColor4bv, (const GLbyte *))
+SDL_PROC_UNUSED(void, glColor4d, (GLdouble, GLdouble, GLdouble, GLdouble))
+SDL_PROC_UNUSED(void, glColor4dv, (const GLdouble *))
+SDL_PROC(void, glColor4f, (GLfloat, GLfloat, GLfloat, GLfloat))
+SDL_PROC_UNUSED(void, glColor4fv, (const GLfloat *))
+SDL_PROC_UNUSED(void, glColor4i, (GLint, GLint, GLint, GLint))
+SDL_PROC_UNUSED(void, glColor4iv, (const GLint *))
+SDL_PROC_UNUSED(void, glColor4s, (GLshort, GLshort, GLshort, GLshort))
+SDL_PROC_UNUSED(void, glColor4sv, (const GLshort *))
+SDL_PROC(void, glColor4ub,
+         (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha))
+SDL_PROC_UNUSED(void, glColor4ubv, (const GLubyte *v))
+SDL_PROC_UNUSED(void, glColor4ui,
+                (GLuint red, GLuint green, GLuint blue, GLuint alpha))
+SDL_PROC_UNUSED(void, glColor4uiv, (const GLuint *v))
+SDL_PROC_UNUSED(void, glColor4us,
+                (GLushort red, GLushort green, GLushort blue, GLushort alpha))
+SDL_PROC_UNUSED(void, glColor4usv, (const GLushort *v))
+SDL_PROC_UNUSED(void, glColorMask,
+                (GLboolean red, GLboolean green, GLboolean blue,
+                 GLboolean alpha))
+SDL_PROC_UNUSED(void, glColorMaterial, (GLenum face, GLenum mode))
+SDL_PROC(void, glColorPointer,
+         (GLint size, GLenum type, GLsizei stride,
+          const GLvoid *pointer))
+SDL_PROC_UNUSED(void, glCopyPixels,
+                (GLint x, GLint y, GLsizei width, GLsizei height,
+                 GLenum type))
+SDL_PROC_UNUSED(void, glCopyTexImage1D,
+                (GLenum target, GLint level, GLenum internalFormat, GLint x,
+                 GLint y, GLsizei width, GLint border))
+SDL_PROC_UNUSED(void, glCopyTexImage2D,
+                (GLenum target, GLint level, GLenum internalFormat, GLint x,
+                 GLint y, GLsizei width, GLsizei height, GLint border))
+SDL_PROC_UNUSED(void, glCopyTexSubImage1D,
+                (GLenum target, GLint level, GLint xoffset, GLint x, GLint y,
+                 GLsizei width))
+SDL_PROC_UNUSED(void, glCopyTexSubImage2D,
+                (GLenum target, GLint level, GLint xoffset, GLint yoffset,
+                 GLint x, GLint y, GLsizei width, GLsizei height))
+SDL_PROC_UNUSED(void, glCullFace, (GLenum mode))
+SDL_PROC_UNUSED(void, glDeleteLists, (GLuint list, GLsizei range))
+SDL_PROC(void, glDeleteTextures, (GLsizei n, const GLuint *textures))
+SDL_PROC(void, glDepthFunc, (GLenum func))
+SDL_PROC_UNUSED(void, glDepthMask, (GLboolean flag))
+SDL_PROC_UNUSED(void, glDepthRange, (GLclampd zNear, GLclampd zFar))
+SDL_PROC(void, glDisable, (GLenum cap))
+SDL_PROC(void, glDisableClientState, (GLenum array))
+SDL_PROC(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count))
+SDL_PROC_UNUSED(void, glDrawBuffer, (GLenum mode))
+SDL_PROC_UNUSED(void, glDrawElements,
+                (GLenum mode, GLsizei count, GLenum type,
+                 const GLvoid *indices))
+SDL_PROC(void, glDrawPixels,
+         (GLsizei width, GLsizei height, GLenum format, GLenum type,
+          const GLvoid *pixels))
+SDL_PROC_UNUSED(void, glEdgeFlag, (GLboolean flag))
+SDL_PROC_UNUSED(void, glEdgeFlagPointer,
+                (GLsizei stride, const GLvoid *pointer))
+SDL_PROC_UNUSED(void, glEdgeFlagv, (const GLboolean *flag))
+SDL_PROC(void, glEnable, (GLenum cap))
+SDL_PROC(void, glEnableClientState, (GLenum array))
+SDL_PROC(void, glEnd, (void))
+SDL_PROC_UNUSED(void, glEndList, (void))
+SDL_PROC_UNUSED(void, glEvalCoord1d, (GLdouble u))
+SDL_PROC_UNUSED(void, glEvalCoord1dv, (const GLdouble *u))
+SDL_PROC_UNUSED(void, glEvalCoord1f, (GLfloat u))
+SDL_PROC_UNUSED(void, glEvalCoord1fv, (const GLfloat *u))
+SDL_PROC_UNUSED(void, glEvalCoord2d, (GLdouble u, GLdouble v))
+SDL_PROC_UNUSED(void, glEvalCoord2dv, (const GLdouble *u))
+SDL_PROC_UNUSED(void, glEvalCoord2f, (GLfloat u, GLfloat v))
+SDL_PROC_UNUSED(void, glEvalCoord2fv, (const GLfloat *u))
+SDL_PROC_UNUSED(void, glEvalMesh1, (GLenum mode, GLint i1, GLint i2))
+SDL_PROC_UNUSED(void, glEvalMesh2,
+                (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2))
+SDL_PROC_UNUSED(void, glEvalPoint1, (GLint i))
+SDL_PROC_UNUSED(void, glEvalPoint2, (GLint i, GLint j))
+SDL_PROC_UNUSED(void, glFeedbackBuffer,
+                (GLsizei size, GLenum type, GLfloat *buffer))
+SDL_PROC_UNUSED(void, glFinish, (void))
+SDL_PROC_UNUSED(void, glFlush, (void))
+SDL_PROC_UNUSED(void, glFogf, (GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glFogfv, (GLenum pname, const GLfloat *params))
+SDL_PROC_UNUSED(void, glFogi, (GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glFogiv, (GLenum pname, const GLint *params))
+SDL_PROC_UNUSED(void, glFrontFace, (GLenum mode))
+SDL_PROC_UNUSED(void, glFrustum,
+                (GLdouble left, GLdouble right, GLdouble bottom,
+                 GLdouble top, GLdouble zNear, GLdouble zFar))
+SDL_PROC_UNUSED(GLuint, glGenLists, (GLsizei range))
+SDL_PROC(void, glGenTextures, (GLsizei n, GLuint *textures))
+SDL_PROC_UNUSED(void, glGetBooleanv, (GLenum pname, GLboolean *params))
+SDL_PROC_UNUSED(void, glGetClipPlane, (GLenum plane, GLdouble *equation))
+SDL_PROC_UNUSED(void, glGetDoublev, (GLenum pname, GLdouble *params))
+SDL_PROC(GLenum, glGetError, (void))
+SDL_PROC(void, glGetFloatv, (GLenum pname, GLfloat *params))
+SDL_PROC(void, glGetIntegerv, (GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glGetLightfv,
+                (GLenum light, GLenum pname, GLfloat *params))
+SDL_PROC_UNUSED(void, glGetLightiv,
+                (GLenum light, GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glGetMapdv, (GLenum target, GLenum query, GLdouble *v))
+SDL_PROC_UNUSED(void, glGetMapfv, (GLenum target, GLenum query, GLfloat *v))
+SDL_PROC_UNUSED(void, glGetMapiv, (GLenum target, GLenum query, GLint *v))
+SDL_PROC_UNUSED(void, glGetMaterialfv,
+                (GLenum face, GLenum pname, GLfloat *params))
+SDL_PROC_UNUSED(void, glGetMaterialiv,
+                (GLenum face, GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glGetPixelMapfv, (GLenum map, GLfloat *values))
+SDL_PROC_UNUSED(void, glGetPixelMapuiv, (GLenum map, GLuint *values))
+SDL_PROC_UNUSED(void, glGetPixelMapusv, (GLenum map, GLushort *values))
+SDL_PROC(void, glGetPointerv, (GLenum pname, GLvoid **params))
+SDL_PROC_UNUSED(void, glGetPolygonStipple, (GLubyte * mask))
+SDL_PROC(const GLubyte *, glGetString, (GLenum name))
+SDL_PROC_UNUSED(void, glGetTexEnvfv,
+                (GLenum target, GLenum pname, GLfloat *params))
+SDL_PROC_UNUSED(void, glGetTexEnviv,
+                (GLenum target, GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glGetTexGendv,
+                (GLenum coord, GLenum pname, GLdouble *params))
+SDL_PROC_UNUSED(void, glGetTexGenfv,
+                (GLenum coord, GLenum pname, GLfloat *params))
+SDL_PROC_UNUSED(void, glGetTexGeniv,
+                (GLenum coord, GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glGetTexImage,
+                (GLenum target, GLint level, GLenum format, GLenum type,
+                 GLvoid *pixels))
+SDL_PROC_UNUSED(void, glGetTexLevelParameterfv,
+                (GLenum target, GLint level, GLenum pname, GLfloat *params))
+SDL_PROC_UNUSED(void, glGetTexLevelParameteriv,
+                (GLenum target, GLint level, GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glGetTexParameterfv,
+                (GLenum target, GLenum pname, GLfloat *params))
+SDL_PROC_UNUSED(void, glGetTexParameteriv,
+                (GLenum target, GLenum pname, GLint *params))
+SDL_PROC_UNUSED(void, glHint, (GLenum target, GLenum mode))
+SDL_PROC_UNUSED(void, glIndexMask, (GLuint mask))
+SDL_PROC_UNUSED(void, glIndexPointer,
+                (GLenum type, GLsizei stride, const GLvoid *pointer))
+SDL_PROC_UNUSED(void, glIndexd, (GLdouble c))
+SDL_PROC_UNUSED(void, glIndexdv, (const GLdouble *c))
+SDL_PROC_UNUSED(void, glIndexf, (GLfloat c))
+SDL_PROC_UNUSED(void, glIndexfv, (const GLfloat *c))
+SDL_PROC_UNUSED(void, glIndexi, (GLint c))
+SDL_PROC_UNUSED(void, glIndexiv, (const GLint *c))
+SDL_PROC_UNUSED(void, glIndexs, (GLshort c))
+SDL_PROC_UNUSED(void, glIndexsv, (const GLshort *c))
+SDL_PROC_UNUSED(void, glIndexub, (GLubyte c))
+SDL_PROC_UNUSED(void, glIndexubv, (const GLubyte *c))
+SDL_PROC_UNUSED(void, glInitNames, (void))
+SDL_PROC_UNUSED(void, glInterleavedArrays,
+                (GLenum format, GLsizei stride, const GLvoid *pointer))
+SDL_PROC_UNUSED(GLboolean, glIsEnabled, (GLenum cap))
+SDL_PROC_UNUSED(GLboolean, glIsList, (GLuint list))
+SDL_PROC_UNUSED(GLboolean, glIsTexture, (GLuint texture))
+SDL_PROC_UNUSED(void, glLightModelf, (GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glLightModelfv, (GLenum pname, const GLfloat *params))
+SDL_PROC_UNUSED(void, glLightModeli, (GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glLightModeliv, (GLenum pname, const GLint *params))
+SDL_PROC_UNUSED(void, glLightf, (GLenum light, GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glLightfv,
+                (GLenum light, GLenum pname, const GLfloat *params))
+SDL_PROC_UNUSED(void, glLighti, (GLenum light, GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glLightiv,
+                (GLenum light, GLenum pname, const GLint *params))
+SDL_PROC_UNUSED(void, glLineStipple, (GLint factor, GLushort pattern))
+SDL_PROC(void, glLineWidth, (GLfloat width))
+SDL_PROC_UNUSED(void, glListBase, (GLuint base))
+SDL_PROC(void, glLoadIdentity, (void))
+SDL_PROC_UNUSED(void, glLoadMatrixd, (const GLdouble *m))
+SDL_PROC_UNUSED(void, glLoadMatrixf, (const GLfloat *m))
+SDL_PROC_UNUSED(void, glLoadName, (GLuint name))
+SDL_PROC_UNUSED(void, glLogicOp, (GLenum opcode))
+SDL_PROC_UNUSED(void, glMap1d,
+                (GLenum target, GLdouble u1, GLdouble u2, GLint stride,
+                 GLint order, const GLdouble *points))
+SDL_PROC_UNUSED(void, glMap1f,
+                (GLenum target, GLfloat u1, GLfloat u2, GLint stride,
+                 GLint order, const GLfloat *points))
+SDL_PROC_UNUSED(void, glMap2d,
+                (GLenum target, GLdouble u1, GLdouble u2, GLint ustride,
+                 GLint uorder, GLdouble v1, GLdouble v2, GLint vstride,
+                 GLint vorder, const GLdouble *points))
+SDL_PROC_UNUSED(void, glMap2f,
+                (GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
+                 GLint uorder, GLfloat v1, GLfloat v2, GLint vstride,
+                 GLint vorder, const GLfloat *points))
+SDL_PROC_UNUSED(void, glMapGrid1d, (GLint un, GLdouble u1, GLdouble u2))
+SDL_PROC_UNUSED(void, glMapGrid1f, (GLint un, GLfloat u1, GLfloat u2))
+SDL_PROC_UNUSED(void, glMapGrid2d,
+                (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1,
+                 GLdouble v2))
+SDL_PROC_UNUSED(void, glMapGrid2f,
+                (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1,
+                 GLfloat v2))
+SDL_PROC_UNUSED(void, glMaterialf, (GLenum face, GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glMaterialfv,
+                (GLenum face, GLenum pname, const GLfloat *params))
+SDL_PROC_UNUSED(void, glMateriali, (GLenum face, GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glMaterialiv,
+                (GLenum face, GLenum pname, const GLint *params))
+SDL_PROC(void, glMatrixMode, (GLenum mode))
+SDL_PROC_UNUSED(void, glMultMatrixd, (const GLdouble *m))
+SDL_PROC_UNUSED(void, glMultMatrixf, (const GLfloat *m))
+SDL_PROC_UNUSED(void, glNewList, (GLuint list, GLenum mode))
+SDL_PROC_UNUSED(void, glNormal3b, (GLbyte nx, GLbyte ny, GLbyte nz))
+SDL_PROC_UNUSED(void, glNormal3bv, (const GLbyte *v))
+SDL_PROC_UNUSED(void, glNormal3d, (GLdouble nx, GLdouble ny, GLdouble nz))
+SDL_PROC_UNUSED(void, glNormal3dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glNormal3f, (GLfloat nx, GLfloat ny, GLfloat nz))
+SDL_PROC_UNUSED(void, glNormal3fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glNormal3i, (GLint nx, GLint ny, GLint nz))
+SDL_PROC_UNUSED(void, glNormal3iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glNormal3s, (GLshort nx, GLshort ny, GLshort nz))
+SDL_PROC_UNUSED(void, glNormal3sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glNormalPointer,
+                (GLenum type, GLsizei stride, const GLvoid *pointer))
+SDL_PROC(void, glOrtho,
+         (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
+          GLdouble zNear, GLdouble zFar))
+SDL_PROC_UNUSED(void, glPassThrough, (GLfloat token))
+SDL_PROC_UNUSED(void, glPixelMapfv,
+                (GLenum map, GLsizei mapsize, const GLfloat *values))
+SDL_PROC_UNUSED(void, glPixelMapuiv,
+                (GLenum map, GLsizei mapsize, const GLuint *values))
+SDL_PROC_UNUSED(void, glPixelMapusv,
+                (GLenum map, GLsizei mapsize, const GLushort *values))
+SDL_PROC_UNUSED(void, glPixelStoref, (GLenum pname, GLfloat param))
+SDL_PROC(void, glPixelStorei, (GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glPixelTransferf, (GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glPixelTransferi, (GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glPixelZoom, (GLfloat xfactor, GLfloat yfactor))
+SDL_PROC(void, glPointSize, (GLfloat size))
+SDL_PROC_UNUSED(void, glPolygonMode, (GLenum face, GLenum mode))
+SDL_PROC_UNUSED(void, glPolygonOffset, (GLfloat factor, GLfloat units))
+SDL_PROC_UNUSED(void, glPolygonStipple, (const GLubyte *mask))
+SDL_PROC_UNUSED(void, glPopAttrib, (void))
+SDL_PROC_UNUSED(void, glPopClientAttrib, (void))
+SDL_PROC_UNUSED(void, glPopMatrix, (void))
+SDL_PROC_UNUSED(void, glPopName, (void))
+SDL_PROC_UNUSED(void, glPrioritizeTextures,
+                (GLsizei n, const GLuint *textures,
+                 const GLclampf *priorities))
+SDL_PROC_UNUSED(void, glPushAttrib, (GLbitfield mask))
+SDL_PROC_UNUSED(void, glPushClientAttrib, (GLbitfield mask))
+SDL_PROC_UNUSED(void, glPushMatrix, (void))
+SDL_PROC_UNUSED(void, glPushName, (GLuint name))
+SDL_PROC_UNUSED(void, glRasterPos2d, (GLdouble x, GLdouble y))
+SDL_PROC_UNUSED(void, glRasterPos2dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glRasterPos2f, (GLfloat x, GLfloat y))
+SDL_PROC_UNUSED(void, glRasterPos2fv, (const GLfloat *v))
+SDL_PROC(void, glRasterPos2i, (GLint x, GLint y))
+SDL_PROC_UNUSED(void, glRasterPos2iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glRasterPos2s, (GLshort x, GLshort y))
+SDL_PROC_UNUSED(void, glRasterPos2sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glRasterPos3d, (GLdouble x, GLdouble y, GLdouble z))
+SDL_PROC_UNUSED(void, glRasterPos3dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glRasterPos3f, (GLfloat x, GLfloat y, GLfloat z))
+SDL_PROC_UNUSED(void, glRasterPos3fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glRasterPos3i, (GLint x, GLint y, GLint z))
+SDL_PROC_UNUSED(void, glRasterPos3iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glRasterPos3s, (GLshort x, GLshort y, GLshort z))
+SDL_PROC_UNUSED(void, glRasterPos3sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glRasterPos4d,
+                (GLdouble x, GLdouble y, GLdouble z, GLdouble w))
+SDL_PROC_UNUSED(void, glRasterPos4dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glRasterPos4f,
+                (GLfloat x, GLfloat y, GLfloat z, GLfloat w))
+SDL_PROC_UNUSED(void, glRasterPos4fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glRasterPos4i, (GLint x, GLint y, GLint z, GLint w))
+SDL_PROC_UNUSED(void, glRasterPos4iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glRasterPos4s,
+                (GLshort x, GLshort y, GLshort z, GLshort w))
+SDL_PROC_UNUSED(void, glRasterPos4sv, (const GLshort *v))
+SDL_PROC(void, glReadBuffer, (GLenum mode))
+SDL_PROC(void, glReadPixels,
+         (GLint x, GLint y, GLsizei width, GLsizei height,
+          GLenum format, GLenum type, GLvoid *pixels))
+SDL_PROC_UNUSED(void, glRectd,
+                (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2))
+SDL_PROC_UNUSED(void, glRectdv, (const GLdouble *v1, const GLdouble *v2))
+SDL_PROC(void, glRectf,
+         (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2))
+SDL_PROC_UNUSED(void, glRectfv, (const GLfloat *v1, const GLfloat *v2))
+SDL_PROC_UNUSED(void, glRecti, (GLint x1, GLint y1, GLint x2, GLint y2))
+SDL_PROC_UNUSED(void, glRectiv, (const GLint *v1, const GLint *v2))
+SDL_PROC_UNUSED(void, glRects,
+                (GLshort x1, GLshort y1, GLshort x2, GLshort y2))
+SDL_PROC_UNUSED(void, glRectsv, (const GLshort *v1, const GLshort *v2))
+SDL_PROC_UNUSED(GLint, glRenderMode, (GLenum mode))
+SDL_PROC_UNUSED(void, glRotated,
+                (GLdouble angle, GLdouble x, GLdouble y, GLdouble z))
+SDL_PROC(void, glRotatef,
+         (GLfloat angle, GLfloat x, GLfloat y, GLfloat z))
+SDL_PROC_UNUSED(void, glScaled, (GLdouble x, GLdouble y, GLdouble z))
+SDL_PROC_UNUSED(void, glScalef, (GLfloat x, GLfloat y, GLfloat z))
+SDL_PROC(void, glScissor, (GLint x, GLint y, GLsizei width, GLsizei height))
+SDL_PROC_UNUSED(void, glSelectBuffer, (GLsizei size, GLuint *buffer))
+SDL_PROC(void, glShadeModel, (GLenum mode))
+SDL_PROC_UNUSED(void, glStencilFunc, (GLenum func, GLint ref, GLuint mask))
+SDL_PROC_UNUSED(void, glStencilMask, (GLuint mask))
+SDL_PROC_UNUSED(void, glStencilOp, (GLenum fail, GLenum zfail, GLenum zpass))
+SDL_PROC_UNUSED(void, glTexCoord1d, (GLdouble s))
+SDL_PROC_UNUSED(void, glTexCoord1dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glTexCoord1f, (GLfloat s))
+SDL_PROC_UNUSED(void, glTexCoord1fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glTexCoord1i, (GLint s))
+SDL_PROC_UNUSED(void, glTexCoord1iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glTexCoord1s, (GLshort s))
+SDL_PROC_UNUSED(void, glTexCoord1sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glTexCoord2d, (GLdouble s, GLdouble t))
+SDL_PROC_UNUSED(void, glTexCoord2dv, (const GLdouble *v))
+SDL_PROC(void, glTexCoord2f, (GLfloat s, GLfloat t))
+SDL_PROC_UNUSED(void, glTexCoord2fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glTexCoord2i, (GLint s, GLint t))
+SDL_PROC_UNUSED(void, glTexCoord2iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glTexCoord2s, (GLshort s, GLshort t))
+SDL_PROC_UNUSED(void, glTexCoord2sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glTexCoord3d, (GLdouble s, GLdouble t, GLdouble r))
+SDL_PROC_UNUSED(void, glTexCoord3dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glTexCoord3f, (GLfloat s, GLfloat t, GLfloat r))
+SDL_PROC_UNUSED(void, glTexCoord3fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glTexCoord3i, (GLint s, GLint t, GLint r))
+SDL_PROC_UNUSED(void, glTexCoord3iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glTexCoord3s, (GLshort s, GLshort t, GLshort r))
+SDL_PROC_UNUSED(void, glTexCoord3sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glTexCoord4d,
+                (GLdouble s, GLdouble t, GLdouble r, GLdouble q))
+SDL_PROC_UNUSED(void, glTexCoord4dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glTexCoord4f,
+                (GLfloat s, GLfloat t, GLfloat r, GLfloat q))
+SDL_PROC_UNUSED(void, glTexCoord4fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glTexCoord4i, (GLint s, GLint t, GLint r, GLint q))
+SDL_PROC_UNUSED(void, glTexCoord4iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glTexCoord4s,
+                (GLshort s, GLshort t, GLshort r, GLshort q))
+SDL_PROC_UNUSED(void, glTexCoord4sv, (const GLshort *v))
+SDL_PROC(void, glTexCoordPointer,
+         (GLint size, GLenum type, GLsizei stride,
+          const GLvoid *pointer))
+SDL_PROC(void, glTexEnvf, (GLenum target, GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glTexEnvfv,
+                (GLenum target, GLenum pname, const GLfloat *params))
+SDL_PROC_UNUSED(void, glTexEnvi, (GLenum target, GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glTexEnviv,
+                (GLenum target, GLenum pname, const GLint *params))
+SDL_PROC_UNUSED(void, glTexGend, (GLenum coord, GLenum pname, GLdouble param))
+SDL_PROC_UNUSED(void, glTexGendv,
+                (GLenum coord, GLenum pname, const GLdouble *params))
+SDL_PROC_UNUSED(void, glTexGenf, (GLenum coord, GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glTexGenfv,
+                (GLenum coord, GLenum pname, const GLfloat *params))
+SDL_PROC_UNUSED(void, glTexGeni, (GLenum coord, GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glTexGeniv,
+                (GLenum coord, GLenum pname, const GLint *params))
+SDL_PROC_UNUSED(void, glTexImage1D,
+                (GLenum target, GLint level, GLint internalformat,
+                 GLsizei width, GLint border, GLenum format, GLenum type,
+                 const GLvoid *pixels))
+SDL_PROC(void, glTexImage2D,
+         (GLenum target, GLint level, GLint internalformat, GLsizei width,
+          GLsizei height, GLint border, GLenum format, GLenum type,
+          const GLvoid *pixels))
+SDL_PROC_UNUSED(void, glTexParameterf,
+                (GLenum target, GLenum pname, GLfloat param))
+SDL_PROC_UNUSED(void, glTexParameterfv,
+                (GLenum target, GLenum pname, const GLfloat *params))
+SDL_PROC(void, glTexParameteri, (GLenum target, GLenum pname, GLint param))
+SDL_PROC_UNUSED(void, glTexParameteriv,
+                (GLenum target, GLenum pname, const GLint *params))
+SDL_PROC_UNUSED(void, glTexSubImage1D,
+                (GLenum target, GLint level, GLint xoffset, GLsizei width,
+                 GLenum format, GLenum type, const GLvoid *pixels))
+SDL_PROC(void, glTexSubImage2D,
+         (GLenum target, GLint level, GLint xoffset, GLint yoffset,
+          GLsizei width, GLsizei height, GLenum format, GLenum type,
+          const GLvoid *pixels))
+SDL_PROC_UNUSED(void, glTranslated, (GLdouble x, GLdouble y, GLdouble z))
+SDL_PROC_UNUSED(void, glTranslatef, (GLfloat x, GLfloat y, GLfloat z))
+SDL_PROC_UNUSED(void, glVertex2d, (GLdouble x, GLdouble y))
+SDL_PROC_UNUSED(void, glVertex2dv, (const GLdouble *v))
+SDL_PROC(void, glVertex2f, (GLfloat x, GLfloat y))
+SDL_PROC_UNUSED(void, glVertex2fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glVertex2i, (GLint x, GLint y))
+SDL_PROC_UNUSED(void, glVertex2iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glVertex2s, (GLshort x, GLshort y))
+SDL_PROC_UNUSED(void, glVertex2sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glVertex3d, (GLdouble x, GLdouble y, GLdouble z))
+SDL_PROC_UNUSED(void, glVertex3dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glVertex3f, (GLfloat x, GLfloat y, GLfloat z))
+SDL_PROC(void, glVertex3fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glVertex3i, (GLint x, GLint y, GLint z))
+SDL_PROC_UNUSED(void, glVertex3iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glVertex3s, (GLshort x, GLshort y, GLshort z))
+SDL_PROC_UNUSED(void, glVertex3sv, (const GLshort *v))
+SDL_PROC_UNUSED(void, glVertex4d,
+                (GLdouble x, GLdouble y, GLdouble z, GLdouble w))
+SDL_PROC_UNUSED(void, glVertex4dv, (const GLdouble *v))
+SDL_PROC_UNUSED(void, glVertex4f,
+                (GLfloat x, GLfloat y, GLfloat z, GLfloat w))
+SDL_PROC_UNUSED(void, glVertex4fv, (const GLfloat *v))
+SDL_PROC_UNUSED(void, glVertex4i, (GLint x, GLint y, GLint z, GLint w))
+SDL_PROC_UNUSED(void, glVertex4iv, (const GLint *v))
+SDL_PROC_UNUSED(void, glVertex4s,
+                (GLshort x, GLshort y, GLshort z, GLshort w))
+SDL_PROC_UNUSED(void, glVertex4sv, (const GLshort *v))
+SDL_PROC(void, glVertexPointer,
+         (GLint size, GLenum type, GLsizei stride,
+          const GLvoid *pointer))
+SDL_PROC(void, glViewport, (GLint x, GLint y, GLsizei width, GLsizei height))
diff --git a/SDL-3.2.8/src/render/opengl/SDL_render_gl.c b/SDL-3.2.8/src/render/opengl/SDL_render_gl.c
new file mode 100644
index 0000000..d534438
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengl/SDL_render_gl.c
@@ -0,0 +1,1844 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_OGL
+#include "../../video/SDL_sysvideo.h" // For SDL_RecreateWindow
+#include <SDL3/SDL_opengl.h>
+#include "../SDL_sysrender.h"
+#include "SDL_shaders_gl.h"
+#include "../../video/SDL_pixels_c.h"
+
+#ifdef SDL_PLATFORM_MACOS
+#include <OpenGL/OpenGL.h>
+#endif
+
+#ifdef SDL_VIDEO_VITA_PVR_OGL
+#include <GL/gl.h>
+#include <GL/glext.h>
+#endif
+
+/* To prevent unnecessary window recreation,
+ * these should match the defaults selected in SDL_GL_ResetAttributes
+ */
+
+#define RENDERER_CONTEXT_MAJOR 2
+#define RENDERER_CONTEXT_MINOR 1
+
+// OpenGL renderer implementation
+
+/* Details on optimizing the texture path on macOS:
+   http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/opengl_texturedata.html
+*/
+
+typedef struct GL_FBOList GL_FBOList;
+
+struct GL_FBOList
+{
+    Uint32 w, h;
+    GLuint FBO;
+    GL_FBOList *next;
+};
+
+typedef struct
+{
+    bool viewport_dirty;
+    SDL_Rect viewport;
+    SDL_Texture *texture;
+    SDL_Texture *target;
+    int drawablew;
+    int drawableh;
+    SDL_BlendMode blend;
+    GL_Shader shader;
+    const float *shader_params;
+    bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_dirty;
+    SDL_Rect cliprect;
+    bool texturing;
+    bool texturing_dirty;
+    bool vertex_array;
+    bool color_array;
+    bool texture_array;
+    bool color_dirty;
+    SDL_FColor color;
+    bool clear_color_dirty;
+    SDL_FColor clear_color;
+} GL_DrawStateCache;
+
+typedef struct
+{
+    SDL_GLContext context;
+
+    bool debug_enabled;
+    bool GL_ARB_debug_output_supported;
+    int errors;
+    char **error_messages;
+    GLDEBUGPROCARB next_error_callback;
+    GLvoid *next_error_userparam;
+
+    GLenum textype;
+
+    bool GL_ARB_texture_non_power_of_two_supported;
+    bool GL_ARB_texture_rectangle_supported;
+    bool GL_EXT_framebuffer_object_supported;
+    GL_FBOList *framebuffers;
+
+    // OpenGL functions
+#define SDL_PROC(ret, func, params) ret (APIENTRY *func) params;
+#include "SDL_glfuncs.h"
+#undef SDL_PROC
+
+    // Multitexture support
+    bool GL_ARB_multitexture_supported;
+    PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
+    GLint num_texture_units;
+
+    PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
+    PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
+    PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
+    PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
+    PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
+
+    // Shader support
+    GL_ShaderContext *shaders;
+
+    GL_DrawStateCache drawstate;
+} GL_RenderData;
+
+typedef struct
+{
+    GLuint texture;
+    bool texture_external;
+    GLfloat texw;
+    GLfloat texh;
+    GLenum format;
+    GLenum formattype;
+    GL_Shader shader;
+    const float *shader_params;
+    void *pixels;
+    int pitch;
+    SDL_Rect locked_rect;
+
+#ifdef SDL_HAVE_YUV
+    // YUV texture support
+    bool yuv;
+    bool nv12;
+    GLuint utexture;
+    bool utexture_external;
+    GLuint vtexture;
+    bool vtexture_external;
+#endif
+
+    GL_FBOList *fbo;
+} GL_TextureData;
+
+static const char *GL_TranslateError(GLenum error)
+{
+#define GL_ERROR_TRANSLATE(e) \
+    case e:                   \
+        return #e;
+    switch (error) {
+        GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
+        GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
+        GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
+        GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
+        GL_ERROR_TRANSLATE(GL_NO_ERROR)
+        GL_ERROR_TRANSLATE(GL_STACK_OVERFLOW)
+        GL_ERROR_TRANSLATE(GL_STACK_UNDERFLOW)
+        GL_ERROR_TRANSLATE(GL_TABLE_TOO_LARGE)
+    default:
+        return "UNKNOWN";
+    }
+#undef GL_ERROR_TRANSLATE
+}
+
+static void GL_ClearErrors(SDL_Renderer *renderer)
+{
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+
+    if (!data->debug_enabled) {
+        return;
+    }
+    if (data->GL_ARB_debug_output_supported) {
+        if (data->errors) {
+            int i;
+            for (i = 0; i < data->errors; ++i) {
+                SDL_free(data->error_messages[i]);
+            }
+            SDL_free(data->error_messages);
+
+            data->errors = 0;
+            data->error_messages = NULL;
+        }
+    } else if (data->glGetError) {
+        while (data->glGetError() != GL_NO_ERROR) {
+            // continue;
+        }
+    }
+}
+
+static bool GL_CheckAllErrors(const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)
+{
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+    bool result = true;
+
+    if (!data->debug_enabled) {
+        return true;
+    }
+    if (data->GL_ARB_debug_output_supported) {
+        if (data->errors) {
+            int i;
+            for (i = 0; i < data->errors; ++i) {
+                SDL_SetError("%s: %s (%d): %s %s", prefix, file, line, function, data->error_messages[i]);
+                result = false;
+            }
+            GL_ClearErrors(renderer);
+        }
+    } else {
+        // check gl errors (can return multiple errors)
+        for (;;) {
+            GLenum error = data->glGetError();
+            if (error != GL_NO_ERROR) {
+                if (prefix == NULL || prefix[0] == '\0') {
+                    prefix = "generic";
+                }
+                SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
+                result = false;
+            } else {
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+#if 0
+#define GL_CheckError(prefix, renderer)
+#else
+#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION)
+#endif
+
+static bool GL_LoadFunctions(GL_RenderData *data)
+{
+#ifdef __SDL_NOGETPROCADDR__
+#define SDL_PROC(ret, func, params) data->func = func;
+#else
+    bool result = true;
+#define SDL_PROC(ret, func, params)                                                           \
+    do {                                                                                      \
+        data->func = (ret (APIENTRY *) params)SDL_GL_GetProcAddress(#func);                                            \
+        if (!data->func) {                                                                    \
+            result = SDL_SetError("Couldn't load GL function %s: %s", #func, SDL_GetError()); \
+        }                                                                                     \
+    } while (0);
+#endif // __SDL_NOGETPROCADDR__
+
+#include "SDL_glfuncs.h"
+#undef SDL_PROC
+    return result;
+}
+
+static bool GL_ActivateRenderer(SDL_Renderer *renderer)
+{
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+
+    if (SDL_GL_GetCurrentContext() != data->context) {
+        if (!SDL_GL_MakeCurrent(renderer->window, data->context)) {
+            return false;
+        }
+    }
+
+    GL_ClearErrors(renderer);
+
+    return true;
+}
+
+static void APIENTRY GL_HandleDebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, const void *userParam)
+{
+    SDL_Renderer *renderer = (SDL_Renderer *)userParam;
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+
+    if (type == GL_DEBUG_TYPE_ERROR_ARB) {
+        // Record this error
+        int errors = data->errors + 1;
+        char **error_messages = (char **)SDL_realloc(data->error_messages, errors * sizeof(*data->error_messages));
+        if (error_messages) {
+            data->errors = errors;
+            data->error_messages = error_messages;
+            data->error_messages[data->errors - 1] = SDL_strdup(message);
+        }
+    }
+
+    // If there's another error callback, pass it along, otherwise log it
+    if (data->next_error_callback) {
+        data->next_error_callback(source, type, id, severity, length, message, data->next_error_userparam);
+    } else {
+        if (type == GL_DEBUG_TYPE_ERROR_ARB) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", message);
+        } else {
+            SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "%s", message);
+        }
+    }
+}
+
+static GL_FBOList *GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h)
+{
+    GL_FBOList *result = data->framebuffers;
+
+    while (result && ((result->w != w) || (result->h != h))) {
+        result = result->next;
+    }
+
+    if (!result) {
+        result = (GL_FBOList *)SDL_malloc(sizeof(GL_FBOList));
+        if (result) {
+            result->w = w;
+            result->h = h;
+            data->glGenFramebuffersEXT(1, &result->FBO);
+            result->next = data->framebuffers;
+            data->framebuffers = result;
+        }
+    }
+    return result;
+}
+
+static void GL_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    /* If the window x/y/w/h changed at all, assume the viewport has been
+     * changed behind our backs. x/y changes might seem weird but viewport
+     * resets have been observed on macOS at minimum!
+     */
+    if (event->type == SDL_EVENT_WINDOW_RESIZED ||
+        event->type == SDL_EVENT_WINDOW_MOVED) {
+        GL_RenderData *data = (GL_RenderData *)renderer->internal;
+        data->drawstate.viewport_dirty = true;
+    }
+}
+
+static GLenum GetBlendFunc(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return GL_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return GL_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return GL_SRC_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return GL_ONE_MINUS_SRC_COLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return GL_SRC_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return GL_ONE_MINUS_SRC_ALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return GL_DST_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return GL_ONE_MINUS_DST_COLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return GL_DST_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return GL_ONE_MINUS_DST_ALPHA;
+    default:
+        return GL_INVALID_ENUM;
+    }
+}
+
+static GLenum GetBlendEquation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return GL_FUNC_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return GL_FUNC_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return GL_FUNC_REVERSE_SUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return GL_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return GL_MAX;
+    default:
+        return GL_INVALID_ENUM;
+    }
+}
+
+static bool GL_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
+        GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
+        GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
+        GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
+        GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
+        GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
+        return false;
+    }
+    if (colorOperation != alphaOperation) {
+        return false;
+    }
+    return true;
+}
+
+static bool convert_format(Uint32 pixel_format, GLint *internalFormat, GLenum *format, GLenum *type)
+{
+    switch (pixel_format) {
+    case SDL_PIXELFORMAT_ARGB8888:
+    case SDL_PIXELFORMAT_XRGB8888:
+        *internalFormat = GL_RGBA8;
+        *format = GL_BGRA;
+        *type = GL_UNSIGNED_BYTE; // previously GL_UNSIGNED_INT_8_8_8_8_REV, seeing if this is better in modern times.
+        break;
+    case SDL_PIXELFORMAT_ABGR8888:
+    case SDL_PIXELFORMAT_XBGR8888:
+        *internalFormat = GL_RGBA8;
+        *format = GL_RGBA;
+        *type = GL_UNSIGNED_BYTE; // previously GL_UNSIGNED_INT_8_8_8_8_REV, seeing if this is better in modern times.
+        break;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        *internalFormat = GL_LUMINANCE;
+        *format = GL_LUMINANCE;
+        *type = GL_UNSIGNED_BYTE;
+        break;
+#ifdef SDL_PLATFORM_MACOS
+    case SDL_PIXELFORMAT_UYVY:
+        *internalFormat = GL_RGB8;
+        *format = GL_YCBCR_422_APPLE;
+        *type = GL_UNSIGNED_SHORT_8_8_APPLE;
+        break;
+#endif
+    default:
+        return false;
+    }
+    return true;
+}
+
+static bool GL_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    GL_RenderData *renderdata = (GL_RenderData *)renderer->internal;
+    const GLenum textype = renderdata->textype;
+    GL_TextureData *data;
+    GLint internalFormat;
+    GLenum format, type;
+    int texture_w, texture_h;
+    GLenum scaleMode;
+
+    GL_ActivateRenderer(renderer);
+
+    renderdata->drawstate.texture = NULL; // we trash this state.
+    renderdata->drawstate.texturing_dirty = true; // we trash this state.
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET &&
+        !renderdata->GL_EXT_framebuffer_object_supported) {
+        return SDL_SetError("Render targets not supported by OpenGL");
+    }
+
+    if (!convert_format(texture->format, &internalFormat, &format, &type)) {
+        return SDL_SetError("Texture format %s not supported by OpenGL",
+                            SDL_GetPixelFormatName(texture->format));
+    }
+
+    data = (GL_TextureData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        size_t size;
+        data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
+        size = (size_t)texture->h * data->pitch;
+        if (texture->format == SDL_PIXELFORMAT_YV12 ||
+            texture->format == SDL_PIXELFORMAT_IYUV) {
+            // Need to add size for the U and V planes
+            size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
+        }
+        if (texture->format == SDL_PIXELFORMAT_NV12 ||
+            texture->format == SDL_PIXELFORMAT_NV21) {
+            // Need to add size for the U/V plane
+            size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
+        }
+        data->pixels = SDL_calloc(1, size);
+        if (!data->pixels) {
+            SDL_free(data);
+            return false;
+        }
+    }
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        data->fbo = GL_GetFBO(renderdata, texture->w, texture->h);
+    } else {
+        data->fbo = NULL;
+    }
+
+    data->texture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_NUMBER, 0);
+    if (data->texture) {
+        data->texture_external = true;
+    } else {
+        GL_CheckError("", renderer);
+        renderdata->glGenTextures(1, &data->texture);
+        if (!GL_CheckError("glGenTextures()", renderer)) {
+            if (data->pixels) {
+                SDL_free(data->pixels);
+            }
+            SDL_free(data);
+            return false;
+        }
+    }
+    texture->internal = data;
+
+    if (renderdata->GL_ARB_texture_non_power_of_two_supported) {
+        texture_w = texture->w;
+        texture_h = texture->h;
+        data->texw = 1.0f;
+        data->texh = 1.0f;
+    } else if (renderdata->GL_ARB_texture_rectangle_supported) {
+        texture_w = texture->w;
+        texture_h = texture->h;
+        data->texw = (GLfloat)texture_w;
+        data->texh = (GLfloat)texture_h;
+    } else {
+        texture_w = SDL_powerof2(texture->w);
+        texture_h = SDL_powerof2(texture->h);
+        data->texw = (GLfloat)(texture->w) / texture_w;
+        data->texh = (GLfloat)texture->h / texture_h;
+    }
+    SDL_PropertiesID props = SDL_GetTextureProperties(texture);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER, data->texture);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER, (Sint64) textype);
+    SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_OPENGL_TEX_W_FLOAT, data->texw);
+    SDL_SetFloatProperty(props, SDL_PROP_TEXTURE_OPENGL_TEX_H_FLOAT, data->texh);
+
+    data->format = format;
+    data->formattype = type;
+    scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? GL_NEAREST : GL_LINEAR;
+    renderdata->glEnable(textype);
+    renderdata->glBindTexture(textype, data->texture);
+    renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, scaleMode);
+    renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, scaleMode);
+#ifdef SDL_PLATFORM_MACOS
+#ifndef GL_TEXTURE_STORAGE_HINT_APPLE
+#define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC
+#endif
+#ifndef STORAGE_CACHED_APPLE
+#define STORAGE_CACHED_APPLE 0x85BE
+#endif
+#ifndef STORAGE_SHARED_APPLE
+#define STORAGE_SHARED_APPLE 0x85BF
+#endif
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE,
+                                    GL_STORAGE_SHARED_APPLE);
+    } else {
+        renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE,
+                                    GL_STORAGE_CACHED_APPLE);
+    }
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING && texture->format == SDL_PIXELFORMAT_ARGB8888 && (texture->w % 8) == 0) {
+        renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
+        renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
+                                  (data->pitch / SDL_BYTESPERPIXEL(texture->format)));
+        renderdata->glTexImage2D(textype, 0, internalFormat, texture_w,
+                                 texture_h, 0, format, type, data->pixels);
+        renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
+    } else
+#endif
+    {
+        renderdata->glTexImage2D(textype, 0, internalFormat, texture_w,
+                                 texture_h, 0, format, type, NULL);
+    }
+    renderdata->glDisable(textype);
+    if (!GL_CheckError("glTexImage2D()", renderer)) {
+        return false;
+    }
+
+#ifdef SDL_HAVE_YUV
+    if (texture->format == SDL_PIXELFORMAT_YV12 ||
+        texture->format == SDL_PIXELFORMAT_IYUV) {
+        data->yuv = true;
+
+        data->utexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_U_NUMBER, 0);
+        if (data->utexture) {
+            data->utexture_external = true;
+        } else {
+            renderdata->glGenTextures(1, &data->utexture);
+        }
+        data->vtexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_V_NUMBER, 0);
+        if (data->vtexture) {
+            data->vtexture_external = true;
+        } else {
+            renderdata->glGenTextures(1, &data->vtexture);
+        }
+
+        renderdata->glBindTexture(textype, data->utexture);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
+                                    scaleMode);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
+                                    scaleMode);
+        renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w + 1) / 2,
+                                 (texture_h + 1) / 2, 0, format, type, NULL);
+        SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_U_NUMBER, data->utexture);
+
+        renderdata->glBindTexture(textype, data->vtexture);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
+                                    scaleMode);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
+                                    scaleMode);
+        renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w + 1) / 2,
+                                 (texture_h + 1) / 2, 0, format, type, NULL);
+        SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_V_NUMBER, data->vtexture);
+    }
+
+    if (texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21) {
+        data->nv12 = true;
+
+        data->utexture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGL_TEXTURE_UV_NUMBER, 0);
+        if (data->utexture) {
+            data->utexture_external = true;
+        } else {
+            renderdata->glGenTextures(1, &data->utexture);
+        }
+        renderdata->glBindTexture(textype, data->utexture);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
+                                    scaleMode);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
+                                    scaleMode);
+        renderdata->glTexImage2D(textype, 0, GL_LUMINANCE_ALPHA, (texture_w + 1) / 2,
+                                 (texture_h + 1) / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+        SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_UV_NUMBER, data->utexture);
+    }
+#endif
+
+    if (texture->format == SDL_PIXELFORMAT_ABGR8888 || texture->format == SDL_PIXELFORMAT_ARGB8888) {
+        data->shader = SHADER_RGBA;
+    } else {
+        data->shader = SHADER_RGB;
+    }
+
+#ifdef SDL_HAVE_YUV
+    if (data->yuv || data->nv12) {
+        if (data->yuv) {
+            data->shader = SHADER_YUV;
+        } else if (texture->format == SDL_PIXELFORMAT_NV12) {
+            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
+                data->shader = SHADER_NV12_RG;
+            } else {
+                data->shader = SHADER_NV12_RA;
+            }
+        } else {
+            if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
+                data->shader = SHADER_NV21_RG;
+            } else {
+                data->shader = SHADER_NV21_RA;
+            }
+        }
+        data->shader_params = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8);
+        if (!data->shader_params) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+#endif // SDL_HAVE_YUV
+
+    return GL_CheckError("", renderer);
+}
+
+static bool GL_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                            const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    GL_RenderData *renderdata = (GL_RenderData *)renderer->internal;
+    const GLenum textype = renderdata->textype;
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+    const int texturebpp = SDL_BYTESPERPIXEL(texture->format);
+
+    SDL_assert_release(texturebpp != 0); // otherwise, division by zero later.
+
+    GL_ActivateRenderer(renderer);
+
+    renderdata->drawstate.texture = NULL; // we trash this state.
+
+    renderdata->glBindTexture(textype, data->texture);
+    renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, (pitch / texturebpp));
+    renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
+                                rect->h, data->format, data->formattype,
+                                pixels);
+#ifdef SDL_HAVE_YUV
+    if (data->yuv) {
+        renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
+
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+        if (texture->format == SDL_PIXELFORMAT_YV12) {
+            renderdata->glBindTexture(textype, data->vtexture);
+        } else {
+            renderdata->glBindTexture(textype, data->utexture);
+        }
+        renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
+                                    (rect->w + 1) / 2, (rect->h + 1) / 2,
+                                    data->format, data->formattype, pixels);
+
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + ((rect->h + 1) / 2) * ((pitch + 1) / 2));
+        if (texture->format == SDL_PIXELFORMAT_YV12) {
+            renderdata->glBindTexture(textype, data->utexture);
+        } else {
+            renderdata->glBindTexture(textype, data->vtexture);
+        }
+        renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
+                                    (rect->w + 1) / 2, (rect->h + 1) / 2,
+                                    data->format, data->formattype, pixels);
+    }
+
+    if (data->nv12) {
+        renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
+
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+        renderdata->glBindTexture(textype, data->utexture);
+        renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
+                                    (rect->w + 1) / 2, (rect->h + 1) / 2,
+                                    GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, pixels);
+    }
+#endif
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+
+#ifdef SDL_HAVE_YUV
+static bool GL_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                               const SDL_Rect *rect,
+                               const Uint8 *Yplane, int Ypitch,
+                               const Uint8 *Uplane, int Upitch,
+                               const Uint8 *Vplane, int Vpitch)
+{
+    GL_RenderData *renderdata = (GL_RenderData *)renderer->internal;
+    const GLenum textype = renderdata->textype;
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+
+    GL_ActivateRenderer(renderer);
+
+    renderdata->drawstate.texture = NULL; // we trash this state.
+
+    renderdata->glBindTexture(textype, data->texture);
+    renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
+    renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
+                                rect->h, data->format, data->formattype,
+                                Yplane);
+
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Upitch);
+    renderdata->glBindTexture(textype, data->utexture);
+    renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
+                                (rect->w + 1) / 2, (rect->h + 1) / 2,
+                                data->format, data->formattype, Uplane);
+
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Vpitch);
+    renderdata->glBindTexture(textype, data->vtexture);
+    renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
+                                (rect->w + 1) / 2, (rect->h + 1) / 2,
+                                data->format, data->formattype, Vplane);
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+
+static bool GL_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                              const SDL_Rect *rect,
+                              const Uint8 *Yplane, int Ypitch,
+                              const Uint8 *UVplane, int UVpitch)
+{
+    GL_RenderData *renderdata = (GL_RenderData *)renderer->internal;
+    const GLenum textype = renderdata->textype;
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+
+    GL_ActivateRenderer(renderer);
+
+    renderdata->drawstate.texture = NULL; // we trash this state.
+
+    renderdata->glBindTexture(textype, data->texture);
+    renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
+    renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
+                                rect->h, data->format, data->formattype,
+                                Yplane);
+
+    renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, UVpitch / 2);
+    renderdata->glBindTexture(textype, data->utexture);
+    renderdata->glTexSubImage2D(textype, 0, rect->x / 2, rect->y / 2,
+                                (rect->w + 1) / 2, (rect->h + 1) / 2,
+                                GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, UVplane);
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+#endif
+
+static bool GL_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                          const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+
+    data->locked_rect = *rect;
+    *pixels =
+        (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
+                 rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = data->pitch;
+    return true;
+}
+
+static void GL_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+    const SDL_Rect *rect;
+    void *pixels;
+
+    rect = &data->locked_rect;
+    pixels =
+        (void *)((Uint8 *)data->pixels + rect->y * data->pitch +
+                 rect->x * SDL_BYTESPERPIXEL(texture->format));
+    GL_UpdateTexture(renderer, texture, rect, pixels, data->pitch);
+}
+
+static void GL_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    GL_RenderData *renderdata = (GL_RenderData *)renderer->internal;
+    const GLenum textype = renderdata->textype;
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+    GLenum glScaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? GL_NEAREST : GL_LINEAR;
+
+    renderdata->glBindTexture(textype, data->texture);
+    renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
+    renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
+
+#ifdef SDL_HAVE_YUV
+    if (texture->format == SDL_PIXELFORMAT_YV12 ||
+        texture->format == SDL_PIXELFORMAT_IYUV) {
+        renderdata->glBindTexture(textype, data->utexture);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
+
+        renderdata->glBindTexture(textype, data->vtexture);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
+    }
+
+    if (texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21) {
+        renderdata->glBindTexture(textype, data->utexture);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
+        renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
+    }
+#endif
+}
+
+static bool GL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+    GL_TextureData *texturedata;
+    GLenum status;
+
+    GL_ActivateRenderer(renderer);
+
+    if (!data->GL_EXT_framebuffer_object_supported) {
+        return SDL_SetError("Render targets not supported by OpenGL");
+    }
+
+    data->drawstate.viewport_dirty = true;
+
+    if (!texture) {
+        data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+        return true;
+    }
+
+    texturedata = (GL_TextureData *)texture->internal;
+    data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, texturedata->fbo->FBO);
+    // TODO: check if texture pixel format allows this operation
+    data->glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, data->textype, texturedata->texture, 0);
+    // Check FBO status
+    status = data->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+    if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+        return SDL_SetError("glFramebufferTexture2DEXT() failed");
+    }
+    return true;
+}
+
+/* !!! FIXME: all these Queue* calls set up the vertex buffer the way the immediate mode
+   !!! FIXME:  renderer wants it, but this might want to operate differently if we move to
+   !!! FIXME:  VBOs at some point. */
+static bool GL_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool GL_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(GLfloat), 0, &cmd->data.draw.first);
+    int i;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    for (i = 0; i < count; i++) {
+        *(verts++) = 0.5f + points[i].x;
+        *(verts++) = 0.5f + points[i].y;
+    }
+
+    return true;
+}
+
+static bool GL_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    int i;
+    GLfloat prevx, prevy;
+    const size_t vertlen = (sizeof(GLfloat) * 2) * count;
+    GLfloat *verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, vertlen, 0, &cmd->data.draw.first);
+
+    if (!verts) {
+        return false;
+    }
+    cmd->data.draw.count = count;
+
+    // 0.5f offset to hit the center of the pixel.
+    prevx = 0.5f + points->x;
+    prevy = 0.5f + points->y;
+    *(verts++) = prevx;
+    *(verts++) = prevy;
+
+    /* bump the end of each line segment out a quarter of a pixel, to provoke
+       the diamond-exit rule. Without this, you won't just drop the last
+       pixel of the last line segment, but you might also drop pixels at the
+       edge of any given line segment along the way too. */
+    for (i = 1; i < count; i++) {
+        const GLfloat xstart = prevx;
+        const GLfloat ystart = prevy;
+        const GLfloat xend = points[i].x + 0.5f; // 0.5f to hit pixel center.
+        const GLfloat yend = points[i].y + 0.5f;
+        // bump a little in the direction we are moving in.
+        const GLfloat deltax = xend - xstart;
+        const GLfloat deltay = yend - ystart;
+        const GLfloat angle = SDL_atan2f(deltay, deltax);
+        prevx = xend + (SDL_cosf(angle) * 0.25f);
+        prevy = yend + (SDL_sinf(angle) * 0.25f);
+        *(verts++) = prevx;
+        *(verts++) = prevy;
+    }
+
+    return true;
+}
+
+static bool GL_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                            const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                            int num_vertices, const void *indices, int num_indices, int size_indices,
+                            float scale_x, float scale_y)
+{
+    GL_TextureData *texturedata = NULL;
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    GLfloat *verts;
+    size_t sz = 2 * sizeof(GLfloat) + 4 * sizeof(GLfloat) + (texture ? 2 : 0) * sizeof(GLfloat);
+    const float color_scale = cmd->data.draw.color_scale;
+
+    verts = (GLfloat *)SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+
+    if (texture) {
+        texturedata = (GL_TextureData *)texture->internal;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        SDL_FColor *col_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+
+        *(verts++) = xy_[0] * scale_x;
+        *(verts++) = xy_[1] * scale_y;
+
+        col_ = (SDL_FColor *)((char *)color + j * color_stride);
+        *(verts++) = col_->r * color_scale;
+        *(verts++) = col_->g * color_scale;
+        *(verts++) = col_->b * color_scale;
+        *(verts++) = col_->a;
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            *(verts++) = uv_[0] * texturedata->texw;
+            *(verts++) = uv_[1] * texturedata->texh;
+        }
+    }
+    return true;
+}
+
+static bool SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader shader, const float *shader_params)
+{
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+    bool vertex_array;
+    bool color_array;
+    bool texture_array;
+
+    if (data->drawstate.viewport_dirty) {
+        const bool istarget = data->drawstate.target != NULL;
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+        data->glMatrixMode(GL_PROJECTION);
+        data->glLoadIdentity();
+        data->glViewport(viewport->x,
+                         istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
+                         viewport->w, viewport->h);
+        if (viewport->w && viewport->h) {
+            data->glOrtho((GLdouble)0, (GLdouble)viewport->w,
+                          (GLdouble)(istarget ? 0 : viewport->h),
+                          (GLdouble)(istarget ? viewport->h : 0),
+                          0.0, 1.0);
+        }
+        data->glMatrixMode(GL_MODELVIEW);
+        data->drawstate.viewport_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled_dirty) {
+        if (!data->drawstate.cliprect_enabled) {
+            data->glDisable(GL_SCISSOR_TEST);
+        } else {
+            data->glEnable(GL_SCISSOR_TEST);
+        }
+        data->drawstate.cliprect_enabled_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+        const SDL_Rect *rect = &data->drawstate.cliprect;
+        data->glScissor(viewport->x + rect->x,
+                        data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
+                        rect->w, rect->h);
+        data->drawstate.cliprect_dirty = false;
+    }
+
+    if (blend != data->drawstate.blend) {
+        if (blend == SDL_BLENDMODE_NONE) {
+            data->glDisable(GL_BLEND);
+        } else {
+            data->glEnable(GL_BLEND);
+            data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
+                                      GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
+                                      GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
+                                      GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
+            data->glBlendEquation(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
+        }
+        data->drawstate.blend = blend;
+    }
+
+    if (data->shaders &&
+        (shader != data->drawstate.shader || shader_params != data->drawstate.shader_params)) {
+        GL_SelectShader(data->shaders, shader, shader_params);
+        data->drawstate.shader = shader;
+        data->drawstate.shader_params = shader_params;
+    }
+
+    if (data->drawstate.texturing_dirty || ((cmd->data.draw.texture != NULL) != data->drawstate.texturing)) {
+        if (!cmd->data.draw.texture) {
+            data->glDisable(data->textype);
+            data->drawstate.texturing = false;
+        } else {
+            data->glEnable(data->textype);
+            data->drawstate.texturing = true;
+        }
+        data->drawstate.texturing_dirty = false;
+    }
+
+    vertex_array = cmd->command == SDL_RENDERCMD_DRAW_POINTS || cmd->command == SDL_RENDERCMD_DRAW_LINES || cmd->command == SDL_RENDERCMD_GEOMETRY;
+    color_array = cmd->command == SDL_RENDERCMD_GEOMETRY;
+    texture_array = cmd->data.draw.texture != NULL;
+
+    if (vertex_array != data->drawstate.vertex_array) {
+        if (vertex_array) {
+            data->glEnableClientState(GL_VERTEX_ARRAY);
+        } else {
+            data->glDisableClientState(GL_VERTEX_ARRAY);
+        }
+        data->drawstate.vertex_array = vertex_array;
+    }
+
+    if (color_array != data->drawstate.color_array) {
+        if (color_array) {
+            data->glEnableClientState(GL_COLOR_ARRAY);
+        } else {
+            data->glDisableClientState(GL_COLOR_ARRAY);
+        }
+        data->drawstate.color_array = color_array;
+    }
+
+    /* This is a little awkward but should avoid texcoord arrays getting into
+       a bad state if the application is manually binding textures */
+    if (texture_array != data->drawstate.texture_array) {
+        if (texture_array) {
+            data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        } else {
+            data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        }
+        data->drawstate.texture_array = texture_array;
+    }
+
+    return true;
+}
+
+static bool SetTextureAddressMode(GL_RenderData *data, GLenum textype, SDL_TextureAddressMode addressMode)
+{
+    switch (addressMode) {
+    case SDL_TEXTURE_ADDRESS_CLAMP:
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        break;
+    case SDL_TEXTURE_ADDRESS_WRAP:
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_T, GL_REPEAT);
+        break;
+    default:
+        return SDL_SetError("Unknown texture address mode: %d", addressMode);
+    }
+    return true;
+}
+
+static bool SetCopyState(GL_RenderData *data, const SDL_RenderCommand *cmd)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    const GL_TextureData *texturedata = (GL_TextureData *)texture->internal;
+
+    SetDrawState(data, cmd, texturedata->shader, texturedata->shader_params);
+
+    if (texture != data->drawstate.texture) {
+        const GLenum textype = data->textype;
+#ifdef SDL_HAVE_YUV
+        if (texturedata->yuv) {
+            if (data->GL_ARB_multitexture_supported) {
+                data->glActiveTextureARB(GL_TEXTURE2_ARB);
+            }
+            data->glBindTexture(textype, texturedata->vtexture);
+
+            if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) {
+                return false;
+            }
+
+            if (data->GL_ARB_multitexture_supported) {
+                data->glActiveTextureARB(GL_TEXTURE1_ARB);
+            }
+            data->glBindTexture(textype, texturedata->utexture);
+
+            if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) {
+                return false;
+            }
+        }
+        if (texturedata->nv12) {
+            if (data->GL_ARB_multitexture_supported) {
+                data->glActiveTextureARB(GL_TEXTURE1_ARB);
+            }
+            data->glBindTexture(textype, texturedata->utexture);
+
+            if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) {
+                return false;
+            }
+        }
+#endif
+        if (data->GL_ARB_multitexture_supported) {
+            data->glActiveTextureARB(GL_TEXTURE0_ARB);
+        }
+        data->glBindTexture(textype, texturedata->texture);
+
+        if (!SetTextureAddressMode(data, textype, cmd->data.draw.texture_address_mode)) {
+            return false;
+        }
+
+        data->drawstate.texture = texture;
+    }
+
+    return true;
+}
+
+static void GL_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    GL_DrawStateCache *cache = &((GL_RenderData *)renderer->internal)->drawstate;
+    cache->viewport_dirty = true;
+    cache->texture = NULL;
+    cache->drawablew = 0;
+    cache->drawableh = 0;
+    cache->blend = SDL_BLENDMODE_INVALID;
+    cache->shader = SHADER_INVALID;
+    cache->cliprect_enabled_dirty = true;
+    cache->cliprect_dirty = true;
+    cache->texturing_dirty = true;
+    cache->vertex_array = false;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
+    cache->color_array = false;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
+    cache->texture_array = false;  // !!! FIXME: this resets to false at the end of GL_RunCommandQueue, but we could cache this more aggressively.
+    cache->color_dirty = true;
+    cache->clear_color_dirty = true;
+}
+
+static bool GL_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    // !!! FIXME: it'd be nice to use a vertex buffer instead of immediate mode...
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+
+    if (!GL_ActivateRenderer(renderer)) {
+        return false;
+    }
+
+    data->drawstate.target = renderer->target;
+    if (!data->drawstate.target) {
+        int w, h;
+        SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = true;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
+    }
+
+#ifdef SDL_PLATFORM_MACOS
+    // On macOS on older systems, the OpenGL view change and resize events aren't
+    // necessarily synchronized, so just always reset it.
+    // Workaround for: https://discourse.libsdl.org/t/sdl-2-0-22-prerelease/35306/6
+    data->drawstate.viewport_dirty = true;
+#endif
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            const float r = cmd->data.color.color.r * cmd->data.color.color_scale;
+            const float g = cmd->data.color.color.g * cmd->data.color.color_scale;
+            const float b = cmd->data.color.color.b * cmd->data.color.color_scale;
+            const float a = cmd->data.color.color.a;
+            if (data->drawstate.color_dirty ||
+                (r != data->drawstate.color.r) ||
+                (g != data->drawstate.color.g) ||
+                (b != data->drawstate.color.b) ||
+                (a != data->drawstate.color.a)) {
+                data->glColor4f(r, g, b, a);
+                data->drawstate.color.r = r;
+                data->drawstate.color.g = g;
+                data->drawstate.color.b = b;
+                data->drawstate.color.a = a;
+                data->drawstate.color_dirty = false;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &data->drawstate.viewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
+                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
+                data->drawstate.cliprect_enabled_dirty = true;
+            }
+
+            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&data->drawstate.cliprect, rect);
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            const float r = cmd->data.color.color.r * cmd->data.color.color_scale;
+            const float g = cmd->data.color.color.g * cmd->data.color.color_scale;
+            const float b = cmd->data.color.color.b * cmd->data.color.color_scale;
+            const float a = cmd->data.color.color.a;
+            if (data->drawstate.clear_color_dirty ||
+                (r != data->drawstate.clear_color.r) ||
+                (g != data->drawstate.clear_color.g) ||
+                (b != data->drawstate.clear_color.b) ||
+                (a != data->drawstate.clear_color.a)) {
+                data->glClearColor(r, g, b, a);
+                data->drawstate.clear_color.r = r;
+                data->drawstate.clear_color.g = g;
+                data->drawstate.clear_color.b = b;
+                data->drawstate.clear_color.a = a;
+                data->drawstate.clear_color_dirty = false;
+            }
+
+            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
+                data->glDisable(GL_SCISSOR_TEST);
+                data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
+            }
+
+            data->glClear(GL_COLOR_BUFFER_BIT);
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            if (SetDrawState(data, cmd, SHADER_SOLID, NULL)) {
+                size_t count = cmd->data.draw.count;
+                const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
+
+                // SetDrawState handles glEnableClientState.
+                data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts);
+
+                if (count > 2) {
+                    // joined lines cannot be grouped
+                    data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count);
+                } else {
+                    // let's group non joined lines
+                    SDL_RenderCommand *finalcmd = cmd;
+                    SDL_RenderCommand *nextcmd = cmd->next;
+                    SDL_BlendMode thisblend = cmd->data.draw.blend;
+
+                    while (nextcmd) {
+                        const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                        if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
+                            break; // can't go any further on this draw call, different render command up next.
+                        } else if (nextcmd->data.draw.count != 2) {
+                            break; // can't go any further on this draw call, those are joined lines
+                        } else if (nextcmd->data.draw.blend != thisblend) {
+                            break; // can't go any further on this draw call, different blendmode copy up next.
+                        } else {
+                            finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                            count += nextcmd->data.draw.count;
+                        }
+                        nextcmd = nextcmd->next;
+                    }
+
+                    data->glDrawArrays(GL_LINES, 0, (GLsizei)count);
+                    cmd = finalcmd; // skip any copy commands we just combined in here.
+                }
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            /* as long as we have the same copy command in a row, with the
+               same texture, we can combine them all into a single draw call. */
+            SDL_Texture *thistexture = cmd->data.draw.texture;
+            SDL_BlendMode thisblend = cmd->data.draw.blend;
+            const SDL_RenderCommandType thiscmdtype = cmd->command;
+            SDL_RenderCommand *finalcmd = cmd;
+            SDL_RenderCommand *nextcmd = cmd->next;
+            size_t count = cmd->data.draw.count;
+            int ret;
+            while (nextcmd) {
+                const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                if (nextcmdtype != thiscmdtype) {
+                    break; // can't go any further on this draw call, different render command up next.
+                } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                    break; // can't go any further on this draw call, different texture/blendmode copy up next.
+                } else {
+                    finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                    count += nextcmd->data.draw.count;
+                }
+                nextcmd = nextcmd->next;
+            }
+
+            if (thistexture) {
+                ret = SetCopyState(data, cmd);
+            } else {
+                ret = SetDrawState(data, cmd, SHADER_SOLID, NULL);
+            }
+
+            if (ret) {
+                const GLfloat *verts = (GLfloat *)(((Uint8 *)vertices) + cmd->data.draw.first);
+                int op = GL_TRIANGLES; // SDL_RENDERCMD_GEOMETRY
+                if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                    op = GL_POINTS;
+                }
+
+                if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                    // SetDrawState handles glEnableClientState.
+                    data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, verts);
+                } else {
+                    // SetDrawState handles glEnableClientState.
+                    if (thistexture) {
+                        data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 8, verts + 0);
+                        data->glColorPointer(4, GL_FLOAT, sizeof(float) * 8, verts + 2);
+                        data->glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 8, verts + 6);
+                    } else {
+                        data->glVertexPointer(2, GL_FLOAT, sizeof(float) * 6, verts + 0);
+                        data->glColorPointer(4, GL_FLOAT, sizeof(float) * 6, verts + 2);
+                    }
+                }
+
+                data->glDrawArrays(op, 0, (GLsizei)count);
+
+                // Restore previously set color when we're done.
+                if (thiscmdtype != SDL_RENDERCMD_DRAW_POINTS) {
+                    const float r = data->drawstate.color.r;
+                    const float g = data->drawstate.color.g;
+                    const float b = data->drawstate.color.b;
+                    const float a = data->drawstate.color.a;
+                    data->glColor4f(r, g, b, a);
+                }
+            }
+
+            cmd = finalcmd; // skip any copy commands we just combined in here.
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    /* Turn off vertex array state when we're done, in case external code
+       relies on it being off. */
+    if (data->drawstate.vertex_array) {
+        data->glDisableClientState(GL_VERTEX_ARRAY);
+        data->drawstate.vertex_array = false;
+    }
+    if (data->drawstate.color_array) {
+        data->glDisableClientState(GL_COLOR_ARRAY);
+        data->drawstate.color_array = false;
+    }
+    if (data->drawstate.texture_array) {
+        data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        data->drawstate.texture_array = false;
+    }
+
+    return GL_CheckError("", renderer);
+}
+
+static SDL_Surface *GL_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+    SDL_PixelFormat format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ARGB8888;
+    GLint internalFormat;
+    GLenum targetFormat, type;
+    SDL_Surface *surface;
+
+    GL_ActivateRenderer(renderer);
+
+    if (!convert_format(format, &internalFormat, &targetFormat, &type)) {
+        SDL_SetError("Texture format %s not supported by OpenGL", SDL_GetPixelFormatName(format));
+        return NULL;
+    }
+
+    surface = SDL_CreateSurface(rect->w, rect->h, format);
+    if (!surface) {
+        return NULL;
+    }
+
+    int y = rect->y;
+    if (!renderer->target) {
+        int w, h;
+        SDL_GetRenderOutputSize(renderer, &w, &h);
+        y = (h - y) - rect->h;
+    }
+
+    data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    data->glPixelStorei(GL_PACK_ROW_LENGTH, (surface->pitch / SDL_BYTESPERPIXEL(format)));
+    data->glReadPixels(rect->x, y, rect->w, rect->h, targetFormat, type, surface->pixels);
+
+    if (!GL_CheckError("glReadPixels()", renderer)) {
+        SDL_DestroySurface(surface);
+        return NULL;
+    }
+
+    // Flip the rows to be top-down if necessary
+    if (!renderer->target) {
+        SDL_FlipSurface(surface, SDL_FLIP_VERTICAL);
+    }
+    return surface;
+}
+
+static bool GL_RenderPresent(SDL_Renderer *renderer)
+{
+    GL_ActivateRenderer(renderer);
+
+    return SDL_GL_SwapWindow(renderer->window);
+}
+
+static void GL_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GL_RenderData *renderdata = (GL_RenderData *)renderer->internal;
+    GL_TextureData *data = (GL_TextureData *)texture->internal;
+
+    GL_ActivateRenderer(renderer);
+
+    if (renderdata->drawstate.texture == texture) {
+        renderdata->drawstate.texture = NULL;
+    }
+    if (renderdata->drawstate.target == texture) {
+        renderdata->drawstate.target = NULL;
+    }
+
+    if (!data) {
+        return;
+    }
+    if (data->texture && !data->texture_external) {
+        renderdata->glDeleteTextures(1, &data->texture);
+    }
+#ifdef SDL_HAVE_YUV
+    if (data->yuv) {
+        if (!data->utexture_external) {
+            renderdata->glDeleteTextures(1, &data->utexture);
+        }
+        if (!data->vtexture_external) {
+            renderdata->glDeleteTextures(1, &data->vtexture);
+        }
+    }
+    if (data->nv12) {
+        if (!data->utexture_external) {
+            renderdata->glDeleteTextures(1, &data->utexture);
+        }
+    }
+#endif
+    SDL_free(data->pixels);
+    SDL_free(data);
+    texture->internal = NULL;
+}
+
+static void GL_DestroyRenderer(SDL_Renderer *renderer)
+{
+    GL_RenderData *data = (GL_RenderData *)renderer->internal;
+
+    if (data) {
+        if (data->context) {
+            // make sure we delete the right resources!
+            GL_ActivateRenderer(renderer);
+        }
+
+        GL_ClearErrors(renderer);
+        if (data->GL_ARB_debug_output_supported) {
+            PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB");
+
+            // Uh oh, we don't have a safe way of removing ourselves from the callback chain, if it changed after we set our callback.
+            // For now, just always replace the callback with the original one
+            glDebugMessageCallbackARBFunc(data->next_error_callback, data->next_error_userparam);
+        }
+        if (data->shaders) {
+            GL_DestroyShaderContext(data->shaders);
+        }
+        if (data->context) {
+            while (data->framebuffers) {
+                GL_FBOList *nextnode = data->framebuffers->next;
+                // delete the framebuffer object
+                data->glDeleteFramebuffersEXT(1, &data->framebuffers->FBO);
+                GL_CheckError("", renderer);
+                SDL_free(data->framebuffers);
+                data->framebuffers = nextnode;
+            }
+            SDL_GL_DestroyContext(data->context);
+        }
+        SDL_free(data);
+    }
+}
+
+static bool GL_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    int interval = 0;
+
+    if (!SDL_GL_SetSwapInterval(vsync)) {
+        return false;
+    }
+
+    if (!SDL_GL_GetSwapInterval(&interval)) {
+        return false;
+    }
+
+    if (interval != vsync) {
+        return SDL_Unsupported();
+    }
+    return true;
+}
+
+static bool GL_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    GL_RenderData *data = NULL;
+    GLint value;
+    SDL_WindowFlags window_flags;
+    int profile_mask = 0, major = 0, minor = 0;
+    bool changed_window = false;
+    const char *hint;
+    bool non_power_of_two_supported = false;
+
+    SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
+    SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
+    SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
+
+#ifndef SDL_VIDEO_VITA_PVR_OGL
+    SDL_SyncWindow(window);
+    window_flags = SDL_GetWindowFlags(window);
+    if (!(window_flags & SDL_WINDOW_OPENGL) ||
+        profile_mask == SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
+
+        changed_window = true;
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, 0);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
+
+        if (!SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL)) {
+            goto error;
+        }
+    }
+#endif
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        SDL_SetError("Unsupported output colorspace");
+        goto error;
+    }
+
+    data = (GL_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        goto error;
+    }
+
+    renderer->WindowEvent = GL_WindowEvent;
+    renderer->SupportsBlendMode = GL_SupportsBlendMode;
+    renderer->CreateTexture = GL_CreateTexture;
+    renderer->UpdateTexture = GL_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = GL_UpdateTextureYUV;
+    renderer->UpdateTextureNV = GL_UpdateTextureNV;
+#endif
+    renderer->LockTexture = GL_LockTexture;
+    renderer->UnlockTexture = GL_UnlockTexture;
+    renderer->SetTextureScaleMode = GL_SetTextureScaleMode;
+    renderer->SetRenderTarget = GL_SetRenderTarget;
+    renderer->QueueSetViewport = GL_QueueNoOp;
+    renderer->QueueSetDrawColor = GL_QueueNoOp;
+    renderer->QueueDrawPoints = GL_QueueDrawPoints;
+    renderer->QueueDrawLines = GL_QueueDrawLines;
+    renderer->QueueGeometry = GL_QueueGeometry;
+    renderer->InvalidateCachedState = GL_InvalidateCachedState;
+    renderer->RunCommandQueue = GL_RunCommandQueue;
+    renderer->RenderReadPixels = GL_RenderReadPixels;
+    renderer->RenderPresent = GL_RenderPresent;
+    renderer->DestroyTexture = GL_DestroyTexture;
+    renderer->DestroyRenderer = GL_DestroyRenderer;
+    renderer->SetVSync = GL_SetVSync;
+    renderer->internal = data;
+    GL_InvalidateCachedState(renderer);
+    renderer->window = window;
+
+    renderer->name = GL_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR8888);
+
+    data->context = SDL_GL_CreateContext(window);
+    if (!data->context) {
+        goto error;
+    }
+    if (!SDL_GL_MakeCurrent(window, data->context)) {
+        goto error;
+    }
+
+    if (!GL_LoadFunctions(data)) {
+        goto error;
+    }
+
+#ifdef SDL_PLATFORM_MACOS
+    // Enable multi-threaded rendering
+    /* Disabled until Ryan finishes his VBO/PBO code...
+       CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
+     */
+#endif
+
+    // Check for debug output support
+    if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) &&
+        (value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
+        data->debug_enabled = true;
+    }
+    if (data->debug_enabled && SDL_GL_ExtensionSupported("GL_ARB_debug_output")) {
+        PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)SDL_GL_GetProcAddress("glDebugMessageCallbackARB");
+
+        data->GL_ARB_debug_output_supported = true;
+        data->glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION_ARB, (GLvoid **)(char *)&data->next_error_callback);
+        data->glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM_ARB, &data->next_error_userparam);
+        glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer);
+
+        // Make sure our callback is called when errors actually happen
+        data->glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+    }
+
+    hint = SDL_GetHint("GL_ARB_texture_non_power_of_two");
+    if (!hint || *hint != '0') {
+        bool isGL2 = false;
+        const char *verstr = (const char *)data->glGetString(GL_VERSION);
+        if (verstr) {
+            char verbuf[16];
+            char *ptr;
+            SDL_strlcpy(verbuf, verstr, sizeof(verbuf));
+            ptr = SDL_strchr(verbuf, '.');
+            if (ptr) {
+                *ptr = '\0';
+                if (SDL_atoi(verbuf) >= 2) {
+                    isGL2 = true;
+                }
+            }
+        }
+        if (isGL2 || SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
+            non_power_of_two_supported = true;
+        }
+    }
+
+    data->textype = GL_TEXTURE_2D;
+    if (non_power_of_two_supported) {
+        data->GL_ARB_texture_non_power_of_two_supported = true;
+        data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
+    } else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
+               SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
+        data->GL_ARB_texture_rectangle_supported = true;
+        data->textype = GL_TEXTURE_RECTANGLE_ARB;
+        data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
+    } else {
+        data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
+        SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
+    }
+
+    // Check for multitexture support
+    if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
+        data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)SDL_GL_GetProcAddress("glActiveTextureARB");
+        if (data->glActiveTextureARB) {
+            data->GL_ARB_multitexture_supported = true;
+            data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
+        }
+    }
+
+    // Check for shader support
+    data->shaders = GL_CreateShaderContext();
+    SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
+                data->shaders ? "ENABLED" : "DISABLED");
+#ifdef SDL_HAVE_YUV
+    // We support YV12 textures using 3 textures and a shader
+    if (data->shaders && data->num_texture_units >= 3) {
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+    }
+
+    // We support NV12 textures using 2 textures and a shader
+    if (data->shaders && data->num_texture_units >= 2) {
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+    }
+#endif
+#ifdef SDL_PLATFORM_MACOS
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_UYVY);
+#endif
+
+    if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
+        data->GL_EXT_framebuffer_object_supported = true;
+        data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)
+            SDL_GL_GetProcAddress("glGenFramebuffersEXT");
+        data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
+            SDL_GL_GetProcAddress("glDeleteFramebuffersEXT");
+        data->glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
+            SDL_GL_GetProcAddress("glFramebufferTexture2DEXT");
+        data->glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)
+            SDL_GL_GetProcAddress("glBindFramebufferEXT");
+        data->glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
+            SDL_GL_GetProcAddress("glCheckFramebufferStatusEXT");
+    } else {
+        SDL_SetError("Can't create render targets, GL_EXT_framebuffer_object not available");
+        goto error;
+    }
+
+    // Set up parameters for rendering
+    data->glMatrixMode(GL_MODELVIEW);
+    data->glLoadIdentity();
+    data->glDisable(GL_DEPTH_TEST);
+    data->glDisable(GL_CULL_FACE);
+    data->glDisable(GL_SCISSOR_TEST);
+    data->glDisable(data->textype);
+    data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+    data->glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+    // This ended up causing video discrepancies between OpenGL and Direct3D
+    // data->glEnable(GL_LINE_SMOOTH);
+
+    data->drawstate.color.r = 1.0f;
+    data->drawstate.color.g = 1.0f;
+    data->drawstate.color.b = 1.0f;
+    data->drawstate.color.a = 1.0f;
+    data->drawstate.clear_color.r = 1.0f;
+    data->drawstate.clear_color.g = 1.0f;
+    data->drawstate.clear_color.b = 1.0f;
+    data->drawstate.clear_color.a = 1.0f;
+
+    return true;
+
+error:
+    if (changed_window) {
+        // Uh oh, better try to put it back...
+        char *error = SDL_strdup(SDL_GetError());
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
+        SDL_RecreateWindow(window, window_flags);
+        SDL_SetError("%s", error);
+        SDL_free(error);
+    }
+    return false;
+}
+
+SDL_RenderDriver GL_RenderDriver = {
+    GL_CreateRenderer, "opengl"
+};
+
+#endif // SDL_VIDEO_RENDER_OGL
diff --git a/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c b/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c
new file mode 100644
index 0000000..b09b12e
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.c
@@ -0,0 +1,545 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_OGL
+
+#include <SDL3/SDL_opengl.h>
+#include "SDL_shaders_gl.h"
+
+// OpenGL shader implementation
+
+// #define DEBUG_SHADERS
+
+typedef struct
+{
+    GLhandleARB program;
+    GLhandleARB vert_shader;
+    GLhandleARB frag_shader;
+} GL_ShaderData;
+
+struct GL_ShaderContext
+{
+    GLenum (*glGetError)(void);
+
+    PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
+    PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
+    PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
+    PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
+    PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
+    PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
+    PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
+    PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
+    PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
+    PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
+    PFNGLUNIFORM1IARBPROC glUniform1iARB;
+    PFNGLUNIFORM1FARBPROC glUniform1fARB;
+    PFNGLUNIFORM3FARBPROC glUniform3fARB;
+    PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
+
+    bool GL_ARB_texture_rectangle_supported;
+
+    GL_ShaderData shaders[NUM_SHADERS];
+    const float *shader_params[NUM_SHADERS];
+};
+
+/* *INDENT-OFF* */ // clang-format off
+
+#define COLOR_VERTEX_SHADER                                     \
+"varying vec4 v_color;\n"                                       \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" \
+"    v_color = gl_Color;\n"                                     \
+"}"                                                             \
+
+#define TEXTURE_VERTEX_SHADER                                   \
+"varying vec4 v_color;\n"                                       \
+"varying vec2 v_texCoord;\n"                                    \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n" \
+"    v_color = gl_Color;\n"                                     \
+"    v_texCoord = vec2(gl_MultiTexCoord0);\n"                   \
+"}"                                                             \
+
+#define YUV_SHADER_PROLOGUE                                     \
+"varying vec4 v_color;\n"                                       \
+"varying vec2 v_texCoord;\n"                                    \
+"uniform sampler2D tex0; // Y \n"                               \
+"uniform sampler2D tex1; // U \n"                               \
+"uniform sampler2D tex2; // V \n"                               \
+"uniform vec3 Yoffset;\n"                                       \
+"uniform vec3 Rcoeff;\n"                                        \
+"uniform vec3 Gcoeff;\n"                                        \
+"uniform vec3 Bcoeff;\n"                                        \
+"\n"                                                            \
+
+#define YUV_SHADER_BODY                                         \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    vec2 tcoord;\n"                                            \
+"    vec3 yuv, rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the Y value \n"                                     \
+"    tcoord = v_texCoord;\n"                                    \
+"    yuv.x = texture2D(tex0, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Get the U and V values \n"                              \
+"    tcoord *= UVCoordScale;\n"                                 \
+"    yuv.y = texture2D(tex1, tcoord).r;\n"                      \
+"    yuv.z = texture2D(tex2, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += Yoffset;\n"                                         \
+"    rgb.r = dot(yuv, Rcoeff);\n"                               \
+"    rgb.g = dot(yuv, Gcoeff);\n"                               \
+"    rgb.b = dot(yuv, Bcoeff);\n"                               \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
+"}"                                                             \
+
+#define NV12_SHADER_PROLOGUE                                    \
+"varying vec4 v_color;\n"                                       \
+"varying vec2 v_texCoord;\n"                                    \
+"uniform sampler2D tex0; // Y \n"                               \
+"uniform sampler2D tex1; // U/V \n"                             \
+"uniform vec3 Yoffset;\n"                                       \
+"uniform vec3 Rcoeff;\n"                                        \
+"uniform vec3 Gcoeff;\n"                                        \
+"uniform vec3 Bcoeff;\n"                                        \
+"\n"                                                            \
+
+#define NV12_RA_SHADER_BODY                                     \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    vec2 tcoord;\n"                                            \
+"    vec3 yuv, rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the Y value \n"                                     \
+"    tcoord = v_texCoord;\n"                                    \
+"    yuv.x = texture2D(tex0, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Get the U and V values \n"                              \
+"    tcoord *= UVCoordScale;\n"                                 \
+"    yuv.yz = texture2D(tex1, tcoord).ra;\n"                    \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += Yoffset;\n"                                         \
+"    rgb.r = dot(yuv, Rcoeff);\n"                               \
+"    rgb.g = dot(yuv, Gcoeff);\n"                               \
+"    rgb.b = dot(yuv, Bcoeff);\n"                               \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
+"}"                                                             \
+
+#define NV12_RG_SHADER_BODY                                     \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    vec2 tcoord;\n"                                            \
+"    vec3 yuv, rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the Y value \n"                                     \
+"    tcoord = v_texCoord;\n"                                    \
+"    yuv.x = texture2D(tex0, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Get the U and V values \n"                              \
+"    tcoord *= UVCoordScale;\n"                                 \
+"    yuv.yz = texture2D(tex1, tcoord).rg;\n"                    \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += Yoffset;\n"                                         \
+"    rgb.r = dot(yuv, Rcoeff);\n"                               \
+"    rgb.g = dot(yuv, Gcoeff);\n"                               \
+"    rgb.b = dot(yuv, Bcoeff);\n"                               \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
+"}"                                                             \
+
+#define NV21_RA_SHADER_BODY                                     \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    vec2 tcoord;\n"                                            \
+"    vec3 yuv, rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the Y value \n"                                     \
+"    tcoord = v_texCoord;\n"                                    \
+"    yuv.x = texture2D(tex0, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Get the U and V values \n"                              \
+"    tcoord *= UVCoordScale;\n"                                 \
+"    yuv.yz = texture2D(tex1, tcoord).ar;\n"                    \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += Yoffset;\n"                                         \
+"    rgb.r = dot(yuv, Rcoeff);\n"                               \
+"    rgb.g = dot(yuv, Gcoeff);\n"                               \
+"    rgb.b = dot(yuv, Bcoeff);\n"                               \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
+"}"                                                             \
+
+#define NV21_RG_SHADER_BODY                                     \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    vec2 tcoord;\n"                                            \
+"    vec3 yuv, rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the Y value \n"                                     \
+"    tcoord = v_texCoord;\n"                                    \
+"    yuv.x = texture2D(tex0, tcoord).r;\n"                      \
+"\n"                                                            \
+"    // Get the U and V values \n"                              \
+"    tcoord *= UVCoordScale;\n"                                 \
+"    yuv.yz = texture2D(tex1, tcoord).gr;\n"                    \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += Yoffset;\n"                                         \
+"    rgb.r = dot(yuv, Rcoeff);\n"                               \
+"    rgb.g = dot(yuv, Gcoeff);\n"                               \
+"    rgb.b = dot(yuv, Bcoeff);\n"                               \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1.0) * v_color;\n"                \
+"}"                                                             \
+
+/*
+ * NOTE: Always use sampler2D, etc here. We'll #define them to the
+ *  texture_rectangle versions if we choose to use that extension.
+ */
+static const char *shader_source[NUM_SHADERS][2] = {
+    // SHADER_NONE
+    { NULL, NULL },
+
+    // SHADER_SOLID
+    {
+        // vertex shader
+        COLOR_VERTEX_SHADER,
+        // fragment shader
+"varying vec4 v_color;\n"
+"\n"
+"void main()\n"
+"{\n"
+"    gl_FragColor = v_color;\n"
+"}"
+    },
+
+    // SHADER_RGB
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+"varying vec4 v_color;\n"
+"varying vec2 v_texCoord;\n"
+"uniform sampler2D tex0;\n"
+"\n"
+"void main()\n"
+"{\n"
+"    gl_FragColor = texture2D(tex0, v_texCoord);\n"
+"    gl_FragColor.a = 1.0;\n"
+"    gl_FragColor *= v_color;\n"
+"}"
+    },
+
+    // SHADER_RGBA
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+"varying vec4 v_color;\n"
+"varying vec2 v_texCoord;\n"
+"uniform sampler2D tex0;\n"
+"\n"
+"void main()\n"
+"{\n"
+"    gl_FragColor = texture2D(tex0, v_texCoord) * v_color;\n"
+"}"
+    },
+#ifdef SDL_HAVE_YUV
+    // SHADER_YUV
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+        YUV_SHADER_PROLOGUE
+        YUV_SHADER_BODY
+    },
+    // SHADER_NV12_RA
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+        NV12_SHADER_PROLOGUE
+        NV12_RA_SHADER_BODY
+    },
+    // SHADER_NV12_RG
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+        NV12_SHADER_PROLOGUE
+        NV12_RG_SHADER_BODY
+    },
+    // SHADER_NV21_RA
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+        NV12_SHADER_PROLOGUE
+        NV21_RA_SHADER_BODY
+    },
+    // SHADER_NV21_RG
+    {
+        // vertex shader
+        TEXTURE_VERTEX_SHADER,
+        // fragment shader
+        NV12_SHADER_PROLOGUE
+        NV21_RG_SHADER_BODY
+    },
+#endif // SDL_HAVE_YUV
+};
+
+/* *INDENT-ON* */ // clang-format on
+
+static bool CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const char *defines, const char *source)
+{
+    GLint status;
+    const char *sources[2];
+
+    sources[0] = defines;
+    sources[1] = source;
+
+    ctx->glShaderSourceARB(shader, SDL_arraysize(sources), sources, NULL);
+    ctx->glCompileShaderARB(shader);
+    ctx->glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
+    if (status == 0) {
+        bool isstack;
+        GLint length;
+        char *info;
+
+        ctx->glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+        info = SDL_small_alloc(char, length + 1, &isstack);
+        if (info) {
+            ctx->glGetInfoLogARB(shader, length, NULL, info);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Failed to compile shader:");
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", defines);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", source);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", info);
+            SDL_small_free(info, isstack);
+        }
+        return false;
+    } else {
+        return true;
+    }
+}
+
+static bool CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_ShaderData *data)
+{
+    const int num_tmus_bound = 4;
+    const char *vert_defines = "";
+    const char *frag_defines = "";
+    int i;
+    GLint location;
+
+    if (index == SHADER_NONE) {
+        return true;
+    }
+
+    ctx->glGetError();
+
+    // Make sure we use the correct sampler type for our texture type
+    if (ctx->GL_ARB_texture_rectangle_supported) {
+        frag_defines =
+            "#define sampler2D sampler2DRect\n"
+            "#define texture2D texture2DRect\n"
+            "#define UVCoordScale 0.5\n";
+    } else {
+        frag_defines =
+            "#define UVCoordScale 1.0\n";
+    }
+
+    // Create one program object to rule them all
+    data->program = ctx->glCreateProgramObjectARB();
+
+    // Create the vertex shader
+    data->vert_shader = ctx->glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+    if (!CompileShader(ctx, data->vert_shader, vert_defines, shader_source[index][0])) {
+        return false;
+    }
+
+    // Create the fragment shader
+    data->frag_shader = ctx->glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+    if (!CompileShader(ctx, data->frag_shader, frag_defines, shader_source[index][1])) {
+        return false;
+    }
+
+    // ... and in the darkness bind them
+    ctx->glAttachObjectARB(data->program, data->vert_shader);
+    ctx->glAttachObjectARB(data->program, data->frag_shader);
+    ctx->glLinkProgramARB(data->program);
+
+    // Set up some uniform variables
+    ctx->glUseProgramObjectARB(data->program);
+    for (i = 0; i < num_tmus_bound; ++i) {
+        char tex_name[10];
+        (void)SDL_snprintf(tex_name, SDL_arraysize(tex_name), "tex%d", i);
+        location = ctx->glGetUniformLocationARB(data->program, tex_name);
+        if (location >= 0) {
+            ctx->glUniform1iARB(location, i);
+        }
+    }
+    ctx->glUseProgramObjectARB(0);
+
+    return ctx->glGetError() == GL_NO_ERROR;
+}
+
+static void DestroyShaderProgram(GL_ShaderContext *ctx, GL_ShaderData *data)
+{
+    ctx->glDeleteObjectARB(data->vert_shader);
+    ctx->glDeleteObjectARB(data->frag_shader);
+    ctx->glDeleteObjectARB(data->program);
+}
+
+GL_ShaderContext *GL_CreateShaderContext(void)
+{
+    GL_ShaderContext *ctx;
+    bool shaders_supported;
+    int i;
+
+    ctx = (GL_ShaderContext *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return NULL;
+    }
+
+    if (!SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two") &&
+        (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
+         SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle"))) {
+        ctx->GL_ARB_texture_rectangle_supported = true;
+    }
+
+    // Check for shader support
+    shaders_supported = false;
+    if (SDL_GL_ExtensionSupported("GL_ARB_shader_objects") &&
+        SDL_GL_ExtensionSupported("GL_ARB_shading_language_100") &&
+        SDL_GL_ExtensionSupported("GL_ARB_vertex_shader") &&
+        SDL_GL_ExtensionSupported("GL_ARB_fragment_shader")) {
+        ctx->glGetError = (GLenum(*)(void))SDL_GL_GetProcAddress("glGetError");
+        ctx->glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)SDL_GL_GetProcAddress("glAttachObjectARB");
+        ctx->glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)SDL_GL_GetProcAddress("glCompileShaderARB");
+        ctx->glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glCreateProgramObjectARB");
+        ctx->glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)SDL_GL_GetProcAddress("glCreateShaderObjectARB");
+        ctx->glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)SDL_GL_GetProcAddress("glDeleteObjectARB");
+        ctx->glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)SDL_GL_GetProcAddress("glGetInfoLogARB");
+        ctx->glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)SDL_GL_GetProcAddress("glGetObjectParameterivARB");
+        ctx->glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)SDL_GL_GetProcAddress("glGetUniformLocationARB");
+        ctx->glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)SDL_GL_GetProcAddress("glLinkProgramARB");
+        ctx->glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)SDL_GL_GetProcAddress("glShaderSourceARB");
+        ctx->glUniform1iARB = (PFNGLUNIFORM1IARBPROC)SDL_GL_GetProcAddress("glUniform1iARB");
+        ctx->glUniform1fARB = (PFNGLUNIFORM1FARBPROC)SDL_GL_GetProcAddress("glUniform1fARB");
+        ctx->glUniform3fARB = (PFNGLUNIFORM3FARBPROC)SDL_GL_GetProcAddress("glUniform3fARB");
+        ctx->glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glUseProgramObjectARB");
+        if (ctx->glGetError &&
+            ctx->glAttachObjectARB &&
+            ctx->glCompileShaderARB &&
+            ctx->glCreateProgramObjectARB &&
+            ctx->glCreateShaderObjectARB &&
+            ctx->glDeleteObjectARB &&
+            ctx->glGetInfoLogARB &&
+            ctx->glGetObjectParameterivARB &&
+            ctx->glGetUniformLocationARB &&
+            ctx->glLinkProgramARB &&
+            ctx->glShaderSourceARB &&
+            ctx->glUniform1iARB &&
+            ctx->glUniform1fARB &&
+            ctx->glUniform3fARB &&
+            ctx->glUseProgramObjectARB) {
+            shaders_supported = true;
+        }
+    }
+
+    if (!shaders_supported) {
+        SDL_free(ctx);
+        return NULL;
+    }
+
+    // Compile all the shaders
+    for (i = 0; i < NUM_SHADERS; ++i) {
+        if (!CompileShaderProgram(ctx, i, &ctx->shaders[i])) {
+            GL_DestroyShaderContext(ctx);
+            return NULL;
+        }
+    }
+
+    // We're done!
+    return ctx;
+}
+
+void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader, const float *shader_params)
+{
+    GLint location;
+    GLhandleARB program = ctx->shaders[shader].program;
+
+    ctx->glUseProgramObjectARB(program);
+
+    if (shader_params && shader_params != ctx->shader_params[shader]) {
+        // YUV shader params are Yoffset, 0, Rcoeff, 0, Gcoeff, 0, Bcoeff, 0
+        location = ctx->glGetUniformLocationARB(program, "Yoffset");
+        if (location >= 0) {
+            ctx->glUniform3fARB(location, shader_params[0], shader_params[1], shader_params[2]);
+        }
+        location = ctx->glGetUniformLocationARB(program, "Rcoeff");
+        if (location >= 0) {
+            ctx->glUniform3fARB(location, shader_params[4], shader_params[5], shader_params[6]);
+        }
+        location = ctx->glGetUniformLocationARB(program, "Gcoeff");
+        if (location >= 0) {
+            ctx->glUniform3fARB(location, shader_params[8], shader_params[9], shader_params[10]);
+        }
+        location = ctx->glGetUniformLocationARB(program, "Bcoeff");
+        if (location >= 0) {
+            ctx->glUniform3fARB(location, shader_params[12], shader_params[13], shader_params[14]);
+        }
+        ctx->shader_params[shader] = shader_params;
+    }
+}
+
+void GL_DestroyShaderContext(GL_ShaderContext *ctx)
+{
+    int i;
+
+    for (i = 0; i < NUM_SHADERS; ++i) {
+        DestroyShaderProgram(ctx, &ctx->shaders[i]);
+    }
+    SDL_free(ctx);
+}
+
+#endif // SDL_VIDEO_RENDER_OGL
diff --git a/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h b/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h
new file mode 100644
index 0000000..374940a
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengl/SDL_shaders_gl.h
@@ -0,0 +1,52 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_shaders_gl_h_
+#define SDL_shaders_gl_h_
+
+#include "SDL_internal.h"
+
+// OpenGL shader implementation
+
+typedef enum
+{
+    SHADER_INVALID = -1,
+    SHADER_NONE,
+    SHADER_SOLID,
+    SHADER_RGB,
+    SHADER_RGBA,
+#ifdef SDL_HAVE_YUV
+    SHADER_YUV,
+    SHADER_NV12_RA,
+    SHADER_NV12_RG,
+    SHADER_NV21_RA,
+    SHADER_NV21_RG,
+#endif
+    NUM_SHADERS
+} GL_Shader;
+
+typedef struct GL_ShaderContext GL_ShaderContext;
+
+extern GL_ShaderContext *GL_CreateShaderContext(void);
+extern void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader, const float *shader_params);
+extern void GL_DestroyShaderContext(GL_ShaderContext *ctx);
+
+#endif // SDL_shaders_gl_h_
diff --git a/SDL-3.2.8/src/render/opengles2/SDL_gles2funcs.h b/SDL-3.2.8/src/render/opengles2/SDL_gles2funcs.h
new file mode 100644
index 0000000..bbc47a4
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengles2/SDL_gles2funcs.h
@@ -0,0 +1,78 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+SDL_PROC(void, glActiveTexture, (GLenum))
+SDL_PROC(void, glAttachShader, (GLuint, GLuint))
+SDL_PROC(void, glBindAttribLocation, (GLuint, GLuint, const char *))
+SDL_PROC(void, glBindTexture, (GLenum, GLuint))
+SDL_PROC(void, glBlendEquationSeparate, (GLenum, GLenum))
+SDL_PROC(void, glBlendFuncSeparate, (GLenum, GLenum, GLenum, GLenum))
+SDL_PROC(void, glClear, (GLbitfield))
+SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
+SDL_PROC(void, glCompileShader, (GLuint))
+SDL_PROC(GLuint, glCreateProgram, (void))
+SDL_PROC(GLuint, glCreateShader, (GLenum))
+SDL_PROC(void, glDeleteProgram, (GLuint))
+SDL_PROC(void, glDeleteShader, (GLuint))
+SDL_PROC(void, glDeleteTextures, (GLsizei, const GLuint *))
+SDL_PROC(void, glDisable, (GLenum))
+SDL_PROC(void, glDisableVertexAttribArray, (GLuint))
+SDL_PROC(void, glDrawArrays, (GLenum, GLint, GLsizei))
+SDL_PROC(void, glEnable, (GLenum))
+SDL_PROC(void, glEnableVertexAttribArray, (GLuint))
+SDL_PROC(void, glFinish, (void))
+SDL_PROC(void, glGenFramebuffers, (GLsizei, GLuint *))
+SDL_PROC(void, glGenTextures, (GLsizei, GLuint *))
+SDL_PROC(const GLubyte *, glGetString, (GLenum))
+SDL_PROC(GLenum, glGetError, (void))
+SDL_PROC(void, glGetIntegerv, (GLenum, GLint *))
+SDL_PROC(void, glGetProgramiv, (GLuint, GLenum, GLint *))
+SDL_PROC(void, glGetShaderInfoLog, (GLuint, GLsizei, GLsizei *, char *))
+SDL_PROC(void, glGetShaderiv, (GLuint, GLenum, GLint *))
+SDL_PROC(GLint, glGetUniformLocation, (GLuint, const char *))
+SDL_PROC(void, glLinkProgram, (GLuint))
+SDL_PROC(void, glPixelStorei, (GLenum, GLint))
+SDL_PROC(void, glReadPixels, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+SDL_PROC(void, glScissor, (GLint, GLint, GLsizei, GLsizei))
+SDL_PROC(void, glShaderBinary, (GLsizei, const GLuint *, GLenum, const void *, GLsizei))
+SDL_PROC(void, glShaderSource, (GLuint, GLsizei, const GLchar *const *, const GLint *))
+SDL_PROC(void, glTexImage2D, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *))
+SDL_PROC(void, glTexParameteri, (GLenum, GLenum, GLint))
+SDL_PROC(void, glTexSubImage2D, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+SDL_PROC(void, glUniform1i, (GLint, GLint))
+SDL_PROC(void, glUniform3f, (GLint, GLfloat, GLfloat, GLfloat))
+SDL_PROC(void, glUniform4f, (GLint, GLfloat, GLfloat, GLfloat, GLfloat))
+SDL_PROC(void, glUniformMatrix3fv, (GLint, GLsizei, GLboolean, const GLfloat *))
+SDL_PROC(void, glUniformMatrix4fv, (GLint, GLsizei, GLboolean, const GLfloat *))
+SDL_PROC(void, glUseProgram, (GLuint))
+SDL_PROC(void, glVertexAttribPointer, (GLuint, GLint, GLenum, GLboolean, GLsizei, const void *))
+SDL_PROC(void, glViewport, (GLint, GLint, GLsizei, GLsizei))
+SDL_PROC(void, glBindFramebuffer, (GLenum, GLuint))
+SDL_PROC(void, glFramebufferTexture2D, (GLenum, GLenum, GLenum, GLuint, GLint))
+SDL_PROC(GLenum, glCheckFramebufferStatus, (GLenum))
+SDL_PROC(void, glDeleteFramebuffers, (GLsizei, const GLuint *))
+SDL_PROC(GLint, glGetAttribLocation, (GLuint, const GLchar *))
+SDL_PROC(void, glGetProgramInfoLog, (GLuint, GLsizei, GLsizei *, GLchar *))
+SDL_PROC(void, glGenBuffers, (GLsizei, GLuint *))
+SDL_PROC(void, glDeleteBuffers, (GLsizei, const GLuint *))
+SDL_PROC(void, glBindBuffer, (GLenum, GLuint))
+SDL_PROC(void, glBufferData, (GLenum, GLsizeiptr, const GLvoid *, GLenum))
+SDL_PROC(void, glBufferSubData, (GLenum, GLintptr, GLsizeiptr, const GLvoid *))
diff --git a/SDL-3.2.8/src/render/opengles2/SDL_render_gles2.c b/SDL-3.2.8/src/render/opengles2/SDL_render_gles2.c
new file mode 100644
index 0000000..0e142a7
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengles2/SDL_render_gles2.c
@@ -0,0 +1,2226 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_OGL_ES2
+
+#include "../../video/SDL_sysvideo.h" // For SDL_RecreateWindow
+#include <SDL3/SDL_opengles2.h>
+#include "../SDL_sysrender.h"
+#include "../../video/SDL_pixels_c.h"
+#include "SDL_shaders_gles2.h"
+
+/* WebGL doesn't offer client-side arrays, so use Vertex Buffer Objects
+   on Emscripten, which converts GLES2 into WebGL calls.
+   In all other cases, attempt to use client-side arrays, as they tend to
+   be dramatically faster when not batching, and about the same when
+   we are. */
+#ifdef SDL_PLATFORM_EMSCRIPTEN
+#define USE_VERTEX_BUFFER_OBJECTS 1
+#else
+#define USE_VERTEX_BUFFER_OBJECTS 0
+#endif
+
+/* To prevent unnecessary window recreation,
+ * these should match the defaults selected in SDL_GL_ResetAttributes
+ */
+#define RENDERER_CONTEXT_MAJOR 2
+#define RENDERER_CONTEXT_MINOR 0
+
+/*************************************************************************************************
+ * Context structures                                                                            *
+ *************************************************************************************************/
+
+typedef struct GLES2_FBOList GLES2_FBOList;
+
+struct GLES2_FBOList
+{
+    Uint32 w, h;
+    GLuint FBO;
+    GLES2_FBOList *next;
+};
+
+typedef struct GLES2_TextureData
+{
+    GLuint texture;
+    bool texture_external;
+    GLenum texture_type;
+    GLenum pixel_format;
+    GLenum pixel_type;
+    void *pixel_data;
+    int pitch;
+#ifdef SDL_HAVE_YUV
+    // YUV texture support
+    bool yuv;
+    bool nv12;
+    GLuint texture_v;
+    GLuint texture_v_external;
+    GLuint texture_u;
+    GLuint texture_u_external;
+#endif
+    GLES2_FBOList *fbo;
+} GLES2_TextureData;
+
+typedef enum
+{
+    GLES2_ATTRIBUTE_POSITION = 0,
+    GLES2_ATTRIBUTE_COLOR = 1,
+    GLES2_ATTRIBUTE_TEXCOORD = 2,
+} GLES2_Attribute;
+
+typedef enum
+{
+    GLES2_UNIFORM_PROJECTION,
+    GLES2_UNIFORM_TEXTURE,
+    GLES2_UNIFORM_TEXTURE_U,
+    GLES2_UNIFORM_TEXTURE_V,
+    GLES2_UNIFORM_OFFSET,
+    GLES2_UNIFORM_MATRIX,
+    NUM_GLES2_UNIFORMS
+} GLES2_Uniform;
+
+static const char *GLES2_UniformNames[] = {
+    "u_projection",
+    "u_texture",
+    "u_texture_u",
+    "u_texture_v",
+    "u_offset",
+    "u_matrix"
+};
+SDL_COMPILE_TIME_ASSERT(GLES2_UniformNames, SDL_arraysize(GLES2_UniformNames) == NUM_GLES2_UNIFORMS);
+
+typedef struct GLES2_ProgramCacheEntry
+{
+    GLuint id;
+    GLuint vertex_shader;
+    GLuint fragment_shader;
+    GLuint uniform_locations[NUM_GLES2_UNIFORMS];
+    GLfloat projection[4][4];
+    const float *shader_params;
+    struct GLES2_ProgramCacheEntry *prev;
+    struct GLES2_ProgramCacheEntry *next;
+} GLES2_ProgramCacheEntry;
+
+typedef struct GLES2_ProgramCache
+{
+    int count;
+    GLES2_ProgramCacheEntry *head;
+    GLES2_ProgramCacheEntry *tail;
+} GLES2_ProgramCache;
+
+typedef enum
+{
+    GLES2_IMAGESOURCE_INVALID,
+    GLES2_IMAGESOURCE_SOLID,
+    GLES2_IMAGESOURCE_TEXTURE_ABGR,
+    GLES2_IMAGESOURCE_TEXTURE_ARGB,
+    GLES2_IMAGESOURCE_TEXTURE_RGB,
+    GLES2_IMAGESOURCE_TEXTURE_BGR,
+    GLES2_IMAGESOURCE_TEXTURE_YUV,
+    GLES2_IMAGESOURCE_TEXTURE_NV12,
+    GLES2_IMAGESOURCE_TEXTURE_NV21,
+    GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES
+} GLES2_ImageSource;
+
+typedef struct
+{
+    SDL_Rect viewport;
+    bool viewport_dirty;
+    SDL_Texture *texture;
+    SDL_Texture *target;
+    SDL_BlendMode blend;
+    bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_dirty;
+    SDL_Rect cliprect;
+    bool texturing;
+    bool texturing_dirty;
+    SDL_FColor clear_color;
+    bool clear_color_dirty;
+    int drawablew;
+    int drawableh;
+    GLES2_ProgramCacheEntry *program;
+    const float *shader_params;
+    GLfloat projection[4][4];
+} GLES2_DrawStateCache;
+
+typedef struct GLES2_RenderData
+{
+    SDL_GLContext context;
+
+    bool debug_enabled;
+
+    bool GL_EXT_blend_minmax_supported;
+
+#define SDL_PROC(ret, func, params) ret (APIENTRY *func) params;
+#include "SDL_gles2funcs.h"
+#undef SDL_PROC
+    GLES2_FBOList *framebuffers;
+    GLuint window_framebuffer;
+
+    GLuint shader_id_cache[GLES2_SHADER_COUNT];
+
+    GLES2_ProgramCache program_cache;
+    Uint8 clear_r, clear_g, clear_b, clear_a;
+
+#if USE_VERTEX_BUFFER_OBJECTS
+    GLuint vertex_buffers[8];
+    size_t vertex_buffer_size[8];
+    int current_vertex_buffer;
+#endif
+
+    GLES2_DrawStateCache drawstate;
+    GLES2_ShaderIncludeType texcoord_precision_hint;
+} GLES2_RenderData;
+
+#define GLES2_MAX_CACHED_PROGRAMS 8
+
+static const char *GL_TranslateError(GLenum error)
+{
+#define GL_ERROR_TRANSLATE(e) \
+    case e:                   \
+        return #e;
+    switch (error) {
+        GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
+        GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
+        GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
+        GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
+        GL_ERROR_TRANSLATE(GL_NO_ERROR)
+    default:
+        return "UNKNOWN";
+    }
+#undef GL_ERROR_TRANSLATE
+}
+
+static void GL_ClearErrors(SDL_Renderer *renderer)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+
+    if (!data->debug_enabled) {
+        return;
+    }
+    while (data->glGetError() != GL_NO_ERROR) {
+        // continue;
+    }
+}
+
+static bool GL_CheckAllErrors(const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    bool result = true;
+
+    if (!data->debug_enabled) {
+        return true;
+    }
+    // check gl errors (can return multiple errors)
+    for (;;) {
+        GLenum error = data->glGetError();
+        if (error != GL_NO_ERROR) {
+            if (!prefix || prefix[0] == '\0') {
+                prefix = "generic";
+            }
+            SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
+            result = false;
+        } else {
+            break;
+        }
+    }
+    return result;
+}
+
+#if 0
+#define GL_CheckError(prefix, renderer)
+#else
+#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION)
+#endif
+
+/*************************************************************************************************
+ * Renderer state APIs                                                                           *
+ *************************************************************************************************/
+
+static bool GLES2_LoadFunctions(GLES2_RenderData *data)
+{
+#ifdef SDL_VIDEO_DRIVER_UIKIT
+#define __SDL_NOGETPROCADDR__
+#elif defined(SDL_VIDEO_DRIVER_ANDROID)
+#define __SDL_NOGETPROCADDR__
+#endif
+
+#if defined __SDL_NOGETPROCADDR__
+#define SDL_PROC(ret, func, params) data->func = func;
+#else
+#define SDL_PROC(ret, func, params)                                                            \
+    do {                                                                                       \
+        data->func = (ret (APIENTRY *) params)SDL_GL_GetProcAddress(#func);                                             \
+        if (!data->func) {                                                                     \
+            return SDL_SetError("Couldn't load GLES2 function %s: %s", #func, SDL_GetError()); \
+        }                                                                                      \
+    } while (0);
+#endif // __SDL_NOGETPROCADDR__
+
+#include "SDL_gles2funcs.h"
+#undef SDL_PROC
+    return true;
+}
+
+static GLES2_FBOList *GLES2_GetFBO(GLES2_RenderData *data, Uint32 w, Uint32 h)
+{
+    GLES2_FBOList *result = data->framebuffers;
+    while ((result) && ((result->w != w) || (result->h != h))) {
+        result = result->next;
+    }
+    if (!result) {
+        result = (GLES2_FBOList *)SDL_malloc(sizeof(GLES2_FBOList));
+        result->w = w;
+        result->h = h;
+        data->glGenFramebuffers(1, &result->FBO);
+        result->next = data->framebuffers;
+        data->framebuffers = result;
+    }
+    return result;
+}
+
+static bool GLES2_ActivateRenderer(SDL_Renderer *renderer)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+
+    if (SDL_GL_GetCurrentContext() != data->context) {
+        // Null out the current program to ensure we set it again
+        data->drawstate.program = NULL;
+
+        if (!SDL_GL_MakeCurrent(renderer->window, data->context)) {
+            return false;
+        }
+    }
+
+    GL_ClearErrors(renderer);
+
+    return true;
+}
+
+static void GLES2_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+
+    if (event->type == SDL_EVENT_WINDOW_MINIMIZED) {
+        // According to Apple documentation, we need to finish drawing NOW!
+        data->glFinish();
+    }
+}
+
+static GLenum GetBlendFunc(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return GL_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return GL_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return GL_SRC_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return GL_ONE_MINUS_SRC_COLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return GL_SRC_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return GL_ONE_MINUS_SRC_ALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return GL_DST_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return GL_ONE_MINUS_DST_COLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return GL_DST_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return GL_ONE_MINUS_DST_ALPHA;
+    default:
+        return GL_INVALID_ENUM;
+    }
+}
+
+static GLenum GetBlendEquation(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return GL_FUNC_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return GL_FUNC_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return GL_FUNC_REVERSE_SUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return GL_MIN_EXT;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return GL_MAX_EXT;
+    default:
+        return GL_INVALID_ENUM;
+    }
+}
+
+static bool GLES2_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
+        GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
+        GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
+        GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
+        GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
+        GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
+        return false;
+    }
+
+    if (colorOperation == SDL_BLENDOPERATION_MINIMUM && !data->GL_EXT_blend_minmax_supported) {
+        return false;
+    }
+    if (colorOperation == SDL_BLENDOPERATION_MAXIMUM && !data->GL_EXT_blend_minmax_supported) {
+        return false;
+    }
+
+    return true;
+}
+
+static GLES2_ProgramCacheEntry *GLES2_CacheProgram(GLES2_RenderData *data, GLuint vertex, GLuint fragment)
+{
+    GLES2_ProgramCacheEntry *entry;
+    GLint linkSuccessful;
+    int i;
+
+    // Check if we've already cached this program
+    entry = data->program_cache.head;
+    while (entry) {
+        if (entry->vertex_shader == vertex && entry->fragment_shader == fragment) {
+            break;
+        }
+        entry = entry->next;
+    }
+    if (entry) {
+        if (data->program_cache.head != entry) {
+            if (entry->next) {
+                entry->next->prev = entry->prev;
+            }
+            if (entry->prev) {
+                entry->prev->next = entry->next;
+            }
+            entry->prev = NULL;
+            entry->next = data->program_cache.head;
+            data->program_cache.head->prev = entry;
+            data->program_cache.head = entry;
+        }
+        return entry;
+    }
+
+    // Create a program cache entry
+    entry = (GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(GLES2_ProgramCacheEntry));
+    if (!entry) {
+        return NULL;
+    }
+    entry->vertex_shader = vertex;
+    entry->fragment_shader = fragment;
+
+    // Create the program and link it
+    entry->id = data->glCreateProgram();
+    data->glAttachShader(entry->id, vertex);
+    data->glAttachShader(entry->id, fragment);
+    data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
+    data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_COLOR, "a_color");
+    data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
+    data->glLinkProgram(entry->id);
+    data->glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
+    if (!linkSuccessful) {
+        data->glDeleteProgram(entry->id);
+        SDL_free(entry);
+        SDL_SetError("Failed to link shader program");
+        return NULL;
+    }
+
+    // Predetermine locations of uniform variables
+    for (i = 0; i < NUM_GLES2_UNIFORMS; ++i) {
+        entry->uniform_locations[i] = data->glGetUniformLocation(entry->id, GLES2_UniformNames[i]);
+    }
+
+    data->glUseProgram(entry->id);
+    if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] != -1) {
+        data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V], 2); // always texture unit 2.
+    }
+    if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] != -1) {
+        data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U], 1); // always texture unit 1.
+    }
+    if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE] != -1) {
+        data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE], 0); // always texture unit 0.
+    }
+    if (entry->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) {
+        data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)entry->projection);
+    }
+
+    // Cache the linked program
+    if (data->program_cache.head) {
+        entry->next = data->program_cache.head;
+        data->program_cache.head->prev = entry;
+    } else {
+        data->program_cache.tail = entry;
+    }
+    data->program_cache.head = entry;
+    ++data->program_cache.count;
+
+    // Evict the last entry from the cache if we exceed the limit
+    if (data->program_cache.count > GLES2_MAX_CACHED_PROGRAMS) {
+        data->glDeleteProgram(data->program_cache.tail->id);
+        data->program_cache.tail = data->program_cache.tail->prev;
+        if (data->program_cache.tail) {
+            SDL_free(data->program_cache.tail->next);
+            data->program_cache.tail->next = NULL;
+        }
+        --data->program_cache.count;
+    }
+    return entry;
+}
+
+static GLuint GLES2_CacheShader(GLES2_RenderData *data, GLES2_ShaderType type, GLenum shader_type)
+{
+    GLuint id = 0;
+    GLint compileSuccessful = GL_FALSE;
+    int attempt, num_src;
+    const GLchar *shader_src_list[3];
+    const GLchar *shader_body = GLES2_GetShader(type);
+
+    if (!shader_body) {
+        SDL_SetError("No shader body src");
+        return true;
+    }
+
+    for (attempt = 0; attempt < 2 && !compileSuccessful; ++attempt) {
+        num_src = 0;
+
+        shader_src_list[num_src++] = GLES2_GetShaderPrologue(type);
+
+        if (shader_type == GL_FRAGMENT_SHADER) {
+            if (attempt == 0) {
+                shader_src_list[num_src++] = GLES2_GetShaderInclude(data->texcoord_precision_hint);
+            } else {
+                shader_src_list[num_src++] = GLES2_GetShaderInclude(GLES2_SHADER_FRAGMENT_INCLUDE_UNDEF_PRECISION);
+            }
+        }
+
+        shader_src_list[num_src++] = shader_body;
+
+        SDL_assert(num_src <= SDL_arraysize(shader_src_list));
+
+#ifdef DEBUG_PRINT_SHADERS
+        {
+            int i;
+            char *message = NULL;
+
+            SDL_asprintf(&message, "Compiling shader:\n");
+            for (i = 0; i < num_src; ++i) {
+                char *last_message = message;
+                SDL_asprintf(&message, "%s%s", last_message, shader_src_list[i]);
+                SDL_free(last_message);
+            }
+            SDL_Log("%s", message);
+            SDL_free(message);
+        }
+#endif
+
+        // Compile
+        id = data->glCreateShader(shader_type);
+        data->glShaderSource(id, num_src, shader_src_list, NULL);
+        data->glCompileShader(id);
+        data->glGetShaderiv(id, GL_COMPILE_STATUS, &compileSuccessful);
+    }
+
+    if (!compileSuccessful) {
+        char *info = NULL;
+        int length = 0;
+
+        data->glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
+        if (length > 0) {
+            info = (char *)SDL_malloc(length);
+            if (info) {
+                data->glGetShaderInfoLog(id, length, &length, info);
+            }
+        }
+        if (info) {
+            SDL_SetError("Failed to load the shader %d: %s", type, info);
+            SDL_free(info);
+        } else {
+            SDL_SetError("Failed to load the shader %d", type);
+        }
+        data->glDeleteShader(id);
+        return true;
+    }
+
+    // Cache
+    data->shader_id_cache[(Uint32)type] = id;
+
+    return id;
+}
+
+static bool GLES2_CacheShaders(GLES2_RenderData *data)
+{
+    int shader;
+
+    data->texcoord_precision_hint = GLES2_GetTexCoordPrecisionEnumFromHint();
+
+    for (shader = 0; shader < GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES; ++shader) {
+        GLenum shader_type;
+
+        if (shader == GLES2_SHADER_VERTEX_DEFAULT) {
+            shader_type = GL_VERTEX_SHADER;
+        } else {
+            shader_type = GL_FRAGMENT_SHADER;
+        }
+        if (!GLES2_CacheShader(data, (GLES2_ShaderType)shader, shader_type)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, SDL_Colorspace colorspace)
+{
+    GLuint vertex;
+    GLuint fragment;
+    GLES2_ShaderType vtype, ftype;
+    GLES2_ProgramCacheEntry *program;
+    const float *shader_params = NULL;
+
+    // Select an appropriate shader pair for the specified modes
+    vtype = GLES2_SHADER_VERTEX_DEFAULT;
+    switch (source) {
+    case GLES2_IMAGESOURCE_SOLID:
+        ftype = GLES2_SHADER_FRAGMENT_SOLID;
+        break;
+    case GLES2_IMAGESOURCE_TEXTURE_ABGR:
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR;
+        break;
+    case GLES2_IMAGESOURCE_TEXTURE_ARGB:
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB;
+        break;
+    case GLES2_IMAGESOURCE_TEXTURE_RGB:
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB;
+        break;
+    case GLES2_IMAGESOURCE_TEXTURE_BGR:
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR;
+        break;
+#ifdef SDL_HAVE_YUV
+    case GLES2_IMAGESOURCE_TEXTURE_YUV:
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV;
+        shader_params = SDL_GetYCbCRtoRGBConversionMatrix(colorspace, 0, 0, 8);
+        if (!shader_params) {
+            SDL_SetError("Unsupported YUV colorspace");
+            goto fault;
+        }
+        break;
+    case GLES2_IMAGESOURCE_TEXTURE_NV12:
+        if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG;
+        } else {
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA;
+        }
+        shader_params = SDL_GetYCbCRtoRGBConversionMatrix(colorspace, 0, 0, 8);
+        if (!shader_params) {
+            SDL_SetError("Unsupported YUV colorspace");
+            goto fault;
+        }
+        break;
+    case GLES2_IMAGESOURCE_TEXTURE_NV21:
+        if (SDL_GetHintBoolean("SDL_RENDER_OPENGL_NV12_RG_SHADER", false)) {
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RG;
+        } else {
+            ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RA;
+        }
+        shader_params = SDL_GetYCbCRtoRGBConversionMatrix(colorspace, 0, 0, 8);
+        if (!shader_params) {
+            SDL_SetError("Unsupported YUV colorspace");
+            goto fault;
+        }
+        break;
+#endif // SDL_HAVE_YUV
+    case GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES:
+        ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES;
+        break;
+    default:
+        goto fault;
+    }
+
+    // Load the requested shaders
+    vertex = data->shader_id_cache[(Uint32)vtype];
+    if (!vertex) {
+        vertex = GLES2_CacheShader(data, vtype, GL_VERTEX_SHADER);
+        if (!vertex) {
+            goto fault;
+        }
+    }
+
+    fragment = data->shader_id_cache[(Uint32)ftype];
+    if (!fragment) {
+        fragment = GLES2_CacheShader(data, ftype, GL_FRAGMENT_SHADER);
+        if (!fragment) {
+            goto fault;
+        }
+    }
+
+    // Check if we need to change programs at all
+    if (data->drawstate.program &&
+        data->drawstate.program->vertex_shader == vertex &&
+        data->drawstate.program->fragment_shader == fragment &&
+        data->drawstate.program->shader_params == shader_params) {
+        return true;
+    }
+
+    // Generate a matching program
+    program = GLES2_CacheProgram(data, vertex, fragment);
+    if (!program) {
+        goto fault;
+    }
+
+    // Select that program in OpenGL
+    data->glUseProgram(program->id);
+
+    if (shader_params && shader_params != program->shader_params) {
+        // YUV shader params are Yoffset, 0, Rcoeff, 0, Gcoeff, 0, Bcoeff, 0
+        if (program->uniform_locations[GLES2_UNIFORM_OFFSET] != -1) {
+            data->glUniform3f(program->uniform_locations[GLES2_UNIFORM_OFFSET], shader_params[0], shader_params[1], shader_params[2]);
+        }
+        if (program->uniform_locations[GLES2_UNIFORM_MATRIX] != -1) {
+            GLfloat matrix[3 * 3];
+
+            matrix[0 * 3 + 0] = shader_params[4];
+            matrix[0 * 3 + 1] = shader_params[5];
+            matrix[0 * 3 + 2] = shader_params[6];
+            matrix[1 * 3 + 0] = shader_params[8];
+            matrix[1 * 3 + 1] = shader_params[9];
+            matrix[1 * 3 + 2] = shader_params[10];
+            matrix[2 * 3 + 0] = shader_params[12];
+            matrix[2 * 3 + 1] = shader_params[13];
+            matrix[2 * 3 + 2] = shader_params[14];
+            data->glUniformMatrix3fv(program->uniform_locations[GLES2_UNIFORM_MATRIX], 1, GL_FALSE, matrix);
+        }
+        program->shader_params = shader_params;
+    }
+
+    // Set the current program
+    data->drawstate.program = program;
+
+    // Clean up and return
+    return true;
+fault:
+    data->drawstate.program = NULL;
+    return false;
+}
+
+static bool GLES2_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool GLES2_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    SDL_VertexSolid *verts = (SDL_VertexSolid *)SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
+    int i;
+    SDL_FColor color = cmd->data.draw.color;
+    const float color_scale = cmd->data.draw.color_scale;
+
+    if (!verts) {
+        return false;
+    }
+
+    color.r *= color_scale;
+    color.g *= color_scale;
+    color.b *= color_scale;
+
+    if (colorswap) {
+        float r = color.r;
+        color.r = color.b;
+        color.b = r;
+    }
+
+    cmd->data.draw.count = count;
+    for (i = 0; i < count; i++) {
+        verts->position.x = 0.5f + points[i].x;
+        verts->position.y = 0.5f + points[i].y;
+        verts->color = color;
+        verts++;
+    }
+
+    return true;
+}
+
+static bool GLES2_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    int i;
+    GLfloat prevx, prevy;
+    SDL_VertexSolid *verts = (SDL_VertexSolid *)SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
+    SDL_FColor color = cmd->data.draw.color;
+    const float color_scale = cmd->data.draw.color_scale;
+
+    if (!verts) {
+        return false;
+    }
+
+    color.r *= color_scale;
+    color.g *= color_scale;
+    color.b *= color_scale;
+
+    if (colorswap) {
+        float r = color.r;
+        color.r = color.b;
+        color.b = r;
+    }
+
+    cmd->data.draw.count = count;
+
+    // 0.5f offset to hit the center of the pixel.
+    prevx = 0.5f + points->x;
+    prevy = 0.5f + points->y;
+    verts->position.x = prevx;
+    verts->position.y = prevy;
+    verts->color = color;
+    verts++;
+
+    /* bump the end of each line segment out a quarter of a pixel, to provoke
+       the diamond-exit rule. Without this, you won't just drop the last
+       pixel of the last line segment, but you might also drop pixels at the
+       edge of any given line segment along the way too. */
+    for (i = 1; i < count; i++) {
+        const GLfloat xstart = prevx;
+        const GLfloat ystart = prevy;
+        const GLfloat xend = points[i].x + 0.5f; // 0.5f to hit pixel center.
+        const GLfloat yend = points[i].y + 0.5f;
+        // bump a little in the direction we are moving in.
+        const GLfloat deltax = xend - xstart;
+        const GLfloat deltay = yend - ystart;
+        const GLfloat angle = SDL_atan2f(deltay, deltax);
+        prevx = xend + (SDL_cosf(angle) * 0.25f);
+        prevy = yend + (SDL_sinf(angle) * 0.25f);
+        verts->position.x = prevx;
+        verts->position.y = prevy;
+        verts->color = color;
+        verts++;
+    }
+
+    return true;
+}
+
+static bool GLES2_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                               const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                               int num_vertices, const void *indices, int num_indices, int size_indices,
+                               float scale_x, float scale_y)
+{
+    int i;
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+    int count = indices ? num_indices : num_vertices;
+    const float color_scale = cmd->data.draw.color_scale;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        SDL_Vertex *verts = (SDL_Vertex *)SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
+        if (!verts) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor col_;
+            float *uv_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+            uv_ = (float *)((char *)uv + j * uv_stride);
+
+            verts->position.x = xy_[0] * scale_x;
+            verts->position.y = xy_[1] * scale_y;
+
+            col_.r *= color_scale;
+            col_.g *= color_scale;
+            col_.b *= color_scale;
+
+            if (colorswap) {
+                float r = col_.r;
+                col_.r = col_.b;
+                col_.b = r;
+            }
+
+            verts->color = col_;
+            verts->tex_coord.x = uv_[0];
+            verts->tex_coord.y = uv_[1];
+            verts++;
+        }
+
+    } else {
+        SDL_VertexSolid *verts = (SDL_VertexSolid *)SDL_AllocateRenderVertices(renderer, count * sizeof(*verts), 0, &cmd->data.draw.first);
+        if (!verts) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor col_;
+
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+
+            verts->position.x = xy_[0] * scale_x;
+            verts->position.y = xy_[1] * scale_y;
+
+            col_.r *= color_scale;
+            col_.g *= color_scale;
+            col_.b *= color_scale;
+
+            if (colorswap) {
+                float r = col_.r;
+                col_.r = col_.b;
+                col_.b = r;
+            }
+
+            verts->color = col_;
+            verts++;
+        }
+    }
+
+    return true;
+}
+
+static bool SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_ImageSource imgsrc, void *vertices)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+    GLES2_ProgramCacheEntry *program;
+    int stride;
+
+    SDL_assert((texture != NULL) == (imgsrc != GLES2_IMAGESOURCE_SOLID));
+
+    if (data->drawstate.viewport_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+        data->glViewport(viewport->x,
+                         data->drawstate.target ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
+                         viewport->w, viewport->h);
+        if (viewport->w && viewport->h) {
+            data->drawstate.projection[0][0] = 2.0f / viewport->w;
+            data->drawstate.projection[1][1] = (data->drawstate.target ? 2.0f : -2.0f) / viewport->h;
+            data->drawstate.projection[3][1] = data->drawstate.target ? -1.0f : 1.0f;
+        }
+        data->drawstate.viewport_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled_dirty) {
+        if (!data->drawstate.cliprect_enabled) {
+            data->glDisable(GL_SCISSOR_TEST);
+        } else {
+            data->glEnable(GL_SCISSOR_TEST);
+        }
+        data->drawstate.cliprect_enabled_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+        const SDL_Rect *rect = &data->drawstate.cliprect;
+        data->glScissor(viewport->x + rect->x,
+                        data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
+                        rect->w, rect->h);
+        data->drawstate.cliprect_dirty = false;
+    }
+
+    if (data->drawstate.texturing_dirty || ((texture != NULL) != data->drawstate.texturing)) {
+        if (!texture) {
+            data->glDisableVertexAttribArray((GLenum)GLES2_ATTRIBUTE_TEXCOORD);
+            data->drawstate.texturing = false;
+        } else {
+            data->glEnableVertexAttribArray((GLenum)GLES2_ATTRIBUTE_TEXCOORD);
+            data->drawstate.texturing = true;
+        }
+        data->drawstate.texturing_dirty = false;
+    }
+
+    if (texture) {
+        stride = sizeof(SDL_Vertex);
+    } else {
+        stride = sizeof(SDL_VertexSolid);
+    }
+
+    if (texture) {
+        SDL_Vertex *verts = (SDL_Vertex *)(((Uint8 *)vertices) + cmd->data.draw.first);
+        data->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, stride, (const GLvoid *)&verts->tex_coord);
+    }
+
+    if (!GLES2_SelectProgram(data, imgsrc, texture ? texture->colorspace : SDL_COLORSPACE_SRGB)) {
+        return false;
+    }
+
+    program = data->drawstate.program;
+
+    if (program->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) {
+        if (SDL_memcmp(program->projection, data->drawstate.projection, sizeof(data->drawstate.projection)) != 0) {
+            data->glUniformMatrix4fv(program->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)data->drawstate.projection);
+            SDL_memcpy(program->projection, data->drawstate.projection, sizeof(data->drawstate.projection));
+        }
+    }
+
+    if (blend != data->drawstate.blend) {
+        if (blend == SDL_BLENDMODE_NONE) {
+            data->glDisable(GL_BLEND);
+        } else {
+            data->glEnable(GL_BLEND);
+            data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
+                                      GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
+                                      GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
+                                      GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
+            data->glBlendEquationSeparate(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)),
+                                          GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend)));
+        }
+        data->drawstate.blend = blend;
+    }
+
+    // all drawing commands use this
+    {
+        SDL_VertexSolid *verts = (SDL_VertexSolid *)(((Uint8 *)vertices) + cmd->data.draw.first);
+        data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, stride, (const GLvoid *)&verts->position);
+        data->glVertexAttribPointer(GLES2_ATTRIBUTE_COLOR, 4, GL_FLOAT, GL_TRUE /* Normalized */, stride, (const GLvoid *)&verts->color);
+    }
+
+    return true;
+}
+
+static bool SetTextureAddressMode(GLES2_RenderData *data, GLenum textype, SDL_TextureAddressMode addressMode)
+{
+    switch (addressMode) {
+    case SDL_TEXTURE_ADDRESS_CLAMP:
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        break;
+    case SDL_TEXTURE_ADDRESS_WRAP:
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        data->glTexParameteri(textype, GL_TEXTURE_WRAP_T, GL_REPEAT);
+        break;
+    default:
+        return SDL_SetError("Unknown texture address mode: %d", addressMode);
+    }
+    return true;
+}
+
+static bool SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, void *vertices)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
+    SDL_Texture *texture = cmd->data.draw.texture;
+    int ret;
+
+    // Pick an appropriate shader
+    if (renderer->target) {
+        // Check if we need to do color mapping between the source and render target textures
+        if (renderer->target->format != texture->format) {
+            switch (texture->format) {
+            case SDL_PIXELFORMAT_BGRA32:
+                switch (renderer->target->format) {
+                case SDL_PIXELFORMAT_RGBA32:
+                case SDL_PIXELFORMAT_RGBX32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
+                    break;
+                case SDL_PIXELFORMAT_BGRX32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
+                    break;
+                default:
+                    break;
+                }
+                break;
+            case SDL_PIXELFORMAT_RGBA32:
+                switch (renderer->target->format) {
+                case SDL_PIXELFORMAT_BGRA32:
+                case SDL_PIXELFORMAT_BGRX32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
+                    break;
+                case SDL_PIXELFORMAT_RGBX32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
+                    break;
+                default:
+                    break;
+                }
+                break;
+            case SDL_PIXELFORMAT_BGRX32:
+                switch (renderer->target->format) {
+                case SDL_PIXELFORMAT_RGBA32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
+                    break;
+                case SDL_PIXELFORMAT_BGRA32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
+                    break;
+                case SDL_PIXELFORMAT_RGBX32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
+                    break;
+                default:
+                    break;
+                }
+                break;
+            case SDL_PIXELFORMAT_RGBX32:
+                switch (renderer->target->format) {
+                case SDL_PIXELFORMAT_RGBA32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
+                    break;
+                case SDL_PIXELFORMAT_BGRA32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
+                    break;
+                case SDL_PIXELFORMAT_BGRX32:
+                    sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
+                    break;
+                default:
+                    break;
+                }
+                break;
+#ifdef SDL_HAVE_YUV
+            case SDL_PIXELFORMAT_IYUV:
+            case SDL_PIXELFORMAT_YV12:
+                sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
+                break;
+            case SDL_PIXELFORMAT_NV12:
+                sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
+                break;
+            case SDL_PIXELFORMAT_NV21:
+                sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
+                break;
+#endif
+            case SDL_PIXELFORMAT_EXTERNAL_OES:
+                sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
+                break;
+            default:
+                return SDL_SetError("Unsupported texture format");
+            }
+        } else {
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR; // Texture formats match, use the non color mapping shader (even if the formats are not ABGR)
+        }
+    } else {
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_BGRA32:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
+            break;
+        case SDL_PIXELFORMAT_RGBA32:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
+            break;
+        case SDL_PIXELFORMAT_BGRX32:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
+            break;
+        case SDL_PIXELFORMAT_RGBX32:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
+            break;
+#ifdef SDL_HAVE_YUV
+        case SDL_PIXELFORMAT_IYUV:
+        case SDL_PIXELFORMAT_YV12:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
+            break;
+        case SDL_PIXELFORMAT_NV12:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
+            break;
+        case SDL_PIXELFORMAT_NV21:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
+            break;
+#endif
+        case SDL_PIXELFORMAT_EXTERNAL_OES:
+            sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
+            break;
+        default:
+            return SDL_SetError("Unsupported texture format");
+        }
+    }
+
+    ret = SetDrawState(data, cmd, sourceType, vertices);
+
+    if (texture != data->drawstate.texture) {
+        GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+#ifdef SDL_HAVE_YUV
+        if (tdata->yuv) {
+            data->glActiveTexture(GL_TEXTURE2);
+            data->glBindTexture(tdata->texture_type, tdata->texture_v);
+
+            if (!SetTextureAddressMode(data, tdata->texture_type, cmd->data.draw.texture_address_mode)) {
+                return false;
+            }
+
+            data->glActiveTexture(GL_TEXTURE1);
+            data->glBindTexture(tdata->texture_type, tdata->texture_u);
+
+            if (!SetTextureAddressMode(data, tdata->texture_type, cmd->data.draw.texture_address_mode)) {
+                return false;
+            }
+
+            data->glActiveTexture(GL_TEXTURE0);
+        } else if (tdata->nv12) {
+            data->glActiveTexture(GL_TEXTURE1);
+            data->glBindTexture(tdata->texture_type, tdata->texture_u);
+
+            if (!SetTextureAddressMode(data, tdata->texture_type, cmd->data.draw.texture_address_mode)) {
+                return false;
+            }
+
+            data->glActiveTexture(GL_TEXTURE0);
+        }
+#endif
+        data->glBindTexture(tdata->texture_type, tdata->texture);
+
+        if (!SetTextureAddressMode(data, tdata->texture_type, cmd->data.draw.texture_address_mode)) {
+            return false;
+        }
+
+        data->drawstate.texture = texture;
+    }
+
+    return ret;
+}
+
+static void GLES2_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    GLES2_DrawStateCache *cache = &((GLES2_RenderData *)renderer->internal)->drawstate;
+    cache->viewport_dirty = true;
+    cache->texture = NULL;
+    cache->blend = SDL_BLENDMODE_INVALID;
+    cache->cliprect_enabled_dirty = true;
+    cache->cliprect_dirty = true;
+    cache->texturing_dirty = true;
+    cache->clear_color_dirty = true;
+    cache->drawablew = 0;
+    cache->drawableh = 0;
+    cache->program = NULL;
+}
+
+static bool GLES2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    const bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_BGRA32 || renderer->target->format == SDL_PIXELFORMAT_BGRX32));
+
+#if USE_VERTEX_BUFFER_OBJECTS
+    const int vboidx = data->current_vertex_buffer;
+    const GLuint vbo = data->vertex_buffers[vboidx];
+#endif
+
+    if (!GLES2_ActivateRenderer(renderer)) {
+        return false;
+    }
+
+    data->drawstate.target = renderer->target;
+    if (!data->drawstate.target) {
+        int w, h;
+        SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = true;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
+    }
+
+#if USE_VERTEX_BUFFER_OBJECTS
+    // upload the new VBO data for this set of commands.
+    data->glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    if (data->vertex_buffer_size[vboidx] < vertsize) {
+        data->glBufferData(GL_ARRAY_BUFFER, vertsize, vertices, GL_STREAM_DRAW);
+        data->vertex_buffer_size[vboidx] = vertsize;
+    } else {
+        data->glBufferSubData(GL_ARRAY_BUFFER, 0, vertsize, vertices);
+    }
+
+    // cycle through a few VBOs so the GL has some time with the data before we replace it.
+    data->current_vertex_buffer++;
+    if (data->current_vertex_buffer >= SDL_arraysize(data->vertex_buffers)) {
+        data->current_vertex_buffer = 0;
+    }
+    vertices = NULL; // attrib pointers will be offsets into the VBO.
+#endif
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            break;
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &data->drawstate.viewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
+                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
+                data->drawstate.cliprect_enabled_dirty = true;
+            }
+
+            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&data->drawstate.cliprect, rect);
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            const float r = (colorswap ? cmd->data.color.color.b : cmd->data.color.color.r) * cmd->data.color.color_scale;
+            const float g = cmd->data.color.color.g * cmd->data.color.color_scale;
+            const float b = (colorswap ? cmd->data.color.color.r : cmd->data.color.color.b) * cmd->data.color.color_scale;
+            const float a = cmd->data.color.color.a;
+            if (data->drawstate.clear_color_dirty ||
+                (r != data->drawstate.clear_color.r) ||
+                (g != data->drawstate.clear_color.g) ||
+                (b != data->drawstate.clear_color.b) ||
+                (a != data->drawstate.clear_color.a)) {
+                data->glClearColor(r, g, b, a);
+                data->drawstate.clear_color.r = r;
+                data->drawstate.clear_color.g = g;
+                data->drawstate.clear_color.b = b;
+                data->drawstate.clear_color.a = a;
+                data->drawstate.clear_color_dirty = false;
+            }
+
+            if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
+                data->glDisable(GL_SCISSOR_TEST);
+                data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
+            }
+
+            data->glClear(GL_COLOR_BUFFER_BIT);
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID, vertices)) {
+                size_t count = cmd->data.draw.count;
+                if (count > 2) {
+                    // joined lines cannot be grouped
+                    data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)count);
+                } else {
+                    // let's group non joined lines
+                    SDL_RenderCommand *finalcmd = cmd;
+                    SDL_RenderCommand *nextcmd = cmd->next;
+                    SDL_BlendMode thisblend = cmd->data.draw.blend;
+
+                    while (nextcmd) {
+                        const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                        if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
+                            break; // can't go any further on this draw call, different render command up next.
+                        } else if (nextcmd->data.draw.count != 2) {
+                            break; // can't go any further on this draw call, those are joined lines
+                        } else if (nextcmd->data.draw.blend != thisblend) {
+                            break; // can't go any further on this draw call, different blendmode copy up next.
+                        } else {
+                            finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                            count += nextcmd->data.draw.count;
+                        }
+                        nextcmd = nextcmd->next;
+                    }
+
+                    data->glDrawArrays(GL_LINES, 0, (GLsizei)count);
+                    cmd = finalcmd; // skip any copy commands we just combined in here.
+                }
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            /* as long as we have the same copy command in a row, with the
+               same texture, we can combine them all into a single draw call. */
+            SDL_Texture *thistexture = cmd->data.draw.texture;
+            SDL_BlendMode thisblend = cmd->data.draw.blend;
+            const SDL_RenderCommandType thiscmdtype = cmd->command;
+            SDL_RenderCommand *finalcmd = cmd;
+            SDL_RenderCommand *nextcmd = cmd->next;
+            size_t count = cmd->data.draw.count;
+            int ret;
+            while (nextcmd) {
+                const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                if (nextcmdtype != thiscmdtype) {
+                    break; // can't go any further on this draw call, different render command up next.
+                } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                    break; // can't go any further on this draw call, different texture/blendmode copy up next.
+                } else {
+                    finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                    count += nextcmd->data.draw.count;
+                }
+                nextcmd = nextcmd->next;
+            }
+
+            if (thistexture) {
+                ret = SetCopyState(renderer, cmd, vertices);
+            } else {
+                ret = SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID, vertices);
+            }
+
+            if (ret) {
+                int op = GL_TRIANGLES; // SDL_RENDERCMD_GEOMETRY
+                if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                    op = GL_POINTS;
+                }
+                data->glDrawArrays(op, 0, (GLsizei)count);
+            }
+
+            cmd = finalcmd; // skip any copy commands we just combined in here.
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    return GL_CheckError("", renderer);
+}
+
+static void GLES2_DestroyRenderer(SDL_Renderer *renderer)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+
+    // Deallocate everything
+    if (data) {
+        GLES2_ActivateRenderer(renderer);
+
+        {
+            int i;
+            for (i = 0; i < GLES2_SHADER_COUNT; i++) {
+                GLuint id = data->shader_id_cache[i];
+                if (id) {
+                    data->glDeleteShader(id);
+                }
+            }
+        }
+        {
+            GLES2_ProgramCacheEntry *entry;
+            GLES2_ProgramCacheEntry *next;
+            entry = data->program_cache.head;
+            while (entry) {
+                data->glDeleteProgram(entry->id);
+                next = entry->next;
+                SDL_free(entry);
+                entry = next;
+            }
+        }
+
+        if (data->context) {
+            while (data->framebuffers) {
+                GLES2_FBOList *nextnode = data->framebuffers->next;
+                data->glDeleteFramebuffers(1, &data->framebuffers->FBO);
+                GL_CheckError("", renderer);
+                SDL_free(data->framebuffers);
+                data->framebuffers = nextnode;
+            }
+
+#if USE_VERTEX_BUFFER_OBJECTS
+            data->glDeleteBuffers(SDL_arraysize(data->vertex_buffers), data->vertex_buffers);
+            GL_CheckError("", renderer);
+#endif
+
+            SDL_GL_DestroyContext(data->context);
+        }
+
+        SDL_free(data);
+    }
+}
+
+static bool GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    GLES2_RenderData *renderdata = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *data;
+    GLenum format;
+    GLenum type;
+    GLenum scaleMode;
+
+    GLES2_ActivateRenderer(renderer);
+
+    renderdata->drawstate.texture = NULL; // we trash this state.
+
+    // Determine the corresponding GLES texture format params
+    switch (texture->format) {
+    case SDL_PIXELFORMAT_BGRA32:
+    case SDL_PIXELFORMAT_RGBA32:
+    case SDL_PIXELFORMAT_BGRX32:
+    case SDL_PIXELFORMAT_RGBX32:
+        format = GL_RGBA;
+        type = GL_UNSIGNED_BYTE;
+        break;
+#ifdef SDL_HAVE_YUV
+    case SDL_PIXELFORMAT_IYUV:
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        format = GL_LUMINANCE;
+        type = GL_UNSIGNED_BYTE;
+        break;
+#endif
+#ifdef GL_TEXTURE_EXTERNAL_OES
+    case SDL_PIXELFORMAT_EXTERNAL_OES:
+        format = GL_NONE;
+        type = GL_NONE;
+        break;
+#endif
+    default:
+        return SDL_SetError("Texture format not supported");
+    }
+
+    if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES &&
+        texture->access != SDL_TEXTUREACCESS_STATIC) {
+        return SDL_SetError("Unsupported texture access for SDL_PIXELFORMAT_EXTERNAL_OES");
+    }
+
+    // Allocate a texture struct
+    data = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData));
+    if (!data) {
+        return false;
+    }
+    data->texture = 0;
+#ifdef GL_TEXTURE_EXTERNAL_OES
+    data->texture_type = (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
+#else
+    data->texture_type = GL_TEXTURE_2D;
+#endif
+    data->pixel_format = format;
+    data->pixel_type = type;
+#ifdef SDL_HAVE_YUV
+    data->yuv = ((texture->format == SDL_PIXELFORMAT_IYUV) || (texture->format == SDL_PIXELFORMAT_YV12));
+    data->nv12 = ((texture->format == SDL_PIXELFORMAT_NV12) || (texture->format == SDL_PIXELFORMAT_NV21));
+    data->texture_u = 0;
+    data->texture_v = 0;
+#endif
+    scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? GL_NEAREST : GL_LINEAR;
+
+    // Allocate a blob for image renderdata
+    if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
+        size_t size;
+        data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
+        size = (size_t)texture->h * data->pitch;
+#ifdef SDL_HAVE_YUV
+        if (data->yuv) {
+            // Need to add size for the U and V planes
+            size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
+        } else if (data->nv12) {
+            // Need to add size for the U/V plane
+            size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
+        }
+#endif
+        data->pixel_data = SDL_calloc(1, size);
+        if (!data->pixel_data) {
+            SDL_free(data);
+            return false;
+        }
+    }
+
+    // Allocate the texture
+    GL_CheckError("", renderer);
+
+#ifdef SDL_HAVE_YUV
+    if (data->yuv) {
+        data->texture_v = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_V_NUMBER, 0);
+        if (data->texture_v) {
+            data->texture_v_external = true;
+        } else {
+            renderdata->glGenTextures(1, &data->texture_v);
+            if (!GL_CheckError("glGenTexures()", renderer)) {
+                return false;
+            }
+        }
+        renderdata->glActiveTexture(GL_TEXTURE2);
+        renderdata->glBindTexture(data->texture_type, data->texture_v);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
+        renderdata->glTexImage2D(data->texture_type, 0, format, (texture->w + 1) / 2, (texture->h + 1) / 2, 0, format, type, NULL);
+        SDL_SetNumberProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_V_NUMBER, data->texture_v);
+
+        data->texture_u = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_U_NUMBER, 0);
+        if (data->texture_u) {
+            data->texture_u_external = true;
+        } else {
+            renderdata->glGenTextures(1, &data->texture_u);
+            if (!GL_CheckError("glGenTexures()", renderer)) {
+                return false;
+            }
+        }
+        renderdata->glActiveTexture(GL_TEXTURE1);
+        renderdata->glBindTexture(data->texture_type, data->texture_u);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
+        renderdata->glTexImage2D(data->texture_type, 0, format, (texture->w + 1) / 2, (texture->h + 1) / 2, 0, format, type, NULL);
+        if (!GL_CheckError("glTexImage2D()", renderer)) {
+            return false;
+        }
+        SDL_SetNumberProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_U_NUMBER, data->texture_u);
+
+        if (!SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8)) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    } else if (data->nv12) {
+        data->texture_u = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_UV_NUMBER, 0);
+        if (data->texture_u) {
+            data->texture_u_external = true;
+        } else {
+            renderdata->glGenTextures(1, &data->texture_u);
+            if (!GL_CheckError("glGenTexures()", renderer)) {
+                return false;
+            }
+        }
+        renderdata->glActiveTexture(GL_TEXTURE1);
+        renderdata->glBindTexture(data->texture_type, data->texture_u);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
+        renderdata->glTexImage2D(data->texture_type, 0, GL_LUMINANCE_ALPHA, (texture->w + 1) / 2, (texture->h + 1) / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+        if (!GL_CheckError("glTexImage2D()", renderer)) {
+            return false;
+        }
+        SDL_SetNumberProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_UV_NUMBER, data->texture_u);
+
+        if (!SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, 8)) {
+            return SDL_SetError("Unsupported YUV colorspace");
+        }
+    }
+#endif
+
+    data->texture = (GLuint)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_OPENGLES2_TEXTURE_NUMBER, 0);
+    if (data->texture) {
+        data->texture_external = true;
+    } else {
+        renderdata->glGenTextures(1, &data->texture);
+        if (!GL_CheckError("glGenTexures()", renderer)) {
+            return false;
+        }
+    }
+    texture->internal = data;
+    renderdata->glActiveTexture(GL_TEXTURE0);
+    renderdata->glBindTexture(data->texture_type, data->texture);
+    renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
+    renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
+    if (texture->format != SDL_PIXELFORMAT_EXTERNAL_OES) {
+        renderdata->glTexImage2D(data->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);
+        if (!GL_CheckError("glTexImage2D()", renderer)) {
+            return false;
+        }
+    }
+    SDL_SetNumberProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_NUMBER, data->texture);
+    SDL_SetNumberProperty(SDL_GetTextureProperties(texture), SDL_PROP_TEXTURE_OPENGLES2_TEXTURE_TARGET_NUMBER, data->texture_type);
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        data->fbo = GLES2_GetFBO((GLES2_RenderData *)renderer->internal, texture->w, texture->h);
+    } else {
+        data->fbo = NULL;
+    }
+
+    return GL_CheckError("", renderer);
+}
+
+static bool GLES2_TexSubImage2D(GLES2_RenderData *data, GLenum target, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, GLint pitch, GLint bpp)
+{
+    Uint8 *blob = NULL;
+    Uint8 *src;
+    size_t src_pitch;
+    int y;
+
+    if ((width == 0) || (height == 0) || (bpp == 0)) {
+        return true; // nothing to do
+    }
+
+    // Reformat the texture data into a tightly packed array
+    src_pitch = (size_t)width * bpp;
+    src = (Uint8 *)pixels;
+    if ((size_t)pitch != src_pitch) {
+        blob = (Uint8 *)SDL_malloc(src_pitch * height);
+        if (!blob) {
+            return false;
+        }
+        src = blob;
+        for (y = 0; y < height; ++y) {
+            SDL_memcpy(src, pixels, src_pitch);
+            src += src_pitch;
+            pixels = (Uint8 *)pixels + pitch;
+        }
+        src = blob;
+    }
+
+    data->glTexSubImage2D(target, 0, xoffset, yoffset, width, height, format, type, src);
+    if (blob) {
+        SDL_free(blob);
+    }
+    return true;
+}
+
+static bool GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
+                               const void *pixels, int pitch)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+
+    GLES2_ActivateRenderer(renderer);
+
+    // Bail out if we're supposed to update an empty rectangle
+    if (rect->w <= 0 || rect->h <= 0) {
+        return true;
+    }
+
+    data->drawstate.texture = NULL; // we trash this state.
+
+    // Create a texture subimage with the supplied data
+    data->glBindTexture(tdata->texture_type, tdata->texture);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+                        rect->x,
+                        rect->y,
+                        rect->w,
+                        rect->h,
+                        tdata->pixel_format,
+                        tdata->pixel_type,
+                        pixels, pitch, SDL_BYTESPERPIXEL(texture->format));
+
+#ifdef SDL_HAVE_YUV
+    if (tdata->yuv) {
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+        if (texture->format == SDL_PIXELFORMAT_YV12) {
+            data->glBindTexture(tdata->texture_type, tdata->texture_v);
+        } else {
+            data->glBindTexture(tdata->texture_type, tdata->texture_u);
+        }
+        GLES2_TexSubImage2D(data, tdata->texture_type,
+                            rect->x / 2,
+                            rect->y / 2,
+                            (rect->w + 1) / 2,
+                            (rect->h + 1) / 2,
+                            tdata->pixel_format,
+                            tdata->pixel_type,
+                            pixels, (pitch + 1) / 2, 1);
+
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + ((rect->h + 1) / 2) * ((pitch + 1) / 2));
+        if (texture->format == SDL_PIXELFORMAT_YV12) {
+            data->glBindTexture(tdata->texture_type, tdata->texture_u);
+        } else {
+            data->glBindTexture(tdata->texture_type, tdata->texture_v);
+        }
+        GLES2_TexSubImage2D(data, tdata->texture_type,
+                            rect->x / 2,
+                            rect->y / 2,
+                            (rect->w + 1) / 2,
+                            (rect->h + 1) / 2,
+                            tdata->pixel_format,
+                            tdata->pixel_type,
+                            pixels, (pitch + 1) / 2, 1);
+    } else if (tdata->nv12) {
+        // Skip to the correct offset into the next texture
+        pixels = (const void *)((const Uint8 *)pixels + rect->h * pitch);
+        data->glBindTexture(tdata->texture_type, tdata->texture_u);
+        GLES2_TexSubImage2D(data, tdata->texture_type,
+                            rect->x / 2,
+                            rect->y / 2,
+                            (rect->w + 1) / 2,
+                            (rect->h + 1) / 2,
+                            GL_LUMINANCE_ALPHA,
+                            GL_UNSIGNED_BYTE,
+                            pixels, 2 * ((pitch + 1) / 2), 2);
+    }
+#endif
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+
+#ifdef SDL_HAVE_YUV
+static bool GLES2_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+
+    GLES2_ActivateRenderer(renderer);
+
+    // Bail out if we're supposed to update an empty rectangle
+    if (rect->w <= 0 || rect->h <= 0) {
+        return true;
+    }
+
+    data->drawstate.texture = NULL; // we trash this state.
+
+    data->glBindTexture(tdata->texture_type, tdata->texture_v);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+                        rect->x / 2,
+                        rect->y / 2,
+                        (rect->w + 1) / 2,
+                        (rect->h + 1) / 2,
+                        tdata->pixel_format,
+                        tdata->pixel_type,
+                        Vplane, Vpitch, 1);
+
+    data->glBindTexture(tdata->texture_type, tdata->texture_u);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+                        rect->x / 2,
+                        rect->y / 2,
+                        (rect->w + 1) / 2,
+                        (rect->h + 1) / 2,
+                        tdata->pixel_format,
+                        tdata->pixel_type,
+                        Uplane, Upitch, 1);
+
+    data->glBindTexture(tdata->texture_type, tdata->texture);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+                        rect->x,
+                        rect->y,
+                        rect->w,
+                        rect->h,
+                        tdata->pixel_format,
+                        tdata->pixel_type,
+                        Yplane, Ypitch, 1);
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+
+static bool GLES2_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                 const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+
+    GLES2_ActivateRenderer(renderer);
+
+    // Bail out if we're supposed to update an empty rectangle
+    if (rect->w <= 0 || rect->h <= 0) {
+        return true;
+    }
+
+    data->drawstate.texture = NULL; // we trash this state.
+
+    data->glBindTexture(tdata->texture_type, tdata->texture_u);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+                        rect->x / 2,
+                        rect->y / 2,
+                        (rect->w + 1) / 2,
+                        (rect->h + 1) / 2,
+                        GL_LUMINANCE_ALPHA,
+                        GL_UNSIGNED_BYTE,
+                        UVplane, UVpitch, 2);
+
+    data->glBindTexture(tdata->texture_type, tdata->texture);
+    GLES2_TexSubImage2D(data, tdata->texture_type,
+                        rect->x,
+                        rect->y,
+                        rect->w,
+                        rect->h,
+                        tdata->pixel_format,
+                        tdata->pixel_type,
+                        Yplane, Ypitch, 1);
+
+    return GL_CheckError("glTexSubImage2D()", renderer);
+}
+#endif
+
+static bool GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
+                             void **pixels, int *pitch)
+{
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+
+    // Retrieve the buffer/pitch for the specified region
+    *pixels = (Uint8 *)tdata->pixel_data +
+              (tdata->pitch * rect->y) +
+              (rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = tdata->pitch;
+
+    return true;
+}
+
+static void GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+    SDL_Rect rect;
+
+    // We do whole texture updates, at least for now
+    rect.x = 0;
+    rect.y = 0;
+    rect.w = texture->w;
+    rect.h = texture->h;
+    GLES2_UpdateTexture(renderer, texture, &rect, tdata->pixel_data, tdata->pitch);
+}
+
+static void GLES2_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    GLES2_RenderData *renderdata = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *data = (GLES2_TextureData *)texture->internal;
+    GLenum glScaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? GL_NEAREST : GL_LINEAR;
+
+#ifdef SDL_HAVE_YUV
+    if (data->yuv) {
+        renderdata->glActiveTexture(GL_TEXTURE2);
+        renderdata->glBindTexture(data->texture_type, data->texture_v);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, glScaleMode);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, glScaleMode);
+
+        renderdata->glActiveTexture(GL_TEXTURE1);
+        renderdata->glBindTexture(data->texture_type, data->texture_u);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, glScaleMode);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, glScaleMode);
+    } else if (data->nv12) {
+        renderdata->glActiveTexture(GL_TEXTURE1);
+        renderdata->glBindTexture(data->texture_type, data->texture_u);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, glScaleMode);
+        renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, glScaleMode);
+    }
+#endif
+
+    renderdata->glActiveTexture(GL_TEXTURE0);
+    renderdata->glBindTexture(data->texture_type, data->texture);
+    renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, glScaleMode);
+    renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, glScaleMode);
+}
+
+static bool GLES2_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *texturedata = NULL;
+    GLenum status;
+
+    data->drawstate.viewport_dirty = true;
+
+    if (!texture) {
+        data->glBindFramebuffer(GL_FRAMEBUFFER, data->window_framebuffer);
+    } else {
+        texturedata = (GLES2_TextureData *)texture->internal;
+        data->glBindFramebuffer(GL_FRAMEBUFFER, texturedata->fbo->FBO);
+        // TODO: check if texture pixel format allows this operation
+        data->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texturedata->texture_type, texturedata->texture, 0);
+        // Check FBO status
+        status = data->glCheckFramebufferStatus(GL_FRAMEBUFFER);
+        if (status != GL_FRAMEBUFFER_COMPLETE) {
+            return SDL_SetError("glFramebufferTexture2D() failed");
+        }
+    }
+    return true;
+}
+
+static void GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    GLES2_TextureData *tdata = (GLES2_TextureData *)texture->internal;
+
+    GLES2_ActivateRenderer(renderer);
+
+    if (data->drawstate.texture == texture) {
+        data->drawstate.texture = NULL;
+    }
+    if (data->drawstate.target == texture) {
+        data->drawstate.target = NULL;
+    }
+
+    // Destroy the texture
+    if (tdata) {
+        if (tdata->texture && !tdata->texture_external) {
+            data->glDeleteTextures(1, &tdata->texture);
+        }
+#ifdef SDL_HAVE_YUV
+        if (tdata->texture_v && !tdata->texture_v_external) {
+            data->glDeleteTextures(1, &tdata->texture_v);
+        }
+        if (tdata->texture_u && !tdata->texture_u_external) {
+            data->glDeleteTextures(1, &tdata->texture_u);
+        }
+#endif
+        SDL_free(tdata->pixel_data);
+        SDL_free(tdata);
+        texture->internal = NULL;
+    }
+}
+
+static SDL_Surface *GLES2_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    GLES2_RenderData *data = (GLES2_RenderData *)renderer->internal;
+    SDL_PixelFormat format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_RGBA32;
+    SDL_Surface *surface;
+
+    surface = SDL_CreateSurface(rect->w, rect->h, format);
+    if (!surface) {
+        return NULL;
+    }
+
+    int y = rect->y;
+    if (!renderer->target) {
+        int w, h;
+        SDL_GetRenderOutputSize(renderer, &w, &h);
+        y = (h - y) - rect->h;
+    }
+
+    data->glReadPixels(rect->x, y, rect->w, rect->h, GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels);
+    if (!GL_CheckError("glReadPixels()", renderer)) {
+        SDL_DestroySurface(surface);
+        return NULL;
+    }
+
+    // Flip the rows to be top-down if necessary
+    if (!renderer->target) {
+        SDL_FlipSurface(surface, SDL_FLIP_VERTICAL);
+    }
+    return surface;
+}
+
+static bool GLES2_RenderPresent(SDL_Renderer *renderer)
+{
+    // Tell the video driver to swap buffers
+    return SDL_GL_SwapWindow(renderer->window);
+}
+
+static bool GLES2_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    int interval = 0;
+
+    if (!SDL_GL_SetSwapInterval(vsync)) {
+        return false;
+    }
+
+    if (!SDL_GL_GetSwapInterval(&interval)) {
+        return false;
+    }
+
+    if (interval != vsync) {
+        return SDL_Unsupported();
+    }
+    return true;
+}
+
+/*************************************************************************************************
+ * Renderer instantiation                                                                        *
+ *************************************************************************************************/
+
+static bool GLES2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    GLES2_RenderData *data = NULL;
+    SDL_WindowFlags window_flags = 0; // -Wconditional-uninitialized
+    GLint window_framebuffer;
+    GLint value;
+    int profile_mask = 0, major = 0, minor = 0;
+    bool changed_window = false;
+
+    if (!SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask)) {
+        goto error;
+    }
+    if (!SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major)) {
+        goto error;
+    }
+    if (!SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor)) {
+        goto error;
+    }
+
+    SDL_SyncWindow(window);
+    window_flags = SDL_GetWindowFlags(window);
+
+    // OpenGL ES 3.0 is a superset of OpenGL ES 2.0
+    if (!(window_flags & SDL_WINDOW_OPENGL) ||
+        profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major < RENDERER_CONTEXT_MAJOR) {
+
+        changed_window = true;
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
+
+        if (!SDL_RecreateWindow(window, (window_flags & ~(SDL_WINDOW_VULKAN | SDL_WINDOW_METAL)) | SDL_WINDOW_OPENGL)) {
+            goto error;
+        }
+    }
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        SDL_SetError("Unsupported output colorspace");
+        goto error;
+    }
+
+    data = (GLES2_RenderData *)SDL_calloc(1, sizeof(GLES2_RenderData));
+    if (!data) {
+        goto error;
+    }
+    renderer->internal = data;
+    GLES2_InvalidateCachedState(renderer);
+    renderer->window = window;
+
+    renderer->name = GLES2_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRA32);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA32);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRX32);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBX32);
+
+    // Create an OpenGL ES 2.0 context
+    data->context = SDL_GL_CreateContext(window);
+    if (!data->context) {
+        goto error;
+    }
+    if (!SDL_GL_MakeCurrent(window, data->context)) {
+        goto error;
+    }
+
+    if (!GLES2_LoadFunctions(data)) {
+        goto error;
+    }
+
+    if (!GLES2_CacheShaders(data)) {
+        goto error;
+    }
+
+    // Check for debug output support
+    if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) &&
+        (value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
+        data->debug_enabled = true;
+    }
+
+    value = 0;
+    data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, value);
+
+#if USE_VERTEX_BUFFER_OBJECTS
+    // we keep a few of these and cycle through them, so data can live for a few frames.
+    data->glGenBuffers(SDL_arraysize(data->vertex_buffers), data->vertex_buffers);
+#endif
+
+    data->framebuffers = NULL;
+    data->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &window_framebuffer);
+    data->window_framebuffer = (GLuint)window_framebuffer;
+
+    // Populate the function pointers for the module
+    renderer->WindowEvent = GLES2_WindowEvent;
+    renderer->SupportsBlendMode = GLES2_SupportsBlendMode;
+    renderer->CreateTexture = GLES2_CreateTexture;
+    renderer->UpdateTexture = GLES2_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = GLES2_UpdateTextureYUV;
+    renderer->UpdateTextureNV = GLES2_UpdateTextureNV;
+#endif
+    renderer->LockTexture = GLES2_LockTexture;
+    renderer->UnlockTexture = GLES2_UnlockTexture;
+    renderer->SetTextureScaleMode = GLES2_SetTextureScaleMode;
+    renderer->SetRenderTarget = GLES2_SetRenderTarget;
+    renderer->QueueSetViewport = GLES2_QueueNoOp;
+    renderer->QueueSetDrawColor = GLES2_QueueNoOp;
+    renderer->QueueDrawPoints = GLES2_QueueDrawPoints;
+    renderer->QueueDrawLines = GLES2_QueueDrawLines;
+    renderer->QueueGeometry = GLES2_QueueGeometry;
+    renderer->InvalidateCachedState = GLES2_InvalidateCachedState;
+    renderer->RunCommandQueue = GLES2_RunCommandQueue;
+    renderer->RenderReadPixels = GLES2_RenderReadPixels;
+    renderer->RenderPresent = GLES2_RenderPresent;
+    renderer->DestroyTexture = GLES2_DestroyTexture;
+    renderer->DestroyRenderer = GLES2_DestroyRenderer;
+    renderer->SetVSync = GLES2_SetVSync;
+#ifdef SDL_HAVE_YUV
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+#endif
+#ifdef GL_TEXTURE_EXTERNAL_OES
+    if (GLES2_CacheShader(data, GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES, GL_FRAGMENT_SHADER)) {
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_EXTERNAL_OES);
+    }
+#endif
+
+    if (SDL_GL_ExtensionSupported("GL_EXT_blend_minmax")) {
+        data->GL_EXT_blend_minmax_supported = true;
+    }
+
+    // Set up parameters for rendering
+    data->glDisable(GL_DEPTH_TEST);
+    data->glDisable(GL_CULL_FACE);
+    data->glActiveTexture(GL_TEXTURE0);
+    data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    data->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
+    data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_COLOR);
+    data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
+
+    data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+
+    data->drawstate.clear_color.r = 1.0f;
+    data->drawstate.clear_color.g = 1.0f;
+    data->drawstate.clear_color.b = 1.0f;
+    data->drawstate.clear_color.a = 1.0f;
+    data->drawstate.projection[3][0] = -1.0f;
+    data->drawstate.projection[3][3] = 1.0f;
+
+    GL_CheckError("", renderer);
+
+    return true;
+
+error:
+    if (changed_window) {
+        // Uh oh, better try to put it back...
+        char *error = SDL_strdup(SDL_GetError());
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
+        SDL_RecreateWindow(window, window_flags);
+        SDL_SetError("%s", error);
+        SDL_free(error);
+    }
+    return false;
+}
+
+SDL_RenderDriver GLES2_RenderDriver = {
+    GLES2_CreateRenderer, "opengles2"
+};
+
+#endif // SDL_VIDEO_RENDER_OGL_ES2
diff --git a/SDL-3.2.8/src/render/opengles2/SDL_shaders_gles2.c b/SDL-3.2.8/src/render/opengles2/SDL_shaders_gles2.c
new file mode 100644
index 0000000..1387968
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengles2/SDL_shaders_gles2.c
@@ -0,0 +1,387 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_OGL_ES2
+
+#include <SDL3/SDL_opengles2.h>
+#include "SDL_shaders_gles2.h"
+
+/* *INDENT-OFF* */ // clang-format off
+
+/*************************************************************************************************
+ * Vertex/fragment shader source                                                                 *
+ *************************************************************************************************/
+
+static const char GLES2_Fragment_Include_Best_Texture_Precision[] = \
+"#ifdef GL_FRAGMENT_PRECISION_HIGH\n"                           \
+"#define SDL_TEXCOORD_PRECISION highp\n"                        \
+"#else\n"                                                       \
+"#define SDL_TEXCOORD_PRECISION mediump\n"                      \
+"#endif\n"                                                      \
+"\n"                                                            \
+"precision mediump float;\n"                                    \
+"\n"                                                            \
+;
+
+static const char GLES2_Fragment_Include_Medium_Texture_Precision[] = \
+"#define SDL_TEXCOORD_PRECISION mediump\n"                      \
+"precision mediump float;\n"                                    \
+"\n"                                                            \
+;
+
+static const char GLES2_Fragment_Include_High_Texture_Precision[] = \
+"#define SDL_TEXCOORD_PRECISION highp\n"                        \
+"precision mediump float;\n"                                    \
+"\n"                                                            \
+;
+
+static const char GLES2_Fragment_Include_Undef_Precision[] =    \
+"#define mediump\n"                                             \
+"#define highp\n"                                               \
+"#define lowp\n"                                                \
+"#define SDL_TEXCOORD_PRECISION\n"                              \
+"\n"                                                            \
+;
+
+static const char GLES2_Vertex_Default[] =                      \
+"uniform mat4 u_projection;\n"                                  \
+"attribute vec2 a_position;\n"                                  \
+"attribute vec4 a_color;\n"                                     \
+"attribute vec2 a_texCoord;\n"                                  \
+"varying vec2 v_texCoord;\n"                                    \
+"varying vec4 v_color;\n"                                       \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    v_texCoord = a_texCoord;\n"                                \
+"    gl_Position = u_projection * vec4(a_position, 0.0, 1.0);\n" \
+"    gl_PointSize = 1.0;\n"                                     \
+"    v_color = a_color;\n"                                      \
+"}\n"                                                           \
+;
+
+static const char GLES2_Fragment_Solid[] =                      \
+"varying mediump vec4 v_color;\n"                               \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    gl_FragColor = v_color;\n"                                 \
+"}\n"                                                           \
+;
+
+static const char GLES2_Fragment_TextureABGR[] =                \
+"uniform sampler2D u_texture;\n"                                \
+"varying mediump vec4 v_color;\n"                               \
+"varying SDL_TEXCOORD_PRECISION vec2 v_texCoord;\n"             \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    gl_FragColor = texture2D(u_texture, v_texCoord);\n"        \
+"    gl_FragColor *= v_color;\n"                                \
+"}\n"                                                           \
+;
+
+// ARGB to ABGR conversion
+static const char GLES2_Fragment_TextureARGB[] =                \
+"uniform sampler2D u_texture;\n"                                \
+"varying mediump vec4 v_color;\n"                               \
+"varying SDL_TEXCOORD_PRECISION vec2 v_texCoord;\n"             \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec4 abgr = texture2D(u_texture, v_texCoord);\n"   \
+"    gl_FragColor = abgr;\n"                                    \
+"    gl_FragColor.r = abgr.b;\n"                                \
+"    gl_FragColor.b = abgr.r;\n"                                \
+"    gl_FragColor *= v_color;\n"                                \
+"}\n"                                                           \
+;
+
+// RGB to ABGR conversion
+static const char GLES2_Fragment_TextureRGB[] =                 \
+"uniform sampler2D u_texture;\n"                                \
+"varying mediump vec4 v_color;\n"                               \
+"varying SDL_TEXCOORD_PRECISION vec2 v_texCoord;\n"             \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec4 abgr = texture2D(u_texture, v_texCoord);\n"   \
+"    gl_FragColor = abgr;\n"                                    \
+"    gl_FragColor.r = abgr.b;\n"                                \
+"    gl_FragColor.b = abgr.r;\n"                                \
+"    gl_FragColor.a = 1.0;\n"                                   \
+"    gl_FragColor *= v_color;\n"                                \
+"}\n"                                                           \
+;
+
+// BGR to ABGR conversion
+static const char GLES2_Fragment_TextureBGR[] =                 \
+"uniform sampler2D u_texture;\n"                                \
+"varying mediump vec4 v_color;\n"                               \
+"varying SDL_TEXCOORD_PRECISION vec2 v_texCoord;\n"             \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec4 abgr = texture2D(u_texture, v_texCoord);\n"   \
+"    gl_FragColor = abgr;\n"                                    \
+"    gl_FragColor.a = 1.0;\n"                                   \
+"    gl_FragColor *= v_color;\n"                                \
+"}\n"                                                           \
+;
+
+#ifdef SDL_HAVE_YUV
+
+#define YUV_SHADER_PROLOGUE                                     \
+"uniform sampler2D u_texture;\n"                                \
+"uniform sampler2D u_texture_u;\n"                              \
+"uniform sampler2D u_texture_v;\n"                              \
+"uniform vec3 u_offset;\n"                                        \
+"uniform mat3 u_matrix;\n"                                        \
+"varying mediump vec4 v_color;\n"                               \
+"varying SDL_TEXCOORD_PRECISION vec2 v_texCoord;\n"             \
+"\n"                                                            \
+
+#define YUV_SHADER_BODY                                         \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec3 yuv;\n"                                       \
+"    lowp vec3 rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the YUV values \n"                                  \
+"    yuv.x = texture2D(u_texture,   v_texCoord).r;\n"           \
+"    yuv.y = texture2D(u_texture_u, v_texCoord).r;\n"           \
+"    yuv.z = texture2D(u_texture_v, v_texCoord).r;\n"           \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += u_offset;\n"                                        \
+"    rgb = yuv * u_matrix;\n"                                   \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1);\n"                            \
+"    gl_FragColor *= v_color;\n"                                \
+"}"                                                             \
+
+#define NV12_RA_SHADER_BODY                                     \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec3 yuv;\n"                                       \
+"    lowp vec3 rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the YUV values \n"                                  \
+"    yuv.x = texture2D(u_texture,   v_texCoord).r;\n"           \
+"    yuv.yz = texture2D(u_texture_u, v_texCoord).ra;\n"         \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += u_offset;\n"                                        \
+"    rgb = yuv * u_matrix;\n"                                   \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1);\n"                            \
+"    gl_FragColor *= v_color;\n"                                \
+"}"                                                             \
+
+#define NV12_RG_SHADER_BODY                                     \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec3 yuv;\n"                                       \
+"    lowp vec3 rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the YUV values \n"                                  \
+"    yuv.x = texture2D(u_texture,   v_texCoord).r;\n"           \
+"    yuv.yz = texture2D(u_texture_u, v_texCoord).rg;\n"         \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += u_offset;\n"                                        \
+"    rgb = yuv * u_matrix;\n"                                   \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1);\n"                            \
+"    gl_FragColor *= v_color;\n"                                \
+"}"                                                             \
+
+#define NV21_RA_SHADER_BODY                                     \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec3 yuv;\n"                                       \
+"    lowp vec3 rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the YUV values \n"                                  \
+"    yuv.x = texture2D(u_texture,   v_texCoord).r;\n"           \
+"    yuv.yz = texture2D(u_texture_u, v_texCoord).ar;\n"         \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += u_offset;\n"                                        \
+"    rgb = yuv * u_matrix;\n"                                   \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1);\n"                            \
+"    gl_FragColor *= v_color;\n"                                \
+"}"                                                             \
+
+#define NV21_RG_SHADER_BODY                                     \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    mediump vec3 yuv;\n"                                       \
+"    lowp vec3 rgb;\n"                                          \
+"\n"                                                            \
+"    // Get the YUV values \n"                                  \
+"    yuv.x = texture2D(u_texture,   v_texCoord).r;\n"           \
+"    yuv.yz = texture2D(u_texture_u, v_texCoord).gr;\n"         \
+"\n"                                                            \
+"    // Do the color transform \n"                              \
+"    yuv += u_offset;\n"                                        \
+"    rgb = yuv * u_matrix;\n"                                   \
+"\n"                                                            \
+"    // That was easy. :) \n"                                   \
+"    gl_FragColor = vec4(rgb, 1);\n"                            \
+"    gl_FragColor *= v_color;\n"                                \
+"}"                                                             \
+
+// YUV to ABGR conversion
+static const char GLES2_Fragment_TextureYUV[] = \
+        YUV_SHADER_PROLOGUE \
+        YUV_SHADER_BODY \
+;
+
+// NV12 to ABGR conversion
+static const char GLES2_Fragment_TextureNV12_RA[] = \
+        YUV_SHADER_PROLOGUE \
+        NV12_RA_SHADER_BODY \
+;
+static const char GLES2_Fragment_TextureNV12_RG[] = \
+        YUV_SHADER_PROLOGUE \
+        NV12_RG_SHADER_BODY \
+;
+
+// NV21 to ABGR conversion
+static const char GLES2_Fragment_TextureNV21_RA[] = \
+        YUV_SHADER_PROLOGUE \
+        NV21_RA_SHADER_BODY \
+;
+static const char GLES2_Fragment_TextureNV21_RG[] = \
+        YUV_SHADER_PROLOGUE \
+        NV21_RG_SHADER_BODY \
+;
+#endif
+
+// Custom Android video format texture
+static const char GLES2_Fragment_TextureExternalOES_Prologue[] = \
+"#extension GL_OES_EGL_image_external : require\n"              \
+"\n"                                                            \
+;
+static const char GLES2_Fragment_TextureExternalOES[] =         \
+"uniform samplerExternalOES u_texture;\n"                       \
+"varying mediump vec4 v_color;\n"                               \
+"varying SDL_TEXCOORD_PRECISION vec2 v_texCoord;\n"             \
+"\n"                                                            \
+"void main()\n"                                                 \
+"{\n"                                                           \
+"    gl_FragColor = texture2D(u_texture, v_texCoord);\n"        \
+"    gl_FragColor *= v_color;\n"                                \
+"}\n"                                                           \
+;
+
+/* *INDENT-ON* */ // clang-format on
+
+/*************************************************************************************************
+ * Shader selector                                                                               *
+ *************************************************************************************************/
+
+const char *GLES2_GetShaderPrologue(GLES2_ShaderType type)
+{
+    switch (type) {
+    case GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES:
+        return GLES2_Fragment_TextureExternalOES_Prologue;
+    default:
+        return "";
+    }
+}
+
+const char *GLES2_GetShaderInclude(GLES2_ShaderIncludeType type)
+{
+    switch (type) {
+    case GLES2_SHADER_FRAGMENT_INCLUDE_UNDEF_PRECISION:
+        return GLES2_Fragment_Include_Undef_Precision;
+    case GLES2_SHADER_FRAGMENT_INCLUDE_BEST_TEXCOORD_PRECISION:
+        return GLES2_Fragment_Include_Best_Texture_Precision;
+    case GLES2_SHADER_FRAGMENT_INCLUDE_MEDIUM_TEXCOORD_PRECISION:
+        return GLES2_Fragment_Include_Medium_Texture_Precision;
+    case GLES2_SHADER_FRAGMENT_INCLUDE_HIGH_TEXCOORD_PRECISION:
+        return GLES2_Fragment_Include_High_Texture_Precision;
+    default:
+        return "";
+    }
+}
+
+GLES2_ShaderIncludeType GLES2_GetTexCoordPrecisionEnumFromHint(void)
+{
+    const char *texcoord_hint = SDL_GetHint("SDL_RENDER_OPENGLES2_TEXCOORD_PRECISION");
+    GLES2_ShaderIncludeType value = GLES2_SHADER_FRAGMENT_INCLUDE_BEST_TEXCOORD_PRECISION;
+    if (texcoord_hint) {
+        if (SDL_strcmp(texcoord_hint, "undefined") == 0) {
+            return GLES2_SHADER_FRAGMENT_INCLUDE_UNDEF_PRECISION;
+        }
+        if (SDL_strcmp(texcoord_hint, "high") == 0) {
+            return GLES2_SHADER_FRAGMENT_INCLUDE_HIGH_TEXCOORD_PRECISION;
+        }
+        if (SDL_strcmp(texcoord_hint, "medium") == 0) {
+            return GLES2_SHADER_FRAGMENT_INCLUDE_MEDIUM_TEXCOORD_PRECISION;
+        }
+    }
+    return value;
+}
+
+const char *GLES2_GetShader(GLES2_ShaderType type)
+{
+    switch (type) {
+    case GLES2_SHADER_VERTEX_DEFAULT:
+        return GLES2_Vertex_Default;
+    case GLES2_SHADER_FRAGMENT_SOLID:
+        return GLES2_Fragment_Solid;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_ABGR:
+        return GLES2_Fragment_TextureABGR;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_ARGB:
+        return GLES2_Fragment_TextureARGB;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_RGB:
+        return GLES2_Fragment_TextureRGB;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_BGR:
+        return GLES2_Fragment_TextureBGR;
+#ifdef SDL_HAVE_YUV
+    case GLES2_SHADER_FRAGMENT_TEXTURE_YUV:
+        return GLES2_Fragment_TextureYUV;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA:
+        return GLES2_Fragment_TextureNV12_RA;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG:
+        return GLES2_Fragment_TextureNV12_RG;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RA:
+        return GLES2_Fragment_TextureNV21_RA;
+    case GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RG:
+        return GLES2_Fragment_TextureNV21_RG;
+#endif
+    case GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES:
+        return GLES2_Fragment_TextureExternalOES;
+    default:
+        return NULL;
+    }
+}
+
+#endif // SDL_VIDEO_RENDER_OGL_ES2
diff --git a/SDL-3.2.8/src/render/opengles2/SDL_shaders_gles2.h b/SDL-3.2.8/src/render/opengles2/SDL_shaders_gles2.h
new file mode 100644
index 0000000..e71f8ce
--- /dev/null
+++ b/SDL-3.2.8/src/render/opengles2/SDL_shaders_gles2.h
@@ -0,0 +1,65 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_shaders_gles2_h_
+#define SDL_shaders_gles2_h_
+
+#ifdef SDL_VIDEO_RENDER_OGL_ES2
+
+typedef enum
+{
+    GLES2_SHADER_FRAGMENT_INCLUDE_NONE = 0,
+    GLES2_SHADER_FRAGMENT_INCLUDE_BEST_TEXCOORD_PRECISION,
+    GLES2_SHADER_FRAGMENT_INCLUDE_MEDIUM_TEXCOORD_PRECISION,
+    GLES2_SHADER_FRAGMENT_INCLUDE_HIGH_TEXCOORD_PRECISION,
+    GLES2_SHADER_FRAGMENT_INCLUDE_UNDEF_PRECISION,
+    GLES2_SHADER_FRAGMENT_INCLUDE_COUNT
+} GLES2_ShaderIncludeType;
+
+typedef enum
+{
+    GLES2_SHADER_VERTEX_DEFAULT = 0,
+    GLES2_SHADER_FRAGMENT_SOLID,
+    GLES2_SHADER_FRAGMENT_TEXTURE_ABGR,
+    GLES2_SHADER_FRAGMENT_TEXTURE_ARGB,
+    GLES2_SHADER_FRAGMENT_TEXTURE_BGR,
+    GLES2_SHADER_FRAGMENT_TEXTURE_RGB,
+#ifdef SDL_HAVE_YUV
+    GLES2_SHADER_FRAGMENT_TEXTURE_YUV,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RA,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV12_RG,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RA,
+    GLES2_SHADER_FRAGMENT_TEXTURE_NV21_RG,
+#endif
+    // Shaders beyond this point are optional and not cached at render creation
+    GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES,
+    GLES2_SHADER_COUNT
+} GLES2_ShaderType;
+
+extern const char *GLES2_GetShaderPrologue(GLES2_ShaderType type);
+extern const char *GLES2_GetShaderInclude(GLES2_ShaderIncludeType type);
+extern const char *GLES2_GetShader(GLES2_ShaderType type);
+extern GLES2_ShaderIncludeType GLES2_GetTexCoordPrecisionEnumFromHint(void);
+
+#endif // SDL_VIDEO_RENDER_OGL_ES2
+
+#endif // SDL_shaders_gles2_h_
diff --git a/SDL-3.2.8/src/render/ps2/SDL_render_ps2.c b/SDL-3.2.8/src/render/ps2/SDL_render_ps2.c
new file mode 100644
index 0000000..ddcab9e
--- /dev/null
+++ b/SDL-3.2.8/src/render/ps2/SDL_render_ps2.c
@@ -0,0 +1,727 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_PS2
+
+#include "../SDL_sysrender.h"
+
+#include <kernel.h>
+#include <malloc.h>
+#include <gsKit.h>
+#include <dmaKit.h>
+#include <gsToolkit.h>
+
+#ifdef HAVE_GCC_DIAGNOSTIC_PRAGMA
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeclaration-after-statement"
+#endif
+
+#include <gsInline.h>
+
+#ifdef HAVE_GCC_DIAGNOSTIC_PRAGMA
+#pragma GCC diagnostic pop
+#endif
+
+// turn black GS Screen
+#define GS_BLACK GS_SETREG_RGBA(0x00, 0x00, 0x00, 0x80)
+// Size of Persistent drawbuffer (Single Buffered)
+#define RENDER_QUEUE_PER_POOLSIZE 1024 * 256 // 256K of persistent renderqueue
+/* Size of Oneshot drawbuffer (Double Buffered, so it uses this size * 2) */
+#define RENDER_QUEUE_OS_POOLSIZE 1024 * 1024 * 2 // 2048K of oneshot renderqueue
+
+typedef struct
+{
+    GSGLOBAL *gsGlobal;
+    uint64_t drawColor;
+    SDL_Rect *viewport;
+    int32_t vsync_callback_id;
+    int vsync; // 0 (Disabled), 1 (Enabled), -1 (Dynamic)
+} PS2_RenderData;
+
+static int vsync_sema_id = 0;
+
+// PRIVATE METHODS
+static int vsync_handler(void)
+{
+    iSignalSema(vsync_sema_id);
+
+    ExitHandler();
+    return 0;
+}
+
+// Copy of gsKit_sync_flip, but without the 'flip'
+static void gsKit_sync(GSGLOBAL *gsGlobal)
+{
+    if (!gsGlobal->FirstFrame) {
+        WaitSema(vsync_sema_id);
+    }
+    while (PollSema(vsync_sema_id) >= 0)
+        ;
+}
+
+// Copy of gsKit_sync_flip, but without the 'sync'
+static void gsKit_flip(GSGLOBAL *gsGlobal)
+{
+    if (!gsGlobal->FirstFrame) {
+        if (gsGlobal->DoubleBuffering == GS_SETTING_ON) {
+            GS_SET_DISPFB2(gsGlobal->ScreenBuffer[gsGlobal->ActiveBuffer & 1] / 8192,
+                           gsGlobal->Width / 64, gsGlobal->PSM, 0, 0);
+
+            gsGlobal->ActiveBuffer ^= 1;
+        }
+    }
+
+    gsKit_setactive(gsGlobal);
+}
+
+static int PixelFormatToPS2PSM(Uint32 format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_ABGR1555:
+        return GS_PSM_CT16;
+    default:
+        return GS_PSM_CT32;
+    }
+}
+
+static gs_rgbaq float_color_to_RGBAQ(const SDL_FColor *color, float color_scale)
+{
+    uint8_t colorR = (uint8_t)SDL_roundf(SDL_clamp(color->r * color_scale, 0.0f, 1.0f) * 255.0f);
+    uint8_t colorG = (uint8_t)SDL_roundf(SDL_clamp(color->g * color_scale, 0.0f, 1.0f) * 255.0f);
+    uint8_t colorB = (uint8_t)SDL_roundf(SDL_clamp(color->b * color_scale, 0.0f, 1.0f) * 255.0f);
+    uint8_t colorA = (uint8_t)SDL_roundf(SDL_clamp(color->a, 0.0f, 1.0f) * 255.0f);
+
+    return color_to_RGBAQ(colorR, colorG, colorB, colorA, 0x00);
+}
+
+static uint64_t float_GS_SETREG_RGBAQ(const SDL_FColor *color, float color_scale)
+{
+    uint8_t colorR = (uint8_t)SDL_roundf(SDL_clamp(color->r * color_scale, 0.0f, 1.0f) * 255.0f);
+    uint8_t colorG = (uint8_t)SDL_roundf(SDL_clamp(color->g * color_scale, 0.0f, 1.0f) * 255.0f);
+    uint8_t colorB = (uint8_t)SDL_roundf(SDL_clamp(color->b * color_scale, 0.0f, 1.0f) * 255.0f);
+    uint8_t colorA = (uint8_t)SDL_roundf(SDL_clamp(color->a, 0.0f, 1.0f) * 255.0f);
+
+    return GS_SETREG_RGBAQ(colorR, colorG, colorB, colorA, 0x00);
+}
+
+static void PS2_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+}
+
+static bool PS2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    GSTEXTURE *ps2_tex = (GSTEXTURE *)SDL_calloc(1, sizeof(GSTEXTURE));
+
+    if (!ps2_tex) {
+        return false;
+    }
+
+    ps2_tex->Width = texture->w;
+    ps2_tex->Height = texture->h;
+    ps2_tex->PSM = PixelFormatToPS2PSM(texture->format);
+    ps2_tex->Mem = SDL_aligned_alloc(128, gsKit_texture_size_ee(ps2_tex->Width, ps2_tex->Height, ps2_tex->PSM));
+
+    if (!ps2_tex->Mem) {
+        SDL_free(ps2_tex);
+        return false;
+    }
+
+    texture->internal = ps2_tex;
+
+    return true;
+}
+
+static bool PS2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                           const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    GSTEXTURE *ps2_texture = (GSTEXTURE *)texture->internal;
+
+    *pixels =
+        (void *)((Uint8 *)ps2_texture->Mem + rect->y * ps2_texture->Width * SDL_BYTESPERPIXEL(texture->format) +
+                 rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = ps2_texture->Width * SDL_BYTESPERPIXEL(texture->format);
+    return true;
+}
+
+static void PS2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GSTEXTURE *ps2_texture = (GSTEXTURE *)texture->internal;
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+
+    gsKit_TexManager_invalidate(data->gsGlobal, ps2_texture);
+}
+
+static bool PS2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    const Uint8 *src;
+    Uint8 *dst;
+    int row, length, dpitch;
+    src = pixels;
+
+    PS2_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+    length = rect->w * SDL_BYTESPERPIXEL(texture->format);
+    if (length == pitch && length == dpitch) {
+        SDL_memcpy(dst, src, length * rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += dpitch;
+        }
+    }
+
+    PS2_UnlockTexture(renderer, texture);
+
+    return true;
+}
+
+static void PS2_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    GSTEXTURE *ps2_texture = (GSTEXTURE *)texture->internal;
+    /*
+     set texture filtering according to scaleMode
+     supported hint values are nearest (0, default) or linear (1)
+     gskit scale mode is either GS_FILTER_NEAREST (good for tile-map)
+     or GS_FILTER_LINEAR (good for scaling)
+     */
+    uint32_t gsKitScaleMode = (scaleMode == SDL_SCALEMODE_NEAREST
+                                   ? GS_FILTER_NEAREST
+                                   : GS_FILTER_LINEAR);
+    ps2_texture->Filter = gsKitScaleMode;
+}
+
+static bool PS2_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    return true;
+}
+
+static bool PS2_QueueSetViewport(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    const SDL_Rect *viewport = &cmd->data.viewport.rect;
+    data->viewport = (SDL_Rect *)viewport;
+
+    data->gsGlobal->OffsetX = (int)((2048.0f + (float)viewport->x) * 16.0f);
+    data->gsGlobal->OffsetY = (int)((2048.0f + (float)viewport->y) * 16.0f);
+    gsKit_set_scissor(data->gsGlobal, GS_SETREG_SCISSOR(viewport->x, viewport->x + viewport->w, viewport->y, viewport->y + viewport->h));
+
+    return true;
+}
+
+static bool PS2_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool PS2_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    GSPRIMPOINT *vertices = (GSPRIMPOINT *)SDL_AllocateRenderVertices(renderer, count * sizeof(GSPRIMPOINT), 4, &cmd->data.draw.first);
+    gs_rgbaq rgbaq;
+    int i;
+
+    if (!vertices) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    rgbaq = float_color_to_RGBAQ(&cmd->data.draw.color, cmd->data.draw.color_scale);
+
+    for (i = 0; i < count; i++, vertices++, points++) {
+        vertices->xyz2 = vertex_to_XYZ2(data->gsGlobal, points->x, points->y, 0);
+        vertices->rgbaq = rgbaq;
+    }
+    return true;
+}
+
+static bool PS2_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                             const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                             int num_vertices, const void *indices, int num_indices, int size_indices,
+                             float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    const float color_scale = cmd->data.draw.color_scale;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        GSPRIMUVPOINT *vertices = (GSPRIMUVPOINT *) SDL_AllocateRenderVertices(renderer, count * sizeof(GSPRIMUVPOINT), 4, &cmd->data.draw.first);
+        GSTEXTURE *ps2_tex = (GSTEXTURE *) texture->internal;
+
+        if (!vertices) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            float *uv_;
+            SDL_FColor *col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = (SDL_FColor *)((char *)color + j * color_stride);
+            uv_ = (float *)((char *)uv + j * uv_stride);
+
+            vertices->xyz2 = vertex_to_XYZ2(data->gsGlobal, xy_[0] * scale_x, xy_[1] * scale_y, 0);
+            vertices->rgbaq = float_color_to_RGBAQ(col_, color_scale);
+            vertices->uv = vertex_to_UV(ps2_tex, uv_[0] * ps2_tex->Width, uv_[1] * ps2_tex->Height);
+
+            vertices++;
+        }
+
+    } else {
+        GSPRIMPOINT *vertices = (GSPRIMPOINT *)SDL_AllocateRenderVertices(renderer, count * sizeof(GSPRIMPOINT), 4, &cmd->data.draw.first);
+
+        if (!vertices) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor *col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = (SDL_FColor *)((char *)color + j * color_stride);
+
+            vertices->xyz2 = vertex_to_XYZ2(data->gsGlobal, xy_[0] * scale_x, xy_[1] * scale_y, 0);
+            vertices->rgbaq = float_color_to_RGBAQ(col_, color_scale);
+
+            vertices++;
+        }
+    }
+
+    return true;
+}
+
+static bool PS2_RenderSetViewPort(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool PS2_RenderSetClipRect(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    SDL_Rect *viewport = data->viewport;
+
+    const SDL_Rect *rect = &cmd->data.cliprect.rect;
+
+    if (cmd->data.cliprect.enabled) {
+        // We need to do it relative to saved viewport
+        viewport->x += rect->x;
+        viewport->y += rect->y;
+        viewport->w = SDL_min(viewport->w, rect->w);
+        viewport->h = SDL_min(viewport->h, rect->h);
+    }
+    gsKit_set_scissor(data->gsGlobal, GS_SETREG_SCISSOR(viewport->x, viewport->x + viewport->w, viewport->y, viewport->y + viewport->h));
+
+    return true;
+}
+
+static bool PS2_RenderSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+
+    data->drawColor = float_GS_SETREG_RGBAQ(&cmd->data.color.color, cmd->data.color.color_scale);
+    return true;
+}
+
+static bool PS2_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    int offsetX, offsetY;
+    SDL_Rect *viewport;
+
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+
+    // Clear the screen, so let's put default viewport
+    gsKit_set_scissor(data->gsGlobal, GS_SCISSOR_RESET);
+    // Put back original offset
+    offsetX = data->gsGlobal->OffsetX;
+    offsetY = data->gsGlobal->OffsetY;
+    data->gsGlobal->OffsetX = (int)(2048.0f * 16.0f);
+    data->gsGlobal->OffsetY = (int)(2048.0f * 16.0f);
+    gsKit_clear(data->gsGlobal, float_GS_SETREG_RGBAQ(&cmd->data.color.color, cmd->data.color.color_scale));
+
+    // Put back original offset
+    data->gsGlobal->OffsetX = offsetX;
+    data->gsGlobal->OffsetY = offsetY;
+
+    // // Put back view port
+    viewport = data->viewport;
+    gsKit_set_scissor(data->gsGlobal, GS_SETREG_SCISSOR(viewport->x, viewport->x + viewport->w, viewport->y, viewport->y + viewport->h));
+
+    return true;
+}
+
+static void PS2_SetBlendMode(PS2_RenderData *data, int blendMode)
+{
+#define A_COLOR_SOURCE 0
+#define A_COLOR_DEST   1
+#define A_COLOR_NULL   2
+#define A_ALPHA_SOURCE 0
+#define A_ALPHA_DEST   1
+#define A_ALPHA_FIX    2
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_NONE:
+    {
+        data->gsGlobal->PrimAlphaEnable = GS_SETTING_OFF;
+        break;
+    }
+    case SDL_BLENDMODE_BLEND:
+    {
+        gsKit_set_primalpha(data->gsGlobal, GS_SETREG_ALPHA(A_COLOR_SOURCE, A_COLOR_DEST, A_ALPHA_SOURCE, A_COLOR_DEST, 0), 0);
+        data->gsGlobal->PrimAlphaEnable = GS_SETTING_ON;
+        break;
+    }
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+    {
+        // FIXME: What are the settings for this?
+        gsKit_set_primalpha(data->gsGlobal, GS_SETREG_ALPHA(A_COLOR_SOURCE, A_COLOR_DEST, A_ALPHA_SOURCE, A_COLOR_DEST, 0), 0);
+        data->gsGlobal->PrimAlphaEnable = GS_SETTING_ON;
+        break;
+    }
+    case SDL_BLENDMODE_ADD:
+    {
+        gsKit_set_primalpha(data->gsGlobal, GS_SETREG_ALPHA(A_COLOR_SOURCE, A_COLOR_NULL, A_ALPHA_FIX, A_COLOR_DEST, 0x80), 0);
+        data->gsGlobal->PrimAlphaEnable = GS_SETTING_ON;
+        break;
+    }
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+    {
+        // FIXME: What are the settings for this?
+        gsKit_set_primalpha(data->gsGlobal, GS_SETREG_ALPHA(A_COLOR_SOURCE, A_COLOR_NULL, A_ALPHA_FIX, A_COLOR_DEST, 0x80), 0);
+        data->gsGlobal->PrimAlphaEnable = GS_SETTING_ON;
+        break;
+    }
+    case SDL_BLENDMODE_MUL:
+    case SDL_BLENDMODE_MOD:
+    {
+        // We don't fully support MOD and MUL, however this is the best we can do
+        gsKit_set_primalpha(data->gsGlobal, GS_SETREG_ALPHA(A_COLOR_DEST, A_COLOR_NULL, A_ALPHA_SOURCE, A_COLOR_SOURCE, 0x80), 0);
+        data->gsGlobal->PrimAlphaEnable = GS_SETTING_ON;
+        break;
+    }
+    }
+}
+
+static bool PS2_RenderGeometry(SDL_Renderer *renderer, void *vertices, SDL_RenderCommand *cmd)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    const size_t count = cmd->data.draw.count;
+
+    PS2_SetBlendMode(data, cmd->data.draw.blend);
+
+    if (cmd->data.draw.texture) {
+        const GSPRIMUVPOINT *verts = (GSPRIMUVPOINT *) (vertices + cmd->data.draw.first);
+        GSTEXTURE *ps2_tex = (GSTEXTURE *)cmd->data.draw.texture->internal;
+
+        gsKit_TexManager_bind(data->gsGlobal, ps2_tex);
+        gsKit_prim_list_triangle_goraud_texture_uv_3d(data->gsGlobal, ps2_tex, count, verts);
+    } else {
+        const GSPRIMPOINT *verts = (GSPRIMPOINT *)(vertices + cmd->data.draw.first);
+        gsKit_prim_list_triangle_gouraud_3d(data->gsGlobal, count, verts);
+    }
+
+    return true;
+}
+
+static bool PS2_RenderLines(SDL_Renderer *renderer, void *vertices, SDL_RenderCommand *cmd)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    const size_t count = cmd->data.draw.count;
+    const GSPRIMPOINT *verts = (GSPRIMPOINT *)(vertices + cmd->data.draw.first);
+
+    PS2_SetBlendMode(data, cmd->data.draw.blend);
+    gsKit_prim_list_line_goraud_3d(data->gsGlobal, count, verts);
+
+    // We're done!
+    return true;
+}
+
+static bool PS2_RenderPoints(SDL_Renderer *renderer, void *vertices, SDL_RenderCommand *cmd)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    const size_t count = cmd->data.draw.count;
+    const GSPRIMPOINT *verts = (GSPRIMPOINT *)(vertices + cmd->data.draw.first);
+
+    PS2_SetBlendMode(data, cmd->data.draw.blend);
+    gsKit_prim_list_points(data->gsGlobal, count, verts);
+
+    // We're done!
+    return true;
+}
+
+static void PS2_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    // currently this doesn't do anything. If this needs to do something (and someone is mixing their own rendering calls in!), update this.
+}
+
+static bool PS2_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            PS2_RenderSetViewPort(renderer, cmd);
+            // FIXME: We need to update the clip rect too, see https://github.com/libsdl-org/SDL/issues/9094
+            break;
+        }
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            PS2_RenderSetClipRect(renderer, cmd);
+            break;
+        }
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            PS2_RenderSetDrawColor(renderer, cmd);
+            break;
+        }
+        case SDL_RENDERCMD_CLEAR:
+        {
+            PS2_RenderClear(renderer, cmd);
+            break;
+        }
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            PS2_RenderPoints(renderer, vertices, cmd);
+            break;
+        }
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            PS2_RenderLines(renderer, vertices, cmd);
+            break;
+        }
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            PS2_RenderGeometry(renderer, vertices, cmd);
+            break;
+        }
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+        cmd = cmd->next;
+    }
+    return true;
+}
+
+static bool PS2_RenderPresent(SDL_Renderer *renderer)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+
+    if (data->gsGlobal->DoubleBuffering == GS_SETTING_OFF) {
+        if (data->vsync == -1) { // Dynamic
+            gsKit_sync(data->gsGlobal);
+        } else if (data->vsync == 1) {
+            gsKit_vsync_wait();
+        }
+        gsKit_queue_exec(data->gsGlobal);
+    } else {
+        gsKit_queue_exec(data->gsGlobal);
+        gsKit_finish();
+        if (data->vsync == -1) { // Dynamic
+            gsKit_sync(data->gsGlobal);
+        } else if (data->vsync == 1) {
+            gsKit_vsync_wait();
+        }
+        gsKit_flip(data->gsGlobal);
+    }
+    gsKit_TexManager_nextFrame(data->gsGlobal);
+    gsKit_clear(data->gsGlobal, GS_BLACK);
+    return true;
+}
+
+static void PS2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    GSTEXTURE *ps2_texture = (GSTEXTURE *)texture->internal;
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+
+    if (!data) {
+        return;
+    }
+
+    if (!ps2_texture) {
+        return;
+    }
+
+    // Free from vram
+    gsKit_TexManager_free(data->gsGlobal, ps2_texture);
+
+    SDL_aligned_free(ps2_texture->Mem);
+    SDL_free(ps2_texture);
+    texture->internal = NULL;
+}
+
+static void PS2_DestroyRenderer(SDL_Renderer *renderer)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+
+    if (data) {
+        gsKit_clear(data->gsGlobal, GS_BLACK);
+        gsKit_vram_clear(data->gsGlobal);
+        gsKit_deinit_global(data->gsGlobal);
+        gsKit_remove_vsync_handler(data->vsync_callback_id);
+
+        SDL_free(data);
+    }
+
+    if (vsync_sema_id >= 0) {
+        DeleteSema(vsync_sema_id);
+    }
+}
+
+static bool PS2_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    PS2_RenderData *data = (PS2_RenderData *)renderer->internal;
+    switch (vsync) {
+    case -1:
+    case 0:
+    case 1:
+        // Supported
+        break;
+    default:
+        return SDL_Unsupported();
+    }
+    data->vsync = vsync;
+    return true;
+}
+
+static bool PS2_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    PS2_RenderData *data;
+    GSGLOBAL *gsGlobal;
+    ee_sema_t sema;
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (PS2_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    // Specific gsKit init
+    sema.init_count = 0;
+    sema.max_count = 1;
+    sema.option = 0;
+    vsync_sema_id = CreateSema(&sema);
+
+    gsGlobal = gsKit_init_global_custom(RENDER_QUEUE_OS_POOLSIZE, RENDER_QUEUE_PER_POOLSIZE);
+
+    gsGlobal->Mode = GS_MODE_NTSC;
+    gsGlobal->Height = 448;
+
+    gsGlobal->PSM = GS_PSM_CT24;
+    gsGlobal->PSMZ = GS_PSMZ_16S;
+    gsGlobal->ZBuffering = GS_SETTING_OFF;
+    gsGlobal->DoubleBuffering = GS_SETTING_ON;
+    gsGlobal->PrimAlphaEnable = GS_SETTING_ON;
+    gsGlobal->Dithering = GS_SETTING_OFF;
+
+    gsKit_set_primalpha(gsGlobal, GS_SETREG_ALPHA(0, 1, 0, 1, 0), 0);
+
+    dmaKit_init(D_CTRL_RELE_OFF, D_CTRL_MFD_OFF, D_CTRL_STS_UNSPEC, D_CTRL_STD_OFF, D_CTRL_RCYC_8, 1 << DMA_CHANNEL_GIF);
+    dmaKit_chan_init(DMA_CHANNEL_GIF);
+
+    gsKit_set_clamp(gsGlobal, GS_CMODE_REPEAT);
+
+    gsKit_vram_clear(gsGlobal);
+
+    gsKit_init_screen(gsGlobal);
+
+    gsKit_TexManager_init(gsGlobal);
+
+    data->vsync_callback_id = gsKit_add_vsync_handler(vsync_handler);
+
+    gsKit_mode_switch(gsGlobal, GS_ONESHOT);
+
+    gsKit_clear(gsGlobal, GS_BLACK);
+
+    data->gsGlobal = gsGlobal;
+
+    renderer->WindowEvent = PS2_WindowEvent;
+    renderer->CreateTexture = PS2_CreateTexture;
+    renderer->UpdateTexture = PS2_UpdateTexture;
+    renderer->LockTexture = PS2_LockTexture;
+    renderer->UnlockTexture = PS2_UnlockTexture;
+    renderer->SetTextureScaleMode = PS2_SetTextureScaleMode;
+    renderer->SetRenderTarget = PS2_SetRenderTarget;
+    renderer->QueueSetViewport = PS2_QueueSetViewport;
+    renderer->QueueSetDrawColor = PS2_QueueNoOp;
+    renderer->QueueDrawPoints = PS2_QueueDrawPoints;
+    renderer->QueueDrawLines = PS2_QueueDrawPoints;
+    renderer->QueueGeometry = PS2_QueueGeometry;
+    renderer->InvalidateCachedState = PS2_InvalidateCachedState;
+    renderer->RunCommandQueue = PS2_RunCommandQueue;
+    renderer->RenderPresent = PS2_RenderPresent;
+    renderer->DestroyTexture = PS2_DestroyTexture;
+    renderer->DestroyRenderer = PS2_DestroyRenderer;
+    renderer->SetVSync = PS2_SetVSync;
+    renderer->internal = data;
+    PS2_InvalidateCachedState(renderer);
+    renderer->window = window;
+
+    renderer->name = PS2_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 1024);
+
+    return true;
+}
+
+SDL_RenderDriver PS2_RenderDriver = {
+    PS2_CreateRenderer, "PS2 gsKit"
+};
+
+#endif // SDL_VIDEO_RENDER_PS2
diff --git a/SDL-3.2.8/src/render/psp/SDL_render_psp.c b/SDL-3.2.8/src/render/psp/SDL_render_psp.c
new file mode 100644
index 0000000..3ce5036
--- /dev/null
+++ b/SDL-3.2.8/src/render/psp/SDL_render_psp.c
@@ -0,0 +1,1400 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_PSP
+
+#include "../SDL_sysrender.h"
+
+#include "SDL_render_psp_c.h"
+
+#include <pspkernel.h>
+#include <pspdisplay.h>
+#include <pspgu.h>
+#include <pspgum.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <pspge.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <vram.h>
+
+// PSP renderer implementation, based on the PGE
+
+static unsigned int __attribute__((aligned(16))) DisplayList[262144];
+
+#define COL5650(r, g, b, a) ((r >> 3) | ((g >> 2) << 5) | ((b >> 3) << 11))
+#define COL5551(r, g, b, a) ((r >> 3) | ((g >> 3) << 5) | ((b >> 3) << 10) | (a > 0 ? 0x7000 : 0))
+#define COL4444(r, g, b, a) ((r >> 4) | ((g >> 4) << 4) | ((b >> 4) << 8) | ((a >> 4) << 12))
+#define COL8888(r, g, b, a) ((r) | ((g) << 8) | ((b) << 16) | ((a) << 24))
+
+/**
+ * Holds psp specific texture data
+ *
+ * Part of a hot-list of textures that are used as render targets
+ * When short of vram we spill Least-Recently-Used render targets to system memory
+ */
+typedef struct PSP_TextureData
+{
+    void *data;                 /**< Image data. */
+    unsigned int size;          /**< Size of data in bytes. */
+    unsigned int width;         /**< Image width. */
+    unsigned int height;        /**< Image height. */
+    unsigned int textureWidth;  /**< Texture width (power of two). */
+    unsigned int textureHeight; /**< Texture height (power of two). */
+    unsigned int bits;          /**< Image bits per pixel. */
+    unsigned int format;        /**< Image format - one of ::pgePixelFormat. */
+    unsigned int pitch;
+    bool swizzled;                /**< Is image swizzled. */
+    struct PSP_TextureData *prevhotw; /**< More recently used render target */
+    struct PSP_TextureData *nexthotw; /**< Less recently used render target */
+} PSP_TextureData;
+
+typedef struct
+{
+    SDL_BlendMode mode;
+    unsigned int color;
+    int shadeModel;
+    SDL_Texture *texture;
+} PSP_BlendState;
+
+typedef struct
+{
+    unsigned int color;
+} PSP_DrawStateCache;
+
+typedef struct
+{
+    void *frontbuffer;         /**< main screen buffer */
+    void *backbuffer;          /**< buffer presented to display */
+    SDL_Texture *boundTarget;  /**< currently bound rendertarget */
+    bool initialized;      /**< is driver initialized */
+    bool displayListAvail; /**< is the display list already initialized for this frame */
+    unsigned int psm;          /**< format of the display buffers */
+    unsigned int bpp;          /**< bits per pixel of the main display */
+
+    bool vsync;                       /**< whether we do vsync */
+    PSP_BlendState blendState;            /**< current blend mode */
+    PSP_TextureData *most_recent_target;  /**< start of render target LRU double linked list */
+    PSP_TextureData *least_recent_target; /**< end of the LRU list */
+
+    bool vblank_not_reached; /**< whether vblank wasn't reached */
+} PSP_RenderData;
+
+typedef struct
+{
+    float x, y, z;
+} VertV;
+
+typedef struct
+{
+    float u, v;
+    float x, y, z;
+} VertTV;
+
+typedef struct
+{
+    SDL_Color col;
+    float x, y, z;
+} VertCV;
+
+typedef struct
+{
+    float u, v;
+    SDL_Color col;
+    float x, y, z;
+} VertTCV;
+
+#define radToDeg(x) ((x)*180.f / SDL_PI_F)
+#define degToRad(x) ((x)*SDL_PI_F / 180.f)
+
+static float MathAbs(float x)
+{
+    float result;
+
+    __asm__ volatile(
+        "mtv      %1, S000\n"
+        "vabs.s   S000, S000\n"
+        "mfv      %0, S000\n"
+        : "=r"(result)
+        : "r"(x));
+
+    return result;
+}
+
+static void MathSincos(float r, float *s, float *c)
+{
+    __asm__ volatile(
+        "mtv      %2, S002\n"
+        "vcst.s   S003, VFPU_2_PI\n"
+        "vmul.s   S002, S002, S003\n"
+        "vrot.p   C000, S002, [s, c]\n"
+        "mfv      %0, S000\n"
+        "mfv      %1, S001\n"
+        : "=r"(*s), "=r"(*c)
+        : "r"(r));
+}
+
+static void Swap(float *a, float *b)
+{
+    float n = *a;
+    *a = *b;
+    *b = n;
+}
+
+static inline int InVram(void *data)
+{
+    return data < (void *)0x04200000;
+}
+
+// Return next power of 2
+static int TextureNextPow2(unsigned int w)
+{
+    unsigned int n = 2;
+    if (w == 0) {
+        return 0;
+    }
+
+    while (w > n) {
+        n <<= 1;
+    }
+
+    return n;
+}
+
+static void psp_on_vblank(u32 sub, PSP_RenderData *data)
+{
+    if (data) {
+        data->vblank_not_reached = false;
+    }
+}
+
+static int PixelFormatToPSPFMT(SDL_PixelFormat format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_BGR565:
+        return GU_PSM_5650;
+    case SDL_PIXELFORMAT_ABGR1555:
+        return GU_PSM_5551;
+    case SDL_PIXELFORMAT_ABGR4444:
+        return GU_PSM_4444;
+    case SDL_PIXELFORMAT_ABGR8888:
+        return GU_PSM_8888;
+    default:
+        return GU_PSM_8888;
+    }
+}
+
+/// SECTION render target LRU management
+static void LRUTargetRelink(PSP_TextureData *psp_texture)
+{
+    if (psp_texture->prevhotw) {
+        psp_texture->prevhotw->nexthotw = psp_texture->nexthotw;
+    }
+    if (psp_texture->nexthotw) {
+        psp_texture->nexthotw->prevhotw = psp_texture->prevhotw;
+    }
+}
+
+static void LRUTargetPushFront(PSP_RenderData *data, PSP_TextureData *psp_texture)
+{
+    psp_texture->nexthotw = data->most_recent_target;
+    if (data->most_recent_target) {
+        data->most_recent_target->prevhotw = psp_texture;
+    }
+    data->most_recent_target = psp_texture;
+    if (!data->least_recent_target) {
+        data->least_recent_target = psp_texture;
+    }
+}
+
+static void LRUTargetRemove(PSP_RenderData *data, PSP_TextureData *psp_texture)
+{
+    LRUTargetRelink(psp_texture);
+    if (data->most_recent_target == psp_texture) {
+        data->most_recent_target = psp_texture->nexthotw;
+    }
+    if (data->least_recent_target == psp_texture) {
+        data->least_recent_target = psp_texture->prevhotw;
+    }
+    psp_texture->prevhotw = NULL;
+    psp_texture->nexthotw = NULL;
+}
+
+static void LRUTargetBringFront(PSP_RenderData *data, PSP_TextureData *psp_texture)
+{
+    if (data->most_recent_target == psp_texture) {
+        return; // nothing to do
+    }
+    LRUTargetRemove(data, psp_texture);
+    LRUTargetPushFront(data, psp_texture);
+}
+
+static void TextureStorageFree(void *storage)
+{
+    if (InVram(storage)) {
+        vfree(storage);
+    } else {
+        SDL_free(storage);
+    }
+}
+
+static bool TextureSwizzle(PSP_TextureData *psp_texture, void *dst)
+{
+    int bytewidth, height;
+    int rowblocks, rowblocksadd;
+    int i, j;
+    unsigned int blockaddress = 0;
+    unsigned int *src = NULL;
+    unsigned char *data = NULL;
+
+    if (psp_texture->swizzled) {
+        return true;
+    }
+
+    bytewidth = psp_texture->textureWidth * (psp_texture->bits >> 3);
+    height = psp_texture->size / bytewidth;
+
+    rowblocks = (bytewidth >> 4);
+    rowblocksadd = (rowblocks - 1) << 7;
+
+    src = (unsigned int *)psp_texture->data;
+
+    data = dst;
+    if (!data) {
+        data = SDL_malloc(psp_texture->size);
+    }
+
+    if (!data) {
+        return false;
+    }
+
+    for (j = 0; j < height; j++, blockaddress += 16) {
+        unsigned int *block;
+
+        block = (unsigned int *)&data[blockaddress];
+
+        for (i = 0; i < rowblocks; i++) {
+            *block++ = *src++;
+            *block++ = *src++;
+            *block++ = *src++;
+            *block++ = *src++;
+            block += 28;
+        }
+
+        if ((j & 0x7) == 0x7) {
+            blockaddress += rowblocksadd;
+        }
+    }
+
+    TextureStorageFree(psp_texture->data);
+    psp_texture->data = data;
+    psp_texture->swizzled = true;
+
+    sceKernelDcacheWritebackRange(psp_texture->data, psp_texture->size);
+    return true;
+}
+
+static bool TextureUnswizzle(PSP_TextureData *psp_texture, void *dst)
+{
+    int bytewidth, height;
+    int widthblocks, heightblocks;
+    int dstpitch, dstrow;
+    int blockx, blocky;
+    int j;
+    unsigned int *src = NULL;
+    unsigned char *data = NULL;
+    unsigned char *ydst = NULL;
+
+    if (!psp_texture->swizzled) {
+        return true;
+    }
+
+    bytewidth = psp_texture->textureWidth * (psp_texture->bits >> 3);
+    height = psp_texture->size / bytewidth;
+
+    widthblocks = bytewidth / 16;
+    heightblocks = height / 8;
+
+    dstpitch = (bytewidth - 16) / 4;
+    dstrow = bytewidth * 8;
+
+    src = (unsigned int *)psp_texture->data;
+
+    data = dst;
+
+    if (!data) {
+        data = SDL_malloc(psp_texture->size);
+    }
+
+    if (!data) {
+        return false;
+    }
+
+    ydst = (unsigned char *)data;
+
+    for (blocky = 0; blocky < heightblocks; ++blocky) {
+        unsigned char *xdst = ydst;
+
+        for (blockx = 0; blockx < widthblocks; ++blockx) {
+            unsigned int *block;
+
+            block = (unsigned int *)xdst;
+
+            for (j = 0; j < 8; ++j) {
+                *(block++) = *(src++);
+                *(block++) = *(src++);
+                *(block++) = *(src++);
+                *(block++) = *(src++);
+                block += dstpitch;
+            }
+
+            xdst += 16;
+        }
+
+        ydst += dstrow;
+    }
+
+    TextureStorageFree(psp_texture->data);
+
+    psp_texture->data = data;
+
+    psp_texture->swizzled = false;
+
+    sceKernelDcacheWritebackRange(psp_texture->data, psp_texture->size);
+    return true;
+}
+
+static bool TextureSpillToSram(PSP_RenderData *data, PSP_TextureData *psp_texture)
+{
+    // Assumes the texture is in VRAM
+    if (psp_texture->swizzled) {
+        // Texture was swizzled in vram, just copy to system memory
+        void *sdata = SDL_malloc(psp_texture->size);
+        if (!sdata) {
+            return false;
+        }
+
+        SDL_memcpy(sdata, psp_texture->data, psp_texture->size);
+        vfree(psp_texture->data);
+        psp_texture->data = sdata;
+        return true;
+    } else {
+        return TextureSwizzle(psp_texture, NULL); // Will realloc in sysram
+    }
+}
+
+static bool TexturePromoteToVram(PSP_RenderData *data, PSP_TextureData *psp_texture, bool target)
+{
+    // Assumes texture in sram and a large enough continuous block in vram
+    void *tdata = vramalloc(psp_texture->size);
+    if (psp_texture->swizzled && target) {
+        return TextureUnswizzle(psp_texture, tdata);
+    } else {
+        SDL_memcpy(tdata, psp_texture->data, psp_texture->size);
+        SDL_free(psp_texture->data);
+        psp_texture->data = tdata;
+        return true;
+    }
+}
+
+static bool TextureSpillLRU(PSP_RenderData *data, size_t wanted)
+{
+    PSP_TextureData *lru = data->least_recent_target;
+    if (lru) {
+        if (!TextureSpillToSram(data, lru)) {
+            return false;
+        }
+        LRUTargetRemove(data, lru);
+    } else {
+        // Asked to spill but there nothing to spill
+        return SDL_SetError("Could not spill more VRAM to system memory. VRAM : %dKB,(%dKB), wanted %dKB", vmemavail() / 1024, vlargestblock() / 1024, wanted / 1024);
+    }
+    return true;
+}
+
+static bool TextureSpillTargetsForSpace(PSP_RenderData *data, size_t size)
+{
+    while (vlargestblock() < size) {
+        if (!TextureSpillLRU(data, size)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool TextureBindAsTarget(PSP_RenderData *data, PSP_TextureData *psp_texture)
+{
+    unsigned int dstFormat;
+
+    if (!InVram(psp_texture->data)) {
+        // Bring back the texture in vram
+        if (!TextureSpillTargetsForSpace(data, psp_texture->size)) {
+            return false;
+        }
+        if (!TexturePromoteToVram(data, psp_texture, true)) {
+            return false;
+        }
+    }
+    LRUTargetBringFront(data, psp_texture);
+    sceGuDrawBufferList(psp_texture->format, vrelptr(psp_texture->data), psp_texture->textureWidth);
+
+    // Stencil alpha dst hack
+    dstFormat = psp_texture->format;
+    if (dstFormat == GU_PSM_5551) {
+        sceGuEnable(GU_STENCIL_TEST);
+        sceGuStencilOp(GU_REPLACE, GU_REPLACE, GU_REPLACE);
+        sceGuStencilFunc(GU_GEQUAL, 0xff, 0xff);
+        sceGuEnable(GU_ALPHA_TEST);
+        sceGuAlphaFunc(GU_GREATER, 0x00, 0xff);
+    } else {
+        sceGuDisable(GU_STENCIL_TEST);
+        sceGuDisable(GU_ALPHA_TEST);
+    }
+    return true;
+}
+
+static void PSP_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+}
+
+static bool PSP_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    PSP_RenderData *data = renderer->internal;
+    PSP_TextureData *psp_texture = (PSP_TextureData *)SDL_calloc(1, sizeof(*psp_texture));
+
+    if (!psp_texture) {
+        return false;
+    }
+
+    psp_texture->swizzled = false;
+    psp_texture->width = texture->w;
+    psp_texture->height = texture->h;
+    psp_texture->textureHeight = TextureNextPow2(texture->h);
+    psp_texture->textureWidth = TextureNextPow2(texture->w);
+    psp_texture->format = PixelFormatToPSPFMT(texture->format);
+
+    switch (psp_texture->format) {
+    case GU_PSM_5650:
+    case GU_PSM_5551:
+    case GU_PSM_4444:
+        psp_texture->bits = 16;
+        break;
+
+    case GU_PSM_8888:
+        psp_texture->bits = 32;
+        break;
+
+    default:
+        SDL_free(psp_texture);
+        return false;
+    }
+
+    psp_texture->pitch = psp_texture->textureWidth * SDL_BYTESPERPIXEL(texture->format);
+    psp_texture->size = psp_texture->textureHeight * psp_texture->pitch;
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        if (!TextureSpillTargetsForSpace(renderer->internal, psp_texture->size)) {
+            SDL_free(psp_texture);
+            return false;
+        }
+        psp_texture->data = vramalloc(psp_texture->size);
+        if (psp_texture->data) {
+            LRUTargetPushFront(data, psp_texture);
+        }
+    } else {
+        psp_texture->data = SDL_calloc(1, psp_texture->size);
+    }
+
+    if (!psp_texture->data) {
+        SDL_free(psp_texture);
+        return false;
+    }
+    texture->internal = psp_texture;
+
+    return true;
+}
+
+static bool TextureShouldSwizzle(PSP_TextureData *psp_texture, SDL_Texture *texture)
+{
+    return !((texture->access == SDL_TEXTUREACCESS_TARGET) && InVram(psp_texture->data)) && texture->access != SDL_TEXTUREACCESS_STREAMING && (texture->w >= 16 || texture->h >= 16);
+}
+
+static void TextureActivate(SDL_Texture *texture)
+{
+    PSP_TextureData *psp_texture = (PSP_TextureData *)texture->internal;
+    int scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? GU_NEAREST : GU_LINEAR;
+
+    // Swizzling is useless with small textures.
+    if (TextureShouldSwizzle(psp_texture, texture)) {
+        TextureSwizzle(psp_texture, NULL);
+    }
+
+    sceGuTexWrap(GU_REPEAT, GU_REPEAT);
+    sceGuTexMode(psp_texture->format, 0, 0, psp_texture->swizzled);
+    sceGuTexFilter(scaleMode, scaleMode); // GU_NEAREST good for tile-map
+    // GU_LINEAR good for scaling
+    sceGuTexImage(0, psp_texture->textureWidth, psp_texture->textureHeight, psp_texture->textureWidth, psp_texture->data);
+}
+
+static bool PSP_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                           const SDL_Rect *rect, void **pixels, int *pitch);
+
+static bool PSP_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    /*  PSP_TextureData *psp_texture = (PSP_TextureData *) texture->internal; */
+    const Uint8 *src;
+    Uint8 *dst;
+    int row, length, dpitch;
+    src = pixels;
+
+    PSP_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+    length = rect->w * SDL_BYTESPERPIXEL(texture->format);
+    if (length == pitch && length == dpitch) {
+        SDL_memcpy(dst, src, length * rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, src, length);
+            src += pitch;
+            dst += dpitch;
+        }
+    }
+
+    sceKernelDcacheWritebackAll();
+    return true;
+}
+
+static bool PSP_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                           const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    PSP_TextureData *psp_texture = (PSP_TextureData *)texture->internal;
+
+    *pixels =
+        (void *)((Uint8 *)psp_texture->data + rect->y * psp_texture->pitch +
+                 rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = psp_texture->pitch;
+    return true;
+}
+
+static void PSP_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    PSP_TextureData *psp_texture = (PSP_TextureData *)texture->internal;
+    SDL_Rect rect;
+
+    // We do whole texture updates, at least for now
+    rect.x = 0;
+    rect.y = 0;
+    rect.w = texture->w;
+    rect.h = texture->h;
+    PSP_UpdateTexture(renderer, texture, &rect, psp_texture->data, psp_texture->pitch);
+}
+
+static void PSP_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    // Nothing to do because TextureActivate takes care of it
+}
+
+static bool PSP_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    return true;
+}
+
+static bool PSP_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool PSP_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    VertV *verts = (VertV *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertV), 4, &cmd->data.draw.first);
+    int i;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    for (i = 0; i < count; i++, verts++, points++) {
+        verts->x = points->x;
+        verts->y = points->y;
+        verts->z = 0.0f;
+    }
+
+    return true;
+}
+
+static bool PSP_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                             const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                             int num_vertices, const void *indices, int num_indices, int size_indices,
+                             float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    const float color_scale = cmd->data.draw.color_scale;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (!texture) {
+        VertCV *verts;
+        verts = (VertCV *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertCV), 4, &cmd->data.draw.first);
+        if (!verts) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor *col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = (SDL_FColor *)((char *)color + j * color_stride);
+
+            verts->x = xy_[0] * scale_x;
+            verts->y = xy_[1] * scale_y;
+            verts->z = 0;
+
+            verts->col.r = (Uint8)SDL_roundf(SDL_clamp(col_->r * color_scale, 0.0f, 1.0f) * 255.0f);
+            verts->col.g = (Uint8)SDL_roundf(SDL_clamp(col_->g * color_scale, 0.0f, 1.0f) * 255.0f);
+            verts->col.b = (Uint8)SDL_roundf(SDL_clamp(col_->b * color_scale, 0.0f, 1.0f) * 255.0f);
+            verts->col.a = (Uint8)SDL_roundf(SDL_clamp(col_->a, 0.0f, 1.0f) * 255.0f);
+
+            verts++;
+        }
+    } else {
+        PSP_TextureData *psp_texture = (PSP_TextureData *)texture->internal;
+        VertTCV *verts;
+        verts = (VertTCV *)SDL_AllocateRenderVertices(renderer, count * sizeof(VertTCV), 4, &cmd->data.draw.first);
+        if (!verts) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor *col_;
+            float *uv_;
+
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = (SDL_FColor *)((char *)color + j * color_stride);
+            uv_ = (float *)((char *)uv + j * uv_stride);
+
+            verts->x = xy_[0] * scale_x;
+            verts->y = xy_[1] * scale_y;
+            verts->z = 0;
+
+            verts->col.r = (Uint8)SDL_roundf(SDL_clamp(col_->r * color_scale, 0.0f, 1.0f) * 255.0f);
+            verts->col.g = (Uint8)SDL_roundf(SDL_clamp(col_->g * color_scale, 0.0f, 1.0f) * 255.0f);
+            verts->col.b = (Uint8)SDL_roundf(SDL_clamp(col_->b * color_scale, 0.0f, 1.0f) * 255.0f);
+            verts->col.a = (Uint8)SDL_roundf(SDL_clamp(col_->a, 0.0f, 1.0f) * 255.0f);
+
+            verts->u = uv_[0] * psp_texture->textureWidth;
+            verts->v = uv_[1] * psp_texture->textureHeight;
+
+            verts++;
+        }
+    }
+
+    return true;
+}
+
+static bool PSP_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
+{
+    VertV *verts = (VertV *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(VertV), 4, &cmd->data.draw.first);
+    int i;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    for (i = 0; i < count; i++, rects++) {
+        verts->x = rects->x;
+        verts->y = rects->y;
+        verts->z = 0.0f;
+        verts++;
+
+        verts->x = rects->x + rects->w + 0.5f;
+        verts->y = rects->y + rects->h + 0.5f;
+        verts->z = 0.0f;
+        verts++;
+    }
+
+    return true;
+}
+
+static bool PSP_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                         const SDL_FRect *srcrect, const SDL_FRect *dstrect)
+{
+    VertTV *verts;
+    const float x = dstrect->x;
+    const float y = dstrect->y;
+    const float width = dstrect->w;
+    const float height = dstrect->h;
+
+    const float u0 = srcrect->x;
+    const float v0 = srcrect->y;
+    const float u1 = srcrect->x + srcrect->w;
+    const float v1 = srcrect->y + srcrect->h;
+
+    if ((MathAbs(u1) - MathAbs(u0)) < 64.0f) {
+        verts = (VertTV *)SDL_AllocateRenderVertices(renderer, 2 * sizeof(VertTV), 4, &cmd->data.draw.first);
+        if (!verts) {
+            return false;
+        }
+
+        cmd->data.draw.count = 1;
+
+        verts->u = u0;
+        verts->v = v0;
+        verts->x = x;
+        verts->y = y;
+        verts->z = 0;
+        verts++;
+
+        verts->u = u1;
+        verts->v = v1;
+        verts->x = x + width;
+        verts->y = y + height;
+        verts->z = 0;
+        verts++;
+    } else {
+        float start, end;
+        float curU = u0;
+        float curX = x;
+        const float endX = x + width;
+        const float slice = 64.0f;
+        const size_t count = (size_t)SDL_ceilf(width / slice);
+        size_t i;
+        float ustep = (u1 - u0) / width * slice;
+
+        if (ustep < 0.0f) {
+            ustep = -ustep;
+        }
+
+        cmd->data.draw.count = count;
+
+        verts = (VertTV *)SDL_AllocateRenderVertices(renderer, count * 2 * sizeof(VertTV), 4, &cmd->data.draw.first);
+        if (!verts) {
+            return false;
+        }
+
+        for (i = 0, start = 0, end = width; i < count; i++, start += slice) {
+            const float polyWidth = ((curX + slice) > endX) ? (endX - curX) : slice;
+            const float sourceWidth = ((curU + ustep) > u1) ? (u1 - curU) : ustep;
+
+            SDL_assert(start < end);
+
+            verts->u = curU;
+            verts->v = v0;
+            verts->x = curX;
+            verts->y = y;
+            verts->z = 0;
+            verts++;
+
+            curU += sourceWidth;
+            curX += polyWidth;
+
+            verts->u = curU;
+            verts->v = v1;
+            verts->x = curX;
+            verts->y = (y + height);
+            verts->z = 0;
+            verts++;
+        }
+    }
+
+    return true;
+}
+
+static bool PSP_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                           const SDL_FRect *srcrect, const SDL_FRect *dstrect,
+                           const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y)
+{
+    VertTV *verts = (VertTV *)SDL_AllocateRenderVertices(renderer, 4 * sizeof(VertTV), 4, &cmd->data.draw.first);
+    const float centerx = center->x;
+    const float centery = center->y;
+    const float x = dstrect->x + centerx;
+    const float y = dstrect->y + centery;
+    const float width = dstrect->w - centerx;
+    const float height = dstrect->h - centery;
+    float s, c;
+    float cw1, sw1, ch1, sh1, cw2, sw2, ch2, sh2;
+
+    float u0 = srcrect->x;
+    float v0 = srcrect->y;
+    float u1 = srcrect->x + srcrect->w;
+    float v1 = srcrect->y + srcrect->h;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = 1;
+
+    MathSincos(degToRad((float)(360 - angle)), &s, &c);
+
+    cw1 = c * -centerx;
+    sw1 = s * -centerx;
+    ch1 = c * -centery;
+    sh1 = s * -centery;
+    cw2 = c * width;
+    sw2 = s * width;
+    ch2 = c * height;
+    sh2 = s * height;
+
+    if (flip & SDL_FLIP_VERTICAL) {
+        Swap(&v0, &v1);
+    }
+
+    if (flip & SDL_FLIP_HORIZONTAL) {
+        Swap(&u0, &u1);
+    }
+
+    verts->u = u0;
+    verts->v = v0;
+    verts->x = x + cw1 + sh1;
+    verts->y = y - sw1 + ch1;
+    verts->z = 0;
+    verts++;
+
+    verts->u = u0;
+    verts->v = v1;
+    verts->x = x + cw1 + sh2;
+    verts->y = y - sw1 + ch2;
+    verts->z = 0;
+    verts++;
+
+    verts->u = u1;
+    verts->v = v1;
+    verts->x = x + cw2 + sh2;
+    verts->y = y - sw2 + ch2;
+    verts->z = 0;
+    verts++;
+
+    verts->u = u1;
+    verts->v = v0;
+    verts->x = x + cw2 + sh1;
+    verts->y = y - sw2 + ch1;
+    verts->z = 0;
+
+    if (scale_x != 1.0f || scale_y != 1.0f) {
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+        verts--;
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+        verts--;
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+        verts--;
+        verts->x *= scale_x;
+        verts->y *= scale_y;
+    }
+
+    return true;
+}
+
+static void ResetBlendState(PSP_BlendState *state)
+{
+    sceGuColor(0xffffffff);
+    state->color = 0xffffffff;
+    state->mode = SDL_BLENDMODE_INVALID;
+    state->texture = NULL;
+    sceGuDisable(GU_TEXTURE_2D);
+    sceGuShadeModel(GU_SMOOTH);
+    state->shadeModel = GU_SMOOTH;
+}
+
+static void StartDrawing(SDL_Renderer *renderer)
+{
+    PSP_RenderData *data = (PSP_RenderData *)renderer->internal;
+
+    // Check if we need to start GU displaylist
+    if (!data->displayListAvail) {
+        sceGuStart(GU_DIRECT, DisplayList);
+        data->displayListAvail = true;
+        // ResetBlendState(&data->blendState);
+    }
+
+    // Check if we need a draw buffer change
+    if (renderer->target != data->boundTarget) {
+        SDL_Texture *texture = renderer->target;
+        if (texture) {
+            PSP_TextureData *psp_texture = (PSP_TextureData *)texture->internal;
+            // Set target, registering LRU
+            TextureBindAsTarget(data, psp_texture);
+        } else {
+            // Set target back to screen
+            sceGuDrawBufferList(data->psm, vrelptr(data->frontbuffer), PSP_FRAME_BUFFER_WIDTH);
+        }
+        data->boundTarget = texture;
+    }
+}
+
+static void PSP_SetBlendState(PSP_RenderData *data, PSP_BlendState *state)
+{
+    PSP_BlendState *current = &data->blendState;
+
+    if (state->mode != current->mode) {
+        switch (state->mode) {
+        case SDL_BLENDMODE_NONE:
+            sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
+            sceGuDisable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_BLEND:
+            sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_FIX, GU_ONE_MINUS_SRC_ALPHA, 0x00FFFFFF, 0 );
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_ADD:
+            sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_FIX, 0, 0x00FFFFFF);
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0, 0x00FFFFFF);
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_MOD:
+            sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
+            sceGuBlendFunc(GU_ADD, GU_FIX, GU_SRC_COLOR, 0, 0);
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_MUL:
+            sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
+            // FIXME SDL_BLENDMODE_MUL is simplified, and dstA is in fact un-changed.
+            sceGuBlendFunc(GU_ADD, GU_DST_COLOR, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
+            sceGuEnable(GU_BLEND);
+            break;
+        case SDL_BLENDMODE_INVALID:
+            break;
+        }
+    }
+
+    if (state->color != current->color) {
+        sceGuColor(state->color);
+    }
+
+    if (state->shadeModel != current->shadeModel) {
+        sceGuShadeModel(state->shadeModel);
+    }
+
+    if (state->texture != current->texture) {
+        if (state->texture) {
+            TextureActivate(state->texture);
+            sceGuEnable(GU_TEXTURE_2D);
+        } else {
+            sceGuDisable(GU_TEXTURE_2D);
+        }
+    }
+
+    *current = *state;
+}
+
+static void PSP_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    // currently this doesn't do anything. If this needs to do something (and someone is mixing their own rendering calls in!), update this.
+}
+
+static bool PSP_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    PSP_RenderData *data = (PSP_RenderData *)renderer->internal;
+    Uint8 *gpumem = NULL;
+    PSP_DrawStateCache drawstate;
+
+    drawstate.color = 0;
+
+    StartDrawing(renderer);
+
+    /* note that before the renderer interface change, this would do extremely small
+       batches with sceGuGetMemory()--a few vertices at a time--and it's not clear that
+       this won't fail if you try to push 100,000 draw calls in a single batch.
+       I don't know what the limits on PSP hardware are. It might be useful to have
+       rendering backends report a reasonable maximum, so the higher level can flush
+       if we appear to be exceeding that. */
+    gpumem = (Uint8 *)sceGuGetMemory(vertsize);
+    if (!gpumem) {
+        return SDL_SetError("Couldn't obtain a %d-byte vertex buffer!", (int)vertsize);
+    }
+    SDL_memcpy(gpumem, vertices, vertsize);
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            const Uint8 r = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.r * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 g = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.g * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 b = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.b * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 a = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.a, 0.0f, 1.0f) * 255.0f);
+            drawstate.color = GU_RGBA(r, g, b, a);
+            break;
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &cmd->data.viewport.rect;
+            sceGuOffset(2048 - (viewport->w >> 1), 2048 - (viewport->h >> 1));
+            sceGuViewport(2048, 2048, viewport->w, viewport->h);
+            sceGuScissor(viewport->x, viewport->y, viewport->w, viewport->h);
+            // FIXME: We need to update the clip rect too, see https://github.com/libsdl-org/SDL/issues/9094
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (cmd->data.cliprect.enabled) {
+                sceGuEnable(GU_SCISSOR_TEST);
+                sceGuScissor(rect->x, rect->y, rect->w, rect->h);
+            } else {
+                sceGuDisable(GU_SCISSOR_TEST);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            const Uint8 r = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.r * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 g = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.g * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 b = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.b * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 a = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.a, 0.0f, 1.0f) * 255.0f);
+            sceGuClearColor(GU_RGBA(r, g, b, a));
+            sceGuClearStencil(a);
+            sceGuClear(GU_COLOR_BUFFER_BIT | GU_STENCIL_BUFFER_BIT);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            const size_t count = cmd->data.draw.count;
+            const VertV *verts = (VertV *)(gpumem + cmd->data.draw.first);
+            PSP_BlendState state = {
+                .color = drawstate.color,
+                .texture = NULL,
+                .mode = cmd->data.draw.blend,
+                .shadeModel = GU_FLAT
+            };
+            PSP_SetBlendState(data, &state);
+            sceGuDrawArray(GU_POINTS, GU_VERTEX_32BITF | GU_TRANSFORM_2D, count, 0, verts);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            const size_t count = cmd->data.draw.count;
+            const VertV *verts = (VertV *)(gpumem + cmd->data.draw.first);
+            PSP_BlendState state = {
+                .color = drawstate.color,
+                .texture = NULL,
+                .mode = cmd->data.draw.blend,
+                .shadeModel = GU_FLAT
+            };
+            PSP_SetBlendState(data, &state);
+            sceGuDrawArray(GU_LINE_STRIP, GU_VERTEX_32BITF | GU_TRANSFORM_2D, count, 0, verts);
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS:
+        {
+            const size_t count = cmd->data.draw.count;
+            const VertV *verts = (VertV *)(gpumem + cmd->data.draw.first);
+            PSP_BlendState state = {
+                .color = drawstate.color,
+                .texture = NULL,
+                .mode = cmd->data.draw.blend,
+                .shadeModel = GU_FLAT
+            };
+            PSP_SetBlendState(data, &state);
+            sceGuDrawArray(GU_SPRITES, GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2 * count, 0, verts);
+            break;
+        }
+
+        case SDL_RENDERCMD_COPY:
+        {
+            const size_t count = cmd->data.draw.count;
+            const VertTV *verts = (VertTV *)(gpumem + cmd->data.draw.first);
+            PSP_BlendState state = {
+                .color = drawstate.color,
+                .texture = cmd->data.draw.texture,
+                .mode = cmd->data.draw.blend,
+                .shadeModel = GU_SMOOTH
+            };
+            PSP_SetBlendState(data, &state);
+            sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2 * count, 0, verts);
+            break;
+        }
+
+        case SDL_RENDERCMD_COPY_EX:
+        {
+            const VertTV *verts = (VertTV *)(gpumem + cmd->data.draw.first);
+            PSP_BlendState state = {
+                .color = drawstate.color,
+                .texture = cmd->data.draw.texture,
+                .mode = cmd->data.draw.blend,
+                .shadeModel = GU_SMOOTH
+            };
+            PSP_SetBlendState(data, &state);
+            sceGuDrawArray(GU_TRIANGLE_FAN, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 4, 0, verts);
+            break;
+        }
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            const size_t count = cmd->data.draw.count;
+            if (!cmd->data.draw.texture) {
+                const VertCV *verts = (VertCV *)(gpumem + cmd->data.draw.first);
+                sceGuDisable(GU_TEXTURE_2D);
+                // In GU_SMOOTH mode
+                sceGuDrawArray(GU_TRIANGLES, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_2D, count, 0, verts);
+                sceGuEnable(GU_TEXTURE_2D);
+            } else {
+                const VertTCV *verts = (VertTCV *)(gpumem + cmd->data.draw.first);
+                PSP_BlendState state = {
+                    .color = drawstate.color,
+                    .texture = NULL,
+                    .mode = cmd->data.draw.blend,
+                    .shadeModel = GU_FLAT
+                };
+                TextureActivate(cmd->data.draw.texture);
+                PSP_SetBlendState(data, &state);
+                sceGuDrawArray(GU_TRIANGLES, GU_TEXTURE_32BITF | GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_2D, count, 0, verts);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    return true;
+}
+
+static bool PSP_RenderPresent(SDL_Renderer *renderer)
+{
+    PSP_RenderData *data = (PSP_RenderData *)renderer->internal;
+    if (!data->displayListAvail) {
+        return false;
+    }
+
+    data->displayListAvail = false;
+    sceGuFinish();
+    sceGuSync(0, 0);
+
+    if ((data->vsync) && (data->vblank_not_reached)) {
+        sceDisplayWaitVblankStart();
+    }
+    data->vblank_not_reached = true;
+
+    data->backbuffer = data->frontbuffer;
+    data->frontbuffer = vabsptr(sceGuSwapBuffers());
+
+    return true;
+}
+
+static void PSP_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    PSP_RenderData *renderdata = (PSP_RenderData *)renderer->internal;
+    PSP_TextureData *psp_texture = (PSP_TextureData *)texture->internal;
+
+    if (!renderdata) {
+        return;
+    }
+
+    if (!psp_texture) {
+        return;
+    }
+
+    LRUTargetRemove(renderdata, psp_texture);
+    TextureStorageFree(psp_texture->data);
+    SDL_free(psp_texture);
+    texture->internal = NULL;
+}
+
+static void PSP_DestroyRenderer(SDL_Renderer *renderer)
+{
+    PSP_RenderData *data = (PSP_RenderData *)renderer->internal;
+    if (data) {
+        if (!data->initialized) {
+            return;
+        }
+
+        sceKernelDisableSubIntr(PSP_VBLANK_INT, 0);
+        sceKernelReleaseSubIntrHandler(PSP_VBLANK_INT, 0);
+        sceDisplayWaitVblankStart();
+        sceGuDisplay(GU_FALSE);
+        sceGuTerm();
+        vfree(data->backbuffer);
+        vfree(data->frontbuffer);
+
+        data->initialized = false;
+        data->displayListAvail = false;
+        SDL_free(data);
+    }
+}
+
+static bool PSP_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    PSP_RenderData *data = renderer->internal;
+    data->vsync = vsync;
+    return true;
+}
+
+static bool PSP_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    PSP_RenderData *data;
+    int pixelformat;
+    void *doublebuffer = NULL;
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (PSP_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+
+    renderer->WindowEvent = PSP_WindowEvent;
+    renderer->CreateTexture = PSP_CreateTexture;
+    renderer->UpdateTexture = PSP_UpdateTexture;
+    renderer->LockTexture = PSP_LockTexture;
+    renderer->UnlockTexture = PSP_UnlockTexture;
+    renderer->SetTextureScaleMode = PSP_SetTextureScaleMode;
+    renderer->SetRenderTarget = PSP_SetRenderTarget;
+    renderer->QueueSetViewport = PSP_QueueNoOp;
+    renderer->QueueSetDrawColor = PSP_QueueNoOp;
+    renderer->QueueDrawPoints = PSP_QueueDrawPoints;
+    renderer->QueueDrawLines = PSP_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueGeometry = PSP_QueueGeometry;
+    renderer->QueueFillRects = PSP_QueueFillRects;
+    renderer->QueueCopy = PSP_QueueCopy;
+    renderer->QueueCopyEx = PSP_QueueCopyEx;
+    renderer->InvalidateCachedState = PSP_InvalidateCachedState;
+    renderer->RunCommandQueue = PSP_RunCommandQueue;
+    renderer->RenderPresent = PSP_RenderPresent;
+    renderer->DestroyTexture = PSP_DestroyTexture;
+    renderer->DestroyRenderer = PSP_DestroyRenderer;
+    renderer->SetVSync = PSP_SetVSync;
+    renderer->internal = data;
+    PSP_InvalidateCachedState(renderer);
+    renderer->window = window;
+
+    renderer->name = PSP_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGR565);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR4444);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 512);
+
+    data->initialized = true;
+    data->most_recent_target = NULL;
+    data->least_recent_target = NULL;
+
+    pixelformat = PixelFormatToPSPFMT(SDL_GetWindowPixelFormat(window));
+    switch (pixelformat) {
+    case GU_PSM_4444:
+    case GU_PSM_5650:
+    case GU_PSM_5551:
+        data->bpp = 2;
+        data->psm = pixelformat;
+        break;
+    default:
+        data->bpp = 4;
+        data->psm = GU_PSM_8888;
+        break;
+    }
+
+    doublebuffer = vramalloc(PSP_FRAME_BUFFER_SIZE * data->bpp * 2);
+    data->backbuffer = doublebuffer;
+    data->frontbuffer = ((uint8_t *)doublebuffer) + PSP_FRAME_BUFFER_SIZE * data->bpp;
+
+    sceGuInit();
+    // setup GU
+    sceGuStart(GU_DIRECT, DisplayList);
+    sceGuDrawBuffer(data->psm, vrelptr(data->frontbuffer), PSP_FRAME_BUFFER_WIDTH);
+    sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, vrelptr(data->backbuffer), PSP_FRAME_BUFFER_WIDTH);
+
+    sceGuOffset(2048 - (PSP_SCREEN_WIDTH >> 1), 2048 - (PSP_SCREEN_HEIGHT >> 1));
+    sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
+
+    sceGuDisable(GU_DEPTH_TEST);
+
+    // Scissoring
+    sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);
+    sceGuEnable(GU_SCISSOR_TEST);
+
+    // Backface culling
+    sceGuDisable(GU_CULL_FACE);
+
+    // Setup initial blend state
+    ResetBlendState(&data->blendState);
+
+    sceGuFinish();
+    sceGuSync(0, 0);
+    sceDisplayWaitVblankStartCB();
+    sceGuDisplay(GU_TRUE);
+
+    // Improve performance when VSYC is enabled and it is not reaching the 60 FPS
+    data->vblank_not_reached = true;
+    sceKernelRegisterSubIntrHandler(PSP_VBLANK_INT, 0, psp_on_vblank, data);
+    sceKernelEnableSubIntr(PSP_VBLANK_INT, 0);
+
+    return true;
+}
+
+SDL_RenderDriver PSP_RenderDriver = {
+    PSP_CreateRenderer, "PSP"
+};
+
+#endif // SDL_VIDEO_RENDER_PSP
diff --git a/SDL-3.2.8/src/render/psp/SDL_render_psp_c.h b/SDL-3.2.8/src/render/psp/SDL_render_psp_c.h
new file mode 100644
index 0000000..4d60847
--- /dev/null
+++ b/SDL-3.2.8/src/render/psp/SDL_render_psp_c.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef SDL_VIDEO_RENDER_PSP_C_H
+#define SDL_VIDEO_RENDER_PSP_C_H
+
+#define PSP_SCREEN_WIDTH  480
+#define PSP_SCREEN_HEIGHT 272
+
+#define PSP_FRAME_BUFFER_WIDTH 512
+#define PSP_FRAME_BUFFER_SIZE  (PSP_FRAME_BUFFER_WIDTH * PSP_SCREEN_HEIGHT)
+
+#endif // SDL_VIDEO_RENDER_PSP_C_H
diff --git a/SDL-3.2.8/src/render/software/SDL_blendfillrect.c b/SDL-3.2.8/src/render/software/SDL_blendfillrect.c
new file mode 100644
index 0000000..4e5c7f8
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_blendfillrect.c
@@ -0,0 +1,371 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include "SDL_draw.h"
+#include "SDL_blendfillrect.h"
+
+static bool SDL_BlendFillRect_RGB555(SDL_Surface *dst, const SDL_Rect *rect,
+                                    SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB555);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
+        break;
+    case SDL_BLENDMODE_MOD:
+        FILLRECT(Uint16, DRAW_SETPIXEL_MOD_RGB555);
+        break;
+    case SDL_BLENDMODE_MUL:
+        FILLRECT(Uint16, DRAW_SETPIXEL_MUL_RGB555);
+        break;
+    default:
+        FILLRECT(Uint16, DRAW_SETPIXEL_RGB555);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendFillRect_RGB565(SDL_Surface *dst, const SDL_Rect *rect,
+                                    SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB565);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
+        break;
+    case SDL_BLENDMODE_MOD:
+        FILLRECT(Uint16, DRAW_SETPIXEL_MOD_RGB565);
+        break;
+    case SDL_BLENDMODE_MUL:
+        FILLRECT(Uint16, DRAW_SETPIXEL_MUL_RGB565);
+        break;
+    default:
+        FILLRECT(Uint16, DRAW_SETPIXEL_RGB565);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendFillRect_XRGB8888(SDL_Surface *dst, const SDL_Rect *rect,
+                                    SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_XRGB8888);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_XRGB8888);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        FILLRECT(Uint32, DRAW_SETPIXEL_ADD_XRGB8888);
+        break;
+    case SDL_BLENDMODE_MOD:
+        FILLRECT(Uint32, DRAW_SETPIXEL_MOD_XRGB8888);
+        break;
+    case SDL_BLENDMODE_MUL:
+        FILLRECT(Uint32, DRAW_SETPIXEL_MUL_XRGB8888);
+        break;
+    default:
+        FILLRECT(Uint32, DRAW_SETPIXEL_XRGB8888);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendFillRect_ARGB8888(SDL_Surface *dst, const SDL_Rect *rect,
+                                      SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_ARGB8888);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        FILLRECT(Uint32, DRAW_SETPIXEL_ADD_ARGB8888);
+        break;
+    case SDL_BLENDMODE_MOD:
+        FILLRECT(Uint32, DRAW_SETPIXEL_MOD_ARGB8888);
+        break;
+    case SDL_BLENDMODE_MUL:
+        FILLRECT(Uint32, DRAW_SETPIXEL_MUL_ARGB8888);
+        break;
+    default:
+        FILLRECT(Uint32, DRAW_SETPIXEL_ARGB8888);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendFillRect_RGB(SDL_Surface *dst, const SDL_Rect *rect,
+                                 SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->bytes_per_pixel) {
+    case 2:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
+            break;
+        case SDL_BLENDMODE_MOD:
+            FILLRECT(Uint16, DRAW_SETPIXEL_MOD_RGB);
+            break;
+        case SDL_BLENDMODE_MUL:
+            FILLRECT(Uint16, DRAW_SETPIXEL_MUL_RGB);
+            break;
+        default:
+            FILLRECT(Uint16, DRAW_SETPIXEL_RGB);
+            break;
+        }
+        return true;
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGB);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
+            break;
+        case SDL_BLENDMODE_MOD:
+            FILLRECT(Uint32, DRAW_SETPIXEL_MOD_RGB);
+            break;
+        case SDL_BLENDMODE_MUL:
+            FILLRECT(Uint32, DRAW_SETPIXEL_MUL_RGB);
+            break;
+        default:
+            FILLRECT(Uint32, DRAW_SETPIXEL_RGB);
+            break;
+        }
+        return true;
+    default:
+        return SDL_Unsupported();
+    }
+}
+
+static bool SDL_BlendFillRect_RGBA(SDL_Surface *dst, const SDL_Rect *rect,
+                                  SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->bytes_per_pixel) {
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGBA);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
+            break;
+        case SDL_BLENDMODE_MOD:
+            FILLRECT(Uint32, DRAW_SETPIXEL_MOD_RGBA);
+            break;
+        case SDL_BLENDMODE_MUL:
+            FILLRECT(Uint32, DRAW_SETPIXEL_MUL_RGBA);
+            break;
+        default:
+            FILLRECT(Uint32, DRAW_SETPIXEL_RGBA);
+            break;
+        }
+        return true;
+    default:
+        return SDL_Unsupported();
+    }
+}
+
+bool SDL_BlendFillRect(SDL_Surface *dst, const SDL_Rect *rect, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_Rect clipped;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_BlendFillRect(): dst");
+    }
+
+    // This function doesn't work on surfaces < 8 bpp
+    if (SDL_BITSPERPIXEL(dst->format) < 8) {
+        return SDL_SetError("SDL_BlendFillRect(): Unsupported surface format");
+    }
+
+    // If 'rect' == NULL, then fill the whole surface
+    if (rect) {
+        // Perform clipping
+        if (!SDL_GetRectIntersection(rect, &dst->clip_rect, &clipped)) {
+            return true;
+        }
+        rect = &clipped;
+    } else {
+        rect = &dst->clip_rect;
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    switch (dst->fmt->bits_per_pixel) {
+    case 15:
+        switch (dst->fmt->Rmask) {
+        case 0x7C00:
+            return SDL_BlendFillRect_RGB555(dst, rect, blendMode, r, g, b, a);
+        }
+        break;
+    case 16:
+        switch (dst->fmt->Rmask) {
+        case 0xF800:
+            return SDL_BlendFillRect_RGB565(dst, rect, blendMode, r, g, b, a);
+        }
+        break;
+    case 32:
+        switch (dst->fmt->Rmask) {
+        case 0x00FF0000:
+            if (!dst->fmt->Amask) {
+                return SDL_BlendFillRect_XRGB8888(dst, rect, blendMode, r, g, b, a);
+            } else {
+                return SDL_BlendFillRect_ARGB8888(dst, rect, blendMode, r, g, b, a);
+            }
+            // break; -Wunreachable-code-break
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!dst->fmt->Amask) {
+        return SDL_BlendFillRect_RGB(dst, rect, blendMode, r, g, b, a);
+    } else {
+        return SDL_BlendFillRect_RGBA(dst, rect, blendMode, r, g, b, a);
+    }
+}
+
+bool SDL_BlendFillRects(SDL_Surface *dst, const SDL_Rect *rects, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    SDL_Rect rect;
+    int i;
+    bool (*func)(SDL_Surface * dst, const SDL_Rect *rect, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
+    bool result = true;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_BlendFillRects(): dst");
+    }
+
+    // This function doesn't work on surfaces < 8 bpp
+    if (dst->fmt->bits_per_pixel < 8) {
+        return SDL_SetError("SDL_BlendFillRects(): Unsupported surface format");
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    // FIXME: Does this function pointer slow things down significantly?
+    switch (dst->fmt->bits_per_pixel) {
+    case 15:
+        switch (dst->fmt->Rmask) {
+        case 0x7C00:
+            func = SDL_BlendFillRect_RGB555;
+        }
+        break;
+    case 16:
+        switch (dst->fmt->Rmask) {
+        case 0xF800:
+            func = SDL_BlendFillRect_RGB565;
+        }
+        break;
+    case 32:
+        switch (dst->fmt->Rmask) {
+        case 0x00FF0000:
+            if (!dst->fmt->Amask) {
+                func = SDL_BlendFillRect_XRGB8888;
+            } else {
+                func = SDL_BlendFillRect_ARGB8888;
+            }
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!func) {
+        if (!dst->fmt->Amask) {
+            func = SDL_BlendFillRect_RGB;
+        } else {
+            func = SDL_BlendFillRect_RGBA;
+        }
+    }
+
+    for (i = 0; i < count; ++i) {
+        // Perform clipping
+        if (!SDL_GetRectIntersection(&rects[i], &dst->clip_rect, &rect)) {
+            continue;
+        }
+        result = func(dst, &rect, blendMode, r, g, b, a);
+    }
+    return result;
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_blendfillrect.h b/SDL-3.2.8/src/render/software/SDL_blendfillrect.h
new file mode 100644
index 0000000..c1ff439
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_blendfillrect.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_blendfillrect_h_
+#define SDL_blendfillrect_h_
+
+#include "SDL_internal.h"
+
+extern bool SDL_BlendFillRect(SDL_Surface *dst, const SDL_Rect *rect, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern bool SDL_BlendFillRects(SDL_Surface *dst, const SDL_Rect *rects, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+#endif // SDL_blendfillrect_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_blendline.c b/SDL-3.2.8/src/render/software/SDL_blendline.c
new file mode 100644
index 0000000..53be2f1
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_blendline.c
@@ -0,0 +1,986 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include "SDL_draw.h"
+#include "SDL_blendline.h"
+#include "SDL_blendpoint.h"
+
+static void SDL_BlendLine_RGB2(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                               SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                               bool draw_end)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint16, DRAW_SETPIXEL_MUL_RGB, draw_end);
+            break;
+        default:
+            HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint16, DRAW_SETPIXEL_MUL_RGB, draw_end);
+            break;
+        default:
+            VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint16, DRAW_SETPIXEL_MUL_RGB, draw_end);
+            break;
+        default:
+            DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_BLEND_CLAMPED_RGB, DRAW_SETPIXELXY2_BLEND_CLAMPED_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_MOD_RGB, DRAW_SETPIXELXY2_MOD_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_MUL_RGB, DRAW_SETPIXELXY2_MUL_RGB,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void SDL_BlendLine_RGB555(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                                 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                                 bool draw_end)
+{
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint16, DRAW_SETPIXEL_MUL_RGB555, draw_end);
+            break;
+        default:
+            HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint16, DRAW_SETPIXEL_MUL_RGB555, draw_end);
+            break;
+        default:
+            VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint16, DRAW_SETPIXEL_MUL_RGB555, draw_end);
+            break;
+        default:
+            DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_CLAMPED_RGB555, DRAW_SETPIXELXY_BLEND_CLAMPED_RGB555,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MOD_RGB555, DRAW_SETPIXELXY_MOD_RGB555,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MUL_RGB555, DRAW_SETPIXELXY_MUL_RGB555,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void SDL_BlendLine_RGB565(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                                 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                                 bool draw_end)
+{
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint16, DRAW_SETPIXEL_MUL_RGB565, draw_end);
+            break;
+        default:
+            HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint16, DRAW_SETPIXEL_MUL_RGB565, draw_end);
+            break;
+        default:
+            VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint16, DRAW_SETPIXEL_BLEND_CLAMPED_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint16, DRAW_SETPIXEL_MUL_RGB565, draw_end);
+            break;
+        default:
+            DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_CLAMPED_RGB565, DRAW_SETPIXELXY_BLEND_CLAMPED_RGB565,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MOD_RGB565, DRAW_SETPIXELXY_MOD_RGB565,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MUL_RGB565, DRAW_SETPIXELXY_MUL_RGB565,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void SDL_BlendLine_RGB4(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                               SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                               bool draw_end)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint32, DRAW_SETPIXEL_MUL_RGB, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint32, DRAW_SETPIXEL_MUL_RGB, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint32, DRAW_SETPIXEL_MUL_RGB, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_BLEND_CLAMPED_RGB, DRAW_SETPIXELXY4_BLEND_CLAMPED_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_MOD_RGB, DRAW_SETPIXELXY4_MOD_RGB,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_MUL_RGB, DRAW_SETPIXELXY4_MUL_RGB,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void SDL_BlendLine_RGBA4(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                                SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                                bool draw_end)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint32, DRAW_SETPIXEL_MUL_RGBA, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint32, DRAW_SETPIXEL_MUL_RGBA, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint32, DRAW_SETPIXEL_MUL_RGBA, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_BLEND_CLAMPED_RGBA, DRAW_SETPIXELXY4_BLEND_CLAMPED_RGBA,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_MOD_RGBA, DRAW_SETPIXELXY4_MOD_RGBA,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_MUL_RGBA, DRAW_SETPIXELXY4_MUL_RGBA,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void SDL_BlendLine_XRGB8888(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                                 SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                                 bool draw_end)
+{
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint32, DRAW_SETPIXEL_MOD_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint32, DRAW_SETPIXEL_MUL_XRGB8888, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_XRGB8888, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint32, DRAW_SETPIXEL_MOD_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint32, DRAW_SETPIXEL_MUL_XRGB8888, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_XRGB8888, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint32, DRAW_SETPIXEL_MOD_XRGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint32, DRAW_SETPIXEL_MUL_XRGB8888, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_XRGB8888, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_XRGB8888, DRAW_SETPIXELXY_BLEND_XRGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_CLAMPED_XRGB8888, DRAW_SETPIXELXY_BLEND_CLAMPED_XRGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_XRGB8888, DRAW_SETPIXELXY_ADD_XRGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MOD_XRGB8888, DRAW_SETPIXELXY_MOD_XRGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MUL_XRGB8888, DRAW_SETPIXELXY_MUL_XRGB8888,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_XRGB8888, DRAW_SETPIXELXY_BLEND_XRGB8888,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+static void SDL_BlendLine_ARGB8888(SDL_Surface *dst, int x1, int y1, int x2, int y2,
+                                   SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
+                                   bool draw_end)
+{
+    unsigned r, g, b, a, inva;
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(_r, _a);
+        g = DRAW_MUL(_g, _a);
+        b = DRAW_MUL(_b, _a);
+        a = _a;
+    } else {
+        r = _r;
+        g = _g;
+        b = _b;
+        a = _a;
+    }
+    inva = (a ^ 0xff);
+
+    if (y1 == y2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            HLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            HLINE(Uint32, DRAW_SETPIXEL_MUL_ARGB8888, draw_end);
+            break;
+        default:
+            HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+            break;
+        }
+    } else if (x1 == x2) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            VLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            VLINE(Uint32, DRAW_SETPIXEL_MUL_ARGB8888, draw_end);
+            break;
+        default:
+            VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+            break;
+        }
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_BLEND_CLAMPED_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DLINE(Uint32, DRAW_SETPIXEL_MUL_ARGB8888, draw_end);
+            break;
+        default:
+            DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
+            break;
+        }
+    } else {
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_BLEND_CLAMPED_ARGB8888, DRAW_SETPIXELXY_BLEND_CLAMPED_ARGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MOD:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MOD_ARGB8888, DRAW_SETPIXELXY_MOD_ARGB8888,
+                   draw_end);
+            break;
+        case SDL_BLENDMODE_MUL:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_MUL_ARGB8888, DRAW_SETPIXELXY_MUL_ARGB8888,
+                   draw_end);
+            break;
+        default:
+            AALINE(x1, y1, x2, y2,
+                   DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
+                   draw_end);
+            break;
+        }
+    }
+}
+
+typedef void (*BlendLineFunc)(SDL_Surface *dst,
+                              int x1, int y1, int x2, int y2,
+                              SDL_BlendMode blendMode,
+                              Uint8 r, Uint8 g, Uint8 b, Uint8 a,
+                              bool draw_end);
+
+static BlendLineFunc SDL_CalculateBlendLineFunc(const SDL_PixelFormatDetails *fmt)
+{
+    switch (fmt->bytes_per_pixel) {
+    case 2:
+        if (fmt->Rmask == 0x7C00) {
+            return SDL_BlendLine_RGB555;
+        } else if (fmt->Rmask == 0xF800) {
+            return SDL_BlendLine_RGB565;
+        } else {
+            return SDL_BlendLine_RGB2;
+        }
+        // break; -Wunreachable-code-break
+    case 4:
+        if (fmt->Rmask == 0x00FF0000) {
+            if (fmt->Amask) {
+                return SDL_BlendLine_ARGB8888;
+            } else {
+                return SDL_BlendLine_XRGB8888;
+            }
+        } else {
+            if (fmt->Amask) {
+                return SDL_BlendLine_RGBA4;
+            } else {
+                return SDL_BlendLine_RGB4;
+            }
+        }
+    }
+    return NULL;
+}
+
+bool SDL_BlendLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    BlendLineFunc func;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_BlendLine(): dst");
+    }
+
+    func = SDL_CalculateBlendLineFunc(dst->fmt);
+    if (!func) {
+        return SDL_SetError("SDL_BlendLine(): Unsupported surface format");
+    }
+
+    // Perform clipping
+    // FIXME: We don't actually want to clip, as it may change line slope
+    if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+        return true;
+    }
+
+    func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, true);
+    return true;
+}
+
+bool SDL_BlendLines(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    int i;
+    int x1, y1;
+    int x2, y2;
+    bool draw_end;
+    BlendLineFunc func;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
+    }
+
+    func = SDL_CalculateBlendLineFunc(dst->fmt);
+    if (!func) {
+        return SDL_SetError("SDL_BlendLines(): Unsupported surface format");
+    }
+
+    for (i = 1; i < count; ++i) {
+        x1 = points[i - 1].x;
+        y1 = points[i - 1].y;
+        x2 = points[i].x;
+        y2 = points[i].y;
+
+        // Perform clipping
+        // FIXME: We don't actually want to clip, as it may change line slope
+        if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+            continue;
+        }
+
+        // Draw the end if it was clipped
+        draw_end = (x2 != points[i].x || y2 != points[i].y);
+
+        func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
+    }
+    if (points[0].x != points[count - 1].x || points[0].y != points[count - 1].y) {
+        SDL_BlendPoint(dst, points[count - 1].x, points[count - 1].y,
+                       blendMode, r, g, b, a);
+    }
+    return true;
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_blendline.h b/SDL-3.2.8/src/render/software/SDL_blendline.h
new file mode 100644
index 0000000..c9a8b20
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_blendline.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_blendline_h_
+#define SDL_blendline_h_
+
+#include "SDL_internal.h"
+
+extern bool SDL_BlendLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern bool SDL_BlendLines(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+#endif // SDL_blendline_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_blendpoint.c b/SDL-3.2.8/src/render/software/SDL_blendpoint.c
new file mode 100644
index 0000000..e408453
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_blendpoint.c
@@ -0,0 +1,376 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include "SDL_draw.h"
+#include "SDL_blendpoint.h"
+
+static bool SDL_BlendPoint_RGB555(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                                 Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_RGB555(x, y);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        DRAW_SETPIXELXY_BLEND_CLAMPED_RGB555(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        DRAW_SETPIXELXY_ADD_RGB555(x, y);
+        break;
+    case SDL_BLENDMODE_MOD:
+        DRAW_SETPIXELXY_MOD_RGB555(x, y);
+        break;
+    case SDL_BLENDMODE_MUL:
+        DRAW_SETPIXELXY_MUL_RGB555(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_RGB555(x, y);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendPoint_RGB565(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                                 Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_RGB565(x, y);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        DRAW_SETPIXELXY_BLEND_CLAMPED_RGB565(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        DRAW_SETPIXELXY_ADD_RGB565(x, y);
+        break;
+    case SDL_BLENDMODE_MOD:
+        DRAW_SETPIXELXY_MOD_RGB565(x, y);
+        break;
+    case SDL_BLENDMODE_MUL:
+        DRAW_SETPIXELXY_MUL_RGB565(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_RGB565(x, y);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendPoint_XRGB8888(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                                 Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_XRGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        DRAW_SETPIXELXY_BLEND_CLAMPED_XRGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        DRAW_SETPIXELXY_ADD_XRGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_MOD:
+        DRAW_SETPIXELXY_MOD_XRGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_MUL:
+        DRAW_SETPIXELXY_MUL_XRGB8888(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_XRGB8888(x, y);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendPoint_ARGB8888(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode,
+                                   Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    unsigned inva = 0xff - a;
+
+    switch (blendMode) {
+    case SDL_BLENDMODE_BLEND:
+        DRAW_SETPIXELXY_BLEND_ARGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+        DRAW_SETPIXELXY_BLEND_CLAMPED_ARGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_ADD:
+    case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+        DRAW_SETPIXELXY_ADD_ARGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_MOD:
+        DRAW_SETPIXELXY_MOD_ARGB8888(x, y);
+        break;
+    case SDL_BLENDMODE_MUL:
+        DRAW_SETPIXELXY_MUL_ARGB8888(x, y);
+        break;
+    default:
+        DRAW_SETPIXELXY_ARGB8888(x, y);
+        break;
+    }
+    return true;
+}
+
+static bool SDL_BlendPoint_RGB(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                              Uint8 g, Uint8 b, Uint8 a)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->bytes_per_pixel) {
+    case 2:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DRAW_SETPIXELXY2_BLEND_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DRAW_SETPIXELXY2_BLEND_CLAMPED_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DRAW_SETPIXELXY2_ADD_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DRAW_SETPIXELXY2_MOD_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DRAW_SETPIXELXY2_MUL_RGB(x, y);
+            break;
+        default:
+            DRAW_SETPIXELXY2_RGB(x, y);
+            break;
+        }
+        return true;
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DRAW_SETPIXELXY4_BLEND_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DRAW_SETPIXELXY4_BLEND_CLAMPED_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DRAW_SETPIXELXY4_ADD_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DRAW_SETPIXELXY4_MOD_RGB(x, y);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DRAW_SETPIXELXY4_MUL_RGB(x, y);
+            break;
+        default:
+            DRAW_SETPIXELXY4_RGB(x, y);
+            break;
+        }
+        return true;
+    default:
+        return SDL_Unsupported();
+    }
+}
+
+static bool SDL_BlendPoint_RGBA(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
+                               Uint8 g, Uint8 b, Uint8 a)
+{
+    const SDL_PixelFormatDetails *fmt = dst->fmt;
+    unsigned inva = 0xff - a;
+
+    switch (fmt->bytes_per_pixel) {
+    case 4:
+        switch (blendMode) {
+        case SDL_BLENDMODE_BLEND:
+            DRAW_SETPIXELXY4_BLEND_RGBA(x, y);
+            break;
+        case SDL_BLENDMODE_BLEND_PREMULTIPLIED:
+            DRAW_SETPIXELXY4_BLEND_CLAMPED_RGBA(x, y);
+            break;
+        case SDL_BLENDMODE_ADD:
+        case SDL_BLENDMODE_ADD_PREMULTIPLIED:
+            DRAW_SETPIXELXY4_ADD_RGBA(x, y);
+            break;
+        case SDL_BLENDMODE_MOD:
+            DRAW_SETPIXELXY4_MOD_RGBA(x, y);
+            break;
+        case SDL_BLENDMODE_MUL:
+            DRAW_SETPIXELXY4_MUL_RGBA(x, y);
+            break;
+        default:
+            DRAW_SETPIXELXY4_RGBA(x, y);
+            break;
+        }
+        return true;
+    default:
+        return SDL_Unsupported();
+    }
+}
+
+bool SDL_BlendPoint(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_BlendPoint(): dst");
+    }
+
+    // This function doesn't work on surfaces < 8 bpp
+    if (SDL_BITSPERPIXEL(dst->format) < 8) {
+        return SDL_SetError("SDL_BlendPoint(): Unsupported surface format");
+    }
+
+    // Perform clipping
+    if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
+        x >= (dst->clip_rect.x + dst->clip_rect.w) ||
+        y >= (dst->clip_rect.y + dst->clip_rect.h)) {
+        return true;
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    switch (dst->fmt->bits_per_pixel) {
+    case 15:
+        switch (dst->fmt->Rmask) {
+        case 0x7C00:
+            return SDL_BlendPoint_RGB555(dst, x, y, blendMode, r, g, b, a);
+        }
+        break;
+    case 16:
+        switch (dst->fmt->Rmask) {
+        case 0xF800:
+            return SDL_BlendPoint_RGB565(dst, x, y, blendMode, r, g, b, a);
+        }
+        break;
+    case 32:
+        switch (dst->fmt->Rmask) {
+        case 0x00FF0000:
+            if (!dst->fmt->Amask) {
+                return SDL_BlendPoint_XRGB8888(dst, x, y, blendMode, r, g, b, a);
+            } else {
+                return SDL_BlendPoint_ARGB8888(dst, x, y, blendMode, r, g, b, a);
+            }
+            // break; -Wunreachable-code-break
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!dst->fmt->Amask) {
+        return SDL_BlendPoint_RGB(dst, x, y, blendMode, r, g, b, a);
+    } else {
+        return SDL_BlendPoint_RGBA(dst, x, y, blendMode, r, g, b, a);
+    }
+}
+
+bool SDL_BlendPoints(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
+{
+    int minx, miny;
+    int maxx, maxy;
+    int i;
+    int x, y;
+    bool (*func)(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
+    bool result = true;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_BlendPoints(): dst");
+    }
+
+    // This function doesn't work on surfaces < 8 bpp
+    if (dst->fmt->bits_per_pixel < 8) {
+        return SDL_SetError("SDL_BlendPoints(): Unsupported surface format");
+    }
+
+    if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
+        r = DRAW_MUL(r, a);
+        g = DRAW_MUL(g, a);
+        b = DRAW_MUL(b, a);
+    }
+
+    // FIXME: Does this function pointer slow things down significantly?
+    switch (dst->fmt->bits_per_pixel) {
+    case 15:
+        switch (dst->fmt->Rmask) {
+        case 0x7C00:
+            func = SDL_BlendPoint_RGB555;
+            break;
+        }
+        break;
+    case 16:
+        switch (dst->fmt->Rmask) {
+        case 0xF800:
+            func = SDL_BlendPoint_RGB565;
+            break;
+        }
+        break;
+    case 32:
+        switch (dst->fmt->Rmask) {
+        case 0x00FF0000:
+            if (!dst->fmt->Amask) {
+                func = SDL_BlendPoint_XRGB8888;
+            } else {
+                func = SDL_BlendPoint_ARGB8888;
+            }
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+
+    if (!func) {
+        if (!dst->fmt->Amask) {
+            func = SDL_BlendPoint_RGB;
+        } else {
+            func = SDL_BlendPoint_RGBA;
+        }
+    }
+
+    minx = dst->clip_rect.x;
+    maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
+    miny = dst->clip_rect.y;
+    maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
+
+    for (i = 0; i < count; ++i) {
+        x = points[i].x;
+        y = points[i].y;
+
+        if (x < minx || x > maxx || y < miny || y > maxy) {
+            continue;
+        }
+        result = func(dst, x, y, blendMode, r, g, b, a);
+    }
+    return result;
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_blendpoint.h b/SDL-3.2.8/src/render/software/SDL_blendpoint.h
new file mode 100644
index 0000000..6dfe49a
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_blendpoint.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_blendpoint_h_
+#define SDL_blendpoint_h_
+
+#include "SDL_internal.h"
+
+extern bool SDL_BlendPoint(SDL_Surface *dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern bool SDL_BlendPoints(SDL_Surface *dst, const SDL_Point *points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+#endif // SDL_blendpoint_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_draw.h b/SDL-3.2.8/src/render/software/SDL_draw.h
new file mode 100644
index 0000000..ec77527
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_draw.h
@@ -0,0 +1,723 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#include "../../video/SDL_surface_c.h"
+
+/* This code assumes that r, g, b, a are the source color,
+ * and in the blend and add case, the RGB values are premultiplied by a.
+ */
+
+#define DRAW_MUL(_a, _b) (((unsigned)(_a) * (_b)) / 255)
+
+#define DRAW_FASTSETPIXEL(type) \
+    *pixel = (type)color
+
+#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(Uint8)
+#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(Uint16)
+#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(Uint32)
+
+#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
+    *(type *)((Uint8 *)dst->pixels + (y)*dst->pitch + (x)*bpp) = (type)color
+
+#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, Uint8, 1, color)
+#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, Uint16, 2, color)
+#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, Uint32, 4, color)
+
+#define DRAW_SETPIXEL(setpixel)                  \
+    do {                                         \
+        unsigned sr = r, sg = g, sb = b, sa = a; \
+        (void)sa;                                \
+        setpixel;                                \
+    } while (0)
+
+#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
+    do {                                        \
+        unsigned sr, sg, sb, sa = 0xFF;         \
+        getpixel;                               \
+        sr = DRAW_MUL(inva, sr) + r;            \
+        sg = DRAW_MUL(inva, sg) + g;            \
+        sb = DRAW_MUL(inva, sb) + b;            \
+        sa = DRAW_MUL(inva, sa) + a;            \
+        setpixel;                               \
+    } while (0)
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED(getpixel, setpixel) \
+    do {                                                \
+        unsigned sr, sg, sb, sa = 0xFF;                 \
+        getpixel;                                       \
+        sr = DRAW_MUL(inva, sr) + r;                    \
+        if (sr > 0xff)                                  \
+            sr = 0xff;                                  \
+        sg = DRAW_MUL(inva, sg) + g;                    \
+        if (sg > 0xff)                                  \
+            sg = 0xff;                                  \
+        sb = DRAW_MUL(inva, sb) + b;                    \
+        if (sb > 0xff)                                  \
+            sb = 0xff;                                  \
+        sa = DRAW_MUL(inva, sa) + a;                    \
+        if (sa > 0xff)                                  \
+            sa = 0xff;                                  \
+        setpixel;                                       \
+    } while (0)
+
+#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
+    do {                                      \
+        unsigned sr, sg, sb, sa;              \
+        (void)sa;                             \
+        getpixel;                             \
+        sr += r;                              \
+        if (sr > 0xff)                        \
+            sr = 0xff;                        \
+        sg += g;                              \
+        if (sg > 0xff)                        \
+            sg = 0xff;                        \
+        sb += b;                              \
+        if (sb > 0xff)                        \
+            sb = 0xff;                        \
+        setpixel;                             \
+    } while (0)
+
+#define DRAW_SETPIXEL_MOD(getpixel, setpixel) \
+    do {                                      \
+        unsigned sr, sg, sb, sa;              \
+        (void)sa;                             \
+        getpixel;                             \
+        sr = DRAW_MUL(sr, r);                 \
+        sg = DRAW_MUL(sg, g);                 \
+        sb = DRAW_MUL(sb, b);                 \
+        setpixel;                             \
+    } while (0)
+
+#define DRAW_SETPIXEL_MUL(getpixel, setpixel)      \
+    do {                                           \
+        unsigned sr, sg, sb, sa;                   \
+        (void)sa;                                  \
+        getpixel;                                  \
+        sr = DRAW_MUL(sr, r) + DRAW_MUL(inva, sr); \
+        if (sr > 0xff)                             \
+            sr = 0xff;                             \
+        sg = DRAW_MUL(sg, g) + DRAW_MUL(inva, sg); \
+        if (sg > 0xff)                             \
+            sg = 0xff;                             \
+        sb = DRAW_MUL(sb, b) + DRAW_MUL(inva, sb); \
+        if (sb > 0xff)                             \
+            sb = 0xff;                             \
+        setpixel;                                  \
+    } while (0)
+
+#define DRAW_SETPIXELXY(x, y, type, bpp, op)                                     \
+    do {                                                                         \
+        type *pixel = (type *)((Uint8 *)dst->pixels + (y)*dst->pitch + (x)*bpp); \
+        op;                                                                      \
+    } while (0)
+
+/*
+ * Define draw operators for RGB555
+ */
+
+#define DRAW_SETPIXEL_RGB555 \
+    DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB555                           \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                        RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED_RGB555                           \
+    DRAW_SETPIXEL_BLEND_CLAMPED(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                                RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB555                           \
+    DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                      RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MOD_RGB555                           \
+    DRAW_SETPIXEL_MOD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                      RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MUL_RGB555                           \
+    DRAW_SETPIXEL_MUL(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
+                      RGB555_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB555)
+
+#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB555)
+
+#define DRAW_SETPIXELXY_BLEND_CLAMPED_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_CLAMPED_RGB555)
+
+#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB555)
+
+#define DRAW_SETPIXELXY_MOD_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB555)
+
+#define DRAW_SETPIXELXY_MUL_RGB555(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MUL_RGB555)
+
+/*
+ * Define draw operators for RGB565
+ */
+
+#define DRAW_SETPIXEL_RGB565 \
+    DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB565                           \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                        RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED_RGB565                           \
+    DRAW_SETPIXEL_BLEND_CLAMPED(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                                RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB565                           \
+    DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                      RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MOD_RGB565                           \
+    DRAW_SETPIXEL_MOD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                      RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MUL_RGB565                           \
+    DRAW_SETPIXEL_MUL(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
+                      RGB565_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB565)
+
+#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB565)
+
+#define DRAW_SETPIXELXY_BLEND_CLAMPED_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_CLAMPED_RGB565)
+
+#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB565)
+
+#define DRAW_SETPIXELXY_MOD_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB565)
+
+#define DRAW_SETPIXELXY_MUL_RGB565(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MUL_RGB565)
+
+/*
+ * Define draw operators for RGB888
+ */
+
+#define DRAW_SETPIXEL_XRGB8888 \
+    DRAW_SETPIXEL(XRGB8888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_XRGB8888                           \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_XRGB8888(*pixel, sr, sg, sb), \
+                        XRGB8888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED_XRGB8888                           \
+    DRAW_SETPIXEL_BLEND_CLAMPED(RGB_FROM_XRGB8888(*pixel, sr, sg, sb), \
+                                XRGB8888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_XRGB8888                           \
+    DRAW_SETPIXEL_ADD(RGB_FROM_XRGB8888(*pixel, sr, sg, sb), \
+                      XRGB8888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MOD_XRGB8888                           \
+    DRAW_SETPIXEL_MOD(RGB_FROM_XRGB8888(*pixel, sr, sg, sb), \
+                      XRGB8888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MUL_XRGB8888                           \
+    DRAW_SETPIXEL_MUL(RGB_FROM_XRGB8888(*pixel, sr, sg, sb), \
+                      XRGB8888_FROM_RGB(*pixel, sr, sg, sb))
+
+#define DRAW_SETPIXELXY_XRGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_XRGB8888)
+
+#define DRAW_SETPIXELXY_BLEND_XRGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_XRGB8888)
+
+#define DRAW_SETPIXELXY_BLEND_CLAMPED_XRGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_CLAMPED_XRGB8888)
+
+#define DRAW_SETPIXELXY_ADD_XRGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_XRGB8888)
+
+#define DRAW_SETPIXELXY_MOD_XRGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_XRGB8888)
+
+#define DRAW_SETPIXELXY_MUL_XRGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MUL_XRGB8888)
+
+/*
+ * Define draw operators for ARGB8888
+ */
+
+#define DRAW_SETPIXEL_ARGB8888 \
+    DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_ARGB8888                                \
+    DRAW_SETPIXEL_BLEND(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                        ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED_ARGB8888                                \
+    DRAW_SETPIXEL_BLEND_CLAMPED(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                                ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_ADD_ARGB8888                                \
+    DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_MOD_ARGB8888                                \
+    DRAW_SETPIXEL_MOD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_MUL_ARGB8888                                \
+    DRAW_SETPIXEL_MUL(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
+                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
+
+#define DRAW_SETPIXELXY_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ARGB8888)
+
+#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_ARGB8888)
+
+#define DRAW_SETPIXELXY_BLEND_CLAMPED_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_CLAMPED_ARGB8888)
+
+#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_ARGB8888)
+
+#define DRAW_SETPIXELXY_MOD_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_ARGB8888)
+
+#define DRAW_SETPIXELXY_MUL_ARGB8888(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MUL_ARGB8888)
+
+/*
+ * Define draw operators for general RGB
+ */
+
+#define DRAW_SETPIXEL_RGB \
+    DRAW_SETPIXEL(PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_RGB                                  \
+    DRAW_SETPIXEL_BLEND(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                        PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED_RGB                                  \
+    DRAW_SETPIXEL_BLEND_CLAMPED(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                                PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_ADD_RGB                                  \
+    DRAW_SETPIXEL_ADD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                      PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MOD_RGB                                  \
+    DRAW_SETPIXEL_MOD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                      PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXEL_MUL_RGB                                  \
+    DRAW_SETPIXEL_MUL(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
+                      PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
+
+#define DRAW_SETPIXELXY2_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB)
+
+#define DRAW_SETPIXELXY4_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB)
+
+#define DRAW_SETPIXELXY2_BLEND_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB)
+
+#define DRAW_SETPIXELXY2_BLEND_CLAMPED_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_CLAMPED_RGB)
+
+#define DRAW_SETPIXELXY4_BLEND_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB)
+
+#define DRAW_SETPIXELXY4_BLEND_CLAMPED_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_CLAMPED_RGB)
+
+#define DRAW_SETPIXELXY2_ADD_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB)
+
+#define DRAW_SETPIXELXY4_ADD_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB)
+
+#define DRAW_SETPIXELXY2_MOD_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB)
+
+#define DRAW_SETPIXELXY4_MOD_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGB)
+
+#define DRAW_SETPIXELXY2_MUL_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MUL_RGB)
+
+#define DRAW_SETPIXELXY4_MUL_RGB(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MUL_RGB)
+
+/*
+ * Define draw operators for general RGBA
+ */
+
+#define DRAW_SETPIXEL_RGBA \
+    DRAW_SETPIXEL(PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_RGBA                                      \
+    DRAW_SETPIXEL_BLEND(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                        PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_BLEND_CLAMPED_RGBA                                      \
+    DRAW_SETPIXEL_BLEND_CLAMPED(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                                PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_ADD_RGBA                                      \
+    DRAW_SETPIXEL_ADD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                      PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_MOD_RGBA                                      \
+    DRAW_SETPIXEL_MOD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                      PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXEL_MUL_RGBA                                      \
+    DRAW_SETPIXEL_MUL(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
+                      PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
+
+#define DRAW_SETPIXELXY4_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGBA)
+
+#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGBA)
+
+#define DRAW_SETPIXELXY4_BLEND_CLAMPED_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_CLAMPED_RGBA)
+
+#define DRAW_SETPIXELXY4_ADD_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGBA)
+
+#define DRAW_SETPIXELXY4_MOD_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGBA)
+
+#define DRAW_SETPIXELXY4_MUL_RGBA(x, y) \
+    DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MUL_RGBA)
+
+/*
+ * Define line drawing macro
+ */
+
+#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
+
+// Horizontal line
+#define HLINE(type, op, draw_end)                              \
+    {                                                          \
+        int length;                                            \
+        int pitch = (dst->pitch / dst->fmt->bytes_per_pixel); \
+        type *pixel;                                           \
+        if (x1 <= x2) {                                        \
+            pixel = (type *)dst->pixels + y1 * pitch + x1;     \
+            length = draw_end ? (x2 - x1 + 1) : (x2 - x1);     \
+        } else {                                               \
+            pixel = (type *)dst->pixels + y1 * pitch + x2;     \
+            if (!draw_end) {                                   \
+                ++pixel;                                       \
+            }                                                  \
+            length = draw_end ? (x1 - x2 + 1) : (x1 - x2);     \
+        }                                                      \
+        while (length--) {                                     \
+            op;                                                \
+            ++pixel;                                           \
+        }                                                      \
+    }
+
+// Vertical line
+#define VLINE(type, op, draw_end)                              \
+    {                                                          \
+        int length;                                            \
+        int pitch = (dst->pitch / dst->fmt->bytes_per_pixel); \
+        type *pixel;                                           \
+        if (y1 <= y2) {                                        \
+            pixel = (type *)dst->pixels + y1 * pitch + x1;     \
+            length = draw_end ? (y2 - y1 + 1) : (y2 - y1);     \
+        } else {                                               \
+            pixel = (type *)dst->pixels + y2 * pitch + x1;     \
+            if (!draw_end) {                                   \
+                pixel += pitch;                                \
+            }                                                  \
+            length = draw_end ? (y1 - y2 + 1) : (y1 - y2);     \
+        }                                                      \
+        while (length--) {                                     \
+            op;                                                \
+            pixel += pitch;                                    \
+        }                                                      \
+    }
+
+// Diagonal line
+#define DLINE(type, op, draw_end)                              \
+    {                                                          \
+        int length;                                            \
+        int pitch = (dst->pitch / dst->fmt->bytes_per_pixel); \
+        type *pixel;                                           \
+        if (y1 <= y2) {                                        \
+            pixel = (type *)dst->pixels + y1 * pitch + x1;     \
+            if (x1 <= x2) {                                    \
+                ++pitch;                                       \
+            } else {                                           \
+                --pitch;                                       \
+            }                                                  \
+            length = (y2 - y1);                                \
+        } else {                                               \
+            pixel = (type *)dst->pixels + y2 * pitch + x2;     \
+            if (x2 <= x1) {                                    \
+                ++pitch;                                       \
+            } else {                                           \
+                --pitch;                                       \
+            }                                                  \
+            if (!draw_end) {                                   \
+                pixel += pitch;                                \
+            }                                                  \
+            length = (y1 - y2);                                \
+        }                                                      \
+        if (draw_end) {                                        \
+            ++length;                                          \
+        }                                                      \
+        while (length--) {                                     \
+            op;                                                \
+            pixel += pitch;                                    \
+        }                                                      \
+    }
+
+// Bresenham's line algorithm
+#define BLINE(x1, y1, x2, y2, op, draw_end) \
+    {                                       \
+        int i, deltax, deltay, numpixels;   \
+        int d, dinc1, dinc2;                \
+        int x, xinc1, xinc2;                \
+        int y, yinc1, yinc2;                \
+                                            \
+        deltax = ABS(x2 - x1);              \
+        deltay = ABS(y2 - y1);              \
+                                            \
+        if (deltax >= deltay) {             \
+            numpixels = deltax + 1;         \
+            d = (2 * deltay) - deltax;      \
+            dinc1 = deltay * 2;             \
+            dinc2 = (deltay - deltax) * 2;  \
+            xinc1 = 1;                      \
+            xinc2 = 1;                      \
+            yinc1 = 0;                      \
+            yinc2 = 1;                      \
+        } else {                            \
+            numpixels = deltay + 1;         \
+            d = (2 * deltax) - deltay;      \
+            dinc1 = deltax * 2;             \
+            dinc2 = (deltax - deltay) * 2;  \
+            xinc1 = 0;                      \
+            xinc2 = 1;                      \
+            yinc1 = 1;                      \
+            yinc2 = 1;                      \
+        }                                   \
+                                            \
+        if (x1 > x2) {                      \
+            xinc1 = -xinc1;                 \
+            xinc2 = -xinc2;                 \
+        }                                   \
+        if (y1 > y2) {                      \
+            yinc1 = -yinc1;                 \
+            yinc2 = -yinc2;                 \
+        }                                   \
+                                            \
+        x = x1;                             \
+        y = y1;                             \
+                                            \
+        if (!draw_end) {                    \
+            --numpixels;                    \
+        }                                   \
+        for (i = 0; i < numpixels; ++i) {   \
+            op(x, y);                       \
+            if (d < 0) {                    \
+                d += dinc1;                 \
+                x += xinc1;                 \
+                y += yinc1;                 \
+            } else {                        \
+                d += dinc2;                 \
+                x += xinc2;                 \
+                y += yinc2;                 \
+            }                               \
+        }                                   \
+    }
+
+// Xiaolin Wu's line algorithm, based on Michael Abrash's implementation
+#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)                       \
+    {                                                                               \
+        Uint16 ErrorAdj, ErrorAcc;                                                  \
+        Uint16 ErrorAccTemp, Weighting;                                             \
+        int DeltaX, DeltaY, Temp, XDir;                                             \
+        unsigned r, g, b, a, inva;                                                  \
+                                                                                    \
+        /* Draw the initial pixel, which is always exactly intersected by           \
+           the line and so needs no weighting */                                    \
+        opaque_op(x1, y1);                                                          \
+                                                                                    \
+        /* Draw the final pixel, which is always exactly intersected by the line    \
+           and so needs no weighting */                                             \
+        if (draw_end) {                                                             \
+            opaque_op(x2, y2);                                                      \
+        }                                                                           \
+                                                                                    \
+        /* Make sure the line runs top to bottom */                                 \
+        if (y1 > y2) {                                                              \
+            Temp = y1;                                                              \
+            y1 = y2;                                                                \
+            y2 = Temp;                                                              \
+            Temp = x1;                                                              \
+            x1 = x2;                                                                \
+            x2 = Temp;                                                              \
+        }                                                                           \
+        DeltaY = y2 - y1;                                                           \
+                                                                                    \
+        if ((DeltaX = x2 - x1) >= 0) {                                              \
+            XDir = 1;                                                               \
+        } else {                                                                    \
+            XDir = -1;                                                              \
+            DeltaX = -DeltaX; /* make DeltaX positive */                            \
+        }                                                                           \
+                                                                                    \
+        /* line is not horizontal, diagonal, or vertical */                         \
+        ErrorAcc = 0; /* initialize the line error accumulator to 0 */              \
+                                                                                    \
+        /* Is this an X-major or Y-major line? */                                   \
+        if (DeltaY > DeltaX) {                                                      \
+            /* Y-major line; calculate 16-bit fixed-point fractional part of a      \
+              pixel that X advances each time Y advances 1 pixel, truncating the    \
+              result so that we won't overrun the endpoint along the X axis */      \
+            ErrorAdj = ((unsigned long)DeltaX << 16) / (unsigned long)DeltaY;       \
+            /* Draw all pixels other than the first and last */                     \
+            while (--DeltaY) {                                                      \
+                ErrorAccTemp = ErrorAcc; /* remember current accumulated error */   \
+                ErrorAcc += ErrorAdj;    /* calculate error for next pixel */       \
+                if (ErrorAcc <= ErrorAccTemp) {                                     \
+                    /* The error accumulator turned over, so advance the X coord */ \
+                    x1 += XDir;                                                     \
+                }                                                                   \
+                y1++; /* Y-major, so always advance Y */                            \
+                /* The IntensityBits most significant bits of ErrorAcc give us the  \
+                 intensity weighting for this pixel, and the complement of the      \
+                 weighting for the paired pixel */                                  \
+                Weighting = ErrorAcc >> 8;                                          \
+                {                                                                   \
+                    a = DRAW_MUL(_a, (Weighting ^ 255));                            \
+                    r = DRAW_MUL(_r, a);                                            \
+                    g = DRAW_MUL(_g, a);                                            \
+                    b = DRAW_MUL(_b, a);                                            \
+                    inva = (a ^ 0xFF);                                              \
+                    blend_op(x1, y1);                                               \
+                }                                                                   \
+                {                                                                   \
+                    a = DRAW_MUL(_a, Weighting);                                    \
+                    r = DRAW_MUL(_r, a);                                            \
+                    g = DRAW_MUL(_g, a);                                            \
+                    b = DRAW_MUL(_b, a);                                            \
+                    inva = (a ^ 0xFF);                                              \
+                    blend_op(x1 + XDir, y1);                                        \
+                }                                                                   \
+            }                                                                       \
+        } else {                                                                    \
+            /* X-major line; calculate 16-bit fixed-point fractional part of a      \
+               pixel that Y advances each time X advances 1 pixel, truncating the   \
+               result to avoid overrunning the endpoint along the X axis */         \
+            ErrorAdj = ((unsigned long)DeltaY << 16) / (unsigned long)DeltaX;       \
+            /* Draw all pixels other than the first and last */                     \
+            while (--DeltaX) {                                                      \
+                ErrorAccTemp = ErrorAcc; /* remember current accumulated error */   \
+                ErrorAcc += ErrorAdj;    /* calculate error for next pixel */       \
+                if (ErrorAcc <= ErrorAccTemp) {                                     \
+                    /* The error accumulator turned over, so advance the Y coord */ \
+                    y1++;                                                           \
+                }                                                                   \
+                x1 += XDir; /* X-major, so always advance X */                      \
+                /* The IntensityBits most significant bits of ErrorAcc give us the  \
+                  intensity weighting for this pixel, and the complement of the     \
+                  weighting for the paired pixel */                                 \
+                Weighting = ErrorAcc >> 8;                                          \
+                {                                                                   \
+                    a = DRAW_MUL(_a, (Weighting ^ 255));                            \
+                    r = DRAW_MUL(_r, a);                                            \
+                    g = DRAW_MUL(_g, a);                                            \
+                    b = DRAW_MUL(_b, a);                                            \
+                    inva = (a ^ 0xFF);                                              \
+                    blend_op(x1, y1);                                               \
+                }                                                                   \
+                {                                                                   \
+                    a = DRAW_MUL(_a, Weighting);                                    \
+                    r = DRAW_MUL(_r, a);                                            \
+                    g = DRAW_MUL(_g, a);                                            \
+                    b = DRAW_MUL(_b, a);                                            \
+                    inva = (a ^ 0xFF);                                              \
+                    blend_op(x1, y1 + 1);                                           \
+                }                                                                   \
+            }                                                                       \
+        }                                                                           \
+    }
+
+#ifdef AA_LINES
+#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+    WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
+#else
+#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
+    BLINE(x1, y1, x2, y2, opaque_op, draw_end)
+#endif
+
+/*
+ * Define fill rect macro
+ */
+
+#define FILLRECT(type, op)                                             \
+    do {                                                               \
+        int width = rect->w;                                           \
+        int height = rect->h;                                          \
+        int pitch = (dst->pitch / dst->fmt->bytes_per_pixel); \
+        int skip = pitch - width;                                      \
+        type *pixel = (type *)dst->pixels + rect->y * pitch + rect->x; \
+        while (height--) {                                             \
+            {                                                          \
+                int n = (width + 3) / 4;                               \
+                switch (width & 3) {                                   \
+                case 0:                                                \
+                    do {                                               \
+                        op;                                            \
+                        pixel++;                                       \
+                        SDL_FALLTHROUGH;                               \
+                    case 3:                                            \
+                        op;                                            \
+                        pixel++;                                       \
+                        SDL_FALLTHROUGH;                               \
+                    case 2:                                            \
+                        op;                                            \
+                        pixel++;                                       \
+                        SDL_FALLTHROUGH;                               \
+                    case 1:                                            \
+                        op;                                            \
+                        pixel++;                                       \
+                    } while (--n > 0);                                 \
+                }                                                      \
+            }                                                          \
+            pixel += skip;                                             \
+        }                                                              \
+    } while (0)
diff --git a/SDL-3.2.8/src/render/software/SDL_drawline.c b/SDL-3.2.8/src/render/software/SDL_drawline.c
new file mode 100644
index 0000000..59ba268
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_drawline.c
@@ -0,0 +1,199 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include "SDL_draw.h"
+#include "SDL_drawline.h"
+#include "SDL_drawpoint.h"
+
+static void SDL_DrawLine1(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color,
+                          bool draw_end)
+{
+    if (y1 == y2) {
+        int length;
+        int pitch = (dst->pitch / dst->fmt->bytes_per_pixel);
+        Uint8 *pixel;
+        if (x1 <= x2) {
+            pixel = (Uint8 *)dst->pixels + y1 * pitch + x1;
+            length = draw_end ? (x2 - x1 + 1) : (x2 - x1);
+        } else {
+            pixel = (Uint8 *)dst->pixels + y1 * pitch + x2;
+            if (!draw_end) {
+                ++pixel;
+            }
+            length = draw_end ? (x1 - x2 + 1) : (x1 - x2);
+        }
+        SDL_memset(pixel, color, length);
+    } else if (x1 == x2) {
+        VLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        DLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
+    } else {
+        BLINE(x1, y1, x2, y2, DRAW_FASTSETPIXELXY1, draw_end);
+    }
+}
+
+static void SDL_DrawLine2(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color,
+                          bool draw_end)
+{
+    if (y1 == y2) {
+        HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+    } else if (x1 == x2) {
+        VLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        DLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
+    } else {
+        Uint8 _r, _g, _b, _a;
+        const SDL_PixelFormatDetails *fmt = dst->fmt;
+        SDL_GetRGBA(color, fmt, dst->palette, &_r, &_g, &_b, &_a);
+        if (fmt->Rmask == 0x7C00) {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB555,
+                   draw_end);
+        } else if (fmt->Rmask == 0xF800) {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB565,
+                   draw_end);
+        } else {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY2_BLEND_RGB,
+                   draw_end);
+        }
+    }
+}
+
+static void SDL_DrawLine4(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color,
+                          bool draw_end)
+{
+    if (y1 == y2) {
+        HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+    } else if (x1 == x2) {
+        VLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+    } else if (ABS(x1 - x2) == ABS(y1 - y2)) {
+        DLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
+    } else {
+        Uint8 _r, _g, _b, _a;
+        const SDL_PixelFormatDetails *fmt = dst->fmt;
+        SDL_GetRGBA(color, fmt, dst->palette, &_r, &_g, &_b, &_a);
+        if (fmt->Rmask == 0x00FF0000) {
+            if (!fmt->Amask) {
+                AALINE(x1, y1, x2, y2,
+                       DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_XRGB8888,
+                       draw_end);
+            } else {
+                AALINE(x1, y1, x2, y2,
+                       DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_ARGB8888,
+                       draw_end);
+            }
+        } else {
+            AALINE(x1, y1, x2, y2,
+                   DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY4_BLEND_RGB,
+                   draw_end);
+        }
+    }
+}
+
+typedef void (*DrawLineFunc)(SDL_Surface *dst,
+                             int x1, int y1, int x2, int y2,
+                             Uint32 color, bool draw_end);
+
+static DrawLineFunc SDL_CalculateDrawLineFunc(const SDL_PixelFormatDetails *fmt)
+{
+    switch (fmt->bytes_per_pixel) {
+    case 1:
+        if (fmt->bits_per_pixel < 8) {
+            break;
+        }
+        return SDL_DrawLine1;
+    case 2:
+        return SDL_DrawLine2;
+    case 4:
+        return SDL_DrawLine4;
+    }
+    return NULL;
+}
+
+bool SDL_DrawLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color)
+{
+    DrawLineFunc func;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_DrawLine(): dst");
+    }
+
+    func = SDL_CalculateDrawLineFunc(dst->fmt);
+    if (!func) {
+        return SDL_SetError("SDL_DrawLine(): Unsupported surface format");
+    }
+
+    // Perform clipping
+    // FIXME: We don't actually want to clip, as it may change line slope
+    if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+        return true;
+    }
+
+    func(dst, x1, y1, x2, y2, color, true);
+    return true;
+}
+
+bool SDL_DrawLines(SDL_Surface *dst, const SDL_Point *points, int count, Uint32 color)
+{
+    int i;
+    int x1, y1;
+    int x2, y2;
+    bool draw_end;
+    DrawLineFunc func;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_DrawLines(): dst");
+    }
+
+    func = SDL_CalculateDrawLineFunc(dst->fmt);
+    if (!func) {
+        return SDL_SetError("SDL_DrawLines(): Unsupported surface format");
+    }
+
+    for (i = 1; i < count; ++i) {
+        x1 = points[i - 1].x;
+        y1 = points[i - 1].y;
+        x2 = points[i].x;
+        y2 = points[i].y;
+
+        // Perform clipping
+        // FIXME: We don't actually want to clip, as it may change line slope
+        if (!SDL_GetRectAndLineIntersection(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
+            continue;
+        }
+
+        // Draw the end if the whole line is a single point or it was clipped
+        draw_end = ((x1 == x2) && (y1 == y2)) || (x2 != points[i].x || y2 != points[i].y);
+
+        func(dst, x1, y1, x2, y2, color, draw_end);
+    }
+    if (points[0].x != points[count - 1].x || points[0].y != points[count - 1].y) {
+        SDL_DrawPoint(dst, points[count - 1].x, points[count - 1].y, color);
+    }
+    return true;
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_drawline.h b/SDL-3.2.8/src/render/software/SDL_drawline.h
new file mode 100644
index 0000000..e88b2c3
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_drawline.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_drawline_h_
+#define SDL_drawline_h_
+
+#include "SDL_internal.h"
+
+extern bool SDL_DrawLine(SDL_Surface *dst, int x1, int y1, int x2, int y2, Uint32 color);
+extern bool SDL_DrawLines(SDL_Surface *dst, const SDL_Point *points, int count, Uint32 color);
+
+#endif // SDL_drawline_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_drawpoint.c b/SDL-3.2.8/src/render/software/SDL_drawpoint.c
new file mode 100644
index 0000000..5aa28b3
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_drawpoint.c
@@ -0,0 +1,108 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include "SDL_draw.h"
+#include "SDL_drawpoint.h"
+
+bool SDL_DrawPoint(SDL_Surface *dst, int x, int y, Uint32 color)
+{
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_DrawPoint(): dst");
+    }
+
+    // This function doesn't work on surfaces < 8 bpp
+    if (dst->fmt->bits_per_pixel < 8) {
+        return SDL_SetError("SDL_DrawPoint(): Unsupported surface format");
+    }
+
+    // Perform clipping
+    if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
+        x >= (dst->clip_rect.x + dst->clip_rect.w) ||
+        y >= (dst->clip_rect.y + dst->clip_rect.h)) {
+        return true;
+    }
+
+    switch (dst->fmt->bytes_per_pixel) {
+    case 1:
+        DRAW_FASTSETPIXELXY1(x, y);
+        break;
+    case 2:
+        DRAW_FASTSETPIXELXY2(x, y);
+        break;
+    case 3:
+        return SDL_Unsupported();
+    case 4:
+        DRAW_FASTSETPIXELXY4(x, y);
+        break;
+    }
+    return true;
+}
+
+bool SDL_DrawPoints(SDL_Surface *dst, const SDL_Point *points, int count, Uint32 color)
+{
+    int minx, miny;
+    int maxx, maxy;
+    int i;
+    int x, y;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("SDL_DrawPoints(): dst");
+    }
+
+    // This function doesn't work on surfaces < 8 bpp
+    if (dst->fmt->bits_per_pixel < 8) {
+        return SDL_SetError("SDL_DrawPoints(): Unsupported surface format");
+    }
+
+    minx = dst->clip_rect.x;
+    maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
+    miny = dst->clip_rect.y;
+    maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
+
+    for (i = 0; i < count; ++i) {
+        x = points[i].x;
+        y = points[i].y;
+
+        if (x < minx || x > maxx || y < miny || y > maxy) {
+            continue;
+        }
+
+        switch (dst->fmt->bytes_per_pixel) {
+        case 1:
+            DRAW_FASTSETPIXELXY1(x, y);
+            break;
+        case 2:
+            DRAW_FASTSETPIXELXY2(x, y);
+            break;
+        case 3:
+            return SDL_Unsupported();
+        case 4:
+            DRAW_FASTSETPIXELXY4(x, y);
+            break;
+        }
+    }
+    return true;
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_drawpoint.h b/SDL-3.2.8/src/render/software/SDL_drawpoint.h
new file mode 100644
index 0000000..631e7aa
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_drawpoint.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_drawpoint_h_
+#define SDL_drawpoint_h_
+
+#include "SDL_internal.h"
+
+extern bool SDL_DrawPoint(SDL_Surface *dst, int x, int y, Uint32 color);
+extern bool SDL_DrawPoints(SDL_Surface *dst, const SDL_Point *points, int count, Uint32 color);
+
+#endif // SDL_drawpoint_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_render_sw.c b/SDL-3.2.8/src/render/software/SDL_render_sw.c
new file mode 100644
index 0000000..2231724
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_render_sw.c
@@ -0,0 +1,1202 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include "../SDL_sysrender.h"
+#include "SDL_render_sw_c.h"
+
+#include "SDL_draw.h"
+#include "SDL_blendfillrect.h"
+#include "SDL_blendline.h"
+#include "SDL_blendpoint.h"
+#include "SDL_drawline.h"
+#include "SDL_drawpoint.h"
+#include "SDL_rotate.h"
+#include "SDL_triangle.h"
+#include "../../video/SDL_pixels_c.h"
+
+// SDL surface based renderer implementation
+
+typedef struct
+{
+    const SDL_Rect *viewport;
+    const SDL_Rect *cliprect;
+    bool surface_cliprect_dirty;
+    SDL_Color color;
+} SW_DrawStateCache;
+
+typedef struct
+{
+    SDL_Surface *surface;
+    SDL_Surface *window;
+} SW_RenderData;
+
+static SDL_Surface *SW_ActivateRenderer(SDL_Renderer *renderer)
+{
+    SW_RenderData *data = (SW_RenderData *)renderer->internal;
+
+    if (!data->surface) {
+        data->surface = data->window;
+    }
+    if (!data->surface) {
+        SDL_Surface *surface = SDL_GetWindowSurface(renderer->window);
+        if (surface) {
+            data->surface = data->window = surface;
+        }
+    }
+    return data->surface;
+}
+
+static void SW_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    SW_RenderData *data = (SW_RenderData *)renderer->internal;
+
+    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
+        data->surface = NULL;
+        data->window = NULL;
+    }
+}
+
+static bool SW_GetOutputSize(SDL_Renderer *renderer, int *w, int *h)
+{
+    SW_RenderData *data = (SW_RenderData *)renderer->internal;
+
+    if (data->surface) {
+        if (w) {
+            *w = data->surface->w;
+        }
+        if (h) {
+            *h = data->surface->h;
+        }
+        return true;
+    }
+
+    if (renderer->window) {
+        SDL_GetWindowSizeInPixels(renderer->window, w, h);
+        return true;
+    }
+
+    return SDL_SetError("Software renderer doesn't have an output surface");
+}
+
+static bool SW_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    SDL_Surface *surface = SDL_CreateSurface(texture->w, texture->h, texture->format);
+    Uint8 r, g, b, a;
+
+    if (!SDL_SurfaceValid(surface)) {
+        return SDL_SetError("Cannot create surface");
+    }
+    texture->internal = surface;
+    r = (Uint8)SDL_roundf(SDL_clamp(texture->color.r, 0.0f, 1.0f) * 255.0f);
+    g = (Uint8)SDL_roundf(SDL_clamp(texture->color.g, 0.0f, 1.0f) * 255.0f);
+    b = (Uint8)SDL_roundf(SDL_clamp(texture->color.b, 0.0f, 1.0f) * 255.0f);
+    a = (Uint8)SDL_roundf(SDL_clamp(texture->color.a, 0.0f, 1.0f) * 255.0f);
+    SDL_SetSurfaceColorMod(surface, r, g, b);
+    SDL_SetSurfaceAlphaMod(surface, a);
+    SDL_SetSurfaceBlendMode(surface, texture->blendMode);
+
+    /* Only RLE encode textures without an alpha channel since the RLE coder
+     * discards the color values of pixels with an alpha value of zero.
+     */
+    if (texture->access == SDL_TEXTUREACCESS_STATIC && !SDL_ISPIXELFORMAT_ALPHA(surface->format)) {
+        SDL_SetSurfaceRLE(surface, 1);
+    }
+
+    return true;
+}
+
+static bool SW_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                            const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    SDL_Surface *surface = (SDL_Surface *)texture->internal;
+    Uint8 *src, *dst;
+    int row;
+    size_t length;
+
+    if (SDL_MUSTLOCK(surface)) {
+        if (!SDL_LockSurface(surface)) {
+            return false;
+        }
+    }
+    src = (Uint8 *)pixels;
+    dst = (Uint8 *)surface->pixels +
+          rect->y * surface->pitch +
+          rect->x * surface->fmt->bytes_per_pixel;
+    length = (size_t)rect->w * surface->fmt->bytes_per_pixel;
+    for (row = 0; row < rect->h; ++row) {
+        SDL_memcpy(dst, src, length);
+        src += pitch;
+        dst += surface->pitch;
+    }
+    if (SDL_MUSTLOCK(surface)) {
+        SDL_UnlockSurface(surface);
+    }
+    return true;
+}
+
+static bool SW_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                          const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    SDL_Surface *surface = (SDL_Surface *)texture->internal;
+
+    *pixels =
+        (void *)((Uint8 *)surface->pixels + rect->y * surface->pitch +
+                 rect->x * surface->fmt->bytes_per_pixel);
+    *pitch = surface->pitch;
+    return true;
+}
+
+static void SW_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+}
+
+static void SW_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+}
+
+static bool SW_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    SW_RenderData *data = (SW_RenderData *)renderer->internal;
+
+    if (texture) {
+        data->surface = (SDL_Surface *)texture->internal;
+    } else {
+        data->surface = data->window;
+    }
+    return true;
+}
+
+static bool SW_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool SW_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    SDL_Point *verts = (SDL_Point *)SDL_AllocateRenderVertices(renderer, count * sizeof(SDL_Point), 0, &cmd->data.draw.first);
+    int i;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    for (i = 0; i < count; i++, verts++, points++) {
+        verts->x = (int)points->x;
+        verts->y = (int)points->y;
+    }
+
+    return true;
+}
+
+static bool SW_QueueFillRects(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
+{
+    SDL_Rect *verts = (SDL_Rect *)SDL_AllocateRenderVertices(renderer, count * sizeof(SDL_Rect), 0, &cmd->data.draw.first);
+    int i;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+
+    for (i = 0; i < count; i++, verts++, rects++) {
+        verts->x = (int)rects->x;
+        verts->y = (int)rects->y;
+        verts->w = SDL_max((int)rects->w, 1);
+        verts->h = SDL_max((int)rects->h, 1);
+    }
+
+    return true;
+}
+
+static bool SW_QueueCopy(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                        const SDL_FRect *srcrect, const SDL_FRect *dstrect)
+{
+    SDL_Rect *verts = (SDL_Rect *)SDL_AllocateRenderVertices(renderer, 2 * sizeof(SDL_Rect), 0, &cmd->data.draw.first);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = 1;
+
+    verts->x = (int)srcrect->x;
+    verts->y = (int)srcrect->y;
+    verts->w = (int)srcrect->w;
+    verts->h = (int)srcrect->h;
+    verts++;
+
+    verts->x = (int)dstrect->x;
+    verts->y = (int)dstrect->y;
+    verts->w = (int)dstrect->w;
+    verts->h = (int)dstrect->h;
+
+    return true;
+}
+
+typedef struct CopyExData
+{
+    SDL_Rect srcrect;
+    SDL_Rect dstrect;
+    double angle;
+    SDL_FPoint center;
+    SDL_FlipMode flip;
+    float scale_x;
+    float scale_y;
+} CopyExData;
+
+static bool SW_QueueCopyEx(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                          const SDL_FRect *srcrect, const SDL_FRect *dstrect,
+                          const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y)
+{
+    CopyExData *verts = (CopyExData *)SDL_AllocateRenderVertices(renderer, sizeof(CopyExData), 0, &cmd->data.draw.first);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = 1;
+
+    verts->srcrect.x = (int)srcrect->x;
+    verts->srcrect.y = (int)srcrect->y;
+    verts->srcrect.w = (int)srcrect->w;
+    verts->srcrect.h = (int)srcrect->h;
+    verts->dstrect.x = (int)dstrect->x;
+    verts->dstrect.y = (int)dstrect->y;
+    verts->dstrect.w = (int)dstrect->w;
+    verts->dstrect.h = (int)dstrect->h;
+    verts->angle = angle;
+    SDL_copyp(&verts->center, center);
+    verts->flip = flip;
+    verts->scale_x = scale_x;
+    verts->scale_y = scale_y;
+
+    return true;
+}
+
+static bool Blit_to_Screen(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *surface, SDL_Rect *dstrect,
+                          float scale_x, float scale_y, SDL_ScaleMode scaleMode)
+{
+    bool result;
+    // Renderer scaling, if needed
+    if (scale_x != 1.0f || scale_y != 1.0f) {
+        SDL_Rect r;
+        r.x = (int)((float)dstrect->x * scale_x);
+        r.y = (int)((float)dstrect->y * scale_y);
+        r.w = (int)((float)dstrect->w * scale_x);
+        r.h = (int)((float)dstrect->h * scale_y);
+        result = SDL_BlitSurfaceScaled(src, srcrect, surface, &r, scaleMode);
+    } else {
+        result = SDL_BlitSurface(src, srcrect, surface, dstrect);
+    }
+    return result;
+}
+
+static bool SW_RenderCopyEx(SDL_Renderer *renderer, SDL_Surface *surface, SDL_Texture *texture,
+                            const SDL_Rect *srcrect, const SDL_Rect *final_rect,
+                            const double angle, const SDL_FPoint *center, const SDL_FlipMode flip, float scale_x, float scale_y)
+{
+    SDL_Surface *src = (SDL_Surface *)texture->internal;
+    SDL_Rect tmp_rect;
+    SDL_Surface *src_clone, *src_rotated, *src_scaled;
+    SDL_Surface *mask = NULL, *mask_rotated = NULL;
+    bool result = true;
+    SDL_BlendMode blendmode;
+    Uint8 alphaMod, rMod, gMod, bMod;
+    int applyModulation = false;
+    int blitRequired = false;
+    int isOpaque = false;
+
+    if (!SDL_SurfaceValid(surface)) {
+        return false;
+    }
+
+    tmp_rect.x = 0;
+    tmp_rect.y = 0;
+    tmp_rect.w = final_rect->w;
+    tmp_rect.h = final_rect->h;
+
+    /* It is possible to encounter an RLE encoded surface here and locking it is
+     * necessary because this code is going to access the pixel buffer directly.
+     */
+    if (SDL_MUSTLOCK(src)) {
+        if (!SDL_LockSurface(src)) {
+            return false;
+        }
+    }
+
+    /* Clone the source surface but use its pixel buffer directly.
+     * The original source surface must be treated as read-only.
+     */
+    src_clone = SDL_CreateSurfaceFrom(src->w, src->h, src->format, src->pixels, src->pitch);
+    if (!src_clone) {
+        if (SDL_MUSTLOCK(src)) {
+            SDL_UnlockSurface(src);
+        }
+        return false;
+    }
+
+    SDL_GetSurfaceBlendMode(src, &blendmode);
+    SDL_GetSurfaceAlphaMod(src, &alphaMod);
+    SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
+
+    // SDLgfx_rotateSurface only accepts 32-bit surfaces with a 8888 layout. Everything else has to be converted.
+    if (src->fmt->bits_per_pixel != 32 || SDL_PIXELLAYOUT(src->format) != SDL_PACKEDLAYOUT_8888 || !SDL_ISPIXELFORMAT_ALPHA(src->format)) {
+        blitRequired = true;
+    }
+
+    // If scaling and cropping is necessary, it has to be taken care of before the rotation.
+    if (!(srcrect->w == final_rect->w && srcrect->h == final_rect->h && srcrect->x == 0 && srcrect->y == 0)) {
+        blitRequired = true;
+    }
+
+    // srcrect is not selecting the whole src surface, so cropping is needed
+    if (!(srcrect->w == src->w && srcrect->h == src->h && srcrect->x == 0 && srcrect->y == 0)) {
+        blitRequired = true;
+    }
+
+    // The color and alpha modulation has to be applied before the rotation when using the NONE, MOD or MUL blend modes.
+    if ((blendmode == SDL_BLENDMODE_NONE || blendmode == SDL_BLENDMODE_MOD || blendmode == SDL_BLENDMODE_MUL) && (alphaMod & rMod & gMod & bMod) != 255) {
+        applyModulation = true;
+        SDL_SetSurfaceAlphaMod(src_clone, alphaMod);
+        SDL_SetSurfaceColorMod(src_clone, rMod, gMod, bMod);
+    }
+
+    // Opaque surfaces are much easier to handle with the NONE blend mode.
+    if (blendmode == SDL_BLENDMODE_NONE && !SDL_ISPIXELFORMAT_ALPHA(src->format) && alphaMod == 255) {
+        isOpaque = true;
+    }
+
+    /* The NONE blend mode requires a mask for non-opaque surfaces. This mask will be used
+     * to clear the pixels in the destination surface. The other steps are explained below.
+     */
+    if (blendmode == SDL_BLENDMODE_NONE && !isOpaque) {
+        mask = SDL_CreateSurface(final_rect->w, final_rect->h, SDL_PIXELFORMAT_ARGB8888);
+        if (!mask) {
+            result = false;
+        } else {
+            SDL_SetSurfaceBlendMode(mask, SDL_BLENDMODE_MOD);
+        }
+    }
+
+    /* Create a new surface should there be a format mismatch or if scaling, cropping,
+     * or modulation is required. It's possible to use the source surface directly otherwise.
+     */
+    if (result && (blitRequired || applyModulation)) {
+        SDL_Rect scale_rect = tmp_rect;
+        src_scaled = SDL_CreateSurface(final_rect->w, final_rect->h, SDL_PIXELFORMAT_ARGB8888);
+        if (!src_scaled) {
+            result = false;
+        } else {
+            SDL_SetSurfaceBlendMode(src_clone, SDL_BLENDMODE_NONE);
+            result = SDL_BlitSurfaceScaled(src_clone, srcrect, src_scaled, &scale_rect, texture->scaleMode);
+            SDL_DestroySurface(src_clone);
+            src_clone = src_scaled;
+            src_scaled = NULL;
+        }
+    }
+
+    // SDLgfx_rotateSurface is going to make decisions depending on the blend mode.
+    SDL_SetSurfaceBlendMode(src_clone, blendmode);
+
+    if (result) {
+        SDL_Rect rect_dest;
+        double cangle, sangle;
+
+        SDLgfx_rotozoomSurfaceSizeTrig(tmp_rect.w, tmp_rect.h, angle, center,
+                                       &rect_dest, &cangle, &sangle);
+        src_rotated = SDLgfx_rotateSurface(src_clone, angle,
+                                           (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? 0 : 1, flip & SDL_FLIP_HORIZONTAL, flip & SDL_FLIP_VERTICAL,
+                                           &rect_dest, cangle, sangle, center);
+        if (!src_rotated) {
+            result = false;
+        }
+        if (result && mask) {
+            // The mask needed for the NONE blend mode gets rotated with the same parameters.
+            mask_rotated = SDLgfx_rotateSurface(mask, angle,
+                                                false, 0, 0,
+                                                &rect_dest, cangle, sangle, center);
+            if (!mask_rotated) {
+                result = false;
+            }
+        }
+        if (result) {
+
+            tmp_rect.x = final_rect->x + rect_dest.x;
+            tmp_rect.y = final_rect->y + rect_dest.y;
+            tmp_rect.w = rect_dest.w;
+            tmp_rect.h = rect_dest.h;
+
+            /* The NONE blend mode needs some special care with non-opaque surfaces.
+             * Other blend modes or opaque surfaces can be blitted directly.
+             */
+            if (blendmode != SDL_BLENDMODE_NONE || isOpaque) {
+                if (applyModulation == false) {
+                    // If the modulation wasn't already applied, make it happen now.
+                    SDL_SetSurfaceAlphaMod(src_rotated, alphaMod);
+                    SDL_SetSurfaceColorMod(src_rotated, rMod, gMod, bMod);
+                }
+                // Renderer scaling, if needed
+                result = Blit_to_Screen(src_rotated, NULL, surface, &tmp_rect, scale_x, scale_y, texture->scaleMode);
+            } else {
+                /* The NONE blend mode requires three steps to get the pixels onto the destination surface.
+                 * First, the area where the rotated pixels will be blitted to get set to zero.
+                 * This is accomplished by simply blitting a mask with the NONE blend mode.
+                 * The colorkey set by the rotate function will discard the correct pixels.
+                 */
+                SDL_Rect mask_rect = tmp_rect;
+                SDL_SetSurfaceBlendMode(mask_rotated, SDL_BLENDMODE_NONE);
+                // Renderer scaling, if needed
+                result = Blit_to_Screen(mask_rotated, NULL, surface, &mask_rect, scale_x, scale_y, texture->scaleMode);
+                if (result) {
+                    /* The next step copies the alpha value. This is done with the BLEND blend mode and
+                     * by modulating the source colors with 0. Since the destination is all zeros, this
+                     * will effectively set the destination alpha to the source alpha.
+                     */
+                    SDL_SetSurfaceColorMod(src_rotated, 0, 0, 0);
+                    mask_rect = tmp_rect;
+                    // Renderer scaling, if needed
+                    result = Blit_to_Screen(src_rotated, NULL, surface, &mask_rect, scale_x, scale_y, texture->scaleMode);
+                    if (result) {
+                        /* The last step gets the color values in place. The ADD blend mode simply adds them to
+                         * the destination (where the color values are all zero). However, because the ADD blend
+                         * mode modulates the colors with the alpha channel, a surface without an alpha mask needs
+                         * to be created. This makes all source pixels opaque and the colors get copied correctly.
+                         */
+                        SDL_Surface *src_rotated_rgb = SDL_CreateSurfaceFrom(src_rotated->w, src_rotated->h, src_rotated->format, src_rotated->pixels, src_rotated->pitch);
+                        if (!src_rotated_rgb) {
+                            result = false;
+                        } else {
+                            SDL_SetSurfaceBlendMode(src_rotated_rgb, SDL_BLENDMODE_ADD);
+                            // Renderer scaling, if needed
+                            result = Blit_to_Screen(src_rotated_rgb, NULL, surface, &tmp_rect, scale_x, scale_y, texture->scaleMode);
+                            SDL_DestroySurface(src_rotated_rgb);
+                        }
+                    }
+                }
+                SDL_DestroySurface(mask_rotated);
+            }
+            if (src_rotated) {
+                SDL_DestroySurface(src_rotated);
+            }
+        }
+    }
+
+    if (SDL_MUSTLOCK(src)) {
+        SDL_UnlockSurface(src);
+    }
+    if (mask) {
+        SDL_DestroySurface(mask);
+    }
+    if (src_clone) {
+        SDL_DestroySurface(src_clone);
+    }
+    return result;
+}
+
+typedef struct GeometryFillData
+{
+    SDL_Point dst;
+    SDL_Color color;
+} GeometryFillData;
+
+typedef struct GeometryCopyData
+{
+    SDL_Point src;
+    SDL_Point dst;
+    SDL_Color color;
+} GeometryCopyData;
+
+static bool SW_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                            const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                            int num_vertices, const void *indices, int num_indices, int size_indices,
+                            float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    void *verts;
+    size_t sz = texture ? sizeof(GeometryCopyData) : sizeof(GeometryFillData);
+    const float color_scale = cmd->data.draw.color_scale;
+
+    verts = SDL_AllocateRenderVertices(renderer, count * sz, 0, &cmd->data.draw.first);
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        GeometryCopyData *ptr = (GeometryCopyData *)verts;
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor col_;
+            float *uv_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+
+            uv_ = (float *)((char *)uv + j * uv_stride);
+
+            ptr->src.x = (int)(uv_[0] * texture->w);
+            ptr->src.y = (int)(uv_[1] * texture->h);
+
+            ptr->dst.x = (int)(xy_[0] * scale_x);
+            ptr->dst.y = (int)(xy_[1] * scale_y);
+            trianglepoint_2_fixedpoint(&ptr->dst);
+
+            ptr->color.r = (Uint8)SDL_roundf(SDL_clamp(col_.r * color_scale, 0.0f, 1.0f) * 255.0f);
+            ptr->color.g = (Uint8)SDL_roundf(SDL_clamp(col_.g * color_scale, 0.0f, 1.0f) * 255.0f);
+            ptr->color.b = (Uint8)SDL_roundf(SDL_clamp(col_.b * color_scale, 0.0f, 1.0f) * 255.0f);
+            ptr->color.a = (Uint8)SDL_roundf(SDL_clamp(col_.a, 0.0f, 1.0f) * 255.0f);
+
+            ptr++;
+        }
+    } else {
+        GeometryFillData *ptr = (GeometryFillData *)verts;
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+
+            ptr->dst.x = (int)(xy_[0] * scale_x);
+            ptr->dst.y = (int)(xy_[1] * scale_y);
+            trianglepoint_2_fixedpoint(&ptr->dst);
+
+            ptr->color.r = (Uint8)SDL_roundf(SDL_clamp(col_.r * color_scale, 0.0f, 1.0f) * 255.0f);
+            ptr->color.g = (Uint8)SDL_roundf(SDL_clamp(col_.g * color_scale, 0.0f, 1.0f) * 255.0f);
+            ptr->color.b = (Uint8)SDL_roundf(SDL_clamp(col_.b * color_scale, 0.0f, 1.0f) * 255.0f);
+            ptr->color.a = (Uint8)SDL_roundf(SDL_clamp(col_.a, 0.0f, 1.0f) * 255.0f);
+
+            ptr++;
+        }
+    }
+    return true;
+}
+
+static void PrepTextureForCopy(const SDL_RenderCommand *cmd, SW_DrawStateCache *drawstate)
+{
+    const Uint8 r = drawstate->color.r;
+    const Uint8 g = drawstate->color.g;
+    const Uint8 b = drawstate->color.b;
+    const Uint8 a = drawstate->color.a;
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+    SDL_Texture *texture = cmd->data.draw.texture;
+    SDL_Surface *surface = (SDL_Surface *)texture->internal;
+    const bool colormod = ((r & g & b) != 0xFF);
+    const bool alphamod = (a != 0xFF);
+    const bool blending = ((blend == SDL_BLENDMODE_ADD) || (blend == SDL_BLENDMODE_MOD) || (blend == SDL_BLENDMODE_MUL));
+
+    if (colormod || alphamod || blending) {
+        SDL_SetSurfaceRLE(surface, 0);
+    }
+
+    // !!! FIXME: we can probably avoid some of these calls.
+    SDL_SetSurfaceColorMod(surface, r, g, b);
+    SDL_SetSurfaceAlphaMod(surface, a);
+    SDL_SetSurfaceBlendMode(surface, blend);
+}
+
+static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
+{
+    if (drawstate->surface_cliprect_dirty) {
+        const SDL_Rect *viewport = drawstate->viewport;
+        const SDL_Rect *cliprect = drawstate->cliprect;
+        SDL_assert_release(viewport != NULL); // the higher level should have forced a SDL_RENDERCMD_SETVIEWPORT
+
+        if (cliprect && viewport) {
+            SDL_Rect clip_rect;
+            clip_rect.x = cliprect->x + viewport->x;
+            clip_rect.y = cliprect->y + viewport->y;
+            clip_rect.w = cliprect->w;
+            clip_rect.h = cliprect->h;
+            SDL_GetRectIntersection(viewport, &clip_rect, &clip_rect);
+            SDL_SetSurfaceClipRect(surface, &clip_rect);
+        } else {
+            SDL_SetSurfaceClipRect(surface, drawstate->viewport);
+        }
+        drawstate->surface_cliprect_dirty = false;
+    }
+}
+
+static void SW_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    // SW_DrawStateCache only lives during SW_RunCommandQueue, so nothing to do here!
+}
+
+
+static bool SW_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    SDL_Surface *surface = SW_ActivateRenderer(renderer);
+    SW_DrawStateCache drawstate;
+
+    if (!SDL_SurfaceValid(surface)) {
+        return false;
+    }
+
+    drawstate.viewport = NULL;
+    drawstate.cliprect = NULL;
+    drawstate.surface_cliprect_dirty = true;
+    drawstate.color.r = 0;
+    drawstate.color.g = 0;
+    drawstate.color.b = 0;
+    drawstate.color.a = 0;
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            drawstate.color.r = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.r * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            drawstate.color.g = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.g * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            drawstate.color.b = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.b * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            drawstate.color.a = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.a, 0.0f, 1.0f) * 255.0f);
+            break;
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            drawstate.viewport = &cmd->data.viewport.rect;
+            drawstate.surface_cliprect_dirty = true;
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            drawstate.cliprect = cmd->data.cliprect.enabled ? &cmd->data.cliprect.rect : NULL;
+            drawstate.surface_cliprect_dirty = true;
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            const Uint8 r = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.r * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 g = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.g * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 b = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.b * cmd->data.color.color_scale, 0.0f, 1.0f) * 255.0f);
+            const Uint8 a = (Uint8)SDL_roundf(SDL_clamp(cmd->data.color.color.a, 0.0f, 1.0f) * 255.0f);
+            // By definition the clear ignores the clip rect
+            SDL_SetSurfaceClipRect(surface, NULL);
+            SDL_FillSurfaceRect(surface, NULL, SDL_MapSurfaceRGBA(surface, r, g, b, a));
+            drawstate.surface_cliprect_dirty = true;
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            const Uint8 r = drawstate.color.r;
+            const Uint8 g = drawstate.color.g;
+            const Uint8 b = drawstate.color.b;
+            const Uint8 a = drawstate.color.a;
+            const int count = (int)cmd->data.draw.count;
+            SDL_Point *verts = (SDL_Point *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const SDL_BlendMode blend = cmd->data.draw.blend;
+            SetDrawState(surface, &drawstate);
+
+            // Apply viewport
+            if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                int i;
+                for (i = 0; i < count; i++) {
+                    verts[i].x += drawstate.viewport->x;
+                    verts[i].y += drawstate.viewport->y;
+                }
+            }
+
+            if (blend == SDL_BLENDMODE_NONE) {
+                SDL_DrawPoints(surface, verts, count, SDL_MapSurfaceRGBA(surface, r, g, b, a));
+            } else {
+                SDL_BlendPoints(surface, verts, count, blend, r, g, b, a);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            const Uint8 r = drawstate.color.r;
+            const Uint8 g = drawstate.color.g;
+            const Uint8 b = drawstate.color.b;
+            const Uint8 a = drawstate.color.a;
+            const int count = (int)cmd->data.draw.count;
+            SDL_Point *verts = (SDL_Point *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const SDL_BlendMode blend = cmd->data.draw.blend;
+            SetDrawState(surface, &drawstate);
+
+            // Apply viewport
+            if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                int i;
+                for (i = 0; i < count; i++) {
+                    verts[i].x += drawstate.viewport->x;
+                    verts[i].y += drawstate.viewport->y;
+                }
+            }
+
+            if (blend == SDL_BLENDMODE_NONE) {
+                SDL_DrawLines(surface, verts, count, SDL_MapSurfaceRGBA(surface, r, g, b, a));
+            } else {
+                SDL_BlendLines(surface, verts, count, blend, r, g, b, a);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS:
+        {
+            const Uint8 r = drawstate.color.r;
+            const Uint8 g = drawstate.color.g;
+            const Uint8 b = drawstate.color.b;
+            const Uint8 a = drawstate.color.a;
+            const int count = (int)cmd->data.draw.count;
+            SDL_Rect *verts = (SDL_Rect *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const SDL_BlendMode blend = cmd->data.draw.blend;
+            SetDrawState(surface, &drawstate);
+
+            // Apply viewport
+            if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                int i;
+                for (i = 0; i < count; i++) {
+                    verts[i].x += drawstate.viewport->x;
+                    verts[i].y += drawstate.viewport->y;
+                }
+            }
+
+            if (blend == SDL_BLENDMODE_NONE) {
+                SDL_FillSurfaceRects(surface, verts, count, SDL_MapSurfaceRGBA(surface, r, g, b, a));
+            } else {
+                SDL_BlendFillRects(surface, verts, count, blend, r, g, b, a);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_COPY:
+        {
+            SDL_Rect *verts = (SDL_Rect *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const SDL_Rect *srcrect = verts;
+            SDL_Rect *dstrect = verts + 1;
+            SDL_Texture *texture = cmd->data.draw.texture;
+            SDL_Surface *src = (SDL_Surface *)texture->internal;
+
+            SetDrawState(surface, &drawstate);
+
+            PrepTextureForCopy(cmd, &drawstate);
+
+            // Apply viewport
+            if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                dstrect->x += drawstate.viewport->x;
+                dstrect->y += drawstate.viewport->y;
+            }
+
+            if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) {
+                SDL_BlitSurface(src, srcrect, surface, dstrect);
+            } else {
+                /* If scaling is ever done, permanently disable RLE (which doesn't support scaling)
+                 * to avoid potentially frequent RLE encoding/decoding.
+                 */
+                SDL_SetSurfaceRLE(surface, 0);
+
+                // Prevent to do scaling + clipping on viewport boundaries as it may lose proportion
+                if (dstrect->x < 0 || dstrect->y < 0 || dstrect->x + dstrect->w > surface->w || dstrect->y + dstrect->h > surface->h) {
+                    SDL_Surface *tmp = SDL_CreateSurface(dstrect->w, dstrect->h, src->format);
+                    // Scale to an intermediate surface, then blit
+                    if (tmp) {
+                        SDL_Rect r;
+                        SDL_BlendMode blendmode;
+                        Uint8 alphaMod, rMod, gMod, bMod;
+
+                        SDL_GetSurfaceBlendMode(src, &blendmode);
+                        SDL_GetSurfaceAlphaMod(src, &alphaMod);
+                        SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
+
+                        r.x = 0;
+                        r.y = 0;
+                        r.w = dstrect->w;
+                        r.h = dstrect->h;
+
+                        SDL_SetSurfaceBlendMode(src, SDL_BLENDMODE_NONE);
+                        SDL_SetSurfaceColorMod(src, 255, 255, 255);
+                        SDL_SetSurfaceAlphaMod(src, 255);
+
+                        SDL_BlitSurfaceScaled(src, srcrect, tmp, &r, texture->scaleMode);
+
+                        SDL_SetSurfaceColorMod(tmp, rMod, gMod, bMod);
+                        SDL_SetSurfaceAlphaMod(tmp, alphaMod);
+                        SDL_SetSurfaceBlendMode(tmp, blendmode);
+
+                        SDL_BlitSurface(tmp, NULL, surface, dstrect);
+                        SDL_DestroySurface(tmp);
+                        // No need to set back r/g/b/a/blendmode to 'src' since it's done in PrepTextureForCopy()
+                    }
+                } else {
+                    SDL_BlitSurfaceScaled(src, srcrect, surface, dstrect, texture->scaleMode);
+                }
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_COPY_EX:
+        {
+            CopyExData *copydata = (CopyExData *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            SetDrawState(surface, &drawstate);
+            PrepTextureForCopy(cmd, &drawstate);
+
+            // Apply viewport
+            if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                copydata->dstrect.x += drawstate.viewport->x;
+                copydata->dstrect.y += drawstate.viewport->y;
+            }
+
+            SW_RenderCopyEx(renderer, surface, cmd->data.draw.texture, &copydata->srcrect,
+                            &copydata->dstrect, copydata->angle, &copydata->center, copydata->flip,
+                            copydata->scale_x, copydata->scale_y);
+            break;
+        }
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            int i;
+            SDL_Rect *verts = (SDL_Rect *)(((Uint8 *)vertices) + cmd->data.draw.first);
+            const int count = (int)cmd->data.draw.count;
+            SDL_Texture *texture = cmd->data.draw.texture;
+            const SDL_BlendMode blend = cmd->data.draw.blend;
+
+            SetDrawState(surface, &drawstate);
+
+            if (texture) {
+                SDL_Surface *src = (SDL_Surface *)texture->internal;
+
+                GeometryCopyData *ptr = (GeometryCopyData *)verts;
+
+                PrepTextureForCopy(cmd, &drawstate);
+
+                // Apply viewport
+                if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                    SDL_Point vp;
+                    vp.x = drawstate.viewport->x;
+                    vp.y = drawstate.viewport->y;
+                    trianglepoint_2_fixedpoint(&vp);
+                    for (i = 0; i < count; i++) {
+                        ptr[i].dst.x += vp.x;
+                        ptr[i].dst.y += vp.y;
+                    }
+                }
+
+                for (i = 0; i < count; i += 3, ptr += 3) {
+                    SDL_SW_BlitTriangle(
+                        src,
+                        &(ptr[0].src), &(ptr[1].src), &(ptr[2].src),
+                        surface,
+                        &(ptr[0].dst), &(ptr[1].dst), &(ptr[2].dst),
+                        ptr[0].color, ptr[1].color, ptr[2].color,
+                        cmd->data.draw.texture_address_mode);
+                }
+            } else {
+                GeometryFillData *ptr = (GeometryFillData *)verts;
+
+                // Apply viewport
+                if (drawstate.viewport && (drawstate.viewport->x || drawstate.viewport->y)) {
+                    SDL_Point vp;
+                    vp.x = drawstate.viewport->x;
+                    vp.y = drawstate.viewport->y;
+                    trianglepoint_2_fixedpoint(&vp);
+                    for (i = 0; i < count; i++) {
+                        ptr[i].dst.x += vp.x;
+                        ptr[i].dst.y += vp.y;
+                    }
+                }
+
+                for (i = 0; i < count; i += 3, ptr += 3) {
+                    SDL_SW_FillTriangle(surface, &(ptr[0].dst), &(ptr[1].dst), &(ptr[2].dst), blend, ptr[0].color, ptr[1].color, ptr[2].color);
+                }
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+
+    return true;
+}
+
+static SDL_Surface *SW_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    SDL_Surface *surface = SW_ActivateRenderer(renderer);
+    void *pixels;
+
+    if (!SDL_SurfaceValid(surface)) {
+        return NULL;
+    }
+
+    /* NOTE: The rect is already adjusted according to the viewport by
+     * SDL_RenderReadPixels.
+     */
+
+    if (rect->x < 0 || rect->x + rect->w > surface->w ||
+        rect->y < 0 || rect->y + rect->h > surface->h) {
+        SDL_SetError("Tried to read outside of surface bounds");
+        return NULL;
+    }
+
+    pixels = (void *)((Uint8 *)surface->pixels +
+                      rect->y * surface->pitch +
+                      rect->x * surface->fmt->bytes_per_pixel);
+
+    return SDL_DuplicatePixels(rect->w, rect->h, surface->format, SDL_COLORSPACE_SRGB, pixels, surface->pitch);
+}
+
+static bool SW_RenderPresent(SDL_Renderer *renderer)
+{
+    SDL_Window *window = renderer->window;
+
+    if (!window) {
+        return false;
+    }
+    return SDL_UpdateWindowSurface(window);
+}
+
+static void SW_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    SDL_Surface *surface = (SDL_Surface *)texture->internal;
+
+    SDL_DestroySurface(surface);
+}
+
+static void SW_DestroyRenderer(SDL_Renderer *renderer)
+{
+    SDL_Window *window = renderer->window;
+    SW_RenderData *data = (SW_RenderData *)renderer->internal;
+
+    if (window) {
+        SDL_DestroyWindowSurface(window);
+    }
+    SDL_free(data);
+}
+
+static void SW_SelectBestFormats(SDL_Renderer *renderer, SDL_PixelFormat format)
+{
+    // Prefer the format used by the framebuffer by default.
+    SDL_AddSupportedTextureFormat(renderer, format);
+
+    switch (format) {
+    case SDL_PIXELFORMAT_XRGB4444:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB4444);
+        break;
+    case SDL_PIXELFORMAT_XBGR4444:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR4444);
+        break;
+    case SDL_PIXELFORMAT_ARGB4444:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB4444);
+        break;
+    case SDL_PIXELFORMAT_ABGR4444:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR4444);
+        break;
+
+    case SDL_PIXELFORMAT_XRGB1555:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB1555);
+        break;
+    case SDL_PIXELFORMAT_XBGR1555:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR1555);
+        break;
+    case SDL_PIXELFORMAT_ARGB1555:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB1555);
+        break;
+    case SDL_PIXELFORMAT_ABGR1555:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR1555);
+        break;
+
+    case SDL_PIXELFORMAT_XRGB8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+        break;
+    case SDL_PIXELFORMAT_RGBX8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA8888);
+        break;
+    case SDL_PIXELFORMAT_XBGR8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+        break;
+    case SDL_PIXELFORMAT_BGRX8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRA8888);
+        break;
+    case SDL_PIXELFORMAT_ARGB8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
+        break;
+    case SDL_PIXELFORMAT_RGBA8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBX8888);
+        break;
+    case SDL_PIXELFORMAT_ABGR8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR8888);
+        break;
+    case SDL_PIXELFORMAT_BGRA8888:
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRX8888);
+        break;
+    default:
+        break;
+    }
+
+    /* Ensure that we always have a SDL_PACKEDLAYOUT_8888 format. Having a matching component order increases the
+     * chances of getting a fast path for blitting.
+     */
+    if (SDL_ISPIXELFORMAT_PACKED(format)) {
+        if (SDL_PIXELLAYOUT(format) != SDL_PACKEDLAYOUT_8888) {
+            switch (SDL_PIXELORDER(format)) {
+            case SDL_PACKEDORDER_BGRX:
+            case SDL_PACKEDORDER_BGRA:
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRX8888);
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGRA8888);
+                break;
+            case SDL_PACKEDORDER_RGBX:
+            case SDL_PACKEDORDER_RGBA:
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBX8888);
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA8888);
+                break;
+            case SDL_PACKEDORDER_XBGR:
+            case SDL_PACKEDORDER_ABGR:
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XBGR8888);
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+                break;
+            case SDL_PACKEDORDER_XRGB:
+            case SDL_PACKEDORDER_ARGB:
+            default:
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
+                SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+                break;
+            }
+        }
+    } else {
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_XRGB8888);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+    }
+}
+
+bool SW_CreateRendererForSurface(SDL_Renderer *renderer, SDL_Surface *surface, SDL_PropertiesID create_props)
+{
+    SW_RenderData *data;
+
+    if (!SDL_SurfaceValid(surface)) {
+        return SDL_InvalidParamError("surface");
+    }
+
+    renderer->software = true;
+
+    data = (SW_RenderData *)SDL_calloc(1, sizeof(*data));
+    if (!data) {
+        return false;
+    }
+    data->surface = surface;
+    data->window = surface;
+
+    renderer->WindowEvent = SW_WindowEvent;
+    renderer->GetOutputSize = SW_GetOutputSize;
+    renderer->CreateTexture = SW_CreateTexture;
+    renderer->UpdateTexture = SW_UpdateTexture;
+    renderer->LockTexture = SW_LockTexture;
+    renderer->UnlockTexture = SW_UnlockTexture;
+    renderer->SetTextureScaleMode = SW_SetTextureScaleMode;
+    renderer->SetRenderTarget = SW_SetRenderTarget;
+    renderer->QueueSetViewport = SW_QueueNoOp;
+    renderer->QueueSetDrawColor = SW_QueueNoOp;
+    renderer->QueueDrawPoints = SW_QueueDrawPoints;
+    renderer->QueueDrawLines = SW_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueFillRects = SW_QueueFillRects;
+    renderer->QueueCopy = SW_QueueCopy;
+    renderer->QueueCopyEx = SW_QueueCopyEx;
+    renderer->QueueGeometry = SW_QueueGeometry;
+    renderer->InvalidateCachedState = SW_InvalidateCachedState;
+    renderer->RunCommandQueue = SW_RunCommandQueue;
+    renderer->RenderReadPixels = SW_RenderReadPixels;
+    renderer->RenderPresent = SW_RenderPresent;
+    renderer->DestroyTexture = SW_DestroyTexture;
+    renderer->DestroyRenderer = SW_DestroyRenderer;
+    renderer->internal = data;
+    SW_InvalidateCachedState(renderer);
+
+    renderer->name = SW_RenderDriver.name;
+
+    SW_SelectBestFormats(renderer, surface->format);
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    return true;
+}
+
+static bool SW_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    // Set the vsync hint based on our flags, if it's not already set
+    const char *hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC);
+    const bool no_hint_set = (!hint || !*hint);
+
+    if (no_hint_set) {
+        if (SDL_GetBooleanProperty(create_props, SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 0)) {
+            SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");
+        } else {
+            SDL_SetHint(SDL_HINT_RENDER_VSYNC, "0");
+        }
+    }
+
+    SDL_Surface *surface = SDL_GetWindowSurface(window);
+
+    // Reset the vsync hint if we set it above
+    if (no_hint_set) {
+        SDL_SetHint(SDL_HINT_RENDER_VSYNC, "");
+    }
+
+    if (!SDL_SurfaceValid(surface)) {
+        return false;
+    }
+
+    return SW_CreateRendererForSurface(renderer, surface, create_props);
+}
+
+SDL_RenderDriver SW_RenderDriver = {
+    SW_CreateRenderer, SDL_SOFTWARE_RENDERER
+};
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_render_sw_c.h b/SDL-3.2.8/src/render/software/SDL_render_sw_c.h
new file mode 100644
index 0000000..40d3c3a
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_render_sw_c.h
@@ -0,0 +1,27 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_render_sw_c_h_
+#define SDL_render_sw_c_h_
+
+extern bool SW_CreateRendererForSurface(SDL_Renderer *renderer, SDL_Surface *surface, SDL_PropertiesID create_props);
+
+#endif // SDL_render_sw_c_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_rotate.c b/SDL-3.2.8/src/render/software/SDL_rotate.c
new file mode 100644
index 0000000..516ba8a
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_rotate.c
@@ -0,0 +1,612 @@
+/*
+
+SDL_rotate.c: rotates 32bit or 8bit surfaces
+
+Shamelessly stolen from SDL_gfx by Andreas Schiffler. Original copyright follows:
+
+Copyright (C) 2001-2011  Andreas Schiffler
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+   1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+   3. This notice may not be removed or altered from any source
+   distribution.
+
+Andreas Schiffler -- aschiffler at ferzkopp dot net
+
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#if defined(SDL_PLATFORM_WINDOWS)
+#include "../../core/windows/SDL_windows.h"
+#endif
+
+#include "SDL_rotate.h"
+
+#include "../../video/SDL_surface_c.h"
+
+// ---- Internally used structures
+
+/**
+A 32 bit RGBA pixel.
+*/
+typedef struct tColorRGBA
+{
+    Uint8 r;
+    Uint8 g;
+    Uint8 b;
+    Uint8 a;
+} tColorRGBA;
+
+/**
+A 8bit Y/palette pixel.
+*/
+typedef struct tColorY
+{
+    Uint8 y;
+} tColorY;
+
+/**
+Number of guard rows added to destination surfaces.
+
+This is a simple but effective workaround for observed issues.
+These rows allocate extra memory and are then hidden from the surface.
+Rows are added to the end of destination surfaces when they are allocated.
+This catches any potential overflows which seem to happen with
+just the right src image dimensions and scale/rotation and can lead
+to a situation where the program can segfault.
+*/
+#define GUARD_ROWS (2)
+
+/**
+Returns colorkey info for a surface
+*/
+static Uint32 get_colorkey(SDL_Surface *src)
+{
+    Uint32 key = 0;
+    if (SDL_SurfaceHasColorKey(src)) {
+        SDL_GetSurfaceColorKey(src, &key);
+    }
+    return key;
+}
+
+// rotate (sx, sy) by (angle, center) into (dx, dy)
+static void rotate(double sx, double sy, double sinangle, double cosangle, const SDL_FPoint *center, double *dx, double *dy)
+{
+    sx -= center->x;
+    sy -= center->y;
+
+    *dx = cosangle * sx - sinangle * sy;
+    *dy = sinangle * sx + cosangle * sy;
+
+    *dx += center->x;
+    *dy += center->y;
+}
+
+/**
+Internal target surface sizing function for rotations with trig result return.
+
+\param width The source surface width.
+\param height The source surface height.
+\param angle The angle to rotate in degrees.
+\param center The center of ratation
+\param rect_dest Bounding box of rotated rectangle
+\param cangle The sine of the angle
+\param sangle The cosine of the angle
+
+*/
+void SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, const SDL_FPoint *center,
+                                    SDL_Rect *rect_dest, double *cangle, double *sangle)
+{
+    int minx, maxx, miny, maxy;
+    double radangle;
+    double x0, x1, x2, x3;
+    double y0, y1, y2, y3;
+    double sinangle;
+    double cosangle;
+
+    radangle = angle * (SDL_PI_D / 180.0);
+    sinangle = SDL_sin(radangle);
+    cosangle = SDL_cos(radangle);
+
+    /*
+     * Determine destination width and height by rotating a source box, at pixel center
+     */
+    rotate(0.5, 0.5, sinangle, cosangle, center, &x0, &y0);
+    rotate(width - 0.5, 0.5, sinangle, cosangle, center, &x1, &y1);
+    rotate(0.5, height - 0.5, sinangle, cosangle, center, &x2, &y2);
+    rotate(width - 0.5, height - 0.5, sinangle, cosangle, center, &x3, &y3);
+
+    minx = (int)SDL_floor(SDL_min(SDL_min(x0, x1), SDL_min(x2, x3)));
+    maxx = (int)SDL_ceil(SDL_max(SDL_max(x0, x1), SDL_max(x2, x3)));
+
+    miny = (int)SDL_floor(SDL_min(SDL_min(y0, y1), SDL_min(y2, y3)));
+    maxy = (int)SDL_ceil(SDL_max(SDL_max(y0, y1), SDL_max(y2, y3)));
+
+    rect_dest->w = maxx - minx;
+    rect_dest->h = maxy - miny;
+    rect_dest->x = minx;
+    rect_dest->y = miny;
+
+    // reverse the angle because our rotations are clockwise
+    *sangle = -sinangle;
+    *cangle = cosangle;
+
+    {
+        // The trig code below gets the wrong size (due to FP inaccuracy?) when angle is a multiple of 90 degrees
+        int angle90 = (int)(angle / 90);
+        if (angle90 == angle / 90) { // if the angle is a multiple of 90 degrees
+            angle90 %= 4;
+            if (angle90 < 0) {
+                angle90 += 4; // 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg
+            }
+
+            if (angle90 & 1) {
+                rect_dest->w = height;
+                rect_dest->h = width;
+                *cangle = 0;
+                *sangle = angle90 == 1 ? -1 : 1; // reversed because our rotations are clockwise
+            } else {
+                rect_dest->w = width;
+                rect_dest->h = height;
+                *cangle = angle90 == 0 ? 1 : -1;
+                *sangle = 0;
+            }
+        }
+    }
+}
+
+// Computes source pointer X/Y increments for a rotation that's a multiple of 90 degrees.
+static void computeSourceIncrements90(SDL_Surface *src, int bpp, int angle, int flipx, int flipy,
+                                      int *sincx, int *sincy, int *signx, int *signy)
+{
+    int pitch = flipy ? -src->pitch : src->pitch;
+    if (flipx) {
+        bpp = -bpp;
+    }
+    switch (angle) { // 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg
+    case 0:
+        *sincx = bpp;
+        *sincy = pitch - src->w * *sincx;
+        *signx = *signy = 1;
+        break;
+    case 1:
+        *sincx = -pitch;
+        *sincy = bpp - *sincx * src->h;
+        *signx = 1;
+        *signy = -1;
+        break;
+    case 2:
+        *sincx = -bpp;
+        *sincy = -src->w * *sincx - pitch;
+        *signx = *signy = -1;
+        break;
+    case 3:
+    default:
+        *sincx = pitch;
+        *sincy = -*sincx * src->h - bpp;
+        *signx = -1;
+        *signy = 1;
+        break;
+    }
+    if (flipx) {
+        *signx = -*signx;
+    }
+    if (flipy) {
+        *signy = -*signy;
+    }
+}
+
+// Performs a relatively fast rotation/flip when the angle is a multiple of 90 degrees.
+#define TRANSFORM_SURFACE_90(pixelType)                                                                     \
+    int dy, dincy = dst->pitch - dst->w * sizeof(pixelType), sincx, sincy, signx, signy;                    \
+    Uint8 *sp = (Uint8 *)src->pixels, *dp = (Uint8 *)dst->pixels, *de;                                      \
+                                                                                                            \
+    computeSourceIncrements90(src, sizeof(pixelType), angle, flipx, flipy, &sincx, &sincy, &signx, &signy); \
+    if (signx < 0)                                                                                          \
+        sp += (src->w - 1) * sizeof(pixelType);                                                             \
+    if (signy < 0)                                                                                          \
+        sp += (src->h - 1) * src->pitch;                                                                    \
+                                                                                                            \
+    for (dy = 0; dy < dst->h; sp += sincy, dp += dincy, dy++) {                                             \
+        if (sincx == sizeof(pixelType)) { /* if advancing src and dest equally, use SDL_memcpy */           \
+            SDL_memcpy(dp, sp, dst->w * sizeof(pixelType));                                                 \
+            sp += dst->w * sizeof(pixelType);                                                               \
+            dp += dst->w * sizeof(pixelType);                                                               \
+        } else {                                                                                            \
+            for (de = dp + dst->w * sizeof(pixelType); dp != de; sp += sincx, dp += sizeof(pixelType)) {    \
+                *(pixelType *)dp = *(pixelType *)sp;                                                        \
+            }                                                                                               \
+        }                                                                                                   \
+    }
+
+static void transformSurfaceRGBA90(SDL_Surface *src, SDL_Surface *dst, int angle, int flipx, int flipy)
+{
+    TRANSFORM_SURFACE_90(tColorRGBA);
+}
+
+static void transformSurfaceY90(SDL_Surface *src, SDL_Surface *dst, int angle, int flipx, int flipy)
+{
+    TRANSFORM_SURFACE_90(tColorY);
+}
+
+#undef TRANSFORM_SURFACE_90
+
+/**
+Internal 32 bit rotozoomer with optional anti-aliasing.
+
+Rotates and zooms 32 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control
+parameters by scanning the destination surface and applying optionally anti-aliasing
+by bilinear interpolation.
+Assumes src and dst surfaces are of 32 bit depth.
+Assumes dst surface was allocated with the correct dimensions.
+
+\param src Source surface.
+\param dst Destination surface.
+\param isin Integer version of sine of angle.
+\param icos Integer version of cosine of angle.
+\param flipx Flag indicating horizontal mirroring should be applied.
+\param flipy Flag indicating vertical mirroring should be applied.
+\param smooth Flag indicating anti-aliasing should be used.
+\param rect_dest destination coordinates
+\param center true center.
+*/
+static void transformSurfaceRGBA(SDL_Surface *src, SDL_Surface *dst, int isin, int icos,
+                                 int flipx, int flipy, int smooth,
+                                 const SDL_Rect *rect_dest,
+                                 const SDL_FPoint *center)
+{
+    int sw, sh;
+    int cx, cy;
+    tColorRGBA c00, c01, c10, c11, cswap;
+    tColorRGBA *pc, *sp;
+    int gap;
+    const int fp_half = (1 << 15);
+
+    /*
+     * Variable setup
+     */
+    sw = src->w - 1;
+    sh = src->h - 1;
+    pc = (tColorRGBA *)dst->pixels;
+    gap = dst->pitch - dst->w * 4;
+    cx = (int)(center->x * 65536.0);
+    cy = (int)(center->y * 65536.0);
+
+    /*
+     * Switch between interpolating and non-interpolating code
+     */
+    if (smooth) {
+        int y;
+        for (y = 0; y < dst->h; y++) {
+            int x;
+            double src_x = ((double)rect_dest->x + 0 + 0.5 - center->x);
+            double src_y = ((double)rect_dest->y + y + 0.5 - center->y);
+            int sdx = (int)((icos * src_x - isin * src_y) + cx - fp_half);
+            int sdy = (int)((isin * src_x + icos * src_y) + cy - fp_half);
+            for (x = 0; x < dst->w; x++) {
+                int dx = (sdx >> 16);
+                int dy = (sdy >> 16);
+                if (flipx) {
+                    dx = sw - dx;
+                }
+                if (flipy) {
+                    dy = sh - dy;
+                }
+                if ((dx > -1) && (dy > -1) && (dx < (src->w - 1)) && (dy < (src->h - 1))) {
+                    int ex, ey;
+                    int t1, t2;
+                    sp = (tColorRGBA *)((Uint8 *)src->pixels + src->pitch * dy) + dx;
+                    c00 = *sp;
+                    sp += 1;
+                    c01 = *sp;
+                    sp += (src->pitch / 4);
+                    c11 = *sp;
+                    sp -= 1;
+                    c10 = *sp;
+                    if (flipx) {
+                        cswap = c00;
+                        c00 = c01;
+                        c01 = cswap;
+                        cswap = c10;
+                        c10 = c11;
+                        c11 = cswap;
+                    }
+                    if (flipy) {
+                        cswap = c00;
+                        c00 = c10;
+                        c10 = cswap;
+                        cswap = c01;
+                        c01 = c11;
+                        c11 = cswap;
+                    }
+                    /*
+                     * Interpolate colors
+                     */
+                    ex = (sdx & 0xffff);
+                    ey = (sdy & 0xffff);
+                    t1 = ((((c01.r - c00.r) * ex) >> 16) + c00.r) & 0xff;
+                    t2 = ((((c11.r - c10.r) * ex) >> 16) + c10.r) & 0xff;
+                    pc->r = (Uint8)((((t2 - t1) * ey) >> 16) + t1);
+                    t1 = ((((c01.g - c00.g) * ex) >> 16) + c00.g) & 0xff;
+                    t2 = ((((c11.g - c10.g) * ex) >> 16) + c10.g) & 0xff;
+                    pc->g = (Uint8)((((t2 - t1) * ey) >> 16) + t1);
+                    t1 = ((((c01.b - c00.b) * ex) >> 16) + c00.b) & 0xff;
+                    t2 = ((((c11.b - c10.b) * ex) >> 16) + c10.b) & 0xff;
+                    pc->b = (Uint8)((((t2 - t1) * ey) >> 16) + t1);
+                    t1 = ((((c01.a - c00.a) * ex) >> 16) + c00.a) & 0xff;
+                    t2 = ((((c11.a - c10.a) * ex) >> 16) + c10.a) & 0xff;
+                    pc->a = (Uint8)((((t2 - t1) * ey) >> 16) + t1);
+                }
+                sdx += icos;
+                sdy += isin;
+                pc++;
+            }
+            pc = (tColorRGBA *)((Uint8 *)pc + gap);
+        }
+    } else {
+        int y;
+        for (y = 0; y < dst->h; y++) {
+            int x;
+            double src_x = ((double)rect_dest->x + 0 + 0.5 - center->x);
+            double src_y = ((double)rect_dest->y + y + 0.5 - center->y);
+            int sdx = (int)((icos * src_x - isin * src_y) + cx - fp_half);
+            int sdy = (int)((isin * src_x + icos * src_y) + cy - fp_half);
+            for (x = 0; x < dst->w; x++) {
+                int dx = (sdx >> 16);
+                int dy = (sdy >> 16);
+                if ((unsigned)dx < (unsigned)src->w && (unsigned)dy < (unsigned)src->h) {
+                    if (flipx) {
+                        dx = sw - dx;
+                    }
+                    if (flipy) {
+                        dy = sh - dy;
+                    }
+                    *pc = *((tColorRGBA *)((Uint8 *)src->pixels + src->pitch * dy) + dx);
+                }
+                sdx += icos;
+                sdy += isin;
+                pc++;
+            }
+            pc = (tColorRGBA *)((Uint8 *)pc + gap);
+        }
+    }
+}
+
+/**
+
+Rotates and zooms 8 bit palette/Y 'src' surface to 'dst' surface without smoothing.
+
+Rotates and zooms 8 bit RGBA/ABGR 'src' surface to 'dst' surface based on the control
+parameters by scanning the destination surface.
+Assumes src and dst surfaces are of 8 bit depth.
+Assumes dst surface was allocated with the correct dimensions.
+
+\param src Source surface.
+\param dst Destination surface.
+\param isin Integer version of sine of angle.
+\param icos Integer version of cosine of angle.
+\param flipx Flag indicating horizontal mirroring should be applied.
+\param flipy Flag indicating vertical mirroring should be applied.
+\param rect_dest destination coordinates
+\param center true center.
+*/
+static void transformSurfaceY(SDL_Surface *src, SDL_Surface *dst, int isin, int icos, int flipx, int flipy,
+                              const SDL_Rect *rect_dest,
+                              const SDL_FPoint *center)
+{
+    int sw, sh;
+    int cx, cy;
+    tColorY *pc;
+    int gap;
+    const int fp_half = (1 << 15);
+    int y;
+
+    /*
+     * Variable setup
+     */
+    sw = src->w - 1;
+    sh = src->h - 1;
+    pc = (tColorY *)dst->pixels;
+    gap = dst->pitch - dst->w;
+    cx = (int)(center->x * 65536.0);
+    cy = (int)(center->y * 65536.0);
+
+    /*
+     * Clear surface to colorkey
+     */
+    SDL_memset(pc, (int)(get_colorkey(src) & 0xff), (size_t)dst->pitch * dst->h);
+    /*
+     * Iterate through destination surface
+     */
+    for (y = 0; y < dst->h; y++) {
+        int x;
+        double src_x = ((double)rect_dest->x + 0 + 0.5 - center->x);
+        double src_y = ((double)rect_dest->y + y + 0.5 - center->y);
+        int sdx = (int)((icos * src_x - isin * src_y) + cx - fp_half);
+        int sdy = (int)((isin * src_x + icos * src_y) + cy - fp_half);
+        for (x = 0; x < dst->w; x++) {
+            int dx = (sdx >> 16);
+            int dy = (sdy >> 16);
+            if ((unsigned)dx < (unsigned)src->w && (unsigned)dy < (unsigned)src->h) {
+                if (flipx) {
+                    dx = sw - dx;
+                }
+                if (flipy) {
+                    dy = sh - dy;
+                }
+                *pc = *((tColorY *)src->pixels + src->pitch * dy + dx);
+            }
+            sdx += icos;
+            sdy += isin;
+            pc++;
+        }
+        pc += gap;
+    }
+}
+
+/**
+Rotates and zooms a surface with different horizontal and vertival scaling factors and optional anti-aliasing.
+
+Rotates a 32-bit or 8-bit 'src' surface to newly created 'dst' surface.
+'angle' is the rotation in degrees, 'center' the rotation center. If 'smooth' is set
+then the destination 32-bit surface is anti-aliased. 8-bit surfaces must have a colorkey. 32-bit
+surfaces must have a 8888 layout with red, green, blue and alpha masks (any ordering goes).
+The blend mode of the 'src' surface has some effects on generation of the 'dst' surface: The NONE
+mode will set the BLEND mode on the 'dst' surface. The MOD mode either generates a white 'dst'
+surface and sets the colorkey or fills the it with the colorkey before copying the pixels.
+When using the NONE and MOD modes, color and alpha modulation must be applied before using this function.
+
+\param src The surface to rotozoom.
+\param angle The angle to rotate in degrees.
+\param smooth Antialiasing flag; set to SMOOTHING_ON to enable.
+\param flipx Set to 1 to flip the image horizontally
+\param flipy Set to 1 to flip the image vertically
+\param rect_dest The destination rect bounding box
+\param cangle The angle cosine
+\param sangle The angle sine
+\param center The true coordinate of the center of rotation
+\return The new rotated surface.
+
+*/
+
+SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int flipy,
+                     const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center)
+{
+    SDL_Surface *rz_dst;
+    int is8bit, angle90;
+    SDL_BlendMode blendmode;
+    Uint32 colorkey = 0;
+    bool colorKeyAvailable = false;
+    double sangleinv, cangleinv;
+
+    // Sanity check
+    if (!SDL_SurfaceValid(src)) {
+        return NULL;
+    }
+
+    if (SDL_SurfaceHasColorKey(src)) {
+        if (SDL_GetSurfaceColorKey(src, &colorkey)) {
+            colorKeyAvailable = true;
+        }
+    }
+    // This function requires a 32-bit surface or 8-bit surface with a colorkey
+    is8bit = src->fmt->bits_per_pixel == 8 && colorKeyAvailable;
+    if (!(is8bit || (src->fmt->bits_per_pixel == 32 && SDL_ISPIXELFORMAT_ALPHA(src->format)))) {
+        return NULL;
+    }
+
+    // Calculate target factors from sine/cosine and zoom
+    sangleinv = sangle * 65536.0;
+    cangleinv = cangle * 65536.0;
+
+    // Alloc space to completely contain the rotated surface
+    rz_dst = NULL;
+    if (is8bit) {
+        // Target surface is 8 bit
+        rz_dst = SDL_CreateSurface(rect_dest->w, rect_dest->h + GUARD_ROWS, src->format);
+        if (rz_dst) {
+            SDL_SetSurfacePalette(rz_dst, src->palette);
+        }
+    } else {
+        // Target surface is 32 bit with source RGBA ordering
+        rz_dst = SDL_CreateSurface(rect_dest->w, rect_dest->h + GUARD_ROWS, src->format);
+    }
+
+    // Check target
+    if (!rz_dst) {
+        return NULL;
+    }
+
+    // Adjust for guard rows
+    rz_dst->h = rect_dest->h;
+
+    SDL_GetSurfaceBlendMode(src, &blendmode);
+
+    if (colorKeyAvailable) {
+        // If available, the colorkey will be used to discard the pixels that are outside of the rotated area.
+        SDL_SetSurfaceColorKey(rz_dst, true, colorkey);
+        SDL_FillSurfaceRect(rz_dst, NULL, colorkey);
+    } else if (blendmode == SDL_BLENDMODE_NONE) {
+        blendmode = SDL_BLENDMODE_BLEND;
+    } else if (blendmode == SDL_BLENDMODE_MOD || blendmode == SDL_BLENDMODE_MUL) {
+        /* Without a colorkey, the target texture has to be white for the MOD and MUL blend mode so
+         * that the pixels outside the rotated area don't affect the destination surface.
+         */
+        colorkey = SDL_MapSurfaceRGBA(rz_dst, 255, 255, 255, 0);
+        SDL_FillSurfaceRect(rz_dst, NULL, colorkey);
+        /* Setting a white colorkey for the destination surface makes the final blit discard
+         * all pixels outside of the rotated area. This doesn't interfere with anything because
+         * white pixels are already a no-op and the MOD blend mode does not interact with alpha.
+         */
+        SDL_SetSurfaceColorKey(rz_dst, true, colorkey);
+    }
+
+    SDL_SetSurfaceBlendMode(rz_dst, blendmode);
+
+    // Lock source surface
+    if (SDL_MUSTLOCK(src)) {
+        if (!SDL_LockSurface(src)) {
+            SDL_DestroySurface(rz_dst);
+            return NULL;
+        }
+    }
+
+    /* check if the rotation is a multiple of 90 degrees so we can take a fast path and also somewhat reduce
+     * the off-by-one problem in transformSurfaceRGBA that expresses itself when the rotation is near
+     * multiples of 90 degrees.
+     */
+    angle90 = (int)(angle / 90);
+    if (angle90 == angle / 90) {
+        angle90 %= 4;
+        if (angle90 < 0) {
+            angle90 += 4; // 0:0 deg, 1:90 deg, 2:180 deg, 3:270 deg
+        }
+
+    } else {
+        angle90 = -1;
+    }
+
+    if (is8bit) {
+        // Call the 8-bit transformation routine to do the rotation
+        if (angle90 >= 0) {
+            transformSurfaceY90(src, rz_dst, angle90, flipx, flipy);
+        } else {
+            transformSurfaceY(src, rz_dst, (int)sangleinv, (int)cangleinv,
+                              flipx, flipy, rect_dest, center);
+        }
+    } else {
+        // Call the 32-bit transformation routine to do the rotation
+        if (angle90 >= 0) {
+            transformSurfaceRGBA90(src, rz_dst, angle90, flipx, flipy);
+        } else {
+            transformSurfaceRGBA(src, rz_dst, (int)sangleinv, (int)cangleinv,
+                                 flipx, flipy, smooth, rect_dest, center);
+        }
+    }
+
+    // Unlock source surface
+    if (SDL_MUSTLOCK(src)) {
+        SDL_UnlockSurface(src);
+    }
+
+    // Return rotated surface
+    return rz_dst;
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_rotate.h b/SDL-3.2.8/src/render/software/SDL_rotate.h
new file mode 100644
index 0000000..ecf84f7
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_rotate.h
@@ -0,0 +1,30 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_rotate_h_
+#define SDL_rotate_h_
+
+extern SDL_Surface *SDLgfx_rotateSurface(SDL_Surface *src, double angle, int smooth, int flipx, int flipy,
+                                         const SDL_Rect *rect_dest, double cangle, double sangle, const SDL_FPoint *center);
+extern void SDLgfx_rotozoomSurfaceSizeTrig(int width, int height, double angle, const SDL_FPoint *center,
+                                           SDL_Rect *rect_dest, double *cangle, double *sangle);
+
+#endif // SDL_rotate_h_
diff --git a/SDL-3.2.8/src/render/software/SDL_triangle.c b/SDL-3.2.8/src/render/software/SDL_triangle.c
new file mode 100644
index 0000000..c4e16d1
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_triangle.c
@@ -0,0 +1,945 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_SW
+
+#include <limits.h>
+
+#include "SDL_triangle.h"
+
+#include "../../video/SDL_surface_c.h"
+
+/* fixed points bits precision
+ * Set to 1, so that it can start rendering with middle of a pixel precision.
+ * It doesn't need to be increased.
+ * But, if increased too much, it overflows (srcx, srcy) coordinates used for filling with texture.
+ * (which could be turned to int64).
+ */
+#define FP_BITS 1
+
+#define COLOR_EQ(c1, c2) ((c1).r == (c2).r && (c1).g == (c2).g && (c1).b == (c2).b && (c1).a == (c2).a)
+
+static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info,
+                                  SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2,
+                                  int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x,
+                                  int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row,
+                                  SDL_Color c0, SDL_Color c1, SDL_Color c2, bool is_uniform, SDL_TextureAddressMode texture_address_mode);
+
+#if 0
+bool SDL_BlitTriangle(SDL_Surface *src, const SDL_Point srcpoints[3], SDL_Surface *dst, const SDL_Point dstpoints[3])
+{
+    int i;
+    SDL_Point points[6];
+
+    if (src == NULL || dst == NULL) {
+        return false;
+    }
+
+    for (i = 0; i < 3; i++) {
+        if (srcpoints[i].x < 0 || srcpoints[i].y < 0 || srcpoints[i].x >= src->w || srcpoints[i].y >= src->h) {
+            return SDL_SetError("Values of 'srcpoints' out of bounds");
+        }
+    }
+
+    points[0] = srcpoints[0];
+    points[1] = dstpoints[0];
+    points[2] = srcpoints[1];
+    points[3] = dstpoints[1];
+    points[4] = srcpoints[2];
+    points[5] = dstpoints[2];
+    for (i = 0; i < 3; i++) {
+        trianglepoint_2_fixedpoint(&points[2 * i + 1]);
+    }
+    return SDL_SW_BlitTriangle(src, dst, points);
+}
+
+bool SDL_FillTriangle(SDL_Surface *dst, const SDL_Point points[3], Uint32 color)
+{
+    int i;
+    SDL_Point points_tmp[3];
+    if (dst == NULL) {
+        return false;
+    }
+    for (i = 0; i < 3; i++) {
+        points_tmp[i] = points[i];
+        trianglepoint_2_fixedpoint(&points_tmp[i]);
+    }
+    return SDL_SW_FillTriangle(dst, points_tmp, SDL_BLENDMODE_NONE, color);
+}
+#endif
+
+// cross product AB x AC
+static Sint64 cross_product(const SDL_Point *a, const SDL_Point *b, int c_x, int c_y)
+{
+    return ((Sint64)(b->x - a->x)) * ((Sint64)(c_y - a->y)) - ((Sint64)(b->y - a->y)) * ((Sint64)(c_x - a->x));
+}
+
+// check for top left rules
+static bool is_top_left(const SDL_Point *a, const SDL_Point *b, int is_clockwise)
+{
+    if (is_clockwise) {
+        if (a->y == b->y && a->x < b->x) {
+            return true;
+        }
+        if (b->y < a->y) {
+            return true;
+        }
+    } else {
+        if (a->y == b->y && b->x < a->x) {
+            return true;
+        }
+        if (a->y < b->y) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// x = (y << FP_BITS)
+// prevent runtime error: left shift of negative value
+#define PRECOMP(x, y)               \
+        val = y;                    \
+        if (val >= 0) {             \
+            x = val << FP_BITS;     \
+        } else {                    \
+            val *= -1;              \
+            x = val << FP_BITS;     \
+            x *= -1;                \
+        }
+
+void trianglepoint_2_fixedpoint(SDL_Point *a)
+{
+    int val;
+    PRECOMP(a->x, a->x);
+    PRECOMP(a->y, a->y);
+}
+
+// bounding rect of three points (in fixed point)
+static void bounding_rect_fixedpoint(const SDL_Point *a, const SDL_Point *b, const SDL_Point *c, SDL_Rect *r)
+{
+    int min_x = SDL_min(a->x, SDL_min(b->x, c->x));
+    int max_x = SDL_max(a->x, SDL_max(b->x, c->x));
+    int min_y = SDL_min(a->y, SDL_min(b->y, c->y));
+    int max_y = SDL_max(a->y, SDL_max(b->y, c->y));
+    // points are in fixed point, shift back
+    r->x = min_x >> FP_BITS;
+    r->y = min_y >> FP_BITS;
+    r->w = (max_x - min_x) >> FP_BITS;
+    r->h = (max_y - min_y) >> FP_BITS;
+}
+
+// bounding rect of three points
+static void bounding_rect(const SDL_Point *a, const SDL_Point *b, const SDL_Point *c, SDL_Rect *r)
+{
+    int min_x = SDL_min(a->x, SDL_min(b->x, c->x));
+    int max_x = SDL_max(a->x, SDL_max(b->x, c->x));
+    int min_y = SDL_min(a->y, SDL_min(b->y, c->y));
+    int max_y = SDL_max(a->y, SDL_max(b->y, c->y));
+    r->x = min_x;
+    r->y = min_y;
+    r->w = (max_x - min_x);
+    r->h = (max_y - min_y);
+}
+
+/* Triangle rendering, using Barycentric coordinates (w0, w1, w2)
+ *
+ * The cross product isn't computed from scratch at each iteration,
+ * but optimized using constant step increments
+ *
+ */
+
+#define TRIANGLE_BEGIN_LOOP                                                        \
+    {                                                                              \
+        int x, y;                                                                  \
+        for (y = 0; y < dstrect.h; y++) {                                          \
+            /* y start */                                                          \
+            Sint64 w0 = w0_row;                                                    \
+            Sint64 w1 = w1_row;                                                    \
+            Sint64 w2 = w2_row;                                                    \
+            for (x = 0; x < dstrect.w; x++) {                                      \
+                /* In triangle */                                                  \
+                if (w0 + bias_w0 >= 0 && w1 + bias_w1 >= 0 && w2 + bias_w2 >= 0) { \
+                    Uint8 *dptr = (Uint8 *)dst_ptr + x * dstbpp;
+
+// Use 64 bits precision to prevent overflow when interpolating color / texture with wide triangles
+#define TRIANGLE_GET_TEXTCOORD                                                          \
+    int srcx = (int)(((Sint64)w0 * s2s0_x + (Sint64)w1 * s2s1_x + s2_x_area.x) / area); \
+    int srcy = (int)(((Sint64)w0 * s2s0_y + (Sint64)w1 * s2s1_y + s2_x_area.y) / area); \
+    if (texture_address_mode == SDL_TEXTURE_ADDRESS_WRAP) {                             \
+        srcx %= src_surface->w;                                                         \
+        if (srcx < 0) {                                                                 \
+            srcx += (src_surface->w - 1);                                               \
+        }                                                                               \
+        srcy %= src_surface->h;                                                         \
+        if (srcy < 0) {                                                                 \
+            srcy += (src_surface->h - 1);                                               \
+        }                                                                               \
+    }
+
+#define TRIANGLE_GET_MAPPED_COLOR                                                      \
+    Uint8 r = (Uint8)(((Sint64)w0 * c0.r + (Sint64)w1 * c1.r + (Sint64)w2 * c2.r) / area); \
+    Uint8 g = (Uint8)(((Sint64)w0 * c0.g + (Sint64)w1 * c1.g + (Sint64)w2 * c2.g) / area); \
+    Uint8 b = (Uint8)(((Sint64)w0 * c0.b + (Sint64)w1 * c1.b + (Sint64)w2 * c2.b) / area); \
+    Uint8 a = (Uint8)(((Sint64)w0 * c0.a + (Sint64)w1 * c1.a + (Sint64)w2 * c2.a) / area); \
+    Uint32 color = SDL_MapRGBA(format, palette, r, g, b, a);
+
+#define TRIANGLE_GET_COLOR                                                             \
+    int r = (int)(((Sint64)w0 * c0.r + (Sint64)w1 * c1.r + (Sint64)w2 * c2.r) / area); \
+    int g = (int)(((Sint64)w0 * c0.g + (Sint64)w1 * c1.g + (Sint64)w2 * c2.g) / area); \
+    int b = (int)(((Sint64)w0 * c0.b + (Sint64)w1 * c1.b + (Sint64)w2 * c2.b) / area); \
+    int a = (int)(((Sint64)w0 * c0.a + (Sint64)w1 * c1.a + (Sint64)w2 * c2.a) / area);
+
+#define TRIANGLE_END_LOOP \
+    }                     \
+    /* x += 1 */          \
+    w0 += d2d1_y;         \
+    w1 += d0d2_y;         \
+    w2 += d1d0_y;         \
+    }                     \
+    /* y += 1 */          \
+    w0_row += d1d2_x;     \
+    w1_row += d2d0_x;     \
+    w2_row += d0d1_x;     \
+    dst_ptr += dst_pitch; \
+    }                     \
+    }
+
+bool SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Point *d2, SDL_BlendMode blend, SDL_Color c0, SDL_Color c1, SDL_Color c2)
+{
+    bool result = true;
+    int dst_locked = 0;
+
+    SDL_Rect dstrect;
+
+    int dstbpp;
+    Uint8 *dst_ptr;
+    int dst_pitch;
+
+    Sint64 area;
+    int is_clockwise;
+
+    int d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x;
+    Sint64 w0_row, w1_row, w2_row;
+    int bias_w0, bias_w1, bias_w2;
+
+    bool is_uniform;
+
+    SDL_Surface *tmp = NULL;
+
+    if (!SDL_SurfaceValid(dst)) {
+        return false;
+    }
+
+    area = cross_product(d0, d1, d2->x, d2->y);
+
+    is_uniform = COLOR_EQ(c0, c1) && COLOR_EQ(c1, c2);
+
+    // Flat triangle
+    if (area == 0) {
+        return true;
+    }
+
+    // Lock the destination, if needed
+    if (SDL_MUSTLOCK(dst)) {
+        if (!SDL_LockSurface(dst)) {
+            result = false;
+            goto end;
+        } else {
+            dst_locked = 1;
+        }
+    }
+
+    bounding_rect_fixedpoint(d0, d1, d2, &dstrect);
+
+    {
+        // Clip triangle rect with surface rect
+        SDL_Rect rect;
+        rect.x = 0;
+        rect.y = 0;
+        rect.w = dst->w;
+        rect.h = dst->h;
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
+    }
+
+    {
+        // Clip triangle with surface clip rect
+        SDL_Rect rect;
+        SDL_GetSurfaceClipRect(dst, &rect);
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
+    }
+
+    if (blend != SDL_BLENDMODE_NONE) {
+        SDL_PixelFormat format = dst->format;
+
+        // need an alpha format
+        if (!SDL_ISPIXELFORMAT_ALPHA(format)) {
+            format = SDL_PIXELFORMAT_ARGB8888;
+        }
+
+        // Use an intermediate surface
+        tmp = SDL_CreateSurface(dstrect.w, dstrect.h, format);
+        if (!tmp) {
+            result = false;
+            goto end;
+        }
+
+        if (blend == SDL_BLENDMODE_MOD) {
+            Uint32 c = SDL_MapSurfaceRGBA(tmp, 255, 255, 255, 255);
+            SDL_FillSurfaceRect(tmp, NULL, c);
+        }
+
+        SDL_SetSurfaceBlendMode(tmp, blend);
+
+        dstbpp = tmp->fmt->bytes_per_pixel;
+        dst_ptr = (Uint8 *)tmp->pixels;
+        dst_pitch = tmp->pitch;
+
+    } else {
+        // Write directly to destination surface
+        dstbpp = dst->fmt->bytes_per_pixel;
+        dst_ptr = (Uint8 *)dst->pixels + dstrect.x * dstbpp + dstrect.y * dst->pitch;
+        dst_pitch = dst->pitch;
+    }
+
+    is_clockwise = area > 0;
+    if (area < 0) {
+        area = -area;
+    }
+
+    {
+        int val;
+        PRECOMP(d2d1_y, d1->y - d2->y)
+        PRECOMP(d0d2_y, d2->y - d0->y)
+        PRECOMP(d1d0_y, d0->y - d1->y)
+        PRECOMP(d1d2_x, d2->x - d1->x)
+        PRECOMP(d2d0_x, d0->x - d2->x)
+        PRECOMP(d0d1_x, d1->x - d0->x)
+    }
+
+    // Starting point for rendering, at the middle of a pixel
+    {
+        SDL_Point p;
+        p.x = dstrect.x;
+        p.y = dstrect.y;
+        trianglepoint_2_fixedpoint(&p);
+        p.x += (1 << FP_BITS) / 2;
+        p.y += (1 << FP_BITS) / 2;
+        w0_row = cross_product(d1, d2, p.x, p.y);
+        w1_row = cross_product(d2, d0, p.x, p.y);
+        w2_row = cross_product(d0, d1, p.x, p.y);
+    }
+
+    // Handle anti-clockwise triangles
+    if (!is_clockwise) {
+        d2d1_y *= -1;
+        d0d2_y *= -1;
+        d1d0_y *= -1;
+        d1d2_x *= -1;
+        d2d0_x *= -1;
+        d0d1_x *= -1;
+        w0_row *= -1;
+        w1_row *= -1;
+        w2_row *= -1;
+    }
+
+    // Add a bias to respect top-left rasterization rule
+    bias_w0 = (is_top_left(d1, d2, is_clockwise) ? 0 : -1);
+    bias_w1 = (is_top_left(d2, d0, is_clockwise) ? 0 : -1);
+    bias_w2 = (is_top_left(d0, d1, is_clockwise) ? 0 : -1);
+
+    if (is_uniform) {
+        Uint32 color;
+        if (tmp) {
+            color = SDL_MapSurfaceRGBA(tmp, c0.r, c0.g, c0.b, c0.a);
+        } else {
+            color = SDL_MapSurfaceRGBA(dst, c0.r, c0.g, c0.b, c0.a);
+        }
+
+        if (dstbpp == 4) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                *(Uint32 *)dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 3) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                Uint8 *s = (Uint8 *)&color;
+                dptr[0] = s[0];
+                dptr[1] = s[1];
+                dptr[2] = s[2];
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 2) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                *(Uint16 *)dptr = (Uint16)color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 1) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                *dptr = (Uint8)color;
+            }
+            TRIANGLE_END_LOOP
+        }
+    } else {
+        const SDL_PixelFormatDetails *format;
+        SDL_Palette *palette;
+        if (tmp) {
+            format = tmp->fmt;
+            palette = tmp->palette;
+        } else {
+            format = dst->fmt;
+            palette = dst->palette;
+        }
+        if (dstbpp == 4) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                *(Uint32 *)dptr = color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 3) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                Uint8 *s = (Uint8 *)&color;
+                dptr[0] = s[0];
+                dptr[1] = s[1];
+                dptr[2] = s[2];
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 2) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                *(Uint16 *)dptr = (Uint16)color;
+            }
+            TRIANGLE_END_LOOP
+        } else if (dstbpp == 1) {
+            TRIANGLE_BEGIN_LOOP
+            {
+                TRIANGLE_GET_MAPPED_COLOR
+                *dptr = (Uint8)color;
+            }
+            TRIANGLE_END_LOOP
+        }
+    }
+
+    if (tmp) {
+        SDL_BlitSurface(tmp, NULL, dst, &dstrect);
+        SDL_DestroySurface(tmp);
+    }
+
+end:
+    if (dst_locked) {
+        SDL_UnlockSurface(dst);
+    }
+
+    return result;
+}
+
+bool SDL_SW_BlitTriangle(
+    SDL_Surface *src,
+    SDL_Point *s0, SDL_Point *s1, SDL_Point *s2,
+    SDL_Surface *dst,
+    SDL_Point *d0, SDL_Point *d1, SDL_Point *d2,
+    SDL_Color c0, SDL_Color c1, SDL_Color c2,
+    SDL_TextureAddressMode texture_address_mode)
+{
+    bool result = true;
+    SDL_Surface *src_surface = src;
+    int src_locked = 0;
+    int dst_locked = 0;
+
+    SDL_BlendMode blend;
+
+    SDL_Rect dstrect;
+
+    SDL_Point s2_x_area;
+
+    int dstbpp;
+    Uint8 *dst_ptr;
+    int dst_pitch;
+
+    const int *src_ptr;
+    int src_pitch;
+
+    Sint64 area, tmp64;
+    int is_clockwise;
+
+    int d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x;
+    int s2s0_x, s2s1_x, s2s0_y, s2s1_y;
+
+    Sint64 w0_row, w1_row, w2_row;
+    int bias_w0, bias_w1, bias_w2;
+
+    bool is_uniform;
+
+    bool has_modulation;
+
+    if (!SDL_SurfaceValid(src)) {
+        return SDL_InvalidParamError("src");
+    }
+    if (!SDL_SurfaceValid(dst)) {
+        return SDL_InvalidParamError("dst");
+    }
+
+    area = cross_product(d0, d1, d2->x, d2->y);
+
+    // Flat triangle
+    if (area == 0) {
+        return true;
+    }
+
+    // Lock the destination, if needed
+    if (SDL_MUSTLOCK(dst)) {
+        if (!SDL_LockSurface(dst)) {
+            result = false;
+            goto end;
+        } else {
+            dst_locked = 1;
+        }
+    }
+
+    // Lock the source, if needed
+    if (SDL_MUSTLOCK(src)) {
+        if (!SDL_LockSurface(src)) {
+            result = false;
+            goto end;
+        } else {
+            src_locked = 1;
+        }
+    }
+
+    is_uniform = COLOR_EQ(c0, c1) && COLOR_EQ(c1, c2);
+
+    bounding_rect_fixedpoint(d0, d1, d2, &dstrect);
+
+    SDL_GetSurfaceBlendMode(src, &blend);
+
+    // TRIANGLE_GET_TEXTCOORD interpolates up to the max values included, so reduce by 1
+    if (texture_address_mode == SDL_TEXTURE_ADDRESS_CLAMP) {
+        SDL_Rect srcrect;
+        int maxx, maxy;
+        bounding_rect(s0, s1, s2, &srcrect);
+        maxx = srcrect.x + srcrect.w;
+        maxy = srcrect.y + srcrect.h;
+        if (srcrect.w > 0) {
+            if (s0->x == maxx) {
+                s0->x--;
+            }
+            if (s1->x == maxx) {
+                s1->x--;
+            }
+            if (s2->x == maxx) {
+                s2->x--;
+            }
+        }
+        if (srcrect.h > 0) {
+            if (s0->y == maxy) {
+                s0->y--;
+            }
+            if (s1->y == maxy) {
+                s1->y--;
+            }
+            if (s2->y == maxy) {
+                s2->y--;
+            }
+        }
+    }
+
+    if (is_uniform) {
+        // SDL_GetSurfaceColorMod(src, &r, &g, &b);
+        has_modulation = c0.r != 255 || c0.g != 255 || c0.b != 255 || c0.a != 255;
+    } else {
+        has_modulation = true;
+    }
+
+    {
+        // Clip triangle with surface clip rect
+        SDL_Rect rect;
+        SDL_GetSurfaceClipRect(dst, &rect);
+        SDL_GetRectIntersection(&dstrect, &rect, &dstrect);
+    }
+
+    // Set destination pointer
+    dstbpp = dst->fmt->bytes_per_pixel;
+    dst_ptr = (Uint8 *)dst->pixels + dstrect.x * dstbpp + dstrect.y * dst->pitch;
+    dst_pitch = dst->pitch;
+
+    // Set source pointer
+    src_ptr = (const int *)src->pixels;
+    src_pitch = src->pitch;
+
+    is_clockwise = area > 0;
+    if (area < 0) {
+        area = -area;
+    }
+
+    {
+        int val;
+        PRECOMP(d2d1_y, d1->y - d2->y)
+        PRECOMP(d0d2_y, d2->y - d0->y)
+        PRECOMP(d1d0_y, d0->y - d1->y)
+        PRECOMP(d1d2_x, d2->x - d1->x)
+        PRECOMP(d2d0_x, d0->x - d2->x)
+        PRECOMP(d0d1_x, d1->x - d0->x)
+    }
+
+    s2s0_x = s0->x - s2->x;
+    s2s1_x = s1->x - s2->x;
+    s2s0_y = s0->y - s2->y;
+    s2s1_y = s1->y - s2->y;
+
+    // Starting point for rendering, at the middle of a pixel
+    {
+        SDL_Point p;
+        p.x = dstrect.x;
+        p.y = dstrect.y;
+        trianglepoint_2_fixedpoint(&p);
+        p.x += (1 << FP_BITS) / 2;
+        p.y += (1 << FP_BITS) / 2;
+        w0_row = cross_product(d1, d2, p.x, p.y);
+        w1_row = cross_product(d2, d0, p.x, p.y);
+        w2_row = cross_product(d0, d1, p.x, p.y);
+    }
+
+    // Handle anti-clockwise triangles
+    if (!is_clockwise) {
+        d2d1_y *= -1;
+        d0d2_y *= -1;
+        d1d0_y *= -1;
+        d1d2_x *= -1;
+        d2d0_x *= -1;
+        d0d1_x *= -1;
+        w0_row *= -1;
+        w1_row *= -1;
+        w2_row *= -1;
+    }
+
+    // Add a bias to respect top-left rasterization rule
+    bias_w0 = (is_top_left(d1, d2, is_clockwise) ? 0 : -1);
+    bias_w1 = (is_top_left(d2, d0, is_clockwise) ? 0 : -1);
+    bias_w2 = (is_top_left(d0, d1, is_clockwise) ? 0 : -1);
+
+    /* precompute constant 's2->x * area' used in TRIANGLE_GET_TEXTCOORD */
+    tmp64 = s2->x * area;
+    if (tmp64 >= INT_MIN && tmp64 <= INT_MAX) {
+        s2_x_area.x = (int)tmp64;
+    } else {
+        result = SDL_SetError("triangle area overflow");
+        goto end;
+    }
+    tmp64 = s2->y * area;
+    if (tmp64 >= INT_MIN && tmp64 <= INT_MAX) {
+        s2_x_area.y = (int)tmp64;
+    } else {
+        result = SDL_SetError("triangle area overflow");
+        goto end;
+    }
+
+    if (blend != SDL_BLENDMODE_NONE || src->format != dst->format || has_modulation || !is_uniform) {
+        // Use SDL_BlitTriangle_Slow
+
+        SDL_BlitInfo *info = &src->map.info;
+        SDL_BlitInfo tmp_info;
+
+        SDL_zero(tmp_info);
+
+        tmp_info.src_fmt = src->fmt;
+        tmp_info.dst_fmt = dst->fmt;
+        tmp_info.flags = info->flags;
+        /*
+        tmp_info.r = info->r;
+        tmp_info.g = info->g;
+        tmp_info.b = info->b;
+        tmp_info.a = info->a;
+        */
+        tmp_info.r = c0.r;
+        tmp_info.g = c0.g;
+        tmp_info.b = c0.b;
+        tmp_info.a = c0.a;
+
+        tmp_info.flags &= ~(SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA);
+
+        if (c0.r != 255 || c1.r != 255 || c2.r != 255 ||
+            c0.g != 255 || c1.g != 255 || c2.g != 255 ||
+            c0.b != 255 || c1.b != 255 || c2.b != 255) {
+            tmp_info.flags |= SDL_COPY_MODULATE_COLOR;
+        }
+
+        if (c0.a != 255 || c1.a != 255 || c2.a != 255) {
+            tmp_info.flags |= SDL_COPY_MODULATE_ALPHA;
+        }
+
+        tmp_info.colorkey = info->colorkey;
+
+        // src
+        tmp_info.src_surface = src_surface;
+        tmp_info.src = (Uint8 *)src_ptr;
+        tmp_info.src_pitch = src_pitch;
+
+        // dst
+        tmp_info.dst = dst_ptr;
+        tmp_info.dst_pitch = dst_pitch;
+
+#define CHECK_INT_RANGE(X) \
+    if ((X) < INT_MIN || (X) > INT_MAX) { \
+        result = SDL_SetError("integer overflow (%s = %" SDL_PRIs64 ")", #X, X); \
+        goto end; \
+    }
+        CHECK_INT_RANGE(area);
+        CHECK_INT_RANGE(w0_row);
+        CHECK_INT_RANGE(w1_row);
+        CHECK_INT_RANGE(w2_row);
+        SDL_BlitTriangle_Slow(&tmp_info, s2_x_area, dstrect, (int)area, bias_w0, bias_w1, bias_w2,
+                              d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x,
+                              s2s0_x, s2s1_x, s2s0_y, s2s1_y, (int)w0_row, (int)w1_row, (int)w2_row,
+                              c0, c1, c2, is_uniform, texture_address_mode);
+
+        goto end;
+    }
+
+    if (dstbpp == 4) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint32 *sptr = (Uint32 *)((Uint8 *)src_ptr + srcy * src_pitch);
+            *(Uint32 *)dptr = sptr[srcx];
+        }
+        TRIANGLE_END_LOOP
+    } else if (dstbpp == 3) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint8 *sptr = (Uint8 *)src_ptr + srcy * src_pitch;
+            dptr[0] = sptr[3 * srcx];
+            dptr[1] = sptr[3 * srcx + 1];
+            dptr[2] = sptr[3 * srcx + 2];
+        }
+        TRIANGLE_END_LOOP
+    } else if (dstbpp == 2) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint16 *sptr = (Uint16 *)((Uint8 *)src_ptr + srcy * src_pitch);
+            *(Uint16 *)dptr = sptr[srcx];
+        }
+        TRIANGLE_END_LOOP
+    } else if (dstbpp == 1) {
+        TRIANGLE_BEGIN_LOOP
+        {
+            TRIANGLE_GET_TEXTCOORD
+            Uint8 *sptr = (Uint8 *)src_ptr + srcy * src_pitch;
+            *dptr = sptr[srcx];
+        }
+        TRIANGLE_END_LOOP
+    }
+
+end:
+    if (dst_locked) {
+        SDL_UnlockSurface(dst);
+    }
+    if (src_locked) {
+        SDL_UnlockSurface(src);
+    }
+
+    return result;
+}
+
+#define FORMAT_ALPHA                0
+#define FORMAT_NO_ALPHA             -1
+#define FORMAT_2101010              1
+#define FORMAT_HAS_ALPHA(format)    format == 0
+#define FORMAT_HAS_NO_ALPHA(format) format < 0
+static int detect_format(const SDL_PixelFormatDetails *pf)
+{
+    if (pf->format == SDL_PIXELFORMAT_ARGB2101010) {
+        return FORMAT_2101010;
+    } else if (pf->Amask) {
+        return FORMAT_ALPHA;
+    } else {
+        return FORMAT_NO_ALPHA;
+    }
+}
+
+static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info,
+                                  SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2,
+                                  int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x,
+                                  int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row,
+                                  SDL_Color c0, SDL_Color c1, SDL_Color c2, bool is_uniform, SDL_TextureAddressMode texture_address_mode)
+{
+    SDL_Surface *src_surface = info->src_surface;
+    const int flags = info->flags;
+    Uint32 modulateR = info->r;
+    Uint32 modulateG = info->g;
+    Uint32 modulateB = info->b;
+    Uint32 modulateA = info->a;
+    Uint32 srcpixel;
+    Uint32 srcR, srcG, srcB, srcA;
+    Uint32 dstpixel;
+    Uint32 dstR, dstG, dstB, dstA;
+    const SDL_PixelFormatDetails *src_fmt = info->src_fmt;
+    const SDL_PixelFormatDetails *dst_fmt = info->dst_fmt;
+    int srcbpp = src_fmt->bytes_per_pixel;
+    int dstbpp = dst_fmt->bytes_per_pixel;
+    int srcfmt_val;
+    int dstfmt_val;
+    Uint32 rgbmask = ~src_fmt->Amask;
+    Uint32 ckey = info->colorkey & rgbmask;
+
+    Uint8 *dst_ptr = info->dst;
+    int dst_pitch = info->dst_pitch;
+
+    srcfmt_val = detect_format(src_fmt);
+    dstfmt_val = detect_format(dst_fmt);
+
+    TRIANGLE_BEGIN_LOOP
+    {
+        Uint8 *src;
+        Uint8 *dst = dptr;
+        TRIANGLE_GET_TEXTCOORD
+        src = (info->src + (srcy * info->src_pitch) + (srcx * srcbpp));
+        if (FORMAT_HAS_ALPHA(srcfmt_val)) {
+            DISEMBLE_RGBA(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB, srcA);
+        } else if (FORMAT_HAS_NO_ALPHA(srcfmt_val)) {
+            DISEMBLE_RGB(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB);
+            srcA = 0xFF;
+        } else {
+            // SDL_PIXELFORMAT_ARGB2101010
+            srcpixel = *((Uint32 *)(src));
+            RGBA_FROM_ARGB2101010(srcpixel, srcR, srcG, srcB, srcA);
+        }
+        if (flags & SDL_COPY_COLORKEY) {
+            // srcpixel isn't set for 24 bpp
+            if (srcbpp == 3) {
+                srcpixel = (srcR << src_fmt->Rshift) |
+                           (srcG << src_fmt->Gshift) | (srcB << src_fmt->Bshift);
+            }
+            if ((srcpixel & rgbmask) == ckey) {
+                continue;
+            }
+        }
+        if ((flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_MUL))) {
+            if (FORMAT_HAS_ALPHA(dstfmt_val)) {
+                DISEMBLE_RGBA(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB, dstA);
+            } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) {
+                DISEMBLE_RGB(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB);
+                dstA = 0xFF;
+            } else {
+                // SDL_PIXELFORMAT_ARGB2101010
+                dstpixel = *((Uint32 *) (dst));
+                RGBA_FROM_ARGB2101010(dstpixel, dstR, dstG, dstB, dstA);
+            }
+        } else {
+            // don't care
+            dstR = dstG = dstB = dstA = 0;
+        }
+
+        if (!is_uniform) {
+            TRIANGLE_GET_COLOR
+            modulateR = r;
+            modulateG = g;
+            modulateB = b;
+            modulateA = a;
+        }
+
+        if (flags & SDL_COPY_MODULATE_COLOR) {
+            srcR = (srcR * modulateR) / 255;
+            srcG = (srcG * modulateG) / 255;
+            srcB = (srcB * modulateB) / 255;
+        }
+        if (flags & SDL_COPY_MODULATE_ALPHA) {
+            srcA = (srcA * modulateA) / 255;
+        }
+        if (flags & (SDL_COPY_BLEND | SDL_COPY_ADD)) {
+            // This goes away if we ever use premultiplied alpha
+            if (srcA < 255) {
+                srcR = (srcR * srcA) / 255;
+                srcG = (srcG * srcA) / 255;
+                srcB = (srcB * srcA) / 255;
+            }
+        }
+        switch (flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_MUL)) {
+        case 0:
+            dstR = srcR;
+            dstG = srcG;
+            dstB = srcB;
+            dstA = srcA;
+            break;
+        case SDL_COPY_BLEND:
+            dstR = srcR + ((255 - srcA) * dstR) / 255;
+            dstG = srcG + ((255 - srcA) * dstG) / 255;
+            dstB = srcB + ((255 - srcA) * dstB) / 255;
+            dstA = srcA + ((255 - srcA) * dstA) / 255;
+            break;
+        case SDL_COPY_ADD:
+            dstR = srcR + dstR;
+            if (dstR > 255) {
+                dstR = 255;
+            }
+            dstG = srcG + dstG;
+            if (dstG > 255) {
+                dstG = 255;
+            }
+            dstB = srcB + dstB;
+            if (dstB > 255) {
+                dstB = 255;
+            }
+            break;
+        case SDL_COPY_MOD:
+            dstR = (srcR * dstR) / 255;
+            dstG = (srcG * dstG) / 255;
+            dstB = (srcB * dstB) / 255;
+            break;
+        case SDL_COPY_MUL:
+            dstR = ((srcR * dstR) + (dstR * (255 - srcA))) / 255;
+            if (dstR > 255) {
+                dstR = 255;
+            }
+            dstG = ((srcG * dstG) + (dstG * (255 - srcA))) / 255;
+            if (dstG > 255) {
+                dstG = 255;
+            }
+            dstB = ((srcB * dstB) + (dstB * (255 - srcA))) / 255;
+            if (dstB > 255) {
+                dstB = 255;
+            }
+            break;
+        }
+        if (FORMAT_HAS_ALPHA(dstfmt_val)) {
+            ASSEMBLE_RGBA(dst, dstbpp, dst_fmt, dstR, dstG, dstB, dstA);
+        } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) {
+            ASSEMBLE_RGB(dst, dstbpp, dst_fmt, dstR, dstG, dstB);
+        } else {
+            // SDL_PIXELFORMAT_ARGB2101010
+            Uint32 pixel;
+            ARGB2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA);
+            *(Uint32 *)dst = pixel;
+        }
+    }
+    TRIANGLE_END_LOOP
+}
+
+#endif // SDL_VIDEO_RENDER_SW
diff --git a/SDL-3.2.8/src/render/software/SDL_triangle.h b/SDL-3.2.8/src/render/software/SDL_triangle.h
new file mode 100644
index 0000000..1c5504c
--- /dev/null
+++ b/SDL-3.2.8/src/render/software/SDL_triangle.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_triangle_h_
+#define SDL_triangle_h_
+
+#include "SDL_internal.h"
+
+#include "../SDL_sysrender.h"   // For SDL_TextureAddressMode
+
+extern bool SDL_SW_FillTriangle(SDL_Surface *dst,
+                                SDL_Point *d0, SDL_Point *d1, SDL_Point *d2,
+                                SDL_BlendMode blend, SDL_Color c0, SDL_Color c1, SDL_Color c2);
+
+extern bool SDL_SW_BlitTriangle(SDL_Surface *src,
+                                SDL_Point *s0, SDL_Point *s1, SDL_Point *s2,
+                                SDL_Surface *dst,
+                                SDL_Point *d0, SDL_Point *d1, SDL_Point *d2,
+                                SDL_Color c0, SDL_Color c1, SDL_Color c2,
+                                SDL_TextureAddressMode texture_address_mode);
+
+extern void trianglepoint_2_fixedpoint(SDL_Point *a);
+
+#endif // SDL_triangle_h_
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm.c b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm.c
new file mode 100644
index 0000000..acf31c3
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm.c
@@ -0,0 +1,1198 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_VITA_GXM
+
+#include "../SDL_sysrender.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include "SDL_render_vita_gxm_types.h"
+#include "SDL_render_vita_gxm_tools.h"
+#include "SDL_render_vita_gxm_memory.h"
+
+#include <psp2/common_dialog.h>
+
+// #define DEBUG_RAZOR
+
+#ifdef DEBUG_RAZOR
+#include <psp2/sysmodule.h>
+#endif
+
+static bool VITA_GXM_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props);
+
+static void VITA_GXM_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event);
+
+static bool VITA_GXM_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode);
+
+static bool VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props);
+
+static bool VITA_GXM_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect, const void *pixels, int pitch);
+
+static bool VITA_GXM_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                     const SDL_Rect *rect,
+                                     const Uint8 *Yplane, int Ypitch,
+                                     const Uint8 *Uplane, int Upitch,
+                                     const Uint8 *Vplane, int Vpitch);
+
+static bool VITA_GXM_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                    const SDL_Rect *rect,
+                                    const Uint8 *Yplane, int Ypitch,
+                                    const Uint8 *UVplane, int UVpitch);
+
+static bool VITA_GXM_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                                const SDL_Rect *rect, void **pixels, int *pitch);
+
+static void VITA_GXM_UnlockTexture(SDL_Renderer *renderer,
+                                   SDL_Texture *texture);
+
+static void VITA_GXM_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode);
+
+static bool VITA_GXM_SetRenderTarget(SDL_Renderer *renderer,
+                                    SDL_Texture *texture);
+
+static bool VITA_GXM_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+
+static bool VITA_GXM_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+
+static bool VITA_GXM_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count);
+static bool VITA_GXM_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count);
+
+static bool VITA_GXM_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                                  const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                                  int num_vertices, const void *indices, int num_indices, int size_indices,
+                                  float scale_x, float scale_y);
+
+static bool VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd);
+
+static void VITA_GXM_InvalidateCachedState(SDL_Renderer *renderer);
+
+static bool VITA_GXM_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize);
+
+static SDL_Surface *VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect);
+
+static bool VITA_GXM_RenderPresent(SDL_Renderer *renderer);
+static void VITA_GXM_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+static void VITA_GXM_DestroyRenderer(SDL_Renderer *renderer);
+
+SDL_RenderDriver VITA_GXM_RenderDriver = {
+    VITA_GXM_CreateRenderer, "VITA gxm"
+};
+
+static int PixelFormatToVITAFMT(Uint32 format)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_ARGB8888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB;
+    case SDL_PIXELFORMAT_XRGB8888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB;
+    case SDL_PIXELFORMAT_XBGR8888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
+    case SDL_PIXELFORMAT_ABGR8888:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
+    case SDL_PIXELFORMAT_RGB565:
+        return SCE_GXM_TEXTURE_FORMAT_U5U6U5_RGB;
+    case SDL_PIXELFORMAT_BGR565:
+        return SCE_GXM_TEXTURE_FORMAT_U5U6U5_BGR;
+    case SDL_PIXELFORMAT_YV12:
+        return SCE_GXM_TEXTURE_FORMAT_YVU420P3_CSC0;
+    case SDL_PIXELFORMAT_IYUV:
+        return SCE_GXM_TEXTURE_FORMAT_YUV420P3_CSC0;
+    // should be the other way around. looks like SCE bug.
+    case SDL_PIXELFORMAT_NV12:
+        return SCE_GXM_TEXTURE_FORMAT_YVU420P2_CSC0;
+    case SDL_PIXELFORMAT_NV21:
+        return SCE_GXM_TEXTURE_FORMAT_YUV420P2_CSC0;
+    default:
+        return SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
+    }
+}
+
+void StartDrawing(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    if (data->drawing) {
+        return;
+    }
+
+    data->drawstate.texture = NULL;
+    data->drawstate.vertex_program = NULL;
+    data->drawstate.fragment_program = NULL;
+    data->drawstate.last_command = -1;
+    data->drawstate.viewport_dirty = true;
+
+    // reset blend mode
+    //    data->currentBlendMode = SDL_BLENDMODE_BLEND;
+    //    fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
+    //    data->colorFragmentProgram = in->color;
+    //    data->textureFragmentProgram = in->texture;
+
+    if (!renderer->target) {
+        sceGxmBeginScene(
+            data->gxm_context,
+            0,
+            data->renderTarget,
+            NULL,
+            NULL,
+            data->displayBufferSync[data->backBufferIndex],
+            &data->displaySurface[data->backBufferIndex],
+            &data->depthSurface);
+    } else {
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)renderer->target->internal;
+
+        sceGxmBeginScene(
+            data->gxm_context,
+            0,
+            vita_texture->tex->gxm_rendertarget,
+            NULL,
+            NULL,
+            NULL,
+            &vita_texture->tex->gxm_colorsurface,
+            &vita_texture->tex->gxm_depthstencil);
+    }
+
+    //    unset_clip_rectangle(data);
+
+    data->drawing = true;
+}
+
+static bool VITA_GXM_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    VITA_GXM_RenderData *data = renderer->internal;
+    if (vsync) {
+        data->displayData.wait_vblank = true;
+    } else {
+        data->displayData.wait_vblank = false;
+    }
+    return true;
+}
+
+static bool VITA_GXM_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    VITA_GXM_RenderData *data;
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    data = (VITA_GXM_RenderData *)SDL_calloc(1, sizeof(VITA_GXM_RenderData));
+    if (!data) {
+        return false;
+    }
+
+    renderer->WindowEvent = VITA_GXM_WindowEvent;
+    renderer->SupportsBlendMode = VITA_GXM_SupportsBlendMode;
+    renderer->CreateTexture = VITA_GXM_CreateTexture;
+    renderer->UpdateTexture = VITA_GXM_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = VITA_GXM_UpdateTextureYUV;
+    renderer->UpdateTextureNV = VITA_GXM_UpdateTextureNV;
+#endif
+    renderer->LockTexture = VITA_GXM_LockTexture;
+    renderer->UnlockTexture = VITA_GXM_UnlockTexture;
+    renderer->SetTextureScaleMode = VITA_GXM_SetTextureScaleMode;
+    renderer->SetRenderTarget = VITA_GXM_SetRenderTarget;
+    renderer->QueueSetViewport = VITA_GXM_QueueNoOp;
+    renderer->QueueSetDrawColor = VITA_GXM_QueueSetDrawColor;
+    renderer->QueueDrawPoints = VITA_GXM_QueueDrawPoints;
+    renderer->QueueDrawLines = VITA_GXM_QueueDrawLines;
+    renderer->QueueGeometry = VITA_GXM_QueueGeometry;
+    renderer->InvalidateCachedState = VITA_GXM_InvalidateCachedState;
+    renderer->RunCommandQueue = VITA_GXM_RunCommandQueue;
+    renderer->RenderReadPixels = VITA_GXM_RenderReadPixels;
+    renderer->RenderPresent = VITA_GXM_RenderPresent;
+    renderer->DestroyTexture = VITA_GXM_DestroyTexture;
+    renderer->DestroyRenderer = VITA_GXM_DestroyRenderer;
+    renderer->SetVSync = VITA_GXM_SetVSync;
+
+    renderer->internal = data;
+    VITA_GXM_InvalidateCachedState(renderer);
+    renderer->window = window;
+
+    renderer->name = VITA_GXM_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGB565);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_BGR565);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 4096);
+
+    data->initialized = true;
+
+#ifdef DEBUG_RAZOR
+    sceSysmoduleLoadModule(SCE_SYSMODULE_RAZOR_HUD);
+    sceSysmoduleLoadModule(SCE_SYSMODULE_RAZOR_CAPTURE);
+#endif
+
+    if (gxm_init(renderer) != 0) {
+        return SDL_SetError("gxm_init failed");
+    }
+
+    return true;
+}
+
+static void VITA_GXM_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+}
+
+static bool VITA_GXM_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    // only for custom modes. we build all modes on init, so no custom modes, sorry
+    return false;
+}
+
+static bool VITA_GXM_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)SDL_calloc(1, sizeof(VITA_GXM_TextureData));
+
+    if (!vita_texture) {
+        return false;
+    }
+
+    vita_texture->tex = create_gxm_texture(
+        data,
+        texture->w,
+        texture->h,
+        PixelFormatToVITAFMT(texture->format),
+        (texture->access == SDL_TEXTUREACCESS_TARGET),
+        &(vita_texture->w),
+        &(vita_texture->h),
+        &(vita_texture->pitch),
+        &(vita_texture->wscale));
+
+    if (!vita_texture->tex) {
+        SDL_free(vita_texture);
+        return SDL_OutOfMemory();
+    }
+
+    texture->internal = vita_texture;
+
+    VITA_GXM_SetTextureScaleMode(renderer, texture, texture->scaleMode);
+
+#ifdef SDL_HAVE_YUV
+    vita_texture->yuv = ((texture->format == SDL_PIXELFORMAT_IYUV) || (texture->format == SDL_PIXELFORMAT_YV12));
+    vita_texture->nv12 = ((texture->format == SDL_PIXELFORMAT_NV12) || (texture->format == SDL_PIXELFORMAT_NV21));
+#endif
+
+    return true;
+}
+
+static void VITA_GXM_SetYUVProfile(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    int ret = 0;
+    if (SDL_ISCOLORSPACE_MATRIX_BT601(texture->colorspace)) {
+        if (SDL_ISCOLORSPACE_LIMITED_RANGE(texture->colorspace)) {
+            ret = sceGxmSetYuvProfile(data->gxm_context, 0, SCE_GXM_YUV_PROFILE_BT601_STANDARD);
+        } else {
+            ret = sceGxmSetYuvProfile(data->gxm_context, 0, SCE_GXM_YUV_PROFILE_BT601_FULL_RANGE);
+        }
+    } else if (SDL_ISCOLORSPACE_MATRIX_BT709(texture->colorspace)) {
+        if (SDL_ISCOLORSPACE_LIMITED_RANGE(texture->colorspace)) {
+            ret = sceGxmSetYuvProfile(data->gxm_context, 0, SCE_GXM_YUV_PROFILE_BT709_STANDARD);
+        } else {
+            ret = sceGxmSetYuvProfile(data->gxm_context, 0, SCE_GXM_YUV_PROFILE_BT709_FULL_RANGE);
+        }
+    } else {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Unsupported YUV colorspace");
+    }
+
+    if (ret < 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Setting YUV profile failed: %x", ret);
+    }
+}
+
+static bool VITA_GXM_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect, const void *pixels, int pitch)
+{
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+    Uint8 *dst;
+    int row, length, dpitch;
+
+#ifdef SDL_HAVE_YUV
+    if (vita_texture->yuv || vita_texture->nv12) {
+        VITA_GXM_SetYUVProfile(renderer, texture);
+    }
+#endif
+
+    VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+    length = rect->w * SDL_BYTESPERPIXEL(texture->format);
+    if (length == pitch && length == dpitch) {
+        SDL_memcpy(dst, pixels, length * rect->h);
+        pixels += pitch * rect->h;
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, pixels, length);
+            pixels += pitch;
+            dst += dpitch;
+        }
+    }
+
+#ifdef SDL_HAVE_YUV
+    if (vita_texture->yuv) {
+        void *Udst;
+        void *Vdst;
+        int uv_pitch = (dpitch + 1) / 2;
+        int uv_src_pitch = (pitch + 1) / 2;
+        SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+        // skip Y plane
+        Uint8 *Dpixels = gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h);
+
+        Udst = Dpixels + (UVrect.y * uv_pitch) + UVrect.x;
+        Vdst = Dpixels + (uv_pitch * ((vita_texture->h + 1) / 2)) + (UVrect.y * uv_pitch) + UVrect.x;
+
+        length = UVrect.w;
+
+        // U plane
+        if (length == uv_src_pitch && length == uv_pitch) {
+            SDL_memcpy(Udst, pixels, length * UVrect.h);
+            pixels += uv_src_pitch * UVrect.h;
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Udst, pixels, length);
+                pixels += uv_src_pitch;
+                Udst += uv_pitch;
+            }
+        }
+
+        // V plane
+        if (length == uv_src_pitch && length == uv_pitch) {
+            SDL_memcpy(Vdst, pixels, length * UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Vdst, pixels, length);
+                pixels += uv_src_pitch;
+                Vdst += uv_pitch;
+            }
+        }
+
+    } else if (vita_texture->nv12) {
+        void *UVdst;
+        int uv_pitch = 2 * ((dpitch + 1) / 2);
+        int uv_src_pitch = 2 * ((pitch + 1) / 2);
+        SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+        // skip Y plane
+        void *Dpixels = (void *)((Uint8 *)gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h));
+        UVdst = Dpixels + (UVrect.y * uv_pitch) + UVrect.x;
+
+        length = UVrect.w * 2;
+
+        // UV plane
+        if (length == uv_src_pitch && length == uv_pitch) {
+            SDL_memcpy(UVdst, pixels, length * UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(UVdst, pixels, length);
+                pixels += uv_src_pitch;
+                UVdst += uv_pitch;
+            }
+        }
+    }
+#endif
+
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool VITA_GXM_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                     const SDL_Rect *rect,
+                                     const Uint8 *Yplane, int Ypitch,
+                                     const Uint8 *Uplane, int Upitch,
+                                     const Uint8 *Vplane, int Vpitch)
+{
+    Uint8 *dst;
+    int row, length, dpitch;
+    SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+    VITA_GXM_SetYUVProfile(renderer, texture);
+
+    // copy Y plane
+    // obtain pixels via locking so that texture is flushed
+    VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+
+    length = rect->w;
+
+    if (length == Ypitch && length == dpitch) {
+        SDL_memcpy(dst, Yplane, length * rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, Yplane, length);
+            Yplane += Ypitch;
+            dst += dpitch;
+        }
+    }
+
+    // U/V planes
+    {
+        void *Udst;
+        void *Vdst;
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+        int uv_pitch = (dpitch + 1) / 2;
+
+        // skip Y plane
+        void *pixels = (void *)((Uint8 *)gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h));
+
+        if (texture->format == SDL_PIXELFORMAT_YV12) { // YVU
+            Vdst = pixels + (UVrect.y * uv_pitch) + UVrect.x;
+            Udst = pixels + (uv_pitch * ((vita_texture->h + 1) / 2)) + (UVrect.y * uv_pitch) + UVrect.x;
+        } else { // YUV
+            Udst = pixels + (UVrect.y * uv_pitch) + UVrect.x;
+            Vdst = pixels + (uv_pitch * ((vita_texture->h + 1) / 2)) + (UVrect.y * uv_pitch) + UVrect.x;
+        }
+
+        length = UVrect.w;
+
+        // U plane
+        if (length == Upitch && length == uv_pitch) {
+            SDL_memcpy(Udst, Uplane, length * UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Udst, Uplane, length);
+                Uplane += Upitch;
+                Udst += uv_pitch;
+            }
+        }
+
+        // V plane
+        if (length == Vpitch && length == uv_pitch) {
+            SDL_memcpy(Vdst, Vplane, length * UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(Vdst, Vplane, length);
+                Vplane += Vpitch;
+                Vdst += uv_pitch;
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool VITA_GXM_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                    const SDL_Rect *rect,
+                                    const Uint8 *Yplane, int Ypitch,
+                                    const Uint8 *UVplane, int UVpitch)
+{
+
+    Uint8 *dst;
+    int row, length, dpitch;
+    SDL_Rect UVrect = { rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2 };
+
+    VITA_GXM_SetYUVProfile(renderer, texture);
+
+    // copy Y plane
+    VITA_GXM_LockTexture(renderer, texture, rect, (void **)&dst, &dpitch);
+
+    length = rect->w * SDL_BYTESPERPIXEL(texture->format);
+
+    if (length == Ypitch && length == dpitch) {
+        SDL_memcpy(dst, Yplane, length * rect->h);
+    } else {
+        for (row = 0; row < rect->h; ++row) {
+            SDL_memcpy(dst, Yplane, length);
+            Yplane += Ypitch;
+            dst += dpitch;
+        }
+    }
+
+    // UV plane
+    {
+        void *UVdst;
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+        int uv_pitch = 2 * ((dpitch + 1) / 2);
+
+        // skip Y plane
+        void *pixels = (void *)((Uint8 *)gxm_texture_get_datap(vita_texture->tex) + (vita_texture->pitch * vita_texture->h));
+
+        UVdst = pixels + (UVrect.y * uv_pitch) + UVrect.x;
+
+        length = UVrect.w * 2;
+
+        // UV plane
+        if (length == UVpitch && length == uv_pitch) {
+            SDL_memcpy(UVdst, UVplane, length * UVrect.h);
+        } else {
+            for (row = 0; row < UVrect.h; ++row) {
+                SDL_memcpy(UVdst, UVplane, length);
+                UVplane += UVpitch;
+                UVdst += uv_pitch;
+            }
+        }
+    }
+
+    return true;
+}
+
+#endif
+
+static bool VITA_GXM_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                                const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+
+    *pixels =
+        (void *)((Uint8 *)gxm_texture_get_datap(vita_texture->tex) + (rect->y * vita_texture->pitch) + rect->x * SDL_BYTESPERPIXEL(texture->format));
+    *pitch = vita_texture->pitch;
+
+    // make sure that rendering is finished on render target textures
+    if (vita_texture->tex->gxm_rendertarget) {
+        sceGxmFinish(data->gxm_context);
+    }
+
+    return true;
+}
+
+static void VITA_GXM_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    // No need to update texture data on ps vita.
+    // VITA_GXM_LockTexture already returns a pointer to the texture pixels buffer.
+    // This really improves framerate when using lock/unlock.
+}
+
+static void VITA_GXM_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+
+    /*
+     set texture filtering according to scaleMode
+     supported hint values are nearest (0, default) or linear (1)
+     vitaScaleMode is either SCE_GXM_TEXTURE_FILTER_POINT (good for tile-map)
+     or SCE_GXM_TEXTURE_FILTER_LINEAR (good for scaling)
+     */
+
+    int vitaScaleMode = (scaleMode == SDL_SCALEMODE_NEAREST
+                             ? SCE_GXM_TEXTURE_FILTER_POINT
+                             : SCE_GXM_TEXTURE_FILTER_LINEAR);
+    gxm_texture_set_filters(vita_texture->tex, vitaScaleMode, vitaScaleMode);
+
+    return;
+}
+
+static bool VITA_GXM_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    return true;
+}
+
+static void VITA_GXM_SetBlendMode(VITA_GXM_RenderData *data, int blendMode)
+{
+    if (blendMode != data->currentBlendMode) {
+        fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
+
+        switch (blendMode) {
+        case SDL_BLENDMODE_NONE:
+            in = &data->blendFragmentPrograms.blend_mode_none;
+            break;
+        case SDL_BLENDMODE_BLEND:
+            in = &data->blendFragmentPrograms.blend_mode_blend;
+            break;
+        case SDL_BLENDMODE_ADD:
+            in = &data->blendFragmentPrograms.blend_mode_add;
+            break;
+        case SDL_BLENDMODE_MOD:
+            in = &data->blendFragmentPrograms.blend_mode_mod;
+            break;
+        case SDL_BLENDMODE_MUL:
+            in = &data->blendFragmentPrograms.blend_mode_mul;
+            break;
+        }
+        data->colorFragmentProgram = in->color;
+        data->textureFragmentProgram = in->texture;
+        data->currentBlendMode = blendMode;
+    }
+}
+
+static bool VITA_GXM_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true;
+}
+
+static bool VITA_GXM_QueueSetDrawColor(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+
+    data->drawstate.color.r = cmd->data.color.color.r * cmd->data.color.color_scale;
+    data->drawstate.color.g = cmd->data.color.color.g * cmd->data.color.color_scale;
+    data->drawstate.color.b = cmd->data.color.color.b * cmd->data.color.color_scale;
+    data->drawstate.color.a = cmd->data.color.color.a;
+
+    return true;
+}
+
+static bool VITA_GXM_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+
+    SDL_FColor color = data->drawstate.color;
+
+    color_vertex *vertex = (color_vertex *)pool_malloc(
+        data,
+        count * sizeof(color_vertex));
+
+    cmd->data.draw.first = (size_t)vertex;
+    cmd->data.draw.count = count;
+
+    for (int i = 0; i < count; i++) {
+        vertex[i].x = points[i].x;
+        vertex[i].y = points[i].y;
+        vertex[i].color = color;
+    }
+
+    return true;
+}
+
+static bool VITA_GXM_QueueDrawLines(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    SDL_FColor color = data->drawstate.color;
+
+    color_vertex *vertex = (color_vertex *)pool_malloc(
+        data,
+        (count - 1) * 2 * sizeof(color_vertex));
+
+    cmd->data.draw.first = (size_t)vertex;
+    cmd->data.draw.count = (count - 1) * 2;
+
+    for (int i = 0; i < count - 1; i++) {
+        vertex[i * 2].x = points[i].x;
+        vertex[i * 2].y = points[i].y;
+        vertex[i * 2].color = color;
+
+        vertex[i * 2 + 1].x = points[i + 1].x;
+        vertex[i * 2 + 1].y = points[i + 1].y;
+        vertex[i * 2 + 1].color = color;
+    }
+
+    return true;
+}
+
+static bool VITA_GXM_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                                  const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                                  int num_vertices, const void *indices, int num_indices, int size_indices,
+                                  float scale_x, float scale_y)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    const float color_scale = cmd->data.draw.color_scale;
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    if (texture) {
+        VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+        texture_vertex *vertices;
+
+        vertices = (texture_vertex *)pool_malloc(
+            data,
+            count * sizeof(texture_vertex));
+
+        if (!vertices) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            float *uv_;
+            SDL_FColor col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+            uv_ = (float *)((char *)uv + j * uv_stride);
+
+            col_.r *= color_scale;
+            col_.g *= color_scale;
+            col_.b *= color_scale;
+
+            vertices[i].x = xy_[0] * scale_x;
+            vertices[i].y = xy_[1] * scale_y;
+            vertices[i].u = uv_[0] * vita_texture->wscale;
+            vertices[i].v = uv_[1];
+            vertices[i].color = col_;
+        }
+
+        cmd->data.draw.first = (size_t)vertices;
+
+    } else {
+        color_vertex *vertices;
+
+        vertices = (color_vertex *)pool_malloc(
+            data,
+            count * sizeof(color_vertex));
+
+        if (!vertices) {
+            return false;
+        }
+
+        for (i = 0; i < count; i++) {
+            int j;
+            float *xy_;
+            SDL_FColor col_;
+            if (size_indices == 4) {
+                j = ((const Uint32 *)indices)[i];
+            } else if (size_indices == 2) {
+                j = ((const Uint16 *)indices)[i];
+            } else if (size_indices == 1) {
+                j = ((const Uint8 *)indices)[i];
+            } else {
+                j = i;
+            }
+
+            xy_ = (float *)((char *)xy + j * xy_stride);
+            col_ = *(SDL_FColor *)((char *)color + j * color_stride);
+
+            col_.r *= color_scale;
+            col_.g *= color_scale;
+            col_.b *= color_scale;
+
+            vertices[i].x = xy_[0] * scale_x;
+            vertices[i].y = xy_[1] * scale_y;
+            vertices[i].color = col_;
+        }
+        cmd->data.draw.first = (size_t)vertices;
+    }
+
+    return true;
+}
+
+static bool VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    void *color_buffer;
+    SDL_FColor color;
+
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    unset_clip_rectangle(data);
+
+    // set clear shaders
+    data->drawstate.fragment_program = data->clearFragmentProgram;
+    data->drawstate.vertex_program = data->clearVertexProgram;
+    sceGxmSetVertexProgram(data->gxm_context, data->clearVertexProgram);
+    sceGxmSetFragmentProgram(data->gxm_context, data->clearFragmentProgram);
+
+    // set the clear color
+    color = cmd->data.color.color;
+    color.r *= cmd->data.color.color_scale;
+    color.g *= cmd->data.color.color_scale;
+    color.b *= cmd->data.color.color_scale;
+    sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &color_buffer);
+    sceGxmSetUniformDataF(color_buffer, data->clearClearColorParam, 0, 4, &color.r);
+
+    // draw the clear triangle
+    sceGxmSetVertexStream(data->gxm_context, 0, data->clearVertices);
+    sceGxmDraw(data->gxm_context, SCE_GXM_PRIMITIVE_TRIANGLES, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, 3);
+
+    data->drawstate.cliprect_dirty = true;
+    return true;
+}
+
+static bool SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    const SDL_BlendMode blend = cmd->data.draw.blend;
+    SceGxmFragmentProgram *fragment_program;
+    SceGxmVertexProgram *vertex_program;
+    bool matrix_updated = false;
+    bool program_updated = false;
+
+    if (data->drawstate.viewport_dirty) {
+        const SDL_Rect *viewport = &data->drawstate.viewport;
+
+        float sw = viewport->w / 2.f;
+        float sh = viewport->h / 2.f;
+
+        float x_scale = sw;
+        float x_off = viewport->x + sw;
+        float y_scale = -(sh);
+        float y_off = viewport->y + sh;
+
+        sceGxmSetViewport(data->gxm_context, x_off, x_scale, y_off, y_scale, 0.5f, 0.5f);
+
+        if (viewport->w && viewport->h) {
+            init_orthographic_matrix(data->ortho_matrix,
+                                     (float)0,
+                                     (float)viewport->w,
+                                     (float)viewport->h,
+                                     (float)0,
+                                     0.0f, 1.0f);
+            matrix_updated = true;
+        }
+
+        data->drawstate.viewport_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled_dirty) {
+        if (!data->drawstate.cliprect_enabled) {
+            unset_clip_rectangle(data);
+        }
+        data->drawstate.cliprect_enabled_dirty = false;
+    }
+
+    if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
+        const SDL_Rect *rect = &data->drawstate.cliprect;
+        set_clip_rectangle(data, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
+        data->drawstate.cliprect_dirty = false;
+    }
+
+    VITA_GXM_SetBlendMode(data, blend); // do that first, to select appropriate shaders
+
+    if (texture) {
+        vertex_program = data->textureVertexProgram;
+        fragment_program = data->textureFragmentProgram;
+    } else {
+        vertex_program = data->colorVertexProgram;
+        fragment_program = data->colorFragmentProgram;
+    }
+
+    if (data->drawstate.vertex_program != vertex_program) {
+        data->drawstate.vertex_program = vertex_program;
+        sceGxmSetVertexProgram(data->gxm_context, vertex_program);
+        program_updated = true;
+    }
+
+    if (data->drawstate.fragment_program != fragment_program) {
+        data->drawstate.fragment_program = fragment_program;
+        sceGxmSetFragmentProgram(data->gxm_context, fragment_program);
+        program_updated = true;
+    }
+
+    if (program_updated || matrix_updated) {
+        if (data->drawstate.fragment_program == data->textureFragmentProgram) {
+            void *vertex_wvp_buffer;
+            sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertex_wvp_buffer);
+            sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix);
+        } else { // color
+            void *vertexDefaultBuffer;
+            sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer);
+            sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix);
+        }
+    }
+
+    if (texture != data->drawstate.texture) {
+        if (texture) {
+            VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)cmd->data.draw.texture->internal;
+            sceGxmSetFragmentTexture(data->gxm_context, 0, &vita_texture->tex->gxm_tex);
+        }
+        data->drawstate.texture = texture;
+    }
+
+    // all drawing commands use this
+    sceGxmSetVertexStream(data->gxm_context, 0, (const void *)cmd->data.draw.first);
+
+    return true;
+}
+
+static void VITA_GXM_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    // currently this doesn't do anything. If this needs to do something (and someone is mixing their own rendering calls in!), update this.
+}
+
+static bool VITA_GXM_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    StartDrawing(renderer);
+
+    data->drawstate.target = renderer->target;
+    if (!data->drawstate.target) {
+        int w, h;
+        SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
+        if ((w != data->drawstate.drawablew) || (h != data->drawstate.drawableh)) {
+            data->drawstate.viewport_dirty = true; // if the window dimensions changed, invalidate the current viewport, etc.
+            data->drawstate.cliprect_dirty = true;
+            data->drawstate.drawablew = w;
+            data->drawstate.drawableh = h;
+        }
+    }
+
+    while (cmd) {
+        switch (cmd->command) {
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &data->drawstate.viewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                data->drawstate.viewport_dirty = true;
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
+                data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
+                data->drawstate.cliprect_enabled_dirty = true;
+            }
+
+            if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&data->drawstate.cliprect, rect);
+                data->drawstate.cliprect_dirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            VITA_GXM_RenderClear(renderer, cmd);
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        case SDL_RENDERCMD_DRAW_LINES:
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            SDL_Texture *thistexture = cmd->data.draw.texture;
+            SDL_BlendMode thisblend = cmd->data.draw.blend;
+            const SDL_RenderCommandType thiscmdtype = cmd->command;
+            SDL_RenderCommand *finalcmd = cmd;
+            SDL_RenderCommand *nextcmd = cmd->next;
+            size_t count = cmd->data.draw.count;
+            int ret;
+            while (nextcmd) {
+                const SDL_RenderCommandType nextcmdtype = nextcmd->command;
+                if (nextcmdtype != thiscmdtype) {
+                    break; // can't go any further on this draw call, different render command up next.
+                } else if (nextcmd->data.draw.texture != thistexture || nextcmd->data.draw.blend != thisblend) {
+                    break; // can't go any further on this draw call, different texture/blendmode copy up next.
+                } else {
+                    finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
+                    count += nextcmd->data.draw.count;
+                }
+                nextcmd = nextcmd->next;
+            }
+
+            ret = SetDrawState(data, cmd);
+
+            if (ret) {
+                int op = SCE_GXM_PRIMITIVE_TRIANGLES;
+
+                if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS) {
+                    sceGxmSetFrontPolygonMode(data->gxm_context, SCE_GXM_POLYGON_MODE_POINT);
+                    op = SCE_GXM_PRIMITIVE_POINTS;
+                } else if (thiscmdtype == SDL_RENDERCMD_DRAW_LINES) {
+                    sceGxmSetFrontPolygonMode(data->gxm_context, SCE_GXM_POLYGON_MODE_LINE);
+                    op = SCE_GXM_PRIMITIVE_LINES;
+                }
+
+                sceGxmDraw(data->gxm_context, op, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, count);
+
+                if (thiscmdtype == SDL_RENDERCMD_DRAW_POINTS || thiscmdtype == SDL_RENDERCMD_DRAW_LINES) {
+                    sceGxmSetFrontPolygonMode(data->gxm_context, SCE_GXM_POLYGON_MODE_TRIANGLE_FILL);
+                }
+            }
+
+            cmd = finalcmd; // skip any copy commands we just combined in here.
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+        data->drawstate.last_command = cmd->command;
+        cmd = cmd->next;
+    }
+
+    sceGxmEndScene(data->gxm_context, NULL, NULL);
+    data->drawing = false;
+
+    return true;
+}
+
+void read_pixels(int x, int y, size_t width, size_t height, void *data)
+{
+    SceDisplayFrameBuf pParam;
+    int i, j;
+    Uint32 *out32;
+    Uint32 *in32;
+
+    pParam.size = sizeof(SceDisplayFrameBuf);
+
+    sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME);
+
+    out32 = (Uint32 *)data;
+    in32 = (Uint32 *)pParam.base;
+
+    in32 += (x + y * pParam.pitch);
+
+    for (i = 0; i < height; i++) {
+        for (j = 0; j < width; j++) {
+            out32[(height - (i + 1)) * width + j] = in32[j];
+        }
+        in32 += pParam.pitch;
+    }
+}
+
+static SDL_Surface *VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    Uint32 format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
+    SDL_Surface *surface;
+
+    // TODO: read from texture rendertarget.
+    if (renderer->target) {
+        SDL_Unsupported();
+        return NULL;
+    }
+
+    surface = SDL_CreateSurface(rect->w, rect->h, format);
+    if (!surface) {
+        return NULL;
+    }
+
+    int y = rect->y;
+    if (!renderer->target) {
+        int w, h;
+        SDL_GetRenderOutputSize(renderer, &w, &h);
+        y = (h - y) - rect->h;
+    }
+
+    read_pixels(rect->x, y, rect->w, rect->h, surface->pixels);
+
+    // Flip the rows to be top-down if necessary
+    if (!renderer->target) {
+        SDL_FlipSurface(surface, SDL_FLIP_VERTICAL);
+    }
+    return surface;
+}
+
+static bool VITA_GXM_RenderPresent(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    SceCommonDialogUpdateParam updateParam;
+
+    data->displayData.address = data->displayBufferData[data->backBufferIndex];
+
+    SDL_memset(&updateParam, 0, sizeof(updateParam));
+
+    updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT;
+    updateParam.renderTarget.surfaceType = SCE_GXM_COLOR_SURFACE_LINEAR;
+    updateParam.renderTarget.width = VITA_GXM_SCREEN_WIDTH;
+    updateParam.renderTarget.height = VITA_GXM_SCREEN_HEIGHT;
+    updateParam.renderTarget.strideInPixels = VITA_GXM_SCREEN_STRIDE;
+
+    updateParam.renderTarget.colorSurfaceData = data->displayBufferData[data->backBufferIndex];
+    updateParam.renderTarget.depthSurfaceData = data->depthBufferData;
+
+    updateParam.displaySyncObject = (SceGxmSyncObject *)data->displayBufferSync[data->backBufferIndex];
+
+    sceCommonDialogUpdate(&updateParam);
+
+#ifdef DEBUG_RAZOR
+    sceGxmPadHeartbeat(
+        (const SceGxmColorSurface *)&data->displaySurface[data->backBufferIndex],
+        (SceGxmSyncObject *)data->displayBufferSync[data->backBufferIndex]);
+#endif
+
+    sceGxmDisplayQueueAddEntry(
+        data->displayBufferSync[data->frontBufferIndex], // OLD fb
+        data->displayBufferSync[data->backBufferIndex],  // NEW fb
+        &data->displayData);
+
+    // update buffer indices
+    data->frontBufferIndex = data->backBufferIndex;
+    data->backBufferIndex = (data->backBufferIndex + 1) % VITA_GXM_BUFFERS;
+    data->pool_index = 0;
+
+    data->current_pool = (data->current_pool + 1) % 2;
+    return true;
+}
+
+static void VITA_GXM_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    VITA_GXM_TextureData *vita_texture = (VITA_GXM_TextureData *)texture->internal;
+
+    if (!data) {
+        return;
+    }
+
+    if (!vita_texture) {
+        return;
+    }
+
+    if (!vita_texture->tex) {
+        return;
+    }
+
+    sceGxmFinish(data->gxm_context);
+
+    free_gxm_texture(data, vita_texture->tex);
+
+    SDL_free(vita_texture);
+
+    texture->internal = NULL;
+}
+
+static void VITA_GXM_DestroyRenderer(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+    if (data) {
+        if (!data->initialized) {
+            return;
+        }
+
+        gxm_finish(renderer);
+
+        data->initialized = false;
+        data->drawing = false;
+        SDL_free(data);
+    }
+}
+
+#endif // SDL_VIDEO_RENDER_VITA_GXM
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_memory.c b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_memory.c
new file mode 100644
index 0000000..e37a345
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_memory.c
@@ -0,0 +1,179 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_VITA_GXM
+
+#include "SDL_render_vita_gxm_memory.h"
+
+void *vita_mem_alloc(unsigned int type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid)
+{
+    void *mem;
+
+    if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW) {
+        size = ALIGN(size, 256 * 1024);
+    } else if (type == SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW) {
+        size = ALIGN(size, 1024 * 1024);
+    } else {
+        size = ALIGN(size, 4 * 1024);
+    }
+
+    *uid = sceKernelAllocMemBlock("gpu_mem", type, size, NULL);
+
+    if (*uid < 0) {
+        return NULL;
+    }
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0) {
+        return NULL;
+    }
+
+    if (sceGxmMapMemory(mem, size, attribs) < 0) {
+        return NULL;
+    }
+
+    return mem;
+}
+
+void vita_mem_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0) {
+        return;
+    }
+    sceGxmUnmapMemory(mem);
+    sceKernelFreeMemBlock(uid);
+}
+
+void *vita_gpu_mem_alloc(VITA_GXM_RenderData *data, unsigned int size)
+{
+    void *mem;
+
+    if (!data->texturePool) {
+        int poolsize;
+        int ret;
+        SceKernelFreeMemorySizeInfo info;
+        info.size = sizeof(SceKernelFreeMemorySizeInfo);
+        sceKernelGetFreeMemorySize(&info);
+
+        poolsize = ALIGN(info.size_cdram, 256 * 1024);
+        if (poolsize > info.size_cdram) {
+            poolsize = ALIGN(info.size_cdram - 256 * 1024, 256 * 1024);
+        }
+        data->texturePoolUID = sceKernelAllocMemBlock("gpu_texture_pool", SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, poolsize, NULL);
+        if (data->texturePoolUID < 0) {
+            return NULL;
+        }
+
+        ret = sceKernelGetMemBlockBase(data->texturePoolUID, &mem);
+        if (ret < 0) {
+            return NULL;
+        }
+        data->texturePool = sceClibMspaceCreate(mem, poolsize);
+
+        if (!data->texturePool) {
+            return NULL;
+        }
+        ret = sceGxmMapMemory(mem, poolsize, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE);
+        if (ret < 0) {
+            return NULL;
+        }
+    }
+    return sceClibMspaceMemalign(data->texturePool, SCE_GXM_TEXTURE_ALIGNMENT, size);
+}
+
+void vita_gpu_mem_free(VITA_GXM_RenderData *data, void *ptr)
+{
+    if (data->texturePool) {
+        sceClibMspaceFree(data->texturePool, ptr);
+    }
+}
+
+void vita_gpu_mem_destroy(VITA_GXM_RenderData *data)
+{
+    void *mem = NULL;
+    if (data->texturePool) {
+        sceClibMspaceDestroy(data->texturePool);
+        data->texturePool = NULL;
+        if (sceKernelGetMemBlockBase(data->texturePoolUID, &mem) < 0) {
+            return;
+        }
+        sceGxmUnmapMemory(mem);
+        sceKernelFreeMemBlock(data->texturePoolUID);
+    }
+}
+
+void *vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
+{
+    void *mem = NULL;
+
+    size = ALIGN(size, 4096);
+    *uid = sceKernelAllocMemBlock("vertex_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL);
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0) {
+        return NULL;
+    }
+    if (sceGxmMapVertexUsseMemory(mem, size, usse_offset) < 0) {
+        return NULL;
+    }
+
+    return mem;
+}
+
+void vita_mem_vertex_usse_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0) {
+        return;
+    }
+    sceGxmUnmapVertexUsseMemory(mem);
+    sceKernelFreeMemBlock(uid);
+}
+
+void *vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset)
+{
+    void *mem = NULL;
+
+    size = ALIGN(size, 4096);
+    *uid = sceKernelAllocMemBlock("fragment_usse", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, size, NULL);
+
+    if (sceKernelGetMemBlockBase(*uid, &mem) < 0) {
+        return NULL;
+    }
+    if (sceGxmMapFragmentUsseMemory(mem, size, usse_offset) < 0) {
+        return NULL;
+    }
+
+    return mem;
+}
+
+void vita_mem_fragment_usse_free(SceUID uid)
+{
+    void *mem = NULL;
+    if (sceKernelGetMemBlockBase(uid, &mem) < 0) {
+        return;
+    }
+    sceGxmUnmapFragmentUsseMemory(mem);
+    sceKernelFreeMemBlock(uid);
+}
+
+#endif // SDL_VIDEO_RENDER_VITA_GXM
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_memory.h b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_memory.h
new file mode 100644
index 0000000..cc548b3
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_memory.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_MEMORY_H
+#define SDL_RENDER_VITA_GXM_MEMORY_H
+
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+#include "SDL_render_vita_gxm_types.h"
+
+#define ALIGN(x, a) (((x) + ((a)-1)) & ~((a)-1))
+
+void *vita_mem_alloc(unsigned int type, unsigned int size, unsigned int alignment, unsigned int attribs, SceUID *uid);
+void vita_mem_free(SceUID uid);
+void *vita_gpu_mem_alloc(VITA_GXM_RenderData *data, unsigned int size);
+void vita_gpu_mem_free(VITA_GXM_RenderData *data, void *ptr);
+void vita_gpu_mem_destroy(VITA_GXM_RenderData *data);
+void *vita_mem_vertex_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
+void vita_mem_vertex_usse_free(SceUID uid);
+void *vita_mem_fragment_usse_alloc(unsigned int size, SceUID *uid, unsigned int *usse_offset);
+void vita_mem_fragment_usse_free(SceUID uid);
+
+#endif // SDL_RENDER_VITA_GXM_MEMORY_H
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_shaders.h b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_shaders.h
new file mode 100644
index 0000000..ef80e03
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_shaders.h
@@ -0,0 +1,282 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_SHADERS_H
+#define SDL_RENDER_VITA_GXM_SHADERS_H
+
+#include <psp2/gxm.h>
+
+/* *INDENT-OFF* */ /* clang-format off */
+
+#define gxm_shader_clear_f_size 232
+static const unsigned char gxm_shader_clear_f[gxm_shader_clear_f_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0xe8, 0x00, 0x00, 0x00, 0xa2, 0x55, 0x22, 0x3e, 
+    0xc6, 0x7e, 0x77, 0xf1, 0x01, 0x00, 0x18, 0x00, 
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0xa4, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x68, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x5c, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x07, 0x44, 0xfa, 0x02, 0x80, 0x19, 0xf0, 
+    0x7e, 0x0d, 0x80, 0x40, 0x0e, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 
+    0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x75, 0x43, 0x6c, 0x65, 
+    0x61, 0x72, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 
+};
+
+#define gxm_shader_clear_v_size 252
+static const unsigned char gxm_shader_clear_v[gxm_shader_clear_v_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0xfa, 0x00, 0x00, 0x00, 0xdc, 0x25, 0x34, 0x74, 
+    0x53, 0x4a, 0x7a, 0x5b, 0x04, 0x00, 0x19, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0xb8, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x70, 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, 
+    0x78, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 
+    0x01, 0x00, 0x04, 0x90, 0x85, 0x11, 0xa5, 0x08, 
+    0x01, 0x80, 0x56, 0x90, 0x81, 0x11, 0x83, 0x08, 
+    0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 
+    0x10, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 
+    0x6e, 0x00, 0x00, 0x00, 
+};
+
+#define gxm_shader_color_f_size 212
+static const unsigned char gxm_shader_color_f[gxm_shader_color_f_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0xd4, 0x00, 0x00, 0x00, 0x9c, 0xd6, 0x9b, 0xf7, 
+    0x78, 0x00, 0x5d, 0x31, 0x01, 0x10, 0x18, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0xac, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 
+    0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x78, 0x00, 0x00, 0x00, 0x74, 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, 
+    0x6c, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x0f, 0xa0, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 
+    0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x07, 0x44, 0xfa, 0x02, 0x80, 0x19, 0xa0, 
+    0x7e, 0x0d, 0x80, 0x40, 
+};
+
+#define gxm_shader_color_v_size 368
+static const unsigned char gxm_shader_color_v[gxm_shader_color_v_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0x6d, 0x01, 0x00, 0x00, 0x09, 0xce, 0x4e, 0xc2, 
+    0xe1, 0xcd, 0x24, 0xbc, 0x00, 0x00, 0x19, 0x00, 
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x00, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x00, 
+    0x98, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 
+    0xb8, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x09, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x43, 0x00, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x07, 0x53, 0x40, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 
+    0x80, 0x00, 0x08, 0x83, 0x21, 0x1d, 0x80, 0x38, 
+    0x00, 0x00, 0xf0, 0x83, 0x20, 0x0d, 0x80, 0x38, 
+    0x0a, 0x84, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40, 
+    0x02, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 
+    0x00, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x01, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x40, 0x00, 0x10, 0x41, 0x09, 0x05, 0x82, 0x38, 
+    0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 
+    0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 
+    0x30, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x2a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x21, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 
+    0x6e, 0x00, 0x61, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 
+    0x00, 0x77, 0x76, 0x70, 0x00, 0x00, 0x00, 0x00, 
+};
+
+#define gxm_shader_texture_f_size 288
+static const unsigned char gxm_shader_texture_f[gxm_shader_texture_f_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0x20, 0x01, 0x00, 0x00, 0xeb, 0x4f, 0xb5, 0xba, 
+    0x60, 0xb2, 0xd0, 0x8d, 0x05, 0x18, 0x18, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0xc4, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 
+    0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x78, 0x00, 0x00, 0x00, 0x74, 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, 
+    0x84, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 
+    0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+    0x01, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x00, 0xa9, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 
+    0xf0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x07, 0x44, 0xfa, 0x00, 0x00, 0x00, 0x00, 
+    0x40, 0x09, 0x00, 0xf8, 0x02, 0x80, 0x99, 0xaf, 
+    0xbc, 0x0d, 0xc0, 0x40, 0x06, 0x82, 0xb9, 0xaf, 
+    0xbc, 0x0d, 0x80, 0x40, 0x7c, 0x0f, 0x04, 0x00, 
+    0x86, 0x47, 0xa4, 0x10, 0x30, 0x00, 0x00, 0x00, 
+    0x02, 0x04, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 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, 0x74, 0x65, 0x78, 0x00, 
+};
+
+#define gxm_shader_texture_v_size 400
+static const unsigned char gxm_shader_texture_v[gxm_shader_texture_v_size] = {
+    0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 
+    0x8f, 0x01, 0x00, 0x00, 0x60, 0x1e, 0x69, 0x97, 
+    0x82, 0x7e, 0x0c, 0xac, 0x00, 0x00, 0x19, 0x00, 
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x08, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 
+    0x0c, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00, 
+    0x98, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
+    0x74, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 
+    0xc0, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x33, 0x0f, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x0a, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x43, 0x00, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x07, 0x53, 0x40, 0x61, 
+    0x86, 0x81, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 
+    0x01, 0x0e, 0x01, 0x01, 0x02, 0x00, 0x10, 0xfa, 
+    0x80, 0x00, 0x08, 0x83, 0x21, 0x25, 0x80, 0x38, 
+    0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x14, 0xfa, 
+    0x00, 0x00, 0xf0, 0x83, 0x20, 0x0d, 0x80, 0x38, 
+    0x0a, 0x84, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40, 
+    0x02, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 
+    0x00, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x01, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18, 
+    0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 
+    0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 
+    0x40, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x3a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 
+    0x34, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 
+    0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 
+    0x2b, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+    0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 
+    0x6e, 0x00, 0x61, 0x54, 0x65, 0x78, 0x63, 0x6f, 
+    0x6f, 0x72, 0x64, 0x00, 0x61, 0x43, 0x6f, 0x6c, 
+    0x6f, 0x72, 0x00, 0x77, 0x76, 0x70, 0x00, 0x00, 
+};
+
+/* *INDENT-ON* */ /* clang-format on */
+
+static const SceGxmProgram *const clearVertexProgramGxp = (const SceGxmProgram *)gxm_shader_clear_v;
+static const SceGxmProgram *const clearFragmentProgramGxp = (const SceGxmProgram *)gxm_shader_clear_f;
+static const SceGxmProgram *const colorVertexProgramGxp = (const SceGxmProgram *)gxm_shader_color_v;
+static const SceGxmProgram *const colorFragmentProgramGxp = (const SceGxmProgram *)gxm_shader_color_f;
+static const SceGxmProgram *const textureVertexProgramGxp = (const SceGxmProgram *)gxm_shader_texture_v;
+static const SceGxmProgram *const textureFragmentProgramGxp = (const SceGxmProgram *)gxm_shader_texture_f;
+
+#endif // SDL_RENDER_VITA_GXM_SHADERS_H
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_tools.c b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_tools.c
new file mode 100644
index 0000000..9140a62
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_tools.c
@@ -0,0 +1,1213 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_VITA_GXM
+
+#include "../SDL_sysrender.h"
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/appmgr.h>
+#include <psp2/display.h>
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+#include <psp2/message_dialog.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include "SDL_render_vita_gxm_tools.h"
+#include "SDL_render_vita_gxm_types.h"
+#include "SDL_render_vita_gxm_memory.h"
+#include "SDL_render_vita_gxm_shaders.h"
+
+void init_orthographic_matrix(float *m, float left, float right, float bottom, float top, float near, float far)
+{
+    m[0x0] = 2.0f / (right - left);
+    m[0x4] = 0.0f;
+    m[0x8] = 0.0f;
+    m[0xC] = -(right + left) / (right - left);
+
+    m[0x1] = 0.0f;
+    m[0x5] = 2.0f / (top - bottom);
+    m[0x9] = 0.0f;
+    m[0xD] = -(top + bottom) / (top - bottom);
+
+    m[0x2] = 0.0f;
+    m[0x6] = 0.0f;
+    m[0xA] = -2.0f / (far - near);
+    m[0xE] = (far + near) / (far - near);
+
+    m[0x3] = 0.0f;
+    m[0x7] = 0.0f;
+    m[0xB] = 0.0f;
+    m[0xF] = 1.0f;
+}
+
+static void *patcher_host_alloc(void *user_data, unsigned int size)
+{
+    void *mem = SDL_malloc(size);
+    (void)user_data;
+    return mem;
+}
+
+static void patcher_host_free(void *user_data, void *mem)
+{
+    (void)user_data;
+    SDL_free(mem);
+}
+
+void *pool_malloc(VITA_GXM_RenderData *data, unsigned int size)
+{
+
+    if ((data->pool_index + size) < VITA_GXM_POOL_SIZE) {
+        void *addr = (void *)((unsigned int)data->pool_addr[data->current_pool] + data->pool_index);
+        data->pool_index += size;
+        return addr;
+    }
+    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "POOL OVERFLOW");
+    return NULL;
+}
+
+void *pool_memalign(VITA_GXM_RenderData *data, unsigned int size, unsigned int alignment)
+{
+    unsigned int new_index = (data->pool_index + alignment - 1) & ~(alignment - 1);
+    if ((new_index + size) < VITA_GXM_POOL_SIZE) {
+        void *addr = (void *)((unsigned int)data->pool_addr[data->current_pool] + new_index);
+        data->pool_index = new_index + size;
+        return addr;
+    }
+    SDL_LogError(SDL_LOG_CATEGORY_RENDER, "POOL OVERFLOW");
+    return NULL;
+}
+
+static int tex_format_to_bytespp(SceGxmTextureFormat format)
+{
+    switch (format & 0x9f000000U) {
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_P8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2: // YUV actually uses 12 bits per pixel. UV planes bits/mem are handled elsewhere
+    case SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3:
+        return 1;
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U3U3U2:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U5U6U5:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S5S5U6:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8:
+        return 2;
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8:
+        return 3;
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_F32:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_U32:
+    case SCE_GXM_TEXTURE_BASE_FORMAT_S32:
+    default:
+        return 4;
+    }
+}
+
+static void display_callback(const void *callback_data)
+{
+    SceDisplayFrameBuf framebuf;
+    const VITA_GXM_DisplayData *display_data = (const VITA_GXM_DisplayData *)callback_data;
+
+    SDL_memset(&framebuf, 0x00, sizeof(SceDisplayFrameBuf));
+    framebuf.size = sizeof(SceDisplayFrameBuf);
+    framebuf.base = display_data->address;
+    framebuf.pitch = VITA_GXM_SCREEN_STRIDE;
+    framebuf.pixelformat = VITA_GXM_PIXEL_FORMAT;
+    framebuf.width = VITA_GXM_SCREEN_WIDTH;
+    framebuf.height = VITA_GXM_SCREEN_HEIGHT;
+    sceDisplaySetFrameBuf(&framebuf, SCE_DISPLAY_SETBUF_NEXTFRAME);
+
+    if (display_data->wait_vblank) {
+        sceDisplayWaitVblankStart();
+    }
+}
+
+static void free_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out)
+{
+    sceGxmShaderPatcherReleaseFragmentProgram(data->shaderPatcher, out->color);
+    sceGxmShaderPatcherReleaseFragmentProgram(data->shaderPatcher, out->texture);
+}
+
+static void make_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out,
+                                   const SceGxmBlendInfo *blend_info)
+{
+    int err;
+
+    err = sceGxmShaderPatcherCreateFragmentProgram(
+        data->shaderPatcher,
+        data->colorFragmentProgramId,
+        SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
+        0,
+        blend_info,
+        colorVertexProgramGxp,
+        &out->color);
+
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Patcher create fragment failed: %d", err);
+        return;
+    }
+
+    err = sceGxmShaderPatcherCreateFragmentProgram(
+        data->shaderPatcher,
+        data->textureFragmentProgramId,
+        SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
+        0,
+        blend_info,
+        textureVertexProgramGxp,
+        &out->texture);
+
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Patcher create fragment failed: %d", err);
+        return;
+    }
+}
+
+static void set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h)
+{
+    void *vertexDefaultBuffer;
+    color_vertex *vertices = (color_vertex *)pool_memalign(
+        data,
+        4 * sizeof(color_vertex), // 4 vertices
+        sizeof(color_vertex));
+
+    vertices[0].x = x;
+    vertices[0].y = y;
+    vertices[0].color.r = 0;
+    vertices[0].color.g = 0;
+    vertices[0].color.b = 0;
+    vertices[0].color.a = 0;
+
+    vertices[1].x = x + w;
+    vertices[1].y = y;
+    vertices[1].color.r = 0;
+    vertices[1].color.g = 0;
+    vertices[1].color.b = 0;
+    vertices[1].color.a = 0;
+
+    vertices[2].x = x;
+    vertices[2].y = y + h;
+    vertices[2].color.r = 0;
+    vertices[2].color.g = 0;
+    vertices[2].color.b = 0;
+    vertices[2].color.a = 0;
+
+    vertices[3].x = x + w;
+    vertices[3].y = y + h;
+    vertices[3].color.r = 0;
+    vertices[3].color.g = 0;
+    vertices[3].color.b = 0;
+    vertices[3].color.a = 0;
+
+    data->drawstate.fragment_program = data->colorFragmentProgram;
+    data->drawstate.vertex_program = data->colorVertexProgram;
+    sceGxmSetVertexProgram(data->gxm_context, data->colorVertexProgram);
+    sceGxmSetFragmentProgram(data->gxm_context, data->colorFragmentProgram);
+
+    sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer);
+    sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix);
+
+    sceGxmSetVertexStream(data->gxm_context, 0, vertices);
+    sceGxmDraw(data->gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_STRIP, SCE_GXM_INDEX_FORMAT_U16, data->linearIndices, 4);
+}
+
+void set_clip_rectangle(VITA_GXM_RenderData *data, int x_min, int y_min, int x_max, int y_max)
+{
+    if (data->drawing) {
+        // clear the stencil buffer to 0
+        sceGxmSetFrontStencilFunc(
+            data->gxm_context,
+            SCE_GXM_STENCIL_FUNC_NEVER,
+            SCE_GXM_STENCIL_OP_ZERO,
+            SCE_GXM_STENCIL_OP_ZERO,
+            SCE_GXM_STENCIL_OP_ZERO,
+            0xFF,
+            0xFF);
+
+        set_stencil_mask(data, 0, 0, VITA_GXM_SCREEN_WIDTH, VITA_GXM_SCREEN_HEIGHT);
+
+        // set the stencil to 1 in the desired region
+        sceGxmSetFrontStencilFunc(
+            data->gxm_context,
+            SCE_GXM_STENCIL_FUNC_NEVER,
+            SCE_GXM_STENCIL_OP_REPLACE,
+            SCE_GXM_STENCIL_OP_REPLACE,
+            SCE_GXM_STENCIL_OP_REPLACE,
+            0xFF,
+            0xFF);
+
+        set_stencil_mask(data, x_min, y_min, x_max - x_min, y_max - y_min);
+
+        // set the stencil function to only accept pixels where the stencil is 1
+        sceGxmSetFrontStencilFunc(
+            data->gxm_context,
+            SCE_GXM_STENCIL_FUNC_EQUAL,
+            SCE_GXM_STENCIL_OP_KEEP,
+            SCE_GXM_STENCIL_OP_KEEP,
+            SCE_GXM_STENCIL_OP_KEEP,
+            0xFF,
+            0xFF);
+    }
+}
+
+void unset_clip_rectangle(VITA_GXM_RenderData *data)
+{
+    sceGxmSetFrontStencilFunc(
+        data->gxm_context,
+        SCE_GXM_STENCIL_FUNC_ALWAYS,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        0xFF,
+        0xFF);
+}
+
+int gxm_init(SDL_Renderer *renderer)
+{
+    unsigned int i, x, y;
+    int err;
+    void *vdmRingBuffer;
+    void *vertexRingBuffer;
+    void *fragmentRingBuffer;
+    unsigned int fragmentUsseRingBufferOffset;
+    void *fragmentUsseRingBuffer;
+    unsigned int patcherVertexUsseOffset;
+    unsigned int patcherFragmentUsseOffset;
+    void *patcherBuffer;
+    void *patcherVertexUsse;
+    void *patcherFragmentUsse;
+
+    SceGxmRenderTargetParams renderTargetParams;
+    SceGxmShaderPatcherParams patcherParams;
+
+    // compute the memory footprint of the depth buffer
+    const unsigned int alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX);
+    const unsigned int alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY);
+
+    unsigned int sampleCount = alignedWidth * alignedHeight;
+    unsigned int depthStrideInSamples = alignedWidth;
+
+    // set buffer sizes for this sample
+    const unsigned int patcherBufferSize = 64 * 1024;
+    const unsigned int patcherVertexUsseSize = 64 * 1024;
+    const unsigned int patcherFragmentUsseSize = 64 * 1024;
+
+    // Fill SceGxmBlendInfo
+    static const SceGxmBlendInfo blend_info_none = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_NONE,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_NONE,
+        .colorSrc = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorDst = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_blend = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
+        .colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .alphaSrc = SCE_GXM_BLEND_FACTOR_ONE,
+        .alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_add = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
+        .colorDst = SCE_GXM_BLEND_FACTOR_ONE,
+        .alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst = SCE_GXM_BLEND_FACTOR_ONE,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_mod = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+
+        .colorSrc = SCE_GXM_BLEND_FACTOR_ZERO,
+        .colorDst = SCE_GXM_BLEND_FACTOR_SRC_COLOR,
+
+        .alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
+        .alphaDst = SCE_GXM_BLEND_FACTOR_ONE,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    static const SceGxmBlendInfo blend_info_mul = {
+        .colorFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
+        .colorSrc = SCE_GXM_BLEND_FACTOR_DST_COLOR,
+        .colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .alphaSrc = SCE_GXM_BLEND_FACTOR_DST_ALPHA,
+        .alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+        .colorMask = SCE_GXM_COLOR_MASK_ALL
+    };
+
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+
+    SceGxmInitializeParams initializeParams;
+    SDL_memset(&initializeParams, 0, sizeof(SceGxmInitializeParams));
+    initializeParams.flags = 0;
+    initializeParams.displayQueueMaxPendingCount = VITA_GXM_PENDING_SWAPS;
+    initializeParams.displayQueueCallback = display_callback;
+    initializeParams.displayQueueCallbackDataSize = sizeof(VITA_GXM_DisplayData);
+    initializeParams.parameterBufferSize = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE;
+
+    err = sceGxmInitialize(&initializeParams);
+
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "gxm init failed: %d", err);
+        return err;
+    }
+
+    // allocate ring buffer memory using default sizes
+    vdmRingBuffer = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->vdmRingBufferUid);
+
+    vertexRingBuffer = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->vertexRingBufferUid);
+
+    fragmentRingBuffer = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->fragmentRingBufferUid);
+
+    fragmentUsseRingBuffer = vita_mem_fragment_usse_alloc(
+        SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE,
+        &data->fragmentUsseRingBufferUid,
+        &fragmentUsseRingBufferOffset);
+
+    SDL_memset(&data->contextParams, 0, sizeof(SceGxmContextParams));
+    data->contextParams.hostMem = SDL_malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE);
+    data->contextParams.hostMemSize = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE;
+    data->contextParams.vdmRingBufferMem = vdmRingBuffer;
+    data->contextParams.vdmRingBufferMemSize = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE;
+    data->contextParams.vertexRingBufferMem = vertexRingBuffer;
+    data->contextParams.vertexRingBufferMemSize = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE;
+    data->contextParams.fragmentRingBufferMem = fragmentRingBuffer;
+    data->contextParams.fragmentRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE;
+    data->contextParams.fragmentUsseRingBufferMem = fragmentUsseRingBuffer;
+    data->contextParams.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE;
+    data->contextParams.fragmentUsseRingBufferOffset = fragmentUsseRingBufferOffset;
+
+    err = sceGxmCreateContext(&data->contextParams, &data->gxm_context);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create context failed: %d", err);
+        return err;
+    }
+
+    // set up parameters
+    SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
+    renderTargetParams.flags = 0;
+    renderTargetParams.width = VITA_GXM_SCREEN_WIDTH;
+    renderTargetParams.height = VITA_GXM_SCREEN_HEIGHT;
+    renderTargetParams.scenesPerFrame = 1;
+    renderTargetParams.multisampleMode = 0;
+    renderTargetParams.multisampleLocations = 0;
+    renderTargetParams.driverMemBlock = -1; // Invalid UID
+
+    // create the render target
+    err = sceGxmCreateRenderTarget(&renderTargetParams, &data->renderTarget);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "render target creation failed: %d", err);
+        return err;
+    }
+
+    // allocate memory and sync objects for display buffers
+    for (i = 0; i < VITA_GXM_BUFFERS; i++) {
+
+        // allocate memory for display
+        data->displayBufferData[i] = vita_mem_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
+            4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
+            SCE_GXM_COLOR_SURFACE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &data->displayBufferUid[i]);
+
+        // SDL_memset the buffer to black
+        for (y = 0; y < VITA_GXM_SCREEN_HEIGHT; y++) {
+            unsigned int *row = (unsigned int *)data->displayBufferData[i] + y * VITA_GXM_SCREEN_STRIDE;
+            for (x = 0; x < VITA_GXM_SCREEN_WIDTH; x++) {
+                row[x] = 0xff000000;
+            }
+        }
+
+        // initialize a color surface for this display buffer
+        err = sceGxmColorSurfaceInit(
+            &data->displaySurface[i],
+            VITA_GXM_COLOR_FORMAT,
+            SCE_GXM_COLOR_SURFACE_LINEAR,
+            SCE_GXM_COLOR_SURFACE_SCALE_NONE,
+            SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
+            VITA_GXM_SCREEN_WIDTH,
+            VITA_GXM_SCREEN_HEIGHT,
+            VITA_GXM_SCREEN_STRIDE,
+            data->displayBufferData[i]);
+
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "color surface init failed: %d", err);
+            return err;
+        }
+
+        // create a sync object that we will associate with this buffer
+        err = sceGxmSyncObjectCreate(&data->displayBufferSync[i]);
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "sync object creation failed: %d", err);
+            return err;
+        }
+    }
+
+    // allocate the depth buffer
+    data->depthBufferData = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        4 * sampleCount,
+        SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &data->depthBufferUid);
+
+    // allocate the stencil buffer
+    data->stencilBufferData = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        4 * sampleCount,
+        SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &data->stencilBufferUid);
+
+    // create the SceGxmDepthStencilSurface structure
+    err = sceGxmDepthStencilSurfaceInit(
+        &data->depthSurface,
+        SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24,
+        SCE_GXM_DEPTH_STENCIL_SURFACE_TILED,
+        depthStrideInSamples,
+        data->depthBufferData,
+        data->stencilBufferData);
+
+    // set the stencil test reference (this is currently assumed to always remain 1 after here for region clipping)
+    sceGxmSetFrontStencilRef(data->gxm_context, 1);
+
+    // set the stencil function (this wouldn't actually be needed, as the set clip rectangle function has to call this at the beginning of every scene)
+    sceGxmSetFrontStencilFunc(
+        data->gxm_context,
+        SCE_GXM_STENCIL_FUNC_ALWAYS,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        SCE_GXM_STENCIL_OP_KEEP,
+        0xFF,
+        0xFF);
+
+    // allocate memory for buffers and USSE code
+    patcherBuffer = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        patcherBufferSize,
+        4,
+        SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+        &data->patcherBufferUid);
+
+    patcherVertexUsse = vita_mem_vertex_usse_alloc(
+        patcherVertexUsseSize,
+        &data->patcherVertexUsseUid,
+        &patcherVertexUsseOffset);
+
+    patcherFragmentUsse = vita_mem_fragment_usse_alloc(
+        patcherFragmentUsseSize,
+        &data->patcherFragmentUsseUid,
+        &patcherFragmentUsseOffset);
+
+    // create a shader patcher
+    SDL_memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams));
+    patcherParams.userData = NULL;
+    patcherParams.hostAllocCallback = &patcher_host_alloc;
+    patcherParams.hostFreeCallback = &patcher_host_free;
+    patcherParams.bufferAllocCallback = NULL;
+    patcherParams.bufferFreeCallback = NULL;
+    patcherParams.bufferMem = patcherBuffer;
+    patcherParams.bufferMemSize = patcherBufferSize;
+    patcherParams.vertexUsseAllocCallback = NULL;
+    patcherParams.vertexUsseFreeCallback = NULL;
+    patcherParams.vertexUsseMem = patcherVertexUsse;
+    patcherParams.vertexUsseMemSize = patcherVertexUsseSize;
+    patcherParams.vertexUsseOffset = patcherVertexUsseOffset;
+    patcherParams.fragmentUsseAllocCallback = NULL;
+    patcherParams.fragmentUsseFreeCallback = NULL;
+    patcherParams.fragmentUsseMem = patcherFragmentUsse;
+    patcherParams.fragmentUsseMemSize = patcherFragmentUsseSize;
+    patcherParams.fragmentUsseOffset = patcherFragmentUsseOffset;
+
+    err = sceGxmShaderPatcherCreate(&patcherParams, &data->shaderPatcher);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "shader patcher creation failed: %d", err);
+        return err;
+    }
+
+    // check the shaders
+    err = sceGxmProgramCheck(clearVertexProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (clear vertex) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(clearFragmentProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (clear fragment) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(colorVertexProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (color vertex) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(colorFragmentProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (color fragment) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(textureVertexProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (texture vertex) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmProgramCheck(textureFragmentProgramGxp);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "check program (texture fragment) failed: %d", err);
+        return err;
+    }
+
+    // register programs with the patcher
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, clearVertexProgramGxp, &data->clearVertexProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (clear vertex) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, clearFragmentProgramGxp, &data->clearFragmentProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (clear fragment) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, colorVertexProgramGxp, &data->colorVertexProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (color vertex) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, colorFragmentProgramGxp, &data->colorFragmentProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (color fragment) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, textureVertexProgramGxp, &data->textureVertexProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (texture vertex) failed: %d", err);
+        return err;
+    }
+
+    err = sceGxmShaderPatcherRegisterProgram(data->shaderPatcher, textureFragmentProgramGxp, &data->textureFragmentProgramId);
+    if (err != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "register program (texture fragment) failed: %d", err);
+        return err;
+    }
+
+    {
+        // get attributes by name to create vertex format bindings
+        const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
+
+        // create clear vertex format
+        SceGxmVertexAttribute clearVertexAttributes[1];
+        SceGxmVertexStream clearVertexStreams[1];
+        clearVertexAttributes[0].streamIndex = 0;
+        clearVertexAttributes[0].offset = 0;
+        clearVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        clearVertexAttributes[0].componentCount = 2;
+        clearVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramClearPositionAttribute);
+        clearVertexStreams[0].stride = sizeof(clear_vertex);
+        clearVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
+
+        // create clear programs
+        err = sceGxmShaderPatcherCreateVertexProgram(
+            data->shaderPatcher,
+            data->clearVertexProgramId,
+            clearVertexAttributes,
+            1,
+            clearVertexStreams,
+            1,
+            &data->clearVertexProgram);
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear vertex) failed: %d", err);
+            return err;
+        }
+
+        err = sceGxmShaderPatcherCreateFragmentProgram(
+            data->shaderPatcher,
+            data->clearFragmentProgramId,
+            SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
+            0,
+            NULL,
+            clearVertexProgramGxp,
+            &data->clearFragmentProgram);
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear fragment) failed: %d", err);
+            return err;
+        }
+
+        // create the clear triangle vertex/index data
+        data->clearVertices = (clear_vertex *)vita_mem_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+            3 * sizeof(clear_vertex),
+            4,
+            SCE_GXM_MEMORY_ATTRIB_READ,
+            &data->clearVerticesUid);
+    }
+
+    // Allocate a 64k * 2 bytes = 128 KiB buffer and store all possible
+    // 16-bit indices in linear ascending order, so we can use this for
+    // all drawing operations where we don't want to use indexing.
+    data->linearIndices = (uint16_t *)vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+        UINT16_MAX * sizeof(uint16_t),
+        sizeof(uint16_t),
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->linearIndicesUid);
+
+    for (i = 0; i <= UINT16_MAX; ++i) {
+        data->linearIndices[i] = i;
+    }
+
+    data->clearVertices[0].x = -1.0f;
+    data->clearVertices[0].y = -1.0f;
+    data->clearVertices[1].x = 3.0f;
+    data->clearVertices[1].y = -1.0f;
+    data->clearVertices[2].x = -1.0f;
+    data->clearVertices[2].y = 3.0f;
+
+    {
+        const SceGxmProgramParameter *paramColorPositionAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aPosition");
+
+        const SceGxmProgramParameter *paramColorColorAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aColor");
+
+        // create color vertex format
+        SceGxmVertexAttribute colorVertexAttributes[2];
+        SceGxmVertexStream colorVertexStreams[1];
+        // x,y: 2 float 32 bits
+        colorVertexAttributes[0].streamIndex = 0;
+        colorVertexAttributes[0].offset = 0;
+        colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        colorVertexAttributes[0].componentCount = 2; // (x, y)
+        colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute);
+        // color: 4 floats = 4*32 bits
+        colorVertexAttributes[1].streamIndex = 0;
+        colorVertexAttributes[1].offset = 8; // (x, y) * 4 = 8 bytes
+        colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        colorVertexAttributes[1].componentCount = 4; // (color)
+        colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute);
+        // 16 bit (short) indices
+        colorVertexStreams[0].stride = sizeof(color_vertex);
+        colorVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
+
+        // create color shaders
+        err = sceGxmShaderPatcherCreateVertexProgram(
+            data->shaderPatcher,
+            data->colorVertexProgramId,
+            colorVertexAttributes,
+            2,
+            colorVertexStreams,
+            1,
+            &data->colorVertexProgram);
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (color vertex) failed: %d", err);
+            return err;
+        }
+    }
+
+    {
+        const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
+        const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
+        const SceGxmProgramParameter *paramTextureColorAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aColor");
+
+        // create texture vertex format
+        SceGxmVertexAttribute textureVertexAttributes[3];
+        SceGxmVertexStream textureVertexStreams[1];
+        // x,y: 2 float 32 bits
+        textureVertexAttributes[0].streamIndex = 0;
+        textureVertexAttributes[0].offset = 0;
+        textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        textureVertexAttributes[0].componentCount = 2; // (x, y)
+        textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute);
+        // u,v: 2 floats 32 bits
+        textureVertexAttributes[1].streamIndex = 0;
+        textureVertexAttributes[1].offset = 8; // (x, y) * 4 = 8 bytes
+        textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        textureVertexAttributes[1].componentCount = 2; // (u, v)
+        textureVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureTexcoordAttribute);
+        // r,g,b,a: 4 floats 4*32 bits
+        textureVertexAttributes[2].streamIndex = 0;
+        textureVertexAttributes[2].offset = 16; // (x, y, u, v) * 4 = 16 bytes
+        textureVertexAttributes[2].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
+        textureVertexAttributes[2].componentCount = 4; // (r, g, b, a)
+        textureVertexAttributes[2].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureColorAttribute);
+        // 16 bit (short) indices
+        textureVertexStreams[0].stride = sizeof(texture_vertex);
+        textureVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
+
+        // create texture shaders
+        err = sceGxmShaderPatcherCreateVertexProgram(
+            data->shaderPatcher,
+            data->textureVertexProgramId,
+            textureVertexAttributes,
+            3,
+            textureVertexStreams,
+            1,
+            &data->textureVertexProgram);
+        if (err != 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (texture vertex) failed: %x", err);
+            return err;
+        }
+    }
+
+    // Create variations of the fragment program based on blending mode
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none, &blend_info_none);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend, &blend_info_blend);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_add, &blend_info_add);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod, &blend_info_mod);
+    make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul, &blend_info_mul);
+
+    {
+        // Default to blend blending mode
+        fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
+
+        data->colorFragmentProgram = in->color;
+        data->textureFragmentProgram = in->texture;
+    }
+
+    // find vertex uniforms by name and cache parameter information
+    data->clearClearColorParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor");
+    data->colorWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(colorVertexProgramGxp, "wvp");
+    data->textureWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(textureVertexProgramGxp, "wvp");
+
+    // Allocate memory for the memory pool
+    data->pool_addr[0] = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW,
+        VITA_GXM_POOL_SIZE,
+        sizeof(void *),
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->poolUid[0]);
+
+    data->pool_addr[1] = vita_mem_alloc(
+        SCE_KERNEL_MEMBLOCK_TYPE_USER_RW,
+        VITA_GXM_POOL_SIZE,
+        sizeof(void *),
+        SCE_GXM_MEMORY_ATTRIB_READ,
+        &data->poolUid[1]);
+
+    init_orthographic_matrix(data->ortho_matrix, 0.0f, VITA_GXM_SCREEN_WIDTH, VITA_GXM_SCREEN_HEIGHT, 0.0f, 0.0f, 1.0f);
+
+    data->backBufferIndex = 0;
+    data->frontBufferIndex = 0;
+    data->pool_index = 0;
+    data->current_pool = 0;
+    data->currentBlendMode = SDL_BLENDMODE_BLEND;
+
+    return 0;
+}
+
+void gxm_finish(SDL_Renderer *renderer)
+{
+    VITA_GXM_RenderData *data = (VITA_GXM_RenderData *)renderer->internal;
+
+    // wait until rendering is done
+    sceGxmFinish(data->gxm_context);
+
+    // clean up allocations
+    sceGxmShaderPatcherReleaseFragmentProgram(data->shaderPatcher, data->clearFragmentProgram);
+    sceGxmShaderPatcherReleaseVertexProgram(data->shaderPatcher, data->clearVertexProgram);
+    sceGxmShaderPatcherReleaseVertexProgram(data->shaderPatcher, data->colorVertexProgram);
+    sceGxmShaderPatcherReleaseVertexProgram(data->shaderPatcher, data->textureVertexProgram);
+
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_add);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod);
+    free_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul);
+
+    vita_mem_free(data->linearIndicesUid);
+    vita_mem_free(data->clearVerticesUid);
+
+    // wait until display queue is finished before deallocating display buffers
+    sceGxmDisplayQueueFinish();
+
+    // clean up display queue
+    vita_mem_free(data->depthBufferUid);
+
+    for (size_t i = 0; i < VITA_GXM_BUFFERS; i++) {
+        // clear the buffer then deallocate
+        SDL_memset(data->displayBufferData[i], 0, VITA_GXM_SCREEN_HEIGHT * VITA_GXM_SCREEN_STRIDE * 4);
+        vita_mem_free(data->displayBufferUid[i]);
+
+        // destroy the sync object
+        sceGxmSyncObjectDestroy(data->displayBufferSync[i]);
+    }
+
+    // Free the depth and stencil buffer
+    vita_mem_free(data->depthBufferUid);
+    vita_mem_free(data->stencilBufferUid);
+
+    // unregister programs and destroy shader patcher
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->clearFragmentProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->clearVertexProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->colorFragmentProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->colorVertexProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->textureFragmentProgramId);
+    sceGxmShaderPatcherUnregisterProgram(data->shaderPatcher, data->textureVertexProgramId);
+
+    sceGxmShaderPatcherDestroy(data->shaderPatcher);
+    vita_mem_fragment_usse_free(data->patcherFragmentUsseUid);
+    vita_mem_vertex_usse_free(data->patcherVertexUsseUid);
+    vita_mem_free(data->patcherBufferUid);
+
+    // destroy the render target
+    sceGxmDestroyRenderTarget(data->renderTarget);
+
+    // destroy the gxm context
+    sceGxmDestroyContext(data->gxm_context);
+    vita_mem_fragment_usse_free(data->fragmentUsseRingBufferUid);
+    vita_mem_free(data->fragmentRingBufferUid);
+    vita_mem_free(data->vertexRingBufferUid);
+    vita_mem_free(data->vdmRingBufferUid);
+    SDL_free(data->contextParams.hostMem);
+
+    vita_mem_free(data->poolUid[0]);
+    vita_mem_free(data->poolUid[1]);
+    vita_gpu_mem_destroy(data);
+
+    // terminate libgxm
+    sceGxmTerminate();
+}
+
+// textures
+
+void free_gxm_texture(VITA_GXM_RenderData *data, gxm_texture *texture)
+{
+    if (texture) {
+        if (texture->gxm_rendertarget) {
+            sceGxmDestroyRenderTarget(texture->gxm_rendertarget);
+        }
+        if (texture->depth_UID) {
+            vita_mem_free(texture->depth_UID);
+        }
+        if (texture->cdram) {
+            vita_gpu_mem_free(data, sceGxmTextureGetData(&texture->gxm_tex));
+        } else {
+            vita_mem_free(texture->data_UID);
+        }
+        SDL_free(texture);
+    }
+}
+
+SceGxmTextureFormat
+gxm_texture_get_format(const gxm_texture *texture)
+{
+    return sceGxmTextureGetFormat(&texture->gxm_tex);
+}
+
+void *gxm_texture_get_datap(const gxm_texture *texture)
+{
+    return sceGxmTextureGetData(&texture->gxm_tex);
+}
+
+static SceGxmColorFormat tex_format_to_color_format(SceGxmTextureFormat format)
+{
+    switch (format) {
+    case SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB:
+        return SCE_GXM_COLOR_FORMAT_U8U8U8U8_ARGB;
+    case SCE_GXM_TEXTURE_FORMAT_U8U8U8_RGB:
+        return SCE_GXM_COLOR_FORMAT_U8U8U8_RGB;
+    case SCE_GXM_TEXTURE_FORMAT_U8U8U8_BGR:
+        return SCE_GXM_COLOR_FORMAT_U8U8U8_BGR;
+    case SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR:
+        return SCE_GXM_COLOR_FORMAT_U8U8U8U8_ABGR;
+    case SCE_GXM_TEXTURE_FORMAT_U5U6U5_RGB:
+        return SCE_GXM_COLOR_FORMAT_U5U6U5_RGB;
+    case SCE_GXM_TEXTURE_FORMAT_U5U6U5_BGR:
+        return SCE_GXM_COLOR_FORMAT_U5U6U5_BGR;
+    default:
+        return SCE_GXM_COLOR_FORMAT_U8U8U8U8_ABGR;
+    }
+}
+
+gxm_texture *create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget, unsigned int *return_w, unsigned int *return_h, unsigned int *return_pitch, float *return_wscale)
+{
+    gxm_texture *texture = SDL_calloc(1, sizeof(gxm_texture));
+    int aligned_w = ALIGN(w, 8);
+    int texture_w = w;
+    int tex_size = aligned_w * h * tex_format_to_bytespp(format);
+    void *texture_data;
+    int ret;
+
+    *return_wscale = 1.0f;
+
+    // SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3/P2 based formats require width aligned to 16
+    if ((format & 0x9f000000U) == SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P3 || (format & 0x9f000000U) == SCE_GXM_TEXTURE_BASE_FORMAT_YUV420P2) {
+        aligned_w = ALIGN(w, 16);
+        texture_w = aligned_w;
+        tex_size = aligned_w * h * tex_format_to_bytespp(format);
+        *return_wscale = (float)(w) / texture_w;
+        // add storage for UV planes
+        tex_size += (((aligned_w + 1) / 2) * ((h + 1) / 2)) * 2;
+    }
+
+    if (!texture) {
+        return NULL;
+    }
+
+    *return_w = w;
+    *return_h = h;
+    *return_pitch = aligned_w * tex_format_to_bytespp(format);
+
+    // Allocate a GPU buffer for the texture
+    texture_data = vita_gpu_mem_alloc(
+        data,
+        tex_size);
+
+    // Try SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE in case we're out of VRAM
+    if (!texture_data) {
+        SDL_LogWarn(SDL_LOG_CATEGORY_RENDER, "CDRAM texture allocation failed");
+        texture_data = vita_mem_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+            tex_size,
+            SCE_GXM_TEXTURE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &texture->data_UID);
+        texture->cdram = 0;
+    } else {
+        texture->cdram = 1;
+    }
+
+    if (!texture_data) {
+        SDL_free(texture);
+        return NULL;
+    }
+
+    // Clear the texture
+    SDL_memset(texture_data, 0, tex_size);
+
+    // Create the gxm texture
+    ret = sceGxmTextureInitLinear(&texture->gxm_tex, texture_data, format, texture_w, h, 0);
+    if (ret < 0) {
+        free_gxm_texture(data, texture);
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "texture init failed: %x", ret);
+        return NULL;
+    }
+
+    if (isRenderTarget) {
+        void *depthBufferData;
+        const uint32_t alignedWidth = ALIGN(w, SCE_GXM_TILE_SIZEX);
+        const uint32_t alignedHeight = ALIGN(h, SCE_GXM_TILE_SIZEY);
+        uint32_t sampleCount = alignedWidth * alignedHeight;
+        uint32_t depthStrideInSamples = alignedWidth;
+        const uint32_t alignedColorSurfaceStride = ALIGN(w, 8);
+
+        int err = sceGxmColorSurfaceInit(
+            &texture->gxm_colorsurface,
+            tex_format_to_color_format(format),
+            SCE_GXM_COLOR_SURFACE_LINEAR,
+            SCE_GXM_COLOR_SURFACE_SCALE_NONE,
+            SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
+            w,
+            h,
+            alignedColorSurfaceStride,
+            texture_data);
+
+        if (err < 0) {
+            free_gxm_texture(data, texture);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "color surface init failed: %x", err);
+            return NULL;
+        }
+
+        // allocate it
+        depthBufferData = vita_mem_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
+            4 * sampleCount,
+            SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &texture->depth_UID);
+
+        // create the SceGxmDepthStencilSurface structure
+        err = sceGxmDepthStencilSurfaceInit(
+            &texture->gxm_depthstencil,
+            SCE_GXM_DEPTH_STENCIL_FORMAT_S8D24,
+            SCE_GXM_DEPTH_STENCIL_SURFACE_TILED,
+            depthStrideInSamples,
+            depthBufferData,
+            NULL);
+
+        if (err < 0) {
+            free_gxm_texture(data, texture);
+            SDL_LogError(SDL_LOG_CATEGORY_RENDER, "depth stencil init failed: %x", err);
+            return NULL;
+        }
+
+        {
+            SceGxmRenderTarget *tgt = NULL;
+
+            // set up parameters
+            SceGxmRenderTargetParams renderTargetParams;
+            SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
+            renderTargetParams.flags = 0;
+            renderTargetParams.width = w;
+            renderTargetParams.height = h;
+            renderTargetParams.scenesPerFrame = 1;
+            renderTargetParams.multisampleMode = SCE_GXM_MULTISAMPLE_NONE;
+            renderTargetParams.multisampleLocations = 0;
+            renderTargetParams.driverMemBlock = -1;
+
+            // create the render target
+            err = sceGxmCreateRenderTarget(&renderTargetParams, &tgt);
+
+            texture->gxm_rendertarget = tgt;
+
+            if (err < 0) {
+                free_gxm_texture(data, texture);
+                SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %x", err);
+                return NULL;
+            }
+        }
+    }
+
+    return texture;
+}
+
+void gxm_texture_set_filters(gxm_texture *texture, SceGxmTextureFilter min_filter, SceGxmTextureFilter mag_filter)
+{
+    sceGxmTextureSetMinFilter(&texture->gxm_tex, min_filter);
+    sceGxmTextureSetMagFilter(&texture->gxm_tex, mag_filter);
+}
+
+static unsigned int back_buffer_index_for_common_dialog = 0;
+static unsigned int front_buffer_index_for_common_dialog = 0;
+struct
+{
+    VITA_GXM_DisplayData displayData;
+    SceGxmSyncObject *sync;
+    SceGxmColorSurface surf;
+    SceUID uid;
+} buffer_for_common_dialog[VITA_GXM_BUFFERS];
+
+void gxm_minimal_init_for_common_dialog(void)
+{
+    SceGxmInitializeParams initializeParams;
+    SDL_zero(initializeParams);
+    initializeParams.flags = 0;
+    initializeParams.displayQueueMaxPendingCount = VITA_GXM_PENDING_SWAPS;
+    initializeParams.displayQueueCallback = display_callback;
+    initializeParams.displayQueueCallbackDataSize = sizeof(VITA_GXM_DisplayData);
+    initializeParams.parameterBufferSize = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE;
+    sceGxmInitialize(&initializeParams);
+}
+
+void gxm_minimal_term_for_common_dialog(void)
+{
+    sceGxmTerminate();
+}
+
+void gxm_init_for_common_dialog(void)
+{
+    for (int i = 0; i < VITA_GXM_BUFFERS; i += 1) {
+        buffer_for_common_dialog[i].displayData.wait_vblank = true;
+        buffer_for_common_dialog[i].displayData.address = vita_mem_alloc(
+            SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW,
+            4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT,
+            SCE_GXM_COLOR_SURFACE_ALIGNMENT,
+            SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
+            &buffer_for_common_dialog[i].uid);
+        sceGxmColorSurfaceInit(
+            &buffer_for_common_dialog[i].surf,
+            VITA_GXM_PIXEL_FORMAT,
+            SCE_GXM_COLOR_SURFACE_LINEAR,
+            SCE_GXM_COLOR_SURFACE_SCALE_NONE,
+            SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
+            VITA_GXM_SCREEN_WIDTH,
+            VITA_GXM_SCREEN_HEIGHT,
+            VITA_GXM_SCREEN_STRIDE,
+            buffer_for_common_dialog[i].displayData.address);
+        sceGxmSyncObjectCreate(&buffer_for_common_dialog[i].sync);
+    }
+    sceGxmDisplayQueueFinish();
+}
+
+void gxm_swap_for_common_dialog(void)
+{
+    SceCommonDialogUpdateParam updateParam;
+    SDL_zero(updateParam);
+    updateParam.renderTarget.colorFormat = VITA_GXM_PIXEL_FORMAT;
+    updateParam.renderTarget.surfaceType = SCE_GXM_COLOR_SURFACE_LINEAR;
+    updateParam.renderTarget.width = VITA_GXM_SCREEN_WIDTH;
+    updateParam.renderTarget.height = VITA_GXM_SCREEN_HEIGHT;
+    updateParam.renderTarget.strideInPixels = VITA_GXM_SCREEN_STRIDE;
+
+    updateParam.renderTarget.colorSurfaceData = buffer_for_common_dialog[back_buffer_index_for_common_dialog].displayData.address;
+
+    updateParam.displaySyncObject = buffer_for_common_dialog[back_buffer_index_for_common_dialog].sync;
+    SDL_memset(buffer_for_common_dialog[back_buffer_index_for_common_dialog].displayData.address, 0, 4 * VITA_GXM_SCREEN_STRIDE * VITA_GXM_SCREEN_HEIGHT);
+    sceCommonDialogUpdate(&updateParam);
+
+    sceGxmDisplayQueueAddEntry(buffer_for_common_dialog[front_buffer_index_for_common_dialog].sync, buffer_for_common_dialog[back_buffer_index_for_common_dialog].sync, &buffer_for_common_dialog[back_buffer_index_for_common_dialog].displayData);
+    front_buffer_index_for_common_dialog = back_buffer_index_for_common_dialog;
+    back_buffer_index_for_common_dialog = (back_buffer_index_for_common_dialog + 1) % VITA_GXM_BUFFERS;
+}
+
+void gxm_term_for_common_dialog(void)
+{
+    sceGxmDisplayQueueFinish();
+    for (int i = 0; i < VITA_GXM_BUFFERS; i += 1) {
+        vita_mem_free(buffer_for_common_dialog[i].uid);
+        sceGxmSyncObjectDestroy(buffer_for_common_dialog[i].sync);
+    }
+}
+
+#endif // SDL_VIDEO_RENDER_VITA_GXM
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_tools.h b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_tools.h
new file mode 100644
index 0000000..023f859
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_tools.h
@@ -0,0 +1,63 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_TOOLS_H
+#define SDL_RENDER_VITA_GXM_TOOLS_H
+
+#include "SDL_internal.h"
+
+#include "../SDL_sysrender.h"
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/appmgr.h>
+#include <psp2/display.h>
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+
+#include "SDL_render_vita_gxm_types.h"
+
+void init_orthographic_matrix(float *m, float left, float right, float bottom, float top, float near, float far);
+
+void *pool_malloc(VITA_GXM_RenderData *data, unsigned int size);
+void *pool_memalign(VITA_GXM_RenderData *data, unsigned int size, unsigned int alignment);
+
+void set_clip_rectangle(VITA_GXM_RenderData *data, int x_min, int y_min, int x_max, int y_max);
+void unset_clip_rectangle(VITA_GXM_RenderData *data);
+
+int gxm_init(SDL_Renderer *renderer);
+void gxm_finish(SDL_Renderer *renderer);
+
+gxm_texture *create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget, unsigned int *return_w, unsigned int *return_h, unsigned int *return_pitch, float *return_wscale);
+void free_gxm_texture(VITA_GXM_RenderData *data, gxm_texture *texture);
+
+void gxm_texture_set_filters(gxm_texture *texture, SceGxmTextureFilter min_filter, SceGxmTextureFilter mag_filter);
+SceGxmTextureFormat gxm_texture_get_format(const gxm_texture *texture);
+
+void *gxm_texture_get_datap(const gxm_texture *texture);
+
+void gxm_minimal_init_for_common_dialog(void);
+void gxm_minimal_term_for_common_dialog(void);
+void gxm_init_for_common_dialog(void);
+void gxm_swap_for_common_dialog(void);
+void gxm_term_for_common_dialog(void);
+
+#endif // SDL_RENDER_VITA_GXM_TOOLS_H
diff --git a/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_types.h b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_types.h
new file mode 100644
index 0000000..19962c7
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/SDL_render_vita_gxm_types.h
@@ -0,0 +1,210 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef SDL_RENDER_VITA_GXM_TYPES_H
+#define SDL_RENDER_VITA_GXM_TYPES_H
+
+#include "SDL_internal.h"
+
+#include "../SDL_sysrender.h"
+
+#include <psp2/kernel/processmgr.h>
+#include <psp2/appmgr.h>
+#include <psp2/display.h>
+#include <psp2/gxm.h>
+#include <psp2/types.h>
+#include <psp2/kernel/sysmem.h>
+#include <psp2/kernel/clib.h>
+
+#include <string.h>
+
+#define VITA_GXM_SCREEN_WIDTH  960
+#define VITA_GXM_SCREEN_HEIGHT 544
+#define VITA_GXM_SCREEN_STRIDE 960
+
+#define VITA_GXM_COLOR_FORMAT SCE_GXM_COLOR_FORMAT_A8B8G8R8
+#define VITA_GXM_PIXEL_FORMAT SCE_DISPLAY_PIXELFORMAT_A8B8G8R8
+
+#define VITA_GXM_BUFFERS       3
+#define VITA_GXM_PENDING_SWAPS 2
+#define VITA_GXM_POOL_SIZE     2 * 1024 * 1024
+
+typedef struct
+{
+    void *address;
+    Uint8 wait_vblank;
+} VITA_GXM_DisplayData;
+
+typedef struct clear_vertex
+{
+    float x;
+    float y;
+} clear_vertex;
+
+typedef struct color_vertex
+{
+    float x;
+    float y;
+    SDL_FColor color;
+} color_vertex;
+
+typedef struct texture_vertex
+{
+    float x;
+    float y;
+    float u;
+    float v;
+    SDL_FColor color;
+} texture_vertex;
+
+typedef struct gxm_texture
+{
+    SceGxmTexture gxm_tex;
+    SceUID data_UID;
+    SceGxmRenderTarget *gxm_rendertarget;
+    SceGxmColorSurface gxm_colorsurface;
+    SceGxmDepthStencilSurface gxm_depthstencil;
+    SceUID depth_UID;
+    bool cdram;
+} gxm_texture;
+
+typedef struct fragment_programs
+{
+    SceGxmFragmentProgram *color;
+    SceGxmFragmentProgram *texture;
+} fragment_programs;
+
+typedef struct blend_fragment_programs
+{
+    fragment_programs blend_mode_none;
+    fragment_programs blend_mode_blend;
+    fragment_programs blend_mode_add;
+    fragment_programs blend_mode_mod;
+    fragment_programs blend_mode_mul;
+} blend_fragment_programs;
+
+typedef struct
+{
+    SDL_Rect viewport;
+    bool viewport_dirty;
+    SDL_Texture *texture;
+    SDL_Texture *target;
+    SDL_FColor color;
+    SceGxmFragmentProgram *fragment_program;
+    SceGxmVertexProgram *vertex_program;
+    int last_command;
+
+    bool cliprect_enabled_dirty;
+    bool cliprect_enabled;
+    bool cliprect_dirty;
+    SDL_Rect cliprect;
+    bool texturing;
+    int drawablew;
+    int drawableh;
+} gxm_drawstate_cache;
+
+typedef struct
+{
+    bool initialized;
+    bool drawing;
+
+    unsigned int psm;
+    unsigned int bpp;
+
+    int currentBlendMode;
+
+    VITA_GXM_DisplayData displayData;
+
+    SceUID vdmRingBufferUid;
+    SceUID vertexRingBufferUid;
+    SceUID fragmentRingBufferUid;
+    SceUID fragmentUsseRingBufferUid;
+    SceGxmContextParams contextParams;
+    SceGxmContext *gxm_context;
+    SceGxmRenderTarget *renderTarget;
+    SceUID displayBufferUid[VITA_GXM_BUFFERS];
+    void *displayBufferData[VITA_GXM_BUFFERS];
+    SceGxmColorSurface displaySurface[VITA_GXM_BUFFERS];
+    SceGxmSyncObject *displayBufferSync[VITA_GXM_BUFFERS];
+
+    SceUID depthBufferUid;
+    SceUID stencilBufferUid;
+    SceGxmDepthStencilSurface depthSurface;
+    void *depthBufferData;
+    void *stencilBufferData;
+
+    unsigned int backBufferIndex;
+    unsigned int frontBufferIndex;
+
+    void *pool_addr[2];
+    SceUID poolUid[2];
+    unsigned int pool_index;
+    unsigned int current_pool;
+
+    float ortho_matrix[4 * 4];
+
+    SceGxmVertexProgram *colorVertexProgram;
+    SceGxmFragmentProgram *colorFragmentProgram;
+    SceGxmVertexProgram *textureVertexProgram;
+    SceGxmFragmentProgram *textureFragmentProgram;
+    SceGxmProgramParameter *clearClearColorParam;
+    SceGxmProgramParameter *colorWvpParam;
+    SceGxmProgramParameter *textureWvpParam;
+
+    SceGxmShaderPatcher *shaderPatcher;
+    SceGxmVertexProgram *clearVertexProgram;
+    SceGxmFragmentProgram *clearFragmentProgram;
+
+    SceGxmShaderPatcherId clearVertexProgramId;
+    SceGxmShaderPatcherId clearFragmentProgramId;
+    SceGxmShaderPatcherId colorVertexProgramId;
+    SceGxmShaderPatcherId colorFragmentProgramId;
+    SceGxmShaderPatcherId textureVertexProgramId;
+    SceGxmShaderPatcherId textureFragmentProgramId;
+
+    SceUID patcherBufferUid;
+    SceUID patcherVertexUsseUid;
+    SceUID patcherFragmentUsseUid;
+
+    SceUID clearVerticesUid;
+    SceUID linearIndicesUid;
+    clear_vertex *clearVertices;
+    uint16_t *linearIndices;
+
+    blend_fragment_programs blendFragmentPrograms;
+
+    gxm_drawstate_cache drawstate;
+    SceClibMspace texturePool;
+    SceUID texturePoolUID;
+} VITA_GXM_RenderData;
+
+typedef struct
+{
+    gxm_texture *tex;
+    unsigned int pitch;
+    unsigned int w;
+    unsigned int h;
+    float wscale;
+    bool yuv;
+    bool nv12;
+} VITA_GXM_TextureData;
+
+#endif // SDL_RENDER_VITA_GXM_TYPES_H
diff --git a/SDL-3.2.8/src/render/vitagxm/shader_src/clear_f.cg b/SDL-3.2.8/src/render/vitagxm/shader_src/clear_f.cg
new file mode 100644
index 0000000..6d8fb3b
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/shader_src/clear_f.cg
@@ -0,0 +1,4 @@
+float4 main( uniform float4 uClearColor) : COLOR
+{
+    return uClearColor;
+}
diff --git a/SDL-3.2.8/src/render/vitagxm/shader_src/clear_v.cg b/SDL-3.2.8/src/render/vitagxm/shader_src/clear_v.cg
new file mode 100644
index 0000000..ee5aa9f
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/shader_src/clear_v.cg
@@ -0,0 +1,4 @@
+float4 main(float2 aPosition) : POSITION
+{
+    return float4(aPosition, 1.f, 1.f);
+}
diff --git a/SDL-3.2.8/src/render/vitagxm/shader_src/color_f.cg b/SDL-3.2.8/src/render/vitagxm/shader_src/color_f.cg
new file mode 100644
index 0000000..dc87c2a
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/shader_src/color_f.cg
@@ -0,0 +1,4 @@
+float4 main(float4 vColor : COLOR)
+{
+    return vColor;
+}
diff --git a/SDL-3.2.8/src/render/vitagxm/shader_src/color_v.cg b/SDL-3.2.8/src/render/vitagxm/shader_src/color_v.cg
new file mode 100644
index 0000000..4966099
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/shader_src/color_v.cg
@@ -0,0 +1,13 @@
+void main(
+    float2 aPosition,
+    float4 aColor,
+    uniform float4x4 wvp,
+    out float4 vPosition : POSITION,
+    out float4 vColor : COLOR,
+    out float pSize : PSIZE
+)
+{
+    vPosition = mul(float4(aPosition, 1.f, 0.5f), wvp);
+    vColor = aColor;
+    pSize = 1.f;
+}
diff --git a/SDL-3.2.8/src/render/vitagxm/shader_src/texture_f.cg b/SDL-3.2.8/src/render/vitagxm/shader_src/texture_f.cg
new file mode 100644
index 0000000..a1f63b8
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/shader_src/texture_f.cg
@@ -0,0 +1,4 @@
+float4 main(float2 vTexcoord : TEXCOORD0, float4 vColor : COLOR, uniform sampler2D tex)
+{
+    return tex2D(tex, vTexcoord) * vColor;
+}
diff --git a/SDL-3.2.8/src/render/vitagxm/shader_src/texture_v.cg b/SDL-3.2.8/src/render/vitagxm/shader_src/texture_v.cg
new file mode 100644
index 0000000..9e05e9a
--- /dev/null
+++ b/SDL-3.2.8/src/render/vitagxm/shader_src/texture_v.cg
@@ -0,0 +1,14 @@
+void main(
+    float2 aPosition,
+    float2 aTexcoord,
+    float4 aColor,
+    uniform float4x4 wvp,
+    out float4 vPosition : POSITION,
+    out float4 vColor : COLOR,
+    out float2 vTexcoord : TEXCOORD0
+)
+{
+    vPosition = mul(float4(aPosition, 1.f, 0.5f), wvp);
+    vTexcoord = aTexcoord;
+    vColor = aColor;
+}
diff --git a/SDL-3.2.8/src/render/vulkan/SDL_render_vulkan.c b/SDL-3.2.8/src/render/vulkan/SDL_render_vulkan.c
new file mode 100644
index 0000000..d2157c3
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/SDL_render_vulkan.c
@@ -0,0 +1,4349 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_VULKAN
+
+#define SDL_VULKAN_FRAME_QUEUE_DEPTH            2
+#define SDL_VULKAN_NUM_VERTEX_BUFFERS           256
+#define SDL_VULKAN_VERTEX_BUFFER_DEFAULT_SIZE   65536
+#define SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE 65536
+#define SDL_VULKAN_NUM_UPLOAD_BUFFERS           32
+#define SDL_VULKAN_MAX_DESCRIPTOR_SETS          4096
+
+#define SDL_VULKAN_VALIDATION_LAYER_NAME        "VK_LAYER_KHRONOS_validation"
+
+#define VK_NO_PROTOTYPES
+#include "../../video/SDL_vulkan_internal.h"
+#include "../../video/SDL_sysvideo.h"
+#include "../SDL_sysrender.h"
+#include "../SDL_d3dmath.h"
+#include "../../video/SDL_pixels_c.h"
+#include "SDL_shaders_vulkan.h"
+
+#define SET_ERROR_CODE(message, rc)                                                                 \
+    if (SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false)) {                                  \
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s: %s", message, SDL_Vulkan_GetResultString(rc)); \
+        SDL_TriggerBreakpoint();                                                                    \
+    }                                                                                               \
+    SDL_SetError("%s: %s", message, SDL_Vulkan_GetResultString(rc))                                 \
+
+#define SET_ERROR_MESSAGE(message)                                                                  \
+    if (SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false)) {                                  \
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", message);                                     \
+        SDL_TriggerBreakpoint();                                                                    \
+    }                                                                                               \
+    SDL_SetError("%s", message)                                                                     \
+
+#define VULKAN_FUNCTIONS()                                              \
+    VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR)                       \
+    VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers)                    \
+    VULKAN_DEVICE_FUNCTION(vkAllocateDescriptorSets)                    \
+    VULKAN_DEVICE_FUNCTION(vkAllocateMemory)                            \
+    VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer)                        \
+    VULKAN_DEVICE_FUNCTION(vkBindBufferMemory)                          \
+    VULKAN_DEVICE_FUNCTION(vkBindImageMemory)                           \
+    VULKAN_DEVICE_FUNCTION(vkCmdBeginRenderPass)                        \
+    VULKAN_DEVICE_FUNCTION(vkCmdBindDescriptorSets)                     \
+    VULKAN_DEVICE_FUNCTION(vkCmdBindPipeline)                           \
+    VULKAN_DEVICE_FUNCTION(vkCmdBindVertexBuffers)                      \
+    VULKAN_DEVICE_FUNCTION(vkCmdClearColorImage)                        \
+    VULKAN_DEVICE_FUNCTION(vkCmdCopyBufferToImage)                      \
+    VULKAN_DEVICE_FUNCTION(vkCmdCopyImageToBuffer)                      \
+    VULKAN_DEVICE_FUNCTION(vkCmdDraw)                                   \
+    VULKAN_DEVICE_FUNCTION(vkCmdEndRenderPass)                          \
+    VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier)                        \
+    VULKAN_DEVICE_FUNCTION(vkCmdPushConstants)                          \
+    VULKAN_DEVICE_FUNCTION(vkCmdSetScissor)                             \
+    VULKAN_DEVICE_FUNCTION(vkCmdSetViewport)                            \
+    VULKAN_DEVICE_FUNCTION(vkCreateBuffer)                              \
+    VULKAN_DEVICE_FUNCTION(vkCreateCommandPool)                         \
+    VULKAN_DEVICE_FUNCTION(vkCreateDescriptorPool)                      \
+    VULKAN_DEVICE_FUNCTION(vkCreateDescriptorSetLayout)                 \
+    VULKAN_DEVICE_FUNCTION(vkCreateFence)                               \
+    VULKAN_DEVICE_FUNCTION(vkCreateFramebuffer)                         \
+    VULKAN_DEVICE_FUNCTION(vkCreateGraphicsPipelines)                   \
+    VULKAN_DEVICE_FUNCTION(vkCreateImage)                               \
+    VULKAN_DEVICE_FUNCTION(vkCreateImageView)                           \
+    VULKAN_DEVICE_FUNCTION(vkCreatePipelineLayout)                      \
+    VULKAN_DEVICE_FUNCTION(vkCreateRenderPass)                          \
+    VULKAN_DEVICE_FUNCTION(vkCreateSampler)                             \
+    VULKAN_DEVICE_FUNCTION(vkCreateSemaphore)                           \
+    VULKAN_DEVICE_FUNCTION(vkCreateShaderModule)                        \
+    VULKAN_DEVICE_FUNCTION(vkCreateSwapchainKHR)                        \
+    VULKAN_DEVICE_FUNCTION(vkDestroyBuffer)                             \
+    VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool)                        \
+    VULKAN_DEVICE_FUNCTION(vkDestroyDevice)                             \
+    VULKAN_DEVICE_FUNCTION(vkDestroyDescriptorPool)                     \
+    VULKAN_DEVICE_FUNCTION(vkDestroyDescriptorSetLayout)                \
+    VULKAN_DEVICE_FUNCTION(vkDestroyFence)                              \
+    VULKAN_DEVICE_FUNCTION(vkDestroyFramebuffer)                        \
+    VULKAN_DEVICE_FUNCTION(vkDestroyImage)                              \
+    VULKAN_DEVICE_FUNCTION(vkDestroyImageView)                          \
+    VULKAN_DEVICE_FUNCTION(vkDestroyPipeline)                           \
+    VULKAN_DEVICE_FUNCTION(vkDestroyPipelineLayout)                     \
+    VULKAN_DEVICE_FUNCTION(vkDestroyRenderPass)                         \
+    VULKAN_DEVICE_FUNCTION(vkDestroySampler)                            \
+    VULKAN_DEVICE_FUNCTION(vkDestroySemaphore)                          \
+    VULKAN_DEVICE_FUNCTION(vkDestroyShaderModule)                       \
+    VULKAN_DEVICE_FUNCTION(vkDestroySwapchainKHR)                       \
+    VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle)                            \
+    VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer)                          \
+    VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers)                        \
+    VULKAN_DEVICE_FUNCTION(vkFreeMemory)                                \
+    VULKAN_DEVICE_FUNCTION(vkGetBufferMemoryRequirements)               \
+    VULKAN_DEVICE_FUNCTION(vkGetImageMemoryRequirements)                \
+    VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue)                            \
+    VULKAN_DEVICE_FUNCTION(vkGetFenceStatus)                            \
+    VULKAN_DEVICE_FUNCTION(vkGetSwapchainImagesKHR)                     \
+    VULKAN_DEVICE_FUNCTION(vkMapMemory)                                 \
+    VULKAN_DEVICE_FUNCTION(vkQueuePresentKHR)                           \
+    VULKAN_DEVICE_FUNCTION(vkQueueSubmit)                               \
+    VULKAN_DEVICE_FUNCTION(vkResetCommandBuffer)                        \
+    VULKAN_DEVICE_FUNCTION(vkResetCommandPool)                          \
+    VULKAN_DEVICE_FUNCTION(vkResetDescriptorPool)                       \
+    VULKAN_DEVICE_FUNCTION(vkResetFences)                               \
+    VULKAN_DEVICE_FUNCTION(vkUnmapMemory)                               \
+    VULKAN_DEVICE_FUNCTION(vkUpdateDescriptorSets)                      \
+    VULKAN_DEVICE_FUNCTION(vkWaitForFences)                             \
+    VULKAN_GLOBAL_FUNCTION(vkCreateInstance)                            \
+    VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties)      \
+    VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties)          \
+    VULKAN_INSTANCE_FUNCTION(vkCreateDevice)                            \
+    VULKAN_INSTANCE_FUNCTION(vkDestroyInstance)                         \
+    VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR)                       \
+    VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties)      \
+    VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices)                \
+    VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr)                       \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures)               \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties)             \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties)       \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties)  \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR)      \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR) \
+    VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR)      \
+    VULKAN_INSTANCE_FUNCTION(vkQueueWaitIdle)                           \
+    VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2KHR)              \
+    VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceFormatProperties2KHR)      \
+    VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceImageFormatProperties2KHR) \
+    VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties2KHR)      \
+    VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties2KHR)            \
+    VULKAN_OPTIONAL_DEVICE_FUNCTION(vkCreateSamplerYcbcrConversionKHR)              \
+    VULKAN_OPTIONAL_DEVICE_FUNCTION(vkDestroySamplerYcbcrConversionKHR)             \
+
+#define VULKAN_DEVICE_FUNCTION(name)            static PFN_##name name = NULL;
+#define VULKAN_GLOBAL_FUNCTION(name)            static PFN_##name name = NULL;
+#define VULKAN_INSTANCE_FUNCTION(name)          static PFN_##name name = NULL;
+#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name) static PFN_##name name = NULL;
+#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name)   static PFN_##name name = NULL;
+VULKAN_FUNCTIONS()
+#undef VULKAN_DEVICE_FUNCTION
+#undef VULKAN_GLOBAL_FUNCTION
+#undef VULKAN_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
+
+// Renderpass types
+typedef enum {
+    VULKAN_RENDERPASS_LOAD = 0,
+    VULKAN_RENDERPASS_CLEAR = 1,
+    VULKAN_RENDERPASS_COUNT
+} VULKAN_RenderPass;
+
+// Sampler types
+typedef enum
+{
+    VULKAN_SAMPLER_NEAREST_CLAMP,
+    VULKAN_SAMPLER_NEAREST_WRAP,
+    VULKAN_SAMPLER_LINEAR_CLAMP,
+    VULKAN_SAMPLER_LINEAR_WRAP,
+    VULKAN_SAMPLER_COUNT
+} VULKAN_Sampler;
+
+// Vertex shader, common values
+typedef struct
+{
+    Float4X4 model;
+    Float4X4 projectionAndView;
+} VULKAN_VertexShaderConstants;
+
+// These should mirror the definitions in VULKAN_PixelShader_Common.hlsli
+//static const float TONEMAP_NONE = 0;
+//static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+typedef enum
+{
+    SAMPLER_POINT_CLAMP,
+    SAMPLER_POINT_WRAP,
+    SAMPLER_LINEAR_CLAMP,
+    SAMPLER_LINEAR_WRAP,
+    NUM_SAMPLERS
+} Sampler;
+
+// Pixel shader constants, common values
+typedef struct
+{
+    float scRGB_output;
+    float input_type;
+    float color_scale;
+    float unused_pad0;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+} VULKAN_PixelShaderConstants;
+
+// Per-vertex data
+typedef struct
+{
+    float pos[2];
+    float tex[2];
+    SDL_FColor color;
+} VULKAN_VertexPositionColor;
+
+// Vulkan Buffer
+typedef struct
+{
+    VkDeviceMemory deviceMemory;
+    VkBuffer buffer;
+    VkDeviceSize size;
+    void *mappedBufferPtr;
+
+} VULKAN_Buffer;
+
+// Vulkan image
+typedef struct
+{
+    bool allocatedImage;
+    VkImage image;
+    VkImageView imageView;
+    VkDeviceMemory deviceMemory;
+    VkImageLayout imageLayout;
+    VkFormat format;
+} VULKAN_Image;
+
+// Per-texture data
+typedef struct
+{
+    VULKAN_Image mainImage;
+    VkRenderPass mainRenderpasses[VULKAN_RENDERPASS_COUNT];
+    VkFramebuffer mainFramebuffer;
+    VULKAN_Buffer stagingBuffer;
+    VkFilter scaleMode;
+    SDL_Rect lockedRect;
+    int width;
+    int height;
+    VULKAN_Shader shader;
+
+    // Object passed to VkImageView and VkSampler for doing Ycbcr -> RGB conversion
+    VkSamplerYcbcrConversion samplerYcbcrConversion;
+    // Sampler created with samplerYcbcrConversion, passed to PSO as immutable sampler
+    VkSampler samplerYcbcr;
+    // Descriptor set layout with samplerYcbcr baked as immutable sampler
+    VkDescriptorSetLayout descriptorSetLayoutYcbcr;
+    // Pipeline layout with immutable sampler descriptor set layout
+    VkPipelineLayout pipelineLayoutYcbcr;
+
+} VULKAN_TextureData;
+
+// Pipeline State Object data
+typedef struct
+{
+    VULKAN_Shader shader;
+    VULKAN_PixelShaderConstants shader_constants;
+    SDL_BlendMode blendMode;
+    VkPrimitiveTopology topology;
+    VkFormat format;
+    VkPipelineLayout pipelineLayout;
+    VkDescriptorSetLayout descriptorSetLayout;
+    VkPipeline pipeline;
+} VULKAN_PipelineState;
+
+typedef struct
+{
+    VkBuffer vertexBuffer;
+} VULKAN_DrawStateCache;
+
+// Private renderer data
+typedef struct
+{
+    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+    VkInstance instance;
+    bool instance_external;
+    VkSurfaceKHR surface;
+    bool surface_external;
+    VkPhysicalDevice physicalDevice;
+    VkPhysicalDeviceProperties physicalDeviceProperties;
+    VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
+    VkPhysicalDeviceFeatures physicalDeviceFeatures;
+    VkQueue graphicsQueue;
+    VkQueue presentQueue;
+    VkDevice device;
+    bool device_external;
+    uint32_t graphicsQueueFamilyIndex;
+    uint32_t presentQueueFamilyIndex;
+    VkSwapchainKHR swapchain;
+    VkCommandPool commandPool;
+    VkCommandBuffer *commandBuffers;
+    uint32_t currentCommandBufferIndex;
+    VkCommandBuffer currentCommandBuffer;
+    VkFence *fences;
+    VkSurfaceCapabilitiesKHR surfaceCapabilities;
+    VkSurfaceFormatKHR *surfaceFormats;
+    bool recreateSwapchain;
+    int vsync;
+    SDL_PropertiesID create_props;
+
+    VkFramebuffer *framebuffers;
+    VkRenderPass renderPasses[VULKAN_RENDERPASS_COUNT];
+    VkRenderPass currentRenderPass;
+
+    VkShaderModule vertexShaderModules[NUM_SHADERS];
+    VkShaderModule fragmentShaderModules[NUM_SHADERS];
+    VkDescriptorSetLayout descriptorSetLayout;
+    VkPipelineLayout pipelineLayout;
+
+    // Vertex buffer data
+    VULKAN_Buffer vertexBuffers[SDL_VULKAN_NUM_VERTEX_BUFFERS];
+    VULKAN_VertexShaderConstants vertexShaderConstantsData;
+
+    // Data for staging/allocating textures
+    VULKAN_Buffer **uploadBuffers;
+    int *currentUploadBuffer;
+
+    // Data for updating constants
+    VULKAN_Buffer **constantBuffers;
+    uint32_t *numConstantBuffers;
+    uint32_t currentConstantBufferIndex;
+    int32_t currentConstantBufferOffset;
+
+    VkSampler samplers[VULKAN_SAMPLER_COUNT];
+    VkDescriptorPool **descriptorPools;
+    uint32_t *numDescriptorPools;
+    uint32_t currentDescriptorPoolIndex;
+    uint32_t currentDescriptorSetIndex;
+
+    int pipelineStateCount;
+    VULKAN_PipelineState *pipelineStates;
+    VULKAN_PipelineState *currentPipelineState;
+
+    bool supportsEXTSwapchainColorspace;
+    bool supportsKHRGetPhysicalDeviceProperties2;
+    bool supportsKHRSamplerYCbCrConversion;
+    uint32_t surfaceFormatsAllocatedCount;
+    uint32_t surfaceFormatsCount;
+    uint32_t swapchainDesiredImageCount;
+    VkSurfaceFormatKHR surfaceFormat;
+    VkExtent2D swapchainSize;
+    VkSurfaceTransformFlagBitsKHR swapChainPreTransform;
+    uint32_t swapchainImageCount;
+    VkImage *swapchainImages;
+    VkImageView *swapchainImageViews;
+    VkImageLayout *swapchainImageLayouts;
+    VkSemaphore *imageAvailableSemaphores;
+    VkSemaphore *renderingFinishedSemaphores;
+    VkSemaphore currentImageAvailableSemaphore;
+    uint32_t currentSwapchainImageIndex;
+
+    VkPipelineStageFlags *waitDestStageMasks;
+    VkSemaphore *waitRenderSemaphores;
+    uint32_t waitRenderSemaphoreCount;
+    uint32_t waitRenderSemaphoreMax;
+    VkSemaphore *signalRenderSemaphores;
+    uint32_t signalRenderSemaphoreCount;
+    uint32_t signalRenderSemaphoreMax;
+
+    // Cached renderer properties
+    VULKAN_TextureData *textureRenderTarget;
+    bool cliprectDirty;
+    bool currentCliprectEnabled;
+    SDL_Rect currentCliprect;
+    SDL_Rect currentViewport;
+    int currentViewportRotation;
+    bool viewportDirty;
+    Float4X4 identity;
+    VkComponentMapping identitySwizzle;
+    int currentVertexBuffer;
+    bool issueBatch;
+} VULKAN_RenderData;
+
+static SDL_PixelFormat VULKAN_VkFormatToSDLPixelFormat(VkFormat vkFormat)
+{
+    switch (vkFormat) {
+    case VK_FORMAT_B8G8R8A8_UNORM:
+        return SDL_PIXELFORMAT_ARGB8888;
+    case VK_FORMAT_R8G8B8A8_UNORM:
+        return SDL_PIXELFORMAT_ABGR8888;
+    case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+        return SDL_PIXELFORMAT_ABGR2101010;
+    case VK_FORMAT_R16G16B16A16_SFLOAT:
+        return SDL_PIXELFORMAT_RGBA64_FLOAT;
+    default:
+        return SDL_PIXELFORMAT_UNKNOWN;
+    }
+}
+
+static int VULKAN_VkFormatGetNumPlanes(VkFormat vkFormat)
+{
+    switch (vkFormat) {
+    case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+        return 3;
+    case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+    case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+        return 2;
+    default:
+        return 1;
+    }
+}
+
+static VkDeviceSize VULKAN_GetBytesPerPixel(VkFormat vkFormat)
+{
+    switch (vkFormat) {
+    case VK_FORMAT_R8_UNORM:
+        return 1;
+    case VK_FORMAT_R8G8_UNORM:
+        return 2;
+    case VK_FORMAT_R16G16_UNORM:
+        return 4;
+    case VK_FORMAT_B8G8R8A8_SRGB:
+    case VK_FORMAT_B8G8R8A8_UNORM:
+    case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+        return 4;
+    case VK_FORMAT_R16G16B16A16_SFLOAT:
+        return 8;
+    default:
+        return 4;
+    }
+}
+
+static VkFormat SDLPixelFormatToVkTextureFormat(Uint32 format, Uint32 output_colorspace)
+{
+    switch (format) {
+    case SDL_PIXELFORMAT_RGBA64_FLOAT:
+        return VK_FORMAT_R16G16B16A16_SFLOAT;
+    case SDL_PIXELFORMAT_ABGR2101010:
+        return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+    case SDL_PIXELFORMAT_ARGB8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return VK_FORMAT_B8G8R8A8_SRGB;
+        }
+        return VK_FORMAT_B8G8R8A8_UNORM;
+    case SDL_PIXELFORMAT_ABGR8888:
+        if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+            return VK_FORMAT_R8G8B8A8_SRGB;
+        }
+        return VK_FORMAT_R8G8B8A8_UNORM;
+    case SDL_PIXELFORMAT_YUY2:
+        return VK_FORMAT_G8B8G8R8_422_UNORM;
+    case SDL_PIXELFORMAT_UYVY:
+        return VK_FORMAT_B8G8R8G8_422_UNORM;
+    case SDL_PIXELFORMAT_YV12:
+    case SDL_PIXELFORMAT_IYUV:
+        return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
+    case SDL_PIXELFORMAT_NV12:
+    case SDL_PIXELFORMAT_NV21:
+        return  VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
+    case SDL_PIXELFORMAT_P010:
+        return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
+    default:
+        return VK_FORMAT_UNDEFINED;
+    }
+}
+
+static void VULKAN_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
+static void VULKAN_DestroyBuffer(VULKAN_RenderData *rendererData, VULKAN_Buffer *vulkanBuffer);
+static void VULKAN_DestroyImage(VULKAN_RenderData *rendererData, VULKAN_Image *vulkanImage);
+static void VULKAN_ResetCommandList(VULKAN_RenderData *rendererData);
+static bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut);
+static VkResult VULKAN_CreateWindowSizeDependentResources(SDL_Renderer *renderer);
+static VkDescriptorPool VULKAN_AllocateDescriptorPool(VULKAN_RenderData *rendererData);
+static VkResult VULKAN_CreateDescriptorSetAndPipelineLayout(VULKAN_RenderData *rendererData, VkSampler samplerYcbcr, VkDescriptorSetLayout *descriptorSetLayoutOut, VkPipelineLayout *pipelineLayoutOut);
+static VkSurfaceTransformFlagBitsKHR VULKAN_GetRotationForCurrentRenderTarget(VULKAN_RenderData *rendererData);
+static bool VULKAN_IsDisplayRotated90Degrees(VkSurfaceTransformFlagBitsKHR rotation);
+
+static void VULKAN_DestroyAll(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData;
+    if (renderer == NULL) {
+        return;
+    }
+    rendererData = (VULKAN_RenderData *)renderer->internal;
+    if (rendererData == NULL) {
+        return;
+    }
+
+    // Release all textures
+    for (SDL_Texture *texture = renderer->textures; texture; texture = texture->next) {
+        VULKAN_DestroyTexture(renderer, texture);
+    }
+
+    if (rendererData->waitDestStageMasks) {
+        SDL_free(rendererData->waitDestStageMasks);
+        rendererData->waitDestStageMasks = NULL;
+    }
+    if (rendererData->waitRenderSemaphores) {
+        SDL_free(rendererData->waitRenderSemaphores);
+        rendererData->waitRenderSemaphores = NULL;
+    }
+    if (rendererData->signalRenderSemaphores) {
+        SDL_free(rendererData->signalRenderSemaphores);
+        rendererData->signalRenderSemaphores = NULL;
+    }
+    if (rendererData->surfaceFormats != NULL) {
+        SDL_free(rendererData->surfaceFormats);
+        rendererData->surfaceFormats = NULL;
+        rendererData->surfaceFormatsAllocatedCount = 0;
+    }
+    if (rendererData->swapchainImages != NULL) {
+        SDL_free(rendererData->swapchainImages);
+        rendererData->swapchainImages = NULL;
+    }
+    if (rendererData->swapchain) {
+        vkDestroySwapchainKHR(rendererData->device, rendererData->swapchain, NULL);
+        rendererData->swapchain = VK_NULL_HANDLE;
+    }
+    if (rendererData->fences != NULL) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            if (rendererData->fences[i] != VK_NULL_HANDLE) {
+                vkDestroyFence(rendererData->device, rendererData->fences[i], NULL);
+                rendererData->fences[i] = VK_NULL_HANDLE;
+            }
+        }
+        SDL_free(rendererData->fences);
+        rendererData->fences = NULL;
+    }
+    if (rendererData->swapchainImageViews) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            if (rendererData->swapchainImageViews[i] != VK_NULL_HANDLE) {
+                vkDestroyImageView(rendererData->device, rendererData->swapchainImageViews[i], NULL);
+            }
+        }
+        SDL_free(rendererData->swapchainImageViews);
+        rendererData->swapchainImageViews = NULL;
+    }
+    if (rendererData->swapchainImageLayouts) {
+        SDL_free(rendererData->swapchainImageLayouts);
+        rendererData->swapchainImageLayouts = NULL;
+    }
+    if (rendererData->framebuffers) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            if (rendererData->framebuffers[i] != VK_NULL_HANDLE) {
+                vkDestroyFramebuffer(rendererData->device, rendererData->framebuffers[i], NULL);
+            }
+        }
+        SDL_free(rendererData->framebuffers);
+        rendererData->framebuffers = NULL;
+    }
+    for (uint32_t i = 0; i < SDL_arraysize(rendererData->samplers); i++) {
+        if (rendererData->samplers[i] != VK_NULL_HANDLE) {
+            vkDestroySampler(rendererData->device, rendererData->samplers[i], NULL);
+            rendererData->samplers[i] = VK_NULL_HANDLE;
+        }
+    }
+    for (uint32_t i = 0; i < SDL_arraysize(rendererData->vertexBuffers); i++ ) {
+        VULKAN_DestroyBuffer(rendererData, &rendererData->vertexBuffers[i]);
+    }
+    SDL_memset(rendererData->vertexBuffers, 0, sizeof(rendererData->vertexBuffers));
+    for (uint32_t i = 0; i < VULKAN_RENDERPASS_COUNT; i++) {
+        if (rendererData->renderPasses[i] != VK_NULL_HANDLE) {
+            vkDestroyRenderPass(rendererData->device, rendererData->renderPasses[i], NULL);
+            rendererData->renderPasses[i] = VK_NULL_HANDLE;
+        }
+    }
+    if (rendererData->imageAvailableSemaphores) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            if (rendererData->imageAvailableSemaphores[i] != VK_NULL_HANDLE) {
+                vkDestroySemaphore(rendererData->device, rendererData->imageAvailableSemaphores[i], NULL);
+            }
+        }
+        SDL_free(rendererData->imageAvailableSemaphores);
+        rendererData->imageAvailableSemaphores = NULL;
+    }
+    if (rendererData->renderingFinishedSemaphores) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            if (rendererData->renderingFinishedSemaphores[i] != VK_NULL_HANDLE) {
+                vkDestroySemaphore(rendererData->device, rendererData->renderingFinishedSemaphores[i], NULL);
+            }
+        }
+        SDL_free(rendererData->renderingFinishedSemaphores);
+        rendererData->renderingFinishedSemaphores = NULL;
+    }
+    if (rendererData->commandBuffers) {
+        vkFreeCommandBuffers(rendererData->device, rendererData->commandPool, rendererData->swapchainImageCount, rendererData->commandBuffers);
+        SDL_free(rendererData->commandBuffers);
+        rendererData->commandBuffers = NULL;
+        rendererData->currentCommandBuffer = VK_NULL_HANDLE;
+        rendererData->currentCommandBufferIndex = 0;
+    }
+    if (rendererData->commandPool) {
+        vkDestroyCommandPool(rendererData->device, rendererData->commandPool, NULL);
+        rendererData->commandPool = VK_NULL_HANDLE;
+    }
+    if (rendererData->descriptorPools) {
+        SDL_assert(rendererData->numDescriptorPools);
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            for (uint32_t j = 0; j < rendererData->numDescriptorPools[i]; j++) {
+                if (rendererData->descriptorPools[i][j] != VK_NULL_HANDLE) {
+                    vkDestroyDescriptorPool(rendererData->device, rendererData->descriptorPools[i][j], NULL);
+                }
+            }
+            SDL_free(rendererData->descriptorPools[i]);
+        }
+        SDL_free(rendererData->descriptorPools);
+        rendererData->descriptorPools = NULL;
+        SDL_free(rendererData->numDescriptorPools);
+        rendererData->numDescriptorPools = NULL;
+    }
+    for (uint32_t i = 0; i < NUM_SHADERS; i++) {
+        if (rendererData->vertexShaderModules[i] != VK_NULL_HANDLE) {
+            vkDestroyShaderModule(rendererData->device, rendererData->vertexShaderModules[i], NULL);
+            rendererData->vertexShaderModules[i] = VK_NULL_HANDLE;
+        }
+        if (rendererData->fragmentShaderModules[i] != VK_NULL_HANDLE) {
+            vkDestroyShaderModule(rendererData->device, rendererData->fragmentShaderModules[i], NULL);
+            rendererData->fragmentShaderModules[i] = VK_NULL_HANDLE;
+        }
+    }
+    if (rendererData->descriptorSetLayout != VK_NULL_HANDLE) {
+        vkDestroyDescriptorSetLayout(rendererData->device, rendererData->descriptorSetLayout, NULL);
+        rendererData->descriptorSetLayout = VK_NULL_HANDLE;
+    }
+    if (rendererData->pipelineLayout != VK_NULL_HANDLE) {
+        vkDestroyPipelineLayout(rendererData->device, rendererData->pipelineLayout, NULL);
+        rendererData->pipelineLayout = VK_NULL_HANDLE;
+    }
+    for (int i = 0; i < rendererData->pipelineStateCount; i++) {
+        vkDestroyPipeline(rendererData->device, rendererData->pipelineStates[i].pipeline, NULL);
+    }
+    SDL_free(rendererData->pipelineStates);
+    rendererData->pipelineStates = NULL;
+    rendererData->pipelineStateCount = 0;
+
+    if (rendererData->currentUploadBuffer) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            for (int j = 0; j < rendererData->currentUploadBuffer[i]; ++j) {
+                VULKAN_DestroyBuffer(rendererData, &rendererData->uploadBuffers[i][j]);
+            }
+            SDL_free(rendererData->uploadBuffers[i]);
+        }
+        SDL_free(rendererData->uploadBuffers);
+        rendererData->uploadBuffers = NULL;
+        SDL_free(rendererData->currentUploadBuffer);
+        rendererData->currentUploadBuffer = NULL;
+    }
+
+    if (rendererData->constantBuffers) {
+        SDL_assert(rendererData->numConstantBuffers);
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            for (uint32_t j = 0; j < rendererData->numConstantBuffers[i]; j++) {
+                VULKAN_DestroyBuffer(rendererData, &rendererData->constantBuffers[i][j]);
+            }
+            SDL_free(rendererData->constantBuffers[i]);
+        }
+        SDL_free(rendererData->constantBuffers);
+        rendererData->constantBuffers = NULL;
+        SDL_free(rendererData->numConstantBuffers);
+        rendererData->numConstantBuffers = NULL;
+    }
+
+    if (rendererData->device != VK_NULL_HANDLE && !rendererData->device_external) {
+        vkDestroyDevice(rendererData->device, NULL);
+        rendererData->device = VK_NULL_HANDLE;
+    }
+    if (rendererData->surface != VK_NULL_HANDLE && !rendererData->surface_external) {
+        vkDestroySurfaceKHR(rendererData->instance, rendererData->surface, NULL);
+        rendererData->surface = VK_NULL_HANDLE;
+    }
+    if (rendererData->instance != VK_NULL_HANDLE && !rendererData->instance_external) {
+        vkDestroyInstance(rendererData->instance, NULL);
+        rendererData->instance = VK_NULL_HANDLE;
+    }
+}
+
+static void VULKAN_DestroyBuffer(VULKAN_RenderData *rendererData, VULKAN_Buffer *vulkanBuffer)
+{
+    if (vulkanBuffer->buffer != VK_NULL_HANDLE) {
+        vkDestroyBuffer(rendererData->device, vulkanBuffer->buffer, NULL);
+        vulkanBuffer->buffer = VK_NULL_HANDLE;
+    }
+    if (vulkanBuffer->deviceMemory != VK_NULL_HANDLE) {
+        vkFreeMemory(rendererData->device, vulkanBuffer->deviceMemory, NULL);
+        vulkanBuffer->deviceMemory = VK_NULL_HANDLE;
+    }
+    SDL_memset(vulkanBuffer, 0, sizeof(VULKAN_Buffer));
+}
+
+static VkResult VULKAN_AllocateBuffer(VULKAN_RenderData *rendererData, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags requiredMemoryProps, VkMemoryPropertyFlags desiredMemoryProps, VULKAN_Buffer *bufferOut)
+{
+    VkResult result;
+    VkBufferCreateInfo bufferCreateInfo = { 0 };
+    bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    bufferCreateInfo.size = size;
+    bufferCreateInfo.usage = usage;
+    result = vkCreateBuffer(rendererData->device, &bufferCreateInfo, NULL, &bufferOut->buffer);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateBuffer()", result);
+        return result;
+    }
+
+    VkMemoryRequirements memoryRequirements = { 0 };
+    vkGetBufferMemoryRequirements(rendererData->device, bufferOut->buffer, &memoryRequirements);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyBuffer(rendererData, bufferOut);
+        SET_ERROR_CODE("vkGetBufferMemoryRequirements()", result);
+        return result;
+    }
+
+    uint32_t memoryTypeIndex = 0;
+    if (!VULKAN_FindMemoryTypeIndex(rendererData, memoryRequirements.memoryTypeBits, requiredMemoryProps, desiredMemoryProps, &memoryTypeIndex)) {
+        VULKAN_DestroyBuffer(rendererData, bufferOut);
+        return VK_ERROR_UNKNOWN;
+    }
+
+    VkMemoryAllocateInfo memoryAllocateInfo = { 0 };
+    memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    memoryAllocateInfo.allocationSize = memoryRequirements.size;
+    memoryAllocateInfo.memoryTypeIndex = memoryTypeIndex;
+    result = vkAllocateMemory(rendererData->device, &memoryAllocateInfo, NULL, &bufferOut->deviceMemory);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyBuffer(rendererData, bufferOut);
+        SET_ERROR_CODE("vkAllocateMemory()", result);
+        return result;
+    }
+    result = vkBindBufferMemory(rendererData->device, bufferOut->buffer, bufferOut->deviceMemory, 0);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyBuffer(rendererData, bufferOut);
+        SET_ERROR_CODE("vkBindBufferMemory()", result);
+        return result;
+    }
+
+    result = vkMapMemory(rendererData->device, bufferOut->deviceMemory, 0, size, 0, &bufferOut->mappedBufferPtr);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyBuffer(rendererData, bufferOut);
+        SET_ERROR_CODE("vkMapMemory()", result);
+        return result;
+    }
+    bufferOut->size = size;
+    return result;
+}
+
+static void VULKAN_DestroyImage(VULKAN_RenderData *rendererData, VULKAN_Image *vulkanImage)
+{
+    if (vulkanImage->imageView != VK_NULL_HANDLE) {
+        vkDestroyImageView(rendererData->device, vulkanImage->imageView, NULL);
+        vulkanImage->imageView = VK_NULL_HANDLE;
+    }
+    if (vulkanImage->image != VK_NULL_HANDLE) {
+        if (vulkanImage->allocatedImage) {
+            vkDestroyImage(rendererData->device, vulkanImage->image, NULL);
+        }
+        vulkanImage->image = VK_NULL_HANDLE;
+    }
+
+    if (vulkanImage->deviceMemory != VK_NULL_HANDLE) {
+        if (vulkanImage->allocatedImage) {
+            vkFreeMemory(rendererData->device, vulkanImage->deviceMemory, NULL);
+        }
+        vulkanImage->deviceMemory = VK_NULL_HANDLE;
+    }
+    SDL_memset(vulkanImage, 0, sizeof(VULKAN_Image));
+}
+
+static VkResult VULKAN_AllocateImage(VULKAN_RenderData *rendererData, SDL_PropertiesID create_props, uint32_t width, uint32_t height, VkFormat format, VkImageUsageFlags imageUsage, VkComponentMapping swizzle, VkSamplerYcbcrConversionKHR samplerYcbcrConversion, VULKAN_Image *imageOut)
+{
+    VkResult result;
+    VkSamplerYcbcrConversionInfoKHR samplerYcbcrConversionInfo = { 0 };
+
+    SDL_memset(imageOut, 0, sizeof(VULKAN_Image));
+    imageOut->format = format;
+    imageOut->image = (VkImage)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER, 0);
+
+    if (imageOut->image == VK_NULL_HANDLE) {
+        imageOut->allocatedImage = VK_TRUE;
+
+        VkImageCreateInfo imageCreateInfo = { 0 };
+        imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+        imageCreateInfo.flags = 0;
+        imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+        imageCreateInfo.format = format;
+        imageCreateInfo.extent.width = width;
+        imageCreateInfo.extent.height = height;
+        imageCreateInfo.extent.depth = 1;
+        imageCreateInfo.mipLevels = 1;
+        imageCreateInfo.arrayLayers = 1;
+        imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+        imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+        imageCreateInfo.usage = imageUsage;
+        imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        imageCreateInfo.queueFamilyIndexCount = 0;
+        imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+        result = vkCreateImage(rendererData->device, &imageCreateInfo, NULL, &imageOut->image);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyImage(rendererData, imageOut);
+            SET_ERROR_CODE("vkCreateImage()", result);
+            return result;
+        }
+
+        VkMemoryRequirements memoryRequirements = { 0 };
+        vkGetImageMemoryRequirements(rendererData->device, imageOut->image, &memoryRequirements);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyImage(rendererData, imageOut);
+            SET_ERROR_CODE("vkGetImageMemoryRequirements()", result);
+            return result;
+        }
+
+        uint32_t memoryTypeIndex = 0;
+        if (!VULKAN_FindMemoryTypeIndex(rendererData, memoryRequirements.memoryTypeBits, 0, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memoryTypeIndex)) {
+            VULKAN_DestroyImage(rendererData, imageOut);
+            return VK_ERROR_UNKNOWN;
+        }
+
+        VkMemoryAllocateInfo memoryAllocateInfo = { 0 };
+        memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+        memoryAllocateInfo.allocationSize = memoryRequirements.size;
+        memoryAllocateInfo.memoryTypeIndex = memoryTypeIndex;
+        result = vkAllocateMemory(rendererData->device, &memoryAllocateInfo, NULL, &imageOut->deviceMemory);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyImage(rendererData, imageOut);
+            SET_ERROR_CODE("vkAllocateMemory()", result);
+            return result;
+        }
+        result = vkBindImageMemory(rendererData->device, imageOut->image, imageOut->deviceMemory, 0);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyImage(rendererData, imageOut);
+            SET_ERROR_CODE("vkBindImageMemory()", result);
+            return result;
+        }
+    } else {
+        imageOut->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    }
+
+    VkImageViewCreateInfo imageViewCreateInfo = { 0 };
+    imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    imageViewCreateInfo.image = imageOut->image;
+    imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+    imageViewCreateInfo.format = format;
+    imageViewCreateInfo.components = swizzle;
+    imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
+    imageViewCreateInfo.subresourceRange.levelCount = 1;
+    imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
+    imageViewCreateInfo.subresourceRange.layerCount = 1;
+
+    // If it's a YCbCr image, we need to pass the conversion info to the VkImageView (and the VkSampler)
+    if (samplerYcbcrConversion != VK_NULL_HANDLE) {
+        samplerYcbcrConversionInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
+        samplerYcbcrConversionInfo.conversion = samplerYcbcrConversion;
+        imageViewCreateInfo.pNext = &samplerYcbcrConversionInfo;
+    }
+
+    result = vkCreateImageView(rendererData->device, &imageViewCreateInfo, NULL, &imageOut->imageView);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyImage(rendererData, imageOut);
+        SET_ERROR_CODE("vkCreateImageView()", result);
+        return result;
+    }
+
+    return result;
+}
+
+
+static void VULKAN_RecordPipelineImageBarrier(VULKAN_RenderData *rendererData, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask,
+    VkPipelineStageFlags srcStageFlags, VkPipelineStageFlags dstStageFlags, VkImageLayout destLayout, VkImage image, VkImageLayout *imageLayout)
+{
+    // Stop any outstanding renderpass if open
+    if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
+        vkCmdEndRenderPass(rendererData->currentCommandBuffer);
+        rendererData->currentRenderPass = VK_NULL_HANDLE;
+    }
+
+    VkImageMemoryBarrier barrier = { 0 };
+    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+    barrier.srcAccessMask = sourceAccessMask;
+    barrier.dstAccessMask = destAccessMask;
+    barrier.oldLayout = *imageLayout;
+    barrier.newLayout = destLayout;
+    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    barrier.image = image;
+    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    barrier.subresourceRange.baseMipLevel = 0;
+    barrier.subresourceRange.levelCount = 1;
+    barrier.subresourceRange.baseArrayLayer = 0;
+    barrier.subresourceRange.layerCount = 1;
+    vkCmdPipelineBarrier(rendererData->currentCommandBuffer, srcStageFlags, dstStageFlags, 0, 0, NULL, 0, NULL, 1, &barrier);
+    *imageLayout = destLayout;
+}
+
+static VkResult VULKAN_AcquireNextSwapchainImage(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = ( VULKAN_RenderData * )renderer->internal;
+
+    VkResult result;
+
+    rendererData->currentImageAvailableSemaphore = VK_NULL_HANDLE;
+    result = vkAcquireNextImageKHR(rendererData->device, rendererData->swapchain, UINT64_MAX,
+        rendererData->imageAvailableSemaphores[rendererData->currentCommandBufferIndex], VK_NULL_HANDLE, &rendererData->currentSwapchainImageIndex);
+    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_ERROR_SURFACE_LOST_KHR) {
+        result = VULKAN_CreateWindowSizeDependentResources(renderer);
+        return result;
+    } else if(result == VK_SUBOPTIMAL_KHR) {
+        // Suboptimal, but we can contiue
+    } else if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkAcquireNextImageKHR()", result);
+        return result;
+    }
+    rendererData->currentImageAvailableSemaphore = rendererData->imageAvailableSemaphores[rendererData->currentCommandBufferIndex];
+    return result;
+}
+
+static void VULKAN_BeginRenderPass(VULKAN_RenderData *rendererData, VkAttachmentLoadOp loadOp, VkClearColorValue *clearColor)
+{
+    int width = rendererData->swapchainSize.width;
+    int height = rendererData->swapchainSize.height;
+    if (rendererData->textureRenderTarget) {
+        width = rendererData->textureRenderTarget->width;
+        height = rendererData->textureRenderTarget->height;
+    }
+
+    switch (loadOp) {
+    case VK_ATTACHMENT_LOAD_OP_CLEAR:
+        rendererData->currentRenderPass = rendererData->textureRenderTarget ?
+            rendererData->textureRenderTarget->mainRenderpasses[VULKAN_RENDERPASS_CLEAR] :
+            rendererData->renderPasses[VULKAN_RENDERPASS_CLEAR];
+        break;
+
+    case VK_ATTACHMENT_LOAD_OP_LOAD:
+    default:
+        rendererData->currentRenderPass = rendererData->textureRenderTarget ?
+            rendererData->textureRenderTarget->mainRenderpasses[VULKAN_RENDERPASS_LOAD] :
+            rendererData->renderPasses[VULKAN_RENDERPASS_LOAD];
+        break;
+    }
+
+    VkFramebuffer framebuffer = rendererData->textureRenderTarget ?
+        rendererData->textureRenderTarget->mainFramebuffer :
+        rendererData->framebuffers[rendererData->currentSwapchainImageIndex];
+
+    VkRenderPassBeginInfo renderPassBeginInfo = { 0 };
+    renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+    renderPassBeginInfo.pNext = NULL;
+    renderPassBeginInfo.renderPass = rendererData->currentRenderPass;
+    renderPassBeginInfo.framebuffer = framebuffer;
+    renderPassBeginInfo.renderArea.offset.x = 0;
+    renderPassBeginInfo.renderArea.offset.y = 0;
+    renderPassBeginInfo.renderArea.extent.width = width;
+    renderPassBeginInfo.renderArea.extent.height = height;
+    renderPassBeginInfo.clearValueCount = (clearColor == NULL) ? 0 : 1;
+    VkClearValue clearValue;
+    if (clearColor != NULL) {
+        clearValue.color = *clearColor;
+        renderPassBeginInfo.pClearValues = &clearValue;
+    }
+    vkCmdBeginRenderPass(rendererData->currentCommandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+}
+
+static void VULKAN_EnsureCommandBuffer(VULKAN_RenderData *rendererData)
+{
+    if (rendererData->currentCommandBuffer == VK_NULL_HANDLE) {
+        rendererData->currentCommandBuffer = rendererData->commandBuffers[rendererData->currentCommandBufferIndex];
+        VULKAN_ResetCommandList(rendererData);
+
+        // Ensure the swapchain is in the correct layout
+        if (rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex] == VK_IMAGE_LAYOUT_UNDEFINED) {
+            VULKAN_RecordPipelineImageBarrier(rendererData,
+                0,
+                VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                rendererData->swapchainImages[rendererData->currentSwapchainImageIndex],
+                &rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex]);
+        }
+        else if (rendererData->swapchainImageLayouts[rendererData->currentCommandBufferIndex] != VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
+            VULKAN_RecordPipelineImageBarrier(rendererData,
+                VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+                VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                rendererData->swapchainImages[rendererData->currentSwapchainImageIndex],
+                &rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex]);
+        }
+    }
+}
+
+static bool VULKAN_ActivateCommandBuffer(SDL_Renderer *renderer, VkAttachmentLoadOp loadOp, VkClearColorValue *clearColor, VULKAN_DrawStateCache *stateCache)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+
+    VULKAN_EnsureCommandBuffer(rendererData);
+
+    if (rendererData->currentRenderPass == VK_NULL_HANDLE || loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
+        if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
+            vkCmdEndRenderPass(rendererData->currentCommandBuffer);
+            rendererData->currentRenderPass = VK_NULL_HANDLE;
+        }
+        VULKAN_BeginRenderPass(rendererData, loadOp, clearColor);
+    }
+
+    // Bind cached VB now
+    if (stateCache->vertexBuffer != VK_NULL_HANDLE) {
+        VkDeviceSize offset = 0;
+        vkCmdBindVertexBuffers(rendererData->currentCommandBuffer, 0, 1, &stateCache->vertexBuffer, &offset);
+    }
+
+    return true;
+}
+
+static void VULKAN_WaitForGPU(VULKAN_RenderData *rendererData)
+{
+    vkQueueWaitIdle(rendererData->graphicsQueue);
+}
+
+
+static void VULKAN_ResetCommandList(VULKAN_RenderData *rendererData)
+{
+    vkResetCommandBuffer(rendererData->currentCommandBuffer, 0);
+    for (uint32_t i = 0; i < rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]; i++) {
+        vkResetDescriptorPool(rendererData->device, rendererData->descriptorPools[rendererData->currentCommandBufferIndex][i], 0);
+    }
+
+    VkCommandBufferBeginInfo beginInfo = { 0 };
+    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    beginInfo.flags = 0;
+    vkBeginCommandBuffer(rendererData->currentCommandBuffer, &beginInfo);
+
+    rendererData->currentPipelineState = NULL;
+    rendererData->currentVertexBuffer = 0;
+    rendererData->issueBatch = false;
+    rendererData->cliprectDirty = true;
+    rendererData->currentDescriptorSetIndex = 0;
+    rendererData->currentDescriptorPoolIndex = 0;
+    rendererData->currentConstantBufferOffset = -1;
+    rendererData->currentConstantBufferIndex = 0;
+
+    // Release any upload buffers that were inflight
+    for (int i = 0; i < rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex]; ++i) {
+        VULKAN_DestroyBuffer(rendererData, &rendererData->uploadBuffers[rendererData->currentCommandBufferIndex][i]);
+    }
+    rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex] = 0;
+}
+
+static VkResult VULKAN_IssueBatch(VULKAN_RenderData *rendererData)
+{
+    VkResult result;
+    if (rendererData->currentCommandBuffer == VK_NULL_HANDLE) {
+        return VK_SUCCESS;
+    }
+
+    if (rendererData->currentRenderPass) {
+        vkCmdEndRenderPass(rendererData->currentCommandBuffer);
+        rendererData->currentRenderPass = VK_NULL_HANDLE;
+    }
+
+    rendererData->currentPipelineState = VK_NULL_HANDLE;
+    rendererData->viewportDirty = true;
+
+    vkEndCommandBuffer(rendererData->currentCommandBuffer);
+
+    VkSubmitInfo submitInfo = { 0 };
+    VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &rendererData->currentCommandBuffer;
+    if (rendererData->waitRenderSemaphoreCount > 0) {
+        Uint32 additionalSemaphoreCount = (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) ? 1 : 0;
+        submitInfo.waitSemaphoreCount = rendererData->waitRenderSemaphoreCount + additionalSemaphoreCount;
+        if (additionalSemaphoreCount > 0) {
+            rendererData->waitRenderSemaphores[rendererData->waitRenderSemaphoreCount] = rendererData->currentImageAvailableSemaphore;
+            rendererData->waitDestStageMasks[rendererData->waitRenderSemaphoreCount] = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+        }
+        submitInfo.pWaitSemaphores = rendererData->waitRenderSemaphores;
+        submitInfo.pWaitDstStageMask = rendererData->waitDestStageMasks;
+        rendererData->waitRenderSemaphoreCount = 0;
+    } else if (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) {
+        submitInfo.waitSemaphoreCount = 1;
+        submitInfo.pWaitSemaphores = &rendererData->currentImageAvailableSemaphore;
+        submitInfo.pWaitDstStageMask = &waitDestStageMask;
+    }
+
+    result = vkQueueSubmit(rendererData->graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
+    rendererData->currentImageAvailableSemaphore = VK_NULL_HANDLE;
+
+    VULKAN_WaitForGPU(rendererData);
+
+    VULKAN_ResetCommandList(rendererData);
+
+    return result;
+}
+
+static void VULKAN_DestroyRenderer(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    if (rendererData) {
+        if (rendererData->device != VK_NULL_HANDLE) {
+            vkDeviceWaitIdle(rendererData->device);
+            VULKAN_DestroyAll(renderer);
+        }
+        SDL_free(rendererData);
+    }
+}
+
+static VkBlendFactor GetBlendFactor(SDL_BlendFactor factor)
+{
+    switch (factor) {
+    case SDL_BLENDFACTOR_ZERO:
+        return VK_BLEND_FACTOR_ZERO;
+    case SDL_BLENDFACTOR_ONE:
+        return VK_BLEND_FACTOR_ONE;
+    case SDL_BLENDFACTOR_SRC_COLOR:
+        return VK_BLEND_FACTOR_SRC_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+        return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
+    case SDL_BLENDFACTOR_SRC_ALPHA:
+        return VK_BLEND_FACTOR_SRC_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+        return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+    case SDL_BLENDFACTOR_DST_COLOR:
+        return VK_BLEND_FACTOR_DST_COLOR;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+        return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
+    case SDL_BLENDFACTOR_DST_ALPHA:
+        return VK_BLEND_FACTOR_DST_ALPHA;
+    case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+        return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+    default:
+        return VK_BLEND_FACTOR_MAX_ENUM;
+    }
+}
+
+static VkBlendOp GetBlendOp(SDL_BlendOperation operation)
+{
+    switch (operation) {
+    case SDL_BLENDOPERATION_ADD:
+        return VK_BLEND_OP_ADD;
+    case SDL_BLENDOPERATION_SUBTRACT:
+        return VK_BLEND_OP_SUBTRACT;
+    case SDL_BLENDOPERATION_REV_SUBTRACT:
+        return VK_BLEND_OP_REVERSE_SUBTRACT;
+    case SDL_BLENDOPERATION_MINIMUM:
+        return VK_BLEND_OP_MIN;
+    case SDL_BLENDOPERATION_MAXIMUM:
+        return VK_BLEND_OP_MAX;
+    default:
+        return VK_BLEND_OP_MAX_ENUM;
+    }
+}
+
+
+static VULKAN_PipelineState *VULKAN_CreatePipelineState(SDL_Renderer *renderer,
+    VULKAN_Shader shader, VkPipelineLayout pipelineLayout, VkDescriptorSetLayout descriptorSetLayout, SDL_BlendMode blendMode, VkPrimitiveTopology topology, VkFormat format)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_PipelineState *pipelineStates;
+    VkPipeline pipeline = VK_NULL_HANDLE;
+    VkResult result = VK_SUCCESS;
+    VkPipelineVertexInputStateCreateInfo vertexInputCreateInfo = { 0 };
+    VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo = { 0 };
+    VkVertexInputAttributeDescription attributeDescriptions[3];
+    VkVertexInputBindingDescription bindingDescriptions[1];
+    VkPipelineShaderStageCreateInfo shaderStageCreateInfo[2];
+    VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo = { 0 };
+    VkPipelineViewportStateCreateInfo viewportStateCreateInfo = { 0 };
+    VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo = { 0 };
+    VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo = { 0 };
+    VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo = { 0 };
+    VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo = { 0 };
+
+    VkGraphicsPipelineCreateInfo pipelineCreateInfo = { 0 };
+    pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    pipelineCreateInfo.flags = 0;
+    pipelineCreateInfo.pStages = shaderStageCreateInfo;
+    pipelineCreateInfo.pVertexInputState = &vertexInputCreateInfo;
+    pipelineCreateInfo.pInputAssemblyState = &inputAssemblyStateCreateInfo;
+    pipelineCreateInfo.pViewportState = &viewportStateCreateInfo;
+    pipelineCreateInfo.pRasterizationState = &rasterizationStateCreateInfo;
+    pipelineCreateInfo.pMultisampleState = &multisampleStateCreateInfo;
+    pipelineCreateInfo.pDepthStencilState = &depthStencilStateCreateInfo;
+    pipelineCreateInfo.pColorBlendState = &colorBlendStateCreateInfo;
+    pipelineCreateInfo.pDynamicState = &dynamicStateCreateInfo;
+
+    // Shaders
+    const char *name = "main";
+    for (uint32_t i = 0; i < 2; i++) {
+        SDL_memset(&shaderStageCreateInfo[i], 0, sizeof(shaderStageCreateInfo[i]));
+        shaderStageCreateInfo[i].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        shaderStageCreateInfo[i].module = (i == 0) ? rendererData->vertexShaderModules[shader] : rendererData->fragmentShaderModules[shader];
+        shaderStageCreateInfo[i].stage = (i == 0) ? VK_SHADER_STAGE_VERTEX_BIT : VK_SHADER_STAGE_FRAGMENT_BIT;
+        shaderStageCreateInfo[i].pName = name;
+    }
+    pipelineCreateInfo.stageCount = 2;
+    pipelineCreateInfo.pStages = &shaderStageCreateInfo[0];
+
+
+    // Vertex input
+    vertexInputCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    vertexInputCreateInfo.vertexAttributeDescriptionCount = 3;
+    vertexInputCreateInfo.pVertexAttributeDescriptions = &attributeDescriptions[0];
+    vertexInputCreateInfo.vertexBindingDescriptionCount = 1;
+    vertexInputCreateInfo.pVertexBindingDescriptions = &bindingDescriptions[0];
+
+    attributeDescriptions[ 0 ].binding = 0;
+    attributeDescriptions[ 0 ].format = VK_FORMAT_R32G32_SFLOAT;
+    attributeDescriptions[ 0 ].location = 0;
+    attributeDescriptions[ 0 ].offset = 0;
+    attributeDescriptions[ 1 ].binding = 0;
+    attributeDescriptions[ 1 ].format = VK_FORMAT_R32G32_SFLOAT;
+    attributeDescriptions[ 1 ].location = 1;
+    attributeDescriptions[ 1 ].offset = 8;
+    attributeDescriptions[ 2 ].binding = 0;
+    attributeDescriptions[ 2 ].format = VK_FORMAT_R32G32B32A32_SFLOAT;
+    attributeDescriptions[ 2 ].location = 2;
+    attributeDescriptions[ 2 ].offset = 16;
+
+    bindingDescriptions[ 0 ].binding = 0;
+    bindingDescriptions[ 0 ].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+    bindingDescriptions[ 0 ].stride = 32;
+
+    // Input assembly
+    inputAssemblyStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    inputAssemblyStateCreateInfo.topology = topology;
+    inputAssemblyStateCreateInfo.primitiveRestartEnable = VK_FALSE;
+
+    viewportStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    viewportStateCreateInfo.scissorCount = 1;
+    viewportStateCreateInfo.viewportCount = 1;
+
+    // Dynamic states
+    dynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+    VkDynamicState dynamicStates[2] = {
+        VK_DYNAMIC_STATE_VIEWPORT,
+        VK_DYNAMIC_STATE_SCISSOR
+    };
+    dynamicStateCreateInfo.dynamicStateCount = SDL_arraysize(dynamicStates);
+    dynamicStateCreateInfo.pDynamicStates = dynamicStates;
+
+    // Rasterization state
+    rasterizationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rasterizationStateCreateInfo.depthClampEnable = VK_FALSE;
+    rasterizationStateCreateInfo.rasterizerDiscardEnable = VK_FALSE;
+    rasterizationStateCreateInfo.cullMode = VK_CULL_MODE_NONE;
+    rasterizationStateCreateInfo.polygonMode = VK_POLYGON_MODE_FILL;
+    rasterizationStateCreateInfo.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+    rasterizationStateCreateInfo.depthBiasEnable = VK_FALSE;
+    rasterizationStateCreateInfo.depthBiasConstantFactor = 0.0f;
+    rasterizationStateCreateInfo.depthBiasClamp = 0.0f;
+    rasterizationStateCreateInfo.depthBiasSlopeFactor = 0.0f;
+    rasterizationStateCreateInfo.lineWidth = 1.0f;
+
+    // MSAA state
+    multisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    VkSampleMask multiSampleMask = 0xFFFFFFFF;
+    multisampleStateCreateInfo.pSampleMask = &multiSampleMask;
+    multisampleStateCreateInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+    // Depth Stencil
+    depthStencilStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+
+    // Color blend
+    VkPipelineColorBlendAttachmentState colorBlendAttachment = { 0 };
+    colorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    colorBlendStateCreateInfo.attachmentCount = 1;
+    colorBlendStateCreateInfo.pAttachments = &colorBlendAttachment;
+    colorBlendAttachment.blendEnable = VK_TRUE;
+    colorBlendAttachment.srcColorBlendFactor = GetBlendFactor(SDL_GetBlendModeSrcColorFactor(blendMode));
+    colorBlendAttachment.srcAlphaBlendFactor = GetBlendFactor(SDL_GetBlendModeSrcAlphaFactor(blendMode));
+    colorBlendAttachment.colorBlendOp = GetBlendOp(SDL_GetBlendModeColorOperation(blendMode));
+    colorBlendAttachment.dstColorBlendFactor = GetBlendFactor(SDL_GetBlendModeDstColorFactor(blendMode));
+    colorBlendAttachment.dstAlphaBlendFactor = GetBlendFactor(SDL_GetBlendModeDstAlphaFactor(blendMode));
+    colorBlendAttachment.alphaBlendOp = GetBlendOp(SDL_GetBlendModeAlphaOperation(blendMode));
+    colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+    // Renderpass / layout
+    pipelineCreateInfo.renderPass = rendererData->currentRenderPass;
+    pipelineCreateInfo.subpass = 0;
+    pipelineCreateInfo.layout = pipelineLayout;
+
+    result = vkCreateGraphicsPipelines(rendererData->device, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &pipeline);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateGraphicsPipelines()", result);
+        return NULL;
+    }
+
+    pipelineStates = (VULKAN_PipelineState *)SDL_realloc(rendererData->pipelineStates, (rendererData->pipelineStateCount + 1) * sizeof(*pipelineStates));
+    if (!pipelineStates) {
+        return NULL;
+    }
+    pipelineStates[rendererData->pipelineStateCount].shader = shader;
+    pipelineStates[rendererData->pipelineStateCount].blendMode = blendMode;
+    pipelineStates[rendererData->pipelineStateCount].topology = topology;
+    pipelineStates[rendererData->pipelineStateCount].format = format;
+    pipelineStates[rendererData->pipelineStateCount].pipeline = pipeline;
+    pipelineStates[rendererData->pipelineStateCount].descriptorSetLayout = descriptorSetLayout;
+    pipelineStates[rendererData->pipelineStateCount].pipelineLayout = pipelineCreateInfo.layout;
+    rendererData->pipelineStates = pipelineStates;
+    ++rendererData->pipelineStateCount;
+
+    return &pipelineStates[rendererData->pipelineStateCount - 1];
+}
+
+static bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut)
+{
+    uint32_t memoryTypeIndex = 0;
+    bool foundExactMatch = false;
+
+    // Desired flags must be a superset of required flags.
+    desiredFlags |= requiredFlags;
+
+    for (memoryTypeIndex = 0; memoryTypeIndex < rendererData->physicalDeviceMemoryProperties.memoryTypeCount; memoryTypeIndex++) {
+        if (typeBits & (1 << memoryTypeIndex)) {
+            if (rendererData->physicalDeviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags == desiredFlags) {
+                foundExactMatch = true;
+                break;
+            }
+        }
+    }
+    if (!foundExactMatch) {
+        for (memoryTypeIndex = 0; memoryTypeIndex < rendererData->physicalDeviceMemoryProperties.memoryTypeCount; memoryTypeIndex++) {
+            if (typeBits & (1 << memoryTypeIndex)) {
+                if ((rendererData->physicalDeviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags & requiredFlags) == requiredFlags) {
+                    break;
+                }
+            }
+        }
+    }
+
+    if (memoryTypeIndex >= rendererData->physicalDeviceMemoryProperties.memoryTypeCount) {
+        SET_ERROR_MESSAGE("Unable to find memory type for allocation");
+        return false;
+    }
+    *memoryTypeIndexOut = memoryTypeIndex;
+    return true;
+}
+
+static VkResult VULKAN_CreateVertexBuffer(VULKAN_RenderData *rendererData, size_t vbidx, size_t size)
+{
+    VkResult result;
+
+    VULKAN_DestroyBuffer(rendererData, &rendererData->vertexBuffers[vbidx]);
+
+    result = VULKAN_AllocateBuffer(rendererData, size,
+        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+        &rendererData->vertexBuffers[vbidx]);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+    return result;
+}
+
+static bool VULKAN_LoadGlobalFunctions(VULKAN_RenderData *rendererData)
+{
+#define VULKAN_DEVICE_FUNCTION(name)
+#define VULKAN_GLOBAL_FUNCTION(name)                                                        \
+    name = (PFN_##name)rendererData->vkGetInstanceProcAddr(VK_NULL_HANDLE, #name);          \
+    if (!name) {                                                                            \
+        SET_ERROR_MESSAGE("vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed");   \
+        return false;                                                                       \
+    }
+#define VULKAN_INSTANCE_FUNCTION(name)
+#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name)
+#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name)
+    VULKAN_FUNCTIONS()
+#undef VULKAN_DEVICE_FUNCTION
+#undef VULKAN_GLOBAL_FUNCTION
+#undef VULKAN_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
+
+    return true;
+}
+
+static bool VULKAN_LoadInstanceFunctions(VULKAN_RenderData *rendererData)
+{
+#define VULKAN_DEVICE_FUNCTION(name)
+#define VULKAN_GLOBAL_FUNCTION(name)
+#define VULKAN_INSTANCE_FUNCTION(name)                                                      \
+    name = (PFN_##name)rendererData->vkGetInstanceProcAddr(rendererData->instance, #name);  \
+    if (!name) {                                                                            \
+        SET_ERROR_MESSAGE("vkGetInstanceProcAddr(instance, \"" #name "\") failed");         \
+        return false;                                                                       \
+    }
+#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name)                                             \
+    name = (PFN_##name)rendererData->vkGetInstanceProcAddr(rendererData->instance, #name);
+#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name)
+
+    VULKAN_FUNCTIONS()
+#undef VULKAN_DEVICE_FUNCTION
+#undef VULKAN_GLOBAL_FUNCTION
+#undef VULKAN_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
+
+    return true;
+}
+
+static bool VULKAN_LoadDeviceFunctions(VULKAN_RenderData *rendererData)
+{
+#define VULKAN_DEVICE_FUNCTION(name)                                            \
+    name = (PFN_##name)vkGetDeviceProcAddr(rendererData->device, #name);        \
+    if (!name) {                                                                \
+        SET_ERROR_MESSAGE("vkGetDeviceProcAddr(device, \"" #name "\") failed"); \
+        return false;                                                           \
+    }
+#define VULKAN_GLOBAL_FUNCTION(name)
+#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name)                                \
+    name = (PFN_##name)vkGetDeviceProcAddr(rendererData->device, #name);
+#define VULKAN_INSTANCE_FUNCTION(name)
+#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name)
+    VULKAN_FUNCTIONS()
+#undef VULKAN_DEVICE_FUNCTION
+#undef VULKAN_GLOBAL_FUNCTION
+#undef VULKAN_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
+#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
+    return true;
+}
+
+static VkResult VULKAN_FindPhysicalDevice(VULKAN_RenderData *rendererData)
+{
+    uint32_t physicalDeviceCount = 0;
+    VkPhysicalDevice *physicalDevices;
+    VkQueueFamilyProperties *queueFamiliesProperties = NULL;
+    uint32_t queueFamiliesPropertiesAllocatedSize = 0;
+    VkExtensionProperties *deviceExtensions = NULL;
+    uint32_t deviceExtensionsAllocatedSize = 0;
+    uint32_t physicalDeviceIndex;
+    VkResult result;
+
+    result = vkEnumeratePhysicalDevices(rendererData->instance, &physicalDeviceCount, NULL);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkEnumeratePhysicalDevices()", result);
+        return result;
+    }
+    if (physicalDeviceCount == 0) {
+        SET_ERROR_MESSAGE("vkEnumeratePhysicalDevices(): no physical devices");
+        return VK_ERROR_UNKNOWN;
+    }
+    physicalDevices = (VkPhysicalDevice *)SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
+    result = vkEnumeratePhysicalDevices(rendererData->instance, &physicalDeviceCount, physicalDevices);
+    if (result != VK_SUCCESS) {
+        SDL_free(physicalDevices);
+        SET_ERROR_CODE("vkEnumeratePhysicalDevices()", result);
+        return result;
+    }
+    rendererData->physicalDevice = NULL;
+    for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
+        uint32_t queueFamiliesCount = 0;
+        uint32_t queueFamilyIndex;
+        uint32_t deviceExtensionCount = 0;
+        bool hasSwapchainExtension = false;
+        uint32_t i;
+
+        VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
+        vkGetPhysicalDeviceProperties(physicalDevice, &rendererData->physicalDeviceProperties);
+        if (VK_VERSION_MAJOR(rendererData->physicalDeviceProperties.apiVersion) < 1) {
+            continue;
+        }
+        vkGetPhysicalDeviceMemoryProperties(physicalDevice, &rendererData->physicalDeviceMemoryProperties);
+        vkGetPhysicalDeviceFeatures(physicalDevice, &rendererData->physicalDeviceFeatures);
+        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);
+        if (queueFamiliesCount == 0) {
+            continue;
+        }
+        if (queueFamiliesPropertiesAllocatedSize < queueFamiliesCount) {
+            SDL_free(queueFamiliesProperties);
+            queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;
+            queueFamiliesProperties = (VkQueueFamilyProperties *)SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
+            if (!queueFamiliesProperties) {
+                SDL_free(physicalDevices);
+                SDL_free(deviceExtensions);
+                return VK_ERROR_UNKNOWN;
+            }
+        }
+        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
+        rendererData->graphicsQueueFamilyIndex = queueFamiliesCount;
+        rendererData->presentQueueFamilyIndex = queueFamiliesCount;
+        for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; queueFamilyIndex++) {
+            VkBool32 supported = 0;
+
+            if (queueFamiliesProperties[queueFamilyIndex].queueCount == 0) {
+                continue;
+            }
+
+            if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+                rendererData->graphicsQueueFamilyIndex = queueFamilyIndex;
+            }
+
+            result = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, rendererData->surface, &supported);
+            if (result != VK_SUCCESS) {
+                SDL_free(physicalDevices);
+                SDL_free(queueFamiliesProperties);
+                SDL_free(deviceExtensions);
+                SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceSupportKHR()", result);
+                return VK_ERROR_UNKNOWN;
+            }
+            if (supported) {
+                rendererData->presentQueueFamilyIndex = queueFamilyIndex;
+                if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+                    break; // use this queue because it can present and do graphics
+                }
+            }
+        }
+
+        if (rendererData->graphicsQueueFamilyIndex == queueFamiliesCount) { // no good queues found
+            continue;
+        }
+        if (rendererData->presentQueueFamilyIndex == queueFamiliesCount) { // no good queues found
+            continue;
+        }
+        result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
+        if (result != VK_SUCCESS) {
+            SDL_free(physicalDevices);
+            SDL_free(queueFamiliesProperties);
+            SDL_free(deviceExtensions);
+            SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
+            return VK_ERROR_UNKNOWN;
+        }
+        if (deviceExtensionCount == 0) {
+            continue;
+        }
+        if (deviceExtensionsAllocatedSize < deviceExtensionCount) {
+            SDL_free(deviceExtensions);
+            deviceExtensionsAllocatedSize = deviceExtensionCount;
+            deviceExtensions = (VkExtensionProperties *)SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
+            if (!deviceExtensions) {
+                SDL_free(physicalDevices);
+                SDL_free(queueFamiliesProperties);
+                return VK_ERROR_UNKNOWN;
+            }
+        }
+        result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
+        if (result != VK_SUCCESS) {
+            SDL_free(physicalDevices);
+            SDL_free(queueFamiliesProperties);
+            SDL_free(deviceExtensions);
+            SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
+            return result;
+        }
+        for (i = 0; i < deviceExtensionCount; i++) {
+            if (SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
+                hasSwapchainExtension = true;
+                break;
+            }
+        }
+        if (!hasSwapchainExtension) {
+            continue;
+        }
+        rendererData->physicalDevice = physicalDevice;
+        break;
+    }
+    SDL_free(physicalDevices);
+    SDL_free(queueFamiliesProperties);
+    SDL_free(deviceExtensions);
+    if (!rendererData->physicalDevice) {
+        SET_ERROR_MESSAGE("No viable physical devices found");
+        return VK_ERROR_UNKNOWN;
+    }
+    return VK_SUCCESS;
+}
+
+static VkResult VULKAN_GetSurfaceFormats(VULKAN_RenderData *rendererData)
+{
+    VkResult result = vkGetPhysicalDeviceSurfaceFormatsKHR(rendererData->physicalDevice,
+                                                           rendererData->surface,
+                                                           &rendererData->surfaceFormatsCount,
+                                                           NULL);
+    if (result != VK_SUCCESS) {
+        rendererData->surfaceFormatsCount = 0;
+        SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceFormatsKHR()", result);
+        return result;
+    }
+    if (rendererData->surfaceFormatsCount > rendererData->surfaceFormatsAllocatedCount) {
+        rendererData->surfaceFormatsAllocatedCount = rendererData->surfaceFormatsCount;
+        SDL_free(rendererData->surfaceFormats);
+        rendererData->surfaceFormats = (VkSurfaceFormatKHR *)SDL_malloc(sizeof(VkSurfaceFormatKHR) * rendererData->surfaceFormatsAllocatedCount);
+    }
+    result = vkGetPhysicalDeviceSurfaceFormatsKHR(rendererData->physicalDevice,
+                                                  rendererData->surface,
+                                                  &rendererData->surfaceFormatsCount,
+                                                  rendererData->surfaceFormats);
+    if (result != VK_SUCCESS) {
+        rendererData->surfaceFormatsCount = 0;
+        SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceFormatsKHR()", result);
+        return result;
+    }
+
+    return VK_SUCCESS;
+}
+
+static VkSemaphore VULKAN_CreateSemaphore(VULKAN_RenderData *rendererData)
+{
+    VkResult result;
+    VkSemaphore semaphore = VK_NULL_HANDLE;
+
+    VkSemaphoreCreateInfo semaphoreCreateInfo = { 0 };
+    semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    result = vkCreateSemaphore(rendererData->device, &semaphoreCreateInfo, NULL, &semaphore);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateSemaphore()", result);
+        return VK_NULL_HANDLE;
+    }
+    return semaphore;
+}
+
+static bool VULKAN_DeviceExtensionsFound(VULKAN_RenderData *rendererData, int extensionsToCheck, const char* const* extNames)
+{
+    uint32_t extensionCount;
+    bool foundExtensions = true;
+    VkResult result = vkEnumerateDeviceExtensionProperties(rendererData->physicalDevice, NULL, &extensionCount, NULL);
+    if (result != VK_SUCCESS ) {
+        SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
+        return false;
+    }
+    if (extensionCount > 0 ) {
+        VkExtensionProperties *extensionProperties = (VkExtensionProperties *)SDL_calloc(extensionCount, sizeof(VkExtensionProperties));
+        result = vkEnumerateDeviceExtensionProperties(rendererData->physicalDevice, NULL, &extensionCount, extensionProperties);
+        if (result != VK_SUCCESS ) {
+            SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
+            SDL_free(extensionProperties);
+            return false;
+        }
+        for (int ext = 0; ext < extensionsToCheck && foundExtensions; ext++) {
+            bool foundExtension = false;
+            for (uint32_t i = 0; i < extensionCount; i++) {
+                if (SDL_strcmp(extensionProperties[i].extensionName, extNames[ext]) == 0) {
+                    foundExtension = true;
+                    break;
+                }
+            }
+            foundExtensions &= foundExtension;
+        }
+
+        SDL_free(extensionProperties);
+    }
+
+    return foundExtensions;
+}
+
+static bool VULKAN_InstanceExtensionFound(VULKAN_RenderData *rendererData, const char *extName)
+{
+    uint32_t extensionCount;
+    VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
+    if (result != VK_SUCCESS ) {
+        SET_ERROR_CODE("vkEnumerateInstanceExtensionProperties()", result);
+        return false;
+    }
+    if (extensionCount > 0 ) {
+        VkExtensionProperties *extensionProperties = (VkExtensionProperties *)SDL_calloc(extensionCount, sizeof(VkExtensionProperties));
+        result = vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensionProperties);
+        if (result != VK_SUCCESS ) {
+            SET_ERROR_CODE("vkEnumerateInstanceExtensionProperties()", result);
+            SDL_free(extensionProperties);
+            return false;
+        }
+        for (uint32_t i = 0; i< extensionCount; i++) {
+            if (SDL_strcmp(extensionProperties[i].extensionName, extName) == 0) {
+                SDL_free(extensionProperties);
+                return true;
+            }
+        }
+        SDL_free(extensionProperties);
+    }
+
+    return false;
+}
+
+static bool VULKAN_ValidationLayersFound(void)
+{
+    uint32_t instanceLayerCount = 0;
+    uint32_t i;
+    bool foundValidation = false;
+
+    vkEnumerateInstanceLayerProperties(&instanceLayerCount, NULL);
+    if (instanceLayerCount > 0) {
+        VkLayerProperties *instanceLayers = (VkLayerProperties *)SDL_calloc(instanceLayerCount, sizeof(VkLayerProperties));
+        vkEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayers);
+        for (i = 0; i < instanceLayerCount; i++) {
+            if (!SDL_strcmp(SDL_VULKAN_VALIDATION_LAYER_NAME, instanceLayers[i].layerName)) {
+                foundValidation = true;
+                break;
+            }
+        }
+        SDL_free(instanceLayers);
+    }
+
+    return foundValidation;
+}
+
+// Create resources that depend on the device.
+static VkResult VULKAN_CreateDeviceResources(SDL_Renderer *renderer, SDL_PropertiesID create_props)
+{
+    static const char *const deviceExtensionNames[] = {
+        VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+        /* VK_KHR_sampler_ycbcr_conversion + dependent extensions.
+           Note VULKAN_DeviceExtensionsFound() call below, if these get moved in this
+           array, update that check too.
+       */
+        VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
+        VK_KHR_MAINTENANCE1_EXTENSION_NAME,
+        VK_KHR_BIND_MEMORY_2_EXTENSION_NAME,
+        VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
+    };
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    SDL_VideoDevice *device = SDL_GetVideoDevice();
+    VkResult result = VK_SUCCESS;
+    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
+    bool createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false);
+    const char *validationLayerName[] = { SDL_VULKAN_VALIDATION_LAYER_NAME };
+
+    if (!SDL_Vulkan_LoadLibrary(NULL)) {
+        SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "SDL_Vulkan_LoadLibrary failed" );
+        return VK_ERROR_UNKNOWN;
+    }
+    vkGetInstanceProcAddr = device ? (PFN_vkGetInstanceProcAddr)device->vulkan_config.vkGetInstanceProcAddr : NULL;
+    if(!vkGetInstanceProcAddr) {
+        SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "vkGetInstanceProcAddr is NULL" );
+        return VK_ERROR_UNKNOWN;
+    }
+
+    // Load global Vulkan functions
+    rendererData->vkGetInstanceProcAddr = vkGetInstanceProcAddr;
+    if (!VULKAN_LoadGlobalFunctions(rendererData)) {
+        return VK_ERROR_UNKNOWN;
+    }
+
+    // Check for colorspace extension
+    rendererData->supportsEXTSwapchainColorspace = VK_FALSE;
+    if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR ||
+        renderer->output_colorspace == SDL_COLORSPACE_HDR10) {
+        rendererData->supportsEXTSwapchainColorspace = VULKAN_InstanceExtensionFound(rendererData, VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME);
+        if (!rendererData->supportsEXTSwapchainColorspace) {
+            SDL_SetError("Using HDR output but %s not supported", VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME);
+            return VK_ERROR_UNKNOWN;
+        }
+    }
+
+    // Check for VK_KHR_get_physical_device_properties2
+    rendererData->supportsKHRGetPhysicalDeviceProperties2 = VULKAN_InstanceExtensionFound(rendererData, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+    // Create VkInstance
+    rendererData->instance = (VkInstance)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER, NULL);
+    if (rendererData->instance) {
+        rendererData->instance_external = true;
+    } else {
+        VkInstanceCreateInfo instanceCreateInfo = { 0 };
+        VkApplicationInfo appInfo = { 0 };
+        appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+        appInfo.apiVersion = VK_API_VERSION_1_0;
+        instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+        instanceCreateInfo.pApplicationInfo = &appInfo;
+        char const *const *instanceExtensions = SDL_Vulkan_GetInstanceExtensions(&instanceCreateInfo.enabledExtensionCount);
+
+        const char **instanceExtensionsCopy = (const char **)SDL_calloc(instanceCreateInfo.enabledExtensionCount + 2, sizeof(const char *));
+        for (uint32_t i = 0; i < instanceCreateInfo.enabledExtensionCount; i++) {
+            instanceExtensionsCopy[i] = instanceExtensions[i];
+        }
+        if (rendererData->supportsEXTSwapchainColorspace) {
+            instanceExtensionsCopy[instanceCreateInfo.enabledExtensionCount] = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME;
+            instanceCreateInfo.enabledExtensionCount++;
+        }
+        if (rendererData->supportsKHRGetPhysicalDeviceProperties2) {
+            instanceExtensionsCopy[instanceCreateInfo.enabledExtensionCount] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+            instanceCreateInfo.enabledExtensionCount++;
+        }
+        instanceCreateInfo.ppEnabledExtensionNames = (const char *const *)instanceExtensionsCopy;
+        if (createDebug && VULKAN_ValidationLayersFound()) {
+            instanceCreateInfo.ppEnabledLayerNames = validationLayerName;
+            instanceCreateInfo.enabledLayerCount = 1;
+        }
+        result = vkCreateInstance(&instanceCreateInfo, NULL, &rendererData->instance);
+        SDL_free((void *)instanceExtensionsCopy);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkCreateInstance()", result);
+            return result;
+        }
+    }
+
+    // Load instance Vulkan functions
+    if (!VULKAN_LoadInstanceFunctions(rendererData)) {
+        VULKAN_DestroyAll(renderer);
+        return VK_ERROR_UNKNOWN;
+    }
+
+    // Create Vulkan surface
+    rendererData->surface = (VkSurfaceKHR)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER, 0);
+    if (rendererData->surface) {
+        rendererData->surface_external = true;
+    } else {
+        if (!device->Vulkan_CreateSurface || !device->Vulkan_CreateSurface(device, renderer->window, rendererData->instance, NULL, &rendererData->surface)) {
+            VULKAN_DestroyAll(renderer);
+            SET_ERROR_MESSAGE("Vulkan_CreateSurface() failed");
+            return VK_ERROR_UNKNOWN;
+        }
+    }
+
+    // Choose Vulkan physical device
+    rendererData->physicalDevice = (VkPhysicalDevice)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER, NULL);
+    if (rendererData->physicalDevice) {
+        vkGetPhysicalDeviceMemoryProperties(rendererData->physicalDevice, &rendererData->physicalDeviceMemoryProperties);
+        vkGetPhysicalDeviceFeatures(rendererData->physicalDevice, &rendererData->physicalDeviceFeatures);
+    } else {
+        if (VULKAN_FindPhysicalDevice(rendererData) != VK_SUCCESS) {
+            VULKAN_DestroyAll(renderer);
+            return VK_ERROR_UNKNOWN;
+        }
+    }
+
+    if (SDL_HasProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER)) {
+        rendererData->graphicsQueueFamilyIndex = (uint32_t)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER, 0);
+    }
+    if (SDL_HasProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER)) {
+        rendererData->presentQueueFamilyIndex = (uint32_t)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER, 0);
+    }
+
+    if (rendererData->supportsKHRGetPhysicalDeviceProperties2 &&
+        VULKAN_DeviceExtensionsFound(rendererData, 4, &deviceExtensionNames[1])) {
+        rendererData->supportsKHRSamplerYCbCrConversion = true;
+    }
+
+    // Create Vulkan device
+    rendererData->device = (VkDevice)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER, NULL);
+    if (rendererData->device) {
+        rendererData->device_external = true;
+    } else {
+        VkPhysicalDeviceSamplerYcbcrConversionFeatures deviceSamplerYcbcrConversionFeatures = { 0 };
+        VkDeviceQueueCreateInfo deviceQueueCreateInfo[2] = { { 0 }, { 0 } };
+        static const float queuePriority[] = { 1.0f };
+
+        VkDeviceCreateInfo deviceCreateInfo = { 0 };
+        deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        deviceCreateInfo.queueCreateInfoCount = 0;
+        deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfo;
+        deviceCreateInfo.pEnabledFeatures = NULL;
+        deviceCreateInfo.enabledExtensionCount = (rendererData->supportsKHRSamplerYCbCrConversion) ? 5 : 1;
+        deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames;
+
+        deviceQueueCreateInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        deviceQueueCreateInfo[0].queueFamilyIndex = rendererData->graphicsQueueFamilyIndex;
+        deviceQueueCreateInfo[0].queueCount = 1;
+        deviceQueueCreateInfo[0].pQueuePriorities = queuePriority;
+        ++deviceCreateInfo.queueCreateInfoCount;
+
+        if (rendererData->presentQueueFamilyIndex != rendererData->graphicsQueueFamilyIndex) {
+            deviceQueueCreateInfo[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+            deviceQueueCreateInfo[1].queueFamilyIndex = rendererData->presentQueueFamilyIndex;
+            deviceQueueCreateInfo[1].queueCount = 1;
+            deviceQueueCreateInfo[1].pQueuePriorities = queuePriority;
+            ++deviceCreateInfo.queueCreateInfoCount;
+        }
+
+        if (rendererData->supportsKHRSamplerYCbCrConversion) {
+            deviceSamplerYcbcrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+            deviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion = VK_TRUE;
+            deviceSamplerYcbcrConversionFeatures.pNext = (void *)deviceCreateInfo.pNext;
+            deviceCreateInfo.pNext = &deviceSamplerYcbcrConversionFeatures;
+        }
+
+        result = vkCreateDevice(rendererData->physicalDevice, &deviceCreateInfo, NULL, &rendererData->device);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkCreateDevice()", result);
+            VULKAN_DestroyAll(renderer);
+            return result;
+        }
+    }
+
+    if (!VULKAN_LoadDeviceFunctions(rendererData)) {
+        VULKAN_DestroyAll(renderer);
+        return VK_ERROR_UNKNOWN;
+    }
+
+    // Get graphics/present queues
+    vkGetDeviceQueue(rendererData->device, rendererData->graphicsQueueFamilyIndex, 0, &rendererData->graphicsQueue);
+    if (rendererData->graphicsQueueFamilyIndex != rendererData->presentQueueFamilyIndex) {
+        vkGetDeviceQueue(rendererData->device, rendererData->presentQueueFamilyIndex, 0, &rendererData->presentQueue);
+    } else {
+        rendererData->presentQueue = rendererData->graphicsQueue;
+    }
+
+    // Create command pool/command buffers
+    VkCommandPoolCreateInfo commandPoolCreateInfo = { 0 };
+    commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+    commandPoolCreateInfo.queueFamilyIndex = rendererData->graphicsQueueFamilyIndex;
+    result = vkCreateCommandPool(rendererData->device, &commandPoolCreateInfo, NULL, &rendererData->commandPool);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyAll(renderer);
+        SET_ERROR_CODE("vkCreateCommandPool()", result);
+        return result;
+    }
+
+    if (VULKAN_GetSurfaceFormats(rendererData) != VK_SUCCESS) {
+        VULKAN_DestroyAll(renderer);
+        return result;
+    }
+
+    // Create shaders / layouts
+    for (uint32_t i = 0; i < NUM_SHADERS; i++) {
+        VULKAN_Shader shader = (VULKAN_Shader)i;
+        VkShaderModuleCreateInfo shaderModuleCreateInfo = { 0 };
+        shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+        VULKAN_GetVertexShader(shader, &shaderModuleCreateInfo.pCode, &shaderModuleCreateInfo.codeSize);
+        result = vkCreateShaderModule(rendererData->device, &shaderModuleCreateInfo, NULL, &rendererData->vertexShaderModules[i]);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyAll(renderer);
+            SET_ERROR_CODE("vkCreateShaderModule()", result);
+            return result;
+        }
+        VULKAN_GetPixelShader(shader, &shaderModuleCreateInfo.pCode, &shaderModuleCreateInfo.codeSize);
+        result = vkCreateShaderModule(rendererData->device, &shaderModuleCreateInfo, NULL, &rendererData->fragmentShaderModules[i]);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyAll(renderer);
+            SET_ERROR_CODE("vkCreateShaderModule()", result);
+            return result;
+        }
+    }
+
+    // Descriptor set layout / pipeline layout
+    result = VULKAN_CreateDescriptorSetAndPipelineLayout(rendererData, VK_NULL_HANDLE, &rendererData->descriptorSetLayout, &rendererData->pipelineLayout);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyAll(renderer);
+        return result;
+    }
+
+    // Create default vertex buffers
+    for (uint32_t i = 0; i < SDL_VULKAN_NUM_VERTEX_BUFFERS; ++i) {
+        VULKAN_CreateVertexBuffer(rendererData, i, SDL_VULKAN_VERTEX_BUFFER_DEFAULT_SIZE);
+    }
+
+    // Create samplers
+    {
+        static struct
+        {
+            VkFilter filter;
+            VkSamplerAddressMode address;
+        } samplerParams[] = {
+            { VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE },
+            { VK_FILTER_NEAREST, VK_SAMPLER_ADDRESS_MODE_REPEAT },
+            { VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE },
+            { VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_REPEAT },
+        };
+        SDL_COMPILE_TIME_ASSERT(samplerParams_SIZE, SDL_arraysize(samplerParams) == VULKAN_SAMPLER_COUNT);
+        VkSamplerCreateInfo samplerCreateInfo = { 0 };
+        samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+        samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+        samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        samplerCreateInfo.mipLodBias = 0.0f;
+        samplerCreateInfo.anisotropyEnable = VK_FALSE;
+        samplerCreateInfo.maxAnisotropy = 1.0f;
+        samplerCreateInfo.minLod = 0.0f;
+        samplerCreateInfo.maxLod = 1000.0f;
+        for (int i = 0; i < SDL_arraysize(samplerParams); ++i) {
+            samplerCreateInfo.magFilter = samplerParams[i].filter;
+            samplerCreateInfo.minFilter = samplerParams[i].filter;
+            samplerCreateInfo.addressModeU = samplerParams[i].address;
+            samplerCreateInfo.addressModeV = samplerParams[i].address;
+            result = vkCreateSampler(rendererData->device, &samplerCreateInfo, NULL, &rendererData->samplers[i]);
+            if (result != VK_SUCCESS) {
+                VULKAN_DestroyAll(renderer);
+                SET_ERROR_CODE("vkCreateSampler()", result);
+                return result;
+            }
+        }
+    }
+
+    SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_VULKAN_INSTANCE_POINTER, rendererData->instance);
+    SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_SURFACE_NUMBER, (Sint64)rendererData->surface);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_VULKAN_PHYSICAL_DEVICE_POINTER, rendererData->physicalDevice);
+    SDL_SetPointerProperty(props, SDL_PROP_RENDERER_VULKAN_DEVICE_POINTER, rendererData->device);
+    SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER, rendererData->graphicsQueueFamilyIndex);
+    SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER, rendererData->presentQueueFamilyIndex);
+
+    return VK_SUCCESS;
+}
+
+static VkResult VULKAN_CreateFramebuffersAndRenderPasses(SDL_Renderer *renderer, int w, int h,
+    VkFormat format, int imageViewCount, VkImageView *imageViews, VkFramebuffer *framebuffers, VkRenderPass renderPasses[VULKAN_RENDERPASS_COUNT])
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *) renderer->internal;
+    VkResult result;
+
+    VkAttachmentDescription attachmentDescription = { 0 };
+    attachmentDescription.format = format;
+    attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+    attachmentDescription.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+    attachmentDescription.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    attachmentDescription.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    attachmentDescription.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescription.flags = 0;
+
+    VkAttachmentReference colorAttachmentReference = { 0 };
+    colorAttachmentReference.attachment = 0;
+    colorAttachmentReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+    VkSubpassDescription subpassDescription = { 0 };
+    subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    subpassDescription.flags = 0;
+    subpassDescription.inputAttachmentCount = 0;
+    subpassDescription.pInputAttachments = NULL;
+    subpassDescription.colorAttachmentCount = 1;
+    subpassDescription.pColorAttachments = &colorAttachmentReference;
+    subpassDescription.pResolveAttachments = NULL;
+    subpassDescription.pDepthStencilAttachment = NULL;
+    subpassDescription.preserveAttachmentCount = 0;
+    subpassDescription.pPreserveAttachments = NULL;
+
+    VkSubpassDependency subPassDependency = { 0 };
+    subPassDependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+    subPassDependency.dstSubpass = 0;
+    subPassDependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    subPassDependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    subPassDependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    subPassDependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
+    subPassDependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
+
+    VkRenderPassCreateInfo renderPassCreateInfo = { 0 };
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    renderPassCreateInfo.flags = 0;
+    renderPassCreateInfo.attachmentCount = 1;
+    renderPassCreateInfo.pAttachments = &attachmentDescription;
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.dependencyCount = 1;
+    renderPassCreateInfo.pDependencies = &subPassDependency;
+
+    result = vkCreateRenderPass(rendererData->device, &renderPassCreateInfo, NULL, &renderPasses[VULKAN_RENDERPASS_LOAD]);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateRenderPass()", result);
+        return result;
+    }
+
+    attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+    result = vkCreateRenderPass(rendererData->device, &renderPassCreateInfo, NULL, &renderPasses[VULKAN_RENDERPASS_CLEAR]);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateRenderPass()", result);
+        return result;
+    }
+
+    VkFramebufferCreateInfo framebufferCreateInfo = { 0 };
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = NULL;
+    framebufferCreateInfo.renderPass = rendererData->renderPasses[VULKAN_RENDERPASS_LOAD];
+    framebufferCreateInfo.attachmentCount = 1;
+    framebufferCreateInfo.width = w;
+    framebufferCreateInfo.height = h;
+    framebufferCreateInfo.layers = 1;
+
+    for (int i = 0; i < imageViewCount; i++) {
+        framebufferCreateInfo.pAttachments = &imageViews[i];
+        result = vkCreateFramebuffer(rendererData->device, &framebufferCreateInfo, NULL, &framebuffers[i]);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkCreateFramebuffer()", result);
+            return result;
+        }
+    }
+
+    return result;
+}
+
+static VkResult VULKAN_CreateSwapChain(SDL_Renderer *renderer, int w, int h)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(rendererData->physicalDevice, rendererData->surface, &rendererData->surfaceCapabilities);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR()", result);
+        return result;
+    }
+
+    // clean up previous swapchain resources
+    if (rendererData->swapchainImageViews) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            vkDestroyImageView(rendererData->device, rendererData->swapchainImageViews[i], NULL);
+        }
+        SDL_free(rendererData->swapchainImageViews);
+        rendererData->swapchainImageViews = NULL;
+    }
+    if (rendererData->fences) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            if (rendererData->fences[i] != VK_NULL_HANDLE) {
+                vkDestroyFence(rendererData->device, rendererData->fences[i], NULL);
+            }
+        }
+        SDL_free(rendererData->fences);
+        rendererData->fences = NULL;
+    }
+    if (rendererData->commandBuffers) {
+        vkResetCommandPool(rendererData->device, rendererData->commandPool, 0);
+        SDL_free(rendererData->commandBuffers);
+        rendererData->commandBuffers = NULL;
+        rendererData->currentCommandBuffer = VK_NULL_HANDLE;
+        rendererData->currentCommandBufferIndex = 0;
+    }
+    if (rendererData->framebuffers) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            if (rendererData->framebuffers[i] != VK_NULL_HANDLE) {
+                vkDestroyFramebuffer(rendererData->device, rendererData->framebuffers[i], NULL);
+            }
+        }
+        SDL_free(rendererData->framebuffers);
+        rendererData->framebuffers = NULL;
+    }
+    if (rendererData->descriptorPools) {
+        SDL_assert(rendererData->numDescriptorPools);
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            for (uint32_t j = 0; j < rendererData->numDescriptorPools[i]; j++) {
+                if (rendererData->descriptorPools[i][j] != VK_NULL_HANDLE) {
+                    vkDestroyDescriptorPool(rendererData->device, rendererData->descriptorPools[i][j], NULL);
+                }
+            }
+            SDL_free(rendererData->descriptorPools[i]);
+        }
+        SDL_free(rendererData->descriptorPools);
+        rendererData->descriptorPools = NULL;
+        SDL_free(rendererData->numDescriptorPools);
+        rendererData->numDescriptorPools = NULL;
+    }
+    if (rendererData->imageAvailableSemaphores) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            if (rendererData->imageAvailableSemaphores[i] != VK_NULL_HANDLE) {
+                vkDestroySemaphore(rendererData->device, rendererData->imageAvailableSemaphores[i], NULL);
+            }
+        }
+        SDL_free(rendererData->imageAvailableSemaphores);
+        rendererData->imageAvailableSemaphores = NULL;
+    }
+    if (rendererData->renderingFinishedSemaphores) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            if (rendererData->renderingFinishedSemaphores[i] != VK_NULL_HANDLE) {
+                vkDestroySemaphore(rendererData->device, rendererData->renderingFinishedSemaphores[i], NULL);
+            }
+        }
+        SDL_free(rendererData->renderingFinishedSemaphores);
+        rendererData->renderingFinishedSemaphores = NULL;
+    }
+    if (rendererData->uploadBuffers) {
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            for (uint32_t j = 0; j < SDL_VULKAN_NUM_UPLOAD_BUFFERS; j++) {
+                VULKAN_DestroyBuffer(rendererData, &rendererData->uploadBuffers[i][j]);
+            }
+            SDL_free(rendererData->uploadBuffers[i]);
+        }
+        SDL_free(rendererData->uploadBuffers);
+        rendererData->uploadBuffers = NULL;
+    }
+    if (rendererData->constantBuffers) {
+        SDL_assert(rendererData->numConstantBuffers);
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
+            for (uint32_t j = 0; j < rendererData->numConstantBuffers[i]; j++) {
+                VULKAN_DestroyBuffer(rendererData, &rendererData->constantBuffers[i][j]);
+            }
+            SDL_free(rendererData->constantBuffers[i]);
+        }
+        SDL_free(rendererData->constantBuffers);
+        rendererData->constantBuffers = NULL;
+        SDL_free(rendererData->numConstantBuffers);
+        rendererData->numConstantBuffers = NULL;
+    }
+
+    // pick an image count
+    rendererData->swapchainDesiredImageCount = rendererData->surfaceCapabilities.minImageCount + SDL_VULKAN_FRAME_QUEUE_DEPTH;
+    if ((rendererData->swapchainDesiredImageCount > rendererData->surfaceCapabilities.maxImageCount) &&
+        (rendererData->surfaceCapabilities.maxImageCount > 0)) {
+        rendererData->swapchainDesiredImageCount = rendererData->surfaceCapabilities.maxImageCount;
+    }
+
+    VkFormat desiredFormat = VK_FORMAT_B8G8R8A8_UNORM;
+    VkColorSpaceKHR desiredColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+    if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+        desiredFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
+        desiredColorSpace = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT;
+    }
+    else if (renderer->output_colorspace == SDL_COLORSPACE_HDR10) {
+        desiredFormat = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+        desiredColorSpace = VK_COLOR_SPACE_HDR10_ST2084_EXT;
+    }
+
+    if ((rendererData->surfaceFormatsCount == 1) &&
+        (rendererData->surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) {
+        // aren't any preferred formats, so we pick
+        rendererData->surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+        rendererData->surfaceFormat.format = desiredFormat;
+    } else {
+        rendererData->surfaceFormat = rendererData->surfaceFormats[0];
+        rendererData->surfaceFormat.colorSpace = rendererData->surfaceFormats[0].colorSpace;
+        for (uint32_t i = 0; i < rendererData->surfaceFormatsCount; i++) {
+            if (rendererData->surfaceFormats[i].format == desiredFormat &&
+                rendererData->surfaceFormats[i].colorSpace == desiredColorSpace) {
+                rendererData->surfaceFormat.colorSpace = rendererData->surfaceFormats[i].colorSpace;
+                rendererData->surfaceFormat = rendererData->surfaceFormats[i];
+                break;
+            }
+        }
+    }
+
+    rendererData->swapchainSize.width = SDL_clamp((uint32_t)w,
+                                          rendererData->surfaceCapabilities.minImageExtent.width,
+                                          rendererData->surfaceCapabilities.maxImageExtent.width);
+
+    rendererData->swapchainSize.height = SDL_clamp((uint32_t)h,
+                                           rendererData->surfaceCapabilities.minImageExtent.height,
+                                           rendererData->surfaceCapabilities.maxImageExtent.height);
+
+    // Handle rotation
+    rendererData->swapChainPreTransform = rendererData->surfaceCapabilities.currentTransform;
+    if (rendererData->swapChainPreTransform == VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR ||
+        rendererData->swapChainPreTransform == VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) {
+        uint32_t tempWidth = rendererData->swapchainSize.width;
+        rendererData->swapchainSize.width = rendererData->swapchainSize.height;
+        rendererData->swapchainSize.height = tempWidth;
+    }
+
+    if (rendererData->swapchainSize.width == 0 && rendererData->swapchainSize.height == 0) {
+        // Don't recreate the swapchain if size is (0,0), just fail and continue attempting creation
+        return VK_ERROR_OUT_OF_DATE_KHR;
+    }
+
+    // Choose a present mode. If vsync is requested, then use VK_PRESENT_MODE_FIFO_KHR which is guaranteed to be supported
+    VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
+    if (rendererData->vsync <= 0) {
+        uint32_t presentModeCount = 0;
+        result = vkGetPhysicalDeviceSurfacePresentModesKHR(rendererData->physicalDevice, rendererData->surface, &presentModeCount, NULL);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkGetPhysicalDeviceSurfacePresentModesKHR()", result);
+            return result;
+        }
+        if (presentModeCount > 0) {
+            VkPresentModeKHR *presentModes = (VkPresentModeKHR *)SDL_calloc(presentModeCount, sizeof(VkPresentModeKHR));
+            result = vkGetPhysicalDeviceSurfacePresentModesKHR(rendererData->physicalDevice, rendererData->surface, &presentModeCount, presentModes);
+            if (result != VK_SUCCESS) {
+                SET_ERROR_CODE("vkGetPhysicalDeviceSurfacePresentModesKHR()", result);
+                SDL_free(presentModes);
+                return result;
+            }
+
+            if (rendererData->vsync == 0) {
+                /* If vsync is not requested, in favor these options in order:
+                   VK_PRESENT_MODE_IMMEDIATE_KHR    - no v-sync with tearing
+                   VK_PRESENT_MODE_MAILBOX_KHR      - no v-sync without tearing
+                   VK_PRESENT_MODE_FIFO_RELAXED_KHR - no v-sync, may tear */
+                for (uint32_t i = 0; i < presentModeCount; i++) {
+                    if (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR) {
+                        presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
+                        break;
+                    }
+                    else if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
+                        presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
+                    }
+                    else if ((presentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
+                             (presentModes[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR)) {
+                        presentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+                    }
+                }
+            } else if (rendererData->vsync == -1) {
+                for (uint32_t i = 0; i < presentModeCount; i++) {
+                    if (presentModes[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR) {
+                        presentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+                        break;
+                    }
+                }
+            }
+            SDL_free(presentModes);
+        }
+    }
+
+    VkSwapchainCreateInfoKHR swapchainCreateInfo = { 0 };
+    swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    swapchainCreateInfo.surface = rendererData->surface;
+    swapchainCreateInfo.minImageCount = rendererData->swapchainDesiredImageCount;
+    swapchainCreateInfo.imageFormat = rendererData->surfaceFormat.format;
+    swapchainCreateInfo.imageColorSpace = rendererData->surfaceFormat.colorSpace;
+    swapchainCreateInfo.imageExtent = rendererData->swapchainSize;
+    swapchainCreateInfo.imageArrayLayers = 1;
+    swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    swapchainCreateInfo.preTransform = rendererData->swapChainPreTransform;
+    swapchainCreateInfo.compositeAlpha = (renderer->window->flags & SDL_WINDOW_TRANSPARENT) ? (VkCompositeAlphaFlagBitsKHR)0 : VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    swapchainCreateInfo.presentMode = presentMode;
+    swapchainCreateInfo.clipped = VK_TRUE;
+    swapchainCreateInfo.oldSwapchain = rendererData->swapchain;
+    result = vkCreateSwapchainKHR(rendererData->device, &swapchainCreateInfo, NULL, &rendererData->swapchain);
+
+    if (swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) {
+        vkDestroySwapchainKHR(rendererData->device, swapchainCreateInfo.oldSwapchain, NULL);
+    }
+
+    if (result != VK_SUCCESS) {
+        rendererData->swapchain = VK_NULL_HANDLE;
+        SET_ERROR_CODE("vkCreateSwapchainKHR()", result);
+        return result;
+    }
+
+    SDL_free(rendererData->swapchainImages);
+    rendererData->swapchainImages = NULL;
+    result = vkGetSwapchainImagesKHR(rendererData->device, rendererData->swapchain, &rendererData->swapchainImageCount, NULL);
+    if (result != VK_SUCCESS) {
+        rendererData->swapchainImageCount = 0;
+        SET_ERROR_CODE("vkGetSwapchainImagesKHR()", result);
+        return result;
+    }
+
+    rendererData->swapchainImages = (VkImage *)SDL_malloc(sizeof(VkImage) * rendererData->swapchainImageCount);
+    result = vkGetSwapchainImagesKHR(rendererData->device,
+                                     rendererData->swapchain,
+                                     &rendererData->swapchainImageCount,
+                                     rendererData->swapchainImages);
+    if (result != VK_SUCCESS) {
+        SDL_free(rendererData->swapchainImages);
+        rendererData->swapchainImages = NULL;
+        rendererData->swapchainImageCount = 0;
+        SET_ERROR_CODE("vkGetSwapchainImagesKHR()", result);
+        return result;
+    }
+
+    // Create VkImageView's for swapchain images
+    {
+        VkImageViewCreateInfo imageViewCreateInfo = { 0 };
+        imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+        imageViewCreateInfo.flags = 0;
+        imageViewCreateInfo.format = rendererData->surfaceFormat.format;
+        imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+        imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+        imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+        imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+        imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+        imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
+        imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
+        imageViewCreateInfo.subresourceRange.layerCount = 1;
+        imageViewCreateInfo.subresourceRange.levelCount = 1;
+        imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        rendererData->swapchainImageViews = (VkImageView *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkImageView));
+        SDL_free(rendererData->swapchainImageLayouts);
+        rendererData->swapchainImageLayouts = (VkImageLayout *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkImageLayout));
+        for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+            imageViewCreateInfo.image = rendererData->swapchainImages[i];
+            result = vkCreateImageView(rendererData->device, &imageViewCreateInfo, NULL, &rendererData->swapchainImageViews[i]);
+            if (result != VK_SUCCESS) {
+                VULKAN_DestroyAll(renderer);
+                SET_ERROR_CODE("vkCreateImageView()", result);
+                return result;
+            }
+            rendererData->swapchainImageLayouts[i] = VK_IMAGE_LAYOUT_UNDEFINED;
+        }
+
+    }
+
+    VkCommandBufferAllocateInfo commandBufferAllocateInfo = { 0 };
+    commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    commandBufferAllocateInfo.commandPool = rendererData->commandPool;
+    commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    commandBufferAllocateInfo.commandBufferCount = rendererData->swapchainImageCount;
+    rendererData->commandBuffers = (VkCommandBuffer *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkCommandBuffer));
+    result = vkAllocateCommandBuffers(rendererData->device, &commandBufferAllocateInfo, rendererData->commandBuffers);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyAll(renderer);
+        SET_ERROR_CODE("vkAllocateCommandBuffers()", result);
+        return result;
+    }
+
+    // Create fences
+    rendererData->fences = (VkFence *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkFence));
+    for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+        VkFenceCreateInfo fenceCreateInfo = { 0 };
+        fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+        fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+        result = vkCreateFence(rendererData->device, &fenceCreateInfo, NULL, &rendererData->fences[i]);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyAll(renderer);
+            SET_ERROR_CODE("vkCreateFence()", result);
+            return result;
+        }
+    }
+
+    // Create renderpasses and framebuffer
+    for (uint32_t i = 0; i < SDL_arraysize(rendererData->renderPasses); i++) {
+        if (rendererData->renderPasses[i] != VK_NULL_HANDLE) {
+            vkDestroyRenderPass(rendererData->device, rendererData->renderPasses[i], NULL);
+            rendererData->renderPasses[i] = VK_NULL_HANDLE;
+        }
+    }
+    rendererData->framebuffers = (VkFramebuffer *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkFramebuffer));
+    result = VULKAN_CreateFramebuffersAndRenderPasses(renderer,
+        rendererData->swapchainSize.width,
+        rendererData->swapchainSize.height,
+        rendererData->surfaceFormat.format,
+        rendererData->swapchainImageCount,
+        rendererData->swapchainImageViews,
+        rendererData->framebuffers,
+        rendererData->renderPasses);
+    if (result != VK_SUCCESS) {
+        VULKAN_DestroyAll(renderer);
+        SET_ERROR_CODE("VULKAN_CreateFramebuffersAndRenderPasses()", result);
+        return result;
+    }
+
+    // Create descriptor pools - start by allocating one per swapchain image, let it grow if more are needed
+    rendererData->descriptorPools = (VkDescriptorPool **)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkDescriptorPool*));
+    rendererData->numDescriptorPools = (uint32_t *)SDL_calloc(rendererData->swapchainImageCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+        // Start by just allocating one pool, it will grow if needed
+        rendererData->numDescriptorPools[i] = 1;
+        rendererData->descriptorPools[i] = (VkDescriptorPool *)SDL_calloc(1, sizeof(VkDescriptorPool));
+        rendererData->descriptorPools[i][0] = VULKAN_AllocateDescriptorPool(rendererData);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyAll(renderer);
+            return result;
+        }
+    }
+
+    // Create semaphores
+    rendererData->imageAvailableSemaphores = (VkSemaphore *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkSemaphore));
+    rendererData->renderingFinishedSemaphores = (VkSemaphore *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkSemaphore));
+    for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+        rendererData->imageAvailableSemaphores[i] = VULKAN_CreateSemaphore(rendererData);
+        if (rendererData->imageAvailableSemaphores[i] == VK_NULL_HANDLE) {
+            VULKAN_DestroyAll(renderer);
+            return VK_ERROR_UNKNOWN;
+        }
+        rendererData->renderingFinishedSemaphores[i] = VULKAN_CreateSemaphore(rendererData);
+        if (rendererData->renderingFinishedSemaphores[i] == VK_NULL_HANDLE) {
+            VULKAN_DestroyAll(renderer);
+            return VK_ERROR_UNKNOWN;
+        }
+    }
+
+    // Upload buffers
+    rendererData->uploadBuffers = (VULKAN_Buffer **)SDL_calloc(rendererData->swapchainImageCount, sizeof(VULKAN_Buffer*));
+    for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+        rendererData->uploadBuffers[i] = (VULKAN_Buffer *)SDL_calloc(SDL_VULKAN_NUM_UPLOAD_BUFFERS, sizeof(VULKAN_Buffer));
+    }
+    SDL_free(rendererData->currentUploadBuffer);
+    rendererData->currentUploadBuffer = (int *)SDL_calloc(rendererData->swapchainImageCount, sizeof(int));
+
+    // Constant buffers
+    rendererData->constantBuffers = (VULKAN_Buffer **)SDL_calloc(rendererData->swapchainImageCount, sizeof(VULKAN_Buffer*));
+    rendererData->numConstantBuffers = (uint32_t *)SDL_calloc(rendererData->swapchainImageCount, sizeof(uint32_t));
+    for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
+        // Start with just allocating one, will grow if needed
+        rendererData->numConstantBuffers[i] = 1;
+        rendererData->constantBuffers[i] = (VULKAN_Buffer *)SDL_calloc(1, sizeof(VULKAN_Buffer));
+        result = VULKAN_AllocateBuffer(rendererData,
+            SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE,
+            VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+            VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+            &rendererData->constantBuffers[i][0]);
+        if (result != VK_SUCCESS) {
+            VULKAN_DestroyAll(renderer);
+            return result;
+        }
+    }
+    rendererData->currentConstantBufferOffset = -1;
+    rendererData->currentConstantBufferIndex = 0;
+
+    VULKAN_AcquireNextSwapchainImage(renderer);
+
+    SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
+    SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER, rendererData->swapchainImageCount);
+
+    return result;
+}
+
+// Initialize all resources that change when the window's size changes.
+static VkResult VULKAN_CreateWindowSizeDependentResources(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VkResult result = VK_SUCCESS;
+    int w, h;
+
+    // Release resources in the current command list
+    VULKAN_IssueBatch(rendererData);
+    VULKAN_WaitForGPU(rendererData);
+
+    /* The width and height of the swap chain must be based on the display's
+     * non-rotated size.
+     */
+    SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
+
+    result = VULKAN_CreateSwapChain(renderer, w, h);
+    if (result != VK_SUCCESS) {
+        rendererData->recreateSwapchain = VK_TRUE;
+    }
+
+    rendererData->viewportDirty = true;
+
+    return result;
+}
+
+static bool VULKAN_HandleDeviceLost(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    bool recovered = false;
+
+    VULKAN_DestroyAll(renderer);
+
+    if (VULKAN_CreateDeviceResources(renderer, rendererData->create_props) == VK_SUCCESS &&
+        VULKAN_CreateWindowSizeDependentResources(renderer) == VK_SUCCESS) {
+        recovered = true;
+    } else {
+        SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Renderer couldn't recover from device lost: %s", SDL_GetError());
+        VULKAN_DestroyAll(renderer);
+    }
+
+    // Let the application know that the device has been reset or lost
+    SDL_Event event;
+    SDL_zero(event);
+    event.type = recovered ? SDL_EVENT_RENDER_DEVICE_RESET : SDL_EVENT_RENDER_DEVICE_LOST;
+    event.render.windowID = SDL_GetWindowID(SDL_GetRenderWindow(renderer));
+    SDL_PushEvent(&event);
+
+    return recovered;
+}
+
+// This method is called when the window's size changes.
+static VkResult VULKAN_UpdateForWindowSizeChange(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    // If the GPU has previous work, wait for it to be done first
+    VULKAN_WaitForGPU(rendererData);
+
+    return VULKAN_CreateWindowSizeDependentResources(renderer);
+}
+
+static void VULKAN_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+
+    if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
+        rendererData->recreateSwapchain = true;
+    }
+}
+
+static bool VULKAN_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
+{
+    SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+    SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+    SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+    SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+    SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+    SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+    if (GetBlendFactor(srcColorFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
+        GetBlendFactor(srcAlphaFactor)  == VK_BLEND_FACTOR_MAX_ENUM ||
+        GetBlendOp(colorOperation) == VK_BLEND_OP_MAX_ENUM ||
+        GetBlendFactor(dstColorFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
+        GetBlendFactor(dstAlphaFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
+        GetBlendOp(alphaOperation) == VK_BLEND_OP_MAX_ENUM) {
+        return false;
+    }
+    return true;
+}
+
+static bool VULKAN_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData;
+    VkResult result;
+    VkFormat textureFormat = SDLPixelFormatToVkTextureFormat(texture->format, renderer->output_colorspace);
+    uint32_t width = texture->w;
+    uint32_t height = texture->h;
+    VkComponentMapping imageViewSwizzle = rendererData->identitySwizzle;
+
+    if (!rendererData->device) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if (textureFormat == VK_FORMAT_UNDEFINED) {
+        return SDL_SetError("%s, An unsupported SDL pixel format (0x%x) was specified", __FUNCTION__, texture->format);
+    }
+
+    textureData = (VULKAN_TextureData *)SDL_calloc(1, sizeof(*textureData));
+    if (!textureData) {
+        return false;
+    }
+    texture->internal = textureData;
+    if (SDL_COLORSPACETRANSFER(texture->colorspace) == SDL_TRANSFER_CHARACTERISTICS_SRGB) {
+        textureData->shader = SHADER_RGB;
+    } else {
+        textureData->shader = SHADER_ADVANCED;
+    }
+    textureData->scaleMode = (texture->scaleMode == SDL_SCALEMODE_NEAREST) ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
+
+#ifdef SDL_HAVE_YUV
+    // YUV textures must have even width and height.  Also create Ycbcr conversion
+    if (texture->format == SDL_PIXELFORMAT_YV12 ||
+        texture->format == SDL_PIXELFORMAT_IYUV ||
+        texture->format == SDL_PIXELFORMAT_NV12 ||
+        texture->format == SDL_PIXELFORMAT_NV21 ||
+        texture->format == SDL_PIXELFORMAT_P010) {
+        const uint32_t YUV_SD_THRESHOLD = 576;
+
+        // Check that we have VK_KHR_sampler_ycbcr_conversion support
+        if (!rendererData->supportsKHRSamplerYCbCrConversion) {
+            return SDL_SetError("YUV textures require a Vulkan device that supports VK_KHR_sampler_ycbcr_conversion");
+        }
+
+        VkSamplerYcbcrConversionCreateInfoKHR samplerYcbcrConversionCreateInfo = { 0 };
+        samplerYcbcrConversionCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR;
+
+        // Pad width/height to multiple of 2
+        width = (width + 1) & ~1;
+        height = (height + 1) & ~1;
+
+        // Create samplerYcbcrConversion which will be used on the VkImageView and VkSampler
+        samplerYcbcrConversionCreateInfo.format = textureFormat;
+        switch (SDL_COLORSPACEMATRIX(texture->colorspace)) {
+        case SDL_MATRIX_COEFFICIENTS_BT470BG:
+        case SDL_MATRIX_COEFFICIENTS_BT601:
+            samplerYcbcrConversionCreateInfo.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR;
+            break;
+        case SDL_MATRIX_COEFFICIENTS_BT709:
+            samplerYcbcrConversionCreateInfo.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR;
+            break;
+        case SDL_MATRIX_COEFFICIENTS_BT2020_NCL:
+            samplerYcbcrConversionCreateInfo.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR;
+            break;
+        case SDL_MATRIX_COEFFICIENTS_UNSPECIFIED:
+            if (texture->format == SDL_PIXELFORMAT_P010) {
+                samplerYcbcrConversionCreateInfo.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR;
+            } else if (height > YUV_SD_THRESHOLD) {
+                samplerYcbcrConversionCreateInfo.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR;
+            } else {
+                samplerYcbcrConversionCreateInfo.ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR;
+            }
+            break;
+        default:
+            return SDL_SetError("Unsupported Ycbcr colorspace: %d", SDL_COLORSPACEMATRIX(texture->colorspace));
+        }
+        samplerYcbcrConversionCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+        samplerYcbcrConversionCreateInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+        samplerYcbcrConversionCreateInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+        samplerYcbcrConversionCreateInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+        if (texture->format == SDL_PIXELFORMAT_YV12 ||
+            texture->format == SDL_PIXELFORMAT_NV21) {
+            samplerYcbcrConversionCreateInfo.components.r = VK_COMPONENT_SWIZZLE_B;
+            samplerYcbcrConversionCreateInfo.components.b = VK_COMPONENT_SWIZZLE_R;
+        }
+
+        switch (SDL_COLORSPACERANGE(texture->colorspace)) {
+        case SDL_COLOR_RANGE_LIMITED:
+            samplerYcbcrConversionCreateInfo.ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR;
+            break;
+        case SDL_COLOR_RANGE_FULL:
+        default:
+            samplerYcbcrConversionCreateInfo.ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR;
+            break;
+        }
+
+        switch (SDL_COLORSPACECHROMA(texture->colorspace)) {
+        case SDL_CHROMA_LOCATION_LEFT:
+            samplerYcbcrConversionCreateInfo.xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN_KHR;
+            samplerYcbcrConversionCreateInfo.yChromaOffset = VK_CHROMA_LOCATION_MIDPOINT_KHR;
+            break;
+        case SDL_CHROMA_LOCATION_TOPLEFT:
+            samplerYcbcrConversionCreateInfo.xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN_KHR;
+            samplerYcbcrConversionCreateInfo.yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN_KHR;
+            break;
+        case SDL_CHROMA_LOCATION_NONE:
+        case SDL_CHROMA_LOCATION_CENTER:
+        default:
+            samplerYcbcrConversionCreateInfo.xChromaOffset = VK_CHROMA_LOCATION_MIDPOINT_KHR;
+            samplerYcbcrConversionCreateInfo.yChromaOffset = VK_CHROMA_LOCATION_MIDPOINT_KHR;
+            break;
+        }
+        samplerYcbcrConversionCreateInfo.chromaFilter = VK_FILTER_LINEAR;
+        samplerYcbcrConversionCreateInfo.forceExplicitReconstruction = VK_FALSE;
+
+        result = vkCreateSamplerYcbcrConversionKHR(rendererData->device, &samplerYcbcrConversionCreateInfo, NULL, &textureData->samplerYcbcrConversion);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkCreateSamplerYcbcrConversionKHR()", result);
+            return false;
+        }
+
+        // Also create VkSampler object which we will need to pass to the PSO as an immutable sampler
+        VkSamplerCreateInfo samplerCreateInfo = { 0 };
+        samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+        samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
+        samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
+        samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+        samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        samplerCreateInfo.mipLodBias = 0.0f;
+        samplerCreateInfo.anisotropyEnable = VK_FALSE;
+        samplerCreateInfo.maxAnisotropy = 1.0f;
+        samplerCreateInfo.minLod = 0.0f;
+        samplerCreateInfo.maxLod = 1000.0f;
+
+        VkSamplerYcbcrConversionInfoKHR samplerYcbcrConversionInfo = { 0 };
+        samplerYcbcrConversionInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
+        samplerYcbcrConversionInfo.conversion = textureData->samplerYcbcrConversion;
+        samplerCreateInfo.pNext = &samplerYcbcrConversionInfo;
+        result = vkCreateSampler(rendererData->device, &samplerCreateInfo, NULL, &textureData->samplerYcbcr);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkCreateSampler()", result);
+            return false;
+        }
+
+        // Allocate special descriptor set layout with samplerYcbcr baked as an immutable sampler
+        result = VULKAN_CreateDescriptorSetAndPipelineLayout(rendererData, textureData->samplerYcbcr, &textureData->descriptorSetLayoutYcbcr, &textureData->pipelineLayoutYcbcr);
+        if (result != VK_SUCCESS) {
+            return false;
+        }
+    }
+#endif
+    textureData->width = width;
+    textureData->height = height;
+
+    VkImageUsageFlags usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    }
+
+    result = VULKAN_AllocateImage(rendererData, create_props, width, height, textureFormat, usage, imageViewSwizzle, textureData->samplerYcbcrConversion, &textureData->mainImage);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("VULKAN_AllocateImage()", result);
+        return false;
+    }
+
+    SDL_PropertiesID props = SDL_GetTextureProperties(texture);
+    SDL_SetNumberProperty(props, SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER, (Sint64)textureData->mainImage.image);
+
+    if (texture->access == SDL_TEXTUREACCESS_TARGET) {
+        result = VULKAN_CreateFramebuffersAndRenderPasses(renderer,
+            texture->w,
+            texture->h,
+            textureFormat,
+            1,
+            &textureData->mainImage.imageView,
+            &textureData->mainFramebuffer,
+            textureData->mainRenderpasses);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("VULKAN_CreateFramebuffersAndRenderPasses()", result);
+            return false;
+        }
+    }
+    return true;
+}
+
+static void VULKAN_DestroyTexture(SDL_Renderer *renderer,
+                                 SDL_Texture *texture)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+
+    /* Because SDL_DestroyTexture might be called while the data is in-flight, we need to issue the batch first
+       Unfortunately, this means that deleting a lot of textures mid-frame will have poor performance. */
+    VULKAN_IssueBatch(rendererData);
+    VULKAN_WaitForGPU(rendererData);
+
+    VULKAN_DestroyImage(rendererData, &textureData->mainImage);
+
+#ifdef SDL_HAVE_YUV
+    if (textureData->samplerYcbcrConversion != VK_NULL_HANDLE) {
+        vkDestroySamplerYcbcrConversionKHR(rendererData->device, textureData->samplerYcbcrConversion, NULL);
+        textureData->samplerYcbcrConversion = VK_NULL_HANDLE;
+    }
+    if (textureData->samplerYcbcr != VK_NULL_HANDLE) {
+        vkDestroySampler(rendererData->device, textureData->samplerYcbcr, NULL);
+        textureData->samplerYcbcr = VK_NULL_HANDLE;
+    }
+    if (textureData->pipelineLayoutYcbcr != VK_NULL_HANDLE) {
+        vkDestroyPipelineLayout(rendererData->device, textureData->pipelineLayoutYcbcr, NULL);
+        textureData->pipelineLayoutYcbcr = VK_NULL_HANDLE;
+    }
+    if (textureData->descriptorSetLayoutYcbcr != VK_NULL_HANDLE) {
+        vkDestroyDescriptorSetLayout(rendererData->device, textureData->descriptorSetLayoutYcbcr, NULL);
+        textureData->descriptorSetLayoutYcbcr = VK_NULL_HANDLE;
+    }
+#endif
+
+    VULKAN_DestroyBuffer(rendererData, &textureData->stagingBuffer);
+    if (textureData->mainFramebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(rendererData->device, textureData->mainFramebuffer, NULL);
+        textureData->mainFramebuffer = VK_NULL_HANDLE;
+    }
+    for (uint32_t i = 0; i < SDL_arraysize(textureData->mainRenderpasses); i++) {
+        if (textureData->mainRenderpasses[i] != VK_NULL_HANDLE) {
+            vkDestroyRenderPass(rendererData->device, textureData->mainRenderpasses[i], NULL);
+            textureData->mainRenderpasses[i] = VK_NULL_HANDLE;
+        }
+    }
+
+    SDL_free(textureData);
+    texture->internal = NULL;
+}
+
+static bool VULKAN_UpdateTextureInternal(VULKAN_RenderData *rendererData, VkImage image, VkFormat format, int plane, int x, int y, int w, int h, const void *pixels, int pitch, VkImageLayout *imageLayout)
+{
+    VkDeviceSize pixelSize = VULKAN_GetBytesPerPixel(format);
+    VkDeviceSize length = w * pixelSize;
+    VkDeviceSize uploadBufferSize = length * h;
+    const Uint8 *src;
+    Uint8 *dst;
+    VkResult rc;
+    int planeCount = VULKAN_VkFormatGetNumPlanes(format);
+
+    VULKAN_EnsureCommandBuffer(rendererData);
+
+    int currentUploadBufferIndex = rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex];
+    VULKAN_Buffer *uploadBuffer = &rendererData->uploadBuffers[rendererData->currentCommandBufferIndex][currentUploadBufferIndex];
+
+    rc = VULKAN_AllocateBuffer(rendererData, uploadBufferSize,
+        VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+        uploadBuffer);
+    if (rc != VK_SUCCESS) {
+        return false;
+    }
+
+    src = (const Uint8 *)pixels;
+    dst = (Uint8 *)uploadBuffer->mappedBufferPtr;
+    if (length == (VkDeviceSize)pitch) {
+        SDL_memcpy(dst, src, (size_t)length * h);
+    } else {
+        if (length > (VkDeviceSize)pitch) {
+            length = pitch;
+        }
+        for (VkDeviceSize row = h; row--; ) {
+            SDL_memcpy(dst, src, (size_t)length);
+            src += pitch;
+            dst += length;
+        }
+    }
+
+    // Make sure the destination is in the correct resource state
+    VULKAN_RecordPipelineImageBarrier(rendererData,
+        VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+        image,
+        imageLayout);
+
+    VkBufferImageCopy region;
+    region.bufferOffset = 0;
+    region.bufferRowLength = 0;
+    region.bufferImageHeight = 0;
+    region.imageSubresource.baseArrayLayer = 0;
+    region.imageSubresource.layerCount = 1;
+    region.imageSubresource.mipLevel = 0;
+    if (planeCount <= 1) {
+        region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    } else {
+        region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT << plane;
+    }
+    region.imageOffset.x = x;
+    region.imageOffset.y = y;
+    region.imageOffset.z = 0;
+    region.imageExtent.width = w;
+    region.imageExtent.height = h;
+    region.imageExtent.depth = 1;
+
+    vkCmdCopyBufferToImage(rendererData->currentCommandBuffer, uploadBuffer->buffer, image, *imageLayout, 1, &region);
+
+    // Transition the texture to be shader accessible
+    VULKAN_RecordPipelineImageBarrier(rendererData,
+        VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_ACCESS_SHADER_READ_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        image,
+        imageLayout);
+
+    rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex]++;
+
+    // If we've used up all the upload buffers, we need to issue the batch
+    if (rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex] == SDL_VULKAN_NUM_UPLOAD_BUFFERS) {
+        VULKAN_IssueBatch(rendererData);
+    }
+
+    return true;
+}
+
+
+static bool VULKAN_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                               const SDL_Rect *rect, const void *srcPixels,
+                               int srcPitch)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 0, rect->x, rect->y, rect->w, rect->h, srcPixels, srcPitch, &textureData->mainImage.imageLayout)) {
+        return false;
+    }
+#ifdef SDL_HAVE_YUV
+    Uint32 numPlanes = VULKAN_VkFormatGetNumPlanes(textureData->mainImage.format);
+    // Skip to the correct offset into the next texture
+    srcPixels = (const void *)((const Uint8 *)srcPixels + rect->h * srcPitch);
+    // YUV data
+    if (numPlanes == 3) {
+        for (Uint32 plane = 1; plane < numPlanes; plane++) {
+            if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, plane, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, srcPixels, (srcPitch + 1) / 2, &textureData->mainImage.imageLayout)) {
+                return false;
+            }
+
+            // Skip to the correct offset into the next texture
+            srcPixels = (const void *)((const Uint8 *)srcPixels + ((rect->h + 1) / 2) * ((srcPitch + 1) / 2));
+        }
+    }
+    // NV12/NV21 data
+    else if (numPlanes == 2)
+    {
+        if (texture->format == SDL_PIXELFORMAT_P010) {
+            srcPitch = (srcPitch + 3) & ~3;
+        } else {
+            srcPitch = (srcPitch + 1) & ~1;
+        }
+
+        if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 1, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, srcPixels, srcPitch, &textureData->mainImage.imageLayout)) {
+            return false;
+        }
+    }
+#endif
+    return true;
+}
+
+#ifdef SDL_HAVE_YUV
+static bool VULKAN_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                  const SDL_Rect *rect,
+                                  const Uint8 *Yplane, int Ypitch,
+                                  const Uint8 *Uplane, int Upitch,
+                                  const Uint8 *Vplane, int Vpitch)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 0, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch, &textureData->mainImage.imageLayout)) {
+        return false;
+    }
+    if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 1, rect->x / 2, rect->y / 2, rect->w / 2, rect->h / 2, Uplane, Upitch, &textureData->mainImage.imageLayout)) {
+        return false;
+    }
+    if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 2, rect->x / 2, rect->y / 2, rect->w / 2, rect->h / 2, Vplane, Vpitch, &textureData->mainImage.imageLayout)) {
+        return false;
+    }
+    return true;
+}
+
+static bool VULKAN_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
+                                 const SDL_Rect *rect,
+                                 const Uint8 *Yplane, int Ypitch,
+                                 const Uint8 *UVplane, int UVpitch)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 0, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch, &textureData->mainImage.imageLayout)) {
+        return false;
+    }
+
+    if (!VULKAN_UpdateTextureInternal(rendererData, textureData->mainImage.image, textureData->mainImage.format, 1, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, UVplane, UVpitch, &textureData->mainImage.imageLayout)) {
+        return false;
+    }
+    return true;
+}
+#endif
+
+static bool VULKAN_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
+                             const SDL_Rect *rect, void **pixels, int *pitch)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+    VkResult rc;
+    if (!textureData) {
+        return SDL_SetError("Texture is not currently available");
+    }
+
+    if (textureData->stagingBuffer.buffer != VK_NULL_HANDLE) {
+        return SDL_SetError("texture is already locked");
+    }
+
+    VkDeviceSize pixelSize = VULKAN_GetBytesPerPixel(textureData->mainImage.format);
+    VkDeviceSize length = rect->w * pixelSize;
+    VkDeviceSize stagingBufferSize = length * rect->h;
+    rc = VULKAN_AllocateBuffer(rendererData,
+        stagingBufferSize,
+        VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+        &textureData->stagingBuffer);
+    if (rc != VK_SUCCESS) {
+        return false;
+    }
+
+    /* Make note of where the staging texture will be written to
+     * (on a call to SDL_UnlockTexture):
+     */
+    textureData->lockedRect = *rect;
+
+    /* Make sure the caller has information on the texture's pixel buffer,
+     * then return:
+     */
+    *pixels = textureData->stagingBuffer.mappedBufferPtr;
+    *pitch = (int)length;
+    return true;
+
+}
+
+static void VULKAN_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+
+    VULKAN_EnsureCommandBuffer(rendererData);
+
+     // Make sure the destination is in the correct resource state
+    VULKAN_RecordPipelineImageBarrier(rendererData,
+        VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+        textureData->mainImage.image,
+        &textureData->mainImage.imageLayout);
+
+    VkBufferImageCopy region;
+    region.bufferOffset = 0;
+    region.bufferRowLength = 0;
+    region.bufferImageHeight = 0;
+    region.imageSubresource.baseArrayLayer = 0;
+    region.imageSubresource.layerCount = 1;
+    region.imageSubresource.mipLevel = 0;
+    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    region.imageOffset.x = textureData->lockedRect.x;
+    region.imageOffset.y = textureData->lockedRect.y;
+    region.imageOffset.z = 0;
+    region.imageExtent.width = textureData->lockedRect.w;
+    region.imageExtent.height = textureData->lockedRect.h;
+    region.imageExtent.depth = 1;
+    vkCmdCopyBufferToImage(rendererData->currentCommandBuffer, textureData->stagingBuffer.buffer, textureData->mainImage.image, textureData->mainImage.imageLayout, 1, &region);
+
+    // Transition the texture to be shader accessible
+    VULKAN_RecordPipelineImageBarrier(rendererData,
+        VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_ACCESS_SHADER_READ_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+        textureData->mainImage.image,
+        &textureData->mainImage.imageLayout);
+
+    // Execute the command list before releasing the staging buffer
+    VULKAN_IssueBatch(rendererData);
+
+    VULKAN_DestroyBuffer(rendererData, &textureData->stagingBuffer);
+}
+
+static void VULKAN_SetTextureScaleMode(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
+{
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (!textureData) {
+        return;
+    }
+
+    textureData->scaleMode = (scaleMode == SDL_SCALEMODE_NEAREST) ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
+}
+
+static bool VULKAN_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = NULL;
+
+    VULKAN_EnsureCommandBuffer(rendererData);
+
+    if (!texture) {
+        if (rendererData->textureRenderTarget) {
+
+            VULKAN_RecordPipelineImageBarrier(rendererData,
+                VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                VK_ACCESS_SHADER_READ_BIT,
+                VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                rendererData->textureRenderTarget->mainImage.image,
+                &rendererData->textureRenderTarget->mainImage.imageLayout);
+        }
+        rendererData->textureRenderTarget = NULL;
+        return true;
+    }
+
+    textureData = (VULKAN_TextureData *)texture->internal;
+
+    if (textureData->mainImage.imageView == VK_NULL_HANDLE) {
+        return SDL_SetError("specified texture is not a render target");
+    }
+
+    rendererData->textureRenderTarget = textureData;
+    VULKAN_RecordPipelineImageBarrier(rendererData,
+                VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                rendererData->textureRenderTarget->mainImage.image,
+                &rendererData->textureRenderTarget->mainImage.imageLayout);
+
+    return true;
+}
+
+static bool VULKAN_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
+{
+    return true; // nothing to do in this backend.
+}
+
+static bool VULKAN_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
+{
+    VULKAN_VertexPositionColor *verts = (VULKAN_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VULKAN_VertexPositionColor), 0, &cmd->data.draw.first);
+    int i;
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    for (i = 0; i < count; i++) {
+        verts->pos[0] = points[i].x + 0.5f;
+        verts->pos[1] = points[i].y + 0.5f;
+        verts->tex[0] = 0.0f;
+        verts->tex[1] = 0.0f;
+        verts->color = cmd->data.draw.color;
+        if (convert_color) {
+            SDL_ConvertToLinear(&verts->color);
+        }
+        verts++;
+    }
+    return true;
+}
+
+static bool VULKAN_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
+                               const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
+                               int num_vertices, const void *indices, int num_indices, int size_indices,
+                               float scale_x, float scale_y)
+{
+    int i;
+    int count = indices ? num_indices : num_vertices;
+    VULKAN_VertexPositionColor *verts = (VULKAN_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VULKAN_VertexPositionColor), 0, &cmd->data.draw.first);
+    bool convert_color = SDL_RenderingLinearSpace(renderer);
+    VULKAN_TextureData *textureData = texture ? (VULKAN_TextureData *)texture->internal : NULL;
+    float u_scale = textureData ? (float)texture->w / textureData->width : 0.0f;
+    float v_scale = textureData ? (float)texture->h / textureData->height : 0.0f;
+
+    if (!verts) {
+        return false;
+    }
+
+    cmd->data.draw.count = count;
+    size_indices = indices ? size_indices : 0;
+
+    for (i = 0; i < count; i++) {
+        int j;
+        float *xy_;
+        if (size_indices == 4) {
+            j = ((const Uint32 *)indices)[i];
+        } else if (size_indices == 2) {
+            j = ((const Uint16 *)indices)[i];
+        } else if (size_indices == 1) {
+            j = ((const Uint8 *)indices)[i];
+        } else {
+            j = i;
+        }
+
+        xy_ = (float *)((char *)xy + j * xy_stride);
+
+        verts->pos[0] = xy_[0] * scale_x;
+        verts->pos[1] = xy_[1] * scale_y;
+        verts->color = *(SDL_FColor *)((char *)color + j * color_stride);
+        if (convert_color) {
+            SDL_ConvertToLinear(&verts->color);
+        }
+
+        if (texture) {
+            float *uv_ = (float *)((char *)uv + j * uv_stride);
+            verts->tex[0] = uv_[0] * u_scale;
+            verts->tex[1] = uv_[1] * v_scale;
+        } else {
+            verts->tex[0] = 0.0f;
+            verts->tex[1] = 0.0f;
+        }
+
+        verts += 1;
+    }
+    return true;
+}
+
+static bool VULKAN_UpdateVertexBuffer(SDL_Renderer *renderer,
+                                    const void *vertexData, size_t dataSizeInBytes, VULKAN_DrawStateCache *stateCache)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    const int vbidx = rendererData->currentVertexBuffer;
+    VULKAN_Buffer *vertexBuffer;
+
+    if (dataSizeInBytes == 0) {
+        return true; // nothing to do.
+    }
+
+    if (rendererData->issueBatch) {
+        if (VULKAN_IssueBatch(rendererData) != VK_SUCCESS) {
+            return SDL_SetError("Failed to issue intermediate batch");
+        }
+    }
+    // If the existing vertex buffer isn't big enough, we need to recreate a big enough one
+    if (dataSizeInBytes > rendererData->vertexBuffers[vbidx].size) {
+        VULKAN_IssueBatch(rendererData);
+        VULKAN_WaitForGPU(rendererData);
+        VULKAN_CreateVertexBuffer(rendererData, vbidx, dataSizeInBytes);
+    }
+
+    vertexBuffer = &rendererData->vertexBuffers[vbidx];
+    SDL_memcpy(vertexBuffer->mappedBufferPtr, vertexData, dataSizeInBytes);
+
+    stateCache->vertexBuffer = vertexBuffer->buffer;
+
+    rendererData->currentVertexBuffer = vbidx + 1;
+    if (rendererData->currentVertexBuffer >= SDL_VULKAN_NUM_VERTEX_BUFFERS) {
+        rendererData->currentVertexBuffer = 0;
+        rendererData->issueBatch = true;
+    }
+
+    return true;
+}
+
+static VkSurfaceTransformFlagBitsKHR VULKAN_GetRotationForCurrentRenderTarget(VULKAN_RenderData *rendererData)
+{
+    if (rendererData->textureRenderTarget) {
+        return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    } else {
+        return rendererData->swapChainPreTransform;
+    }
+}
+
+static bool VULKAN_IsDisplayRotated90Degrees(VkSurfaceTransformFlagBitsKHR rotation)
+{
+    switch (rotation) {
+        case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
+        case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
+            return true;
+        default:
+            return false;
+    }
+}
+
+static bool VULKAN_UpdateViewport(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    const SDL_Rect *viewport = &rendererData->currentViewport;
+    Float4X4 projection;
+    Float4X4 view;
+    VkSurfaceTransformFlagBitsKHR rotation = VULKAN_GetRotationForCurrentRenderTarget(rendererData);
+    bool swapDimensions;
+
+    if (viewport->w == 0 || viewport->h == 0) {
+        /* If the viewport is empty, assume that it is because
+         * SDL_CreateRenderer is calling it, and will call it again later
+         * with a non-empty viewport.
+         */
+        // SDL_Log("%s, no viewport was set!", __FUNCTION__);
+        return false;
+    }
+
+    switch (rotation) {
+        case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
+            projection = MatrixRotationZ(SDL_PI_F * 0.5f);
+            break;
+        case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
+            projection = MatrixRotationZ(SDL_PI_F);
+            break;
+        case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
+            projection = MatrixRotationZ(-SDL_PI_F * 0.5f);
+            break;
+        case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
+        default:
+            projection = MatrixIdentity();
+            break;
+
+    }
+
+    // Update the view matrix
+    SDL_zero(view);
+    view.m[0][0] = 2.0f / viewport->w;
+    view.m[1][1] = -2.0f / viewport->h;
+    view.m[2][2] = 1.0f;
+    view.m[3][0] = -1.0f;
+    view.m[3][1] = 1.0f;
+    view.m[3][3] = 1.0f;
+
+    rendererData->vertexShaderConstantsData.projectionAndView = MatrixMultiply(
+        view,
+        projection);
+
+    VkViewport vkViewport;
+
+    swapDimensions = VULKAN_IsDisplayRotated90Degrees(rotation);
+    if (swapDimensions) {
+        vkViewport.x = viewport->y;
+        vkViewport.y = viewport->x;
+        vkViewport.width = viewport->h;
+        vkViewport.height = viewport->w;
+    }
+    else {
+        vkViewport.x = viewport->x;
+        vkViewport.y = viewport->y;
+        vkViewport.width = viewport->w;
+        vkViewport.height = viewport->h;
+    }
+    vkViewport.minDepth = 0.0f;
+    vkViewport.maxDepth = 1.0f;
+    vkCmdSetViewport(rendererData->currentCommandBuffer, 0, 1, &vkViewport);
+
+    rendererData->viewportDirty = false;
+    return true;
+}
+
+static bool VULKAN_UpdateClipRect(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    const SDL_Rect *viewport = &rendererData->currentViewport;
+    VkSurfaceTransformFlagBitsKHR rotation = VULKAN_GetRotationForCurrentRenderTarget(rendererData);
+    bool swapDimensions = VULKAN_IsDisplayRotated90Degrees(rotation);
+
+    VkRect2D scissor;
+    if (rendererData->currentCliprectEnabled) {
+        scissor.offset.x = viewport->x + rendererData->currentCliprect.x;
+        scissor.offset.y = viewport->y + rendererData->currentCliprect.y;
+        scissor.extent.width = rendererData->currentCliprect.w;
+        scissor.extent.height = rendererData->currentCliprect.h;
+    } else {
+        scissor.offset.x = viewport->x;
+        scissor.offset.y = viewport->y;
+        scissor.extent.width = viewport->w;
+        scissor.extent.height = viewport->h;
+    }
+    if (swapDimensions) {
+        VkRect2D scissorTemp = scissor;
+        scissor.offset.x = scissorTemp.offset.y;
+        scissor.offset.y = scissorTemp.offset.x;
+        scissor.extent.width = scissorTemp.extent.height;
+        scissor.extent.height = scissorTemp.extent.width;
+    }
+    vkCmdSetScissor(rendererData->currentCommandBuffer, 0, 1, &scissor);
+
+    rendererData->cliprectDirty = false;
+    return true;
+}
+
+static void VULKAN_SetupShaderConstants(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Texture *texture, VULKAN_PixelShaderConstants *constants)
+{
+    float output_headroom;
+
+    SDL_zerop(constants);
+
+    constants->scRGB_output = (float)SDL_RenderingLinearSpace(renderer);
+    constants->color_scale = cmd->data.draw.color_scale;
+
+    if (texture) {
+        switch (texture->format) {
+        case SDL_PIXELFORMAT_YV12:
+        case SDL_PIXELFORMAT_IYUV:
+        case SDL_PIXELFORMAT_NV12:
+        case SDL_PIXELFORMAT_NV21:
+            constants->input_type = INPUTTYPE_SRGB;
+            break;
+        case SDL_PIXELFORMAT_P010:
+            constants->input_type = INPUTTYPE_HDR10;
+            break;
+        default:
+            if (texture->colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
+                constants->input_type = INPUTTYPE_SCRGB;
+            } else if (SDL_COLORSPACEPRIMARIES(texture->colorspace) == SDL_COLOR_PRIMARIES_BT2020 &&
+                       SDL_COLORSPACETRANSFER(texture->colorspace) == SDL_TRANSFER_CHARACTERISTICS_PQ) {
+                constants->input_type = INPUTTYPE_HDR10;
+            } else {
+                // The sampler will convert from sRGB to linear on load if working in linear colorspace
+                constants->input_type = INPUTTYPE_UNSPECIFIED;
+            }
+            break;
+        }
+
+        constants->sdr_white_point = texture->SDR_white_point;
+
+        if (renderer->target) {
+            output_headroom = renderer->target->HDR_headroom;
+        } else {
+            output_headroom = renderer->HDR_headroom;
+        }
+
+        if (texture->HDR_headroom > output_headroom) {
+            constants->tonemap_method = TONEMAP_CHROME;
+            constants->tonemap_factor1 = (output_headroom / (texture->HDR_headroom * texture->HDR_headroom));
+            constants->tonemap_factor2 = (1.0f / output_headroom);
+        }
+    }
+}
+
+static VkDescriptorPool VULKAN_AllocateDescriptorPool(VULKAN_RenderData *rendererData)
+{
+    VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
+    VkDescriptorPoolSize descriptorPoolSizes[3];
+    VkResult result;
+    descriptorPoolSizes[0].descriptorCount = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
+    descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_SAMPLER;
+
+    descriptorPoolSizes[1].descriptorCount = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
+    descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+
+    descriptorPoolSizes[2].descriptorCount = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
+    descriptorPoolSizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+
+    VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = { 0 };
+    descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+    descriptorPoolCreateInfo.poolSizeCount = SDL_arraysize(descriptorPoolSizes);
+    descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes;
+    descriptorPoolCreateInfo.maxSets = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
+    result = vkCreateDescriptorPool(rendererData->device, &descriptorPoolCreateInfo, NULL, &descriptorPool);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateDescrptorPool()", result);
+        return VK_NULL_HANDLE;
+    }
+
+    return descriptorPool;
+}
+
+static VkResult VULKAN_CreateDescriptorSetAndPipelineLayout(VULKAN_RenderData *rendererData, VkSampler samplerYcbcr, VkDescriptorSetLayout *descriptorSetLayoutOut,
+    VkPipelineLayout *pipelineLayoutOut)
+{
+    VkResult result;
+
+    // Descriptor set layout
+    VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = { 0 };
+    descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    descriptorSetLayoutCreateInfo.flags = 0;
+    VkDescriptorSetLayoutBinding layoutBindings[2];
+    // PixelShaderConstants
+    layoutBindings[0].binding = 1;
+    layoutBindings[0].descriptorCount = 1;
+    layoutBindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+    layoutBindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+    layoutBindings[0].pImmutableSamplers = NULL;
+
+    // Combined image/sampler
+    layoutBindings[1].binding = 0;
+    layoutBindings[1].descriptorCount = 1;
+    layoutBindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    layoutBindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+    layoutBindings[1].pImmutableSamplers = (samplerYcbcr != VK_NULL_HANDLE) ? &samplerYcbcr : NULL;
+
+    descriptorSetLayoutCreateInfo.bindingCount = 2;
+    descriptorSetLayoutCreateInfo.pBindings = layoutBindings;
+    result = vkCreateDescriptorSetLayout(rendererData->device, &descriptorSetLayoutCreateInfo, NULL, descriptorSetLayoutOut);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreateDescriptorSetLayout()", result);
+        return result;
+    }
+
+    // Pipeline layout
+    VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { 0 };
+    VkPushConstantRange pushConstantRange;
+    pushConstantRange.size = sizeof( VULKAN_VertexShaderConstants );
+    pushConstantRange.offset = 0;
+    pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+    pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    pipelineLayoutCreateInfo.setLayoutCount = 1;
+    pipelineLayoutCreateInfo.pSetLayouts = descriptorSetLayoutOut;
+    pipelineLayoutCreateInfo.pushConstantRangeCount = 1;
+    pipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;
+    result = vkCreatePipelineLayout(rendererData->device, &pipelineLayoutCreateInfo, NULL, pipelineLayoutOut);
+    if (result != VK_SUCCESS) {
+        SET_ERROR_CODE("vkCreatePipelineLayout()", result);
+        return result;
+    }
+
+    return result;
+}
+
+static VkDescriptorSet VULKAN_AllocateDescriptorSet(SDL_Renderer *renderer, VULKAN_Shader shader, VkDescriptorSetLayout descriptorSetLayout,
+    VkSampler sampler, VkBuffer constantBuffer, VkDeviceSize constantBufferOffset, VkImageView imageView)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    uint32_t currentDescriptorPoolIndex = rendererData->currentDescriptorPoolIndex;
+    VkDescriptorPool descriptorPool = rendererData->descriptorPools[rendererData->currentCommandBufferIndex][currentDescriptorPoolIndex];
+
+    VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = { 0 };
+    descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    descriptorSetAllocateInfo.descriptorSetCount = 1;
+    descriptorSetAllocateInfo.descriptorPool = descriptorPool;
+    descriptorSetAllocateInfo.pSetLayouts = &descriptorSetLayout;
+
+    VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
+    VkResult result = (rendererData->currentDescriptorSetIndex >= SDL_VULKAN_MAX_DESCRIPTOR_SETS) ? VK_ERROR_OUT_OF_DEVICE_MEMORY : VK_SUCCESS;
+    if (result == VK_SUCCESS) {
+        result = vkAllocateDescriptorSets(rendererData->device, &descriptorSetAllocateInfo, &descriptorSet);
+    }
+    if (result != VK_SUCCESS) {
+        // Out of descriptor sets in this pool - see if we have more pools allocated
+        currentDescriptorPoolIndex++;
+        if (currentDescriptorPoolIndex < rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]) {
+            descriptorPool = rendererData->descriptorPools[rendererData->currentCommandBufferIndex][currentDescriptorPoolIndex];
+            descriptorSetAllocateInfo.descriptorPool = descriptorPool;
+            result = vkAllocateDescriptorSets(rendererData->device, &descriptorSetAllocateInfo, &descriptorSet);
+            if (result != VK_SUCCESS) {
+                // This should not fail - we are allocating from the front of the descriptor set
+                SDL_SetError("Unable to allocate descriptor set");
+                return VK_NULL_HANDLE;
+            }
+            rendererData->currentDescriptorPoolIndex = currentDescriptorPoolIndex;
+            rendererData->currentDescriptorSetIndex = 0;
+
+        }
+        // We are out of pools, create a new one
+        else {
+            descriptorPool = VULKAN_AllocateDescriptorPool(rendererData);
+            if (descriptorPool == VK_NULL_HANDLE) {
+                // SDL_SetError called in VULKAN_AllocateDescriptorPool if we failed to allocate a new pool
+                return VK_NULL_HANDLE;
+            }
+            rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]++;
+            VkDescriptorPool *descriptorPools = (VkDescriptorPool *)SDL_realloc(rendererData->descriptorPools[rendererData->currentCommandBufferIndex],
+                                                            sizeof(VkDescriptorPool) * rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]);
+            descriptorPools[rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex] - 1] = descriptorPool;
+            rendererData->descriptorPools[rendererData->currentCommandBufferIndex] = descriptorPools;
+            rendererData->currentDescriptorPoolIndex = currentDescriptorPoolIndex;
+            rendererData->currentDescriptorSetIndex = 0;
+
+            // Call recursively to allocate from the new pool
+            return VULKAN_AllocateDescriptorSet(renderer, shader, descriptorSetLayout, sampler, constantBuffer, constantBufferOffset, imageView);
+        }
+    }
+    rendererData->currentDescriptorSetIndex++;
+    VkDescriptorImageInfo combinedImageSamplerDescriptor = { 0 };
+    VkDescriptorBufferInfo bufferDescriptor = { 0 };
+    bufferDescriptor.buffer = constantBuffer;
+    bufferDescriptor.offset = constantBufferOffset;
+    bufferDescriptor.range = sizeof(VULKAN_PixelShaderConstants);
+
+    VkWriteDescriptorSet descriptorWrites[2];
+    SDL_memset(descriptorWrites, 0, sizeof(descriptorWrites));
+    uint32_t descriptorCount = 1; // Always have the uniform buffer
+
+    descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptorWrites[0].dstSet = descriptorSet;
+    descriptorWrites[0].dstBinding = 1;
+    descriptorWrites[0].dstArrayElement = 0;
+    descriptorWrites[0].descriptorCount = 1;
+    descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+    descriptorWrites[0].pBufferInfo = &bufferDescriptor;
+
+    if (sampler != VK_NULL_HANDLE && imageView != VK_NULL_HANDLE) {
+        descriptorCount++;
+        descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        descriptorWrites[1].dstSet = descriptorSet;
+        descriptorWrites[1].dstBinding = 0;
+        descriptorWrites[1].dstArrayElement = 0;
+        descriptorWrites[1].descriptorCount = 1;
+        descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+        descriptorWrites[1].pImageInfo = &combinedImageSamplerDescriptor;
+
+        // Ignore the sampler if we're using YcBcCr data since it will be baked in the descriptor set layout
+        if (descriptorSetLayout == rendererData->descriptorSetLayout) {
+            combinedImageSamplerDescriptor.sampler = sampler;
+        }
+        combinedImageSamplerDescriptor.imageView = imageView;
+        combinedImageSamplerDescriptor.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    }
+
+    vkUpdateDescriptorSets(rendererData->device, descriptorCount, descriptorWrites, 0, NULL);
+
+    return descriptorSet;
+}
+
+static bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, VULKAN_Shader shader, VkPipelineLayout pipelineLayout, VkDescriptorSetLayout descriptorSetLayout,
+    const VULKAN_PixelShaderConstants *shader_constants, VkPrimitiveTopology topology, VkImageView imageView, VkSampler sampler, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)
+
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    const SDL_BlendMode blendMode = cmd->data.draw.blend;
+    VkFormat format = rendererData->surfaceFormat.format;
+    const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
+    bool updateConstants = false;
+    VULKAN_PixelShaderConstants solid_constants;
+    VkDescriptorSet descriptorSet;
+    VkBuffer constantBuffer;
+    VkDeviceSize constantBufferOffset;
+    int i;
+
+    if (!VULKAN_ActivateCommandBuffer(renderer, VK_ATTACHMENT_LOAD_OP_LOAD, NULL, stateCache)) {
+        return false;
+    }
+
+    // See if we need to change the pipeline state
+    if (!rendererData->currentPipelineState ||
+        rendererData->currentPipelineState->shader != shader ||
+        rendererData->currentPipelineState->blendMode != blendMode ||
+        rendererData->currentPipelineState->topology != topology ||
+        rendererData->currentPipelineState->format != format ||
+        rendererData->currentPipelineState->pipelineLayout != pipelineLayout ||
+        rendererData->currentPipelineState->descriptorSetLayout != descriptorSetLayout) {
+
+        rendererData->currentPipelineState = NULL;
+        for (i = 0; i < rendererData->pipelineStateCount; ++i) {
+            VULKAN_PipelineState *candidatePiplineState = &rendererData->pipelineStates[i];
+            if (candidatePiplineState->shader == shader &&
+                candidatePiplineState->blendMode == blendMode &&
+                candidatePiplineState->topology == topology &&
+                candidatePiplineState->format == format &&
+                candidatePiplineState->pipelineLayout == pipelineLayout &&
+                candidatePiplineState->descriptorSetLayout == descriptorSetLayout) {
+                rendererData->currentPipelineState = candidatePiplineState;
+                break;
+            }
+        }
+
+        // If we didn't find a match, create a new one -- it must mean the blend mode is non-standard
+        if (!rendererData->currentPipelineState) {
+            rendererData->currentPipelineState = VULKAN_CreatePipelineState(renderer, shader, pipelineLayout, descriptorSetLayout, blendMode, topology, format);
+        }
+
+        if (!rendererData->currentPipelineState) {
+            return SDL_SetError("Unable to create required pipeline state");
+        }
+
+        vkCmdBindPipeline(rendererData->currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, rendererData->currentPipelineState->pipeline);
+        updateConstants = true;
+    }
+
+    if (rendererData->viewportDirty) {
+        if (VULKAN_UpdateViewport(renderer)) {
+            // vertexShaderConstantsData.projectionAndView has changed
+            updateConstants = true;
+        }
+    }
+
+    if (rendererData->cliprectDirty) {
+        VULKAN_UpdateClipRect(renderer);
+    }
+
+    if (updateConstants == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
+        SDL_memcpy(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix));
+        vkCmdPushConstants(rendererData->currentCommandBuffer, rendererData->currentPipelineState->pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0,
+            sizeof(rendererData->vertexShaderConstantsData),
+            &rendererData->vertexShaderConstantsData);
+    }
+
+    if (!shader_constants) {
+        VULKAN_SetupShaderConstants(renderer, cmd, NULL, &solid_constants);
+        shader_constants = &solid_constants;
+    }
+
+    constantBuffer = rendererData->constantBuffers[rendererData->currentCommandBufferIndex][rendererData->currentConstantBufferIndex].buffer;
+    constantBufferOffset = (rendererData->currentConstantBufferOffset < 0) ? 0 : rendererData->currentConstantBufferOffset;
+    if (updateConstants ||
+        SDL_memcmp(shader_constants, &rendererData->currentPipelineState->shader_constants, sizeof(*shader_constants)) != 0) {
+
+        if (rendererData->currentConstantBufferOffset == -1) {
+            // First time, grab offset 0
+            rendererData->currentConstantBufferOffset = 0;
+            constantBufferOffset = 0;
+        }
+        else {
+            // Align the next address to the minUniformBufferOffsetAlignment
+            VkDeviceSize alignment = rendererData->physicalDeviceProperties.limits.minUniformBufferOffsetAlignment;
+            SDL_assert(rendererData->currentConstantBufferOffset >= 0 );
+            rendererData->currentConstantBufferOffset += (int32_t)(sizeof(VULKAN_PixelShaderConstants) + alignment - 1) & ~(alignment - 1);
+            constantBufferOffset = rendererData->currentConstantBufferOffset;
+        }
+
+        // If we have run out of size in this constant buffer, create another if needed
+        if (rendererData->currentConstantBufferOffset >= SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE) {
+            uint32_t newConstantBufferIndex = (rendererData->currentConstantBufferIndex + 1);
+            // We need a new constant buffer
+            if (newConstantBufferIndex >= rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]) {
+                VULKAN_Buffer newConstantBuffer;
+                VkResult result = VULKAN_AllocateBuffer(rendererData,
+                    SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE,
+                    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+                    &newConstantBuffer);
+                if (result != VK_SUCCESS) {
+                    return false;
+                }
+
+                rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]++;
+                VULKAN_Buffer *newConstantBuffers = (VULKAN_Buffer *)SDL_realloc(rendererData->constantBuffers[rendererData->currentCommandBufferIndex],
+                                                                sizeof(VULKAN_Buffer) * rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]);
+                newConstantBuffers[rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex] - 1] = newConstantBuffer;
+                rendererData->constantBuffers[rendererData->currentCommandBufferIndex] = newConstantBuffers;
+            }
+            rendererData->currentConstantBufferIndex = newConstantBufferIndex;
+            rendererData->currentConstantBufferOffset = 0;
+            constantBufferOffset = 0;
+            constantBuffer = rendererData->constantBuffers[rendererData->currentCommandBufferIndex][rendererData->currentConstantBufferIndex].buffer;
+        }
+
+        SDL_memcpy(&rendererData->currentPipelineState->shader_constants, shader_constants, sizeof(*shader_constants));
+
+        // Upload constants to persistently mapped buffer
+        uint8_t *dst = (uint8_t *)rendererData->constantBuffers[rendererData->currentCommandBufferIndex][rendererData->currentConstantBufferIndex].mappedBufferPtr;
+        dst += constantBufferOffset;
+        SDL_memcpy(dst, &rendererData->currentPipelineState->shader_constants, sizeof(VULKAN_PixelShaderConstants));
+    }
+
+    // Allocate/update descriptor set with the bindings
+    descriptorSet = VULKAN_AllocateDescriptorSet(renderer, shader, descriptorSetLayout, sampler, constantBuffer, constantBufferOffset, imageView);
+    if (descriptorSet == VK_NULL_HANDLE) {
+        return false;
+    }
+
+    // Bind the descriptor set with the sampler/UBO/image views
+    vkCmdBindDescriptorSets(rendererData->currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, rendererData->currentPipelineState->pipelineLayout,
+            0, 1, &descriptorSet, 0, NULL);
+
+    return true;
+}
+
+
+static bool VULKAN_SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)
+{
+    SDL_Texture *texture = cmd->data.draw.texture;
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
+    VkSampler textureSampler = VK_NULL_HANDLE;
+    VULKAN_PixelShaderConstants constants;
+    VkDescriptorSetLayout descriptorSetLayout = (textureData->descriptorSetLayoutYcbcr != VK_NULL_HANDLE) ? textureData->descriptorSetLayoutYcbcr : rendererData->descriptorSetLayout;
+    VkPipelineLayout pipelineLayout = (textureData->pipelineLayoutYcbcr != VK_NULL_HANDLE) ? textureData->pipelineLayoutYcbcr : rendererData->pipelineLayout;
+
+    VULKAN_SetupShaderConstants(renderer, cmd, texture, &constants);
+
+    switch (textureData->scaleMode) {
+    case VK_FILTER_NEAREST:
+        switch (cmd->data.draw.texture_address_mode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            textureSampler = rendererData->samplers[VULKAN_SAMPLER_NEAREST_CLAMP];
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            textureSampler = rendererData->samplers[VULKAN_SAMPLER_NEAREST_WRAP];
+            break;
+        default:
+            return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+        }
+        break;
+    case VK_FILTER_LINEAR:
+        switch (cmd->data.draw.texture_address_mode) {
+        case SDL_TEXTURE_ADDRESS_CLAMP:
+            textureSampler = rendererData->samplers[VULKAN_SAMPLER_LINEAR_CLAMP];
+            break;
+        case SDL_TEXTURE_ADDRESS_WRAP:
+            textureSampler = rendererData->samplers[VULKAN_SAMPLER_LINEAR_WRAP];
+            break;
+        default:
+            return SDL_SetError("Unknown texture address mode: %d", cmd->data.draw.texture_address_mode);
+        }
+        break;
+    default:
+        return SDL_SetError("Unknown scale mode: %d", textureData->scaleMode);
+    }
+
+    if (textureData->mainImage.imageLayout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
+        bool stoppedRenderPass = false;
+        if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
+            vkCmdEndRenderPass(rendererData->currentCommandBuffer);
+            rendererData->currentRenderPass = VK_NULL_HANDLE;
+            stoppedRenderPass = true;
+        }
+
+        VULKAN_RecordPipelineImageBarrier(rendererData,
+            VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+            VK_ACCESS_SHADER_READ_BIT,
+            VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+            textureData->mainImage.image,
+            &textureData->mainImage.imageLayout);
+
+        if (stoppedRenderPass) {
+            VULKAN_BeginRenderPass(rendererData, VK_ATTACHMENT_LOAD_OP_LOAD, NULL);
+        }
+    }
+
+    return VULKAN_SetDrawState(renderer, cmd, textureData->shader, pipelineLayout, descriptorSetLayout, &constants, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, textureData->mainImage.imageView, textureSampler, matrix, stateCache);
+}
+
+static void VULKAN_DrawPrimitives(SDL_Renderer *renderer, VkPrimitiveTopology primitiveTopology, const size_t vertexStart, const size_t vertexCount)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    vkCmdDraw(rendererData->currentCommandBuffer, (uint32_t)vertexCount, 1, (uint32_t)vertexStart, 0);
+}
+
+static void VULKAN_InvalidateCachedState(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    rendererData->currentPipelineState = NULL;
+    rendererData->cliprectDirty = true;
+}
+
+static bool VULKAN_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VkSurfaceTransformFlagBitsKHR currentRotation = VULKAN_GetRotationForCurrentRenderTarget(rendererData);
+    VULKAN_DrawStateCache stateCache;
+    SDL_memset(&stateCache, 0, sizeof(stateCache));
+
+    if (!rendererData->device) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if(rendererData->currentViewportRotation != currentRotation) {
+        rendererData->currentViewportRotation = currentRotation;
+        rendererData->viewportDirty = true;
+        rendererData->cliprectDirty = true;
+    }
+
+    if (rendererData->recreateSwapchain) {
+        if (VULKAN_UpdateForWindowSizeChange(renderer) != VK_SUCCESS) {
+            return false;
+        }
+        rendererData->recreateSwapchain = false;
+    }
+
+    if (!VULKAN_UpdateVertexBuffer(renderer, vertices, vertsize, &stateCache)) {
+        return false;
+    }
+
+    while (cmd) {
+        switch (cmd->command) {
+        case SDL_RENDERCMD_SETDRAWCOLOR:
+        {
+            break; // this isn't currently used in this render backend.
+        }
+
+        case SDL_RENDERCMD_SETVIEWPORT:
+        {
+            SDL_Rect *viewport = &rendererData->currentViewport;
+            if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
+                SDL_copyp(viewport, &cmd->data.viewport.rect);
+                rendererData->viewportDirty = true;
+                rendererData->cliprectDirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_SETCLIPRECT:
+        {
+            const SDL_Rect *rect = &cmd->data.cliprect.rect;
+            if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
+                rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
+                rendererData->cliprectDirty = true;
+            }
+            if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
+                SDL_copyp(&rendererData->currentCliprect, rect);
+                rendererData->cliprectDirty = true;
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_CLEAR:
+        {
+            bool convert_color = SDL_RenderingLinearSpace(renderer);
+            SDL_FColor color = cmd->data.color.color;
+            if (convert_color) {
+                SDL_ConvertToLinear(&color);
+            }
+            color.r *= cmd->data.color.color_scale;
+            color.g *= cmd->data.color.color_scale;
+            color.b *= cmd->data.color.color_scale;
+
+            VkClearColorValue clearColor;
+            clearColor.float32[0] = color.r;
+            clearColor.float32[1] = color.g;
+            clearColor.float32[2] = color.b;
+            clearColor.float32[3] = color.a;
+            VULKAN_ActivateCommandBuffer(renderer, VK_ATTACHMENT_LOAD_OP_CLEAR, &clearColor, &stateCache);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_POINTS:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(VULKAN_VertexPositionColor);
+            VULKAN_SetDrawState(renderer, cmd, SHADER_SOLID, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, &stateCache);
+            VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, start, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_DRAW_LINES:
+        {
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(VULKAN_VertexPositionColor);
+            const VULKAN_VertexPositionColor *verts = (VULKAN_VertexPositionColor *)(((Uint8 *)vertices) + first);
+            VULKAN_SetDrawState(renderer, cmd, SHADER_SOLID, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, &stateCache);
+            VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, start, count);
+            if (verts[0].pos[0] != verts[count - 1].pos[0] || verts[0].pos[1] != verts[count - 1].pos[1]) {
+                VULKAN_SetDrawState(renderer, cmd, SHADER_SOLID, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, &stateCache);
+                VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, start + (count - 1), 1);
+            }
+            break;
+        }
+
+        case SDL_RENDERCMD_FILL_RECTS: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY: // unused
+            break;
+
+        case SDL_RENDERCMD_COPY_EX: // unused
+            break;
+
+        case SDL_RENDERCMD_GEOMETRY:
+        {
+            SDL_Texture *texture = cmd->data.draw.texture;
+            const size_t count = cmd->data.draw.count;
+            const size_t first = cmd->data.draw.first;
+            const size_t start = first / sizeof(VULKAN_VertexPositionColor);
+
+            if (texture) {
+                VULKAN_SetCopyState(renderer, cmd, NULL, &stateCache);
+            } else {
+                VULKAN_SetDrawState(renderer, cmd, SHADER_SOLID, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_NULL_HANDLE, VK_NULL_HANDLE, NULL, &stateCache);
+            }
+
+            VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, start, count);
+            break;
+        }
+
+        case SDL_RENDERCMD_NO_OP:
+            break;
+        }
+
+        cmd = cmd->next;
+    }
+    return true;
+}
+
+static SDL_Surface* VULKAN_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VkImage backBuffer;
+    VkImageLayout *imageLayout;
+    VULKAN_Buffer readbackBuffer;
+    VkDeviceSize pixelSize;
+    VkDeviceSize length;
+    VkDeviceSize readbackBufferSize;
+    VkFormat vkFormat;
+    SDL_Surface *output;
+
+    VULKAN_EnsureCommandBuffer(rendererData);
+
+    // Stop any outstanding renderpass if open
+    if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
+        vkCmdEndRenderPass(rendererData->currentCommandBuffer);
+        rendererData->currentRenderPass = VK_NULL_HANDLE;
+    }
+
+    if (rendererData->textureRenderTarget) {
+        backBuffer = rendererData->textureRenderTarget->mainImage.image;
+        imageLayout = &rendererData->textureRenderTarget->mainImage.imageLayout;
+        vkFormat = rendererData->textureRenderTarget->mainImage.format;
+    } else {
+        backBuffer = rendererData->swapchainImages[rendererData->currentSwapchainImageIndex];
+        imageLayout = &rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex];
+        vkFormat = rendererData->surfaceFormat.format;
+    }
+
+    pixelSize = VULKAN_GetBytesPerPixel(vkFormat);
+    length = rect->w * pixelSize;
+    readbackBufferSize = length * rect->h;
+    if (VULKAN_AllocateBuffer(rendererData, readbackBufferSize,
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+        &readbackBuffer) != VK_SUCCESS) {
+        return NULL;
+    }
+
+
+    // Make sure the source is in the correct resource state
+    VULKAN_RecordPipelineImageBarrier(rendererData,
+        VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_ACCESS_TRANSFER_READ_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+        backBuffer,
+        imageLayout);
+
+    // Copy the image to the readback buffer
+    VkBufferImageCopy region;
+    region.bufferOffset = 0;
+    region.bufferRowLength = 0;
+    region.bufferImageHeight = 0;
+    region.imageSubresource.baseArrayLayer = 0;
+    region.imageSubresource.layerCount = 1;
+    region.imageSubresource.mipLevel = 0;
+    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    region.imageOffset.x = rect->x;
+    region.imageOffset.y = rect->y;
+    region.imageOffset.z = 0;
+    region.imageExtent.width = rect->w;
+    region.imageExtent.height = rect->h;
+    region.imageExtent.depth = 1;
+    vkCmdCopyImageToBuffer(rendererData->currentCommandBuffer, backBuffer, *imageLayout, readbackBuffer.buffer, 1, &region);
+
+    // We need to issue the command list for the copy to finish
+    VULKAN_IssueBatch(rendererData);
+
+    // Transition the render target back to a render target
+     VULKAN_RecordPipelineImageBarrier(rendererData,
+        VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT,
+        VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        backBuffer,
+        imageLayout);
+
+    output = SDL_DuplicatePixels(
+        rect->w, rect->h,
+        VULKAN_VkFormatToSDLPixelFormat(vkFormat),
+        renderer->target ? renderer->target->colorspace : renderer->output_colorspace,
+        readbackBuffer.mappedBufferPtr,
+        (int)length);
+
+    VULKAN_DestroyBuffer(rendererData, &readbackBuffer);
+
+    return output;
+}
+
+static bool VULKAN_AddVulkanRenderSemaphores(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+
+    if (wait_semaphore) {
+        if (rendererData->waitRenderSemaphoreCount == rendererData->waitRenderSemaphoreMax) {
+            // Allocate an additional one at the end for the normal present wait
+            VkPipelineStageFlags *waitDestStageMasks = (VkPipelineStageFlags *)SDL_realloc(rendererData->waitDestStageMasks, (rendererData->waitRenderSemaphoreMax + 2) * sizeof(*waitDestStageMasks));
+            if (!waitDestStageMasks) {
+                return false;
+            }
+            rendererData->waitDestStageMasks = waitDestStageMasks;
+
+            VkSemaphore *semaphores = (VkSemaphore *)SDL_realloc(rendererData->waitRenderSemaphores, (rendererData->waitRenderSemaphoreMax + 2) * sizeof(*semaphores));
+            if (!semaphores) {
+                return false;
+            }
+            rendererData->waitRenderSemaphores = semaphores;
+            ++rendererData->waitRenderSemaphoreMax;
+        }
+        rendererData->waitDestStageMasks[rendererData->waitRenderSemaphoreCount] = wait_stage_mask;
+        rendererData->waitRenderSemaphores[rendererData->waitRenderSemaphoreCount] = (VkSemaphore)wait_semaphore;
+        ++rendererData->waitRenderSemaphoreCount;
+    }
+
+    if (signal_semaphore) {
+        if (rendererData->signalRenderSemaphoreCount == rendererData->signalRenderSemaphoreMax) {
+            // Allocate an additional one at the end for the normal present signal
+            VkSemaphore *semaphores = (VkSemaphore *)SDL_realloc(rendererData->signalRenderSemaphores, (rendererData->signalRenderSemaphoreMax + 2) * sizeof(*semaphores));
+            if (!semaphores) {
+                return false;
+            }
+            rendererData->signalRenderSemaphores = semaphores;
+            ++rendererData->signalRenderSemaphoreMax;
+        }
+        rendererData->signalRenderSemaphores[rendererData->signalRenderSemaphoreCount] = (VkSemaphore)signal_semaphore;
+        ++rendererData->signalRenderSemaphoreCount;
+    }
+
+    return true;
+}
+
+static bool VULKAN_RenderPresent(SDL_Renderer *renderer)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+    VkResult result = VK_SUCCESS;
+
+    if (!rendererData->device) {
+        return SDL_SetError("Device lost and couldn't be recovered");
+    }
+
+    if (rendererData->currentCommandBuffer) {
+        rendererData->currentPipelineState = VK_NULL_HANDLE;
+        rendererData->viewportDirty = true;
+
+        VULKAN_RecordPipelineImageBarrier(rendererData,
+            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+            VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+            VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+            rendererData->swapchainImages[rendererData->currentSwapchainImageIndex],
+            &rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex]);
+
+        vkEndCommandBuffer(rendererData->currentCommandBuffer);
+
+        result = vkResetFences(rendererData->device, 1, &rendererData->fences[rendererData->currentCommandBufferIndex]);
+        if (result != VK_SUCCESS) {
+            SET_ERROR_CODE("vkResetFences()", result);
+            return false;
+        }
+
+        VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+        VkSubmitInfo submitInfo = { 0 };
+        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+        if (rendererData->waitRenderSemaphoreCount > 0) {
+            Uint32 additionalSemaphoreCount = (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) ? 1 : 0;
+            submitInfo.waitSemaphoreCount = rendererData->waitRenderSemaphoreCount + additionalSemaphoreCount;
+            if (additionalSemaphoreCount > 0) {
+                rendererData->waitRenderSemaphores[rendererData->waitRenderSemaphoreCount] = rendererData->currentImageAvailableSemaphore;
+                rendererData->waitDestStageMasks[rendererData->waitRenderSemaphoreCount] = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+            }
+            submitInfo.pWaitSemaphores = rendererData->waitRenderSemaphores;
+            submitInfo.pWaitDstStageMask = rendererData->waitDestStageMasks;
+            rendererData->waitRenderSemaphoreCount = 0;
+        } else if (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) {
+            submitInfo.waitSemaphoreCount = 1;
+            submitInfo.pWaitSemaphores = &rendererData->currentImageAvailableSemaphore;
+            submitInfo.pWaitDstStageMask = &waitDestStageMask;
+        }
+        submitInfo.commandBufferCount = 1;
+        submitInfo.pCommandBuffers = &rendererData->currentCommandBuffer;
+        if (rendererData->signalRenderSemaphoreCount > 0) {
+            submitInfo.signalSemaphoreCount = rendererData->signalRenderSemaphoreCount + 1;
+            rendererData->signalRenderSemaphores[rendererData->signalRenderSemaphoreCount] = rendererData->renderingFinishedSemaphores[rendererData->currentCommandBufferIndex];
+            submitInfo.pSignalSemaphores = rendererData->signalRenderSemaphores;
+            rendererData->signalRenderSemaphoreCount = 0;
+        } else {
+            submitInfo.signalSemaphoreCount = 1;
+            submitInfo.pSignalSemaphores = &rendererData->renderingFinishedSemaphores[rendererData->currentCommandBufferIndex];
+        }
+        result = vkQueueSubmit(rendererData->graphicsQueue, 1, &submitInfo, rendererData->fences[rendererData->currentCommandBufferIndex]);
+        if (result != VK_SUCCESS) {
+            if (result == VK_ERROR_DEVICE_LOST) {
+                if (VULKAN_HandleDeviceLost(renderer)) {
+                    SDL_SetError("Present failed, device lost");
+                } else {
+                    // Recovering from device lost failed, error is already set
+                }
+            } else {
+                SET_ERROR_CODE("vkQueueSubmit()", result);
+            }
+            return false;
+        }
+        rendererData->currentCommandBuffer = VK_NULL_HANDLE;
+        rendererData->currentImageAvailableSemaphore = VK_NULL_HANDLE;
+
+        VkPresentInfoKHR presentInfo = { 0 };
+        presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+        presentInfo.waitSemaphoreCount = 1;
+        presentInfo.pWaitSemaphores = &rendererData->renderingFinishedSemaphores[rendererData->currentCommandBufferIndex];
+        presentInfo.swapchainCount = 1;
+        presentInfo.pSwapchains = &rendererData->swapchain;
+        presentInfo.pImageIndices = &rendererData->currentSwapchainImageIndex;
+        result = vkQueuePresentKHR(rendererData->presentQueue, &presentInfo);
+        if ((result != VK_SUCCESS) && (result != VK_ERROR_OUT_OF_DATE_KHR) && (result != VK_ERROR_SURFACE_LOST_KHR) && (result != VK_SUBOPTIMAL_KHR )) {
+            SET_ERROR_CODE("vkQueuePresentKHR()", result);
+            return false;
+        }
+
+        rendererData->currentCommandBufferIndex = ( rendererData->currentCommandBufferIndex + 1 ) % rendererData->swapchainImageCount;
+
+        // Wait for previous time this command buffer was submitted, will be N frames ago
+        result = vkWaitForFences(rendererData->device, 1, &rendererData->fences[rendererData->currentCommandBufferIndex], VK_TRUE, UINT64_MAX);
+        if (result != VK_SUCCESS) {
+            if (result == VK_ERROR_DEVICE_LOST) {
+                if (VULKAN_HandleDeviceLost(renderer)) {
+                    SDL_SetError("Present failed, device lost");
+                } else {
+                    // Recovering from device lost failed, error is already set
+                }
+            } else {
+                SET_ERROR_CODE("vkWaitForFences()", result);
+            }
+            return false;
+        }
+
+        VULKAN_AcquireNextSwapchainImage(renderer);
+    }
+
+    return true;
+}
+
+static bool VULKAN_SetVSync(SDL_Renderer *renderer, const int vsync)
+{
+    VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
+
+    switch (vsync) {
+    case -1:
+    case 0:
+    case 1:
+        // Supported
+        break;
+    default:
+        return SDL_Unsupported();
+    }
+    if (vsync != rendererData->vsync) {
+        rendererData->vsync = vsync;
+        rendererData->recreateSwapchain = true;
+    }
+    return true;
+}
+
+static bool VULKAN_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    VULKAN_RenderData *rendererData;
+
+    SDL_SetupRendererColorspace(renderer, create_props);
+
+    if (renderer->output_colorspace != SDL_COLORSPACE_SRGB &&
+        renderer->output_colorspace != SDL_COLORSPACE_SRGB_LINEAR
+        /*&& renderer->output_colorspace != SDL_COLORSPACE_HDR10*/) {
+        return SDL_SetError("Unsupported output colorspace");
+    }
+
+    rendererData = (VULKAN_RenderData *)SDL_calloc(1, sizeof(*rendererData));
+    if (!rendererData) {
+        return false;
+    }
+
+    rendererData->identity = MatrixIdentity();
+    rendererData->identitySwizzle.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+    rendererData->identitySwizzle.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+    rendererData->identitySwizzle.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+    rendererData->identitySwizzle.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+
+    // Save the create props in case we need to recreate on device lost
+    rendererData->create_props = SDL_CreateProperties();
+    if (!SDL_CopyProperties(create_props, rendererData->create_props)) {
+        SDL_free(rendererData);
+        return false;
+    }
+
+    renderer->WindowEvent = VULKAN_WindowEvent;
+    renderer->SupportsBlendMode = VULKAN_SupportsBlendMode;
+    renderer->CreateTexture = VULKAN_CreateTexture;
+    renderer->UpdateTexture = VULKAN_UpdateTexture;
+#ifdef SDL_HAVE_YUV
+    renderer->UpdateTextureYUV = VULKAN_UpdateTextureYUV;
+    renderer->UpdateTextureNV = VULKAN_UpdateTextureNV;
+#endif
+    renderer->LockTexture = VULKAN_LockTexture;
+    renderer->UnlockTexture = VULKAN_UnlockTexture;
+    renderer->SetTextureScaleMode = VULKAN_SetTextureScaleMode;
+    renderer->SetRenderTarget = VULKAN_SetRenderTarget;
+    renderer->QueueSetViewport = VULKAN_QueueNoOp;
+    renderer->QueueSetDrawColor = VULKAN_QueueNoOp;
+    renderer->QueueDrawPoints = VULKAN_QueueDrawPoints;
+    renderer->QueueDrawLines = VULKAN_QueueDrawPoints; // lines and points queue vertices the same way.
+    renderer->QueueGeometry = VULKAN_QueueGeometry;
+    renderer->InvalidateCachedState = VULKAN_InvalidateCachedState;
+    renderer->RunCommandQueue = VULKAN_RunCommandQueue;
+    renderer->RenderReadPixels = VULKAN_RenderReadPixels;
+    renderer->AddVulkanRenderSemaphores = VULKAN_AddVulkanRenderSemaphores;
+    renderer->RenderPresent = VULKAN_RenderPresent;
+    renderer->DestroyTexture = VULKAN_DestroyTexture;
+    renderer->DestroyRenderer = VULKAN_DestroyRenderer;
+    renderer->SetVSync = VULKAN_SetVSync;
+    renderer->internal = rendererData;
+    VULKAN_InvalidateCachedState(renderer);
+
+    renderer->name = VULKAN_RenderDriver.name;
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ARGB8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR8888);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_ABGR2101010);
+    SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_RGBA64_FLOAT);
+    SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
+
+    /* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
+     * order to give init functions access to the underlying window handle:
+     */
+    renderer->window = window;
+
+    // Initialize Vulkan resources
+    if (VULKAN_CreateDeviceResources(renderer, create_props) != VK_SUCCESS) {
+        return false;
+    }
+
+    if (VULKAN_CreateWindowSizeDependentResources(renderer) != VK_SUCCESS) {
+        return false;
+    }
+
+#ifdef SDL_HAVE_YUV
+    if (rendererData->supportsKHRSamplerYCbCrConversion) {
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_YV12);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_IYUV);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV12);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_NV21);
+        SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_P010);
+    }
+#endif
+
+    return true;
+}
+
+SDL_RenderDriver VULKAN_RenderDriver = {
+    VULKAN_CreateRenderer, "vulkan"
+};
+
+#endif // SDL_VIDEO_RENDER_VULKAN
diff --git a/SDL-3.2.8/src/render/vulkan/SDL_shaders_vulkan.c b/SDL-3.2.8/src/render/vulkan/SDL_shaders_vulkan.c
new file mode 100644
index 0000000..6c02cf2
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/SDL_shaders_vulkan.c
@@ -0,0 +1,60 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_RENDER_VULKAN
+
+#include "SDL_shaders_vulkan.h"
+
+// The shaders here were compiled with compile_shaders.bat
+#include "VULKAN_PixelShader_Colors.h"
+#include "VULKAN_PixelShader_Textures.h"
+#include "VULKAN_PixelShader_Advanced.h"
+#include "VULKAN_VertexShader.h"
+
+static struct
+{
+    const void *ps_shader_data;
+    size_t ps_shader_size;
+    const void *vs_shader_data;
+    size_t vs_shader_size;
+} VULKAN_shaders[NUM_SHADERS] = {
+    { VULKAN_PixelShader_Colors, sizeof(VULKAN_PixelShader_Colors),
+      VULKAN_VertexShader, sizeof(VULKAN_VertexShader) },
+    { VULKAN_PixelShader_Textures, sizeof(VULKAN_PixelShader_Textures),
+      VULKAN_VertexShader, sizeof(VULKAN_VertexShader) },
+    { VULKAN_PixelShader_Advanced, sizeof(VULKAN_PixelShader_Advanced),
+      VULKAN_VertexShader, sizeof(VULKAN_VertexShader) },
+};
+
+void VULKAN_GetVertexShader(VULKAN_Shader shader, const uint32_t **outBytecode, size_t *outSize)
+{
+    *outBytecode = (const uint32_t *)VULKAN_shaders[shader].vs_shader_data;
+    *outSize = VULKAN_shaders[shader].vs_shader_size;
+}
+
+void VULKAN_GetPixelShader(VULKAN_Shader shader, const uint32_t **outBytecode, size_t *outSize)
+{
+    *outBytecode = (const uint32_t *)VULKAN_shaders[shader].ps_shader_data;
+    *outSize = VULKAN_shaders[shader].ps_shader_size;
+}
+
+#endif // SDL_VIDEO_RENDER_VULKAN
diff --git a/SDL-3.2.8/src/render/vulkan/SDL_shaders_vulkan.h b/SDL-3.2.8/src/render/vulkan/SDL_shaders_vulkan.h
new file mode 100644
index 0000000..bc98aa3
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/SDL_shaders_vulkan.h
@@ -0,0 +1,44 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// Vulkan shader implementation
+
+// Set up for C function definitions, even when using C++
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum
+{
+    SHADER_SOLID,
+    SHADER_RGB,
+    SHADER_ADVANCED,
+    NUM_SHADERS
+} VULKAN_Shader;
+
+extern void VULKAN_GetVertexShader(VULKAN_Shader shader, const uint32_t **outBytecode, size_t *outSize);
+extern void VULKAN_GetPixelShader(VULKAN_Shader shader, const uint32_t **outBytecode, size_t *outSize);
+
+// Ends C function definitions when using C++
+#ifdef __cplusplus
+}
+#endif
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Advanced.h b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Advanced.h
new file mode 100644
index 0000000..0c267cf
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Advanced.h
@@ -0,0 +1,271 @@
+        // 1113.1.1
+         #pragma once
+static const uint32_t VULKAN_PixelShader_Advanced[] = {
+        0x07230203,0x00010000,0x0008000b,0x0000043e,0x00000000,0x00020011,0x00000001,0x0006000b,
+        0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+        0x0008000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x000001bb,0x000001be,0x000001c2,
+        0x00030010,0x00000004,0x00000007,0x00030003,0x00000005,0x000001f4,0x00040005,0x00000004,
+        0x6e69616d,0x00000000,0x00050005,0x00000075,0x736e6f43,0x746e6174,0x00000073,0x00070006,
+        0x00000075,0x00000000,0x47526373,0x756f5f42,0x74757074,0x00000000,0x00060006,0x00000075,
+        0x00000001,0x75706e69,0x79745f74,0x00006570,0x00060006,0x00000075,0x00000002,0x6f6c6f63,
+        0x63735f72,0x00656c61,0x00060006,0x00000075,0x00000003,0x73756e75,0x705f6465,0x00306461,
+        0x00070006,0x00000075,0x00000004,0x656e6f74,0x5f70616d,0x6874656d,0x0000646f,0x00070006,
+        0x00000075,0x00000005,0x656e6f74,0x5f70616d,0x74636166,0x0031726f,0x00070006,0x00000075,
+        0x00000006,0x656e6f74,0x5f70616d,0x74636166,0x0032726f,0x00070006,0x00000075,0x00000007,
+        0x5f726473,0x74696877,0x6f705f65,0x00746e69,0x00030005,0x00000077,0x00000000,0x00050005,
+        0x000000e6,0x74786574,0x30657275,0x00000000,0x00050005,0x000001bb,0x75706e69,0x65742e74,
+        0x00000078,0x00050005,0x000001be,0x75706e69,0x6f632e74,0x00726f6c,0x00070005,0x000001c2,
+        0x746e6540,0x6f507972,0x4f746e69,0x75707475,0x00000074,0x00050048,0x00000075,0x00000000,
+        0x00000023,0x00000000,0x00050048,0x00000075,0x00000001,0x00000023,0x00000004,0x00050048,
+        0x00000075,0x00000002,0x00000023,0x00000008,0x00050048,0x00000075,0x00000003,0x00000023,
+        0x0000000c,0x00050048,0x00000075,0x00000004,0x00000023,0x00000010,0x00050048,0x00000075,
+        0x00000005,0x00000023,0x00000014,0x00050048,0x00000075,0x00000006,0x00000023,0x00000018,
+        0x00050048,0x00000075,0x00000007,0x00000023,0x0000001c,0x00030047,0x00000075,0x00000002,
+        0x00040047,0x00000077,0x00000022,0x00000000,0x00040047,0x00000077,0x00000021,0x00000001,
+        0x00040047,0x000000e6,0x00000022,0x00000000,0x00040047,0x000000e6,0x00000021,0x00000000,
+        0x00040047,0x000001bb,0x0000001e,0x00000000,0x00040047,0x000001be,0x0000001e,0x00000001,
+        0x00040047,0x000001c2,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,
+        0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x0000000f,0x00000006,0x00000003,
+        0x00040017,0x00000018,0x00000006,0x00000004,0x00040017,0x00000019,0x00000006,0x00000002,
+        0x0004002b,0x00000006,0x00000032,0x3d25aee6,0x00020014,0x00000033,0x0004002b,0x00000006,
+        0x00000038,0x414eb852,0x0004002b,0x00000006,0x0000003c,0x3d6147ae,0x0004002b,0x00000006,
+        0x0000003f,0x3f870a3d,0x0004002b,0x00000006,0x00000041,0x4019999a,0x0004002b,0x00000006,
+        0x00000047,0x3b4d2e1c,0x0004002b,0x00000006,0x00000050,0x3ed55555,0x0004002b,0x00000006,
+        0x0000005a,0x3c4fcdac,0x0006002c,0x0000000f,0x0000005b,0x0000005a,0x0000005a,0x0000005a,
+        0x0004002b,0x00000006,0x0000005d,0x3f560000,0x0004002b,0x00000006,0x00000060,0x00000000,
+        0x0006002c,0x0000000f,0x00000061,0x00000060,0x00000060,0x00000060,0x0004002b,0x00000006,
+        0x00000064,0x4196d000,0x0004002b,0x00000006,0x00000065,0x41958000,0x0004002b,0x00000006,
+        0x0000006c,0x461c4000,0x0004002b,0x00000006,0x00000071,0x40c8e06b,0x0006002c,0x0000000f,
+        0x00000072,0x00000071,0x00000071,0x00000071,0x000a001e,0x00000075,0x00000006,0x00000006,
+        0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00040020,0x00000076,
+        0x00000002,0x00000075,0x0004003b,0x00000076,0x00000077,0x00000002,0x00040015,0x00000078,
+        0x00000020,0x00000001,0x0004002b,0x00000078,0x00000079,0x00000007,0x00040020,0x0000007a,
+        0x00000002,0x00000006,0x0004002b,0x00000078,0x00000081,0x00000004,0x0004002b,0x00000006,
+        0x00000084,0x3f800000,0x0004002b,0x00000078,0x00000088,0x00000005,0x0004002b,0x00000006,
+        0x00000090,0x40000000,0x0004002b,0x00000078,0x00000094,0x00000001,0x00040018,0x0000009b,
+        0x0000000f,0x00000003,0x0004002b,0x00000006,0x0000009c,0x3f209d8c,0x0004002b,0x00000006,
+        0x0000009d,0x3ea897c8,0x0004002b,0x00000006,0x0000009e,0x3d3168f9,0x0006002c,0x0000000f,
+        0x0000009f,0x0000009c,0x0000009d,0x0000009e,0x0004002b,0x00000006,0x000000a0,0x3d8d82ba,
+        0x0004002b,0x00000006,0x000000a1,0x3f6b670a,0x0004002b,0x00000006,0x000000a2,0x3c3a27af,
+        0x0006002c,0x0000000f,0x000000a3,0x000000a0,0x000000a1,0x000000a2,0x0004002b,0x00000006,
+        0x000000a4,0x3c86466b,0x0004002b,0x00000006,0x000000a5,0x3db44029,0x0004002b,0x00000006,
+        0x000000a6,0x3f6545b7,0x0006002c,0x0000000f,0x000000a7,0x000000a4,0x000000a5,0x000000a6,
+        0x0006002c,0x0000009b,0x000000a8,0x0000009f,0x000000a3,0x000000a7,0x0004002b,0x00000078,
+        0x000000c1,0x00000006,0x0004002b,0x00000006,0x000000d1,0x3fd48b22,0x0004002b,0x00000006,
+        0x000000d2,0xbf1670a0,0x0004002b,0x00000006,0x000000d3,0xbd952d23,0x0006002c,0x0000000f,
+        0x000000d4,0x000000d1,0x000000d2,0x000000d3,0x0004002b,0x00000006,0x000000d5,0xbdff127f,
+        0x0004002b,0x00000006,0x000000d6,0x3f9102b4,0x0004002b,0x00000006,0x000000d7,0xbc08c60d,
+        0x0006002c,0x0000000f,0x000000d8,0x000000d5,0x000000d6,0x000000d7,0x0004002b,0x00000006,
+        0x000000d9,0xbc94b7b3,0x0004002b,0x00000006,0x000000da,0xbdce05cd,0x0004002b,0x00000006,
+        0x000000db,0x3f8f333c,0x0006002c,0x0000000f,0x000000dc,0x000000d9,0x000000da,0x000000db,
+        0x0006002c,0x0000009b,0x000000dd,0x000000d4,0x000000d8,0x000000dc,0x00090019,0x000000e3,
+        0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x0003001b,
+        0x000000e4,0x000000e3,0x00040020,0x000000e5,0x00000000,0x000000e4,0x0004003b,0x000000e5,
+        0x000000e6,0x00000000,0x0004002b,0x00000078,0x000000f2,0x00000002,0x0004002b,0x00000078,
+        0x00000103,0x00000000,0x0004002b,0x00000006,0x00000147,0x40400000,0x00040020,0x000001b6,
+        0x00000001,0x00000018,0x00040020,0x000001ba,0x00000001,0x00000019,0x0004003b,0x000001ba,
+        0x000001bb,0x00000001,0x0004003b,0x000001b6,0x000001be,0x00000001,0x00040020,0x000001c1,
+        0x00000003,0x00000018,0x0004003b,0x000001c1,0x000001c2,0x00000003,0x0006002c,0x0000000f,
+        0x000003fa,0x0000005d,0x0000005d,0x0000005d,0x0006002c,0x0000000f,0x000003fb,0x00000064,
+        0x00000064,0x00000064,0x0006002c,0x0000000f,0x00000400,0x00000084,0x00000084,0x00000084,
+        0x0004002b,0x00000006,0x00000406,0x3f72a76f,0x0004002b,0x00000006,0x00000407,0x3d9e8391,
+        0x0004002b,0x00000006,0x00000409,0xbd6147ae,0x00030001,0x00000018,0x0000043d,0x00050036,
+        0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003d,0x00000019,
+        0x000001bc,0x000001bb,0x0004003d,0x00000018,0x000001bf,0x000001be,0x0004003d,0x000000e4,
+        0x0000023c,0x000000e6,0x00050057,0x00000018,0x0000023f,0x0000023c,0x000001bc,0x00050041,
+        0x0000007a,0x000001d8,0x00000077,0x00000094,0x0004003d,0x00000006,0x000001d9,0x000001d8,
+        0x000500b4,0x00000033,0x000001da,0x000001d9,0x00000147,0x000300f7,0x000001e5,0x00000000,
+        0x000400fa,0x000001da,0x000001db,0x000001e5,0x000200f8,0x000001db,0x0008004f,0x0000000f,
+        0x000001dd,0x0000023f,0x0000023f,0x00000000,0x00000001,0x00000002,0x0006000c,0x0000000f,
+        0x00000246,0x00000001,0x00000004,0x000001dd,0x0007000c,0x0000000f,0x00000247,0x00000001,
+        0x0000001a,0x00000246,0x0000005b,0x00050083,0x0000000f,0x00000249,0x00000247,0x000003fa,
+        0x0007000c,0x0000000f,0x0000024a,0x00000001,0x00000028,0x00000249,0x00000061,0x0006000c,
+        0x0000000f,0x0000024c,0x00000001,0x00000004,0x000001dd,0x0007000c,0x0000000f,0x0000024d,
+        0x00000001,0x0000001a,0x0000024c,0x0000005b,0x0005008e,0x0000000f,0x0000024e,0x0000024d,
+        0x00000065,0x00050083,0x0000000f,0x00000250,0x000003fb,0x0000024e,0x00050088,0x0000000f,
+        0x00000253,0x0000024a,0x00000250,0x0006000c,0x0000000f,0x00000254,0x00000001,0x00000004,
+        0x00000253,0x0007000c,0x0000000f,0x00000255,0x00000001,0x0000001a,0x00000254,0x00000072,
+        0x0005008e,0x0000000f,0x00000256,0x00000255,0x0000006c,0x00050041,0x0000007a,0x00000257,
+        0x00000077,0x00000079,0x0004003d,0x00000006,0x00000258,0x00000257,0x00060050,0x0000000f,
+        0x00000259,0x00000258,0x00000258,0x00000258,0x00050088,0x0000000f,0x0000025a,0x00000256,
+        0x00000259,0x00050051,0x00000006,0x000001e0,0x0000025a,0x00000000,0x00060052,0x00000018,
+        0x000003a7,0x000001e0,0x0000023f,0x00000000,0x00050051,0x00000006,0x000001e2,0x0000025a,
+        0x00000001,0x00060052,0x00000018,0x000003a9,0x000001e2,0x000003a7,0x00000001,0x00050051,
+        0x00000006,0x000001e4,0x0000025a,0x00000002,0x00060052,0x00000018,0x000003ab,0x000001e4,
+        0x000003a9,0x00000002,0x000200f9,0x000001e5,0x000200f8,0x000001e5,0x000700f5,0x00000018,
+        0x0000040a,0x0000023f,0x00000005,0x000003ab,0x000001db,0x00050041,0x0000007a,0x000001e6,
+        0x00000077,0x00000081,0x0004003d,0x00000006,0x000001e7,0x000001e6,0x000500b7,0x00000033,
+        0x000001e8,0x000001e7,0x00000060,0x000300f7,0x000001f3,0x00000000,0x000400fa,0x000001e8,
+        0x000001e9,0x000001f3,0x000200f8,0x000001e9,0x0008004f,0x0000000f,0x000001eb,0x0000040a,
+        0x0000040a,0x00000000,0x00000001,0x00000002,0x00050041,0x0000007a,0x0000025f,0x00000077,
+        0x00000081,0x0004003d,0x00000006,0x00000260,0x0000025f,0x000500b4,0x00000033,0x00000261,
+        0x00000260,0x00000084,0x000300f7,0x00000295,0x00000000,0x000400fa,0x00000261,0x00000262,
+        0x00000267,0x000200f8,0x00000262,0x00050041,0x0000007a,0x00000263,0x00000077,0x00000088,
+        0x0004003d,0x00000006,0x00000264,0x00000263,0x0005008e,0x0000000f,0x00000266,0x000001eb,
+        0x00000264,0x000200f9,0x00000295,0x000200f8,0x00000267,0x00050041,0x0000007a,0x00000268,
+        0x00000077,0x00000081,0x0004003d,0x00000006,0x00000269,0x00000268,0x000500b4,0x00000033,
+        0x0000026a,0x00000269,0x00000090,0x000300f7,0x00000294,0x00000000,0x000400fa,0x0000026a,
+        0x0000026b,0x00000294,0x000200f8,0x0000026b,0x00050041,0x0000007a,0x0000026c,0x00000077,
+        0x00000094,0x0004003d,0x00000006,0x0000026d,0x0000026c,0x000500b4,0x00000033,0x0000026e,
+        0x0000026d,0x00000090,0x000300f7,0x00000272,0x00000000,0x000400fa,0x0000026e,0x0000026f,
+        0x00000272,0x000200f8,0x0000026f,0x00050090,0x0000000f,0x00000271,0x000001eb,0x000000a8,
+        0x000200f9,0x00000272,0x000200f8,0x00000272,0x000700f5,0x0000000f,0x0000040b,0x000001eb,
+        0x0000026b,0x00000271,0x0000026f,0x00050051,0x00000006,0x00000274,0x0000040b,0x00000000,
+        0x00050051,0x00000006,0x00000276,0x0000040b,0x00000001,0x00050051,0x00000006,0x00000278,
+        0x0000040b,0x00000002,0x0007000c,0x00000006,0x00000279,0x00000001,0x00000028,0x00000276,
+        0x00000278,0x0007000c,0x00000006,0x0000027a,0x00000001,0x00000028,0x00000274,0x00000279,
+        0x000500ba,0x00000033,0x0000027c,0x0000027a,0x00000060,0x000300f7,0x0000028c,0x00000000,
+        0x000400fa,0x0000027c,0x0000027d,0x0000028c,0x000200f8,0x0000027d,0x00050041,0x0000007a,
+        0x0000027e,0x00000077,0x00000088,0x0004003d,0x00000006,0x0000027f,0x0000027e,0x0008000c,
+        0x00000006,0x00000282,0x00000001,0x00000032,0x0000027f,0x0000027a,0x00000084,0x00050041,
+        0x0000007a,0x00000283,0x00000077,0x000000c1,0x0004003d,0x00000006,0x00000284,0x00000283,
+        0x0008000c,0x00000006,0x00000287,0x00000001,0x00000032,0x00000284,0x0000027a,0x00000084,
+        0x00050088,0x00000006,0x00000288,0x00000282,0x00000287,0x0005008e,0x0000000f,0x0000028b,
+        0x0000040b,0x00000288,0x000200f9,0x0000028c,0x000200f8,0x0000028c,0x000700f5,0x0000000f,
+        0x0000040c,0x0000040b,0x00000272,0x0000028b,0x0000027d,0x00050041,0x0000007a,0x0000028d,
+        0x00000077,0x00000094,0x0004003d,0x00000006,0x0000028e,0x0000028d,0x000500b4,0x00000033,
+        0x0000028f,0x0000028e,0x00000090,0x000300f7,0x00000293,0x00000000,0x000400fa,0x0000028f,
+        0x00000290,0x00000293,0x000200f8,0x00000290,0x00050090,0x0000000f,0x00000292,0x0000040c,
+        0x000000dd,0x000200f9,0x00000293,0x000200f8,0x00000293,0x000700f5,0x0000000f,0x0000040f,
+        0x0000040c,0x0000028c,0x00000292,0x00000290,0x000200f9,0x00000294,0x000200f8,0x00000294,
+        0x000700f5,0x0000000f,0x0000040e,0x000001eb,0x00000267,0x0000040f,0x00000293,0x000200f9,
+        0x00000295,0x000200f8,0x00000295,0x000700f5,0x0000000f,0x0000040d,0x00000266,0x00000262,
+        0x0000040e,0x00000294,0x00050051,0x00000006,0x000001ee,0x0000040d,0x00000000,0x00060052,
+        0x00000018,0x000003b0,0x000001ee,0x0000040a,0x00000000,0x00050051,0x00000006,0x000001f0,
+        0x0000040d,0x00000001,0x00060052,0x00000018,0x000003b2,0x000001f0,0x000003b0,0x00000001,
+        0x00050051,0x00000006,0x000001f2,0x0000040d,0x00000002,0x00060052,0x00000018,0x000003b4,
+        0x000001f2,0x000003b2,0x00000002,0x000200f9,0x000001f3,0x000200f8,0x000001f3,0x000700f5,
+        0x00000018,0x00000415,0x0000040a,0x000001e5,0x000003b4,0x00000295,0x00050041,0x0000007a,
+        0x000001f4,0x00000077,0x00000094,0x0004003d,0x00000006,0x000001f5,0x000001f4,0x000500b4,
+        0x00000033,0x000001f6,0x000001f5,0x00000084,0x000300f7,0x00000234,0x00000000,0x000400fa,
+        0x000001f6,0x000001f7,0x00000204,0x000200f8,0x000001f7,0x0008004f,0x0000000f,0x000001f9,
+        0x00000415,0x00000415,0x00000000,0x00000001,0x00000002,0x00050041,0x0000007a,0x0000029d,
+        0x00000077,0x00000103,0x0004003d,0x00000006,0x0000029e,0x0000029d,0x000500b7,0x00000033,
+        0x0000029f,0x0000029e,0x00000060,0x000300f7,0x000002ad,0x00000000,0x000400fa,0x0000029f,
+        0x000002a0,0x000002ad,0x000200f8,0x000002a0,0x00050051,0x00000006,0x000002a2,0x00000415,
+        0x00000000,0x000500bc,0x00000033,0x000002b6,0x000002a2,0x00000032,0x000300f7,0x000002c0,
+        0x00000000,0x000400fa,0x000002b6,0x000002b7,0x000002ba,0x000200f8,0x000002b7,0x00050085,
+        0x00000006,0x000002b9,0x000002a2,0x00000407,0x000200f9,0x000002c0,0x000200f8,0x000002ba,
+        0x00050081,0x00000006,0x000002bc,0x000002a2,0x0000003c,0x0006000c,0x00000006,0x000002bd,
+        0x00000001,0x00000004,0x000002bc,0x00050085,0x00000006,0x000002be,0x000002bd,0x00000406,
+        0x0007000c,0x00000006,0x000002bf,0x00000001,0x0000001a,0x000002be,0x00000041,0x000200f9,
+        0x000002c0,0x000200f8,0x000002c0,0x000700f5,0x00000006,0x0000042c,0x000002b9,0x000002b7,
+        0x000002bf,0x000002ba,0x00050051,0x00000006,0x000002a6,0x00000415,0x00000001,0x000500bc,
+        0x00000033,0x000002c5,0x000002a6,0x00000032,0x000300f7,0x000002cf,0x00000000,0x000400fa,
+        0x000002c5,0x000002c6,0x000002c9,0x000200f8,0x000002c6,0x00050085,0x00000006,0x000002c8,
+        0x000002a6,0x00000407,0x000200f9,0x000002cf,0x000200f8,0x000002c9,0x00050081,0x00000006,
+        0x000002cb,0x000002a6,0x0000003c,0x0006000c,0x00000006,0x000002cc,0x00000001,0x00000004,
+        0x000002cb,0x00050085,0x00000006,0x000002cd,0x000002cc,0x00000406,0x0007000c,0x00000006,
+        0x000002ce,0x00000001,0x0000001a,0x000002cd,0x00000041,0x000200f9,0x000002cf,0x000200f8,
+        0x000002cf,0x000700f5,0x00000006,0x0000042e,0x000002c8,0x000002c6,0x000002ce,0x000002c9,
+        0x00050051,0x00000006,0x000002aa,0x00000415,0x00000002,0x000500bc,0x00000033,0x000002d4,
+        0x000002aa,0x00000032,0x000300f7,0x000002de,0x00000000,0x000400fa,0x000002d4,0x000002d5,
+        0x000002d8,0x000200f8,0x000002d5,0x00050085,0x00000006,0x000002d7,0x000002aa,0x00000407,
+        0x000200f9,0x000002de,0x000200f8,0x000002d8,0x00050081,0x00000006,0x000002da,0x000002aa,
+        0x0000003c,0x0006000c,0x00000006,0x000002db,0x00000001,0x00000004,0x000002da,0x00050085,
+        0x00000006,0x000002dc,0x000002db,0x00000406,0x0007000c,0x00000006,0x000002dd,0x00000001,
+        0x0000001a,0x000002dc,0x00000041,0x000200f9,0x000002de,0x000200f8,0x000002de,0x000700f5,
+        0x00000006,0x00000430,0x000002d7,0x000002d5,0x000002dd,0x000002d8,0x00060050,0x0000000f,
+        0x0000043c,0x0000042c,0x0000042e,0x00000430,0x000200f9,0x000002ad,0x000200f8,0x000002ad,
+        0x000700f5,0x0000000f,0x00000432,0x000001f9,0x000001f7,0x0000043c,0x000002de,0x00050041,
+        0x0000007a,0x000002af,0x00000077,0x000000f2,0x0004003d,0x00000006,0x000002b0,0x000002af,
+        0x0005008e,0x0000000f,0x000002b1,0x00000432,0x000002b0,0x00050051,0x00000006,0x000001fc,
+        0x000002b1,0x00000000,0x00050051,0x00000006,0x000001fe,0x000002b1,0x00000001,0x00050051,
+        0x00000006,0x00000200,0x000002b1,0x00000002,0x00050051,0x00000006,0x00000202,0x00000415,
+        0x00000003,0x00070050,0x00000018,0x00000408,0x000001fc,0x000001fe,0x00000200,0x00000202,
+        0x000200f9,0x00000234,0x000200f8,0x00000204,0x00050041,0x0000007a,0x00000205,0x00000077,
+        0x00000094,0x0004003d,0x00000006,0x00000206,0x00000205,0x000500b4,0x00000033,0x00000207,
+        0x00000206,0x00000090,0x000300f7,0x00000233,0x00000000,0x000400fa,0x00000207,0x00000208,
+        0x00000215,0x000200f8,0x00000208,0x0008004f,0x0000000f,0x0000020a,0x00000415,0x00000415,
+        0x00000000,0x00000001,0x00000002,0x00050041,0x0000007a,0x000002e7,0x00000077,0x000000f2,
+        0x0004003d,0x00000006,0x000002e8,0x000002e7,0x0005008e,0x0000000f,0x000002e9,0x0000020a,
+        0x000002e8,0x00050041,0x0000007a,0x000002ea,0x00000077,0x00000103,0x0004003d,0x00000006,
+        0x000002eb,0x000002ea,0x000500b7,0x00000033,0x000002ec,0x000002eb,0x00000060,0x000400a8,
+        0x00000033,0x000002ed,0x000002ec,0x000300f7,0x000002ff,0x00000000,0x000400fa,0x000002ed,
+        0x000002ee,0x000002ff,0x000200f8,0x000002ee,0x00050051,0x00000006,0x000002f0,0x000002e9,
+        0x00000000,0x000500bc,0x00000033,0x00000304,0x000002f0,0x00000047,0x000300f7,0x0000030e,
+        0x00000000,0x000400fa,0x00000304,0x00000305,0x00000308,0x000200f8,0x00000305,0x00050085,
+        0x00000006,0x00000307,0x000002f0,0x00000038,0x000200f9,0x0000030e,0x000200f8,0x00000308,
+        0x0006000c,0x00000006,0x0000030a,0x00000001,0x00000004,0x000002f0,0x0007000c,0x00000006,
+        0x0000030b,0x00000001,0x0000001a,0x0000030a,0x00000050,0x0008000c,0x00000006,0x0000030d,
+        0x00000001,0x00000032,0x0000030b,0x0000003f,0x00000409,0x000200f9,0x0000030e,0x000200f8,
+        0x0000030e,0x000700f5,0x00000006,0x00000421,0x00000307,0x00000305,0x0000030d,0x00000308,
+        0x00050051,0x00000006,0x000002f4,0x000002e9,0x00000001,0x000500bc,0x00000033,0x00000313,
+        0x000002f4,0x00000047,0x000300f7,0x0000031d,0x00000000,0x000400fa,0x00000313,0x00000314,
+        0x00000317,0x000200f8,0x00000314,0x00050085,0x00000006,0x00000316,0x000002f4,0x00000038,
+        0x000200f9,0x0000031d,0x000200f8,0x00000317,0x0006000c,0x00000006,0x00000319,0x00000001,
+        0x00000004,0x000002f4,0x0007000c,0x00000006,0x0000031a,0x00000001,0x0000001a,0x00000319,
+        0x00000050,0x0008000c,0x00000006,0x0000031c,0x00000001,0x00000032,0x0000031a,0x0000003f,
+        0x00000409,0x000200f9,0x0000031d,0x000200f8,0x0000031d,0x000700f5,0x00000006,0x00000423,
+        0x00000316,0x00000314,0x0000031c,0x00000317,0x00050051,0x00000006,0x000002f8,0x000002e9,
+        0x00000002,0x000500bc,0x00000033,0x00000322,0x000002f8,0x00000047,0x000300f7,0x0000032c,
+        0x00000000,0x000400fa,0x00000322,0x00000323,0x00000326,0x000200f8,0x00000323,0x00050085,
+        0x00000006,0x00000325,0x000002f8,0x00000038,0x000200f9,0x0000032c,0x000200f8,0x00000326,
+        0x0006000c,0x00000006,0x00000328,0x00000001,0x00000004,0x000002f8,0x0007000c,0x00000006,
+        0x00000329,0x00000001,0x0000001a,0x00000328,0x00000050,0x0008000c,0x00000006,0x0000032b,
+        0x00000001,0x00000032,0x00000329,0x0000003f,0x00000409,0x000200f9,0x0000032c,0x000200f8,
+        0x0000032c,0x000700f5,0x00000006,0x00000425,0x00000325,0x00000323,0x0000032b,0x00000326,
+        0x00060050,0x0000000f,0x0000043b,0x00000421,0x00000423,0x00000425,0x0008000c,0x0000000f,
+        0x000002fe,0x00000001,0x0000002b,0x0000043b,0x00000061,0x00000400,0x000200f9,0x000002ff,
+        0x000200f8,0x000002ff,0x000700f5,0x0000000f,0x00000427,0x000002e9,0x00000208,0x000002fe,
+        0x0000032c,0x00050051,0x00000006,0x0000020d,0x00000427,0x00000000,0x00050051,0x00000006,
+        0x0000020f,0x00000427,0x00000001,0x00050051,0x00000006,0x00000211,0x00000427,0x00000002,
+        0x00050051,0x00000006,0x00000213,0x00000415,0x00000003,0x00070050,0x00000018,0x00000405,
+        0x0000020d,0x0000020f,0x00000211,0x00000213,0x000200f9,0x00000233,0x000200f8,0x00000215,
+        0x00050041,0x0000007a,0x00000216,0x00000077,0x00000094,0x0004003d,0x00000006,0x00000217,
+        0x00000216,0x000500b4,0x00000033,0x00000218,0x00000217,0x00000147,0x000300f7,0x00000232,
+        0x00000000,0x000400fa,0x00000218,0x00000219,0x0000022f,0x000200f8,0x00000219,0x0008004f,
+        0x0000000f,0x0000021b,0x00000415,0x00000415,0x00000000,0x00000001,0x00000002,0x00050090,
+        0x0000000f,0x0000021c,0x0000021b,0x000000dd,0x00050051,0x00000006,0x0000021e,0x0000021c,
+        0x00000000,0x00060052,0x00000018,0x000003da,0x0000021e,0x0000043d,0x00000000,0x00050051,
+        0x00000006,0x00000220,0x0000021c,0x00000001,0x00060052,0x00000018,0x000003dc,0x00000220,
+        0x000003da,0x00000001,0x00050051,0x00000006,0x00000222,0x0000021c,0x00000002,0x00060052,
+        0x00000018,0x000003de,0x00000222,0x000003dc,0x00000002,0x0008004f,0x0000000f,0x00000224,
+        0x000003de,0x000003de,0x00000000,0x00000001,0x00000002,0x00050041,0x0000007a,0x00000335,
+        0x00000077,0x000000f2,0x0004003d,0x00000006,0x00000336,0x00000335,0x0005008e,0x0000000f,
+        0x00000337,0x00000224,0x00000336,0x00050041,0x0000007a,0x00000338,0x00000077,0x00000103,
+        0x0004003d,0x00000006,0x00000339,0x00000338,0x000500b7,0x00000033,0x0000033a,0x00000339,
+        0x00000060,0x000400a8,0x00000033,0x0000033b,0x0000033a,0x000300f7,0x0000034d,0x00000000,
+        0x000400fa,0x0000033b,0x0000033c,0x0000034d,0x000200f8,0x0000033c,0x00050051,0x00000006,
+        0x0000033e,0x00000337,0x00000000,0x000500bc,0x00000033,0x00000352,0x0000033e,0x00000047,
+        0x000300f7,0x0000035c,0x00000000,0x000400fa,0x00000352,0x00000353,0x00000356,0x000200f8,
+        0x00000353,0x00050085,0x00000006,0x00000355,0x0000033e,0x00000038,0x000200f9,0x0000035c,
+        0x000200f8,0x00000356,0x0006000c,0x00000006,0x00000358,0x00000001,0x00000004,0x0000033e,
+        0x0007000c,0x00000006,0x00000359,0x00000001,0x0000001a,0x00000358,0x00000050,0x0008000c,
+        0x00000006,0x0000035b,0x00000001,0x00000032,0x00000359,0x0000003f,0x00000409,0x000200f9,
+        0x0000035c,0x000200f8,0x0000035c,0x000700f5,0x00000006,0x00000416,0x00000355,0x00000353,
+        0x0000035b,0x00000356,0x00050051,0x00000006,0x00000342,0x00000337,0x00000001,0x000500bc,
+        0x00000033,0x00000361,0x00000342,0x00000047,0x000300f7,0x0000036b,0x00000000,0x000400fa,
+        0x00000361,0x00000362,0x00000365,0x000200f8,0x00000362,0x00050085,0x00000006,0x00000364,
+        0x00000342,0x00000038,0x000200f9,0x0000036b,0x000200f8,0x00000365,0x0006000c,0x00000006,
+        0x00000367,0x00000001,0x00000004,0x00000342,0x0007000c,0x00000006,0x00000368,0x00000001,
+        0x0000001a,0x00000367,0x00000050,0x0008000c,0x00000006,0x0000036a,0x00000001,0x00000032,
+        0x00000368,0x0000003f,0x00000409,0x000200f9,0x0000036b,0x000200f8,0x0000036b,0x000700f5,
+        0x00000006,0x00000418,0x00000364,0x00000362,0x0000036a,0x00000365,0x00050051,0x00000006,
+        0x00000346,0x00000337,0x00000002,0x000500bc,0x00000033,0x00000370,0x00000346,0x00000047,
+        0x000300f7,0x0000037a,0x00000000,0x000400fa,0x00000370,0x00000371,0x00000374,0x000200f8,
+        0x00000371,0x00050085,0x00000006,0x00000373,0x00000346,0x00000038,0x000200f9,0x0000037a,
+        0x000200f8,0x00000374,0x0006000c,0x00000006,0x00000376,0x00000001,0x00000004,0x00000346,
+        0x0007000c,0x00000006,0x00000377,0x00000001,0x0000001a,0x00000376,0x00000050,0x0008000c,
+        0x00000006,0x00000379,0x00000001,0x00000032,0x00000377,0x0000003f,0x00000409,0x000200f9,
+        0x0000037a,0x000200f8,0x0000037a,0x000700f5,0x00000006,0x0000041a,0x00000373,0x00000371,
+        0x00000379,0x00000374,0x00060050,0x0000000f,0x0000043a,0x00000416,0x00000418,0x0000041a,
+        0x0008000c,0x0000000f,0x0000034c,0x00000001,0x0000002b,0x0000043a,0x00000061,0x00000400,
+        0x000200f9,0x0000034d,0x000200f8,0x0000034d,0x000700f5,0x0000000f,0x0000041c,0x00000337,
+        0x00000219,0x0000034c,0x0000037a,0x00050051,0x00000006,0x00000227,0x0000041c,0x00000000,
+        0x00050051,0x00000006,0x00000229,0x0000041c,0x00000001,0x00050051,0x00000006,0x0000022b,
+        0x0000041c,0x00000002,0x00050051,0x00000006,0x0000022d,0x00000415,0x00000003,0x00070050,
+        0x00000018,0x00000401,0x00000227,0x00000229,0x0000022b,0x0000022d,0x000200f9,0x00000232,
+        0x000200f8,0x0000022f,0x0008004f,0x0000000f,0x00000380,0x00000415,0x00000415,0x00000000,
+        0x00000001,0x00000002,0x00050041,0x0000007a,0x00000381,0x00000077,0x000000f2,0x0004003d,
+        0x00000006,0x00000382,0x00000381,0x0005008e,0x0000000f,0x00000383,0x00000380,0x00000382,
+        0x00050051,0x00000006,0x00000385,0x00000383,0x00000000,0x00050051,0x00000006,0x00000387,
+        0x00000383,0x00000001,0x00050051,0x00000006,0x00000389,0x00000383,0x00000002,0x00050051,
+        0x00000006,0x0000038b,0x00000415,0x00000003,0x00070050,0x00000018,0x000003fc,0x00000385,
+        0x00000387,0x00000389,0x0000038b,0x000200f9,0x00000232,0x000200f8,0x00000232,0x000700f5,
+        0x00000018,0x00000439,0x00000401,0x0000034d,0x000003fc,0x0000022f,0x000200f9,0x00000233,
+        0x000200f8,0x00000233,0x000700f5,0x00000018,0x00000438,0x00000405,0x000002ff,0x00000439,
+        0x00000232,0x000200f9,0x00000234,0x000200f8,0x00000234,0x000700f5,0x00000018,0x00000437,
+        0x00000408,0x000002ad,0x00000438,0x00000233,0x00050085,0x00000018,0x00000238,0x00000437,
+        0x000001bf,0x0003003e,0x000001c2,0x00000238,0x000100fd,0x00010038
+};
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Advanced.hlsl b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Advanced.hlsl
new file mode 100644
index 0000000..f3a0a61
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Advanced.hlsl
@@ -0,0 +1,7 @@
+
+#include "VULKAN_PixelShader_Common.hlsli"
+
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+        return AdvancedPixelShader(input);
+}
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Colors.h b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Colors.h
new file mode 100644
index 0000000..bd03f72
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Colors.h
@@ -0,0 +1,41 @@
+        // 1113.1.1
+         #pragma once
+static const uint32_t VULKAN_PixelShader_Colors[] = {
+        0x07230203,0x00010000,0x0008000b,0x000000a1,0x00000000,0x00020011,0x00000001,0x0006000b,
+        0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+        0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000048,0x0000004c,0x00030010,
+        0x00000004,0x00000007,0x00030003,0x00000005,0x000001f4,0x00040005,0x00000004,0x6e69616d,
+        0x00000000,0x00050005,0x00000018,0x736e6f43,0x746e6174,0x00000073,0x00070006,0x00000018,
+        0x00000000,0x47526373,0x756f5f42,0x74757074,0x00000000,0x00060006,0x00000018,0x00000001,
+        0x75706e69,0x79745f74,0x00006570,0x00060006,0x00000018,0x00000002,0x6f6c6f63,0x63735f72,
+        0x00656c61,0x00060006,0x00000018,0x00000003,0x73756e75,0x705f6465,0x00306461,0x00070006,
+        0x00000018,0x00000004,0x656e6f74,0x5f70616d,0x6874656d,0x0000646f,0x00070006,0x00000018,
+        0x00000005,0x656e6f74,0x5f70616d,0x74636166,0x0031726f,0x00070006,0x00000018,0x00000006,
+        0x656e6f74,0x5f70616d,0x74636166,0x0032726f,0x00070006,0x00000018,0x00000007,0x5f726473,
+        0x74696877,0x6f705f65,0x00746e69,0x00030005,0x0000001a,0x00000000,0x00050005,0x00000048,
+        0x75706e69,0x6f632e74,0x00726f6c,0x00070005,0x0000004c,0x746e6540,0x6f507972,0x4f746e69,
+        0x75707475,0x00000074,0x00050048,0x00000018,0x00000000,0x00000023,0x00000000,0x00050048,
+        0x00000018,0x00000001,0x00000023,0x00000004,0x00050048,0x00000018,0x00000002,0x00000023,
+        0x00000008,0x00050048,0x00000018,0x00000003,0x00000023,0x0000000c,0x00050048,0x00000018,
+        0x00000004,0x00000023,0x00000010,0x00050048,0x00000018,0x00000005,0x00000023,0x00000014,
+        0x00050048,0x00000018,0x00000006,0x00000023,0x00000018,0x00050048,0x00000018,0x00000007,
+        0x00000023,0x0000001c,0x00030047,0x00000018,0x00000002,0x00040047,0x0000001a,0x00000022,
+        0x00000000,0x00040047,0x0000001a,0x00000021,0x00000001,0x00040047,0x00000048,0x0000001e,
+        0x00000001,0x00040047,0x0000004c,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,
+        0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,
+        0x00000004,0x00040017,0x00000015,0x00000006,0x00000003,0x000a001e,0x00000018,0x00000006,
+        0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00040020,
+        0x00000019,0x00000002,0x00000018,0x0004003b,0x00000019,0x0000001a,0x00000002,0x00040015,
+        0x0000001b,0x00000020,0x00000001,0x0004002b,0x0000001b,0x0000001c,0x00000002,0x00040020,
+        0x0000001d,0x00000002,0x00000006,0x0004002b,0x00000006,0x00000033,0x3f800000,0x00040020,
+        0x0000003e,0x00000001,0x00000007,0x0004003b,0x0000003e,0x00000048,0x00000001,0x00040020,
+        0x0000004b,0x00000003,0x00000007,0x0004003b,0x0000004b,0x0000004c,0x00000003,0x0006002c,
+        0x00000015,0x0000009f,0x00000033,0x00000033,0x00000033,0x00050036,0x00000002,0x00000004,
+        0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003d,0x00000007,0x00000049,0x00000048,
+        0x00050041,0x0000001d,0x0000007e,0x0000001a,0x0000001c,0x0004003d,0x00000006,0x0000007f,
+        0x0000007e,0x0005008e,0x00000015,0x00000080,0x0000009f,0x0000007f,0x00050051,0x00000006,
+        0x00000082,0x00000080,0x00000000,0x00050051,0x00000006,0x00000084,0x00000080,0x00000001,
+        0x00050051,0x00000006,0x00000086,0x00000080,0x00000002,0x00070050,0x00000007,0x000000a0,
+        0x00000082,0x00000084,0x00000086,0x00000033,0x00050085,0x00000007,0x00000078,0x000000a0,
+        0x00000049,0x0003003e,0x0000004c,0x00000078,0x000100fd,0x00010038
+};
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Colors.hlsl b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Colors.hlsl
new file mode 100644
index 0000000..b754dde
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Colors.hlsl
@@ -0,0 +1,7 @@
+
+#include "VULKAN_PixelShader_Common.hlsli"
+
+float4 main(PixelShaderInput input) : SV_TARGET0
+{
+    return GetOutputColor(1.0) * input.color;
+}
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Common.hlsli b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Common.hlsli
new file mode 100644
index 0000000..04ca409
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Common.hlsli
@@ -0,0 +1,181 @@
+SamplerState sampler0 : register(s0);
+Texture2D texture0 : register(t0);
+
+struct PixelShaderInput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+// These should mirror the definitions in SDL_render_vulkan.c
+static const float TONEMAP_NONE = 0;
+static const float TONEMAP_LINEAR = 1;
+static const float TONEMAP_CHROME = 2;
+
+static const float INPUTTYPE_UNSPECIFIED = 0;
+static const float INPUTTYPE_SRGB = 1;
+static const float INPUTTYPE_SCRGB = 2;
+static const float INPUTTYPE_HDR10 = 3;
+
+cbuffer Constants : register(b1)
+{
+    float scRGB_output;
+    float input_type;
+    float color_scale;
+    float unused_pad0;
+
+    float tonemap_method;
+    float tonemap_factor1;
+    float tonemap_factor2;
+    float sdr_white_point;
+};
+
+static const float3x3 mat709to2020 = {
+    { 0.627404, 0.329283, 0.043313 },
+    { 0.069097, 0.919541, 0.011362 },
+    { 0.016391, 0.088013, 0.895595 }
+};
+
+static const float3x3 mat2020to709 = {
+    { 1.660496, -0.587656, -0.072840 },
+    { -0.124547, 1.132895, -0.008348 },
+    { -0.018154, -0.100597, 1.118751 }
+};
+
+float sRGBtoLinear(float v)
+{
+    if (v <= 0.04045) {
+        v = (v / 12.92);
+    } else {
+        v = pow(abs(v + 0.055) / 1.055, 2.4);
+    }
+    return v;
+}
+
+float sRGBfromLinear(float v)
+{
+    if (v <= 0.0031308) {
+        v = (v * 12.92);
+    } else {
+        v = (pow(abs(v), 1.0 / 2.4) * 1.055 - 0.055);
+    }
+    return v;
+}
+
+float3 PQtoLinear(float3 v)
+{
+    const float c1 = 0.8359375;
+    const float c2 = 18.8515625;
+    const float c3 = 18.6875;
+    const float oo_m1 = 1.0 / 0.1593017578125;
+    const float oo_m2 = 1.0 / 78.84375;
+
+    float3 num = max(pow(abs(v), oo_m2) - c1, 0.0);
+    float3 den = c2 - c3 * pow(abs(v), oo_m2);
+    return (10000.0 * pow(abs(num / den), oo_m1) / sdr_white_point);
+}
+
+float3 ApplyTonemap(float3 v)
+{
+    if (tonemap_method == TONEMAP_LINEAR) {
+        v *= tonemap_factor1;
+    } else if (tonemap_method == TONEMAP_CHROME) {
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.2020 colorspace for tone mapping
+            v = mul(mat709to2020, v);
+        }
+
+        float vmax = max(v.r, max(v.g, v.b));
+        if (vmax > 0.0) {
+            float scale = (1.0 + tonemap_factor1 * vmax) / (1.0 + tonemap_factor2 * vmax);
+            v *= scale;
+        }
+
+        if (input_type == INPUTTYPE_SCRGB) {
+            // Convert to BT.709 colorspace after tone mapping
+            v = mul(mat2020to709, v);
+        }
+    }
+    return v;
+}
+
+float4 GetInputColor(PixelShaderInput input)
+{
+    float4 rgba;
+
+    rgba = texture0.Sample(sampler0, input.tex).rgba;
+
+    return rgba;
+}
+
+float4 GetOutputColor(float4 rgba)
+{
+    float4 output;
+
+    output.rgb = rgba.rgb * color_scale;
+    output.a = rgba.a;
+
+    return output;
+}
+
+float3 GetOutputColorFromSRGB(float3 rgb)
+{
+    float3 output;
+
+    if (scRGB_output) {
+        rgb.r = sRGBtoLinear(rgb.r);
+        rgb.g = sRGBtoLinear(rgb.g);
+        rgb.b = sRGBtoLinear(rgb.b);
+    }
+
+    output.rgb = rgb * color_scale;
+
+    return output;
+}
+
+float3 GetOutputColorFromLinear(float3 rgb)
+{
+    float3 output;
+
+    output.rgb = rgb * color_scale;
+
+    if (!scRGB_output) {
+        output.r = sRGBfromLinear(output.r);
+        output.g = sRGBfromLinear(output.g);
+        output.b = sRGBfromLinear(output.b);
+        output.rgb = saturate(output.rgb);
+    }
+
+    return output;
+}
+
+float4 AdvancedPixelShader(PixelShaderInput input)
+{
+    float4 rgba = GetInputColor(input);
+    float4 output;
+
+    if (input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = PQtoLinear(rgba.rgb);
+    }
+
+    if (tonemap_method != TONEMAP_NONE) {
+        rgba.rgb = ApplyTonemap(rgba.rgb);
+    }
+
+    if (input_type == INPUTTYPE_SRGB) {
+        output.rgb = GetOutputColorFromSRGB(rgba.rgb);
+        output.a = rgba.a;
+    } else if (input_type == INPUTTYPE_SCRGB) {
+        output.rgb = GetOutputColorFromLinear(rgba.rgb);
+        output.a = rgba.a;
+    } else if (input_type == INPUTTYPE_HDR10) {
+        rgba.rgb = mul(mat2020to709, rgba.rgb);
+        output.rgb = GetOutputColorFromLinear(rgba.rgb);
+        output.a = rgba.a;
+    } else {
+        output = GetOutputColor(rgba);
+    }
+
+    return output * input.color;
+}
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Textures.h b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Textures.h
new file mode 100644
index 0000000..3b49aab
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Textures.h
@@ -0,0 +1,50 @@
+        // 1113.1.1
+         #pragma once
+static const uint32_t VULKAN_PixelShader_Textures[] = {
+        0x07230203,0x00010000,0x0008000b,0x000000a8,0x00000000,0x00020011,0x00000001,0x0006000b,
+        0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+        0x0008000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000004b,0x0000004e,0x00000052,
+        0x00030010,0x00000004,0x00000007,0x00030003,0x00000005,0x000001f4,0x00040005,0x00000004,
+        0x6e69616d,0x00000000,0x00050005,0x00000018,0x736e6f43,0x746e6174,0x00000073,0x00070006,
+        0x00000018,0x00000000,0x47526373,0x756f5f42,0x74757074,0x00000000,0x00060006,0x00000018,
+        0x00000001,0x75706e69,0x79745f74,0x00006570,0x00060006,0x00000018,0x00000002,0x6f6c6f63,
+        0x63735f72,0x00656c61,0x00060006,0x00000018,0x00000003,0x73756e75,0x705f6465,0x00306461,
+        0x00070006,0x00000018,0x00000004,0x656e6f74,0x5f70616d,0x6874656d,0x0000646f,0x00070006,
+        0x00000018,0x00000005,0x656e6f74,0x5f70616d,0x74636166,0x0031726f,0x00070006,0x00000018,
+        0x00000006,0x656e6f74,0x5f70616d,0x74636166,0x0032726f,0x00070006,0x00000018,0x00000007,
+        0x5f726473,0x74696877,0x6f705f65,0x00746e69,0x00030005,0x0000001a,0x00000000,0x00050005,
+        0x00000036,0x74786574,0x30657275,0x00000000,0x00050005,0x0000004b,0x75706e69,0x65742e74,
+        0x00000078,0x00050005,0x0000004e,0x75706e69,0x6f632e74,0x00726f6c,0x00070005,0x00000052,
+        0x746e6540,0x6f507972,0x4f746e69,0x75707475,0x00000074,0x00050048,0x00000018,0x00000000,
+        0x00000023,0x00000000,0x00050048,0x00000018,0x00000001,0x00000023,0x00000004,0x00050048,
+        0x00000018,0x00000002,0x00000023,0x00000008,0x00050048,0x00000018,0x00000003,0x00000023,
+        0x0000000c,0x00050048,0x00000018,0x00000004,0x00000023,0x00000010,0x00050048,0x00000018,
+        0x00000005,0x00000023,0x00000014,0x00050048,0x00000018,0x00000006,0x00000023,0x00000018,
+        0x00050048,0x00000018,0x00000007,0x00000023,0x0000001c,0x00030047,0x00000018,0x00000002,
+        0x00040047,0x0000001a,0x00000022,0x00000000,0x00040047,0x0000001a,0x00000021,0x00000001,
+        0x00040047,0x00000036,0x00000022,0x00000000,0x00040047,0x00000036,0x00000021,0x00000000,
+        0x00040047,0x0000004b,0x0000001e,0x00000000,0x00040047,0x0000004e,0x0000001e,0x00000001,
+        0x00040047,0x00000052,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,
+        0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,
+        0x00040017,0x0000000d,0x00000006,0x00000002,0x00040017,0x00000015,0x00000006,0x00000003,
+        0x000a001e,0x00000018,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,0x00000006,
+        0x00000006,0x00000006,0x00040020,0x00000019,0x00000002,0x00000018,0x0004003b,0x00000019,
+        0x0000001a,0x00000002,0x00040015,0x0000001b,0x00000020,0x00000001,0x0004002b,0x0000001b,
+        0x0000001c,0x00000002,0x00040020,0x0000001d,0x00000002,0x00000006,0x00090019,0x00000033,
+        0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x0003001b,
+        0x00000034,0x00000033,0x00040020,0x00000035,0x00000000,0x00000034,0x0004003b,0x00000035,
+        0x00000036,0x00000000,0x00040020,0x00000046,0x00000001,0x00000007,0x00040020,0x0000004a,
+        0x00000001,0x0000000d,0x0004003b,0x0000004a,0x0000004b,0x00000001,0x0004003b,0x00000046,
+        0x0000004e,0x00000001,0x00040020,0x00000051,0x00000003,0x00000007,0x0004003b,0x00000051,
+        0x00000052,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,
+        0x00000005,0x0004003d,0x0000000d,0x0000004c,0x0000004b,0x0004003d,0x00000007,0x0000004f,
+        0x0000004e,0x0004003d,0x00000034,0x00000078,0x00000036,0x00050057,0x00000007,0x0000007b,
+        0x00000078,0x0000004c,0x0008004f,0x00000015,0x00000084,0x0000007b,0x0000007b,0x00000000,
+        0x00000001,0x00000002,0x00050041,0x0000001d,0x00000085,0x0000001a,0x0000001c,0x0004003d,
+        0x00000006,0x00000086,0x00000085,0x0005008e,0x00000015,0x00000087,0x00000084,0x00000086,
+        0x00050051,0x00000006,0x00000089,0x00000087,0x00000000,0x00050051,0x00000006,0x0000008b,
+        0x00000087,0x00000001,0x00050051,0x00000006,0x0000008d,0x00000087,0x00000002,0x00050051,
+        0x00000006,0x0000008f,0x0000007b,0x00000003,0x00070050,0x00000007,0x000000a7,0x00000089,
+        0x0000008b,0x0000008d,0x0000008f,0x00050085,0x00000007,0x0000007f,0x000000a7,0x0000004f,
+        0x0003003e,0x00000052,0x0000007f,0x000100fd,0x00010038
+};
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Textures.hlsl b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Textures.hlsl
new file mode 100644
index 0000000..e665291
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_PixelShader_Textures.hlsl
@@ -0,0 +1,7 @@
+
+#include "VULKAN_PixelShader_Common.hlsli"
+
+float4 main(PixelShaderInput input) : SV_TARGET
+{
+    return GetOutputColor(texture0.Sample(sampler0, input.tex)) * input.color;
+}
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_VertexShader.h b/SDL-3.2.8/src/render/vulkan/VULKAN_VertexShader.h
new file mode 100644
index 0000000..76c1c7b
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_VertexShader.h
@@ -0,0 +1,51 @@
+        // 1113.1.1
+         #pragma once
+static const uint32_t VULKAN_VertexShader[] = {
+        0x07230203,0x00010000,0x0008000b,0x000000af,0x00000000,0x00020011,0x00000001,0x0006000b,
+        0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+        0x000c000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000003f,0x00000043,0x00000047,
+        0x00000058,0x0000005b,0x0000005e,0x00000062,0x00030003,0x00000005,0x000001f4,0x00040005,
+        0x00000004,0x6e69616d,0x00000000,0x00060005,0x0000001e,0x68737570,0x736e6f43,0x746e6174,
+        0x00000073,0x00050006,0x0000001e,0x00000000,0x65646f6d,0x0000006c,0x00080006,0x0000001e,
+        0x00000001,0x6a6f7270,0x69746365,0x6e416e6f,0x65695664,0x00000077,0x00060005,0x00000020,
+        0x68737570,0x736e6f43,0x746e6174,0x00000073,0x00050005,0x0000003f,0x75706e69,0x6f702e74,
+        0x00000073,0x00050005,0x00000043,0x75706e69,0x65742e74,0x00000078,0x00050005,0x00000047,
+        0x75706e69,0x6f632e74,0x00726f6c,0x00080005,0x00000058,0x746e6540,0x6f507972,0x4f746e69,
+        0x75707475,0x6f702e74,0x00000073,0x00080005,0x0000005b,0x746e6540,0x6f507972,0x4f746e69,
+        0x75707475,0x65742e74,0x00000078,0x00080005,0x0000005e,0x746e6540,0x6f507972,0x4f746e69,
+        0x75707475,0x6f632e74,0x00726f6c,0x00090005,0x00000062,0x746e6540,0x6f507972,0x4f746e69,
+        0x75707475,0x6f702e74,0x53746e69,0x00657a69,0x00040048,0x0000001e,0x00000000,0x00000005,
+        0x00050048,0x0000001e,0x00000000,0x00000023,0x00000000,0x00050048,0x0000001e,0x00000000,
+        0x00000007,0x00000010,0x00040048,0x0000001e,0x00000001,0x00000005,0x00050048,0x0000001e,
+        0x00000001,0x00000023,0x00000040,0x00050048,0x0000001e,0x00000001,0x00000007,0x00000010,
+        0x00030047,0x0000001e,0x00000002,0x00040047,0x0000003f,0x0000001e,0x00000000,0x00040047,
+        0x00000043,0x0000001e,0x00000001,0x00040047,0x00000047,0x0000001e,0x00000002,0x00040047,
+        0x00000058,0x0000000b,0x00000000,0x00040047,0x0000005b,0x0000001e,0x00000000,0x00040047,
+        0x0000005e,0x0000001e,0x00000001,0x00040047,0x00000062,0x0000000b,0x00000001,0x00020013,
+        0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,
+        0x00000007,0x00000006,0x00000003,0x00040017,0x00000008,0x00000006,0x00000002,0x00040017,
+        0x00000009,0x00000006,0x00000004,0x00040015,0x00000013,0x00000020,0x00000001,0x0004002b,
+        0x00000013,0x00000014,0x00000000,0x0004002b,0x00000006,0x00000018,0x3f800000,0x00040018,
+        0x0000001d,0x00000009,0x00000004,0x0004001e,0x0000001e,0x0000001d,0x0000001d,0x00040020,
+        0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009,0x00040020,
+        0x00000021,0x00000009,0x0000001d,0x0004002b,0x00000013,0x00000026,0x00000001,0x00040020,
+        0x0000003e,0x00000001,0x00000007,0x0004003b,0x0000003e,0x0000003f,0x00000001,0x00040020,
+        0x00000042,0x00000001,0x00000008,0x0004003b,0x00000042,0x00000043,0x00000001,0x00040020,
+        0x00000046,0x00000001,0x00000009,0x0004003b,0x00000046,0x00000047,0x00000001,0x00040020,
+        0x00000057,0x00000003,0x00000009,0x0004003b,0x00000057,0x00000058,0x00000003,0x00040020,
+        0x0000005a,0x00000003,0x00000008,0x0004003b,0x0000005a,0x0000005b,0x00000003,0x0004003b,
+        0x00000057,0x0000005e,0x00000003,0x00040020,0x00000061,0x00000003,0x00000006,0x0004003b,
+        0x00000061,0x00000062,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,
+        0x000200f8,0x00000005,0x0004003d,0x00000007,0x00000040,0x0000003f,0x0004003d,0x00000008,
+        0x00000044,0x00000043,0x0004003d,0x00000009,0x00000048,0x00000047,0x00050051,0x00000006,
+        0x0000006b,0x00000040,0x00000000,0x00050051,0x00000006,0x0000006c,0x00000040,0x00000001,
+        0x00050051,0x00000006,0x0000006d,0x00000040,0x00000002,0x00070050,0x00000009,0x0000006e,
+        0x0000006b,0x0000006c,0x0000006d,0x00000018,0x00050041,0x00000021,0x0000006f,0x00000020,
+        0x00000014,0x0004003d,0x0000001d,0x00000070,0x0000006f,0x00050091,0x00000009,0x00000072,
+        0x00000070,0x0000006e,0x00050041,0x00000021,0x00000073,0x00000020,0x00000026,0x0004003d,
+        0x0000001d,0x00000074,0x00000073,0x00050091,0x00000009,0x00000076,0x00000074,0x00000072,
+        0x00050051,0x00000006,0x00000054,0x00000076,0x00000001,0x0004007f,0x00000006,0x00000055,
+        0x00000054,0x00060052,0x00000009,0x000000ae,0x00000055,0x00000076,0x00000001,0x0003003e,
+        0x00000058,0x000000ae,0x0003003e,0x0000005b,0x00000044,0x0003003e,0x0000005e,0x00000048,
+        0x0003003e,0x00000062,0x00000018,0x000100fd,0x00010038
+};
diff --git a/SDL-3.2.8/src/render/vulkan/VULKAN_VertexShader.hlsl b/SDL-3.2.8/src/render/vulkan/VULKAN_VertexShader.hlsl
new file mode 100644
index 0000000..373a179
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/VULKAN_VertexShader.hlsl
@@ -0,0 +1,45 @@
+#pragma pack_matrix( row_major )
+
+struct VertexShaderConstants
+{
+    matrix model;
+    matrix projectionAndView;
+};
+[[vk::push_constant]]
+ConstantBuffer<VertexShaderConstants> pushConstants;
+
+struct VertexShaderInput
+{
+    float3 pos : POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+};
+
+struct VertexShaderOutput
+{
+    float4 pos : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float4 color : COLOR0;
+    [[vk::builtin("PointSize")]] float pointSize : SV_PointSize;
+};
+
+VertexShaderOutput mainColor(VertexShaderInput input)
+{
+    VertexShaderOutput output;
+    float4 pos = float4(input.pos, 1.0f);
+
+    // Transform the vertex position into projected space.
+    pos = mul(pos, pushConstants.model);
+    pos = mul(pos, pushConstants.projectionAndView);
+    output.pos = pos;
+
+    // Pass through texture coordinates and color values without transformation
+    output.tex = input.tex;
+    output.color = input.color;
+
+    // Always output pointSize so that this VS can be used with points
+    output.pointSize = 1.0;
+
+    return output;
+}
+
diff --git a/SDL-3.2.8/src/render/vulkan/compile_shaders.bat b/SDL-3.2.8/src/render/vulkan/compile_shaders.bat
new file mode 100644
index 0000000..093de82
--- /dev/null
+++ b/SDL-3.2.8/src/render/vulkan/compile_shaders.bat
@@ -0,0 +1,5 @@
+glslangValidator -D --sep main -e main -S frag --target-env vulkan1.0 --auto-sampled-textures --vn VULKAN_PixelShader_Colors -o VULKAN_PixelShader_Colors.h VULKAN_PixelShader_Colors.hlsl
+glslangValidator -D --sep main -e main -S frag --target-env vulkan1.0 --auto-sampled-textures --vn VULKAN_PixelShader_Textures -o VULKAN_PixelShader_Textures.h VULKAN_PixelShader_Textures.hlsl
+glslangValidator -D --sep main -e main -S frag --target-env vulkan1.0 --auto-sampled-textures --vn VULKAN_PixelShader_Advanced -o VULKAN_PixelShader_Advanced.h VULKAN_PixelShader_Advanced.hlsl
+
+glslangValidator -D --sep mainColor -e main -S vert --iy --target-env vulkan1.0 --vn VULKAN_VertexShader -o VULKAN_VertexShader.h VULKAN_VertexShader.hlsl