packages feed

raylib-imgui (empty) → 4.5.0.9

raw patch · 31 files changed

+37842/−0 lines, 31 filesdep +GLFW-bdep +basedep +dear-imgui

Dependencies added: GLFW-b, base, dear-imgui, gl, h-raylib, raylib-imgui

Files

+ CHANGELOG.md view
@@ -0,0 +1,6 @@+# raylib-imgui changelog
+
+## Version 4.5.0.9 (Works with dear-imgui 1.2.2)
+_23 December 2022_
+
+- Initial commit
+ LICENSE view
@@ -0,0 +1,201 @@+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+ README.md view
@@ -0,0 +1,36 @@+# raylib-imgui: Haskell bindings for rlImGui
+
+This package provides bindings to rlImGui allowing raylib and dear-imgui interop.
+
+## Usage
+
+Add the following in your `.cabal` file:
+
+```cabal
+...
+build-depends:
+  , base
+  , dear-imgui==1.2.2
+  , gl
+  , GLFW-b
+  , h-raylib
+  , raylib-imgui==4.5.0.9
+...
+```
+
+**NOTE: Each version of raylib-imgui requires a specific version of dear-imgui. raylib-imgui 4.5.0.9 requires dear-imgui 1.2.2**
+
+And in your `cabal.project` file add the following:
+
+```
+package dear-imgui
+  flags: -sdl +glfw +opengl3
+```
+
+This is required because raylib uses GLFW rather than SDL.
+
+See the `example` directory in the source for example code.
+
+## See also
+- [dear-imgui.hs](https://github.com/haskell-game/dear-imgui.hs#dear-imguihs) for Dear ImGui setup
+- [h-raylib](https://github.com/Anut-py/h-raylib#h-raylib-haskell-bindings-for-raylib) for rayllib setup
+ example/Main.hs view
@@ -0,0 +1,36 @@+module Main where
+
+import Raylib.Types (ConfigFlag(Msaa4xHint, VsyncHint))
+import Raylib (setConfigFlags, initWindow, setTargetFPS, beginDrawing, clearBackground, closeWindow, endDrawing, windowShouldClose)
+import Raylib.ImGui (rlImGuiSetup, rlImGuiShutdown, rlImGuiBegin, rlImGuiEnd)
+import Raylib.Colors (darkGray)
+import DearImGui (showDemoWindow)
+import Control.Monad (unless)
+
+main :: IO ()
+main = do
+  setConfigFlags [Msaa4xHint, VsyncHint]
+  initWindow 1280 800 "rlImGui - simple window"
+  setTargetFPS 44
+  rlImGuiSetup True
+
+  loop
+
+  rlImGuiShutdown
+  closeWindow
+
+loop :: IO ()
+loop = do
+  beginDrawing
+  clearBackground darkGray
+
+  rlImGuiBegin
+
+  showDemoWindow
+
+  rlImGuiEnd
+
+  endDrawing
+
+  shouldClose <- windowShouldClose
+  unless shouldClose loop
+ lib/wrapper.cpp view
@@ -0,0 +1,5 @@+#include "wrapper.h"
+
+void rlImGuiImageRect_(const Texture *image, int destWidth, int destHeight, Rectangle *sourceRect) {
+    rlImGuiImageRect(image, destWidth, destHeight, *sourceRect);
+}
+ lib/wrapper.h view
@@ -0,0 +1,3 @@+#include "rlImGui.h"
+
+void rlImGuiImageRect_(const Texture *image, int destWidth, int destHeight, Rectangle *sourceRect);
+ raylib-imgui.cabal view
@@ -0,0 +1,66 @@+cabal-version:      2.4
+name:               raylib-imgui
+version:            4.5.0.9
+synopsis:           Haskell bindings for rlImGui
+description:
+  This package contains simple bindings to the functions defined in rlImGui, allowing raylib and Dear ImGui interop
+
+category:           graphics
+
+bug-reports:        https://github.com/Anut-py/raylib-imgui/issues
+license:            Apache-2.0
+license-file:       LICENSE
+author:             Anut
+maintainer:         Anut
+extra-doc-files:    README.md
+extra-source-files:
+  CHANGELOG.md
+  lib/wrapper.h
+  rlImGui/*.h
+  rlImGui/extras/*.h
+  rlImGui/imgui/*.h
+  rlImGui/raylib/src/*.h
+  rlImGui/raylib/src/external/glfw/include/GLFW/*.h
+
+flag example
+  description: Build example project
+  default:     False
+  manual:      True
+
+executable example
+  hs-source-dirs:   example
+  default-language: Haskell2010
+  main-is:          Main.hs
+
+  if !flag(example)
+    buildable: False
+
+  else
+    build-depends:
+      , base
+      , dear-imgui    ==1.2.2
+      , gl
+      , GLFW-b
+      , h-raylib
+      , raylib-imgui
+
+-- This version of rlImGui only works with dear-imgui version 1.2.2
+library
+  exposed-modules:  Raylib.ImGui
+  build-depends:
+    , base      >=4.0     && <4.17.0
+    , h-raylib  ==4.5.0.9
+
+  hs-source-dirs:   src
+  default-language: Haskell2010
+  cxx-options:      -std=c++11
+  cxx-sources:
+    lib/wrapper.cpp
+    rlImGui/rlImGui.cpp
+
+  include-dirs:
+    lib
+    rlImGui
+    rlImGui/imgui
+    rlImGui/raylib/src
+    rlImGui/raylib/src/external/glfw/include
+ rlImGui/extras/FA6FreeSolidFontData.h view
@@ -0,0 +1,4973 @@+// File: 'fa-solid-900.ttf' (388460 bytes)
+// Exported using binary_to_compressed_c.cpp
+static const unsigned int fa_solid_900_compressed_size = 238367;
+static const unsigned int fa_solid_900_compressed_data[238368 / 4] =
+{
+    0x0000bc57, 0x00000000, 0x6ced0500, 0x00000400, 0x00010037, 0x000a0000, 0x00030080, 0x2f534f20, 0x624b6132, 0x0100004a, 0x08158228, 0x6d636028,
+    0x65aa7061, 0x0000ee77, 0x00003017, 0x6c67be47, 0x45da6679, 0x0000c1e9, 0x05009c74, 0x65682828, 0x5e216461, 0x2b829870, 0x0382ac20, 0x82683621,
+    0x42042310, 0x0b82a907, 0x0382e420, 0x6d682428, 0x4be27874, 0x4f82760f, 0x00008830, 0x6f6ca815, 0xdc0d6163, 0x0000a0e0, 0x0f82f05e, 0x616dac28,
+    0x81057078, 0x1f827c01, 0x2f820820, 0x6e202008, 0xb5656d61, 0x00e9d029, 0x00c49c05, 0x70ed0300, 0x7674736f, 0x00b7464a, 0x00b4a005, 0x83b74c00,
+    0x01032fab, 0x1e4c0003, 0x0f5f1f08, 0x0b00f53c, 0x00830002, 0x965fde23, 0x2507898d, 0x8002c0ff, 0x0f82c001, 0x02000822, 0x09823183, 0x00000125,
+    0x82ffc001, 0x80022713, 0xfeffffff, 0x17868002, 0x02851a82, 0x836a0521, 0x6a052511, 0x15007a01, 0x01201184, 0x01200582, 0x0426258c, 0x84030202,
+    0x49820500, 0x66014c22, 0x47211d82, 0x25078501, 0x001900f5, 0x6a820084, 0x82030921, 0x21028515, 0x07851001, 0x41290584, 0x004d5357, 0xff210080,
+    0x238385ff, 0x4000c001, 0x01201882, 0x00240382, 0xa5013901, 0x202c0782, 0x80010000, 0x80000000, 0xc0011800, 0x40240b82, 0x80011000, 0xc0240782,
+    0xc0011900, 0x2f820b82, 0x07839084, 0x1b830383, 0x078b0b87, 0x3b853385, 0x02211782, 0x20478600, 0x824b8240, 0x875384f9, 0x00c0222f, 0x850f8c01,
+    0x82202017, 0x848b846f, 0x85138307, 0x2013838f, 0x202f841f, 0x824b8380, 0x855384ef, 0x2117830b, 0x13820002, 0x17850020, 0x1b820220, 0x2f820f88,
+    0x03830220, 0x20004022, 0x1b831384, 0x1b870f87, 0x438b0787, 0x00203789, 0x7b873f83, 0x00000223, 0x215b8710, 0x0b82c001, 0x13864393, 0xc020c384,
+    0x0f879389, 0xeb850120, 0x4f83e788, 0x57871383, 0x3383078b, 0x01201f87, 0x3784b785, 0xeb860220, 0x13830120, 0x00000022, 0x1f865384, 0x23411b88,
+    0x8701200e, 0x8e9f8a97, 0x410020db, 0x00200c23, 0x53875782, 0x87844b82, 0x1020cf85, 0x1383af84, 0x0f840386, 0x33858b87, 0x82010521, 0x824f843f,
+    0x8cc787ab, 0x865b8be3, 0x4102203b, 0x23870f4f, 0x738a1787, 0xcb410220, 0x84102005, 0x00002233, 0x895b8421, 0x88082047, 0x22bb8773, 0x82200040,
+    0x022022a7, 0x06b74140, 0x80221783, 0x3f822000, 0x13820389, 0xe3850120, 0x8b970020, 0x42800121, 0x2388097f, 0x0b41e38f, 0x844b840d, 0x8ff38b57,
+    0x099b42cb, 0x200f7342, 0x85db8809, 0x201f84af, 0x853f9302, 0x86222013, 0x8420202f, 0x1f534123, 0xd3431f8f, 0x213f820a, 0x03420120, 0x0733420e,
+    0xf3820220, 0xe7415f84, 0x00802207, 0x070f4103, 0x8a0b0f42, 0x820020bb, 0x411f202f, 0xef870833, 0x08205f89, 0x13821b88, 0x00c00122, 0x0321e783,
+    0x859f8501, 0x83f393cb, 0x82178277, 0x8420202f, 0x200b829b, 0x0baf4202, 0x40229f87, 0x8b8c0f00, 0x00205783, 0x7b88b389, 0xb3430020, 0x10634109,
+    0x420d2b41, 0x1b870d3b, 0x0b873f83, 0xe7860783, 0x6f850120, 0x00021023, 0x44038400, 0xe782080f, 0x1b421b84, 0x200f8d0f, 0x20db8c07, 0x87a38240,
+    0x097f4167, 0x8d15b342, 0x020021b3, 0x2020df85, 0x0021ef84, 0x08334100, 0x44800121, 0xa74309db, 0x46402008, 0xb7430513, 0x843f820c, 0x828387bb,
+    0x0002210f, 0x0f853b82, 0x7b410e20, 0x85078807, 0x0220211f, 0x01212386, 0x24bb86c0, 0x01000000, 0x41038240, 0x002005e7, 0x078b1787, 0x47430120,
+    0x077b4406, 0x13840f83, 0x43413786, 0x2457850c, 0x00000210, 0x8643841a, 0x822f849f, 0x80012183, 0x7783df89, 0x13820220, 0x01200383, 0x87846382,
+    0x5f876b8b, 0x20050b43, 0x8fff8f40, 0x8287880f, 0x21a38343, 0xd7850002, 0x33461786, 0x20178708, 0x06134202, 0x0b830f83, 0x41c00121, 0x0b820a13,
+    0x13840f83, 0x18008023, 0x06cb4202, 0x53450783, 0x4383880b, 0x40200777, 0xd3822b82, 0x83830120, 0x07434f87, 0x8657880e, 0x83c78fdf, 0x2023820f,
+    0x93038320, 0x2013821b, 0x82179001, 0x8002236f, 0x03821200, 0x8608c341, 0x41042047, 0x8f850817, 0x40021024, 0x1b862700, 0x20058742, 0x83f78200,
+    0x0a73443f, 0x13820120, 0x40200382, 0x178a2784, 0x10207786, 0x33861784, 0x21071b41, 0xdb418001, 0x858b8506, 0x47402087, 0x012105f3, 0x436386c0,
+    0x00220f9f, 0x9f8b2000, 0xbf41f784, 0x85012006, 0x01202183, 0xdb870f86, 0x10200f82, 0x82084341, 0x140b4123, 0x0221b382, 0x837b8240, 0x06ff4307,
+    0x85c00121, 0x208b879f, 0x0aef4100, 0x07204382, 0x0121db83, 0x06974680, 0x0f000022, 0x5f932784, 0xbb411383, 0x2327820a, 0x00800008, 0x840ceb46,
+    0x84b7869f, 0x42c0200b, 0x4742058b, 0x24138b07, 0x20008001, 0x0d674901, 0x8b860020, 0x82010021, 0x209b8643, 0x20cf8208, 0x20038207, 0x220f8808,
+    0x41000000, 0x0b830b9f, 0x20200f92, 0xef8a1788, 0x2b426f83, 0x0a97410c, 0x41078b43, 0x9b820857, 0xaf410b8a, 0x84338209, 0x88079a2b, 0x057f4437,
+    0xf7860020, 0xc3419384, 0x82012017, 0x0747484f, 0x41079345, 0x40210c8b, 0x45838400, 0x8f410843, 0x41022006, 0x202009eb, 0x01240b83, 0x020000c0,
+    0xbf871383, 0x01200782, 0x5f871383, 0x47824020, 0x10008027, 0xffffc001, 0x23078201, 0x60000002, 0x0b835384, 0x26090f41, 0x00800120, 0x8680020f,
+    0x0ee3422b, 0x4a089342, 0x73880a63, 0x20073743, 0x82878600, 0x41c78853, 0xc0211333, 0x08ab4100, 0x40208784, 0x2020e788, 0x13846783, 0x3f424386,
+    0x4902200b, 0x00220753, 0x0b820600, 0x00020024, 0xbb41ffff, 0xc0012107, 0x83827b86, 0x4f8b0b8b, 0x0f422b87, 0x86638208, 0x42202013, 0x1f4408af,
+    0x01102309, 0x038c0040, 0x6f4a6b8c, 0x451f2015, 0x0782078b, 0xbb831020, 0xc74b0786, 0x850f8208, 0x062f46fb, 0x40215388, 0x843b8400, 0x450b833f,
+    0x01210633, 0x82d78280, 0x148b45e7, 0x8b87eb87, 0x07412b82, 0x11bf4c0c, 0x80011022, 0x0386d382, 0x47420220, 0x83638506, 0x050b4467, 0x8a0c3f41,
+    0x820220e7, 0x10e7424f, 0xc022a787, 0x4f430000, 0x860b830b, 0x2073832f, 0x07e74200, 0x8b413f8f, 0x060f4108, 0x774c0120, 0x410b880a, 0x674407db,
+    0x078b450a, 0x378f0788, 0x200b8748, 0x20db8200, 0x092b4280, 0x80228b90, 0x13820e00, 0x93490120, 0x4300200c, 0x9b830a53, 0x8a062b41, 0x057f4a23,
+    0x9006a741, 0x202f85d7, 0x0aa34a07, 0x77421020, 0x1127490c, 0x8305fb42, 0x49002017, 0x3b880527, 0xcf8fff83, 0x0b83938b, 0x4109c743, 0x4020096b,
+    0x4743f382, 0x82012012, 0x2103864f, 0x37440210, 0x82c7840e, 0x85012013, 0x84042073, 0x440f8783, 0x6f440977, 0x201b8509, 0x08f74210, 0x8b890f83,
+    0xcb430420, 0x00002208, 0x148b4300, 0x0f004022, 0x00201788, 0x20095747, 0x060f4201, 0x42081f43, 0x0220065f, 0x00238387, 0x86012000, 0x211382db,
+    0x1f82011f, 0x20080b42, 0x84478400, 0x10b34293, 0x4f434020, 0x0a1b4306, 0x01206383, 0x07830f86, 0x07844783, 0x03000022, 0x03240b82, 0xffff0002,
+    0x5f415b8a, 0x172f4705, 0x5f821797, 0x4a0f2342, 0x402010d7, 0x9009334a, 0x82578fb7, 0x419384fb, 0x63830e27, 0x1b830120, 0x01212f86, 0x22ef83c0,
+    0x82020200, 0x08f74206, 0x17861f82, 0x87092b42, 0x00802333, 0x538f0201, 0x4505974b, 0x1f8309b3, 0x20098741, 0x080b4d00, 0x21066748, 0x7f484001,
+    0x0000210a, 0x84085b45, 0x4c00207f, 0x3f43084b, 0x42b38408, 0xa749056f, 0x0b33420d, 0x00220b83, 0x438c1300, 0x4e0e0f47, 0xc3450807, 0x49002009,
+    0x4f860c8f, 0x8b410120, 0x21f39212, 0x53420110, 0x079b4507, 0x97438020, 0x0ecf420a, 0x4a085343, 0xb3850b13, 0x40020022, 0x200c0341, 0x0a434410,
+    0x86095b4f, 0x20738acb, 0x430b8520, 0x338405c3, 0x89000021, 0x0acf4493, 0x73820120, 0x20202b82, 0x4020d784, 0x84096743, 0x0a27420f, 0x00201f88,
+    0x820aa34a, 0x213b820b, 0x37820210, 0x22082b41, 0x460c0040, 0x9741081b, 0x8e2f820f, 0x500020cf, 0xe78406d3, 0x8b0ccb4b, 0x06174153, 0x37470220,
+    0x86278213, 0x0c1b477f, 0x8b075341, 0x088b4333, 0xc78e4f83, 0x00000224, 0xaf820100, 0x87420020, 0x49378d06, 0x01200523, 0x09201b89, 0x8b411f82,
+    0x20938605, 0x84538201, 0x41238703, 0x3b480a4b, 0x056f410c, 0x13830020, 0x6341a384, 0x880b8306, 0x203b8227, 0x86178301, 0x862b845b, 0x200b8227,
+    0x212b8210, 0x7b450220, 0x8e0f840a, 0x424b872f, 0x8b41085b, 0x8c278207, 0x41478313, 0x6f410f57, 0x02072309, 0x534b0000, 0x0ecf4611, 0x7b8a0120,
+    0x0f820b84, 0x00000023, 0x20038204, 0x20038203, 0x82038224, 0x3218250b, 0x01000300, 0x032e0f84, 0x00000a00, 0x04003218, 0x00000e18, 0x1c828e05,
+    0x01099c0d, 0x0021008e, 0x002b0025, 0x005a0039, 0x00620061, 0x00640063, 0x00660065, 0x00680067, 0x006a0069, 0x006c006b, 0x006e006d, 0x0070006f,
+    0x00720071, 0x00740073, 0x00760075, 0x00780077, 0x007a0079, 0x00a500a3, 0x00ab00a9, 0x00b600ae, 0x00d700bb, 0x201320f7, 0x201d201c, 0x203a2039,
+    0x20a820a4, 0x20aa20a9, 0x20b420ac, 0x21bd20b8, 0x21902122, 0x21922191, 0x21942193, 0x21972195, 0x21bb21ba, 0x221222c4, 0x2303231e, 0x231b2304,
+    0x23292328, 0x232b232a, 0x23cf2399, 0x23ea23e9, 0x23ee23ed, 0x23f323f1, 0x23f923f8, 0x24fe23fb, 0x25a025bd, 0x25cf25b6, 0x25fb25d0, 0x260026fc,
+    0x26032601, 0x26112604, 0x261d2615, 0x26222620, 0x26252623, 0x262c262a, 0x262f262e, 0x26392638, 0x2640263f, 0x265a2642, 0x265c265b, 0x265e265d,
+    0x2665265f, 0x26722666, 0x267b267a, 0x2680267e, 0x26822681, 0x26842683, 0x26932685, 0x26992696, 0x26a0269b, 0x26a226a1, 0x26a426a3, 0x26a626a5,
+    0x26a826a7, 0x26aa26a9, 0x26b226ab, 0x26be26bd, 0x26c526c4, 0x26df26c6, 0x26ea26e9, 0x26fa26f7, 0x270027fd, 0x27042702, 0x27092705, 0x270b270a,
+    0x270f270c, 0x27122711, 0x27142713, 0x27162715, 0x2721271d, 0x27442731, 0x274c2746, 0x2753274e, 0x27552754, 0x27642757, 0x27962795, 0x29342997,
+    0x2b0d2b35, 0x2b1c2b1b, 0xe0502b24, 0xe00de006, 0xe041e012, 0xe086e076, 0xe09ae098, 0xe0ace0a9, 0xe0b7e0b4, 0xe0d8e0bb, 0xe1e4e0df, 0xe13ce131,
+    0xe152e140, 0xe169e163, 0xe17be16d, 0xe18fe185, 0xe1a8e19b, 0xe1bce1b0, 0xe1c8e1c4, 0xe1d5e1d3, 0xe1ede1d7, 0xe2f6e1f3, 0xe222e209, 0xe23de22d,
+    0xe29ce289, 0xe2bbe2b7, 0xe2cae2c5, 0xe3ebe2ce, 0xe3afe31e, 0xe4f5e3b2, 0xe43ce433, 0xe448e445, 0xe473e46c, 0xe47be477, 0xe494e490, 0xe4ade4a5,
+    0xe4b3e4b0, 0xe4dee4cc, 0xe5ebe4e6, 0xe525e503, 0xe54fe52f, 0xe56fe558, 0xe587e574, 0xe59ae58f, 0xf002f09d, 0xf005f003, 0xf00ef006, 0xf014f013,
+    0xf016f015, 0xf01af019, 0xf01cf01b, 0xf01ef01d, 0xf040f03e, 0xf045f044, 0xf04ef046, 0xf05cf05b, 0xf05ef05d, 0xf067f066, 0xf069f068, 0xf07ef06e,
+    0xf086f080, 0xf088f087, 0xf08af089, 0xf08ef08b, 0xf095f091, 0xf097f096, 0xf09ef098, 0xf0a2f0a1, 0xf0b2f0ae, 0xf0d1f0ce, 0xf0e0f0de, 0xf0e4f0e3,
+    0xf0e6f0e5, 0xf0f4f0ee, 0xf0f6f0f5, 0xf1fef0f7, 0xf108f107, 0xf10cf10b, 0xf111f10e, 0xf114f112, 0xf11cf115, 0xf11ef11d, 0xf123f122, 0xf128f127,
+    0xf12af129, 0xf135f12e, 0xf13ef13a, 0xf147f146, 0xf154f14e, 0xf159f155, 0xf165f15e, 0xf183f178, 0xf18ef188, 0xf193f190, 0xf196f195, 0xf199f197,
+    0xf1aef19d, 0xf1b1f1b0, 0xf1bbf1b3, 0xf1cef1c9, 0xf1d9f1d8, 0xf1dbf1da, 0xf1e6f1de, 0xf1f6f1ec, 0xf1f9f1f7, 0xf2fef1fa, 0xf207f201, 0xf21ef20b,
+    0xf236f22d, 0xf249f239, 0xf24ef24a, 0xf25df250, 0xf277f26c, 0xf27af278, 0xf283f27b, 0xf28cf28b, 0xf28ef28d, 0xf292f291, 0xf29af295, 0xf29ef29c,
+    0xf2a8f2a4, 0xf2b7f2b6, 0xf2baf2b9, 0xf2bcf2bb, 0xf2bef2bd, 0xf2c2f2c0, 0xf2cef2c3, 0xf2d4f2d3, 0xf2e5f2dc, 0xf2eaf2e7, 0xf2f2f2ed, 0xf2f9f2f6,
+    0xf305f3fe, 0xf31cf30c, 0xf328f31e, 0xf338f332, 0xf35df35b, 0xf363f360, 0xf382f381, 0xf390f387, 0xf3bff3a5, 0xf3c5f3c1, 0xf3cff3c9, 0xf3ddf3d1,
+    0xf3e5f3e0, 0xf3fbf3ed, 0xf4fff3fd, 0xf410f406, 0xf424f422, 0xf436f434, 0xf43cf43a, 0xf441f43f, 0xf445f443, 0xf44bf447, 0xf450f44e, 0xf458f453,
+    0xf45ff45d, 0xf466f462, 0xf472f46d, 0xf479f474, 0xf47ff47d, 0xf487f482, 0xf48ef48b, 0xf497f494, 0xf4a1f49e, 0xf4b3f4ad, 0xf4bef4ba, 0xf4c4f4c2,
+    0xf4cef4c6, 0xf4dbf4d3, 0xf4e3f4df, 0xf509f5e6, 0xf52cf52b, 0xf531f530, 0xf536f535, 0xf541f540, 0xf59df591, 0xf5a7f5a2, 0xf5b4f5b1, 0xf5bdf5b8,
+    0xf5cbf5c5, 0xf5d2f5ce, 0xf5daf5d7, 0xf5dff5dc, 0xf5e4f5e1, 0xf5ebf5e7, 0xf6fdf5ee, 0xf604f601, 0xf613f610, 0xf61ff619, 0xf625f621, 0xf630f62a,
+    0xf63cf637, 0xf644f641, 0xf64af647, 0xf651f64f, 0xf658f655, 0xf662f65e, 0xf66bf666, 0xf66ff66d, 0xf676f674, 0xf67cf679, 0xf684f67f, 0xf696f689,
+    0xf6a1f69b, 0xf6a9f6a7, 0xf6b7f6ad, 0xf6bef6bb, 0xf6c4f6c0, 0xf6cff6c8, 0xf6d3f6d1, 0xf6d7f6d5, 0xf6def6d9, 0xf6e6f6e3, 0xf6edf6e8, 0xf6faf6f2,
+    0xf700f7fc, 0xf70ef70c, 0xf717f715, 0xf722f71e, 0xf72bf729, 0xf73df72f, 0xf743f740, 0xf74df747, 0xf756f753, 0xf75ff75b, 0xf76cf769, 0xf773f770,
+    0xf781f77d, 0xf788f784, 0xf794f78c, 0xf79cf796, 0xf7a2f7a0, 0xf7abf7a6, 0xf7b6f7ae, 0xf7bdf7ba, 0xf7c2f7c0, 0xf7caf7c5, 0xf7d0f7ce, 0xf7daf7d2,
+    0xf7ecf7e6, 0xf7f3f7ef, 0xf7f7f7f5, 0xf802f8fb, 0xf80af807, 0xf80cf80b, 0xf810f80d, 0xf816f812, 0xf81df818, 0xf82ff82a, 0xf84af83e, 0xf850f84c,
+    0xf85ef853, 0xf86df863, 0xf87df879, 0xf887f882, 0xf897f891, 0xf8ccf8c1, 0xf8d9f8d7, 0xf8eff8e5, 0x00ffffff, 0x00210000, 0x002a0023, 0x103c0030,
+    0x7c018f05, 0x0de0052c, 0x3fe012e0, 0x85e059e0, 0x8f4597e0, 0xe1e32410, 0x4539e131, 0x84240c8f, 0x9ae18fe1, 0x20188f45, 0x108f4521, 0x8f45cd20,
+    0xb1480806, 0x33e4f5e3, 0x45e43be4, 0x6ce447e4, 0x76e473e4, 0x90e47ae4, 0xa5e493e4, 0xafe4a8e4, 0xb5e4b3e4, 0xe0e4cee4, 0xede4e8e4, 0x27e507e5,
+    0x51e532e5, 0x71e55ae5, 0x89e576e5, 0x9ce591e5, 0x03f000f0, 0x06f004f0, 0x10f007f0, 0x20068f45, 0x0a8f4517, 0x40f0212c, 0x45f041f0, 0x47f046f0,
+    0x8f4550f0, 0x45602006, 0x6a26068f, 0x80f070f0, 0x8f4583f0, 0xf08d240a, 0x4593f090, 0x9c32068f, 0xa2f0a0f0, 0xb0f0a3f0, 0xd0f0c0f0, 0xe0f0d6f0,
+    0x8f45e2f0, 0xf0e72206, 0x068f45f0, 0x00f1f82c, 0x09f108f1, 0x0df10cf1, 0x8f4510f1, 0xf1182a06, 0xf11ef11d, 0xf123f120, 0x068f4524, 0xf12b2208,
+    0xf137f130, 0xf140f13d, 0xf148f147, 0xf155f150, 0xf15bf156, 0xf175f160, 0xf185f182, 0xf190f18e, 0x088f4591, 0xabf19c2e, 0xb1f1b0f1, 0xb8f1b2f1,
+    0xcdf1c0f1, 0x08088f45, 0xe0f1dc2e, 0xf6f1eaf1, 0xf8f1f7f1, 0xfbf1faf1, 0x04f200f2, 0x17f20af2, 0x33f221f2, 0x40f238f2, 0x4df24af2, 0x51f250f2,
+    0x71f26cf2, 0x79f278f2, 0x200c8f45, 0x088f4590, 0xa0f29d26, 0xb4f2a7f2, 0x2a108f45, 0xf2c3f2c1, 0xf2d0f2c7, 0x45dbf2d4, 0xf12a088f, 0xf9f2f5f2,
+    0x02f3fef2, 0x8f4509f3, 0xf3373408, 0xf35df358, 0xf362f360, 0xf382f381, 0xf390f386, 0x45bef3a5, 0xcd20068f, 0x200a8f45, 0x0c8f45fa, 0x36f43224,
+    0x8f4539f4, 0xf45c3e16, 0xf461f45f, 0xf468f466, 0xf474f470, 0xf47df477, 0xf481f47e, 0xf48bf484, 0xf490f48d, 0x088f4596, 0xf4b83e08, 0xf4c0f4bd,
+    0xf4c6f4c4, 0xf4d3f4cd, 0xf4def4d6, 0xf4e6f4e2, 0xf515f5fa, 0xf52df52c, 0xf532f531, 0xf537f536, 0xf542f541, 0xf59ff593, 0xf5aaf5a4, 0xf5b6f5b3,
+    0xf5bff5ba, 0xf5cdf5c7, 0x068f45d0, 0x8f45de20, 0x45fc200a, 0x24280e8f, 0x2ef629f6, 0x3bf637f6, 0x2a0c8f45, 0xf658f653, 0xf662f65d, 0x4569f664,
+    0x782e088f, 0x7ff67bf6, 0x87f681f6, 0x98f696f6, 0x8f45a0f6, 0x45b62006, 0xc320068f, 0x360e8f45, 0xf6e2f6dd, 0xf6e8f6e6, 0xf6f0f6ec, 0xf6fcf6fa,
+    0xf70bf7ff, 0x4514f70e, 0x2826068f, 0x2ef72bf7, 0x8f453bf7, 0x51500808, 0x5af756f7, 0x69f75ef7, 0x6ff76bf7, 0x7cf772f7, 0x83f780f7, 0x8cf786f7,
+    0x96f793f7, 0x9ff79cf7, 0xa4f7a2f7, 0xadf7a9f7, 0xb9f7b5f7, 0xbff7bdf7, 0xc4f7c2f7, 0xccf7c9f7, 0xd2f7d0f7, 0xe4f7d7f7, 0xeff7ecf7, 0xf5f7f2f7,
+    0xfaf7f7f7, 0x05f802f8, 0x2a088f45, 0xf812f80f, 0xf818f815, 0x4528f81d, 0x7b2a148f, 0x84f881f8, 0x97f891f8, 0x8f45c0f8, 0xe0ff2a0d, 0xdbffdfff,
+    0xd5ffd7ff, 0x00001000, 0xab087a01, 0x25202b20, 0xf51f2120, 0xd01fde1f, 0xbf1fc01f, 0xaf1fb11f, 0xa61fa81f, 0x871fa31f, 0x7e1f811f, 0x2b1f321f,
+    0x171f281f, 0x021f071f, 0xf21eff1e, 0xe11eea1e, 0xcb1ed71e, 0xb91ec41e, 0xaf1eb21e, 0xa41ea51e, 0x8e1ea31e, 0x871e891e, 0x5e1e751e, 0x451e541e,
+    0xe81dfa1d, 0xcb1dce1d, 0xbe1dc21d, 0xa01dbc1d, 0xde1c6e1d, 0x9b1cdd1c, 0x571c5e1c, 0x4e1c4f1c, 0x251c2b1c, 0x211c231c, 0x0b1c0d1c, 0xf91bfb1b,
+    0xf61bf81b, 0xf41bf51b, 0xf21bf31b, 0xee1bf11b, 0xeb1bed1b, 0xe91bea1b, 0xe71be81b, 0xe51be61b, 0x8211e41b, 0x81110000, 0x80220382, 0x05827f11,
+    0x03827e20, 0x82007d21, 0x7b112700, 0x7a110000, 0x05827811, 0x0e827620, 0x74110024, 0x07847311, 0x70117126, 0x6f110000, 0x6e260382, 0x6c116d11,
+    0x15846a11, 0x0000682a, 0x66116711, 0x64116511, 0x62340f84, 0x5e115f11, 0x5d110000, 0x4f115c11, 0x4a114e11, 0x48114911, 0x13821983, 0x44114522,
+    0x41260986, 0x00004011, 0x03823f11, 0x3d113e22, 0x37201386, 0x36220d82, 0x05823511, 0x03823420, 0x03823320, 0x31113228, 0x2e113011, 0x0b822d11,
+    0x2b112c22, 0x2a2a0582, 0x28112911, 0x10111911, 0x35830f11, 0x1107113b, 0x11000006, 0x11041105, 0x10f51002, 0x100000f4, 0x10ef10f3, 0x10e810eb,
+    0x200b82df, 0x260382de, 0x10dc10dd, 0x82d010d9, 0x82cf2009, 0x10ce3003, 0x10cb10cd, 0x10be10c9, 0x10b710bc, 0x82b010b6, 0x82ad2013, 0x10ab2403,
+    0x8299109d, 0x83982007, 0x88102555, 0x87100000, 0x85200382, 0x7d2a0d84, 0x7b100000, 0x78107a10, 0x09826d10, 0x03826b20, 0x03826a20, 0x1b846920,
+    0x00006626, 0x61106210, 0x5a3a0582, 0x51105210, 0x4d104f10, 0x48104a10, 0x42104610, 0x3c103f10, 0x2c102d10, 0x1d822310, 0xf60f1528, 0xf30ff50f,
+    0x3583f20f, 0x0fd00f3a, 0x0fb40fc8, 0x0f9b0f9c, 0x0f950f98, 0x0f910f92, 0x0f840f86, 0x0f790f80, 0x61086182, 0x640f6a0f, 0x4a0f5b0f, 0x3c0f490f,
+    0x390f3b0f, 0x360f380f, 0x340f350f, 0x320f330f, 0x2d0f2f0f, 0x2a0f2c0f, 0x230f260f, 0x210f220f, 0x1d0f1e0f, 0x1a0f1b0f, 0x0000180f, 0x130f140f,
+    0x0f0f120f, 0x0d0f0e0f, 0x060f0c0f, 0xf80e0000, 0xef0ef30e, 0xec0eed0e, 0xea0eeb0e, 0xe00ee40e, 0xdc0ede0e, 0x1982da0e, 0xb90ec422, 0xb8200582,
+    0xb7200382, 0xb6200382, 0x11090382, 0x0eb40eb5, 0x0eb20eb3, 0x0eaf0eb0, 0x0ead0eae, 0x0eab0eac, 0x0ea90eaa, 0x0ea30ea5, 0x0ea10ea2, 0x0e9e0ea0,
+    0x0e990e9c, 0x0e8a0e97, 0x0e850e87, 0x0e780e7a, 0x0e6e0e73, 0x0e6b0e6d, 0x0e650e68, 0x0e5c0e5f, 0x0e560e58, 0x0e520e54, 0x0e4d0e4e, 0x0e4a0e4c,
+    0x0e430e46, 0x0e400e42, 0x0e3e0e3f, 0x0e390e3a, 0x0e370e38, 0x0e340e35, 0x0e260e32, 0x0e210e25, 0x0e1b0e1c, 0x0e100e18, 0x0e0b0e0d, 0x0e080e0a,
+    0x0dff0d05, 0x0dfd0dfe, 0x0dfb0dfc, 0x0df70dfa, 0x0df20df4, 0x0dee0df1, 0x0de50dec, 0x0de20de4, 0x0dd70dd8, 0x0dd10dd2, 0x0dc80dcb, 0x0dc20dc3,
+    0x0db50dc0, 0x0db10db3, 0x0da90dae, 0x0da40da6, 0x0d9f0da1, 0x0d950d96, 0x0d920d93, 0x0d880d8a, 0x0d860d87, 0x0d7d0d83, 0x0d770d7c, 0x0d740d75,
+    0x0d710d73, 0x0d6a0d70, 0x0d660d68, 0x0d640d65, 0x0d600d63, 0x0d5e0d5f, 0x0d590d5d, 0x0d4b0d50, 0x0d470d49, 0x0d450d46, 0x0d3d0d43, 0x0084003b,
+    0x360d3b08, 0x340d350d, 0x310d320d, 0x230d2d0d, 0x110d1f0d, 0x050d060d, 0x000d020d, 0xf20cf60c, 0xde0ce90c, 0xda0cdd0c, 0xd00cd90c, 0xa30ccb0c,
+    0x8f0c990c, 0x00008e0c, 0x6a0c790c, 0x40840100, 0x05210484, 0x3501b19a, 0x2a062806, 0x00064806, 0x3c067006, 0x9605fc05, 0xc805c806, 0x0182fe05,
+    0xf205f23e, 0x0c062206, 0x2c061006, 0xdc060206, 0x0406ec06, 0xa4054a06, 0xa205a605, 0x6606a405, 0x6e230182, 0x8305ba05, 0x06982203, 0x3c338298,
+    0x052406c8, 0x057a05ce, 0x058c067a, 0x0570055e, 0x0560056a, 0x065a0568, 0x050e0638, 0x2c01825a, 0x06d2053e, 0x0582055a, 0x05a4054c, 0x2a278242,
+    0x05c00578, 0x06940670, 0x82a00588, 0x06642c03, 0x0684067c, 0x065c067e, 0x825e0664, 0x06642401, 0x827e0556, 0x05b4265f, 0x061606b4, 0x2001821a,
+    0x2c89820e, 0x05ee0410, 0x059005a0, 0x068c058e, 0x34178424, 0x060e0616, 0x050e060a, 0x04a40556, 0x051806de, 0x0528050e, 0x2201848a, 0x82880580,
+    0x05862641, 0x05340586, 0x24778232, 0x06ca0560, 0x34438226, 0x06000516, 0x06d40504, 0x05020618, 0x04f004de, 0x05ec04ee, 0x2057821e, 0x2aad82f8,
+    0x058c0568, 0x04ce05d2, 0x828c048e, 0x058a3c01, 0x04d805d0, 0x056e0538, 0x057e046c, 0x04380466, 0x04220436, 0x046a0420, 0x82a40426, 0x82742087,
+    0x056029e5, 0x04800582, 0x005804d2, 0x25a60040, 0x00000404, 0xac83aa03, 0x009c0425, 0x82340400, 0x049e2203, 0x200582a2, 0x26138416, 0x0400008c,
+    0x830e0412, 0xb203230b, 0x0784b203, 0x00003824, 0x09833203, 0x04230383, 0x82060406, 0x8366200f, 0x2303830b, 0x6e03b003, 0x00230783, 0x85b60300,
+    0x25058707, 0x82038e04, 0x0d838603, 0x03300425, 0x84d803ce, 0x823c2009, 0x84a42027, 0x03382309, 0x45820366, 0x832e0321, 0x6003240d, 0x82020000,
+    0xc2022121, 0x03850d83, 0x02213b85, 0x850d85b4, 0xf6032305, 0x0983f203, 0x834e0321, 0x21038505, 0x0785d003, 0x76241784, 0x44030000, 0x03830983,
+    0x02219983, 0x8d098384, 0x83032003, 0x85782025, 0x7c032713, 0xc4030000, 0x0582e202, 0x03827420, 0x87827220, 0x42024022, 0xb8200582, 0x00231f85,
+    0x82620300, 0x82602003, 0x825e2003, 0x025c2203, 0x20058270, 0x201b8358, 0x83418603, 0x2103910b, 0x13895c02, 0x02980223, 0x910d8998, 0x91618309,
+    0x2111a115, 0x238f4602, 0x8ff60221, 0x210f8711, 0x09839a02, 0xbd820120, 0x006e0125, 0x82660100, 0x83a18a03, 0x0300101b, 0x9c230401, 0x41008a00,
+    0x25411cab, 0x43012017, 0xc7090721, 0x00020001, 0x00040003, 0x00060005, 0x00120011, 0x00140013, 0x00160015, 0x00180017, 0x001a0019, 0x001c001b,
+    0x001e001d, 0x0020001f, 0x00220021, 0x00240023, 0x00260025, 0x00280027, 0x002a0029, 0x002c002b, 0x002e002d, 0x018d002f, 0x01860185, 0x018c0187,
+    0x0190018d, 0x01930192, 0x019c0198, 0x01a701a6, 0x01b801a8, 0x01be01bd, 0x01c001bf, 0x01c201c1, 0x01c501c3, 0x01c701c6, 0x01cb01ca, 0x01d001cc,
+    0x01d201d1, 0x01d701d3, 0x01e201de, 0x01e901e8, 0x01f101f0, 0x020302fc, 0x02130211, 0x021f0217, 0x022a0229, 0x0231022c, 0x02330232, 0x02390237,
+    0x0240023f, 0x02440241, 0x02460245, 0x024b0247, 0x024e024c, 0x02530250, 0x0271026b, 0x02760273, 0x027e0279, 0x0280027f, 0x02820281, 0x02840283,
+    0x028c0285, 0x0294028d, 0x029b0295, 0x02a702a2, 0x02ba02b7, 0x02c602bf, 0x02d402c8, 0x02dd02d7, 0x02df02de, 0x02e102e0, 0x02e302e2, 0x02e502e4,
+    0x02e702e6, 0x02f902e8, 0x02fe02fb, 0x030103ff, 0x03070306, 0x03090308, 0x03130311, 0x03210314, 0x03240323, 0x03260325, 0x03340328, 0x03370336,
+    0x033a0338, 0x0342033c, 0x034d034c, 0x034f034e, 0x03510350, 0x03580353, 0x035b035a, 0x036b0365, 0x0373036f, 0x03760375, 0x03780377, 0x037f0379,
+    0x03920385, 0x03d603a5, 0x03dd03dc, 0x03df03de, 0x03e103e0, 0x03e703e2, 0x040f04eb, 0x045d045c, 0x0490047b, 0x049a0492, 0x04a104a0, 0x04b304ac,
+    0x04bf04be, 0x04c504c2, 0x04cc04c8, 0x04de04d5, 0x04f204e6, 0x050805f9, 0x05220520, 0x052e0529, 0x000c0030, 0x2f210082, 0x8204828c, 0xf5032102,
+    0x21200482, 0x01200386, 0x23200782, 0x25200382, 0x02240382, 0x2a000000, 0x2b200382, 0x05200382, 0x30200382, 0x39200382, 0x07200382, 0x3c200382,
+    0x5a200382, 0x11200382, 0x61200382, 0x16200386, 0x62200782, 0x17200386, 0x63200782, 0x18200386, 0x64200782, 0x19200386, 0x65200782, 0x1a200386,
+    0x66200782, 0x1b200386, 0x67200782, 0x1c200386, 0x68200782, 0x1d200386, 0x69200782, 0x1e200386, 0x6a200782, 0x1f200386, 0x6b200782, 0x20200386,
+    0x6c200782, 0x21200386, 0x6d200782, 0x22200386, 0x6e200782, 0x23200386, 0x6f200782, 0x24200386, 0x70200782, 0xe7830386, 0x0b827120, 0x26200383,
+    0x72200782, 0x27200386, 0x73200782, 0x28200386, 0x74200782, 0x29200386, 0x75200782, 0x2a200386, 0x76200782, 0x2b200386, 0x77200782, 0x2c200386,
+    0x78200782, 0x2d200386, 0x79200782, 0x2e200386, 0x7a200782, 0x2f200386, 0xa3200782, 0x02210385, 0x2007827f, 0x210385a5, 0x07828102, 0x0385a920,
+    0x82c80221, 0x85ab2007, 0x40022103, 0xae200782, 0x03210385, 0x20078208, 0x210385b6, 0x0782ba02, 0x0385bb20, 0x82410221, 0x85d72007, 0x8d012103,
+    0xf7200782, 0x03250385, 0x200000e2, 0x20038513, 0x211f8201, 0x0b821c20, 0x02210382, 0x2007824b, 0x2103851d, 0x07824c02, 0x03853920, 0x82440221,
+    0x853a2007, 0x45022103, 0xa4200782, 0x02210385, 0x2007829b, 0x250385a8, 0x00008002, 0x0385a920, 0x82830221, 0x85aa2007, 0xd4022103, 0xac200782,
+    0x02210385, 0x2007827e, 0x210385b4, 0x0782de04, 0x0385b820, 0x82300521, 0x85bd2007, 0x82022503, 0x22210000, 0x03210385, 0x20078207, 0x21038590,
+    0x0782d001, 0x03859120, 0x82d20121, 0x85922007, 0xd1012103, 0x93200782, 0x01210385, 0x200782d3, 0x20038594, 0x21bf8203, 0x0b829521, 0x03210382,
+    0x2007824d, 0x21038597, 0x07825303, 0x0385ba20, 0x822a0221, 0x85bb2007, 0x98012103, 0xc4200782, 0x02250385, 0x22000031, 0x21038512, 0x0782d701,
+    0x03851e20, 0x00eb0325, 0x85032300, 0x46022103, 0x04200782, 0x02210385, 0x20078247, 0x2103851b, 0x0782fe02, 0x03852820, 0x6b820220, 0x82292321,
+    0x2103820b, 0x0782c601, 0x03852a20, 0x82c70121, 0x852b2007, 0x0f042103, 0x99200782, 0x01210385, 0x200782a7, 0x210385cf, 0x0782c501, 0x0385e920,
+    0x82c20121, 0x85ea2007, 0xbe012103, 0xed200782, 0x01210385, 0x200782c3, 0x210385ee, 0x0782bd01, 0x0385f120, 0x823c0321, 0x85f32007, 0xff022103,
+    0xf8200782, 0x01210385, 0x200782c0, 0x210385f9, 0x0782c101, 0x0385fb20, 0x82900121, 0x82b78307, 0x95022403, 0x82240000, 0x2503834b, 0x00009203,
+    0x0385a025, 0x82170221, 0x85b62007, 0xbf012103, 0xa7820782, 0x03822520, 0x824e0221, 0x85d0200b, 0xb8012103, 0x53820782, 0x03822520, 0xfc202f84,
+    0x03820f82, 0x26240b83, 0x26000000, 0x02210382, 0x20078294, 0x21038501, 0x07821102, 0x03850320, 0x822e0521, 0x85042007, 0xf9042103, 0x1b830782,
+    0x02210382, 0x200b8276, 0x21038515, 0x07822005, 0x03851d20, 0x37830220, 0x03820f83, 0x82e60421, 0x85222013, 0x83052003, 0x82232007, 0x2103820b,
+    0x07820805, 0x03852520, 0x009a0425, 0x852a2600, 0xbe042103, 0x2c200782, 0x04210385, 0x200782ac, 0x2103852e, 0x0782b304, 0x03852f20, 0x82c50421,
+    0x85382007, 0xa1042103, 0x39200782, 0x02210385, 0x20078250, 0x2103853f, 0x0782df02, 0x03854020, 0x82dd0221, 0x85422007, 0xde022103, 0x5a200782,
+    0x03210385, 0x20078275, 0x2103855b, 0x07827803, 0x03855c20, 0x82790321, 0x855d2007, 0x73032103, 0x5e200782, 0x03200385, 0x5f20ef83, 0x03820b82,
+    0x82770321, 0x85652007, 0x85012103, 0x66200782, 0x02210385, 0x200782d7, 0x21038572, 0x0782a702, 0x03857a20, 0x7b200b84, 0x03820b82, 0x7e200b84,
+    0x03820b82, 0x82eb0321, 0x85802007, 0x83032003, 0x8281209b, 0x2103820b, 0x0782e103, 0x03858220, 0x82e00321, 0x85832007, 0x83032003, 0x828420cb,
+    0x2103820b, 0x0782dc03, 0x03827b83, 0x82df0321, 0x8593200b, 0x6b022103, 0x96200782, 0x02210385, 0x200782fb, 0x21038599, 0x07829201, 0x03859b20,
+    0x87820420, 0x82a02621, 0x2103820b, 0x0782de01, 0x0385a120, 0x822c0221, 0x85a22007, 0xe2022103, 0xa3200782, 0x02210385, 0x200782e3, 0x210385a4,
+    0x0782e402, 0x0385a520, 0x82e00221, 0x85a62007, 0xe5022103, 0xa7200782, 0x02210385, 0x200782e1, 0x210385a8, 0x0782e602, 0x0385a920, 0x82e70221,
+    0x85aa2007, 0x4e022103, 0xab200782, 0x0b840385, 0x0b82b220, 0x02210382, 0x200782e8, 0x210385bd, 0x0782bf02, 0x0385be20, 0x826f0321, 0x85c42007,
+    0x2e052103, 0xc5200782, 0x04210385, 0x200782cc, 0x210385c6, 0x0782f204, 0x0385df20, 0x821f0221, 0x85e92007, 0xc2042103, 0xea200782, 0x03210385,
+    0x200782d6, 0x210385f7, 0x07822905, 0x0385fa20, 0x82c80421, 0x85fd2007, 0x82032003, 0x002724a7, 0x82270000, 0x13022103, 0x02200782, 0x0b840385,
+    0x0b820420, 0x0b840382, 0x0b820520, 0x02210382, 0x20078276, 0x20038509, 0x21538202, 0x0b820a27, 0x04210382, 0x200782d5, 0x2103850b, 0x07820103,
+    0x03850c20, 0x82060321, 0x850f2007, 0x42032103, 0x11200782, 0x04210385, 0x2007825d, 0x21038512, 0x07825c04, 0x03851320, 0x828c0121, 0x85142007,
+    0x200b8403, 0x820b8215, 0x8d012103, 0x16200782, 0x0b840385, 0x0b821d20, 0x04210382, 0x200782a0, 0x21038521, 0x0782bf04, 0x03853120, 0xab820020,
+    0x82442721, 0x2103820b, 0x07823603, 0x03854620, 0x4c200b84, 0x03820b82, 0x4e204784, 0x03820b82, 0x82340321, 0x85532007, 0x14002103, 0x54200782,
+    0x0b840385, 0x0b825520, 0x00200382, 0x5720d783, 0x03820b82, 0x64200b84, 0x03820b82, 0x82850121, 0x85952007, 0x83002003, 0x829620ef, 0x2103820b,
+    0x0782d701, 0x03859720, 0x00e20324, 0x63822900, 0x03210383, 0x200b825b, 0x25038535, 0x00005a03, 0x03850d2b, 0x824d0321, 0x851b2007, 0x7f032103,
+    0x1c200782, 0x0b840385, 0x0b822420, 0x02200382, 0x2b21ab82, 0x820b8250, 0x86012403, 0x82e00000, 0x82e020e7, 0x30002173, 0x47820b82, 0x0382e020,
+    0x82320021, 0x8512200b, 0x33002103, 0x3f200782, 0x41240382, 0x34000000, 0x59200782, 0x76200382, 0x37200b82, 0xb7820782, 0x4382e020, 0x82550021,
+    0x21a7820b, 0x178298e0, 0x0b825720, 0x03859a20, 0x2b830020, 0x0b82a920, 0x00200382, 0xe021a782, 0x820b82ac, 0x5b002103, 0xb4200782, 0x00210385,
+    0x2007825c, 0x210385b7, 0x07825d00, 0x0385bb20, 0x825e0021, 0x85d82007, 0x5f002103, 0xdf200782, 0x00210385, 0x20078260, 0x200382e3, 0x246b82e4,
+    0xe1000061, 0x21038531, 0x07826300, 0x03823920, 0x93493c20, 0x40e12105, 0x03820b82, 0x82680021, 0x85522007, 0x69002103, 0x27830782, 0x00210382,
+    0x830b826a, 0x2103820f, 0x0b826b00, 0x03856d20, 0x826c0021, 0x857b2007, 0x83002003, 0x82842013, 0x21e7820b, 0x07826e00, 0x03858f20, 0x82700021,
+    0x21e38207, 0x63499be1, 0xa8e12105, 0x03820f82, 0x82730021, 0x85b02007, 0x74002103, 0xbc200782, 0x00210385, 0x20078275, 0x210385c4, 0x07827600,
+    0x0385c820, 0x82770021, 0x85d32007, 0x78002103, 0xd5200782, 0x00210385, 0x20078279, 0x210385d7, 0x07827a00, 0x0385ed20, 0x827b0021, 0x85f32007,
+    0x7c002103, 0xf6200782, 0x00250385, 0xe200007d, 0x21038509, 0x07827e00, 0x03822120, 0x9b822220, 0x07827f20, 0x03852d20, 0x82810021, 0x853d2007,
+    0x82002103, 0x89200782, 0x00210385, 0x20078283, 0x2003859c, 0x21eb8200, 0x0b82b7e2, 0x00200382, 0xe221f382, 0x820b82bb, 0x86002103, 0xc5200782,
+    0x00210385, 0x20078287, 0x210385ca, 0x07828800, 0x0382cd20, 0x6b82ce20, 0xeb204f83, 0x03820b82, 0x008b0025, 0x851ee300, 0x8c002103, 0xaf200782,
+    0x00210385, 0x2007828d, 0x200382b1, 0x202f82b2, 0x2007828e, 0x250385f5, 0x00009000, 0x038533e4, 0x82910021, 0x823b2007, 0x823c2003, 0x82922023,
+    0x85452007, 0x94002103, 0x47200782, 0x48200382, 0x95201782, 0x6c200782, 0x00210385, 0x20078297, 0x21038573, 0x07829800, 0x03827620, 0x23827720,
+    0x07829920, 0x03827a20, 0x0b827b20, 0x07829b20, 0x03859020, 0x829d0021, 0x82932007, 0x214f8203, 0x07829e00, 0x0385a520, 0x82a00021, 0x82a82007,
+    0x82ad2003, 0x82a1202f, 0x82af2007, 0x82b02003, 0x82a7200b, 0x85b32007, 0xa9002103, 0xb5200782, 0xcc200382, 0xaa201782, 0xce200782, 0xde200382,
+    0xc2200b82, 0xe0200782, 0xe6200382, 0xd3200b82, 0xe8200782, 0xeb200382, 0xda200b82, 0xed240782, 0x03e50000, 0x27820b82, 0x8207e521, 0x8225200b,
+    0x21f7820b, 0x0b8227e5, 0x00002f24, 0x07821401, 0x03823220, 0x0b824f20, 0x07821d20, 0x03825120, 0x0b825820, 0x07823b20, 0x03825a20, 0x0b826f20,
+    0x07824320, 0x03827120, 0x0b827420, 0x07825920, 0x03827620, 0x0b828720, 0x07825d20, 0x03828920, 0x0b828f20, 0xe5212782, 0x200b8291, 0x830b829a,
+    0x829c201f, 0x25eb820b, 0x00008001, 0x038200f0, 0x17820220, 0x07828220, 0xf0208b82, 0x02210382, 0x200b8229, 0x24038204, 0x01000005, 0x20078285,
+    0x21038506, 0x07828601, 0x03820720, 0x00000e24, 0x07828701, 0x03821020, 0x0b821320, 0xf0206382, 0x0383ab82, 0x823a0321, 0x85152013, 0x93012103,
+    0x16200782, 0x02210385, 0x20078284, 0x20038217, 0x202f8219, 0x20078294, 0x2103851a, 0x07824e03, 0x03851b20, 0xdf820320, 0x821cf021, 0x2103820b,
+    0x07829701, 0xf020f382, 0x02200382, 0xf021df82, 0x820f821e, 0x98012103, 0x21200782, 0x3e200382, 0x99204782, 0x40200782, 0x03210385, 0x20078242,
+    0x20038241, 0x20178244, 0x200782b7, 0x21038545, 0x07827902, 0x03854620, 0xfb820220, 0x8247f021, 0x2173820b, 0x0782bb01, 0x03825020, 0x2f825b20,
+    0x0782c320, 0x03855c20, 0x82ca0121, 0x855d2007, 0xcb012103, 0x5e200782, 0x01210385, 0x200782cf, 0x20038260, 0x202f8266, 0x200782d0, 0x21038567,
+    0x07820600, 0x03856820, 0x82d70121, 0x85692007, 0x05002103, 0x6a200782, 0x6e240382, 0xd8010000, 0x70200782, 0x7e200382, 0xdd200b82, 0x80200782,
+    0x01210385, 0x200782ec, 0x20038283, 0x20178286, 0x200782ed, 0x21038587, 0x07828c02, 0x03858820, 0x828d0221, 0x85892007, 0xf1012103, 0x8a200782,
+    0x01210385, 0x20078285, 0x2103858b, 0x0782f201, 0x8e202783, 0xf3204782, 0x90200b82, 0x91200382, 0xf5200b82, 0x93200782, 0x95200382, 0xf7200b82,
+    0x96200782, 0x02210385, 0x20078217, 0x21038597, 0x0782a601, 0x03859820, 0x82fa0121, 0x829c2007, 0x829e2003, 0x82fb202f, 0x82a02007, 0x82a12003,
+    0x82fe200b, 0x85a22007, 0x37022103, 0xa3200782, 0xae240382, 0x00020000, 0xb0200782, 0xb2200382, 0x0c200b82, 0xc0200782, 0xce200382, 0x0f200b82,
+    0xd0200782, 0xd1200382, 0x1e200b82, 0xd6200782, 0xde200382, 0x20200b82, 0xe0200782, 0x02210385, 0x20078229, 0x200382e2, 0x201782e3, 0x2007822a,
+    0x210385e4, 0x07829204, 0x0385e520, 0x1f830120, 0x0b82e620, 0x01210382, 0x200782f0, 0x200382e7, 0x202f82ee, 0x8307822c, 0x82f4200f, 0x8234200b,
+    0x85f5200b, 0x38032103, 0xf6200782, 0x02210385, 0x20078285, 0x200385f7, 0x20bb8302, 0x820b82f8, 0x390224c7, 0x82f10000, 0x07f121b7, 0x40203b82,
+    0x08200b82, 0x03210385, 0x20078258, 0x24038209, 0x0200000b, 0x82078248, 0x82f120cf, 0x4e022103, 0x0d200b82, 0x0e200382, 0x4b201782, 0x10200782,
+    0x11200382, 0x4d200b82, 0x12200782, 0x03210385, 0x20078265, 0x21038514, 0x0782e801, 0x03851520, 0x82e90121, 0x82182007, 0x821c2003, 0x824f202f,
+    0x851d2007, 0x9c012103, 0x1e200782, 0x02210385, 0x20078254, 0x20038220, 0x20238222, 0x20078255, 0x20038523, 0x21a48201, 0x0b8224f1, 0x17822720,
+    0x28209b83, 0x03820b82, 0x67830020, 0x0b822920, 0x02210382, 0x2007825c, 0x2103852a, 0x07820100, 0x03822b20, 0x2f822e20, 0x07825d20, 0x03823020,
+    0x0b823520, 0x07826120, 0x03823720, 0x0b823a20, 0x07826720, 0x03823d20, 0x0b823e20, 0x07826b20, 0x4620ff83, 0x6d200b82, 0x47200b82, 0x02210385,
+    0x83078273, 0x21f782ff, 0x0b827402, 0x03825020, 0x0221a382, 0x8307827b, 0x2103829f, 0x0b820300, 0x03825620, 0x3b825920, 0x07828020, 0x03825b20,
+    0x0b825e20, 0x07828420, 0x03826020, 0x0b826520, 0x07828820, 0x03827520, 0x0b827820, 0x07828e20, 0x03828220, 0x0b828320, 0x07829220, 0x03828520,
+    0x02211f82, 0x83078294, 0x2003821b, 0x20678303, 0x820f8290, 0x4f032103, 0x91200782, 0x93200382, 0x98202f82, 0x95200782, 0x02210385, 0x2007829b,
+    0x21038596, 0x07823f02, 0x03859720, 0x829c0221, 0x85992007, 0x9d022103, 0x0f830782, 0x02210782, 0x200b829e, 0x200382ab, 0x204782ae, 0x200782a0,
+    0x210385b0, 0x0782a402, 0x0385b120, 0x82370321, 0x82b22007, 0x82b32003, 0x82a52023, 0x82b82007, 0x82bb2003, 0x82a7200b, 0x82c02007, 0x82c92003,
+    0x2043830b, 0x200b82cd, 0x200b82ce, 0x200782b5, 0x210385d8, 0x0782b702, 0x0385d920, 0xda200b84, 0x03820b82, 0x43830220, 0x0b82db20, 0x02210382,
+    0x2007824e, 0x200382dc, 0x203b82de, 0x200782b9, 0x200382e0, 0x200b82e6, 0x200782bc, 0x200382ea, 0x200b82ec, 0x200782c3, 0x210385f6, 0x0782c602,
+    0x0385f720, 0xf8200b84, 0xf9200b82, 0xc7202382, 0xfa200782, 0x00210385, 0x20078215, 0x200382fb, 0x821782fe, 0x00f2259f, 0x01f20000, 0xa3820b82,
+    0x8204f221, 0x8207200b, 0x82cf200b, 0x820a2007, 0x000b2403, 0x82d30200, 0x82172007, 0x821e2003, 0x82d5200b, 0x82212007, 0x822d2003, 0x82dd200b,
+    0x82332007, 0x82362003, 0x218b820b, 0x0b8238f2, 0x0b823920, 0x0782ee20, 0x03824020, 0x0b824920, 0x0782f020, 0x03854a20, 0x82f90221, 0x824d2007,
+    0x20d38203, 0x218b8202, 0x0b8250f2, 0x02210382, 0x200782ff, 0x20038251, 0x202f825d, 0x200782fc, 0x2103856c, 0x07820903, 0x03827120, 0x00007724,
+    0x07820a03, 0x03857820, 0x82110321, 0x82792007, 0x827a2003, 0x200b8317, 0x820b827b, 0xa5032103, 0x83200782, 0x01200385, 0x8b204783, 0x03820b82,
+    0x82130321, 0x858c2007, 0x200b8403, 0x820b828d, 0x14032103, 0x8e200782, 0x0b840385, 0x0b829020, 0x53829120, 0x07821520, 0x03859220, 0x82020021,
+    0x85952007, 0x04002103, 0x9a200782, 0x03210385, 0x20078217, 0x2103859c, 0x0782cc01, 0x03829d20, 0x3b829e20, 0x07821820, 0x0382a020, 0x0b82a420,
+    0x07821a20, 0x0382a720, 0x0b82a820, 0x07821f20, 0x0382b420, 0x0b82b620, 0x07822120, 0x0385b720, 0x82230321, 0x85b92007, 0x24032103, 0xba200782,
+    0x0b840385, 0x0b82bb20, 0x03210382, 0x20078225, 0x840385bc, 0x82bd200b, 0x2103820b, 0x07822603, 0x0385be20, 0xc0200b84, 0x03820b82, 0x82870121,
+    0x82c12007, 0x82c22003, 0x8227206b, 0x85c32007, 0x28032103, 0xc7200782, 0xce200382, 0x29201782, 0xd0200782, 0xd3200382, 0x31200b82, 0xd4200782,
+    0x03210385, 0x2007826b, 0x200382db, 0x201782dc, 0x20078235, 0x210385e5, 0x07823703, 0x0385e720, 0x82380321, 0x85ea2007, 0x39032103, 0xed200782,
+    0x03210385, 0x2007823a, 0x200382f1, 0x203b82f2, 0x2007823b, 0x200382f5, 0x200b82f6, 0x2007823d, 0x210385f9, 0x07823f03, 0x0385fe20, 0x00400325,
+    0x8202f300, 0x82052003, 0x82412023, 0x82092007, 0x000c2403, 0x82450300, 0x851c2007, 0x49032103, 0x1e200782, 0x03210385, 0x8207824a, 0x82f320c3,
+    0x4b032103, 0x32200b82, 0x01210385, 0x820782a8, 0x38f3219f, 0x4c203b82, 0x58200b82, 0x5b200382, 0x4e200b82, 0x5d200782, 0x03210385, 0x20078252,
+    0x21038560, 0x07825303, 0x03826220, 0x23826320, 0x07825420, 0x03858120, 0x4f830220, 0x0b828220, 0x02210382, 0x20078233, 0x20038286, 0x20238287,
+    0x20078256, 0x20038590, 0x205b8303, 0x820b82a5, 0x59032103, 0xbe200782, 0xbf200382, 0x5a202382, 0xc1200782, 0x03210385, 0x2007825c, 0x200385c5,
+    0x207f8303, 0x820b82c9, 0x5e032103, 0xcd200782, 0xcf200382, 0x5f202f82, 0xd1200782, 0x03200385, 0xdd208b83, 0x03820b82, 0x93820320, 0x82e0f321,
+    0x2103820b, 0x07826403, 0x0385e520, 0x82650321, 0x85ed2007, 0x66032103, 0xfa200782, 0xfb200382, 0x67204782, 0xfd200782, 0x04200385, 0xff20a383,
+    0x03820b82, 0x00690325, 0x8506f400, 0x6a032103, 0x10200782, 0x03210385, 0x2007826b, 0x21038522, 0x07826c03, 0x03852420, 0x826d0321, 0x21ff8207,
+    0x538234f4, 0x0b826e20, 0x03853620, 0x82710321, 0x82392007, 0x5b3a2003, 0xf421050d, 0x820b823c, 0x74032103, 0x3f200782, 0x03210385, 0x20078275,
+    0x21038541, 0x07827603, 0x03854320, 0x82770321, 0x85452007, 0x78032103, 0x47200782, 0x03210385, 0x20078279, 0x2103854b, 0x07827a03, 0x03854e20,
+    0x827b0321, 0x85502007, 0x7c032103, 0x53200782, 0x03210385, 0x2007827d, 0x21038558, 0x07827e03, 0x03825c20, 0x8f825d20, 0x07827f20, 0x03855f20,
+    0x82810321, 0x82612007, 0x82622003, 0x82822017, 0x85662007, 0x84032103, 0x68200782, 0xdf820382, 0x82850321, 0x82702007, 0x82722003, 0x828b2023,
+    0x85742007, 0x8e032103, 0xab830782, 0x17827920, 0x0b828f20, 0x03857d20, 0xf7830220, 0x7f206f83, 0x92201782, 0x63831382, 0x0b828220, 0x0b829420,
+    0x87205783, 0x96200b82, 0x4b830b82, 0x03210382, 0x200b829a, 0x8203828d, 0x9b03214f, 0x90200782, 0x94200382, 0x9d202382, 0x96200782, 0x97200382,
+    0xa2200b82, 0x9e200782, 0x03210385, 0x200782a4, 0x840385a1, 0x82ad209b, 0x2103820b, 0x0782a503, 0x0385b320, 0x82a60321, 0x82b82007, 0x82ba2003,
+    0x82a7203b, 0x82bd2007, 0x82be2003, 0x82aa200b, 0x82c02007, 0x82c22003, 0x82ac200b, 0x85c42007, 0xaf032103, 0xc6200782, 0x03210385, 0x200782b0,
+    0x200382cd, 0x202382ce, 0x200782b1, 0x210385d3, 0x0782b303, 0x0382d620, 0x1782db20, 0x0782b420, 0x0382de20, 0x0b82df20, 0xf4216382, 0x200b82e2,
+    0x200b82e3, 0x200782bc, 0x210385e6, 0x07822103, 0x0000fa24, 0x178209f5, 0x0782be20, 0x03821520, 0x0b822b20, 0xf5215782, 0x820b822c, 0x12002103,
+    0x2d200782, 0x30200382, 0xe5201782, 0x31200782, 0x00210385, 0x20078213, 0x20038232, 0x20178235, 0x200782e9, 0x21038536, 0x07821100, 0x03823720,
+    0x17824020, 0x0782ed20, 0x03854120, 0x82040021, 0x82422007, 0x82912003, 0x82f72017, 0x82932007, 0x009d2403, 0x82470400, 0x829f2007, 0x82a22003,
+    0x8252200b, 0x82a42007, 0x82a72003, 0x8256200b, 0x82aa2007, 0x82b12003, 0x825a200b, 0x82b32007, 0x21d38203, 0x07826204, 0x0382b620, 0x1782b820,
+    0x07826420, 0x0382ba20, 0x0b82bd20, 0x07826720, 0x0382bf20, 0x0b82c520, 0x07826b20, 0x0382c720, 0x0b82cb20, 0x07827220, 0x0382cd20, 0x0421d382,
+    0x20078277, 0x200382d0, 0x201782d2, 0x20078279, 0x210385d7, 0x07827c04, 0x0385da20, 0x827d0421, 0x85dc2007, 0x7e042103, 0xde200782, 0xdf200382,
+    0x7f202f82, 0xe1200782, 0x04210385, 0x20078281, 0x210385e4, 0x07828204, 0x0385e720, 0x82830421, 0x85eb2007, 0x84042103, 0xee200782, 0x04210385,
+    0x20078285, 0x200382fc, 0x244782fd, 0xf6000086, 0x21038501, 0x07828804, 0x03850420, 0x82890421, 0x85102007, 0x8a042103, 0x13200782, 0x04210385,
+    0x2007828b, 0x21038519, 0x07828c04, 0x03851f20, 0x828d0421, 0x85212007, 0x8e042103, 0x24200782, 0x25240382, 0x8f040000, 0x29200782, 0x2a200382,
+    0x91200b82, 0x2e200782, 0x30200382, 0x93200b82, 0x37200782, 0x04210385, 0x20078296, 0x2003823b, 0x2017823c, 0x20078297, 0x21038541, 0x07829904,
+    0x03854420, 0x829a0421, 0x85472007, 0x9b042103, 0x4a200782, 0x04210385, 0x2007829c, 0x2103854f, 0x07829d04, 0x03855120, 0x829e0421, 0x82532007,
+    0x82552003, 0x829f2053, 0x85582007, 0xa2042103, 0x5d200782, 0x5e200382, 0xa3201782, 0x62200782, 0x04210385, 0x200782a5, 0x20038264, 0x20178266,
+    0x200782a6, 0x20038269, 0x200b826b, 0x200782a9, 0x2103856d, 0x0782ac04, 0x03856f20, 0x82ad0421, 0x85742007, 0xae042103, 0x76200782, 0x04210385,
+    0x200782af, 0x20038278, 0x203b8279, 0x200782b0, 0x2003827b, 0x200b827c, 0x200782b2, 0x2103857f, 0x0782b404, 0x03828120, 0x17828420, 0x0782b520,
+    0x03828720, 0x0b828920, 0x0782b920, 0x03859620, 0x82bc0421, 0x82982007, 0x21eb8203, 0x0782bd04, 0x0382a020, 0x2382a120, 0x0782c120, 0x0385a720,
+    0x82c30421, 0x829f8307, 0xc4042103, 0xad200b82, 0x04210385, 0x200782c5, 0x200382b6, 0x202f82b7, 0x200782c6, 0x210385bb, 0x0782c804, 0x0385be20,
+    0x82c90421, 0x85c02007, 0xca042103, 0x4b830782, 0x2f82c420, 0x0b82cb20, 0x0385c820, 0x82cd0421, 0x85cf2007, 0xce042103, 0xd1200782, 0x04200385,
+    0xd3201383, 0x03820b82, 0x82d00421, 0x85d52007, 0xd1042103, 0xd7200782, 0x04210385, 0x200782d2, 0x210385d9, 0x0782d304, 0x0382dd20, 0x5f82de20,
+    0x0782d420, 0x0382e220, 0x0b82e320, 0x0782d620, 0x0385e620, 0x82d80421, 0x85e82007, 0x83042003, 0x82ec2037, 0x82ed200b, 0x82da2023, 0x82f02007,
+    0x82f22003, 0x82dc200b, 0x85fa2007, 0xdf042103, 0xfc200782, 0x04210385, 0x240782e0, 0xf70000ff, 0x20238200, 0x200782e1, 0x2003820b, 0x200b820c,
+    0x200782e3, 0x2103850e, 0x0782e504, 0x03821420, 0x17821520, 0xf7217382, 0x820b8217, 0x82042003, 0x1ef72173, 0x03820b82, 0x82e90421, 0x85222007,
+    0xea042103, 0x28200782, 0x29200382, 0xeb202f82, 0x2b200782, 0x04200385, 0xf7219382, 0x200b822e, 0x2017822f, 0x200782ee, 0x2003823b, 0x200b823d,
+    0x200782f0, 0x21038540, 0x0782f304, 0x03854320, 0x82f40421, 0x85472007, 0xf5042103, 0x4d200782, 0x04210385, 0x200782f6, 0x20038251, 0x203b8253,
+    0x200782f7, 0x20038556, 0x21df8204, 0x0b825af7, 0x17825b20, 0x0782fb20, 0x03825e20, 0x0b825f20, 0x0782fd20, 0x03856920, 0x82ff0421, 0x826b2007,
+    0x006c2303, 0xf3820500, 0x826ff721, 0x8270200b, 0x8202200b, 0x82722007, 0x82732003, 0x8204200b, 0x827c2007, 0x827d2003, 0x8206200b, 0x82802007,
+    0x82812003, 0x8208200b, 0x82832007, 0x82842003, 0x820a200b, 0x82862007, 0x82882003, 0x820c200b, 0x858c2007, 0x0f052103, 0x93200782, 0x94200382,
+    0x10201782, 0x96200782, 0x05210385, 0x20078212, 0x2103859c, 0x07821305, 0x03829f20, 0x2382a020, 0x07821420, 0x0385a220, 0x82160521, 0x82a42007,
+    0x00a62403, 0x82170500, 0x82a92007, 0x82ab2003, 0x821a200b, 0x82ad2007, 0x82ae2003, 0x821d200b, 0x82b52007, 0x82b62003, 0x821f200b, 0x82b92007,
+    0x82ba2003, 0x8221200b, 0x85bd2007, 0x23052103, 0xbf200782, 0xc0200382, 0x24201782, 0xc2200782, 0x05210385, 0x20078226, 0x200382c4, 0x201782c5,
+    0x20078227, 0x200382c9, 0x200b82ca, 0x20078229, 0x200382cc, 0x200b82ce, 0x2007822b, 0x210385d0, 0x07822e05, 0x0385d220, 0x822f0521, 0x82d72007,
+    0x82da2003, 0x82302023, 0x82e42007, 0x82e62003, 0x8234200b, 0x85ec2007, 0x37052103, 0xef200782, 0x05210385, 0x20078238, 0x200382f2, 0x202382f3,
+    0x20078239, 0x210385f5, 0x07823b05, 0x0385f720, 0x823c0521, 0x82fa2007, 0x82fb2003, 0x003d2423, 0x8502f800, 0x3f052103, 0x05200782, 0x07200382,
+    0x40201782, 0x0a200782, 0x01210385, 0x20078293, 0x2103850b, 0x07828d00, 0x03850c20, 0x0d201784, 0x03820b82, 0x82430521, 0x820f2007, 0x82102003,
+    0x8244203b, 0x85122007, 0x46052103, 0x15200782, 0x16240382, 0x47050000, 0x18200782, 0x05210385, 0x20078249, 0x2103851d, 0x07824a05, 0x03822820,
+    0x23822a20, 0x07824b20, 0xf820f382, 0x05210382, 0x200b824e, 0x2103853e, 0x07824f05, 0x03822783, 0x82500521, 0x854c200b, 0x51052103, 0x0f830782,
+    0x05210382, 0x200b8252, 0x20038553, 0x20078305, 0x820b825e, 0x54052103, 0x63200782, 0x05210385, 0x20078255, 0x2103856d, 0x07825605, 0x03857920,
+    0x82570521, 0x827b2007, 0x827d2003, 0x82582083, 0x82812007, 0x82822003, 0x825b200b, 0x82842007, 0x82872003, 0x825d200b, 0x85912007, 0x61052103,
+    0x97200782, 0x05210385, 0x20078262, 0x200382c0, 0x202382c1, 0x20078263, 0x210385cc, 0x07826505, 0x0385d720, 0x82660521, 0x85d92007, 0x67052103,
+    0xe5200782, 0x03210385, 0x20078209, 0x210385ef, 0x07826805, 0x0385ff20, 0x00690525, 0x847ff101, 0x03002603, 0xf30100f6, 0x22038408, 0x82fc0400,
+    0x840b2007, 0x05002203, 0x20078203, 0x2203840d, 0x82310400, 0x840e2007, 0x04002203, 0x20078232, 0x2203840f, 0x82330400, 0x84102007, 0x02002203,
+    0x20078209, 0x22038419, 0x82950200, 0x84212007, 0x03002203, 0x2007822b, 0x22038426, 0x82f40400, 0x84272007, 0x04002203, 0x200782f2, 0x22038429,
+    0x82010500, 0x842a2007, 0x05002203, 0x20078202, 0x2203842d, 0x82440500, 0x84312007, 0x03002203, 0x830782b6, 0x0032247b, 0x82aa0200, 0x8436200b,
+    0x05002203, 0x20078248, 0x2203844b, 0x82f80100, 0x844e2007, 0x04002203, 0x2007827a, 0x8503844f, 0x8268200b, 0x0068240b, 0x82450500, 0x846a2007,
+    0x04002203, 0x20078218, 0x22038474, 0x82380300, 0x84772007, 0x03002203, 0x200782bd, 0x22038478, 0x82300400, 0x84812007, 0x01002203, 0x200782d9,
+    0x22038482, 0x82cb0200, 0x84932007, 0x02002203, 0x2007829f, 0x22038497, 0x82b40300, 0x84992007, 0x03002203, 0x2007825e, 0x2203849e, 0x82880100,
+    0x20278307, 0x20bf829f, 0x200b8272, 0x220384a7, 0x829d0100, 0x84a82007, 0x03002203, 0x200782f5, 0x220384ad, 0x82950400, 0x84b22007, 0x03002203,
+    0x200782db, 0x220384b5, 0x82830100, 0x84c02007, 0x03002203, 0x20078270, 0x220384c1, 0x82540200, 0x84c22007, 0x05002203, 0x2007822d, 0x220384c3,
+    0x82e40400, 0x84c52007, 0x04002203, 0x20078255, 0x220384c6, 0x82f60100, 0x84c82007, 0x03002203, 0x2007827b, 0x210384ca, 0x53830400, 0x0b82cd20,
+    0xa782cd20, 0x0782da20, 0x0384d020, 0x81030022, 0xd3200782, 0x00220384, 0x07828003, 0x0384d420, 0xe0040022, 0xd6200782, 0x00220384, 0x07827504,
+    0x0384d920, 0x83040021, 0x82db20d7, 0x00db230b, 0xd3830400, 0xe0242783, 0x93010000, 0xe2201382, 0x00220384, 0x0782a202, 0x0384e520, 0x39020022,
+    0xe8200782, 0x00220384, 0x07824804, 0x0384eb20, 0xfe030022, 0xf4200782, 0x00220384, 0x07829c01, 0x0384f720, 0xa3010026, 0x04f40100, 0x00210384,
+    0x21af8204, 0x0b8208f4, 0x6b820820, 0x0782c920, 0x03840920, 0xd1040022, 0x0e200782, 0x00220384, 0x0782dc04, 0x03841520, 0x82040021, 0x1ff421d3,
+    0x1f240b82, 0x2d040000, 0x41200782, 0x00210384, 0x20238301, 0x240b824d, 0x0200004d, 0x2007828c, 0x2203844e, 0x828d0200, 0x84512007, 0x03002203,
+    0x200782da, 0x21038455, 0x73830400, 0x0b826420, 0xd7826420, 0x07828720, 0x03846520, 0xc4030022, 0x7b200782, 0x00220384, 0x0782d604, 0x03848020,
+    0x01040022, 0x89200782, 0x00210384, 0x21cb8203, 0x0b828ef4, 0x00008e24, 0x07825903, 0x03849420, 0x1a050022, 0x99200782, 0x00220384, 0x07828501,
+    0x03849a20, 0x9b200b85, 0x9b200b82, 0x17836b82, 0x9c203f83, 0xa1200b86, 0xa1201782, 0x3020b382, 0xa3200782, 0x00220384, 0x0782be02, 0x0384a720,
+    0xb9010022, 0xa9200782, 0x00220384, 0x07824003, 0x0384ac20, 0xa5030022, 0xb0200782, 0x00220384, 0x07824a05, 0x0384b220, 0x07829082, 0x0384b320,
+    0xfc010022, 0xbb200782, 0x00220384, 0x07824802, 0x0384bc20, 0x0d020022, 0xbe200782, 0x00220384, 0x07821602, 0x0384bf20, 0xd8030022, 0xc0200782,
+    0x0b850384, 0x0b82c120, 0xa782c120, 0x0782e820, 0x0384c220, 0xe9010022, 0xc4200782, 0x00220384, 0x07828402, 0x0384c520, 0x64020022, 0xc6200782,
+    0x0b850384, 0x0b82cb20, 0x8e82cb20, 0x07824b20, 0x0384cc20, 0xf3010022, 0xcd200782, 0x00220384, 0x07820f03, 0x0384ce20, 0x15020022, 0xcf200782,
+    0x00220384, 0x0782fa03, 0x0384d420, 0x83010021, 0x82d620e3, 0x82d6200b, 0x82d12047, 0x84dc2007, 0x04002203, 0x200782e5, 0x220384dd, 0x82490300,
+    0x84de2007, 0x01002203, 0x200782f9, 0x220384df, 0x82470500, 0x84e02007, 0x02002203, 0x200782a1, 0x220384e1, 0x82250500, 0x84e22007, 0x01002203,
+    0x200782ff, 0x210384e6, 0xcb830300, 0x0b82f020, 0x0000f024, 0x0782c302, 0x0384f120, 0x60030022, 0xf6200782, 0x00220384, 0x07829101, 0x0384f720,
+    0xed010022, 0xfb200782, 0x00260384, 0x01006605, 0x038400f5, 0x82010021, 0x01f52167, 0x01200b82, 0x5520b382, 0x04200782, 0x00220384, 0x07823b03,
+    0x03840820, 0x9f010022, 0x0a200782, 0x00220384, 0x0782a001, 0x03840b20, 0x82020021, 0x0cf5217f, 0x0c240b82, 0xc2020000, 0x0d200782, 0x00210384,
+    0x219b8201, 0x0b8211f5, 0x64821120, 0x0782ee20, 0x03841220, 0x9b010022, 0x13200782, 0x00210384, 0x218b8201, 0x0b8214f5, 0x3b821420, 0x07823720,
+    0x03841520, 0xc6020022, 0x16200782, 0x00220384, 0x0782a601, 0x03841720, 0x10020022, 0x18200782, 0x00220384, 0x07829902, 0x03842520, 0xdb010022,
+    0x27200782, 0x00220384, 0x07820a02, 0x03842820, 0xd7040022, 0x2c200782, 0x00220384, 0x07828a04, 0x03843420, 0x4e020022, 0x35200782, 0x0b850384,
+    0x0b824720, 0x00004723, 0x20d78304, 0x200b8249, 0x200b8249, 0x200782b1, 0x2203844a, 0x82a90300, 0x844b2007, 0x04002203, 0x200782ab, 0x2203844c,
+    0x82b00400, 0x844d2007, 0x04002203, 0x200782c0, 0x2203844e, 0x82d80400, 0x84532007, 0x01002203, 0x20078294, 0x2203846b, 0x82ff0100, 0x846e2007,
+    0x03002203, 0x200782d1, 0x22038471, 0x82e60400, 0x84752007, 0x02002203, 0x200782d9, 0x22038477, 0x82e80400, 0x847b2007, 0x01002203, 0x200782f9,
+    0x2203847d, 0x82570500, 0x84822007, 0x02002203, 0x20078229, 0x22038488, 0x82f30100, 0x848a2007, 0x03002203, 0x20078243, 0x2203848b, 0x825c0400,
+    0x848c2007, 0x02002203, 0x200782ca, 0x22038495, 0x82410500, 0x84962007, 0x03002203, 0x20078204, 0x220384a4, 0x82850100, 0x84a52007, 0x03002203,
+    0x20078258, 0x220384a8, 0x82a70100, 0x84a92007, 0x02002203, 0x200782c5, 0x220384aa, 0x82160200, 0x84b12007, 0x05002203, 0x20078265, 0x220384b4,
+    0x82fe0100, 0x84b62007, 0x203b8503, 0x240b82b7, 0x020000b7, 0x200782a1, 0x220384b8, 0x82d80300, 0x84b92007, 0x02002103, 0xbb207783, 0xbb200b82,
+    0xb0202382, 0xbf200782, 0x00220384, 0x0782e801, 0x0384c120, 0xe9010022, 0xcb200782, 0x00220384, 0x07828402, 0x0384ce20, 0xd5203b85, 0xd5240b82,
+    0x32030000, 0xd6200782, 0x00220384, 0x07823103, 0xd8246383, 0x99010000, 0xd9200b82, 0x00220384, 0x07828d01, 0xe9204b83, 0xe2201782, 0xea200b82,
+    0x00220384, 0x0782f001, 0x0384fa20, 0x11030025, 0x82f60100, 0x2203821e, 0x82350400, 0x8401200b, 0x04002203, 0x2007824e, 0x22038402, 0x823d0400,
+    0x84032007, 0x04002203, 0x20078236, 0x22038404, 0x82370400, 0x84052007, 0x04002203, 0x20078238, 0x22038406, 0x823a0400, 0x84092007, 0x03002203,
+    0x200782b8, 0x2203840a, 0x82660400, 0x840d2007, 0x04002203, 0x20078239, 0x22038410, 0x82510200, 0x84172007, 0x04002203, 0x2007824a, 0x22038418,
+    0x824c0400, 0x84192007, 0x04002203, 0x2007824b, 0x2203841b, 0x823e0400, 0x841c2007, 0x04002203, 0x20078240, 0x2203841d, 0x823f0400, 0x84202007,
+    0x04002203, 0x2007820b, 0x22038422, 0x82630400, 0x84262007, 0x04002203, 0x2007822f, 0x2203842b, 0x82730400, 0x842c2007, 0x04002203, 0x20078234,
+    0x2203842d, 0x82620400, 0x842e2007, 0x04002203, 0x2007826e, 0x21038433, 0x13830400, 0x0b823620, 0x00003624, 0x07825604, 0x03844220, 0x4f020022,
+    0x44200782, 0x00220384, 0x07825704, 0x03848120, 0xea030022, 0x86200782, 0x00220384, 0x0782ee02, 0x03848a20, 0x83050021, 0x828d204f, 0x008d240b,
+    0x82d20200, 0x84902007, 0x04002203, 0x20078264, 0x22038491, 0x823a0200, 0x84962007, 0x02002203, 0x200782a9, 0x22038497, 0x82820400, 0x84982007,
+    0x02002203, 0x200782a8, 0x2203849a, 0x821f0200, 0x849c2007, 0x04002103, 0xa2207783, 0xa2200b82, 0xd8205f82, 0xa6200782, 0x00210384, 0x204f8304,
+    0x240b82aa, 0x030000aa, 0x200782e3, 0x220384ab, 0x82cf0100, 0x84ac2007, 0x03002203, 0x2007829b, 0x220384ad, 0x82020400, 0x84b02007, 0x00002203,
+    0x20078231, 0x220384b2, 0x82d10200, 0x84b42007, 0x05002203, 0x20078250, 0x220384b6, 0x82090400, 0x84bd2007, 0x05002103, 0xbf202f83, 0xbf200b82,
+    0x2e206b82, 0xc1200782, 0x00220384, 0x07822f03, 0x0384cc20, 0xed020022, 0xce200782, 0x00220384, 0x07821704, 0x0384d020, 0xb7040022, 0xd2200782,
+    0x00220384, 0x0782e701, 0x0384e120, 0x63020022, 0xe3200782, 0x00220384, 0x07829501, 0x0384eb20, 0x60040022, 0xec200782, 0x00220384, 0x07825f04,
+    0x0384f020, 0x24050022, 0xfb200782, 0x00260384, 0x01009804, 0x0384e0f7, 0x4e020022, 0xe1200782, 0x0b850384, 0x0b82e220, 0x8500e221, 0x82e3200b,
+    0x86e3200b, 0x82e4200b, 0x86e4200b, 0x82e5200b, 0x82e5200b, 0x827f20cb, 0x84e62007, 0x03002103, 0xe7200b83, 0xe7200b82, 0xe8201786, 0xe8200b82,
+    0xe9200b86, 0xe9200b82, 0xea200b86, 0xea200b82, 0xeb200b86, 0xeb200b82, 0xf9230b85, 0x8201000d, 0x01002203, 0x20078285, 0x8503840e, 0x8216200b,
+    0x8216200b, 0x82f92023, 0x841a2007, 0x03002203, 0x20078201, 0x2203841d, 0x82b00300, 0x84232007, 0x04002203, 0x2007823b, 0x22038429, 0x823c0400,
+    0x84412007, 0x04002203, 0x2007821e, 0x22038442, 0x82140500, 0x84432007, 0x05002203, 0x20078215, 0x22038444, 0x82370300, 0x844e2007, 0x03002203,
+    0x2007826f, 0x22038453, 0x82350500, 0x84552007, 0x05002103, 0x5a20a383, 0x5a240b82, 0x3e050000, 0x77200782, 0x00220384, 0x0782c803, 0x03849020,
+    0x96000022, 0x9b200782, 0x00220384, 0x0782db04, 0x0384a620, 0xe2040022, 0xb4200782, 0x00220384, 0x07827c04, 0x0384b720, 0x74040022, 0xcd200782,
+    0x00220384, 0x07829302, 0x0384e020, 0x7e040022, 0xe1200782, 0x07410384, 0x82e62005, 0x00e6240b, 0x82bc0400, 0x84e92007, 0x02002203, 0x20078260,
+    0x220384ea, 0x829f0300, 0x84ec2007, 0x03002203, 0x2007828c, 0x220384ed, 0x827a0200, 0x84ef2007, 0x02002203, 0x20078265, 0x220384f0, 0x82070400,
+    0x84f22007, 0x01002203, 0x200782e3, 0x220384f3, 0x82360200, 0x84f92007, 0x03002203, 0x200782d3, 0x210384fb, 0x73830400, 0x0b82fc20, 0x0000fc24,
+    0x07824c00, 0x0384fe20, 0xf8030026, 0x79fa0100, 0x00220384, 0x07828303, 0xfa256f82, 0x0200007a, 0x200b8235, 0x22038491, 0x82ca0400, 0x849b2007,
+    0x03002203, 0x200782ff, 0x220384b6, 0x82e50300, 0x84c12007, 0x04002203, 0x85578289, 0x82882002, 0x00f82406, 0x59fc0100, 0x042005f5, 0x04250e82,
+    0x050000b8, 0x2403822c, 0x060000b0, 0x82038224, 0x5c072d07, 0xe8070000, 0x8c080000, 0x28090000, 0x80230382, 0x820a0000, 0x820a2013, 0x580b2937,
+    0xcc0b0000, 0x280c0000, 0xe42b0382, 0xf40d0000, 0x600e0000, 0x820f0000, 0xac0f254b, 0x24100000, 0x9c240382, 0x08110000, 0x27820382, 0x00441229,
+    0x00bc1200, 0x82341300, 0x205b8203, 0x24278214, 0x00007814, 0x285f8214, 0x00007c15, 0x0000f015, 0x24178216, 0x00004017, 0x21338218, 0x07826818,
+    0x0000dc24, 0x03823c19, 0x0000c824, 0x0382501a, 0x1b24a382, 0x1b000020, 0x1c201782, 0x1d205382, 0x1e243782, 0x1f000094, 0x21287f82, 0x22000030,
+    0x250000a4, 0x27200b82, 0x28307f82, 0x29000054, 0x2a00001c, 0x2c0000c4, 0x2d0000e0, 0x2e204382, 0x302c6382, 0x31000060, 0x32000070, 0x33000048,
+    0x34287b82, 0x350000d4, 0x38000098, 0x39242b82, 0x3a0000a8, 0x3b203782, 0x3b204b82, 0x3d2ce382, 0x3e0000a0, 0x3f000088, 0x410000e8, 0x412c9782,
+    0x420000fc, 0x430000d8, 0x440000c4, 0x46246782, 0x47000074, 0x4a208b82, 0x4b209b82, 0x4c253382, 0x4d00007c, 0x23038204, 0x4e000090, 0x4f206782,
+    0x5024f382, 0x5100002c, 0x5124f382, 0x52000094, 0x53200782, 0x5320cf82, 0x55248782, 0x56000014, 0x56202b82, 0x57282b82, 0x5800008c, 0x5a0000e0,
+    0x5b291382, 0x5c000064, 0x5d000078, 0x82038258, 0x825e2013, 0x8260206f, 0x08612443, 0x82610000, 0x106228d7, 0xb0620000, 0x82630000, 0x3864306b,
+    0xd0650000, 0xa4660000, 0x6c670000, 0x82680000, 0x286928c3, 0xb4690000, 0x826a0000, 0x806b243f, 0x826c0000, 0x826d20eb, 0x826e205f, 0x826f2077,
+    0x826f205f, 0x827020bb, 0x8271201f, 0x837220ff, 0x20bf8203, 0x20178274, 0x245f8275, 0x0000f875, 0x20938277, 0x20438278, 0x201b8279, 0x20c3827a,
+    0x24db827c, 0x0000307d, 0x2477827e, 0x0000a87e, 0x209f827f, 0x200b8280, 0x20138281, 0x242f8281, 0x0000a082, 0x245b8283, 0x00008884, 0x24cb8285,
+    0x00000c87, 0x20b38287, 0x20678288, 0x20f38289, 0x242f828a, 0x0000e88b, 0x3c33828d, 0x0000e48d, 0x0000d48e, 0x0000c88f, 0x00008491, 0x0000f492,
+    0x00005494, 0x0000c095, 0x20438297, 0x24df8298, 0x0000bc99, 0x20ef829b, 0x20a3829c, 0x2487829e, 0x0000b89f, 0x201b82a2, 0x24eb82a3, 0x000058a5,
+    0x200382a6, 0x28d782a7, 0x000078a8, 0x00006caa, 0x20f382ac, 0x202382ad, 0x240382ae, 0x000020b0, 0x280f82b1, 0x0000ccb1, 0x00007cb2, 0x206382b3,
+    0x282f82b4, 0x000068b5, 0x000040b6, 0x248b82b7, 0x000098b8, 0x209f82b9, 0x20ef82bb, 0x201382bc, 0x209b82bc, 0x204782be, 0x205f82c0, 0x20cf82c1,
+    0x20b782c3, 0x24d382c5, 0x000024c7, 0x241b82c8, 0x0000a4ca, 0x202782cc, 0x209b82cd, 0x202782cf, 0x2c2382d1, 0x00009cd2, 0x0000d0d3, 0x0000e0d4,
+    0x203782d6, 0x24d782d7, 0x00008cd8, 0x242382d9, 0x000050db, 0x246382dc, 0x0000f0dd, 0x281f82de, 0x0000dcdf, 0x000044e1, 0x204f82e2, 0x204f82e2,
+    0x203782e3, 0x201b82e4, 0x20af82e5, 0x204f82e7, 0x201b82e8, 0x20ef82e9, 0x207382e9, 0x243b82ea, 0x000000ed, 0x203782ed, 0x2c2382ef, 0x00000cf1,
+    0x000088f2, 0x0000b0f3, 0x285382f4, 0x000070f5, 0x000054f6, 0x20e382f7, 0x24bf82f8, 0x0000fcf8, 0x208f82f9, 0x350b82fb, 0x00003cfc, 0x000048fd,
+    0x000030fe, 0x010028ff, 0x01002c00, 0x03824c01, 0x0100f438, 0x0100a403, 0x0100c805, 0x0100dc06, 0x0100ec07, 0x01000809, 0x0382340a, 0x0100fc24,
+    0x03820c0d, 0x01009c33, 0x0100bc0e, 0x01006c0f, 0x01002010, 0x0100cc11, 0x25138212, 0x01005013, 0x03821814, 0x0100d827, 0x0100e415, 0x282b8217,
+    0x0100a817, 0x01006818, 0x284b8219, 0x0100f81a, 0x01008c1b, 0x2c2f821c, 0x0100481e, 0x0100ac1f, 0x0100e021, 0x24338223, 0x01005c25, 0x242b8225,
+    0x01001427, 0x28078227, 0x01008028, 0x0100642a, 0x2097822c, 0x204b822d, 0x2043822f, 0x205f8231, 0x203f8232, 0x289b8233, 0x0100f034, 0x01003c36,
+    0x2c138237, 0x01005838, 0x01008839, 0x0100c43a, 0x202b823b, 0x20cf823d, 0x20c3823e, 0x2023823f, 0x20578241, 0x28178242, 0x0100b043, 0x01002445,
+    0x28938246, 0x0100b847, 0x01009048, 0x20178249, 0x24c3824b, 0x0100d04c, 0x209f824d, 0x20b7824e, 0x20178250, 0x24838252, 0x01001c54, 0x280b8255,
+    0x01007c56, 0x01007457, 0x20078258, 0x24078259, 0x01004c5b, 0x2433825c, 0x0100785d, 0x201f825e, 0x208f825f, 0x24c78260, 0x0100d461, 0x24cb8262,
+    0x01009463, 0x206b8264, 0x29a38265, 0x0100ec66, 0x01002068, 0x03825469, 0x0100f423, 0x2023826a, 0x241b826b, 0x0100346d, 0x207b826e, 0x20df8270,
+    0x25078271, 0x01006073, 0x03820474, 0x75200b82, 0x76204b82, 0x77242f82, 0x78010044, 0x7920fb82, 0x7a286382, 0x7c0100c0, 0x7d0100a0, 0x7e240f82,
+    0x7e010010, 0x7f203782, 0x7f29a382, 0x800100cc, 0x81010080, 0x82038250, 0x828220bf, 0x828320eb, 0x8284209f, 0x8285200b, 0x70872403, 0x82870100,
+    0xfc882883, 0x588a0100, 0x828b0100, 0x828c207b, 0x828e200f, 0x828f20ff, 0x8291201f, 0x8292201f, 0x82942097, 0x82962097, 0x829820b7, 0x8299206b,
+    0x829b205b, 0x829c209f, 0x829d20bf, 0x829f2073, 0xe89f2497, 0x82a00100, 0x40a1246b, 0x82a10100, 0x82a2202b, 0x82a22037, 0x48a3243f, 0x82a30100,
+    0x82a5209b, 0x82a5202f, 0x82a62053, 0x28a7248b, 0x83a70100, 0x24738207, 0x0100a8a8, 0x28b382a9, 0x010008aa, 0x01001cab, 0x20a782ac, 0x24b782ad,
+    0x0100a4ad, 0x206782ae, 0x203782af, 0x206382af, 0x200b82b0, 0x203382b1, 0x204382b2, 0x25f782b3, 0x0100d0b3, 0x03827cb4, 0xb5206b82, 0xb62c1b82,
+    0xb7010084, 0xb80100ac, 0xb901009c, 0xb9203f82, 0xba248b82, 0xba01008c, 0xbb20a382, 0xbc200782, 0xbc207382, 0xbd288782, 0xbd010078, 0xbf0100f0,
+    0xc0246f82, 0xc0010020, 0xc1288382, 0xc20100d8, 0xc30100b4, 0xc420df82, 0xc5204382, 0xc6240b82, 0xc70100bc, 0xc7257b82, 0xc80100f8, 0x82038254,
+    0x82c92067, 0x82ca2067, 0x6ccb289f, 0xe0cb0100, 0x82cc0100, 0x82cc200f, 0x10cd2467, 0x82cd0100, 0xeccd2477, 0x82ce0100, 0x82ce201f, 0x4ccf284f,
+    0xc4cf0100, 0x82d00100, 0x82d0208b, 0x82d12027, 0x82d1206f, 0x30d224a3, 0x82d20100, 0x82d320bb, 0x82d420c7, 0xe8d524cf, 0x82d60100, 0x82d6209f,
+    0x82d72067, 0x82d72027, 0x3cd8281b, 0xb0d80100, 0x82d90100, 0x82da20af, 0x0cdb245f, 0x82db0100, 0x82dc202f, 0x82dd2003, 0x82de2023, 0x82df200f,
+    0x83e02003, 0x00a02703, 0x002ce101, 0x7f82e201, 0x9782e320, 0x4f82e320, 0x0088e424, 0x8382e401, 0xf382e520, 0x00f4e529, 0x00c8e601, 0x821ce701,
+    0x20178203, 0x200782e8, 0x2c5b82e8, 0x0100a4e9, 0x010068ea, 0x010004eb, 0x243b82ed, 0x010060ee, 0x201782ee, 0x209382ef, 0x24b382f0, 0x0100fcf0,
+    0x297b82f1, 0x0100dcf2, 0x0100b4f3, 0x03827cf4, 0x0100e423, 0x244382f5, 0x010020f6, 0x20db82f6, 0x207b82f7, 0x201782f8, 0x20af82f9, 0x206b82fa,
+    0x209b82fb, 0x201382fc, 0x203382fd, 0x314382ff, 0x0200d0ff, 0x02008c00, 0x02004801, 0x02000402, 0x03822c03, 0x0200cc24, 0x03821405, 0x03826020,
+    0x0200fc2c, 0x0200d806, 0x02002008, 0x03827009, 0x0200e823, 0x2517820a, 0x02007c0b, 0x03821c0c, 0x0200e424, 0x0382980d, 0x0e2d1782, 0x0f020090,
+    0x110200dc, 0x12020034, 0x23038210, 0x130200ec, 0x13203382, 0x14206382, 0x15200b82, 0x16255782, 0x16020008, 0x20038244, 0x23038280, 0x170200bc,
+    0x17216f82, 0x8207829c, 0x18182437, 0x82180200, 0x5c19254b, 0x241a0200, 0x782b0382, 0xb01b0200, 0xa41c0200, 0x821d0200, 0x821e2047, 0xf41e2c2b,
+    0xac1f0200, 0x64200200, 0x82210200, 0x8222201b, 0x40232803, 0xd4230200, 0x82240200, 0x8225202f, 0x8227200f, 0x00282c47, 0xe0280200, 0xc8290200,
+    0x822a0200, 0xf82a24af, 0x822b0200, 0x202c28e7, 0xb42c0200, 0x822d0200, 0x822d20ef, 0x822d206b, 0x382e28b7, 0x882e0200, 0x822f0200, 0x822f2033,
+    0x82302097, 0x82302007, 0x94312537, 0x0c330200, 0x68270382, 0x74340200, 0x82350200, 0x8236201b, 0x8237209b, 0x8239203b, 0x823a200f, 0x503b2523,
+    0x283c0200, 0xdb820382, 0xf3823d20, 0x00c43d24, 0xa3823e02, 0xbf824020, 0x00c04024, 0x6b824102, 0x00a84224, 0x93824302, 0x007c4424, 0xfb824502,
+    0x001c4624, 0x4b824602, 0x00144728, 0x00fc4702, 0x33824802, 0x63824920, 0x6b824a20, 0xbf824a20, 0x53824b20, 0x00844c28, 0x00544d02, 0x07824e02,
+    0x00304f28, 0x00dc4f02, 0x03825002, 0x27825120, 0x00345224, 0x53825202, 0x002c5328, 0x00ac5302, 0xff825402, 0x00e4542c, 0x00905502, 0x006c5602,
+    0x2f825702, 0x47825720, 0x07825820, 0x7f825820, 0x009c5924, 0xb7825a02, 0x97825b20, 0x6b825c20, 0xeb825d20, 0x47825e20, 0xbf825e20, 0x0b825f20,
+    0x4b826020, 0x0b826120, 0xf7826320, 0x5b826420, 0x1b826520, 0x33826620, 0xe3826720, 0x004c6828, 0x00b86802, 0xcf826902, 0x5f826920, 0x00f86928,
+    0x00e86a02, 0x13826b02, 0x4b826c20, 0x00486d28, 0x00d46d02, 0xd3826f02, 0x00a06f24, 0x3f827002, 0x33827120, 0x93827220, 0x0010732c, 0x00bc7302,
+    0x008c7402, 0xf7827502, 0x3f827620, 0x67827720, 0x00187924, 0x43827902, 0x53827b20, 0x33827b20, 0x1f827c20, 0x00d87d28, 0x00d07e02, 0xc7827f02,
+    0x00808028, 0x003c8102, 0xcb828202, 0x00288328, 0x00f08302, 0xa3828402, 0x00708528, 0x00388602, 0x73828702, 0x00048824, 0x4b828802, 0x6f828a20,
+    0x33828a20, 0x73828b20, 0x2b828c20, 0x00088d28, 0x00848d02, 0x6f828f02, 0xdb829020, 0x43829120, 0x0060922c, 0x00149302, 0x00309502, 0x93829602,
+    0x00b09624, 0xbb829702, 0xc3829820, 0x00509a24, 0x33829b02, 0x2b829b20, 0x00549c28, 0x00fc9c02, 0x8f829d02, 0x00949f24, 0x4382a002, 0x9382a020,
+    0x007ca124, 0x3b82a202, 0x3782a220, 0x3f82a420, 0x0f82a520, 0x6382a620, 0x3b82a720, 0x0068a824, 0x6382a902, 0x00b4a92c, 0x0000ab02, 0x002cac02,
+    0xcb82ad02, 0x001caf24, 0x5f82af02, 0x1b82b020, 0x5f82b120, 0x00f8b12c, 0x00dcb202, 0x0020b402, 0x1382b502, 0x0090b624, 0xbf82b702, 0x6782b820,
+    0x9f82b920, 0x5f82ba20, 0x00bcba24, 0xdf82bb02, 0xc782bc20, 0x00e8bc24, 0x6f82bd02, 0xd782be20, 0x003cbf24, 0x9f82c002, 0x0024c129, 0x00c0c102,
+    0x825cc202, 0x00f42303, 0x8382c302, 0x2782c320, 0x00ccc424, 0x0782c502, 0x0004c725, 0x8270c702, 0x20c38203, 0x209b82c9, 0x207782ca, 0x208b82ca,
+    0x20cf82cb, 0x203382cc, 0x203382cc, 0x206382cd, 0x242382ce, 0x0200f0ce, 0x203382cf, 0x209382d0, 0x289382d2, 0x0200e0d2, 0x0200a4d3, 0x247f82d4,
+    0x020014d5, 0x249b82d5, 0x0200a8d6, 0x28df82d7, 0x0200d4d7, 0x020078d8, 0x208782d9, 0x202382d9, 0x296782da, 0x0200c4da, 0x020048db, 0x038210dc,
+    0xde20db82, 0xdf201382, 0xdf203782, 0xe1207b82, 0xe4244f82, 0xe602009c, 0xe8207382, 0xe9208382, 0xea246f82, 0xeb0200e4, 0xec240382, 0xed0200b8,
+    0xee202382, 0xef207782, 0xf0200382, 0xf1249382, 0xf20200b4, 0xf320a382, 0xf4240782, 0xf5020080, 0xf628f382, 0xf602001c, 0xf70200ec, 0xf9202f82,
+    0xfa20e782, 0xfb20cf82, 0xfc20fb82, 0xfc247382, 0xfd020088, 0xfd205b82, 0xff254782, 0x01030050, 0x2b038210, 0x02030078, 0x03030088, 0x04030030,
+    0x042d0f82, 0x050300f4, 0x060300a8, 0x07030068, 0x27038228, 0x090300dc, 0x0a030024, 0xac240383, 0x0c0b0300, 0x94200382, 0xec240382, 0x480c0300,
+    0x9c200382, 0xf82c0382, 0xb00d0300, 0x840e0300, 0x3c0f0300, 0x3f820382, 0x0018102d, 0x00bc1003, 0x005c1103, 0x82001203, 0x00a42403, 0x82601303,
+    0x00fc2b03, 0x00a01403, 0x007c1503, 0x5f821603, 0x43821720, 0x00d01725, 0x82201803, 0x00902303, 0x2b821903, 0x53821920, 0x002c1a24, 0x73821b03,
+    0x57821b20, 0x07821c20, 0x3f821c20, 0x00c01d24, 0x43821e03, 0x00141f24, 0xb3821f03, 0x8b822020, 0x2b822020, 0xb7822120, 0x93822120, 0x07822220,
+    0x2f822220, 0x00542324, 0x67822303, 0x00b42428, 0x00442603, 0x03822703, 0x4f822820, 0x2b822920, 0x00582a24, 0x4f822b03, 0x00e02b24, 0xcf822c03,
+    0x00502d28, 0x00642e03, 0x7f822f03, 0xc7822f20, 0x43823120, 0x0b823220, 0x2b823220, 0x008c3324, 0x23823303, 0x6b823420, 0x2f823520, 0x3b823720,
+    0xdf823820, 0x1b823820, 0xc3823920, 0x006c3a28, 0x00f43a03, 0xe7823b03, 0xbb823c20, 0xa3823d20, 0x001c3f24, 0x3f824003, 0x00084124, 0xcb824203,
+    0x3f824220, 0xb3824320, 0x17824420, 0xbf824420, 0x00c84528, 0x00984603, 0x67824703, 0x00d44728, 0x00684803, 0xcf824903, 0x5b824a20, 0x47824b20,
+    0x00e84c24, 0xc3824d03, 0x00704e25, 0x82044f03, 0x007c2403, 0x82285003, 0x00d82303, 0x17825103, 0x57825320, 0xd7825320, 0x57825420, 0x00485524,
+    0x63825603, 0x0f825720, 0x00805824, 0x8b825803, 0x00b85928, 0x00f05a03, 0x07825b03, 0x00a85c24, 0x97825d03, 0x6f825e20, 0xab825f20, 0x000c6128,
+    0x00306203, 0x33826303, 0x00786424, 0x27826403, 0xc7826520, 0x4b826620, 0xe3826720, 0x6b826820, 0x83826920, 0x004c6a28, 0x00c46a03, 0x07826b03,
+    0x73826c20, 0xbf826d20, 0xf7826e20, 0xbb826f20, 0x008c7024, 0x4b827103, 0x47827220, 0x00507328, 0x00ec7303, 0x43827403, 0x4f827520, 0x57827620,
+    0x00d0762c, 0x005c7703, 0x00947903, 0x5f827a03, 0x00407c24, 0x2b827d03, 0x27827d20, 0x00487f24, 0x23828003, 0x67828020, 0xef828120, 0x001c8224,
+    0x6f828303, 0xbf828420, 0x0074852c, 0x00388603, 0x00688703, 0x4f828803, 0xbb828920, 0xf7828a20, 0x6f828b20, 0x13828c20, 0x00148d29, 0x00c08d03,
+    0x82448e03, 0x00dc2303, 0x13828f03, 0x67829020, 0xa3829120, 0x23829220, 0x4b829320, 0x00089430, 0x00d49403, 0x00909503, 0x00209603, 0x4f829703,
+    0xb7829820, 0x03829920, 0x9f829a20, 0x00349b24, 0x6f829c03, 0x00709d24, 0xdf829e03, 0x13829f20, 0x1382a020, 0x3b82a120, 0x9b82a220, 0x00e4a229,
+    0x00aca303, 0x8254a403, 0x00e82403, 0x8264a603, 0x24cf8203, 0x0300b8a7, 0x287b82a8, 0x0300e0a9, 0x03009caa, 0x203382ab, 0x200b82ab, 0x207f82ae,
+    0x20db82af, 0x204b82af, 0x20df82b0, 0x247782b1, 0x0300c8b2, 0x203782b3, 0x20c382b4, 0x296782b6, 0x030010b7, 0x03006cb8, 0x038224b9, 0x0300cc23,
+    0x29bb82ba, 0x03000cbc, 0x0300a4bc, 0x038260bd, 0x0300d823, 0x206382be, 0x201b82bf, 0x202f82c0, 0x205782c1, 0x201f82c3, 0x205782c4, 0x200382c5,
+    0x20c382c6, 0x207f82c6, 0x202782c7, 0x20af82c8, 0x20d782c9, 0x206382c9, 0x280382ca, 0x030028cc, 0x030014cd, 0x201382ce, 0x209f82ce, 0x247782cf,
+    0x03004cd0, 0x201782d2, 0x20bf82d2, 0x204782d4, 0x230383d5, 0xd6030080, 0xd724f782, 0xd90300f4, 0xda209782, 0xdb201b82, 0xdc200382, 0xde24b382,
+    0xe0030088, 0xe1200382, 0xe2246382, 0xe40300d4, 0xe5289782, 0xe80300fc, 0xe903007c, 0xeb201382, 0xec203f82, 0xed20bf82, 0xee200382, 0xf0204382,
+    0xf0200f82, 0xf2204782, 0xf2287782, 0xf40300a8, 0xf5030034, 0xf620ff82, 0xf8200382, 0xfa204782, 0xfd205782, 0xfe201b82, 0xff3d2782, 0x000400a0,
+    0x010400b4, 0x020400ac, 0x030400dc, 0x040400bc, 0x050400c8, 0x06040050, 0x24038238, 0x080400f8, 0x24038204, 0x09040090, 0x2403821c, 0x0b0400e0,
+    0x2b038210, 0x0c040094, 0x0d04002c, 0x0e040018, 0x20080383, 0x0f0400c0, 0x10040074, 0x1104008c, 0x120400b0, 0x130400cc, 0x150400fc, 0x160400a4,
+    0x17040070, 0x28038240, 0x190400f0, 0x1a0400a8, 0x82038258, 0x821b206b, 0x821c2033, 0x801d247b, 0x821f0400, 0x8220204b, 0x9c21315b, 0xd4220400,
+    0x84230400, 0x48240400, 0x5c250400, 0xf42b0382, 0x88260400, 0x60280400, 0x82290400, 0xd82a248b, 0x822b0400, 0x822c2027, 0x822d201f, 0x822e201f,
+    0x542f245f, 0x82300400, 0x82312013, 0x82322053, 0x983324b3, 0x82340400, 0x8235208f, 0x0c3624c7, 0x82370400, 0x143825bb, 0x00390400, 0xf3820382,
+    0x4b823a20, 0x17823b20, 0x27823b20, 0x97823c20, 0x3f823e20, 0x67823e20, 0x43823f20, 0x00684124, 0x53824304, 0x00284524, 0xdb824604, 0x7b824820,
+    0x57824920, 0xab824a20, 0x27824b20, 0x00204c28, 0x00244d04, 0x5b824f04, 0x1b825020, 0x47825220, 0x07825220, 0x1b825420, 0x57825520, 0xbf825520,
+    0x006c5624, 0xe3825704, 0x2b825920, 0xa7825a20, 0x00385b28, 0x00b05c04, 0x27825e04, 0x63825f20, 0x0034612c, 0x00d06104, 0x00b86204, 0x0b826504,
+    0x6f826620, 0x00406824, 0x3b826a04, 0x008c6b24, 0x13826c04, 0xb3826d20, 0xef826e20, 0x00c46e24, 0x17826f04, 0x00fc7024, 0x8f827204, 0xdf827220,
+    0x37827320, 0x00947424, 0x37827504, 0x004c7624, 0x3b827704, 0x00a47824, 0xbb827904, 0x23827b20, 0x00bc7b24, 0x37827c04, 0x37827d20, 0x83827f20,
+    0x7b827f20, 0x03828020, 0x005c8124, 0xb7828204, 0x00848324, 0xd3828404, 0x0000862c, 0x00988604, 0x00748704, 0x4b828804, 0xd7828920, 0x1f828b20,
+    0x00c88c24, 0x7b828e04, 0x00d88e28, 0x00808f04, 0x37829204, 0x47829320, 0x1b829420, 0x07829520, 0x27829620, 0x1b829620, 0x93829720, 0x00e49824,
+    0xdf829904, 0x00649a2d, 0x00789c04, 0x00109d04, 0x82289e04, 0x24438203, 0x040008a0, 0x209b82a0, 0x20af82a1, 0x20b782a2, 0x209382a4, 0x209b82a5,
+    0x207382a6, 0x20ff82a7, 0x201f82a9, 0x24ef82a9, 0x04000cab, 0x207f82ac, 0x202782ad, 0x245782ae, 0x0400b4b0, 0x287382b2, 0x0400e8b3, 0x0400acb4,
+    0x241b82b5, 0x0400a8b6, 0x285b82b8, 0x04001cb9, 0x040060ba, 0x205f82bb, 0x284b82bc, 0x0400f4bd, 0x04002cbf, 0x201b82c0, 0x203f82c0, 0x200382c1,
+    0x20b382c2, 0x201382c5, 0x389782c6, 0x040030c7, 0x0400d4c8, 0x0400dcc9, 0x040094ca, 0x04004ccb, 0x040058cc, 0x20df82cd, 0x285b82ce, 0x0400f0cf,
+    0x0400b0d0, 0x248b82d2, 0x040084d2, 0x20d382d3, 0x20ab82d4, 0x242382d5, 0x040034d7, 0x207782d7, 0x207382d8, 0x292782d8, 0x04007cd9, 0x04003cdb,
+    0x038200dc, 0x04007423, 0x206382dd, 0x20ab82dd, 0x200382de, 0x20c782df, 0x297b82e0, 0x040054e2, 0x040048e3, 0x038250e4, 0xe5209f82, 0xe6208b82,
+    0xe820d382, 0xe9203382, 0xea248b82, 0xec040020, 0xed206b82, 0xee248782, 0xf00400d8, 0xf0242f82, 0xf10400e4, 0xf2242b82, 0xf40400c0, 0xf4201b82,
+    0xf5207382, 0xf6244382, 0xf6040014, 0xf62c6782, 0xf70400c4, 0xf8040098, 0xf9040090, 0xf9209782, 0xfb209f82, 0xfb244f82, 0xfc040088, 0xfd208f82,
+    0xfe204782, 0xff299b82, 0x0005000c, 0x0205003c, 0x28038204, 0x030500b0, 0x04050074, 0x28038230, 0x050500d0, 0x070500c4, 0x2c038244, 0x080500f0,
+    0x090500b8, 0x0a050084, 0x23038268, 0x0c0500fc, 0x0d340b82, 0x10050008, 0x120500e4, 0x13050080, 0x140500a0, 0x15050048, 0x16283782, 0x16050038,
+    0x180500dc, 0x19204b82, 0x1a300b82, 0x1b050054, 0x1c050070, 0x1d0500a4, 0x1f0500d8, 0x20287382, 0x21050040, 0x2205005c, 0x23345f82, 0x23050014,
+    0x240500b4, 0x2505001c, 0x26050018, 0x27050010, 0x28211382, 0x089b8228, 0xc0ff0045, 0xc0018001, 0x18001400, 0x20001c00, 0x00002400, 0x07062101,
+    0x16110706, 0x21171617, 0x37363736, 0x26272611, 0x27010f27, 0x07170733, 0x17371311, 0x37273723, 0xfe500111, 0x0d0e14e0, 0x0e0d0101, 0x87200114,
+    0x5a362f09, 0x5adab359, 0x5a59275a, 0x5959d9b3, 0x1d83c001, 0x8860fe21, 0x83a02027, 0x86402909, 0x86863a86, 0xbafe0c01, 0x2d080884, 0x0000f4fe,
+    0x18000200, 0x6800e1ff, 0x1300a001, 0x00002500, 0x31373237, 0x34113536, 0x22232627, 0x011d0607, 0x33161714, 0x31072215, 0x09831506, 0x36373223,
+    0x231a8235, 0x090e4027, 0x0e200082, 0x11250585, 0x0b0c0c0b, 0x22058511, 0x82090960, 0x24178598, 0x090a0eff, 0x27198430, 0x100c0b0b, 0x010b0c10,
+    0x6f826e82, 0xe0ff0022, 0xa0249e82, 0x59005400, 0x2322f182, 0xe3823637, 0x06072624, 0x0a8b010f, 0x71837c82, 0x07013b22, 0x0a868783, 0x16170622,
+    0x36248e82, 0x0733013f, 0x32210a83, 0x860a8333, 0x012b2393, 0x0a863337, 0x23072333, 0x01073337, 0x010a3aa0, 0x0d0e0707, 0x0b030a0b, 0x200a895f,
+    0x219d8545, 0x0887153a, 0x02231a84, 0x86071903, 0x8f0a8425, 0x5f9b2725, 0x01155f15, 0x4d823b41, 0x82020221, 0x89452055, 0x0a092209, 0x2052820d,
+    0x21068380, 0x16830908, 0x02020323, 0x201f8419, 0x21078203, 0x1d850909, 0x0f0d0928, 0x80c00a0a, 0x00820080, 0x10000137, 0x3001c0ff, 0x7300c001,
+    0x32130000, 0x1d163117, 0x32333201, 0x83dd8233, 0x060725e1, 0x26270607, 0x22220182, 0x0b832623, 0x1f211383, 0x821c8a01, 0x14152e14, 0x22230607,
+    0x013d2627, 0x15263130, 0x822d8331, 0x36372303, 0x2d833637, 0x83161721, 0x22418209, 0x8a012f26, 0x2614821a, 0x36373435, 0x82a03133, 0x023108b0,
+    0x09010101, 0x0c0b1211, 0x04030707, 0x070d0b0b, 0x020a0e0e, 0x1a1d3102, 0x03030202, 0x0330190a, 0x14171816, 0x060c0e16, 0x19121106, 0x09091814,
+    0x3334820e, 0x1a191401, 0x04050c15, 0x0c0b0605, 0x1516110c, 0x191b3110, 0x12242f90, 0x16141913, 0x01212f82, 0x200482c0, 0x204d8224, 0x245f8302,
+    0x0306070d, 0x39008202, 0x120a0c07, 0x0806050f, 0x05010c0e, 0x0e0c0809, 0x1d1f1b1a, 0x080a1413, 0x98412103, 0x01232b05, 0x07070301, 0x0c0c0609,
+    0x68820c0d, 0x06060724, 0x32820603, 0x06051024, 0x32880f07, 0x131d2027, 0x02080913, 0x23328223, 0x03000000, 0x00330382, 0x80018001, 0x25001300,
+    0x00003700, 0x31232601, 0x42010722, 0x013a07b4, 0x27343536, 0x31373605, 0x27263736, 0x07062726, 0x17160706, 0x06051716, 0x09853107, 0x85373621,
+    0x77012619, 0x0a0d0d0a, 0x83b782fe, 0x40012d07, 0xc9fe0909, 0x0112121b, 0x1b121201, 0x01210787, 0x20119000, 0x20278277, 0x233183c0, 0x40010909,
+    0x77200783, 0x2e83308b, 0x108f8020, 0x00010033, 0x01e0ff19, 0x00a001a5, 0x2500003c, 0x2f222306, 0x09d34101, 0x2305db41, 0x013f3637, 0x2630ae82,
+    0x16173637, 0x3435011f, 0x32333637, 0x011d1617, 0x2305e541, 0x010f0607, 0x162ac482, 0x0aa10107, 0x75080812, 0xba820909, 0x08760a34, 0x060a1208,
+    0x750c0303, 0x04030c75, 0x06140d06, 0xba417606, 0x06762605, 0x070a1506, 0x29198204, 0x03030c76, 0x04105007, 0x71418945, 0x45893105, 0x0c0c1004,
+    0x4444070d, 0x0c0c0d07, 0x03010212, 0x03231989, 0x89120201, 0x00002d1b, 0x10000100, 0xb001f0ff, 0x29009001, 0x1424b782, 0x2b063107, 0x2323b88a,
+    0x83262722, 0x8a3b20a8, 0x22b483ae, 0x82b00115, 0x85902085, 0x85902089, 0x200d8a76, 0x911182c0, 0x32318615, 0x00020000, 0x01e1ff00, 0x00a00140,
+    0x00270013, 0x82061300, 0x15072e75, 0x17161716, 0x37363736, 0x26272635, 0x83138527, 0x83352009, 0x291b8313, 0x2d44a015, 0x2d02022d, 0x0787442d,
+    0x1b016028, 0x1b29291b, 0x0788011b, 0x1e83a020, 0x1f877f20, 0xfe210884, 0x202187e0, 0x20088880, 0x24f78300, 0x01e0ff00, 0x20838200, 0x88f78824,
+    0x431120ec, 0x372405b0, 0x36013f36, 0x11209582, 0x0020f285, 0xd983c082, 0x402f0682, 0x0d0c0c2e, 0x02030708, 0x1110600b, 0x82400110, 0x450020ef,
+    0x01220843, 0x19831f24, 0x40262183, 0x1309090a, 0x3182a0fe, 0x00217282, 0x20f78201, 0x22f782e0, 0x862b009f, 0x21232173, 0x6482e282, 0x22053445,
+    0x4206010f, 0x7685051f, 0x06071624, 0x7a85010f, 0x41824020, 0x00ff2208, 0x0f070915, 0x010218c1, 0x23241715, 0x0d0b231a, 0x01090a0c, 0x2d230901,
+    0x25293f40, 0x882a0302, 0x2d8686b0, 0x0f141301, 0x1f2018b9, 0x01021b1b, 0x23832018, 0x1f292b83, 0x2f05022a, 0x2a38392e, 0x884c8282, 0x00a0228b,
+    0x258b8237, 0x06310706, 0xff822307, 0x42262721, 0xf582058d, 0x45433320, 0x84232007, 0x090a42a3, 0x16171622, 0x05829782, 0xcb821720, 0x3a26273b,
+    0x1b1b2450, 0x0605040b, 0x0c0b0d0d, 0x501e0b04, 0x0114141f, 0x1f141401, 0x21af8368, 0x17419e84, 0x84f02005, 0x3916280c, 0x68022627, 0x8227263a,
+    0x0d212a1f, 0x04050b0c, 0x1c0c0606, 0x200d8202, 0x2335841f, 0x780f1513, 0x20055442, 0x200a8301, 0x415d8201, 0x802408ab, 0x2f009f01, 0x2116a342,
+    0x29451337, 0x43988206, 0x33200958, 0x1522a382, 0x50828001, 0x54852020, 0x0a11e02f, 0x06800709, 0x0c0d0c0c, 0x6a050404, 0x201585ad, 0x20a18220,
+    0x20038272, 0x25a98552, 0x0f0f0f52, 0x20830f01, 0xe0212883, 0x2415858e, 0x0909018e, 0x248b880d, 0x00a00140, 0x20374135, 0x26272231, 0x3736013f,
+    0x16173233, 0x06071415, 0x8307012b, 0x05354191, 0x24503924, 0x35411c1c, 0x1f0c2308, 0x35411e50, 0x991e2805, 0x03090a0f, 0x42190620, 0xa5270669,
+    0x26397315, 0x83670127, 0x14142204, 0x06334122, 0x021c0d27, 0x1e141401, 0x2533821f, 0xb20e0c0b, 0xc9850218, 0x26027124, 0x5f433a26, 0x01e02105,
+    0x1d25a383, 0x00002f00, 0x055d4213, 0x07222323, 0x43018506, 0x2629086a, 0x07272627, 0x26312726, 0x07644327, 0xa8302183, 0x01010940, 0x0e0b0a0a,
+    0x301a210a, 0x0b0b1b1c, 0x23087343, 0x08412b2a, 0x330c6f43, 0x01291b1b, 0x0d0b4c1f, 0x0b08090c, 0x23371e27, 0x1f1a1a23, 0x25077d43, 0x042d2c42,
+    0x218201ff, 0x1b1a2923, 0x24078201, 0x1b1c2828, 0x0a774201, 0x00001825, 0x42060301, 0x13200674, 0x32075e42, 0x17162133, 0x3c010716, 0x08120ae0,
+    0x03030c08, 0x41c8c406, 0x01310580, 0x080a1200, 0xfe700108, 0x07041080, 0x010c0c0d, 0x27f38550, 0x10100f01, 0x03000000, 0x29065b43, 0x001e00a0,
+    0x00440031, 0x02462500, 0x46232005, 0x0582051d, 0x3320f584, 0x3425e883, 0x012f2627, 0x20678233, 0x23168217, 0x27262307, 0x1320ff85, 0x1b880988,
+    0x230c0131, 0x24250101, 0x24362036, 0x23010125, 0x830e0e18, 0x8340200d, 0x0e0e240d, 0x46207c18, 0x0888073a, 0x87403021, 0x22088812, 0x843524c7,
+    0x2446823d, 0x1b122435, 0x824b851a, 0x1a20240d, 0x4699121b, 0xfe210f48, 0x41118fc0, 0x1e230bcf, 0x45003000, 0xbe83062f, 0x17060722, 0x33220682,
+    0xd5833732, 0x35200382, 0x1120ca83, 0x4510d041, 0x2a220538, 0xd841412b, 0x1b31210a, 0x4106d841, 0xa02810cf, 0x442d2d02, 0x042d2c42, 0x2112d741,
+    0xc84100ff, 0x07d84107, 0x00820020, 0x04840120, 0x7f017f30, 0x00001800, 0x25272225, 0x37362726, 0x9b833625, 0x07060724, 0xa382010d, 0x06072808,
+    0x075f0123, 0x10c0fe07, 0x01110101, 0x0c0c0c40, 0x04040507, 0x01fafe0c, 0x04040c06, 0x00140a05, 0x130aa003, 0x83a00a13, 0x221d8315, 0x82078383,
+    0x00122e06, 0x00100002, 0x01b00141, 0x0012003f, 0x20fb8225, 0x07144a21, 0x524a2120, 0x05332106, 0x1b880988, 0x60013022, 0x21053442, 0x0785a0fe,
+    0x89600121, 0x2d118609, 0x0e090900, 0x0909080e, 0x090d0d09, 0x0685800a, 0x0d231282, 0x85000909, 0x858020cf, 0x223728cf, 0x36372627, 0x49012d37,
+    0x052a078f, 0x07061716, 0x20230605, 0xac830a13, 0xfe060123, 0x83c283fa, 0x400122ae, 0x25de8211, 0x0707c0fe, 0xc4891200, 0xdc851d83, 0xfb460320,
+    0x002e220b, 0x24cf8240, 0x06070623, 0x088b4b07, 0x3b363725, 0x82171601, 0x010f2160, 0x8206ac4b, 0x013d21ee, 0x36217f82, 0x217f8235, 0xba4b0327,
+    0x6ccc2510, 0x011b1b29, 0x82050a43, 0x166c2805, 0x01010e0f, 0x8510621d, 0x1e502811, 0x21011111, 0x4b3c3121, 0x01250bd4, 0x1b1b01a0, 0x2cfb8529,
+    0x0109090e, 0x1f160f0e, 0x120a3910, 0x05194128, 0x0f2f162b, 0x31211c1b, 0xfe012121, 0x0dee4b90, 0x1000022c, 0xef01d3ff, 0x4800af01, 0xbb825a00,
+    0x31070622, 0xa04abd82, 0x4a352007, 0x894506b5, 0x48172006, 0x262109fe, 0x20e58227, 0x057b4426, 0x36212d82, 0x83e28237, 0x4a3d20d2, 0x072205cc,
+    0x82442213, 0x3b36840a, 0x323347d0, 0x17170d0f, 0x0f423232, 0x19020b0a, 0x012a2a40, 0x50383702, 0x012c2c46, 0x0c3f9384, 0x0c200f01, 0x1e302603,
+    0x05051413, 0x28342020, 0x1c1d121e, 0x14152322, 0x41282701, 0x4d1f4e40, 0x4c080728, 0x0e0e0e14, 0xab01150d, 0x4733320f, 0x293d3d47, 0x0a020a29,
+    0x051a0f09, 0x44302f0c, 0x0532334f, 0x47343309, 0x0b0c1110, 0x78110c0b, 0x0b01020e, 0x170b0f14, 0x24361f18, 0x17010125, 0x080b0b17, 0x241d1d09,
+    0x3a3b4b15, 0xfe0e1c1d, 0x874982e5, 0x0d152257, 0x0767450e, 0xa0018030, 0x1d001900, 0x03250000, 0x07062726, 0xe2820603, 0x36371625, 0x8233013f,
+    0x83322008, 0x272d08e7, 0x23173725, 0x09a07e01, 0xa0081515, 0x0d050405, 0x060c0c0c, 0x0a1fc61f, 0x0d060614, 0xfe040405, 0x914849f9, 0x1380010c,
+    0xfe130101, 0x201c8380, 0x25248204, 0x01134c4c, 0x0d820602, 0xadad7422, 0x240bdf44, 0x00250019, 0x09df4431, 0x06072229, 0x17141115, 0x44013b16,
+    0x352312da, 0x44352313, 0x012709cc, 0x2501011e, 0x41803624, 0xa02005e7, 0x1124e583, 0x60c11d11, 0x2307b244, 0x80808060, 0xce220b87, 0x1f833022,
+    0x0e090923, 0x832f83fe, 0x1d232437, 0x4492121c, 0x8022079d, 0x044bc0fe, 0x82002008, 0xff012a00, 0x01e0ffff, 0x009f017f, 0x279b8235, 0x16311716,
+    0x06071415, 0x26210182, 0x23018227, 0x36373435, 0x16210182, 0x84018217, 0x4b158417, 0xbe4408b9, 0x60013605, 0x15070711, 0x31252415, 0x1a313145,
+    0x311a1a1b, 0x24324631, 0x082f8225, 0x10110832, 0x16170e11, 0x28294a28, 0x28280101, 0x1717284b, 0x5810110e, 0x0a0b0a01, 0x1015150c, 0x21010111,
+    0x36333322, 0x21333335, 0x11010122, 0x0c151411, 0x09821a82, 0x0c0c0d31, 0x30310301, 0x31313b3b, 0x0c0c0103, 0x8201110d, 0x020031aa, 0xe0ff0000,
+    0xa0018001, 0x23001700, 0x23130000, 0x460d4341, 0x26240538, 0x11231127, 0x20083b41, 0x063441a0, 0x333e802e, 0x011e1e32, 0x321e1e01, 0x60603e33,
+    0x2107eb46, 0x2841a001, 0x85198408, 0x80fe2a25, 0x2d024001, 0x2e43432d, 0x2072822e, 0x0afb4600, 0xff492a20, 0x27222908, 0x34113526, 0x21333637,
+    0x20082548, 0x09304815, 0x01200a85, 0x4105fe49, 0x012005b6, 0x2006684a, 0x06da44e0, 0x4ae0a021, 0x0120097c, 0x1182a586, 0x00448020, 0x84068305,
+    0x056f4b77, 0x84822420, 0x8a06e34b, 0x067b4e64, 0x7184878a, 0x5d446188, 0x847b8408, 0x06304564, 0x01238386, 0x82090d80, 0x000e2100, 0x00295e82,
+    0x01e2ff01, 0x00a001c0, 0x22e38240, 0x83310706, 0x26232202, 0x20018227, 0x05e64135, 0x83171621, 0x07062201, 0x20158506, 0x46098227, 0x172005c7,
+    0x664a1f83, 0x17322309, 0x48821516, 0x21222e08, 0x43363433, 0x1c1c3231, 0x321e1e01, 0x262b3e32, 0x01181826, 0x0d090901, 0x180e1110, 0x2d432918,
+    0x0d01022d, 0x4123230c, 0x0b2b2b3d, 0x05244186, 0x0682a820, 0x3148c037, 0x01191a32, 0x32331e1f, 0x33323f3b, 0x01011d1e, 0x14150e0f, 0x331a8211,
+    0x0c0e1001, 0x2d02010c, 0x2513452c, 0x02201f26, 0x37232302, 0x21050e46, 0xc4820908, 0x2005a74b, 0x20c38280, 0x20d08228, 0x061e4111, 0x21013d23,
+    0x0c294115, 0x1d22a082, 0x6e4a2101, 0x05684a07, 0xff215c82, 0x082f4100, 0x01200d82, 0x01220d86, 0x9c41fe80, 0xc0c02106, 0x0120a385, 0x80200f86,
+    0x1f420786, 0x078b4d0b, 0x4c212321, 0x21490993, 0x08294209, 0x1d4c1120, 0x2055850b, 0x06f94660, 0x26420120, 0x4c0f8406, 0x40200a9b, 0xfe219c8b,
+    0x8b0d82c0, 0x82242077, 0x4311200c, 0x484b07b5, 0x079a4d09, 0x4e341121, 0x152205b3, 0x134a4001, 0x204e8507, 0x06884d01, 0x802b0d86, 0x2c43fdfe,
+    0x2c02022c, 0x8523432c, 0x28232a96, 0x01011a1a, 0x01281a1a, 0x20108503, 0x0c4b4b00, 0x1622ef83, 0x79823107, 0x2f222324, 0x67410701, 0x2e788612,
+    0x17010f14, 0x03083a01, 0x0a080b02, 0x8c860a10, 0x0ac932cd, 0x0a0a0c0d, 0x128c8909, 0x080c0d0b, 0x42c10e06, 0x0d69416d, 0x0acdb723, 0x27238309,
+    0x0000cb8d, 0xff200001, 0x2005234b, 0x068b4319, 0x43012b21, 0x3223088b, 0x41151617, 0xe0200a5b, 0x2008da4d, 0x116b43c0, 0x4206dd4d, 0xc0240533,
+    0x2400a001, 0x230a3342, 0x06071135, 0x4342d183, 0x11352d07, 0x1f363736, 0x17363701, 0xc0011716, 0x25052d41, 0x11110a85, 0x0b85850a, 0x16160129,
+    0x0ea5a50e, 0x42011616, 0x0127092f, 0x0d0dc816, 0x85eafec8, 0x80012c84, 0x12050817, 0x0512f8f8, 0x41001708, 0x80200843, 0x20207782, 0x2306bb41,
+    0x01272223, 0x17216f8c, 0x09b74101, 0x14018028, 0x0a0f0605, 0x6f86f9fe, 0x0f151424, 0xb5410701, 0x16802808, 0x010c0208, 0x87d8fe3c, 0x0816266b,
+    0xc4fe1006, 0x06194801, 0x230def53, 0x002c001a, 0x51068b4a, 0xbf4f0676, 0x083e4505, 0x2010874a, 0x0b3c45e0, 0xd84f0b8b, 0xa001210f, 0x91056045,
+    0x80fe212f, 0x21057842, 0x5845022c, 0x022d2305, 0xcf450000, 0x01402606, 0x001800a0, 0x0bcf4524, 0x37323325, 0x4e013d36, 0x112008c8, 0x450a0c47,
+    0xe98207d0, 0x2108c545, 0x0c4b6060, 0x09cf4507, 0x0e090923, 0x246a8560, 0x00ff022e, 0x07e842c0, 0xc0227384, 0x7382c001, 0x3c002022, 0x52088d47,
+    0x8452058c, 0x17162505, 0x16173736, 0x35237c83, 0x4d012f34, 0x273b0f66, 0x07062326, 0x1f141506, 0x01070601, 0x01023589, 0x32331d1e, 0x33333e3e,
+    0x85011e1e, 0x35442a0b, 0x100e0a2f, 0x2f070808, 0x0b1f41a9, 0x46200123, 0x2516840b, 0x2d2c2348, 0x2241563d, 0x23012b11, 0x0a010b39, 0x090b0b0a,
+    0x2c410d39, 0x2937230b, 0x17850c54, 0x01155622, 0x250a3341, 0x002f0023, 0x4d533700, 0x080c4708, 0x82063c41, 0x823220c2, 0x2f36221d, 0x080c4702,
+    0xe535232a, 0x01191928, 0x3d292802, 0x0806e551, 0x09090e21, 0x100a695d, 0x030a090a, 0xa5550802, 0x16172270, 0x17160101, 0x118a7022, 0x3d2e2423,
+    0x47022829, 0x0782071f, 0x0d938029, 0x0c0d0806, 0x83d6770c, 0x16223522, 0x009f0116, 0x1f000100, 0x6001e0ff, 0x3e00a001, 0x06250000, 0x51058051,
+    0x3721050d, 0x05514936, 0x8b05c64e, 0x84072013, 0x08584a27, 0x16313022, 0x33082983, 0x0a5e0107, 0x2f2e262f, 0x0c192a2b, 0x06040505, 0x3b0d0b0c,
+    0x151b3232, 0x18170604, 0x2526243f, 0x09081717, 0x0d8a452a, 0x03040706, 0x430d0c0b, 0x130e2525, 0x45291b8a, 0x01141a38, 0x0b0b0c01, 0x821c8206,
+    0x17053e40, 0x0b0f0506, 0x11111e1a, 0x0f100a11, 0x31341e1f, 0x04242c1c, 0x0d0e0b0b, 0x11030606, 0x22428203, 0x83101f16, 0x1e10231b, 0xc782341e,
+    0x20075b48, 0x086b471e, 0x45098d43, 0x01240dc3, 0x0e090980, 0x4307a847, 0x40200672, 0x01210782, 0x4c048280, 0xb14509b0, 0x0def4308, 0x00002424,
+    0xab451501, 0x0a974619, 0x37360227, 0x36375151, 0x23488502, 0x36242501, 0x8406da49, 0x50e2296b, 0x02023636, 0xe2503636, 0xe2288285, 0x01242435,
+    0x35242401, 0x66820f86, 0xd3870020, 0x0c821820, 0x07060326, 0x26032726, 0x21062752, 0xef4b011b, 0x4a072006, 0x092205e0, 0xe04a04a0, 0x83823206,
+    0x0c0c0c05, 0x0404050d, 0x80fe7401, 0x13010113, 0x08db4a01, 0x01c7fe23, 0x20198339, 0x86218206, 0x3f02255f, 0x2600a001, 0x30285f85, 0x0b272623,
+    0x22070601, 0x1621678d, 0x086d8917, 0x903d0233, 0x16011608, 0x08515008, 0x90091616, 0x0d050504, 0x050c0b0d, 0x1708556e, 0x6e550817, 0x0d0b0c05,
+    0x0505050d, 0x80fe7501, 0x15020114, 0xe9fe1701, 0x20068215, 0x83248380, 0xdbfe2b2c, 0x02142401, 0xdcfe1601, 0x28822501, 0x82040421, 0x0d5f4130,
+    0x500e9346, 0x3f2206a9, 0xfa862701, 0x41011f21, 0x16260602, 0x0117010f, 0x33510879, 0x870b2c05, 0x0b0e0b87, 0x01010b09, 0x828f8f08, 0x0a0b2a13,
+    0x87090d0d, 0x0d0d0987, 0x2013850a, 0x25108314, 0xa3a30c07, 0x1483070b, 0x0baaac22, 0x28832082, 0x83a2a221, 0x20138420, 0x051341ac, 0x7f01e126,
+    0x1e00a001, 0x11470c82, 0x923d2008, 0x0107237e, 0xda419a7a, 0x089a3e05, 0x0c0a0302, 0x86080d0c, 0x0c0d0885, 0x03020b0c, 0xd76d0108, 0x09080e96,
+    0x960e0809, 0x831983d7, 0xbbbb2421, 0x8202020b, 0x0c0c217d, 0x200bdb41, 0x08934a1f, 0xe2822620, 0x90510120, 0x0569480e, 0x67828020, 0x14c0fe28,
+    0x010c0809, 0x2e42fc15, 0x40012105, 0xfe210e83, 0x200e83eb, 0x25128200, 0x0f131101, 0x8f854c01, 0xfe210b83, 0x230b82b4, 0x00020000, 0x02270082,
+    0x00800100, 0x8240002a, 0x26232f69, 0x07273527, 0x23070615, 0x16150706, 0xc7503317, 0x26678407, 0x3b161714, 0x4e373201, 0x252b05f3, 0x37321737,
+    0x07232635, 0x83272635, 0x2227212c, 0x33383082, 0x18276001, 0x21202021, 0x010f7718, 0x105d0f01, 0x27271e1e, 0x0d101e1e, 0x40209485, 0x02320682,
+    0xfe442d2d, 0x108e8ef2, 0x6e100202, 0x0f200f01, 0x0a836e01, 0x0814c039, 0x2f04042f, 0x0f011408, 0x1d010f60, 0x11121211, 0x0e09091d, 0x82090a0d,
+    0x2d442b05, 0x0f60022d, 0x111e110f, 0x57831c0c, 0x820c1c21, 0x0300250a, 0xc0ff0000, 0xc02ebb82, 0x3c001100, 0x00005200, 0x31171405, 0xa0873316,
+    0x06070624, 0xcfc00307, 0x3241a020, 0x0e022305, 0x0383020e, 0xdeb64020, 0x00412020, 0x17102905, 0x17020217, 0x20011017, 0xdb46eeb1, 0x40023105,
+    0x2d00c001, 0x00003a00, 0x31070625, 0x17230706, 0x2126e783, 0x27262726, 0xd24d2335, 0x36252305, 0xc8583217, 0x013b2a05, 0x1d161732, 0x07161701,
+    0x292d8231, 0x33171615, 0x26353736, 0x44822327, 0x0d09092e, 0x12010120, 0xbffe1b12, 0x0112121b, 0x0a279f83, 0x0b0b0001, 0x826a0a0c, 0x290e83f1,
+    0xfe010c35, 0x020216b8, 0x04845016, 0x090dc025, 0x83a00109, 0x2135832b, 0x408201a0, 0xe00a0e27, 0x5e070109, 0x24db8525, 0x0e0a2f79, 0x282d8740,
+    0x00000216, 0xff000005, 0x2eaf84c0, 0x00250018, 0x004a0038, 0x0100005b, 0x82313336, 0x0716219d, 0x1520ba82, 0x2109e753, 0x1082013f, 0x0322a089,
+    0xcb820706, 0x2625d382, 0x16373627, 0x24018317, 0x31373425, 0x05864236, 0x2105b759, 0x1a85013d, 0x25082a89, 0x0c0a3a01, 0x0fd00a0c, 0x20150907,
+    0x140e0d01, 0x353512a8, 0xd007024b, 0x02020f0a, 0x010f400f, 0x30400f01, 0xcd821602, 0x4e343422, 0x16260582, 0x1f343441, 0x184c011f, 0x1602250d,
+    0x0127263a, 0x013b2583, 0x16251919, 0x08b80102, 0x140fc108, 0x14700113, 0x4b010d0e, 0x09123635, 0x82b8c106, 0x234e8449, 0xd8fe010f, 0x4e234983,
+    0x84023434, 0x1f1f2533, 0x08413434, 0x2308984a, 0x680e0909, 0x27224382, 0x25833a26, 0x19192522, 0x00215982, 0x08b74204, 0x2e00162f, 0x6e004a00,
+    0x35370000, 0x0f062726, 0x06b65101, 0x82053954, 0x263723fd, 0xbb483127, 0x48152005, 0x362205bc, 0x13823637, 0x06033524, 0xf8443107, 0x20108206,
+    0x24158335, 0x1d161716, 0x22048201, 0x82262507, 0x010f211b, 0x21075b5e, 0xf75d1115, 0x06072905, 0x3316011f, 0x36013f32, 0x49080f82, 0x0e0e019f,
+    0x08110101, 0x0d030309, 0x0d12120d, 0x0903030d, 0x01601109, 0x30301f1f, 0x1f01201f, 0x29280201, 0x29283d3d, 0x231f0101, 0x1a141509, 0x0914151a,
+    0x15070808, 0x140e0d01, 0x160e0d14, 0x01080807, 0x0d0c0b17, 0x1d430609, 0x09083f05, 0x0a0b0d0c, 0x40080102, 0x0a0f0f0b, 0x02010840, 0x0f137d0b,
+    0x140f0102, 0x110f0f06, 0x00820b12, 0x0f111225, 0x83d3060f, 0x20012a5d, 0x25a7301f, 0x28293d34, 0x2f668302, 0xfea72534, 0x0e0f19e7, 0x19180f0f,
+    0xc0101818, 0x2507ca51, 0x181810c0, 0x4a823219, 0x01090a22, 0x22066142, 0x8309dbfe, 0x286c8364, 0x500c0c50, 0x090c0d0b, 0x41008200, 0x6d200f4f,
+    0x21064f41, 0x4f411507, 0x27012643, 0x0f222326, 0x083e5201, 0x15541120, 0x49112007, 0x27240782, 0x0f0e019f, 0x223e4d41, 0x410a401c, 0x0a200639,
+    0x0820d683, 0x23055741, 0x0b0f0a07, 0x0927f283, 0x010fd37d, 0x41d30f01, 0x01253e4d, 0x0b0b500d, 0x255f8450, 0x090a0201, 0xa742dbfe, 0x012c0805,
+    0x070c0925, 0x0b0d0c09, 0x08000000, 0xe0ff0000, 0xa0018002, 0x2d002300, 0x41003800, 0x57004c00, 0x7b006900, 0x16010000, 0x17163117, 0x2605fa50,
+    0x23060714, 0x42272621, 0x2320059b, 0x112a0883, 0x37363736, 0x36150521, 0x15833537, 0x32173123, 0x24088417, 0x17333615, 0x230a8616, 0x17161537,
+    0x33201f86, 0x0e852483, 0x37360123, 0x07c94331, 0x2105cb43, 0x11823217, 0x61343521, 0x152a051c, 0x33161714, 0x0e14f001, 0x0f61010d, 0xbffe2a06,
+    0x2b1f1e07, 0x071e1f2b, 0x08786111, 0x50fec02b, 0x0f01110f, 0x0870010f, 0x24068308, 0x11500808, 0x2008830f, 0x83048360, 0x87802003, 0x80fe2108,
+    0x2220c982, 0x83070a4b, 0x43502007, 0x01260baf, 0x0e0d01a0, 0x8041f014, 0x1a2a2705, 0x1b01011b, 0x12832a1a, 0x83000121, 0x98502b6d, 0x0f83090c,
+    0x700f0101, 0x06837101, 0x13017125, 0x83980c09, 0x83832209, 0x840683c0, 0x22088804, 0x8be0fec0, 0x20798369, 0x08384a20, 0x00207682, 0x053d0082,
+    0xc1ff0000, 0xbf017f02, 0x89007700, 0x0f01fd00, 0x00001801, 0x26273625, 0x2726010f, 0x27078237, 0x010f0627, 0x07060722, 0x2205c943, 0x8206011f,
+    0x4126200b, 0x0c85051d, 0x27313025, 0x85060726, 0x2509860b, 0x17060717, 0x6f823f16, 0x322d0785, 0x30373637, 0x37161731, 0x36012f36, 0x27079737,
+    0x07372736, 0x26312722, 0x2408a44a, 0x23060714, 0x88328427, 0x87918434, 0x85978799, 0x827a867c, 0x200f8da7, 0x238c8c06, 0x013f3617, 0x3d4c8e83,
+    0x822f2005, 0x3736218e, 0x84066648, 0x8233200c, 0x2085919d, 0x05094637, 0x07064608, 0x030f7302, 0x0d0b0f07, 0x04020318, 0x040d0b04, 0x0d0d0603,
+    0x07040811, 0x0a0a0807, 0x01020a09, 0x07020203, 0x06050b05, 0x0a0c090e, 0x0804020b, 0x04060f0f, 0x140f0606, 0x090d0c0a, 0x020d090b, 0x06030f0c,
+    0x083e8310, 0x1010032c, 0x09080305, 0x07031011, 0x04040f10, 0x0b071418, 0x06090c0e, 0x0e091013, 0x090c090a, 0x100a0a0d, 0x0b0f0407, 0x01080101,
+    0x2142d30b, 0x8990200b, 0x820a2051, 0x21518a27, 0x5187110f, 0x040e1129, 0x07151704, 0x830d0d0b, 0x0f082551, 0x080d090a, 0xc493518c, 0x92080321,
+    0x0b0b22c4, 0x4dc48201, 0x092509d0, 0x0f500e09, 0x05cc4201, 0x1006dd33, 0x1804030f, 0x08060b0c, 0x0c010107, 0x0a02020b, 0x08ff8309, 0x090d0c24,
+    0x09070d12, 0x0a040101, 0x1004090f, 0x09010908, 0x0f08050e, 0x02010209, 0x0b0a090c, 0x16090c0d, 0x3b87041a, 0x03051022, 0x2508e582, 0x0f090503,
+    0x0a100704, 0x0c080d0a, 0x090e0b08, 0x08071310, 0x070b0e0c, 0x04031714, 0x0406100f, 0x15180202, 0xba42bd04, 0xafbe200b, 0x09062150, 0x18215084,
+    0x22508504, 0x85151703, 0x0d172183, 0x0931bf9e, 0x050e0808, 0x0e0a091e, 0x09090a0d, 0x0a0e0d0a, 0x08d54309, 0x00820020, 0x20000331, 0x1f02c0ff,
+    0x7900bf01, 0x94008b00, 0x43010000, 0x0f240839, 0x06072601, 0x42108f42, 0x06230fa7, 0x43313015, 0x17270b2e, 0x16013f36, 0x42373637, 0x17210ea1,
+    0x053d4336, 0x32373622, 0x20074943, 0x43128231, 0x2724074d, 0x01273637, 0x210b5c51, 0x7b821415, 0x0809b742, 0x16081f32, 0x041f110f, 0x07161403,
+    0x0f0f0704, 0x1509041e, 0x1f050514, 0x120f081c, 0x1a080c11, 0x0e130b15, 0x120b100b, 0x09150d0d, 0x090d1405, 0x140f0101, 0x40082282, 0x0420100f,
+    0x0f050502, 0x08040512, 0x0b161211, 0x0a0a0905, 0x0c0d0d0e, 0x02040204, 0x0e080903, 0x0c130807, 0x020e0e10, 0x150a0501, 0x01050612, 0x131a0708,
+    0x0d10110e, 0x02110d0e, 0xfe041410, 0x072245a1, 0x820e1421, 0x50143100, 0x16020216, 0x16010215, 0x04145901, 0x0e101f04, 0x152d8c82, 0x0202010e,
+    0x06140c09, 0x0d0c1509, 0x3a838213, 0x160b120f, 0x110b0819, 0x1b080f12, 0x1405041f, 0x1f040915, 0x05070e0e, 0x82151508, 0x112b08b0, 0x0b0a080e,
+    0x0e110101, 0x0e030301, 0x0202050c, 0x0c111108, 0x0a0a1713, 0x01050101, 0x0b140d01, 0x0b0b1606, 0x07130c01, 0x820c140b, 0x0e042958, 0x110f0d0c,
+    0x231d0c10, 0xfe253f82, 0x0e0d01f7, 0x22928914, 0x8388010d, 0x1502238e, 0x4b590216, 0x05cf4b05, 0x1b000d28, 0x00003600, 0x865e3725, 0x26272505,
+    0x2113012b, 0x3605dd4b, 0x36373221, 0x1521013d, 0x33072301, 0x07061716, 0x36272621, 0x67273337, 0x2c080546, 0x27343521, 0x80012326, 0x12176d40,
+    0x12080812, 0x408d1712, 0x80fe0001, 0x010e0909, 0x09090ec0, 0xe00100fe, 0x0f0e1529, 0xfe0f0101, 0x220583a0, 0x82310e0f, 0x00022116, 0xa0292082,
+    0x160d0dc0, 0xfe0d0d16, 0x822983e0, 0x82402010, 0x4340203a, 0x0f220567, 0x10824001, 0x82808021, 0x0000212b, 0x2606874b, 0x00c0013f, 0x82430026,
+    0x272626a5, 0x010f2631, 0x82888423, 0x3637219d, 0x222daf83, 0x0627010f, 0x17161507, 0x013f3221, 0x21138236, 0xde4a3325, 0x06834b06, 0x4d06364d,
+    0x28080567, 0x100a3802, 0x79770e10, 0x0d02010e, 0x090a0c4e, 0x090a0203, 0x2129a10f, 0x020d372f, 0x5a010d02, 0x0f871c22, 0xfe0a0302, 0x20908268,
+    0x838d8240, 0x210a8abb, 0x30820d70, 0xab835820, 0x0c080734, 0x1a0b0b0f, 0x0f020126, 0x14010f60, 0x10100a64, 0xfa4aa00e, 0x0f012105, 0x874a398d,
+    0x827f2006, 0x004c26c7, 0x00820067, 0x25cb829b, 0x36023f36, 0x7a473537, 0x011d2506, 0x27260706, 0x15210da3, 0x058e4611, 0x1f140725, 0x82171601,
+    0x26272de1, 0x010f012f, 0x2f222306, 0x34352602, 0x332b5482, 0x16021f32, 0x30071415, 0x82322515, 0x3035230e, 0x1a822635, 0x0f222326, 0x14150602,
+    0x33221a82, 0x0f8d3405, 0x01272584, 0x281401c0, 0x440c080f, 0xe0830577, 0x3c340999, 0x0c10100c, 0x710c010b, 0x4126523b, 0x0116092f, 0x020c1e62,
+    0x0c230082, 0x8902021e, 0xf2fe2c09, 0x31150204, 0x31030104, 0x84040215, 0x8304200a, 0x2f022109, 0x01200682, 0x1a83108a, 0x17100328, 0x0d26100c,
+    0xfd45c406, 0x0f702505, 0xb00f0101, 0xb0200b85, 0xd0200b83, 0xd0200b85, 0xfe3b178a, 0x0b0c3be9, 0x0c10110c, 0x01013a71, 0x170c0428, 0x031e0b3c,
+    0x010c1f02, 0x86010203, 0x03012488, 0x84940101, 0x82148274, 0x200a838a, 0x216e8303, 0x8f89d005, 0x00390989, 0x20000600, 0x2002c0ff, 0x1100c001,
+    0x5f005100, 0xa7007100, 0x0000b900, 0x10254901, 0x83421320, 0x26272a08, 0x36372327, 0x010f2627, 0x05574d06, 0x14171623, 0x05bc4f07, 0xaa421a83,
+    0x250b8d07, 0x3336012f, 0x36831732, 0x37223883, 0xc9673617, 0x22232106, 0x162f4382, 0x05171617, 0x30313330, 0x37363533, 0x82023f36, 0x215e845c,
+    0x524c2627, 0x82222005, 0x820b8a6a, 0x07062259, 0x20348215, 0x5681821f, 0x33220587, 0x83563732, 0x5a012005, 0x3d41069e, 0x9f673f05, 0x07010107,
+    0x07070b80, 0xc7130601, 0x0804142f, 0x17276c16, 0x121c0116, 0x1b060111, 0x1885d023, 0x248a5f20, 0x0b837f20, 0x1785a020, 0x0808cf2e, 0x030f0a09,
+    0x130c0605, 0xb8111507, 0x390b5944, 0x140e0d01, 0x01016efe, 0x311c1d01, 0x0603224a, 0x07130b06, 0x06080222, 0x0b822c01, 0x06130c28, 0x08070330,
+    0x17852702, 0x02023c2a, 0x01031616, 0x121c1110, 0x0121428f, 0x055b6a80, 0x22058460, 0x8201f0fe, 0x080936a8, 0x1101120c, 0x04141608, 0x201f0e21,
+    0x15061a28, 0x0e101d16, 0x88168413, 0x3408881f, 0x3003029e, 0x010a090b, 0x05421201, 0x0d0d012e, 0x0e0e1414, 0x3505830e, 0x1aa2010d, 0x11282833,
+    0x090b6c17, 0x12010209, 0x0302076b, 0x0b838a07, 0x07971227, 0x7a070301, 0x2c16820c, 0x1632be12, 0x71160102, 0x101c1b22, 0x443d8d1e, 0x8029088b,
+    0x3300c001, 0x00004c00, 0x06206625, 0x34013d27, 0x012b2627, 0x07894426, 0x06233723, 0x05a14307, 0x16011735, 0x012f3637, 0x07012f34, 0x17363727,
+    0x25010f16, 0x60310722, 0x3b2205d5, 0x1c821701, 0x04833720, 0x01013f2b, 0x91670123, 0x0d520412, 0x08008209, 0x1f5f0d28, 0x082c2828, 0x1b5d0a0c,
+    0x36430651, 0x0b08077b, 0x02100c08, 0x0c0f1350, 0x950b8810, 0x0c41190c, 0x1b08080b, 0x2d85b9fe, 0x5b723f08, 0x11191a15, 0x0f0f0c12, 0x8ffe0d0a,
+    0x0f76fc08, 0x09090117, 0x0a0da10d, 0x11101f09, 0x4a135509, 0x05602401, 0xfe0f1309, 0x13100c30, 0x0a0e6a0f, 0x3c150a79, 0x0b0c0808, 0x0a09451a,
+    0x2782a00d, 0x0210522f, 0x09101503, 0x100c0201, 0x00002201, 0x06234b06, 0x0800c028, 0x1b001100, 0xef822400, 0x00005d23, 0x05b26c01, 0x17231123,
+    0x05285026, 0x1125072d, 0x36373233, 0x23273735, 0x84070617, 0x011f2214, 0x22d68a33, 0x8a051525, 0x059a4cfb, 0x012b2626, 0x27010f22, 0x21102441,
+    0xb4821f02, 0x305f4036, 0x0e02020e, 0x1001010e, 0x0e3fb1fd, 0x38010909, 0x0d024028, 0x0e240f82, 0x1240020d, 0xe722e98b, 0x0b416f01, 0x090a2f05,
+    0x04921a0a, 0x28281f04, 0x090d082c, 0x33411a5d, 0x134f290b, 0x87100c0f, 0x0ee04001, 0x00234a82, 0x830f01e0, 0x010f2c49, 0x0900ffe0, 0x2cb40e09,
+    0x85010fd0, 0x41102012, 0x023b0601, 0xde100c01, 0x090f0b9c, 0x3c140b7a, 0x0b0c0a09, 0x04037618, 0x11101fc2, 0x41145708, 0x31310846, 0x0f13100c,
+    0x00000069, 0xff000008, 0x017802c0, 0x370982c0, 0x00480036, 0x005c0053, 0x00720067, 0x2500007b, 0x17160706, 0x2f263736, 0x6205a448, 0x2b220516,
+    0xe8620601, 0x15172905, 0x36333533, 0x27373637, 0x8408da5c, 0x012f210f, 0x2010104c, 0x25488317, 0x35363732, 0x2f822726, 0x83272621, 0x8923200e,
+    0x89152013, 0x8229840a, 0x02272672, 0x02021660, 0x39038316, 0x0c0e0c83, 0x1d0c0b0c, 0x2a342c2d, 0x02363652, 0xdf1e1111, 0x12121b40, 0x0e445f01,
+    0x20602605, 0x07090912, 0x0c6f4b8d, 0x02021529, 0x07070a15, 0x87801602, 0x88402045, 0x20088812, 0x201b8740, 0x39688559, 0x1d540216, 0x201f222c,
+    0x18172911, 0x52363602, 0x1b25242b, 0x120120b1, 0x96631a12, 0x01202506, 0x33110d0e, 0x200bd14a, 0x24398387, 0x160a0707, 0x05265202, 0x1621b084,
+    0x20118402, 0x4d1b9160, 0x97420bbb, 0x00312505, 0x0056004d, 0x2405e366, 0x17160706, 0x82fb8315, 0x011f2408, 0x59363327, 0x27230927, 0x43012b26,
+    0x27210c8f, 0x07644125, 0x25333726, 0x17141506, 0x8e413a82, 0x41232007, 0x02210863, 0x05bc495f, 0x85150221, 0x15032dea, 0x1207be18, 0x0b070909,
+    0x0c0d0c0d, 0x22055241, 0x43293040, 0x4f26069b, 0x100d0f13, 0x6456c9fe, 0xfe062f05, 0x111112cc, 0x1a40df1e, 0x07021211, 0x4087df57, 0x15028924,
+    0x03830215, 0x0882de82, 0x15163608, 0x01953e02, 0x1b100e0d, 0x21212329, 0x18172a12, 0x05202401, 0xfe0f1309, 0x11100c31, 0x09093610, 0x090a0d0d,
+    0x2b25f001, 0x1b24252b, 0x10011fb1, 0x39061910, 0x83368202, 0x0d8b5103, 0x22000b2a, 0x4a003800, 0x06130000, 0x2a053750, 0x07062735, 0x23373305,
+    0x82323315, 0x463520d2, 0x372005ab, 0x34210682, 0x1191423f, 0x34211722, 0x3e127942, 0x11110100, 0x03dca01f, 0xa0500101, 0x1592ff10, 0x7f071110,
+    0x0f01010f, 0x0f950a8b, 0x41ad0f01, 0x42290907, 0x1732333f, 0x031101e2, 0x0648429d, 0x82090821, 0x080136bb, 0x1c27262e, 0x0ea1c3b1, 0xc030b80e,
+    0x04140c0c, 0x010f0f01, 0x20048320, 0x20f1855d, 0x25f18229, 0xa4382221, 0x18420706, 0x5300200c, 0x08270ab3, 0x35001100, 0x82008a00, 0x160726d7,
+    0x34373617, 0x08e54227, 0x27261723, 0x20028431, 0x05e14126, 0x1407062a, 0x15171617, 0x36333521, 0x0583f183, 0x23012f28, 0x1f060706, 0x805e1601,
+    0x07262905, 0x06150706, 0x35272607, 0x0f243282, 0x22230601, 0x41074347, 0x3782051e, 0x26012f24, 0x30823637, 0x36214183, 0x274e8237, 0x3f161716,
+    0x16173601, 0x2f059352, 0x06171633, 0x010fd007, 0x020e0d02, 0x010e400f, 0x0322cc83, 0x6543ed0e, 0x434a2009, 0x013d0665, 0x121b4000, 0x13200111,
+    0x8d070909, 0x0708160c, 0x0909090e, 0x05070605, 0x12121108, 0x28368302, 0x11121202, 0x06070508, 0x25188205, 0x1608070e, 0x4d820f0c, 0x0c212987,
+    0x2027820b, 0x845e8413, 0x0b0c2127, 0x73822587, 0x11010e24, 0x07820f01, 0x020d0f22, 0x2206314b, 0x4324020e, 0x252e0d7d, 0x40b11b24, 0x1a121201,
+    0x0d0e0141, 0x43862311, 0x09050522, 0x0523698e, 0x8d0c0b05, 0x8b698991, 0x20258a8f, 0x20008200, 0x086b5603, 0x3d002b22, 0x57050947, 0x24832417,
+    0x81522b20, 0x0bb37005, 0x6a330721, 0x02210ca6, 0x202a5700, 0x09090125, 0x70e0200d, 0x60210fb3, 0x2ab382c0, 0x40221716, 0x01161722, 0x57a00f01,
+    0x0d221f3f, 0x05710909, 0x224f830c, 0x840f0180, 0x2146823d, 0xeb89010f, 0xc0018024, 0xeb822200, 0x00004223, 0x06535713, 0x06231522, 0x24078d59,
+    0x15331716, 0x08145823, 0x17013f2a, 0x16173233, 0x1633011d, 0x37092e58, 0x35333736, 0x33363734, 0x35331517, 0x0c0ada23, 0x0ad00a0c, 0x01121e90,
+    0x31052957, 0x0e149f3f, 0x1520010d, 0xd00f0709, 0x090ee076, 0xc9822009, 0x140e0d3b, 0x0d14dffe, 0x0e02010e, 0x0e090a20, 0x01c0c010, 0xc10808b8,
+    0x15010e09, 0x831e8226, 0x01802139, 0x702c2482, 0x0f141301, 0x0909f8c1, 0x0f01a00e, 0x14834783, 0xa0010f22, 0x30224682, 0xc3839090, 0x00000625,
+    0x4802c1ff, 0x3f3305b7, 0x9d009400, 0xd900a600, 0x26370000, 0x3f343135, 0x6b222301, 0x332206fb, 0xa3842627, 0x35173222, 0x21079e41, 0x346c0706,
+    0x013f3006, 0x07223736, 0x37132726, 0x06232726, 0x8236010f, 0x361325e2, 0x3726012f, 0x3620d982, 0x32821483, 0xa64a2482, 0x35272606, 0x07062726,
+    0x823c8215, 0x06824322, 0x06230727, 0x33171607, 0x064c4316, 0x82323321, 0x1617312e, 0x17161517, 0x36353736, 0x011f3637, 0x37363316, 0x16288b84,
+    0x17070617, 0x37362726, 0x05200883, 0x82079c58, 0x1507214d, 0x16221383, 0x7c6f1415, 0x20128306, 0x05596e23, 0x23260723, 0x05b94316, 0xc4273426,
+    0x0c080f0f, 0x08070a41, 0x0f080c2c, 0x0e140e0f, 0x1413010c, 0x10101d1e, 0x4503020e, 0x25020421, 0x213c3125, 0x14030413, 0x0101930e, 0x010f100f,
+    0x0e0c0b01, 0x8d434f0b, 0x25234313, 0x2015dd43, 0x20588286, 0x06ad410f, 0x3105de4e, 0x45211c01, 0x100e0203, 0x131e1d10, 0x0f0c0114, 0xac8d0e13,
+    0x0e0e0e34, 0x13040413, 0x25313c21, 0x03040225, 0x0e14130f, 0xc64f0e09, 0x0e092a05, 0x0e0e1314, 0x131c1b07, 0x34b38212, 0x0404180f, 0x0f0f7a6d,
+    0x0c1b1a2f, 0x01190a0f, 0x26010d01, 0x246a8387, 0xfe070787, 0x1d4244f1, 0x44196844, 0x01251224, 0x0e017704, 0x22b3820e, 0x4440020e, 0x0e270579,
+    0x6d7a1701, 0x83180404, 0x131225d9, 0x01071b1c, 0xa8832082, 0x85077050, 0x01012aa9, 0x0c100919, 0x0f2f1a1b, 0x0a9f5a0f, 0x3300212e, 0x64004500,
+    0x00008800, 0x013f3437, 0x2a056559, 0x06070623, 0x17141507, 0x82173316, 0x013b2a04, 0x3d363732, 0x35262701, 0x07174d25, 0xc36e2720, 0x17162205,
+    0x31119021, 0x07262705, 0x23011d06, 0x26273435, 0x1f06010f, 0x3c831601, 0x82153321, 0x215e8248, 0x524d3727, 0x22188207, 0x4a0f1415, 0x608406c5,
+    0x26340484, 0x60272627, 0x0201480e, 0x2a110101, 0x12121b40, 0x0d090901, 0x0e270382, 0x09090e40, 0x6a010e32, 0x6f44080e, 0x90fe2007, 0x5c012c11,
+    0x07070648, 0x06070780, 0x8a080848, 0x4044260a, 0x07101014, 0x255a8201, 0x320e0e48, 0x52840909, 0x01285582, 0x901b1212, 0x01440d13, 0x26210082,
+    0x200d8302, 0x20158260, 0x053e4780, 0x0d306024, 0x006fb013, 0x2e0f8f0f, 0x030544a7, 0x24240803, 0x05030308, 0x8d090944, 0x0b87230d, 0x5982120b,
+    0x0d440126, 0x300d1313, 0x63615a83, 0x83602006, 0x510020c2, 0x80300653, 0x1c00c001, 0x00003500, 0x37262713, 0x011f1633, 0x2409db62, 0x06071617,
+    0x050a4727, 0x05273108, 0x23070607, 0x23013f26, 0x012b0607, 0x3f342726, 0x35262701, 0xee313734, 0x38120328, 0x74650913, 0x031f1f1d, 0x1d1f1f03,
+    0x0c10be49, 0xb0fd130f, 0xc73d0583, 0x424101c4, 0x12381309, 0x2b673103, 0x0d2a0805, 0x1f1f0101, 0x1f010a01, 0x0103118d, 0x2add840f, 0x0111121c,
+    0x10130f95, 0x83d0010c, 0x209c3405, 0x010f72fd, 0x3bad1103, 0x010e0106, 0x026d6f02, 0x46030a02, 0x0120076b, 0x172aab83, 0x49002c00, 0x27010000,
+    0x704d2b26, 0x07223205, 0x33171506, 0x16173335, 0x2736013f, 0x07062307, 0x06a64706, 0x2305c947, 0x17272627, 0x1520bb82, 0xaf5d0382, 0x36352a05,
+    0x36353337, 0x1716013b, 0x08eb8215, 0x7b011525, 0x4319142b, 0x410e0909, 0x01090a0d, 0x0b2b4380, 0x0a0a160c, 0x1219988f, 0x02150212, 0xbf1d1213,
+    0x8213121d, 0x12112e09, 0x0c010319, 0x1a0d0128, 0x0c27020c, 0x220a8501, 0x8228010d, 0x2b62220a, 0x06b44113, 0x0a2b203c, 0x0b0c160a, 0x10100142,
+    0x141de019, 0x14010114, 0x19e01d14, 0xad011010, 0x2a83020c, 0x02280c23, 0x2140820c, 0x3f850d28, 0x84085b46, 0x001427db, 0x00400028, 0xc3931300,
+    0xe6540320, 0x17362208, 0x82018216, 0x130721e6, 0x20160441, 0x33bc93ec, 0x12121a4d, 0x14130201, 0x0e09080f, 0x01021314, 0xdc1c1212, 0x0121f993,
+    0x35bc9120, 0x100100ff, 0x1e141911, 0x0808121d, 0x141e1d12, 0x01101119, 0xf58f4201, 0x0427cc82, 0xc0ff1000, 0x4b01f001, 0x2822059b, 0x034d9100,
+    0x050c4d0b, 0x37273422, 0x2006de5b, 0x23c78307, 0x37323316, 0x2005fc43, 0x2ff68307, 0x011f1415, 0x07061516, 0x26012f22, 0x06072223, 0x220b0f53,
+    0x4a06010f, 0x362205ba, 0x46513435, 0x3435210b, 0x44822c82, 0x3a823220, 0xa55e4d83, 0x82152005, 0x3233285d, 0x3336013f, 0x82141716, 0x05b64e3a,
+    0x06171625, 0x45200107, 0x3c080a8e, 0x020e0d02, 0x09c0f30f, 0xc0080a0a, 0x3003011d, 0x1c393830, 0x2f39381d, 0x1c010330, 0x080f0c53, 0x05090909,
+    0x05070e02, 0x0d0c0b08, 0x0f010a09, 0x090a010f, 0x080b0c0d, 0x020e0705, 0x211c8205, 0xb3490f08, 0x23298505, 0x060f0101, 0x01212a8a, 0x272b9309,
+    0x0e0f01c1, 0x0e0e0101, 0x3a09b849, 0x0404506b, 0x811e0d50, 0x2a2b5556, 0x55562a2b, 0xab0d1f80, 0x0c0a0901, 0x82080a0d, 0x91012067, 0x0d022967,
+    0x0a080507, 0x090a0c0d, 0x92867182, 0x06050722, 0xb0829282, 0x0d0f0822, 0xbc85e083, 0x0e010424, 0x4a830506, 0x020a0925, 0x50020f0e, 0x003308bf,
+    0x4200c001, 0x00005000, 0x33352325, 0x26353736, 0x4522012f, 0x606a063f, 0x011d2205, 0x06bb6016, 0x2305af70, 0x34352315, 0x2005634b, 0x20188215,
+    0x05445515, 0x39832120, 0x16052725, 0x7d163117, 0x352605d7, 0xf0011521, 0x7f834060, 0x090e5023, 0x06956a09, 0x200f0122, 0x22261182, 0x15232f21,
+    0x13830114, 0x0e825020, 0x60400f22, 0x01210583, 0x3a0583e0, 0x1b0130fe, 0x0001291b, 0x011b1b29, 0x20a040fe, 0x0f0f0d02, 0x09090201, 0x58c02f0e,
+    0x10200581, 0x102a2583, 0x071b1c2e, 0x241b1c08, 0x5c8230bc, 0x0f0f0125, 0x85200110, 0x2060835b, 0x07b36880, 0x4e202021, 0xdb560727, 0x00112805,
+    0x00370025, 0x82740049, 0x103746ed, 0x7b060721, 0x3320072b, 0x22058742, 0x7e232726, 0x0d5d052b, 0x8f07200b, 0x011f2637, 0x17160706, 0x0a4f6116,
+    0x37363723, 0x533b8233, 0x212008fd, 0x35264e83, 0x27262726, 0xa44a4001, 0x08944a0f, 0x1987c020, 0x5a6bc020, 0x09092309, 0x1253b00e, 0x01d02a0f,
+    0x12111c1e, 0x291b1b01, 0x22e587c0, 0x88011859, 0x400121f1, 0xc0201587, 0x200f2346, 0x20108f20, 0x0b7f4fe0, 0x1c582020, 0x2b60260f, 0x18180b1b,
+    0x834e871f, 0x251b2107, 0x6b887783, 0xeb430884, 0x01b03108, 0x000a00c0, 0x004f003b, 0x25000076, 0x17163736, 0x21055c4d, 0xf8703203, 0x012b2406,
+    0x6c171615, 0x162109b3, 0x064a5d17, 0x37362726, 0x23353736, 0x8208fa50, 0x06312117, 0x250efb7a, 0x0f141507, 0x89420601, 0x27262a06, 0x013f3623,
+    0x34013d36, 0x05b96127, 0x43161721, 0x332605dd, 0x0b011401, 0x0383010b, 0x87450420, 0x39102305, 0xb57c152b, 0x20182f05, 0x3b3b0201, 0x3b3b5858,
+    0x31310202, 0x1f85104c, 0x16106029, 0x01010e0f, 0x87160f0e, 0x74200807, 0x01152704, 0x02124013, 0x022c1202, 0x0f0d2709, 0x0d25160e, 0x12110401,
+    0x09030206, 0xc001010a, 0x60205f83, 0xc76e0484, 0x0a222507, 0x09091623, 0x18226683, 0x60844031, 0x50246882, 0x220e3838, 0x20056041, 0x205f83cc,
+    0x84608760, 0x02352708, 0x182c0505, 0x6683101f, 0x0e011328, 0x14102c0b, 0x89821702, 0x22023008, 0x05061202, 0x01090111, 0x0300000c, 0xc0ff0000,
+    0xc0018002, 0x2c002100, 0x00003d00, 0x37363713, 0x011f1621, 0x07141516, 0x17212306, 0x84153335, 0x099e4703, 0x3f34072d, 0x22231701, 0x31352627,
+    0x42173505, 0x29820993, 0x084a3334, 0x8c011a0e, 0x064c0e1a, 0xfe100a0b, 0x80402bba, 0xa2473740, 0x23200809, 0x650f064a, 0x0b0a1055, 0x01404001,
+    0xe0140e0d, 0x010d0e14, 0x9f01c040, 0x0101140c, 0x0b097214, 0x22261a82, 0x97633402, 0xa5472bca, 0x7a1c2509, 0x4f16090b, 0xe5234e82, 0x42413324,
+    0xf02207a9, 0xbb8b00a0, 0x36002a24, 0xbb844900, 0x64213321, 0x0625067c, 0x06272623, 0x29038307, 0x33163517, 0x36313732, 0x63481537, 0x26022709,
+    0x37263127, 0xc6820617, 0x33173122, 0x21280782, 0x27262726, 0x33171635, 0x153f2b83, 0x1008175f, 0x08106401, 0x100f153a, 0x2807062a, 0x28281919,
+    0xb30b0819, 0x08091211, 0x89570705, 0x382a08d1, 0x11112111, 0x110e6a04, 0xce300606, 0xfe140f95, 0x12121bc0, 0x01050601, 0x11130808, 0x0d248f01,
+    0x25255b0d, 0x01010825, 0x03821c1c, 0x8c070929, 0x01010564, 0x89449401, 0xae2c30de, 0x1f1a1a05, 0xa1010653, 0x12010a76, 0x82c31b12, 0x85052e1f,
+    0x00000300, 0x7f02c1ff, 0x1300c001, 0x05655100, 0x6b141521, 0x212b0670, 0x35363736, 0x06253736, 0x44270115, 0xa94a0744, 0x35272605, 0x37363734,
+    0x0d7a5221, 0x61340321, 0x4084067e, 0xe6822220, 0x0605403b, 0x0305040b, 0x16190112, 0x06100108, 0x0203c5fe, 0x19256e37, 0x1b020118, 0x05d77d1b,
+    0x11391829, 0xe3fe1c10, 0x52391a25, 0x98230b6c, 0x420d0a09, 0x0d2205d2, 0xa6820909, 0x19ac2b08, 0x0c201616, 0x0102120e, 0x29010115, 0x1515f632,
+    0x0856eafe, 0x524d3535, 0x02023636, 0x4c513636, 0x3f542c34, 0x021d3132, 0x64522d30, 0x16012109, 0x83078544, 0x12122207, 0x06a74b1c, 0xeb828020,
+    0x2200112a, 0x50004100, 0x00005c00, 0x2612b34f, 0x15160722, 0x4f061516, 0x072008bb, 0x8205c34f, 0x353621ee, 0x57053d4e, 0x6b450c02, 0x17142805,
+    0x36213316, 0x51232737, 0x07270599, 0x26331716, 0x4f000227, 0x07870771, 0x11131622, 0x203ad182, 0x010210c7, 0x3e251919, 0x01011a5d, 0x382b1d1e,
+    0x010f2a1e, 0x25221716, 0x08411d17, 0x100c3e09, 0x283c7fe9, 0x08080228, 0x1248010c, 0x5438b808, 0x19252240, 0x10020119, 0x010916c7, 0x0f7c6220,
+    0x03082039, 0x33060502, 0x27110225, 0x5e011a1b, 0x1e2c291d, 0x2c02011d, 0x841a1420, 0x171b217b, 0x37071a41, 0x42b60f13, 0x38262601, 0x0108070c,
+    0x336d900f, 0x271b1a01, 0x231a0211, 0x250a0769, 0x00830071, 0xa963008c, 0x013f2205, 0x052d6736, 0x2006804a, 0x05934e32, 0x52012b21, 0x1528057f,
+    0x23060714, 0x26012f22, 0x0ce54218, 0x21098552, 0x40823435, 0x27262723, 0x08134523, 0x2205c14a, 0x82373435, 0x011f2557, 0x37363716, 0x17230b85,
+    0x41011d16, 0x1621054b, 0x056a7017, 0x27214582, 0x06fa5417, 0x20011733, 0x1e1f2003, 0x0d0c0a08, 0x0809090a, 0x270d0d19, 0x0524420b, 0x0d270b30,
+    0x0908190d, 0x0c0d0a09, 0x1f1e080a, 0xa9440320, 0x212d8e05, 0x2d850c26, 0x94260c21, 0x4640202d, 0x50200f9b, 0x2305da54, 0x94011602, 0x5f8e3195,
+    0x84208db6, 0x200faa46, 0x07755698, 0x2c077744, 0x00c0017f, 0x0072002d, 0x3700007e, 0x06147b23, 0x16013b24, 0xfe491617, 0x086c5006, 0x2b064f66,
+    0x3736013d, 0x06273736, 0x34270507, 0x33200882, 0x08704518, 0x26272625, 0x5d36013f, 0x3b820585, 0x915d2720, 0x4a06200d, 0x0722069b, 0xdd421522,
+    0x2527300a, 0x16333627, 0x14151617, 0x71071431, 0x82080c15, 0x160c3700, 0x1a0d0e27, 0x0908080f, 0x0f090b0b, 0x0321201e, 0x0c0c0808, 0xc9820808,
+    0x0ef5132a, 0xa1060217, 0x161a0f0f, 0x0d282a98, 0x0308080b, 0x0f1e2021, 0x02233e83, 0x56600101, 0xd7280c67, 0x140d0a45, 0xdc010e0d, 0x28885385,
+    0x0f080826, 0x270e0d1a, 0x172c5687, 0xc0040f0e, 0x7ef1010d, 0x01111217, 0xac862a9d, 0x01030223, 0x091c444c, 0x0637e82b, 0x140d0d01, 0x00060701,
+    0x0a174400, 0x6600542c, 0xc4006f00, 0x0000d600, 0xfa513325, 0x37322149, 0x20064e52, 0x11035927, 0x20080a52, 0x44655223, 0xbe846a88, 0x3d11fe64,
+    0x13105b01, 0x10130202, 0x130a0a1e, 0x0f0c0c0c, 0x18160c0f, 0x14010219, 0x19020114, 0x0f831618, 0x130c0c25, 0x8c1e0a0a, 0x08072325, 0x27840609,
+    0x86130221, 0x09062327, 0x3e820708, 0xbb202983, 0x85055743, 0x4c502005, 0x01210784, 0x07875180, 0x523b6252, 0xb9640bb2, 0x9eeb200c, 0x88d786b1,
+    0x0f0f23af, 0xd7830606, 0x89111d21, 0x060621fd, 0x15202586, 0x200d3b4a, 0x20c3850f, 0x0e9e5680, 0x86163456, 0x125b5225, 0x670b8056, 0x032510ab,
+    0xc0ff0000, 0x29018201, 0x40003300, 0x00004d00, 0x894c2725, 0x0f222205, 0x054f4501, 0xba4c2b20, 0x06073305, 0x1714011d, 0x35013b16, 0x27013f34,
+    0x37323316, 0x0f4e1507, 0x27342205, 0x05c06c05, 0x36013f26, 0x05071617, 0x37283685, 0x16011f36, 0x35b50107, 0x2030d482, 0x1b190607, 0x191b1f1f,
+    0x0e200706, 0x0b350909, 0xa0291382, 0x23390d02, 0x4a232727, 0x301182c0, 0x30cefe0b, 0x05060605, 0x0b300a0a, 0x010a0a0b, 0x240c8300, 0x0b0a0a30,
+    0x2204820b, 0x828050d0, 0x11042122, 0x04200082, 0x80243882, 0xcd131050, 0xe0281082, 0xaa290505, 0xe0dd1313, 0xcd261382, 0x30831013, 0x2e840505,
+    0x05210482, 0x82468405, 0x05e75804, 0x5024df86, 0x75006200, 0x2620e1b6, 0x21074f77, 0xe382010f, 0xf487e284, 0x43172721, 0x2528104d, 0x35372623,
+    0x17363736, 0x22050651, 0x41060716, 0x8b342909, 0x09080707, 0x0908100f, 0x10100606, 0x05040606, 0x0f100305, 0x07270583, 0x200f0f07, 0x180c0b11,
+    0x3108354b, 0x08300701, 0x08070101, 0x0501150b, 0x08010416, 0x2a410b07, 0x09212625, 0x0f080808, 0x8404820f, 0x03032a67, 0x03031010, 0x0f100809,
+    0x825a88b7, 0x78200866, 0x0b300601, 0x04010807, 0x15010516, 0x0107080b, 0x00000100, 0x40022000, 0x2e006001, 0x27250000, 0x47066f47, 0x1f210534,
+    0x05464701, 0x37280d83, 0x1d161716, 0x06071401, 0x2d05ea78, 0x3b363734, 0x93d30101, 0x0d0d0a69, 0xd44ba00a, 0x6a882105, 0xa9200c83, 0x6108f042,
+    0x53260641, 0x096a9360, 0x5d4ca009, 0x828a2005, 0x54aa2a0a, 0x0109090d, 0x0d090901, 0x08de43a1, 0x2f22878a, 0xce5d0000, 0x013b2208, 0x25768632,
+    0x26272223, 0x9e85013d, 0x2605a441, 0x013f3435, 0x82323336, 0x010721a4, 0x61060254, 0xa92009b3, 0x6a216e83, 0x84748588, 0x9369237b, 0x29430153,
+    0x25298609, 0x0909aa53, 0xbe858a6a, 0x6a23c582, 0x4f000194, 0x012b07ef, 0x00c001c0, 0x00490026, 0x82152500, 0x212321f6, 0x74648084, 0x974d1808,
+    0x08026c08, 0x0607032a, 0x16171415, 0x013f3233, 0x37230785, 0x6d013d36, 0x3521057e, 0x05004734, 0x09800126, 0x00ff0e09, 0xc14ff588, 0x05344109,
+    0x1f82b720, 0x4920b283, 0x49200e85, 0x8020be85, 0x60200683, 0x8706576c, 0x076e4e06, 0x01210f86, 0x23258457, 0xd34a0909, 0xd3215d85, 0x82d5854a,
+    0x03002251, 0x674d1800, 0x82452007, 0x824e20cf, 0x057449d1, 0x2b060722, 0x83057359, 0x290a82e0, 0x07060716, 0x2f262706, 0x08852301, 0x3f262722,
+    0x2208ca73, 0x4937013b, 0x37310965, 0x1f163736, 0x07272301, 0x33010f33, 0x45012327, 0x2274855b, 0x85330d40, 0x16182d08, 0x0d050404, 0x050c0b0d,
+    0x061fc620, 0x2106ca75, 0x1c851816, 0x860d3321, 0x485b30b4, 0x09151508, 0x20214547, 0x910e5b41, 0x85e0760d, 0x06a541f6, 0x36823420, 0x46830620,
+    0x0d4c4c25, 0x83040405, 0x8c342045, 0x13ac2a20, 0xac130101, 0x20404d4d, 0x06674720, 0x01400131, 0x002f00c0, 0x003f0034, 0x00510044, 0x53151300,
+    0x765005f8, 0x42e88308, 0xcc840549, 0x37341123, 0x9e4a1836, 0x31152609, 0x33152307, 0x05205d35, 0x82361521, 0x200f85e4, 0x06626436, 0x1d822720,
+    0x1f30b02d, 0x14010120, 0x010e0f18, 0x86301f20, 0x124627a9, 0x0b0b0c0c, 0x9d854a10, 0x30304023, 0x07784970, 0x30307023, 0x07fc4960, 0x01202024,
+    0x358320a0, 0x0f1c2525, 0x831e1919, 0x41202048, 0x20280510, 0x01120c0c, 0x0b0b1030, 0x60230f86, 0x83306060, 0x83602035, 0x82702046, 0x204e870d,
+    0x06b74960, 0x4624e784, 0x5f005300, 0x3420e382, 0x33259e82, 0x1d161732, 0x052a5b01, 0x14200a84, 0xf88af98e, 0x65150341, 0xe5830848, 0x51150721,
+    0x302009d9, 0x220c7341, 0x89161623, 0x20198cfe, 0x05044106, 0x87800a21, 0x707023ef, 0x0b879070, 0x43019021, 0x20200670, 0x2026e286, 0x1d0a0302,
+    0x0a41271d, 0x10124111, 0xfc88c020, 0x87604021, 0x00002d0a, 0x00000100, 0x7f01c0ff, 0x1b00c001, 0x26250c82, 0x3637012b, 0x56058227, 0x3e0805c9,
+    0x0607013b, 0x32331617, 0x27361337, 0x0e077d01, 0x0705339d, 0x14b00c08, 0x07012004, 0x29920b07, 0x05041103, 0x07d0080c, 0x0d130106, 0x0b0a0c7f,
+    0x0bf01401, 0x13c20808, 0x010a0308, 0x440d0c30, 0x32290f03, 0x11250000, 0x27262726, 0x05995b23, 0x82060721, 0x2335210b, 0x099f5118, 0x23056762,
+    0x07373635, 0x2307737f, 0x01152133, 0x3026b984, 0x08080801, 0x04823737, 0x217c0120, 0x0e402909, 0x0f010909, 0xfe40010f, 0x0806c352, 0x70200127,
+    0x0e142001, 0x0abf010d, 0x2c060405, 0x0404052d, 0x1b01bf0b, 0xc0fe291b, 0x011b1b29, 0x120e0909, 0x160e5109, 0x05714170, 0xa0824020, 0xff820320,
+    0x0002e02e, 0x1c00a001, 0x52003700, 0x23010000, 0x23209482, 0x978aff82, 0x36373623, 0x24b88437, 0x26070603, 0x29b68527, 0x16333736, 0x010f1617,
+    0x1d823316, 0x07161726, 0x23070637, 0x3f22db82, 0x38832601, 0x82262721, 0x17162132, 0x2a05e546, 0x0c58d001, 0x207e200d, 0x70580c0d, 0xa02008c3,
+    0x6b390987, 0x24313e27, 0x08080713, 0x4d090101, 0x07030409, 0x271d1613, 0x10130f18, 0x8daf820c, 0x2c298910, 0x021d2160, 0x01211d02, 0xfe140e0d,
+    0x845388e0, 0xf1fe29f9, 0x20010130, 0x04030614, 0x012e4e82, 0x07080801, 0x1e011214, 0x130f0c10, 0x0e8c096b, 0xa7412689, 0x05f74309, 0x00003a23,
+    0x82db8213, 0x270624d4, 0x85152726, 0x780620df, 0xe7820aff, 0x15822720, 0x3314134e, 0x242fe035, 0x0701020b, 0x19141815, 0x15181419, 0x2f24160f,
+    0x27056e41, 0x012d2c46, 0x462c2d01, 0x403d0d85, 0x011a1b2a, 0x2a1b1a01, 0x1b087d01, 0x0b0d0c09, 0x070f0f16, 0x0f1005f7, 0x1b151816, 0xb2401808,
+    0x330d2707, 0x34494934, 0x0f870d33, 0x210c4129, 0x222e2d21, 0x82f70b21, 0x410520b4, 0x1b2808bb, 0x43002f00, 0x6b005700, 0x3227b982, 0x15163117,
+    0x18171611, 0x7207cc43, 0x112505bb, 0x33363734, 0x221b8317, 0x4614011d, 0x3d2105f8, 0x21138401, 0x5e750714, 0x250e8505, 0x1d161732, 0x27a63701,
+    0x090e2026, 0x010f0109, 0x2506f54a, 0x172270fe, 0xdd820116, 0x44064547, 0x5b7c0594, 0x46f48606, 0x757c08b2, 0x21198509, 0x0782a001, 0x0fb0fe22,
+    0x24823f83, 0x17160125, 0x82500122, 0x5bc02008, 0x068606b5, 0x44064c5b, 0xa0200605, 0x12865c83, 0x430ac15b, 0xe021060c, 0x20008200, 0x10234104,
+    0x41130021, 0x34251b21, 0x3b363137, 0x083f5001, 0x26272224, 0x50551735, 0x081f5009, 0x0d411393, 0x82602016, 0x86a38aba, 0x0623419c, 0x19868020,
+    0x2006c946, 0x17064140, 0x3e412686, 0x71421805, 0x415e830c, 0xbf460855, 0x05cf4305, 0x00082808, 0x0013000d, 0x002a001c, 0x26370100, 0x012b2223,
+    0x37233307, 0x25330723, 0x26353307, 0x06232527, 0x15070607, 0x58033733, 0x21080d43, 0x01018046, 0x80560202, 0x5c80a05c, 0x4c015c80, 0x0d017668,
+    0x1b4694fe, 0x06011212, 0x12018680, 0x915d1b12, 0x00fe2e05, 0x017f2001, 0x68808080, 0x11174068, 0x21188318, 0x9a5d8040, 0xe0e02109, 0x00207682,
+    0x2107b37a, 0xc1790051, 0x26232905, 0x16272627, 0x14171617, 0x26237b82, 0x18070627, 0x83079245, 0x0507618b, 0x36272625, 0x83333637, 0x261b8223,
+    0x36373427, 0x60171637, 0x23830574, 0x0f823620, 0x3f823220, 0x16070625, 0x83000217, 0x211e3974, 0x0d0f1a22, 0x1312010c, 0x12121c1b, 0x13121b1c,
+    0x0f0d0c01, 0x1e21221a, 0x0123b283, 0x8b011313, 0x12132125, 0x11212582, 0x2025921d, 0x99139292, 0x211b215f, 0x85845f95, 0x001d1122, 0x290a4365,
+    0x003a002c, 0x00700067, 0x8e610500, 0x34352305, 0xfc4b013f, 0x20cc8305, 0x07014135, 0x20071541, 0x2c258215, 0x13152307, 0x26312734, 0x06072223,
+    0x20fe8315, 0x059f6125, 0x51141521, 0xbb410613, 0x078e4805, 0x20072841, 0x23258235, 0x03353337, 0x3a083183, 0x07062726, 0x0d014001, 0x08500b0f,
+    0x0f0b5008, 0x1b10010d, 0x16011212, 0x16010d0d, 0x17222217, 0x0d0d0116, 0x25240116, 0x07881036, 0x070a0a07, 0x16160207, 0x01f8fe02, 0x830c0e0d,
+    0x0e0c2130, 0x2a83309a, 0x28380383, 0x0a06070f, 0x0b0b0748, 0x060a4807, 0x01280f07, 0xa71b1212, 0x1913130a, 0x66835e83, 0x1313192b, 0x2536a70a,
+    0x01280124, 0x82628299, 0x01172468, 0x93371701, 0x14092136, 0x1421368b, 0x21368509, 0xe15268fe, 0x82002007, 0x4e042000, 0x4b30088f, 0x5d005400,
+    0x00006600, 0x31071413, 0x14150706, 0x2106ac7d, 0x4e41013d, 0x102a4116, 0x28822320, 0x7c412720, 0x0731230c, 0xdf693736, 0x87212005, 0x06032208,
+    0x054b4107, 0x0d0da02a, 0x0e090916, 0x09090ea0, 0x230e4141, 0x30291b1b, 0x3023128d, 0x411b1b29, 0xa4530b67, 0x87202009, 0x539020cc, 0x702508b7,
+    0x0a131319, 0x05bf4327, 0x3a412720, 0x8327200f, 0x41472049, 0x47210f19, 0x8c738201, 0x4118202b, 0x07870790, 0x87d0fe21, 0x06375209, 0xc001002e,
+    0x36002d00, 0x63005a00, 0x00006c00, 0x2206815f, 0x41151716, 0x9e481017, 0x4226200a, 0x312105a9, 0x070e4113, 0x17162523, 0x05775b31, 0x41087142,
+    0x3241106e, 0x41112008, 0x0127073b, 0x10010d32, 0x42242536, 0x12230f7b, 0x42101b12, 0x7e20099f, 0x21071241, 0x4e41c0fe, 0x410d8d0d, 0x41410842,
+    0x07be2808, 0x2401280f, 0x41a73625, 0xa7240f27, 0x0112121b, 0x210ca242, 0x16413afe, 0x8f612007, 0x41ce202c, 0xce220f7b, 0x4d412f01, 0x41a02008,
+    0x374b084d, 0x01c12f05, 0x00bf0140, 0x004e0045, 0x13000056, 0x41181716, 0x35480983, 0x48072007, 0x0f250633, 0x06070601, 0x05164927, 0x0c4d2720,
+    0x06354109, 0x84013f21, 0x16172826, 0x0706020f, 0x82150631, 0x17320849, 0x07272637, 0xd9311716, 0x040b0e0e, 0x0d0d0c0b, 0x10030706, 0x020b0103,
+    0x100a0701, 0x18101235, 0x27160f15, 0x0b040a33, 0x070d0e0a, 0x0e080206, 0x0b840d0e, 0x12212682, 0x22ef821f, 0x8242292a, 0x3337851c, 0x121e5606,
+    0x2e140113, 0x0f0e3e25, 0x010f0d3d, 0x2f04017e, 0x30834f83, 0x01013c32, 0x0b0d0c09, 0x07da010d, 0x18160f0c, 0x2a071d15, 0x1c231a87, 0x87340503,
+    0x1a47290b, 0x462c2526, 0x2d0f3333, 0x1a2f1187, 0x1e1e104d, 0xb81f2825, 0x0105f8ef, 0x180306f5, 0x240daf42, 0x37000047, 0x2ad48235, 0x36173233,
+    0x011f3233, 0x83161716, 0x012f25f5, 0x07062326, 0x85054849, 0x66072011, 0x4b180554, 0x1d410a8d, 0x05bc5906, 0x31171637, 0x0909019f, 0x10080d0d,
+    0x0a161b13, 0x0703020b, 0x0b0d0d08, 0x3b44820a, 0x0a2d3e02, 0x09090d0d, 0x3d0a0101, 0x33323f58, 0x01011e1d, 0x32331d1e, 0x0a3d583f, 0x3382d482,
+    0x3e2d0a37, 0x022d2e44, 0x2a1b1a01, 0x090e932d, 0x0f070709, 0x0c0d0806, 0x2645830c, 0x15020407, 0x83280169, 0x0d0a253d, 0x0238090c, 0x47853b85,
+    0x83370221, 0x2945833d, 0x2d020128, 0x2632442d, 0x1b4a1427, 0x40022708, 0x2200c001, 0x5d182700, 0x33210c51, 0x29d78207, 0x36211716, 0x23272637,
+    0x274b3327, 0x11212709, 0x10021121, 0x9b4a20fe, 0x10c02807, 0x02021648, 0x83100116, 0x7d482005, 0x102109f8, 0x4b5682fe, 0xfe2105e1, 0x6d2c83c0,
+    0x3026088c, 0x140e0d01, 0x13834001, 0x01a0fe25, 0x76e0fe20, 0x012c0633, 0x00a00180, 0x00420030, 0x01000056, 0x27079948, 0x07141123, 0x27262306,
+    0x26210383, 0x05244727, 0x2c0ae15d, 0x33363734, 0x15161732, 0x27260731, 0x22258231, 0x58070607, 0xc84807be, 0xe64b1808, 0x21332108, 0x30077b7c,
+    0x150e0909, 0x36251e08, 0x01012425, 0x23362524, 0x07544d1d, 0x2005b249, 0x0fdf5e40, 0x2106a448, 0xcf44c0fe, 0x40012305, 0x29858001, 0x8200ff21,
+    0x12012211, 0x83458313, 0x3111214d, 0x27851785, 0x2010486a, 0x0e347ca0, 0x47480720, 0x000d2208, 0x28fb841b, 0x00610054, 0x1300006e, 0x054a5633,
+    0x06010f34, 0x25331617, 0x36013f16, 0x012b2627, 0x1f060722, 0x0e602102, 0x2611220d, 0x05594327, 0x230d065f, 0x31171623, 0x1721118d, 0x05464723,
+    0x16171625, 0x8b331517, 0x824f2f0c, 0x0603040a, 0x410b0b41, 0x0a040306, 0x08841601, 0x85090521, 0x485b2015, 0xb16609fa, 0x08b34f09, 0x59080642,
+    0xa02510c1, 0x140e0d01, 0x20168340, 0x2c0a89c0, 0x08096001, 0x08084407, 0x09080744, 0x83068504, 0x01242910, 0xff1a1212, 0x0112121d, 0x01220883,
+    0x09821b01, 0x5908cb4e, 0x0f870fa3, 0x8730e021, 0x89302073, 0x064b4209, 0x0140022f, 0x001800c0, 0x0043002a, 0x37361300, 0x21f38221, 0x8143010f,
+    0x2f262905, 0x013d2601, 0x31372627, 0x51057c5c, 0x062a0500, 0x26272607, 0x27363727, 0x1b820f26, 0x1f06073d, 0x17060701, 0x17013f16, 0x2f363716,
+    0x0b043701, 0x19b00119, 0x6a100a0b, 0x8228273d, 0x020332a4, 0x0fb70d40, 0x021b010a, 0x3d3d2929, 0x02022829, 0x2e078328, 0x0acc0229, 0x250b0b0a,
+    0x0a0b0b25, 0x8b24240a, 0xa901390b, 0x16010116, 0x0d831317, 0x29412f2f, 0x30010224, 0xe04f100a, 0xa7fe1713, 0x46853e89, 0x48853c92, 0x0b4f4618,
+    0x23433920, 0x012b240a, 0x52010f06, 0x072009b0, 0x8354e782, 0x5236200a, 0x36240ca2, 0x013b3637, 0x07c05518, 0x09152524, 0xaa42502d, 0x376b2605,
+    0x1e18170c, 0x8c0c8525, 0x180b2117, 0x01201782, 0x2206b942, 0x426c1301, 0x852305c2, 0x8510101b, 0x54128c09, 0xa74b061b, 0x000e2205, 0x22a5821c,
+    0x82232723, 0x15072890, 0x27263521, 0x4b012726, 0xd02e0d93, 0x14a040c0, 0x02010d0e, 0x0e0d0100, 0x1a44fe14, 0x24118405, 0x600100fe, 0x21148340,
+    0x20831050, 0xbe62fe20, 0xf0f02108, 0x24070741, 0x00a00140, 0x0c07413a, 0x10dc5118, 0x18071421, 0x5216715d, 0x012005d8, 0x2006f743, 0x06e84db0,
+    0x0d419020, 0x85502006, 0x06da61da, 0xd020e883, 0x4c070141, 0xa94c0695, 0x07dd4c06, 0x01212f85, 0x055a7a00, 0x00030030, 0x01c0ff00, 0x00c00180,
+    0x003e0033, 0x67530046, 0x82152005, 0x2227248d, 0x85272627, 0x5d0620a6, 0x794f0fb3, 0x3115210c, 0x20098d5d, 0x057b5235, 0xe0152330, 0x090a2a3c,
+    0x0a0c0d0a, 0x0e802218, 0x734f0909, 0x16814f09, 0x18224034, 0x015b0819, 0x290b23a0, 0x0a0d0c0a, 0x1808010a, 0xab825c09, 0x4f0b784f, 0x642f0e88,
+    0x2e21220b, 0x0b21212e, 0x1908f7f7, 0x845b2218, 0x02e028cb, 0x00a00140, 0x82390032, 0x01002acd, 0x27263523, 0x21150706, 0x061d5922, 0x2a052e51,
+    0x17161706, 0x013f3633, 0x84373233, 0x08098505, 0x34013d37, 0x07232627, 0x37012b06, 0x21370733, 0x02152135, 0x16021020, 0x4bfe0216, 0x0d0d0c12,
+    0x0911120c, 0x04290409, 0x68100a09, 0x5f1b0817, 0x060e0f12, 0x090d2419, 0x06584117, 0x0503d733, 0x135c1152, 0x0160fe97, 0x088001a0, 0x16020216,
+    0x20348208, 0x313b825a, 0x100c0c01, 0x0c0c109e, 0x69160101, 0x4a110a0b, 0xd8821709, 0x090e5028, 0x4005eb09, 0xaf658b3b, 0x000a2d0f, 0x00650019,
+    0x008e0074, 0x37360100, 0xaf82c085, 0x013f3223, 0x2c0c8236, 0x06010f22, 0x13171615, 0x26273635, 0x82d68427, 0x070622b4, 0x07206314, 0xe7472220,
+    0x210fa005, 0x01831617, 0x37363326, 0x16033736, 0x34200682, 0x022a3787, 0x06310722, 0x1527011d, 0x01830706, 0x85821b83, 0x65823420, 0x0f400125,
+    0x830f0101, 0x093f2903, 0x02032005, 0x2105080e, 0x01240582, 0x14060701, 0x972dcc82, 0x02160a07, 0x04045a07, 0x04060605, 0x200c846c, 0x200c856c,
+    0x20198b5a, 0x300c8435, 0x27371317, 0x2a423128, 0x058d012b, 0x03020e09, 0x20058521, 0x284782ed, 0x10100120, 0x0b081312, 0x241d830b, 0x010e0909,
+    0x06217060, 0x07257e82, 0x0f050430, 0x2f058501, 0x06a4fafe, 0x09010d0e, 0x974d0d09, 0x0a150307, 0x06237a82, 0x82040506, 0x1602267a, 0x056b0809,
+    0x200c8305, 0x20198459, 0x23928359, 0x07340505, 0x17301983, 0x1d1d3a14, 0x402c2c02, 0x01070d01, 0x3004050f, 0x47200585, 0x4c296a82, 0x202e7a20,
+    0x06121220, 0x201f8302, 0x2f8c82a6, 0x00000300, 0x4002c0ff, 0x2100c001, 0x43003300, 0x20054918, 0x31071623, 0x08536725, 0x36373627, 0x26272637,
+    0x071f4327, 0x0e853320, 0x1d0e4918, 0x010cff23, 0x108e47fe, 0x17222026, 0x0f010116, 0x2007dd71, 0x1b4918c0, 0x0ae12317, 0x1248600e, 0x01a0250f,
+    0x0f221716, 0x43833d82, 0x00820020, 0xd3820120, 0x4001e12d, 0x4600a001, 0x34130000, 0x18363137, 0x210a7556, 0x9f451716, 0x82062009, 0x4a1720b8,
+    0x2560093f, 0x0a3c5806, 0xbf45dc82, 0x00312605, 0x010e0909, 0x05944500, 0x060e3823, 0x38098524, 0x21210a24, 0x020a912e, 0x0d080803, 0x11e00c0c,
+    0x50160806, 0x09141319, 0x251e8599, 0x13140999, 0x0b825019, 0xae520120, 0x1a162109, 0x2505a144, 0x071e1e2c, 0x35820966, 0xa0243d83, 0x0115150f,
+    0x4d05ff4d, 0x238205fe, 0x230b6346, 0x3700003c, 0xb289b689, 0x580e1f57, 0x1d230c22, 0x85363701, 0x010f2329, 0x9085a9b7, 0x4a9ea921, 0x0c2205bf,
+    0x8585ab0b, 0x290d6d49, 0x0d0c0bab, 0x01010909, 0xde589e0a, 0x82882006, 0x830b20a0, 0x7a922132, 0x7c464085, 0x061b5306, 0x83927a21, 0x2034832c,
+    0x0da34b88, 0x53006321, 0x1d220501, 0xb6823601, 0x2009d662, 0x4c908516, 0x272005af, 0x2221bd89, 0x89018523, 0x053d4a11, 0x384af387, 0x013b2108,
+    0x84057a4a, 0x90312152, 0x08209482, 0xcb850082, 0x1c1c2a23, 0x05c34b0a, 0x0a030b23, 0x22138523, 0x82030505, 0x05052100, 0x2e250d85, 0x25240102,
+    0x4abc8636, 0x11260742, 0x1e01022f, 0x2182321f, 0xdd830120, 0x01012123, 0x2feb8521, 0x24231431, 0x0b0b0c2e, 0x07070303, 0x441d2d0e, 0x60201585,
+    0x2506814a, 0x363f2544, 0x4a542425, 0x265e8506, 0x2e3b4b35, 0x8231182e, 0x0bbb4127, 0x00002e22, 0x0ae76218, 0x84081747, 0x013d21d2, 0x22050a41,
+    0x183f3637, 0x2a0a7964, 0x0c0d7780, 0x0603040b, 0x53890d06, 0xff2106c9, 0x20548200, 0x20158717, 0x216e8529, 0x228322fd, 0x27211483, 0x08cd4a9a,
+    0x8707a821, 0x960b2114, 0x832cb085, 0x00000100, 0x8001e0ff, 0x3800a001, 0x2006ff46, 0x09684117, 0x26272624, 0xad551127, 0x11352106, 0x560d0947,
+    0x15240b7f, 0x2d2c46e0, 0x0123ee86, 0x852a1b1a, 0x1b2a2171, 0x4707fd79, 0x01260901, 0x330d2380, 0x66414934, 0x2ea02606, 0xfe0b2221, 0x258b85e4,
+    0x220b1c01, 0x19872e21, 0x220afb46, 0x82000600, 0x80023b00, 0x24008001, 0x3f003100, 0x55004a00, 0x00006000, 0x3b161701, 0x16171601, 0x99821517,
+    0x06010f2a, 0x012f2607, 0x27262726, 0x26053f4b, 0x36013f32, 0x82173233, 0x23352111, 0x2305a151, 0x3525011f, 0x2005fb58, 0x21bc8237, 0xbd623135,
+    0x07062106, 0x16244184, 0x37363317, 0x06861e82, 0x3c081583, 0x18268c01, 0x1018611d, 0x1801010f, 0x356c2919, 0x6c354444, 0x01181929, 0x18100f01,
+    0x25191d61, 0x222a2a22, 0x0123f8fe, 0x0f010728, 0x011d190f, 0x280701cc, 0x181e2301, 0x80fe0f0f, 0x203482e0, 0x8804840f, 0x20e02208, 0x840b83a0,
+    0x69012304, 0x46831019, 0x202a552f, 0x211b0b20, 0x1b210202, 0x2a20200b, 0x3d6c8355, 0x17171910, 0x4535fdfe, 0x55070130, 0x07131319, 0x07554d07,
+    0x35453001, 0x13130707, 0x85462d19, 0x06497905, 0x0c744918, 0x0001002d, 0x01c1ff00, 0x00bf0180, 0x49000050, 0xcb4105c2, 0x0f22220d, 0x20108401,
+    0x0a0b5026, 0x27263524, 0xda412726, 0x1135270b, 0x33363734, 0x03841716, 0x25092250, 0x2b1b0101, 0xe4411c1d, 0x0e0d3407, 0x24060614, 0x140e0909,
+    0x0b051608, 0x060c0d0c, 0x734e0405, 0x092108fd, 0x05d2410e, 0x18091128, 0x0820301e, 0x22872307, 0x5f011327, 0x2d1f1e05, 0x271e85d0, 0x0d0e14d0,
+    0x9a640201, 0x02220d82, 0x42833c0f, 0xda212783, 0x8316832b, 0x2126864b, 0x20822001, 0x01240f82, 0x5f060821, 0x36242587, 0x07000000, 0xe038ef82,
+    0xa0018002, 0x1c001500, 0x2b002300, 0x45003300, 0x00005b00, 0x31373613, 0x6b054e4c, 0x21200512, 0x3522e383, 0x06833317, 0x15351537, 0x37363736,
+    0x07060523, 0x33070631, 0x17162735, 0x35171631, 0x11556723, 0x2306dc6e, 0x07061716, 0x36294085, 0x15171637, 0x12120160, 0x9b4f181b, 0x60fe2609,
+    0x0112121b, 0x088b4e40, 0x1a854020, 0x40211085, 0x0fda6890, 0x01c0fe36, 0x011f1414, 0x02021690, 0x3370fe16, 0x02012222, 0x01021616, 0x58834484,
+    0x2008fc46, 0x210984e0, 0x5884e040, 0x1a83a020, 0x84a04021, 0x10d36869, 0x141fe823, 0x23458514, 0xf0332222, 0xf0215883, 0x055f4d00, 0xc001e02d,
+    0x3600a001, 0x3e003a00, 0x5d250000, 0x2e460a55, 0x05085c09, 0x2b462320, 0x37362d14, 0x35031f36, 0x15012f23, 0x39070133, 0x250d1346, 0x0e161601,
+    0x13916461, 0x0f2a8c27, 0x3a3a770f, 0x06824fc0, 0x2185c020, 0x08178025, 0x46921205, 0x934f06e7, 0x83c02006, 0x40d22613, 0x56401616, 0x3aaf8656,
+    0x018002e1, 0x001b007f, 0x0046002d, 0x23060100, 0x26272231, 0x11070607, 0x50161716, 0x065c0540, 0x05072106, 0x2810d462, 0x22232605, 0x26270607,
+    0x064a613f, 0x8205fd51, 0x42022d11, 0x7f83837f, 0x01121318, 0x19121201, 0x12210b84, 0x230b8213, 0x3efe1813, 0x0c894c18, 0x4e4c5a2f, 0x060b4a4c,
+    0x05310605, 0x20050808, 0x3205835e, 0x0506066d, 0x267e010b, 0x0d0e0626, 0x19c0fe19, 0x84060e0d, 0x011a220b, 0x200b833f, 0x0859459e, 0xa5314982,
+    0x08010c0d, 0x07440909, 0x088b2c07, 0x080aa507, 0x083f7a08, 0x2a055f45, 0x0035002c, 0x1300003d, 0x48311716, 0x7f410f67, 0x06e1590a, 0x34353326,
+    0x013b3637, 0x2605c35f, 0x07331523, 0x82363315, 0xc02326fd, 0x0d2a2b3b, 0x24b88503, 0x2b2a0d03, 0x06e84c3b, 0x8f821185, 0x0b5b8034, 0x60201818,
+    0x2060bbbb, 0xbb0b1818, 0x2401a001, 0xa7853823, 0x24233822, 0x4707524e, 0x602006c2, 0x802b3682, 0x0111121c, 0x01404040, 0x5a1c1211, 0x012b07af,
+    0x00a00180, 0x00490043, 0x91570051, 0x151623b1, 0x27490714, 0x90bf930d, 0x24c586c8, 0x23273435, 0x260b8217, 0x34b03736, 0x75172929, 0x0120063f,
+    0xc3850082, 0x29171324, 0xd94d3429, 0x0ba04106, 0x702fc382, 0x502f1f4e, 0x01bf9e9e, 0x9e9ebf01, 0x821f2f50, 0x1a1a22dc, 0x47dc852b, 0x2b2209ea,
+    0x40521a1a, 0x06914807, 0x2006de60, 0x254e8240, 0x20011f60, 0x2c832040, 0x01206023, 0x2aef821f, 0xff000001, 0x010002c0, 0x823100c0, 0x37362ae9,
+    0x16373631, 0x15171617, 0x05256417, 0x84012f21, 0x07062409, 0x82272322, 0x27262c03, 0x013f3435, 0x27060735, 0x83013d26, 0xc0240809, 0x1b121201,
+    0x0111121c, 0x06070eb2, 0x063aab08, 0x02010e01, 0x02026e6e, 0x3a06010d, 0x070608ab, 0x6201b20e, 0x08072177, 0x09774223, 0x05083911, 0x51390304,
+    0x2909042b, 0x2020010e, 0x09290e01, 0x39512b04, 0x08050403, 0x77091139, 0x08675842, 0xa0289382, 0x2f002300, 0x56004900, 0x175c9982, 0x07055105,
+    0x2305c454, 0x012f2627, 0x23087a41, 0x33171135, 0x2108c672, 0x57522515, 0x42208a08, 0x363a0d52, 0x00373637, 0x500e0909, 0x0228293d, 0x27171701,
+    0x05050434, 0x0b0c0d0c, 0xc0473806, 0x30402106, 0x2b07be44, 0x30500130, 0x0101201f, 0x30301f20, 0x2508f442, 0x0d013050, 0xd551140e, 0x0e802c06,
+    0x28020909, 0x232d3d29, 0x83801222, 0x204c8344, 0x06f2438c, 0xc0800122, 0x2107f559, 0x448460a0, 0x2b494c82, 0x20012106, 0x70203982, 0x83082662,
+    0x00012eff, 0x02e0ff00, 0x00a00140, 0x01000037, 0x8f6d1814, 0x012b2108, 0x8505e063, 0x966d1805, 0x05fd620c, 0x32250587, 0x02151617, 0x20a88240,
+    0x86038a60, 0x20128f8b, 0x83178301, 0x8503878b, 0x21118edf, 0x93820400, 0x8002d025, 0x5900b001, 0x372108fb, 0x0cbf5921, 0x06071423, 0x0ac14907,
+    0x6111da58, 0xa5820753, 0x2010b658, 0x08e35827, 0x59070621, 0x032005f2, 0xa0221187, 0x83584001, 0x4340200d, 0xff210516, 0x20168d00, 0x06814cff,
+    0xb1582d8e, 0x18012008, 0x2008d043, 0x07bc58c0, 0x5837e021, 0x37200f76, 0x3720fd85, 0x870f9f58, 0x222f9017, 0x85160268, 0x0838564d, 0x5890fe21,
+    0x875c0aae, 0x0027260a, 0x00430031, 0x0c9d4755, 0xd5601120, 0x012b2705, 0x3d262722, 0xd8412101, 0x013d3108, 0x17112726, 0x26272107, 0x07062327,
+    0x07220731, 0x0dad7318, 0x18052321, 0x30108f49, 0x17160100, 0x22600122, 0x01011617, 0x0e09091f, 0x86621820, 0x2c088307, 0x1282011f, 0x07122001,
+    0x0717bf18, 0x0cf64522, 0x85064c41, 0x18012013, 0x2408b45d, 0x1729e0fe, 0x63148530, 0x302c07ea, 0x20012917, 0x17484848, 0x88170101, 0x76080443,
+    0x128509ea, 0x2508bf42, 0xa0018001, 0xeb4c5000, 0x096f4d08, 0x0a8a1520, 0x37363323, 0x05b05836, 0x16171628, 0x07061707, 0xd6650706, 0x0afa4b05,
+    0x210e054c, 0x72826031, 0x8909044c, 0x34403109, 0x01042424, 0x0d0e090a, 0x01010809, 0x4e363606, 0x184c2983, 0x0c224c09, 0x82a00121, 0x4c2320ae,
+    0x1d200924, 0x9a250a89, 0x35222201, 0x82448308, 0x4e08244b, 0x82023333, 0x0a3a4c2a, 0x454c1e20, 0x82362009, 0x07175d8a, 0x0140022e, 0x001100c0,
+    0x0041002f, 0x37000054, 0x83084945, 0x272623d3, 0x91442726, 0x84112005, 0x230723e2, 0x03832327, 0x09cb5418, 0x20116172, 0x052f5025, 0x16282f83,
+    0x17161517, 0x90353736, 0x88074444, 0x1b702107, 0x25058c56, 0x4010101b, 0x0382e010, 0x10871020, 0xfec00124, 0x711844e0, 0x01230e2b, 0x4a021e00,
+    0x022607a3, 0x0f0f011e, 0x9f49d001, 0x01f0260f, 0xfe1b1212, 0x204583a0, 0x83008220, 0x059c490d, 0x0270fe22, 0x0a757118, 0xb3225983, 0xa84a210c,
+    0x21390807, 0x010f730c, 0x00730f01, 0x00050000, 0x02c0ff00, 0x00c00120, 0x002e0018, 0x004c0033, 0x13000065, 0x1f323336, 0x14151602, 0x2306020f,
+    0x26022f22, 0x023f3435, 0x31333617, 0x05ba5232, 0x15830120, 0x15820120, 0x17013727, 0x27371707, 0x05c64805, 0x3721318d, 0x2a159401, 0x050502f9,
+    0x05260e02, 0x840e2605, 0x04272e09, 0xb20e2704, 0x0e14130f, 0xfe0e0e23, 0x32088683, 0x69227d01, 0xfe186918, 0x0315393a, 0x15030808, 0x89070739,
+    0x61012209, 0x24158f38, 0x01080838, 0x895388bb, 0x0926225d, 0x2457820e, 0xfe0f1314, 0x22088683, 0x832d7d01, 0x8d3a2059, 0x225c8552, 0x821500ff,
+    0x305c8f48, 0x00000200, 0xff01c0ff, 0x0a00c001, 0x00005f00, 0x05b74901, 0x0f161726, 0x011f1603, 0x89061a6b, 0x23062609, 0x35262722, 0x05777e34,
+    0x17013f25, 0x85371716, 0x20098d0f, 0x253f8236, 0x36071601, 0x09853717, 0x013c4987, 0x0e1110a0, 0x1011580e, 0x59580f0f, 0x16222c20, 0x27261d16,
+    0x2b1f0d1d, 0x1e161623, 0x0c210982, 0x059d6a45, 0x1c0a4538, 0x2016171c, 0x1c0a1e05, 0x2016161c, 0x1d0a1e06, 0x0717161d, 0x39832e05, 0x09073925,
+    0x833b201f, 0x2d230809, 0x17170808, 0x1e26271d, 0x0f40010c, 0x5811100f, 0x11110e0e, 0x051f6657, 0x1c161721, 0x04200c1c, 0x82171621, 0x6a452007,
+    0x442b05b5, 0x26261e0b, 0x2116161e, 0x820b1e2a, 0x171d2334, 0x09832017, 0x17247682, 0x2e080617, 0x3a253b83, 0x070a2121, 0x2309823b, 0x08062f10,
+    0x00354384, 0xff000003, 0x01bf01c0, 0x001100c0, 0x00580046, 0x07060100, 0x05fa5831, 0x48373621, 0x0722059f, 0xde721f36, 0x32332105, 0xe55df783,
+    0x5f232008, 0x2a83091f, 0x37173223, 0x093f4427, 0x6a360321, 0x55430701, 0x17162305, 0xb659a001, 0x0ff3390f, 0x05167412, 0x75261004, 0x03090a0f,
+    0x0b0a0320, 0x07070e0d, 0x0d451703, 0x2e0bff42, 0x33371010, 0x0c0d0b31, 0x02010709, 0x180d400b, 0x69103f6f, 0x21430830, 0x0a062c07, 0x170b3707,
+    0x0c2b1316, 0x83a00e0c, 0x22588350, 0x43221e7a, 0x03230ba2, 0x83251836, 0x2257834f, 0x1876fe30, 0x2208d074, 0x83291b1b, 0x00320860, 0x10000d00,
+    0x3002c0ff, 0x0a009001, 0x20001500, 0x4b004000, 0x61005600, 0x77006c00, 0x8d008200, 0xa3009800, 0x36130000, 0x17163337, 0x26230706, 0x0a891527,
+    0x0a890720, 0x17320523, 0x05254131, 0x106d1620, 0x34352208, 0x06526037, 0x25213322, 0x31823d86, 0x0a892320, 0x40892720, 0x15b61720, 0xd0253689,
+    0x16101602, 0x20048e02, 0x290f8ac0, 0x08080b05, 0x321f1f01, 0x676d0901, 0x32012b06, 0x08011f1f, 0xea010b08, 0x3989e3fe, 0x0a896020, 0x3d892820,
+    0x1594e820, 0x159f8820, 0x2089c020, 0x47780121, 0x022105d3, 0x083c6216, 0x38200888, 0x38258582, 0x04112a2a, 0x051e4704, 0x11040425, 0x82382a2a,
+    0x475020af, 0x078707f6, 0x44873820, 0x11ab3820, 0x440aec60, 0x57460527, 0x4b4c2005, 0x53460b9d, 0x26032307, 0xd5603527, 0x37362c09, 0x3b323332,
+    0x16333201, 0x521f1617, 0x585a0518, 0x09e74e0f, 0x0808da6c, 0x0e0d012a, 0x0d0e1414, 0x02161801, 0x0d0c0705, 0x03030c0b, 0x2d183a07, 0x02030403,
+    0x1b020210, 0x06051414, 0x01151622, 0x380e0909, 0x5b05e147, 0xe3420750, 0xb2fe2610, 0x08371806, 0x833f820b, 0x27613047, 0x11120308, 0x1a07211b,
+    0x0e202419, 0x54600909, 0x62200d22, 0x83087b4c, 0x005526df, 0x06172500, 0x0697701d, 0x0726312b, 0x31220726, 0x26272223, 0xea42183d, 0x231c8708,
+    0x22313023, 0x22062f49, 0x18013d34, 0x361a8560, 0x07060706, 0x01000223, 0x110b0c01, 0x01010110, 0x39010102, 0x680c0b11, 0x148206c8, 0x82023821,
+    0x82102000, 0x219e8312, 0x6018010a, 0xf2820f8f, 0xa0200d25, 0x830404a0, 0x203f8222, 0x22328201, 0x82090e58, 0x580e2100, 0x0d823482, 0x02017023,
+    0x9a601845, 0x090d2515, 0x00000109, 0x83055b4d, 0x842e20df, 0x259083df, 0x2f363727, 0xb95d2601, 0x841f2005, 0x4a6118be, 0x8216200e, 0x33b88625,
+    0x7b1b1212, 0x0c0c5126, 0x08090d76, 0x0a553c07, 0x1b661f06, 0x0d3e6118, 0x010cff22, 0x1883a686, 0x0d43402d, 0x08075d0c, 0x47530c09, 0x18340c09,
+    0x220e3961, 0x850e0ae1, 0x46002095, 0x0220057f, 0x21229783, 0xd5583e00, 0x18272023, 0x180c3f56, 0x180e5b56, 0x821cdf61, 0x01f82ba0, 0x010f300f,
+    0x01010f38, 0x0a8a380f, 0x201bc658, 0x842d9018, 0x82002038, 0x00012500, 0x01c0ff00, 0x3820bb83, 0x6c085b4a, 0xd745092b, 0x1e326c07, 0x0ec03124,
+    0x266c0909, 0x2c212107, 0x21076061, 0x2e6c212c, 0xc0012516, 0x230e0909, 0x2107266c, 0x47610119, 0x19012107, 0x82192d6c, 0x820520ab, 0x02c12eab,
+    0x00c00180, 0x00350011, 0x00590047, 0x20b38263, 0x0ecb4614, 0x23171522, 0x2009ce4e, 0x09124a21, 0x2e4ad583, 0x33272a05, 0x33110127, 0x31303130,
+    0x20d88235, 0x08038237, 0x23013d3b, 0x07141521, 0x31140706, 0x33173114, 0x33011f16, 0x27032311, 0x30150706, 0x17351431, 0x150d0ebf, 0x010e0d14,
+    0x140d0e01, 0xc20e0d15, 0x0307544a, 0x0c0c0b02, 0xfe21080d, 0x079246fc, 0x1c630220, 0x2baa3f08, 0xbefe282e, 0x1b1b0140, 0x100f1c2e, 0x142101e0,
+    0x48292113, 0x444f0e16, 0x054556e0, 0x05634b01, 0x0b294705, 0x0b7ed025, 0x83080d0d, 0x83322054, 0x61012016, 0xfe210868, 0x085e83a0, 0x01304025,
+    0x4ac0fe10, 0x13282732, 0x1e17180b, 0x23290a0a, 0x01011623, 0x5f11013e, 0xc0fe4001, 0x49100d67, 0x43010101, 0x0029061f, 0x3e00c001, 0x23050000,
+    0x08895511, 0x840b1162, 0x173221f2, 0x16240684, 0x15171617, 0x32871c8c, 0x2001112d, 0x100f0140, 0x0f101818, 0x4b022e01, 0x0227071f, 0x2222012e,
+    0x83191f33, 0x22332205, 0x86198d22, 0x0140222d, 0x83348308, 0x110c2d3c, 0x21211636, 0x20211d1d, 0x0c113617, 0x0e213083, 0x83058316, 0x871b8d3e,
+    0x78fe2231, 0x21008200, 0x77560002, 0x00c02805, 0x003b0012, 0x7b212500, 0x33200681, 0x088c7618, 0x74332521, 0x6c7b094a, 0xec581809, 0x87232009,
+    0x60012131, 0x18077a59, 0x21088060, 0x774570d0, 0x44702005, 0x0d8d057b, 0x1b830020, 0x0909082a, 0x090d0d09, 0x0e6ff00a, 0x6f200a84, 0x21083093,
+    0x03000000, 0xc0ff0500, 0xbf013a02, 0x1c000d00, 0x00002d00, 0x36373601, 0x07161317, 0x26012b06, 0x07581127, 0x26232d05, 0x013f2627, 0x03311736,
+    0x16213726, 0x20058e62, 0x08138221, 0x01012f41, 0x0b0a0100, 0x0405e007, 0x0fe00905, 0x010b2c01, 0x09800f01, 0x80040405, 0x03ce0b07, 0x12160212,
+    0x220c0403, 0xc9fe2c21, 0x0c22212b, 0x0bb00104, 0xfe090304, 0x090808c0, 0x40010f01, 0x820c0351, 0x07013634, 0x0ae00808, 0x11cdfe03, 0x0f110303,
+    0x0119192a, 0x2a191901, 0x0643410f, 0xff00c022, 0x54259b82, 0x00006e00, 0x20998237, 0x82758427, 0x07df6704, 0x27281487, 0x07060726, 0x17161706,
+    0x16230585, 0x82313017, 0x0716210c, 0x3382c882, 0x87313021, 0x011f281f, 0x17163132, 0x85323316, 0x4d2f2038, 0x32200564, 0x8305fe5e, 0x82072042,
+    0x8223205c, 0xe1373403, 0x12060617, 0x1c1d1e12, 0x0a0b2b0c, 0x180b0204, 0x181a102d, 0x2907256a, 0x2d481520, 0x09050621, 0x24841009, 0x151a1b2e,
+    0x0f0f2f0d, 0x18160105, 0x0a1d1a26, 0x09362587, 0x13232001, 0x311b2311, 0x08090509, 0x0b03a011, 0x06020d0b, 0x29830107, 0x05230b83, 0x83010b0b,
+    0x6f32085a, 0x192c2215, 0x080d0d1a, 0x0c0b0e03, 0x10080e10, 0x05090307, 0x0d0d0506, 0x0b050c0b, 0x181f0b04, 0x16152027, 0x2b23150e, 0x0c0d1919,
+    0x0c0d0406, 0x1b82140b, 0x0c060623, 0x20258203, 0x270e820c, 0x070e0306, 0x33170c03, 0x60272683, 0x0207070f, 0x82010202, 0x83142016, 0x0401210a,
+    0x00395584, 0xff000006, 0x01ff01e0, 0x001e00a0, 0x00340027, 0x004b0044, 0x25000057, 0xcf691835, 0x37362409, 0x45212726, 0x3325072d, 0x17161716,
+    0x794e1833, 0x1f062409, 0x82070601, 0x27353a11, 0x34250726, 0x35263127, 0x14151607, 0x17231415, 0x15072736, 0x06273736, 0x2a3e8207, 0x23272631,
+    0x17323315, 0x5b200137, 0x01280689, 0x01010f70, 0x1b90fe0f, 0x2606944e, 0x34330d03, 0x49602049, 0x27080706, 0x06130622, 0x16020213, 0x09163f48,
+    0x01021d01, 0x5b01017d, 0x399f052a, 0x0a085029, 0x2e2d1692, 0x13100839, 0xc080820d, 0x09755b18, 0x2307cd5e, 0x012d2c46, 0x08086851, 0x0916b728,
+    0x16140303, 0x07184602, 0x06067014, 0x035b0302, 0x01020204, 0x7e493528, 0x24230642, 0x32af0308, 0xc0011d1e, 0x474c5e0c, 0x00022905, 0x5300c001,
+    0x83007700, 0x21068363, 0x1d49011d, 0x06186905, 0xeb822b20, 0x1f25ed82, 0x16171601, 0x490b841d, 0x505b0924, 0x18372005, 0x22089c4f, 0x85353736,
+    0x5b352012, 0x312108fd, 0x2e995405, 0x90012108, 0x1309090e, 0x040c0a11, 0x0c070504, 0x100a0c0c, 0x0f170210, 0x2002010f, 0x14142234, 0x23161601,
+    0x1722ff85, 0x76691813, 0x0c0c2705, 0x15141117, 0x21880e0e, 0x82241521, 0x70fe2121, 0x2028ba54, 0x222982c0, 0x84080412, 0x3275836d, 0x0f010805,
+    0x0f23170f, 0x1d1d0e15, 0x1d270425, 0x44150c1d, 0x1332055a, 0x080f0d06, 0x0b0b0d0d, 0x10070302, 0x0e0e010b, 0x25860415, 0x1e1d2824, 0x2482160d,
+    0xe5544020, 0x058f6327, 0x01c00129, 0x001500a0, 0x4a41002b, 0x332007bd, 0x2a09d546, 0x27262726, 0x37360711, 0x84373631, 0xbc451815, 0x0b2b510a,
+    0x25081047, 0x0d01a033, 0xb446140e, 0x92088408, 0x4a012012, 0x2a890897, 0x14700125, 0x83010d0e, 0x059f463e, 0x2005b346, 0x201487c0, 0x200888a0,
+    0x13d174b0, 0x00020027, 0x02e0ff00, 0x23cb8200, 0x004e0026, 0x21068d4e, 0xb5831523, 0x06010f26, 0x3726012f, 0x3521c282, 0x087b5d23, 0xe4832120,
+    0x33031527, 0x36372335, 0x20db8927, 0x23208821, 0x011f0633, 0x173b3f82, 0x3f323316, 0x01000201, 0xa81b1212, 0x0605112e, 0x1110470b, 0x05060a47,
+    0x51a82e11, 0x802008c7, 0xc7260983, 0x18074787, 0x4f183109, 0x302d1181, 0x47081809, 0x16121187, 0x01111216, 0x2d1f8320, 0x0d0e0140, 0x0e0e470c,
+    0x0e0d0c47, 0x5a834001, 0x08834918, 0x00ff4026, 0x1e1a0840, 0x3383138d, 0x081a1e29, 0x11111040, 0x41000010, 0xeb8405b7, 0x1a001526, 0x00004300,
+    0x22058259, 0x5c373635, 0x252a0c50, 0x21152135, 0x31070603, 0xf78f0706, 0x230e1641, 0x15232726, 0x9a698188, 0x80fe2309, 0x03838001, 0x8d83a020,
+    0xed88a020, 0x17223025, 0x41260116, 0x26240b0a, 0x20500f01, 0x4024b291, 0x00014040, 0x5f853687, 0x22171623, 0x23fc8b10, 0x40010f10, 0x3e20cf8c,
+    0x4109c363, 0xac41098b, 0xa2252005, 0x070621c5, 0x2724ef82, 0x15233533, 0x6a05b241, 0xfe210f71, 0x84c79fe0, 0xa0a022eb, 0x24b78d20, 0x401b1212,
+    0x93e189c0, 0x823083c6, 0x000024f1, 0x59000600, 0x1a2b07af, 0x5e004d00, 0x74006900, 0x54007f00, 0x3120066f, 0x21051c51, 0xaa831716, 0x2e053051,
+    0x011f2726, 0x3f323316, 0x34353601, 0x8226012f, 0x22232b02, 0x2706010f, 0x35302726, 0x0b842627, 0x07210e82, 0x21258206, 0x25821617, 0x31220783,
+    0x13872637, 0x36013b27, 0x012f3637, 0x051b6003, 0x16070625, 0x84263717, 0x2215832c, 0x83273607, 0x2c378328, 0x22220100, 0x4848393a, 0x22223a39,
+    0x390b8b01, 0x0e0a19d8, 0x090d0c15, 0x04071209, 0x0607030a, 0x0c080b03, 0x0b050305, 0x06821313, 0x23032708, 0x07050510, 0x0d0d0704, 0x0a0a100e,
+    0x3a040327, 0x0b271410, 0x2b0b0102, 0x0b1e0907, 0x16070403, 0x010f100a, 0x04840f01, 0x0e06a725, 0x8408030d, 0x0a142504, 0x200b0b0a, 0xc0200484,
+    0x7e857291, 0x10692c08, 0x0c0f1107, 0x170b0f0e, 0x071a0a0a, 0x01090f04, 0x06010302, 0x03070f0f, 0x0f081102, 0x0d061010, 0x04050605, 0x020d0404,
+    0x8210da02, 0x0b0a2e84, 0x01031306, 0x16080909, 0x0f01cffe, 0x2775820f, 0x0d95010f, 0x180e0603, 0x50250484, 0x0a0a0b0b, 0x57048420, 0x803506d3,
+    0x2e00c001, 0x62004300, 0x00006800, 0x33173613, 0x3f341732, 0x07471801, 0x15222308, 0xe75c1530, 0x0714220b, 0xb64a1817, 0x57372009, 0x36200ae9,
+    0x2706d252, 0x37360531, 0x27261517, 0x20051c78, 0x224b8335, 0x47352637, 0x3b2f07b2, 0x17351701, 0xef310706, 0x1a700c0d, 0x53400116, 0x402405b4,
+    0x40020902, 0x2205bc45, 0x189a0340, 0x28090a4a, 0x0808b1c8, 0x080c880c, 0x07445208, 0x0200ff27, 0x25358905, 0x2236863f, 0x870f0303, 0x5fb02b36,
+    0x1d013827, 0x010b0104, 0xb4534001, 0x01402405, 0x46151201, 0x0f220584, 0x4a18780e, 0x9e22091d, 0x51820443, 0x04205882, 0x2707ef52, 0x6d0d10a0,
+    0x3f21068f, 0x02233786, 0x85252002, 0x76df2437, 0x4106264a, 0x40240627, 0x1d00c001, 0x20074167, 0x05ef4513, 0x33053074, 0x06070615, 0x16171407,
+    0x21230617, 0x27262726, 0x17350511, 0x83069760, 0x0718410e, 0x27072722, 0x22057342, 0x8236013f, 0x00312609, 0x1b121201, 0x2a6882a0, 0x23243880,
+    0x22141401, 0x44ff0505, 0x0026050a, 0x40018080, 0xeb6c2802, 0x0228300b, 0x0b1d3d63, 0x280a0a0b, 0x0a480b0b, 0x440b0b0a, 0x802c0582, 0x2709090e,
+    0x3e2d2e10, 0x1825252d, 0x1227ef82, 0x4080011b, 0x6cf08080, 0x2b220fe5, 0x34831c3c, 0x0a0a2823, 0x20448348, 0x51d39000, 0x33200897, 0x1720d39a,
+    0x6d100d58, 0xdc9c18c2, 0xdb8f2020, 0xc76dcb20, 0x1b802418, 0xa7011212, 0x1acb6de5, 0x0000042c, 0x8002c0ff, 0x1900c001, 0x8b5d2a00, 0x013f2207,
+    0x974d1836, 0x26072309, 0x2f7d0627, 0x05312105, 0x0d804d18, 0x37333529, 0x16311716, 0x18321517, 0x3a0b7342, 0x3734013d, 0x36353336, 0x15373637,
+    0x06310722, 0x3533011d, 0x23262734, 0x184c0600, 0x2d07af4d, 0x1f0f090a, 0xfe1f2f2f, 0x0b0a1063, 0x4d188001, 0x40250a9d, 0x16172290, 0x05f04201,
+    0x0685a020, 0x17160123, 0x3c098222, 0x0e090940, 0x090b2501, 0x01011472, 0x0b097214, 0x020a0a0f, 0x1f01011f, 0x45100a0b, 0x07df47f0, 0xa0a0f023,
+    0x202f8320, 0x202c8230, 0x833e8580, 0x83302006, 0x21138354, 0x14823030, 0x2106e771, 0xf3820002, 0x8b007924, 0x53559400, 0x1615310a, 0x26273717,
+    0x011f3637, 0x2f060716, 0x17160701, 0xe182c883, 0x26070628, 0x06233527, 0x7d571707, 0x27062905, 0x27013f26, 0x33150706, 0x2409f454, 0x07272635,
+    0x84368417, 0x26372440, 0x84152327, 0x37362136, 0x33214082, 0x05a95636, 0x36013f2e, 0x010f1617, 0x35373617, 0x31272623, 0x31212182, 0x082c7206,
+    0x0ceb4a18, 0x9d54c020, 0x2f102906, 0x0e0b1823, 0x3811110e, 0x0b240483, 0x22061c18, 0x29076f54, 0x181c0622, 0x0e11110b, 0x0483380e, 0x23180b26,
+    0x0216102f, 0x397136b6, 0x7670200f, 0xa8200801, 0x6ccb0985, 0x9820a39b, 0x200fb257, 0x0b6f5d98, 0xaf420220, 0x00452508, 0x1300007f, 0x20058f41,
+    0x70511817, 0x1716240c, 0x41230706, 0xae4521ca, 0x41032008, 0x735f08c8, 0x14cc4109, 0x2205b054, 0x41333637, 0x312205d0, 0x77412186, 0x2d242405,
+    0x82070a10, 0x510a2500, 0x16020216, 0x221bb041, 0x459f1105, 0x5f2509c5, 0x1f1afc0f, 0x20328310, 0x223e8551, 0x41242d10, 0x0a260aea, 0x23061c19,
+    0x1a851701, 0x23011727, 0x70010201, 0x08034221, 0x4109557a, 0x23221c98, 0xe1457c1e, 0x864b2909, 0x22040ec6, 0x02161602, 0x39943d85, 0x50201a82,
+    0xc7827382, 0x45090921, 0x802a070f, 0x4400c001, 0x68005600, 0xe9707800, 0x17162d0e, 0x26012b06, 0x35272627, 0x26270607, 0x29056048, 0x012f0607,
+    0x16171615, 0xde463317, 0x05bb6a0a, 0x2107857b, 0xe05e2733, 0x8207200b, 0x66332016, 0x184605b0, 0x07dd631b, 0x1314212b, 0xa00c0c22, 0x022d2d44,
+    0x06fd4207, 0x0f0f372b, 0x01071110, 0x30291b1b, 0x05f84320, 0x02290b22, 0x24071c47, 0x0b130c0c, 0x29158541, 0x0109090d, 0x0d090901, 0x6a456101,
+    0x0f46460f, 0x29060657, 0x021925d0, 0x442d2d02, 0x61830606, 0x0e0e382e, 0x0f101138, 0x2906060f, 0xd0011b1b, 0x21050c47, 0x2f47341c, 0x15192407,
+    0x5f300d15, 0x6f460b3a, 0x42052021, 0x5f4108cf, 0x00712205, 0x5861417c, 0x1811a646, 0x2208584f, 0x82161527, 0x2635240b, 0x41070627, 0x41204a65,
+    0x7b0f6441, 0x11290898, 0x010f0e02, 0x020e0f01, 0x55674101, 0x33446020, 0x50b02107, 0x04846783, 0x410ad749, 0x8120056b, 0x486a6941, 0x6e411810,
+    0x193e485b, 0x48557541, 0x47262467, 0x78005900, 0x7b418500, 0x3732230e, 0x4a441415, 0x48172048, 0x7f412a96, 0x08312308, 0x55440808, 0x48f1203e,
+    0x73411cbd, 0x21012307, 0x53440e10, 0x4840203a, 0x7f7822e1, 0x0049310b, 0x00620056, 0x35263700, 0x36373431, 0x011f3233, 0x22089545, 0x4c352137,
+    0x1a830a8d, 0x2605325e, 0x15012f22, 0x85171633, 0x1521210c, 0x0c833583, 0x06010f23, 0x201a8223, 0xe4551813, 0x011d2407, 0x53013523, 0x3321094d,
+    0x05274c29, 0x0a5c2920, 0x60012206, 0x058e4c29, 0x06836020, 0x1c8d6020, 0x8ca0fe21, 0x4557201c, 0x40210535, 0x07d17601, 0x2a211d86, 0x25188274,
+    0x0109090d, 0x3f852a72, 0x4e844682, 0x2a09092b, 0x09090172, 0x09090e0d, 0x221a8a74, 0x450d5801, 0x802406e1, 0x8100ff80, 0x2005f445, 0x08b76281,
+    0x2c05c746, 0x005c0050, 0x0088007b, 0x26271700, 0x2c134135, 0x011d0622, 0x220e0e41, 0x18033127, 0x2109764d, 0x0d410523, 0x1f1b4b0a, 0x1b4b0620,
+    0x69272109, 0x4d071d41, 0x012106b5, 0x0c1d4100, 0x2923fa85, 0x8cff0b4b, 0x41092017, 0x00200734, 0xb0200886, 0x201b7f42, 0x07374137, 0x221b5241,
+    0x41101917, 0x01220a4e, 0x4e418038, 0x074c4109, 0x17018028, 0x0a302117, 0x614b0e09, 0x300a2c09, 0x01171721, 0x09090130, 0x8330300d, 0x00002231,
+    0x08d74607, 0x2f00222e, 0x49003c00, 0x63005600, 0x00008700, 0x5305a457, 0x5c4b0535, 0x0e425306, 0x18171121, 0x23085b7e, 0x17150706, 0x0f880382,
+    0x09880720, 0x37201582, 0x25271998, 0x14311516, 0x4f06010f, 0x797a055c, 0x09f0410b, 0x01200130, 0x60140e0d, 0x010d0e14, 0x16160228, 0x004b1802,
+    0x00ff2107, 0x40200983, 0x097d5d18, 0x010f1022, 0x10200c87, 0xb0201589, 0xfe241594, 0x500909f7, 0x2105f542, 0x7d42731a, 0x1a732105, 0x2005be41,
+    0x09b95450, 0x16489026, 0x48160202, 0x8308f84c, 0xa0012208, 0x20518940, 0x20678930, 0x20159f90, 0x206e83a7, 0x20638550, 0x05084219, 0x81851920,
+    0xbb665020, 0x0022290c, 0x006a0058, 0x2500007d, 0x7319f443, 0x1727070b, 0x17161736, 0x83333736, 0x06237606, 0x27262722, 0x21057152, 0x07830706,
+    0x21069163, 0x01833637, 0x83311721, 0x8231202d, 0x07262222, 0x221e8222, 0x83350706, 0x15332417, 0x83261525, 0x26232114, 0x35211482, 0x23498233,
+    0x00013117, 0xb7919d87, 0x120e2408, 0x2a2b2213, 0x13140123, 0x070d1c16, 0x0b030307, 0x14260c0c, 0x1f31322d, 0x09070709, 0x2b33311f, 0x740d2615,
+    0x0d3c0594, 0x1513161c, 0x232b2a23, 0x131c1f4e, 0x11111515, 0x01080915, 0x90140e0d, 0x09088001, 0x152a0e83, 0x901e1d13, 0x010d0e14, 0x8041d281,
+    0x099a4107, 0x0a0ed236, 0x0e0a0909, 0x190c0c67, 0x0d180201, 0x0307120f, 0x0d0d0b0b, 0x0a267282, 0x0301190f, 0x00820410, 0x01031029, 0x030a0f19,
+    0x830d0707, 0x07260872, 0x180d0f12, 0x05190102, 0x010c1401, 0x02050d0f, 0x0d14ba05, 0xb2e2010e, 0x050303b9, 0x0c010f0d, 0x01e20114, 0x40180d0e,
+    0x53230ecf, 0x6f008900, 0x1d220511, 0x76413301, 0x16332719, 0x15171617, 0x2c410714, 0x23098209, 0x06072223, 0x51411183, 0x3d262606, 0x36373601,
+    0x05584f37, 0x41133321, 0x36202f9c, 0x31256182, 0x0e0d15ef, 0x137e4181, 0x0e143027, 0x0605010d, 0x07384106, 0x111d1e27, 0x1a111414, 0x075b4121,
+    0x05060627, 0x140e0d01, 0x21048310, 0xa141917f, 0x1312252e, 0xc0012b22, 0xd0213a83, 0x118a4193, 0x18839320, 0x0a0c6024, 0x46410202, 0x14012506,
+    0x02130c0c, 0x23076641, 0x600c0a02, 0xd0209c83, 0xfe210483, 0x2dac4140, 0x190c0c2a, 0x00000001, 0xff00000b, 0x2005e779, 0x06a75f23, 0x7d006b2c,
+    0xa1008f00, 0xc500b300, 0x375ad700, 0x06fd4208, 0xa8412720, 0x3c6a180a, 0x013b2107, 0x20119e4c, 0x12b56607, 0x107d7e18, 0x33202390, 0x25201190,
+    0x20073d52, 0x25808215, 0x26272607, 0x43601727, 0x90232010, 0x90252023, 0x52272047, 0x01211085, 0x05e7421f, 0x09090d24, 0x1344c801, 0x34ca2105,
+    0x2108d145, 0x694f2101, 0x8f80200f, 0xfd401810, 0x90109010, 0x9ffe2732, 0x140d0e01, 0x00820e15, 0x0d141527, 0x0e61010e, 0x09ab600e, 0xe10e0e22,
+    0x0d211d84, 0x07c1600e, 0x72a0e120, 0x51c00121, 0x332109cd, 0x05e744ca, 0xe744c920, 0x50502005, 0x80200fb4, 0x31e310b1, 0x2e087759, 0x00a00140,
+    0x00370013, 0x2500005b, 0x49311732, 0x75500660, 0x21332806, 0x31230627, 0x48012f22, 0x9e180994, 0x91720a3f, 0x010f2305, 0x4c6b0727, 0x05cc4908,
+    0x07222390, 0x034f0231, 0x6ffe2006, 0x02220632, 0x82494900, 0x053c410b, 0x20076148, 0x0c9e49e0, 0x20201b8c, 0x220bcb4e, 0x84090929, 0x09092229,
+    0xbb54182a, 0x07784907, 0x95496020, 0x821b8e0a, 0x060039fa, 0xc0ff1000, 0xc0016f02, 0x29001700, 0x4d003b00, 0xc000a900, 0x15130000, 0x5b05bc51,
+    0x1f200561, 0x2605047a, 0x17311716, 0x82310714, 0x262723e3, 0x794a3627, 0x90072006, 0x36212311, 0x8a573137, 0x05c14a06, 0x83052721, 0x012b2223,
+    0x0a8a5022, 0x3b363726, 0x37173201, 0x07834582, 0x011f1622, 0x07820f84, 0x82071621, 0x08a25773, 0x2207ba50, 0x8c012f26, 0x06072113, 0x2406cf53,
+    0x37261315, 0x899f8836, 0xa72308b5, 0x0f101118, 0x1110400f, 0x110e0e40, 0x07071611, 0xc001170a, 0x10120b0b, 0x01010b0c, 0x12100c0b, 0x8db00b0b,
+    0x1001210e, 0x16861786, 0x0900ff37, 0x0d300e09, 0x1a010909, 0x0913140c, 0x15140c26, 0x14191418, 0x24078422, 0x0c141518, 0x830d8222, 0x09262507,
+    0x1c0c1413, 0x24222c8c, 0x10890202, 0x00820120, 0x23842420, 0x8b82d820, 0x84171021, 0x239e888b, 0x1776a801, 0x40201683, 0x0e29ad84, 0x0a76170e,
+    0x16020707, 0x05e666b0, 0x60200585, 0x0b8b0c8b, 0xc648b820, 0x31262d05, 0x140c0913, 0x0c0d1547, 0x0d153f0d, 0x15210082, 0x270a823f, 0x0c144715,
+    0x26311309, 0x4424238b, 0x36310402, 0x36261085, 0x02010231, 0x23854401, 0x10480123, 0x897b8811, 0x00002390, 0x00820003, 0x01800229, 0x00130080,
+    0x185c0048, 0x18086351, 0x200c8993, 0x05d34917, 0x08c46f18, 0x16011f23, 0x0ce34915, 0x4306ae4c, 0xa859053f, 0x01312105, 0x79073842, 0x322005f4,
+    0x11202382, 0x85061b43, 0x09d724a0, 0x4ce62a09, 0x128f115a, 0x43890121, 0x01210b09, 0x630d8280, 0x49250cc7, 0x0a0d0d0a, 0x13b34b29, 0xfe21138e,
+    0x637785e9, 0x200808fd, 0x000000c0, 0xff210004, 0x01e101e0, 0x001800a0, 0x004a0031, 0x01000063, 0x36350722, 0x37171633, 0x05ff7b36, 0x27222335,
+    0x26013f26, 0x14073127, 0x35262317, 0x26273736, 0x82373637, 0x14152f20, 0x012f0607, 0x17310706, 0x36171607, 0x54181537, 0x07220f40, 0x16823731,
+    0x33273423, 0x251a8216, 0x06071617, 0x417c2307, 0x31172405, 0x82110101, 0x59300800, 0x09081e3e, 0x0f010109, 0x04040b69, 0x3e2c1f07, 0x024103a0,
+    0x081d3702, 0x6a0a0404, 0x0a09010f, 0x01261e08, 0x3d2b1d55, 0x100f0f10, 0x091f3d58, 0x02232c82, 0x820a6a0e, 0x1da6232c, 0x2c830127, 0x071f382e,
+    0x690b0404, 0x0901010f, 0x60010809, 0x3f831284, 0x3f821283, 0x01261f24, 0x008210a0, 0x1d3e5822, 0x0b313c86, 0x1e070304, 0x1d5c3d2b, 0x02010225,
+    0x03010240, 0x2a418b36, 0x3e2b1d10, 0x110f0f11, 0x8a1f3e59, 0x00002199, 0x2d0aef61, 0x0054004f, 0x13000058, 0x22312306, 0x5a182627, 0xbd4e0861,
+    0x16112208, 0x0b9b5b17, 0x85272621, 0x42232001, 0x31240923, 0x36373526, 0x2e0ace5b, 0x35171633, 0x3734010f, 0x35311506, 0x4ef73115, 0x012312b8,
+    0x4d1b1212, 0x4024069e, 0x01242536, 0x73200f83, 0x22083a42, 0x45040302, 0x7327071d, 0xf7291d23, 0x4f010202, 0x1b45060e, 0xedfe250a, 0x0112121b,
+    0x23054a42, 0x36252401, 0x20420d83, 0x0e092407, 0x4e04070c, 0x282b0606, 0x2aa41101, 0x06050789, 0x4e010106, 0x2d280cbb, 0x67003f00, 0xbf009000,
+    0x5e71fb82, 0x36352305, 0x5b183637, 0x312208f3, 0x02820706, 0x06073022, 0x83050745, 0x052f431a, 0xbd483120, 0x08637a11, 0x31013b26, 0x16311732,
+    0x10bf5b18, 0x21055741, 0x1c830123, 0x50011d21, 0x88460903, 0x26638505, 0x26272631, 0x8234023d, 0x1331211c, 0x4f095b41, 0x34230904, 0x82313015,
+    0x3037271d, 0x30333635, 0x53182231, 0x09250af8, 0x0a0d0d0a, 0x06c14f68, 0x0201012a, 0x01050504, 0x0d600805, 0x2106bd4f, 0x08826a14, 0x1092a518,
+    0x07865718, 0x090e6025, 0x41020304, 0x69200547, 0x2205aa41, 0x8201136a, 0x88092015, 0x0566430d, 0x05211282, 0x20288302, 0x834f824d, 0x85692028,
+    0x02022434, 0x180e0905, 0x26088048, 0x09b70113, 0x87146a09, 0x0860217b, 0x05238a82, 0x82010204, 0x830e209d, 0x83682014, 0x5ff72039, 0x9b1807d4,
+    0x4a850849, 0x06050925, 0x85610506, 0x8713206e, 0x20012165, 0x0d881c82, 0x06252886, 0x01070505, 0x2129825f, 0xa68fe0fe, 0x07010125, 0x82040605,
+    0x0e09216f, 0x0ac78718, 0x0002c030, 0x2200c001, 0x59004700, 0xa2007d00, 0x85410000, 0x0e04480a, 0x9f413620, 0x011d2205, 0x08424813, 0x270ddc42,
+    0x07141516, 0x17012b06, 0x31210783, 0x08164527, 0x21063c48, 0x314f2715, 0x26072322, 0x015f3135, 0x90461805, 0x09eb410a, 0x92820720, 0x82312721,
+    0x0d0a26f9, 0x09090a0d, 0x20068340, 0x05ae4940, 0xd9820820, 0x0a0e0d24, 0x13869709, 0x1a821b84, 0x36413320, 0x82332005, 0x4597202e, 0x69200b60,
+    0x228d3e86, 0x31823c84, 0x0920598b, 0x1b833686, 0x826d0121, 0x21619647, 0x9193fcfe, 0x2f835f82, 0x86855720, 0x17200585, 0x5d8bb78a, 0xce203f82,
+    0x76825c96, 0x06002d08, 0xc9ff0800, 0xb8017702, 0x35001500, 0x5c004700, 0x87007200, 0x36130000, 0x3635011f, 0x15171637, 0x26230706, 0x33373627,
+    0x31372627, 0x61058857, 0x162108cd, 0x0bcf6107, 0x78181f88, 0x355c0b43, 0x16332205, 0x85468417, 0x01372251, 0x84528537, 0x0681595d, 0x25313723,
+    0x06755c15, 0x17202d85, 0x24085d82, 0x110f012f, 0x16023f11, 0x16020216, 0x03031660, 0x0e3f2616, 0x190c770e, 0x3125251a, 0x1a252531, 0x05050d19,
+    0x230d890d, 0xba06060c, 0x820fed42, 0x0f102441, 0x85263e0f, 0x26478242, 0xfd3f0216, 0x83263fc0, 0x0601684d, 0x11113f26, 0x01020e0e, 0x23826687,
+    0x0f3e262a, 0x3f11100f, 0x0e0eb101, 0xe52e298f, 0x161e1f1a, 0x16010116, 0x1a1f1e16, 0x0d8d0c0c, 0x46184c20, 0x01230fe6, 0x8f0e0e31, 0x40fe21c1,
+    0x6a88d188, 0x9f8c1d20, 0xb1831120, 0x0c276018, 0x5d002e25, 0x45010000, 0x3e480539, 0xfd43180e, 0x063a4511, 0x2e940320, 0x70072221, 0x232205ce,
+    0x994f2722, 0x26272707, 0x31373435, 0x6a4b2901, 0x082c4b06, 0x210df345, 0x474b2ad3, 0x0a174606, 0x80429320, 0x1b012408, 0x8293291b, 0xb7012121,
+    0x4f832589, 0x12012924, 0xb9481b12, 0x36202306, 0x65852425, 0x8e00ff21, 0x09092225, 0x2224870e, 0x851b1b29, 0x2b571824, 0x00b02809, 0x005b002d,
+    0x467f006d, 0xd355063d, 0x077c5005, 0x8f710620, 0x47272008, 0xd3820a27, 0x13013f22, 0x96101d44, 0x333624fd, 0x4e021f32, 0x01201098, 0xf9201190,
+    0x21052344, 0xa583931a, 0x5008f943, 0x5e200b1d, 0x4109ac51, 0x42500e1d, 0x42a92007, 0xfe210f24, 0x21118f80, 0x7f44a701, 0x01182405, 0x41291b1b,
+    0x0d240718, 0x1a010909, 0x50207f85, 0x50220683, 0x8952b0fe, 0x0b42410e, 0x20072d51, 0x10104317, 0x1053ac18, 0x20051369, 0x0ae34d02, 0x41181320,
+    0x5c1808c7, 0x1679092c, 0x1806200a, 0x241341ac, 0x013f3435, 0x05a75717, 0x4508ce48, 0x26240e64, 0x31373435, 0x0220a486, 0x2006e24d, 0x36e24dfe,
+    0x5a180120, 0xe34d0cdf, 0x05975f39, 0xc001002f, 0x37001700, 0x32010000, 0x15163117, 0x0bcb6f11, 0x82341121, 0x067118d5, 0x092a6a0a, 0x21091471,
+    0xce830133, 0x41021e21, 0x022507c8, 0x0e09091e, 0x07c75d60, 0x7009e569, 0x7022088f, 0x2182c001, 0x12f7fe23, 0x079f4125, 0x01122531, 0x09090e09,
+    0x1b29e080, 0x1b01011b, 0x69e0291b, 0x202416f3, 0x2001c0ff, 0x2225af82, 0x00003800, 0x22a98313, 0x4b161523, 0x0620056d, 0x230af468, 0x27262335,
+    0x3b23b982, 0x78320301, 0x9c18075d, 0xe0290b01, 0x16020216, 0x13142008, 0x20b38301, 0x31858480, 0x08201413, 0x06070216, 0x1440810a, 0x01010d0e,
+    0x104e0c0b, 0x2e058305, 0x01140e0d, 0x161502c0, 0x1e105d03, 0x84c0261f, 0x1212362f, 0x1f26c01b, 0x025d101e, 0x07070a16, 0x0c0c80fe, 0x12121118,
+    0x2439820d, 0x12120d0d, 0x22438311, 0x87000400, 0x000826af, 0x0049003e, 0x2fb38454, 0x36352315, 0x36073337, 0x3b36013f, 0x011f3201, 0x038fc583,
+    0x3623cc86, 0x8b272637, 0x18312003, 0x210a0848, 0x58570615, 0x27263505, 0x0216c823, 0x50160280, 0x191601a8, 0x135a1310, 0x02151910, 0x0123d882,
+    0x89141401, 0x20c38203, 0x8bd884a0, 0x12122814, 0x0f605001, 0x840f0101, 0x20088804, 0x3aed8260, 0x16282816, 0x0c199802, 0x0b08080b, 0x0c16190c,
+    0x0c1c170e, 0x0e1b190f, 0x821a1a0e, 0x82498403, 0x820b8352, 0x191b2a03, 0x171c0c0f, 0x68160c0e, 0x06a56701, 0x08876020, 0x00820020, 0x1000023a,
+    0x3002e0ff, 0x2b00a001, 0x00004c00, 0x31333013, 0x37363330, 0x17323736, 0x33270582, 0x17161732, 0x82163336, 0x31322305, 0x6d603132, 0x26212205,
+    0x231a8235, 0x34073137, 0x080d4d18, 0x82070621, 0x0f1d79f1, 0x0160313a, 0x15150601, 0x0a14151e, 0x17171313, 0x120a1313, 0x15151e17, 0x1b010106,
+    0x0928dc82, 0x010912fe, 0x501b1212, 0x0121c482, 0x78ca82ea, 0x012811bf, 0x11121c40, 0x0c130b01, 0x13250082, 0x1211010b, 0x2330831c, 0x120e0e12,
+    0x9b204083, 0x5b783382, 0x60002014, 0x1c2a0903, 0x3f003200, 0x58004d00, 0x27590000, 0x6d212005, 0x3621094f, 0x3212823d, 0x26272635, 0x01352327,
+    0x26012f36, 0x1706010f, 0x5f013f16, 0x172605b9, 0x25313716, 0x2f823736, 0x07061526, 0x35272621, 0x2805fa4e, 0x26272221, 0x1521013d, 0x09e14127,
+    0x01000125, 0x18140e0d, 0x210985b4, 0x357e03d3, 0x70200805, 0x0a0a3b01, 0x400b0b40, 0x0b0b0a0a, 0x0f0f0125, 0x0b0b2501, 0x0f01c5fd, 0x010f6001,
+    0xa0fe0f01, 0x60200582, 0x2108af79, 0xe241d040, 0x6d90200a, 0x6020087e, 0x08250983, 0x210cf308, 0x22098320, 0x84d5fe50, 0x23568250, 0x79240a0a,
+    0x79243283, 0xab0a0a24, 0x2109d358, 0xfb46d0fe, 0xe0e02205, 0x08e641a0, 0x43180420, 0x4026081f, 0x4a004500, 0x2b5e4f00, 0x18e1820e, 0x490c5741,
+    0x41180728, 0x26220c5e, 0x7e623527, 0x21332409, 0x82152307, 0x2103820e, 0x0482022b, 0x21072053, 0x80464828, 0x82202006, 0x07664485, 0x83064447,
+    0x2848210e, 0x022c9d85, 0x50505800, 0x305050d0, 0xa0015050, 0x2105af46, 0x20838040, 0x16e66718, 0x56834020, 0x86408021, 0x84402029, 0x00003600,
+    0xff200006, 0x018002c0, 0x003500a0, 0x003f003a, 0x00560044, 0x44db8f66, 0x2621055c, 0x078f4823, 0x22012b25, 0x633d2627, 0xd0990562, 0x69116247,
+    0x476a0f55, 0x48282907, 0x2935412f, 0x09091729, 0xeb93fa8e, 0xc0619820, 0x0f25630f, 0x27070c41, 0x01012748, 0x022c1b1a, 0x410f1341, 0xfe200e03,
+    0x20201063, 0x12234107, 0x6a005f22, 0x20452541, 0x10215713, 0x41130063, 0x78203329, 0x620f2841, 0x2b4112e9, 0x14d46240, 0x57420020, 0x416f2015,
+    0xc8625731, 0x44364118, 0x4119b162, 0x9c62403d, 0x09974319, 0x3b00362a, 0x45004000, 0x71006400, 0x113d5318, 0x93431520, 0x06fd5c05, 0x6d440720,
+    0x05152616, 0x15233533, 0x21038223, 0x09832333, 0x8b620520, 0x0920232a, 0xd0490e09, 0x08282907, 0x01201f30, 0x2c1c090f, 0x2b13a743, 0x50507801,
+    0xd0505030, 0x78015050, 0x201bf45f, 0x06a45f01, 0x09090e30, 0x1f200140, 0x10081930, 0x1b010220, 0xb844291c, 0x1b1c2408, 0x82408001, 0x60012277,
+    0x6b008440, 0x02202240, 0x24069f45, 0x00320080, 0x0b274168, 0x14011d24, 0x25410607, 0x07262305, 0xb5440706, 0x82062005, 0x07152609, 0x07262726,
+    0x26048235, 0x26272227, 0x5c01013d, 0x002034be, 0x2a071e41, 0x1d0c0808, 0x14011313, 0x451e1d11, 0x012d07b4, 0x14111c1e, 0x1d131301, 0x0108080c,
+    0x33a15c80, 0x2006b562, 0x82408324, 0x017d2647, 0x0101140c, 0x07454a80, 0x01018026, 0x7d010c14, 0x7d827683, 0xc0fe2422, 0x2532895c, 0xff000002,
+    0x018201c0, 0x00180026, 0x13000039, 0x0bfc5c18, 0x26352325, 0x41272627, 0xa848053b, 0x0714260a, 0x07012b06, 0x056d5306, 0x2f262108, 0x27222301,
+    0x60313526, 0x2a2b0230, 0x2a413041, 0x0130022b, 0x302c1e1d, 0x011d1e2c, 0x0e090960, 0x3207ee41, 0x0d031605, 0x13ea130d, 0x16030d0d, 0x09090e05,
+    0x83082001, 0x2135832c, 0x2c830808, 0x08203583, 0x82060342, 0x48d5201f, 0xd52005b3, 0x00234282, 0x82020000, 0x02c528a7, 0x00bf013b, 0x827f003f,
+    0x593320a7, 0x072306a7, 0x59171523, 0x0226063d, 0x27260706, 0xf269010f, 0x013f2305, 0x9b822335, 0x36372625, 0x5633011f, 0x1f21059a, 0x24338501,
+    0x05311716, 0x250a8517, 0x07012f06, 0x33861617, 0x39822720, 0x6a273521, 0x37220832, 0x186d2627, 0x23088208, 0x07151633, 0xf9083485, 0xbb310716,
+    0x16060511, 0x05080215, 0x0f272014, 0x16010803, 0x13050516, 0x12252712, 0x16050513, 0x03080116, 0x1120250f, 0x15020806, 0x11040716, 0x07221007,
+    0x1a0b1513, 0x12150b1a, 0x070f2106, 0x0e0e3b01, 0x0d101110, 0x1b110d1b, 0x050b1c0c, 0x13150a16, 0x200e0f06, 0x19122021, 0x0c10130f, 0x25100a23,
+    0x05101c0c, 0x1316090d, 0x0f100804, 0x16040813, 0x13340615, 0x43100b0e, 0x39010209, 0x07021514, 0x01112816, 0x10040a18, 0x01051638, 0x1f042816,
+    0x041f0101, 0x05011628, 0x04103816, 0x1101180a, 0x02071628, 0x0c101415, 0x070b1549, 0x133a3a13, 0x49150b07, 0x08bc100c, 0x100d0f10, 0x080d2011,
+    0x0b1b1410, 0x0613350f, 0x0d26150a, 0x24151112, 0x0c101f05, 0x0b2d120f, 0x10140c02, 0x1427120b, 0x14160905, 0x4f030b08, 0x3f160416, 0x13110c24,
+    0x13112f0f, 0x3f630900, 0x00243408, 0x003e0031, 0x0058004b, 0x00720065, 0x009a0084, 0x18361300, 0x240cff51, 0x06171615, 0x05404207, 0x0607062a,
+    0x26231507, 0x11272627, 0x630c3863, 0x38630c52, 0x6327200c, 0x338c1852, 0x24114056, 0x06231727, 0x293c8207, 0x16170607, 0x2f36013f, 0x09822601,
+    0x5c4a3120, 0x111e260a, 0x0e330211, 0x08325e17, 0x0e146025, 0x4950010d, 0x502009fa, 0x2009e462, 0x20158970, 0x8a1594d0, 0x8001212b, 0x220f6b47,
+    0x83591c93, 0x1c592d3f, 0x0b0b0a0a, 0x380a0a38, 0x0a0a0b0b, 0x28096d63, 0x232319b8, 0x11324c29, 0x082e5e01, 0x0d015027, 0xa001140e, 0x206a89b0,
+    0x14656330, 0x9163ac8a, 0x202b8a0a, 0x0f4f72e0, 0x011d2d26, 0x1d010f0f, 0x85828083, 0x0b228b82, 0xcb41000b, 0x1894201a, 0x2208c754, 0x41060706,
+    0x362515c6, 0x21373637, 0x25a44101, 0x11652720, 0x0cbe410b, 0x4a0cf241, 0x2a41212c, 0x14c04105, 0x0e0d0127, 0xfe200114, 0x1fa641f0, 0x410a1f65,
+    0x012115e8, 0x0fc74170, 0x200f5c4a, 0x416b83c0, 0x142518bd, 0xfe010d0e, 0x14b741f0, 0x410aa141, 0x924a20e3, 0x0a002121, 0x22188b43, 0x4198008d,
+    0xc84a74c1, 0x63c54125, 0xc4415020, 0x12f84a0f, 0x4b76c741, 0x5745142e, 0x419d2019, 0x604b86c9, 0x74ce4118, 0x4119904b, 0xc64b76d5, 0x08002119,
+    0x2e08a743, 0x002d0020, 0x0047003a, 0x00610054, 0x4182006e, 0x112207d9, 0x28470706, 0x52614512, 0x17323729, 0x33151631, 0x82151716, 0x2311266f,
+    0x36373411, 0x097e4633, 0x450d1147, 0xb02d4850, 0x9009090e, 0x0f01010f, 0x09094090, 0x0571670e, 0x7447fe20, 0x079f5105, 0x4506f846, 0x6020463a,
+    0x0f276683, 0xfe010f80, 0x82e001c0, 0x8200207c, 0x055f4300, 0xc0014023, 0x0db74800, 0x9e009122, 0x250a5f43, 0x15070615, 0xb2481714, 0x52894110,
+    0x2a2c0a70, 0x0d0e1450, 0x1e011f01, 0x18590902, 0x4108cd76, 0xf346073a, 0x4dc02044, 0xc0201cab, 0x92287483, 0x12192f1f, 0x0e128025, 0x410fad48,
+    0x3e7047b4, 0x00083b21, 0x01c0ff00, 0x00c00180, 0x002b000a, 0x00450038, 0x00690052, 0x0094007d, 0xd2780100, 0x16372509, 0x17163117, 0x2a4d5243,
+    0x23150706, 0x37363335, 0x41232726, 0x8a1805b8, 0x06210869, 0x211b8207, 0x05832627, 0x36171627, 0x16173537, 0x21058237, 0x15832726, 0x54400121,
+    0x1020073a, 0x4307ad41, 0x58273562, 0x1602010f, 0x83021620, 0x2010274e, 0x0f01010f, 0x9f685830, 0x07c3230f, 0x18820a0b, 0x23010f22, 0x01210888,
+    0x842b8450, 0x83702004, 0x3b75432f, 0x0f01d028, 0x02021658, 0x7e831816, 0xd9841020, 0x20080942, 0x26de8720, 0x03094920, 0x83600b04, 0x342b2122,
+    0x00200a8a, 0x22060345, 0x41c00140, 0x5f2608b9, 0x83006c00, 0x354c8a00, 0x2307300d, 0x14150706, 0x16153015, 0x06171617, 0x5535012b, 0x3c4c0843,
+    0x262f4c1f, 0x1f361723, 0x5e5b8201, 0x272005d9, 0x262b5d83, 0x013f3437, 0x37361517, 0x4c273736, 0x2a210a25, 0x24c58246, 0x09371615, 0x0db3410a,
+    0x2015284c, 0x1f764a60, 0x0909a73b, 0x01010e78, 0x1e1d0b0c, 0x36090936, 0x0c0b1d1e, 0x09780f01, 0x02151632, 0x09124c5f, 0x01119f2c, 0x0101400f,
+    0x38382d01, 0x6843042c, 0x15324a0f, 0x694a8020, 0x04523e1f, 0x10063004, 0x26292921, 0x04041726, 0x29262617, 0x06102129, 0x1bbc3030, 0x25282a2a,
+    0x20008200, 0x08574306, 0x22079f46, 0x4677005e, 0x1d434a9b, 0x26072115, 0x1805164c, 0x210879c7, 0xc4430706, 0x3f904605, 0x09431320, 0x017d2411,
+    0x43010f0f, 0xbf590831, 0x41894606, 0xed42c920, 0x82092015, 0x5b0f206b, 0x0d230562, 0x1840140e, 0x20088696, 0x08874640, 0xc0018023, 0x0b7f7200,
+    0x82007024, 0x71419700, 0x6685460b, 0x18113d4f, 0x180a1847, 0x2008ac81, 0x05914131, 0x12111d24, 0x7f465a0a, 0x30012455, 0x18171601, 0x300caeac,
+    0x1b1a01e0, 0x1b276627, 0x0a0a011a, 0x0a0fda0f, 0x06ad410a, 0x1d10c026, 0x1013241c, 0x460f1b43, 0xb0204684, 0x0f975818, 0x8183cd20, 0x81828a83,
+    0x00228882, 0xcb491000, 0x007b3016, 0x00950088, 0x00b000a2, 0x00c800bd, 0x44de00d3, 0x8d460cd7, 0x4e095115, 0x454a1520, 0x37362505, 0x07333736,
+    0x8406c353, 0x8b152013, 0x5127200c, 0xf5720586, 0x26272505, 0x27263127, 0x15220b85, 0x1a8b3723, 0x08579018, 0x17373622, 0x092e4018, 0x17162722,
+    0x2105a443, 0xae5b3736, 0x2325450e, 0x242d4e51, 0x22171601, 0x20048410, 0x89068550, 0x25098310, 0x17221030, 0x048f0116, 0x108a1020, 0x63021621,
+    0x068506f3, 0xa8021622, 0x083b4018, 0x420e195c, 0x6a450f4e, 0x0a6b5115, 0x8a208151, 0x89d0209d, 0x89702092, 0x8910200a, 0x896020d3, 0x898020d8,
+    0x02f02315, 0xaf836816, 0x60200482, 0x20200783, 0x38220484, 0x08851602, 0x18021621, 0x270ac750, 0x13000030, 0x16373637, 0x2f07de54, 0x06171617,
+    0x1617010f, 0x012f0607, 0x26070607, 0x27270583, 0x27013f26, 0x83362726, 0x36373d05, 0x20c9011f, 0x06111106, 0x0a0e4722, 0x6a1a040b, 0x10010110,
+    0x0d083567, 0x21650f0c, 0x21271783, 0x0b0d0f65, 0x83673507, 0x70632917, 0x110e0c09, 0x634c01a3, 0x6a270d83, 0x0b0a041a, 0x8622470e, 0x0d0c2225,
+    0x8b258508, 0xa320273d, 0x090c0e11, 0x6f770070, 0xbf013106, 0x0a00c001, 0x3b003200, 0x4d004400, 0x64005900, 0x5442af82, 0x33072309, 0xba821732,
+    0x58171621, 0x5e180aba, 0xb2820b93, 0x36373625, 0x82153133, 0x823320d3, 0x072321c2, 0x10b55f18, 0x43180120, 0x2624071a, 0x36213137, 0x2008ce55,
+    0x07f941f8, 0x198c5e2c, 0x1c0a1415, 0x09090220, 0x5e18100e, 0x088307a1, 0x1c20022f, 0x1a141509, 0xd013040b, 0x8c0a0513, 0x0821423a, 0x09870020,
+    0x11a7fe26, 0x0e0e3011, 0x012d0484, 0x0f101190, 0x1110300f, 0x01300e0e, 0xd3421858, 0x38502808, 0x4f180e0f, 0x1888250f, 0x2e0db95e, 0x4f0f2588,
+    0x400f0e18, 0x35350a01, 0x18a8010a, 0x2110b15f, 0x46823101, 0x2f215083, 0x28508211, 0x0f2f1111, 0x3011100f, 0x06775f00, 0xc001002f, 0x11000800,
+    0x34001a00, 0x00005b00, 0x05496137, 0x82372321, 0x171626fc, 0x27260706, 0x2b048333, 0x17163736, 0x07061537, 0x21230706, 0x094b4a18, 0x16391583,
+    0x03171617, 0x36313732, 0x2f26013d, 0x26272601, 0x0722012b, 0x06010f06, 0x13521807, 0x2a0a840a, 0x0502bf31, 0x0d020574, 0x872f0e9d, 0x87e020a3,
+    0x01902b08, 0x401b1212, 0x1b4000ff, 0x49181212, 0x80200c60, 0x012eeb82, 0x0e06151b, 0x1274120f, 0x15060e0f, 0x565e011b, 0x82c02005, 0x06aa2506,
+    0x6a2a2a06, 0x87074141, 0x62802007, 0x49180956, 0xff210b3d, 0x2d318200, 0x40102168, 0x0b0b0a12, 0x1040120a, 0x47416821, 0x6d00200a, 0x12240b5f,
+    0x78004300, 0x13915818, 0x22133127, 0x3d263127, 0x95581801, 0x5833200b, 0x07220513, 0x41712706, 0x05486606, 0x1415232d, 0x31230607, 0x17161501,
+    0x6e353715, 0x062205ac, 0x154f010f, 0x16172607, 0x27262307, 0x232b8535, 0x33363734, 0x35222282, 0x27842726, 0x014f3132, 0x1c1a1312, 0x01011112,
+    0x1a1c1211, 0x19011213, 0x0d2ca982, 0x0c0c0d07, 0x0703030b, 0x0c341d34, 0x07250382, 0x0c0b0303, 0x1815820c, 0x2d09b758, 0x010f4801, 0x100f0110,
+    0x0a01010f, 0x05823035, 0x172c0f25, 0x823c1102, 0x21e98514, 0xc5490f01, 0x05a96307, 0x0a23d218, 0x8240fe21, 0x14b32146, 0x072b5f83, 0x510c0d0d,
+    0x2c01012c, 0x780d0c51, 0x14210586, 0x213f85b3, 0x07828080, 0x74f00127, 0x056d1309, 0x244a8338, 0x11040b55, 0x2570841b, 0x0102125c, 0x4382600f,
+    0x22829020, 0x09132023, 0x206b8564, 0x22008200, 0x72000004, 0x112606ff, 0x5f004c00, 0x59419200, 0x35032613, 0x26272223, 0x0c59413f, 0x210b5841,
+    0x74181617, 0xc3180e44, 0x76180840, 0x31211241, 0x0b326613, 0x27060723, 0x735a8326, 0x4b820908, 0x2010ae41, 0x0f73415f, 0x12072408, 0x02040508,
+    0x0d091c1f, 0x020b0b0c, 0x253a0801, 0x3b253a3a, 0x0b020107, 0x080d0c0b, 0x04031e1d, 0x41120805, 0xf682097b, 0x67480121, 0x38200f81, 0x0d221f85,
+    0x44820d07, 0x0703022d, 0x16150d34, 0x16190c19, 0x41340d15, 0x4e180fbe, 0x1b23093b, 0x83011212, 0x60fe2748, 0x08060750, 0x7c82255d, 0x82090721,
+    0x2c4f253f, 0x4f2c0202, 0x09207c82, 0x25258483, 0x0706085d, 0x05974150, 0x07865020, 0x4d180120, 0x438808a1, 0xd75bc020, 0x0ada4106, 0x820c1521,
+    0x4115208d, 0x602110dc, 0x2f008200, 0xff000002, 0x01e001c0, 0x002700c0, 0x25000032, 0x2409c166, 0x06273734, 0x9e441823, 0xecc81809, 0x07063208,
+    0x27010f06, 0x013f3617, 0x16072726, 0x7d013107, 0xa0561821, 0x92042308, 0xea481210, 0xb8162508, 0x21171602, 0x11300e84, 0xe1251b11, 0x25090792,
+    0x01b90506, 0x2b175204, 0x16261584, 0x0b0d2217, 0xa2490880, 0x22492409, 0x83011615, 0x151d2e0e, 0x86d00715, 0xd0020480, 0x0b4a0504, 0x0753420a,
+    0x82800121, 0x001d2aa7, 0x004f002f, 0x01000061, 0x082c6433, 0x180a5167, 0x1808515f, 0x27105164, 0x16170607, 0x3b363537, 0x14246082, 0x1d06010f,
+    0xc4820782, 0x5c373621, 0x0f220588, 0x64181701, 0x01211095, 0x0866671b, 0xfe68ff20, 0x0a262908, 0x20201818, 0x5b0b1818, 0x85058b41, 0x05573b05,
+    0x02091713, 0x010e3a06, 0x020c2c08, 0x21011616, 0x1101011f, 0x273a1b12, 0x6f6d010e, 0x8001260c, 0x1b121201, 0x08b244fe, 0x1b400125, 0x43011212,
+    0x831807fb, 0x673d0c8a, 0x14060915, 0x0e010502, 0x071a0409, 0x02160d0e, 0x13121602, 0x12111b24, 0x02230201, 0x05694299, 0x00360585, 0x00000600,
+    0x3f02c0ff, 0x2100c001, 0x38002c00, 0x4f004300, 0x59748500, 0x45172006, 0x332205b6, 0xa4181716, 0x36210cc1, 0x20018337, 0x05d35c03, 0x0f161724,
+    0x03822501, 0x31210d86, 0x20168905, 0x7d168a37, 0x36303024, 0x31171617, 0x17171edf, 0x1e22170c, 0x02061515, 0x2008a842, 0x290987bf, 0x291b1b01,
+    0x12140d82, 0x04843009, 0x87770121, 0x140d2309, 0x1789f9fe, 0x16899720, 0xef5e1c20, 0x10c02533, 0x0117190f, 0x6a07a566, 0x292a0bde, 0xfe011b1b,
+    0x0d09128c, 0x04845014, 0x08877120, 0x71091222, 0xbd201594, 0x20320c5f, 0x05a34100, 0x8002e030, 0x2b00a001, 0x46003000, 0x5c005100, 0x0f4f6e00,
+    0x3317230d, 0x25791732, 0x013b230d, 0x54182337, 0x21250833, 0x35211505, 0x4e541821, 0x06072115, 0x2008d468, 0x05525215, 0x1f211082, 0x10064301,
+    0x22091550, 0x424b0a85, 0x681805bc, 0x4b22076a, 0xfe53850a, 0xfe602708, 0xfe4001b0, 0x625202c0, 0x09784e08, 0x520a6e5a, 0x10200908, 0x0c866718,
+    0x0d01a026, 0x00ff140e, 0x54794d83, 0x1820200c, 0x23090cba, 0x40e0e040, 0x0fc25418, 0xdc522f83, 0x08076908, 0xea42d020, 0x0600350d, 0xe0ff0000,
+    0xa001c001, 0x28001500, 0x54003e00, 0x80006a00, 0x08536b18, 0x0e9c4d18, 0xc1490720, 0x010f2305, 0xb35f2706, 0x013f2205, 0x05e27317, 0x2507874e,
+    0x3734013d, 0x15963b36, 0x87180520, 0x901808c0, 0x3d220965, 0x41942701, 0xa782c020, 0x0a0e8f18, 0x121a362f, 0x03030620, 0x0d0c370c, 0x071f080c,
+    0x20098204, 0x052441d6, 0x8f182487, 0xff210e3b, 0x8e408d00, 0x07ec601e, 0x6e271687, 0x0c37180b, 0x89080c0c, 0x12202164, 0xa020408d, 0x20200e8d,
+    0x20207d8d, 0x00211d8d, 0x05876800, 0x8001802a, 0x28001700, 0x4a003a00, 0x24079b42, 0x06010f06, 0x39048307, 0x2726012f, 0x37363736, 0x06370321,
+    0x21171615, 0x27262726, 0x33161735, 0x9e7d3732, 0xe6501812, 0x012a080e, 0x0d0e14d0, 0x0e120101, 0x12272633, 0xda13133a, 0x0d010112, 0xa001140e,
+    0x01011baa, 0x1bd8fe27, 0xda011212, 0x11151511, 0x635b5a01, 0x0f285d0f, 0x38838020, 0x0b0e182c, 0x2e1d1e05, 0xa40c0c2b, 0x5a83180e, 0x14edfe2f,
+    0x2f410809, 0x1b121201, 0x0d0da3d0, 0x0fab5e03, 0x10fb5018, 0x0000032e, 0x4002c1ff, 0x3000c001, 0x50004400, 0x3624ed82, 0x03071617, 0x22058578,
+    0x5423010f, 0x23260723, 0x36372627, 0xe961011f, 0x33362307, 0x0c823f32, 0x011f1625, 0x7c16011b, 0x37210fd4, 0x4e138221, 0x313107ca, 0x130cf401,
+    0x03890712, 0x0d126103, 0x47560e0b, 0x053a460b, 0x4c500a3b, 0x130a070f, 0x3f050561, 0x100f0e08, 0x01010166, 0x14040d02, 0xaf0d0414, 0x05a3412c,
+    0x2009c97c, 0x08304cff, 0x10b5012f, 0xfe140b08, 0x370403cf, 0x0e100f08, 0x07334657, 0x110d333d, 0x061f0411, 0x0d116806, 0x01580c0c, 0x02158e01,
+    0x018e1502, 0x014cfe19, 0x180d0909, 0x2c0a074c, 0x301502bf, 0x17010117, 0x00021530, 0x082f4604, 0x3e001726, 0x79004300, 0x26073f67, 0x16171633,
+    0x7921010f, 0x3626056f, 0x013b3637, 0x52432105, 0x010f2405, 0x79062322, 0x26220550, 0x08862223, 0x26012f2f, 0x3734013d, 0x17233336, 0x15213521,
+    0x34e86405, 0x82600121, 0x104b2da5, 0x150a0606, 0x0a14affe, 0x4a100606, 0x8124ba83, 0x8101fffe, 0x22081982, 0x0101330c, 0x1b180103, 0x11181b10,
+    0x17111414, 0x181b111b, 0x0c330303, 0x010e0909, 0xfe410120, 0x460101bf, 0x3f833410, 0x0d0d0d24, 0x04821818, 0x090e0124, 0x10828009, 0x11147c35,
+    0x11010248, 0x0c100403, 0x0304100c, 0x48010211, 0x827c1411, 0x60a0231c, 0xf645a060, 0x00052532, 0x02c0ff00, 0x09335418, 0x47003c22, 0x18070d4b,
+    0x692d6153, 0x002013b9, 0x1b395418, 0x105c5318, 0x1812a95e, 0x5e2c5553, 0x4742145f, 0x20df8905, 0x54dda33e, 0x2720111e, 0x23055b63, 0x27263736,
+    0x5518d49c, 0x5025110e, 0x01010f80, 0x1804840f, 0x182d0a55, 0x1808924d, 0x24480355, 0x07062726, 0x6ec88515, 0x864705a4, 0x9c352005, 0x10a641d1,
+    0x0f01a025, 0x8330010f, 0x8a3020d4, 0x2ca94109, 0x020e4127, 0x02300e02, 0x2147890e, 0xff4f020e, 0x09ab4108, 0x5f003c22, 0x1823ad41, 0x201b464f,
+    0x4e1c8216, 0x524b05eb, 0x35372508, 0x34373637, 0x21061650, 0xfcad011d, 0x4808a342, 0x09340505, 0x07010d28, 0x0f010920, 0x1718010f, 0x140d0d01,
+    0x0c0c1228, 0x422de641, 0x882e08b5, 0x0f01010f, 0x01010906, 0x1104080d, 0x52820905, 0x050f012c, 0x141a0f0c, 0x0c0c0d0d, 0x48180612, 0x1c250c3b,
+    0x37002000, 0x10cb4200, 0x07060723, 0xde571806, 0x1ff7590e, 0x07da5718, 0x02215d28, 0x37141401, 0x5718110d, 0xba5909da, 0x08ef411c, 0x0f252f32,
+    0x3a3a2d25, 0x1201082f, 0x80011b12, 0x62808040, 0x4c1f7859, 0x8034050b, 0x1900c001, 0x65003100, 0x89007700, 0x00009b00, 0x36373601, 0xe14dbd82,
+    0x840f8209, 0x17312611, 0x26072726, 0x06ee4627, 0x18161521, 0x21086262, 0x5e183405, 0x152c07cd, 0x23060714, 0x22352115, 0x34352627, 0x2205897f,
+    0x18011d16, 0x71080499, 0x18820576, 0x18353321, 0x2011c971, 0x10574d37, 0x32082391, 0x0f0c5d01, 0x17250a0a, 0x2d020117, 0x2d45442d, 0x1f01022c,
+    0x0b09331f, 0x03291a1d, 0x0e012404, 0x030f0f0e, 0x010b0c16, 0x1c221617, 0x05051716, 0x779afe0d, 0x012109fb, 0x05e446c0, 0x06822020, 0xfd200985,
+    0x01201186, 0x0cfc4018, 0x0c479218, 0x8507f34a, 0x01340830, 0x080e0f83, 0x2d2d2408, 0x2e2e4420, 0x2e2e0202, 0x32312944, 0x1a08082e, 0x0606731f,
+    0x1212012a, 0x1b041313, 0x25111313, 0x110f1514, 0x6f1a1b1a, 0x0109090d, 0x21065e47, 0x8a824141, 0x61200f87, 0x210d5449, 0x7218c161, 0xea4d1859,
+    0x6c00200c, 0xa02b0763, 0x45003300, 0x16010000, 0x18163117, 0x490ad863, 0x2729057e, 0x26013f26, 0x07272627, 0x05745506, 0x48059548, 0x02200697,
+    0x08106641, 0x29610134, 0x1d1b2223, 0x080b1515, 0x15150b08, 0x23221b1d, 0x13114e29, 0x1d090412, 0x5d111718, 0x0a0f1215, 0x0f0a2e2e, 0x115d1512,
+    0x091d1817, 0x11131204, 0xc64b3f4e, 0x035f3e0c, 0x17140f0f, 0x10131818, 0x18181310, 0x0f0f1417, 0x0b0c3b03, 0x0e31150c, 0x37131211, 0x213a820a,
+    0x46835050, 0x12133726, 0x15310e11, 0x3b211a82, 0x0dac4b7f, 0xd7580420, 0x001c2208, 0x23d98221, 0x37000050, 0x20055650, 0x064b4211, 0x2908247f,
+    0x06071523, 0x35330315, 0x46181523, 0x1523092b, 0x18151617, 0x23088bb4, 0x35013f36, 0x27373482, 0x3b363736, 0x14150701, 0x2733010f, 0x23013d26,
+    0x291010a0, 0x85011b1b, 0x06f941b9, 0x400f3126, 0xa0014040, 0x762e1385, 0x1413010a, 0x1dcafe1d, 0x01011414, 0xab41750a, 0x80c12d07, 0x31ab3005,
+    0x05054005, 0x291b1b01, 0x0a859b18, 0xf6273582, 0x011d194f, 0x6f60601b, 0x97270686, 0x1d1411bf, 0x83011314, 0x11142347, 0xe48597bf, 0x09a0402a,
+    0x084f4f08, 0x0000a009, 0x2e054751, 0x00c00180, 0x00200014, 0x17320100, 0x18030716, 0x0808a2cb, 0x3726033c, 0x07213336, 0x17363716, 0x23023f16,
+    0x6001011f, 0x010a090e, 0x1616031d, 0x1621a621, 0x011d0316, 0x010e090a, 0x1f1fff40, 0x1f1f2121, 0x07fc0718, 0x0ac00118, 0x6cfe0e0a, 0xb3821520,
+    0x20151432, 0x0a0e9401, 0x0e0ea90a, 0x0e0e1010, 0x0c5d5d0c, 0x2007bf54, 0x24738501, 0x00350029, 0x0d844b00, 0x2105ec43, 0x8a933731, 0x8a8a0120,
+    0x54010021, 0x02290616, 0x0c0f1211, 0x11120f0c, 0x219d9602, 0x00842000, 0xfc120c38, 0x19fc0d11, 0x01011111, 0x14191111, 0x0c121c1b, 0x1b1c120c,
+    0xb091c414, 0x0fd0fe22, 0x25080084, 0x06eaea06, 0x09000600, 0xf601caff, 0x2c00b601, 0x82005600, 0xcc00ae00, 0x0000ea00, 0x31071413, 0x07061514,
+    0x5f4a0706, 0x27062505, 0x37262726, 0x7605bb77, 0x172006e7, 0x21075a5f, 0xed763731, 0x07142105, 0x09a64d18, 0x22272623, 0x22318223, 0x83353427,
+    0x82262005, 0x23f98339, 0x33320131, 0x17242382, 0x15161514, 0x0b8a8218, 0x52070621, 0x638505d3, 0x20062341, 0x05654205, 0x82272621, 0x217d8685,
+    0x4f823736, 0x37363526, 0x33323736, 0x20072845, 0x21a38216, 0x79842531, 0x35202583, 0x20057943, 0x05f14b3b, 0x012f0624, 0x9f821506, 0x66511720,
+    0x05bf5405, 0x35272623, 0x05a54334, 0x33086f83, 0x0101a031, 0x021c1211, 0x04070b03, 0x0d0d0c0b, 0x09040606, 0x01010612, 0x0f1b1212, 0x0d201d0c,
+    0x03050b0b, 0x160d0606, 0x0d0ce613, 0x0111121c, 0x040a1105, 0x0d2d0f82, 0x06040b0c, 0x1b03030c, 0x13011212, 0x2a358216, 0x0b0b0503, 0xfe1d200d,
+    0x830203d4, 0x21148c26, 0x26830f0c, 0x12060123, 0x243a8709, 0x80010b07, 0x20778305, 0x25638c0d, 0x13120101, 0x8a8a041a, 0x110a2308, 0x2102e7fe,
+    0x140c0812, 0x0111101c, 0x03060b1c, 0x0a3c0703, 0x06060101, 0x520f0f05, 0x111b150c, 0x16820110, 0x03030525, 0x82093d06, 0x0f062d15, 0x2102010e,
+    0x66010813, 0x01020102, 0x0c219c8f, 0x8c11830e, 0x06342186, 0x0e20e983, 0xfb82858d, 0x0f410320, 0xc6fe210c, 0x51822583, 0x070b0226, 0x0d0b0c04,
+    0x0423ef82, 0x8205110a, 0x1b1221ae, 0x26203b8d, 0x26416385, 0x0c0b2208, 0x82eb8204, 0x338b8f8c, 0x0c122785, 0x0f081314, 0x2c211a1a, 0x06060b1f,
+    0x3d090106, 0x0524dd82, 0x5b18110f, 0x2d231685, 0x84050c1e, 0x02072616, 0x11100403, 0x20308318, 0x27651800, 0x00242509, 0x01000049, 0x21078542,
+    0xe449012f, 0x41162005, 0x222d05e3, 0x2607012f, 0x37363527, 0x31173233, 0x073e4203, 0x49011f21, 0x262205fd, 0x62592627, 0x332f0806, 0x06151716,
+    0x27222107, 0x67490131, 0x0a02030d, 0x0e10100a, 0x020e6a57, 0x1a3f0e02, 0x090a0208, 0x20297010, 0x020d082f, 0x23fb0d02, 0x8787b21c, 0x79772822,
+    0x0f01010f, 0x82071b4e, 0x800f2522, 0x172f202a, 0xfe2a0f83, 0x011b23e5, 0x100a448c, 0x28830e10, 0x0e023935, 0x1a02010f, 0x190b0a0f, 0x10010127,
+    0x14010f5f, 0x876468fe, 0x0158221d, 0x281d820f, 0x0b0b0f19, 0x0f01261a, 0x201c8260, 0x20008200, 0x089b4508, 0x23001122, 0x5b28e182, 0x99008700,
+    0xbd00ab00, 0x4318eb82, 0x07201031, 0x0f42d018, 0x67153521, 0x142108f4, 0x05f34215, 0x09d37418, 0x013d262a, 0x34333736, 0x11333637, 0x10a47418,
+    0x37363722, 0x2105334e, 0x2082013b, 0x3a823720, 0x18331521, 0x860c1c9e, 0x34352546, 0x06373127, 0x0effea18, 0x33822f20, 0x0d094b18, 0x90173521,
+    0x18012099, 0x200c945a, 0x0b914690, 0x09090e39, 0x2b021608, 0x02011a1a, 0x44442d2d, 0x01022d2d, 0x012c1a1a, 0x82081602, 0xf7741825, 0x1ab2260f,
+    0x07070135, 0x831a830a, 0x070a2237, 0x26388707, 0x14252530, 0x8f8e0e0e, 0x206a8c30, 0x18778b50, 0x200db7c3, 0x0b654730, 0x0228ac83, 0x02031016,
+    0x32272713, 0x99839183, 0x27273228, 0x10030213, 0x29820216, 0x18c0fe21, 0x250f3b75, 0x021733a9, 0x8f821004, 0x8207ca46, 0x041021a5, 0x01284088,
+    0x22271817, 0x17222727, 0xe020378f, 0x0c8b778c, 0x00820020, 0x20000235, 0x6002c0ff, 0x4a00c001, 0x00006200, 0x37161713, 0x45012f36, 0x1f270650,
+    0x15171601, 0x18343533, 0x250a4184, 0x3f161706, 0x4d183501, 0x1426088f, 0x1633010f, 0xc8180617, 0xe3410755, 0x32332605, 0x07151617, 0x18401813,
+    0x76218309, 0x2337052f, 0x465f2335, 0x0a0f0f0a, 0x0101081c, 0x0d0c0b0a, 0x01172f09, 0x182f1941, 0x25078788, 0x0e0f0a1b, 0x4441450b, 0x560e2805,
+    0x02021604, 0x8380fe16, 0x56042105, 0x0e20b982, 0x01230382, 0x82070a20, 0x010a2200, 0x31168381, 0x80418020, 0x5c2f0120, 0x100b070c, 0x0d0c0a24,
+    0x56820908, 0x261d3436, 0x1d265e5e, 0x01010a34, 0x0c0d0809, 0x0b10240a, 0x715c0c07, 0xb623fa85, 0x5c631116, 0x63230790, 0x85b61611, 0xfe712215,
+    0x6c5e18b1, 0x82202009, 0x4c002000, 0x802c081b, 0x1100c001, 0x59003000, 0x00008300, 0x25128942, 0x2f060716, 0x9e492301, 0x20058505, 0x05a77e36,
+    0x17231783, 0x41161705, 0x54540f52, 0x07465107, 0x21823720, 0x25011d27, 0x010f1415, 0x06097b06, 0x180e7141, 0x260b3e88, 0x18013115, 0x18110b0c,
+    0x0808bd4c, 0x1701603a, 0x08040515, 0x16160504, 0x13130b01, 0x29100d0f, 0x15241410, 0x0d0f2b0e, 0x0b14120f, 0x083cd8fe, 0x100a0b0b, 0x0307150a,
+    0x0c0b0b02, 0x1830080b, 0x600e0909, 0x0e790a0f, 0x023b4685, 0x09790f30, 0x090e600f, 0x082e1909, 0x0b0b0c0c, 0x16070302, 0x0b0a1009, 0x853c080b,
+    0x98012121, 0x10826d88, 0x0516d534, 0x23231701, 0x16050117, 0x100e1059, 0x0d231012, 0x0682230d, 0x59100e37, 0x010a5006, 0x14100701, 0x0c0c0c23,
+    0x02010707, 0x281e3a0a, 0x33588274, 0x1612960d, 0x0b0c10ce, 0x0c0b0101, 0xcd9b9c10, 0x0d961216, 0x74348482, 0x0a3a1e28, 0x07070102, 0x230c0c0c,
+    0x01071014, 0x9b500a01, 0xb1186a85, 0x11240a47, 0x64003a00, 0x20134d5c, 0x515a4107, 0x2001d024, 0x8118301f, 0x1f230825, 0x41800120, 0x8118423d,
+    0x50820976, 0x93206083, 0x41492641, 0x40310627, 0x2000a001, 0x4a003200, 0x16250000, 0x23060717, 0x0ac34322, 0x28061c49, 0x23260716, 0x07060706,
+    0x10207c33, 0x06073726, 0x013b1617, 0x0806e474, 0x2b26272b, 0x27363701, 0x01310726, 0x061c0100, 0x090d0d0a, 0x03022ac2, 0x34352a2f, 0x28131328,
+    0x202c3434, 0x220a0b0b, 0x32314b29, 0x10c85002, 0x0760b12b, 0x24080303, 0x0706041e, 0x210a8508, 0x0a82031f, 0x2b36503d, 0xc70a0a05, 0x2b3b3c2e,
+    0x27050423, 0x05271515, 0x271d2304, 0x02112727, 0x554b3132, 0x52290fb4, 0x08080648, 0x05070836, 0x22088504, 0x8e040408, 0xa24220e7, 0x182120e7,
+    0x7e109145, 0xdfa10f2e, 0x56117a52, 0xd8ad0e96, 0x20108d56, 0x08875200, 0x2205bf41, 0xa246003b, 0x11c141d9, 0xa1132854, 0x10bd41dd, 0x5d619020,
+    0x02112807, 0x01010f0e, 0xad020e0f, 0x087751df, 0x0b916018, 0x09a75d18, 0x3d20e385, 0xbb41e1a2, 0x092c5412, 0xb641d8a1, 0x0a315411, 0x0941d2ad,
+    0x083b6208, 0x20076b43, 0x41c7a24b, 0x372011a9, 0xa1173054, 0x10ae41d5, 0xad143554, 0x163554de, 0xb60fb341, 0xe39718eb, 0x73ebb217, 0xefad18a3,
+    0x081a5973, 0x05000030, 0xc2ff2200, 0xbe011e02, 0x17000b00, 0x2e002200, 0x00005700, 0x17163501, 0x26231716, 0x31272627, 0x37363511, 0x06333736,
+    0x31070607, 0x17833325, 0x17831520, 0x83151321, 0x83232011, 0x0731221b, 0x0a1c4933, 0x63060721, 0x266405fa, 0x27222105, 0x37091e49, 0x4001011d,
+    0x0c3d3c59, 0x2b2a0b41, 0x2a2b3d3d, 0x3d0c410b, 0xe2fe593c, 0x18830f84, 0x1488de20, 0x48181020, 0x0c8c0cbd, 0x847d0121, 0x212a8336, 0x3a9245fe,
+    0x891e0121, 0x06415c14, 0x20062a51, 0x180e8e40, 0x240ae385, 0x002b0026, 0xbd571842, 0x012b230c, 0xed821715, 0x23070624, 0x215b2f22, 0x83352005,
+    0x056160eb, 0x23073125, 0x70351707, 0x976d16b5, 0x06954a19, 0x5602703d, 0x16020216, 0x81060a60, 0x1918267f, 0x20200101, 0x62433636, 0xa0094342,
+    0x704f212e, 0x866d097e, 0x147d6d08, 0x304ae020, 0x01af3b05, 0x02161602, 0x19017907, 0x43382618, 0x20203636, 0x3f3f0201, 0x49384060, 0x5d6db981,
+    0x0004272f, 0x02c0ff20, 0x9b530161, 0x00572605, 0x13000068, 0x20f68426, 0x065a6116, 0x14071429, 0x16171607, 0x55070615, 0x3527053b, 0x23262734,
+    0x18270722, 0x2408b257, 0x01270607, 0x22534d25, 0x07160326, 0x21070631, 0x2907f05f, 0x01a10117, 0x140e0d01, 0x32630b23, 0x01022b05, 0x020e0e17,
+    0x100c5223, 0x00820c10, 0x222e0582, 0x1b23231b, 0x1e181a1a, 0xc9fe1a1f, 0x724c5f01, 0x0c785f0b, 0x0913182b, 0xc3fe1b0a, 0x01161722, 0x2ba88202,
+    0x64016401, 0x0e140606, 0x2102010d, 0x2a05be63, 0x04030708, 0x1a141309, 0x8551182c, 0x0d0d2459, 0x831a1a22, 0x0317265d, 0x36011102, 0x0b2d4c1c,
+    0x0c3ea618, 0x15e4fe31, 0x01021716, 0x01221716, 0x090a1b3d, 0x189bfe12, 0x3008c353, 0x00a00140, 0x00230012, 0x00480036, 0x1300005a, 0xb8491826,
+    0x05df4a08, 0x13012f22, 0x3724f08f, 0x34013d26, 0x1f252682, 0x011d1601, 0x22268214, 0x4101012f, 0xf24d1038, 0x04fc2911, 0x09051b04, 0x1b050936,
+    0xac200888, 0x2026f28f, 0x07300808, 0x05823009, 0x30070924, 0x2b41f8fe, 0x229e180b, 0x5801210c, 0x02882282, 0x8facfe21, 0x8e4320de, 0x21718268,
+    0x1e413901, 0x0658430b, 0x3f451285, 0x01802c07, 0x002e00c0, 0x00500040, 0x18232500, 0x23074e4f, 0x2322012b, 0x19008018, 0x2005a449, 0x122e5b23,
+    0x210f5b5f, 0x6c824040, 0x16038018, 0x0d0dd427, 0x07313146, 0x11094701, 0x220ec048, 0x18090960, 0x26150a80, 0x2c0202bb, 0x4910452d, 0xc2480f9b,
+    0x5004200f, 0xe783084f, 0x54004922, 0x6a5ae9b0, 0x05525b1b, 0x06272624, 0xeda30107, 0x48102147, 0xefaf11d0, 0x4c16d248, 0xf7830a9f, 0xf5c25920,
+    0xb419137b, 0x183047fa, 0x472f0141, 0xbe181932, 0x312809eb, 0x63004b00, 0x15250000, 0x7527e442, 0x15220533, 0x9f5a3731, 0x20012230, 0x19f64220,
+    0x0f138928, 0x0a102236, 0x595add0b, 0x1b232827, 0x05051716, 0x4302620d, 0x792d1706, 0x36310d01, 0x1b1b1c19, 0x060f1080, 0x122c5a07, 0x06722024,
+    0x2c5a2b06, 0x1010240c, 0x511a1b1b, 0x002a055b, 0x8002c0ff, 0x1400c001, 0x6b613b00, 0x0a307b0a, 0x31033123, 0x05234833, 0x64093d5d, 0x232b09a3,
+    0x3f262726, 0x011f3601, 0x82e00111, 0x0f7026f4, 0x700f0101, 0x22aa8240, 0x63410140, 0x0d820dd7, 0x0914212a, 0x15e01007, 0xc0018b15, 0x210eb37a,
+    0x108200fe, 0x8606be45, 0x01c02a06, 0xc00e1514, 0xfe771010, 0x07ab449f, 0xc0013f28, 0x58002200, 0xa9828e00, 0x18071621, 0x180728e5, 0x2409a463,
+    0x23262722, 0x20918835, 0x3d651807, 0x18172034, 0x852d6d65, 0x01312e63, 0x080611e3, 0x03011116, 0x1e1e1d02, 0xb563181d, 0x01012e07, 0x16100201,
+    0xb0110608, 0xd5b01313, 0x55651812, 0x18bf2031, 0x862c8365, 0x0e3a2e60, 0x49011516, 0x01140102, 0x0c0c1401, 0x2b088313, 0x15014902, 0x0c800e16,
+    0x0cb0800c, 0x306b6518, 0x65187020, 0x5e852b98, 0x5f620020, 0x015f2d05, 0x001100c0, 0x00490027, 0x00b5007f, 0x125f8a18, 0x15bc4418, 0xde703f20,
+    0x23072a06, 0x26272617, 0x06072623, 0x07e34107, 0x36373626, 0x31273435, 0x35776518, 0x67180720, 0x3623314c, 0x45013117, 0x441810b2, 0xa02414e8,
+    0xb0131350, 0x25050442, 0x15110304, 0x08421315, 0x120f2607, 0x12121320, 0x320a6473, 0x67184d20, 0x12233085, 0x47300113, 0x45180f0e, 0x232e120b,
+    0x800c0c3a, 0x0115160e, 0x0f020254, 0x28420c01, 0x060a2905, 0x2b252418, 0xf0fe252b, 0x20314f64, 0xbf671856, 0x0c0c212f, 0x290b7f48, 0x005a003b,
+    0x05000067, 0x68441714, 0x1a8b4815, 0x06070624, 0x02821507, 0x4b181320, 0x01232adf, 0x18010980, 0x2620a288, 0x141422b5, 0x18021e01, 0x221c0977,
+    0x180e1220, 0x291ead88, 0x1c1d0c9f, 0x25121925, 0x4b180180, 0xcf5522d0, 0x0033290c, 0x004c003a, 0x2500005c, 0xea18d984, 0x2628120d, 0x31070623,
+    0x27263523, 0x15200782, 0x16230383, 0x82153317, 0x37322903, 0x14333731, 0x35310615, 0x2622a149, 0x13140341, 0x18f5fe20, 0x3a0ef088, 0x410d0dd4,
+    0x1001382f, 0x38020e30, 0x0e02020e, 0x300e0238, 0x01070406, 0x69380101, 0x42291e04, 0x16222228, 0x1b121201, 0xb28918a0, 0x02bb2409, 0x18382701,
+    0x210c9888, 0x4a824602, 0x42380321, 0xb9490faa, 0x4400200f, 0x80230647, 0x4100c001, 0x5522050f, 0x11416000, 0x26c9493c, 0x202e1541, 0x0f144118,
+    0x4111d449, 0xe1493c17, 0x09d74a15, 0x20051b41, 0x4e194165, 0x4119ed49, 0xf8493f1e, 0x3c254118, 0x4419054a, 0x14240b6b, 0x44002700, 0x6419e948,
+    0x43480532, 0x03112108, 0x230a5843, 0x33353736, 0x26210382, 0x07744327, 0x2110f248, 0xe548bffe, 0x30c1210b, 0x2d06f066, 0x31010f20, 0x0f01010f,
+    0x200f0131, 0xfc48020e, 0x0aee4815, 0x82000121, 0x09246727, 0x30203d82, 0x30203d83, 0x2a0adf53, 0x006000c0, 0x00b3007d, 0x18321300, 0x8209cfa2,
+    0x070622aa, 0x240f8316, 0x30313233, 0x05b74a31, 0x291af96a, 0x07262322, 0x23300726, 0x7b602722, 0x37362105, 0x36264c8f, 0x36373137, 0x6d18011f,
+    0x22281015, 0x35232635, 0x13013f34, 0x39342c49, 0x0c1d23b8, 0x06060505, 0x110c0c0c, 0x191a2515, 0x11110101, 0x0112101b, 0x2249232b, 0x0101231e,
+    0x00820102, 0x14162408, 0x01252543, 0x583b3c02, 0x060d2024, 0x0b050406, 0x19170d0c, 0x1222212b, 0x13f53d2a, 0x010c6013, 0x18080801, 0x2509436d,
+    0x0d020201, 0x49492060, 0x0e602133, 0x0d30a382, 0x0605040c, 0x19190108, 0x17161e25, 0x18020409, 0x821e4149, 0x12062aa0, 0x56463535, 0x0b023838,
+    0x06296004, 0x13010830, 0x01282114, 0x480c0c32, 0x0490100a, 0x6d180404, 0x01270966, 0x0a0f7a02, 0x4988fe48, 0xbc183265, 0x13240bdf, 0x2e002900,
+    0x7a0b6d70, 0x3520085d, 0x200ae47e, 0x08fb6311, 0x23051129, 0x20353315, 0x500e0909, 0x06830616, 0x12012024, 0x03741b12, 0x22088508, 0x5ec0c000,
+    0x80200d25, 0x20082b73, 0x082b73e0, 0xa0402024, 0x5f5100a0, 0x40012407, 0x8300c001, 0x4d3a208f, 0x13200573, 0x9f08ac70, 0x059e4593, 0x07062330,
+    0x16232726, 0x33171617, 0x31373635, 0x108a3736, 0x10901520, 0x36171625, 0xa1333537, 0x25cd84c8, 0x12121e30, 0xe583301e, 0xbb834020, 0x10250e98,
+    0x010f0f01, 0x20f7a210, 0x234b83a0, 0x01151501, 0x60204e83, 0xc0200c8b, 0x90720c8b, 0x00002c05, 0xff200001, 0x012002c0, 0x823c00c0, 0x1d16230c,
+    0xe1821701, 0x647e1620, 0x15232206, 0x23118217, 0x35230706, 0x26058157, 0x26352726, 0x1835013f, 0x200bbf7e, 0x64671837, 0x5b012208, 0x019b1805,
+    0x3b902508, 0x600f0105, 0x6025b283, 0x0701010f, 0x3218893a, 0x0a052c05, 0x012c050a, 0x4d0d0c4f, 0x02161354, 0x83701602, 0x21082804, 0x10080532,
+    0x8240010f, 0x400f292e, 0x08100f01, 0x08213205, 0x13281e88, 0x0c0d4d54, 0x670a0a67, 0x21054350, 0xaf828001, 0x28001222, 0x1323b383, 0x82333736,
+    0x056b55af, 0x82272621, 0x0b5e420d, 0x07061522, 0x2b062654, 0x17140535, 0x32331631, 0x013d3637, 0x28057554, 0x60011d06, 0x16501602, 0x20678402,
+    0x2d868490, 0x25240160, 0x25368036, 0x12010124, 0x836a1b12, 0x0b015307, 0x83a80121, 0x5f182028, 0x1821070e, 0x822c84e8, 0x09a54235, 0x240d364e,
+    0x00080060, 0x06634100, 0x3300112e, 0x57004500, 0x7c006400, 0x8f008400, 0x2013a15d, 0x10825b17, 0xe1843320, 0x24058e6a, 0x23272623, 0x0feb6127,
+    0x18052721, 0x260c6f80, 0x17163736, 0x18333507, 0x20089381, 0x0524692f, 0x06070624, 0x274f2307, 0x20548209, 0x204c8217, 0x205d8215, 0xac801817,
+    0x79502009, 0xcc240fa8, 0x3426270b, 0x34071649, 0x0b272634, 0x68160e48, 0x010d0e14, 0x140e0d01, 0x480e1668, 0x0fdb618c, 0x60180127, 0x16020216,
+    0x260483f0, 0x16160260, 0x83e08802, 0x8380202b, 0xa95f1834, 0x09103208, 0x0e400e09, 0x0f010909, 0x0f011080, 0x010f1010, 0x202f8308, 0x210484b0,
+    0xc6433001, 0x24078707, 0x1f1f3120, 0x07d34801, 0x1f1f0123, 0x4d441831, 0x6180200b, 0xd8210fbd, 0x079d4108, 0xc8215484, 0x20768870, 0x83898390,
+    0x05095088, 0x010f5028, 0x20010f30, 0xcf480f01, 0x06df4908, 0xc001402f, 0x18000a00, 0x35002900, 0x00004000, 0x0a2b7f01, 0x27083a44, 0x3521011d,
+    0x21373607, 0x26068c7b, 0x26272621, 0x7f03013f, 0x25200a07, 0x2009077f, 0x0a961801, 0x44982008, 0xff3a06df, 0x1d0e4d00, 0x0e1d4401, 0x0809071c,
+    0x1368fe13, 0x1c070908, 0x68140e4f, 0x04840b11, 0x14160226, 0x68110b0e, 0x01260484, 0x02021618, 0x04849016, 0xb9859820, 0x5b202037, 0x1a01011a,
+    0x0e0f1037, 0x0f0e0101, 0x11013710, 0x0e480b11, 0x25048414, 0x14110b06, 0x0484480e, 0x0002002f, 0x02c0ff00, 0x00c00100, 0x0041001e, 0x05826700,
+    0x77152321, 0x272e0c3e, 0x3b363736, 0x37363501, 0x15330533, 0x03893533, 0x30333025, 0x4316011f, 0x3f2d0641, 0x30313601, 0x60013531, 0x0f01010f,
+    0x06a34550, 0x0d5ffe23, 0x05e06b09, 0x0e02c029, 0x40dffe61, 0x82314028, 0x01013403, 0x08051230, 0x163ffe17, 0x30120508, 0x01c00101, 0x6a0f400f,
+    0x70240d38, 0xc0e0010f, 0xc42d0084, 0x160e2001, 0x16010116, 0x01200e16, 0x0c734cc4, 0x39001b2f, 0x42003e00, 0x14130000, 0x3b163117, 0x6a591801,
+    0x09ea7708, 0x45153321, 0x212205a3, 0x06441716, 0x0af24305, 0x3521d182, 0x31d18217, 0x35233723, 0x0909c017, 0x2220600e, 0x21011617, 0xc142730c,
+    0x30902107, 0x20096877, 0x7ad88220, 0x0f340972, 0xe0e04020, 0x01606010, 0x09090e60, 0x17160140, 0x1e027022, 0x40202c84, 0x60203c83, 0x08f1b118,
+    0x0f019023, 0x07a74210, 0x010f1029, 0x80801090, 0x826060c0, 0x03003fc6, 0xe0ff0000, 0xa0018001, 0x28001300, 0x00003d00, 0x31070617, 0x27262706,
+    0x36133726, 0xaf823637, 0x03071624, 0xd9821613, 0x69030721, 0x18840750, 0x32333122, 0x15201482, 0x0982aa18, 0x36373425, 0x473e3133, 0x052205bb,
+    0x08888004, 0x070ec729, 0x03400107, 0x880d0b0a, 0x0c6d7b08, 0x060d0a24, 0x2d830405, 0x87800121, 0x80fe2309, 0x3083aa01, 0x8380fe21, 0x20098332,
+    0x22098401, 0x820e0909, 0x82092012, 0x820e2000, 0x09092110, 0x2a088741, 0x00c00100, 0x0031001f, 0x825d0050, 0x272622c1, 0x97d91831, 0x07cc6608,
+    0x07061522, 0x06250282, 0x31272223, 0x11c56637, 0x3b2a074f, 0x27281ba8, 0x02021e1e, 0x49523636, 0x290d3434, 0x1e011a1a, 0x0a111702, 0x180a0e0e,
+    0x200f1244, 0x324d18d0, 0x21333b1b, 0x3b3b3738, 0x3636522d, 0x2d2c0202, 0x1e1e0747, 0x2512192b, 0x0c151f5f, 0xe144f30c, 0x377d180f, 0x00053325,
+    0x02e0ff00, 0x00a00140, 0x00490045, 0x0057004e, 0x7d6e0061, 0x16312d06, 0x31301517, 0x07063130, 0x17230706, 0x640bda64, 0x272c06e1, 0x26270607,
+    0x17361337, 0x37011f16, 0x33350584, 0x27261732, 0x26232726, 0x33373627, 0x07273317, 0x37330727, 0x08916027, 0x07332522, 0x50081983, 0x01313736,
+    0x38384548, 0x01012121, 0x0c221617, 0x14120919, 0x2f51270d, 0x0b11140e, 0x0e344b1e, 0x280c1113, 0x130f4f2b, 0x09f00c10, 0x16060d0d, 0x0d0e0829,
+    0x0f402a06, 0x35360e0e, 0x0216104c, 0x04101602, 0x4a1f1130, 0x11023021, 0x01010fee, 0x0803830f, 0x2669fe37, 0x0101104e, 0x01181010, 0x212101a0,
+    0x28453838, 0x01161722, 0x090d142c, 0x11464412, 0x2a140e0b, 0x0e0c1146, 0x65113713, 0x130f0c10, 0x010a3001, 0x37320d02, 0x2405820b, 0x2e480561,
+    0x2355822d, 0x29d00216, 0x02220082, 0x63188927, 0x6126088a, 0x10181810, 0xdf6d0110, 0x00022d06, 0x1a00c001, 0x00002f00, 0x17070625, 0x2205a77b,
+    0x18012f22, 0x240dca9d, 0x06072627, 0x06216a1f, 0x21064663, 0x9382012f, 0x09802832, 0x0d0d0a09, 0x46357e0a, 0x023b3b58, 0x583b3b02, 0xb0260783,
+    0x0e0e1110, 0xd583761f, 0x0e1f762d, 0x4810110e, 0xf0480f0f, 0x837e3546, 0x0909242b, 0x18012880, 0x8208f6d6, 0x83592031, 0x02202721, 0x1f021616,
+    0x28821011, 0x48111022, 0x09ef6818, 0x25249b83, 0x3b003000, 0x05249f9c, 0x37361716, 0x2005f848, 0x990a9433, 0xc8fe21ab, 0x18078046, 0x88081c9c,
+    0x20b29808, 0x20da8348, 0x20048840, 0x840983a0, 0x83602004, 0x00603209, 0x00030000, 0x02c0ff03, 0x00c0017f, 0x005d004b, 0x9f781880, 0x059e6d12,
+    0x2308dd45, 0x1415012b, 0x22054f5f, 0x70233527, 0xd3820811, 0x22055d42, 0x89371716, 0x07ac1815, 0x012f2310, 0x14820637, 0x06171625, 0x7107012f,
+    0x4e710648, 0x36372709, 0x011f3233, 0x8e465f02, 0x090d2905, 0x13230109, 0x39232301, 0x2006de7c, 0x06ea7110, 0x19831020, 0x09090130, 0x2338100d,
+    0x2d020124, 0x2a39432e, 0x6f181421, 0xd0200851, 0x080f3c48, 0x213cb328, 0x02011314, 0x3c060929, 0x0a09083a, 0x0b4e0501, 0x42080103, 0x07060528,
+    0x051d4c0b, 0x1d040c09, 0x0909c001, 0x7785580e, 0x23250b28, 0x2a2b3b2b, 0xa149130d, 0x827c8a05, 0x0d132b1f, 0x443b2b2a, 0x01022d2d, 0x1f852120,
+    0x08102948, 0x1a122420, 0x452e2727, 0x36060233, 0x05040736, 0x020d4f0b, 0x2d070a0a, 0x08090945, 0x0b4a1703, 0x8d184a0b, 0xa02808f3, 0x44003600,
+    0x5f005200, 0x6007f543, 0x062b05ca, 0x010f0607, 0x36350706, 0x74273437, 0x07270617, 0x17161506, 0x182f2615, 0x240a93af, 0x37363736, 0x24c28231,
+    0x16171415, 0x2717821f, 0x21233736, 0x07141716, 0x36211682, 0x200f823d, 0x08346c23, 0x011d4c08, 0x40013523, 0x1b222327, 0x0f101881, 0x19180101,
+    0x39254729, 0x0d0d011f, 0x1b1b1516, 0x0d0d1615, 0x233b1f01, 0x18192947, 0x100f0101, 0x231a8118, 0xf8fe2822, 0x0f0f0107, 0x01061f19, 0x01671f01,
+    0x06011ea9, 0x0f0f1820, 0x73670701, 0x40260653, 0x1b01a001, 0xaf182a1a, 0x11300876, 0x194d142f, 0x1f20192a, 0x01011717, 0x201f1717, 0x4d230c82,
+    0x18112f14, 0x3d0888af, 0x011b1a2a, 0x55070190, 0x07131319, 0x39181608, 0x18394444, 0x13070816, 0x07551913, 0x79419001, 0xc0c02105, 0x0b9f7518,
+    0x22000c27, 0x00002f00, 0x0a964725, 0x47271121, 0x322005b2, 0x2706704b, 0x0722012b, 0x13011d06, 0x09b96618, 0x01112123, 0x09344b00, 0x220e147e,
+    0x4d2001e0, 0x002609d5, 0x1b121201, 0x10830001, 0x4b80fe21, 0x8048065d, 0x01c02206, 0x0aa94b20, 0x0900802c, 0xc0ff0000, 0xc0014001, 0x93821500,
+    0x34002b2c, 0x46003d00, 0x58004f00, 0x94186300, 0x5b18178b, 0x83450c10, 0x06152308, 0x0c841607, 0x48183720, 0x119a07ec, 0x40180320, 0xab840953,
+    0x200db14e, 0x07bc4940, 0x10021622, 0x0f934718, 0x10a05020, 0x010f7024, 0x174d0f01, 0x09e94e06, 0x01220988, 0x4918a880, 0x78200907, 0x20077744,
+    0x2108ab20, 0xc7455001, 0x00330807, 0x00000600, 0x8002c1ff, 0x1700c001, 0x5d002f00, 0x6c006500, 0x00007e00, 0x011f3601, 0x0f141516, 0x26270601,
+    0x2623013f, 0x013f3627, 0x31372627, 0x18370701, 0x320aea4a, 0x3f343526, 0x16173601, 0x33033107, 0x17161506, 0x51013b16, 0x3f2f06fd, 0x07061501,
+    0x36230706, 0x26273435, 0x82260727, 0x23262a04, 0x35010f22, 0x37363736, 0x06434f31, 0x35051522, 0x33212483, 0x10444827, 0x1117022d, 0x08084010,
+    0x0e111040, 0x83ae170e, 0xae3408ef, 0xfe0e0e17, 0x17ad1651, 0xad170101, 0x100f0f16, 0x07074011, 0x0f101140, 0x06f3090f, 0x160f0e01, 0x03160661,
+    0x15151003, 0x12011310, 0x05f21b12, 0x60170e0f, 0x14201287, 0x1c341283, 0x40011112, 0x121bc101, 0xe1400112, 0x011b1b2a, 0x2a1b1b01, 0x29078f44,
+    0x0e0eb901, 0x0a0a0740, 0x5a834006, 0x1502182e, 0x16010216, 0x8ffe1111, 0x15030118, 0x69837383, 0x0b064038, 0x0e400709, 0x0110110e, 0x170c0b38,
+    0x0f1c0f0e, 0x0f0f0304, 0x5383d613, 0x150e0b24, 0x53820f0f, 0x14211284, 0x201283d7, 0x22768380, 0x8340c040, 0x4c202006, 0x4b180fb4, 0x023b07ab,
+    0x00c00100, 0x00480032, 0x0056004f, 0x0066005e, 0x01000078, 0x15161716, 0x45311516, 0x3d2107cd, 0x05ae6a01, 0x18190720, 0x1f210933, 0xa2b71801,
+    0x1732220a, 0x266a1831, 0x4f15200a, 0x17250903, 0x26272633, 0x0ab21827, 0xd7012529, 0x01010304, 0x26053c45, 0x0c0c0a69, 0x185a5c0a, 0x25070eb7,
+    0x59151570, 0x0c441355, 0x0f5f2a05, 0x0129fe09, 0x01140e0d, 0xf16918a0, 0x3030210d, 0x2007704d, 0x851a8530, 0x18302010, 0x27108e47, 0x0605b701,
+    0x02030403, 0x2506dc43, 0x08096a13, 0xb7184e4e, 0x60240748, 0x544c1010, 0x09228485, 0x6187d9fe, 0xa0206a88, 0x30210984, 0x206b84a0, 0x21708370,
+    0x24837030, 0x49103021, 0x00240fea, 0x000f0000, 0x24070f4d, 0x0017000c, 0x0f5a1822, 0x00842c0c, 0x0092008b, 0x00a2009a, 0x480000b4, 0x162408ad,
+    0x27171617, 0x4f09214f, 0x07220a2c, 0x76503736, 0x65372007, 0xe14805d8, 0x85172005, 0x20128506, 0x076b4707, 0x06070623, 0x83478407, 0x8236201d,
+    0x20198b30, 0x46af410f, 0x0f010026, 0x01161722, 0x98250585, 0x16020216, 0x20048430, 0x084a5120, 0x87687021, 0x02162213, 0x202d8bf0, 0x260c8bd0,
+    0x01010f50, 0x85221716, 0x8b302005, 0x8cb0200c, 0x3df4410c, 0x4b8b7020, 0xb2444020, 0x87482007, 0x45602008, 0xa820071b, 0x0c8b278c, 0xb48b9020,
+    0x0c986020, 0x085f5018, 0x20343442, 0x08af6301, 0x00006928, 0x3d262705, 0x81182701, 0x35210892, 0x08154507, 0x3f343524, 0x92433101, 0x36272505,
+    0x013f3637, 0x26092d49, 0x17010f16, 0x82373635, 0x1d162602, 0x15171601, 0x211a8337, 0x16831736, 0x17200384, 0x2405dd51, 0x31012f06, 0x21218217,
+    0x46821617, 0x01312808, 0x190630ae, 0x0d0e0909, 0x17010909, 0x12103006, 0x062a0d0f, 0x241e8441, 0x011a1b23, 0x22161601, 0x080c2899, 0x820b2718,
+    0x30330818, 0x31160809, 0x07011602, 0x33011708, 0x30090816, 0x0b0f130f, 0x0b081726, 0x16229929, 0x1a010116, 0x1e24231b, 0x2a054486, 0x10120f0d,
+    0x09073838, 0x493f1f38, 0x2f080784, 0x09381f3f, 0x0d0f3807, 0x37311210, 0x7a570609, 0x1902011d, 0x1a252a1a, 0x2917061a, 0x332a100e, 0x100c0f13,
+    0x270f0d40, 0x07182632, 0x01010739, 0x24080482, 0x27322618, 0x10400d0f, 0x33130f0c, 0x290e102a, 0x1a1a0617, 0x191a2a25, 0x7a1d0102, 0x37090657,
+    0x0d101231, 0x094b460f, 0x6900bf34, 0xc000bb00, 0xca00c500, 0x0000cf00, 0x013f2617, 0x03823635, 0x211e2b41, 0x2b413233, 0x07062315, 0x03832726,
+    0x06072222, 0x27280182, 0x15141715, 0x07061716, 0x25119341, 0x17162531, 0xcf543315, 0x05a84305, 0x87062753, 0x54458306, 0xd45407cd, 0x05924d06,
+    0x068d3520, 0x86373621, 0x17312148, 0x33212e82, 0x20048315, 0x08598227, 0x011d2334, 0xa9233533, 0x011d060d, 0x1b743a05, 0x18172020, 0x14130101,
+    0x0831a01f, 0x061d0e03, 0x20070e0d, 0x2c0c0203, 0x06011702, 0x2e011609, 0x2003020c, 0x2d820e07, 0x08030e3b, 0x1422a031, 0x1a0e0304, 0x1a0e0e1a,
+    0x050c0c11, 0x21290a10, 0x04071501, 0x06f0412c, 0x82021f21, 0x57012b2a, 0x0130010f, 0x10010f0f, 0x2553010f, 0x83058805, 0x9d1a8415, 0x3040211f,
+    0x80200082, 0x28080382, 0x0e070e30, 0x05052d3d, 0x1a65173c, 0x16160101, 0x16171f25, 0x072a1804, 0x0e3a2a0a, 0x400d0607, 0x26260606, 0x2a081817,
+    0x08028208, 0x2617182a, 0x40060626, 0x0e07060d, 0x070a2a3a, 0x1a05182a, 0x02150504, 0x02151502, 0x050f0a0a, 0x2117230e, 0x0c1c0203, 0x322b0605,
+    0x24074442, 0x05282032, 0x26318203, 0x100e02cf, 0x82020e10, 0x0e022105, 0x0488bb82, 0x0e21c093, 0x86bb8202, 0x82338504, 0x30702505, 0x30305030,
+    0x0582b182, 0x00820020, 0x1f00012a, 0x20022000, 0x14006001, 0x2206bf49, 0x53173233, 0x90200c72, 0x2d21ad82, 0x2fbd822d, 0x0809096c, 0x133efe13,
+    0x6c090908, 0x16270d01, 0x272a0082, 0x0f0f11bd, 0x0f0f0101, 0x5f47bd11, 0x01802208, 0x798a18c0, 0x0073230a, 0xc74f0079, 0x0a2a4206, 0x1517162e,
+    0x07060706, 0x30373023, 0x012f3637, 0x2806645b, 0x35270722, 0x37363736, 0x201a8233, 0x79651815, 0x7b8a1808, 0x0d4b4a0c, 0x0d888a18, 0x21203582,
+    0x2b06fb51, 0x03131716, 0x33371707, 0x14b00127, 0x10688a18, 0x01017a26, 0x03491311, 0x2028b783, 0x01470405, 0x60140e0d, 0x0a038a18, 0x0a6b8a18,
+    0x8a18a020, 0x5538148c, 0x130b090a, 0x0a1484fe, 0x09be0a09, 0xbe0a1314, 0x301849dc, 0xc0013d3e, 0x90204983, 0x0f628a18, 0x22220123, 0x2246847a,
+    0x185c7703, 0x180ee08a, 0x200a628a, 0xe55a1860, 0x116b2314, 0xac821112, 0x3a2c0482, 0x10010110, 0x0e01c6fe, 0x6340297a, 0x240dc765, 0x002c0011,
+    0xccc61800, 0x34012811, 0x37361337, 0x4e011f16, 0xb94e0549, 0x26212705, 0x31272627, 0x4e18e001, 0x173d09ea, 0x16172222, 0x0920fe01, 0x14140bd8,
+    0x06307e0b, 0x84070c0d, 0x11110109, 0x18f5fd1a, 0x18958210, 0x8308bab2, 0x25378327, 0x0e1088fe, 0x8f835901, 0x0b4fc928, 0x110fd80b, 0xa482111a,
+    0x17101022, 0x24060b55, 0x00bd0140, 0x05337241, 0x06310733, 0x2706010f, 0x05012f26, 0x013f3315, 0x37273307, 0x0c195517, 0x37343526, 0x11013b36,
+    0x1722a782, 0xc3823f15, 0x2723ae83, 0x82363726, 0x8217200b, 0x33053b0b, 0x02072327, 0x1010083a, 0x0c0d0f21, 0xfe1a030b, 0x4a352aae, 0x3e1b4219,
+    0x48188943, 0x23080d9f, 0x16160210, 0x080e8402, 0x07081616, 0x0603196c, 0x210f0d07, 0x2a091c1c, 0x0b8693fe, 0x21e80b70, 0x040a1b1c, 0x5e281583,
+    0x14989f58, 0xbe104e4c, 0x330c7258, 0x02021608, 0x27232716, 0x14010114, 0x0d5c1c13, 0x04040b0b, 0x26087482, 0x20e89b20, 0x00000020, 0xff00000a,
+    0x018002e0, 0x001100a0, 0x0033002d, 0x0054004e, 0x00780066, 0x009c0096, 0x190000a2, 0x20094f23, 0x05a64836, 0x06011f24, 0x55181407, 0x26210bec,
+    0x05a66d27, 0x1716332b, 0x07060731, 0x05351716, 0x05577e35, 0x16221182, 0x13821417, 0x2009285b, 0x20198337, 0x05845815, 0x2407a65d, 0x17161716,
+    0x10237505, 0x07141725, 0x18070631, 0x430d0f6f, 0x2f830540, 0x83350721, 0x15372169, 0xb8254e83, 0x18100f01, 0x05244418, 0x18220784, 0x4b18022e,
+    0x1d3e0776, 0x20011211, 0x2420301f, 0x010f901c, 0x80010f01, 0x2e02011f, 0x3020251b, 0x1201201f, 0x48581d11, 0x83802006, 0x8f08201b, 0xc8fe2146,
+    0x200f024a, 0x873289c0, 0x20488358, 0x1c4718c0, 0x8b682009, 0x25508387, 0x34422a6c, 0xcf411527, 0x0e1b2405, 0x83221b1a, 0x13012f30, 0x19191132,
+    0x15aa5411, 0x2a423427, 0xa2830113, 0x1a1b2224, 0x27851b0e, 0x1c845620, 0x4a8ff220, 0xc5540820, 0x20338211, 0x2033852b, 0x825b882b, 0x542a21ee,
+    0x05844184, 0x00820020, 0xe3410520, 0x0023260a, 0x00490037, 0x137d7ca5, 0xe37b0520, 0x32052310, 0x81533117, 0x22212a05, 0x34352627, 0x21333637,
+    0x22259127, 0x79310714, 0xec510748, 0x18362005, 0x20262587, 0x061c523d, 0x012f2622, 0x2308e941, 0x06073527, 0x17280182, 0x2f060716, 0x68011701,
+    0x210b7b79, 0x0d8b00ff, 0x18f80121, 0x220d8844, 0x8d984002, 0x0909232c, 0x2282300e, 0x87181b20, 0x1b202206, 0x24222b8b, 0x0f830202, 0x090d3125,
+    0x181a0109, 0x22090587, 0x79780101, 0x86180b97, 0xe86e0cdc, 0x8bf8200c, 0x85b82026, 0xea8618a4, 0x0c0c230d, 0x8618150d, 0x83542fea, 0x013f2a07,
+    0x001200c0, 0x0080006d, 0x13035c93, 0x3217312e, 0x3f36011f, 0x32333601, 0x021f1617, 0x098dc518, 0x07012f22, 0x3907fc46, 0x2f262706, 0x013f2602,
+    0x15222306, 0x010f0607, 0x2f062706, 0x07161301, 0x19830706, 0xac180120, 0x50730a5b, 0x37362406, 0x18173736, 0x2008538c, 0x27278217, 0x26272607,
+    0x17033127, 0x23263e84, 0x35262722, 0x6c823f34, 0x18203121, 0x080fdb62, 0x12135644, 0x0b221486, 0x1b22231f, 0x160e0e1b, 0x0504040c, 0x0c0c0c07,
+    0x0907101b, 0x03083214, 0x06070317, 0x0b0c0d0d, 0x17471504, 0x01011109, 0x0a180b01, 0x06150a01, 0x033a7705, 0x0d0d0707, 0x1e030b0b, 0x2b191510,
+    0x182c07c0, 0x090e0f09, 0x12120109, 0x2a01361b, 0x3b25698f, 0x07040e28, 0x05d2553d, 0x03193c24, 0xb0180104, 0x502b106d, 0x0e1e3807, 0x12130e05,
+    0x830a251f, 0x2c8c8384, 0x1710080e, 0x0c093641, 0x0b0a0e5c, 0x318c8304, 0x211b4d58, 0x04010140, 0x1404180b, 0x32020101, 0x8483fbfe, 0x8c820320,
+    0x0d7b8734, 0x01030a0b, 0x900e0707, 0x0e0a090b, 0x12131a80, 0x8c180101, 0xfe26102f, 0x09242dd8, 0x88563e07, 0x3e3b3605, 0x04000404, 0xc0ff0800,
+    0xc0012f02, 0x49003600, 0x89005c00, 0x05d34600, 0x17161727, 0x06010f16, 0x07ab5907, 0xbc183d20, 0x26200b99, 0x260c157e, 0x37323316, 0x60013f36,
+    0x368205fc, 0x55061721, 0x3120069b, 0x23113a45, 0x1f161731, 0x0a34cd18, 0x0c512a19, 0x32091975, 0x36373603, 0xf0011737, 0x0d0c0b04, 0x0307060d,
+    0x183b1309, 0x340c7757, 0x020a133b, 0x0e0d0706, 0x09040b0a, 0x20181808, 0x08181820, 0x08035d08, 0x20077b41, 0xa2dd18fe, 0x24118708, 0x26182b49,
+    0x05f3421e, 0x0b113023, 0x26538c0c, 0x1b121201, 0x18a80121, 0x240797d2, 0xfe204323, 0x212a85ce, 0x07858080, 0x20320124, 0x89412343, 0x1f233707,
+    0x12131312, 0x1417231f, 0x01010d0d, 0x15140d0d, 0x0d0e0e0d, 0xc54f0115, 0x81681807, 0x86242009, 0x140f22bb, 0x274f8de3, 0x1a6002bf, 0x01011213,
+    0x2d069b5d, 0x00c0017f, 0x00290017, 0x004e003c, 0xbb4900aa, 0x06072605, 0x25270607, 0x060e5105, 0x36253725, 0x18010d17, 0x2010098c, 0x21119007,
+    0x8c182131, 0x05211040, 0x0cc54427, 0x0a1e5918, 0x3f2f8c18, 0x31272508, 0x030b7002, 0x0c060704, 0xeefe0c0c, 0x0c0df1fe, 0x0306070c, 0x21010b04,
+    0x2001100f, 0x0b01a7fe, 0x0b12100c, 0x12250082, 0x010b0c10, 0x200e8db0, 0x308c1801, 0xccfe220e, 0xf48b181c, 0x218c180c, 0x1c012542, 0x0d0c0c07,
+    0x9625a183, 0x03040796, 0x249f830b, 0xa00808a0, 0x18304524, 0xc320188b, 0x0deb8b18, 0x18154721, 0x20370f8c, 0x07234500, 0xc001802a, 0x44001100,
+    0x6d004900, 0x18132345, 0x180ae2d5, 0x2013bf5a, 0x1f561821, 0x17352611, 0x33152335, 0xef981837, 0x9241180a, 0x36372108, 0x8205f649, 0x22232354,
+    0x2243012f, 0x1d182110, 0x0822b518, 0x15160d33, 0x151a1e1a, 0x073a0d16, 0x0c0b0303, 0x1d070c0d, 0x068d5801, 0x074d4b18, 0x10505824, 0x3b44c110,
+    0x78951805, 0x0d0a230e, 0x95180a0d, 0xfc420aef, 0x30d12507, 0x0703030b, 0x61286283, 0x0c0c0d16, 0x0b61160d, 0x5f835782, 0x4abf3021, 0xbf240b08,
+    0x796060bf, 0x21051c45, 0x2443f31a, 0x18f32005, 0x200a3993, 0x5f3b4100, 0x15160124, 0x7a541431, 0x0d8a5405, 0xf9552720, 0x32332205, 0x433b411f,
+    0x418f0121, 0x0121573c, 0x1b3d4147, 0x0000032e, 0xbf01c0ff, 0x1100c001, 0x66005400, 0x18137542, 0x2308865d, 0x27262337, 0x2406bd78, 0x14011d06,
+    0xf3461815, 0x23302209, 0x271b8226, 0x37262726, 0x31303736, 0x270a3544, 0x07161716, 0x27310716, 0x107f4c18, 0xee4c9020, 0x25012d0f, 0x13130e3f,
+    0x03040d10, 0x283c0107, 0x2b050142, 0x06061266, 0x12120a09, 0x0101a012, 0x023c8583, 0x01010905, 0x201f1444, 0x1e234c24, 0x0333151f, 0x01020502,
+    0x0c13a10b, 0x130c0d0d, 0xbf180585, 0x1b4d09d6, 0x4ed12c08, 0x0c020310, 0x0f100f0c, 0x42252d0a, 0x30230541, 0x82330101, 0x12133d57, 0x50090606,
+    0x07070501, 0x0112130a, 0x111e6502, 0x1c101011, 0x0a050547, 0x5f0d100b, 0x59825388, 0x240a875c, 0x00460011, 0x0add4d6e, 0x23081653, 0x31272213,
+    0x0ea4b818, 0x013b3622, 0x2008b94f, 0x12601806, 0x3527210b, 0x2205d146, 0x53370331, 0x0f200512, 0x08396318, 0x53054153, 0x2b4e0947, 0xaf012105,
+    0x0d2c9418, 0x090d0825, 0x431c0109, 0x1e211aa1, 0x05455309, 0x07821020, 0x0b4cdb2e, 0x26060607, 0x05321937, 0x08090a01, 0x4819665c, 0xfe211079,
+    0x203e8230, 0x19aa43df, 0xb646df20, 0xa4012f0a, 0x09080317, 0x29264509, 0x050b4f08, 0x5e5c0704, 0x42002017, 0xeb440573, 0x00432205, 0x12ad4d5c,
+    0x46031721, 0x5b4807a4, 0x6961180a, 0x3b36220d, 0x6b611801, 0x0637230c, 0xaa502607, 0x17162205, 0x06cb6716, 0x06272625, 0x49f01507, 0xa3820f6f,
+    0xb6820e20, 0x63421020, 0x0de54405, 0x1d2d2431, 0x0101084a, 0x0d0d0a0b, 0x02582f09, 0x4d021616, 0x0b84075e, 0x01070722, 0x21119d49, 0xbb4750fe,
+    0x0d2e410d, 0x59220122, 0x54834c83, 0x60f53928, 0x16020216, 0xf44d1808, 0x83702006, 0x8270200d, 0x08072652, 0x20000200, 0x050376ff, 0x5d001122,
+    0x20138543, 0x6c621813, 0x3b362111, 0x18054b5a, 0x2a09339c, 0x26272623, 0x15333527, 0x5f233533, 0xa7490a10, 0x4531200f, 0x082010eb, 0x0841c182,
+    0x018f250d, 0xe0140e0d, 0x8407ac45, 0xc0402208, 0x066c5ec0, 0x1d498820, 0x120e4109, 0x4a113242, 0x5088086b, 0xc0203023, 0x20448540, 0x06e17dfe,
+    0x82808021, 0x5e002083, 0x402a067b, 0x1100c001, 0x54004200, 0x1d426400, 0x0b894514, 0x21055155, 0x1147013f, 0x07062309, 0x9a4d3126, 0x22232506,
+    0x013d2627, 0x2022257b, 0x0f2542d0, 0x1e423820, 0x1a1e2b13, 0x2d0d1615, 0x03010b19, 0x1f851d01, 0xa8011022, 0x7b0f7770, 0x21410e39, 0x4ad02012,
+    0x29420635, 0x0d0c290d, 0x231b4a16, 0x30020301, 0x7b075543, 0x1c192055, 0x2f410b0b, 0x005d2205, 0x44314168, 0x4125a371, 0x88203835, 0x200f3441,
+    0x07f75890, 0x08484318, 0x684b3741, 0x441808eb, 0x04210c70, 0x7f591800, 0x053b4107, 0x39415f20, 0x12ef7344, 0x55062321, 0x26210530, 0x38304127,
+    0x18116642, 0x410aaa44, 0x7f414b2a, 0x118b4308, 0x1f416d20, 0x11594244, 0x18eb4418, 0x42382d41, 0x4518105e, 0x36411402, 0x2045184b, 0xe35b1817,
+    0x05634209, 0x80005d22, 0x61564541, 0x272108c5, 0x78591816, 0x49584120, 0x24945918, 0x45115648, 0x59183801, 0x4b462ab2, 0x58bf4210, 0x26273622,
+    0x14a3de18, 0x75496641, 0xc34218ac, 0x1dbb754b, 0x29078767, 0x00510011, 0x01000079, 0xc6180714, 0x15220da7, 0x6b183703, 0xfa4a0b09, 0xb4691810,
+    0x07004b0d, 0x26272222, 0x2005a767, 0x280a4b37, 0x0e0f0222, 0x0cf2bf18, 0x22269822, 0x2a07074b, 0x19191035, 0x191e0c1e, 0x4e351019, 0x222607a9,
+    0x05040325, 0x0d4b1308, 0x090d290a, 0x08110109, 0x9b020405, 0x2239164b, 0x4e3973c5, 0x5a2707be, 0x0f0f0e19, 0x4e5a190e, 0x392407be, 0x07060873,
+    0x0e01c418, 0x06076025, 0x4b0f0108, 0x003a261e, 0xff000003, 0x013f02e0, 0x002d00a0, 0x0075003f, 0x17161300, 0x16171631, 0xd918013f, 0x062208c8,
+    0x717f010f, 0x82372009, 0x013d220a, 0x05d04f36, 0x45011d21, 0x13201160, 0x181a7f76, 0x200dd756, 0x6d688336, 0x312805a7, 0x171701bf, 0x6a3e3d26,
+    0x3d074654, 0x11101069, 0x14111315, 0x211a1114, 0x1d150c0b, 0x09011111, 0x090e0d09, 0x12014009, 0xe5571b13, 0x12132308, 0x677d8101, 0x60012932,
+    0x0c1f2028, 0x03180d13, 0x2f063e55, 0x61020418, 0x0c0c0d05, 0x03010213, 0x24231b92, 0x08b49218, 0x6a871f20, 0x11121c29, 0x12110101, 0x7ddffe1c,
+    0x0020312c, 0x022c0082, 0xc1ff2000, 0xc001c001, 0x4e003c00, 0x230b596a, 0x33171507, 0x560b5c4c, 0x07250b58, 0x22070615, 0x066a4c27, 0x36373629,
+    0x3734013d, 0x54313336, 0x07210ce1, 0x3b208226, 0x090e0001, 0x21131409, 0x0e185739, 0x0201072c, 0x0c0d0b0b, 0x5c612609, 0x0c020307, 0x08340a82,
+    0x020105a0, 0x09090d1e, 0x1b1b0101, 0x100f1c2e, 0xe00e090a, 0x330f844a, 0x0909c001, 0x23290a0e, 0x4f011623, 0x0b3a1301, 0x07090d0c, 0x34254982,
+    0x0c0d0b90, 0x25488308, 0x490f0ef8, 0x2482021e, 0xc2184920, 0x75820880, 0x2810db55, 0x00030000, 0x02c1ff00, 0x24eb827c, 0x004d003b, 0x23ed827c,
+    0x06310714, 0x3620e8ad, 0x23056142, 0x06071715, 0x466b3b82, 0x16373907, 0x05171617, 0x012f2607, 0x27262737, 0x30271423, 0x013f2631, 0x36372627,
+    0x4e07e75c, 0x162106e2, 0x1f721807, 0x00012708, 0x39211314, 0x18411946, 0x50272109, 0x42181841, 0x01210665, 0x101d41a0, 0x0327702c, 0x12022503,
+    0x01122017, 0x306b0902, 0x0b042407, 0x431d040b, 0x412d05d9, 0x0b030108, 0x0a01054e, 0x013b0809, 0x30464196, 0x0e090924, 0xbb55250a, 0x07084d05,
+    0x0424cf2a, 0x03113104, 0x01010115, 0x2209336b, 0x434a0a0a, 0x2d2505da, 0x020a0a07, 0x05fc4e0d, 0x08835b18, 0xc0013f28, 0x2b001100, 0xd54d4b00,
+    0x5f172013, 0x1f5009d9, 0x1135210c, 0x4d055042, 0x6f180aba, 0xc8180e11, 0x382110d4, 0x0da15307, 0x23059f4c, 0x19190f6e, 0x2406aa4c, 0x04050812,
+    0x0a2b4502, 0x20113a46, 0x0c865350, 0x2806854c, 0x19366001, 0xfe010e0e, 0x05e54ea0, 0x06076023, 0x0afc4408, 0x0021e682, 0x08474b06, 0x45001226,
+    0x79005700, 0x2517e775, 0x27260331, 0xaa4d2631, 0x0cbd4f06, 0x16581420, 0x11ed4f05, 0x5c183120, 0x16230db7, 0x43171617, 0x1526096a, 0x07060706,
+    0xa0522f22, 0x23598408, 0x0335011f, 0x1809a466, 0x4e0a85b6, 0x802910f5, 0x0703030c, 0x15160d3a, 0x0cf64f1a, 0x250cfa57, 0x0d0c071d, 0xc847010b,
+    0x5d102010, 0x12260875, 0x141b1c13, 0x96591c36, 0x07302807, 0x290c1011, 0x7f0f01b0, 0x0f27056b, 0x060d2f01, 0x84300e07, 0x11704104, 0x55f5fe21,
+    0x26500700, 0x134f500c, 0x3d584b20, 0x08b35d0f, 0x131c6628, 0x37130112, 0xa25a0c38, 0x0f602c06, 0x2a0b0203, 0x0f28013b, 0x830f0101, 0x074a2503,
+    0x18060d0e, 0x4f580484, 0x01002c06, 0x000b00bf, 0x0029001a, 0x7547003a, 0x26280821, 0x013f3627, 0x33373407, 0x2b059860, 0x27262726, 0x17161731,
+    0x22233507, 0x2105455d, 0x1a752137, 0x05aa4205, 0x16372324, 0xea5e3117, 0x01332f0b, 0x01020f6f, 0x0216980f, 0x9f981601, 0x6f189c02, 0x692408fa,
+    0x98a31416, 0x27053957, 0x4c751101, 0x0f040409, 0x092a0082, 0x1baba936, 0x09092e11, 0xf082800e, 0xbf01c032, 0x0f1e0f01, 0x16160201, 0x076e0d03,
+    0x23070909, 0x2e052075, 0x07017023, 0x0b0b5aa2, 0x0b0c1012, 0x83814401, 0x26408338, 0x11ab2e5a, 0x41209d1d, 0x2020052a, 0x0120d785, 0x00214482,
+    0x22d7820c, 0x544f0042, 0x3f2005cb, 0x8406fc75, 0x5b1520c9, 0xe28207ff, 0x15271328, 0x31301514, 0xed823627, 0x26371724, 0xd9823637, 0x5a010f21,
+    0x994205d9, 0x83272009, 0x06397920, 0x17161523, 0x11835107, 0x2b061324, 0xee828001, 0xae20f886, 0x023af388, 0xae36489c, 0x18321c19, 0x060c5f16,
+    0x0c1c0e08, 0x0b033807, 0x24070403, 0x00410203, 0x166e2208, 0x4d581802, 0x82682007, 0x093621c8, 0x0f2fdc82, 0x4c090404, 0x05b5160e, 0x99018006,
+    0x410d0316, 0x38200614, 0x3d090f41, 0x93fe0907, 0x02026e5a, 0x01010bf9, 0x0d09a408, 0x0910060c, 0x0701600d, 0x3f0c0d0c, 0x20410504, 0x188d2008,
+    0x25092eb7, 0x0e0909c1, 0x59835a6e, 0x81256183, 0xfdfe0f19, 0xe35b1802, 0x01003a08, 0x000b00c0, 0x0027001b, 0x00480036, 0x0077005e, 0x13000091,
+    0x06151732, 0x05f36c07, 0x9d791720, 0x37343f08, 0x31151633, 0x17373607, 0x22012b22, 0x013d2627, 0x37322717, 0x16013b36, 0x15171617, 0x0a750714,
+    0x06e75b06, 0x27260724, 0x18822726, 0x1b843120, 0x2607695f, 0x37363736, 0x54060133, 0x272505df, 0x33363734, 0x052b4617, 0x1415162a, 0x013f010f,
+    0x0f161736, 0x8205055c, 0x06bd437f, 0x3734352f, 0x0210b631, 0x106f0f01, 0x6f0e0101, 0x07e0600a, 0x027b0339, 0x901401a0, 0x0e800302, 0x89be0909,
+    0x04030202, 0x12121b40, 0x61620201, 0x60200f02, 0x69421683, 0x391b8306, 0x12f8fe40, 0x100f0d10, 0x07021571, 0x10700a07, 0x12100d0f, 0x40080840,
+    0x16844090, 0x070a7025, 0x88160207, 0xc0012a16, 0x010f0e10, 0x030e1001, 0x8348840c, 0x82092041, 0x1da02300, 0x54826f12, 0x6a2b202f, 0x12010101,
+    0x07201a13, 0x131bcb05, 0x490b8312, 0x6020080f, 0xa6422c83, 0x29858307, 0x0f0dc6fe, 0x010e1012, 0x64821701, 0x100e012d, 0x380d0f12, 0x070c0a07,
+    0x83385c38, 0x820d2018, 0x0117228f, 0x2416850f, 0x00070a0c, 0x055f4500, 0x01ff012f, 0x001100c0, 0x00500044, 0x0067005b, 0xc9471872, 0x53032013,
+    0x285f1d17, 0x20268908, 0x0bbc7923, 0x18362121, 0x2008c478, 0xdbbb1801, 0x31372208, 0x051d4325, 0x2f060725, 0x47300101, 0x26530f83, 0x092b5a19,
+    0x39065045, 0x4f1111f1, 0x11100f0f, 0x010e0e50, 0x0f1011d0, 0x1110500f, 0xfe500e0e, 0x0c835030, 0x82114f21, 0x8001260c, 0x10110e0e, 0x45258450,
+    0x354e122d, 0x093b5a18, 0x2206b446, 0x82590180, 0x8757885a, 0x886b8279, 0x842f2060, 0x2687847d, 0x03000000, 0x7eff0f00, 0x142c0513, 0x5b002600,
+    0x32010000, 0x35231117, 0x200ed14c, 0x080a4337, 0x56643620, 0x37172105, 0x33d27718, 0x27090124, 0xed43c020, 0x1e132509, 0x3732251f, 0x210f1059,
+    0x77180f90, 0x002426be, 0xaed4fe14, 0x2209dd43, 0x66121120, 0x4021101f, 0xa5771874, 0x0003252b, 0x02c0ff00, 0x27053f7b, 0x00540030, 0x17160100,
+    0x20099779, 0x08f75f27, 0x36113527, 0x1f36013f, 0x11806301, 0xbb181320, 0x52630903, 0x05524505, 0x15012f24, 0x1a820706, 0x06822320, 0xf0013124,
+    0x1942010f, 0xc0c02105, 0x01270785, 0x110fe00f, 0x63e8fee0, 0x08220b0d, 0x07630216, 0x1518350a, 0x09260c14, 0x1b0c1413, 0x02161602, 0x01160210,
+    0xfe120a3c, 0x25061673, 0x6e6e2d01, 0x1046d3fe, 0x40012705, 0x08800a12, 0xc85d8008, 0xa8fe2c0c, 0x31ae1602, 0x140c0913, 0x820d1547, 0x47152f00,
+    0x13090c14, 0x0216ae31, 0x58581602, 0x4b5c0216, 0x0012260d, 0x0060004d, 0x13b54996, 0x06073122, 0x620b8a5d, 0x0f2129b4, 0x10786201, 0x35260524,
+    0x41863431, 0x0f141523, 0xd8dd1801, 0x06744709, 0x24055d45, 0x07060706, 0x09567823, 0x2e100b4b, 0x010a182f, 0x0d0c0b06, 0x0405050c, 0x622f1402,
+    0x0c202ab7, 0x210f7e62, 0xb3180904, 0x132008b6, 0x08f29318, 0x0a090e2f, 0x800e090a, 0x022d2d44, 0x442d2d02, 0x07825d13, 0x2311a543, 0x04180b9d,
+    0x8d838583, 0x162f0422, 0x2027b662, 0x0e7d628b, 0x0d0a1f25, 0x5d500a0d, 0x01230614, 0x83291b1b, 0x0527428a, 0x079d6118, 0x0adab318, 0x2108b376,
+    0xb74100c0, 0x41842005, 0x25205fb7, 0x1007a218, 0x21052349, 0x0785013b, 0x1f323322, 0x4111b14c, 0x022149a5, 0x14a21812, 0x32a21810, 0x58934108,
+    0x93416f20, 0x058b410b, 0x220b8341, 0x5a000008, 0x834106c3, 0x008f2607, 0x00a5009a, 0x838b41b0, 0x0a458218, 0x5c061721, 0x1623052a, 0x5c071517,
+    0x8218072a, 0x5d430c71, 0x1bb7415a, 0x0359ef20, 0x69431807, 0x41119009, 0xe92073db, 0x20093d73, 0x38d818a8, 0x02982309, 0x0d861016, 0x74731584,
+    0x05434505, 0xc0ff0322, 0x2406af48, 0x005f004c, 0x130b6d79, 0x234a4245, 0x010f1627, 0x22059045, 0x6426012f, 0x1f2606bd, 0x17363701, 0x84180131,
+    0xb7480821, 0x49814307, 0x060d4638, 0x4002012c, 0x0c0c0d07, 0x04030c37, 0x0c083f07, 0x20360c0d, 0xa2410c09, 0x09462758, 0x04044d0c, 0x6c820b6f,
+    0x0c072025, 0x826f0c0c, 0x20062776, 0x00060b38, 0xb3470000, 0x01803805, 0x002a00c0, 0x004c003c, 0x17150100, 0x15060706, 0x17161714, 0x18222306,
+    0x220ed1e4, 0x5e3f3435, 0x1620053a, 0x31211e82, 0x10d54801, 0x10016118, 0x234d402b, 0x11111515, 0x010b031d, 0xf2e41802, 0x11ac2b07, 0x01b80803,
+    0x1c1b1212, 0x58181112, 0x27082140, 0x2c546201, 0x2e262519, 0x18222329, 0x0120200a, 0x0409290e, 0x0331472b, 0x05094212, 0x1f1d5469, 0x1f03031f,
+    0xeefe1d1f, 0x218e4e18, 0x830aeb45, 0x004522eb, 0x18edac50, 0xa0262f94, 0x915218f1, 0x12c25c10, 0xae5cf3b6, 0x0ee34115, 0xf5be5520, 0xb5583720,
+    0xb1012017, 0x199e58fa, 0x58360141, 0x07411b8a, 0x002d240a, 0x4659004c, 0x15270b5d, 0x011d0617, 0x18270706, 0x2616c9e7, 0x013f3435, 0x18160535,
+    0x2029a8c9, 0x07df42c0, 0x1c066625, 0x183a4004, 0x420cf2e7, 0x502005ff, 0x1b934318, 0x090fe818, 0x113a542b, 0x23101913, 0x042b4713, 0x0de81809,
+    0x0800430a, 0x16016224, 0xc9182217, 0x0a211eab, 0x05974b00, 0x0e00a036, 0x24001900, 0x3e002f00, 0x5d004d00, 0x7c006c00, 0x00009d00, 0x22055c4b,
+    0x79352726, 0xbf790584, 0x79152027, 0x352005b9, 0x88053363, 0x2016823e, 0x0a526331, 0x3f471520, 0x20118805, 0x06334407, 0x6e836c82, 0x034c1520,
+    0x32212205, 0x053b5217, 0x14151425, 0x6f230607, 0x3526057d, 0x27262726, 0xa6790131, 0x09a37947, 0x80010f22, 0x200b1779, 0x2d198b60, 0x090900ff,
+    0x0ec0010e, 0x1a010909, 0x0b822a1b, 0x8200ff21, 0x1b2a260b, 0x5001011a, 0x86358510, 0xcce61806, 0x11837908, 0x288cb820, 0x8d401021, 0x22602738,
+    0x01011617, 0x0686100f, 0x0a892020, 0x20201183, 0x90201d8d, 0x2505974c, 0x0b22212e, 0x0b850202, 0x0b020226, 0x002e2122, 0x320bc361, 0x0019000c,
+    0x004c003a, 0x13000064, 0x16311732, 0x7323011d, 0x0c8a058e, 0x70173321, 0x072d07dd, 0x17140706, 0x23150706, 0x26272635, 0x7f751827, 0x21332107,
+    0x18118b58, 0x2017b967, 0x24898260, 0x0e090940, 0x200786c0, 0x2c078240, 0x23233801, 0x13100301, 0x24233840, 0x21a98501, 0xce184001, 0x67181069,
+    0x012116c0, 0x204d82c0, 0x0bfd5a60, 0x1082a020, 0x10040330, 0x113d2e2e, 0x63040810, 0x2b2a0d63, 0x3b4a203b, 0x45d02005, 0x67180feb, 0x1f4113d0,
+    0x415c2014, 0xd0523c1f, 0x76cf1809, 0x28174117, 0xc762e020, 0x0ffc630f, 0x183c0f41, 0x52118a55, 0x0224050b, 0x00c00140, 0x22072b42, 0x41600055,
+    0x2d423c0d, 0x09496011, 0x09575f18, 0x42281141, 0x16471029, 0x3c144112, 0x61151c47, 0x17410967, 0x41572007, 0x23423c15, 0x09c56312, 0x42280c41,
+    0xb463101e, 0x3c05410b, 0x560aa663, 0x134205fb, 0xbc65200c, 0x111142fb, 0x4118a163, 0x16422809, 0x15916310, 0x633c1341, 0x1b422183, 0x501f4107,
+    0x41174b49, 0x5249391f, 0x3c234119, 0x201b5849, 0x08bf4f04, 0x35001f24, 0x4b184b00, 0x0f3908ed, 0x07141701, 0x07012f06, 0x35262706, 0x37262737,
+    0x36023f36, 0x021f3233, 0x05964607, 0x09605118, 0x36373424, 0x1595013b, 0x152c8518, 0x0796013e, 0x26050302, 0x06060509, 0x05072f2f, 0x05260905,
+    0x34070203, 0x07060418, 0x16341803, 0x69057e46, 0x8020062d, 0x8607296a, 0x20012115, 0x0ddad218, 0x82820121, 0x250539a1, 0x04040734, 0x03191803,
+    0x35070404, 0x07060525, 0x06300801, 0xc2083006, 0x0d645518, 0x3b8d4020, 0x0e1a0d19, 0x7a059347, 0x1728055f, 0x21001c00, 0x3c002600, 0x21085343,
+    0x8c180733, 0x1120086f, 0x3326f182, 0x37230131, 0x02820733, 0x21372328, 0x37230733, 0x64713505, 0xcd4e1806, 0x823d2008, 0x82202021, 0x555521b6,
+    0x8205f946, 0x15012605, 0x604a604a, 0x21048396, 0x058300ff, 0x88750121, 0x2129841b, 0x0f82a001, 0xb6aa2022, 0x0121ed85, 0x22078280, 0x85c000ff,
+    0x36162100, 0xfe201585, 0x22061a41, 0x8200aaa0, 0x41062000, 0x143108bf, 0x2a001f00, 0x5b003500, 0x00006000, 0x17322101, 0x248a8516, 0x26272221,
+    0x20b38435, 0x09da4517, 0x27261724, 0x0e850706, 0x15890320, 0x15210525, 0x18331523, 0x18135eae, 0x200b4bae, 0x24238217, 0x01600135, 0x208f8500,
+    0x200786ff, 0xce421868, 0x085c4907, 0xfe250888, 0x28000158, 0xc7a91828, 0x24ee8213, 0x015050a8, 0x210782c0, 0x4f8540fe, 0x82c00121, 0x18e02007,
+    0x850e204c, 0x4001210e, 0x20231689, 0x18604040, 0x200f6dad, 0x065f6c60, 0x40404023, 0x20008200, 0x065f6d03, 0x3e00a034, 0x60005000, 0x33130000,
+    0x16171415, 0x36373233, 0x845f013d, 0x23262505, 0x07060722, 0x840ae070, 0x8206201e, 0x2d188326, 0x2623011d, 0x34272627, 0x37361337, 0x334f3336,
+    0x4bd52122, 0x2b05cf41, 0x1011144b, 0x11112b07, 0x1826252d, 0x2408e141, 0x01070403, 0x2cdb8201, 0x0f0f18c9, 0x07760301, 0x01151010, 0x1f4b48ab,
+    0x1541a020, 0x0c402806, 0x0378140b, 0x7b231414, 0x16830644, 0x19180124, 0x5e820808, 0x0f014023, 0x2666820f, 0x0b144c01, 0x49b0fe0c, 0x50480f60,
+    0x41042011, 0x59220c17, 0x19416400, 0x255f4f40, 0x202f1d41, 0x0f1c418b, 0x41125648, 0x5b48411f, 0x0d3b4215, 0x21416920, 0x4f332052, 0x2641178c,
+    0x24a72140, 0x1636d918, 0x2d410120, 0x174b4641, 0x00820020, 0x29095742, 0x00450031, 0x00710064, 0x58180100, 0x7043098c, 0x07062405, 0x82150706,
+    0x43232002, 0x63430973, 0x013b270a, 0x2734011f, 0x7c432631, 0x08ab4305, 0xbd4f3720, 0x4c01202a, 0x4b2b0668, 0x07101114, 0x1c1d2c1f, 0x86021e01,
+    0x0a784312, 0x18014a21, 0x180c6e81, 0x201c38ce, 0x07284601, 0x140b0c2b, 0x1f1f0456, 0x2512192d, 0x50131980, 0x097a4308, 0x98454020, 0x181a8706,
+    0x38247862, 0x00000002, 0x01800201, 0x001e005b, 0x13000032, 0x36313736, 0x3635011f, 0x26058e37, 0x07060716, 0x18013521, 0x25125f8a, 0x0b0a0140,
+    0x048d6307, 0x090a8227, 0xfcfd1408, 0x06835e02, 0x2d5bfd20, 0x40022906, 0x040c4b01, 0x8a940903, 0xc327058f, 0x010f1011, 0x65f6feea, 0x39690677,
+    0x209b8206, 0x20038203, 0x309f8200, 0x00230080, 0x004c0028, 0x23111300, 0x37362726, 0x3a461833, 0x27148b0e, 0x1121013b, 0x23051121, 0x0e854618,
+    0x0c9a4618, 0x0d841120, 0x16385027, 0x08160202, 0x27059508, 0xa0012038, 0xf80160fe, 0x3d841f98, 0xfe800128, 0x16160280, 0x04832802, 0x04882020,
+    0xfe240e84, 0x30800180, 0x01201893, 0x43553284, 0x01002808, 0x000d00c0, 0x8248002f, 0x372622df, 0x25de8231, 0x0f161716, 0xca602301, 0x18312006,
+    0x20102791, 0x25238330, 0x17163330, 0x064a1731, 0x05913417, 0xc40a0404, 0x0504040a, 0xbb2f802f, 0x202a291f, 0x19010220, 0x08082a19, 0x20200237,
+    0x071e2a29, 0x05018006, 0x0f0f0406, 0x302f1110, 0x0e0e1110, 0x0e0e2f2f, 0x2f301011, 0x0f0f1011, 0xa7012e2e, 0x01070809, 0x09080701, 0x126f4747,
+    0x38372322, 0x079c5b52, 0x37385226, 0x04122223, 0x98200082, 0x4f853791, 0x2006374e, 0x2edb8280, 0x00420035, 0x005e004f, 0x007f0070, 0x82170100,
+    0x011d28dc, 0x27262726, 0x18360706, 0x8208f9a0, 0x32172d14, 0x23070637, 0x06070631, 0x21331507, 0x11272083, 0x3f363734, 0x821f3602, 0x180720a5,
+    0x20090a46, 0xf0451815, 0x1837200b, 0x220a955c, 0x71373635, 0x2308110a, 0x07262707, 0x16011f06, 0x2736013f, 0x01010f26, 0x0a117ddd, 0x2526180b,
+    0x0f2c3b2d, 0x25191901, 0x01191925, 0x18390783, 0x01062413, 0x0112121b, 0x14f0fe40, 0x0b010d0e, 0x8b7d110a, 0xfe8b1311, 0x94451883, 0x23098909,
+    0x10010fe0, 0x01200d88, 0x18116a4c, 0x300c14df, 0x1b5e013d, 0x110d0d05, 0x1414235e, 0x15210101, 0x3b73871d, 0x01181926, 0x013a290a, 0x601b1212,
+    0x140e0d01, 0x0d112301, 0x5d1b050d, 0x5e5d0a0a, 0x078d5018, 0x80010f22, 0xc0230a89, 0x65100f01, 0x20230561, 0x47f0010f, 0x11210f6b, 0x4ddf181c,
+    0x183c200b, 0x410c8b47, 0x79220983, 0x85418400, 0x110f6c5f, 0x4113e04f, 0x2257538a, 0x658c4123, 0x4b14d847, 0x8f41092f, 0x41892009, 0xfc47718d,
+    0x64924118, 0x41192048, 0x44486599, 0x09576a1a, 0x42003036, 0x5c004f00, 0x76006900, 0x33010000, 0x06151716, 0x17152307, 0x180af878, 0x2b0eb4a5,
+    0x36373635, 0x35373337, 0x33363734, 0x1258e018, 0x0ccc4a18, 0x4a180520, 0x062308d6, 0x44051507, 0x21200bce, 0x01320c8b, 0x010f7020, 0x5a500f01,
+    0x12121b66, 0x12120101, 0x545cb01b, 0x87b02007, 0x5a662411, 0x690e0909, 0xd0200fa8, 0x25089a44, 0x01700120, 0x0e86200f, 0x8a90fe21, 0x8a802017,
+    0x01c0270b, 0x010f300f, 0x62834010, 0x5983e020, 0x08ca5f18, 0x12887020, 0x0e404024, 0x42180909, 0x202010c3, 0x20099b44, 0x41551850, 0x89302009,
+    0x20098915, 0x0c8f4400, 0x37000e2c, 0x51004400, 0x82006300, 0x61418f00, 0x07062305, 0x4a582623, 0x27152405, 0x46021f36, 0x06220a26, 0x19461507,
+    0x41032014, 0x1d210a47, 0x200c8a01, 0x215d1815, 0x05b0573d, 0x34053741, 0x1122010f, 0x117d8b13, 0x20010b0a, 0x1f30301f, 0x021e0120, 0x0f274640,
+    0x6441de20, 0x20098909, 0x07e645f0, 0x5d180787, 0x01211c4c, 0x08d84520, 0x100f0137, 0x5d0a0a9b, 0x0d0d051b, 0x202f6211, 0x20010120, 0x121a2f20,
+    0x10274625, 0x41f5fe21, 0x80200973, 0x88200a89, 0x830bd746, 0x5948207c, 0xe35c22ea, 0x80012905, 0x1700c001, 0x2e002300, 0x26080f4a, 0x17162137,
+    0x4e111716, 0x112b0a91, 0x010f2637, 0x3f161706, 0x48273601, 0x0d840681, 0x35071324, 0x58180033, 0x802e0944, 0xa009090e, 0x0112121b, 0x600b0bab,
+    0x04840a0a, 0xa0200784, 0xa0230c83, 0x18808075, 0x2509749c, 0x0909e0fe, 0x3b84800e, 0x0a0b8025, 0x850b600a, 0x83362004, 0x84a02007, 0xebfe2304,
+    0xa3828080, 0xc0ff1024, 0xa382f001, 0x1100082b, 0x3b002d00, 0x36370000, 0x28a01837, 0x1903200e, 0x25099a17, 0x22230607, 0x01832627, 0x82363721,
+    0x313324ad, 0x83152707, 0x823620cd, 0x07352335, 0x7e18c723, 0x7120074c, 0x08057b41, 0x38010f29, 0x11cd0709, 0x11100402, 0x09603131, 0x5f090808,
+    0x10103132, 0xcc120104, 0x40210808, 0x291b1b01, 0x011b1b2a, 0x6cb04140, 0x078707e8, 0x0410013a, 0x32140757, 0x49494b4a, 0x2d04042d, 0x4a4b4949,
+    0x57071432, 0x8040d004, 0x2108d064, 0xbf8c0040, 0x3d00242b, 0x00004b00, 0x26070625, 0x20c38327, 0x24b69a27, 0x35170703, 0x22b48433, 0x82232726,
+    0x152328ce, 0x07060706, 0x84312722, 0x055250ce, 0x07062324, 0xc7822001, 0x0f020225, 0x9920010f, 0x125f23c7, 0x295a3081, 0x07402b05, 0x012d1409,
+    0x071c1211, 0x7a4b1207, 0x0e302306, 0xd387f002, 0xd295d020, 0x22e2fe36, 0x16014040, 0x0f202217, 0x01110e01, 0x12121b40, 0x306e0201, 0x23053e51,
+    0x000f0140, 0x02210082, 0x07a74100, 0x33001b25, 0x9a010000, 0x371322da, 0x24d08236, 0x0f060726, 0x28078501, 0x011f0607, 0x01313716, 0x38c29900,
+    0x0115620a, 0x19151802, 0x0a0a141a, 0x151a1b13, 0x15010118, 0x010a0c60, 0x08b196c0, 0x17639529, 0x12151e1e, 0x09140302, 0x02031409, 0x1e1e1512,
+    0x0a0a6317, 0x00040000, 0x01e0ff00, 0x00a001c0, 0x002d0015, 0x184e0043, 0x4a11cfa6, 0xbc520588, 0x16172b06, 0x013d3637, 0x07062726, 0xb2822715,
+    0x1731072d, 0x37361716, 0x37363335, 0x86232726, 0x561b8206, 0x1a8405bc, 0x20050f43, 0x07ae4540, 0x83c0fe21, 0x01403109, 0x42010f0f, 0x010b0c06,
+    0x41020e0f, 0x010b0b07, 0x200a9b56, 0x06c84330, 0x0891c118, 0x09bf0919, 0x0ba79d18, 0x83a05021, 0x6e662527, 0x0c03030a, 0x50200a8f, 0x4f445f83,
+    0x84a02006, 0x2104851c, 0xef8a0300, 0x48002722, 0x0ced9b18, 0x08e67b18, 0x5d213721, 0x2843056a, 0x27262407, 0x83172726, 0x010f22ee, 0x26ef8206,
+    0x3f363716, 0x42161701, 0x2622078e, 0x2e820627, 0xca431520, 0x25e2840a, 0x1b121201, 0x63184001, 0xa14608be, 0x29202a07, 0x0711100c, 0x04040530,
+    0x2800820c, 0x14361c07, 0x12131c1b, 0x08db7001, 0x9e18a020, 0x4020138e, 0x260f026c, 0x020b2ad3, 0x83600f03, 0x2a498341, 0x01133738, 0x661c1312,
+    0x840f1018, 0x413b2049, 0x11290ad7, 0x30001a00, 0x00007300, 0x8d4d1837, 0x43172010, 0xec760779, 0x18112005, 0x2308c059, 0x36373611, 0x83060441,
+    0x161721f6, 0x0622e082, 0xfb831607, 0x17060722, 0x0983ff82, 0x24831720, 0x0d833620, 0x82262721, 0x3736212e, 0x83066644, 0x4c272031, 0x312005dd,
+    0x0cc77b18, 0x08355c18, 0x0c426820, 0x0529410d, 0x1202b836, 0x11111113, 0x080f0e0e, 0x02161608, 0x08161602, 0x0e0e0f08, 0x13211282, 0x220d8312,
+    0x87130102, 0x1707211f, 0x17211f83, 0x211f8707, 0x2d820113, 0xaa560220, 0x06864306, 0x37824184, 0x41000121, 0x56201350, 0x7c8f5c99, 0x9c8f5c85,
+    0x00820020, 0x00000230, 0x8001c0ff, 0x6100c001, 0x00006a00, 0x846f3313, 0x07084307, 0x11910720, 0x26070624, 0x6118012f, 0x2731090d, 0x26272623,
+    0x36373627, 0x17161537, 0x06232733, 0x25108807, 0x31342733, 0x1a823530, 0x17323334, 0x31141716, 0x07011d30, 0x07062726, 0x37361716, 0x534541df,
+    0x28282807, 0x0f01010f, 0x87280444, 0x10102110, 0x22081083, 0x1002032c, 0x2801020d, 0x010b0c10, 0x100c0b01, 0x28130124, 0x01011c1b, 0x02221716,
+    0x2905120e, 0x42102310, 0x6a30072b, 0x09090102, 0x08090d0d, 0x0f019001, 0x0e02020e, 0x90203f82, 0x2307fc69, 0x0f0f0150, 0x0a6a1782, 0x820d8506,
+    0x200f211f, 0x20052f6c, 0x24278320, 0x071a1a24, 0x2125825f, 0xc442021e, 0x01102c07, 0x09080d01, 0x010d0809, 0x45301001, 0x4918074c, 0x43270d6f,
+    0xa6005500, 0x18130000, 0x23104a7e, 0x011f3227, 0x2305086f, 0x14151617, 0x09a24518, 0x59222321, 0x3f25050c, 0x35262701, 0x0aec7634, 0x18153121,
+    0x2010c65d, 0x5c531805, 0x21332110, 0x5009ef52, 0x7741054c, 0x5e352005, 0xf918058d, 0x342816fd, 0x06272627, 0x11150607, 0x56062c6d, 0x2038054a,
+    0x3918050a, 0x0307070a, 0x09093816, 0x07031638, 0x18390a07, 0x040b0a05, 0x04211591, 0x07e9420b, 0x01220787, 0x50186858, 0x01210d89, 0x215585a8,
+    0xe3430117, 0x01172608, 0x11221716, 0x2305830f, 0x01161722, 0x2b85198b, 0x95180120, 0xa0200c46, 0x04218488, 0x209aa00b, 0x0fa571e0, 0x0cb43c19,
+    0x9b85b020, 0x210c152f, 0x1415160f, 0x0f161514, 0x21160c21, 0x21818217, 0x06841807, 0x21171723, 0x2e1c8b36, 0x09090d36, 0x09090101, 0x00effe0d,
+    0x82000300, 0x40022900, 0x16008001, 0x2c002800, 0x08777d18, 0x250a5745, 0x17161716, 0xa1182515, 0x35251103, 0x40020733, 0x217d8280, 0x2941a0fe,
+    0x83c02008, 0x8cfe2009, 0x600124ea, 0x49a08080, 0x00200827, 0xa0212a87, 0x08e45760, 0xff234282, 0x7e808000, 0xbf260887, 0x35001400, 0x09784700,
+    0x72971809, 0x4331200d, 0x362405a2, 0x33373637, 0xe4499b84, 0x20b18905, 0xbf5b1931, 0x21ac8212, 0x931802e0, 0x5041089b, 0x86a02107, 0x0788a418,
+    0x97838520, 0xc590cc8d, 0x135c0127, 0x0b131c1c, 0x2a05830b, 0x01111119, 0x19111101, 0x83121c1c, 0x1c122108, 0xe68e5283, 0x0c662919, 0xff18e184,
+    0x16200bff, 0x42080c82, 0x16011f36, 0x07161317, 0x27012b06, 0x27222115, 0x36133726, 0x0d01013f, 0x0be01313, 0x09012002, 0x80800e0a, 0x0a0e00ff,
+    0x02200109, 0xba01e00b, 0x0a9f0c0c, 0x0ee0fe0e, 0xe0e00b0a, 0x010e0a0b, 0x180a0e20, 0x4b086f7c, 0x34280503, 0x00003800, 0x010f1613, 0x0e21db18,
+    0x36371525, 0x83173117, 0x011f216f, 0x11fe4c18, 0x75823720, 0x2733133e, 0x0f0df215, 0x50101050, 0x12100d0f, 0x0a070727, 0x11290117, 0x13137b11,
+    0x18020ba8, 0x080d0143, 0x02188025, 0x4d13a80b, 0x1150014d, 0x0c0c4811, 0x0f111148, 0x0a7a240d, 0x16020707, 0x0f0d247a, 0x800e0e17, 0x19a50c08,
+    0x260c0b10, 0xfe80080c, 0x458080c7, 0x02290783, 0x00c00140, 0x00390022, 0x3c621800, 0x7421200a, 0xe07408c8, 0x74212006, 0x072305f3, 0x41011f16,
+    0x23230625, 0x82262722, 0x3302821c, 0x3802011f, 0x12500808, 0x220f0d10, 0x0f216dfe, 0x5011110d, 0x11280f82, 0x210f0d11, 0x0f229301, 0x5021c482,
+    0x2ab9825d, 0x0f090a02, 0x0fbf6160, 0x84020a09, 0xa81333b5, 0x0b077201, 0x0d48070b, 0x1e10120f, 0x0f12101e, 0x0f8f480d, 0x0c08d92c, 0x0b0b0fa0,
+    0x0b0ba0a0, 0xb982a00f, 0x0023cf82, 0x18000200, 0x27070745, 0x00370020, 0x16211300, 0x0a414918, 0x90272621, 0x950520bc, 0x015730b5, 0x22223371,
+    0x16160201, 0x14140102, 0x8e8ffe1f, 0x958420ba, 0x01782eb3, 0x28332222, 0x16020216, 0x14141f28, 0x20b78f01, 0x30b193df, 0x00030000, 0x02c0ff07,
+    0x00c00138, 0x002b0015, 0x0e1b4242, 0x16373629, 0x36371517, 0x42213117, 0x15880b31, 0x20167641, 0x092542d2, 0xc5832820, 0x11112824, 0x13916001,
+    0xc7955720, 0x830c3142, 0x247a23ce, 0x45420f0d, 0x2013870b, 0x41d193b7, 0x80200583, 0x1222cf82, 0x41432900, 0x071b4206, 0x012f2626, 0x13372726,
+    0x21157541, 0xc7428d01, 0x0a022c05, 0x07920f09, 0x0da81404, 0x860ea10e, 0x606121a1, 0x230c1d42, 0x800e0eb9, 0x29287b85, 0x0980101a, 0xe0fe7a03,
+    0x00218a93, 0x4f661803, 0x000d2408, 0x1827001c, 0x240dd5c6, 0x11053521, 0x07c47306, 0x11272623, 0x210b8221, 0x375e0706, 0x09003105, 0x00010e09,
+    0xfe09090e, 0x024001c0, 0xe0021616, 0x01220483, 0xd04d4040, 0x7c012007, 0x20240644, 0x78fe4020, 0x2209e857, 0x4f908801, 0x0020092f, 0x2306ab56,
+    0x00c00140, 0x35247f85, 0x4f004400, 0x20087d5f, 0x05116721, 0x8c210721, 0x0acf5e86, 0x95602520, 0x2027a005, 0x20a882e0, 0x23b283ff, 0x0001e0c0,
+    0xa020a883, 0xb0200483, 0x7020ab88, 0xc0201f9e, 0x2021ed82, 0x20248220, 0x18cb8e60, 0x20097db5, 0x3922a1f0, 0x07000000, 0xc1ff0000, 0xbf014002,
+    0x35001a00, 0x5d005800, 0x73006100, 0xf1828500, 0x31171623, 0x05c46d16, 0x07060725, 0x72262706, 0x3724055a, 0x21311736, 0x16200382, 0x85050f74,
+    0x36372d18, 0x26273435, 0x31373637, 0x31071603, 0x2f222d84, 0x36872301, 0x26133722, 0x22085748, 0x83130714, 0x27332719, 0x27072733, 0x60821714,
+    0x09835685, 0x21311523, 0x224f8314, 0x82373637, 0x2968826c, 0x3f311516, 0x0505050c, 0x04821010, 0x0c0d0c2c, 0x1515050c, 0x0d0c0c05, 0x0b89c201,
+    0x24221f89, 0x1c820405, 0x060c0c27, 0x0615dc15, 0x8200820c, 0x0c89210f, 0x39079546, 0x0e6c890c, 0x77a20e86, 0x6226264c, 0x1513070b, 0x0b0f0f0b,
+    0x0b071315, 0x07844001, 0x01010a23, 0x2915840a, 0x0c06be01, 0x2d270d0b, 0x6382262d, 0x05040628, 0x3a320c05, 0x6582323a, 0x0b8b0420, 0x0d2a5f82,
+    0x272d2d26, 0x060c0b0d, 0x6b822ffe, 0x6c820620, 0x2d2d0c23, 0x8206820c, 0x010c241b, 0x4715102e, 0x15340794, 0x53d2fe10, 0x53602020, 0x191da053,
+    0x13080916, 0x23272723, 0x15227982, 0x07821d19, 0x16090827, 0x191d1d19, 0x21938215, 0x47612723, 0x01003208, 0x003b00c0, 0x0045003f, 0x004d0049,
+    0x13000058, 0xc6b91836, 0x14152207, 0x86361907, 0x3122240d, 0x82012b30, 0x7d312004, 0x3b220729, 0x0a833701, 0x26013d3a, 0x36372627, 0x2713013f,
+    0x17273307, 0x0f232737, 0x1f273702, 0x27072701, 0x08124a18, 0x0ef22325, 0x820ca00e, 0x130a27da, 0x050e0909, 0x91464520, 0x015f2305, 0x6d5cfe01,
+    0x20452207, 0x39148205, 0x04050a13, 0x49a00c04, 0x7a753a3b, 0x74053f3f, 0x2e0b0905, 0x0b2d6e23, 0x1a197622, 0xa02c086a, 0x0606bd01, 0x0c0c0750,
+    0x5001110c, 0x2b4a3282, 0x220c830c, 0x82110150, 0x5007331c, 0x313143fe, 0x1c3535a4, 0x2643371c, 0x43261d1d, 0x6918f01d, 0xea18090e, 0x882016af,
+    0x66afea18, 0x4b071421, 0x23200514, 0x20076463, 0x0579613d, 0x42373621, 0x012209c2, 0xea180120, 0xe03653b0, 0x01022002, 0x10221716, 0x0e0d090a,
+    0x23100909, 0x02011616, 0x6818011f, 0x481808b6, 0x601808c7, 0x8d821051, 0xea180120, 0xf02437b4, 0x29170709, 0x1c456a83, 0x01a02806, 0x29231616,
+    0x4d090717, 0x00200746, 0x21080082, 0xff000001, 0x010002c0, 0x002500c0, 0x17072500, 0x07060716, 0x26270605, 0x37361337, 0x37011f36, 0x44783526,
+    0x063b080b, 0x31272223, 0x42635801, 0x1005040c, 0x0e1300ff, 0x0650050d, 0x410d1211, 0x5f0b0b63, 0x151c1b16, 0x0b601414, 0xeb0b0f0f, 0x120d4163,
+    0x05500611, 0x01120e0d, 0x04051100, 0x8363420c, 0x14602917, 0x1b1c1514, 0x0b0b5f16, 0xbf4a7a82, 0x2d7b8306, 0x00370021, 0x0063004d, 0x1d161300,
+    0x77183301, 0x152e0ea3, 0x2f060714, 0x36272601, 0x1736013f, 0x76181731, 0x18820a34, 0x66062f7e, 0x2120151b, 0x8205b145, 0x21232126, 0x08fd8e18,
+    0x0ff12125, 0x19180759, 0x3208c535, 0x59071858, 0xc0100f0f, 0x11010111, 0x2f0f10c0, 0x410e0909, 0x0e22072f, 0x0a860909, 0x3b436020, 0x43602005,
+    0xff200738, 0x28068f64, 0xbb010001, 0x16481209, 0x07d74c02, 0x4816022f, 0x07090912, 0x13130a60, 0x0907600a, 0x258718fb, 0x8280200d, 0x60ab185c,
+    0x2020890e, 0x066f6900, 0xc001802c, 0x38003200, 0x5c004a00, 0xa9527100, 0x3315260c, 0x16011f32, 0x078f4a1d, 0x18012b21, 0x20077740, 0x2b088823,
+    0x27262726, 0x27350511, 0x05331523, 0x1910324e, 0x22115823, 0x18072603, 0x20113772, 0x99751800, 0x19332409, 0x85134d14, 0x422020a2, 0x6f1807ad,
+    0x102a08f8, 0x010d0e14, 0x334d2002, 0xe818fe80, 0x08191013, 0xe02c11ee, 0x0e0e1110, 0x0216a627, 0x27a61602, 0x18062c7d, 0x250abe57, 0x134d1330,
+    0x004b731a, 0xc8701805, 0x238f850f, 0x604d13d0, 0x102f4318, 0x20108775, 0x28658201, 0x02281011, 0x27021616, 0x050b7e11, 0x82005021, 0x00052500,
+    0x02c0ff00, 0x206b5b41, 0x087f4125, 0x59522620, 0x41312008, 0xfe33555b, 0x14141ff0, 0x15140201, 0x110b0d11, 0x01021415, 0x761f1414, 0x5a41092d,
+    0x01603847, 0x151d1312, 0x0d162121, 0x2121160d, 0x12131d15, 0x04000001, 0x68ff0000, 0x422605cf, 0x59004700, 0x70186b00, 0x33240a19, 0x14011f16,
+    0x2005667c, 0x06434d15, 0x7c13b342, 0x3321068f, 0x07a24335, 0x05353722, 0x3127c042, 0x12120120, 0x1225e01b, 0x35122934, 0x121b0401, 0xad420112,
+    0x0d9d4e17, 0x2b2bb625, 0x5bcafe56, 0xb5420f51, 0x05955511, 0x021e0225, 0x82027724, 0x201a24fe, 0x820e090a, 0x0fa14261, 0x15830920, 0x82200a21,
+    0x0d602706, 0x1f010909, 0xaa426080, 0x06002122, 0x37083b41, 0x00480043, 0x006c005a, 0x009c0083, 0x17160100, 0x011f1633, 0x15321706, 0x4105af4f,
+    0x332b2b3b, 0x36373635, 0x15173337, 0x55232733, 0x134411e0, 0x26032111, 0x654b2582, 0x16172105, 0x09eec318, 0x19389318, 0x6c414020, 0x41012006,
+    0x12272b6e, 0x40e01b12, 0x182b2b56, 0x4108a755, 0x71410779, 0x18e32011, 0x18086a93, 0x271d7393, 0x1e02a001, 0x01772402, 0x5d820082, 0x41067d65,
+    0x09201497, 0x60291c83, 0x2009090e, 0x0112121b, 0x239a4160, 0x18290121, 0x442faf93, 0x273a095f, 0x51004700, 0x63005a00, 0x1d010000, 0x17163102,
+    0x27171415, 0x26270607, 0x1d19013d, 0x36210df7, 0x05507537, 0x48613120, 0x071d4f05, 0x07061527, 0x35272623, 0x82078623, 0x0717280a, 0x27262733,
+    0x83070623, 0x27262529, 0x17160706, 0x363c0484, 0x01272637, 0x021d0300, 0x06085b5a, 0x7b320607, 0x08060708, 0x0f100188, 0x0f101818, 0x2d05ca48,
+    0x0e140001, 0x1e02010d, 0x16101602, 0x0584a002, 0x50021e2b, 0x0610e010, 0x060e980e, 0x074056c8, 0x4956d020, 0x6a260808, 0x22e40161, 0x06082111,
+    0x05021e1d, 0x08200804, 0x25522804, 0x08050503, 0x51050940, 0x1d1d1a6b, 0x1d1d0202, 0xbf415a1a, 0x21e02307, 0x3b832b0c, 0x83282821, 0x0c2b2b05,
+    0x314fe021, 0x01010e31, 0xa96b910e, 0x00002110, 0x3309c77d, 0x0015000a, 0x003a0027, 0x0062004b, 0x00860074, 0x37361300, 0x0625ff82, 0x27262107,
+    0x220a8911, 0x18071413, 0x700e0b50, 0x33220542, 0xef821732, 0x22230728, 0x31352627, 0x62443625, 0x07142a05, 0x26012b06, 0x07272627, 0x052c7616,
+    0x44012b21, 0x37200659, 0x32222182, 0x4c903717, 0x37340523, 0x05824131, 0x25063f47, 0x16020035, 0xc9835002, 0x83b0fd21, 0x220b8905, 0x181213d3,
+    0x08087945, 0x13121b27, 0x121201b3, 0x0e13601b, 0x0813141c, 0x09090e56, 0x120e8001, 0x12121b60, 0x0e090901, 0x15140952, 0x1233191c, 0x210c8206,
+    0x1c82e00d, 0x30120528, 0x0b600e0b, 0x438dac0a, 0x17bffe31, 0x16222217, 0x17010117, 0x17222216, 0x18a80117, 0x2008a5bd, 0x088e4130, 0x5b554820,
+    0x84a0200f, 0x170c2365, 0x6a821e16, 0x01093722, 0x62828782, 0x17171e28, 0x300e190b, 0xfd44110f, 0x0f112605, 0x02030e2f, 0x763b8f82, 0x16200551,
+    0x099cc218, 0x234e0020, 0x05bf4505, 0x2400112d, 0x4c003500, 0x70005e00, 0x56008400, 0x072005b5, 0x25054156, 0x17163736, 0x7b411516, 0x1801205e,
+    0x41125c67, 0x6e206376, 0x210da953, 0x895b4002, 0x07404109, 0x204c7441, 0x5ab618fe, 0x0a00290f, 0xc1ff0000, 0xc0017f02, 0x153d0982, 0x2c002100,
+    0x5c003e00, 0x7e006f00, 0x9e008c00, 0x16130000, 0x012f0607, 0x1f363726, 0x06811801, 0x0540580b, 0x26270622, 0x0c494718, 0x11946618, 0x35361727,
+    0x3b323332, 0x27048201, 0x16171633, 0x16311417, 0x25055a44, 0x37363734, 0x03432731, 0x17312110, 0x22065d43, 0x82362726, 0x05332221, 0x43088223,
+    0x06220562, 0xf3183107, 0x70391100, 0x11100f0f, 0x110e0e48, 0xe7014711, 0x0f0f1011, 0x0e111048, 0xb0fd480e, 0x210c8348, 0x0c821147, 0x82080221,
+    0x4810211e, 0xfe212884, 0x0f9d57f1, 0x05010a3b, 0x50020303, 0x04030302, 0x01010f27, 0xb0160204, 0x0e040216, 0x0d0e8a28, 0x07674415, 0x0d152008,
+    0x0b0e5b0e, 0x06111119, 0x01021938, 0x46160f0f, 0x0e382a01, 0x460d0d34, 0x010f0f16, 0x5c651902, 0x01210f3c, 0x207d8871, 0x859c8548, 0x8330207d,
+    0x208a850c, 0x84a78427, 0x43f020b1, 0x62320f2a, 0x22090101, 0x0b010103, 0x0202160d, 0x250b0d16, 0x2c487209, 0x0650270f, 0x1a13130a, 0x80831902,
+    0x15355023, 0x21958306, 0x73180219, 0x2e870814, 0x0ef3a618, 0x30002222, 0x2306eb47, 0x00980082, 0x094f6c18, 0x46343521, 0x6543060d, 0x2726210d,
+    0x2208df44, 0x82230706, 0x06dc440d, 0x30830a82, 0x2008d841, 0x41481831, 0x05eb4711, 0x1907ae5b, 0x570e3e1f, 0x212009fc, 0x34053e6d, 0x36373221,
+    0x27341135, 0x22212326, 0x11150607, 0x0e0d01e0, 0xa3501814, 0x83802009, 0x414620dd, 0x2b200981, 0x25087941, 0x17340e38, 0xb4410f29, 0x280f2106,
+    0x2008ca41, 0x0f91418c, 0x4100ff21, 0x01210ff8, 0x07af4720, 0x1840fe21, 0x23082c78, 0x0920fec0, 0x8206617b, 0x40fe2607, 0x0109090e, 0x0f7b4110,
+    0x0f168524, 0x7f41010f, 0x412f2006, 0x35240679, 0x260a1a15, 0x2107af41, 0xdc640a26, 0x203b8708, 0x0fe34110, 0x296bc020, 0x20098309, 0x21838401,
+    0x0e4460fe, 0x3cf01805, 0x9bd4180b, 0x00103909, 0x00320023, 0x00570040, 0x007b0069, 0x009d008c, 0x130000ae, 0x27260706, 0x26053c54, 0x07061716,
+    0x43171523, 0x07202e53, 0x26213482, 0x0ccf4127, 0x16171623, 0x116a4315, 0x4505d049, 0x17290a93, 0x33373637, 0x1d161732, 0x24838401, 0x01272623,
+    0x2c838433, 0x3d262722, 0x16373601, 0x33211517, 0x47078435, 0x3630061e, 0x16023037, 0x09090216, 0x0216680e, 0x50581602, 0x202a6443, 0x05994355,
+    0x230ae441, 0x10040f29, 0x190fe741, 0x26103258, 0x68160260, 0x8309090e, 0x16582476, 0x8250fe02, 0x22118904, 0x8b58c801, 0x3801218f, 0x2e889583,
+    0xf8412820, 0x1574430f, 0xa4431820, 0x0a262605, 0x0d0b260a, 0x41338fb8, 0xa82010f8, 0x0223ff8a, 0x4148fe16, 0x9d8c0c10, 0x2b05df4c, 0x010002c0,
+    0x001f00a0, 0x00360024, 0x07f13119, 0x155a3b20, 0x06153508, 0x06171407, 0x26272607, 0x27221127, 0x17313526, 0x15233533, 0x1811a26c, 0x200ffb42,
+    0x09387600, 0x0f011f30, 0x1b29331c, 0x090e011b, 0x40406009, 0x9472a001, 0x0ffd7b0f, 0x82060570, 0x2cab272e, 0x27212639, 0xb0180102, 0x8022074c,
+    0x9d736060, 0x00052620, 0x02c0ff20, 0x2ad38221, 0x004f004a, 0x00a30091, 0x470000ac, 0x1535097e, 0x15060706, 0x31141714, 0x30313330, 0x01391423,
+    0x31303322, 0x21138422, 0x09821716, 0x3431332f, 0x30313015, 0x15353215, 0x31303122, 0x25fc8b06, 0x3b363734, 0xff820701, 0x16373322, 0x23054562,
+    0x06071617, 0x25820983, 0x15565782, 0x49072005, 0x4561066f, 0x051a6405, 0x37362722, 0x27250182, 0x17363726, 0x22098316, 0x5d073137, 0x43821042,
+    0x4a171621, 0xa54305f5, 0x04052405, 0x82011010, 0x10182100, 0x18200082, 0x01240882, 0x2b1c0111, 0x28064941, 0xc00e0909, 0xc0404040, 0x20556116,
+    0x95610220, 0x0c394e1c, 0x9a494020, 0x82a02008, 0x2d85825f, 0x1104036f, 0x01111617, 0x18101001, 0x8d840f18, 0x12010124, 0x92411d17, 0x22248209,
+    0x616060a0, 0x08211cec, 0x0d0c6216, 0x20138f61, 0x0b1d5ca2, 0x08958918, 0x280ddb50, 0x005f000a, 0x007a0071, 0x11231985, 0x06172a0d, 0x30151407,
+    0x012f0615, 0x13231907, 0x214b8240, 0x5a182f26, 0xfb6d120b, 0x10a03414, 0x580e0e11, 0x0f0f1011, 0x1a205958, 0x2e011818, 0x191f0d24, 0x27373523,
+    0x2b460607, 0x190c090b, 0x750f1c43, 0x402012b1, 0x0b562319, 0x290c0428, 0x01010132, 0x23192207, 0x18242959, 0x2e080618, 0x0e592319, 0x0b060527,
+    0x0c090634, 0x0f8f6f8a, 0x2d14026e, 0x20000200, 0xe001c0ff, 0x3d00c001, 0xe1564600, 0x4211200c, 0xad6107fc, 0x4e118809, 0x42780712, 0x26232709,
+    0x37272627, 0xf7420706, 0x1b013007, 0x2626291b, 0x0101191a, 0x3a3a2627, 0x62012726, 0x844505a4, 0x25158c08, 0x1b1b2920, 0xb1427801, 0x83602008,
+    0x1901250e, 0xe2fe261a, 0x41833983, 0x0b115023, 0x2041820c, 0x073345a8, 0x188ea820, 0x6f83b820, 0x08008118, 0x4c064753, 0x1328052f, 0x41002700,
+    0x74005a00, 0x180b3b44, 0x20091773, 0x12ce4b11, 0x62362521, 0xf87b09f7, 0x823f2007, 0x31372286, 0x05cd4a05, 0x8c161721, 0x972e8416, 0x47022032,
+    0x787406a9, 0x0fc84b09, 0x11a7fd2e, 0x11373711, 0x360f0f10, 0x100f0f36, 0x11280b83, 0x37370e0e, 0x39010e0e, 0x3821168b, 0x23168610, 0x87381011,
+    0x1b940382, 0xe6650120, 0x60fe200c, 0xf9200cab, 0x3a915585, 0x15916b83, 0x1b952d85, 0x73650020, 0x01402608, 0x001100c0, 0x0a234a4c, 0x1e422720,
+    0x22032507, 0x3f263127, 0x0c9e5818, 0x095b5618, 0x18012f21, 0x180d115f, 0x290cfb58, 0x1101df23, 0x131a1c12, 0xc8180112, 0x99200789, 0x2f80c818,
+    0x04681220, 0x07514909, 0x18b0fe21, 0x212e43c8, 0x3b6a0050, 0x846f2005, 0x184a20e3, 0x27137354, 0x32171607, 0x013f3637, 0x7218f382, 0x31202c17,
+    0x49050c67, 0x64320bec, 0x191f1311, 0x0812111a, 0x0b0c0d0c, 0x12070302, 0x4b452d1c, 0x06355205, 0x141c2b2f, 0x0b020307, 0x080d0c0c, 0x01241713,
+    0x27e09102, 0x0e01056a, 0x0c1b1a0e, 0x44833c82, 0x162b1b24, 0x2319fefe, 0x01240d8b, 0x1c2a1503, 0x49834183, 0x0d201e23, 0x08c74101, 0xe382ff20,
+    0x21001d22, 0x362ce382, 0x27263127, 0x06070621, 0x2315011f, 0xe2820682, 0x36333f08, 0x26272637, 0x37352327, 0x07212707, 0x080ff601, 0x44fe1708,
+    0x0f080817, 0x0e1430d6, 0x0f01010d, 0x01010fe0, 0x2f140d0d, 0x0195f6d4, 0x8601952a, 0x02131312, 0x12131302, 0x0d01b0d6, 0x1c82140e, 0x27830f20,
+    0x9bd6b024, 0x72829595, 0x77820020, 0xcf59ff20, 0x182d2005, 0x230f9bb7, 0x05351732, 0x08aa5818, 0x36373623, 0x20108237, 0x31068234, 0x32333625,
+    0x03151617, 0x1b01ff01, 0x1b28281b, 0x0783011b, 0xff0f112a, 0x1b1b0200, 0x1a1b2929, 0x07260f86, 0x3f010a06, 0xf7820506, 0x22510131, 0x01011617,
+    0x22211716, 0x05011616, 0x86d04c92, 0x8422200f, 0x0be72b0f, 0x5f030908, 0x0e090901, 0xcf42b1fe, 0x00022708, 0x1c00bf01, 0x95822e00, 0x82362721,
+    0x272624f2, 0x48060726, 0x162a061a, 0x33161737, 0x35363732, 0xbf4e2734, 0x01210811, 0x092a77f4, 0x4631310b, 0x1f373845, 0x310a081e, 0x3e534630,
+    0x10100c78, 0xfe0c0c0c, 0x2425015b, 0x35921836, 0x24363807, 0x78040125, 0x3046533e, 0x1e080a31, 0x4538371f, 0x0a323146, 0x82772a09, 0x202e8229,
+    0x841f83ec, 0x8327822f, 0x309b8307, 0xff000001, 0x010002e0, 0x001f0095, 0x36351300, 0x21018237, 0x88191617, 0x22080993, 0x0f061517, 0x22230601,
+    0x2726012f, 0x21010031, 0x21223421, 0x0b0c1921, 0x2321201a, 0x01212134, 0x83b42f01, 0x2fb4318a, 0x06010101, 0x0a272636, 0x190a0a05, 0x0a190c0c,
+    0x272b0882, 0x41063626, 0x0b0ba92c, 0x85412ca9, 0xff182b6b, 0x012802c0, 0x001e00c0, 0xd5420100, 0x0ff14405, 0x36023f23, 0x087e8237, 0x907d0141,
+    0x0d050713, 0x10031868, 0x80811110, 0x020f1012, 0x060e6819, 0x40901306, 0x0914130a, 0x162a0140, 0x0e131203, 0x0c139366, 0x4444090b, 0x130c0b09,
+    0x130e6693, 0x84160312, 0x11010111, 0x82020084, 0x01c021d7, 0x00250182, 0x00240011, 0x10297100, 0x23011f2d, 0x07060706, 0x33161714, 0x77373221,
+    0xe02005a1, 0x39084841, 0x01012425, 0x33362524, 0x31314966, 0x0f0a0a02, 0x0a0f7a01, 0x3131020a, 0x1683c049, 0x3020268b, 0x1c821583, 0x2b832482,
+    0x82090021, 0x01e03677, 0x00a001ff, 0x00210014, 0x003b002e, 0x00550048, 0x006f0062, 0x20f3827c, 0x21738321, 0xfa821611, 0x82362121, 0x34113274,
+    0x01272627, 0x26230706, 0x37363527, 0x17151633, 0x220c8935, 0x8937011d, 0x1f15210c, 0x1721268a, 0x22268a15, 0x83171517, 0x013d2126, 0x17224083,
+    0x33892715, 0x2008268c, 0xcf01011d, 0x0d1460fe, 0x0d01010d, 0xa001140d, 0x0e0e0e14, 0xa0fe150d, 0x07300701, 0x2f070101, 0x91048208, 0x01f02209,
+    0x0a586d0f, 0x20060e5f, 0x202e8270, 0x82038407, 0x842f2033, 0x2004873d, 0x20478206, 0x60c818a0, 0x88fe2113, 0x60842283, 0x94803021, 0x83f8200a,
+    0x8460205d, 0x89c02004, 0x94c8200a, 0x49418a2b, 0xe02007ff, 0x086f1c19, 0x24001f24, 0xf36d2900, 0x23152417, 0x84353315, 0x35272104, 0x07210a82,
+    0x20058233, 0x08ca6d01, 0x6880fe21, 0x80210898, 0x200082a0, 0x220382e0, 0x6d01a0a0, 0x802515ae, 0x8080c080, 0x82058440, 0x000a2184, 0x25054743,
+    0x001500a0, 0x8385001a, 0x33002e28, 0x3d003800, 0x8d974200, 0x82820520, 0x83173521, 0x83372083, 0x88052009, 0x20138409, 0x951d8d07, 0xd8fe34a6,
+    0x58385858, 0x5858f058, 0x585880fe, 0x405858e8, 0x87d05858, 0x20b99612, 0x20008640, 0x890786c0, 0x00002206, 0x7dc79607, 0x25730535, 0x09436e06,
+    0x2524a884, 0x35211521, 0x098ebc84, 0x12010024, 0x4d461b12, 0x055e4109, 0x01296d82, 0x0100ff80, 0x4080fe00, 0x70098f40, 0xa0851505, 0x0585ae85,
+    0x00303e82, 0xc0012000, 0x1a006001, 0x16010000, 0x07143115, 0x2706a644, 0x36373435, 0x011f3233, 0x172e0583, 0x09b70131, 0x0a00ff09, 0x800a0d0d,
+    0x06830909, 0x83ea6821, 0x57012105, 0xff240583, 0x80090900, 0x09260883, 0x09ea6a09, 0x00820009, 0x03820120, 0x40012022, 0x29235782, 0x84250000,
+    0x23062457, 0x73012f22, 0x35210563, 0x059a6c34, 0xc06c618a, 0x37012105, 0x69205d85, 0x0775fd18, 0x0f8f6a20, 0x67827084, 0x28871890, 0xb3440020,
+    0x06274605, 0x27463720, 0x012f211d, 0x0d638418, 0x32373625, 0x501d1617, 0x304605fc, 0x39d42a1b, 0x02161502, 0x02021539, 0x27098215, 0x3807070a,
+    0x16020217, 0x210f3446, 0x34460b31, 0x38d42208, 0x24208216, 0x16160238, 0x22098202, 0x840a0707, 0x20ab8d0a, 0x28aba027, 0x37362726, 0x06171633,
+    0x219b9c07, 0x968215a1, 0x909fa020, 0x03838a83, 0x102a8383, 0xf001d0ff, 0x1300c001, 0x83824900, 0x31071423, 0x051d6406, 0x088c7718, 0x1716232a,
+    0x36171631, 0x34373637, 0x46057347, 0x205905df, 0x50072005, 0x7a5205b5, 0x18362005, 0x2108efbe, 0x96181506, 0x31080d5d, 0x313202d0, 0x32314b4b,
+    0x1d111102, 0x0801010b, 0x0a0d0d09, 0x01171828, 0x36362020, 0x36364343, 0x17012020, 0x0d0a2818, 0x0108090d, 0x111e0a01, 0x1a49c011, 0x06ab7005,
+    0x3a83e020, 0x29234283, 0x83182323, 0x2443833b, 0x37302f22, 0x843a8444, 0x37442446, 0x82222f30, 0x830b203d, 0x23182345, 0x0b612923, 0x84402006,
+    0x002730db, 0x004f003b, 0x01000063, 0x06310722, 0x48141115, 0x1120062d, 0x2320d382, 0x1d211384, 0xc7411801, 0x20138308, 0x8e278307, 0x843b9313,
+    0x204f8e27, 0x0cee4f02, 0x6951fe20, 0x09092209, 0x820c850e, 0x820a20fe, 0x9201200c, 0x850e201a, 0xc00126f9, 0xfe0d0909, 0x270c843f, 0x0dc2010d,
+    0xe0fe0909, 0xa0211182, 0x2237820e, 0x82a20d09, 0x8260200f, 0x8440200e, 0x410e210e, 0x01210e82, 0x210f8220, 0x30869ffe, 0x20866220, 0x8400ff21,
+    0x010d2221, 0x3c108202, 0x02000000, 0xc0ff0e00, 0xc001f101, 0x63005100, 0x16010000, 0x1516010f, 0x16170714, 0xa5561807, 0x29078507, 0x26272223,
+    0x2726012f, 0x07850607, 0x013f2626, 0x37343526, 0x24053166, 0x1f363736, 0x05574b01, 0x17323329, 0x16011f16, 0x85363717, 0x56312007, 0xff18057b,
+    0x26080c13, 0x2c0a04f0, 0x0a2c0202, 0x04090704, 0x0e0a0d0a, 0x0c171538, 0x17150e04, 0x040f1415, 0x3814180c, 0x090d0a0e, 0x89070905, 0x09052125,
+    0x142d2583, 0x0f040c18, 0x15161614, 0x170c040e, 0x24258315, 0x0709040a, 0x08264af0, 0x08053e4a, 0x19012228, 0x0c280a0e, 0x280c0d0d, 0x11120e0a,
+    0x0b0f1008, 0x0a101204, 0x03040e39, 0x390e0403, 0x0412100a, 0x08100f0b, 0x25951211, 0x04040323, 0x24258b03, 0x161701a9, 0x07c26f23, 0x17162323,
+    0x05cf4401, 0x02c0ff25, 0x77c00140, 0x31250685, 0x17230706, 0x252f1906, 0x0716223f, 0x23538231, 0x200d0909, 0x2d1a2f19, 0x010cff28, 0x09090dc0,
+    0x2f19a001, 0xe1222811, 0x17450e0a, 0x00c02708, 0x002b001a, 0x98180500, 0x22190b37, 0x03320dad, 0x16011f14, 0x012f3637, 0x22272635, 0x17150607,
+    0xd8180001, 0x0b8b0b9d, 0x600b1830, 0x120c0d13, 0x0a170255, 0x40010707, 0x22192201, 0x0132157b, 0x40060d00, 0x0e13120c, 0x02167b39, 0x880a0707,
+    0x8f840000, 0xff82e020, 0x2f00a024, 0x45184300, 0x1727107f, 0x06151613, 0x18070607, 0x212c7d45, 0x48180001, 0x76260ad4, 0x0f0f0103, 0x1185c918,
+    0x19504518, 0x2a078c65, 0x140b0c40, 0x0909b4fe, 0x570f0f18, 0x481807b5, 0x45180bad, 0x00230f32, 0x66000300, 0x1b2e07f3, 0x47002400, 0x23250000,
+    0x22230607, 0x4618012f, 0x21390912, 0x3d363732, 0x26273401, 0x27260723, 0x17163736, 0x16270706, 0x013f3233, 0x05b55136, 0x51010f21, 0x248209bd,
+    0x06072232, 0x011f1415, 0x2e85e001, 0x131a1a13, 0x090e862d, 0x0e210082, 0x06094501, 0x2008cf5d, 0x0a8847c7, 0x0ed86019, 0x132d6024, 0xad182d13,
+    0x4a180d27, 0x512008ed, 0x2108a647, 0x5985f34a, 0x474af321, 0x80210536, 0x088f4100, 0xa1010032, 0x1f001600, 0x26010000, 0x0f062127, 0x011d0601,
+    0x0807684b, 0x34353737, 0x2303012f, 0x21372327, 0x01072317, 0xfe1807bf, 0x3d0718c0, 0x0e0d0104, 0x14a00114, 0x04010d0e, 0x20c05f3d, 0x0e013037,
+    0x01203730, 0x02021788, 0x100ffa16, 0x83198360, 0x10603523, 0xd8fef90f, 0x40c0c040, 0x20000100, 0xf001e0ff, 0x4000b001, 0x7f186982, 0xfe5808df,
+    0x27262705, 0x07062326, 0x77830706, 0x46373221, 0x17820951, 0x27262724, 0x744e3736, 0x17162105, 0x08c74c18, 0x82f00121, 0x859020f1, 0x173f24d2,
+    0x18262121, 0x3a070760, 0x0c0b2b35, 0x0108080d, 0x4a3c0b02, 0x1e32323f, 0x1e01011e, 0x3f32321e, 0x4f2e2e34, 0x012106b4, 0x82378690, 0x111e263d,
+    0x2d2d0211, 0x293c8344, 0x02020820, 0x0d0d0b0a, 0x31842c08, 0x3e3e3323, 0x233d8333, 0x46281717, 0x00206685, 0x22093747, 0x463100b0, 0x1d210855,
+    0x20bc8701, 0x05b75606, 0x2321ac88, 0x05fa5622, 0x42013b21, 0x03230813, 0x83310726, 0x070622e7, 0x4ed78222, 0x262206b9, 0x2982012b, 0x200a7546,
+    0x063e7916, 0x23823620, 0x82d00121, 0x2e1e387d, 0x3848362e, 0x06041737, 0x0c0d0d05, 0x2711040b, 0x21263327, 0x852c1520, 0x064f4699, 0x1a991620,
+    0x1f232782, 0x82352e2d, 0x83182043, 0xb0012c43, 0x4a0e0909, 0x0118182a, 0x83442928, 0x05042a35, 0x1d300d06, 0x1111011c, 0x082c561e, 0x34829020,
+    0x83eefe21, 0x8c19932e, 0x030c2140, 0x3007ff4a, 0x00a00140, 0x00270015, 0x004b0039, 0x00610056, 0x0c87686c, 0x240a4379, 0x31273417, 0x07214126,
+    0x8f05a17c, 0x15352111, 0x37201190, 0x2009a46c, 0x4b0a9415, 0x974c0538, 0x1b402309, 0x80531212, 0x41df880d, 0x0588053b, 0x02164025, 0x98e01602,
+    0x155f4b04, 0x1906e569, 0x2008cf08, 0x185d8809, 0x200c55b5, 0x077a49d8, 0x8808f255, 0x0a6f4f08, 0x2b001f23, 0x06495000, 0x16171624, 0x42181517,
+    0x212b094c, 0x27262726, 0x36373635, 0x18023b37, 0x18095742, 0x5a08ddef, 0x007c08a7, 0x40102309, 0xaf6101a0, 0x30002107, 0x21077956, 0xa5180130,
+    0xeb7d10c8, 0x202a8205, 0x082f7430, 0xc001002f, 0x2a000f00, 0x06170000, 0x27262307, 0x3b501811, 0x22012308, 0x88820607, 0x22272625, 0x84361107,
+    0x8216209d, 0x34112892, 0x40232627, 0x18200f01, 0x3f073d65, 0x0a099c01, 0x222a2943, 0x35243424, 0x2d362530, 0x4030352e, 0x0a0b0114, 0x010f300f,
+    0xd0010f01, 0x3c052d41, 0xf00130fe, 0x02021e04, 0x10030e0d, 0x020ea2fe, 0x01020e0e, 0x01140918, 0x08080f2d, 0x20008200, 0x084f4d01, 0x00003623,
+    0x087e5225, 0x0a443520, 0x076a4805, 0x1d878685, 0x44012f21, 0x1621052a, 0x28018217, 0x02331415, 0x16170100, 0x078c4422, 0x0b0e102a, 0x51513939,
+    0x0e0b3939, 0x3408175e, 0x01161622, 0x22220101, 0x47473a3a, 0x2322393a, 0x2270a001, 0x23128217, 0x80140e0d, 0x072a3783, 0x02333250, 0x50323302,
+    0x12870107, 0x17160129, 0x3a477022, 0x8422223a, 0x47392338, 0xab840001, 0x0140012a, 0x0018009f, 0x06110100, 0x41061446, 0x3b2307b5, 0x82363701,
+    0x26208291, 0x0c060712, 0x87548709, 0x87543b91, 0x0112130f, 0x81fe8001, 0x08040914, 0x0d0d0178, 0x0d146114, 0x080d780e, 0x9f451507, 0xc0012708,
+    0x1200a001, 0x59822b00, 0x06072622, 0x4a056171, 0x372505c7, 0x26012f26, 0x058f510f, 0xf1821520, 0xed823b20, 0x37323735, 0x26113736, 0x139d0127,
+    0x120f0c0f, 0x070d1012, 0x8307090b, 0x137022aa, 0x23798b0f, 0x06070c09, 0x12357b82, 0x0f0c0a01, 0x160f0f13, 0x130f0f16, 0x2d1d0508, 0x08931d2d,
+    0x2e8a840d, 0x0d0d155f, 0x03010c78, 0x80011409, 0x82000815, 0x00042800, 0x02dcff00, 0x82a40180, 0x0029248f, 0x935d0044, 0x37272193, 0x294ca684,
+    0x22a88605, 0x89263536, 0x07142216, 0x20c78306, 0x26a98333, 0x27343536, 0x8b072726, 0x331721c5, 0xc5943486, 0x10123c3b, 0x0e19100c, 0x1034010e,
+    0x080b080c, 0x13122207, 0x123d4502, 0x2a100d0f, 0x20008217, 0x28ef832a, 0x1b330708, 0x331b1c1c, 0x20f19ce9, 0x39f18515, 0x1c2d2e1c, 0x12100c4a,
+    0x1c1d150f, 0x0f2e4120, 0x1c050813, 0x592c2626, 0x14834b3a, 0x30302337, 0x31303636, 0x0a120f23, 0x3a3a2a05, 0x39394242, 0x0d08022a, 0x08ed6f78,
+    0x03087829, 0x80011409, 0x82000914, 0x18048200, 0x37082f40, 0x0030001a, 0x004b0035, 0x00550050, 0x0067005a, 0x17161300, 0x15171631, 0x0721fb82,
+    0x08cf4323, 0xab503320, 0x201a9905, 0xa32f1913, 0x33172f14, 0x13152335, 0x35231533, 0x33352317, 0x09832715, 0x83152321, 0x3533210a, 0x47081370,
+    0x40210a85, 0x08f14240, 0x8020158c, 0x0888c788, 0x40404026, 0x60202020, 0x04820382, 0x40604024, 0x2394a001, 0x1594c020, 0x89097061, 0x40502466,
+    0x83e0fe40, 0xc020284e, 0xc0602080, 0x6a002020, 0x003406bf, 0x0c00a001, 0x24001700, 0x3e003100, 0x00004900, 0x11171613, 0x22057244, 0x83333736,
+    0x2726260a, 0x16373611, 0x88028217, 0x013b2117, 0x2882248c, 0x27200f88, 0x28822b83, 0x28203582, 0x09156418, 0x0f015824, 0x0383010f, 0x13894820,
+    0x0a896020, 0x0a346418, 0x68754020, 0x02a02408, 0x8370fe16, 0x90012623, 0xfe100216, 0x21408360, 0x0583a001, 0x198b1020, 0x18200b8b, 0x34872e83,
+    0x2a830820, 0x00293687, 0x00020000, 0x01ebff00, 0x22ef82b5, 0x82280016, 0x323322e7, 0x068b791f, 0x2f22232a, 0x013d2601, 0x37363736, 0x29124c7b,
+    0x131a9630, 0x861212b0, 0x07821a13, 0x0d011324, 0x0470140e, 0x05424506, 0x13a00123, 0x221a83b0, 0x82121286, 0x14962507, 0x90010d0e, 0x82088046,
+    0x03002122, 0x25084345, 0x002c0015, 0xef51003e, 0x010f2905, 0x3f262706, 0x34353601, 0x21061c66, 0x7f833505, 0x3521948e, 0x0ad31831, 0xd9013311,
+    0x11702727, 0x700e0e11, 0x0e801919, 0x8110110e, 0x958327fe, 0xa820a682, 0xa822a686, 0x52477013, 0x268b8208, 0x362a1801, 0x82712a36, 0x7111262b,
+    0x1b23231b, 0x213d8381, 0xab843e81, 0x86a81321, 0x200782bc, 0x20b78c76, 0x21b78204, 0x018201c0, 0x0019002f, 0x002f0024, 0x2500003b, 0x26272611,
+    0x0a065627, 0x36373225, 0x82272635, 0x332522b9, 0x05a84616, 0x15373622, 0x13200a89, 0x2009505c, 0x25498215, 0xfe140e0d, 0xa15829d0, 0x01292205,
+    0x2fa28240, 0x010f0f01, 0x10c0cffe, 0xc10f0101, 0x0d02020d, 0xf1210989, 0x506819fe, 0x09ef630f, 0x0d090928, 0x0e520912, 0x2b42d016, 0x08344207,
+    0x884cff20, 0x00402406, 0x84010000, 0x018024bf, 0x820d00c0, 0x2711260c, 0x37361107, 0x05025436, 0xc0800124, 0x051901c0, 0x902609e2, 0x707030fe,
+    0x1046d001, 0x3b881807, 0x82002008, 0x0020263b, 0x002e0025, 0x07fd5641, 0x17141525, 0x83013b16, 0x4c332005, 0x35490564, 0x27262b05, 0x21032726,
+    0x37152135, 0x6f4c2726, 0x33252805, 0x35331517, 0x65012f34, 0x1d250592, 0x01353301, 0x054254c0, 0x0e090923, 0x25038220, 0x090e4001, 0x03822009,
+    0x12120125, 0x82ff401b, 0x08684caf, 0xe6d0fe2a, 0x2e09401a, 0xedfe0d09, 0x40221f82, 0x22830001, 0x0a826020, 0x2006345d, 0x293e8260, 0x12121b60,
+    0x6000ff01, 0xd7489860, 0x1be82407, 0x820d5345, 0x211c8235, 0xef426080, 0x05575605, 0x2f001d2a, 0x33130000, 0x33011f16, 0x13ffe218, 0x37363724,
+    0x6e721331, 0x7ac32510, 0x4b0a0c22, 0x5608235c, 0x4b24085b, 0x3d220c0a, 0x240fa96d, 0x1f02a001, 0x7da0181f, 0xa4a0180a, 0x1f1f2408, 0x72a0fe02,
+    0x0787077b, 0x01239b86, 0x82a001c0, 0x00332a99, 0x03232500, 0x07062726, 0x0cac4b03, 0x27343528, 0x37012b26, 0xbd621733, 0x013b2407, 0x83363732,
+    0x27232e15, 0x01231737, 0x08891aa0, 0x87091516, 0x0cf8491a, 0xa0110222, 0x4106466b, 0xf82c062b, 0x20703838, 0x01146b01, 0x95fe1401, 0x200be042,
+    0xf2cd1830, 0x9570230c, 0x5b4e0095, 0x01e02205, 0x20978280, 0x06f14223, 0x4c06e15b, 0x11200845, 0x9753a389, 0x412f2006, 0x06240555, 0x23070607,
+    0x0d69ae19, 0x011e4126, 0x36242501, 0x2106854a, 0xa8851010, 0x2436e029, 0x11110125, 0x4170d11d, 0x7023075c, 0x87909090, 0x22ce220b, 0x851f8330,
+    0xc0fe21a8, 0x45830785, 0x1c1d2326, 0x12019212, 0x2305c86c, 0x80c0fe80, 0x1a240b82, 0x0113121b, 0x0020b682, 0xff200482, 0x292bb785, 0x14010000,
+    0x2b063107, 0x70330301, 0x496d0879, 0x013b2206, 0x09897813, 0x01211c83, 0x215f8280, 0xcf44853b, 0x8ca78606, 0x8001210f, 0x8687b482, 0x55188c86,
+    0x4b500917, 0x0034220a, 0x20798267, 0x0d434d21, 0x2d413320, 0x06bb410a, 0x11012b22, 0x0a625918, 0x26273426, 0x35071323, 0x43056b48, 0x2223052d,
+    0x1906010f, 0x4f087d70, 0xbe4f099c, 0x0107240b, 0x4400ff20, 0x402008e0, 0x8306f253, 0x20a182a9, 0x209e8920, 0x05654fe9, 0x0dd71219, 0x01201393,
+    0x0af6e018, 0xed8f2020, 0x40205e86, 0xfe247082, 0x0ae60ab7, 0x65824085, 0x0d0a4023, 0x910d830d, 0x05174112, 0x01c00127, 0x003400a0, 0x12174168,
+    0xe9421520, 0x41352012, 0x03220e17, 0xf9422326, 0x011f2205, 0x06f74223, 0x21051b41, 0x6e5d011f, 0x012f2206, 0x05dc4e33, 0x2406da50, 0xa001012f,
+    0x09d754fe, 0x70428020, 0x06084306, 0xf4601020, 0x98292009, 0x24df8cb9, 0x0909a001, 0x0507550e, 0x82200e21, 0x25ee843d, 0x090d0e09, 0x14418009,
+    0x211c8306, 0x1141f7fe, 0x13584105, 0x0020138d, 0x0af34718, 0x25001229, 0x4c003900, 0x42010000, 0x14240d92, 0x11230607, 0x25261291, 0x36313734,
+    0x41182133, 0x01200ccb, 0x87095d46, 0x00012117, 0x94063546, 0x00ff2106, 0x240af855, 0x090e80fe, 0x092f4109, 0x37410120, 0x18012006, 0x440ea843,
+    0x684e0b31, 0x18fe200c, 0x200c9644, 0x20dba700, 0x20b49117, 0x20db9205, 0x11024125, 0x43400121, 0x068606a0, 0xac186020, 0xa7820ca4, 0xba83fe20,
+    0x1c84c787, 0xdc8d328f, 0x22090f42, 0x4109090e, 0x55430630, 0x0c034105, 0xb741da82, 0x41a02061, 0x148614b0, 0xe742d892, 0x55b74108, 0x2011a441,
+    0x42129111, 0xab902793, 0x9022b841, 0x0dba4133, 0xe748ff20, 0x059d4206, 0x2f1d9742, 0xff100006, 0x010002f0, 0x000c0090, 0x00340020, 0x2405d15f,
+    0x17161300, 0x086d5f15, 0xee650520, 0xa6152012, 0x36252313, 0x4b883337, 0x09881720, 0x58221582, 0x70180216, 0x01210723, 0x05594288, 0x9f09d549,
+    0x30fe210f, 0x16223b87, 0x488a4802, 0x16899020, 0x9c431020, 0x200c980c, 0x203d8998, 0x333c8988, 0x1a000500, 0xe001e0ff, 0x1400a001, 0x3c002800,
+    0x5f005100, 0x0fd10a19, 0x6c212321, 0xb47c0512, 0x09315508, 0x086e6918, 0x2108a774, 0xc843013b, 0x35312513, 0x36013f26, 0x23051641, 0x20012f06,
+    0x200f8144, 0x806218c0, 0x06f1420d, 0x2006e243, 0x11f942c0, 0x660c0c2b, 0x01080809, 0x09080801, 0x07fb4266, 0x430c8054, 0x1f4212c1, 0x0db3320c,
+    0x04064f0d, 0x0b9e0b04, 0x4f060404, 0x05000000, 0x5f4f1800, 0x00132107, 0x2005ab5b, 0x1507415e, 0x4109bb7d, 0x372e3106, 0x26312706, 0x37363527,
+    0x16011f36, 0x8845010f, 0x2f064110, 0x04411a20, 0x0b0b2108, 0x20350741, 0x09044164, 0x4f0d0d27, 0x02000000, 0x28008200, 0x80014002, 0x21001400,
+    0x05415200, 0x69710720, 0x17162b0a, 0x11011f16, 0x2f060706, 0x4a523501, 0x01802505, 0xfe140e0d, 0x32081579, 0x0e142001, 0x01c0010d, 0x6e111010,
+    0x1010116e, 0x8f500101, 0x2d30831c, 0x1400ff10, 0x4b0b0908, 0x090b4b9e, 0x734a1408, 0x05736307, 0x3c002622, 0x2a106763, 0x27261137, 0x16052726,
+    0x18163117, 0x2a085492, 0x37363736, 0x21230601, 0x19262722, 0x2b0eef58, 0x80febf01, 0x0112121a, 0x1a121201, 0x2406bb60, 0xfe1c1211, 0x053163b0,
+    0x0d0d1523, 0x30838301, 0x09054f01, 0x040aa2fe, 0x05460504, 0x20050808, 0x2205835e, 0x61040580, 0x24701672, 0xfe21080f, 0x080908c8, 0x07076008,
+    0x07088b2c, 0x000908c0, 0xff000001, 0x018001c1, 0x001b00c0, 0x07060100, 0x21028431, 0x9f822306, 0x2621bb82, 0x082c7927, 0x0280012b, 0x27271f1e,
+    0x0e0e0a1b, 0xe2b2180a, 0x36522e09, 0x00010236, 0x373b3b2d, 0x0c0c2138, 0xb1b21821, 0x36362209, 0x0c3f5b52, 0x00002423, 0x785a8425, 0x59850658,
+    0x2107455b, 0x67831125, 0x71822620, 0x5b000221, 0xff211711, 0x206c8300, 0x20588202, 0x175b5bc0, 0x80fec022, 0x27831f83, 0x6f580020, 0x01702208,
+    0x05bf5bba, 0x37363723, 0x24028431, 0x17323336, 0x081b6f16, 0x33207583, 0x6b05dd79, 0x108305ec, 0x1b011031, 0x1a23231b, 0x0a0f0f0a, 0x1b23231a,
+    0x5f02011b, 0x6028068b, 0x010f0f01, 0x301f2001, 0x0f2e0582, 0x01161722, 0x38392681, 0x0d253838, 0x0682250d, 0x4c263925, 0x82023231, 0x0e4c282b,
+    0x300e0202, 0x84012020, 0x1617222e, 0x2f8e8223, 0x00000300, 0xfb01c0ff, 0x0d00bb01, 0x4e001c00, 0x20084f50, 0x05d66127, 0x17370524, 0x5d500607,
+    0x31372207, 0x07374237, 0x06012b23, 0x067d5f07, 0x2005b94e, 0x82c98234, 0x831d20bf, 0x0ae74217, 0xea01333c, 0x621e1111, 0x1616121e, 0xc2fe1212,
+    0x09a862a8, 0x0a0f580d, 0x041e040a, 0x6a4d1409, 0x4b01200c, 0xe7820983, 0x00ff2922, 0x2207154e, 0x83980160, 0x2344823d, 0xca121111, 0x3c824183,
+    0x0f090b2a, 0xb3090d58, 0x0d090901, 0x06834582, 0x85fffe21, 0x0d61244e, 0x83010909, 0x50612010, 0x0120081b, 0xff5d0983, 0x01002b08, 0x006800c0,
+    0x0f142500, 0x17490601, 0x013f2305, 0x98181523, 0x26200ea9, 0x2205965a, 0x1835011f, 0x180a107b, 0x190dff42, 0x181b5f2c, 0x26099e79, 0x00021516,
+    0x830a4809, 0x120923a5, 0x08851173, 0x0d2b0f82, 0x0909480a, 0x0a0d0e09, 0x85127311, 0xa60f8208, 0x82c12027, 0x0a0a233c, 0x3c850d09, 0x3c850884,
+    0x0a090d22, 0x08836485, 0x0e0a4825, 0x8248090d, 0x2527a011, 0x0000000c, 0x00820002, 0x0140012a, 0x00130080, 0x13000023, 0x67095d61, 0x2321079c,
+    0x05d85c17, 0x8d561620, 0x07262305, 0xb8820d1f, 0x0e0e0922, 0x0a300582, 0x0cc0ed0e, 0x1111c00b, 0x11020112, 0x80011011, 0xfe21da82, 0x059941c0,
+    0x3f010e22, 0x072f0882, 0x0e0e0ba0, 0x080c9f0b, 0x40011508, 0x83080814, 0x00012173, 0x02280082, 0x00800100, 0x3700002a, 0x20079458, 0x055a571d,
+    0x36371525, 0x45171617, 0x15240521, 0x2f060706, 0x0873b318, 0x09003529, 0x0a0e0d09, 0x8210ac09, 0x2404846e, 0x10111201, 0x850484ac, 0x82212019,
+    0x09082672, 0x840e0809, 0x8570839d, 0xc0fe2205, 0x21768215, 0x0585839c, 0x0020bb85, 0x8384f785, 0x1c000c28, 0x07010000, 0xe0881715, 0xf08e2120,
+    0xaccc0122, 0xff236e88, 0x8a0bc100, 0x8f7923f0, 0x6a828f54, 0x3f011622, 0xeb955e83, 0x2e06534f, 0x2500000f, 0x07061716, 0x26270605, 0x82361127,
+    0x01052de6, 0x01011669, 0x18e0fe16, 0x01011818, 0x20320483, 0x1b1a0fe9, 0x0d0fb00d, 0x60011c0e, 0x0e0d0e1c, 0xa34100b0, 0x0081240a, 0x82290014,
+    0x06232aab, 0x11070607, 0x33161716, 0x45468217, 0x2b2105d9, 0x21148701, 0x1488013b, 0x20100122, 0x88078e52, 0x91c02008, 0x81012c12, 0x140d0d01,
+    0x0d15e0fe, 0x5201020e, 0x0e2106d0, 0x05964601, 0x0e0e1522, 0x4b431289, 0x01002505, 0x80018001, 0x00228b82, 0x05671501, 0x53352008, 0xc2510a16,
+    0x40012213, 0x079c50ff, 0xdb880888, 0x24098741, 0x2735013f, 0x22dd8626, 0x54372137, 0x0f8705d8, 0xabab352d, 0x01121111, 0x11111201, 0x41c00001,
+    0x0d830686, 0x85410720, 0x41152005, 0x9f2005ea, 0x26087142, 0x0714c0fe, 0x42000c08, 0x01200c6f, 0x076d8018, 0x07013d27, 0x27262706, 0x20058435,
+    0x20be8211, 0x0e65181f, 0x07255b07, 0x70420220, 0x88758406, 0x83ab207a, 0x42ab2071, 0x01230570, 0x42c0fe60, 0x83250551, 0x08080c9d, 0x42058516,
+    0x7142050c, 0x080e2507, 0x0e080909, 0x0121eb88, 0x076b433e, 0x37322523, 0x066f7931, 0x06072229, 0x17161115, 0x8e273316, 0x1f0121f2, 0x09213e83,
+    0x2064820e, 0x20728201, 0x82f58bea, 0x05634310, 0xfe251882, 0x09090ec0, 0x22f98506, 0x4108070d, 0x3b420609, 0xe0ff3d05, 0xa101bf01, 0x22000f00,
+    0x21370000, 0x2f363736, 0x22232601, 0x1706010f, 0x21051716, 0x8307ab5f, 0x34353918, 0x30272627, 0x0c205f01, 0x0faf150c, 0xb00f1414, 0x200c0c15,
+    0xa1fe5f01, 0x21074642, 0x02485f01, 0x02812d05, 0xc0191a1b, 0x19c11010, 0x41021a1a, 0x820fd947, 0x00012e77, 0x01e0ff00, 0x00a00100, 0x17000018,
+    0x18728222, 0x2d0c4448, 0x14151617, 0xe0230607, 0x09c00a0d, 0x4850c009, 0xaaaa2605, 0x0d0a0909, 0x820e8520, 0x21158316, 0x1b84a9a9, 0x01000024,
+    0x4f824000, 0x4f874020, 0x071b5518, 0x8207ae45, 0x25d0824e, 0x0a0d6023, 0x47850909, 0x20205987, 0x0d215382, 0x8747860a, 0x57b9185b, 0x0033210d,
+    0x19061b6d, 0x5f082924, 0xb26005d8, 0x36052105, 0x08f65918, 0x06272623, 0x68ed1807, 0x181d4809, 0x1600012b, 0x02164002, 0x02401602, 0x48098916,
+    0x70201829, 0x3284288e, 0xbb410020, 0x05c76f06, 0x25001a22, 0x4c5fa39c, 0x2095980a, 0x10c018a8, 0x208a9809, 0x08586818, 0x00000223, 0x207b87ff,
+    0x207b9d34, 0x3b711917, 0xa666180c, 0x31172108, 0xaf388a98, 0x0e0e2f2f, 0x302f1011, 0x0f0f1011, 0x0f0f2e2e, 0x2f301110, 0x0e0e1110, 0x30209898,
+    0x43852b91, 0x9d0f2741, 0x36252aab, 0x27343135, 0x0f222326, 0x0e145401, 0x0129ab98, 0x09080874, 0x6c090b0b, 0x2205832c, 0x83400808, 0x98802006,
+    0x212586a8, 0x35852c6c, 0x08084023, 0x056b4980, 0x0100022a, 0x001a00c0, 0x004b002a, 0x4909db4a, 0xe95e05f9, 0x056d4205, 0x27221127, 0x36352631,
+    0x078b5237, 0x1507372f, 0x27260706, 0x013f3435, 0x27263536, 0x05267623, 0x33203183, 0x6505d67d, 0x0e3819dd, 0x1e020909, 0x0a0a090d, 0x2d450d09,
+    0x02161602, 0x020b390c, 0x01153315, 0x012c0b83, 0x331d1413, 0x0114141f, 0xc0012201, 0x2617e64a, 0x090970fe, 0x4f031d0e, 0x8e310513, 0x0216021c,
+    0x0d101602, 0x0d062208, 0x14020214, 0x230d8216, 0x0113141e, 0x1e244a82, 0x00001626, 0x2c22e78c, 0xe79c4200, 0x56091750, 0x33230656, 0x18262313,
+    0x210aef69, 0x015a1716, 0x4fde9c05, 0x282108ac, 0x209a8450, 0x23058308, 0x10021620, 0xd6990783, 0x260cb252, 0x160200ff, 0x42400216, 0x582005f8,
+    0xc78a0683, 0x4c001124, 0x5c188500, 0x132a1351, 0x16311732, 0x1716011d, 0x20571716, 0xda261909, 0x2726230d, 0x7f532726, 0xe84e1909, 0x44032009,
+    0x172005b3, 0x14833e82, 0x30832289, 0x09974e18, 0x5a894c83, 0x2a546883, 0x0e20280c, 0x31480909, 0x4a0a0c31, 0x0a2405fd, 0x4831310c, 0x92050e41,
+    0x85202015, 0x1f2c2419, 0x85150a20, 0x0a15242f, 0x952c1f20, 0x0cee6215, 0x82000121, 0x8a5c9d24, 0x6bfe2188, 0x74895ea1, 0x220c2f42, 0x4d300024,
+    0x51661d95, 0x37362e05, 0x27260501, 0x06272631, 0x37360107, 0x19a14d31, 0x2364fe2d, 0x36360201, 0xfe303f52, 0x855c01f5, 0x0c012309, 0xb8430122,
+    0x306f2b18, 0x3636523f, 0x01220102, 0x08846f0c, 0xf5fe2324, 0x3b483f30, 0xbf012505, 0x23008001, 0x14259f82, 0x23063107, 0x2a871821, 0x0d194c09,
+    0x82322121, 0xbf012619, 0xfe0e0809, 0x06e26ecd, 0x0909a032, 0x0d0d0aa0, 0x6a09090a, 0x080e3301, 0x090ec009, 0x073b2d19, 0x1f821784, 0x69241e83,
+    0x000e0909, 0xc0206b86, 0x22206b82, 0x6d6f6b82, 0x43212009, 0x21200722, 0x230b5f4c, 0xb7010714, 0x5b824384, 0x41cdfe21, 0x012105d6, 0x20778933,
+    0x8e5b8aa9, 0x84002075, 0xe1ff266b, 0xa0018001, 0x206b8300, 0x58c31906, 0x207a890d, 0x064a5e36, 0x77010722, 0xcc82a786, 0xe06f0a20, 0x827d8406,
+    0x85c92065, 0x09082181, 0x818bf982, 0x0b481f84, 0x01802208, 0x836b849f, 0x012f215c, 0x6408684d, 0x8a4d0993, 0x416b8207, 0x738a0e1b, 0x51418920,
+    0x0b6d410f, 0x0221d787, 0x2ad78600, 0x26270607, 0x07223527, 0x84161706, 0x06e94f0a, 0x42523320, 0x14153c06, 0xb0f80107, 0x010d0d0d, 0x212f2e75,
+    0x0c090a03, 0x01181822, 0x41262601, 0x82015141, 0xb0230816, 0x97de0808, 0x1006060a, 0x6b282757, 0x0706070c, 0x2f292a18, 0x1028284b, 0x0610500f,
+    0x08970a06, 0x57070b0b, 0x182a0cb3, 0x4a003100, 0x00006400, 0xc35a2313, 0x06b85a0e, 0x59212321, 0xe07b09b3, 0x27342409, 0x6b012326, 0x14230a2b,
+    0x5c3b1617, 0x252608a6, 0x06310722, 0xeb59011d, 0x05966a0c, 0x93598020, 0x090e2306, 0xff414009, 0x86202006, 0x09be5a12, 0x89e0fe21, 0x211c860b,
+    0x31892001, 0xa0201287, 0x1809766a, 0x860cb170, 0x21268358, 0x0c8a80fe, 0x2005c643, 0x8d068260, 0x0de7575e, 0x20080f41, 0x20f69737, 0x17284121,
+    0x52692720, 0x34352109, 0x2605ac47, 0x1714011d, 0x41273316, 0x9189200f, 0x0f410120, 0x41f08a07, 0xc0201021, 0x46100d41, 0xee8d0620, 0x2291378d,
+    0x0b41a020, 0x00012d14, 0x01a00010, 0x00e000b0, 0x25000012, 0x2211fe57, 0x55fe9001, 0x01200658, 0x637c6086, 0x0c23450c, 0x37002522, 0x211c5347,
+    0x0a193607, 0x172308e4, 0x43312722, 0xad440662, 0x19484706, 0x2208f449, 0x82090d18, 0x850d2000, 0x193e4705, 0x02169825, 0x84801602, 0x18f82004,
+    0x210be8fb, 0x334a0500, 0x82292008, 0x004625a9, 0x0058004f, 0x2f053160, 0x33373637, 0x17161716, 0x32330714, 0x011d1617, 0x0c8d5318, 0x26013b2a,
+    0x36373635, 0x27261737, 0x25092542, 0x06233727, 0x0342010f, 0x23220807, 0x15330531, 0x26272623, 0x35053527, 0x07061533, 0x98230706, 0x181b3302,
+    0x02331b18, 0x01191925, 0x00432a0a, 0x41fe2005, 0x2a2906b3, 0x1919010a, 0x180d2725, 0x05dc7e02, 0xa9224927, 0x230c1802, 0x220d8549, 0x65c0b8fe,
+    0x002e055a, 0x0e0d01c0, 0xc0019014, 0x29292a02, 0x3383022a, 0x18131521, 0x210da053, 0x5f831513, 0x7f144521, 0x3b240664, 0x3b140115, 0x21056f7f,
+    0x3c83e0f0, 0xe0e0b027, 0x0d0e14b0, 0x0ce76801, 0xa7413520, 0x84062007, 0x82af82b4, 0x272222b3, 0x49e58226, 0x138207ec, 0x85340721, 0x1617210f,
+    0x3f080783, 0x16173233, 0x01000217, 0x1f502f2f, 0x292a3122, 0x0f0f2718, 0x03031205, 0x20040314, 0x7a484821, 0x0f01010f, 0x293b3c50, 0x23230b04,
+    0x2b262b32, 0x05182929, 0x19040808, 0x621b0101, 0x0c1c4948, 0x2c31bc82, 0x03212128, 0x07010111, 0x35361616, 0x01032f2f, 0x3234820f, 0x11201615,
+    0x23243310, 0x0a09090d, 0x07290f0f, 0x7c433a08, 0xc0260897, 0x1800c001, 0xad843200, 0x4e272621, 0x2c74070a, 0x05b36005, 0x1f740320, 0x06e65305,
+    0x3032a182, 0x17163731, 0x07060716, 0x19204401, 0x2e4b3a29, 0x8019012e, 0x01300b7b, 0x14372222, 0x25382c21, 0x12120125, 0x18170525, 0x3a35d382,
+    0x08150506, 0x8d012509, 0x36391f1d, 0x384e4d47, 0x1f343440, 0x0836821e, 0x34341f26, 0x43432b40, 0x17abfe36, 0x21210101, 0x1e1e1c3a, 0x1e1e062b,
+    0x42021d1c, 0x2b29090a, 0x00001b2b, 0xff000003, 0x24056770, 0x003f0018, 0x21a98251, 0xf84a3332, 0x20988605, 0x25ad8535, 0x16372726, 0x99853117,
+    0x200bbd4d, 0x0a744126, 0x17211d82, 0x20e58231, 0x074b4831, 0x0123e285, 0x54040418, 0x07830733, 0x1b110f3a, 0x01011212, 0x1723c907, 0x04040c17,
+    0x2317170c, 0x3d303024, 0x2430303d, 0xc1201191, 0x0f0a4218, 0xc0180120, 0x04360c89, 0x01010704, 0x111b1212, 0x23212f0f, 0x0c0c1c23, 0x2222231c,
+    0xee821722, 0x82171721, 0x21118508, 0x11872123, 0x42180120, 0xff840fd7, 0x8002c02b, 0x1e00c001, 0x52003700, 0x06837800, 0x0384ca83, 0x0818b418,
+    0x2601272c, 0x031f3637, 0x27263536, 0x4b6b3332, 0x07142205, 0x05d47b17, 0x13070627, 0x26312726, 0x25018427, 0x17373637, 0x9e6f1506, 0x06172805,
+    0x21973107, 0x89332b2a, 0x140b25dc, 0x10691d14, 0x0881a519, 0x5a487030, 0x01070107, 0x29020302, 0x09011b1b, 0xa1831128, 0x61283922, 0x0f223089,
+    0xb6845e22, 0x49191c2b, 0x63014836, 0x0110111b, 0x85dc8201, 0x1f192aee, 0x0f521f20, 0x010c1013, 0x380583d0, 0x0c463958, 0x010f1011, 0x291b1b01,
+    0x1f1e1216, 0x29293c27, 0xfe250202, 0x323183b6, 0x1c232222, 0x2e240c0c, 0x3e090a4a, 0x0a022829, 0x41021e3a, 0x003207ff, 0x0f00a001, 0x2e001c00,
+    0x03250000, 0x07222326, 0x3f7c0603, 0x25272106, 0x2406f444, 0x3d262722, 0x12f64401, 0x0ed5fa3b, 0xd50e1717, 0x1a0b0c0c, 0x0b1aaa01, 0xeefe0c0c,
+    0x02161602, 0x070a1502, 0x0cf04408, 0x6c011f2f, 0x94fe1515, 0x01141416, 0x16141401, 0x272382f9, 0x02168016, 0x800a0707, 0x230de644, 0x00000100,
+    0x2d064f74, 0x0100002d, 0x16311716, 0x06070617, 0x03832307, 0x013f2622, 0x2b230782, 0x79272601, 0x362b0526, 0x1f323337, 0x26273301, 0x82163337,
+    0xe2012b07, 0x031f1f1d, 0x1d1f1f03, 0xa6196574, 0x013010d7, 0x05082a0d, 0x0331672b, 0x09133812, 0x00017465, 0x07208818, 0x010fb026, 0x3aac1103,
+    0x0f218818, 0xb00f0124, 0x8b830800, 0x01c00125, 0x182200c0, 0x270a85bb, 0x007d0070, 0x33151300, 0x2b096a4c, 0x16171633, 0x35211517, 0x37363736,
+    0x15221688, 0xc76f2107, 0x566f180b, 0x222f820b, 0x4e373633, 0x15200571, 0x0cd52019, 0x0cd27018, 0x6182198c, 0xa0203389, 0x2b062147, 0x0d0e1430,
+    0x0140fe01, 0x30140e0d, 0x20053448, 0x06c467a0, 0x1983a020, 0x0f014025, 0x84010f20, 0x89802004, 0x8690200a, 0x19118212, 0x8a0b0121, 0xec701816,
+    0xa001220a, 0x06486220, 0x65842020, 0x11867184, 0xf0fea022, 0x2008ba52, 0xae111910, 0x205f890a, 0x20758930, 0x201594b0, 0x20158930, 0x058f4200,
+    0xff01d835, 0x2100a801, 0x47003700, 0x26250000, 0x07063107, 0x71272315, 0xda6705fb, 0x16172d05, 0x1615013b, 0x013f1617, 0x33022f36, 0x01220987,
+    0x29830726, 0x010f2225, 0x46073717, 0x322e09ea, 0x0727013f, 0x0e0ca801, 0xb630010d, 0x0648100a, 0x82502006, 0x01402a0a, 0x4f0d0d0e, 0x58500e0e,
+    0x20098230, 0x2c09820c, 0x0e0e0c4f, 0x0a103f01, 0xe02b2728, 0x05f24650, 0x0d826020, 0xa12a2829, 0x1105060b, 0x410df330, 0xf32e0562, 0x0610300d,
+    0x11500b06, 0x307f5011, 0x09850511, 0x06060b28, 0x360d3010, 0x0f663835, 0x200a8306, 0x05a75300, 0xa001ff24, 0x5b482400, 0x0706210c, 0x2505d96d,
+    0x37363736, 0xa1503316, 0x0748480b, 0x0c370232, 0x03031414, 0x32050202, 0x31142324, 0x393a473a, 0x3805476f, 0x01473a39, 0x1c1b01a0, 0x4c3a2f2f,
+    0x1c1b2737, 0x05050401, 0x10111101, 0x24138513, 0x1c2f2f3a, 0x4576821b, 0x012d06db, 0x00a001c0, 0x0028001a, 0x13000036, 0xb26f1815, 0x05e44708,
+    0x2405e345, 0x33352726, 0x083d5f27, 0x23011d24, 0x0d8c2135, 0x088d5a18, 0x89468020, 0x1880200b, 0x2207695b, 0x47400180, 0x802306d2, 0x5a602001,
+    0x6023085e, 0x1933323f, 0x20087487, 0x06754160, 0x3f484020, 0x40402506, 0x01000000, 0x60200382, 0x60259f82, 0x00001800, 0x0c007d25, 0x2308174d,
+    0xa0012306, 0x23105e54, 0x600d0a09, 0x220e8654, 0x7d090a0d, 0x202008af, 0x37204f83, 0x7d051355, 0x13550f45, 0x0afc5407, 0x55c00921, 0xdc540815,
+    0x0000220b, 0x27478302, 0x80016702, 0x45002200, 0x2623a182, 0x50352327, 0xd0650575, 0x013b2a05, 0x23151716, 0x1f060706, 0x05f86601, 0x23052726,
+    0x33352726, 0x210d0256, 0xc5501533, 0x061d6605, 0x06660224, 0x38823010, 0xca642220, 0x0f802206, 0x054b4201, 0x0a0a0728, 0x050a5007, 0x118fcafe,
+    0x71272f8d, 0x228f010f, 0x42011617, 0x01360588, 0x0e018f0f, 0x08500b0f, 0x0e0c5007, 0x900f0111, 0x0c0e0e01, 0x0d830750, 0x90010e22, 0x00362789,
+    0xff000003, 0x013d02c0, 0x001c00c0, 0x0040002e, 0x1f161300, 0x99822101, 0x06010f25, 0x18172107, 0x20071856, 0x05245203, 0x11078018, 0x90182120,
+    0x603a1067, 0x01010513, 0x090910a5, 0x17083603, 0x0109c3fe, 0x02021634, 0x12b7fe16, 0x09843c05, 0x56204821, 0x01210fb6, 0x33119080, 0x0c1301c0,
+    0x100c0c01, 0x300116c0, 0x02161602, 0x3d011201, 0xfe210783, 0x07564430, 0x0f4a0797, 0x6016200c, 0x33221109, 0xdd823317, 0x00021722, 0xe6197383,
+    0xa022098d, 0x5184c040, 0xf45f3020, 0x4560200a, 0x0d260528, 0x0000140e, 0xa5180002, 0x112607bf, 0x00001e00, 0xf1412113, 0x05185405, 0x36371133,
+    0x06210537, 0x3621010f, 0x2736013f, 0x01942726, 0x225e834c, 0x83a040a0, 0x125b3442, 0xfe8b0127, 0x77091475, 0x0a13bf01, 0x09090860, 0x84000113,
+    0x844020c8, 0xb5b83084, 0x01200122, 0x1101ee11, 0x0e0e11c0, 0x82010001, 0x82c0206b, 0x00c02506, 0x37000032, 0x42066257, 0x11200bb6, 0x50122850,
+    0x3725054a, 0x17323336, 0x353919f7, 0x0630680e, 0x0d0a6025, 0x67600a0d, 0x292005d4, 0x57201384, 0x19841186, 0x2a090924, 0x42192601, 0xfe21112a,
+    0x201382da, 0x25938300, 0x00024000, 0x93834001, 0x7f892520, 0x51199451, 0xf7200e33, 0x50846487, 0xa920789a, 0xca9aa28c, 0x8205d766, 0x00a02793,
+    0x002f001b, 0x8a180043, 0x1522071d, 0x94191611, 0xbc4414bd, 0x1d016308, 0x20081c64, 0x09364e23, 0x1a9b9319, 0x8306b753, 0x06514e06, 0x0e14d719,
+    0x6018ff20, 0x941909b0, 0x4f5016a4, 0x0ccb4e09, 0xfc820e20, 0x6c0cd46f, 0xf38407e3, 0x2d001f33, 0x00003f00, 0x37363513, 0x15171633, 0x3b363733,
+    0x12206e01, 0x2b061730, 0x36331501, 0x33171637, 0x17072335, 0x854b0706, 0x01402a0e, 0x010f400f, 0x0f0d3320, 0x112e6eb1, 0x0f0e9d2c, 0x2c217380,
+    0xb173212c, 0x77182332, 0x07870764, 0x10800129, 0x0f01010f, 0x18071910, 0x200e0171, 0x2c488320, 0x17400739, 0x60170101, 0x19015f19, 0x037e1819,
+    0x623b8308, 0x22260a13, 0x00003400, 0xa2830725, 0x23070622, 0x2106d166, 0x984e3f34, 0x076f4c06, 0x19272221, 0x2711d6ab, 0x06221a01, 0x1602280a,
+    0x50260282, 0xa1070216, 0x9c610208, 0x22078306, 0x4e5e1a1c, 0x05850570, 0x08206825, 0x82021628, 0x16022802, 0xa1070a50, 0x614b1c1a, 0x4b2005a0,
+    0x08210783, 0x05554ea8, 0x00330585, 0xff030004, 0x017802c4, 0x005c00b8, 0x00cb006e, 0x7f0000dd, 0x072008e8, 0x2305e27f, 0x012f0607, 0xec7f0985,
+    0x35262314, 0xf07f3734, 0x30372305, 0xf27f013f, 0x05f47f16, 0x010f1622, 0x2208164d, 0x4d373233, 0x06200616, 0x40185682, 0x2727083e, 0x26013f26,
+    0x4326012f, 0x4f83054d, 0x2205584d, 0x8230013f, 0x1f36252f, 0x32333601, 0x08444018, 0x82171621, 0x1f162251, 0x21078201, 0xad851415, 0x07161723,
+    0x21b78a06, 0xc4552637, 0x09894d05, 0x021e0138, 0x050b1702, 0x03020102, 0x02020303, 0x1d0e0a03, 0x03071410, 0x00820a0f, 0x07031035, 0x0f1c1013,
+    0x0305050a, 0x0c050404, 0x02020116, 0x820c1601, 0x03012b0c, 0x0f0a0505, 0x0713101c, 0x27821003, 0x030f0a29, 0x1d101407, 0x82030a0e, 0x222a8340,
+    0x457e170b, 0x2c080f9f, 0x0b0a4501, 0x0b140a0b, 0x0607080e, 0x03030404, 0x0d09050c, 0x030f1d08, 0x0f030101, 0x090d081d, 0x02010c05, 0x01050606,
+    0x0b0e0806, 0x212a8414, 0x2a820f0a, 0x02060523, 0x202a9101, 0x28648203, 0x03050406, 0x140a0f03, 0x103c461b, 0x090b2525, 0x82140a0c, 0x05032294,
+    0x246b9604, 0x07060707, 0x273c8208, 0x0a090102, 0x02020808, 0x06249783, 0x07080501, 0x04226b92, 0x2c820403, 0x1c209582, 0x0daeb718, 0x02a1fe26,
+    0x050b1702, 0x3741cc83, 0x01012116, 0x0129a282, 0x0c050304, 0x16020216, 0x222a840c, 0x41010105, 0x03241839, 0x05020102, 0x20123b41, 0x057f4600,
+    0x25058f4e, 0x0040001b, 0xc7410100, 0x09324a0a, 0x2005924f, 0x05474213, 0x22313027, 0x16151431, 0x536e1915, 0x17162d09, 0x27363732, 0x27263130,
+    0xa0012726, 0x0766d618, 0x29012708, 0x010d0c0e, 0x05020203, 0x3a2f253a, 0x023b3b58, 0x020127b8, 0x01523636, 0x34330201, 0x32321151, 0x252a3345,
+    0xe3820536, 0x0c0b0325, 0x4310010c, 0x3c34073d, 0x1010192d, 0x05040401, 0x01171602, 0x4b313202, 0x3e2ef4fe, 0x012f1c83, 0x4b070701, 0x3a123737,
+    0x01012525, 0x82021415, 0x022908f7, 0x00170f0f, 0xff180002, 0x01b101c0, 0x001000c0, 0x25000014, 0x26270607, 0x2627013f, 0x023f3637, 0x17133736,
+    0x01332322, 0x6f4b1820, 0x0112260d, 0x03020191, 0x644b1808, 0x48fe230e, 0x7b7f0048, 0x00a0300a, 0x00490026, 0x22233700, 0x11352627, 0x55363734,
+    0x9d6108c4, 0x52172009, 0x252008d2, 0x4c09815c, 0x896f090b, 0x1827200c, 0x4b084687, 0x591805e9, 0xa44a0820, 0x57012206, 0x055b5880, 0x85d34a21,
+    0x18d32020, 0x25071140, 0x09200909, 0x5a650e09, 0x05c84514, 0x4780b721, 0x4018057f, 0x4e830e80, 0x17450020, 0x7f012705, 0x2500c001, 0xc5693100,
+    0x012b270f, 0x011f1617, 0x37680716, 0x013f2108, 0x1919ef84, 0x33200a09, 0x1d337c8b, 0x0116390b, 0x10090a05, 0x0a10c0fe, 0x16010509, 0x821e0c39,
+    0x06834cad, 0x46014021, 0x128206ab, 0x401f942d, 0x0d0e0f03, 0x030f0e0d, 0x82941f40, 0xa0fe21a7, 0x20069046, 0x2b938560, 0x01c001e0, 0x003200a0,
+    0x01000058, 0x2b054347, 0x31303130, 0x33141732, 0x31301716, 0x30200383, 0x0ed2d118, 0x35262723, 0x269f8634, 0x37360531, 0x5b373631, 0x11210952,
+    0x091d4f21, 0x2208c662, 0x82000111, 0x087f2678, 0x05050105, 0x06c34a08, 0x22058260, 0x8233aa09, 0x00ff21a3, 0x82074475, 0x01602126, 0x7b75e883,
+    0xe0fe2706, 0x0112121b, 0x0e828001, 0x02010225, 0x470d0a04, 0x3321067d, 0x056941aa, 0x3082a920, 0x22834020, 0x21058041, 0xdb87e0fe, 0x086e4b18,
+    0x4b422020, 0x0bf65712, 0x15161728, 0x06071411, 0x4674012b, 0x08e86308, 0x4b420720, 0x93891821, 0x052b4209, 0x42064342, 0x49200853, 0x7f194b42,
+    0x43480a75, 0x2a438207, 0x291b1b01, 0x1b290001, 0x42c9011b, 0xd74b1a4c, 0x013f3105, 0x004000c0, 0x0059004d, 0x27260100, 0x26353423, 0x2120b082,
+    0x0725c782, 0x15141706, 0x06394423, 0x22561720, 0x44e18205, 0x3324052b, 0x27343736, 0x2005445d, 0x05814e27, 0x0e823620, 0x27260524, 0x4e562631,
+    0x27262405, 0x83070621, 0x33610819, 0x07060716, 0x12053c02, 0x09090165, 0x0d00ff0d, 0x01010909, 0x05126501, 0x07020301, 0x83391907, 0x0c0d021d,
+    0x0e140512, 0x0d02010d, 0x0e010edf, 0x1304150d, 0x02010c0c, 0x1b38831e, 0x02030807, 0x1411fe01, 0x51010505, 0x1b0d0e03, 0xa6012449, 0x0d1b4924,
+    0x0151030e, 0x01140505, 0x1301116e, 0x8251820e, 0x0f0b3259, 0x11010403, 0x24181803, 0x21542825, 0x0c12200a, 0x8151180d, 0x3e63820b, 0x54210a20,
+    0x18242528, 0x208a0318, 0x2e121d1d, 0x1d2c3231, 0x2c1d3434, 0x122d3232, 0x57201d1d, 0x232d0acf, 0x4a004100, 0x16130000, 0x3f323133, 0x090c5a01,
+    0x2112c674, 0x69182305, 0x222508dc, 0x011d0607, 0x18238214, 0x24129d44, 0x0d0d0a69, 0x12d1430a, 0x09098026, 0x01a07701, 0x4306f575, 0x44180670,
+    0x01231097, 0x18090909, 0x22105a44, 0x83800909, 0x42a92054, 0x441807a4, 0x9f43169c, 0x0029230b, 0x1746003d, 0x06072405, 0x41072627, 0x511806db,
+    0x362008e5, 0x2305ed56, 0x26273637, 0x27200383, 0x31202082, 0x23222382, 0x0f822322, 0x37363722, 0x07361f82, 0x1210ac01, 0x2b1a0e12, 0x3d36362b,
+    0x0609093a, 0x04080d07, 0x13930f04, 0x23d82808, 0x040a2324, 0x0d02020d, 0x2a290d02, 0x02050f2c, 0x0f8c010e, 0x0d080404, 0x09090607, 0x36363d3a,
+    0x0e1a2b2b, 0x93101212, 0x0a4c2113, 0x0b2b3d82, 0x292c0f04, 0x0e030c2a, 0x7900050f, 0xff2708ef, 0x1c00bf01, 0x18250000, 0x22081d4b, 0x6e013f36,
+    0x16240573, 0x37171617, 0x3b080a83, 0x17ff0107, 0x677f1807, 0x013e3d67, 0x18651701, 0x11082e0c, 0x29291935, 0x160f2c34, 0x3d03156c, 0x01011765,
+    0x67673d3e, 0x1707187f, 0x166c1604, 0x29342b0f, 0x11361a29, 0x180d2e08, 0x26089765, 0x00a001c0, 0x6d2f0014, 0x032016ad, 0x7c867e93, 0x42188020,
+    0x01210920, 0x079d4140, 0x030c203a, 0x3334400c, 0x01011e1f, 0x050c330b, 0x1b090418, 0x0816351b, 0x020b370a, 0x2a15936d, 0x0b32defe, 0x1f1e0101,
+    0x82403433, 0x0b022d3a, 0x16080a37, 0x091b1b35, 0x0d051804, 0x5b549482, 0x20a18208, 0xc3421813, 0x35332513, 0x37363736, 0x56088856, 0x23210560,
+    0x21b78206, 0x61189015, 0xa989084f, 0x28021038, 0x222c3d29, 0x05061222, 0x0c0c0d04, 0x130a060c, 0x17221813, 0xea540116, 0xeb431805, 0x28088408,
+    0x28293d30, 0x16160102, 0x82298225, 0x0c04292f, 0x010d0c15, 0x30221716, 0x2a066f4d, 0x00a00140, 0x001b000d, 0x18310026, 0x200871d0, 0x258f8421,
+    0x07061321, 0x8d6c0631, 0x21352305, 0x44182515, 0x4319095e, 0x022e0a8b, 0x12121b00, 0x01c0fd01, 0x011b1212, 0x068340c0, 0x8340fe21, 0x40022812,
+    0x010f30fe, 0x84400f01, 0x80802104, 0x04840683, 0x21054241, 0x24832020, 0x8305837b, 0x82c02034, 0x830f203b, 0x010f2223, 0xe7701820, 0x0003230a,
+    0xaf46ff00, 0x00182705, 0x00480036, 0x85831300, 0x85171621, 0x33322301, 0x1d493130, 0x27262305, 0xac822237, 0x17141524, 0x1b853316, 0x00441420,
+    0x27262106, 0xca850183, 0x20071653, 0x37138234, 0x0104161a, 0x33343d15, 0x03052021, 0x15010114, 0x26270501, 0x06493d3d, 0x2405d645, 0x2f4f5062,
+    0x06b8462f, 0x37380126, 0x1f745e5e, 0x8307c86f, 0x121238b7, 0x0110011c, 0x05041615, 0x33332120, 0x0402143e, 0x3d3d4916, 0x7e062627, 0x0125066d,
+    0x504f2f2f, 0x264a8562, 0x375e5e74, 0x19fe0138, 0x4e100fb8, 0x142f0aef, 0x38002600, 0x00004900, 0x07062125, 0x18150706, 0x83096c48, 0x5c0720bb,
+    0x33201084, 0x13201190, 0x36253885, 0x17162137, 0x21348335, 0x0c51d001, 0xa0012109, 0x0857e418, 0x396e9285, 0x200c850c, 0x292e8530, 0xa0011c14,
+    0x0d01141c, 0x4018140e, 0xf06312e4, 0x09d0180c, 0x8380200c, 0x0fc02531, 0xc00f0101, 0x17686a83, 0x0033220b, 0x06574241, 0x83141521, 0x21e082db,
+    0xa182012f, 0xcd182b20, 0x3d200997, 0x0a93de18, 0x36373222, 0x2506a273, 0x33152305, 0xc36c1732, 0x31232205, 0x068c7301, 0x13130129, 0x2e252b10,
+    0x8209332f, 0x82402080, 0x07b443bb, 0x33892808, 0x2b252e2f, 0x01131310, 0x0909e9fe, 0x2d37373c, 0x3c37372d, 0x10070c01, 0x10151510, 0x15940710,
+    0x2d0e0709, 0x48131324, 0x80250650, 0x1b121201, 0x333d8360, 0x2c241413, 0x1509070e, 0x16600c94, 0x06012815, 0x00161528, 0x24054371, 0x00bf01ff,
+    0x25bd8248, 0x16173637, 0x5b18011f, 0x17250757, 0x17010f16, 0x29b51816, 0x22d58209, 0x4d012f06, 0xe01805e2, 0x7e180f91, 0x2c080978, 0x011f3637,
+    0x0a2c0001, 0x10030e0e, 0x090a0e3e, 0x0d3f1203, 0x2e090304, 0x0403092e, 0x03123f0d, 0x3e0e0a09, 0x0e0e0310, 0x0b2d2c0a, 0x24239d0c, 0x012d0b0c,
+    0x82378e8b, 0x235bb513, 0x00050000, 0x02330082, 0x00800100, 0x00210013, 0x00450031, 0x37000073, 0x61311714, 0x2c49093d, 0x60372005, 0x1522094b,
+    0x0d8a0714, 0x16151428, 0x3413011d, 0xbc573127, 0x3732360b, 0x26273536, 0x26373435, 0x35272627, 0x17163736, 0x16171415, 0x78df1817, 0x584b1809,
+    0x83332009, 0x37362226, 0x0d325ee0, 0x42542c21, 0x5023059a, 0x85d00404, 0x01d12209, 0x2d228d30, 0x1d030a76, 0x02011213, 0x0a010f0d, 0x1e50150a,
+    0x353f2d05, 0x011a1a20, 0x213a2627, 0x120c0c09, 0x0c595018, 0xb4424020, 0x0d282205, 0x0654790b, 0x03010124, 0x8c493803, 0x361f820a, 0x0914103c,
+    0x14140208, 0x020d491d, 0x0d460d02, 0x0b010e0e, 0x8280110b, 0x2a01305b, 0x592c2424, 0x0127263a, 0x1015120e, 0x82000710, 0x41052000, 0x122b083b,
+    0x31002000, 0x72004400, 0x4c250000, 0xaf620988, 0x35272107, 0x26261389, 0x3734013d, 0x118a3431, 0x18033521, 0x300cf84a, 0x16171415, 0x07143733,
+    0x36373633, 0x2f343537, 0x05d15f01, 0x8205b048, 0x82352013, 0x17162116, 0x2805094e, 0x16071415, 0x01151617, 0x07884a00, 0x20052941, 0x06d55810,
+    0x01045423, 0x211185d1, 0x218d10d0, 0x21098022, 0x1a24ca83, 0x3f34211a, 0x0c33dc82, 0x0a15100b, 0x0f010109, 0x1201010f, 0x0b031d13, 0x610c0c13,
+    0x38210c42, 0x053c4128, 0x800d0b23, 0x7cdd1803, 0xfe382208, 0x0b0744a8, 0x12202908, 0x2627010e, 0x242c593a, 0x0c012a24, 0x1180110b, 0x0e010b0b,
+    0x0d460d0e, 0x490d0202, 0x0214141d, 0x10140908, 0x15101007, 0x26053b41, 0x01c0ff20, 0x42c001a0, 0x25260b77, 0x36313732, 0xaa62013d, 0x09b9620d,
+    0x17323323, 0x250d8927, 0x3b363332, 0x52182501, 0x072512a1, 0x27220706, 0x29058206, 0x36272623, 0x37323337, 0xfb183736, 0x16260994, 0x3b16011f,
+    0x13823601, 0x23063526, 0x27262722, 0x0d1f8118, 0x4e152442, 0x24420a04, 0x0acc7e2c, 0x090e4023, 0x22d34209, 0x010a752c, 0x12131d03, 0x0f0f0101,
+    0xd4420901, 0x00132414, 0x41000500, 0x7742073b, 0x0d0a650b, 0x06072225, 0x89230715, 0x2b062613, 0x31272201, 0x21118a22, 0x13640523, 0x3732250d,
+    0x32273536, 0x25054046, 0x010f2223, 0xa5190706, 0x3528084a, 0x2b262726, 0x36272601, 0x2805324c, 0x17323336, 0x33363736, 0x0cfb7a01, 0x21152342,
+    0x23425801, 0x42c02035, 0xd2420db0, 0x3520212a, 0x2109d242, 0xd1420e03, 0x0cbf760a, 0xa95b3d20, 0x071b480c, 0x20074f48, 0x0bb97413, 0xd9773720,
+    0x16172505, 0x010f1415, 0x2007fb4e, 0x190b6423, 0x32b38022, 0x2505ae4e, 0x01010a68, 0x5e50670a, 0xb3312105, 0x64058943, 0xfe221912, 0x2a8531e0,
+    0x29826820, 0x85670e21, 0x41302042, 0x6b6f053d, 0x57bb9e0d, 0x176b09d0, 0x0ac05709, 0x07160722, 0x9720bb99, 0xca87ae8e, 0x020c6724, 0xbb9a0a01,
+    0xaf8de920, 0x6721c986, 0x8dbe820f, 0x413e20bb, 0x17241c77, 0x22312306, 0x2009ad74, 0x2e59183d, 0x1736270a, 0x16011f36, 0xbc9a1415, 0x0d0a7f25,
+    0x41310a0d, 0x818b0531, 0x090a6722, 0xff23ba99, 0x41320909, 0xec8c069b, 0x820b6721, 0x41bb8d4c, 0x27212077, 0x0a946906, 0x21091951, 0x35423637,
+    0x19774106, 0x0f677f22, 0x6820b782, 0x8d05f441, 0x27ba99c2, 0x0c67d1fe, 0x680a0102, 0x8f053642, 0x000023c5, 0x7f700009, 0x000a3507, 0x001d0015,
+    0x0035002c, 0x004f0040, 0x00620059, 0x07142500, 0x24051f45, 0x16371516, 0x250c8215, 0x27343536, 0x13822733, 0x16171627, 0x36012b17, 0x21018237,
+    0x0b823617, 0x31171632, 0x31373621, 0x07063736, 0x07061723, 0x26231716, 0x3326db82, 0x33272617, 0x01820706, 0x27062726, 0x07312726, 0x11820382,
+    0x33222c82, 0x18843736, 0x60013127, 0x0103ba03, 0x08048201, 0x08089826, 0x7b03037b, 0x2810740b, 0x172c2d3c, 0x1209b095, 0x0b111110, 0x1011110b,
+    0xbbfe0912, 0x3c2d2c17, 0x70741028, 0x7b202c83, 0x40222a82, 0x21850912, 0x820a0c21, 0x83042021, 0x20398232, 0x83228282, 0x21c02429, 0x83211f1f,
+    0x83402003, 0x20202d06, 0x62201f21, 0x28271136, 0x23283738, 0x2c05c558, 0x38372823, 0x36112728, 0x211f2062, 0x24038220, 0x28ff1f21, 0x201d8937,
+    0x232c8339, 0x62363662, 0x00272483, 0x00020000, 0x82c0ff01, 0x00bf2504, 0x00300027, 0x2505774f, 0x3523010f, 0x8d183637, 0x07220763, 0x55541706,
+    0x37162209, 0x08018336, 0x26012730, 0x16373627, 0x01070617, 0x080903fc, 0x4c534d07, 0x09030207, 0x202f2824, 0x0c070820, 0x151515b2, 0xb2171c1c,
+    0x23302824, 0x090b0c23, 0x661854fe, 0x2508083f, 0x02030945, 0x4d534d06, 0x03090807, 0x230b0a09, 0x24273023, 0x1d1d16b2, 0xb2151616, 0x2008060c,
+    0x232a2e21, 0x4672b3fe, 0x06003d08, 0xf0ff0000, 0xa0010002, 0x23001100, 0x4c003800, 0x72006000, 0x16130000, 0x2706010f, 0x07d27018, 0x17363724,
+    0x11901531, 0x275b3720, 0x15312112, 0x07201492, 0x12fa4218, 0x18362321, 0x310ed773, 0x0d0f9827, 0x0b0a0748, 0x0e0e2807, 0x37161111, 0x0f8f1210,
+    0x09094823, 0x4042180e, 0x82402018, 0x076e471c, 0x2583fe20, 0xee57a020, 0x109a3110, 0x01085012, 0x10280902, 0x160e0e11, 0xa00d0f3d, 0x6620108f,
+    0x7f0bc54c, 0x0c8c0c4f, 0x200fb258, 0x08436d00, 0xa001ff30, 0x00001500, 0x21373613, 0x0f161716, 0x944c1501, 0x3d470805, 0x37262701, 0x190b0431,
+    0x0b19b001, 0x01b6100a, 0x40101111, 0x0a0fb70d, 0x01168901, 0x13171601, 0x0a137fe0, 0x0a300b08, 0x13e04f10, 0x00030017, 0x02e0ff00, 0x00c00100,
+    0x002d0014, 0x25000032, 0x26230706, 0x4d233527, 0x23220abf, 0x4c603715, 0x20628206, 0x05a25307, 0x6c5e1520, 0x012b2c05, 0x01153335, 0x600f0140,
+    0x18c0010f, 0x22093e56, 0x835090c0, 0x83a0200c, 0x835020bd, 0x05da5e04, 0xa0a08029, 0x01010f70, 0x4d90300f, 0x302108cb, 0x083d5ff0, 0x32833020,
+    0x83707021, 0x3030211a, 0x0021e682, 0x08f74301, 0xab7b4c20, 0x209b830a, 0x29f18433, 0x2f222306, 0x36372601, 0xae823337, 0x0e849a82, 0x4d343521,
+    0x1482067a, 0xcc7e2620, 0x07162108, 0x1520d682, 0x0808eb6d, 0x0800022b, 0x05090750, 0x60010d05, 0x06070f28, 0x0c07480a, 0x0a47070b, 0x270f0706,
+    0x050d015f, 0x50070905, 0x0c500808, 0x5f010d0e, 0x251f8327, 0x0b0a0847, 0x1f834807, 0x82612821, 0x500c23a5, 0x0f82c008, 0x07020625, 0x8560280f,
+    0x832d850f, 0x0602244d, 0x820b0748, 0x0509211d, 0x05211d93, 0x821d8209, 0x840620dc, 0x01802edb, 0x001100c0, 0x00360024, 0x005a0048, 0x18e5826b,
+    0x220c354b, 0x18161714, 0x82139763, 0x063150f1, 0x28051b55, 0x34051716, 0x37343137, 0x055a5826, 0x33171625, 0x8c012f26, 0x17162148, 0x23252382,
+    0x17140722, 0x5fc31916, 0x40012909, 0x011d1d2c, 0x2b1e1d01, 0x1d350783, 0x64322c1e, 0x0228283c, 0x010c0808, 0x08080c48, 0x3c282802, 0xa05b188e,
+    0xb8fe300f, 0x13110101, 0x1919253e, 0xc7100201, 0x8f380120, 0xa8013020, 0x0111133e, 0xc7200101, 0x19010210, 0x82802519, 0x2c2c225f, 0x8467841e,
+    0x01202f07, 0x0c382626, 0x07080807, 0x2626380c, 0x5418c001, 0x162208cf, 0x4c832217, 0x0606382e, 0x01080202, 0x11271b1a, 0x38332502, 0x20211e8f,
+    0x6dc31908, 0x0000350b, 0xff120002, 0x016e02d5, 0x003700ab, 0x1300006f, 0x32313336, 0x1620ec82, 0x0b37b918, 0x75262721, 0x062105e6, 0x20ff8215,
+    0xdec61817, 0x281a830c, 0x013f3435, 0x31230605, 0x240c8322, 0x3736013f, 0x83408636, 0xe3591806, 0x26272108, 0x21835282, 0x0807db4f, 0x14151646,
+    0x2cad010f, 0x262c3a39, 0x011f0504, 0x0b0d0c08, 0x0702020b, 0x02021101, 0x20201915, 0x18187019, 0x191c1d15, 0x0c0d0b02, 0x02020709, 0x332e010b,
+    0x2a2a2733, 0x2d270171, 0x262d393a, 0x011f0404, 0x0c0c0d07, 0x7123338c, 0x86161717, 0x08082133, 0x02233382, 0x8234332c, 0x01702933, 0x272a2a3d,
+    0x022c3434, 0x08202d82, 0x23086983, 0x1d1c1902, 0x71171716, 0x19212018, 0x11020314, 0x03020702, 0x0d0c0c0a, 0x041f0108, 0x392d2505, 0xf9712d3a,
+    0x33203282, 0x68833286, 0x1d180222, 0x70253283, 0x18202119, 0x23328215, 0x02030801, 0x7032328d, 0x01000000, 0xe0ff0000, 0xa0018002, 0x00002300,
+    0xd3533437, 0x07456a08, 0x0807ff5e, 0x2726214c, 0x37362726, 0x02603736, 0x2d442d2d, 0x17162424, 0x1b1b291e, 0x1d2c0601, 0x2401011c, 0x90fe3625,
+    0x0228293d, 0x2b1a1a01, 0x440404f8, 0x01022d2d, 0x10241615, 0x291b1b01, 0x23091112, 0x25362f22, 0x28020124, 0x24303d29, 0x836c1024, 0x001a270c,
+    0x25000025, 0x3e683527, 0x17162409, 0x69071733, 0x2f0809e4, 0x013d3637, 0x1f141533, 0xb5012301, 0x01160776, 0x16ce1502, 0x07150202, 0x13157502,
+    0x32012b13, 0x1513132b, 0x0730d4fe, 0xad300640, 0x0297bd2c, 0x083eb618, 0x25bd9734, 0x02022322, 0x54252223, 0xa00a084e, 0x4e080aa0, 0xef820400,
+    0xf801c02f, 0x2c00c001, 0x50003e00, 0x00005a00, 0x05434201, 0x5c010721, 0xe88705a7, 0x37171623, 0x05c26d27, 0x2307e754, 0x37170714, 0x43052e48,
+    0x33250687, 0x37363732, 0x10794303, 0x17013f23, 0x05e97216, 0x168d0132, 0x0b161d1d, 0x07e6fe0b, 0x301f2001, 0x01201f30, 0x16250783, 0x13262613,
+    0x830d8716, 0x26072307, 0x5446ed8e, 0x1066640f, 0x9c40a724, 0x50830b0b, 0x8d017629, 0x0d0d1515, 0x8912e5fe, 0x82202044, 0x2908225a, 0x25678f26,
+    0x0e143c8c, 0x5a83010d, 0x0e0d1527, 0xfe150d0e, 0x28668faf, 0x0d9c4069, 0x7615150d, 0x0a9f5800, 0x1a001628, 0x00003100, 0x6e7e3501, 0x4f172008,
+    0x232905d7, 0x35262722, 0x27331537, 0x261a9103, 0x27262726, 0x87708001, 0x83c0206f, 0x0e5f2708, 0x60200a09, 0x0046e060, 0x27158408, 0x12121b20,
+    0x60600101, 0x0dfd4418, 0x0909d029, 0x6060600e, 0x8de0a0fe, 0x01302517, 0x001b1212, 0x01340082, 0xc4ff0400, 0xb701bc01, 0x00004600, 0x31232601,
+    0x06010f22, 0x21052a4e, 0xab4a013f, 0xe0411806, 0x21119b0a, 0x31821617, 0x27343531, 0x136c0131, 0xb8131919, 0x2b212020, 0x7998212b, 0x983505e6,
+    0x33414133, 0x25b83030, 0x23252f2f, 0x1d17b023, 0x1515171d, 0x271b8590, 0x0c0a0a90, 0x1313b00c, 0x13213782, 0x243383b8, 0x08982020, 0x221b8308,
+    0x83303098, 0x23b82237, 0x22378323, 0x831515b0, 0x85902037, 0x0c90251b, 0xb00a0a0c, 0xc6826983, 0x2905d76e, 0xa001c001, 0x29001700, 0xcb823600,
+    0x27262722, 0x1806cc45, 0x27081c69, 0x27263537, 0x31272603, 0x43057543, 0x69180786, 0x17310a12, 0x54b10115, 0x09090a05, 0x12121bfc, 0x12120101,
+    0x060c581b, 0x18d10e21, 0x250fe976, 0xe00f0160, 0x0485010f, 0x05543f24, 0x2c630404, 0x13fc240d, 0x83e1fe10, 0x20378b12, 0x203083d0, 0x83048460,
+    0x560120b3, 0x834808d3, 0x48312005, 0x17200586, 0x200a436c, 0x82838a00, 0x06fa578d, 0x54876020, 0x24090a58, 0x00004001, 0x28548403, 0x008001c0,
+    0x00270013, 0x0f695e3a, 0x22212326, 0x15352627, 0x2012dc49, 0x09106505, 0x1807277b, 0x20100b48, 0xa5511909, 0xa44d1809, 0x188e4918, 0x0cdb8818,
+    0x4a180020, 0x112909fb, 0x39002500, 0x5f004d00, 0x95851800, 0x0b8c7008, 0x4a182520, 0x4b1826ec, 0x79181314, 0x791811aa, 0x102011ce, 0x180fb743,
+    0x1808815b, 0x8508e654, 0x98fe20d2, 0x30fe210f, 0x6020438f, 0x0121108f, 0x07be4360, 0xe65e0787, 0x059d4e06, 0x8c0c5c53, 0x5942180c, 0x20378708,
+    0x34488fa0, 0x00050000, 0x02e0ff27, 0x00a00120, 0x003f001f, 0x00670053, 0x06f7417b, 0x18013b21, 0x1808e0a3, 0x21086952, 0x0a832335, 0x47133121,
+    0xa7470587, 0x14072c06, 0x1633010f, 0x23070617, 0x82262726, 0x31272113, 0x13367e18, 0x93136341, 0x07372e13, 0x17200a07, 0x01171001, 0x0a501701,
+    0x22008207, 0x8208100a, 0x0d403f07, 0x130f0b0b, 0x130c0b11, 0x10161d1d, 0x21231001, 0x16020216, 0x06070f58, 0x0708480a, 0xac188901, 0x65530d94,
+    0x09636707, 0x01211f8f, 0x26548288, 0x02781602, 0x82021616, 0x200c8272, 0x25068260, 0x0c0be3fe, 0x68821110, 0x821a0f21, 0x1812247f, 0x83261218,
+    0x0d012820, 0x0a4e0b0f, 0x5215010b, 0x6b410b80, 0x620c8c0c, 0x1b280c83, 0x00004300, 0x06071625, 0x1805f178, 0x5d09606f, 0x27240578, 0x26233723,
+    0x2205d348, 0x5d373637, 0x2b4e068d, 0x17370807, 0x06231716, 0x21171607, 0x27263736, 0x06194c01, 0x311c1504, 0x0b0d3b32, 0x0404060c, 0x2a190d05,
+    0x262d302b, 0x09050a2f, 0x19b09c4e, 0x17183f16, 0x0e130406, 0x82442425, 0x04033320, 0x8a0d0607, 0x06092a45, 0x71160c0b, 0x16020216, 0x0583d001,
+    0x1f11802c, 0x050f0b1a, 0x05041806, 0x27820d04, 0x0a062b08, 0x01010c0c, 0x23381a14, 0x07085018, 0x1e111111, 0x030b0c16, 0x06031103, 0x0b0d0e06,
+    0x2c24040b, 0x1a26311c, 0x1502111a, 0x03830215, 0x220c2748, 0x824d0012, 0x612120db, 0x33210600, 0x07a55621, 0x15330122, 0x20070653, 0x10915635,
+    0x18013b21, 0x9009725e, 0x1833201c, 0x2a11bc51, 0x021090fe, 0x44442d2d, 0x18022d2d, 0x270efb52, 0x291b1b01, 0x011b1b29, 0x4954168d, 0x8001260c,
+    0x2c2d44a0, 0x27408202, 0x0909a043, 0x09080e0e, 0x2805c241, 0x1b1a29a0, 0x1c1b0101, 0x08b84128, 0x0a0d0d27, 0x0500000a, 0x058b4d00, 0x1800a021,
+    0x7209336d, 0x9a180653, 0x352910a6, 0x07331523, 0x23353315, 0x21038217, 0x0e833715, 0x15106d18, 0x83a0e021, 0xb96d1800, 0x60e0241b, 0x83604060,
+    0x60a02200, 0x0a5b5460, 0x00278383, 0x31352617, 0x6e013734, 0x013808e2, 0x2f222306, 0x27370101, 0x0e0e1707, 0x0f7d010e, 0x230e1413, 0x83fe0e0e,
+    0x012d0884, 0x6918694e, 0x140e0f18, 0x7d010f13, 0xd49b190e, 0x1301210a, 0x00201883, 0x04200082, 0x10778918, 0x8a18e186, 0x362d27cc, 0x21373637,
+    0x35331517, 0x06052327, 0x0e386a07, 0x18053845, 0x240cb068, 0x0d0e1470, 0xb78a1801, 0x0d012b21, 0x4001140e, 0x334d8030, 0xa94400ff, 0x4001210f,
+    0xc0201190, 0x30212f83, 0xa38a1813, 0x2337831f, 0x4d1360a0, 0x21a78a18, 0x00820020, 0x03820620, 0x40020030, 0x15008001, 0x25001d00, 0x33002c00,
+    0x6f184500, 0x6d67172b, 0x33153705, 0x31373627, 0x15233736, 0x07063505, 0x11330706, 0x16171623, 0x69183517, 0x022111b9, 0x08784700, 0x09874020,
+    0xfec00128, 0x12120180, 0x1184401b, 0x40424020, 0x40402105, 0xe0201283, 0x10905918, 0xff202984, 0x01204588, 0xc4470984, 0xc0402105, 0x395f4584,
+    0x21188505, 0x5918e040, 0x012611a3, 0x40000000, 0x06823f01, 0x00000f23, 0x05114b25, 0x57372621, 0x073f058c, 0x0b7f3701, 0x7f0a0d0d, 0x1509070f,
+    0x070915ff, 0x0980c90d, 0x13108009, 0x13010113, 0x82001013, 0x80002134, 0x40213b82, 0x203b8200, 0x0690423f, 0x2325f082, 0x37262726, 0x233a8509,
+    0x1608070e, 0x0e213a83, 0x843a8cb7, 0x0020243b, 0x836001c0, 0x2737223b, 0x08225026, 0x06070624, 0x2b8b8927, 0x0b7f2923, 0x2083820e, 0x2083870e,
+    0x243b8200, 0x01210040, 0x203b8500, 0x053b5713, 0x26270629, 0x37363527, 0x8b771736, 0x5701273b, 0x0c0b0b80, 0x85827f0b, 0x0e20c084, 0x2205d749,
+    0x43010002, 0xaf7707cf, 0x6d212006, 0x13290e11, 0x11231133, 0x33112301, 0x05314911, 0x08185b18, 0x0984fe20, 0xa0a04024, 0x03828001, 0x24143849,
+    0x0001c0fe, 0x83a482ff, 0x02002703, 0xe0ff0000, 0x6f824001, 0x1f000f22, 0x16df4718, 0x3608fe71, 0x011c2726, 0x06071308, 0x0b09840c, 0x0c85080b,
+    0x01130706, 0x83f8fe08, 0x07852511, 0x84090b0c, 0xe02b1183, 0x0e101001, 0x89080889, 0x8210100e, 0x200c8a58, 0x20008200, 0x226f8501, 0x4100a000,
+    0xe0830dcf, 0x38010722, 0x5683588b, 0x48877120, 0x3f865483, 0xaf870020, 0x108d4818, 0x8b8c9d90, 0x0020eb83, 0x01250482, 0x00120080, 0x08797725,
+    0x06010f24, 0x214b012f, 0x03212105, 0x67064c65, 0x352b08cf, 0x14d00117, 0x01010d0e, 0x1913da12, 0x2909f939, 0x151511f6, 0x1201da11, 0x6e411b12,
+    0x01da2e05, 0x0e0d0180, 0xa40e1814, 0x0ea40c0c, 0x25308318, 0x0d0dedfe, 0x3443d0a3, 0xa3d02207, 0x28fb8400, 0x01e0ff10, 0x00b001e0, 0xab421842,
+    0x054a470f, 0x085fc918, 0x06072223, 0x09696807, 0x08769018, 0x16173226, 0x3736011d, 0x2105574f, 0x4a821716, 0x321e1e3d, 0x3c4a3f32, 0x0801020b,
+    0x0b0c0d08, 0x2d44352b, 0x2d02022d, 0x2126442d, 0x483f1721, 0x90200543, 0x2c08a64a, 0x352d2e20, 0x1e32323f, 0x3ec0011e, 0x2a068333, 0x0d082c01,
+    0x020a0b0d, 0x46200802, 0x671807b2, 0x09270ff7, 0x28460e09, 0x82011717, 0x3e332169, 0x220b1358, 0x8243002c, 0x2f3427c5, 0x22232601, 0x4a18010f,
+    0x0b830778, 0x14150622, 0x21063242, 0x0b890717, 0x05353623, 0x8b2a8407, 0x27343712, 0x00022737, 0x09071707, 0x72060709, 0x16070705, 0x070a0908,
+    0x1183077d, 0x06060a24, 0x09830671, 0x08090a31, 0xe4fe097c, 0x0d0c0a3b, 0x0909730a, 0x840d092e, 0x2d3a3007, 0x160809e8, 0x71050707, 0x0a080805,
+    0x82091607, 0x090a2137, 0x49833982, 0x84080821, 0x057d2c09, 0x093b160a, 0x0d0a7309, 0x862e0a0c, 0x2e3b2107, 0x0808a765, 0xc0017f30, 0x00001600,
+    0x17163337, 0x06050716, 0x013f2627, 0x26272623, 0x17362537, 0xf1010f16, 0x0807166f, 0x1300ff10, 0x4d091315, 0x07091471, 0x0b840110, 0x01e04c2b,
+    0xe00f1414, 0x17100d0f, 0x2a0989b3, 0x00010000, 0x02e0ff00, 0x18a00140, 0x830921e9, 0x05b05e58, 0x85152321, 0x60118a0b, 0x3625061f, 0x26353337,
+    0x5d1f8727, 0x2d4406bc, 0x22198205, 0x18070623, 0x180afe67, 0x210a2e64, 0xc5543635, 0x24458405, 0x0e0d01d0, 0x08724614, 0x18980827, 0x08010f10,
+    0x06b54f14, 0x01221789, 0x15929807, 0x94079821, 0x100f222b, 0x4f2d8618, 0x4984088f, 0x82012821, 0x8c202019, 0x23178470, 0x28010720, 0x28221591,
+    0x2b930701, 0x2d85a083, 0x0be39b18, 0x4e001a26, 0x15370000, 0x2406b677, 0x06070607, 0x016b1817, 0x26352907, 0x25070627, 0x26312726, 0x820a075f,
+    0x67a31820, 0x51372009, 0x32820763, 0x43163121, 0x43080551, 0xff273637, 0x030c0f01, 0x0d0c0b05, 0x0506050d, 0x19141509, 0x01171623, 0x0f12120e,
+    0x47184101, 0x09095a47, 0x0a090e0e, 0x1847465a, 0x08060601, 0x27282927, 0x150f090a, 0x131b2115, 0x030b0b13, 0x260b0901, 0x092d1282, 0x92010606,
+    0x01010f82, 0x05060c0a, 0x314c8304, 0x010f0e18, 0x82231617, 0x0d02010d, 0x3b3b6715, 0x6543120a, 0x0a123d05, 0x08673b3b, 0x2a070505, 0x0e420607,
+    0x16161c0e, 0x0f0f0101, 0x02071011, 0x06420e0e, 0x05231582, 0x82000805, 0x18042000, 0x250c3f6e, 0x003f0028, 0xe2820100, 0x23272622, 0x3251e783,
+    0x8311200a, 0x273323d5, 0x6f592726, 0x15052405, 0x51072733, 0x222f1137, 0x01352627, 0x0e0d0140, 0x25123914, 0x41391225, 0x902a07fa, 0x22171601,
+    0x0216a030, 0x03831602, 0x60000124, 0x5d512060, 0x8260200d, 0x600122b7, 0x23308310, 0x1e02021e, 0xfe214283, 0x243e84c0, 0x16172210, 0x24821801,
+    0x60282108, 0x54510082, 0x09d0230d, 0xca820e09, 0x0003002b, 0x01c0ff10, 0x00c00170, 0x05cb730e, 0x1f141722, 0x33287782, 0x36013f36, 0x15233537,
+    0x2a098366, 0x31141716, 0x30333130, 0x83353031, 0x05725ed6, 0x2105cb73, 0x83450706, 0x82162005, 0x7022080e, 0x100a1205, 0x120a103e, 0x4fa00104,
+    0x0130314d, 0x0f0d2b01, 0x08a00810, 0x2b0d0f10, 0x32320201, 0x9b83014b, 0x54180120, 0x063a0abe, 0x0d1a080a, 0x1a0d0101, 0x27270a08, 0x3203c601,
+    0x30444733, 0x191a190f, 0x04820101, 0x452f0f27, 0x0231324a, 0x27958260, 0x01011021, 0x1f202f0f, 0x0e210582, 0x0bcf4401, 0x45002226, 0x21130000,
+    0x240c416f, 0x2326012f, 0x05c34422, 0x2108344c, 0x5f182105, 0x4e4c1707, 0x01202308, 0xce5c3a73, 0x09702e05, 0x0d0a7009, 0x09090a0d, 0x0e8dfe3a,
+    0x24008209, 0xfec0010e, 0x211d918d, 0x1d867301, 0x85391021, 0x8236842f, 0x230d833e, 0x0e090939, 0xa0201e82, 0xc7471a99, 0x80022a05, 0x2400a001,
+    0x00003900, 0x08f55117, 0x341a8e55, 0x013f1637, 0x0f262736, 0x27263501, 0x27150706, 0x1f060726, 0x08825501, 0x3318a355, 0x5010119f, 0x11100f0f,
+    0x16160227, 0x11102802, 0x20500e0e, 0x55079555, 0x582318b6, 0x83500f0f, 0x8627292a, 0x16020216, 0x0e0e2786, 0x774e4582, 0x21b7ae08, 0xb9821706,
+    0x09709218, 0x82012f21, 0x20b7a1c3, 0x2073834f, 0x22b48328, 0x84101127, 0x20b7a28e, 0x202a83d9, 0x20b48526, 0x20f58326, 0x18ee8250, 0x28083fdb,
+    0x00c001c0, 0x00670011, 0x7d801874, 0x07062614, 0x15070631, 0x4e731816, 0x5f362007, 0x1d22050b, 0xbf840701, 0x013d362d, 0x27262734, 0x16171635,
+    0x71141517, 0x3d21060f, 0x24258201, 0x07061537, 0x08904e06, 0x302c2484, 0x013b3231, 0x31303332, 0x0706010f, 0x0806de50, 0x17163328, 0x25016001,
+    0x24363724, 0x24020224, 0x24373624, 0x14410125, 0x01010d0e, 0x0b0b1005, 0x010c0a0a, 0x0e0d0909, 0x0a82090a, 0x100b0b29, 0x150d0e05, 0x82232438,
+    0xfe0e2c13, 0x09090e80, 0x38242301, 0x180b0b12, 0x29078ba6, 0x04120b0b, 0x04047004, 0xd7187801, 0x0121099b, 0xcd7d1840, 0x06ea2e0f, 0x18171110,
+    0x0a100407, 0x0c0b0b0a, 0x05b34211, 0x0b0c1122, 0x102d6282, 0x17180704, 0x35061011, 0x3d2c2c0e, 0x2a198508, 0x2c2d3c08, 0x0e063d0e, 0x5e18130f,
+    0x1827059d, 0x060e0f13, 0x503e3a42, 0x023107c3, 0x00000016, 0xff200002, 0x013002c0, 0x004900c0, 0x07494152, 0x65171421, 0x262106e9, 0x05184427,
+    0x2f263524, 0xfe822601, 0x8e4f1f20, 0x3637210a, 0x07211385, 0x05fb6a15, 0x36171626, 0x35373637, 0x35200482, 0x15203683, 0x0808a55e, 0x1722e040,
+    0x0e0d0116, 0x1f200115, 0x201f2e30, 0x24243703, 0x3f120101, 0x02040616, 0x1b011f15, 0x1c29281b, 0x151f011b, 0x16060303, 0x0101123f, 0x04382324,
+    0x4b493231, 0x16023231, 0x16010d0d, 0x41452217, 0x83502008, 0x13193f0d, 0x2c4f0914, 0x01011e1d, 0x0d2a1c1c, 0x9a3c2b2a, 0x020d0513, 0x06161015,
+    0x1c287a06, 0x5182021b, 0x067b293c, 0x15101606, 0x13050c03, 0x2b2b3b9b, 0x2e2e450c, 0x302f0202, 0x14094f47, 0x8d831913, 0x08997318, 0x2c080f6b,
+    0x000c00c0, 0x001e0019, 0x1300002b, 0x27d08311, 0x06231133, 0x25070607, 0x11220584, 0xd3841121, 0x33352327, 0x11233315, 0x08bc7133, 0xd8820020,
+    0x57301421, 0x502005e9, 0x84053253, 0xa0a02212, 0x23158680, 0x01140e0d, 0x2007107c, 0x202d8380, 0x2b048390, 0xb00150fe, 0x010d0e14, 0xfe303060,
+    0x01211584, 0x0ac36a20, 0x01c0012b, 0x002400c0, 0x0100002e, 0x208b8315, 0x05b57315, 0x82210721, 0x013f2184, 0x20056441, 0x07e76137, 0x31152508,
+    0x26272203, 0x07143335, 0x00012306, 0x01242338, 0x0d073001, 0xfe140908, 0x08091480, 0x012f080d, 0x38242301, 0x0805c544, 0x131a2023, 0x13138013,
+    0x13a0011a, 0x3b2b2b0c, 0x09364913, 0x0112130f, 0x0f131201, 0x13493609, 0x0c2b2b3b, 0x053d4213, 0x8220fe21, 0x462d8226, 0x635a0563, 0x00162407,
+    0x6e310022, 0x988405f1, 0x37363324, 0x394b3736, 0x23152308, 0x52553335, 0x21172307, 0x516c0706, 0x27263a08, 0x78fe0002, 0x1b010216, 0x29c0291b,
+    0x20011b1b, 0x01252436, 0x36242501, 0x054a5820, 0x1b121238, 0x0fe0fd30, 0x0e0d0101, 0x14e00114, 0x01010d0e, 0x02a0010f, 0x5a18e816, 0x2b82080f,
+    0xc0213383, 0x07e75680, 0x0f01c022, 0x31822784, 0x00010f23, 0x09a75000, 0x35001827, 0x6c005000, 0x06bd4d00, 0x11209184, 0x5f050f5f, 0x1125050e,
+    0x15070617, 0x22038223, 0x82331716, 0x20be82c5, 0x06bb5a35, 0x27263525, 0x49110723, 0xae1805e7, 0x35200c2d, 0x2125e784, 0x16311716, 0x833a8317,
+    0x83418239, 0x23538306, 0xc0331123, 0x55093f5f, 0x50250793, 0x18010f78, 0x23c9820f, 0x100f0118, 0x98210a8a, 0x20b88370, 0x20198350, 0x83058550,
+    0x42702031, 0x16900510, 0x9a187020, 0xfe220908, 0xf2875030, 0xd0015025, 0x8e0f0110, 0x22638458, 0x4260fe20, 0x0f240565, 0x0140010f, 0x865a0482,
+    0x83302008, 0x5912840d, 0xa02005cd, 0x0d7b8a18, 0x38003227, 0x5c004a00, 0x03001900, 0x1f32210a, 0x23ae9c18, 0x412fe151, 0x92411476, 0x70012106,
+    0x2353fe51, 0x0f0190fe, 0x2025fd82, 0x0f30010f, 0x520a8b01, 0x01205016, 0x79846391, 0x44082b54, 0x2b240567, 0x4d003000, 0x44106944, 0x2f200957,
+    0x20052d52, 0x06b04223, 0x23112129, 0x15332335, 0x7c133523, 0x232609e1, 0x36352726, 0x03833337, 0x15171623, 0x2c038233, 0x0e0d0100, 0x14101014,
+    0x01010d0e, 0x820786d0, 0x09d96111, 0x40012032, 0xa0a0d020, 0x380701b0, 0x07300701, 0x01073801, 0xa5440a8b, 0x0c96440c, 0x28094242, 0x800180fe,
+    0xfe303030, 0x843d90f8, 0x0b637a53, 0x4e004324, 0xad190000, 0x172d0889, 0x011f3233, 0x0f061716, 0x012b0601, 0x07025807, 0x2321c083, 0x23118207,
+    0x3d262722, 0x07ee9718, 0x34353326, 0x013b3637, 0x33212f82, 0x21e58235, 0x03720731, 0x02a03709, 0x02167016, 0x68101602, 0x660b0c74, 0x0e01010e,
+    0x740c0b66, 0x13831068, 0x08281884, 0x0d093720, 0x09090e13, 0x8205c544, 0x0d132907, 0x08203709, 0x0f500216, 0x21081772, 0x5146a801, 0x04902905,
+    0x0f0f0726, 0x90042607, 0x2405a14b, 0x37900216, 0x093d7f09, 0x43834020, 0x1b823720, 0x0f01d822, 0x0f333c83, 0x00000001, 0xff200005, 0x010002e0,
+    0x002000a0, 0x7636002b, 0x01230507, 0x18343523, 0x29087993, 0x17161716, 0x36373633, 0x03823537, 0x66703620, 0x06012105, 0x0859d618, 0x0a943320,
+    0x0f14372b, 0x16333501, 0xb0011517, 0x21818230, 0x9978e0fe, 0x1be02e06, 0x51011212, 0x010d0c16, 0xfe221716, 0xee6e18f0, 0xf76e1810, 0x09a02308,
+    0xa4823037, 0x85206021, 0xa2ac18f8, 0x24202c09, 0x1813140a, 0x16172263, 0x82f0fe01, 0x09495c21, 0x5d270990, 0x9a18050a, 0x82630f01, 0x02002de6,
+    0xe0ff0000, 0xa001c001, 0x2d001400, 0x8417e374, 0x152321ca, 0x3522d18a, 0xc4833736, 0x2514e174, 0x16160230, 0x6a418002, 0x73088407, 0x595c0596,
+    0x27ef830b, 0x0216b8fe, 0x50501602, 0xd0200583, 0x978d0a8a, 0x2e001522, 0x21176b55, 0x59183603, 0xb21816f6, 0xa02115ff, 0xf2591816, 0x219a9612,
+    0x5a1802b0, 0x3a840d19, 0x02219882, 0x82008200, 0x00802633, 0x00310018, 0x687c1800, 0x0772510a, 0x35363726, 0x33012f34, 0x2117c04c, 0xb54c8a4d,
+    0x23531805, 0xc08a2109, 0x89201292, 0x1805a14c, 0x200b6453, 0x41139389, 0x2025052b, 0xc0010000, 0x21938601, 0x504d2737, 0x0c684d08, 0x97332721,
+    0x84f72018, 0x09092266, 0x2088898a, 0x201291c0, 0x83b282d7, 0x8b879495, 0x8293859b, 0x80012b05, 0x1800a001, 0x00003200, 0x3279013f, 0x33162312,
+    0x1e603f32, 0x2026890f, 0x41679337, 0xc920140f, 0x2084b78a, 0x0e090923, 0xd3551809, 0x201b8807, 0x06eb4200, 0x27418020, 0x287e1808, 0x091c410d,
+    0x89073721, 0x21238b0b, 0xfe83a907, 0x200f0541, 0x20a793a0, 0x207f91a9, 0x23a5910e, 0x01000000, 0x00220382, 0x9384e000, 0x18370021, 0x2217835d,
+    0x420a0dc0, 0x8a250a2f, 0x0d0a0909, 0x8de08500, 0x204f838d, 0x87048320, 0x835d184f, 0x0d402216, 0x0ced410a, 0x4f83a020, 0x8312db41, 0x0000264a,
+    0x01800160, 0x5f491840, 0x0d60221d, 0x1106410a, 0x50426020, 0x0598410b, 0x4020ef84, 0x20204f82, 0x1c5f4918, 0x908eef85, 0xd2414020, 0x41092010,
+    0xe13805d3, 0xa0018002, 0x21001000, 0x21130000, 0x26113311, 0x21272627, 0x07060706, 0x01200b82, 0x32690882, 0x2726250a, 0x40800180, 0x09ce4718,
+    0xf0014036, 0x010fa0fd, 0x1b121201, 0x121b0002, 0x0f010112, 0x00ff6001, 0x09587718, 0x01f0fe28, 0x02e1fe00, 0x1c84100e, 0x10232682, 0x5c00020e,
+    0x14220cef, 0x37452600, 0x10497717, 0x30450120, 0x0c586a14, 0x56c00121, 0x098309f3, 0x83800121, 0x30fe2179, 0x0edc4518, 0x0f520220, 0x207fac08,
+    0x09455b40, 0x4f5b0120, 0x0cc67408, 0x77052e6a, 0x7f920fdf, 0x20000022, 0x602e2b82, 0x41002000, 0x22370000, 0x37363507, 0xec5d3736, 0x07062207,
+    0x052f4e06, 0x26241483, 0x21272627, 0x6022209f, 0xee830f11, 0x2305d646, 0x01252436, 0x210ba75a, 0x1d9b0001, 0x0606e022, 0x2309b47f, 0x36242501,
+    0x08404c18, 0x1b1b2923, 0x221c9c01, 0x87000200, 0x002124c7, 0x53000043, 0x32220946, 0xc4831537, 0x42452220, 0x20c78306, 0x20c88335, 0x15451805,
+    0x8825930c, 0x21b3937d, 0xd78b6001, 0x1d882190, 0xd79db594, 0x54070021, 0x112c08ef, 0x35002300, 0x5a004700, 0x7f006c00, 0x20133751, 0x8a4b1811,
+    0x6d252010, 0x4b18108c, 0x052411ae, 0x34313526, 0x28056151, 0x06071415, 0x31272223, 0x05a06913, 0x2208a44e, 0x67170714, 0x208605a6, 0x19822620,
+    0xe6183120, 0xcf621136, 0xd0fe210f, 0x0221118f, 0x27118f00, 0x0e0e4bfe, 0x0f13130f, 0x44200585, 0x0e220a89, 0x0c8be20e, 0x1909484d, 0x8b0d9813,
+    0x05705a4f, 0x140e0d22, 0x870f415e, 0x8cb5200f, 0x8b262051, 0x8be22079, 0x8200200c, 0x41012000, 0x1a200877, 0x200f735a, 0x05825527, 0x18053951,
+    0x1819095d, 0x4e18f15c, 0x002a06ef, 0x1a00c001, 0x46003400, 0x61185800, 0x17231ce7, 0x18060726, 0x7f090ebb, 0x262606d9, 0x31272627, 0x935f2237,
+    0xdb441806, 0x4cb61808, 0x8207200c, 0x183320a1, 0x08185f61, 0x0b0ba421, 0x1c11090b, 0x1d2a291d, 0x0a09111d, 0x170e0b0c, 0x17202117, 0x0d0c0e16,
+    0x01010909, 0x430d0909, 0xc84405b6, 0x98148706, 0x0b462dd5, 0x140c0b09, 0x01011010, 0x0c141010, 0x10280c82, 0x01010c0d, 0x96100d0c, 0x180be544,
+    0x200ce35a, 0x0ccf5700, 0x35001a26, 0x59004700, 0x421d0b41, 0x162308d0, 0x60273637, 0x0623077b, 0x41371617, 0x9f333d0c, 0x231a1a0a, 0x0a1a1a23,
+    0x030d0f05, 0x2e22220d, 0x8222222e, 0x050f2208, 0x350c4111, 0x5f1e8521, 0x1e25054b, 0x0f05030d, 0x054c5728, 0x050f2825, 0x41d50d03, 0x04201b0c,
+    0x240a7342, 0x003e002c, 0x1c0b4149, 0x0c134b18, 0x17160724, 0x0f423316, 0x0a7e4d11, 0x20180842, 0x05e741b0, 0xa020e887, 0xb025f18d, 0x0f01010f,
+    0x410484c0, 0x711818fa, 0xe1410cc9, 0x4da0200c, 0xdb82087d, 0x0200002d, 0x00800180, 0x002b0012, 0x474f003d, 0x6852075f, 0x2726220a, 0x06904c07,
+    0x27262722, 0x4f051f4f, 0x0621051e, 0x60561807, 0x47372011, 0xc0201188, 0x091e6e18, 0x18000121, 0x2a07286e, 0x160220c9, 0x161f0216, 0x84160203,
+    0x16203209, 0xb8170102, 0x0c0b0b11, 0x0c10100b, 0x120a0b0b, 0x820c8540, 0x250c8205, 0x36028001, 0x3c875236, 0xd8200783, 0x3b823182, 0x15020124,
+    0x0a850216, 0x40205083, 0x11253e82, 0x0b0c0c0b, 0x20378211, 0x230c8b60, 0x000e0000, 0x02230082, 0x18800140, 0x2b128793, 0x00960089, 0x00b000a3,
+    0x250000bd, 0x0d9e7018, 0x2305ce69, 0x27263501, 0x2206df52, 0xb2333736, 0xb205200c, 0x8c678c33, 0x98212040, 0x0002224d, 0x0adb62fe, 0x2508ef62,
+    0x280b0180, 0x0484010b, 0x0aaa6020, 0x37c2fe20, 0x01200124, 0x7b83e80b, 0x7b8a0482, 0x4a05e861, 0x12230508, 0x85ff1b12, 0x870c2009, 0x9fa489a5,
+    0xd0602009, 0x00003332, 0x20000300, 0x2002c0ff, 0x2900c001, 0x77006c00, 0x86180000, 0x26230821, 0x4c343107, 0x112906b3, 0x36331716, 0x17363537,
+    0x23018316, 0x11373637, 0x07391983, 0x36150706, 0x23061537, 0x22352722, 0x26232223, 0x27261527, 0x22270635, 0x22188223, 0x82350706, 0x85348227,
+    0x36152608, 0x32173233, 0x05345933, 0x32171623, 0x820b8237, 0x1527213b, 0x35305183, 0x27262722, 0x090afe01, 0x21292741, 0x54313123, 0x0805a444,
+    0x200f0136, 0x344c010f, 0x342c2c34, 0x01133f2d, 0x1e0e0a0a, 0x2a26212f, 0x08081e22, 0x05050102, 0x2d231d26, 0x01020404, 0x211f261f, 0x060d0e19,
+    0x19241c06, 0x1d271215, 0x022d1382, 0x0e0d1b1a, 0x0605251e, 0x2a260101, 0x2e0c83f0, 0x2c210102, 0x1e04c001, 0x0e0d0202, 0x44220203, 0xfe280572,
+    0x01010f30, 0x0222700f, 0x09b98618, 0x090e3808, 0x02148e08, 0x52100251, 0x014a010b, 0x030a4309, 0x0101014c, 0x0c08450b, 0x04060b3f, 0x08520203,
+    0x080b3f0e, 0x010a4206, 0x040a0345, 0x010c4204, 0x10024401, 0x83500840, 0x0153220d, 0x0566440d, 0xff00002e, 0x014002e0, 0x001900a0, 0x1300002d,
+    0x1807e148, 0x4d093182, 0xbf6a0642, 0x4f092013, 0x6b1805ca, 0x02210b1e, 0x0fdd6b17, 0x4f690121, 0xc02005ca, 0x6b180683, 0xfe210832, 0x0dd04bb7,
+    0x87820320, 0x8002c026, 0x1300c001, 0x47238782, 0x19010000, 0x240d1e27, 0x07161716, 0x20949031, 0x06774926, 0x07053122, 0x15f06418, 0x0131072c,
+    0x0b04809f, 0x060d0d0c, 0x08880306, 0x325d6820, 0x5a5a2109, 0xfe21c385, 0x890987a0, 0x9701231b, 0x378340fe, 0x01213f83, 0x200987c0, 0x0b355d50,
+    0x85595921, 0x872e20dc, 0x201c8b08, 0x20008200, 0x31d78202, 0x014002e1, 0x002000a0, 0x37000033, 0x36371617, 0xcd833537, 0x0a840620, 0x23059e5e,
+    0x26272635, 0x20052370, 0x22158423, 0x89372735, 0xb0883612, 0x010d0d0d, 0x1c1e1d52, 0x0c090a03, 0x01181822, 0x633d3e02, 0x23148201, 0x800808b0,
+    0x9e211c84, 0x2a0e869e, 0x060a97de, 0x08541006, 0x825b292a, 0x190632af, 0x612e2a29, 0x52062829, 0x0a060610, 0x0b0a0898, 0x231f8407, 0x10888710,
+    0x97391183, 0x070b0b08, 0x00010000, 0x01f1ff10, 0x009001b0, 0x25000010, 0x27262706, 0x08a16235, 0x03072508, 0x190b1e01, 0x18b00219, 0x01170406,
+    0x0e101360, 0x17049007, 0xb0190604, 0x0b191802, 0x100e0790, 0x00a0fe13, 0x00284383, 0x0002c0ff, 0x4000c001, 0x57644382, 0x08064b09, 0x33071123,
+    0x20558315, 0xf37c1827, 0x08354b0a, 0x23371124, 0x584b3335, 0x010f2407, 0x53c00111, 0x202006df, 0x25052542, 0x1be0b3d3, 0xdb781212, 0x21148807,
+    0x7d4136f3, 0x47372005, 0x34860648, 0xd3330128, 0x12120140, 0xf56a011b, 0x24168606, 0x40d3cdfe, 0x05ed4137, 0xedfe3622, 0x27074f49, 0xc001c001,
+    0x50004700, 0x3105b57b, 0x31071413, 0x36150706, 0x3736013b, 0x26353736, 0x69742627, 0x60451808, 0x56072007, 0xe31905ad, 0x2b8813cd, 0x3607312a,
+    0x06272637, 0x25171607, 0x0c830483, 0x11855082, 0x0d0da026, 0x60231d16, 0xf75bcf83, 0x17222306, 0x14820116, 0x25240123, 0x8a169236, 0x38221924,
+    0x20012108, 0x2305d955, 0xe0fe1602, 0x01270987, 0x13131970, 0x8311580a, 0x0a0722f9, 0x05005c13, 0x2605485c, 0x36070a13, 0x84012425, 0x071a5c19,
+    0x14221985, 0x2a8bce09, 0x08666318, 0x16023022, 0xfe215785, 0x09277b70, 0x2e097b5a, 0x003a0031, 0x00610043, 0x17361300, 0x82171631, 0x17072101,
+    0x7605f053, 0x1720158e, 0x095fad19, 0x2627362b, 0x31072627, 0x17372617, 0x220a8206, 0x4e172731, 0xff760561, 0x2cba2a15, 0x21283535, 0x20120808,
+    0x15827660, 0x188e5b21, 0x34090760, 0x09733493, 0x1919141e, 0x032d1918, 0x262626ba, 0x3d32921e, 0x14ec7618, 0x48013934, 0x26030321, 0x2a2b2c22,
+    0x21195f18, 0x02161820, 0x78761203, 0x6f5a2111, 0x09166018, 0x5b297333, 0x0413212a, 0x30db0a03, 0x090b923e, 0x28c01d09, 0x19e5763e, 0xfb433820,
+    0x00c12e07, 0x00a001c0, 0x00350023, 0x35233700, 0x815d1834, 0x1b81180c, 0x75232011, 0xa02111a4, 0x95451820, 0x435e1809, 0x06b05007, 0xbc4d4020,
+    0x7100200f, 0x0e220652, 0x1d720908, 0x090d2209, 0x05b56309, 0x00212d8b, 0x26a08502, 0x1e00c001, 0x64005800, 0x0f280517, 0x06070601, 0x15331617,
+    0x08bc4f18, 0x08614518, 0x31373223, 0x21bd8636, 0xc48c010f, 0x5e181720, 0x68180d25, 0x2b310a15, 0x33372701, 0x0e01e001, 0x0c20100f, 0x09050404,
+    0x051a4614, 0x2c4d4020, 0x1020260c, 0x0a56560a, 0x06a34310, 0x5a5a0f23, 0x911e850f, 0x20012d17, 0x09091280, 0x0c071007, 0x50120c0c, 0x440b3e46,
+    0x0e220610, 0x3b827a7a, 0x03820e20, 0x6e808021, 0x0e2105d7, 0x25118379, 0x0a090d0d, 0x87637f80, 0x85802009, 0x452520f3, 0xf3960662, 0xf3c30320,
+    0x665e0a20, 0x20f3b706, 0x20f29700, 0x06f24401, 0x072df3a1, 0x0002e0ff, 0x1d009901, 0x00002300, 0x0afd7325, 0x09ef7218, 0x27065747, 0x27372333,
+    0x01331707, 0x36064542, 0x131bb7fe, 0xea121250, 0x131a1a13, 0x8312128a, 0x8a44d77c, 0x4172507c, 0x1321066c, 0x23178350, 0x8a1212ea, 0x83250783,
+    0x507d8a43, 0x0a074600, 0x7900bf22, 0x06256d82, 0x07063107, 0x067c4e22, 0x07141526, 0x26012b06, 0x18051250, 0x21085790, 0x4a5f1714, 0x82232005,
+    0x013d2326, 0x0d833736, 0xa46a1620, 0x1806200c, 0x4708b6ac, 0x2622052c, 0x2a463635, 0x82172005, 0x05b54d50, 0x16173224, 0x9861011d, 0x05b86a05,
+    0x21053d51, 0x1e82070d, 0x0216102d, 0x480e0909, 0x0c020216, 0x5f060507, 0x06320756, 0x020c0705, 0x0e881602, 0x16020909, 0x0706080f, 0x1f430d07,
+    0x20358a07, 0x20359588, 0x24358e48, 0x12121ba0, 0x22518c01, 0xa2050810, 0x84132051, 0x010d2935, 0x0e481502, 0x15040908, 0x0e228788, 0x8589140d,
+    0xbb890d20, 0x001b1322, 0x02200082, 0x2808fb54, 0x00410013, 0x37363700, 0x05ab4631, 0x76542720, 0x06372308, 0x0c821507, 0x82262721, 0x05796501,
+    0x16171623, 0x05704417, 0x3317162a, 0x27343736, 0x35012b26, 0x2006e446, 0x0f546fc0, 0xf7829820, 0x3927262f, 0x01222233, 0x02161602, 0x432a2a01,
+    0x2af38328, 0x020ea00e, 0x280e0909, 0x822b2a42, 0x01602518, 0xa0291b1b, 0x08843b87, 0x02a02708, 0x24392915, 0x26050225, 0x15243327, 0x20150202,
+    0x0b333345, 0x0f090a23, 0x0d01010d, 0x220a090f, 0x4430300a, 0x43561529, 0x7f022b09, 0x2100c001, 0x00004600, 0x8f822305, 0x85062721, 0x056d4bb3,
+    0x3625b08a, 0x17232627, 0x84e78427, 0x5c2720db, 0x22210672, 0x4b0e8207, 0x173205fb, 0x36371601, 0x277f0127, 0x162c1b1f, 0x23223318, 0xb9823001,
+    0x0d284233, 0x0e020909, 0x01010e9f, 0xf80e0908, 0x0201179f, 0x3ed28215, 0x01091a0e, 0x2a281a1a, 0xba011c1c, 0x080b0807, 0x4f02100c, 0x100d0f13,
+    0x0e042210, 0x83010722, 0x250422c0, 0x08bd8326, 0x09092237, 0x0201100d, 0x090a0e0d, 0x31277d05, 0x02021628, 0x1a202716, 0x9b151114, 0x021d1c29,
+    0x362a1b1b, 0x13090591, 0x0c31fe0f, 0x00101110, 0x00010000, 0x01c3ff0f, 0x20d782f0, 0x270c821d, 0x16011f32, 0x16151617, 0x9141a782, 0x82262007,
+    0x363d08e8, 0x3336013f, 0x07000131, 0x0a11bd06, 0x1212010b, 0x1a562e2f, 0x2f2e561a, 0x0b011212, 0x06bd110a, 0x03c00107, 0x0f0f0750, 0x44453413,
+    0x0c2b4242, 0x42422b0c, 0x13344544, 0x50070f0f, 0xc7931803, 0x00232f0a, 0x13000031, 0x36313734, 0x16173233, 0x6518011d, 0x0a820839, 0x65187882,
+    0x01200950, 0x09715018, 0x11211123, 0x05404560, 0x12016518, 0x01600126, 0xfe140e0d, 0x2005e563, 0xfc5618c0, 0xbf641807, 0x61fe2013, 0x013608a7,
+    0x00f0fe10, 0xff000003, 0x01fe01c0, 0x000d00c0, 0x00500047, 0x4c181700, 0x3d2608e7, 0x01152301, 0x82820f26, 0x20090447, 0x180d821d, 0x2209c063,
+    0x82153736, 0x32be840c, 0x35272627, 0x011f1633, 0x37323332, 0x36013d36, 0x6a260527, 0x40300699, 0xa10d0909, 0xdf09080e, 0x0b08b701, 0x410113af,
+    0x2d080f82, 0x09090e21, 0x0f22222c, 0x04041405, 0x150a0710, 0x111d1d15, 0x1112df12, 0x13013f1c, 0x090202af, 0x09020807, 0x010fb9fe, 0x010e0f01,
+    0x67460e01, 0x20202906, 0x0107da01, 0x18130520, 0x26056d46, 0x1d1d081b, 0x8209162b, 0x141d3924, 0x0e1f0813, 0xb0221a1b, 0x1b1a22b0, 0x0513230e,
+    0x0b08051f, 0x5a070a70, 0x20089f51, 0x3be78402, 0x00bf01ff, 0x00420030, 0x26273700, 0x23373637, 0x3f262722, 0x33373601, 0x31363736, 0xad7f0382,
+    0x05f44105, 0x06150722, 0x2722fa82, 0xf1833d26, 0x52312721, 0x2720088d, 0x3108f182, 0x16171415, 0x0d1f9d33, 0x6a090404, 0x0606070e, 0x52291535,
+    0x2a010303, 0x31313232, 0x07051225, 0x1a1a0403, 0x0105063c, 0x0c0c5922, 0x120f150c, 0x5d18e30d, 0x3f250bae, 0x0e120d20, 0x08198214, 0x02225931,
+    0x3c010504, 0x03041a1a, 0x25120507, 0x32323131, 0x5302042a, 0x06351529, 0x6b0e0706, 0x0d050507, 0x120b0bda, 0x010b0c10, 0x100c0b01, 0x180b0b12,
+    0x200d7b47, 0x37481834, 0x1813201c, 0x180960a1, 0x180d4e72, 0x4b1ab89b, 0x4e4d066a, 0x5a5a2209, 0xc5751801, 0x6aa72019, 0x59221191, 0xa38d0059,
+    0xa39d3320, 0x09974918, 0x0e4e6118, 0x185b9c18, 0x85706721, 0x0afa4d75, 0xe920a29a, 0x2f83ca82, 0x180cea4d, 0x4312db77, 0x01760567, 0x06944606,
+    0x27263722, 0x13250183, 0x22312306, 0x7549182f, 0xbb72180b, 0x20a49808, 0x82739087, 0x22a69a87, 0x4e0909c9, 0x47410fca, 0x1817202c, 0x470efc72,
+    0x4a18056b, 0x87201c18, 0x410bf54e, 0xa299071e, 0x7e4ff720, 0x05cf4411, 0x013f0225, 0x195800c0, 0x3110e193, 0x37363736, 0x27060735, 0x36013f26,
+    0x0716011f, 0x9e692f06, 0x26232105, 0x0ae0a719, 0x16241887, 0x33171617, 0x2305937b, 0x3b363734, 0x83066f48, 0x07142515, 0x27330706, 0x10acb118,
+    0x44600121, 0x20370502, 0x1b1b2930, 0x11100801, 0x11380e0e, 0x0f0f3810, 0x02071110, 0x19442d2d, 0x182d5bb8, 0x550d3193, 0xd02506ed, 0x291b1b01,
+    0x35b81906, 0x0745730e, 0x8583178f, 0x214db819, 0x28087742, 0xc001c001, 0x45003100, 0x06bb5b00, 0x220ac871, 0x71272621, 0xb77008e2, 0x07737b08,
+    0x23262724, 0xe24a1331, 0x05854d0a, 0xe0013b26, 0x01161722, 0x27175718, 0x86064d45, 0x01402cf4, 0x17160180, 0x12013022, 0x54c01b12, 0x571807e5,
+    0xfe201827, 0x820dc07e, 0x5b0520d0, 0x50250ebf, 0x00006200, 0x95d21825, 0x36491810, 0x36172211, 0x78461837, 0x3b85180e, 0x109d791b, 0x0d46a418,
+    0x6e18b020, 0x90200fdf, 0x104b4618, 0x57181f58, 0x15570954, 0x42c02007, 0x0585055c, 0x28293d23, 0x205d8b02, 0x45461850, 0x1850200f, 0x5718a985,
+    0x00200f69, 0x03290082, 0x88000800, 0xf800b801, 0x05ef5c00, 0x5c370021, 0x332010d5, 0xe75c1191, 0x6d782010, 0x0787079e, 0x108fa020, 0x108f3020,
+    0x1018c024, 0x148f010f, 0x00200f9b, 0xff25ab82, 0x017800e8, 0x22ab8898, 0x18311716, 0x220bfdd3, 0x91353736, 0x57421811, 0xaf402010, 0x8f582078,
+    0x22dca195, 0x66000400, 0x25240913, 0x53003b00, 0x2117df60, 0x266f2306, 0x17322b07, 0x07141516, 0x31072617, 0xea452330, 0x05b24805, 0x3725e183,
+    0x30312314, 0x23158d31, 0x07141716, 0x20150c61, 0x059246e9, 0x26080585, 0x01010163, 0x1e030315, 0x01152b1d, 0x2a3c1604, 0x1501062a, 0x0315025f,
+    0x52393805, 0x16030116, 0x21373742, 0x65160322, 0xa92216c3, 0x4c8a0909, 0x02010131, 0x1e1d2b14, 0x15160404, 0x2a2b0501, 0x8203173c, 0x52152f11,
+    0x02063939, 0x04011616, 0x36372221, 0x974b1742, 0x05735d0a, 0xd15d2b20, 0x1525301c, 0x3f161714, 0x34353601, 0x0726012f, 0x5d311506, 0xfe2b19e2,
+    0x0d0c0cb0, 0x900b0b90, 0x5b0c0c0d, 0x5833181d, 0x06070eb0, 0x0d085806, 0x0858070d, 0x000e0707, 0x82000300, 0x40023400, 0x04008001, 0x42002c00,
+    0x21130000, 0x25352115, 0x6f311716, 0x162006ba, 0x4407c36f, 0xf64409ed, 0x01212208, 0x20278214, 0x865e1833, 0x22212a09, 0x011d0607, 0xfe400180,
+    0x055762c0, 0x1807f34d, 0x8b095a5b, 0xc0012611, 0x090960fe, 0x63bb180e, 0x090e2709, 0xc0200109, 0x2e8360c0, 0xff6c5020, 0x07ea4408, 0xfe20118d,
+    0x0ee18c18, 0x0b7f5e18, 0x20001522, 0x5c17d367, 0xc5670a86, 0x18f82015, 0x41092381, 0xc82015f7, 0x8209b153, 0x00002964, 0x6001c0ff, 0x2a00c001,
+    0x06250c82, 0x012f2223, 0x93c21811, 0x37342708, 0x36013b36, 0x39491137, 0x48362009, 0x572a088f, 0x0a0d0e0a, 0x17160148, 0xbc447022, 0x0f702305,
+    0x4e424901, 0x837f2005, 0x0a802906, 0x09090109, 0xbdfe4a09, 0x09216d18, 0x010f0123, 0xde631843, 0x83802009, 0x08135026, 0x5f7d8387, 0x05fb5507,
+    0x11011f24, 0x53182726, 0x16240946, 0x11171617, 0x21097048, 0x84838057, 0xc6427f20, 0x01492205, 0x8389870f, 0x238b8671, 0x09098049, 0x8a826884,
+    0x18430121, 0x820813a0, 0xbdfe21b6, 0x00218a86, 0x08cf4302, 0x2f001522, 0x18187741, 0x41187681, 0x2c201586, 0x13728118, 0x26159041, 0x0b0b09b4,
+    0x18080809, 0x28106f81, 0x01c001e0, 0x001500a0, 0x1d5e1823, 0x4f411809, 0x23262610, 0x010f2231, 0x05546917, 0x73010f21, 0x3f2505d5, 0x06072701,
+    0x37979507, 0x0f100d3a, 0x1547150d, 0xd60e0c0c, 0x06060110, 0x06093c09, 0x06694769, 0x165d5f18, 0x0c0c6c22, 0x0d2c2c82, 0x0e0c1010, 0x060a3ba4,
+    0x020f0206, 0x68222e82, 0x5f180808, 0x38200eff, 0x47170345, 0x5418079e, 0xd0410b4b, 0x17322409, 0x44011d16, 0x282015e8, 0x2005804e, 0x05534279,
+    0x42437a21, 0x90200565, 0x45410682, 0xe8fe2115, 0x43212185, 0x050f427a, 0x01547920, 0x86902008, 0x02c128ab, 0x00bf0140, 0x82480022, 0x262726ab,
+    0x15070607, 0x71048222, 0x1629059f, 0x26273637, 0x15173637, 0x06b04416, 0x22072729, 0x1d063107, 0x18112101, 0x18096f43, 0x3f0cf5b1, 0x27343537,
+    0x39022326, 0x0b0b0b97, 0x393a4801, 0x01012222, 0x0a1e1615, 0x1d030909, 0x01622c2c, 0x97231682, 0x82990707, 0x58fe2094, 0x094408ad, 0x40012107,
+    0x08069065, 0x8b300123, 0x0f050508, 0x240d0e4a, 0x25294323, 0x06061624, 0x215d0c05, 0x0f4a0120, 0x8a080505, 0x060a0907, 0x22c782f0, 0x853f011f,
+    0x120125cd, 0xc1fe1b12, 0x1f204687, 0xdb825c82, 0x17490320, 0x002c220a, 0x1313493e, 0x37362123, 0x08d84731, 0x7a055647, 0x272106e0, 0x22f98305,
+    0x4206010f, 0x3721073c, 0x0def4831, 0x18e0fe21, 0x2e175a83, 0x04384501, 0x910f0a0a, 0x0438050d, 0x82100a09, 0x0ccd4807, 0x2c17ab48, 0x0a109133,
+    0x05380409, 0x0a0f910d, 0x8207830a, 0x0a8343c2, 0x24001422, 0x82164b42, 0x222323a1, 0x4118012f, 0x2d68097a, 0x68262f14, 0x080a0a08, 0x07060a68,
+    0x0510d00f, 0x2d420a07, 0x70c82515, 0x0b700808, 0x20057552, 0x0ecb420b, 0x03207f97, 0x08ae4718, 0x1f323324, 0xa0471601, 0x05232716, 0x070fd010,
+    0x86860a06, 0x7f950720, 0x0deefe27, 0x0f0d0101, 0x4586850b, 0xaf680bfb, 0x4bff8419, 0x7f8206b2, 0x22481520, 0x70482517, 0x05050907, 0x80955f88,
+    0x0668f225, 0x820f0702, 0x090536a9, 0x0a0b0768, 0x00000008, 0xff200001, 0x016001e0, 0x005700a0, 0x08136200, 0x36013b25, 0x5b373637, 0x062009b1,
+    0x0c174018, 0x011d1424, 0x1c891514, 0x19171621, 0x430f4bb1, 0x342509eb, 0x3534013d, 0x060b4c23, 0x36181c25, 0x43184836, 0x182505b1, 0x1423232c,
+    0x180b857e, 0x24070da9, 0x2323147e, 0x241f872c, 0x18363648, 0x211f851c, 0xfb4c1010, 0x27402306, 0x13430128, 0x16152206, 0x24098524, 0x04100404,
+    0x220a8504, 0x87151624, 0x2728221e, 0x841e8a40, 0x6f4218e7, 0x82422007, 0x823320e7, 0x057a56b3, 0xca880582, 0x26212328, 0x013f2627, 0x99183d36,
+    0x35240a95, 0x37363736, 0x091ce418, 0x26012f22, 0x2005ea5b, 0x07774670, 0x85c71721, 0x00ff28a4, 0x09080a12, 0x85100e1d, 0x0110370e, 0x15362425,
+    0x060d5213, 0x0c040405, 0x0a510d0b, 0x12121b0b, 0xa082e101, 0x21820d20, 0x272b2e22, 0x0f26aa87, 0x17321010, 0xae852d1a, 0x24364026, 0x1b070125,
+    0x39833183, 0x01031b26, 0x3f1b1212, 0x2a06ef43, 0x01bf01e0, 0x002300a0, 0x1888002f, 0x430a7b4a, 0x172105d9, 0x05c44d16, 0x23012f22, 0x71095e5d,
+    0xd482058b, 0x15232727, 0x16171405, 0x82f78317, 0x4a2b8506, 0x2221067e, 0x82208227, 0x061d61e4, 0x20062161, 0x82158336, 0x201c88ed, 0x88188332,
+    0x2832823b, 0x06072627, 0x31170615, 0x23b98200, 0x28293d50, 0x2143e919, 0x04012b08, 0x0d011c0a, 0x100c0f0f, 0x08030708, 0x0f272224, 0x02080a0e,
+    0x0c020201, 0x05040505, 0x030d0c0c, 0x07080705, 0x17030405, 0x1682070a, 0x03013c08, 0x1a031b0a, 0x08080f1c, 0x23230803, 0x07010127, 0x0c070a0a,
+    0x05030606, 0x050d0b0b, 0x17050909, 0x0101080b, 0x090e8001, 0x29280209, 0x22232d3d, 0x0c0d8012, 0x0504060b, 0x198c0c05, 0x311279e9, 0x0803021a,
+    0x07070409, 0x14150c0a, 0x0f132a18, 0x6a820407, 0x2d084082, 0x0d0b0c05, 0x0505050d, 0x04020201, 0x01010202, 0x0a030603, 0x0402020a, 0x07010908,
+    0x14140b13, 0x10112b17, 0x02010107, 0x0b040203, 0x80830e0b, 0x26820220, 0x05060334, 0x00010907, 0xff000001, 0x013f01e0, 0x0048009f, 0x53183f00,
+    0x61420990, 0x0929430a, 0x19079941, 0x2b0c8543, 0x26272223, 0x36373627, 0x26273337, 0x2d058641, 0x669f011f, 0x0c0c0d08, 0x0703020b, 0x4f42345f,
+    0x50502105, 0x09270786, 0x090d0e0a, 0x83500109, 0x09012404, 0x88500d09, 0x5f352c09, 0x0b020307, 0x080d0c0c, 0x8398fa64, 0x2043833b, 0x0670428d,
+    0x090a2023, 0x2f82180e, 0x051c4309, 0x09200a23, 0x204c8409, 0x8334838d, 0x7098203c, 0xa027080f, 0x47003a00, 0x4d130000, 0x2320087f, 0x21082643,
+    0xc787012b, 0x430c2843, 0x352409f4, 0x3b363734, 0x09bbed19, 0xd5823620, 0xe64ef020, 0x69702007, 0xa020060f, 0x5505ef42, 0xdd85087a, 0x902b9083,
+    0x17160150, 0x22707022, 0x18011617, 0x83094dc4, 0x60238219, 0x14860d02, 0x1882c020, 0x2e839020, 0x3983a020, 0x04000036, 0xe1ff0000, 0xa0010002,
+    0x41003d00, 0x49004500, 0x33370000, 0x16228482, 0x0683011f, 0x16173624, 0x5e181617, 0x2b2c0955, 0x27060701, 0x23012f26, 0x06070607, 0xbe4d0682,
+    0x013b2106, 0x34088e41, 0x37233703, 0x1f072733, 0x77233701, 0x18082940, 0x41290718, 0x07a24339, 0xc15c3220, 0x39292e06, 0x08171609, 0x07292f29,
+    0x39081717, 0x3ecf8529, 0x05043214, 0x0b0d0d06, 0x1539040c, 0x6c1b0b10, 0x6008070f, 0xe01c100c, 0x010117a8, 0x44aaa817, 0xe269071c, 0x82aa2006,
+    0xa81622f0, 0x200583a8, 0x051e41aa, 0x3a839620, 0xaa264283, 0x402e2e40, 0x05821c1c, 0xff540020, 0x80012706, 0x1700c001, 0xeb791b00, 0x14152408,
+    0x4b3b1617, 0x212f05c8, 0x27262726, 0x17350511, 0x12010023, 0x82a01b12, 0x1149184c, 0x8000220b, 0x05274a80, 0xa5828020, 0x48e0fe21, 0x01250759,
+    0x80804080, 0x07735100, 0x032b5f84, 0x25001a00, 0x3b003000, 0x18010000, 0x240e0042, 0x36373621, 0x05b76137, 0x2623132b, 0x33373627, 0x07061716,
+    0x220a8935, 0x87070637, 0x0001250c, 0xb0208080, 0x2008454d, 0x25098320, 0x090a0e7f, 0xd918a030, 0x098809a5, 0x0f011022, 0xc0211688, 0x70008280,
+    0x09830999, 0x82300121, 0xe0fe21cd, 0x20100d76, 0x05a67650, 0x0f012208, 0x00040000, 0x01e0ff07, 0x00a001ef, 0x00420023, 0x0060005c, 0x27363700,
+    0x26272631, 0x010f0623, 0x08156611, 0x27262725, 0x18060722, 0x2108667a, 0x25822317, 0x0bcb8318, 0x17060723, 0xf7701816, 0x82372009, 0x1822203e,
+    0x200a60e8, 0x07294533, 0x37012f2d, 0x09f02317, 0x0b090101, 0x42090d0d, 0x20240693, 0x0b0c0d0a, 0x582f1383, 0x0a0e0e09, 0x4a33d059, 0x1609070e,
+    0x82090d80, 0x840e2000, 0x7f14240c, 0x820a090f, 0x502d2acb, 0x0a13130a, 0x04040550, 0x3100820c, 0x07580707, 0x0e0c0c05, 0x0504040c, 0x2010107d,
+    0x53820a4b, 0x0a010925, 0x422e0124, 0xfe320552, 0x010a23d2, 0x0d0d0909, 0x0a0a600a, 0x10492b61, 0x49461313, 0x290a8a06, 0x1010a0cf, 0x0c0c0da0,
+    0x55820606, 0x062a7f82, 0x0c060705, 0x202a0d0c, 0x00820020, 0x08000422, 0x200f1f41, 0x05534c13, 0x1615062a, 0x36331617, 0x1411013f, 0x32270782,
+    0x11353637, 0x82171617, 0x36372407, 0x4101012f, 0x98213b1f, 0x2786820a, 0x09010957, 0x0a0d0c0b, 0x82072341, 0x052341c5, 0x33280128, 0x09070e4a,
+    0x1f418115, 0x96012430, 0x41600a0a, 0x232a0623, 0x090ed2fe, 0x0e0a0909, 0x23412d01, 0x8afe2108, 0x22312141, 0x66070005, 0x122806ff, 0x38002500,
+    0x6e004b00, 0x14636618, 0x66181320, 0x03201176, 0x25921291, 0x42070521, 0x32830b84, 0x2a088442, 0x27342736, 0x07062326, 0x415fa001, 0x068605ef,
+    0x85df8021, 0x4c06860e, 0x0e27085d, 0x08090908, 0x859f800e, 0x2106861d, 0x8542e0fe, 0x0c0e2208, 0x0885420a, 0x01095727, 0x0c0d090a, 0x067b450a,
+    0x20056244, 0x06501801, 0x18fe200c, 0x8d0c726a, 0x23ab211b, 0x200a8342, 0x0782420b, 0x25077c41, 0x05000000, 0x37410800, 0x416f200e, 0x1d621437,
+    0x0521640b, 0x24412320, 0x7a891812, 0x0772620a, 0xa5420520, 0x4232200b, 0x342212a5, 0x3841012f, 0x4640200f, 0x29410732, 0x41402014, 0xfe210d56,
+    0x07a64278, 0x0e0c0a22, 0x4308a642, 0x082105ca, 0x0c374158, 0x8c1a2841, 0x420a201a, 0x0b20079f, 0x23069e42, 0x2e010e09, 0x33089e42, 0x07000400,
+    0xe001e0ff, 0x1f00a001, 0x45003c00, 0x00006800, 0x2005a052, 0x62f48717, 0x172e0a91, 0x06072215, 0x07061715, 0x14070631, 0x25651617, 0x82332006,
+    0x36372829, 0x26273637, 0x18232627, 0x21087a42, 0xea442227, 0x0565421a, 0x09400124, 0x9b4b0e09, 0x01280806, 0x2010100e, 0x0604030c, 0x090e1309,
+    0x19254809, 0x0f0f0119, 0x09080818, 0x080c0b08, 0x0e220d10, 0x1901010e, 0x02162519, 0x20054852, 0x0f1d41b0, 0x58090123, 0x05e14309, 0x0c080a27,
+    0x080e0001, 0x06954409, 0x0912602c, 0x07100809, 0x110c0c0c, 0x6f832f01, 0x1918012a, 0x15161b26, 0x0c08080b, 0x09200382, 0x14255b82, 0x19261913,
+    0x08546619, 0x420b3021, 0xec440b68, 0x05694209, 0x4108bf44, 0x25205233, 0x24165342, 0x0f222326, 0x051b4501, 0x2b3a3341, 0x0a0ea0fe, 0x0d090920,
+    0x210a090d, 0x42075242, 0x3341096e, 0x42b0203d, 0x7a42145d, 0x67551807, 0x0014250c, 0x3700004b, 0x32087666, 0x1714011d, 0x16013b16, 0x25353637,
+    0x26312726, 0x43362327, 0x1b470593, 0x06072105, 0x3025f983, 0x1f161531, 0x82268201, 0x3437231b, 0x03843627, 0x83353621, 0x35362109, 0x07af8218,
+    0x28064c42, 0x0d018001, 0x1192140e, 0x08e98208, 0x09181723, 0x0c060609, 0x12101e0d, 0x2b221201, 0x0e143b35, 0x1f01010d, 0x0b110702, 0x0d130d0b,
+    0x0de0010d, 0x29008209, 0x080edf0d, 0x09080109, 0x1f83df0e, 0x1c1b1d36, 0x0e0f120c, 0x150d0d01, 0x19191815, 0xa0160f0d, 0x201a0e18, 0x052f5583,
+    0x0e220b06, 0x0d0d030b, 0x020d1312, 0x7a140d0d, 0x022806bf, 0x00a00100, 0x004a0014, 0x0abf8e18, 0x32013b2b, 0x013d3637, 0x23262734, 0x23a98305,
+    0x35362726, 0xe2820385, 0xd4822220, 0x30150724, 0xd4821431, 0x2005d74c, 0x83f58733, 0x82372008, 0x60272135, 0x0d0d6918, 0x0d730129, 0x07110b0b,
+    0x83011f02, 0x353b2388, 0xd282222b, 0x0d1e102f, 0x0906060c, 0x0d171809, 0x1208090d, 0x26be8393, 0x01130d0d, 0x840909a0, 0x300682d3, 0x09090ede,
+    0x12130dd0, 0x0b030d0d, 0x040b220f, 0x36238306, 0x170e1a20, 0x0d0f16a0, 0x15191919, 0x010d0d15, 0x0d120f0e, 0x831d1b1b, 0x0d143c59, 0x0000020d,
+    0x00000100, 0x4001c0ff, 0x2300c001, 0x36370000, 0x1f323133, 0x82341101, 0x17322308, 0x0e551516, 0x20c68208, 0x051f7b23, 0x18093721, 0x23194475,
+    0x4a090977, 0x07e74918, 0x558dfe21, 0x23550601, 0x206b8f07, 0x058e5e01, 0xcb761120, 0x35262105, 0x20140856, 0x566c9937, 0x4a180500, 0x73200773,
+    0xd7826d8f, 0x0220002a, 0x00600100, 0x3f000022, 0x09f95c18, 0x2d592120, 0x18062005, 0x200ea592, 0x09c85537, 0xe2467320, 0x20c08b05, 0xc07718d7,
+    0x86d7851a, 0x0020236b, 0xd0562500, 0x22212709, 0x36352627, 0x12602137, 0x56f7200e, 0xfe200733, 0x0322bd83, 0xbc8a011d, 0x6988a920, 0x1d0e0a24,
+    0x9f544902, 0x4b2f8405, 0x3f26088f, 0x1100c001, 0x8a185000, 0x06210be9, 0x05705307, 0x82230321, 0x183f2071, 0x210cf3ca, 0x35193b36, 0xca180e05,
+    0x24191af8, 0x182110d6, 0xb6241912, 0x1910200e, 0x2016e229, 0x05e34712, 0x06851020, 0x21120478, 0x241907b0, 0x19200cb9, 0x22b62919, 0x21057343,
+    0xef8501c0, 0xcb184420, 0x204e14e3, 0x05955009, 0x3f262725, 0x90373601, 0x202689f3, 0x10eb7823, 0xb3853820, 0x0c071d2d, 0x030c0b0d, 0x0d3a0703,
+    0x191a1516, 0x850e7039, 0x92102022, 0x4fd020d7, 0xdf2206ff, 0x3b820b30, 0x61304383, 0x0c0c0d16, 0x0b61160d, 0x07070c0d, 0x300b0303, 0x2006f947,
+    0x3b601880, 0x00c12909, 0x00420011, 0x01000054, 0x08100e5e, 0x37271728, 0x2f262736, 0x26272602, 0x2627010f, 0x020f0607, 0x1f060706, 0x17060701,
+    0x16021f16, 0x013f1617, 0x36371617, 0xe582023f, 0x5c072721, 0x012710a2, 0x1b1a2900, 0x181a0101, 0x3a0792ca, 0x3ffd291a, 0x0303053f, 0x02136d09,
+    0x5b070807, 0x0807075c, 0x096d1202, 0x8c050303, 0x825b2017, 0x1302211c, 0xfd281784, 0x01242436, 0x36242401, 0x01290787, 0x1b1b0121, 0x1c1c2828,
+    0x22078701, 0x835b5cbc, 0x202f8547, 0x215f8840, 0x17820707, 0x86070821, 0x205f8b47, 0x834f8b24, 0x29fa8257, 0xe0ff2000, 0xa001b001, 0x3d772800,
+    0x06fc510a, 0x520b3957, 0xd85c0570, 0x20270806, 0x331d1e01, 0x0b093f32, 0x0107090c, 0x172a0601, 0x1d010117, 0x382f2f1d, 0x04040307, 0x342d2d20,
+    0x1d33323f, 0x85c0011e, 0x01013706, 0x07060202, 0x28291804, 0x2a2b3730, 0x010a1515, 0x27060606, 0x44851616, 0x0b3b8d18, 0x1a000d24, 0x87822b00,
+    0x31171624, 0x714e1716, 0x11212205, 0x72a91837, 0x5b25200b, 0x1d8405be, 0x27343537, 0x01202326, 0x01140e0d, 0x0d0e1460, 0x8040fe01, 0x0ba80b01,
+    0x2f048501, 0x0e40fe40, 0x0f010909, 0x010fe001, 0x100e0909, 0x23088e4e, 0xc4f0fe10, 0x08202483, 0xcc200484, 0x30251b82, 0x0f01010f, 0x422d8230,
+    0x022706eb, 0x00c00100, 0x18770013, 0x220b35be, 0x8236013d, 0x17162488, 0x45051716, 0x1625059d, 0x013b3617, 0x03e21932, 0x5516201e, 0x062b05c3,
+    0x012f2223, 0x26350706, 0x19070627, 0x081af2e1, 0x2637362a, 0x3526012f, 0x01313734, 0x0c080860, 0x09080c88, 0x291b1b01, 0x011b1b2a, 0x0d0ac9fe,
+    0x01400a0d, 0x71191501, 0x4001161a, 0x23059144, 0x02090240, 0x2307b646, 0x4003030f, 0x29051559, 0x0135253f, 0x33020e10, 0x25863f26, 0x0f030322,
+    0x02232587, 0x82010109, 0x60012426, 0x82080c04, 0x180c2000, 0x22085190, 0x82090909, 0x0b0b215d, 0x6b861e84, 0x43151221, 0x25230571, 0x86020220,
+    0x213f2b71, 0x010fef06, 0x06ef0f01, 0x6d853f21, 0x02024024, 0x27852520, 0x82121521, 0x9b7f183d, 0x05db5a09, 0x2119eb56, 0x66640603, 0x013f2308,
+    0x45181736, 0x6026184c, 0x05050d01, 0xcd570709, 0x01a02108, 0x09b26118, 0x01360982, 0x12121b40, 0x0fb8fe01, 0x68060207, 0x080a0a08, 0x07050968,
+    0x3766d00f, 0x7a2c200d, 0x5b181c1b, 0x0020119b, 0x18181059, 0x6a08f8a5, 0xc95e07f4, 0x0ce67e18, 0x00202d83, 0x3105eb42, 0x01ff01c0, 0x002c00c0,
+    0x005a0048, 0x27262500, 0x4f6f2631, 0x4a961805, 0x2627230a, 0xaa502627, 0x33172c06, 0x32171617, 0x3736013f, 0x44052736, 0x27200869, 0x09a68218,
+    0x23373622, 0x13210c83, 0x0f006336, 0x04fe012c, 0x140d0b0c, 0x62150929, 0x4d47410a, 0x4f340805, 0x100f0401, 0x0b0c1414, 0x1b051703, 0x15092d8d,
+    0x0d300505, 0xfe040506, 0x201f30a2, 0x19190101, 0x24390827, 0x2d020124, 0x2b3b442d, 0x0c310d2a, 0x20271c1d, 0x87073943, 0x831a2007, 0x64062131,
+    0x07278f18, 0x4e830720, 0x0f0f032b, 0x021b8c15, 0x0201136c, 0x3a758310, 0x1f20012a, 0x1e1d2a30, 0x2a0c2f09, 0x2d443c2b, 0x2401022d, 0x16233823,
+    0x46010116, 0x002010de, 0x240caf57, 0x13000056, 0x09af5733, 0x06210a89, 0x10b95707, 0x84543720, 0x570a8a0a, 0x0f2314c3, 0x41716f01, 0x71200504,
+    0x04210787, 0x0dcc5712, 0x0e030922, 0x10202185, 0x201dd557, 0x7d008201, 0x202105f0, 0x23078301, 0x1d22090a, 0x200bde57, 0x0680470e, 0x5707954f,
+    0x1f2313e4, 0x18040000, 0x3008cf68, 0x000d0006, 0x00480039, 0x35231700, 0x07060733, 0x27068213, 0x23011f32, 0x32211716, 0x3f078357, 0x07062123,
+    0x26231523, 0x35272627, 0x26272233, 0x3734013d, 0x35233336, 0x37363736, 0x05331533, 0x14208282, 0x08052c6b, 0x26273429, 0xe0018123, 0xdf3f356b,
+    0x353f01e0, 0x1729f86b, 0x2e352001, 0x0a0a222e, 0x352e2e22, 0x2917e0fe, 0x0e141008, 0x6a08010d, 0x082c0546, 0x140e0d01, 0x74010810, 0x0a100404,
+    0x10350082, 0x1f406020, 0x60600101, 0x1f014020, 0x0e2c1313, 0x13132c0e, 0x05126c1f, 0x0b0c3024, 0x3682b011, 0x3f833020, 0x04506028, 0x0a0a0458,
+    0x36821810, 0x2808b358, 0x00a001c0, 0x00270014, 0x16e15b37, 0x07141126, 0x21230631, 0x172dc184, 0x3f323316, 0x07351501, 0x35012f06, 0x83ce8234,
+    0x172c5eee, 0x0e090931, 0x090e00ff, 0x0b0a8b09, 0x998b0a0b, 0x82990707, 0x83012011, 0x15fd5a11, 0x41d0fe21, 0x6e2a05cc, 0x45050545, 0x034d926e,
+    0xde414d03, 0x05536206, 0xab76ff20, 0x82152005, 0x004a23ab, 0x56681300, 0x15072305, 0x9b850706, 0x26272624, 0x4018013f, 0x15210c20, 0x22af8214,
+    0x19353303, 0x361d2861, 0x0df31533, 0x0416e00d, 0x17011a06, 0x070a70fe, 0x04061807, 0x850de016, 0x2605858b, 0x31402881, 0x19402840, 0x360e2d61,
+    0x06bd0140, 0x180b6006, 0x16080218, 0x0a070702, 0x18180208, 0x457d600b, 0x0585055a, 0xc0e0fe22, 0x61190083, 0xc0210d39, 0x08ef4d00, 0xa0018032,
+    0x35002400, 0x25010000, 0x06050726, 0x011f1607, 0x30052744, 0x33170607, 0x36012f36, 0x36272637, 0x37161737, 0x26098325, 0x22230605, 0x1807012f,
+    0x08079162, 0x02072726, 0x15e5fe6f, 0x0fe6fe15, 0x3c0f0101, 0x01130612, 0x01190b01, 0x01113a11, 0x01010b19, 0xbf12070c, 0x1b011515, 0x30081c82,
+    0x0ef0fe10, 0x91101011, 0x3636020f, 0x37365152, 0x01920f02, 0x08086537, 0x11110665, 0x1e181606, 0x090f1508, 0x02021195, 0x0f099511, 0x141b0910,
+    0x251a8644, 0x330606b1, 0x4482208e, 0x15150126, 0x00348f20, 0x05200082, 0x802cbc84, 0x39008001, 0x53003d00, 0x6a005800, 0x6518bd82, 0x07260861,
+    0x33300706, 0xf0691f30, 0x27262305, 0xab182726, 0x362b09ec, 0x37262737, 0x31011f36, 0x83233736, 0x35332bd5, 0x05153736, 0x27372317, 0x67183736,
+    0x012412f1, 0x11211121, 0x17324086, 0x33013f16, 0x36371617, 0xc001012f, 0x123c0212, 0x02820202, 0x011a0d36, 0x080f1301, 0x0213100b, 0x10040502,
+    0x09110412, 0x05041006, 0x2605a855, 0x130f0e0e, 0x82136b0b, 0x01342821, 0x13e0fe13, 0x18a01427, 0x230a3047, 0xfe1b1212, 0x0805277d, 0x00014026,
+    0x058e00ff, 0x40050d0d, 0x09111006, 0x09094a09, 0x40061011, 0x13011c01, 0x12130104, 0x1d240502, 0x100b0b02, 0x01266682, 0x0c040301, 0x25830108,
+    0x0302022c, 0x0e0c0203, 0x0e0c0c0e, 0x25831b12, 0x02120427, 0x2b2b4501, 0x07aa5769, 0x0bda6018, 0x8300ff21, 0x0bd02562, 0x900b0101, 0x1528a183,
+    0x09061015, 0x00009011, 0x0afb4418, 0x2700122f, 0x45003800, 0x5f005200, 0x00006c00, 0x9ebb1813, 0x012b2808, 0x1d060722, 0x53353301, 0x11210593,
+    0x07ab7514, 0x27341126, 0x21052326, 0x33251083, 0x36373221, 0x26108435, 0x23070607, 0x49352726, 0x35200580, 0x17200c8b, 0xc02d1998, 0x09401ac6,
+    0xf30d092e, 0x4009090e, 0x088d5380, 0x00820920, 0xa0010e24, 0x4c65a0fe, 0x01c0230a, 0x0a19200f, 0x802010cb, 0x01231493, 0x18451b80, 0x2009eebb,
+    0x19438240, 0x2008f128, 0x18678340, 0x20084868, 0x200d8200, 0x205389f0, 0x200a9f80, 0x07374100, 0x01800127, 0x002000c0, 0x27b2192d, 0x0100290a,
+    0x16311716, 0x07061117, 0x3524ec82, 0x27262726, 0x82450983, 0x19112005, 0x20529bb0, 0x084a7101, 0x08eb6818, 0x08e26818, 0xfe200123, 0xebac19f0,
+    0x89b0201f, 0x945020ec, 0xd748182b, 0x2b6b880b, 0x0e0d0150, 0x14a00114, 0xfe010d0e, 0x200a3941, 0x20418930, 0x20578930, 0x8a1594b0, 0x09936c2b,
+    0x18052f4e, 0x18084f48, 0x2209aa6e, 0x4e031716, 0x3321162f, 0xe54c1932, 0x0b765c0b, 0x6b18e020, 0x50200ff2, 0x3a051045, 0x0c0d0715, 0x03030b0c,
+    0x1e132807, 0x1e24241e, 0x0728131e, 0x0c0b0303, 0x4a070d0c, 0x202006bb, 0x8b05fa5a, 0xc0fe213f, 0x2106ee6d, 0x3a8321c0, 0x0d0d0726, 0x111e3e0c,
+    0x1e250082, 0x0d0d0c3e, 0x20408307, 0x06e56221, 0xa3446020, 0xe0ff3106, 0xa001ff01, 0x2e001c00, 0x52004000, 0x00006400, 0x6f085d6c, 0x162005dd,
+    0x20053759, 0x25e68335, 0x26012f26, 0xd8183127, 0x37240832, 0x27363736, 0x31210482, 0x07d54936, 0x16282b82, 0x07262537, 0x06070631, 0xcd550b84,
+    0x16072305, 0x09853137, 0x23083b87, 0x2c290001, 0x011f1e2c, 0x1d264601, 0x1a1c1b1a, 0x1322251d, 0x1e1f0213, 0x93292c2c, 0x17141409, 0x07090a16,
+    0x55290787, 0x090a0a17, 0x1815160a, 0x25078518, 0x17190119, 0x1f821414, 0x84160a21, 0x0a0a2507, 0x16179c15, 0x0a223182, 0x0787180a, 0x02e02608,
+    0x2e2e2121, 0x02023628, 0x01010a0c, 0x0f020b0b, 0x2e281b0e, 0x0221212e, 0x0e0e1a0d, 0x15160604, 0x0f0e1a1b, 0x2b078305, 0x1a1b0714, 0x12122122,
+    0x1b1a0705, 0x1e280784, 0x1a0e0e04, 0x0616151b, 0x1e280787, 0x21121205, 0x071b1a22, 0x00200787, 0x2a061348, 0x010002c2, 0x001a00be, 0x1824001f,
+    0x2a0841f6, 0x0714011d, 0x06010f06, 0x4826012f, 0x3f3106ca, 0x17071701, 0x37132737, 0xeb150735, 0x12c01615, 0x2d00820c, 0x1516c012, 0x0c0b13c1,
+    0xc1130b0c, 0x0082ae15, 0xa0a02031, 0x0808ba01, 0x10110744, 0x1015f215, 0x8c440711, 0x3e3c210c, 0xfe250082, 0x3abc3a8f, 0x070f45bc, 0xc0014030,
+    0x2a002300, 0x36002f00, 0x42003b00, 0x83824a00, 0x1f363729, 0x15171601, 0x82173332, 0x20868505, 0x2d8a8407, 0x013f3635, 0x36353332, 0x26173137,
+    0x8e82010f, 0x8d821720, 0x86073721, 0x209a830b, 0x83148237, 0x2b17830e, 0xac313536, 0x60141460, 0x02020222, 0x012e0482, 0x16176020, 0x16177172,
+    0x02012061, 0x14826022, 0x0477222b, 0x52504e02, 0x5252654e, 0x260982ed, 0x134e5151, 0x82a95252, 0x080c8206, 0x4d52b93c, 0x24980105, 0x0f240808,
+    0x0f257026, 0x10237726, 0x310a0a2a, 0x2a0a0a31, 0x26772310, 0x2670250f, 0x0101090f, 0x1d20201d, 0x59205aa2, 0x0101281f, 0x1e1f1f1e, 0x206024cc,
+    0x0882ae64, 0x85260e82, 0x2264205b, 0x67410502, 0x02cb2207, 0x2aeb8200, 0x00480025, 0x3700006d, 0x82310716, 0x060721d2, 0x1810ad63, 0x2507438e,
+    0x011f3601, 0x20831737, 0x16011f25, 0x5036013f, 0x232005ea, 0x230bf35c, 0x1f323336, 0x0b040719, 0x08450720, 0x010f2206, 0x25338206, 0x35373637,
+    0x05823633, 0xb427362c, 0x0f0c0c03, 0x090a3318, 0xf1451309, 0x19263207, 0x1406061a, 0x020d1933, 0x0e5c0f03, 0x29671505, 0x840a8718, 0x1f2a252c,
+    0x081f3232, 0x2607ad43, 0x11110a08, 0x4311d60a, 0x112007ce, 0x602d4983, 0x0c0e0e01, 0x420a0a42, 0x010e0e0c, 0x284f8560, 0x090910cd, 0x11510f08,
+    0x08e66910, 0x21171728, 0x0f512122, 0x63820f0a, 0x5b0e022a, 0x0a0f42a4, 0x15050f0e, 0x11210a82, 0x232a8208, 0x0c2d2d42, 0x68850082, 0xde0f0f23,
+    0x05f2431b, 0x1b0c0c22, 0x1d264383, 0x0b060610, 0x02820b43, 0x10060624, 0x4b84011d, 0x2c06974b, 0x00a00100, 0x0034002b, 0x00580046, 0x0cce5200,
+    0x1d161723, 0xcef51801, 0x18212009, 0x2f081d95, 0x3734013d, 0x37313736, 0x27262721, 0x020f0623, 0x10f04919, 0x78720520, 0x23283710, 0x1f18190a,
+    0x19181fb6, 0x0b12230a, 0x0e09090b, 0x09090e20, 0x0886c0fe, 0x120b0b2c, 0x1a260145, 0x16b61608, 0x424a1a08, 0x078f6c0c, 0x2c05504a, 0x111d65fb,
+    0x1d111212, 0x10100765, 0x06ba4414, 0x85303021, 0x14c02b1b, 0x05071010, 0x0101144b, 0x48184b14, 0x0c8c0c6c, 0x00820020, 0x45180420, 0x3720085b,
+    0x2307e544, 0x31173201, 0x3125ed82, 0x1f161716, 0x9a048201, 0x013f22f8, 0x62fd8336, 0x0728050c, 0x21010f06, 0x23272627, 0x1118e518, 0x16412520,
+    0x60012110, 0x1d22a982, 0x02411717, 0x0a232c17, 0x091d1717, 0x9b800e09, 0x411a0816, 0x4520050e, 0x410b4e4b, 0x01210d0b, 0x242a82c0, 0x11110220,
+    0x180d411c, 0x111c6525, 0x82200211, 0x01802642, 0x144b4b14, 0xb1aa1801, 0x0d16410c, 0x28059757, 0x00c001c0, 0x25000032, 0x09b84607, 0x27262325,
+    0x8b013f26, 0x68362005, 0x06250531, 0x16172307, 0x22058707, 0x469e9e01, 0x270805a9, 0x0808169f, 0x130f450d, 0x3c0c0708, 0x0607100b, 0x0b08870a,
+    0x0a87080b, 0x0b100706, 0x08070b3d, 0x0d450f13, 0x01160908, 0x08e04218, 0x12130131, 0x10015012, 0x01471010, 0x930c0c0c, 0x82930808, 0x47012106,
+    0x01241082, 0x12121250, 0x03239882, 0x82ff0000, 0x269b8299, 0x00260012, 0x18000039, 0x200ab15e, 0x06ac5236, 0x37360722, 0x09556e18, 0x2105e94b,
+    0xb2460531, 0x29178b05, 0x4002c001, 0x3f5f5f3f, 0x07870240, 0x181f3722, 0x17270a87, 0x63634620, 0x83aefe46, 0x24158b05, 0x22307001, 0x22b18217,
+    0x88221716, 0x0b872308, 0x14876612, 0x0b126627, 0x18010118, 0x220483a0, 0x8756120b, 0x12562216, 0x069b450b, 0x82800121, 0x000737bb, 0x00270010,
+    0x004b003a, 0x00650061, 0x35233700, 0x06171633, 0x05823707, 0x07061525, 0x62133523, 0xdb8310e8, 0xf4183320, 0x277e080a, 0x18232008, 0x28088c58,
+    0x27262726, 0x15070623, 0x83038237, 0x183520eb, 0x320ce05c, 0x35231727, 0x16080858, 0x68160202, 0x01010f08, 0x6320080f, 0x12240e30, 0xa0a01b12,
+    0x0f231983, 0x72180801, 0x602307e5, 0x51180f01, 0x18230701, 0x8580010f, 0x05bf4a1f, 0x30320584, 0x90808020, 0x16160230, 0x0f013002, 0x60010f40,
+    0x70630001, 0x121b260f, 0x01e00112, 0x203b840f, 0x07957220, 0x49829020, 0x08556718, 0x90800f22, 0x44821f86, 0x82010f21, 0x010f2424, 0x7b8080e0,
+    0x802b0657, 0x1600c001, 0x3c003800, 0x18130000, 0x550a9c65, 0x23330529, 0x35262722, 0x0f163317, 0x23070601, 0x07012f26, 0x82012b06, 0x37262906,
+    0x011f1633, 0x013b3637, 0x37250684, 0x27331527, 0x129c63e0, 0x0d173a38, 0x09022b01, 0x1e02091e, 0x1d08031e, 0x012b020a, 0x020a170d, 0x13841c18,
+    0x02181c29, 0x80801a0a, 0x63804001, 0x7034129e, 0x08b80d02, 0x6e080101, 0x08010a6d, 0x01020db8, 0x09676708, 0x08220483, 0xbb8ef001, 0x3f003b22,
+    0x0720bb99, 0x20053843, 0x18bb8622, 0x2207ed94, 0x86323337, 0x201f82c0, 0x33be9603, 0x05313030, 0x1a0a0405, 0x1b1b0509, 0x0a1a0905, 0x31050504,
+    0x0422118e, 0xc1971005, 0x5050882e, 0x01070808, 0x082c2c08, 0x08080701, 0x01210d8d, 0x31c48208, 0x04000000, 0xc0ff0000, 0xc0018001, 0x1a000300,
+    0x25652f00, 0x20ab821e, 0xc25c1831, 0x37362709, 0x16171633, 0x686e0717, 0x65152009, 0x38331725, 0x22161602, 0x100f012c, 0x0f01010f, 0x17171e48,
+    0x552c7804, 0x2c2105ac, 0x17206501, 0x1823b425, 0x83280118, 0x82b02030, 0x13122604, 0x0808241e, 0x2034820c, 0x8ab68238, 0x001626b7, 0x003e0028,
+    0x18814142, 0x17320724, 0x4f6a1631, 0x37342d08, 0x06173336, 0x2722012b, 0x36013f26, 0x44058441, 0x844105e3, 0x45551817, 0x05de360c, 0x0509e009,
+    0x04350504, 0x0d050909, 0x0809052d, 0x04055505, 0x1782413e, 0x0c86c318, 0x0808d832, 0x07500809, 0x07441407, 0x09088007, 0x8080b801, 0x200b3344,
+    0x064d4a03, 0x36002925, 0x66004100, 0x27251bab, 0x35231533, 0x23048815, 0x31272617, 0x3327cc82, 0x06071617, 0x18233707, 0x41086d5d, 0x8021178b,
+    0x2c008440, 0x13121f20, 0x1f401f05, 0x1f131205, 0x09b24e10, 0x23188e41, 0x40202060, 0xff2b0284, 0x1e161601, 0x161e7574, 0x664f0115, 0x002107c2,
+    0x08474205, 0x2a001628, 0x55003d00, 0x91415900, 0x06032618, 0x2f063107, 0x06854f01, 0x17363729, 0x37151716, 0x5f262722, 0x0f8405b3, 0x06071425,
+    0x82143723, 0x84078226, 0x26372119, 0x29821f83, 0x41151621, 0x302c17a8, 0x06070601, 0x010b2c24, 0x242c0b01, 0x26080a82, 0x05073001, 0x0b0b0a09,
+    0x0c0b090a, 0x05150114, 0x0e0f6006, 0x0805041a, 0x280b0705, 0x0b280101, 0x1a0d0907, 0x41400f0e, 0xfe3317bb, 0x030308ec, 0x0b012406, 0x24010b38,
+    0x08030306, 0x82061088, 0x0e0e214c, 0x083e5283, 0x141c1c14, 0x1b203404, 0x0703121c, 0x321d090d, 0x0d091e31, 0x1c12070b, 0x5001201b, 0x57438080,
+    0x0030220f, 0x1cd1413d, 0xea831120, 0x82012b21, 0x013d22e9, 0x06635c34, 0x37011d23, 0x24c58215, 0x3735012f, 0x41f78236, 0x092317cd, 0x48600e09,
+    0x06830538, 0x0701602a, 0x28280808, 0x01070808, 0x2118c841, 0x2f8900ff, 0x63283d83, 0x04040a66, 0x19501904, 0x0a200582, 0x200f5b43, 0x1c994527,
+    0x58160721, 0x3f2106ed, 0x28a38201, 0x3717010f, 0x06010f16, 0x18c78223, 0x4107c38e, 0x463117ac, 0x08060c0c, 0x0c300608, 0x0e0e300c, 0x22220c0c,
+    0x83098298, 0x250b8311, 0x0e0e0c0c, 0x98413230, 0x0ee22417, 0x8206060e, 0x233b8235, 0x22220e0e, 0x06210983, 0x20098306, 0x2148820e, 0x37820130,
+    0x08ef8118, 0xc001002e, 0x44003900, 0x5c005000, 0x79006700, 0x0c51e118, 0x26070623, 0x094f5f27, 0x36272623, 0x094b5f37, 0x16373624, 0x7c183717,
+    0x162508bf, 0x17070617, 0x22d68327, 0x82171607, 0x82372026, 0x15162338, 0x0b820714, 0x82273521, 0x222d841a, 0x82232726, 0x201d8250, 0x20248206,
+    0x087d5d3f, 0x22071b45, 0x5ad70127, 0x0d31055a, 0x43595c41, 0x0d0d0a0c, 0x0d09090a, 0x34020234, 0x2517850d, 0x5c59430c, 0x178b0d41, 0x1e18a23a,
+    0x303a181c, 0x3a30403e, 0x3a22018b, 0x223a0d0d, 0x303ec101, 0x1e1c183a, 0x3f2f1682, 0x010e6101, 0x233a0e01, 0x3a230202, 0x830d1461, 0x140d230c,
+    0x00820e15, 0x91171521, 0x20769d5e, 0x825c8446, 0x83642064, 0x1d1d215f, 0xc0205f84, 0x62865882, 0x8a89f620, 0x0e016622, 0x0d246682, 0x150d0e0e,
+    0x00207483, 0x01310082, 0xc1ff0000, 0xb6010002, 0x00003600, 0x31071613, 0x08645d06, 0x36373625, 0x84272637, 0x089e6f01, 0x0b22ac18, 0x088ea419,
+    0x0603df35, 0x253d0d06, 0x36020126, 0x36525236, 0x26010236, 0x6f0d3d25, 0x51230628, 0x5a023232, 0x02310bbb, 0x0d513232, 0x01050b0b, 0x0b0c0da0,
+    0x31311304, 0x83318342, 0x31422739, 0x0b041331, 0x39820d0c, 0x41190424, 0xdf745842, 0x22222906, 0x58483a39, 0x04194142, 0x97626582, 0x26af8205,
+    0x001c00c0, 0x5b030100, 0x072906b1, 0x27262306, 0x13373435, 0x08af8201, 0x25373441, 0x07161736, 0x03400002, 0x0608080d, 0x06337b06, 0x0702130b,
+    0x66dafed9, 0x01100212, 0x101012c0, 0xfe9b0102, 0x04080f61, 0x0a4c3302, 0x0b601302, 0xfe170109, 0x15082af8, 0x09ff0a14, 0x56140b0b, 0xc02006bf,
+    0x37236784, 0x53004700, 0x31200679, 0x410cc574, 0x26410614, 0x48062007, 0x8882062d, 0x1f201282, 0x23056f60, 0x15171615, 0x06248b82, 0x3d26012f,
+    0x31201182, 0x0d0d8a18, 0x0b3f532b, 0x08080302, 0x300b0d0c, 0x0705413e, 0x1f36523e, 0x1105060b, 0x0102166e, 0x220d0d0e, 0x352e2e23, 0x40021601,
+    0x11100f0f, 0x16020748, 0x0ec14018, 0x0c092d29, 0x030b0b0c, 0x41210802, 0x2508087c, 0x0c1f3602, 0x02010e0e, 0x05116e16, 0x23220b06, 0x02801414,
+    0x11415e16, 0x480f0f10, 0x16680a06, 0x00010002, 0x0b5dff00, 0x00552305, 0xbe442500, 0x05294d08, 0x0ca55419, 0x20088b6e, 0x0c3e7711, 0x2205614e,
+    0x92353315, 0x33112715, 0x15161732, 0xdb44c001, 0xe0102109, 0x4406bd5a, 0xcc5a06eb, 0x930e8707, 0x06e6441e, 0x09090e24, 0x70589090, 0x4d01200b,
+    0x70210c0d, 0x0c8c5870, 0x00207383, 0x01220082, 0xdf862000, 0xcf182920, 0x4f64088f, 0x87232009, 0x013d220a, 0x07dc4223, 0x2026b389, 0x0d0d0909,
+    0x06860a0a, 0x2f41192e, 0x2e05082e, 0x0ee0472e, 0x8101090a, 0xb2180482, 0x09870975, 0x28016028, 0x324a3f28, 0x39820232, 0x00002008, 0xff000006,
+    0x010002d0, 0x002600b0, 0x005e0038, 0x00960070, 0x370000a8, 0x36313734, 0x4436013b, 0xb8180598, 0x23240dfb, 0x27262722, 0x35250483, 0x27343331,
+    0x12dc1831, 0x3735250c, 0x16311732, 0x34202f97, 0x22052b7b, 0x95173336, 0x05a74137, 0x29450620, 0x0ad27a05, 0x05218688, 0x185d8214, 0x31087d5a,
+    0x15060722, 0x0e090900, 0x13140937, 0x13131919, 0x6c46f70a, 0x0af72205, 0x220f8313, 0x82370914, 0x2141180f, 0x83a0200c, 0x83158325, 0x87258735,
+    0x18458335, 0x410c017f, 0xd72006f0, 0x57202887, 0x57205e85, 0xd7216e87, 0x205c8cfe, 0x211e8220, 0x00820d16, 0xe5411620, 0x410b8b05, 0xf02208f7,
+    0x1e920d0d, 0xaf722a82, 0x86628506, 0x184d9157, 0x200cb0e4, 0x20008200, 0x081b4304, 0x49003a27, 0x6d005b00, 0x068d6300, 0x0727222d, 0x15140716,
+    0x07161514, 0x18373617, 0x220bbd80, 0x65273734, 0x36210566, 0x054d4637, 0x08853520, 0x35171627, 0x34373605, 0x05a65727, 0x33263182, 0x31070625,
+    0xda6e1506, 0x20198307, 0x10815111, 0x01c00129, 0x28291b1b, 0x82015e1b, 0x1b5e2200, 0x064b1828, 0x840f8a0c, 0x83298221, 0x9ffe301f, 0x0909021e,
+    0x09090d0e, 0x09090101, 0x5001010d, 0x99500b8d, 0x8341200c, 0x2f1a2c2e, 0x03020403, 0x04040202, 0x83011a2f, 0x2163876d, 0x108b0507, 0x072f1a23,
+    0x23198705, 0x1e02a001, 0x50825e87, 0x6683c020, 0x09775a18, 0x41bffe21, 0x1482088f, 0x220a5779, 0x45480015, 0x457c073b, 0x07062710, 0x14070631,
+    0x1e410715, 0x36172508, 0x15141737, 0x46051350, 0x22240579, 0x16372707, 0x20084f4f, 0x155c7c31, 0x121b4027, 0x13510112, 0x2606831c, 0x1b121201,
+    0x5751131c, 0x18250b5c, 0x11555511, 0x08637218, 0x2014ab61, 0x24308340, 0x132d0304, 0x23398801, 0x04032e14, 0x07833487, 0x2e2f0f23, 0x201c870e,
+    0x23008200, 0xff000003, 0x24051f46, 0x003c0018, 0x34e58252, 0x1f323336, 0x14151602, 0x2306020f, 0x26022f22, 0x023f3435, 0x059a6307, 0x60493720,
+    0x201c8305, 0x28871801, 0x1732280d, 0x37360737, 0x50373631, 0x06200511, 0x2b084550, 0x0502b901, 0x260e0205, 0x0e260505, 0x27350984, 0x0e270404,
+    0x0d0d0a98, 0x0b121c0a, 0x110a0a0b, 0x0b09091d, 0x04a4180c, 0x27078307, 0xc20a2225, 0x2b1e1e01, 0x27054350, 0x02262739, 0x010f0e02, 0x15461a1a,
+    0x09095c2a, 0x0a0a111d, 0x1c120b0b, 0x0b265283, 0x3b582521, 0x4d87023b, 0xc70b0c28, 0x011d1e2c, 0x3e820f01, 0x3a262722, 0x2b625085, 0x0005300b,
+    0x00370020, 0x33173700, 0x37072737, 0x84310706, 0x17162102, 0x4107bc41, 0x262305be, 0x4a271327, 0x073b0563, 0x27372726, 0x37173736, 0x17071716,
+    0x1fb10706, 0x4f4e1e60, 0x3a39474e, 0x48012222, 0x4720051c, 0x0805cc7c, 0x39222221, 0x56a2483a, 0x1a1a1819, 0x1b561918, 0x201b4503, 0x31444431,
+    0x03451b20, 0x5b5bdb1b, 0x85e53939, 0x0ae77b2e, 0x47472108, 0x22233a3a, 0x0197fe01, 0x51070751, 0x32352a01, 0x33132850, 0x50281333, 0x002a3532,
+    0xff00000d, 0x3c05df62, 0x0019000c, 0x00330026, 0x004d0040, 0x0067005a, 0x00810074, 0x009b008e, 0x250000b8, 0xc2b11815, 0x8b33200a, 0x1827200c,
+    0x2308cb5b, 0x07273635, 0xcf820c89, 0x3720268b, 0x36221989, 0x33963327, 0x012f3422, 0x3d241987, 0x05273601, 0x34212689, 0x8a818c27, 0x2726254d,
+    0x31272625, 0x2b059959, 0x3f16011f, 0x27353601, 0x06071736, 0x27220b85, 0x5a180f01, 0x0a2207f4, 0x0a896002, 0x0b285c26, 0x270b0101, 0x0c210482,
+    0xf45a18bf, 0x895b2009, 0x83c42020, 0x820a2015, 0x0c022220, 0x202b8960, 0x7d5b1860, 0xc00c2107, 0x02231486, 0x8420010c, 0x2204820a, 0x877dfe0c,
+    0x010b2240, 0x3b568904, 0x5a46a501, 0x465a5959, 0x0b2a090c, 0x060f5512, 0x01055757, 0x0b12550f, 0x540c092a, 0x09892589, 0x45896c20, 0x0a89c020,
+    0x208a2a8a, 0x358a2a94, 0x993e40a0, 0x16161745, 0x100e4517, 0x22050f43, 0x1d351108, 0x0712351d, 0x43100622, 0x00000e10, 0x82180005, 0x082b0743,
+    0x3e002400, 0x4c004300, 0x53010000, 0x332305aa, 0x42060535, 0x312206d6, 0xf2530706, 0x37323005, 0x23113536, 0x07060722, 0x31272621, 0x5e012b26,
+    0x3d2008ae, 0x26213582, 0x26018327, 0x23353307, 0x82230315, 0x35332532, 0xa0012726, 0x3c057953, 0x0801a0fe, 0x0a0d0b08, 0x0909020b, 0x090e800e,
+    0x090e6009, 0x80010108, 0x0e090801, 0x08128660, 0x0a0b0223, 0x08080b0d, 0x4040e001, 0x010f4030, 0x010f0160, 0x01010f90, 0x7030300f, 0x16181720,
+    0x34212119, 0x0572452c, 0x09400127, 0x0a0d0d0a, 0x07725e09, 0x21342c2d, 0x18161921, 0xa0802017, 0x830001a0, 0x010f2231, 0x08db6500, 0xc0018028,
+    0x19000c00, 0x13193900, 0x232008ad, 0x5705e949, 0x0c84054a, 0x51173321, 0x15210868, 0x21df8206, 0xbc822315, 0x35272622, 0x2106ff49, 0xaf822133,
+    0x82400921, 0x82c020a8, 0x0bb57181, 0x38232426, 0x24233840, 0x21067046, 0xf7494001, 0x06e84705, 0x07836020, 0x1a46a020, 0x3b202a05, 0x630d2a2b,
+    0x2b2a0d63, 0x0613483b, 0x3f052b49, 0x010002e0, 0x001f00a0, 0x0035002a, 0x004b0040, 0x01000058, 0x06072221, 0x07061115, 0x23112726, 0x60180a84,
+    0x11250863, 0x23262734, 0x09e37703, 0x200aee77, 0x23159417, 0x21070637, 0x3629c782, 0x17162137, 0xfee00115, 0x24bf82a0, 0x010f0f01, 0x22078320,
+    0x461b1212, 0xa2820552, 0xe419d020, 0x0989091b, 0x1493a020, 0x0f011029, 0x010f00ff, 0x83010f01, 0x21de8305, 0x0e84b0fe, 0x46051878, 0xfc830869,
+    0x8380fe21, 0x2003836c, 0x20089960, 0x853d8370, 0x00003169, 0xff000003, 0x018002e1, 0x001100a0, 0x0051002f, 0x4706d75d, 0x37210b15, 0x06a54d22,
+    0x8206aa5d, 0x3233211b, 0x25057e73, 0x25232627, 0x424a2726, 0x48072005, 0x744a0869, 0x49162006, 0x012106e8, 0x84a3873f, 0x12113807, 0x3135011c,
+    0x010a2731, 0x0d090901, 0x54400a0d, 0x0b0a4054, 0x82090a0e, 0x31283b0f, 0x36013531, 0x584f503f, 0x3f504f58, 0x0c0a090a, 0x44360a0d, 0x444b4b45,
+    0x0b833744, 0x610a0922, 0x22083147, 0x831b1212, 0x13a0244f, 0x820a2312, 0x254e8346, 0x37010137, 0x0d820b08, 0x13230926, 0x203d2213, 0x3d200082,
+    0x0a296283, 0x1b1b3509, 0x09341b1c, 0x211b830a, 0xf3820a00, 0x8001c02c, 0x1400c001, 0x2e002100, 0xf4183b00, 0x89200af7, 0x2016b565, 0x0b846b05,
+    0x0c8b1520, 0x62190962, 0x268c2630, 0x01200c8c, 0x1452d218, 0x600b0861, 0xa020098e, 0x61063657, 0xb6600af1, 0x010f2209, 0x95298960, 0x83e02009,
+    0x2004832d, 0x0ee056c0, 0x0e14a025, 0x89d0010d, 0x6260204b, 0x158a1452, 0xc0200a8a, 0x2b8f3694, 0x25834020, 0x8b424020, 0x02c02e05, 0x00c00180,
+    0x00310025, 0x1300003b, 0xf9761836, 0x011d2e08, 0x17161716, 0x011f1615, 0x31300716, 0x35068322, 0x26012706, 0x011f3637, 0x21173507, 0x3f262726,
+    0x31373601, 0x77182213, 0xba22071e, 0x09444224, 0x25771805, 0x01012208, 0x275b185a, 0xf61a390a, 0x0815eafe, 0x2f080d08, 0x131aa001, 0x13138013,
+    0x3747011a, 0x090e130f, 0x0e200082, 0x0a327718, 0x18470121, 0x2c09005b, 0xc2056a74, 0x0f131201, 0xfe493609, 0x823182e3, 0x080f7138, 0xb782c020,
+    0x28001a22, 0x3320b584, 0x3320a782, 0x0cbeda18, 0x36373429, 0x0137013b, 0x56310706, 0x272a0550, 0x87032103, 0x14781409, 0xbd440709, 0x56fe2006,
+    0x6037063c, 0x02040107, 0xf6130e0d, 0x020d0e13, 0x15810116, 0x0111ae01, 0x4a0e1101, 0x0e240bf2, 0x0d1440fe, 0x14270082, 0xaefe5201, 0x18000200,
+    0x200903ca, 0x1f521849, 0x16032e1c, 0x30313033, 0x36373231, 0x06071617, 0x200b8307, 0x05c95226, 0x0b833720, 0x15831620, 0x23262729, 0x07223130,
+    0x18141506, 0x3c1ad852, 0x21201839, 0x0e111117, 0x3435250e, 0x26252526, 0x0e253534, 0x1711110e, 0x17182021, 0x0e335017, 0xee182220, 0xfe2f09ad,
+    0x0e1717c7, 0x2511110d, 0x27250101, 0x83273333, 0x10112a07, 0x17170e0e, 0x19202019, 0x0c075100, 0x39001f22, 0x08edd218, 0x94571720, 0x012f2106,
+    0x088fc418, 0x33363730, 0x01311732, 0x06071737, 0x3233011d, 0x0882013f, 0x2d05da7e, 0x3435013f, 0xe3013137, 0x0a661d1d, 0x6f180909, 0x092e0aae,
+    0x28281e66, 0x7954fe1f, 0x2405782d, 0x06820407, 0x2a211830, 0x10131628, 0x01171b0c, 0x28281fa3, 0x2e84661e, 0x08b76f18, 0x1d660a2c, 0x78dafe1d,
+    0x0704792d, 0x06820524, 0x0c1b1739, 0x28161310, 0x0018212a, 0xff200002, 0x014002c0, 0x000f00c0, 0x1800002d, 0x26087894, 0x010f1617, 0x78270706,
+    0xae5005b3, 0x37362509, 0x35262736, 0x373a0582, 0x31151417, 0xed2501e0, 0x0e11100f, 0x0a02020d, 0x732b19a1, 0x1f200160, 0x79429030, 0x0d053e05,
+    0x01010808, 0x2e1f1e01, 0x1d2fb974, 0x01010bb1, 0x11110c0c, 0x0724fa0f, 0x1f308968, 0x07666b20, 0x0d0b0b2c, 0x202e0606, 0x0369031f, 0xc37e0004,
+    0x82c02008, 0x0017308f, 0x0073002f, 0x00b4009c, 0x37320100, 0x48353631, 0x30200528, 0x24066953, 0x33161714, 0x21179623, 0x8c483717, 0x35232105,
+    0x264c078d, 0x4bc08208, 0x09900973, 0x07206984, 0x086d4f18, 0x34663583, 0x27262207, 0x0cab1815, 0x23062109, 0x9c971683, 0x1160012a, 0x09010c0b,
+    0x01090a0a, 0x0c230585, 0x9180110b, 0x019f2712, 0x0f200f01, 0x058a4001, 0x12121b2f, 0x10110f01, 0x0b070f0f, 0x100f060b, 0x2e099310, 0x12010f11,
+    0x0b1f1c12, 0x14141110, 0x8b0b1011, 0x0f112b07, 0x010e0909, 0x09090e80, 0x1b83110f, 0x9100ff21, 0x51012175, 0x0c2e8d82, 0x0d0c1110, 0x0d0d0101,
+    0x110c1011, 0x11910b0b, 0x0f3f7022, 0x40209d82, 0x8505d744, 0x2a758205, 0x010a451a, 0x060a0a01, 0x83070a0a, 0x200994db, 0x27c38345, 0x08090996,
+    0x09080101, 0x078a0082, 0xbe500620, 0x01072607, 0x01090809, 0x43769106, 0xe348073f, 0x001a2505, 0x3700003b, 0x2905416d, 0x06071415, 0x27262123,
+    0x53772726, 0xc190190a, 0x33162908, 0x36013f16, 0x011f1633, 0x2205d861, 0x82222123, 0x40332429, 0x42010f01, 0xfe220694, 0xba182270, 0x4031082a,
+    0x0e0b4f08, 0x0728090e, 0x15080a0b, 0x0a0e0d0a, 0x28a98241, 0x0ddffe0e, 0x01010909, 0x08966230, 0x22171623, 0x06135101, 0x50b0fe34, 0x5a0a0c54,
+    0x082f0c0b, 0x09150801, 0x094d0a01, 0xed42440c, 0x03003205, 0xc0ff2000, 0xc0013e02, 0x20000c00, 0x00002900, 0x25f31801, 0x35232809, 0x31373605,
+    0x54323736, 0x072005d3, 0x2105c842, 0xea581605, 0x01332405, 0x730f0130, 0x22080560, 0xfedf0f02, 0x393a02f0, 0x9d011159, 0x4f3c0c0a, 0x20363643,
+    0x0e020120, 0x0b3c0e10, 0x01ee9f0a, 0x73020faf, 0x0f3e056b, 0x5dffdf01, 0x100e4241, 0x0b0c9dee, 0x2001012b, 0x43363620, 0x560f0210, 0x9f080838,
+    0x9f4b0200, 0x001a2208, 0x1c3b413a, 0x34782520, 0x05e85205, 0x20084741, 0x08055837, 0x27163a41, 0x0d0a1701, 0x59390a0d, 0x09220583, 0x0c847009,
+    0x0c856920, 0x39418020, 0x09792416, 0x445a3a09, 0x702005c5, 0x6a200a82, 0x80200a85, 0x0a135018, 0x24001124, 0xad823700, 0x21108475, 0x73682317,
+    0xa97d1807, 0x23112608, 0x07060706, 0x07286016, 0x5c181f83, 0xc02110f7, 0xb75318c0, 0x28088808, 0x01242536, 0x36252401, 0x710887c0, 0x602010da,
+    0x0f9c5318, 0x18400121, 0x220f7efe, 0x82000200, 0x40022500, 0x13008001, 0x0a178a18, 0x2805636b, 0x37362726, 0x11333736, 0x10c47136, 0x8e918020,
+    0x220ca352, 0x18291b1b, 0x2011846b, 0xe28c18fe, 0x4d002012, 0x8033057f, 0x3d00a001, 0x6c005600, 0x75007100, 0x16010000, 0x4136011f, 0x31410820,
+    0x07272405, 0x44012b06, 0x978307be, 0x37173223, 0x06ef4b27, 0x33011f22, 0x230ad954, 0x31171613, 0x83054d62, 0x07222639, 0x06071617, 0x233a822f,
+    0x22372531, 0x20086b41, 0x82d98232, 0x3726323d, 0x27313731, 0x17273307, 0x5b012337, 0x13620a12, 0x074e4114, 0x022a0783, 0x0854162d, 0x2307310d,
+    0x16873223, 0x1b0f1031, 0x02162c16, 0x0b381602, 0x22951b09, 0x82070a1b, 0x240a2a00, 0x1414015d, 0x14141f1f, 0x08078301, 0x2005062d, 0x0c141309,
+    0xfe011220, 0x040218b5, 0x0115141e, 0x1e141501, 0x0613131b, 0x08071041, 0x3348b507, 0x313c217b, 0x01a0016d, 0x4105b410, 0x3f280b93, 0x0c8f2824,
+    0x011f2030, 0x042d1487, 0x16021f35, 0x08010216, 0x07074027, 0x216c820a, 0x6587c0fe, 0x3c290784, 0x13090c14, 0x171d133b, 0x2e808731, 0x01190f10,
+    0x090e0c0c, 0x53806565, 0x65060053, 0x3e2b083f, 0x59004c00, 0x7d006b00, 0x58008800, 0x152106cb, 0x06366632, 0x14152324, 0x04840607, 0x8b06c45c,
+    0x2722230b, 0xda5c3d26, 0x35333408, 0x37363736, 0x31171403, 0x35013b16, 0x06072223, 0x7117011d, 0x2b2208e2, 0x5c651501, 0x54212011, 0x032010df,
+    0x230ae45e, 0x3d3c6620, 0x22063a4e, 0x660e0909, 0xc0200663, 0x0f830786, 0x00820920, 0x3d010e25, 0x82a0663c, 0x70702114, 0xb0201282, 0x0c830483,
+    0xd754a020, 0x0cc7550c, 0x18a04021, 0x2608cc45, 0x1601c001, 0x7e302217, 0x3383061a, 0x12f14718, 0x40205c83, 0x30264e82, 0x01161722, 0x098200ff,
+    0x60211183, 0x20358220, 0x580c8360, 0x8d580c65, 0x4d50200c, 0x002d07d5, 0xff000003, 0x014002e0, 0x001400a0, 0x05c54e36, 0x0db94f18, 0x27261127,
+    0x16012726, 0x07ec4933, 0x27222325, 0x44263526, 0x072205a2, 0xf5572706, 0xa0332007, 0xb86d1821, 0x0ea92f16, 0x110e1314, 0x1d0e0e11, 0x1c1d2726,
+    0x06831d01, 0x10830e20, 0x0e221682, 0x1d9cc00e, 0x2116af72, 0x00820efe, 0x1c111126, 0x28281c1c, 0x5c830482, 0x14211082, 0x83048214, 0x18179159,
+    0x200cd34e, 0xbf491823, 0x09a56609, 0x26272623, 0x08805927, 0x3411352b, 0x013b3637, 0x31272203, 0x2a0b8426, 0x16173233, 0x3633011d, 0x47373637,
+    0x06250917, 0x23070607, 0xcf3d1ac0, 0x12012409, 0x41801b12, 0xa0200885, 0x2109f941, 0xfe191b80, 0xa0200cbc, 0x2422d582, 0x27423625, 0x83a02006,
+    0x86fe201c, 0x8001260c, 0xfe09090e, 0x20448240, 0x06685a01, 0x5583e020, 0x4b860120, 0x83e0fe21, 0x6200206d, 0x022705a7, 0x00c0013d, 0x8235001c,
+    0x005922cd, 0x5dc11800, 0x3317221c, 0x0bdd6515, 0x0627262d, 0x06231507, 0x03171607, 0x58313736, 0x21200d33, 0x10035918, 0xc1186020, 0xb0361f76,
+    0x1213012c, 0x02122c02, 0x022c1202, 0x2c011312, 0x13010113, 0x75180190, 0x80200f2f, 0xc1181190, 0xb420178b, 0x55844b8a, 0xfe255f83, 0x0d0e14e4,
+    0x8a439001, 0x00002a65, 0xff000003, 0x013d02c0, 0x067d6ec0, 0x3613002b, 0x1f163337, 0x27153301, 0x089a5426, 0x010f2624, 0xc2183335, 0x31201487,
+    0x10088019, 0x41331721, 0x00371020, 0x13481602, 0x18bf0105, 0x0e0e1110, 0x40101140, 0x11100f0f, 0x1810b617, 0x201696c2, 0x20b18fe0, 0x2a108fc0,
+    0x0216a801, 0x660c1301, 0x840e0e17, 0x8340204d, 0x66172558, 0x100c0c01, 0x0da4c218, 0x4148fe21, 0x00212101, 0x5f761800, 0x00152309, 0x58192500,
+    0x2f220877, 0x7e482601, 0xf4012708, 0x0cd80c0c, 0x04821010, 0xdc200786, 0x1d820d8c, 0x28074b41, 0x00c0013f, 0x00380030, 0x574f186e, 0x05094308,
+    0x16171624, 0x03821517, 0x010f1625, 0x44260706, 0x07210524, 0x33648226, 0x013f3637, 0x36373635, 0x07353337, 0x011f3637, 0x17152135, 0x36200c82,
+    0x17212b83, 0x06f47e16, 0x27203284, 0x82053747, 0xbc981805, 0x0523470a, 0x31212c82, 0x067d54c0, 0xf4833020, 0x122c2608, 0x650d0304, 0x1d1e191a,
+    0x11141411, 0x1a19211a, 0x04030d65, 0x0d012c12, 0x2030140e, 0x6c14146c, 0x2ae000ff, 0x319e1923, 0x43012030, 0x20200677, 0x80374883, 0x1110070f,
+    0x010f5c0e, 0x0c0c1401, 0x0f010213, 0x10110e5c, 0x83801007, 0xbb1f3080, 0x24070724, 0x02e55b5b, 0x120f0d18, 0x1a0b0307, 0x2425f40c, 0x01190c0c,
+    0x06af4300, 0x01c0013a, 0x004300c0, 0x004d0048, 0x25000067, 0x26273637, 0x3536012b, 0x35342734, 0x4d058c5b, 0x965b0602, 0x07062706, 0x17161506,
+    0x46191514, 0x1f210752, 0xff621801, 0x32212107, 0x2b05d364, 0x1f270727, 0x27330701, 0x1307013f, 0x41052b5f, 0x37080788, 0x26272223, 0x3316013d,
+    0x01153732, 0x0503257a, 0x0a390905, 0x16033e01, 0x0f092515, 0x0c0f150e, 0x0f0c1a1a, 0x080f0e15, 0x03161625, 0x3a0a013e, 0x03050409, 0x13132025,
+    0x07140819, 0x13135608, 0x4030ca20, 0x1f5f2010, 0x31314010, 0x0d100b0b, 0x0703091a, 0x1a090307, 0x0b0b100d, 0x2a36362a, 0x07085d6d, 0x041a1607,
+    0x0e020204, 0x0a0a0c16, 0x1b1b2207, 0x110a0101, 0x01010a11, 0x07221b1b, 0x160c0a0a, 0x0402020e, 0x07161a04, 0x185d0807, 0x0f2b2324, 0x2f00820a,
+    0x24232b0f, 0x20bf8c18, 0x207f7f20, 0x2501bf20, 0x02254e82, 0x17070717, 0x23648202, 0x10060610, 0x280beb79, 0x005f0046, 0x00950083, 0x058f6900,
+    0x32013b22, 0x22061848, 0x4917012b, 0x1c411088, 0x36232305, 0x01822627, 0x36352324, 0x2f823637, 0x37011f22, 0x20198249, 0x06824923, 0x4e311521,
+    0x1f5d0989, 0x82232007, 0x0c954945, 0x19273321, 0x28108334, 0x0c175701, 0x0c092f0e, 0x05ef4714, 0x49373e21, 0x0f390fa5, 0x0311111e, 0x02010346,
+    0x60452d2c, 0x0d090901, 0x2c131a67, 0x0a3b1063, 0x22008207, 0x5469400a, 0x042d0ba0, 0x13091c03, 0x0f1c0c14, 0x22220ac2, 0x07d64930, 0x2222302c,
+    0x1007430a, 0x121b1410, 0x2e830112, 0x10101424, 0x276d4307, 0x05694606, 0x01a00126, 0x07281a14, 0x20069a48, 0x0eb74965, 0x21161d25, 0x82102821,
+    0x2d442400, 0x8220022d, 0x2d1323a8, 0xb2491e52, 0x0b6c5507, 0x0c14352b, 0x11341309, 0x1d2d1818, 0x08e6491d, 0x1d1d0126, 0x0b0b122d, 0x0b23a787,
+    0x4818120b, 0x23440bdb, 0x01002907, 0x001100c0, 0x0069002f, 0x4b06915e, 0x5746051b, 0x16072505, 0x17163117, 0x2605ef5f, 0x23070607, 0x42012f26,
+    0x3624059d, 0x33373637, 0x08cb9c18, 0xbb410d83, 0x37262105, 0x20062b44, 0x05d26317, 0x87052b44, 0x21278252, 0x35821617, 0x40013122, 0x830b3e41,
+    0x472020ca, 0x02280665, 0x261b050b, 0x020b051b, 0x08064957, 0x04e14039, 0x0e050504, 0x60603e1d, 0x050e1d3e, 0x18040405, 0x0602162d, 0x10203216,
+    0x01010d0c, 0x170b0908, 0x65654522, 0x0b172245, 0x01010809, 0x20100c0d, 0x01061632, 0x75182d15, 0x60201110, 0x30207483, 0x64295882, 0x1a02021a,
+    0x0e090964, 0x08758330, 0x0202ff46, 0x08090505, 0x11010111, 0x05050908, 0x080d0202, 0x02151606, 0x0b081009, 0x0b10140d, 0x090e070b, 0x13010113,
+    0x0b070e09, 0x0d14100b, 0x0910080b, 0x06161502, 0x00000d08, 0x20000200, 0x1f02e0ff, 0x1000a001, 0x7a05396f, 0x232e056b, 0x32331617, 0x2723013f,
+    0x31072637, 0x5b720f06, 0x33172208, 0x0a606a37, 0x36334608, 0x01272627, 0x09063160, 0x1e390509, 0x0d0ab062, 0x70b00a0d, 0x342b8f17, 0x14142735,
+    0x2b343527, 0x2005052b, 0x0a052469, 0x313a0609, 0x06090905, 0x05207a1b, 0x63cc2b05, 0x487f0909, 0xb60a0ab6, 0x0423b52c, 0x322b8305, 0x27230405,
+    0x562e3636, 0x6282090a, 0x2e370909, 0x82273636, 0xff102b9b, 0x017001c1, 0x002800c0, 0xc218003a, 0x16220c1b, 0x8b181517, 0x3623152d, 0x18373637,
+    0x2c12e743, 0x31320270, 0x32314b4b, 0x28280102, 0x7089183f, 0x300f260e, 0x0128283f, 0x10ac4db0, 0x0810c218, 0x2f2f4226, 0x0e02230c, 0x0b468918,
+    0x23020e26, 0x422f2f0c, 0x2d105e4e, 0xffff0200, 0xc001e0ff, 0x2000a101, 0xb3823100, 0x0629a582, 0x2607011f, 0x06072223, 0x06915817, 0x27363725,
+    0x82161737, 0x263525a8, 0x23060327, 0x0d976018, 0xaf012a08, 0x05061170, 0x2e391d0b, 0x2d384b36, 0x382f0201, 0x2e364648, 0x38230505, 0x1509081e,
+    0xbb100103, 0x1e27261e, 0x271e1c1c, 0x3e058226, 0x0e01a101, 0x381e0c0e, 0x44353b1f, 0x34363443, 0x363d3e2f, 0x01081d38, 0x0e711701, 0x82abfe02,
+    0x83262026, 0x821e2026, 0x00003705, 0xff100002, 0x017001c0, 0x003e00c1, 0x25000050, 0x26312734, 0x8d823627, 0x83272621, 0x2607229e, 0x82088527,
+    0x05fe45a7, 0x3f306541, 0x1f1e1112, 0x04050311, 0x05083609, 0x1b32311c, 0x09360805, 0x11030504, 0x12111e1f, 0x3f282801, 0x2105926b, 0x07820f01,
+    0x79410a85, 0x2ae13f14, 0x1a192323, 0x07070826, 0x01280701, 0x01052702, 0x25090707, 0x2323191b, 0x2f2f4229, 0x3f84150c, 0x010f1025, 0x84100f01,
+    0x0d132d0a, 0x61432f2f, 0x291b1b01, 0x011b1a29, 0x28240782, 0x011b1b29, 0x602aef83, 0xf001c1ff, 0x3700c001, 0x8b414900, 0x9341180a, 0x1a434208,
+    0xa2412620, 0x10b1500a, 0x41e00121, 0x1b2a05a3, 0x2d443829, 0x2401022d, 0xd9903823, 0x2423382a, 0x1e140101, 0x0e0e0c1e, 0xe020a882, 0x87075471,
+    0xc0012807, 0x0d0d0e01, 0x18211b1e, 0x2508c341, 0x1f0f0113, 0x4787010f, 0x13350a82, 0x3b2b2b0c, 0x1d1e232b, 0x1106050b, 0xfe010f70, 0x171601d0,
+    0x56488b22, 0x57220c87, 0xe38d6900, 0x36372727, 0x0f26012f, 0x20078201, 0x05275527, 0x16171625, 0x4a17013f, 0x1720068a, 0x41056051, 0x1f210503,
+    0x758e1801, 0x492f200b, 0x03410543, 0xf321081d, 0x05040e5f, 0x26431509, 0x10263232, 0x0c090906, 0x11060b0b, 0x04050915, 0x010c5f0e, 0x0a0c0b01,
+    0x25158816, 0x2401011a, 0xb1413823, 0x2e0a850a, 0x01242338, 0x16431a01, 0x010b0c0a, 0x41f30b02, 0x45831222, 0x3d824320, 0x06111a29, 0x090c0b0b,
+    0x84100609, 0x0c01212c, 0x15887b85, 0x3b32262c, 0x130d2a2b, 0x0f0f0f01, 0x5c850101, 0x13270b85, 0x3b2b2a0d, 0x87432632, 0xb0fe2197, 0x25124341,
+    0xff100003, 0x674402c0, 0x446f2007, 0x25283c69, 0x26312726, 0x16070627, 0x830c0c65, 0x1a6c420f, 0x9e440120, 0x02b02a33, 0x3b4b3132, 0x190f1c2d,
+    0x07ba4424, 0x0e1a2425, 0x4428201c, 0x012014de, 0x2933cd44, 0x32314b60, 0x1e210102, 0x0e651627, 0x26162709, 0x2407181e, 0x0d450f01, 0x010f270b,
+    0x2f2f0d23, 0x00820042, 0x2b05ef4f, 0x00a00180, 0x00320020, 0x25000063, 0x4508ea44, 0x9918070a, 0x322908c6, 0x36373637, 0x23060727, 0x0e024531,
+    0x15212986, 0x231b8206, 0x16152322, 0x21075659, 0x19832623, 0x33160722, 0x59883985, 0x38410122, 0x3b066743, 0x05061071, 0x37391e0a, 0x2d304040,
+    0x36300101, 0x2e374747, 0x4d230505, 0x1d26271e, 0x33450082, 0x857b2005, 0x012b3625, 0x0418100f, 0x1c0a0a04, 0x03261e1c, 0x0f010102, 0x1f0a0917,
+    0x0d6d4521, 0x1d38f43e, 0x1106050b, 0x01010e71, 0x1e0d0d0e, 0x07072538, 0x44433632, 0x2f343534, 0xa8363d3e, 0x210b6045, 0x22845401, 0x180d2c32,
+    0x06051010, 0x26261e09, 0x1d011c1e, 0x0c080917, 0x390a9645, 0x00010f70, 0xff000003, 0x018002c1, 0x002700c0, 0x00680039, 0x35232500, 0x1b643736,
+    0x07f75405, 0x21132d42, 0x8944012f, 0x0a5f4611, 0x55171621, 0x072606d7, 0x27222306, 0x6d460706, 0x00012612, 0x28283f30, 0x1b0c4701, 0x07475020,
+    0x44c02010, 0x182805ec, 0x1617352f, 0x09090714, 0x3b055046, 0x21181c25, 0x352d0612, 0x052d3746, 0x1d192305, 0x03150908, 0x23400f01, 0x422f2f0d,
+    0x0749c918, 0x26123847, 0x0170020d, 0x8c291b1b, 0x01102e64, 0x1e0d0d0e, 0x23061f18, 0x1e1c0229, 0x345f8226, 0x0a121d1a, 0x2f341e13, 0x18363d3e,
+    0x0101081d, 0x010f7017, 0x06ab4800, 0xc0010026, 0x42003000, 0x2909eb44, 0x010f2627, 0x07011f06, 0x854b0726, 0x0a1e4205, 0x36013f24, 0x2642012f,
+    0x42032008, 0xf0201169, 0x222fdb86, 0x0a160c0b, 0x3613220a, 0x342f3e3d, 0x42463634, 0x13280504, 0x170b0b22, 0x18220909, 0x20065d42, 0x859c84dc,
+    0x451c20a2, 0x182c06c1, 0x17090922, 0x13220b0b, 0x2e050523, 0x34203883, 0x1328b684, 0x160a0a22, 0x18220b0c, 0x2008bd45, 0x0c8c478c, 0x0f000226,
+    0x7001c4ff, 0x1328cb87, 0x37363335, 0x012b2635, 0xb6450783, 0x17062405, 0x42331716, 0x3b220506, 0x817e1501, 0x16172106, 0x20062742, 0x100a4203,
+    0x0718e034, 0x18070101, 0x04050c19, 0x09093d08, 0x0504083d, 0x1385190c, 0x29284129, 0x30310602, 0x49334b47, 0x20200500, 0x2d0c7e41, 0x01291b1b,
+    0x0601131d, 0x01110711, 0x38820b0a, 0x20083e82, 0x0f010a0b, 0x070f0601, 0x32320e13, 0x2f2f4645, 0x31310202, 0x2f2f424c, 0x01f4fe0d, 0x28281b1b,
+    0x0567471b, 0x002a0783, 0x20000200, 0x70021000, 0x97417001, 0x27252705, 0x07060726, 0x9c5b0715, 0x06584e07, 0x08bf4418, 0x18074866, 0x1807df63,
+    0x200a2d49, 0x20f38216, 0x393c8214, 0x0d526b02, 0x21010e0d, 0x0f200e01, 0x2f0d1301, 0x314c412f, 0x32020232, 0x83824b31, 0x02130c30, 0x010e200e,
+    0x0d0e0122, 0x0a0a520d, 0xcd8865fe, 0x821b1a21, 0xcb29289c, 0x06060b4e, 0x45012710, 0xef420507, 0x01312a14, 0x06061028, 0x0b0b4e0b, 0x0f8d426b,
+    0x27490020, 0x00c02409, 0x462a0018, 0x1267100d, 0x23674a05, 0x820f0121, 0x14e148bd, 0x250d8d45, 0x01010f94, 0xe582930f, 0x48064f4a, 0x022d0bc4,
+    0x10001000, 0x70017001, 0x23001100, 0xf3891800, 0x0730440a, 0x08421120, 0x43c02010, 0x0787077e, 0x210ded41, 0x6e46281c, 0x07084409, 0x41f0fe21,
+    0x00221206, 0x07660006, 0x00142807, 0x0026001d, 0x1844003b, 0x21082fa9, 0x275d011d, 0x27342209, 0xd20c1926, 0x26332d09, 0x16373627, 0x13070617,
+    0x06072221, 0x012226a1, 0x5719fee0, 0x09230b40, 0x18800e09, 0x2007cc56, 0xa1088840, 0x51a02022, 0x068606af, 0x16027822, 0x07853c87, 0x9e780121,
+    0x08bb6a20, 0xc001802c, 0x24001100, 0x00003d00, 0xe5593637, 0x011f230e, 0x18190623, 0x25220fe1, 0xd1543523, 0x0be95409, 0x22fa1819, 0x7a550121,
+    0xa3830587, 0x19190989, 0x68211f10, 0x842f8d30, 0x20bf8839, 0x20bf8278, 0x20bf8512, 0x20ad9025, 0xd3b5182f, 0x19252011, 0x2517cf55, 0x49661301,
+    0x19193131, 0x33200caa, 0x87071a50, 0x62012d07, 0x110e0e2f, 0x112f2f11, 0x2f0e0e11, 0x90200b8b, 0x0dc41919, 0x655b3020, 0x8421200f, 0x90302032,
+    0x0030213e, 0x0abb9e18, 0x82001121, 0x1085410e, 0xd7831720, 0x11231524, 0xdf822726, 0x8f431120, 0x4a212005, 0x262406bf, 0xb0272627, 0x2510494a,
+    0x010ff070, 0x461801e0, 0x022108c4, 0x220b8500, 0x19291b1b, 0x4b090b0b, 0xa023065b, 0x4ab00f01, 0xfe210542, 0x05666860, 0xf0200583, 0x2705514c,
+    0x00030000, 0x01c0ff00, 0x00250182, 0x003d0027, 0x0cc56d4f, 0x2408157b, 0x2b060723, 0x20898201, 0x2204833f, 0x82361127, 0x702120c1, 0x21210552,
+    0xfc561832, 0x051d4307, 0x61421720, 0x0117220f, 0x386a8360, 0x23171601, 0x0303052e, 0x090d2708, 0x09378037, 0x0208280d, 0x232e0503, 0x05894917,
+    0xfe000123, 0x0aa557e0, 0x55059b59, 0xa5820f9e, 0xff2fe082, 0x1b1a2400, 0x06062e06, 0x37090106, 0x82010937, 0x062e2608, 0x01241a1b, 0x20678300,
+    0x0d3677c0, 0x21101d56, 0xef8c0500, 0x65005324, 0xf3ae7700, 0x87013b21, 0x012b2af3, 0x1d060722, 0x07223701, 0x05184431, 0x07201a8b, 0x106e4018,
+    0x11854118, 0x5f2b1b41, 0x068306d3, 0xe485d020, 0xb0201187, 0x200b4552, 0x09517301, 0x0e090922, 0x20233241, 0x0d3241e0, 0xac788020, 0xa240180d,
+    0x0300381a, 0x20000000, 0x60014002, 0x24000400, 0x00003100, 0x21352125, 0x18362515, 0x5c08064b, 0x06200a7b, 0x22054d6b, 0x7f352726, 0x2137051c,
+    0x26353736, 0xc0012127, 0x6001a0fe, 0x160140fe, 0x80012217, 0x5c161722, 0x0f830626, 0x0f84fe20, 0x010f5023, 0x06f57e01, 0x8280fe21, 0x11731800,
+    0x5b102008, 0x102006ec, 0x21071d43, 0x611810a0, 0x9bc409d1, 0x00ff6024, 0x9f820001, 0x23229be1, 0x37413335, 0xc020242e, 0x41e0fec0, 0x00205035,
+    0x20113741, 0x189b8337, 0x410ada4c, 0xc02321d3, 0xd0c06060, 0x42022099, 0x1f22086b, 0xdb5e2c00, 0x095f4212, 0x21059d44, 0x61421716, 0x07062406,
+    0x42d00115, 0xa2851358, 0x4270fe21, 0x0f23095d, 0x83600101, 0x11594215, 0xf0203f83, 0x20086c5e, 0x308b82a0, 0xff000001, 0x013f01e8, 0x001c00a0,
+    0x07062500, 0x18691823, 0x06072709, 0x26272223, 0x88821127, 0x1605172d, 0x063e0107, 0x072d6910, 0x820f0605, 0x2f082600, 0x040b074b, 0x2a4a8204,
+    0x010c0e0d, 0x8f050c0f, 0x835f010e, 0x2f1f8317, 0x01085962, 0x6f011107, 0x0a06070f, 0x00100bf0, 0xc1326383, 0xc0010001, 0x00005100, 0x31071405,
+    0x27262306, 0x5c4e0706, 0x205f8207, 0x0a997737, 0x82263521, 0x231b8774, 0x37361716, 0x21070769, 0x52180706, 0x2b260ac1, 0x17161501, 0x1b831716,
+    0x09000128, 0x253b0e09, 0x00443b25, 0x121b2105, 0x09e48618, 0x090d9418, 0x202d1f9c, 0x0209080e, 0x09022a2a, 0x090d0d09, 0x7f34830a, 0x6020064c,
+    0x8509a25d, 0x560e201f, 0x1f8e063d, 0x2106cb59, 0xe3824002, 0x2d001526, 0x5f005200, 0x180d195b, 0x4609ee46, 0x35200559, 0x89053a5e, 0x25332a16,
+    0x37362726, 0x17163736, 0x05215721, 0x11070622, 0x2205bd79, 0x56212726, 0x362305ec, 0x84371137, 0x20218215, 0x20158211, 0x0d394980, 0xab83a020,
+    0x2006b249, 0x24a68280, 0x1e00ff20, 0x25cb8302, 0x52011225, 0x1d832512, 0x871e0221, 0xaefe2111, 0x57261187, 0x080f0f08, 0x05835201, 0x5eaefe21,
+    0x60200751, 0x21054a41, 0x3f83a060, 0x49452020, 0xc9202109, 0xee204890, 0x0126118f, 0x080f1712, 0x5684eefe, 0x0f081222, 0x270cbf49, 0x00320024,
+    0x1300005d, 0x3320eb87, 0x1520eb87, 0x2320eb87, 0x3521eb87, 0x08394833, 0x31211382, 0x22179313, 0x92352726, 0x87202041, 0x8fd220e4, 0x2310889a,
+    0xd2080f40, 0x0482a083, 0x2487d720, 0x2e231387, 0x90491209, 0x90012038, 0x8f722012, 0x72722123, 0x04845183, 0x8797fe21, 0x29292182, 0x10231485,
+    0x83191116, 0x1a132313, 0x39881226, 0x00820020, 0x0000022c, 0xc001e0ff, 0x1500a001, 0x3b6e2000, 0x32332d0c, 0x3d36013f, 0x26272601, 0x15210527,
+    0x2505bd62, 0x90011123, 0x5048a0fe, 0x1af63307, 0x01135a13, 0xfe140e0d, 0x404001b0, 0xe009090e, 0x8018a001, 0x1b820976, 0x83f61a21, 0xe040282a,
+    0x400e0909, 0x83004001, 0x02c0266b, 0x00c00100, 0x05736a17, 0x36313727, 0x16153337, 0x9ba21817, 0x296c8308, 0x27261735, 0x35272631, 0x1c823736,
+    0x15301b83, 0x07060706, 0x12010023, 0x01401b12, 0x80291b1b, 0xe0240983, 0x0112121b, 0x0d880484, 0x12840884, 0x1b298025, 0x5a40011b, 0xe0200748,
+    0x2b883089, 0x2105bf48, 0x8b828002, 0x21001d2f, 0x45004100, 0x00007300, 0x31232601, 0x836c8222, 0x6a062070, 0x3423081e, 0x83273431, 0x37072898,
+    0x30072317, 0x83363135, 0x21a1829e, 0x2b912326, 0x23172726, 0x11230137, 0x0d5db982, 0x012b2306, 0xbd822726, 0x24058f6c, 0x16013b16, 0x07c36617,
+    0x5e5d2120, 0x2b022c05, 0x0f1c1c0f, 0x0b1b0d13, 0x5a02020b, 0x242c05e3, 0x04040124, 0x74291212, 0xb7904848, 0x2a200a84, 0x243c238d, 0x25243636,
+    0x90488001, 0x8f6f0148, 0x0e720925, 0x09090908, 0x2818800d, 0x0e801729, 0x093e0a82, 0x2509720d, 0x0d0e148f, 0x010f0101, 0x0e010fa0, 0x2501150e,
+    0x1b251b1b, 0x07171635, 0x6b560507, 0x0a062a08, 0x5224240a, 0x109090a5, 0x220a8201, 0x91532423, 0x90a02b23, 0x01f0fe90, 0x09281127, 0x5a820e09,
+    0x01011f23, 0x2809851f, 0xd9fe1128, 0x140e0d01, 0x8363820f, 0x08476e69, 0xc0018029, 0x3e003300, 0x73010000, 0x0f250a23, 0x17161701, 0x0f516e15,
+    0x36353325, 0x7327013f, 0x03220b37, 0x0a740727, 0x01312106, 0x24060444, 0x44442e01, 0x06ce482e, 0x8b07c173, 0x40012813, 0x1b44445c, 0x8201c001,
+    0x279a8503, 0x442f420b, 0x0b422f44, 0x8208f462, 0x29138db8, 0x44448ffe, 0x0b0b271d, 0xb6821d27, 0x8506bb4b, 0x003d22b7, 0x1fbc1847, 0x06152110,
+    0x172fbea2, 0x011f1615, 0x35373637, 0x35331123, 0x83012f26, 0x180020c7, 0x9c0a2b53, 0x016022c6, 0x82c3841b, 0x200783c4, 0x06ff5f01, 0xdf90b790,
+    0x280b202a, 0x1c44441c, 0x80fe0b28, 0xd484cc82, 0x67430020, 0x87012005, 0x348741cf, 0x84170721, 0x161522ca, 0x29864117, 0x8641e420, 0x848f2030,
+    0x5dc282ba, 0xb38606b3, 0x47003c22, 0x2a353d42, 0x3d363307, 0x14152301, 0x41331117, 0x06210581, 0x2a464207, 0x10a1f12e, 0x05a10fc0, 0x06444407,
+    0x01010105, 0x4206037d, 0x80410d38, 0x090e2c10, 0x1d188009, 0x181d0b0b, 0x830800ff, 0x0107233a, 0x00820001, 0x20000122, 0x32060f4e, 0x01000030,
+    0x06071415, 0x35211507, 0x35272627, 0x64013f36, 0x986905f6, 0x17162105, 0x23053460, 0x32373615, 0x08ec181a, 0xc0012608, 0xff1d1112, 0x012a3500,
+    0x011f1001, 0x01010f0f, 0x13140e0d, 0x0d020d0e, 0x0d0e1413, 0x121a0e01, 0x0b030d0d, 0x300b830e, 0x26783001, 0x80141f1f, 0x34202780, 0x180e1745,
+    0x212c822d, 0x1983800f, 0x130d0d23, 0x2637830d, 0x0b011506, 0x8307110b, 0x298a820a, 0xc0ff0000, 0xc001e001, 0x0c824500, 0x21055a45, 0x96702f26,
+    0x18372005, 0x210ab364, 0x9882011d, 0x720cbd72, 0x0d890dcb, 0xe0011531, 0x4b313202, 0x713b5226, 0x110c0b0c, 0x1a3c0c10, 0x9a091048, 0xd0403409,
+    0x0232314b, 0x0c713a01, 0x0b0c1010, 0x013b0c01, 0x82090e17, 0xb00e2100, 0x9a4dc083, 0x83d02006, 0x06974d0b, 0xcd681784, 0x27c78406, 0x00020000,
+    0x3a008001, 0x272bc789, 0x37342726, 0x35262726, 0x72233736, 0x3b210617, 0x31148401, 0x17323736, 0x36331605, 0x34353637, 0x3637012f, 0xeb823337,
+    0x17164e08, 0x00021516, 0x3d292802, 0x0d0e1450, 0x0b110701, 0xbe15010b, 0x0c0c0b11, 0xd2e6110b, 0x0a02011b, 0x0106061c, 0x0b020317, 0x490b0104,
+    0x30170e0f, 0x27260d10, 0x00010105, 0x28293e6f, 0x0e0d0102, 0x040b0e14, 0x1a120c0d, 0x0b0b010d, 0x203e8211, 0x82318344, 0x01572338, 0x36830a01,
+    0x1112172a, 0x1f1c0a01, 0x00050630, 0x01200082, 0xb3850382, 0x00002826, 0x07061525, 0x3522a482, 0x72182327, 0x3623084f, 0x8236013f, 0x82ba84ad,
+    0x213324a9, 0x83011f16, 0x0f0137a1, 0x55010f80, 0x09090dac, 0x12120101, 0x0816691b, 0x0909050b, 0x1c4ab510, 0x010c3b05, 0x81182a0f, 0x0f67770f,
+    0x100f0101, 0x0d080940, 0x0112131c, 0x10201501, 0x2f820c0d, 0x1c132108, 0x0109080d, 0x1815ba21, 0x20000100, 0x2002c0ff, 0x5200c001, 0x34010000,
+    0x27263127, 0x06010f06, 0x34266f82, 0x35363735, 0x0f852734, 0x2f260723, 0x23098201, 0x14170607, 0x06227f83, 0x0f832207, 0x06072223, 0x200f8515,
+    0x200f8423, 0x230f8606, 0x37163317, 0x4d08ac82, 0x35361337, 0x06072002, 0x22081713, 0x010d0a04, 0x08080124, 0x26071810, 0x07151606, 0x14180734,
+    0x01010706, 0x0b010132, 0x092f0208, 0x0a090d16, 0x01014601, 0x3c030307, 0x0a12110e, 0x327a0c0b, 0x1a0d3345, 0x0d1a1b1b, 0x3f01024a, 0xb8820c08,
+    0x7d173b08, 0x010d010a, 0x0403a702, 0x010a0b0b, 0x15b11702, 0xd1140101, 0x0d010217, 0x0404060c, 0x0a0201ca, 0x17900801, 0x0f080901, 0x01d80505,
+    0x3d020801, 0x0c01010c, 0x0c10100b, 0x0e82307b, 0x16160828, 0x050f012c, 0xe7640004, 0x00302b0c, 0x0046003b, 0x25000051, 0x4b630722, 0x059b6405,
+    0x2321fb83, 0x21d18222, 0xd5472711, 0x23e98305, 0x013b1617, 0x3520d983, 0x27222382, 0x30820607, 0x37363526, 0x33151716, 0x012f0a94, 0x030b0e90,
+    0x1b120d0d, 0x0c0d040e, 0x820d1312, 0x0b12318a, 0x130d380c, 0x010b0c10, 0x1c145b08, 0x3d60201d, 0x24063542, 0x0f0f01a0, 0xe1aa1801, 0x26088c08,
+    0x0b1107e0, 0x8216010b, 0x940c2104, 0x36058942, 0x104bbdfe, 0x0d120b0b, 0x0f197a0b, 0x2928020e, 0x0e14603d, 0x79b0010d, 0x09930904, 0x44050021,
+    0x0c24087f, 0x31001d00, 0x2005df48, 0x29e78725, 0x1716011d, 0x31333627, 0xd6653332, 0x82152005, 0x013f21ef, 0x6c087f51, 0x232308a3, 0x18373207,
+    0x23106dd4, 0x22070617, 0x21052a42, 0x08822322, 0x3f34352c, 0x26373601, 0x22072627, 0x2342010f, 0x079f6f05, 0x2623063c, 0x09000127, 0x090e0e09,
+    0x55152b09, 0x01010302, 0x10140955, 0x52030808, 0xed43f536, 0x0c345105, 0x2b080c85, 0x151e1230, 0x0b071010, 0x02023024, 0x0b01040b, 0x02021c2e,
+    0x0607100f, 0x021c6806, 0x22230f12, 0x2e3f4b2d, 0x0e0d102e, 0xffa1121e, 0xd8303185, 0x01242502, 0x010112c7, 0x060b0a0a, 0x1b11bf07, 0x09276d18,
+    0x21824020, 0x080e8a51, 0x01150a28, 0x22130b0c, 0x030a0f0d, 0x0e040b03, 0x08191d0a, 0x20020108, 0x07061b0b, 0x19192a36, 0x25250101, 0x1501063b,
+    0x2b4f0000, 0x01802c05, 0x00240060, 0x01000042, 0x82010f26, 0x070625e5, 0x16171411, 0x63052241, 0x1520050d, 0x087c7118, 0x25272623, 0x08ea4923,
+    0x3d201687, 0x095ef618, 0x156a0228, 0x0f76760f, 0x06751515, 0x0a562506, 0x560a1010, 0x23052041, 0x76fe1501, 0x20067653, 0x4d118540, 0x012a064c,
+    0x9e11065e, 0x0806119e, 0x9452ff16, 0x73a02406, 0x48730c0c, 0x01240623, 0x02081600, 0xdf202f85, 0x20050d41, 0x470d85df, 0x02290653, 0x00c00100,
+    0x0033001a, 0x1c59773f, 0x07161329, 0x2f222306, 0x42152301, 0x332a06dd, 0x17161716, 0x27170706, 0xeb831523, 0x27343524, 0x47182326, 0x40180d8d,
+    0x48290a53, 0x0513075e, 0x26070f05, 0x055f573c, 0x17225829, 0x23020116, 0x57404e23, 0x401808c3, 0x48201087, 0xfe363f85, 0x020b15a2, 0x1648520e,
+    0xd0160202, 0x16010216, 0x172c2217, 0x0241ae4b, 0x059b4906, 0x82800221, 0x001228c3, 0x002c0027, 0x41212500, 0xc1180660, 0x13210995, 0x123a6e21,
+    0x1121032a, 0x00021121, 0x090d7ffe, 0x0d240082, 0x0a0e8001, 0x0e2c0782, 0x14e0fd50, 0x01010d0e, 0x02140e0d, 0x08186318, 0x00fe1026, 0x09000002,
+    0x26056a7b, 0x090e0e09, 0x83c00109, 0xc0fe2121, 0x01212b87, 0x25098340, 0x2001a0fe, 0xeb55e0fe, 0x0023240a, 0x4a4a0031, 0x8d18072f, 0x27252bb9,
+    0x07062315, 0x12006d16, 0x27d28d18, 0x1638f822, 0x0a2b2c19, 0x38160226, 0x02161602, 0x2008376a, 0x05094220, 0x0ba7f218, 0x8850fe21, 0xfe1023cb,
+    0x2f84c0f0, 0x0b4b438e, 0x01c02809, 0x002200c0, 0x183a002f, 0x2431ddf3, 0x26373605, 0x18dc8527, 0x20269af3, 0x20868401, 0x20cf83b0, 0x63f318b0,
+    0x18b82028, 0x200a2083, 0x9bf41803, 0xb348200c, 0x432720b3, 0x1f2e06db, 0x17060701, 0x17013f16, 0x2f363716, 0xc1a73701, 0x0f0f3023, 0xf16a1910,
+    0x33f41815, 0x59102028, 0x6b190728, 0x5385082d, 0x08974018, 0x20079341, 0x82dfbd3e, 0x20d5a7dc, 0x21818348, 0x516e305f, 0x41702006, 0x7020289b,
+    0x5f213183, 0x06386e2f, 0x0100702c, 0xe0ff2000, 0xa0012002, 0xbb822100, 0x3117322b, 0x37011d16, 0x17161736, 0x20058415, 0x08735411, 0x2805df70,
+    0x09090e80, 0x0b0b0c9d, 0x2f048401, 0x140e0d01, 0x0e1460fe, 0x0909010d, 0xa001400e, 0x97210582, 0x21318254, 0x05843f0e, 0x42e8fe21, 0x702008d6,
+    0x00213782, 0x2a6b8203, 0x014001c0, 0x001100c0, 0x69310022, 0xf24613fb, 0x16072405, 0x85373617, 0x35032501, 0x37163716, 0x08365318, 0x6b190120,
+    0x8032107c, 0x1b290f01, 0x0f01011b, 0x1201010f, 0x010f1b12, 0x00821030, 0x19056645, 0x201127d3, 0x22258250, 0x82291b1b, 0x1b0f2305, 0x35821212,
+    0xa360fe27, 0x03010103, 0x059443a3, 0xa3820020, 0xc0ff0624, 0xa382f901, 0x36001d2a, 0x00004300, 0x31373613, 0x2905a361, 0x011f3233, 0x06010f16,
+    0x95192123, 0x3b25079f, 0x07140101, 0x36108331, 0x3f26012f, 0x33373601, 0x33153335, 0x1d161716, 0x27220701, 0x82272631, 0x07143a0e, 0x01df2306,
+    0x0e0d0909, 0x0799090a, 0x09093005, 0xfe070530, 0x09090d86, 0x20158301, 0x220583a0, 0x8787fe0e, 0x41982219, 0x208a82a0, 0x231e83e1, 0x0e0a0941,
+    0x25073544, 0x0b0b3005, 0x3a470530, 0xe0fe2106, 0x11852282, 0x20200122, 0x41214583, 0x211a82c0, 0x16826060, 0x00820020, 0x00000336, 0x4002e4ff,
+    0x04009c01, 0x1b000f00, 0x27050000, 0x13111711, 0x2706d041, 0x0511010f, 0x06071137, 0x3305be55, 0xc0800131, 0x0d7f20c0, 0x01010a09, 0x6ffe910e,
+    0x0a0c7f91, 0x1c3a0a83, 0x37810137, 0x84017ffe, 0x07070532, 0x0fb1fe0d, 0x83013a07, 0x7dfe3a07, 0x0f820433, 0x0f4f012e, 0x01000007, 0xc3ffffff,
+    0xc001ff01, 0x01246383, 0x06070611, 0x2105247d, 0x1c563527, 0x21372508, 0x17161716, 0x12272382, 0x7d901b12, 0x19060606, 0x32097827, 0x121c8001,
+    0x81010111, 0x121be1fe, 0x03045e12, 0x82540803, 0x1f012224, 0x2215831b, 0x471a1212, 0x2d220d23, 0x23474000, 0x4207201c, 0x3d230722, 0x41373401,
+    0x129106af, 0x20192447, 0x05314220, 0x73056746, 0x0d230892, 0x7e0a0a0d, 0xbf201971, 0x2006b746, 0x05c64681, 0xe7670d8d, 0x001a220c, 0x20bd9c27,
+    0x056f4c13, 0x33373625, 0x99151716, 0x026025a4, 0x02169016, 0x95990484, 0x86b8fe21, 0x56278222, 0x2c82067b, 0x2000c028, 0x35002c00, 0xd1423e00,
+    0x16372206, 0x826a8217, 0x4305826e, 0xd75308e3, 0x17352305, 0xff613533, 0x18152007, 0x3008689d, 0x16070637, 0x26373617, 0x20017027, 0x1f30301f,
+    0x05764720, 0x0aaf1119, 0x140e0d24, 0xb7183040, 0x18200857, 0x2205c35f, 0x87b01602, 0x50012108, 0x3d843583, 0x2b820120, 0x6229d021, 0x29290590,
+    0x0d0e14d0, 0x30303001, 0x06b16e1b, 0xe6823020, 0x30203385, 0x28094846, 0xff000004, 0x014002c0, 0x5d4518bf, 0x13002808, 0x37262733, 0x83011f36,
+    0x141525c4, 0x07230607, 0x2326c882, 0x26272221, 0x0482012f, 0x3734352e, 0x37333736, 0x0f161736, 0x27261701, 0x08ae5a18, 0x8305e04f, 0x89332010,
+    0xe8ac2815, 0x14130951, 0x44565d0c, 0x342b0507, 0x16111106, 0x1116e3fe, 0x85340610, 0x5d563a11, 0x0913140c, 0x0f011351, 0x0e02020e, 0x0250010f,
+    0x0101100e, 0x91020e10, 0x062f4c01, 0x9c01012b, 0x13090c14, 0x090901b2, 0x3533820d, 0x0e0d15d1, 0xd1150d0e, 0x0d0e0909, 0xb2010909, 0x140c0913,
+    0x3c83709c, 0x010f6025, 0x85600f01, 0x890f8305, 0x080f5713, 0x2205174a, 0x4259002c, 0x15201c35, 0x11515818, 0x07060732, 0x17152322, 0x23060716,
+    0x26012f26, 0x010f2223, 0x27251182, 0x35013f26, 0x27118422, 0x011f3637, 0x36013f16, 0x67422282, 0x05dc4c19, 0x2a080585, 0x04033c77, 0x051f0202,
+    0x10040414, 0x05031907, 0x07190305, 0x14040410, 0x02021f05, 0x143c0304, 0x3b160804, 0x163b2e2e, 0x42140408, 0x50231993, 0x88110b0c, 0x87250854,
+    0x3f010111, 0x010a1557, 0x05470f01, 0x010f4705, 0x57150a01, 0x1101013f, 0x04141608, 0x110d0d11, 0x08161404, 0x081b4e00, 0xc001bf2f, 0x1e000c00,
+    0x59002b00, 0x27050000, 0x26e28206, 0x32331617, 0x7f273637, 0x342005e5, 0x21083346, 0xed823316, 0x82161721, 0x3f362c1d, 0x37152701, 0x012f2627,
+    0x87060722, 0x3f322514, 0x1f141501, 0x3e850382, 0x34013d25, 0x8335012f, 0x3637212e, 0xbd344c83, 0x07060575, 0x08057508, 0x070b0405, 0x0e14d2fe,
+    0x140d0e0e, 0x0805c046, 0x2f140d22, 0x0607031f, 0x1804040d, 0xda351607, 0x182f1e4d, 0x0c17171c, 0x0404052f, 0x1307070c, 0x5709230a, 0x37053e44,
+    0x09462d13, 0x0b0b0d0c, 0x26070102, 0x040606ac, 0x0307ab03, 0x87010e08, 0x25084988, 0x0d14140e, 0x0e7cfd0e, 0x01040a0b, 0x35581701, 0x25674f01,
+    0x0e0e0101, 0x0c0c5e19, 0x1203070c, 0x0a0d3846, 0x72425356, 0x1a532505, 0x5e5e2d13, 0x53834b83, 0xfc820020, 0xff000038, 0x014002e0, 0x000300a0,
+    0x002c0018, 0x0048003c, 0x27333700, 0x644b2507, 0x05334c14, 0x27060734, 0x36013f26, 0x011f3233, 0x23170716, 0x36352726, 0x3f4c3337, 0x07062405,
+    0x18152335, 0x2608924e, 0x15152aab, 0x57fe5501, 0x0121089a, 0x079043c0, 0x0506ed2f, 0x520a070e, 0x12150b0a, 0x0e084807, 0x2704820e, 0x16386d12,
+    0x38160202, 0x2007c343, 0x08af4b20, 0x2a2aa823, 0x437018f8, 0x02c22e14, 0x1213130d, 0x90150b08, 0x15900c0c, 0x06c6440c, 0x22065768, 0x77016090,
+    0xf7410696, 0x02c12b06, 0x00bf0100, 0x00270012, 0x2a190042, 0x06201c97, 0x0a7c2a19, 0x37272623, 0x230e8326, 0x14151617, 0x6a05b16a, 0x352b0575,
+    0x27262734, 0x013f3207, 0x18012f36, 0x85083a66, 0x010f2d0d, 0x01173726, 0x0d0f131d, 0x10121210, 0x085d2b19, 0x10123c34, 0x0134100c, 0x0c103401,
+    0x07080b08, 0x02131222, 0x2a193d45, 0xff281596, 0x05220811, 0x0e10430f, 0x0b9e4b18, 0x35120738, 0x01351d1d, 0x130f0c0a, 0x16160f0f, 0x08130f0f,
+    0x2d2d1d05, 0x10834b1d, 0x43432c2e, 0x0912102c, 0x26271b06, 0x4a3b592c, 0x23271283, 0x36363030, 0x83233031, 0x3a292f27, 0x3942423a, 0x0f8e2a39,
+    0x2a0a1355, 0x4c180c09, 0x542a0a92, 0x57050110, 0x00000657, 0xb6191400, 0x23080cbb, 0x003e002c, 0x00590047, 0x00740062, 0x00980086, 0x00b300aa,
+    0x00ce00c5, 0x00e900e0, 0x010401fb, 0x001f0116, 0x73068766, 0x16230716, 0x641f1617, 0x0c420558, 0x22198307, 0x6d373617, 0xe0740509, 0x46272011,
+    0x17200700, 0x8710ef79, 0x06a9641a, 0x0864508b, 0x7a118b05, 0x3320112e, 0x27225098, 0x6d7a3607, 0x21a1870f, 0x3598011f, 0x35a28692, 0xba462720,
+    0x12012808, 0x121b1b12, 0x74200112, 0x40210f2f, 0x05674a0f, 0x98600f21, 0xa9e02019, 0x8fa02019, 0x7401202a, 0x229010a0, 0x2a908188, 0x9b9919a2,
+    0xaf494d99, 0x070d4409, 0x0476a020, 0x20c2830b, 0x07014710, 0x19989020, 0x19981020, 0x5e903390, 0x0f8f3a8f, 0x73197e88, 0x21870825, 0x7e9098a2,
+    0x003833a2, 0xff000006, 0x010002c0, 0x001100bf, 0x00370025, 0x00820068, 0x3700009c, 0x20100d65, 0x78251907, 0x68251909, 0x11336508, 0x07260124,
+    0x02830631, 0x16170625, 0x82373633, 0x16172601, 0x06071617, 0x059a580f, 0x4d06d673, 0x3629060f, 0x07272627, 0x16311732, 0x058d4915, 0x82272621,
+    0x8307201f, 0x3734240b, 0x18373336, 0x2109f76a, 0xfa521617, 0x82262008, 0x0da02633, 0x0a09090a, 0x0559460d, 0x0d0a4922, 0x40200e83, 0x37200686,
+    0x080d5c65, 0x30313832, 0x02062020, 0x1a0f0a0a, 0x21200605, 0x1d1c372e, 0x11210a0a, 0x0b170f0f, 0x0a010808, 0x1d2b0f0b, 0x043d051d, 0x3b232301,
+    0x0c0b1130, 0x02161602, 0x0756fb18, 0x0c2e0b83, 0x0d9e110b, 0x05060c0c, 0x240c0404, 0x18471515, 0x1e012705, 0x0980341f, 0x294b0d09, 0x21058205,
+    0x8d820929, 0x400a0d22, 0x3f470686, 0x08218306, 0x010a0a31, 0x11110e7a, 0x0f342728, 0x1b020a09, 0x011c1c2c, 0x372b2c05, 0x0d12222d, 0x05111118,
+    0x0c090902, 0x0209090f, 0x2c1e1e08, 0x313e583f, 0x82821131, 0x02162771, 0x19251602, 0x88830119, 0x97820b83, 0x8083c520, 0x12238883, 0x852c2322,
+    0x333e23e1, 0x974b1a32, 0x02c22c06, 0x00c00180, 0x008b0045, 0x48163700, 0x262b0804, 0x37363727, 0x27262736, 0x8b010f26, 0x24118309, 0x010f0607,
+    0x05105f06, 0x07212386, 0x4a018206, 0x33220669, 0x6c182325, 0x52830a70, 0x07141524, 0x49822306, 0x71462720, 0x05914607, 0x3f161723, 0x85098b01,
+    0x013f237b, 0x2b833536, 0x0b1bc832, 0x0d0c0b05, 0x0405060c, 0x0d502f12, 0x04030606, 0x632b0e82, 0x01010a51, 0x0c0d0909, 0x8216640b, 0x0c0d3719,
+    0x54060c0c, 0x1f1e010f, 0x1d32642d, 0x0b020308, 0x080d0c0c, 0x6149150c, 0x4d012105, 0x56a01492, 0x04040522, 0xd022568a, 0x82831a01, 0x2f228a83,
+    0x82831710, 0x1d218a83, 0x83828346, 0x3156218a, 0x33838283, 0x2521bc28, 0x011e1f2d, 0x82832905, 0x8a820720, 0x49011121, 0x702005eb, 0x12221289,
+    0x82590101, 0x19012205, 0x84be820d, 0x16112555, 0x0d0b0c04, 0x1c215583, 0x82558d45, 0xbc0c2221, 0x48558420, 0x012e070b, 0x00c101ff, 0x002c0012,
+    0x007a003f, 0xd64a3700, 0x05de4205, 0x36013f26, 0x37273635, 0x43086a7b, 0x25220f15, 0x2e8e2734, 0x60072721, 0x4a600724, 0x43142005, 0x07420775,
+    0x82152005, 0x0a794315, 0x17211d82, 0x087b4332, 0x0d0ac030, 0x098a0a0c, 0x0d0c0a09, 0x0109890a, 0xeb850809, 0x270f0243, 0x0a093701, 0x280a0d0d,
+    0x2f822882, 0x092a2108, 0x11016001, 0x42262710, 0x0c26264c, 0x090a010c, 0x06051a0e, 0x282c1f1e, 0x0b0b1819, 0x08121202, 0x29065b43, 0x040d090a,
+    0x191a1819, 0x16822c07, 0x0808812f, 0x0e0d0a8a, 0x8a090908, 0x0b0c0c0a, 0x05dc414f, 0x250fe742, 0x090a0dd1, 0x8e832b09, 0x09092508, 0xd30e0a29,
+    0x2029291f, 0x2403021f, 0x07262725, 0x0209090e, 0x1b1c2a1c, 0x14140101, 0x2b171c1c, 0x11071c1c, 0x2d084243, 0x0109090d, 0x18180808, 0x2d2c3131,
+    0x6b4f0012, 0x003b270b, 0x007a0049, 0x41822500, 0x3b6d0620, 0x16172705, 0x1716013b, 0xe1420706, 0x590b9905, 0x2f200790, 0x42056e4a, 0x1f2705f8,
+    0x0f062501, 0x72262701, 0x162405f4, 0x012f0607, 0x072a0b8c, 0x1f060706, 0x16171602, 0x3f861517, 0x6c4b0134, 0x14040816, 0x0613c72f, 0x0b070701,
+    0x01010780, 0x0b859f07, 0x0b83a020, 0x178a7f20, 0x0b855f20, 0x33d02308, 0x01012222, 0x86261717, 0x09080a09, 0x13071510, 0x0305060c, 0x1622010f,
+    0x073c0202, 0x06060b13, 0x4b822703, 0x832f0321, 0x03062718, 0x0806012c, 0x17852202, 0x304a2237, 0x1d011d1d, 0x03011111, 0x0421ce16, 0x11081614,
+    0x080c1201, 0x202e8209, 0x39089701, 0x20332222, 0x0e201f29, 0x0502043e, 0x02011242, 0x310b0909, 0x32160223, 0x0a8212be, 0x077a0c26, 0x97070103,
+    0x0b270a83, 0x0203078a, 0x84136a07, 0x176c2e21, 0x33282811, 0x1c1c101c, 0x01167123, 0x06db4200, 0x8002c02a, 0x1e00c001, 0x3f003700, 0x0def8018,
+    0x04461620, 0x06072205, 0xdcab1807, 0x2635240b, 0x5e333227, 0x14210594, 0xd90b1907, 0x36012d09, 0x07060137, 0x37262531, 0x22313005, 0x08219b18,
+    0x0b193120, 0xab3034d7, 0x100cadfe, 0x1c186b01, 0x030498fe, 0x04052801, 0x07e70b19, 0x36d80b19, 0x0901c134, 0xe2fe1515, 0x0ac9080d, 0x1701e80a,
+    0x22222217, 0xfe821c23, 0x00010030, 0x01e0ff00, 0x00a001c0, 0x01000046, 0xeb820611, 0x2b053145, 0x36350706, 0x16171637, 0x35373217, 0x22201185,
+    0x07201b83, 0x09f85e18, 0x2006e351, 0x21f8821d, 0x0f413736, 0x05a54305, 0x0ec0012e, 0x14141f0c, 0x1e1e2d16, 0x15151e2d, 0x1e250482, 0x1b1b1c2d,
+    0x250f831c, 0x10111217, 0x90461613, 0x05694605, 0x10131625, 0x83171211, 0x1416371b, 0x0f0b1f14, 0xb0fe9001, 0x060c0405, 0x0e0e0205, 0x40070102,
+    0x08830107, 0x09d00922, 0x05250683, 0x05080605, 0x651519fe, 0x06f45107, 0x08050e24, 0x2e840506, 0x0c060526, 0x06000504, 0x0233d883, 0x00810180,
+    0x00110008, 0x005c0034, 0x006e0065, 0x82333700, 0x013d239e, 0xd6821123, 0x26070630, 0x01373627, 0x30010f22, 0x06311431, 0xe8821415, 0x30371625,
+    0x18313031, 0x2808a4f3, 0x26272635, 0x06020f23, 0x24078227, 0x013f3637, 0x26ff8323, 0x16173315, 0x83373637, 0x05045704, 0x36013f27, 0x012f2627,
+    0x24418337, 0x2311013b, 0x2a578317, 0x07061716, 0x090e4000, 0x4a306009, 0x440807ad, 0x090d2d01, 0x0a0b0d62, 0x500e1010, 0x09080b0c, 0x0404921b,
+    0x2c28281f, 0x181e0e08, 0x14151d1c, 0x52160101, 0x28282c06, 0x155b121f, 0x1212191a, 0x0a0f0f0c, 0x0c0b0520, 0x080a090d, 0x950a0201, 0x0d0909d1,
+    0x274e8941, 0x0e090940, 0x4000ffe0, 0x0807f649, 0x08000120, 0x100c015a, 0x020a0d0f, 0x09490b01, 0x180b0c0a, 0xc2040376, 0x0111101f, 0x01141c99,
+    0x64831502, 0x10114b3c, 0x1052e01f, 0x10150302, 0x0c010209, 0x01080426, 0x0b0b0b01, 0x7a090c0d, 0xad82e059, 0xe0000122, 0x00204f87, 0x23098b66,
+    0x0047002c, 0x2206437e, 0x85272631, 0x06312201, 0x32018c07, 0x17161115, 0x36211716, 0x11373637, 0x06072734, 0x7b2f2223, 0x1183050a, 0x83054642,
+    0x07152320, 0xa482ee01, 0x1f202e08, 0x0e05043b, 0x0f0f1211, 0x050e1112, 0x34070804, 0x0f0f1d1c, 0x0d01120b, 0xa001140e, 0x010d0e14, 0x1916bf12,
+    0x0d911619, 0x05501f20, 0x33a48206, 0x060b0e0c, 0x1f204f05, 0x1d01910e, 0x170c0c09, 0x04032b17, 0xbe84b982, 0x0603042d, 0x14152605, 0x0f090b0c,
+    0x50f9fe17, 0x2308072c, 0x0f170801, 0x711010cd, 0x17180b2e, 0x0104043a, 0x09080801, 0x3a040409, 0x2e0b1817, 0x00000071, 0xff200006, 0x26056b67,
+    0x00260014, 0x823e0035, 0x675020e5, 0xcd850cdf, 0x0720ef83, 0x10b49f18, 0x26231323, 0x087f6727, 0x1307062b, 0x36331523, 0x27263537, 0x23089015,
+    0xe0fe8001, 0x08c25718, 0x09872020, 0x3010f24a, 0x010fc060, 0x22171601, 0x16172240, 0xa00f0101, 0x058c7b10, 0x0127058a, 0x121201c0, 0x8880fe1b,
+    0x4d09844c, 0xff23102f, 0x840f0100, 0x824c8243, 0x60402752, 0x0f400f01, 0x068c8001, 0x00820020, 0x18000621, 0x83095f4a, 0x004024ff, 0x9656004b,
+    0x9f0520ff, 0x183720ff, 0x20142b59, 0x18158935, 0x4c16634a, 0x0641102d, 0x80e0210e, 0x0f20c282, 0x4a180498, 0x174e1566, 0x0d124110, 0x91083243,
+    0x47002008, 0x1a240c83, 0x3a002c00, 0x411dfb53, 0x11201017, 0x530c1642, 0x1f2319dc, 0x18011414, 0x8307634d, 0x37512c07, 0x241c1b0d, 0x1b1c2440,
+    0x5351370d, 0x802019c2, 0x4383338b, 0x02c0fe2d, 0x13142036, 0x14130101, 0x18023620, 0x420daf69, 0x402005d7, 0x4216d341, 0x5b1820d3, 0x58180a15,
+    0xc34215a6, 0x6030251f, 0x0f01010f, 0x2d5e0484, 0x5a602006, 0xa020088a, 0x584f0983, 0x0da84110, 0xa0410120, 0x20d78308, 0x08af4207, 0x18000c21,
+    0x2207c393, 0x875c004d, 0x211528dd, 0x26272635, 0x18160127, 0x190b5885, 0x2015c638, 0xb0ca1815, 0x41272009, 0x072010c0, 0x20069653, 0x05c84123,
+    0xfe100223, 0x27aa8320, 0x0d014002, 0xf0fd140e, 0x09d3ce18, 0x01c0fd23, 0x18984270, 0xba531884, 0x07b14308, 0x84804021, 0xc00f21ff, 0x6c05ae66,
+    0x1021050b, 0x21148310, 0x1a4170fe, 0xfe302308, 0xfe62f0d0, 0x10ef4319, 0x636aa020, 0x0003370e, 0x01c1ff10, 0x00c00130, 0x00290012, 0x37000041,
+    0x06272635, 0xd67c1507, 0x27262109, 0xb34e1283, 0x25168505, 0x36373617, 0x87182637, 0x352008e6, 0x33240e82, 0x17161732, 0x2006f46d, 0x218e83b0,
+    0x6883021e, 0x023ba583, 0x2001601e, 0x202f2f1f, 0x011f0121, 0x3d292802, 0x0228293d, 0x22701f01, 0x82011617, 0x06425411, 0x01011f27, 0x7d221716,
+    0x25eb82d3, 0x210cd30f, 0x00820e14, 0x0c211424, 0x7f58a72c, 0x25a72d07, 0x29283d34, 0x28290101, 0xa925343d, 0x21232c82, 0x57c01828, 0xc02305af,
+    0x82212818, 0x4000204c, 0xa3208ecb, 0xa320cb83, 0x0f21cbcc, 0x3d974101, 0x01010e22, 0x20369841, 0x20cc8373, 0x21ccb673, 0x9b410000, 0x20cff916,
+    0x20cf8333, 0x27cfc333, 0x002e0016, 0x25000040, 0x20097f5b, 0x08827d06, 0x23192443, 0x31070635, 0x2623278b, 0x43100127, 0xfc432826, 0x20078707,
+    0x2a2543a9, 0x4e188020, 0x00220f98, 0x7f7c0800, 0x00112e08, 0x00350023, 0x00590047, 0x007d006b, 0x53d582a8, 0x3153101f, 0x20119111, 0x0e6a1807,
+    0x20479011, 0x99531833, 0x11655310, 0x26012f28, 0x2726010f, 0xbe180726, 0x112c0cc7, 0x33363734, 0x06011f32, 0x07171617, 0x08896418, 0x10532020,
+    0x7773180b, 0x7eac180c, 0x4cc0200c, 0x0e20074a, 0x338c2f82, 0x198c268c, 0x0b052608, 0x1b060c0b, 0x101d2020, 0x212b2a1f, 0x200f0116, 0x0a0b010f,
+    0x110a0f0f, 0x1402020f, 0x0b090907, 0x0aa90b0c, 0x1a6c180a, 0x088e5e0c, 0x198d6783, 0x8b0ca867, 0x180b8b8e, 0x080cfd73, 0x090be527, 0x02140709,
+    0x1d110f02, 0xfe251e27, 0x01010fba, 0x0f4c010f, 0x100b0b0a, 0x1b20201d, 0x0b0b0c06, 0x0ba90a0a, 0x0cbf5e0c, 0x41001627, 0x16370000, 0x06767317,
+    0x2e07b87b, 0x21353736, 0x35212515, 0x1f363736, 0x41170601, 0x2f25063f, 0x26072601, 0x06955b07, 0x06231523, 0x76358207, 0x202205a8, 0xf0841f01,
+    0x84000121, 0x011f2e06, 0xd00140fe, 0x070170fe, 0x0b0d0708, 0x21fb8417, 0x89820a69, 0x2a1d0c25, 0x8220170e, 0x05d47b65, 0x83e00121, 0x2c4021a4,
+    0x2105b761, 0x0d830f0f, 0x2c1b292d, 0xb3802020, 0x06040308, 0x841d2a0e, 0x0b6922b4, 0x29db820c, 0x160d0b17, 0x15160101, 0x6384b321, 0x4b5c0484,
+    0x01c02d08, 0x002a00c0, 0x00560044, 0x1300007a, 0x0beb6718, 0xaf822620, 0x0d8bbc18, 0x18070621, 0x21093470, 0x61432611, 0xa0431807, 0x69372008,
+    0x35200557, 0x23100c7c, 0x31272637, 0x2505e146, 0x37361716, 0xcd473330, 0x26378205, 0x32070617, 0x83313031, 0xe04f0815, 0x1d33323f, 0x2501011e,
+    0x02053c25, 0x02161624, 0x4b4b3132, 0x16023231, 0x05022416, 0x0125253c, 0x331d1e01, 0x121a3f32, 0x06010113, 0x0c040707, 0x0c0f0f0c, 0x0707040c,
+    0x13010106, 0x10181a12, 0x1001010f, 0x10171710, 0x0f010110, 0x47901810, 0x0226070a, 0x011a0633, 0x40180224, 0x02280718, 0x061a0124, 0xc0010233,
+    0x46294e85, 0x211b3637, 0x26261919, 0x836b832f, 0x262f2973, 0x21191926, 0x4637361b, 0xfe379085, 0x090a01c8, 0x29291b1a, 0x05040e18, 0x180e0405,
+    0x1a1b2929, 0x18010a09, 0x83084f79, 0x247d836d, 0x28293d38, 0x25758302, 0x0f142a45, 0x065c301c, 0x1c302607, 0x452a140f, 0x33871800, 0x01002708,
+    0x001500a0, 0x83180029, 0xc4180bed, 0x05200a69, 0x1808c943, 0x2107a050, 0x765c2123, 0x0b6f4c09, 0x08ed5418, 0x21065943, 0x804bc0fe, 0x0c1d4315,
+    0x63508682, 0x00022a05, 0x13002000, 0x34370000, 0xfb3b1937, 0x09002410, 0x69010e09, 0xfe2006db, 0x5c7c5d83, 0x0300220c, 0x05eb5700, 0x1c00c025,
+    0x82003200, 0x230125da, 0x23150706, 0x21052961, 0x3d611716, 0x35232106, 0x2005834d, 0x1e871805, 0x69172014, 0x2b2107a4, 0x071f6901, 0xe0b00129,
+    0x0140010f, 0x18221716, 0x4d08654a, 0xfe270576, 0x12120150, 0x1800011b, 0x200d9d86, 0x86a08660, 0x80012406, 0x7c100f01, 0x41840813, 0x0f014022,
+    0x80205182, 0x4a85368d, 0x18101341, 0x1925afa9, 0x1818d22b, 0x2115ba6c, 0x2b192ff1, 0xa84116cf, 0x2fb02515, 0x0f101130, 0x0cf82b19, 0x074d4085,
+    0x0004350c, 0x007a006d, 0x35333700, 0x33251523, 0x27263736, 0x27263523, 0x06220585, 0x0c831507, 0x0621068a, 0xa4561807, 0x69332007, 0xec6807c2,
+    0x05b55705, 0x36230582, 0x8d333537, 0x37362106, 0x59851383, 0x45826086, 0x2b08265f, 0xc0c0a015, 0x0f302001, 0x300f0101, 0x2008eb5a, 0x08156e40,
+    0x121b1024, 0x1d850112, 0x29a3058b, 0x2805b041, 0x0fe00f01, 0xc0c06001, 0xba5283b0, 0x20a1944d, 0x82b683c0, 0x2464825f, 0x1f000100, 0x055b72ff,
+    0x00009a2c, 0x22230625, 0x1617012f, 0x07822207, 0x2e620220, 0x65108205, 0x3460092f, 0x0f272205, 0x2b288201, 0x013f2623, 0x22230607, 0x36372627,
+    0x074d7718, 0x83273721, 0x8227203a, 0x05a15219, 0x1f363723, 0x221f8301, 0x8435021f, 0x27012106, 0x5208a053, 0x3f2606d3, 0x16173601, 0x0d83010f,
+    0x8305db5a, 0x22232505, 0x17072723, 0x3908f552, 0xdc010716, 0x0808120a, 0x15040519, 0x05120303, 0x0e303c12, 0x090a070e, 0xcd460e08, 0x110e2705,
+    0x300e0e11, 0x19823c01, 0x15030337, 0x06190504, 0x060a1209, 0x1a0c0303, 0x07041514, 0x3d3d4216, 0x35368342, 0x1a141504, 0x0603030c, 0x0c0c0c08,
+    0x13030519, 0x3b120816, 0x3c830e2f, 0x0a090123, 0x244b830d, 0x0e0f1111, 0x21478231, 0x45831607, 0x08202682, 0x052c4587, 0x43030312, 0x16423c3b,
+    0x15140407, 0x40314584, 0x140f0410, 0x43110816, 0x11314623, 0x0e070711, 0x0573471d, 0x830e1d21, 0x46312a52, 0x08114323, 0x040f1416, 0x21468310,
+    0x0b82050f, 0x23120329, 0x16111223, 0x830f0508, 0x83898381, 0x14032140, 0x0e234185, 0x851e0f0e, 0x0f1e2141, 0x14214187, 0x20368203, 0x2383830f,
+    0x070d0c0c, 0x11204483, 0x03204383, 0x44857782, 0x01000022, 0x27088744, 0x2500001e, 0x27060706, 0x0d357818, 0xa3582620, 0x16173005, 0x01070607,
+    0x1b1e14c2, 0xe8121720, 0x8210100c, 0x0ee73695, 0x0c0b0204, 0x3c3c3518, 0x090a2528, 0x0c18ce33, 0x0e04030c, 0x821982e7, 0x13e72e1e, 0x1d1d1f17,
+    0x0a093314, 0x3c3c2825, 0x057b5335, 0x01c0012a, 0x003a00c0, 0x1300005d, 0x06204f83, 0x22085c67, 0x82263527, 0x3f262177, 0x079ba518, 0x33011d23,
+    0x06e94137, 0x15141728, 0x36353317, 0x03823037, 0x16173626, 0x1413011f, 0x23053542, 0x2223013d, 0x2005ba53, 0x05ad553d, 0x84161721, 0x15143301,
+    0x0404de11, 0x21160c04, 0x0f120b0b, 0x1f010c0c, 0x0f820c16, 0x05011f36, 0x04060605, 0x04111204, 0x04060404, 0x10120103, 0x06050301, 0x02230182,
+    0x840ce21e, 0x0d112fd1, 0x09090c0b, 0x1f020406, 0x08073420, 0x25830708, 0x132b0128, 0x19101313, 0xf183da07, 0xda100c38, 0x130f1a06, 0x05891314,
+    0x01010404, 0x90060504, 0x03040594, 0x0c820303, 0x06909424, 0x07820104, 0x88225c82, 0x2d85bdfe, 0x05782508, 0x0c090905, 0x39720c0c, 0x03162e2f,
+    0x04050101, 0x02060607, 0x0048fe01, 0x10000100, 0xe001e0ff, 0x3400a001, 0x0fa9b118, 0x0eefe918, 0x11337718, 0xe918e785, 0x39301be1, 0x060c2d2c,
+    0x11921207, 0x0f100102, 0x543e300e, 0x1fd9e918, 0x2d24013e, 0x01100f0e, 0x13921102, 0x300c0606, 0x1e010236, 0x3e33321e, 0x00050000, 0x01c0ff00,
+    0x00280182, 0x0027001a, 0x003d0032, 0x1326bc82, 0x16333736, 0x6818011f, 0x0721132d, 0x0ada6b21, 0x13451720, 0x27262305, 0x1e450706, 0x180a8e06,
+    0x36174d68, 0x01810168, 0xfe1b1212, 0x12121bff, 0x0e025001, 0x0f01010f, 0x6760020e, 0x6120071b, 0x18082256, 0x21126668, 0xa550fe6e, 0x40012208,
+    0x226a1850, 0x930f2008, 0x00003209, 0xff100002, 0x01f001e0, 0x002200a0, 0x01000046, 0x05624907, 0x16170624, 0xfa421617, 0x16372305, 0x0e830717,
+    0x24058947, 0x26010f26, 0x062a5607, 0x51182620, 0x16220e4d, 0xdc5d3617, 0xc2013c06, 0x48553c31, 0x04173738, 0x0d0d0506, 0x11040b0c, 0x3a332727,
+    0x060b2d2a, 0x41931206, 0x08200594, 0x2c211689, 0x2216890c, 0x82543c31, 0x83182037, 0x98012837, 0x01023630, 0x83442928, 0x05042e29, 0x1d300d06,
+    0x2501011c, 0x0f0f0e2c, 0x06a84102, 0x2783fa20, 0x37881691, 0x00030c22, 0xe3830082, 0xb001c028, 0x3000c001, 0x65793b00, 0x012b220a, 0x067c1815,
+    0xa475180f, 0x23352109, 0x2006815e, 0x0513413b, 0x2105ca41, 0x63441001, 0x39102305, 0xe55f152b, 0x20182205, 0x60731801, 0x31312208, 0x201f864c,
+    0x91c61860, 0x07537908, 0x230a2223, 0x05945f16, 0x40311822, 0x07487318, 0x38385024, 0x8445220e, 0x16c02505, 0x80160202, 0xe7490484, 0x0026240d,
+    0x48000042, 0x27220bea, 0x346e3526, 0x76322005, 0x2b2105c0, 0x080a7201, 0x26272529, 0x15070607, 0x18072223, 0x82075446, 0x3f1627b6, 0x34353601,
+    0xe2496027, 0x4a068e06, 0x01260762, 0x0e0c9099, 0x954d010e, 0x01802706, 0x900c0e0e, 0xbe6b0707, 0x190e2008, 0x2614f016, 0x060b88f1, 0x6d480f07,
+    0x472a063f, 0x0a06070f, 0x0a0a0788, 0x65180007, 0x1b200a97, 0x989bbf83, 0x3e743720, 0x17322709, 0x14111516, 0xd0490607, 0x013b2c08, 0x37363736,
+    0x26272611, 0x93590127, 0x8e4720a0, 0x059e41ce, 0xd5874020, 0xa08cd120, 0xa0824820, 0xa0840b20, 0xc74dcf20, 0x075f7408, 0x01253882, 0x01291b1b,
+    0x243a8300, 0x00010000, 0x06174320, 0x31423920, 0x011d2306, 0x13420706, 0x783f2005, 0x4150052a, 0x37362108, 0x0621b783, 0x053c4207, 0x0805974c,
+    0x16373623, 0x33363717, 0x080bd501, 0x92110208, 0x0808070c, 0x443a2b2d, 0x02022d2d, 0x22442d2d, 0x0f0d1414, 0x2972820d, 0x342e2e03, 0x1e32333e,
+    0x7044011e, 0x3e543405, 0x010a0930, 0x0c0708a0, 0x08011292, 0x090a0b08, 0x8301242d, 0x82398331, 0x0b092210, 0x22b98201, 0x8615151b, 0x233b852f,
+    0x08303602, 0x3408f75c, 0x00c10100, 0x004d003b, 0x006e005c, 0x37362500, 0x27262726, 0x20068723, 0x230d8335, 0x15160722, 0x2320ad83, 0x8605e262,
+    0x590c8506, 0x268306f1, 0x0973c518, 0x20060943, 0x09a16633, 0x3337262a, 0x22270716, 0x35263127, 0x2d06a746, 0x06071415, 0x1cc30123, 0x14140101,
+    0x9f820e1f, 0x12122008, 0x0106061b, 0x08291b1b, 0x16010f07, 0x1b102217, 0x01011212, 0x141f0e15, 0x1c010114, 0x8410111b, 0x70012129, 0x10240f84,
+    0xfdfe1b11, 0x8505bb41, 0x0ba02d05, 0x1d1d1c1c, 0x02091c1d, 0x0109b009, 0x220cea4f, 0x8324154f, 0x12220833, 0x11121b1f, 0x29120f01, 0x02011b1b,
+    0x17221915, 0x12010116, 0x121e1a12, 0x1f141502, 0x13051524, 0x5a841b14, 0x1b248e82, 0x71051314, 0x8208f141, 0x168b2d60, 0x01010f0f, 0x09160f0f,
+    0x4b090202, 0x0c987818, 0x2c064741, 0x014002e0, 0x001400a0, 0x003c0026, 0x166f5751, 0x276c0520, 0x3736240c, 0x19053336, 0x2613f141, 0x2621010f,
+    0x55272627, 0x535b05b3, 0x27262406, 0x56fe1002, 0x0d23053b, 0x8801140e, 0xcffe2109, 0x2108fe85, 0x01090a0d, 0x010d0909, 0xfe09050f, 0x04040ae0,
+    0x08054605, 0x3f160508, 0x05090904, 0x2604056a, 0xdb83b0fe, 0x1616022d, 0x22220102, 0x16500133, 0x56160202, 0xff20057c, 0x081eda18, 0x09840120,
+    0x340ca54c, 0x080908d8, 0x07076008, 0x07075e1e, 0x780908a0, 0x1f141401, 0x253b83f0, 0x222233f0, 0x4e820201, 0x0034fe82, 0xff000002, 0x01ff01c0,
+    0x001b00bf, 0x25000029, 0x23372707, 0x0727bf82, 0x37010f06, 0x18173736, 0x2a08ce94, 0x3717013f, 0x14311516, 0x8227010f, 0x324508fb, 0xa601011f,
+    0x2e0322e9, 0x0803010f, 0x094f1703, 0x16102208, 0x0a0a0e78, 0x10072304, 0x124782e9, 0x31823112, 0x131a1a13, 0x21e9e428, 0x2e0f0104, 0x4f090803,
+    0x21070317, 0x04230710, 0x780e090b, 0x82ea0f16, 0x822083a1, 0x12122327, 0x878a0028, 0x89820d20, 0x36010024, 0x64823133, 0x84151621, 0x83172070,
+    0x2706258e, 0x36013f26, 0x01218782, 0x8459846b, 0xe93b2163, 0x0121778b, 0x864b82ad, 0xe9c92155, 0x5f8c6b8b, 0x01206e82, 0x0723cb8c, 0x6b010f26,
+    0x6c8b09e2, 0xed012727, 0x82341212, 0x3c718434, 0x671110fd, 0x0e0e1110, 0x1d1d1666, 0x4abc8f16, 0x090d1966, 0x15050209, 0x010e9a4a, 0x82218385,
+    0x39808228, 0x650e0e38, 0x11100f0f, 0x8f151566, 0x051549bd, 0x0d080a02, 0x9b496619, 0x0082000d, 0x2705434c, 0x00c00120, 0x2500001a, 0x2405695d,
+    0x37363726, 0x05455333, 0x15161735, 0x17163311, 0x1a010716, 0x0a0a0868, 0x060a6808, 0x42490e07, 0x482505b4, 0x0a06070f, 0x659c1838, 0x09c54f08,
+    0x0b0f0d24, 0x5b820100, 0x00023f26, 0x1b004001, 0x51735782, 0x06153105, 0x012f0607, 0x3f343526, 0x16173601, 0x32211517, 0x02215e82, 0x224d8200,
+    0x8201c0fe, 0x234a8c34, 0x09090ec0, 0x778d6184, 0x00820020, 0x18205b89, 0x07255b82, 0x3d262706, 0xb3a21801, 0x01341907, 0x0b70240b, 0x83fe0e0f,
+    0x1d032347, 0x60864001, 0xc186ae20, 0x1d0e0a23, 0x205e8902, 0x064b4d00, 0x07411f20, 0x06012205, 0x04661807, 0x2623210a, 0x240a6d6d, 0x0e071d01,
+    0x30ff8548, 0x05070f49, 0x0a07680a, 0x0b68080a, 0x0d2e0107, 0x826b8401, 0x826c881b, 0x27ae8280, 0x00000400, 0x4002c0ff, 0x19275b82, 0x2b001d00,
+    0x74003a00, 0x37210581, 0x05e55f33, 0x06071526, 0x1706010f, 0x27266783, 0x17350511, 0x0d420523, 0x4237200d, 0x37270a6f, 0x12010031, 0x82a01b12,
+    0x80290866, 0x10040c5f, 0x1bc30503, 0x01011212, 0x01808000, 0x1d0c0c34, 0x0f0d1d47, 0xfc0e0d10, 0x06814781, 0x06093c09, 0x020f0206, 0xcdae1806,
+    0x5e8c2609, 0x0f3c110d, 0x2942830d, 0x80408001, 0x100c7a80, 0x34820d10, 0x0e0c0c24, 0x328280a6, 0x06252d83, 0x08083b0a, 0x4b361900, 0x61bf2008,
+    0x252005cb, 0x2e053f7f, 0x27013f26, 0x07161707, 0x26012b06, 0x43363527, 0x3724057b, 0x27060727, 0x2d08856e, 0x14313007, 0x3717010f, 0x36372627,
+    0x4d513337, 0x012f2105, 0x0805134e, 0xbf011522, 0x15871502, 0x1e0e0709, 0x0e1e4748, 0x88150907, 0x13010215, 0x0a0d0605, 0x1e47471e, 0x01131310,
+    0x04231f84, 0x821d0901, 0x2e20830f, 0x01011687, 0x1e101213, 0x0f1e4848, 0x83811513, 0x1312240e, 0x84451e10, 0x212c842d, 0x3b830903, 0x16212b82,
+    0x234c8487, 0x1f0a0d05, 0x6c824c8b, 0x82484721, 0x130b226c, 0x05fb5100, 0x01800125, 0x791d00c0, 0x0121056f, 0x07177323, 0xca482320, 0x09aa5f08,
+    0x66452320, 0x8234200c, 0x5e1720ee, 0x012b0985, 0x180a3650, 0x18202018, 0x5b360a18, 0x346f086f, 0x46902008, 0x50250b52, 0x01010fa0, 0x2004840f,
+    0x05237501, 0x1c121125, 0x180e0d01, 0x820732c8, 0x60012109, 0x0f464383, 0x61a0200b, 0x002c083d, 0xffff0100, 0xff013f00, 0x22004001, 0x2008f342,
+    0x0f504323, 0x82353321, 0x011f33a1, 0x07141516, 0x0c70f701, 0x01c00e0e, 0x700c0e0e, 0x0b820707, 0xc0010f22, 0x082c0b84, 0x060a68ae, 0x38380f07,
+    0x0a06070f, 0x21085b43, 0x0f82370f, 0x680a0526, 0x080a0b07, 0x2305974e, 0xc0010001, 0x37206b83, 0x200a1344, 0x0c0a4335, 0x23070629, 0x17163315,
+    0x84fa0716, 0x0a672346, 0x56900606, 0x24446685, 0x0ce64308, 0x00200c84, 0x240c9356, 0x0034001a, 0x05705300, 0x36483120, 0x27262305, 0x1d480706,
+    0x17162507, 0x013b3627, 0x3b27e383, 0x16173201, 0x8233011d, 0x010f2605, 0x26012f06, 0x191b5f37, 0x0a057f36, 0x0e090940, 0x09090e20, 0x03050a40,
+    0x0b0b7007, 0x40030770, 0x22171f7d, 0x41600af6, 0x602905b8, 0x70070a0a, 0x07700a0a, 0x23a3920a, 0x31171637, 0xf3180284, 0xa987092e, 0x98863720,
+    0x14011d27, 0x012b0607, 0x82058215, 0x013f23a0, 0xa1181736, 0x73921823, 0x1824a118, 0x4f46ce95, 0x00022d05, 0x1a00c001, 0x00003400, 0x31272625,
+    0x5a08b356, 0x214d0547, 0x07372706, 0x23013d26, 0x05822722, 0x41373421, 0x0379064e, 0x82272005, 0x7b75183e, 0x0b20410a, 0xe741a0c2, 0x05ec6f11,
+    0x8706e55a, 0x2726219d, 0x17200183, 0x21063841, 0xa884012b, 0x3f22ae83, 0xa6823601, 0x1b691119, 0x6014e741, 0xd39219fc, 0x2522a38c, 0xdf5a3e00,
+    0xf0bc1806, 0x69132020, 0x07210508, 0x07bf6a06, 0x3716172e, 0x26353736, 0x0e800127, 0xe0fe0909, 0x29075142, 0x0112121b, 0x1b121201, 0x09832001,
+    0x0e09092a, 0x09158868, 0xca2a0e07, 0x28059c4d, 0x131029c9, 0x16020113, 0x20198280, 0x83221960, 0x83398212, 0x40012749, 0x10131301, 0x034ec929,
+    0x2aca2805, 0x1509070e, 0x18021688, 0x200d2fbb, 0x16374a2e, 0x07060325, 0x18012f06, 0x250a47a4, 0x36372627, 0xa418013b, 0x3536184b, 0x080a0901,
+    0x0d0a442d, 0x09170a0c, 0x072d4409, 0x9e0a0503, 0x0056010f, 0xdcfe2a15, 0x0703050a, 0x0909442d, 0x28308217, 0x082c440b, 0x0e01090a, 0x0f3f439f,
+    0x00003524, 0x1c4e2113, 0x012f2608, 0x07060726, 0x66401815, 0x21053108, 0x26272635, 0x1506010f, 0x16011f14, 0x35373637, 0x20084858, 0x0b594720,
+    0x200a6f47, 0x123f48c0, 0x0e090924, 0xe1472001, 0x0a682109, 0x2a052c4e, 0x0a0a0d0d, 0x070f49c0, 0x48680904, 0x0f2007cf, 0x4306cf47, 0x25220a43,
+    0xfb414a00, 0x05ac4c06, 0x3321918b, 0xc7971832, 0x27342b08, 0x33252326, 0x16171617, 0xc3183233, 0x072209d1, 0x58182317, 0x2a82079c, 0x37363526,
+    0xe0013736, 0x2606e24d, 0x0e0d01a0, 0x1908500c, 0x2407b10e, 0x2d2d44a0, 0x32a98202, 0x019fc0fe, 0x04050d01, 0x09500709, 0x0e0c5008, 0x8701010e,
+    0x2038861a, 0x372582c0, 0x011b1b29, 0x05070f28, 0x0b074809, 0x0648070b, 0x280f0702, 0x442d2d02, 0x80202282, 0x02241782, 0x0c074806, 0x09221782,
+    0x17880805, 0x00203586, 0x0029db83, 0x01800220, 0x00250060, 0x73db8237, 0x6a500868, 0x82a88309, 0x521720ca, 0x2b23075a, 0x18360701, 0x2b0e7759,
+    0x0ddd0117, 0x3b3b2b2a, 0x830c2b2b, 0x22052545, 0x832b0c83, 0x0d2a210f, 0x9d200f87, 0x0ff45718, 0x2338a028, 0x24010124, 0xda463823, 0x24382605,
+    0x23010123, 0x200d8624, 0x06621830, 0x052f4912, 0x01c0012f, 0x003b00c0, 0x00510048, 0x3700005f, 0x6f9d8733, 0x2720069f, 0x1520b782, 0x1520ad82,
+    0x26240f83, 0x34272627, 0x5b057143, 0x20820def, 0x27351725, 0x5e343736, 0x162f0620, 0x37361117, 0x07062726, 0x22251716, 0x82063107, 0x211c8541,
+    0xd71857d0, 0x57220fe3, 0xd8182838, 0x0d220a45, 0x0d8d160d, 0x1b1a0524, 0xf5188026, 0x1621092d, 0x05d67a02, 0x0a200124, 0x0a830707, 0x0a070733,
+    0x0d0d15d1, 0x17170101, 0x17162321, 0x160e0d01, 0x2263901f, 0x18130ace, 0x270d72d8, 0x01181826, 0x17018801, 0x40824482, 0xfe011723, 0x2256859f,
+    0x84d10216, 0x4219840f, 0x402606a7, 0x2200c001, 0xe7432700, 0x0733220c, 0x20db8323, 0xefb91a21, 0x21352211, 0xefb91a15, 0xe0e02249, 0x07d74ae0,
+    0x02e03f08, 0x00a00100, 0x00070003, 0x0013000b, 0x17230100, 0x07271737, 0x33072533, 0x33161327, 0x21013f32, 0xf67b0117, 0x6b857b7b, 0x6bfede73,
+    0x8973de6b, 0x05070705, 0xf302fef3, 0x9797a001, 0x00838da0, 0x0558fe25, 0x57fbfb05, 0x0120060f, 0x8b4cd785, 0x2726210d, 0x2309a642, 0x17161716,
+    0x2006934c, 0x0ac3433a, 0x0de9c418, 0x200e9b4c, 0xe4c41810, 0x01f0240c, 0x820b0f0d, 0x000121c0, 0x0743b018, 0x7c822220, 0x23070625, 0x82070611,
+    0x087b5305, 0x11373623, 0x0cfb4b27, 0x0f073e28, 0x17160148, 0xfb427022, 0x0f702205, 0x0c604401, 0x0d2e0129, 0x22f0fe01, 0x42011617, 0x012805ea,
+    0x0110010f, 0x0b0e0d01, 0x4905d84c, 0x02200557, 0x3120df83, 0xa77d6f82, 0x07e64215, 0x0d927218, 0x15249783, 0x1b206001, 0x55064046, 0xe0210966,
+    0x06316502, 0x9d827286, 0x01218083, 0x50cc1800, 0x202e8316, 0x20be8530, 0x8c981830, 0x00003308, 0x00000200, 0x8001c1ff, 0x1b00c001, 0x00002d00,
+    0x3f482617, 0x0b764306, 0x23218582, 0xbb041a22, 0x19a82013, 0x2a0dac51, 0x271f1e02, 0x0e0a1b27, 0x87180a0e, 0x260787b0, 0x37382133, 0x182d3b3b,
+    0x1907a277, 0x2007d451, 0x0f3677f3, 0x10248f82, 0x7001c0ff, 0x26318f82, 0x00005400, 0x31373637, 0x26233736, 0x33373627, 0x82068b35, 0x057849a8,
+    0x17161528, 0x06371716, 0xd5181507, 0x50252ec2, 0x0f01010f, 0x18058b50, 0x200b825f, 0xd4d51898, 0x0f012429, 0x8320010f, 0x83212004, 0x54012004,
+    0xd5180705, 0x03212ee2, 0x27f78700, 0x00260014, 0x0100002b, 0x2109964c, 0x8f543633, 0x52032007, 0x132610fd, 0x33112311, 0x1b6c3001, 0x42088808,
+    0xf24106ab, 0xe0702205, 0x15f76be0, 0x8d18fe20, 0x01250c08, 0x01c0fea0, 0x0a834140, 0x1f001422, 0x4d0c6744, 0x03220920, 0x8e410706, 0x17162305,
+    0xff514001, 0x0d012e0f, 0x0150140e, 0x020d410f, 0x0f400f01, 0x15b66901, 0x1041fe2a, 0x0f0f0101, 0x000d0201, 0xff8b0082, 0x24001f22, 0x372075a1,
+    0x1120f782, 0x40207aa0, 0x4418f884, 0x988308da, 0x8905196e, 0x013f267d, 0x00c0fe40, 0x34838207, 0x01400200, 0x00140080, 0x0032002a, 0x0041003a,
+    0x005a0048, 0x06cb4e00, 0x2909ec69, 0x27263533, 0x31171625, 0x75591716, 0x8236200a, 0x01212726, 0x26312726, 0x07191527, 0xd96517ce, 0x01fc3410,
+    0x02121013, 0x02021204, 0x01133012, 0x0f041301, 0x19040101, 0x272de107, 0x01201f30, 0x301f2001, 0xf0200787, 0x44224783, 0x53831301, 0x3001132a,
+    0x01901004, 0xff1b1212, 0x20088260, 0x44098401, 0x40210546, 0x221b83c0, 0x6040c040, 0x402109a5, 0x834c8b10, 0x09c34954, 0xc0017f33, 0x2d001000,
+    0x27250000, 0x06010f26, 0x1716011f, 0x24f58232, 0x05070627, 0x18fe8327, 0x08080efc, 0x01070635, 0x07222326, 0x16011706, 0x01273637, 0x160f2b0f,
+    0x1704166c, 0x49501807, 0x14593b48, 0xa0680117, 0x011b1c31, 0x18651602, 0x11082e0c, 0xfe1b1235, 0x180807a5, 0x390955d8, 0x08113650, 0x65180c2e,
+    0x1a1b0117, 0x0b0e452f, 0x493c7d65, 0x0718524a, 0x47820417, 0x252c0f28, 0x05100120, 0xd8181309, 0xdb4f0942, 0x0014240a, 0x42350026, 0xa96c163b,
+    0x359e6c20, 0x6b15dc42, 0x936c105f, 0x33a2820d, 0xe1ff0000, 0x9f010002, 0x00002200, 0x17363713, 0x32151716, 0x16230482, 0x82070617, 0x26272501,
+    0x26273637, 0x3909e84f, 0x0db00837, 0x51010d0d, 0x26264141, 0x18180101, 0x0a090c22, 0x2e2f2103, 0x16820175, 0x0808b033, 0x0a970201, 0x50100606,
+    0x28280f0f, 0x2a292f4b, 0x3d448218, 0x27286b0c, 0x06061058, 0x0b08970a, 0x0000070b, 0x0f000200, 0xf001c3ff, 0x1d00c001, 0xd9182800, 0x11231f6d,
+    0x83313736, 0x27352302, 0xd9180111, 0x442a1a78, 0x100f2726, 0x03c001b0, 0xd9180750, 0xfe2a167e, 0x36362343, 0x4a2e3a39, 0x838286fe, 0xf7820320,
+    0xc001c122, 0xe7448382, 0x51212007, 0xe744127e, 0x21372411, 0x18112111, 0x18151ccb, 0x240c717b, 0x01c0fea0, 0x09eb4440, 0x01011125, 0x531b1112,
+    0xeb440507, 0x0160250d, 0x00c0fe40, 0x86055349, 0x23eb448f, 0x82478020, 0xf9581809, 0x01602a09, 0x020d610f, 0x10600d02, 0x16664501, 0x210ceb44,
+    0x00820001, 0x01400226, 0x00270080, 0x20061154, 0x087e6421, 0xc0570888, 0x66362005, 0x2726059b, 0x12010035, 0x50651b12, 0x08735205, 0xfe251182,
+    0x12121b40, 0x84118801, 0x1829830d, 0x8d0d5fcf, 0x08d34311, 0x01ff0127, 0x001100c0, 0xb31a1924, 0x7883820f, 0x0720052d, 0x07646618, 0x27263526,
+    0x00012726, 0x87072966, 0xbf5f2107, 0x2a05c84c, 0x0ec1010d, 0x2d010908, 0x66a0452d, 0x9f4808be, 0x4c202006, 0x092206a9, 0x2b830e09, 0x200d675c,
+    0x63ce1815, 0x64052019, 0x6b5e19b3, 0x0c556608, 0xb464ef20, 0x00022148, 0x25072766, 0x0035001b, 0xe54f3700, 0x011f2709, 0x3f323316, 0x05821701,
+    0x3105764c, 0x37363337, 0x37012f36, 0x2f343536, 0x22232601, 0x0d5d010f, 0x17162905, 0x081588d7, 0x4e1e0d06, 0x3005134f, 0x0a1e4e0a, 0x1306060d,
+    0x51170201, 0x07091588, 0x4f188a0e, 0xb03705fc, 0x10131301, 0x0c0a4e1e, 0x09170a0d, 0x091e4e09, 0x88150902, 0x8e200216, 0x070e2616, 0x17871509,
+    0x0ab34e02, 0x36001c22, 0x2622a382, 0x7c843123, 0x21055d76, 0x978b1716, 0xc0920120, 0xd023be85, 0x890c0d0a, 0x8916209a, 0x17012199, 0x0823be82,
+    0x884f1f0e, 0x131022be, 0x20bc8214, 0x829a87a7, 0x21998a83, 0xa6911901, 0x02214d82, 0x57501800, 0x0024220c, 0x18a98439, 0x8307d254, 0x343524a3,
+    0x4725012f, 0x37201019, 0x82074d41, 0x1707302a, 0x3f363736, 0x3a353601, 0x0811100a, 0x822f0607, 0x08072c06, 0xb6012e07, 0x01171622, 0x18161701,
+    0x3b089271, 0x16170d90, 0xca121620, 0x43243845, 0x4f2c5338, 0x331bcb44, 0x0b0b010d, 0x40090a09, 0x2d200787, 0x330f784e, 0x201215fd, 0x32930d1c,
+    0x4e382c3f, 0x31211034, 0x00211693, 0x03200082, 0x33080342, 0x007c0065, 0x25000091, 0x36313734, 0x1732013b, 0x35343534, 0x3305ad52, 0x23222322,
+    0x07141516, 0x27220706, 0x35342726, 0x27343536, 0x1624b083, 0x32373233, 0x27074d4f, 0x27222327, 0x15141530, 0x82054062, 0x26332d16, 0x36373435,
+    0x14171633, 0x14151407, 0x3723dc83, 0x65222326, 0x35200583, 0x31223f82, 0x02820706, 0x4b05d84e, 0x15200685, 0x0b0c7718, 0x7a543520, 0x26fb8205,
+    0x0b0a09ae, 0x53181903, 0x022a05b0, 0x06010102, 0x050e0201, 0x08820505, 0x3a3a5531, 0x0a17160e, 0x05010204, 0x0a090506, 0x8718040a, 0x02012126,
+    0x0d232684, 0x85060103, 0x820b2024, 0x06033924, 0x1401c007, 0x10191a14, 0x2409010f, 0x09081111, 0x0304090c, 0x230901a0, 0x0a320b82, 0x0403090c,
+    0x19141402, 0x020e1119, 0x02030caf, 0x44820206, 0x3a39483a, 0x18012222, 0x0d090918, 0x08040402, 0x0a040201, 0x3a0e1617, 0x0106543b, 0x0c210e82,
+    0x225f8203, 0x87020301, 0x09082825, 0x020e010e, 0x83090401, 0x3a220823, 0x03010655, 0x0f900a03, 0x15141a19, 0x0a0f0101, 0x14141304, 0x0101140f,
+    0xa2040606, 0x14120509, 0x0c821014, 0x04060527, 0x15191a0f, 0x23208215, 0x08000000, 0x3d088f41, 0x00120007, 0x0025001a, 0x003a0032, 0x004f0047,
+    0x06271300, 0x36331607, 0x37011f37, 0x675e2726, 0x34372105, 0x17381382, 0x06073736, 0x06272207, 0x37171615, 0x07271727, 0x33161716, 0x35263732,
+    0x36272a83, 0x06232637, 0x82073707, 0x17322924, 0x27343536, 0x14032726, 0x37820c82, 0x55952f08, 0x16140f2b, 0x3d2e2b3a, 0x0b6346a9, 0x2b02070c,
+    0x3043060d, 0x24012454, 0x17184834, 0xa93e0201, 0xa93e923d, 0x312b2c21, 0x02060b0b, 0x2e862d2c, 0x3da95522, 0x11261f84, 0x06901e11, 0x2f823142,
+    0x15012908, 0x06423154, 0x3d012401, 0x01023ea9, 0x34481817, 0x0f14167c, 0x3a2b552b, 0x06022b93, 0x46630b0b, 0x3d913da9, 0x11111ea9, 0x01201c84,
+    0xfe232d85, 0x832c3ea9, 0x2b31251d, 0x87fe212c, 0x1b513086, 0x55022005, 0x2c2405e7, 0x50003e00, 0x821c5176, 0x0e255ff5, 0xd0583720, 0x4c152010,
+    0x4b57104b, 0x0c4c4c19, 0xe0586020, 0x550b8b0b, 0xd0201973, 0x6f0bde58, 0xa0200c02, 0x200e085f, 0x08e74105, 0x5600352b, 0x73005e00, 0x00008800,
+    0x05786e37, 0x07143331, 0x33352633, 0x26013f36, 0x34372327, 0x82353035, 0xb3a61807, 0x036c1807, 0x332e820b, 0x05011f14, 0x37273307, 0x34013d36,
+    0x1d22012b, 0x36352301, 0x07230782, 0x85352315, 0x1f14260f, 0x16373602, 0x210f8217, 0x47832707, 0x1507062f, 0x011d0607, 0x36331716, 0x27343537,
+    0x2a149321, 0x010f0a4a, 0x10100d02, 0x820f1080, 0x0d022608, 0x0e02220a, 0x055b7939, 0x11820120, 0x393b0985, 0x2201020e, 0x7e030a01, 0x070b1903,
+    0x0119061a, 0x01053606, 0x061a0619, 0x832c190b, 0x89203125, 0xa00f0117, 0x0917010f, 0x0fe00f01, 0x00010901, 0x80200f82, 0xc0200f85, 0xf0220f82,
+    0x48820f01, 0x3f3f4123, 0x23088441, 0x0103025a, 0x8906604e, 0x01203069, 0x5a03030f, 0x1552525e, 0x063b0e0a, 0x851a1a06, 0x0e3b2c03, 0x0f02150a,
+    0x200f0101, 0x850c9c20, 0x040c232d, 0x1183160a, 0x040a1622, 0x00211191, 0x05474600, 0x0140012d, 0x000e00c0, 0x2500003d, 0x52070623, 0x262e0849,
+    0x17142527, 0x15171631, 0x37363533, 0xa4683536, 0x06c85d05, 0x5d532620, 0x05346305, 0x2606b44a, 0xe0100107, 0x820d0e14, 0x20013f7f, 0x0d01010f,
+    0xf8fe140e, 0xc01a0f0f, 0x010f0f1a, 0x0402641a, 0x020c0203, 0x27206c02, 0xbc630217, 0x17022806, 0x111a1a1b, 0x76000110, 0xa02e0b7c, 0x08131426,
+    0x13082b2b, 0x37302614, 0x33820265, 0x02040327, 0x07213b6c, 0x056b4218, 0x07182208, 0x2c272617, 0x0000262b, 0xff000006, 0x01c001e0, 0x000400a0,
+    0x003e0019, 0x00480043, 0x3700004d, 0x20b08223, 0x13564a37, 0x19821520, 0x35230385, 0x84231523, 0x35332303, 0x03843523, 0x33203382, 0x07200384,
+    0x23210582, 0x831c8237, 0x1523250e, 0xc04040c0, 0x2013f349, 0x82009040, 0x20138429, 0x233182e0, 0x1b121201, 0x8020358f, 0x40203190, 0x874a1288,
+    0x000e250a, 0x25000040, 0x6b71be83, 0x27342405, 0x82132726, 0x373227a4, 0x27263536, 0x7c192b26, 0x072508a5, 0x07222315, 0x22248206, 0x84013b16,
+    0x1407240a, 0x8521011f, 0x01233f25, 0x14e1fe6f, 0x0f010e0e, 0x010f6001, 0x31150e0e, 0x090e10a0, 0x09090109, 0x090a100d, 0x0a820d0e, 0x0a0d1022,
+    0xa0210f85, 0x3908820b, 0x2c014901, 0x0a010149, 0x01000b0a, 0x10140d0d, 0x140f0101, 0x01010d0e, 0xa0433020, 0x3a121a05, 0x08302c0d, 0x05050f09,
+    0x0505d6d6, 0x4708090f, 0x012c05e3, 0x00a00180, 0x00300027, 0x3700003f, 0x2f061857, 0x3f36013f, 0x0f061501, 0x06070601, 0x3521011d, 0x2720be82,
+    0x43059b43, 0x407f056a, 0x42212009, 0x13210c76, 0x080e8229, 0x0e0c0621, 0x0a030905, 0x391a0116, 0x010c0c14, 0x36360240, 0x010b9452, 0x07090e02,
+    0x12211201, 0x83120202, 0x1c012603, 0x0d14dffe, 0x83ae820d, 0x0d0124e8, 0x82af140e, 0x05200816, 0x0b1e0f06, 0x1d320b05, 0x130a1d0e, 0xc00e1813,
+    0x02373651, 0x04040b01, 0x0a07091c, 0x91091589, 0x12233c85, 0x8bc0fe02, 0x0a0f43ed, 0x2500a024, 0xc9823400, 0x0706232c, 0x011f1615, 0x33071615,
+    0x19703726, 0x43232006, 0x2621050d, 0x06ee5727, 0x24062b4b, 0x36211716, 0x22e28337, 0x820f1969, 0x0310268f, 0x031bb01b, 0x300a8310, 0x0e0d1619,
+    0x2d1d1e01, 0x011d1c2d, 0xa7160d0e, 0x43b186e1, 0x22080625, 0x200f01e0, 0x0601010e, 0x43373743, 0x200d0206, 0x170e0110, 0x1e2c1c17, 0x1d01011d,
+    0x171c2c1e, 0x8ce00e17, 0x000321a5, 0x28052b63, 0x001100c0, 0x005a0020, 0x54701800, 0x41132011, 0x4f490d50, 0x94411805, 0x05ef4408, 0x4105d653,
+    0x07200793, 0x2105c548, 0x5c182726, 0x2128075d, 0x34353637, 0x18000135, 0x1034c284, 0x10101818, 0x10100101, 0xe0fe8f18, 0x010d0e14, 0x60010e03,
+    0x3708db82, 0x70150d0e, 0x04041c07, 0x0805060a, 0x0d160f08, 0x270a030d, 0x0d04030a, 0x0d11120d, 0x0a02040d, 0x0b010d27, 0x080f1a0b, 0x0a060508,
+    0x061d0404, 0x30016602, 0x50010166, 0x0f6ade18, 0x8bb0fe21, 0xfb3008e2, 0x02100508, 0x05060801, 0x0f0f0106, 0x01010c14, 0x0b0a1109, 0x09110a0b,
+    0x100c0101, 0x05011111, 0x01080606, 0x08051002, 0xd3d30404, 0x01010303, 0x260a8342, 0x002e0022, 0x7100003d, 0x901806db, 0x17210da0, 0x20e68214,
+    0x26f28221, 0x26353735, 0x19230327, 0x2009172d, 0x0d304117, 0x38700128, 0x0130010f, 0x0584500f, 0x402d0b82, 0x01080302, 0x0203081a, 0x900f0140,
+    0x05134340, 0x7a427020, 0xa001240f, 0x6f300f01, 0x058405be, 0x2420b026, 0x30302626, 0x20258382, 0xfe010fb0, 0x062a63e0, 0x41804021, 0xbb840cce,
+    0x8002e032, 0x1500a001, 0x48003200, 0x23130000, 0x22150706, 0x2906565c, 0x33171617, 0x26113736, 0x15832527, 0xbb412320, 0x84112005, 0x33352114,
+    0x8205c475, 0x8c17201c, 0x06a56917, 0x30682326, 0x090e0216, 0x0d230082, 0x82160201, 0x1602230b, 0x06826001, 0x0c868020, 0x98200a8a, 0x30841289,
+    0x60010e25, 0x85681602, 0x166822e7, 0x27388202, 0x40021610, 0xa8a81602, 0xfe210c83, 0x85058370, 0x9001240b, 0x84c00216, 0xf0fe2122, 0x34861583,
+    0x0000003a, 0xff100006, 0x01f001d0, 0x000d00b0, 0x002c001d, 0x004a003b, 0x37000059, 0x2c050a4b, 0x37323316, 0x25150627, 0x27262726, 0x82bd8222,
+    0x17072505, 0x17053536, 0x2205df4a, 0x83070627, 0x06172f01, 0x012f2207, 0x37363526, 0x16011f32, 0x0e8d3715, 0x16862720, 0x10371586, 0x0a020c02,
+    0x3d1f1e0b, 0x01bc100e, 0x0c02e001, 0x0a011c08, 0x83291d1c, 0x2bfe280e, 0x2e2e47ec, 0x86091919, 0x02e52806, 0x4005060e, 0x830f0105, 0x85302005,
+    0x8c05850c, 0x456e350c, 0x0c0c0a26, 0xbc010908, 0x46a30f10, 0x01081c26, 0x01050503, 0x0e290d82, 0x2713ec4a, 0x242d2c26, 0x2e0684ed, 0x010f5625,
+    0x08043f05, 0x4005020e, 0x85300506, 0x8205820c, 0x8370200c, 0x06052106, 0x03220583, 0x00820008, 0x00052008, 0x01c3ff00, 0x00c00180, 0x002a0017,
+    0x004c003b, 0x3700005d, 0x16311714, 0x16171633, 0x4233011d, 0x372c0596, 0x23013d36, 0x07061315, 0x14070631, 0x26050542, 0x27263536, 0x4e072726,
+    0x342c057e, 0x06171627, 0x26230607, 0x27261727, 0x07821285, 0x82141721, 0x86372012, 0x83352010, 0x20108323, 0x05c94160, 0x0806b842, 0x5260c023,
+    0x17023636, 0x26da2616, 0x36021716, 0x060d5236, 0x09090d07, 0x02110301, 0x0d090901, 0x152d0815, 0x22118508, 0x83110201, 0x143f2911, 0x0e070609,
+    0x12030909, 0x0e2a0d82, 0x09080e31, 0x0d090801, 0x34823030, 0x10352f82, 0x028f0110, 0x31533637, 0x1b1b2929, 0x53312929, 0xcd023736, 0x23188203,
+    0x15080607, 0x01242282, 0x12016212, 0x3b820f87, 0x0d873f20, 0x82150721, 0x00002353, 0x00820002, 0x01000227, 0x00110080, 0x07115125, 0xf1821620,
+    0x2607e35b, 0x31272217, 0x83152726, 0x37362412, 0x82353736, 0x00232917, 0x6d484803, 0x0348486d, 0xff240787, 0x2c44444b, 0x2c230c87, 0x194d4444,
+    0x82098a9c, 0x01012196, 0x8f249a82, 0x6e1f0f0f, 0x6e230c87, 0x4e0f0f1f, 0x11250b9f, 0x50003800, 0xd79a1800, 0x2734240e, 0x6e012f26, 0x3727087c,
+    0x15323332, 0x82010f14, 0x3231257f, 0x16331617, 0x2b06ad6e, 0x22012f36, 0x0f222527, 0x23262701, 0x0981de18, 0x0805296d, 0xef01234a, 0x01161622,
+    0x21171601, 0x01161721, 0xfc231616, 0x252c2c19, 0x0a0e0e10, 0x0601013c, 0x03055f01, 0x12110103, 0x3b3b351c, 0x11111d20, 0x56010707, 0x6c010d01,
+    0x1ee00a0a, 0x05090805, 0x0d325716, 0x0ce11c03, 0x610f0909, 0x080bba4e, 0x17172138, 0x08018701, 0x1a0d1b08, 0x0616201a, 0x18700202, 0x01010f10,
+    0x16070801, 0x1b232319, 0x016d011b, 0x25af07d8, 0x6d2f0906, 0x050c030b, 0x0aaf2405, 0x0a090d0f, 0x5f4b0100, 0x00042f08, 0x11211300, 0x02001121,
+    0x0100fe00, 0x0782fec0, 0x2a0af74e, 0x001800c1, 0x00450033, 0x4d162500, 0x2623061e, 0x47072227, 0x072205ca, 0xf8823617, 0x0627072a, 0x011f1615,
+    0x14150607, 0x240b1651, 0x3f262726, 0x10d04f01, 0x2ba0012e, 0x191a1520, 0x2d453031, 0x37222b2b, 0x013ea882, 0x1e1e10e7, 0x14ee7e26, 0x5c242201,
+    0x0a22090b, 0x510a0e0c, 0x07302524, 0x01011007, 0xa5417d03, 0x283b0807, 0x01011b1c, 0xa1291b1b, 0x312e1801, 0x20323135, 0x11120121, 0x01023722,
+    0x20e60201, 0x69011314, 0x2f2222ee, 0x0a522523, 0x220a0d0d, 0x245d0b09, 0x231c0124, 0x01480c0c, 0x87291a1b, 0x1b28223b, 0x20f6821b, 0xeb4f1800,
+    0x00c02f08, 0x0025000e, 0x004f003c, 0x00720063, 0xc8471300, 0x05784407, 0x3621ee82, 0x26ec8227, 0x22232623, 0x82171607, 0x24058401, 0x01393427,
+    0x070d7a34, 0x12820620, 0x3f2c2d84, 0x31171601, 0x07140716, 0x36373231, 0x20061850, 0x82fd8803, 0x06372313, 0x4d822623, 0x31830720, 0xd0080e89,
+    0x3e2a15c8, 0x08012525, 0x24242418, 0x02b61725, 0x45161602, 0x07060202, 0x162f292e, 0x01070616, 0x291d1c0c, 0x1004058e, 0x25252616, 0x28181224,
+    0x1d1e1d11, 0x36570f1d, 0x02011212, 0x0201342d, 0x47513333, 0x1918170d, 0x48313015, 0x0a1d3b31, 0x293c2c32, 0x17671029, 0x344c3e0c, 0x27232e2d,
+    0x35354d22, 0x27560119, 0x3b3c2126, 0x441e204b, 0x18182c2b, 0x180eaf09, 0x4241422d, 0x2f2e0f01, 0x1126252f, 0x050b0b07, 0x1d0f0122, 0x1908251e,
+    0x4e313119, 0x2a3f2230, 0x0818182b, 0x3e3e41ed, 0x1010172d, 0x03040202, 0x19424259, 0x1306f7fe, 0x16122113, 0x2b120216, 0x0f010e36, 0x27680a0e,
+    0x13012736, 0x02082213, 0x00141718, 0x00070000, 0x068f7600, 0x4f00463b, 0x61005800, 0x73006a00, 0x00007c00, 0x31072201, 0x06011d06, 0x35272607,
+    0x058a5f34, 0x15210d9b, 0x2a238511, 0x011f1407, 0x36331716, 0x84373637, 0x26012836, 0x16373627, 0x18070617, 0x20081449, 0x88119035, 0x8737201a,
+    0xc001261a, 0x0109090e, 0x08015e0f, 0x3c360992, 0x0c10100c, 0x710c010b, 0x4b26523b, 0x09023231, 0x00ff0e09, 0x3483010f, 0x6d05b85a, 0x108f05b1,
+    0x22872020, 0x01210888, 0x203a8260, 0x18168370, 0x180b4469, 0x2f125c69, 0x0c3be9fe, 0x10110c0b, 0x013a710c, 0x4b313202, 0xfe212283, 0x4d7085c0,
+    0x0c8306e5, 0x11906020, 0x9f184020, 0x002510a7, 0x00000700, 0x05db6100, 0x11000c2c, 0x23001a00, 0x35002c00, 0x635e4200, 0x1123260c, 0x21112103,
+    0xf0551811, 0x61362009, 0x07200607, 0x08025618, 0x23081961, 0x26231133, 0x2505ce69, 0xe0013736, 0x745e1b60, 0x20602506, 0x000100ff, 0x08fa5b18,
+    0xf3606020, 0x22089107, 0x8860d0fe, 0x60012535, 0x1b121201, 0x2005aa55, 0x82e28240, 0x60e82003, 0x5c1807d4, 0x0891080b, 0x2a82e820, 0xde823787,
+    0x39051b49, 0xa001c001, 0x0d000600, 0x00001b00, 0x33373613, 0x17372315, 0x1f163335, 0x42192301, 0x332c0d19, 0xd0721d0e, 0x1d72bd33, 0xd0d0330e,
+    0x2c0a824d, 0x1a8501c0, 0x65658001, 0x651a0180, 0x080b5bff, 0x44e0e021, 0x402808ef, 0x1d00c001, 0x57003a00, 0x2409a16b, 0x36331716, 0x20648237,
+    0x05c86a17, 0x1a410720, 0x49072005, 0x17900570, 0x82373621, 0x074a7f96, 0xc3573320, 0x094f4108, 0x01a03330, 0x30140e0d, 0x0f200f01, 0x0e143001,
+    0x0e83010d, 0x0883a020, 0x13924020, 0x19992b85, 0x38839020, 0x010f5025, 0x83500f01, 0x08ca6f2a, 0x93f08021, 0x832c9714, 0x08634117, 0x0100022c,
+    0x002000c0, 0x00420025, 0x34190100, 0x4b18102a, 0x262c0a97, 0x25272627, 0x35231533, 0x23070613, 0x20051c6c, 0x20e78235, 0x78121935, 0xd001210d,
+    0xe1849984, 0x09116518, 0xb1830e84, 0xa0e0fe2d, 0x0f01c0a0, 0x340d0236, 0x8337010f, 0x013526c8, 0x010e340f, 0x200a8238, 0x081f4160, 0x2a853020,
+    0x270d636b, 0xfe303030, 0x36010ff6, 0x3f863487, 0x3f823620, 0x2008bf4d, 0x27cb8280, 0x00260012, 0x07261300, 0x1805594e, 0x23097c97, 0x31272603,
+    0x3723c382, 0x18363736, 0x0808964f, 0x0b0bcb4d, 0x01323151, 0x56343501, 0x01353456, 0x51313201, 0x1a1a2b0b, 0x0e0e0201, 0x3a0c0c3a, 0x01020e0e,
+    0x012b1a1a, 0x4e0808bc, 0x5f3d5455, 0x01013434, 0x3d5f3434, 0xfe4e5455, 0x19190154, 0x22220929, 0x420a0a42, 0x29092222, 0x41011919, 0x3f220953,
+    0x8582a001, 0x3e003229, 0x27250000, 0x82222726, 0x207a828c, 0x48928327, 0x272508cd, 0x1f161530, 0x054c5d01, 0x25273624, 0x0a623523, 0x27172308,
+    0x0c823726, 0x1e823320, 0x2b020730, 0x223a2483, 0x030c1e1f, 0x2f2e201f, 0xf55d1f20, 0x062b0809, 0x39258308, 0x08271e23, 0x74fe1b08, 0x0e0d015f,
+    0x0d0e1414, 0x0b42c301, 0x0d110403, 0x41101a0f, 0x30bb9452, 0x21151501, 0x831e1e2e, 0xe12f2235, 0x06345e30, 0x0c019523, 0x241a830c, 0x292d2c1d,
+    0x3948182c, 0x2d702b08, 0x1514115e, 0x1501090c, 0x376d3a5d, 0x0044230f, 0x376d0100, 0x26f3822f, 0x31220734, 0x82012f22, 0x011f26cd, 0x16173637,
+    0x2a416d07, 0x07585b32, 0x0901010a, 0x0d0f3807, 0x48251210, 0x0c10130f, 0x3229496d, 0x010870c7, 0x30060101, 0x0d0f1210, 0x0c105c1f, 0x8200130f,
+    0x00063400, 0x01c0ff00, 0x00c00180, 0x0026001d, 0x0041002f, 0x9f57004c, 0x460320d9, 0x7b460757, 0x11525508, 0x15f0dd18, 0xf020ec9d, 0x45074e45,
+    0x52550856, 0x1b4a180b, 0x20ff9d14, 0xb26718fe, 0x7b611808, 0x55e82008, 0x6e460b64, 0x08654609, 0x47000021, 0x022905c3, 0x00c0013f, 0x001a0008,
+    0x06c54723, 0x0000772c, 0x34373625, 0x16070627, 0x14682717, 0x4f621810, 0x052f6808, 0x35331523, 0x05136916, 0x27363722, 0x8205e642, 0x34352205,
+    0x05f84237, 0x8305c067, 0x83062005, 0x25372625, 0x07061716, 0x20558226, 0x08088727, 0x06210520, 0x17161507, 0x013f3621, 0xcf012726, 0x0e0f010e,
+    0xb00d0201, 0x01181925, 0x26181801, 0x07821826, 0x25181922, 0x012e1882, 0x01010f0e, 0x1b01040f, 0x2ddf2d1b, 0x0e821b1b, 0x0f183208, 0x1003030b,
+    0x1b0e3004, 0x010e0d14, 0x282d463b, 0x0d012328, 0x0c11140e, 0x0310031c, 0x130c0b03, 0x03011113, 0x15020116, 0x15020215, 0x0102155f, 0x23088316,
+    0xe1fd3f01, 0x02236483, 0x82010e1f, 0x08894751, 0x19015022, 0x0d5c5419, 0x7f475020, 0x01773407, 0x6b111010, 0x1010116b, 0x11140901, 0x050c1313,
+    0x8301151a, 0x05052d69, 0x090a0115, 0x0d0d140e, 0x03100a01, 0x77836f83, 0xf3461f20, 0x088c4107, 0x0f01d823, 0x82bd8310, 0xcb441804, 0x003d2a0c,
+    0x004a0043, 0x17000051, 0x05fb4814, 0x17162123, 0x20098216, 0x054a4135, 0x23210c83, 0x06704c36, 0x23273427, 0x07060706, 0x221a8321, 0x83150623,
+    0x5a16201b, 0x133c0623, 0x06332726, 0x07063707, 0x05272623, 0x33373601, 0x00211716, 0x020e2010, 0x38010301, 0x0d350482, 0x19021021, 0x201b4418,
+    0x01020608, 0x552f1f7f, 0x11112c2d, 0x08208502, 0x03c8fe49, 0x200e0201, 0x0e0d0210, 0x3f402122, 0x0d0e2222, 0x1a26e002, 0x83261a80, 0x0cdd0c09,
+    0xfe070109, 0xdb0c09fa, 0xfafe090d, 0x0102102e, 0x0b0b070d, 0x02010d07, 0x3a3a1e10, 0x0611133e, 0x1b010106, 0x34352c18, 0x8b192e2f, 0x28163a1d,
+    0x2b2f2e28, 0x282e2f2b, 0x12011628, 0x15171715, 0x100f107c, 0xc1fe0110, 0x47008210, 0x3f3f0883, 0x1000c001, 0x4a003800, 0x16250000, 0x2f363717,
+    0x010f2601, 0x07270717, 0x05011f06, 0x82312726, 0x2726220d, 0x79f18203, 0x13220aa8, 0x144e0706, 0x823f2006, 0x273622ea, 0x11d35805, 0x171b263f,
+    0x3c040ea1, 0x213d0e06, 0x0d3e213d, 0x18013503, 0x0d0b0c04, 0x5c2e1bcb, 0x15101107, 0x056d4349, 0x235c4932, 0x1b1b0102, 0x1b1b2829, 0x050dca02,
+    0xc2fe0406, 0x3d0b8643, 0x351107aa, 0x0db50f06, 0x14631503, 0x0e061463, 0x060d20a0, 0x22430405, 0x14140103, 0x5d430c0c, 0xebfe2305, 0xb54c301b,
+    0x281a2305, 0x62820444, 0x17838a20, 0x09090827, 0x090e0e08, 0x55e68209, 0x022105e3, 0x26e78280, 0x00540019, 0x18213700, 0x2508f570, 0x07271523,
+    0x16462335, 0x21052208, 0x20e78211, 0x09a37a27, 0x11171627, 0x3b161714, 0x05ea4101, 0x34223683, 0x0c8c3327, 0x35281382, 0x23262734, 0x144001f0,
+    0x22065d48, 0x45303070, 0x012a08d4, 0x0120fe70, 0x211b1212, 0x0082090d, 0x0f110d23, 0x219c8201, 0x2d460343, 0xc6032107, 0x43200a89, 0x8020f885,
+    0xc0201b83, 0x80224b83, 0x0c892020, 0x40014022, 0x8206c36e, 0x0f012326, 0x0682b1fe, 0x26190920, 0x082008c3, 0x7e850082, 0x09140d27, 0x0a090107,
+    0x226f820e, 0x45000300, 0x0329076f, 0x37001a00, 0x15010000, 0x48ef8733, 0x23290a58, 0x35262722, 0x07061517, 0x06554827, 0x5a740720, 0x36352605,
+    0x17163337, 0x18038215, 0x2b17afba, 0x320d0140, 0x0d240d01, 0x010d3201, 0xc0210a8b, 0x26e31880, 0x82ae2015, 0x3201222a, 0x212b820e, 0x378c0133,
+    0x87570020, 0x0003220a, 0x26a98c3b, 0x07062315, 0x18171615, 0x6609debd, 0x22220512, 0x556f012f, 0x82232005, 0x1716221c, 0xfee31821, 0x40013909,
+    0xb0208080, 0x010d0e14, 0x01010f30, 0x040a800f, 0x09053212, 0x461c0509, 0x50200e83, 0x042b0e83, 0x1c040a0a, 0x0e0d0146, 0x83200114, 0x0e7f2428,
+    0x8801090a, 0x01b02db5, 0x010f200f, 0x08632309, 0x0f013708, 0x09230984, 0x49903709, 0x3023080e, 0x6b0e0909, 0x4028098f, 0x0c00a001, 0x2e001100,
+    0x1320b783, 0x2006cb4b, 0x05984a11, 0x11211123, 0x4aba8217, 0x362407bc, 0x27263537, 0x84064954, 0x232522d6, 0x09646811, 0x6a204021, 0x402a086f,
+    0xc0fe4001, 0x350f0130, 0xa7490f01, 0x84362007, 0x8236200a, 0x895020c2, 0xa0012227, 0x054566fe, 0x121b4024, 0x0b820112, 0x49fac021, 0x2e8906a1,
+    0x0a830f20, 0x278bfa20, 0x0220bb83, 0x21088f50, 0xfa18001a, 0x06241eb3, 0x35272607, 0x08377118, 0x1806965a, 0x221c6369, 0x19160270, 0x20105d1a,
+    0x170074c0, 0x1998fe21, 0x8a0a561a, 0x6e00200a, 0x23080597, 0xc0014002, 0x35001400, 0x56004700, 0x33010000, 0x3d363732, 0x26273401, 0x0722012b,
+    0x14011d06, 0x25331617, 0x06209c83, 0x6906294c, 0x346909be, 0x16072109, 0x0fc7f518, 0x18231721, 0x200ee953, 0x057d4340, 0x012b0686, 0x0d019010,
+    0x1460140e, 0x41010d0e, 0xe02009f7, 0x18070142, 0x4d087af8, 0xc02008aa, 0x4c05775b, 0x0f210510, 0x12af1801, 0x2051830a, 0x0e594b40, 0x76088e4b,
+    0x53180583, 0xe0201048, 0x8206045a, 0x010f3682, 0x00030000, 0x01e0ff00, 0x00c001e0, 0x002e0011, 0x01000043, 0x2aec8515, 0x36373611, 0x17162137,
+    0x42071716, 0x73420d57, 0x3505210d, 0x36432783, 0x07062505, 0x06150706, 0x01222e82, 0x631960e0, 0x202009d2, 0x6021d983, 0x8b1e1901, 0x80fe2b14,
+    0x33222201, 0x020216f0, 0x887cf016, 0xf0302208, 0x093d4360, 0x78220983, 0x1e190107, 0x4c840ec2, 0x6c7c6020, 0x087e7c08, 0x2f08fb53, 0x1c008000,
+    0x26002100, 0x36250000, 0x27263537, 0x20058548, 0xed4c1833, 0x3523230c, 0x03820533, 0x83331521, 0x70022704, 0x0f01010f, 0x0583a0fd, 0x83303021,
+    0x60022105, 0xfe260b85, 0xe0a0a0b0, 0xb84da0a0, 0x71a81805, 0x200a850a, 0x7d008340, 0x13280ceb, 0x2d001f00, 0x00003c00, 0x4c05c74e, 0x85820813,
+    0x17272622, 0x180a0a4c, 0x2e070b67, 0x36371617, 0x2637012f, 0x07263127, 0x82011f06, 0x2627230d, 0xd04b7027, 0x18078807, 0x2e088167, 0x2206078c,
+    0x2c2a0404, 0x06313939, 0x86e6d305, 0x05073a07, 0x2a040322, 0x2001a001, 0x30df2f1f, 0x01011f1f, 0xdf2f201f, 0x01201f2f, 0x083146e0, 0x051e7037,
+    0x38393106, 0x03042b2c, 0xd3070522, 0x04042a13, 0xd2070622, 0x22148206, 0x45002c39, 0x80260627, 0x2100c001, 0xbf822e00, 0x2005d541, 0x48068d15,
+    0x372605c0, 0x21113736, 0x56412515, 0x36212c05, 0x27263537, 0x010f7020, 0x8b700f01, 0x082d5005, 0x01c0fe29, 0x16b0fe48, 0x7e160202, 0x00250662,
+    0x010f0f01, 0x44048840, 0x0123089c, 0x58c04040, 0x002009b5, 0x2006cf41, 0x26938301, 0x002a000d, 0x77000037, 0xd94405ad, 0x11212105, 0x33208782,
+    0x20094b46, 0x0dbd4e15, 0x9e8c0120, 0x78828c8a, 0x0f013022, 0x0d6d9318, 0xbd823020, 0xa38b0820, 0x25085350, 0xc0fe4001, 0xf0450f90, 0x21368e05,
+    0xac8b3001, 0x00000525, 0x8302c0ff, 0x000628ab, 0x001d0018, 0x826e0043, 0x331525af, 0x35223522, 0x11948a18, 0x07063731, 0x23253533, 0x26070607,
+    0x0623012f, 0x18071507, 0x2a187c8b, 0x26272337, 0x22232627, 0x83352223, 0x0f062305, 0x11192701, 0x172508f9, 0x3f361716, 0x2a058201, 0x35373633,
+    0x02602726, 0x73500101, 0x50300fb6, 0x01020101, 0x100b5220, 0x0c102223, 0xe0010f22, 0x14b68b18, 0x19735025, 0x83010504, 0x03033e00, 0x070d0101,
+    0x0f06162a, 0x02010f95, 0x0925850d, 0x2e070f0e, 0x800d0708, 0x0f01010f, 0x21628282, 0xfb560102, 0x15012106, 0x8305ab65, 0x189e2d13, 0x1e01021e,
+    0xaf0d0219, 0x0e100102, 0xfe213882, 0x212f8360, 0x05832f2f, 0x1b29f027, 0x2570011b, 0x25288206, 0x5b0c0201, 0x49820c2c, 0x020e1023, 0x2307824b,
+    0x0a0c610d, 0x0f210d83, 0x07974501, 0xc001802a, 0x53004d00, 0x77006500, 0x22084743, 0x82070623, 0x17162373, 0x09840706, 0x83059542, 0x43098513,
+    0x0e820867, 0x36171625, 0x18373637, 0x3707d54d, 0x2f343523, 0x012b2601, 0x26272635, 0x15052127, 0x17333523, 0x31272605, 0x5805a545, 0xb0660793,
+    0x4f228305, 0x702007ab, 0x2108e647, 0xc1830001, 0x1419e020, 0x098908de, 0x60709020, 0xdf661907, 0x45202008, 0x133005ec, 0x3319144d, 0x140e0d01,
+    0xb00100ff, 0xfe4d3380, 0x4708cf51, 0xda1808ea, 0x766c100b, 0x18302005, 0x54089447, 0x0f220ca9, 0x894a8001, 0xe8931805, 0x05a34a09, 0x131a7325,
+    0x8330134d, 0x13ed2455, 0x18e34d60, 0x460ff253, 0x7787081e, 0x06000022, 0x2b08a742, 0x00150010, 0x002f0022, 0x0065004a, 0x25059f60, 0x17161507,
+    0xd1431716, 0x23072405, 0x63153335, 0x362307a7, 0x18263537, 0x250b6eb8, 0x26032726, 0x8642013d, 0x63348207, 0x26230967, 0x63260727, 0x1420076a,
+    0x52184d82, 0x34250897, 0x01272627, 0x090a41b0, 0x0f80012e, 0x200f0101, 0x3088b0b0, 0x07010107, 0x60200484, 0x4f210a89, 0x23138509, 0x1211201c,
+    0x17250984, 0x26412917, 0x230a8402, 0x231b1011, 0x0f233285, 0x83601a0f, 0x05234bf4, 0x52820f20, 0x40407026, 0x90070170, 0x048d5283, 0x0b060923,
+    0x2715833e, 0x1514243e, 0x1e262120, 0x1e270b83, 0x1c2b2a32, 0x842d1b37, 0x21422618, 0x1a131b1c, 0x2318852b, 0x131c1c21, 0x30061345, 0x00c001ff,
+    0x0040001c, 0x26270100, 0x011f0607, 0x28068507, 0x37323316, 0x37012f36, 0x23088417, 0x16170527, 0x2005364a, 0x24088807, 0x07011d06, 0x081e8306,
+    0x33013f21, 0x27013f32, 0x40f80107, 0x0e0e1111, 0x11372610, 0x950a0c11, 0x070a0707, 0x26370e0e, 0x820a070f, 0xfe0f2b08, 0x0a0a3ad9, 0x05060605,
+    0x0887293b, 0x39132724, 0x1d830e0e, 0x1a593939, 0x3d95bb13, 0x0e407901, 0x0f11110e, 0x0e0e3726, 0x0595100f, 0x83111107, 0x2706823e, 0x0b0b3b53,
+    0x293a0505, 0x27290685, 0x39591a13, 0x07071111, 0x23358339, 0xffff0400, 0x20069b44, 0x22c9820e, 0x4339002a, 0x16220757, 0x815c2117, 0x21172105,
+    0x22097c4c, 0x82132736, 0x161721e7, 0x9c460183, 0x3e9f3012, 0x010b2b2c, 0x08300108, 0x3f2c2b0b, 0x83d0fe99, 0x3e3d2307, 0x14822c2b, 0x0507332e,
+    0x2b040423, 0x3138392c, 0xe6d20606, 0xd3230785, 0x82220507, 0x01012e14, 0x3b252601, 0x08010109, 0x0126263b, 0x210682b1, 0x12842625, 0x01010823,
+    0x0585462e, 0x86079a46, 0x20148507, 0x5f4d1800, 0x822d200b, 0x2307280c, 0x26270607, 0x4135013f, 0x8341067a, 0x3b088b08, 0x17363736, 0x07060716,
+    0x64fde301, 0x0e111159, 0x3431590e, 0x05060605, 0x29330a0a, 0x34210886, 0x3a08872a, 0x25251c32, 0x0101241e, 0xfd1d011c, 0x110e0e59, 0x31655911,
+    0x0b050533, 0x8529340b, 0x83298206, 0x1c32280d, 0x21170303, 0x821c2929, 0x09e74a93, 0x23001e22, 0xe9589582, 0x14152d05, 0x0601011f, 0x16170607,
+    0x37163133, 0x3e06576c, 0x07273435, 0x07173723, 0x0aa0f701, 0x090a0d0d, 0xf1fe0709, 0x1b03041d, 0x20292e20, 0x85071301, 0x6fc02913, 0x015e3796,
+    0x0909a017, 0x21820f83, 0x29281e29, 0x1f012420, 0x85081301, 0x95572312, 0x6b485e37, 0x01002d08, 0x001500a0, 0x0030001a, 0x13000035, 0x20051345,
+    0x06394f11, 0x33113725, 0x82263736, 0x33352372, 0x1a992515, 0x16b0c826, 0x08160202, 0x2007835c, 0x240d8308, 0x01404038, 0x26179658, 0x161602a0,
+    0x46c0fe02, 0x0121075e, 0x230f8340, 0xe0b0b0e0, 0xab861796, 0x8002c038, 0x2300bd01, 0x31002c00, 0x00003600, 0x37341117, 0x36253736, 0xad820517,
+    0x0611152f, 0x27262307, 0x26273411, 0x07062127, 0x2e0f8606, 0x35272617, 0x07061521, 0x15212721, 0x82013d21, 0x00353a04, 0x01120b0b, 0x010c0c0c,
+    0x0b0b120c, 0x16301602, 0x0e090902, 0x090e80fe, 0x2d0c8409, 0x01021698, 0xfe160280, 0x800118b0, 0x038380fe, 0x3d012830, 0x080f1014, 0x6b05056b,
+    0x14100f08, 0xde83c3fe, 0x0d09012b, 0x01010909, 0xfe0d0909, 0x2c0f83f7, 0x38160218, 0xb0021638, 0x50704040, 0x08b75050, 0xc001002d, 0x32001400,
+    0x00004400, 0x180f2601, 0x2908a6a5, 0x35363732, 0x36372734, 0xb2823727, 0x22232623, 0x70bb8207, 0xa11812e9, 0x3623122b, 0x1821070e, 0x2e086073,
+    0x0d04220b, 0x2319388a, 0x23292923, 0x4b381923, 0x012007e8, 0x081d5418, 0x2436c028, 0x25010125, 0x07873624, 0x045f0126, 0x0b014e0d, 0x07a47318,
+    0x4f0b1022, 0x1e214f82, 0x20008211, 0x1395661e, 0x3b8bf020, 0x57474383, 0x02e02f05, 0x00a00100, 0x00110008, 0x0077002e, 0x2d5a3700, 0x4b132010,
+    0x11200b2b, 0x46051b4f, 0x2322050a, 0xec833311, 0x16331527, 0x07061517, 0x25078323, 0x06010f16, 0x0256012b, 0x33372105, 0x58082e58, 0x3e580736,
+    0x21378611, 0x6a5bd015, 0x87602007, 0x83c02008, 0x20fe2108, 0x10210583, 0x21058310, 0x0b85e001, 0x07015033, 0x01076888, 0x45680701, 0x0a080914,
+    0x7f120a15, 0x23058211, 0x45140908, 0x88201685, 0x22861c83, 0x10070124, 0x16880107, 0x21116e5b, 0xf6482001, 0xc0fe2109, 0x01230b89, 0x82077840,
+    0x2b3d831b, 0x10100120, 0x0e0e2011, 0x10101120, 0x18851288, 0x18200583, 0x18206d83, 0x20206784, 0x00200582, 0x023d0082, 0xe2ff0e00, 0x9f017202,
+    0x35001900, 0x17130000, 0x011f3237, 0x0f060716, 0x012f0601, 0x27038207, 0x3f262726, 0x31333601, 0x17251582, 0x15013f16, 0xfad71814, 0x175d080b,
+    0x3f363716, 0xf54b3301, 0x2a050bf5, 0x0f050606, 0x530e17a3, 0xa3170e53, 0x0606050f, 0xf60b052a, 0x14130c37, 0x0a0a8015, 0x0f10cc10, 0x0a0a10cd,
+    0x13141580, 0x0102370c, 0x091e1e9f, 0x0d0d0e54, 0x15062e05, 0x06158b8b, 0x0d0d052e, 0x5f09540e, 0x0708135b, 0x10a72405, 0x33040d0d, 0x29028204,
+    0xa7100d0d, 0x08070524, 0xab825b13, 0x0100042e, 0x0002e1ff, 0x2400a101, 0x44003400, 0x09fde718, 0x07063124, 0xc5551716, 0x36332406, 0x19373637,
+    0x6c0d4d70, 0x06220d79, 0x91533307, 0x370f910c, 0x3a470001, 0x01222239, 0x140c3702, 0x02030314, 0x23320502, 0x3a321324, 0xab4f1585, 0x53812005,
+    0x022e088a, 0x080e811e, 0x0d090909, 0x0209090d, 0x178a7f1d, 0x01a10135, 0x2f2f1c1b, 0x27374c3a, 0x03021c1b, 0x11010505, 0x83131011, 0x3a2e2813,
+    0x1c2f2f3a, 0x84f0011c, 0x090a2536, 0x021d0e09, 0xf6820a95, 0x00020030, 0x02c1ff00, 0x00c0017f, 0x002d0015, 0xeb8f3700, 0x01373226, 0x27051506,
+    0x3520f882, 0x24050470, 0x26270706, 0x06eb7607, 0xc58a4020, 0x1324242f, 0x31383a31, 0x0213aafe, 0x111d7637, 0x25ca8411, 0x6b476847, 0x0f190f13,
+    0xd122073e, 0xac8b384b, 0x0b011236, 0x5ce62924, 0x2723231c, 0x1c2e2f3a, 0x3602011b, 0x13100c54, 0x8309e876, 0x0527669b, 0x3a002323, 0x06a96200,
+    0x84211521, 0x07062a88, 0x16150706, 0x3f363317, 0x07865c01, 0x05209f83, 0x65541e82, 0x83212008, 0x16172124, 0x02270182, 0x0d0e1450, 0x4a40fe01,
+    0x0f260800, 0x01010e40, 0xf55ec001, 0x0e0d3a05, 0x0130fe14, 0x12110180, 0x2524011c, 0x36fffe36, 0x01012524, 0x0111121c, 0x203083e0, 0x08cf5b50,
+    0x8543c020, 0x83c02009, 0x30302b50, 0x15151e30, 0x25362206, 0x39830124, 0x15062224, 0x974d1e15, 0x00022906, 0x1f00c001, 0x99007900, 0x2326b983,
+    0x37222722, 0x424b3130, 0x8214200b, 0x150622c1, 0x22058222, 0x42150331, 0x17230660, 0x82011f16, 0x161521af, 0x27201083, 0x232c2d82, 0x07262326,
+    0x33161706, 0x17161530, 0x36220282, 0x13573537, 0x221d8306, 0x83312227, 0x26272220, 0x215a8233, 0xe05b3435, 0x4f332005, 0x35300524, 0x07062726,
+    0x16330735, 0x21152317, 0x37362335, 0x2009a55d, 0x08f55e21, 0x4701312c, 0x22252522, 0x212e0101, 0x51180238, 0x5e080762, 0x011b0f10, 0x2c200101,
+    0x1807095b, 0x07060307, 0x0213130b, 0x01030915, 0x130a0701, 0x02020f0b, 0x07120201, 0x03011104, 0x1102110d, 0x04050114, 0x061a0303, 0x0b060603,
+    0x02011413, 0x09120101, 0x09010104, 0x0a061309, 0x06120204, 0x0c091103, 0x02121202, 0x2a1e10bc, 0x48800148, 0x4b101e2a, 0xfe21076b, 0x27098760,
+    0x010c0c2c, 0x563a2211, 0x07b15118, 0x25252a24, 0x8182011c, 0x25011130, 0x0a030207, 0x0d0e0f1c, 0x01040c06, 0x7b820606, 0x03060536, 0x06020305,
+    0x11040101, 0x01020612, 0x12060504, 0x05120202, 0x0a287983, 0x0e0d101d, 0x01050c07, 0x01232382, 0x82040404, 0x01022214, 0x20268303, 0x27248403,
+    0x1927f101, 0x27192020, 0x2309104b, 0x40140e0d, 0x5506145e, 0xff2a05b3, 0x0b00bf01, 0x3f003600, 0x124d0000, 0x07262e05, 0x17160706, 0x31070637,
+    0x26150706, 0x21018227, 0x12842223, 0x16171623, 0xcea91817, 0x3f322908, 0x37363301, 0x37353736, 0x0977f318, 0x20013308, 0x0a020b2b, 0x11200709,
+    0x22704e35, 0x4f011616, 0x061f3d3e, 0x19050a09, 0x17160101, 0x90131427, 0x05030308, 0x4524240c, 0x4d410a0c, 0x022d2d44, 0xf3456f1f, 0x19012d07,
+    0x0a46371c, 0x26070303, 0x67113a31, 0x20082e82, 0x2b053b22, 0x090a452c, 0x30353f35, 0x0e12262f, 0x07070324, 0x19181608, 0x02380805, 0xa0442d2d,
+    0x08d14540, 0x0f4a0020, 0x003f2b08, 0x00230081, 0x06072500, 0x58562123, 0x23a18205, 0x16173233, 0x22059947, 0x5e331716, 0x02360810, 0x231c8730,
+    0x010ea5fe, 0x2f370d02, 0x0f9f2a20, 0x0702090a, 0x0f834d1b, 0x77792308, 0x0a10100e, 0x0d02030b, 0x01146438, 0x010f600f, 0x0b011926, 0x011a0f0b,
+    0x010e0d02, 0x02030a58, 0x20820f0e, 0x0002002d, 0x02c0ff00, 0x00c0013f, 0x823d0016, 0x3f162875, 0x26273601, 0x18072627, 0x580acca9, 0x232608d7,
+    0x37362726, 0x8f823233, 0x2b242382, 0x010f2201, 0x20064f47, 0x05d65832, 0x0d13013f, 0x01176c0d, 0x1d181b01, 0x0a0b161e, 0x191d1e16, 0x1701011a,
+    0x0a25016d, 0x770e1010, 0x2d988379, 0x090a0c4e, 0x090a0203, 0x2129a10f, 0x1183372f, 0x5a012108, 0x0f871c22, 0xc50a0302, 0x1a730b0b, 0x14182222,
+    0x0c160302, 0x0203160c, 0x22221814, 0x0d55731a, 0x58202f82, 0x0832b683, 0x0b0f0c07, 0x01261a0b, 0x010f5e0f, 0x100a6414, 0x0b450e10, 0x22c38507,
+    0x82690026, 0x272623c3, 0x9a822631, 0x2726ac90, 0x16150706, 0xac862117, 0x2f262523, 0x21e68201, 0xbc430607, 0x08a44305, 0x17832720, 0x37262728,
+    0x17363530, 0x94431716, 0x0615210a, 0x17222b83, 0x16833130, 0x31300726, 0x38022706, 0x0d23d797, 0x880d0202, 0xfe2808d7, 0x050e0cdf, 0x0409080a,
+    0x0a040403, 0x020e0d05, 0x28021616, 0x18170406, 0x03120615, 0x1c050104, 0x09160c07, 0x090b1405, 0x272d1883, 0x16170309, 0x05170611, 0x1d040104,
+    0x25fa8470, 0x010f0f01, 0x311b0807, 0xa12311ab, 0x82020602, 0x82092052, 0x3d458200, 0x02160c04, 0x0a0a1602, 0x0f0f2524, 0x03050204, 0x0a010303,
+    0x06040103, 0x04091614, 0x1b830b02, 0x24090b2e, 0x030f0f24, 0x03030702, 0x00040b04, 0x2708fb41, 0x001900bf, 0x25000040, 0x2408385d, 0x07262726,
+    0x43ee8330, 0x05200632, 0x25255141, 0x1b291f01, 0xad82011a, 0x0e131327, 0x130d0d0d, 0x25b78213, 0x291b1b01, 0x26411901, 0x0cfe4117, 0x1a01c038,
+    0x1d15271b, 0x131c1d1e, 0x11010c0c, 0x1d1e1c1d, 0x1b1a2815, 0x04415001, 0x610e2112, 0x210a0042, 0xa3520002, 0x00802605, 0x00530029, 0x06755400,
+    0x1f060729, 0x06071601, 0x702f2627, 0x1d220889, 0x13821401, 0x074d9c18, 0x5f192f20, 0xc87c0709, 0x0af84205, 0x82052757, 0x08138227, 0x34013d28,
+    0xd8232627, 0x0b0c0c09, 0x0801020a, 0x0a0f0d13, 0x3e090b0c, 0x11110b0c, 0x780e0c0b, 0x0e610e0b, 0x33150909, 0x0e828001, 0x0b093e39, 0x0d0f0a0c,
+    0x02010813, 0x0c0d0b0a, 0x09153209, 0x0f600e09, 0x820f780a, 0x0ad4312e, 0x09090202, 0x1f0b0d0c, 0x01091213, 0x99540a01, 0x24053c4b, 0x971216cd,
+    0x2427820c, 0x3e1b217a, 0x212782ac, 0x1d825599, 0x13120927, 0x0d0c0b1f, 0x24498309, 0x7a211a3f, 0x2339820e, 0xcd161297, 0xb7413282, 0x02c12c05,
+    0x00bf0180, 0x004c002b, 0x41230100, 0x272305aa, 0x83352726, 0x831520ca, 0x21e78204, 0xde441617, 0x37322406, 0x53013d36, 0x3720054a, 0x26242482,
+    0x2223010f, 0x15212382, 0x05e34f14, 0x24081b82, 0x17161716, 0x37363715, 0xe8012736, 0x12110198, 0x1716211d, 0x13211901, 0x030c5013, 0x07500603,
+    0x670c0c0d, 0x05c07b89, 0x16080e26, 0x94160202, 0x3f241385, 0x010e313a, 0x24050a41, 0x0f1018b8, 0x322e8401, 0x1d340101, 0x02041516, 0x79211415,
+    0x2121150f, 0x82072e28, 0x838b20f5, 0x013c2e49, 0x0e1b1212, 0x0230140e, 0x03163016, 0x23138524, 0x7e12091f, 0x27050a41, 0x0f100159, 0x062f1d18,
+    0x00202e82, 0x02200082, 0x802a0484, 0x30008001, 0x00005b00, 0x70180725, 0x57180d9b, 0x17210ac9, 0x4abc8216, 0x05850578, 0x26273626, 0x2325012f,
+    0x2105855d, 0x7018010f, 0x332016f2, 0xdf41f182, 0x4f012705, 0x1d1d201e, 0x7018140c, 0x60220896, 0x0082090e, 0x18720d21, 0x080c9d70, 0x090c0d23,
+    0x0201080a, 0x1101940a, 0x28281f60, 0x0a0c092b, 0x070b0d62, 0x50111010, 0x0a090b0c, 0x0412911a, 0x35378452, 0x1a1ce70e, 0x180e0808, 0x4b151d1c,
+    0x091f1011, 0x0da00d0a, 0x70180a09, 0x1f3b168a, 0x59091110, 0x10100c01, 0x0403090c, 0x0a09490e, 0x76180b0c, 0x0901170f, 0x82a00d09, 0x00002c4d,
+    0xff030001, 0x01fc01c0, 0x824900c0, 0x33152d0c, 0x23371732, 0x27343534, 0x17162726, 0x072a0182, 0x07012b06, 0x06011d16, 0xe6580607, 0x36352605,
+    0x26232737, 0x20dc8237, 0x2b138237, 0x23151415, 0x013b3617, 0x35262335, 0x0a7d4818, 0x23155208, 0x0b201001, 0x0f1c7809, 0x23441a10, 0x04010a24,
+    0x8c060705, 0x0e0d0105, 0x0d146114, 0x0501010e, 0x0211068c, 0x4423240a, 0x1c0f101a, 0x200a0978, 0x0201016e, 0x33312627, 0x70022626, 0x04800001,
+    0x30080884, 0x1a1d2929, 0x07292d2d, 0x0a9a0605, 0x0818480c, 0x0c602908, 0x10029a0a, 0x1a2d2d29, 0x3029291d, 0x04840808, 0x04040380, 0x2f324e05,
+    0x322f0101, 0x0008084e, 0x00000500, 0x7f02c0ff, 0x112ed382, 0x70002300, 0x8a007d00, 0x32130000, 0xe3783137, 0x070c6505, 0x08ffba18, 0x11862720,
+    0x46011f21, 0x8a82069d, 0x06232726, 0x012f1507, 0x2806ad46, 0x16021f06, 0x30333217, 0x82f78233, 0x012f2214, 0x05d84537, 0x3f363323, 0x26028201,
+    0x0f060717, 0x83170601, 0x31322622, 0x36023f36, 0x45ef8227, 0x3f2705e0, 0x05012f01, 0x82010f27, 0x05db460d, 0x0d148026, 0x140d0e0e, 0x2008d554,
+    0x2209827f, 0x84150d0d, 0x0817820f, 0x08135d67, 0x221c1d1d, 0x020f0b0e, 0x0f9f0f01, 0x0e0b1001, 0x1d1d1c22, 0x15071208, 0x1b050a43, 0x0d010102,
+    0x0a010808, 0x112b0d03, 0x33130607, 0x099f0908, 0x06133308, 0x0d2b1107, 0x08010a03, 0x01010e08, 0x0a061a01, 0xfd061544, 0x05042cd2, 0x0c0d0c05,
+    0x021b060b, 0x2b500229, 0x081c022a, 0x0d060614, 0x01040505, 0x85828861, 0x080e8e8a, 0x1f50a344, 0x15100c0e, 0x600a2226, 0x0f01010f, 0x26220a5f,
+    0x0e0c1015, 0x1920501f, 0x021b5d4c, 0x0d0a0a02, 0x310f145d, 0x0d131547, 0x01010421, 0x130d2104, 0x0f314715, 0x0a0d5d14, 0x1a02020a, 0x20194c5d,
+    0x79836e64, 0x4d088183, 0x6e2e1345, 0x45132e6e, 0x06020113, 0x000d0c0b, 0x00000300, 0x4002c0ff, 0x1200c001, 0x67005e00, 0x07010000, 0x22012b26,
+    0x34313007, 0x36373635, 0x16171637, 0x33320717, 0x37361716, 0x17160733, 0x16173233, 0x0714011d, 0x06012b06, 0x07841507, 0x26272225, 0x8a23013d,
+    0x2726220b, 0x07474b23, 0x2005de56, 0x83388306, 0x3b36234c, 0xb84f1701, 0x90012707, 0x80080701, 0x84561719, 0x05102b07, 0x1c060705, 0x1813202d,
+    0x5b430d0e, 0x0e202605, 0x0e090912, 0x200c8220, 0x3d078680, 0x1d1d0936, 0x01011313, 0x041d1313, 0x16020216, 0x02021204, 0x1f0a1f12, 0x16122d1f,
+    0xb0642880, 0x60012607, 0x03060101, 0x3e821803, 0x01012608, 0x174b0121, 0x2043821e, 0x224b8260, 0x86400e12, 0x8259835e, 0x29402214, 0x83508347,
+    0x16022d58, 0x13010216, 0x212d0212, 0x70050c21, 0x03830d83, 0x3608835f, 0x000b00bf, 0x37000042, 0x16311706, 0x3f16011f, 0x21072701, 0x8a312726,
+    0x4d362002, 0x0722079f, 0x9e423717, 0x06c54205, 0x53480120, 0x82132005, 0x08178234, 0x0706277d, 0x440a0101, 0x4f5b0f11, 0x01b40175, 0x2c2b1d1e,
+    0x1d1e2c2b, 0x37371703, 0x0d0e0216, 0x50010d0d, 0x04031522, 0x0a072b11, 0x24333322, 0x022b070a, 0x02010607, 0x110ff817, 0x01010945, 0x0a090407,
+    0x091c070a, 0x8258660d, 0x30212001, 0x22303130, 0x020f0321, 0x0f040e03, 0x010f0e10, 0x20182557, 0x0c4b1c1f, 0x01011406, 0x490c0616, 0x1a111102,
+    0xedfe1c1a, 0x071c0a0e, 0x7b090a0a, 0x3d260abb, 0x72004f00, 0x6b188400, 0x3b230a3f, 0x4e171601, 0x21200563, 0x210b8758, 0xd241012b, 0x0b234d08,
+    0x0723d582, 0x19230706, 0x6208141b, 0x332c0721, 0x01393001, 0x07063130, 0x31062314, 0xaf583083, 0x2136830d, 0x04442731, 0x20348307, 0x21758207,
+    0x99410133, 0x41602006, 0xfe2607ba, 0x09110dec, 0xaf41e30a, 0x29602c05, 0x01011b1c, 0x2a291c1b, 0x820c0c11, 0x291b2108, 0x02212683, 0x21008217,
+    0x037c6002, 0xd6fe250c, 0x09010507, 0x5e421985, 0x0c012807, 0x0303110c, 0x19170c0e, 0x200d052e, 0x058758c0, 0x0f222587, 0x1f820d16, 0x03820e20,
+    0x17231187, 0x87161a19, 0x2521258e, 0x011a1a25, 0x2b0c2e7c, 0x050898fe, 0x1a010a01, 0x2125251a, 0x16279f87, 0x0417191a, 0x740e1204, 0x61850678,
+    0x68180020, 0x17260cb7, 0x00002400, 0xf4822313, 0x17161722, 0x41099f47, 0x25230529, 0x43310706, 0x36300525, 0x40402337, 0x331d1e01, 0x09093f32,
+    0x0a0a0d0d, 0x01380b85, 0x33334080, 0x57112a1e, 0x40023838, 0x323f6101, 0x011d1e33, 0x0a090e80, 0x80206a82, 0x1e2c0d83, 0x1f013f01, 0x3e2e341f,
+    0x593d3e0b, 0x27061b5d, 0xc0010002, 0x3f002900, 0x322f7782, 0x1d163117, 0x17322101, 0x07141516, 0x18212306, 0x2b07e8d7, 0x22231135, 0x34352627,
+    0x013b3637, 0x33210583, 0x84298505, 0x21198224, 0x1a82013d, 0x60213326, 0x0109090e, 0x21067041, 0xde85a0fe, 0x20064b43, 0x870d8220, 0x00ff211a,
+    0x20056a41, 0x82788201, 0x821a8316, 0xa0fe2110, 0x60201586, 0x43833889, 0x06831686, 0x210a9f42, 0x3219001a, 0x36224e37, 0xf6823133, 0x56363721,
+    0x172205ee, 0x55183716, 0xa42d180b, 0x090b0b0b, 0x291d1c11, 0x111d1d2a, 0x37321909, 0x0e7d3019, 0x0a0e1515, 0x19080b0d, 0x08192424, 0x180a0d0b,
+    0x2d183155, 0x0b090b46, 0x1010140c, 0x10100101, 0x0c820c14, 0x0c0d1028, 0x0d0c0101, 0x0e699610, 0x123a2c0b, 0x0a080b12, 0x0d1e1e0d, 0x450a070a,
+    0xe026059f, 0xa0014002, 0xff721100, 0x07062206, 0xa1611831, 0x17162709, 0x32051716, 0xc9413117, 0x096a4306, 0x2605b945, 0x07141716, 0x4b330706,
+    0x062009f1, 0x1806e94b, 0x20117f84, 0x06ae4101, 0xf918fe20, 0x1e2f07fc, 0x3f32331d, 0x1d33323f, 0x1212011e, 0x18fea31f, 0x551170c5, 0x078707fc,
+    0x42060b42, 0x398505a4, 0x2f240b85, 0x401f2929, 0x20088943, 0x05b9431b, 0x0730db83, 0x8002c0ff, 0x1900c001, 0x49002b00, 0x11010000, 0xc4839f83,
+    0x024a0520, 0x25372706, 0x36373611, 0xc3723337, 0x80461809, 0x26253307, 0x3f363137, 0x3f161701, 0x012f3601, 0x16173637, 0xbb54011f, 0x26272305,
+    0x5582012f, 0x301f202c, 0x02201f2f, 0x0b0d90fe, 0x3f82040b, 0x40010d22, 0x1b20c882, 0x50095160, 0x072008e8, 0x2e291d83, 0x1f0e0515, 0x2e15020e,
+    0x202e820e, 0x20118329, 0x2409829a, 0xc0012a03, 0x05cf60fe, 0x2e1f1f23, 0x83168364, 0x0157224e, 0x21f48322, 0xb15ca0fe, 0x8390200f, 0x4d0d2833,
+    0x0509010d, 0x870d4d0e, 0x85042045, 0x1800204f, 0x2c086789, 0x00a00180, 0x003a0033, 0x005e004c, 0x26f78270, 0x16311716, 0x18331517, 0x2108c9c8,
+    0xd618012b, 0x342209fe, 0x0c872337, 0x2d05f741, 0x36373611, 0x26172137, 0x3315012b, 0x45450727, 0x1415250b, 0x25331617, 0x08f86c18, 0x2105f257,
+    0x23912326, 0x83a00121, 0x1a3129be, 0x090a3a11, 0x02020e09, 0x21074559, 0x0a84a402, 0x17172934, 0x16172229, 0x12120101, 0x7760011b, 0x68310402,
+    0xdc540731, 0x18318208, 0x8507615c, 0xc5701813, 0xa001210c, 0x30263583, 0x0b471401, 0x1f825a0f, 0x84080821, 0x17162349, 0x00820822, 0x1f220b84,
+    0x7083011f, 0x83300121, 0x03a32484, 0x43ed3d40, 0x5f180b00, 0x0c8c0cac, 0x43450020, 0x050f5506, 0x2b000a23, 0x05516100, 0x36213334, 0x05110137,
+    0x37161727, 0x26113736, 0x010f2627, 0x9b7e2715, 0x06e74305, 0x19820120, 0x01202730, 0x01140d0d, 0xfe0d1f1f, 0x59570286, 0x89431110, 0x6e112105,
+    0xff231784, 0x1808074b, 0x3e09f24b, 0x0d0e1431, 0x28011b01, 0x4646ebfe, 0x08090b0b, 0x14000114, 0x4b0b0908, 0x14bd1995, 0x183c0e0d, 0x310aee4b,
+    0xff100002, 0x012f01c0, 0x002000c0, 0x17000025, 0xf7473523, 0x4a232006, 0x15210686, 0x05147f23, 0x37363323, 0x088d8234, 0x17330337, 0x28e83723,
+    0x041f1f35, 0xe00d030f, 0x040f030d, 0x28351f1f, 0x010c0b11, 0x0107d007, 0x9a110b0c, 0x07b207a4, 0x2a0d7510, 0x0eb2382b, 0xb20e0101, 0x0d2a2b38,
+    0x23188275, 0x07010107, 0xa0232783, 0x69005050, 0x10260abb, 0x00002a00, 0xfb7d2325, 0x21332906, 0x31303130, 0x27052723, 0x83072843, 0x0b064118,
+    0x3d1d013d, 0x022d2d44, 0x010d0909, 0x01f40ec0, 0x1725fa5a, 0x28020116, 0x27353c29, 0x418d0b26, 0x503c0605, 0x100c0f13, 0x2d2d0280, 0x090a0e43,
+    0x12c395c0, 0x3d2c2222, 0x01012928, 0x6f322020, 0x3024fe84, 0x0f13100c, 0x21068f5f, 0xff82c001, 0x10000735, 0x43002100, 0x78006200, 0x06370000,
+    0x35331507, 0x46332726, 0x263105c8, 0x16170327, 0x2f36023f, 0x020f2602, 0x06021f06, 0x08ac7e07, 0x20056a46, 0x485b183b, 0x5d372007, 0x252105d0,
+    0x070d5c33, 0x6f05cf4e, 0x15270be4, 0x36371716, 0x84363137, 0x15172133, 0x25090e4d, 0x20010fb0, 0x99590f01, 0x086c2808, 0x19080404, 0x87190505,
+    0xac2d0807, 0x313f3f31, 0x011e1f32, 0x5d0f0a0a, 0x800e0909, 0x5d09090e, 0x010a0a0f, 0xfe321f1e, 0x26130ef0, 0x27323227, 0x0f0d1426, 0x0d0f0101,
+    0x210d8514, 0x0d830e13, 0x0d012824, 0xf066140e, 0x1b1b2805, 0x1b293029, 0x7d00011b, 0x1454075a, 0x8b142006, 0x28718369, 0x0101248f, 0x2b2b1424,
+    0x48618238, 0x402006d8, 0x382c7882, 0x5b142b2b, 0x011a1a2b, 0x2b1a1a01, 0x0c8cad84, 0x0b115827, 0x110b0c0c, 0x07734818, 0x46001821, 0x27450503,
+    0x00122405, 0x41360024, 0x32200ced, 0x21053041, 0x0d6f012f, 0x18252010, 0x2808da96, 0x32313316, 0x2736013f, 0xc0af1801, 0x11983023, 0x11265711,
+    0x380e0e11, 0x070b0a07, 0x180f0d68, 0x2e1fb8af, 0x5d0f0d7a, 0x110e0e26, 0x08073811, 0x5d111170, 0xc0280a37, 0x20001100, 0x45003200, 0x320fc57a,
+    0x27262726, 0x27262317, 0x16373635, 0x16331517, 0x46070617, 0x1f2610a2, 0x26373401, 0xd642012b, 0x22338208, 0x18f00135, 0x290ff04b, 0x01093630,
+    0x010f0f01, 0x06820f20, 0x36c0fe22, 0x8706e857, 0x09603107, 0x49661c1a, 0x0a023131, 0x68010f0a, 0xe0151422, 0x0f0e4c18, 0x0901a023, 0x293b8346,
+    0x0f0d0230, 0x24018002, 0x438b3625, 0x1a1d702e, 0x31310209, 0x0a0a0f49, 0x2d252618, 0x222cdb8c, 0x71003400, 0x00008300, 0x07272605, 0x24059945,
+    0x34013f26, 0x8bdb8235, 0x373224b7, 0x70013d26, 0x052411ab, 0x36372736, 0x0f242a83, 0x35272601, 0x0722dc82, 0xec821d06, 0x51262721, 0x062c05d4,
+    0x17060717, 0x3f161716, 0x15171601, 0x37270782, 0x36353736, 0x4c161737, 0x07210555, 0x74661826, 0x0617210a, 0x012f3282, 0x080403a9, 0x0c110a09,
+    0x18070c1c, 0x82130708, 0x24f78836, 0x0407097a, 0x0f1941c9, 0x0383013c, 0x01051903, 0x0504170b, 0x01141119, 0x06202205, 0x041a1114, 0x010b1605,
+    0x1a851905, 0x05041623, 0x271a851a, 0x11140105, 0x17040519, 0x73261b83, 0x0e0e0d15, 0x0582150d, 0x82010121, 0x02233207, 0x01050402, 0x271f0c01,
+    0x04050f1e, 0x160c0404, 0x06304106, 0x08080424, 0x5041e309, 0x15753e0f, 0x06030f15, 0x03041920, 0x1e070e0e, 0x07070205, 0x071e0502, 0x04030e0e,
+    0x03062019, 0x211d870f, 0x1d8b0f02, 0x85020f21, 0x831c201d, 0x4a7e8970, 0x802d0627, 0x1100c001, 0x30002400, 0x00003d00, 0x0f064337, 0x45011f21,
+    0x262e0919, 0x3f36013f, 0x17272601, 0x14010f06, 0x0b823733, 0x25072723, 0x09227d27, 0x41df2721, 0x24270825, 0x24010124, 0x41343624, 0x20080844,
+    0x0e02021e, 0x302d0b03, 0x02036047, 0x06470b0e, 0x7e487e03, 0x0b160301, 0x260c0e0e, 0x0a0a2748, 0x20e98fc0, 0x06064130, 0x4709082e, 0x2e2e0b0f,
+    0x06037502, 0x020e0b47, 0xa52a3783, 0x260b0b15, 0x0e0c2648, 0xc38e0b0e, 0x47003522, 0x3221c39e, 0x05204537, 0x16231728, 0x14151617, 0x00443307,
+    0x17162513, 0x17160706, 0x226fb418, 0x234acc2f, 0x8a0a1414, 0x0209090e, 0x2f452d2d, 0x06887530, 0x121d2627, 0x201f0101, 0x35d49830, 0x490f0a0a,
+    0x10023131, 0x2f29281d, 0x090a0f14, 0x2d2d430e, 0x53184002, 0x162708ab, 0x29362821, 0x82000120, 0x00023100, 0x01c0ff20, 0x00c001e0, 0x003e002a,
+    0x15171300, 0x072d9a83, 0x36331706, 0x3736012f, 0x17352726, 0x06ea4515, 0x36023f30, 0x012f3435, 0x06010f26, 0x05171415, 0xfb432707, 0x08e38608,
+    0x062e272c, 0x0a01010b, 0x2a09020f, 0x0a100109, 0x340b0101, 0x36252401, 0x01242436, 0x0e0e5201, 0xbe1414be, 0x39010e0e, 0x21366767, 0xa2820121,
+    0x0f7a013d, 0x21010a0a, 0x70013621, 0x0e063b01, 0x0c3e070d, 0x3f0b0202, 0x060e0d07, 0x413c0d35, 0x3c2907eb, 0x0b0b0514, 0x04042e05, 0x2607832e,
+    0x116767e9, 0x823b2c2c, 0x23408238, 0x112c2c3b, 0x4506b349, 0x1f2e057f, 0x3d003100, 0x61004f00, 0x23250000, 0xdc4f2635, 0x15072205, 0x08297123,
+    0x8305665a, 0x0d785e18, 0x06071429, 0x35233723, 0x51363734, 0xee440541, 0x02352a22, 0x13011050, 0x19252014, 0xd2431919, 0x14c02109, 0x4e064c71,
+    0x20200cf0, 0x21062649, 0xe643d0fe, 0x0460230f, 0xc3421a17, 0x0f2d2c08, 0x214ba001, 0x02051718, 0x79241717, 0x57830ea8, 0x86499020, 0x5090230b,
+    0x0082090e, 0x20500e22, 0x230fd942, 0x070c0d50, 0x2206dc42, 0x46801c14, 0x2f20109f, 0x63279f46, 0x362205db, 0x98462637, 0x90882525, 0x16020216,
+    0x7e860485, 0x18068642, 0x20104bb6, 0x08ba5138, 0x42030021, 0x1827087f, 0x37002300, 0x4d130000, 0x1d490519, 0x2726310b, 0x07061716, 0x17323337,
+    0x34231516, 0x17333637, 0x27127b42, 0x0c1b2a40, 0x362d2121, 0x38061944, 0x101e1e26, 0x2902321c, 0x5f900229, 0xa0090a0e, 0x820e0909, 0x273e5252,
+    0x09784228, 0x3e27282a, 0x1d010001, 0x011a192a, 0x28084241, 0x26211313, 0x1c1c3402, 0x06fe4e34, 0x6d6dd326, 0x412e2f0c, 0x24056e42, 0x0c2f2e41,
+    0x0c634600, 0x1b001430, 0x42002d00, 0x27250000, 0x06010f26, 0xc8541607, 0x85372005, 0x350721bd, 0x3a47b682, 0x0d804614, 0x33342308, 0x27262726,
+    0x07736e02, 0x0111730f, 0x33282802, 0x1e1b070f, 0x0116161f, 0x607e1101, 0x1c1f1e07, 0x3842f0fe, 0x1661220f, 0x08374218, 0x047a2408, 0x1d280104,
+    0x2db1031d, 0x082d0404, 0x38375410, 0x09040413, 0x2c2c1b1b, 0xbf08103f, 0x254126bd, 0x42ce0c25, 0x36200f25, 0x25070746, 0x331e0101, 0x0b444433,
+    0x4d002005, 0x0d3406ef, 0x00002700, 0x31171417, 0x32213316, 0x07062537, 0x012d0706, 0x3e17b04a, 0x0f0a0a5f, 0x07097a01, 0x3048fdfe, 0x18020230,
+    0x1a2aebfe, 0x2403011a, 0x24353724, 0x4a990323, 0x1d2f0bb1, 0x040a0a0f, 0x313004cc, 0x0cda0848, 0x852d2121, 0x352322d5, 0x0bb24a78, 0x2a0a7345,
+    0x00240012, 0x0043003a, 0x41352500, 0x36240b32, 0x35262737, 0x7112b347, 0x1f21095d, 0x6a611801, 0x2729820a, 0x07061716, 0x2a236001, 0x24093341,
+    0x1c3d0913, 0x0f554180, 0x5b970134, 0x0e4f1a13, 0x5b120909, 0x0a0d0c0a, 0xb7090a5c, 0xac420216, 0x2c512205, 0x06d54213, 0x3e0e0125, 0x416f281c,
+    0x6d310f4f, 0x0909135a, 0x121b4f0e, 0x5d09095b, 0x0a0c0d0a, 0x109f5415, 0x1100c024, 0x9e182a00, 0x072f13f9, 0x17073327, 0x16171637, 0x06071417,
+    0x82222123, 0x373627dd, 0x37173736, 0x668f6001, 0x60218f39, 0x3b282121, 0x09012626, 0x7efe0d09, 0x0109090d, 0x283b2626, 0x8f400121, 0x37e728cb,
+    0x0aa17c37, 0x753d2c2c, 0x3d2805c2, 0xa10a2c2c, 0x0008007c, 0x2e07e341, 0x00230011, 0x004a0035, 0x0071005c, 0x18c000ae, 0x2013154a, 0x11ad4721,
+    0x1429118c, 0x011f1617, 0x27223734, 0x0e084a22, 0x37342723, 0x081e4a31, 0x33171628, 0x23252726, 0x2e820722, 0x07061524, 0x10823736, 0x26373626,
+    0x17272627, 0x0f2a0482, 0x35272601, 0x07262734, 0x1c820706, 0x82145f49, 0x36372337, 0x5f49013d, 0x27362409, 0x45273637, 0x022611c0, 0x16172200,
+    0x5e180101, 0x078207da, 0x8f80fe21, 0x2cc02811, 0x01011d1d, 0x832b1e1d, 0x1e1d2807, 0x0209302c, 0x19020201, 0x25080471, 0x0f0e1a0b, 0x701901b8,
+    0x29080cee, 0x133e7001, 0x01010111, 0x4127200e, 0x0210032a, 0x25191901, 0x03110842, 0x0f0c1403, 0x02191904, 0x140c0f01, 0x08110303, 0x06820301,
+    0x01031422, 0x1a221a87, 0x19870418, 0x03130427, 0x02041303, 0x0ba24f6a, 0x18200121, 0x8f0f5954, 0x82a0200f, 0x182c20a6, 0x8307d54b, 0x19502107,
+    0x3408dd82, 0x0c382626, 0x1d140807, 0x06b8221d, 0x08020206, 0x271b1a01, 0x33250211, 0x02030818, 0x1b200605, 0x2e020112, 0x1b271102, 0x19af011a,
+    0x0b020312, 0x0417060a, 0x30298201, 0x0a061603, 0x1303020b, 0x0b020418, 0x020b1010, 0x221d8404, 0x8316050b, 0x0401241d, 0x820b0516, 0x1912211d,
+    0x01221d85, 0x6b464104, 0x0863470b, 0xc0017f32, 0x23001f00, 0x45004100, 0x00007400, 0x31070637, 0x17200286, 0x25062448, 0x36353037, 0xe8612627,
+    0x010f2405, 0x18231737, 0x6f0cbbb1, 0x34210848, 0x20258531, 0x23218207, 0x36112317, 0x4205b760, 0x0627060e, 0x14070607, 0x82151615, 0x17062b06,
+    0x3f321716, 0x11171601, 0xa14f1716, 0x12552b06, 0x0c0b1b0d, 0x01010202, 0x0c4c2424, 0x04042e05, 0x0f2a1212, 0x1d0f1c1c, 0x01904848, 0x240983f3,
+    0x0914111c, 0x48228308, 0x2283067e, 0x82742921, 0x8f38351e, 0x0d7e0c20, 0x04040506, 0x710d0b0c, 0x16222e17, 0x7c010116, 0x08371083, 0x88050516,
+    0x0f010806, 0x0e010fdf, 0x24c5150d, 0x1717361a, 0x42050707, 0x21380641, 0x0a0a0601, 0x1b542324, 0x8f8fa51b, 0x1b1b2501, 0x11282238, 0x05060611,
+    0x16214184, 0x211f8517, 0x1d825224, 0x2701a025, 0x832b210f, 0x22578360, 0x82022525, 0x032225bf, 0x29020103, 0x152e1383, 0x052d0201, 0x0fa9fe03,
+    0x150d0201, 0x5b410e0e, 0x00bf330a, 0x001f001b, 0x006c004e, 0x25000070, 0x22312326, 0x23630607, 0x37362408, 0x41343736, 0x0723065b, 0x82231737,
+    0x2736240e, 0x82012f26, 0x7b352013, 0x3b4305f1, 0x16172205, 0x216e821f, 0x39822311, 0x17141533, 0x11373633, 0x16173736, 0x35300533, 0x31273631,
+    0x21028326, 0x588f2326, 0x4f822720, 0x0f2b022a, 0x1d0f1c1c, 0x06051d11, 0x35050f47, 0x01012424, 0x12120404, 0x48487329, 0x08164890, 0x0d060504,
+    0x5c82017a, 0x172e2127, 0x0c0c0e71, 0x31108304, 0x90200c7e, 0x0f0e0d14, 0x08010edf, 0x05078806, 0x338400ff, 0x22058e41, 0x83061c11, 0x3624264b,
+    0x02242536, 0x28448280, 0x391b1bc5, 0x0e0e3822, 0x08544106, 0x0b050135, 0x5224240a, 0xe08f8fa5, 0x0b0d1501, 0x0228040c, 0x83030301, 0x2502261e,
+    0x05060525, 0x3a13830d, 0xfe0f222a, 0x0d0d01d9, 0x02011014, 0x0358010d, 0x70022d05, 0x0a0a0501, 0x88542423, 0x16162150, 0x16249a82, 0x8f8fa022,
+    0x2c0a9f56, 0x00280023, 0x004f003d, 0x37330100, 0x09044a21, 0x37211728, 0x36272623, 0x068c3337, 0x33350525, 0x85052317, 0x19142026, 0x4a086189,
+    0x0124152b, 0xfe119f50, 0x2c08fe70, 0x00010967, 0x010f6111, 0x126a0f01, 0x2206837c, 0x83961284, 0xf0fe3806, 0x01520c46, 0x1b00ff60, 0x09011212,
+    0x40010e09, 0x0109090e, 0x531b1212, 0x80210d91, 0xdc431840, 0x40602108, 0x230dbc74, 0xc0808080, 0xbf573083, 0x18488307, 0x580cd283, 0x402e09b7,
+    0x1c00a001, 0x00003b00, 0x06072613, 0xc1821107, 0x82059f64, 0x373626c9, 0x34113536, 0x23ca8327, 0x06232605, 0x06231e82, 0x83150631, 0x32172222,
+    0x831c8237, 0x08228328, 0x90272685, 0x01124439, 0x40080707, 0x1d1e3132, 0x09050502, 0x02070304, 0x01372020, 0x3239449d, 0x01081f1f, 0x09040307,
+    0x1d020505, 0x4032311e, 0x01070708, 0x01a00112, 0xfe14091e, 0x0405099a, 0x05041c03, 0x03040e0f, 0x04060501, 0x05088001, 0x030e0f03, 0x0d021d1d,
+    0x0501060d, 0x0581fe08, 0x03010506, 0x050f0e04, 0x04031c04, 0x66010905, 0x00000914, 0xff000005, 0x014002c0, 0x001400bf, 0x0048002e, 0x8575005b,
+    0x611520c1, 0x37270615, 0x35262736, 0x18363734, 0x8307564b, 0x85b58517, 0x20d58217, 0x05de7605, 0x17060725, 0x4f141516, 0x33200597, 0x8905ac48,
+    0x82332012, 0x343522e8, 0x1a7a1827, 0x17162107, 0x1484fd83, 0x2a821120, 0x26284482, 0x0d14a127, 0x0f070c10, 0x0337f482, 0x0a080404, 0x0d621209,
+    0x15050c0c, 0x06150915, 0x05050c06, 0x82101005, 0x010c2604, 0x0c0c05ec, 0x2a0f890d, 0x09150606, 0x14010114, 0x83071387, 0x06062e33, 0x0c10080d,
+    0x2076150b, 0x02011617, 0x0545451e, 0x0809123d, 0x0d0c0505, 0x09850112, 0x1d211e12, 0x05020e1a, 0x10090909, 0x15121513, 0x8204390c, 0x3734331a,
+    0x01133439, 0x0b0c0602, 0x2c2c280d, 0x0c0b0d28, 0x62821206, 0x10860420, 0x88822720, 0x0102062a, 0x37393413, 0x150b2634, 0x03213885, 0x2a4a830c,
+    0x05070713, 0x251f1213, 0x46d7fe12, 0x0129055d, 0x13130a29, 0x0d0c1217, 0x0a835404, 0x3b002622, 0x2307ad45, 0x16173637, 0x08914c18, 0x8305fc41,
+    0x30352905, 0x07262731, 0x07060722, 0x08380f19, 0x17010f26, 0x012f3637, 0x59081d83, 0x0e105d27, 0x053c0a0e, 0x5f020202, 0x01030305, 0x2e2e2020,
+    0x1d182b2b, 0x06071111, 0x1b1c0256, 0x021f2626, 0x0d0d081c, 0x0b23e10b, 0x3a571908, 0xe222060d, 0x0801020a, 0x1a1a0dbe, 0x03011620, 0x18700404,
+    0x0102100f, 0x08070202, 0x23231912, 0x6d011b1b, 0x09080101, 0x2583f618, 0x092caf2e, 0x0c6d350c, 0xb0290d05, 0x0b0d0c08, 0x5359b784, 0x00102e05,
+    0x13000025, 0x11331121, 0x23262726, 0x209e8221, 0x200b8215, 0x0b8a7c01, 0x17162408, 0x35373621, 0x01602726, 0x0b014080, 0x50fe100c, 0x400b0b12,
+    0x0190d001, 0x010fa00f, 0x01010fd0, 0x8320020f, 0x60012505, 0x3801e0fe, 0x2605be53, 0x2001c8fe, 0x8330c0fe, 0x18302016, 0x210c2a86, 0x1f490300,
+    0x06195308, 0x10440120, 0x17162405, 0x88112135, 0x17162177, 0x5309fe7c, 0xd25010d9, 0x07194f0b, 0xfe500235, 0x0d0e1480, 0x011b2401, 0x0f014060,
+    0x60010f60, 0x58fe1122, 0x502008e1, 0x3d0f7e75, 0x25364020, 0x09090124, 0x0e00010e, 0x24010909, 0xc0013625, 0x150e0e01, 0x3211012e, 0xb885e0fe,
+    0x83271921, 0x3c012711, 0x010e0e15, 0xbe59c0fe, 0x8320200f, 0x05124234, 0x00204a83, 0x310c074e, 0x00340028, 0x01000040, 0x06171633, 0x17152307,
+    0xdb841716, 0x2605f455, 0x36112315, 0x4535013f, 0x02540521, 0x37012205, 0x210e8215, 0x0d822726, 0x23053123, 0x382f8235, 0x06070615, 0x58013107,
+    0x02021620, 0x16712016, 0x12016001, 0x121b1b12, 0x21088212, 0x15857116, 0x16160227, 0x67c1fe02, 0x2ce68450, 0x50370218, 0x01011867, 0x01140e0d,
+    0x26198390, 0x1b0e442e, 0x7c60fbfe, 0x0125088a, 0x440e1b05, 0x2019832e, 0x24538318, 0x38e6fe18, 0x282d83ee, 0xb60f1b5c, 0x1b0f38ee, 0x7646835c,
+    0x002e065f, 0x1600c001, 0x50004100, 0x7f006f00, 0xc9829200, 0x26258e83, 0x22272627, 0x21048207, 0x444e3736, 0x05312405, 0x82323336, 0x171622ac,
+    0x21ad8214, 0x01823130, 0x22311522, 0x2d820682, 0x2321cf83, 0x83e48426, 0x1731212e, 0xd5840583, 0x26353424, 0x2f823127, 0x22072222, 0x4f820583,
+    0xde48f882, 0x22258307, 0x52153334, 0x362205c7, 0x58831537, 0x013d3423, 0x833d8807, 0x83352084, 0x022d082d, 0x2e250100, 0x3d06054d, 0x020c0c57,
+    0x36020125, 0x36525236, 0xa1fe0236, 0x272f100f, 0x01261b28, 0x011b0802, 0x3027281b, 0x0101385c, 0x3a218202, 0x39232301, 0x2be71110, 0x01131921,
+    0x021e162b, 0x25010816, 0x01010202, 0x82305c38, 0x01253d2f, 0x573d1913, 0x0b0c3d57, 0x02010809, 0x04052001, 0x13191417, 0xe0371a0f, 0x13193d57,
+    0x23835d87, 0x1b70012e, 0x03061915, 0x01011902, 0x221b1501, 0x0806124b, 0x0901512c, 0x1c150e08, 0x0f140705, 0x09080f01, 0x02011c01, 0x141b1b15,
+    0x01030814, 0x0a0e071a, 0x151e230f, 0x0302070b, 0x1b951421, 0x1d820215, 0x0f080927, 0x0f231b15, 0x2445820a, 0x05060519, 0x254c8206, 0x01013a23,
+    0x2a820806, 0x190f1029, 0x3a03020d, 0x821901aa, 0x8460870c, 0x0a7b472b, 0x2c001a25, 0x18003e00, 0x2a1d775c, 0x35262303, 0x37363736, 0x48061732,
+    0x072105ea, 0x103c7917, 0x2f5b3520, 0x00012310, 0xf1183948, 0x0b8b0971, 0x1001af31, 0x47303008, 0x0d01020f, 0x0728283b, 0x43af0d02, 0x824b0f58,
+    0x18db7f0c, 0x0200ff38, 0x3030470f, 0x020e1008, 0x3b282806, 0x015f010e, 0x28281b1b, 0xd7601b1c, 0x1b1a2305, 0x1f4b7f01, 0x0002280e, 0x02c1ff00,
+    0x54c00180, 0x012805e7, 0x16171633, 0x1507011f, 0x172ad783, 0x2f060716, 0x22152201, 0x0a85012b, 0x41672320, 0x01372107, 0x1625fe84, 0x36073517,
+    0x7c6e1837, 0x0c023709, 0x11111632, 0x01600406, 0x2a3e2627, 0x0a151407, 0x0101012f, 0x09842729, 0x4a853108, 0x080d0d0b, 0x0a020108, 0x19016401,
+    0x1a2a2519, 0x07021644, 0x070a0a07, 0x01160207, 0x0e0d01a1, 0x48180f15, 0x12333243, 0x070a1566, 0x5f017214, 0x71210683, 0x83318339, 0x12012c39,
+    0x1919251d, 0x011f0101, 0x18170150, 0x2407406e, 0xffff0100, 0x057345ff, 0x00004438, 0x31071401, 0x31302306, 0x06033122, 0x27262107, 0x30233003,
+    0x58432223, 0x60332005, 0xde670596, 0x27262405, 0x84363736, 0x07062211, 0x23f18217, 0x2726013f, 0x08064353, 0x40021523, 0x01110b0c, 0xfe1a0632,
+    0x32061ab6, 0x0b110101, 0x0b01010b, 0x0b11100c, 0x0d59080c, 0x39080e0e, 0x200f8312, 0x27178311, 0x0e083912, 0x075a0d0e, 0x2106c368, 0x24823801,
+    0x18eafe27, 0x01180202, 0x3ea81816, 0x0a0e2908, 0x04030a47, 0x160b740d, 0x2905c445, 0x0d740b16, 0x470a0304, 0x0f850d0b, 0x3506db4e, 0x00c0017e,
+    0x001d0014, 0x002f0026, 0x00410038, 0x00600057, 0x62182500, 0x52180820, 0x3622087d, 0xbe830527, 0x15275018, 0x11305018, 0x16233727, 0x010f1415,
+    0x20e58215, 0x08af6817, 0x18072721, 0x3c083d50, 0x0eaf0ebf, 0xaf101215, 0x0faf0e0e, 0xaf0f1414, 0xa1fe010e, 0x15020215, 0x16020315, 0x22088480,
+    0x84160102, 0x84108207, 0x880f8207, 0x77ef3018, 0x01881807, 0xdf140e0e, 0x0d0d0e14, 0x8770150d, 0x83e02021, 0xaf0e234a, 0x07851210, 0x18140e22,
+    0x02205282, 0x02218682, 0x83088380, 0x91088403, 0x261a8311, 0x21101038, 0x822e8918, 0x01012553, 0xe1140d0d, 0xb8200883, 0x00373787, 0xff000006,
+    0x01c001e0, 0x001400a0, 0x00380026, 0x005c004a, 0x4600006e, 0x112005f1, 0x2706ab7b, 0x26113736, 0x01272627, 0x240c9773, 0x23060714, 0x20119035,
+    0x9111a217, 0xa4671835, 0x079d6215, 0x113b6018, 0x8c0c5955, 0x0cdb430c, 0xbc76a020, 0x070e6313, 0x1805bc43, 0x4b0cc38f, 0x0c8c0c55, 0x2360268c,
+    0x0e374108, 0x414b3541, 0xc0204123, 0x85113641, 0x05fd5f11, 0x0f695e18, 0x8c1a1641, 0x180c8cfc, 0x200d4776, 0x16374226, 0x13420320, 0x15ef4110,
+    0xbc41a020, 0x00ff2121, 0x200e7345, 0x14bf4207, 0x89968020, 0x4123c142, 0xd3421179, 0x91239111, 0x42e39511, 0xfc8b19d3, 0x4118bb41, 0xc7412121,
+    0x0cc4420d, 0xc7410c8c, 0x8c198c0c, 0x07eb560c, 0x420d2344, 0x4b1815e9, 0x39411149, 0x41119111, 0xe2432327, 0x420c8c0c, 0x641815cc, 0xcf8c0c21,
+    0x0f4b0c8c, 0xb9db8b06, 0x41c7a3d9, 0xbaa20cd7, 0x330ca441, 0x10000300, 0xb001f0ff, 0x12009001, 0x36002400, 0x21250000, 0x106fb918, 0x21111157,
+    0x96180615, 0x9020101d, 0x4209e167, 0xb0200550, 0x20051d46, 0x08666d0e, 0xe0200f8f, 0x2308fd78, 0x5009090d, 0x200f5165, 0x44108fe0, 0xb36c0517,
+    0x00182205, 0x21a9822a, 0x5f191123, 0xa8740935, 0x37362406, 0x432f2635, 0x02211191, 0x215f8430, 0x8383e0fe, 0xbb4d5020, 0x42b02009, 0x002c0bfb,
+    0x0e168d01, 0x0e01010e, 0x73fe160e, 0x4109bd4d, 0x376d0cf7, 0x00bf2608, 0x00210010, 0x2485882f, 0x11331523, 0x257d8333, 0x06070127, 0x8e861107,
+    0x0720a083, 0x2a05aa44, 0x17163736, 0x23060714, 0x83303002, 0x607022d9, 0x25868370, 0x17c0e8fe, 0x09833001, 0x01300127, 0x30100c0b, 0xbe77180a,
+    0x01002308, 0x8e82154e, 0x80fe402e, 0x111f0d02, 0x32bf0101, 0x93fe1907, 0xdf2d0b85, 0x03090a10, 0x0909e1fe, 0x02021d0d, 0x2bc4821c, 0x00000100,
+    0xff01c2ff, 0x2800c001, 0x07229382, 0x85820633, 0x010f0622, 0x232f0783, 0x06072726, 0x01372627, 0x0f262736, 0x55372601, 0x172a0514, 0x07161716,
+    0x6283e301, 0xb1820103, 0x62931d2b, 0x2b2f3026, 0x11421b2c, 0x34748211, 0x0c090904, 0x0d07b20b, 0x45562c0d, 0x27304344, 0xcc220605, 0x2128852b,
+    0x1f822431, 0x0e420939, 0x0111110e, 0x090c0b03, 0x3a2fb309, 0x43552f3a, 0x26300304, 0x52383435, 0x42220d37, 0x8d824b00, 0x37272322, 0x21059757,
+    0x01832726, 0x9e839a84, 0x0a480720, 0x20148306, 0x07156123, 0x3f24a982, 0x32333601, 0x17219f84, 0x08388533, 0x37360347, 0x07061716, 0x10022726,
+    0x1d8c5a20, 0x201e0101, 0x05032020, 0x1e1e1516, 0x52061615, 0x26264141, 0x12120101, 0x0f30011b, 0x0d0d0101, 0x12183514, 0x27210909, 0x0a0d2022,
+    0x1d230b08, 0x0a1c2222, 0x77021011, 0x211d835a, 0x5218140e, 0x202d0898, 0x21124f60, 0x0c111122, 0x121c010c, 0x08418312, 0x2c081d24, 0x5446452c,
+    0x0111121b, 0x0e140f01, 0x1d20010d, 0x0e0f201f, 0x0b071919, 0x151a0a0c, 0x17170615, 0x19857e29, 0x59300121, 0xf38707c2, 0x0002c028, 0x4500c001,
+    0x57185200, 0xe08308bd, 0x84331521, 0x17162405, 0x82353736, 0x013d27e9, 0x36372627, 0xd071011f, 0x27118206, 0x27343527, 0x15232726, 0x102dc718,
+    0x16171123, 0x05534217, 0x07062324, 0xe0832015, 0x821ba021, 0x25083ea7, 0x02011919, 0x15021616, 0x0d200e0d, 0x4d10100d, 0x14140113, 0x14141f1f,
+    0x110b0c01, 0x05d34208, 0x85e0fe21, 0x01402307, 0xf682800f, 0xac7f0484, 0x19012409, 0x83202519, 0x059b2ebf, 0x40171011, 0x0d101020, 0x1b134d0d,
+    0x834383dd, 0x1120254b, 0x91010b0c, 0x220b1747, 0x83708001, 0x84602046, 0x00003304, 0xff000003, 0x014002e0, 0x004600a0, 0x00680057, 0xc3822500,
+    0x010f2623, 0x26d98206, 0x1736013f, 0x82011f16, 0x230727da, 0x07060726, 0xf0843637, 0x2f211682, 0x820f8201, 0x011d2124, 0x2207ee4a, 0x8233013f,
+    0x28e784e5, 0x34353736, 0x07060527, 0x09e67231, 0x07173222, 0x0805156d, 0x27222377, 0x36012f26, 0x15171633, 0x0a2d3e02, 0x0f262121, 0x0605030d,
+    0x10110e0e, 0x22270410, 0x4a3e3430, 0x2230343e, 0x10100427, 0x060e0e11, 0x100d0305, 0x0a212224, 0x2101022d, 0x2f253120, 0x03042020, 0x20040324,
+    0x31252f20, 0x02012120, 0x0e028dfe, 0x1625150e, 0x1c010e0e, 0x0423232d, 0x0e013501, 0x1525150f, 0x04020e0e, 0x1c2d2323, 0x1325b5a8, 0x06060b12,
+    0x0865820e, 0x07060422, 0x0b9a1109, 0x1c1c0201, 0x9a0b0102, 0x06070911, 0x0f0d0304, 0x0b06060e, 0xb5251312, 0x30460808, 0x01365282, 0x272d1e1d,
+    0x1e1d2d27, 0x21200101, 0x08084630, 0x0c0d145a, 0x65830101, 0x0d010c24, 0x5a820429, 0x0d0d0128, 0x010d2914, 0x2343250c, 0xc0012508, 0x18009f01,
+    0x2706cf68, 0x36253732, 0x25272637, 0x2508b378, 0x06070607, 0x8e450517, 0x09223d11, 0x01060615, 0x01011340, 0x0dc0fe13, 0x04060b0c, 0xf60c0505,
+    0x05050cf6, 0xfe7e0104, 0x20060256, 0x29078601, 0x02011374, 0x15150a7f, 0x88728009, 0x62622607, 0x0d0c0b06, 0x0ef34854, 0x04000323, 0x05eb60ff,
+    0x39003024, 0xc1425300, 0x6e332006, 0x2b21072c, 0x06c64201, 0x3205fa71, 0x2f26022f, 0x33372601, 0x33011f32, 0x27222335, 0x82312726, 0x82262008,
+    0x15232207, 0x20b78217, 0x07d44d21, 0x43322121, 0x152906cc, 0x7f310714, 0x0d090901, 0x06457f01, 0x6820a021, 0x2208058d, 0x0a0ff10e, 0x040f9057,
+    0x1b110217, 0xd0250a11, 0x09090da0, 0x80010101, 0x291b1b01, 0x2604f720, 0x84e7fe35, 0x273a8311, 0x03131b19, 0x0a0d0d0a, 0xd7492182, 0x02402609,
+    0x40442d2d, 0x291f820e, 0x10063a73, 0x0d02125c, 0xdc824033, 0x20e0fe2a, 0x011b1b29, 0x24049780, 0x0e207682, 0x13231f82, 0x83090904, 0x0300353d,
+    0x20000000, 0x60018002, 0x2e001e00, 0x00003f00, 0x010f0601, 0xc857bb82, 0x3f362508, 0x17161701, 0x2108af7e, 0xa4520605, 0x37362107, 0x9242f182,
+    0x2f222406, 0x43363701, 0x012f05db, 0x482b3cef, 0x3d3c2b48, 0x02022929, 0x8d3d2929, 0xdcfe310d, 0x17222218, 0x17010117, 0x18222217, 0x75014848,
+    0x17860987, 0x2a016026, 0x012a4848, 0x1e203983, 0x0e824283, 0x89294921, 0x18e8210e, 0x1e202f83, 0x3d824283, 0x07863920, 0xd3541485, 0x00322f0a,
+    0x2500003b, 0x26070615, 0x23063527, 0x09852722, 0x210bb571, 0xae851716, 0x2f22e782, 0x5a5d0601, 0x07063405, 0x26373637, 0x16070627, 0x02000117,
+    0x08021616, 0x83171908, 0x2c210807, 0x0201191a, 0x37523636, 0x1919182c, 0x2536381b, 0x0a010124, 0x0755070b, 0x191b3807, 0x13101819, 0x07fe44c0,
+    0x83332b21, 0x01292309, 0x07832f07, 0x2c194238, 0x3652362b, 0x1b010236, 0x010a0b0e, 0x36252401, 0x03040bf0, 0x3e837a09, 0x070a0e23, 0x08be5e9d,
+    0x0343bb85, 0x1605270a, 0x36373633, 0x1b562627, 0x21ba8206, 0x98830507, 0x3c120343, 0x06400134, 0x05091505, 0xf50c0605, 0x05050cf6, 0x0c0b0604,
+    0x13c0fe0d, 0x01130101, 0x0f03436c, 0x0280e228, 0x0c0d1301, 0xfa42060b, 0x2b2e8305, 0x15150980, 0x0909c209, 0x0a0a0d0d, 0x23050943, 0x05000000,
+    0x00320382, 0x80014002, 0x37002000, 0x51004400, 0x00005e00, 0xaa543337, 0x23069605, 0x35011521, 0x26088548, 0x06171615, 0x82211507, 0x37362110,
+    0x9718b982, 0x332109f1, 0x971f1906, 0x260c8c0a, 0x0f015000, 0x8d60010f, 0xfd502204, 0x2e8682c0, 0xfe140e0d, 0x0d0e1420, 0x02021e01, 0x8340021e,
+    0x80fe2105, 0x95099748, 0x1900200a, 0x200ae014, 0x240b8b20, 0x2d016060, 0x07824923, 0x210c2326, 0x53530c21, 0x5d200583, 0x9309d545, 0x09db4609,
+    0xc0017f31, 0x58002100, 0x23050000, 0x27373635, 0x82262706, 0x27352101, 0x1621f382, 0x0aec6c17, 0x2627362a, 0x36271723, 0x27263537, 0x2505795f,
+    0x27233536, 0xf7553b36, 0x26232108, 0x33201c82, 0x23213b82, 0x05521906, 0x23392b39, 0x514f0705, 0x0d02010e, 0x05834f4f, 0x1c01502a, 0x1a282a1c,
+    0x07b8011a, 0x230acd6d, 0x0e042210, 0x27165219, 0x1f051b27, 0x020e0d02, 0x23048221, 0x1b1b2a01, 0x29224f82, 0xef6d9132, 0x4606200a, 0x223008ef,
+    0x3b003400, 0x4a004200, 0x00005200, 0x31371613, 0x2106e85a, 0xd0821117, 0x82262721, 0x312221d4, 0x27210984, 0x22198211, 0x60133117, 0x16240cda,
+    0x07171617, 0x2723fe83, 0x82151115, 0x2337211f, 0x3805f146, 0x16273533, 0x17163117, 0x3b312335, 0x413c3c3c, 0x1a414142, 0x0e0f0101, 0x200d8313,
+    0x200d8201, 0x290e8540, 0x171623ee, 0x16170101, 0x51442123, 0x212a0805, 0x110140e0, 0x121c1c12, 0x01400111, 0x12121bc1, 0x01404001, 0x401b1212,
+    0x090f7101, 0x08121108, 0x1e0c1608, 0x0a12cafe, 0x0f890409, 0x13350122, 0xfe260f82, 0x1b1b01ef, 0xec82292a, 0x29200782, 0x4020f483, 0x01213f84,
+    0x26528411, 0x131201a0, 0x84d0411b, 0x00002259, 0x2cff8807, 0x00370014, 0x0047003f, 0x0055004e, 0x977c1867, 0x012f2115, 0x20221641, 0xa47c1826,
+    0x02fb2b2d, 0x02131012, 0x02021204, 0x04833112, 0x020e0423, 0x1c2941ca, 0x11014e26, 0x40401c12, 0x20101941, 0x82f18be1, 0xf12a21f9, 0x442c4e83,
+    0x01131202, 0x02121301, 0x8011042f, 0x26203941, 0x12121baf, 0x84c14001, 0x41812761, 0x1b131201, 0x68840101, 0x20013028, 0x20302f20, 0x07820120,
+    0x822f3021, 0x06eb4e07, 0x57440020, 0x00152605, 0x002b0020, 0xbb9e1838, 0x07062218, 0x05f24a16, 0x21152327, 0x27263736, 0x23108321, 0x15070625,
+    0x2108084a, 0x7d180002, 0x70201498, 0x08de8b18, 0x6001a022, 0xfe210b83, 0x260583a0, 0x02160801, 0x84501602, 0x80012104, 0x13827d18, 0x0f01a022,
+    0x0f202883, 0x08861d82, 0x0dcb5218, 0xc0830420, 0x01400224, 0xbb850080, 0xbb978420, 0xbb8a0720, 0xc6183320, 0x27200813, 0x79060544, 0x45180506,
+    0x07414a45, 0x18f02015, 0x2108f350, 0x0a88e0e0, 0x14016c24, 0x45180211, 0x44414633, 0x41802015, 0xa0251044, 0x12020212, 0x24451806, 0x82002046,
+    0x00013300, 0x01e0ff10, 0x009f01b0, 0x2500003f, 0x06310714, 0x455a012b, 0x013f2207, 0x08bf7723, 0x0a612b19, 0x07596218, 0x33010f23, 0x05c15e32,
+    0x0a843282, 0x09b00130, 0x41d40e09, 0x0909100b, 0x0703020b, 0x2a4c3f2a, 0x3f6a2205, 0x250885a9, 0x0d0841d4, 0x1a910c0c, 0x1e827020, 0x010d6223,
+    0x201d8305, 0x0536473e, 0x2006fb50, 0x8e2c8362, 0x06835f16, 0xc001002c, 0x43003100, 0x67005500, 0xbb857900, 0x14153022, 0x2405497c, 0x17140706,
+    0x23018216, 0x17161530, 0x07221282, 0x224e2322, 0x83362005, 0x833720bb, 0x17162419, 0x82062135, 0x78b818ed, 0x27342308, 0x777a2726, 0x62272008,
+    0x1622058d, 0x23903733, 0x6b7e1720, 0x363d840b, 0x15010002, 0x14621c14, 0x01010d0e, 0x01020503, 0x0e0f010b, 0x59050618, 0xfe2011f3, 0x180c0d52,
+    0x610c7f95, 0x0c8c0c60, 0x0102c136, 0x10111b01, 0x140e0e01, 0x0c0c0505, 0x14010303, 0x12121815, 0x0cdb1319, 0x2222012a, 0x0148393a, 0x0d090901,
+    0x26098e7a, 0x0e090940, 0x8709090d, 0x8d802015, 0x8d80201d, 0x05774d1d, 0x01c0012d, 0x000b00a0, 0x003b0021, 0x41353700, 0x372109dd, 0x0e821816,
+    0x26072c13, 0x27263127, 0x06072223, 0x1814011d, 0x24081242, 0x37363736, 0x898518c0, 0xc97c1807, 0x2a098809, 0x01304001, 0x48291b1b, 0x410c0b11,
+    0x302505e9, 0x011b1b29, 0x06716cc0, 0x0557e020, 0x83c02013, 0x0b0c2321, 0xdc85b811, 0x3f832020, 0x00820020, 0x3b460120, 0x4f3f2008, 0xa2180e19,
+    0x26280ff2, 0x35272627, 0x15141523, 0x2109a94a, 0x14842307, 0x27353422, 0x00200885, 0x08885a18, 0x0988c020, 0xc0210888, 0xa3401850, 0x0e142309,
+    0x0e86010d, 0x0b837020, 0x10212483, 0x88098710, 0x10102427, 0x8d6c0103, 0x02032249, 0x4510846b, 0xff2506bb, 0x018001c0, 0x019d18c0, 0x011f230b,
+    0x03873637, 0x17161728, 0x06070611, 0x0389012f, 0x1124c482, 0x17313736, 0x20141145, 0x26158935, 0x280c0e0e, 0x85101028, 0x6d0c2003, 0x119005e0,
+    0x010f5225, 0x84c00f01, 0x18058504, 0x280c804e, 0x06be01c0, 0x0c22220a, 0x2703850c, 0x0f07060a, 0x070f30fe, 0x0124138f, 0x8e070fd0, 0x2007a444,
+    0x10ad44e0, 0x08d77a18, 0x0c31e783, 0x31002c00, 0x48004300, 0x5f004d00, 0x00006c00, 0x05374237, 0x35013b27, 0x25072223, 0x416b1823, 0x18232009,
+    0x25124750, 0x33352303, 0x9c572715, 0x83172010, 0x95332016, 0x2637381b, 0x3315012b, 0x3d363732, 0x09273401, 0x0d0a0909, 0x0a0d2020, 0x4270c701,
+    0x70200577, 0x2c089178, 0x12121b40, 0x17160101, 0x4040d022, 0x059b5b20, 0x80230585, 0x8e604040, 0x85d72012, 0x09092145, 0x80260882, 0xc0090a0d,
+    0x8c758909, 0x21418307, 0x4b84f0fe, 0x1b121224, 0x5f831001, 0x20c0fe24, 0x115c7820, 0x21558208, 0x00822078, 0x3f20118c, 0x0a214382, 0x084b820d,
+    0x00010020, 0x01c4ff04, 0x00bc01fc, 0x17000031, 0x22312306, 0x3526012f, 0x17013f34, 0x2f363716, 0x06943701, 0x32333639, 0x1516011f, 0xb2010714,
+    0x0f13130f, 0x330e0e5c, 0x0a0b0b30, 0x932a300a, 0x86332006, 0xc4fe2523, 0x5c0e0e2e, 0x33250c83, 0x0b0a0a30, 0x922d820b, 0x86332006, 0xc4fe2123,
+    0x00289b82, 0x0002c0ff, 0x4400c001, 0x11249b82, 0x37363736, 0x2605f44d, 0x16070623, 0x8d153317, 0x17162606, 0x33353736, 0x22068c15, 0x77161716,
+    0x2126055c, 0x27262722, 0x70433534, 0x18502009, 0x1811aa88, 0x660c115b, 0xfe2808b7, 0x0d0d1360, 0xa0011003, 0x20076d43, 0x0d7d6630, 0x0d234892,
+    0x8360140e, 0x0d0c282d, 0x00030212, 0x82010000, 0x02402603, 0x00400180, 0x08334438, 0x0d94a78d, 0x2620bc89, 0xbb85bc82, 0x8a0efa66, 0x219e870e,
+    0x0984e0fd, 0x05831020, 0x118b9b91, 0x84085067, 0x82a38208, 0xc0ff27a7, 0xc0010001, 0xdb443100, 0x0d68410d, 0xba780d8d, 0x00112108, 0x77975088,
+    0x5f182088, 0x4d410978, 0x41d0840e, 0x0121087b, 0x0a8b6da0, 0x28000e31, 0x41003400, 0x5b004e00, 0x7a006800, 0x77010000, 0x23230777, 0x50352726,
+    0x162205e6, 0x65181115, 0x112a08c3, 0x3f363734, 0x011f3602, 0x4f183303, 0x032009cd, 0x200b7f4a, 0x08894a05, 0x05201582, 0xb77d1998, 0x40012611,
+    0x0f10010f, 0x06bf4e01, 0x117d9d24, 0xda830b0a, 0x28057a41, 0x7d110a0b, 0x8b13118b, 0xaf8618dd, 0x88a02008, 0x0120222a, 0x09f44e90, 0x9570fe21,
+    0x25b02617, 0x01011919, 0x2b671819, 0x40012409, 0x44100f01, 0x202b05e8, 0x1b1e010f, 0x110d0d05, 0x4514ddfe, 0x142d0564, 0x0d112301, 0x5d1b050d,
+    0xfe5d0a0a, 0x0a2a6462, 0xa6823482, 0x820f0121, 0x83502004, 0x200c8568, 0x8f108430, 0x38012115, 0x0f9b6718, 0x6b180020, 0xfe2908f7, 0x1300c001,
+    0x00001f00, 0x96721837, 0x4536200a, 0x2a080639, 0x07170701, 0x17161716, 0x27373337, 0x0b0b7580, 0x0f0f0b35, 0x1616750b, 0x171e1d17, 0x01803f01,
+    0x09090a53, 0x5f3e5206, 0x8375a93f, 0x0b353519, 0x1e17750b, 0x1616171d, 0x3e601701, 0x09090653, 0x4080530a, 0x00236a82, 0x62000004, 0x0b2c061b,
+    0x32001800, 0x00004b00, 0x23353313, 0x2507eb7f, 0x31171603, 0x10821716, 0x0607222a, 0x07222507, 0x30070631, 0x23211c83, 0x074d7215, 0x2726272c,
+    0x26132326, 0x010f0607, 0x14833215, 0x33250383, 0x37363716, 0x211a8236, 0x5e1820c0, 0x2b6a08e2, 0x080e8505, 0x1c1b5239, 0x1101161c, 0x3a2c1615,
+    0x30312927, 0x01222252, 0x46333302, 0x29313099, 0x15293a27, 0x03030f16, 0x1b1c1c16, 0x02333346, 0x52222201, 0x017f2101, 0x1b1a1212, 0x6a011212,
+    0x2f0805af, 0x1b12127f, 0x0e080980, 0x80090a0e, 0x04030c10, 0x2122120a, 0x18183024, 0x040a1801, 0x7f100c03, 0x010b0809, 0x08080f02, 0x30181802,
+    0x13212222, 0x44056b56, 0x342705d3, 0x58004600, 0x18250000, 0x21081593, 0xa9180706, 0xcb8208b0, 0x34352722, 0x08ca5118, 0x4a05a965, 0x30230556,
+    0x18391433, 0x2012dd83, 0x10994f17, 0x01a00125, 0x43140e0d, 0x3028095f, 0x010d0e14, 0x01191a2c, 0x3a22c982, 0x2a4a4839, 0x1a1a2205, 0x66ca862d,
+    0x0783079a, 0x46083849, 0x30210758, 0x203c8340, 0x9c611830, 0x83302009, 0x0140255b, 0x352e2d1f, 0x0b244118, 0x2d2e3525, 0x8bd0011f, 0x4341834a,
+    0x18870808, 0x66000021, 0x08360aa3, 0x2e002300, 0x45003300, 0x00005c00, 0x33171637, 0x07062327, 0xae181315, 0x96180b7c, 0x11310dd0, 0x26312726,
+    0x01373627, 0x33370706, 0x17272315, 0x06585827, 0x162d1382, 0x06171617, 0x27262707, 0x06012b26, 0x05744b15, 0x013b1624, 0x11823536, 0x01602729,
+    0x1660760f, 0x4ba0010f, 0x13411126, 0x37513005, 0x23010236, 0x3f300b01, 0x2033532d, 0x83232f6f, 0x7c8323f0, 0x18853f30, 0x061a5b37, 0x08110601,
+    0x19111204, 0x06020619, 0x11040810, 0x0f901812, 0x22578201, 0x85300140, 0x2d5a9142, 0x360240fe, 0x303f5137, 0x0123f5fe, 0x558220c0, 0x400f0127,
+    0x237c010f, 0x29168501, 0x061802ef, 0x0f180801, 0x0888010f, 0x33057b43, 0x02c0ff0f, 0x00c00130, 0x003d0020, 0x23062500, 0x07062726, 0x22210387,
+    0x30cf8227, 0x3336013f, 0x011f3221, 0x07060716, 0x37361731, 0x08fa4415, 0x1716352a, 0x32331631, 0x35211537, 0x31280683, 0x0706f001, 0x28191928,
+    0x29350386, 0x102a0606, 0x083a150f, 0x10640110, 0x0f153a08, 0x05042a10, 0x09054b07, 0x08060630, 0x01111308, 0x09121140, 0x0101e108, 0x03891c1c,
+    0x25250827, 0x0d0d5b25, 0x2406825b, 0x01012008, 0x072042c3, 0x0101c328, 0x85850501, 0x43690105, 0x0015280d, 0x00320026, 0x82341300, 0x213722ab,
+    0x20ab8216, 0x08bd7315, 0x33173126, 0x33353315, 0x0e4bb584, 0x33212105, 0x09c54518, 0x4c06003a, 0x8c011a0e, 0x064c0e1a, 0xfd100a0b, 0x0b0a10ca,
+    0x40c04040, 0x140e0d01, 0x4b05e046, 0x012b07bd, 0x72090b25, 0x14010114, 0x820b0972, 0x232c8224, 0xf0a0a045, 0x21071c45, 0x4518fff0, 0x002208c1,
+    0x58410300, 0x80012705, 0x27001300, 0x97833a00, 0x19313721, 0x210febea, 0x13913417, 0x4e210521, 0x43580693, 0x00232408, 0x580e0909, 0xfe250797,
+    0x09090e80, 0x21108f40, 0xbb556001, 0x4d01200f, 0xcd610c8b, 0x0dc85e0c, 0x0ce77b18, 0x09000433, 0x29000e00, 0xcb00c600, 0x07370000, 0x37273717,
+    0x82058227, 0x07272102, 0x241a2543, 0x2f060713, 0x26248201, 0x16011f36, 0x8217010f, 0x06d74b03, 0x013f2622, 0x0f9d3f82, 0x37822382, 0x33826782,
+    0x27200b82, 0x5b860f96, 0x1f873720, 0x6b860f96, 0x86371721, 0x0716221f, 0x22c58227, 0x822dbc07, 0x82712000, 0x5a2d2903, 0x2c2e2d2d, 0x3636432d,
+    0x22056c52, 0x8b433636, 0x0cbb350b, 0x2d1c0605, 0x06061022, 0x1105050b, 0x0b050511, 0x11100606, 0x22220d85, 0x0f841c2d, 0x841c1c21, 0x8626820f,
+    0x2b2d8d1f, 0x061c2d21, 0x04040c05, 0x04041d1d, 0x2e214d83, 0x853f8622, 0x8454822d, 0x824d965b, 0x227b8b74, 0x892e2211, 0x83a4204d, 0x83ed20bf,
+    0x83172004, 0x83882004, 0x34012404, 0x8e202001, 0x21d085c4, 0xc282e8fe, 0x569ba487, 0x0621a4b1, 0x82f28d11, 0x20f2afcb, 0x21bc8328, 0x974f0000,
+    0x00022f05, 0x2a00a001, 0x4c002f00, 0x27010000, 0x1a582b26, 0x06232d05, 0x15070607, 0x010f2223, 0x33011d06, 0x07f96518, 0x34270788, 0x3523012f,
+    0x58171533, 0x74180522, 0x152008c9, 0x27092a72, 0xf7011523, 0x330d092e, 0x24080a4a, 0x2e090d33, 0x05ff5709, 0x09230586, 0x6ea0a0a7, 0x10870571,
+    0x010e0925, 0x82090ec0, 0x4a2a8225, 0x3020081c, 0x0d210c82, 0x0b165863, 0x090d632a, 0xf0303037, 0x0f01010f, 0x20062e58, 0x05bd4f70, 0x4c207021,
+    0x8022064b, 0xd182b001, 0x14010022, 0x2324bf82, 0x11012f22, 0x2209bd4a, 0x4c270607, 0x362207fa, 0xca6c013b, 0x05e84c07, 0x07800228, 0x0b0f0a32,
+    0x7e443a09, 0x3b220808, 0x0a0f0b08, 0x870c0732, 0x06231814, 0x24241a1a, 0x22061a1a, 0x0c871419, 0x0a0a1d01, 0x2e070c3d, 0x9f49fbfe, 0x2e052c08,
+    0x3c0c0107, 0x0a0f0a0a, 0x7323106a, 0x23340582, 0x0f0a6a10, 0x00000300, 0x3f01c0ff, 0x1100c001, 0x5f004d00, 0x2614f578, 0x22312306, 0x82060715,
+    0x050f6baf, 0x36013f22, 0x2106855c, 0xa482021f, 0xc0820720, 0x26012f27, 0x1707012f, 0x05094616, 0x07a3831a, 0x82370721, 0x53388410, 0x3f230550,
+    0x62000101, 0x81240f86, 0x0b010101, 0x34b8601a, 0x03193a28, 0x040e2804, 0xc25c3d07, 0x4b3c2005, 0xf68709d0, 0x01019726, 0x04180b04, 0x2b07cf5a,
+    0x05162f04, 0x1f12130e, 0x0c070a25, 0x21080082, 0x0e050404, 0x41171008, 0x5c0c0936, 0x040b0a0e, 0x0d060703, 0x211b4d58, 0x043ec740, 0x09242d04,
+    0xdf5c3e07, 0x183b2005, 0x250d734c, 0x00350023, 0x4a180100, 0x0624092b, 0x21171607, 0x260d274d, 0x36373611, 0x18032137, 0x20105248, 0x065b6401,
+    0x0f90fe27, 0x010f0101, 0x087a5670, 0x21084860, 0x1e538001, 0x6301200c, 0x0121062c, 0x2330820f, 0xe01b1212, 0x01213187, 0x20098340, 0x7f8918fe,
+    0x0400220c, 0x07ab4e00, 0xa3821a20, 0x67004e24, 0xed5f0000, 0x18312005, 0x830f4daa, 0x05c652ae, 0x82070621, 0x16172101, 0x3622af82, 0xc74a3233,
+    0x31272205, 0x20b98527, 0x05784f35, 0x06072624, 0xe583011f, 0x3f331622, 0x2305f362, 0x3f161706, 0x2805da48, 0x36373233, 0x31273435, 0xff4b1802,
+    0xac220818, 0x1e15150c, 0x0c15151e, 0x0c0b0a09, 0x150e0f09, 0x090f0f16, 0x090a0c0b, 0x09090ea4, 0x03060e0b, 0x0483600d, 0xb0531f20, 0x1eb72605,
+    0x0e06030d, 0x20048360, 0x08d7530c, 0xd048c020, 0x05e84811, 0x0b0e7528, 0x0b01010b, 0x59820e0b, 0x090a0a25, 0x82090808, 0x0b0c2d05, 0x0e090965,
+    0x03030202, 0x20060e0d, 0x0a2c0483, 0x090e0e09, 0x060a3709, 0x20030d0e, 0x04220483, 0x94430203, 0x090e2105, 0x220ddb41, 0x41330013, 0x72470cdb,
+    0x21052208, 0x08f35511, 0x74633520, 0x42152007, 0x372405d5, 0x01113336, 0x20061d62, 0x061451fe, 0xfec00123, 0x07ed4140, 0x1b018027, 0x1b29291b,
+    0x07aa471b, 0x8207d441, 0x228582a5, 0x85e0fe60, 0x59802008, 0x80200747, 0x01210f85, 0x829b8320, 0xc0ff22a0, 0x33018201, 0x10000a00, 0x20001600,
+    0x40002600, 0x5e005200, 0x00006400, 0x20057a47, 0x06a27b33, 0x8e501620, 0x37362205, 0x083a442b, 0x07062726, 0x17373633, 0x270ad765, 0x17161716,
+    0x36373221, 0x3522c482, 0xd24c3736, 0x07937105, 0x36373624, 0x66481337, 0x27153c09, 0x16232726, 0x0806f017, 0x022e0207, 0x5e060807, 0x020c2c09,
+    0x0c022727, 0x8447092c, 0x22198310, 0x820a2b40, 0x01f92611, 0xfe140e0d, 0x00ae18d0, 0x0e402708, 0x0f010909, 0x4118010f, 0x90201048, 0x22074763,
+    0x82b92001, 0x2b0a354c, 0x14065f01, 0x14212114, 0x314f0614, 0x20291d15, 0x31151d29, 0x15830d83, 0x31156631, 0x01e61d29, 0x0d0e1420, 0x1b1b0101,
+    0x83c0fe29, 0x09092960, 0x5109120e, 0x1001160e, 0x200f747d, 0x063a41fe, 0x1daa4025, 0x43153129, 0x012f050f, 0x00c0017f, 0x00730061, 0x00970084,
+    0x5c362500, 0x3723065f, 0x82262736, 0x373622ee, 0x82e58226, 0x85058309, 0x05e34403, 0x07062722, 0x27210182, 0x85058326, 0x16172103, 0x16210784,
+    0x76018217, 0x098305bc, 0x77161721, 0x362006bd, 0x21051e58, 0x61842737, 0x4305034c, 0x2c830576, 0x17013f2f, 0x33303316, 0x26013f36, 0x06250727,
+    0x243a8207, 0x33303130, 0x07e35232, 0x20012e08, 0x0705060b, 0x080f0a08, 0x03020206, 0x010a0603, 0x03070a01, 0x06020102, 0x080b0e08, 0x0b060507,
+    0x0a0c100c, 0x0e0d0909, 0x0a090d0e, 0x8c0c820a, 0x8507202f, 0x0203212f, 0x0a202f8d, 0xb0242f8a, 0x22171601, 0x350b657d, 0x0909056e, 0x07152d0e,
+    0x060f010f, 0x20385322, 0x53385c01, 0x0d820622, 0x2d15072b, 0x0509090e, 0x0f085a20, 0x8b7a880a, 0x227a8c4a, 0x83020a06, 0xa37a84aa, 0x83aa862f,
+    0x7da620da, 0xf13b0ff4, 0x020b0b0d, 0x010d2a09, 0x3709520e, 0x09375252, 0x0d010e52, 0x0b02092a, 0x50520d0b, 0x002a050b, 0x01400200, 0x00160080,
+    0xdb440030, 0x47212006, 0x33280831, 0x16171621, 0x17251117, 0x2b077041, 0x012f3637, 0x26273637, 0x2627010f, 0x31201382, 0x12393a82, 0xcdfe1b12,
+    0x0997131a, 0x1a139709, 0x121b3301, 0xcffe0112, 0x0e0e2f2f, 0x36e01811, 0x1110240e, 0x83400e0e, 0x9613271e, 0x0a0d0d0a, 0xec5b1396, 0x30b02205,
+    0x12b9182f, 0x302f2109, 0x3d852583, 0x00820020, 0x00000430, 0x8002e0ff, 0x6700a001, 0x71006c00, 0x4e187600, 0x3d4f0991, 0x05684305, 0xa6832320,
+    0x18083962, 0x22088258, 0x44333736, 0x23200558, 0x9405de75, 0x37362421, 0x18233736, 0x200bb650, 0x05f25733, 0x35330726, 0x15071523, 0x05200582,
+    0x33290882, 0x0e146001, 0x1276010d, 0x072f4628, 0x42122827, 0x051b1c2c, 0x18168304, 0x2e0c1760, 0x1c1d0503, 0x401a0e2d, 0x1c2d0e1a, 0x9003051d,
+    0x0405251f, 0x432d1c1b, 0x7620488b, 0x38263f84, 0x30d03030, 0x03830130, 0x1083a020, 0x02220422, 0x2507594f, 0x2e1e2202, 0x658c392f, 0x57834020,
+    0x2727332b, 0x01011414, 0x27271414, 0x231d9133, 0x1e2e2f39, 0xaa84438b, 0x30306824, 0x008330f0, 0x46180020, 0x2f3d09ff, 0x00003a00, 0x36373605,
+    0x37272637, 0x013f1617, 0x26012f36, 0x1f06010f, 0x27260701, 0x06864f35, 0x17070622, 0x0714f118, 0x09831620, 0x35372724, 0x08821533, 0x37362132,
+    0x14244f01, 0x1a010118, 0x0b0c092b, 0x340a0a0b, 0x092b0584, 0x10151227, 0x0f01010f, 0x82020ee1, 0x10220805, 0x01191a2c, 0x25131901, 0x6018b7dd,
+    0xfe142518, 0x402513ff, 0x352a2001, 0x092b2c37, 0x0b0b0a0a, 0x0584340c, 0x11270929, 0x0e029a0c, 0x84010f20, 0x199a3104, 0x35362b2c, 0xfd01202a,
+    0x0db6b60d, 0x17262617, 0x2b065f49, 0x00c00180, 0x002a0012, 0x13000033, 0x2005d741, 0x05b74121, 0x33371725, 0x4e133717, 0x0584057f, 0x82272621,
+    0x068a4ec4, 0x08877b18, 0x1470e02d, 0xfe010d0e, 0x0e0d0180, 0x83201014, 0x01a02500, 0x401b1212, 0x1b220483, 0x0c481212, 0x80012205, 0x07ca58c0,
+    0x83c00121, 0xd0d02129, 0x40203583, 0xfe220082, 0x268920e0, 0x20223887, 0xa15e01b0, 0x42002006, 0xc02006bb, 0xc0203782, 0x4024a582, 0x64005200,
+    0x1625a982, 0x17163117, 0xad151911, 0x1135271d, 0x37363736, 0x2a821403, 0xfb183320, 0x00491084, 0x20218210, 0x07b65331, 0x1415062b, 0xe0331617,
+    0x023f3f60, 0x8c151909, 0x3f022413, 0x82a0603f, 0x4f012019, 0xff20063d, 0x10200783, 0x490c5c6f, 0xc0260d2b, 0x22171601, 0x2182b0fe, 0x20201786,
+    0x45830787, 0x17225024, 0x43840116, 0x695c0d82, 0x18802006, 0x670ca947, 0x01300cc1, 0xc0ff1f00, 0xc0012002, 0x00006c00, 0x06071425, 0x222b0182,
+    0x16151623, 0x22270607, 0x66272627, 0x1582050d, 0x27062326, 0x37343726, 0x2405695d, 0x35263122, 0x07564634, 0x3726352e, 0x33323336, 0x17323116,
+    0x36351716, 0x30211684, 0x23128233, 0x16313017, 0x16221282, 0x14821517, 0x16221084, 0x5f821407, 0x46081484, 0x08200215, 0x38252504, 0x03100809,
+    0x020a0607, 0x021c1413, 0x1c021616, 0x0a021314, 0x11030706, 0x24330909, 0x09010924, 0x14150109, 0x13132f22, 0x07040601, 0x06010101, 0x013b3030,
+    0x0f0f0f0e, 0x09040102, 0x82020509, 0x0e5e0809, 0x31303a01, 0x07020106, 0x13010604, 0x14222f13, 0x4a080215, 0x0e02050a, 0x0324020d, 0x03070709,
+    0x2b120808, 0x15020216, 0x0808122b, 0x09070703, 0x0c012305, 0x0a05060c, 0x09010509, 0x323c0708, 0x06090632, 0x12110105, 0x313b052d, 0x041d1d30,
+    0x1d040707, 0x3b30311d, 0x11122d05, 0x1c820501, 0x3c323229, 0x01090807, 0x66000905, 0xa027087b, 0x33001900, 0x59370000, 0x0c1908c5, 0x172009d7,
+    0x96059875, 0x01072719, 0x0d0d0ab7, 0x734b500a, 0x8a382105, 0x2005d44b, 0x200683a0, 0x21138580, 0x1385ea68, 0xc900ff25, 0x85500909, 0x8a3a210b,
+    0xa0241b85, 0x800909e0, 0x6a211285, 0x211285ea, 0x008300ff, 0x0000023c, 0x3f02c0ff, 0x1c00c001, 0x00003c00, 0x37352305, 0x27262736, 0x06070621,
+    0x6665011f, 0x064e490e, 0xb2823620, 0x2207bf47, 0x53072722, 0x262005f8, 0x4e083482, 0xa9302001, 0x1106060b, 0x061192fe, 0x30a90b06, 0x0209090e,
+    0x010ebf0d, 0x0e080902, 0x24243090, 0x160d340f, 0x1a291b15, 0x1b01011b, 0x1215281b, 0x3d292224, 0x01012928, 0x103d2829, 0x0e0da97d, 0x0e01010e,
+    0x7da90d0e, 0x0f0e0909, 0x820f0101, 0xd001283e, 0x2b1a1a01, 0x4a0d0d16, 0x09230722, 0x18011424, 0x20075a4f, 0x29bb8200, 0xff010000, 0x18008001,
+    0x09822300, 0x07623520, 0x17142407, 0x53013b16, 0x1720096a, 0x2108cd82, 0x36211716, 0x01272637, 0x02161018, 0x15511602, 0x09070702, 0x38385611,
+    0x02c00102, 0xd0563838, 0x178230fe, 0xd001152b, 0x16010216, 0x02212f01, 0x300e8316, 0x2108070a, 0x593d3e0b, 0x0b3e3d59, 0x171502ff, 0x39038302,
+    0x00040000, 0x01d1ff10, 0x00af01f0, 0x0030001e, 0x00540042, 0x26272500, 0x0283012f, 0x06010f22, 0x1f220282, 0x02851601, 0x18050a4e, 0x20129f7d,
+    0x11b25c37, 0x01311190, 0x1d060cef, 0x48271d33, 0x24412328, 0x06122013, 0x210e860b, 0x0e824024, 0xfe06132a, 0x09080ec1, 0x0d0d0909, 0x08220482,
+    0x0c85200e, 0xa0200585, 0xc122198b, 0x46822748, 0x11223d82, 0x3a821222, 0x0e832820, 0x0b071c23, 0x200e8606, 0x88428270, 0x869f202e, 0x2055844f,
+    0x89198b7f, 0x00b028f7, 0x00320020, 0x82560044, 0x272623f7, 0x174a2631, 0x23f9cd05, 0x01222133, 0x02210382, 0x8deb8427, 0x112122fa, 0x82fa8205,
+    0x0e0921f4, 0x4405ee44, 0xb3530ce7, 0x2202240d, 0x82013321, 0x11052303, 0xfb871321, 0x0a411d20, 0x6f272108, 0xfb90ee8b, 0x63830d20, 0x05820d20,
+    0x43000021, 0x002b0527, 0x1c00c001, 0x00003900, 0x19153337, 0x2819a882, 0x33352301, 0x17161716, 0x09296111, 0x0714152f, 0x27222306, 0x80113526,
+    0x121be0e0, 0x65b71812, 0x45202007, 0x01210554, 0x27159300, 0x12014040, 0x00011b12, 0xe4862385, 0x01a0fe23, 0x20178400, 0x24178dff, 0x09006001,
+    0x29008200, 0x80018002, 0x21001400, 0xa7822c00, 0x53004628, 0x6d006000, 0x4b767800, 0x36052216, 0x20a98237, 0x050a5215, 0x2621052b, 0x21373627,
+    0x07141716, 0x062d5227, 0x33201884, 0x666a0c99, 0x8b35200b, 0x2317210c, 0x5b824b83, 0x02070624, 0x4366fe40, 0x0a456508, 0x07010025, 0x85010710,
+    0xff102704, 0x02010f00, 0x0582010d, 0x89d00f21, 0x94402017, 0x8960200a, 0x10012415, 0x840110fe, 0xa0d02104, 0x65089066, 0xe8201532, 0x07226b87,
+    0xd7475810, 0x88482007, 0x8a8a8980, 0x25318909, 0x0202104a, 0x04845c10, 0x14489220, 0x0b4f500a, 0x45002c26, 0x00005e00, 0x20054f7f, 0x05ce4a31,
+    0x0d7e1620, 0x05204306, 0xfd590520, 0x4b032010, 0x33201789, 0x45501897, 0x41012018, 0xd14a0862, 0x249b2c07, 0x0b0a0a24, 0x0b25250b, 0x8b0a0a0b,
+    0x98c0200b, 0x17465018, 0x2c5aa020, 0x0501210f, 0x55975691, 0xe7491785, 0x00023805, 0x4000c001, 0x61005200, 0x14010000, 0x07061707, 0x16072327,
+    0x18373233, 0x310a31de, 0x22070607, 0x0f060727, 0x26270601, 0x3f34013d, 0x884e2601, 0x16172105, 0x37220182, 0x41183526, 0x5a180813, 0x1325116d,
+    0x16173736, 0x0858821d, 0x012f0639, 0x01012f26, 0x24350960, 0x43013434, 0x2e352420, 0x0c091f2d, 0x020a0b0d, 0x3b280801, 0x3035443a, 0x380c0838,
+    0x06080708, 0x0810133c, 0x0b0a0201, 0x09090c0d, 0x46094609, 0x05580767, 0x3274240c, 0x82062c28, 0x0c38342c, 0x60012908, 0x275b1216, 0x0a76590f,
+    0x0a281617, 0x83090201, 0x1d323256, 0x6212011c, 0x041b070c, 0x37090504, 0x11680b0d, 0x27508414, 0x0c0a0102, 0x16127809, 0x1807f64f, 0x080c74a8,
+    0x13f6fe20, 0x0d0b4c22, 0x04050937, 0x0c071b04, 0x02000046, 0xe0ff0000, 0x9f01ff01, 0x5e003a00, 0x9b4d0000, 0x27ff8206, 0x30313023, 0x06072231,
+    0x15220184, 0x216e1716, 0x83078405, 0x17162419, 0x85373615, 0x26078313, 0x07272627, 0x18013930, 0x8309656e, 0x17322923, 0x16170607, 0x013f3233,
+    0x3b07ba47, 0x1146af01, 0x6b130e0a, 0x0c1f1f26, 0x2e29280f, 0x0221212e, 0x16024403, 0x3c350116, 0x02220582, 0x0583313e, 0x02453e08, 0x23161601,
+    0x3a3b58b0, 0x3a3b0202, 0x3f191a58, 0x0c080a11, 0x286d0607, 0x03011617, 0x01593b3a, 0x130e2e46, 0x07460a11, 0x03020201, 0x17170a0b, 0x1f2fa028,
+    0x02021666, 0x030e7716, 0x23078368, 0x770e0368, 0x21080783, 0xa02f1f66, 0x0c151520, 0x13120197, 0x11121b1b, 0x0e280201, 0x47040c13, 0x100d0e08,
+    0x0112131b, 0xb7650500, 0x001c2f08, 0x0037002a, 0x00550047, 0x07220100, 0x02830631, 0x4205295c, 0x3521062c, 0x22e58226, 0x4d072326, 0x172409ea,
+    0x06170716, 0x2307c67f, 0x37230617, 0x26833484, 0x33363526, 0x17151732, 0xfc8a0a82, 0x4150202c, 0x01262741, 0x41272601, 0x0b8b5041, 0x1507533a,
+    0x0123223b, 0x38222101, 0x53080f1a, 0x11061d20, 0x10161610, 0x201d0611, 0x3e084f4c, 0x1f21211f, 0x0807152f, 0x22381a0f, 0x23010121, 0xa0013a23,
+    0x1d1c1211, 0x1d24c024, 0x8a11121c, 0x1a9e380a, 0x13130a0f, 0x12121717, 0x1d1a2c0a, 0x14040132, 0x0c0d0d0c, 0x43900314, 0x0d3107a6, 0x870d0303,
+    0x1b1d1a0f, 0x12130a2c, 0x13131717, 0x22f2820a, 0x5effffff, 0x2525057f, 0x07250000, 0x06577733, 0x06072724, 0x61542627, 0x059b5106, 0x07bd7718,
+    0x0107063c, 0x0b5e74d3, 0x2c56850e, 0x445a4142, 0x0e0e1111, 0x0b0907fe, 0x2c0da90b, 0x0082492c, 0x0e2d2f08, 0x02010a0a, 0xcf170a0a, 0x3515162f,
+    0x14111028, 0x110e0e44, 0x0a0bfd11, 0x72a80a0a, 0x26274747, 0x01020f0f, 0x230e0a0a, 0x003d3838, 0x84180500, 0x27240cb7, 0x5f003400, 0x84189482,
+    0x272019bb, 0x200b4546, 0x210c8b15, 0x66581617, 0x07262d05, 0x06010f26, 0x2f26012b, 0x07060701, 0x20051b46, 0x24ca8232, 0x011f1637, 0x22248236,
+    0x18013b16, 0x2517e384, 0x500701a0, 0x048e0107, 0x010ff036, 0x1a2f0f01, 0x0504060d, 0x09050805, 0x11040a01, 0x0c1e0b0b, 0x0c301583, 0x06120308,
+    0x0e061111, 0x0a141410, 0x012f0703, 0x08568418, 0x8367fe20, 0x30012508, 0x380e0909, 0x2009df45, 0x220a8940, 0x820f01f8, 0x08172545, 0x0f070102,
+    0x32235782, 0x83021b20, 0x36082b11, 0x10010110, 0x04040c29, 0xcb440613, 0x80012305, 0x0982c001, 0x31001a2a, 0x23010000, 0x33071735, 0x2b0ad662,
+    0x37363736, 0x17141533, 0x010f3316, 0x28059870, 0x22232627, 0x011f0607, 0x24f58216, 0x01072627, 0x24008380, 0x140e0d01, 0x052a5dfe, 0xb0200982,
+    0x013b9482, 0x16160227, 0x0a062802, 0x0e0e070a, 0x50111150, 0x11110e0e, 0x80804001, 0x58d0fe20, 0xa02008ac, 0x802e0983, 0x8709090e, 0x02166627,
+    0x27661602, 0x2a840707, 0x0e223082, 0x9f85000e, 0x823f0221, 0x001d279f, 0x00350021, 0x8d823700, 0x22233526, 0x013d2627, 0x280e4367, 0x27262335,
+    0x27331513, 0x82938201, 0x1523249d, 0x83060733, 0x23a583b7, 0xa81602c0, 0xb0206583, 0x0d878e18, 0x0216a822, 0x01218f82, 0x226c8438, 0x866e6e28,
+    0x880f247c, 0x82800216, 0x848020c1, 0x086a41d4, 0x16028028, 0x80803801, 0xc984d9fe, 0x27302723, 0x87da8707, 0x820020a7, 0x000322a7, 0x20a7832d,
+    0x09634201, 0x26200982, 0x26068b5c, 0x35262706, 0x18013f34, 0x2c106786, 0x16070605, 0x23353317, 0x80808001, 0x23a48420, 0x0e0e27ae, 0x23070841,
+    0xae270707, 0x0d608618, 0x16b8fe27, 0x68160202, 0x09114268, 0x1127f023, 0x07664111, 0x27219783, 0x20ea8880, 0x28ca8230, 0x161602a0, 0x00003002,
+    0x0a0f4307, 0x1f000822, 0x20085949, 0x25af8300, 0x33152313, 0x47192735, 0x1843156c, 0x49012019, 0x80490c39, 0x37362606, 0x01171633, 0x22cd8200,
+    0x4140c0c0, 0x7f230e75, 0x43090a0e, 0x0121140a, 0x0a1b4300, 0x856e0f20, 0x80c02708, 0x4000ff80, 0x8e418040, 0x1af9420e, 0x43d0fe21, 0xc8210905,
+    0x089b7360, 0x0f440020, 0x42752013, 0x27201cf3, 0x7a0bb365, 0x16230a51, 0x4727011f, 0x37210acd, 0x430d8236, 0x0620051d, 0x0b097118, 0x18820c82,
+    0x42233021, 0x16270592, 0x17161517, 0x64353736, 0x37430523, 0x41c02017, 0x08200904, 0x3e092e44, 0x0310077e, 0x09010204, 0x09080b09, 0x10040812,
+    0x1202080b, 0x07230212, 0x10131303, 0x85041506, 0x0c0b231a, 0x1c820401, 0x0c041123, 0x221d860d, 0x43121514, 0x48201872, 0x20092441, 0x09884a48,
+    0x05029d22, 0x063d6882, 0x01020202, 0x11110404, 0x07010408, 0x12020212, 0x1f200806, 0x01040c0d, 0x04030406, 0x291c8205, 0x04020502, 0x02071211,
+    0x1e890304, 0x00040d23, 0x085f4204, 0x0b000731, 0x4b002200, 0x23370000, 0x37363315, 0x45372726, 0x33601975, 0x07cd5d13, 0x84693620, 0x07062d05,
+    0x17363717, 0x0f3030b0, 0x500f0101, 0x43072543, 0x452c0d15, 0x1e09090b, 0x0b09091e, 0x1e1e0b0c, 0x09270482, 0x133a1d09, 0x84100f01, 0x121b2632,
+    0x1f020112, 0x26178221, 0x0f0120d0, 0x44f0010f, 0x4b4508b5, 0x0bbc220d, 0x2d3d820b, 0x0a0b0b0c, 0x0a1e1e0a, 0x0c0b0b0a, 0x74843b1e, 0x4682a020,
+    0x1b121228, 0x1d211226, 0x47530a0a, 0x40023c08, 0x0900c001, 0x16001200, 0x00005700, 0x011d0625, 0x013f3233, 0x27250727, 0x82010f26, 0x252721b2,
+    0x1122f682, 0x36462726, 0x35172420, 0x44013f34, 0x013817d9, 0x073e0525, 0x9e449d05, 0x12201401, 0x1b441c12, 0xc7fe0f10, 0x0c1a8080, 0x22203546,
+    0x44770906, 0x803712f8, 0x3e07056a, 0x9d449e05, 0x0f0f1faf, 0x121c441b, 0x8080a712, 0x460140fe, 0x05261b2c, 0x0a0d4501, 0x17452f75, 0x18102011,
+    0x210cb785, 0x47460003, 0x19ed4105, 0x23061725, 0x53012f22, 0x07200555, 0x23050748, 0x0716011f, 0x29173547, 0x0a0a0640, 0x16022707, 0xe2440216,
+    0x440f2009, 0x0a4709f8, 0x08d8220e, 0x07494607, 0x82084045, 0x00022fa0, 0x01c2ff03, 0x00c001ef, 0x0035001f, 0xaa521300, 0x15162105, 0x2507995f,
+    0x3f343526, 0x05822701, 0x07241885, 0x37210706, 0x20056c56, 0x20248217, 0x33b18407, 0x1635a807, 0x97161d1d, 0x1ebe1515, 0x751e2626, 0x525c1c1c,
+    0x2d057f52, 0x02065c51, 0x052a3f01, 0x06069705, 0x13853235, 0x015c3127, 0x15153565, 0x23328397, 0x751d1dbe, 0x5d203283, 0x2b06ca52, 0x0707b652,
+    0x97060629, 0x31350505, 0x2405c952, 0x00005c32, 0x22a38203, 0x824002c0, 0x002124a3, 0x824f0038, 0x333625a5, 0x011f3231, 0x3122ab99, 0xa9922717,
+    0x67312721, 0x3623059d, 0x5a173233, 0x31210b9c, 0x206b8329, 0x21c49351, 0xc19231b0, 0x1201e72c, 0x08050f11, 0x110f0508, 0x374d0112, 0x09b72308,
+    0xd7955209, 0x5c32de25, 0x8c2a0807, 0x15d92ad6, 0x07182020, 0x20201807, 0x07254a15, 0x06000022, 0x2208134a, 0x823a0010, 0x006a2ce7, 0x009f007d,
+    0x07062500, 0x82060716, 0x373621b1, 0x35280182, 0x06012f26, 0x15063107, 0x16201385, 0x27211383, 0x5b058234, 0x37260a94, 0x27363536, 0x29822726,
+    0x8a072621, 0x36272828, 0x36373627, 0x83223727, 0x06e0534d, 0x32204583, 0x27212f87, 0x832f8217, 0x1615301c, 0x36171615, 0x36313437, 0x2726012f,
+    0x82272631, 0x011d2732, 0x31321716, 0x2d823130, 0x19013d21, 0x820818b8, 0x013c084f, 0x02021500, 0x0505031e, 0x0a061110, 0x1602090a, 0x1c1c2f01,
+    0x05020e01, 0x080a0a05, 0x010f0308, 0x181b0e0e, 0x01011010, 0x0506020b, 0x07060f0a, 0x1d02010c, 0x136e2c1e, 0x0a01270f, 0x3b081286, 0x01010b01,
+    0x6c100e1b, 0x03151716, 0x11121507, 0x0227283a, 0x16010601, 0x0707070c, 0x34350301, 0x1607fd4f, 0x02060509, 0x16020104, 0x08020216, 0x38382529,
+    0x474a6c40, 0x09011503, 0x38312182, 0x2d35573d, 0x130e1f2e, 0x02ca0b10, 0x09686c15, 0x314f820a, 0x38392510, 0x5202164b, 0x291e1d01, 0x09094649,
+    0x92830208, 0x154c4c22, 0x10248b83, 0x48471710, 0x02319e82, 0x05080801, 0x1d2c4c4b, 0x0d13021d, 0x393f3110, 0x82288337, 0x3d042914, 0x12242d3d,
+    0x06053f0f, 0x043e9282, 0x39262602, 0x05163938, 0x3c070707, 0x34334c3c, 0x02157a03, 0x0a080803, 0x110e0e10, 0xf2820316, 0x5b281f3c, 0x011e1d35,
+    0x15664849, 0x06070316, 0x3a51180a, 0x1818013b, 0x0e0b112b, 0x00820013, 0x0000022e, 0x40021000, 0x2c007001, 0x00003e00, 0x2105c079, 0x01861716,
+    0x2108615d, 0x01832726, 0x2a05fc43, 0x36372627, 0x3736011f, 0x74221731, 0x232c0eac, 0x27271db5, 0x27273030, 0x15141d1e, 0x0a24c482, 0x1e1d1415,
+    0x1d311185, 0x155a1219, 0x2e0a0f12, 0x120f0a2e, 0x19125a15, 0x0c2d58eb, 0x121a3233, 0x11010111, 0x1a191a12, 0x0f0f151b, 0x1a1b1a15, 0x23118519,
+    0x35171519, 0x50213283, 0x233e8350, 0x52151635, 0x210c0b58, 0x57610006, 0x00082207, 0x30c38211, 0x00490037, 0x3700005b, 0x27260706, 0x17163736,
+    0x22088633, 0x4d06011f, 0x757506cb, 0x77052011, 0x28510ac3, 0x05cb4d10, 0xe6421620, 0x243c8306, 0x161602b8, 0x20038302, 0x200887c0, 0x18db6988,
+    0x4218c020, 0x0f21088f, 0x6f421820, 0x19078707, 0x230dc02f, 0xe01f1414, 0x55875685, 0x20160222, 0x21171551, 0x1e5a0190, 0x18682006, 0x87070c43,
+    0x8f902007, 0x6b5f1810, 0x01002a08, 0x001a00c0, 0x003e002c, 0x1c2b5254, 0x21087076, 0xf7582223, 0x37332705, 0x06310722, 0x4e751607, 0x34352405,
+    0x83232627, 0x3637220c, 0x05135d27, 0xb6430620, 0x31372105, 0x20182152, 0x05eb41b0, 0xf9750d20, 0x76a02006, 0x09370a02, 0x2c4c0e09, 0x07080925,
+    0x1b1a0d04, 0x1b1b2323, 0x0707030d, 0x622c250a, 0x10201857, 0x18476b18, 0x1001c134, 0x0a050503, 0x0112121d, 0x1d121201, 0x0405050a, 0xe342010f,
+    0xc0ff2306, 0xff82ff01, 0x22001d28, 0x36010000, 0x65583127, 0x20bd8209, 0x4c5d1815, 0x23350808, 0x010f3735, 0x01212723, 0x08080ff6, 0x1744fe17,
+    0xd60f0808, 0x0e0d1431, 0x0fe00f01, 0x0e0d0101, 0x61d52f14, 0x0140aa40, 0x1286012a, 0x02021313, 0xd6121313, 0x821783b0, 0x140f291d, 0xb0010d0e,
+    0x404006d6, 0x02207482, 0x22089742, 0x636a001a, 0x252f1ceb, 0x011d1617, 0x3f161714, 0x011f3601, 0x85323316, 0x06172707, 0x2f06010f, 0x4a672601,
+    0x17162106, 0x7118a382, 0x21820746, 0x34013d22, 0x37210582, 0x20218234, 0x83368337, 0x27262604, 0x07222726, 0x19ee6331, 0xb2fe2008, 0x0c04040a,
+    0x0c080e0a, 0x0a07040f, 0x06050407, 0x01010c1d, 0x0c0b2410, 0x0c050420, 0x83102708, 0x0f2032c8, 0x0e090901, 0x0d190a10, 0x01130606, 0x07072108,
+    0x29f68209, 0x1c0b070b, 0x49363514, 0x9841242a, 0x12c12d18, 0x06290907, 0x110a0904, 0x03070509, 0x22085d82, 0x0e060f03, 0x03090511, 0x07020a04,
+    0x1c140c1d, 0x010d0e14, 0x0e300f01, 0x220d0909, 0x070c1412, 0x82060102, 0x08213005, 0x05030806, 0x020b1104, 0x2a2a4305, 0x4d000f01, 0x1a240b9b,
+    0x66005700, 0x261f3d41, 0x1716011f, 0x41171615, 0x3721051d, 0x05f65836, 0x34353728, 0x2726012f, 0x05832223, 0x53412620, 0x36372105, 0x0a820c82,
+    0x22012f29, 0x06070623, 0x82253107, 0x82062004, 0x011f243e, 0x65263536, 0xfe261b28, 0x190d093a, 0xbe821d39, 0x010f3b08, 0x190c0909, 0x18070208,
+    0x0e011708, 0x2c140e04, 0x07220f10, 0x060f0502, 0x0e180a0a, 0x0e080708, 0x0e0f100f, 0x0505030a, 0x15353547, 0x0c1a7c01, 0x10040505, 0x021d1106,
+    0x3a411901, 0x11403418, 0x09110717, 0x0712281d, 0x0c27110a, 0x08030607, 0x821b0b19, 0x081c225c, 0x08058214, 0x14070129, 0x09100704, 0x07040503,
+    0x0b0c0b04, 0x13141510, 0x01041411, 0x25402728, 0x0b0b050a, 0x0411320d, 0x380e0e08, 0x4206002d, 0x47280a73, 0x72006600, 0x89007d00, 0x361c3d41,
+    0x3f161705, 0x16173601, 0x3316011f, 0x2f363732, 0x36372601, 0x8236013b, 0x820a8413, 0x013f2d07, 0x07062326, 0x17160706, 0x06070531, 0x27211582,
+    0x056c5906, 0x82060721, 0x263e8434, 0x3736011f, 0x82310726, 0x2541844b, 0x31170607, 0x19840637, 0x0f262724, 0x0f823701, 0x27206483, 0x9a422282,
+    0x345d081a, 0x10090d1f, 0x060c0b09, 0x0b120809, 0x06030607, 0x0c070703, 0x0b0d1403, 0x08100908, 0x110d0404, 0x2010050c, 0x3b3b5826, 0x01040102,
+    0x070b0f8e, 0x13110a02, 0x04020609, 0x04050d25, 0x0e060705, 0x10040f0e, 0x1139010e, 0xdafe0504, 0x02050f20, 0x040f200e, 0x03510e03, 0x08050f0e,
+    0x261c8202, 0x06105508, 0x84070e0d, 0x18884104, 0x07274508, 0x0a0f0902, 0x120b0302, 0x0b08090f, 0x0a090c14, 0x0e101101, 0x0c0b150e, 0x0205040b,
+    0x020c290b, 0x14583b3b, 0x02050513, 0x010f0309, 0x030a0f01, 0x0e081501, 0x0e0d0e0f, 0x02050606, 0x2e010904, 0x44010149, 0x79836f85, 0x88882820,
+    0x20cf2026, 0x0d06070e, 0x00200484, 0x0b200082, 0x320aab41, 0x002a0022, 0x0034002f, 0x003e0039, 0x004e0046, 0x45720060, 0x05281ca1, 0x32331523,
+    0x27373637, 0x26250782, 0x07232627, 0x20088235, 0x26048315, 0x35331527, 0x82011d23, 0x35272704, 0x06072223, 0x16823307, 0x16171624, 0xc345013b,
+    0x3e661911, 0x8207200c, 0x45332024, 0x013018bf, 0x1208378f, 0x2f030d0d, 0x0d033708, 0x4018120d, 0x90200082, 0x40210382, 0x20168410, 0x21158437,
+    0xd6450808, 0x45a0200d, 0x73410df4, 0x28683018, 0x38110c0b, 0x0b0c1128, 0x38282828, 0x84602828, 0x88102005, 0x45e02015, 0x002018f0, 0x5d0edb46,
+    0x0759060f, 0x2726251b, 0x17060726, 0x2007cd47, 0x220d8336, 0x46273107, 0x1b4110df, 0x4700352b, 0x06070a3c, 0x28281403, 0x28283433, 0x06070413,
+    0x50483c0a, 0x35350b41, 0x0312014c, 0x2d0a0606, 0x01011b1b, 0x0a2d1b1b, 0x12030606, 0x00419c01, 0x4204201b, 0xffb80a47, 0xc7490620, 0x36172806,
+    0x34353637, 0x82272627, 0xbc7c1808, 0x14152409, 0x42171617, 0xff95191b, 0x420bdd49, 0x12850609, 0x94180742, 0x4ccc20fb, 0x122208c6, 0x2b741b12,
+    0x0d034117, 0x93006222, 0x421d3d43, 0x36201503, 0x82083a6a, 0x31372bee, 0x22313433, 0x34373433, 0x9e7f3637, 0x15162f0a, 0x31301716, 0x31331530,
+    0x37313716, 0x33ad3716, 0x362e4241, 0x1001051d, 0x0f18180f, 0x05060110, 0x01010103, 0x03030102, 0x820e0202, 0x02022400, 0x82010303, 0x06032400,
+    0xa0060397, 0x2d704125, 0x0602642e, 0x0215151c, 0x1c151502, 0x04010206, 0x012c6582, 0x02040301, 0x01010c02, 0x0402020c, 0x16827784, 0x01040322,
+    0x002228a3, 0x9f420500, 0x001c2a08, 0x0054003e, 0x00b70086, 0x05bb4d00, 0x30373423, 0x065f4131, 0x82161721, 0x07142701, 0x23060706, 0xba5c2731,
+    0x23118305, 0x15163732, 0xd7181382, 0x31210e70, 0x77c14111, 0xd0012408, 0x010d0e14, 0x0a070105, 0x0606080b, 0x010f0e0c, 0x060f0a0a, 0x3d4ed007,
+    0x01060202, 0x21171701, 0x4c150d0e, 0x2044110b, 0x47dd4113, 0x40012608, 0x140d0d01, 0x01010a08, 0x0a101010, 0x170f0606, 0x0c111018, 0x8002040c,
+    0x05052801, 0x1622120c, 0x2f050116, 0x11484c36, 0x44b4fe21, 0xfe41136b, 0x0cf76e4f, 0x49003024, 0x9b436100, 0x07262633, 0x010f0631, 0x2d4e1827,
+    0x054f4808, 0x17312722, 0x07b46218, 0x4c05db58, 0x28820591, 0x322e6943, 0x0c0c0d39, 0x0d110404, 0x03040c0b, 0x410e0706, 0x8312050e, 0x049b2a07,
+    0x0e0d0c0c, 0x12030607, 0x82138205, 0x0c042507, 0x04100e0b, 0x202d4f43, 0x264983cb, 0x07040410, 0x820e0e06, 0x0311235f, 0x6783420e, 0x57831820,
+    0x0d244f82, 0x11030e42, 0x0e270782, 0x0407060e, 0x41001004, 0x46220e2f, 0x2f415d00, 0x06152637, 0x0607011f, 0x05584c17, 0x2f343532, 0x27340501,
+    0x010f2631, 0x1f141506, 0x36371601, 0x05821283, 0x2019b44d, 0x14d84501, 0x05077a39, 0x24040106, 0x06010424, 0x08590705, 0x06015908, 0x5a060506,
+    0x825a0808, 0x24032306, 0x1e410324, 0x03b9232d, 0xf8820303, 0x042b2b24, 0x0a820704, 0x09043026, 0x0a300409, 0x1e890a89, 0x370c137a, 0x0046001c,
+    0x0073005d, 0x009d0089, 0x33360100, 0x16173231, 0x06071415, 0x222e0182, 0x22312207, 0x34373637, 0x36313437, 0x13843137, 0x82170621, 0x201382f0,
+    0x210d8516, 0x0b823627, 0x2205fb47, 0x83260706, 0x3637260b, 0x26173117, 0x08e75e07, 0x30861420, 0x31273625, 0x84011f05, 0x013f210d, 0x0f213182,
+    0x28628201, 0x31171617, 0x31170637, 0x20128216, 0x29148237, 0x26012f23, 0x06072627, 0x5782020f, 0x2005af44, 0x069c7023, 0x31372c08, 0x140fab01,
+    0x0e0f0f14, 0x141b180d, 0x0b020101, 0x01060301, 0x022d0b06, 0x02030702, 0x14150d0e, 0x2907071f, 0x413e0b0a, 0x934b5453, 0x22300813, 0x05080904,
+    0x3833321e, 0x2d090108, 0x24253030, 0xfe130909, 0x030539be, 0x03060605, 0x0506011e, 0x02066209, 0x04030502, 0x0606038e, 0x0107610a, 0x38220b83,
+    0x1f840105, 0x1eb81d28, 0x07030a14, 0x82850a07, 0x011a0c25, 0x830f0eb2, 0x0a25080b, 0x01020707, 0x011d120a, 0x0c1a0101, 0x1e080713, 0x0e0d1514,
+    0x02070302, 0x53544b02, 0x0a0b3e41, 0x20070729, 0x3e138f13, 0x090109a9, 0x1d333337, 0x04090905, 0x24090912, 0x2e302f25, 0x04380557, 0x01020503,
+    0x820a6107, 0x821d2090, 0x03052884, 0x05096301, 0x841e0106, 0x3905210b, 0x022b1e83, 0x07dc6206, 0x140b0103, 0x850d191e, 0x060b2181, 0x240ebb49,
+    0x00510031, 0x1cab4c71, 0x27360724, 0x0a462631, 0x0ac24905, 0x0f273125, 0x42070601, 0x162005eb, 0x2d05b16f, 0x36372735, 0x022f2627, 0x07222326,
+    0x1e9d3331, 0x2019914c, 0x05c84969, 0x3e0dbb45, 0x052611fe, 0x1c040201, 0x04050207, 0x04232104, 0x1b070404, 0x04030104, 0x06021126, 0x8bc00204,
+    0x2222211d, 0x05221d8b, 0x18430205, 0x05e64919, 0x230d8e45, 0x010522cf, 0x1b2f6382, 0x03030525, 0x02121202, 0x25050303, 0x8205031b, 0x05222214,
+    0x431b9b05, 0x802e0827, 0x3000c001, 0x78004700, 0xc500aa00, 0x5b41e800, 0x27262207, 0x05ff4226, 0x37363724, 0x05433130, 0x55362005, 0x574706a6,
+    0x17162509, 0x27311716, 0x20167141, 0x06254a16, 0x2005174e, 0x202c4916, 0x27491720, 0x2350822d, 0x31070605, 0x06205d83, 0x2620ac82, 0x8306b56b,
+    0x07322aa4, 0x39220531, 0x30352601, 0x26ab8235, 0x32333427, 0x54153233, 0x014408ad, 0x31273105, 0x3c212502, 0x3c4b4d3c, 0x0607213c, 0x0305050c,
+    0x38056a43, 0x4510100a, 0x46636245, 0x0a101045, 0x020e0d15, 0x05030901, 0x07060c05, 0x13e8414e, 0x0603bd2a, 0x190f1004, 0x01110f17, 0x220d7e49,
+    0x490e0f0d, 0xa920077e, 0x08207a49, 0xfe060321, 0x060602a7, 0x0f01010b, 0x0e0e1212, 0x0e0e060e, 0x08090a10, 0x01010907, 0x0b0201c8, 0x82020706,
+    0x08012709, 0x10070708, 0x1c820f0e, 0x12110f34, 0x26404d0e, 0x26010126, 0x06044026, 0x0e0d0d0e, 0xab83121e, 0x5f030231, 0x02023d3c, 0x035f3c3d,
+    0x0d0e0202, 0x831e1215, 0x0406221b, 0x133a4227, 0x9b496720, 0x49032025, 0x043323c0, 0x1b121601, 0x01020c1b, 0x0d01010c, 0x0e13130f, 0x82050507,
+    0x01012a5e, 0x01015709, 0x1b1b0c01, 0x2ac18312, 0x05040101, 0x130e0705, 0x820d0f13, 0x0ac34614, 0x3f002d2c, 0x6c005100, 0x16010000, 0x02843117,
+    0x06070628, 0x013d3607, 0x79423736, 0x07714205, 0x17141522, 0x20099842, 0x0c5e6531, 0xb3190720, 0x0324150e, 0x26312726, 0x24062b68, 0x37323316,
+    0x064d6836, 0x31070622, 0x08db6418, 0x4d303025, 0x4112250e, 0x12260bdf, 0x304e0f25, 0xa3490130, 0x4e502005, 0x96540da1, 0x1b502f0e, 0x02011212,
+    0x05120219, 0x04080903, 0x0a821205, 0x12120125, 0x85c0011b, 0x4156283c, 0x1c171b41, 0x412a1b2f, 0x2a280b82, 0x171c2f1b, 0x5641411b, 0x20056f49,
+    0x18b94df0, 0x83b0fe21, 0x192d264b, 0x09120102, 0x20668309, 0x456d832d, 0x2d260c13, 0x59004300, 0x3b417400, 0x47172030, 0x262a0cf5, 0x06150607,
+    0x06173117, 0xf7473115, 0x2734240c, 0x41010f26, 0x89204243, 0x250a0a48, 0x01060507, 0x0a48aa04, 0x05062409, 0x41215a06, 0x95204145, 0x2b0d1d48,
+    0x07030303, 0x041e0404, 0x30040909, 0x210e3d48, 0x5541b3fe, 0x09834c14, 0x3500082b, 0x58004600, 0x00007200, 0x665b1825, 0x05044107, 0xe64d3620,
+    0x17a3420a, 0x31171623, 0x55851813, 0x33362509, 0x37161732, 0x11574318, 0x2b720720, 0x37362209, 0x06355733, 0x31210883, 0xb3771801, 0x42892008,
+    0x29420984, 0x42012005, 0x243412aa, 0x0b2b0f01, 0x24241908, 0x0d0a0719, 0x15150e0a, 0x760d0a0e, 0x8707955b, 0x73102007, 0xa94208d9, 0x58f0200c,
+    0xfe21074a, 0x098e42dd, 0x2e1fb842, 0x0d0a0601, 0x0a0d1e1e, 0x12120a07, 0x4f23080b, 0x83210f7a, 0x4274872d, 0x00200ab7, 0x260cb342, 0x0030001a,
+    0x4a530041, 0x372032b3, 0x440f5841, 0xd54b1103, 0x188a202e, 0x4109ae86, 0xda20053b, 0x470dee43, 0x8947198f, 0x05df430d, 0x1a415f20, 0x5a03200b,
+    0x002d0c82, 0x00000006, 0x01c00120, 0x00150060, 0x27ff822b, 0x006d0057, 0x13000083, 0x130c6619, 0x14930220, 0x34370122, 0x07eb8118, 0x14011d2c,
+    0x012b0607, 0x3d262722, 0x2bc01701, 0x0b0c8027, 0x0b113011, 0x2006940c, 0x8e158d20, 0x211d9d2b, 0x558d0801, 0x0e8dc020, 0x0ebaf020, 0x0600002a,
+    0xe0ff0000, 0xa0014001, 0x230d4f41, 0x31173237, 0x4105626b, 0x3424061f, 0x023b3637, 0x01271493, 0x31272227, 0x83013d26, 0x32012220, 0x94348717,
+    0x202bac40, 0xcad78d58, 0x416020f5, 0x0d8d0d8c, 0x9d1d8b41, 0x0000311d, 0x00000300, 0x0002e0ff, 0x2400a001, 0x4e003900, 0x0ac5c818, 0x17161522,
+    0x2007365f, 0xb95f1837, 0x2627280c, 0x06230327, 0x82070607, 0x17162121, 0x07b04e18, 0x33232622, 0x085a5118, 0x18013b21, 0x0808335c, 0x48000120,
+    0x22213939, 0x0a150203, 0x3b020807, 0x3b58583b, 0x1602023b, 0x22030216, 0x48393921, 0x37441060, 0x06217607, 0x0786d020, 0x012e1788, 0x232301a0,
+    0x68453a3a, 0x07070216, 0x3e84680a, 0x0e824682, 0x6916022f, 0x233a3945, 0x00ff0123, 0x1b121201, 0x22498340, 0x760e0909, 0x0e220723, 0x16880909,
+    0x200b375a, 0x29e58215, 0x37000064, 0x26312734, 0xc78c012b, 0x5d273521, 0x312005d1, 0xfd8ddb84, 0x06071426, 0x2726012b, 0x0722e383, 0xf7821706,
+    0x33373622, 0x262ae588, 0x37361327, 0x35373631, 0x22852726, 0x14011d27, 0x013b1617, 0x208f82bf, 0x21e18b0f, 0x0e414101, 0x0b0c3612, 0x1c0d6f11,
+    0x0d0e121e, 0x0e0e0404, 0x0d1c2116, 0x1919256f, 0x05214101, 0x086c4018, 0x20071841, 0x20d886e0, 0x21ef8630, 0x2041e070, 0x16282605, 0x0a070702,
+    0x07204128, 0x0b11903f, 0x0b01170c, 0x1118110a, 0x17010110, 0x25191901, 0x3a3a4590, 0xfe012323, 0x12120190, 0x823e881b, 0x0025084e, 0x00030000,
+    0x02c0ff10, 0x00c0012f, 0x0021001c, 0x3700002e, 0x25373635, 0x1f323336, 0x14151601, 0x07060307, 0x05386323, 0x3435262c, 0x2725013f, 0x01371707,
+    0x13411737, 0x352a0805, 0x8f313734, 0x11011401, 0x0d120f0a, 0xca070c36, 0x1849170f, 0x0a0d0d0a, 0x180a0a32, 0xd71d5a01, 0x2efe9f55, 0x071f473f,
+    0xa382450a, 0x18488031, 0x0d08ca0e, 0x0d120d36, 0x12eefe0c, 0x820a1901, 0x342c8227, 0x9e1ddc19, 0x92fed655, 0x081e473f, 0x0a051602, 0x00080007,
+    0x066f6c00, 0x25001234, 0x4b003e00, 0x65005800, 0x84007200, 0x16010000, 0x394c3317, 0x27262905, 0x16150623, 0x23171617, 0x1f231290, 0x41272301,
+    0x21290be2, 0x37363736, 0x26273435, 0x945c1823, 0x69332026, 0x72180b0d, 0x172b1087, 0x0d029e01, 0x2b061010, 0x8203051b, 0x2a082407, 0x8f6c051b,
+    0xe0ae2510, 0x2b14126f, 0x08fd4118, 0xb3418020, 0xa0fe2206, 0x08d07101, 0x0a9f6020, 0x47a0fe21, 0x01290fd8, 0x02010d0e, 0x17243d10, 0x21078428,
+    0x07851625, 0x4e240f8a, 0x12010d53, 0x0a774218, 0x090ea029, 0x0107b809, 0xa2700701, 0x38012104, 0x200fde47, 0x0a8b4100, 0x3600292e, 0x50004300,
+    0x6a005d00, 0x8a007700, 0x0b774118, 0x0a6b4118, 0x41182320, 0x41180a64, 0x4f18098d, 0x43430b27, 0x26352105, 0x0af17219, 0x37363322, 0x4f180f83,
+    0x37200c5b, 0x07203398, 0x2405084e, 0x013b1617, 0x05de5332, 0xe0012722, 0x210b5b58, 0x661860b0, 0x01230cd7, 0x1890fec0, 0x2009354f, 0x4c4f1870,
+    0x21158a09, 0x1694f0fe, 0x60332c8a, 0x091a1922, 0x0a070601, 0x06070a90, 0x19190902, 0x47c00122, 0xfe2105f2, 0x21078580, 0x07854040, 0x0f860120,
+    0x52896020, 0x7f893020, 0x68943020, 0x2b8c158a, 0x20131424, 0x0082070a, 0x13200a25, 0x82000114, 0x05b74a00, 0xc001802e, 0x23001a00, 0x4b003e00,
+    0x00005600, 0x2005ec5e, 0x05e44233, 0x18262721, 0x2c0bc7a9, 0x16070607, 0x26273317, 0x3d260107, 0x05734101, 0x16171425, 0x821d1617, 0x2d308733,
+    0x31232203, 0x16172322, 0x2627013b, 0x08843323, 0x26234a82, 0x18bc0127, 0x1809aea9, 0x3309c2a9, 0x805a69f9, 0x18715997, 0x09660124, 0x07300701,
+    0x11201d01, 0x08eaa918, 0x1cc02308, 0x76031c1d, 0x75581d13, 0xb8ff1d14, 0x111d1575, 0x16020216, 0x2b1a0b01, 0x0101071e, 0x1c211e07, 0xa918131c,
+    0xb22a0bb7, 0x014f3811, 0x01051b83, 0xa9180610, 0xfe2316e6, 0x83168af7, 0x16022401, 0x55021670, 0x80240d0b, 0xa4009200, 0x2c1f574a, 0x17060706,
+    0x15331531, 0x33141732, 0x82038416, 0x06072205, 0x2b178215, 0x06152207, 0x39231523, 0x14150601, 0x32202382, 0x16212386, 0x24218d17, 0x15352314,
+    0x05e86206, 0x37363727, 0x27262726, 0x082f5122, 0x2b5c0d83, 0x1520303e, 0x0102061b, 0x02010105, 0x01060401, 0x84020405, 0x04062108, 0x01220682,
+    0x16850404, 0x158c0620, 0x02010533, 0x0a151b06, 0x01010607, 0x010a0706, 0x05030302, 0x200d8704, 0x35645c70, 0x010b2c27, 0x02070401, 0x24008201,
+    0x04010403, 0x82868205, 0x21068280, 0x81820103, 0x82050521, 0x01012205, 0x21178203, 0x1f820305, 0x18860220, 0x062d1282, 0x08060b05, 0x08090c07,
+    0x02010509, 0x86988202, 0x4e7c200c, 0xc34118e6, 0x00b2220f, 0x83c341e3, 0x5b308f52, 0x02424aeb, 0x523d204d, 0x245c2283, 0x502c423c, 0x76524420,
+    0x27605c25, 0x2b09db4f, 0x008b0025, 0x00ae009d, 0x250000c5, 0x220a175a, 0x67230617, 0x142511f1, 0x31072607, 0x44178527, 0x10440534, 0x33142107,
+    0x44111244, 0x58440734, 0x44219407, 0x15201634, 0x11029818, 0x2310ea4e, 0x17363717, 0x07215382, 0x05f26506, 0x83363721, 0x011f300f, 0x180bce01,
+    0x0e1e1d18, 0x0317070f, 0x5b352f08, 0x0e2711c2, 0x01a61311, 0x440a0706, 0x78204854, 0x200d214f, 0x0f414fda, 0x11152d2d, 0x04050f0e, 0x55110809,
+    0x8317050f, 0x2e0f8207, 0x1a710604, 0x09080d0d, 0x591e1b1a, 0x5014080c, 0xac8b0564, 0x08282c28, 0x070b0303, 0x77440509, 0x02042128, 0x20099044,
+    0x13754403, 0x445c0121, 0x03200b72, 0x300b9b4f, 0x09050588, 0x10121109, 0x0218050f, 0x0f12590e, 0x200f840f, 0x0fa75015, 0x40002e24, 0x8b445200,
+    0x37362e1d, 0x36373631, 0x21232627, 0x17060722, 0x21018216, 0x29620331, 0x2b3a313d, 0x07030f2b, 0xecfe0b06, 0x0307060b, 0x3a2b2b0f, 0x2f362762,
+    0x212001b0, 0x08070b34, 0x340b0708, 0x01012021, 0x91191469, 0x006022f7, 0x20f7b091, 0x7b314527, 0x36410020, 0x473d5f11, 0x41180352, 0xd8200e60,
+    0x534db444, 0x2e240e33, 0x5b004400, 0x24309341, 0x31072603, 0x42e55d06, 0x5d115d41, 0x364139e3, 0x3d01210e, 0x5d0ea055, 0xfb5e1cde, 0x489f430c,
+    0x45051c5e, 0x46540a73, 0x110a411a, 0x200e9f43, 0x089b187d, 0x0f094128, 0x200ca143, 0xff9a183a, 0x05c3460d, 0xc0018032, 0x4d003f00, 0x5f005200,
+    0x00006c00, 0x31151625, 0x2705d35e, 0x27262726, 0x35343734, 0x08229918, 0x23270e83, 0x35262722, 0x18272611, 0x25090d65, 0x17161716, 0x085f2111,
+    0x012b2506, 0x31171603, 0x232c1082, 0x36373611, 0x33073337, 0x07152335, 0x0a8af018, 0x15251529, 0x2b060714, 0x83333501, 0x1d022f31, 0x0e0e0201,
+    0x0d0e1414, 0x03c50201, 0x0a850d01, 0x0e430326, 0x0f010909, 0x24069450, 0x12121b20, 0x077c4d01, 0x836d4321, 0x83c0202b, 0x82602029, 0x20502100,
+    0x26053946, 0x09400120, 0x83200e09, 0x0200240d, 0x83060503, 0x25238324, 0x01010608, 0x0d880808, 0x24820820, 0x0f500123, 0x05c44501, 0x12120123,
+    0xed73191b, 0x84012007, 0xf0fe2352, 0x2c831001, 0x30306023, 0x202382e0, 0x215c82a0, 0x0584c0e0, 0x534a0d82, 0x02c82d05, 0x00c00140, 0x002a001b,
+    0x0046003a, 0x2005f147, 0x32b81827, 0x0706220e, 0x30f18206, 0x36111731, 0x013f3437, 0x17161736, 0x010f0611, 0x05e95201, 0x29190720, 0x272108c0,
+    0x07a45735, 0x01153008, 0x18191111, 0x01011314, 0x34322223, 0x01012222, 0x18191313, 0x09090611, 0x05058f06, 0x090d7401, 0x0e01010a, 0x7b6ffe91,
+    0x05050804, 0x830a0c7f, 0x7101260e, 0x111722c1, 0x28028217, 0x23148921, 0x1c252522, 0x08398333, 0x33222237, 0x2225251c, 0x08081423, 0x0a2f01c0,
+    0x2e02020a, 0x0d070705, 0x0610f1fe, 0x313c013a, 0x0a0a1416, 0x060333fc, 0x0e010d07, 0xc3fe0611, 0x1b31c237, 0x311b1414, 0x06f74df9, 0x1a28df85,
+    0x3b002c00, 0x58004b00, 0x830ab353, 0x09d148d3, 0x1720ba82, 0x250c2a57, 0x16171415, 0xef8a1733, 0x2123fd82, 0x86151716, 0x013f28ef, 0x17311716,
+    0x87153736, 0x013122f5, 0x23e58998, 0x13191811, 0xbb82fd82, 0x7820c383, 0x8505ed54, 0x888a2005, 0x050523fe, 0xfd88ecfe, 0x08047b27, 0xc02117b2,
+    0x23fe8221, 0x48011117, 0x0841f287, 0x1820200d, 0x200b6d62, 0x0c09411c, 0x820a2f21, 0x09084100, 0x14163126, 0xf9311b97, 0x20050d41, 0x07476f00,
+    0x01fc0130, 0x001b00bc, 0x01000029, 0x27372707, 0xf9180f26, 0x37220ab1, 0xf3423336, 0x07312205, 0x08178706, 0x17013f3f, 0xa4e00107, 0x100e7482,
+    0x11105711, 0x16560e0e, 0x0d161d1d, 0x24251c0f, 0xfa1c1c1c, 0x0d19664a, 0x05020909, 0x82404a15, 0xa6200140, 0x0e0d7482, 0x0f0f550e, 0x15561110,
+    0x1b0f0d15, 0x2127831b, 0xf91849fd, 0x412208bd, 0x9b444182, 0xff012e05, 0x0b00c001, 0x3c001d00, 0x00004800, 0x06785213, 0x36011f25, 0x18061737,
+    0x2c0f2478, 0x16170717, 0x012f0607, 0x26270607, 0x23b38235, 0x023f3637, 0x1f22aa82, 0x17821602, 0x23132008, 0x16010f22, 0x27363717, 0x4be02726,
+    0x0a780904, 0x6f050404, 0x4b20402e, 0x02023231, 0x874b3132, 0x5d350807, 0x05010826, 0x2f2f0705, 0x09050507, 0x02030526, 0x03183407, 0x18030707,
+    0x03020734, 0x09779205, 0x2e404a05, 0x0404056f, 0x7b3d010b, 0x08080108, 0x0b2a9f08, 0x83418b1d, 0x9d270849, 0x04073525, 0x19190304, 0x07040403,
+    0x07052535, 0x2f080106, 0x082f0707, 0x05070601, 0x7a083d01, 0x089f2a0b, 0x6f010807, 0x2c220e7b, 0x91613e00, 0x4925201c, 0x6061220d, 0xb0fe2119,
+    0x2035be4e, 0x1a6d4e50, 0x200d6f4e, 0x20bf8225, 0x1c574758, 0x66181720, 0x272009a0, 0x0b5b8219, 0x4a181683, 0xe15b075b, 0x461f9107, 0xc0201849,
+    0x07847618, 0x06800f23, 0x22ae8506, 0x5b022406, 0x242708a9, 0x12121ba6, 0x8d240201, 0x188b481a, 0xec737020, 0x08ca2207, 0x0566450a, 0x10080a23,
+    0x8342832a, 0x102a2251, 0x8f06857a, 0x060f571c, 0x01800138, 0x000b00c0, 0x002a0016, 0x1f361300, 0x13171601, 0x3f361321, 0xfa890301, 0x13241f1a,
+    0x0b0bb52d, 0x28010450, 0x0128f0fe, 0x181d5004, 0x2009596d, 0x188185c8, 0x31071c9f, 0xbb014001, 0x04500a0a, 0x01befe05, 0x50040542, 0xbd74f5fe,
+    0x5bb02007, 0x02200d23, 0x2506e755, 0x000a00bf, 0x83730029, 0x0f262a06, 0x07373301, 0x15070621, 0x20988316, 0x068e4116, 0x27263524, 0xa2823736,
+    0x08059852, 0x020cf622, 0x12131103, 0x066398cc, 0x010f20fe, 0x010f0f01, 0x13362121, 0xe0100106, 0x36130610, 0x11012021, 0x012a1583, 0x11110e83,
+    0x980c0909, 0x75538262, 0x2f3e2f05, 0x211a162f, 0x11020211, 0x2f161a21, 0x39823e2f, 0x820e2021, 0x4f491886, 0x0015230b, 0xf3760042, 0x18212006,
+    0x270d2658, 0x37341335, 0x35333631, 0x37208882, 0x8805fe58, 0x8223201f, 0x09545aaf, 0x2627222a, 0x0100013d, 0x011b1212, 0x82052147, 0xe0fe3c09,
+    0x0112121b, 0x0e0909a0, 0x22171601, 0x09090e90, 0x0111121c, 0x291b1b01, 0x41010f90, 0x40200540, 0x01210682, 0x07c44180, 0x08884020, 0x82e0fe21,
+    0x22102418, 0x82011617, 0x0b7b2c3d, 0x20201818, 0x011b1b29, 0x58100f01, 0x00220af6, 0x56180000, 0x053e097b, 0x16000b00, 0x31001c00, 0x4e003c00,
+    0x5e005400, 0x16370000, 0x23272617, 0x37363335, 0xbe420706, 0x83232005, 0x241682bd, 0x37272633, 0xca681821, 0x27262914, 0x16333736, 0x27070617,
+    0x103d8618, 0x37363723, 0x82178223, 0x2726213b, 0x822c3b83, 0x020c2c09, 0x0c022727, 0x065e0a2b, 0x07805618, 0x12822920, 0x772c0924, 0x5918c0fe,
+    0x01240d06, 0x301b1212, 0x08194018, 0x36700f22, 0x0ebd9c18, 0x092c2922, 0x40254882, 0x0807022e, 0x204b8306, 0x685618f0, 0x186f2008, 0x25077b56,
+    0x31291db5, 0x48836a15, 0x3041fe20, 0x053a4108, 0x4360fe21, 0x9318071a, 0x2a2910e3, 0x1d293115, 0x14142166, 0x35468306, 0x00020000, 0x02c2ff02,
+    0x00c00100, 0x0027000b, 0x37360100, 0xed821716, 0x27010f2c, 0x06070337, 0x1637010f, 0xd6643233, 0x23210805, 0x15060722, 0x37071714, 0x17013f36,
+    0x24177601, 0x01161622, 0x56cf1a01, 0x071377b6, 0x0460b21b, 0x05c14104, 0x013b0582, 0x1b09315f, 0xa5015553, 0x1601011a, 0x18242216, 0xfecf55b4,
+    0x091b53c5, 0x42015f31, 0x042808fe, 0x19b36004, 0x00551308, 0xc3288384, 0xbe01fe01, 0x2d000d00, 0x33218383, 0x057a5931, 0x17268583, 0x05070607,
+    0x87822706, 0x6507846f, 0x0723055e, 0x84133726, 0x702e0889, 0x12161612, 0x3810102e, 0x2e31377d, 0xf7fe1e0a, 0x0a990e12, 0x0e0d150a, 0x14150d0e,
+    0x01010e0d, 0x060d9a05, 0x98200b58, 0x10ae0182, 0x2d832e10, 0x387d372b, 0x0c1f99ce, 0x9a0d0658, 0x07d44905, 0x0b2a0783, 0x120e990a, 0x0a1f0801,
+    0x1f4e812e, 0xff012308, 0x9782bf01, 0x37001b24, 0x9b825100, 0x31151623, 0x21968314, 0xa2823336, 0x82370121, 0x095c479d, 0x26270726, 0x013f3435,
+    0x30301a84, 0x07153023, 0x3f161706, 0x30313001, 0x22011f37, 0x34220d88, 0xae7d1733, 0x37310809, 0x12ed0117, 0x39723912, 0x131a1a13, 0xff40fe18,
+    0x0e0aff72, 0x090a0e68, 0x0a041e03, 0x0e5792cc, 0x130f4e0e, 0x01140f13, 0x0b0a0a40, 0x2d01400b, 0x200987cd, 0x241a8614, 0x012d9257, 0x823d8395,
+    0x12122444, 0x83cafe18, 0x1e042442, 0x83090b04, 0x92fa2247, 0x223f8357, 0x820e0e4e, 0x0b0b2342, 0x42850a0a, 0x14200985, 0x42821a86, 0x3905c747,
+    0xc0018002, 0x34002000, 0x58004600, 0x35130000, 0x16011f36, 0x2627021f, 0x06823337, 0x0c821620, 0x0706072a, 0x26252706, 0x3526012f, 0x1418fd19,
+    0x07142524, 0x5a180631, 0x32200861, 0x1723e882, 0x48313734, 0x19850789, 0x02002008, 0x06112312, 0x03298011, 0x09132812, 0x13186c6d, 0x03031123,
+    0xfe423f16, 0x520d11d6, 0x4260020a, 0xfd210546, 0x230785c0, 0x60fe4002, 0x82083342, 0xaf491812, 0x0121080c, 0x01116319, 0x2f100408, 0x03119227,
+    0x20c20f01, 0x101b1007, 0x170a1615, 0x0c054d11, 0xfe0d0954, 0x643a8be7, 0x578506d7, 0x0c955318, 0x45000021, 0x802f0587, 0x21009a01, 0x00003500,
+    0x013b3601, 0x82161716, 0x060524ef, 0x7722012b, 0x1f29051f, 0x26273701, 0x013f3635, 0x20098236, 0x4cd88401, 0x23220757, 0x1a822221, 0xe5012408,
+    0x15391f1b, 0x1d070b0b, 0x07effe47, 0x0a0f8908, 0x200e0949, 0x64390e0e, 0x08010893, 0xc31b182e, 0x821bfe68, 0x40022191, 0xe3848385, 0x0e82013f,
+    0x140f1001, 0x0389254b, 0x0a0f550b, 0x19060710, 0x09055f31, 0x0c170509, 0xfe35490a, 0x0855435e, 0xa7863882, 0x01bf012d, 0x002c00c0, 0x25000038,
+    0x82363727, 0x010f249c, 0x7a373627, 0x23350577, 0x15060722, 0x33171611, 0x33353736, 0x1f060717, 0x013f1601, 0x22038217, 0x18012736, 0x3f09fb4e,
+    0x60b80135, 0x170e0e60, 0x435f1111, 0x09131323, 0x2c212209, 0x09090d86, 0x161f1502, 0x61712a01, 0x602b1a84, 0x17111160, 0x97fe0f0e, 0x820b1157,
+    0x57112200, 0x2c118300, 0x600e0e16, 0x23241244, 0x191a2b2c, 0x27938201, 0x0216f8fe, 0x70381602, 0x0e202c84, 0x01215586, 0x05da4a70, 0x67515020,
+    0x0024330d, 0x00470035, 0x0500005b, 0x27222306, 0x06272635, 0xdf661507, 0x05b06809, 0x06070623, 0x20198507, 0x0efb6203, 0xd16c3f20, 0x0ab44e06,
+    0x17160723, 0xa57b1831, 0x2d3b830a, 0x2d600115, 0x012d3333, 0x3a010f0f, 0x67182223, 0x01230cb5, 0x833a2322, 0x64862017, 0x63200f3e, 0x200fbf4e,
+    0xf25f186d, 0x132d2c0f, 0x010fcd13, 0x22be0f01, 0x53483a3a, 0x48240bc5, 0xbe223a3a, 0xcd221983, 0x0b630001, 0x0bcb4e0c, 0x0e148624, 0x5283010d,
+    0x08882020, 0x7c08c75a, 0x2826057f, 0x4f003d00, 0xd5666100, 0x035f180e, 0x1611230d, 0xfb831617, 0x83062721, 0x260727f6, 0x27263127, 0x0e450726,
+    0x33162a05, 0x37363732, 0x17143731, 0x820a8531, 0x2223251a, 0x23150607, 0x09842683, 0x8a551420, 0x08066806, 0x1068ff18, 0x0b263628, 0x2f090a0c,
+    0xe8820f45, 0x0f013024, 0xcc710c0e, 0x070b4105, 0x0809602f, 0x09090d0f, 0x09090101, 0x09080f0d, 0x87078660, 0xf18c1815, 0xa0fe3218, 0x090a2a01,
+    0x02330c0b, 0x010f0f01, 0x17181011, 0x0590710f, 0x0e0d1426, 0xa1140d0e, 0x420be142, 0xf3620ded, 0x80023306, 0x2700a001, 0x33002e00, 0x4a003800,
+    0x00005c00, 0xf6832325, 0x2720e382, 0x0d830889, 0x37363526, 0x16213736, 0x085a8118, 0x35332522, 0x15272082, 0x15232721, 0x82352333, 0x11904c04,
+    0x11035018, 0x1050022b, 0x291b1b01, 0x011b1b29, 0x08088780, 0x0e141021, 0x1401010d, 0x89011f14, 0x106e141d, 0x140e0d01, 0x5860f0fd, 0xe1010107,
+    0xe1a15150, 0x84a06060, 0x06215020, 0xfe201e83, 0x08af9f18, 0x08a05a18, 0x50875183, 0x26830783, 0x141fe82a, 0x16010114, 0x6c181184, 0xc0252783,
+    0x58070160, 0x20008260, 0x0f814290, 0x0847cb18, 0x00321887, 0xff000004, 0x018002e0, 0x004600a0, 0x005d0053, 0x5b650066, 0x22232705, 0x013d2627,
+    0xcb473736, 0x14152c05, 0x17363707, 0x33010f16, 0x50161716, 0x1f8205dc, 0x07013f25, 0x42010f06, 0x3520055f, 0x3f322a82, 0x35273601, 0x23262734,
+    0x07060722, 0x16150717, 0x12823217, 0x0c823720, 0x33073133, 0x23151415, 0x37362726, 0x37362105, 0x06171621, 0x06f55d07, 0x0427cb87, 0x0e0d127b,
+    0x41541206, 0x803605bc, 0x05090a10, 0x29125e0c, 0x1f29150e, 0x01011515, 0x551f1213, 0x74180107, 0x203907c4, 0x03040801, 0x31101a0e, 0x28880116,
+    0x02021628, 0xfe500216, 0x010a0cb4, 0x200b8336, 0x07315101, 0x28072b41, 0x251f1f08, 0x120e0d04, 0x20408235, 0x3660820d, 0x260f0e0c, 0x19474f1d,
+    0x14010123, 0x21481e15, 0x1a091919, 0x85082929, 0xb020367a, 0x04010748, 0x0e332e19, 0x28201709, 0x16020404, 0x18300216, 0x20068318, 0x0d034d00,
+    0x66003424, 0x034d9700, 0x1111791d, 0x20052e41, 0x2edf7631, 0x184c1377, 0x20189aae, 0x5ff15a3f, 0x180b4621, 0x2016c2ae, 0x4f04565e, 0x00072608,
+    0x02c0ff01, 0x00c0017f, 0x00270022, 0x0031002c, 0x003b0036, 0x01000040, 0x06212726, 0x17060307, 0x15013b16, 0x05f84423, 0x3736333a, 0x27262734,
+    0x32213523, 0x03273637, 0x27231707, 0x23172333, 0x07233337, 0x032b0482, 0x23073337, 0x17333733, 0x82273323, 0x024c0804, 0xfe1a063f, 0x3f061941,
+    0x0f090903, 0x0e142fff, 0x0f01010d, 0x0d010fdf, 0x0130140e, 0x090a0f00, 0x13394003, 0x8a590a62, 0x780a8c0a, 0x13620aa9, 0x67168c59, 0x0ba3720b,
+    0xddac0b96, 0x7216670b, 0x0218a601, 0xc0fe1802, 0x400c0b0f, 0x0f233583, 0x830e0201, 0x0c402745, 0x40010e0c, 0x00846026, 0x7000ff22, 0x00200084,
+    0x022c0082, 0xe1ff0000, 0xa0014002, 0x41002e00, 0x0722c183, 0xc36f0631, 0x05ab5205, 0x73072621, 0x16210539, 0x24018217, 0x32333237, 0xc8e31831,
+    0x22d58208, 0x5f373605, 0xe645056d, 0x17500808, 0x240f3802, 0x292b2c23, 0x30121230, 0x232c2b29, 0x01070f24, 0x14050601, 0x363f2813, 0x01011b35,
+    0x36361a01, 0x13142840, 0x01010605, 0x13e8fe07, 0x0c1f1d19, 0x08221919, 0x19192307, 0x1a1c1f0c, 0x01000113, 0x12120505, 0x31312f25, 0x1112262e,
+    0x0f322784, 0x29282121, 0x0d0c3a25, 0x0d0d0303, 0x2828253a, 0x56822121, 0x161d6f34, 0x2d35111c, 0x06061e2c, 0x362c2d1d, 0x1d171b11, 0xcf820100,
+    0x0002c033, 0x3600c001, 0x17010000, 0x16011f16, 0x010f0617, 0x051c4a06, 0x012f2226, 0x22232726, 0xbc820f82, 0x013f2625, 0x82343536, 0xfb851811,
+    0x32372109, 0x6908e682, 0x135d0131, 0x223a270b, 0x52160102, 0x01030115, 0x171e1213, 0x20182d14, 0x43080908, 0x0a101013, 0x091c0f0f, 0x040c2c0b,
+    0x15111103, 0x1f1e2d48, 0x10161f14, 0x91010611, 0x150f2845, 0x111c250f, 0x321b113b, 0x0114141d, 0x01142610, 0x07030d02, 0x1c1c1008, 0x14121031,
+    0x15124610, 0x010d0d15, 0x28230105, 0x0d0d0118, 0x00820015, 0xaf880920, 0x20190d20, 0x8f250c37, 0x0000a100, 0x05246913, 0x3435232c, 0x013b3637,
+    0x31373603, 0x60183736, 0x33200fc2, 0x2010c152, 0x10e44a37, 0xe44a3320, 0x90332010, 0x90072023, 0x90172023, 0x90272023, 0x0ec03c23, 0x09800909,
+    0xc0400e09, 0x291b1b01, 0x1b1b2980, 0x0e0d0101, 0x0e14e014, 0x18a0010d, 0x200f8a62, 0x18274ba0, 0xa263198c, 0x8c2c8506, 0x21268c0c, 0x2182c001,
+    0x82606021, 0x00ff2180, 0x80827784, 0x08ef5018, 0x1801d021, 0x4b0e9963, 0xbe4706ad, 0x180b910b, 0x990cc155, 0x0737430c, 0x2b056742, 0x00360031,
+    0x16332500, 0x06171617, 0x2105436e, 0xdf632621, 0x37362205, 0x05876836, 0x8507424a, 0x07062123, 0x27080782, 0x1521011f, 0x6e013521, 0x201f3022,
+    0x011e0201, 0xfe140e0d, 0x0d0e14a0, 0x01021e01, 0x22301f20, 0x010f0f17, 0x01131202, 0x2d07c246, 0x02121301, 0x170f0f01, 0x01c0fe32, 0x2283c040,
+    0x330c2122, 0x39832f83, 0x210c3322, 0x1f834683, 0x19141b23, 0x070d4122, 0x14192223, 0x3347831b, 0x002020a0, 0xff180002, 0x012802c0, 0x001e00c0,
+    0x05000027, 0x2c08e354, 0x2627013f, 0x023f3637, 0x1f163736, 0x08988202, 0x17010f61, 0x27173127, 0x31012f37, 0x03cf0111, 0x81111010, 0x0f101280,
+    0x0e681902, 0x90130606, 0x14130a40, 0x13904009, 0x680d0507, 0x1670af18, 0x1b387d5b, 0x090b0c13, 0x0b094444, 0x6693130c, 0x0312130e, 0x01118416,
+    0x16841101, 0x0e131203, 0x3c639366, 0x72135a7e, 0x0000dffe, 0xff200004, 0x82a001c0, 0x00302e83, 0x00400035, 0x0100004b, 0x27343523, 0x05244926,
+    0x20053145, 0x22838211, 0x4c153317, 0x07870620, 0x3637362e, 0x27261137, 0x33012f26, 0x13352315, 0x09295a18, 0x0a893520, 0x30700129, 0x60140e0e,
+    0x180d0e14, 0x260935e2, 0x200f0110, 0x8480010f, 0x05224905, 0x140e0d26, 0xa06060c0, 0x8909da50, 0x40012209, 0x07514150, 0x82015021, 0x00ff2127,
+    0x10200e83, 0x09b8c518, 0x15831020, 0x15840120, 0x50505024, 0xc550b0fe, 0x525f8207, 0xc34705e0, 0x002c240d, 0x4750003e, 0x47181cc3, 0x481824b3,
+    0xbf5410da, 0x06526718, 0x16af4718, 0xaa685020, 0x18b9540f, 0x430cf45a, 0xf0200c81, 0x18117d68, 0x2d0bf373, 0x00190014, 0x0027001e, 0x00440037,
+    0x1c6f1300, 0x18152008, 0x08083bb5, 0x23171124, 0x07353315, 0x15233533, 0x26373617, 0x16070627, 0x37113717, 0x1f323336, 0x14151601, 0x3534010f,
+    0xbb183731, 0x232308c8, 0x53003721, 0xf04a063e, 0x83402008, 0x71202000, 0x802b0726, 0x0d0d0a4b, 0x0a0a5a0a, 0x436997d3, 0xfe2405cf, 0xa001c0d7,
+    0x8f440a86, 0x1b1b2a05, 0x20800129, 0x40c04040, 0x024a1840, 0x01182408, 0x820a4b06, 0x0d0d2637, 0x0505d409, 0x38648660, 0x030000c0, 0x11000000,
+    0x60014002, 0x83003600, 0x00009500, 0x31373237, 0x22028336, 0x83161732, 0x36332901, 0x30373637, 0x31322737, 0xb6830883, 0x82323321, 0x2f262511,
+    0x06232601, 0x07fac018, 0x05331622, 0x82063e47, 0x07094ce1, 0x86313021, 0x83072021, 0x200d831b, 0x222f8322, 0x4c150607, 0xcf5a07f9, 0x20078e07,
+    0x91ab1835, 0x17480810, 0x0d0d1ac0, 0x0e190b08, 0x08060808, 0x1b1a0d0d, 0x01050e0f, 0x1305018d, 0x12132013, 0x0c040327, 0x0101090a, 0x1a1a2618,
+    0x1427283c, 0x031f1813, 0x80011b14, 0x0a141802, 0x0f08060b, 0x10090c0d, 0x12241d11, 0x0d0a0112, 0x23220b85, 0x0b821312, 0x130a0c35, 0x0a0a0f14,
+    0x080f0809, 0x0f131312, 0x21211818, 0x870f1818, 0x13132207, 0x22188212, 0x421ffe09, 0x80320f45, 0x0f080807, 0x07050502, 0x01070709, 0x01060908,
+    0x08820374, 0x01090427, 0x180e0909, 0x200f8207, 0x2b008215, 0x342b1c03, 0x06194d0c, 0x05050604, 0x0a289a82, 0x01060707, 0x03090a01, 0x08202582,
+    0x09350a87, 0x0604040e, 0x090d1107, 0x0b06050a, 0x08070809, 0x070a0a07, 0x26058208, 0x0905060b, 0x42ad0d09, 0x2108107a, 0xff000003, 0x014002e0,
+    0x000a00a0, 0x009c004f, 0x15300100, 0x14313031, 0x35151431, 0x15333507, 0x01833736, 0x5a343521, 0x5f4e076a, 0x26352a05, 0x06272627, 0x011d0607,
+    0x201a8f23, 0x6f1a8637, 0xc441053d, 0x36172139, 0x8606db4c, 0x32332e07, 0x01353637, 0x1ac08040, 0x01070e0e, 0xb28e1802, 0x1a1b250c, 0x1a192e29,
+    0x4c06b04c, 0x022d0683, 0x292c1919, 0x02011b1b, 0x0e0d0702, 0x46b9411a, 0x01400122, 0x042a0082, 0x01605fff, 0x01080807, 0xff46e502, 0x1a29280b,
+    0x1d01011b, 0x465c271e, 0x0d290bf5, 0x011d1d26, 0x291b1b01, 0x228882e5, 0x413e0708, 0x01202dbe, 0x09236682, 0x84070809, 0x060b3807, 0x0d090a05,
+    0x03000000, 0xc0ff0000, 0xc0018002, 0x27001c00, 0x57003900, 0x362106c5, 0x065e4333, 0x07141731, 0x06071617, 0x37260127, 0x07011f36, 0x4c053736,
+    0x332006d4, 0x21052c44, 0x704a1716, 0x31273806, 0x151516d7, 0x0f0f0a10, 0x23231a0a, 0x04011b1b, 0x0f0c108b, 0x83b0fd13, 0xb0330805, 0x01180248,
+    0x4a4b3213, 0x60023232, 0x020e0f01, 0x2f202001, 0x10010110, 0x01171721, 0x21243101, 0x0d0d1720, 0x38383825, 0x13162639, 0x10130f6d, 0x83d0010c,
+    0xb08a3a05, 0x31d73623, 0x31320202, 0x02020e4c, 0x2020300e, 0x0f0f0101, 0x16170101, 0x0e9f4d23, 0x51003b24, 0xdb456800, 0x0617221c, 0x05c47f07,
+    0x32013b26, 0x3716011f, 0x18058a63, 0x22087a4d, 0x62273107, 0x8a3f4408, 0x07070109, 0x2b291408, 0x14292b04, 0x01070708, 0x10110a09, 0x1c1c1718,
+    0x11101817, 0x7f07040a, 0x6c3d37f6, 0x05081212, 0x0f070405, 0x0504070f, 0x12120805, 0x0c111112, 0x0c01010c, 0x1211110c, 0x2c1f62d9, 0x2000012e,
+    0x9f01e0ff, 0x3400a001, 0x06250000, 0x1806d84f, 0x2107934a, 0x09832607, 0x26272624, 0x884b3637, 0x36372406, 0x8532012f, 0x0573450d, 0x01076b08,
+    0x05031c8a, 0x1405070d, 0x081e0514, 0x1e081a1a, 0x05141306, 0x04040d07, 0x080b1e1c, 0x1f1d1515, 0x080b561b, 0x02190905, 0x11030301, 0x1d151314,
+    0x0b081515, 0x342aeb1e, 0x141d3d3e, 0x79130101, 0x1a02021a, 0x01011379, 0x3e3d1d14, 0x38292a34, 0x0816161e, 0x06390f06, 0x10080c0a, 0x0e020101,
+    0x08050706, 0x391e1616, 0xe7410028, 0x01802e08, 0x000d00c0, 0x00270019, 0x1300003a, 0x209c8317, 0x050c4d26, 0x36021f23, 0x20af8227, 0x27c98223,
+    0x17162507, 0x16170716, 0x1382ad83, 0x37231324, 0x17840727, 0x21171624, 0x24833736, 0x67736908, 0x2924241a, 0x2e414149, 0x07030205, 0x0c1bee85,
+    0x0c0b2f0b, 0x222f2f2c, 0x04091201, 0x08661b08, 0x01010607, 0x06391f1f, 0x493c41cf, 0x0d0e14cd, 0x020f0101, 0x01010f20, 0x01140e0d, 0x2c3e2537,
+    0x1d03172d, 0x0707381e, 0x57300308, 0x1347465e, 0x2e2e0104, 0x1f187c4e, 0x03255a4d, 0x49080405, 0xfe2c4040, 0xc816b27d, 0x0f263083, 0x150d0201,
+    0xf9180e0e, 0x3d2a0bef, 0x57004200, 0x61005c00, 0x0f706600, 0x011d2606, 0x23060714, 0x0c0b5b15, 0x82233521, 0x099f7513, 0x22353323, 0x0a887527,
+    0x3433152c, 0x013b3637, 0x35331507, 0x38830523, 0x24841084, 0x23203884, 0x0a266d18, 0x15233523, 0x07814733, 0x2309335b, 0x0e0909c0, 0x8e065556,
+    0x20302414, 0x82f0fe20, 0x06024513, 0x12820683, 0x82600121, 0x20c02416, 0x86a00120, 0x44409938, 0x368208c7, 0x458a5020, 0xf0211782, 0x24008320,
+    0x20204001, 0x22008200, 0x18000002, 0x27084f50, 0x2500002f, 0x23272603, 0x200b2067, 0x05bb4f23, 0x3621172b, 0x03273637, 0x26312722, 0x20098227,
+    0x05a66033, 0x23062008, 0x0749fe01, 0x01063c18, 0x29291b1b, 0x06011b1c, 0x4907183b, 0x180e0e06, 0x0e18a001, 0x82fe060e, 0x5a01206e, 0x0226093d,
+    0x01192401, 0x8a4b120e, 0x0f112f07, 0xdcfe1901, 0x0114131a, 0x1a131401, 0x02463e01, 0x0200230b, 0x97821000, 0xc0012f25, 0x82002000, 0x18172097,
+    0x211fa7bb, 0xbd4e0627, 0x17332805, 0x07060716, 0x1828e823, 0x2a1ab1bb, 0x24151434, 0x0e021415, 0x82020ea4, 0x10012209, 0xbbbb1875, 0x05a42e18,
+    0x1d1c0905, 0x25959525, 0x00091c1d, 0x0e974e07, 0x6f005226, 0xae008e00, 0x270bd549, 0x3523011d, 0x31171617, 0x0cf4ed18, 0x36373624, 0xa94e3337,
+    0x07ea4405, 0x24821620, 0x0f14133c, 0x06152202, 0x022f2223, 0x3f343526, 0x32333602, 0x1f331417, 0x17151601, 0x118e012f, 0x272a2a87, 0x1516021f,
+    0x15220714, 0x3a91010f, 0x07142723, 0x83199531, 0x42602054, 0x80200634, 0x250d914e, 0x291b1b01, 0x964e4080, 0x02e02b0f, 0x02010c1e, 0x0c020201,
+    0x0a82021e, 0x0a820220, 0x0a820120, 0x0e8d4c20, 0x08202487, 0x01211682, 0x20319101, 0x83149314, 0x068c4a2b, 0x80606022, 0xa14e7e83, 0x1b292509,
+    0x00ff011b, 0x210fa74e, 0x87837001, 0x84010121, 0x83928488, 0x02022557, 0x020c1e2e, 0x7c860082, 0x25820a85, 0x16836420, 0x0c21bc82, 0x20328d1e,
+    0x83139232, 0x4300202a, 0xbe290503, 0x2500c001, 0x00003200, 0xf1621801, 0x4a062008, 0x17210587, 0x0cbc4816, 0x36273628, 0x012f2627, 0x1e822335,
+    0x15073008, 0x36373633, 0x19500137, 0x19191f1f, 0x3c191e1f, 0x14141a1b, 0x1b302423, 0x0a0a0b10, 0x301b100b, 0x14142424, 0x1a1a0201, 0x2220103c,
+    0x84011617, 0x012b0804, 0x0a090140, 0x090a0c0c, 0x30300301, 0x3334333d, 0x02012322, 0x01010508, 0x01020805, 0x33332223, 0x30313c34, 0x01206003,
+    0x84221716, 0x00002804, 0xff200009, 0x82df01c0, 0x001132a3, 0x0054004b, 0x006a0061, 0x00850073, 0x009b008e, 0x11bc6200, 0x27263725, 0x42072631,
+    0xa345076d, 0x52172006, 0x332406b6, 0x31303732, 0x07374e18, 0x0f820982, 0x1b72c482, 0x05272305, 0x1a833726, 0x37272225, 0x82260706, 0x333225da,
+    0x07063332, 0x0e821382, 0x37362724, 0x04822611, 0x49821620, 0x5a5f3520, 0x06172210, 0x22468223, 0x82071637, 0x27262549, 0x33363332, 0x07224882,
+    0x04440001, 0x07d63e0d, 0x10381a1b, 0x21211819, 0x38101918, 0x0d071b1a, 0x1d1d0504, 0x0f0d0405, 0x16161819, 0x25198708, 0x18161608, 0x1b870f19,
+    0x0789fe3a, 0x030b0b16, 0x25062604, 0x06150b0b, 0x01022006, 0x03040102, 0x11130f7c, 0x13210082, 0x4207870f, 0xa1290fc6, 0x03042606, 0x07160b0b,
+    0x833d830f, 0x06202434, 0x44e01607, 0x603c0b69, 0x050f1010, 0x01171727, 0x27171701, 0x10100f05, 0x29212016, 0x16202129, 0x0109081a, 0x01231787,
+    0x87190909, 0x0ce03b17, 0x140a0924, 0x0aa30b14, 0x0a0c2409, 0x7d141401, 0x07062401, 0x01240607, 0x098780fe, 0xc2427020, 0x0b10230f, 0x2f831513,
+    0x090a902d, 0x02011414, 0x00240c0a, 0x82010000, 0x02203e03, 0x005f0140, 0x25000044, 0x14151716, 0x06070607, 0x30272627, 0x26313031, 0x07062327,
+    0x580f8531, 0x35210519, 0x211a8234, 0x526f3435, 0x16172905, 0x37363317, 0x36373631, 0x42051575, 0x023a05aa, 0x10022717, 0x181e1a10, 0x1d0a0a17,
+    0x0a0b1cd0, 0x1a1e1817, 0x27021010, 0x18980707, 0x2d15b43f, 0x15151c04, 0x0e0e0606, 0x02021b1b, 0x0e0e1b1b, 0x15150606, 0x152d041c, 0x04070705,
+    0x241d9716, 0x07070416, 0x06bb4a05, 0xc001002e, 0x24001000, 0x00003600, 0x17161537, 0x11210183, 0x24ad8226, 0x15060722, 0x22c68425, 0x82111522,
+    0x07cf78ab, 0x56059761, 0x5c43050c, 0x02003e05, 0x3f3f2719, 0x3e3d2f30, 0x09080d28, 0x3d28e201, 0x30012e3e, 0x18283f3f, 0x0d080902, 0xcdaa1882,
+    0xe523080f, 0x010417d5, 0x011e0b0b, 0x0c0b1d0b, 0x0c080701, 0x0b0c011b, 0xf6fe011d, 0x010b0b1e, 0x0cd51704, 0x59600708, 0xe7430fb9, 0x83022005,
+    0x002e2bab, 0x1300005d, 0x16311716, 0x85831117, 0x90822220, 0x21055b71, 0xb7823734, 0x82343521, 0x8a2620a8, 0x37362305, 0xd5823336, 0x15163124,
+    0x91590714, 0x22058505, 0x75160706, 0x27200590, 0x23204582, 0x27203982, 0x3220e584, 0xb8212b82, 0x05245118, 0x10161829, 0x0808030f, 0x8212121b,
+    0x0e0f3697, 0x0e150c0d, 0x02160e0e, 0x03150d0e, 0xc816100f, 0x020e0d15, 0x24118216, 0x0e0d0c15, 0x24d3820f, 0x081b1212, 0x8b198308, 0xc001273e,
+    0x18100f01, 0x138370fe, 0x01203c83, 0x0b2a2582, 0x1414090a, 0x1313181a, 0xc482120a, 0x08061127, 0x10111709, 0x364a8206, 0x11100632, 0x06080917,
+    0x16171111, 0x13130a12, 0x14141a18, 0x830b0a09, 0x83698380, 0x90012149, 0x00234986, 0x7d000500, 0x312c074f, 0x47003a00, 0x5d005200, 0x33130000,
+    0x1f21c182, 0x22e38201, 0x1806011d, 0x200b36cc, 0x088b5a21, 0x26013d25, 0x64343527, 0x362c05d9, 0x06153133, 0x2721010f, 0x17232726, 0x62182f82,
+    0x072308b6, 0x82373633, 0x07062413, 0x65251716, 0xa53409a2, 0x19181fb6, 0x0b12230a, 0x091e020b, 0x0e200e09, 0x00ff0909, 0x1e330886, 0x120b0b02,
+    0x18190a23, 0x1a08161f, 0x081a2601, 0x182bb616, 0x26084263, 0x16208860, 0x84160202, 0x50012104, 0x202e0a88, 0x1112a001, 0x1007651d, 0x25501410,
+    0xfa483912, 0x30302105, 0x39360785, 0x14502512, 0x65071010, 0x4012111d, 0x4b4b1401, 0x01b00114, 0xd778200f, 0x18202006, 0x201051f6, 0x20008200,
+    0x05184903, 0x00800127, 0x00420029, 0x0cb5514d, 0x2305f449, 0x15161732, 0x20097456, 0x08c55c21, 0x26053325, 0x18070627, 0x2407ac8b, 0x37361716,
+    0x05024135, 0x41053521, 0x5020090a, 0x47068847, 0x10200790, 0x119e7d18, 0x30011022, 0x0825c118, 0x09892020, 0x18e0fe21, 0x20094f64, 0x0c8b5501,
+    0x200c3c7b, 0x845083e0, 0x843b8a29, 0x83402045, 0x33038305, 0x03000500, 0x5e02c8ff, 0x2400b801, 0x55004c00, 0x67005e00, 0x3233e782, 0x3637011f,
+    0x06171417, 0x0f06010f, 0x26270602, 0x8227013f, 0x210583dc, 0x1b833637, 0x1f313326, 0x16171601, 0x21820482, 0x2f060723, 0x211d8501, 0x0b880607,
+    0x013f3623, 0x33438236, 0x0f260731, 0x26271701, 0x1607012f, 0x26273637, 0x05170607, 0x0c830483, 0x0bb03908, 0x0b4c1d04, 0x121a0107, 0x140e2b29,
+    0x0a090824, 0x0b4e0501, 0x42080103, 0x07060528, 0x041d4c0b, 0x1988d00b, 0x07030f10, 0x0423081b, 0x0f0d0b0b, 0x0306060e, 0x0508f708, 0x55080b83,
+    0x0306070d, 0x30230b24, 0x1917170f, 0x20070b10, 0x0b0105ca, 0x08166487, 0x07171403, 0x04011403, 0x15040716, 0x15040815, 0x4a0ab801, 0x01080317,
+    0x3c180d01, 0x214a2e0e, 0x0b050407, 0x0a020d4f, 0x452d070a, 0x03080909, 0x5c0a4a17, 0x13130823, 0x2416541a, 0x60820d84, 0x6a830420, 0x1f421f26,
+    0x0407060d, 0x83330b84, 0x16450623, 0x3e070908, 0x362f0903, 0x24030a3a, 0x83140393, 0x08162267, 0x21628514, 0x3f430716, 0x01802f06, 0x002f00a0,
+    0x003d0036, 0x005f004e, 0x26432500, 0x11ee5e05, 0x3c07404c, 0x3736013f, 0x16013b36, 0x1716011f, 0x25151716, 0x33010f22, 0x33172335, 0x012b2627,
+    0x624a1815, 0x8206200a, 0x3736221d, 0x09904b21, 0x022e1085, 0x0e090980, 0x1a1a0721, 0x1a1a2424, 0x08878207, 0x0e212108, 0x0b0b0909, 0x180c2913,
+    0x2db61e17, 0x1f31641e, 0x2bfe011f, 0x711f0815, 0x43ad6535, 0xfd510f0a, 0x27080e6f, 0x210c0401, 0xc0fe0c21, 0x8021108e, 0x27428230, 0x01161623,
+    0x23161601, 0x6b820787, 0x0f157039, 0x1b680810, 0x23011110, 0x2323077d, 0x14e00131, 0x5460604c, 0x6fd0600c, 0x1e230b09, 0x8f1e0202, 0x054a430f,
+    0xc0ff002a, 0xc0014002, 0x6d005500, 0x09ab7a18, 0x0ca44118, 0x36013d22, 0x0fb19b18, 0x20061047, 0x07464115, 0x27343526, 0x15012b26, 0x116ea118,
+    0x82373621, 0x010f263b, 0x17161706, 0xa1591833, 0x23273a08, 0x26273637, 0x00013107, 0x0112121b, 0x19192510, 0x16160201, 0x100f1902, 0x27028301,
+    0x0120010f, 0x10010f0f, 0x19200283, 0x07675e18, 0x110b0c22, 0x21066264, 0x3e44e0fe, 0x12013005, 0x3aa01b12, 0x04030870, 0x03193b0a, 0x830a0909,
+    0x3a0b210a, 0x0b230a82, 0x83c00108, 0x18c0201d, 0x240892a1, 0x1514087c, 0xe8e9181b, 0x61302008, 0x20250690, 0x0814151b, 0x9fa1187c, 0x0c0b2109,
+    0x0c0c7818, 0x2a05fc67, 0x0b076054, 0x0b4b0109, 0x89070607, 0x02003209, 0xc1ff0000, 0xc0010002, 0x35001400, 0x27250000, 0x8d191a26, 0x32372709,
+    0x3536013f, 0xb65b2734, 0x23352505, 0x06071415, 0x330a1271, 0x36373635, 0x0716011f, 0xf1010714, 0x12130fd0, 0x0e0ed00f, 0x13200782, 0x0f270782,
+    0x09096056, 0x49410108, 0x0a2c0504, 0x015f0d09, 0x60090809, 0xe2040107, 0x12202484, 0x0f212482, 0x282d8301, 0x541e0f12, 0x0a040507, 0x064b4534,
+    0x090e502d, 0x040b3409, 0x05540603, 0x18050707, 0x220b8b77, 0x824b002e, 0x144b189f, 0x27262208, 0x05a15223, 0x35373624, 0x8a822726, 0x17163723,
+    0x05d96033, 0xa6820620, 0x82160721, 0x051721ad, 0x30281382, 0x27313031, 0x23300726, 0x23070d5a, 0x31373332, 0x15203b82, 0x30094e6a, 0x12d21225,
+    0x12121b25, 0x1e1e0201, 0x12120102, 0x8310881b, 0x06262c0c, 0xe0fe2606, 0x25d2080f, 0x45010201, 0x02260747, 0x08d22502, 0xa36c600f, 0x87388f08,
+    0x2b2f8249, 0x0f0f0d45, 0x0809440d, 0x0101400f, 0x40202f87, 0x00204e82, 0x2a09a761, 0x00210010, 0x00430032, 0x1a211300, 0x321fef05, 0x32331625,
+    0x2f36013f, 0x06072601, 0x0607011f, 0x5d262717, 0x33220566, 0x15823732, 0x27363736, 0x40800180, 0x140e0d01, 0x0e1460fe, 0x0140010d, 0x0fa0fdf0,
+    0x02217884, 0x23bd8400, 0x06fefe0f, 0x0c82ac19, 0x5c0c0c28, 0x0c300e0e, 0x1683300c, 0x220c0c2a, 0x010b0b22, 0x0100ff60, 0x2708b859, 0x0001f0fe,
+    0x0f01e0fe, 0x26084546, 0x62010f10, 0x84300606, 0x0e0e2635, 0x0e0e2222, 0x823e827c, 0x90ac190e, 0x0cb34907, 0x37002322, 0x3620d982, 0x8207125e,
+    0x362724ba, 0x5e05013f, 0x0d860520, 0x3f161726, 0x37071701, 0x2005636a, 0x2d148806, 0x17e93137, 0x010dda18, 0x18da0d01, 0x0783db17, 0x0901db22,
+    0x35280e8b, 0x98252598, 0x3598cd35, 0x0129148f, 0x650a0abb, 0x07100e07, 0x24078365, 0x65070e10, 0x280d8be5, 0x10104618, 0x46ae1846, 0x55148f18,
+    0x002b082b, 0x1100c001, 0x5d004b00, 0x18370000, 0x5e100781, 0x16200621, 0xa750af82, 0x012b2507, 0x07060706, 0x27092343, 0x27262726, 0x26272223,
+    0x5705445e, 0x03200811, 0x0c659319, 0xb0203283, 0x280fc84b, 0x09090e50, 0x0b2a2b3d, 0x051f4423, 0x2a0b2324, 0x49433d2b, 0x24159205, 0x25240180,
+    0x0b256c36, 0xa04cc020, 0x0001210f, 0x449d3c82, 0xff21708a, 0x0f726c00, 0x00010034, 0x02c1ff00, 0x00c00180, 0x25000052, 0x06310706, 0xdd82012f,
+    0x17013d28, 0x36013f16, 0xf682012f, 0x821f0621, 0x3f3222c4, 0x44fe8301, 0x3420052e, 0x57054854, 0x152e0690, 0x013d3637, 0x16333736, 0x1f141517,
+    0xae433501, 0x05c44b05, 0x15165b08, 0x25028002, 0x203c3125, 0x06561413, 0x05030905, 0x0102a8a8, 0x02090201, 0x56030303, 0x3c201314, 0x02252531,
+    0x03452104, 0x10100e02, 0x13141e1d, 0x01072101, 0x010f100f, 0x13012107, 0x101d1e14, 0x02020e11, 0x1c042145, 0x0c1b1a2f, 0x18180a0f, 0x033a581f,
+    0x05060d06, 0x42837070, 0x030d2108, 0x583a0101, 0x0a18181f, 0x1a1b0c0f, 0x7a0f0f2f, 0x1804046d, 0x01010f0f, 0x3c1c1312, 0xab080516, 0x0f290a82,
+    0x160508ab, 0x12131c3c, 0x26598201, 0x6d030418, 0x420f0f7a, 0x22270ac3, 0x4e004100, 0x5d370000, 0x3220081f, 0x343ccf83, 0x35232627, 0x06232726,
+    0x07221507, 0x14011d06, 0x05331617, 0x26373623, 0x15272627, 0x2007735e, 0x05814c21, 0x16852120, 0x36332523, 0x29328637, 0x0ca01716, 0x0f280f01,
+    0xe6410c01, 0x0f012305, 0xec6e0f40, 0x30013206, 0x02022f01, 0x36513736, 0x01012524, 0xfe362425, 0x059f54f0, 0x54e00121, 0xfe26059f, 0x0107d098,
+    0x04840701, 0x82108021, 0x100f2513, 0xe00e0909, 0x0c8c4882, 0x4b358027, 0x02363751, 0x84428340, 0x0e0d224a, 0x832c8314, 0x1820204c, 0x20096245,
+    0x31008200, 0x00000002, 0x017e0220, 0x00300080, 0x01000035, 0xa7493315, 0x0f162505, 0x21230601, 0x3520d183, 0x3521d582, 0x9e701836, 0x05d64208,
+    0x34083e77, 0x17152307, 0x51200135, 0xa7320e0f, 0x0806070e, 0xfe1c14b7, 0x236783fd, 0x01011c43, 0xb0207682, 0x2006bf65, 0x2fec8580, 0x3030c020,
+    0x07204001, 0x0b022419, 0x16ce0c0b, 0x15242283, 0x411e0e1e, 0x9c6b9a84, 0x1541230c, 0x90820056, 0x46180020, 0x3c2007f7, 0x082d8318, 0x4507d045,
+    0x332005fe, 0xa2830686, 0x33200a82, 0x8405757e, 0x07062106, 0x13830686, 0x0100022f, 0xfe1f1514, 0x14141f91, 0x11100101, 0x3f9f821b, 0x0e1f1414,
+    0x12010115, 0x22101b12, 0x01011617, 0x2908070e, 0x06011b1b, 0x12121b06, 0x0e150101, 0x1c252a84, 0x0110111b, 0x820a8408, 0x141b252f, 0x24150513,
+    0x12210d83, 0x2b25841e, 0x1a221716, 0x1b010214, 0x0f11291b, 0x1e224983, 0x26820112, 0x05152425, 0x441b1413, 0x0f370c53, 0x37002500, 0x16010000,
+    0x012b0607, 0x3f262722, 0x16373601, 0x5d07011f, 0x4c1808b5, 0x84680bd2, 0x074b4205, 0x0138f083, 0x0a08099b, 0x0a12c012, 0x09600908, 0x60091212,
+    0x110b0c7b, 0x0c0b1190, 0xfe210686, 0x0f1044e0, 0x1010012e, 0x110f0f10, 0x010fa00f, 0x88a00f01, 0x31832a89, 0xed434820, 0x379a8210, 0xc0ff1300,
+    0xc001ec01, 0x00002a00, 0x2f060725, 0x07061501, 0x35272623, 0xaf820a83, 0x1f22b384, 0xcf432701, 0x858e1805, 0xe9013409, 0x81140d18, 0x16301602,
+    0x0d148002, 0x81120918, 0x83091281, 0x84012012, 0x84812013, 0x81803813, 0x2a550a12, 0x954b0912, 0x16020216, 0x12094b95, 0x4b0c142a, 0x90140d4a,
+    0x0c4b2213, 0x0be35e14, 0x31001a22, 0x0a299e18, 0x2f650620, 0xab401806, 0x06246c11, 0x06070623, 0x077f5215, 0x26273423, 0xbc5d192f, 0x08f36a08,
+    0x69180720, 0x0523108e, 0x18313732, 0x200dd281, 0x75239027, 0xe82719a0, 0x02161602, 0x470b0b12, 0x0b2307e3, 0x4288120b, 0x058505ed, 0x8506e148,
+    0x5701200c, 0x1a8c0c94, 0x29181e60, 0x0216cd25, 0x07cd1602, 0x8f191010, 0x75200c6d, 0x200b2e43, 0x18ed7530, 0x200d6074, 0x084f4306, 0x2c001a2a,
+    0x59004700, 0x7d006b00, 0x1821bd76, 0x320b6a9f, 0x37361123, 0x26373631, 0x27363727, 0x22010f26, 0x44312631, 0x162305eb, 0x41033117, 0x74791037,
+    0x94d41811, 0x195b4111, 0x0dc6b218, 0x12121b2c, 0x3f110101, 0x0b151308, 0x92490140, 0x41702008, 0x5f41266c, 0x090c5e18, 0xfe214982, 0x05c741a0,
+    0x0b15912a, 0x01921307, 0x1b131201, 0x60417684, 0x0c53410c, 0x4c0cb061, 0x00260993, 0x1a00c001, 0x5b413100, 0x15b3421c, 0x0f412720, 0x126b4219,
+    0x3642d698, 0x0bd77516, 0x215c1a20, 0x05836806, 0x41125343, 0x232006e2, 0x43054961, 0x26210757, 0x3d691827, 0x4ccf341a, 0x0c141309, 0x0201014d,
+    0x12131a03, 0x13120101, 0x82121c1a, 0x980e2007, 0x933626a8, 0x13090c14, 0x096b4193, 0x1b121227, 0x00001218, 0x086f6009, 0x25001430, 0x46003500,
+    0x67005600, 0x88007700, 0x7f189800, 0x5e57162b, 0x44352009, 0x352005a4, 0x6c05c044, 0x172008fb, 0xd8087f57, 0xe0012220, 0x050559fe, 0x291b1b23,
+    0x21098801, 0xbf6db0fe, 0x400f2408, 0x8401010f, 0x061d6e04, 0x1a8d8020, 0x0d440d23, 0xa9118701, 0x22508b1a, 0x8201a001, 0x67ff207c, 0x012008a6,
+    0x78180984, 0x2021099d, 0x2080820f, 0x05c55120, 0x850e1421, 0x6020216d, 0x1d840988, 0x820d5e21, 0x87422084, 0x5e422113, 0x598e1dab, 0x00820020,
+    0xcb410a20, 0x0036330c, 0x00580047, 0x007d006d, 0x009d008d, 0x250000ad, 0x51180621, 0x00190744, 0x05200979, 0x200fac41, 0x2010b133, 0x23589603,
+    0x35272623, 0x8c0b1542, 0xeb4e180f, 0x37362708, 0x17161716, 0x45423715, 0x0002220e, 0x058978fe, 0x2309e241, 0xfe1b1212, 0x2309a26f, 0x010f400f,
+    0x9b0dba41, 0xfe30210d, 0x82052642, 0x78012043, 0x57820516, 0x42b0fe21, 0x16420f23, 0x410d8c0d, 0xa0210bfc, 0x79478201, 0x4682050c, 0x121b2024,
+    0x66670112, 0x05f84108, 0x9b0dca41, 0x5001220d, 0x85438201, 0x2a5582eb, 0x1b1b2940, 0x010fb001, 0x88200f01, 0x42022035, 0x0d8d0d27, 0x2b8d0220,
+    0x5c000021, 0x240806e7, 0x00c0017f, 0x00310008, 0x005e0042, 0x00800072, 0x37000091, 0x06310706, 0x013f3617, 0x31342707, 0x33363130, 0x49018232,
+    0x847005d3, 0x52062005, 0x162305d0, 0x44373233, 0x068205a8, 0x06070624, 0x9c180627, 0x252508b9, 0x26312726, 0x05ef6007, 0x26601483, 0x013f2a05,
+    0x27262736, 0x31373605, 0x82148336, 0x253e821f, 0x34372607, 0x2f831733, 0x82163721, 0x20338226, 0x204e8227, 0x58168226, 0x268206f5, 0x1bcf3408,
+    0x12011010, 0x206f0820, 0x01026459, 0x1f150101, 0x1b0f1d1c, 0x68742424, 0x03080912, 0x24240820, 0x06232d2c, 0x26121504, 0x61062222, 0x160d0301,
+    0x82011017, 0x0d250806, 0x09091111, 0x439e0103, 0x154c4a4b, 0x20040e0f, 0x271b1a06, 0x30212127, 0x09292831, 0x09080320, 0x03effe12, 0x8325860d,
+    0x82112035, 0x2a452d5c, 0x21021819, 0x0c2d4343, 0x832c2221, 0x49084a8e, 0x1409cb03, 0x0c131914, 0x03b3322b, 0x04051531, 0x06051601, 0x13120b39,
+    0x2029b316, 0x01131220, 0x180b291a, 0x07891a18, 0x03050e05, 0x11060609, 0x03020909, 0x25100d0e, 0x0c0d0d25, 0x150f0e03, 0x2d2e2cb5, 0x05072021,
+    0x5c821211, 0x1316b325, 0x83610a13, 0x82042023, 0x05063684, 0x0904040e, 0xc7010506, 0x29201f09, 0x1a0a0d29, 0x06151527, 0x83148498, 0x83032048,
+    0x050637a9, 0x00000400, 0x4001c0ff, 0x1400c001, 0x38002600, 0x00004a00, 0xe3581601, 0x089d5808, 0x06033322, 0x200fe07f, 0x062d4835, 0x48272621,
+    0x4e190725, 0x00311247, 0x0112121b, 0x442d2d02, 0x022d2d44, 0x1b121201, 0x088e44c0, 0x970f4773, 0x0532530f, 0x83e0fe21, 0x7c498341, 0xfe210566,
+    0x0f3773c0, 0x108f2020, 0x108fe020, 0x60180020, 0x372a0c1b, 0x75003c00, 0xc1008700, 0xf382d300, 0x2c691720, 0x06ff4c05, 0x55750720, 0x23072106,
+    0xe1590887, 0x4d332006, 0xfb820526, 0x33373633, 0x07311716, 0x15232733, 0x16171607, 0x011f3617, 0x29088416, 0x06070615, 0x010f1607, 0x97182706,
+    0x0624083c, 0x3726012f, 0x2908f057, 0x36013f26, 0x36373617, 0x30191737, 0x252011f3, 0x4db25684, 0xf0743120, 0xa3012611, 0x090e504d, 0x05454909,
+    0x21211628, 0x21212828, 0x08863f17, 0x16851620, 0xa03d1e82, 0x140e0d01, 0x83132060, 0x78503080, 0x0b0b0414, 0x0d0b0f10, 0x1303060b, 0x03130202,
+    0x2b0a8206, 0x0b0b100f, 0x12101504, 0x110a0b05, 0x14231a85, 0x85140202, 0x0a11261a, 0x1112050b, 0x0fbb4108, 0x04200124, 0x4b981014, 0x4b871a84,
+    0x4b826689, 0x87087e44, 0xa6012250, 0x20a28266, 0x25038240, 0x0109080e, 0x0082111e, 0x05851e20, 0x08090123, 0x20c3820e, 0x20038240, 0x242d8450,
+    0x40406619, 0x82b28780, 0x2281a84b, 0x47010214, 0xba4709c4, 0x8c9b2006, 0x204aa896, 0x1072423b, 0x2d091354, 0x00460041, 0x006a0058, 0x16330100,
+    0x6e42011f, 0x012b210c, 0x2505125c, 0x27262726, 0x46183734, 0x342211e7, 0x78423637, 0x1731250b, 0x27331523, 0x20111c62, 0x10914321, 0x61100126,
+    0x316c141e, 0x2b080542, 0x20010121, 0x1f30301f, 0x42010120, 0x21200a89, 0x240d0b42, 0x4c9d5161, 0x11d141c1, 0xa0231190, 0x41881701, 0x0923079c,
+    0x84080809, 0x205e8256, 0x89008208, 0x05bf4c0b, 0x62824020, 0x41837020, 0x60604022, 0x4111ba43, 0x00201035, 0x0a8f8418, 0x0c000337, 0x34002200,
+    0x00004b00, 0x37231737, 0x26070617, 0x16373627, 0x00ab1817, 0x26053215, 0x010f0627, 0x3f161706, 0x16173301, 0x012f3637, 0x09e34a17, 0x16373222,
+    0x2b05af51, 0xd0150706, 0xd0152a15, 0x02161602, 0x60200383, 0x47084e5b, 0x01370813, 0x07e6fec0, 0x48070e0f, 0x0c151208, 0x0b065a05, 0x48071215,
+    0x500d0bba, 0x11230730, 0x850a070e, 0x2ad2233c, 0x09852a2a, 0xf8160226, 0x1b121201, 0x0f034018, 0x010c8d36, 0x15900c01, 0x0b12070c, 0x0c07120b,
+    0x04279015, 0x1f141401, 0x08244983, 0x90160208, 0x1c203c83, 0x4505b351, 0x2527068b, 0x00003200, 0x76362325, 0x17210d81, 0x05285d23, 0x2709cc6f,
+    0x012f2635, 0x07061716, 0x25073957, 0x112d2801, 0x30500a0a, 0x0a0a2307, 0x5b832d11, 0x16026026, 0x60021620, 0x883d0a83, 0x0f01022e, 0x0f11110f,
+    0x2e02010f, 0x1d1d1ac0, 0x2626431c, 0x26260101, 0x1d1d1c43, 0x2027841a, 0x20278398, 0x2d0a8498, 0x1b3e02b0, 0x12121c1c, 0x3e1b1c1c, 0x3f530002,
+    0xc0012905, 0x1900c001, 0x42003600, 0x9718a182, 0x252318bc, 0x4b013f36, 0x33250689, 0x06151716, 0x0772500f, 0x27262326, 0x22211335, 0x22054655,
+    0x82152133, 0x180d204e, 0x23149d97, 0x0f01d0fe, 0x0ecd0219, 0x30010f25, 0x59f0010f, 0x20210866, 0x7d971870, 0x120d2a11, 0x160e5209, 0x01010ec0,
+    0x28038230, 0x0d02300e, 0x01010f20, 0x26038270, 0x0f01700f, 0x42d0fe20, 0x0022068e, 0x3f6b0005, 0x00112807, 0x00320020, 0x82560051, 0x10e446cf,
+    0xde181720, 0x27200dc1, 0x23350e83, 0x16171615, 0x27262117, 0x35343534, 0x35173237, 0x27262726, 0x21058523, 0xca5d0706, 0x24058205, 0x36373621,
+    0x2b178233, 0xf0011533, 0x0228293d, 0x3d292802, 0xde180787, 0xe0200cd2, 0xc02b9e82, 0x140e0d01, 0x01273801, 0x830808b0, 0x1850200a, 0x4408ff9d,
+    0x682805dc, 0x29232319, 0xe0a0a0a0, 0x4d83458b, 0x08dbde18, 0x0f0f0135, 0x0f012001, 0x0e149030, 0x412f010d, 0x05050303, 0x713101a0, 0x30200cc4,
+    0x70275483, 0x6011111e, 0x82003030, 0x410c2000, 0x2e2e0803, 0x48003b00, 0x62005500, 0x7c006f00, 0x151a8900, 0x012009d7, 0x200eb15e, 0x05305411,
+    0x16373626, 0x35331517, 0xb5460688, 0x17152106, 0x26053d55, 0x36331716, 0x55053537, 0x33210a1a, 0x20198b27, 0x0bf05f25, 0x198b2520, 0x59182720,
+    0x198b0c09, 0x4d8b0720, 0x012233a6, 0xa91870e0, 0x0d280ef6, 0x0210140e, 0x40021616, 0x01200484, 0x60200e82, 0x58182183, 0xfe200abe, 0x2405074b,
+    0x0f01010f, 0x12591820, 0x9001210a, 0x04841184, 0x0b405918, 0x23602d8a, 0x202c8a0a, 0x05c44201, 0x0f214d82, 0xee581801, 0x0850600c, 0x75000121,
+    0x088308ea, 0x83400121, 0x16482591, 0x48160202, 0x30200585, 0x9020c487, 0x56956d8a, 0x5020b18a, 0x1020b089, 0x2009bd60, 0x95158970, 0x94d02041,
+    0x02002f2b, 0xe1ff0000, 0xa101ff01, 0x67002400, 0x904f0000, 0x18312005, 0x751d97fb, 0x262f05c7, 0x2f263527, 0x36372601, 0x3132011f, 0x18161716,
+    0x25077769, 0x3134012f, 0x17822726, 0x47423720, 0x221a8205, 0x7e270607, 0x172006e9, 0x2005e65e, 0xaafb1807, 0x0204280d, 0x24320601, 0x18311324,
+    0x0809aafb, 0x473a3921, 0x0223073e, 0x0d021212, 0x0511040c, 0x01041207, 0x090b0b0c, 0x04020109, 0x10061504, 0x85031313, 0x0b08271d, 0x12080410,
+    0x1a850809, 0x0610033b, 0x03141513, 0x1b01a101, 0x3a2f2f1c, 0x1b27384b, 0x0405021c, 0x11110104, 0xc0fb1810, 0x20fb320c, 0x02120a08, 0x030b1202,
+    0x11080204, 0x05020411, 0x2d008202, 0x04030405, 0x03010106, 0x201f0d0c, 0x1f840909, 0x83040121, 0x0104211e, 0x062a1d82, 0x05030402, 0x0d0d0402,
+    0xa76f001f, 0x001b290b, 0x0083005e, 0x27260100, 0x0621f682, 0x0d3a4107, 0x8205d064, 0x06152214, 0x12304107, 0x36313424, 0x30412627, 0x58052024,
+    0x30250597, 0x14312231, 0x05554815, 0x83171621, 0x1716265d, 0x27363732, 0x237b8230, 0xa0012726, 0x07a56018, 0x0e290132, 0x03010d0c, 0x3a050202,
+    0x583a2f25, 0x92023b3b, 0x08334d41, 0x15120724, 0x4a010314, 0x36020127, 0x01015236, 0x51343302, 0x45323211, 0x36252a33, 0x03020205, 0x0c0c0b03,
+    0x631a1001, 0x2a22186b, 0x6441091f, 0x03012113, 0x41096541, 0x01250685, 0x11120704, 0x0e654104, 0x3e2ee222, 0x24085a83, 0x07070101, 0x1237374b,
+    0x0125253a, 0x02141501, 0x02040405, 0x00170f0f, 0x00010000, 0x01c0ff00, 0x00c0017f, 0x610c822c, 0x94640567, 0x0b025f0a, 0x09316318, 0x1732332a,
+    0x7f011516, 0x600d0909, 0x41240382, 0x6009090e, 0x63052649, 0x08200582, 0x01220e84, 0x14824020, 0x2006f75f, 0x07a363e0, 0x00222789, 0x7b830a00,
+    0x82000221, 0x0048377b, 0x0056004f, 0x0064005d, 0x007d006b, 0x008b0084, 0x25000092, 0x43182607, 0x088207d9, 0x23272627, 0x06170706, 0x06025e07,
+    0x06260882, 0x17161507, 0x43181637, 0x088207df, 0x33171627, 0x36273736, 0x06ab5b37, 0x36210882, 0x05064837, 0x23204a83, 0x36213d83, 0x82448437,
+    0x22398306, 0x82172726, 0x1839825a, 0x8312f694, 0x07062147, 0x6c824e84, 0x24082685, 0x0911ef01, 0x090a0c23, 0x0b0b0d14, 0x01013c2e, 0x010f1e0f,
+    0x0b2e3c01, 0x09160c0b, 0x08230c0a, 0x02020f11, 0x2222850f, 0x820c0b16, 0x89022022, 0x150d2122, 0x09212283, 0x3c228310, 0x2a1e25d5, 0x34040f0e,
+    0x2b0d0f04, 0x3168251e, 0x06400309, 0x03401b15, 0x06153109, 0x201b8583, 0x0be1551a, 0x0f041a24, 0x28882a0e, 0x27842520, 0x84df4021, 0x82568b79,
+    0x0a0d2479, 0x940c1609, 0x9179859c, 0x067e229c, 0x857f8315, 0x8340207c, 0x1e252296, 0x206f8577, 0x201a8583, 0x0b67577d, 0x288c7d20, 0x97847320,
+    0x93780420, 0x00112c0b, 0x004c0041, 0x25000057, 0x48012f06, 0x3632050e, 0x35373637, 0x37230607, 0x26352726, 0x012b2627, 0xba762326, 0x0706220d,
+    0x05d27022, 0x0706152d, 0x17011d06, 0x37152135, 0x65273435, 0xf7650ae4, 0x07063806, 0x00011716, 0x01d11619, 0x01140e0d, 0x0d0e14a0, 0x1916d101,
+    0x83110dee, 0x014d2f0f, 0x04040401, 0x12110e05, 0x11120f0f, 0x0c82050e, 0x4d010122, 0x11292383, 0x0160120d, 0xfe126040, 0x05185ac2, 0x01010f22,
+    0x8306225a, 0x011f2409, 0x46d59710, 0x0d350547, 0x0f97d614, 0x2c0d0afe, 0x010e0e14, 0x04030303, 0x010b0b0b, 0x24048201, 0x03020404, 0x2f648301,
+    0x0f0a0d2c, 0xb9460a17, 0x170a46b9, 0x0e015c0f, 0x0e2b4083, 0x0f014001, 0x0d02010e, 0x8200010f, 0x68022000, 0x16260803, 0x00002100, 0x7b7a2301,
+    0x16112605, 0x21171617, 0x06657a36, 0x7a072721, 0xd0220a55, 0xcb8440c0, 0x0983d589, 0x15a1802c, 0xa0150202, 0x16020217, 0xe6606001, 0x20258905,
+    0x29b08320, 0x151601d7, 0x16160102, 0x738b0001, 0x739a2f20, 0x85054345, 0x055b467a, 0x17163325, 0x96010706, 0x03382681, 0x3a011615, 0x21868215,
+    0x66820338, 0x8b9b3820, 0x15211c83, 0x8491833a, 0x02392130, 0x174b3082, 0x40023405, 0x1800c001, 0x7f002a00, 0x36130000, 0x17162137, 0x45010f16,
+    0x262905e6, 0x3d26012f, 0x37262701, 0x09c75631, 0x485f3620, 0x36272e06, 0x16173233, 0x26273637, 0x27263527, 0x05f87c06, 0x2b052d67, 0x30071617,
+    0x16071615, 0x22270607, 0x26260182, 0x06072627, 0x2e833217, 0x16151726, 0x35373617, 0x24071e4c, 0x22312330, 0x081e8231, 0x31303721, 0x36373435,
+    0x0b043137, 0x19b00119, 0x6a100a0b, 0x0128273d, 0x02031201, 0x0fb70d40, 0x4a3c020a, 0x2923053d, 0x4a290202, 0x2c08058b, 0x0c0a09a3, 0x02050f0e,
+    0x0109090e, 0x09010f0f, 0x0401140a, 0x020e0e12, 0x0105080f, 0x05010201, 0x0e0e0a07, 0x03030101, 0x0d03050f, 0x21118201, 0x26840d0b, 0x02150923,
+    0x232e8211, 0x06080f01, 0x033a1582, 0x0116a901, 0x13171601, 0x2f2f0d83, 0x02242941, 0x100a3001, 0x1713e04f, 0xf74aa7fe, 0x03253d0f, 0x0e0e0204,
+    0x09020205, 0x0f01010f, 0x0905010a, 0x0708171c, 0x04040202, 0x03010203, 0x04236082, 0x82010501, 0x0e0e3370, 0x03030206, 0x02020e0c, 0x04020b0e,
+    0x09181b0a, 0x00820407, 0x02010122, 0xc75f1c82, 0x0065270a, 0x007e0072, 0x8d4a1300, 0x240d890d, 0x1d161732, 0x26048901, 0x2b060714, 0x83233501,
+    0x33152101, 0xb44b0182, 0x05b34b05, 0x82333521, 0x15232101, 0x22200184, 0x2106b373, 0x794f3533, 0x35332a07, 0x22133736, 0x1d063107, 0x23148201,
+    0x27232627, 0x22210685, 0x28118207, 0x28021678, 0x02161602, 0x84048330, 0x090e2209, 0x08734f09, 0x83204021, 0xf3ca1800, 0x84502008, 0x062d5c0e,
+    0x02222685, 0x2d828816, 0x0c824020, 0x04832020, 0x01270b82, 0x081602c0, 0x8d021608, 0x4f682005, 0x6020066d, 0x60200782, 0xa0252582, 0x80606080,
+    0x081d4aa0, 0x0f853020, 0x20831c86, 0x68246583, 0xf0fe0216, 0x30211382, 0x20318230, 0x06b55f30, 0x43412020, 0xff012e05, 0x3a00c001, 0x67005500,
+    0x26250000, 0x05437e27, 0x1857d284, 0x6d342005, 0x0727058e, 0x23071415, 0x88352726, 0x0623220e, 0x05b55507, 0x3f363329, 0x07273601, 0x83312726,
+    0x62352002, 0x16210523, 0x6e018217, 0x07210597, 0x10375c35, 0x09fd0130, 0x0b0c4014, 0x0c0b1111, 0x09140901, 0x0a820b01, 0x010c0c26, 0x0208140a,
+    0x0b351584, 0x09143f01, 0x1b660e08, 0x572b2526, 0x080e663a, 0x16151bfd, 0x2200820d, 0x891b1516, 0x0b384609, 0x01128d27, 0x0b0c10d0, 0x253e8201,
+    0x01010986, 0x0c86af08, 0x0c82ae20, 0x86860921, 0x01d0310c, 0x6e101312, 0x01100f1d, 0x13106e3b, 0x0f10016d, 0x05910a82, 0x0c824c18, 0x250df35b,
+    0x004b0038, 0x1c5d2500, 0x05566706, 0xb3652720, 0x06b96506, 0x32331632, 0x16073733, 0x013f3217, 0x36331617, 0x16172737, 0x2a06c265, 0x27072726,
+    0x37072717, 0x82273707, 0x373c0815, 0x17073717, 0xf0011707, 0x09042a6e, 0x235e0c09, 0x050b0d05, 0x090d5e22, 0x6e2a0409, 0x0c02020e, 0x04074b62,
+    0x02020c05, 0x1102046c, 0x44440608, 0x02110806, 0x060e6c04, 0x624b0806, 0x58081682, 0x02349d0e, 0x33022121, 0x14352f23, 0x2d100f2d, 0x242f3513,
+    0x0e6810f5, 0x3c060807, 0x6b0d0d6b, 0x0807063c, 0x0310680e, 0x35070c0c, 0x0b0a0a53, 0x01127118, 0x07595907, 0x18711201, 0x0b0b0b02, 0x0c073553,
+    0x0c6d030c, 0x362a2a36, 0x0819280c, 0x33331d32, 0x1908321d, 0x20f08228, 0x23691801, 0x827c2008, 0x330721ed, 0x2b075b50, 0x35262733, 0x35343734,
+    0x37362733, 0x33230182, 0x5f161716, 0x14200690, 0x08d94418, 0x06073722, 0x2006fd6b, 0x07fd6b36, 0x37361325, 0x19131716, 0x2208a15b, 0x83010f06,
+    0x012f2237, 0x25458417, 0x26272627, 0x4f823437, 0x07823420, 0x7a373621, 0x4b0805ba, 0x17143307, 0x07161514, 0x283b2b02, 0x55414221, 0x21414154,
+    0x01053b28, 0x1c0b292f, 0x05042a1b, 0x03050508, 0x0638020a, 0x0a190601, 0x1b08060a, 0x1b02251a, 0x03040505, 0x01062a14, 0x142a0601, 0x05050403,
+    0x06010c1e, 0x1e0c0107, 0x1b29178f, 0x1b1a2502, 0x0a0a0608, 0x243e8219, 0x030a0139, 0x374e8205, 0x1c1b2a04, 0x012f290b, 0x3b9b0501, 0x022b2b48,
+    0x482b2c01, 0x051a1a3b, 0x35085382, 0x2a293229, 0x0701041d, 0x1a190807, 0x07052c46, 0x1f170508, 0x1a25211e, 0x1342081a, 0x06040403, 0x06020822,
+    0x21090206, 0x03040406, 0x07200115, 0xfe070101, 0x198315e0, 0x89092121, 0x41123819, 0x251a1a08, 0x171f1e21, 0x05070805, 0x191a472b, 0x01070708,
+    0x822a1e03, 0x21ad835e, 0x5b511a1a, 0x009a220d, 0x1c5b51a6, 0x25055642, 0x17063736, 0x03831716, 0xc6693720, 0x118e1805, 0x0a796d07, 0x011f3230,
+    0x30333637, 0x16173231, 0x1617010f, 0x7f411415, 0x22232105, 0x27058141, 0x36373627, 0x07171627, 0x3f244482, 0x30151601, 0x072e0182, 0x17141506,
+    0x33163114, 0x31303732, 0x59520637, 0x83172006, 0x2f36240f, 0x82313401, 0x51372001, 0x2a0825bf, 0x060615c5, 0x101b0404, 0x04040d1f, 0x0a091613,
+    0x010b021f, 0x01020101, 0x03120801, 0x02081203, 0x0c020302, 0x03030105, 0x820e0501, 0x01022816, 0x03110802, 0x84091103, 0x0127080b, 0x0b1f020d,
+    0x04131608, 0x101f0d04, 0x0604041b, 0x25051506, 0x03040103, 0x0a180302, 0x29291d1d, 0x180a1d1d, 0x82050302, 0x05252212, 0x221152fb, 0x8316b021,
+    0x201a2c44, 0x17171511, 0x1e20180f, 0x84072108, 0x0e01228b, 0x2c828304, 0x02030e04, 0x6f080202, 0x09700404, 0x85098201, 0x0f032115, 0x012d0a82,
+    0x1e082208, 0x170f1820, 0x20111517, 0x08d2831a, 0x10101620, 0x03200101, 0x01020203, 0x26150103, 0x01011817, 0x15261818, 0x04050502, 0x10010120,
+    0x2b74fe10, 0x00402106, 0x053b0082, 0xc1ff0000, 0xbd014002, 0x2f002000, 0x45003a00, 0x00005500, 0x36253537, 0x44150517, 0x6267053e, 0x06826706,
+    0x2105985f, 0xc3542625, 0x05ea4106, 0x27360722, 0x02301086, 0x1f060726, 0x36371601, 0x3505022f, 0x36013f36, 0x27080c82, 0x26251517, 0x01003107,
+    0x01090a16, 0x060e2717, 0x0b2f0e02, 0x0af0110a, 0x0a11f00a, 0x020e2f0b, 0x01270e06, 0x2b040424, 0x1f820984, 0x2c0c0128, 0x06010c64, 0x1083560e,
+    0x83c95721, 0x562f0830, 0x0c01060e, 0xf2fe7b57, 0x0ff01f02, 0x021ff00f, 0x1212f2fe, 0x02522ad1, 0x0a2a5202, 0x050e0e03, 0x0d10890e, 0x0236040d,
+    0x0d043602, 0x8289100d, 0x030e2810, 0x02024e0a, 0x820e050c, 0x21228408, 0x0b833a0c, 0x04841820, 0x33831e20, 0x04841820, 0x214f682f, 0x05500c22,
+    0x220c5005, 0x06064f21, 0x31008200, 0xff1f0003, 0x011f02c2, 0x007400c0, 0x0086007d, 0xd5820100, 0x17161728, 0x0f060706, 0xdb823501, 0x37360122,
+    0x8305c64e, 0x74f0830b, 0x064d05a9, 0x27152105, 0x21052657, 0x35822736, 0x17060739, 0x16011f16, 0x0717013f, 0x23222722, 0x17160706, 0x15013f36,
+    0x18140706, 0x2008a440, 0x83598235, 0x0722264d, 0x37272322, 0x762b8217, 0x072a05b8, 0x26270706, 0x1716013f, 0x15823623, 0x010f4508, 0xc0012726,
+    0x0507090b, 0x12010119, 0x2c4c2213, 0x1a080306, 0x01010f0f, 0x05190f0e, 0x3b3b0704, 0x19050408, 0x0f100f0e, 0x0602091a, 0x13214c2b, 0x06190112,
+    0x3c0b0908, 0x0b191718, 0x0b083814, 0x012f1d50, 0x16330082, 0x13160202, 0x010f2904, 0x0d0d0909, 0x0f010909, 0x83130429, 0x82022013, 0x2f20081b,
+    0x080b501d, 0x100d1c35, 0x60381918, 0x0d061b02, 0x011a080d, 0x08190180, 0x1c050d0d, 0x057f0101, 0x283b4f82, 0x2322292f, 0x24143616, 0x0f100907,
+    0x1f201919, 0x0b0f1919, 0x35360609, 0x820b0907, 0x201e210f, 0x29080f82, 0x24070912, 0x22173614, 0x282f2823, 0x0609080b, 0x463f3e22, 0x0941161b,
+    0x21142a05, 0x15160201, 0x1c130202, 0x0e12091e, 0x84820908, 0x1e091224, 0x9482131c, 0x02162308, 0x2a142101, 0x213d0905, 0x3838402a, 0x12236f20,
+    0x1126260c, 0x13212113, 0x0c262611, 0x00002312, 0x93670002, 0x00133c07, 0x13000036, 0x15021f36, 0x06071617, 0x27262107, 0x35013f26, 0x3307013f,
+    0x89353315, 0x33302403, 0x89011f30, 0x31363c20, 0xf0353132, 0x03ac110f, 0x07051431, 0x1640fe19, 0x2f140508, 0x40b0ac05, 0x82304028, 0x01013803,
+    0x08051230, 0x1740fe17, 0x30120508, 0xbc010101, 0x02620808, 0x770d1b01, 0x0d260549, 0x6202011b, 0x0084c0dc, 0x01c43608, 0x16160e20, 0x16160101,
+    0xc401200e, 0x05000000, 0xc0ff2000, 0xc0016002, 0x25001100, 0x4c003500, 0x00005100, 0x012f2217, 0x16171415, 0x37322133, 0x07013d36, 0x06c26406,
+    0x28059b49, 0x06072221, 0x3533011d, 0x21088517, 0xc2821617, 0x26273424, 0x0f852523, 0x2005d954, 0x83398433, 0x23072116, 0xc033d982, 0x09840d0f,
+    0x00010e09, 0x8409090e, 0x12010f0d, 0x82e01b12, 0xc0fe210f, 0x60220f82, 0x1683ff80, 0x09099722, 0x22820282, 0x1a231485, 0x83031211, 0x2625821d,
+    0x01404020, 0x488c6409, 0x8c27059b, 0x01010964, 0x7312121b, 0xc0220773, 0x22824020, 0x06720c25, 0x820c7206, 0x82602021, 0x0120250c, 0x86191010,
+    0x3f830882, 0x40408022, 0x220d9355, 0x821c0008, 0x392908e9, 0x61004d00, 0xa5009c00, 0xcd00b900, 0xea00e100, 0x26010000, 0x07062327, 0x27353315,
+    0x36313732, 0x26272635, 0x06313027, 0x05f34207, 0x1c871720, 0x1c923720, 0x13912120, 0x47673b20, 0x83448e05, 0x052c4b5f, 0x22514e85, 0x250b8505,
+    0x17161716, 0x21821533, 0x16070622, 0x27069c7f, 0x33352327, 0x37363736, 0x05208b82, 0x23207f9b, 0x44877fa7, 0x0120022f, 0x010f200f, 0x090e8040,
+    0x0e0e0209, 0x22038302, 0x860e0909, 0x8da02015, 0xe0fe2115, 0xc0200f8d, 0x70200e8d, 0x3b824882, 0x5184c020, 0x08841b83, 0x1b1b0124, 0x2556c029,
+    0x010f2205, 0x058d6b60, 0x29c07029, 0x01011b1b, 0x8430fe0f, 0x40402122, 0x578e488d, 0x1d8d6020, 0x33858020, 0x2205eb55, 0x82319090, 0x170f2b72,
+    0x17020217, 0x090d0f17, 0x6182310a, 0x15900f20, 0x0d8d238d, 0x0f012123, 0x20618290, 0x203883b0, 0x201a82b0, 0x83418490, 0x014021a0, 0x200afe6b,
+    0x82c88340, 0xb010201b, 0x36928660, 0x04000000, 0xc0ff0000, 0xc0018002, 0x4e002200, 0x6e005e00, 0x49010000, 0x30230593, 0x6a171631, 0x212405b4,
+    0x37362726, 0x30210183, 0x27078431, 0x26033133, 0x15070627, 0x21084453, 0x32822133, 0x4e06f26a, 0x232505d1, 0x012f3435, 0x23238307, 0x1f360335,
+    0x82052178, 0x36372613, 0x3307013f, 0x08178215, 0x0617142f, 0x2726012b, 0x01112726, 0x1a050890, 0x05292121, 0x2d030404, 0xfe1d0101, 0x01011d9c,
+    0x0404032d, 0x21212905, 0x7009041a, 0x02161602, 0x05604330, 0x071b4118, 0x13833020, 0x18403108, 0x01161918, 0x0a0ada40, 0x0e0f1910, 0x190f0ea0,
+    0x1ea04610, 0x0c0a0602, 0x0d0e1440, 0x06c00101, 0x1b191a22, 0x03020303, 0x1e2b371f, 0x1f372b1e, 0x03260a82, 0x221a191b, 0x6457fe06, 0x55751805,
+    0x0813850d, 0x121e3b27, 0x1e121515, 0xb301483b, 0x140c0606, 0x02201d1c, 0x1c1d2002, 0x899b0c14, 0x0e802512, 0x0d01050d, 0x3001140e, 0x08e75500,
+    0xc001002d, 0x7e001200, 0x00009c00, 0x73331601, 0x2f2a056e, 0x010f2601, 0x1f141506, 0x07820602, 0x36012b22, 0xec82e882, 0x2906c747, 0x16171637,
+    0x06071417, 0x534d2707, 0x41332006, 0xd15b0567, 0x21278405, 0x22821415, 0x2c052056, 0x36332726, 0x3336013f, 0x1d161732, 0x52308201, 0x07210562,
+    0x880c8206, 0x82352023, 0x37272234, 0x05924d06, 0x07262723, 0x85198406, 0x3d36223f, 0x2c1d8201, 0x03690107, 0x16030404, 0x07160303, 0x08058307,
+    0x1e293325, 0x2f0f0a18, 0x19080911, 0x28382118, 0x091b0c0b, 0x14110d0a, 0x0e010d0e, 0x091f150e, 0x10040405, 0x5d210904, 0x43340723, 0x020f1e1e,
+    0x06050401, 0x23240f0f, 0x2424363b, 0x16110101, 0x37084184, 0x010b0a10, 0x1e0b0a0a, 0x040b1514, 0x05010505, 0x2f151404, 0x011d1c26, 0x2b1c1c01,
+    0x26272b2a, 0x0b021919, 0x01050909, 0x1b1a0d0d, 0x15163a27, 0x08010101, 0x83010908, 0x90848882, 0x16060622, 0x823a0784, 0x0a191c01, 0x16202922,
+    0x24080517, 0x06140b0e, 0x01010b06, 0x15140e0d, 0x32820e0d, 0x08070725, 0x73010722, 0x1b3408a9, 0x03021f1b, 0x07020105, 0x1a22231d, 0x2501011a,
+    0x1d233624, 0x0a264083, 0x0a640f0b, 0x38820707, 0x02040f25, 0x4d260601, 0x192406ed, 0x2b642519, 0x7c219482, 0x3653821f, 0x0706030d, 0x12020c08,
+    0x01111111, 0x070f0e02, 0x0a240303, 0x4b050404, 0x022e068f, 0x00c00180, 0x00d400cb, 0x250000dd, 0x597d0726, 0x30272207, 0x05054331, 0x22065441,
+    0x63373617, 0x06200504, 0x2205da41, 0x48363727, 0x954506bf, 0x26072405, 0x18072223, 0x240a426a, 0x1f161716, 0x7d1a8301, 0x272206a9, 0x49820706,
+    0x4208a641, 0xd2450500, 0x25518405, 0x16170607, 0x1f823637, 0x20058643, 0x235e8432, 0x17163736, 0x85864385, 0x33163723, 0x83138232, 0x053c493d,
+    0x1621a383, 0x21338517, 0x92833316, 0x82313221, 0x36372345, 0x1a850127, 0x25070622, 0x0c834383, 0x71022d08, 0x0e121319, 0x03060916, 0x0e040304,
+    0x02020101, 0x0e191b0f, 0x080f070f, 0x16020216, 0x080e0f19, 0x110a080e, 0x1911110b, 0x10111a11, 0x26087c41, 0x1f1a120b, 0x6d13191f, 0x01210822,
+    0x251e8210, 0x0c111119, 0x30820a10, 0x190e0f22, 0x092e3d83, 0x0801010c, 0x1b180f0e, 0x0102020f, 0x60820e01, 0x06032108, 0x120e1609, 0x06131913,
+    0x07061509, 0x0d0a0c07, 0x0c0b100d, 0x04090918, 0x25180303, 0x15101007, 0x212f3783, 0x0c0d1616, 0x0b0b0a05, 0x0d0c050a, 0x83211616, 0x10153e13,
+    0x18250710, 0x09040303, 0x0b0c1809, 0x0a0d0c10, 0x150a1601, 0xfe130609, 0x01010f4f, 0x2103830f, 0x09870001, 0x08096430, 0x05110a07, 0x0f060702,
+    0x01011615, 0xb8820303, 0x0e0e0e23, 0x050c4917, 0x19290985, 0x12141411, 0x12110322, 0x07de421a, 0x250f1426, 0x0f250808, 0x2c08926d, 0x0311121a,
+    0x14141222, 0x02021911, 0x22348217, 0x82160201, 0x17300889, 0x0d0d0201, 0x1001010d, 0x02020203, 0x060f1515, 0x11050207, 0x0908070a, 0x05131609,
+    0x09020303, 0x01060707, 0x11120a05, 0x15060d11, 0x1d1e1e0d, 0x172a7485, 0x151e1e18, 0x1e150101, 0x4182181e, 0x1d374883, 0x150d1e1e, 0x12110d06,
+    0x01050a11, 0x11080606, 0x15130506, 0x850c010a, 0x010f22cc, 0x23088720, 0x00050000, 0x28079f49, 0x001f001a, 0x002e0024, 0x0c895b37, 0x4205fa41,
+    0x2638077b, 0x27260327, 0x17371537, 0x27350706, 0x36313736, 0x26071537, 0x35270527, 0x18055f42, 0x38191d5a, 0x60293720, 0x37296040, 0x2d2c02e0,
+    0x01178845, 0x46886801, 0x01012d2c, 0xfa811817, 0x165b1807, 0x3921080c, 0x0122223a, 0x240a43fe, 0x4c7a7a4c, 0x437a0b23, 0x0d343349, 0x332a6cae,
+    0x0dae6c5d, 0x33493334, 0x056b522a, 0x01800223, 0x20b582b9, 0x2bb3832b, 0x1f363713, 0x011d1601, 0x15171617, 0x600c8353, 0x31210535, 0x2aea1807,
+    0x4ce93016, 0x094c0b0b, 0x60011629, 0x1c121201, 0x8212131a, 0x28172408, 0x18d00901, 0x2b121fea, 0x09094c69, 0x6d0d094c, 0xe51b0e18, 0x3108de61,
+    0x0e1be560, 0x090d6d18, 0x01ee38f3, 0x5c140e0d, 0xea180f1b, 0x00250a16, 0xff000004, 0x28e482e0, 0x001500a0, 0x003d0029, 0x0c0b6751, 0x2726212b,
+    0x36112726, 0x21373637, 0x05095405, 0x0860cd18, 0x26273428, 0x17141723, 0x4d4a1631, 0x07222109, 0x0cf5ac19, 0x01211889, 0x086b6280, 0x2605136a,
+    0x011b1212, 0x4600ff40, 0x058505d4, 0x180c796e, 0x210c79ce, 0x6062a001, 0x53c02013, 0x068606f3, 0x954a3186, 0x83c02006, 0x07f7534d, 0xc7585f82,
+    0x23e78e05, 0x31070625, 0x8605e74b, 0x17162be2, 0x03111716, 0x26312734, 0xcb82012b, 0x1714152a, 0x32013b16, 0x07353637, 0x8507d153, 0x22fa820e,
+    0x9217012b, 0xc0012127, 0x2020a9c0, 0x114a6318, 0x01c0fe22, 0x63262941, 0x802a084f, 0x1100c001, 0x00003d00, 0x2e4b3613, 0x05965707, 0x07171625,
+    0x4e311716, 0x262d080f, 0x2627010f, 0x010f0607, 0x1f161706, 0x07557201, 0x36013b29, 0x012f3637, 0x83ff1737, 0x1211228c, 0x2993871b, 0x10100b1e,
+    0x020d580d, 0x08830a01, 0x19273a3b, 0x31122627, 0x21090a12, 0x0b115c2d, 0x110b0c0c, 0x0a091bd0, 0x18236e12, 0x1c8b1901, 0x0caa2110, 0x48203582,
+    0x3e833683, 0x1d2e2f2b, 0x5c200503, 0x15232222, 0x82368223, 0x1702273c, 0x416e1516, 0x8f4d001d, 0x01802805, 0x003000bf, 0x19000060, 0x200cd938,
+    0x0547483f, 0x31220731, 0x06073130, 0x0607011d, 0x17141507, 0x82321716, 0x017c1818, 0x35272408, 0x83012f34, 0x29d78221, 0x011f0607, 0x06011d16,
+    0x15822607, 0x23262723, 0x20358306, 0x21ea8316, 0xe2823316, 0x013d3508, 0x10012726, 0x0109090e, 0x0e010f0f, 0x0303064e, 0x01111a0b, 0x155a1075,
+    0x11080701, 0x26b30404, 0x09011717, 0x5a010e09, 0x0175105a, 0x030b1912, 0x0e4e0603, 0x20050d58, 0x2c36830e, 0xb3261717, 0x08110404, 0x01150107,
+    0x08288200, 0x010f5021, 0x1a4d0f01, 0x0d0b8217, 0x160d070c, 0x511d18b0, 0x6016091d, 0x010a0b09, 0x1e0b2f01, 0x8280281e, 0x1ea22f35, 0xb0181d51,
+    0x0c070c15, 0x17810c0d, 0x33834c1b, 0x090d5136, 0x0908010a, 0x1f287f0d, 0x01310c1e, 0x080b0b01, 0x00081760, 0x04300082, 0xc0ff0000, 0xc001bf01,
+    0x34001900, 0x61005500, 0x4f0a2d70, 0x212006f2, 0x2408ca82, 0x27341137, 0x16072726, 0x1417010f, 0x27352207, 0x26231407, 0x26273735, 0x3336023f,
+    0x27021f32, 0x07161732, 0x05014106, 0x17160727, 0x37321716, 0x7c118336, 0x1323084f, 0x6a213521, 0x23220607, 0x5d6f6001, 0x0f0f2106, 0x3908fd82,
+    0x2940010d, 0x1b011b1b, 0x051b291b, 0x04051503, 0x011a1a01, 0x03150504, 0x010d1d05, 0x0d010202, 0x1e246d1d, 0x06030205, 0x1925090b, 0x19010119,
+    0x0b092519, 0x05020306, 0x6d18241e, 0x88230712, 0x4301e0fe, 0x012f068b, 0x0e0d01c0, 0x16e0fe14, 0x1109510e, 0x83090a0e, 0x3d5f8556, 0x140502aa,
+    0x0101041c, 0x01010d0d, 0x05141c04, 0x021a0402, 0x62041a02, 0x06060414, 0x56830301, 0x03295e83, 0x04060601, 0x22220114, 0x215c8333, 0x344488fe,
+    0x4f002006, 0xbf2809c7, 0x5b001c00, 0x27250000, 0x4a08724a, 0x3720070c, 0x24061d51, 0x06012f34, 0x0d726007, 0x8205a161, 0x012f2331, 0x9f612722,
+    0xf43a0821, 0x0b092a77, 0x45463131, 0x1e1f3738, 0x30310a08, 0x783e5346, 0x0c10100c, 0x08e20c0c, 0x12120226, 0x050d0f02, 0x12070511, 0x0d0c0e05,
+    0x02020a0a, 0x06180505, 0x12110201, 0x1e850313, 0x110c0927, 0x0c120804, 0x3c1c8407, 0x06130404, 0x03151516, 0x533e7804, 0x0a313046, 0x371f1e08,
+    0x31464538, 0x2a090b31, 0x82528277, 0x22be2a57, 0x02120808, 0x03091202, 0x06916105, 0x0202032e, 0x04050703, 0x01020704, 0x1f0e0d04, 0x01231f84,
+    0x82010913, 0x04112374, 0x1d830105, 0x04040428, 0x0e040206, 0x3b5a220d, 0x00bf2608, 0x002f0011, 0x495f1849, 0x3435230a, 0xf45f3637, 0x23062605,
+    0x012f2231, 0x05cc4906, 0x083a4718, 0x17071627, 0x07141516, 0x0abf6103, 0x087a3419, 0x37262483, 0x0c0808ec, 0x0082080c, 0x01220583, 0xac820c08,
+    0xce3ac695, 0x25191801, 0x01181824, 0x120f0e01, 0x04030c12, 0x130c0305, 0x010e0f12, 0x3f881001, 0xfe234b82, 0x410c0cbc, 0x0123175d, 0x8219243e,
+    0x1827083f, 0x1a142419, 0x0d18181b, 0x180d0404, 0x141a1b18, 0x20000400, 0x2002c0ff, 0x0c00c001, 0x31002100, 0x00003e00, 0x45373401, 0x072905c4,
+    0x03353315, 0x15233537, 0xd4491807, 0x013f2608, 0x3f363726, 0x24108501, 0x013f3233, 0x241f8236, 0x22231307, 0x08e95a07, 0x3f012e08, 0x7f060208,
+    0x0109090e, 0xa04948a0, 0x09081e57, 0x16170e12, 0x151b1f19, 0x280b0b16, 0x091e5668, 0x34201208, 0x32731b1f, 0xa101c001, 0x28288280, 0x0e0909c0,
+    0x0d11a001, 0x35078202, 0xeafe2020, 0x41af9f37, 0x21242317, 0x130c0d17, 0x2e2d2a11, 0x0e842720, 0x57133128, 0xafcf4126, 0x71180f01, 0xbb420832,
+    0x02c12806, 0x00bf0140, 0x834d0023, 0x312721bb, 0x0625bc82, 0x26270307, 0x09934527, 0x17161735, 0x37363332, 0x37323313, 0x26073536, 0x0f223123,
+    0x85262701, 0x821f201f, 0x141523cd, 0xcd831617, 0x8209e642, 0x27342327, 0x6a824002, 0x0718e027, 0x130a495b, 0x056a4740, 0x0a672c29, 0x15020213,
+    0x83c76a06, 0x0d0a250f, 0x29290a0d, 0x09250583, 0x092a2a09, 0x2a0f8f09, 0x080ea001, 0xfe170109, 0x53119295, 0x0a2b05df, 0x030111ce, 0x08a80115,
+    0x95c90e09, 0x45428932, 0x012e05cf, 0x00c001ff, 0x00480029, 0x07220500, 0x75442231, 0x33322208, 0x20d18216, 0x06974436, 0x16070622, 0xe582e382,
+    0x37363727, 0x2f372726, 0x24dc8201, 0x0706020f, 0x5add8306, 0x35220760, 0x2f823727, 0x01275808, 0x03020255, 0x3b3c5903, 0x3c3b0303, 0x02030359,
+    0x02030b02, 0x472e2c0b, 0x22223a3a, 0x22220101, 0x2e473a3a, 0x01010a2b, 0x224da30e, 0x03060603, 0x02064d22, 0x0d370401, 0x03020b01, 0x02034444,
+    0x04370d0a, 0x12060102, 0x3c3c0201, 0x3c3c5959, 0x0b010102, 0x8510060c, 0x08458539, 0x0b041027, 0x0bfc020d, 0x45060645, 0x0506010b, 0x0b4c3605,
+    0x24240201, 0x4c0b0102, 0x05060536, 0x00080001, 0x01c0ff10, 0x2fdb82f0, 0x00280024, 0x0030002c, 0x003b0034, 0x0043003f, 0x2106335b, 0x335b2327,
+    0x053b5c05, 0x82060721, 0x413320de, 0xf68405a4, 0x23170325, 0x82370337, 0x33272304, 0x03821707, 0x27233727, 0x07173337, 0x33128633, 0x3737eb01,
+    0x160b0a0a, 0x150c3a6f, 0x6f3a0c15, 0x0a0a0a17, 0x0a211183, 0x27118b17, 0x172f18eb, 0x2a1515a7, 0x92200283, 0x3a230b82, 0x82363674, 0x15433602,
+    0x14142914, 0x59671529, 0x11111459, 0x12135d01, 0x1111015e, 0x200d8214, 0x230d8210, 0x025d1214, 0x012f0d82, 0xfe26260f, 0x8e2121f3, 0x26ed2121,
+    0x82575f26, 0x510c8400, 0x16220c17, 0xd3822f00, 0x00004f22, 0x20057857, 0x0bbc4a11, 0x3f361128, 0x0f261701, 0xa3412301, 0x27dc8205, 0x3633013f,
+    0x3637012f, 0x1724fa82, 0x32333637, 0x2a068047, 0x11230706, 0x26231121, 0x18272627, 0x2708466a, 0x0a0a3601, 0x60011c79, 0x3307d54e, 0x791c0160,
+    0x10070610, 0x10040b20, 0x200b0410, 0x11060710, 0x11280b87, 0x07051cba, 0x0c400507, 0x40292c83, 0x1b4080fe, 0x0c011212, 0x29138340, 0x08bc011c,
+    0x24186508, 0x654aa5fe, 0x01803008, 0x6518245b, 0x1c080878, 0x1d1b0a02, 0x841c020a, 0x1b1d2109, 0x79270982, 0x47050520, 0x8384130d, 0x0b01233f,
+    0x4f83f5fe, 0x0d138428, 0x20050547, 0x0b520b00, 0x03250808, 0x1b000700, 0x23001f00, 0x3e002a00, 0x68004300, 0x70006c00, 0x37250000, 0x013f1723,
+    0x22010727, 0x07063107, 0x6a591811, 0x82112007, 0x05232fd6, 0x07371723, 0x3b072737, 0x23273701, 0x22931707, 0x11210128, 0x36131121, 0x18413337,
+    0x82332005, 0x059b5a3f, 0x07012b29, 0x2f222306, 0x5c222301, 0x3f25054b, 0x27330701, 0x2a508207, 0x24124001, 0x12243f12, 0x6eb1fe12, 0x7324108a,
+    0xc6121325, 0x42230382, 0x82212142, 0x31012102, 0xfe36218f, 0xfe800130, 0x0c064380, 0x0b061d3c, 0x3c1d050c, 0x0606060c, 0x04821d1d, 0x0c221183,
+    0x1183070b, 0x83070521, 0x117c3411, 0x253d1324, 0x1e511312, 0x1e01371e, 0x0938011f, 0x44fe0e09, 0x0128062d, 0x09090ec0, 0x6f1e1ec9, 0x38231882,
+    0x91383737, 0x20fe361c, 0x40fec001, 0x010a2601, 0x310a0a31, 0x0a0b0a01, 0x0a0b3031, 0x200c830b, 0x2910820b, 0x280a0b31, 0x1e371d1d, 0xa747001e,
+    0x00c0380a, 0x0048001e, 0x17351300, 0x32213316, 0x0615013f, 0x23070607, 0x88352315, 0x27262403, 0x18172726, 0x2008a3ba, 0x08a57f21, 0x099d4218,
+    0x0a892120, 0x47002330, 0x0d011919, 0x0147191a, 0x10140e0d, 0x01826040, 0x0e141023, 0x0978480d, 0x2005fa44, 0x05f26420, 0x8500ff21, 0x01202807,
+    0x08185070, 0x83501808, 0x8440202a, 0x6d3f8300, 0x23850631, 0x8707524c, 0x0b275107, 0x9600912c, 0x00009b00, 0x37363701, 0xa1823336, 0x16011f24,
+    0x0782011f, 0x83069c75, 0x2b0624d3, 0x69171501, 0x172505d9, 0x17163330, 0x22e98414, 0x82220706, 0x05954e17, 0x0a934618, 0x79510a96, 0x23352105,
+    0x23053945, 0x35342726, 0x37236f82, 0x82013f36, 0x47158202, 0x272105b4, 0x21858426, 0x06823336, 0x07312408, 0x23353315, 0x21352107, 0x1a180115,
+    0x04050202, 0x02020506, 0x173d3319, 0x03030203, 0x01060101, 0x82010201, 0x07082a07, 0x26200c08, 0x0403021d, 0x2e0e8303, 0x05040203, 0x27030205,
+    0x01122d20, 0x85281602, 0x8ca020ff, 0x16283206, 0x2d120102, 0x02032720, 0x03040406, 0x04010102, 0x27068203, 0x0c20261d, 0x01070907, 0x12824482,
+    0x04030635, 0x02020101, 0x39323d17, 0x0140c1c1, 0x01bffe41, 0x820211aa, 0x02012711, 0x07102411, 0x23820202, 0x820a0821, 0x2581823e, 0x1a093805,
+    0x38820a0c, 0x82050321, 0x82042050, 0x01032800, 0x050c2342, 0x4a021612, 0x20200633, 0x0228078f, 0x0c051216, 0x03014223, 0x02822c82, 0x03050622,
+    0x0a254782, 0x38091a0c, 0x24478305, 0x080a0404, 0x08618204, 0x24100727, 0xe040406a, 0x02004040, 0xe3ff0000, 0xa0013802, 0x31001800, 0x26010000,
+    0x0623010f, 0x15070607, 0x3b161716, 0x052f4701, 0x26113724, 0x885c1727, 0x05a25c05, 0x2b05205e, 0x36371617, 0x2d01012f, 0x54870f13, 0x36075f43,
+    0x0c098754, 0x01120607, 0x2fd51201, 0x11110e0e, 0x1111302f, 0x842f0e0e, 0x2f30210b, 0x01360b84, 0x780d089d, 0x140d0d01, 0x0d0d155f, 0x09030878,
+    0x147d0114, 0x1c84dc09, 0xbe193020, 0x0021130a, 0x2da38204, 0x010002c0, 0x001100c0, 0x003e002c, 0xfb4c0058, 0x0cac7e05, 0x07063522, 0x4705dd7c,
+    0x36200528, 0x22087353, 0x43112726, 0x28430829, 0x76232006, 0x62180999, 0x4e4e0f42, 0x11d9500d, 0x22220125, 0x4348393a, 0x05850530, 0x1b1b292f,
+    0x1b1b0101, 0x36365229, 0x36360202, 0x200f8752, 0x0db54f01, 0x50913885, 0x6880fe21, 0x80200b69, 0x41834983, 0x51834983, 0x00200f87, 0x34087746,
+    0x00c00140, 0x002f001a, 0x005b0041, 0x26273700, 0x3726010f, 0x32481817, 0x14152a08, 0x16171617, 0x2736013f, 0x05c74105, 0x1617142e, 0x37320533,
+    0x34013d36, 0x07272627, 0x24100a41, 0x21373313, 0xbb001911, 0x332c0813, 0x0c041b9f, 0x2d1a1a2d, 0x051a040c, 0x1319270b, 0x0c084745, 0x0a270a0c,
+    0xff400103, 0x0111121b, 0x010d0909, 0x09090e3f, 0x7f1c1212, 0x30055a5c, 0x0909090d, 0x9f2f0e08, 0x017ffe12, 0x0f621220, 0xbc001901, 0x0221080d,
+    0x0c3e720e, 0x4b490402, 0x0c3f0b05, 0x130c1808, 0x51656451, 0x06010108, 0x320e0718, 0x1a121201, 0x20468220, 0x25568202, 0x12121d1f, 0x08826001,
+    0x012a5688, 0xa1fe40a0, 0x0e0d0240, 0x04853f01, 0x00150e29, 0x00000600, 0x8201c0ff, 0x08002e01, 0x37002200, 0x60005400, 0x00006900, 0x057e5501,
+    0x011f1622, 0x2e188e72, 0x31171603, 0x07061716, 0x23070615, 0x44352726, 0x07270543, 0x1f363726, 0x61363701, 0x7546051b, 0x27058205, 0x3f262726,
+    0x21052701, 0x2009a372, 0x22608603, 0x54100117, 0xb021075a, 0x15b57201, 0x22d02a08, 0x02011617, 0x400f011e, 0x021e010f, 0x22171601, 0x07040d76,
+    0x0e6a6a0e, 0x4d0d0407, 0x05040d4d, 0x6a03030a, 0x0a03036a, 0x210f8305, 0xbb600601, 0x87b02009, 0x3001215b, 0x2007f253, 0x17e072c0, 0x01100128,
+    0x201b1212, 0x33830d13, 0x130d2108, 0x12121b20, 0x0e07af01, 0x2e2e040d, 0x070e0d04, 0x0e072121, 0x2e2e010a, 0x0f090101, 0xd1212106, 0x20057142,
+    0x36588940, 0x00020000, 0x02c0ff00, 0x00c00140, 0x00290025, 0x16130100, 0x5d06011d, 0x272406ea, 0x13373435, 0x23054245, 0x011f1617, 0x095be218,
+    0x07271327, 0xec480133, 0x08fc840c, 0x0e142025, 0xeb0c010d, 0x02020930, 0x0d0c0b0a, 0x09272808, 0x0b0a0d0c, 0x30090102, 0xef777850, 0xdbfe5001,
+    0x44181310, 0x18330728, 0x25011013, 0x0c0d0b3c, 0x02010809, 0x0a31310a, 0x82080102, 0x3c0b272f, 0x9c9cb0fe, 0xb74c0000, 0x00a02808, 0x00430035,
+    0x1855004c, 0x240a4369, 0x26272635, 0x06845227, 0x17323333, 0x16111516, 0x33171617, 0x34353736, 0x012b2627, 0x060f7537, 0x83230621, 0x23372227,
+    0x27441827, 0x0f352108, 0x2208e956, 0x57272633, 0x012b0531, 0x1c1c0b43, 0x011d2122, 0x43291b1b, 0x058205d0, 0x1212012a, 0x010fb01b, 0x200e0909,
+    0x2805bf5b, 0x222f110f, 0x409d0923, 0x078f4340, 0x41484021, 0x5020079e, 0x012b0887, 0x04050100, 0x56291312, 0x831b1b29, 0x204d853a, 0x05f27aff,
+    0x82110d21, 0x9060210e, 0xce282b83, 0x1c1c0104, 0x8640602d, 0x22072944, 0x41504086, 0xdc5507e1, 0x00022508, 0x01c0ff00, 0x00260182, 0x0039001e,
+    0xf1822500, 0x8b522120, 0xa3481805, 0x84212007, 0x013f29e6, 0x27363732, 0x15373625, 0x2105885f, 0x08821716, 0xfd43f783, 0x27332e05, 0x090fbd01,
+    0x149efe14, 0x09070f09, 0x06f8710a, 0x0f01003c, 0x02010f1f, 0x07090a11, 0x2602b2fe, 0x27303030, 0x24013001, 0x36403625, 0x09822424, 0x12206d2a,
+    0x20120101, 0x700f0f0f, 0x7020b083, 0x0e820585, 0x182dd32e, 0xc5d0d0c5, 0x80802e17, 0x01242536, 0x802f3283, 0xff020080, 0x02c0ffff, 0x00c0013f,
+    0x824f0025, 0x05835eab, 0x82070621, 0x70858486, 0x33250b78, 0x37363736, 0x5acd8234, 0x34200591, 0x36200d82, 0x08f45d18, 0x16171426, 0x16333617,
+    0x32820582, 0x08071266, 0x5701234c, 0x12120109, 0x0e111b1a, 0x291c1616, 0x01011b1b, 0x0111121d, 0x291b1b02, 0x161622ef, 0x1f141401, 0x343448de,
+    0x24141402, 0x06010105, 0x37511311, 0x09020236, 0x29121208, 0x24011b1a, 0x24232911, 0x02030519, 0x120f5f07, 0xd782121b, 0x0e171124, 0x3c82010e,
+    0x01022a08, 0x180a0102, 0x1b292018, 0x1601011c, 0x16202217, 0x0c370316, 0x29482b2c, 0x04152223, 0x03020605, 0x52363602, 0x08060c0d, 0x2b2e8307,
+    0x23110605, 0x1f121203, 0x00050505, 0x032e0082, 0xc0ff0000, 0xbf017f02, 0x3d002b00, 0x4c186600, 0x36380b43, 0x37173233, 0x26022f36, 0x2627010f,
+    0x1f06020f, 0x1f060701, 0x013f1602, 0x82058659, 0x4d3120df, 0x262a07c8, 0x06070627, 0x37340507, 0xd4423431, 0x0f334106, 0x3f6d1420, 0x34240807,
+    0x60272627, 0x2f1f2001, 0x0a1d1e28, 0x07071f1c, 0x580e0618, 0x4a0e0510, 0x10050e4a, 0x34060e59, 0x590e0634, 0x0b270f82, 0x1b292905, 0x8320011a,
+    0x0f3908d2, 0x04280b0d, 0x22201516, 0x01011617, 0x120101bf, 0x0f131a12, 0x221b1b0e, 0x01201f30, 0x19192601, 0x291b1a01, 0x1b291001, 0x1112011b,
+    0x1f30f01d, 0x1701011f, 0x010e2518, 0x87538d23, 0x36082663, 0x1e1e0722, 0x264e832b, 0x1e203405, 0x83011414, 0x02762c65, 0x1b010201, 0x0a011212,
+    0x8312111e, 0x030227a1, 0x1b030202, 0x5783271a, 0x1b1b0127, 0x18182029, 0x0633410a, 0x02000030, 0x0080017f, 0x00600050, 0x25000069, 0xd6823527,
+    0x07060722, 0x2121db82, 0x2b078206, 0x15070615, 0x36373633, 0x37363537, 0x08cd7418, 0xde6c1620, 0x33322806, 0x37323316, 0x84171615, 0x8207821e,
+    0x17352429, 0x821f1415, 0x37322784, 0x36013f36, 0x43822527, 0x26055c74, 0x17163337, 0x43170716, 0x022d07e5, 0x07080a7a, 0x420a1008, 0xc1fe301e,
+    0x22f88225, 0x83080117, 0x023c08b2, 0x0f010117, 0x0e010f3f, 0x0e0e0212, 0x05020201, 0x020c0605, 0x14010f0e, 0x400d020e, 0x0b1f010f, 0x12181129,
+    0x15040d0c, 0xfffe0803, 0x30302217, 0x070b1722, 0x13a61307, 0xc70c0807, 0x3e07f843, 0x094d0eab, 0x08040405, 0x01275b0f, 0x25191901, 0x201f1356,
+    0x1b121201, 0x060a1b68, 0x83d0fe07, 0x0e702326, 0x07831a08, 0x01011123, 0x23078311, 0x700e081a, 0xb03d0783, 0x10132a20, 0x0b01143e, 0x0d6d110a,
+    0x21176e0b, 0x17210101, 0x010d0d0c, 0x0c0d0d01, 0x080d44b9, 0x0a000022, 0x08084f4f, 0x13000b37, 0x2f002100, 0x3b003700, 0x53004b00, 0x6f006100,
+    0x22370000, 0x3734013d, 0x07011f32, 0x27172706, 0x3f343526, 0x34071701, 0x17333037, 0x22071415, 0x2726012f, 0x27148413, 0x17323336, 0x27010f14,
+    0x23067f4e, 0x27071723, 0x09967818, 0x37352729, 0x31303514, 0x82151637, 0x17372422, 0x4e352603, 0x0e8305a4, 0x32172726, 0x2314011d, 0x47084a82,
+    0x34313637, 0x04041415, 0x4c4d0101, 0xd0d30201, 0x6c6a0107, 0xcb0104c8, 0xc3010207, 0x02030102, 0x03019702, 0x4f020107, 0x065f7152, 0x5f060807,
+    0x6464d1d9, 0x020478c8, 0x070201c3, 0x0113cc01, 0x6a6cd007, 0x070102b2, 0x022e2882, 0xae505102, 0x01020404, 0x83024d4c, 0x5282a204, 0x047a2d25,
+    0x83165801, 0x9c22081c, 0x01030fbe, 0x01074216, 0x02025701, 0x02012f01, 0x01620202, 0x8f020208, 0x07a83a31, 0xb01fa808, 0x6c83d0b0, 0x08015728,
+    0x01011642, 0x5c82022c, 0x9cbe1629, 0x02025c01, 0x82620108, 0x3101232c, 0x52827c8f, 0x2d7a0226, 0x00010101, 0x3105936f, 0xc001c001, 0x1f000e00,
+    0x00002e00, 0x011f3613, 0x1b410615, 0x36352305, 0xf2822517, 0x86053741, 0x36172ef3, 0x0f061517, 0x26230601, 0x36373527, 0x38798217, 0x040e02c4,
+    0x011f9804, 0xa2010701, 0x04c6c604, 0x1110a504, 0x05a50f11, 0x26a3820e, 0x0404981f, 0x82c4020e, 0x262b08a9, 0xdf750201, 0x5d020110, 0x09c62514,
+    0x02052501, 0x04037777, 0x09650304, 0x04036509, 0xc6090125, 0x025d1425, 0x75df1001, 0x82000102, 0x00032600, 0x02c0ff00, 0x2d978240, 0x001e0015,
+    0x01000049, 0x1f323736, 0x03833301, 0x81821620, 0x07060730, 0x37270723, 0x16070617, 0x26373617, 0xa8740727, 0x2306230a, 0x0e8a2722, 0x3606f842,
+    0x1f161736, 0x33171601, 0x044d0117, 0x11070c13, 0x120e1434, 0x82021638, 0x45222512, 0x73177005, 0x2b07b542, 0x0e090920, 0x09090e20, 0x242c2b25,
+    0x22080a86, 0x03040e2d, 0x0e0d0607, 0x04040b0a, 0x70ce1807, 0x0113ac01, 0x120e160a, 0x22181602, 0x1f011617, 0x482c8b40, 0xe474088a, 0x13732306,
+    0xe8467313, 0x12e63405, 0x0c0d0f31, 0x0602040b, 0x16100d07, 0x00004101, 0x82ffff03, 0x827f20db, 0x001428db, 0x00500048, 0x51013f00, 0x262105e7,
+    0x095a593d, 0x27053330, 0x33352726, 0x013b1617, 0x36013f36, 0x9b54012f, 0x821f2005, 0x011f252a, 0x16171415, 0x6406d55e, 0x3623065d, 0x82273637,
+    0x081482e8, 0x2627269a, 0x5bae1237, 0x0b040307, 0x12780fdf, 0x75111515, 0x0c050409, 0x1a642d02, 0x0a1c4001, 0x0a121e0d, 0x4b0b080f, 0x05ee0f09,
+    0x3d030202, 0x3b08083b, 0x8e2d191a, 0x05446b6c, 0x03010d04, 0x31f30110, 0x02032323, 0x56201111, 0x0b12062e, 0xc0030707, 0x09084520, 0x2b280109,
+    0x010c572b, 0x08750e01, 0x32220a0a, 0x17251d0e, 0x1c110109, 0x0d631012, 0x32050405, 0x19070719, 0x2f2f366d, 0x1312061f, 0x04010110, 0x0102100d,
+    0x24311e1f, 0xe0101e1d, 0x0101110c, 0x000d0808, 0x01210082, 0x059b5d00, 0x3c00c12b, 0x14010000, 0x06232615, 0x05b56807, 0x822b0621, 0x4ad888da,
+    0x06210555, 0x20cd8223, 0x21db8235, 0x03531637, 0x080b8405, 0x32333624, 0x02151617, 0x291c1a00, 0x090a1717, 0x57201d1e, 0x03030928, 0x11110101,
+    0x11121919, 0x1f080702, 0x0c830e0e, 0x070f3408, 0x090d0906, 0x12110129, 0x4444341b, 0x17013134, 0x010e0302, 0x19181314, 0x0a222a11, 0x090d0a28,
+    0x1a100606, 0x12011110, 0x07081712, 0x14130202, 0x82111913, 0x03032fab, 0x2f572809, 0x321a2322, 0x00433532, 0xb3860c00, 0x1300c028, 0x3f002a00,
+    0xff7b5100, 0x00a1240a, 0x82b700ac, 0x3f2622c9, 0x39451801, 0x010f2708, 0x27262706, 0xbd822731, 0x07222327, 0x26012f22, 0x831b8237, 0x161727b4,
+    0x3627010f, 0x7c183117, 0x1a82073b, 0x1c832720, 0x83053121, 0x4f17203f, 0xf38206db, 0x25312725, 0x82060716, 0x4b232001, 0x36250583, 0x1607011f,
+    0x06964b17, 0x33373623, 0x200c8b21, 0x82199805, 0x27262d40, 0x16373611, 0x06231117, 0x35272607, 0x15210a83, 0x080a8933, 0x0f51015a, 0x09041f05,
+    0x19200a09, 0x08020106, 0x020f1244, 0x14092702, 0x07060607, 0x031f0914, 0x1d0a0404, 0x0a1c1d1d, 0x1e040405, 0x09090ab0, 0x10061f04, 0x12100102,
+    0x01020943, 0x01201906, 0x440f0502, 0x040a0a09, 0x16010410, 0x01051550, 0x0efffe01, 0x05010204, 0x01165015, 0x0a241482, 0x1345090a, 0x09138218,
+    0x89800121, 0x8afe200b, 0x20178b0b, 0x074843d8, 0x08874020, 0x08ec6e18, 0x0e230139, 0x030a4c12, 0x1c130604, 0x07090a08, 0x020d092d, 0x01102c01,
+    0x824c1001, 0x06032399, 0xc6820306, 0x4b4c2808, 0x0a030406, 0x010e124c, 0x2d090d02, 0x080a0907, 0x13b8131c, 0x03062e0b, 0x29240a02, 0x15020215,
+    0x0b1e0505, 0x83050513, 0x24292a89, 0x0603020a, 0x1602602e, 0x8c0e8330, 0x93802004, 0x0f302414, 0x4c0f0101, 0xfe2105dc, 0x8f0b83f0, 0x067b6004,
+    0x01800130, 0x001600c0, 0x00650042, 0x00840080, 0x165e1300, 0x7cc31805, 0x5f07200f, 0x3b28081e, 0x36373201, 0x2726013d, 0x23087a4d, 0x16333736,
+    0x3006df47, 0x2b262734, 0x16011f01, 0x23070615, 0x17160706, 0x252b8233, 0x012f2635, 0x24823526, 0x26373623, 0x23158227, 0x17161506, 0x3e820982,
+    0x29821420, 0x3f323323, 0x314e8701, 0x3d260714, 0x23172701, 0x0909e035, 0x1201800e, 0x794b1b12, 0x21098305, 0x825d90a0, 0x82102005, 0x0f012106,
+    0x9818d082, 0x0d830888, 0x110b0c29, 0x071a5f10, 0x821a0d01, 0x1a0f2619, 0x010e0d13, 0x200e8316, 0x200e8312, 0x200e8412, 0x27278369, 0x0805051e,
+    0x1e050508, 0x10230b83, 0x82801810, 0x0e8025fc, 0xe0fe0909, 0x2008965e, 0x20098380, 0x204f82e0, 0x206f8550, 0x25418308, 0x01010708, 0x04835007,
+    0x1a820e85, 0x040e5725, 0x83010d09, 0x0d0e2447, 0x880e1b13, 0x0d01210d, 0x47210e83, 0x291a820f, 0x082c3520, 0x2c080707, 0x0d842035, 0x1f1f233e,
+    0x80f02023, 0x00050080, 0x01c0ff20, 0x00c001a0, 0x001d000d, 0x00450031, 0x13000075, 0x07c17918, 0x33011d25, 0x89271732, 0x3332390d, 0x17013b36,
+    0x36313732, 0x2734013d, 0x07222326, 0x14011d06, 0x37331617, 0x60089241, 0x07260989, 0x23062726, 0x70452722, 0x26232405, 0x83373627, 0x214c831b,
+    0x3884012b, 0x011f1627, 0x36353315, 0x834c8237, 0x06d66e28, 0x0b0d2823, 0x05504e60, 0x03010125, 0x4da03803, 0x14820844, 0x0c5f5e18, 0x0813212d,
+    0x0b0b1410, 0x14010105, 0x83481f14, 0x414820d6, 0x80200526, 0x012d0682, 0x1de0352a, 0x120e1211, 0x0c010e13, 0x23438594, 0x70040490, 0x71220985,
+    0xd2601001, 0x5571830d, 0x06830683, 0x150c962a, 0x0f0d040b, 0x0114141f, 0x8506d141, 0x3f200859, 0x4e262035, 0x1e1d1355, 0x0a094125, 0x00000300,
+    0x8001c0ff, 0x2300c001, 0x47003500, 0x06130000, 0x2507ab56, 0x1f36013f, 0x058b1601, 0x37363727, 0x26272611, 0x11315123, 0x43513320, 0xba210810,
+    0x02343351, 0x08090901, 0x2b0a0c19, 0x0c290b0b, 0x0b0b290c, 0x190c0a2b, 0x01090908, 0x54383802, 0x07c8503a, 0xc6820a20, 0x350dc061, 0x393905c0,
+    0x0bf8fe51, 0x12080404, 0x0a300a08, 0x0b0b2d0a, 0x08820a2d, 0x04270e82, 0x10010b04, 0x18363753, 0x180c6c64, 0x4f0ce268, 0x3f2906b7, 0x2400c001,
+    0x00003400, 0x05545925, 0x2f362728, 0x06272601, 0x1e4b010f, 0x07172208, 0x07304306, 0x26252725, 0x53060727, 0x3f23053c, 0x822f2601, 0x176208a1,
+    0x070a0907, 0x1a061406, 0x4545312d, 0x15600732, 0x071d1531, 0x0e061507, 0x0a07170e, 0x0e5b0709, 0x06d7fe0f, 0x1515f004, 0x171c1c16, 0x300606d1,
+    0x070716fc, 0x1c251405, 0x0101302d, 0x0e300830, 0x1431151e, 0x05150201, 0x07171111, 0x11115b07, 0xd1070504, 0x161d1d16, 0x05ef1515, 0x00003205,
+    0x3f581000, 0x082a0808, 0x1a001100, 0x2c002300, 0x70003500, 0x8c007d00, 0xae009d00, 0xd000bf00, 0xf200e100, 0x00000301, 0x15070613, 0x27263533,
+    0x0886012b, 0x90332321, 0x08d66c08, 0x1a872520, 0xa36c2120, 0x4d2f2038, 0x05620698, 0x4d212005, 0xa96705a5, 0x33162205, 0x670e8525, 0x1424057d,
+    0x07331617, 0x3b20108e, 0x21883d86, 0x332810c3, 0x200106e7, 0x40110701, 0xe1210685, 0x210d8307, 0x06854010, 0x07015823, 0x21098210, 0x1c8547fe,
+    0x6c090221, 0x212208c8, 0xc86c020d, 0x14712e0d, 0x02010d0d, 0x1060010d, 0x0e0d0101, 0x07c86c14, 0x02171125, 0x840a0b01, 0x15022303, 0x0d89c0fd,
+    0x09070728, 0x02162001, 0x1c850a01, 0xcf200e82, 0x2a860d82, 0x0a070723, 0x200d9a40, 0x8d1b9aa0, 0x25cc8337, 0x01077878, 0x058f0701, 0x14850820,
+    0x19860820, 0x0e700f2c, 0x0fc00909, 0xc00f0101, 0x304d0909, 0x29702905, 0x40011b1b, 0x140d0d01, 0x0f23d282, 0x820d0e14, 0x1b1b320c, 0x010f7029,
+    0x0d190220, 0x02021313, 0x190d1313, 0x230b8902, 0x3008070c, 0x0b210d89, 0x8c0d8e08, 0x4b0cb31a, 0x003008c3, 0x1e00c001, 0x3e002f00, 0x27370000,
+    0x3f343526, 0x2f055e62, 0x0f141516, 0x26273302, 0x0607013f, 0x2733010f, 0x1f2e1682, 0x020f1602, 0x26022f06, 0x06210137, 0xe14f1607, 0x27262c07,
+    0x060631c8, 0x05031031, 0x83100305, 0xd0083409, 0x38080a56, 0x6f1124bc, 0x191f0890, 0x0c04040c, 0x87040419, 0x09012707, 0x010f20fe, 0x127e0d01,
+    0x0f012207, 0x85398948, 0xca282a09, 0x6ba91716, 0x28fa2615, 0x83398bcc, 0xecfe2641, 0x0e140f01, 0x213f840d, 0x4b63010f, 0x82802008, 0x001127c3,
+    0x005b0029, 0x1f650067, 0x26372205, 0xd04d1827, 0x36072509, 0x3536013f, 0x23211182, 0x2ecc8322, 0x1f161506, 0x32373201, 0x06232533, 0x46231507,
+    0xdb6c055f, 0x44012005, 0x372f055e, 0x34013d36, 0x3132012f, 0x17373134, 0x4f013b16, 0x112305b4, 0x82012726, 0x1617223b, 0x224f8233, 0x5bf00727,
+    0xa0320f9c, 0x0129040c, 0x0a0a0c01, 0x0716161c, 0x0b010119, 0x00830140, 0x0f203208, 0x2f23010e, 0x0f151813, 0x011b0510, 0x09095709, 0x0a090d0d,
+    0x13012f13, 0x2f0d0b17, 0x120f0d02, 0xfe0f0101, 0x170101e1, 0x06180404, 0x01223419, 0x484a1860, 0xbf21080f, 0x029e0b01, 0x02040b02, 0x621b1010,
+    0x030c0202, 0x017f0110, 0x112f100f, 0x6b140d0c, 0x0a0d0404, 0x2bb51956, 0x012f2609, 0xf0091750, 0x2553820f, 0x010f4001, 0x5482c8fe, 0x5b820720,
+    0x8a356523, 0x32008200, 0xff000002, 0x018002e0, 0x003b00a0, 0x01000044, 0x52310706, 0x222805f0, 0x27263507, 0x15070623, 0x85053641, 0x163523f1,
+    0x96543617, 0x07bf5307, 0x09493220, 0x27262105, 0x08ef0d19, 0x1e48023f, 0x0b0b0b1c, 0x111e1817, 0x1016020f, 0x4b350216, 0x02363652, 0x16301602,
+    0x3f3f3102, 0x54088431, 0x0e2b058f, 0x0f010909, 0x0f89190f, 0x820f0201, 0x01102ca2, 0x06100160, 0x10101b04, 0x82160e06, 0x28312730, 0x2d2d0201,
+    0x0b83e844, 0x01163f25, 0x833f1601, 0x48a82009, 0x0928054b, 0x19600e09, 0x50031212, 0x550a5e50, 0x50220aff, 0xcf825900, 0x59273421, 0x34200519,
+    0x0621cb83, 0x22d08207, 0x82070635, 0x1f162ad5, 0x35373601, 0x15143736, 0x2dda8206, 0x011f0607, 0x36331716, 0x012f3637, 0x14681737, 0x013d2808,
+    0x31303536, 0x83013d30, 0x3f16211d, 0xe4893183, 0x09403e08, 0x03030403, 0x78080511, 0x01242536, 0x251c2ca1, 0x02011918, 0x010e100d, 0x01011001,
+    0x05071a1e, 0x20180916, 0x03090911, 0x09851816, 0x0e1f0d09, 0x11230908, 0x0b0b0613, 0x0113210c, 0x20268240, 0x3703830e, 0x090d7301, 0x04030404,
+    0x0109140a, 0x36252401, 0x01012001, 0x38251919, 0x01251b82, 0x0c14380f, 0x31008202, 0x13441b2b, 0x01175714, 0x100c0b01, 0x86174055, 0x0082090e,
+    0x20a20e30, 0x0766012e, 0x05040b26, 0x15090d05, 0x0641134d, 0x4f012008, 0x5c18088b, 0x23210883, 0x21f58317, 0xe0832723, 0x6d612620, 0x011f2705,
+    0x26272623, 0x05833527, 0x37343528, 0x32173625, 0x0882011f, 0x013b362e, 0x1d161732, 0x07161701, 0x01400231, 0x9182b982, 0x1b121237, 0x0c51267b,
+    0x090d760c, 0x553c0708, 0x661f060a, 0x0112121b, 0x22898220, 0x8200010a, 0x6a0a21d2, 0x28067b4f, 0xc0010c35, 0x0109090d, 0x2e1f83a0, 0x0c0d4340,
+    0x0908075d, 0x0947530c, 0x8201340c, 0x83a02045, 0x0a0e2750, 0x070109e0, 0x3d82255e, 0x79243582, 0x000e0a2f, 0xe02cb383, 0xa0018001, 0x00006700,
+    0x31270613, 0x37239b82, 0x82013f36, 0x1716268d, 0x07141716, 0x081c5e33, 0x010f0622, 0x15200c8a, 0x33211e83, 0x20298232, 0x20098217, 0x211c8207,
+    0xd8840706, 0x23373422, 0x09d56018, 0x8a013f21, 0x8237200c, 0x2327265b, 0x73010f22, 0x06b7570a, 0x372b0629, 0x2020302b, 0x85140401, 0x02442492,
+    0x857b3203, 0x0be5360a, 0x140e0d01, 0x0619212c, 0x080d0c0b, 0x0b020109, 0x2c372b05, 0x212c8d2f, 0x2c867c33, 0x82010a21, 0x2b15262d, 0x01071921,
+    0x832b8348, 0x22052760, 0x2f202001, 0xf0480f11, 0x01022205, 0x2708851d, 0x0e15120d, 0x0514010d, 0x22076758, 0x82012106, 0x10302127, 0x13212790,
+    0x24278314, 0x03000004, 0x2a008200, 0x80014002, 0x36002400, 0x43004800, 0x312106ad, 0x2af98306, 0x36371617, 0x3736013f, 0x66011f16, 0x372206ea,
+    0xe8832736, 0x6e180320, 0x2120109c, 0x24081190, 0x3e7b2001, 0x0215153f, 0x4b313202, 0x0b111115, 0x10100a14, 0x110b140a, 0x314b1511, 0x15020232,
+    0x7b3e3f15, 0x071e4c80, 0x01210787, 0x3c119000, 0x21210180, 0x50302f30, 0x01012e2f, 0x28160808, 0x12010112, 0x08081628, 0x2e2f0101, 0x24188250,
+    0xff012121, 0x070b6200, 0x00200797, 0x090f4318, 0x15000f2b, 0x03250000, 0x07222326, 0x21e58303, 0xd4823621, 0x23170334, 0x01372707, 0x0f09dff7,
+    0x11df090f, 0x0120110f, 0x06822090, 0x4848f73a, 0x364f1f30, 0x0c0c5e01, 0x1d1ca2fe, 0x1c01021b, 0x1a011c1d, 0x7b354070, 0x2b0b0374, 0x0060005b,
+    0x006a0065, 0x17160100, 0x089b7218, 0x7b601520, 0x1a4c180a, 0x18232009, 0x2308db52, 0x15213533, 0x57421795, 0x21332207, 0x2a2e8a35, 0x35331507,
+    0x23350323, 0x83373315, 0x90012109, 0x20071b46, 0x07985d30, 0x87306021, 0x88a02012, 0x00ff211b, 0x7b4c1492, 0x8a012006, 0x8090281b, 0x80802080,
+    0x698080c0, 0x6020056b, 0x20204083, 0x24055542, 0x0e0d0120, 0x88108414, 0x93202008, 0x242d8f13, 0xfe404040, 0x21048280, 0x2b414040, 0x05134605,
+    0x11000831, 0xbe008f00, 0x36130000, 0x06272637, 0x84171607, 0x210c8304, 0x0d822225, 0x1617162e, 0x0706011d, 0x26352726, 0x06072627, 0x1d250183,
+    0x37322301, 0x056d4d36, 0x3d211482, 0x09b06601, 0x17272d82, 0x23373633, 0x4d363736, 0x23290791, 0x35340722, 0x34013d36, 0x23068235, 0x23272637,
+    0x2b223282, 0x48822201, 0x6d832320, 0x14150627, 0x1714011d, 0x45398315, 0x3720059f, 0x2105b64a, 0x44823505, 0x91413720, 0x2f222309, 0x454f3001,
+    0x06232508, 0x1f16011d, 0x31207883, 0x2105f75c, 0x2c54e027, 0x87802007, 0x7a013508, 0x0901010d, 0x01141422, 0x01010f0f, 0x2d0b0908, 0x0d0e1605,
+    0x3906f44d, 0x0508175c, 0x0f100808, 0x100f1111, 0x180a0a0b, 0x0a252019, 0x0a014c1d, 0xe6430b0a, 0x19182205, 0x2b348201, 0x1b0e0b0f, 0x2240221a,
+    0x0b0e1b1a, 0x10250e82, 0x1e011001, 0x0884821d, 0x323fa032, 0x011e1d33, 0x482e2e02, 0x120166fe, 0x1b401b12, 0x01011212, 0x06150d0d, 0x03012206,
+    0x010e0804, 0x010d260c, 0x0304080c, 0x06062101, 0x010d0d15, 0x71090d71, 0x40370816, 0x0a03090d, 0x701a2221, 0x0f01010f, 0x06060b5c, 0x0d331805,
+    0x411b1615, 0x012b06e7, 0x02141417, 0x08080602, 0x821d0206, 0x1a26245d, 0x41060713, 0x0d3805d3, 0x06050101, 0x01010110, 0x0f130802, 0x12111d01,
+    0x011d1112, 0x0208130f, 0x10231282, 0x852b171e, 0x1e01299d, 0x3f33331e, 0x0b34354a, 0x0ac6ab18, 0x03318a83, 0x0604010e, 0x010b070d, 0x0d070b01,
+    0x0e010406, 0x44b98303, 0x0029067b, 0x13008001, 0x2d001c00, 0x067b4400, 0x2509925c, 0x27262726, 0x8c5c2615, 0x26372a06, 0x26070627, 0x36373635,
+    0x05bd4537, 0x00014608, 0x02474770, 0x6d484803, 0x0348486d, 0x6f474802, 0x53353751, 0x51373553, 0x6f6f46b5, 0x36020b46, 0x36515236, 0x010b0237,
+    0x28280180, 0x283c623f, 0x28020228, 0x3f623c28, 0xe0012828, 0x01181601, 0x01161801, 0x2c148336, 0x17220e0c, 0x16010116, 0x0c0e2217, 0x32978200,
+    0x01c0ff10, 0x00c001b0, 0x004c003a, 0x2500005e, 0x68262723, 0x01220556, 0x396e1506, 0x32332a07, 0x06071733, 0x011f1417, 0x08b04907, 0x82353621,
+    0x17372127, 0x23069f51, 0x23262734, 0x3120bc82, 0x2009354d, 0x211a8216, 0x7b69010f, 0x06d55505, 0x2e08e282, 0x1a2c9001, 0x0c472915, 0x271a210a,
+    0x0e09090d, 0x0927090b, 0x0e03030b, 0x1f010625, 0x01021b55, 0x16050416, 0x01021f09, 0x14203d17, 0x42371c0e, 0x4f18052f, 0xe94308ad, 0x0f9e2207,
+    0x30198543, 0x080e1e4e, 0xe00c1a0a, 0x150b2835, 0x0a1e1403, 0x2c538210, 0x071e0701, 0x0d0c5705, 0x57331324, 0x2c4d8205, 0x65150101, 0x0f1b0607,
+    0x1a294e24, 0x05e34101, 0x099d5b18, 0x140e0d22, 0xde215483, 0x38188522, 0x06151c01, 0x00001a10, 0x00000300, 0x4002e0ff, 0x0e00a001, 0x30002200,
+    0x06235000, 0xee821520, 0x82263521, 0x351322c7, 0x23078433, 0x11171621, 0x2e062f46, 0x06153735, 0x21070607, 0x37363736, 0x44212726, 0x0f22058a,
+    0x62820150, 0x01e0d028, 0xfe291b1b, 0x8b820ff0, 0x181f1625, 0x83200f0e, 0x10012b0f, 0x01201f30, 0xf0fe0f01, 0x2583a001, 0x010f4023, 0x358c8350,
+    0xc03da3fe, 0x011b1b29, 0xd0fe1c14, 0x0412131e, 0x18131304, 0x1183201d, 0x1f200125, 0x82010f30, 0x0400219e, 0xc1339f82, 0xc001bf01, 0x2f001d00,
+    0x6c004100, 0x14010000, 0x58063107, 0x27200917, 0x42429f84, 0x18312007, 0x180c9761, 0x63093bb6, 0x05230c3b, 0x60313736, 0x172506fa, 0x0f060716,
+    0x05124801, 0x07ae9918, 0x37262725, 0x82013f36, 0x37263cfc, 0x12700131, 0x09091d11, 0x090d610e, 0x111d0109, 0x29020111, 0x293e3c29, 0x18c90228,
+    0x200d2ba3, 0x0b065271, 0x07ebfe27, 0xb10c0c0c, 0x2a0482b3, 0x04040507, 0x0c86860c, 0x83050404, 0xb1b32113, 0x0126138d, 0x1c1b2240, 0x3c851611,
+    0x1c111624, 0x675e221b, 0x97611807, 0x0c5a630c, 0x4c83a220, 0x83595921, 0x214c8358, 0x58834343, 0x00201393, 0x01210082, 0x07d37a00, 0x00000b26,
+    0x01173613, 0x2721ef82, 0x32d88201, 0x02130f05, 0x0f0c1050, 0x10b0fd13, 0x10b7010c, 0x1830fe0c, 0x8507bf7e, 0xff0c3237, 0x013302c0, 0x007d00c0,
+    0x0f162500, 0x022f0601, 0x27068417, 0x013f2601, 0x14151427, 0x08636e18, 0x34353424, 0x1b890735, 0x23832a83, 0x26823620, 0x842f2621, 0x021f2209,
+    0x22348227, 0x82011f36, 0x35172f40, 0x37363726, 0x33151736, 0x16173635, 0x48821617, 0x011d1423, 0x52208937, 0x45820594, 0x17010f39, 0x02011f16,
+    0x100d0333, 0x5018060e, 0x1c030836, 0x0e0f0f05, 0x60261902, 0x26390794, 0x0f0e0219, 0x031c050f, 0x18503608, 0x0d100e06, 0x0a041b03, 0x040a6969,
+    0x2f338e1b, 0x01361803, 0x0a180f0f, 0x0a012001, 0x360f0f17, 0x2e373798, 0x0304050e, 0x3e204d0d, 0x0e6e0c0a, 0x0f050402, 0x01022d62, 0x64290202,
+    0x022006f3, 0x2d390c82, 0x04050f62, 0x0c6e0e02, 0x4e203e0a, 0x0604030d, 0x040b590d, 0x0a052a2b, 0x223b8459, 0x883f204e, 0x183e293b, 0x0916151c,
+    0x18180901, 0x14230482, 0x82011b14, 0x3e182100, 0x04233f95, 0x8200590b, 0x4b072000, 0x1f2a0893, 0x31002800, 0x43003a00, 0xeb4a5500, 0x07f54205,
+    0x0706072b, 0x33161706, 0x36373621, 0x25038335, 0x36373427, 0x704c2137, 0x08e96108, 0x37200891, 0x10df5518, 0x27261125, 0x83352631, 0x17162440,
+    0x82141516, 0x287f215a, 0x0537eb82, 0x05040b06, 0x08050503, 0x08161901, 0x07070a01, 0x1c101101, 0x471fe3fe, 0x3f2d0715, 0x0e02010f, 0x0f01020e,
+    0x02020e40, 0x8815830e, 0x41c02008, 0x292d072b, 0x01011c1b, 0x0d291b1c, 0x0a09090a, 0x05e1420d, 0x02c0013d, 0xac523636, 0x20161619, 0x06080e0c,
+    0x02150107, 0x1c1d1b01, 0x323fac27, 0x62e01d32, 0x0f8f0f14, 0x3602e025, 0x66525137, 0x07830676, 0x7811234a, 0x802d0623, 0x6e00c001, 0x85007300,
+    0xa1009800, 0x06d94f00, 0x22059469, 0x59343533, 0x0f2408d2, 0x011d0601, 0x1d341683, 0x010f0601, 0x07062326, 0x06071423, 0x0706012b, 0x14151617,
+    0x23221d82, 0x0c822f22, 0x200b735c, 0x21b11827, 0x2726210a, 0x2208f57d, 0x5136013b, 0x01280504, 0x33351736, 0x23273315, 0x118f5c18, 0x37360526,
+    0x33323336, 0x200bdf7c, 0x072e4917, 0x1201602d, 0x146a1b12, 0x30081010, 0x4302116a, 0x033d07d0, 0x0b11380a, 0x2b16010c, 0x243d1915, 0x0e09094f,
+    0x07050208, 0x0a170909, 0x060a0d0c, 0x32098207, 0x090e200e, 0x06070709, 0x0a0c0d0a, 0x06090917, 0x41080303, 0x08230568, 0x82060303, 0x120f2628,
+    0x6a279140, 0x416d1810, 0x02082610, 0x041d1623, 0x2b178404, 0x25251919, 0x58011919, 0x16020216, 0xa0770383, 0x0b0b2805, 0x26227812, 0x440c0521,
+    0x052d06b8, 0x0c221615, 0x1b2d110b, 0x02091b0e, 0x22758c2e, 0x87020507, 0x829e9775, 0x0d1727af, 0x60608106, 0x8b1801c0, 0xa8270e4f, 0x04101a2e,
+    0x83231918, 0x82012082, 0x8518208a, 0x02162184, 0x20070b43, 0x05ef6601, 0x20000d2d, 0x3e002900, 0x50004a00, 0x5c010000, 0x333c055d, 0x27261737,
+    0x36073307, 0x37363137, 0x27342734, 0x06150623, 0x16171615, 0x1723011f, 0x2405a047, 0x07222337, 0x06724117, 0x32333108, 0x26353637, 0x05272627,
+    0x16311714, 0x0635013b, 0x37150607, 0x06273315, 0x18150107, 0x201f291d, 0x425a510e, 0x6742180d, 0x24253677, 0xfc010101, 0x3b080382, 0x30362524,
+    0x02203b2d, 0x140e0d01, 0x08086603, 0x17224132, 0x0f010116, 0x0a0a0f4d, 0x49313102, 0x0a0aedfe, 0x111e1d0f, 0x7d996011, 0xb4010d0f, 0x1615010c,
+    0x1d444424, 0x01b03215, 0x06223b82, 0x00820206, 0x83060621, 0x5ea03050, 0x0e14220c, 0x0170010d, 0x1716014f, 0x82141c22, 0x31492439, 0x82ad0231,
+    0x18a9294a, 0x9b292223, 0x0605c9be, 0x0320f782, 0x002a0382, 0x80018002, 0x31001f00, 0xe5754300, 0x1716220a, 0x09bc4d33, 0x57363321, 0x272106b3,
+    0x10a84d05, 0x1811ba4d, 0x2a0b0ae5, 0x1b122980, 0x0e1c1c0e, 0x4d28131b, 0xfe2108ad, 0x10a54d60, 0x20058f4a, 0x09f37712, 0x0bdee418, 0x3d24022a,
+    0x1c01011c, 0x0102243d, 0xe34d2182, 0x4df02005, 0x112405aa, 0x11120101, 0x21082878, 0x0f89121b, 0x00002b08, 0xff000004, 0x01ff01c2, 0x002300c0,
+    0x0059003c, 0x13000074, 0x3316011f, 0x31303130, 0x36023f32, 0x26353035, 0x2731012f, 0x11832326, 0x020f222c, 0x17141506, 0x022f3405, 0x0c852326,
+    0x16021f23, 0x21288433, 0x08861701, 0x22211c82, 0x221e8231, 0x53233015, 0x0223058c, 0x50353736, 0x052505c0, 0x15070623, 0x83428207, 0x37322f62,
+    0x31043301, 0x04040215, 0x04311502, 0x0a880301, 0xfb010422, 0x01201782, 0x21881785, 0xd0fe0324, 0x7f18020d, 0x200807cd, 0x0301010b, 0x1d0d0102,
+    0xc01d0202, 0x095c010e, 0x0b0b1209, 0x0e2be9fe, 0x090a7601, 0x0d0e092a, 0x248d820a, 0x31162b01, 0x823e8404, 0x8461822b, 0x0104220a, 0x886e84db,
+    0x26218656, 0x02021e30, 0x82020c1e, 0x890c2000, 0x017f3709, 0x0a661c0f, 0x0809120c, 0x250d02fb, 0x0d0d0a6a, 0x0a092a0a, 0x73553601, 0x00242a0c,
+    0x006e0049, 0x36211300, 0x05e34237, 0x50097a4a, 0x232206fa, 0xef582221, 0x90172006, 0x7a2b201b, 0x3f8709cd, 0x2e882520, 0x8609dc4e, 0x013b2140,
+    0x20202487, 0x23059a77, 0x291b1b01, 0x4407836d, 0xfe200569, 0x20060b6f, 0x06e65980, 0x24870686, 0x21081d6c, 0x1986fe00, 0x21980120, 0x5907d647,
+    0x0b850bf1, 0x850c336c, 0x5b2c8712, 0x338b068b, 0x00201a87, 0x02370082, 0xc0ff0000, 0xc0010002, 0x25002000, 0x27010000, 0x06010f26, 0x55260717,
+    0x545d05cf, 0x37410808, 0x16372736, 0x2736013f, 0x17372701, 0x44fb0107, 0x09170b0b, 0x26244c09, 0x139e1d26, 0x19145a13, 0x1d9e141a, 0x4d0f0706,
+    0x0a160c0b, 0x5ab8fe0a, 0x017a5a7a, 0x0a0a4477, 0x4d0b0c16, 0x1d06070f, 0x2f22839e, 0x9e13135a, 0x2426261d, 0x1709094c, 0xa2fe0b0b, 0xdb692583,
+    0x00c02a0a, 0x00230011, 0x007e0048, 0x11894700, 0x9b472120, 0x36072710, 0x26072627, 0xac830627, 0x0706172c, 0x17061716, 0x37363316, 0x03851716,
+    0x36273625, 0x82272637, 0x26312602, 0x30233027, 0x10856823, 0x35833382, 0x4f080f4f, 0x50200a1c, 0x200f8256, 0x085c5001, 0x77361987, 0x17131107,
+    0x0c19190c, 0x07111317, 0x16010116, 0x110d1107, 0x11830606, 0x10070623, 0x3a13850d, 0x1b1b01a7, 0x02010129, 0x22171601, 0x1a0e1726, 0x1f30211a,
+    0x1d020120, 0x83011212, 0x062b2619, 0x151e1509, 0x2602821e, 0x2b060915, 0x561b1b29, 0xb15611a1, 0x890b200f, 0x227e876e, 0x8302010d, 0x0102237f,
+    0x12850c01, 0x49838b20, 0x22080823, 0x27168217, 0x11101c1c, 0x301f2001, 0x83057e4f, 0x0a0c2518, 0x01140114, 0x14220282, 0x84830c0a, 0x376d0020,
+    0x3f023905, 0x2000c001, 0x4d004000, 0x67005a00, 0x00007400, 0x31272625, 0x07222726, 0x4a05b856, 0x9c5805cf, 0x2726210a, 0x220cb269, 0x41070623,
+    0x2282054d, 0x33163335, 0x27363736, 0x1706010f, 0x3f323316, 0x26273601, 0xa4072307, 0x5f01290c, 0x1e151606, 0x321c0f13, 0x1c29ab83, 0x01011112,
+    0x01221716, 0x08cc8400, 0x1c12122e, 0x272737d9, 0x1b0f0f02, 0x0d0d0a08, 0x0429283c, 0x131c112a, 0x03020513, 0x2b450505, 0x20e40b05, 0x0606110a,
+    0x0b20080c, 0x600e1212, 0x07200c9d, 0x0a312682, 0xde0e1311, 0x0112121d, 0x01022507, 0x01291a1b, 0x227d8301, 0x83161622, 0x21260875, 0x0516151e,
+    0x21200802, 0x1a1a1f36, 0x0205080f, 0x3b272701, 0x170b2b13, 0x01011e16, 0x010a3302, 0x0e1330cb, 0x04820b04, 0x9d110a21, 0x18002009, 0x2c0b1b58,
+    0x003e0028, 0x006a0054, 0x23300100, 0x1b964231, 0x6e08c044, 0x4118059d, 0x062109b7, 0x23018307, 0x31171621, 0x09dfef18, 0x2205a441, 0x94330706,
+    0xa0012115, 0x44198442, 0x302009b8, 0x25086c42, 0x0b0c0c0b, 0x05840101, 0x0a8d6318, 0xa020158a, 0x01212a93, 0x18744240, 0x21077244, 0x3f43b0fe,
+    0x160e2b07, 0x01121117, 0x17111201, 0x13a70e16, 0x67620020, 0x00022d06, 0x2800c001, 0x44003700, 0x5e005100, 0x212a4941, 0x93422607, 0x2327210b,
+    0x33200e8b, 0x3d410c98, 0x26212807, 0x1a1a1016, 0x43202f21, 0x1a2708c2, 0x2a3f0129, 0x83011b1c, 0x15d935de, 0x14072f0b, 0x070f0503, 0x0304052f,
+    0x0a157609, 0x0414082f, 0x08270e83, 0x0a15eb14, 0x84130630, 0x1307220c, 0x22288376, 0x82040413, 0x13092128, 0x2c223341, 0x701307e2, 0x0f020b15,
+    0x09090970, 0x210b8704, 0x09930b14, 0x0700003b, 0xc0ff2000, 0xc0016002, 0x43000e00, 0x73006400, 0x95008400, 0x0000a600, 0x05214201, 0x42171421,
+    0x144a0533, 0x230b8305, 0x31303130, 0x2006e851, 0x08444827, 0x06070124, 0x4a481415, 0x26012805, 0x26373435, 0x49352627, 0x0f440545, 0x22172f1a,
+    0x1506010f, 0x3f321716, 0x26353601, 0x0e8b2327, 0x26273424, 0x109f012b, 0x01232d08, 0x191e1200, 0x0b011111, 0x1710120a, 0x01881806, 0x2b251919,
+    0x342b2119, 0x0408020d, 0x023f3f02, 0x0d020903, 0x2b02094b, 0x4b09022b, 0x14271384, 0x0e170b05, 0x44a7010e, 0x12360d35, 0x16170101, 0x23000122,
+    0x01011716, 0x091c1212, 0x0420080c, 0x05851602, 0x06846020, 0x05831520, 0x0a070622, 0x01390d9b, 0x01011635, 0x14191110, 0x12070f0e, 0x241c220c,
+    0x01181925, 0x01181f02, 0x82838c0c, 0x08042197, 0x0d309784, 0x161a1110, 0x1c15150b, 0x12121d33, 0x02260801, 0x2505ff45, 0x1d151605, 0x4b821722,
+    0x2316162d, 0x0515161d, 0x06300bbd, 0x8f021707, 0x070a2205, 0x8f128908, 0x08fb420c, 0xc0017f33, 0x4f001900, 0x79006400, 0x00008e00, 0x31171617,
+    0x06476516, 0x14153323, 0x2a0b8717, 0x27250721, 0x2b262726, 0x75362701, 0x2c8209aa, 0x32171623, 0x05ad5d15, 0x16011f2a, 0x3f323317, 0x35211701,
+    0x3005fa46, 0x36013f16, 0x17072527, 0x07012f06, 0x27373506, 0x059b5e26, 0x86330721, 0x9c272012, 0x01bf2a12, 0x200d0909, 0xa009090e, 0x0807850a,
+    0x01a1fe2e, 0x1613be01, 0xed262121, 0x02020f50, 0x2a08070c, 0x0906062b, 0x040c0201, 0x01010106, 0x0b4b0202, 0x13090f08, 0x260a0d1f, 0x0a5f0136,
+    0x043c1a82, 0x1b0d0905, 0xabfe070c, 0x07010410, 0x04081315, 0x16070410, 0x0a05040b, 0x70040617, 0x14221384, 0x14890107, 0x14850720, 0x148c1420,
+    0x1f04062a, 0x090a090e, 0x40400e09, 0x37058049, 0x1dde7f80, 0x51121220, 0x12141410, 0x2b2a0608, 0x110e0705, 0x03040d10, 0x29088183, 0x1c121063,
+    0x23090111, 0x07074e6c, 0x07060f08, 0x0912070c, 0x17100e0d, 0x0a0a0207, 0x10170702, 0x14040206, 0x04140606, 0x13a70602, 0x00820020, 0x20000535,
+    0x2002c0ff, 0x5f00c001, 0x71006800, 0x83007a00, 0x57010000, 0x272105da, 0x22018326, 0x5f343107, 0x1526051d, 0x33171611, 0xea513736, 0x16172205,
+    0x200a8237, 0x21208206, 0x26823122, 0x15880720, 0x13973520, 0x22272623, 0x05bc4131, 0x56053721, 0x67820733, 0x6e05c972, 0x118808ec, 0x2c089382,
+    0x42131110, 0x22212827, 0x09553131, 0x090e0e09, 0x210d0209, 0x344c010f, 0x30292c34, 0x01134330, 0x303a3346, 0x33332d01, 0x36364b49, 0x9007832d,
+    0x33552d10, 0x0821212c, 0x1e0e0b02, 0xfe5e3536, 0x50080858, 0x402007fa, 0x07870887, 0x1f82012e, 0x08080813, 0x0d02021e, 0x2202030e, 0x21059441,
+    0x1e8330fe, 0x0222702d, 0x030d0e02, 0x14091a03, 0x82011924, 0x03022c0a, 0x031a231d, 0x020d0d03, 0x903e1c02, 0x21452e11, 0x0a0b0102, 0x05032105,
+    0x2604050f, 0x1031694a, 0x118a3820, 0x22057751, 0x67030000, 0x2b78081f, 0x37002105, 0x079f4618, 0x59323321, 0x2f23055e, 0x59363701, 0x16240674,
+    0x07171617, 0x4c05454a, 0x1720053a, 0x6c10384e, 0xc58506e6, 0x0219102f, 0x4f090605, 0x02023333, 0x18583b3b, 0x210c8203, 0x0c85344e, 0xe6511020,
+    0x051e4609, 0x814be120, 0x090d3108, 0x4b7f0109, 0x01070609, 0x52393a0b, 0x023b3b58, 0x06200c82, 0xff200b87, 0x0f968818, 0x09af4318, 0x2400c02a,
+    0x00004700, 0x15171601, 0x0b887e18, 0x2221232a, 0x36272627, 0x013b3637, 0x37200482, 0x20057a5e, 0x85531803, 0x35332409, 0x18301533, 0x2b0f8953,
+    0x01353130, 0x3d021608, 0x030b2a2b, 0xfe21cc85, 0x3098837f, 0x0d090901, 0x2a2a0b04, 0x0a07073d, 0x2840c911, 0xec401a40, 0xc0012612, 0x0b0b1602,
+    0xa47e182a, 0x83d88507, 0x0a0b2649, 0xe0fe0707, 0x21008480, 0x53180184, 0x84330aa1, 0x00000400, 0xff01c0ff, 0x3900bf01, 0x5d004b00, 0x58006600,
+    0x7a4406f9, 0x48072006, 0x062205d4, 0x58181407, 0x372207ac, 0xce833732, 0x4c180384, 0x0d8208fb, 0x07161722, 0x0d634318, 0x37251382, 0x31071427,
+    0x08425c06, 0x16173225, 0x53061715, 0x013c06f1, 0x101009ff, 0x06040414, 0x03030705, 0x16160b04, 0x011e1c1d, 0x4e3c0101, 0x39393c4e, 0x012b0882,
+    0x262a2a1f, 0x07071626, 0x82010207, 0x32392401, 0x82091e32, 0x01c0300b, 0x36362524, 0x01012524, 0x37362425, 0x4d012424, 0x0d230963, 0x5321090a,
+    0x0e2805d5, 0x1eab0102, 0x013a3232, 0x41823983, 0x26271625, 0x831f2a2a, 0x39392154, 0x09826083, 0x1d1c1e37, 0x040b1616, 0x05070303, 0x14040406,
+    0x03091010, 0xfe090707, 0x245a8bd6, 0x37242401, 0x05854120, 0x09225b82, 0x43760c0b, 0x0e022106, 0x31069b4b, 0x00c00140, 0x00150008, 0x005a0027,
+    0x007f0063, 0x36441700, 0x15232305, 0x41442301, 0x34112405, 0x18232627, 0x2410c2a4, 0x2723011f, 0x05d24e26, 0x7b141121, 0x3d2605bc, 0x16311601,
+    0xef571733, 0x35372507, 0x35012f34, 0x20063546, 0x29448335, 0x35331527, 0x06072223, 0x0b433315, 0x37162205, 0x20398516, 0x2d418635, 0x15231135,
+    0x200f01c0, 0x0140010f, 0x08842060, 0x0e090924, 0x334d20fe, 0x33a0240f, 0x821a132d, 0x82132001, 0x090d261d, 0x0101010a, 0x2709841d, 0x29070109,
+    0x39140e15, 0x2021f085, 0x2bf98340, 0x031f2060, 0x180e0a0a, 0x09090108, 0x82060b55, 0x30c02b1e, 0x0f01010f, 0xf001b0b0, 0x098310fe, 0x82d00121,
+    0x10b35914, 0x132d6027, 0xff1a1313, 0x244f8500, 0x2b010165, 0x250a8538, 0x3d0d1038, 0x0b821551, 0x03820e20, 0xc0a0c022, 0xdf297d82, 0x0b0b109b,
+    0x080d1f01, 0x088e4309, 0x20a00122, 0x2b07074f, 0xc001c001, 0x58001800, 0x23250000, 0x24053447, 0x3b161706, 0x0ab94c01, 0x35241682, 0x27262726,
+    0x28064d4e, 0x15160722, 0x07060706, 0x20048323, 0x09504e14, 0x3f2e2282, 0x32173601, 0x010f1617, 0x16171633, 0xbd4b3307, 0x30012c07, 0x0a042738,
+    0x07800a0a, 0x830b0403, 0x0404230a, 0x0c820506, 0x450b033e, 0x1212010b, 0x0106061b, 0x08291b1b, 0x16010f07, 0x1b102217, 0x0b011212, 0x01141521,
+    0x24081483, 0x0a04060d, 0x110e8017, 0x0d1d0c10, 0x0d200713, 0x290d130a, 0x01011b1b, 0x50211514, 0x06080b5a, 0x0a086f07, 0x2108820a, 0x08820404,
+    0x108d0b23, 0x213d8313, 0x2383110f, 0x1a140226, 0x01161722, 0x13256083, 0x19190810, 0x2e148323, 0x161f0807, 0x09010d70, 0x022d2317, 0x83161b1d,
+    0x19232562, 0x00000819, 0x2805f35a, 0x00a00180, 0x00480028, 0x091f616d, 0xbd640720, 0x77cc8306, 0x16210597, 0x46128617, 0xd45505d6, 0x20258b05,
+    0x24218b17, 0x07062707, 0x98028431, 0x26273a22, 0x58380107, 0x29294746, 0x200f0101, 0x2301010f, 0x483b3a23, 0x22393847, 0x28108621, 0x4a4a2c2c,
+    0x2235025b, 0x250f8622, 0x1c1a1110, 0x0c851314, 0x26260229, 0x313d0138, 0x851c1d31, 0x2b01270f, 0x2f46432b, 0x4a85022f, 0x341f1f2d, 0xa0014034,
+    0x492c2d03, 0x826a5849, 0x6b0f2d5b, 0x233b3c48, 0x23220223, 0x70473939, 0x702c1083, 0x2a49495b, 0x04c0012a, 0x6c352625, 0x6e281083, 0x0312131a,
+    0x1c131201, 0x382b1e85, 0x60012425, 0x331f1f03, 0x836b3e33, 0x436c281e, 0x01042f2e, 0x85462d2e, 0x3340251e, 0x011e1d33, 0x66050348, 0x0d2f070f,
+    0x37002200, 0x7b004c00, 0x26010000, 0x65263127, 0x15260540, 0x07253521, 0x69491417, 0x3512a211, 0x07062317, 0x26070615, 0x15213527, 0x33161714,
+    0x36373217, 0xfc49013d, 0x1533230b, 0x01821716, 0x36372708, 0x27263537, 0x2d022002, 0x43e2432d, 0x02022d2d, 0x1391fe1f, 0x18190804, 0x05140509,
+    0x050d1b08, 0x081b0d05, 0x12a49005, 0x20a02908, 0x0d02010e, 0xddfd010e, 0x410d0909, 0xbf09090e, 0x400d090a, 0x2009080e, 0x20141301, 0x011a1926,
+    0x01010f01, 0x022c2d44, 0x40366e83, 0x1b141540, 0x0d0d0309, 0x141b0a03, 0x19040306, 0x04190606, 0x13870703, 0x07141a22, 0x0921138f, 0x21138a1b,
+    0x5a820295, 0x0e010124, 0x60829f6f, 0xcd490220, 0x600d2d09, 0x1817212b, 0x17170205, 0x020e4025, 0x3208574f, 0x00c00180, 0x002f0020, 0x004f003e,
+    0x16333700, 0x43373617, 0x22260871, 0x26272607, 0xc6500623, 0x17162406, 0x53071716, 0x362f09f5, 0x25272637, 0x14070621, 0x21331617, 0x82343736,
+    0x53072029, 0x108509ee, 0x9c902408, 0x23313123, 0x201f303c, 0x1f200101, 0x13171b30, 0x3f292121, 0x3d3f2929, 0x02022829, 0x083d2928, 0x82070971,
+    0x71093800, 0x16020216, 0xf0fde001, 0x07070216, 0x16100209, 0x0a070602, 0x85bffe40, 0x4101211d, 0x0a251683, 0x01011fa0, 0x8347831f, 0x230c264f,
+    0x2b021514, 0xfb6f182b, 0x82b02008, 0x070a2937, 0x16160208, 0x15026002, 0x04830983, 0x15866020, 0x5b420b83, 0x02c02207, 0x28f38200, 0x00240012,
+    0x004e0036, 0x20f58266, 0x06457135, 0xe1821620, 0x20056d44, 0x10325301, 0xaa6e1520, 0x26272310, 0x194e3127, 0x06152205, 0x203a8907, 0x05624735,
+    0x35373622, 0x33214a82, 0x05c54332, 0x0607062a, 0x0f01a007, 0x021e010f, 0x2307fe4f, 0x00011e02, 0x210fe948, 0x5c45090e, 0x87a02009, 0x011f32e9,
+    0x3d292802, 0x0228293d, 0x22701f01, 0x01011617, 0x2e43871f, 0x1601011f, 0xd37d2217, 0x0f01010f, 0x46210cd3, 0x21230746, 0x4943010c, 0xe7540f0b,
+    0x05355f0c, 0x301f2025, 0x413425a7, 0x3324078a, 0xb0fea726, 0x28244e83, 0x0e14c018, 0x14230082, 0x832818c0, 0x0f37416e, 0x42002a24, 0x37415400,
+    0x05335416, 0x1341ed83, 0x23674125, 0x20103741, 0x28194160, 0x4105907b, 0x61410b0a, 0x137d260b, 0x0f01010f, 0x0b374113, 0xca19d320, 0xa3420b87,
+    0x18184106, 0x41c00121, 0x00201c64, 0x220c2356, 0x474c0018, 0x2721191b, 0x1ed05237, 0x3637332a, 0x16173233, 0x010f1617, 0x2c089d43, 0x2f476001,
+    0x0a0a0904, 0x04030899, 0x230a830b, 0x05060603, 0x40200c84, 0x2b19b252, 0x120d8c2f, 0x040d0d10, 0x561b0704, 0x34077d42, 0x080c6961, 0x07800706,
+    0x0b6a0a0b, 0x80040408, 0x010b0a07, 0x188f52df, 0x0a0b7527, 0x1010100a, 0x080a573c, 0x00000425, 0x8201c0ff, 0x0c002b01, 0x24001800, 0x00003300,
+    0x867c3601, 0x21173106, 0x26073736, 0x35263127, 0x21171621, 0x06032726, 0x24051049, 0x07162337, 0x23128237, 0x17163130, 0x6108d082, 0x27263534,
+    0x050b9801, 0x91fe1007, 0x06010315, 0x240d6201, 0x0b0b1114, 0x2312affe, 0x0b0c5a01, 0x050e0154, 0x42070a05, 0x06199518, 0x28b5fe80, 0xbb202b29,
+    0x0f010103, 0x0f0b9601, 0x1502010f, 0x20162029, 0x1010139a, 0x0f243c11, 0x11dffe0d, 0x41070208, 0xe6422338, 0x1915141f, 0x02020d0f, 0xe7581d24,
+    0x00162b0c, 0x00520036, 0x22232500, 0x8f86010f, 0x661f3621, 0x27290525, 0x32272326, 0x37331737, 0x08674116, 0x4305ff44, 0x162605e9, 0x01171617,
+    0xec7a0727, 0x31232205, 0x05b25d06, 0x18680720, 0x30013f08, 0x370a1060, 0x0c0c080d, 0x1b1b1108, 0x0b082012, 0x372d080c, 0x1491100a, 0x1d401d0f,
+    0x085b1311, 0x11182707, 0x13232612, 0x0f851911, 0x011a132a, 0x1229655b, 0x1f121a1a, 0x24083983, 0x121b1b12, 0x080b6508, 0xc0011409, 0x0b080914,
+    0x11470ce0, 0x01150909, 0x09251501, 0x0c473409, 0x3a3a0a50, 0x050f5b0a, 0x01011228, 0x02021d0e, 0x58180e1d, 0xfe330837, 0x133081c3, 0x09251401,
+    0x14140901, 0x1011800b, 0x82010111, 0x0c8f6304, 0x22000d25, 0x47003f00, 0x21200653, 0x0725c482, 0x0f112111, 0x22e88201, 0x78313023, 0x1f30057c,
+    0x17363701, 0x23170716, 0x21070615, 0x23352726, 0x126c8018, 0xe0012708, 0x140e0d01, 0x0e14e0fe, 0x8001010d, 0x0b065865, 0x06090201, 0x100d0f38,
+    0x0f482512, 0x950c1013, 0xfe0f0110, 0x8d180f60, 0x0120091d, 0x35822b85, 0x90640120, 0xd0fe3508, 0x70573001, 0x06010108, 0x0f130e30, 0x105c1f0d,
+    0x79130f0c, 0x68051448, 0xc7851149, 0x0200002c, 0x00800140, 0x00a90052, 0x6d5700f8, 0x31352705, 0x23263130, 0xa7830722, 0x26272623, 0x720d9327,
+    0x21820558, 0x4506e147, 0x078a07b4, 0x37363723, 0x05466636, 0x87263121, 0x89368552, 0x8c0f9554, 0x32332156, 0xfc4b4882, 0x48372006, 0x5683054e,
+    0x83362521, 0xbe9a180c, 0x821c890c, 0x93352060, 0x87d191b5, 0x2602306a, 0x0a0c0c17, 0x010a0c0d, 0x24241312, 0x8f011212, 0x0c022e0b, 0x070d170b,
+    0x0b020308, 0x14260e0a, 0x2fa5180f, 0x2614290e, 0x020b0a0e, 0x0d070803, 0x02234686, 0x87231312, 0x12022246, 0x21528912, 0x46960c0c, 0x1817222a,
+    0x0f26140e, 0x02030b0a, 0xfe214682, 0x84649600, 0x21ab961d, 0xb7861323, 0x180b0c22, 0xd22eab87, 0x01080705, 0x0a020909, 0x0a010209, 0x0987020a,
+    0x82030921, 0x07072209, 0x83ce8305, 0x0d08292a, 0x01070809, 0x09080701, 0x0d210787, 0x83ce8308, 0x059023d6, 0x38820707, 0x0a090325, 0x830a0101,
+    0x21098938, 0x42860801, 0x21820820, 0x070a0d28, 0x0a070808, 0x00820809, 0x090d0926, 0x0d080702, 0xe2203e83, 0x03215b9a, 0x219d8804, 0x9d8d0902,
+    0x08070122, 0x00209d88, 0x04380082, 0xc0ff2000, 0xc0019f01, 0x23001100, 0x56004400, 0x013f0000, 0x07060727, 0x25054276, 0x36373637, 0x0582012f,
+    0x2c0ef467, 0x31272637, 0x06010f26, 0x012f2223, 0x2b2d8326, 0x011f1617, 0x33151716, 0x013f3635, 0x24051f5a, 0x17060717, 0x08235a16, 0x9d012f38,
+    0x0b343c1f, 0x30090101, 0x0b0d130d, 0x0a02030d, 0x1722431b, 0x14610116, 0xb940080b, 0x0e10100a, 0x30302829, 0x100e2928, 0x03090a10, 0x12290e02,
+    0x1214c014, 0x03020e29, 0x1f3c5909, 0x03020a1b, 0x130c0b0d, 0x0109300d, 0x24330b01, 0x0b35361f, 0x400c0f0e, 0x0f0b0810, 0xfd240e10, 0x21234c82,
+    0x83171721, 0x22212554, 0x0e011716, 0x1d233783, 0x831d1c1c, 0x3b52834a, 0x26080d1c, 0x1c0d0826, 0x0e10100a, 0x242035b6, 0x0b0f100e, 0x0c401008,
+    0x350b0e0f, 0x2f05c750, 0xb6010002, 0x2d000a00, 0x51003f00, 0x23130000, 0x3721cc82, 0x41dd8336, 0x556f0504, 0x14152109, 0xd150f783, 0x26272605,
+    0x21352627, 0x22f98235, 0x64373631, 0x1382074d, 0xd95c2720, 0x83098305, 0x30198247, 0x03ffff17, 0x0a2c1a1a, 0x74070c0b, 0x12120181, 0x061b501b,
+    0x1111202b, 0x29291f20, 0x292a2b2e, 0x330b821f, 0x9ffe8001, 0x140e0d01, 0x0e0e0d15, 0x0e14150d, 0x8101010d, 0x68089659, 0x012f06cf, 0x2e2e3800,
+    0x0302061e, 0x1b20a90a, 0x4e011212, 0x403105f5, 0x1b232426, 0x0f0f0e1b, 0x231b1b0e, 0xfe402624, 0x873d84d0, 0x36079233, 0x00000500, 0x4002c1ff,
+    0x5400c001, 0x71006600, 0x87007c00, 0x84250000, 0x05d854b4, 0x7e181720, 0x50530ba2, 0x05397a05, 0x16170623, 0x68d88237, 0x795f0742, 0x82118205,
+    0x058053e8, 0x45822720, 0x37252187, 0x22052736, 0x3e5f1827, 0x15162508, 0x23060714, 0x2e07d04a, 0x27070607, 0x37361736, 0x07222326, 0x82031716,
+    0x26272108, 0x16360882, 0x15400217, 0x0a1d1a36, 0x06042801, 0x01070105, 0x33332222, 0x08822222, 0x0406052b, 0x09010128, 0x16351a1d, 0x350b8201,
+    0x2e2d0f0e, 0x0c181b2e, 0x150f2c0c, 0x363e0606, 0x1b12121b, 0x90823d36, 0x0c2c0f2a, 0x2f1a180c, 0x0e0f2d2e, 0xfe214183, 0x090e41df, 0x0e0e6508,
+    0x0262150d, 0x16162419, 0x091f2203, 0x21258424, 0x2c260d22, 0x220d262c, 0x24021959, 0x03231e09, 0xa4241616, 0x050f203d, 0x313f1e1a, 0x06040305,
+    0x23341214, 0x23010123, 0x14123423, 0x05030406, 0x1a1e3f31, 0x3c200f05, 0x04030307, 0x0c190811, 0x2f2d2d0d, 0x05091b30, 0x02060602, 0x18101f0b,
+    0x0b1f1018, 0x05300b83, 0x302f1b09, 0x0c0d2d2d, 0x04100919, 0x24060303, 0x0807d441, 0x140e0d24, 0x3a0e0e14, 0x281b1a23, 0x12093027, 0x0af52232,
+    0x1124100a, 0xfe112311, 0x21241ace, 0x30091232, 0x8e182827, 0xc22d0773, 0xc0010002, 0x32001400, 0x00005800, 0x05d24b13, 0x16171626, 0x30333217,
+    0x55069e43, 0x17830900, 0x18171621, 0x2a090969, 0x27262726, 0x31072607, 0x65011d06, 0x23210684, 0x41d31822, 0x53128209, 0x12820590, 0x0416da33,
+    0x2b3e1501, 0x1503062b, 0x01150101, 0x4f383807, 0x05944a06, 0x32333e24, 0x66421e1e, 0x26012c06, 0x50414127, 0x09080b34, 0x4c1d1001, 0x22080932,
+    0x02163016, 0x48323302, 0x0a1d1e29, 0x3b20210b, 0x15016001, 0x2b060217, 0x02143e2b, 0x384f1603, 0x42600738, 0x012505a6, 0x33321e1e, 0x0857853e,
+    0x41415028, 0xe3012627, 0x0c070702, 0x0c051032, 0x0d0d1520, 0xf6140d0e, 0x16010215, 0x2a2a45f7, 0x1e1d0a0c, 0x2f303f29, 0x5b47000d, 0x06cb4905,
+    0x2f002229, 0x00003c00, 0x18331513, 0x2207bd57, 0x8233011d, 0x151727c8, 0x37363521, 0x16883736, 0xc6191520, 0x06200daf, 0x2307e950, 0xa0232726,
+    0x2a06744c, 0x0d0e1430, 0x0140fe01, 0x6a140e0d, 0xa020067b, 0x21053670, 0x1983a0fe, 0x010f5025, 0x84600f01, 0xa0012104, 0x08874f18, 0x39842d84,
+    0x2106c343, 0xde76fea0, 0x10012208, 0x20318740, 0xfb43180f, 0x21538209, 0xb7bc00c0, 0x37362126, 0x21272635, 0x0121b7ab, 0x21b88320, 0xb9abe0fe,
+    0x32834020, 0x002c0482, 0x00000700, 0xff01c1ff, 0x2900c001, 0x08a3b518, 0x87664720, 0x31272605, 0x0f222326, 0x052a4601, 0x3f16172c, 0x32333601,
+    0x06071617, 0x12870507, 0x46253721, 0x272b050a, 0x06173736, 0x37270307, 0x88370717, 0x013f2704, 0x26071716, 0x1c821727, 0x82353621, 0x013e081e,
+    0x272716f2, 0x1c272a2e, 0x0703040b, 0x0c0c0721, 0x09081b0d, 0x03070a11, 0x9ffe0b04, 0x0703030c, 0x0d0c0720, 0x365c010c, 0xb2191414, 0x100e1403,
+    0xae0d0f15, 0x1f3d1f3d, 0x3c1f3c6b, 0x04836f1f, 0x2e152608, 0x092d0a0c, 0x053c520e, 0x033d0103, 0x2c650107, 0x0f171817, 0x0c0c0d08, 0x04030b37,
+    0x10041107, 0x070c0d0b, 0x214782d3, 0x6583370b, 0x22ce2d08, 0x0d3b3b3a, 0x03073e03, 0xfe06013e, 0x261227b8, 0x12274013, 0x25431227, 0xc4112713,
+    0x2e0d092d, 0x146c080f, 0x07070908, 0x000f1014, 0x0a5f9918, 0x3300202a, 0x26010000, 0x07063107, 0x2327f183, 0x03012f22, 0x18161706, 0x24097d6f,
+    0x26273637, 0x4f048227, 0x1f23057f, 0x44371601, 0x550805d1, 0x29282a01, 0x0a371d29, 0x0606050a, 0x04803205, 0x86130b04, 0x0b0a0a31, 0x2566390b,
+    0x10101614, 0x080f5c2f, 0x01261f07, 0x24082102, 0x19212a2a, 0x011f2121, 0x0a091323, 0x0b0b3820, 0xfe320505, 0x120a09f9, 0x0b324107, 0x390a0a0b,
+    0x30271232, 0x23182f2f, 0x27822020, 0x232a2a2a, 0x02012108, 0x08071e26, 0x0023a982, 0x63000a00, 0x333207fb, 0x49003e00, 0x5b005200, 0x6d006400,
+    0x7f007600, 0xbb828800, 0x3117322b, 0x14011d16, 0x012b0607, 0x051c6a15, 0x0d044e18, 0x36013f27, 0x013b3637, 0x05254435, 0x07250b84, 0x17160706,
+    0x22c78333, 0x19210323, 0x2008b532, 0x83158337, 0x6917200d, 0x278407cf, 0xf3840c83, 0x119a1e83, 0x3b430120, 0xd8502c06, 0x04111219, 0x12010117,
+    0x67fe1b12, 0x17300598, 0x18121104, 0x090d5038, 0x09010109, 0xc0e10d09, 0x09d57818, 0x60011022, 0xfe210c83, 0x200583a0, 0x07bd6920, 0x08876020,
+    0x08873020, 0x11a29020, 0x09c00133, 0x0e400e09, 0x0f200909, 0x0796180f, 0x121b4607, 0x27868412, 0x96070746, 0x200f0f18, 0x30221e86, 0xf65a0f01,
+    0x70fe2105, 0xe8200987, 0x100ea018, 0x11872020, 0x002008a3, 0x04330082, 0xc1ffffff, 0xc0010202, 0x37001d00, 0x6d005300, 0x18370000, 0x20072659,
+    0x07a26515, 0x2506024e, 0x26273435, 0x81793723, 0x35363306, 0x26012f34, 0x010f2223, 0x06072627, 0x17161507, 0x0b832627, 0x06201183, 0x8c473983,
+    0x82172005, 0x3635282e, 0x36371327, 0x82272627, 0x22278258, 0x83013f16, 0x013f2150, 0xc83b4284, 0x07091588, 0x093e1e0e, 0x0d0a1709, 0x1e3e0a0c,
+    0x06060d0a, 0x07070113, 0x8e87700a, 0x10200819, 0x02011213, 0x10136c16, 0x0c0a3e1e, 0x09170b0d, 0x091e3f09, 0x87150902, 0x14020116, 0x070e1eed,
+    0x01300a84, 0x1e0f1313, 0x0d0d093f, 0x0a0a160a, 0x1301a13f, 0x0a202f86, 0x3e202f82, 0x88242f84, 0x3f07070a, 0x3c84178e, 0xbe021722, 0x022d8a92,
+    0x09158915, 0x101eadfe, 0x02011413, 0x23948a15, 0x3b0a0d0c, 0x08098f55, 0xa001402f, 0x0d000800, 0x1b001200, 0x00003e00, 0x012f3601, 0x17012b26,
+    0x07232533, 0x23333533, 0x05273315, 0x06233733, 0x1706010f, 0x21372305, 0x050c4117, 0xe4563320, 0x56212007, 0x310806b6, 0x37363337, 0x02272635,
+    0x18011130, 0x1a630c04, 0x64e0fe61, 0x65857e1a, 0x7bfe197e, 0x0c631a61, 0x11021803, 0x04142002, 0x140400fe, 0x0f01010f, 0x8056141c, 0x84402005,
+    0x1c142106, 0x01261383, 0x5f120220, 0x0086800d, 0x5f0b0126, 0x20400213, 0x21054d59, 0xb51810a0, 0xa0200a0a, 0x00273384, 0xff000007, 0x827f02e0,
+    0x00062cbf, 0x0020000b, 0x00400029, 0x82710055, 0x822720c3, 0x373622b6, 0x25c18327, 0x36171617, 0x0582013f, 0x30311624, 0xdb823235, 0x1f232723,
+    0x90d18901, 0x263322cf, 0x552f8227, 0x36270b1a, 0x34373637, 0x75272627, 0x342006ef, 0x16200e82, 0x17234f83, 0x84373130, 0x06072a08, 0x0ea30107,
+    0x1e183d65, 0x27f28293, 0x09171cbd, 0x01151509, 0x18270083, 0x0c630c03, 0x4143fe0c, 0x01230700, 0x8ccbfe45, 0xd14108fe, 0x3302022f, 0x1e1216d2,
+    0x21203629, 0x2e2d0101, 0x2d2d4443, 0x27191802, 0x261e1712, 0x0d011919, 0x1003190c, 0x020f0f10, 0x03010227, 0x06060e02, 0x48580118, 0x481b1c7f,
+    0x19488080, 0x1308091b, 0x08678413, 0x010b604f, 0x80380a3e, 0x12600b01, 0x01202002, 0x010e200f, 0x010f129f, 0x340f0d02, 0x1d493a4b, 0x25271514,
+    0x27353531, 0x022c2d43, 0x432d2c02, 0x252e2e1e, 0x170110e6, 0x15142917, 0x15041e15, 0x02141415, 0x0403022f, 0x1e1e1e04, 0x01000014, 0x2c008200,
+    0x80010002, 0x00002c00, 0x07061525, 0x55591823, 0x84152009, 0x2726250b, 0x33373635, 0x16230387, 0x85331517, 0x23348203, 0x4020500f, 0x50250184,
+    0x0f01010f, 0x23028430, 0x30010fe0, 0xf0200284, 0xde410982, 0x880f2008, 0x82248416, 0x6700202a, 0x80280777, 0x3100c001, 0x61005600, 0x24067945,
+    0x36371300, 0x05375a17, 0x08780620, 0x17142105, 0x0906a618, 0x26273326, 0x011f3637, 0x704c0583, 0x852a8305, 0x18372009, 0x850a0199, 0x05e348ba,
+    0x06842620, 0x2617313b, 0x06072227, 0x33171615, 0x0f063727, 0x37363301, 0x23262734, 0x33350131, 0x205e8415, 0x83088217, 0xc1233170, 0x0c0e1319,
+    0x1a161c11, 0x1504240e, 0x99090e0d, 0x08070d4b, 0x111c1621, 0x1c130e0c, 0x0a140509, 0x0a040908, 0x14150a0a, 0x23970805, 0x161f1e17, 0x14151e23,
+    0x83040401, 0xc0240829, 0x0d01c020, 0x0404140e, 0x1e151401, 0x0a0c0814, 0x16020707, 0x0c9c1d31, 0x16311e07, 0x0a070702, 0x90c0d8fe, 0xe0202883,
+    0x90332784, 0x0c128901, 0x140e1311, 0x2f1c1502, 0x17111106, 0x830e12e0, 0x4001213f, 0x153a2383, 0x0c11130e, 0x09161914, 0x09040503, 0x05141e1e,
+    0x4817150a, 0x28281c01, 0x5e83011c, 0x010a0e2f, 0x51140d0e, 0x14516161, 0x0a010e0d, 0x3585830e, 0x08010a3b, 0x01170907, 0x0a010b25, 0x09170125,
+    0xdffe0807, 0x52838050, 0x50803022, 0x00325383, 0xff000003, 0x017f02c1, 0x004500c0, 0x004f004a, 0xa94e2500, 0x36272705, 0x012f3637, 0x046b0f26,
+    0x17162506, 0x07262707, 0x2c05a748, 0x26273637, 0x3237012f, 0x32331633, 0x06634337, 0x32220982, 0xd84e1733, 0x081a6b05, 0x27332a08, 0x02071737,
+    0x0f0f067f, 0x25271610, 0x57160a0a, 0x7372190e, 0x16570f19, 0x27250a0a, 0x0e0f1016, 0xa2070307, 0x06060407, 0x31208206, 0x04050202, 0x0c1f1f28,
+    0x200b1414, 0x0504281f, 0x22820202, 0x04311a82, 0x0206a207, 0x247095fe, 0x1358135f, 0x0e70245f, 0x33148210, 0x2a1b6509, 0x1696292b, 0x08313008,
+    0x2a289716, 0x09661b2b, 0x103a1682, 0x03430307, 0x0f0e1007, 0x01680907, 0x4b281716, 0x1716284b, 0x07096801, 0x1a850f0e, 0x2e100129, 0x47472740,
+    0x182e4027, 0x3408a740, 0x00a00100, 0x00190014, 0x22210100, 0x13170607, 0x33161716, 0x21d88221, 0xe7821337, 0x07233908, 0x07212721, 0x41fedf01,
+    0x0109090f, 0x11120438, 0x18110119, 0x38041112, 0x10090901, 0x14b2fe38, 0x01147601, 0x0f0b0ba0, 0x0f189cfe, 0x180f1010, 0x0b0f6401, 0x8080c00b,
+    0x04205f82, 0x29085348, 0x0076001a, 0x00a50099, 0x99182500, 0x272319bb, 0x821d0607, 0x3f3221b3, 0x23059f7e, 0x06010f14, 0x07200282, 0x1d220783,
+    0x94821401, 0x19823620, 0x1f323329, 0x36331601, 0x8226012f, 0x3637270c, 0x17163337, 0xc2460706, 0x17162105, 0x17211c84, 0x21328414, 0x28821415,
+    0x6b013b21, 0x312405e8, 0x22232613, 0x04843382, 0x84232721, 0x24208657, 0x17141716, 0x21488236, 0xa3182531, 0x072908d9, 0x01000231, 0x393a2222,
+    0x91591848, 0xf6730811, 0x0b010921, 0x032a0304, 0x010a0104, 0x0c091403, 0x0401091a, 0x08090a12, 0x0408120d, 0x04070904, 0x0e060311, 0x0c050104,
+    0x02010c15, 0x010f1d11, 0x0b150f01, 0x01030508, 0x07090c0a, 0x02010206, 0x06060701, 0x06171012, 0x3738020b, 0x0805ac55, 0x0b0e0709, 0x1c0b0f11,
+    0x13151811, 0x011c1b10, 0x130d1013, 0x01021615, 0x192b2b36, 0x0a20effe, 0x840b0b0a, 0x91c02004, 0x34a3858b, 0x0b061ad0, 0x02010b09, 0x0a01021c,
+    0x08140305, 0x0a030905, 0x3e928206, 0x080d040e, 0x080f0109, 0x04160608, 0x0c030d03, 0x0d040706, 0x0f010211, 0x0508010f, 0x820a0503, 0x05022987,
+    0x01010203, 0x08090507, 0x1e289182, 0x3a3a5622, 0x04ccfe06, 0x0a2a8f82, 0x01010f17, 0x2114120b, 0x8e821a04, 0x3f820220, 0x1d1c0529, 0x0b20ff2d,
+    0x840a0a0b, 0x00003104, 0x00000200, 0xc0016000, 0x13002001, 0x00002700, 0x0917cf19, 0x090b5918, 0x17323523, 0x05b44f31, 0x01211389, 0x05c24da0,
+    0x890fe06e, 0x09a0230f, 0xd3580e09, 0x0ce35908, 0x2305c37e, 0xa001c000, 0x37207385, 0x2008e761, 0x8e651811, 0x33112107, 0x10781392, 0x85518d0c,
+    0x6f012068, 0x94910665, 0x2e0bc34b, 0x0041002f, 0x26270100, 0x010f2223, 0x7d020f06, 0x0720089c, 0x082a4018, 0x2208124f, 0x8236013f, 0x34352402,
+    0x50260127, 0x31080ebf, 0x1ef70107, 0x0a0c0d0a, 0x0c03062e, 0x3416134c, 0x0b070e25, 0x221a241f, 0x2b2a0505, 0x18253334, 0x131e0504, 0x060d220e,
+    0x07254c0d, 0x090a2f06, 0x7045d9fe, 0x14360807, 0x0e0d0e0d, 0x1e990114, 0x062f0909, 0x0d4c2408, 0x0e220c06, 0x03051d14, 0x3433241a, 0x0505292c,
+    0x1f241b21, 0x250f060b, 0x4c131634, 0x2e06030c, 0x0a0d0c0a, 0x0452c7fe, 0x8200200f, 0x00013900, 0x02e0ff00, 0x00960100, 0x1300002b, 0x07011f36,
+    0x17063114, 0x16011f06, 0x2405bc53, 0x1736012f, 0x21018216, 0xb1530615, 0x46272007, 0x2c080536, 0x33202477, 0x0101034c, 0x06047004, 0x5b3d0305,
+    0x2c170104, 0x21213434, 0xb42f0101, 0x0c10100c, 0x01012fb4, 0x01342121, 0x4e0b0694, 0x3f26824b, 0x04680204, 0x62060404, 0x3f05044c, 0x270a081a,
+    0x41063626, 0x0b0ba92c, 0x06412ca9, 0x0a272636, 0x05208b82, 0xc1238b82, 0x5401ff01, 0x352c054f, 0x96006700, 0x16010000, 0x33163117, 0x22069365,
+    0x82070627, 0x37322187, 0x0e64fd18, 0x5c343721, 0x152006ac, 0x2b83aa83, 0x11830720, 0x27060723, 0x05914122, 0x37820720, 0x0b842320, 0x37220f83,
+    0x23821736, 0x26085e52, 0x27363736, 0x18173726, 0x8207b568, 0x0623250c, 0x16072627, 0x07202a83, 0x2607dc48, 0x33161706, 0x84161736, 0x2421832a,
+    0x0d011f01, 0x0662530d, 0x0d0e132a, 0x0d146f01, 0x140d0e0e, 0x7f230585, 0x82150d0e, 0x31218609, 0x0908073b, 0x05083e3d, 0x03070204, 0x0d070802,
+    0x0b831919, 0x01061227, 0x3a0b0909, 0x2317843c, 0x08070104, 0x2c081786, 0x19fc0813, 0x08070d19, 0x02070302, 0x3e090404, 0x03080b3c, 0x05110602,
+    0x0d121306, 0x03010708, 0x05040208, 0x0b3a3c08, 0x06010909, 0x240b8312, 0x0e143101, 0x227a840d, 0x8201010d, 0x83302093, 0x8391820b, 0x2319820b,
+    0x0d149001, 0x21081885, 0x010e0e14, 0xc4150e0e, 0x0405060a, 0x0606011a, 0x0c191707, 0x0403090a, 0x36080606, 0x06060b3d, 0x14821804, 0x84160821,
+    0x01053e14, 0x08050601, 0x04713e39, 0x0c0a0903, 0x06071719, 0x041a0106, 0x370a0807, 0x010f0f32, 0x21148403, 0x14820816, 0x3e821820, 0x363d0b22,
+    0x00230a82, 0x65000200, 0x342707cb, 0x00003d00, 0x82262725, 0x63362001, 0x07220630, 0x856a1706, 0x22108205, 0x8335012f, 0x3f26211a, 0x27055c42,
+    0x17373233, 0x32013b16, 0x2f210e82, 0x6f5b1801, 0xfe320808, 0x19180c46, 0x0e0d0f20, 0xca090308, 0x02242461, 0xec0e0909, 0x07090813, 0x1b1b2329,
+    0x0c04030f, 0x170c0508, 0x141a1e17, 0x33100a2e, 0x0d2e090d, 0xb14db606, 0xa5733407, 0x0615151f, 0x22141408, 0x244b0309, 0x51795353, 0x8209090e,
+    0x521136fb, 0x13120301, 0x0c04061d, 0x10190805, 0x0d400d10, 0x130f2809, 0x05774d6e, 0x00011722, 0x2f060f43, 0x01ff01c0, 0x002100c0, 0x06030100,
+    0x03272223, 0x2307075b, 0x012f2223, 0x27390b83, 0x36372603, 0x17162137, 0xff010716, 0x06060257, 0x032d4302, 0x22030505, 0x210b832e, 0x0b83232d,
+    0x04572708, 0x01110909, 0x090a0fc0, 0xfe9a0103, 0x0107072d, 0x0606ac6b, 0x0606c585, 0x05057cbb, 0x0c101201, 0x0b01010c, 0x834c0f0b, 0x0010260f,
+    0x00360016, 0x217b823c, 0x64823621, 0x15173230, 0x31171637, 0x35231716, 0x36231505, 0x08823337, 0x23152124, 0x5e643315, 0x18352005, 0x200830bd,
+    0x24098323, 0x25353335, 0x082b8333, 0xfe400120, 0x3e3e27f1, 0x2010104c, 0x1f2d2d37, 0x6000ffb0, 0x60421d01, 0x40400140, 0x0e0d01c0, 0x605bb014,
+    0xb0220807, 0x010d0e14, 0x422001c0, 0x0160011d, 0x22223b20, 0x797e0201, 0x2d201f0d, 0x46809979, 0x8080803a, 0x21835020, 0x2008ed76, 0x253d8380,
+    0x3a802050, 0xef418046, 0x01c03007, 0x001200bf, 0x25000029, 0x06072221, 0x4806011d, 0x3d2b0633, 0x37272601, 0x06310726, 0x4527010f, 0x1f240620,
+    0x36372101, 0x29080c82, 0xe1fe5f01, 0x0109080e, 0x010d0909, 0x09090e20, 0x154a1e02, 0x1512191a, 0x30310f1e, 0x1f1e3c3c, 0x20013c0d, 0x03021151,
+    0x21822014, 0x090f1f23, 0x2206830a, 0x83d10220, 0x80192512, 0x0c1e1f3b, 0xd0222883, 0x34821656, 0x270c5b48, 0x00240018, 0x0052003b, 0x2205bf48,
+    0x6716011d, 0x3621050f, 0x08ef5c37, 0x35231523, 0x06c45433, 0x44250721, 0x3420072d, 0x49419382, 0x83142005, 0x23169530, 0x90fe9001, 0x0128ab82,
+    0xc0291b1b, 0x011b1b29, 0x21086660, 0x97451010, 0xdcfe2b07, 0x16020113, 0x0c07070a, 0x0983150b, 0x82021621, 0x92702008, 0x00012413, 0x7b0e0909,
+    0xf15f08f1, 0x60a02107, 0x3107a145, 0x16180bfb, 0x09070802, 0x0c151418, 0x0216170c, 0x09831602, 0xff841494, 0xc8ff0933, 0x8401f601, 0x20001100,
+    0x43003000, 0x32250000, 0x0d755937, 0x012f3322, 0x08228f18, 0x36331724, 0x9941013f, 0x82162005, 0x3637210b, 0x0324fe82, 0x27260706, 0x21052c45,
+    0xb9593233, 0x00012105, 0x22086f46, 0x83010d0e, 0x2a34089a, 0x0e0d0947, 0x0210450c, 0x860f090a, 0x0ccb2402, 0x47090d0e, 0x0f860224, 0x10020a09,
+    0x18127745, 0x08471218, 0x2e0d0404, 0x0d2e3636, 0x47080404, 0x140e0e91, 0x0e214484, 0x0807820d, 0x71730e2a, 0x0902020d, 0x0b0e5e3b, 0x172d010a,
+    0x02020979, 0x2d17710d, 0x0e0b0a01, 0xfffe3b5e, 0x0b01010b, 0x0d0d0d71, 0x07151507, 0x713f0682, 0x10000600, 0xf001d0ff, 0x0a00b001, 0x2b001c00,
+    0x51003600, 0x00006300, 0x07262737, 0x83140706, 0x461720b9, 0xb963070a, 0x17332407, 0x84222306, 0x26c583c7, 0x2637012f, 0x8216010f, 0x26352329,
+    0x6e4a012f, 0x17162107, 0x63180183, 0xce6b0cf8, 0x29e22a10, 0x092f0e0a, 0x19014f10, 0x0517481e, 0x21080585, 0x11100e1e, 0x0e07290d, 0x1d23231d,
+    0x4129070e, 0x19290b0d, 0x09104f01, 0x36435f2f, 0x01202036, 0x32192001, 0x4b3a0f9f, 0x02023231, 0x4b4b3231, 0x02023132, 0xef4b3132, 0x26090d43,
+    0x1f02113d, 0xdc484f10, 0x090f260b, 0x080f4309, 0x2b02820f, 0x0d09a543, 0x021f1043, 0x7a263d11, 0x66854e91, 0x8360fe21, 0x825a844a, 0x08078352,
+    0x00050023, 0x02c0ff00, 0x00c0017f, 0x003c000c, 0x0060004e, 0x01000091, 0x16110706, 0x36373217, 0x27261135, 0x21e48307, 0xe36f012b, 0x16172405,
+    0x18371617, 0x20097b4d, 0x200a8933, 0x06fe4116, 0x47360221, 0x07200a65, 0x4706df75, 0x11820a77, 0x27011f25, 0x8b262726, 0x07332152, 0x3321498a,
+    0x83238215, 0x013d234d, 0x84822733, 0x36372808, 0x153f0127, 0x0a150202, 0x17010707, 0x10110769, 0x10153215, 0x04280711, 0x140d0605, 0x0e09090e,
+    0x1009080e, 0x820d0a09, 0x0e0a2906, 0x060d0505, 0x56270406, 0x20055147, 0x06814214, 0x147f0130, 0x0d0e0e0e, 0x0d0d1515, 0x140d0d01, 0x458d287f,
+    0x1105052c, 0x0d090928, 0x100a090d, 0x07820801, 0x27090a26, 0x0f060510, 0x01314882, 0xfe1602c0, 0x07021630, 0xd0010a07, 0x14ac0216, 0x2800820c,
+    0x0b0d7a14, 0x0f06040c, 0x05dd419b, 0x85909021, 0x0b9b2807, 0x0b0c0402, 0x494c7a0d, 0x0f8f0f30, 0x8a7ac621, 0x30022246, 0x203e8560, 0x20078760,
+    0x22468430, 0x4c030000, 0x472908fb, 0x51004c00, 0x27250000, 0x0b825337, 0x4e097653, 0x07220656, 0xed5f3122, 0x06a84205, 0x2734352c, 0x17373530,
+    0x37363716, 0x07822736, 0x4a323321, 0x47820552, 0x17071722, 0x22081182, 0x51f70107, 0x2f0a0a30, 0x0b0d0d0b, 0x0d095030, 0x0961090e, 0x290a5109,
+    0x0d282c2c, 0x01126c0a, 0x550d0403, 0xa2820609, 0x6b120138, 0x02150a0d, 0x500a1201, 0x090d0c0a, 0xfe090a61, 0x454945e5, 0x0483a449, 0x3050b829,
+    0x0b0d0e0a, 0x820a0a2f, 0x301b8247, 0x510a0c0d, 0x02011209, 0x6c0d0a15, 0x09090111, 0x2a48870e, 0x12010304, 0x280d0a6c, 0x82292c2c, 0x25298221,
+    0x430a0e0c, 0x46824a44, 0x444a4423, 0xf7ad184a, 0x002e220c, 0x0c735a57, 0x26373625, 0x5a272627, 0x03211d6f, 0x06534f37, 0x2620fb82, 0x2007dd43,
+    0x06784f31, 0x83161721, 0x05a54401, 0x0216d827, 0x293d1602, 0x82058228, 0x37362309, 0x705a0851, 0x1b232417, 0x6e030101, 0x0d3b06d4, 0x0101090a,
+    0x0706751c, 0x091f0407, 0x42333109, 0x01073c41, 0x01750601, 0x82160258, 0x29282246, 0x2505823d, 0x36375116, 0xa6436802, 0x11735a05, 0x1ba6fe22,
+    0x3b050f41, 0x0d090a0a, 0x1b010304, 0x01010674, 0x42413c07, 0x09093133, 0x0707051f, 0x00007506, 0x3105175e, 0xc0018001, 0x16001100, 0x20001b00,
+    0x23010000, 0x8e181107, 0x35240fee, 0x23331533, 0x01230487, 0x7e80c040, 0x0983091c, 0x3030a023, 0x22028450, 0x1880c001, 0x260a259a, 0x12121b80,
+    0x8460a001, 0x246b8200, 0xff000008, 0x2d6b88c0, 0x0028001f, 0x0036002d, 0x0045003b, 0x718a1300, 0x2005686a, 0x316e8717, 0x1d161732, 0x15330701,
+    0x2b060714, 0x33233501, 0x04842315, 0x2627222f, 0x1521023d, 0x34013d21, 0x3b363137, 0x20168201, 0x21948900, 0x7a83c080, 0x4040e02f, 0x0e204060,
+    0x40400909, 0x200e0909, 0x230e8760, 0x00ff0001, 0x40221083, 0x8f578001, 0x12122406, 0x8440011b, 0x40c021d4, 0x80202c85, 0x39883785, 0x46834020,
+    0xc7442020, 0xc0012d05, 0x1100c001, 0x3e002200, 0x77004c00, 0x2e0b1170, 0x35363736, 0x27262734, 0x06070611, 0x58062307, 0x36290554, 0x05272635,
+    0x06310722, 0x05d84f23, 0x15060722, 0x2005fd56, 0x05cb5237, 0x10823720, 0xb6561620, 0x26272405, 0x8233012f, 0x1706213a, 0xf4442182, 0x2f342609,
+    0x30333401, 0x442f8233, 0x1b8407d0, 0x448f0121, 0x15210777, 0x0800820e, 0x020e1525, 0x0e600f01, 0x600e0202, 0x010e0e14, 0x08f2fe0f, 0x06080403,
+    0x06054405, 0x05050506, 0x0b140e44, 0x82010d0d, 0x5e2d350a, 0x0c0b0109, 0x5c090d08, 0x2f06071e, 0x040f146a, 0x4e130104, 0x2d054842, 0x01013d0e,
+    0x01010b52, 0xce110b0b, 0x0082090d, 0x2d5c0d20, 0x0b6b4705, 0x0140fe22, 0x2a062f58, 0x140e0d01, 0x0504010f, 0x82440404, 0x2e668261, 0x07060e44,
+    0x0404080c, 0x0d095eaf, 0x82070712, 0x09082b61, 0x0e0f1175, 0x131a060e, 0xfa42534e, 0x14592105, 0x53256482, 0x0b11100c, 0x5c73850c, 0x5b4d08fb,
+    0x00362505, 0x01000066, 0x250b454d, 0x16171607, 0x05661333, 0x22290805, 0x3637012f, 0x022f3435, 0x1f161506, 0x26270701, 0x14070623, 0x33160517,
+    0x37363736, 0x33160701, 0x22173732, 0x17313031, 0xff0e1937, 0x2e2d8308, 0x27262726, 0x27010f22, 0x27343530, 0x83302707, 0x011f2334, 0x6c69b001,
+    0x08dc8705, 0x16024f4a, 0x1408060c, 0x32880808, 0x6a290e08, 0x4b120101, 0x0605c62e, 0x010d0117, 0x1d131288, 0xfe011314, 0x09080a78, 0x01300b0e,
+    0x06072073, 0x07073a12, 0x1209090e, 0x10051134, 0x0d0b180f, 0x0b153e52, 0x01040123, 0x60011902, 0x22075948, 0x82140e0d, 0xfe470863, 0x0102168b,
+    0x03010a07, 0x0e0d4a46, 0x35280f13, 0x131a0504, 0x0366454b, 0x070e1503, 0x0e0108cb, 0x79010e0e, 0x18090416, 0x13130d39, 0x0a031c09, 0x09130d09,
+    0x0d0f331b, 0x2005010e, 0x0c16011f, 0x05010715, 0x43170202, 0x022d05af, 0x00c00140, 0x003d0011, 0x00630055, 0x05996100, 0x0bdf5418, 0x07061325,
+    0x42230706, 0x2b21055d, 0x0f4b1801, 0x16072709, 0x30171617, 0xfc820331, 0x21171623, 0x32208236, 0x23052726, 0x27262737, 0x36132707, 0x3336013f,
+    0x42173332, 0x0721059d, 0x183f8233, 0x2208214b, 0x49500107, 0xd83d0f6b, 0x16020216, 0x01131945, 0x2c0e0909, 0x4729151a, 0x1a200c0b, 0x01010d27,
+    0x35010403, 0x081c832b, 0x1fe0012c, 0x02011414, 0x61fcfe16, 0x0c12162b, 0x0634183e, 0x0b092805, 0x250e0303, 0x19551f05, 0x02172b6e, 0x203e1601,
+    0x211d0e14, 0x54180119, 0xfe3a10e2, 0x161602c0, 0x1509b202, 0x3509090e, 0x03150b28, 0x100a1e14, 0x0105050a, 0x1883f1fe, 0x14012908, 0x02161f14,
+    0x0b0c5b30, 0x01018411, 0x1e040205, 0x0d570507, 0x3214240c, 0x07064c51, 0x4e240f1a, 0xb0011a29, 0x00020000, 0x2c07cf6e, 0x00530037, 0x17321300,
+    0x1f161716, 0x20048201, 0x09747433, 0x15291482, 0x23060714, 0x06070615, 0x06825607, 0x26272624, 0x52183527, 0x9c490840, 0x82212005, 0x8227200f,
+    0x21332336, 0x985f3736, 0x053f2f09, 0x23232803, 0x311e0516, 0x0f183931, 0x535b010f, 0x2a068206, 0x291b1b01, 0x2940c040, 0x42011b1b, 0x1f2905f9,
+    0x19014102, 0x17fe2519, 0x06ee460d, 0x16e90123, 0x05034302, 0x01a00128, 0x23151504, 0x2c823107, 0x180f0f22, 0x09c36918, 0x3e836020, 0x00822020,
+    0x71524d83, 0x98fe2406, 0x83191925, 0x21568268, 0x51461602, 0x00082106, 0x04200082, 0x002aef84, 0x2400a001, 0x72005500, 0x0571a300, 0x08d7620a,
+    0x3043fa84, 0x05eb4605, 0x82272621, 0x066050f8, 0x17321728, 0x37161716, 0x70502726, 0x270f8308, 0x26270607, 0x16072627, 0x30211d82, 0x261f8233,
+    0x07061707, 0x4e352726, 0xd46f057a, 0x37362205, 0x05b86836, 0x37151724, 0x4dad0706, 0x54000121, 0x022f0533, 0x14140c37, 0x01020303, 0x24243206,
+    0x543a3113, 0x24080b49, 0x06280659, 0x0f0b0c06, 0x020d0603, 0x13080a01, 0x02130103, 0x0f0f0b03, 0x0f100303, 0x0e090918, 0x070e0604, 0x32158206,
+    0x01010210, 0x030f100e, 0x0f0f0199, 0x08051301, 0x83130508, 0x0a012a09, 0x2323070b, 0x010a0b07, 0x26488377, 0x030e0b0d, 0x9a010e05, 0x87022048,
+    0xa0013548, 0x2f1c1b01, 0x374c3a2f, 0x021c1b27, 0x01050503, 0x13101111, 0x26081385, 0x1c2f2f3a, 0x1ef0011b, 0x05020102, 0x040e0f06, 0x03010401,
+    0x01040708, 0x180a0a02, 0x03080812, 0x0e060302, 0x8202040e, 0x82062014, 0x2a148219, 0x01010f10, 0x061a300f, 0x83301a06, 0x0a602c09, 0x2f080305,
+    0x0403082f, 0x8610600b, 0x030d2145, 0xbf4845a0, 0x004b270a, 0x006d005b, 0x184b2500, 0x2f342805, 0x022f2601, 0x43222726, 0x162605c6, 0x0607011f,
+    0x03821507, 0x27171622, 0x25062244, 0x16171415, 0x2e840517, 0x12823520, 0x2a822320, 0x2f222322, 0x26060654, 0x1737012f, 0x8206010f, 0x30272923,
+    0x013f3633, 0x17353736, 0x840c2267, 0x0151083d, 0x090a09cd, 0x0d010b0b, 0x3f19156f, 0x0e13091b, 0x1d030909, 0x29101309, 0x154a0122, 0x26080201,
+    0x11050511, 0x0c05050e, 0x6c011c0b, 0x11130f10, 0x0908010e, 0x08050506, 0x5a070708, 0x0116040d, 0x54423413, 0x03011391, 0x040301a9, 0x3c021f55,
+    0x095e4474, 0x0e0e2908, 0x06c6140e, 0x0f110807, 0x0810530b, 0x01113415, 0x070d090a, 0x06123a07, 0x27121506, 0x16081935, 0x080e0611, 0x01010d0c,
+    0x08285282, 0x850c1112, 0x0f070805, 0x023c6c82, 0x07210204, 0x0505650f, 0x1e270f18, 0x035c333e, 0x3d060803, 0x0c1c0101, 0xcd2d1521, 0x21056d52,
+    0x0787010e, 0x00820020, 0x00072b08, 0x01c0ff00, 0x00c001ff, 0x00500047, 0x00620059, 0x007b006b, 0x01000084, 0x010f2627, 0x23272635, 0x30150706,
+    0x07311431, 0x9c572726, 0x07062c05, 0x17140706, 0x30270706, 0x86313035, 0x232b8320, 0x16011f06, 0x14201682, 0x8206ce4f, 0x35362519, 0x25273637,
+    0x37203782, 0x13201883, 0x19830887, 0x088b1184, 0x1d873120, 0x30070624, 0x0c853731, 0x01071430, 0x0e0706ff, 0x100f021c, 0x0831020e, 0xf16d0f0e,
+    0x1a2d0805, 0x080e0f01, 0x100f0131, 0x0e1c010f, 0x0d040607, 0x36070186, 0x1e111202, 0x12111ebe, 0x87073503, 0xe1fe040d, 0x0d02010e, 0x0e01020d,
+    0x20ee8220, 0x2403930e, 0x01060701, 0x23198301, 0x1f010706, 0x0e382d83, 0x28010f01, 0x0c040d0e, 0x01010f1d, 0x15012f0f, 0x1d160f13, 0x011b1b29,
+    0x28277582, 0x1310161d, 0x832f0115, 0x0c1d3b19, 0x0e0e0d04, 0x11133707, 0x21284a2e, 0x21161621, 0x2e4a2821, 0x07371311, 0x7383390e, 0xfe2a0383,
+    0x0e0d02f0, 0x0f0d0203, 0x08904002, 0x0c015724, 0x4883080b, 0x0c0b0823, 0x41318801, 0x0233088b, 0x00c00180, 0x00110008, 0x0023001a, 0x006b0065,
+    0x1900007e, 0x2809f11b, 0x17163736, 0x27260706, 0x07217923, 0x11872320, 0x1d162523, 0xff4b1801, 0x1715210d, 0x2605cd57, 0x26012f22, 0x6723013d,
+    0x212605e3, 0x27262726, 0xbb453734, 0x013b3705, 0x36373635, 0x1f163337, 0x31151601, 0x17152327, 0x21132733, 0x5c180706, 0x26210cc8, 0xbac61a27,
+    0x60c02008, 0x802010fd, 0x3a081187, 0x40010f01, 0x0c09390e, 0x020b0a0d, 0x37380901, 0x0d0a0909, 0x13360a0d, 0x20010b2b, 0x00ff301f, 0x01201f30,
+    0x091d1112, 0x01200e09, 0x7b140e0d, 0x02571229, 0x70406b94, 0x50ff4545, 0xcc5008c2, 0x08e06109, 0x8f072d54, 0x03962b07, 0x16351f04, 0x020a4712,
+    0x74830902, 0x36a84822, 0x09276f83, 0x19143709, 0x831a1633, 0x3777836d, 0x0e1a1b22, 0x09090e6b, 0x0d0e1470, 0xcc250201, 0x60ba0403, 0xe0fea040,
+    0x200f244e, 0x05234700, 0x0180012c, 0x001300a0, 0x13000032, 0x45193734, 0x1520101d, 0x2b2b138c, 0x07141501, 0x27222306, 0x83013d26, 0x00352105,
+    0x0121db82, 0x38481840, 0x200f870d, 0x05df4680, 0x1d828020, 0x8507bc58, 0x06c95828, 0x9c7c0c82, 0x82e02006, 0x0d076729, 0x33002639, 0x00004500,
+    0x35373601, 0x06212726, 0x17161507, 0x07061533, 0x6b161714, 0x21240581, 0x2f363736, 0x36201d82, 0x35261e82, 0x37360533, 0x67181633, 0x17200774,
+    0x21078e69, 0x2d823233, 0xae820620, 0x0fb00127, 0xfe0f0101, 0x3e058360, 0x17011f10, 0x04132716, 0x01110909, 0x09091100, 0x17271404, 0x101f0117,
+    0x0701b0fe, 0x84010730, 0x44802804, 0x02022d2d, 0x87442d2d, 0x90012407, 0x84100f01, 0x010f3a3d, 0x2e1c159f, 0x411a2727, 0x010c0c10, 0x100c0c01,
+    0x27271a41, 0x9f161b2e, 0x203c8318, 0x20048410, 0x0b4051d8, 0x31079b47, 0x010002c0, 0x002000c0, 0x004a003c, 0x25000053, 0xbe831f16, 0x27363729,
+    0x0f262726, 0x85352301, 0x06072109, 0x15320183, 0x17333617, 0x26312726, 0x27352707, 0x17331707, 0x2e821706, 0x5d4f1620, 0x012f2306, 0x07632707,
+    0x22108305, 0x56073726, 0x43080899, 0x13202b4c, 0x0816151f, 0x08020808, 0x4c450608, 0x02020645, 0x2a242108, 0x02071d1d, 0x340d0c53, 0x15171712,
+    0x60407f6c, 0x040b6b3e, 0x0b751203, 0x350b0f0f, 0x9c750b0b, 0x1414953b, 0x151a1b15, 0xa4070d77, 0x31077442, 0x141e01e0, 0x2119190e, 0x02092024,
+    0x4b450602, 0x55840645, 0x201f0b35, 0x530c0c2b, 0x03123704, 0x3e6b0b04, 0x6b7f3f60, 0x82171715, 0x340b224b, 0x234e820c, 0x953b1c73, 0x14254983,
+    0x22207714, 0xfa4d18a5, 0x05bf4a0a, 0x01bf0139, 0x003c00c0, 0x00640052, 0x13000076, 0x06010f22, 0x013f2627, 0x83213736, 0x06072ddf, 0x2b26012f,
+    0x16331501, 0x15171617, 0x2a058566, 0x2f222307, 0x06072301, 0x8326012b, 0x27262129, 0x2205bc43, 0x18172335, 0x28080066, 0x3732013b, 0x34013d36,
+    0x7f3b8327, 0x23200f2c, 0x32118953, 0x0d0c1357, 0x0c101210, 0x012a1b0d, 0x0e1a2a12, 0x8211110c, 0x1324080c, 0x1b292871, 0x2302011b, 0x03030542,
+    0x090d2708, 0x09378037, 0x0208280d, 0x23420503, 0x1b1b0102, 0x49712829, 0x420cbf42, 0x092209c6, 0x0c8c0e09, 0x0f900125, 0x820c1010, 0x01202363,
+    0x06822001, 0x10100c24, 0x4283300f, 0x1c2fa02c, 0x06060642, 0x37370901, 0x08820109, 0x2f1c4223, 0x217583a0, 0x42827030, 0x5d852020, 0x5f5c0683,
+    0x0c1a5c0c, 0x00010022, 0x21074b4f, 0xa95e0030, 0x06cd5806, 0x76363721, 0x162005f5, 0xdd49f282, 0x37262207, 0x20168436, 0x05995016, 0x01173208,
+    0x37360280, 0x36375151, 0x11100102, 0x0e0e0c15, 0x12110101, 0x12121c1b, 0x0d0d0101, 0x10111611, 0x0b270404, 0x01011010, 0x251c1413, 0x81021e1f,
+    0x832a8252, 0x2c250832, 0x0c152223, 0x55110605, 0x0113121b, 0x171b1312, 0x14101211, 0x26251919, 0x05050f3a, 0x191a2112, 0x2b2b1f18, 0x087b7546,
+    0xbf013f2a, 0x2f001600, 0x27370000, 0x3f228282, 0x02853601, 0x07011f25, 0x82010f06, 0x27012102, 0x17200886, 0x8505d542, 0x3762081e, 0x121d2736,
+    0x1205040e, 0x142a4945, 0x195c4e2d, 0x55692213, 0x4b2b1630, 0x16180272, 0x162b4c71, 0x25685530, 0x0807120b, 0x142d4d5d, 0x1245492a, 0x0f0d0305,
+    0x16161115, 0x4b231f09, 0x2b255026, 0x30261309, 0x4d295728, 0x4d013524, 0x4e243418, 0x30285728, 0x2b030d2a, 0x4b265025, 0x16091f23, 0xa9181017,
+    0x46632df3, 0x63162005, 0xac190542, 0x234c0feb, 0xf3a91806, 0x01c02e1c, 0x0f01350f, 0x37010f34, 0x0f01010f, 0x200a8436, 0x210a8236, 0xfa44fe00,
+    0x18012006, 0x2219f4a9, 0x83010faa, 0x84358a2a, 0xe6fe210a, 0x23055e44, 0x01000040, 0x2008f34b, 0x230c821e, 0x06310714, 0x2006a045, 0x09a14521,
+    0x11653620, 0x00022506, 0x071b0f0f, 0xfe353a82, 0x09090ec0, 0x0f0f1b07, 0x79434301, 0x01434379, 0x0d151001, 0x2b8e860e, 0x150d0ee0, 0x032d2d33,
+    0x332d2d03, 0x29061f46, 0xa0010002, 0x15000c00, 0x97550000, 0x32213005, 0x013d3637, 0x07220121, 0x27262105, 0x82002726, 0x83012053, 0x00fe3e53,
+    0x090c2c01, 0x0002e9fe, 0x5a3c3c02, 0x090e9fa0, 0x0d09090a, 0x060001a1, 0x3e3f5bd9, 0x081b4207, 0xc001402e, 0x48002b00, 0x17250000, 0x07060706,
+    0x60184484, 0x24831b8c, 0x68822320, 0x77492320, 0x46232006, 0x1625060e, 0x37363317, 0x82038335, 0x12012aa2, 0xbffe1b12, 0x0112121b, 0x22de8220,
+    0x1800010a, 0x200e9a60, 0x2c8a8201, 0x0f017020, 0x300f0138, 0x0f38010f, 0x210a8a01, 0x3783a0a0, 0x1aa46018, 0x09090d24, 0x358f2801, 0xd7444085,
+    0x82802006, 0x001d2bd3, 0x0041002f, 0x01000050, 0xae822623, 0x5208667f, 0x17830ae1, 0x71602320, 0x07404208, 0x17161525, 0x83171631, 0x07c9432f,
+    0x41821320, 0x2005a448, 0x2b188317, 0x0a365001, 0x20201818, 0x360a1818, 0x20087056, 0x56098720, 0xf682061c, 0x0e090922, 0x0787c987, 0x82c06021,
+    0x171626ea, 0x17224022, 0x2df38216, 0x121c8001, 0x11010111, 0x0d011c12, 0x086e140e, 0x21098305, 0x4d836001, 0x5b0cd560, 0x07870789, 0x0100ff23,
+    0x8244840f, 0x010f214d, 0x25053b48, 0xa1010002, 0xf5822400, 0xc4580020, 0x21c8830a, 0x654e1706, 0x0d6b4e05, 0x2323e382, 0x82070615, 0x833520dc,
+    0x06a56603, 0x27065e43, 0x3a470001, 0x01222239, 0x2305094e, 0x05020204, 0x2011094e, 0x0b434370, 0x200a5943, 0x05934da1, 0x27384b27, 0x05021c1b,
+    0x06a74d04, 0x2e1c1c24, 0xa74d3b2f, 0x43eb2005, 0x0020154b, 0x27090357, 0x001200c1, 0x00310027, 0x20053d61, 0x09a95307, 0x2734353a, 0x27372707,
+    0x020f0607, 0x16011f06, 0x3f36023f, 0x010f2701, 0x37010f06, 0x172a0982, 0xa0f70107, 0x090d0d0a, 0x0683090a, 0x090a2608, 0x3743a909, 0x07136d2e,
+    0x0a0a6c1c, 0x6d0b0c16, 0x6e131b78, 0x0736382d, 0x03124f09, 0x09440906, 0x0a9f1801, 0x22308209, 0x8209a00a, 0x0b0c3d06, 0x2d38434d, 0x781b136e,
+    0x160c0b6d, 0x1c6c0a0a, 0x2e6d1307, 0x03063737, 0x07094f12, 0x003b2e82, 0xff000004, 0x010002e0, 0x0028009f, 0x004c003a, 0x25000055, 0x012f2627,
+    0x82262726, 0x20078284, 0x82958307, 0x1617240a, 0x8236013f, 0x829583a0, 0x27362298, 0x05997226, 0x2407af50, 0x06071415, 0x73811823, 0x17322409,
+    0x82161516, 0x06764c11, 0x07162d08, 0x1e42d801, 0x240b1008, 0x15301c23, 0x13294721, 0x11261413, 0x180e1c0c, 0x20452817, 0x21203719, 0x03050522,
+    0x02233d1b, 0xc7fe2503, 0x82051f54, 0x09082305, 0x0c88800e, 0x09013908, 0x0e100e09, 0x0e0d0201, 0xfc100101, 0x3d1b0b16, 0x19070821, 0x0601152f,
+    0x1f1a1b01, 0x391a1834, 0x07181821, 0x2812060f, 0x230c0c16, 0x1f0f1c3e, 0x0f1f1f14, 0x0d09093c, 0x5f204288, 0x0e220c82, 0x12850908, 0x49847f20,
+    0x020d0e23, 0x2f008200, 0xff000002, 0x018001d0, 0x001600b0, 0x13000028, 0x520b345b, 0x262005d0, 0x0720f182, 0x274c1684, 0x08158205, 0x07161734,
+    0x2b2b36c0, 0x0201191a, 0x51523636, 0x01023736, 0x2b2c1a19, 0x13192035, 0x0f010113, 0x1601010f, 0x0d0a1b15, 0xb001080a, 0x42313102, 0x36523743,
+    0x2a830236, 0x4243372a, 0x7a023131, 0x2a2f2e1f, 0x0f282482, 0x22333431, 0x0c0a090b, 0x22082f42, 0x82c00140, 0x002d2d87, 0x01000040, 0x22232723,
+    0x011d0607, 0x09ca4a18, 0x26273424, 0x16951123, 0x27260126, 0x11070623, 0x35232b84, 0x82333523, 0x20022403, 0x43502070, 0x854505bd, 0x300f8f06,
+    0x0f0120fe, 0x09010f20, 0xc0e00e09, 0xa001c0c0, 0x20098220, 0x203185a0, 0x21068280, 0x108ee0fe, 0x83300121, 0x70fe21b4, 0x403c1b82, 0x005040e0,
+    0xff100006, 0x01f001e0, 0x001200a0, 0x00430027, 0x0077005d, 0x25000091, 0x64052a4d, 0x322209f8, 0x3f6f0717, 0x46232005, 0x34280540, 0x21333637,
+    0x26251732, 0x6b079262, 0x30240852, 0x06070631, 0x25222583, 0xcb821506, 0x33321722, 0x2305e943, 0x35342734, 0x06232d83, 0x98273107, 0x05bc4a19,
+    0x01273393, 0x0e0e0ee2, 0x5580fe14, 0x0120059c, 0x31080782, 0x13130507, 0x1ac0fe1a, 0x04051313, 0x07a00107, 0x0657fe04, 0x02010505, 0x3c3d1202,
+    0x3d3c5454, 0x01020212, 0x07060505, 0x0882fe08, 0x05430107, 0x1c820203, 0x0503032d, 0x01010403, 0x05040402, 0xa6800407, 0x0eb22213, 0x83768514,
+    0x04772305, 0x73821007, 0x25087b82, 0x05040710, 0x0504a805, 0x07070806, 0x012a2a43, 0x432a2a01, 0x06080707, 0x03030306, 0x05070468, 0x01020404,
+    0x70820401, 0x88820320, 0x01030225, 0xaa200501, 0x00002715, 0xff200001, 0x018201c0, 0x0035003c, 0x06152500, 0x23070607, 0x2f262722, 0x013d2601,
+    0x15013f34, 0x37361716, 0xc4473635, 0x097b5406, 0x32373622, 0x086b7c18, 0x242f3d82, 0x26883625, 0x0f162221, 0x011e120a, 0x4d010f0f, 0x220807eb,
+    0x11110b0c, 0x1a0e0c0b, 0x030d0d12, 0x0e140e0b, 0x60a0010d, 0x01242536, 0x131e1111, 0x1730100d, 0x822d180e, 0x600f212c, 0x20074b46, 0x822d82c8,
+    0x15be2633, 0x110b0b01, 0x43458307, 0xe028077b, 0xa0014002, 0x2d001500, 0x2624a582, 0x27263127, 0x07266a18, 0xb2832720, 0x35211527, 0x21232617,
+    0x9c971822, 0x374d080d, 0x27363334, 0x28012002, 0x01343c27, 0x01115c11, 0x28273c34, 0x1f000201, 0xe0fd0a05, 0x0603050a, 0x3e1a1a01, 0x3c676b3d,
+    0x031c1c3d, 0xa7040801, 0x18353444, 0x01117c5a, 0x5a7c1101, 0x44343518, 0x0a714747, 0x0308090a, 0x10101110, 0x2bd78201, 0x01041110, 0x04000908,
+    0xc0ff0000, 0xc0298f82, 0x42002500, 0x69005400, 0x058d6500, 0x82111721, 0x6c15208b, 0x3520067d, 0x8705d571, 0x37362806, 0x07333736, 0x48150706,
+    0x2623113e, 0x82352327, 0x06052503, 0x07063107, 0x27078247, 0x17161716, 0x31373607, 0x0a833582, 0x06071434, 0x2722012b, 0x01313526, 0x0d0e1410,
+    0x12111d01, 0x0883da0a, 0x820f9021, 0x85902098, 0x0d012805, 0x78e0140e, 0x8318010f, 0x01182313, 0x0a8a100f, 0x7a680121, 0x22340b14, 0xe0011617,
+    0x271b1a01, 0x1a1b2766, 0x0f0a0a01, 0x0a0a0fda, 0x27056f59, 0x1d10c0fe, 0x1013241c, 0x50204c83, 0x0121f382, 0x20048340, 0x826b83d0, 0x84558e09,
+    0x47d02060, 0x07870796, 0x5483cd20, 0x54825d83, 0x003b5b82, 0xff000004, 0x010002c1, 0x001100c0, 0x00950088, 0x010000a2, 0x22312326, 0x82060107,
+    0x371626e5, 0x34353601, 0x053a4527, 0x31303123, 0x05844e06, 0x31300724, 0x0b871530, 0x15862220, 0x1f8a1382, 0x27231d84, 0x82363726, 0x31302101,
+    0x09850583, 0x87353021, 0x8b32200b, 0x200b8915, 0x242d8633, 0x05071617, 0x05014f01, 0x1f238982, 0x83012501, 0x3f29088f, 0x26273601, 0xe901012f,
+    0x18202019, 0x0b20a0fe, 0x212c2c0d, 0x17176001, 0x0d0d0f32, 0x0809090b, 0x03030909, 0x05050101, 0x230f820e, 0x1012010a, 0x02200e82, 0x0e200e83,
+    0x0a271e82, 0x0b090808, 0x8209090c, 0x830b201a, 0x202a8c0b, 0x8b1c8209, 0x8301202c, 0x0c0b3610, 0x69fe0808, 0x140b2201, 0xcf121918, 0x13010111,
+    0xfec1010b, 0x380e8bde, 0xfe1717a9, 0x2c2c21a0, 0x01200b0d, 0x20201860, 0x050e5f19, 0x03020105, 0x268c8203, 0x0a010908, 0x830f0d0d, 0x0f012110,
+    0x09210f82, 0x820d870b, 0x0a0a231e, 0x2a940b0b, 0xc6823b82, 0x2c8aaa82, 0x0b090932, 0x2201cc0b, 0x0101130c, 0x1813cf11, 0x840c1418, 0x0d888682,
+    0x02000b22, 0x081b4e18, 0x37000b28, 0x21370000, 0x8d510607, 0x012f2205, 0x05e14d25, 0x14151424, 0xbf411407, 0x45232005, 0x372207d7, 0x40442633,
+    0x14230808, 0x17323307, 0x63000160, 0x09070904, 0x0408070a, 0x09220163, 0x03030707, 0x04010401, 0x09080705, 0x45e0fe0a, 0x01280505, 0x2b290101,
+    0x292b3c3a, 0x09250882, 0x08cea009, 0x25008205, 0x047cce08, 0x3a820706, 0x0a010125, 0x82010109, 0x03042b68, 0x13130f0e, 0x08010d0f, 0x2b833b08,
+    0x3b2b2925, 0x47040808, 0xe02d0627, 0xa0018002, 0x21001000, 0x00003e00, 0x05c65125, 0x2b067f5a, 0x01272635, 0x11331121, 0x27262726, 0x06211882,
+    0x4b0b8207, 0x904308cf, 0x0cac4306, 0x70022208, 0x010fa0fd, 0x1b121201, 0x121b0002, 0x0f010112, 0x800110fe, 0x0e0d0140, 0x1460fe14, 0x40010d0e,
+    0x76d018b0, 0x0f012108, 0x40230a8a, 0x84100f01, 0x203a8230, 0x22418210, 0x1800ff20, 0x27091a41, 0x0001f0fe, 0x300f01f0, 0x3c85318c, 0xc783c382,
+    0x0002002a, 0x14008001, 0x26001d00, 0x2005fd66, 0x4bf58206, 0x01200ed2, 0x2906cd4a, 0x07063715, 0x16333523, 0xf66b1517, 0x0c454705, 0x011d1624,
+    0x755ec001, 0x08ba660a, 0x50e0fe22, 0x0f259682, 0x0f018050, 0x20098250, 0x07a34da0, 0x01240782, 0x09090e40, 0x0ba45d18, 0x0120ff83, 0xfe21ff84,
+    0x22d782d0, 0x8230010f, 0x20bd82d2, 0x067f5010, 0x08068a53, 0x0000402b, 0xff000002, 0x010002c0, 0x001700bf, 0x01000030, 0x26312736, 0x06072627,
+    0x26071617, 0x17070627, 0x36173315, 0x07272637, 0x830c8235, 0x610385d2, 0x240806d7, 0x01232737, 0x020110d1, 0x11130e13, 0x1a11150b, 0x4e27371e,
+    0x0123215b, 0x35912d02, 0x16111113, 0x31202116, 0x82798218, 0x18280882, 0x35646488, 0x3a016617, 0x1c21211d, 0x140e0b11, 0x010c2421, 0x5a232301,
+    0x3f38274e, 0x17659a2a, 0x2627291e, 0x01191925, 0x33832b83, 0x33330327, 0x0000383f, 0x08934405, 0x1c000a2c, 0x40002e00, 0x00005100, 0x9f820313,
+    0x82253721, 0x132721a8, 0x10f94718, 0x12eeb118, 0x03232390, 0x83010f26, 0x054d53c3, 0x27262733, 0x06026364, 0x7c010807, 0x86505105, 0x090a0d1b,
+    0xb9621809, 0x8b302007, 0x4961200c, 0x0585054c, 0x1b712208, 0x568e0f08, 0x19390856, 0x31310c01, 0x015c4c4b, 0x0984fe50, 0x69030706, 0x034f4f85,
+    0x0909d0fe, 0x8328840d, 0x62912005, 0x12850578, 0x4e186020, 0x0d34080a, 0x6f010909, 0x05391901, 0x108d5555, 0x4b5b1b09, 0x0a2f304a, 0x2d096b4c,
+    0x000c00c0, 0x0085002c, 0x27230100, 0x61463726, 0x020f2405, 0x43333033, 0x0b4e05c4, 0x51212005, 0x372a08d6, 0x37363130, 0x27261731, 0x90450706,
+    0x08ca5c05, 0x83161521, 0x21e68210, 0x01822326, 0x17060728, 0x15303316, 0x34481716, 0x41362009, 0x22210608, 0x27208331, 0x22332627, 0x34353431,
+    0x21051252, 0x1c841633, 0x01353408, 0x052f8040, 0xc40a0404, 0x0504040a, 0x0180802f, 0x291f0605, 0x0220202a, 0x291b1b01, 0x1b29c0fe, 0x2002011b,
+    0x1e2a2920, 0x01540607, 0x09021114, 0x19071807, 0x3342c1af, 0x09476001, 0x01010708, 0x47090807, 0x12040420, 0x38372322, 0x087b8a18, 0x3738523c,
+    0x04122223, 0x02126004, 0x02061202, 0x0f1c0a03, 0x0c060d0e, 0x06060104, 0xa0820202, 0x03050328, 0x01010602, 0x1c821104, 0x05040123, 0x2c268306,
+    0x01020105, 0x101d0a01, 0x0c070e0d, 0x21238305, 0xd0820401, 0x2f820120, 0x26830320, 0x00060322, 0x2609cf43, 0x001a0015, 0x18350030, 0x220c0b6e,
+    0x54272621, 0x2124065e, 0x33152307, 0x0bc2e018, 0x05261a8a, 0x21352115, 0x3049d001, 0x057b4407, 0x0e0d0128, 0x10a00114, 0x71698080, 0x08524909,
+    0xfea00129, 0xff0001f0, 0x83800100, 0x87402025, 0x23088438, 0xa0202040, 0x81181594, 0x1a2b0bef, 0x41002700, 0x16010000, 0x1833011f, 0x290ff7d5,
+    0x3637013b, 0x21073337, 0x9f480603, 0x03272206, 0x05237217, 0x17141526, 0x37363316, 0x372dc582, 0x26012f36, 0x31070627, 0x09141c01, 0x06036607,
+    0x08074670, 0x0907602d, 0x01fd7814, 0x0d021581, 0x13f6130e, 0x16020d0e, 0x0e0e50b0, 0x07271011, 0x02170a07, 0x0f101127, 0x0b06500f, 0xc0010709,
+    0x500e1101, 0x0e270b20, 0xfe800111, 0x820d14ae, 0x01142400, 0x83504752, 0x86263129, 0x0207070a, 0x0f268616, 0x5011100f, 0x07010107, 0xa30a6f53,
+    0x521120c7, 0x11200811, 0x0129c7b5, 0xfe1b1212, 0x12121bff, 0x20c6ab01, 0x072046c0, 0x98400121, 0x083365c8, 0xc001c028, 0x32001500, 0x0c193e00,
+    0x3522096f, 0xb67a2f26, 0x07062b05, 0x16171615, 0x3b342717, 0x03823501, 0x011d3223, 0x23038233, 0x15012b14, 0x22230382, 0x8223013d, 0x6d072003,
+    0x26270523, 0x35272627, 0x83270717, 0x6c1420f1, 0x3520069a, 0xe0371483, 0x01242536, 0x0b541401, 0x550b0b0c, 0x24010114, 0x05283625, 0x82100516,
+    0x21068603, 0x4b4aa028, 0x19b72007, 0x240d3798, 0x36202102, 0x29308390, 0x2008166e, 0x08200404, 0x4c836e16, 0x3a89e820, 0x10220982, 0x284a1058,
+    0x99102707, 0x2c116767, 0x274a3b2c, 0x2c3b2605, 0x0100112c, 0x05376100, 0x36009f2c, 0x23050000, 0x35262722, 0x67182311, 0x35230830, 0x83363734,
+    0x250583da, 0x15161732, 0x74183311, 0x23850838, 0x232d0583, 0x0f98dc01, 0x0b600b0a, 0x0d7d0f0a, 0x21008209, 0x0a82610d, 0x7c201287, 0x83053c45,
+    0x82202012, 0x5c012216, 0x692b829c, 0x9c280563, 0x0a0a0b0f, 0xa4fe0f0b, 0x08220883, 0x29820e09, 0x00211c83, 0x32938206, 0x018002c0, 0x001100c0,
+    0x004b0039, 0x006f005d, 0x18000081, 0x53089944, 0x1721083b, 0x06cd7316, 0x06012b26, 0x1707012f, 0x8206cd4e, 0x013d2dc4, 0x26272627, 0x3336013f,
+    0x33011f32, 0x4b05eb4a, 0x27200bea, 0x107a4e18, 0x91110e4c, 0x11bd6223, 0x24078747, 0x3c29090b, 0x062f432b, 0x01193c2b, 0x0e531702, 0x3e0d1010,
+    0xfcd01835, 0x1f802810, 0x01011414, 0x871f1414, 0x00022907, 0x36252401, 0x01242536, 0x22900787, 0x09557218, 0x21074d44, 0x7b46016f, 0x08012605,
+    0x0a1c3120, 0x2a858611, 0x1b12266f, 0x0a40131c, 0x18e1300a, 0x200f45d1, 0x83728b48, 0xa048207a, 0x00003421, 0xff000005, 0x01c001e0, 0x001500a0,
+    0x001f001a, 0x4d290024, 0xca550b79, 0x36112a05, 0x21373637, 0x33152315, 0x21048435, 0x0a823527, 0x82330721, 0x48012005, 0x704309f2, 0x8280200a,
+    0x82c02000, 0x80802103, 0x150ba018, 0x80804022, 0x05851e82, 0x00000023, 0x24838815, 0x00230011, 0x19d01835, 0x008f3c08, 0x00b300a1, 0x00d700c5,
+    0x01fb00e9, 0x011f010d, 0x01430131, 0x01670155, 0x75000079, 0x84750985, 0x0d085307, 0x06071424, 0x4c481123, 0x75172010, 0x359908a7, 0x23901320,
+    0x116f7f18, 0x23900720, 0x6bb40320, 0x2520a191, 0x05205990, 0x23915990, 0x1f41fb91, 0x9147a311, 0x5a479123, 0xd2180cbc, 0x72490c52, 0x4620200b,
+    0x81180b58, 0x198c0c80, 0x8506215b, 0x8c598c39, 0x8c338c19, 0x20738b4d, 0x0c645bfe, 0x81180120, 0x1b8d0ce9, 0x8018428c, 0x71190cca, 0x01200d6c,
+    0x1b8d518c, 0x0020368c, 0x0120fb98, 0x990cfa77, 0x47eb1878, 0x8c5c8c0d, 0x60012134, 0x8c185941, 0x41778d34, 0x278c0c4d, 0xab8c198c, 0x8141198c,
+    0x815c180c, 0x8c198c0c, 0x00002333, 0xdb430800, 0x001b3708, 0x003f002d, 0x00630051, 0x00870075, 0x13000099, 0x36313736, 0xff482137, 0x07062208,
+    0x06896011, 0x4c113521, 0x3320112a, 0x18100543, 0x90126f5b, 0xb2861923, 0x11014411, 0x35902720, 0x16010025, 0x55012217, 0xfe2306c0, 0x41010fb0,
+    0x105e0571, 0x41c0200c, 0xb8420bf0, 0x0cad410c, 0x41181642, 0x01240c28, 0x16172250, 0x01236586, 0x85b0fe0f, 0x50012235, 0x53df18fe, 0x0bf7410c,
+    0x81413e8c, 0x51d4180c, 0x0c9e430c, 0x200ccb42, 0x05fb4500, 0x28057353, 0x002c0011, 0x00590054, 0x13816a5d, 0x2f260323, 0x05045401, 0x3f363724,
+    0xc96c1701, 0x1727250a, 0x21010f06, 0x2605ec51, 0x2726012f, 0x4c223126, 0x2b380593, 0x010f2201, 0x15063106, 0x17161706, 0x2f230705, 0x07333701,
+    0x27173717, 0x4609a64f, 0x3e2e07e6, 0x3a472927, 0x0d060603, 0x040b0b0e, 0xe3853d24, 0x16650e3c, 0x40011908, 0x12110a66, 0x1841200b, 0x0101380e,
+    0x02010201, 0x4a191702, 0x0c820a0e, 0x03040730, 0x0a51010b, 0x1d18cd28, 0x225e2722, 0xb547300e, 0xfbfe2911, 0xc927161a, 0x040c0b0d, 0x80395c83,
+    0x090d4f28, 0x0d090a0a, 0x3b0a1160, 0xce4a1501, 0x11010111, 0x3e792436, 0x2359821d, 0x400b0a01, 0x0a2e0682, 0xb8070c0c, 0x200dd411, 0x4329342d,
+    0x6f4f001a, 0x00c12c09, 0x00360024, 0x07220100, 0x49232637, 0x272205db, 0xb9751506, 0x57072005, 0x17230724, 0x18263536, 0x3114cc96, 0x232b6101,
+    0x3d12010d, 0x0d022728, 0x2d08127a, 0x0f853e2c, 0x0128272a, 0x09127b0d, 0x623e2c2c, 0x24082b59, 0x010e0908, 0x20158241, 0x8f15820a, 0x23458825,
+    0x0e0909a0, 0x2008e94e, 0x20008200, 0x08774f05, 0x42002528, 0x6b005400, 0xad828300, 0x011d1622, 0x27064a52, 0x36373627, 0x15073537, 0x36260e8c,
+    0x1736013f, 0x19820131, 0x1f163324, 0xcd823301, 0x55011d21, 0x91610711, 0x1e711806, 0x08127b08, 0x27830520, 0xe1610f20, 0x22232305, 0x43832627,
+    0x010f1625, 0x60262725, 0x1f200594, 0x36214f83, 0x834c8217, 0x01313224, 0x12010cf4, 0x131a1c12, 0x12010112, 0x01601a13, 0x360c8911, 0x0ea01902,
+    0x0c57fe0c, 0x113e1109, 0x151a0b0a, 0x0d0e0e0d, 0x7a14c015, 0x1c29063f, 0x0e0d1444, 0x0d0e0101, 0x33188514, 0x0b382901, 0x80080503, 0x040a0a0a,
+    0x040b3827, 0x09800803, 0xfe3c0a83, 0x011561bd, 0x1a151801, 0x0a0a131b, 0x161a1b13, 0x15010117, 0x010b0c60, 0x900e0ab9, 0x48833a85, 0x75133822,
+    0x60280c89, 0x03200618, 0x11d8fe09, 0x11206083, 0x70206383, 0x70201c85, 0x74892a84, 0x082f0e83, 0x070b0a01, 0x08060770, 0x0a095b0b, 0x82067009,
+    0x94592908, 0x1e1d1764, 0x03021116, 0x032b7383, 0x1e161102, 0x0a64171d, 0x5101000a, 0x1c25089f, 0x013f0000, 0x050e6436, 0x84262721, 0x0501500a,
+    0x26070636, 0x3726012f, 0x0f166c13, 0x2929342c, 0x08113519, 0x65180c2e, 0x2608b582, 0x67673d3e, 0x17071780, 0x2e611604, 0x19351108, 0x2c342929,
+    0x166c160f, 0x18071704, 0x3e67677f, 0x1701013d, 0x570c1865, 0x012708bb, 0x00a001c0, 0x712f0014, 0x7b530d6f, 0x37172108, 0x7c937e84, 0x18055a71,
+    0x08083870, 0x1bc0fe22, 0x6a011212, 0x16080a36, 0x081b1b35, 0x0d051803, 0x01010b32, 0x34331f1e, 0x0c030c40, 0x60010c02, 0x880a0672, 0x18d02c36,
+    0x1b1b0904, 0x0a081635, 0x82020b37, 0x34402a27, 0x011e1f33, 0x0d320b01, 0x08a38305, 0x00000822, 0x7f02c0ff, 0x1800c001, 0x32002500, 0x4c003f00,
+    0x73006100, 0x00008900, 0x23070625, 0x23112726, 0x230d7553, 0x07152335, 0x35261884, 0x16333736, 0xd7181517, 0x0c90083d, 0x670c1a66, 0xbc5305e6,
+    0x11352608, 0x27262734, 0x0b8f5f05, 0x37362728, 0x06053336, 0xaf422123, 0x32332305, 0x1082011f, 0x16280582, 0x01600107, 0x010fa00f, 0x08415518,
+    0x14a0012c, 0xa0010d0e, 0x1e0801f8, 0x04990108, 0x1a893020, 0xa0feb733, 0x010e0d14, 0x140e0d01, 0x0e146001, 0x150e0d0e, 0x061c47fe, 0x166e0d20,
+    0x050f3d07, 0x09dffe09, 0x46050404, 0x05080705, 0x09053f16, 0x056a0509, 0x010f1004, 0x30010f01, 0xfe213a83, 0x070d45e0, 0x07305022, 0x68207989,
+    0xb2200a94, 0x01211589, 0x683d8399, 0x8c460f78, 0x08d82e0c, 0x60080809, 0x5e1e0707, 0x08a00707, 0x77441809, 0x00162a0a, 0x0041003a, 0x37232500,
+    0x8c5c1827, 0x06fc7e0a, 0x25052324, 0xe9453337, 0x05095a0b, 0x27011d29, 0x17060726, 0x82331601, 0x01273027, 0x013d3627, 0x60010733, 0x2037132d,
+    0x82090e2f, 0xa00d2300, 0x06820a0e, 0x17010e26, 0x702eebfe, 0x2108b046, 0x1d82a0fe, 0x0f137936, 0x4f02100c, 0x080b0807, 0xb5fe100d, 0x216d0652,
+    0x6b2b4020, 0x22822488, 0x9cd93522, 0x4606d846, 0x380806b8, 0x100c5f24, 0x31fe0f13, 0x10110905, 0x08400301, 0x0072200a, 0x07000400, 0xef01e0ff,
+    0x2300a001, 0x5a004000, 0x00005e00, 0x31331617, 0x36013f32, 0x26273427, 0x010f0623, 0xdb661811, 0x280f8208, 0x07060722, 0x13011f06, 0x24ba8233,
+    0x36331716, 0x261c8237, 0x3637012b, 0x79272627, 0x132008cb, 0x0f202783, 0x23063c59, 0x33013f36, 0x2f09f575, 0x68231737, 0x0a0e0e0a, 0x0a010957,
+    0x090d0c0b, 0x33066d47, 0x0c0e0a20, 0x0101090a, 0x33d85809, 0x09070e4a, 0x021f7f15, 0x0b84cb82, 0x827f1621, 0x260c82cc, 0x130a50ad, 0x1a500a13,
+    0x2716abb9, 0x600a0a16, 0x090d0d0a, 0x23225782, 0x31852e01, 0x23d2fe32, 0x0d09090b, 0x01600a0d, 0x13104976, 0x1d030113, 0x09841882, 0x2d052841,
+    0x10a0affe, 0x0c0da010, 0x0406060c, 0x96820c04, 0x0705062a, 0x0d0c0c06, 0x0020202a, 0x04220082, 0x1b410800, 0x26132c0f, 0x0f223123, 0x16150601,
+    0x82331617, 0x181120da, 0x82084363, 0x7632200f, 0x172005d9, 0x20391b41, 0x061b4198, 0x0c0b0924, 0x1b410a0d, 0x41a82010, 0x0121361b, 0x0a1c4196,
+    0x0ed2fe29, 0x0a090909, 0x412d010e, 0x3620071c, 0x35331b41, 0xff070005, 0x014002e0, 0x001200a0, 0x00380025, 0x006e004b, 0xdc462500, 0x012b2207,
+    0x05c55e22, 0x91153321, 0x91112012, 0x42132012, 0xae18073b, 0x23220864, 0x77420725, 0x33162113, 0x22099942, 0x4c400107, 0x5f200695, 0x0821d283,
+    0x062c4a0e, 0x0d859f20, 0x080e2022, 0x0d20e882, 0x21060343, 0x1342dfe0, 0x21068605, 0x5d41a0fe, 0x42092010, 0x09230696, 0x4b0a0c0d, 0xc74b0cd4,
+    0x0001210c, 0x200b6343, 0x0c204afe, 0x79425520, 0x09794112, 0x05000024, 0x33410800, 0x006f230e, 0xfa912500, 0x20410320, 0x12464111, 0x03201292,
+    0x220b9d42, 0x42013f32, 0x17290b9d, 0x37363732, 0x02012f34, 0x0d094120, 0x2741e020, 0x1b51410d, 0x9d42a820, 0x0c0a2207, 0x099d420e, 0x0b0c0d26,
+    0x58080109, 0x200c374b, 0x0c374501, 0x8c0c4041, 0x3601210c, 0x21071f41, 0x9842230b, 0x0e092605, 0x0a232e01, 0x05b64301, 0x00000037, 0xff070004,
+    0x01e001e0, 0x002200a0, 0x0047003e, 0x37000066, 0x0d934422, 0x93442720, 0x0a1b4206, 0x7d423720, 0x22f38306, 0x71363736, 0x072507e1, 0x17161714,
+    0x052d6f37, 0x13373623, 0x05246435, 0x17060725, 0x5f153316, 0x1620051a, 0x21088042, 0xe38fd827, 0x58090122, 0x3b072342, 0x088e0c08, 0x0b080908,
+    0x0d10080c, 0x010e0e22, 0x25191901, 0x01191925, 0x22180f0f, 0x2b07216c, 0x100e0118, 0x030c2010, 0x13090604, 0x45057b42, 0x80210687, 0x0b27420b,
+    0x0841eb87, 0x08772d07, 0x090b0b09, 0x0c110807, 0x19141323, 0x5c835483, 0x16151c24, 0x2f6c690a, 0xc0fe2d07, 0x090a1160, 0x0c061108, 0x2f110d0c,
+    0x09616718, 0x09090d24, 0xb7440001, 0x01e03108, 0x002300a0, 0x0048003f, 0x13000067, 0x34313736, 0x44078455, 0x172016bc, 0x24423441, 0x080109ee,
+    0x0ec44458, 0x090d0d29, 0x0e0a210a, 0x41780a0c, 0x10423933, 0x10c74406, 0x010e0927, 0x090b232e, 0x40344112, 0x33610620, 0x00192d08, 0x00370033,
+    0x0057004f, 0x2500005f, 0x46055143, 0x9d7a05f8, 0x013f2a06, 0x27343536, 0x27262725, 0x0ee44606, 0x00463220, 0x17372505, 0x36331723, 0x1e730b82,
+    0x08006507, 0x33373329, 0x07061716, 0x86153523, 0x37022707, 0x0a0d0d0a, 0x058349a9, 0x60090922, 0x2f080683, 0xfe0909c0, 0x150950a7, 0x04500915,
+    0x0c0d0504, 0x05060c0c, 0x140a055a, 0x050d0606, 0x13810404, 0x50c32613, 0x01161722, 0x010a1901, 0x41211716, 0x27055b42, 0x010f2020, 0x30200f01,
+    0x30250583, 0xaa0909b7, 0x056d714a, 0x09096023, 0x265583c0, 0x0113c035, 0x83c01301, 0x2355854d, 0x06020113, 0x34230d82, 0x83602d2d, 0x17242346,
+    0x55831412, 0x0d09092d, 0x090a0ec0, 0x0f0f01c0, 0x84602001, 0x03002905, 0x41000000, 0x60018002, 0x2b065154, 0x07220100, 0x06070631, 0x23171617,
+    0x0f6ab018, 0xf7852120, 0x05272627, 0x36313736, 0xb2431837, 0x27262107, 0x41181182, 0x260810ad, 0x2228ef01, 0x02131322, 0x1b6f1602, 0x23210403,
+    0x2c2d302f, 0x0d0b1314, 0x01332626, 0x28293d60, 0x29280202, 0x6251fe3e, 0x01290f19, 0x171622af, 0x16170101, 0x08b18322, 0x16160120, 0x14600123,
+    0x27242315, 0x312a2227, 0x08252630, 0x2c191708, 0x1d31312c, 0x2801011d, 0x48833d29, 0x03629020, 0x16162208, 0x21318201, 0x54825022, 0x07365c18,
+    0x82222221, 0x21e38214, 0x00820002, 0x017f022a, 0x001a00a0, 0x25000043, 0x3122af84, 0xeb4d2726, 0x07035e07, 0x013f3625, 0x61300726, 0xd98306e8,
+    0x30272628, 0x06072631, 0x466e1417, 0x06de6106, 0x36275e08, 0x04e90127, 0x14140c0c, 0x1010151d, 0x10101313, 0x14141d15, 0x39050c0c, 0x90397170,
+    0x22010a0a, 0x5f414121, 0x2141415f, 0x0a0a0122, 0x10100309, 0x3d3d2525, 0x3e3d5a5a, 0x11102524, 0xb70a0601, 0x2d363620, 0x0d01032d, 0x010d0c0c,
+    0x362d2d03, 0x02152036, 0x06251502, 0x15160307, 0x820a8316, 0x07032e06, 0x030b0706, 0x27271e1e, 0x02021d1e, 0x2307831d, 0x070c021e, 0xff23cf85,
+    0x828002ff, 0x001022cf, 0x20cf8331, 0x29c18423, 0x21331617, 0x2f262722, 0x6d503701, 0x22148205, 0x4b32010f, 0x1c8206c7, 0x3420bd83, 0x5d081a83,
+    0x2c050127, 0x2b2c3b35, 0x0e0e0511, 0x4b220216, 0x62383333, 0x16051ceb, 0x15bf1b16, 0x07020e0d, 0x08090102, 0x33623640, 0x14462e2d, 0x0c010d0e,
+    0x3820200c, 0x2a0123bc, 0x151a472a, 0x321b1b15, 0x1a9d1255, 0x29050f10, 0x150f0f05, 0x2b010141, 0x191a2e54, 0x140e0d01, 0x191c1d0e, 0xef5d051a,
+    0x80013006, 0x0d00c001, 0x1f001600, 0x16370000, 0x43163117, 0x3523053a, 0x84131521, 0x331524ae, 0x82233335, 0x82262004, 0x02002d91, 0x40442d2d,
+    0x022d2d44, 0x10b080fe, 0xb0230783, 0x83b01030, 0x83602014, 0x2308830c, 0x60018080, 0x20230783, 0x8320c0c0, 0x82002013, 0x396a8200, 0xff01c2ff,
+    0x1b00bf01, 0x35002800, 0x54004200, 0x23010000, 0x26273625, 0xfd820507, 0x15310723, 0x20f78216, 0x21f88221, 0x1482013d, 0x3605272e, 0x1d16013b,
+    0x012b0601, 0x17013d26, 0x12850685, 0x0c8b3720, 0xd0421720, 0xbf200811, 0x131401e4, 0xfe170703, 0x0e0e1653, 0x12120102, 0x1b7f011a, 0x12011212,
+    0x91fe1c11, 0x076f0601, 0x80200383, 0x10230887, 0x82910601, 0x078f2211, 0x08d04291, 0x01161633, 0x23161501, 0x08514001, 0x7e041416, 0x17121107,
+    0x224083ff, 0x841b1211, 0x82782007, 0x830f202f, 0x878f2003, 0x82402008, 0x83102008, 0x42482003, 0x003112d2, 0xff000004, 0x010002c0, 0x001100c0,
+    0x003e0023, 0x0e957f50, 0x27263724, 0x68182726, 0x11231146, 0x59310706, 0x162108f2, 0x74451817, 0x3268181d, 0x0baa7a1d, 0x50590b8b, 0x2001250f,
+    0x291b1b01, 0x84065c77, 0x0d2a4807, 0x4f182020, 0xfe2117cf, 0x0f115a80, 0x20088b5c, 0x26f78280, 0x00400033, 0x825a004d, 0x6f2320f7, 0x078a0721,
+    0x15070622, 0x24069d45, 0x1615011f, 0x077d4217, 0x3d363727, 0x26273401, 0x26464f23, 0x6a600121, 0x05850582, 0x16023034, 0x0e200216, 0x17090909,
+    0x140e0d01, 0x0d0e14e0, 0x0d821701, 0x01400e26, 0x0107b007, 0x60210499, 0x28561810, 0x15492c0a, 0x49150202, 0xb30e0909, 0x4f17090d, 0x70240856,
+    0xb30d0917, 0xd8205a82, 0x10204783, 0x40200484, 0x03410a94, 0x80022b07, 0x2300a001, 0x4d003700, 0x27565f00, 0x20e88308, 0x092d5f15, 0x28075b6f,
+    0x26272623, 0x33053527, 0x22088235, 0x18333736, 0x200a1a9a, 0x144e7427, 0x7f057556, 0x00200b61, 0x2205ed55, 0x412d2d44, 0x09220500, 0x6818fe0e,
+    0x565d088f, 0x80402105, 0x08a59218, 0xe2764020, 0x060e5609, 0x4f608021, 0xc76f07bc, 0x22502808, 0x02011617, 0x55442d2d, 0x7f180671, 0x16290860,
+    0xf0e02217, 0x0f0f0160, 0x06574901, 0x7ee0c021, 0x12830961, 0x0aaae718, 0x140e0d22, 0x00205083, 0x16240083, 0x01000e01, 0x03820883, 0x03821a20,
+    0x01240b85, 0x8e001900, 0x02241786, 0xdd000500, 0x03240b86, 0xbe001f00, 0x04200b86, 0x0524238a, 0x1a003200, 0x06241786, 0x4c001600, 0x0a240b86,
+    0x62002c00, 0x0b240b86, 0xa7001700, 0x10240b86, 0xe2001300, 0x11200b86, 0x03245f84, 0x09040100, 0x34237f82, 0x8500f500, 0x0001240b, 0x86110232,
+    0x0002240b, 0x86af020a, 0x0003240b, 0x8671023e, 0x8a04200b, 0x00052423, 0x86290164, 0x00062417, 0x868d012c, 0x000a240b, 0x86b90158, 0x000b240b,
+    0x8643022e, 0x0010230b, 0x17870226, 0x5f831120, 0x6f432f08, 0x69727970, 0x20746867, 0x20296328, 0x746e6f46, 0x65774120, 0x656d6f73, 0x73726556,
+    0x206e6f69, 0x2e393637, 0x37313130, 0x35373831, 0x218b2820, 0x85762021, 0x203a2722, 0x2e312e36, 0x1b832931, 0x23083c86, 0x65724636, 0x6f532d65,
+    0x5464696c, 0x77206568, 0x73276265, 0x736f6d20, 0x6f702074, 0x616c7570, 0x63692072, 0x732f5b82, 0x61207465, 0x7420646e, 0x6b6c6f6f, 0x8c2e7469,
+    0x2036215d, 0x20204483, 0x68284484, 0x73707474, 0x662f2f3a, 0x6120a082, 0x2e239f85, 0x986d6f63, 0x842d202f, 0x923a8491, 0x43003923, 0x70006f00,
+    0x72007900, 0x67006900, 0x74006800, 0x28002000, 0x29006300, 0x46200782, 0x6e201b82, 0x41261184, 0x65007700, 0x0f827300, 0x07826d20, 0x03825620,
+    0x0d827220, 0x1f846920, 0x3700202c, 0x39003600, 0x30002e00, 0x01823100, 0x03823720, 0x13823820, 0x41823520, 0x97002821, 0x00202243, 0x20458c76,
+    0x202d823a, 0x20438236, 0x20038431, 0x8d378829, 0x82362079, 0x82722017, 0x00652437, 0x8253002d, 0x826c207d, 0x006422b5, 0x20b78254, 0x833f8265,
+    0x006222a3, 0x22998227, 0x826d0020, 0x8473201d, 0x827020bb, 0x00702609, 0x006c0075, 0x20e58261, 0x20318220, 0x20b78663, 0x20498273, 0x24378274,
+    0x006e0061, 0x20078264, 0x20178274, 0x2227826f, 0x8269006b, 0x9a2e2039, 0x823620bb, 0x8246202d, 0x8265204d, 0x8a202041, 0x82682089, 0x00742237,
+    0x22818270, 0x822f003a, 0x84662001, 0x82742069, 0x0b3f4179, 0x63002e22, 0x6d201782, 0x2d215fb2, 0x09234100, 0x6341ff89, 0x24a78b19, 0x02000000,
+    0x23008400, 0x1900dbff, 0x048e0884, 0x05f50a07, 0x0100006a, 0x01030102, 0x00080004, 0x010e000d, 0x01060105, 0x01080107, 0x010a0109, 0x010c010b,
+    0x010e010d, 0x0110010f, 0x00220011, 0x01120123, 0x01140113, 0x01160115, 0x01180117, 0x011a0119, 0x011c011b, 0x011e011d, 0x0120011f, 0x01220121,
+    0x01240123, 0x01260125, 0x01280127, 0x012a0129, 0x012c012b, 0x012e012d, 0x0130012f, 0x01320131, 0x01340133, 0x01360135, 0x01380137, 0x013a0139,
+    0x013c013b, 0x013e013d, 0x0140013f, 0x01420141, 0x01440143, 0x01460145, 0x01480147, 0x014a0149, 0x014c014b, 0x014e014d, 0x0150014f, 0x01520151,
+    0x01540153, 0x01560155, 0x01580157, 0x015a0159, 0x015c015b, 0x015e015d, 0x0160015f, 0x01620161, 0x01640163, 0x01660165, 0x01680167, 0x016a0169,
+    0x016c016b, 0x016e016d, 0x0170016f, 0x01720171, 0x01740173, 0x01760175, 0x01780177, 0x017a0179, 0x017c017b, 0x017e017d, 0x0180017f, 0x01820181,
+    0x01840183, 0x01860185, 0x01880187, 0x018a0189, 0x018c018b, 0x018e018d, 0x0190018f, 0x01920191, 0x01940193, 0x01960195, 0x01980197, 0x019a0199,
+    0x019c019b, 0x019e019d, 0x01a0019f, 0x01a201a1, 0x01a401a3, 0x01a601a5, 0x01a801a7, 0x01aa01a9, 0x01ac01ab, 0x01ae01ad, 0x01b001af, 0x01b201b1,
+    0x01b401b3, 0x01b601b5, 0x01b801b7, 0x01ba01b9, 0x01bc01bb, 0x01be01bd, 0x01c001bf, 0x01c201c1, 0x01c401c3, 0x01c601c5, 0x01c801c7, 0x01ca01c9,
+    0x01cc01cb, 0x01ce01cd, 0x01d001cf, 0x01d201d1, 0x01d401d3, 0x01d601d5, 0x01d801d7, 0x01da01d9, 0x01dc01db, 0x01de01dd, 0x01e001df, 0x01e201e1,
+    0x01e401e3, 0x01e601e5, 0x01e801e7, 0x01ea01e9, 0x01ec01eb, 0x01ee01ed, 0x01f001ef, 0x01f201f1, 0x01f401f3, 0x01f601f5, 0x01f801f7, 0x01fa01f9,
+    0x01fc01fb, 0x01fe01fd, 0x020002ff, 0x02020201, 0x02040203, 0x02060205, 0x02080207, 0x020a0209, 0x020c020b, 0x020e020d, 0x0210020f, 0x02120211,
+    0x02140213, 0x02160215, 0x02180217, 0x021a0219, 0x021c021b, 0x021e021d, 0x0220021f, 0x02220221, 0x02240223, 0x02260225, 0x02280227, 0x022a0229,
+    0x022c022b, 0x022e022d, 0x0230022f, 0x02320231, 0x02340233, 0x02360235, 0x02380237, 0x023a0239, 0x023c023b, 0x023e023d, 0x0240023f, 0x02420241,
+    0x02440243, 0x02460245, 0x02480247, 0x024a0249, 0x024c024b, 0x024e024d, 0x0250024f, 0x02520251, 0x02540253, 0x02560255, 0x02580257, 0x025a0259,
+    0x025c025b, 0x025e025d, 0x0260025f, 0x02620261, 0x02640263, 0x02660265, 0x02680267, 0x026a0269, 0x026c026b, 0x026e026d, 0x0270026f, 0x02720271,
+    0x02740273, 0x02760275, 0x02780277, 0x027a0279, 0x027c027b, 0x027e027d, 0x0280027f, 0x02820281, 0x02840283, 0x02860285, 0x02880287, 0x028a0289,
+    0x028c028b, 0x028e028d, 0x0290028f, 0x02920291, 0x02940293, 0x02960295, 0x02980297, 0x029a0299, 0x029c029b, 0x029e029d, 0x02a0029f, 0x02a202a1,
+    0x02a402a3, 0x02a602a5, 0x02a802a7, 0x02aa02a9, 0x02ac02ab, 0x02ae02ad, 0x02b002af, 0x02b202b1, 0x02b402b3, 0x02b602b5, 0x02b802b7, 0x02ba02b9,
+    0x02bc02bb, 0x02be02bd, 0x02c002bf, 0x02c202c1, 0x02c402c3, 0x02c602c5, 0x02c802c7, 0x02ca02c9, 0x02cc02cb, 0x02ce02cd, 0x02d002cf, 0x02d202d1,
+    0x02d402d3, 0x02d602d5, 0x02d802d7, 0x02da02d9, 0x02dc02db, 0x02de02dd, 0x02e002df, 0x02e202e1, 0x02e402e3, 0x02e602e5, 0x02e802e7, 0x02ea02e9,
+    0x02ec02eb, 0x02ee02ed, 0x02f002ef, 0x02f202f1, 0x02f402f3, 0x02f602f5, 0x02f802f7, 0x02fa02f9, 0x02fc02fb, 0x02fe02fd, 0x030003ff, 0x03020301,
+    0x03040303, 0x03060305, 0x03080307, 0x030a0309, 0x030c030b, 0x030e030d, 0x0310030f, 0x03120311, 0x03140313, 0x03160315, 0x03180317, 0x031a0319,
+    0x031c031b, 0x031e031d, 0x0320031f, 0x03220321, 0x03240323, 0x03260325, 0x03280327, 0x032a0329, 0x032c032b, 0x032e032d, 0x0330032f, 0x03320331,
+    0x03340333, 0x03360335, 0x03380337, 0x033a0339, 0x033c033b, 0x033e033d, 0x0340033f, 0x03420341, 0x03440343, 0x03460345, 0x03480347, 0x034a0349,
+    0x034c034b, 0x034e034d, 0x0350034f, 0x03520351, 0x03540353, 0x03560355, 0x03580357, 0x035a0359, 0x035c035b, 0x035e035d, 0x0360035f, 0x03620361,
+    0x03640363, 0x03660365, 0x03680367, 0x036a0369, 0x036c036b, 0x036e036d, 0x0370036f, 0x03720371, 0x03740373, 0x03760375, 0x03780377, 0x037a0379,
+    0x037c037b, 0x037e037d, 0x0380037f, 0x03820381, 0x03840383, 0x03860385, 0x03880387, 0x038a0389, 0x038c038b, 0x038e038d, 0x0390038f, 0x03920391,
+    0x03940393, 0x03960395, 0x03980397, 0x039a0399, 0x039c039b, 0x039e039d, 0x03a0039f, 0x03a203a1, 0x03a403a3, 0x03a603a5, 0x03a803a7, 0x03aa03a9,
+    0x03ac03ab, 0x03ae03ad, 0x03b003af, 0x03b203b1, 0x03b403b3, 0x03b603b5, 0x03b803b7, 0x03ba03b9, 0x03bc03bb, 0x03be03bd, 0x03c003bf, 0x03c203c1,
+    0x03c403c3, 0x03c603c5, 0x03c803c7, 0x03ca03c9, 0x03cc03cb, 0x03ce03cd, 0x03d003cf, 0x03d203d1, 0x03d403d3, 0x03d603d5, 0x03d803d7, 0x03da03d9,
+    0x03dc03db, 0x03de03dd, 0x03e003df, 0x03e203e1, 0x03e403e3, 0x03e603e5, 0x03e803e7, 0x03ea03e9, 0x03ec03eb, 0x03ee03ed, 0x03f003ef, 0x03f203f1,
+    0x03f403f3, 0x03f603f5, 0x03f803f7, 0x03fa03f9, 0x03fc03fb, 0x03fe03fd, 0x040004ff, 0x04020401, 0x04040403, 0x04060405, 0x04080407, 0x040a0409,
+    0x040c040b, 0x040e040d, 0x0410040f, 0x04120411, 0x04140413, 0x04160415, 0x04180417, 0x041a0419, 0x041c041b, 0x041e041d, 0x0420041f, 0x04220421,
+    0x04240423, 0x04260425, 0x04280427, 0x042a0429, 0x042c042b, 0x042e042d, 0x0430042f, 0x04320431, 0x04340433, 0x04360435, 0x04380437, 0x043a0439,
+    0x043c043b, 0x043e043d, 0x0440043f, 0x04420441, 0x04440443, 0x04460445, 0x04480447, 0x044a0449, 0x044c044b, 0x044e044d, 0x0450044f, 0x04520451,
+    0x04540453, 0x04560455, 0x04580457, 0x045a0459, 0x045c045b, 0x045e045d, 0x0460045f, 0x04620461, 0x04640463, 0x04660465, 0x04680467, 0x046a0469,
+    0x046c046b, 0x046e046d, 0x0470046f, 0x04720471, 0x04740473, 0x04760475, 0x04780477, 0x047a0479, 0x047c047b, 0x047e047d, 0x0480047f, 0x04820481,
+    0x04840483, 0x04860485, 0x04880487, 0x048a0489, 0x048c048b, 0x048e048d, 0x0490048f, 0x04920491, 0x04940493, 0x04960495, 0x04980497, 0x049a0499,
+    0x049c049b, 0x049e049d, 0x04a0049f, 0x04a204a1, 0x04a404a3, 0x04a604a5, 0x04a804a7, 0x04aa04a9, 0x04ac04ab, 0x04ae04ad, 0x04b004af, 0x04b204b1,
+    0x04b404b3, 0x04b604b5, 0x04b804b7, 0x04ba04b9, 0x04bc04bb, 0x04be04bd, 0x04c004bf, 0x04c204c1, 0x04c404c3, 0x04c604c5, 0x04c804c7, 0x04ca04c9,
+    0x04cc04cb, 0x04ce04cd, 0x04d004cf, 0x04d204d1, 0x04d404d3, 0x04d604d5, 0x04d804d7, 0x04da04d9, 0x04dc04db, 0x04de04dd, 0x04e004df, 0x04e204e1,
+    0x04e404e3, 0x04e604e5, 0x04e804e7, 0x04ea04e9, 0x04ec04eb, 0x04ee04ed, 0x04f004ef, 0x04f204f1, 0x04f404f3, 0x04f604f5, 0x04f804f7, 0x04fa04f9,
+    0x04fc04fb, 0x04fe04fd, 0x050005ff, 0x05020501, 0x05040503, 0x05060505, 0x05080507, 0x050a0509, 0x050c050b, 0x050e050d, 0x0510050f, 0x05120511,
+    0x05140513, 0x05160515, 0x05180517, 0x051a0519, 0x051c051b, 0x051e051d, 0x0520051f, 0x05220521, 0x05240523, 0x05260525, 0x05280527, 0x052a0529,
+    0x052c052b, 0x052e052d, 0x0530052f, 0x05320531, 0x05340533, 0x05360535, 0x05380537, 0x053a0539, 0x053c053b, 0x053e053d, 0x0540053f, 0x05420541,
+    0x05440543, 0x05460545, 0x05480547, 0x054a0549, 0x054c054b, 0x054e054d, 0x0550054f, 0x05520551, 0x05540553, 0x05560555, 0x05580557, 0x055a0559,
+    0x055c055b, 0x055e055d, 0x0560055f, 0x05620561, 0x05640563, 0x05660565, 0x05680567, 0x056a0569, 0x056c056b, 0x056e056d, 0x0570056f, 0x05720571,
+    0x05740573, 0x05760575, 0x05780577, 0x057a0579, 0x057c057b, 0x057e057d, 0x0580057f, 0x05820581, 0x05840583, 0x05860585, 0x05880587, 0x058a0589,
+    0x058c058b, 0x058e058d, 0x0590058f, 0x05920591, 0x05940593, 0x05960595, 0x05980597, 0x059a0599, 0x059c059b, 0x059e059d, 0x05a0059f, 0x05a205a1,
+    0x05a405a3, 0x05a605a5, 0x05a805a7, 0x05aa05a9, 0x05ac05ab, 0x05ae05ad, 0x05b005af, 0x05b205b1, 0x05b405b3, 0x05b605b5, 0x05b805b7, 0x05ba05b9,
+    0x05bc05bb, 0x05be05bd, 0x05c005bf, 0x05c205c1, 0x05c405c3, 0x05c605c5, 0x05c805c7, 0x05ca05c9, 0x05cc05cb, 0x05ce05cd, 0x05d005cf, 0x05d205d1,
+    0x05d405d3, 0x05d605d5, 0x05d805d7, 0x05da05d9, 0x05dc05db, 0x05de05dd, 0x05e005df, 0x05e205e1, 0x05e405e3, 0x05e605e5, 0x05e805e7, 0x05ea05e9,
+    0x05ec05eb, 0x05ee05ed, 0x05f005ef, 0x05f205f1, 0x05f405f3, 0x05f605f5, 0x05f805f7, 0x05fa05f9, 0x05fc05fb, 0x05fe05fd, 0x060006ff, 0x06020601,
+    0x06040603, 0x06060605, 0x06080607, 0x060a0609, 0x060c060b, 0x060e060d, 0x0610060f, 0x06120611, 0x06140613, 0x06160615, 0x06180617, 0x061a0619,
+    0x061c061b, 0x061e061d, 0x0620061f, 0x06220621, 0x06240623, 0x06260625, 0x06280627, 0x062a0629, 0x062c062b, 0x062e062d, 0x0630062f, 0x06320631,
+    0x06340633, 0x06360635, 0x06380637, 0x063a0639, 0x063c063b, 0x063e063d, 0x0640063f, 0x06420641, 0x06440643, 0x06460645, 0x06480647, 0x064a0649,
+    0x064c064b, 0x064e064d, 0x0650064f, 0x06520651, 0x06540653, 0x06560655, 0x06580657, 0x065a0659, 0x065c065b, 0x065e065d, 0x0660065f, 0x06620661,
+    0x06640663, 0x78650b65, 0x6d616c63, 0x6f697461, 0x6168076e, 0x61746873, 0x6f640b67, 0x72616c6c, 0x6769732d, 0x138b4a6e, 0x656c0938, 0x742d7373,
+    0x066e6168, 0x61757165, 0x670c736c, 0x74616572, 0x13847265, 0x27335b4a, 0x75616606, 0x0b746563, 0x2d3a0685, 0x70697264, 0x756f6814, 0x632d6573,
+    0x6e6d6968, 0x772d7965, 0x6f646e69, 0x14850c77, 0x61349883, 0x6574166c, 0x7265706d, 0x72757461, 0x72612d65, 0x2d776f72, 0x6e212282, 0x2d169114,
+    0x74077075, 0x6c696172, 0x62087265, 0xa8826361, 0x09616922, 0x752d0886, 0x6f620a6d, 0x69742d78, 0x65757373, 0x31d28214, 0x6f682d64, 0x6e69646c,
+    0x656d2d67, 0x61636964, 0x14840d6c, 0x61707327, 0x656c6b72, 0x250d8473, 0x75622d73, 0x0d826262, 0x1b831620, 0x6168732a, 0x732d656b, 0x6c706d69,
+    0x6c240682, 0x0f687361, 0x0f85168a, 0x64616522, 0x64202182, 0x6f25cf82, 0x15686775, 0x210f8d68, 0x2583732d, 0x15890e20, 0x73616d24, 0x0e890f6b,
+    0x72697625, 0x41127375, 0x75230d10, 0x41726573, 0x6c2c060e, 0x6f747061, 0x756c0b70, 0x2d73676e, 0x18232b84, 0x836f6570, 0x7261358d, 0x73776f72,
+    0x66656c2d, 0x69722d74, 0x0b746867, 0x6e616c70, 0x0c24a586, 0x706d7570, 0x0920e587, 0x732a0c84, 0x0c70616f, 0x65696873, 0x4885646c, 0x69730425,
+    0x85046b6e, 0x2c638216, 0x63746177, 0x30322d68, 0x6f68730a, 0x24b58570, 0x6f74730b, 0x2c518672, 0x696f7412, 0x2d74656c, 0x65706170, 0x831e8672,
+    0x857320a7, 0x8405200b, 0x840b209b, 0x20118505, 0x270b8407, 0x76047365, 0x0c747365, 0x3b820483, 0x65226282, 0xba841073, 0x72742d2b, 0x2d646e65,
+    0x6e776f64, 0x22108b0e, 0x85157075, 0x7520080e, 0x72662d70, 0x622d6d6f, 0x6b636172, 0x610c7465, 0x72747375, 0x732d6c61, 0x096e6769, 0x74686162,
+    0x0c270984, 0x63746962, 0x846e696f, 0x620e340c, 0x2d746c6f, 0x6867696c, 0x6e696e74, 0x6f620d67, 0x832d6b6f, 0x616d3604, 0x630d6b72, 0x72656d61,
+    0x6f722d61, 0x65746174, 0x64656309, 0x2d348469, 0x6168630c, 0x632d7472, 0x6d756c6f, 0x0c850b6e, 0x6e616729, 0x630c7474, 0x8270616c, 0x6f6230ed,
+    0x06647261, 0x766f6c63, 0x630c7265, 0x8265646f, 0x706d232b, 0x43827261, 0x66240c83, 0x116b726f, 0x70281684, 0x2d6c6c75, 0x75716572, 0x0a20f182,
+    0x6f204f82, 0x0d289585, 0x7a757263, 0x6f726965, 0x072c6e84, 0x70736964, 0x0979616c, 0x676e6f64, 0x08391184, 0x76656c65, 0x726f7461, 0x6c696613,
+    0x2d726574, 0x63726963, 0x782d656c, 0x24b5826d, 0x6f6c660b, 0x24de8672, 0x6c6f660d, 0x2a1f8364, 0x65736f6c, 0x72660a64, 0x84636e61, 0x670c2341,
+    0x0c826175, 0x032acf85, 0x0e6e7567, 0x646e6168, 0xc0842d73, 0x676e6923, 0x055f420a, 0x65737530, 0x6e691172, 0x6e616964, 0x7075722d, 0x3c846565,
+    0x696b0823, 0x23088470, 0x72616c09, 0x0d244285, 0x6574696c, 0x24085541, 0x6e616d0a, 0x056d4161, 0x616d092c, 0x662d6b73, 0x09656361, 0xec82696d,
+    0x6769732b, 0x6f6d0b6e, 0x2d79656e, 0x260f8262, 0x616e0a73, 0x84617269, 0x70082e4d, 0x726f6e61, 0x0b616d61, 0x65736570, 0x20148574, 0x410b8209,
+    0x08200506, 0x2205ad42, 0x820b7075, 0x61692289, 0x22338468, 0x82747306, 0x08733f3f, 0x656d6974, 0x656e696c, 0x7572740b, 0x662d6b63, 0x746e6f72,
+    0x72757411, 0x6873696b, 0x61876c2d, 0x61760527, 0x13746c75, 0x26ea8277, 0x67616d2d, 0x432d6369, 0x092307c9, 0x82656877, 0x776123b1, 0x09820f6e,
+    0x636c6523, 0x3f568268, 0x766f6d2d, 0x6f620965, 0x722d6c77, 0x0f656369, 0x73726570, 0x702d6e6f, 0x6e676572, 0x0d746e61, 0x200c8343, 0x230d860b,
+    0x6b636172, 0x33441986, 0x63092306, 0x0c416e65, 0x86152005, 0x68742641, 0x67756f72, 0x06c74468, 0xd8830a20, 0x0c827420, 0x82746c21, 0x752c080a,
+    0x696d2d73, 0x0873756e, 0x6c696173, 0x74616f62, 0x63657307, 0x6e6f6974, 0x72687306, 0x13706d69, 0x7a617262, 0x61696c69, 0x65722d6e, 0x4206dc42,
+    0x75440690, 0x640c2d05, 0x72676169, 0x6e2d6d61, 0x13747865, 0xb4820c87, 0x63656428, 0x6f737365, 0x13871172, 0x63757322, 0x0d311185, 0x74726165,
+    0x636f2d68, 0x696e6165, 0x75620961, 0x05914367, 0x69661124, 0x5c42656c, 0x68632407, 0x8c6b6365, 0x6d782e11, 0x096b7261, 0x706f6873, 0x636f6c2d,
+    0x06cb436b, 0x766f6328, 0x76116469, 0xc9827269, 0x4b850b84, 0x6e611325, 0x426f6863, 0x4d8408aa, 0x138d1920, 0x8e0a7d46, 0x2069842d, 0x832d860b,
+    0x4519206b, 0x2d2f09e2, 0x612d7075, 0x736f7263, 0x696c2d73, 0x8d12656e, 0x202c8319, 0x2d128513, 0x68676972, 0x6f742d74, 0x7469632d, 0x32441a79,
+    0x72672c0d, 0x646e756f, 0x7461772d, 0x8d187265, 0x2413841a, 0x6d75702d, 0x82478670, 0x234a856f, 0x73746f64, 0x73251385, 0x776f642d, 0x835b836e,
+    0x058e4482, 0x7f451389, 0x45b28505, 0x2f870b7f, 0x70840b20, 0x732d7325, 0x856e6970, 0x220b837c, 0x8474696c, 0x249682da, 0x7466656c, 0x84248610,
+    0x637224bf, 0x890d656c, 0x8a888210, 0x7965230d, 0x1b871165, 0x6e727522, 0x8705eb45, 0x837420a7, 0x82438211, 0x87732032, 0x82d08225, 0x39b98311,
+    0x726f6209, 0x6f682d65, 0x620e656c, 0x6c74746f, 0x72642d65, 0x656c706f, 0x0e860c74, 0x74617724, 0x12437265, 0x6f663905, 0x620d646f, 0x7365786f,
+    0x6361702d, 0x676e696b, 0x69726206, 0x13656764, 0x37420685, 0x8d19200c, 0x0be94113, 0xe941198d, 0x24138605, 0x6b636f6c, 0x840b860c, 0x62062f79,
+    0x656b6375, 0x75620474, 0x621b7367, 0x9b476975, 0x44632005, 0xe54105fd, 0x8f15200a, 0x6863241b, 0x906b6365, 0x90868a31, 0x20888431, 0x2347880d,
+    0x67616c66, 0x98850d89, 0x6e237f87, 0x880f6f67, 0x05304728, 0x0f880b20, 0x896e7521, 0x73752436, 0x880e7265, 0x68773219, 0x05746165, 0x73727562,
+    0x61630674, 0x6e6f2d72, 0x2806830a, 0x6e6e7574, 0x630b6c65, 0x26dd8268, 0x6669722d, 0x8408656c, 0x6572230b, 0xe9860c6e, 0x6f6e2508, 0x12736564,
+    0x70696c63, 0x72616f62, 0x75712d64, 0x69747365, 0x63136e6f, 0x64756f6c, 0x6f68732d, 0x73726577, 0x3e05cd42, 0x6d6f6308, 0x65747570, 0x75630d72,
+    0x2d736562, 0x63617473, 0x1564656b, 0x65766e65, 0x43706f6c, 0x09260dde, 0x6c707865, 0x4a82736f, 0x65660526, 0x17797272, 0x410b0044, 0x06440a2d,
+    0x696d250c, 0x1073756e, 0x7024298b, 0x1473756c, 0xa087108b, 0x14840b20, 0x24062241, 0x65726966, 0x39fe822d, 0x0972656e, 0x68736966, 0x6e69662d,
+    0x6c660a73, 0x2d6b7361, 0x6c616976, 0x0a82670b, 0x1320c586, 0x93420b8a, 0x67132507, 0x70756f72, 0x2005ec49, 0x06a44773, 0xb4491120, 0x200c830c,
+    0x25048309, 0x66667563, 0xe2460b73, 0x6f622505, 0x13646e75, 0xdd490b85, 0x68632507, 0x14646c69, 0x692a138e, 0x656c6372, 0x61656811, 0xcb427472,
+    0x6f622407, 0x8c12746c, 0x68632511, 0x186b6365, 0x2741128c, 0x242b8d0a, 0x756e696d, 0x23508d73, 0x73756c70, 0x7824248d, 0x6b72616d, 0x6c2b2482,
+    0x706f6369, 0x2d726574, 0x826d7973, 0x68092a76, 0x656d6c65, 0x6e752d74, 0x27ab820e, 0x76612d6c, 0x6e616c61, 0x0e857d82, 0x636f7228, 0x696c736b,
+    0x184a6564, 0x20bc8407, 0x4b9d862d, 0x1285053c, 0x188b9d8c, 0xf7477884, 0x69662306, 0x0a876572, 0x67616c23, 0x05db4611, 0x6f6c6623, 0x0623456f,
+    0x11902420, 0x43072241, 0x41860a85, 0x9b826c20, 0x2f851a20, 0x44061147, 0x20200c1a, 0xa68a1a94, 0xae843b95, 0x5687ed86, 0xab826620, 0x2b067b47,
+    0x6e757374, 0x03696d61, 0x0972616a, 0x2d3b0382, 0x61656877, 0x656a0e74, 0x69662d74, 0x65746867, 0x70752d72, 0x67756a0d, 0x8265642d, 0x65673d0c,
+    0x6b0b746e, 0x68637469, 0x732d6e65, 0x6c0c7465, 0x2d646e61, 0x656e696d, 0x0d6e6f2d, 0x6d240c83, 0x2d6b7261, 0x0b205f83, 0x8205604b, 0x656c2346,
+    0x21826c0d, 0x6c2d7329, 0x696e6165, 0x8211676e, 0x746129e8, 0x2d6e6f69, 0x2d6e6970, 0x6b210c82, 0x2a048206, 0x1c747375, 0x6e67616d, 0x82796669,
+    0x422d2023, 0x244105c7, 0x9016200a, 0x6863251c, 0x14747261, 0x73217082, 0x3085832d, 0x756e6576, 0x75622d73, 0x0f747372, 0x6b73616d, 0x2610822d,
+    0x616c6974, 0x82726f74, 0x7474250f, 0x73736572, 0x6c317182, 0x0c776f6c, 0x69626f6d, 0x722d656c, 0x6f727465, 0x09654913, 0x72742d28, 0x66736e61,
+    0x138d7265, 0xe3826520, 0x10707522, 0x772d278a, 0x74616568, 0x736f6d08, 0x74697571, 0x854e826f, 0x6e2d2a08, 0x6d057465, 0x646e756f, 0x2105830d,
+    0xdf826174, 0x74696323, 0x21208279, 0x0d846e75, 0x6e75732c, 0x6c696f08, 0x6c65772d, 0xef460c6c, 0x672d2605, 0x70756f72, 0x240c860b, 0x656e696c,
+    0x220b860e, 0x826c7570, 0x8767200e, 0x6f72260e, 0x72656262, 0x24298779, 0x666f6f72, 0x06284919, 0x460acb47, 0x198d06a1, 0xf14b7520, 0x214e8206,
+    0x33861465, 0x6572622d, 0x66747361, 0x69646565, 0x870c676e, 0x72752314, 0x61827473, 0x6f737229, 0x61632d6e, 0x8611656e, 0x68632a18, 0x626b6c61,
+    0x6472616f, 0x43118713, 0x6d870a3a, 0x42067745, 0x2d8e0a94, 0x6e696d25, 0x8d127375, 0x6c702441, 0x8d167375, 0x08a84512, 0xcb42168d, 0x23138605,
+    0x73657264, 0x8807ef41, 0x776f2212, 0x20cd826e, 0x230f860e, 0x6c6c6166, 0xf1870e82, 0x23420e86, 0x86112005, 0x21d78223, 0x4b842d66, 0x11881020,
+    0x73617223, 0x20378273, 0x2d108618, 0x696c696d, 0x79726174, 0x696f702d, 0x1882746e, 0x88079f4a, 0x69722418, 0x41656c66, 0x15880704, 0x2d6f7422,
+    0x50414185, 0x61722307, 0x69417379, 0x87328407, 0x687327a8, 0x65746c65, 0x2e851e72, 0x61772d24, 0x66826b6c, 0x2a05b245, 0x6f6f6c2d, 0x656c2d70,
+    0x941a7466, 0x6972251e, 0x26746867, 0x64211a8e, 0x21528261, 0xfd822d64, 0x8407e54f, 0x8e162026, 0x756c2726, 0x67616767, 0x324c1265, 0x06bd4105,
+    0x8c050c45, 0x0ad04112, 0x78252b8d, 0x6b72616d, 0x242b850a, 0x6b636f6c, 0x210a820b, 0x45446574, 0x70102105, 0x11465e82, 0x8b11200b, 0x20658410,
+    0x8a118b17, 0x24298c64, 0x756e696d, 0x824c8c73, 0x8c732035, 0x3a868422, 0x6e61720c, 0x676e696b, 0x6174732d, 0x6f720c72, 0x622d6461, 0x69727261,
+    0x850b7265, 0x6972250c, 0x11656764, 0xea8b0b84, 0x118b1720, 0x178b848b, 0x09206184, 0xe7841184, 0x732e0984, 0x656b6970, 0x75720373, 0x61730a67,
+    0x574e6b63, 0x73132605, 0x6f6f6863, 0x0cbb456c, 0x138d1920, 0x2d8e648a, 0x0b206684, 0x66232d86, 0x8767616c, 0x2e74830b, 0x6568730d, 0x702d7465,
+    0x7473616c, 0x480a6369, 0x2d23051e, 0x87746163, 0x6f64220a, 0x07885067, 0x61656823, 0x2a178272, 0x72617571, 0x666e2d65, 0x85731669, 0x0600420a,
+    0x826f6321, 0x656e2313, 0x16860c64, 0x7269763b, 0x73117375, 0x66666174, 0x7365612d, 0x616c7563, 0x73756970, 0x6e75730e, 0x206f822d, 0x05764d6e,
+    0x61740425, 0x830c7072, 0x075b4804, 0x65740425, 0x8317746e, 0x0a4c5204, 0x2007af4b, 0x51178a15, 0x1420094d, 0x7424158a, 0x2d6e7275, 0x10201a83,
+    0x73261489, 0x776f642d, 0x1083056e, 0x510f7321, 0x6f27071b, 0x62617472, 0x8510656c, 0x2d73220f, 0x2b108670, 0x776f740a, 0x632d7265, 0x116c6c65,
+    0x6f370a85, 0x72657362, 0x69746176, 0x74096e6f, 0x2d656572, 0x79746963, 0x82727406, 0x0d6c2127, 0x2d270685, 0x63697262, 0x4f11736b, 0x63460503,
+    0x221f820a, 0x876b6375, 0x850b20db, 0x6966251f, 0x0e646c65, 0x2d220b8a, 0x1a866e75, 0x616c7026, 0x7513656e, 0x73277082, 0x7465622d, 0x82656577,
+    0x6e6924cd, 0x850a7365, 0x826c2013, 0x240a860b, 0x73796172, 0x2615850f, 0x74636572, 0x82676e61, 0x2d0f85cd, 0x77656976, 0x646e6966, 0x76117265,
+    0x38426169, 0x840a200d, 0x69762711, 0x1c737572, 0x7a4f6877, 0x075a4206, 0x2a0a4642, 0x726f7704, 0x6d780c6d, 0x4d6b7261, 0x732005de, 0x2e06184b,
+    0x73657264, 0x68630e73, 0x2d646c69, 0x82616572, 0x676e2208, 0x23268213, 0x696e6974, 0x2b066447, 0x74706d65, 0x756d0579, 0x10636973, 0x200f6447,
+    0x27738205, 0x73047472, 0x04726174, 0x042fad83, 0x6d6c6966, 0x62617411, 0x632d656c, 0x826c6c65, 0x7261246c, 0x8a0b6567, 0x850a2011, 0x696c2a0b,
+    0x63057473, 0x6b636568, 0x20968405, 0x245a8f15, 0x756c702d, 0x11d54773, 0x6e696d2f, 0x70097375, 0x7265776f, 0x66666f2d, 0x05b65406, 0x65670427,
+    0x68057261, 0x3083826f, 0x6f6c6305, 0x72046b63, 0x0864616f, 0x6e776f64, 0x2608826c, 0x626e6905, 0x4112786f, 0x6f2406ca, 0x65746174, 0x4d05ce4d,
+    0x9a5207ee, 0x410e2005, 0x2d20087a, 0x04209e83, 0x66244884, 0x0a67616c, 0x642de682, 0x6e6f6870, 0x760a7365, 0x6d756c6f, 0x877b8365, 0x6f6c230a,
+    0x15860b77, 0x6769682d, 0x72710668, 0x65646f63, 0x84616207, 0x74032407, 0x82046761, 0x04732603, 0x6b6f6f62, 0x07145308, 0x72700526, 0x06746e69,
+    0x24051a53, 0x6e6f6604, 0x301f8274, 0x6906646c, 0x696c6174, 0x65740b63, 0x682d7478, 0x214e8265, 0x0b840a74, 0x64697725, 0x820a6874, 0x4367201b,
+    0x0c200511, 0x63260a85, 0x65746e65, 0x0c850b72, 0x2e837220, 0x0b850d20, 0x73756a27, 0x79666974, 0x24c88304, 0x74756f07, 0x22288264, 0x836e6906,
+    0x76052c06, 0x6f656469, 0x616d6905, 0x490c6567, 0x12200b6c, 0x2b06f644, 0x666c6168, 0x7274732d, 0x07656b6f, 0x2706b84e, 0x6e65700d, 0x2d6f742d,
+    0x4f050f44, 0x75250783, 0x6f642d70, 0x41908577, 0x62270650, 0x776b6361, 0x82647261, 0x7065223f, 0x240d880d, 0x74736166, 0x330d8708, 0x616c7004,
+    0x61700579, 0x04657375, 0x706f7473, 0x726f6607, 0x0c203383, 0x2d200786, 0x0c882d83, 0x65747330, 0x6a650570, 0x0c746365, 0x76656863, 0x6f856f72,
+    0x0c870d20, 0x0b20f584, 0x7023ba86, 0x4d73756c, 0x6d2207de, 0x0c896e69, 0x616d7824, 0x19876b72, 0x63223a82, 0x32860f6b, 0x8608544d, 0x6e69330f,
+    0x630a6f66, 0x73736f72, 0x72696168, 0x61620373, 0x39420a6e, 0x656c2305, 0x64507466, 0x20ec8505, 0x21168508, 0x1f867075, 0x776f6424, 0x3582056e,
+    0x06657232, 0x61707865, 0x6308646e, 0x72706d6f, 0x05737365, 0x5f418b84, 0x0b984307, 0x66696732, 0x656c0474, 0x66046661, 0x03657269, 0x09657965,
+    0xeb510382, 0x74142905, 0x6e616972, 0x2d656c67, 0x053c318a, 0x6e616c70, 0x61630d65, 0x646e656c, 0x642d7261, 0x07737961, 0x66756873, 0x07656c66,
+    0x6d2b6f82, 0x06746e65, 0x6e67616d, 0x410a7465, 0x75210722, 0x083a4170, 0x0727a383, 0x77746572, 0x82746565, 0x74722b44, 0x6f68732d, 0x6e697070,
+    0xe4540667, 0x850b2005, 0x6f2d2306, 0x1f566570, 0x2d732106, 0x5006e741, 0xac4507e8, 0x63092309, 0x42826168, 0x72616223, 0x05c9420c, 0x2a05334b,
+    0x79656b03, 0x61656705, 0x86087372, 0x09732391, 0xac827473, 0x6c616823, 0x059a5166, 0x56054141, 0x09290c68, 0x6d756874, 0x63617462, 0x0955526b,
+    0x67697224, 0x25857468, 0x20057a42, 0x0e845216, 0xa4566220, 0x74063905, 0x68706f72, 0x70750679, 0x64616f6c, 0x6d656c05, 0x70056e6f, 0x656e6f68,
+    0x8407c246, 0x7506370c, 0x636f6c6e, 0x72630b6b, 0x74696465, 0x7261632d, 0x73720364, 0xc5820a73, 0x2d642008, 0x76697264, 0x75620865, 0x6f686c6c,
+    0x630b6e72, 0x69747265, 0x61636966, 0x68106574, 0x49646e61, 0xb78505de, 0x108a0f20, 0x66656c24, 0x0f8a0d74, 0x8b707521, 0x6f64241d, 0x51116e77,
+    0x2f830c59, 0x8a070942, 0x078e42cc, 0x75211285, 0x83348d70, 0x67053046, 0x65626f6c, 0x65727706, 0x0a68636e, 0x8273696c, 0x656824c0, 0x56066b63,
+    0x092a05bd, 0x65697262, 0x73616366, 0x97431265, 0x75053d11, 0x73726573, 0x6e696c04, 0x6c63056b, 0x0564756f, 0x73616c66, 0x6373086b, 0x6f737369,
+    0x633a1982, 0x0979706f, 0x65706170, 0x696c6372, 0x6c660b70, 0x7970706f, 0x7369642d, 0x7841066b, 0x62042505, 0x07737261, 0x75217584, 0x2807856c,
+    0x730d6c6f, 0x6b697274, 0x06885565, 0x6e750925, 0x82726564, 0x05652763, 0x6c626174, 0x21560a65, 0x74052609, 0x6b637572, 0x09234d0a, 0x61630a2b,
+    0x2d746572, 0x6e776f64, 0x210a8508, 0x13867075, 0x66656c24, 0x13850b74, 0x67697225, 0x840d7468, 0x0627584c, 0x82047321, 0x097421ae, 0x3c840483,
+    0x09840720, 0x08707522, 0x42078851, 0xc75005a4, 0x832d2006, 0x0523084b, 0x65766167, 0x6f62046c, 0x7307746c, 0x6d657469, 0x75087061, 0x6572626d,
+    0x05616c6c, 0x74736170, 0x836c0965, 0x75622367, 0x5e42626c, 0x09f5430c, 0x6c631025, 0x4864756f, 0x0e200ac3, 0x7526108b, 0x73750b70, 0x8f827265,
+    0x6f746324, 0x50820b72, 0x6f687432, 0x706f6373, 0x75730865, 0x61637469, 0x62046573, 0x0a2b6d82, 0x2d67756d, 0x63756173, 0x82087265, 0x69702a20,
+    0x0d6c6174, 0x63757274, 0x07315a6b, 0x2f871020, 0x0b201087, 0x220a6a4f, 0x8265620e, 0x25438364, 0x74706d65, 0x97410879, 0x682d2205, 0x2a08860b,
+    0x73756c70, 0x676e610b, 0x8473656c, 0x860c20f7, 0x8372200b, 0x860920dc, 0x86ab820c, 0x6f642409, 0x840a6e77, 0x852d840b, 0x05de4239, 0x16850820,
+    0x86707521, 0x202a831f, 0x05b04f06, 0x28058c41, 0x75622d74, 0x6e6f7474, 0x06294f0d, 0x0a250d85, 0x746f7571, 0x854d8565, 0x287a840a, 0x69707307,
+    0x72656e6e, 0x05064306, 0x61660a2a, 0x732d6563, 0x656c696d, 0x66210a85, 0x20898272, 0x38158408, 0x0768656d, 0x656d6167, 0x08646170, 0x6279656b,
+    0x6472616f, 0x616c660e, 0x05825167, 0x6572653c, 0x65740864, 0x6e696d72, 0x63046c61, 0x0965646f, 0x6c706572, 0x6c612d79, 0xc9460e6c, 0x72612108,
+    0x04255082, 0x706f7263, 0x2322830b, 0x6172622d, 0x21053043, 0x57456b6e, 0x69043405, 0x0b6f666e, 0x65707573, 0x72637372, 0x09747069, 0x85627573,
+    0x65063609, 0x65736172, 0x75700c72, 0x656c7a7a, 0x6569702d, 0x6d0a6563, 0x244c8369, 0x656e6f68, 0x850a8910, 0x4b06204a, 0x08200565, 0x2f078e45,
+    0x72696611, 0x78652d65, 0x676e6974, 0x68736975, 0x7226f582, 0x656b636f, 0x524c1374, 0x08c24609, 0x138e1420, 0x67697224, 0xf7437468, 0x09bb4507,
+    0x64243a8f, 0x066e776f, 0x2005c457, 0x05cf440e, 0x656b2d26, 0x6c6f6879, 0x2d05bc44, 0x65796573, 0x6c6c6508, 0x69737069, 0x08871173, 0x65762d25,
+    0x82697472, 0x420a20a6, 0x7222062d, 0x34477373, 0x79612209, 0x821c8206, 0x072d45a6, 0x6e696d24, 0x1d497375, 0x742d2d05, 0x2d6e7275, 0x610f7075,
+    0x776f7272, 0x82830d85, 0xa8822a87, 0x876b6321, 0x65702355, 0x6086156e, 0xe5572e85, 0x73112507, 0x65726168, 0x280bc945, 0x6d6f6307, 0x73736170,
+    0x442f8611, 0x0f200910, 0x7522118c, 0x0f8c1270, 0x67697227, 0x65097468, 0x06d65b75, 0x74730d26, 0x696c7265, 0x2006d25b, 0x0a5e5b0a, 0x5c657921,
+    0x13820506, 0x5b6c6221, 0x77210672, 0x2513856f, 0x6c696604, 0x04830a65, 0x3b822d20, 0x5d736521, 0xd7830609, 0x2d612d24, 0xbc880c7a, 0x15200c82,
+    0x1b840c85, 0x64697722, 0x68234982, 0x5874726f, 0x2d200509, 0x1389df82, 0x3122458b, 0x4589392d, 0xdd460c82, 0x82732005, 0x740b2530, 0x626d7568,
+    0x4105c74c, 0x5b840654, 0x6e6f6c23, 0x06724167, 0x0d835582, 0x6c241d86, 0x2d746665, 0x10200f83, 0x840a2f46, 0x072d5010, 0x65726425, 0x4d067373,
+    0x033805bc, 0x046e7573, 0x6e6f6f6d, 0x786f620b, 0x6372612d, 0x65766968, 0x67756203, 0x830d6841, 0x420a2054, 0x64230680, 0x5b0a746f, 0x092009af,
+    0x2608e85b, 0x7568730d, 0x826c7474, 0x617023f1, 0x96416563, 0x07694507, 0x82571020, 0x63230808, 0x6d756c6f, 0x670e736e, 0x75646172, 0x6f697461,
+    0x61632d6e, 0x616c0870, 0x6175676e, 0x66036567, 0x87087861, 0x8205202c, 0x646c2b8f, 0x77617003, 0x62756304, 0x04830565, 0x07732208, 0x79636572,
+    0x03656c63, 0x04726163, 0x69786174, 0x65727404, 0x61640865, 0x61626174, 0x66086573, 0x23848269, 0x09666470, 0x77230884, 0x4164726f, 0x652505bb,
+    0x6c656378, 0x2914840f, 0x65776f70, 0x696f7072, 0x1a85746e, 0x826d6921, 0x840b2079, 0x697a251a, 0x72657070, 0x61241685, 0x6f696475, 0x76240a85,
+    0x6f656469, 0x63235185, 0x8265646f, 0x656626f6, 0x6e69722d, 0x091f5867, 0x68637425, 0x8261700b, 0x702d213c, 0x6526cc82, 0x6f6c6311, 0x5b466b63,
+    0x6807240b, 0x82646165, 0x70092c32, 0x67617261, 0x68706172, 0x826c7307, 0x73722257, 0x05f0420b, 0x59826e20, 0xc0427320, 0x08128a07, 0x6f620424,
+    0x6606626d, 0x6f627475, 0x7474036c, 0x69620a79, 0x75636f6e, 0x7372616c, 0x756c7004, 0x656e0967, 0x7a847377, 0x69770428, 0x630a6966, 0x1d836c61,
+    0x726f7427, 0x6c65620a, 0x057d446c, 0x72740528, 0x09687361, 0x47706f63, 0x650b2706, 0x642d6579, 0xee846f72, 0x69617037, 0x7262746e, 0x0c687375,
+    0x656b6163, 0x6e61632d, 0x73656c64, 0x05b2490a, 0x65726123, 0x06bd4961, 0x65697022, 0x6c2f1486, 0x0a656e69, 0x67676f74, 0x6f2d656c, 0x87096666,
+    0x076e230a, 0x9f416962, 0x75622905, 0x6c631173, 0x6465736f, 0x70244f82, 0x6e6f6974, 0xea82fc82, 0x656b6522, 0x24062060, 0x74726163, 0x21c1822d,
+    0x09840f73, 0x2b093b43, 0x61696407, 0x646e6f6d, 0x69687304, 0x28063047, 0x72636573, 0x6d0a7465, 0x84d6826f, 0x730b2e5f, 0x65657274, 0x69762d74,
+    0x680b7765, 0x374a8465, 0x65736c75, 0x6e657605, 0x6d047375, 0x07737261, 0x6372656d, 0x0e797275, 0x2c0dd955, 0x6172740b, 0x6567736e, 0x7265646e,
+    0x272d840c, 0x756f642d, 0x0b656c62, 0x0b852784, 0x18850a20, 0x16851183, 0x8505e44c, 0x230b854a, 0x1170752d, 0x0e863184, 0x6769722c, 0x6e067468,
+    0x65747565, 0x5e850a72, 0x73656c2c, 0x65730673, 0x72657672, 0x07827509, 0x0a20ed84, 0x78200984, 0x6b253a82, 0x64656203, 0x228e8205, 0x840c6e69,
+    0x732d3405, 0x61776275, 0x61620c79, 0x72657474, 0x75662d79, 0x87166c6c, 0x6874210c, 0x2d22f082, 0xea827571, 0x73726522, 0x68242388, 0x0f666c61,
+    0x1d862387, 0x0f870d20, 0x706d6524, 0x29447974, 0x6f702306, 0x55826e69, 0x2d69082f, 0x73727563, 0x6f0c726f, 0x63656a62, 0x05355674, 0x0c860e20,
+    0x566e7521, 0x29080544, 0x65746f6e, 0x6974732d, 0x05796b63, 0x6e6f6c63, 0x63730e65, 0x2d656c61, 0x616c6162, 0x6465636e, 0x756f680f, 0x616c6772,
+    0x25827373, 0x74726122, 0x73850f8a, 0x65231f89, 0x8809646e, 0x680e240d, 0x82646e61, 0x6b632745, 0x7369662d, 0x0e830474, 0x4a05124b, 0x0b20075f,
+    0x6c262184, 0x72617a69, 0x0b840a64, 0x6f707325, 0x840c6b63, 0x85c3860a, 0x65703217, 0x09656361, 0x64617274, 0x72616d65, 0x65720a6b, 0x26528267,
+    0x64657265, 0x4c767402, 0x702409f6, 0x0e73756c, 0x2208044d, 0x8b6e696d, 0x8378200e, 0x081d8939, 0x65686321, 0x69086b63, 0x7375646e, 0x07797274,
+    0x2d70616d, 0x0a6e6970, 0x6e676973, 0x6f702d73, 0x82037473, 0x6d072712, 0x61737365, 0xfc436567, 0x61702407, 0x47657375, 0x73270721, 0x0c706f74,
+    0x4d676162, 0x0f25082c, 0x6b736162, 0x093c4d65, 0x6e75102d, 0x72657669, 0x2d6c6173, 0x82636361, 0x55182049, 0x77310e4a, 0x2d687469, 0x656e6163,
+    0x64756111, 0x642d6f69, 0x05704865, 0x6e6f6929, 0x6f68700c, 0x502d656e, 0x072d0542, 0x69617262, 0x0a656c6c, 0x2d726165, 0x38f9836c, 0x6168166e,
+    0x2d73646e, 0x2d6c7361, 0x65746e69, 0x65727072, 0x676e6974, 0x24218308, 0x66616564, 0x2b1f8405, 0x6579650e, 0x776f6c2d, 0x7369762d, 0x662c5483,
+    0x2d746e6f, 0x73657761, 0x09656d6f, 0x68242184, 0x0d656b61, 0x2807bc45, 0x65706f2d, 0x64610c6e, 0x05265764, 0x6b6f6f22, 0x63230c88, 0x87647261,
+    0x73752df8, 0x69087265, 0x61622d64, 0x07656764, 0x1c830882, 0x0d661020, 0x7566240b, 0x8b1a6c6c, 0x0dd14210, 0x68242b8c, 0x13666c61, 0xd9422b8b,
+    0x8b112006, 0x6d652513, 0x06797470, 0x2d057c5d, 0x74616204, 0x6f700768, 0x73616364, 0xaf660f74, 0x6d2d2805, 0x6d697861, 0x88657a69, 0x6e69210f,
+    0x0e200f84, 0xd1821f86, 0x726f7422, 0x0808f84d, 0x616d7829, 0x6d096b72, 0x6f726369, 0x70696863, 0x6f6e7309, 0x616c6677, 0x7305656b, 0x6e6f6f70,
+    0x65747508, 0x6c69736e, 0x52720b73, 0x6c2e0518, 0x09746665, 0x73617274, 0x61632d68, 0x1585066e, 0x7473092a, 0x6177706f, 0x12686374, 0x4e0a924e,
+    0x1020067c, 0x86081261, 0x850c2010, 0x054c4b34, 0x65820320, 0x6d69062e, 0x73656761, 0x6e657006, 0x036c6963, 0x08200682, 0x2d220382, 0x8f826c63,
+    0x2008fb47, 0x08e74709, 0x50850a20, 0x6e6f6c24, 0x0a480767, 0x06024706, 0x086e6522, 0x0920fe87, 0x2008b85e, 0x09904f0a, 0x50832e83, 0x8b07bf41,
+    0x4225830b, 0x608407dd, 0xfe470920, 0x70752206, 0x07a64914, 0x470ba049, 0x1b8707ef, 0x65299587, 0x72067466, 0x61657065, 0x055f4b74, 0x6f632108,
+    0x74696d6d, 0x646f630a, 0x656d2d65, 0x07656772, 0x6b736564, 0x03706f74, 0x096d6567, 0x6e727574, 0x8405a94d, 0x70752609, 0x636f6c09, 0x057e426b,
+    0x2208b24b, 0x4b746f64, 0x6c250b5a, 0x73656e69, 0x065b4c14, 0x72637325, 0x4c6e6565, 0x06200670, 0x774c1485, 0x201b8507, 0x09564e0c, 0x0b312d22,
+    0x67054d43, 0x290805fd, 0x67616d69, 0x6f702d65, 0x61727472, 0x72057469, 0x796c7065, 0x6968730d, 0x2d646c65, 0x766c6168, 0x74146465, 0x656c6261,
+    0x658d2d74, 0x0d201485, 0x6805134b, 0xe1450686, 0x616c2105, 0x0f20e082, 0x25092854, 0x72616d78, 0x0553206b, 0x6e612309, 0x4c412d64, 0x6f742908,
+    0x6e65632d, 0x22726574, 0x1f831288, 0x66232d89, 0x866d6f72, 0x62112c22, 0x62657361, 0x2d6c6c61, 0x82746162, 0x6c6c2203, 0x20118708, 0x056c440a,
+    0x0c271c83, 0x6c776f62, 0x84676e69, 0x63052620, 0x73736568, 0x2705840c, 0x7369622d, 0x0b706f68, 0x6f240c86, 0x0a647261, 0x6b200b85, 0x23862e82,
+    0x696e6b25, 0x86746867, 0x61702317, 0x2e866e77, 0x65757124, 0x16866e65, 0x6f6f722a, 0x7564086b, 0x6562626d, 0x66238282, 0x83746f6f, 0x670d2477,
+    0x84666c6f, 0x742d3174, 0x680b6565, 0x656b636f, 0x75702d79, 0x620a6b63, 0x6d203182, 0x884e1a84, 0x75662907, 0x74186c6c, 0x656c6261, 0x6e282c82,
+    0x2d73696e, 0x64646170, 0x27056746, 0x6f760a6c, 0x79656c6c, 0x09215483, 0x050d4168, 0x07737423, 0x26098262, 0x03656761, 0x63786f62, 0x7320060c,
+    0x20056061, 0x08d55011, 0x2907124f, 0x72696611, 0x6c662d65, 0x206a6d61, 0x63082907, 0x75737061, 0x0f73656c, 0x4e081243, 0x0e20052f, 0x6c230f89,
+    0x5b747369, 0x64230797, 0x4273746f, 0x6c2905e8, 0x03656e69, 0x05616e64, 0x25948264, 0x61630c79, 0x59837472, 0x65627426, 0x69660c64, 0x125fb182,
+    0x840d2006, 0x61772b0c, 0x6f666576, 0x6b0b6d72, 0x8d877469, 0x43430820, 0x0c682106, 0x20061c45, 0x2573832d, 0x746f6e0d, 0x23877365, 0x61700622,
+    0x7429f282, 0x6c697005, 0x7013736c, 0x09fa4572, 0x0f642d20, 0x921b2005, 0x203c8713, 0x268b8209, 0x6c75702d, 0x500a6573, 0x662f052a, 0x07747361,
+    0x6b6f6d73, 0x07676e69, 0x82727973, 0x07653a06, 0x6c626174, 0x0b737465, 0x72656874, 0x656d6f6d, 0x04726574, 0x6c616976, 0x08048305, 0x77097321,
+    0x68657261, 0x6573756f, 0x6965770c, 0x2d746867, 0x6c616373, 0x2d780565, 0x08796172, 0x43786f62, 0x632c058e, 0x656d6d6f, 0x642d746e, 0x0d73746f,
+    0x732b0c87, 0x6873616c, 0x756f6305, 0x4c156863, 0x6c30082e, 0x2d72616c, 0x732d6f74, 0x04746f6c, 0x65766f64, 0x6205c847, 0x12200607, 0x240d3d62,
+    0x74726165, 0x21128c13, 0x40836f64, 0x560d196c, 0x3d620768, 0x0af46b0c, 0x676e6123, 0x0588536c, 0x1b6c7320, 0x700d2a0a, 0x63617261, 0x65747568,
+    0x20c6822d, 0x06195f10, 0x72616324, 0x10837972, 0x69700a24, 0x09826767, 0x6b6e612c, 0x62697206, 0x056e6f62, 0x2c826f72, 0x6573082e, 0x696c6465,
+    0x730c676e, 0x2d6e6769, 0x67207382, 0x0f200c82, 0x29099950, 0x6e69772d, 0x6174046b, 0xda596570, 0x61722306, 0x5183706d, 0x84410c20, 0x6f6d2205,
+    0x25308276, 0x6469760b, 0x8b4b6f65, 0x820a2005, 0x2d653031, 0x73616c67, 0x73751073, 0x6c2d7265, 0x6b677261, 0x0e2006c3, 0x61281084, 0x6f727473,
+    0x7475616e, 0x24054944, 0x63656863, 0x240a866b, 0x6b636f6c, 0x24248409, 0x72616567, 0x22098408, 0x856e6570, 0x8267201d, 0x0d7021b2, 0x604d1384,
+    0x85652006, 0x8535832b, 0x696d2322, 0x555a756e, 0x6e2d2605, 0x616a6e69, 0x442d840b, 0x218505e8, 0x98827320, 0x58856820, 0x67617422, 0x69210886,
+    0x211c8465, 0x75832d73, 0x63731028, 0x2d656c61, 0x0d4a6e75, 0x8f152007, 0x662d3010, 0x0770696c, 0x6e656c62, 0x09726564, 0x456f6f62, 0x0f2005c6,
+    0x2505595b, 0x616f7262, 0xe4826364, 0x09820520, 0x0a6d6f22, 0x20091260, 0x200a890f, 0x3f98832d, 0x75686306, 0x05686372, 0x6e696f63, 0x6f630c73,
+    0x6361706d, 0x69642d74, 0x63046373, 0x05776f72, 0x6e260483, 0x63696404, 0x04830965, 0x69662d23, 0x23098776, 0x0872756f, 0x6f221384, 0x0885656e,
+    0x78697323, 0x2311840a, 0x65726874, 0x742f1386, 0x64066f77, 0x64697669, 0x6f640b65, 0x4c2d726f, 0x092005b1, 0x22080b84, 0x6e65706f, 0x61656607,
+    0x72656874, 0x6f726604, 0x61670867, 0x75702d73, 0x6707706d, 0x7373616c, 0x6f127365, 0x2d280b79, 0x61757165, 0x65680a6c, 0x33074864, 0x666e6908,
+    0x74696e69, 0x696b0979, 0x622d6977, 0x0f647269, 0x8508bb6f, 0x6d06272d, 0x726f6d65, 0x2c521679, 0x696c230a, 0xb16d656e, 0x460f2006, 0x77240aad,
+    0x11657661, 0x31210f8a, 0x6b11832d, 0x632506d8, 0x6b636568, 0x841d8512, 0x432d200b, 0x09230537, 0x85746f6e, 0x70072868, 0x74656c61, 0x510e6574,
+    0x70270620, 0x696b7261, 0x6a0f676e, 0x70330799, 0x656a6f72, 0x72077463, 0x69656365, 0x72057470, 0x826f626f, 0x6c752505, 0x720e7265, 0x2d240583,
+    0x626d6f63, 0x64219a82, 0x290e8510, 0x69726f68, 0x746e6f7a, 0x1f866c61, 0x35527620, 0x73062f06, 0x6f6f6863, 0x63730b6c, 0x64776572, 0x17826972,
+    0x68730b36, 0x702d656f, 0x746e6972, 0x6b730573, 0x0b6c6c75, 0x2d6e6162, 0x26069944, 0x6f747305, 0x82046572, 0x0e702423, 0x82726162, 0x617435fb,
+    0x72656767, 0x730b6465, 0x6f6f7274, 0x66617770, 0x74076c65, 0x62295482, 0x7305786f, 0x74726968, 0x0d334b0e, 0x61770626, 0x74656c6c, 0x08052454,
+    0x676e6120, 0x61077972, 0x77686372, 0x620a7961, 0x2d6b6f6f, 0x616c7461, 0x77610573, 0x0b647261, 0x29826564, 0x3a057a54, 0x7a65620c, 0x2d726569,
+    0x76727563, 0x6f620465, 0x6205676e, 0x68737572, 0x8275620a, 0x6d692e85, 0x08656c70, 0x6e6e6163, 0x73696261, 0x0757410c, 0x6c627524, 0xf75c1465,
+    0x6963220d, 0x29368274, 0x6c65620e, 0x6f632d6c, 0x5382636e, 0x06656729, 0x6b6f6f63, 0x850b6569, 0x622d2306, 0x0b827469, 0x706f7222, 0x32062348,
+    0x63617412, 0x72676f68, 0x2d687061, 0x69676964, 0x856c6174, 0x696426be, 0x10797a7a, 0x05f15263, 0x72642d2e, 0x69746661, 0x6404676e, 0x0d6d7572,
+    0x2d290483, 0x65657473, 0x6e61706c, 0x069a420f, 0x21056d58, 0x79466465, 0x6f632705, 0x6172746e, 0xea507463, 0x09534f05, 0x2505df50, 0x6f707865,
+    0x0b857472, 0x0b82df82, 0x2c05bc46, 0x6f766e69, 0x13656369, 0x656c6966, 0x420c862d, 0x79680643, 0x0b764605, 0x25840e20, 0x67697328, 0x7574616e,
+    0x77856572, 0x75226985, 0x1c820470, 0x83096c21, 0x23bb8204, 0x660b7069, 0x6526bc82, 0x69727072, 0x1a82746e, 0x0c68732e, 0x65636166, 0x756c662d,
+    0x64656873, 0x2a054645, 0x776f7266, 0x706f2d6e, 0x410d6e65, 0x0c2d0c57, 0x74726165, 0x66612d68, 0x61636972, 0x210c860e, 0x0d83656d, 0x860a7321,
+    0x6973220e, 0x23518561, 0x6d697267, 0x09205982, 0x0c825e84, 0x880e6e21, 0x772d2409, 0x8a656469, 0x6562240e, 0x89146d61, 0x260e831d, 0x6577732d,
+    0x89107461, 0x83682014, 0x8a73205f, 0x71732210, 0x20c28275, 0x85218916, 0x742d2110, 0x73202882, 0x7583c785, 0x74732d24, 0x0f8b7261, 0x478a1f84,
+    0x6e6f7426, 0x17657567, 0x10854789, 0x4e852d20, 0x17901520, 0x6e697723, 0x22ca8c6b, 0x82046b6e, 0x0d702168, 0xaa550483, 0x5e112008, 0x5f420976,
+    0x83072006, 0x65732811, 0x69680b74, 0x676c6867, 0x0e270581, 0x2d746f68, 0x64627574, 0x0520064c, 0x65240e82, 0x6f6a056c, 0x3741d882, 0x696b2305,
+    0x6c857373, 0x2d200983, 0x84092841, 0x208a830e, 0x2056822d, 0x06684372, 0x75616c24, 0xfa856867, 0x2f840a84, 0xc1841120, 0xd3850f85, 0x4283218b,
+    0x3b491520, 0x732d210b, 0x2d06f658, 0x70616d0c, 0x636f6c2d, 0x6f697461, 0x0c8b106e, 0x6f642d30, 0x616d0674, 0x72656b72, 0x64656d05, 0xa1856c61,
+    0x68656d28, 0x616c622d, 0x71856b6e, 0x6c6f723b, 0x676e696c, 0x6579652d, 0x6f6d0873, 0x656d756e, 0x6d0d746e, 0x6174726f, 0x26ef8272, 0x656c7473,
+    0x8261700c, 0x832d20e9, 0x72652729, 0x73617008, 0x1e827073, 0x6570092a, 0x61662d6e, 0x0779636e, 0x6e220983, 0x11846269, 0x6c757226, 0x700d7265,
+    0x65296082, 0x7272612d, 0x6c617669, 0x270d850f, 0x61706564, 0x72757472, 0x9f494f82, 0x0585420a, 0x6461732c, 0x7972632d, 0x6361660d, 0x0c832d65,
+    0x61657428, 0x61760b72, 0x1f552d6e, 0x43092006, 0x42480836, 0x6562270b, 0x730b6d61, 0xaa836c6f, 0x6e612008, 0x73036c65, 0x73076170, 0x746f6c70,
+    0x73096863, 0x79617270, 0x6e61632d, 0x61747305, 0x5d10706d, 0x785f081e, 0x09095a06, 0x86060341, 0x72752a7d, 0x73697270, 0x77730a65, 0x24468261,
+    0x6b6f6f62, 0x0635450f, 0x69777328, 0x6e696d6d, 0x19820c67, 0x2d726526, 0x6464616c, 0x5649eb82, 0x06a34806, 0x742bc184, 0x64657269, 0x6f6f7405,
+    0x5b0e6874, 0x2d200707, 0x6328ac82, 0x65760d68, 0x726f7463, 0x2006e55f, 0x062b4a0e, 0x20061d49, 0x09e04810, 0x6d652d26, 0x12797470, 0x2d20c388,
+    0x3607ff71, 0x7070610b, 0x772d656c, 0x656c6f68, 0x6f746104, 0x6f62046d, 0x4810656e, 0x2d23082a, 0x82616572, 0x62052995, 0x6e696172, 0x72616308,
+    0x72211083, 0x5208830b, 0x092006dc, 0x75230b84, 0x84747372, 0x6973291e, 0x63106564, 0x67726168, 0x2d28d982, 0x74617473, 0x126e6f69, 0x58064954,
+    0x7231058b, 0x74686769, 0x6172640c, 0x6f702d77, 0x6f67796c, 0x075b6a6e, 0x646f6323, 0x220b8265, 0x53726579, 0x1320050e, 0x20078942, 0x09de5f2d,
+    0x756c0525, 0x5973676e, 0x733905e2, 0x65706f63, 0x6c696f07, 0x6e61632d, 0x6f6f7004, 0x68730670, 0x73657061, 0x2f78820c, 0x666f2d72, 0x66696c2d,
+    0x61670565, 0x0a656775, 0x2d250584, 0x68676968, 0x720a850c, 0x11200536, 0x1e840c8b, 0x65740526, 0x0a687465, 0x0f450584, 0x6b733207, 0x68742d73,
+    0x65746165, 0x72740d72, 0x69666661, 0x825b8263, 0x270d82c7, 0x2d6b6375, 0x736e6f6d, 0x0c201b82, 0x26056c4a, 0x6b636970, 0x4e0c7075, 0x61260974,
+    0x6e610464, 0x0647686b, 0x69622c05, 0x0d656c62, 0x69737562, 0x8273656e, 0x6d692856, 0x69630465, 0x4b0e7974, 0x6c2409ce, 0x0f72616c, 0x73200e86,
+    0x33060146, 0x6f726305, 0x640c7373, 0x6d726168, 0x61686361, 0x1261726b, 0x260c1c52, 0x7865742d, 0x74660c74, 0x6d2505f9, 0x73756e69, 0x6e0c860b,
+    0x32750797, 0x0599480a, 0x67073a08, 0x7275706f, 0x68056d61, 0x61736d61, 0x68616205, 0x6a046961, 0x13696465, 0x6b6f6f62, 0x756f6a2d, 0x6c616e72,
+    0x6968772d, 0x05736c6c, 0x6261616b, 0x686b0661, 0x61646e61, 0x071c6c08, 0x83870e20, 0x2d732108, 0x6b6c7562, 0x6e656d07, 0x6861726f, 0x736f6d06,
+    0x02657571, 0x73186d6f, 0x68676170, 0x69747465, 0x2f072541, 0x796c662d, 0x05676e69, 0x63616570, 0x6c701065, 0x2d2b0582, 0x772d666f, 0x6873726f,
+    0x82147069, 0x72612737, 0x6f702d65, 0x59456c6c, 0x08ee6608, 0xf4481483, 0x064a430a, 0x61727022, 0x0d205183, 0x86058b4c, 0x056d410d, 0xdf827120,
+    0x6d176e22, 0x850f896c, 0x901920ff, 0x07714217, 0x6f730525, 0x87736b63, 0x6f723f8b, 0x762d746f, 0x61697261, 0x11656c62, 0x72617473, 0x646e612d,
+    0x6572632d, 0x6e656373, 0x11840d74, 0x6432c282, 0x64697661, 0x6e797309, 0x676f6761, 0x730c6575, 0xb0837263, 0x726f7425, 0x820a6861, 0x69692e05,
+    0x7461672d, 0x69760665, 0x61726168, 0x0541540c, 0x20056668, 0x25c08208, 0x6e61792d, 0xaf4b0d67, 0x702d2506, 0x656e6f68, 0x2508c485, 0x6c756b73,
+    0x61630a6c, 0x7267706d, 0x646e756f, 0x74616303, 0x61686305, 0x630a7269, 0x64756f6c, 0x6f6f6d2d, 0x0a85096e, 0x6e757326, 0x776f6303, 0x31056c4b,
+    0x07303264, 0x65636964, 0x0336642d, 0x06676f64, 0x99827264, 0x640e6e37, 0x736d7572, 0x6b636974, 0x7469622d, 0x75640765, 0x6f65676e, 0x05b2526e,
+    0x76736322, 0x3705e74f, 0x74736966, 0x6f686705, 0x68067473, 0x656d6d61, 0x61680872, 0x696b756e, 0x682aca82, 0x772d7461, 0x72617a69, 0x81410d64,
+    0x69683306, 0x676e696b, 0x70696805, 0x68056f70, 0x6573726f, 0xbb7a6813, 0x7263370c, 0x0c6b6361, 0x76797268, 0x2d61696e, 0x6e676973, 0x73616d04,
+    0x586d086b, 0x6e0d2707, 0x6f777465, 0x57826b72, 0x6465722a, 0x74746f05, 0x72047265, 0x230afc6b, 0x6e6e7572, 0x06200e82, 0x25055341, 0x756b7310,
+    0x17446c6c, 0x6f623305, 0x0573656e, 0x73616c73, 0x70730668, 0x72656469, 0x8379740c, 0x7407210a, 0x742c7a82, 0x750c726f, 0x2d726573, 0x756a6e69,
+    0x0c246082, 0x632d7276, 0x6221bf82, 0x2404826f, 0x6e61770d, 0x08134564, 0x69770425, 0x820b646e, 0x4f652004, 0x3b6006ed, 0x656d2806, 0x61627461,
+    0x410f6c6c, 0x2d240972, 0x6e696172, 0x83068241, 0x0e88720a, 0x61656824, 0x3d867976, 0x6e757322, 0x083b2d84, 0x6f6d6564, 0x74617263, 0x616c6608,
+    0x73752d67, 0x75680961, 0x63697272, 0x6f656e61, 0x64280971, 0x06656d6f, 0x6574656d, 0x6141b682, 0x6f622f06, 0x0968746f, 0x2d6f6f70, 0x726f7473,
+    0x6f83076d, 0x776f6229, 0x7065720a, 0x836c6275, 0x7304243f, 0x55676f6d, 0x69230dbf, 0x550f6867, 0x6c200bab, 0xbe853082, 0x6c6f622f, 0x6f740774,
+    0x64616e72, 0x6f76076f, 0x217f826c, 0x5d4b0d6f, 0x06275005, 0x6177052b, 0x04726574, 0x79626162, 0x2204830d, 0x8261632d, 0x676132a7, 0x69620965,
+    0x7a61686f, 0x04647261, 0x676f6c62, 0x08d5570c, 0x79616422, 0x2409f057, 0x6b656577, 0x2155820a, 0x38827964, 0x06656e22, 0x6f213d83, 0x221f8274,
+    0x582d6873, 0x08220723, 0x0a56696d, 0x64082505, 0x73706d75, 0x0d206e82, 0x2d3c0887, 0x65726966, 0x68746508, 0x656e7265, 0x69670574, 0x11737466,
+    0x6d616863, 0x6e676170, 0x2906b74f, 0x770d7365, 0x6b736968, 0xc74f7965, 0x06aa4a05, 0x7275652a, 0x0a65706f, 0x70697267, 0x20052c5e, 0x440a8913,
+    0x06260851, 0x74697567, 0xb45a7261, 0x63430806, 0x6b636172, 0x6c6f680b, 0x622d796c, 0x79727265, 0x726f680a, 0x682d6573, 0x07646165, 0x63696369,
+    0x0573656c, 0x6f6c6769, 0x696d066f, 0x6e657474, 0x67756d07, 0x746f682d, 0x64617209, 0x69746169, 0x51106e6f, 0x1088066c, 0x65720833, 0x6f727473,
+    0x73096d6f, 0x6c657461, 0x6574696c, 0x3009880e, 0x7369642d, 0x64730768, 0x7261632d, 0x69730864, 0x4d08846d, 0x73210750, 0x2152826b, 0x5c43676e,
+    0x6b732207, 0x0af66e69, 0x2d2e0d85, 0x64726f6e, 0x73066369, 0x6769656c, 0xfd510b68, 0x736d2108, 0x2507a26f, 0x776f6e73, 0x5e826f62, 0x07203b82,
+    0x6d230c83, 0x83086e61, 0x6c702407, 0x820a776f, 0x5f6720c3, 0x06200563, 0x20052c43, 0x0a2a4e12, 0xb3642d20, 0x050e5b06, 0x6d210582, 0x0ac45311,
+    0x7275632f, 0x05646576, 0x6f636162, 0x6f620c6e, 0x080d636f, 0x72620b33, 0x2d646165, 0x63696c73, 0x68630665, 0x65736565, 0x0d054415, 0x4e7e6d20,
+    0x0ae75305, 0x65737522, 0x5308ea46, 0x06320742, 0x74757263, 0x64076863, 0x61657369, 0x65036573, 0xca466767, 0x72742a07, 0x62066565, 0x65677275,
+    0x05b55272, 0x64696d26, 0x2d656c64, 0x2005e04c, 0x062d740d, 0x66617326, 0x0d797465, 0x5007b363, 0x682605c4, 0x6f64746f, 0x9b820967, 0x82632d21,
+    0x0e6d21a7, 0x87052063, 0x70052274, 0x27548261, 0x7065700a, 0x2d726570, 0x0b252c82, 0x7a7a6970, 0x24cd8561, 0x6361730b, 0x0688476b, 0x61620d33,
+    0x702d7372, 0x72676f72, 0x0e737365, 0x73617274, 0x06696468, 0x12707522, 0x88088858, 0x830a2012, 0x6e2d2ae2, 0x65737275, 0x7661770b, 0x06ad4965,
+    0x2a07dc41, 0x696b6962, 0x620a676e, 0x8264726f, 0x6c612377, 0x0a860b6c, 0x6e6f6e24, 0x0b860f65, 0x706f7426, 0x66656c2d, 0x2308714f, 0x67676964,
+    0x032c3582, 0x056e6166, 0x6e6f6369, 0x68700a73, 0x2d242e82, 0x70696c66, 0x89073660, 0x261c8311, 0x662d6f74, 0x6a6d6c69, 0x7321059c, 0x60b3826c,
+    0x7a220bfc, 0xfc60612d, 0x610c8209, 0x73290b42, 0x74726f68, 0x6469772d, 0x09426165, 0x458b1389, 0x312d3922, 0x0c824589, 0x730b2108, 0x6c6c6570,
+    0x6568632d, 0x76096b63, 0x6563696f, 0x6c69616d, 0x7461680a, 0x776f632d, 0x0f796f62, 0x2d210a89, 0x21608273, 0xb477630e, 0x2d210806, 0x73756f6d,
+    0x61720565, 0x0c6f6964, 0x6f636572, 0x762d6472, 0x6c796e69, 0x6c61770d, 0x2d65696b, 0x28068474, 0x72616307, 0x6e617661, 0x3ffa0500, 0x00870e0b,
+};
+
+ rlImGui/extras/IconsFontAwesome6.h view
@@ -0,0 +1,1396 @@+// Generated by https://github.com/juliettef/IconFontCppHeaders script GenerateIconFontCppHeaders.py for languages C and C++
+// from https://github.com/FortAwesome/Font-Awesome/raw/6.x/metadata/icons.yml
+// for use with https://github.com/FortAwesome/Font-Awesome/blob/6.x/webfonts/fa-regular-400.ttf, https://github.com/FortAwesome/Font-Awesome/blob/6.x/webfonts/fa-solid-900.ttf
+#pragma once
+
+#define FONT_ICON_FILE_NAME_FAR "fa-regular-400.ttf"
+#define FONT_ICON_FILE_NAME_FAS "fa-solid-900.ttf"
+
+#define ICON_MIN_FA 0xe005
+#define ICON_MAX_16_FA 0xf8ff
+#define ICON_MAX_FA 0xf8ff
+#define ICON_FA_0 "0"	// U+0030
+#define ICON_FA_1 "1"	// U+0031
+#define ICON_FA_2 "2"	// U+0032
+#define ICON_FA_3 "3"	// U+0033
+#define ICON_FA_4 "4"	// U+0034
+#define ICON_FA_5 "5"	// U+0035
+#define ICON_FA_6 "6"	// U+0036
+#define ICON_FA_7 "7"	// U+0037
+#define ICON_FA_8 "8"	// U+0038
+#define ICON_FA_9 "9"	// U+0039
+#define ICON_FA_A "A"	// U+0041
+#define ICON_FA_ADDRESS_BOOK "\xef\x8a\xb9"	// U+f2b9
+#define ICON_FA_ADDRESS_CARD "\xef\x8a\xbb"	// U+f2bb
+#define ICON_FA_ALIGN_CENTER "\xef\x80\xb7"	// U+f037
+#define ICON_FA_ALIGN_JUSTIFY "\xef\x80\xb9"	// U+f039
+#define ICON_FA_ALIGN_LEFT "\xef\x80\xb6"	// U+f036
+#define ICON_FA_ALIGN_RIGHT "\xef\x80\xb8"	// U+f038
+#define ICON_FA_ANCHOR "\xef\x84\xbd"	// U+f13d
+#define ICON_FA_ANCHOR_CIRCLE_CHECK "\xee\x92\xaa"	// U+e4aa
+#define ICON_FA_ANCHOR_CIRCLE_EXCLAMATION "\xee\x92\xab"	// U+e4ab
+#define ICON_FA_ANCHOR_CIRCLE_XMARK "\xee\x92\xac"	// U+e4ac
+#define ICON_FA_ANCHOR_LOCK "\xee\x92\xad"	// U+e4ad
+#define ICON_FA_ANGLE_DOWN "\xef\x84\x87"	// U+f107
+#define ICON_FA_ANGLE_LEFT "\xef\x84\x84"	// U+f104
+#define ICON_FA_ANGLE_RIGHT "\xef\x84\x85"	// U+f105
+#define ICON_FA_ANGLE_UP "\xef\x84\x86"	// U+f106
+#define ICON_FA_ANGLES_DOWN "\xef\x84\x83"	// U+f103
+#define ICON_FA_ANGLES_LEFT "\xef\x84\x80"	// U+f100
+#define ICON_FA_ANGLES_RIGHT "\xef\x84\x81"	// U+f101
+#define ICON_FA_ANGLES_UP "\xef\x84\x82"	// U+f102
+#define ICON_FA_ANKH "\xef\x99\x84"	// U+f644
+#define ICON_FA_APPLE_WHOLE "\xef\x97\x91"	// U+f5d1
+#define ICON_FA_ARCHWAY "\xef\x95\x97"	// U+f557
+#define ICON_FA_ARROW_DOWN "\xef\x81\xa3"	// U+f063
+#define ICON_FA_ARROW_DOWN_1_9 "\xef\x85\xa2"	// U+f162
+#define ICON_FA_ARROW_DOWN_9_1 "\xef\xa2\x86"	// U+f886
+#define ICON_FA_ARROW_DOWN_A_Z "\xef\x85\x9d"	// U+f15d
+#define ICON_FA_ARROW_DOWN_LONG "\xef\x85\xb5"	// U+f175
+#define ICON_FA_ARROW_DOWN_SHORT_WIDE "\xef\xa2\x84"	// U+f884
+#define ICON_FA_ARROW_DOWN_UP_ACROSS_LINE "\xee\x92\xaf"	// U+e4af
+#define ICON_FA_ARROW_DOWN_UP_LOCK "\xee\x92\xb0"	// U+e4b0
+#define ICON_FA_ARROW_DOWN_WIDE_SHORT "\xef\x85\xa0"	// U+f160
+#define ICON_FA_ARROW_DOWN_Z_A "\xef\xa2\x81"	// U+f881
+#define ICON_FA_ARROW_LEFT "\xef\x81\xa0"	// U+f060
+#define ICON_FA_ARROW_LEFT_LONG "\xef\x85\xb7"	// U+f177
+#define ICON_FA_ARROW_POINTER "\xef\x89\x85"	// U+f245
+#define ICON_FA_ARROW_RIGHT "\xef\x81\xa1"	// U+f061
+#define ICON_FA_ARROW_RIGHT_ARROW_LEFT "\xef\x83\xac"	// U+f0ec
+#define ICON_FA_ARROW_RIGHT_FROM_BRACKET "\xef\x82\x8b"	// U+f08b
+#define ICON_FA_ARROW_RIGHT_LONG "\xef\x85\xb8"	// U+f178
+#define ICON_FA_ARROW_RIGHT_TO_BRACKET "\xef\x82\x90"	// U+f090
+#define ICON_FA_ARROW_RIGHT_TO_CITY "\xee\x92\xb3"	// U+e4b3
+#define ICON_FA_ARROW_ROTATE_LEFT "\xef\x83\xa2"	// U+f0e2
+#define ICON_FA_ARROW_ROTATE_RIGHT "\xef\x80\x9e"	// U+f01e
+#define ICON_FA_ARROW_TREND_DOWN "\xee\x82\x97"	// U+e097
+#define ICON_FA_ARROW_TREND_UP "\xee\x82\x98"	// U+e098
+#define ICON_FA_ARROW_TURN_DOWN "\xef\x85\x89"	// U+f149
+#define ICON_FA_ARROW_TURN_UP "\xef\x85\x88"	// U+f148
+#define ICON_FA_ARROW_UP "\xef\x81\xa2"	// U+f062
+#define ICON_FA_ARROW_UP_1_9 "\xef\x85\xa3"	// U+f163
+#define ICON_FA_ARROW_UP_9_1 "\xef\xa2\x87"	// U+f887
+#define ICON_FA_ARROW_UP_A_Z "\xef\x85\x9e"	// U+f15e
+#define ICON_FA_ARROW_UP_FROM_BRACKET "\xee\x82\x9a"	// U+e09a
+#define ICON_FA_ARROW_UP_FROM_GROUND_WATER "\xee\x92\xb5"	// U+e4b5
+#define ICON_FA_ARROW_UP_FROM_WATER_PUMP "\xee\x92\xb6"	// U+e4b6
+#define ICON_FA_ARROW_UP_LONG "\xef\x85\xb6"	// U+f176
+#define ICON_FA_ARROW_UP_RIGHT_DOTS "\xee\x92\xb7"	// U+e4b7
+#define ICON_FA_ARROW_UP_RIGHT_FROM_SQUARE "\xef\x82\x8e"	// U+f08e
+#define ICON_FA_ARROW_UP_SHORT_WIDE "\xef\xa2\x85"	// U+f885
+#define ICON_FA_ARROW_UP_WIDE_SHORT "\xef\x85\xa1"	// U+f161
+#define ICON_FA_ARROW_UP_Z_A "\xef\xa2\x82"	// U+f882
+#define ICON_FA_ARROWS_DOWN_TO_LINE "\xee\x92\xb8"	// U+e4b8
+#define ICON_FA_ARROWS_DOWN_TO_PEOPLE "\xee\x92\xb9"	// U+e4b9
+#define ICON_FA_ARROWS_LEFT_RIGHT "\xef\x81\xbe"	// U+f07e
+#define ICON_FA_ARROWS_LEFT_RIGHT_TO_LINE "\xee\x92\xba"	// U+e4ba
+#define ICON_FA_ARROWS_ROTATE "\xef\x80\xa1"	// U+f021
+#define ICON_FA_ARROWS_SPIN "\xee\x92\xbb"	// U+e4bb
+#define ICON_FA_ARROWS_SPLIT_UP_AND_LEFT "\xee\x92\xbc"	// U+e4bc
+#define ICON_FA_ARROWS_TO_CIRCLE "\xee\x92\xbd"	// U+e4bd
+#define ICON_FA_ARROWS_TO_DOT "\xee\x92\xbe"	// U+e4be
+#define ICON_FA_ARROWS_TO_EYE "\xee\x92\xbf"	// U+e4bf
+#define ICON_FA_ARROWS_TURN_RIGHT "\xee\x93\x80"	// U+e4c0
+#define ICON_FA_ARROWS_TURN_TO_DOTS "\xee\x93\x81"	// U+e4c1
+#define ICON_FA_ARROWS_UP_DOWN "\xef\x81\xbd"	// U+f07d
+#define ICON_FA_ARROWS_UP_DOWN_LEFT_RIGHT "\xef\x81\x87"	// U+f047
+#define ICON_FA_ARROWS_UP_TO_LINE "\xee\x93\x82"	// U+e4c2
+#define ICON_FA_ASTERISK "*"	// U+002a
+#define ICON_FA_AT "@"	// U+0040
+#define ICON_FA_ATOM "\xef\x97\x92"	// U+f5d2
+#define ICON_FA_AUDIO_DESCRIPTION "\xef\x8a\x9e"	// U+f29e
+#define ICON_FA_AUSTRAL_SIGN "\xee\x82\xa9"	// U+e0a9
+#define ICON_FA_AWARD "\xef\x95\x99"	// U+f559
+#define ICON_FA_B "B"	// U+0042
+#define ICON_FA_BABY "\xef\x9d\xbc"	// U+f77c
+#define ICON_FA_BABY_CARRIAGE "\xef\x9d\xbd"	// U+f77d
+#define ICON_FA_BACKWARD "\xef\x81\x8a"	// U+f04a
+#define ICON_FA_BACKWARD_FAST "\xef\x81\x89"	// U+f049
+#define ICON_FA_BACKWARD_STEP "\xef\x81\x88"	// U+f048
+#define ICON_FA_BACON "\xef\x9f\xa5"	// U+f7e5
+#define ICON_FA_BACTERIA "\xee\x81\x99"	// U+e059
+#define ICON_FA_BACTERIUM "\xee\x81\x9a"	// U+e05a
+#define ICON_FA_BAG_SHOPPING "\xef\x8a\x90"	// U+f290
+#define ICON_FA_BAHAI "\xef\x99\xa6"	// U+f666
+#define ICON_FA_BAHT_SIGN "\xee\x82\xac"	// U+e0ac
+#define ICON_FA_BAN "\xef\x81\x9e"	// U+f05e
+#define ICON_FA_BAN_SMOKING "\xef\x95\x8d"	// U+f54d
+#define ICON_FA_BANDAGE "\xef\x91\xa2"	// U+f462
+#define ICON_FA_BARCODE "\xef\x80\xaa"	// U+f02a
+#define ICON_FA_BARS "\xef\x83\x89"	// U+f0c9
+#define ICON_FA_BARS_PROGRESS "\xef\xa0\xa8"	// U+f828
+#define ICON_FA_BARS_STAGGERED "\xef\x95\x90"	// U+f550
+#define ICON_FA_BASEBALL "\xef\x90\xb3"	// U+f433
+#define ICON_FA_BASEBALL_BAT_BALL "\xef\x90\xb2"	// U+f432
+#define ICON_FA_BASKET_SHOPPING "\xef\x8a\x91"	// U+f291
+#define ICON_FA_BASKETBALL "\xef\x90\xb4"	// U+f434
+#define ICON_FA_BATH "\xef\x8b\x8d"	// U+f2cd
+#define ICON_FA_BATTERY_EMPTY "\xef\x89\x84"	// U+f244
+#define ICON_FA_BATTERY_FULL "\xef\x89\x80"	// U+f240
+#define ICON_FA_BATTERY_HALF "\xef\x89\x82"	// U+f242
+#define ICON_FA_BATTERY_QUARTER "\xef\x89\x83"	// U+f243
+#define ICON_FA_BATTERY_THREE_QUARTERS "\xef\x89\x81"	// U+f241
+#define ICON_FA_BED "\xef\x88\xb6"	// U+f236
+#define ICON_FA_BED_PULSE "\xef\x92\x87"	// U+f487
+#define ICON_FA_BEER_MUG_EMPTY "\xef\x83\xbc"	// U+f0fc
+#define ICON_FA_BELL "\xef\x83\xb3"	// U+f0f3
+#define ICON_FA_BELL_CONCIERGE "\xef\x95\xa2"	// U+f562
+#define ICON_FA_BELL_SLASH "\xef\x87\xb6"	// U+f1f6
+#define ICON_FA_BEZIER_CURVE "\xef\x95\x9b"	// U+f55b
+#define ICON_FA_BICYCLE "\xef\x88\x86"	// U+f206
+#define ICON_FA_BINOCULARS "\xef\x87\xa5"	// U+f1e5
+#define ICON_FA_BIOHAZARD "\xef\x9e\x80"	// U+f780
+#define ICON_FA_BITCOIN_SIGN "\xee\x82\xb4"	// U+e0b4
+#define ICON_FA_BLENDER "\xef\x94\x97"	// U+f517
+#define ICON_FA_BLENDER_PHONE "\xef\x9a\xb6"	// U+f6b6
+#define ICON_FA_BLOG "\xef\x9e\x81"	// U+f781
+#define ICON_FA_BOLD "\xef\x80\xb2"	// U+f032
+#define ICON_FA_BOLT "\xef\x83\xa7"	// U+f0e7
+#define ICON_FA_BOLT_LIGHTNING "\xee\x82\xb7"	// U+e0b7
+#define ICON_FA_BOMB "\xef\x87\xa2"	// U+f1e2
+#define ICON_FA_BONE "\xef\x97\x97"	// U+f5d7
+#define ICON_FA_BONG "\xef\x95\x9c"	// U+f55c
+#define ICON_FA_BOOK "\xef\x80\xad"	// U+f02d
+#define ICON_FA_BOOK_ATLAS "\xef\x95\x98"	// U+f558
+#define ICON_FA_BOOK_BIBLE "\xef\x99\x87"	// U+f647
+#define ICON_FA_BOOK_BOOKMARK "\xee\x82\xbb"	// U+e0bb
+#define ICON_FA_BOOK_JOURNAL_WHILLS "\xef\x99\xaa"	// U+f66a
+#define ICON_FA_BOOK_MEDICAL "\xef\x9f\xa6"	// U+f7e6
+#define ICON_FA_BOOK_OPEN "\xef\x94\x98"	// U+f518
+#define ICON_FA_BOOK_OPEN_READER "\xef\x97\x9a"	// U+f5da
+#define ICON_FA_BOOK_QURAN "\xef\x9a\x87"	// U+f687
+#define ICON_FA_BOOK_SKULL "\xef\x9a\xb7"	// U+f6b7
+#define ICON_FA_BOOKMARK "\xef\x80\xae"	// U+f02e
+#define ICON_FA_BORDER_ALL "\xef\xa1\x8c"	// U+f84c
+#define ICON_FA_BORDER_NONE "\xef\xa1\x90"	// U+f850
+#define ICON_FA_BORDER_TOP_LEFT "\xef\xa1\x93"	// U+f853
+#define ICON_FA_BORE_HOLE "\xee\x93\x83"	// U+e4c3
+#define ICON_FA_BOTTLE_DROPLET "\xee\x93\x84"	// U+e4c4
+#define ICON_FA_BOTTLE_WATER "\xee\x93\x85"	// U+e4c5
+#define ICON_FA_BOWL_FOOD "\xee\x93\x86"	// U+e4c6
+#define ICON_FA_BOWL_RICE "\xee\x8b\xab"	// U+e2eb
+#define ICON_FA_BOWLING_BALL "\xef\x90\xb6"	// U+f436
+#define ICON_FA_BOX "\xef\x91\xa6"	// U+f466
+#define ICON_FA_BOX_ARCHIVE "\xef\x86\x87"	// U+f187
+#define ICON_FA_BOX_OPEN "\xef\x92\x9e"	// U+f49e
+#define ICON_FA_BOX_TISSUE "\xee\x81\x9b"	// U+e05b
+#define ICON_FA_BOXES_PACKING "\xee\x93\x87"	// U+e4c7
+#define ICON_FA_BOXES_STACKED "\xef\x91\xa8"	// U+f468
+#define ICON_FA_BRAILLE "\xef\x8a\xa1"	// U+f2a1
+#define ICON_FA_BRAIN "\xef\x97\x9c"	// U+f5dc
+#define ICON_FA_BRAZILIAN_REAL_SIGN "\xee\x91\xac"	// U+e46c
+#define ICON_FA_BREAD_SLICE "\xef\x9f\xac"	// U+f7ec
+#define ICON_FA_BRIDGE "\xee\x93\x88"	// U+e4c8
+#define ICON_FA_BRIDGE_CIRCLE_CHECK "\xee\x93\x89"	// U+e4c9
+#define ICON_FA_BRIDGE_CIRCLE_EXCLAMATION "\xee\x93\x8a"	// U+e4ca
+#define ICON_FA_BRIDGE_CIRCLE_XMARK "\xee\x93\x8b"	// U+e4cb
+#define ICON_FA_BRIDGE_LOCK "\xee\x93\x8c"	// U+e4cc
+#define ICON_FA_BRIDGE_WATER "\xee\x93\x8e"	// U+e4ce
+#define ICON_FA_BRIEFCASE "\xef\x82\xb1"	// U+f0b1
+#define ICON_FA_BRIEFCASE_MEDICAL "\xef\x91\xa9"	// U+f469
+#define ICON_FA_BROOM "\xef\x94\x9a"	// U+f51a
+#define ICON_FA_BROOM_BALL "\xef\x91\x98"	// U+f458
+#define ICON_FA_BRUSH "\xef\x95\x9d"	// U+f55d
+#define ICON_FA_BUCKET "\xee\x93\x8f"	// U+e4cf
+#define ICON_FA_BUG "\xef\x86\x88"	// U+f188
+#define ICON_FA_BUG_SLASH "\xee\x92\x90"	// U+e490
+#define ICON_FA_BUGS "\xee\x93\x90"	// U+e4d0
+#define ICON_FA_BUILDING "\xef\x86\xad"	// U+f1ad
+#define ICON_FA_BUILDING_CIRCLE_ARROW_RIGHT "\xee\x93\x91"	// U+e4d1
+#define ICON_FA_BUILDING_CIRCLE_CHECK "\xee\x93\x92"	// U+e4d2
+#define ICON_FA_BUILDING_CIRCLE_EXCLAMATION "\xee\x93\x93"	// U+e4d3
+#define ICON_FA_BUILDING_CIRCLE_XMARK "\xee\x93\x94"	// U+e4d4
+#define ICON_FA_BUILDING_COLUMNS "\xef\x86\x9c"	// U+f19c
+#define ICON_FA_BUILDING_FLAG "\xee\x93\x95"	// U+e4d5
+#define ICON_FA_BUILDING_LOCK "\xee\x93\x96"	// U+e4d6
+#define ICON_FA_BUILDING_NGO "\xee\x93\x97"	// U+e4d7
+#define ICON_FA_BUILDING_SHIELD "\xee\x93\x98"	// U+e4d8
+#define ICON_FA_BUILDING_UN "\xee\x93\x99"	// U+e4d9
+#define ICON_FA_BUILDING_USER "\xee\x93\x9a"	// U+e4da
+#define ICON_FA_BUILDING_WHEAT "\xee\x93\x9b"	// U+e4db
+#define ICON_FA_BULLHORN "\xef\x82\xa1"	// U+f0a1
+#define ICON_FA_BULLSEYE "\xef\x85\x80"	// U+f140
+#define ICON_FA_BURGER "\xef\xa0\x85"	// U+f805
+#define ICON_FA_BURST "\xee\x93\x9c"	// U+e4dc
+#define ICON_FA_BUS "\xef\x88\x87"	// U+f207
+#define ICON_FA_BUS_SIMPLE "\xef\x95\x9e"	// U+f55e
+#define ICON_FA_BUSINESS_TIME "\xef\x99\x8a"	// U+f64a
+#define ICON_FA_C "C"	// U+0043
+#define ICON_FA_CAKE_CANDLES "\xef\x87\xbd"	// U+f1fd
+#define ICON_FA_CALCULATOR "\xef\x87\xac"	// U+f1ec
+#define ICON_FA_CALENDAR "\xef\x84\xb3"	// U+f133
+#define ICON_FA_CALENDAR_CHECK "\xef\x89\xb4"	// U+f274
+#define ICON_FA_CALENDAR_DAY "\xef\x9e\x83"	// U+f783
+#define ICON_FA_CALENDAR_DAYS "\xef\x81\xb3"	// U+f073
+#define ICON_FA_CALENDAR_MINUS "\xef\x89\xb2"	// U+f272
+#define ICON_FA_CALENDAR_PLUS "\xef\x89\xb1"	// U+f271
+#define ICON_FA_CALENDAR_WEEK "\xef\x9e\x84"	// U+f784
+#define ICON_FA_CALENDAR_XMARK "\xef\x89\xb3"	// U+f273
+#define ICON_FA_CAMERA "\xef\x80\xb0"	// U+f030
+#define ICON_FA_CAMERA_RETRO "\xef\x82\x83"	// U+f083
+#define ICON_FA_CAMERA_ROTATE "\xee\x83\x98"	// U+e0d8
+#define ICON_FA_CAMPGROUND "\xef\x9a\xbb"	// U+f6bb
+#define ICON_FA_CANDY_CANE "\xef\x9e\x86"	// U+f786
+#define ICON_FA_CANNABIS "\xef\x95\x9f"	// U+f55f
+#define ICON_FA_CAPSULES "\xef\x91\xab"	// U+f46b
+#define ICON_FA_CAR "\xef\x86\xb9"	// U+f1b9
+#define ICON_FA_CAR_BATTERY "\xef\x97\x9f"	// U+f5df
+#define ICON_FA_CAR_BURST "\xef\x97\xa1"	// U+f5e1
+#define ICON_FA_CAR_ON "\xee\x93\x9d"	// U+e4dd
+#define ICON_FA_CAR_REAR "\xef\x97\x9e"	// U+f5de
+#define ICON_FA_CAR_SIDE "\xef\x97\xa4"	// U+f5e4
+#define ICON_FA_CAR_TUNNEL "\xee\x93\x9e"	// U+e4de
+#define ICON_FA_CARAVAN "\xef\xa3\xbf"	// U+f8ff
+#define ICON_FA_CARET_DOWN "\xef\x83\x97"	// U+f0d7
+#define ICON_FA_CARET_LEFT "\xef\x83\x99"	// U+f0d9
+#define ICON_FA_CARET_RIGHT "\xef\x83\x9a"	// U+f0da
+#define ICON_FA_CARET_UP "\xef\x83\x98"	// U+f0d8
+#define ICON_FA_CARROT "\xef\x9e\x87"	// U+f787
+#define ICON_FA_CART_ARROW_DOWN "\xef\x88\x98"	// U+f218
+#define ICON_FA_CART_FLATBED "\xef\x91\xb4"	// U+f474
+#define ICON_FA_CART_FLATBED_SUITCASE "\xef\x96\x9d"	// U+f59d
+#define ICON_FA_CART_PLUS "\xef\x88\x97"	// U+f217
+#define ICON_FA_CART_SHOPPING "\xef\x81\xba"	// U+f07a
+#define ICON_FA_CASH_REGISTER "\xef\x9e\x88"	// U+f788
+#define ICON_FA_CAT "\xef\x9a\xbe"	// U+f6be
+#define ICON_FA_CEDI_SIGN "\xee\x83\x9f"	// U+e0df
+#define ICON_FA_CENT_SIGN "\xee\x8f\xb5"	// U+e3f5
+#define ICON_FA_CERTIFICATE "\xef\x82\xa3"	// U+f0a3
+#define ICON_FA_CHAIR "\xef\x9b\x80"	// U+f6c0
+#define ICON_FA_CHALKBOARD "\xef\x94\x9b"	// U+f51b
+#define ICON_FA_CHALKBOARD_USER "\xef\x94\x9c"	// U+f51c
+#define ICON_FA_CHAMPAGNE_GLASSES "\xef\x9e\x9f"	// U+f79f
+#define ICON_FA_CHARGING_STATION "\xef\x97\xa7"	// U+f5e7
+#define ICON_FA_CHART_AREA "\xef\x87\xbe"	// U+f1fe
+#define ICON_FA_CHART_BAR "\xef\x82\x80"	// U+f080
+#define ICON_FA_CHART_COLUMN "\xee\x83\xa3"	// U+e0e3
+#define ICON_FA_CHART_GANTT "\xee\x83\xa4"	// U+e0e4
+#define ICON_FA_CHART_LINE "\xef\x88\x81"	// U+f201
+#define ICON_FA_CHART_PIE "\xef\x88\x80"	// U+f200
+#define ICON_FA_CHART_SIMPLE "\xee\x91\xb3"	// U+e473
+#define ICON_FA_CHECK "\xef\x80\x8c"	// U+f00c
+#define ICON_FA_CHECK_DOUBLE "\xef\x95\xa0"	// U+f560
+#define ICON_FA_CHECK_TO_SLOT "\xef\x9d\xb2"	// U+f772
+#define ICON_FA_CHEESE "\xef\x9f\xaf"	// U+f7ef
+#define ICON_FA_CHESS "\xef\x90\xb9"	// U+f439
+#define ICON_FA_CHESS_BISHOP "\xef\x90\xba"	// U+f43a
+#define ICON_FA_CHESS_BOARD "\xef\x90\xbc"	// U+f43c
+#define ICON_FA_CHESS_KING "\xef\x90\xbf"	// U+f43f
+#define ICON_FA_CHESS_KNIGHT "\xef\x91\x81"	// U+f441
+#define ICON_FA_CHESS_PAWN "\xef\x91\x83"	// U+f443
+#define ICON_FA_CHESS_QUEEN "\xef\x91\x85"	// U+f445
+#define ICON_FA_CHESS_ROOK "\xef\x91\x87"	// U+f447
+#define ICON_FA_CHEVRON_DOWN "\xef\x81\xb8"	// U+f078
+#define ICON_FA_CHEVRON_LEFT "\xef\x81\x93"	// U+f053
+#define ICON_FA_CHEVRON_RIGHT "\xef\x81\x94"	// U+f054
+#define ICON_FA_CHEVRON_UP "\xef\x81\xb7"	// U+f077
+#define ICON_FA_CHILD "\xef\x86\xae"	// U+f1ae
+#define ICON_FA_CHILD_DRESS "\xee\x96\x9c"	// U+e59c
+#define ICON_FA_CHILD_REACHING "\xee\x96\x9d"	// U+e59d
+#define ICON_FA_CHILD_RIFLE "\xee\x93\xa0"	// U+e4e0
+#define ICON_FA_CHILDREN "\xee\x93\xa1"	// U+e4e1
+#define ICON_FA_CHURCH "\xef\x94\x9d"	// U+f51d
+#define ICON_FA_CIRCLE "\xef\x84\x91"	// U+f111
+#define ICON_FA_CIRCLE_ARROW_DOWN "\xef\x82\xab"	// U+f0ab
+#define ICON_FA_CIRCLE_ARROW_LEFT "\xef\x82\xa8"	// U+f0a8
+#define ICON_FA_CIRCLE_ARROW_RIGHT "\xef\x82\xa9"	// U+f0a9
+#define ICON_FA_CIRCLE_ARROW_UP "\xef\x82\xaa"	// U+f0aa
+#define ICON_FA_CIRCLE_CHECK "\xef\x81\x98"	// U+f058
+#define ICON_FA_CIRCLE_CHEVRON_DOWN "\xef\x84\xba"	// U+f13a
+#define ICON_FA_CIRCLE_CHEVRON_LEFT "\xef\x84\xb7"	// U+f137
+#define ICON_FA_CIRCLE_CHEVRON_RIGHT "\xef\x84\xb8"	// U+f138
+#define ICON_FA_CIRCLE_CHEVRON_UP "\xef\x84\xb9"	// U+f139
+#define ICON_FA_CIRCLE_DOLLAR_TO_SLOT "\xef\x92\xb9"	// U+f4b9
+#define ICON_FA_CIRCLE_DOT "\xef\x86\x92"	// U+f192
+#define ICON_FA_CIRCLE_DOWN "\xef\x8d\x98"	// U+f358
+#define ICON_FA_CIRCLE_EXCLAMATION "\xef\x81\xaa"	// U+f06a
+#define ICON_FA_CIRCLE_H "\xef\x91\xbe"	// U+f47e
+#define ICON_FA_CIRCLE_HALF_STROKE "\xef\x81\x82"	// U+f042
+#define ICON_FA_CIRCLE_INFO "\xef\x81\x9a"	// U+f05a
+#define ICON_FA_CIRCLE_LEFT "\xef\x8d\x99"	// U+f359
+#define ICON_FA_CIRCLE_MINUS "\xef\x81\x96"	// U+f056
+#define ICON_FA_CIRCLE_NODES "\xee\x93\xa2"	// U+e4e2
+#define ICON_FA_CIRCLE_NOTCH "\xef\x87\x8e"	// U+f1ce
+#define ICON_FA_CIRCLE_PAUSE "\xef\x8a\x8b"	// U+f28b
+#define ICON_FA_CIRCLE_PLAY "\xef\x85\x84"	// U+f144
+#define ICON_FA_CIRCLE_PLUS "\xef\x81\x95"	// U+f055
+#define ICON_FA_CIRCLE_QUESTION "\xef\x81\x99"	// U+f059
+#define ICON_FA_CIRCLE_RADIATION "\xef\x9e\xba"	// U+f7ba
+#define ICON_FA_CIRCLE_RIGHT "\xef\x8d\x9a"	// U+f35a
+#define ICON_FA_CIRCLE_STOP "\xef\x8a\x8d"	// U+f28d
+#define ICON_FA_CIRCLE_UP "\xef\x8d\x9b"	// U+f35b
+#define ICON_FA_CIRCLE_USER "\xef\x8a\xbd"	// U+f2bd
+#define ICON_FA_CIRCLE_XMARK "\xef\x81\x97"	// U+f057
+#define ICON_FA_CITY "\xef\x99\x8f"	// U+f64f
+#define ICON_FA_CLAPPERBOARD "\xee\x84\xb1"	// U+e131
+#define ICON_FA_CLIPBOARD "\xef\x8c\xa8"	// U+f328
+#define ICON_FA_CLIPBOARD_CHECK "\xef\x91\xac"	// U+f46c
+#define ICON_FA_CLIPBOARD_LIST "\xef\x91\xad"	// U+f46d
+#define ICON_FA_CLIPBOARD_QUESTION "\xee\x93\xa3"	// U+e4e3
+#define ICON_FA_CLIPBOARD_USER "\xef\x9f\xb3"	// U+f7f3
+#define ICON_FA_CLOCK "\xef\x80\x97"	// U+f017
+#define ICON_FA_CLOCK_ROTATE_LEFT "\xef\x87\x9a"	// U+f1da
+#define ICON_FA_CLONE "\xef\x89\x8d"	// U+f24d
+#define ICON_FA_CLOSED_CAPTIONING "\xef\x88\x8a"	// U+f20a
+#define ICON_FA_CLOUD "\xef\x83\x82"	// U+f0c2
+#define ICON_FA_CLOUD_ARROW_DOWN "\xef\x83\xad"	// U+f0ed
+#define ICON_FA_CLOUD_ARROW_UP "\xef\x83\xae"	// U+f0ee
+#define ICON_FA_CLOUD_BOLT "\xef\x9d\xac"	// U+f76c
+#define ICON_FA_CLOUD_MEATBALL "\xef\x9c\xbb"	// U+f73b
+#define ICON_FA_CLOUD_MOON "\xef\x9b\x83"	// U+f6c3
+#define ICON_FA_CLOUD_MOON_RAIN "\xef\x9c\xbc"	// U+f73c
+#define ICON_FA_CLOUD_RAIN "\xef\x9c\xbd"	// U+f73d
+#define ICON_FA_CLOUD_SHOWERS_HEAVY "\xef\x9d\x80"	// U+f740
+#define ICON_FA_CLOUD_SHOWERS_WATER "\xee\x93\xa4"	// U+e4e4
+#define ICON_FA_CLOUD_SUN "\xef\x9b\x84"	// U+f6c4
+#define ICON_FA_CLOUD_SUN_RAIN "\xef\x9d\x83"	// U+f743
+#define ICON_FA_CLOVER "\xee\x84\xb9"	// U+e139
+#define ICON_FA_CODE "\xef\x84\xa1"	// U+f121
+#define ICON_FA_CODE_BRANCH "\xef\x84\xa6"	// U+f126
+#define ICON_FA_CODE_COMMIT "\xef\x8e\x86"	// U+f386
+#define ICON_FA_CODE_COMPARE "\xee\x84\xba"	// U+e13a
+#define ICON_FA_CODE_FORK "\xee\x84\xbb"	// U+e13b
+#define ICON_FA_CODE_MERGE "\xef\x8e\x87"	// U+f387
+#define ICON_FA_CODE_PULL_REQUEST "\xee\x84\xbc"	// U+e13c
+#define ICON_FA_COINS "\xef\x94\x9e"	// U+f51e
+#define ICON_FA_COLON_SIGN "\xee\x85\x80"	// U+e140
+#define ICON_FA_COMMENT "\xef\x81\xb5"	// U+f075
+#define ICON_FA_COMMENT_DOLLAR "\xef\x99\x91"	// U+f651
+#define ICON_FA_COMMENT_DOTS "\xef\x92\xad"	// U+f4ad
+#define ICON_FA_COMMENT_MEDICAL "\xef\x9f\xb5"	// U+f7f5
+#define ICON_FA_COMMENT_SLASH "\xef\x92\xb3"	// U+f4b3
+#define ICON_FA_COMMENT_SMS "\xef\x9f\x8d"	// U+f7cd
+#define ICON_FA_COMMENTS "\xef\x82\x86"	// U+f086
+#define ICON_FA_COMMENTS_DOLLAR "\xef\x99\x93"	// U+f653
+#define ICON_FA_COMPACT_DISC "\xef\x94\x9f"	// U+f51f
+#define ICON_FA_COMPASS "\xef\x85\x8e"	// U+f14e
+#define ICON_FA_COMPASS_DRAFTING "\xef\x95\xa8"	// U+f568
+#define ICON_FA_COMPRESS "\xef\x81\xa6"	// U+f066
+#define ICON_FA_COMPUTER "\xee\x93\xa5"	// U+e4e5
+#define ICON_FA_COMPUTER_MOUSE "\xef\xa3\x8c"	// U+f8cc
+#define ICON_FA_COOKIE "\xef\x95\xa3"	// U+f563
+#define ICON_FA_COOKIE_BITE "\xef\x95\xa4"	// U+f564
+#define ICON_FA_COPY "\xef\x83\x85"	// U+f0c5
+#define ICON_FA_COPYRIGHT "\xef\x87\xb9"	// U+f1f9
+#define ICON_FA_COUCH "\xef\x92\xb8"	// U+f4b8
+#define ICON_FA_COW "\xef\x9b\x88"	// U+f6c8
+#define ICON_FA_CREDIT_CARD "\xef\x82\x9d"	// U+f09d
+#define ICON_FA_CROP "\xef\x84\xa5"	// U+f125
+#define ICON_FA_CROP_SIMPLE "\xef\x95\xa5"	// U+f565
+#define ICON_FA_CROSS "\xef\x99\x94"	// U+f654
+#define ICON_FA_CROSSHAIRS "\xef\x81\x9b"	// U+f05b
+#define ICON_FA_CROW "\xef\x94\xa0"	// U+f520
+#define ICON_FA_CROWN "\xef\x94\xa1"	// U+f521
+#define ICON_FA_CRUTCH "\xef\x9f\xb7"	// U+f7f7
+#define ICON_FA_CRUZEIRO_SIGN "\xee\x85\x92"	// U+e152
+#define ICON_FA_CUBE "\xef\x86\xb2"	// U+f1b2
+#define ICON_FA_CUBES "\xef\x86\xb3"	// U+f1b3
+#define ICON_FA_CUBES_STACKED "\xee\x93\xa6"	// U+e4e6
+#define ICON_FA_D "D"	// U+0044
+#define ICON_FA_DATABASE "\xef\x87\x80"	// U+f1c0
+#define ICON_FA_DELETE_LEFT "\xef\x95\x9a"	// U+f55a
+#define ICON_FA_DEMOCRAT "\xef\x9d\x87"	// U+f747
+#define ICON_FA_DESKTOP "\xef\x8e\x90"	// U+f390
+#define ICON_FA_DHARMACHAKRA "\xef\x99\x95"	// U+f655
+#define ICON_FA_DIAGRAM_NEXT "\xee\x91\xb6"	// U+e476
+#define ICON_FA_DIAGRAM_PREDECESSOR "\xee\x91\xb7"	// U+e477
+#define ICON_FA_DIAGRAM_PROJECT "\xef\x95\x82"	// U+f542
+#define ICON_FA_DIAGRAM_SUCCESSOR "\xee\x91\xba"	// U+e47a
+#define ICON_FA_DIAMOND "\xef\x88\x99"	// U+f219
+#define ICON_FA_DIAMOND_TURN_RIGHT "\xef\x97\xab"	// U+f5eb
+#define ICON_FA_DICE "\xef\x94\xa2"	// U+f522
+#define ICON_FA_DICE_D20 "\xef\x9b\x8f"	// U+f6cf
+#define ICON_FA_DICE_D6 "\xef\x9b\x91"	// U+f6d1
+#define ICON_FA_DICE_FIVE "\xef\x94\xa3"	// U+f523
+#define ICON_FA_DICE_FOUR "\xef\x94\xa4"	// U+f524
+#define ICON_FA_DICE_ONE "\xef\x94\xa5"	// U+f525
+#define ICON_FA_DICE_SIX "\xef\x94\xa6"	// U+f526
+#define ICON_FA_DICE_THREE "\xef\x94\xa7"	// U+f527
+#define ICON_FA_DICE_TWO "\xef\x94\xa8"	// U+f528
+#define ICON_FA_DISEASE "\xef\x9f\xba"	// U+f7fa
+#define ICON_FA_DISPLAY "\xee\x85\xa3"	// U+e163
+#define ICON_FA_DIVIDE "\xef\x94\xa9"	// U+f529
+#define ICON_FA_DNA "\xef\x91\xb1"	// U+f471
+#define ICON_FA_DOG "\xef\x9b\x93"	// U+f6d3
+#define ICON_FA_DOLLAR_SIGN "$"	// U+0024
+#define ICON_FA_DOLLY "\xef\x91\xb2"	// U+f472
+#define ICON_FA_DONG_SIGN "\xee\x85\xa9"	// U+e169
+#define ICON_FA_DOOR_CLOSED "\xef\x94\xaa"	// U+f52a
+#define ICON_FA_DOOR_OPEN "\xef\x94\xab"	// U+f52b
+#define ICON_FA_DOVE "\xef\x92\xba"	// U+f4ba
+#define ICON_FA_DOWN_LEFT_AND_UP_RIGHT_TO_CENTER "\xef\x90\xa2"	// U+f422
+#define ICON_FA_DOWN_LONG "\xef\x8c\x89"	// U+f309
+#define ICON_FA_DOWNLOAD "\xef\x80\x99"	// U+f019
+#define ICON_FA_DRAGON "\xef\x9b\x95"	// U+f6d5
+#define ICON_FA_DRAW_POLYGON "\xef\x97\xae"	// U+f5ee
+#define ICON_FA_DROPLET "\xef\x81\x83"	// U+f043
+#define ICON_FA_DROPLET_SLASH "\xef\x97\x87"	// U+f5c7
+#define ICON_FA_DRUM "\xef\x95\xa9"	// U+f569
+#define ICON_FA_DRUM_STEELPAN "\xef\x95\xaa"	// U+f56a
+#define ICON_FA_DRUMSTICK_BITE "\xef\x9b\x97"	// U+f6d7
+#define ICON_FA_DUMBBELL "\xef\x91\x8b"	// U+f44b
+#define ICON_FA_DUMPSTER "\xef\x9e\x93"	// U+f793
+#define ICON_FA_DUMPSTER_FIRE "\xef\x9e\x94"	// U+f794
+#define ICON_FA_DUNGEON "\xef\x9b\x99"	// U+f6d9
+#define ICON_FA_E "E"	// U+0045
+#define ICON_FA_EAR_DEAF "\xef\x8a\xa4"	// U+f2a4
+#define ICON_FA_EAR_LISTEN "\xef\x8a\xa2"	// U+f2a2
+#define ICON_FA_EARTH_AFRICA "\xef\x95\xbc"	// U+f57c
+#define ICON_FA_EARTH_AMERICAS "\xef\x95\xbd"	// U+f57d
+#define ICON_FA_EARTH_ASIA "\xef\x95\xbe"	// U+f57e
+#define ICON_FA_EARTH_EUROPE "\xef\x9e\xa2"	// U+f7a2
+#define ICON_FA_EARTH_OCEANIA "\xee\x91\xbb"	// U+e47b
+#define ICON_FA_EGG "\xef\x9f\xbb"	// U+f7fb
+#define ICON_FA_EJECT "\xef\x81\x92"	// U+f052
+#define ICON_FA_ELEVATOR "\xee\x85\xad"	// U+e16d
+#define ICON_FA_ELLIPSIS "\xef\x85\x81"	// U+f141
+#define ICON_FA_ELLIPSIS_VERTICAL "\xef\x85\x82"	// U+f142
+#define ICON_FA_ENVELOPE "\xef\x83\xa0"	// U+f0e0
+#define ICON_FA_ENVELOPE_CIRCLE_CHECK "\xee\x93\xa8"	// U+e4e8
+#define ICON_FA_ENVELOPE_OPEN "\xef\x8a\xb6"	// U+f2b6
+#define ICON_FA_ENVELOPE_OPEN_TEXT "\xef\x99\x98"	// U+f658
+#define ICON_FA_ENVELOPES_BULK "\xef\x99\xb4"	// U+f674
+#define ICON_FA_EQUALS "="	// U+003d
+#define ICON_FA_ERASER "\xef\x84\xad"	// U+f12d
+#define ICON_FA_ETHERNET "\xef\x9e\x96"	// U+f796
+#define ICON_FA_EURO_SIGN "\xef\x85\x93"	// U+f153
+#define ICON_FA_EXCLAMATION "!"	// U+0021
+#define ICON_FA_EXPAND "\xef\x81\xa5"	// U+f065
+#define ICON_FA_EXPLOSION "\xee\x93\xa9"	// U+e4e9
+#define ICON_FA_EYE "\xef\x81\xae"	// U+f06e
+#define ICON_FA_EYE_DROPPER "\xef\x87\xbb"	// U+f1fb
+#define ICON_FA_EYE_LOW_VISION "\xef\x8a\xa8"	// U+f2a8
+#define ICON_FA_EYE_SLASH "\xef\x81\xb0"	// U+f070
+#define ICON_FA_F "F"	// U+0046
+#define ICON_FA_FACE_ANGRY "\xef\x95\x96"	// U+f556
+#define ICON_FA_FACE_DIZZY "\xef\x95\xa7"	// U+f567
+#define ICON_FA_FACE_FLUSHED "\xef\x95\xb9"	// U+f579
+#define ICON_FA_FACE_FROWN "\xef\x84\x99"	// U+f119
+#define ICON_FA_FACE_FROWN_OPEN "\xef\x95\xba"	// U+f57a
+#define ICON_FA_FACE_GRIMACE "\xef\x95\xbf"	// U+f57f
+#define ICON_FA_FACE_GRIN "\xef\x96\x80"	// U+f580
+#define ICON_FA_FACE_GRIN_BEAM "\xef\x96\x82"	// U+f582
+#define ICON_FA_FACE_GRIN_BEAM_SWEAT "\xef\x96\x83"	// U+f583
+#define ICON_FA_FACE_GRIN_HEARTS "\xef\x96\x84"	// U+f584
+#define ICON_FA_FACE_GRIN_SQUINT "\xef\x96\x85"	// U+f585
+#define ICON_FA_FACE_GRIN_SQUINT_TEARS "\xef\x96\x86"	// U+f586
+#define ICON_FA_FACE_GRIN_STARS "\xef\x96\x87"	// U+f587
+#define ICON_FA_FACE_GRIN_TEARS "\xef\x96\x88"	// U+f588
+#define ICON_FA_FACE_GRIN_TONGUE "\xef\x96\x89"	// U+f589
+#define ICON_FA_FACE_GRIN_TONGUE_SQUINT "\xef\x96\x8a"	// U+f58a
+#define ICON_FA_FACE_GRIN_TONGUE_WINK "\xef\x96\x8b"	// U+f58b
+#define ICON_FA_FACE_GRIN_WIDE "\xef\x96\x81"	// U+f581
+#define ICON_FA_FACE_GRIN_WINK "\xef\x96\x8c"	// U+f58c
+#define ICON_FA_FACE_KISS "\xef\x96\x96"	// U+f596
+#define ICON_FA_FACE_KISS_BEAM "\xef\x96\x97"	// U+f597
+#define ICON_FA_FACE_KISS_WINK_HEART "\xef\x96\x98"	// U+f598
+#define ICON_FA_FACE_LAUGH "\xef\x96\x99"	// U+f599
+#define ICON_FA_FACE_LAUGH_BEAM "\xef\x96\x9a"	// U+f59a
+#define ICON_FA_FACE_LAUGH_SQUINT "\xef\x96\x9b"	// U+f59b
+#define ICON_FA_FACE_LAUGH_WINK "\xef\x96\x9c"	// U+f59c
+#define ICON_FA_FACE_MEH "\xef\x84\x9a"	// U+f11a
+#define ICON_FA_FACE_MEH_BLANK "\xef\x96\xa4"	// U+f5a4
+#define ICON_FA_FACE_ROLLING_EYES "\xef\x96\xa5"	// U+f5a5
+#define ICON_FA_FACE_SAD_CRY "\xef\x96\xb3"	// U+f5b3
+#define ICON_FA_FACE_SAD_TEAR "\xef\x96\xb4"	// U+f5b4
+#define ICON_FA_FACE_SMILE "\xef\x84\x98"	// U+f118
+#define ICON_FA_FACE_SMILE_BEAM "\xef\x96\xb8"	// U+f5b8
+#define ICON_FA_FACE_SMILE_WINK "\xef\x93\x9a"	// U+f4da
+#define ICON_FA_FACE_SURPRISE "\xef\x97\x82"	// U+f5c2
+#define ICON_FA_FACE_TIRED "\xef\x97\x88"	// U+f5c8
+#define ICON_FA_FAN "\xef\xa1\xa3"	// U+f863
+#define ICON_FA_FAUCET "\xee\x80\x85"	// U+e005
+#define ICON_FA_FAUCET_DRIP "\xee\x80\x86"	// U+e006
+#define ICON_FA_FAX "\xef\x86\xac"	// U+f1ac
+#define ICON_FA_FEATHER "\xef\x94\xad"	// U+f52d
+#define ICON_FA_FEATHER_POINTED "\xef\x95\xab"	// U+f56b
+#define ICON_FA_FERRY "\xee\x93\xaa"	// U+e4ea
+#define ICON_FA_FILE "\xef\x85\x9b"	// U+f15b
+#define ICON_FA_FILE_ARROW_DOWN "\xef\x95\xad"	// U+f56d
+#define ICON_FA_FILE_ARROW_UP "\xef\x95\xb4"	// U+f574
+#define ICON_FA_FILE_AUDIO "\xef\x87\x87"	// U+f1c7
+#define ICON_FA_FILE_CIRCLE_CHECK "\xee\x92\x93"	// U+e493
+#define ICON_FA_FILE_CIRCLE_EXCLAMATION "\xee\x93\xab"	// U+e4eb
+#define ICON_FA_FILE_CIRCLE_MINUS "\xee\x93\xad"	// U+e4ed
+#define ICON_FA_FILE_CIRCLE_PLUS "\xee\x93\xae"	// U+e4ee
+#define ICON_FA_FILE_CIRCLE_QUESTION "\xee\x93\xaf"	// U+e4ef
+#define ICON_FA_FILE_CIRCLE_XMARK "\xee\x92\x94"	// U+e494
+#define ICON_FA_FILE_CODE "\xef\x87\x89"	// U+f1c9
+#define ICON_FA_FILE_CONTRACT "\xef\x95\xac"	// U+f56c
+#define ICON_FA_FILE_CSV "\xef\x9b\x9d"	// U+f6dd
+#define ICON_FA_FILE_EXCEL "\xef\x87\x83"	// U+f1c3
+#define ICON_FA_FILE_EXPORT "\xef\x95\xae"	// U+f56e
+#define ICON_FA_FILE_IMAGE "\xef\x87\x85"	// U+f1c5
+#define ICON_FA_FILE_IMPORT "\xef\x95\xaf"	// U+f56f
+#define ICON_FA_FILE_INVOICE "\xef\x95\xb0"	// U+f570
+#define ICON_FA_FILE_INVOICE_DOLLAR "\xef\x95\xb1"	// U+f571
+#define ICON_FA_FILE_LINES "\xef\x85\x9c"	// U+f15c
+#define ICON_FA_FILE_MEDICAL "\xef\x91\xb7"	// U+f477
+#define ICON_FA_FILE_PDF "\xef\x87\x81"	// U+f1c1
+#define ICON_FA_FILE_PEN "\xef\x8c\x9c"	// U+f31c
+#define ICON_FA_FILE_POWERPOINT "\xef\x87\x84"	// U+f1c4
+#define ICON_FA_FILE_PRESCRIPTION "\xef\x95\xb2"	// U+f572
+#define ICON_FA_FILE_SHIELD "\xee\x93\xb0"	// U+e4f0
+#define ICON_FA_FILE_SIGNATURE "\xef\x95\xb3"	// U+f573
+#define ICON_FA_FILE_VIDEO "\xef\x87\x88"	// U+f1c8
+#define ICON_FA_FILE_WAVEFORM "\xef\x91\xb8"	// U+f478
+#define ICON_FA_FILE_WORD "\xef\x87\x82"	// U+f1c2
+#define ICON_FA_FILE_ZIPPER "\xef\x87\x86"	// U+f1c6
+#define ICON_FA_FILL "\xef\x95\xb5"	// U+f575
+#define ICON_FA_FILL_DRIP "\xef\x95\xb6"	// U+f576
+#define ICON_FA_FILM "\xef\x80\x88"	// U+f008
+#define ICON_FA_FILTER "\xef\x82\xb0"	// U+f0b0
+#define ICON_FA_FILTER_CIRCLE_DOLLAR "\xef\x99\xa2"	// U+f662
+#define ICON_FA_FILTER_CIRCLE_XMARK "\xee\x85\xbb"	// U+e17b
+#define ICON_FA_FINGERPRINT "\xef\x95\xb7"	// U+f577
+#define ICON_FA_FIRE "\xef\x81\xad"	// U+f06d
+#define ICON_FA_FIRE_BURNER "\xee\x93\xb1"	// U+e4f1
+#define ICON_FA_FIRE_EXTINGUISHER "\xef\x84\xb4"	// U+f134
+#define ICON_FA_FIRE_FLAME_CURVED "\xef\x9f\xa4"	// U+f7e4
+#define ICON_FA_FIRE_FLAME_SIMPLE "\xef\x91\xaa"	// U+f46a
+#define ICON_FA_FISH "\xef\x95\xb8"	// U+f578
+#define ICON_FA_FISH_FINS "\xee\x93\xb2"	// U+e4f2
+#define ICON_FA_FLAG "\xef\x80\xa4"	// U+f024
+#define ICON_FA_FLAG_CHECKERED "\xef\x84\x9e"	// U+f11e
+#define ICON_FA_FLAG_USA "\xef\x9d\x8d"	// U+f74d
+#define ICON_FA_FLASK "\xef\x83\x83"	// U+f0c3
+#define ICON_FA_FLASK_VIAL "\xee\x93\xb3"	// U+e4f3
+#define ICON_FA_FLOPPY_DISK "\xef\x83\x87"	// U+f0c7
+#define ICON_FA_FLORIN_SIGN "\xee\x86\x84"	// U+e184
+#define ICON_FA_FOLDER "\xef\x81\xbb"	// U+f07b
+#define ICON_FA_FOLDER_CLOSED "\xee\x86\x85"	// U+e185
+#define ICON_FA_FOLDER_MINUS "\xef\x99\x9d"	// U+f65d
+#define ICON_FA_FOLDER_OPEN "\xef\x81\xbc"	// U+f07c
+#define ICON_FA_FOLDER_PLUS "\xef\x99\x9e"	// U+f65e
+#define ICON_FA_FOLDER_TREE "\xef\xa0\x82"	// U+f802
+#define ICON_FA_FONT "\xef\x80\xb1"	// U+f031
+#define ICON_FA_FONT_AWESOME "\xef\x8a\xb4"	// U+f2b4
+#define ICON_FA_FOOTBALL "\xef\x91\x8e"	// U+f44e
+#define ICON_FA_FORWARD "\xef\x81\x8e"	// U+f04e
+#define ICON_FA_FORWARD_FAST "\xef\x81\x90"	// U+f050
+#define ICON_FA_FORWARD_STEP "\xef\x81\x91"	// U+f051
+#define ICON_FA_FRANC_SIGN "\xee\x86\x8f"	// U+e18f
+#define ICON_FA_FROG "\xef\x94\xae"	// U+f52e
+#define ICON_FA_FUTBOL "\xef\x87\xa3"	// U+f1e3
+#define ICON_FA_G "G"	// U+0047
+#define ICON_FA_GAMEPAD "\xef\x84\x9b"	// U+f11b
+#define ICON_FA_GAS_PUMP "\xef\x94\xaf"	// U+f52f
+#define ICON_FA_GAUGE "\xef\x98\xa4"	// U+f624
+#define ICON_FA_GAUGE_HIGH "\xef\x98\xa5"	// U+f625
+#define ICON_FA_GAUGE_SIMPLE "\xef\x98\xa9"	// U+f629
+#define ICON_FA_GAUGE_SIMPLE_HIGH "\xef\x98\xaa"	// U+f62a
+#define ICON_FA_GAVEL "\xef\x83\xa3"	// U+f0e3
+#define ICON_FA_GEAR "\xef\x80\x93"	// U+f013
+#define ICON_FA_GEARS "\xef\x82\x85"	// U+f085
+#define ICON_FA_GEM "\xef\x8e\xa5"	// U+f3a5
+#define ICON_FA_GENDERLESS "\xef\x88\xad"	// U+f22d
+#define ICON_FA_GHOST "\xef\x9b\xa2"	// U+f6e2
+#define ICON_FA_GIFT "\xef\x81\xab"	// U+f06b
+#define ICON_FA_GIFTS "\xef\x9e\x9c"	// U+f79c
+#define ICON_FA_GLASS_WATER "\xee\x93\xb4"	// U+e4f4
+#define ICON_FA_GLASS_WATER_DROPLET "\xee\x93\xb5"	// U+e4f5
+#define ICON_FA_GLASSES "\xef\x94\xb0"	// U+f530
+#define ICON_FA_GLOBE "\xef\x82\xac"	// U+f0ac
+#define ICON_FA_GOLF_BALL_TEE "\xef\x91\x90"	// U+f450
+#define ICON_FA_GOPURAM "\xef\x99\xa4"	// U+f664
+#define ICON_FA_GRADUATION_CAP "\xef\x86\x9d"	// U+f19d
+#define ICON_FA_GREATER_THAN ">"	// U+003e
+#define ICON_FA_GREATER_THAN_EQUAL "\xef\x94\xb2"	// U+f532
+#define ICON_FA_GRIP "\xef\x96\x8d"	// U+f58d
+#define ICON_FA_GRIP_LINES "\xef\x9e\xa4"	// U+f7a4
+#define ICON_FA_GRIP_LINES_VERTICAL "\xef\x9e\xa5"	// U+f7a5
+#define ICON_FA_GRIP_VERTICAL "\xef\x96\x8e"	// U+f58e
+#define ICON_FA_GROUP_ARROWS_ROTATE "\xee\x93\xb6"	// U+e4f6
+#define ICON_FA_GUARANI_SIGN "\xee\x86\x9a"	// U+e19a
+#define ICON_FA_GUITAR "\xef\x9e\xa6"	// U+f7a6
+#define ICON_FA_GUN "\xee\x86\x9b"	// U+e19b
+#define ICON_FA_H "H"	// U+0048
+#define ICON_FA_HAMMER "\xef\x9b\xa3"	// U+f6e3
+#define ICON_FA_HAMSA "\xef\x99\xa5"	// U+f665
+#define ICON_FA_HAND "\xef\x89\x96"	// U+f256
+#define ICON_FA_HAND_BACK_FIST "\xef\x89\x95"	// U+f255
+#define ICON_FA_HAND_DOTS "\xef\x91\xa1"	// U+f461
+#define ICON_FA_HAND_FIST "\xef\x9b\x9e"	// U+f6de
+#define ICON_FA_HAND_HOLDING "\xef\x92\xbd"	// U+f4bd
+#define ICON_FA_HAND_HOLDING_DOLLAR "\xef\x93\x80"	// U+f4c0
+#define ICON_FA_HAND_HOLDING_DROPLET "\xef\x93\x81"	// U+f4c1
+#define ICON_FA_HAND_HOLDING_HAND "\xee\x93\xb7"	// U+e4f7
+#define ICON_FA_HAND_HOLDING_HEART "\xef\x92\xbe"	// U+f4be
+#define ICON_FA_HAND_HOLDING_MEDICAL "\xee\x81\x9c"	// U+e05c
+#define ICON_FA_HAND_LIZARD "\xef\x89\x98"	// U+f258
+#define ICON_FA_HAND_MIDDLE_FINGER "\xef\xa0\x86"	// U+f806
+#define ICON_FA_HAND_PEACE "\xef\x89\x9b"	// U+f25b
+#define ICON_FA_HAND_POINT_DOWN "\xef\x82\xa7"	// U+f0a7
+#define ICON_FA_HAND_POINT_LEFT "\xef\x82\xa5"	// U+f0a5
+#define ICON_FA_HAND_POINT_RIGHT "\xef\x82\xa4"	// U+f0a4
+#define ICON_FA_HAND_POINT_UP "\xef\x82\xa6"	// U+f0a6
+#define ICON_FA_HAND_POINTER "\xef\x89\x9a"	// U+f25a
+#define ICON_FA_HAND_SCISSORS "\xef\x89\x97"	// U+f257
+#define ICON_FA_HAND_SPARKLES "\xee\x81\x9d"	// U+e05d
+#define ICON_FA_HAND_SPOCK "\xef\x89\x99"	// U+f259
+#define ICON_FA_HANDCUFFS "\xee\x93\xb8"	// U+e4f8
+#define ICON_FA_HANDS "\xef\x8a\xa7"	// U+f2a7
+#define ICON_FA_HANDS_ASL_INTERPRETING "\xef\x8a\xa3"	// U+f2a3
+#define ICON_FA_HANDS_BOUND "\xee\x93\xb9"	// U+e4f9
+#define ICON_FA_HANDS_BUBBLES "\xee\x81\x9e"	// U+e05e
+#define ICON_FA_HANDS_CLAPPING "\xee\x86\xa8"	// U+e1a8
+#define ICON_FA_HANDS_HOLDING "\xef\x93\x82"	// U+f4c2
+#define ICON_FA_HANDS_HOLDING_CHILD "\xee\x93\xba"	// U+e4fa
+#define ICON_FA_HANDS_HOLDING_CIRCLE "\xee\x93\xbb"	// U+e4fb
+#define ICON_FA_HANDS_PRAYING "\xef\x9a\x84"	// U+f684
+#define ICON_FA_HANDSHAKE "\xef\x8a\xb5"	// U+f2b5
+#define ICON_FA_HANDSHAKE_ANGLE "\xef\x93\x84"	// U+f4c4
+#define ICON_FA_HANDSHAKE_SIMPLE "\xef\x93\x86"	// U+f4c6
+#define ICON_FA_HANDSHAKE_SIMPLE_SLASH "\xee\x81\x9f"	// U+e05f
+#define ICON_FA_HANDSHAKE_SLASH "\xee\x81\xa0"	// U+e060
+#define ICON_FA_HANUKIAH "\xef\x9b\xa6"	// U+f6e6
+#define ICON_FA_HARD_DRIVE "\xef\x82\xa0"	// U+f0a0
+#define ICON_FA_HASHTAG "#"	// U+0023
+#define ICON_FA_HAT_COWBOY "\xef\xa3\x80"	// U+f8c0
+#define ICON_FA_HAT_COWBOY_SIDE "\xef\xa3\x81"	// U+f8c1
+#define ICON_FA_HAT_WIZARD "\xef\x9b\xa8"	// U+f6e8
+#define ICON_FA_HEAD_SIDE_COUGH "\xee\x81\xa1"	// U+e061
+#define ICON_FA_HEAD_SIDE_COUGH_SLASH "\xee\x81\xa2"	// U+e062
+#define ICON_FA_HEAD_SIDE_MASK "\xee\x81\xa3"	// U+e063
+#define ICON_FA_HEAD_SIDE_VIRUS "\xee\x81\xa4"	// U+e064
+#define ICON_FA_HEADING "\xef\x87\x9c"	// U+f1dc
+#define ICON_FA_HEADPHONES "\xef\x80\xa5"	// U+f025
+#define ICON_FA_HEADPHONES_SIMPLE "\xef\x96\x8f"	// U+f58f
+#define ICON_FA_HEADSET "\xef\x96\x90"	// U+f590
+#define ICON_FA_HEART "\xef\x80\x84"	// U+f004
+#define ICON_FA_HEART_CIRCLE_BOLT "\xee\x93\xbc"	// U+e4fc
+#define ICON_FA_HEART_CIRCLE_CHECK "\xee\x93\xbd"	// U+e4fd
+#define ICON_FA_HEART_CIRCLE_EXCLAMATION "\xee\x93\xbe"	// U+e4fe
+#define ICON_FA_HEART_CIRCLE_MINUS "\xee\x93\xbf"	// U+e4ff
+#define ICON_FA_HEART_CIRCLE_PLUS "\xee\x94\x80"	// U+e500
+#define ICON_FA_HEART_CIRCLE_XMARK "\xee\x94\x81"	// U+e501
+#define ICON_FA_HEART_CRACK "\xef\x9e\xa9"	// U+f7a9
+#define ICON_FA_HEART_PULSE "\xef\x88\x9e"	// U+f21e
+#define ICON_FA_HELICOPTER "\xef\x94\xb3"	// U+f533
+#define ICON_FA_HELICOPTER_SYMBOL "\xee\x94\x82"	// U+e502
+#define ICON_FA_HELMET_SAFETY "\xef\xa0\x87"	// U+f807
+#define ICON_FA_HELMET_UN "\xee\x94\x83"	// U+e503
+#define ICON_FA_HIGHLIGHTER "\xef\x96\x91"	// U+f591
+#define ICON_FA_HILL_AVALANCHE "\xee\x94\x87"	// U+e507
+#define ICON_FA_HILL_ROCKSLIDE "\xee\x94\x88"	// U+e508
+#define ICON_FA_HIPPO "\xef\x9b\xad"	// U+f6ed
+#define ICON_FA_HOCKEY_PUCK "\xef\x91\x93"	// U+f453
+#define ICON_FA_HOLLY_BERRY "\xef\x9e\xaa"	// U+f7aa
+#define ICON_FA_HORSE "\xef\x9b\xb0"	// U+f6f0
+#define ICON_FA_HORSE_HEAD "\xef\x9e\xab"	// U+f7ab
+#define ICON_FA_HOSPITAL "\xef\x83\xb8"	// U+f0f8
+#define ICON_FA_HOSPITAL_USER "\xef\xa0\x8d"	// U+f80d
+#define ICON_FA_HOT_TUB_PERSON "\xef\x96\x93"	// U+f593
+#define ICON_FA_HOTDOG "\xef\xa0\x8f"	// U+f80f
+#define ICON_FA_HOTEL "\xef\x96\x94"	// U+f594
+#define ICON_FA_HOURGLASS "\xef\x89\x94"	// U+f254
+#define ICON_FA_HOURGLASS_EMPTY "\xef\x89\x92"	// U+f252
+#define ICON_FA_HOURGLASS_END "\xef\x89\x93"	// U+f253
+#define ICON_FA_HOURGLASS_START "\xef\x89\x91"	// U+f251
+#define ICON_FA_HOUSE "\xef\x80\x95"	// U+f015
+#define ICON_FA_HOUSE_CHIMNEY "\xee\x8e\xaf"	// U+e3af
+#define ICON_FA_HOUSE_CHIMNEY_CRACK "\xef\x9b\xb1"	// U+f6f1
+#define ICON_FA_HOUSE_CHIMNEY_MEDICAL "\xef\x9f\xb2"	// U+f7f2
+#define ICON_FA_HOUSE_CHIMNEY_USER "\xee\x81\xa5"	// U+e065
+#define ICON_FA_HOUSE_CHIMNEY_WINDOW "\xee\x80\x8d"	// U+e00d
+#define ICON_FA_HOUSE_CIRCLE_CHECK "\xee\x94\x89"	// U+e509
+#define ICON_FA_HOUSE_CIRCLE_EXCLAMATION "\xee\x94\x8a"	// U+e50a
+#define ICON_FA_HOUSE_CIRCLE_XMARK "\xee\x94\x8b"	// U+e50b
+#define ICON_FA_HOUSE_CRACK "\xee\x8e\xb1"	// U+e3b1
+#define ICON_FA_HOUSE_FIRE "\xee\x94\x8c"	// U+e50c
+#define ICON_FA_HOUSE_FLAG "\xee\x94\x8d"	// U+e50d
+#define ICON_FA_HOUSE_FLOOD_WATER "\xee\x94\x8e"	// U+e50e
+#define ICON_FA_HOUSE_FLOOD_WATER_CIRCLE_ARROW_RIGHT "\xee\x94\x8f"	// U+e50f
+#define ICON_FA_HOUSE_LAPTOP "\xee\x81\xa6"	// U+e066
+#define ICON_FA_HOUSE_LOCK "\xee\x94\x90"	// U+e510
+#define ICON_FA_HOUSE_MEDICAL "\xee\x8e\xb2"	// U+e3b2
+#define ICON_FA_HOUSE_MEDICAL_CIRCLE_CHECK "\xee\x94\x91"	// U+e511
+#define ICON_FA_HOUSE_MEDICAL_CIRCLE_EXCLAMATION "\xee\x94\x92"	// U+e512
+#define ICON_FA_HOUSE_MEDICAL_CIRCLE_XMARK "\xee\x94\x93"	// U+e513
+#define ICON_FA_HOUSE_MEDICAL_FLAG "\xee\x94\x94"	// U+e514
+#define ICON_FA_HOUSE_SIGNAL "\xee\x80\x92"	// U+e012
+#define ICON_FA_HOUSE_TSUNAMI "\xee\x94\x95"	// U+e515
+#define ICON_FA_HOUSE_USER "\xee\x86\xb0"	// U+e1b0
+#define ICON_FA_HRYVNIA_SIGN "\xef\x9b\xb2"	// U+f6f2
+#define ICON_FA_HURRICANE "\xef\x9d\x91"	// U+f751
+#define ICON_FA_I "I"	// U+0049
+#define ICON_FA_I_CURSOR "\xef\x89\x86"	// U+f246
+#define ICON_FA_ICE_CREAM "\xef\xa0\x90"	// U+f810
+#define ICON_FA_ICICLES "\xef\x9e\xad"	// U+f7ad
+#define ICON_FA_ICONS "\xef\xa1\xad"	// U+f86d
+#define ICON_FA_ID_BADGE "\xef\x8b\x81"	// U+f2c1
+#define ICON_FA_ID_CARD "\xef\x8b\x82"	// U+f2c2
+#define ICON_FA_ID_CARD_CLIP "\xef\x91\xbf"	// U+f47f
+#define ICON_FA_IGLOO "\xef\x9e\xae"	// U+f7ae
+#define ICON_FA_IMAGE "\xef\x80\xbe"	// U+f03e
+#define ICON_FA_IMAGE_PORTRAIT "\xef\x8f\xa0"	// U+f3e0
+#define ICON_FA_IMAGES "\xef\x8c\x82"	// U+f302
+#define ICON_FA_INBOX "\xef\x80\x9c"	// U+f01c
+#define ICON_FA_INDENT "\xef\x80\xbc"	// U+f03c
+#define ICON_FA_INDIAN_RUPEE_SIGN "\xee\x86\xbc"	// U+e1bc
+#define ICON_FA_INDUSTRY "\xef\x89\xb5"	// U+f275
+#define ICON_FA_INFINITY "\xef\x94\xb4"	// U+f534
+#define ICON_FA_INFO "\xef\x84\xa9"	// U+f129
+#define ICON_FA_ITALIC "\xef\x80\xb3"	// U+f033
+#define ICON_FA_J "J"	// U+004a
+#define ICON_FA_JAR "\xee\x94\x96"	// U+e516
+#define ICON_FA_JAR_WHEAT "\xee\x94\x97"	// U+e517
+#define ICON_FA_JEDI "\xef\x99\xa9"	// U+f669
+#define ICON_FA_JET_FIGHTER "\xef\x83\xbb"	// U+f0fb
+#define ICON_FA_JET_FIGHTER_UP "\xee\x94\x98"	// U+e518
+#define ICON_FA_JOINT "\xef\x96\x95"	// U+f595
+#define ICON_FA_JUG_DETERGENT "\xee\x94\x99"	// U+e519
+#define ICON_FA_K "K"	// U+004b
+#define ICON_FA_KAABA "\xef\x99\xab"	// U+f66b
+#define ICON_FA_KEY "\xef\x82\x84"	// U+f084
+#define ICON_FA_KEYBOARD "\xef\x84\x9c"	// U+f11c
+#define ICON_FA_KHANDA "\xef\x99\xad"	// U+f66d
+#define ICON_FA_KIP_SIGN "\xee\x87\x84"	// U+e1c4
+#define ICON_FA_KIT_MEDICAL "\xef\x91\xb9"	// U+f479
+#define ICON_FA_KITCHEN_SET "\xee\x94\x9a"	// U+e51a
+#define ICON_FA_KIWI_BIRD "\xef\x94\xb5"	// U+f535
+#define ICON_FA_L "L"	// U+004c
+#define ICON_FA_LAND_MINE_ON "\xee\x94\x9b"	// U+e51b
+#define ICON_FA_LANDMARK "\xef\x99\xaf"	// U+f66f
+#define ICON_FA_LANDMARK_DOME "\xef\x9d\x92"	// U+f752
+#define ICON_FA_LANDMARK_FLAG "\xee\x94\x9c"	// U+e51c
+#define ICON_FA_LANGUAGE "\xef\x86\xab"	// U+f1ab
+#define ICON_FA_LAPTOP "\xef\x84\x89"	// U+f109
+#define ICON_FA_LAPTOP_CODE "\xef\x97\xbc"	// U+f5fc
+#define ICON_FA_LAPTOP_FILE "\xee\x94\x9d"	// U+e51d
+#define ICON_FA_LAPTOP_MEDICAL "\xef\xa0\x92"	// U+f812
+#define ICON_FA_LARI_SIGN "\xee\x87\x88"	// U+e1c8
+#define ICON_FA_LAYER_GROUP "\xef\x97\xbd"	// U+f5fd
+#define ICON_FA_LEAF "\xef\x81\xac"	// U+f06c
+#define ICON_FA_LEFT_LONG "\xef\x8c\x8a"	// U+f30a
+#define ICON_FA_LEFT_RIGHT "\xef\x8c\xb7"	// U+f337
+#define ICON_FA_LEMON "\xef\x82\x94"	// U+f094
+#define ICON_FA_LESS_THAN "<"	// U+003c
+#define ICON_FA_LESS_THAN_EQUAL "\xef\x94\xb7"	// U+f537
+#define ICON_FA_LIFE_RING "\xef\x87\x8d"	// U+f1cd
+#define ICON_FA_LIGHTBULB "\xef\x83\xab"	// U+f0eb
+#define ICON_FA_LINES_LEANING "\xee\x94\x9e"	// U+e51e
+#define ICON_FA_LINK "\xef\x83\x81"	// U+f0c1
+#define ICON_FA_LINK_SLASH "\xef\x84\xa7"	// U+f127
+#define ICON_FA_LIRA_SIGN "\xef\x86\x95"	// U+f195
+#define ICON_FA_LIST "\xef\x80\xba"	// U+f03a
+#define ICON_FA_LIST_CHECK "\xef\x82\xae"	// U+f0ae
+#define ICON_FA_LIST_OL "\xef\x83\x8b"	// U+f0cb
+#define ICON_FA_LIST_UL "\xef\x83\x8a"	// U+f0ca
+#define ICON_FA_LITECOIN_SIGN "\xee\x87\x93"	// U+e1d3
+#define ICON_FA_LOCATION_ARROW "\xef\x84\xa4"	// U+f124
+#define ICON_FA_LOCATION_CROSSHAIRS "\xef\x98\x81"	// U+f601
+#define ICON_FA_LOCATION_DOT "\xef\x8f\x85"	// U+f3c5
+#define ICON_FA_LOCATION_PIN "\xef\x81\x81"	// U+f041
+#define ICON_FA_LOCATION_PIN_LOCK "\xee\x94\x9f"	// U+e51f
+#define ICON_FA_LOCK "\xef\x80\xa3"	// U+f023
+#define ICON_FA_LOCK_OPEN "\xef\x8f\x81"	// U+f3c1
+#define ICON_FA_LOCUST "\xee\x94\xa0"	// U+e520
+#define ICON_FA_LUNGS "\xef\x98\x84"	// U+f604
+#define ICON_FA_LUNGS_VIRUS "\xee\x81\xa7"	// U+e067
+#define ICON_FA_M "M"	// U+004d
+#define ICON_FA_MAGNET "\xef\x81\xb6"	// U+f076
+#define ICON_FA_MAGNIFYING_GLASS "\xef\x80\x82"	// U+f002
+#define ICON_FA_MAGNIFYING_GLASS_ARROW_RIGHT "\xee\x94\xa1"	// U+e521
+#define ICON_FA_MAGNIFYING_GLASS_CHART "\xee\x94\xa2"	// U+e522
+#define ICON_FA_MAGNIFYING_GLASS_DOLLAR "\xef\x9a\x88"	// U+f688
+#define ICON_FA_MAGNIFYING_GLASS_LOCATION "\xef\x9a\x89"	// U+f689
+#define ICON_FA_MAGNIFYING_GLASS_MINUS "\xef\x80\x90"	// U+f010
+#define ICON_FA_MAGNIFYING_GLASS_PLUS "\xef\x80\x8e"	// U+f00e
+#define ICON_FA_MANAT_SIGN "\xee\x87\x95"	// U+e1d5
+#define ICON_FA_MAP "\xef\x89\xb9"	// U+f279
+#define ICON_FA_MAP_LOCATION "\xef\x96\x9f"	// U+f59f
+#define ICON_FA_MAP_LOCATION_DOT "\xef\x96\xa0"	// U+f5a0
+#define ICON_FA_MAP_PIN "\xef\x89\xb6"	// U+f276
+#define ICON_FA_MARKER "\xef\x96\xa1"	// U+f5a1
+#define ICON_FA_MARS "\xef\x88\xa2"	// U+f222
+#define ICON_FA_MARS_AND_VENUS "\xef\x88\xa4"	// U+f224
+#define ICON_FA_MARS_AND_VENUS_BURST "\xee\x94\xa3"	// U+e523
+#define ICON_FA_MARS_DOUBLE "\xef\x88\xa7"	// U+f227
+#define ICON_FA_MARS_STROKE "\xef\x88\xa9"	// U+f229
+#define ICON_FA_MARS_STROKE_RIGHT "\xef\x88\xab"	// U+f22b
+#define ICON_FA_MARS_STROKE_UP "\xef\x88\xaa"	// U+f22a
+#define ICON_FA_MARTINI_GLASS "\xef\x95\xbb"	// U+f57b
+#define ICON_FA_MARTINI_GLASS_CITRUS "\xef\x95\xa1"	// U+f561
+#define ICON_FA_MARTINI_GLASS_EMPTY "\xef\x80\x80"	// U+f000
+#define ICON_FA_MASK "\xef\x9b\xba"	// U+f6fa
+#define ICON_FA_MASK_FACE "\xee\x87\x97"	// U+e1d7
+#define ICON_FA_MASK_VENTILATOR "\xee\x94\xa4"	// U+e524
+#define ICON_FA_MASKS_THEATER "\xef\x98\xb0"	// U+f630
+#define ICON_FA_MATTRESS_PILLOW "\xee\x94\xa5"	// U+e525
+#define ICON_FA_MAXIMIZE "\xef\x8c\x9e"	// U+f31e
+#define ICON_FA_MEDAL "\xef\x96\xa2"	// U+f5a2
+#define ICON_FA_MEMORY "\xef\x94\xb8"	// U+f538
+#define ICON_FA_MENORAH "\xef\x99\xb6"	// U+f676
+#define ICON_FA_MERCURY "\xef\x88\xa3"	// U+f223
+#define ICON_FA_MESSAGE "\xef\x89\xba"	// U+f27a
+#define ICON_FA_METEOR "\xef\x9d\x93"	// U+f753
+#define ICON_FA_MICROCHIP "\xef\x8b\x9b"	// U+f2db
+#define ICON_FA_MICROPHONE "\xef\x84\xb0"	// U+f130
+#define ICON_FA_MICROPHONE_LINES "\xef\x8f\x89"	// U+f3c9
+#define ICON_FA_MICROPHONE_LINES_SLASH "\xef\x94\xb9"	// U+f539
+#define ICON_FA_MICROPHONE_SLASH "\xef\x84\xb1"	// U+f131
+#define ICON_FA_MICROSCOPE "\xef\x98\x90"	// U+f610
+#define ICON_FA_MILL_SIGN "\xee\x87\xad"	// U+e1ed
+#define ICON_FA_MINIMIZE "\xef\x9e\x8c"	// U+f78c
+#define ICON_FA_MINUS "\xef\x81\xa8"	// U+f068
+#define ICON_FA_MITTEN "\xef\x9e\xb5"	// U+f7b5
+#define ICON_FA_MOBILE "\xef\x8f\x8e"	// U+f3ce
+#define ICON_FA_MOBILE_BUTTON "\xef\x84\x8b"	// U+f10b
+#define ICON_FA_MOBILE_RETRO "\xee\x94\xa7"	// U+e527
+#define ICON_FA_MOBILE_SCREEN "\xef\x8f\x8f"	// U+f3cf
+#define ICON_FA_MOBILE_SCREEN_BUTTON "\xef\x8f\x8d"	// U+f3cd
+#define ICON_FA_MONEY_BILL "\xef\x83\x96"	// U+f0d6
+#define ICON_FA_MONEY_BILL_1 "\xef\x8f\x91"	// U+f3d1
+#define ICON_FA_MONEY_BILL_1_WAVE "\xef\x94\xbb"	// U+f53b
+#define ICON_FA_MONEY_BILL_TRANSFER "\xee\x94\xa8"	// U+e528
+#define ICON_FA_MONEY_BILL_TREND_UP "\xee\x94\xa9"	// U+e529
+#define ICON_FA_MONEY_BILL_WAVE "\xef\x94\xba"	// U+f53a
+#define ICON_FA_MONEY_BILL_WHEAT "\xee\x94\xaa"	// U+e52a
+#define ICON_FA_MONEY_BILLS "\xee\x87\xb3"	// U+e1f3
+#define ICON_FA_MONEY_CHECK "\xef\x94\xbc"	// U+f53c
+#define ICON_FA_MONEY_CHECK_DOLLAR "\xef\x94\xbd"	// U+f53d
+#define ICON_FA_MONUMENT "\xef\x96\xa6"	// U+f5a6
+#define ICON_FA_MOON "\xef\x86\x86"	// U+f186
+#define ICON_FA_MORTAR_PESTLE "\xef\x96\xa7"	// U+f5a7
+#define ICON_FA_MOSQUE "\xef\x99\xb8"	// U+f678
+#define ICON_FA_MOSQUITO "\xee\x94\xab"	// U+e52b
+#define ICON_FA_MOSQUITO_NET "\xee\x94\xac"	// U+e52c
+#define ICON_FA_MOTORCYCLE "\xef\x88\x9c"	// U+f21c
+#define ICON_FA_MOUND "\xee\x94\xad"	// U+e52d
+#define ICON_FA_MOUNTAIN "\xef\x9b\xbc"	// U+f6fc
+#define ICON_FA_MOUNTAIN_CITY "\xee\x94\xae"	// U+e52e
+#define ICON_FA_MOUNTAIN_SUN "\xee\x94\xaf"	// U+e52f
+#define ICON_FA_MUG_HOT "\xef\x9e\xb6"	// U+f7b6
+#define ICON_FA_MUG_SAUCER "\xef\x83\xb4"	// U+f0f4
+#define ICON_FA_MUSIC "\xef\x80\x81"	// U+f001
+#define ICON_FA_N "N"	// U+004e
+#define ICON_FA_NAIRA_SIGN "\xee\x87\xb6"	// U+e1f6
+#define ICON_FA_NETWORK_WIRED "\xef\x9b\xbf"	// U+f6ff
+#define ICON_FA_NEUTER "\xef\x88\xac"	// U+f22c
+#define ICON_FA_NEWSPAPER "\xef\x87\xaa"	// U+f1ea
+#define ICON_FA_NOT_EQUAL "\xef\x94\xbe"	// U+f53e
+#define ICON_FA_NOTE_STICKY "\xef\x89\x89"	// U+f249
+#define ICON_FA_NOTES_MEDICAL "\xef\x92\x81"	// U+f481
+#define ICON_FA_O "O"	// U+004f
+#define ICON_FA_OBJECT_GROUP "\xef\x89\x87"	// U+f247
+#define ICON_FA_OBJECT_UNGROUP "\xef\x89\x88"	// U+f248
+#define ICON_FA_OIL_CAN "\xef\x98\x93"	// U+f613
+#define ICON_FA_OIL_WELL "\xee\x94\xb2"	// U+e532
+#define ICON_FA_OM "\xef\x99\xb9"	// U+f679
+#define ICON_FA_OTTER "\xef\x9c\x80"	// U+f700
+#define ICON_FA_OUTDENT "\xef\x80\xbb"	// U+f03b
+#define ICON_FA_P "P"	// U+0050
+#define ICON_FA_PAGER "\xef\xa0\x95"	// U+f815
+#define ICON_FA_PAINT_ROLLER "\xef\x96\xaa"	// U+f5aa
+#define ICON_FA_PAINTBRUSH "\xef\x87\xbc"	// U+f1fc
+#define ICON_FA_PALETTE "\xef\x94\xbf"	// U+f53f
+#define ICON_FA_PALLET "\xef\x92\x82"	// U+f482
+#define ICON_FA_PANORAMA "\xee\x88\x89"	// U+e209
+#define ICON_FA_PAPER_PLANE "\xef\x87\x98"	// U+f1d8
+#define ICON_FA_PAPERCLIP "\xef\x83\x86"	// U+f0c6
+#define ICON_FA_PARACHUTE_BOX "\xef\x93\x8d"	// U+f4cd
+#define ICON_FA_PARAGRAPH "\xef\x87\x9d"	// U+f1dd
+#define ICON_FA_PASSPORT "\xef\x96\xab"	// U+f5ab
+#define ICON_FA_PASTE "\xef\x83\xaa"	// U+f0ea
+#define ICON_FA_PAUSE "\xef\x81\x8c"	// U+f04c
+#define ICON_FA_PAW "\xef\x86\xb0"	// U+f1b0
+#define ICON_FA_PEACE "\xef\x99\xbc"	// U+f67c
+#define ICON_FA_PEN "\xef\x8c\x84"	// U+f304
+#define ICON_FA_PEN_CLIP "\xef\x8c\x85"	// U+f305
+#define ICON_FA_PEN_FANCY "\xef\x96\xac"	// U+f5ac
+#define ICON_FA_PEN_NIB "\xef\x96\xad"	// U+f5ad
+#define ICON_FA_PEN_RULER "\xef\x96\xae"	// U+f5ae
+#define ICON_FA_PEN_TO_SQUARE "\xef\x81\x84"	// U+f044
+#define ICON_FA_PENCIL "\xef\x8c\x83"	// U+f303
+#define ICON_FA_PEOPLE_ARROWS_LEFT_RIGHT "\xee\x81\xa8"	// U+e068
+#define ICON_FA_PEOPLE_CARRY_BOX "\xef\x93\x8e"	// U+f4ce
+#define ICON_FA_PEOPLE_GROUP "\xee\x94\xb3"	// U+e533
+#define ICON_FA_PEOPLE_LINE "\xee\x94\xb4"	// U+e534
+#define ICON_FA_PEOPLE_PULLING "\xee\x94\xb5"	// U+e535
+#define ICON_FA_PEOPLE_ROBBERY "\xee\x94\xb6"	// U+e536
+#define ICON_FA_PEOPLE_ROOF "\xee\x94\xb7"	// U+e537
+#define ICON_FA_PEPPER_HOT "\xef\xa0\x96"	// U+f816
+#define ICON_FA_PERCENT "%"	// U+0025
+#define ICON_FA_PERSON "\xef\x86\x83"	// U+f183
+#define ICON_FA_PERSON_ARROW_DOWN_TO_LINE "\xee\x94\xb8"	// U+e538
+#define ICON_FA_PERSON_ARROW_UP_FROM_LINE "\xee\x94\xb9"	// U+e539
+#define ICON_FA_PERSON_BIKING "\xef\xa1\x8a"	// U+f84a
+#define ICON_FA_PERSON_BOOTH "\xef\x9d\x96"	// U+f756
+#define ICON_FA_PERSON_BREASTFEEDING "\xee\x94\xba"	// U+e53a
+#define ICON_FA_PERSON_BURST "\xee\x94\xbb"	// U+e53b
+#define ICON_FA_PERSON_CANE "\xee\x94\xbc"	// U+e53c
+#define ICON_FA_PERSON_CHALKBOARD "\xee\x94\xbd"	// U+e53d
+#define ICON_FA_PERSON_CIRCLE_CHECK "\xee\x94\xbe"	// U+e53e
+#define ICON_FA_PERSON_CIRCLE_EXCLAMATION "\xee\x94\xbf"	// U+e53f
+#define ICON_FA_PERSON_CIRCLE_MINUS "\xee\x95\x80"	// U+e540
+#define ICON_FA_PERSON_CIRCLE_PLUS "\xee\x95\x81"	// U+e541
+#define ICON_FA_PERSON_CIRCLE_QUESTION "\xee\x95\x82"	// U+e542
+#define ICON_FA_PERSON_CIRCLE_XMARK "\xee\x95\x83"	// U+e543
+#define ICON_FA_PERSON_DIGGING "\xef\xa1\x9e"	// U+f85e
+#define ICON_FA_PERSON_DOTS_FROM_LINE "\xef\x91\xb0"	// U+f470
+#define ICON_FA_PERSON_DRESS "\xef\x86\x82"	// U+f182
+#define ICON_FA_PERSON_DRESS_BURST "\xee\x95\x84"	// U+e544
+#define ICON_FA_PERSON_DROWNING "\xee\x95\x85"	// U+e545
+#define ICON_FA_PERSON_FALLING "\xee\x95\x86"	// U+e546
+#define ICON_FA_PERSON_FALLING_BURST "\xee\x95\x87"	// U+e547
+#define ICON_FA_PERSON_HALF_DRESS "\xee\x95\x88"	// U+e548
+#define ICON_FA_PERSON_HARASSING "\xee\x95\x89"	// U+e549
+#define ICON_FA_PERSON_HIKING "\xef\x9b\xac"	// U+f6ec
+#define ICON_FA_PERSON_MILITARY_POINTING "\xee\x95\x8a"	// U+e54a
+#define ICON_FA_PERSON_MILITARY_RIFLE "\xee\x95\x8b"	// U+e54b
+#define ICON_FA_PERSON_MILITARY_TO_PERSON "\xee\x95\x8c"	// U+e54c
+#define ICON_FA_PERSON_PRAYING "\xef\x9a\x83"	// U+f683
+#define ICON_FA_PERSON_PREGNANT "\xee\x8c\x9e"	// U+e31e
+#define ICON_FA_PERSON_RAYS "\xee\x95\x8d"	// U+e54d
+#define ICON_FA_PERSON_RIFLE "\xee\x95\x8e"	// U+e54e
+#define ICON_FA_PERSON_RUNNING "\xef\x9c\x8c"	// U+f70c
+#define ICON_FA_PERSON_SHELTER "\xee\x95\x8f"	// U+e54f
+#define ICON_FA_PERSON_SKATING "\xef\x9f\x85"	// U+f7c5
+#define ICON_FA_PERSON_SKIING "\xef\x9f\x89"	// U+f7c9
+#define ICON_FA_PERSON_SKIING_NORDIC "\xef\x9f\x8a"	// U+f7ca
+#define ICON_FA_PERSON_SNOWBOARDING "\xef\x9f\x8e"	// U+f7ce
+#define ICON_FA_PERSON_SWIMMING "\xef\x97\x84"	// U+f5c4
+#define ICON_FA_PERSON_THROUGH_WINDOW "\xee\x90\xb3"	// U+e433
+#define ICON_FA_PERSON_WALKING "\xef\x95\x94"	// U+f554
+#define ICON_FA_PERSON_WALKING_ARROW_LOOP_LEFT "\xee\x95\x91"	// U+e551
+#define ICON_FA_PERSON_WALKING_ARROW_RIGHT "\xee\x95\x92"	// U+e552
+#define ICON_FA_PERSON_WALKING_DASHED_LINE_ARROW_RIGHT "\xee\x95\x93"	// U+e553
+#define ICON_FA_PERSON_WALKING_LUGGAGE "\xee\x95\x94"	// U+e554
+#define ICON_FA_PERSON_WALKING_WITH_CANE "\xef\x8a\x9d"	// U+f29d
+#define ICON_FA_PESETA_SIGN "\xee\x88\xa1"	// U+e221
+#define ICON_FA_PESO_SIGN "\xee\x88\xa2"	// U+e222
+#define ICON_FA_PHONE "\xef\x82\x95"	// U+f095
+#define ICON_FA_PHONE_FLIP "\xef\xa1\xb9"	// U+f879
+#define ICON_FA_PHONE_SLASH "\xef\x8f\x9d"	// U+f3dd
+#define ICON_FA_PHONE_VOLUME "\xef\x8a\xa0"	// U+f2a0
+#define ICON_FA_PHOTO_FILM "\xef\xa1\xbc"	// U+f87c
+#define ICON_FA_PIGGY_BANK "\xef\x93\x93"	// U+f4d3
+#define ICON_FA_PILLS "\xef\x92\x84"	// U+f484
+#define ICON_FA_PIZZA_SLICE "\xef\xa0\x98"	// U+f818
+#define ICON_FA_PLACE_OF_WORSHIP "\xef\x99\xbf"	// U+f67f
+#define ICON_FA_PLANE "\xef\x81\xb2"	// U+f072
+#define ICON_FA_PLANE_ARRIVAL "\xef\x96\xaf"	// U+f5af
+#define ICON_FA_PLANE_CIRCLE_CHECK "\xee\x95\x95"	// U+e555
+#define ICON_FA_PLANE_CIRCLE_EXCLAMATION "\xee\x95\x96"	// U+e556
+#define ICON_FA_PLANE_CIRCLE_XMARK "\xee\x95\x97"	// U+e557
+#define ICON_FA_PLANE_DEPARTURE "\xef\x96\xb0"	// U+f5b0
+#define ICON_FA_PLANE_LOCK "\xee\x95\x98"	// U+e558
+#define ICON_FA_PLANE_SLASH "\xee\x81\xa9"	// U+e069
+#define ICON_FA_PLANE_UP "\xee\x88\xad"	// U+e22d
+#define ICON_FA_PLANT_WILT "\xee\x90\xbb"	// U+e43b
+#define ICON_FA_PLATE_WHEAT "\xee\x95\x9a"	// U+e55a
+#define ICON_FA_PLAY "\xef\x81\x8b"	// U+f04b
+#define ICON_FA_PLUG "\xef\x87\xa6"	// U+f1e6
+#define ICON_FA_PLUG_CIRCLE_BOLT "\xee\x95\x9b"	// U+e55b
+#define ICON_FA_PLUG_CIRCLE_CHECK "\xee\x95\x9c"	// U+e55c
+#define ICON_FA_PLUG_CIRCLE_EXCLAMATION "\xee\x95\x9d"	// U+e55d
+#define ICON_FA_PLUG_CIRCLE_MINUS "\xee\x95\x9e"	// U+e55e
+#define ICON_FA_PLUG_CIRCLE_PLUS "\xee\x95\x9f"	// U+e55f
+#define ICON_FA_PLUG_CIRCLE_XMARK "\xee\x95\xa0"	// U+e560
+#define ICON_FA_PLUS "+"	// U+002b
+#define ICON_FA_PLUS_MINUS "\xee\x90\xbc"	// U+e43c
+#define ICON_FA_PODCAST "\xef\x8b\x8e"	// U+f2ce
+#define ICON_FA_POO "\xef\x8b\xbe"	// U+f2fe
+#define ICON_FA_POO_STORM "\xef\x9d\x9a"	// U+f75a
+#define ICON_FA_POOP "\xef\x98\x99"	// U+f619
+#define ICON_FA_POWER_OFF "\xef\x80\x91"	// U+f011
+#define ICON_FA_PRESCRIPTION "\xef\x96\xb1"	// U+f5b1
+#define ICON_FA_PRESCRIPTION_BOTTLE "\xef\x92\x85"	// U+f485
+#define ICON_FA_PRESCRIPTION_BOTTLE_MEDICAL "\xef\x92\x86"	// U+f486
+#define ICON_FA_PRINT "\xef\x80\xaf"	// U+f02f
+#define ICON_FA_PUMP_MEDICAL "\xee\x81\xaa"	// U+e06a
+#define ICON_FA_PUMP_SOAP "\xee\x81\xab"	// U+e06b
+#define ICON_FA_PUZZLE_PIECE "\xef\x84\xae"	// U+f12e
+#define ICON_FA_Q "Q"	// U+0051
+#define ICON_FA_QRCODE "\xef\x80\xa9"	// U+f029
+#define ICON_FA_QUESTION "?"	// U+003f
+#define ICON_FA_QUOTE_LEFT "\xef\x84\x8d"	// U+f10d
+#define ICON_FA_QUOTE_RIGHT "\xef\x84\x8e"	// U+f10e
+#define ICON_FA_R "R"	// U+0052
+#define ICON_FA_RADIATION "\xef\x9e\xb9"	// U+f7b9
+#define ICON_FA_RADIO "\xef\xa3\x97"	// U+f8d7
+#define ICON_FA_RAINBOW "\xef\x9d\x9b"	// U+f75b
+#define ICON_FA_RANKING_STAR "\xee\x95\xa1"	// U+e561
+#define ICON_FA_RECEIPT "\xef\x95\x83"	// U+f543
+#define ICON_FA_RECORD_VINYL "\xef\xa3\x99"	// U+f8d9
+#define ICON_FA_RECTANGLE_AD "\xef\x99\x81"	// U+f641
+#define ICON_FA_RECTANGLE_LIST "\xef\x80\xa2"	// U+f022
+#define ICON_FA_RECTANGLE_XMARK "\xef\x90\x90"	// U+f410
+#define ICON_FA_RECYCLE "\xef\x86\xb8"	// U+f1b8
+#define ICON_FA_REGISTERED "\xef\x89\x9d"	// U+f25d
+#define ICON_FA_REPEAT "\xef\x8d\xa3"	// U+f363
+#define ICON_FA_REPLY "\xef\x8f\xa5"	// U+f3e5
+#define ICON_FA_REPLY_ALL "\xef\x84\xa2"	// U+f122
+#define ICON_FA_REPUBLICAN "\xef\x9d\x9e"	// U+f75e
+#define ICON_FA_RESTROOM "\xef\x9e\xbd"	// U+f7bd
+#define ICON_FA_RETWEET "\xef\x81\xb9"	// U+f079
+#define ICON_FA_RIBBON "\xef\x93\x96"	// U+f4d6
+#define ICON_FA_RIGHT_FROM_BRACKET "\xef\x8b\xb5"	// U+f2f5
+#define ICON_FA_RIGHT_LEFT "\xef\x8d\xa2"	// U+f362
+#define ICON_FA_RIGHT_LONG "\xef\x8c\x8b"	// U+f30b
+#define ICON_FA_RIGHT_TO_BRACKET "\xef\x8b\xb6"	// U+f2f6
+#define ICON_FA_RING "\xef\x9c\x8b"	// U+f70b
+#define ICON_FA_ROAD "\xef\x80\x98"	// U+f018
+#define ICON_FA_ROAD_BARRIER "\xee\x95\xa2"	// U+e562
+#define ICON_FA_ROAD_BRIDGE "\xee\x95\xa3"	// U+e563
+#define ICON_FA_ROAD_CIRCLE_CHECK "\xee\x95\xa4"	// U+e564
+#define ICON_FA_ROAD_CIRCLE_EXCLAMATION "\xee\x95\xa5"	// U+e565
+#define ICON_FA_ROAD_CIRCLE_XMARK "\xee\x95\xa6"	// U+e566
+#define ICON_FA_ROAD_LOCK "\xee\x95\xa7"	// U+e567
+#define ICON_FA_ROAD_SPIKES "\xee\x95\xa8"	// U+e568
+#define ICON_FA_ROBOT "\xef\x95\x84"	// U+f544
+#define ICON_FA_ROCKET "\xef\x84\xb5"	// U+f135
+#define ICON_FA_ROTATE "\xef\x8b\xb1"	// U+f2f1
+#define ICON_FA_ROTATE_LEFT "\xef\x8b\xaa"	// U+f2ea
+#define ICON_FA_ROTATE_RIGHT "\xef\x8b\xb9"	// U+f2f9
+#define ICON_FA_ROUTE "\xef\x93\x97"	// U+f4d7
+#define ICON_FA_RSS "\xef\x82\x9e"	// U+f09e
+#define ICON_FA_RUBLE_SIGN "\xef\x85\x98"	// U+f158
+#define ICON_FA_RUG "\xee\x95\xa9"	// U+e569
+#define ICON_FA_RULER "\xef\x95\x85"	// U+f545
+#define ICON_FA_RULER_COMBINED "\xef\x95\x86"	// U+f546
+#define ICON_FA_RULER_HORIZONTAL "\xef\x95\x87"	// U+f547
+#define ICON_FA_RULER_VERTICAL "\xef\x95\x88"	// U+f548
+#define ICON_FA_RUPEE_SIGN "\xef\x85\x96"	// U+f156
+#define ICON_FA_RUPIAH_SIGN "\xee\x88\xbd"	// U+e23d
+#define ICON_FA_S "S"	// U+0053
+#define ICON_FA_SACK_DOLLAR "\xef\xa0\x9d"	// U+f81d
+#define ICON_FA_SACK_XMARK "\xee\x95\xaa"	// U+e56a
+#define ICON_FA_SAILBOAT "\xee\x91\x85"	// U+e445
+#define ICON_FA_SATELLITE "\xef\x9e\xbf"	// U+f7bf
+#define ICON_FA_SATELLITE_DISH "\xef\x9f\x80"	// U+f7c0
+#define ICON_FA_SCALE_BALANCED "\xef\x89\x8e"	// U+f24e
+#define ICON_FA_SCALE_UNBALANCED "\xef\x94\x95"	// U+f515
+#define ICON_FA_SCALE_UNBALANCED_FLIP "\xef\x94\x96"	// U+f516
+#define ICON_FA_SCHOOL "\xef\x95\x89"	// U+f549
+#define ICON_FA_SCHOOL_CIRCLE_CHECK "\xee\x95\xab"	// U+e56b
+#define ICON_FA_SCHOOL_CIRCLE_EXCLAMATION "\xee\x95\xac"	// U+e56c
+#define ICON_FA_SCHOOL_CIRCLE_XMARK "\xee\x95\xad"	// U+e56d
+#define ICON_FA_SCHOOL_FLAG "\xee\x95\xae"	// U+e56e
+#define ICON_FA_SCHOOL_LOCK "\xee\x95\xaf"	// U+e56f
+#define ICON_FA_SCISSORS "\xef\x83\x84"	// U+f0c4
+#define ICON_FA_SCREWDRIVER "\xef\x95\x8a"	// U+f54a
+#define ICON_FA_SCREWDRIVER_WRENCH "\xef\x9f\x99"	// U+f7d9
+#define ICON_FA_SCROLL "\xef\x9c\x8e"	// U+f70e
+#define ICON_FA_SCROLL_TORAH "\xef\x9a\xa0"	// U+f6a0
+#define ICON_FA_SD_CARD "\xef\x9f\x82"	// U+f7c2
+#define ICON_FA_SECTION "\xee\x91\x87"	// U+e447
+#define ICON_FA_SEEDLING "\xef\x93\x98"	// U+f4d8
+#define ICON_FA_SERVER "\xef\x88\xb3"	// U+f233
+#define ICON_FA_SHAPES "\xef\x98\x9f"	// U+f61f
+#define ICON_FA_SHARE "\xef\x81\xa4"	// U+f064
+#define ICON_FA_SHARE_FROM_SQUARE "\xef\x85\x8d"	// U+f14d
+#define ICON_FA_SHARE_NODES "\xef\x87\xa0"	// U+f1e0
+#define ICON_FA_SHEET_PLASTIC "\xee\x95\xb1"	// U+e571
+#define ICON_FA_SHEKEL_SIGN "\xef\x88\x8b"	// U+f20b
+#define ICON_FA_SHIELD "\xef\x84\xb2"	// U+f132
+#define ICON_FA_SHIELD_CAT "\xee\x95\xb2"	// U+e572
+#define ICON_FA_SHIELD_DOG "\xee\x95\xb3"	// U+e573
+#define ICON_FA_SHIELD_HALVED "\xef\x8f\xad"	// U+f3ed
+#define ICON_FA_SHIELD_HEART "\xee\x95\xb4"	// U+e574
+#define ICON_FA_SHIELD_VIRUS "\xee\x81\xac"	// U+e06c
+#define ICON_FA_SHIP "\xef\x88\x9a"	// U+f21a
+#define ICON_FA_SHIRT "\xef\x95\x93"	// U+f553
+#define ICON_FA_SHOE_PRINTS "\xef\x95\x8b"	// U+f54b
+#define ICON_FA_SHOP "\xef\x95\x8f"	// U+f54f
+#define ICON_FA_SHOP_LOCK "\xee\x92\xa5"	// U+e4a5
+#define ICON_FA_SHOP_SLASH "\xee\x81\xb0"	// U+e070
+#define ICON_FA_SHOWER "\xef\x8b\x8c"	// U+f2cc
+#define ICON_FA_SHRIMP "\xee\x91\x88"	// U+e448
+#define ICON_FA_SHUFFLE "\xef\x81\xb4"	// U+f074
+#define ICON_FA_SHUTTLE_SPACE "\xef\x86\x97"	// U+f197
+#define ICON_FA_SIGN_HANGING "\xef\x93\x99"	// U+f4d9
+#define ICON_FA_SIGNAL "\xef\x80\x92"	// U+f012
+#define ICON_FA_SIGNATURE "\xef\x96\xb7"	// U+f5b7
+#define ICON_FA_SIGNS_POST "\xef\x89\xb7"	// U+f277
+#define ICON_FA_SIM_CARD "\xef\x9f\x84"	// U+f7c4
+#define ICON_FA_SINK "\xee\x81\xad"	// U+e06d
+#define ICON_FA_SITEMAP "\xef\x83\xa8"	// U+f0e8
+#define ICON_FA_SKULL "\xef\x95\x8c"	// U+f54c
+#define ICON_FA_SKULL_CROSSBONES "\xef\x9c\x94"	// U+f714
+#define ICON_FA_SLASH "\xef\x9c\x95"	// U+f715
+#define ICON_FA_SLEIGH "\xef\x9f\x8c"	// U+f7cc
+#define ICON_FA_SLIDERS "\xef\x87\x9e"	// U+f1de
+#define ICON_FA_SMOG "\xef\x9d\x9f"	// U+f75f
+#define ICON_FA_SMOKING "\xef\x92\x8d"	// U+f48d
+#define ICON_FA_SNOWFLAKE "\xef\x8b\x9c"	// U+f2dc
+#define ICON_FA_SNOWMAN "\xef\x9f\x90"	// U+f7d0
+#define ICON_FA_SNOWPLOW "\xef\x9f\x92"	// U+f7d2
+#define ICON_FA_SOAP "\xee\x81\xae"	// U+e06e
+#define ICON_FA_SOCKS "\xef\x9a\x96"	// U+f696
+#define ICON_FA_SOLAR_PANEL "\xef\x96\xba"	// U+f5ba
+#define ICON_FA_SORT "\xef\x83\x9c"	// U+f0dc
+#define ICON_FA_SORT_DOWN "\xef\x83\x9d"	// U+f0dd
+#define ICON_FA_SORT_UP "\xef\x83\x9e"	// U+f0de
+#define ICON_FA_SPA "\xef\x96\xbb"	// U+f5bb
+#define ICON_FA_SPAGHETTI_MONSTER_FLYING "\xef\x99\xbb"	// U+f67b
+#define ICON_FA_SPELL_CHECK "\xef\xa2\x91"	// U+f891
+#define ICON_FA_SPIDER "\xef\x9c\x97"	// U+f717
+#define ICON_FA_SPINNER "\xef\x84\x90"	// U+f110
+#define ICON_FA_SPLOTCH "\xef\x96\xbc"	// U+f5bc
+#define ICON_FA_SPOON "\xef\x8b\xa5"	// U+f2e5
+#define ICON_FA_SPRAY_CAN "\xef\x96\xbd"	// U+f5bd
+#define ICON_FA_SPRAY_CAN_SPARKLES "\xef\x97\x90"	// U+f5d0
+#define ICON_FA_SQUARE "\xef\x83\x88"	// U+f0c8
+#define ICON_FA_SQUARE_ARROW_UP_RIGHT "\xef\x85\x8c"	// U+f14c
+#define ICON_FA_SQUARE_CARET_DOWN "\xef\x85\x90"	// U+f150
+#define ICON_FA_SQUARE_CARET_LEFT "\xef\x86\x91"	// U+f191
+#define ICON_FA_SQUARE_CARET_RIGHT "\xef\x85\x92"	// U+f152
+#define ICON_FA_SQUARE_CARET_UP "\xef\x85\x91"	// U+f151
+#define ICON_FA_SQUARE_CHECK "\xef\x85\x8a"	// U+f14a
+#define ICON_FA_SQUARE_ENVELOPE "\xef\x86\x99"	// U+f199
+#define ICON_FA_SQUARE_FULL "\xef\x91\x9c"	// U+f45c
+#define ICON_FA_SQUARE_H "\xef\x83\xbd"	// U+f0fd
+#define ICON_FA_SQUARE_MINUS "\xef\x85\x86"	// U+f146
+#define ICON_FA_SQUARE_NFI "\xee\x95\xb6"	// U+e576
+#define ICON_FA_SQUARE_PARKING "\xef\x95\x80"	// U+f540
+#define ICON_FA_SQUARE_PEN "\xef\x85\x8b"	// U+f14b
+#define ICON_FA_SQUARE_PERSON_CONFINED "\xee\x95\xb7"	// U+e577
+#define ICON_FA_SQUARE_PHONE "\xef\x82\x98"	// U+f098
+#define ICON_FA_SQUARE_PHONE_FLIP "\xef\xa1\xbb"	// U+f87b
+#define ICON_FA_SQUARE_PLUS "\xef\x83\xbe"	// U+f0fe
+#define ICON_FA_SQUARE_POLL_HORIZONTAL "\xef\x9a\x82"	// U+f682
+#define ICON_FA_SQUARE_POLL_VERTICAL "\xef\x9a\x81"	// U+f681
+#define ICON_FA_SQUARE_ROOT_VARIABLE "\xef\x9a\x98"	// U+f698
+#define ICON_FA_SQUARE_RSS "\xef\x85\x83"	// U+f143
+#define ICON_FA_SQUARE_SHARE_NODES "\xef\x87\xa1"	// U+f1e1
+#define ICON_FA_SQUARE_UP_RIGHT "\xef\x8d\xa0"	// U+f360
+#define ICON_FA_SQUARE_VIRUS "\xee\x95\xb8"	// U+e578
+#define ICON_FA_SQUARE_XMARK "\xef\x8b\x93"	// U+f2d3
+#define ICON_FA_STAFF_AESCULAPIUS "\xee\x95\xb9"	// U+e579
+#define ICON_FA_STAIRS "\xee\x8a\x89"	// U+e289
+#define ICON_FA_STAMP "\xef\x96\xbf"	// U+f5bf
+#define ICON_FA_STAR "\xef\x80\x85"	// U+f005
+#define ICON_FA_STAR_AND_CRESCENT "\xef\x9a\x99"	// U+f699
+#define ICON_FA_STAR_HALF "\xef\x82\x89"	// U+f089
+#define ICON_FA_STAR_HALF_STROKE "\xef\x97\x80"	// U+f5c0
+#define ICON_FA_STAR_OF_DAVID "\xef\x9a\x9a"	// U+f69a
+#define ICON_FA_STAR_OF_LIFE "\xef\x98\xa1"	// U+f621
+#define ICON_FA_STERLING_SIGN "\xef\x85\x94"	// U+f154
+#define ICON_FA_STETHOSCOPE "\xef\x83\xb1"	// U+f0f1
+#define ICON_FA_STOP "\xef\x81\x8d"	// U+f04d
+#define ICON_FA_STOPWATCH "\xef\x8b\xb2"	// U+f2f2
+#define ICON_FA_STOPWATCH_20 "\xee\x81\xaf"	// U+e06f
+#define ICON_FA_STORE "\xef\x95\x8e"	// U+f54e
+#define ICON_FA_STORE_SLASH "\xee\x81\xb1"	// U+e071
+#define ICON_FA_STREET_VIEW "\xef\x88\x9d"	// U+f21d
+#define ICON_FA_STRIKETHROUGH "\xef\x83\x8c"	// U+f0cc
+#define ICON_FA_STROOPWAFEL "\xef\x95\x91"	// U+f551
+#define ICON_FA_SUBSCRIPT "\xef\x84\xac"	// U+f12c
+#define ICON_FA_SUITCASE "\xef\x83\xb2"	// U+f0f2
+#define ICON_FA_SUITCASE_MEDICAL "\xef\x83\xba"	// U+f0fa
+#define ICON_FA_SUITCASE_ROLLING "\xef\x97\x81"	// U+f5c1
+#define ICON_FA_SUN "\xef\x86\x85"	// U+f185
+#define ICON_FA_SUN_PLANT_WILT "\xee\x95\xba"	// U+e57a
+#define ICON_FA_SUPERSCRIPT "\xef\x84\xab"	// U+f12b
+#define ICON_FA_SWATCHBOOK "\xef\x97\x83"	// U+f5c3
+#define ICON_FA_SYNAGOGUE "\xef\x9a\x9b"	// U+f69b
+#define ICON_FA_SYRINGE "\xef\x92\x8e"	// U+f48e
+#define ICON_FA_T "T"	// U+0054
+#define ICON_FA_TABLE "\xef\x83\x8e"	// U+f0ce
+#define ICON_FA_TABLE_CELLS "\xef\x80\x8a"	// U+f00a
+#define ICON_FA_TABLE_CELLS_LARGE "\xef\x80\x89"	// U+f009
+#define ICON_FA_TABLE_COLUMNS "\xef\x83\x9b"	// U+f0db
+#define ICON_FA_TABLE_LIST "\xef\x80\x8b"	// U+f00b
+#define ICON_FA_TABLE_TENNIS_PADDLE_BALL "\xef\x91\x9d"	// U+f45d
+#define ICON_FA_TABLET "\xef\x8f\xbb"	// U+f3fb
+#define ICON_FA_TABLET_BUTTON "\xef\x84\x8a"	// U+f10a
+#define ICON_FA_TABLET_SCREEN_BUTTON "\xef\x8f\xba"	// U+f3fa
+#define ICON_FA_TABLETS "\xef\x92\x90"	// U+f490
+#define ICON_FA_TACHOGRAPH_DIGITAL "\xef\x95\xa6"	// U+f566
+#define ICON_FA_TAG "\xef\x80\xab"	// U+f02b
+#define ICON_FA_TAGS "\xef\x80\xac"	// U+f02c
+#define ICON_FA_TAPE "\xef\x93\x9b"	// U+f4db
+#define ICON_FA_TARP "\xee\x95\xbb"	// U+e57b
+#define ICON_FA_TARP_DROPLET "\xee\x95\xbc"	// U+e57c
+#define ICON_FA_TAXI "\xef\x86\xba"	// U+f1ba
+#define ICON_FA_TEETH "\xef\x98\xae"	// U+f62e
+#define ICON_FA_TEETH_OPEN "\xef\x98\xaf"	// U+f62f
+#define ICON_FA_TEMPERATURE_ARROW_DOWN "\xee\x80\xbf"	// U+e03f
+#define ICON_FA_TEMPERATURE_ARROW_UP "\xee\x81\x80"	// U+e040
+#define ICON_FA_TEMPERATURE_EMPTY "\xef\x8b\x8b"	// U+f2cb
+#define ICON_FA_TEMPERATURE_FULL "\xef\x8b\x87"	// U+f2c7
+#define ICON_FA_TEMPERATURE_HALF "\xef\x8b\x89"	// U+f2c9
+#define ICON_FA_TEMPERATURE_HIGH "\xef\x9d\xa9"	// U+f769
+#define ICON_FA_TEMPERATURE_LOW "\xef\x9d\xab"	// U+f76b
+#define ICON_FA_TEMPERATURE_QUARTER "\xef\x8b\x8a"	// U+f2ca
+#define ICON_FA_TEMPERATURE_THREE_QUARTERS "\xef\x8b\x88"	// U+f2c8
+#define ICON_FA_TENGE_SIGN "\xef\x9f\x97"	// U+f7d7
+#define ICON_FA_TENT "\xee\x95\xbd"	// U+e57d
+#define ICON_FA_TENT_ARROW_DOWN_TO_LINE "\xee\x95\xbe"	// U+e57e
+#define ICON_FA_TENT_ARROW_LEFT_RIGHT "\xee\x95\xbf"	// U+e57f
+#define ICON_FA_TENT_ARROW_TURN_LEFT "\xee\x96\x80"	// U+e580
+#define ICON_FA_TENT_ARROWS_DOWN "\xee\x96\x81"	// U+e581
+#define ICON_FA_TENTS "\xee\x96\x82"	// U+e582
+#define ICON_FA_TERMINAL "\xef\x84\xa0"	// U+f120
+#define ICON_FA_TEXT_HEIGHT "\xef\x80\xb4"	// U+f034
+#define ICON_FA_TEXT_SLASH "\xef\xa1\xbd"	// U+f87d
+#define ICON_FA_TEXT_WIDTH "\xef\x80\xb5"	// U+f035
+#define ICON_FA_THERMOMETER "\xef\x92\x91"	// U+f491
+#define ICON_FA_THUMBS_DOWN "\xef\x85\xa5"	// U+f165
+#define ICON_FA_THUMBS_UP "\xef\x85\xa4"	// U+f164
+#define ICON_FA_THUMBTACK "\xef\x82\x8d"	// U+f08d
+#define ICON_FA_TICKET "\xef\x85\x85"	// U+f145
+#define ICON_FA_TICKET_SIMPLE "\xef\x8f\xbf"	// U+f3ff
+#define ICON_FA_TIMELINE "\xee\x8a\x9c"	// U+e29c
+#define ICON_FA_TOGGLE_OFF "\xef\x88\x84"	// U+f204
+#define ICON_FA_TOGGLE_ON "\xef\x88\x85"	// U+f205
+#define ICON_FA_TOILET "\xef\x9f\x98"	// U+f7d8
+#define ICON_FA_TOILET_PAPER "\xef\x9c\x9e"	// U+f71e
+#define ICON_FA_TOILET_PAPER_SLASH "\xee\x81\xb2"	// U+e072
+#define ICON_FA_TOILET_PORTABLE "\xee\x96\x83"	// U+e583
+#define ICON_FA_TOILETS_PORTABLE "\xee\x96\x84"	// U+e584
+#define ICON_FA_TOOLBOX "\xef\x95\x92"	// U+f552
+#define ICON_FA_TOOTH "\xef\x97\x89"	// U+f5c9
+#define ICON_FA_TORII_GATE "\xef\x9a\xa1"	// U+f6a1
+#define ICON_FA_TORNADO "\xef\x9d\xaf"	// U+f76f
+#define ICON_FA_TOWER_BROADCAST "\xef\x94\x99"	// U+f519
+#define ICON_FA_TOWER_CELL "\xee\x96\x85"	// U+e585
+#define ICON_FA_TOWER_OBSERVATION "\xee\x96\x86"	// U+e586
+#define ICON_FA_TRACTOR "\xef\x9c\xa2"	// U+f722
+#define ICON_FA_TRADEMARK "\xef\x89\x9c"	// U+f25c
+#define ICON_FA_TRAFFIC_LIGHT "\xef\x98\xb7"	// U+f637
+#define ICON_FA_TRAILER "\xee\x81\x81"	// U+e041
+#define ICON_FA_TRAIN "\xef\x88\xb8"	// U+f238
+#define ICON_FA_TRAIN_SUBWAY "\xef\x88\xb9"	// U+f239
+#define ICON_FA_TRAIN_TRAM "\xef\x9f\x9a"	// U+f7da
+#define ICON_FA_TRANSGENDER "\xef\x88\xa5"	// U+f225
+#define ICON_FA_TRASH "\xef\x87\xb8"	// U+f1f8
+#define ICON_FA_TRASH_ARROW_UP "\xef\xa0\xa9"	// U+f829
+#define ICON_FA_TRASH_CAN "\xef\x8b\xad"	// U+f2ed
+#define ICON_FA_TRASH_CAN_ARROW_UP "\xef\xa0\xaa"	// U+f82a
+#define ICON_FA_TREE "\xef\x86\xbb"	// U+f1bb
+#define ICON_FA_TREE_CITY "\xee\x96\x87"	// U+e587
+#define ICON_FA_TRIANGLE_EXCLAMATION "\xef\x81\xb1"	// U+f071
+#define ICON_FA_TROPHY "\xef\x82\x91"	// U+f091
+#define ICON_FA_TROWEL "\xee\x96\x89"	// U+e589
+#define ICON_FA_TROWEL_BRICKS "\xee\x96\x8a"	// U+e58a
+#define ICON_FA_TRUCK "\xef\x83\x91"	// U+f0d1
+#define ICON_FA_TRUCK_ARROW_RIGHT "\xee\x96\x8b"	// U+e58b
+#define ICON_FA_TRUCK_DROPLET "\xee\x96\x8c"	// U+e58c
+#define ICON_FA_TRUCK_FAST "\xef\x92\x8b"	// U+f48b
+#define ICON_FA_TRUCK_FIELD "\xee\x96\x8d"	// U+e58d
+#define ICON_FA_TRUCK_FIELD_UN "\xee\x96\x8e"	// U+e58e
+#define ICON_FA_TRUCK_FRONT "\xee\x8a\xb7"	// U+e2b7
+#define ICON_FA_TRUCK_MEDICAL "\xef\x83\xb9"	// U+f0f9
+#define ICON_FA_TRUCK_MONSTER "\xef\x98\xbb"	// U+f63b
+#define ICON_FA_TRUCK_MOVING "\xef\x93\x9f"	// U+f4df
+#define ICON_FA_TRUCK_PICKUP "\xef\x98\xbc"	// U+f63c
+#define ICON_FA_TRUCK_PLANE "\xee\x96\x8f"	// U+e58f
+#define ICON_FA_TRUCK_RAMP_BOX "\xef\x93\x9e"	// U+f4de
+#define ICON_FA_TTY "\xef\x87\xa4"	// U+f1e4
+#define ICON_FA_TURKISH_LIRA_SIGN "\xee\x8a\xbb"	// U+e2bb
+#define ICON_FA_TURN_DOWN "\xef\x8e\xbe"	// U+f3be
+#define ICON_FA_TURN_UP "\xef\x8e\xbf"	// U+f3bf
+#define ICON_FA_TV "\xef\x89\xac"	// U+f26c
+#define ICON_FA_U "U"	// U+0055
+#define ICON_FA_UMBRELLA "\xef\x83\xa9"	// U+f0e9
+#define ICON_FA_UMBRELLA_BEACH "\xef\x97\x8a"	// U+f5ca
+#define ICON_FA_UNDERLINE "\xef\x83\x8d"	// U+f0cd
+#define ICON_FA_UNIVERSAL_ACCESS "\xef\x8a\x9a"	// U+f29a
+#define ICON_FA_UNLOCK "\xef\x82\x9c"	// U+f09c
+#define ICON_FA_UNLOCK_KEYHOLE "\xef\x84\xbe"	// U+f13e
+#define ICON_FA_UP_DOWN "\xef\x8c\xb8"	// U+f338
+#define ICON_FA_UP_DOWN_LEFT_RIGHT "\xef\x82\xb2"	// U+f0b2
+#define ICON_FA_UP_LONG "\xef\x8c\x8c"	// U+f30c
+#define ICON_FA_UP_RIGHT_AND_DOWN_LEFT_FROM_CENTER "\xef\x90\xa4"	// U+f424
+#define ICON_FA_UP_RIGHT_FROM_SQUARE "\xef\x8d\x9d"	// U+f35d
+#define ICON_FA_UPLOAD "\xef\x82\x93"	// U+f093
+#define ICON_FA_USER "\xef\x80\x87"	// U+f007
+#define ICON_FA_USER_ASTRONAUT "\xef\x93\xbb"	// U+f4fb
+#define ICON_FA_USER_CHECK "\xef\x93\xbc"	// U+f4fc
+#define ICON_FA_USER_CLOCK "\xef\x93\xbd"	// U+f4fd
+#define ICON_FA_USER_DOCTOR "\xef\x83\xb0"	// U+f0f0
+#define ICON_FA_USER_GEAR "\xef\x93\xbe"	// U+f4fe
+#define ICON_FA_USER_GRADUATE "\xef\x94\x81"	// U+f501
+#define ICON_FA_USER_GROUP "\xef\x94\x80"	// U+f500
+#define ICON_FA_USER_INJURED "\xef\x9c\xa8"	// U+f728
+#define ICON_FA_USER_LARGE "\xef\x90\x86"	// U+f406
+#define ICON_FA_USER_LARGE_SLASH "\xef\x93\xba"	// U+f4fa
+#define ICON_FA_USER_LOCK "\xef\x94\x82"	// U+f502
+#define ICON_FA_USER_MINUS "\xef\x94\x83"	// U+f503
+#define ICON_FA_USER_NINJA "\xef\x94\x84"	// U+f504
+#define ICON_FA_USER_NURSE "\xef\xa0\xaf"	// U+f82f
+#define ICON_FA_USER_PEN "\xef\x93\xbf"	// U+f4ff
+#define ICON_FA_USER_PLUS "\xef\x88\xb4"	// U+f234
+#define ICON_FA_USER_SECRET "\xef\x88\x9b"	// U+f21b
+#define ICON_FA_USER_SHIELD "\xef\x94\x85"	// U+f505
+#define ICON_FA_USER_SLASH "\xef\x94\x86"	// U+f506
+#define ICON_FA_USER_TAG "\xef\x94\x87"	// U+f507
+#define ICON_FA_USER_TIE "\xef\x94\x88"	// U+f508
+#define ICON_FA_USER_XMARK "\xef\x88\xb5"	// U+f235
+#define ICON_FA_USERS "\xef\x83\x80"	// U+f0c0
+#define ICON_FA_USERS_BETWEEN_LINES "\xee\x96\x91"	// U+e591
+#define ICON_FA_USERS_GEAR "\xef\x94\x89"	// U+f509
+#define ICON_FA_USERS_LINE "\xee\x96\x92"	// U+e592
+#define ICON_FA_USERS_RAYS "\xee\x96\x93"	// U+e593
+#define ICON_FA_USERS_RECTANGLE "\xee\x96\x94"	// U+e594
+#define ICON_FA_USERS_SLASH "\xee\x81\xb3"	// U+e073
+#define ICON_FA_USERS_VIEWFINDER "\xee\x96\x95"	// U+e595
+#define ICON_FA_UTENSILS "\xef\x8b\xa7"	// U+f2e7
+#define ICON_FA_V "V"	// U+0056
+#define ICON_FA_VAN_SHUTTLE "\xef\x96\xb6"	// U+f5b6
+#define ICON_FA_VAULT "\xee\x8b\x85"	// U+e2c5
+#define ICON_FA_VECTOR_SQUARE "\xef\x97\x8b"	// U+f5cb
+#define ICON_FA_VENUS "\xef\x88\xa1"	// U+f221
+#define ICON_FA_VENUS_DOUBLE "\xef\x88\xa6"	// U+f226
+#define ICON_FA_VENUS_MARS "\xef\x88\xa8"	// U+f228
+#define ICON_FA_VEST "\xee\x82\x85"	// U+e085
+#define ICON_FA_VEST_PATCHES "\xee\x82\x86"	// U+e086
+#define ICON_FA_VIAL "\xef\x92\x92"	// U+f492
+#define ICON_FA_VIAL_CIRCLE_CHECK "\xee\x96\x96"	// U+e596
+#define ICON_FA_VIAL_VIRUS "\xee\x96\x97"	// U+e597
+#define ICON_FA_VIALS "\xef\x92\x93"	// U+f493
+#define ICON_FA_VIDEO "\xef\x80\xbd"	// U+f03d
+#define ICON_FA_VIDEO_SLASH "\xef\x93\xa2"	// U+f4e2
+#define ICON_FA_VIHARA "\xef\x9a\xa7"	// U+f6a7
+#define ICON_FA_VIRUS "\xee\x81\xb4"	// U+e074
+#define ICON_FA_VIRUS_COVID "\xee\x92\xa8"	// U+e4a8
+#define ICON_FA_VIRUS_COVID_SLASH "\xee\x92\xa9"	// U+e4a9
+#define ICON_FA_VIRUS_SLASH "\xee\x81\xb5"	// U+e075
+#define ICON_FA_VIRUSES "\xee\x81\xb6"	// U+e076
+#define ICON_FA_VOICEMAIL "\xef\xa2\x97"	// U+f897
+#define ICON_FA_VOLCANO "\xef\x9d\xb0"	// U+f770
+#define ICON_FA_VOLLEYBALL "\xef\x91\x9f"	// U+f45f
+#define ICON_FA_VOLUME_HIGH "\xef\x80\xa8"	// U+f028
+#define ICON_FA_VOLUME_LOW "\xef\x80\xa7"	// U+f027
+#define ICON_FA_VOLUME_OFF "\xef\x80\xa6"	// U+f026
+#define ICON_FA_VOLUME_XMARK "\xef\x9a\xa9"	// U+f6a9
+#define ICON_FA_VR_CARDBOARD "\xef\x9c\xa9"	// U+f729
+#define ICON_FA_W "W"	// U+0057
+#define ICON_FA_WALKIE_TALKIE "\xef\xa3\xaf"	// U+f8ef
+#define ICON_FA_WALLET "\xef\x95\x95"	// U+f555
+#define ICON_FA_WAND_MAGIC "\xef\x83\x90"	// U+f0d0
+#define ICON_FA_WAND_MAGIC_SPARKLES "\xee\x8b\x8a"	// U+e2ca
+#define ICON_FA_WAND_SPARKLES "\xef\x9c\xab"	// U+f72b
+#define ICON_FA_WAREHOUSE "\xef\x92\x94"	// U+f494
+#define ICON_FA_WATER "\xef\x9d\xb3"	// U+f773
+#define ICON_FA_WATER_LADDER "\xef\x97\x85"	// U+f5c5
+#define ICON_FA_WAVE_SQUARE "\xef\xa0\xbe"	// U+f83e
+#define ICON_FA_WEIGHT_HANGING "\xef\x97\x8d"	// U+f5cd
+#define ICON_FA_WEIGHT_SCALE "\xef\x92\x96"	// U+f496
+#define ICON_FA_WHEAT_AWN "\xee\x8b\x8d"	// U+e2cd
+#define ICON_FA_WHEAT_AWN_CIRCLE_EXCLAMATION "\xee\x96\x98"	// U+e598
+#define ICON_FA_WHEELCHAIR "\xef\x86\x93"	// U+f193
+#define ICON_FA_WHEELCHAIR_MOVE "\xee\x8b\x8e"	// U+e2ce
+#define ICON_FA_WHISKEY_GLASS "\xef\x9e\xa0"	// U+f7a0
+#define ICON_FA_WIFI "\xef\x87\xab"	// U+f1eb
+#define ICON_FA_WIND "\xef\x9c\xae"	// U+f72e
+#define ICON_FA_WINDOW_MAXIMIZE "\xef\x8b\x90"	// U+f2d0
+#define ICON_FA_WINDOW_MINIMIZE "\xef\x8b\x91"	// U+f2d1
+#define ICON_FA_WINDOW_RESTORE "\xef\x8b\x92"	// U+f2d2
+#define ICON_FA_WINE_BOTTLE "\xef\x9c\xaf"	// U+f72f
+#define ICON_FA_WINE_GLASS "\xef\x93\xa3"	// U+f4e3
+#define ICON_FA_WINE_GLASS_EMPTY "\xef\x97\x8e"	// U+f5ce
+#define ICON_FA_WON_SIGN "\xef\x85\x99"	// U+f159
+#define ICON_FA_WORM "\xee\x96\x99"	// U+e599
+#define ICON_FA_WRENCH "\xef\x82\xad"	// U+f0ad
+#define ICON_FA_X "X"	// U+0058
+#define ICON_FA_X_RAY "\xef\x92\x97"	// U+f497
+#define ICON_FA_XMARK "\xef\x80\x8d"	// U+f00d
+#define ICON_FA_XMARKS_LINES "\xee\x96\x9a"	// U+e59a
+#define ICON_FA_Y "Y"	// U+0059
+#define ICON_FA_YEN_SIGN "\xef\x85\x97"	// U+f157
+#define ICON_FA_YIN_YANG "\xef\x9a\xad"	// U+f6ad
+#define ICON_FA_Z "Z"	// U+005a
+ rlImGui/imgui/imconfig.h view
@@ -0,0 +1,123 @@+//-----------------------------------------------------------------------------
+// COMPILE-TIME OPTIONS FOR DEAR IMGUI
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
+// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
+//-----------------------------------------------------------------------------
+// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
+// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
+// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Disable all of Dear ImGui or don't implement standard windows.
+// It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
+//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
+//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable metrics/debugger and other debug tools: ShowMetricsWindow() and ShowStackToolWindow() will be empty.
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
+//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
+//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, ime).
+//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
+//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
+//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
+//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
+//#define IMGUI_USE_WCHAR32
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+
+//---- Use stb_printf's faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
+// Requires 'stb_sprintf.h' to be available in the include path. Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
+// #define IMGUI_USE_STB_SPRINTF
+
+//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
+// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
+//#define IMGUI_ENABLE_FREETYPE
+
+//---- Use stb_truetype to build and rasterize the font atlas (default)
+// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
+//#define IMGUI_ENABLE_STB_TRUETYPE
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                 \
+        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                 \
+        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
+// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
+// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
+// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
+//#define ImDrawIdx unsigned int
+
+//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
+//struct ImDrawList;
+//struct ImDrawCmd;
+//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
+//#define ImDrawCallback MyImDrawCallback
+
+//---- Debug Tools: Macro to break in Debugger
+// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
+//#define IM_DEBUG_BREAK  IM_ASSERT(0)
+//#define IM_DEBUG_BREAK  __debugbreak()
+
+//---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(),
+// (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.)
+// This adds a small runtime cost which is why it is not enabled by default.
+//#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
+
+//---- Debug Tools: Enable slower asserts
+//#define IMGUI_DEBUG_PARANOID
+
+//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, const MyMatrix44& v);
+}
+*/
+ rlImGui/imgui/imgui.h view
@@ -0,0 +1,2911 @@+// dear imgui, v1.85 WIP
+// (headers)
+
+// Help:
+// - Read FAQ at http://dearimgui.org/faq
+// - Newcomers, read 'Programmer guide' in imgui.cpp for notes on how to setup Dear ImGui in your codebase.
+// - Call and read ImGui::ShowDemoWindow() in imgui_demo.cpp. All applications in examples/ are doing that.
+// Read imgui.cpp for details, links and comments.
+
+// Resources:
+// - FAQ                   http://dearimgui.org/faq
+// - Homepage & latest     https://github.com/ocornut/imgui
+// - Releases & changelog  https://github.com/ocornut/imgui/releases
+// - Gallery               https://github.com/ocornut/imgui/issues/4451 (please post your screenshots/video there!)
+// - Wiki                  https://github.com/ocornut/imgui/wiki (lots of good stuff there)
+// - Glossary              https://github.com/ocornut/imgui/wiki/Glossary
+// - Issues & support      https://github.com/ocornut/imgui/issues
+
+// Getting Started?
+// - For first-time users having issues compiling/linking/running or issues loading fonts:
+//   please post in https://github.com/ocornut/imgui/discussions if you cannot find a solution in resources above.
+
+/*
+
+Index of this file:
+// [SECTION] Header mess
+// [SECTION] Forward declarations and basic types
+// [SECTION] Dear ImGui end-user API functions
+// [SECTION] Flags & Enumerations
+// [SECTION] Helpers: Memory allocations macros, ImVector<>
+// [SECTION] ImGuiStyle
+// [SECTION] ImGuiIO
+// [SECTION] Misc data structures (ImGuiInputTextCallbackData, ImGuiSizeCallbackData, ImGuiPayload, ImGuiTableSortSpecs, ImGuiTableColumnSortSpecs)
+// [SECTION] Helpers (ImGuiOnceUponAFrame, ImGuiTextFilter, ImGuiTextBuffer, ImGuiStorage, ImGuiListClipper, ImColor)
+// [SECTION] Drawing API (ImDrawCallback, ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListSplitter, ImDrawFlags, ImDrawListFlags, ImDrawList, ImDrawData)
+// [SECTION] Font API (ImFontConfig, ImFontGlyph, ImFontGlyphRangesBuilder, ImFontAtlasFlags, ImFontAtlas, ImFont)
+// [SECTION] Viewports (ImGuiViewportFlags, ImGuiViewport)
+// [SECTION] Obsolete functions and types
+
+*/
+
+#pragma once
+
+// Configuration file with compile-time options (edit imconfig.h or '#define IMGUI_USER_CONFIG "myfilename.h" from your build system')
+#ifdef IMGUI_USER_CONFIG
+#include IMGUI_USER_CONFIG
+#endif
+#if !defined(IMGUI_DISABLE_INCLUDE_IMCONFIG_H) || defined(IMGUI_INCLUDE_IMCONFIG_H)
+#include "imconfig.h"
+#endif
+
+#ifndef IMGUI_DISABLE
+
+//-----------------------------------------------------------------------------
+// [SECTION] Header mess
+//-----------------------------------------------------------------------------
+
+// Includes
+#include <float.h>                  // FLT_MIN, FLT_MAX
+#include <stdarg.h>                 // va_list, va_start, va_end
+#include <stddef.h>                 // ptrdiff_t, NULL
+#include <string.h>                 // memset, memmove, memcpy, strlen, strchr, strcpy, strcmp
+
+// Version
+// (Integer encoded as XYYZZ for use in #if preprocessor conditionals. Work in progress versions typically starts at XYY99 then bounce up to XYY00, XYY01 etc. when release tagging happens)
+#define IMGUI_VERSION               "1.85 WIP"
+#define IMGUI_VERSION_NUM           18420
+#define IMGUI_CHECKVERSION()        ImGui::DebugCheckVersionAndDataLayout(IMGUI_VERSION, sizeof(ImGuiIO), sizeof(ImGuiStyle), sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert), sizeof(ImDrawIdx))
+#define IMGUI_HAS_TABLE
+
+// Define attributes of all API symbols declarations (e.g. for DLL under Windows)
+// IMGUI_API is used for core imgui functions, IMGUI_IMPL_API is used for the default backends files (imgui_impl_xxx.h)
+// Using dear imgui via a shared library is not recommended, because we don't guarantee backward nor forward ABI compatibility (also function call overhead, as dear imgui is a call-heavy API)
+#ifndef IMGUI_API
+#define IMGUI_API
+#endif
+#ifndef IMGUI_IMPL_API
+#define IMGUI_IMPL_API              IMGUI_API
+#endif
+
+// Helper Macros
+#ifndef IM_ASSERT
+#include <assert.h>
+#define IM_ASSERT(_EXPR)            assert(_EXPR)                               // You can override the default assert handler by editing imconfig.h
+#endif
+#define IM_ARRAYSIZE(_ARR)          ((int)(sizeof(_ARR) / sizeof(*(_ARR))))     // Size of a static C-style array. Don't use on pointers!
+#define IM_UNUSED(_VAR)             ((void)(_VAR))                              // Used to silence "unused variable warnings". Often useful as asserts may be stripped out from final builds.
+#if (__cplusplus >= 201100) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201100)
+#define IM_OFFSETOF(_TYPE,_MEMBER)  offsetof(_TYPE, _MEMBER)                    // Offset of _MEMBER within _TYPE. Standardized as offsetof() in C++11
+#else
+#define IM_OFFSETOF(_TYPE,_MEMBER)  ((size_t)&(((_TYPE*)0)->_MEMBER))           // Offset of _MEMBER within _TYPE. Old style macro.
+#endif
+
+// Helper Macros - IM_FMTARGS, IM_FMTLIST: Apply printf-style warnings to our formatting functions.
+#if !defined(IMGUI_USE_STB_SPRINTF) && defined(__MINGW32__) && !defined(__clang__)
+#define IM_FMTARGS(FMT)             __attribute__((format(gnu_printf, FMT, FMT+1)))
+#define IM_FMTLIST(FMT)             __attribute__((format(gnu_printf, FMT, 0)))
+#elif !defined(IMGUI_USE_STB_SPRINTF) && (defined(__clang__) || defined(__GNUC__))
+#define IM_FMTARGS(FMT)             __attribute__((format(printf, FMT, FMT+1)))
+#define IM_FMTLIST(FMT)             __attribute__((format(printf, FMT, 0)))
+#else
+#define IM_FMTARGS(FMT)
+#define IM_FMTLIST(FMT)
+#endif
+
+// Disable some of MSVC most aggressive Debug runtime checks in function header/footer (used in some simple/low-level functions)
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(IMGUI_DEBUG_PARANOID)
+#define IM_MSVC_RUNTIME_CHECKS_OFF      __pragma(runtime_checks("",off))     __pragma(check_stack(off)) __pragma(strict_gs_check(push,off))
+#define IM_MSVC_RUNTIME_CHECKS_RESTORE  __pragma(runtime_checks("",restore)) __pragma(check_stack())    __pragma(strict_gs_check(pop))
+#else
+#define IM_MSVC_RUNTIME_CHECKS_OFF
+#define IM_MSVC_RUNTIME_CHECKS_RESTORE
+#endif
+
+// Warnings
+#ifdef _MSC_VER
+#pragma warning (push)
+#pragma warning (disable: 26495)    // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6).
+#endif
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#if __has_warning("-Wzero-as-null-pointer-constant")
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas"          // warning: unknown option after '#pragma GCC diagnostic' kind
+#pragma GCC diagnostic ignored "-Wclass-memaccess"  // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
+#endif
+
+//-----------------------------------------------------------------------------
+// [SECTION] Forward declarations and basic types
+//-----------------------------------------------------------------------------
+
+// Forward declarations
+struct ImDrawChannel;               // Temporary storage to output draw commands out of order, used by ImDrawListSplitter and ImDrawList::ChannelsSplit()
+struct ImDrawCmd;                   // A single draw command within a parent ImDrawList (generally maps to 1 GPU draw call, unless it is a callback)
+struct ImDrawData;                  // All draw command lists required to render the frame + pos/size coordinates to use for the projection matrix.
+struct ImDrawList;                  // A single draw command list (generally one per window, conceptually you may see this as a dynamic "mesh" builder)
+struct ImDrawListSharedData;        // Data shared among multiple draw lists (typically owned by parent ImGui context, but you may create one yourself)
+struct ImDrawListSplitter;          // Helper to split a draw list into different layers which can be drawn into out of order, then flattened back.
+struct ImDrawVert;                  // A single vertex (pos + uv + col = 20 bytes by default. Override layout with IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT)
+struct ImFont;                      // Runtime data for a single font within a parent ImFontAtlas
+struct ImFontAtlas;                 // Runtime data for multiple fonts, bake multiple fonts into a single texture, TTF/OTF font loader
+struct ImFontBuilderIO;             // Opaque interface to a font builder (stb_truetype or FreeType).
+struct ImFontConfig;                // Configuration data when adding a font or merging fonts
+struct ImFontGlyph;                 // A single font glyph (code point + coordinates within in ImFontAtlas + offset)
+struct ImFontGlyphRangesBuilder;    // Helper to build glyph ranges from text/string data
+struct ImColor;                     // Helper functions to create a color that can be converted to either u32 or float4 (*OBSOLETE* please avoid using)
+struct ImGuiContext;                // Dear ImGui context (opaque structure, unless including imgui_internal.h)
+struct ImGuiIO;                     // Main configuration and I/O between your application and ImGui
+struct ImGuiInputTextCallbackData;  // Shared state of InputText() when using custom ImGuiInputTextCallback (rare/advanced use)
+struct ImGuiListClipper;            // Helper to manually clip large list of items
+struct ImGuiOnceUponAFrame;         // Helper for running a block of code not more than once a frame, used by IMGUI_ONCE_UPON_A_FRAME macro
+struct ImGuiPayload;                // User data payload for drag and drop operations
+struct ImGuiSizeCallbackData;       // Callback data when using SetNextWindowSizeConstraints() (rare/advanced use)
+struct ImGuiStorage;                // Helper for key->value storage
+struct ImGuiStyle;                  // Runtime data for styling/colors
+struct ImGuiTableSortSpecs;         // Sorting specifications for a table (often handling sort specs for a single column, occasionally more)
+struct ImGuiTableColumnSortSpecs;   // Sorting specification for one column of a table
+struct ImGuiTextBuffer;             // Helper to hold and append into a text buffer (~string builder)
+struct ImGuiTextFilter;             // Helper to parse and apply text filters (e.g. "aaaaa[,bbbbb][,ccccc]")
+struct ImGuiViewport;               // A Platform Window (always only one in 'master' branch), in the future may represent Platform Monitor
+
+// Enums/Flags (declared as int for compatibility with old C++, to allow using as flags without overhead, and to not pollute the top of this file)
+// - Tip: Use your programming IDE navigation facilities on the names in the _central column_ below to find the actual flags/enum lists!
+//   In Visual Studio IDE: CTRL+comma ("Edit.NavigateTo") can follow symbols in comments, whereas CTRL+F12 ("Edit.GoToImplementation") cannot.
+//   With Visual Assist installed: ALT+G ("VAssistX.GoToImplementation") can also follow symbols in comments.
+typedef int ImGuiCol;               // -> enum ImGuiCol_             // Enum: A color identifier for styling
+typedef int ImGuiCond;              // -> enum ImGuiCond_            // Enum: A condition for many Set*() functions
+typedef int ImGuiDataType;          // -> enum ImGuiDataType_        // Enum: A primary data type
+typedef int ImGuiDir;               // -> enum ImGuiDir_             // Enum: A cardinal direction
+typedef int ImGuiKey;               // -> enum ImGuiKey_             // Enum: A key identifier (ImGui-side enum)
+typedef int ImGuiNavInput;          // -> enum ImGuiNavInput_        // Enum: An input identifier for navigation
+typedef int ImGuiMouseButton;       // -> enum ImGuiMouseButton_     // Enum: A mouse button identifier (0=left, 1=right, 2=middle)
+typedef int ImGuiMouseCursor;       // -> enum ImGuiMouseCursor_     // Enum: A mouse cursor identifier
+typedef int ImGuiSortDirection;     // -> enum ImGuiSortDirection_   // Enum: A sorting direction (ascending or descending)
+typedef int ImGuiStyleVar;          // -> enum ImGuiStyleVar_        // Enum: A variable identifier for styling
+typedef int ImGuiTableBgTarget;     // -> enum ImGuiTableBgTarget_   // Enum: A color target for TableSetBgColor()
+typedef int ImDrawFlags;            // -> enum ImDrawFlags_          // Flags: for ImDrawList functions
+typedef int ImDrawListFlags;        // -> enum ImDrawListFlags_      // Flags: for ImDrawList instance
+typedef int ImFontAtlasFlags;       // -> enum ImFontAtlasFlags_     // Flags: for ImFontAtlas build
+typedef int ImGuiBackendFlags;      // -> enum ImGuiBackendFlags_    // Flags: for io.BackendFlags
+typedef int ImGuiButtonFlags;       // -> enum ImGuiButtonFlags_     // Flags: for InvisibleButton()
+typedef int ImGuiColorEditFlags;    // -> enum ImGuiColorEditFlags_  // Flags: for ColorEdit4(), ColorPicker4() etc.
+typedef int ImGuiConfigFlags;       // -> enum ImGuiConfigFlags_     // Flags: for io.ConfigFlags
+typedef int ImGuiComboFlags;        // -> enum ImGuiComboFlags_      // Flags: for BeginCombo()
+typedef int ImGuiDragDropFlags;     // -> enum ImGuiDragDropFlags_   // Flags: for BeginDragDropSource(), AcceptDragDropPayload()
+typedef int ImGuiFocusedFlags;      // -> enum ImGuiFocusedFlags_    // Flags: for IsWindowFocused()
+typedef int ImGuiHoveredFlags;      // -> enum ImGuiHoveredFlags_    // Flags: for IsItemHovered(), IsWindowHovered() etc.
+typedef int ImGuiInputTextFlags;    // -> enum ImGuiInputTextFlags_  // Flags: for InputText(), InputTextMultiline()
+typedef int ImGuiKeyModFlags;       // -> enum ImGuiKeyModFlags_     // Flags: for io.KeyMods (Ctrl/Shift/Alt/Super)
+typedef int ImGuiPopupFlags;        // -> enum ImGuiPopupFlags_      // Flags: for OpenPopup*(), BeginPopupContext*(), IsPopupOpen()
+typedef int ImGuiSelectableFlags;   // -> enum ImGuiSelectableFlags_ // Flags: for Selectable()
+typedef int ImGuiSliderFlags;       // -> enum ImGuiSliderFlags_     // Flags: for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.
+typedef int ImGuiTabBarFlags;       // -> enum ImGuiTabBarFlags_     // Flags: for BeginTabBar()
+typedef int ImGuiTabItemFlags;      // -> enum ImGuiTabItemFlags_    // Flags: for BeginTabItem()
+typedef int ImGuiTableFlags;        // -> enum ImGuiTableFlags_      // Flags: For BeginTable()
+typedef int ImGuiTableColumnFlags;  // -> enum ImGuiTableColumnFlags_// Flags: For TableSetupColumn()
+typedef int ImGuiTableRowFlags;     // -> enum ImGuiTableRowFlags_   // Flags: For TableNextRow()
+typedef int ImGuiTreeNodeFlags;     // -> enum ImGuiTreeNodeFlags_   // Flags: for TreeNode(), TreeNodeEx(), CollapsingHeader()
+typedef int ImGuiViewportFlags;     // -> enum ImGuiViewportFlags_   // Flags: for ImGuiViewport
+typedef int ImGuiWindowFlags;       // -> enum ImGuiWindowFlags_     // Flags: for Begin(), BeginChild()
+
+// ImTexture: user data for renderer backend to identify a texture [Compile-time configurable type]
+// - To use something else than an opaque void* pointer: override with e.g. '#define ImTextureID MyTextureType*' in your imconfig.h file.
+// - This can be whatever to you want it to be! read the FAQ about ImTextureID for details.
+#ifndef ImTextureID
+typedef void* ImTextureID;          // Default: store a pointer or an integer fitting in a pointer (most renderer backends are ok with that)
+#endif
+
+// ImDrawIdx: vertex index. [Compile-time configurable type]
+// - To use 16-bit indices + allow large meshes: backend need to set 'io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset' and handle ImDrawCmd::VtxOffset (recommended).
+// - To use 32-bit indices: override with '#define ImDrawIdx unsigned int' in your imconfig.h file.
+#ifndef ImDrawIdx
+typedef unsigned short ImDrawIdx;   // Default: 16-bit (for maximum compatibility with renderer backends)
+#endif
+
+// Scalar data types
+typedef unsigned int        ImGuiID;// A unique ID used by widgets (typically the result of hashing a stack of string)
+typedef signed char         ImS8;   // 8-bit signed integer
+typedef unsigned char       ImU8;   // 8-bit unsigned integer
+typedef signed short        ImS16;  // 16-bit signed integer
+typedef unsigned short      ImU16;  // 16-bit unsigned integer
+typedef signed int          ImS32;  // 32-bit signed integer == int
+typedef unsigned int        ImU32;  // 32-bit unsigned integer (often used to store packed colors)
+#if defined(_MSC_VER) && !defined(__clang__)
+typedef signed   __int64    ImS64;  // 64-bit signed integer (pre and post C++11 with Visual Studio)
+typedef unsigned __int64    ImU64;  // 64-bit unsigned integer (pre and post C++11 with Visual Studio)
+#elif (defined(__clang__) || defined(__GNUC__)) && (__cplusplus < 201100)
+#include <stdint.h>
+typedef int64_t             ImS64;  // 64-bit signed integer (pre C++11)
+typedef uint64_t            ImU64;  // 64-bit unsigned integer (pre C++11)
+#else
+typedef signed   long long  ImS64;  // 64-bit signed integer (post C++11)
+typedef unsigned long long  ImU64;  // 64-bit unsigned integer (post C++11)
+#endif
+
+// Character types
+// (we generally use UTF-8 encoded string in the API. This is storage specifically for a decoded character used for keyboard input and display)
+typedef unsigned short ImWchar16;   // A single decoded U16 character/code point. We encode them as multi bytes UTF-8 when used in strings.
+typedef unsigned int ImWchar32;     // A single decoded U32 character/code point. We encode them as multi bytes UTF-8 when used in strings.
+#ifdef IMGUI_USE_WCHAR32            // ImWchar [configurable type: override in imconfig.h with '#define IMGUI_USE_WCHAR32' to support Unicode planes 1-16]
+typedef ImWchar32 ImWchar;
+#else
+typedef ImWchar16 ImWchar;
+#endif
+
+// Callback and functions types
+typedef int     (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData* data);    // Callback function for ImGui::InputText()
+typedef void    (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data);              // Callback function for ImGui::SetNextWindowSizeConstraints()
+typedef void*   (*ImGuiMemAllocFunc)(size_t sz, void* user_data);               // Function signature for ImGui::SetAllocatorFunctions()
+typedef void    (*ImGuiMemFreeFunc)(void* ptr, void* user_data);                // Function signature for ImGui::SetAllocatorFunctions()
+
+// ImVec2: 2D vector used to store positions, sizes etc. [Compile-time configurable type]
+// This is a frequently used type in the API. Consider using IM_VEC2_CLASS_EXTRA to create implicit cast from/to our preferred type.
+IM_MSVC_RUNTIME_CHECKS_OFF
+struct ImVec2
+{
+    float                                   x, y;
+    ImVec2()                                { x = y = 0.0f; }
+    ImVec2(float _x, float _y)              { x = _x; y = _y; }
+    float  operator[] (size_t idx) const    { IM_ASSERT(idx <= 1); return (&x)[idx]; }    // We very rarely use this [] operator, the assert overhead is fine.
+    float& operator[] (size_t idx)          { IM_ASSERT(idx <= 1); return (&x)[idx]; }    // We very rarely use this [] operator, the assert overhead is fine.
+#ifdef IM_VEC2_CLASS_EXTRA
+    IM_VEC2_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h to convert back and forth between your math types and ImVec2.
+#endif
+};
+
+// ImVec4: 4D vector used to store clipping rectangles, colors etc. [Compile-time configurable type]
+struct ImVec4
+{
+    float                                           x, y, z, w;
+    ImVec4()                                        { x = y = z = w = 0.0f; }
+    ImVec4(float _x, float _y, float _z, float _w)  { x = _x; y = _y; z = _z; w = _w; }
+#ifdef IM_VEC4_CLASS_EXTRA
+    IM_VEC4_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h to convert back and forth between your math types and ImVec4.
+#endif
+};
+IM_MSVC_RUNTIME_CHECKS_RESTORE
+
+//-----------------------------------------------------------------------------
+// [SECTION] Dear ImGui end-user API functions
+// (Note that ImGui:: being a namespace, you can add extra ImGui:: functions in your own separate file. Please don't modify imgui source files!)
+//-----------------------------------------------------------------------------
+
+namespace ImGui
+{
+    // Context creation and access
+    // - Each context create its own ImFontAtlas by default. You may instance one yourself and pass it to CreateContext() to share a font atlas between contexts.
+    // - DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+    //   for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for details.
+    IMGUI_API ImGuiContext* CreateContext(ImFontAtlas* shared_font_atlas = NULL);
+    IMGUI_API void          DestroyContext(ImGuiContext* ctx = NULL);   // NULL = destroy current context
+    IMGUI_API ImGuiContext* GetCurrentContext();
+    IMGUI_API void          SetCurrentContext(ImGuiContext* ctx);
+
+    // Main
+    IMGUI_API ImGuiIO&      GetIO();                                    // access the IO structure (mouse/keyboard/gamepad inputs, time, various configuration options/flags)
+    IMGUI_API ImGuiStyle&   GetStyle();                                 // access the Style structure (colors, sizes). Always use PushStyleCol(), PushStyleVar() to modify style mid-frame!
+    IMGUI_API void          NewFrame();                                 // start a new Dear ImGui frame, you can submit any command from this point until Render()/EndFrame().
+    IMGUI_API void          EndFrame();                                 // ends the Dear ImGui frame. automatically called by Render(). If you don't need to render data (skipping rendering) you may call EndFrame() without Render()... but you'll have wasted CPU already! If you don't need to render, better to not create any windows and not call NewFrame() at all!
+    IMGUI_API void          Render();                                   // ends the Dear ImGui frame, finalize the draw data. You can then get call GetDrawData().
+    IMGUI_API ImDrawData*   GetDrawData();                              // valid after Render() and until the next call to NewFrame(). this is what you have to render.
+
+    // Demo, Debug, Information
+    IMGUI_API void          ShowDemoWindow(bool* p_open = NULL);        // create Demo window. demonstrate most ImGui features. call this to learn about the library! try to make it always available in your application!
+    IMGUI_API void          ShowMetricsWindow(bool* p_open = NULL);     // create Metrics/Debugger window. display Dear ImGui internals: windows, draw commands, various internal state, etc.
+    IMGUI_API void          ShowStackToolWindow(bool* p_open = NULL);   // create Stack Tool window. hover items with mouse to query information about the source of their unique ID.
+    IMGUI_API void          ShowAboutWindow(bool* p_open = NULL);       // create About window. display Dear ImGui version, credits and build/system information.
+    IMGUI_API void          ShowStyleEditor(ImGuiStyle* ref = NULL);    // add style editor block (not a window). you can pass in a reference ImGuiStyle structure to compare to, revert to and save to (else it uses the default style)
+    IMGUI_API bool          ShowStyleSelector(const char* label);       // add style selector block (not a window), essentially a combo listing the default styles.
+    IMGUI_API void          ShowFontSelector(const char* label);        // add font selector block (not a window), essentially a combo listing the loaded fonts.
+    IMGUI_API void          ShowUserGuide();                            // add basic help/info block (not a window): how to manipulate ImGui as a end-user (mouse/keyboard controls).
+    IMGUI_API const char*   GetVersion();                               // get the compiled version string e.g. "1.80 WIP" (essentially the value for IMGUI_VERSION from the compiled version of imgui.cpp)
+
+    // Styles
+    IMGUI_API void          StyleColorsDark(ImGuiStyle* dst = NULL);    // new, recommended style (default)
+    IMGUI_API void          StyleColorsLight(ImGuiStyle* dst = NULL);   // best used with borders and a custom, thicker font
+    IMGUI_API void          StyleColorsClassic(ImGuiStyle* dst = NULL); // classic imgui style
+
+    // Windows
+    // - Begin() = push window to the stack and start appending to it. End() = pop window from the stack.
+    // - Passing 'bool* p_open != NULL' shows a window-closing widget in the upper-right corner of the window,
+    //   which clicking will set the boolean to false when clicked.
+    // - You may append multiple times to the same window during the same frame by calling Begin()/End() pairs multiple times.
+    //   Some information such as 'flags' or 'p_open' will only be considered by the first call to Begin().
+    // - Begin() return false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting
+    //   anything to the window. Always call a matching End() for each Begin() call, regardless of its return value!
+    //   [Important: due to legacy reason, this is inconsistent with most other functions such as BeginMenu/EndMenu,
+    //    BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function
+    //    returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.]
+    // - Note that the bottom of window stack always contains a window called "Debug".
+    IMGUI_API bool          Begin(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0);
+    IMGUI_API void          End();
+
+    // Child Windows
+    // - Use child windows to begin into a self-contained independent scrolling/clipping regions within a host window. Child windows can embed their own child.
+    // - For each independent axis of 'size': ==0.0f: use remaining host window size / >0.0f: fixed size / <0.0f: use remaining window size minus abs(size) / Each axis can use a different mode, e.g. ImVec2(0,400).
+    // - BeginChild() returns false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window.
+    //   Always call a matching EndChild() for each BeginChild() call, regardless of its return value.
+    //   [Important: due to legacy reason, this is inconsistent with most other functions such as BeginMenu/EndMenu,
+    //    BeginPopup/EndPopup, etc. where the EndXXX call should only be called if the corresponding BeginXXX function
+    //    returned true. Begin and BeginChild are the only odd ones out. Will be fixed in a future update.]
+    IMGUI_API bool          BeginChild(const char* str_id, const ImVec2& size = ImVec2(0, 0), bool border = false, ImGuiWindowFlags flags = 0);
+    IMGUI_API bool          BeginChild(ImGuiID id, const ImVec2& size = ImVec2(0, 0), bool border = false, ImGuiWindowFlags flags = 0);
+    IMGUI_API void          EndChild();
+
+    // Windows Utilities
+    // - 'current window' = the window we are appending into while inside a Begin()/End() block. 'next window' = next window we will Begin() into.
+    IMGUI_API bool          IsWindowAppearing();
+    IMGUI_API bool          IsWindowCollapsed();
+    IMGUI_API bool          IsWindowFocused(ImGuiFocusedFlags flags=0); // is current window focused? or its root/child, depending on flags. see flags for options.
+    IMGUI_API bool          IsWindowHovered(ImGuiHoveredFlags flags=0); // is current window hovered (and typically: not blocked by a popup/modal)? see flags for options. NB: If you are trying to check whether your mouse should be dispatched to imgui or to your app, you should use the 'io.WantCaptureMouse' boolean for that! Please read the FAQ!
+    IMGUI_API ImDrawList*   GetWindowDrawList();                        // get draw list associated to the current window, to append your own drawing primitives
+    IMGUI_API ImVec2        GetWindowPos();                             // get current window position in screen space (useful if you want to do your own drawing via the DrawList API)
+    IMGUI_API ImVec2        GetWindowSize();                            // get current window size
+    IMGUI_API float         GetWindowWidth();                           // get current window width (shortcut for GetWindowSize().x)
+    IMGUI_API float         GetWindowHeight();                          // get current window height (shortcut for GetWindowSize().y)
+
+    // Window manipulation
+    // - Prefer using SetNextXXX functions (before Begin) rather that SetXXX functions (after Begin).
+    IMGUI_API void          SetNextWindowPos(const ImVec2& pos, ImGuiCond cond = 0, const ImVec2& pivot = ImVec2(0, 0)); // set next window position. call before Begin(). use pivot=(0.5f,0.5f) to center on given point, etc.
+    IMGUI_API void          SetNextWindowSize(const ImVec2& size, ImGuiCond cond = 0);                  // set next window size. set axis to 0.0f to force an auto-fit on this axis. call before Begin()
+    IMGUI_API void          SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback = NULL, void* custom_callback_data = NULL); // set next window size limits. use -1,-1 on either X/Y axis to preserve the current size. Sizes will be rounded down. Use callback to apply non-trivial programmatic constraints.
+    IMGUI_API void          SetNextWindowContentSize(const ImVec2& size);                               // set next window content size (~ scrollable client area, which enforce the range of scrollbars). Not including window decorations (title bar, menu bar, etc.) nor WindowPadding. set an axis to 0.0f to leave it automatic. call before Begin()
+    IMGUI_API void          SetNextWindowCollapsed(bool collapsed, ImGuiCond cond = 0);                 // set next window collapsed state. call before Begin()
+    IMGUI_API void          SetNextWindowFocus();                                                       // set next window to be focused / top-most. call before Begin()
+    IMGUI_API void          SetNextWindowBgAlpha(float alpha);                                          // set next window background color alpha. helper to easily override the Alpha component of ImGuiCol_WindowBg/ChildBg/PopupBg. you may also use ImGuiWindowFlags_NoBackground.
+    IMGUI_API void          SetWindowPos(const ImVec2& pos, ImGuiCond cond = 0);                        // (not recommended) set current window position - call within Begin()/End(). prefer using SetNextWindowPos(), as this may incur tearing and side-effects.
+    IMGUI_API void          SetWindowSize(const ImVec2& size, ImGuiCond cond = 0);                      // (not recommended) set current window size - call within Begin()/End(). set to ImVec2(0, 0) to force an auto-fit. prefer using SetNextWindowSize(), as this may incur tearing and minor side-effects.
+    IMGUI_API void          SetWindowCollapsed(bool collapsed, ImGuiCond cond = 0);                     // (not recommended) set current window collapsed state. prefer using SetNextWindowCollapsed().
+    IMGUI_API void          SetWindowFocus();                                                           // (not recommended) set current window to be focused / top-most. prefer using SetNextWindowFocus().
+    IMGUI_API void          SetWindowFontScale(float scale);                                            // [OBSOLETE] set font scale. Adjust IO.FontGlobalScale if you want to scale all windows. This is an old API! For correct scaling, prefer to reload font + rebuild ImFontAtlas + call style.ScaleAllSizes().
+    IMGUI_API void          SetWindowPos(const char* name, const ImVec2& pos, ImGuiCond cond = 0);      // set named window position.
+    IMGUI_API void          SetWindowSize(const char* name, const ImVec2& size, ImGuiCond cond = 0);    // set named window size. set axis to 0.0f to force an auto-fit on this axis.
+    IMGUI_API void          SetWindowCollapsed(const char* name, bool collapsed, ImGuiCond cond = 0);   // set named window collapsed state
+    IMGUI_API void          SetWindowFocus(const char* name);                                           // set named window to be focused / top-most. use NULL to remove focus.
+
+    // Content region
+    // - Retrieve available space from a given point. GetContentRegionAvail() is frequently useful.
+    // - Those functions are bound to be redesigned (they are confusing, incomplete and the Min/Max return values are in local window coordinates which increases confusion)
+    IMGUI_API ImVec2        GetContentRegionAvail();                                        // == GetContentRegionMax() - GetCursorPos()
+    IMGUI_API ImVec2        GetContentRegionMax();                                          // current content boundaries (typically window boundaries including scrolling, or current column boundaries), in windows coordinates
+    IMGUI_API ImVec2        GetWindowContentRegionMin();                                    // content boundaries min for the full window (roughly (0,0)-Scroll), in window coordinates
+    IMGUI_API ImVec2        GetWindowContentRegionMax();                                    // content boundaries max for the full window (roughly (0,0)+Size-Scroll) where Size can be override with SetNextWindowContentSize(), in window coordinates
+
+    // Windows Scrolling
+    IMGUI_API float         GetScrollX();                                                   // get scrolling amount [0 .. GetScrollMaxX()]
+    IMGUI_API float         GetScrollY();                                                   // get scrolling amount [0 .. GetScrollMaxY()]
+    IMGUI_API void          SetScrollX(float scroll_x);                                     // set scrolling amount [0 .. GetScrollMaxX()]
+    IMGUI_API void          SetScrollY(float scroll_y);                                     // set scrolling amount [0 .. GetScrollMaxY()]
+    IMGUI_API float         GetScrollMaxX();                                                // get maximum scrolling amount ~~ ContentSize.x - WindowSize.x - DecorationsSize.x
+    IMGUI_API float         GetScrollMaxY();                                                // get maximum scrolling amount ~~ ContentSize.y - WindowSize.y - DecorationsSize.y
+    IMGUI_API void          SetScrollHereX(float center_x_ratio = 0.5f);                    // adjust scrolling amount to make current cursor position visible. center_x_ratio=0.0: left, 0.5: center, 1.0: right. When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
+    IMGUI_API void          SetScrollHereY(float center_y_ratio = 0.5f);                    // adjust scrolling amount to make current cursor position visible. center_y_ratio=0.0: top, 0.5: center, 1.0: bottom. When using to make a "default/current item" visible, consider using SetItemDefaultFocus() instead.
+    IMGUI_API void          SetScrollFromPosX(float local_x, float center_x_ratio = 0.5f);  // adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
+    IMGUI_API void          SetScrollFromPosY(float local_y, float center_y_ratio = 0.5f);  // adjust scrolling amount to make given position visible. Generally GetCursorStartPos() + offset to compute a valid position.
+
+    // Parameters stacks (shared)
+    IMGUI_API void          PushFont(ImFont* font);                                         // use NULL as a shortcut to push default font
+    IMGUI_API void          PopFont();
+    IMGUI_API void          PushStyleColor(ImGuiCol idx, ImU32 col);                        // modify a style color. always use this if you modify the style after NewFrame().
+    IMGUI_API void          PushStyleColor(ImGuiCol idx, const ImVec4& col);
+    IMGUI_API void          PopStyleColor(int count = 1);
+    IMGUI_API void          PushStyleVar(ImGuiStyleVar idx, float val);                     // modify a style float variable. always use this if you modify the style after NewFrame().
+    IMGUI_API void          PushStyleVar(ImGuiStyleVar idx, const ImVec2& val);             // modify a style ImVec2 variable. always use this if you modify the style after NewFrame().
+    IMGUI_API void          PopStyleVar(int count = 1);
+    IMGUI_API void          PushAllowKeyboardFocus(bool allow_keyboard_focus);              // == tab stop enable. Allow focusing using TAB/Shift-TAB, enabled by default but you can disable it for certain widgets
+    IMGUI_API void          PopAllowKeyboardFocus();
+    IMGUI_API void          PushButtonRepeat(bool repeat);                                  // in 'repeat' mode, Button*() functions return repeated true in a typematic manner (using io.KeyRepeatDelay/io.KeyRepeatRate setting). Note that you can call IsItemActive() after any Button() to tell if the button is held in the current frame.
+    IMGUI_API void          PopButtonRepeat();
+
+    // Parameters stacks (current window)
+    IMGUI_API void          PushItemWidth(float item_width);                                // push width of items for common large "item+label" widgets. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side).
+    IMGUI_API void          PopItemWidth();
+    IMGUI_API void          SetNextItemWidth(float item_width);                             // set width of the _next_ common large "item+label" widget. >0.0f: width in pixels, <0.0f align xx pixels to the right of window (so -FLT_MIN always align width to the right side)
+    IMGUI_API float         CalcItemWidth();                                                // width of item given pushed settings and current cursor position. NOT necessarily the width of last item unlike most 'Item' functions.
+    IMGUI_API void          PushTextWrapPos(float wrap_local_pos_x = 0.0f);                 // push word-wrapping position for Text*() commands. < 0.0f: no wrapping; 0.0f: wrap to end of window (or column); > 0.0f: wrap at 'wrap_pos_x' position in window local space
+    IMGUI_API void          PopTextWrapPos();
+
+    // Style read access
+    // - Use the style editor (ShowStyleEditor() function) to interactively see what the colors are)
+    IMGUI_API ImFont*       GetFont();                                                      // get current font
+    IMGUI_API float         GetFontSize();                                                  // get current font size (= height in pixels) of current font with current scale applied
+    IMGUI_API ImVec2        GetFontTexUvWhitePixel();                                       // get UV coordinate for a while pixel, useful to draw custom shapes via the ImDrawList API
+    IMGUI_API ImU32         GetColorU32(ImGuiCol idx, float alpha_mul = 1.0f);              // retrieve given style color with style alpha applied and optional extra alpha multiplier, packed as a 32-bit value suitable for ImDrawList
+    IMGUI_API ImU32         GetColorU32(const ImVec4& col);                                 // retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList
+    IMGUI_API ImU32         GetColorU32(ImU32 col);                                         // retrieve given color with style alpha applied, packed as a 32-bit value suitable for ImDrawList
+    IMGUI_API const ImVec4& GetStyleColorVec4(ImGuiCol idx);                                // retrieve style color as stored in ImGuiStyle structure. use to feed back into PushStyleColor(), otherwise use GetColorU32() to get style color with style alpha baked in.
+
+    // Cursor / Layout
+    // - By "cursor" we mean the current output position.
+    // - The typical widget behavior is to output themselves at the current cursor position, then move the cursor one line down.
+    // - You can call SameLine() between widgets to undo the last carriage return and output at the right of the preceding widget.
+    // - Attention! We currently have inconsistencies between window-local and absolute positions we will aim to fix with future API:
+    //    Window-local coordinates:   SameLine(), GetCursorPos(), SetCursorPos(), GetCursorStartPos(), GetContentRegionMax(), GetWindowContentRegion*(), PushTextWrapPos()
+    //    Absolute coordinate:        GetCursorScreenPos(), SetCursorScreenPos(), all ImDrawList:: functions.
+    IMGUI_API void          Separator();                                                    // separator, generally horizontal. inside a menu bar or in horizontal layout mode, this becomes a vertical separator.
+    IMGUI_API void          SameLine(float offset_from_start_x=0.0f, float spacing=-1.0f);  // call between widgets or groups to layout them horizontally. X position given in window coordinates.
+    IMGUI_API void          NewLine();                                                      // undo a SameLine() or force a new line when in an horizontal-layout context.
+    IMGUI_API void          Spacing();                                                      // add vertical spacing.
+    IMGUI_API void          Dummy(const ImVec2& size);                                      // add a dummy item of given size. unlike InvisibleButton(), Dummy() won't take the mouse click or be navigable into.
+    IMGUI_API void          Indent(float indent_w = 0.0f);                                  // move content position toward the right, by indent_w, or style.IndentSpacing if indent_w <= 0
+    IMGUI_API void          Unindent(float indent_w = 0.0f);                                // move content position back to the left, by indent_w, or style.IndentSpacing if indent_w <= 0
+    IMGUI_API void          BeginGroup();                                                   // lock horizontal starting position
+    IMGUI_API void          EndGroup();                                                     // unlock horizontal starting position + capture the whole group bounding box into one "item" (so you can use IsItemHovered() or layout primitives such as SameLine() on whole group, etc.)
+    IMGUI_API ImVec2        GetCursorPos();                                                 // cursor position in window coordinates (relative to window position)
+    IMGUI_API float         GetCursorPosX();                                                //   (some functions are using window-relative coordinates, such as: GetCursorPos, GetCursorStartPos, GetContentRegionMax, GetWindowContentRegion* etc.
+    IMGUI_API float         GetCursorPosY();                                                //    other functions such as GetCursorScreenPos or everything in ImDrawList::
+    IMGUI_API void          SetCursorPos(const ImVec2& local_pos);                          //    are using the main, absolute coordinate system.
+    IMGUI_API void          SetCursorPosX(float local_x);                                   //    GetWindowPos() + GetCursorPos() == GetCursorScreenPos() etc.)
+    IMGUI_API void          SetCursorPosY(float local_y);                                   //
+    IMGUI_API ImVec2        GetCursorStartPos();                                            // initial cursor position in window coordinates
+    IMGUI_API ImVec2        GetCursorScreenPos();                                           // cursor position in absolute coordinates (useful to work with ImDrawList API). generally top-left == GetMainViewport()->Pos == (0,0) in single viewport mode, and bottom-right == GetMainViewport()->Pos+Size == io.DisplaySize in single-viewport mode.
+    IMGUI_API void          SetCursorScreenPos(const ImVec2& pos);                          // cursor position in absolute coordinates
+    IMGUI_API void          AlignTextToFramePadding();                                      // vertically align upcoming text baseline to FramePadding.y so that it will align properly to regularly framed items (call if you have text on a line before a framed item)
+    IMGUI_API float         GetTextLineHeight();                                            // ~ FontSize
+    IMGUI_API float         GetTextLineHeightWithSpacing();                                 // ~ FontSize + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of text)
+    IMGUI_API float         GetFrameHeight();                                               // ~ FontSize + style.FramePadding.y * 2
+    IMGUI_API float         GetFrameHeightWithSpacing();                                    // ~ FontSize + style.FramePadding.y * 2 + style.ItemSpacing.y (distance in pixels between 2 consecutive lines of framed widgets)
+
+    // ID stack/scopes
+    // Read the FAQ (docs/FAQ.md or http://dearimgui.org/faq) for more details about how ID are handled in dear imgui.
+    // - Those questions are answered and impacted by understanding of the ID stack system:
+    //   - "Q: Why is my widget not reacting when I click on it?"
+    //   - "Q: How can I have widgets with an empty label?"
+    //   - "Q: How can I have multiple widgets with the same label?"
+    // - Short version: ID are hashes of the entire ID stack. If you are creating widgets in a loop you most likely
+    //   want to push a unique identifier (e.g. object pointer, loop index) to uniquely differentiate them.
+    // - You can also use the "Label##foobar" syntax within widget label to distinguish them from each others.
+    // - In this header file we use the "label"/"name" terminology to denote a string that will be displayed + used as an ID,
+    //   whereas "str_id" denote a string that is only used as an ID and not normally displayed.
+    IMGUI_API void          PushID(const char* str_id);                                     // push string into the ID stack (will hash string).
+    IMGUI_API void          PushID(const char* str_id_begin, const char* str_id_end);       // push string into the ID stack (will hash string).
+    IMGUI_API void          PushID(const void* ptr_id);                                     // push pointer into the ID stack (will hash pointer).
+    IMGUI_API void          PushID(int int_id);                                             // push integer into the ID stack (will hash integer).
+    IMGUI_API void          PopID();                                                        // pop from the ID stack.
+    IMGUI_API ImGuiID       GetID(const char* str_id);                                      // calculate unique ID (hash of whole ID stack + given parameter). e.g. if you want to query into ImGuiStorage yourself
+    IMGUI_API ImGuiID       GetID(const char* str_id_begin, const char* str_id_end);
+    IMGUI_API ImGuiID       GetID(const void* ptr_id);
+
+    // Widgets: Text
+    IMGUI_API void          TextUnformatted(const char* text, const char* text_end = NULL); // raw text without formatting. Roughly equivalent to Text("%s", text) but: A) doesn't require null terminated string if 'text_end' is specified, B) it's faster, no memory copy is done, no buffer size limits, recommended for long chunks of text.
+    IMGUI_API void          Text(const char* fmt, ...)                                      IM_FMTARGS(1); // formatted text
+    IMGUI_API void          TextV(const char* fmt, va_list args)                            IM_FMTLIST(1);
+    IMGUI_API void          TextColored(const ImVec4& col, const char* fmt, ...)            IM_FMTARGS(2); // shortcut for PushStyleColor(ImGuiCol_Text, col); Text(fmt, ...); PopStyleColor();
+    IMGUI_API void          TextColoredV(const ImVec4& col, const char* fmt, va_list args)  IM_FMTLIST(2);
+    IMGUI_API void          TextDisabled(const char* fmt, ...)                              IM_FMTARGS(1); // shortcut for PushStyleColor(ImGuiCol_Text, style.Colors[ImGuiCol_TextDisabled]); Text(fmt, ...); PopStyleColor();
+    IMGUI_API void          TextDisabledV(const char* fmt, va_list args)                    IM_FMTLIST(1);
+    IMGUI_API void          TextWrapped(const char* fmt, ...)                               IM_FMTARGS(1); // shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();. Note that this won't work on an auto-resizing window if there's no other widgets to extend the window width, yoy may need to set a size using SetNextWindowSize().
+    IMGUI_API void          TextWrappedV(const char* fmt, va_list args)                     IM_FMTLIST(1);
+    IMGUI_API void          LabelText(const char* label, const char* fmt, ...)              IM_FMTARGS(2); // display text+label aligned the same way as value+label widgets
+    IMGUI_API void          LabelTextV(const char* label, const char* fmt, va_list args)    IM_FMTLIST(2);
+    IMGUI_API void          BulletText(const char* fmt, ...)                                IM_FMTARGS(1); // shortcut for Bullet()+Text()
+    IMGUI_API void          BulletTextV(const char* fmt, va_list args)                      IM_FMTLIST(1);
+
+    // Widgets: Main
+    // - Most widgets return true when the value has been changed or when pressed/selected
+    // - You may also use one of the many IsItemXXX functions (e.g. IsItemActive, IsItemHovered, etc.) to query widget state.
+    IMGUI_API bool          Button(const char* label, const ImVec2& size = ImVec2(0, 0));   // button
+    IMGUI_API bool          SmallButton(const char* label);                                 // button with FramePadding=(0,0) to easily embed within text
+    IMGUI_API bool          InvisibleButton(const char* str_id, const ImVec2& size, ImGuiButtonFlags flags = 0); // flexible button behavior without the visuals, frequently useful to build custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.)
+    IMGUI_API bool          ArrowButton(const char* str_id, ImGuiDir dir);                  // square button with an arrow shape
+    IMGUI_API void          Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0, 0), const ImVec2& uv1 = ImVec2(1,1), const ImVec4& tint_col = ImVec4(1,1,1,1), const ImVec4& border_col = ImVec4(0,0,0,0));
+    IMGUI_API bool          ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0, 0),  const ImVec2& uv1 = ImVec2(1,1), int frame_padding = -1, const ImVec4& bg_col = ImVec4(0,0,0,0), const ImVec4& tint_col = ImVec4(1,1,1,1));    // <0 frame_padding uses default frame padding settings. 0 for no padding
+    IMGUI_API bool          Checkbox(const char* label, bool* v);
+    IMGUI_API bool          CheckboxFlags(const char* label, int* flags, int flags_value);
+    IMGUI_API bool          CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value);
+    IMGUI_API bool          RadioButton(const char* label, bool active);                    // use with e.g. if (RadioButton("one", my_value==1)) { my_value = 1; }
+    IMGUI_API bool          RadioButton(const char* label, int* v, int v_button);           // shortcut to handle the above pattern when value is an integer
+    IMGUI_API void          ProgressBar(float fraction, const ImVec2& size_arg = ImVec2(-FLT_MIN, 0), const char* overlay = NULL);
+    IMGUI_API void          Bullet();                                                       // draw a small circle + keep the cursor on the same line. advance cursor x position by GetTreeNodeToLabelSpacing(), same distance that TreeNode() uses
+
+    // Widgets: Combo Box
+    // - The BeginCombo()/EndCombo() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() items.
+    // - The old Combo() api are helpers over BeginCombo()/EndCombo() which are kept available for convenience purpose. This is analogous to how ListBox are created.
+    IMGUI_API bool          BeginCombo(const char* label, const char* preview_value, ImGuiComboFlags flags = 0);
+    IMGUI_API void          EndCombo(); // only call EndCombo() if BeginCombo() returns true!
+    IMGUI_API bool          Combo(const char* label, int* current_item, const char* const items[], int items_count, int popup_max_height_in_items = -1);
+    IMGUI_API bool          Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int popup_max_height_in_items = -1);      // Separate items with \0 within a string, end item-list with \0\0. e.g. "One\0Two\0Three\0"
+    IMGUI_API bool          Combo(const char* label, int* current_item, bool(*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int popup_max_height_in_items = -1);
+
+    // Widgets: Drag Sliders
+    // - CTRL+Click on any drag box to turn them into an input box. Manually input values aren't clamped by default and can go off-bounds. Use ImGuiSliderFlags_AlwaysClamp to always clamp.
+    // - For all the Float2/Float3/Float4/Int2/Int3/Int4 versions of every functions, note that a 'float v[X]' function argument is the same as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible. You can pass address of your first element out of a contiguous set, e.g. &myvector.x
+    // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
+    // - Format string may also be set to NULL or use the default format ("%f" or "%d").
+    // - Speed are per-pixel of mouse movement (v_speed=0.2f: mouse needs to move by 5 pixels to increase value by 1). For gamepad/keyboard navigation, minimum speed is Max(v_speed, minimum_step_at_given_precision).
+    // - Use v_min < v_max to clamp edits to given limits. Note that CTRL+Click manual input can override those limits if ImGuiSliderFlags_AlwaysClamp is not used.
+    // - Use v_max = FLT_MAX / INT_MAX etc to avoid clamping to a maximum, same with v_min = -FLT_MAX / INT_MIN to avoid clamping to a minimum.
+    // - We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.
+    // - Legacy: Pre-1.78 there are DragXXX() function signatures that takes a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.
+    //   If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361
+    IMGUI_API bool          DragFloat(const char* label, float* v, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* format = "%.3f", ImGuiSliderFlags flags = 0);     // If v_min >= v_max we have no bound
+    IMGUI_API bool          DragFloat2(const char* label, float v[2], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragFloat3(const char* label, float v[3], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragFloat4(const char* label, float v[4], float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed = 1.0f, float v_min = 0.0f, float v_max = 0.0f, const char* format = "%.3f", const char* format_max = NULL, ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragInt(const char* label, int* v, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* format = "%d", ImGuiSliderFlags flags = 0);  // If v_min >= v_max we have no bound
+    IMGUI_API bool          DragInt2(const char* label, int v[2], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragInt3(const char* label, int v[3], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragInt4(const char* label, int v[4], float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed = 1.0f, int v_min = 0, int v_max = 0, const char* format = "%d", const char* format_max = NULL, ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragScalar(const char* label, ImGuiDataType data_type, void* p_data, float v_speed = 1.0f, const void* p_min = NULL, const void* p_max = NULL, const char* format = NULL, ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          DragScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, float v_speed = 1.0f, const void* p_min = NULL, const void* p_max = NULL, const char* format = NULL, ImGuiSliderFlags flags = 0);
+
+    // Widgets: Regular Sliders
+    // - CTRL+Click on any slider to turn them into an input box. Manually input values aren't clamped by default and can go off-bounds. Use ImGuiSliderFlags_AlwaysClamp to always clamp.
+    // - Adjust format string to decorate the value with a prefix, a suffix, or adapt the editing and display precision e.g. "%.3f" -> 1.234; "%5.2f secs" -> 01.23 secs; "Biscuit: %.0f" -> Biscuit: 1; etc.
+    // - Format string may also be set to NULL or use the default format ("%f" or "%d").
+    // - Legacy: Pre-1.78 there are SliderXXX() function signatures that takes a final `float power=1.0f' argument instead of the `ImGuiSliderFlags flags=0' argument.
+    //   If you get a warning converting a float to ImGuiSliderFlags, read https://github.com/ocornut/imgui/issues/3361
+    IMGUI_API bool          SliderFloat(const char* label, float* v, float v_min, float v_max, const char* format = "%.3f", ImGuiSliderFlags flags = 0);     // adjust format to decorate the value with a prefix or a suffix for in-slider labels or unit display.
+    IMGUI_API bool          SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderFloat4(const char* label, float v[4], float v_min, float v_max, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderAngle(const char* label, float* v_rad, float v_degrees_min = -360.0f, float v_degrees_max = +360.0f, const char* format = "%.0f deg", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderInt(const char* label, int* v, int v_min, int v_max, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderInt2(const char* label, int v[2], int v_min, int v_max, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderInt3(const char* label, int v[3], int v_min, int v_max, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderInt4(const char* label, int v[4], int v_min, int v_max, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format = NULL, ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          SliderScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, const void* p_min, const void* p_max, const char* format = NULL, ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          VSliderFloat(const char* label, const ImVec2& size, float* v, float v_min, float v_max, const char* format = "%.3f", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* format = "%d", ImGuiSliderFlags flags = 0);
+    IMGUI_API bool          VSliderScalar(const char* label, const ImVec2& size, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format = NULL, ImGuiSliderFlags flags = 0);
+
+    // Widgets: Input with Keyboard
+    // - If you want to use InputText() with std::string or any custom dynamic string type, see misc/cpp/imgui_stdlib.h and comments in imgui_demo.cpp.
+    // - Most of the ImGuiInputTextFlags flags are only useful for InputText() and not for InputFloatX, InputIntX, InputDouble etc.
+    IMGUI_API bool          InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
+    IMGUI_API bool          InputTextMultiline(const char* label, char* buf, size_t buf_size, const ImVec2& size = ImVec2(0, 0), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
+    IMGUI_API bool          InputTextWithHint(const char* label, const char* hint, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
+    IMGUI_API bool          InputFloat(const char* label, float* v, float step = 0.0f, float step_fast = 0.0f, const char* format = "%.3f", ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputFloat2(const char* label, float v[2], const char* format = "%.3f", ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputFloat3(const char* label, float v[3], const char* format = "%.3f", ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputFloat4(const char* label, float v[4], const char* format = "%.3f", ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputInt(const char* label, int* v, int step = 1, int step_fast = 100, ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputInt2(const char* label, int v[2], ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputInt3(const char* label, int v[3], ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputInt4(const char* label, int v[4], ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputDouble(const char* label, double* v, double step = 0.0, double step_fast = 0.0, const char* format = "%.6f", ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_step = NULL, const void* p_step_fast = NULL, const char* format = NULL, ImGuiInputTextFlags flags = 0);
+    IMGUI_API bool          InputScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, const void* p_step = NULL, const void* p_step_fast = NULL, const char* format = NULL, ImGuiInputTextFlags flags = 0);
+
+    // Widgets: Color Editor/Picker (tip: the ColorEdit* functions have a little color square that can be left-clicked to open a picker, and right-clicked to open an option menu.)
+    // - Note that in C++ a 'float v[X]' function argument is the _same_ as 'float* v', the array syntax is just a way to document the number of elements that are expected to be accessible.
+    // - You can pass the address of a first float element out of a contiguous structure, e.g. &myvector.x
+    IMGUI_API bool          ColorEdit3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
+    IMGUI_API bool          ColorEdit4(const char* label, float col[4], ImGuiColorEditFlags flags = 0);
+    IMGUI_API bool          ColorPicker3(const char* label, float col[3], ImGuiColorEditFlags flags = 0);
+    IMGUI_API bool          ColorPicker4(const char* label, float col[4], ImGuiColorEditFlags flags = 0, const float* ref_col = NULL);
+    IMGUI_API bool          ColorButton(const char* desc_id, const ImVec4& col, ImGuiColorEditFlags flags = 0, ImVec2 size = ImVec2(0, 0)); // display a color square/button, hover for details, return true when pressed.
+    IMGUI_API void          SetColorEditOptions(ImGuiColorEditFlags flags);                     // initialize current options (generally on application startup) if you want to select a default format, picker type, etc. User will be able to change many settings, unless you pass the _NoOptions flag to your calls.
+
+    // Widgets: Trees
+    // - TreeNode functions return true when the node is open, in which case you need to also call TreePop() when you are finished displaying the tree node contents.
+    IMGUI_API bool          TreeNode(const char* label);
+    IMGUI_API bool          TreeNode(const char* str_id, const char* fmt, ...) IM_FMTARGS(2);   // helper variation to easily decorelate the id from the displayed string. Read the FAQ about why and how to use ID. to align arbitrary text at the same level as a TreeNode() you can use Bullet().
+    IMGUI_API bool          TreeNode(const void* ptr_id, const char* fmt, ...) IM_FMTARGS(2);   // "
+    IMGUI_API bool          TreeNodeV(const char* str_id, const char* fmt, va_list args) IM_FMTLIST(2);
+    IMGUI_API bool          TreeNodeV(const void* ptr_id, const char* fmt, va_list args) IM_FMTLIST(2);
+    IMGUI_API bool          TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags = 0);
+    IMGUI_API bool          TreeNodeEx(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_FMTARGS(3);
+    IMGUI_API bool          TreeNodeEx(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, ...) IM_FMTARGS(3);
+    IMGUI_API bool          TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args) IM_FMTLIST(3);
+    IMGUI_API bool          TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args) IM_FMTLIST(3);
+    IMGUI_API void          TreePush(const char* str_id);                                       // ~ Indent()+PushId(). Already called by TreeNode() when returning true, but you can call TreePush/TreePop yourself if desired.
+    IMGUI_API void          TreePush(const void* ptr_id = NULL);                                // "
+    IMGUI_API void          TreePop();                                                          // ~ Unindent()+PopId()
+    IMGUI_API float         GetTreeNodeToLabelSpacing();                                        // horizontal distance preceding label when using TreeNode*() or Bullet() == (g.FontSize + style.FramePadding.x*2) for a regular unframed TreeNode
+    IMGUI_API bool          CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags = 0);  // if returning 'true' the header is open. doesn't indent nor push on ID stack. user doesn't have to call TreePop().
+    IMGUI_API bool          CollapsingHeader(const char* label, bool* p_visible, ImGuiTreeNodeFlags flags = 0); // when 'p_visible != NULL': if '*p_visible==true' display an additional small close button on upper right of the header which will set the bool to false when clicked, if '*p_visible==false' don't display the header.
+    IMGUI_API void          SetNextItemOpen(bool is_open, ImGuiCond cond = 0);                  // set next TreeNode/CollapsingHeader open state.
+
+    // Widgets: Selectables
+    // - A selectable highlights when hovered, and can display another color when selected.
+    // - Neighbors selectable extend their highlight bounds in order to leave no gap between them. This is so a series of selected Selectable appear contiguous.
+    IMGUI_API bool          Selectable(const char* label, bool selected = false, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0, 0)); // "bool selected" carry the selection state (read-only). Selectable() is clicked is returns true so you can modify your selection state. size.x==0.0: use remaining width, size.x>0.0: specify width. size.y==0.0: use label height, size.y>0.0: specify height
+    IMGUI_API bool          Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags = 0, const ImVec2& size = ImVec2(0, 0));      // "bool* p_selected" point to the selection state (read-write), as a convenient helper.
+
+    // Widgets: List Boxes
+    // - This is essentially a thin wrapper to using BeginChild/EndChild with some stylistic changes.
+    // - The BeginListBox()/EndListBox() api allows you to manage your contents and selection state however you want it, by creating e.g. Selectable() or any items.
+    // - The simplified/old ListBox() api are helpers over BeginListBox()/EndListBox() which are kept available for convenience purpose. This is analoguous to how Combos are created.
+    // - Choose frame width:   size.x > 0.0f: custom  /  size.x < 0.0f or -FLT_MIN: right-align   /  size.x = 0.0f (default): use current ItemWidth
+    // - Choose frame height:  size.y > 0.0f: custom  /  size.y < 0.0f or -FLT_MIN: bottom-align  /  size.y = 0.0f (default): arbitrary default height which can fit ~7 items
+    IMGUI_API bool          BeginListBox(const char* label, const ImVec2& size = ImVec2(0, 0)); // open a framed scrolling region
+    IMGUI_API void          EndListBox();                                                       // only call EndListBox() if BeginListBox() returned true!
+    IMGUI_API bool          ListBox(const char* label, int* current_item, const char* const items[], int items_count, int height_in_items = -1);
+    IMGUI_API bool          ListBox(const char* label, int* current_item, bool (*items_getter)(void* data, int idx, const char** out_text), void* data, int items_count, int height_in_items = -1);
+
+    // Widgets: Data Plotting
+    // - Consider using ImPlot (https://github.com/epezent/implot) which is much better!
+    IMGUI_API void          PlotLines(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float));
+    IMGUI_API void          PlotLines(const char* label, float(*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0));
+    IMGUI_API void          PlotHistogram(const char* label, const float* values, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0), int stride = sizeof(float));
+    IMGUI_API void          PlotHistogram(const char* label, float(*values_getter)(void* data, int idx), void* data, int values_count, int values_offset = 0, const char* overlay_text = NULL, float scale_min = FLT_MAX, float scale_max = FLT_MAX, ImVec2 graph_size = ImVec2(0, 0));
+
+    // Widgets: Value() Helpers.
+    // - Those are merely shortcut to calling Text() with a format string. Output single value in "name: value" format (tip: freely declare more in your code to handle your types. you can add functions to the ImGui namespace)
+    IMGUI_API void          Value(const char* prefix, bool b);
+    IMGUI_API void          Value(const char* prefix, int v);
+    IMGUI_API void          Value(const char* prefix, unsigned int v);
+    IMGUI_API void          Value(const char* prefix, float v, const char* float_format = NULL);
+
+    // Widgets: Menus
+    // - Use BeginMenuBar() on a window ImGuiWindowFlags_MenuBar to append to its menu bar.
+    // - Use BeginMainMenuBar() to create a menu bar at the top of the screen and append to it.
+    // - Use BeginMenu() to create a menu. You can call BeginMenu() multiple time with the same identifier to append more items to it.
+    // - Not that MenuItem() keyboardshortcuts are displayed as a convenience but _not processed_ by Dear ImGui at the moment.
+    IMGUI_API bool          BeginMenuBar();                                                     // append to menu-bar of current window (requires ImGuiWindowFlags_MenuBar flag set on parent window).
+    IMGUI_API void          EndMenuBar();                                                       // only call EndMenuBar() if BeginMenuBar() returns true!
+    IMGUI_API bool          BeginMainMenuBar();                                                 // create and append to a full screen menu-bar.
+    IMGUI_API void          EndMainMenuBar();                                                   // only call EndMainMenuBar() if BeginMainMenuBar() returns true!
+    IMGUI_API bool          BeginMenu(const char* label, bool enabled = true);                  // create a sub-menu entry. only call EndMenu() if this returns true!
+    IMGUI_API void          EndMenu();                                                          // only call EndMenu() if BeginMenu() returns true!
+    IMGUI_API bool          MenuItem(const char* label, const char* shortcut = NULL, bool selected = false, bool enabled = true);  // return true when activated.
+    IMGUI_API bool          MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled = true);              // return true when activated + toggle (*p_selected) if p_selected != NULL
+
+    // Tooltips
+    // - Tooltip are windows following the mouse. They do not take focus away.
+    IMGUI_API void          BeginTooltip();                                                     // begin/append a tooltip window. to create full-featured tooltip (with any kind of items).
+    IMGUI_API void          EndTooltip();
+    IMGUI_API void          SetTooltip(const char* fmt, ...) IM_FMTARGS(1);                     // set a text-only tooltip, typically use with ImGui::IsItemHovered(). override any previous call to SetTooltip().
+    IMGUI_API void          SetTooltipV(const char* fmt, va_list args) IM_FMTLIST(1);
+
+    // Popups, Modals
+    //  - They block normal mouse hovering detection (and therefore most mouse interactions) behind them.
+    //  - If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.
+    //  - Their visibility state (~bool) is held internally instead of being held by the programmer as we are used to with regular Begin*() calls.
+    //  - The 3 properties above are related: we need to retain popup visibility state in the library because popups may be closed as any time.
+    //  - You can bypass the hovering restriction by using ImGuiHoveredFlags_AllowWhenBlockedByPopup when calling IsItemHovered() or IsWindowHovered().
+    //  - IMPORTANT: Popup identifiers are relative to the current ID stack, so OpenPopup and BeginPopup generally needs to be at the same level of the stack.
+    //    This is sometimes leading to confusing mistakes. May rework this in the future.
+
+    // Popups: begin/end functions
+    //  - BeginPopup(): query popup state, if open start appending into the window. Call EndPopup() afterwards. ImGuiWindowFlags are forwarded to the window.
+    //  - BeginPopupModal(): block every interactions behind the window, cannot be closed by user, add a dimming background, has a title bar.
+    IMGUI_API bool          BeginPopup(const char* str_id, ImGuiWindowFlags flags = 0);                         // return true if the popup is open, and you can start outputting to it.
+    IMGUI_API bool          BeginPopupModal(const char* name, bool* p_open = NULL, ImGuiWindowFlags flags = 0); // return true if the modal is open, and you can start outputting to it.
+    IMGUI_API void          EndPopup();                                                                         // only call EndPopup() if BeginPopupXXX() returns true!
+
+    // Popups: open/close functions
+    //  - OpenPopup(): set popup state to open. ImGuiPopupFlags are available for opening options.
+    //  - If not modal: they can be closed by clicking anywhere outside them, or by pressing ESCAPE.
+    //  - CloseCurrentPopup(): use inside the BeginPopup()/EndPopup() scope to close manually.
+    //  - CloseCurrentPopup() is called by default by Selectable()/MenuItem() when activated (FIXME: need some options).
+    //  - Use ImGuiPopupFlags_NoOpenOverExistingPopup to avoid opening a popup if there's already one at the same level. This is equivalent to e.g. testing for !IsAnyPopupOpen() prior to OpenPopup().
+    //  - Use IsWindowAppearing() after BeginPopup() to tell if a window just opened.
+    IMGUI_API void          OpenPopup(const char* str_id, ImGuiPopupFlags popup_flags = 0);                     // call to mark popup as open (don't call every frame!).
+    IMGUI_API void          OpenPopup(ImGuiID id, ImGuiPopupFlags popup_flags = 0);                             // id overload to facilitate calling from nested stacks
+    IMGUI_API void          OpenPopupOnItemClick(const char* str_id = NULL, ImGuiPopupFlags popup_flags = 1);   // helper to open popup when clicked on last item. Default to ImGuiPopupFlags_MouseButtonRight == 1. (note: actually triggers on the mouse _released_ event to be consistent with popup behaviors)
+    IMGUI_API void          CloseCurrentPopup();                                                                // manually close the popup we have begin-ed into.
+
+    // Popups: open+begin combined functions helpers
+    //  - Helpers to do OpenPopup+BeginPopup where the Open action is triggered by e.g. hovering an item and right-clicking.
+    //  - They are convenient to easily create context menus, hence the name.
+    //  - IMPORTANT: Notice that BeginPopupContextXXX takes ImGuiPopupFlags just like OpenPopup() and unlike BeginPopup(). For full consistency, we may add ImGuiWindowFlags to the BeginPopupContextXXX functions in the future.
+    //  - IMPORTANT: we exceptionally default their flags to 1 (== ImGuiPopupFlags_MouseButtonRight) for backward compatibility with older API taking 'int mouse_button = 1' parameter, so if you add other flags remember to re-add the ImGuiPopupFlags_MouseButtonRight.
+    IMGUI_API bool          BeginPopupContextItem(const char* str_id = NULL, ImGuiPopupFlags popup_flags = 1);  // open+begin popup when clicked on last item. Use str_id==NULL to associate the popup to previous item. If you want to use that on a non-interactive item such as Text() you need to pass in an explicit ID here. read comments in .cpp!
+    IMGUI_API bool          BeginPopupContextWindow(const char* str_id = NULL, ImGuiPopupFlags popup_flags = 1);// open+begin popup when clicked on current window.
+    IMGUI_API bool          BeginPopupContextVoid(const char* str_id = NULL, ImGuiPopupFlags popup_flags = 1);  // open+begin popup when clicked in void (where there are no windows).
+
+    // Popups: query functions
+    //  - IsPopupOpen(): return true if the popup is open at the current BeginPopup() level of the popup stack.
+    //  - IsPopupOpen() with ImGuiPopupFlags_AnyPopupId: return true if any popup is open at the current BeginPopup() level of the popup stack.
+    //  - IsPopupOpen() with ImGuiPopupFlags_AnyPopupId + ImGuiPopupFlags_AnyPopupLevel: return true if any popup is open.
+    IMGUI_API bool          IsPopupOpen(const char* str_id, ImGuiPopupFlags flags = 0);                         // return true if the popup is open.
+
+    // Tables
+    // [BETA API] API may evolve slightly! If you use this, please update to the next version when it comes out!
+    // - Full-featured replacement for old Columns API.
+    // - See Demo->Tables for demo code.
+    // - See top of imgui_tables.cpp for general commentary.
+    // - See ImGuiTableFlags_ and ImGuiTableColumnFlags_ enums for a description of available flags.
+    // The typical call flow is:
+    // - 1. Call BeginTable().
+    // - 2. Optionally call TableSetupColumn() to submit column name/flags/defaults.
+    // - 3. Optionally call TableSetupScrollFreeze() to request scroll freezing of columns/rows.
+    // - 4. Optionally call TableHeadersRow() to submit a header row. Names are pulled from TableSetupColumn() data.
+    // - 5. Populate contents:
+    //    - In most situations you can use TableNextRow() + TableSetColumnIndex(N) to start appending into a column.
+    //    - If you are using tables as a sort of grid, where every columns is holding the same type of contents,
+    //      you may prefer using TableNextColumn() instead of TableNextRow() + TableSetColumnIndex().
+    //      TableNextColumn() will automatically wrap-around into the next row if needed.
+    //    - IMPORTANT: Comparatively to the old Columns() API, we need to call TableNextColumn() for the first column!
+    //    - Summary of possible call flow:
+    //        --------------------------------------------------------------------------------------------------------
+    //        TableNextRow() -> TableSetColumnIndex(0) -> Text("Hello 0") -> TableSetColumnIndex(1) -> Text("Hello 1")  // OK
+    //        TableNextRow() -> TableNextColumn()      -> Text("Hello 0") -> TableNextColumn()      -> Text("Hello 1")  // OK
+    //                          TableNextColumn()      -> Text("Hello 0") -> TableNextColumn()      -> Text("Hello 1")  // OK: TableNextColumn() automatically gets to next row!
+    //        TableNextRow()                           -> Text("Hello 0")                                               // Not OK! Missing TableSetColumnIndex() or TableNextColumn()! Text will not appear!
+    //        --------------------------------------------------------------------------------------------------------
+    // - 5. Call EndTable()
+    IMGUI_API bool          BeginTable(const char* str_id, int column, ImGuiTableFlags flags = 0, const ImVec2& outer_size = ImVec2(0.0f, 0.0f), float inner_width = 0.0f);
+    IMGUI_API void          EndTable();                                 // only call EndTable() if BeginTable() returns true!
+    IMGUI_API void          TableNextRow(ImGuiTableRowFlags row_flags = 0, float min_row_height = 0.0f); // append into the first cell of a new row.
+    IMGUI_API bool          TableNextColumn();                          // append into the next column (or first column of next row if currently in last column). Return true when column is visible.
+    IMGUI_API bool          TableSetColumnIndex(int column_n);          // append into the specified column. Return true when column is visible.
+
+    // Tables: Headers & Columns declaration
+    // - Use TableSetupColumn() to specify label, resizing policy, default width/weight, id, various other flags etc.
+    // - Use TableHeadersRow() to create a header row and automatically submit a TableHeader() for each column.
+    //   Headers are required to perform: reordering, sorting, and opening the context menu.
+    //   The context menu can also be made available in columns body using ImGuiTableFlags_ContextMenuInBody.
+    // - You may manually submit headers using TableNextRow() + TableHeader() calls, but this is only useful in
+    //   some advanced use cases (e.g. adding custom widgets in header row).
+    // - Use TableSetupScrollFreeze() to lock columns/rows so they stay visible when scrolled.
+    IMGUI_API void          TableSetupColumn(const char* label, ImGuiTableColumnFlags flags = 0, float init_width_or_weight = 0.0f, ImGuiID user_id = 0);
+    IMGUI_API void          TableSetupScrollFreeze(int cols, int rows); // lock columns/rows so they stay visible when scrolled.
+    IMGUI_API void          TableHeadersRow();                          // submit all headers cells based on data provided to TableSetupColumn() + submit context menu
+    IMGUI_API void          TableHeader(const char* label);             // submit one header cell manually (rarely used)
+
+    // Tables: Sorting
+    // - Call TableGetSortSpecs() to retrieve latest sort specs for the table. NULL when not sorting.
+    // - When 'SpecsDirty == true' you should sort your data. It will be true when sorting specs have changed
+    //   since last call, or the first time. Make sure to set 'SpecsDirty = false' after sorting, else you may
+    //   wastefully sort your data every frame!
+    // - Lifetime: don't hold on this pointer over multiple frames or past any subsequent call to BeginTable().
+    IMGUI_API ImGuiTableSortSpecs*  TableGetSortSpecs();                        // get latest sort specs for the table (NULL if not sorting).
+
+    // Tables: Miscellaneous functions
+    // - Functions args 'int column_n' treat the default value of -1 as the same as passing the current column index.
+    IMGUI_API int                   TableGetColumnCount();                      // return number of columns (value passed to BeginTable)
+    IMGUI_API int                   TableGetColumnIndex();                      // return current column index.
+    IMGUI_API int                   TableGetRowIndex();                         // return current row index.
+    IMGUI_API const char*           TableGetColumnName(int column_n = -1);      // return "" if column didn't have a name declared by TableSetupColumn(). Pass -1 to use current column.
+    IMGUI_API ImGuiTableColumnFlags TableGetColumnFlags(int column_n = -1);     // return column flags so you can query their Enabled/Visible/Sorted/Hovered status flags. Pass -1 to use current column.
+    IMGUI_API void                  TableSetColumnEnabled(int column_n, bool v);// change user accessible enabled/disabled state of a column. Set to false to hide the column. User can use the context menu to change this themselves (right-click in headers, or right-click in columns body with ImGuiTableFlags_ContextMenuInBody)
+    IMGUI_API void                  TableSetBgColor(ImGuiTableBgTarget target, ImU32 color, int column_n = -1);  // change the color of a cell, row, or column. See ImGuiTableBgTarget_ flags for details.
+
+    // Legacy Columns API (prefer using Tables!)
+    // - You can also use SameLine(pos_x) to mimic simplified columns.
+    IMGUI_API void          Columns(int count = 1, const char* id = NULL, bool border = true);
+    IMGUI_API void          NextColumn();                                                       // next column, defaults to current row or next row if the current row is finished
+    IMGUI_API int           GetColumnIndex();                                                   // get current column index
+    IMGUI_API float         GetColumnWidth(int column_index = -1);                              // get column width (in pixels). pass -1 to use current column
+    IMGUI_API void          SetColumnWidth(int column_index, float width);                      // set column width (in pixels). pass -1 to use current column
+    IMGUI_API float         GetColumnOffset(int column_index = -1);                             // get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetColumnsCount() inclusive. column 0 is typically 0.0f
+    IMGUI_API void          SetColumnOffset(int column_index, float offset_x);                  // set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column
+    IMGUI_API int           GetColumnsCount();
+
+    // Tab Bars, Tabs
+    IMGUI_API bool          BeginTabBar(const char* str_id, ImGuiTabBarFlags flags = 0);        // create and append into a TabBar
+    IMGUI_API void          EndTabBar();                                                        // only call EndTabBar() if BeginTabBar() returns true!
+    IMGUI_API bool          BeginTabItem(const char* label, bool* p_open = NULL, ImGuiTabItemFlags flags = 0); // create a Tab. Returns true if the Tab is selected.
+    IMGUI_API void          EndTabItem();                                                       // only call EndTabItem() if BeginTabItem() returns true!
+    IMGUI_API bool          TabItemButton(const char* label, ImGuiTabItemFlags flags = 0);      // create a Tab behaving like a button. return true when clicked. cannot be selected in the tab bar.
+    IMGUI_API void          SetTabItemClosed(const char* tab_or_docked_window_label);           // notify TabBar or Docking system of a closed tab/window ahead (useful to reduce visual flicker on reorderable tab bars). For tab-bar: call after BeginTabBar() and before Tab submissions. Otherwise call with a window name.
+
+    // Logging/Capture
+    // - All text output from the interface can be captured into tty/file/clipboard. By default, tree nodes are automatically opened during logging.
+    IMGUI_API void          LogToTTY(int auto_open_depth = -1);                                 // start logging to tty (stdout)
+    IMGUI_API void          LogToFile(int auto_open_depth = -1, const char* filename = NULL);   // start logging to file
+    IMGUI_API void          LogToClipboard(int auto_open_depth = -1);                           // start logging to OS clipboard
+    IMGUI_API void          LogFinish();                                                        // stop logging (close file, etc.)
+    IMGUI_API void          LogButtons();                                                       // helper to display buttons for logging to tty/file/clipboard
+    IMGUI_API void          LogText(const char* fmt, ...) IM_FMTARGS(1);                        // pass text data straight to log (without being displayed)
+    IMGUI_API void          LogTextV(const char* fmt, va_list args) IM_FMTLIST(1);
+
+    // Drag and Drop
+    // - On source items, call BeginDragDropSource(), if it returns true also call SetDragDropPayload() + EndDragDropSource().
+    // - On target candidates, call BeginDragDropTarget(), if it returns true also call AcceptDragDropPayload() + EndDragDropTarget().
+    // - If you stop calling BeginDragDropSource() the payload is preserved however it won't have a preview tooltip (we currently display a fallback "..." tooltip, see #1725)
+    // - An item can be both drag source and drop target.
+    IMGUI_API bool          BeginDragDropSource(ImGuiDragDropFlags flags = 0);                                      // call after submitting an item which may be dragged. when this return true, you can call SetDragDropPayload() + EndDragDropSource()
+    IMGUI_API bool          SetDragDropPayload(const char* type, const void* data, size_t sz, ImGuiCond cond = 0);  // type is a user defined string of maximum 32 characters. Strings starting with '_' are reserved for dear imgui internal types. Data is copied and held by imgui.
+    IMGUI_API void          EndDragDropSource();                                                                    // only call EndDragDropSource() if BeginDragDropSource() returns true!
+    IMGUI_API bool                  BeginDragDropTarget();                                                          // call after submitting an item that may receive a payload. If this returns true, you can call AcceptDragDropPayload() + EndDragDropTarget()
+    IMGUI_API const ImGuiPayload*   AcceptDragDropPayload(const char* type, ImGuiDragDropFlags flags = 0);          // accept contents of a given type. If ImGuiDragDropFlags_AcceptBeforeDelivery is set you can peek into the payload before the mouse button is released.
+    IMGUI_API void                  EndDragDropTarget();                                                            // only call EndDragDropTarget() if BeginDragDropTarget() returns true!
+    IMGUI_API const ImGuiPayload*   GetDragDropPayload();                                                           // peek directly into the current payload from anywhere. may return NULL. use ImGuiPayload::IsDataType() to test for the payload type.
+
+    // Disabling [BETA API]
+    // - Disable all user interactions and dim items visuals (applying style.DisabledAlpha over current colors)
+    // - Those can be nested but it cannot be used to enable an already disabled section (a single BeginDisabled(true) in the stack is enough to keep everything disabled)
+    // - BeginDisabled(false) essentially does nothing useful but is provided to facilitate use of boolean expressions. If you can avoid calling BeginDisabled(False)/EndDisabled() best to avoid it.
+    IMGUI_API void          BeginDisabled(bool disabled = true);
+    IMGUI_API void          EndDisabled();
+
+    // Clipping
+    // - Mouse hovering is affected by ImGui::PushClipRect() calls, unlike direct calls to ImDrawList::PushClipRect() which are render only.
+    IMGUI_API void          PushClipRect(const ImVec2& clip_rect_min, const ImVec2& clip_rect_max, bool intersect_with_current_clip_rect);
+    IMGUI_API void          PopClipRect();
+
+    // Focus, Activation
+    // - Prefer using "SetItemDefaultFocus()" over "if (IsWindowAppearing()) SetScrollHereY()" when applicable to signify "this is the default item"
+    IMGUI_API void          SetItemDefaultFocus();                                              // make last item the default focused item of a window.
+    IMGUI_API void          SetKeyboardFocusHere(int offset = 0);                               // focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget. Use -1 to access previous widget.
+
+    // Item/Widgets Utilities and Query Functions
+    // - Most of the functions are referring to the previous Item that has been submitted.
+    // - See Demo Window under "Widgets->Querying Status" for an interactive visualization of most of those functions.
+    IMGUI_API bool          IsItemHovered(ImGuiHoveredFlags flags = 0);                         // is the last item hovered? (and usable, aka not blocked by a popup, etc.). See ImGuiHoveredFlags for more options.
+    IMGUI_API bool          IsItemActive();                                                     // is the last item active? (e.g. button being held, text field being edited. This will continuously return true while holding mouse button on an item. Items that don't interact will always return false)
+    IMGUI_API bool          IsItemFocused();                                                    // is the last item focused for keyboard/gamepad navigation?
+    IMGUI_API bool          IsItemClicked(ImGuiMouseButton mouse_button = 0);                   // is the last item hovered and mouse clicked on? (**)  == IsMouseClicked(mouse_button) && IsItemHovered()Important. (**) this it NOT equivalent to the behavior of e.g. Button(). Read comments in function definition.
+    IMGUI_API bool          IsItemVisible();                                                    // is the last item visible? (items may be out of sight because of clipping/scrolling)
+    IMGUI_API bool          IsItemEdited();                                                     // did the last item modify its underlying value this frame? or was pressed? This is generally the same as the "bool" return value of many widgets.
+    IMGUI_API bool          IsItemActivated();                                                  // was the last item just made active (item was previously inactive).
+    IMGUI_API bool          IsItemDeactivated();                                                // was the last item just made inactive (item was previously active). Useful for Undo/Redo patterns with widgets that requires continuous editing.
+    IMGUI_API bool          IsItemDeactivatedAfterEdit();                                       // was the last item just made inactive and made a value change when it was active? (e.g. Slider/Drag moved). Useful for Undo/Redo patterns with widgets that requires continuous editing. Note that you may get false positives (some widgets such as Combo()/ListBox()/Selectable() will return true even when clicking an already selected item).
+    IMGUI_API bool          IsItemToggledOpen();                                                // was the last item open state toggled? set by TreeNode().
+    IMGUI_API bool          IsAnyItemHovered();                                                 // is any item hovered?
+    IMGUI_API bool          IsAnyItemActive();                                                  // is any item active?
+    IMGUI_API bool          IsAnyItemFocused();                                                 // is any item focused?
+    IMGUI_API ImVec2        GetItemRectMin();                                                   // get upper-left bounding rectangle of the last item (screen space)
+    IMGUI_API ImVec2        GetItemRectMax();                                                   // get lower-right bounding rectangle of the last item (screen space)
+    IMGUI_API ImVec2        GetItemRectSize();                                                  // get size of last item
+    IMGUI_API void          SetItemAllowOverlap();                                              // allow last item to be overlapped by a subsequent item. sometimes useful with invisible buttons, selectables, etc. to catch unused area.
+
+    // Viewports
+    // - Currently represents the Platform Window created by the application which is hosting our Dear ImGui windows.
+    // - In 'docking' branch with multi-viewport enabled, we extend this concept to have multiple active viewports.
+    // - In the future we will extend this concept further to also represent Platform Monitor and support a "no main platform window" operation mode.
+    IMGUI_API ImGuiViewport* GetMainViewport();                                                 // return primary/default viewport. This can never be NULL.
+
+    // Miscellaneous Utilities
+    IMGUI_API bool          IsRectVisible(const ImVec2& size);                                  // test if rectangle (of given size, starting from cursor position) is visible / not clipped.
+    IMGUI_API bool          IsRectVisible(const ImVec2& rect_min, const ImVec2& rect_max);      // test if rectangle (in screen space) is visible / not clipped. to perform coarse clipping on user's side.
+    IMGUI_API double        GetTime();                                                          // get global imgui time. incremented by io.DeltaTime every frame.
+    IMGUI_API int           GetFrameCount();                                                    // get global imgui frame count. incremented by 1 every frame.
+    IMGUI_API ImDrawList*   GetBackgroundDrawList();                                            // this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
+    IMGUI_API ImDrawList*   GetForegroundDrawList();                                            // this draw list will be the last rendered one. Useful to quickly draw shapes/text over dear imgui contents.
+    IMGUI_API ImDrawListSharedData* GetDrawListSharedData();                                    // you may use this when creating your own ImDrawList instances.
+    IMGUI_API const char*   GetStyleColorName(ImGuiCol idx);                                    // get a string corresponding to the enum value (for display, saving, etc.).
+    IMGUI_API void          SetStateStorage(ImGuiStorage* storage);                             // replace current window storage with our own (if you want to manipulate it yourself, typically clear subsection of it)
+    IMGUI_API ImGuiStorage* GetStateStorage();
+    IMGUI_API void          CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end);    // calculate coarse clipping for large list of evenly sized items. Prefer using the ImGuiListClipper higher-level helper if you can.
+    IMGUI_API bool          BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags flags = 0); // helper to create a child window / scrolling region that looks like a normal widget frame
+    IMGUI_API void          EndChildFrame();                                                    // always call EndChildFrame() regardless of BeginChildFrame() return values (which indicates a collapsed/clipped window)
+
+    // Text Utilities
+    IMGUI_API ImVec2        CalcTextSize(const char* text, const char* text_end = NULL, bool hide_text_after_double_hash = false, float wrap_width = -1.0f);
+
+    // Color Utilities
+    IMGUI_API ImVec4        ColorConvertU32ToFloat4(ImU32 in);
+    IMGUI_API ImU32         ColorConvertFloat4ToU32(const ImVec4& in);
+    IMGUI_API void          ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v);
+    IMGUI_API void          ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b);
+
+    // Inputs Utilities: Keyboard
+    // - For 'int user_key_index' you can use your own indices/enums according to how your backend/engine stored them in io.KeysDown[].
+    // - We don't know the meaning of those value. You can use GetKeyIndex() to map a ImGuiKey_ value into the user index.
+    IMGUI_API int           GetKeyIndex(ImGuiKey imgui_key);                                    // map ImGuiKey_* values into user's key index. == io.KeyMap[key]
+    IMGUI_API bool          IsKeyDown(int user_key_index);                                      // is key being held. == io.KeysDown[user_key_index].
+    IMGUI_API bool          IsKeyPressed(int user_key_index, bool repeat = true);               // was key pressed (went from !Down to Down)? if repeat=true, uses io.KeyRepeatDelay / KeyRepeatRate
+    IMGUI_API bool          IsKeyReleased(int user_key_index);                                  // was key released (went from Down to !Down)?
+    IMGUI_API int           GetKeyPressedAmount(int key_index, float repeat_delay, float rate); // uses provided repeat rate/delay. return a count, most often 0 or 1 but might be >1 if RepeatRate is small enough that DeltaTime > RepeatRate
+    IMGUI_API void          CaptureKeyboardFromApp(bool want_capture_keyboard_value = true);    // attention: misleading name! manually override io.WantCaptureKeyboard flag next frame (said flag is entirely left for your application to handle). e.g. force capture keyboard when your widget is being hovered. This is equivalent to setting "io.WantCaptureKeyboard = want_capture_keyboard_value"; after the next NewFrame() call.
+
+    // Inputs Utilities: Mouse
+    // - To refer to a mouse button, you may use named enums in your code e.g. ImGuiMouseButton_Left, ImGuiMouseButton_Right.
+    // - You can also use regular integer: it is forever guaranteed that 0=Left, 1=Right, 2=Middle.
+    // - Dragging operations are only reported after mouse has moved a certain distance away from the initial clicking position (see 'lock_threshold' and 'io.MouseDraggingThreshold')
+    IMGUI_API bool          IsMouseDown(ImGuiMouseButton button);                               // is mouse button held?
+    IMGUI_API bool          IsMouseClicked(ImGuiMouseButton button, bool repeat = false);       // did mouse button clicked? (went from !Down to Down)
+    IMGUI_API bool          IsMouseReleased(ImGuiMouseButton button);                           // did mouse button released? (went from Down to !Down)
+    IMGUI_API bool          IsMouseDoubleClicked(ImGuiMouseButton button);                      // did mouse button double-clicked? (note that a double-click will also report IsMouseClicked() == true)
+    IMGUI_API bool          IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip = true);// is mouse hovering given bounding rect (in screen space). clipped by current clipping settings, but disregarding of other consideration of focus/window ordering/popup-block.
+    IMGUI_API bool          IsMousePosValid(const ImVec2* mouse_pos = NULL);                    // by convention we use (-FLT_MAX,-FLT_MAX) to denote that there is no mouse available
+    IMGUI_API bool          IsAnyMouseDown();                                                   // is any mouse button held?
+    IMGUI_API ImVec2        GetMousePos();                                                      // shortcut to ImGui::GetIO().MousePos provided by user, to be consistent with other calls
+    IMGUI_API ImVec2        GetMousePosOnOpeningCurrentPopup();                                 // retrieve mouse position at the time of opening popup we have BeginPopup() into (helper to avoid user backing that value themselves)
+    IMGUI_API bool          IsMouseDragging(ImGuiMouseButton button, float lock_threshold = -1.0f);         // is mouse dragging? (if lock_threshold < -1.0f, uses io.MouseDraggingThreshold)
+    IMGUI_API ImVec2        GetMouseDragDelta(ImGuiMouseButton button = 0, float lock_threshold = -1.0f);   // return the delta from the initial clicking position while the mouse button is pressed or was just released. This is locked and return 0.0f until the mouse moves past a distance threshold at least once (if lock_threshold < -1.0f, uses io.MouseDraggingThreshold)
+    IMGUI_API void          ResetMouseDragDelta(ImGuiMouseButton button = 0);                   //
+    IMGUI_API ImGuiMouseCursor GetMouseCursor();                                                // get desired cursor type, reset in ImGui::NewFrame(), this is updated during the frame. valid before Render(). If you use software rendering by setting io.MouseDrawCursor ImGui will render those for you
+    IMGUI_API void          SetMouseCursor(ImGuiMouseCursor cursor_type);                       // set desired cursor type
+    IMGUI_API void          CaptureMouseFromApp(bool want_capture_mouse_value = true);          // attention: misleading name! manually override io.WantCaptureMouse flag next frame (said flag is entirely left for your application to handle). This is equivalent to setting "io.WantCaptureMouse = want_capture_mouse_value;" after the next NewFrame() call.
+
+    // Clipboard Utilities
+    // - Also see the LogToClipboard() function to capture GUI into clipboard, or easily output text data to the clipboard.
+    IMGUI_API const char*   GetClipboardText();
+    IMGUI_API void          SetClipboardText(const char* text);
+
+    // Settings/.Ini Utilities
+    // - The disk functions are automatically called if io.IniFilename != NULL (default is "imgui.ini").
+    // - Set io.IniFilename to NULL to load/save manually. Read io.WantSaveIniSettings description about handling .ini saving manually.
+    // - Important: default value "imgui.ini" is relative to current working dir! Most apps will want to lock this to an absolute path (e.g. same path as executables).
+    IMGUI_API void          LoadIniSettingsFromDisk(const char* ini_filename);                  // call after CreateContext() and before the first call to NewFrame(). NewFrame() automatically calls LoadIniSettingsFromDisk(io.IniFilename).
+    IMGUI_API void          LoadIniSettingsFromMemory(const char* ini_data, size_t ini_size=0); // call after CreateContext() and before the first call to NewFrame() to provide .ini data from your own data source.
+    IMGUI_API void          SaveIniSettingsToDisk(const char* ini_filename);                    // this is automatically called (if io.IniFilename is not empty) a few seconds after any modification that should be reflected in the .ini file (and also by DestroyContext).
+    IMGUI_API const char*   SaveIniSettingsToMemory(size_t* out_ini_size = NULL);               // return a zero-terminated string with the .ini data which you can save by your own mean. call when io.WantSaveIniSettings is set, then save data by your own mean and clear io.WantSaveIniSettings.
+
+    // Debug Utilities
+    // - This is used by the IMGUI_CHECKVERSION() macro.
+    IMGUI_API bool          DebugCheckVersionAndDataLayout(const char* version_str, size_t sz_io, size_t sz_style, size_t sz_vec2, size_t sz_vec4, size_t sz_drawvert, size_t sz_drawidx); // This is called by IMGUI_CHECKVERSION() macro.
+
+    // Memory Allocators
+    // - Those functions are not reliant on the current context.
+    // - DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+    //   for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
+    IMGUI_API void          SetAllocatorFunctions(ImGuiMemAllocFunc alloc_func, ImGuiMemFreeFunc free_func, void* user_data = NULL);
+    IMGUI_API void          GetAllocatorFunctions(ImGuiMemAllocFunc* p_alloc_func, ImGuiMemFreeFunc* p_free_func, void** p_user_data);
+    IMGUI_API void*         MemAlloc(size_t size);
+    IMGUI_API void          MemFree(void* ptr);
+
+} // namespace ImGui
+
+//-----------------------------------------------------------------------------
+// [SECTION] Flags & Enumerations
+//-----------------------------------------------------------------------------
+
+// Flags for ImGui::Begin()
+enum ImGuiWindowFlags_
+{
+    ImGuiWindowFlags_None                   = 0,
+    ImGuiWindowFlags_NoTitleBar             = 1 << 0,   // Disable title-bar
+    ImGuiWindowFlags_NoResize               = 1 << 1,   // Disable user resizing with the lower-right grip
+    ImGuiWindowFlags_NoMove                 = 1 << 2,   // Disable user moving the window
+    ImGuiWindowFlags_NoScrollbar            = 1 << 3,   // Disable scrollbars (window can still scroll with mouse or programmatically)
+    ImGuiWindowFlags_NoScrollWithMouse      = 1 << 4,   // Disable user vertically scrolling with mouse wheel. On child window, mouse wheel will be forwarded to the parent unless NoScrollbar is also set.
+    ImGuiWindowFlags_NoCollapse             = 1 << 5,   // Disable user collapsing window by double-clicking on it
+    ImGuiWindowFlags_AlwaysAutoResize       = 1 << 6,   // Resize every window to its content every frame
+    ImGuiWindowFlags_NoBackground           = 1 << 7,   // Disable drawing background color (WindowBg, etc.) and outside border. Similar as using SetNextWindowBgAlpha(0.0f).
+    ImGuiWindowFlags_NoSavedSettings        = 1 << 8,   // Never load/save settings in .ini file
+    ImGuiWindowFlags_NoMouseInputs          = 1 << 9,   // Disable catching mouse, hovering test with pass through.
+    ImGuiWindowFlags_MenuBar                = 1 << 10,  // Has a menu-bar
+    ImGuiWindowFlags_HorizontalScrollbar    = 1 << 11,  // Allow horizontal scrollbar to appear (off by default). You may use SetNextWindowContentSize(ImVec2(width,0.0f)); prior to calling Begin() to specify width. Read code in imgui_demo in the "Horizontal Scrolling" section.
+    ImGuiWindowFlags_NoFocusOnAppearing     = 1 << 12,  // Disable taking focus when transitioning from hidden to visible state
+    ImGuiWindowFlags_NoBringToFrontOnFocus  = 1 << 13,  // Disable bringing window to front when taking focus (e.g. clicking on it or programmatically giving it focus)
+    ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14,  // Always show vertical scrollbar (even if ContentSize.y < Size.y)
+    ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15,  // Always show horizontal scrollbar (even if ContentSize.x < Size.x)
+    ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16,  // Ensure child windows without border uses style.WindowPadding (ignored by default for non-bordered child windows, because more convenient)
+    ImGuiWindowFlags_NoNavInputs            = 1 << 18,  // No gamepad/keyboard navigation within the window
+    ImGuiWindowFlags_NoNavFocus             = 1 << 19,  // No focusing toward this window with gamepad/keyboard navigation (e.g. skipped by CTRL+TAB)
+    ImGuiWindowFlags_UnsavedDocument        = 1 << 20,  // Display a dot next to the title. When used in a tab/docking context, tab is selected when clicking the X + closure is not assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar.
+    ImGuiWindowFlags_NoNav                  = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
+    ImGuiWindowFlags_NoDecoration           = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse,
+    ImGuiWindowFlags_NoInputs               = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus,
+
+    // [Internal]
+    ImGuiWindowFlags_NavFlattened           = 1 << 23,  // [BETA] Allow gamepad/keyboard navigation to cross over parent border to this child (only use on child that have no scrolling!)
+    ImGuiWindowFlags_ChildWindow            = 1 << 24,  // Don't use! For internal use by BeginChild()
+    ImGuiWindowFlags_Tooltip                = 1 << 25,  // Don't use! For internal use by BeginTooltip()
+    ImGuiWindowFlags_Popup                  = 1 << 26,  // Don't use! For internal use by BeginPopup()
+    ImGuiWindowFlags_Modal                  = 1 << 27,  // Don't use! For internal use by BeginPopupModal()
+    ImGuiWindowFlags_ChildMenu              = 1 << 28   // Don't use! For internal use by BeginMenu()
+
+    // [Obsolete]
+    //ImGuiWindowFlags_ResizeFromAnySide    = 1 << 17,  // --> Set io.ConfigWindowsResizeFromEdges=true and make sure mouse cursors are supported by backend (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors)
+};
+
+// Flags for ImGui::InputText()
+enum ImGuiInputTextFlags_
+{
+    ImGuiInputTextFlags_None                = 0,
+    ImGuiInputTextFlags_CharsDecimal        = 1 << 0,   // Allow 0123456789.+-*/
+    ImGuiInputTextFlags_CharsHexadecimal    = 1 << 1,   // Allow 0123456789ABCDEFabcdef
+    ImGuiInputTextFlags_CharsUppercase      = 1 << 2,   // Turn a..z into A..Z
+    ImGuiInputTextFlags_CharsNoBlank        = 1 << 3,   // Filter out spaces, tabs
+    ImGuiInputTextFlags_AutoSelectAll       = 1 << 4,   // Select entire text when first taking mouse focus
+    ImGuiInputTextFlags_EnterReturnsTrue    = 1 << 5,   // Return 'true' when Enter is pressed (as opposed to every time the value was modified). Consider looking at the IsItemDeactivatedAfterEdit() function.
+    ImGuiInputTextFlags_CallbackCompletion  = 1 << 6,   // Callback on pressing TAB (for completion handling)
+    ImGuiInputTextFlags_CallbackHistory     = 1 << 7,   // Callback on pressing Up/Down arrows (for history handling)
+    ImGuiInputTextFlags_CallbackAlways      = 1 << 8,   // Callback on each iteration. User code may query cursor position, modify text buffer.
+    ImGuiInputTextFlags_CallbackCharFilter  = 1 << 9,   // Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard.
+    ImGuiInputTextFlags_AllowTabInput       = 1 << 10,  // Pressing TAB input a '\t' character into the text field
+    ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11,  // In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter (default is opposite: unfocus with Ctrl+Enter, add line with Enter).
+    ImGuiInputTextFlags_NoHorizontalScroll  = 1 << 12,  // Disable following the cursor horizontally
+    ImGuiInputTextFlags_AlwaysOverwrite     = 1 << 13,  // Overwrite mode
+    ImGuiInputTextFlags_ReadOnly            = 1 << 14,  // Read-only mode
+    ImGuiInputTextFlags_Password            = 1 << 15,  // Password mode, display all characters as '*'
+    ImGuiInputTextFlags_NoUndoRedo          = 1 << 16,  // Disable undo/redo. Note that input text owns the text data while active, if you want to provide your own undo/redo stack you need e.g. to call ClearActiveID().
+    ImGuiInputTextFlags_CharsScientific     = 1 << 17,  // Allow 0123456789.+-*/eE (Scientific notation input)
+    ImGuiInputTextFlags_CallbackResize      = 1 << 18,  // Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow. Notify when the string wants to be resized (for string types which hold a cache of their Size). You will be provided a new BufSize in the callback and NEED to honor it. (see misc/cpp/imgui_stdlib.h for an example of using this)
+    ImGuiInputTextFlags_CallbackEdit        = 1 << 19   // Callback on any edit (note that InputText() already returns true on edit, the callback is useful mainly to manipulate the underlying buffer while focus is active)
+
+    // Obsolete names (will be removed soon)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    , ImGuiInputTextFlags_AlwaysInsertMode    = ImGuiInputTextFlags_AlwaysOverwrite   // [renamed in 1.82] name was not matching behavior
+#endif
+};
+
+// Flags for ImGui::TreeNodeEx(), ImGui::CollapsingHeader*()
+enum ImGuiTreeNodeFlags_
+{
+    ImGuiTreeNodeFlags_None                 = 0,
+    ImGuiTreeNodeFlags_Selected             = 1 << 0,   // Draw as selected
+    ImGuiTreeNodeFlags_Framed               = 1 << 1,   // Draw frame with background (e.g. for CollapsingHeader)
+    ImGuiTreeNodeFlags_AllowItemOverlap     = 1 << 2,   // Hit testing to allow subsequent widgets to overlap this one
+    ImGuiTreeNodeFlags_NoTreePushOnOpen     = 1 << 3,   // Don't do a TreePush() when open (e.g. for CollapsingHeader) = no extra indent nor pushing on ID stack
+    ImGuiTreeNodeFlags_NoAutoOpenOnLog      = 1 << 4,   // Don't automatically and temporarily open node when Logging is active (by default logging will automatically open tree nodes)
+    ImGuiTreeNodeFlags_DefaultOpen          = 1 << 5,   // Default node to be open
+    ImGuiTreeNodeFlags_OpenOnDoubleClick    = 1 << 6,   // Need double-click to open node
+    ImGuiTreeNodeFlags_OpenOnArrow          = 1 << 7,   // Only open when clicking on the arrow part. If ImGuiTreeNodeFlags_OpenOnDoubleClick is also set, single-click arrow or double-click all box to open.
+    ImGuiTreeNodeFlags_Leaf                 = 1 << 8,   // No collapsing, no arrow (use as a convenience for leaf nodes).
+    ImGuiTreeNodeFlags_Bullet               = 1 << 9,   // Display a bullet instead of arrow
+    ImGuiTreeNodeFlags_FramePadding         = 1 << 10,  // Use FramePadding (even for an unframed text node) to vertically align text baseline to regular widget height. Equivalent to calling AlignTextToFramePadding().
+    ImGuiTreeNodeFlags_SpanAvailWidth       = 1 << 11,  // Extend hit box to the right-most edge, even if not framed. This is not the default in order to allow adding other items on the same line. In the future we may refactor the hit system to be front-to-back, allowing natural overlaps and then this can become the default.
+    ImGuiTreeNodeFlags_SpanFullWidth        = 1 << 12,  // Extend hit box to the left-most and right-most edges (bypass the indented area).
+    ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 13,  // (WIP) Nav: left direction may move to this TreeNode() from any of its child (items submitted between TreeNode and TreePop)
+    //ImGuiTreeNodeFlags_NoScrollOnOpen     = 1 << 14,  // FIXME: TODO: Disable automatic scroll on TreePop() if node got just open and contents is not visible
+    ImGuiTreeNodeFlags_CollapsingHeader     = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog
+};
+
+// Flags for OpenPopup*(), BeginPopupContext*(), IsPopupOpen() functions.
+// - To be backward compatible with older API which took an 'int mouse_button = 1' argument, we need to treat
+//   small flags values as a mouse button index, so we encode the mouse button in the first few bits of the flags.
+//   It is therefore guaranteed to be legal to pass a mouse button index in ImGuiPopupFlags.
+// - For the same reason, we exceptionally default the ImGuiPopupFlags argument of BeginPopupContextXXX functions to 1 instead of 0.
+//   IMPORTANT: because the default parameter is 1 (==ImGuiPopupFlags_MouseButtonRight), if you rely on the default parameter
+//   and want to another another flag, you need to pass in the ImGuiPopupFlags_MouseButtonRight flag.
+// - Multiple buttons currently cannot be combined/or-ed in those functions (we could allow it later).
+enum ImGuiPopupFlags_
+{
+    ImGuiPopupFlags_None                    = 0,
+    ImGuiPopupFlags_MouseButtonLeft         = 0,        // For BeginPopupContext*(): open on Left Mouse release. Guaranteed to always be == 0 (same as ImGuiMouseButton_Left)
+    ImGuiPopupFlags_MouseButtonRight        = 1,        // For BeginPopupContext*(): open on Right Mouse release. Guaranteed to always be == 1 (same as ImGuiMouseButton_Right)
+    ImGuiPopupFlags_MouseButtonMiddle       = 2,        // For BeginPopupContext*(): open on Middle Mouse release. Guaranteed to always be == 2 (same as ImGuiMouseButton_Middle)
+    ImGuiPopupFlags_MouseButtonMask_        = 0x1F,
+    ImGuiPopupFlags_MouseButtonDefault_     = 1,
+    ImGuiPopupFlags_NoOpenOverExistingPopup = 1 << 5,   // For OpenPopup*(), BeginPopupContext*(): don't open if there's already a popup at the same level of the popup stack
+    ImGuiPopupFlags_NoOpenOverItems         = 1 << 6,   // For BeginPopupContextWindow(): don't return true when hovering items, only when hovering empty space
+    ImGuiPopupFlags_AnyPopupId              = 1 << 7,   // For IsPopupOpen(): ignore the ImGuiID parameter and test for any popup.
+    ImGuiPopupFlags_AnyPopupLevel           = 1 << 8,   // For IsPopupOpen(): search/test at any level of the popup stack (default test in the current level)
+    ImGuiPopupFlags_AnyPopup                = ImGuiPopupFlags_AnyPopupId | ImGuiPopupFlags_AnyPopupLevel
+};
+
+// Flags for ImGui::Selectable()
+enum ImGuiSelectableFlags_
+{
+    ImGuiSelectableFlags_None               = 0,
+    ImGuiSelectableFlags_DontClosePopups    = 1 << 0,   // Clicking this don't close parent popup window
+    ImGuiSelectableFlags_SpanAllColumns     = 1 << 1,   // Selectable frame can span all columns (text will still fit in current column)
+    ImGuiSelectableFlags_AllowDoubleClick   = 1 << 2,   // Generate press events on double clicks too
+    ImGuiSelectableFlags_Disabled           = 1 << 3,   // Cannot be selected, display grayed out text
+    ImGuiSelectableFlags_AllowItemOverlap   = 1 << 4    // (WIP) Hit testing to allow subsequent widgets to overlap this one
+};
+
+// Flags for ImGui::BeginCombo()
+enum ImGuiComboFlags_
+{
+    ImGuiComboFlags_None                    = 0,
+    ImGuiComboFlags_PopupAlignLeft          = 1 << 0,   // Align the popup toward the left by default
+    ImGuiComboFlags_HeightSmall             = 1 << 1,   // Max ~4 items visible. Tip: If you want your combo popup to be a specific size you can use SetNextWindowSizeConstraints() prior to calling BeginCombo()
+    ImGuiComboFlags_HeightRegular           = 1 << 2,   // Max ~8 items visible (default)
+    ImGuiComboFlags_HeightLarge             = 1 << 3,   // Max ~20 items visible
+    ImGuiComboFlags_HeightLargest           = 1 << 4,   // As many fitting items as possible
+    ImGuiComboFlags_NoArrowButton           = 1 << 5,   // Display on the preview box without the square arrow button
+    ImGuiComboFlags_NoPreview               = 1 << 6,   // Display only a square arrow button
+    ImGuiComboFlags_HeightMask_             = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest
+};
+
+// Flags for ImGui::BeginTabBar()
+enum ImGuiTabBarFlags_
+{
+    ImGuiTabBarFlags_None                           = 0,
+    ImGuiTabBarFlags_Reorderable                    = 1 << 0,   // Allow manually dragging tabs to re-order them + New tabs are appended at the end of list
+    ImGuiTabBarFlags_AutoSelectNewTabs              = 1 << 1,   // Automatically select new tabs when they appear
+    ImGuiTabBarFlags_TabListPopupButton             = 1 << 2,   // Disable buttons to open the tab list popup
+    ImGuiTabBarFlags_NoCloseWithMiddleMouseButton   = 1 << 3,   // Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You can still repro this behavior on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
+    ImGuiTabBarFlags_NoTabListScrollingButtons      = 1 << 4,   // Disable scrolling buttons (apply when fitting policy is ImGuiTabBarFlags_FittingPolicyScroll)
+    ImGuiTabBarFlags_NoTooltip                      = 1 << 5,   // Disable tooltips when hovering a tab
+    ImGuiTabBarFlags_FittingPolicyResizeDown        = 1 << 6,   // Resize tabs when they don't fit
+    ImGuiTabBarFlags_FittingPolicyScroll            = 1 << 7,   // Add scroll buttons when tabs don't fit
+    ImGuiTabBarFlags_FittingPolicyMask_             = ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll,
+    ImGuiTabBarFlags_FittingPolicyDefault_          = ImGuiTabBarFlags_FittingPolicyResizeDown
+};
+
+// Flags for ImGui::BeginTabItem()
+enum ImGuiTabItemFlags_
+{
+    ImGuiTabItemFlags_None                          = 0,
+    ImGuiTabItemFlags_UnsavedDocument               = 1 << 0,   // Display a dot next to the title + tab is selected when clicking the X + closure is not assumed (will wait for user to stop submitting the tab). Otherwise closure is assumed when pressing the X, so if you keep submitting the tab may reappear at end of tab bar.
+    ImGuiTabItemFlags_SetSelected                   = 1 << 1,   // Trigger flag to programmatically make the tab selected when calling BeginTabItem()
+    ImGuiTabItemFlags_NoCloseWithMiddleMouseButton  = 1 << 2,   // Disable behavior of closing tabs (that are submitted with p_open != NULL) with middle mouse button. You can still repro this behavior on user's side with if (IsItemHovered() && IsMouseClicked(2)) *p_open = false.
+    ImGuiTabItemFlags_NoPushId                      = 1 << 3,   // Don't call PushID(tab->ID)/PopID() on BeginTabItem()/EndTabItem()
+    ImGuiTabItemFlags_NoTooltip                     = 1 << 4,   // Disable tooltip for the given tab
+    ImGuiTabItemFlags_NoReorder                     = 1 << 5,   // Disable reordering this tab or having another tab cross over this tab
+    ImGuiTabItemFlags_Leading                       = 1 << 6,   // Enforce the tab position to the left of the tab bar (after the tab list popup button)
+    ImGuiTabItemFlags_Trailing                      = 1 << 7    // Enforce the tab position to the right of the tab bar (before the scrolling buttons)
+};
+
+// Flags for ImGui::BeginTable()
+// [BETA API] API may evolve slightly! If you use this, please update to the next version when it comes out!
+// - Important! Sizing policies have complex and subtle side effects, more so than you would expect.
+//   Read comments/demos carefully + experiment with live demos to get acquainted with them.
+// - The DEFAULT sizing policies are:
+//    - Default to ImGuiTableFlags_SizingFixedFit    if ScrollX is on, or if host window has ImGuiWindowFlags_AlwaysAutoResize.
+//    - Default to ImGuiTableFlags_SizingStretchSame if ScrollX is off.
+// - When ScrollX is off:
+//    - Table defaults to ImGuiTableFlags_SizingStretchSame -> all Columns defaults to ImGuiTableColumnFlags_WidthStretch with same weight.
+//    - Columns sizing policy allowed: Stretch (default), Fixed/Auto.
+//    - Fixed Columns will generally obtain their requested width (unless the table cannot fit them all).
+//    - Stretch Columns will share the remaining width.
+//    - Mixed Fixed/Stretch columns is possible but has various side-effects on resizing behaviors.
+//      The typical use of mixing sizing policies is: any number of LEADING Fixed columns, followed by one or two TRAILING Stretch columns.
+//      (this is because the visible order of columns have subtle but necessary effects on how they react to manual resizing).
+// - When ScrollX is on:
+//    - Table defaults to ImGuiTableFlags_SizingFixedFit -> all Columns defaults to ImGuiTableColumnFlags_WidthFixed
+//    - Columns sizing policy allowed: Fixed/Auto mostly.
+//    - Fixed Columns can be enlarged as needed. Table will show an horizontal scrollbar if needed.
+//    - When using auto-resizing (non-resizable) fixed columns, querying the content width to use item right-alignment e.g. SetNextItemWidth(-FLT_MIN) doesn't make sense, would create a feedback loop.
+//    - Using Stretch columns OFTEN DOES NOT MAKE SENSE if ScrollX is on, UNLESS you have specified a value for 'inner_width' in BeginTable().
+//      If you specify a value for 'inner_width' then effectively the scrolling space is known and Stretch or mixed Fixed/Stretch columns become meaningful again.
+// - Read on documentation at the top of imgui_tables.cpp for details.
+enum ImGuiTableFlags_
+{
+    // Features
+    ImGuiTableFlags_None                       = 0,
+    ImGuiTableFlags_Resizable                  = 1 << 0,   // Enable resizing columns.
+    ImGuiTableFlags_Reorderable                = 1 << 1,   // Enable reordering columns in header row (need calling TableSetupColumn() + TableHeadersRow() to display headers)
+    ImGuiTableFlags_Hideable                   = 1 << 2,   // Enable hiding/disabling columns in context menu.
+    ImGuiTableFlags_Sortable                   = 1 << 3,   // Enable sorting. Call TableGetSortSpecs() to obtain sort specs. Also see ImGuiTableFlags_SortMulti and ImGuiTableFlags_SortTristate.
+    ImGuiTableFlags_NoSavedSettings            = 1 << 4,   // Disable persisting columns order, width and sort settings in the .ini file.
+    ImGuiTableFlags_ContextMenuInBody          = 1 << 5,   // Right-click on columns body/contents will display table context menu. By default it is available in TableHeadersRow().
+    // Decorations
+    ImGuiTableFlags_RowBg                      = 1 << 6,   // Set each RowBg color with ImGuiCol_TableRowBg or ImGuiCol_TableRowBgAlt (equivalent of calling TableSetBgColor with ImGuiTableBgFlags_RowBg0 on each row manually)
+    ImGuiTableFlags_BordersInnerH              = 1 << 7,   // Draw horizontal borders between rows.
+    ImGuiTableFlags_BordersOuterH              = 1 << 8,   // Draw horizontal borders at the top and bottom.
+    ImGuiTableFlags_BordersInnerV              = 1 << 9,   // Draw vertical borders between columns.
+    ImGuiTableFlags_BordersOuterV              = 1 << 10,  // Draw vertical borders on the left and right sides.
+    ImGuiTableFlags_BordersH                   = ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_BordersOuterH, // Draw horizontal borders.
+    ImGuiTableFlags_BordersV                   = ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_BordersOuterV, // Draw vertical borders.
+    ImGuiTableFlags_BordersInner               = ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_BordersInnerH, // Draw inner borders.
+    ImGuiTableFlags_BordersOuter               = ImGuiTableFlags_BordersOuterV | ImGuiTableFlags_BordersOuterH, // Draw outer borders.
+    ImGuiTableFlags_Borders                    = ImGuiTableFlags_BordersInner | ImGuiTableFlags_BordersOuter,   // Draw all borders.
+    ImGuiTableFlags_NoBordersInBody            = 1 << 11,  // [ALPHA] Disable vertical borders in columns Body (borders will always appears in Headers). -> May move to style
+    ImGuiTableFlags_NoBordersInBodyUntilResize = 1 << 12,  // [ALPHA] Disable vertical borders in columns Body until hovered for resize (borders will always appears in Headers). -> May move to style
+    // Sizing Policy (read above for defaults)
+    ImGuiTableFlags_SizingFixedFit             = 1 << 13,  // Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching contents width.
+    ImGuiTableFlags_SizingFixedSame            = 2 << 13,  // Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable), matching the maximum contents width of all columns. Implicitly enable ImGuiTableFlags_NoKeepColumnsVisible.
+    ImGuiTableFlags_SizingStretchProp          = 3 << 13,  // Columns default to _WidthStretch with default weights proportional to each columns contents widths.
+    ImGuiTableFlags_SizingStretchSame          = 4 << 13,  // Columns default to _WidthStretch with default weights all equal, unless overridden by TableSetupColumn().
+    // Sizing Extra Options
+    ImGuiTableFlags_NoHostExtendX              = 1 << 16,  // Make outer width auto-fit to columns, overriding outer_size.x value. Only available when ScrollX/ScrollY are disabled and Stretch columns are not used.
+    ImGuiTableFlags_NoHostExtendY              = 1 << 17,  // Make outer height stop exactly at outer_size.y (prevent auto-extending table past the limit). Only available when ScrollX/ScrollY are disabled. Data below the limit will be clipped and not visible.
+    ImGuiTableFlags_NoKeepColumnsVisible       = 1 << 18,  // Disable keeping column always minimally visible when ScrollX is off and table gets too small. Not recommended if columns are resizable.
+    ImGuiTableFlags_PreciseWidths              = 1 << 19,  // Disable distributing remainder width to stretched columns (width allocation on a 100-wide table with 3 columns: Without this flag: 33,33,34. With this flag: 33,33,33). With larger number of columns, resizing will appear to be less smooth.
+    // Clipping
+    ImGuiTableFlags_NoClip                     = 1 << 20,  // Disable clipping rectangle for every individual columns (reduce draw command count, items will be able to overflow into other columns). Generally incompatible with TableSetupScrollFreeze().
+    // Padding
+    ImGuiTableFlags_PadOuterX                  = 1 << 21,  // Default if BordersOuterV is on. Enable outer-most padding. Generally desirable if you have headers.
+    ImGuiTableFlags_NoPadOuterX                = 1 << 22,  // Default if BordersOuterV is off. Disable outer-most padding.
+    ImGuiTableFlags_NoPadInnerX                = 1 << 23,  // Disable inner padding between columns (double inner padding if BordersOuterV is on, single inner padding if BordersOuterV is off).
+    // Scrolling
+    ImGuiTableFlags_ScrollX                    = 1 << 24,  // Enable horizontal scrolling. Require 'outer_size' parameter of BeginTable() to specify the container size. Changes default sizing policy. Because this create a child window, ScrollY is currently generally recommended when using ScrollX.
+    ImGuiTableFlags_ScrollY                    = 1 << 25,  // Enable vertical scrolling. Require 'outer_size' parameter of BeginTable() to specify the container size.
+    // Sorting
+    ImGuiTableFlags_SortMulti                  = 1 << 26,  // Hold shift when clicking headers to sort on multiple column. TableGetSortSpecs() may return specs where (SpecsCount > 1).
+    ImGuiTableFlags_SortTristate               = 1 << 27,  // Allow no sorting, disable default sorting. TableGetSortSpecs() may return specs where (SpecsCount == 0).
+
+    // [Internal] Combinations and masks
+    ImGuiTableFlags_SizingMask_                = ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_SizingFixedSame | ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_SizingStretchSame
+
+    // Obsolete names (will be removed soon)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    //, ImGuiTableFlags_ColumnsWidthFixed = ImGuiTableFlags_SizingFixedFit, ImGuiTableFlags_ColumnsWidthStretch = ImGuiTableFlags_SizingStretchSame   // WIP Tables 2020/12
+    //, ImGuiTableFlags_SizingPolicyFixed = ImGuiTableFlags_SizingFixedFit, ImGuiTableFlags_SizingPolicyStretch = ImGuiTableFlags_SizingStretchSame   // WIP Tables 2021/01
+#endif
+};
+
+// Flags for ImGui::TableSetupColumn()
+enum ImGuiTableColumnFlags_
+{
+    // Input configuration flags
+    ImGuiTableColumnFlags_None                  = 0,
+    ImGuiTableColumnFlags_Disabled              = 1 << 0,   // Overriding/master disable flag: hide column, won't show in context menu (unlike calling TableSetColumnEnabled() which manipulates the user accessible state)
+    ImGuiTableColumnFlags_DefaultHide           = 1 << 1,   // Default as a hidden/disabled column.
+    ImGuiTableColumnFlags_DefaultSort           = 1 << 2,   // Default as a sorting column.
+    ImGuiTableColumnFlags_WidthStretch          = 1 << 3,   // Column will stretch. Preferable with horizontal scrolling disabled (default if table sizing policy is _SizingStretchSame or _SizingStretchProp).
+    ImGuiTableColumnFlags_WidthFixed            = 1 << 4,   // Column will not stretch. Preferable with horizontal scrolling enabled (default if table sizing policy is _SizingFixedFit and table is resizable).
+    ImGuiTableColumnFlags_NoResize              = 1 << 5,   // Disable manual resizing.
+    ImGuiTableColumnFlags_NoReorder             = 1 << 6,   // Disable manual reordering this column, this will also prevent other columns from crossing over this column.
+    ImGuiTableColumnFlags_NoHide                = 1 << 7,   // Disable ability to hide/disable this column.
+    ImGuiTableColumnFlags_NoClip                = 1 << 8,   // Disable clipping for this column (all NoClip columns will render in a same draw command).
+    ImGuiTableColumnFlags_NoSort                = 1 << 9,   // Disable ability to sort on this field (even if ImGuiTableFlags_Sortable is set on the table).
+    ImGuiTableColumnFlags_NoSortAscending       = 1 << 10,  // Disable ability to sort in the ascending direction.
+    ImGuiTableColumnFlags_NoSortDescending      = 1 << 11,  // Disable ability to sort in the descending direction.
+    ImGuiTableColumnFlags_NoHeaderLabel         = 1 << 12,  // TableHeadersRow() will not submit label for this column. Convenient for some small columns. Name will still appear in context menu.
+    ImGuiTableColumnFlags_NoHeaderWidth         = 1 << 13,  // Disable header text width contribution to automatic column width.
+    ImGuiTableColumnFlags_PreferSortAscending   = 1 << 14,  // Make the initial sort direction Ascending when first sorting on this column (default).
+    ImGuiTableColumnFlags_PreferSortDescending  = 1 << 15,  // Make the initial sort direction Descending when first sorting on this column.
+    ImGuiTableColumnFlags_IndentEnable          = 1 << 16,  // Use current Indent value when entering cell (default for column 0).
+    ImGuiTableColumnFlags_IndentDisable         = 1 << 17,  // Ignore current Indent value when entering cell (default for columns > 0). Indentation changes _within_ the cell will still be honored.
+
+    // Output status flags, read-only via TableGetColumnFlags()
+    ImGuiTableColumnFlags_IsEnabled             = 1 << 24,  // Status: is enabled == not hidden by user/api (referred to as "Hide" in _DefaultHide and _NoHide) flags.
+    ImGuiTableColumnFlags_IsVisible             = 1 << 25,  // Status: is visible == is enabled AND not clipped by scrolling.
+    ImGuiTableColumnFlags_IsSorted              = 1 << 26,  // Status: is currently part of the sort specs
+    ImGuiTableColumnFlags_IsHovered             = 1 << 27,  // Status: is hovered by mouse
+
+    // [Internal] Combinations and masks
+    ImGuiTableColumnFlags_WidthMask_            = ImGuiTableColumnFlags_WidthStretch | ImGuiTableColumnFlags_WidthFixed,
+    ImGuiTableColumnFlags_IndentMask_           = ImGuiTableColumnFlags_IndentEnable | ImGuiTableColumnFlags_IndentDisable,
+    ImGuiTableColumnFlags_StatusMask_           = ImGuiTableColumnFlags_IsEnabled | ImGuiTableColumnFlags_IsVisible | ImGuiTableColumnFlags_IsSorted | ImGuiTableColumnFlags_IsHovered,
+    ImGuiTableColumnFlags_NoDirectResize_       = 1 << 30   // [Internal] Disable user resizing this column directly (it may however we resized indirectly from its left edge)
+
+    // Obsolete names (will be removed soon)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    //ImGuiTableColumnFlags_WidthAuto           = ImGuiTableColumnFlags_WidthFixed | ImGuiTableColumnFlags_NoResize, // Column will not stretch and keep resizing based on submitted contents.
+#endif
+};
+
+// Flags for ImGui::TableNextRow()
+enum ImGuiTableRowFlags_
+{
+    ImGuiTableRowFlags_None                         = 0,
+    ImGuiTableRowFlags_Headers                      = 1 << 0    // Identify header row (set default background color + width of its contents accounted different for auto column width)
+};
+
+// Enum for ImGui::TableSetBgColor()
+// Background colors are rendering in 3 layers:
+//  - Layer 0: draw with RowBg0 color if set, otherwise draw with ColumnBg0 if set.
+//  - Layer 1: draw with RowBg1 color if set, otherwise draw with ColumnBg1 if set.
+//  - Layer 2: draw with CellBg color if set.
+// The purpose of the two row/columns layers is to let you decide if a background color changes should override or blend with the existing color.
+// When using ImGuiTableFlags_RowBg on the table, each row has the RowBg0 color automatically set for odd/even rows.
+// If you set the color of RowBg0 target, your color will override the existing RowBg0 color.
+// If you set the color of RowBg1 or ColumnBg1 target, your color will blend over the RowBg0 color.
+enum ImGuiTableBgTarget_
+{
+    ImGuiTableBgTarget_None                         = 0,
+    ImGuiTableBgTarget_RowBg0                       = 1,        // Set row background color 0 (generally used for background, automatically set when ImGuiTableFlags_RowBg is used)
+    ImGuiTableBgTarget_RowBg1                       = 2,        // Set row background color 1 (generally used for selection marking)
+    ImGuiTableBgTarget_CellBg                       = 3         // Set cell background color (top-most color)
+};
+
+// Flags for ImGui::IsWindowFocused()
+enum ImGuiFocusedFlags_
+{
+    ImGuiFocusedFlags_None                          = 0,
+    ImGuiFocusedFlags_ChildWindows                  = 1 << 0,   // Return true if any children of the window is focused
+    ImGuiFocusedFlags_RootWindow                    = 1 << 1,   // Test from root window (top most parent of the current hierarchy)
+    ImGuiFocusedFlags_AnyWindow                     = 1 << 2,   // Return true if any window is focused. Important: If you are trying to tell how to dispatch your low-level inputs, do NOT use this. Use 'io.WantCaptureMouse' instead! Please read the FAQ!
+    ImGuiFocusedFlags_NoPopupHierarchy              = 1 << 3,   // Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow)
+    //ImGuiFocusedFlags_DockHierarchy               = 1 << 4,   // Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow)
+    ImGuiFocusedFlags_RootAndChildWindows           = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows
+};
+
+// Flags for ImGui::IsItemHovered(), ImGui::IsWindowHovered()
+// Note: if you are trying to check whether your mouse should be dispatched to Dear ImGui or to your app, you should use 'io.WantCaptureMouse' instead! Please read the FAQ!
+// Note: windows with the ImGuiWindowFlags_NoInputs flag are ignored by IsWindowHovered() calls.
+enum ImGuiHoveredFlags_
+{
+    ImGuiHoveredFlags_None                          = 0,        // Return true if directly over the item/window, not obstructed by another window, not obstructed by an active popup or modal blocking inputs under them.
+    ImGuiHoveredFlags_ChildWindows                  = 1 << 0,   // IsWindowHovered() only: Return true if any children of the window is hovered
+    ImGuiHoveredFlags_RootWindow                    = 1 << 1,   // IsWindowHovered() only: Test from root window (top most parent of the current hierarchy)
+    ImGuiHoveredFlags_AnyWindow                     = 1 << 2,   // IsWindowHovered() only: Return true if any window is hovered
+    ImGuiHoveredFlags_NoPopupHierarchy              = 1 << 3,   // IsWindowHovered() only: Do not consider popup hierarchy (do not treat popup emitter as parent of popup) (when used with _ChildWindows or _RootWindow)
+    //ImGuiHoveredFlags_DockHierarchy               = 1 << 4,   // IsWindowHovered() only: Consider docking hierarchy (treat dockspace host as parent of docked window) (when used with _ChildWindows or _RootWindow)
+    ImGuiHoveredFlags_AllowWhenBlockedByPopup       = 1 << 5,   // Return true even if a popup window is normally blocking access to this item/window
+    //ImGuiHoveredFlags_AllowWhenBlockedByModal     = 1 << 6,   // Return true even if a modal popup window is normally blocking access to this item/window. FIXME-TODO: Unavailable yet.
+    ImGuiHoveredFlags_AllowWhenBlockedByActiveItem  = 1 << 7,   // Return true even if an active item is blocking access to this item/window. Useful for Drag and Drop patterns.
+    ImGuiHoveredFlags_AllowWhenOverlapped           = 1 << 8,   // IsItemHovered() only: Return true even if the position is obstructed or overlapped by another window
+    ImGuiHoveredFlags_AllowWhenDisabled             = 1 << 9,   // IsItemHovered() only: Return true even if the item is disabled
+    ImGuiHoveredFlags_RectOnly                      = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped,
+    ImGuiHoveredFlags_RootAndChildWindows           = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows
+};
+
+// Flags for ImGui::BeginDragDropSource(), ImGui::AcceptDragDropPayload()
+enum ImGuiDragDropFlags_
+{
+    ImGuiDragDropFlags_None                         = 0,
+    // BeginDragDropSource() flags
+    ImGuiDragDropFlags_SourceNoPreviewTooltip       = 1 << 0,   // By default, a successful call to BeginDragDropSource opens a tooltip so you can display a preview or description of the source contents. This flag disable this behavior.
+    ImGuiDragDropFlags_SourceNoDisableHover         = 1 << 1,   // By default, when dragging we clear data so that IsItemHovered() will return false, to avoid subsequent user code submitting tooltips. This flag disable this behavior so you can still call IsItemHovered() on the source item.
+    ImGuiDragDropFlags_SourceNoHoldToOpenOthers     = 1 << 2,   // Disable the behavior that allows to open tree nodes and collapsing header by holding over them while dragging a source item.
+    ImGuiDragDropFlags_SourceAllowNullID            = 1 << 3,   // Allow items such as Text(), Image() that have no unique identifier to be used as drag source, by manufacturing a temporary identifier based on their window-relative position. This is extremely unusual within the dear imgui ecosystem and so we made it explicit.
+    ImGuiDragDropFlags_SourceExtern                 = 1 << 4,   // External source (from outside of dear imgui), won't attempt to read current item/window info. Will always return true. Only one Extern source can be active simultaneously.
+    ImGuiDragDropFlags_SourceAutoExpirePayload      = 1 << 5,   // Automatically expire the payload if the source cease to be submitted (otherwise payloads are persisting while being dragged)
+    // AcceptDragDropPayload() flags
+    ImGuiDragDropFlags_AcceptBeforeDelivery         = 1 << 10,  // AcceptDragDropPayload() will returns true even before the mouse button is released. You can then call IsDelivery() to test if the payload needs to be delivered.
+    ImGuiDragDropFlags_AcceptNoDrawDefaultRect      = 1 << 11,  // Do not draw the default highlight rectangle when hovering over target.
+    ImGuiDragDropFlags_AcceptNoPreviewTooltip       = 1 << 12,  // Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site.
+    ImGuiDragDropFlags_AcceptPeekOnly               = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect  // For peeking ahead and inspecting the payload before delivery.
+};
+
+// Standard Drag and Drop payload types. You can define you own payload types using short strings. Types starting with '_' are defined by Dear ImGui.
+#define IMGUI_PAYLOAD_TYPE_COLOR_3F     "_COL3F"    // float[3]: Standard type for colors, without alpha. User code may use this type.
+#define IMGUI_PAYLOAD_TYPE_COLOR_4F     "_COL4F"    // float[4]: Standard type for colors. User code may use this type.
+
+// A primary data type
+enum ImGuiDataType_
+{
+    ImGuiDataType_S8,       // signed char / char (with sensible compilers)
+    ImGuiDataType_U8,       // unsigned char
+    ImGuiDataType_S16,      // short
+    ImGuiDataType_U16,      // unsigned short
+    ImGuiDataType_S32,      // int
+    ImGuiDataType_U32,      // unsigned int
+    ImGuiDataType_S64,      // long long / __int64
+    ImGuiDataType_U64,      // unsigned long long / unsigned __int64
+    ImGuiDataType_Float,    // float
+    ImGuiDataType_Double,   // double
+    ImGuiDataType_COUNT
+};
+
+// A cardinal direction
+enum ImGuiDir_
+{
+    ImGuiDir_None    = -1,
+    ImGuiDir_Left    = 0,
+    ImGuiDir_Right   = 1,
+    ImGuiDir_Up      = 2,
+    ImGuiDir_Down    = 3,
+    ImGuiDir_COUNT
+};
+
+// A sorting direction
+enum ImGuiSortDirection_
+{
+    ImGuiSortDirection_None         = 0,
+    ImGuiSortDirection_Ascending    = 1,    // Ascending = 0->9, A->Z etc.
+    ImGuiSortDirection_Descending   = 2     // Descending = 9->0, Z->A etc.
+};
+
+// User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
+enum ImGuiKey_
+{
+    ImGuiKey_Tab,
+    ImGuiKey_LeftArrow,
+    ImGuiKey_RightArrow,
+    ImGuiKey_UpArrow,
+    ImGuiKey_DownArrow,
+    ImGuiKey_PageUp,
+    ImGuiKey_PageDown,
+    ImGuiKey_Home,
+    ImGuiKey_End,
+    ImGuiKey_Insert,
+    ImGuiKey_Delete,
+    ImGuiKey_Backspace,
+    ImGuiKey_Space,
+    ImGuiKey_Enter,
+    ImGuiKey_Escape,
+    ImGuiKey_KeyPadEnter,
+    ImGuiKey_A,                 // for text edit CTRL+A: select all
+    ImGuiKey_C,                 // for text edit CTRL+C: copy
+    ImGuiKey_V,                 // for text edit CTRL+V: paste
+    ImGuiKey_X,                 // for text edit CTRL+X: cut
+    ImGuiKey_Y,                 // for text edit CTRL+Y: redo
+    ImGuiKey_Z,                 // for text edit CTRL+Z: undo
+    ImGuiKey_COUNT
+};
+
+// To test io.KeyMods (which is a combination of individual fields io.KeyCtrl, io.KeyShift, io.KeyAlt set by user/backend)
+enum ImGuiKeyModFlags_
+{
+    ImGuiKeyModFlags_None       = 0,
+    ImGuiKeyModFlags_Ctrl       = 1 << 0,
+    ImGuiKeyModFlags_Shift      = 1 << 1,
+    ImGuiKeyModFlags_Alt        = 1 << 2,
+    ImGuiKeyModFlags_Super      = 1 << 3
+};
+
+// Gamepad/Keyboard navigation
+// Keyboard: Set io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard to enable. NewFrame() will automatically fill io.NavInputs[] based on your io.KeysDown[] + io.KeyMap[] arrays.
+// Gamepad:  Set io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad to enable. Backend: set ImGuiBackendFlags_HasGamepad and fill the io.NavInputs[] fields before calling NewFrame(). Note that io.NavInputs[] is cleared by EndFrame().
+// Read instructions in imgui.cpp for more details. Download PNG/PSD at http://dearimgui.org/controls_sheets.
+enum ImGuiNavInput_
+{
+    // Gamepad Mapping
+    ImGuiNavInput_Activate,      // activate / open / toggle / tweak value       // e.g. Cross  (PS4), A (Xbox), A (Switch), Space (Keyboard)
+    ImGuiNavInput_Cancel,        // cancel / close / exit                        // e.g. Circle (PS4), B (Xbox), B (Switch), Escape (Keyboard)
+    ImGuiNavInput_Input,         // text input / on-screen keyboard              // e.g. Triang.(PS4), Y (Xbox), X (Switch), Return (Keyboard)
+    ImGuiNavInput_Menu,          // tap: toggle menu / hold: focus, move, resize // e.g. Square (PS4), X (Xbox), Y (Switch), Alt (Keyboard)
+    ImGuiNavInput_DpadLeft,      // move / tweak / resize window (w/ PadMenu)    // e.g. D-pad Left/Right/Up/Down (Gamepads), Arrow keys (Keyboard)
+    ImGuiNavInput_DpadRight,     //
+    ImGuiNavInput_DpadUp,        //
+    ImGuiNavInput_DpadDown,      //
+    ImGuiNavInput_LStickLeft,    // scroll / move window (w/ PadMenu)            // e.g. Left Analog Stick Left/Right/Up/Down
+    ImGuiNavInput_LStickRight,   //
+    ImGuiNavInput_LStickUp,      //
+    ImGuiNavInput_LStickDown,    //
+    ImGuiNavInput_FocusPrev,     // next window (w/ PadMenu)                     // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
+    ImGuiNavInput_FocusNext,     // prev window (w/ PadMenu)                     // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
+    ImGuiNavInput_TweakSlow,     // slower tweaks                                // e.g. L1 or L2 (PS4), LB or LT (Xbox), L or ZL (Switch)
+    ImGuiNavInput_TweakFast,     // faster tweaks                                // e.g. R1 or R2 (PS4), RB or RT (Xbox), R or ZL (Switch)
+
+    // [Internal] Don't use directly! This is used internally to differentiate keyboard from gamepad inputs for behaviors that require to differentiate them.
+    // Keyboard behavior that have no corresponding gamepad mapping (e.g. CTRL+TAB) will be directly reading from io.KeysDown[] instead of io.NavInputs[].
+    ImGuiNavInput_KeyLeft_,      // move left                                    // = Arrow keys
+    ImGuiNavInput_KeyRight_,     // move right
+    ImGuiNavInput_KeyUp_,        // move up
+    ImGuiNavInput_KeyDown_,      // move down
+    ImGuiNavInput_COUNT,
+    ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyLeft_
+};
+
+// Configuration flags stored in io.ConfigFlags. Set by user/application.
+enum ImGuiConfigFlags_
+{
+    ImGuiConfigFlags_None                   = 0,
+    ImGuiConfigFlags_NavEnableKeyboard      = 1 << 0,   // Master keyboard navigation enable flag. NewFrame() will automatically fill io.NavInputs[] based on io.KeysDown[].
+    ImGuiConfigFlags_NavEnableGamepad       = 1 << 1,   // Master gamepad navigation enable flag. This is mostly to instruct your imgui backend to fill io.NavInputs[]. Backend also needs to set ImGuiBackendFlags_HasGamepad.
+    ImGuiConfigFlags_NavEnableSetMousePos   = 1 << 2,   // Instruct navigation to move the mouse cursor. May be useful on TV/console systems where moving a virtual mouse is awkward. Will update io.MousePos and set io.WantSetMousePos=true. If enabled you MUST honor io.WantSetMousePos requests in your backend, otherwise ImGui will react as if the mouse is jumping around back and forth.
+    ImGuiConfigFlags_NavNoCaptureKeyboard   = 1 << 3,   // Instruct navigation to not set the io.WantCaptureKeyboard flag when io.NavActive is set.
+    ImGuiConfigFlags_NoMouse                = 1 << 4,   // Instruct imgui to clear mouse position/buttons in NewFrame(). This allows ignoring the mouse information set by the backend.
+    ImGuiConfigFlags_NoMouseCursorChange    = 1 << 5,   // Instruct backend to not alter mouse cursor shape and visibility. Use if the backend cursor changes are interfering with yours and you don't want to use SetMouseCursor() to change mouse cursor. You may want to honor requests from imgui by reading GetMouseCursor() yourself instead.
+
+    // User storage (to allow your backend/engine to communicate to code that may be shared between multiple projects. Those flags are not used by core Dear ImGui)
+    ImGuiConfigFlags_IsSRGB                 = 1 << 20,  // Application is SRGB-aware.
+    ImGuiConfigFlags_IsTouchScreen          = 1 << 21   // Application is using a touch screen instead of a mouse.
+};
+
+// Backend capabilities flags stored in io.BackendFlags. Set by imgui_impl_xxx or custom backend.
+enum ImGuiBackendFlags_
+{
+    ImGuiBackendFlags_None                  = 0,
+    ImGuiBackendFlags_HasGamepad            = 1 << 0,   // Backend Platform supports gamepad and currently has one connected.
+    ImGuiBackendFlags_HasMouseCursors       = 1 << 1,   // Backend Platform supports honoring GetMouseCursor() value to change the OS cursor shape.
+    ImGuiBackendFlags_HasSetMousePos        = 1 << 2,   // Backend Platform supports io.WantSetMousePos requests to reposition the OS mouse position (only used if ImGuiConfigFlags_NavEnableSetMousePos is set).
+    ImGuiBackendFlags_RendererHasVtxOffset  = 1 << 3    // Backend Renderer supports ImDrawCmd::VtxOffset. This enables output of large meshes (64K+ vertices) while still using 16-bit indices.
+};
+
+// Enumeration for PushStyleColor() / PopStyleColor()
+enum ImGuiCol_
+{
+    ImGuiCol_Text,
+    ImGuiCol_TextDisabled,
+    ImGuiCol_WindowBg,              // Background of normal windows
+    ImGuiCol_ChildBg,               // Background of child windows
+    ImGuiCol_PopupBg,               // Background of popups, menus, tooltips windows
+    ImGuiCol_Border,
+    ImGuiCol_BorderShadow,
+    ImGuiCol_FrameBg,               // Background of checkbox, radio button, plot, slider, text input
+    ImGuiCol_FrameBgHovered,
+    ImGuiCol_FrameBgActive,
+    ImGuiCol_TitleBg,
+    ImGuiCol_TitleBgActive,
+    ImGuiCol_TitleBgCollapsed,
+    ImGuiCol_MenuBarBg,
+    ImGuiCol_ScrollbarBg,
+    ImGuiCol_ScrollbarGrab,
+    ImGuiCol_ScrollbarGrabHovered,
+    ImGuiCol_ScrollbarGrabActive,
+    ImGuiCol_CheckMark,
+    ImGuiCol_SliderGrab,
+    ImGuiCol_SliderGrabActive,
+    ImGuiCol_Button,
+    ImGuiCol_ButtonHovered,
+    ImGuiCol_ButtonActive,
+    ImGuiCol_Header,                // Header* colors are used for CollapsingHeader, TreeNode, Selectable, MenuItem
+    ImGuiCol_HeaderHovered,
+    ImGuiCol_HeaderActive,
+    ImGuiCol_Separator,
+    ImGuiCol_SeparatorHovered,
+    ImGuiCol_SeparatorActive,
+    ImGuiCol_ResizeGrip,
+    ImGuiCol_ResizeGripHovered,
+    ImGuiCol_ResizeGripActive,
+    ImGuiCol_Tab,
+    ImGuiCol_TabHovered,
+    ImGuiCol_TabActive,
+    ImGuiCol_TabUnfocused,
+    ImGuiCol_TabUnfocusedActive,
+    ImGuiCol_PlotLines,
+    ImGuiCol_PlotLinesHovered,
+    ImGuiCol_PlotHistogram,
+    ImGuiCol_PlotHistogramHovered,
+    ImGuiCol_TableHeaderBg,         // Table header background
+    ImGuiCol_TableBorderStrong,     // Table outer and header borders (prefer using Alpha=1.0 here)
+    ImGuiCol_TableBorderLight,      // Table inner borders (prefer using Alpha=1.0 here)
+    ImGuiCol_TableRowBg,            // Table row background (even rows)
+    ImGuiCol_TableRowBgAlt,         // Table row background (odd rows)
+    ImGuiCol_TextSelectedBg,
+    ImGuiCol_DragDropTarget,
+    ImGuiCol_NavHighlight,          // Gamepad/keyboard: current highlighted item
+    ImGuiCol_NavWindowingHighlight, // Highlight window when using CTRL+TAB
+    ImGuiCol_NavWindowingDimBg,     // Darken/colorize entire screen behind the CTRL+TAB window list, when active
+    ImGuiCol_ModalWindowDimBg,      // Darken/colorize entire screen behind a modal window, when one is active
+    ImGuiCol_COUNT
+};
+
+// Enumeration for PushStyleVar() / PopStyleVar() to temporarily modify the ImGuiStyle structure.
+// - The enum only refers to fields of ImGuiStyle which makes sense to be pushed/popped inside UI code.
+//   During initialization or between frames, feel free to just poke into ImGuiStyle directly.
+// - Tip: Use your programming IDE navigation facilities on the names in the _second column_ below to find the actual members and their description.
+//   In Visual Studio IDE: CTRL+comma ("Edit.NavigateTo") can follow symbols in comments, whereas CTRL+F12 ("Edit.GoToImplementation") cannot.
+//   With Visual Assist installed: ALT+G ("VAssistX.GoToImplementation") can also follow symbols in comments.
+// - When changing this enum, you need to update the associated internal table GStyleVarInfo[] accordingly. This is where we link enum values to members offset/type.
+enum ImGuiStyleVar_
+{
+    // Enum name --------------------- // Member in ImGuiStyle structure (see ImGuiStyle for descriptions)
+    ImGuiStyleVar_Alpha,               // float     Alpha
+    ImGuiStyleVar_DisabledAlpha,       // float     DisabledAlpha
+    ImGuiStyleVar_WindowPadding,       // ImVec2    WindowPadding
+    ImGuiStyleVar_WindowRounding,      // float     WindowRounding
+    ImGuiStyleVar_WindowBorderSize,    // float     WindowBorderSize
+    ImGuiStyleVar_WindowMinSize,       // ImVec2    WindowMinSize
+    ImGuiStyleVar_WindowTitleAlign,    // ImVec2    WindowTitleAlign
+    ImGuiStyleVar_ChildRounding,       // float     ChildRounding
+    ImGuiStyleVar_ChildBorderSize,     // float     ChildBorderSize
+    ImGuiStyleVar_PopupRounding,       // float     PopupRounding
+    ImGuiStyleVar_PopupBorderSize,     // float     PopupBorderSize
+    ImGuiStyleVar_FramePadding,        // ImVec2    FramePadding
+    ImGuiStyleVar_FrameRounding,       // float     FrameRounding
+    ImGuiStyleVar_FrameBorderSize,     // float     FrameBorderSize
+    ImGuiStyleVar_ItemSpacing,         // ImVec2    ItemSpacing
+    ImGuiStyleVar_ItemInnerSpacing,    // ImVec2    ItemInnerSpacing
+    ImGuiStyleVar_IndentSpacing,       // float     IndentSpacing
+    ImGuiStyleVar_CellPadding,         // ImVec2    CellPadding
+    ImGuiStyleVar_ScrollbarSize,       // float     ScrollbarSize
+    ImGuiStyleVar_ScrollbarRounding,   // float     ScrollbarRounding
+    ImGuiStyleVar_GrabMinSize,         // float     GrabMinSize
+    ImGuiStyleVar_GrabRounding,        // float     GrabRounding
+    ImGuiStyleVar_TabRounding,         // float     TabRounding
+    ImGuiStyleVar_ButtonTextAlign,     // ImVec2    ButtonTextAlign
+    ImGuiStyleVar_SelectableTextAlign, // ImVec2    SelectableTextAlign
+    ImGuiStyleVar_COUNT
+};
+
+// Flags for InvisibleButton() [extended in imgui_internal.h]
+enum ImGuiButtonFlags_
+{
+    ImGuiButtonFlags_None                   = 0,
+    ImGuiButtonFlags_MouseButtonLeft        = 1 << 0,   // React on left mouse button (default)
+    ImGuiButtonFlags_MouseButtonRight       = 1 << 1,   // React on right mouse button
+    ImGuiButtonFlags_MouseButtonMiddle      = 1 << 2,   // React on center mouse button
+
+    // [Internal]
+    ImGuiButtonFlags_MouseButtonMask_       = ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight | ImGuiButtonFlags_MouseButtonMiddle,
+    ImGuiButtonFlags_MouseButtonDefault_    = ImGuiButtonFlags_MouseButtonLeft
+};
+
+// Flags for ColorEdit3() / ColorEdit4() / ColorPicker3() / ColorPicker4() / ColorButton()
+enum ImGuiColorEditFlags_
+{
+    ImGuiColorEditFlags_None            = 0,
+    ImGuiColorEditFlags_NoAlpha         = 1 << 1,   //              // ColorEdit, ColorPicker, ColorButton: ignore Alpha component (will only read 3 components from the input pointer).
+    ImGuiColorEditFlags_NoPicker        = 1 << 2,   //              // ColorEdit: disable picker when clicking on color square.
+    ImGuiColorEditFlags_NoOptions       = 1 << 3,   //              // ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.
+    ImGuiColorEditFlags_NoSmallPreview  = 1 << 4,   //              // ColorEdit, ColorPicker: disable color square preview next to the inputs. (e.g. to show only the inputs)
+    ImGuiColorEditFlags_NoInputs        = 1 << 5,   //              // ColorEdit, ColorPicker: disable inputs sliders/text widgets (e.g. to show only the small preview color square).
+    ImGuiColorEditFlags_NoTooltip       = 1 << 6,   //              // ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.
+    ImGuiColorEditFlags_NoLabel         = 1 << 7,   //              // ColorEdit, ColorPicker: disable display of inline text label (the label is still forwarded to the tooltip and picker).
+    ImGuiColorEditFlags_NoSidePreview   = 1 << 8,   //              // ColorPicker: disable bigger color preview on right side of the picker, use small color square preview instead.
+    ImGuiColorEditFlags_NoDragDrop      = 1 << 9,   //              // ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source.
+    ImGuiColorEditFlags_NoBorder        = 1 << 10,  //              // ColorButton: disable border (which is enforced by default)
+
+    // User Options (right-click on widget to change some of them).
+    ImGuiColorEditFlags_AlphaBar        = 1 << 16,  //              // ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.
+    ImGuiColorEditFlags_AlphaPreview    = 1 << 17,  //              // ColorEdit, ColorPicker, ColorButton: display preview as a transparent color over a checkerboard, instead of opaque.
+    ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 18,  //              // ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard, instead of opaque.
+    ImGuiColorEditFlags_HDR             = 1 << 19,  //              // (WIP) ColorEdit: Currently only disable 0.0f..1.0f limits in RGBA edition (note: you probably want to use ImGuiColorEditFlags_Float flag as well).
+    ImGuiColorEditFlags_DisplayRGB      = 1 << 20,  // [Display]    // ColorEdit: override _display_ type among RGB/HSV/Hex. ColorPicker: select any combination using one or more of RGB/HSV/Hex.
+    ImGuiColorEditFlags_DisplayHSV      = 1 << 21,  // [Display]    // "
+    ImGuiColorEditFlags_DisplayHex      = 1 << 22,  // [Display]    // "
+    ImGuiColorEditFlags_Uint8           = 1 << 23,  // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.
+    ImGuiColorEditFlags_Float           = 1 << 24,  // [DataType]   // ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0f..1.0f floats instead of 0..255 integers. No round-trip of value via integers.
+    ImGuiColorEditFlags_PickerHueBar    = 1 << 25,  // [Picker]     // ColorPicker: bar for Hue, rectangle for Sat/Value.
+    ImGuiColorEditFlags_PickerHueWheel  = 1 << 26,  // [Picker]     // ColorPicker: wheel for Hue, triangle for Sat/Value.
+    ImGuiColorEditFlags_InputRGB        = 1 << 27,  // [Input]      // ColorEdit, ColorPicker: input and output data in RGB format.
+    ImGuiColorEditFlags_InputHSV        = 1 << 28,  // [Input]      // ColorEdit, ColorPicker: input and output data in HSV format.
+
+    // Defaults Options. You can set application defaults using SetColorEditOptions(). The intent is that you probably don't want to
+    // override them in most of your calls. Let the user choose via the option menu and/or call SetColorEditOptions() once during startup.
+    ImGuiColorEditFlags_DefaultOptions_ = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_PickerHueBar,
+
+    // [Internal] Masks
+    ImGuiColorEditFlags_DisplayMask_    = ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_DisplayHex,
+    ImGuiColorEditFlags_DataTypeMask_   = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_Float,
+    ImGuiColorEditFlags_PickerMask_     = ImGuiColorEditFlags_PickerHueWheel | ImGuiColorEditFlags_PickerHueBar,
+    ImGuiColorEditFlags_InputMask_      = ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_InputHSV
+
+    // Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    , ImGuiColorEditFlags_RGB = ImGuiColorEditFlags_DisplayRGB, ImGuiColorEditFlags_HSV = ImGuiColorEditFlags_DisplayHSV, ImGuiColorEditFlags_HEX = ImGuiColorEditFlags_DisplayHex  // [renamed in 1.69]
+#endif
+};
+
+// Flags for DragFloat(), DragInt(), SliderFloat(), SliderInt() etc.
+// We use the same sets of flags for DragXXX() and SliderXXX() functions as the features are the same and it makes it easier to swap them.
+enum ImGuiSliderFlags_
+{
+    ImGuiSliderFlags_None                   = 0,
+    ImGuiSliderFlags_AlwaysClamp            = 1 << 4,       // Clamp value to min/max bounds when input manually with CTRL+Click. By default CTRL+Click allows going out of bounds.
+    ImGuiSliderFlags_Logarithmic            = 1 << 5,       // Make the widget logarithmic (linear otherwise). Consider using ImGuiSliderFlags_NoRoundToFormat with this if using a format-string with small amount of digits.
+    ImGuiSliderFlags_NoRoundToFormat        = 1 << 6,       // Disable rounding underlying value to match precision of the display format string (e.g. %.3f values are rounded to those 3 digits)
+    ImGuiSliderFlags_NoInput                = 1 << 7,       // Disable CTRL+Click or Enter key allowing to input text directly into the widget
+    ImGuiSliderFlags_InvalidMask_           = 0x7000000F    // [Internal] We treat using those bits as being potentially a 'float power' argument from the previous API that has got miscast to this enum, and will trigger an assert if needed.
+
+    // Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    , ImGuiSliderFlags_ClampOnInput = ImGuiSliderFlags_AlwaysClamp // [renamed in 1.79]
+#endif
+};
+
+// Identify a mouse button.
+// Those values are guaranteed to be stable and we frequently use 0/1 directly. Named enums provided for convenience.
+enum ImGuiMouseButton_
+{
+    ImGuiMouseButton_Left = 0,
+    ImGuiMouseButton_Right = 1,
+    ImGuiMouseButton_Middle = 2,
+    ImGuiMouseButton_COUNT = 5
+};
+
+// Enumeration for GetMouseCursor()
+// User code may request backend to display given cursor by calling SetMouseCursor(), which is why we have some cursors that are marked unused here
+enum ImGuiMouseCursor_
+{
+    ImGuiMouseCursor_None = -1,
+    ImGuiMouseCursor_Arrow = 0,
+    ImGuiMouseCursor_TextInput,         // When hovering over InputText, etc.
+    ImGuiMouseCursor_ResizeAll,         // (Unused by Dear ImGui functions)
+    ImGuiMouseCursor_ResizeNS,          // When hovering over an horizontal border
+    ImGuiMouseCursor_ResizeEW,          // When hovering over a vertical border or a column
+    ImGuiMouseCursor_ResizeNESW,        // When hovering over the bottom-left corner of a window
+    ImGuiMouseCursor_ResizeNWSE,        // When hovering over the bottom-right corner of a window
+    ImGuiMouseCursor_Hand,              // (Unused by Dear ImGui functions. Use for e.g. hyperlinks)
+    ImGuiMouseCursor_NotAllowed,        // When hovering something with disallowed interaction. Usually a crossed circle.
+    ImGuiMouseCursor_COUNT
+};
+
+// Enumeration for ImGui::SetWindow***(), SetNextWindow***(), SetNextItem***() functions
+// Represent a condition.
+// Important: Treat as a regular enum! Do NOT combine multiple values using binary operators! All the functions above treat 0 as a shortcut to ImGuiCond_Always.
+enum ImGuiCond_
+{
+    ImGuiCond_None          = 0,        // No condition (always set the variable), same as _Always
+    ImGuiCond_Always        = 1 << 0,   // No condition (always set the variable)
+    ImGuiCond_Once          = 1 << 1,   // Set the variable once per runtime session (only the first call will succeed)
+    ImGuiCond_FirstUseEver  = 1 << 2,   // Set the variable if the object/window has no persistently saved data (no entry in .ini file)
+    ImGuiCond_Appearing     = 1 << 3    // Set the variable if the object/window is appearing after being hidden/inactive (or the first time)
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Helpers: Memory allocations macros, ImVector<>
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// IM_MALLOC(), IM_FREE(), IM_NEW(), IM_PLACEMENT_NEW(), IM_DELETE()
+// We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.
+// Defining a custom placement new() with a custom parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions.
+//-----------------------------------------------------------------------------
+
+struct ImNewWrapper {};
+inline void* operator new(size_t, ImNewWrapper, void* ptr) { return ptr; }
+inline void  operator delete(void*, ImNewWrapper, void*)   {} // This is only required so we can use the symmetrical new()
+#define IM_ALLOC(_SIZE)                     ImGui::MemAlloc(_SIZE)
+#define IM_FREE(_PTR)                       ImGui::MemFree(_PTR)
+#define IM_PLACEMENT_NEW(_PTR)              new(ImNewWrapper(), _PTR)
+#define IM_NEW(_TYPE)                       new(ImNewWrapper(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
+template<typename T> void IM_DELETE(T* p)   { if (p) { p->~T(); ImGui::MemFree(p); } }
+
+//-----------------------------------------------------------------------------
+// ImVector<>
+// Lightweight std::vector<>-like class to avoid dragging dependencies (also, some implementations of STL with debug enabled are absurdly slow, we bypass it so our code runs fast in debug).
+//-----------------------------------------------------------------------------
+// - You generally do NOT need to care or use this ever. But we need to make it available in imgui.h because some of our public structures are relying on it.
+// - We use std-like naming convention here, which is a little unusual for this codebase.
+// - Important: clear() frees memory, resize(0) keep the allocated buffer. We use resize(0) a lot to intentionally recycle allocated buffers across frames and amortize our costs.
+// - Important: our implementation does NOT call C++ constructors/destructors, we treat everything as raw data! This is intentional but be extra mindful of that,
+//   Do NOT use this class as a std::vector replacement in your own code! Many of the structures used by dear imgui can be safely initialized by a zero-memset.
+//-----------------------------------------------------------------------------
+
+IM_MSVC_RUNTIME_CHECKS_OFF
+template<typename T>
+struct ImVector
+{
+    int                 Size;
+    int                 Capacity;
+    T*                  Data;
+
+    // Provide standard typedefs but we don't use them ourselves.
+    typedef T                   value_type;
+    typedef value_type*         iterator;
+    typedef const value_type*   const_iterator;
+
+    // Constructors, destructor
+    inline ImVector()                                       { Size = Capacity = 0; Data = NULL; }
+    inline ImVector(const ImVector<T>& src)                 { Size = Capacity = 0; Data = NULL; operator=(src); }
+    inline ImVector<T>& operator=(const ImVector<T>& src)   { clear(); resize(src.Size); memcpy(Data, src.Data, (size_t)Size * sizeof(T)); return *this; }
+    inline ~ImVector()                                      { if (Data) IM_FREE(Data); } // Important: does not destruct anything
+
+    inline void         clear()                             { if (Data) { Size = Capacity = 0; IM_FREE(Data); Data = NULL; } }  // Important: does not destruct anything
+    inline void         clear_delete()                      { for (int n = 0; n < Size; n++) IM_DELETE(Data[n]); clear(); }     // Important: never called automatically! always explicit.
+    inline void         clear_destruct()                    { for (int n = 0; n < Size; n++) Data[n].~T(); clear(); }           // Important: never called automatically! always explicit.
+
+    inline bool         empty() const                       { return Size == 0; }
+    inline int          size() const                        { return Size; }
+    inline int          size_in_bytes() const               { return Size * (int)sizeof(T); }
+    inline int          max_size() const                    { return 0x7FFFFFFF / (int)sizeof(T); }
+    inline int          capacity() const                    { return Capacity; }
+    inline T&           operator[](int i)                   { IM_ASSERT(i >= 0 && i < Size); return Data[i]; }
+    inline const T&     operator[](int i) const             { IM_ASSERT(i >= 0 && i < Size); return Data[i]; }
+
+    inline T*           begin()                             { return Data; }
+    inline const T*     begin() const                       { return Data; }
+    inline T*           end()                               { return Data + Size; }
+    inline const T*     end() const                         { return Data + Size; }
+    inline T&           front()                             { IM_ASSERT(Size > 0); return Data[0]; }
+    inline const T&     front() const                       { IM_ASSERT(Size > 0); return Data[0]; }
+    inline T&           back()                              { IM_ASSERT(Size > 0); return Data[Size - 1]; }
+    inline const T&     back() const                        { IM_ASSERT(Size > 0); return Data[Size - 1]; }
+    inline void         swap(ImVector<T>& rhs)              { int rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; int rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; T* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
+
+    inline int          _grow_capacity(int sz) const        { int new_capacity = Capacity ? (Capacity + Capacity / 2) : 8; return new_capacity > sz ? new_capacity : sz; }
+    inline void         resize(int new_size)                { if (new_size > Capacity) reserve(_grow_capacity(new_size)); Size = new_size; }
+    inline void         resize(int new_size, const T& v)    { if (new_size > Capacity) reserve(_grow_capacity(new_size)); if (new_size > Size) for (int n = Size; n < new_size; n++) memcpy(&Data[n], &v, sizeof(v)); Size = new_size; }
+    inline void         shrink(int new_size)                { IM_ASSERT(new_size <= Size); Size = new_size; } // Resize a vector to a smaller size, guaranteed not to cause a reallocation
+    inline void         reserve(int new_capacity)           { if (new_capacity <= Capacity) return; T* new_data = (T*)IM_ALLOC((size_t)new_capacity * sizeof(T)); if (Data) { memcpy(new_data, Data, (size_t)Size * sizeof(T)); IM_FREE(Data); } Data = new_data; Capacity = new_capacity; }
+
+    // NB: It is illegal to call push_back/push_front/insert with a reference pointing inside the ImVector data itself! e.g. v.push_back(v[10]) is forbidden.
+    inline void         push_back(const T& v)               { if (Size == Capacity) reserve(_grow_capacity(Size + 1)); memcpy(&Data[Size], &v, sizeof(v)); Size++; }
+    inline void         pop_back()                          { IM_ASSERT(Size > 0); Size--; }
+    inline void         push_front(const T& v)              { if (Size == 0) push_back(v); else insert(Data, v); }
+    inline T*           erase(const T* it)                  { IM_ASSERT(it >= Data && it < Data + Size); const ptrdiff_t off = it - Data; memmove(Data + off, Data + off + 1, ((size_t)Size - (size_t)off - 1) * sizeof(T)); Size--; return Data + off; }
+    inline T*           erase(const T* it, const T* it_last){ IM_ASSERT(it >= Data && it < Data + Size && it_last > it && it_last <= Data + Size); const ptrdiff_t count = it_last - it; const ptrdiff_t off = it - Data; memmove(Data + off, Data + off + count, ((size_t)Size - (size_t)off - count) * sizeof(T)); Size -= (int)count; return Data + off; }
+    inline T*           erase_unsorted(const T* it)         { IM_ASSERT(it >= Data && it < Data + Size);  const ptrdiff_t off = it - Data; if (it < Data + Size - 1) memcpy(Data + off, Data + Size - 1, sizeof(T)); Size--; return Data + off; }
+    inline T*           insert(const T* it, const T& v)     { IM_ASSERT(it >= Data && it <= Data + Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(_grow_capacity(Size + 1)); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(T)); memcpy(&Data[off], &v, sizeof(v)); Size++; return Data + off; }
+    inline bool         contains(const T& v) const          { const T* data = Data;  const T* data_end = Data + Size; while (data < data_end) if (*data++ == v) return true; return false; }
+    inline T*           find(const T& v)                    { T* data = Data;  const T* data_end = Data + Size; while (data < data_end) if (*data == v) break; else ++data; return data; }
+    inline const T*     find(const T& v) const              { const T* data = Data;  const T* data_end = Data + Size; while (data < data_end) if (*data == v) break; else ++data; return data; }
+    inline bool         find_erase(const T& v)              { const T* it = find(v); if (it < Data + Size) { erase(it); return true; } return false; }
+    inline bool         find_erase_unsorted(const T& v)     { const T* it = find(v); if (it < Data + Size) { erase_unsorted(it); return true; } return false; }
+    inline int          index_from_ptr(const T* it) const   { IM_ASSERT(it >= Data && it < Data + Size); const ptrdiff_t off = it - Data; return (int)off; }
+};
+IM_MSVC_RUNTIME_CHECKS_RESTORE
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImGuiStyle
+//-----------------------------------------------------------------------------
+// You may modify the ImGui::GetStyle() main instance during initialization and before NewFrame().
+// During the frame, use ImGui::PushStyleVar(ImGuiStyleVar_XXXX)/PopStyleVar() to alter the main style values,
+// and ImGui::PushStyleColor(ImGuiCol_XXX)/PopStyleColor() for colors.
+//-----------------------------------------------------------------------------
+
+struct ImGuiStyle
+{
+    float       Alpha;                      // Global alpha applies to everything in Dear ImGui.
+    float       DisabledAlpha;              // Additional alpha multiplier applied by BeginDisabled(). Multiply over current value of Alpha.
+    ImVec2      WindowPadding;              // Padding within a window.
+    float       WindowRounding;             // Radius of window corners rounding. Set to 0.0f to have rectangular windows. Large values tend to lead to variety of artifacts and are not recommended.
+    float       WindowBorderSize;           // Thickness of border around windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+    ImVec2      WindowMinSize;              // Minimum window size. This is a global setting. If you want to constraint individual windows, use SetNextWindowSizeConstraints().
+    ImVec2      WindowTitleAlign;           // Alignment for title bar text. Defaults to (0.0f,0.5f) for left-aligned,vertically centered.
+    ImGuiDir    WindowMenuButtonPosition;   // Side of the collapsing/docking button in the title bar (None/Left/Right). Defaults to ImGuiDir_Left.
+    float       ChildRounding;              // Radius of child window corners rounding. Set to 0.0f to have rectangular windows.
+    float       ChildBorderSize;            // Thickness of border around child windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+    float       PopupRounding;              // Radius of popup window corners rounding. (Note that tooltip windows use WindowRounding)
+    float       PopupBorderSize;            // Thickness of border around popup/tooltip windows. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+    ImVec2      FramePadding;               // Padding within a framed rectangle (used by most widgets).
+    float       FrameRounding;              // Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
+    float       FrameBorderSize;            // Thickness of border around frames. Generally set to 0.0f or 1.0f. (Other values are not well tested and more CPU/GPU costly).
+    ImVec2      ItemSpacing;                // Horizontal and vertical spacing between widgets/lines.
+    ImVec2      ItemInnerSpacing;           // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label).
+    ImVec2      CellPadding;                // Padding within a table cell
+    ImVec2      TouchExtraPadding;          // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
+    float       IndentSpacing;              // Horizontal indentation when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
+    float       ColumnsMinSpacing;          // Minimum horizontal spacing between two columns. Preferably > (FramePadding.x + 1).
+    float       ScrollbarSize;              // Width of the vertical scrollbar, Height of the horizontal scrollbar.
+    float       ScrollbarRounding;          // Radius of grab corners for scrollbar.
+    float       GrabMinSize;                // Minimum width/height of a grab box for slider/scrollbar.
+    float       GrabRounding;               // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
+    float       LogSliderDeadzone;          // The size in pixels of the dead-zone around zero on logarithmic sliders that cross zero.
+    float       TabRounding;                // Radius of upper corners of a tab. Set to 0.0f to have rectangular tabs.
+    float       TabBorderSize;              // Thickness of border around tabs.
+    float       TabMinWidthForCloseButton;  // Minimum width for close button to appears on an unselected tab when hovered. Set to 0.0f to always show when hovering, set to FLT_MAX to never show close button unless selected.
+    ImGuiDir    ColorButtonPosition;        // Side of the color button in the ColorEdit4 widget (left/right). Defaults to ImGuiDir_Right.
+    ImVec2      ButtonTextAlign;            // Alignment of button text when button is larger than text. Defaults to (0.5f, 0.5f) (centered).
+    ImVec2      SelectableTextAlign;        // Alignment of selectable text. Defaults to (0.0f, 0.0f) (top-left aligned). It's generally important to keep this left-aligned if you want to lay multiple items on a same line.
+    ImVec2      DisplayWindowPadding;       // Window position are clamped to be visible within the display area or monitors by at least this amount. Only applies to regular windows.
+    ImVec2      DisplaySafeAreaPadding;     // If you cannot see the edges of your screen (e.g. on a TV) increase the safe area padding. Apply to popups/tooltips as well regular windows. NB: Prefer configuring your TV sets correctly!
+    float       MouseCursorScale;           // Scale software rendered mouse cursor (when io.MouseDrawCursor is enabled). May be removed later.
+    bool        AntiAliasedLines;           // Enable anti-aliased lines/borders. Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
+    bool        AntiAliasedLinesUseTex;     // Enable anti-aliased lines/borders using textures where possible. Require backend to render with bilinear filtering. Latched at the beginning of the frame (copied to ImDrawList).
+    bool        AntiAliasedFill;            // Enable anti-aliased edges around filled shapes (rounded rectangles, circles, etc.). Disable if you are really tight on CPU/GPU. Latched at the beginning of the frame (copied to ImDrawList).
+    float       CurveTessellationTol;       // Tessellation tolerance when using PathBezierCurveTo() without a specific number of segments. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
+    float       CircleTessellationMaxError; // Maximum error (in pixels) allowed when using AddCircle()/AddCircleFilled() or drawing rounded corner rectangles with no explicit segment count specified. Decrease for higher quality but more geometry.
+    ImVec4      Colors[ImGuiCol_COUNT];
+
+    IMGUI_API ImGuiStyle();
+    IMGUI_API void ScaleAllSizes(float scale_factor);
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImGuiIO
+//-----------------------------------------------------------------------------
+// Communicate most settings and inputs/outputs to Dear ImGui using this structure.
+// Access via ImGui::GetIO(). Read 'Programmer guide' section in .cpp file for general usage.
+//-----------------------------------------------------------------------------
+
+struct ImGuiIO
+{
+    //------------------------------------------------------------------
+    // Configuration (fill once)                // Default value
+    //------------------------------------------------------------------
+
+    ImGuiConfigFlags   ConfigFlags;             // = 0              // See ImGuiConfigFlags_ enum. Set by user/application. Gamepad/keyboard navigation options, etc.
+    ImGuiBackendFlags  BackendFlags;            // = 0              // See ImGuiBackendFlags_ enum. Set by backend (imgui_impl_xxx files or custom backend) to communicate features supported by the backend.
+    ImVec2      DisplaySize;                    // <unset>          // Main display size, in pixels (generally == GetMainViewport()->Size)
+    float       DeltaTime;                      // = 1.0f/60.0f     // Time elapsed since last frame, in seconds.
+    float       IniSavingRate;                  // = 5.0f           // Minimum time between saving positions/sizes to .ini file, in seconds.
+    const char* IniFilename;                    // = "imgui.ini"    // Path to .ini file (important: default "imgui.ini" is relative to current working dir!). Set NULL to disable automatic .ini loading/saving or if you want to manually call LoadIniSettingsXXX() / SaveIniSettingsXXX() functions.
+    const char* LogFilename;                    // = "imgui_log.txt"// Path to .log file (default parameter to ImGui::LogToFile when no file is specified).
+    float       MouseDoubleClickTime;           // = 0.30f          // Time for a double-click, in seconds.
+    float       MouseDoubleClickMaxDist;        // = 6.0f           // Distance threshold to stay in to validate a double-click, in pixels.
+    float       MouseDragThreshold;             // = 6.0f           // Distance threshold before considering we are dragging.
+    int         KeyMap[ImGuiKey_COUNT];         // <unset>          // Map of indices into the KeysDown[512] entries array which represent your "native" keyboard state.
+    float       KeyRepeatDelay;                 // = 0.250f         // When holding a key/button, time before it starts repeating, in seconds (for buttons in Repeat mode, etc.).
+    float       KeyRepeatRate;                  // = 0.050f         // When holding a key/button, rate at which it repeats, in seconds.
+    void*       UserData;                       // = NULL           // Store your own data for retrieval by callbacks.
+
+    ImFontAtlas*Fonts;                          // <auto>           // Font atlas: load, rasterize and pack one or more fonts into a single texture.
+    float       FontGlobalScale;                // = 1.0f           // Global scale all fonts
+    bool        FontAllowUserScaling;           // = false          // Allow user scaling text of individual window with CTRL+Wheel.
+    ImFont*     FontDefault;                    // = NULL           // Font to use on NewFrame(). Use NULL to uses Fonts->Fonts[0].
+    ImVec2      DisplayFramebufferScale;        // = (1, 1)         // For retina display or other situations where window coordinates are different from framebuffer coordinates. This generally ends up in ImDrawData::FramebufferScale.
+
+    // Miscellaneous options
+    bool        MouseDrawCursor;                // = false          // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor). Cannot be easily renamed to 'io.ConfigXXX' because this is frequently used by backend implementations.
+    bool        ConfigMacOSXBehaviors;          // = defined(__APPLE__) // OS X style: Text editing cursor movement using Alt instead of Ctrl, Shortcuts using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows instead of Home/End, Double click selects by word instead of selecting whole text, Multi-selection in lists uses Cmd/Super instead of Ctrl.
+    bool        ConfigInputTextCursorBlink;     // = true           // Enable blinking cursor (optional as some users consider it to be distracting).
+    bool        ConfigDragClickToInputText;     // = false          // [BETA] Enable turning DragXXX widgets into text input with a simple mouse click-release (without moving). Not desirable on devices without a keyboard.
+    bool        ConfigWindowsResizeFromEdges;   // = true           // Enable resizing of windows from their edges and from the lower-left corner. This requires (io.BackendFlags & ImGuiBackendFlags_HasMouseCursors) because it needs mouse cursor feedback. (This used to be a per-window ImGuiWindowFlags_ResizeFromAnySide flag)
+    bool        ConfigWindowsMoveFromTitleBarOnly; // = false       // Enable allowing to move windows only when clicking on their title bar. Does not apply to windows without a title bar.
+    float       ConfigMemoryCompactTimer;       // = 60.0f          // Timer (in seconds) to free transient windows/tables memory buffers when unused. Set to -1.0f to disable.
+
+    //------------------------------------------------------------------
+    // Platform Functions
+    // (the imgui_impl_xxxx backend files are setting those up for you)
+    //------------------------------------------------------------------
+
+    // Optional: Platform/Renderer backend name (informational only! will be displayed in About Window) + User data for backend/wrappers to store their own stuff.
+    const char* BackendPlatformName;            // = NULL
+    const char* BackendRendererName;            // = NULL
+    void*       BackendPlatformUserData;        // = NULL           // User data for platform backend
+    void*       BackendRendererUserData;        // = NULL           // User data for renderer backend
+    void*       BackendLanguageUserData;        // = NULL           // User data for non C++ programming language backend
+
+    // Optional: Access OS clipboard
+    // (default to use native Win32 clipboard on Windows, otherwise uses a private clipboard. Override to access OS clipboard on other architectures)
+    const char* (*GetClipboardTextFn)(void* user_data);
+    void        (*SetClipboardTextFn)(void* user_data, const char* text);
+    void*       ClipboardUserData;
+
+    // Optional: Notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese IME on Windows)
+    // (default to use native imm32 api on Windows)
+    void        (*ImeSetInputScreenPosFn)(int x, int y);
+    void*       ImeWindowHandle;                // = NULL           // (Windows) Set this to your HWND to get automatic IME cursor positioning.
+
+    //------------------------------------------------------------------
+    // Input - Fill before calling NewFrame()
+    //------------------------------------------------------------------
+
+    ImVec2      MousePos;                       // Mouse position, in pixels. Set to ImVec2(-FLT_MAX, -FLT_MAX) if mouse is unavailable (on another screen, etc.)
+    bool        MouseDown[5];                   // Mouse buttons: 0=left, 1=right, 2=middle + extras (ImGuiMouseButton_COUNT == 5). Dear ImGui mostly uses left and right buttons. Others buttons allows us to track if the mouse is being used by your application + available to user as a convenience via IsMouse** API.
+    float       MouseWheel;                     // Mouse wheel Vertical: 1 unit scrolls about 5 lines text.
+    float       MouseWheelH;                    // Mouse wheel Horizontal. Most users don't have a mouse with an horizontal wheel, may not be filled by all backends.
+    bool        KeyCtrl;                        // Keyboard modifier pressed: Control
+    bool        KeyShift;                       // Keyboard modifier pressed: Shift
+    bool        KeyAlt;                         // Keyboard modifier pressed: Alt
+    bool        KeySuper;                       // Keyboard modifier pressed: Cmd/Super/Windows
+    bool        KeysDown[512];                  // Keyboard keys that are pressed (ideally left in the "native" order your engine has access to keyboard keys, so you can use your own defines/enums for keys).
+    float       NavInputs[ImGuiNavInput_COUNT]; // Gamepad inputs. Cleared back to zero by EndFrame(). Keyboard keys will be auto-mapped and be written here by NewFrame().
+
+    // Functions
+    IMGUI_API void  AddInputCharacter(unsigned int c);          // Queue new character input
+    IMGUI_API void  AddInputCharacterUTF16(ImWchar16 c);        // Queue new character input from an UTF-16 character, it can be a surrogate
+    IMGUI_API void  AddInputCharactersUTF8(const char* str);    // Queue new characters input from an UTF-8 string
+    IMGUI_API void  AddFocusEvent(bool focused);                // Notifies Dear ImGui when hosting platform windows lose or gain input focus
+    IMGUI_API void  ClearInputCharacters();                     // [Internal] Clear the text input buffer manually
+    IMGUI_API void  ClearInputKeys();                           // [Internal] Release all keys
+
+    //------------------------------------------------------------------
+    // Output - Updated by NewFrame() or EndFrame()/Render()
+    // (when reading from the io.WantCaptureMouse, io.WantCaptureKeyboard flags to dispatch your inputs, it is
+    //  generally easier and more correct to use their state BEFORE calling NewFrame(). See FAQ for details!)
+    //------------------------------------------------------------------
+
+    bool        WantCaptureMouse;               // Set when Dear ImGui will use mouse inputs, in this case do not dispatch them to your main game/application (either way, always pass on mouse inputs to imgui). (e.g. unclicked mouse is hovering over an imgui window, widget is active, mouse was clicked over an imgui window, etc.).
+    bool        WantCaptureKeyboard;            // Set when Dear ImGui will use keyboard inputs, in this case do not dispatch them to your main game/application (either way, always pass keyboard inputs to imgui). (e.g. InputText active, or an imgui window is focused and navigation is enabled, etc.).
+    bool        WantTextInput;                  // Mobile/console: when set, you may display an on-screen keyboard. This is set by Dear ImGui when it wants textual keyboard input to happen (e.g. when a InputText widget is active).
+    bool        WantSetMousePos;                // MousePos has been altered, backend should reposition mouse on next frame. Rarely used! Set only when ImGuiConfigFlags_NavEnableSetMousePos flag is enabled.
+    bool        WantSaveIniSettings;            // When manual .ini load/save is active (io.IniFilename == NULL), this will be set to notify your application that you can call SaveIniSettingsToMemory() and save yourself. Important: clear io.WantSaveIniSettings yourself after saving!
+    bool        NavActive;                      // Keyboard/Gamepad navigation is currently allowed (will handle ImGuiKey_NavXXX events) = a window is focused and it doesn't use the ImGuiWindowFlags_NoNavInputs flag.
+    bool        NavVisible;                     // Keyboard/Gamepad navigation is visible and allowed (will handle ImGuiKey_NavXXX events).
+    float       Framerate;                      // Rough estimate of application framerate, in frame per second. Solely for convenience. Rolling average estimation based on io.DeltaTime over 120 frames.
+    int         MetricsRenderVertices;          // Vertices output during last call to Render()
+    int         MetricsRenderIndices;           // Indices output during last call to Render() = number of triangles * 3
+    int         MetricsRenderWindows;           // Number of visible windows
+    int         MetricsActiveWindows;           // Number of active windows
+    int         MetricsActiveAllocations;       // Number of active allocations, updated by MemAlloc/MemFree based on current context. May be off if you have multiple imgui contexts.
+    ImVec2      MouseDelta;                     // Mouse delta. Note that this is zero if either current or previous position are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have a huge delta.
+
+    //------------------------------------------------------------------
+    // [Internal] Dear ImGui will maintain those fields. Forward compatibility not guaranteed!
+    //------------------------------------------------------------------
+
+    bool        WantCaptureMouseUnlessPopupClose;// Alternative to WantCaptureMouse: (WantCaptureMouse == true && WantCaptureMouseUnlessPopupClose == false) when a click over void is expected to close a popup.
+    ImGuiKeyModFlags KeyMods;                   // Key mods flags (same as io.KeyCtrl/KeyShift/KeyAlt/KeySuper but merged into flags), updated by NewFrame()
+    ImGuiKeyModFlags KeyModsPrev;               // Previous key mods
+    ImVec2      MousePosPrev;                   // Previous mouse position (note that MouseDelta is not necessary == MousePos-MousePosPrev, in case either position is invalid)
+    ImVec2      MouseClickedPos[5];             // Position at time of clicking
+    double      MouseClickedTime[5];            // Time of last click (used to figure out double-click)
+    bool        MouseClicked[5];                // Mouse button went from !Down to Down
+    bool        MouseDoubleClicked[5];          // Has mouse button been double-clicked?
+    bool        MouseReleased[5];               // Mouse button went from Down to !Down
+    bool        MouseDownOwned[5];              // Track if button was clicked inside a dear imgui window or over void blocked by a popup. We don't request mouse capture from the application if click started outside ImGui bounds.
+    bool        MouseDownOwnedUnlessPopupClose[5];//Track if button was clicked inside a dear imgui window.
+    bool        MouseDownWasDoubleClick[5];     // Track if button down was a double-click
+    float       MouseDownDuration[5];           // Duration the mouse button has been down (0.0f == just clicked)
+    float       MouseDownDurationPrev[5];       // Previous time the mouse button has been down
+    ImVec2      MouseDragMaxDistanceAbs[5];     // Maximum distance, absolute, on each axis, of how much mouse has traveled from the clicking point
+    float       MouseDragMaxDistanceSqr[5];     // Squared maximum distance of how much mouse has traveled from the clicking point
+    float       KeysDownDuration[512];          // Duration the keyboard key has been down (0.0f == just pressed)
+    float       KeysDownDurationPrev[512];      // Previous duration the key has been down
+    float       NavInputsDownDuration[ImGuiNavInput_COUNT];
+    float       NavInputsDownDurationPrev[ImGuiNavInput_COUNT];
+    float       PenPressure;                    // Touch/Pen pressure (0.0f to 1.0f, should be >0.0f only when MouseDown[0] == true). Helper storage currently unused by Dear ImGui.
+    bool        AppFocusLost;
+    ImWchar16   InputQueueSurrogate;            // For AddInputCharacterUTF16
+    ImVector<ImWchar> InputQueueCharacters;     // Queue of _characters_ input (obtained by platform backend). Fill using AddInputCharacter() helper.
+
+    IMGUI_API   ImGuiIO();
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Misc data structures
+//-----------------------------------------------------------------------------
+
+// Shared state of InputText(), passed as an argument to your callback when a ImGuiInputTextFlags_Callback* flag is used.
+// The callback function should return 0 by default.
+// Callbacks (follow a flag name and see comments in ImGuiInputTextFlags_ declarations for more details)
+// - ImGuiInputTextFlags_CallbackEdit:        Callback on buffer edit (note that InputText() already returns true on edit, the callback is useful mainly to manipulate the underlying buffer while focus is active)
+// - ImGuiInputTextFlags_CallbackAlways:      Callback on each iteration
+// - ImGuiInputTextFlags_CallbackCompletion:  Callback on pressing TAB
+// - ImGuiInputTextFlags_CallbackHistory:     Callback on pressing Up/Down arrows
+// - ImGuiInputTextFlags_CallbackCharFilter:  Callback on character inputs to replace or discard them. Modify 'EventChar' to replace or discard, or return 1 in callback to discard.
+// - ImGuiInputTextFlags_CallbackResize:      Callback on buffer capacity changes request (beyond 'buf_size' parameter value), allowing the string to grow.
+struct ImGuiInputTextCallbackData
+{
+    ImGuiInputTextFlags EventFlag;      // One ImGuiInputTextFlags_Callback*    // Read-only
+    ImGuiInputTextFlags Flags;          // What user passed to InputText()      // Read-only
+    void*               UserData;       // What user passed to InputText()      // Read-only
+
+    // Arguments for the different callback events
+    // - To modify the text buffer in a callback, prefer using the InsertChars() / DeleteChars() function. InsertChars() will take care of calling the resize callback if necessary.
+    // - If you know your edits are not going to resize the underlying buffer allocation, you may modify the contents of 'Buf[]' directly. You need to update 'BufTextLen' accordingly (0 <= BufTextLen < BufSize) and set 'BufDirty'' to true so InputText can update its internal state.
+    ImWchar             EventChar;      // Character input                      // Read-write   // [CharFilter] Replace character with another one, or set to zero to drop. return 1 is equivalent to setting EventChar=0;
+    ImGuiKey            EventKey;       // Key pressed (Up/Down/TAB)            // Read-only    // [Completion,History]
+    char*               Buf;            // Text buffer                          // Read-write   // [Resize] Can replace pointer / [Completion,History,Always] Only write to pointed data, don't replace the actual pointer!
+    int                 BufTextLen;     // Text length (in bytes)               // Read-write   // [Resize,Completion,History,Always] Exclude zero-terminator storage. In C land: == strlen(some_text), in C++ land: string.length()
+    int                 BufSize;        // Buffer size (in bytes) = capacity+1  // Read-only    // [Resize,Completion,History,Always] Include zero-terminator storage. In C land == ARRAYSIZE(my_char_array), in C++ land: string.capacity()+1
+    bool                BufDirty;       // Set if you modify Buf/BufTextLen!    // Write        // [Completion,History,Always]
+    int                 CursorPos;      //                                      // Read-write   // [Completion,History,Always]
+    int                 SelectionStart; //                                      // Read-write   // [Completion,History,Always] == to SelectionEnd when no selection)
+    int                 SelectionEnd;   //                                      // Read-write   // [Completion,History,Always]
+
+    // Helper functions for text manipulation.
+    // Use those function to benefit from the CallbackResize behaviors. Calling those function reset the selection.
+    IMGUI_API ImGuiInputTextCallbackData();
+    IMGUI_API void      DeleteChars(int pos, int bytes_count);
+    IMGUI_API void      InsertChars(int pos, const char* text, const char* text_end = NULL);
+    void                SelectAll()             { SelectionStart = 0; SelectionEnd = BufTextLen; }
+    void                ClearSelection()        { SelectionStart = SelectionEnd = BufTextLen; }
+    bool                HasSelection() const    { return SelectionStart != SelectionEnd; }
+};
+
+// Resizing callback data to apply custom constraint. As enabled by SetNextWindowSizeConstraints(). Callback is called during the next Begin().
+// NB: For basic min/max size constraint on each axis you don't need to use the callback! The SetNextWindowSizeConstraints() parameters are enough.
+struct ImGuiSizeCallbackData
+{
+    void*   UserData;       // Read-only.   What user passed to SetNextWindowSizeConstraints()
+    ImVec2  Pos;            // Read-only.   Window position, for reference.
+    ImVec2  CurrentSize;    // Read-only.   Current window size.
+    ImVec2  DesiredSize;    // Read-write.  Desired size, based on user's mouse position. Write to this field to restrain resizing.
+};
+
+// Data payload for Drag and Drop operations: AcceptDragDropPayload(), GetDragDropPayload()
+struct ImGuiPayload
+{
+    // Members
+    void*           Data;               // Data (copied and owned by dear imgui)
+    int             DataSize;           // Data size
+
+    // [Internal]
+    ImGuiID         SourceId;           // Source item id
+    ImGuiID         SourceParentId;     // Source parent id (if available)
+    int             DataFrameCount;     // Data timestamp
+    char            DataType[32 + 1];   // Data type tag (short user-supplied string, 32 characters max)
+    bool            Preview;            // Set when AcceptDragDropPayload() was called and mouse has been hovering the target item (nb: handle overlapping drag targets)
+    bool            Delivery;           // Set when AcceptDragDropPayload() was called and mouse button is released over the target item.
+
+    ImGuiPayload()  { Clear(); }
+    void Clear()    { SourceId = SourceParentId = 0; Data = NULL; DataSize = 0; memset(DataType, 0, sizeof(DataType)); DataFrameCount = -1; Preview = Delivery = false; }
+    bool IsDataType(const char* type) const { return DataFrameCount != -1 && strcmp(type, DataType) == 0; }
+    bool IsPreview() const                  { return Preview; }
+    bool IsDelivery() const                 { return Delivery; }
+};
+
+// Sorting specification for one column of a table (sizeof == 12 bytes)
+struct ImGuiTableColumnSortSpecs
+{
+    ImGuiID                     ColumnUserID;       // User id of the column (if specified by a TableSetupColumn() call)
+    ImS16                       ColumnIndex;        // Index of the column
+    ImS16                       SortOrder;          // Index within parent ImGuiTableSortSpecs (always stored in order starting from 0, tables sorted on a single criteria will always have a 0 here)
+    ImGuiSortDirection          SortDirection : 8;  // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending (you can use this or SortSign, whichever is more convenient for your sort function)
+
+    ImGuiTableColumnSortSpecs() { memset(this, 0, sizeof(*this)); }
+};
+
+// Sorting specifications for a table (often handling sort specs for a single column, occasionally more)
+// Obtained by calling TableGetSortSpecs().
+// When 'SpecsDirty == true' you can sort your data. It will be true with sorting specs have changed since last call, or the first time.
+// Make sure to set 'SpecsDirty = false' after sorting, else you may wastefully sort your data every frame!
+struct ImGuiTableSortSpecs
+{
+    const ImGuiTableColumnSortSpecs* Specs;     // Pointer to sort spec array.
+    int                         SpecsCount;     // Sort spec count. Most often 1. May be > 1 when ImGuiTableFlags_SortMulti is enabled. May be == 0 when ImGuiTableFlags_SortTristate is enabled.
+    bool                        SpecsDirty;     // Set to true when specs have changed since last time! Use this to sort again, then clear the flag.
+
+    ImGuiTableSortSpecs()       { memset(this, 0, sizeof(*this)); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Helpers (ImGuiOnceUponAFrame, ImGuiTextFilter, ImGuiTextBuffer, ImGuiStorage, ImGuiListClipper, ImColor)
+//-----------------------------------------------------------------------------
+
+// Helper: Unicode defines
+#define IM_UNICODE_CODEPOINT_INVALID 0xFFFD     // Invalid Unicode code point (standard value).
+#ifdef IMGUI_USE_WCHAR32
+#define IM_UNICODE_CODEPOINT_MAX     0x10FFFF   // Maximum Unicode code point supported by this build.
+#else
+#define IM_UNICODE_CODEPOINT_MAX     0xFFFF     // Maximum Unicode code point supported by this build.
+#endif
+
+// Helper: Execute a block of code at maximum once a frame. Convenient if you want to quickly create an UI within deep-nested code that runs multiple times every frame.
+// Usage: static ImGuiOnceUponAFrame oaf; if (oaf) ImGui::Text("This will be called only once per frame");
+struct ImGuiOnceUponAFrame
+{
+    ImGuiOnceUponAFrame() { RefFrame = -1; }
+    mutable int RefFrame;
+    operator bool() const { int current_frame = ImGui::GetFrameCount(); if (RefFrame == current_frame) return false; RefFrame = current_frame; return true; }
+};
+
+// Helper: Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
+struct ImGuiTextFilter
+{
+    IMGUI_API           ImGuiTextFilter(const char* default_filter = "");
+    IMGUI_API bool      Draw(const char* label = "Filter (inc,-exc)", float width = 0.0f);  // Helper calling InputText+Build
+    IMGUI_API bool      PassFilter(const char* text, const char* text_end = NULL) const;
+    IMGUI_API void      Build();
+    void                Clear()          { InputBuf[0] = 0; Build(); }
+    bool                IsActive() const { return !Filters.empty(); }
+
+    // [Internal]
+    struct ImGuiTextRange
+    {
+        const char*     b;
+        const char*     e;
+
+        ImGuiTextRange()                                { b = e = NULL; }
+        ImGuiTextRange(const char* _b, const char* _e)  { b = _b; e = _e; }
+        bool            empty() const                   { return b == e; }
+        IMGUI_API void  split(char separator, ImVector<ImGuiTextRange>* out) const;
+    };
+    char                    InputBuf[256];
+    ImVector<ImGuiTextRange>Filters;
+    int                     CountGrep;
+};
+
+// Helper: Growable text buffer for logging/accumulating text
+// (this could be called 'ImGuiTextBuilder' / 'ImGuiStringBuilder')
+struct ImGuiTextBuffer
+{
+    ImVector<char>      Buf;
+    IMGUI_API static char EmptyString[1];
+
+    ImGuiTextBuffer()   { }
+    inline char         operator[](int i) const { IM_ASSERT(Buf.Data != NULL); return Buf.Data[i]; }
+    const char*         begin() const           { return Buf.Data ? &Buf.front() : EmptyString; }
+    const char*         end() const             { return Buf.Data ? &Buf.back() : EmptyString; }   // Buf is zero-terminated, so end() will point on the zero-terminator
+    int                 size() const            { return Buf.Size ? Buf.Size - 1 : 0; }
+    bool                empty() const           { return Buf.Size <= 1; }
+    void                clear()                 { Buf.clear(); }
+    void                reserve(int capacity)   { Buf.reserve(capacity); }
+    const char*         c_str() const           { return Buf.Data ? Buf.Data : EmptyString; }
+    IMGUI_API void      append(const char* str, const char* str_end = NULL);
+    IMGUI_API void      appendf(const char* fmt, ...) IM_FMTARGS(2);
+    IMGUI_API void      appendfv(const char* fmt, va_list args) IM_FMTLIST(2);
+};
+
+// Helper: Key->Value storage
+// Typically you don't have to worry about this since a storage is held within each Window.
+// We use it to e.g. store collapse state for a tree (Int 0/1)
+// This is optimized for efficient lookup (dichotomy into a contiguous buffer) and rare insertion (typically tied to user interactions aka max once a frame)
+// You can use it as custom user storage for temporary values. Declare your own storage if, for example:
+// - You want to manipulate the open/close state of a particular sub-tree in your interface (tree node uses Int 0/1 to store their state).
+// - You want to store custom debug data easily without adding or editing structures in your code (probably not efficient, but convenient)
+// Types are NOT stored, so it is up to you to make sure your Key don't collide with different types.
+struct ImGuiStorage
+{
+    // [Internal]
+    struct ImGuiStoragePair
+    {
+        ImGuiID key;
+        union { int val_i; float val_f; void* val_p; };
+        ImGuiStoragePair(ImGuiID _key, int _val_i)      { key = _key; val_i = _val_i; }
+        ImGuiStoragePair(ImGuiID _key, float _val_f)    { key = _key; val_f = _val_f; }
+        ImGuiStoragePair(ImGuiID _key, void* _val_p)    { key = _key; val_p = _val_p; }
+    };
+
+    ImVector<ImGuiStoragePair>      Data;
+
+    // - Get***() functions find pair, never add/allocate. Pairs are sorted so a query is O(log N)
+    // - Set***() functions find pair, insertion on demand if missing.
+    // - Sorted insertion is costly, paid once. A typical frame shouldn't need to insert any new pair.
+    void                Clear() { Data.clear(); }
+    IMGUI_API int       GetInt(ImGuiID key, int default_val = 0) const;
+    IMGUI_API void      SetInt(ImGuiID key, int val);
+    IMGUI_API bool      GetBool(ImGuiID key, bool default_val = false) const;
+    IMGUI_API void      SetBool(ImGuiID key, bool val);
+    IMGUI_API float     GetFloat(ImGuiID key, float default_val = 0.0f) const;
+    IMGUI_API void      SetFloat(ImGuiID key, float val);
+    IMGUI_API void*     GetVoidPtr(ImGuiID key) const; // default_val is NULL
+    IMGUI_API void      SetVoidPtr(ImGuiID key, void* val);
+
+    // - Get***Ref() functions finds pair, insert on demand if missing, return pointer. Useful if you intend to do Get+Set.
+    // - References are only valid until a new value is added to the storage. Calling a Set***() function or a Get***Ref() function invalidates the pointer.
+    // - A typical use case where this is convenient for quick hacking (e.g. add storage during a live Edit&Continue session if you can't modify existing struct)
+    //      float* pvar = ImGui::GetFloatRef(key); ImGui::SliderFloat("var", pvar, 0, 100.0f); some_var += *pvar;
+    IMGUI_API int*      GetIntRef(ImGuiID key, int default_val = 0);
+    IMGUI_API bool*     GetBoolRef(ImGuiID key, bool default_val = false);
+    IMGUI_API float*    GetFloatRef(ImGuiID key, float default_val = 0.0f);
+    IMGUI_API void**    GetVoidPtrRef(ImGuiID key, void* default_val = NULL);
+
+    // Use on your own storage if you know only integer are being stored (open/close all tree nodes)
+    IMGUI_API void      SetAllInt(int val);
+
+    // For quicker full rebuild of a storage (instead of an incremental one), you may add all your contents and then sort once.
+    IMGUI_API void      BuildSortByKey();
+};
+
+// Helper: Manually clip large list of items.
+// If you are submitting lots of evenly spaced items and you have a random access to the list, you can perform coarse
+// clipping based on visibility to save yourself from processing those items at all.
+// The clipper calculates the range of visible items and advance the cursor to compensate for the non-visible items we have skipped.
+// (Dear ImGui already clip items based on their bounds but it needs to measure text size to do so, whereas manual coarse clipping before submission makes this cost and your own data fetching/submission cost almost null)
+// Usage:
+//   ImGuiListClipper clipper;
+//   clipper.Begin(1000);         // We have 1000 elements, evenly spaced.
+//   while (clipper.Step())
+//       for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
+//           ImGui::Text("line number %d", i);
+// Generally what happens is:
+// - Clipper lets you process the first element (DisplayStart = 0, DisplayEnd = 1) regardless of it being visible or not.
+// - User code submit one element.
+// - Clipper can measure the height of the first element
+// - Clipper calculate the actual range of elements to display based on the current clipping rectangle, position the cursor before the first visible element.
+// - User code submit visible elements.
+struct ImGuiListClipper
+{
+    int     DisplayStart;
+    int     DisplayEnd;
+
+    // [Internal]
+    int     ItemsCount;
+    int     StepNo;
+    int     ItemsFrozen;
+    float   ItemsHeight;
+    float   StartPosY;
+
+    IMGUI_API ImGuiListClipper();
+    IMGUI_API ~ImGuiListClipper();
+
+    // items_count: Use INT_MAX if you don't know how many items you have (in which case the cursor won't be advanced in the final step)
+    // items_height: Use -1.0f to be calculated automatically on first step. Otherwise pass in the distance between your items, typically GetTextLineHeightWithSpacing() or GetFrameHeightWithSpacing().
+    IMGUI_API void Begin(int items_count, float items_height = -1.0f);  // Automatically called by constructor if you passed 'items_count' or by Step() in Step 1.
+    IMGUI_API void End();                                               // Automatically called on the last call of Step() that returns false.
+    IMGUI_API bool Step();                                              // Call until it returns false. The DisplayStart/DisplayEnd fields will be set and you can process/draw those items.
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    inline ImGuiListClipper(int items_count, float items_height = -1.0f) { memset(this, 0, sizeof(*this)); ItemsCount = -1; Begin(items_count, items_height); } // [removed in 1.79]
+#endif
+};
+
+// Helpers macros to generate 32-bit encoded colors
+#ifdef IMGUI_USE_BGRA_PACKED_COLOR
+#define IM_COL32_R_SHIFT    16
+#define IM_COL32_G_SHIFT    8
+#define IM_COL32_B_SHIFT    0
+#define IM_COL32_A_SHIFT    24
+#define IM_COL32_A_MASK     0xFF000000
+#else
+#define IM_COL32_R_SHIFT    0
+#define IM_COL32_G_SHIFT    8
+#define IM_COL32_B_SHIFT    16
+#define IM_COL32_A_SHIFT    24
+#define IM_COL32_A_MASK     0xFF000000
+#endif
+#define IM_COL32(R,G,B,A)    (((ImU32)(A)<<IM_COL32_A_SHIFT) | ((ImU32)(B)<<IM_COL32_B_SHIFT) | ((ImU32)(G)<<IM_COL32_G_SHIFT) | ((ImU32)(R)<<IM_COL32_R_SHIFT))
+#define IM_COL32_WHITE       IM_COL32(255,255,255,255)  // Opaque white = 0xFFFFFFFF
+#define IM_COL32_BLACK       IM_COL32(0,0,0,255)        // Opaque black
+#define IM_COL32_BLACK_TRANS IM_COL32(0,0,0,0)          // Transparent black = 0x00000000
+
+// Helper: ImColor() implicitly converts colors to either ImU32 (packed 4x1 byte) or ImVec4 (4x1 float)
+// Prefer using IM_COL32() macros if you want a guaranteed compile-time ImU32 for usage with ImDrawList API.
+// **Avoid storing ImColor! Store either u32 of ImVec4. This is not a full-featured color class. MAY OBSOLETE.
+// **None of the ImGui API are using ImColor directly but you can use it as a convenience to pass colors in either ImU32 or ImVec4 formats. Explicitly cast to ImU32 or ImVec4 if needed.
+struct ImColor
+{
+    ImVec4              Value;
+
+    ImColor()                                                       { Value.x = Value.y = Value.z = Value.w = 0.0f; }
+    ImColor(int r, int g, int b, int a = 255)                       { float sc = 1.0f / 255.0f; Value.x = (float)r * sc; Value.y = (float)g * sc; Value.z = (float)b * sc; Value.w = (float)a * sc; }
+    ImColor(ImU32 rgba)                                             { float sc = 1.0f / 255.0f; Value.x = (float)((rgba >> IM_COL32_R_SHIFT) & 0xFF) * sc; Value.y = (float)((rgba >> IM_COL32_G_SHIFT) & 0xFF) * sc; Value.z = (float)((rgba >> IM_COL32_B_SHIFT) & 0xFF) * sc; Value.w = (float)((rgba >> IM_COL32_A_SHIFT) & 0xFF) * sc; }
+    ImColor(float r, float g, float b, float a = 1.0f)              { Value.x = r; Value.y = g; Value.z = b; Value.w = a; }
+    ImColor(const ImVec4& col)                                      { Value = col; }
+    inline operator ImU32() const                                   { return ImGui::ColorConvertFloat4ToU32(Value); }
+    inline operator ImVec4() const                                  { return Value; }
+
+    // FIXME-OBSOLETE: May need to obsolete/cleanup those helpers.
+    inline void    SetHSV(float h, float s, float v, float a = 1.0f){ ImGui::ColorConvertHSVtoRGB(h, s, v, Value.x, Value.y, Value.z); Value.w = a; }
+    static ImColor HSV(float h, float s, float v, float a = 1.0f)   { float r, g, b; ImGui::ColorConvertHSVtoRGB(h, s, v, r, g, b); return ImColor(r, g, b, a); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Drawing API (ImDrawCmd, ImDrawIdx, ImDrawVert, ImDrawChannel, ImDrawListSplitter, ImDrawListFlags, ImDrawList, ImDrawData)
+// Hold a series of drawing commands. The user provides a renderer for ImDrawData which essentially contains an array of ImDrawList.
+//-----------------------------------------------------------------------------
+
+// The maximum line width to bake anti-aliased textures for. Build atlas with ImFontAtlasFlags_NoBakedLines to disable baking.
+#ifndef IM_DRAWLIST_TEX_LINES_WIDTH_MAX
+#define IM_DRAWLIST_TEX_LINES_WIDTH_MAX     (63)
+#endif
+
+// ImDrawCallback: Draw callbacks for advanced uses [configurable type: override in imconfig.h]
+// NB: You most likely do NOT need to use draw callbacks just to create your own widget or customized UI rendering,
+// you can poke into the draw list for that! Draw callback may be useful for example to:
+//  A) Change your GPU render state,
+//  B) render a complex 3D scene inside a UI element without an intermediate texture/render target, etc.
+// The expected behavior from your rendering function is 'if (cmd.UserCallback != NULL) { cmd.UserCallback(parent_list, cmd); } else { RenderTriangles() }'
+// If you want to override the signature of ImDrawCallback, you can simply use e.g. '#define ImDrawCallback MyDrawCallback' (in imconfig.h) + update rendering backend accordingly.
+#ifndef ImDrawCallback
+typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd);
+#endif
+
+// Special Draw callback value to request renderer backend to reset the graphics/render state.
+// The renderer backend needs to handle this special value, otherwise it will crash trying to call a function at this address.
+// This is useful for example if you submitted callbacks which you know have altered the render state and you want it to be restored.
+// It is not done by default because they are many perfectly useful way of altering render state for imgui contents (e.g. changing shader/blending settings before an Image call).
+#define ImDrawCallback_ResetRenderState     (ImDrawCallback)(-1)
+
+// Typically, 1 command = 1 GPU draw call (unless command is a callback)
+// - VtxOffset/IdxOffset: When 'io.BackendFlags & ImGuiBackendFlags_RendererHasVtxOffset' is enabled,
+//   those fields allow us to render meshes larger than 64K vertices while keeping 16-bit indices.
+//   Pre-1.71 backends will typically ignore the VtxOffset/IdxOffset fields.
+// - The ClipRect/TextureId/VtxOffset fields must be contiguous as we memcmp() them together (this is asserted for).
+struct ImDrawCmd
+{
+    ImVec4          ClipRect;           // 4*4  // Clipping rectangle (x1, y1, x2, y2). Subtract ImDrawData->DisplayPos to get clipping rectangle in "viewport" coordinates
+    ImTextureID     TextureId;          // 4-8  // User-provided texture ID. Set by user in ImfontAtlas::SetTexID() for fonts or passed to Image*() functions. Ignore if never using images or multiple fonts atlas.
+    unsigned int    VtxOffset;          // 4    // Start offset in vertex buffer. ImGuiBackendFlags_RendererHasVtxOffset: always 0, otherwise may be >0 to support meshes larger than 64K vertices with 16-bit indices.
+    unsigned int    IdxOffset;          // 4    // Start offset in index buffer. Always equal to sum of ElemCount drawn so far.
+    unsigned int    ElemCount;          // 4    // Number of indices (multiple of 3) to be rendered as triangles. Vertices are stored in the callee ImDrawList's vtx_buffer[] array, indices in idx_buffer[].
+    ImDrawCallback  UserCallback;       // 4-8  // If != NULL, call the function instead of rendering the vertices. clip_rect and texture_id will be set normally.
+    void*           UserCallbackData;   // 4-8  // The draw callback code can access this.
+
+    ImDrawCmd() { memset(this, 0, sizeof(*this)); } // Also ensure our padding fields are zeroed
+
+    // Since 1.83: returns ImTextureID associated with this draw call. Warning: DO NOT assume this is always same as 'TextureId' (we will change this function for an upcoming feature)
+    inline ImTextureID GetTexID() const { return TextureId; }
+};
+
+// Vertex layout
+#ifndef IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT
+struct ImDrawVert
+{
+    ImVec2  pos;
+    ImVec2  uv;
+    ImU32   col;
+};
+#else
+// You can override the vertex format layout by defining IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT in imconfig.h
+// The code expect ImVec2 pos (8 bytes), ImVec2 uv (8 bytes), ImU32 col (4 bytes), but you can re-order them or add other fields as needed to simplify integration in your engine.
+// The type has to be described within the macro (you can either declare the struct or use a typedef). This is because ImVec2/ImU32 are likely not declared a the time you'd want to set your type up.
+// NOTE: IMGUI DOESN'T CLEAR THE STRUCTURE AND DOESN'T CALL A CONSTRUCTOR SO ANY CUSTOM FIELD WILL BE UNINITIALIZED. IF YOU ADD EXTRA FIELDS (SUCH AS A 'Z' COORDINATES) YOU WILL NEED TO CLEAR THEM DURING RENDER OR TO IGNORE THEM.
+IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT;
+#endif
+
+// [Internal] For use by ImDrawList
+struct ImDrawCmdHeader
+{
+    ImVec4          ClipRect;
+    ImTextureID     TextureId;
+    unsigned int    VtxOffset;
+};
+
+// [Internal] For use by ImDrawListSplitter
+struct ImDrawChannel
+{
+    ImVector<ImDrawCmd>         _CmdBuffer;
+    ImVector<ImDrawIdx>         _IdxBuffer;
+};
+
+
+// Split/Merge functions are used to split the draw list into different layers which can be drawn into out of order.
+// This is used by the Columns/Tables API, so items of each column can be batched together in a same draw call.
+struct ImDrawListSplitter
+{
+    int                         _Current;    // Current channel number (0)
+    int                         _Count;      // Number of active channels (1+)
+    ImVector<ImDrawChannel>     _Channels;   // Draw channels (not resized down so _Count might be < Channels.Size)
+
+    inline ImDrawListSplitter()  { memset(this, 0, sizeof(*this)); }
+    inline ~ImDrawListSplitter() { ClearFreeMemory(); }
+    inline void                 Clear() { _Current = 0; _Count = 1; } // Do not clear Channels[] so our allocations are reused next frame
+    IMGUI_API void              ClearFreeMemory();
+    IMGUI_API void              Split(ImDrawList* draw_list, int count);
+    IMGUI_API void              Merge(ImDrawList* draw_list);
+    IMGUI_API void              SetCurrentChannel(ImDrawList* draw_list, int channel_idx);
+};
+
+// Flags for ImDrawList functions
+// (Legacy: bit 0 must always correspond to ImDrawFlags_Closed to be backward compatible with old API using a bool. Bits 1..3 must be unused)
+enum ImDrawFlags_
+{
+    ImDrawFlags_None                        = 0,
+    ImDrawFlags_Closed                      = 1 << 0, // PathStroke(), AddPolyline(): specify that shape should be closed (Important: this is always == 1 for legacy reason)
+    ImDrawFlags_RoundCornersTopLeft         = 1 << 4, // AddRect(), AddRectFilled(), PathRect(): enable rounding top-left corner only (when rounding > 0.0f, we default to all corners). Was 0x01.
+    ImDrawFlags_RoundCornersTopRight        = 1 << 5, // AddRect(), AddRectFilled(), PathRect(): enable rounding top-right corner only (when rounding > 0.0f, we default to all corners). Was 0x02.
+    ImDrawFlags_RoundCornersBottomLeft      = 1 << 6, // AddRect(), AddRectFilled(), PathRect(): enable rounding bottom-left corner only (when rounding > 0.0f, we default to all corners). Was 0x04.
+    ImDrawFlags_RoundCornersBottomRight     = 1 << 7, // AddRect(), AddRectFilled(), PathRect(): enable rounding bottom-right corner only (when rounding > 0.0f, we default to all corners). Wax 0x08.
+    ImDrawFlags_RoundCornersNone            = 1 << 8, // AddRect(), AddRectFilled(), PathRect(): disable rounding on all corners (when rounding > 0.0f). This is NOT zero, NOT an implicit flag!
+    ImDrawFlags_RoundCornersTop             = ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight,
+    ImDrawFlags_RoundCornersBottom          = ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersBottomRight,
+    ImDrawFlags_RoundCornersLeft            = ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersTopLeft,
+    ImDrawFlags_RoundCornersRight           = ImDrawFlags_RoundCornersBottomRight | ImDrawFlags_RoundCornersTopRight,
+    ImDrawFlags_RoundCornersAll             = ImDrawFlags_RoundCornersTopLeft | ImDrawFlags_RoundCornersTopRight | ImDrawFlags_RoundCornersBottomLeft | ImDrawFlags_RoundCornersBottomRight,
+    ImDrawFlags_RoundCornersDefault_        = ImDrawFlags_RoundCornersAll, // Default to ALL corners if none of the _RoundCornersXX flags are specified.
+    ImDrawFlags_RoundCornersMask_           = ImDrawFlags_RoundCornersAll | ImDrawFlags_RoundCornersNone
+};
+
+// Flags for ImDrawList instance. Those are set automatically by ImGui:: functions from ImGuiIO settings, and generally not manipulated directly.
+// It is however possible to temporarily alter flags between calls to ImDrawList:: functions.
+enum ImDrawListFlags_
+{
+    ImDrawListFlags_None                    = 0,
+    ImDrawListFlags_AntiAliasedLines        = 1 << 0,  // Enable anti-aliased lines/borders (*2 the number of triangles for 1.0f wide line or lines thin enough to be drawn using textures, otherwise *3 the number of triangles)
+    ImDrawListFlags_AntiAliasedLinesUseTex  = 1 << 1,  // Enable anti-aliased lines/borders using textures when possible. Require backend to render with bilinear filtering.
+    ImDrawListFlags_AntiAliasedFill         = 1 << 2,  // Enable anti-aliased edge around filled shapes (rounded rectangles, circles).
+    ImDrawListFlags_AllowVtxOffset          = 1 << 3   // Can emit 'VtxOffset > 0' to allow large meshes. Set when 'ImGuiBackendFlags_RendererHasVtxOffset' is enabled.
+};
+
+// Draw command list
+// This is the low-level list of polygons that ImGui:: functions are filling. At the end of the frame,
+// all command lists are passed to your ImGuiIO::RenderDrawListFn function for rendering.
+// Each dear imgui window contains its own ImDrawList. You can use ImGui::GetWindowDrawList() to
+// access the current window draw list and draw custom primitives.
+// You can interleave normal ImGui:: calls and adding primitives to the current draw list.
+// In single viewport mode, top-left is == GetMainViewport()->Pos (generally 0,0), bottom-right is == GetMainViewport()->Pos+Size (generally io.DisplaySize).
+// You are totally free to apply whatever transformation matrix to want to the data (depending on the use of the transformation you may want to apply it to ClipRect as well!)
+// Important: Primitives are always added to the list and not culled (culling is done at higher-level by ImGui:: functions), if you use this API a lot consider coarse culling your drawn objects.
+struct ImDrawList
+{
+    // This is what you have to render
+    ImVector<ImDrawCmd>     CmdBuffer;          // Draw commands. Typically 1 command = 1 GPU draw call, unless the command is a callback.
+    ImVector<ImDrawIdx>     IdxBuffer;          // Index buffer. Each command consume ImDrawCmd::ElemCount of those
+    ImVector<ImDrawVert>    VtxBuffer;          // Vertex buffer.
+    ImDrawListFlags         Flags;              // Flags, you may poke into these to adjust anti-aliasing settings per-primitive.
+
+    // [Internal, used while building lists]
+    unsigned int            _VtxCurrentIdx;     // [Internal] generally == VtxBuffer.Size unless we are past 64K vertices, in which case this gets reset to 0.
+    const ImDrawListSharedData* _Data;          // Pointer to shared draw data (you can use ImGui::GetDrawListSharedData() to get the one from current ImGui context)
+    const char*             _OwnerName;         // Pointer to owner window's name for debugging
+    ImDrawVert*             _VtxWritePtr;       // [Internal] point within VtxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
+    ImDrawIdx*              _IdxWritePtr;       // [Internal] point within IdxBuffer.Data after each add command (to avoid using the ImVector<> operators too much)
+    ImVector<ImVec4>        _ClipRectStack;     // [Internal]
+    ImVector<ImTextureID>   _TextureIdStack;    // [Internal]
+    ImVector<ImVec2>        _Path;              // [Internal] current path building
+    ImDrawCmdHeader         _CmdHeader;         // [Internal] template of active commands. Fields should match those of CmdBuffer.back().
+    ImDrawListSplitter      _Splitter;          // [Internal] for channels api (note: prefer using your own persistent instance of ImDrawListSplitter!)
+    float                   _FringeScale;       // [Internal] anti-alias fringe is scaled by this value, this helps to keep things sharp while zooming at vertex buffer content
+
+    // If you want to create ImDrawList instances, pass them ImGui::GetDrawListSharedData() or create and use your own ImDrawListSharedData (so you can use ImDrawList without ImGui)
+    ImDrawList(const ImDrawListSharedData* shared_data) { memset(this, 0, sizeof(*this)); _Data = shared_data; }
+
+    ~ImDrawList() { _ClearFreeMemory(); }
+    IMGUI_API void  PushClipRect(ImVec2 clip_rect_min, ImVec2 clip_rect_max, bool intersect_with_current_clip_rect = false);  // Render-level scissoring. This is passed down to your render function but not used for CPU-side coarse clipping. Prefer using higher-level ImGui::PushClipRect() to affect logic (hit-testing and widget culling)
+    IMGUI_API void  PushClipRectFullScreen();
+    IMGUI_API void  PopClipRect();
+    IMGUI_API void  PushTextureID(ImTextureID texture_id);
+    IMGUI_API void  PopTextureID();
+    inline ImVec2   GetClipRectMin() const { const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.x, cr.y); }
+    inline ImVec2   GetClipRectMax() const { const ImVec4& cr = _ClipRectStack.back(); return ImVec2(cr.z, cr.w); }
+
+    // Primitives
+    // - For rectangular primitives, "p_min" and "p_max" represent the upper-left and lower-right corners.
+    // - For circle primitives, use "num_segments == 0" to automatically calculate tessellation (preferred).
+    //   In older versions (until Dear ImGui 1.77) the AddCircle functions defaulted to num_segments == 12.
+    //   In future versions we will use textures to provide cheaper and higher-quality circles.
+    //   Use AddNgon() and AddNgonFilled() functions if you need to guaranteed a specific number of sides.
+    IMGUI_API void  AddLine(const ImVec2& p1, const ImVec2& p2, ImU32 col, float thickness = 1.0f);
+    IMGUI_API void  AddRect(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding = 0.0f, ImDrawFlags flags = 0, float thickness = 1.0f);   // a: upper-left, b: lower-right (== upper-left + size)
+    IMGUI_API void  AddRectFilled(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding = 0.0f, ImDrawFlags flags = 0);                     // a: upper-left, b: lower-right (== upper-left + size)
+    IMGUI_API void  AddRectFilledMultiColor(const ImVec2& p_min, const ImVec2& p_max, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left);
+    IMGUI_API void  AddQuad(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness = 1.0f);
+    IMGUI_API void  AddQuadFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col);
+    IMGUI_API void  AddTriangle(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness = 1.0f);
+    IMGUI_API void  AddTriangleFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col);
+    IMGUI_API void  AddCircle(const ImVec2& center, float radius, ImU32 col, int num_segments = 0, float thickness = 1.0f);
+    IMGUI_API void  AddCircleFilled(const ImVec2& center, float radius, ImU32 col, int num_segments = 0);
+    IMGUI_API void  AddNgon(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness = 1.0f);
+    IMGUI_API void  AddNgonFilled(const ImVec2& center, float radius, ImU32 col, int num_segments);
+    IMGUI_API void  AddText(const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL);
+    IMGUI_API void  AddText(const ImFont* font, float font_size, const ImVec2& pos, ImU32 col, const char* text_begin, const char* text_end = NULL, float wrap_width = 0.0f, const ImVec4* cpu_fine_clip_rect = NULL);
+    IMGUI_API void  AddPolyline(const ImVec2* points, int num_points, ImU32 col, ImDrawFlags flags, float thickness);
+    IMGUI_API void  AddConvexPolyFilled(const ImVec2* points, int num_points, ImU32 col); // Note: Anti-aliased filling requires points to be in clockwise order.
+    IMGUI_API void  AddBezierCubic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness, int num_segments = 0); // Cubic Bezier (4 control points)
+    IMGUI_API void  AddBezierQuadratic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness, int num_segments = 0);               // Quadratic Bezier (3 control points)
+
+    // Image primitives
+    // - Read FAQ to understand what ImTextureID is.
+    // - "p_min" and "p_max" represent the upper-left and lower-right corners of the rectangle.
+    // - "uv_min" and "uv_max" represent the normalized texture coordinates to use for those corners. Using (0,0)->(1,1) texture coordinates will generally display the entire texture.
+    IMGUI_API void  AddImage(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min = ImVec2(0, 0), const ImVec2& uv_max = ImVec2(1, 1), ImU32 col = IM_COL32_WHITE);
+    IMGUI_API void  AddImageQuad(ImTextureID user_texture_id, const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& uv1 = ImVec2(0, 0), const ImVec2& uv2 = ImVec2(1, 0), const ImVec2& uv3 = ImVec2(1, 1), const ImVec2& uv4 = ImVec2(0, 1), ImU32 col = IM_COL32_WHITE);
+    IMGUI_API void  AddImageRounded(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col, float rounding, ImDrawFlags flags = 0);
+
+    // Stateful path API, add points then finish with PathFillConvex() or PathStroke()
+    inline    void  PathClear()                                                 { _Path.Size = 0; }
+    inline    void  PathLineTo(const ImVec2& pos)                               { _Path.push_back(pos); }
+    inline    void  PathLineToMergeDuplicate(const ImVec2& pos)                 { if (_Path.Size == 0 || memcmp(&_Path.Data[_Path.Size - 1], &pos, 8) != 0) _Path.push_back(pos); }
+    inline    void  PathFillConvex(ImU32 col)                                   { AddConvexPolyFilled(_Path.Data, _Path.Size, col); _Path.Size = 0; }  // Note: Anti-aliased filling requires points to be in clockwise order.
+    inline    void  PathStroke(ImU32 col, ImDrawFlags flags = 0, float thickness = 1.0f) { AddPolyline(_Path.Data, _Path.Size, col, flags, thickness); _Path.Size = 0; }
+    IMGUI_API void  PathArcTo(const ImVec2& center, float radius, float a_min, float a_max, int num_segments = 0);
+    IMGUI_API void  PathArcToFast(const ImVec2& center, float radius, int a_min_of_12, int a_max_of_12);                // Use precomputed angles for a 12 steps circle
+    IMGUI_API void  PathBezierCubicCurveTo(const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, int num_segments = 0); // Cubic Bezier (4 control points)
+    IMGUI_API void  PathBezierQuadraticCurveTo(const ImVec2& p2, const ImVec2& p3, int num_segments = 0);               // Quadratic Bezier (3 control points)
+    IMGUI_API void  PathRect(const ImVec2& rect_min, const ImVec2& rect_max, float rounding = 0.0f, ImDrawFlags flags = 0);
+
+    // Advanced
+    IMGUI_API void  AddCallback(ImDrawCallback callback, void* callback_data);  // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles.
+    IMGUI_API void  AddDrawCmd();                                               // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
+    IMGUI_API ImDrawList* CloneOutput() const;                                  // Create a clone of the CmdBuffer/IdxBuffer/VtxBuffer.
+
+    // Advanced: Channels
+    // - Use to split render into layers. By switching channels to can render out-of-order (e.g. submit FG primitives before BG primitives)
+    // - Use to minimize draw calls (e.g. if going back-and-forth between multiple clipping rectangles, prefer to append into separate channels then merge at the end)
+    // - FIXME-OBSOLETE: This API shouldn't have been in ImDrawList in the first place!
+    //   Prefer using your own persistent instance of ImDrawListSplitter as you can stack them.
+    //   Using the ImDrawList::ChannelsXXXX you cannot stack a split over another.
+    inline void     ChannelsSplit(int count)    { _Splitter.Split(this, count); }
+    inline void     ChannelsMerge()             { _Splitter.Merge(this); }
+    inline void     ChannelsSetCurrent(int n)   { _Splitter.SetCurrentChannel(this, n); }
+
+    // Advanced: Primitives allocations
+    // - We render triangles (three vertices)
+    // - All primitives needs to be reserved via PrimReserve() beforehand.
+    IMGUI_API void  PrimReserve(int idx_count, int vtx_count);
+    IMGUI_API void  PrimUnreserve(int idx_count, int vtx_count);
+    IMGUI_API void  PrimRect(const ImVec2& a, const ImVec2& b, ImU32 col);      // Axis aligned rectangle (composed of two triangles)
+    IMGUI_API void  PrimRectUV(const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, ImU32 col);
+    IMGUI_API void  PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col);
+    inline    void  PrimWriteVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col)    { _VtxWritePtr->pos = pos; _VtxWritePtr->uv = uv; _VtxWritePtr->col = col; _VtxWritePtr++; _VtxCurrentIdx++; }
+    inline    void  PrimWriteIdx(ImDrawIdx idx)                                     { *_IdxWritePtr = idx; _IdxWritePtr++; }
+    inline    void  PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col)         { PrimWriteIdx((ImDrawIdx)_VtxCurrentIdx); PrimWriteVtx(pos, uv, col); } // Write vertex with unique index
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    inline    void  AddBezierCurve(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness, int num_segments = 0) { AddBezierCubic(p1, p2, p3, p4, col, thickness, num_segments); }
+    inline    void  PathBezierCurveTo(const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, int num_segments = 0) { PathBezierCubicCurveTo(p2, p3, p4, num_segments); }
+#endif
+
+    // [Internal helpers]
+    IMGUI_API void  _ResetForNewFrame();
+    IMGUI_API void  _ClearFreeMemory();
+    IMGUI_API void  _PopUnusedDrawCmd();
+    IMGUI_API void  _TryMergeDrawCmds();
+    IMGUI_API void  _OnChangedClipRect();
+    IMGUI_API void  _OnChangedTextureID();
+    IMGUI_API void  _OnChangedVtxOffset();
+    IMGUI_API int   _CalcCircleAutoSegmentCount(float radius) const;
+    IMGUI_API void  _PathArcToFastEx(const ImVec2& center, float radius, int a_min_sample, int a_max_sample, int a_step);
+    IMGUI_API void  _PathArcToN(const ImVec2& center, float radius, float a_min, float a_max, int num_segments);
+};
+
+// All draw data to render a Dear ImGui frame
+// (NB: the style and the naming convention here is a little inconsistent, we currently preserve them for backward compatibility purpose,
+// as this is one of the oldest structure exposed by the library! Basically, ImDrawList == CmdList)
+struct ImDrawData
+{
+    bool            Valid;                  // Only valid after Render() is called and before the next NewFrame() is called.
+    int             CmdListsCount;          // Number of ImDrawList* to render
+    int             TotalIdxCount;          // For convenience, sum of all ImDrawList's IdxBuffer.Size
+    int             TotalVtxCount;          // For convenience, sum of all ImDrawList's VtxBuffer.Size
+    ImDrawList**    CmdLists;               // Array of ImDrawList* to render. The ImDrawList are owned by ImGuiContext and only pointed to from here.
+    ImVec2          DisplayPos;             // Top-left position of the viewport to render (== top-left of the orthogonal projection matrix to use) (== GetMainViewport()->Pos for the main viewport, == (0.0) in most single-viewport applications)
+    ImVec2          DisplaySize;            // Size of the viewport to render (== GetMainViewport()->Size for the main viewport, == io.DisplaySize in most single-viewport applications)
+    ImVec2          FramebufferScale;       // Amount of pixels for each unit of DisplaySize. Based on io.DisplayFramebufferScale. Generally (1,1) on normal display, (2,2) on OSX with Retina display.
+
+    // Functions
+    ImDrawData()    { Clear(); }
+    void Clear()    { memset(this, 0, sizeof(*this)); }     // The ImDrawList are owned by ImGuiContext!
+    IMGUI_API void  DeIndexAllBuffers();                    // Helper to convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
+    IMGUI_API void  ScaleClipRects(const ImVec2& fb_scale); // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than Dear ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Font API (ImFontConfig, ImFontGlyph, ImFontAtlasFlags, ImFontAtlas, ImFontGlyphRangesBuilder, ImFont)
+//-----------------------------------------------------------------------------
+
+struct ImFontConfig
+{
+    void*           FontData;               //          // TTF/OTF data
+    int             FontDataSize;           //          // TTF/OTF data size
+    bool            FontDataOwnedByAtlas;   // true     // TTF/OTF data ownership taken by the container ImFontAtlas (will delete memory itself).
+    int             FontNo;                 // 0        // Index of font within TTF/OTF file
+    float           SizePixels;             //          // Size in pixels for rasterizer (more or less maps to the resulting font height).
+    int             OversampleH;            // 3        // Rasterize at higher quality for sub-pixel positioning. Note the difference between 2 and 3 is minimal so you can reduce this to 2 to save memory. Read https://github.com/nothings/stb/blob/master/tests/oversample/README.md for details.
+    int             OversampleV;            // 1        // Rasterize at higher quality for sub-pixel positioning. This is not really useful as we don't use sub-pixel positions on the Y axis.
+    bool            PixelSnapH;             // false    // Align every glyph to pixel boundary. Useful e.g. if you are merging a non-pixel aligned font with the default font. If enabled, you can set OversampleH/V to 1.
+    ImVec2          GlyphExtraSpacing;      // 0, 0     // Extra spacing (in pixels) between glyphs. Only X axis is supported for now.
+    ImVec2          GlyphOffset;            // 0, 0     // Offset all glyphs from this font input.
+    const ImWchar*  GlyphRanges;            // NULL     // Pointer to a user-provided list of Unicode range (2 value per range, values are inclusive, zero-terminated list). THE ARRAY DATA NEEDS TO PERSIST AS LONG AS THE FONT IS ALIVE.
+    float           GlyphMinAdvanceX;       // 0        // Minimum AdvanceX for glyphs, set Min to align font icons, set both Min/Max to enforce mono-space font
+    float           GlyphMaxAdvanceX;       // FLT_MAX  // Maximum AdvanceX for glyphs
+    bool            MergeMode;              // false    // Merge into previous ImFont, so you can combine multiple inputs font into one ImFont (e.g. ASCII font + icons + Japanese glyphs). You may want to use GlyphOffset.y when merge font of different heights.
+    unsigned int    FontBuilderFlags;       // 0        // Settings for custom font builder. THIS IS BUILDER IMPLEMENTATION DEPENDENT. Leave as zero if unsure.
+    float           RasterizerMultiply;     // 1.0f     // Brighten (>1.0f) or darken (<1.0f) font output. Brightening small fonts may be a good workaround to make them more readable.
+    ImWchar         EllipsisChar;           // -1       // Explicitly specify unicode codepoint of ellipsis character. When fonts are being merged first specified ellipsis will be used.
+
+    // [Internal]
+    char            Name[40];               // Name (strictly to ease debugging)
+    ImFont*         DstFont;
+
+    IMGUI_API ImFontConfig();
+};
+
+// Hold rendering data for one glyph.
+// (Note: some language parsers may fail to convert the 31+1 bitfield members, in this case maybe drop store a single u32 or we can rework this)
+struct ImFontGlyph
+{
+    unsigned int    Colored : 1;        // Flag to indicate glyph is colored and should generally ignore tinting (make it usable with no shift on little-endian as this is used in loops)
+    unsigned int    Visible : 1;        // Flag to indicate glyph has no visible pixels (e.g. space). Allow early out when rendering.
+    unsigned int    Codepoint : 30;     // 0x0000..0x10FFFF
+    float           AdvanceX;           // Distance to next character (= data from font + ImFontConfig::GlyphExtraSpacing.x baked in)
+    float           X0, Y0, X1, Y1;     // Glyph corners
+    float           U0, V0, U1, V1;     // Texture coordinates
+};
+
+// Helper to build glyph ranges from text/string data. Feed your application strings/characters to it then call BuildRanges().
+// This is essentially a tightly packed of vector of 64k booleans = 8KB storage.
+struct ImFontGlyphRangesBuilder
+{
+    ImVector<ImU32> UsedChars;            // Store 1-bit per Unicode code point (0=unused, 1=used)
+
+    ImFontGlyphRangesBuilder()              { Clear(); }
+    inline void     Clear()                 { int size_in_bytes = (IM_UNICODE_CODEPOINT_MAX + 1) / 8; UsedChars.resize(size_in_bytes / (int)sizeof(ImU32)); memset(UsedChars.Data, 0, (size_t)size_in_bytes); }
+    inline bool     GetBit(size_t n) const  { int off = (int)(n >> 5); ImU32 mask = 1u << (n & 31); return (UsedChars[off] & mask) != 0; }  // Get bit n in the array
+    inline void     SetBit(size_t n)        { int off = (int)(n >> 5); ImU32 mask = 1u << (n & 31); UsedChars[off] |= mask; }               // Set bit n in the array
+    inline void     AddChar(ImWchar c)      { SetBit(c); }                      // Add character
+    IMGUI_API void  AddText(const char* text, const char* text_end = NULL);     // Add string (each character of the UTF-8 string are added)
+    IMGUI_API void  AddRanges(const ImWchar* ranges);                           // Add ranges, e.g. builder.AddRanges(ImFontAtlas::GetGlyphRangesDefault()) to force add all of ASCII/Latin+Ext
+    IMGUI_API void  BuildRanges(ImVector<ImWchar>* out_ranges);                 // Output new ranges
+};
+
+// See ImFontAtlas::AddCustomRectXXX functions.
+struct ImFontAtlasCustomRect
+{
+    unsigned short  Width, Height;  // Input    // Desired rectangle dimension
+    unsigned short  X, Y;           // Output   // Packed position in Atlas
+    unsigned int    GlyphID;        // Input    // For custom font glyphs only (ID < 0x110000)
+    float           GlyphAdvanceX;  // Input    // For custom font glyphs only: glyph xadvance
+    ImVec2          GlyphOffset;    // Input    // For custom font glyphs only: glyph display offset
+    ImFont*         Font;           // Input    // For custom font glyphs only: target font
+    ImFontAtlasCustomRect()         { Width = Height = 0; X = Y = 0xFFFF; GlyphID = 0; GlyphAdvanceX = 0.0f; GlyphOffset = ImVec2(0, 0); Font = NULL; }
+    bool IsPacked() const           { return X != 0xFFFF; }
+};
+
+// Flags for ImFontAtlas build
+enum ImFontAtlasFlags_
+{
+    ImFontAtlasFlags_None               = 0,
+    ImFontAtlasFlags_NoPowerOfTwoHeight = 1 << 0,   // Don't round the height to next power of two
+    ImFontAtlasFlags_NoMouseCursors     = 1 << 1,   // Don't build software mouse cursors into the atlas (save a little texture memory)
+    ImFontAtlasFlags_NoBakedLines       = 1 << 2    // Don't build thick line textures into the atlas (save a little texture memory). The AntiAliasedLinesUseTex features uses them, otherwise they will be rendered using polygons (more expensive for CPU/GPU).
+};
+
+// Load and rasterize multiple TTF/OTF fonts into a same texture. The font atlas will build a single texture holding:
+//  - One or more fonts.
+//  - Custom graphics data needed to render the shapes needed by Dear ImGui.
+//  - Mouse cursor shapes for software cursor rendering (unless setting 'Flags |= ImFontAtlasFlags_NoMouseCursors' in the font atlas).
+// It is the user-code responsibility to setup/build the atlas, then upload the pixel data into a texture accessible by your graphics api.
+//  - Optionally, call any of the AddFont*** functions. If you don't call any, the default font embedded in the code will be loaded for you.
+//  - Call GetTexDataAsAlpha8() or GetTexDataAsRGBA32() to build and retrieve pixels data.
+//  - Upload the pixels data into a texture within your graphics system (see imgui_impl_xxxx.cpp examples)
+//  - Call SetTexID(my_tex_id); and pass the pointer/identifier to your texture in a format natural to your graphics API.
+//    This value will be passed back to you during rendering to identify the texture. Read FAQ entry about ImTextureID for more details.
+// Common pitfalls:
+// - If you pass a 'glyph_ranges' array to AddFont*** functions, you need to make sure that your array persist up until the
+//   atlas is build (when calling GetTexData*** or Build()). We only copy the pointer, not the data.
+// - Important: By default, AddFontFromMemoryTTF() takes ownership of the data. Even though we are not writing to it, we will free the pointer on destruction.
+//   You can set font_cfg->FontDataOwnedByAtlas=false to keep ownership of your data and it won't be freed,
+// - Even though many functions are suffixed with "TTF", OTF data is supported just as well.
+// - This is an old API and it is currently awkward for those and and various other reasons! We will address them in the future!
+struct ImFontAtlas
+{
+    IMGUI_API ImFontAtlas();
+    IMGUI_API ~ImFontAtlas();
+    IMGUI_API ImFont*           AddFont(const ImFontConfig* font_cfg);
+    IMGUI_API ImFont*           AddFontDefault(const ImFontConfig* font_cfg = NULL);
+    IMGUI_API ImFont*           AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);
+    IMGUI_API ImFont*           AddFontFromMemoryTTF(void* font_data, int font_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL); // Note: Transfer ownership of 'ttf_data' to ImFontAtlas! Will be deleted after destruction of the atlas. Set font_cfg->FontDataOwnedByAtlas=false to keep ownership of your data and it won't be freed.
+    IMGUI_API ImFont*           AddFontFromMemoryCompressedTTF(const void* compressed_font_data, int compressed_font_size, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL); // 'compressed_font_data' still owned by caller. Compress with binary_to_compressed_c.cpp.
+    IMGUI_API ImFont*           AddFontFromMemoryCompressedBase85TTF(const char* compressed_font_data_base85, float size_pixels, const ImFontConfig* font_cfg = NULL, const ImWchar* glyph_ranges = NULL);              // 'compressed_font_data_base85' still owned by caller. Compress with binary_to_compressed_c.cpp with -base85 parameter.
+    IMGUI_API void              ClearInputData();           // Clear input data (all ImFontConfig structures including sizes, TTF data, glyph ranges, etc.) = all the data used to build the texture and fonts.
+    IMGUI_API void              ClearTexData();             // Clear output texture data (CPU side). Saves RAM once the texture has been copied to graphics memory.
+    IMGUI_API void              ClearFonts();               // Clear output font data (glyphs storage, UV coordinates).
+    IMGUI_API void              Clear();                    // Clear all input and output.
+
+    // Build atlas, retrieve pixel data.
+    // User is in charge of copying the pixels into graphics memory (e.g. create a texture with your engine). Then store your texture handle with SetTexID().
+    // The pitch is always = Width * BytesPerPixels (1 or 4)
+    // Building in RGBA32 format is provided for convenience and compatibility, but note that unless you manually manipulate or copy color data into
+    // the texture (e.g. when using the AddCustomRect*** api), then the RGB pixels emitted will always be white (~75% of memory/bandwidth waste.
+    IMGUI_API bool              Build();                    // Build pixels data. This is called automatically for you by the GetTexData*** functions.
+    IMGUI_API void              GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL);  // 1 byte per-pixel
+    IMGUI_API void              GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel = NULL);  // 4 bytes-per-pixel
+    bool                        IsBuilt() const             { return Fonts.Size > 0 && TexReady; } // Bit ambiguous: used to detect when user didn't built texture but effectively we should check TexID != 0 except that would be backend dependent...
+    void                        SetTexID(ImTextureID id)    { TexID = id; }
+
+    //-------------------------------------------
+    // Glyph Ranges
+    //-------------------------------------------
+
+    // Helpers to retrieve list of common Unicode ranges (2 value per range, values are inclusive, zero-terminated list)
+    // NB: Make sure that your string are UTF-8 and NOT in your local code page. In C++11, you can create UTF-8 string literal using the u8"Hello world" syntax. See FAQ for details.
+    // NB: Consider using ImFontGlyphRangesBuilder to build glyph ranges from textual data.
+    IMGUI_API const ImWchar*    GetGlyphRangesDefault();                // Basic Latin, Extended Latin
+    IMGUI_API const ImWchar*    GetGlyphRangesKorean();                 // Default + Korean characters
+    IMGUI_API const ImWchar*    GetGlyphRangesJapanese();               // Default + Hiragana, Katakana, Half-Width, Selection of 2999 Ideographs
+    IMGUI_API const ImWchar*    GetGlyphRangesChineseFull();            // Default + Half-Width + Japanese Hiragana/Katakana + full set of about 21000 CJK Unified Ideographs
+    IMGUI_API const ImWchar*    GetGlyphRangesChineseSimplifiedCommon();// Default + Half-Width + Japanese Hiragana/Katakana + set of 2500 CJK Unified Ideographs for common simplified Chinese
+    IMGUI_API const ImWchar*    GetGlyphRangesCyrillic();               // Default + about 400 Cyrillic characters
+    IMGUI_API const ImWchar*    GetGlyphRangesThai();                   // Default + Thai characters
+    IMGUI_API const ImWchar*    GetGlyphRangesVietnamese();             // Default + Vietnamese characters
+
+    //-------------------------------------------
+    // [BETA] Custom Rectangles/Glyphs API
+    //-------------------------------------------
+
+    // You can request arbitrary rectangles to be packed into the atlas, for your own purposes.
+    // - After calling Build(), you can query the rectangle position and render your pixels.
+    // - If you render colored output, set 'atlas->TexPixelsUseColors = true' as this may help some backends decide of prefered texture format.
+    // - You can also request your rectangles to be mapped as font glyph (given a font + Unicode point),
+    //   so you can render e.g. custom colorful icons and use them as regular glyphs.
+    // - Read docs/FONTS.md for more details about using colorful icons.
+    // - Note: this API may be redesigned later in order to support multi-monitor varying DPI settings.
+    IMGUI_API int               AddCustomRectRegular(int width, int height);
+    IMGUI_API int               AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset = ImVec2(0, 0));
+    ImFontAtlasCustomRect*      GetCustomRectByIndex(int index) { IM_ASSERT(index >= 0); return &CustomRects[index]; }
+
+    // [Internal]
+    IMGUI_API void              CalcCustomRectUV(const ImFontAtlasCustomRect* rect, ImVec2* out_uv_min, ImVec2* out_uv_max) const;
+    IMGUI_API bool              GetMouseCursorTexData(ImGuiMouseCursor cursor, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2]);
+
+    //-------------------------------------------
+    // Members
+    //-------------------------------------------
+
+    ImFontAtlasFlags            Flags;              // Build flags (see ImFontAtlasFlags_)
+    ImTextureID                 TexID;              // User data to refer to the texture once it has been uploaded to user's graphic systems. It is passed back to you during rendering via the ImDrawCmd structure.
+    int                         TexDesiredWidth;    // Texture width desired by user before Build(). Must be a power-of-two. If have many glyphs your graphics API have texture size restrictions you may want to increase texture width to decrease height.
+    int                         TexGlyphPadding;    // Padding between glyphs within texture in pixels. Defaults to 1. If your rendering method doesn't rely on bilinear filtering you may set this to 0.
+    bool                        Locked;             // Marked as Locked by ImGui::NewFrame() so attempt to modify the atlas will assert.
+
+    // [Internal]
+    // NB: Access texture data via GetTexData*() calls! Which will setup a default font for you.
+    bool                        TexReady;           // Set when texture was built matching current font input
+    bool                        TexPixelsUseColors; // Tell whether our texture data is known to use colors (rather than just alpha channel), in order to help backend select a format.
+    unsigned char*              TexPixelsAlpha8;    // 1 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight
+    unsigned int*               TexPixelsRGBA32;    // 4 component per pixel, each component is unsigned 8-bit. Total size = TexWidth * TexHeight * 4
+    int                         TexWidth;           // Texture width calculated during Build().
+    int                         TexHeight;          // Texture height calculated during Build().
+    ImVec2                      TexUvScale;         // = (1.0f/TexWidth, 1.0f/TexHeight)
+    ImVec2                      TexUvWhitePixel;    // Texture coordinates to a white pixel
+    ImVector<ImFont*>           Fonts;              // Hold all the fonts returned by AddFont*. Fonts[0] is the default font upon calling ImGui::NewFrame(), use ImGui::PushFont()/PopFont() to change the current font.
+    ImVector<ImFontAtlasCustomRect> CustomRects;    // Rectangles for packing custom texture data into the atlas.
+    ImVector<ImFontConfig>      ConfigData;         // Configuration data
+    ImVec4                      TexUvLines[IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 1];  // UVs for baked anti-aliased lines
+
+    // [Internal] Font builder
+    const ImFontBuilderIO*      FontBuilderIO;      // Opaque interface to a font builder (default to stb_truetype, can be changed to use FreeType by defining IMGUI_ENABLE_FREETYPE).
+    unsigned int                FontBuilderFlags;   // Shared flags (for all fonts) for custom font builder. THIS IS BUILD IMPLEMENTATION DEPENDENT. Per-font override is also available in ImFontConfig.
+
+    // [Internal] Packing data
+    int                         PackIdMouseCursors; // Custom texture rectangle ID for white pixel and mouse cursors
+    int                         PackIdLines;        // Custom texture rectangle ID for baked anti-aliased lines
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    typedef ImFontAtlasCustomRect    CustomRect;         // OBSOLETED in 1.72+
+    //typedef ImFontGlyphRangesBuilder GlyphRangesBuilder; // OBSOLETED in 1.67+
+#endif
+};
+
+// Font runtime data and rendering
+// ImFontAtlas automatically loads a default embedded font for you when you call GetTexDataAsAlpha8() or GetTexDataAsRGBA32().
+struct ImFont
+{
+    // Members: Hot ~20/24 bytes (for CalcTextSize)
+    ImVector<float>             IndexAdvanceX;      // 12-16 // out //            // Sparse. Glyphs->AdvanceX in a directly indexable way (cache-friendly for CalcTextSize functions which only this this info, and are often bottleneck in large UI).
+    float                       FallbackAdvanceX;   // 4     // out // = FallbackGlyph->AdvanceX
+    float                       FontSize;           // 4     // in  //            // Height of characters/line, set during loading (don't change after loading)
+
+    // Members: Hot ~28/40 bytes (for CalcTextSize + render loop)
+    ImVector<ImWchar>           IndexLookup;        // 12-16 // out //            // Sparse. Index glyphs by Unicode code-point.
+    ImVector<ImFontGlyph>       Glyphs;             // 12-16 // out //            // All glyphs.
+    const ImFontGlyph*          FallbackGlyph;      // 4-8   // out // = FindGlyph(FontFallbackChar)
+
+    // Members: Cold ~32/40 bytes
+    ImFontAtlas*                ContainerAtlas;     // 4-8   // out //            // What we has been loaded into
+    const ImFontConfig*         ConfigData;         // 4-8   // in  //            // Pointer within ContainerAtlas->ConfigData
+    short                       ConfigDataCount;    // 2     // in  // ~ 1        // Number of ImFontConfig involved in creating this font. Bigger than 1 when merging multiple font sources into one ImFont.
+    ImWchar                     FallbackChar;       // 2     // out // = FFFD/'?' // Character used if a glyph isn't found.
+    ImWchar                     EllipsisChar;       // 2     // out // = '...'    // Character used for ellipsis rendering.
+    ImWchar                     DotChar;            // 2     // out // = '.'      // Character used for ellipsis rendering (if a single '...' character isn't found)
+    bool                        DirtyLookupTables;  // 1     // out //
+    float                       Scale;              // 4     // in  // = 1.f      // Base font scale, multiplied by the per-window font scale which you can adjust with SetWindowFontScale()
+    float                       Ascent, Descent;    // 4+4   // out //            // Ascent: distance from top to bottom of e.g. 'A' [0..FontSize]
+    int                         MetricsTotalSurface;// 4     // out //            // Total surface in pixels to get an idea of the font rasterization/texture cost (not exact, we approximate the cost of padding between glyphs)
+    ImU8                        Used4kPagesMap[(IM_UNICODE_CODEPOINT_MAX+1)/4096/8]; // 2 bytes if ImWchar=ImWchar16, 34 bytes if ImWchar==ImWchar32. Store 1-bit for each block of 4K codepoints that has one active glyph. This is mainly used to facilitate iterations across all used codepoints.
+
+    // Methods
+    IMGUI_API ImFont();
+    IMGUI_API ~ImFont();
+    IMGUI_API const ImFontGlyph*FindGlyph(ImWchar c) const;
+    IMGUI_API const ImFontGlyph*FindGlyphNoFallback(ImWchar c) const;
+    float                       GetCharAdvance(ImWchar c) const     { return ((int)c < IndexAdvanceX.Size) ? IndexAdvanceX[(int)c] : FallbackAdvanceX; }
+    bool                        IsLoaded() const                    { return ContainerAtlas != NULL; }
+    const char*                 GetDebugName() const                { return ConfigData ? ConfigData->Name : "<unknown>"; }
+
+    // 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.
+    // 'wrap_width' enable automatic word-wrapping across multiple lines to fit into given width. 0.0f to disable.
+    IMGUI_API ImVec2            CalcTextSizeA(float size, float max_width, float wrap_width, const char* text_begin, const char* text_end = NULL, const char** remaining = NULL) const; // utf8
+    IMGUI_API const char*       CalcWordWrapPositionA(float scale, const char* text, const char* text_end, float wrap_width) const;
+    IMGUI_API void              RenderChar(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, ImWchar c) const;
+    IMGUI_API void              RenderText(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4& clip_rect, const char* text_begin, const char* text_end, float wrap_width = 0.0f, bool cpu_fine_clip = false) const;
+
+    // [Internal] Don't use!
+    IMGUI_API void              BuildLookupTable();
+    IMGUI_API void              ClearOutputData();
+    IMGUI_API void              GrowIndex(int new_size);
+    IMGUI_API void              AddGlyph(const ImFontConfig* src_cfg, ImWchar c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x);
+    IMGUI_API void              AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst = true); // Makes 'dst' character/glyph points to 'src' character/glyph. Currently needs to be called AFTER fonts have been built.
+    IMGUI_API void              SetGlyphVisible(ImWchar c, bool visible);
+    IMGUI_API bool              IsGlyphRangeUnused(unsigned int c_begin, unsigned int c_last);
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Viewports
+//-----------------------------------------------------------------------------
+
+// Flags stored in ImGuiViewport::Flags, giving indications to the platform backends.
+enum ImGuiViewportFlags_
+{
+    ImGuiViewportFlags_None                     = 0,
+    ImGuiViewportFlags_IsPlatformWindow         = 1 << 0,   // Represent a Platform Window
+    ImGuiViewportFlags_IsPlatformMonitor        = 1 << 1,   // Represent a Platform Monitor (unused yet)
+    ImGuiViewportFlags_OwnedByApp               = 1 << 2    // Platform Window: is created/managed by the application (rather than a dear imgui backend)
+};
+
+// - Currently represents the Platform Window created by the application which is hosting our Dear ImGui windows.
+// - In 'docking' branch with multi-viewport enabled, we extend this concept to have multiple active viewports.
+// - In the future we will extend this concept further to also represent Platform Monitor and support a "no main platform window" operation mode.
+// - About Main Area vs Work Area:
+//   - Main Area = entire viewport.
+//   - Work Area = entire viewport minus sections used by main menu bars (for platform windows), or by task bar (for platform monitor).
+//   - Windows are generally trying to stay within the Work Area of their host viewport.
+struct ImGuiViewport
+{
+    ImGuiViewportFlags  Flags;                  // See ImGuiViewportFlags_
+    ImVec2              Pos;                    // Main Area: Position of the viewport (Dear ImGui coordinates are the same as OS desktop/native coordinates)
+    ImVec2              Size;                   // Main Area: Size of the viewport.
+    ImVec2              WorkPos;                // Work Area: Position of the viewport minus task bars, menus bars, status bars (>= Pos)
+    ImVec2              WorkSize;               // Work Area: Size of the viewport minus task bars, menu bars, status bars (<= Size)
+
+    ImGuiViewport()     { memset(this, 0, sizeof(*this)); }
+
+    // Helpers
+    ImVec2              GetCenter() const       { return ImVec2(Pos.x + Size.x * 0.5f, Pos.y + Size.y * 0.5f); }
+    ImVec2              GetWorkCenter() const   { return ImVec2(WorkPos.x + WorkSize.x * 0.5f, WorkPos.y + WorkSize.y * 0.5f); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Obsolete functions and types
+// (Will be removed! Read 'API BREAKING CHANGES' section in imgui.cpp for details)
+// Please keep your copy of dear imgui up to date! Occasionally set '#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS' in imconfig.h to stay ahead.
+//-----------------------------------------------------------------------------
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+namespace ImGui
+{
+    // OBSOLETED in 1.85 (from August 2021)
+    static inline float GetWindowContentRegionWidth() { return GetWindowContentRegionMax().x - GetWindowContentRegionMin().x; }
+    // OBSOLETED in 1.81 (from February 2021)
+    IMGUI_API bool      ListBoxHeader(const char* label, int items_count, int height_in_items = -1); // Helper to calculate size from items_count and height_in_items
+    static inline bool  ListBoxHeader(const char* label, const ImVec2& size = ImVec2(0, 0)) { return BeginListBox(label, size); }
+    static inline void  ListBoxFooter() { EndListBox(); }
+    // OBSOLETED in 1.79 (from August 2020)
+    static inline void  OpenPopupContextItem(const char* str_id = NULL, ImGuiMouseButton mb = 1) { OpenPopupOnItemClick(str_id, mb); } // Bool return value removed. Use IsWindowAppearing() in BeginPopup() instead. Renamed in 1.77, renamed back in 1.79. Sorry!
+    // OBSOLETED in 1.78 (from June 2020)
+    // Old drag/sliders functions that took a 'float power = 1.0' argument instead of flags.
+    // For shared code, you can version check at compile-time with `#if IMGUI_VERSION_NUM >= 17704`.
+    IMGUI_API bool      DragScalar(const char* label, ImGuiDataType data_type, void* p_data, float v_speed, const void* p_min, const void* p_max, const char* format, float power);
+    IMGUI_API bool      DragScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, float v_speed, const void* p_min, const void* p_max, const char* format, float power);
+    static inline bool  DragFloat(const char* label, float* v, float v_speed, float v_min, float v_max, const char* format, float power)    { return DragScalar(label, ImGuiDataType_Float, v, v_speed, &v_min, &v_max, format, power); }
+    static inline bool  DragFloat2(const char* label, float v[2], float v_speed, float v_min, float v_max, const char* format, float power) { return DragScalarN(label, ImGuiDataType_Float, v, 2, v_speed, &v_min, &v_max, format, power); }
+    static inline bool  DragFloat3(const char* label, float v[3], float v_speed, float v_min, float v_max, const char* format, float power) { return DragScalarN(label, ImGuiDataType_Float, v, 3, v_speed, &v_min, &v_max, format, power); }
+    static inline bool  DragFloat4(const char* label, float v[4], float v_speed, float v_min, float v_max, const char* format, float power) { return DragScalarN(label, ImGuiDataType_Float, v, 4, v_speed, &v_min, &v_max, format, power); }
+    IMGUI_API bool      SliderScalar(const char* label, ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max, const char* format, float power);
+    IMGUI_API bool      SliderScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, const void* p_min, const void* p_max, const char* format, float power);
+    static inline bool  SliderFloat(const char* label, float* v, float v_min, float v_max, const char* format, float power)                 { return SliderScalar(label, ImGuiDataType_Float, v, &v_min, &v_max, format, power); }
+    static inline bool  SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* format, float power)              { return SliderScalarN(label, ImGuiDataType_Float, v, 2, &v_min, &v_max, format, power); }
+    static inline bool  SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* format, float power)              { return SliderScalarN(label, ImGuiDataType_Float, v, 3, &v_min, &v_max, format, power); }
+    static inline bool  SliderFloat4(const char* label, float v[4], float v_min, float v_max, const char* format, float power)              { return SliderScalarN(label, ImGuiDataType_Float, v, 4, &v_min, &v_max, format, power); }
+    // OBSOLETED in 1.77 (from June 2020)
+    static inline bool  BeginPopupContextWindow(const char* str_id, ImGuiMouseButton mb, bool over_items) { return BeginPopupContextWindow(str_id, mb | (over_items ? 0 : ImGuiPopupFlags_NoOpenOverItems)); }
+    // OBSOLETED in 1.72 (from April 2019)
+    static inline void  TreeAdvanceToLabelPos()             { SetCursorPosX(GetCursorPosX() + GetTreeNodeToLabelSpacing()); }
+    // OBSOLETED in 1.71 (from June 2019)
+    static inline void  SetNextTreeNodeOpen(bool open, ImGuiCond cond = 0) { SetNextItemOpen(open, cond); }
+    // OBSOLETED in 1.70 (from May 2019)
+    static inline float GetContentRegionAvailWidth()        { return GetContentRegionAvail().x; }
+
+    // Some of the older obsolete names along with their replacement (commented out so they are not reported in IDE)
+    //static inline ImDrawList* GetOverlayDrawList()            { return GetForegroundDrawList(); }                         // OBSOLETED in 1.69 (from Mar 2019)
+    //static inline void  SetScrollHere(float ratio = 0.5f)     { SetScrollHereY(ratio); }                                  // OBSOLETED in 1.66 (from Nov 2018)
+    //static inline bool  IsItemDeactivatedAfterChange()        { return IsItemDeactivatedAfterEdit(); }                    // OBSOLETED in 1.63 (from Aug 2018)
+    //static inline bool  IsAnyWindowFocused()                  { return IsWindowFocused(ImGuiFocusedFlags_AnyWindow); }    // OBSOLETED in 1.60 (from Apr 2018)
+    //static inline bool  IsAnyWindowHovered()                  { return IsWindowHovered(ImGuiHoveredFlags_AnyWindow); }    // OBSOLETED in 1.60 (between Dec 2017 and Apr 2018)
+    //static inline void  ShowTestWindow()                      { return ShowDemoWindow(); }                                // OBSOLETED in 1.53 (between Oct 2017 and Dec 2017)
+    //static inline bool  IsRootWindowFocused()                 { return IsWindowFocused(ImGuiFocusedFlags_RootWindow); }   // OBSOLETED in 1.53 (between Oct 2017 and Dec 2017)
+    //static inline bool  IsRootWindowOrAnyChildFocused()       { return IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows); } // OBSOLETED in 1.53 (between Oct 2017 and Dec 2017)
+    //static inline void  SetNextWindowContentWidth(float w)    { SetNextWindowContentSize(ImVec2(w, 0.0f)); }              // OBSOLETED in 1.53 (between Oct 2017 and Dec 2017)
+    //static inline float GetItemsLineHeightWithSpacing()       { return GetFrameHeightWithSpacing(); }                     // OBSOLETED in 1.53 (between Oct 2017 and Dec 2017)
+}
+
+// OBSOLETED in 1.82 (from Mars 2021): flags for AddRect(), AddRectFilled(), AddImageRounded(), PathRect()
+typedef ImDrawFlags ImDrawCornerFlags;
+enum ImDrawCornerFlags_
+{
+    ImDrawCornerFlags_None      = ImDrawFlags_RoundCornersNone,         // Was == 0 prior to 1.82, this is now == ImDrawFlags_RoundCornersNone which is != 0 and not implicit
+    ImDrawCornerFlags_TopLeft   = ImDrawFlags_RoundCornersTopLeft,      // Was == 0x01 (1 << 0) prior to 1.82. Order matches ImDrawFlags_NoRoundCorner* flag (we exploit this internally).
+    ImDrawCornerFlags_TopRight  = ImDrawFlags_RoundCornersTopRight,     // Was == 0x02 (1 << 1) prior to 1.82.
+    ImDrawCornerFlags_BotLeft   = ImDrawFlags_RoundCornersBottomLeft,   // Was == 0x04 (1 << 2) prior to 1.82.
+    ImDrawCornerFlags_BotRight  = ImDrawFlags_RoundCornersBottomRight,  // Was == 0x08 (1 << 3) prior to 1.82.
+    ImDrawCornerFlags_All       = ImDrawFlags_RoundCornersAll,          // Was == 0x0F prior to 1.82
+    ImDrawCornerFlags_Top       = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight,
+    ImDrawCornerFlags_Bot       = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight,
+    ImDrawCornerFlags_Left      = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft,
+    ImDrawCornerFlags_Right     = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight
+};
+
+#endif // #ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//-----------------------------------------------------------------------------
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (pop)
+#endif
+
+// Include imgui_user.h at the end of imgui.h (convenient for user to only explicitly include vanilla imgui.h)
+#ifdef IMGUI_INCLUDE_IMGUI_USER_H
+#include "imgui_user.h"
+#endif
+
+#endif // #ifndef IMGUI_DISABLE
+ rlImGui/imgui/imgui_internal.h view
@@ -0,0 +1,2810 @@+// dear imgui, v1.85 WIP
+// (internal structures/api)
+
+// You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
+// Set:
+//   #define IMGUI_DEFINE_MATH_OPERATORS
+// To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
+
+/*
+
+Index of this file:
+
+// [SECTION] Header mess
+// [SECTION] Forward declarations
+// [SECTION] Context pointer
+// [SECTION] STB libraries includes
+// [SECTION] Macros
+// [SECTION] Generic helpers
+// [SECTION] ImDrawList support
+// [SECTION] Widgets support: flags, enums, data structures
+// [SECTION] Navigation support
+// [SECTION] Columns support
+// [SECTION] Multi-select support
+// [SECTION] Docking support
+// [SECTION] Viewport support
+// [SECTION] Settings support
+// [SECTION] Metrics, Debug tools
+// [SECTION] Generic context hooks
+// [SECTION] ImGuiContext (main imgui context)
+// [SECTION] ImGuiWindowTempData, ImGuiWindow
+// [SECTION] Tab bar, Tab item support
+// [SECTION] Table support
+// [SECTION] ImGui internal API
+// [SECTION] ImFontAtlas internal API
+// [SECTION] Test Engine specific hooks (imgui_test_engine)
+
+*/
+
+#pragma once
+#ifndef IMGUI_DISABLE
+
+//-----------------------------------------------------------------------------
+// [SECTION] Header mess
+//-----------------------------------------------------------------------------
+
+#ifndef IMGUI_VERSION
+#include "imgui.h"
+#endif
+
+#include <stdio.h>      // FILE*, sscanf
+#include <stdlib.h>     // NULL, malloc, free, qsort, atoi, atof
+#include <math.h>       // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
+#include <limits.h>     // INT_MIN, INT_MAX
+
+// Enable SSE intrinsics if available
+#if (defined __SSE__ || defined __x86_64__ || defined _M_X64) && !defined(IMGUI_DISABLE_SSE)
+#define IMGUI_ENABLE_SSE
+#include <immintrin.h>
+#endif
+
+// Visual Studio warnings
+#ifdef _MSC_VER
+#pragma warning (push)
+#pragma warning (disable: 4251)     // class 'xxx' needs to have dll-interface to be used by clients of struct 'xxx' // when IMGUI_API is set to__declspec(dllexport)
+#pragma warning (disable: 26812)    // The enum type 'xxx' is unscoped. Prefer 'enum class' over 'enum' (Enum.3). [MSVC Static Analyzer)
+#pragma warning (disable: 26495)    // [Static Analyzer] Variable 'XXX' is uninitialized. Always initialize a member variable (type.6).
+#if defined(_MSC_VER) && _MSC_VER >= 1922 // MSVC 2019 16.2 or later
+#pragma warning (disable: 5054)     // operator '|': deprecated between enumerations of different types
+#endif
+#endif
+
+// Clang/GCC warnings with -Weverything
+#if defined(__clang__)
+#pragma clang diagnostic push
+#if __has_warning("-Wunknown-warning-option")
+#pragma clang diagnostic ignored "-Wunknown-warning-option"         // warning: unknown warning group 'xxx'
+#endif
+#pragma clang diagnostic ignored "-Wunknown-pragmas"                // warning: unknown warning group 'xxx'
+#pragma clang diagnostic ignored "-Wfloat-equal"                    // warning: comparing floating point with == or != is unsafe // storing and comparing against same constants ok, for ImFloorSigned()
+#pragma clang diagnostic ignored "-Wunused-function"                // for stb_textedit.h
+#pragma clang diagnostic ignored "-Wmissing-prototypes"             // for stb_textedit.h
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#pragma clang diagnostic ignored "-Wdouble-promotion"
+#pragma clang diagnostic ignored "-Wimplicit-int-float-conversion"  // warning: implicit conversion from 'xxx' to 'float' may lose precision
+#pragma clang diagnostic ignored "-Wmissing-noreturn"               // warning: function 'xxx' could be declared with attribute 'noreturn'
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas"              // warning: unknown option after '#pragma GCC diagnostic' kind
+#pragma GCC diagnostic ignored "-Wclass-memaccess"      // [__GNUC__ >= 8] warning: 'memset/memcpy' clearing/writing an object of type 'xxxx' with no trivial copy-assignment; use assignment or value-initialization instead
+#endif
+
+// Legacy defines
+#ifdef IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS            // Renamed in 1.74
+#error Use IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS
+#endif
+#ifdef IMGUI_DISABLE_MATH_FUNCTIONS                     // Renamed in 1.74
+#error Use IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
+#endif
+
+// Enable stb_truetype by default unless FreeType is enabled.
+// You can compile with both by defining both IMGUI_ENABLE_FREETYPE and IMGUI_ENABLE_STB_TRUETYPE together.
+#ifndef IMGUI_ENABLE_FREETYPE
+#define IMGUI_ENABLE_STB_TRUETYPE
+#endif
+
+//-----------------------------------------------------------------------------
+// [SECTION] Forward declarations
+//-----------------------------------------------------------------------------
+
+struct ImBitVector;                 // Store 1-bit per value
+struct ImRect;                      // An axis-aligned rectangle (2 points)
+struct ImDrawDataBuilder;           // Helper to build a ImDrawData instance
+struct ImDrawListSharedData;        // Data shared between all ImDrawList instances
+struct ImGuiColorMod;               // Stacked color modifier, backup of modified data so we can restore it
+struct ImGuiContext;                // Main Dear ImGui context
+struct ImGuiContextHook;            // Hook for extensions like ImGuiTestEngine
+struct ImGuiDataTypeInfo;           // Type information associated to a ImGuiDataType enum
+struct ImGuiGroupData;              // Stacked storage data for BeginGroup()/EndGroup()
+struct ImGuiInputTextState;         // Internal state of the currently focused/edited text input box
+struct ImGuiLastItemData;           // Status storage for last submitted items
+struct ImGuiMenuColumns;            // Simple column measurement, currently used for MenuItem() only
+struct ImGuiNavItemData;            // Result of a gamepad/keyboard directional navigation move query result
+struct ImGuiMetricsConfig;          // Storage for ShowMetricsWindow() and DebugNodeXXX() functions
+struct ImGuiNextWindowData;         // Storage for SetNextWindow** functions
+struct ImGuiNextItemData;           // Storage for SetNextItem** functions
+struct ImGuiOldColumnData;          // Storage data for a single column for legacy Columns() api
+struct ImGuiOldColumns;             // Storage data for a columns set for legacy Columns() api
+struct ImGuiPopupData;              // Storage for current popup stack
+struct ImGuiSettingsHandler;        // Storage for one type registered in the .ini file
+struct ImGuiStackSizes;             // Storage of stack sizes for debugging/asserting
+struct ImGuiStyleMod;               // Stacked style modifier, backup of modified data so we can restore it
+struct ImGuiTabBar;                 // Storage for a tab bar
+struct ImGuiTabItem;                // Storage for a tab item (within a tab bar)
+struct ImGuiTable;                  // Storage for a table
+struct ImGuiTableColumn;            // Storage for one column of a table
+struct ImGuiTableTempData;          // Temporary storage for one table (one per table in the stack), shared between tables.
+struct ImGuiTableSettings;          // Storage for a table .ini settings
+struct ImGuiTableColumnsSettings;   // Storage for a column .ini settings
+struct ImGuiWindow;                 // Storage for one window
+struct ImGuiWindowTempData;         // Temporary storage for one window (that's the data which in theory we could ditch at the end of the frame, in practice we currently keep it for each window)
+struct ImGuiWindowSettings;         // Storage for a window .ini settings (we keep one of those even if the actual window wasn't instanced during this session)
+
+// Use your programming IDE "Go to definition" facility on the names of the center columns to find the actual flags/enum lists.
+typedef int ImGuiLayoutType;            // -> enum ImGuiLayoutType_         // Enum: Horizontal or vertical
+typedef int ImGuiActivateFlags;         // -> enum ImGuiActivateFlags_      // Flags: for navigation/focus function (will be for ActivateItem() later)
+typedef int ImGuiItemFlags;             // -> enum ImGuiItemFlags_          // Flags: for PushItemFlag()
+typedef int ImGuiItemStatusFlags;       // -> enum ImGuiItemStatusFlags_    // Flags: for DC.LastItemStatusFlags
+typedef int ImGuiOldColumnFlags;        // -> enum ImGuiOldColumnFlags_     // Flags: for BeginColumns()
+typedef int ImGuiNavHighlightFlags;     // -> enum ImGuiNavHighlightFlags_  // Flags: for RenderNavHighlight()
+typedef int ImGuiNavDirSourceFlags;     // -> enum ImGuiNavDirSourceFlags_  // Flags: for GetNavInputAmount2d()
+typedef int ImGuiNavMoveFlags;          // -> enum ImGuiNavMoveFlags_       // Flags: for navigation requests
+typedef int ImGuiNextItemDataFlags;     // -> enum ImGuiNextItemDataFlags_  // Flags: for SetNextItemXXX() functions
+typedef int ImGuiNextWindowDataFlags;   // -> enum ImGuiNextWindowDataFlags_// Flags: for SetNextWindowXXX() functions
+typedef int ImGuiScrollFlags;           // -> enum ImGuiScrollFlags_        // Flags: for ScrollToItem() and navigation requests
+typedef int ImGuiSeparatorFlags;        // -> enum ImGuiSeparatorFlags_     // Flags: for SeparatorEx()
+typedef int ImGuiTextFlags;             // -> enum ImGuiTextFlags_          // Flags: for TextEx()
+typedef int ImGuiTooltipFlags;          // -> enum ImGuiTooltipFlags_       // Flags: for BeginTooltipEx()
+
+typedef void (*ImGuiErrorLogCallback)(void* user_data, const char* fmt, ...);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Context pointer
+// See implementation of this variable in imgui.cpp for comments and details.
+//-----------------------------------------------------------------------------
+
+#ifndef GImGui
+extern IMGUI_API ImGuiContext* GImGui;  // Current implicit context pointer
+#endif
+
+//-------------------------------------------------------------------------
+// [SECTION] STB libraries includes
+//-------------------------------------------------------------------------
+
+namespace ImStb
+{
+
+#undef STB_TEXTEDIT_STRING
+#undef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_STRING             ImGuiInputTextState
+#define STB_TEXTEDIT_CHARTYPE           ImWchar
+#define STB_TEXTEDIT_GETWIDTH_NEWLINE   (-1.0f)
+#define STB_TEXTEDIT_UNDOSTATECOUNT     99
+#define STB_TEXTEDIT_UNDOCHARCOUNT      999
+#include "imstb_textedit.h"
+
+} // namespace ImStb
+
+//-----------------------------------------------------------------------------
+// [SECTION] Macros
+//-----------------------------------------------------------------------------
+
+// Debug Logging
+#ifndef IMGUI_DEBUG_LOG
+#define IMGUI_DEBUG_LOG(_FMT,...)       printf("[%05d] " _FMT, GImGui->FrameCount, __VA_ARGS__)
+#endif
+
+// Debug Logging for selected systems. Remove the '((void)0) //' to enable.
+//#define IMGUI_DEBUG_LOG_POPUP         IMGUI_DEBUG_LOG // Enable log
+//#define IMGUI_DEBUG_LOG_NAV           IMGUI_DEBUG_LOG // Enable log
+#define IMGUI_DEBUG_LOG_POPUP(...)      ((void)0)       // Disable log
+#define IMGUI_DEBUG_LOG_NAV(...)        ((void)0)       // Disable log
+
+// Static Asserts
+#if (__cplusplus >= 201100) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201100)
+#define IM_STATIC_ASSERT(_COND)         static_assert(_COND, "")
+#else
+#define IM_STATIC_ASSERT(_COND)         typedef char static_assertion_##__line__[(_COND)?1:-1]
+#endif
+
+// "Paranoid" Debug Asserts are meant to only be enabled during specific debugging/work, otherwise would slow down the code too much.
+// We currently don't have many of those so the effect is currently negligible, but onward intent to add more aggressive ones in the code.
+//#define IMGUI_DEBUG_PARANOID
+#ifdef IMGUI_DEBUG_PARANOID
+#define IM_ASSERT_PARANOID(_EXPR)       IM_ASSERT(_EXPR)
+#else
+#define IM_ASSERT_PARANOID(_EXPR)
+#endif
+
+// Error handling
+// Down the line in some frameworks/languages we would like to have a way to redirect those to the programmer and recover from more faults.
+#ifndef IM_ASSERT_USER_ERROR
+#define IM_ASSERT_USER_ERROR(_EXP,_MSG) IM_ASSERT((_EXP) && _MSG)   // Recoverable User Error
+#endif
+
+// Misc Macros
+#define IM_PI                           3.14159265358979323846f
+#ifdef _WIN32
+#define IM_NEWLINE                      "\r\n"   // Play it nice with Windows users (Update: since 2018-05, Notepad finally appears to support Unix-style carriage returns!)
+#else
+#define IM_NEWLINE                      "\n"
+#endif
+#define IM_TABSIZE                      (4)
+#define IM_MEMALIGN(_OFF,_ALIGN)        (((_OFF) + (_ALIGN - 1)) & ~(_ALIGN - 1))               // Memory align e.g. IM_ALIGN(0,4)=0, IM_ALIGN(1,4)=4, IM_ALIGN(4,4)=4, IM_ALIGN(5,4)=8
+#define IM_F32_TO_INT8_UNBOUND(_VAL)    ((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f)))   // Unsaturated, for display purpose
+#define IM_F32_TO_INT8_SAT(_VAL)        ((int)(ImSaturate(_VAL) * 255.0f + 0.5f))               // Saturated, always output 0..255
+#define IM_FLOOR(_VAL)                  ((float)(int)(_VAL))                                    // ImFloor() is not inlined in MSVC debug builds
+#define IM_ROUND(_VAL)                  ((float)(int)((_VAL) + 0.5f))                           //
+
+// Enforce cdecl calling convention for functions called by the standard library, in case compilation settings changed the default to e.g. __vectorcall
+#ifdef _MSC_VER
+#define IMGUI_CDECL __cdecl
+#else
+#define IMGUI_CDECL
+#endif
+
+// Warnings
+#if defined(_MSC_VER) && !defined(__clang__)
+#define IM_MSVC_WARNING_SUPPRESS(XXXX)  __pragma(warning(suppress: XXXX))
+#else
+#define IM_MSVC_WARNING_SUPPRESS(XXXX)
+#endif
+
+// Debug Tools
+// Use 'Metrics->Tools->Item Picker' to break into the call-stack of a specific item.
+#ifndef IM_DEBUG_BREAK
+#if defined(__clang__)
+#define IM_DEBUG_BREAK()    __builtin_debugtrap()
+#elif defined (_MSC_VER)
+#define IM_DEBUG_BREAK()    __debugbreak()
+#else
+#define IM_DEBUG_BREAK()    IM_ASSERT(0)    // It is expected that you define IM_DEBUG_BREAK() into something that will break nicely in a debugger!
+#endif
+#endif // #ifndef IM_DEBUG_BREAK
+
+//-----------------------------------------------------------------------------
+// [SECTION] Generic helpers
+// Note that the ImXXX helpers functions are lower-level than ImGui functions.
+// ImGui functions or the ImGui context are never called/used from other ImXXX functions.
+//-----------------------------------------------------------------------------
+// - Helpers: Hashing
+// - Helpers: Sorting
+// - Helpers: Bit manipulation
+// - Helpers: String, Formatting
+// - Helpers: UTF-8 <> wchar conversions
+// - Helpers: ImVec2/ImVec4 operators
+// - Helpers: Maths
+// - Helpers: Geometry
+// - Helper: ImVec1
+// - Helper: ImVec2ih
+// - Helper: ImRect
+// - Helper: ImBitArray
+// - Helper: ImBitVector
+// - Helper: ImSpan<>, ImSpanAllocator<>
+// - Helper: ImPool<>
+// - Helper: ImChunkStream<>
+//-----------------------------------------------------------------------------
+
+// Helpers: Hashing
+IMGUI_API ImGuiID       ImHashData(const void* data, size_t data_size, ImU32 seed = 0);
+IMGUI_API ImGuiID       ImHashStr(const char* data, size_t data_size = 0, ImU32 seed = 0);
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+static inline ImGuiID   ImHash(const void* data, int size, ImU32 seed = 0) { return size ? ImHashData(data, (size_t)size, seed) : ImHashStr((const char*)data, 0, seed); } // [moved to ImHashStr/ImHashData in 1.68]
+#endif
+
+// Helpers: Sorting
+#define ImQsort         qsort
+
+// Helpers: Color Blending
+IMGUI_API ImU32         ImAlphaBlendColors(ImU32 col_a, ImU32 col_b);
+
+// Helpers: Bit manipulation
+static inline bool      ImIsPowerOfTwo(int v)           { return v != 0 && (v & (v - 1)) == 0; }
+static inline bool      ImIsPowerOfTwo(ImU64 v)         { return v != 0 && (v & (v - 1)) == 0; }
+static inline int       ImUpperPowerOfTwo(int v)        { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
+
+// Helpers: String, Formatting
+IMGUI_API int           ImStricmp(const char* str1, const char* str2);
+IMGUI_API int           ImStrnicmp(const char* str1, const char* str2, size_t count);
+IMGUI_API void          ImStrncpy(char* dst, const char* src, size_t count);
+IMGUI_API char*         ImStrdup(const char* str);
+IMGUI_API char*         ImStrdupcpy(char* dst, size_t* p_dst_size, const char* str);
+IMGUI_API const char*   ImStrchrRange(const char* str_begin, const char* str_end, char c);
+IMGUI_API int           ImStrlenW(const ImWchar* str);
+IMGUI_API const char*   ImStreolRange(const char* str, const char* str_end);                // End end-of-line
+IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin);   // Find beginning-of-line
+IMGUI_API const char*   ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
+IMGUI_API void          ImStrTrimBlanks(char* str);
+IMGUI_API const char*   ImStrSkipBlank(const char* str);
+IMGUI_API int           ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
+IMGUI_API int           ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
+IMGUI_API const char*   ImParseFormatFindStart(const char* format);
+IMGUI_API const char*   ImParseFormatFindEnd(const char* format);
+IMGUI_API const char*   ImParseFormatTrimDecorations(const char* format, char* buf, size_t buf_size);
+IMGUI_API int           ImParseFormatPrecision(const char* format, int default_value);
+static inline bool      ImCharIsBlankA(char c)          { return c == ' ' || c == '\t'; }
+static inline bool      ImCharIsBlankW(unsigned int c)  { return c == ' ' || c == '\t' || c == 0x3000; }
+
+// Helpers: UTF-8 <> wchar conversions
+IMGUI_API const char*   ImTextCharToUtf8(char out_buf[5], unsigned int c);                                                      // return out_buf
+IMGUI_API int           ImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end);   // return output UTF-8 bytes count
+IMGUI_API int           ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end);               // read one character. return input UTF-8 bytes count
+IMGUI_API int           ImTextStrFromUtf8(ImWchar* out_buf, int out_buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL);   // return input UTF-8 bytes count
+IMGUI_API int           ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end);                                 // return number of UTF-8 code-points (NOT bytes count)
+IMGUI_API int           ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_text_end);                             // return number of bytes to express one char in UTF-8
+IMGUI_API int           ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end);                        // return number of bytes to express string in UTF-8
+
+// Helpers: ImVec2/ImVec4 operators
+// We are keeping those disabled by default so they don't leak in user space, to allow user enabling implicit cast operators between ImVec2 and their own types (using IM_VEC2_CLASS_EXTRA etc.)
+// We unfortunately don't have a unary- operator for ImVec2 because this would needs to be defined inside the class itself.
+#ifdef IMGUI_DEFINE_MATH_OPERATORS
+IM_MSVC_RUNTIME_CHECKS_OFF
+static inline ImVec2 operator*(const ImVec2& lhs, const float rhs)              { return ImVec2(lhs.x * rhs, lhs.y * rhs); }
+static inline ImVec2 operator/(const ImVec2& lhs, const float rhs)              { return ImVec2(lhs.x / rhs, lhs.y / rhs); }
+static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x + rhs.x, lhs.y + rhs.y); }
+static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x - rhs.x, lhs.y - rhs.y); }
+static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
+static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs)            { return ImVec2(lhs.x / rhs.x, lhs.y / rhs.y); }
+static inline ImVec2& operator*=(ImVec2& lhs, const float rhs)                  { lhs.x *= rhs; lhs.y *= rhs; return lhs; }
+static inline ImVec2& operator/=(ImVec2& lhs, const float rhs)                  { lhs.x /= rhs; lhs.y /= rhs; return lhs; }
+static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x += rhs.x; lhs.y += rhs.y; return lhs; }
+static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }
+static inline ImVec2& operator*=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x *= rhs.x; lhs.y *= rhs.y; return lhs; }
+static inline ImVec2& operator/=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x /= rhs.x; lhs.y /= rhs.y; return lhs; }
+static inline ImVec4 operator+(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); }
+static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); }
+static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); }
+IM_MSVC_RUNTIME_CHECKS_RESTORE
+#endif
+
+// Helpers: File System
+#ifdef IMGUI_DISABLE_FILE_FUNCTIONS
+#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
+typedef void* ImFileHandle;
+static inline ImFileHandle  ImFileOpen(const char*, const char*)                    { return NULL; }
+static inline bool          ImFileClose(ImFileHandle)                               { return false; }
+static inline ImU64         ImFileGetSize(ImFileHandle)                             { return (ImU64)-1; }
+static inline ImU64         ImFileRead(void*, ImU64, ImU64, ImFileHandle)           { return 0; }
+static inline ImU64         ImFileWrite(const void*, ImU64, ImU64, ImFileHandle)    { return 0; }
+#endif
+#ifndef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
+typedef FILE* ImFileHandle;
+IMGUI_API ImFileHandle      ImFileOpen(const char* filename, const char* mode);
+IMGUI_API bool              ImFileClose(ImFileHandle file);
+IMGUI_API ImU64             ImFileGetSize(ImFileHandle file);
+IMGUI_API ImU64             ImFileRead(void* data, ImU64 size, ImU64 count, ImFileHandle file);
+IMGUI_API ImU64             ImFileWrite(const void* data, ImU64 size, ImU64 count, ImFileHandle file);
+#else
+#define IMGUI_DISABLE_TTY_FUNCTIONS // Can't use stdout, fflush if we are not using default file functions
+#endif
+IMGUI_API void*             ImFileLoadToMemory(const char* filename, const char* mode, size_t* out_file_size = NULL, int padding_bytes = 0);
+
+// Helpers: Maths
+IM_MSVC_RUNTIME_CHECKS_OFF
+// - Wrapper for standard libs functions. (Note that imgui_demo.cpp does _not_ use them to keep the code easy to copy)
+#ifndef IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS
+#define ImFabs(X)           fabsf(X)
+#define ImSqrt(X)           sqrtf(X)
+#define ImFmod(X, Y)        fmodf((X), (Y))
+#define ImCos(X)            cosf(X)
+#define ImSin(X)            sinf(X)
+#define ImAcos(X)           acosf(X)
+#define ImAtan2(Y, X)       atan2f((Y), (X))
+#define ImAtof(STR)         atof(STR)
+//#define ImFloorStd(X)     floorf(X)           // We use our own, see ImFloor() and ImFloorSigned()
+#define ImCeil(X)           ceilf(X)
+static inline float  ImPow(float x, float y)    { return powf(x, y); }          // DragBehaviorT/SliderBehaviorT uses ImPow with either float/double and need the precision
+static inline double ImPow(double x, double y)  { return pow(x, y); }
+static inline float  ImLog(float x)             { return logf(x); }             // DragBehaviorT/SliderBehaviorT uses ImLog with either float/double and need the precision
+static inline double ImLog(double x)            { return log(x); }
+static inline int    ImAbs(int x)               { return x < 0 ? -x : x; }
+static inline float  ImAbs(float x)             { return fabsf(x); }
+static inline double ImAbs(double x)            { return fabs(x); }
+static inline float  ImSign(float x)            { return (x < 0.0f) ? -1.0f : ((x > 0.0f) ? 1.0f : 0.0f); } // Sign operator - returns -1, 0 or 1 based on sign of argument
+static inline double ImSign(double x)           { return (x < 0.0) ? -1.0 : ((x > 0.0) ? 1.0 : 0.0); }
+#ifdef IMGUI_ENABLE_SSE
+static inline float  ImRsqrt(float x)           { return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }
+#else
+static inline float  ImRsqrt(float x)           { return 1.0f / sqrtf(x); }
+#endif
+static inline double ImRsqrt(double x)          { return 1.0 / sqrt(x); }
+#endif
+// - ImMin/ImMax/ImClamp/ImLerp/ImSwap are used by widgets which support variety of types: signed/unsigned int/long long float/double
+// (Exceptionally using templates here but we could also redefine them for those types)
+template<typename T> static inline T ImMin(T lhs, T rhs)                        { return lhs < rhs ? lhs : rhs; }
+template<typename T> static inline T ImMax(T lhs, T rhs)                        { return lhs >= rhs ? lhs : rhs; }
+template<typename T> static inline T ImClamp(T v, T mn, T mx)                   { return (v < mn) ? mn : (v > mx) ? mx : v; }
+template<typename T> static inline T ImLerp(T a, T b, float t)                  { return (T)(a + (b - a) * t); }
+template<typename T> static inline void ImSwap(T& a, T& b)                      { T tmp = a; a = b; b = tmp; }
+template<typename T> static inline T ImAddClampOverflow(T a, T b, T mn, T mx)   { if (b < 0 && (a < mn - b)) return mn; if (b > 0 && (a > mx - b)) return mx; return a + b; }
+template<typename T> static inline T ImSubClampOverflow(T a, T b, T mn, T mx)   { if (b > 0 && (a < mn + b)) return mn; if (b < 0 && (a > mx + b)) return mx; return a - b; }
+// - Misc maths helpers
+static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
+static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
+static inline ImVec2 ImClamp(const ImVec2& v, const ImVec2& mn, ImVec2 mx)      { return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }
+static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t)          { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
+static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t)  { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
+static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t)          { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
+static inline float  ImSaturate(float f)                                        { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
+static inline float  ImLengthSqr(const ImVec2& lhs)                             { return (lhs.x * lhs.x) + (lhs.y * lhs.y); }
+static inline float  ImLengthSqr(const ImVec4& lhs)                             { return (lhs.x * lhs.x) + (lhs.y * lhs.y) + (lhs.z * lhs.z) + (lhs.w * lhs.w); }
+static inline float  ImInvLength(const ImVec2& lhs, float fail_value)           { float d = (lhs.x * lhs.x) + (lhs.y * lhs.y); if (d > 0.0f) return ImRsqrt(d); return fail_value; }
+static inline float  ImFloor(float f)                                           { return (float)(int)(f); }
+static inline float  ImFloorSigned(float f)                                     { return (float)((f >= 0 || (int)f == f) ? (int)f : (int)f - 1); } // Decent replacement for floorf()
+static inline ImVec2 ImFloor(const ImVec2& v)                                   { return ImVec2((float)(int)(v.x), (float)(int)(v.y)); }
+static inline int    ImModPositive(int a, int b)                                { return (a + b) % b; }
+static inline float  ImDot(const ImVec2& a, const ImVec2& b)                    { return a.x * b.x + a.y * b.y; }
+static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a)        { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
+static inline float  ImLinearSweep(float current, float target, float speed)    { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }
+static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
+IM_MSVC_RUNTIME_CHECKS_RESTORE
+
+// Helpers: Geometry
+IMGUI_API ImVec2     ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t);
+IMGUI_API ImVec2     ImBezierCubicClosestPoint(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& p, int num_segments);       // For curves with explicit number of segments
+IMGUI_API ImVec2     ImBezierCubicClosestPointCasteljau(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& p, float tess_tol);// For auto-tessellated curves you can use tess_tol = style.CurveTessellationTol
+IMGUI_API ImVec2     ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t);
+IMGUI_API ImVec2     ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
+IMGUI_API bool       ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
+IMGUI_API ImVec2     ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
+IMGUI_API void       ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
+inline float         ImTriangleArea(const ImVec2& a, const ImVec2& b, const ImVec2& c) { return ImFabs((a.x * (b.y - c.y)) + (b.x * (c.y - a.y)) + (c.x * (a.y - b.y))) * 0.5f; }
+IMGUI_API ImGuiDir   ImGetDirQuadrantFromDelta(float dx, float dy);
+
+// Helper: ImVec1 (1D vector)
+// (this odd construct is used to facilitate the transition between 1D and 2D, and the maintenance of some branches/patches)
+IM_MSVC_RUNTIME_CHECKS_OFF
+struct ImVec1
+{
+    float   x;
+    ImVec1()         { x = 0.0f; }
+    ImVec1(float _x) { x = _x; }
+};
+
+// Helper: ImVec2ih (2D vector, half-size integer, for long-term packed storage)
+struct ImVec2ih
+{
+    short   x, y;
+    ImVec2ih()                           { x = y = 0; }
+    ImVec2ih(short _x, short _y)         { x = _x; y = _y; }
+    explicit ImVec2ih(const ImVec2& rhs) { x = (short)rhs.x; y = (short)rhs.y; }
+};
+
+// Helper: ImRect (2D axis aligned bounding-box)
+// NB: we can't rely on ImVec2 math operators being available here!
+struct IMGUI_API ImRect
+{
+    ImVec2      Min;    // Upper-left
+    ImVec2      Max;    // Lower-right
+
+    ImRect()                                        : Min(0.0f, 0.0f), Max(0.0f, 0.0f)  {}
+    ImRect(const ImVec2& min, const ImVec2& max)    : Min(min), Max(max)                {}
+    ImRect(const ImVec4& v)                         : Min(v.x, v.y), Max(v.z, v.w)      {}
+    ImRect(float x1, float y1, float x2, float y2)  : Min(x1, y1), Max(x2, y2)          {}
+
+    ImVec2      GetCenter() const                   { return ImVec2((Min.x + Max.x) * 0.5f, (Min.y + Max.y) * 0.5f); }
+    ImVec2      GetSize() const                     { return ImVec2(Max.x - Min.x, Max.y - Min.y); }
+    float       GetWidth() const                    { return Max.x - Min.x; }
+    float       GetHeight() const                   { return Max.y - Min.y; }
+    float       GetArea() const                     { return (Max.x - Min.x) * (Max.y - Min.y); }
+    ImVec2      GetTL() const                       { return Min; }                   // Top-left
+    ImVec2      GetTR() const                       { return ImVec2(Max.x, Min.y); }  // Top-right
+    ImVec2      GetBL() const                       { return ImVec2(Min.x, Max.y); }  // Bottom-left
+    ImVec2      GetBR() const                       { return Max; }                   // Bottom-right
+    bool        Contains(const ImVec2& p) const     { return p.x     >= Min.x && p.y     >= Min.y && p.x     <  Max.x && p.y     <  Max.y; }
+    bool        Contains(const ImRect& r) const     { return r.Min.x >= Min.x && r.Min.y >= Min.y && r.Max.x <= Max.x && r.Max.y <= Max.y; }
+    bool        Overlaps(const ImRect& r) const     { return r.Min.y <  Max.y && r.Max.y >  Min.y && r.Min.x <  Max.x && r.Max.x >  Min.x; }
+    void        Add(const ImVec2& p)                { if (Min.x > p.x)     Min.x = p.x;     if (Min.y > p.y)     Min.y = p.y;     if (Max.x < p.x)     Max.x = p.x;     if (Max.y < p.y)     Max.y = p.y; }
+    void        Add(const ImRect& r)                { if (Min.x > r.Min.x) Min.x = r.Min.x; if (Min.y > r.Min.y) Min.y = r.Min.y; if (Max.x < r.Max.x) Max.x = r.Max.x; if (Max.y < r.Max.y) Max.y = r.Max.y; }
+    void        Expand(const float amount)          { Min.x -= amount;   Min.y -= amount;   Max.x += amount;   Max.y += amount; }
+    void        Expand(const ImVec2& amount)        { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
+    void        Translate(const ImVec2& d)          { Min.x += d.x; Min.y += d.y; Max.x += d.x; Max.y += d.y; }
+    void        TranslateX(float dx)                { Min.x += dx; Max.x += dx; }
+    void        TranslateY(float dy)                { Min.y += dy; Max.y += dy; }
+    void        ClipWith(const ImRect& r)           { Min = ImMax(Min, r.Min); Max = ImMin(Max, r.Max); }                   // Simple version, may lead to an inverted rectangle, which is fine for Contains/Overlaps test but not for display.
+    void        ClipWithFull(const ImRect& r)       { Min = ImClamp(Min, r.Min, r.Max); Max = ImClamp(Max, r.Min, r.Max); } // Full version, ensure both points are fully clipped.
+    void        Floor()                             { Min.x = IM_FLOOR(Min.x); Min.y = IM_FLOOR(Min.y); Max.x = IM_FLOOR(Max.x); Max.y = IM_FLOOR(Max.y); }
+    bool        IsInverted() const                  { return Min.x > Max.x || Min.y > Max.y; }
+    ImVec4      ToVec4() const                      { return ImVec4(Min.x, Min.y, Max.x, Max.y); }
+};
+IM_MSVC_RUNTIME_CHECKS_RESTORE
+
+// Helper: ImBitArray
+inline bool     ImBitArrayTestBit(const ImU32* arr, int n)      { ImU32 mask = (ImU32)1 << (n & 31); return (arr[n >> 5] & mask) != 0; }
+inline void     ImBitArrayClearBit(ImU32* arr, int n)           { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] &= ~mask; }
+inline void     ImBitArraySetBit(ImU32* arr, int n)             { ImU32 mask = (ImU32)1 << (n & 31); arr[n >> 5] |= mask; }
+inline void     ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)
+{
+    n2--;
+    while (n <= n2)
+    {
+        int a_mod = (n & 31);
+        int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
+        ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
+        arr[n >> 5] |= mask;
+        n = (n + 32) & ~31;
+    }
+}
+
+// Helper: ImBitArray class (wrapper over ImBitArray functions)
+// Store 1-bit per value.
+template<int BITCOUNT>
+struct IMGUI_API ImBitArray
+{
+    ImU32           Storage[(BITCOUNT + 31) >> 5];
+    ImBitArray()                                { ClearAllBits(); }
+    void            ClearAllBits()              { memset(Storage, 0, sizeof(Storage)); }
+    void            SetAllBits()                { memset(Storage, 255, sizeof(Storage)); }
+    bool            TestBit(int n) const        { IM_ASSERT(n < BITCOUNT); return ImBitArrayTestBit(Storage, n); }
+    void            SetBit(int n)               { IM_ASSERT(n < BITCOUNT); ImBitArraySetBit(Storage, n); }
+    void            ClearBit(int n)             { IM_ASSERT(n < BITCOUNT); ImBitArrayClearBit(Storage, n); }
+    void            SetBitRange(int n, int n2)  { ImBitArraySetBitRange(Storage, n, n2); } // Works on range [n..n2)
+};
+
+// Helper: ImBitVector
+// Store 1-bit per value.
+struct IMGUI_API ImBitVector
+{
+    ImVector<ImU32> Storage;
+    void            Create(int sz)              { Storage.resize((sz + 31) >> 5); memset(Storage.Data, 0, (size_t)Storage.Size * sizeof(Storage.Data[0])); }
+    void            Clear()                     { Storage.clear(); }
+    bool            TestBit(int n) const        { IM_ASSERT(n < (Storage.Size << 5)); return ImBitArrayTestBit(Storage.Data, n); }
+    void            SetBit(int n)               { IM_ASSERT(n < (Storage.Size << 5)); ImBitArraySetBit(Storage.Data, n); }
+    void            ClearBit(int n)             { IM_ASSERT(n < (Storage.Size << 5)); ImBitArrayClearBit(Storage.Data, n); }
+};
+
+// Helper: ImSpan<>
+// Pointing to a span of data we don't own.
+template<typename T>
+struct ImSpan
+{
+    T*                  Data;
+    T*                  DataEnd;
+
+    // Constructors, destructor
+    inline ImSpan()                                 { Data = DataEnd = NULL; }
+    inline ImSpan(T* data, int size)                { Data = data; DataEnd = data + size; }
+    inline ImSpan(T* data, T* data_end)             { Data = data; DataEnd = data_end; }
+
+    inline void         set(T* data, int size)      { Data = data; DataEnd = data + size; }
+    inline void         set(T* data, T* data_end)   { Data = data; DataEnd = data_end; }
+    inline int          size() const                { return (int)(ptrdiff_t)(DataEnd - Data); }
+    inline int          size_in_bytes() const       { return (int)(ptrdiff_t)(DataEnd - Data) * (int)sizeof(T); }
+    inline T&           operator[](int i)           { T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }
+    inline const T&     operator[](int i) const     { const T* p = Data + i; IM_ASSERT(p >= Data && p < DataEnd); return *p; }
+
+    inline T*           begin()                     { return Data; }
+    inline const T*     begin() const               { return Data; }
+    inline T*           end()                       { return DataEnd; }
+    inline const T*     end() const                 { return DataEnd; }
+
+    // Utilities
+    inline int  index_from_ptr(const T* it) const   { IM_ASSERT(it >= Data && it < DataEnd); const ptrdiff_t off = it - Data; return (int)off; }
+};
+
+// Helper: ImSpanAllocator<>
+// Facilitate storing multiple chunks into a single large block (the "arena")
+// - Usage: call Reserve() N times, allocate GetArenaSizeInBytes() worth, pass it to SetArenaBasePtr(), call GetSpan() N times to retrieve the aligned ranges.
+template<int CHUNKS>
+struct ImSpanAllocator
+{
+    char*   BasePtr;
+    int     CurrOff;
+    int     CurrIdx;
+    int     Offsets[CHUNKS];
+    int     Sizes[CHUNKS];
+
+    ImSpanAllocator()                               { memset(this, 0, sizeof(*this)); }
+    inline void  Reserve(int n, size_t sz, int a=4) { IM_ASSERT(n == CurrIdx && n < CHUNKS); CurrOff = IM_MEMALIGN(CurrOff, a); Offsets[n] = CurrOff; Sizes[n] = (int)sz; CurrIdx++; CurrOff += (int)sz; }
+    inline int   GetArenaSizeInBytes()              { return CurrOff; }
+    inline void  SetArenaBasePtr(void* base_ptr)    { BasePtr = (char*)base_ptr; }
+    inline void* GetSpanPtrBegin(int n)             { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n]); }
+    inline void* GetSpanPtrEnd(int n)               { IM_ASSERT(n >= 0 && n < CHUNKS && CurrIdx == CHUNKS); return (void*)(BasePtr + Offsets[n] + Sizes[n]); }
+    template<typename T>
+    inline void  GetSpan(int n, ImSpan<T>* span)    { span->set((T*)GetSpanPtrBegin(n), (T*)GetSpanPtrEnd(n)); }
+};
+
+// Helper: ImPool<>
+// Basic keyed storage for contiguous instances, slow/amortized insertion, O(1) indexable, O(Log N) queries by ID over a dense/hot buffer,
+// Honor constructor/destructor. Add/remove invalidate all pointers. Indexes have the same lifetime as the associated object.
+typedef int ImPoolIdx;
+template<typename T>
+struct IMGUI_API ImPool
+{
+    ImVector<T>     Buf;        // Contiguous data
+    ImGuiStorage    Map;        // ID->Index
+    ImPoolIdx       FreeIdx;    // Next free idx to use
+    ImPoolIdx       AliveCount; // Number of active/alive items (for display purpose)
+
+    ImPool()    { FreeIdx = AliveCount = 0; }
+    ~ImPool()   { Clear(); }
+    T*          GetByKey(ImGuiID key)               { int idx = Map.GetInt(key, -1); return (idx != -1) ? &Buf[idx] : NULL; }
+    T*          GetByIndex(ImPoolIdx n)             { return &Buf[n]; }
+    ImPoolIdx   GetIndex(const T* p) const          { IM_ASSERT(p >= Buf.Data && p < Buf.Data + Buf.Size); return (ImPoolIdx)(p - Buf.Data); }
+    T*          GetOrAddByKey(ImGuiID key)          { int* p_idx = Map.GetIntRef(key, -1); if (*p_idx != -1) return &Buf[*p_idx]; *p_idx = FreeIdx; return Add(); }
+    bool        Contains(const T* p) const          { return (p >= Buf.Data && p < Buf.Data + Buf.Size); }
+    void        Clear()                             { for (int n = 0; n < Map.Data.Size; n++) { int idx = Map.Data[n].val_i; if (idx != -1) Buf[idx].~T(); } Map.Clear(); Buf.clear(); FreeIdx = AliveCount = 0; }
+    T*          Add()                               { int idx = FreeIdx; if (idx == Buf.Size) { Buf.resize(Buf.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Buf[idx]; } IM_PLACEMENT_NEW(&Buf[idx]) T(); AliveCount++; return &Buf[idx]; }
+    void        Remove(ImGuiID key, const T* p)     { Remove(key, GetIndex(p)); }
+    void        Remove(ImGuiID key, ImPoolIdx idx)  { Buf[idx].~T(); *(int*)&Buf[idx] = FreeIdx; FreeIdx = idx; Map.SetInt(key, -1); AliveCount--; }
+    void        Reserve(int capacity)               { Buf.reserve(capacity); Map.Data.reserve(capacity); }
+
+    // To iterate a ImPool: for (int n = 0; n < pool.GetMapSize(); n++) if (T* t = pool.TryGetMapData(n)) { ... }
+    // Can be avoided if you know .Remove() has never been called on the pool, or AliveCount == GetMapSize()
+    int         GetAliveCount() const               { return AliveCount; }      // Number of active/alive items in the pool (for display purpose)
+    int         GetBufSize() const                  { return Buf.Size; }
+    int         GetMapSize() const                  { return Map.Data.Size; }   // It is the map we need iterate to find valid items, since we don't have "alive" storage anywhere
+    T*          TryGetMapData(ImPoolIdx n)          { int idx = Map.Data[n].val_i; if (idx == -1) return NULL; return GetByIndex(idx); }
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    int         GetSize()                           { return GetMapSize(); } // For ImPlot: should use GetMapSize() from (IMGUI_VERSION_NUM >= 18304)
+#endif
+};
+
+// Helper: ImChunkStream<>
+// Build and iterate a contiguous stream of variable-sized structures.
+// This is used by Settings to store persistent data while reducing allocation count.
+// We store the chunk size first, and align the final size on 4 bytes boundaries.
+// The tedious/zealous amount of casting is to avoid -Wcast-align warnings.
+template<typename T>
+struct IMGUI_API ImChunkStream
+{
+    ImVector<char>  Buf;
+
+    void    clear()                     { Buf.clear(); }
+    bool    empty() const               { return Buf.Size == 0; }
+    int     size() const                { return Buf.Size; }
+    T*      alloc_chunk(size_t sz)      { size_t HDR_SZ = 4; sz = IM_MEMALIGN(HDR_SZ + sz, 4u); int off = Buf.Size; Buf.resize(off + (int)sz); ((int*)(void*)(Buf.Data + off))[0] = (int)sz; return (T*)(void*)(Buf.Data + off + (int)HDR_SZ); }
+    T*      begin()                     { size_t HDR_SZ = 4; if (!Buf.Data) return NULL; return (T*)(void*)(Buf.Data + HDR_SZ); }
+    T*      next_chunk(T* p)            { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; }
+    int     chunk_size(const T* p)      { return ((const int*)p)[-1]; }
+    T*      end()                       { return (T*)(void*)(Buf.Data + Buf.Size); }
+    int     offset_from_ptr(const T* p) { IM_ASSERT(p >= begin() && p < end()); const ptrdiff_t off = (const char*)p - Buf.Data; return (int)off; }
+    T*      ptr_from_offset(int off)    { IM_ASSERT(off >= 4 && off < Buf.Size); return (T*)(void*)(Buf.Data + off); }
+    void    swap(ImChunkStream<T>& rhs) { rhs.Buf.swap(Buf); }
+
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImDrawList support
+//-----------------------------------------------------------------------------
+
+// ImDrawList: Helper function to calculate a circle's segment count given its radius and a "maximum error" value.
+// Estimation of number of circle segment based on error is derived using method described in https://stackoverflow.com/a/2244088/15194693
+// Number of segments (N) is calculated using equation:
+//   N = ceil ( pi / acos(1 - error / r) )     where r > 0, error <= r
+// Our equation is significantly simpler that one in the post thanks for choosing segment that is
+// perpendicular to X axis. Follow steps in the article from this starting condition and you will
+// will get this result.
+//
+// Rendering circles with an odd number of segments, while mathematically correct will produce
+// asymmetrical results on the raster grid. Therefore we're rounding N to next even number (7->8, 8->8, 9->10 etc.)
+//
+#define IM_ROUNDUP_TO_EVEN(_V)                                  ((((_V) + 1) / 2) * 2)
+#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN                     4
+#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX                     512
+#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(_RAD,_MAXERROR)    ImClamp(IM_ROUNDUP_TO_EVEN((int)ImCeil(IM_PI / ImAcos(1 - ImMin((_MAXERROR), (_RAD)) / (_RAD)))), IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX)
+
+// Raw equation from IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC rewritten for 'r' and 'error'.
+#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR)    ((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))))
+#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD)     ((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD))
+
+// ImDrawList: Lookup table size for adaptive arc drawing, cover full circle.
+#ifndef IM_DRAWLIST_ARCFAST_TABLE_SIZE
+#define IM_DRAWLIST_ARCFAST_TABLE_SIZE                          48 // Number of samples in lookup table.
+#endif
+#define IM_DRAWLIST_ARCFAST_SAMPLE_MAX                          IM_DRAWLIST_ARCFAST_TABLE_SIZE // Sample index _PathArcToFastEx() for 360 angle.
+
+// Data shared between all ImDrawList instances
+// You may want to create your own instance of this if you want to use ImDrawList completely without ImGui. In that case, watch out for future changes to this structure.
+struct IMGUI_API ImDrawListSharedData
+{
+    ImVec2          TexUvWhitePixel;            // UV of white pixel in the atlas
+    ImFont*         Font;                       // Current/default font (optional, for simplified AddText overload)
+    float           FontSize;                   // Current/default font size (optional, for simplified AddText overload)
+    float           CurveTessellationTol;       // Tessellation tolerance when using PathBezierCurveTo()
+    float           CircleSegmentMaxError;      // Number of circle segments to use per pixel of radius for AddCircle() etc
+    ImVec4          ClipRectFullscreen;         // Value for PushClipRectFullscreen()
+    ImDrawListFlags InitialFlags;               // Initial flags at the beginning of the frame (it is possible to alter flags on a per-drawlist basis afterwards)
+
+    // [Internal] Lookup tables
+    ImVec2          ArcFastVtx[IM_DRAWLIST_ARCFAST_TABLE_SIZE]; // Sample points on the quarter of the circle.
+    float           ArcFastRadiusCutoff;                        // Cutoff radius after which arc drawing will fallback to slower PathArcTo()
+    ImU8            CircleSegmentCounts[64];    // Precomputed segment count for given radius before we calculate it dynamically (to avoid calculation overhead)
+    const ImVec4*   TexUvLines;                 // UV of anti-aliased lines in the atlas
+
+    ImDrawListSharedData();
+    void SetCircleTessellationMaxError(float max_error);
+};
+
+struct ImDrawDataBuilder
+{
+    ImVector<ImDrawList*>   Layers[2];           // Global layers for: regular, tooltip
+
+    void Clear()                    { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].resize(0); }
+    void ClearFreeMemory()          { for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) Layers[n].clear(); }
+    int  GetDrawListCount() const   { int count = 0; for (int n = 0; n < IM_ARRAYSIZE(Layers); n++) count += Layers[n].Size; return count; }
+    IMGUI_API void FlattenIntoSingleLayer();
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Widgets support: flags, enums, data structures
+//-----------------------------------------------------------------------------
+
+// Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
+// This is going to be exposed in imgui.h when stabilized enough.
+enum ImGuiItemFlags_
+{
+    ImGuiItemFlags_None                     = 0,
+    ImGuiItemFlags_NoTabStop                = 1 << 0,  // false     // Disable keyboard tabbing (FIXME: should merge with _NoNav)
+    ImGuiItemFlags_ButtonRepeat             = 1 << 1,  // false     // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
+    ImGuiItemFlags_Disabled                 = 1 << 2,  // false     // Disable interactions but doesn't affect visuals. See BeginDisabled()/EndDisabled(). See github.com/ocornut/imgui/issues/211
+    ImGuiItemFlags_NoNav                    = 1 << 3,  // false     // Disable keyboard/gamepad directional navigation (FIXME: should merge with _NoTabStop)
+    ImGuiItemFlags_NoNavDefaultFocus        = 1 << 4,  // false     // Disable item being a candidate for default focus (e.g. used by title bar items)
+    ImGuiItemFlags_SelectableDontClosePopup = 1 << 5,  // false     // Disable MenuItem/Selectable() automatically closing their popup window
+    ImGuiItemFlags_MixedValue               = 1 << 6,  // false     // [BETA] Represent a mixed/indeterminate value, generally multi-selection where values differ. Currently only supported by Checkbox() (later should support all sorts of widgets)
+    ImGuiItemFlags_ReadOnly                 = 1 << 7,  // false     // [ALPHA] Allow hovering interactions but underlying value is not changed.
+    ImGuiItemFlags_Inputable                = 1 << 8   // false     // [WIP] Auto-activate item when focused. Currently only used and supported by a few items before it becomes a generic feature.
+};
+
+// Storage for LastItem data
+enum ImGuiItemStatusFlags_
+{
+    ImGuiItemStatusFlags_None               = 0,
+    ImGuiItemStatusFlags_HoveredRect        = 1 << 0,   // Mouse position is within item rectangle (does NOT mean that the window is in correct z-order and can be hovered!, this is only one part of the most-common IsItemHovered test)
+    ImGuiItemStatusFlags_HasDisplayRect     = 1 << 1,   // g.LastItemData.DisplayRect is valid
+    ImGuiItemStatusFlags_Edited             = 1 << 2,   // Value exposed by item was edited in the current frame (should match the bool return value of most widgets)
+    ImGuiItemStatusFlags_ToggledSelection   = 1 << 3,   // Set when Selectable(), TreeNode() reports toggling a selection. We can't report "Selected", only state changes, in order to easily handle clipping with less issues.
+    ImGuiItemStatusFlags_ToggledOpen        = 1 << 4,   // Set when TreeNode() reports toggling their open state.
+    ImGuiItemStatusFlags_HasDeactivated     = 1 << 5,   // Set if the widget/group is able to provide data for the ImGuiItemStatusFlags_Deactivated flag.
+    ImGuiItemStatusFlags_Deactivated        = 1 << 6,   // Only valid if ImGuiItemStatusFlags_HasDeactivated is set.
+    ImGuiItemStatusFlags_HoveredWindow      = 1 << 7,   // Override the HoveredWindow test to allow cross-window hover testing.
+    ImGuiItemStatusFlags_FocusedByTabbing   = 1 << 8    // Set when the Focusable item just got focused by Tabbing (FIXME: to be removed soon)
+
+#ifdef IMGUI_ENABLE_TEST_ENGINE
+    , // [imgui_tests only]
+    ImGuiItemStatusFlags_Openable           = 1 << 20,  //
+    ImGuiItemStatusFlags_Opened             = 1 << 21,  //
+    ImGuiItemStatusFlags_Checkable          = 1 << 22,  //
+    ImGuiItemStatusFlags_Checked            = 1 << 23   //
+#endif
+};
+
+// Extend ImGuiInputTextFlags_
+enum ImGuiInputTextFlagsPrivate_
+{
+    // [Internal]
+    ImGuiInputTextFlags_Multiline           = 1 << 26,  // For internal use by InputTextMultiline()
+    ImGuiInputTextFlags_NoMarkEdited        = 1 << 27,  // For internal use by functions using InputText() before reformatting data
+    ImGuiInputTextFlags_MergedItem          = 1 << 28   // For internal use by TempInputText(), will skip calling ItemAdd(). Require bounding-box to strictly match.
+};
+
+// Extend ImGuiButtonFlags_
+enum ImGuiButtonFlagsPrivate_
+{
+    ImGuiButtonFlags_PressedOnClick         = 1 << 4,   // return true on click (mouse down event)
+    ImGuiButtonFlags_PressedOnClickRelease  = 1 << 5,   // [Default] return true on click + release on same item <-- this is what the majority of Button are using
+    ImGuiButtonFlags_PressedOnClickReleaseAnywhere = 1 << 6, // return true on click + release even if the release event is not done while hovering the item
+    ImGuiButtonFlags_PressedOnRelease       = 1 << 7,   // return true on release (default requires click+release)
+    ImGuiButtonFlags_PressedOnDoubleClick   = 1 << 8,   // return true on double-click (default requires click+release)
+    ImGuiButtonFlags_PressedOnDragDropHold  = 1 << 9,   // return true when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
+    ImGuiButtonFlags_Repeat                 = 1 << 10,  // hold to repeat
+    ImGuiButtonFlags_FlattenChildren        = 1 << 11,  // allow interactions even if a child window is overlapping
+    ImGuiButtonFlags_AllowItemOverlap       = 1 << 12,  // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
+    ImGuiButtonFlags_DontClosePopups        = 1 << 13,  // disable automatically closing parent popup on press // [UNUSED]
+    //ImGuiButtonFlags_Disabled             = 1 << 14,  // disable interactions -> use BeginDisabled() or ImGuiItemFlags_Disabled
+    ImGuiButtonFlags_AlignTextBaseLine      = 1 << 15,  // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
+    ImGuiButtonFlags_NoKeyModifiers         = 1 << 16,  // disable mouse interaction if a key modifier is held
+    ImGuiButtonFlags_NoHoldingActiveId      = 1 << 17,  // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
+    ImGuiButtonFlags_NoNavFocus             = 1 << 18,  // don't override navigation focus when activated
+    ImGuiButtonFlags_NoHoveredOnFocus       = 1 << 19,  // don't report as hovered when nav focus is on this item
+    ImGuiButtonFlags_PressedOnMask_         = ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnClickReleaseAnywhere | ImGuiButtonFlags_PressedOnRelease | ImGuiButtonFlags_PressedOnDoubleClick | ImGuiButtonFlags_PressedOnDragDropHold,
+    ImGuiButtonFlags_PressedOnDefault_      = ImGuiButtonFlags_PressedOnClickRelease
+};
+
+// Extend ImGuiComboFlags_
+enum ImGuiComboFlagsPrivate_
+{
+    ImGuiComboFlags_CustomPreview           = 1 << 20   // enable BeginComboPreview()
+};
+
+// Extend ImGuiSliderFlags_
+enum ImGuiSliderFlagsPrivate_
+{
+    ImGuiSliderFlags_Vertical               = 1 << 20,  // Should this slider be orientated vertically?
+    ImGuiSliderFlags_ReadOnly               = 1 << 21
+};
+
+// Extend ImGuiSelectableFlags_
+enum ImGuiSelectableFlagsPrivate_
+{
+    // NB: need to be in sync with last value of ImGuiSelectableFlags_
+    ImGuiSelectableFlags_NoHoldingActiveID      = 1 << 20,
+    ImGuiSelectableFlags_SelectOnNav            = 1 << 21,  // (WIP) Auto-select when moved into. This is not exposed in public API as to handle multi-select and modifiers we will need user to explicitly control focus scope. May be replaced with a BeginSelection() API.
+    ImGuiSelectableFlags_SelectOnClick          = 1 << 22,  // Override button behavior to react on Click (default is Click+Release)
+    ImGuiSelectableFlags_SelectOnRelease        = 1 << 23,  // Override button behavior to react on Release (default is Click+Release)
+    ImGuiSelectableFlags_SpanAvailWidth         = 1 << 24,  // Span all avail width even if we declared less for layout purpose. FIXME: We may be able to remove this (added in 6251d379, 2bcafc86 for menus)
+    ImGuiSelectableFlags_DrawHoveredWhenHeld    = 1 << 25,  // Always show active when held, even is not hovered. This concept could probably be renamed/formalized somehow.
+    ImGuiSelectableFlags_SetNavIdOnHover        = 1 << 26,  // Set Nav/Focus ID on mouse hover (used by MenuItem)
+    ImGuiSelectableFlags_NoPadWithHalfSpacing   = 1 << 27   // Disable padding each side with ItemSpacing * 0.5f
+};
+
+// Extend ImGuiTreeNodeFlags_
+enum ImGuiTreeNodeFlagsPrivate_
+{
+    ImGuiTreeNodeFlags_ClipLabelForTrailingButton = 1 << 20
+};
+
+enum ImGuiSeparatorFlags_
+{
+    ImGuiSeparatorFlags_None                = 0,
+    ImGuiSeparatorFlags_Horizontal          = 1 << 0,   // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
+    ImGuiSeparatorFlags_Vertical            = 1 << 1,
+    ImGuiSeparatorFlags_SpanAllColumns      = 1 << 2
+};
+
+enum ImGuiTextFlags_
+{
+    ImGuiTextFlags_None = 0,
+    ImGuiTextFlags_NoWidthForLargeClippedText = 1 << 0
+};
+
+enum ImGuiTooltipFlags_
+{
+    ImGuiTooltipFlags_None = 0,
+    ImGuiTooltipFlags_OverridePreviousTooltip = 1 << 0      // Override will clear/ignore previously submitted tooltip (defaults to append)
+};
+
+// FIXME: this is in development, not exposed/functional as a generic feature yet.
+// Horizontal/Vertical enums are fixed to 0/1 so they may be used to index ImVec2
+enum ImGuiLayoutType_
+{
+    ImGuiLayoutType_Horizontal = 0,
+    ImGuiLayoutType_Vertical = 1
+};
+
+enum ImGuiLogType
+{
+    ImGuiLogType_None = 0,
+    ImGuiLogType_TTY,
+    ImGuiLogType_File,
+    ImGuiLogType_Buffer,
+    ImGuiLogType_Clipboard
+};
+
+// X/Y enums are fixed to 0/1 so they may be used to index ImVec2
+enum ImGuiAxis
+{
+    ImGuiAxis_None = -1,
+    ImGuiAxis_X = 0,
+    ImGuiAxis_Y = 1
+};
+
+enum ImGuiPlotType
+{
+    ImGuiPlotType_Lines,
+    ImGuiPlotType_Histogram
+};
+
+enum ImGuiInputSource
+{
+    ImGuiInputSource_None = 0,
+    ImGuiInputSource_Mouse,
+    ImGuiInputSource_Keyboard,
+    ImGuiInputSource_Gamepad,
+    ImGuiInputSource_Nav,               // Stored in g.ActiveIdSource only
+    ImGuiInputSource_Clipboard,         // Currently only used by InputText()
+    ImGuiInputSource_COUNT
+};
+
+// FIXME-NAV: Clarify/expose various repeat delay/rate
+enum ImGuiInputReadMode
+{
+    ImGuiInputReadMode_Down,
+    ImGuiInputReadMode_Pressed,
+    ImGuiInputReadMode_Released,
+    ImGuiInputReadMode_Repeat,
+    ImGuiInputReadMode_RepeatSlow,
+    ImGuiInputReadMode_RepeatFast
+};
+
+enum ImGuiPopupPositionPolicy
+{
+    ImGuiPopupPositionPolicy_Default,
+    ImGuiPopupPositionPolicy_ComboBox,
+    ImGuiPopupPositionPolicy_Tooltip
+};
+
+struct ImGuiDataTypeTempStorage
+{
+    ImU8        Data[8];        // Can fit any data up to ImGuiDataType_COUNT
+};
+
+// Type information associated to one ImGuiDataType. Retrieve with DataTypeGetInfo().
+struct ImGuiDataTypeInfo
+{
+    size_t      Size;           // Size in bytes
+    const char* Name;           // Short descriptive name for the type, for debugging
+    const char* PrintFmt;       // Default printf format for the type
+    const char* ScanFmt;        // Default scanf format for the type
+};
+
+// Extend ImGuiDataType_
+enum ImGuiDataTypePrivate_
+{
+    ImGuiDataType_String = ImGuiDataType_COUNT + 1,
+    ImGuiDataType_Pointer,
+    ImGuiDataType_ID
+};
+
+// Stacked color modifier, backup of modified data so we can restore it
+struct ImGuiColorMod
+{
+    ImGuiCol    Col;
+    ImVec4      BackupValue;
+};
+
+// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
+struct ImGuiStyleMod
+{
+    ImGuiStyleVar   VarIdx;
+    union           { int BackupInt[2]; float BackupFloat[2]; };
+    ImGuiStyleMod(ImGuiStyleVar idx, int v)     { VarIdx = idx; BackupInt[0] = v; }
+    ImGuiStyleMod(ImGuiStyleVar idx, float v)   { VarIdx = idx; BackupFloat[0] = v; }
+    ImGuiStyleMod(ImGuiStyleVar idx, ImVec2 v)  { VarIdx = idx; BackupFloat[0] = v.x; BackupFloat[1] = v.y; }
+};
+
+// Storage data for BeginComboPreview()/EndComboPreview()
+struct IMGUI_API ImGuiComboPreviewData
+{
+    ImRect          PreviewRect;
+    ImVec2          BackupCursorPos;
+    ImVec2          BackupCursorMaxPos;
+    ImVec2          BackupCursorPosPrevLine;
+    float           BackupPrevLineTextBaseOffset;
+    ImGuiLayoutType BackupLayout;
+
+    ImGuiComboPreviewData() { memset(this, 0, sizeof(*this)); }
+};
+
+// Stacked storage data for BeginGroup()/EndGroup()
+struct IMGUI_API ImGuiGroupData
+{
+    ImGuiID     WindowID;
+    ImVec2      BackupCursorPos;
+    ImVec2      BackupCursorMaxPos;
+    ImVec1      BackupIndent;
+    ImVec1      BackupGroupOffset;
+    ImVec2      BackupCurrLineSize;
+    float       BackupCurrLineTextBaseOffset;
+    ImGuiID     BackupActiveIdIsAlive;
+    bool        BackupActiveIdPreviousFrameIsAlive;
+    bool        BackupHoveredIdIsAlive;
+    bool        EmitItem;
+};
+
+// Simple column measurement, currently used for MenuItem() only.. This is very short-sighted/throw-away code and NOT a generic helper.
+struct IMGUI_API ImGuiMenuColumns
+{
+    ImU32       TotalWidth;
+    ImU32       NextTotalWidth;
+    ImU16       Spacing;
+    ImU16       OffsetIcon;         // Always zero for now
+    ImU16       OffsetLabel;        // Offsets are locked in Update()
+    ImU16       OffsetShortcut;
+    ImU16       OffsetMark;
+    ImU16       Widths[4];          // Width of:   Icon, Label, Shortcut, Mark  (accumulators for current frame)
+
+    ImGuiMenuColumns() { memset(this, 0, sizeof(*this)); }
+    void        Update(float spacing, bool window_reappearing);
+    float       DeclColumns(float w_icon, float w_label, float w_shortcut, float w_mark);
+    void        CalcNextTotalWidth(bool update_offsets);
+};
+
+// Internal state of the currently focused/edited text input box
+// For a given item ID, access with ImGui::GetInputTextState()
+struct IMGUI_API ImGuiInputTextState
+{
+    ImGuiID                 ID;                     // widget id owning the text state
+    int                     CurLenW, CurLenA;       // we need to maintain our buffer length in both UTF-8 and wchar format. UTF-8 length is valid even if TextA is not.
+    ImVector<ImWchar>       TextW;                  // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
+    ImVector<char>          TextA;                  // temporary UTF8 buffer for callbacks and other operations. this is not updated in every code-path! size=capacity.
+    ImVector<char>          InitialTextA;           // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
+    bool                    TextAIsValid;           // temporary UTF8 buffer is not initially valid before we make the widget active (until then we pull the data from user argument)
+    int                     BufCapacityA;           // end-user buffer capacity
+    float                   ScrollX;                // horizontal scrolling/offset
+    ImStb::STB_TexteditState Stb;                   // state for stb_textedit.h
+    float                   CursorAnim;             // timer for cursor blink, reset on every user action so the cursor reappears immediately
+    bool                    CursorFollow;           // set when we want scrolling to follow the current cursor position (not always!)
+    bool                    SelectedAllMouseLock;   // after a double-click to select all, we ignore further mouse drags to update selection
+    bool                    Edited;                 // edited this frame
+    ImGuiInputTextFlags     Flags;                  // copy of InputText() flags
+    ImGuiInputTextCallback  UserCallback;           // "
+    void*                   UserCallbackData;       // "
+
+    ImGuiInputTextState()                   { memset(this, 0, sizeof(*this)); }
+    void        ClearText()                 { CurLenW = CurLenA = 0; TextW[0] = 0; TextA[0] = 0; CursorClamp(); }
+    void        ClearFreeMemory()           { TextW.clear(); TextA.clear(); InitialTextA.clear(); }
+    int         GetUndoAvailCount() const   { return Stb.undostate.undo_point; }
+    int         GetRedoAvailCount() const   { return STB_TEXTEDIT_UNDOSTATECOUNT - Stb.undostate.redo_point; }
+    void        OnKeyPressed(int key);      // Cannot be inline because we call in code in stb_textedit.h implementation
+
+    // Cursor & Selection
+    void        CursorAnimReset()           { CursorAnim = -0.30f; }                                   // After a user-input the cursor stays on for a while without blinking
+    void        CursorClamp()               { Stb.cursor = ImMin(Stb.cursor, CurLenW); Stb.select_start = ImMin(Stb.select_start, CurLenW); Stb.select_end = ImMin(Stb.select_end, CurLenW); }
+    bool        HasSelection() const        { return Stb.select_start != Stb.select_end; }
+    void        ClearSelection()            { Stb.select_start = Stb.select_end = Stb.cursor; }
+    int         GetCursorPos() const        { return Stb.cursor; }
+    int         GetSelectionStart() const   { return Stb.select_start; }
+    int         GetSelectionEnd() const     { return Stb.select_end; }
+    void        SelectAll()                 { Stb.select_start = 0; Stb.cursor = Stb.select_end = CurLenW; Stb.has_preferred_x = 0; }
+};
+
+// Storage for current popup stack
+struct ImGuiPopupData
+{
+    ImGuiID             PopupId;        // Set on OpenPopup()
+    ImGuiWindow*        Window;         // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
+    ImGuiWindow*        SourceWindow;   // Set on OpenPopup() copy of NavWindow at the time of opening the popup
+    int                 OpenFrameCount; // Set on OpenPopup()
+    ImGuiID             OpenParentId;   // Set on OpenPopup(), we need this to differentiate multiple menu sets from each others (e.g. inside menu bar vs loose menu items)
+    ImVec2              OpenPopupPos;   // Set on OpenPopup(), preferred popup position (typically == OpenMousePos when using mouse)
+    ImVec2              OpenMousePos;   // Set on OpenPopup(), copy of mouse position at the time of opening popup
+
+    ImGuiPopupData()    { memset(this, 0, sizeof(*this)); OpenFrameCount = -1; }
+};
+
+enum ImGuiNextWindowDataFlags_
+{
+    ImGuiNextWindowDataFlags_None               = 0,
+    ImGuiNextWindowDataFlags_HasPos             = 1 << 0,
+    ImGuiNextWindowDataFlags_HasSize            = 1 << 1,
+    ImGuiNextWindowDataFlags_HasContentSize     = 1 << 2,
+    ImGuiNextWindowDataFlags_HasCollapsed       = 1 << 3,
+    ImGuiNextWindowDataFlags_HasSizeConstraint  = 1 << 4,
+    ImGuiNextWindowDataFlags_HasFocus           = 1 << 5,
+    ImGuiNextWindowDataFlags_HasBgAlpha         = 1 << 6,
+    ImGuiNextWindowDataFlags_HasScroll          = 1 << 7
+};
+
+// Storage for SetNexWindow** functions
+struct ImGuiNextWindowData
+{
+    ImGuiNextWindowDataFlags    Flags;
+    ImGuiCond                   PosCond;
+    ImGuiCond                   SizeCond;
+    ImGuiCond                   CollapsedCond;
+    ImVec2                      PosVal;
+    ImVec2                      PosPivotVal;
+    ImVec2                      SizeVal;
+    ImVec2                      ContentSizeVal;
+    ImVec2                      ScrollVal;
+    bool                        CollapsedVal;
+    ImRect                      SizeConstraintRect;
+    ImGuiSizeCallback           SizeCallback;
+    void*                       SizeCallbackUserData;
+    float                       BgAlphaVal;             // Override background alpha
+    ImVec2                      MenuBarOffsetMinVal;    // (Always on) This is not exposed publicly, so we don't clear it and it doesn't have a corresponding flag (could we? for consistency?)
+
+    ImGuiNextWindowData()       { memset(this, 0, sizeof(*this)); }
+    inline void ClearFlags()    { Flags = ImGuiNextWindowDataFlags_None; }
+};
+
+enum ImGuiNextItemDataFlags_
+{
+    ImGuiNextItemDataFlags_None     = 0,
+    ImGuiNextItemDataFlags_HasWidth = 1 << 0,
+    ImGuiNextItemDataFlags_HasOpen  = 1 << 1
+};
+
+struct ImGuiNextItemData
+{
+    ImGuiNextItemDataFlags      Flags;
+    float                       Width;          // Set by SetNextItemWidth()
+    ImGuiID                     FocusScopeId;   // Set by SetNextItemMultiSelectData() (!= 0 signify value has been set, so it's an alternate version of HasSelectionData, we don't use Flags for this because they are cleared too early. This is mostly used for debugging)
+    ImGuiCond                   OpenCond;
+    bool                        OpenVal;        // Set by SetNextItemOpen()
+
+    ImGuiNextItemData()         { memset(this, 0, sizeof(*this)); }
+    inline void ClearFlags()    { Flags = ImGuiNextItemDataFlags_None; } // Also cleared manually by ItemAdd()!
+};
+
+// Status storage for the last submitted item
+struct ImGuiLastItemData
+{
+    ImGuiID                 ID;
+    ImGuiItemFlags          InFlags;            // See ImGuiItemFlags_
+    ImGuiItemStatusFlags    StatusFlags;        // See ImGuiItemStatusFlags_
+    ImRect                  Rect;               // Full rectangle
+    ImRect                  NavRect;            // Navigation scoring rectangle (not displayed)
+    ImRect                  DisplayRect;        // Display rectangle (only if ImGuiItemStatusFlags_HasDisplayRect is set)
+
+    ImGuiLastItemData()     { memset(this, 0, sizeof(*this)); }
+};
+
+struct IMGUI_API ImGuiStackSizes
+{
+    short   SizeOfIDStack;
+    short   SizeOfColorStack;
+    short   SizeOfStyleVarStack;
+    short   SizeOfFontStack;
+    short   SizeOfFocusScopeStack;
+    short   SizeOfGroupStack;
+    short   SizeOfItemFlagsStack;
+    short   SizeOfBeginPopupStack;
+    short   SizeOfDisabledStack;
+
+    ImGuiStackSizes() { memset(this, 0, sizeof(*this)); }
+    void SetToCurrentState();
+    void CompareWithCurrentState();
+};
+
+// Data saved for each window pushed into the stack
+struct ImGuiWindowStackData
+{
+    ImGuiWindow*            Window;
+    ImGuiLastItemData       ParentLastItemDataBackup;
+    ImGuiStackSizes         StackSizesOnBegin;      // Store size of various stacks for asserting
+};
+
+struct ImGuiShrinkWidthItem
+{
+    int         Index;
+    float       Width;
+};
+
+struct ImGuiPtrOrIndex
+{
+    void*       Ptr;            // Either field can be set, not both. e.g. Dock node tab bars are loose while BeginTabBar() ones are in a pool.
+    int         Index;          // Usually index in a main pool.
+
+    ImGuiPtrOrIndex(void* ptr)  { Ptr = ptr; Index = -1; }
+    ImGuiPtrOrIndex(int index)  { Ptr = NULL; Index = index; }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Navigation support
+//-----------------------------------------------------------------------------
+
+enum ImGuiActivateFlags_
+{
+    ImGuiActivateFlags_None                 = 0,
+    ImGuiActivateFlags_PreferInput          = 1 << 0,       // Favor activation that requires keyboard text input (e.g. for Slider/Drag). Default if keyboard is available.
+    ImGuiActivateFlags_PreferTweak          = 1 << 1,       // Favor activation for tweaking with arrows or gamepad (e.g. for Slider/Drag). Default if keyboard is not available.
+    ImGuiActivateFlags_TryToPreserveState   = 1 << 2        // Request widget to preserve state if it can (e.g. InputText will try to preserve cursor/selection)
+};
+
+// Early work-in-progress API for ScrollToItem()
+enum ImGuiScrollFlags_
+{
+    ImGuiScrollFlags_None                   = 0,
+    ImGuiScrollFlags_KeepVisibleEdgeX       = 1 << 0,       // If item is not visible: scroll as little as possible on X axis to bring item back into view [default for X axis]
+    ImGuiScrollFlags_KeepVisibleEdgeY       = 1 << 1,       // If item is not visible: scroll as little as possible on Y axis to bring item back into view [default for Y axis for windows that are already visible]
+    ImGuiScrollFlags_KeepVisibleCenterX     = 1 << 2,       // If item is not visible: scroll to make the item centered on X axis [rarely used]
+    ImGuiScrollFlags_KeepVisibleCenterY     = 1 << 3,       // If item is not visible: scroll to make the item centered on Y axis
+    ImGuiScrollFlags_AlwaysCenterX          = 1 << 4,       // Always center the result item on X axis [rarely used]
+    ImGuiScrollFlags_AlwaysCenterY          = 1 << 5,       // Always center the result item on Y axis [default for Y axis for appearing window)
+    ImGuiScrollFlags_NoScrollParent         = 1 << 6,       // Disable forwarding scrolling to parent window if required to keep item/rect visible (only scroll window the function was applied to).
+    ImGuiScrollFlags_MaskX_                 = ImGuiScrollFlags_KeepVisibleEdgeX | ImGuiScrollFlags_KeepVisibleCenterX | ImGuiScrollFlags_AlwaysCenterX,
+    ImGuiScrollFlags_MaskY_                 = ImGuiScrollFlags_KeepVisibleEdgeY | ImGuiScrollFlags_KeepVisibleCenterY | ImGuiScrollFlags_AlwaysCenterY
+};
+
+enum ImGuiNavHighlightFlags_
+{
+    ImGuiNavHighlightFlags_None             = 0,
+    ImGuiNavHighlightFlags_TypeDefault      = 1 << 0,
+    ImGuiNavHighlightFlags_TypeThin         = 1 << 1,
+    ImGuiNavHighlightFlags_AlwaysDraw       = 1 << 2,       // Draw rectangular highlight if (g.NavId == id) _even_ when using the mouse.
+    ImGuiNavHighlightFlags_NoRounding       = 1 << 3
+};
+
+enum ImGuiNavDirSourceFlags_
+{
+    ImGuiNavDirSourceFlags_None             = 0,
+    ImGuiNavDirSourceFlags_Keyboard         = 1 << 0,
+    ImGuiNavDirSourceFlags_PadDPad          = 1 << 1,
+    ImGuiNavDirSourceFlags_PadLStick        = 1 << 2
+};
+
+enum ImGuiNavMoveFlags_
+{
+    ImGuiNavMoveFlags_None                  = 0,
+    ImGuiNavMoveFlags_LoopX                 = 1 << 0,   // On failed request, restart from opposite side
+    ImGuiNavMoveFlags_LoopY                 = 1 << 1,
+    ImGuiNavMoveFlags_WrapX                 = 1 << 2,   // On failed request, request from opposite side one line down (when NavDir==right) or one line up (when NavDir==left)
+    ImGuiNavMoveFlags_WrapY                 = 1 << 3,   // This is not super useful but provided for completeness
+    ImGuiNavMoveFlags_AllowCurrentNavId     = 1 << 4,   // Allow scoring and considering the current NavId as a move target candidate. This is used when the move source is offset (e.g. pressing PageDown actually needs to send a Up move request, if we are pressing PageDown from the bottom-most item we need to stay in place)
+    ImGuiNavMoveFlags_AlsoScoreVisibleSet   = 1 << 5,   // Store alternate result in NavMoveResultLocalVisible that only comprise elements that are already fully visible (used by PageUp/PageDown)
+    ImGuiNavMoveFlags_ScrollToEdgeY         = 1 << 6,   // Force scrolling to min/max (used by Home/End) // FIXME-NAV: Aim to remove or reword, probably unnecessary
+    ImGuiNavMoveFlags_Forwarded             = 1 << 7,
+    ImGuiNavMoveFlags_DebugNoResult         = 1 << 8,   // Dummy scoring for debug purpose, don't apply result
+    ImGuiNavMoveFlags_Tabbing               = 1 << 9,   // == Focus + Activate if item is Inputable + DontChangeNavHighlight
+    ImGuiNavMoveFlags_Activate              = 1 << 10,
+    ImGuiNavMoveFlags_DontSetNavHighlight   = 1 << 11   // Do not alter the visible state of keyboard vs mouse nav highlight
+};
+
+enum ImGuiNavLayer
+{
+    ImGuiNavLayer_Main  = 0,    // Main scrolling layer
+    ImGuiNavLayer_Menu  = 1,    // Menu layer (access with Alt/ImGuiNavInput_Menu)
+    ImGuiNavLayer_COUNT
+};
+
+struct ImGuiNavItemData
+{
+    ImGuiWindow*        Window;         // Init,Move    // Best candidate window (result->ItemWindow->RootWindowForNav == request->Window)
+    ImGuiID             ID;             // Init,Move    // Best candidate item ID
+    ImGuiID             FocusScopeId;   // Init,Move    // Best candidate focus scope ID
+    ImRect              RectRel;        // Init,Move    // Best candidate bounding box in window relative space
+    ImGuiItemFlags      InFlags;        // ????,Move    // Best candidate item flags
+    float               DistBox;        //      Move    // Best candidate box distance to current NavId
+    float               DistCenter;     //      Move    // Best candidate center distance to current NavId
+    float               DistAxial;      //      Move    // Best candidate axial distance to current NavId
+
+    ImGuiNavItemData()  { Clear(); }
+    void Clear()        { Window = NULL; ID = FocusScopeId = 0; InFlags = 0; DistBox = DistCenter = DistAxial = FLT_MAX; }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Columns support
+//-----------------------------------------------------------------------------
+
+// Flags for internal's BeginColumns(). Prefix using BeginTable() nowadays!
+enum ImGuiOldColumnFlags_
+{
+    ImGuiOldColumnFlags_None                    = 0,
+    ImGuiOldColumnFlags_NoBorder                = 1 << 0,   // Disable column dividers
+    ImGuiOldColumnFlags_NoResize                = 1 << 1,   // Disable resizing columns when clicking on the dividers
+    ImGuiOldColumnFlags_NoPreserveWidths        = 1 << 2,   // Disable column width preservation when adjusting columns
+    ImGuiOldColumnFlags_NoForceWithinWindow     = 1 << 3,   // Disable forcing columns to fit within window
+    ImGuiOldColumnFlags_GrowParentContentsSize  = 1 << 4    // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
+
+    // Obsolete names (will be removed)
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    , ImGuiColumnsFlags_None                    = ImGuiOldColumnFlags_None,
+    ImGuiColumnsFlags_NoBorder                  = ImGuiOldColumnFlags_NoBorder,
+    ImGuiColumnsFlags_NoResize                  = ImGuiOldColumnFlags_NoResize,
+    ImGuiColumnsFlags_NoPreserveWidths          = ImGuiOldColumnFlags_NoPreserveWidths,
+    ImGuiColumnsFlags_NoForceWithinWindow       = ImGuiOldColumnFlags_NoForceWithinWindow,
+    ImGuiColumnsFlags_GrowParentContentsSize    = ImGuiOldColumnFlags_GrowParentContentsSize
+#endif
+};
+
+struct ImGuiOldColumnData
+{
+    float               OffsetNorm;         // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
+    float               OffsetNormBeforeResize;
+    ImGuiOldColumnFlags Flags;              // Not exposed
+    ImRect              ClipRect;
+
+    ImGuiOldColumnData() { memset(this, 0, sizeof(*this)); }
+};
+
+struct ImGuiOldColumns
+{
+    ImGuiID             ID;
+    ImGuiOldColumnFlags Flags;
+    bool                IsFirstFrame;
+    bool                IsBeingResized;
+    int                 Current;
+    int                 Count;
+    float               OffMinX, OffMaxX;       // Offsets from HostWorkRect.Min.x
+    float               LineMinY, LineMaxY;
+    float               HostCursorPosY;         // Backup of CursorPos at the time of BeginColumns()
+    float               HostCursorMaxPosX;      // Backup of CursorMaxPos at the time of BeginColumns()
+    ImRect              HostInitialClipRect;    // Backup of ClipRect at the time of BeginColumns()
+    ImRect              HostBackupClipRect;     // Backup of ClipRect during PushColumnsBackground()/PopColumnsBackground()
+    ImRect              HostBackupParentWorkRect;//Backup of WorkRect at the time of BeginColumns()
+    ImVector<ImGuiOldColumnData> Columns;
+    ImDrawListSplitter  Splitter;
+
+    ImGuiOldColumns()   { memset(this, 0, sizeof(*this)); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Multi-select support
+//-----------------------------------------------------------------------------
+
+#ifdef IMGUI_HAS_MULTI_SELECT
+// <this is filled in 'range_select' branch>
+#endif // #ifdef IMGUI_HAS_MULTI_SELECT
+
+//-----------------------------------------------------------------------------
+// [SECTION] Docking support
+//-----------------------------------------------------------------------------
+
+#ifdef IMGUI_HAS_DOCK
+// <this is filled in 'docking' branch>
+#endif // #ifdef IMGUI_HAS_DOCK
+
+//-----------------------------------------------------------------------------
+// [SECTION] Viewport support
+//-----------------------------------------------------------------------------
+
+// ImGuiViewport Private/Internals fields (cardinal sin: we are using inheritance!)
+// Every instance of ImGuiViewport is in fact a ImGuiViewportP.
+struct ImGuiViewportP : public ImGuiViewport
+{
+    int                 DrawListsLastFrame[2];  // Last frame number the background (0) and foreground (1) draw lists were used
+    ImDrawList*         DrawLists[2];           // Convenience background (0) and foreground (1) draw lists. We use them to draw software mouser cursor when io.MouseDrawCursor is set and to draw most debug overlays.
+    ImDrawData          DrawDataP;
+    ImDrawDataBuilder   DrawDataBuilder;
+
+    ImVec2              WorkOffsetMin;          // Work Area: Offset from Pos to top-left corner of Work Area. Generally (0,0) or (0,+main_menu_bar_height). Work Area is Full Area but without menu-bars/status-bars (so WorkArea always fit inside Pos/Size!)
+    ImVec2              WorkOffsetMax;          // Work Area: Offset from Pos+Size to bottom-right corner of Work Area. Generally (0,0) or (0,-status_bar_height).
+    ImVec2              BuildWorkOffsetMin;     // Work Area: Offset being built during current frame. Generally >= 0.0f.
+    ImVec2              BuildWorkOffsetMax;     // Work Area: Offset being built during current frame. Generally <= 0.0f.
+
+    ImGuiViewportP()    { DrawListsLastFrame[0] = DrawListsLastFrame[1] = -1; DrawLists[0] = DrawLists[1] = NULL; }
+    ~ImGuiViewportP()   { if (DrawLists[0]) IM_DELETE(DrawLists[0]); if (DrawLists[1]) IM_DELETE(DrawLists[1]); }
+
+    // Calculate work rect pos/size given a set of offset (we have 1 pair of offset for rect locked from last frame data, and 1 pair for currently building rect)
+    ImVec2  CalcWorkRectPos(const ImVec2& off_min) const                            { return ImVec2(Pos.x + off_min.x, Pos.y + off_min.y); }
+    ImVec2  CalcWorkRectSize(const ImVec2& off_min, const ImVec2& off_max) const    { return ImVec2(ImMax(0.0f, Size.x - off_min.x + off_max.x), ImMax(0.0f, Size.y - off_min.y + off_max.y)); }
+    void    UpdateWorkRect()            { WorkPos = CalcWorkRectPos(WorkOffsetMin); WorkSize = CalcWorkRectSize(WorkOffsetMin, WorkOffsetMax); } // Update public fields
+
+    // Helpers to retrieve ImRect (we don't need to store BuildWorkRect as every access tend to change it, hence the code asymmetry)
+    ImRect  GetMainRect() const         { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
+    ImRect  GetWorkRect() const         { return ImRect(WorkPos.x, WorkPos.y, WorkPos.x + WorkSize.x, WorkPos.y + WorkSize.y); }
+    ImRect  GetBuildWorkRect() const    { ImVec2 pos = CalcWorkRectPos(BuildWorkOffsetMin); ImVec2 size = CalcWorkRectSize(BuildWorkOffsetMin, BuildWorkOffsetMax); return ImRect(pos.x, pos.y, pos.x + size.x, pos.y + size.y); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Settings support
+//-----------------------------------------------------------------------------
+
+// Windows data saved in imgui.ini file
+// Because we never destroy or rename ImGuiWindowSettings, we can store the names in a separate buffer easily.
+// (this is designed to be stored in a ImChunkStream buffer, with the variable-length Name following our structure)
+struct ImGuiWindowSettings
+{
+    ImGuiID     ID;
+    ImVec2ih    Pos;
+    ImVec2ih    Size;
+    bool        Collapsed;
+    bool        WantApply;      // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)
+
+    ImGuiWindowSettings()       { memset(this, 0, sizeof(*this)); }
+    char* GetName()             { return (char*)(this + 1); }
+};
+
+struct ImGuiSettingsHandler
+{
+    const char* TypeName;       // Short description stored in .ini file. Disallowed characters: '[' ']'
+    ImGuiID     TypeHash;       // == ImHashStr(TypeName)
+    void        (*ClearAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler);                                // Clear all settings data
+    void        (*ReadInitFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler);                                // Read: Called before reading (in registration order)
+    void*       (*ReadOpenFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name);              // Read: Called when entering into a new ini entry e.g. "[Window][Name]"
+    void        (*ReadLineFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line); // Read: Called for every line of text within an ini entry
+    void        (*ApplyAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler);                                // Read: Called after reading (in registration order)
+    void        (*WriteAllFn)(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf);      // Write: Output every entries into 'out_buf'
+    void*       UserData;
+
+    ImGuiSettingsHandler() { memset(this, 0, sizeof(*this)); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Metrics, Debug Tools
+//-----------------------------------------------------------------------------
+
+struct ImGuiMetricsConfig
+{
+    bool        ShowStackTool;
+    bool        ShowWindowsRects;
+    bool        ShowWindowsBeginOrder;
+    bool        ShowTablesRects;
+    bool        ShowDrawCmdMesh;
+    bool        ShowDrawCmdBoundingBoxes;
+    int         ShowWindowsRectsType;
+    int         ShowTablesRectsType;
+
+    ImGuiMetricsConfig()
+    {
+        ShowStackTool = false;
+        ShowWindowsRects = false;
+        ShowWindowsBeginOrder = false;
+        ShowTablesRects = false;
+        ShowDrawCmdMesh = true;
+        ShowDrawCmdBoundingBoxes = true;
+        ShowWindowsRectsType = -1;
+        ShowTablesRectsType = -1;
+    }
+};
+
+struct ImGuiStackLevelInfo
+{
+    ImGuiID                 ID;
+    ImS8                    QueryFrameCount;            // >= 1: Query in progress
+    bool                    QuerySuccess;               // Obtained result from DebugHookIdInfo()
+    char                    Desc[58];                   // Arbitrarily sized buffer to hold a result (FIXME: could replace Results[] with a chunk stream?)
+
+    ImGuiStackLevelInfo()   { memset(this, 0, sizeof(*this)); }
+};
+
+// State for Stack tool queries
+struct ImGuiStackTool
+{
+    int                     LastActiveFrame;
+    int                     StackLevel;                 // -1: query stack and resize Results, >= 0: individual stack level
+    ImGuiID                 QueryId;                    // ID to query details for
+    ImVector<ImGuiStackLevelInfo> Results;
+
+    ImGuiStackTool()        { memset(this, 0, sizeof(*this)); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Generic context hooks
+//-----------------------------------------------------------------------------
+
+typedef void (*ImGuiContextHookCallback)(ImGuiContext* ctx, ImGuiContextHook* hook);
+enum ImGuiContextHookType { ImGuiContextHookType_NewFramePre, ImGuiContextHookType_NewFramePost, ImGuiContextHookType_EndFramePre, ImGuiContextHookType_EndFramePost, ImGuiContextHookType_RenderPre, ImGuiContextHookType_RenderPost, ImGuiContextHookType_Shutdown, ImGuiContextHookType_PendingRemoval_ };
+
+struct ImGuiContextHook
+{
+    ImGuiID                     HookId;     // A unique ID assigned by AddContextHook()
+    ImGuiContextHookType        Type;
+    ImGuiID                     Owner;
+    ImGuiContextHookCallback    Callback;
+    void*                       UserData;
+
+    ImGuiContextHook()          { memset(this, 0, sizeof(*this)); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImGuiContext (main imgui context)
+//-----------------------------------------------------------------------------
+
+struct ImGuiContext
+{
+    bool                    Initialized;
+    bool                    FontAtlasOwnedByContext;            // IO.Fonts-> is owned by the ImGuiContext and will be destructed along with it.
+    ImGuiIO                 IO;
+    ImGuiStyle              Style;
+    ImFont*                 Font;                               // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
+    float                   FontSize;                           // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
+    float                   FontBaseSize;                       // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
+    ImDrawListSharedData    DrawListSharedData;
+    double                  Time;
+    int                     FrameCount;
+    int                     FrameCountEnded;
+    int                     FrameCountRendered;
+    bool                    WithinFrameScope;                   // Set by NewFrame(), cleared by EndFrame()
+    bool                    WithinFrameScopeWithImplicitWindow; // Set by NewFrame(), cleared by EndFrame() when the implicit debug window has been pushed
+    bool                    WithinEndChild;                     // Set within EndChild()
+    bool                    GcCompactAll;                       // Request full GC
+    bool                    TestEngineHookItems;                // Will call test engine hooks: ImGuiTestEngineHook_ItemAdd(), ImGuiTestEngineHook_ItemInfo(), ImGuiTestEngineHook_Log()
+    void*                   TestEngine;                         // Test engine user data
+
+    // Windows state
+    ImVector<ImGuiWindow*>  Windows;                            // Windows, sorted in display order, back to front
+    ImVector<ImGuiWindow*>  WindowsFocusOrder;                  // Root windows, sorted in focus order, back to front.
+    ImVector<ImGuiWindow*>  WindowsTempSortBuffer;              // Temporary buffer used in EndFrame() to reorder windows so parents are kept before their child
+    ImVector<ImGuiWindowStackData> CurrentWindowStack;
+    ImGuiStorage            WindowsById;                        // Map window's ImGuiID to ImGuiWindow*
+    int                     WindowsActiveCount;                 // Number of unique windows submitted by frame
+    ImVec2                  WindowsHoverPadding;                // Padding around resizable windows for which hovering on counts as hovering the window == ImMax(style.TouchExtraPadding, WINDOWS_HOVER_PADDING)
+    ImGuiWindow*            CurrentWindow;                      // Window being drawn into
+    ImGuiWindow*            HoveredWindow;                      // Window the mouse is hovering. Will typically catch mouse inputs.
+    ImGuiWindow*            HoveredWindowUnderMovingWindow;     // Hovered window ignoring MovingWindow. Only set if MovingWindow is set.
+    ImGuiWindow*            MovingWindow;                       // Track the window we clicked on (in order to preserve focus). The actual window that is moved is generally MovingWindow->RootWindow.
+    ImGuiWindow*            WheelingWindow;                     // Track the window we started mouse-wheeling on. Until a timer elapse or mouse has moved, generally keep scrolling the same window even if during the course of scrolling the mouse ends up hovering a child window.
+    ImVec2                  WheelingWindowRefMousePos;
+    float                   WheelingWindowTimer;
+
+    // Item/widgets state and tracking information
+    ImGuiID                 DebugHookIdInfo;                    // Will call core hooks: DebugHookIdInfo() from GetID functions, used by Stack Tool [next HoveredId/ActiveId to not pull in an extra cache-line]
+    ImGuiID                 HoveredId;                          // Hovered widget, filled during the frame
+    ImGuiID                 HoveredIdPreviousFrame;
+    bool                    HoveredIdAllowOverlap;
+    bool                    HoveredIdUsingMouseWheel;           // Hovered widget will use mouse wheel. Blocks scrolling the underlying window.
+    bool                    HoveredIdPreviousFrameUsingMouseWheel;
+    bool                    HoveredIdDisabled;                  // At least one widget passed the rect test, but has been discarded by disabled flag or popup inhibit. May be true even if HoveredId == 0.
+    float                   HoveredIdTimer;                     // Measure contiguous hovering time
+    float                   HoveredIdNotActiveTimer;            // Measure contiguous hovering time where the item has not been active
+    ImGuiID                 ActiveId;                           // Active widget
+    ImGuiID                 ActiveIdIsAlive;                    // Active widget has been seen this frame (we can't use a bool as the ActiveId may change within the frame)
+    float                   ActiveIdTimer;
+    bool                    ActiveIdIsJustActivated;            // Set at the time of activation for one frame
+    bool                    ActiveIdAllowOverlap;               // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
+    bool                    ActiveIdNoClearOnFocusLoss;         // Disable losing active id if the active id window gets unfocused.
+    bool                    ActiveIdHasBeenPressedBefore;       // Track whether the active id led to a press (this is to allow changing between PressOnClick and PressOnRelease without pressing twice). Used by range_select branch.
+    bool                    ActiveIdHasBeenEditedBefore;        // Was the value associated to the widget Edited over the course of the Active state.
+    bool                    ActiveIdHasBeenEditedThisFrame;
+    bool                    ActiveIdUsingMouseWheel;            // Active widget will want to read mouse wheel. Blocks scrolling the underlying window.
+    ImU32                   ActiveIdUsingNavDirMask;            // Active widget will want to read those nav move requests (e.g. can activate a button and move away from it)
+    ImU32                   ActiveIdUsingNavInputMask;          // Active widget will want to read those nav inputs.
+    ImU64                   ActiveIdUsingKeyInputMask;          // Active widget will want to read those key inputs. When we grow the ImGuiKey enum we'll need to either to order the enum to make useful keys come first, either redesign this into e.g. a small array.
+    ImVec2                  ActiveIdClickOffset;                // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
+    ImGuiWindow*            ActiveIdWindow;
+    ImGuiInputSource        ActiveIdSource;                     // Activating with mouse or nav (gamepad/keyboard)
+    int                     ActiveIdMouseButton;
+    ImGuiID                 ActiveIdPreviousFrame;
+    bool                    ActiveIdPreviousFrameIsAlive;
+    bool                    ActiveIdPreviousFrameHasBeenEditedBefore;
+    ImGuiWindow*            ActiveIdPreviousFrameWindow;
+    ImGuiID                 LastActiveId;                       // Store the last non-zero ActiveId, useful for animation.
+    float                   LastActiveIdTimer;                  // Store the last non-zero ActiveId timer since the beginning of activation, useful for animation.
+
+    // Next window/item data
+    ImGuiItemFlags          CurrentItemFlags;                      // == g.ItemFlagsStack.back()
+    ImGuiNextItemData       NextItemData;                       // Storage for SetNextItem** functions
+    ImGuiLastItemData       LastItemData;                       // Storage for last submitted item (setup by ItemAdd)
+    ImGuiNextWindowData     NextWindowData;                     // Storage for SetNextWindow** functions
+
+    // Shared stacks
+    ImVector<ImGuiColorMod> ColorStack;                         // Stack for PushStyleColor()/PopStyleColor() - inherited by Begin()
+    ImVector<ImGuiStyleMod> StyleVarStack;                      // Stack for PushStyleVar()/PopStyleVar() - inherited by Begin()
+    ImVector<ImFont*>       FontStack;                          // Stack for PushFont()/PopFont() - inherited by Begin()
+    ImVector<ImGuiID>       FocusScopeStack;                    // Stack for PushFocusScope()/PopFocusScope() - not inherited by Begin(), unless child window
+    ImVector<ImGuiItemFlags>ItemFlagsStack;                     // Stack for PushItemFlag()/PopItemFlag() - inherited by Begin()
+    ImVector<ImGuiGroupData>GroupStack;                         // Stack for BeginGroup()/EndGroup() - not inherited by Begin()
+    ImVector<ImGuiPopupData>OpenPopupStack;                     // Which popups are open (persistent)
+    ImVector<ImGuiPopupData>BeginPopupStack;                    // Which level of BeginPopup() we are in (reset every frame)
+
+    // Viewports
+    ImVector<ImGuiViewportP*> Viewports;                        // Active viewports (Size==1 in 'master' branch). Each viewports hold their copy of ImDrawData.
+
+    // Gamepad/keyboard Navigation
+    ImGuiWindow*            NavWindow;                          // Focused window for navigation. Could be called 'FocusWindow'
+    ImGuiID                 NavId;                              // Focused item for navigation
+    ImGuiID                 NavFocusScopeId;                    // Identify a selection scope (selection code often wants to "clear other items" when landing on an item of the selection set)
+    ImGuiID                 NavActivateId;                      // ~~ (g.ActiveId == 0) && IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0, also set when calling ActivateItem()
+    ImGuiID                 NavActivateDownId;                  // ~~ IsNavInputDown(ImGuiNavInput_Activate) ? NavId : 0
+    ImGuiID                 NavActivatePressedId;               // ~~ IsNavInputPressed(ImGuiNavInput_Activate) ? NavId : 0
+    ImGuiID                 NavActivateInputId;                 // ~~ IsNavInputPressed(ImGuiNavInput_Input) ? NavId : 0; ImGuiActivateFlags_PreferInput will be set and NavActivateId will be 0.
+    ImGuiActivateFlags      NavActivateFlags;
+    ImGuiID                 NavJustTabbedId;                    // Just tabbed to this id.
+    ImGuiID                 NavJustMovedToId;                   // Just navigated to this id (result of a successfully MoveRequest).
+    ImGuiID                 NavJustMovedToFocusScopeId;         // Just navigated to this focus scope id (result of a successfully MoveRequest).
+    ImGuiKeyModFlags        NavJustMovedToKeyMods;
+    ImGuiID                 NavNextActivateId;                  // Set by ActivateItem(), queued until next frame.
+    ImGuiActivateFlags      NavNextActivateFlags;
+    ImGuiInputSource        NavInputSource;                     // Keyboard or Gamepad mode? THIS WILL ONLY BE None or NavGamepad or NavKeyboard.
+    ImGuiNavLayer           NavLayer;                           // Layer we are navigating on. For now the system is hard-coded for 0=main contents and 1=menu/title bar, may expose layers later.
+    int                     NavIdTabCounter;                    // == NavWindow->DC.FocusIdxTabCounter at time of NavId processing
+    bool                    NavIdIsAlive;                       // Nav widget has been seen this frame ~~ NavRectRel is valid
+    bool                    NavMousePosDirty;                   // When set we will update mouse position if (io.ConfigFlags & ImGuiConfigFlags_NavEnableSetMousePos) if set (NB: this not enabled by default)
+    bool                    NavDisableHighlight;                // When user starts using mouse, we hide gamepad/keyboard highlight (NB: but they are still available, which is why NavDisableHighlight isn't always != NavDisableMouseHover)
+    bool                    NavDisableMouseHover;               // When user starts using gamepad/keyboard, we hide mouse hovering highlight until mouse is touched again.
+
+    // Navigation: Init & Move Requests
+    bool                    NavAnyRequest;                      // ~~ NavMoveRequest || NavInitRequest this is to perform early out in ItemAdd()
+    bool                    NavInitRequest;                     // Init request for appearing window to select first item
+    bool                    NavInitRequestFromMove;
+    ImGuiID                 NavInitResultId;                    // Init request result (first item of the window, or one for which SetItemDefaultFocus() was called)
+    ImRect                  NavInitResultRectRel;               // Init request result rectangle (relative to parent window)
+    bool                    NavMoveSubmitted;                   // Move request submitted, will process result on next NewFrame()
+    bool                    NavMoveScoringItems;                // Move request submitted, still scoring incoming items
+    bool                    NavMoveForwardToNextFrame;
+    ImGuiNavMoveFlags       NavMoveFlags;
+    ImGuiScrollFlags        NavMoveScrollFlags;
+    ImGuiKeyModFlags        NavMoveKeyMods;
+    ImGuiDir                NavMoveDir;                         // Direction of the move request (left/right/up/down)
+    ImGuiDir                NavMoveDirForDebug;
+    ImGuiDir                NavMoveClipDir;                     // FIXME-NAV: Describe the purpose of this better. Might want to rename?
+    ImRect                  NavScoringRect;                     // Rectangle used for scoring, in screen space. Based of window->NavRectRel[], modified for directional navigation scoring.
+    int                     NavScoringDebugCount;               // Metrics for debugging
+    int                     NavTabbingInputableRemaining;       // >0 when counting items for tabbing
+    ImGuiNavItemData        NavMoveResultLocal;                 // Best move request candidate within NavWindow
+    ImGuiNavItemData        NavMoveResultLocalVisible;          // Best move request candidate within NavWindow that are mostly visible (when using ImGuiNavMoveFlags_AlsoScoreVisibleSet flag)
+    ImGuiNavItemData        NavMoveResultOther;                 // Best move request candidate within NavWindow's flattened hierarchy (when using ImGuiWindowFlags_NavFlattened flag)
+
+    // Navigation: Windowing (CTRL+TAB for list, or Menu button + keys or directional pads to move/resize)
+    ImGuiWindow*            NavWindowingTarget;                 // Target window when doing CTRL+Tab (or Pad Menu + FocusPrev/Next), this window is temporarily displayed top-most!
+    ImGuiWindow*            NavWindowingTargetAnim;             // Record of last valid NavWindowingTarget until DimBgRatio and NavWindowingHighlightAlpha becomes 0.0f, so the fade-out can stay on it.
+    ImGuiWindow*            NavWindowingListWindow;             // Internal window actually listing the CTRL+Tab contents
+    float                   NavWindowingTimer;
+    float                   NavWindowingHighlightAlpha;
+    bool                    NavWindowingToggleLayer;
+
+    // Legacy Focus/Tabbing system (older than Nav, active even if Nav is disabled, misnamed. FIXME-NAV: This needs a redesign!)
+    ImGuiWindow*            TabFocusRequestCurrWindow;          //
+    ImGuiWindow*            TabFocusRequestNextWindow;          //
+    int                     TabFocusRequestCurrCounterTabStop;  // Tab item being requested for focus, stored as an index
+    int                     TabFocusRequestNextCounterTabStop;  // "
+    bool                    TabFocusPressed;                    // Set in NewFrame() when user pressed Tab
+
+    // Render
+    float                   DimBgRatio;                         // 0.0..1.0 animation when fading in a dimming background (for modal window and CTRL+TAB list)
+    ImGuiMouseCursor        MouseCursor;
+
+    // Drag and Drop
+    bool                    DragDropActive;
+    bool                    DragDropWithinSource;               // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag source.
+    bool                    DragDropWithinTarget;               // Set when within a BeginDragDropXXX/EndDragDropXXX block for a drag target.
+    ImGuiDragDropFlags      DragDropSourceFlags;
+    int                     DragDropSourceFrameCount;
+    int                     DragDropMouseButton;
+    ImGuiPayload            DragDropPayload;
+    ImRect                  DragDropTargetRect;                 // Store rectangle of current target candidate (we favor small targets when overlapping)
+    ImGuiID                 DragDropTargetId;
+    ImGuiDragDropFlags      DragDropAcceptFlags;
+    float                   DragDropAcceptIdCurrRectSurface;    // Target item surface (we resolve overlapping targets by prioritizing the smaller surface)
+    ImGuiID                 DragDropAcceptIdCurr;               // Target item id (set at the time of accepting the payload)
+    ImGuiID                 DragDropAcceptIdPrev;               // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
+    int                     DragDropAcceptFrameCount;           // Last time a target expressed a desire to accept the source
+    ImGuiID                 DragDropHoldJustPressedId;          // Set when holding a payload just made ButtonBehavior() return a press.
+    ImVector<unsigned char> DragDropPayloadBufHeap;             // We don't expose the ImVector<> directly, ImGuiPayload only holds pointer+size
+    unsigned char           DragDropPayloadBufLocal[16];        // Local buffer for small payloads
+
+    // Table
+    ImGuiTable*                     CurrentTable;
+    int                             CurrentTableStackIdx;
+    ImPool<ImGuiTable>              Tables;
+    ImVector<ImGuiTableTempData>    TablesTempDataStack;
+    ImVector<float>                 TablesLastTimeActive;       // Last used timestamp of each tables (SOA, for efficient GC)
+    ImVector<ImDrawChannel>         DrawChannelsTempMergeBuffer;
+
+    // Tab bars
+    ImGuiTabBar*                    CurrentTabBar;
+    ImPool<ImGuiTabBar>             TabBars;
+    ImVector<ImGuiPtrOrIndex>       CurrentTabBarStack;
+    ImVector<ImGuiShrinkWidthItem>  ShrinkWidthBuffer;
+
+    // Widget state
+    ImVec2                  MouseLastValidPos;
+    ImGuiInputTextState     InputTextState;
+    ImFont                  InputTextPasswordFont;
+    ImGuiID                 TempInputId;                        // Temporary text input when CTRL+clicking on a slider, etc.
+    ImGuiColorEditFlags     ColorEditOptions;                   // Store user options for color edit widgets
+    float                   ColorEditLastHue;                   // Backup of last Hue associated to LastColor, so we can restore Hue in lossy RGB<>HSV round trips
+    float                   ColorEditLastSat;                   // Backup of last Saturation associated to LastColor, so we can restore Saturation in lossy RGB<>HSV round trips
+    ImU32                   ColorEditLastColor;                 // RGB value with alpha set to 0.
+    ImVec4                  ColorPickerRef;                     // Initial/reference color at the time of opening the color picker.
+    ImGuiComboPreviewData   ComboPreviewData;
+    float                   SliderCurrentAccum;                 // Accumulated slider delta when using navigation controls.
+    bool                    SliderCurrentAccumDirty;            // Has the accumulated slider delta changed since last time we tried to apply it?
+    bool                    DragCurrentAccumDirty;
+    float                   DragCurrentAccum;                   // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
+    float                   DragSpeedDefaultRatio;              // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
+    float                   ScrollbarClickDeltaToGrabCenter;    // Distance between mouse and center of grab box, normalized in parent space. Use storage?
+    float                   DisabledAlphaBackup;                // Backup for style.Alpha for BeginDisabled()
+    short                   DisabledStackSize;
+    short                   TooltipOverrideCount;
+    float                   TooltipSlowDelay;                   // Time before slow tooltips appears (FIXME: This is temporary until we merge in tooltip timer+priority work)
+    ImVector<char>          ClipboardHandlerData;               // If no custom clipboard handler is defined
+    ImVector<ImGuiID>       MenusIdSubmittedThisFrame;          // A list of menu IDs that were rendered at least once
+
+    // Platform support
+    ImVec2                  PlatformImePos;                     // Cursor position request & last passed to the OS Input Method Editor
+    ImVec2                  PlatformImeLastPos;
+    char                    PlatformLocaleDecimalPoint;         // '.' or *localeconv()->decimal_point
+
+    // Settings
+    bool                    SettingsLoaded;
+    float                   SettingsDirtyTimer;                 // Save .ini Settings to memory when time reaches zero
+    ImGuiTextBuffer         SettingsIniData;                    // In memory .ini settings
+    ImVector<ImGuiSettingsHandler>      SettingsHandlers;       // List of .ini settings handlers
+    ImChunkStream<ImGuiWindowSettings>  SettingsWindows;        // ImGuiWindow .ini settings entries
+    ImChunkStream<ImGuiTableSettings>   SettingsTables;         // ImGuiTable .ini settings entries
+    ImVector<ImGuiContextHook>          Hooks;                  // Hooks for extensions (e.g. test engine)
+    ImGuiID                             HookIdNext;             // Next available HookId
+
+    // Capture/Logging
+    bool                    LogEnabled;                         // Currently capturing
+    ImGuiLogType            LogType;                            // Capture target
+    ImFileHandle            LogFile;                            // If != NULL log to stdout/ file
+    ImGuiTextBuffer         LogBuffer;                          // Accumulation buffer when log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
+    const char*             LogNextPrefix;
+    const char*             LogNextSuffix;
+    float                   LogLinePosY;
+    bool                    LogLineFirstItem;
+    int                     LogDepthRef;
+    int                     LogDepthToExpand;
+    int                     LogDepthToExpandDefault;            // Default/stored value for LogDepthMaxExpand if not specified in the LogXXX function call.
+
+    // Debug Tools
+    bool                    DebugItemPickerActive;              // Item picker is active (started with DebugStartItemPicker())
+    ImGuiID                 DebugItemPickerBreakId;             // Will call IM_DEBUG_BREAK() when encountering this ID
+    ImGuiMetricsConfig      DebugMetricsConfig;
+    ImGuiStackTool          DebugStackTool;
+
+    // Misc
+    float                   FramerateSecPerFrame[120];          // Calculate estimate of framerate for user over the last 2 seconds.
+    int                     FramerateSecPerFrameIdx;
+    int                     FramerateSecPerFrameCount;
+    float                   FramerateSecPerFrameAccum;
+    int                     WantCaptureMouseNextFrame;          // Explicit capture via CaptureKeyboardFromApp()/CaptureMouseFromApp() sets those flags
+    int                     WantCaptureKeyboardNextFrame;
+    int                     WantTextInputNextFrame;
+    char                    TempBuffer[1024 * 3 + 1];           // Temporary text buffer
+
+    ImGuiContext(ImFontAtlas* shared_font_atlas)
+    {
+        Initialized = false;
+        FontAtlasOwnedByContext = shared_font_atlas ? false : true;
+        Font = NULL;
+        FontSize = FontBaseSize = 0.0f;
+        IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(ImFontAtlas)();
+        Time = 0.0f;
+        FrameCount = 0;
+        FrameCountEnded = FrameCountRendered = -1;
+        WithinFrameScope = WithinFrameScopeWithImplicitWindow = WithinEndChild = false;
+        GcCompactAll = false;
+        TestEngineHookItems = false;
+        TestEngine = NULL;
+
+        WindowsActiveCount = 0;
+        CurrentWindow = NULL;
+        HoveredWindow = NULL;
+        HoveredWindowUnderMovingWindow = NULL;
+        MovingWindow = NULL;
+        WheelingWindow = NULL;
+        WheelingWindowTimer = 0.0f;
+
+        DebugHookIdInfo = 0;
+        HoveredId = HoveredIdPreviousFrame = 0;
+        HoveredIdAllowOverlap = false;
+        HoveredIdUsingMouseWheel = HoveredIdPreviousFrameUsingMouseWheel = false;
+        HoveredIdDisabled = false;
+        HoveredIdTimer = HoveredIdNotActiveTimer = 0.0f;
+        ActiveId = 0;
+        ActiveIdIsAlive = 0;
+        ActiveIdTimer = 0.0f;
+        ActiveIdIsJustActivated = false;
+        ActiveIdAllowOverlap = false;
+        ActiveIdNoClearOnFocusLoss = false;
+        ActiveIdHasBeenPressedBefore = false;
+        ActiveIdHasBeenEditedBefore = false;
+        ActiveIdHasBeenEditedThisFrame = false;
+        ActiveIdUsingMouseWheel = false;
+        ActiveIdUsingNavDirMask = 0x00;
+        ActiveIdUsingNavInputMask = 0x00;
+        ActiveIdUsingKeyInputMask = 0x00;
+        ActiveIdClickOffset = ImVec2(-1, -1);
+        ActiveIdWindow = NULL;
+        ActiveIdSource = ImGuiInputSource_None;
+        ActiveIdMouseButton = -1;
+        ActiveIdPreviousFrame = 0;
+        ActiveIdPreviousFrameIsAlive = false;
+        ActiveIdPreviousFrameHasBeenEditedBefore = false;
+        ActiveIdPreviousFrameWindow = NULL;
+        LastActiveId = 0;
+        LastActiveIdTimer = 0.0f;
+
+        CurrentItemFlags = ImGuiItemFlags_None;
+
+        NavWindow = NULL;
+        NavId = NavFocusScopeId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavActivateInputId = 0;
+        NavJustTabbedId = NavJustMovedToId = NavJustMovedToFocusScopeId = NavNextActivateId = 0;
+        NavActivateFlags = NavNextActivateFlags = ImGuiActivateFlags_None;
+        NavJustMovedToKeyMods = ImGuiKeyModFlags_None;
+        NavInputSource = ImGuiInputSource_None;
+        NavLayer = ImGuiNavLayer_Main;
+        NavIdTabCounter = INT_MAX;
+        NavIdIsAlive = false;
+        NavMousePosDirty = false;
+        NavDisableHighlight = true;
+        NavDisableMouseHover = false;
+        NavAnyRequest = false;
+        NavInitRequest = false;
+        NavInitRequestFromMove = false;
+        NavInitResultId = 0;
+        NavMoveSubmitted = false;
+        NavMoveScoringItems = false;
+        NavMoveForwardToNextFrame = false;
+        NavMoveFlags = ImGuiNavMoveFlags_None;
+        NavMoveScrollFlags = ImGuiScrollFlags_None;
+        NavMoveKeyMods = ImGuiKeyModFlags_None;
+        NavMoveDir = NavMoveDirForDebug = NavMoveClipDir = ImGuiDir_None;
+        NavScoringDebugCount = 0;
+        NavTabbingInputableRemaining = 0;
+
+        NavWindowingTarget = NavWindowingTargetAnim = NavWindowingListWindow = NULL;
+        NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
+        NavWindowingToggleLayer = false;
+
+        TabFocusRequestCurrWindow = TabFocusRequestNextWindow = NULL;
+        TabFocusRequestCurrCounterTabStop = INT_MAX;
+        TabFocusRequestNextCounterTabStop = INT_MAX;
+        TabFocusPressed = false;
+
+        DimBgRatio = 0.0f;
+        MouseCursor = ImGuiMouseCursor_Arrow;
+
+        DragDropActive = DragDropWithinSource = DragDropWithinTarget = false;
+        DragDropSourceFlags = ImGuiDragDropFlags_None;
+        DragDropSourceFrameCount = -1;
+        DragDropMouseButton = -1;
+        DragDropTargetId = 0;
+        DragDropAcceptFlags = ImGuiDragDropFlags_None;
+        DragDropAcceptIdCurrRectSurface = 0.0f;
+        DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
+        DragDropAcceptFrameCount = -1;
+        DragDropHoldJustPressedId = 0;
+        memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
+
+        CurrentTable = NULL;
+        CurrentTableStackIdx = -1;
+        CurrentTabBar = NULL;
+
+        TempInputId = 0;
+        ColorEditOptions = ImGuiColorEditFlags_DefaultOptions_;
+        ColorEditLastHue = ColorEditLastSat = 0.0f;
+        ColorEditLastColor = 0;
+        SliderCurrentAccum = 0.0f;
+        SliderCurrentAccumDirty = false;
+        DragCurrentAccumDirty = false;
+        DragCurrentAccum = 0.0f;
+        DragSpeedDefaultRatio = 1.0f / 100.0f;
+        DisabledAlphaBackup = 0.0f;
+        DisabledStackSize = 0;
+        ScrollbarClickDeltaToGrabCenter = 0.0f;
+        TooltipOverrideCount = 0;
+        TooltipSlowDelay = 0.50f;
+
+        PlatformImePos = PlatformImeLastPos = ImVec2(FLT_MAX, FLT_MAX);
+        PlatformLocaleDecimalPoint = '.';
+
+        SettingsLoaded = false;
+        SettingsDirtyTimer = 0.0f;
+        HookIdNext = 0;
+
+        LogEnabled = false;
+        LogType = ImGuiLogType_None;
+        LogNextPrefix = LogNextSuffix = NULL;
+        LogFile = NULL;
+        LogLinePosY = FLT_MAX;
+        LogLineFirstItem = false;
+        LogDepthRef = 0;
+        LogDepthToExpand = LogDepthToExpandDefault = 2;
+
+        DebugItemPickerActive = false;
+        DebugItemPickerBreakId = 0;
+
+        memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
+        FramerateSecPerFrameIdx = FramerateSecPerFrameCount = 0;
+        FramerateSecPerFrameAccum = 0.0f;
+        WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
+        memset(TempBuffer, 0, sizeof(TempBuffer));
+    }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImGuiWindowTempData, ImGuiWindow
+//-----------------------------------------------------------------------------
+
+// Transient per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the DC variable name in ImGuiWindow.
+// (That's theory, in practice the delimitation between ImGuiWindow and ImGuiWindowTempData is quite tenuous and could be reconsidered..)
+// (This doesn't need a constructor because we zero-clear it as part of ImGuiWindow and all frame-temporary data are setup on Begin)
+struct IMGUI_API ImGuiWindowTempData
+{
+    // Layout
+    ImVec2                  CursorPos;              // Current emitting position, in absolute coordinates.
+    ImVec2                  CursorPosPrevLine;
+    ImVec2                  CursorStartPos;         // Initial position after Begin(), generally ~ window position + WindowPadding.
+    ImVec2                  CursorMaxPos;           // Used to implicitly calculate ContentSize at the beginning of next frame, for scrolling range and auto-resize. Always growing during the frame.
+    ImVec2                  IdealMaxPos;            // Used to implicitly calculate ContentSizeIdeal at the beginning of next frame, for auto-resize only. Always growing during the frame.
+    ImVec2                  CurrLineSize;
+    ImVec2                  PrevLineSize;
+    float                   CurrLineTextBaseOffset; // Baseline offset (0.0f by default on a new line, generally == style.FramePadding.y when a framed item has been added).
+    float                   PrevLineTextBaseOffset;
+    ImVec1                  Indent;                 // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
+    ImVec1                  ColumnsOffset;          // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
+    ImVec1                  GroupOffset;
+
+    // Keyboard/Gamepad navigation
+    ImGuiNavLayer           NavLayerCurrent;        // Current layer, 0..31 (we currently only use 0..1)
+    short                   NavLayersActiveMask;    // Which layers have been written to (result from previous frame)
+    short                   NavLayersActiveMaskNext;// Which layers have been written to (accumulator for current frame)
+    ImGuiID                 NavFocusScopeIdCurrent; // Current focus scope ID while appending
+    bool                    NavHideHighlightOneFrame;
+    bool                    NavHasScroll;           // Set when scrolling can be used (ScrollMax > 0.0f)
+
+    // Miscellaneous
+    bool                    MenuBarAppending;       // FIXME: Remove this
+    ImVec2                  MenuBarOffset;          // MenuBarOffset.x is sort of equivalent of a per-layer CursorPos.x, saved/restored as we switch to the menu bar. The only situation when MenuBarOffset.y is > 0 if when (SafeAreaPadding.y > FramePadding.y), often used on TVs.
+    ImGuiMenuColumns        MenuColumns;            // Simplified columns storage for menu items measurement
+    int                     TreeDepth;              // Current tree depth.
+    ImU32                   TreeJumpToParentOnPopMask; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31.. Could be turned into a ImU64 if necessary.
+    ImVector<ImGuiWindow*>  ChildWindows;
+    ImGuiStorage*           StateStorage;           // Current persistent per-window storage (store e.g. tree node open/close state)
+    ImGuiOldColumns*        CurrentColumns;         // Current columns set
+    int                     CurrentTableIdx;        // Current table index (into g.Tables)
+    ImGuiLayoutType         LayoutType;
+    ImGuiLayoutType         ParentLayoutType;       // Layout type of parent window at the time of Begin()
+    int                     FocusCounterTabStop;    // (Legacy Focus/Tabbing system) Same, but only count widgets which you can Tab through.
+
+    // Local parameters stacks
+    // We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
+    float                   ItemWidth;              // Current item width (>0.0: width in pixels, <0.0: align xx pixels to the right of window).
+    float                   TextWrapPos;            // Current text wrap pos.
+    ImVector<float>         ItemWidthStack;         // Store item widths to restore (attention: .back() is not == ItemWidth)
+    ImVector<float>         TextWrapPosStack;       // Store text wrap pos to restore (attention: .back() is not == TextWrapPos)
+};
+
+// Storage for one window
+struct IMGUI_API ImGuiWindow
+{
+    char*                   Name;                               // Window name, owned by the window.
+    ImGuiID                 ID;                                 // == ImHashStr(Name)
+    ImGuiWindowFlags        Flags;                              // See enum ImGuiWindowFlags_
+    ImVec2                  Pos;                                // Position (always rounded-up to nearest pixel)
+    ImVec2                  Size;                               // Current size (==SizeFull or collapsed title bar size)
+    ImVec2                  SizeFull;                           // Size when non collapsed
+    ImVec2                  ContentSize;                        // Size of contents/scrollable client area (calculated from the extents reach of the cursor) from previous frame. Does not include window decoration or window padding.
+    ImVec2                  ContentSizeIdeal;
+    ImVec2                  ContentSizeExplicit;                // Size of contents/scrollable client area explicitly request by the user via SetNextWindowContentSize().
+    ImVec2                  WindowPadding;                      // Window padding at the time of Begin().
+    float                   WindowRounding;                     // Window rounding at the time of Begin(). May be clamped lower to avoid rendering artifacts with title bar, menu bar etc.
+    float                   WindowBorderSize;                   // Window border size at the time of Begin().
+    int                     NameBufLen;                         // Size of buffer storing Name. May be larger than strlen(Name)!
+    ImGuiID                 MoveId;                             // == window->GetID("#MOVE")
+    ImGuiID                 ChildId;                            // ID of corresponding item in parent window (for navigation to return from child window to parent window)
+    ImVec2                  Scroll;
+    ImVec2                  ScrollMax;
+    ImVec2                  ScrollTarget;                       // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
+    ImVec2                  ScrollTargetCenterRatio;            // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
+    ImVec2                  ScrollTargetEdgeSnapDist;           // 0.0f = no snapping, >0.0f snapping threshold
+    ImVec2                  ScrollbarSizes;                     // Size taken by each scrollbars on their smaller axis. Pay attention! ScrollbarSizes.x == width of the vertical scrollbar, ScrollbarSizes.y = height of the horizontal scrollbar.
+    bool                    ScrollbarX, ScrollbarY;             // Are scrollbars visible?
+    bool                    Active;                             // Set to true on Begin(), unless Collapsed
+    bool                    WasActive;
+    bool                    WriteAccessed;                      // Set to true when any widget access the current window
+    bool                    Collapsed;                          // Set when collapsing window to become only title-bar
+    bool                    WantCollapseToggle;
+    bool                    SkipItems;                          // Set when items can safely be all clipped (e.g. window not visible or collapsed)
+    bool                    Appearing;                          // Set during the frame where the window is appearing (or re-appearing)
+    bool                    Hidden;                             // Do not display (== HiddenFrames*** > 0)
+    bool                    IsFallbackWindow;                   // Set on the "Debug##Default" window.
+    bool                    HasCloseButton;                     // Set when the window has a close button (p_open != NULL)
+    signed char             ResizeBorderHeld;                   // Current border being held for resize (-1: none, otherwise 0-3)
+    short                   BeginCount;                         // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
+    short                   BeginOrderWithinParent;             // Begin() order within immediate parent window, if we are a child window. Otherwise 0.
+    short                   BeginOrderWithinContext;            // Begin() order within entire imgui context. This is mostly used for debugging submission order related issues.
+    short                   FocusOrder;                         // Order within WindowsFocusOrder[], altered when windows are focused.
+    ImGuiID                 PopupId;                            // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
+    ImS8                    AutoFitFramesX, AutoFitFramesY;
+    ImS8                    AutoFitChildAxises;
+    bool                    AutoFitOnlyGrows;
+    ImGuiDir                AutoPosLastDirection;
+    ImS8                    HiddenFramesCanSkipItems;           // Hide the window for N frames
+    ImS8                    HiddenFramesCannotSkipItems;        // Hide the window for N frames while allowing items to be submitted so we can measure their size
+    ImS8                    HiddenFramesForRenderOnly;          // Hide the window until frame N at Render() time only
+    ImS8                    DisableInputsFrames;                // Disable window interactions for N frames
+    ImGuiCond               SetWindowPosAllowFlags : 8;         // store acceptable condition flags for SetNextWindowPos() use.
+    ImGuiCond               SetWindowSizeAllowFlags : 8;        // store acceptable condition flags for SetNextWindowSize() use.
+    ImGuiCond               SetWindowCollapsedAllowFlags : 8;   // store acceptable condition flags for SetNextWindowCollapsed() use.
+    ImVec2                  SetWindowPosVal;                    // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
+    ImVec2                  SetWindowPosPivot;                  // store window pivot for positioning. ImVec2(0, 0) when positioning from top-left corner; ImVec2(0.5f, 0.5f) for centering; ImVec2(1, 1) for bottom right.
+
+    ImVector<ImGuiID>       IDStack;                            // ID stack. ID are hashes seeded with the value at the top of the stack. (In theory this should be in the TempData structure)
+    ImGuiWindowTempData     DC;                                 // Temporary per-window data, reset at the beginning of the frame. This used to be called ImGuiDrawContext, hence the "DC" variable name.
+
+    // The best way to understand what those rectangles are is to use the 'Metrics->Tools->Show Windows Rectangles' viewer.
+    // The main 'OuterRect', omitted as a field, is window->Rect().
+    ImRect                  OuterRectClipped;                   // == Window->Rect() just after setup in Begin(). == window->Rect() for root window.
+    ImRect                  InnerRect;                          // Inner rectangle (omit title bar, menu bar, scroll bar)
+    ImRect                  InnerClipRect;                      // == InnerRect shrunk by WindowPadding*0.5f on each side, clipped within viewport or parent clip rect.
+    ImRect                  WorkRect;                           // Initially covers the whole scrolling region. Reduced by containers e.g columns/tables when active. Shrunk by WindowPadding*1.0f on each side. This is meant to replace ContentRegionRect over time (from 1.71+ onward).
+    ImRect                  ParentWorkRect;                     // Backup of WorkRect before entering a container such as columns/tables. Used by e.g. SpanAllColumns functions to easily access. Stacked containers are responsible for maintaining this. // FIXME-WORKRECT: Could be a stack?
+    ImRect                  ClipRect;                           // Current clipping/scissoring rectangle, evolve as we are using PushClipRect(), etc. == DrawList->clip_rect_stack.back().
+    ImRect                  ContentRegionRect;                  // FIXME: This is currently confusing/misleading. It is essentially WorkRect but not handling of scrolling. We currently rely on it as right/bottom aligned sizing operation need some size to rely on.
+    ImVec2ih                HitTestHoleSize;                    // Define an optional rectangular hole where mouse will pass-through the window.
+    ImVec2ih                HitTestHoleOffset;
+
+    int                     LastFrameActive;                    // Last frame number the window was Active.
+    float                   LastTimeActive;                     // Last timestamp the window was Active (using float as we don't need high precision there)
+    float                   ItemWidthDefault;
+    ImGuiStorage            StateStorage;
+    ImVector<ImGuiOldColumns> ColumnsStorage;
+    float                   FontWindowScale;                    // User scale multiplier per-window, via SetWindowFontScale()
+    int                     SettingsOffset;                     // Offset into SettingsWindows[] (offsets are always valid as we only grow the array from the back)
+
+    ImDrawList*             DrawList;                           // == &DrawListInst (for backward compatibility reason with code using imgui_internal.h we keep this a pointer)
+    ImDrawList              DrawListInst;
+    ImGuiWindow*            ParentWindow;                       // If we are a child _or_ popup _or_ docked window, this is pointing to our parent. Otherwise NULL.
+    ImGuiWindow*            RootWindow;                         // Point to ourself or first ancestor that is not a child window. Doesn't cross through popups/dock nodes.
+    ImGuiWindow*            RootWindowPopupTree;                // Point to ourself or first ancestor that is not a child window. Cross through popups parent<>child.
+    ImGuiWindow*            RootWindowForTitleBarHighlight;     // Point to ourself or first ancestor which will display TitleBgActive color when this window is active.
+    ImGuiWindow*            RootWindowForNav;                   // Point to ourself or first ancestor which doesn't have the NavFlattened flag.
+
+    ImGuiWindow*            NavLastChildNavWindow;              // When going to the menu bar, we remember the child window we came from. (This could probably be made implicit if we kept g.Windows sorted by last focused including child window.)
+    ImGuiID                 NavLastIds[ImGuiNavLayer_COUNT];    // Last known NavId for this window, per layer (0/1)
+    ImRect                  NavRectRel[ImGuiNavLayer_COUNT];    // Reference rectangle, in window relative space
+
+    int                     MemoryDrawListIdxCapacity;          // Backup of last idx/vtx count, so when waking up the window we can preallocate and avoid iterative alloc/copy
+    int                     MemoryDrawListVtxCapacity;
+    bool                    MemoryCompacted;                    // Set when window extraneous data have been garbage collected
+
+public:
+    ImGuiWindow(ImGuiContext* context, const char* name);
+    ~ImGuiWindow();
+
+    ImGuiID     GetID(const char* str, const char* str_end = NULL);
+    ImGuiID     GetID(const void* ptr);
+    ImGuiID     GetID(int n);
+    ImGuiID     GetIDNoKeepAlive(const char* str, const char* str_end = NULL);
+    ImGuiID     GetIDNoKeepAlive(const void* ptr);
+    ImGuiID     GetIDNoKeepAlive(int n);
+    ImGuiID     GetIDFromRectangle(const ImRect& r_abs);
+
+    // We don't use g.FontSize because the window may be != g.CurrentWidow.
+    ImRect      Rect() const            { return ImRect(Pos.x, Pos.y, Pos.x + Size.x, Pos.y + Size.y); }
+    float       CalcFontSize() const    { ImGuiContext& g = *GImGui; float scale = g.FontBaseSize * FontWindowScale; if (ParentWindow) scale *= ParentWindow->FontWindowScale; return scale; }
+    float       TitleBarHeight() const  { ImGuiContext& g = *GImGui; return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + g.Style.FramePadding.y * 2.0f; }
+    ImRect      TitleBarRect() const    { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); }
+    float       MenuBarHeight() const   { ImGuiContext& g = *GImGui; return (Flags & ImGuiWindowFlags_MenuBar) ? DC.MenuBarOffset.y + CalcFontSize() + g.Style.FramePadding.y * 2.0f : 0.0f; }
+    ImRect      MenuBarRect() const     { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Tab bar, Tab item support
+//-----------------------------------------------------------------------------
+
+// Extend ImGuiTabBarFlags_
+enum ImGuiTabBarFlagsPrivate_
+{
+    ImGuiTabBarFlags_DockNode                   = 1 << 20,  // Part of a dock node [we don't use this in the master branch but it facilitate branch syncing to keep this around]
+    ImGuiTabBarFlags_IsFocused                  = 1 << 21,
+    ImGuiTabBarFlags_SaveSettings               = 1 << 22   // FIXME: Settings are handled by the docking system, this only request the tab bar to mark settings dirty when reordering tabs
+};
+
+// Extend ImGuiTabItemFlags_
+enum ImGuiTabItemFlagsPrivate_
+{
+    ImGuiTabItemFlags_SectionMask_              = ImGuiTabItemFlags_Leading | ImGuiTabItemFlags_Trailing,
+    ImGuiTabItemFlags_NoCloseButton             = 1 << 20,  // Track whether p_open was set or not (we'll need this info on the next frame to recompute ContentWidth during layout)
+    ImGuiTabItemFlags_Button                    = 1 << 21   // Used by TabItemButton, change the tab item behavior to mimic a button
+};
+
+// Storage for one active tab item (sizeof() 40 bytes)
+struct ImGuiTabItem
+{
+    ImGuiID             ID;
+    ImGuiTabItemFlags   Flags;
+    int                 LastFrameVisible;
+    int                 LastFrameSelected;      // This allows us to infer an ordered list of the last activated tabs with little maintenance
+    float               Offset;                 // Position relative to beginning of tab
+    float               Width;                  // Width currently displayed
+    float               ContentWidth;           // Width of label, stored during BeginTabItem() call
+    ImS32               NameOffset;             // When Window==NULL, offset to name within parent ImGuiTabBar::TabsNames
+    ImS16               BeginOrder;             // BeginTabItem() order, used to re-order tabs after toggling ImGuiTabBarFlags_Reorderable
+    ImS16               IndexDuringLayout;      // Index only used during TabBarLayout()
+    bool                WantClose;              // Marked as closed by SetTabItemClosed()
+
+    ImGuiTabItem()      { memset(this, 0, sizeof(*this)); LastFrameVisible = LastFrameSelected = -1; NameOffset = -1; BeginOrder = IndexDuringLayout = -1; }
+};
+
+// Storage for a tab bar (sizeof() 152 bytes)
+struct ImGuiTabBar
+{
+    ImVector<ImGuiTabItem> Tabs;
+    ImGuiTabBarFlags    Flags;
+    ImGuiID             ID;                     // Zero for tab-bars used by docking
+    ImGuiID             SelectedTabId;          // Selected tab/window
+    ImGuiID             NextSelectedTabId;      // Next selected tab/window. Will also trigger a scrolling animation
+    ImGuiID             VisibleTabId;           // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)
+    int                 CurrFrameVisible;
+    int                 PrevFrameVisible;
+    ImRect              BarRect;
+    float               CurrTabsContentsHeight;
+    float               PrevTabsContentsHeight; // Record the height of contents submitted below the tab bar
+    float               WidthAllTabs;           // Actual width of all tabs (locked during layout)
+    float               WidthAllTabsIdeal;      // Ideal width if all tabs were visible and not clipped
+    float               ScrollingAnim;
+    float               ScrollingTarget;
+    float               ScrollingTargetDistToVisibility;
+    float               ScrollingSpeed;
+    float               ScrollingRectMinX;
+    float               ScrollingRectMaxX;
+    ImGuiID             ReorderRequestTabId;
+    ImS16               ReorderRequestOffset;
+    ImS8                BeginCount;
+    bool                WantLayout;
+    bool                VisibleTabWasSubmitted;
+    bool                TabsAddedNew;           // Set to true when a new tab item or button has been added to the tab bar during last frame
+    ImS16               TabsActiveCount;        // Number of tabs submitted this frame.
+    ImS16               LastTabItemIdx;         // Index of last BeginTabItem() tab for use by EndTabItem()
+    float               ItemSpacingY;
+    ImVec2              FramePadding;           // style.FramePadding locked at the time of BeginTabBar()
+    ImVec2              BackupCursorPos;
+    ImGuiTextBuffer     TabsNames;              // For non-docking tab bar we re-append names in a contiguous buffer.
+
+    ImGuiTabBar();
+    int                 GetTabOrder(const ImGuiTabItem* tab) const  { return Tabs.index_from_ptr(tab); }
+    const char*         GetTabName(const ImGuiTabItem* tab) const
+    {
+        IM_ASSERT(tab->NameOffset != -1 && tab->NameOffset < TabsNames.Buf.Size);
+        return TabsNames.Buf.Data + tab->NameOffset;
+    }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] Table support
+//-----------------------------------------------------------------------------
+
+#define IM_COL32_DISABLE                IM_COL32(0,0,0,1)   // Special sentinel code which cannot be used as a regular color.
+#define IMGUI_TABLE_MAX_COLUMNS         64                  // sizeof(ImU64) * 8. This is solely because we frequently encode columns set in a ImU64.
+#define IMGUI_TABLE_MAX_DRAW_CHANNELS   (4 + 64 * 2)        // See TableSetupDrawChannels()
+
+// Our current column maximum is 64 but we may raise that in the future.
+typedef ImS8 ImGuiTableColumnIdx;
+typedef ImU8 ImGuiTableDrawChannelIdx;
+
+// [Internal] sizeof() ~ 104
+// We use the terminology "Enabled" to refer to a column that is not Hidden by user/api.
+// We use the terminology "Clipped" to refer to a column that is out of sight because of scrolling/clipping.
+// This is in contrast with some user-facing api such as IsItemVisible() / IsRectVisible() which use "Visible" to mean "not clipped".
+struct ImGuiTableColumn
+{
+    ImGuiTableColumnFlags   Flags;                          // Flags after some patching (not directly same as provided by user). See ImGuiTableColumnFlags_
+    float                   WidthGiven;                     // Final/actual width visible == (MaxX - MinX), locked in TableUpdateLayout(). May be > WidthRequest to honor minimum width, may be < WidthRequest to honor shrinking columns down in tight space.
+    float                   MinX;                           // Absolute positions
+    float                   MaxX;
+    float                   WidthRequest;                   // Master width absolute value when !(Flags & _WidthStretch). When Stretch this is derived every frame from StretchWeight in TableUpdateLayout()
+    float                   WidthAuto;                      // Automatic width
+    float                   StretchWeight;                  // Master width weight when (Flags & _WidthStretch). Often around ~1.0f initially.
+    float                   InitStretchWeightOrWidth;       // Value passed to TableSetupColumn(). For Width it is a content width (_without padding_).
+    ImRect                  ClipRect;                       // Clipping rectangle for the column
+    ImGuiID                 UserID;                         // Optional, value passed to TableSetupColumn()
+    float                   WorkMinX;                       // Contents region min ~(MinX + CellPaddingX + CellSpacingX1) == cursor start position when entering column
+    float                   WorkMaxX;                       // Contents region max ~(MaxX - CellPaddingX - CellSpacingX2)
+    float                   ItemWidth;                      // Current item width for the column, preserved across rows
+    float                   ContentMaxXFrozen;              // Contents maximum position for frozen rows (apart from headers), from which we can infer content width.
+    float                   ContentMaxXUnfrozen;
+    float                   ContentMaxXHeadersUsed;         // Contents maximum position for headers rows (regardless of freezing). TableHeader() automatically softclip itself + report ideal desired size, to avoid creating extraneous draw calls
+    float                   ContentMaxXHeadersIdeal;
+    ImS16                   NameOffset;                     // Offset into parent ColumnsNames[]
+    ImGuiTableColumnIdx     DisplayOrder;                   // Index within Table's IndexToDisplayOrder[] (column may be reordered by users)
+    ImGuiTableColumnIdx     IndexWithinEnabledSet;          // Index within enabled/visible set (<= IndexToDisplayOrder)
+    ImGuiTableColumnIdx     PrevEnabledColumn;              // Index of prev enabled/visible column within Columns[], -1 if first enabled/visible column
+    ImGuiTableColumnIdx     NextEnabledColumn;              // Index of next enabled/visible column within Columns[], -1 if last enabled/visible column
+    ImGuiTableColumnIdx     SortOrder;                      // Index of this column within sort specs, -1 if not sorting on this column, 0 for single-sort, may be >0 on multi-sort
+    ImGuiTableDrawChannelIdx DrawChannelCurrent;            // Index within DrawSplitter.Channels[]
+    ImGuiTableDrawChannelIdx DrawChannelFrozen;             // Draw channels for frozen rows (often headers)
+    ImGuiTableDrawChannelIdx DrawChannelUnfrozen;           // Draw channels for unfrozen rows
+    bool                    IsEnabled;                      // IsUserEnabled && (Flags & ImGuiTableColumnFlags_Disabled) == 0
+    bool                    IsUserEnabled;                  // Is the column not marked Hidden by the user? (unrelated to being off view, e.g. clipped by scrolling).
+    bool                    IsUserEnabledNextFrame;
+    bool                    IsVisibleX;                     // Is actually in view (e.g. overlapping the host window clipping rectangle, not scrolled).
+    bool                    IsVisibleY;
+    bool                    IsRequestOutput;                // Return value for TableSetColumnIndex() / TableNextColumn(): whether we request user to output contents or not.
+    bool                    IsSkipItems;                    // Do we want item submissions to this column to be completely ignored (no layout will happen).
+    bool                    IsPreserveWidthAuto;
+    ImS8                    NavLayerCurrent;                // ImGuiNavLayer in 1 byte
+    ImU8                    AutoFitQueue;                   // Queue of 8 values for the next 8 frames to request auto-fit
+    ImU8                    CannotSkipItemsQueue;           // Queue of 8 values for the next 8 frames to disable Clipped/SkipItem
+    ImU8                    SortDirection : 2;              // ImGuiSortDirection_Ascending or ImGuiSortDirection_Descending
+    ImU8                    SortDirectionsAvailCount : 2;   // Number of available sort directions (0 to 3)
+    ImU8                    SortDirectionsAvailMask : 4;    // Mask of available sort directions (1-bit each)
+    ImU8                    SortDirectionsAvailList;        // Ordered of available sort directions (2-bits each)
+
+    ImGuiTableColumn()
+    {
+        memset(this, 0, sizeof(*this));
+        StretchWeight = WidthRequest = -1.0f;
+        NameOffset = -1;
+        DisplayOrder = IndexWithinEnabledSet = -1;
+        PrevEnabledColumn = NextEnabledColumn = -1;
+        SortOrder = -1;
+        SortDirection = ImGuiSortDirection_None;
+        DrawChannelCurrent = DrawChannelFrozen = DrawChannelUnfrozen = (ImU8)-1;
+    }
+};
+
+// Transient cell data stored per row.
+// sizeof() ~ 6
+struct ImGuiTableCellData
+{
+    ImU32                       BgColor;    // Actual color
+    ImGuiTableColumnIdx         Column;     // Column number
+};
+
+// FIXME-TABLE: more transient data could be stored in a per-stacked table structure: DrawSplitter, SortSpecs, incoming RowData
+struct ImGuiTable
+{
+    ImGuiID                     ID;
+    ImGuiTableFlags             Flags;
+    void*                       RawData;                    // Single allocation to hold Columns[], DisplayOrderToIndex[] and RowCellData[]
+    ImGuiTableTempData*         TempData;                   // Transient data while table is active. Point within g.CurrentTableStack[]
+    ImSpan<ImGuiTableColumn>    Columns;                    // Point within RawData[]
+    ImSpan<ImGuiTableColumnIdx> DisplayOrderToIndex;        // Point within RawData[]. Store display order of columns (when not reordered, the values are 0...Count-1)
+    ImSpan<ImGuiTableCellData>  RowCellData;                // Point within RawData[]. Store cells background requests for current row.
+    ImU64                       EnabledMaskByDisplayOrder;  // Column DisplayOrder -> IsEnabled map
+    ImU64                       EnabledMaskByIndex;         // Column Index -> IsEnabled map (== not hidden by user/api) in a format adequate for iterating column without touching cold data
+    ImU64                       VisibleMaskByIndex;         // Column Index -> IsVisibleX|IsVisibleY map (== not hidden by user/api && not hidden by scrolling/cliprect)
+    ImU64                       RequestOutputMaskByIndex;   // Column Index -> IsVisible || AutoFit (== expect user to submit items)
+    ImGuiTableFlags             SettingsLoadedFlags;        // Which data were loaded from the .ini file (e.g. when order is not altered we won't save order)
+    int                         SettingsOffset;             // Offset in g.SettingsTables
+    int                         LastFrameActive;
+    int                         ColumnsCount;               // Number of columns declared in BeginTable()
+    int                         CurrentRow;
+    int                         CurrentColumn;
+    ImS16                       InstanceCurrent;            // Count of BeginTable() calls with same ID in the same frame (generally 0). This is a little bit similar to BeginCount for a window, but multiple table with same ID look are multiple tables, they are just synched.
+    ImS16                       InstanceInteracted;         // Mark which instance (generally 0) of the same ID is being interacted with
+    float                       RowPosY1;
+    float                       RowPosY2;
+    float                       RowMinHeight;               // Height submitted to TableNextRow()
+    float                       RowTextBaseline;
+    float                       RowIndentOffsetX;
+    ImGuiTableRowFlags          RowFlags : 16;              // Current row flags, see ImGuiTableRowFlags_
+    ImGuiTableRowFlags          LastRowFlags : 16;
+    int                         RowBgColorCounter;          // Counter for alternating background colors (can be fast-forwarded by e.g clipper), not same as CurrentRow because header rows typically don't increase this.
+    ImU32                       RowBgColor[2];              // Background color override for current row.
+    ImU32                       BorderColorStrong;
+    ImU32                       BorderColorLight;
+    float                       BorderX1;
+    float                       BorderX2;
+    float                       HostIndentX;
+    float                       MinColumnWidth;
+    float                       OuterPaddingX;
+    float                       CellPaddingX;               // Padding from each borders
+    float                       CellPaddingY;
+    float                       CellSpacingX1;              // Spacing between non-bordered cells
+    float                       CellSpacingX2;
+    float                       LastOuterHeight;            // Outer height from last frame
+    float                       LastFirstRowHeight;         // Height of first row from last frame
+    float                       InnerWidth;                 // User value passed to BeginTable(), see comments at the top of BeginTable() for details.
+    float                       ColumnsGivenWidth;          // Sum of current column width
+    float                       ColumnsAutoFitWidth;        // Sum of ideal column width in order nothing to be clipped, used for auto-fitting and content width submission in outer window
+    float                       ResizedColumnNextWidth;
+    float                       ResizeLockMinContentsX2;    // Lock minimum contents width while resizing down in order to not create feedback loops. But we allow growing the table.
+    float                       RefScale;                   // Reference scale to be able to rescale columns on font/dpi changes.
+    ImRect                      OuterRect;                  // Note: for non-scrolling table, OuterRect.Max.y is often FLT_MAX until EndTable(), unless a height has been specified in BeginTable().
+    ImRect                      InnerRect;                  // InnerRect but without decoration. As with OuterRect, for non-scrolling tables, InnerRect.Max.y is
+    ImRect                      WorkRect;
+    ImRect                      InnerClipRect;
+    ImRect                      BgClipRect;                 // We use this to cpu-clip cell background color fill
+    ImRect                      Bg0ClipRectForDrawCmd;      // Actual ImDrawCmd clip rect for BG0/1 channel. This tends to be == OuterWindow->ClipRect at BeginTable() because output in BG0/BG1 is cpu-clipped
+    ImRect                      Bg2ClipRectForDrawCmd;      // Actual ImDrawCmd clip rect for BG2 channel. This tends to be a correct, tight-fit, because output to BG2 are done by widgets relying on regular ClipRect.
+    ImRect                      HostClipRect;               // This is used to check if we can eventually merge our columns draw calls into the current draw call of the current window.
+    ImRect                      HostBackupInnerClipRect;    // Backup of InnerWindow->ClipRect during PushTableBackground()/PopTableBackground()
+    ImGuiWindow*                OuterWindow;                // Parent window for the table
+    ImGuiWindow*                InnerWindow;                // Window holding the table data (== OuterWindow or a child window)
+    ImGuiTextBuffer             ColumnsNames;               // Contiguous buffer holding columns names
+    ImDrawListSplitter*         DrawSplitter;               // Shortcut to TempData->DrawSplitter while in table. Isolate draw commands per columns to avoid switching clip rect constantly
+    ImGuiTableColumnSortSpecs   SortSpecsSingle;
+    ImVector<ImGuiTableColumnSortSpecs> SortSpecsMulti;     // FIXME-OPT: Using a small-vector pattern would be good.
+    ImGuiTableSortSpecs         SortSpecs;                  // Public facing sorts specs, this is what we return in TableGetSortSpecs()
+    ImGuiTableColumnIdx         SortSpecsCount;
+    ImGuiTableColumnIdx         ColumnsEnabledCount;        // Number of enabled columns (<= ColumnsCount)
+    ImGuiTableColumnIdx         ColumnsEnabledFixedCount;   // Number of enabled columns (<= ColumnsCount)
+    ImGuiTableColumnIdx         DeclColumnsCount;           // Count calls to TableSetupColumn()
+    ImGuiTableColumnIdx         HoveredColumnBody;          // Index of column whose visible region is being hovered. Important: == ColumnsCount when hovering empty region after the right-most column!
+    ImGuiTableColumnIdx         HoveredColumnBorder;        // Index of column whose right-border is being hovered (for resizing).
+    ImGuiTableColumnIdx         AutoFitSingleColumn;        // Index of single column requesting auto-fit.
+    ImGuiTableColumnIdx         ResizedColumn;              // Index of column being resized. Reset when InstanceCurrent==0.
+    ImGuiTableColumnIdx         LastResizedColumn;          // Index of column being resized from previous frame.
+    ImGuiTableColumnIdx         HeldHeaderColumn;           // Index of column header being held.
+    ImGuiTableColumnIdx         ReorderColumn;              // Index of column being reordered. (not cleared)
+    ImGuiTableColumnIdx         ReorderColumnDir;           // -1 or +1
+    ImGuiTableColumnIdx         LeftMostEnabledColumn;      // Index of left-most non-hidden column.
+    ImGuiTableColumnIdx         RightMostEnabledColumn;     // Index of right-most non-hidden column.
+    ImGuiTableColumnIdx         LeftMostStretchedColumn;    // Index of left-most stretched column.
+    ImGuiTableColumnIdx         RightMostStretchedColumn;   // Index of right-most stretched column.
+    ImGuiTableColumnIdx         ContextPopupColumn;         // Column right-clicked on, of -1 if opening context menu from a neutral/empty spot
+    ImGuiTableColumnIdx         FreezeRowsRequest;          // Requested frozen rows count
+    ImGuiTableColumnIdx         FreezeRowsCount;            // Actual frozen row count (== FreezeRowsRequest, or == 0 when no scrolling offset)
+    ImGuiTableColumnIdx         FreezeColumnsRequest;       // Requested frozen columns count
+    ImGuiTableColumnIdx         FreezeColumnsCount;         // Actual frozen columns count (== FreezeColumnsRequest, or == 0 when no scrolling offset)
+    ImGuiTableColumnIdx         RowCellDataCurrent;         // Index of current RowCellData[] entry in current row
+    ImGuiTableDrawChannelIdx    DummyDrawChannel;           // Redirect non-visible columns here.
+    ImGuiTableDrawChannelIdx    Bg2DrawChannelCurrent;      // For Selectable() and other widgets drawing across columns after the freezing line. Index within DrawSplitter.Channels[]
+    ImGuiTableDrawChannelIdx    Bg2DrawChannelUnfrozen;
+    bool                        IsLayoutLocked;             // Set by TableUpdateLayout() which is called when beginning the first row.
+    bool                        IsInsideRow;                // Set when inside TableBeginRow()/TableEndRow().
+    bool                        IsInitializing;
+    bool                        IsSortSpecsDirty;
+    bool                        IsUsingHeaders;             // Set when the first row had the ImGuiTableRowFlags_Headers flag.
+    bool                        IsContextPopupOpen;         // Set when default context menu is open (also see: ContextPopupColumn, InstanceInteracted).
+    bool                        IsSettingsRequestLoad;
+    bool                        IsSettingsDirty;            // Set when table settings have changed and needs to be reported into ImGuiTableSetttings data.
+    bool                        IsDefaultDisplayOrder;      // Set when display order is unchanged from default (DisplayOrder contains 0...Count-1)
+    bool                        IsResetAllRequest;
+    bool                        IsResetDisplayOrderRequest;
+    bool                        IsUnfrozenRows;             // Set when we got past the frozen row.
+    bool                        IsDefaultSizingPolicy;      // Set if user didn't explicitly set a sizing policy in BeginTable()
+    bool                        MemoryCompacted;
+    bool                        HostSkipItems;              // Backup of InnerWindow->SkipItem at the end of BeginTable(), because we will overwrite InnerWindow->SkipItem on a per-column basis
+
+    IMGUI_API ImGuiTable()      { memset(this, 0, sizeof(*this)); LastFrameActive = -1; }
+    IMGUI_API ~ImGuiTable()     { IM_FREE(RawData); }
+};
+
+// Transient data that are only needed between BeginTable() and EndTable(), those buffers are shared (1 per level of stacked table).
+// - Accessing those requires chasing an extra pointer so for very frequently used data we leave them in the main table structure.
+// - We also leave out of this structure data that tend to be particularly useful for debugging/metrics.
+struct ImGuiTableTempData
+{
+    int                         TableIndex;                 // Index in g.Tables.Buf[] pool
+    float                       LastTimeActive;             // Last timestamp this structure was used
+
+    ImVec2                      UserOuterSize;              // outer_size.x passed to BeginTable()
+    ImDrawListSplitter          DrawSplitter;
+
+    ImRect                      HostBackupWorkRect;         // Backup of InnerWindow->WorkRect at the end of BeginTable()
+    ImRect                      HostBackupParentWorkRect;   // Backup of InnerWindow->ParentWorkRect at the end of BeginTable()
+    ImVec2                      HostBackupPrevLineSize;     // Backup of InnerWindow->DC.PrevLineSize at the end of BeginTable()
+    ImVec2                      HostBackupCurrLineSize;     // Backup of InnerWindow->DC.CurrLineSize at the end of BeginTable()
+    ImVec2                      HostBackupCursorMaxPos;     // Backup of InnerWindow->DC.CursorMaxPos at the end of BeginTable()
+    ImVec1                      HostBackupColumnsOffset;    // Backup of OuterWindow->DC.ColumnsOffset at the end of BeginTable()
+    float                       HostBackupItemWidth;        // Backup of OuterWindow->DC.ItemWidth at the end of BeginTable()
+    int                         HostBackupItemWidthStackSize;//Backup of OuterWindow->DC.ItemWidthStack.Size at the end of BeginTable()
+
+    IMGUI_API ImGuiTableTempData() { memset(this, 0, sizeof(*this)); LastTimeActive = -1.0f; }
+};
+
+// sizeof() ~ 12
+struct ImGuiTableColumnSettings
+{
+    float                   WidthOrWeight;
+    ImGuiID                 UserID;
+    ImGuiTableColumnIdx     Index;
+    ImGuiTableColumnIdx     DisplayOrder;
+    ImGuiTableColumnIdx     SortOrder;
+    ImU8                    SortDirection : 2;
+    ImU8                    IsEnabled : 1; // "Visible" in ini file
+    ImU8                    IsStretch : 1;
+
+    ImGuiTableColumnSettings()
+    {
+        WidthOrWeight = 0.0f;
+        UserID = 0;
+        Index = -1;
+        DisplayOrder = SortOrder = -1;
+        SortDirection = ImGuiSortDirection_None;
+        IsEnabled = 1;
+        IsStretch = 0;
+    }
+};
+
+// This is designed to be stored in a single ImChunkStream (1 header followed by N ImGuiTableColumnSettings, etc.)
+struct ImGuiTableSettings
+{
+    ImGuiID                     ID;                     // Set to 0 to invalidate/delete the setting
+    ImGuiTableFlags             SaveFlags;              // Indicate data we want to save using the Resizable/Reorderable/Sortable/Hideable flags (could be using its own flags..)
+    float                       RefScale;               // Reference scale to be able to rescale columns on font/dpi changes.
+    ImGuiTableColumnIdx         ColumnsCount;
+    ImGuiTableColumnIdx         ColumnsCountMax;        // Maximum number of columns this settings instance can store, we can recycle a settings instance with lower number of columns but not higher
+    bool                        WantApply;              // Set when loaded from .ini data (to enable merging/loading .ini data into an already running context)
+
+    ImGuiTableSettings()        { memset(this, 0, sizeof(*this)); }
+    ImGuiTableColumnSettings*   GetColumnSettings()     { return (ImGuiTableColumnSettings*)(this + 1); }
+};
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImGui internal API
+// No guarantee of forward compatibility here!
+//-----------------------------------------------------------------------------
+
+namespace ImGui
+{
+    // Windows
+    // We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
+    // If this ever crash because g.CurrentWindow is NULL it means that either
+    // - ImGui::NewFrame() has never been called, which is illegal.
+    // - You are calling ImGui functions after ImGui::EndFrame()/ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
+    inline    ImGuiWindow*  GetCurrentWindowRead()      { ImGuiContext& g = *GImGui; return g.CurrentWindow; }
+    inline    ImGuiWindow*  GetCurrentWindow()          { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
+    IMGUI_API ImGuiWindow*  FindWindowByID(ImGuiID id);
+    IMGUI_API ImGuiWindow*  FindWindowByName(const char* name);
+    IMGUI_API void          UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window);
+    IMGUI_API ImVec2        CalcWindowNextAutoFitSize(ImGuiWindow* window);
+    IMGUI_API bool          IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent, bool popup_hierarchy);
+    IMGUI_API bool          IsWindowAbove(ImGuiWindow* potential_above, ImGuiWindow* potential_below);
+    IMGUI_API bool          IsWindowNavFocusable(ImGuiWindow* window);
+    IMGUI_API void          SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiCond cond = 0);
+    IMGUI_API void          SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond = 0);
+    IMGUI_API void          SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiCond cond = 0);
+    IMGUI_API void          SetWindowHitTestHole(ImGuiWindow* window, const ImVec2& pos, const ImVec2& size);
+
+    // Windows: Display Order and Focus Order
+    IMGUI_API void          FocusWindow(ImGuiWindow* window);
+    IMGUI_API void          FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window);
+    IMGUI_API void          BringWindowToFocusFront(ImGuiWindow* window);
+    IMGUI_API void          BringWindowToDisplayFront(ImGuiWindow* window);
+    IMGUI_API void          BringWindowToDisplayBack(ImGuiWindow* window);
+
+    // Fonts, drawing
+    IMGUI_API void          SetCurrentFont(ImFont* font);
+    inline ImFont*          GetDefaultFont() { ImGuiContext& g = *GImGui; return g.IO.FontDefault ? g.IO.FontDefault : g.IO.Fonts->Fonts[0]; }
+    inline ImDrawList*      GetForegroundDrawList(ImGuiWindow* window) { IM_UNUSED(window); return GetForegroundDrawList(); } // This seemingly unnecessary wrapper simplifies compatibility between the 'master' and 'docking' branches.
+    IMGUI_API ImDrawList*   GetBackgroundDrawList(ImGuiViewport* viewport);                     // get background draw list for the given viewport. this draw list will be the first rendering one. Useful to quickly draw shapes/text behind dear imgui contents.
+    IMGUI_API ImDrawList*   GetForegroundDrawList(ImGuiViewport* viewport);                     // get foreground draw list for the given viewport. this draw list will be the last rendered one. Useful to quickly draw shapes/text over dear imgui contents.
+
+    // Init
+    IMGUI_API void          Initialize(ImGuiContext* context);
+    IMGUI_API void          Shutdown(ImGuiContext* context);    // Since 1.60 this is a _private_ function. You can call DestroyContext() to destroy the context created by CreateContext().
+
+    // NewFrame
+    IMGUI_API void          UpdateHoveredWindowAndCaptureFlags();
+    IMGUI_API void          StartMouseMovingWindow(ImGuiWindow* window);
+    IMGUI_API void          UpdateMouseMovingWindowNewFrame();
+    IMGUI_API void          UpdateMouseMovingWindowEndFrame();
+
+    // Generic context hooks
+    IMGUI_API ImGuiID       AddContextHook(ImGuiContext* context, const ImGuiContextHook* hook);
+    IMGUI_API void          RemoveContextHook(ImGuiContext* context, ImGuiID hook_to_remove);
+    IMGUI_API void          CallContextHooks(ImGuiContext* context, ImGuiContextHookType type);
+
+    // Settings
+    IMGUI_API void                  MarkIniSettingsDirty();
+    IMGUI_API void                  MarkIniSettingsDirty(ImGuiWindow* window);
+    IMGUI_API void                  ClearIniSettings();
+    IMGUI_API ImGuiWindowSettings*  CreateNewWindowSettings(const char* name);
+    IMGUI_API ImGuiWindowSettings*  FindWindowSettings(ImGuiID id);
+    IMGUI_API ImGuiWindowSettings*  FindOrCreateWindowSettings(const char* name);
+    IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(const char* type_name);
+
+    // Scrolling
+    IMGUI_API void          SetNextWindowScroll(const ImVec2& scroll); // Use -1.0f on one axis to leave as-is
+    IMGUI_API void          SetScrollX(ImGuiWindow* window, float scroll_x);
+    IMGUI_API void          SetScrollY(ImGuiWindow* window, float scroll_y);
+    IMGUI_API void          SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio);
+    IMGUI_API void          SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio);
+
+    // Early work-in-progress API (ScrollToItem() will become public)
+    IMGUI_API void          ScrollToItem(ImGuiScrollFlags flags = 0);
+    IMGUI_API void          ScrollToRect(ImGuiWindow* window, const ImRect& rect, ImGuiScrollFlags flags = 0);
+    IMGUI_API ImVec2        ScrollToRectEx(ImGuiWindow* window, const ImRect& rect, ImGuiScrollFlags flags = 0);
+//#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    inline void             ScrollToBringRectIntoView(ImGuiWindow* window, const ImRect& rect) { ScrollToRect(window, rect, ImGuiScrollFlags_KeepVisibleEdgeY); }
+//#endif
+
+    // Basic Accessors
+    inline ImGuiID          GetItemID()     { ImGuiContext& g = *GImGui; return g.LastItemData.ID; }   // Get ID of last item (~~ often same ImGui::GetID(label) beforehand)
+    inline ImGuiItemStatusFlags GetItemStatusFlags(){ ImGuiContext& g = *GImGui; return g.LastItemData.StatusFlags; }
+    inline ImGuiItemFlags   GetItemFlags()  { ImGuiContext& g = *GImGui; return g.LastItemData.InFlags; }
+    inline ImGuiID          GetActiveID()   { ImGuiContext& g = *GImGui; return g.ActiveId; }
+    inline ImGuiID          GetFocusID()    { ImGuiContext& g = *GImGui; return g.NavId; }
+    IMGUI_API void          SetActiveID(ImGuiID id, ImGuiWindow* window);
+    IMGUI_API void          SetFocusID(ImGuiID id, ImGuiWindow* window);
+    IMGUI_API void          ClearActiveID();
+    IMGUI_API ImGuiID       GetHoveredID();
+    IMGUI_API void          SetHoveredID(ImGuiID id);
+    IMGUI_API void          KeepAliveID(ImGuiID id);
+    IMGUI_API void          MarkItemEdited(ImGuiID id);     // Mark data associated to given item as "edited", used by IsItemDeactivatedAfterEdit() function.
+    IMGUI_API void          PushOverrideID(ImGuiID id);     // Push given value as-is at the top of the ID stack (whereas PushID combines old and new hashes)
+    IMGUI_API ImGuiID       GetIDWithSeed(const char* str_id_begin, const char* str_id_end, ImGuiID seed);
+
+    // Basic Helpers for widget code
+    IMGUI_API void          ItemSize(const ImVec2& size, float text_baseline_y = -1.0f);
+    IMGUI_API void          ItemSize(const ImRect& bb, float text_baseline_y = -1.0f);
+    IMGUI_API bool          ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb = NULL, ImGuiItemFlags extra_flags = 0);
+    IMGUI_API bool          ItemHoverable(const ImRect& bb, ImGuiID id);
+    IMGUI_API void          ItemInputable(ImGuiWindow* window, ImGuiID id);
+    IMGUI_API bool          IsClippedEx(const ImRect& bb, ImGuiID id);
+    IMGUI_API ImVec2        CalcItemSize(ImVec2 size, float default_w, float default_h);
+    IMGUI_API float         CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
+    IMGUI_API void          PushMultiItemsWidths(int components, float width_full);
+    IMGUI_API bool          IsItemToggledSelection();                                   // Was the last item selection toggled? (after Selectable(), TreeNode() etc. We only returns toggle _event_ in order to handle clipping correctly)
+    IMGUI_API ImVec2        GetContentRegionMaxAbs();
+    IMGUI_API void          ShrinkWidths(ImGuiShrinkWidthItem* items, int count, float width_excess);
+
+    // Parameter stacks
+    IMGUI_API void          PushItemFlag(ImGuiItemFlags option, bool enabled);
+    IMGUI_API void          PopItemFlag();
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    // Currently refactoring focus/nav/tabbing system
+    // If you have old/custom copy-and-pasted widgets that used FocusableItemRegister():
+    //  (Old) IMGUI_VERSION_NUM  < 18209: using 'ItemAdd(....)'                              and 'bool tab_focused = FocusableItemRegister(...)'
+    //  (Old) IMGUI_VERSION_NUM >= 18209: using 'ItemAdd(..., ImGuiItemAddFlags_Focusable)'  and 'bool tab_focused = (GetItemStatusFlags() & ImGuiItemStatusFlags_Focused) != 0'
+    //  (New) IMGUI_VERSION_NUM >= 18413: using 'ItemAdd(..., ImGuiItemFlags_Inputable)'     and 'bool tab_focused = (GetItemStatusFlags() & ImGuiItemStatusFlags_FocusedTabbing) != 0 || g.NavActivateInputId == id' (WIP)
+    // Widget code are simplified as there's no need to call FocusableItemUnregister() while managing the transition from regular widget to TempInputText()
+    inline bool FocusableItemRegister(ImGuiWindow* window, ImGuiID id)  { IM_ASSERT(0); IM_UNUSED(window); IM_UNUSED(id); return false; } // -> pass ImGuiItemAddFlags_Inputable flag to ItemAdd()
+    inline void FocusableItemUnregister(ImGuiWindow* window)            { IM_ASSERT(0); IM_UNUSED(window); }                              // -> unnecessary: TempInputText() uses ImGuiInputTextFlags_MergedItem
+#endif
+
+    // Logging/Capture
+    IMGUI_API void          LogBegin(ImGuiLogType type, int auto_open_depth);           // -> BeginCapture() when we design v2 api, for now stay under the radar by using the old name.
+    IMGUI_API void          LogToBuffer(int auto_open_depth = -1);                      // Start logging/capturing to internal buffer
+    IMGUI_API void          LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end = NULL);
+    IMGUI_API void          LogSetNextTextDecoration(const char* prefix, const char* suffix);
+
+    // Popups, Modals, Tooltips
+    IMGUI_API bool          BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, bool border, ImGuiWindowFlags flags);
+    IMGUI_API void          OpenPopupEx(ImGuiID id, ImGuiPopupFlags popup_flags = ImGuiPopupFlags_None);
+    IMGUI_API void          ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup);
+    IMGUI_API void          ClosePopupsOverWindow(ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup);
+    IMGUI_API void          ClosePopupsExceptModals();
+    IMGUI_API bool          IsPopupOpen(ImGuiID id, ImGuiPopupFlags popup_flags);
+    IMGUI_API bool          BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags);
+    IMGUI_API void          BeginTooltipEx(ImGuiWindowFlags extra_flags, ImGuiTooltipFlags tooltip_flags);
+    IMGUI_API ImRect        GetPopupAllowedExtentRect(ImGuiWindow* window);
+    IMGUI_API ImGuiWindow*  GetTopMostPopupModal();
+    IMGUI_API ImVec2        FindBestWindowPosForPopup(ImGuiWindow* window);
+    IMGUI_API ImVec2        FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy);
+
+    // Menus
+    IMGUI_API bool          BeginViewportSideBar(const char* name, ImGuiViewport* viewport, ImGuiDir dir, float size, ImGuiWindowFlags window_flags);
+    IMGUI_API bool          BeginMenuEx(const char* label, const char* icon, bool enabled = true);
+    IMGUI_API bool          MenuItemEx(const char* label, const char* icon, const char* shortcut = NULL, bool selected = false, bool enabled = true);
+
+    // Combos
+    IMGUI_API bool          BeginComboPopup(ImGuiID popup_id, const ImRect& bb, ImGuiComboFlags flags);
+    IMGUI_API bool          BeginComboPreview();
+    IMGUI_API void          EndComboPreview();
+
+    // Gamepad/Keyboard Navigation
+    IMGUI_API void          NavInitWindow(ImGuiWindow* window, bool force_reinit);
+    IMGUI_API void          NavInitRequestApplyResult();
+    IMGUI_API bool          NavMoveRequestButNoResultYet();
+    IMGUI_API void          NavMoveRequestSubmit(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags);
+    IMGUI_API void          NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags);
+    IMGUI_API void          NavMoveRequestResolveWithLastItem();
+    IMGUI_API void          NavMoveRequestCancel();
+    IMGUI_API void          NavMoveRequestApplyResult();
+    IMGUI_API void          NavMoveRequestTryWrapping(ImGuiWindow* window, ImGuiNavMoveFlags move_flags);
+    IMGUI_API float         GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode);
+    IMGUI_API ImVec2        GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor = 0.0f, float fast_factor = 0.0f);
+    IMGUI_API int           CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate);
+    IMGUI_API void          ActivateItem(ImGuiID id);   // Remotely activate a button, checkbox, tree node etc. given its unique ID. activation is queued and processed on the next frame when the item is encountered again.
+    IMGUI_API void          SetNavID(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel);
+
+    // Focus Scope (WIP)
+    // This is generally used to identify a selection set (multiple of which may be in the same window), as selection
+    // patterns generally need to react (e.g. clear selection) when landing on an item of the set.
+    IMGUI_API void          PushFocusScope(ImGuiID id);
+    IMGUI_API void          PopFocusScope();
+    inline ImGuiID          GetFocusedFocusScope()          { ImGuiContext& g = *GImGui; return g.NavFocusScopeId; }                            // Focus scope which is actually active
+    inline ImGuiID          GetFocusScope()                 { ImGuiContext& g = *GImGui; return g.CurrentWindow->DC.NavFocusScopeIdCurrent; }   // Focus scope we are outputting into, set by PushFocusScope()
+
+    // Inputs
+    // FIXME: Eventually we should aim to move e.g. IsActiveIdUsingKey() into IsKeyXXX functions.
+    IMGUI_API void          SetItemUsingMouseWheel();
+    IMGUI_API void          SetActiveIdUsingNavAndKeys();
+    inline bool             IsActiveIdUsingNavDir(ImGuiDir dir)                         { ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavDirMask & (1 << dir)) != 0; }
+    inline bool             IsActiveIdUsingNavInput(ImGuiNavInput input)                { ImGuiContext& g = *GImGui; return (g.ActiveIdUsingNavInputMask & (1 << input)) != 0; }
+    inline bool             IsActiveIdUsingKey(ImGuiKey key)                            { ImGuiContext& g = *GImGui; IM_ASSERT(key < 64); return (g.ActiveIdUsingKeyInputMask & ((ImU64)1 << key)) != 0; }
+    IMGUI_API bool          IsMouseDragPastThreshold(ImGuiMouseButton button, float lock_threshold = -1.0f);
+    inline bool             IsKeyPressedMap(ImGuiKey key, bool repeat = true)           { ImGuiContext& g = *GImGui; const int key_index = g.IO.KeyMap[key]; return (key_index >= 0) ? IsKeyPressed(key_index, repeat) : false; }
+    inline bool             IsNavInputDown(ImGuiNavInput n)                             { ImGuiContext& g = *GImGui; return g.IO.NavInputs[n] > 0.0f; }
+    inline bool             IsNavInputTest(ImGuiNavInput n, ImGuiInputReadMode rm)      { return (GetNavInputAmount(n, rm) > 0.0f); }
+    IMGUI_API ImGuiKeyModFlags GetMergedKeyModFlags();
+
+    // Drag and Drop
+    IMGUI_API bool          BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
+    IMGUI_API void          ClearDragDrop();
+    IMGUI_API bool          IsDragDropPayloadBeingAccepted();
+
+    // Internal Columns API (this is not exposed because we will encourage transitioning to the Tables API)
+    IMGUI_API void          SetWindowClipRectBeforeSetChannel(ImGuiWindow* window, const ImRect& clip_rect);
+    IMGUI_API void          BeginColumns(const char* str_id, int count, ImGuiOldColumnFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
+    IMGUI_API void          EndColumns();                                                               // close columns
+    IMGUI_API void          PushColumnClipRect(int column_index);
+    IMGUI_API void          PushColumnsBackground();
+    IMGUI_API void          PopColumnsBackground();
+    IMGUI_API ImGuiID       GetColumnsID(const char* str_id, int count);
+    IMGUI_API ImGuiOldColumns* FindOrCreateColumns(ImGuiWindow* window, ImGuiID id);
+    IMGUI_API float         GetColumnOffsetFromNorm(const ImGuiOldColumns* columns, float offset_norm);
+    IMGUI_API float         GetColumnNormFromOffset(const ImGuiOldColumns* columns, float offset);
+
+    // Tables: Candidates for public API
+    IMGUI_API void          TableOpenContextMenu(int column_n = -1);
+    IMGUI_API void          TableSetColumnWidth(int column_n, float width);
+    IMGUI_API void          TableSetColumnSortDirection(int column_n, ImGuiSortDirection sort_direction, bool append_to_sort_specs);
+    IMGUI_API int           TableGetHoveredColumn(); // May use (TableGetColumnFlags() & ImGuiTableColumnFlags_IsHovered) instead. Return hovered column. return -1 when table is not hovered. return columns_count if the unused space at the right of visible columns is hovered.
+    IMGUI_API float         TableGetHeaderRowHeight();
+    IMGUI_API void          TablePushBackgroundChannel();
+    IMGUI_API void          TablePopBackgroundChannel();
+
+    // Tables: Internals
+    inline    ImGuiTable*   GetCurrentTable() { ImGuiContext& g = *GImGui; return g.CurrentTable; }
+    IMGUI_API ImGuiTable*   TableFindByID(ImGuiID id);
+    IMGUI_API bool          BeginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags = 0, const ImVec2& outer_size = ImVec2(0, 0), float inner_width = 0.0f);
+    IMGUI_API void          TableBeginInitMemory(ImGuiTable* table, int columns_count);
+    IMGUI_API void          TableBeginApplyRequests(ImGuiTable* table);
+    IMGUI_API void          TableSetupDrawChannels(ImGuiTable* table);
+    IMGUI_API void          TableUpdateLayout(ImGuiTable* table);
+    IMGUI_API void          TableUpdateBorders(ImGuiTable* table);
+    IMGUI_API void          TableUpdateColumnsWeightFromWidth(ImGuiTable* table);
+    IMGUI_API void          TableDrawBorders(ImGuiTable* table);
+    IMGUI_API void          TableDrawContextMenu(ImGuiTable* table);
+    IMGUI_API void          TableMergeDrawChannels(ImGuiTable* table);
+    IMGUI_API void          TableSortSpecsSanitize(ImGuiTable* table);
+    IMGUI_API void          TableSortSpecsBuild(ImGuiTable* table);
+    IMGUI_API ImGuiSortDirection TableGetColumnNextSortDirection(ImGuiTableColumn* column);
+    IMGUI_API void          TableFixColumnSortDirection(ImGuiTable* table, ImGuiTableColumn* column);
+    IMGUI_API float         TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column);
+    IMGUI_API void          TableBeginRow(ImGuiTable* table);
+    IMGUI_API void          TableEndRow(ImGuiTable* table);
+    IMGUI_API void          TableBeginCell(ImGuiTable* table, int column_n);
+    IMGUI_API void          TableEndCell(ImGuiTable* table);
+    IMGUI_API ImRect        TableGetCellBgRect(const ImGuiTable* table, int column_n);
+    IMGUI_API const char*   TableGetColumnName(const ImGuiTable* table, int column_n);
+    IMGUI_API ImGuiID       TableGetColumnResizeID(const ImGuiTable* table, int column_n, int instance_no = 0);
+    IMGUI_API float         TableGetMaxColumnWidth(const ImGuiTable* table, int column_n);
+    IMGUI_API void          TableSetColumnWidthAutoSingle(ImGuiTable* table, int column_n);
+    IMGUI_API void          TableSetColumnWidthAutoAll(ImGuiTable* table);
+    IMGUI_API void          TableRemove(ImGuiTable* table);
+    IMGUI_API void          TableGcCompactTransientBuffers(ImGuiTable* table);
+    IMGUI_API void          TableGcCompactTransientBuffers(ImGuiTableTempData* table);
+    IMGUI_API void          TableGcCompactSettings();
+
+    // Tables: Settings
+    IMGUI_API void                  TableLoadSettings(ImGuiTable* table);
+    IMGUI_API void                  TableSaveSettings(ImGuiTable* table);
+    IMGUI_API void                  TableResetSettings(ImGuiTable* table);
+    IMGUI_API ImGuiTableSettings*   TableGetBoundSettings(ImGuiTable* table);
+    IMGUI_API void                  TableSettingsInstallHandler(ImGuiContext* context);
+    IMGUI_API ImGuiTableSettings*   TableSettingsCreate(ImGuiID id, int columns_count);
+    IMGUI_API ImGuiTableSettings*   TableSettingsFindByID(ImGuiID id);
+
+    // Tab Bars
+    IMGUI_API bool          BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& bb, ImGuiTabBarFlags flags);
+    IMGUI_API ImGuiTabItem* TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab_id);
+    IMGUI_API void          TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id);
+    IMGUI_API void          TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab);
+    IMGUI_API void          TabBarQueueReorder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int offset);
+    IMGUI_API void          TabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, ImVec2 mouse_pos);
+    IMGUI_API bool          TabBarProcessReorder(ImGuiTabBar* tab_bar);
+    IMGUI_API bool          TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags);
+    IMGUI_API ImVec2        TabItemCalcSize(const char* label, bool has_close_button);
+    IMGUI_API void          TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col);
+    IMGUI_API void          TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id, bool is_contents_visible, bool* out_just_closed, bool* out_text_clipped);
+
+    // Render helpers
+    // AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
+    // NB: All position are in absolute pixels coordinates (we are never using window coordinates internally)
+    IMGUI_API void          RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
+    IMGUI_API void          RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
+    IMGUI_API void          RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
+    IMGUI_API void          RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0, 0), const ImRect* clip_rect = NULL);
+    IMGUI_API void          RenderTextEllipsis(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, float clip_max_x, float ellipsis_max_x, const char* text, const char* text_end, const ImVec2* text_size_if_known);
+    IMGUI_API void          RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
+    IMGUI_API void          RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
+    IMGUI_API void          RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, ImDrawFlags flags = 0);
+    IMGUI_API void          RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags = ImGuiNavHighlightFlags_TypeDefault); // Navigation highlight
+    IMGUI_API const char*   FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
+
+    // Render helpers (those functions don't access any ImGui state!)
+    IMGUI_API void          RenderArrow(ImDrawList* draw_list, ImVec2 pos, ImU32 col, ImGuiDir dir, float scale = 1.0f);
+    IMGUI_API void          RenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col);
+    IMGUI_API void          RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz);
+    IMGUI_API void          RenderMouseCursor(ImDrawList* draw_list, ImVec2 pos, float scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow);
+    IMGUI_API void          RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col);
+    IMGUI_API void          RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
+    IMGUI_API void          RenderRectFilledWithHole(ImDrawList* draw_list, ImRect outer, ImRect inner, ImU32 col, float rounding);
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+    // [1.71: 2019/06/07: Updating prototypes of some of the internal functions. Leaving those for reference for a short while]
+    inline void RenderArrow(ImVec2 pos, ImGuiDir dir, float scale=1.0f) { ImGuiWindow* window = GetCurrentWindow(); RenderArrow(window->DrawList, pos, GetColorU32(ImGuiCol_Text), dir, scale); }
+    inline void RenderBullet(ImVec2 pos)                                { ImGuiWindow* window = GetCurrentWindow(); RenderBullet(window->DrawList, pos, GetColorU32(ImGuiCol_Text)); }
+#endif
+
+    // Widgets
+    IMGUI_API void          TextEx(const char* text, const char* text_end = NULL, ImGuiTextFlags flags = 0);
+    IMGUI_API bool          ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0, 0), ImGuiButtonFlags flags = 0);
+    IMGUI_API bool          CloseButton(ImGuiID id, const ImVec2& pos);
+    IMGUI_API bool          CollapseButton(ImGuiID id, const ImVec2& pos);
+    IMGUI_API bool          ArrowButtonEx(const char* str_id, ImGuiDir dir, ImVec2 size_arg, ImGuiButtonFlags flags = 0);
+    IMGUI_API void          Scrollbar(ImGuiAxis axis);
+    IMGUI_API bool          ScrollbarEx(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* p_scroll_v, float avail_v, float contents_v, ImDrawFlags flags);
+    IMGUI_API bool          ImageButtonEx(ImGuiID id, ImTextureID texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, const ImVec2& padding, const ImVec4& bg_col, const ImVec4& tint_col);
+    IMGUI_API ImRect        GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis);
+    IMGUI_API ImGuiID       GetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis);
+    IMGUI_API ImGuiID       GetWindowResizeCornerID(ImGuiWindow* window, int n); // 0..3: corners
+    IMGUI_API ImGuiID       GetWindowResizeBorderID(ImGuiWindow* window, ImGuiDir dir);
+    IMGUI_API void          SeparatorEx(ImGuiSeparatorFlags flags);
+    IMGUI_API bool          CheckboxFlags(const char* label, ImS64* flags, ImS64 flags_value);
+    IMGUI_API bool          CheckboxFlags(const char* label, ImU64* flags, ImU64 flags_value);
+
+    // Widgets low-level behaviors
+    IMGUI_API bool          ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
+    IMGUI_API bool          DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags);
+    IMGUI_API bool          SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* p_v, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb);
+    IMGUI_API bool          SplitterBehavior(const ImRect& bb, ImGuiID id, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f, float hover_visibility_delay = 0.0f);
+    IMGUI_API bool          TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
+    IMGUI_API bool          TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0);                     // Consume previous SetNextItemOpen() data, if any. May return true when logging
+    IMGUI_API void          TreePushOverrideID(ImGuiID id);
+
+    // Template functions are instantiated in imgui_widgets.cpp for a finite number of types.
+    // To use them externally (for custom widget) you may need an "extern template" statement in your code in order to link to existing instances and silence Clang warnings (see #2036).
+    // e.g. " extern template IMGUI_API float RoundScalarWithFormatT<float, float>(const char* format, ImGuiDataType data_type, float v); "
+    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API float ScaleRatioFromValueT(ImGuiDataType data_type, T v, T v_min, T v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_size);
+    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API T     ScaleValueFromRatioT(ImGuiDataType data_type, float t, T v_min, T v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_size);
+    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API bool  DragBehaviorT(ImGuiDataType data_type, T* v, float v_speed, T v_min, T v_max, const char* format, ImGuiSliderFlags flags);
+    template<typename T, typename SIGNED_T, typename FLOAT_T>   IMGUI_API bool  SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, T* v, T v_min, T v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb);
+    template<typename T, typename SIGNED_T>                     IMGUI_API T     RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, T v);
+    template<typename T>                                        IMGUI_API bool  CheckboxFlagsT(const char* label, T* flags, T flags_value);
+
+    // Data type helpers
+    IMGUI_API const ImGuiDataTypeInfo*  DataTypeGetInfo(ImGuiDataType data_type);
+    IMGUI_API int           DataTypeFormatString(char* buf, int buf_size, ImGuiDataType data_type, const void* p_data, const char* format);
+    IMGUI_API void          DataTypeApplyOp(ImGuiDataType data_type, int op, void* output, const void* arg_1, const void* arg_2);
+    IMGUI_API bool          DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* p_data, const char* format);
+    IMGUI_API int           DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2);
+    IMGUI_API bool          DataTypeClamp(ImGuiDataType data_type, void* p_data, const void* p_min, const void* p_max);
+
+    // InputText
+    IMGUI_API bool          InputTextEx(const char* label, const char* hint, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback = NULL, void* user_data = NULL);
+    IMGUI_API bool          TempInputText(const ImRect& bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags);
+    IMGUI_API bool          TempInputScalar(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min = NULL, const void* p_clamp_max = NULL);
+    inline bool             TempInputIsActive(ImGuiID id)       { ImGuiContext& g = *GImGui; return (g.ActiveId == id && g.TempInputId == id); }
+    inline ImGuiInputTextState* GetInputTextState(ImGuiID id)   { ImGuiContext& g = *GImGui; return (g.InputTextState.ID == id) ? &g.InputTextState : NULL; } // Get input text state if active
+
+    // Color
+    IMGUI_API void          ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
+    IMGUI_API void          ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
+    IMGUI_API void          ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags);
+
+    // Plot
+    IMGUI_API int           PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size);
+
+    // Shade functions (write over already created vertices)
+    IMGUI_API void          ShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
+    IMGUI_API void          ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
+
+    // Garbage collection
+    IMGUI_API void          GcCompactTransientMiscBuffers();
+    IMGUI_API void          GcCompactTransientWindowBuffers(ImGuiWindow* window);
+    IMGUI_API void          GcAwakeTransientWindowBuffers(ImGuiWindow* window);
+
+    // Debug Tools
+    IMGUI_API void          ErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback, void* user_data = NULL);
+    IMGUI_API void          ErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback, void* user_data = NULL);
+    inline void             DebugDrawItemRect(ImU32 col = IM_COL32(255,0,0,255))    { ImGuiContext& g = *GImGui; ImGuiWindow* window = g.CurrentWindow; GetForegroundDrawList(window)->AddRect(g.LastItemData.Rect.Min, g.LastItemData.Rect.Max, col); }
+    inline void             DebugStartItemPicker()                                  { ImGuiContext& g = *GImGui; g.DebugItemPickerActive = true; }
+
+    IMGUI_API void          ShowFontAtlas(ImFontAtlas* atlas);
+    IMGUI_API void          DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* data_id, const void* data_id_end);
+    IMGUI_API void          DebugNodeColumns(ImGuiOldColumns* columns);
+    IMGUI_API void          DebugNodeDrawList(ImGuiWindow* window, const ImDrawList* draw_list, const char* label);
+    IMGUI_API void          DebugNodeDrawCmdShowMeshAndBoundingBox(ImDrawList* out_draw_list, const ImDrawList* draw_list, const ImDrawCmd* draw_cmd, bool show_mesh, bool show_aabb);
+    IMGUI_API void          DebugNodeFont(ImFont* font);
+    IMGUI_API void          DebugNodeStorage(ImGuiStorage* storage, const char* label);
+    IMGUI_API void          DebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label);
+    IMGUI_API void          DebugNodeTable(ImGuiTable* table);
+    IMGUI_API void          DebugNodeTableSettings(ImGuiTableSettings* settings);
+    IMGUI_API void          DebugNodeWindow(ImGuiWindow* window, const char* label);
+    IMGUI_API void          DebugNodeWindowSettings(ImGuiWindowSettings* settings);
+    IMGUI_API void          DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label);
+    IMGUI_API void          DebugNodeViewport(ImGuiViewportP* viewport);
+    IMGUI_API void          DebugRenderViewportThumbnail(ImDrawList* draw_list, ImGuiViewportP* viewport, const ImRect& bb);
+
+} // namespace ImGui
+
+
+//-----------------------------------------------------------------------------
+// [SECTION] ImFontAtlas internal API
+//-----------------------------------------------------------------------------
+
+// This structure is likely to evolve as we add support for incremental atlas updates
+struct ImFontBuilderIO
+{
+    bool    (*FontBuilder_Build)(ImFontAtlas* atlas);
+};
+
+// Helper for font builder
+IMGUI_API const ImFontBuilderIO* ImFontAtlasGetBuilderForStbTruetype();
+IMGUI_API void      ImFontAtlasBuildInit(ImFontAtlas* atlas);
+IMGUI_API void      ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent);
+IMGUI_API void      ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* stbrp_context_opaque);
+IMGUI_API void      ImFontAtlasBuildFinish(ImFontAtlas* atlas);
+IMGUI_API void      ImFontAtlasBuildRender8bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned char in_marker_pixel_value);
+IMGUI_API void      ImFontAtlasBuildRender32bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned int in_marker_pixel_value);
+IMGUI_API void      ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor);
+IMGUI_API void      ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride);
+
+//-----------------------------------------------------------------------------
+// [SECTION] Test Engine specific hooks (imgui_test_engine)
+//-----------------------------------------------------------------------------
+
+#ifdef IMGUI_ENABLE_TEST_ENGINE
+extern void         ImGuiTestEngineHook_ItemAdd(ImGuiContext* ctx, const ImRect& bb, ImGuiID id);
+extern void         ImGuiTestEngineHook_ItemInfo(ImGuiContext* ctx, ImGuiID id, const char* label, ImGuiItemStatusFlags flags);
+extern void         ImGuiTestEngineHook_Log(ImGuiContext* ctx, const char* fmt, ...);
+extern const char*  ImGuiTestEngine_FindItemDebugLabel(ImGuiContext* ctx, ImGuiID id);
+
+#define IMGUI_TEST_ENGINE_ITEM_ADD(_BB,_ID)                 if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemAdd(&g, _BB, _ID)               // Register item bounding box
+#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS)      if (g.TestEngineHookItems) ImGuiTestEngineHook_ItemInfo(&g, _ID, _LABEL, _FLAGS)   // Register item label and status flags (optional)
+#define IMGUI_TEST_ENGINE_LOG(_FMT,...)                     if (g.TestEngineHookItems) ImGuiTestEngineHook_Log(&g, _FMT, __VA_ARGS__)          // Custom log entry from user land into test log
+#else
+#define IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS)      ((void)0)
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (pop)
+#endif
+
+#endif // #ifndef IMGUI_DISABLE
+ rlImGui/imgui/imstb_rectpack.h view
@@ -0,0 +1,639 @@+// [DEAR IMGUI]
+// This is a slightly modified version of stb_rect_pack.h 1.00.
+// Those changes would need to be pushed into nothings/stb:
+// - Added STBRP__CDECL
+// Grep for [DEAR IMGUI] to find the changes.
+
+// stb_rect_pack.h - v1.00 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+typedef int            stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+// [DEAR IMGUI] Added STBRP__CDECL
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+#ifndef STBRP_LARGE_RECTS
+   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+#ifdef STBRP_LARGE_RECTS
+   context->extra[1].y = (1<<30);
+#else
+   context->extra[1].y = 65535;
+#endif
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height <= c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  STBRP_ASSERT(y <= best_y);
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL  0xffffffff
+#else
+#define STBRP__MAXVAL  0xffff
+#endif
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
+ rlImGui/imgui/imstb_textedit.h view
@@ -0,0 +1,1449 @@+// [DEAR IMGUI]
+// This is a slightly modified version of stb_textedit.h 1.13.
+// Those changes would need to be pushed into nothings/stb:
+// - Fix in stb_textedit_discard_redo (see https://github.com/nothings/stb/issues/321)
+// Grep for [DEAR IMGUI] to find the changes.
+
+// stb_textedit.h - v1.13  - public domain - Sean Barrett
+// Development of this library was sponsored by RAD Game Tools
+//
+// This C header file implements the guts of a multi-line text-editing
+// widget; you implement display, word-wrapping, and low-level string
+// insertion/deletion, and stb_textedit will map user inputs into
+// insertions & deletions, plus updates to the cursor position,
+// selection state, and undo state.
+//
+// It is intended for use in games and other systems that need to build
+// their own custom widgets and which do not have heavy text-editing
+// requirements (this library is not recommended for use for editing large
+// texts, as its performance does not scale and it has limited undo).
+//
+// Non-trivial behaviors are modelled after Windows text controls.
+//
+//
+// LICENSE
+//
+// See end of file for license information.
+//
+//
+// DEPENDENCIES
+//
+// Uses the C runtime function 'memmove', which you can override
+// by defining STB_TEXTEDIT_memmove before the implementation.
+// Uses no other functions. Performs no runtime allocations.
+//
+//
+// VERSION HISTORY
+//
+//   1.13 (2019-02-07) fix bug in undo size management
+//   1.12 (2018-01-29) user can change STB_TEXTEDIT_KEYTYPE, fix redo to avoid crash
+//   1.11 (2017-03-03) fix HOME on last line, dragging off single-line textfield
+//   1.10 (2016-10-25) supress warnings about casting away const with -Wcast-qual
+//   1.9  (2016-08-27) customizable move-by-word
+//   1.8  (2016-04-02) better keyboard handling when mouse button is down
+//   1.7  (2015-09-13) change y range handling in case baseline is non-0
+//   1.6  (2015-04-15) allow STB_TEXTEDIT_memmove
+//   1.5  (2014-09-10) add support for secondary keys for OS X
+//   1.4  (2014-08-17) fix signed/unsigned warnings
+//   1.3  (2014-06-19) fix mouse clicking to round to nearest char boundary
+//   1.2  (2014-05-27) fix some RAD types that had crept into the new code
+//   1.1  (2013-12-15) move-by-word (requires STB_TEXTEDIT_IS_SPACE )
+//   1.0  (2012-07-26) improve documentation, initial public release
+//   0.3  (2012-02-24) bugfixes, single-line mode; insert mode
+//   0.2  (2011-11-28) fixes to undo/redo
+//   0.1  (2010-07-08) initial version
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Ulf Winklemann: move-by-word in 1.1
+//   Fabian Giesen: secondary key inputs in 1.5
+//   Martins Mozeiko: STB_TEXTEDIT_memmove in 1.6
+//
+//   Bugfixes:
+//      Scott Graham
+//      Daniel Keller
+//      Omar Cornut
+//      Dan Thompson
+//
+// USAGE
+//
+// This file behaves differently depending on what symbols you define
+// before including it.
+//
+//
+// Header-file mode:
+//
+//   If you do not define STB_TEXTEDIT_IMPLEMENTATION before including this,
+//   it will operate in "header file" mode. In this mode, it declares a
+//   single public symbol, STB_TexteditState, which encapsulates the current
+//   state of a text widget (except for the string, which you will store
+//   separately).
+//
+//   To compile in this mode, you must define STB_TEXTEDIT_CHARTYPE to a
+//   primitive type that defines a single character (e.g. char, wchar_t, etc).
+//
+//   To save space or increase undo-ability, you can optionally define the
+//   following things that are used by the undo system:
+//
+//      STB_TEXTEDIT_POSITIONTYPE         small int type encoding a valid cursor position
+//      STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//      STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+//   If you don't define these, they are set to permissive types and
+//   moderate sizes. The undo system does no memory allocations, so
+//   it grows STB_TexteditState by the worst-case storage which is (in bytes):
+//
+//        [4 + 3 * sizeof(STB_TEXTEDIT_POSITIONTYPE)] * STB_TEXTEDIT_UNDOSTATE_COUNT
+//      +          sizeof(STB_TEXTEDIT_CHARTYPE)      * STB_TEXTEDIT_UNDOCHAR_COUNT
+//
+//
+// Implementation mode:
+//
+//   If you define STB_TEXTEDIT_IMPLEMENTATION before including this, it
+//   will compile the implementation of the text edit widget, depending
+//   on a large number of symbols which must be defined before the include.
+//
+//   The implementation is defined only as static functions. You will then
+//   need to provide your own APIs in the same file which will access the
+//   static functions.
+//
+//   The basic concept is that you provide a "string" object which
+//   behaves like an array of characters. stb_textedit uses indices to
+//   refer to positions in the string, implicitly representing positions
+//   in the displayed textedit. This is true for both plain text and
+//   rich text; even with rich text stb_truetype interacts with your
+//   code as if there was an array of all the displayed characters.
+//
+// Symbols that must be the same in header-file and implementation mode:
+//
+//     STB_TEXTEDIT_CHARTYPE             the character type
+//     STB_TEXTEDIT_POSITIONTYPE         small type that is a valid cursor position
+//     STB_TEXTEDIT_UNDOSTATECOUNT       the number of undo states to allow
+//     STB_TEXTEDIT_UNDOCHARCOUNT        the number of characters to store in the undo buffer
+//
+// Symbols you must define for implementation mode:
+//
+//    STB_TEXTEDIT_STRING               the type of object representing a string being edited,
+//                                      typically this is a wrapper object with other data you need
+//
+//    STB_TEXTEDIT_STRINGLEN(obj)       the length of the string (ideally O(1))
+//    STB_TEXTEDIT_LAYOUTROW(&r,obj,n)  returns the results of laying out a line of characters
+//                                        starting from character #n (see discussion below)
+//    STB_TEXTEDIT_GETWIDTH(obj,n,i)    returns the pixel delta from the xpos of the i'th character
+//                                        to the xpos of the i+1'th char for a line of characters
+//                                        starting at character #n (i.e. accounts for kerning
+//                                        with previous char)
+//    STB_TEXTEDIT_KEYTOTEXT(k)         maps a keyboard input to an insertable character
+//                                        (return type is int, -1 means not valid to insert)
+//    STB_TEXTEDIT_GETCHAR(obj,i)       returns the i'th character of obj, 0-based
+//    STB_TEXTEDIT_NEWLINE              the character returned by _GETCHAR() we recognize
+//                                        as manually wordwrapping for end-of-line positioning
+//
+//    STB_TEXTEDIT_DELETECHARS(obj,i,n)      delete n characters starting at i
+//    STB_TEXTEDIT_INSERTCHARS(obj,i,c*,n)   insert n characters at i (pointed to by STB_TEXTEDIT_CHARTYPE*)
+//
+//    STB_TEXTEDIT_K_SHIFT       a power of two that is or'd in to a keyboard input to represent the shift key
+//
+//    STB_TEXTEDIT_K_LEFT        keyboard input to move cursor left
+//    STB_TEXTEDIT_K_RIGHT       keyboard input to move cursor right
+//    STB_TEXTEDIT_K_UP          keyboard input to move cursor up
+//    STB_TEXTEDIT_K_DOWN        keyboard input to move cursor down
+//    STB_TEXTEDIT_K_PGUP        keyboard input to move cursor up a page
+//    STB_TEXTEDIT_K_PGDOWN      keyboard input to move cursor down a page
+//    STB_TEXTEDIT_K_LINESTART   keyboard input to move cursor to start of line  // e.g. HOME
+//    STB_TEXTEDIT_K_LINEEND     keyboard input to move cursor to end of line    // e.g. END
+//    STB_TEXTEDIT_K_TEXTSTART   keyboard input to move cursor to start of text  // e.g. ctrl-HOME
+//    STB_TEXTEDIT_K_TEXTEND     keyboard input to move cursor to end of text    // e.g. ctrl-END
+//    STB_TEXTEDIT_K_DELETE      keyboard input to delete selection or character under cursor
+//    STB_TEXTEDIT_K_BACKSPACE   keyboard input to delete selection or character left of cursor
+//    STB_TEXTEDIT_K_UNDO        keyboard input to perform undo
+//    STB_TEXTEDIT_K_REDO        keyboard input to perform redo
+//
+// Optional:
+//    STB_TEXTEDIT_K_INSERT              keyboard input to toggle insert mode
+//    STB_TEXTEDIT_IS_SPACE(ch)          true if character is whitespace (e.g. 'isspace'),
+//                                          required for default WORDLEFT/WORDRIGHT handlers
+//    STB_TEXTEDIT_MOVEWORDLEFT(obj,i)   custom handler for WORDLEFT, returns index to move cursor to
+//    STB_TEXTEDIT_MOVEWORDRIGHT(obj,i)  custom handler for WORDRIGHT, returns index to move cursor to
+//    STB_TEXTEDIT_K_WORDLEFT            keyboard input to move cursor left one word // e.g. ctrl-LEFT
+//    STB_TEXTEDIT_K_WORDRIGHT           keyboard input to move cursor right one word // e.g. ctrl-RIGHT
+//    STB_TEXTEDIT_K_LINESTART2          secondary keyboard input to move cursor to start of line
+//    STB_TEXTEDIT_K_LINEEND2            secondary keyboard input to move cursor to end of line
+//    STB_TEXTEDIT_K_TEXTSTART2          secondary keyboard input to move cursor to start of text
+//    STB_TEXTEDIT_K_TEXTEND2            secondary keyboard input to move cursor to end of text
+//
+// Keyboard input must be encoded as a single integer value; e.g. a character code
+// and some bitflags that represent shift states. to simplify the interface, SHIFT must
+// be a bitflag, so we can test the shifted state of cursor movements to allow selection,
+// i.e. (STB_TEXTEDIT_K_RIGHT|STB_TEXTEDIT_K_SHIFT) should be shifted right-arrow.
+//
+// You can encode other things, such as CONTROL or ALT, in additional bits, and
+// then test for their presence in e.g. STB_TEXTEDIT_K_WORDLEFT. For example,
+// my Windows implementations add an additional CONTROL bit, and an additional KEYDOWN
+// bit. Then all of the STB_TEXTEDIT_K_ values bitwise-or in the KEYDOWN bit,
+// and I pass both WM_KEYDOWN and WM_CHAR events to the "key" function in the
+// API below. The control keys will only match WM_KEYDOWN events because of the
+// keydown bit I add, and STB_TEXTEDIT_KEYTOTEXT only tests for the KEYDOWN
+// bit so it only decodes WM_CHAR events.
+//
+// STB_TEXTEDIT_LAYOUTROW returns information about the shape of one displayed
+// row of characters assuming they start on the i'th character--the width and
+// the height and the number of characters consumed. This allows this library
+// to traverse the entire layout incrementally. You need to compute word-wrapping
+// here.
+//
+// Each textfield keeps its own insert mode state, which is not how normal
+// applications work. To keep an app-wide insert mode, update/copy the
+// "insert_mode" field of STB_TexteditState before/after calling API functions.
+//
+// API
+//
+//    void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+//
+//    void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+//    int  stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+//    int  stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+//    void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXEDIT_KEYTYPE key)
+//
+//    Each of these functions potentially updates the string and updates the
+//    state.
+//
+//      initialize_state:
+//          set the textedit state to a known good default state when initially
+//          constructing the textedit.
+//
+//      click:
+//          call this with the mouse x,y on a mouse down; it will update the cursor
+//          and reset the selection start/end to the cursor point. the x,y must
+//          be relative to the text widget, with (0,0) being the top left.
+//
+//      drag:
+//          call this with the mouse x,y on a mouse drag/up; it will update the
+//          cursor and the selection end point
+//
+//      cut:
+//          call this to delete the current selection; returns true if there was
+//          one. you should FIRST copy the current selection to the system paste buffer.
+//          (To copy, just copy the current selection out of the string yourself.)
+//
+//      paste:
+//          call this to paste text at the current cursor point or over the current
+//          selection if there is one.
+//
+//      key:
+//          call this for keyboard inputs sent to the textfield. you can use it
+//          for "key down" events or for "translated" key events. if you need to
+//          do both (as in Win32), or distinguish Unicode characters from control
+//          inputs, set a high bit to distinguish the two; then you can define the
+//          various definitions like STB_TEXTEDIT_K_LEFT have the is-key-event bit
+//          set, and make STB_TEXTEDIT_KEYTOCHAR check that the is-key-event bit is
+//          clear. STB_TEXTEDIT_KEYTYPE defaults to int, but you can #define it to
+//          anything other type you wante before including.
+//
+//
+//   When rendering, you can read the cursor position and selection state from
+//   the STB_TexteditState.
+//
+//
+// Notes:
+//
+// This is designed to be usable in IMGUI, so it allows for the possibility of
+// running in an IMGUI that has NOT cached the multi-line layout. For this
+// reason, it provides an interface that is compatible with computing the
+// layout incrementally--we try to make sure we make as few passes through
+// as possible. (For example, to locate the mouse pointer in the text, we
+// could define functions that return the X and Y positions of characters
+// and binary search Y and then X, but if we're doing dynamic layout this
+// will run the layout algorithm many times, so instead we manually search
+// forward in one pass. Similar logic applies to e.g. up-arrow and
+// down-arrow movement.)
+//
+// If it's run in a widget that *has* cached the layout, then this is less
+// efficient, but it's not horrible on modern computers. But you wouldn't
+// want to edit million-line files with it.
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Header-file mode
+////
+////
+
+#ifndef INCLUDE_STB_TEXTEDIT_H
+#define INCLUDE_STB_TEXTEDIT_H
+
+////////////////////////////////////////////////////////////////////////
+//
+//     STB_TexteditState
+//
+// Definition of STB_TexteditState which you should store
+// per-textfield; it includes cursor position, selection state,
+// and undo state.
+//
+
+#ifndef STB_TEXTEDIT_UNDOSTATECOUNT
+#define STB_TEXTEDIT_UNDOSTATECOUNT   99
+#endif
+#ifndef STB_TEXTEDIT_UNDOCHARCOUNT
+#define STB_TEXTEDIT_UNDOCHARCOUNT   999
+#endif
+#ifndef STB_TEXTEDIT_CHARTYPE
+#define STB_TEXTEDIT_CHARTYPE        int
+#endif
+#ifndef STB_TEXTEDIT_POSITIONTYPE
+#define STB_TEXTEDIT_POSITIONTYPE    int
+#endif
+
+typedef struct
+{
+   // private data
+   STB_TEXTEDIT_POSITIONTYPE  where;
+   STB_TEXTEDIT_POSITIONTYPE  insert_length;
+   STB_TEXTEDIT_POSITIONTYPE  delete_length;
+   int                        char_storage;
+} StbUndoRecord;
+
+typedef struct
+{
+   // private data
+   StbUndoRecord          undo_rec [STB_TEXTEDIT_UNDOSTATECOUNT];
+   STB_TEXTEDIT_CHARTYPE  undo_char[STB_TEXTEDIT_UNDOCHARCOUNT];
+   short undo_point, redo_point;
+   int undo_char_point, redo_char_point;
+} StbUndoState;
+
+typedef struct
+{
+   /////////////////////
+   //
+   // public data
+   //
+
+   int cursor;
+   // position of the text cursor within the string
+
+   int select_start;          // selection start point
+   int select_end;
+   // selection start and end point in characters; if equal, no selection.
+   // note that start may be less than or greater than end (e.g. when
+   // dragging the mouse, start is where the initial click was, and you
+   // can drag in either direction)
+
+   unsigned char insert_mode;
+   // each textfield keeps its own insert mode state. to keep an app-wide
+   // insert mode, copy this value in/out of the app state
+
+   int row_count_per_page;
+   // page size in number of row.
+   // this value MUST be set to >0 for pageup or pagedown in multilines documents.
+
+   /////////////////////
+   //
+   // private data
+   //
+   unsigned char cursor_at_end_of_line; // not implemented yet
+   unsigned char initialized;
+   unsigned char has_preferred_x;
+   unsigned char single_line;
+   unsigned char padding1, padding2, padding3;
+   float preferred_x; // this determines where the cursor up/down tries to seek to along x
+   StbUndoState undostate;
+} STB_TexteditState;
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//     StbTexteditRow
+//
+// Result of layout query, used by stb_textedit to determine where
+// the text in each row is.
+
+// result of layout query
+typedef struct
+{
+   float x0,x1;             // starting x location, end x location (allows for align=right, etc)
+   float baseline_y_delta;  // position of baseline relative to previous row's baseline
+   float ymin,ymax;         // height of row above and below baseline
+   int num_chars;
+} StbTexteditRow;
+#endif //INCLUDE_STB_TEXTEDIT_H
+
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////
+////   Implementation mode
+////
+////
+
+
+// implementation isn't include-guarded, since it might have indirectly
+// included just the "header" portion
+#ifdef STB_TEXTEDIT_IMPLEMENTATION
+
+#ifndef STB_TEXTEDIT_memmove
+#include <string.h>
+#define STB_TEXTEDIT_memmove memmove
+#endif
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Mouse input handling
+//
+
+// traverse the layout to locate the nearest character to a display position
+static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
+{
+   StbTexteditRow r;
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   float base_y = 0, prev_x;
+   int i=0, k;
+
+   r.x0 = r.x1 = 0;
+   r.ymin = r.ymax = 0;
+   r.num_chars = 0;
+
+   // search rows to find one that straddles 'y'
+   while (i < n) {
+      STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+      if (r.num_chars <= 0)
+         return n;
+
+      if (i==0 && y < base_y + r.ymin)
+         return 0;
+
+      if (y < base_y + r.ymax)
+         break;
+
+      i += r.num_chars;
+      base_y += r.baseline_y_delta;
+   }
+
+   // below all text, return 'after' last character
+   if (i >= n)
+      return n;
+
+   // check if it's before the beginning of the line
+   if (x < r.x0)
+      return i;
+
+   // check if it's before the end of the line
+   if (x < r.x1) {
+      // search characters in row for one that straddles 'x'
+      prev_x = r.x0;
+      for (k=0; k < r.num_chars; ++k) {
+         float w = STB_TEXTEDIT_GETWIDTH(str, i, k);
+         if (x < prev_x+w) {
+            if (x < prev_x+w/2)
+               return k+i;
+            else
+               return k+i+1;
+         }
+         prev_x += w;
+      }
+      // shouldn't happen, but if it does, fall through to end-of-line case
+   }
+
+   // if the last character is a newline, return that. otherwise return 'after' the last character
+   if (STB_TEXTEDIT_GETCHAR(str, i+r.num_chars-1) == STB_TEXTEDIT_NEWLINE)
+      return i+r.num_chars-1;
+   else
+      return i+r.num_chars;
+}
+
+// API click: on mouse down, move the cursor to the clicked location, and reset the selection
+static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
+   // goes off the top or bottom of the text
+   if( state->single_line )
+   {
+      StbTexteditRow r;
+      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+      y = r.ymin;
+   }
+
+   state->cursor = stb_text_locate_coord(str, x, y);
+   state->select_start = state->cursor;
+   state->select_end = state->cursor;
+   state->has_preferred_x = 0;
+}
+
+// API drag: on mouse drag, move the cursor and selection endpoint to the clicked location
+static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
+{
+   int p = 0;
+
+   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
+   // goes off the top or bottom of the text
+   if( state->single_line )
+   {
+      StbTexteditRow r;
+      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+      y = r.ymin;
+   }
+
+   if (state->select_start == state->select_end)
+      state->select_start = state->cursor;
+
+   p = stb_text_locate_coord(str, x, y);
+   state->cursor = state->select_end = p;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Keyboard input handling
+//
+
+// forward declarations
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state);
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length);
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length);
+
+typedef struct
+{
+   float x,y;    // position of n'th character
+   float height; // height of line
+   int first_char, length; // first char of row, and length
+   int prev_first;  // first char of previous row
+} StbFindState;
+
+// find the x/y location of a character, and remember info about the previous row in
+// case we get a move-up event (for page up, we'll have to rescan)
+static void stb_textedit_find_charpos(StbFindState *find, STB_TEXTEDIT_STRING *str, int n, int single_line)
+{
+   StbTexteditRow r;
+   int prev_start = 0;
+   int z = STB_TEXTEDIT_STRINGLEN(str);
+   int i=0, first;
+
+   if (n == z) {
+      // if it's at the end, then find the last line -- simpler than trying to
+      // explicitly handle this case in the regular code
+      if (single_line) {
+         STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
+         find->y = 0;
+         find->first_char = 0;
+         find->length = z;
+         find->height = r.ymax - r.ymin;
+         find->x = r.x1;
+      } else {
+         find->y = 0;
+         find->x = 0;
+         find->height = 1;
+         while (i < z) {
+            STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+            prev_start = i;
+            i += r.num_chars;
+         }
+         find->first_char = i;
+         find->length = 0;
+         find->prev_first = prev_start;
+      }
+      return;
+   }
+
+   // search rows to find the one that straddles character n
+   find->y = 0;
+
+   for(;;) {
+      STB_TEXTEDIT_LAYOUTROW(&r, str, i);
+      if (n < i + r.num_chars)
+         break;
+      prev_start = i;
+      i += r.num_chars;
+      find->y += r.baseline_y_delta;
+   }
+
+   find->first_char = first = i;
+   find->length = r.num_chars;
+   find->height = r.ymax - r.ymin;
+   find->prev_first = prev_start;
+
+   // now scan to find xpos
+   find->x = r.x0;
+   for (i=0; first+i < n; ++i)
+      find->x += STB_TEXTEDIT_GETWIDTH(str, first, i);
+}
+
+#define STB_TEXT_HAS_SELECTION(s)   ((s)->select_start != (s)->select_end)
+
+// make the selection/cursor state valid if client altered the string
+static void stb_textedit_clamp(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   int n = STB_TEXTEDIT_STRINGLEN(str);
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      if (state->select_start > n) state->select_start = n;
+      if (state->select_end   > n) state->select_end = n;
+      // if clamping forced them to be equal, move the cursor to match
+      if (state->select_start == state->select_end)
+         state->cursor = state->select_start;
+   }
+   if (state->cursor > n) state->cursor = n;
+}
+
+// delete characters while updating undo
+static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
+{
+   stb_text_makeundo_delete(str, state, where, len);
+   STB_TEXTEDIT_DELETECHARS(str, where, len);
+   state->has_preferred_x = 0;
+}
+
+// delete the section
+static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   stb_textedit_clamp(str, state);
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      if (state->select_start < state->select_end) {
+         stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_start);
+         state->select_end = state->cursor = state->select_start;
+      } else {
+         stb_textedit_delete(str, state, state->select_end, state->select_start - state->select_end);
+         state->select_start = state->cursor = state->select_end;
+      }
+      state->has_preferred_x = 0;
+   }
+}
+
+// canoncialize the selection so start <= end
+static void stb_textedit_sortselection(STB_TexteditState *state)
+{
+   if (state->select_end < state->select_start) {
+      int temp = state->select_end;
+      state->select_end = state->select_start;
+      state->select_start = temp;
+   }
+}
+
+// move cursor to first character of selection
+static void stb_textedit_move_to_first(STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      stb_textedit_sortselection(state);
+      state->cursor = state->select_start;
+      state->select_end = state->select_start;
+      state->has_preferred_x = 0;
+   }
+}
+
+// move cursor to last character of selection
+static void stb_textedit_move_to_last(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      stb_textedit_sortselection(state);
+      stb_textedit_clamp(str, state);
+      state->cursor = state->select_end;
+      state->select_start = state->select_end;
+      state->has_preferred_x = 0;
+   }
+}
+
+#ifdef STB_TEXTEDIT_IS_SPACE
+static int is_word_boundary( STB_TEXTEDIT_STRING *str, int idx )
+{
+   return idx > 0 ? (STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str,idx-1) ) && !STB_TEXTEDIT_IS_SPACE( STB_TEXTEDIT_GETCHAR(str, idx) ) ) : 1;
+}
+
+#ifndef STB_TEXTEDIT_MOVEWORDLEFT
+static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *str, int c )
+{
+   --c; // always move at least one character
+   while( c >= 0 && !is_word_boundary( str, c ) )
+      --c;
+
+   if( c < 0 )
+      c = 0;
+
+   return c;
+}
+#define STB_TEXTEDIT_MOVEWORDLEFT stb_textedit_move_to_word_previous
+#endif
+
+#ifndef STB_TEXTEDIT_MOVEWORDRIGHT
+static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *str, int c )
+{
+   const int len = STB_TEXTEDIT_STRINGLEN(str);
+   ++c; // always move at least one character
+   while( c < len && !is_word_boundary( str, c ) )
+      ++c;
+
+   if( c > len )
+      c = len;
+
+   return c;
+}
+#define STB_TEXTEDIT_MOVEWORDRIGHT stb_textedit_move_to_word_next
+#endif
+
+#endif
+
+// update selection and cursor to match each other
+static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)
+{
+   if (!STB_TEXT_HAS_SELECTION(state))
+      state->select_start = state->select_end = state->cursor;
+   else
+      state->cursor = state->select_end;
+}
+
+// API cut: delete selection
+static int stb_textedit_cut(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   if (STB_TEXT_HAS_SELECTION(state)) {
+      stb_textedit_delete_selection(str,state); // implicitly clamps
+      state->has_preferred_x = 0;
+      return 1;
+   }
+   return 0;
+}
+
+// API paste: replace existing selection with passed-in text
+static int stb_textedit_paste_internal(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE *text, int len)
+{
+   // if there's a selection, the paste should delete it
+   stb_textedit_clamp(str, state);
+   stb_textedit_delete_selection(str,state);
+   // try to insert the characters
+   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) {
+      stb_text_makeundo_insert(state, state->cursor, len);
+      state->cursor += len;
+      state->has_preferred_x = 0;
+      return 1;
+   }
+   // [DEAR IMGUI]
+   //// remove the undo since we didn't actually insert the characters
+   //if (state->undostate.undo_point)
+   //   --state->undostate.undo_point;
+   // note: paste failure will leave deleted selection, may be restored with an undo (see https://github.com/nothings/stb/issues/734 for details)
+   return 0;
+}
+
+#ifndef STB_TEXTEDIT_KEYTYPE
+#define STB_TEXTEDIT_KEYTYPE int
+#endif
+
+// API key: process a keyboard input
+static void stb_textedit_key(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_KEYTYPE key)
+{
+retry:
+   switch (key) {
+      default: {
+         int c = STB_TEXTEDIT_KEYTOTEXT(key);
+         if (c > 0) {
+            STB_TEXTEDIT_CHARTYPE ch = (STB_TEXTEDIT_CHARTYPE) c;
+
+            // can't add newline in single-line mode
+            if (c == '\n' && state->single_line)
+               break;
+
+            if (state->insert_mode && !STB_TEXT_HAS_SELECTION(state) && state->cursor < STB_TEXTEDIT_STRINGLEN(str)) {
+               stb_text_makeundo_replace(str, state, state->cursor, 1, 1);
+               STB_TEXTEDIT_DELETECHARS(str, state->cursor, 1);
+               if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
+                  ++state->cursor;
+                  state->has_preferred_x = 0;
+               }
+            } else {
+               stb_textedit_delete_selection(str,state); // implicitly clamps
+               if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, &ch, 1)) {
+                  stb_text_makeundo_insert(state, state->cursor, 1);
+                  ++state->cursor;
+                  state->has_preferred_x = 0;
+               }
+            }
+         }
+         break;
+      }
+
+#ifdef STB_TEXTEDIT_K_INSERT
+      case STB_TEXTEDIT_K_INSERT:
+         state->insert_mode = !state->insert_mode;
+         break;
+#endif
+
+      case STB_TEXTEDIT_K_UNDO:
+         stb_text_undo(str, state);
+         state->has_preferred_x = 0;
+         break;
+
+      case STB_TEXTEDIT_K_REDO:
+         stb_text_redo(str, state);
+         state->has_preferred_x = 0;
+         break;
+
+      case STB_TEXTEDIT_K_LEFT:
+         // if currently there's a selection, move cursor to start of selection
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_first(state);
+         else
+            if (state->cursor > 0)
+               --state->cursor;
+         state->has_preferred_x = 0;
+         break;
+
+      case STB_TEXTEDIT_K_RIGHT:
+         // if currently there's a selection, move cursor to end of selection
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_last(str, state);
+         else
+            ++state->cursor;
+         stb_textedit_clamp(str, state);
+         state->has_preferred_x = 0;
+         break;
+
+      case STB_TEXTEDIT_K_LEFT | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_clamp(str, state);
+         stb_textedit_prep_selection_at_cursor(state);
+         // move selection left
+         if (state->select_end > 0)
+            --state->select_end;
+         state->cursor = state->select_end;
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_MOVEWORDLEFT
+      case STB_TEXTEDIT_K_WORDLEFT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_first(state);
+         else {
+            state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
+            stb_textedit_clamp( str, state );
+         }
+         break;
+
+      case STB_TEXTEDIT_K_WORDLEFT | STB_TEXTEDIT_K_SHIFT:
+         if( !STB_TEXT_HAS_SELECTION( state ) )
+            stb_textedit_prep_selection_at_cursor(state);
+
+         state->cursor = STB_TEXTEDIT_MOVEWORDLEFT(str, state->cursor);
+         state->select_end = state->cursor;
+
+         stb_textedit_clamp( str, state );
+         break;
+#endif
+
+#ifdef STB_TEXTEDIT_MOVEWORDRIGHT
+      case STB_TEXTEDIT_K_WORDRIGHT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_last(str, state);
+         else {
+            state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
+            stb_textedit_clamp( str, state );
+         }
+         break;
+
+      case STB_TEXTEDIT_K_WORDRIGHT | STB_TEXTEDIT_K_SHIFT:
+         if( !STB_TEXT_HAS_SELECTION( state ) )
+            stb_textedit_prep_selection_at_cursor(state);
+
+         state->cursor = STB_TEXTEDIT_MOVEWORDRIGHT(str, state->cursor);
+         state->select_end = state->cursor;
+
+         stb_textedit_clamp( str, state );
+         break;
+#endif
+
+      case STB_TEXTEDIT_K_RIGHT | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_prep_selection_at_cursor(state);
+         // move selection right
+         ++state->select_end;
+         stb_textedit_clamp(str, state);
+         state->cursor = state->select_end;
+         state->has_preferred_x = 0;
+         break;
+
+      case STB_TEXTEDIT_K_DOWN:
+      case STB_TEXTEDIT_K_DOWN | STB_TEXTEDIT_K_SHIFT:
+      case STB_TEXTEDIT_K_PGDOWN:
+      case STB_TEXTEDIT_K_PGDOWN | STB_TEXTEDIT_K_SHIFT: {
+         StbFindState find;
+         StbTexteditRow row;
+         int i, j, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+         int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGDOWN;
+         int row_count = is_page ? state->row_count_per_page : 1;
+
+         if (!is_page && state->single_line) {
+            // on windows, up&down in single-line behave like left&right
+            key = STB_TEXTEDIT_K_RIGHT | (key & STB_TEXTEDIT_K_SHIFT);
+            goto retry;
+         }
+
+         if (sel)
+            stb_textedit_prep_selection_at_cursor(state);
+         else if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_last(str, state);
+
+         // compute current position of cursor point
+         stb_textedit_clamp(str, state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+         for (j = 0; j < row_count; ++j) {
+            float x, goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+            int start = find.first_char + find.length;
+
+            if (find.length == 0)
+               break;
+
+            // [DEAR IMGUI]
+            // going down while being on the last line shouldn't bring us to that line end
+            if (STB_TEXTEDIT_GETCHAR(str, find.first_char + find.length - 1) != STB_TEXTEDIT_NEWLINE)
+               break;
+
+            // now find character position down a row
+            state->cursor = start;
+            STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+            x = row.x0;
+            for (i=0; i < row.num_chars; ++i) {
+               float dx = STB_TEXTEDIT_GETWIDTH(str, start, i);
+               #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+               if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+                  break;
+               #endif
+               x += dx;
+               if (x > goal_x)
+                  break;
+               ++state->cursor;
+            }
+            stb_textedit_clamp(str, state);
+
+            state->has_preferred_x = 1;
+            state->preferred_x = goal_x;
+
+            if (sel)
+               state->select_end = state->cursor;
+
+            // go to next line
+            find.first_char = find.first_char + find.length;
+            find.length = row.num_chars;
+         }
+         break;
+      }
+
+      case STB_TEXTEDIT_K_UP:
+      case STB_TEXTEDIT_K_UP | STB_TEXTEDIT_K_SHIFT:
+      case STB_TEXTEDIT_K_PGUP:
+      case STB_TEXTEDIT_K_PGUP | STB_TEXTEDIT_K_SHIFT: {
+         StbFindState find;
+         StbTexteditRow row;
+         int i, j, prev_scan, sel = (key & STB_TEXTEDIT_K_SHIFT) != 0;
+         int is_page = (key & ~STB_TEXTEDIT_K_SHIFT) == STB_TEXTEDIT_K_PGUP;
+         int row_count = is_page ? state->row_count_per_page : 1;
+
+         if (!is_page && state->single_line) {
+            // on windows, up&down become left&right
+            key = STB_TEXTEDIT_K_LEFT | (key & STB_TEXTEDIT_K_SHIFT);
+            goto retry;
+         }
+
+         if (sel)
+            stb_textedit_prep_selection_at_cursor(state);
+         else if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_move_to_first(state);
+
+         // compute current position of cursor point
+         stb_textedit_clamp(str, state);
+         stb_textedit_find_charpos(&find, str, state->cursor, state->single_line);
+
+         for (j = 0; j < row_count; ++j) {
+            float  x, goal_x = state->has_preferred_x ? state->preferred_x : find.x;
+
+            // can only go up if there's a previous row
+            if (find.prev_first == find.first_char)
+               break;
+
+            // now find character position up a row
+            state->cursor = find.prev_first;
+            STB_TEXTEDIT_LAYOUTROW(&row, str, state->cursor);
+            x = row.x0;
+            for (i=0; i < row.num_chars; ++i) {
+               float dx = STB_TEXTEDIT_GETWIDTH(str, find.prev_first, i);
+               #ifdef STB_TEXTEDIT_GETWIDTH_NEWLINE
+               if (dx == STB_TEXTEDIT_GETWIDTH_NEWLINE)
+                  break;
+               #endif
+               x += dx;
+               if (x > goal_x)
+                  break;
+               ++state->cursor;
+            }
+            stb_textedit_clamp(str, state);
+
+            state->has_preferred_x = 1;
+            state->preferred_x = goal_x;
+
+            if (sel)
+               state->select_end = state->cursor;
+
+            // go to previous line
+            // (we need to scan previous line the hard way. maybe we could expose this as a new API function?)
+            prev_scan = find.prev_first > 0 ? find.prev_first - 1 : 0;
+            while (prev_scan > 0 && STB_TEXTEDIT_GETCHAR(str, prev_scan - 1) != STB_TEXTEDIT_NEWLINE)
+               --prev_scan;
+            find.first_char = find.prev_first;
+            find.prev_first = prev_scan;
+         }
+         break;
+      }
+
+      case STB_TEXTEDIT_K_DELETE:
+      case STB_TEXTEDIT_K_DELETE | STB_TEXTEDIT_K_SHIFT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_delete_selection(str, state);
+         else {
+            int n = STB_TEXTEDIT_STRINGLEN(str);
+            if (state->cursor < n)
+               stb_textedit_delete(str, state, state->cursor, 1);
+         }
+         state->has_preferred_x = 0;
+         break;
+
+      case STB_TEXTEDIT_K_BACKSPACE:
+      case STB_TEXTEDIT_K_BACKSPACE | STB_TEXTEDIT_K_SHIFT:
+         if (STB_TEXT_HAS_SELECTION(state))
+            stb_textedit_delete_selection(str, state);
+         else {
+            stb_textedit_clamp(str, state);
+            if (state->cursor > 0) {
+               stb_textedit_delete(str, state, state->cursor-1, 1);
+               --state->cursor;
+            }
+         }
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_K_TEXTSTART2
+      case STB_TEXTEDIT_K_TEXTSTART2:
+#endif
+      case STB_TEXTEDIT_K_TEXTSTART:
+         state->cursor = state->select_start = state->select_end = 0;
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_K_TEXTEND2
+      case STB_TEXTEDIT_K_TEXTEND2:
+#endif
+      case STB_TEXTEDIT_K_TEXTEND:
+         state->cursor = STB_TEXTEDIT_STRINGLEN(str);
+         state->select_start = state->select_end = 0;
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_K_TEXTSTART2
+      case STB_TEXTEDIT_K_TEXTSTART2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+      case STB_TEXTEDIT_K_TEXTSTART | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_prep_selection_at_cursor(state);
+         state->cursor = state->select_end = 0;
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_K_TEXTEND2
+      case STB_TEXTEDIT_K_TEXTEND2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+      case STB_TEXTEDIT_K_TEXTEND | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_prep_selection_at_cursor(state);
+         state->cursor = state->select_end = STB_TEXTEDIT_STRINGLEN(str);
+         state->has_preferred_x = 0;
+         break;
+
+
+#ifdef STB_TEXTEDIT_K_LINESTART2
+      case STB_TEXTEDIT_K_LINESTART2:
+#endif
+      case STB_TEXTEDIT_K_LINESTART:
+         stb_textedit_clamp(str, state);
+         stb_textedit_move_to_first(state);
+         if (state->single_line)
+            state->cursor = 0;
+         else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
+            --state->cursor;
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_K_LINEEND2
+      case STB_TEXTEDIT_K_LINEEND2:
+#endif
+      case STB_TEXTEDIT_K_LINEEND: {
+         int n = STB_TEXTEDIT_STRINGLEN(str);
+         stb_textedit_clamp(str, state);
+         stb_textedit_move_to_first(state);
+         if (state->single_line)
+             state->cursor = n;
+         else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
+             ++state->cursor;
+         state->has_preferred_x = 0;
+         break;
+      }
+
+#ifdef STB_TEXTEDIT_K_LINESTART2
+      case STB_TEXTEDIT_K_LINESTART2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+      case STB_TEXTEDIT_K_LINESTART | STB_TEXTEDIT_K_SHIFT:
+         stb_textedit_clamp(str, state);
+         stb_textedit_prep_selection_at_cursor(state);
+         if (state->single_line)
+            state->cursor = 0;
+         else while (state->cursor > 0 && STB_TEXTEDIT_GETCHAR(str, state->cursor-1) != STB_TEXTEDIT_NEWLINE)
+            --state->cursor;
+         state->select_end = state->cursor;
+         state->has_preferred_x = 0;
+         break;
+
+#ifdef STB_TEXTEDIT_K_LINEEND2
+      case STB_TEXTEDIT_K_LINEEND2 | STB_TEXTEDIT_K_SHIFT:
+#endif
+      case STB_TEXTEDIT_K_LINEEND | STB_TEXTEDIT_K_SHIFT: {
+         int n = STB_TEXTEDIT_STRINGLEN(str);
+         stb_textedit_clamp(str, state);
+         stb_textedit_prep_selection_at_cursor(state);
+         if (state->single_line)
+             state->cursor = n;
+         else while (state->cursor < n && STB_TEXTEDIT_GETCHAR(str, state->cursor) != STB_TEXTEDIT_NEWLINE)
+            ++state->cursor;
+         state->select_end = state->cursor;
+         state->has_preferred_x = 0;
+         break;
+      }
+   }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//      Undo processing
+//
+// @OPTIMIZE: the undo/redo buffer should be circular
+
+static void stb_textedit_flush_redo(StbUndoState *state)
+{
+   state->redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+   state->redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+}
+
+// discard the oldest entry in the undo list
+static void stb_textedit_discard_undo(StbUndoState *state)
+{
+   if (state->undo_point > 0) {
+      // if the 0th undo state has characters, clean those up
+      if (state->undo_rec[0].char_storage >= 0) {
+         int n = state->undo_rec[0].insert_length, i;
+         // delete n characters from all other records
+         state->undo_char_point -= n;
+         STB_TEXTEDIT_memmove(state->undo_char, state->undo_char + n, (size_t) (state->undo_char_point*sizeof(STB_TEXTEDIT_CHARTYPE)));
+         for (i=0; i < state->undo_point; ++i)
+            if (state->undo_rec[i].char_storage >= 0)
+               state->undo_rec[i].char_storage -= n; // @OPTIMIZE: get rid of char_storage and infer it
+      }
+      --state->undo_point;
+      STB_TEXTEDIT_memmove(state->undo_rec, state->undo_rec+1, (size_t) (state->undo_point*sizeof(state->undo_rec[0])));
+   }
+}
+
+// discard the oldest entry in the redo list--it's bad if this
+// ever happens, but because undo & redo have to store the actual
+// characters in different cases, the redo character buffer can
+// fill up even though the undo buffer didn't
+static void stb_textedit_discard_redo(StbUndoState *state)
+{
+   int k = STB_TEXTEDIT_UNDOSTATECOUNT-1;
+
+   if (state->redo_point <= k) {
+      // if the k'th undo state has characters, clean those up
+      if (state->undo_rec[k].char_storage >= 0) {
+         int n = state->undo_rec[k].insert_length, i;
+         // move the remaining redo character data to the end of the buffer
+         state->redo_char_point += n;
+         STB_TEXTEDIT_memmove(state->undo_char + state->redo_char_point, state->undo_char + state->redo_char_point-n, (size_t) ((STB_TEXTEDIT_UNDOCHARCOUNT - state->redo_char_point)*sizeof(STB_TEXTEDIT_CHARTYPE)));
+         // adjust the position of all the other records to account for above memmove
+         for (i=state->redo_point; i < k; ++i)
+            if (state->undo_rec[i].char_storage >= 0)
+               state->undo_rec[i].char_storage += n;
+      }
+      // now move all the redo records towards the end of the buffer; the first one is at 'redo_point'
+      // [DEAR IMGUI]
+      size_t move_size = (size_t)((STB_TEXTEDIT_UNDOSTATECOUNT - state->redo_point - 1) * sizeof(state->undo_rec[0]));
+      const char* buf_begin = (char*)state->undo_rec; (void)buf_begin;
+      const char* buf_end   = (char*)state->undo_rec + sizeof(state->undo_rec); (void)buf_end;
+      IM_ASSERT(((char*)(state->undo_rec + state->redo_point)) >= buf_begin);
+      IM_ASSERT(((char*)(state->undo_rec + state->redo_point + 1) + move_size) <= buf_end);
+      STB_TEXTEDIT_memmove(state->undo_rec + state->redo_point+1, state->undo_rec + state->redo_point, move_size);
+
+      // now move redo_point to point to the new one
+      ++state->redo_point;
+   }
+}
+
+static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, int numchars)
+{
+   // any time we create a new undo record, we discard redo
+   stb_textedit_flush_redo(state);
+
+   // if we have no free records, we have to make room, by sliding the
+   // existing records down
+   if (state->undo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+      stb_textedit_discard_undo(state);
+
+   // if the characters to store won't possibly fit in the buffer, we can't undo
+   if (numchars > STB_TEXTEDIT_UNDOCHARCOUNT) {
+      state->undo_point = 0;
+      state->undo_char_point = 0;
+      return NULL;
+   }
+
+   // if we don't have enough free characters in the buffer, we have to make room
+   while (state->undo_char_point + numchars > STB_TEXTEDIT_UNDOCHARCOUNT)
+      stb_textedit_discard_undo(state);
+
+   return &state->undo_rec[state->undo_point++];
+}
+
+static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
+{
+   StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
+   if (r == NULL)
+      return NULL;
+
+   r->where = pos;
+   r->insert_length = (STB_TEXTEDIT_POSITIONTYPE) insert_len;
+   r->delete_length = (STB_TEXTEDIT_POSITIONTYPE) delete_len;
+
+   if (insert_len == 0) {
+      r->char_storage = -1;
+      return NULL;
+   } else {
+      r->char_storage = state->undo_char_point;
+      state->undo_char_point += insert_len;
+      return &state->undo_char[r->char_storage];
+   }
+}
+
+static void stb_text_undo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   StbUndoState *s = &state->undostate;
+   StbUndoRecord u, *r;
+   if (s->undo_point == 0)
+      return;
+
+   // we need to do two things: apply the undo record, and create a redo record
+   u = s->undo_rec[s->undo_point-1];
+   r = &s->undo_rec[s->redo_point-1];
+   r->char_storage = -1;
+
+   r->insert_length = u.delete_length;
+   r->delete_length = u.insert_length;
+   r->where = u.where;
+
+   if (u.delete_length) {
+      // if the undo record says to delete characters, then the redo record will
+      // need to re-insert the characters that get deleted, so we need to store
+      // them.
+
+      // there are three cases:
+      //    there's enough room to store the characters
+      //    characters stored for *redoing* don't leave room for redo
+      //    characters stored for *undoing* don't leave room for redo
+      // if the last is true, we have to bail
+
+      if (s->undo_char_point + u.delete_length >= STB_TEXTEDIT_UNDOCHARCOUNT) {
+         // the undo records take up too much character space; there's no space to store the redo characters
+         r->insert_length = 0;
+      } else {
+         int i;
+
+         // there's definitely room to store the characters eventually
+         while (s->undo_char_point + u.delete_length > s->redo_char_point) {
+            // should never happen:
+            if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+               return;
+            // there's currently not enough room, so discard a redo record
+            stb_textedit_discard_redo(s);
+         }
+         r = &s->undo_rec[s->redo_point-1];
+
+         r->char_storage = s->redo_char_point - u.delete_length;
+         s->redo_char_point = s->redo_char_point - u.delete_length;
+
+         // now save the characters
+         for (i=0; i < u.delete_length; ++i)
+            s->undo_char[r->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u.where + i);
+      }
+
+      // now we can carry out the deletion
+      STB_TEXTEDIT_DELETECHARS(str, u.where, u.delete_length);
+   }
+
+   // check type of recorded action:
+   if (u.insert_length) {
+      // easy case: was a deletion, so we need to insert n characters
+      STB_TEXTEDIT_INSERTCHARS(str, u.where, &s->undo_char[u.char_storage], u.insert_length);
+      s->undo_char_point -= u.insert_length;
+   }
+
+   state->cursor = u.where + u.insert_length;
+
+   s->undo_point--;
+   s->redo_point--;
+}
+
+static void stb_text_redo(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
+{
+   StbUndoState *s = &state->undostate;
+   StbUndoRecord *u, r;
+   if (s->redo_point == STB_TEXTEDIT_UNDOSTATECOUNT)
+      return;
+
+   // we need to do two things: apply the redo record, and create an undo record
+   u = &s->undo_rec[s->undo_point];
+   r = s->undo_rec[s->redo_point];
+
+   // we KNOW there must be room for the undo record, because the redo record
+   // was derived from an undo record
+
+   u->delete_length = r.insert_length;
+   u->insert_length = r.delete_length;
+   u->where = r.where;
+   u->char_storage = -1;
+
+   if (r.delete_length) {
+      // the redo record requires us to delete characters, so the undo record
+      // needs to store the characters
+
+      if (s->undo_char_point + u->insert_length > s->redo_char_point) {
+         u->insert_length = 0;
+         u->delete_length = 0;
+      } else {
+         int i;
+         u->char_storage = s->undo_char_point;
+         s->undo_char_point = s->undo_char_point + u->insert_length;
+
+         // now save the characters
+         for (i=0; i < u->insert_length; ++i)
+            s->undo_char[u->char_storage + i] = STB_TEXTEDIT_GETCHAR(str, u->where + i);
+      }
+
+      STB_TEXTEDIT_DELETECHARS(str, r.where, r.delete_length);
+   }
+
+   if (r.insert_length) {
+      // easy case: need to insert n characters
+      STB_TEXTEDIT_INSERTCHARS(str, r.where, &s->undo_char[r.char_storage], r.insert_length);
+      s->redo_char_point += r.insert_length;
+   }
+
+   state->cursor = r.where + r.insert_length;
+
+   s->undo_point++;
+   s->redo_point++;
+}
+
+static void stb_text_makeundo_insert(STB_TexteditState *state, int where, int length)
+{
+   stb_text_createundo(&state->undostate, where, 0, length);
+}
+
+static void stb_text_makeundo_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int length)
+{
+   int i;
+   STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, length, 0);
+   if (p) {
+      for (i=0; i < length; ++i)
+         p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
+   }
+}
+
+static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)
+{
+   int i;
+   STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length);
+   if (p) {
+      for (i=0; i < old_length; ++i)
+         p[i] = STB_TEXTEDIT_GETCHAR(str, where+i);
+   }
+}
+
+// reset the state to default
+static void stb_textedit_clear_state(STB_TexteditState *state, int is_single_line)
+{
+   state->undostate.undo_point = 0;
+   state->undostate.undo_char_point = 0;
+   state->undostate.redo_point = STB_TEXTEDIT_UNDOSTATECOUNT;
+   state->undostate.redo_char_point = STB_TEXTEDIT_UNDOCHARCOUNT;
+   state->select_end = state->select_start = 0;
+   state->cursor = 0;
+   state->has_preferred_x = 0;
+   state->preferred_x = 0;
+   state->cursor_at_end_of_line = 0;
+   state->initialized = 1;
+   state->single_line = (unsigned char) is_single_line;
+   state->insert_mode = 0;
+   state->row_count_per_page = 0;
+}
+
+// API initialize
+static void stb_textedit_initialize_state(STB_TexteditState *state, int is_single_line)
+{
+   stb_textedit_clear_state(state, is_single_line);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+
+static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
+{
+   return stb_textedit_paste_internal(str, state, (STB_TEXTEDIT_CHARTYPE *) ctext, len);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+#endif//STB_TEXTEDIT_IMPLEMENTATION
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
+ rlImGui/imgui/imstb_truetype.h view
@@ -0,0 +1,4903 @@+// [DEAR IMGUI]
+// This is a slightly modified version of stb_truetype.h 1.20.
+// Mostly fixing for compiler and static analyzer warnings.
+// Grep for [DEAR IMGUI] to find the changes.
+
+// stb_truetype.h - v1.20 - public domain
+// authored from 2009-2016 by Sean Barrett / RAD Game Tools
+//
+//   This library processes TrueType files:
+//        parse files
+//        extract glyph metrics
+//        extract glyph shapes
+//        render glyphs to one-channel bitmaps with antialiasing (box filter)
+//        render glyphs to one-channel SDF bitmaps (signed-distance field/function)
+//
+//   Todo:
+//        non-MS cmaps
+//        crashproof on bad data
+//        hinting? (no longer patented)
+//        cleartype-style AA?
+//        optimize: use simple memory allocator for intermediates
+//        optimize: build edge-list directly from curves
+//        optimize: rasterize directly from curves?
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Mikko Mononen: compound shape support, more cmap formats
+//   Tor Andersson: kerning, subpixel rendering
+//   Dougall Johnson: OpenType / Type 2 font handling
+//   Daniel Ribeiro Maciel: basic GPOS-based kerning
+//
+//   Misc other:
+//       Ryan Gordon
+//       Simon Glass
+//       github:IntellectualKitty
+//       Imanol Celaya
+//       Daniel Ribeiro Maciel
+//
+//   Bug/warning reports/fixes:
+//       "Zer" on mollyrocket       Fabian "ryg" Giesen
+//       Cass Everitt               Martins Mozeiko
+//       stoiko (Haemimont Games)   Cap Petschulat
+//       Brian Hook                 Omar Cornut
+//       Walter van Niftrik         github:aloucks
+//       David Gow                  Peter LaValle
+//       David Given                Sergey Popov
+//       Ivan-Assen Ivanov          Giumo X. Clanjor
+//       Anthony Pesch              Higor Euripedes
+//       Johan Duparc               Thomas Fields
+//       Hou Qiming                 Derek Vinyard
+//       Rob Loach                  Cort Stratton
+//       Kenney Phillis Jr.         github:oyvindjam
+//       Brian Costabile            github:vassvik
+//
+// VERSION HISTORY
+//
+//   1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics()
+//   1.19 (2018-02-11) GPOS kerning, STBTT_fmod
+//   1.18 (2018-01-29) add missing function
+//   1.17 (2017-07-23) make more arguments const; doc fix
+//   1.16 (2017-07-12) SDF support
+//   1.15 (2017-03-03) make more arguments const
+//   1.14 (2017-01-16) num-fonts-in-TTC function
+//   1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
+//   1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
+//   1.11 (2016-04-02) fix unused-variable warning
+//   1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef
+//   1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly
+//   1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
+//   1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
+//                     variant PackFontRanges to pack and render in separate phases;
+//                     fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
+//                     fixed an assert() bug in the new rasterizer
+//                     replace assert() with STBTT_assert() in new rasterizer
+//
+//   Full history can be found at the end of this file.
+//
+// LICENSE
+//
+//   See end of file for license information.
+//
+// USAGE
+//
+//   Include this file in whatever places need to refer to it. In ONE C/C++
+//   file, write:
+//      #define STB_TRUETYPE_IMPLEMENTATION
+//   before the #include of this file. This expands out the actual
+//   implementation into that C/C++ file.
+//
+//   To make the implementation private to the file that generates the implementation,
+//      #define STBTT_STATIC
+//
+//   Simple 3D API (don't ship this, but it's fine for tools and quick start)
+//           stbtt_BakeFontBitmap()               -- bake a font to a bitmap for use as texture
+//           stbtt_GetBakedQuad()                 -- compute quad to draw for a given char
+//
+//   Improved 3D API (more shippable):
+//           #include "stb_rect_pack.h"           -- optional, but you really want it
+//           stbtt_PackBegin()
+//           stbtt_PackSetOversampling()          -- for improved quality on small fonts
+//           stbtt_PackFontRanges()               -- pack and renders
+//           stbtt_PackEnd()
+//           stbtt_GetPackedQuad()
+//
+//   "Load" a font file from a memory buffer (you have to keep the buffer loaded)
+//           stbtt_InitFont()
+//           stbtt_GetFontOffsetForIndex()        -- indexing for TTC font collections
+//           stbtt_GetNumberOfFonts()             -- number of fonts for TTC font collections
+//
+//   Render a unicode codepoint to a bitmap
+//           stbtt_GetCodepointBitmap()           -- allocates and returns a bitmap
+//           stbtt_MakeCodepointBitmap()          -- renders into bitmap you provide
+//           stbtt_GetCodepointBitmapBox()        -- how big the bitmap must be
+//
+//   Character advance/positioning
+//           stbtt_GetCodepointHMetrics()
+//           stbtt_GetFontVMetrics()
+//           stbtt_GetFontVMetricsOS2()
+//           stbtt_GetCodepointKernAdvance()
+//
+//   Starting with version 1.06, the rasterizer was replaced with a new,
+//   faster and generally-more-precise rasterizer. The new rasterizer more
+//   accurately measures pixel coverage for anti-aliasing, except in the case
+//   where multiple shapes overlap, in which case it overestimates the AA pixel
+//   coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If
+//   this turns out to be a problem, you can re-enable the old rasterizer with
+//        #define STBTT_RASTERIZER_VERSION 1
+//   which will incur about a 15% speed hit.
+//
+// ADDITIONAL DOCUMENTATION
+//
+//   Immediately after this block comment are a series of sample programs.
+//
+//   After the sample programs is the "header file" section. This section
+//   includes documentation for each API function.
+//
+//   Some important concepts to understand to use this library:
+//
+//      Codepoint
+//         Characters are defined by unicode codepoints, e.g. 65 is
+//         uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is
+//         the hiragana for "ma".
+//
+//      Glyph
+//         A visual character shape (every codepoint is rendered as
+//         some glyph)
+//
+//      Glyph index
+//         A font-specific integer ID representing a glyph
+//
+//      Baseline
+//         Glyph shapes are defined relative to a baseline, which is the
+//         bottom of uppercase characters. Characters extend both above
+//         and below the baseline.
+//
+//      Current Point
+//         As you draw text to the screen, you keep track of a "current point"
+//         which is the origin of each character. The current point's vertical
+//         position is the baseline. Even "baked fonts" use this model.
+//
+//      Vertical Font Metrics
+//         The vertical qualities of the font, used to vertically position
+//         and space the characters. See docs for stbtt_GetFontVMetrics.
+//
+//      Font Size in Pixels or Points
+//         The preferred interface for specifying font sizes in stb_truetype
+//         is to specify how tall the font's vertical extent should be in pixels.
+//         If that sounds good enough, skip the next paragraph.
+//
+//         Most font APIs instead use "points", which are a common typographic
+//         measurement for describing font size, defined as 72 points per inch.
+//         stb_truetype provides a point API for compatibility. However, true
+//         "per inch" conventions don't make much sense on computer displays
+//         since different monitors have different number of pixels per
+//         inch. For example, Windows traditionally uses a convention that
+//         there are 96 pixels per inch, thus making 'inch' measurements have
+//         nothing to do with inches, and thus effectively defining a point to
+//         be 1.333 pixels. Additionally, the TrueType font data provides
+//         an explicit scale factor to scale a given font's glyphs to points,
+//         but the author has observed that this scale factor is often wrong
+//         for non-commercial fonts, thus making fonts scaled in points
+//         according to the TrueType spec incoherently sized in practice.
+//
+// DETAILED USAGE:
+//
+//  Scale:
+//    Select how high you want the font to be, in points or pixels.
+//    Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute
+//    a scale factor SF that will be used by all other functions.
+//
+//  Baseline:
+//    You need to select a y-coordinate that is the baseline of where
+//    your text will appear. Call GetFontBoundingBox to get the baseline-relative
+//    bounding box for all characters. SF*-y0 will be the distance in pixels
+//    that the worst-case character could extend above the baseline, so if
+//    you want the top edge of characters to appear at the top of the
+//    screen where y=0, then you would set the baseline to SF*-y0.
+//
+//  Current point:
+//    Set the current point where the first character will appear. The
+//    first character could extend left of the current point; this is font
+//    dependent. You can either choose a current point that is the leftmost
+//    point and hope, or add some padding, or check the bounding box or
+//    left-side-bearing of the first character to be displayed and set
+//    the current point based on that.
+//
+//  Displaying a character:
+//    Compute the bounding box of the character. It will contain signed values
+//    relative to <current_point, baseline>. I.e. if it returns x0,y0,x1,y1,
+//    then the character should be displayed in the rectangle from
+//    <current_point+SF*x0, baseline+SF*y0> to <current_point+SF*x1,baseline+SF*y1).
+//
+//  Advancing for the next character:
+//    Call GlyphHMetrics, and compute 'current_point += SF * advance'.
+//
+//
+// ADVANCED USAGE
+//
+//   Quality:
+//
+//    - Use the functions with Subpixel at the end to allow your characters
+//      to have subpixel positioning. Since the font is anti-aliased, not
+//      hinted, this is very import for quality. (This is not possible with
+//      baked fonts.)
+//
+//    - Kerning is now supported, and if you're supporting subpixel rendering
+//      then kerning is worth using to give your text a polished look.
+//
+//   Performance:
+//
+//    - Convert Unicode codepoints to glyph indexes and operate on the glyphs;
+//      if you don't do this, stb_truetype is forced to do the conversion on
+//      every call.
+//
+//    - There are a lot of memory allocations. We should modify it to take
+//      a temp buffer and allocate from the temp buffer (without freeing),
+//      should help performance a lot.
+//
+// NOTES
+//
+//   The system uses the raw data found in the .ttf file without changing it
+//   and without building auxiliary data structures. This is a bit inefficient
+//   on little-endian systems (the data is big-endian), but assuming you're
+//   caching the bitmaps or glyph shapes this shouldn't be a big deal.
+//
+//   It appears to be very hard to programmatically determine what font a
+//   given file is in a general way. I provide an API for this, but I don't
+//   recommend it.
+//
+//
+// SOURCE STATISTICS (based on v0.6c, 2050 LOC)
+//
+//   Documentation & header file        520 LOC  \___ 660 LOC documentation
+//   Sample code                        140 LOC  /
+//   Truetype parsing                   620 LOC  ---- 620 LOC TrueType
+//   Software rasterization             240 LOC  \.
+//   Curve tessellation                 120 LOC   \__ 550 LOC Bitmap creation
+//   Bitmap management                  100 LOC   /
+//   Baked bitmap interface              70 LOC  /
+//   Font name matching & access        150 LOC  ---- 150
+//   C runtime library abstraction       60 LOC  ----  60
+//
+//
+// PERFORMANCE MEASUREMENTS FOR 1.06:
+//
+//                      32-bit     64-bit
+//   Previous release:  8.83 s     7.68 s
+//   Pool allocations:  7.72 s     6.34 s
+//   Inline sort     :  6.54 s     5.65 s
+//   New rasterizer  :  5.63 s     5.00 s
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+////  SAMPLE PROGRAMS
+////
+//
+//  Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless
+//
+#if 0
+#define STB_TRUETYPE_IMPLEMENTATION  // force following include to generate implementation
+#include "stb_truetype.h"
+
+unsigned char ttf_buffer[1<<20];
+unsigned char temp_bitmap[512*512];
+
+stbtt_bakedchar cdata[96]; // ASCII 32..126 is 95 glyphs
+GLuint ftex;
+
+void my_stbtt_initfont(void)
+{
+   fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb"));
+   stbtt_BakeFontBitmap(ttf_buffer,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits!
+   // can free ttf_buffer at this point
+   glGenTextures(1, &ftex);
+   glBindTexture(GL_TEXTURE_2D, ftex);
+   glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap);
+   // can free temp_bitmap at this point
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+}
+
+void my_stbtt_print(float x, float y, char *text)
+{
+   // assume orthographic projection with units = screen pixels, origin at top left
+   glEnable(GL_TEXTURE_2D);
+   glBindTexture(GL_TEXTURE_2D, ftex);
+   glBegin(GL_QUADS);
+   while (*text) {
+      if (*text >= 32 && *text < 128) {
+         stbtt_aligned_quad q;
+         stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9
+         glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0);
+         glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0);
+         glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1);
+         glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1);
+      }
+      ++text;
+   }
+   glEnd();
+}
+#endif
+//
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program (this compiles): get a single bitmap, print as ASCII art
+//
+#if 0
+#include <stdio.h>
+#define STB_TRUETYPE_IMPLEMENTATION  // force following include to generate implementation
+#include "stb_truetype.h"
+
+char ttf_buffer[1<<25];
+
+int main(int argc, char **argv)
+{
+   stbtt_fontinfo font;
+   unsigned char *bitmap;
+   int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20);
+
+   fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb"));
+
+   stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0));
+   bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0);
+
+   for (j=0; j < h; ++j) {
+      for (i=0; i < w; ++i)
+         putchar(" .:ioVM@"[bitmap[j*w+i]>>5]);
+      putchar('\n');
+   }
+   return 0;
+}
+#endif
+//
+// Output:
+//
+//     .ii.
+//    @@@@@@.
+//   V@Mio@@o
+//   :i.  V@V
+//     :oM@@M
+//   :@@@MM@M
+//   @@o  o@M
+//  :@@.  M@M
+//   @@@o@@@@
+//   :M@@V:@@.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Complete program: print "Hello World!" banner, with bugs
+//
+#if 0
+char buffer[24<<20];
+unsigned char screen[20][79];
+
+int main(int arg, char **argv)
+{
+   stbtt_fontinfo font;
+   int i,j,ascent,baseline,ch=0;
+   float scale, xpos=2; // leave a little padding in case the character extends left
+   char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness
+
+   fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb"));
+   stbtt_InitFont(&font, buffer, 0);
+
+   scale = stbtt_ScaleForPixelHeight(&font, 15);
+   stbtt_GetFontVMetrics(&font, &ascent,0,0);
+   baseline = (int) (ascent*scale);
+
+   while (text[ch]) {
+      int advance,lsb,x0,y0,x1,y1;
+      float x_shift = xpos - (float) floor(xpos);
+      stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb);
+      stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1);
+      stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]);
+      // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong
+      // because this API is really for baking character bitmaps into textures. if you want to render
+      // a sequence of characters, you really need to render each bitmap to a temp buffer, then
+      // "alpha blend" that into the working buffer
+      xpos += (advance * scale);
+      if (text[ch+1])
+         xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]);
+      ++ch;
+   }
+
+   for (j=0; j < 20; ++j) {
+      for (i=0; i < 78; ++i)
+         putchar(" .:ioVM@"[screen[j][i]>>5]);
+      putchar('\n');
+   }
+
+   return 0;
+}
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+////
+////   INTEGRATION WITH YOUR CODEBASE
+////
+////   The following sections allow you to supply alternate definitions
+////   of C library functions used by stb_truetype, e.g. if you don't
+////   link with the C runtime library.
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+   // #define your own (u)stbtt_int8/16/32 before including to override this
+   #ifndef stbtt_uint8
+   typedef unsigned char   stbtt_uint8;
+   typedef signed   char   stbtt_int8;
+   typedef unsigned short  stbtt_uint16;
+   typedef signed   short  stbtt_int16;
+   typedef unsigned int    stbtt_uint32;
+   typedef signed   int    stbtt_int32;
+   #endif
+
+   typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1];
+   typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1];
+
+   // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h
+   #ifndef STBTT_ifloor
+   #include <math.h>
+   #define STBTT_ifloor(x)   ((int) floor(x))
+   #define STBTT_iceil(x)    ((int) ceil(x))
+   #endif
+
+   #ifndef STBTT_sqrt
+   #include <math.h>
+   #define STBTT_sqrt(x)      sqrt(x)
+   #define STBTT_pow(x,y)     pow(x,y)
+   #endif
+
+   #ifndef STBTT_fmod
+   #include <math.h>
+   #define STBTT_fmod(x,y)    fmod(x,y)
+   #endif
+
+   #ifndef STBTT_cos
+   #include <math.h>
+   #define STBTT_cos(x)       cos(x)
+   #define STBTT_acos(x)      acos(x)
+   #endif
+
+   #ifndef STBTT_fabs
+   #include <math.h>
+   #define STBTT_fabs(x)      fabs(x)
+   #endif
+
+   // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h
+   #ifndef STBTT_malloc
+   #include <stdlib.h>
+   #define STBTT_malloc(x,u)  ((void)(u),malloc(x))
+   #define STBTT_free(x,u)    ((void)(u),free(x))
+   #endif
+
+   #ifndef STBTT_assert
+   #include <assert.h>
+   #define STBTT_assert(x)    assert(x)
+   #endif
+
+   #ifndef STBTT_strlen
+   #include <string.h>
+   #define STBTT_strlen(x)    strlen(x)
+   #endif
+
+   #ifndef STBTT_memcpy
+   #include <string.h>
+   #define STBTT_memcpy       memcpy
+   #define STBTT_memset       memset
+   #endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+////   INTERFACE
+////
+////
+
+#ifndef __STB_INCLUDE_STB_TRUETYPE_H__
+#define __STB_INCLUDE_STB_TRUETYPE_H__
+
+#ifdef STBTT_STATIC
+#define STBTT_DEF static
+#else
+#define STBTT_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// private structure
+typedef struct
+{
+   unsigned char *data;
+   int cursor;
+   int size;
+} stbtt__buf;
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// TEXTURE BAKING API
+//
+// If you use this API, you only have to call two functions ever.
+//
+
+typedef struct
+{
+   unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
+   float xoff,yoff,xadvance;
+} stbtt_bakedchar;
+
+STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,  // font location (use offset=0 for plain .ttf)
+                                float pixel_height,                     // height of font in pixels
+                                unsigned char *pixels, int pw, int ph,  // bitmap to be filled in
+                                int first_char, int num_chars,          // characters to bake
+                                stbtt_bakedchar *chardata);             // you allocate this, it's num_chars long
+// if return is positive, the first unused row of the bitmap
+// if return is negative, returns the negative of the number of characters that fit
+// if return is 0, no characters fit and no rows were used
+// This uses a very crappy packing.
+
+typedef struct
+{
+   float x0,y0,s0,t0; // top-left
+   float x1,y1,s1,t1; // bottom-right
+} stbtt_aligned_quad;
+
+STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph,  // same data as above
+                               int char_index,             // character to display
+                               float *xpos, float *ypos,   // pointers to current position in screen pixel space
+                               stbtt_aligned_quad *q,      // output: quad to draw
+                               int opengl_fillrule);       // true if opengl fill rule; false if DX9 or earlier
+// Call GetBakedQuad with char_index = 'character - first_char', and it
+// creates the quad you need to draw and advances the current position.
+//
+// The coordinate system used assumes y increases downwards.
+//
+// Characters will extend both above and below the current position;
+// see discussion of "BASELINE" above.
+//
+// It's inefficient; you might want to c&p it and optimize it.
+
+STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap);
+// Query the font vertical metrics without having to create a font first.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// NEW TEXTURE BAKING API
+//
+// This provides options for packing multiple fonts into one atlas, not
+// perfectly but better than nothing.
+
+typedef struct
+{
+   unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap
+   float xoff,yoff,xadvance;
+   float xoff2,yoff2;
+} stbtt_packedchar;
+
+typedef struct stbtt_pack_context stbtt_pack_context;
+typedef struct stbtt_fontinfo stbtt_fontinfo;
+#ifndef STB_RECT_PACK_VERSION
+typedef struct stbrp_rect stbrp_rect;
+#endif
+
+STBTT_DEF int  stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context);
+// Initializes a packing context stored in the passed-in stbtt_pack_context.
+// Future calls using this context will pack characters into the bitmap passed
+// in here: a 1-channel bitmap that is width * height. stride_in_bytes is
+// the distance from one row to the next (or 0 to mean they are packed tightly
+// together). "padding" is the amount of padding to leave between each
+// character (normally you want '1' for bitmaps you'll use as textures with
+// bilinear filtering).
+//
+// Returns 0 on failure, 1 on success.
+
+STBTT_DEF void stbtt_PackEnd  (stbtt_pack_context *spc);
+// Cleans up the packing context and frees all memory.
+
+#define STBTT_POINT_SIZE(x)   (-(x))
+
+STBTT_DEF int  stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
+                                int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range);
+// Creates character bitmaps from the font_index'th font found in fontdata (use
+// font_index=0 if you don't know what that is). It creates num_chars_in_range
+// bitmaps for characters with unicode values starting at first_unicode_char_in_range
+// and increasing. Data for how to render them is stored in chardata_for_range;
+// pass these to stbtt_GetPackedQuad to get back renderable quads.
+//
+// font_size is the full height of the character from ascender to descender,
+// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed
+// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE()
+// and pass that result as 'font_size':
+//       ...,                  20 , ... // font max minus min y is 20 pixels tall
+//       ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall
+
+typedef struct
+{
+   float font_size;
+   int first_unicode_codepoint_in_range;  // if non-zero, then the chars are continuous, and this is the first codepoint
+   int *array_of_unicode_codepoints;       // if non-zero, then this is an array of unicode codepoints
+   int num_chars;
+   stbtt_packedchar *chardata_for_range; // output
+   unsigned char h_oversample, v_oversample; // don't set these, they're used internally
+} stbtt_pack_range;
+
+STBTT_DEF int  stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges);
+// Creates character bitmaps from multiple ranges of characters stored in
+// ranges. This will usually create a better-packed bitmap than multiple
+// calls to stbtt_PackFontRange. Note that you can call this multiple
+// times within a single PackBegin/PackEnd.
+
+STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample);
+// Oversampling a font increases the quality by allowing higher-quality subpixel
+// positioning, and is especially valuable at smaller text sizes.
+//
+// This function sets the amount of oversampling for all following calls to
+// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given
+// pack context. The default (no oversampling) is achieved by h_oversample=1
+// and v_oversample=1. The total number of pixels required is
+// h_oversample*v_oversample larger than the default; for example, 2x2
+// oversampling requires 4x the storage of 1x1. For best results, render
+// oversampled textures with bilinear filtering. Look at the readme in
+// stb/tests/oversample for information about oversampled fonts
+//
+// To use with PackFontRangesGather etc., you must set it before calls
+// call to PackFontRangesGatherRects.
+
+STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip);
+// If skip != 0, this tells stb_truetype to skip any codepoints for which
+// there is no corresponding glyph. If skip=0, which is the default, then
+// codepoints without a glyph recived the font's "missing character" glyph,
+// typically an empty box by convention.
+
+STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph,  // same data as above
+                               int char_index,             // character to display
+                               float *xpos, float *ypos,   // pointers to current position in screen pixel space
+                               stbtt_aligned_quad *q,      // output: quad to draw
+                               int align_to_integer);
+
+STBTT_DEF int  stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
+STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects);
+STBTT_DEF int  stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects);
+// Calling these functions in sequence is roughly equivalent to calling
+// stbtt_PackFontRanges(). If you more control over the packing of multiple
+// fonts, or if you want to pack custom data into a font texture, take a look
+// at the source to of stbtt_PackFontRanges() and create a custom version
+// using these functions, e.g. call GatherRects multiple times,
+// building up a single array of rects, then call PackRects once,
+// then call RenderIntoRects repeatedly. This may result in a
+// better packing than calling PackFontRanges multiple times
+// (or it may not).
+
+// this is an opaque structure that you shouldn't mess with which holds
+// all the context needed from PackBegin to PackEnd.
+struct stbtt_pack_context {
+   void *user_allocator_context;
+   void *pack_info;
+   int   width;
+   int   height;
+   int   stride_in_bytes;
+   int   padding;
+   int   skip_missing;
+   unsigned int   h_oversample, v_oversample;
+   unsigned char *pixels;
+   void  *nodes;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// FONT LOADING
+//
+//
+
+STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data);
+// This function will determine the number of fonts in a font file.  TrueType
+// collection (.ttc) files may contain multiple fonts, while TrueType font
+// (.ttf) files only contain one font. The number of fonts can be used for
+// indexing with the previous function where the index is between zero and one
+// less than the total fonts. If an error occurs, -1 is returned.
+
+STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index);
+// Each .ttf/.ttc file may have more than one font. Each font has a sequential
+// index number starting from 0. Call this function to get the font offset for
+// a given index; it returns -1 if the index is out of range. A regular .ttf
+// file will only define one font and it always be at offset 0, so it will
+// return '0' for index 0, and -1 for all other indices.
+
+// The following structure is defined publicly so you can declare one on
+// the stack or as a global or etc, but you should treat it as opaque.
+struct stbtt_fontinfo
+{
+   void           * userdata;
+   unsigned char  * data;              // pointer to .ttf file
+   int              fontstart;         // offset of start of font
+
+   int numGlyphs;                     // number of glyphs, needed for range checking
+
+   int loca,head,glyf,hhea,hmtx,kern,gpos; // table locations as offset from start of .ttf
+   int index_map;                     // a cmap mapping for our chosen character encoding
+   int indexToLocFormat;              // format needed to map from glyph index to glyph
+
+   stbtt__buf cff;                    // cff font data
+   stbtt__buf charstrings;            // the charstring index
+   stbtt__buf gsubrs;                 // global charstring subroutines index
+   stbtt__buf subrs;                  // private charstring subroutines index
+   stbtt__buf fontdicts;              // array of font dicts
+   stbtt__buf fdselect;               // map from glyph to fontdict
+};
+
+STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset);
+// Given an offset into the file that defines a font, this function builds
+// the necessary cached info for the rest of the system. You must allocate
+// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't
+// need to do anything special to free it, because the contents are pure
+// value data with no additional data structures. Returns 0 on failure.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CHARACTER TO GLYPH-INDEX CONVERSIOn
+
+STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint);
+// If you're going to perform multiple operations on the same character
+// and you want a speed-up, call this function with the character you're
+// going to process, then use glyph-based functions instead of the
+// codepoint-based functions.
+// Returns 0 if the character codepoint is not defined in the font.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CHARACTER PROPERTIES
+//
+
+STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels);
+// computes a scale factor to produce a font whose "height" is 'pixels' tall.
+// Height is measured as the distance from the highest ascender to the lowest
+// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics
+// and computing:
+//       scale = pixels / (ascent - descent)
+// so if you prefer to measure height by the ascent only, use a similar calculation.
+
+STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels);
+// computes a scale factor to produce a font whose EM size is mapped to
+// 'pixels' tall. This is probably what traditional APIs compute, but
+// I'm not positive.
+
+STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap);
+// ascent is the coordinate above the baseline the font extends; descent
+// is the coordinate below the baseline the font extends (i.e. it is typically negative)
+// lineGap is the spacing between one row's descent and the next row's ascent...
+// so you should advance the vertical position by "*ascent - *descent + *lineGap"
+//   these are expressed in unscaled coordinates, so you must multiply by
+//   the scale factor for a given size
+
+STBTT_DEF int  stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap);
+// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2
+// table (specific to MS/Windows TTF files).
+//
+// Returns 1 on success (table present), 0 on failure.
+
+STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1);
+// the bounding box around all possible characters
+
+STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing);
+// leftSideBearing is the offset from the current horizontal position to the left edge of the character
+// advanceWidth is the offset from the current horizontal position to the next horizontal position
+//   these are expressed in unscaled coordinates
+
+STBTT_DEF int  stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2);
+// an additional amount to add to the 'advance' value between ch1 and ch2
+
+STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1);
+// Gets the bounding box of the visible part of the glyph, in unscaled coordinates
+
+STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing);
+STBTT_DEF int  stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2);
+STBTT_DEF int  stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
+// as above, but takes one or more glyph indices for greater efficiency
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// GLYPH SHAPES (you probably don't need these, but they have to go before
+// the bitmaps for C declaration-order reasons)
+//
+
+#ifndef STBTT_vmove // you can predefine these to use different values (but why?)
+   enum {
+      STBTT_vmove=1,
+      STBTT_vline,
+      STBTT_vcurve,
+      STBTT_vcubic
+   };
+#endif
+
+#ifndef stbtt_vertex // you can predefine this to use different values
+                   // (we share this with other code at RAD)
+   #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file
+   typedef struct
+   {
+      stbtt_vertex_type x,y,cx,cy,cx1,cy1;
+      unsigned char type,padding;
+   } stbtt_vertex;
+#endif
+
+STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index);
+// returns non-zero if nothing is drawn for this glyph
+
+STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices);
+STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices);
+// returns # of vertices and fills *vertices with the pointer to them
+//   these are expressed in "unscaled" coordinates
+//
+// The shape is a series of contours. Each one starts with
+// a STBTT_moveto, then consists of a series of mixed
+// STBTT_lineto and STBTT_curveto segments. A lineto
+// draws a line from previous endpoint to its x,y; a curveto
+// draws a quadratic bezier from previous endpoint to
+// its x,y, using cx,cy as the bezier control point.
+
+STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices);
+// frees the data allocated above
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// BITMAP RENDERING
+//
+
+STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata);
+// frees the bitmap allocated below
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+// allocates a large-enough single-channel 8bpp bitmap and renders the
+// specified character/glyph at the specified scale into it, with
+// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque).
+// *width & *height are filled out with the width & height of the bitmap,
+// which is stored left-to-right, top-to-bottom.
+//
+// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff);
+// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel
+// shift for the character
+
+STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint);
+// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap
+// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap
+// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the
+// width and height and positioning info for it first.
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint);
+// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel
+// shift for the character
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint);
+// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering
+// is performed (see stbtt_PackSetOversampling)
+
+STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+// get the bbox of the bitmap centered around the glyph origin; so the
+// bitmap width is ix1-ix0, height is iy1-iy0, and location to place
+// the bitmap top left is (leftSideBearing*scale,iy0).
+// (Note that the bitmap uses y-increases-down, but the shape uses
+// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.)
+
+STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel
+// shift for the character
+
+// the following functions are equivalent to the above functions, but operate
+// on glyph indices instead of Unicode codepoints (for efficiency)
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff);
+STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph);
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph);
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph);
+STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1);
+STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1);
+
+
+// @TODO: don't expose this structure
+typedef struct
+{
+   int w,h,stride;
+   unsigned char *pixels;
+} stbtt__bitmap;
+
+// rasterize a shape with quadratic beziers into a bitmap
+STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result,        // 1-channel bitmap to draw into
+                               float flatness_in_pixels,     // allowable error of curve in pixels
+                               stbtt_vertex *vertices,       // array of vertices defining shape
+                               int num_verts,                // number of vertices in above array
+                               float scale_x, float scale_y, // scale applied to input vertices
+                               float shift_x, float shift_y, // translation applied to input vertices
+                               int x_off, int y_off,         // another translation applied to input
+                               int invert,                   // if non-zero, vertically flip shape
+                               void *userdata);              // context for to STBTT_MALLOC
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Signed Distance Function (or Field) rendering
+
+STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata);
+// frees the SDF bitmap allocated below
+
+STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff);
+STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff);
+// These functions compute a discretized SDF field for a single character, suitable for storing
+// in a single-channel texture, sampling with bilinear filtering, and testing against
+// larger than some threshold to produce scalable fonts.
+//        info              --  the font
+//        scale             --  controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap
+//        glyph/codepoint   --  the character to generate the SDF for
+//        padding           --  extra "pixels" around the character which are filled with the distance to the character (not 0),
+//                                 which allows effects like bit outlines
+//        onedge_value      --  value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character)
+//        pixel_dist_scale  --  what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale)
+//                                 if positive, > onedge_value is inside; if negative, < onedge_value is inside
+//        width,height      --  output height & width of the SDF bitmap (including padding)
+//        xoff,yoff         --  output origin of the character
+//        return value      --  a 2D array of bytes 0..255, width*height in size
+//
+// pixel_dist_scale & onedge_value are a scale & bias that allows you to make
+// optimal use of the limited 0..255 for your application, trading off precision
+// and special effects. SDF values outside the range 0..255 are clamped to 0..255.
+//
+// Example:
+//      scale = stbtt_ScaleForPixelHeight(22)
+//      padding = 5
+//      onedge_value = 180
+//      pixel_dist_scale = 180/5.0 = 36.0
+//
+//      This will create an SDF bitmap in which the character is about 22 pixels
+//      high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled
+//      shape, sample the SDF at each pixel and fill the pixel if the SDF value
+//      is greater than or equal to 180/255. (You'll actually want to antialias,
+//      which is beyond the scope of this example.) Additionally, you can compute
+//      offset outlines (e.g. to stroke the character border inside & outside,
+//      or only outside). For example, to fill outside the character up to 3 SDF
+//      pixels, you would compare against (180-36.0*3)/255 = 72/255. The above
+//      choice of variables maps a range from 5 pixels outside the shape to
+//      2 pixels inside the shape to 0..255; this is intended primarily for apply
+//      outside effects only (the interior range is needed to allow proper
+//      antialiasing of the font at *smaller* sizes)
+//
+// The function computes the SDF analytically at each SDF pixel, not by e.g.
+// building a higher-res bitmap and approximating it. In theory the quality
+// should be as high as possible for an SDF of this size & representation, but
+// unclear if this is true in practice (perhaps building a higher-res bitmap
+// and computing from that can allow drop-out prevention).
+//
+// The algorithm has not been optimized at all, so expect it to be slow
+// if computing lots of characters or very large sizes.
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Finding the right font...
+//
+// You should really just solve this offline, keep your own tables
+// of what font is what, and don't try to get it out of the .ttf file.
+// That's because getting it out of the .ttf file is really hard, because
+// the names in the file can appear in many possible encodings, in many
+// possible languages, and e.g. if you need a case-insensitive comparison,
+// the details of that depend on the encoding & language in a complex way
+// (actually underspecified in truetype, but also gigantic).
+//
+// But you can use the provided functions in two possible ways:
+//     stbtt_FindMatchingFont() will use *case-sensitive* comparisons on
+//             unicode-encoded names to try to find the font you want;
+//             you can run this before calling stbtt_InitFont()
+//
+//     stbtt_GetFontNameString() lets you get any of the various strings
+//             from the file yourself and do your own comparisons on them.
+//             You have to have called stbtt_InitFont() first.
+
+
+STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags);
+// returns the offset (not index) of the font that matches, or -1 if none
+//   if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold".
+//   if you use any other flag, use a font name like "Arial"; this checks
+//     the 'macStyle' header field; i don't know if fonts set this consistently
+#define STBTT_MACSTYLE_DONTCARE     0
+#define STBTT_MACSTYLE_BOLD         1
+#define STBTT_MACSTYLE_ITALIC       2
+#define STBTT_MACSTYLE_UNDERSCORE   4
+#define STBTT_MACSTYLE_NONE         8   // <= not same as 0, this makes us check the bitfield is 0
+
+STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2);
+// returns 1/0 whether the first string interpreted as utf8 is identical to
+// the second string interpreted as big-endian utf16... useful for strings from next func
+
+STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID);
+// returns the string (which may be big-endian double byte, e.g. for unicode)
+// and puts the length in bytes in *length.
+//
+// some of the values for the IDs are below; for more see the truetype spec:
+//     http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html
+//     http://www.microsoft.com/typography/otspec/name.htm
+
+enum { // platformID
+   STBTT_PLATFORM_ID_UNICODE   =0,
+   STBTT_PLATFORM_ID_MAC       =1,
+   STBTT_PLATFORM_ID_ISO       =2,
+   STBTT_PLATFORM_ID_MICROSOFT =3
+};
+
+enum { // encodingID for STBTT_PLATFORM_ID_UNICODE
+   STBTT_UNICODE_EID_UNICODE_1_0    =0,
+   STBTT_UNICODE_EID_UNICODE_1_1    =1,
+   STBTT_UNICODE_EID_ISO_10646      =2,
+   STBTT_UNICODE_EID_UNICODE_2_0_BMP=3,
+   STBTT_UNICODE_EID_UNICODE_2_0_FULL=4
+};
+
+enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT
+   STBTT_MS_EID_SYMBOL        =0,
+   STBTT_MS_EID_UNICODE_BMP   =1,
+   STBTT_MS_EID_SHIFTJIS      =2,
+   STBTT_MS_EID_UNICODE_FULL  =10
+};
+
+enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes
+   STBTT_MAC_EID_ROMAN        =0,   STBTT_MAC_EID_ARABIC       =4,
+   STBTT_MAC_EID_JAPANESE     =1,   STBTT_MAC_EID_HEBREW       =5,
+   STBTT_MAC_EID_CHINESE_TRAD =2,   STBTT_MAC_EID_GREEK        =6,
+   STBTT_MAC_EID_KOREAN       =3,   STBTT_MAC_EID_RUSSIAN      =7
+};
+
+enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID...
+       // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs
+   STBTT_MS_LANG_ENGLISH     =0x0409,   STBTT_MS_LANG_ITALIAN     =0x0410,
+   STBTT_MS_LANG_CHINESE     =0x0804,   STBTT_MS_LANG_JAPANESE    =0x0411,
+   STBTT_MS_LANG_DUTCH       =0x0413,   STBTT_MS_LANG_KOREAN      =0x0412,
+   STBTT_MS_LANG_FRENCH      =0x040c,   STBTT_MS_LANG_RUSSIAN     =0x0419,
+   STBTT_MS_LANG_GERMAN      =0x0407,   STBTT_MS_LANG_SPANISH     =0x0409,
+   STBTT_MS_LANG_HEBREW      =0x040d,   STBTT_MS_LANG_SWEDISH     =0x041D
+};
+
+enum { // languageID for STBTT_PLATFORM_ID_MAC
+   STBTT_MAC_LANG_ENGLISH      =0 ,   STBTT_MAC_LANG_JAPANESE     =11,
+   STBTT_MAC_LANG_ARABIC       =12,   STBTT_MAC_LANG_KOREAN       =23,
+   STBTT_MAC_LANG_DUTCH        =4 ,   STBTT_MAC_LANG_RUSSIAN      =32,
+   STBTT_MAC_LANG_FRENCH       =1 ,   STBTT_MAC_LANG_SPANISH      =6 ,
+   STBTT_MAC_LANG_GERMAN       =2 ,   STBTT_MAC_LANG_SWEDISH      =5 ,
+   STBTT_MAC_LANG_HEBREW       =10,   STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33,
+   STBTT_MAC_LANG_ITALIAN      =3 ,   STBTT_MAC_LANG_CHINESE_TRAD =19
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __STB_INCLUDE_STB_TRUETYPE_H__
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+////
+////   IMPLEMENTATION
+////
+////
+
+#ifdef STB_TRUETYPE_IMPLEMENTATION
+
+#ifndef STBTT_MAX_OVERSAMPLE
+#define STBTT_MAX_OVERSAMPLE   8
+#endif
+
+#if STBTT_MAX_OVERSAMPLE > 255
+#error "STBTT_MAX_OVERSAMPLE cannot be > 255"
+#endif
+
+typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1];
+
+#ifndef STBTT_RASTERIZER_VERSION
+#define STBTT_RASTERIZER_VERSION 2
+#endif
+
+#ifdef _MSC_VER
+#define STBTT__NOTUSED(v)  (void)(v)
+#else
+#define STBTT__NOTUSED(v)  (void)sizeof(v)
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+//
+// stbtt__buf helpers to parse data from file
+//
+
+static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)
+{
+   if (b->cursor >= b->size)
+      return 0;
+   return b->data[b->cursor++];
+}
+
+static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)
+{
+   if (b->cursor >= b->size)
+      return 0;
+   return b->data[b->cursor];
+}
+
+static void stbtt__buf_seek(stbtt__buf *b, int o)
+{
+   STBTT_assert(!(o > b->size || o < 0));
+   b->cursor = (o > b->size || o < 0) ? b->size : o;
+}
+
+static void stbtt__buf_skip(stbtt__buf *b, int o)
+{
+   stbtt__buf_seek(b, b->cursor + o);
+}
+
+static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)
+{
+   stbtt_uint32 v = 0;
+   int i;
+   STBTT_assert(n >= 1 && n <= 4);
+   for (i = 0; i < n; i++)
+      v = (v << 8) | stbtt__buf_get8(b);
+   return v;
+}
+
+static stbtt__buf stbtt__new_buf(const void *p, size_t size)
+{
+   stbtt__buf r;
+   STBTT_assert(size < 0x40000000);
+   r.data = (stbtt_uint8*) p;
+   r.size = (int) size;
+   r.cursor = 0;
+   return r;
+}
+
+#define stbtt__buf_get16(b)  stbtt__buf_get((b), 2)
+#define stbtt__buf_get32(b)  stbtt__buf_get((b), 4)
+
+static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)
+{
+   stbtt__buf r = stbtt__new_buf(NULL, 0);
+   if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r;
+   r.data = b->data + o;
+   r.size = s;
+   return r;
+}
+
+static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
+{
+   int count, start, offsize;
+   start = b->cursor;
+   count = stbtt__buf_get16(b);
+   if (count) {
+      offsize = stbtt__buf_get8(b);
+      STBTT_assert(offsize >= 1 && offsize <= 4);
+      stbtt__buf_skip(b, offsize * count);
+      stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
+   }
+   return stbtt__buf_range(b, start, b->cursor - start);
+}
+
+static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
+{
+   int b0 = stbtt__buf_get8(b);
+   if (b0 >= 32 && b0 <= 246)       return b0 - 139;
+   else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108;
+   else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108;
+   else if (b0 == 28)               return stbtt__buf_get16(b);
+   else if (b0 == 29)               return stbtt__buf_get32(b);
+   STBTT_assert(0);
+   return 0;
+}
+
+static void stbtt__cff_skip_operand(stbtt__buf *b) {
+   int v, b0 = stbtt__buf_peek8(b);
+   STBTT_assert(b0 >= 28);
+   if (b0 == 30) {
+      stbtt__buf_skip(b, 1);
+      while (b->cursor < b->size) {
+         v = stbtt__buf_get8(b);
+         if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
+            break;
+      }
+   } else {
+      stbtt__cff_int(b);
+   }
+}
+
+static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)
+{
+   stbtt__buf_seek(b, 0);
+   while (b->cursor < b->size) {
+      int start = b->cursor, end, op;
+      while (stbtt__buf_peek8(b) >= 28)
+         stbtt__cff_skip_operand(b);
+      end = b->cursor;
+      op = stbtt__buf_get8(b);
+      if (op == 12)  op = stbtt__buf_get8(b) | 0x100;
+      if (op == key) return stbtt__buf_range(b, start, end-start);
+   }
+   return stbtt__buf_range(b, 0, 0);
+}
+
+static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
+{
+   int i;
+   stbtt__buf operands = stbtt__dict_get(b, key);
+   for (i = 0; i < outcount && operands.cursor < operands.size; i++)
+      out[i] = stbtt__cff_int(&operands);
+}
+
+static int stbtt__cff_index_count(stbtt__buf *b)
+{
+   stbtt__buf_seek(b, 0);
+   return stbtt__buf_get16(b);
+}
+
+static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
+{
+   int count, offsize, start, end;
+   stbtt__buf_seek(&b, 0);
+   count = stbtt__buf_get16(&b);
+   offsize = stbtt__buf_get8(&b);
+   STBTT_assert(i >= 0 && i < count);
+   STBTT_assert(offsize >= 1 && offsize <= 4);
+   stbtt__buf_skip(&b, i*offsize);
+   start = stbtt__buf_get(&b, offsize);
+   end = stbtt__buf_get(&b, offsize);
+   return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
+}
+
+//////////////////////////////////////////////////////////////////////////
+//
+// accessors to parse data from file
+//
+
+// on platforms that don't allow misaligned reads, if we want to allow
+// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE
+
+#define ttBYTE(p)     (* (stbtt_uint8 *) (p))
+#define ttCHAR(p)     (* (stbtt_int8 *) (p))
+#define ttFixed(p)    ttLONG(p)
+
+static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }
+static stbtt_int16 ttSHORT(stbtt_uint8 *p)   { return p[0]*256 + p[1]; }
+static stbtt_uint32 ttULONG(stbtt_uint8 *p)  { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
+static stbtt_int32 ttLONG(stbtt_uint8 *p)    { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
+
+#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
+#define stbtt_tag(p,str)           stbtt_tag4(p,str[0],str[1],str[2],str[3])
+
+static int stbtt__isfont(stbtt_uint8 *font)
+{
+   // check the version number
+   if (stbtt_tag4(font, '1',0,0,0))  return 1; // TrueType 1
+   if (stbtt_tag(font, "typ1"))   return 1; // TrueType with type 1 font -- we don't support this!
+   if (stbtt_tag(font, "OTTO"))   return 1; // OpenType with CFF
+   if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
+   if (stbtt_tag(font, "true"))   return 1; // Apple specification for TrueType fonts
+   return 0;
+}
+
+// @OPTIMIZE: binary search
+static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
+{
+   stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
+   stbtt_uint32 tabledir = fontstart + 12;
+   stbtt_int32 i;
+   for (i=0; i < num_tables; ++i) {
+      stbtt_uint32 loc = tabledir + 16*i;
+      if (stbtt_tag(data+loc+0, tag))
+         return ttULONG(data+loc+8);
+   }
+   return 0;
+}
+
+static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)
+{
+   // if it's just a font, there's only one valid index
+   if (stbtt__isfont(font_collection))
+      return index == 0 ? 0 : -1;
+
+   // check if it's a TTC
+   if (stbtt_tag(font_collection, "ttcf")) {
+      // version 1?
+      if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
+         stbtt_int32 n = ttLONG(font_collection+8);
+         if (index >= n)
+            return -1;
+         return ttULONG(font_collection+12+index*4);
+      }
+   }
+   return -1;
+}
+
+static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)
+{
+   // if it's just a font, there's only one valid font
+   if (stbtt__isfont(font_collection))
+      return 1;
+
+   // check if it's a TTC
+   if (stbtt_tag(font_collection, "ttcf")) {
+      // version 1?
+      if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
+         return ttLONG(font_collection+8);
+      }
+   }
+   return 0;
+}
+
+static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
+{
+   stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
+   stbtt__buf pdict;
+   stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
+   if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
+   pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
+   stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
+   if (!subrsoff) return stbtt__new_buf(NULL, 0);
+   stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
+   return stbtt__cff_get_index(&cff);
+}
+
+static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart)
+{
+   stbtt_uint32 cmap, t;
+   stbtt_int32 i,numTables;
+
+   info->data = data;
+   info->fontstart = fontstart;
+   info->cff = stbtt__new_buf(NULL, 0);
+
+   cmap = stbtt__find_table(data, fontstart, "cmap");       // required
+   info->loca = stbtt__find_table(data, fontstart, "loca"); // required
+   info->head = stbtt__find_table(data, fontstart, "head"); // required
+   info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required
+   info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required
+   info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required
+   info->kern = stbtt__find_table(data, fontstart, "kern"); // not required
+   info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required
+
+   if (!cmap || !info->head || !info->hhea || !info->hmtx)
+      return 0;
+   if (info->glyf) {
+      // required for truetype
+      if (!info->loca) return 0;
+   } else {
+      // initialization for CFF / Type2 fonts (OTF)
+      stbtt__buf b, topdict, topdictidx;
+      stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0;
+      stbtt_uint32 cff;
+
+      cff = stbtt__find_table(data, fontstart, "CFF ");
+      if (!cff) return 0;
+
+      info->fontdicts = stbtt__new_buf(NULL, 0);
+      info->fdselect = stbtt__new_buf(NULL, 0);
+
+      // @TODO this should use size from table (not 512MB)
+      info->cff = stbtt__new_buf(data+cff, 512*1024*1024);
+      b = info->cff;
+
+      // read the header
+      stbtt__buf_skip(&b, 2);
+      stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize
+
+      // @TODO the name INDEX could list multiple fonts,
+      // but we just use the first one.
+      stbtt__cff_get_index(&b);  // name INDEX
+      topdictidx = stbtt__cff_get_index(&b);
+      topdict = stbtt__cff_index_get(topdictidx, 0);
+      stbtt__cff_get_index(&b);  // string INDEX
+      info->gsubrs = stbtt__cff_get_index(&b);
+
+      stbtt__dict_get_ints(&topdict, 17, 1, &charstrings);
+      stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype);
+      stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff);
+      stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff);
+      info->subrs = stbtt__get_subrs(b, topdict);
+
+      // we only support Type 2 charstrings
+      if (cstype != 2) return 0;
+      if (charstrings == 0) return 0;
+
+      if (fdarrayoff) {
+         // looks like a CID font
+         if (!fdselectoff) return 0;
+         stbtt__buf_seek(&b, fdarrayoff);
+         info->fontdicts = stbtt__cff_get_index(&b);
+         info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff);
+      }
+
+      stbtt__buf_seek(&b, charstrings);
+      info->charstrings = stbtt__cff_get_index(&b);
+   }
+
+   t = stbtt__find_table(data, fontstart, "maxp");
+   if (t)
+      info->numGlyphs = ttUSHORT(data+t+4);
+   else
+      info->numGlyphs = 0xffff;
+
+   // find a cmap encoding table we understand *now* to avoid searching
+   // later. (todo: could make this installable)
+   // the same regardless of glyph.
+   numTables = ttUSHORT(data + cmap + 2);
+   info->index_map = 0;
+   for (i=0; i < numTables; ++i) {
+      stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
+      // find an encoding we understand:
+      switch(ttUSHORT(data+encoding_record)) {
+         case STBTT_PLATFORM_ID_MICROSOFT:
+            switch (ttUSHORT(data+encoding_record+2)) {
+               case STBTT_MS_EID_UNICODE_BMP:
+               case STBTT_MS_EID_UNICODE_FULL:
+                  // MS/Unicode
+                  info->index_map = cmap + ttULONG(data+encoding_record+4);
+                  break;
+            }
+            break;
+        case STBTT_PLATFORM_ID_UNICODE:
+            // Mac/iOS has these
+            // all the encodingIDs are unicode, so we don't bother to check it
+            info->index_map = cmap + ttULONG(data+encoding_record+4);
+            break;
+      }
+   }
+   if (info->index_map == 0)
+      return 0;
+
+   info->indexToLocFormat = ttUSHORT(data+info->head + 50);
+   return 1;
+}
+
+STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
+{
+   stbtt_uint8 *data = info->data;
+   stbtt_uint32 index_map = info->index_map;
+
+   stbtt_uint16 format = ttUSHORT(data + index_map + 0);
+   if (format == 0) { // apple byte encoding
+      stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
+      if (unicode_codepoint < bytes-6)
+         return ttBYTE(data + index_map + 6 + unicode_codepoint);
+      return 0;
+   } else if (format == 6) {
+      stbtt_uint32 first = ttUSHORT(data + index_map + 6);
+      stbtt_uint32 count = ttUSHORT(data + index_map + 8);
+      if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count)
+         return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2);
+      return 0;
+   } else if (format == 2) {
+      STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean
+      return 0;
+   } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges
+      stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
+      stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1;
+      stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10);
+      stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
+
+      // do a binary search of the segments
+      stbtt_uint32 endCount = index_map + 14;
+      stbtt_uint32 search = endCount;
+
+      if (unicode_codepoint > 0xffff)
+         return 0;
+
+      // they lie from endCount .. endCount + segCount
+      // but searchRange is the nearest power of two, so...
+      if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2))
+         search += rangeShift*2;
+
+      // now decrement to bias correctly to find smallest
+      search -= 2;
+      while (entrySelector) {
+         stbtt_uint16 end;
+         searchRange >>= 1;
+         end = ttUSHORT(data + search + searchRange*2);
+         if (unicode_codepoint > end)
+            search += searchRange*2;
+         --entrySelector;
+      }
+      search += 2;
+
+      {
+         stbtt_uint16 offset, start;
+         stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
+
+         STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item));
+         start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
+         if (unicode_codepoint < start)
+            return 0;
+
+         offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
+         if (offset == 0)
+            return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item));
+
+         return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
+      }
+   } else if (format == 12 || format == 13) {
+      stbtt_uint32 ngroups = ttULONG(data+index_map+12);
+      stbtt_int32 low,high;
+      low = 0; high = (stbtt_int32)ngroups;
+      // Binary search the right group.
+      while (low < high) {
+         stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high
+         stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
+         stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
+         if ((stbtt_uint32) unicode_codepoint < start_char)
+            high = mid;
+         else if ((stbtt_uint32) unicode_codepoint > end_char)
+            low = mid+1;
+         else {
+            stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
+            if (format == 12)
+               return start_glyph + unicode_codepoint-start_char;
+            else // format == 13
+               return start_glyph;
+         }
+      }
+      return 0; // not found
+   }
+   // @TODO
+   STBTT_assert(0);
+   return 0;
+}
+
+STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices)
+{
+   return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices);
+}
+
+static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy)
+{
+   v->type = type;
+   v->x = (stbtt_int16) x;
+   v->y = (stbtt_int16) y;
+   v->cx = (stbtt_int16) cx;
+   v->cy = (stbtt_int16) cy;
+}
+
+static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
+{
+   int g1,g2;
+
+   STBTT_assert(!info->cff.size);
+
+   if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range
+   if (info->indexToLocFormat >= 2)    return -1; // unknown index->glyph map format
+
+   if (info->indexToLocFormat == 0) {
+      g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
+      g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
+   } else {
+      g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4);
+      g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4);
+   }
+
+   return g1==g2 ? -1 : g1; // if length is 0, return -1
+}
+
+static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1);
+
+STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
+{
+   if (info->cff.size) {
+      stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
+   } else {
+      int g = stbtt__GetGlyfOffset(info, glyph_index);
+      if (g < 0) return 0;
+
+      if (x0) *x0 = ttSHORT(info->data + g + 2);
+      if (y0) *y0 = ttSHORT(info->data + g + 4);
+      if (x1) *x1 = ttSHORT(info->data + g + 6);
+      if (y1) *y1 = ttSHORT(info->data + g + 8);
+   }
+   return 1;
+}
+
+STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1)
+{
+   return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1);
+}
+
+STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
+{
+   stbtt_int16 numberOfContours;
+   int g;
+   if (info->cff.size)
+      return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0;
+   g = stbtt__GetGlyfOffset(info, glyph_index);
+   if (g < 0) return 1;
+   numberOfContours = ttSHORT(info->data + g);
+   return numberOfContours == 0;
+}
+
+static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
+    stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
+{
+   if (start_off) {
+      if (was_off)
+         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy);
+      stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy);
+   } else {
+      if (was_off)
+         stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy);
+      else
+         stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0);
+   }
+   return num_vertices;
+}
+
+static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+   stbtt_int16 numberOfContours;
+   stbtt_uint8 *endPtsOfContours;
+   stbtt_uint8 *data = info->data;
+   stbtt_vertex *vertices=0;
+   int num_vertices=0;
+   int g = stbtt__GetGlyfOffset(info, glyph_index);
+
+   *pvertices = NULL;
+
+   if (g < 0) return 0;
+
+   numberOfContours = ttSHORT(data + g);
+
+   if (numberOfContours > 0) {
+      stbtt_uint8 flags=0,flagcount;
+      stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0;
+      stbtt_int32 x,y,cx,cy,sx,sy, scx,scy;
+      stbtt_uint8 *points;
+      endPtsOfContours = (data + g + 10);
+      ins = ttUSHORT(data + g + 10 + numberOfContours * 2);
+      points = data + g + 10 + numberOfContours * 2 + 2 + ins;
+
+      n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2);
+
+      m = n + 2*numberOfContours;  // a loose bound on how many vertices we might need
+      vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata);
+      if (vertices == 0)
+         return 0;
+
+      next_move = 0;
+      flagcount=0;
+
+      // in first pass, we load uninterpreted data into the allocated array
+      // above, shifted to the end of the array so we won't overwrite it when
+      // we create our final data starting from the front
+
+      off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated
+
+      // first load flags
+
+      for (i=0; i < n; ++i) {
+         if (flagcount == 0) {
+            flags = *points++;
+            if (flags & 8)
+               flagcount = *points++;
+         } else
+            --flagcount;
+         vertices[off+i].type = flags;
+      }
+
+      // now load x coordinates
+      x=0;
+      for (i=0; i < n; ++i) {
+         flags = vertices[off+i].type;
+         if (flags & 2) {
+            stbtt_int16 dx = *points++;
+            x += (flags & 16) ? dx : -dx; // ???
+         } else {
+            if (!(flags & 16)) {
+               x = x + (stbtt_int16) (points[0]*256 + points[1]);
+               points += 2;
+            }
+         }
+         vertices[off+i].x = (stbtt_int16) x;
+      }
+
+      // now load y coordinates
+      y=0;
+      for (i=0; i < n; ++i) {
+         flags = vertices[off+i].type;
+         if (flags & 4) {
+            stbtt_int16 dy = *points++;
+            y += (flags & 32) ? dy : -dy; // ???
+         } else {
+            if (!(flags & 32)) {
+               y = y + (stbtt_int16) (points[0]*256 + points[1]);
+               points += 2;
+            }
+         }
+         vertices[off+i].y = (stbtt_int16) y;
+      }
+
+      // now convert them to our format
+      num_vertices=0;
+      sx = sy = cx = cy = scx = scy = 0;
+      for (i=0; i < n; ++i) {
+         flags = vertices[off+i].type;
+         x     = (stbtt_int16) vertices[off+i].x;
+         y     = (stbtt_int16) vertices[off+i].y;
+
+         if (next_move == i) {
+            if (i != 0)
+               num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
+
+            // now start the new one
+            start_off = !(flags & 1);
+            if (start_off) {
+               // if we start off with an off-curve point, then when we need to find a point on the curve
+               // where we can start, and we need to save some state for when we wraparound.
+               scx = x;
+               scy = y;
+               if (!(vertices[off+i+1].type & 1)) {
+                  // next point is also a curve point, so interpolate an on-point curve
+                  sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1;
+                  sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1;
+               } else {
+                  // otherwise just use the next point as our start point
+                  sx = (stbtt_int32) vertices[off+i+1].x;
+                  sy = (stbtt_int32) vertices[off+i+1].y;
+                  ++i; // we're using point i+1 as the starting point, so skip it
+               }
+            } else {
+               sx = x;
+               sy = y;
+            }
+            stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0);
+            was_off = 0;
+            next_move = 1 + ttUSHORT(endPtsOfContours+j*2);
+            ++j;
+         } else {
+            if (!(flags & 1)) { // if it's a curve
+               if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint
+                  stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy);
+               cx = x;
+               cy = y;
+               was_off = 1;
+            } else {
+               if (was_off)
+                  stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy);
+               else
+                  stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0);
+               was_off = 0;
+            }
+         }
+      }
+      num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy);
+   } else if (numberOfContours == -1) {
+      // Compound shapes.
+      int more = 1;
+      stbtt_uint8 *comp = data + g + 10;
+      num_vertices = 0;
+      vertices = 0;
+      while (more) {
+         stbtt_uint16 flags, gidx;
+         int comp_num_verts = 0, i;
+         stbtt_vertex *comp_verts = 0, *tmp = 0;
+         float mtx[6] = {1,0,0,1,0,0}, m, n;
+
+         flags = ttSHORT(comp); comp+=2;
+         gidx = ttSHORT(comp); comp+=2;
+
+         if (flags & 2) { // XY values
+            if (flags & 1) { // shorts
+               mtx[4] = ttSHORT(comp); comp+=2;
+               mtx[5] = ttSHORT(comp); comp+=2;
+            } else {
+               mtx[4] = ttCHAR(comp); comp+=1;
+               mtx[5] = ttCHAR(comp); comp+=1;
+            }
+         }
+         else {
+            // @TODO handle matching point
+            STBTT_assert(0);
+         }
+         if (flags & (1<<3)) { // WE_HAVE_A_SCALE
+            mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
+            mtx[1] = mtx[2] = 0;
+         } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE
+            mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
+            mtx[1] = mtx[2] = 0;
+            mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
+         } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO
+            mtx[0] = ttSHORT(comp)/16384.0f; comp+=2;
+            mtx[1] = ttSHORT(comp)/16384.0f; comp+=2;
+            mtx[2] = ttSHORT(comp)/16384.0f; comp+=2;
+            mtx[3] = ttSHORT(comp)/16384.0f; comp+=2;
+         }
+
+         // Find transformation scales.
+         m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]);
+         n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]);
+
+         // Get indexed glyph.
+         comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts);
+         if (comp_num_verts > 0) {
+            // Transform vertices.
+            for (i = 0; i < comp_num_verts; ++i) {
+               stbtt_vertex* v = &comp_verts[i];
+               stbtt_vertex_type x,y;
+               x=v->x; y=v->y;
+               v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
+               v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
+               x=v->cx; y=v->cy;
+               v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4]));
+               v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5]));
+            }
+            // Append vertices.
+            tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata);
+            if (!tmp) {
+               if (vertices) STBTT_free(vertices, info->userdata);
+               if (comp_verts) STBTT_free(comp_verts, info->userdata);
+               return 0;
+            }
+            if (num_vertices > 0) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); //-V595
+            STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex));
+            if (vertices) STBTT_free(vertices, info->userdata);
+            vertices = tmp;
+            STBTT_free(comp_verts, info->userdata);
+            num_vertices += comp_num_verts;
+         }
+         // More components ?
+         more = flags & (1<<5);
+      }
+   } else if (numberOfContours < 0) {
+      // @TODO other compound variations?
+      STBTT_assert(0);
+   } else {
+      // numberOfCounters == 0, do nothing
+   }
+
+   *pvertices = vertices;
+   return num_vertices;
+}
+
+typedef struct
+{
+   int bounds;
+   int started;
+   float first_x, first_y;
+   float x, y;
+   stbtt_int32 min_x, max_x, min_y, max_y;
+
+   stbtt_vertex *pvertices;
+   int num_vertices;
+} stbtt__csctx;
+
+#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0}
+
+static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
+{
+   if (x > c->max_x || !c->started) c->max_x = x;
+   if (y > c->max_y || !c->started) c->max_y = y;
+   if (x < c->min_x || !c->started) c->min_x = x;
+   if (y < c->min_y || !c->started) c->min_y = y;
+   c->started = 1;
+}
+
+static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)
+{
+   if (c->bounds) {
+      stbtt__track_vertex(c, x, y);
+      if (type == STBTT_vcubic) {
+         stbtt__track_vertex(c, cx, cy);
+         stbtt__track_vertex(c, cx1, cy1);
+      }
+   } else {
+      stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy);
+      c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1;
+      c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1;
+   }
+   c->num_vertices++;
+}
+
+static void stbtt__csctx_close_shape(stbtt__csctx *ctx)
+{
+   if (ctx->first_x != ctx->x || ctx->first_y != ctx->y)
+      stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0);
+}
+
+static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)
+{
+   stbtt__csctx_close_shape(ctx);
+   ctx->first_x = ctx->x = ctx->x + dx;
+   ctx->first_y = ctx->y = ctx->y + dy;
+   stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
+}
+
+static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)
+{
+   ctx->x += dx;
+   ctx->y += dy;
+   stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
+}
+
+static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)
+{
+   float cx1 = ctx->x + dx1;
+   float cy1 = ctx->y + dy1;
+   float cx2 = cx1 + dx2;
+   float cy2 = cy1 + dy2;
+   ctx->x = cx2 + dx3;
+   ctx->y = cy2 + dy3;
+   stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2);
+}
+
+static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
+{
+   int count = stbtt__cff_index_count(&idx);
+   int bias = 107;
+   if (count >= 33900)
+      bias = 32768;
+   else if (count >= 1240)
+      bias = 1131;
+   n += bias;
+   if (n < 0 || n >= count)
+      return stbtt__new_buf(NULL, 0);
+   return stbtt__cff_index_get(idx, n);
+}
+
+static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)
+{
+   stbtt__buf fdselect = info->fdselect;
+   int nranges, start, end, v, fmt, fdselector = -1, i;
+
+   stbtt__buf_seek(&fdselect, 0);
+   fmt = stbtt__buf_get8(&fdselect);
+   if (fmt == 0) {
+      // untested
+      stbtt__buf_skip(&fdselect, glyph_index);
+      fdselector = stbtt__buf_get8(&fdselect);
+   } else if (fmt == 3) {
+      nranges = stbtt__buf_get16(&fdselect);
+      start = stbtt__buf_get16(&fdselect);
+      for (i = 0; i < nranges; i++) {
+         v = stbtt__buf_get8(&fdselect);
+         end = stbtt__buf_get16(&fdselect);
+         if (glyph_index >= start && glyph_index < end) {
+            fdselector = v;
+            break;
+         }
+         start = end;
+      }
+   }
+   if (fdselector == -1) stbtt__new_buf(NULL, 0);
+   return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector));
+}
+
+static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c)
+{
+   int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0;
+   int has_subrs = 0, clear_stack;
+   float s[48];
+   stbtt__buf subr_stack[10], subrs = info->subrs, b;
+   float f;
+
+#define STBTT__CSERR(s) (0)
+
+   // this currently ignores the initial width value, which isn't needed if we have hmtx
+   b = stbtt__cff_index_get(info->charstrings, glyph_index);
+   while (b.cursor < b.size) {
+      i = 0;
+      clear_stack = 1;
+      b0 = stbtt__buf_get8(&b);
+      switch (b0) {
+      // @TODO implement hinting
+      case 0x13: // hintmask
+      case 0x14: // cntrmask
+         if (in_header)
+            maskbits += (sp / 2); // implicit "vstem"
+         in_header = 0;
+         stbtt__buf_skip(&b, (maskbits + 7) / 8);
+         break;
+
+      case 0x01: // hstem
+      case 0x03: // vstem
+      case 0x12: // hstemhm
+      case 0x17: // vstemhm
+         maskbits += (sp / 2);
+         break;
+
+      case 0x15: // rmoveto
+         in_header = 0;
+         if (sp < 2) return STBTT__CSERR("rmoveto stack");
+         stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]);
+         break;
+      case 0x04: // vmoveto
+         in_header = 0;
+         if (sp < 1) return STBTT__CSERR("vmoveto stack");
+         stbtt__csctx_rmove_to(c, 0, s[sp-1]);
+         break;
+      case 0x16: // hmoveto
+         in_header = 0;
+         if (sp < 1) return STBTT__CSERR("hmoveto stack");
+         stbtt__csctx_rmove_to(c, s[sp-1], 0);
+         break;
+
+      case 0x05: // rlineto
+         if (sp < 2) return STBTT__CSERR("rlineto stack");
+         for (; i + 1 < sp; i += 2)
+            stbtt__csctx_rline_to(c, s[i], s[i+1]);
+         break;
+
+      // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical
+      // starting from a different place.
+
+      case 0x07: // vlineto
+         if (sp < 1) return STBTT__CSERR("vlineto stack");
+         goto vlineto;
+      case 0x06: // hlineto
+         if (sp < 1) return STBTT__CSERR("hlineto stack");
+         for (;;) {
+            if (i >= sp) break;
+            stbtt__csctx_rline_to(c, s[i], 0);
+            i++;
+      vlineto:
+            if (i >= sp) break;
+            stbtt__csctx_rline_to(c, 0, s[i]);
+            i++;
+         }
+         break;
+
+      case 0x1F: // hvcurveto
+         if (sp < 4) return STBTT__CSERR("hvcurveto stack");
+         goto hvcurveto;
+      case 0x1E: // vhcurveto
+         if (sp < 4) return STBTT__CSERR("vhcurveto stack");
+         for (;;) {
+            if (i + 3 >= sp) break;
+            stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f);
+            i += 4;
+      hvcurveto:
+            if (i + 3 >= sp) break;
+            stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]);
+            i += 4;
+         }
+         break;
+
+      case 0x08: // rrcurveto
+         if (sp < 6) return STBTT__CSERR("rcurveline stack");
+         for (; i + 5 < sp; i += 6)
+            stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
+         break;
+
+      case 0x18: // rcurveline
+         if (sp < 8) return STBTT__CSERR("rcurveline stack");
+         for (; i + 5 < sp - 2; i += 6)
+            stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
+         if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack");
+         stbtt__csctx_rline_to(c, s[i], s[i+1]);
+         break;
+
+      case 0x19: // rlinecurve
+         if (sp < 8) return STBTT__CSERR("rlinecurve stack");
+         for (; i + 1 < sp - 6; i += 2)
+            stbtt__csctx_rline_to(c, s[i], s[i+1]);
+         if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack");
+         stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]);
+         break;
+
+      case 0x1A: // vvcurveto
+      case 0x1B: // hhcurveto
+         if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack");
+         f = 0.0;
+         if (sp & 1) { f = s[i]; i++; }
+         for (; i + 3 < sp; i += 4) {
+            if (b0 == 0x1B)
+               stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0);
+            else
+               stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]);
+            f = 0.0;
+         }
+         break;
+
+      case 0x0A: // callsubr
+         if (!has_subrs) {
+            if (info->fdselect.size)
+               subrs = stbtt__cid_get_glyph_subrs(info, glyph_index);
+            has_subrs = 1;
+         }
+         // fallthrough
+      case 0x1D: // callgsubr
+         if (sp < 1) return STBTT__CSERR("call(g|)subr stack");
+         v = (int) s[--sp];
+         if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit");
+         subr_stack[subr_stack_height++] = b;
+         b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v);
+         if (b.size == 0) return STBTT__CSERR("subr not found");
+         b.cursor = 0;
+         clear_stack = 0;
+         break;
+
+      case 0x0B: // return
+         if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr");
+         b = subr_stack[--subr_stack_height];
+         clear_stack = 0;
+         break;
+
+      case 0x0E: // endchar
+         stbtt__csctx_close_shape(c);
+         return 1;
+
+      case 0x0C: { // two-byte escape
+         float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6;
+         float dx, dy;
+         int b1 = stbtt__buf_get8(&b);
+         switch (b1) {
+         // @TODO These "flex" implementations ignore the flex-depth and resolution,
+         // and always draw beziers.
+         case 0x22: // hflex
+            if (sp < 7) return STBTT__CSERR("hflex stack");
+            dx1 = s[0];
+            dx2 = s[1];
+            dy2 = s[2];
+            dx3 = s[3];
+            dx4 = s[4];
+            dx5 = s[5];
+            dx6 = s[6];
+            stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0);
+            stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0);
+            break;
+
+         case 0x23: // flex
+            if (sp < 13) return STBTT__CSERR("flex stack");
+            dx1 = s[0];
+            dy1 = s[1];
+            dx2 = s[2];
+            dy2 = s[3];
+            dx3 = s[4];
+            dy3 = s[5];
+            dx4 = s[6];
+            dy4 = s[7];
+            dx5 = s[8];
+            dy5 = s[9];
+            dx6 = s[10];
+            dy6 = s[11];
+            //fd is s[12]
+            stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
+            stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
+            break;
+
+         case 0x24: // hflex1
+            if (sp < 9) return STBTT__CSERR("hflex1 stack");
+            dx1 = s[0];
+            dy1 = s[1];
+            dx2 = s[2];
+            dy2 = s[3];
+            dx3 = s[4];
+            dx4 = s[5];
+            dx5 = s[6];
+            dy5 = s[7];
+            dx6 = s[8];
+            stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0);
+            stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5));
+            break;
+
+         case 0x25: // flex1
+            if (sp < 11) return STBTT__CSERR("flex1 stack");
+            dx1 = s[0];
+            dy1 = s[1];
+            dx2 = s[2];
+            dy2 = s[3];
+            dx3 = s[4];
+            dy3 = s[5];
+            dx4 = s[6];
+            dy4 = s[7];
+            dx5 = s[8];
+            dy5 = s[9];
+            dx6 = dy6 = s[10];
+            dx = dx1+dx2+dx3+dx4+dx5;
+            dy = dy1+dy2+dy3+dy4+dy5;
+            if (STBTT_fabs(dx) > STBTT_fabs(dy))
+               dy6 = -dy;
+            else
+               dx6 = -dx;
+            stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3);
+            stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6);
+            break;
+
+         default:
+            return STBTT__CSERR("unimplemented");
+         }
+      } break;
+
+      default:
+         if (b0 != 255 && b0 != 28 && (b0 < 32 || b0 > 254)) //-V560
+            return STBTT__CSERR("reserved operator");
+
+         // push immediate
+         if (b0 == 255) {
+            f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000;
+         } else {
+            stbtt__buf_skip(&b, -1);
+            f = (float)(stbtt_int16)stbtt__cff_int(&b);
+         }
+         if (sp >= 48) return STBTT__CSERR("push stack overflow");
+         s[sp++] = f;
+         clear_stack = 0;
+         break;
+      }
+      if (clear_stack) sp = 0;
+   }
+   return STBTT__CSERR("no endchar");
+
+#undef STBTT__CSERR
+}
+
+static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+   // runs the charstring twice, once to count and once to output (to avoid realloc)
+   stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1);
+   stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0);
+   if (stbtt__run_charstring(info, glyph_index, &count_ctx)) {
+      *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata);
+      output_ctx.pvertices = *pvertices;
+      if (stbtt__run_charstring(info, glyph_index, &output_ctx)) {
+         STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices);
+         return output_ctx.num_vertices;
+      }
+   }
+   *pvertices = NULL;
+   return 0;
+}
+
+static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
+{
+   stbtt__csctx c = STBTT__CSCTX_INIT(1);
+   int r = stbtt__run_charstring(info, glyph_index, &c);
+   if (x0)  *x0 = r ? c.min_x : 0;
+   if (y0)  *y0 = r ? c.min_y : 0;
+   if (x1)  *x1 = r ? c.max_x : 0;
+   if (y1)  *y1 = r ? c.max_y : 0;
+   return r ? c.num_vertices : 0;
+}
+
+STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices)
+{
+   if (!info->cff.size)
+      return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices);
+   else
+      return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices);
+}
+
+STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
+{
+   stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
+   if (glyph_index < numOfLongHorMetrics) {
+      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*glyph_index);
+      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
+   } else {
+      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
+      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
+   }
+}
+
+static int  stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
+{
+   stbtt_uint8 *data = info->data + info->kern;
+   stbtt_uint32 needle, straw;
+   int l, r, m;
+
+   // we only look at the first table. it must be 'horizontal' and format 0.
+   if (!info->kern)
+      return 0;
+   if (ttUSHORT(data+2) < 1) // number of tables, need at least 1
+      return 0;
+   if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format
+      return 0;
+
+   l = 0;
+   r = ttUSHORT(data+10) - 1;
+   needle = glyph1 << 16 | glyph2;
+   while (l <= r) {
+      m = (l + r) >> 1;
+      straw = ttULONG(data+18+(m*6)); // note: unaligned read
+      if (needle < straw)
+         r = m - 1;
+      else if (needle > straw)
+         l = m + 1;
+      else
+         return ttSHORT(data+22+(m*6));
+   }
+   return 0;
+}
+
+static stbtt_int32  stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph)
+{
+    stbtt_uint16 coverageFormat = ttUSHORT(coverageTable);
+    switch(coverageFormat) {
+        case 1: {
+            stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2);
+
+            // Binary search.
+            stbtt_int32 l=0, r=glyphCount-1, m;
+            int straw, needle=glyph;
+            while (l <= r) {
+                stbtt_uint8 *glyphArray = coverageTable + 4;
+                stbtt_uint16 glyphID;
+                m = (l + r) >> 1;
+                glyphID = ttUSHORT(glyphArray + 2 * m);
+                straw = glyphID;
+                if (needle < straw)
+                    r = m - 1;
+                else if (needle > straw)
+                    l = m + 1;
+                else {
+                     return m;
+                }
+            }
+        } break;
+
+        case 2: {
+            stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2);
+            stbtt_uint8 *rangeArray = coverageTable + 4;
+
+            // Binary search.
+            stbtt_int32 l=0, r=rangeCount-1, m;
+            int strawStart, strawEnd, needle=glyph;
+            while (l <= r) {
+                stbtt_uint8 *rangeRecord;
+                m = (l + r) >> 1;
+                rangeRecord = rangeArray + 6 * m;
+                strawStart = ttUSHORT(rangeRecord);
+                strawEnd = ttUSHORT(rangeRecord + 2);
+                if (needle < strawStart)
+                    r = m - 1;
+                else if (needle > strawEnd)
+                    l = m + 1;
+                else {
+                    stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4);
+                    return startCoverageIndex + glyph - strawStart;
+                }
+            }
+        } break;
+
+        default: {
+            // There are no other cases.
+            STBTT_assert(0);
+        } break;
+    }
+
+    return -1;
+}
+
+static stbtt_int32  stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
+{
+    stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
+    switch(classDefFormat)
+    {
+        case 1: {
+            stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
+            stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
+            stbtt_uint8 *classDef1ValueArray = classDefTable + 6;
+
+            if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
+                return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));
+
+            // [DEAR IMGUI] Commented to fix static analyzer warning
+            //classDefTable = classDef1ValueArray + 2 * glyphCount;
+        } break;
+
+        case 2: {
+            stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
+            stbtt_uint8 *classRangeRecords = classDefTable + 4;
+
+            // Binary search.
+            stbtt_int32 l=0, r=classRangeCount-1, m;
+            int strawStart, strawEnd, needle=glyph;
+            while (l <= r) {
+                stbtt_uint8 *classRangeRecord;
+                m = (l + r) >> 1;
+                classRangeRecord = classRangeRecords + 6 * m;
+                strawStart = ttUSHORT(classRangeRecord);
+                strawEnd = ttUSHORT(classRangeRecord + 2);
+                if (needle < strawStart)
+                    r = m - 1;
+                else if (needle > strawEnd)
+                    l = m + 1;
+                else
+                    return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
+            }
+
+            // [DEAR IMGUI] Commented to fix static analyzer warning
+            //classDefTable = classRangeRecords + 6 * classRangeCount;
+        } break;
+
+        default: {
+            // There are no other cases.
+            STBTT_assert(0);
+        } break;
+    }
+
+    return -1;
+}
+
+// Define to STBTT_assert(x) if you want to break on unimplemented formats.
+#define STBTT_GPOS_TODO_assert(x)
+
+static stbtt_int32  stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2)
+{
+    stbtt_uint16 lookupListOffset;
+    stbtt_uint8 *lookupList;
+    stbtt_uint16 lookupCount;
+    stbtt_uint8 *data;
+    stbtt_int32 i;
+
+    if (!info->gpos) return 0;
+
+    data = info->data + info->gpos;
+
+    if (ttUSHORT(data+0) != 1) return 0; // Major version 1
+    if (ttUSHORT(data+2) != 0) return 0; // Minor version 0
+
+    lookupListOffset = ttUSHORT(data+8);
+    lookupList = data + lookupListOffset;
+    lookupCount = ttUSHORT(lookupList);
+
+    for (i=0; i<lookupCount; ++i) {
+        stbtt_uint16 lookupOffset = ttUSHORT(lookupList + 2 + 2 * i);
+        stbtt_uint8 *lookupTable = lookupList + lookupOffset;
+
+        stbtt_uint16 lookupType = ttUSHORT(lookupTable);
+        stbtt_uint16 subTableCount = ttUSHORT(lookupTable + 4);
+        stbtt_uint8 *subTableOffsets = lookupTable + 6;
+        switch(lookupType) {
+            case 2: { // Pair Adjustment Positioning Subtable
+                stbtt_int32 sti;
+                for (sti=0; sti<subTableCount; sti++) {
+                    stbtt_uint16 subtableOffset = ttUSHORT(subTableOffsets + 2 * sti);
+                    stbtt_uint8 *table = lookupTable + subtableOffset;
+                    stbtt_uint16 posFormat = ttUSHORT(table);
+                    stbtt_uint16 coverageOffset = ttUSHORT(table + 2);
+                    stbtt_int32 coverageIndex = stbtt__GetCoverageIndex(table + coverageOffset, glyph1);
+                    if (coverageIndex == -1) continue;
+
+                    switch (posFormat) {
+                        case 1: {
+                            stbtt_int32 l, r, m;
+                            int straw, needle;
+                            stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
+                            stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
+                            stbtt_int32 valueRecordPairSizeInBytes = 2;
+                            stbtt_uint16 pairSetCount = ttUSHORT(table + 8);
+                            stbtt_uint16 pairPosOffset = ttUSHORT(table + 10 + 2 * coverageIndex);
+                            stbtt_uint8 *pairValueTable = table + pairPosOffset;
+                            stbtt_uint16 pairValueCount = ttUSHORT(pairValueTable);
+                            stbtt_uint8 *pairValueArray = pairValueTable + 2;
+                            // TODO: Support more formats.
+                            STBTT_GPOS_TODO_assert(valueFormat1 == 4);
+                            if (valueFormat1 != 4) return 0;
+                            STBTT_GPOS_TODO_assert(valueFormat2 == 0);
+                            if (valueFormat2 != 0) return 0;
+
+                            STBTT_assert(coverageIndex < pairSetCount);
+                            STBTT__NOTUSED(pairSetCount);
+
+                            needle=glyph2;
+                            r=pairValueCount-1;
+                            l=0;
+
+                            // Binary search.
+                            while (l <= r) {
+                                stbtt_uint16 secondGlyph;
+                                stbtt_uint8 *pairValue;
+                                m = (l + r) >> 1;
+                                pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m;
+                                secondGlyph = ttUSHORT(pairValue);
+                                straw = secondGlyph;
+                                if (needle < straw)
+                                    r = m - 1;
+                                else if (needle > straw)
+                                    l = m + 1;
+                                else {
+                                    stbtt_int16 xAdvance = ttSHORT(pairValue + 2);
+                                    return xAdvance;
+                                }
+                            }
+                        } break;
+
+                        case 2: {
+                            stbtt_uint16 valueFormat1 = ttUSHORT(table + 4);
+                            stbtt_uint16 valueFormat2 = ttUSHORT(table + 6);
+
+                            stbtt_uint16 classDef1Offset = ttUSHORT(table + 8);
+                            stbtt_uint16 classDef2Offset = ttUSHORT(table + 10);
+                            int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1);
+                            int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2);
+
+                            stbtt_uint16 class1Count = ttUSHORT(table + 12);
+                            stbtt_uint16 class2Count = ttUSHORT(table + 14);
+                            STBTT_assert(glyph1class < class1Count);
+                            STBTT_assert(glyph2class < class2Count);
+
+                            // TODO: Support more formats.
+                            STBTT_GPOS_TODO_assert(valueFormat1 == 4);
+                            if (valueFormat1 != 4) return 0;
+                            STBTT_GPOS_TODO_assert(valueFormat2 == 0);
+                            if (valueFormat2 != 0) return 0;
+
+                            if (glyph1class >= 0 && glyph1class < class1Count && glyph2class >= 0 && glyph2class < class2Count) {
+                                stbtt_uint8 *class1Records = table + 16;
+                                stbtt_uint8 *class2Records = class1Records + 2 * (glyph1class * class2Count);
+                                stbtt_int16 xAdvance = ttSHORT(class2Records + 2 * glyph2class);
+                                return xAdvance;
+                            }
+                        } break;
+
+                        default: {
+                            // There are no other cases.
+                            STBTT_assert(0);
+                            break;
+                        } // [DEAR IMGUI] removed ;
+                    }
+                }
+                break;
+            } // [DEAR IMGUI] removed ;
+
+            default:
+                // TODO: Implement other stuff.
+                break;
+        }
+    }
+
+    return 0;
+}
+
+STBTT_DEF int  stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2)
+{
+   int xAdvance = 0;
+
+   if (info->gpos)
+      xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2);
+
+   if (info->kern)
+      xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2);
+
+   return xAdvance;
+}
+
+STBTT_DEF int  stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2)
+{
+   if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs
+      return 0;
+   return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2));
+}
+
+STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing)
+{
+   stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing);
+}
+
+STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap)
+{
+   if (ascent ) *ascent  = ttSHORT(info->data+info->hhea + 4);
+   if (descent) *descent = ttSHORT(info->data+info->hhea + 6);
+   if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8);
+}
+
+STBTT_DEF int  stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)
+{
+   int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
+   if (!tab)
+      return 0;
+   if (typoAscent ) *typoAscent  = ttSHORT(info->data+tab + 68);
+   if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70);
+   if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72);
+   return 1;
+}
+
+STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1)
+{
+   *x0 = ttSHORT(info->data + info->head + 36);
+   *y0 = ttSHORT(info->data + info->head + 38);
+   *x1 = ttSHORT(info->data + info->head + 40);
+   *y1 = ttSHORT(info->data + info->head + 42);
+}
+
+STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height)
+{
+   int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6);
+   return (float) height / fheight;
+}
+
+STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels)
+{
+   int unitsPerEm = ttUSHORT(info->data + info->head + 18);
+   return pixels / unitsPerEm;
+}
+
+STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)
+{
+   STBTT_free(v, info->userdata);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// antialiasing software rasterizer
+//
+
+STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+   int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning
+   if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) {
+      // e.g. space character
+      if (ix0) *ix0 = 0;
+      if (iy0) *iy0 = 0;
+      if (ix1) *ix1 = 0;
+      if (iy1) *iy1 = 0;
+   } else {
+      // move to integral bboxes (treating pixels as little squares, what pixels get touched)?
+      if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x);
+      if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
+      if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x);
+      if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y);
+   }
+}
+
+STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+   stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1);
+}
+
+STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+   stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1);
+}
+
+STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1)
+{
+   stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Rasterizer
+
+typedef struct stbtt__hheap_chunk
+{
+   struct stbtt__hheap_chunk *next;
+} stbtt__hheap_chunk;
+
+typedef struct stbtt__hheap
+{
+   struct stbtt__hheap_chunk *head;
+   void   *first_free;
+   int    num_remaining_in_head_chunk;
+} stbtt__hheap;
+
+static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata)
+{
+   if (hh->first_free) {
+      void *p = hh->first_free;
+      hh->first_free = * (void **) p;
+      return p;
+   } else {
+      if (hh->num_remaining_in_head_chunk == 0) {
+         int count = (size < 32 ? 2000 : size < 128 ? 800 : 100);
+         stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata);
+         if (c == NULL)
+            return NULL;
+         c->next = hh->head;
+         hh->head = c;
+         hh->num_remaining_in_head_chunk = count;
+      }
+      --hh->num_remaining_in_head_chunk;
+      return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk;
+   }
+}
+
+static void stbtt__hheap_free(stbtt__hheap *hh, void *p)
+{
+   *(void **) p = hh->first_free;
+   hh->first_free = p;
+}
+
+static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
+{
+   stbtt__hheap_chunk *c = hh->head;
+   while (c) {
+      stbtt__hheap_chunk *n = c->next;
+      STBTT_free(c, userdata);
+      c = n;
+   }
+}
+
+typedef struct stbtt__edge {
+   float x0,y0, x1,y1;
+   int invert;
+} stbtt__edge;
+
+
+typedef struct stbtt__active_edge
+{
+   struct stbtt__active_edge *next;
+   #if STBTT_RASTERIZER_VERSION==1
+   int x,dx;
+   float ey;
+   int direction;
+   #elif STBTT_RASTERIZER_VERSION==2
+   float fx,fdx,fdy;
+   float direction;
+   float sy;
+   float ey;
+   #else
+   #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+   #endif
+} stbtt__active_edge;
+
+#if STBTT_RASTERIZER_VERSION == 1
+#define STBTT_FIXSHIFT   10
+#define STBTT_FIX        (1 << STBTT_FIXSHIFT)
+#define STBTT_FIXMASK    (STBTT_FIX-1)
+
+static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+   stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
+   float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+   STBTT_assert(z != NULL);
+   if (!z) return z;
+
+   // round dx down to avoid overshooting
+   if (dxdy < 0)
+      z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy);
+   else
+      z->dx = STBTT_ifloor(STBTT_FIX * dxdy);
+
+   z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); // use z->dx so when we offset later it's by the same amount
+   z->x -= off_x * STBTT_FIX;
+
+   z->ey = e->y1;
+   z->next = 0;
+   z->direction = e->invert ? 1 : -1;
+   return z;
+}
+#elif STBTT_RASTERIZER_VERSION == 2
+static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata)
+{
+   stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata);
+   float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0);
+   STBTT_assert(z != NULL);
+   //STBTT_assert(e->y0 <= start_point);
+   if (!z) return z;
+   z->fdx = dxdy;
+   z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f;
+   z->fx = e->x0 + dxdy * (start_point - e->y0);
+   z->fx -= off_x;
+   z->direction = e->invert ? 1.0f : -1.0f;
+   z->sy = e->y0;
+   z->ey = e->y1;
+   z->next = 0;
+   return z;
+}
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+
+#if STBTT_RASTERIZER_VERSION == 1
+// note: this routine clips fills that extend off the edges... ideally this
+// wouldn't happen, but it could happen if the truetype glyph bounding boxes
+// are wrong, or if the user supplies a too-small bitmap
+static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight)
+{
+   // non-zero winding fill
+   int x0=0, w=0;
+
+   while (e) {
+      if (w == 0) {
+         // if we're currently at zero, we need to record the edge start point
+         x0 = e->x; w += e->direction;
+      } else {
+         int x1 = e->x; w += e->direction;
+         // if we went to zero, we need to draw
+         if (w == 0) {
+            int i = x0 >> STBTT_FIXSHIFT;
+            int j = x1 >> STBTT_FIXSHIFT;
+
+            if (i < len && j >= 0) {
+               if (i == j) {
+                  // x0,x1 are the same pixel, so compute combined coverage
+                  scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT);
+               } else {
+                  if (i >= 0) // add antialiasing for x0
+                     scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT);
+                  else
+                     i = -1; // clip
+
+                  if (j < len) // add antialiasing for x1
+                     scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT);
+                  else
+                     j = len; // clip
+
+                  for (++i; i < j; ++i) // fill pixels between x0 and x1
+                     scanline[i] = scanline[i] + (stbtt_uint8) max_weight;
+               }
+            }
+         }
+      }
+
+      e = e->next;
+   }
+}
+
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+   stbtt__hheap hh = { 0, 0, 0 };
+   stbtt__active_edge *active = NULL;
+   int y,j=0;
+   int max_weight = (255 / vsubsample);  // weight per vertical scanline
+   int s; // vertical subsample index
+   unsigned char scanline_data[512], *scanline;
+
+   if (result->w > 512)
+      scanline = (unsigned char *) STBTT_malloc(result->w, userdata);
+   else
+      scanline = scanline_data;
+
+   y = off_y * vsubsample;
+   e[n].y0 = (off_y + result->h) * (float) vsubsample + 1;
+
+   while (j < result->h) {
+      STBTT_memset(scanline, 0, result->w);
+      for (s=0; s < vsubsample; ++s) {
+         // find center of pixel for this scanline
+         float scan_y = y + 0.5f;
+         stbtt__active_edge **step = &active;
+
+         // update all active edges;
+         // remove all active edges that terminate before the center of this scanline
+         while (*step) {
+            stbtt__active_edge * z = *step;
+            if (z->ey <= scan_y) {
+               *step = z->next; // delete from list
+               STBTT_assert(z->direction);
+               z->direction = 0;
+               stbtt__hheap_free(&hh, z);
+            } else {
+               z->x += z->dx; // advance to position for current scanline
+               step = &((*step)->next); // advance through list
+            }
+         }
+
+         // resort the list if needed
+         for(;;) {
+            int changed=0;
+            step = &active;
+            while (*step && (*step)->next) {
+               if ((*step)->x > (*step)->next->x) {
+                  stbtt__active_edge *t = *step;
+                  stbtt__active_edge *q = t->next;
+
+                  t->next = q->next;
+                  q->next = t;
+                  *step = q;
+                  changed = 1;
+               }
+               step = &(*step)->next;
+            }
+            if (!changed) break;
+         }
+
+         // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline
+         while (e->y0 <= scan_y) {
+            if (e->y1 > scan_y) {
+               stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata);
+               if (z != NULL) {
+                  // find insertion point
+                  if (active == NULL)
+                     active = z;
+                  else if (z->x < active->x) {
+                     // insert at front
+                     z->next = active;
+                     active = z;
+                  } else {
+                     // find thing to insert AFTER
+                     stbtt__active_edge *p = active;
+                     while (p->next && p->next->x < z->x)
+                        p = p->next;
+                     // at this point, p->next->x is NOT < z->x
+                     z->next = p->next;
+                     p->next = z;
+                  }
+               }
+            }
+            ++e;
+         }
+
+         // now process all active edges in XOR fashion
+         if (active)
+            stbtt__fill_active_edges(scanline, result->w, active, max_weight);
+
+         ++y;
+      }
+      STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w);
+      ++j;
+   }
+
+   stbtt__hheap_cleanup(&hh, userdata);
+
+   if (scanline != scanline_data)
+      STBTT_free(scanline, userdata);
+}
+
+#elif STBTT_RASTERIZER_VERSION == 2
+
+// the edge passed in here does not cross the vertical line at x or the vertical line at x+1
+// (i.e. it has already been clipped to those)
+static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1)
+{
+   if (y0 == y1) return;
+   STBTT_assert(y0 < y1);
+   STBTT_assert(e->sy <= e->ey);
+   if (y0 > e->ey) return;
+   if (y1 < e->sy) return;
+   if (y0 < e->sy) {
+      x0 += (x1-x0) * (e->sy - y0) / (y1-y0);
+      y0 = e->sy;
+   }
+   if (y1 > e->ey) {
+      x1 += (x1-x0) * (e->ey - y1) / (y1-y0);
+      y1 = e->ey;
+   }
+
+   if (x0 == x)
+      STBTT_assert(x1 <= x+1);
+   else if (x0 == x+1)
+      STBTT_assert(x1 >= x);
+   else if (x0 <= x)
+      STBTT_assert(x1 <= x);
+   else if (x0 >= x+1)
+      STBTT_assert(x1 >= x+1);
+   else
+      STBTT_assert(x1 >= x && x1 <= x+1);
+
+   if (x0 <= x && x1 <= x)
+      scanline[x] += e->direction * (y1-y0);
+   else if (x0 >= x+1 && x1 >= x+1)
+      ;
+   else {
+      STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1);
+      scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position
+   }
+}
+
+static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top)
+{
+   float y_bottom = y_top+1;
+
+   while (e) {
+      // brute force every pixel
+
+      // compute intersection points with top & bottom
+      STBTT_assert(e->ey >= y_top);
+
+      if (e->fdx == 0) {
+         float x0 = e->fx;
+         if (x0 < len) {
+            if (x0 >= 0) {
+               stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom);
+               stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom);
+            } else {
+               stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom);
+            }
+         }
+      } else {
+         float x0 = e->fx;
+         float dx = e->fdx;
+         float xb = x0 + dx;
+         float x_top, x_bottom;
+         float sy0,sy1;
+         float dy = e->fdy;
+         STBTT_assert(e->sy <= y_bottom && e->ey >= y_top);
+
+         // compute endpoints of line segment clipped to this scanline (if the
+         // line segment starts on this scanline. x0 is the intersection of the
+         // line with y_top, but that may be off the line segment.
+         if (e->sy > y_top) {
+            x_top = x0 + dx * (e->sy - y_top);
+            sy0 = e->sy;
+         } else {
+            x_top = x0;
+            sy0 = y_top;
+         }
+         if (e->ey < y_bottom) {
+            x_bottom = x0 + dx * (e->ey - y_top);
+            sy1 = e->ey;
+         } else {
+            x_bottom = xb;
+            sy1 = y_bottom;
+         }
+
+         if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) {
+            // from here on, we don't have to range check x values
+
+            if ((int) x_top == (int) x_bottom) {
+               float height;
+               // simple case, only spans one pixel
+               int x = (int) x_top;
+               height = sy1 - sy0;
+               STBTT_assert(x >= 0 && x < len);
+               scanline[x] += e->direction * (1-((x_top - x) + (x_bottom-x))/2)  * height;
+               scanline_fill[x] += e->direction * height; // everything right of this pixel is filled
+            } else {
+               int x,x1,x2;
+               float y_crossing, step, sign, area;
+               // covers 2+ pixels
+               if (x_top > x_bottom) {
+                  // flip scanline vertically; signed area is the same
+                  float t;
+                  sy0 = y_bottom - (sy0 - y_top);
+                  sy1 = y_bottom - (sy1 - y_top);
+                  t = sy0, sy0 = sy1, sy1 = t;
+                  t = x_bottom, x_bottom = x_top, x_top = t;
+                  dx = -dx;
+                  dy = -dy;
+                  t = x0, x0 = xb, xb = t;
+                  // [DEAR IMGUI] Fix static analyzer warning
+                  (void)dx; // [ImGui: fix static analyzer warning]
+               }
+
+               x1 = (int) x_top;
+               x2 = (int) x_bottom;
+               // compute intersection with y axis at x1+1
+               y_crossing = (x1+1 - x0) * dy + y_top;
+
+               sign = e->direction;
+               // area of the rectangle covered from y0..y_crossing
+               area = sign * (y_crossing-sy0);
+               // area of the triangle (x_top,y0), (x+1,y0), (x+1,y_crossing)
+               scanline[x1] += area * (1-((x_top - x1)+(x1+1-x1))/2);
+
+               step = sign * dy;
+               for (x = x1+1; x < x2; ++x) {
+                  scanline[x] += area + step/2;
+                  area += step;
+               }
+               y_crossing += dy * (x2 - (x1+1));
+
+               STBTT_assert(STBTT_fabs(area) <= 1.01f);
+
+               scanline[x2] += area + sign * (1-((x2-x2)+(x_bottom-x2))/2) * (sy1-y_crossing);
+
+               scanline_fill[x2] += sign * (sy1-sy0);
+            }
+         } else {
+            // if edge goes outside of box we're drawing, we require
+            // clipping logic. since this does not match the intended use
+            // of this library, we use a different, very slow brute
+            // force implementation
+            int x;
+            for (x=0; x < len; ++x) {
+               // cases:
+               //
+               // there can be up to two intersections with the pixel. any intersection
+               // with left or right edges can be handled by splitting into two (or three)
+               // regions. intersections with top & bottom do not necessitate case-wise logic.
+               //
+               // the old way of doing this found the intersections with the left & right edges,
+               // then used some simple logic to produce up to three segments in sorted order
+               // from top-to-bottom. however, this had a problem: if an x edge was epsilon
+               // across the x border, then the corresponding y position might not be distinct
+               // from the other y segment, and it might ignored as an empty segment. to avoid
+               // that, we need to explicitly produce segments based on x positions.
+
+               // rename variables to clearly-defined pairs
+               float y0 = y_top;
+               float x1 = (float) (x);
+               float x2 = (float) (x+1);
+               float x3 = xb;
+               float y3 = y_bottom;
+
+               // x = e->x + e->dx * (y-y_top)
+               // (y-y_top) = (x - e->x) / e->dx
+               // y = (x - e->x) / e->dx + y_top
+               float y1 = (x - x0) / dx + y_top;
+               float y2 = (x+1 - x0) / dx + y_top;
+
+               if (x0 < x1 && x3 > x2) {         // three segments descending down-right
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
+                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2);
+                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
+               } else if (x3 < x1 && x0 > x2) {  // three segments descending down-left
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
+                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1);
+                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
+               } else if (x0 < x1 && x3 > x1) {  // two segments across x, down-right
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
+                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
+               } else if (x3 < x1 && x0 > x1) {  // two segments across x, down-left
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1);
+                  stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3);
+               } else if (x0 < x2 && x3 > x2) {  // two segments across x+1, down-right
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
+                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
+               } else if (x3 < x2 && x0 > x2) {  // two segments across x+1, down-left
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2);
+                  stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3);
+               } else {  // one segment
+                  stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3);
+               }
+            }
+         }
+      }
+      e = e->next;
+   }
+}
+
+// directly AA rasterize edges w/o supersampling
+static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata)
+{
+   stbtt__hheap hh = { 0, 0, 0 };
+   stbtt__active_edge *active = NULL;
+   int y,j=0, i;
+   float scanline_data[129], *scanline, *scanline2;
+
+   STBTT__NOTUSED(vsubsample);
+
+   if (result->w > 64)
+      scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata);
+   else
+      scanline = scanline_data;
+
+   scanline2 = scanline + result->w;
+
+   y = off_y;
+   e[n].y0 = (float) (off_y + result->h) + 1;
+
+   while (j < result->h) {
+      // find center of pixel for this scanline
+      float scan_y_top    = y + 0.0f;
+      float scan_y_bottom = y + 1.0f;
+      stbtt__active_edge **step = &active;
+
+      STBTT_memset(scanline , 0, result->w*sizeof(scanline[0]));
+      STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0]));
+
+      // update all active edges;
+      // remove all active edges that terminate before the top of this scanline
+      while (*step) {
+         stbtt__active_edge * z = *step;
+         if (z->ey <= scan_y_top) {
+            *step = z->next; // delete from list
+            STBTT_assert(z->direction);
+            z->direction = 0;
+            stbtt__hheap_free(&hh, z);
+         } else {
+            step = &((*step)->next); // advance through list
+         }
+      }
+
+      // insert all edges that start before the bottom of this scanline
+      while (e->y0 <= scan_y_bottom) {
+         if (e->y0 != e->y1) {
+            stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata);
+            if (z != NULL) {
+               if (j == 0 && off_y != 0) {
+                  if (z->ey < scan_y_top) {
+                     // this can happen due to subpixel positioning and some kind of fp rounding error i think
+                     z->ey = scan_y_top;
+                  }
+               }
+               STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds
+               // insert at front
+               z->next = active;
+               active = z;
+            }
+         }
+         ++e;
+      }
+
+      // now process all active edges
+      if (active)
+         stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top);
+
+      {
+         float sum = 0;
+         for (i=0; i < result->w; ++i) {
+            float k;
+            int m;
+            sum += scanline2[i];
+            k = scanline[i] + sum;
+            k = (float) STBTT_fabs(k)*255 + 0.5f;
+            m = (int) k;
+            if (m > 255) m = 255;
+            result->pixels[j*result->stride + i] = (unsigned char) m;
+         }
+      }
+      // advance all the edges
+      step = &active;
+      while (*step) {
+         stbtt__active_edge *z = *step;
+         z->fx += z->fdx; // advance to position for current scanline
+         step = &((*step)->next); // advance through list
+      }
+
+      ++y;
+      ++j;
+   }
+
+   stbtt__hheap_cleanup(&hh, userdata);
+
+   if (scanline != scanline_data)
+      STBTT_free(scanline, userdata);
+}
+#else
+#error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+
+#define STBTT__COMPARE(a,b)  ((a)->y0 < (b)->y0)
+
+static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
+{
+   int i,j;
+   for (i=1; i < n; ++i) {
+      stbtt__edge t = p[i], *a = &t;
+      j = i;
+      while (j > 0) {
+         stbtt__edge *b = &p[j-1];
+         int c = STBTT__COMPARE(a,b);
+         if (!c) break;
+         p[j] = p[j-1];
+         --j;
+      }
+      if (i != j)
+         p[j] = t;
+   }
+}
+
+static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)
+{
+   /* threshold for transitioning to insertion sort */
+   while (n > 12) {
+      stbtt__edge t;
+      int c01,c12,c,m,i,j;
+
+      /* compute median of three */
+      m = n >> 1;
+      c01 = STBTT__COMPARE(&p[0],&p[m]);
+      c12 = STBTT__COMPARE(&p[m],&p[n-1]);
+      /* if 0 >= mid >= end, or 0 < mid < end, then use mid */
+      if (c01 != c12) {
+         /* otherwise, we'll need to swap something else to middle */
+         int z;
+         c = STBTT__COMPARE(&p[0],&p[n-1]);
+         /* 0>mid && mid<n:  0>n => n; 0<n => 0 */
+         /* 0<mid && mid>n:  0>n => 0; 0<n => n */
+         z = (c == c12) ? 0 : n-1;
+         t = p[z];
+         p[z] = p[m];
+         p[m] = t;
+      }
+      /* now p[m] is the median-of-three */
+      /* swap it to the beginning so it won't move around */
+      t = p[0];
+      p[0] = p[m];
+      p[m] = t;
+
+      /* partition loop */
+      i=1;
+      j=n-1;
+      for(;;) {
+         /* handling of equality is crucial here */
+         /* for sentinels & efficiency with duplicates */
+         for (;;++i) {
+            if (!STBTT__COMPARE(&p[i], &p[0])) break;
+         }
+         for (;;--j) {
+            if (!STBTT__COMPARE(&p[0], &p[j])) break;
+         }
+         /* make sure we haven't crossed */
+         if (i >= j) break;
+         t = p[i];
+         p[i] = p[j];
+         p[j] = t;
+
+         ++i;
+         --j;
+      }
+      /* recurse on smaller side, iterate on larger */
+      if (j < (n-i)) {
+         stbtt__sort_edges_quicksort(p,j);
+         p = p+i;
+         n = n-i;
+      } else {
+         stbtt__sort_edges_quicksort(p+i, n-i);
+         n = j;
+      }
+   }
+}
+
+static void stbtt__sort_edges(stbtt__edge *p, int n)
+{
+   stbtt__sort_edges_quicksort(p, n);
+   stbtt__sort_edges_ins_sort(p, n);
+}
+
+typedef struct
+{
+   float x,y;
+} stbtt__point;
+
+static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata)
+{
+   float y_scale_inv = invert ? -scale_y : scale_y;
+   stbtt__edge *e;
+   int n,i,j,k,m;
+#if STBTT_RASTERIZER_VERSION == 1
+   int vsubsample = result->h < 8 ? 15 : 5;
+#elif STBTT_RASTERIZER_VERSION == 2
+   int vsubsample = 1;
+#else
+   #error "Unrecognized value of STBTT_RASTERIZER_VERSION"
+#endif
+   // vsubsample should divide 255 evenly; otherwise we won't reach full opacity
+
+   // now we have to blow out the windings into explicit edge lists
+   n = 0;
+   for (i=0; i < windings; ++i)
+      n += wcount[i];
+
+   e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel
+   if (e == 0) return;
+   n = 0;
+
+   m=0;
+   for (i=0; i < windings; ++i) {
+      stbtt__point *p = pts + m;
+      m += wcount[i];
+      j = wcount[i]-1;
+      for (k=0; k < wcount[i]; j=k++) {
+         int a=k,b=j;
+         // skip the edge if horizontal
+         if (p[j].y == p[k].y)
+            continue;
+         // add edge from j to k to the list
+         e[n].invert = 0;
+         if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) {
+            e[n].invert = 1;
+            a=j,b=k;
+         }
+         e[n].x0 = p[a].x * scale_x + shift_x;
+         e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample;
+         e[n].x1 = p[b].x * scale_x + shift_x;
+         e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample;
+         ++n;
+      }
+   }
+
+   // now sort the edges by their highest point (should snap to integer, and then by x)
+   //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare);
+   stbtt__sort_edges(e, n);
+
+   // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule
+   stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata);
+
+   STBTT_free(e, userdata);
+}
+
+static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
+{
+   if (!points) return; // during first pass, it's unallocated
+   points[n].x = x;
+   points[n].y = y;
+}
+
+// tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching
+static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
+{
+   // midpoint
+   float mx = (x0 + 2*x1 + x2)/4;
+   float my = (y0 + 2*y1 + y2)/4;
+   // versus directly drawn line
+   float dx = (x0+x2)/2 - mx;
+   float dy = (y0+y2)/2 - my;
+   if (n > 16) // 65536 segments on one curve better be enough!
+      return 1;
+   if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
+      stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
+      stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
+   } else {
+      stbtt__add_point(points, *num_points,x2,y2);
+      *num_points = *num_points+1;
+   }
+   return 1;
+}
+
+static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n)
+{
+   // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough
+   float dx0 = x1-x0;
+   float dy0 = y1-y0;
+   float dx1 = x2-x1;
+   float dy1 = y2-y1;
+   float dx2 = x3-x2;
+   float dy2 = y3-y2;
+   float dx = x3-x0;
+   float dy = y3-y0;
+   float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2));
+   float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy);
+   float flatness_squared = longlen*longlen-shortlen*shortlen;
+
+   if (n > 16) // 65536 segments on one curve better be enough!
+      return;
+
+   if (flatness_squared > objspace_flatness_squared) {
+      float x01 = (x0+x1)/2;
+      float y01 = (y0+y1)/2;
+      float x12 = (x1+x2)/2;
+      float y12 = (y1+y2)/2;
+      float x23 = (x2+x3)/2;
+      float y23 = (y2+y3)/2;
+
+      float xa = (x01+x12)/2;
+      float ya = (y01+y12)/2;
+      float xb = (x12+x23)/2;
+      float yb = (y12+y23)/2;
+
+      float mx = (xa+xb)/2;
+      float my = (ya+yb)/2;
+
+      stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1);
+      stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1);
+   } else {
+      stbtt__add_point(points, *num_points,x3,y3);
+      *num_points = *num_points+1;
+   }
+}
+
+// returns number of contours
+static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata)
+{
+   stbtt__point *points=0;
+   int num_points=0;
+
+   float objspace_flatness_squared = objspace_flatness * objspace_flatness;
+   int i,n=0,start=0, pass;
+
+   // count how many "moves" there are to get the contour count
+   for (i=0; i < num_verts; ++i)
+      if (vertices[i].type == STBTT_vmove)
+         ++n;
+
+   *num_contours = n;
+   if (n == 0) return 0;
+
+   *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata);
+
+   if (*contour_lengths == 0) {
+      *num_contours = 0;
+      return 0;
+   }
+
+   // make two passes through the points so we don't need to realloc
+   for (pass=0; pass < 2; ++pass) {
+      float x=0,y=0;
+      if (pass == 1) {
+         points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata);
+         if (points == NULL) goto error;
+      }
+      num_points = 0;
+      n= -1;
+      for (i=0; i < num_verts; ++i) {
+         switch (vertices[i].type) {
+            case STBTT_vmove:
+               // start the next contour
+               if (n >= 0)
+                  (*contour_lengths)[n] = num_points - start;
+               ++n;
+               start = num_points;
+
+               x = vertices[i].x, y = vertices[i].y;
+               stbtt__add_point(points, num_points++, x,y);
+               break;
+            case STBTT_vline:
+               x = vertices[i].x, y = vertices[i].y;
+               stbtt__add_point(points, num_points++, x, y);
+               break;
+            case STBTT_vcurve:
+               stbtt__tesselate_curve(points, &num_points, x,y,
+                                        vertices[i].cx, vertices[i].cy,
+                                        vertices[i].x,  vertices[i].y,
+                                        objspace_flatness_squared, 0);
+               x = vertices[i].x, y = vertices[i].y;
+               break;
+            case STBTT_vcubic:
+               stbtt__tesselate_cubic(points, &num_points, x,y,
+                                        vertices[i].cx, vertices[i].cy,
+                                        vertices[i].cx1, vertices[i].cy1,
+                                        vertices[i].x,  vertices[i].y,
+                                        objspace_flatness_squared, 0);
+               x = vertices[i].x, y = vertices[i].y;
+               break;
+         }
+      }
+      (*contour_lengths)[n] = num_points - start;
+   }
+
+   return points;
+error:
+   STBTT_free(points, userdata);
+   STBTT_free(*contour_lengths, userdata);
+   *contour_lengths = 0;
+   *num_contours = 0;
+   return NULL;
+}
+
+STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata)
+{
+   float scale            = scale_x > scale_y ? scale_y : scale_x;
+   int winding_count      = 0;
+   int *winding_lengths   = NULL;
+   stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata);
+   if (windings) {
+      stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata);
+      STBTT_free(winding_lengths, userdata);
+      STBTT_free(windings, userdata);
+   }
+}
+
+STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
+{
+   STBTT_free(bitmap, userdata);
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+   int ix0,iy0,ix1,iy1;
+   stbtt__bitmap gbm;
+   stbtt_vertex *vertices;
+   int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+
+   if (scale_x == 0) scale_x = scale_y;
+   if (scale_y == 0) {
+      if (scale_x == 0) {
+         STBTT_free(vertices, info->userdata);
+         return NULL;
+      }
+      scale_y = scale_x;
+   }
+
+   stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1);
+
+   // now we get the size
+   gbm.w = (ix1 - ix0);
+   gbm.h = (iy1 - iy0);
+   gbm.pixels = NULL; // in case we error
+
+   if (width ) *width  = gbm.w;
+   if (height) *height = gbm.h;
+   if (xoff  ) *xoff   = ix0;
+   if (yoff  ) *yoff   = iy0;
+
+   if (gbm.w && gbm.h) {
+      gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata);
+      if (gbm.pixels) {
+         gbm.stride = gbm.w;
+
+         stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata);
+      }
+   }
+   STBTT_free(vertices, info->userdata);
+   return gbm.pixels;
+}
+
+STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff)
+{
+   return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph)
+{
+   int ix0,iy0;
+   stbtt_vertex *vertices;
+   int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices);
+   stbtt__bitmap gbm;
+
+   stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0);
+   gbm.pixels = output;
+   gbm.w = out_w;
+   gbm.h = out_h;
+   gbm.stride = out_stride;
+
+   if (gbm.w && gbm.h)
+      stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata);
+
+   STBTT_free(vertices, info->userdata);
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph)
+{
+   stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph);
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+   return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff);
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint)
+{
+   stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info,codepoint));
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint)
+{
+   stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint));
+}
+
+STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff)
+{
+   return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff);
+}
+
+STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint)
+{
+   stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-CRAPPY packing to keep source code small
+
+static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset,  // font location (use offset=0 for plain .ttf)
+                                float pixel_height,                     // height of font in pixels
+                                unsigned char *pixels, int pw, int ph,  // bitmap to be filled in
+                                int first_char, int num_chars,          // characters to bake
+                                stbtt_bakedchar *chardata)
+{
+   float scale;
+   int x,y,bottom_y, i;
+   stbtt_fontinfo f;
+   f.userdata = NULL;
+   if (!stbtt_InitFont(&f, data, offset))
+      return -1;
+   STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels
+   x=y=1;
+   bottom_y = 1;
+
+   scale = stbtt_ScaleForPixelHeight(&f, pixel_height);
+
+   for (i=0; i < num_chars; ++i) {
+      int advance, lsb, x0,y0,x1,y1,gw,gh;
+      int g = stbtt_FindGlyphIndex(&f, first_char + i);
+      stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
+      stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1);
+      gw = x1-x0;
+      gh = y1-y0;
+      if (x + gw + 1 >= pw)
+         y = bottom_y, x = 1; // advance to next row
+      if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row
+         return -i;
+      STBTT_assert(x+gw < pw);
+      STBTT_assert(y+gh < ph);
+      stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g);
+      chardata[i].x0 = (stbtt_int16) x;
+      chardata[i].y0 = (stbtt_int16) y;
+      chardata[i].x1 = (stbtt_int16) (x + gw);
+      chardata[i].y1 = (stbtt_int16) (y + gh);
+      chardata[i].xadvance = scale * advance;
+      chardata[i].xoff     = (float) x0;
+      chardata[i].yoff     = (float) y0;
+      x = x + gw + 1;
+      if (y+gh+1 > bottom_y)
+         bottom_y = y+gh+1;
+   }
+   return bottom_y;
+}
+
+STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule)
+{
+   float d3d_bias = opengl_fillrule ? 0 : -0.5f;
+   float ipw = 1.0f / pw, iph = 1.0f / ph;
+   const stbtt_bakedchar *b = chardata + char_index;
+   int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f);
+   int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f);
+
+   q->x0 = round_x + d3d_bias;
+   q->y0 = round_y + d3d_bias;
+   q->x1 = round_x + b->x1 - b->x0 + d3d_bias;
+   q->y1 = round_y + b->y1 - b->y0 + d3d_bias;
+
+   q->s0 = b->x0 * ipw;
+   q->t0 = b->y0 * iph;
+   q->s1 = b->x1 * ipw;
+   q->t1 = b->y1 * iph;
+
+   *xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// rectangle packing replacement routines if you don't have stb_rect_pack.h
+//
+
+#ifndef STB_RECT_PACK_VERSION
+
+typedef int stbrp_coord;
+
+////////////////////////////////////////////////////////////////////////////////////
+//                                                                                //
+//                                                                                //
+// COMPILER WARNING ?!?!?                                                         //
+//                                                                                //
+//                                                                                //
+// if you get a compile warning due to these symbols being defined more than      //
+// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h"         //
+//                                                                                //
+////////////////////////////////////////////////////////////////////////////////////
+
+typedef struct
+{
+   int width,height;
+   int x,y,bottom_y;
+} stbrp_context;
+
+typedef struct
+{
+   unsigned char x;
+} stbrp_node;
+
+struct stbrp_rect
+{
+   stbrp_coord x,y;
+   int id,w,h,was_packed;
+};
+
+static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes)
+{
+   con->width  = pw;
+   con->height = ph;
+   con->x = 0;
+   con->y = 0;
+   con->bottom_y = 0;
+   STBTT__NOTUSED(nodes);
+   STBTT__NOTUSED(num_nodes);
+}
+
+static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects)
+{
+   int i;
+   for (i=0; i < num_rects; ++i) {
+      if (con->x + rects[i].w > con->width) {
+         con->x = 0;
+         con->y = con->bottom_y;
+      }
+      if (con->y + rects[i].h > con->height)
+         break;
+      rects[i].x = con->x;
+      rects[i].y = con->y;
+      rects[i].was_packed = 1;
+      con->x += rects[i].w;
+      if (con->y + rects[i].h > con->bottom_y)
+         con->bottom_y = con->y + rects[i].h;
+   }
+   for (   ; i < num_rects; ++i)
+      rects[i].was_packed = 0;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// bitmap baking
+//
+// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If
+// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy.
+
+STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)
+{
+   stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context)            ,alloc_context);
+   int            num_nodes = pw - padding;
+   stbrp_node    *nodes   = (stbrp_node    *) STBTT_malloc(sizeof(*nodes  ) * num_nodes,alloc_context);
+
+   if (context == NULL || nodes == NULL) {
+      if (context != NULL) STBTT_free(context, alloc_context);
+      if (nodes   != NULL) STBTT_free(nodes  , alloc_context);
+      return 0;
+   }
+
+   spc->user_allocator_context = alloc_context;
+   spc->width = pw;
+   spc->height = ph;
+   spc->pixels = pixels;
+   spc->pack_info = context;
+   spc->nodes = nodes;
+   spc->padding = padding;
+   spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw;
+   spc->h_oversample = 1;
+   spc->v_oversample = 1;
+   spc->skip_missing = 0;
+
+   stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes);
+
+   if (pixels)
+      STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels
+
+   return 1;
+}
+
+STBTT_DEF void stbtt_PackEnd  (stbtt_pack_context *spc)
+{
+   STBTT_free(spc->nodes    , spc->user_allocator_context);
+   STBTT_free(spc->pack_info, spc->user_allocator_context);
+}
+
+STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
+{
+   STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
+   STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
+   if (h_oversample <= STBTT_MAX_OVERSAMPLE)
+      spc->h_oversample = h_oversample;
+   if (v_oversample <= STBTT_MAX_OVERSAMPLE)
+      spc->v_oversample = v_oversample;
+}
+
+STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip)
+{
+   spc->skip_missing = skip;
+}
+
+#define STBTT__OVER_MASK  (STBTT_MAX_OVERSAMPLE-1)
+
+static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
+{
+   unsigned char buffer[STBTT_MAX_OVERSAMPLE];
+   int safe_w = w - kernel_width;
+   int j;
+   STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze
+   for (j=0; j < h; ++j) {
+      int i;
+      unsigned int total;
+      STBTT_memset(buffer, 0, kernel_width);
+
+      total = 0;
+
+      // make kernel_width a constant in common cases so compiler can optimize out the divide
+      switch (kernel_width) {
+         case 2:
+            for (i=0; i <= safe_w; ++i) {
+               total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
+               pixels[i] = (unsigned char) (total / 2);
+            }
+            break;
+         case 3:
+            for (i=0; i <= safe_w; ++i) {
+               total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
+               pixels[i] = (unsigned char) (total / 3);
+            }
+            break;
+         case 4:
+            for (i=0; i <= safe_w; ++i) {
+               total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
+               pixels[i] = (unsigned char) (total / 4);
+            }
+            break;
+         case 5:
+            for (i=0; i <= safe_w; ++i) {
+               total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
+               pixels[i] = (unsigned char) (total / 5);
+            }
+            break;
+         default:
+            for (i=0; i <= safe_w; ++i) {
+               total += pixels[i] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i];
+               pixels[i] = (unsigned char) (total / kernel_width);
+            }
+            break;
+      }
+
+      for (; i < w; ++i) {
+         STBTT_assert(pixels[i] == 0);
+         total -= buffer[i & STBTT__OVER_MASK];
+         pixels[i] = (unsigned char) (total / kernel_width);
+      }
+
+      pixels += stride_in_bytes;
+   }
+}
+
+static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width)
+{
+   unsigned char buffer[STBTT_MAX_OVERSAMPLE];
+   int safe_h = h - kernel_width;
+   int j;
+   STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze
+   for (j=0; j < w; ++j) {
+      int i;
+      unsigned int total;
+      STBTT_memset(buffer, 0, kernel_width);
+
+      total = 0;
+
+      // make kernel_width a constant in common cases so compiler can optimize out the divide
+      switch (kernel_width) {
+         case 2:
+            for (i=0; i <= safe_h; ++i) {
+               total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
+               pixels[i*stride_in_bytes] = (unsigned char) (total / 2);
+            }
+            break;
+         case 3:
+            for (i=0; i <= safe_h; ++i) {
+               total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
+               pixels[i*stride_in_bytes] = (unsigned char) (total / 3);
+            }
+            break;
+         case 4:
+            for (i=0; i <= safe_h; ++i) {
+               total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
+               pixels[i*stride_in_bytes] = (unsigned char) (total / 4);
+            }
+            break;
+         case 5:
+            for (i=0; i <= safe_h; ++i) {
+               total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
+               pixels[i*stride_in_bytes] = (unsigned char) (total / 5);
+            }
+            break;
+         default:
+            for (i=0; i <= safe_h; ++i) {
+               total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK];
+               buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes];
+               pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width);
+            }
+            break;
+      }
+
+      for (; i < h; ++i) {
+         STBTT_assert(pixels[i*stride_in_bytes] == 0);
+         total -= buffer[i & STBTT__OVER_MASK];
+         pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width);
+      }
+
+      pixels += 1;
+   }
+}
+
+static float stbtt__oversample_shift(int oversample)
+{
+   if (!oversample)
+      return 0.0f;
+
+   // The prefilter is a box filter of width "oversample",
+   // which shifts phase by (oversample - 1)/2 pixels in
+   // oversampled space. We want to shift in the opposite
+   // direction to counter this.
+   return (float)-(oversample - 1) / (2.0f * (float)oversample);
+}
+
+// rects array must be big enough to accommodate all characters in the given ranges
+STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
+{
+   int i,j,k;
+
+   k=0;
+   for (i=0; i < num_ranges; ++i) {
+      float fh = ranges[i].font_size;
+      float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
+      ranges[i].h_oversample = (unsigned char) spc->h_oversample;
+      ranges[i].v_oversample = (unsigned char) spc->v_oversample;
+      for (j=0; j < ranges[i].num_chars; ++j) {
+         int x0,y0,x1,y1;
+         int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
+         int glyph = stbtt_FindGlyphIndex(info, codepoint);
+         if (glyph == 0 && spc->skip_missing) {
+            rects[k].w = rects[k].h = 0;
+         } else {
+            stbtt_GetGlyphBitmapBoxSubpixel(info,glyph,
+                                            scale * spc->h_oversample,
+                                            scale * spc->v_oversample,
+                                            0,0,
+                                            &x0,&y0,&x1,&y1);
+            rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1);
+            rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1);
+         }
+         ++k;
+      }
+   }
+
+   return k;
+}
+
+STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph)
+{
+   stbtt_MakeGlyphBitmapSubpixel(info,
+                                 output,
+                                 out_w - (prefilter_x - 1),
+                                 out_h - (prefilter_y - 1),
+                                 out_stride,
+                                 scale_x,
+                                 scale_y,
+                                 shift_x,
+                                 shift_y,
+                                 glyph);
+
+   if (prefilter_x > 1)
+      stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x);
+
+   if (prefilter_y > 1)
+      stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y);
+
+   *sub_x = stbtt__oversample_shift(prefilter_x);
+   *sub_y = stbtt__oversample_shift(prefilter_y);
+}
+
+// rects array must be big enough to accommodate all characters in the given ranges
+STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects)
+{
+   int i,j,k, return_value = 1;
+
+   // save current values
+   int old_h_over = spc->h_oversample;
+   int old_v_over = spc->v_oversample;
+
+   k = 0;
+   for (i=0; i < num_ranges; ++i) {
+      float fh = ranges[i].font_size;
+      float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh);
+      float recip_h,recip_v,sub_x,sub_y;
+      spc->h_oversample = ranges[i].h_oversample;
+      spc->v_oversample = ranges[i].v_oversample;
+      recip_h = 1.0f / spc->h_oversample;
+      recip_v = 1.0f / spc->v_oversample;
+      sub_x = stbtt__oversample_shift(spc->h_oversample);
+      sub_y = stbtt__oversample_shift(spc->v_oversample);
+      for (j=0; j < ranges[i].num_chars; ++j) {
+         stbrp_rect *r = &rects[k];
+         if (r->was_packed && r->w != 0 && r->h != 0) {
+            stbtt_packedchar *bc = &ranges[i].chardata_for_range[j];
+            int advance, lsb, x0,y0,x1,y1;
+            int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j];
+            int glyph = stbtt_FindGlyphIndex(info, codepoint);
+            stbrp_coord pad = (stbrp_coord) spc->padding;
+
+            // pad on left and top
+            r->x += pad;
+            r->y += pad;
+            r->w -= pad;
+            r->h -= pad;
+            stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb);
+            stbtt_GetGlyphBitmapBox(info, glyph,
+                                    scale * spc->h_oversample,
+                                    scale * spc->v_oversample,
+                                    &x0,&y0,&x1,&y1);
+            stbtt_MakeGlyphBitmapSubpixel(info,
+                                          spc->pixels + r->x + r->y*spc->stride_in_bytes,
+                                          r->w - spc->h_oversample+1,
+                                          r->h - spc->v_oversample+1,
+                                          spc->stride_in_bytes,
+                                          scale * spc->h_oversample,
+                                          scale * spc->v_oversample,
+                                          0,0,
+                                          glyph);
+
+            if (spc->h_oversample > 1)
+               stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes,
+                                  r->w, r->h, spc->stride_in_bytes,
+                                  spc->h_oversample);
+
+            if (spc->v_oversample > 1)
+               stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes,
+                                  r->w, r->h, spc->stride_in_bytes,
+                                  spc->v_oversample);
+
+            bc->x0       = (stbtt_int16)  r->x;
+            bc->y0       = (stbtt_int16)  r->y;
+            bc->x1       = (stbtt_int16) (r->x + r->w);
+            bc->y1       = (stbtt_int16) (r->y + r->h);
+            bc->xadvance =                scale * advance;
+            bc->xoff     =       (float)  x0 * recip_h + sub_x;
+            bc->yoff     =       (float)  y0 * recip_v + sub_y;
+            bc->xoff2    =                (x0 + r->w) * recip_h + sub_x;
+            bc->yoff2    =                (y0 + r->h) * recip_v + sub_y;
+         } else {
+            return_value = 0; // if any fail, report failure
+         }
+
+         ++k;
+      }
+   }
+
+   // restore original values
+   spc->h_oversample = old_h_over;
+   spc->v_oversample = old_v_over;
+
+   return return_value;
+}
+
+STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects)
+{
+   stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects);
+}
+
+STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges)
+{
+   stbtt_fontinfo info;
+   int i,j,n, return_value; // [DEAR IMGUI] removed = 1
+   //stbrp_context *context = (stbrp_context *) spc->pack_info;
+   stbrp_rect    *rects;
+
+   // flag all characters as NOT packed
+   for (i=0; i < num_ranges; ++i)
+      for (j=0; j < ranges[i].num_chars; ++j)
+         ranges[i].chardata_for_range[j].x0 =
+         ranges[i].chardata_for_range[j].y0 =
+         ranges[i].chardata_for_range[j].x1 =
+         ranges[i].chardata_for_range[j].y1 = 0;
+
+   n = 0;
+   for (i=0; i < num_ranges; ++i)
+      n += ranges[i].num_chars;
+
+   rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context);
+   if (rects == NULL)
+      return 0;
+
+   info.userdata = spc->user_allocator_context;
+   stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index));
+
+   n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects);
+
+   stbtt_PackFontRangesPackRects(spc, rects, n);
+
+   return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects);
+
+   STBTT_free(rects, spc->user_allocator_context);
+   return return_value;
+}
+
+STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size,
+            int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range)
+{
+   stbtt_pack_range range;
+   range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range;
+   range.array_of_unicode_codepoints = NULL;
+   range.num_chars                   = num_chars_in_range;
+   range.chardata_for_range          = chardata_for_range;
+   range.font_size                   = font_size;
+   return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1);
+}
+
+STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap)
+{
+   int i_ascent, i_descent, i_lineGap;
+   float scale;
+   stbtt_fontinfo info;
+   stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index));
+   scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size);
+   stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap);
+   *ascent  = (float) i_ascent  * scale;
+   *descent = (float) i_descent * scale;
+   *lineGap = (float) i_lineGap * scale;
+}
+
+STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer)
+{
+   float ipw = 1.0f / pw, iph = 1.0f / ph;
+   const stbtt_packedchar *b = chardata + char_index;
+
+   if (align_to_integer) {
+      float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f);
+      float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f);
+      q->x0 = x;
+      q->y0 = y;
+      q->x1 = x + b->xoff2 - b->xoff;
+      q->y1 = y + b->yoff2 - b->yoff;
+   } else {
+      q->x0 = *xpos + b->xoff;
+      q->y0 = *ypos + b->yoff;
+      q->x1 = *xpos + b->xoff2;
+      q->y1 = *ypos + b->yoff2;
+   }
+
+   q->s0 = b->x0 * ipw;
+   q->t0 = b->y0 * iph;
+   q->s1 = b->x1 * ipw;
+   q->t1 = b->y1 * iph;
+
+   *xpos += b->xadvance;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// sdf computation
+//
+
+#define STBTT_min(a,b)  ((a) < (b) ? (a) : (b))
+#define STBTT_max(a,b)  ((a) < (b) ? (b) : (a))
+
+static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2])
+{
+   float q0perp = q0[1]*ray[0] - q0[0]*ray[1];
+   float q1perp = q1[1]*ray[0] - q1[0]*ray[1];
+   float q2perp = q2[1]*ray[0] - q2[0]*ray[1];
+   float roperp = orig[1]*ray[0] - orig[0]*ray[1];
+
+   float a = q0perp - 2*q1perp + q2perp;
+   float b = q1perp - q0perp;
+   float c = q0perp - roperp;
+
+   float s0 = 0., s1 = 0.;
+   int num_s = 0;
+
+   if (a != 0.0) {
+      float discr = b*b - a*c;
+      if (discr > 0.0) {
+         float rcpna = -1 / a;
+         float d = (float) STBTT_sqrt(discr);
+         s0 = (b+d) * rcpna;
+         s1 = (b-d) * rcpna;
+         if (s0 >= 0.0 && s0 <= 1.0)
+            num_s = 1;
+         if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) {
+            if (num_s == 0) s0 = s1;
+            ++num_s;
+         }
+      }
+   } else {
+      // 2*b*s + c = 0
+      // s = -c / (2*b)
+      s0 = c / (-2 * b);
+      if (s0 >= 0.0 && s0 <= 1.0)
+         num_s = 1;
+   }
+
+   if (num_s == 0)
+      return 0;
+   else {
+      float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]);
+      float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2;
+
+      float q0d =   q0[0]*rayn_x +   q0[1]*rayn_y;
+      float q1d =   q1[0]*rayn_x +   q1[1]*rayn_y;
+      float q2d =   q2[0]*rayn_x +   q2[1]*rayn_y;
+      float rod = orig[0]*rayn_x + orig[1]*rayn_y;
+
+      float q10d = q1d - q0d;
+      float q20d = q2d - q0d;
+      float q0rd = q0d - rod;
+
+      hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d;
+      hits[0][1] = a*s0+b;
+
+      if (num_s > 1) {
+         hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d;
+         hits[1][1] = a*s1+b;
+         return 2;
+      } else {
+         return 1;
+      }
+   }
+}
+
+static int equal(float *a, float *b)
+{
+   return (a[0] == b[0] && a[1] == b[1]);
+}
+
+static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts)
+{
+   int i;
+   float orig[2], ray[2] = { 1, 0 };
+   float y_frac;
+   int winding = 0;
+
+   orig[0] = x;
+   //orig[1] = y; // [DEAR IMGUI] commented double assignment
+
+   // make sure y never passes through a vertex of the shape
+   y_frac = (float) STBTT_fmod(y, 1.0f);
+   if (y_frac < 0.01f)
+      y += 0.01f;
+   else if (y_frac > 0.99f)
+      y -= 0.01f;
+   orig[1] = y;
+
+   // test a ray from (-infinity,y) to (x,y)
+   for (i=0; i < nverts; ++i) {
+      if (verts[i].type == STBTT_vline) {
+         int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y;
+         int x1 = (int) verts[i  ].x, y1 = (int) verts[i  ].y;
+         if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
+            float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
+            if (x_inter < x)
+               winding += (y0 < y1) ? 1 : -1;
+         }
+      }
+      if (verts[i].type == STBTT_vcurve) {
+         int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ;
+         int x1 = (int) verts[i  ].cx, y1 = (int) verts[i  ].cy;
+         int x2 = (int) verts[i  ].x , y2 = (int) verts[i  ].y ;
+         int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2));
+         int by = STBTT_max(y0,STBTT_max(y1,y2));
+         if (y > ay && y < by && x > ax) {
+            float q0[2],q1[2],q2[2];
+            float hits[2][2];
+            q0[0] = (float)x0;
+            q0[1] = (float)y0;
+            q1[0] = (float)x1;
+            q1[1] = (float)y1;
+            q2[0] = (float)x2;
+            q2[1] = (float)y2;
+            if (equal(q0,q1) || equal(q1,q2)) {
+               x0 = (int)verts[i-1].x;
+               y0 = (int)verts[i-1].y;
+               x1 = (int)verts[i  ].x;
+               y1 = (int)verts[i  ].y;
+               if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) {
+                  float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0;
+                  if (x_inter < x)
+                     winding += (y0 < y1) ? 1 : -1;
+               }
+            } else {
+               int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits);
+               if (num_hits >= 1)
+                  if (hits[0][0] < 0)
+                     winding += (hits[0][1] < 0 ? -1 : 1);
+               if (num_hits >= 2)
+                  if (hits[1][0] < 0)
+                     winding += (hits[1][1] < 0 ? -1 : 1);
+            }
+         }
+      }
+   }
+   return winding;
+}
+
+static float stbtt__cuberoot( float x )
+{
+   if (x<0)
+      return -(float) STBTT_pow(-x,1.0f/3.0f);
+   else
+      return  (float) STBTT_pow( x,1.0f/3.0f);
+}
+
+// x^3 + c*x^2 + b*x + a = 0
+static int stbtt__solve_cubic(float a, float b, float c, float* r)
+{
+	float s = -a / 3;
+	float p = b - a*a / 3;
+	float q = a * (2*a*a - 9*b) / 27 + c;
+   float p3 = p*p*p;
+	float d = q*q + 4*p3 / 27;
+	if (d >= 0) {
+		float z = (float) STBTT_sqrt(d);
+		float u = (-q + z) / 2;
+		float v = (-q - z) / 2;
+		u = stbtt__cuberoot(u);
+		v = stbtt__cuberoot(v);
+		r[0] = s + u + v;
+		return 1;
+	} else {
+	   float u = (float) STBTT_sqrt(-p/3);
+	   float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative
+	   float m = (float) STBTT_cos(v);
+      float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f;
+	   r[0] = s + u * 2 * m;
+	   r[1] = s - u * (m + n);
+	   r[2] = s - u * (m - n);
+
+      //STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f);  // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe?
+      //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f);
+      //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f);
+   	return 3;
+   }
+}
+
+STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)
+{
+   float scale_x = scale, scale_y = scale;
+   int ix0,iy0,ix1,iy1;
+   int w,h;
+   unsigned char *data;
+
+   // if one scale is 0, use same scale for both
+   if (scale_x == 0) scale_x = scale_y;
+   if (scale_y == 0) {
+      if (scale_x == 0) return NULL;  // if both scales are 0, return NULL
+      scale_y = scale_x;
+   }
+
+   stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1);
+
+   // if empty, return NULL
+   if (ix0 == ix1 || iy0 == iy1)
+      return NULL;
+
+   ix0 -= padding;
+   iy0 -= padding;
+   ix1 += padding;
+   iy1 += padding;
+
+   w = (ix1 - ix0);
+   h = (iy1 - iy0);
+
+   if (width ) *width  = w;
+   if (height) *height = h;
+   if (xoff  ) *xoff   = ix0;
+   if (yoff  ) *yoff   = iy0;
+
+   // invert for y-downwards bitmaps
+   scale_y = -scale_y;
+
+   {
+      int x,y,i,j;
+      float *precompute;
+      stbtt_vertex *verts;
+      int num_verts = stbtt_GetGlyphShape(info, glyph, &verts);
+      data = (unsigned char *) STBTT_malloc(w * h, info->userdata);
+      precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata);
+
+      for (i=0,j=num_verts-1; i < num_verts; j=i++) {
+         if (verts[i].type == STBTT_vline) {
+            float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y;
+            float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y;
+            float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0));
+            precompute[i] = (dist == 0) ? 0.0f : 1.0f / dist;
+         } else if (verts[i].type == STBTT_vcurve) {
+            float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y;
+            float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y;
+            float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y;
+            float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
+            float len2 = bx*bx + by*by;
+            if (len2 != 0.0f)
+               precompute[i] = 1.0f / (bx*bx + by*by);
+            else
+               precompute[i] = 0.0f;
+         } else
+            precompute[i] = 0.0f;
+      }
+
+      for (y=iy0; y < iy1; ++y) {
+         for (x=ix0; x < ix1; ++x) {
+            float val;
+            float min_dist = 999999.0f;
+            float sx = (float) x + 0.5f;
+            float sy = (float) y + 0.5f;
+            float x_gspace = (sx / scale_x);
+            float y_gspace = (sy / scale_y);
+
+            int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path
+
+            for (i=0; i < num_verts; ++i) {
+               float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y;
+
+               // check against every point here rather than inside line/curve primitives -- @TODO: wrong if multiple 'moves' in a row produce a garbage point, and given culling, probably more efficient to do within line/curve
+               float dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy);
+               if (dist2 < min_dist*min_dist)
+                  min_dist = (float) STBTT_sqrt(dist2);
+
+               if (verts[i].type == STBTT_vline) {
+                  float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y;
+
+                  // coarse culling against bbox
+                  //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist &&
+                  //    sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist)
+                  float dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i];
+                  STBTT_assert(i != 0);
+                  if (dist < min_dist) {
+                     // check position along line
+                     // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0)
+                     // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy)
+                     float dx = x1-x0, dy = y1-y0;
+                     float px = x0-sx, py = y0-sy;
+                     // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy
+                     // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve
+                     float t = -(px*dx + py*dy) / (dx*dx + dy*dy);
+                     if (t >= 0.0f && t <= 1.0f)
+                        min_dist = dist;
+                  }
+               } else if (verts[i].type == STBTT_vcurve) {
+                  float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y;
+                  float x1 = verts[i  ].cx*scale_x, y1 = verts[i  ].cy*scale_y;
+                  float box_x0 = STBTT_min(STBTT_min(x0,x1),x2);
+                  float box_y0 = STBTT_min(STBTT_min(y0,y1),y2);
+                  float box_x1 = STBTT_max(STBTT_max(x0,x1),x2);
+                  float box_y1 = STBTT_max(STBTT_max(y0,y1),y2);
+                  // coarse culling against bbox to avoid computing cubic unnecessarily
+                  if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) {
+                     int num=0;
+                     float ax = x1-x0, ay = y1-y0;
+                     float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2;
+                     float mx = x0 - sx, my = y0 - sy;
+                     float res[3],px,py,t,it;
+                     float a_inv = precompute[i];
+                     if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula
+                        float a = 3*(ax*bx + ay*by);
+                        float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by);
+                        float c = mx*ax+my*ay;
+                        if (a == 0.0) { // if a is 0, it's linear
+                           if (b != 0.0) {
+                              res[num++] = -c/b;
+                           }
+                        } else {
+                           float discriminant = b*b - 4*a*c;
+                           if (discriminant < 0)
+                              num = 0;
+                           else {
+                              float root = (float) STBTT_sqrt(discriminant);
+                              res[0] = (-b - root)/(2*a);
+                              res[1] = (-b + root)/(2*a);
+                              num = 2; // don't bother distinguishing 1-solution case, as code below will still work
+                           }
+                        }
+                     } else {
+                        float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point
+                        float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv;
+                        float d = (mx*ax+my*ay) * a_inv;
+                        num = stbtt__solve_cubic(b, c, d, res);
+                     }
+                     if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) {
+                        t = res[0], it = 1.0f - t;
+                        px = it*it*x0 + 2*t*it*x1 + t*t*x2;
+                        py = it*it*y0 + 2*t*it*y1 + t*t*y2;
+                        dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
+                        if (dist2 < min_dist * min_dist)
+                           min_dist = (float) STBTT_sqrt(dist2);
+                     }
+                     if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) {
+                        t = res[1], it = 1.0f - t;
+                        px = it*it*x0 + 2*t*it*x1 + t*t*x2;
+                        py = it*it*y0 + 2*t*it*y1 + t*t*y2;
+                        dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
+                        if (dist2 < min_dist * min_dist)
+                           min_dist = (float) STBTT_sqrt(dist2);
+                     }
+                     if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) {
+                        t = res[2], it = 1.0f - t;
+                        px = it*it*x0 + 2*t*it*x1 + t*t*x2;
+                        py = it*it*y0 + 2*t*it*y1 + t*t*y2;
+                        dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy);
+                        if (dist2 < min_dist * min_dist)
+                           min_dist = (float) STBTT_sqrt(dist2);
+                     }
+                  }
+               }
+            }
+            if (winding == 0)
+               min_dist = -min_dist;  // if outside the shape, value is negative
+            val = onedge_value + pixel_dist_scale * min_dist;
+            if (val < 0)
+               val = 0;
+            else if (val > 255)
+               val = 255;
+            data[(y-iy0)*w+(x-ix0)] = (unsigned char) val;
+         }
+      }
+      STBTT_free(precompute, info->userdata);
+      STBTT_free(verts, info->userdata);
+   }
+   return data;
+}
+
+STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff)
+{
+   return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff);
+}
+
+STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)
+{
+   STBTT_free(bitmap, userdata);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// font name matching -- recommended not to use this
+//
+
+// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string
+static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2)
+{
+   stbtt_int32 i=0;
+
+   // convert utf16 to utf8 and compare the results while converting
+   while (len2) {
+      stbtt_uint16 ch = s2[0]*256 + s2[1];
+      if (ch < 0x80) {
+         if (i >= len1) return -1;
+         if (s1[i++] != ch) return -1;
+      } else if (ch < 0x800) {
+         if (i+1 >= len1) return -1;
+         if (s1[i++] != 0xc0 + (ch >> 6)) return -1;
+         if (s1[i++] != 0x80 + (ch & 0x3f)) return -1;
+      } else if (ch >= 0xd800 && ch < 0xdc00) {
+         stbtt_uint32 c;
+         stbtt_uint16 ch2 = s2[2]*256 + s2[3];
+         if (i+3 >= len1) return -1;
+         c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
+         if (s1[i++] != 0xf0 + (c >> 18)) return -1;
+         if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1;
+         if (s1[i++] != 0x80 + ((c >>  6) & 0x3f)) return -1;
+         if (s1[i++] != 0x80 + ((c      ) & 0x3f)) return -1;
+         s2 += 2; // plus another 2 below
+         len2 -= 2;
+      } else if (ch >= 0xdc00 && ch < 0xe000) {
+         return -1;
+      } else {
+         if (i+2 >= len1) return -1;
+         if (s1[i++] != 0xe0 + (ch >> 12)) return -1;
+         if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1;
+         if (s1[i++] != 0x80 + ((ch     ) & 0x3f)) return -1;
+      }
+      s2 += 2;
+      len2 -= 2;
+   }
+   return i;
+}
+
+static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2)
+{
+   return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2);
+}
+
+// returns results in whatever encoding you request... but note that 2-byte encodings
+// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare
+STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID)
+{
+   stbtt_int32 i,count,stringOffset;
+   stbtt_uint8 *fc = font->data;
+   stbtt_uint32 offset = font->fontstart;
+   stbtt_uint32 nm = stbtt__find_table(fc, offset, "name");
+   if (!nm) return NULL;
+
+   count = ttUSHORT(fc+nm+2);
+   stringOffset = nm + ttUSHORT(fc+nm+4);
+   for (i=0; i < count; ++i) {
+      stbtt_uint32 loc = nm + 6 + 12 * i;
+      if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2)
+          && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) {
+         *length = ttUSHORT(fc+loc+8);
+         return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10));
+      }
+   }
+   return NULL;
+}
+
+static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id)
+{
+   stbtt_int32 i;
+   stbtt_int32 count = ttUSHORT(fc+nm+2);
+   stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4);
+
+   for (i=0; i < count; ++i) {
+      stbtt_uint32 loc = nm + 6 + 12 * i;
+      stbtt_int32 id = ttUSHORT(fc+loc+6);
+      if (id == target_id) {
+         // find the encoding
+         stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4);
+
+         // is this a Unicode encoding?
+         if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) {
+            stbtt_int32 slen = ttUSHORT(fc+loc+8);
+            stbtt_int32 off = ttUSHORT(fc+loc+10);
+
+            // check if there's a prefix match
+            stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen);
+            if (matchlen >= 0) {
+               // check for target_id+1 immediately following, with same encoding & language
+               if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) {
+                  slen = ttUSHORT(fc+loc+12+8);
+                  off = ttUSHORT(fc+loc+12+10);
+                  if (slen == 0) {
+                     if (matchlen == nlen)
+                        return 1;
+                  } else if (matchlen < nlen && name[matchlen] == ' ') {
+                     ++matchlen;
+                     if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen))
+                        return 1;
+                  }
+               } else {
+                  // if nothing immediately following
+                  if (matchlen == nlen)
+                     return 1;
+               }
+            }
+         }
+
+         // @TODO handle other encodings
+      }
+   }
+   return 0;
+}
+
+static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags)
+{
+   stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name);
+   stbtt_uint32 nm,hd;
+   if (!stbtt__isfont(fc+offset)) return 0;
+
+   // check italics/bold/underline flags in macStyle...
+   if (flags) {
+      hd = stbtt__find_table(fc, offset, "head");
+      if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0;
+   }
+
+   nm = stbtt__find_table(fc, offset, "name");
+   if (!nm) return 0;
+
+   if (flags) {
+      // if we checked the macStyle flags, then just check the family and ignore the subfamily
+      if (stbtt__matchpair(fc, nm, name, nlen, 16, -1))  return 1;
+      if (stbtt__matchpair(fc, nm, name, nlen,  1, -1))  return 1;
+      if (stbtt__matchpair(fc, nm, name, nlen,  3, -1))  return 1;
+   } else {
+      if (stbtt__matchpair(fc, nm, name, nlen, 16, 17))  return 1;
+      if (stbtt__matchpair(fc, nm, name, nlen,  1,  2))  return 1;
+      if (stbtt__matchpair(fc, nm, name, nlen,  3, -1))  return 1;
+   }
+
+   return 0;
+}
+
+static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags)
+{
+   stbtt_int32 i;
+   for (i=0;;++i) {
+      stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i);
+      if (off < 0) return off;
+      if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags))
+         return off;
+   }
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+
+STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,
+                                float pixel_height, unsigned char *pixels, int pw, int ph,
+                                int first_char, int num_chars, stbtt_bakedchar *chardata)
+{
+   return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata);
+}
+
+STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index)
+{
+   return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index);
+}
+
+STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)
+{
+   return stbtt_GetNumberOfFonts_internal((unsigned char *) data);
+}
+
+STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset)
+{
+   return stbtt_InitFont_internal(info, (unsigned char *) data, offset);
+}
+
+STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags)
+{
+   return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags);
+}
+
+STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2)
+{
+   return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+#endif // STB_TRUETYPE_IMPLEMENTATION
+
+
+// FULL VERSION HISTORY
+//
+//   1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod
+//   1.18 (2018-01-29) add missing function
+//   1.17 (2017-07-23) make more arguments const; doc fix
+//   1.16 (2017-07-12) SDF support
+//   1.15 (2017-03-03) make more arguments const
+//   1.14 (2017-01-16) num-fonts-in-TTC function
+//   1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
+//   1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
+//   1.11 (2016-04-02) fix unused-variable warning
+//   1.10 (2016-04-02) allow user-defined fabs() replacement
+//                     fix memory leak if fontsize=0.0
+//                     fix warning from duplicate typedef
+//   1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges
+//   1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
+//   1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
+//                     allow PackFontRanges to pack and render in separate phases;
+//                     fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
+//                     fixed an assert() bug in the new rasterizer
+//                     replace assert() with STBTT_assert() in new rasterizer
+//   1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine)
+//                     also more precise AA rasterizer, except if shapes overlap
+//                     remove need for STBTT_sort
+//   1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC
+//   1.04 (2015-04-15) typo in example
+//   1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes
+//   1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++
+//   1.01 (2014-12-08) fix subpixel position when oversampling to exactly match
+//                        non-oversampled; STBTT_POINT_SIZE for packed case only
+//   1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling
+//   0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg)
+//   0.9  (2014-08-07) support certain mac/iOS fonts without an MS platformID
+//   0.8b (2014-07-07) fix a warning
+//   0.8  (2014-05-25) fix a few more warnings
+//   0.7  (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back
+//   0.6c (2012-07-24) improve documentation
+//   0.6b (2012-07-20) fix a few more warnings
+//   0.6  (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels,
+//                        stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty
+//   0.5  (2011-12-09) bugfixes:
+//                        subpixel glyph renderer computed wrong bounding box
+//                        first vertex of shape can be off-curve (FreeSans)
+//   0.4b (2011-12-03) fixed an error in the font baking example
+//   0.4  (2011-12-01) kerning, subpixel rendering (tor)
+//                    bugfixes for:
+//                        codepoint-to-glyph conversion using table fmt=12
+//                        codepoint-to-glyph conversion using table fmt=4
+//                        stbtt_GetBakedQuad with non-square texture (Zer)
+//                    updated Hello World! sample to use kerning and subpixel
+//                    fixed some warnings
+//   0.3  (2009-06-24) cmap fmt=12, compound shapes (MM)
+//                    userdata, malloc-from-userdata, non-zero fill (stb)
+//   0.2  (2009-03-11) Fix unsigned/signed char warnings
+//   0.1  (2009-03-09) First public release
+//
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
+ rlImGui/raylib/src/config.h view
@@ -0,0 +1,241 @@+/**********************************************************************************************
+*
+*   raylib configuration flags
+*
+*   This file defines all the configuration flags for the different raylib modules
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2018-2021 Ahmad Fatoum & Ramon Santamaria (@raysan5)
+*
+*   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.
+*
+**********************************************************************************************/
+
+//------------------------------------------------------------------------------------
+// Module selection - Some modules could be avoided
+// Mandatory modules: rcore, rlgl, utils
+//------------------------------------------------------------------------------------
+#define SUPPORT_MODULE_RSHAPES           1
+#define SUPPORT_MODULE_RTEXTURES         1
+#define SUPPORT_MODULE_RTEXT             1          // WARNING: It requires SUPPORT_MODULE_RTEXTURES to load sprite font textures
+#define SUPPORT_MODULE_RMODELS           1
+#define SUPPORT_MODULE_RAUDIO            1
+
+//------------------------------------------------------------------------------------
+// Module: rcore - Configuration Flags
+//------------------------------------------------------------------------------------
+// Camera module is included (rcamera.h) and multiple predefined cameras are available: free, 1st/3rd person, orbital
+#define SUPPORT_CAMERA_SYSTEM       1
+// Gestures module is included (rgestures.h) to support gestures detection: tap, hold, swipe, drag
+#define SUPPORT_GESTURES_SYSTEM     1
+// Mouse gestures are directly mapped like touches and processed by gestures system
+#define SUPPORT_MOUSE_GESTURES      1
+// Reconfigure standard input to receive key inputs, works with SSH connection.
+#define SUPPORT_SSH_KEYBOARD_RPI    1
+// Draw a mouse pointer on screen
+//#define SUPPORT_MOUSE_CURSOR_POINT   1
+// Setting a higher resolution can improve the accuracy of time-out intervals in wait functions.
+// However, it can also reduce overall system performance, because the thread scheduler switches tasks more often.
+#define SUPPORT_WINMM_HIGHRES_TIMER 1
+// Use busy wait loop for timing sync, if not defined, a high-resolution timer is setup and used
+//#define SUPPORT_BUSY_WAIT_LOOP      1
+// Use a partial-busy wait loop, in this case frame sleeps for most of the time, but then runs a busy loop at the end for accuracy
+#define SUPPORT_PARTIALBUSY_WAIT_LOOP
+// Wait for events passively (sleeping while no events) instead of polling them actively every frame
+//#define SUPPORT_EVENTS_WAITING      1
+// Allow automatic screen capture of current screen pressing F12, defined in KeyCallback()
+#define SUPPORT_SCREEN_CAPTURE      1
+// Allow automatic gif recording of current screen pressing CTRL+F12, defined in KeyCallback()
+#define SUPPORT_GIF_RECORDING       1
+// Support CompressData() and DecompressData() functions
+#define SUPPORT_COMPRESSION_API     1
+// Support saving binary data automatically to a generated storage.data file. This file is managed internally.
+#define SUPPORT_DATA_STORAGE        1
+// Support automatic generated events, loading and recording of those events when required
+//#define SUPPORT_EVENTS_AUTOMATION     1
+// Support custom frame control, only for advance users
+// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timming + PollInputEvents()
+// Enabling this flag allows manual control of the frame processes, use at your own risk
+//#define SUPPORT_CUSTOM_FRAME_CONTROL   1
+
+// rcore: Configuration values
+//------------------------------------------------------------------------------------
+#define MAX_FILEPATH_CAPACITY       8192        // Maximum file paths capacity
+#define MAX_FILEPATH_LENGTH         4096        // Maximum length for filepaths (Linux PATH_MAX default value)
+
+#define MAX_KEYBOARD_KEYS            512        // Maximum number of keyboard keys supported
+#define MAX_MOUSE_BUTTONS              8        // Maximum number of mouse buttons supported
+#define MAX_GAMEPADS                   4        // Maximum number of gamepads supported
+#define MAX_GAMEPAD_AXIS               8        // Maximum number of axis supported (per gamepad)
+#define MAX_GAMEPAD_BUTTONS           32        // Maximum number of buttons supported (per gamepad)
+#define MAX_TOUCH_POINTS               8        // Maximum number of touch points supported
+#define MAX_KEY_PRESSED_QUEUE         16        // Maximum number of keys in the key input queue
+#define MAX_CHAR_PRESSED_QUEUE        16        // Maximum number of characters in the char input queue
+
+#define STORAGE_DATA_FILE  "storage.data"       // Automatic storage filename
+
+#define MAX_DECOMPRESSION_SIZE        64        // Max size allocated for decompression in MB
+
+
+//------------------------------------------------------------------------------------
+// Module: rlgl - Configuration values
+//------------------------------------------------------------------------------------
+
+// Enable OpenGL Debug Context (only available on OpenGL 4.3)
+//#define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT       1
+
+// Show OpenGL extensions and capabilities detailed logs on init
+//#define RLGL_SHOW_GL_DETAILS_INFO              1
+
+//#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS    4096    // Default internal render batch elements limits
+#define RL_DEFAULT_BATCH_BUFFERS               1      // Default number of batch buffers (multi-buffering)
+#define RL_DEFAULT_BATCH_DRAWCALLS           256      // Default number of batch draw calls (by state changes: mode, texture)
+#define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS     4      // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+
+#define RL_MAX_MATRIX_STACK_SIZE              32      // Maximum size of internal Matrix stack
+
+#define RL_MAX_SHADER_LOCATIONS               32      // Maximum number of shader locations supported
+
+#define RL_CULL_DISTANCE_NEAR               0.01      // Default projection matrix near cull distance
+#define RL_CULL_DISTANCE_FAR              1000.0      // Default projection matrix far cull distance
+
+// Default shader vertex attribute names to set location points
+// NOTE: When a new shader is loaded, the following locations are tried to be set for convenience
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Binded by default to shader location: 0
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Binded by default to shader location: 1
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Binded by default to shader location: 2
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Binded by default to shader location: 3
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Binded by default to shader location: 4
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Binded by default to shader location: 5
+
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+
+
+//------------------------------------------------------------------------------------
+// Module: rshapes - Configuration Flags
+//------------------------------------------------------------------------------------
+// Use QUADS instead of TRIANGLES for drawing when possible
+// Some lines-based shapes could still use lines
+#define SUPPORT_QUADS_DRAW_MODE     1
+
+
+//------------------------------------------------------------------------------------
+// Module: rtextures - Configuration Flags
+//------------------------------------------------------------------------------------
+// Selecte desired fileformats to be supported for image data loading
+#define SUPPORT_FILEFORMAT_PNG      1
+//#define SUPPORT_FILEFORMAT_BMP      1
+//#define SUPPORT_FILEFORMAT_TGA      1
+//#define SUPPORT_FILEFORMAT_JPG      1
+#define SUPPORT_FILEFORMAT_GIF      1
+#define SUPPORT_FILEFORMAT_QOI      1
+//#define SUPPORT_FILEFORMAT_PSD      1
+#define SUPPORT_FILEFORMAT_DDS      1
+#define SUPPORT_FILEFORMAT_HDR      1
+//#define SUPPORT_FILEFORMAT_KTX      1
+//#define SUPPORT_FILEFORMAT_ASTC     1
+//#define SUPPORT_FILEFORMAT_PKM      1
+//#define SUPPORT_FILEFORMAT_PVR      1
+
+// Support image export functionality (.png, .bmp, .tga, .jpg, .qoi)
+#define SUPPORT_IMAGE_EXPORT        1
+// Support procedural image generation functionality (gradient, spot, perlin-noise, cellular)
+#define SUPPORT_IMAGE_GENERATION    1
+// Support multiple image editing functions to scale, adjust colors, flip, draw on images, crop...
+// If not defined, still some functions are supported: ImageFormat(), ImageCrop(), ImageToPOT()
+#define SUPPORT_IMAGE_MANIPULATION  1
+
+
+//------------------------------------------------------------------------------------
+// Module: rtext - Configuration Flags
+//------------------------------------------------------------------------------------
+// Default font is loaded on window initialization to be available for the user to render simple text
+// NOTE: If enabled, uses external module functions to load default raylib font
+#define SUPPORT_DEFAULT_FONT        1
+// Selected desired font fileformats to be supported for loading
+#define SUPPORT_FILEFORMAT_FNT      1
+#define SUPPORT_FILEFORMAT_TTF      1
+
+// Support text management functions
+// If not defined, still some functions are supported: TextLength(), TextFormat()
+#define SUPPORT_TEXT_MANIPULATION   1
+
+// rtext: Configuration values
+//------------------------------------------------------------------------------------
+#define MAX_TEXT_BUFFER_LENGTH      1024        // Size of internal static buffers used on some functions:
+                                                // TextFormat(), TextSubtext(), TextToUpper(), TextToLower(), TextToPascal(), TextSplit()
+#define MAX_TEXTSPLIT_COUNT          128        // Maximum number of substrings to split: TextSplit()
+
+
+//------------------------------------------------------------------------------------
+// Module: rmodels - Configuration Flags
+//------------------------------------------------------------------------------------
+// Selected desired model fileformats to be supported for loading
+#define SUPPORT_FILEFORMAT_OBJ      1
+#define SUPPORT_FILEFORMAT_MTL      1
+#define SUPPORT_FILEFORMAT_IQM      1
+#define SUPPORT_FILEFORMAT_GLTF     1
+#define SUPPORT_FILEFORMAT_VOX      1
+// Support procedural mesh generation functions, uses external par_shapes.h library
+// NOTE: Some generated meshes DO NOT include generated texture coordinates
+#define SUPPORT_MESH_GENERATION     1
+
+// rmodels: Configuration values
+//------------------------------------------------------------------------------------
+#define MAX_MATERIAL_MAPS               12      // Maximum number of shader maps supported
+#define MAX_MESH_VERTEX_BUFFERS          7      // Maximum vertex buffers (VBO) per mesh
+
+//------------------------------------------------------------------------------------
+// Module: raudio - Configuration Flags
+//------------------------------------------------------------------------------------
+// Desired audio fileformats to be supported for loading
+#define SUPPORT_FILEFORMAT_WAV      1
+#define SUPPORT_FILEFORMAT_OGG      1
+#define SUPPORT_FILEFORMAT_XM       1
+#define SUPPORT_FILEFORMAT_MOD      1
+#define SUPPORT_FILEFORMAT_MP3      1
+//#define SUPPORT_FILEFORMAT_FLAC     1
+
+// raudio: Configuration values
+//------------------------------------------------------------------------------------
+#define AUDIO_DEVICE_FORMAT    ma_format_f32    // Device output format (miniaudio: float-32bit)
+#define AUDIO_DEVICE_CHANNELS              2    // Device output channels: stereo
+#define AUDIO_DEVICE_SAMPLE_RATE           0    // Device sample rate (device default)
+
+#define MAX_AUDIO_BUFFER_POOL_CHANNELS    16    // Maximum number of audio pool channels
+
+//------------------------------------------------------------------------------------
+// Module: utils - Configuration Flags
+//------------------------------------------------------------------------------------
+// Standard file io library (stdio.h) included
+#define SUPPORT_STANDARD_FILEIO
+// Show TRACELOG() output messages
+// NOTE: By default LOG_DEBUG traces not shown
+#define SUPPORT_TRACELOG            1
+//#define SUPPORT_TRACELOG_DEBUG      1
+
+// utils: Configuration values
+//------------------------------------------------------------------------------------
+#define MAX_TRACELOG_MSG_LENGTH          128    // Max length of one trace-log message
+ rlImGui/raylib/src/easings.h view
@@ -0,0 +1,263 @@+/*******************************************************************************************
+*
+*   raylib easings (header only file)
+*
+*   Useful easing functions for values animation
+*
+*   This header uses:
+*       #define EASINGS_STATIC_INLINE       // Inlines all functions code, so it runs faster.
+*                                           // This requires lots of memory on system.
+*   How to use:
+*   The four inputs t,b,c,d are defined as follows:
+*   t = current time (in any unit measure, but same unit as duration)
+*   b = starting value to interpolate
+*   c = the total change in value of b that needs to occur
+*   d = total time it should take to complete (duration)
+*
+*   Example:
+*
+*   int currentTime = 0;
+*   int duration = 100;
+*   float startPositionX = 0.0f;
+*   float finalPositionX = 30.0f;
+*   float currentPositionX = startPositionX;
+*
+*   while (currentPositionX < finalPositionX)
+*   {
+*       currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
+*       currentTime++;
+*   }
+*
+*   A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
+*
+*   Robert Penner License
+*   ---------------------------------------------------------------------------------
+*   Open source under the BSD License.
+*
+*   Copyright (c) 2001 Robert Penner. All rights reserved.
+*
+*   Redistribution and use in source and binary forms, with or without modification,
+*   are permitted provided that the following conditions are met:
+*
+*       - Redistributions of source code must retain the above copyright notice,
+*         this list of conditions and the following disclaimer.
+*       - Redistributions in binary form must reproduce the above copyright notice,
+*         this list of conditions and the following disclaimer in the documentation
+*         and/or other materials provided with the distribution.
+*       - Neither the name of the author nor the names of contributors may be used
+*         to endorse or promote products derived from this software without specific
+*         prior written permission.
+*
+*   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+*   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+*   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+*   IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+*   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+*   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+*   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+*   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+*   OF THE POSSIBILITY OF SUCH DAMAGE.
+*   ---------------------------------------------------------------------------------
+*
+*   Copyright (c) 2015 Ramon Santamaria
+*
+*   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 EASINGS_H
+#define EASINGS_H
+
+#define EASINGS_STATIC_INLINE     // NOTE: By default, compile functions as static inline
+
+#if defined(EASINGS_STATIC_INLINE)
+    #define EASEDEF static inline
+#else
+    #define EASEDEF extern
+#endif
+
+#include <math.h>       // Required for: sinf(), cosf(), sqrtf(), powf()
+
+#ifndef PI
+    #define PI 3.14159265358979323846f //Required as PI is not always defined in math.h
+#endif
+
+#ifdef __cplusplus
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+// Linear Easing functions
+EASEDEF float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }                            // Ease: Linear
+EASEDEF float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }                              // Ease: Linear In
+EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }                             // Ease: Linear Out
+EASEDEF float EaseLinearInOut(float t, float b, float c, float d) { return (c*t/d + b); }                           // Ease: Linear In Out
+
+// Sine Easing functions
+EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }            // Ease: Sine In
+EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }                // Ease: Sine Out
+EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }      // Ease: Sine Out
+
+// Circular Easing functions
+EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); } // Ease: Circular In
+EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); }  // Ease: Circular Out
+EASEDEF float EaseCircInOut(float t, float b, float c, float d)                                                      // Ease: Circular In Out
+{
+    if ((t/=d/2.0f) < 1.0f) return (-c/2.0f*(sqrtf(1.0f - t*t) - 1.0f) + b);
+    t -= 2.0f; return (c/2.0f*(sqrtf(1.0f - t*t) + 1.0f) + b);
+}
+
+// Cubic Easing functions
+EASEDEF float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }                      // Ease: Cubic In
+EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }    // Ease: Cubic Out
+EASEDEF float EaseCubicInOut(float t, float b, float c, float d)                                                     // Ease: Cubic In Out
+{
+    if ((t/=d/2.0f) < 1.0f) return (c/2.0f*t*t*t + b);
+    t -= 2.0f; return (c/2.0f*(t*t*t + 2.0f) + b);
+}
+
+// Quadratic Easing functions
+EASEDEF float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }                         // Ease: Quadratic In
+EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }              // Ease: Quadratic Out
+EASEDEF float EaseQuadInOut(float t, float b, float c, float d)                                                      // Ease: Quadratic In Out
+{
+    if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
+    return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b);
+}
+
+// Exponential Easing functions
+EASEDEF float EaseExpoIn(float t, float b, float c, float d) { return (t == 0.0f) ? b : (c*powf(2.0f, 10.0f*(t/d - 1.0f)) + b); }       // Ease: Exponential In
+EASEDEF float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-powf(2.0f, -10.0f*t/d) + 1.0f) + b); } // Ease: Exponential Out
+EASEDEF float EaseExpoInOut(float t, float b, float c, float d)                                                                         // Ease: Exponential In Out
+{
+    if (t == 0.0f) return b;
+    if (t == d) return (b + c);
+    if ((t/=d/2.0f) < 1.0f) return (c/2.0f*powf(2.0f, 10.0f*(t - 1.0f)) + b);
+
+    return (c/2.0f*(-powf(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
+}
+
+// Back Easing functions
+EASEDEF float EaseBackIn(float t, float b, float c, float d) // Ease: Back In
+{
+    float s = 1.70158f;
+    float postFix = t/=d;
+    return (c*(postFix)*t*((s + 1.0f)*t - s) + b);
+}
+
+EASEDEF float EaseBackOut(float t, float b, float c, float d) // Ease: Back Out
+{
+    float s = 1.70158f;
+    t = t/d - 1.0f;
+    return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b);
+}
+
+EASEDEF float EaseBackInOut(float t, float b, float c, float d) // Ease: Back In Out
+{
+    float s = 1.70158f;
+    if ((t/=d/2.0f) < 1.0f)
+    {
+        s *= 1.525f;
+        return (c/2.0f*(t*t*((s + 1.0f)*t - s)) + b);
+    }
+
+    float postFix = t-=2.0f;
+    s *= 1.525f;
+    return (c/2.0f*((postFix)*t*((s + 1.0f)*t + s) + 2.0f) + b);
+}
+
+// Bounce Easing functions
+EASEDEF float EaseBounceOut(float t, float b, float c, float d) // Ease: Bounce Out
+{
+    if ((t/=d) < (1.0f/2.75f))
+    {
+        return (c*(7.5625f*t*t) + b);
+    }
+    else if (t < (2.0f/2.75f))
+    {
+        float postFix = t-=(1.5f/2.75f);
+        return (c*(7.5625f*(postFix)*t + 0.75f) + b);
+    }
+    else if (t < (2.5/2.75))
+    {
+        float postFix = t-=(2.25f/2.75f);
+        return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
+    }
+    else
+    {
+        float postFix = t-=(2.625f/2.75f);
+        return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
+    }
+}
+
+EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); } // Ease: Bounce In
+EASEDEF float EaseBounceInOut(float t, float b, float c, float d) // Ease: Bounce In Out
+{
+    if (t < d/2.0f) return (EaseBounceIn(t*2.0f, 0.0f, c, d)*0.5f + b);
+    else return (EaseBounceOut(t*2.0f - d, 0.0f, c, d)*0.5f + c*0.5f + b);
+}
+
+// Elastic Easing functions
+EASEDEF float EaseElasticIn(float t, float b, float c, float d) // Ease: Elastic In
+{
+    if (t == 0.0f) return b;
+    if ((t/=d) == 1.0f) return (b + c);
+
+    float p = d*0.3f;
+    float a = c;
+    float s = p/4.0f;
+    float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
+
+    return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b);
+}
+
+EASEDEF float EaseElasticOut(float t, float b, float c, float d) // Ease: Elastic Out
+{
+    if (t == 0.0f) return b;
+    if ((t/=d) == 1.0f) return (b + c);
+
+    float p = d*0.3f;
+    float a = c;
+    float s = p/4.0f;
+
+    return (a*powf(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b);
+}
+
+EASEDEF float EaseElasticInOut(float t, float b, float c, float d) // Ease: Elastic In Out
+{
+    if (t == 0.0f) return b;
+    if ((t/=d/2.0f) == 2.0f) return (b + c);
+
+    float p = d*(0.3f*1.5f);
+    float a = c;
+    float s = p/4.0f;
+
+    if (t < 1.0f)
+    {
+        float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
+        return -0.5f*(postFix*sinf((t*d-s)*(2.0f*PI)/p)) + b;
+    }
+
+    float postFix = a*powf(2.0f, -10.0f*(t-=1.0f));
+
+    return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // EASINGS_H
+ rlImGui/raylib/src/external/glfw/include/GLFW/glfw3.h view
@@ -0,0 +1,6075 @@+/*************************************************************************
+ * GLFW 3.4 - www.glfw.org
+ * A library for OpenGL, window and input
+ *------------------------------------------------------------------------
+ * Copyright (c) 2002-2006 Marcus Geelnard
+ * Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.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 _glfw3_h_
+#define _glfw3_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************
+ * Doxygen documentation
+ *************************************************************************/
+
+/*! @file glfw3.h
+ *  @brief The header of the GLFW 3 API.
+ *
+ *  This is the header file of the GLFW 3 API.  It defines all its types and
+ *  declares all its functions.
+ *
+ *  For more information about how to use this file, see @ref build_include.
+ */
+/*! @defgroup context Context reference
+ *  @brief Functions and types related to OpenGL and OpenGL ES contexts.
+ *
+ *  This is the reference documentation for OpenGL and OpenGL ES context related
+ *  functions.  For more task-oriented information, see the @ref context_guide.
+ */
+/*! @defgroup vulkan Vulkan support reference
+ *  @brief Functions and types related to Vulkan.
+ *
+ *  This is the reference documentation for Vulkan related functions and types.
+ *  For more task-oriented information, see the @ref vulkan_guide.
+ */
+/*! @defgroup init Initialization, version and error reference
+ *  @brief Functions and types related to initialization and error handling.
+ *
+ *  This is the reference documentation for initialization and termination of
+ *  the library, version management and error handling.  For more task-oriented
+ *  information, see the @ref intro_guide.
+ */
+/*! @defgroup input Input reference
+ *  @brief Functions and types related to input handling.
+ *
+ *  This is the reference documentation for input related functions and types.
+ *  For more task-oriented information, see the @ref input_guide.
+ */
+/*! @defgroup monitor Monitor reference
+ *  @brief Functions and types related to monitors.
+ *
+ *  This is the reference documentation for monitor related functions and types.
+ *  For more task-oriented information, see the @ref monitor_guide.
+ */
+/*! @defgroup window Window reference
+ *  @brief Functions and types related to windows.
+ *
+ *  This is the reference documentation for window related functions and types,
+ *  including creation, deletion and event polling.  For more task-oriented
+ *  information, see the @ref window_guide.
+ */
+
+
+/*************************************************************************
+ * Compiler- and platform-specific preprocessor work
+ *************************************************************************/
+
+/* If we are we on Windows, we want a single define for it.
+ */
+#if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__))
+ #define _WIN32
+#endif /* _WIN32 */
+
+/* Include because most Windows GLU headers need wchar_t and
+ * the macOS OpenGL header blocks the definition of ptrdiff_t by glext.h.
+ * Include it unconditionally to avoid surprising side-effects.
+ */
+#include <stddef.h>
+
+/* Include because it is needed by Vulkan and related functions.
+ * Include it unconditionally to avoid surprising side-effects.
+ */
+#include <stdint.h>
+
+#if defined(GLFW_INCLUDE_VULKAN)
+  #include <vulkan/vulkan.h>
+#endif /* Vulkan header */
+
+/* The Vulkan header may have indirectly included windows.h (because of
+ * VK_USE_PLATFORM_WIN32_KHR) so we offer our replacement symbols after it.
+ */
+
+/* It is customary to use APIENTRY for OpenGL function pointer declarations on
+ * all platforms.  Additionally, the Windows OpenGL header needs APIENTRY.
+ */
+#if !defined(APIENTRY)
+ #if defined(_WIN32)
+  #define APIENTRY __stdcall
+ #else
+  #define APIENTRY
+ #endif
+ #define GLFW_APIENTRY_DEFINED
+#endif /* APIENTRY */
+
+/* Some Windows OpenGL headers need this.
+ */
+#if !defined(WINGDIAPI) && defined(_WIN32)
+ #define WINGDIAPI __declspec(dllimport)
+ #define GLFW_WINGDIAPI_DEFINED
+#endif /* WINGDIAPI */
+
+/* Some Windows GLU headers need this.
+ */
+#if !defined(CALLBACK) && defined(_WIN32)
+ #define CALLBACK __stdcall
+ #define GLFW_CALLBACK_DEFINED
+#endif /* CALLBACK */
+
+/* Include the chosen OpenGL or OpenGL ES headers.
+ */
+#if defined(GLFW_INCLUDE_ES1)
+
+ #include <GLES/gl.h>
+ #if defined(GLFW_INCLUDE_GLEXT)
+  #include <GLES/glext.h>
+ #endif
+
+#elif defined(GLFW_INCLUDE_ES2)
+
+ #include <GLES2/gl2.h>
+ #if defined(GLFW_INCLUDE_GLEXT)
+  #include <GLES2/gl2ext.h>
+ #endif
+
+#elif defined(GLFW_INCLUDE_ES3)
+
+ #include <GLES3/gl3.h>
+ #if defined(GLFW_INCLUDE_GLEXT)
+  #include <GLES2/gl2ext.h>
+ #endif
+
+#elif defined(GLFW_INCLUDE_ES31)
+
+ #include <GLES3/gl31.h>
+ #if defined(GLFW_INCLUDE_GLEXT)
+  #include <GLES2/gl2ext.h>
+ #endif
+
+#elif defined(GLFW_INCLUDE_ES32)
+
+ #include <GLES3/gl32.h>
+ #if defined(GLFW_INCLUDE_GLEXT)
+  #include <GLES2/gl2ext.h>
+ #endif
+
+#elif defined(GLFW_INCLUDE_GLCOREARB)
+
+ #if defined(__APPLE__)
+
+  #include <OpenGL/gl3.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <OpenGL/gl3ext.h>
+  #endif /*GLFW_INCLUDE_GLEXT*/
+
+ #else /*__APPLE__*/
+
+  #include <GL/glcorearb.h>
+
+ #endif /*__APPLE__*/
+
+#elif defined(GLFW_INCLUDE_GLU)
+
+ #if defined(__APPLE__)
+
+  #if defined(GLFW_INCLUDE_GLU)
+   #include <OpenGL/glu.h>
+  #endif
+
+ #else /*__APPLE__*/
+
+  #if defined(GLFW_INCLUDE_GLU)
+   #include <GL/glu.h>
+  #endif
+
+ #endif /*__APPLE__*/
+
+#elif !defined(GLFW_INCLUDE_NONE) && \
+      !defined(__gl_h_) && \
+      !defined(__gles1_gl_h_) && \
+      !defined(__gles2_gl2_h_) && \
+      !defined(__gles2_gl3_h_) && \
+      !defined(__gles2_gl31_h_) && \
+      !defined(__gles2_gl32_h_) && \
+      !defined(__gl_glcorearb_h_) && \
+      !defined(__gl2_h_) /*legacy*/ && \
+      !defined(__gl3_h_) /*legacy*/ && \
+      !defined(__gl31_h_) /*legacy*/ && \
+      !defined(__gl32_h_) /*legacy*/ && \
+      !defined(__glcorearb_h_) /*legacy*/ && \
+      !defined(__GL_H__) /*non-standard*/ && \
+      !defined(__gltypes_h_) /*non-standard*/ && \
+      !defined(__glee_h_) /*non-standard*/
+
+ #if defined(__APPLE__)
+
+  #if !defined(GLFW_INCLUDE_GLEXT)
+   #define GL_GLEXT_LEGACY
+  #endif
+  #include <OpenGL/gl.h>
+
+ #else /*__APPLE__*/
+
+  #include <GL/gl.h>
+  #if defined(GLFW_INCLUDE_GLEXT)
+   #include <GL/glext.h>
+  #endif
+
+ #endif /*__APPLE__*/
+
+#endif /* OpenGL and OpenGL ES headers */
+
+#if defined(GLFW_DLL) && defined(_GLFW_BUILD_DLL)
+ /* GLFW_DLL must be defined by applications that are linking against the DLL
+  * version of the GLFW library.  _GLFW_BUILD_DLL is defined by the GLFW
+  * configuration header when compiling the DLL version of the library.
+  */
+ #error "You must not have both GLFW_DLL and _GLFW_BUILD_DLL defined"
+#endif
+
+/* GLFWAPI is used to declare public API functions for export
+ * from the DLL / shared library / dynamic library.
+ */
+#if defined(_WIN32) && defined(_GLFW_BUILD_DLL)
+ /* We are building GLFW as a Win32 DLL */
+ #define GLFWAPI __declspec(dllexport)
+#elif defined(_WIN32) && defined(GLFW_DLL)
+ /* We are calling GLFW as a Win32 DLL */
+ #define GLFWAPI __declspec(dllimport)
+#elif defined(__GNUC__) && defined(_GLFW_BUILD_DLL)
+ /* We are building GLFW as a shared / dynamic library */
+ #define GLFWAPI __attribute__((visibility("default")))
+#else
+ /* We are building or calling GLFW as a static library */
+ #define GLFWAPI
+#endif
+
+
+/*************************************************************************
+ * GLFW API tokens
+ *************************************************************************/
+
+/*! @name GLFW version macros
+ *  @{ */
+/*! @brief The major version number of the GLFW header.
+ *
+ *  The major version number of the GLFW header.  This is incremented when the
+ *  API is changed in non-compatible ways.
+ *  @ingroup init
+ */
+#define GLFW_VERSION_MAJOR          3
+/*! @brief The minor version number of the GLFW header.
+ *
+ *  The minor version number of the GLFW header.  This is incremented when
+ *  features are added to the API but it remains backward-compatible.
+ *  @ingroup init
+ */
+#define GLFW_VERSION_MINOR          4
+/*! @brief The revision number of the GLFW header.
+ *
+ *  The revision number of the GLFW header.  This is incremented when a bug fix
+ *  release is made that does not contain any API changes.
+ *  @ingroup init
+ */
+#define GLFW_VERSION_REVISION       0
+/*! @} */
+
+/*! @brief One.
+ *
+ *  This is only semantic sugar for the number 1.  You can instead use `1` or
+ *  `true` or `_True` or `GL_TRUE` or `VK_TRUE` or anything else that is equal
+ *  to one.
+ *
+ *  @ingroup init
+ */
+#define GLFW_TRUE                   1
+/*! @brief Zero.
+ *
+ *  This is only semantic sugar for the number 0.  You can instead use `0` or
+ *  `false` or `_False` or `GL_FALSE` or `VK_FALSE` or anything else that is
+ *  equal to zero.
+ *
+ *  @ingroup init
+ */
+#define GLFW_FALSE                  0
+
+/*! @name Key and button actions
+ *  @{ */
+/*! @brief The key or mouse button was released.
+ *
+ *  The key or mouse button was released.
+ *
+ *  @ingroup input
+ */
+#define GLFW_RELEASE                0
+/*! @brief The key or mouse button was pressed.
+ *
+ *  The key or mouse button was pressed.
+ *
+ *  @ingroup input
+ */
+#define GLFW_PRESS                  1
+/*! @brief The key was held down until it repeated.
+ *
+ *  The key was held down until it repeated.
+ *
+ *  @ingroup input
+ */
+#define GLFW_REPEAT                 2
+/*! @} */
+
+/*! @defgroup hat_state Joystick hat states
+ *  @brief Joystick hat states.
+ *
+ *  See [joystick hat input](@ref joystick_hat) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_HAT_CENTERED           0
+#define GLFW_HAT_UP                 1
+#define GLFW_HAT_RIGHT              2
+#define GLFW_HAT_DOWN               4
+#define GLFW_HAT_LEFT               8
+#define GLFW_HAT_RIGHT_UP           (GLFW_HAT_RIGHT | GLFW_HAT_UP)
+#define GLFW_HAT_RIGHT_DOWN         (GLFW_HAT_RIGHT | GLFW_HAT_DOWN)
+#define GLFW_HAT_LEFT_UP            (GLFW_HAT_LEFT  | GLFW_HAT_UP)
+#define GLFW_HAT_LEFT_DOWN          (GLFW_HAT_LEFT  | GLFW_HAT_DOWN)
+/*! @} */
+
+/*! @defgroup keys Keyboard keys
+ *  @brief Keyboard key IDs.
+ *
+ *  See [key input](@ref input_key) for how these are used.
+ *
+ *  These key codes are inspired by the _USB HID Usage Tables v1.12_ (p. 53-60),
+ *  but re-arranged to map to 7-bit ASCII for printable keys (function keys are
+ *  put in the 256+ range).
+ *
+ *  The naming of the key codes follow these rules:
+ *   - The US keyboard layout is used
+ *   - Names of printable alpha-numeric characters are used (e.g. "A", "R",
+ *     "3", etc.)
+ *   - For non-alphanumeric characters, Unicode:ish names are used (e.g.
+ *     "COMMA", "LEFT_SQUARE_BRACKET", etc.). Note that some names do not
+ *     correspond to the Unicode standard (usually for brevity)
+ *   - Keys that lack a clear US mapping are named "WORLD_x"
+ *   - For non-printable keys, custom names are used (e.g. "F4",
+ *     "BACKSPACE", etc.)
+ *
+ *  @ingroup input
+ *  @{
+ */
+
+/* The unknown key */
+#define GLFW_KEY_UNKNOWN            -1
+
+/* Printable keys */
+#define GLFW_KEY_SPACE              32
+#define GLFW_KEY_APOSTROPHE         39  /* ' */
+#define GLFW_KEY_COMMA              44  /* , */
+#define GLFW_KEY_MINUS              45  /* - */
+#define GLFW_KEY_PERIOD             46  /* . */
+#define GLFW_KEY_SLASH              47  /* / */
+#define GLFW_KEY_0                  48
+#define GLFW_KEY_1                  49
+#define GLFW_KEY_2                  50
+#define GLFW_KEY_3                  51
+#define GLFW_KEY_4                  52
+#define GLFW_KEY_5                  53
+#define GLFW_KEY_6                  54
+#define GLFW_KEY_7                  55
+#define GLFW_KEY_8                  56
+#define GLFW_KEY_9                  57
+#define GLFW_KEY_SEMICOLON          59  /* ; */
+#define GLFW_KEY_EQUAL              61  /* = */
+#define GLFW_KEY_A                  65
+#define GLFW_KEY_B                  66
+#define GLFW_KEY_C                  67
+#define GLFW_KEY_D                  68
+#define GLFW_KEY_E                  69
+#define GLFW_KEY_F                  70
+#define GLFW_KEY_G                  71
+#define GLFW_KEY_H                  72
+#define GLFW_KEY_I                  73
+#define GLFW_KEY_J                  74
+#define GLFW_KEY_K                  75
+#define GLFW_KEY_L                  76
+#define GLFW_KEY_M                  77
+#define GLFW_KEY_N                  78
+#define GLFW_KEY_O                  79
+#define GLFW_KEY_P                  80
+#define GLFW_KEY_Q                  81
+#define GLFW_KEY_R                  82
+#define GLFW_KEY_S                  83
+#define GLFW_KEY_T                  84
+#define GLFW_KEY_U                  85
+#define GLFW_KEY_V                  86
+#define GLFW_KEY_W                  87
+#define GLFW_KEY_X                  88
+#define GLFW_KEY_Y                  89
+#define GLFW_KEY_Z                  90
+#define GLFW_KEY_LEFT_BRACKET       91  /* [ */
+#define GLFW_KEY_BACKSLASH          92  /* \ */
+#define GLFW_KEY_RIGHT_BRACKET      93  /* ] */
+#define GLFW_KEY_GRAVE_ACCENT       96  /* ` */
+#define GLFW_KEY_WORLD_1            161 /* non-US #1 */
+#define GLFW_KEY_WORLD_2            162 /* non-US #2 */
+
+/* Function keys */
+#define GLFW_KEY_ESCAPE             256
+#define GLFW_KEY_ENTER              257
+#define GLFW_KEY_TAB                258
+#define GLFW_KEY_BACKSPACE          259
+#define GLFW_KEY_INSERT             260
+#define GLFW_KEY_DELETE             261
+#define GLFW_KEY_RIGHT              262
+#define GLFW_KEY_LEFT               263
+#define GLFW_KEY_DOWN               264
+#define GLFW_KEY_UP                 265
+#define GLFW_KEY_PAGE_UP            266
+#define GLFW_KEY_PAGE_DOWN          267
+#define GLFW_KEY_HOME               268
+#define GLFW_KEY_END                269
+#define GLFW_KEY_CAPS_LOCK          280
+#define GLFW_KEY_SCROLL_LOCK        281
+#define GLFW_KEY_NUM_LOCK           282
+#define GLFW_KEY_PRINT_SCREEN       283
+#define GLFW_KEY_PAUSE              284
+#define GLFW_KEY_F1                 290
+#define GLFW_KEY_F2                 291
+#define GLFW_KEY_F3                 292
+#define GLFW_KEY_F4                 293
+#define GLFW_KEY_F5                 294
+#define GLFW_KEY_F6                 295
+#define GLFW_KEY_F7                 296
+#define GLFW_KEY_F8                 297
+#define GLFW_KEY_F9                 298
+#define GLFW_KEY_F10                299
+#define GLFW_KEY_F11                300
+#define GLFW_KEY_F12                301
+#define GLFW_KEY_F13                302
+#define GLFW_KEY_F14                303
+#define GLFW_KEY_F15                304
+#define GLFW_KEY_F16                305
+#define GLFW_KEY_F17                306
+#define GLFW_KEY_F18                307
+#define GLFW_KEY_F19                308
+#define GLFW_KEY_F20                309
+#define GLFW_KEY_F21                310
+#define GLFW_KEY_F22                311
+#define GLFW_KEY_F23                312
+#define GLFW_KEY_F24                313
+#define GLFW_KEY_F25                314
+#define GLFW_KEY_KP_0               320
+#define GLFW_KEY_KP_1               321
+#define GLFW_KEY_KP_2               322
+#define GLFW_KEY_KP_3               323
+#define GLFW_KEY_KP_4               324
+#define GLFW_KEY_KP_5               325
+#define GLFW_KEY_KP_6               326
+#define GLFW_KEY_KP_7               327
+#define GLFW_KEY_KP_8               328
+#define GLFW_KEY_KP_9               329
+#define GLFW_KEY_KP_DECIMAL         330
+#define GLFW_KEY_KP_DIVIDE          331
+#define GLFW_KEY_KP_MULTIPLY        332
+#define GLFW_KEY_KP_SUBTRACT        333
+#define GLFW_KEY_KP_ADD             334
+#define GLFW_KEY_KP_ENTER           335
+#define GLFW_KEY_KP_EQUAL           336
+#define GLFW_KEY_LEFT_SHIFT         340
+#define GLFW_KEY_LEFT_CONTROL       341
+#define GLFW_KEY_LEFT_ALT           342
+#define GLFW_KEY_LEFT_SUPER         343
+#define GLFW_KEY_RIGHT_SHIFT        344
+#define GLFW_KEY_RIGHT_CONTROL      345
+#define GLFW_KEY_RIGHT_ALT          346
+#define GLFW_KEY_RIGHT_SUPER        347
+#define GLFW_KEY_MENU               348
+
+#define GLFW_KEY_LAST               GLFW_KEY_MENU
+
+/*! @} */
+
+/*! @defgroup mods Modifier key flags
+ *  @brief Modifier key flags.
+ *
+ *  See [key input](@ref input_key) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+
+/*! @brief If this bit is set one or more Shift keys were held down.
+ *
+ *  If this bit is set one or more Shift keys were held down.
+ */
+#define GLFW_MOD_SHIFT           0x0001
+/*! @brief If this bit is set one or more Control keys were held down.
+ *
+ *  If this bit is set one or more Control keys were held down.
+ */
+#define GLFW_MOD_CONTROL         0x0002
+/*! @brief If this bit is set one or more Alt keys were held down.
+ *
+ *  If this bit is set one or more Alt keys were held down.
+ */
+#define GLFW_MOD_ALT             0x0004
+/*! @brief If this bit is set one or more Super keys were held down.
+ *
+ *  If this bit is set one or more Super keys were held down.
+ */
+#define GLFW_MOD_SUPER           0x0008
+/*! @brief If this bit is set the Caps Lock key is enabled.
+ *
+ *  If this bit is set the Caps Lock key is enabled and the @ref
+ *  GLFW_LOCK_KEY_MODS input mode is set.
+ */
+#define GLFW_MOD_CAPS_LOCK       0x0010
+/*! @brief If this bit is set the Num Lock key is enabled.
+ *
+ *  If this bit is set the Num Lock key is enabled and the @ref
+ *  GLFW_LOCK_KEY_MODS input mode is set.
+ */
+#define GLFW_MOD_NUM_LOCK        0x0020
+
+/*! @} */
+
+/*! @defgroup buttons Mouse buttons
+ *  @brief Mouse button IDs.
+ *
+ *  See [mouse button input](@ref input_mouse_button) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_MOUSE_BUTTON_1         0
+#define GLFW_MOUSE_BUTTON_2         1
+#define GLFW_MOUSE_BUTTON_3         2
+#define GLFW_MOUSE_BUTTON_4         3
+#define GLFW_MOUSE_BUTTON_5         4
+#define GLFW_MOUSE_BUTTON_6         5
+#define GLFW_MOUSE_BUTTON_7         6
+#define GLFW_MOUSE_BUTTON_8         7
+#define GLFW_MOUSE_BUTTON_LAST      GLFW_MOUSE_BUTTON_8
+#define GLFW_MOUSE_BUTTON_LEFT      GLFW_MOUSE_BUTTON_1
+#define GLFW_MOUSE_BUTTON_RIGHT     GLFW_MOUSE_BUTTON_2
+#define GLFW_MOUSE_BUTTON_MIDDLE    GLFW_MOUSE_BUTTON_3
+/*! @} */
+
+/*! @defgroup joysticks Joysticks
+ *  @brief Joystick IDs.
+ *
+ *  See [joystick input](@ref joystick) for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_JOYSTICK_1             0
+#define GLFW_JOYSTICK_2             1
+#define GLFW_JOYSTICK_3             2
+#define GLFW_JOYSTICK_4             3
+#define GLFW_JOYSTICK_5             4
+#define GLFW_JOYSTICK_6             5
+#define GLFW_JOYSTICK_7             6
+#define GLFW_JOYSTICK_8             7
+#define GLFW_JOYSTICK_9             8
+#define GLFW_JOYSTICK_10            9
+#define GLFW_JOYSTICK_11            10
+#define GLFW_JOYSTICK_12            11
+#define GLFW_JOYSTICK_13            12
+#define GLFW_JOYSTICK_14            13
+#define GLFW_JOYSTICK_15            14
+#define GLFW_JOYSTICK_16            15
+#define GLFW_JOYSTICK_LAST          GLFW_JOYSTICK_16
+/*! @} */
+
+/*! @defgroup gamepad_buttons Gamepad buttons
+ *  @brief Gamepad buttons.
+ *
+ *  See @ref gamepad for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_GAMEPAD_BUTTON_A               0
+#define GLFW_GAMEPAD_BUTTON_B               1
+#define GLFW_GAMEPAD_BUTTON_X               2
+#define GLFW_GAMEPAD_BUTTON_Y               3
+#define GLFW_GAMEPAD_BUTTON_LEFT_BUMPER     4
+#define GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER    5
+#define GLFW_GAMEPAD_BUTTON_BACK            6
+#define GLFW_GAMEPAD_BUTTON_START           7
+#define GLFW_GAMEPAD_BUTTON_GUIDE           8
+#define GLFW_GAMEPAD_BUTTON_LEFT_THUMB      9
+#define GLFW_GAMEPAD_BUTTON_RIGHT_THUMB     10
+#define GLFW_GAMEPAD_BUTTON_DPAD_UP         11
+#define GLFW_GAMEPAD_BUTTON_DPAD_RIGHT      12
+#define GLFW_GAMEPAD_BUTTON_DPAD_DOWN       13
+#define GLFW_GAMEPAD_BUTTON_DPAD_LEFT       14
+#define GLFW_GAMEPAD_BUTTON_LAST            GLFW_GAMEPAD_BUTTON_DPAD_LEFT
+
+#define GLFW_GAMEPAD_BUTTON_CROSS       GLFW_GAMEPAD_BUTTON_A
+#define GLFW_GAMEPAD_BUTTON_CIRCLE      GLFW_GAMEPAD_BUTTON_B
+#define GLFW_GAMEPAD_BUTTON_SQUARE      GLFW_GAMEPAD_BUTTON_X
+#define GLFW_GAMEPAD_BUTTON_TRIANGLE    GLFW_GAMEPAD_BUTTON_Y
+/*! @} */
+
+/*! @defgroup gamepad_axes Gamepad axes
+ *  @brief Gamepad axes.
+ *
+ *  See @ref gamepad for how these are used.
+ *
+ *  @ingroup input
+ *  @{ */
+#define GLFW_GAMEPAD_AXIS_LEFT_X        0
+#define GLFW_GAMEPAD_AXIS_LEFT_Y        1
+#define GLFW_GAMEPAD_AXIS_RIGHT_X       2
+#define GLFW_GAMEPAD_AXIS_RIGHT_Y       3
+#define GLFW_GAMEPAD_AXIS_LEFT_TRIGGER  4
+#define GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER 5
+#define GLFW_GAMEPAD_AXIS_LAST          GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER
+/*! @} */
+
+/*! @defgroup errors Error codes
+ *  @brief Error codes.
+ *
+ *  See [error handling](@ref error_handling) for how these are used.
+ *
+ *  @ingroup init
+ *  @{ */
+/*! @brief No error has occurred.
+ *
+ *  No error has occurred.
+ *
+ *  @analysis Yay.
+ */
+#define GLFW_NO_ERROR               0
+/*! @brief GLFW has not been initialized.
+ *
+ *  This occurs if a GLFW function was called that must not be called unless the
+ *  library is [initialized](@ref intro_init).
+ *
+ *  @analysis Application programmer error.  Initialize GLFW before calling any
+ *  function that requires initialization.
+ */
+#define GLFW_NOT_INITIALIZED        0x00010001
+/*! @brief No context is current for this thread.
+ *
+ *  This occurs if a GLFW function was called that needs and operates on the
+ *  current OpenGL or OpenGL ES context but no context is current on the calling
+ *  thread.  One such function is @ref glfwSwapInterval.
+ *
+ *  @analysis Application programmer error.  Ensure a context is current before
+ *  calling functions that require a current context.
+ */
+#define GLFW_NO_CURRENT_CONTEXT     0x00010002
+/*! @brief One of the arguments to the function was an invalid enum value.
+ *
+ *  One of the arguments to the function was an invalid enum value, for example
+ *  requesting @ref GLFW_RED_BITS with @ref glfwGetWindowAttrib.
+ *
+ *  @analysis Application programmer error.  Fix the offending call.
+ */
+#define GLFW_INVALID_ENUM           0x00010003
+/*! @brief One of the arguments to the function was an invalid value.
+ *
+ *  One of the arguments to the function was an invalid value, for example
+ *  requesting a non-existent OpenGL or OpenGL ES version like 2.7.
+ *
+ *  Requesting a valid but unavailable OpenGL or OpenGL ES version will instead
+ *  result in a @ref GLFW_VERSION_UNAVAILABLE error.
+ *
+ *  @analysis Application programmer error.  Fix the offending call.
+ */
+#define GLFW_INVALID_VALUE          0x00010004
+/*! @brief A memory allocation failed.
+ *
+ *  A memory allocation failed.
+ *
+ *  @analysis A bug in GLFW or the underlying operating system.  Report the bug
+ *  to our [issue tracker](https://github.com/glfw/glfw/issues).
+ */
+#define GLFW_OUT_OF_MEMORY          0x00010005
+/*! @brief GLFW could not find support for the requested API on the system.
+ *
+ *  GLFW could not find support for the requested API on the system.
+ *
+ *  @analysis The installed graphics driver does not support the requested
+ *  API, or does not support it via the chosen context creation backend.
+ *  Below are a few examples.
+ *
+ *  @par
+ *  Some pre-installed Windows graphics drivers do not support OpenGL.  AMD only
+ *  supports OpenGL ES via EGL, while Nvidia and Intel only support it via
+ *  a WGL or GLX extension.  macOS does not provide OpenGL ES at all.  The Mesa
+ *  EGL, OpenGL and OpenGL ES libraries do not interface with the Nvidia binary
+ *  driver.  Older graphics drivers do not support Vulkan.
+ */
+#define GLFW_API_UNAVAILABLE        0x00010006
+/*! @brief The requested OpenGL or OpenGL ES version is not available.
+ *
+ *  The requested OpenGL or OpenGL ES version (including any requested context
+ *  or framebuffer hints) is not available on this machine.
+ *
+ *  @analysis The machine does not support your requirements.  If your
+ *  application is sufficiently flexible, downgrade your requirements and try
+ *  again.  Otherwise, inform the user that their machine does not match your
+ *  requirements.
+ *
+ *  @par
+ *  Future invalid OpenGL and OpenGL ES versions, for example OpenGL 4.8 if 5.0
+ *  comes out before the 4.x series gets that far, also fail with this error and
+ *  not @ref GLFW_INVALID_VALUE, because GLFW cannot know what future versions
+ *  will exist.
+ */
+#define GLFW_VERSION_UNAVAILABLE    0x00010007
+/*! @brief A platform-specific error occurred that does not match any of the
+ *  more specific categories.
+ *
+ *  A platform-specific error occurred that does not match any of the more
+ *  specific categories.
+ *
+ *  @analysis A bug or configuration error in GLFW, the underlying operating
+ *  system or its drivers, or a lack of required resources.  Report the issue to
+ *  our [issue tracker](https://github.com/glfw/glfw/issues).
+ */
+#define GLFW_PLATFORM_ERROR         0x00010008
+/*! @brief The requested format is not supported or available.
+ *
+ *  If emitted during window creation, the requested pixel format is not
+ *  supported.
+ *
+ *  If emitted when querying the clipboard, the contents of the clipboard could
+ *  not be converted to the requested format.
+ *
+ *  @analysis If emitted during window creation, one or more
+ *  [hard constraints](@ref window_hints_hard) did not match any of the
+ *  available pixel formats.  If your application is sufficiently flexible,
+ *  downgrade your requirements and try again.  Otherwise, inform the user that
+ *  their machine does not match your requirements.
+ *
+ *  @par
+ *  If emitted when querying the clipboard, ignore the error or report it to
+ *  the user, as appropriate.
+ */
+#define GLFW_FORMAT_UNAVAILABLE     0x00010009
+/*! @brief The specified window does not have an OpenGL or OpenGL ES context.
+ *
+ *  A window that does not have an OpenGL or OpenGL ES context was passed to
+ *  a function that requires it to have one.
+ *
+ *  @analysis Application programmer error.  Fix the offending call.
+ */
+#define GLFW_NO_WINDOW_CONTEXT      0x0001000A
+/*! @brief The specified cursor shape is not available.
+ *
+ *  The specified standard cursor shape is not available, either because the
+ *  current system cursor theme does not provide it or because it is not
+ *  available on the platform.
+ *
+ *  @analysis Platform or system settings limitation.  Pick another
+ *  [standard cursor shape](@ref shapes) or create a
+ *  [custom cursor](@ref cursor_custom).
+ */
+#define GLFW_CURSOR_UNAVAILABLE     0x0001000B
+/*! @brief The requested feature is not provided by the platform.
+ *
+ *  The requested feature is not provided by the platform, so GLFW is unable to
+ *  implement it.  The documentation for each function notes if it could emit
+ *  this error.
+ *
+ *  @analysis Platform or platform version limitation.  The error can be ignored
+ *  unless the feature is critical to the application.
+ *
+ *  @par
+ *  A function call that emits this error has no effect other than the error and
+ *  updating any existing out parameters.
+ */
+#define GLFW_FEATURE_UNAVAILABLE    0x0001000C
+/*! @brief The requested feature is not implemented for the platform.
+ *
+ *  The requested feature has not yet been implemented in GLFW for this platform.
+ *
+ *  @analysis An incomplete implementation of GLFW for this platform, hopefully
+ *  fixed in a future release.  The error can be ignored unless the feature is
+ *  critical to the application.
+ *
+ *  @par
+ *  A function call that emits this error has no effect other than the error and
+ *  updating any existing out parameters.
+ */
+#define GLFW_FEATURE_UNIMPLEMENTED  0x0001000D
+/*! @} */
+
+/*! @addtogroup window
+ *  @{ */
+/*! @brief Input focus window hint and attribute
+ *
+ *  Input focus [window hint](@ref GLFW_FOCUSED_hint) or
+ *  [window attribute](@ref GLFW_FOCUSED_attrib).
+ */
+#define GLFW_FOCUSED                0x00020001
+/*! @brief Window iconification window attribute
+ *
+ *  Window iconification [window attribute](@ref GLFW_ICONIFIED_attrib).
+ */
+#define GLFW_ICONIFIED              0x00020002
+/*! @brief Window resize-ability window hint and attribute
+ *
+ *  Window resize-ability [window hint](@ref GLFW_RESIZABLE_hint) and
+ *  [window attribute](@ref GLFW_RESIZABLE_attrib).
+ */
+#define GLFW_RESIZABLE              0x00020003
+/*! @brief Window visibility window hint and attribute
+ *
+ *  Window visibility [window hint](@ref GLFW_VISIBLE_hint) and
+ *  [window attribute](@ref GLFW_VISIBLE_attrib).
+ */
+#define GLFW_VISIBLE                0x00020004
+/*! @brief Window decoration window hint and attribute
+ *
+ *  Window decoration [window hint](@ref GLFW_DECORATED_hint) and
+ *  [window attribute](@ref GLFW_DECORATED_attrib).
+ */
+#define GLFW_DECORATED              0x00020005
+/*! @brief Window auto-iconification window hint and attribute
+ *
+ *  Window auto-iconification [window hint](@ref GLFW_AUTO_ICONIFY_hint) and
+ *  [window attribute](@ref GLFW_AUTO_ICONIFY_attrib).
+ */
+#define GLFW_AUTO_ICONIFY           0x00020006
+/*! @brief Window decoration window hint and attribute
+ *
+ *  Window decoration [window hint](@ref GLFW_FLOATING_hint) and
+ *  [window attribute](@ref GLFW_FLOATING_attrib).
+ */
+#define GLFW_FLOATING               0x00020007
+/*! @brief Window maximization window hint and attribute
+ *
+ *  Window maximization [window hint](@ref GLFW_MAXIMIZED_hint) and
+ *  [window attribute](@ref GLFW_MAXIMIZED_attrib).
+ */
+#define GLFW_MAXIMIZED              0x00020008
+/*! @brief Cursor centering window hint
+ *
+ *  Cursor centering [window hint](@ref GLFW_CENTER_CURSOR_hint).
+ */
+#define GLFW_CENTER_CURSOR          0x00020009
+/*! @brief Window framebuffer transparency hint and attribute
+ *
+ *  Window framebuffer transparency
+ *  [window hint](@ref GLFW_TRANSPARENT_FRAMEBUFFER_hint) and
+ *  [window attribute](@ref GLFW_TRANSPARENT_FRAMEBUFFER_attrib).
+ */
+#define GLFW_TRANSPARENT_FRAMEBUFFER 0x0002000A
+/*! @brief Mouse cursor hover window attribute.
+ *
+ *  Mouse cursor hover [window attribute](@ref GLFW_HOVERED_attrib).
+ */
+#define GLFW_HOVERED                0x0002000B
+/*! @brief Input focus on calling show window hint and attribute
+ *
+ *  Input focus [window hint](@ref GLFW_FOCUS_ON_SHOW_hint) or
+ *  [window attribute](@ref GLFW_FOCUS_ON_SHOW_attrib).
+ */
+#define GLFW_FOCUS_ON_SHOW          0x0002000C
+
+/*! @brief Mouse input transparency window hint and attribute
+ *
+ *  Mouse input transparency [window hint](@ref GLFW_MOUSE_PASSTHROUGH_hint) or
+ *  [window attribute](@ref GLFW_MOUSE_PASSTHROUGH_attrib).
+ */
+#define GLFW_MOUSE_PASSTHROUGH      0x0002000D
+
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_RED_BITS).
+ */
+#define GLFW_RED_BITS               0x00021001
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_GREEN_BITS).
+ */
+#define GLFW_GREEN_BITS             0x00021002
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_BLUE_BITS).
+ */
+#define GLFW_BLUE_BITS              0x00021003
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_ALPHA_BITS).
+ */
+#define GLFW_ALPHA_BITS             0x00021004
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_DEPTH_BITS).
+ */
+#define GLFW_DEPTH_BITS             0x00021005
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_STENCIL_BITS).
+ */
+#define GLFW_STENCIL_BITS           0x00021006
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_ACCUM_RED_BITS).
+ */
+#define GLFW_ACCUM_RED_BITS         0x00021007
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_ACCUM_GREEN_BITS).
+ */
+#define GLFW_ACCUM_GREEN_BITS       0x00021008
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_ACCUM_BLUE_BITS).
+ */
+#define GLFW_ACCUM_BLUE_BITS        0x00021009
+/*! @brief Framebuffer bit depth hint.
+ *
+ *  Framebuffer bit depth [hint](@ref GLFW_ACCUM_ALPHA_BITS).
+ */
+#define GLFW_ACCUM_ALPHA_BITS       0x0002100A
+/*! @brief Framebuffer auxiliary buffer hint.
+ *
+ *  Framebuffer auxiliary buffer [hint](@ref GLFW_AUX_BUFFERS).
+ */
+#define GLFW_AUX_BUFFERS            0x0002100B
+/*! @brief OpenGL stereoscopic rendering hint.
+ *
+ *  OpenGL stereoscopic rendering [hint](@ref GLFW_STEREO).
+ */
+#define GLFW_STEREO                 0x0002100C
+/*! @brief Framebuffer MSAA samples hint.
+ *
+ *  Framebuffer MSAA samples [hint](@ref GLFW_SAMPLES).
+ */
+#define GLFW_SAMPLES                0x0002100D
+/*! @brief Framebuffer sRGB hint.
+ *
+ *  Framebuffer sRGB [hint](@ref GLFW_SRGB_CAPABLE).
+ */
+#define GLFW_SRGB_CAPABLE           0x0002100E
+/*! @brief Monitor refresh rate hint.
+ *
+ *  Monitor refresh rate [hint](@ref GLFW_REFRESH_RATE).
+ */
+#define GLFW_REFRESH_RATE           0x0002100F
+/*! @brief Framebuffer double buffering hint and attribute.
+ *
+ *  Framebuffer double buffering [hint](@ref GLFW_DOUBLEBUFFER_hint) and
+ *  [attribute](@ref GLFW_DOUBLEBUFFER_attrib).
+ */
+#define GLFW_DOUBLEBUFFER           0x00021010
+
+/*! @brief Context client API hint and attribute.
+ *
+ *  Context client API [hint](@ref GLFW_CLIENT_API_hint) and
+ *  [attribute](@ref GLFW_CLIENT_API_attrib).
+ */
+#define GLFW_CLIENT_API             0x00022001
+/*! @brief Context client API major version hint and attribute.
+ *
+ *  Context client API major version [hint](@ref GLFW_CONTEXT_VERSION_MAJOR_hint)
+ *  and [attribute](@ref GLFW_CONTEXT_VERSION_MAJOR_attrib).
+ */
+#define GLFW_CONTEXT_VERSION_MAJOR  0x00022002
+/*! @brief Context client API minor version hint and attribute.
+ *
+ *  Context client API minor version [hint](@ref GLFW_CONTEXT_VERSION_MINOR_hint)
+ *  and [attribute](@ref GLFW_CONTEXT_VERSION_MINOR_attrib).
+ */
+#define GLFW_CONTEXT_VERSION_MINOR  0x00022003
+/*! @brief Context client API revision number hint and attribute.
+ *
+ *  Context client API revision number
+ *  [attribute](@ref GLFW_CONTEXT_REVISION_attrib).
+ */
+#define GLFW_CONTEXT_REVISION       0x00022004
+/*! @brief Context robustness hint and attribute.
+ *
+ *  Context client API revision number [hint](@ref GLFW_CONTEXT_ROBUSTNESS_hint)
+ *  and [attribute](@ref GLFW_CONTEXT_ROBUSTNESS_attrib).
+ */
+#define GLFW_CONTEXT_ROBUSTNESS     0x00022005
+/*! @brief OpenGL forward-compatibility hint and attribute.
+ *
+ *  OpenGL forward-compatibility [hint](@ref GLFW_OPENGL_FORWARD_COMPAT_hint)
+ *  and [attribute](@ref GLFW_OPENGL_FORWARD_COMPAT_attrib).
+ */
+#define GLFW_OPENGL_FORWARD_COMPAT  0x00022006
+/*! @brief Debug mode context hint and attribute.
+ *
+ *  Debug mode context [hint](@ref GLFW_CONTEXT_DEBUG_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_DEBUG_attrib).
+ */
+#define GLFW_CONTEXT_DEBUG          0x00022007
+/*! @brief Legacy name for compatibility.
+ *
+ *  This is an alias for compatibility with earlier versions.
+ */
+#define GLFW_OPENGL_DEBUG_CONTEXT   GLFW_CONTEXT_DEBUG
+/*! @brief OpenGL profile hint and attribute.
+ *
+ *  OpenGL profile [hint](@ref GLFW_OPENGL_PROFILE_hint) and
+ *  [attribute](@ref GLFW_OPENGL_PROFILE_attrib).
+ */
+#define GLFW_OPENGL_PROFILE         0x00022008
+/*! @brief Context flush-on-release hint and attribute.
+ *
+ *  Context flush-on-release [hint](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_attrib).
+ */
+#define GLFW_CONTEXT_RELEASE_BEHAVIOR 0x00022009
+/*! @brief Context error suppression hint and attribute.
+ *
+ *  Context error suppression [hint](@ref GLFW_CONTEXT_NO_ERROR_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_NO_ERROR_attrib).
+ */
+#define GLFW_CONTEXT_NO_ERROR       0x0002200A
+/*! @brief Context creation API hint and attribute.
+ *
+ *  Context creation API [hint](@ref GLFW_CONTEXT_CREATION_API_hint) and
+ *  [attribute](@ref GLFW_CONTEXT_CREATION_API_attrib).
+ */
+#define GLFW_CONTEXT_CREATION_API   0x0002200B
+/*! @brief Window content area scaling window
+ *  [window hint](@ref GLFW_SCALE_TO_MONITOR).
+ */
+#define GLFW_SCALE_TO_MONITOR       0x0002200C
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_RETINA_FRAMEBUFFER_hint).
+ */
+#define GLFW_COCOA_RETINA_FRAMEBUFFER 0x00023001
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_FRAME_NAME_hint).
+ */
+#define GLFW_COCOA_FRAME_NAME         0x00023002
+/*! @brief macOS specific
+ *  [window hint](@ref GLFW_COCOA_GRAPHICS_SWITCHING_hint).
+ */
+#define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003
+/*! @brief X11 specific
+ *  [window hint](@ref GLFW_X11_CLASS_NAME_hint).
+ */
+#define GLFW_X11_CLASS_NAME         0x00024001
+/*! @brief X11 specific
+ *  [window hint](@ref GLFW_X11_CLASS_NAME_hint).
+ */
+#define GLFW_X11_INSTANCE_NAME      0x00024002
+#define GLFW_WIN32_KEYBOARD_MENU    0x00025001
+/*! @} */
+
+#define GLFW_NO_API                          0
+#define GLFW_OPENGL_API             0x00030001
+#define GLFW_OPENGL_ES_API          0x00030002
+
+#define GLFW_NO_ROBUSTNESS                   0
+#define GLFW_NO_RESET_NOTIFICATION  0x00031001
+#define GLFW_LOSE_CONTEXT_ON_RESET  0x00031002
+
+#define GLFW_OPENGL_ANY_PROFILE              0
+#define GLFW_OPENGL_CORE_PROFILE    0x00032001
+#define GLFW_OPENGL_COMPAT_PROFILE  0x00032002
+
+#define GLFW_CURSOR                 0x00033001
+#define GLFW_STICKY_KEYS            0x00033002
+#define GLFW_STICKY_MOUSE_BUTTONS   0x00033003
+#define GLFW_LOCK_KEY_MODS          0x00033004
+#define GLFW_RAW_MOUSE_MOTION       0x00033005
+
+#define GLFW_CURSOR_NORMAL          0x00034001
+#define GLFW_CURSOR_HIDDEN          0x00034002
+#define GLFW_CURSOR_DISABLED        0x00034003
+
+#define GLFW_ANY_RELEASE_BEHAVIOR            0
+#define GLFW_RELEASE_BEHAVIOR_FLUSH 0x00035001
+#define GLFW_RELEASE_BEHAVIOR_NONE  0x00035002
+
+#define GLFW_NATIVE_CONTEXT_API     0x00036001
+#define GLFW_EGL_CONTEXT_API        0x00036002
+#define GLFW_OSMESA_CONTEXT_API     0x00036003
+
+#define GLFW_ANGLE_PLATFORM_TYPE_NONE    0x00037001
+#define GLFW_ANGLE_PLATFORM_TYPE_OPENGL  0x00037002
+#define GLFW_ANGLE_PLATFORM_TYPE_OPENGLES 0x00037003
+#define GLFW_ANGLE_PLATFORM_TYPE_D3D9    0x00037004
+#define GLFW_ANGLE_PLATFORM_TYPE_D3D11   0x00037005
+#define GLFW_ANGLE_PLATFORM_TYPE_VULKAN  0x00037007
+#define GLFW_ANGLE_PLATFORM_TYPE_METAL   0x00037008
+
+/*! @defgroup shapes Standard cursor shapes
+ *  @brief Standard system cursor shapes.
+ *
+ *  These are the [standard cursor shapes](@ref cursor_standard) that can be
+ *  requested from the window system.
+ *
+ *  @ingroup input
+ *  @{ */
+
+/*! @brief The regular arrow cursor shape.
+ *
+ *  The regular arrow cursor shape.
+ */
+#define GLFW_ARROW_CURSOR           0x00036001
+/*! @brief The text input I-beam cursor shape.
+ *
+ *  The text input I-beam cursor shape.
+ */
+#define GLFW_IBEAM_CURSOR           0x00036002
+/*! @brief The crosshair cursor shape.
+ *
+ *  The crosshair cursor shape.
+ */
+#define GLFW_CROSSHAIR_CURSOR       0x00036003
+/*! @brief The pointing hand cursor shape.
+ *
+ *  The pointing hand cursor shape.
+ */
+#define GLFW_POINTING_HAND_CURSOR   0x00036004
+/*! @brief The horizontal resize/move arrow shape.
+ *
+ *  The horizontal resize/move arrow shape.  This is usually a horizontal
+ *  double-headed arrow.
+ */
+#define GLFW_RESIZE_EW_CURSOR       0x00036005
+/*! @brief The vertical resize/move arrow shape.
+ *
+ *  The vertical resize/move shape.  This is usually a vertical double-headed
+ *  arrow.
+ */
+#define GLFW_RESIZE_NS_CURSOR       0x00036006
+/*! @brief The top-left to bottom-right diagonal resize/move arrow shape.
+ *
+ *  The top-left to bottom-right diagonal resize/move shape.  This is usually
+ *  a diagonal double-headed arrow.
+ *
+ *  @note @macos This shape is provided by a private system API and may fail
+ *  with @ref GLFW_CURSOR_UNAVAILABLE in the future.
+ *
+ *  @note @x11 This shape is provided by a newer standard not supported by all
+ *  cursor themes.
+ *
+ *  @note @wayland This shape is provided by a newer standard not supported by
+ *  all cursor themes.
+ */
+#define GLFW_RESIZE_NWSE_CURSOR     0x00036007
+/*! @brief The top-right to bottom-left diagonal resize/move arrow shape.
+ *
+ *  The top-right to bottom-left diagonal resize/move shape.  This is usually
+ *  a diagonal double-headed arrow.
+ *
+ *  @note @macos This shape is provided by a private system API and may fail
+ *  with @ref GLFW_CURSOR_UNAVAILABLE in the future.
+ *
+ *  @note @x11 This shape is provided by a newer standard not supported by all
+ *  cursor themes.
+ *
+ *  @note @wayland This shape is provided by a newer standard not supported by
+ *  all cursor themes.
+ */
+#define GLFW_RESIZE_NESW_CURSOR     0x00036008
+/*! @brief The omni-directional resize/move cursor shape.
+ *
+ *  The omni-directional resize cursor/move shape.  This is usually either
+ *  a combined horizontal and vertical double-headed arrow or a grabbing hand.
+ */
+#define GLFW_RESIZE_ALL_CURSOR      0x00036009
+/*! @brief The operation-not-allowed shape.
+ *
+ *  The operation-not-allowed shape.  This is usually a circle with a diagonal
+ *  line through it.
+ *
+ *  @note @x11 This shape is provided by a newer standard not supported by all
+ *  cursor themes.
+ *
+ *  @note @wayland This shape is provided by a newer standard not supported by
+ *  all cursor themes.
+ */
+#define GLFW_NOT_ALLOWED_CURSOR     0x0003600A
+/*! @brief Legacy name for compatibility.
+ *
+ *  This is an alias for compatibility with earlier versions.
+ */
+#define GLFW_HRESIZE_CURSOR         GLFW_RESIZE_EW_CURSOR
+/*! @brief Legacy name for compatibility.
+ *
+ *  This is an alias for compatibility with earlier versions.
+ */
+#define GLFW_VRESIZE_CURSOR         GLFW_RESIZE_NS_CURSOR
+/*! @brief Legacy name for compatibility.
+ *
+ *  This is an alias for compatibility with earlier versions.
+ */
+#define GLFW_HAND_CURSOR            GLFW_POINTING_HAND_CURSOR
+/*! @} */
+
+#define GLFW_CONNECTED              0x00040001
+#define GLFW_DISCONNECTED           0x00040002
+
+/*! @addtogroup init
+ *  @{ */
+/*! @brief Joystick hat buttons init hint.
+ *
+ *  Joystick hat buttons [init hint](@ref GLFW_JOYSTICK_HAT_BUTTONS).
+ */
+#define GLFW_JOYSTICK_HAT_BUTTONS   0x00050001
+/*! @brief ANGLE rendering backend init hint.
+ *
+ *  ANGLE rendering backend [init hint](@ref GLFW_ANGLE_PLATFORM_TYPE_hint).
+ */
+#define GLFW_ANGLE_PLATFORM_TYPE    0x00050002
+/*! @brief macOS specific init hint.
+ *
+ *  macOS specific [init hint](@ref GLFW_COCOA_CHDIR_RESOURCES_hint).
+ */
+#define GLFW_COCOA_CHDIR_RESOURCES  0x00051001
+/*! @brief macOS specific init hint.
+ *
+ *  macOS specific [init hint](@ref GLFW_COCOA_MENUBAR_hint).
+ */
+#define GLFW_COCOA_MENUBAR          0x00051002
+/*! @brief X11 specific init hint.
+ *
+ *  X11 specific [init hint](@ref GLFW_X11_XCB_VULKAN_SURFACE_hint).
+ */
+#define GLFW_X11_XCB_VULKAN_SURFACE 0x00052001
+/*! @} */
+
+#define GLFW_DONT_CARE              -1
+
+
+/*************************************************************************
+ * GLFW API types
+ *************************************************************************/
+
+/*! @brief Client API function pointer type.
+ *
+ *  Generic function pointer used for returning client API function pointers
+ *  without forcing a cast from a regular pointer.
+ *
+ *  @sa @ref context_glext
+ *  @sa @ref glfwGetProcAddress
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup context
+ */
+typedef void (*GLFWglproc)(void);
+
+/*! @brief Vulkan API function pointer type.
+ *
+ *  Generic function pointer used for returning Vulkan API function pointers
+ *  without forcing a cast from a regular pointer.
+ *
+ *  @sa @ref vulkan_proc
+ *  @sa @ref glfwGetInstanceProcAddress
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+typedef void (*GLFWvkproc)(void);
+
+/*! @brief Opaque monitor object.
+ *
+ *  Opaque monitor object.
+ *
+ *  @see @ref monitor_object
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+typedef struct GLFWmonitor GLFWmonitor;
+
+/*! @brief Opaque window object.
+ *
+ *  Opaque window object.
+ *
+ *  @see @ref window_object
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef struct GLFWwindow GLFWwindow;
+
+/*! @brief Opaque cursor object.
+ *
+ *  Opaque cursor object.
+ *
+ *  @see @ref cursor_object
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+typedef struct GLFWcursor GLFWcursor;
+
+/*! @brief The function pointer type for error callbacks.
+ *
+ *  This is the function pointer type for error callbacks.  An error callback
+ *  function has the following signature:
+ *  @code
+ *  void callback_name(int error_code, const char* description)
+ *  @endcode
+ *
+ *  @param[in] error_code An [error code](@ref errors).  Future releases may add
+ *  more error codes.
+ *  @param[in] description A UTF-8 encoded string describing the error.
+ *
+ *  @pointer_lifetime The error description string is valid until the callback
+ *  function returns.
+ *
+ *  @sa @ref error_handling
+ *  @sa @ref glfwSetErrorCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup init
+ */
+typedef void (* GLFWerrorfun)(int,const char*);
+
+/*! @brief The function pointer type for window position callbacks.
+ *
+ *  This is the function pointer type for window position callbacks.  A window
+ *  position callback function has the following signature:
+ *  @code
+ *  void callback_name(GLFWwindow* window, int xpos, int ypos)
+ *  @endcode
+ *
+ *  @param[in] window The window that was moved.
+ *  @param[in] xpos The new x-coordinate, in screen coordinates, of the
+ *  upper-left corner of the content area of the window.
+ *  @param[in] ypos The new y-coordinate, in screen coordinates, of the
+ *  upper-left corner of the content area of the window.
+ *
+ *  @sa @ref window_pos
+ *  @sa @ref glfwSetWindowPosCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowposfun)(GLFWwindow*,int,int);
+
+/*! @brief The function pointer type for window size callbacks.
+ *
+ *  This is the function pointer type for window size callbacks.  A window size
+ *  callback function has the following signature:
+ *  @code
+ *  void callback_name(GLFWwindow* window, int width, int height)
+ *  @endcode
+ *
+ *  @param[in] window The window that was resized.
+ *  @param[in] width The new width, in screen coordinates, of the window.
+ *  @param[in] height The new height, in screen coordinates, of the window.
+ *
+ *  @sa @ref window_size
+ *  @sa @ref glfwSetWindowSizeCallback
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowsizefun)(GLFWwindow*,int,int);
+
+/*! @brief The function pointer type for window close callbacks.
+ *
+ *  This is the function pointer type for window close callbacks.  A window
+ *  close callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window)
+ *  @endcode
+ *
+ *  @param[in] window The window that the user attempted to close.
+ *
+ *  @sa @ref window_close
+ *  @sa @ref glfwSetWindowCloseCallback
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowclosefun)(GLFWwindow*);
+
+/*! @brief The function pointer type for window content refresh callbacks.
+ *
+ *  This is the function pointer type for window content refresh callbacks.
+ *  A window content refresh callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window);
+ *  @endcode
+ *
+ *  @param[in] window The window whose content needs to be refreshed.
+ *
+ *  @sa @ref window_refresh
+ *  @sa @ref glfwSetWindowRefreshCallback
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowrefreshfun)(GLFWwindow*);
+
+/*! @brief The function pointer type for window focus callbacks.
+ *
+ *  This is the function pointer type for window focus callbacks.  A window
+ *  focus callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int focused)
+ *  @endcode
+ *
+ *  @param[in] window The window that gained or lost input focus.
+ *  @param[in] focused `GLFW_TRUE` if the window was given input focus, or
+ *  `GLFW_FALSE` if it lost it.
+ *
+ *  @sa @ref window_focus
+ *  @sa @ref glfwSetWindowFocusCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowfocusfun)(GLFWwindow*,int);
+
+/*! @brief The function pointer type for window iconify callbacks.
+ *
+ *  This is the function pointer type for window iconify callbacks.  A window
+ *  iconify callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int iconified)
+ *  @endcode
+ *
+ *  @param[in] window The window that was iconified or restored.
+ *  @param[in] iconified `GLFW_TRUE` if the window was iconified, or
+ *  `GLFW_FALSE` if it was restored.
+ *
+ *  @sa @ref window_iconify
+ *  @sa @ref glfwSetWindowIconifyCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowiconifyfun)(GLFWwindow*,int);
+
+/*! @brief The function pointer type for window maximize callbacks.
+ *
+ *  This is the function pointer type for window maximize callbacks.  A window
+ *  maximize callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int maximized)
+ *  @endcode
+ *
+ *  @param[in] window The window that was maximized or restored.
+ *  @param[in] maximized `GLFW_TRUE` if the window was maximized, or
+ *  `GLFW_FALSE` if it was restored.
+ *
+ *  @sa @ref window_maximize
+ *  @sa glfwSetWindowMaximizeCallback
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowmaximizefun)(GLFWwindow*,int);
+
+/*! @brief The function pointer type for framebuffer size callbacks.
+ *
+ *  This is the function pointer type for framebuffer size callbacks.
+ *  A framebuffer size callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int width, int height)
+ *  @endcode
+ *
+ *  @param[in] window The window whose framebuffer was resized.
+ *  @param[in] width The new width, in pixels, of the framebuffer.
+ *  @param[in] height The new height, in pixels, of the framebuffer.
+ *
+ *  @sa @ref window_fbsize
+ *  @sa @ref glfwSetFramebufferSizeCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWframebuffersizefun)(GLFWwindow*,int,int);
+
+/*! @brief The function pointer type for window content scale callbacks.
+ *
+ *  This is the function pointer type for window content scale callbacks.
+ *  A window content scale callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, float xscale, float yscale)
+ *  @endcode
+ *
+ *  @param[in] window The window whose content scale changed.
+ *  @param[in] xscale The new x-axis content scale of the window.
+ *  @param[in] yscale The new y-axis content scale of the window.
+ *
+ *  @sa @ref window_scale
+ *  @sa @ref glfwSetWindowContentScaleCallback
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+typedef void (* GLFWwindowcontentscalefun)(GLFWwindow*,float,float);
+
+/*! @brief The function pointer type for mouse button callbacks.
+ *
+ *  This is the function pointer type for mouse button callback functions.
+ *  A mouse button callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int button, int action, int mods)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] button The [mouse button](@ref buttons) that was pressed or
+ *  released.
+ *  @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`.  Future releases
+ *  may add more actions.
+ *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+ *  held down.
+ *
+ *  @sa @ref input_mouse_button
+ *  @sa @ref glfwSetMouseButtonCallback
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle and modifier mask parameters.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
+
+/*! @brief The function pointer type for cursor position callbacks.
+ *
+ *  This is the function pointer type for cursor position callbacks.  A cursor
+ *  position callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, double xpos, double ypos);
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] xpos The new cursor x-coordinate, relative to the left edge of
+ *  the content area.
+ *  @param[in] ypos The new cursor y-coordinate, relative to the top edge of the
+ *  content area.
+ *
+ *  @sa @ref cursor_pos
+ *  @sa @ref glfwSetCursorPosCallback
+ *
+ *  @since Added in version 3.0.  Replaces `GLFWmouseposfun`.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcursorposfun)(GLFWwindow*,double,double);
+
+/*! @brief The function pointer type for cursor enter/leave callbacks.
+ *
+ *  This is the function pointer type for cursor enter/leave callbacks.
+ *  A cursor enter/leave callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int entered)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] entered `GLFW_TRUE` if the cursor entered the window's content
+ *  area, or `GLFW_FALSE` if it left it.
+ *
+ *  @sa @ref cursor_enter
+ *  @sa @ref glfwSetCursorEnterCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcursorenterfun)(GLFWwindow*,int);
+
+/*! @brief The function pointer type for scroll callbacks.
+ *
+ *  This is the function pointer type for scroll callbacks.  A scroll callback
+ *  function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, double xoffset, double yoffset)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] xoffset The scroll offset along the x-axis.
+ *  @param[in] yoffset The scroll offset along the y-axis.
+ *
+ *  @sa @ref scrolling
+ *  @sa @ref glfwSetScrollCallback
+ *
+ *  @since Added in version 3.0.  Replaces `GLFWmousewheelfun`.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWscrollfun)(GLFWwindow*,double,double);
+
+/*! @brief The function pointer type for keyboard key callbacks.
+ *
+ *  This is the function pointer type for keyboard key callbacks.  A keyboard
+ *  key callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int key, int scancode, int action, int mods)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] key The [keyboard key](@ref keys) that was pressed or released.
+ *  @param[in] scancode The system-specific scancode of the key.
+ *  @param[in] action `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`.  Future
+ *  releases may add more actions.
+ *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+ *  held down.
+ *
+ *  @sa @ref input_key
+ *  @sa @ref glfwSetKeyCallback
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle, scancode and modifier mask parameters.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWkeyfun)(GLFWwindow*,int,int,int,int);
+
+/*! @brief The function pointer type for Unicode character callbacks.
+ *
+ *  This is the function pointer type for Unicode character callbacks.
+ *  A Unicode character callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, unsigned int codepoint)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] codepoint The Unicode code point of the character.
+ *
+ *  @sa @ref input_char
+ *  @sa @ref glfwSetCharCallback
+ *
+ *  @since Added in version 2.4.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcharfun)(GLFWwindow*,unsigned int);
+
+/*! @brief The function pointer type for Unicode character with modifiers
+ *  callbacks.
+ *
+ *  This is the function pointer type for Unicode character with modifiers
+ *  callbacks.  It is called for each input character, regardless of what
+ *  modifier keys are held down.  A Unicode character with modifiers callback
+ *  function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, unsigned int codepoint, int mods)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] codepoint The Unicode code point of the character.
+ *  @param[in] mods Bit field describing which [modifier keys](@ref mods) were
+ *  held down.
+ *
+ *  @sa @ref input_char
+ *  @sa @ref glfwSetCharModsCallback
+ *
+ *  @deprecated Scheduled for removal in version 4.0.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcharmodsfun)(GLFWwindow*,unsigned int,int);
+
+/*! @brief The function pointer type for path drop callbacks.
+ *
+ *  This is the function pointer type for path drop callbacks.  A path drop
+ *  callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, int path_count, const char* paths[])
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] path_count The number of dropped paths.
+ *  @param[in] paths The UTF-8 encoded file and/or directory path names.
+ *
+ *  @pointer_lifetime The path array and its strings are valid until the
+ *  callback function returns.
+ *
+ *  @sa @ref path_drop
+ *  @sa @ref glfwSetDropCallback
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWdropfun)(GLFWwindow*,int,const char*[]);
+
+/*! @brief The function pointer type for monitor configuration callbacks.
+ *
+ *  This is the function pointer type for monitor configuration callbacks.
+ *  A monitor callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWmonitor* monitor, int event)
+ *  @endcode
+ *
+ *  @param[in] monitor The monitor that was connected or disconnected.
+ *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.  Future
+ *  releases may add more events.
+ *
+ *  @sa @ref monitor_event
+ *  @sa @ref glfwSetMonitorCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+typedef void (* GLFWmonitorfun)(GLFWmonitor*,int);
+
+/*! @brief The function pointer type for joystick configuration callbacks.
+ *
+ *  This is the function pointer type for joystick configuration callbacks.
+ *  A joystick configuration callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int event)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that was connected or disconnected.
+ *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.  Future
+ *  releases may add more events.
+ *
+ *  @sa @ref joystick_event
+ *  @sa @ref glfwSetJoystickCallback
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickfun)(int,int);
+
+/*! @brief Video mode type.
+ *
+ *  This describes a single video mode.
+ *
+ *  @sa @ref monitor_modes
+ *  @sa @ref glfwGetVideoMode
+ *  @sa @ref glfwGetVideoModes
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added refresh rate member.
+ *
+ *  @ingroup monitor
+ */
+typedef struct GLFWvidmode
+{
+    /*! The width, in screen coordinates, of the video mode.
+     */
+    int width;
+    /*! The height, in screen coordinates, of the video mode.
+     */
+    int height;
+    /*! The bit depth of the red channel of the video mode.
+     */
+    int redBits;
+    /*! The bit depth of the green channel of the video mode.
+     */
+    int greenBits;
+    /*! The bit depth of the blue channel of the video mode.
+     */
+    int blueBits;
+    /*! The refresh rate, in Hz, of the video mode.
+     */
+    int refreshRate;
+} GLFWvidmode;
+
+/*! @brief Gamma ramp.
+ *
+ *  This describes the gamma ramp for a monitor.
+ *
+ *  @sa @ref monitor_gamma
+ *  @sa @ref glfwGetGammaRamp
+ *  @sa @ref glfwSetGammaRamp
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+typedef struct GLFWgammaramp
+{
+    /*! An array of value describing the response of the red channel.
+     */
+    unsigned short* red;
+    /*! An array of value describing the response of the green channel.
+     */
+    unsigned short* green;
+    /*! An array of value describing the response of the blue channel.
+     */
+    unsigned short* blue;
+    /*! The number of elements in each array.
+     */
+    unsigned int size;
+} GLFWgammaramp;
+
+/*! @brief Image data.
+ *
+ *  This describes a single 2D image.  See the documentation for each related
+ *  function what the expected pixel format is.
+ *
+ *  @sa @ref cursor_custom
+ *  @sa @ref window_icon
+ *
+ *  @since Added in version 2.1.
+ *  @glfw3 Removed format and bytes-per-pixel members.
+ *
+ *  @ingroup window
+ */
+typedef struct GLFWimage
+{
+    /*! The width, in pixels, of this image.
+     */
+    int width;
+    /*! The height, in pixels, of this image.
+     */
+    int height;
+    /*! The pixel data of this image, arranged left-to-right, top-to-bottom.
+     */
+    unsigned char* pixels;
+} GLFWimage;
+
+/*! @brief Gamepad input state
+ *
+ *  This describes the input state of a gamepad.
+ *
+ *  @sa @ref gamepad
+ *  @sa @ref glfwGetGamepadState
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+typedef struct GLFWgamepadstate
+{
+    /*! The states of each [gamepad button](@ref gamepad_buttons), `GLFW_PRESS`
+     *  or `GLFW_RELEASE`.
+     */
+    unsigned char buttons[15];
+    /*! The states of each [gamepad axis](@ref gamepad_axes), in the range -1.0
+     *  to 1.0 inclusive.
+     */
+    float axes[6];
+} GLFWgamepadstate;
+
+
+/*************************************************************************
+ * GLFW API functions
+ *************************************************************************/
+
+/*! @brief Initializes the GLFW library.
+ *
+ *  This function initializes the GLFW library.  Before most GLFW functions can
+ *  be used, GLFW must be initialized, and before an application terminates GLFW
+ *  should be terminated in order to free any resources allocated during or
+ *  after initialization.
+ *
+ *  If this function fails, it calls @ref glfwTerminate before returning.  If it
+ *  succeeds, you should call @ref glfwTerminate before the application exits.
+ *
+ *  Additional calls to this function after successful initialization but before
+ *  termination will return `GLFW_TRUE` immediately.
+ *
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @macos This function will change the current directory of the
+ *  application to the `Contents/Resources` subdirectory of the application's
+ *  bundle, if present.  This can be disabled with the @ref
+ *  GLFW_COCOA_CHDIR_RESOURCES init hint.
+ *
+ *  @remark @macos This function will create the main menu and dock icon for the
+ *  application.  If GLFW finds a `MainMenu.nib` it is loaded and assumed to
+ *  contain a menu bar.  Otherwise a minimal menu bar is created manually with
+ *  common commands like Hide, Quit and About.  The About entry opens a minimal
+ *  about dialog with information from the application's bundle.  The menu bar
+ *  and dock icon can be disabled entirely with the @ref GLFW_COCOA_MENUBAR init
+ *  hint.
+ *
+ *  @remark @x11 This function will set the `LC_CTYPE` category of the
+ *  application locale according to the current environment if that category is
+ *  still "C".  This is because the "C" locale breaks Unicode text input.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref intro_init
+ *  @sa @ref glfwTerminate
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI int glfwInit(void);
+
+/*! @brief Terminates the GLFW library.
+ *
+ *  This function destroys all remaining windows and cursors, restores any
+ *  modified gamma ramps and frees any other allocated resources.  Once this
+ *  function is called, you must again call @ref glfwInit successfully before
+ *  you will be able to use most GLFW functions.
+ *
+ *  If GLFW has been successfully initialized, this function should be called
+ *  before the application exits.  If initialization fails, there is no need to
+ *  call this function, as it is called by @ref glfwInit before it returns
+ *  failure.
+ *
+ *  This function has no effect if GLFW is not initialized.
+ *
+ *  @errors Possible errors include @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @warning The contexts of any remaining windows must not be current on any
+ *  other thread when this function is called.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref intro_init
+ *  @sa @ref glfwInit
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI void glfwTerminate(void);
+
+/*! @brief Sets the specified init hint to the desired value.
+ *
+ *  This function sets hints for the next initialization of GLFW.
+ *
+ *  The values you set hints to are never reset by GLFW, but they only take
+ *  effect during initialization.  Once GLFW has been initialized, any values
+ *  you set will be ignored until the library is terminated and initialized
+ *  again.
+ *
+ *  Some hints are platform specific.  These may be set on any platform but they
+ *  will only affect their specific platform.  Other platforms will ignore them.
+ *  Setting these hints requires no platform specific headers or functions.
+ *
+ *  @param[in] hint The [init hint](@ref init_hints) to set.
+ *  @param[in] value The new value of the init hint.
+ *
+ *  @errors Possible errors include @ref GLFW_INVALID_ENUM and @ref
+ *  GLFW_INVALID_VALUE.
+ *
+ *  @remarks This function may be called before @ref glfwInit.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa init_hints
+ *  @sa glfwInit
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup init
+ */
+GLFWAPI void glfwInitHint(int hint, int value);
+
+/*! @brief Retrieves the version of the GLFW library.
+ *
+ *  This function retrieves the major, minor and revision numbers of the GLFW
+ *  library.  It is intended for when you are using GLFW as a shared library and
+ *  want to ensure that you are using the minimum required version.
+ *
+ *  Any or all of the version arguments may be `NULL`.
+ *
+ *  @param[out] major Where to store the major version number, or `NULL`.
+ *  @param[out] minor Where to store the minor version number, or `NULL`.
+ *  @param[out] rev Where to store the revision number, or `NULL`.
+ *
+ *  @errors None.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref intro_version
+ *  @sa @ref glfwGetVersionString
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev);
+
+/*! @brief Returns a string describing the compile-time configuration.
+ *
+ *  This function returns the compile-time generated
+ *  [version string](@ref intro_version_string) of the GLFW library binary.  It
+ *  describes the version, platform, compiler and any platform-specific
+ *  compile-time options.  It should not be confused with the OpenGL or OpenGL
+ *  ES version string, queried with `glGetString`.
+ *
+ *  __Do not use the version string__ to parse the GLFW library version.  The
+ *  @ref glfwGetVersion function provides the version of the running library
+ *  binary in numerical format.
+ *
+ *  @return The ASCII encoded GLFW version string.
+ *
+ *  @errors None.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @pointer_lifetime The returned string is static and compile-time generated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref intro_version
+ *  @sa @ref glfwGetVersion
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI const char* glfwGetVersionString(void);
+
+/*! @brief Returns and clears the last error for the calling thread.
+ *
+ *  This function returns and clears the [error code](@ref errors) of the last
+ *  error that occurred on the calling thread, and optionally a UTF-8 encoded
+ *  human-readable description of it.  If no error has occurred since the last
+ *  call, it returns @ref GLFW_NO_ERROR (zero) and the description pointer is
+ *  set to `NULL`.
+ *
+ *  @param[in] description Where to store the error description pointer, or `NULL`.
+ *  @return The last error code for the calling thread, or @ref GLFW_NO_ERROR
+ *  (zero).
+ *
+ *  @errors None.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is guaranteed to be valid only until the
+ *  next error occurs or the library is terminated.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref error_handling
+ *  @sa @ref glfwSetErrorCallback
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup init
+ */
+GLFWAPI int glfwGetError(const char** description);
+
+/*! @brief Sets the error callback.
+ *
+ *  This function sets the error callback, which is called with an error code
+ *  and a human-readable description each time a GLFW error occurs.
+ *
+ *  The error code is set before the callback is called.  Calling @ref
+ *  glfwGetError from the error callback will return the same value as the error
+ *  code argument.
+ *
+ *  The error callback is called on the thread where the error occurred.  If you
+ *  are using GLFW from multiple threads, your error callback needs to be
+ *  written accordingly.
+ *
+ *  Because the description string may have been generated specifically for that
+ *  error, it is not guaranteed to be valid after the callback has returned.  If
+ *  you wish to use it after the callback returns, you need to make a copy.
+ *
+ *  Once set, the error callback remains set even after the library has been
+ *  terminated.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set.
+ *
+ *  @callback_signature
+ *  @code
+ *  void callback_name(int error_code, const char* description)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [callback pointer type](@ref GLFWerrorfun).
+ *
+ *  @errors None.
+ *
+ *  @remark This function may be called before @ref glfwInit.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref error_handling
+ *  @sa @ref glfwGetError
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup init
+ */
+GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun callback);
+
+/*! @brief Returns the currently connected monitors.
+ *
+ *  This function returns an array of handles for all currently connected
+ *  monitors.  The primary monitor is always first in the returned array.  If no
+ *  monitors were found, this function returns `NULL`.
+ *
+ *  @param[out] count Where to store the number of monitors in the returned
+ *  array.  This is set to zero if an error occurred.
+ *  @return An array of monitor handles, or `NULL` if no monitors were found or
+ *  if an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is guaranteed to be valid only until the
+ *  monitor configuration changes or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_monitors
+ *  @sa @ref monitor_event
+ *  @sa @ref glfwGetPrimaryMonitor
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI GLFWmonitor** glfwGetMonitors(int* count);
+
+/*! @brief Returns the primary monitor.
+ *
+ *  This function returns the primary monitor.  This is usually the monitor
+ *  where elements like the task bar or global menu bar are located.
+ *
+ *  @return The primary monitor, or `NULL` if no monitors were found or if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @remark The primary monitor is always first in the array returned by @ref
+ *  glfwGetMonitors.
+ *
+ *  @sa @ref monitor_monitors
+ *  @sa @ref glfwGetMonitors
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void);
+
+/*! @brief Returns the position of the monitor's viewport on the virtual screen.
+ *
+ *  This function returns the position, in screen coordinates, of the upper-left
+ *  corner of the specified monitor.
+ *
+ *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position arguments will be set to zero.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] xpos Where to store the monitor x-coordinate, or `NULL`.
+ *  @param[out] ypos Where to store the monitor y-coordinate, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_properties
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos);
+
+/*! @brief Retrieves the work area of the monitor.
+ *
+ *  This function returns the position, in screen coordinates, of the upper-left
+ *  corner of the work area of the specified monitor along with the work area
+ *  size in screen coordinates. The work area is defined as the area of the
+ *  monitor not occluded by the operating system task bar where present. If no
+ *  task bar exists then the work area is the monitor resolution in screen
+ *  coordinates.
+ *
+ *  Any or all of the position and size arguments may be `NULL`.  If an error
+ *  occurs, all non-`NULL` position and size arguments will be set to zero.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] xpos Where to store the monitor x-coordinate, or `NULL`.
+ *  @param[out] ypos Where to store the monitor y-coordinate, or `NULL`.
+ *  @param[out] width Where to store the monitor width, or `NULL`.
+ *  @param[out] height Where to store the monitor height, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_workarea
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height);
+
+/*! @brief Returns the physical size of the monitor.
+ *
+ *  This function returns the size, in millimetres, of the display area of the
+ *  specified monitor.
+ *
+ *  Some systems do not provide accurate monitor size information, either
+ *  because the monitor
+ *  [EDID](https://en.wikipedia.org/wiki/Extended_display_identification_data)
+ *  data is incorrect or because the driver does not report it accurately.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] widthMM Where to store the width, in millimetres, of the
+ *  monitor's display area, or `NULL`.
+ *  @param[out] heightMM Where to store the height, in millimetres, of the
+ *  monitor's display area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @remark @win32 calculates the returned physical size from the
+ *  current resolution and system DPI instead of querying the monitor EDID data.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_properties
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int* heightMM);
+
+/*! @brief Retrieves the content scale for the specified monitor.
+ *
+ *  This function retrieves the content scale for the specified monitor.  The
+ *  content scale is the ratio between the current DPI and the platform's
+ *  default DPI.  This is especially important for text and any UI elements.  If
+ *  the pixel dimensions of your UI scaled by this look appropriate on your
+ *  machine then it should appear at a reasonable size on other machines
+ *  regardless of their DPI and scaling settings.  This relies on the system DPI
+ *  and scaling settings being somewhat correct.
+ *
+ *  The content scale may depend on both the monitor resolution and pixel
+ *  density and on user settings.  It may be very different from the raw DPI
+ *  calculated from the physical size and current resolution.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] xscale Where to store the x-axis content scale, or `NULL`.
+ *  @param[out] yscale Where to store the y-axis content scale, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_scale
+ *  @sa @ref glfwGetWindowContentScale
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* monitor, float* xscale, float* yscale);
+
+/*! @brief Returns the name of the specified monitor.
+ *
+ *  This function returns a human-readable name, encoded as UTF-8, of the
+ *  specified monitor.  The name typically reflects the make and model of the
+ *  monitor and is not guaranteed to be unique among the connected monitors.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @return The UTF-8 encoded name of the monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified monitor is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_properties
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* monitor);
+
+/*! @brief Sets the user pointer of the specified monitor.
+ *
+ *  This function sets the user-defined pointer of the specified monitor.  The
+ *  current value is retained until the monitor is disconnected.  The initial
+ *  value is `NULL`.
+ *
+ *  This function may be called from the monitor callback, even for a monitor
+ *  that is being disconnected.
+ *
+ *  @param[in] monitor The monitor whose pointer to set.
+ *  @param[in] pointer The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref monitor_userptr
+ *  @sa @ref glfwGetMonitorUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwSetMonitorUserPointer(GLFWmonitor* monitor, void* pointer);
+
+/*! @brief Returns the user pointer of the specified monitor.
+ *
+ *  This function returns the current value of the user-defined pointer of the
+ *  specified monitor.  The initial value is `NULL`.
+ *
+ *  This function may be called from the monitor callback, even for a monitor
+ *  that is being disconnected.
+ *
+ *  @param[in] monitor The monitor whose pointer to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref monitor_userptr
+ *  @sa @ref glfwSetMonitorUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void* glfwGetMonitorUserPointer(GLFWmonitor* monitor);
+
+/*! @brief Sets the monitor configuration callback.
+ *
+ *  This function sets the monitor configuration callback, or removes the
+ *  currently set callback.  This is called when a monitor is connected to or
+ *  disconnected from the system.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWmonitor* monitor, int event)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWmonitorfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_event
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun callback);
+
+/*! @brief Returns the available video modes for the specified monitor.
+ *
+ *  This function returns an array of all video modes supported by the specified
+ *  monitor.  The returned array is sorted in ascending order, first by color
+ *  bit depth (the sum of all channel depths), then by resolution area (the
+ *  product of width and height), then resolution width and finally by refresh
+ *  rate.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @param[out] count Where to store the number of video modes in the returned
+ *  array.  This is set to zero if an error occurred.
+ *  @return An array of video modes, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified monitor is
+ *  disconnected, this function is called again for that monitor or the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_modes
+ *  @sa @ref glfwGetVideoMode
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Changed to return an array of modes for a specific monitor.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* monitor, int* count);
+
+/*! @brief Returns the current mode of the specified monitor.
+ *
+ *  This function returns the current video mode of the specified monitor.  If
+ *  you have created a full screen window for that monitor, the return value
+ *  will depend on whether that window is iconified.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @return The current mode of the monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified monitor is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_modes
+ *  @sa @ref glfwGetVideoModes
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetDesktopMode`.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
+
+/*! @brief Generates a gamma ramp and sets it for the specified monitor.
+ *
+ *  This function generates an appropriately sized gamma ramp from the specified
+ *  exponent and then calls @ref glfwSetGammaRamp with it.  The value must be
+ *  a finite number greater than zero.
+ *
+ *  The software controlled gamma ramp is applied _in addition_ to the hardware
+ *  gamma correction, which today is usually an approximation of sRGB gamma.
+ *  This means that setting a perfectly linear ramp, or gamma 1.0, will produce
+ *  the default (usually sRGB-like) behavior.
+ *
+ *  For gamma correct rendering with OpenGL or OpenGL ES, see the @ref
+ *  GLFW_SRGB_CAPABLE hint.
+ *
+ *  @param[in] monitor The monitor whose gamma ramp to set.
+ *  @param[in] gamma The desired exponent.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  will thus never be implemented and emits @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_gamma
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);
+
+/*! @brief Returns the current gamma ramp for the specified monitor.
+ *
+ *  This function returns the current gamma ramp of the specified monitor.
+ *
+ *  @param[in] monitor The monitor to query.
+ *  @return The current gamma ramp, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  will thus never be implemented and emits @ref GLFW_PLATFORM_ERROR while
+ *  returning `NULL`.
+ *
+ *  @pointer_lifetime The returned structure and its arrays are allocated and
+ *  freed by GLFW.  You should not free them yourself.  They are valid until the
+ *  specified monitor is disconnected, this function is called again for that
+ *  monitor or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_gamma
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
+
+/*! @brief Sets the current gamma ramp for the specified monitor.
+ *
+ *  This function sets the current gamma ramp for the specified monitor.  The
+ *  original gamma ramp for that monitor is saved by GLFW the first time this
+ *  function is called and is restored by @ref glfwTerminate.
+ *
+ *  The software controlled gamma ramp is applied _in addition_ to the hardware
+ *  gamma correction, which today is usually an approximation of sRGB gamma.
+ *  This means that setting a perfectly linear ramp, or gamma 1.0, will produce
+ *  the default (usually sRGB-like) behavior.
+ *
+ *  For gamma correct rendering with OpenGL or OpenGL ES, see the @ref
+ *  GLFW_SRGB_CAPABLE hint.
+ *
+ *  @param[in] monitor The monitor whose gamma ramp to set.
+ *  @param[in] ramp The gamma ramp to use.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark The size of the specified gamma ramp should match the size of the
+ *  current ramp for that monitor.
+ *
+ *  @remark @win32 The gamma ramp size must be 256.
+ *
+ *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  will thus never be implemented and emits @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified gamma ramp is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref monitor_gamma
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup monitor
+ */
+GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp);
+
+/*! @brief Resets all window hints to their default values.
+ *
+ *  This function resets all window hints to their
+ *  [default values](@ref window_hints_values).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hints
+ *  @sa @ref glfwWindowHint
+ *  @sa @ref glfwWindowHintString
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwDefaultWindowHints(void);
+
+/*! @brief Sets the specified window hint to the desired value.
+ *
+ *  This function sets hints for the next call to @ref glfwCreateWindow.  The
+ *  hints, once set, retain their values until changed by a call to this
+ *  function or @ref glfwDefaultWindowHints, or until the library is terminated.
+ *
+ *  Only integer value hints can be set with this function.  String value hints
+ *  are set with @ref glfwWindowHintString.
+ *
+ *  This function does not check whether the specified hint values are valid.
+ *  If you set hints to invalid values this will instead be reported by the next
+ *  call to @ref glfwCreateWindow.
+ *
+ *  Some hints are platform specific.  These may be set on any platform but they
+ *  will only affect their specific platform.  Other platforms will ignore them.
+ *  Setting these hints requires no platform specific headers or functions.
+ *
+ *  @param[in] hint The [window hint](@ref window_hints) to set.
+ *  @param[in] value The new value of the window hint.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hints
+ *  @sa @ref glfwWindowHintString
+ *  @sa @ref glfwDefaultWindowHints
+ *
+ *  @since Added in version 3.0.  Replaces `glfwOpenWindowHint`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWindowHint(int hint, int value);
+
+/*! @brief Sets the specified window hint to the desired value.
+ *
+ *  This function sets hints for the next call to @ref glfwCreateWindow.  The
+ *  hints, once set, retain their values until changed by a call to this
+ *  function or @ref glfwDefaultWindowHints, or until the library is terminated.
+ *
+ *  Only string type hints can be set with this function.  Integer value hints
+ *  are set with @ref glfwWindowHint.
+ *
+ *  This function does not check whether the specified hint values are valid.
+ *  If you set hints to invalid values this will instead be reported by the next
+ *  call to @ref glfwCreateWindow.
+ *
+ *  Some hints are platform specific.  These may be set on any platform but they
+ *  will only affect their specific platform.  Other platforms will ignore them.
+ *  Setting these hints requires no platform specific headers or functions.
+ *
+ *  @param[in] hint The [window hint](@ref window_hints) to set.
+ *  @param[in] value The new value of the window hint.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @pointer_lifetime The specified string is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hints
+ *  @sa @ref glfwWindowHint
+ *  @sa @ref glfwDefaultWindowHints
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWindowHintString(int hint, const char* value);
+
+/*! @brief Creates a window and its associated context.
+ *
+ *  This function creates a window and its associated OpenGL or OpenGL ES
+ *  context.  Most of the options controlling how the window and its context
+ *  should be created are specified with [window hints](@ref window_hints).
+ *
+ *  Successful creation does not change which context is current.  Before you
+ *  can use the newly created context, you need to
+ *  [make it current](@ref context_current).  For information about the `share`
+ *  parameter, see @ref context_sharing.
+ *
+ *  The created window, framebuffer and context may differ from what you
+ *  requested, as not all parameters and hints are
+ *  [hard constraints](@ref window_hints_hard).  This includes the size of the
+ *  window, especially for full screen windows.  To query the actual attributes
+ *  of the created window, framebuffer and context, see @ref
+ *  glfwGetWindowAttrib, @ref glfwGetWindowSize and @ref glfwGetFramebufferSize.
+ *
+ *  To create a full screen window, you need to specify the monitor the window
+ *  will cover.  If no monitor is specified, the window will be windowed mode.
+ *  Unless you have a way for the user to choose a specific monitor, it is
+ *  recommended that you pick the primary monitor.  For more information on how
+ *  to query connected monitors, see @ref monitor_monitors.
+ *
+ *  For full screen windows, the specified size becomes the resolution of the
+ *  window's _desired video mode_.  As long as a full screen window is not
+ *  iconified, the supported video mode most closely matching the desired video
+ *  mode is set for the specified monitor.  For more information about full
+ *  screen windows, including the creation of so called _windowed full screen_
+ *  or _borderless full screen_ windows, see @ref window_windowed_full_screen.
+ *
+ *  Once you have created the window, you can switch it between windowed and
+ *  full screen mode with @ref glfwSetWindowMonitor.  This will not affect its
+ *  OpenGL or OpenGL ES context.
+ *
+ *  By default, newly created windows use the placement recommended by the
+ *  window system.  To create the window at a specific position, make it
+ *  initially invisible using the [GLFW_VISIBLE](@ref GLFW_VISIBLE_hint) window
+ *  hint, set its [position](@ref window_pos) and then [show](@ref window_hide)
+ *  it.
+ *
+ *  As long as at least one full screen window is not iconified, the screensaver
+ *  is prohibited from starting.
+ *
+ *  Window systems put limits on window sizes.  Very large or very small window
+ *  dimensions may be overridden by the window system on creation.  Check the
+ *  actual [size](@ref window_size) after creation.
+ *
+ *  The [swap interval](@ref buffer_swap) is not set during window creation and
+ *  the initial value may vary depending on driver settings and defaults.
+ *
+ *  @param[in] width The desired width, in screen coordinates, of the window.
+ *  This must be greater than zero.
+ *  @param[in] height The desired height, in screen coordinates, of the window.
+ *  This must be greater than zero.
+ *  @param[in] title The initial, UTF-8 encoded window title.
+ *  @param[in] monitor The monitor to use for full screen mode, or `NULL` for
+ *  windowed mode.
+ *  @param[in] share The window whose context to share resources with, or `NULL`
+ *  to not share resources.
+ *  @return The handle of the created window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE, @ref GLFW_API_UNAVAILABLE, @ref
+ *  GLFW_VERSION_UNAVAILABLE, @ref GLFW_FORMAT_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @win32 Window creation will fail if the Microsoft GDI software
+ *  OpenGL implementation is the only one available.
+ *
+ *  @remark @win32 If the executable has an icon resource named `GLFW_ICON,` it
+ *  will be set as the initial icon for the window.  If no such icon is present,
+ *  the `IDI_APPLICATION` icon will be used instead.  To set a different icon,
+ *  see @ref glfwSetWindowIcon.
+ *
+ *  @remark @win32 The context to share resources with must not be current on
+ *  any other thread.
+ *
+ *  @remark @macos The OS only supports core profile contexts for OpenGL
+ *  versions 3.2 and later.  Before creating an OpenGL context of version 3.2 or
+ *  later you must set the [GLFW_OPENGL_PROFILE](@ref GLFW_OPENGL_PROFILE_hint)
+ *  hint accordingly.  OpenGL 3.0 and 3.1 contexts are not supported at all
+ *  on macOS.
+ *
+ *  @remark @macos The GLFW window has no icon, as it is not a document
+ *  window, but the dock icon will be the same as the application bundle's icon.
+ *  For more information on bundles, see the
+ *  [Bundle Programming Guide](https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/)
+ *  in the Mac Developer Library.
+ *
+ *  @remark @macos On OS X 10.10 and later the window frame will not be rendered
+ *  at full resolution on Retina displays unless the
+ *  [GLFW_COCOA_RETINA_FRAMEBUFFER](@ref GLFW_COCOA_RETINA_FRAMEBUFFER_hint)
+ *  hint is `GLFW_TRUE` and the `NSHighResolutionCapable` key is enabled in the
+ *  application bundle's `Info.plist`.  For more information, see
+ *  [High Resolution Guidelines for OS X](https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html)
+ *  in the Mac Developer Library.  The GLFW test and example programs use
+ *  a custom `Info.plist` template for this, which can be found as
+ *  `CMake/Info.plist.in` in the source tree.
+ *
+ *  @remark @macos When activating frame autosaving with
+ *  [GLFW_COCOA_FRAME_NAME](@ref GLFW_COCOA_FRAME_NAME_hint), the specified
+ *  window size and position may be overridden by previously saved values.
+ *
+ *  @remark @x11 Some window managers will not respect the placement of
+ *  initially hidden windows.
+ *
+ *  @remark @x11 Due to the asynchronous nature of X11, it may take a moment for
+ *  a window to reach its requested state.  This means you may not be able to
+ *  query the final size, position or other attributes directly after window
+ *  creation.
+ *
+ *  @remark @x11 The class part of the `WM_CLASS` window property will by
+ *  default be set to the window title passed to this function.  The instance
+ *  part will use the contents of the `RESOURCE_NAME` environment variable, if
+ *  present and not empty, or fall back to the window title.  Set the
+ *  [GLFW_X11_CLASS_NAME](@ref GLFW_X11_CLASS_NAME_hint) and
+ *  [GLFW_X11_INSTANCE_NAME](@ref GLFW_X11_INSTANCE_NAME_hint) window hints to
+ *  override this.
+ *
+ *  @remark @wayland Compositors should implement the xdg-decoration protocol
+ *  for GLFW to decorate the window properly.  If this protocol isn't
+ *  supported, or if the compositor prefers client-side decorations, a very
+ *  simple fallback frame will be drawn using the wp_viewporter protocol.  A
+ *  compositor can still emit close, maximize or fullscreen events, using for
+ *  instance a keybind mechanism.  If neither of these protocols is supported,
+ *  the window won't be decorated.
+ *
+ *  @remark @wayland A full screen window will not attempt to change the mode,
+ *  no matter what the requested size or refresh rate.
+ *
+ *  @remark @wayland Screensaver inhibition requires the idle-inhibit protocol
+ *  to be implemented in the user's compositor.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_creation
+ *  @sa @ref glfwDestroyWindow
+ *
+ *  @since Added in version 3.0.  Replaces `glfwOpenWindow`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share);
+
+/*! @brief Destroys the specified window and its context.
+ *
+ *  This function destroys the specified window and its context.  On calling
+ *  this function, no further callbacks will be called for that window.
+ *
+ *  If the context of the specified window is current on the main thread, it is
+ *  detached before being destroyed.
+ *
+ *  @param[in] window The window to destroy.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @note The context of the specified window must not be current on any other
+ *  thread when this function is called.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_creation
+ *  @sa @ref glfwCreateWindow
+ *
+ *  @since Added in version 3.0.  Replaces `glfwCloseWindow`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwDestroyWindow(GLFWwindow* window);
+
+/*! @brief Checks the close flag of the specified window.
+ *
+ *  This function returns the value of the close flag of the specified window.
+ *
+ *  @param[in] window The window to query.
+ *  @return The value of the close flag.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_close
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI int glfwWindowShouldClose(GLFWwindow* window);
+
+/*! @brief Sets the close flag of the specified window.
+ *
+ *  This function sets the value of the close flag of the specified window.
+ *  This can be used to override the user's attempt to close the window, or
+ *  to signal that it should be closed.
+ *
+ *  @param[in] window The window whose flag to change.
+ *  @param[in] value The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_close
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* window, int value);
+
+/*! @brief Sets the title of the specified window.
+ *
+ *  This function sets the window title, encoded as UTF-8, of the specified
+ *  window.
+ *
+ *  @param[in] window The window whose title to change.
+ *  @param[in] title The UTF-8 encoded window title.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @macos The window title will not be updated until the next time you
+ *  process events.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_title
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title);
+
+/*! @brief Sets the icon for the specified window.
+ *
+ *  This function sets the icon of the specified window.  If passed an array of
+ *  candidate images, those of or closest to the sizes desired by the system are
+ *  selected.  If no images are specified, the window reverts to its default
+ *  icon.
+ *
+ *  The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight
+ *  bits per channel with the red channel first.  They are arranged canonically
+ *  as packed sequential rows, starting from the top-left corner.
+ *
+ *  The desired image sizes varies depending on platform and system settings.
+ *  The selected images will be rescaled as needed.  Good sizes include 16x16,
+ *  32x32 and 48x48.
+ *
+ *  @param[in] window The window whose icon to set.
+ *  @param[in] count The number of images in the specified array, or zero to
+ *  revert to the default window icon.
+ *  @param[in] images The images to create the icon from.  This is ignored if
+ *  count is zero.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
+ *
+ *  @pointer_lifetime The specified image data is copied before this function
+ *  returns.
+ *
+ *  @remark @macos Regular windows do not have icons on macOS.  This function
+ *  will emit @ref GLFW_FEATURE_UNAVAILABLE.  The dock icon will be the same as
+ *  the application bundle's icon.  For more information on bundles, see the
+ *  [Bundle Programming Guide](https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/)
+ *  in the Mac Developer Library.
+ *
+ *  @remark @wayland There is no existing protocol to change an icon, the
+ *  window will thus inherit the one defined in the application's desktop file.
+ *  This function will emit @ref GLFW_FEATURE_UNAVAILABLE.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_icon
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images);
+
+/*! @brief Retrieves the position of the content area of the specified window.
+ *
+ *  This function retrieves the position, in screen coordinates, of the
+ *  upper-left corner of the content area of the specified window.
+ *
+ *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position arguments will be set to zero.
+ *
+ *  @param[in] window The window to query.
+ *  @param[out] xpos Where to store the x-coordinate of the upper-left corner of
+ *  the content area, or `NULL`.
+ *  @param[out] ypos Where to store the y-coordinate of the upper-left corner of
+ *  the content area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
+ *
+ *  @remark @wayland There is no way for an application to retrieve the global
+ *  position of its windows.  This function will emit @ref
+ *  GLFW_FEATURE_UNAVAILABLE.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_pos
+ *  @sa @ref glfwSetWindowPos
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
+
+/*! @brief Sets the position of the content area of the specified window.
+ *
+ *  This function sets the position, in screen coordinates, of the upper-left
+ *  corner of the content area of the specified windowed mode window.  If the
+ *  window is a full screen window, this function does nothing.
+ *
+ *  __Do not use this function__ to move an already visible window unless you
+ *  have very good reasons for doing so, as it will confuse and annoy the user.
+ *
+ *  The window manager may put limits on what positions are allowed.  GLFW
+ *  cannot and should not override these limits.
+ *
+ *  @param[in] window The window to query.
+ *  @param[in] xpos The x-coordinate of the upper-left corner of the content area.
+ *  @param[in] ypos The y-coordinate of the upper-left corner of the content area.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
+ *
+ *  @remark @wayland There is no way for an application to set the global
+ *  position of its windows.  This function will emit @ref
+ *  GLFW_FEATURE_UNAVAILABLE.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_pos
+ *  @sa @ref glfwGetWindowPos
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
+
+/*! @brief Retrieves the size of the content area of the specified window.
+ *
+ *  This function retrieves the size, in screen coordinates, of the content area
+ *  of the specified window.  If you wish to retrieve the size of the
+ *  framebuffer of the window in pixels, see @ref glfwGetFramebufferSize.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] window The window whose size to retrieve.
+ *  @param[out] width Where to store the width, in screen coordinates, of the
+ *  content area, or `NULL`.
+ *  @param[out] height Where to store the height, in screen coordinates, of the
+ *  content area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *  @sa @ref glfwSetWindowSize
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height);
+
+/*! @brief Sets the size limits of the specified window.
+ *
+ *  This function sets the size limits of the content area of the specified
+ *  window.  If the window is full screen, the size limits only take effect
+ *  once it is made windowed.  If the window is not resizable, this function
+ *  does nothing.
+ *
+ *  The size limits are applied immediately to a windowed mode window and may
+ *  cause it to be resized.
+ *
+ *  The maximum dimensions must be greater than or equal to the minimum
+ *  dimensions and all must be greater than or equal to zero.
+ *
+ *  @param[in] window The window to set limits for.
+ *  @param[in] minwidth The minimum width, in screen coordinates, of the content
+ *  area, or `GLFW_DONT_CARE`.
+ *  @param[in] minheight The minimum height, in screen coordinates, of the
+ *  content area, or `GLFW_DONT_CARE`.
+ *  @param[in] maxwidth The maximum width, in screen coordinates, of the content
+ *  area, or `GLFW_DONT_CARE`.
+ *  @param[in] maxheight The maximum height, in screen coordinates, of the
+ *  content area, or `GLFW_DONT_CARE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark If you set size limits and an aspect ratio that conflict, the
+ *  results are undefined.
+ *
+ *  @remark @wayland The size limits will not be applied until the window is
+ *  actually resized, either by the user or by the compositor.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_sizelimits
+ *  @sa @ref glfwSetWindowAspectRatio
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight);
+
+/*! @brief Sets the aspect ratio of the specified window.
+ *
+ *  This function sets the required aspect ratio of the content area of the
+ *  specified window.  If the window is full screen, the aspect ratio only takes
+ *  effect once it is made windowed.  If the window is not resizable, this
+ *  function does nothing.
+ *
+ *  The aspect ratio is specified as a numerator and a denominator and both
+ *  values must be greater than zero.  For example, the common 16:9 aspect ratio
+ *  is specified as 16 and 9, respectively.
+ *
+ *  If the numerator and denominator is set to `GLFW_DONT_CARE` then the aspect
+ *  ratio limit is disabled.
+ *
+ *  The aspect ratio is applied immediately to a windowed mode window and may
+ *  cause it to be resized.
+ *
+ *  @param[in] window The window to set limits for.
+ *  @param[in] numer The numerator of the desired aspect ratio, or
+ *  `GLFW_DONT_CARE`.
+ *  @param[in] denom The denominator of the desired aspect ratio, or
+ *  `GLFW_DONT_CARE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark If you set size limits and an aspect ratio that conflict, the
+ *  results are undefined.
+ *
+ *  @remark @wayland The aspect ratio will not be applied until the window is
+ *  actually resized, either by the user or by the compositor.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_sizelimits
+ *  @sa @ref glfwSetWindowSizeLimits
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom);
+
+/*! @brief Sets the size of the content area of the specified window.
+ *
+ *  This function sets the size, in screen coordinates, of the content area of
+ *  the specified window.
+ *
+ *  For full screen windows, this function updates the resolution of its desired
+ *  video mode and switches to the video mode closest to it, without affecting
+ *  the window's context.  As the context is unaffected, the bit depths of the
+ *  framebuffer remain unchanged.
+ *
+ *  If you wish to update the refresh rate of the desired video mode in addition
+ *  to its resolution, see @ref glfwSetWindowMonitor.
+ *
+ *  The window manager may put limits on what sizes are allowed.  GLFW cannot
+ *  and should not override these limits.
+ *
+ *  @param[in] window The window to resize.
+ *  @param[in] width The desired width, in screen coordinates, of the window
+ *  content area.
+ *  @param[in] height The desired height, in screen coordinates, of the window
+ *  content area.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @wayland A full screen window will not attempt to change the mode,
+ *  no matter what the requested size.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *  @sa @ref glfwGetWindowSize
+ *  @sa @ref glfwSetWindowMonitor
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowSize(GLFWwindow* window, int width, int height);
+
+/*! @brief Retrieves the size of the framebuffer of the specified window.
+ *
+ *  This function retrieves the size, in pixels, of the framebuffer of the
+ *  specified window.  If you wish to retrieve the size of the window in screen
+ *  coordinates, see @ref glfwGetWindowSize.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] window The window whose framebuffer to query.
+ *  @param[out] width Where to store the width, in pixels, of the framebuffer,
+ *  or `NULL`.
+ *  @param[out] height Where to store the height, in pixels, of the framebuffer,
+ *  or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_fbsize
+ *  @sa @ref glfwSetFramebufferSizeCallback
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetFramebufferSize(GLFWwindow* window, int* width, int* height);
+
+/*! @brief Retrieves the size of the frame of the window.
+ *
+ *  This function retrieves the size, in screen coordinates, of each edge of the
+ *  frame of the specified window.  This size includes the title bar, if the
+ *  window has one.  The size of the frame may vary depending on the
+ *  [window-related hints](@ref window_hints_wnd) used to create it.
+ *
+ *  Because this function retrieves the size of each window frame edge and not
+ *  the offset along a particular coordinate axis, the retrieved values will
+ *  always be zero or positive.
+ *
+ *  Any or all of the size arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` size arguments will be set to zero.
+ *
+ *  @param[in] window The window whose frame size to query.
+ *  @param[out] left Where to store the size, in screen coordinates, of the left
+ *  edge of the window frame, or `NULL`.
+ *  @param[out] top Where to store the size, in screen coordinates, of the top
+ *  edge of the window frame, or `NULL`.
+ *  @param[out] right Where to store the size, in screen coordinates, of the
+ *  right edge of the window frame, or `NULL`.
+ *  @param[out] bottom Where to store the size, in screen coordinates, of the
+ *  bottom edge of the window frame, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int* right, int* bottom);
+
+/*! @brief Retrieves the content scale for the specified window.
+ *
+ *  This function retrieves the content scale for the specified window.  The
+ *  content scale is the ratio between the current DPI and the platform's
+ *  default DPI.  This is especially important for text and any UI elements.  If
+ *  the pixel dimensions of your UI scaled by this look appropriate on your
+ *  machine then it should appear at a reasonable size on other machines
+ *  regardless of their DPI and scaling settings.  This relies on the system DPI
+ *  and scaling settings being somewhat correct.
+ *
+ *  On systems where each monitors can have its own content scale, the window
+ *  content scale will depend on which monitor the system considers the window
+ *  to be on.
+ *
+ *  @param[in] window The window to query.
+ *  @param[out] xscale Where to store the x-axis content scale, or `NULL`.
+ *  @param[out] yscale Where to store the y-axis content scale, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_scale
+ *  @sa @ref glfwSetWindowContentScaleCallback
+ *  @sa @ref glfwGetMonitorContentScale
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwGetWindowContentScale(GLFWwindow* window, float* xscale, float* yscale);
+
+/*! @brief Returns the opacity of the whole window.
+ *
+ *  This function returns the opacity of the window, including any decorations.
+ *
+ *  The opacity (or alpha) value is a positive finite number between zero and
+ *  one, where zero is fully transparent and one is fully opaque.  If the system
+ *  does not support whole window transparency, this function always returns one.
+ *
+ *  The initial opacity value for newly created windows is one.
+ *
+ *  @param[in] window The window to query.
+ *  @return The opacity value of the specified window.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_transparency
+ *  @sa @ref glfwSetWindowOpacity
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI float glfwGetWindowOpacity(GLFWwindow* window);
+
+/*! @brief Sets the opacity of the whole window.
+ *
+ *  This function sets the opacity of the window, including any decorations.
+ *
+ *  The opacity (or alpha) value is a positive finite number between zero and
+ *  one, where zero is fully transparent and one is fully opaque.
+ *
+ *  The initial opacity value for newly created windows is one.
+ *
+ *  A window created with framebuffer transparency may not use whole window
+ *  transparency.  The results of doing this are undefined.
+ *
+ *  @param[in] window The window to set the opacity for.
+ *  @param[in] opacity The desired opacity of the specified window.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
+ *
+ *  @remark @wayland There is no way to set an opacity factor for a window.
+ *  This function will emit @ref GLFW_FEATURE_UNAVAILABLE.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_transparency
+ *  @sa @ref glfwGetWindowOpacity
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity);
+
+/*! @brief Iconifies the specified window.
+ *
+ *  This function iconifies (minimizes) the specified window if it was
+ *  previously restored.  If the window is already iconified, this function does
+ *  nothing.
+ *
+ *  If the specified window is a full screen window, the original monitor
+ *  resolution is restored until the window is restored.
+ *
+ *  @param[in] window The window to iconify.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @wayland Once a window is iconified, @ref glfwRestoreWindow won’t
+ *  be able to restore it.  This is a design decision of the xdg-shell
+ *  protocol.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *  @sa @ref glfwRestoreWindow
+ *  @sa @ref glfwMaximizeWindow
+ *
+ *  @since Added in version 2.1.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwIconifyWindow(GLFWwindow* window);
+
+/*! @brief Restores the specified window.
+ *
+ *  This function restores the specified window if it was previously iconified
+ *  (minimized) or maximized.  If the window is already restored, this function
+ *  does nothing.
+ *
+ *  If the specified window is a full screen window, the resolution chosen for
+ *  the window is restored on the selected monitor.
+ *
+ *  @param[in] window The window to restore.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *  @sa @ref glfwIconifyWindow
+ *  @sa @ref glfwMaximizeWindow
+ *
+ *  @since Added in version 2.1.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwRestoreWindow(GLFWwindow* window);
+
+/*! @brief Maximizes the specified window.
+ *
+ *  This function maximizes the specified window if it was previously not
+ *  maximized.  If the window is already maximized, this function does nothing.
+ *
+ *  If the specified window is a full screen window, this function does nothing.
+ *
+ *  @param[in] window The window to maximize.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @par Thread Safety
+ *  This function may only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *  @sa @ref glfwIconifyWindow
+ *  @sa @ref glfwRestoreWindow
+ *
+ *  @since Added in GLFW 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwMaximizeWindow(GLFWwindow* window);
+
+/*! @brief Makes the specified window visible.
+ *
+ *  This function makes the specified window visible if it was previously
+ *  hidden.  If the window is already visible or is in full screen mode, this
+ *  function does nothing.
+ *
+ *  By default, windowed mode windows are focused when shown
+ *  Set the [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) window hint
+ *  to change this behavior for all newly created windows, or change the
+ *  behavior for an existing window with @ref glfwSetWindowAttrib.
+ *
+ *  @param[in] window The window to make visible.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hide
+ *  @sa @ref glfwHideWindow
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwShowWindow(GLFWwindow* window);
+
+/*! @brief Hides the specified window.
+ *
+ *  This function hides the specified window if it was previously visible.  If
+ *  the window is already hidden or is in full screen mode, this function does
+ *  nothing.
+ *
+ *  @param[in] window The window to hide.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_hide
+ *  @sa @ref glfwShowWindow
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwHideWindow(GLFWwindow* window);
+
+/*! @brief Brings the specified window to front and sets input focus.
+ *
+ *  This function brings the specified window to front and sets input focus.
+ *  The window should already be visible and not iconified.
+ *
+ *  By default, both windowed and full screen mode windows are focused when
+ *  initially created.  Set the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) to
+ *  disable this behavior.
+ *
+ *  Also by default, windowed mode windows are focused when shown
+ *  with @ref glfwShowWindow. Set the
+ *  [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) to disable this behavior.
+ *
+ *  __Do not use this function__ to steal focus from other applications unless
+ *  you are certain that is what the user wants.  Focus stealing can be
+ *  extremely disruptive.
+ *
+ *  For a less disruptive way of getting the user's attention, see
+ *  [attention requests](@ref window_attention).
+ *
+ *  @param[in] window The window to give input focus.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
+ *
+ *  @remark @wayland It is not possible for an application to set the input
+ *  focus.  This function will emit @ref GLFW_FEATURE_UNAVAILABLE.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_focus
+ *  @sa @ref window_attention
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwFocusWindow(GLFWwindow* window);
+
+/*! @brief Requests user attention to the specified window.
+ *
+ *  This function requests user attention to the specified window.  On
+ *  platforms where this is not supported, attention is requested to the
+ *  application as a whole.
+ *
+ *  Once the user has given attention, usually by focusing the window or
+ *  application, the system will end the request automatically.
+ *
+ *  @param[in] window The window to request attention to.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @macos Attention is requested to the application as a whole, not the
+ *  specific window.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_attention
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window);
+
+/*! @brief Returns the monitor that the window uses for full screen mode.
+ *
+ *  This function returns the handle of the monitor that the specified window is
+ *  in full screen on.
+ *
+ *  @param[in] window The window to query.
+ *  @return The monitor, or `NULL` if the window is in windowed mode or an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_monitor
+ *  @sa @ref glfwSetWindowMonitor
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
+
+/*! @brief Sets the mode, monitor, video mode and placement of a window.
+ *
+ *  This function sets the monitor that the window uses for full screen mode or,
+ *  if the monitor is `NULL`, makes it windowed mode.
+ *
+ *  When setting a monitor, this function updates the width, height and refresh
+ *  rate of the desired video mode and switches to the video mode closest to it.
+ *  The window position is ignored when setting a monitor.
+ *
+ *  When the monitor is `NULL`, the position, width and height are used to
+ *  place the window content area.  The refresh rate is ignored when no monitor
+ *  is specified.
+ *
+ *  If you only wish to update the resolution of a full screen window or the
+ *  size of a windowed mode window, see @ref glfwSetWindowSize.
+ *
+ *  When a window transitions from full screen to windowed mode, this function
+ *  restores any previous window settings such as whether it is decorated,
+ *  floating, resizable, has size or aspect ratio limits, etc.
+ *
+ *  @param[in] window The window whose monitor, size or video mode to set.
+ *  @param[in] monitor The desired monitor, or `NULL` to set windowed mode.
+ *  @param[in] xpos The desired x-coordinate of the upper-left corner of the
+ *  content area.
+ *  @param[in] ypos The desired y-coordinate of the upper-left corner of the
+ *  content area.
+ *  @param[in] width The desired with, in screen coordinates, of the content
+ *  area or video mode.
+ *  @param[in] height The desired height, in screen coordinates, of the content
+ *  area or video mode.
+ *  @param[in] refreshRate The desired refresh rate, in Hz, of the video mode,
+ *  or `GLFW_DONT_CARE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark The OpenGL or OpenGL ES context will not be destroyed or otherwise
+ *  affected by any resizing or mode switching, although you may need to update
+ *  your viewport if the framebuffer size has changed.
+ *
+ *  @remark @wayland The desired window position is ignored, as there is no way
+ *  for an application to set this property.
+ *
+ *  @remark @wayland Setting the window to full screen will not attempt to
+ *  change the mode, no matter what the requested size or refresh rate.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_monitor
+ *  @sa @ref window_full_screen
+ *  @sa @ref glfwGetWindowMonitor
+ *  @sa @ref glfwSetWindowSize
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate);
+
+/*! @brief Returns an attribute of the specified window.
+ *
+ *  This function returns the value of an attribute of the specified window or
+ *  its OpenGL or OpenGL ES context.
+ *
+ *  @param[in] window The window to query.
+ *  @param[in] attrib The [window attribute](@ref window_attribs) whose value to
+ *  return.
+ *  @return The value of the attribute, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark Framebuffer related hints are not window attributes.  See @ref
+ *  window_attribs_fb for more information.
+ *
+ *  @remark Zero is a valid value for many window and context related
+ *  attributes so you cannot use a return value of zero as an indication of
+ *  errors.  However, this function should not fail as long as it is passed
+ *  valid arguments and the library has been [initialized](@ref intro_init).
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_attribs
+ *  @sa @ref glfwSetWindowAttrib
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetWindowParam` and
+ *  `glfwGetGLVersion`.
+ *
+ *  @ingroup window
+ */
+GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
+
+/*! @brief Sets an attribute of the specified window.
+ *
+ *  This function sets the value of an attribute of the specified window.
+ *
+ *  The supported attributes are [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
+ *  [GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib),
+ *  [GLFW_FLOATING](@ref GLFW_FLOATING_attrib),
+ *  [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib) and
+ *  [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_attrib).
+ *  [GLFW_MOUSE_PASSTHROUGH](@ref GLFW_MOUSE_PASSTHROUGH_attrib)
+ *
+ *  Some of these attributes are ignored for full screen windows.  The new
+ *  value will take effect if the window is later made windowed.
+ *
+ *  Some of these attributes are ignored for windowed mode windows.  The new
+ *  value will take effect if the window is later made full screen.
+ *
+ *  @param[in] window The window to set the attribute for.
+ *  @param[in] attrib A supported window attribute.
+ *  @param[in] value `GLFW_TRUE` or `GLFW_FALSE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark Calling @ref glfwGetWindowAttrib will always return the latest
+ *  value, even if that value is ignored by the current mode of the window.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_attribs
+ *  @sa @ref glfwGetWindowAttrib
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowAttrib(GLFWwindow* window, int attrib, int value);
+
+/*! @brief Sets the user pointer of the specified window.
+ *
+ *  This function sets the user-defined pointer of the specified window.  The
+ *  current value is retained until the window is destroyed.  The initial value
+ *  is `NULL`.
+ *
+ *  @param[in] window The window whose pointer to set.
+ *  @param[in] pointer The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_userptr
+ *  @sa @ref glfwGetWindowUserPointer
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer);
+
+/*! @brief Returns the user pointer of the specified window.
+ *
+ *  This function returns the current value of the user-defined pointer of the
+ *  specified window.  The initial value is `NULL`.
+ *
+ *  @param[in] window The window whose pointer to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref window_userptr
+ *  @sa @ref glfwSetWindowUserPointer
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
+
+/*! @brief Sets the position callback for the specified window.
+ *
+ *  This function sets the position callback of the specified window, which is
+ *  called when the window is moved.  The callback is provided with the
+ *  position, in screen coordinates, of the upper-left corner of the content
+ *  area of the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int xpos, int ypos)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowposfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @remark @wayland This callback will never be called, as there is no way for
+ *  an application to know its global position.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_pos
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun callback);
+
+/*! @brief Sets the size callback for the specified window.
+ *
+ *  This function sets the size callback of the specified window, which is
+ *  called when the window is resized.  The callback is provided with the size,
+ *  in screen coordinates, of the content area of the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int width, int height)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowsizefun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_size
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun callback);
+
+/*! @brief Sets the close callback for the specified window.
+ *
+ *  This function sets the close callback of the specified window, which is
+ *  called when the user attempts to close the window, for example by clicking
+ *  the close widget in the title bar.
+ *
+ *  The close flag is set before this callback is called, but you can modify it
+ *  at any time with @ref glfwSetWindowShouldClose.
+ *
+ *  The close callback is not triggered by @ref glfwDestroyWindow.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowclosefun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @remark @macos Selecting Quit from the application menu will trigger the
+ *  close callback for all windows.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_close
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback);
+
+/*! @brief Sets the refresh callback for the specified window.
+ *
+ *  This function sets the refresh callback of the specified window, which is
+ *  called when the content area of the window needs to be redrawn, for example
+ *  if the window has been exposed after having been covered by another window.
+ *
+ *  On compositing window systems such as Aero, Compiz, Aqua or Wayland, where
+ *  the window contents are saved off-screen, this callback may be called only
+ *  very infrequently or never at all.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window);
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowrefreshfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_refresh
+ *
+ *  @since Added in version 2.5.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback);
+
+/*! @brief Sets the focus callback for the specified window.
+ *
+ *  This function sets the focus callback of the specified window, which is
+ *  called when the window gains or loses input focus.
+ *
+ *  After the focus callback is called for a window that lost input focus,
+ *  synthetic key and mouse button release events will be generated for all such
+ *  that had been pressed.  For more information, see @ref glfwSetKeyCallback
+ *  and @ref glfwSetMouseButtonCallback.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int focused)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowfocusfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_focus
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback);
+
+/*! @brief Sets the iconify callback for the specified window.
+ *
+ *  This function sets the iconification callback of the specified window, which
+ *  is called when the window is iconified or restored.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int iconified)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowiconifyfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_iconify
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback);
+
+/*! @brief Sets the maximize callback for the specified window.
+ *
+ *  This function sets the maximization callback of the specified window, which
+ *  is called when the window is maximized or restored.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int maximized)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowmaximizefun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_maximize
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback);
+
+/*! @brief Sets the framebuffer resize callback for the specified window.
+ *
+ *  This function sets the framebuffer resize callback of the specified window,
+ *  which is called when the framebuffer of the specified window is resized.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int width, int height)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWframebuffersizefun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_fbsize
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun callback);
+
+/*! @brief Sets the window content scale callback for the specified window.
+ *
+ *  This function sets the window content scale callback of the specified window,
+ *  which is called when the content scale of the specified window changes.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, float xscale, float yscale)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWwindowcontentscalefun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref window_scale
+ *  @sa @ref glfwGetWindowContentScale
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup window
+ */
+GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun callback);
+
+/*! @brief Processes all pending events.
+ *
+ *  This function processes only those events that are already in the event
+ *  queue and then returns immediately.  Processing events will cause the window
+ *  and input callbacks associated with those events to be called.
+ *
+ *  On some platforms, a window move, resize or menu operation will cause event
+ *  processing to block.  This is due to how event processing is designed on
+ *  those platforms.  You can use the
+ *  [window refresh callback](@ref window_refresh) to redraw the contents of
+ *  your window when necessary during such operations.
+ *
+ *  Do not assume that callbacks you set will _only_ be called in response to
+ *  event processing functions like this one.  While it is necessary to poll for
+ *  events, window systems that require GLFW to register callbacks of its own
+ *  can pass events to GLFW in response to many window system function calls.
+ *  GLFW will pass those events on to the application callbacks before
+ *  returning.
+ *
+ *  Event processing is not required for joystick input to work.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref events
+ *  @sa @ref glfwWaitEvents
+ *  @sa @ref glfwWaitEventsTimeout
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwPollEvents(void);
+
+/*! @brief Waits until events are queued and processes them.
+ *
+ *  This function puts the calling thread to sleep until at least one event is
+ *  available in the event queue.  Once one or more events are available,
+ *  it behaves exactly like @ref glfwPollEvents, i.e. the events in the queue
+ *  are processed and the function then returns immediately.  Processing events
+ *  will cause the window and input callbacks associated with those events to be
+ *  called.
+ *
+ *  Since not all events are associated with callbacks, this function may return
+ *  without a callback having been called even if you are monitoring all
+ *  callbacks.
+ *
+ *  On some platforms, a window move, resize or menu operation will cause event
+ *  processing to block.  This is due to how event processing is designed on
+ *  those platforms.  You can use the
+ *  [window refresh callback](@ref window_refresh) to redraw the contents of
+ *  your window when necessary during such operations.
+ *
+ *  Do not assume that callbacks you set will _only_ be called in response to
+ *  event processing functions like this one.  While it is necessary to poll for
+ *  events, window systems that require GLFW to register callbacks of its own
+ *  can pass events to GLFW in response to many window system function calls.
+ *  GLFW will pass those events on to the application callbacks before
+ *  returning.
+ *
+ *  Event processing is not required for joystick input to work.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref events
+ *  @sa @ref glfwPollEvents
+ *  @sa @ref glfwWaitEventsTimeout
+ *
+ *  @since Added in version 2.5.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWaitEvents(void);
+
+/*! @brief Waits with timeout until events are queued and processes them.
+ *
+ *  This function puts the calling thread to sleep until at least one event is
+ *  available in the event queue, or until the specified timeout is reached.  If
+ *  one or more events are available, it behaves exactly like @ref
+ *  glfwPollEvents, i.e. the events in the queue are processed and the function
+ *  then returns immediately.  Processing events will cause the window and input
+ *  callbacks associated with those events to be called.
+ *
+ *  The timeout value must be a positive finite number.
+ *
+ *  Since not all events are associated with callbacks, this function may return
+ *  without a callback having been called even if you are monitoring all
+ *  callbacks.
+ *
+ *  On some platforms, a window move, resize or menu operation will cause event
+ *  processing to block.  This is due to how event processing is designed on
+ *  those platforms.  You can use the
+ *  [window refresh callback](@ref window_refresh) to redraw the contents of
+ *  your window when necessary during such operations.
+ *
+ *  Do not assume that callbacks you set will _only_ be called in response to
+ *  event processing functions like this one.  While it is necessary to poll for
+ *  events, window systems that require GLFW to register callbacks of its own
+ *  can pass events to GLFW in response to many window system function calls.
+ *  GLFW will pass those events on to the application callbacks before
+ *  returning.
+ *
+ *  Event processing is not required for joystick input to work.
+ *
+ *  @param[in] timeout The maximum amount of time, in seconds, to wait.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref events
+ *  @sa @ref glfwPollEvents
+ *  @sa @ref glfwWaitEvents
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwWaitEventsTimeout(double timeout);
+
+/*! @brief Posts an empty event to the event queue.
+ *
+ *  This function posts an empty event from the current thread to the event
+ *  queue, causing @ref glfwWaitEvents or @ref glfwWaitEventsTimeout to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref events
+ *  @sa @ref glfwWaitEvents
+ *  @sa @ref glfwWaitEventsTimeout
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwPostEmptyEvent(void);
+
+/*! @brief Returns the value of an input option for the specified window.
+ *
+ *  This function returns the value of an input option for the specified window.
+ *  The mode must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
+ *  @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or
+ *  @ref GLFW_RAW_MOUSE_MOTION.
+ *
+ *  @param[in] window The window to query.
+ *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
+ *  `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or
+ *  `GLFW_RAW_MOUSE_MOTION`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref glfwSetInputMode
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
+
+/*! @brief Sets an input option for the specified window.
+ *
+ *  This function sets an input mode option for the specified window.  The mode
+ *  must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
+ *  @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or
+ *  @ref GLFW_RAW_MOUSE_MOTION.
+ *
+ *  If the mode is `GLFW_CURSOR`, the value must be one of the following cursor
+ *  modes:
+ *  - `GLFW_CURSOR_NORMAL` makes the cursor visible and behaving normally.
+ *  - `GLFW_CURSOR_HIDDEN` makes the cursor invisible when it is over the
+ *    content area of the window but does not restrict the cursor from leaving.
+ *  - `GLFW_CURSOR_DISABLED` hides and grabs the cursor, providing virtual
+ *    and unlimited cursor movement.  This is useful for implementing for
+ *    example 3D camera controls.
+ *
+ *  If the mode is `GLFW_STICKY_KEYS`, the value must be either `GLFW_TRUE` to
+ *  enable sticky keys, or `GLFW_FALSE` to disable it.  If sticky keys are
+ *  enabled, a key press will ensure that @ref glfwGetKey returns `GLFW_PRESS`
+ *  the next time it is called even if the key had been released before the
+ *  call.  This is useful when you are only interested in whether keys have been
+ *  pressed but not when or in which order.
+ *
+ *  If the mode is `GLFW_STICKY_MOUSE_BUTTONS`, the value must be either
+ *  `GLFW_TRUE` to enable sticky mouse buttons, or `GLFW_FALSE` to disable it.
+ *  If sticky mouse buttons are enabled, a mouse button press will ensure that
+ *  @ref glfwGetMouseButton returns `GLFW_PRESS` the next time it is called even
+ *  if the mouse button had been released before the call.  This is useful when
+ *  you are only interested in whether mouse buttons have been pressed but not
+ *  when or in which order.
+ *
+ *  If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `GLFW_TRUE` to
+ *  enable lock key modifier bits, or `GLFW_FALSE` to disable them.  If enabled,
+ *  callbacks that receive modifier bits will also have the @ref
+ *  GLFW_MOD_CAPS_LOCK bit set when the event was generated with Caps Lock on,
+ *  and the @ref GLFW_MOD_NUM_LOCK bit when Num Lock was on.
+ *
+ *  If the mode is `GLFW_RAW_MOUSE_MOTION`, the value must be either `GLFW_TRUE`
+ *  to enable raw (unscaled and unaccelerated) mouse motion when the cursor is
+ *  disabled, or `GLFW_FALSE` to disable it.  If raw motion is not supported,
+ *  attempting to set this will emit @ref GLFW_FEATURE_UNAVAILABLE.  Call @ref
+ *  glfwRawMouseMotionSupported to check for support.
+ *
+ *  @param[in] window The window whose input mode to set.
+ *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
+ *  `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or
+ *  `GLFW_RAW_MOUSE_MOTION`.
+ *  @param[in] value The new value of the specified input mode.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM, @ref GLFW_PLATFORM_ERROR and @ref
+ *  GLFW_FEATURE_UNAVAILABLE (see above).
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref glfwGetInputMode
+ *
+ *  @since Added in version 3.0.  Replaces `glfwEnable` and `glfwDisable`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetInputMode(GLFWwindow* window, int mode, int value);
+
+/*! @brief Returns whether raw mouse motion is supported.
+ *
+ *  This function returns whether raw mouse motion is supported on the current
+ *  system.  This status does not change after GLFW has been initialized so you
+ *  only need to check this once.  If you attempt to enable raw motion on
+ *  a system that does not support it, @ref GLFW_PLATFORM_ERROR will be emitted.
+ *
+ *  Raw mouse motion is closer to the actual motion of the mouse across
+ *  a surface.  It is not affected by the scaling and acceleration applied to
+ *  the motion of the desktop cursor.  That processing is suitable for a cursor
+ *  while raw motion is better for controlling for example a 3D camera.  Because
+ *  of this, raw mouse motion is only provided when the cursor is disabled.
+ *
+ *  @return `GLFW_TRUE` if raw mouse motion is supported on the current machine,
+ *  or `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref raw_mouse_motion
+ *  @sa @ref glfwSetInputMode
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwRawMouseMotionSupported(void);
+
+/*! @brief Returns the layout-specific name of the specified printable key.
+ *
+ *  This function returns the name of the specified printable key, encoded as
+ *  UTF-8.  This is typically the character that key would produce without any
+ *  modifier keys, intended for displaying key bindings to the user.  For dead
+ *  keys, it is typically the diacritic it would add to a character.
+ *
+ *  __Do not use this function__ for [text input](@ref input_char).  You will
+ *  break text input for many languages even if it happens to work for yours.
+ *
+ *  If the key is `GLFW_KEY_UNKNOWN`, the scancode is used to identify the key,
+ *  otherwise the scancode is ignored.  If you specify a non-printable key, or
+ *  `GLFW_KEY_UNKNOWN` and a scancode that maps to a non-printable key, this
+ *  function returns `NULL` but does not emit an error.
+ *
+ *  This behavior allows you to always pass in the arguments in the
+ *  [key callback](@ref input_key) without modification.
+ *
+ *  The printable keys are:
+ *  - `GLFW_KEY_APOSTROPHE`
+ *  - `GLFW_KEY_COMMA`
+ *  - `GLFW_KEY_MINUS`
+ *  - `GLFW_KEY_PERIOD`
+ *  - `GLFW_KEY_SLASH`
+ *  - `GLFW_KEY_SEMICOLON`
+ *  - `GLFW_KEY_EQUAL`
+ *  - `GLFW_KEY_LEFT_BRACKET`
+ *  - `GLFW_KEY_RIGHT_BRACKET`
+ *  - `GLFW_KEY_BACKSLASH`
+ *  - `GLFW_KEY_WORLD_1`
+ *  - `GLFW_KEY_WORLD_2`
+ *  - `GLFW_KEY_0` to `GLFW_KEY_9`
+ *  - `GLFW_KEY_A` to `GLFW_KEY_Z`
+ *  - `GLFW_KEY_KP_0` to `GLFW_KEY_KP_9`
+ *  - `GLFW_KEY_KP_DECIMAL`
+ *  - `GLFW_KEY_KP_DIVIDE`
+ *  - `GLFW_KEY_KP_MULTIPLY`
+ *  - `GLFW_KEY_KP_SUBTRACT`
+ *  - `GLFW_KEY_KP_ADD`
+ *  - `GLFW_KEY_KP_EQUAL`
+ *
+ *  Names for printable keys depend on keyboard layout, while names for
+ *  non-printable keys are the same across layouts but depend on the application
+ *  language and should be localized along with other user interface text.
+ *
+ *  @param[in] key The key to query, or `GLFW_KEY_UNKNOWN`.
+ *  @param[in] scancode The scancode of the key to query.
+ *  @return The UTF-8 encoded, layout-specific name of the key, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark The contents of the returned string may change when a keyboard
+ *  layout change event is received.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_key_name
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetKeyName(int key, int scancode);
+
+/*! @brief Returns the platform-specific scancode of the specified key.
+ *
+ *  This function returns the platform-specific scancode of the specified key.
+ *
+ *  If the key is `GLFW_KEY_UNKNOWN` or does not exist on the keyboard this
+ *  method will return `-1`.
+ *
+ *  @param[in] key Any [named key](@ref keys).
+ *  @return The platform-specific scancode for the key, or `-1` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref input_key
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetKeyScancode(int key);
+
+/*! @brief Returns the last reported state of a keyboard key for the specified
+ *  window.
+ *
+ *  This function returns the last state reported for the specified key to the
+ *  specified window.  The returned state is one of `GLFW_PRESS` or
+ *  `GLFW_RELEASE`.  The higher-level action `GLFW_REPEAT` is only reported to
+ *  the key callback.
+ *
+ *  If the @ref GLFW_STICKY_KEYS input mode is enabled, this function returns
+ *  `GLFW_PRESS` the first time you call it for a key that was pressed, even if
+ *  that key has already been released.
+ *
+ *  The key functions deal with physical keys, with [key tokens](@ref keys)
+ *  named after their use on the standard US keyboard layout.  If you want to
+ *  input text, use the Unicode character callback instead.
+ *
+ *  The [modifier key bit masks](@ref mods) are not key tokens and cannot be
+ *  used with this function.
+ *
+ *  __Do not use this function__ to implement [text input](@ref input_char).
+ *
+ *  @param[in] window The desired window.
+ *  @param[in] key The desired [keyboard key](@ref keys).  `GLFW_KEY_UNKNOWN` is
+ *  not a valid key for this function.
+ *  @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_key
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
+
+/*! @brief Returns the last reported state of a mouse button for the specified
+ *  window.
+ *
+ *  This function returns the last state reported for the specified mouse button
+ *  to the specified window.  The returned state is one of `GLFW_PRESS` or
+ *  `GLFW_RELEASE`.
+ *
+ *  If the @ref GLFW_STICKY_MOUSE_BUTTONS input mode is enabled, this function
+ *  returns `GLFW_PRESS` the first time you call it for a mouse button that was
+ *  pressed, even if that mouse button has already been released.
+ *
+ *  @param[in] window The desired window.
+ *  @param[in] button The desired [mouse button](@ref buttons).
+ *  @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_mouse_button
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
+
+/*! @brief Retrieves the position of the cursor relative to the content area of
+ *  the window.
+ *
+ *  This function returns the position of the cursor, in screen coordinates,
+ *  relative to the upper-left corner of the content area of the specified
+ *  window.
+ *
+ *  If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor
+ *  position is unbounded and limited only by the minimum and maximum values of
+ *  a `double`.
+ *
+ *  The coordinate can be converted to their integer equivalents with the
+ *  `floor` function.  Casting directly to an integer type works for positive
+ *  coordinates, but fails for negative ones.
+ *
+ *  Any or all of the position arguments may be `NULL`.  If an error occurs, all
+ *  non-`NULL` position arguments will be set to zero.
+ *
+ *  @param[in] window The desired window.
+ *  @param[out] xpos Where to store the cursor x-coordinate, relative to the
+ *  left edge of the content area, or `NULL`.
+ *  @param[out] ypos Where to store the cursor y-coordinate, relative to the to
+ *  top edge of the content area, or `NULL`.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_pos
+ *  @sa @ref glfwSetCursorPos
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetMousePos`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
+
+/*! @brief Sets the position of the cursor, relative to the content area of the
+ *  window.
+ *
+ *  This function sets the position, in screen coordinates, of the cursor
+ *  relative to the upper-left corner of the content area of the specified
+ *  window.  The window must have input focus.  If the window does not have
+ *  input focus when this function is called, it fails silently.
+ *
+ *  __Do not use this function__ to implement things like camera controls.  GLFW
+ *  already provides the `GLFW_CURSOR_DISABLED` cursor mode that hides the
+ *  cursor, transparently re-centers it and provides unconstrained cursor
+ *  motion.  See @ref glfwSetInputMode for more information.
+ *
+ *  If the cursor mode is `GLFW_CURSOR_DISABLED` then the cursor position is
+ *  unconstrained and limited only by the minimum and maximum values of
+ *  a `double`.
+ *
+ *  @param[in] window The desired window.
+ *  @param[in] xpos The desired x-coordinate, relative to the left edge of the
+ *  content area.
+ *  @param[in] ypos The desired y-coordinate, relative to the top edge of the
+ *  content area.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @wayland This function will only work when the cursor mode is
+ *  `GLFW_CURSOR_DISABLED`, otherwise it will do nothing.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_pos
+ *  @sa @ref glfwGetCursorPos
+ *
+ *  @since Added in version 3.0.  Replaces `glfwSetMousePos`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos);
+
+/*! @brief Creates a custom cursor.
+ *
+ *  Creates a new custom cursor image that can be set for a window with @ref
+ *  glfwSetCursor.  The cursor can be destroyed with @ref glfwDestroyCursor.
+ *  Any remaining cursors are destroyed by @ref glfwTerminate.
+ *
+ *  The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight
+ *  bits per channel with the red channel first.  They are arranged canonically
+ *  as packed sequential rows, starting from the top-left corner.
+ *
+ *  The cursor hotspot is specified in pixels, relative to the upper-left corner
+ *  of the cursor image.  Like all other coordinate systems in GLFW, the X-axis
+ *  points to the right and the Y-axis points down.
+ *
+ *  @param[in] image The desired cursor image.
+ *  @param[in] xhot The desired x-coordinate, in pixels, of the cursor hotspot.
+ *  @param[in] yhot The desired y-coordinate, in pixels, of the cursor hotspot.
+ *  @return The handle of the created cursor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified image data is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *  @sa @ref glfwDestroyCursor
+ *  @sa @ref glfwCreateStandardCursor
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot);
+
+/*! @brief Creates a cursor with a standard shape.
+ *
+ *  Returns a cursor with a standard shape, that can be set for a window with
+ *  @ref glfwSetCursor.  The images for these cursors come from the system
+ *  cursor theme and their exact appearance will vary between platforms.
+ *
+ *  Most of these shapes are guaranteed to exist on every supported platform but
+ *  a few may not be present.  See the table below for details.
+ *
+ *  Cursor shape                   | Windows | macOS | X11    | Wayland
+ *  ------------------------------ | ------- | ----- | ------ | -------
+ *  @ref GLFW_ARROW_CURSOR         | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_IBEAM_CURSOR         | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_CROSSHAIR_CURSOR     | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_POINTING_HAND_CURSOR | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_RESIZE_EW_CURSOR     | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_RESIZE_NS_CURSOR     | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_RESIZE_NWSE_CURSOR   | Yes     | Yes<sup>1</sup> | Maybe<sup>2</sup> | Maybe<sup>2</sup>
+ *  @ref GLFW_RESIZE_NESW_CURSOR   | Yes     | Yes<sup>1</sup> | Maybe<sup>2</sup> | Maybe<sup>2</sup>
+ *  @ref GLFW_RESIZE_ALL_CURSOR    | Yes     | Yes   | Yes    | Yes
+ *  @ref GLFW_NOT_ALLOWED_CURSOR   | Yes     | Yes   | Maybe<sup>2</sup> | Maybe<sup>2</sup>
+ *
+ *  1) This uses a private system API and may fail in the future.
+ *
+ *  2) This uses a newer standard that not all cursor themes support.
+ *
+ *  If the requested shape is not available, this function emits a @ref
+ *  GLFW_CURSOR_UNAVAILABLE error and returns `NULL`.
+ *
+ *  @param[in] shape One of the [standard shapes](@ref shapes).
+ *  @return A new cursor ready to use or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM, @ref GLFW_CURSOR_UNAVAILABLE and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_standard
+ *  @sa @ref glfwCreateCursor
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape);
+
+/*! @brief Destroys a cursor.
+ *
+ *  This function destroys a cursor previously created with @ref
+ *  glfwCreateCursor.  Any remaining cursors will be destroyed by @ref
+ *  glfwTerminate.
+ *
+ *  If the specified cursor is current for any window, that window will be
+ *  reverted to the default cursor.  This does not affect the cursor mode.
+ *
+ *  @param[in] cursor The cursor object to destroy.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @reentrancy This function must not be called from a callback.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *  @sa @ref glfwCreateCursor
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor);
+
+/*! @brief Sets the cursor for the window.
+ *
+ *  This function sets the cursor image to be used when the cursor is over the
+ *  content area of the specified window.  The set cursor will only be visible
+ *  when the [cursor mode](@ref cursor_mode) of the window is
+ *  `GLFW_CURSOR_NORMAL`.
+ *
+ *  On some platforms, the set cursor may not be visible unless the window also
+ *  has input focus.
+ *
+ *  @param[in] window The window to set the cursor for.
+ *  @param[in] cursor The cursor to set, or `NULL` to switch back to the default
+ *  arrow cursor.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_object
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor);
+
+/*! @brief Sets the key callback.
+ *
+ *  This function sets the key callback of the specified window, which is called
+ *  when a key is pressed, repeated or released.
+ *
+ *  The key functions deal with physical keys, with layout independent
+ *  [key tokens](@ref keys) named after their values in the standard US keyboard
+ *  layout.  If you want to input text, use the
+ *  [character callback](@ref glfwSetCharCallback) instead.
+ *
+ *  When a window loses input focus, it will generate synthetic key release
+ *  events for all pressed keys.  You can tell these events from user-generated
+ *  events by the fact that the synthetic ones are generated after the focus
+ *  loss event has been processed, i.e. after the
+ *  [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
+ *
+ *  The scancode of a key is specific to that platform or sometimes even to that
+ *  machine.  Scancodes are intended to allow users to bind keys that don't have
+ *  a GLFW key token.  Such keys have `key` set to `GLFW_KEY_UNKNOWN`, their
+ *  state is not saved and so it cannot be queried with @ref glfwGetKey.
+ *
+ *  Sometimes GLFW needs to generate synthetic key events, in which case the
+ *  scancode may be zero.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new key callback, or `NULL` to remove the currently
+ *  set callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int key, int scancode, int action, int mods)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWkeyfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_key
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun callback);
+
+/*! @brief Sets the Unicode character callback.
+ *
+ *  This function sets the character callback of the specified window, which is
+ *  called when a Unicode character is input.
+ *
+ *  The character callback is intended for Unicode text input.  As it deals with
+ *  characters, it is keyboard layout dependent, whereas the
+ *  [key callback](@ref glfwSetKeyCallback) is not.  Characters do not map 1:1
+ *  to physical keys, as a key may produce zero, one or more characters.  If you
+ *  want to know whether a specific physical key was pressed or released, see
+ *  the key callback instead.
+ *
+ *  The character callback behaves as system text input normally does and will
+ *  not be called if modifier keys are held down that would prevent normal text
+ *  input on that platform, for example a Super (Command) key on macOS or Alt key
+ *  on Windows.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, unsigned int codepoint)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWcharfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_char
+ *
+ *  @since Added in version 2.4.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun callback);
+
+/*! @brief Sets the Unicode character with modifiers callback.
+ *
+ *  This function sets the character with modifiers callback of the specified
+ *  window, which is called when a Unicode character is input regardless of what
+ *  modifier keys are used.
+ *
+ *  The character with modifiers callback is intended for implementing custom
+ *  Unicode character input.  For regular Unicode text input, see the
+ *  [character callback](@ref glfwSetCharCallback).  Like the character
+ *  callback, the character with modifiers callback deals with characters and is
+ *  keyboard layout dependent.  Characters do not map 1:1 to physical keys, as
+ *  a key may produce zero, one or more characters.  If you want to know whether
+ *  a specific physical key was pressed or released, see the
+ *  [key callback](@ref glfwSetKeyCallback) instead.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, unsigned int codepoint, int mods)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWcharmodsfun).
+ *
+ *  @deprecated Scheduled for removal in version 4.0.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_char
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun callback);
+
+/*! @brief Sets the mouse button callback.
+ *
+ *  This function sets the mouse button callback of the specified window, which
+ *  is called when a mouse button is pressed or released.
+ *
+ *  When a window loses input focus, it will generate synthetic mouse button
+ *  release events for all pressed mouse buttons.  You can tell these events
+ *  from user-generated events by the fact that the synthetic ones are generated
+ *  after the focus loss event has been processed, i.e. after the
+ *  [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int button, int action, int mods)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWmousebuttonfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref input_mouse_button
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter and return value.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback);
+
+/*! @brief Sets the cursor position callback.
+ *
+ *  This function sets the cursor position callback of the specified window,
+ *  which is called when the cursor is moved.  The callback is provided with the
+ *  position, in screen coordinates, relative to the upper-left corner of the
+ *  content area of the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, double xpos, double ypos);
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWcursorposfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_pos
+ *
+ *  @since Added in version 3.0.  Replaces `glfwSetMousePosCallback`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun callback);
+
+/*! @brief Sets the cursor enter/leave callback.
+ *
+ *  This function sets the cursor boundary crossing callback of the specified
+ *  window, which is called when the cursor enters or leaves the content area of
+ *  the window.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int entered)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWcursorenterfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref cursor_enter
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback);
+
+/*! @brief Sets the scroll callback.
+ *
+ *  This function sets the scroll callback of the specified window, which is
+ *  called when a scrolling device is used, such as a mouse wheel or scrolling
+ *  area of a touchpad.
+ *
+ *  The scroll callback receives all scrolling input, like that from a mouse
+ *  wheel or a touchpad scrolling area.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new scroll callback, or `NULL` to remove the
+ *  currently set callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, double xoffset, double yoffset)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWscrollfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref scrolling
+ *
+ *  @since Added in version 3.0.  Replaces `glfwSetMouseWheelCallback`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun callback);
+
+/*! @brief Sets the path drop callback.
+ *
+ *  This function sets the path drop callback of the specified window, which is
+ *  called when one or more dragged paths are dropped on the window.
+ *
+ *  Because the path array and its strings may have been generated specifically
+ *  for that event, they are not guaranteed to be valid after the callback has
+ *  returned.  If you wish to use them after the callback returns, you need to
+ *  make a deep copy.
+ *
+ *  @param[in] window The window whose callback to set.
+ *  @param[in] callback The new file drop callback, or `NULL` to remove the
+ *  currently set callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(GLFWwindow* window, int path_count, const char* paths[])
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWdropfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @remark @wayland File drop is currently unimplemented.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref path_drop
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun callback);
+
+/*! @brief Returns whether the specified joystick is present.
+ *
+ *  This function returns whether the specified joystick is present.
+ *
+ *  There is no need to call this function before other functions that accept
+ *  a joystick ID, as they all check for presence before performing any other
+ *  work.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @return `GLFW_TRUE` if the joystick is present, or `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetJoystickParam`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwJoystickPresent(int jid);
+
+/*! @brief Returns the values of all axes of the specified joystick.
+ *
+ *  This function returns the values of all axes of the specified joystick.
+ *  Each element in the array is a value between -1.0 and 1.0.
+ *
+ *  If the specified joystick is not present this function will return `NULL`
+ *  but will not generate an error.  This can be used instead of first calling
+ *  @ref glfwJoystickPresent.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @param[out] count Where to store the number of axis values in the returned
+ *  array.  This is set to zero if the joystick is not present or an error
+ *  occurred.
+ *  @return An array of axis values, or `NULL` if the joystick is not present or
+ *  an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_axis
+ *
+ *  @since Added in version 3.0.  Replaces `glfwGetJoystickPos`.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count);
+
+/*! @brief Returns the state of all buttons of the specified joystick.
+ *
+ *  This function returns the state of all buttons of the specified joystick.
+ *  Each element in the array is either `GLFW_PRESS` or `GLFW_RELEASE`.
+ *
+ *  For backward compatibility with earlier versions that did not have @ref
+ *  glfwGetJoystickHats, the button array also includes all hats, each
+ *  represented as four buttons.  The hats are in the same order as returned by
+ *  __glfwGetJoystickHats__ and are in the order _up_, _right_, _down_ and
+ *  _left_.  To disable these extra buttons, set the @ref
+ *  GLFW_JOYSTICK_HAT_BUTTONS init hint before initialization.
+ *
+ *  If the specified joystick is not present this function will return `NULL`
+ *  but will not generate an error.  This can be used instead of first calling
+ *  @ref glfwJoystickPresent.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @param[out] count Where to store the number of button states in the returned
+ *  array.  This is set to zero if the joystick is not present or an error
+ *  occurred.
+ *  @return An array of button states, or `NULL` if the joystick is not present
+ *  or an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_button
+ *
+ *  @since Added in version 2.2.
+ *  @glfw3 Changed to return a dynamic array.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count);
+
+/*! @brief Returns the state of all hats of the specified joystick.
+ *
+ *  This function returns the state of all hats of the specified joystick.
+ *  Each element in the array is one of the following values:
+ *
+ *  Name                  | Value
+ *  ----                  | -----
+ *  `GLFW_HAT_CENTERED`   | 0
+ *  `GLFW_HAT_UP`         | 1
+ *  `GLFW_HAT_RIGHT`      | 2
+ *  `GLFW_HAT_DOWN`       | 4
+ *  `GLFW_HAT_LEFT`       | 8
+ *  `GLFW_HAT_RIGHT_UP`   | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP`
+ *  `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN`
+ *  `GLFW_HAT_LEFT_UP`    | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP`
+ *  `GLFW_HAT_LEFT_DOWN`  | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN`
+ *
+ *  The diagonal directions are bitwise combinations of the primary (up, right,
+ *  down and left) directions and you can test for these individually by ANDing
+ *  it with the corresponding direction.
+ *
+ *  @code
+ *  if (hats[2] & GLFW_HAT_RIGHT)
+ *  {
+ *      // State of hat 2 could be right-up, right or right-down
+ *  }
+ *  @endcode
+ *
+ *  If the specified joystick is not present this function will return `NULL`
+ *  but will not generate an error.  This can be used instead of first calling
+ *  @ref glfwJoystickPresent.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @param[out] count Where to store the number of hat states in the returned
+ *  array.  This is set to zero if the joystick is not present or an error
+ *  occurred.
+ *  @return An array of hat states, or `NULL` if the joystick is not present
+ *  or an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected, this function is called again for that joystick or the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_hat
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const unsigned char* glfwGetJoystickHats(int jid, int* count);
+
+/*! @brief Returns the name of the specified joystick.
+ *
+ *  This function returns the name, encoded as UTF-8, of the specified joystick.
+ *  The returned string is allocated and freed by GLFW.  You should not free it
+ *  yourself.
+ *
+ *  If the specified joystick is not present this function will return `NULL`
+ *  but will not generate an error.  This can be used instead of first calling
+ *  @ref glfwJoystickPresent.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @return The UTF-8 encoded name of the joystick, or `NULL` if the joystick
+ *  is not present or an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_name
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetJoystickName(int jid);
+
+/*! @brief Returns the SDL compatible GUID of the specified joystick.
+ *
+ *  This function returns the SDL compatible GUID, as a UTF-8 encoded
+ *  hexadecimal string, of the specified joystick.  The returned string is
+ *  allocated and freed by GLFW.  You should not free it yourself.
+ *
+ *  The GUID is what connects a joystick to a gamepad mapping.  A connected
+ *  joystick will always have a GUID even if there is no gamepad mapping
+ *  assigned to it.
+ *
+ *  If the specified joystick is not present this function will return `NULL`
+ *  but will not generate an error.  This can be used instead of first calling
+ *  @ref glfwJoystickPresent.
+ *
+ *  The GUID uses the format introduced in SDL 2.0.5.  This GUID tries to
+ *  uniquely identify the make and model of a joystick but does not identify
+ *  a specific unit, e.g. all wired Xbox 360 controllers will have the same
+ *  GUID on that platform.  The GUID for a unit may vary between platforms
+ *  depending on what hardware information the platform specific APIs provide.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @return The UTF-8 encoded GUID of the joystick, or `NULL` if the joystick
+ *  is not present or an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref gamepad
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetJoystickGUID(int jid);
+
+/*! @brief Sets the user pointer of the specified joystick.
+ *
+ *  This function sets the user-defined pointer of the specified joystick.  The
+ *  current value is retained until the joystick is disconnected.  The initial
+ *  value is `NULL`.
+ *
+ *  This function may be called from the joystick callback, even for a joystick
+ *  that is being disconnected.
+ *
+ *  @param[in] jid The joystick whose pointer to set.
+ *  @param[in] pointer The new value.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref joystick_userptr
+ *  @sa @ref glfwGetJoystickUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer);
+
+/*! @brief Returns the user pointer of the specified joystick.
+ *
+ *  This function returns the current value of the user-defined pointer of the
+ *  specified joystick.  The initial value is `NULL`.
+ *
+ *  This function may be called from the joystick callback, even for a joystick
+ *  that is being disconnected.
+ *
+ *  @param[in] jid The joystick whose pointer to return.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @sa @ref joystick_userptr
+ *  @sa @ref glfwSetJoystickUserPointer
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void* glfwGetJoystickUserPointer(int jid);
+
+/*! @brief Returns whether the specified joystick has a gamepad mapping.
+ *
+ *  This function returns whether the specified joystick is both present and has
+ *  a gamepad mapping.
+ *
+ *  If the specified joystick is present but does not have a gamepad mapping
+ *  this function will return `GLFW_FALSE` but will not generate an error.  Call
+ *  @ref glfwJoystickPresent to check if a joystick is present regardless of
+ *  whether it has a mapping.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @return `GLFW_TRUE` if a joystick is both present and has a gamepad mapping,
+ *  or `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref gamepad
+ *  @sa @ref glfwGetGamepadState
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwJoystickIsGamepad(int jid);
+
+/*! @brief Sets the joystick configuration callback.
+ *
+ *  This function sets the joystick configuration callback, or removes the
+ *  currently set callback.  This is called when a joystick is connected to or
+ *  disconnected from the system.
+ *
+ *  For joystick connection and disconnection events to be delivered on all
+ *  platforms, you need to call one of the [event processing](@ref events)
+ *  functions.  Joystick disconnection may also be detected and the callback
+ *  called by joystick functions.  The function will then return whatever it
+ *  returns if the joystick is not present.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(int jid, int event)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWjoystickfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_event
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun callback);
+
+/*! @brief Adds the specified SDL_GameControllerDB gamepad mappings.
+ *
+ *  This function parses the specified ASCII encoded string and updates the
+ *  internal list with any gamepad mappings it finds.  This string may
+ *  contain either a single gamepad mapping or many mappings separated by
+ *  newlines.  The parser supports the full format of the `gamecontrollerdb.txt`
+ *  source file including empty lines and comments.
+ *
+ *  See @ref gamepad_mapping for a description of the format.
+ *
+ *  If there is already a gamepad mapping for a given GUID in the internal list,
+ *  it will be replaced by the one passed to this function.  If the library is
+ *  terminated and re-initialized the internal list will revert to the built-in
+ *  default.
+ *
+ *  @param[in] string The string containing the gamepad mappings.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_VALUE.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref gamepad
+ *  @sa @ref glfwJoystickIsGamepad
+ *  @sa @ref glfwGetGamepadName
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwUpdateGamepadMappings(const char* string);
+
+/*! @brief Returns the human-readable gamepad name for the specified joystick.
+ *
+ *  This function returns the human-readable name of the gamepad from the
+ *  gamepad mapping assigned to the specified joystick.
+ *
+ *  If the specified joystick is not present or does not have a gamepad mapping
+ *  this function will return `NULL` but will not generate an error.  Call
+ *  @ref glfwJoystickPresent to check whether it is present regardless of
+ *  whether it has a mapping.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @return The UTF-8 encoded name of the gamepad, or `NULL` if the
+ *  joystick is not present, does not have a mapping or an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the specified joystick is
+ *  disconnected, the gamepad mappings are updated or the library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref gamepad
+ *  @sa @ref glfwJoystickIsGamepad
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetGamepadName(int jid);
+
+/*! @brief Retrieves the state of the specified joystick remapped as a gamepad.
+ *
+ *  This function retrieves the state of the specified joystick remapped to
+ *  an Xbox-like gamepad.
+ *
+ *  If the specified joystick is not present or does not have a gamepad mapping
+ *  this function will return `GLFW_FALSE` but will not generate an error.  Call
+ *  @ref glfwJoystickPresent to check whether it is present regardless of
+ *  whether it has a mapping.
+ *
+ *  The Guide button may not be available for input as it is often hooked by the
+ *  system or the Steam client.
+ *
+ *  Not all devices have all the buttons or axes provided by @ref
+ *  GLFWgamepadstate.  Unavailable buttons and axes will always report
+ *  `GLFW_RELEASE` and 0.0 respectively.
+ *
+ *  @param[in] jid The [joystick](@ref joysticks) to query.
+ *  @param[out] state The gamepad input state of the joystick.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if no joystick is
+ *  connected, it has no gamepad mapping or an [error](@ref error_handling)
+ *  occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_ENUM.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref gamepad
+ *  @sa @ref glfwUpdateGamepadMappings
+ *  @sa @ref glfwJoystickIsGamepad
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup input
+ */
+GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state);
+
+/*! @brief Sets the clipboard to the specified string.
+ *
+ *  This function sets the system clipboard to the specified, UTF-8 encoded
+ *  string.
+ *
+ *  @param[in] window Deprecated.  Any valid window or `NULL`.
+ *  @param[in] string A UTF-8 encoded string.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified string is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa @ref glfwGetClipboardString
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string);
+
+/*! @brief Returns the contents of the clipboard as a string.
+ *
+ *  This function returns the contents of the system clipboard, if it contains
+ *  or is convertible to a UTF-8 encoded string.  If the clipboard is empty or
+ *  if its contents cannot be converted, `NULL` is returned and a @ref
+ *  GLFW_FORMAT_UNAVAILABLE error is generated.
+ *
+ *  @param[in] window Deprecated.  Any valid window or `NULL`.
+ *  @return The contents of the clipboard as a UTF-8 encoded string, or `NULL`
+ *  if an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is valid until the next call to @ref
+ *  glfwGetClipboardString or @ref glfwSetClipboardString, or until the library
+ *  is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa @ref glfwSetClipboardString
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window);
+
+/*! @brief Returns the GLFW time.
+ *
+ *  This function returns the current GLFW time, in seconds.  Unless the time
+ *  has been set using @ref glfwSetTime it measures time elapsed since GLFW was
+ *  initialized.
+ *
+ *  This function and @ref glfwSetTime are helper functions on top of @ref
+ *  glfwGetTimerFrequency and @ref glfwGetTimerValue.
+ *
+ *  The resolution of the timer is system dependent, but is usually on the order
+ *  of a few micro- or nanoseconds.  It uses the highest-resolution monotonic
+ *  time source on each supported platform.
+ *
+ *  @return The current time, in seconds, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.  Reading and
+ *  writing of the internal base time is not atomic, so it needs to be
+ *  externally synchronized with calls to @ref glfwSetTime.
+ *
+ *  @sa @ref time
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup input
+ */
+GLFWAPI double glfwGetTime(void);
+
+/*! @brief Sets the GLFW time.
+ *
+ *  This function sets the current GLFW time, in seconds.  The value must be
+ *  a positive finite number less than or equal to 18446744073.0, which is
+ *  approximately 584.5 years.
+ *
+ *  This function and @ref glfwGetTime are helper functions on top of @ref
+ *  glfwGetTimerFrequency and @ref glfwGetTimerValue.
+ *
+ *  @param[in] time The new value, in seconds.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_INVALID_VALUE.
+ *
+ *  @remark The upper limit of GLFW time is calculated as
+ *  floor((2<sup>64</sup> - 1) / 10<sup>9</sup>) and is due to implementations
+ *  storing nanoseconds in 64 bits.  The limit may be increased in the future.
+ *
+ *  @thread_safety This function may be called from any thread.  Reading and
+ *  writing of the internal base time is not atomic, so it needs to be
+ *  externally synchronized with calls to @ref glfwGetTime.
+ *
+ *  @sa @ref time
+ *
+ *  @since Added in version 2.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI void glfwSetTime(double time);
+
+/*! @brief Returns the current value of the raw timer.
+ *
+ *  This function returns the current value of the raw timer, measured in
+ *  1&nbsp;/&nbsp;frequency seconds.  To get the frequency, call @ref
+ *  glfwGetTimerFrequency.
+ *
+ *  @return The value of the timer, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref time
+ *  @sa @ref glfwGetTimerFrequency
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI uint64_t glfwGetTimerValue(void);
+
+/*! @brief Returns the frequency, in Hz, of the raw timer.
+ *
+ *  This function returns the frequency, in Hz, of the raw timer.
+ *
+ *  @return The frequency of the timer, in Hz, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref time
+ *  @sa @ref glfwGetTimerValue
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI uint64_t glfwGetTimerFrequency(void);
+
+/*! @brief Makes the context of the specified window current for the calling
+ *  thread.
+ *
+ *  This function makes the OpenGL or OpenGL ES context of the specified window
+ *  current on the calling thread.  A context must only be made current on
+ *  a single thread at a time and each thread can have only a single current
+ *  context at a time.
+ *
+ *  When moving a context between threads, you must make it non-current on the
+ *  old thread before making it current on the new one.
+ *
+ *  By default, making a context non-current implicitly forces a pipeline flush.
+ *  On machines that support `GL_KHR_context_flush_control`, you can control
+ *  whether a context performs this flush by setting the
+ *  [GLFW_CONTEXT_RELEASE_BEHAVIOR](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint)
+ *  hint.
+ *
+ *  The specified window must have an OpenGL or OpenGL ES context.  Specifying
+ *  a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT
+ *  error.
+ *
+ *  @param[in] window The window whose context to make current, or `NULL` to
+ *  detach the current context.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_current
+ *  @sa @ref glfwGetCurrentContext
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI void glfwMakeContextCurrent(GLFWwindow* window);
+
+/*! @brief Returns the window whose context is current on the calling thread.
+ *
+ *  This function returns the window whose OpenGL or OpenGL ES context is
+ *  current on the calling thread.
+ *
+ *  @return The window whose context is current, or `NULL` if no window's
+ *  context is current.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_current
+ *  @sa @ref glfwMakeContextCurrent
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI GLFWwindow* glfwGetCurrentContext(void);
+
+/*! @brief Swaps the front and back buffers of the specified window.
+ *
+ *  This function swaps the front and back buffers of the specified window when
+ *  rendering with OpenGL or OpenGL ES.  If the swap interval is greater than
+ *  zero, the GPU driver waits the specified number of screen updates before
+ *  swapping the buffers.
+ *
+ *  The specified window must have an OpenGL or OpenGL ES context.  Specifying
+ *  a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT
+ *  error.
+ *
+ *  This function does not apply to Vulkan.  If you are rendering with Vulkan,
+ *  see `vkQueuePresentKHR` instead.
+ *
+ *  @param[in] window The window whose buffers to swap.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark __EGL:__ The context of the specified window must be current on the
+ *  calling thread.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref buffer_swap
+ *  @sa @ref glfwSwapInterval
+ *
+ *  @since Added in version 1.0.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup window
+ */
+GLFWAPI void glfwSwapBuffers(GLFWwindow* window);
+
+/*! @brief Sets the swap interval for the current context.
+ *
+ *  This function sets the swap interval for the current OpenGL or OpenGL ES
+ *  context, i.e. the number of screen updates to wait from the time @ref
+ *  glfwSwapBuffers was called before swapping the buffers and returning.  This
+ *  is sometimes called _vertical synchronization_, _vertical retrace
+ *  synchronization_ or just _vsync_.
+ *
+ *  A context that supports either of the `WGL_EXT_swap_control_tear` and
+ *  `GLX_EXT_swap_control_tear` extensions also accepts _negative_ swap
+ *  intervals, which allows the driver to swap immediately even if a frame
+ *  arrives a little bit late.  You can check for these extensions with @ref
+ *  glfwExtensionSupported.
+ *
+ *  A context must be current on the calling thread.  Calling this function
+ *  without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+ *
+ *  This function does not apply to Vulkan.  If you are rendering with Vulkan,
+ *  see the present mode of your swapchain instead.
+ *
+ *  @param[in] interval The minimum number of screen updates to wait for
+ *  until the buffers are swapped by @ref glfwSwapBuffers.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark This function is not called during context creation, leaving the
+ *  swap interval set to whatever is the default on that platform.  This is done
+ *  because some swap interval extensions used by GLFW do not allow the swap
+ *  interval to be reset to zero once it has been set to a non-zero value.
+ *
+ *  @remark Some GPU drivers do not honor the requested swap interval, either
+ *  because of a user setting that overrides the application's request or due to
+ *  bugs in the driver.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref buffer_swap
+ *  @sa @ref glfwSwapBuffers
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI void glfwSwapInterval(int interval);
+
+/*! @brief Returns whether the specified extension is available.
+ *
+ *  This function returns whether the specified
+ *  [API extension](@ref context_glext) is supported by the current OpenGL or
+ *  OpenGL ES context.  It searches both for client API extension and context
+ *  creation API extensions.
+ *
+ *  A context must be current on the calling thread.  Calling this function
+ *  without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+ *
+ *  As this functions retrieves and searches one or more extension strings each
+ *  call, it is recommended that you cache its results if it is going to be used
+ *  frequently.  The extension strings will not change during the lifetime of
+ *  a context, so there is no danger in doing this.
+ *
+ *  This function does not apply to Vulkan.  If you are using Vulkan, see @ref
+ *  glfwGetRequiredInstanceExtensions, `vkEnumerateInstanceExtensionProperties`
+ *  and `vkEnumerateDeviceExtensionProperties` instead.
+ *
+ *  @param[in] extension The ASCII encoded name of the extension.
+ *  @return `GLFW_TRUE` if the extension is available, or `GLFW_FALSE`
+ *  otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_CURRENT_CONTEXT, @ref GLFW_INVALID_VALUE and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_glext
+ *  @sa @ref glfwGetProcAddress
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI int glfwExtensionSupported(const char* extension);
+
+/*! @brief Returns the address of the specified function for the current
+ *  context.
+ *
+ *  This function returns the address of the specified OpenGL or OpenGL ES
+ *  [core or extension function](@ref context_glext), if it is supported
+ *  by the current context.
+ *
+ *  A context must be current on the calling thread.  Calling this function
+ *  without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error.
+ *
+ *  This function does not apply to Vulkan.  If you are rendering with Vulkan,
+ *  see @ref glfwGetInstanceProcAddress, `vkGetInstanceProcAddr` and
+ *  `vkGetDeviceProcAddr` instead.
+ *
+ *  @param[in] procname The ASCII encoded name of the function.
+ *  @return The address of the function, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark The address of a given function is not guaranteed to be the same
+ *  between contexts.
+ *
+ *  @remark This function may return a non-`NULL` address despite the
+ *  associated version or extension not being available.  Always check the
+ *  context version or extension string first.
+ *
+ *  @pointer_lifetime The returned function pointer is valid until the context
+ *  is destroyed or the library is terminated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref context_glext
+ *  @sa @ref glfwExtensionSupported
+ *
+ *  @since Added in version 1.0.
+ *
+ *  @ingroup context
+ */
+GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname);
+
+/*! @brief Returns whether the Vulkan loader and an ICD have been found.
+ *
+ *  This function returns whether the Vulkan loader and any minimally functional
+ *  ICD have been found.
+ *
+ *  The availability of a Vulkan loader and even an ICD does not by itself
+ *  guarantee that surface creation or even instance creation is possible.
+ *  For example, on Fermi systems Nvidia will install an ICD that provides no
+ *  actual Vulkan support.  Call @ref glfwGetRequiredInstanceExtensions to check
+ *  whether the extensions necessary for Vulkan surface creation are available
+ *  and @ref glfwGetPhysicalDevicePresentationSupport to check whether a queue
+ *  family of a physical device supports image presentation.
+ *
+ *  @return `GLFW_TRUE` if Vulkan is minimally available, or `GLFW_FALSE`
+ *  otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref vulkan_support
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI int glfwVulkanSupported(void);
+
+/*! @brief Returns the Vulkan instance extensions required by GLFW.
+ *
+ *  This function returns an array of names of Vulkan instance extensions required
+ *  by GLFW for creating Vulkan surfaces for GLFW windows.  If successful, the
+ *  list will always contain `VK_KHR_surface`, so if you don't require any
+ *  additional extensions you can pass this list directly to the
+ *  `VkInstanceCreateInfo` struct.
+ *
+ *  If Vulkan is not available on the machine, this function returns `NULL` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
+ *  to check whether Vulkan is at least minimally available.
+ *
+ *  If Vulkan is available but no set of extensions allowing window surface
+ *  creation was found, this function returns `NULL`.  You may still use Vulkan
+ *  for off-screen rendering and compute work.
+ *
+ *  @param[out] count Where to store the number of extensions in the returned
+ *  array.  This is set to zero if an error occurred.
+ *  @return An array of ASCII encoded extension names, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_API_UNAVAILABLE.
+ *
+ *  @remark Additional extensions may be required by future versions of GLFW.
+ *  You should check if any extensions you wish to enable are already in the
+ *  returned array, as it is an error to specify an extension more than once in
+ *  the `VkInstanceCreateInfo` struct.
+ *
+ *  @remark @macos GLFW currently supports both the `VK_MVK_macos_surface` and
+ *  the newer `VK_EXT_metal_surface` extensions.
+ *
+ *  @pointer_lifetime The returned array is allocated and freed by GLFW.  You
+ *  should not free it yourself.  It is guaranteed to be valid only until the
+ *  library is terminated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref vulkan_ext
+ *  @sa @ref glfwCreateWindowSurface
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count);
+
+#if defined(VK_VERSION_1_0)
+
+/*! @brief Returns the address of the specified Vulkan instance function.
+ *
+ *  This function returns the address of the specified Vulkan core or extension
+ *  function for the specified instance.  If instance is set to `NULL` it can
+ *  return any function exported from the Vulkan loader, including at least the
+ *  following functions:
+ *
+ *  - `vkEnumerateInstanceExtensionProperties`
+ *  - `vkEnumerateInstanceLayerProperties`
+ *  - `vkCreateInstance`
+ *  - `vkGetInstanceProcAddr`
+ *
+ *  If Vulkan is not available on the machine, this function returns `NULL` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
+ *  to check whether Vulkan is at least minimally available.
+ *
+ *  This function is equivalent to calling `vkGetInstanceProcAddr` with
+ *  a platform-specific query of the Vulkan loader as a fallback.
+ *
+ *  @param[in] instance The Vulkan instance to query, or `NULL` to retrieve
+ *  functions related to instance creation.
+ *  @param[in] procname The ASCII encoded name of the function.
+ *  @return The address of the function, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_API_UNAVAILABLE.
+ *
+ *  @pointer_lifetime The returned function pointer is valid until the library
+ *  is terminated.
+ *
+ *  @thread_safety This function may be called from any thread.
+ *
+ *  @sa @ref vulkan_proc
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname);
+
+/*! @brief Returns whether the specified queue family can present images.
+ *
+ *  This function returns whether the specified queue family of the specified
+ *  physical device supports presentation to the platform GLFW was built for.
+ *
+ *  If Vulkan or the required window surface creation instance extensions are
+ *  not available on the machine, or if the specified instance was not created
+ *  with the required extensions, this function returns `GLFW_FALSE` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported
+ *  to check whether Vulkan is at least minimally available and @ref
+ *  glfwGetRequiredInstanceExtensions to check what instance extensions are
+ *  required.
+ *
+ *  @param[in] instance The instance that the physical device belongs to.
+ *  @param[in] device The physical device that the queue family belongs to.
+ *  @param[in] queuefamily The index of the queue family to query.
+ *  @return `GLFW_TRUE` if the queue family supports presentation, or
+ *  `GLFW_FALSE` otherwise.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR.
+ *
+ *  @remark @macos This function currently always returns `GLFW_TRUE`, as the
+ *  `VK_MVK_macos_surface` and `VK_EXT_metal_surface` extensions do not provide
+ *  a `vkGetPhysicalDevice*PresentationSupport` type function.
+ *
+ *  @thread_safety This function may be called from any thread.  For
+ *  synchronization details of Vulkan objects, see the Vulkan specification.
+ *
+ *  @sa @ref vulkan_present
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily);
+
+/*! @brief Creates a Vulkan surface for the specified window.
+ *
+ *  This function creates a Vulkan surface for the specified window.
+ *
+ *  If the Vulkan loader or at least one minimally functional ICD were not found,
+ *  this function returns `VK_ERROR_INITIALIZATION_FAILED` and generates a @ref
+ *  GLFW_API_UNAVAILABLE error.  Call @ref glfwVulkanSupported to check whether
+ *  Vulkan is at least minimally available.
+ *
+ *  If the required window surface creation instance extensions are not
+ *  available or if the specified instance was not created with these extensions
+ *  enabled, this function returns `VK_ERROR_EXTENSION_NOT_PRESENT` and
+ *  generates a @ref GLFW_API_UNAVAILABLE error.  Call @ref
+ *  glfwGetRequiredInstanceExtensions to check what instance extensions are
+ *  required.
+ *
+ *  The window surface cannot be shared with another API so the window must
+ *  have been created with the [client api hint](@ref GLFW_CLIENT_API_attrib)
+ *  set to `GLFW_NO_API` otherwise it generates a @ref GLFW_INVALID_VALUE error
+ *  and returns `VK_ERROR_NATIVE_WINDOW_IN_USE_KHR`.
+ *
+ *  The window surface must be destroyed before the specified Vulkan instance.
+ *  It is the responsibility of the caller to destroy the window surface.  GLFW
+ *  does not destroy it for you.  Call `vkDestroySurfaceKHR` to destroy the
+ *  surface.
+ *
+ *  @param[in] instance The Vulkan instance to create the surface in.
+ *  @param[in] window The window to create the surface for.
+ *  @param[in] allocator The allocator to use, or `NULL` to use the default
+ *  allocator.
+ *  @param[out] surface Where to store the handle of the surface.  This is set
+ *  to `VK_NULL_HANDLE` if an error occurred.
+ *  @return `VK_SUCCESS` if successful, or a Vulkan error code if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
+ *  GLFW_API_UNAVAILABLE, @ref GLFW_PLATFORM_ERROR and @ref GLFW_INVALID_VALUE
+ *
+ *  @remark If an error occurs before the creation call is made, GLFW returns
+ *  the Vulkan error code most appropriate for the error.  Appropriate use of
+ *  @ref glfwVulkanSupported and @ref glfwGetRequiredInstanceExtensions should
+ *  eliminate almost all occurrences of these errors.
+ *
+ *  @remark @macos This function currently only supports the
+ *  `VK_MVK_macos_surface` extension from MoltenVK.
+ *
+ *  @remark @macos This function creates and sets a `CAMetalLayer` instance for
+ *  the window content view, which is required for MoltenVK to function.
+ *
+ *  @remark @x11 GLFW by default attempts to use the `VK_KHR_xcb_surface`
+ *  extension, if available.  You can make it prefer the `VK_KHR_xlib_surface`
+ *  extension by setting the
+ *  [GLFW_X11_XCB_VULKAN_SURFACE](@ref GLFW_X11_XCB_VULKAN_SURFACE_hint) init
+ *  hint.
+ *
+ *  @thread_safety This function may be called from any thread.  For
+ *  synchronization details of Vulkan objects, see the Vulkan specification.
+ *
+ *  @sa @ref vulkan_surface
+ *  @sa @ref glfwGetRequiredInstanceExtensions
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup vulkan
+ */
+GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
+
+#endif /*VK_VERSION_1_0*/
+
+
+/*************************************************************************
+ * Global definition cleanup
+ *************************************************************************/
+
+/* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */
+
+#ifdef GLFW_WINGDIAPI_DEFINED
+ #undef WINGDIAPI
+ #undef GLFW_WINGDIAPI_DEFINED
+#endif
+
+#ifdef GLFW_CALLBACK_DEFINED
+ #undef CALLBACK
+ #undef GLFW_CALLBACK_DEFINED
+#endif
+
+/* Some OpenGL related headers need GLAPIENTRY, but it is unconditionally
+ * defined by some gl.h variants (OpenBSD) so define it after if needed.
+ */
+#ifndef GLAPIENTRY
+ #define GLAPIENTRY APIENTRY
+#endif
+
+/* -------------------- END SYSTEM/COMPILER SPECIFIC --------------------- */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _glfw3_h_ */
+
+ rlImGui/raylib/src/external/glfw/include/GLFW/glfw3native.h view
@@ -0,0 +1,530 @@+/*************************************************************************
+ * GLFW 3.4 - www.glfw.org
+ * A library for OpenGL, window and input
+ *------------------------------------------------------------------------
+ * Copyright (c) 2002-2006 Marcus Geelnard
+ * Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.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 _glfw3_native_h_
+#define _glfw3_native_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************
+ * Doxygen documentation
+ *************************************************************************/
+
+/*! @file glfw3native.h
+ *  @brief The header of the native access functions.
+ *
+ *  This is the header file of the native access functions.  See @ref native for
+ *  more information.
+ */
+/*! @defgroup native Native access
+ *  @brief Functions related to accessing native handles.
+ *
+ *  **By using the native access functions you assert that you know what you're
+ *  doing and how to fix problems caused by using them.  If you don't, you
+ *  shouldn't be using them.**
+ *
+ *  Before the inclusion of @ref glfw3native.h, you may define zero or more
+ *  window system API macro and zero or more context creation API macros.
+ *
+ *  The chosen backends must match those the library was compiled for.  Failure
+ *  to do this will cause a link-time error.
+ *
+ *  The available window API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WIN32`
+ *  * `GLFW_EXPOSE_NATIVE_COCOA`
+ *  * `GLFW_EXPOSE_NATIVE_X11`
+ *  * `GLFW_EXPOSE_NATIVE_WAYLAND`
+ *
+ *  The available context API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WGL`
+ *  * `GLFW_EXPOSE_NATIVE_NSGL`
+ *  * `GLFW_EXPOSE_NATIVE_GLX`
+ *  * `GLFW_EXPOSE_NATIVE_EGL`
+ *  * `GLFW_EXPOSE_NATIVE_OSMESA`
+ *
+ *  These macros select which of the native access functions that are declared
+ *  and which platform-specific headers to include.  It is then up your (by
+ *  definition platform-specific) code to handle which of these should be
+ *  defined.
+ */
+
+
+/*************************************************************************
+ * System headers and types
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32) || defined(GLFW_EXPOSE_NATIVE_WGL)
+ // This is a workaround for the fact that glfw3.h needs to export APIENTRY (for
+ // example to allow applications to correctly declare a GL_KHR_debug callback)
+ // but windows.h assumes no one will define APIENTRY before it does
+ #if defined(GLFW_APIENTRY_DEFINED)
+  #undef APIENTRY
+  #undef GLFW_APIENTRY_DEFINED
+ #endif
+// @raysan5: Actually, only HWND handler needs to be defined
+// Including windows.h could suppose symbols re-definition issues (i.e Rectangle type)
+//#include <windows.h>
+ typedef void *PVOID;
+ typedef PVOID HANDLE;
+ typedef HANDLE HWND;
+#elif defined(GLFW_EXPOSE_NATIVE_COCOA) || defined(GLFW_EXPOSE_NATIVE_NSGL)
+ #if defined(__OBJC__)
+  #import <Cocoa/Cocoa.h>
+ #else
+  #include <ApplicationServices/ApplicationServices.h>
+  typedef void* id;
+ #endif
+#elif defined(GLFW_EXPOSE_NATIVE_X11) || defined(GLFW_EXPOSE_NATIVE_GLX)
+ #include <X11/Xlib.h>
+ #include <X11/extensions/Xrandr.h>
+#elif defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+ #include <wayland-client.h>
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+ /* WGL is declared by windows.h */
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+ /* NSGL is declared by Cocoa.h */
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+ #include <GL/glx.h>
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+ #include <EGL/egl.h>
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_OSMESA)
+ #include <GL/osmesa.h>
+#endif
+
+
+/*************************************************************************
+ * Functions
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+/*! @brief Returns the adapter device name of the specified monitor.
+ *
+ *  @return The UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`)
+ *  of the specified monitor, or `NULL` if an [error](@ref error_handling)
+ *  occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* monitor);
+
+/*! @brief Returns the display device name of the specified monitor.
+ *
+ *  @return The UTF-8 encoded display device name (for example
+ *  `\\.\DISPLAY1\Monitor0`) of the specified monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `HWND` of the specified window.
+ *
+ *  @return The `HWND` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+/*! @brief Returns the `HGLRC` of the specified window.
+ *
+ *  @return The `HGLRC` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_COCOA)
+/*! @brief Returns the `CGDirectDisplayID` of the specified monitor.
+ *
+ *  @return The `CGDirectDisplayID` of the specified monitor, or
+ *  `kCGNullDirectDisplay` if an [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `NSWindow` of the specified window.
+ *
+ *  @return The `NSWindow` of the specified window, or `nil` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+/*! @brief Returns the `NSOpenGLContext` of the specified window.
+ *
+ *  @return The `NSOpenGLContext` of the specified window, or `nil` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_X11)
+/*! @brief Returns the `Display` used by GLFW.
+ *
+ *  @return The `Display` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI Display* glfwGetX11Display(void);
+
+/*! @brief Returns the `RRCrtc` of the specified monitor.
+ *
+ *  @return The `RRCrtc` of the specified monitor, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor);
+
+/*! @brief Returns the `RROutput` of the specified monitor.
+ *
+ *  @return The `RROutput` of the specified monitor, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `Window` of the specified window.
+ *
+ *  @return The `Window` of the specified window, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
+
+/*! @brief Sets the current primary selection to the specified string.
+ *
+ *  @param[in] string A UTF-8 encoded string.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The specified string is copied before this function
+ *  returns.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa glfwGetX11SelectionString
+ *  @sa glfwSetClipboardString
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI void glfwSetX11SelectionString(const char* string);
+
+/*! @brief Returns the contents of the current primary selection as a string.
+ *
+ *  If the selection is empty or if its contents cannot be converted, `NULL`
+ *  is returned and a @ref GLFW_FORMAT_UNAVAILABLE error is generated.
+ *
+ *  @return The contents of the selection as a UTF-8 encoded string, or `NULL`
+ *  if an [error](@ref error_handling) occurred.
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
+ *  GLFW_PLATFORM_ERROR.
+ *
+ *  @pointer_lifetime The returned string is allocated and freed by GLFW. You
+ *  should not free it yourself. It is valid until the next call to @ref
+ *  glfwGetX11SelectionString or @ref glfwSetX11SelectionString, or until the
+ *  library is terminated.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref clipboard
+ *  @sa glfwSetX11SelectionString
+ *  @sa glfwGetClipboardString
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetX11SelectionString(void);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+/*! @brief Returns the `GLXContext` of the specified window.
+ *
+ *  @return The `GLXContext` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
+
+/*! @brief Returns the `GLXWindow` of the specified window.
+ *
+ *  @return The `GLXWindow` of the specified window, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+/*! @brief Returns the `struct wl_display*` used by GLFW.
+ *
+ *  @return The `struct wl_display*` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_display* glfwGetWaylandDisplay(void);
+
+/*! @brief Returns the `struct wl_output*` of the specified monitor.
+ *
+ *  @return The `struct wl_output*` of the specified monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the main `struct wl_surface*` of the specified window.
+ *
+ *  @return The main `struct wl_surface*` of the specified window, or `NULL` if
+ *  an [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+/*! @brief Returns the `EGLDisplay` used by GLFW.
+ *
+ *  @return The `EGLDisplay` used by GLFW, or `EGL_NO_DISPLAY` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
+
+/*! @brief Returns the `EGLContext` of the specified window.
+ *
+ *  @return The `EGLContext` of the specified window, or `EGL_NO_CONTEXT` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
+
+/*! @brief Returns the `EGLSurface` of the specified window.
+ *
+ *  @return The `EGLSurface` of the specified window, or `EGL_NO_SURFACE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_OSMESA)
+/*! @brief Retrieves the color buffer associated with the specified window.
+ *
+ *  @param[in] window The window whose color buffer to retrieve.
+ *  @param[out] width Where to store the width of the color buffer, or `NULL`.
+ *  @param[out] height Where to store the height of the color buffer, or `NULL`.
+ *  @param[out] format Where to store the OSMesa pixel format of the color
+ *  buffer, or `NULL`.
+ *  @param[out] buffer Where to store the address of the color buffer, or
+ *  `NULL`.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* window, int* width, int* height, int* format, void** buffer);
+
+/*! @brief Retrieves the depth buffer associated with the specified window.
+ *
+ *  @param[in] window The window whose depth buffer to retrieve.
+ *  @param[out] width Where to store the width of the depth buffer, or `NULL`.
+ *  @param[out] height Where to store the height of the depth buffer, or `NULL`.
+ *  @param[out] bytesPerValue Where to store the number of bytes per depth
+ *  buffer element, or `NULL`.
+ *  @param[out] buffer Where to store the address of the depth buffer, or
+ *  `NULL`.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* window, int* width, int* height, int* bytesPerValue, void** buffer);
+
+/*! @brief Returns the `OSMesaContext` of the specified window.
+ *
+ *  @return The `OSMesaContext` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* window);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _glfw3_native_h_ */
+
+ rlImGui/raylib/src/raudio.h view
@@ -0,0 +1,201 @@+/**********************************************************************************************
+*
+*   raudio v1.0 - A simple and easy-to-use audio library based on miniaudio
+*
+*   FEATURES:
+*       - Manage audio device (init/close)
+*       - Load and unload audio files
+*       - Format wave data (sample rate, size, channels)
+*       - Play/Stop/Pause/Resume loaded audio
+*       - Manage mixing channels
+*       - Manage raw audio context
+*
+*   DEPENDENCIES:
+*       miniaudio.h  - Audio device management lib (https://github.com/dr-soft/miniaudio)
+*       stb_vorbis.h - Ogg audio files loading (http://www.nothings.org/stb_vorbis/)
+*       dr_mp3.h     - MP3 audio file loading (https://github.com/mackron/dr_libs)
+*       dr_flac.h    - FLAC audio file loading (https://github.com/mackron/dr_libs)
+*       jar_xm.h     - XM module file loading
+*       jar_mod.h    - MOD audio file loading
+*
+*   CONTRIBUTORS:
+*       David Reid (github: @mackron) (Nov. 2017):
+*           - Complete port to miniaudio library
+*
+*       Joshua Reisenauer (github: @kd7tck) (2015)
+*           - XM audio module support (jar_xm)
+*           - MOD audio module support (jar_mod)
+*           - Mixing channels support
+*           - Raw audio context support
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2014-2022 Ramon Santamaria (@raysan5)
+*
+*   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 RAUDIO_H
+#define RAUDIO_H
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+// Allow custom memory allocators
+#ifndef RL_MALLOC
+    #define RL_MALLOC(sz)       malloc(sz)
+#endif
+#ifndef RL_CALLOC
+    #define RL_CALLOC(n,sz)     calloc(n,sz)
+#endif
+#ifndef RL_FREE
+    #define RL_FREE(p)          free(p)
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+#ifndef __cplusplus
+// Boolean type
+    #if !defined(_STDBOOL_H)
+        typedef enum { false, true } bool;
+        #define _STDBOOL_H
+    #endif
+#endif
+
+// Wave, audio wave data
+typedef struct Wave {
+    unsigned int frameCount;    // Total number of frames (considering channels)
+    unsigned int sampleRate;    // Frequency (samples per second)
+    unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+    unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
+    void *data;                 // Buffer data pointer
+} Wave;
+
+typedef struct rAudioBuffer rAudioBuffer;
+
+// AudioStream, custom audio stream
+typedef struct AudioStream {
+    rAudioBuffer *buffer;       // Pointer to internal data used by the audio system
+
+    unsigned int sampleRate;    // Frequency (samples per second)
+    unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+    unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
+} AudioStream;
+
+// Sound
+typedef struct Sound {
+    AudioStream stream;         // Audio stream
+    unsigned int frameCount;    // Total number of frames (considering channels)
+} Sound;
+
+// Music, audio stream, anything longer than ~10 seconds should be streamed
+typedef struct Music {
+    AudioStream stream;         // Audio stream
+    unsigned int frameCount;    // Total number of frames (considering channels)
+    bool looping;               // Music looping enable
+
+    int ctxType;                // Type of music context (audio filetype)
+    void *ctxData;              // Audio context data, depends on type
+} Music;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+// Audio device management functions
+void InitAudioDevice(void);                                     // Initialize audio device and context
+void CloseAudioDevice(void);                                    // Close the audio device and context
+bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
+void SetMasterVolume(float volume);                             // Set master volume (listener)
+
+// Wave/Sound loading/unloading functions
+Wave LoadWave(const char *fileName);                            // Load wave data from file
+Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. ".wav"
+Sound LoadSound(const char *fileName);                          // Load sound from file
+Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
+void UpdateSound(Sound sound, const void *data, int samplesCount);// Update sound buffer with new data
+void UnloadWave(Wave wave);                                     // Unload wave data
+void UnloadSound(Sound sound);                                  // Unload sound
+bool ExportWave(Wave wave, const char *fileName);               // Export wave data to file, returns true on success
+bool ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h), returns true on success
+
+// Wave/Sound management functions
+void PlaySound(Sound sound);                                    // Play a sound
+void StopSound(Sound sound);                                    // Stop playing a sound
+void PauseSound(Sound sound);                                   // Pause a sound
+void ResumeSound(Sound sound);                                  // Resume a paused sound
+void PlaySoundMulti(Sound sound);                               // Play a sound (using multichannel buffer pool)
+void StopSoundMulti(void);                                      // Stop any sound playing (using multichannel buffer pool)
+int GetSoundsPlaying(void);                                     // Get number of sounds playing in the multichannel
+bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
+void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
+void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
+void SetSoundPan(Sound sound, float pan);                       // Set pan for a sound (0.0 to 1.0, 0.5=center)
+void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels);  // Convert wave data to desired format
+Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
+void WaveCrop(Wave *wave, int initSample, int finalSample);     // Crop a wave to defined samples range
+float *LoadWaveSamples(Wave wave);                              // Load samples data from wave as a floats array
+void UnloadWaveSamples(float *samples);                         // Unload samples data loaded with LoadWaveSamples()
+
+// Music management functions
+Music LoadMusicStream(const char *fileName);                    // Load music stream from file
+Music LoadMusicStreamFromMemory(const char *fileType, unsigned char* data, int dataSize); // Load music stream from data
+void UnloadMusicStream(Music music);                            // Unload music stream
+void PlayMusicStream(Music music);                              // Start music playing
+bool IsMusicStreamPlaying(Music music);                         // Check if music is playing
+void UpdateMusicStream(Music music);                            // Updates buffers for music streaming
+void StopMusicStream(Music music);                              // Stop music playing
+void PauseMusicStream(Music music);                             // Pause music playing
+void ResumeMusicStream(Music music);                            // Resume playing paused music
+void SeekMusicStream(Music music, float position);              // Seek music to a position (in seconds)
+void SetMusicVolume(Music music, float volume);                 // Set volume for music (1.0 is max level)
+void SetMusicPan(Music sound, float pan);                       // Set pan for a music (0.0 to 1.0, 0.5=center)
+void SetMusicPitch(Music music, float pitch);                   // Set pitch for a music (1.0 is base level)
+float GetMusicTimeLength(Music music);                          // Get music time length (in seconds)
+float GetMusicTimePlayed(Music music);                          // Get current music time played (in seconds)
+
+// AudioStream management functions
+AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
+void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); // Update audio stream buffers with data
+void UnloadAudioStream(AudioStream stream);                      // Unload audio stream and free memory
+bool IsAudioStreamProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
+void PlayAudioStream(AudioStream stream);                       // Play audio stream
+void PauseAudioStream(AudioStream stream);                      // Pause audio stream
+void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
+bool IsAudioStreamPlaying(AudioStream stream);                  // Check if audio stream is playing
+void StopAudioStream(AudioStream stream);                       // Stop audio stream
+void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
+void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
+void SetAudioStreamPan(AudioStream strean, float pan);          // Set pan for audio stream  (0.0 to 1.0, 0.5=center)
+void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // RAUDIO_H
+ rlImGui/raylib/src/raylib.h view
@@ -0,0 +1,1569 @@+/**********************************************************************************************
+*
+*   raylib v4.2-dev - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
+*
+*   FEATURES:
+*       - NO external dependencies, all required libraries included with raylib
+*       - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly,
+*                        MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5.
+*       - Written in plain C code (C99) in PascalCase/camelCase notation
+*       - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile)
+*       - Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
+*       - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts)
+*       - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
+*       - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
+*       - Flexible Materials system, supporting classic maps and PBR maps
+*       - Animated 3D models supported (skeletal bones animation) (IQM)
+*       - Shaders support, including Model shaders and Postprocessing shaders
+*       - Powerful math module for Vector, Matrix and Quaternion operations: [raymath]
+*       - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD)
+*       - VR stereo rendering with configurable HMD device parameters
+*       - Bindings to multiple programming languages available!
+*
+*   NOTES:
+*       - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text]
+*       - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2)
+*       - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2)
+*       - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2)
+*
+*   DEPENDENCIES (included):
+*       [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP)
+*       [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP)
+*       [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management
+*
+*   OPTIONAL DEPENDENCIES (included):
+*       [rcore] msf_gif (Miles Fogle) for GIF recording
+*       [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
+*       [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
+*       [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
+*       [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG)
+*       [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms
+*       [rtext] stb_truetype (Sean Barret) for ttf fonts loading
+*       [rtext] stb_rect_pack (Sean Barret) for rectangles packing
+*       [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation
+*       [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL)
+*       [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF)
+*       [raudio] dr_wav (David Reid) for WAV audio file loading
+*       [raudio] dr_flac (David Reid) for FLAC audio file loading
+*       [raudio] dr_mp3 (David Reid) for MP3 audio file loading
+*       [raudio] stb_vorbis (Sean Barret) for OGG audio loading
+*       [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading
+*       [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software:
+*
+*   Copyright (c) 2013-2022 Ramon Santamaria (@raysan5)
+*
+*   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 RAYLIB_H
+#define RAYLIB_H
+
+#include <stdarg.h>     // Required for: va_list - Only used by TraceLogCallback
+
+#define RAYLIB_VERSION  "4.2-dev"
+
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+#if defined(_WIN32)
+    #if defined(BUILD_LIBTYPE_SHARED)
+        #define RLAPI __declspec(dllexport)     // We are building the library as a Win32 shared library (.dll)
+    #elif defined(USE_LIBTYPE_SHARED)
+        #define RLAPI __declspec(dllimport)     // We are using the library as a Win32 shared library (.dll)
+    #endif
+#endif
+
+#ifndef RLAPI
+    #define RLAPI       // Functions defined as 'extern' by default (implicit specifiers)
+#endif
+
+//----------------------------------------------------------------------------------
+// Some basic Defines
+//----------------------------------------------------------------------------------
+#ifndef PI
+    #define PI 3.14159265358979323846f
+#endif
+#ifndef DEG2RAD
+    #define DEG2RAD (PI/180.0f)
+#endif
+#ifndef RAD2DEG
+    #define RAD2DEG (180.0f/PI)
+#endif
+
+// Allow custom memory allocators
+#ifndef RL_MALLOC
+    #define RL_MALLOC(sz)       malloc(sz)
+#endif
+#ifndef RL_CALLOC
+    #define RL_CALLOC(n,sz)     calloc(n,sz)
+#endif
+#ifndef RL_REALLOC
+    #define RL_REALLOC(ptr,sz)  realloc(ptr,sz)
+#endif
+#ifndef RL_FREE
+    #define RL_FREE(ptr)        free(ptr)
+#endif
+
+// NOTE: MSVC C++ compiler does not support compound literals (C99 feature)
+// Plain structures in C++ (without constructors) can be initialized with { }
+#if defined(__cplusplus)
+    #define CLITERAL(type)      type
+#else
+    #define CLITERAL(type)      (type)
+#endif
+
+// NOTE: We set some defines with some data types declared by raylib
+// Other modules (raymath, rlgl) also require some of those types, so,
+// to be able to use those other modules as standalone (not depending on raylib)
+// this defines are very useful for internal check and avoid type (re)definitions
+#define RL_COLOR_TYPE
+#define RL_RECTANGLE_TYPE
+#define RL_VECTOR2_TYPE
+#define RL_VECTOR3_TYPE
+#define RL_VECTOR4_TYPE
+#define RL_QUATERNION_TYPE
+#define RL_MATRIX_TYPE
+
+// Some Basic Colors
+// NOTE: Custom raylib color palette for amazing visuals on WHITE background
+#define LIGHTGRAY  CLITERAL(Color){ 200, 200, 200, 255 }   // Light Gray
+#define GRAY       CLITERAL(Color){ 130, 130, 130, 255 }   // Gray
+#define DARKGRAY   CLITERAL(Color){ 80, 80, 80, 255 }      // Dark Gray
+#define YELLOW     CLITERAL(Color){ 253, 249, 0, 255 }     // Yellow
+#define GOLD       CLITERAL(Color){ 255, 203, 0, 255 }     // Gold
+#define ORANGE     CLITERAL(Color){ 255, 161, 0, 255 }     // Orange
+#define PINK       CLITERAL(Color){ 255, 109, 194, 255 }   // Pink
+#define RED        CLITERAL(Color){ 230, 41, 55, 255 }     // Red
+#define MAROON     CLITERAL(Color){ 190, 33, 55, 255 }     // Maroon
+#define GREEN      CLITERAL(Color){ 0, 228, 48, 255 }      // Green
+#define LIME       CLITERAL(Color){ 0, 158, 47, 255 }      // Lime
+#define DARKGREEN  CLITERAL(Color){ 0, 117, 44, 255 }      // Dark Green
+#define SKYBLUE    CLITERAL(Color){ 102, 191, 255, 255 }   // Sky Blue
+#define BLUE       CLITERAL(Color){ 0, 121, 241, 255 }     // Blue
+#define DARKBLUE   CLITERAL(Color){ 0, 82, 172, 255 }      // Dark Blue
+#define PURPLE     CLITERAL(Color){ 200, 122, 255, 255 }   // Purple
+#define VIOLET     CLITERAL(Color){ 135, 60, 190, 255 }    // Violet
+#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 }    // Dark Purple
+#define BEIGE      CLITERAL(Color){ 211, 176, 131, 255 }   // Beige
+#define BROWN      CLITERAL(Color){ 127, 106, 79, 255 }    // Brown
+#define DARKBROWN  CLITERAL(Color){ 76, 63, 47, 255 }      // Dark Brown
+
+#define WHITE      CLITERAL(Color){ 255, 255, 255, 255 }   // White
+#define BLACK      CLITERAL(Color){ 0, 0, 0, 255 }         // Black
+#define BLANK      CLITERAL(Color){ 0, 0, 0, 0 }           // Blank (Transparent)
+#define MAGENTA    CLITERAL(Color){ 255, 0, 255, 255 }     // Magenta
+#define RAYWHITE   CLITERAL(Color){ 245, 245, 245, 255 }   // My own White (raylib logo)
+
+//----------------------------------------------------------------------------------
+// Structures Definition
+//----------------------------------------------------------------------------------
+// Boolean type
+#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
+    #include <stdbool.h>
+#elif !defined(__cplusplus) && !defined(bool)
+    typedef enum bool { false = 0, true = !false } bool;
+    #define RL_BOOL_TYPE
+#endif
+
+// Vector2, 2 components
+typedef struct Vector2 {
+    float x;                // Vector x component
+    float y;                // Vector y component
+} Vector2;
+
+// Vector3, 3 components
+typedef struct Vector3 {
+    float x;                // Vector x component
+    float y;                // Vector y component
+    float z;                // Vector z component
+} Vector3;
+
+// Vector4, 4 components
+typedef struct Vector4 {
+    float x;                // Vector x component
+    float y;                // Vector y component
+    float z;                // Vector z component
+    float w;                // Vector w component
+} Vector4;
+
+// Quaternion, 4 components (Vector4 alias)
+typedef Vector4 Quaternion;
+
+// Matrix, 4x4 components, column major, OpenGL style, right handed
+typedef struct Matrix {
+    float m0, m4, m8, m12;  // Matrix first row (4 components)
+    float m1, m5, m9, m13;  // Matrix second row (4 components)
+    float m2, m6, m10, m14; // Matrix third row (4 components)
+    float m3, m7, m11, m15; // Matrix fourth row (4 components)
+} Matrix;
+
+// Color, 4 components, R8G8B8A8 (32bit)
+typedef struct Color {
+    unsigned char r;        // Color red value
+    unsigned char g;        // Color green value
+    unsigned char b;        // Color blue value
+    unsigned char a;        // Color alpha value
+} Color;
+
+// Rectangle, 4 components
+typedef struct Rectangle {
+    float x;                // Rectangle top-left corner position x
+    float y;                // Rectangle top-left corner position y
+    float width;            // Rectangle width
+    float height;           // Rectangle height
+} Rectangle;
+
+// Image, pixel data stored in CPU memory (RAM)
+typedef struct Image {
+    void *data;             // Image raw data
+    int width;              // Image base width
+    int height;             // Image base height
+    int mipmaps;            // Mipmap levels, 1 by default
+    int format;             // Data format (PixelFormat type)
+} Image;
+
+// Texture, tex data stored in GPU memory (VRAM)
+typedef struct Texture {
+    unsigned int id;        // OpenGL texture id
+    int width;              // Texture base width
+    int height;             // Texture base height
+    int mipmaps;            // Mipmap levels, 1 by default
+    int format;             // Data format (PixelFormat type)
+} Texture;
+
+// Texture2D, same as Texture
+typedef Texture Texture2D;
+
+// TextureCubemap, same as Texture
+typedef Texture TextureCubemap;
+
+// RenderTexture, fbo for texture rendering
+typedef struct RenderTexture {
+    unsigned int id;        // OpenGL framebuffer object id
+    Texture texture;        // Color buffer attachment texture
+    Texture depth;          // Depth buffer attachment texture
+} RenderTexture;
+
+// RenderTexture2D, same as RenderTexture
+typedef RenderTexture RenderTexture2D;
+
+// NPatchInfo, n-patch layout info
+typedef struct NPatchInfo {
+    Rectangle source;       // Texture source rectangle
+    int left;               // Left border offset
+    int top;                // Top border offset
+    int right;              // Right border offset
+    int bottom;             // Bottom border offset
+    int layout;             // Layout of the n-patch: 3x3, 1x3 or 3x1
+} NPatchInfo;
+
+// GlyphInfo, font characters glyphs info
+typedef struct GlyphInfo {
+    int value;              // Character value (Unicode)
+    int offsetX;            // Character offset X when drawing
+    int offsetY;            // Character offset Y when drawing
+    int advanceX;           // Character advance position X
+    Image image;            // Character image data
+} GlyphInfo;
+
+// Font, font texture and GlyphInfo array data
+typedef struct Font {
+    int baseSize;           // Base size (default chars height)
+    int glyphCount;         // Number of glyph characters
+    int glyphPadding;       // Padding around the glyph characters
+    Texture2D texture;      // Texture atlas containing the glyphs
+    Rectangle *recs;        // Rectangles in texture for the glyphs
+    GlyphInfo *glyphs;      // Glyphs info data
+} Font;
+
+// Camera, defines position/orientation in 3d space
+typedef struct Camera3D {
+    Vector3 position;       // Camera position
+    Vector3 target;         // Camera target it looks-at
+    Vector3 up;             // Camera up vector (rotation over its axis)
+    float fovy;             // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
+    int projection;         // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+} Camera3D;
+
+typedef Camera3D Camera;    // Camera type fallback, defaults to Camera3D
+
+// Camera2D, defines position/orientation in 2d space
+typedef struct Camera2D {
+    Vector2 offset;         // Camera offset (displacement from target)
+    Vector2 target;         // Camera target (rotation and zoom origin)
+    float rotation;         // Camera rotation in degrees
+    float zoom;             // Camera zoom (scaling), should be 1.0f by default
+} Camera2D;
+
+// Mesh, vertex data and vao/vbo
+typedef struct Mesh {
+    int vertexCount;        // Number of vertices stored in arrays
+    int triangleCount;      // Number of triangles stored (indexed or not)
+
+    // Vertex attributes data
+    float *vertices;        // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    float *texcoords;       // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    float *texcoords2;      // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
+    float *normals;         // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
+    float *tangents;        // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
+    unsigned char *colors;      // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+    unsigned short *indices;    // Vertex indices (in case vertex data comes indexed)
+
+    // Animation vertex data
+    float *animVertices;    // Animated vertex positions (after bones transformations)
+    float *animNormals;     // Animated normals (after bones transformations)
+    unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
+    float *boneWeights;     // Vertex bone weight, up to 4 bones influence by vertex (skinning)
+
+    // OpenGL identifiers
+    unsigned int vaoId;     // OpenGL Vertex Array Object id
+    unsigned int *vboId;    // OpenGL Vertex Buffer Objects id (default vertex data)
+} Mesh;
+
+// Shader
+typedef struct Shader {
+    unsigned int id;        // Shader program id
+    int *locs;              // Shader locations array (RL_MAX_SHADER_LOCATIONS)
+} Shader;
+
+// MaterialMap
+typedef struct MaterialMap {
+    Texture2D texture;      // Material map texture
+    Color color;            // Material map color
+    float value;            // Material map value
+} MaterialMap;
+
+// Material, includes shader and maps
+typedef struct Material {
+    Shader shader;          // Material shader
+    MaterialMap *maps;      // Material maps array (MAX_MATERIAL_MAPS)
+    float params[4];        // Material generic parameters (if required)
+} Material;
+
+// Transform, vectex transformation data
+typedef struct Transform {
+    Vector3 translation;    // Translation
+    Quaternion rotation;    // Rotation
+    Vector3 scale;          // Scale
+} Transform;
+
+// Bone, skeletal animation bone
+typedef struct BoneInfo {
+    char name[32];          // Bone name
+    int parent;             // Bone parent
+} BoneInfo;
+
+// Model, meshes, materials and animation data
+typedef struct Model {
+    Matrix transform;       // Local transform matrix
+
+    int meshCount;          // Number of meshes
+    int materialCount;      // Number of materials
+    Mesh *meshes;           // Meshes array
+    Material *materials;    // Materials array
+    int *meshMaterial;      // Mesh material number
+
+    // Animation data
+    int boneCount;          // Number of bones
+    BoneInfo *bones;        // Bones information (skeleton)
+    Transform *bindPose;    // Bones base transformation (pose)
+} Model;
+
+// ModelAnimation
+typedef struct ModelAnimation {
+    int boneCount;          // Number of bones
+    int frameCount;         // Number of animation frames
+    BoneInfo *bones;        // Bones information (skeleton)
+    Transform **framePoses; // Poses array by frame
+} ModelAnimation;
+
+// Ray, ray for raycasting
+typedef struct Ray {
+    Vector3 position;       // Ray position (origin)
+    Vector3 direction;      // Ray direction
+} Ray;
+
+// RayCollision, ray hit information
+typedef struct RayCollision {
+    bool hit;               // Did the ray hit something?
+    float distance;         // Distance to nearest hit
+    Vector3 point;          // Point of nearest hit
+    Vector3 normal;         // Surface normal of hit
+} RayCollision;
+
+// BoundingBox
+typedef struct BoundingBox {
+    Vector3 min;            // Minimum vertex box-corner
+    Vector3 max;            // Maximum vertex box-corner
+} BoundingBox;
+
+// Wave, audio wave data
+typedef struct Wave {
+    unsigned int frameCount;    // Total number of frames (considering channels)
+    unsigned int sampleRate;    // Frequency (samples per second)
+    unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+    unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
+    void *data;                 // Buffer data pointer
+} Wave;
+
+// Opaque structs declaration
+// NOTE: Actual structs are defined internally in raudio module
+typedef struct rAudioBuffer rAudioBuffer;
+typedef struct rAudioProcessor rAudioProcessor;
+
+// AudioStream, custom audio stream
+typedef struct AudioStream {
+    rAudioBuffer *buffer;       // Pointer to internal data used by the audio system
+    rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects
+
+    unsigned int sampleRate;    // Frequency (samples per second)
+    unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
+    unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
+} AudioStream;
+
+// Sound
+typedef struct Sound {
+    AudioStream stream;         // Audio stream
+    unsigned int frameCount;    // Total number of frames (considering channels)
+} Sound;
+
+// Music, audio stream, anything longer than ~10 seconds should be streamed
+typedef struct Music {
+    AudioStream stream;         // Audio stream
+    unsigned int frameCount;    // Total number of frames (considering channels)
+    bool looping;               // Music looping enable
+
+    int ctxType;                // Type of music context (audio filetype)
+    void *ctxData;              // Audio context data, depends on type
+} Music;
+
+// VrDeviceInfo, Head-Mounted-Display device parameters
+typedef struct VrDeviceInfo {
+    int hResolution;                // Horizontal resolution in pixels
+    int vResolution;                // Vertical resolution in pixels
+    float hScreenSize;              // Horizontal size in meters
+    float vScreenSize;              // Vertical size in meters
+    float vScreenCenter;            // Screen center in meters
+    float eyeToScreenDistance;      // Distance between eye and display in meters
+    float lensSeparationDistance;   // Lens separation distance in meters
+    float interpupillaryDistance;   // IPD (distance between pupils) in meters
+    float lensDistortionValues[4];  // Lens distortion constant parameters
+    float chromaAbCorrection[4];    // Chromatic aberration correction parameters
+} VrDeviceInfo;
+
+// VrStereoConfig, VR stereo rendering configuration for simulator
+typedef struct VrStereoConfig {
+    Matrix projection[2];           // VR projection matrices (per eye)
+    Matrix viewOffset[2];           // VR view offset matrices (per eye)
+    float leftLensCenter[2];        // VR left lens center
+    float rightLensCenter[2];       // VR right lens center
+    float leftScreenCenter[2];      // VR left screen center
+    float rightScreenCenter[2];     // VR right screen center
+    float scale[2];                 // VR distortion scale
+    float scaleIn[2];               // VR distortion scale in
+} VrStereoConfig;
+
+// File path list
+typedef struct FilePathList {
+    unsigned int capacity;          // Filepaths max entries
+    unsigned int count;             // Filepaths entries count
+    char **paths;                   // Filepaths entries
+} FilePathList;
+
+//----------------------------------------------------------------------------------
+// Enumerators Definition
+//----------------------------------------------------------------------------------
+// System/Window config flags
+// NOTE: Every bit registers one state (use it with bit masks)
+// By default all flags are set to 0
+typedef enum {
+    FLAG_VSYNC_HINT         = 0x00000040,   // Set to try enabling V-Sync on GPU
+    FLAG_FULLSCREEN_MODE    = 0x00000002,   // Set to run program in fullscreen
+    FLAG_WINDOW_RESIZABLE   = 0x00000004,   // Set to allow resizable window
+    FLAG_WINDOW_UNDECORATED = 0x00000008,   // Set to disable window decoration (frame and buttons)
+    FLAG_WINDOW_HIDDEN      = 0x00000080,   // Set to hide window
+    FLAG_WINDOW_MINIMIZED   = 0x00000200,   // Set to minimize window (iconify)
+    FLAG_WINDOW_MAXIMIZED   = 0x00000400,   // Set to maximize window (expanded to monitor)
+    FLAG_WINDOW_UNFOCUSED   = 0x00000800,   // Set to window non focused
+    FLAG_WINDOW_TOPMOST     = 0x00001000,   // Set to window always on top
+    FLAG_WINDOW_ALWAYS_RUN  = 0x00000100,   // Set to allow windows running while minimized
+    FLAG_WINDOW_TRANSPARENT = 0x00000010,   // Set to allow transparent framebuffer
+    FLAG_WINDOW_HIGHDPI     = 0x00002000,   // Set to support HighDPI
+    FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED
+    FLAG_MSAA_4X_HINT       = 0x00000020,   // Set to try enabling MSAA 4X
+    FLAG_INTERLACED_HINT    = 0x00010000    // Set to try enabling interlaced video format (for V3D)
+} ConfigFlags;
+
+// Trace log level
+// NOTE: Organized by priority level
+typedef enum {
+    LOG_ALL = 0,        // Display all logs
+    LOG_TRACE,          // Trace logging, intended for internal use only
+    LOG_DEBUG,          // Debug logging, used for internal debugging, it should be disabled on release builds
+    LOG_INFO,           // Info logging, used for program execution info
+    LOG_WARNING,        // Warning logging, used on recoverable failures
+    LOG_ERROR,          // Error logging, used on unrecoverable failures
+    LOG_FATAL,          // Fatal logging, used to abort program: exit(EXIT_FAILURE)
+    LOG_NONE            // Disable logging
+} TraceLogLevel;
+
+// Keyboard keys (US keyboard layout)
+// NOTE: Use GetKeyPressed() to allow redefining
+// required keys for alternative layouts
+typedef enum {
+    KEY_NULL            = 0,        // Key: NULL, used for no key pressed
+    // Alphanumeric keys
+    KEY_APOSTROPHE      = 39,       // Key: '
+    KEY_COMMA           = 44,       // Key: ,
+    KEY_MINUS           = 45,       // Key: -
+    KEY_PERIOD          = 46,       // Key: .
+    KEY_SLASH           = 47,       // Key: /
+    KEY_ZERO            = 48,       // Key: 0
+    KEY_ONE             = 49,       // Key: 1
+    KEY_TWO             = 50,       // Key: 2
+    KEY_THREE           = 51,       // Key: 3
+    KEY_FOUR            = 52,       // Key: 4
+    KEY_FIVE            = 53,       // Key: 5
+    KEY_SIX             = 54,       // Key: 6
+    KEY_SEVEN           = 55,       // Key: 7
+    KEY_EIGHT           = 56,       // Key: 8
+    KEY_NINE            = 57,       // Key: 9
+    KEY_SEMICOLON       = 59,       // Key: ;
+    KEY_EQUAL           = 61,       // Key: =
+    KEY_A               = 65,       // Key: A | a
+    KEY_B               = 66,       // Key: B | b
+    KEY_C               = 67,       // Key: C | c
+    KEY_D               = 68,       // Key: D | d
+    KEY_E               = 69,       // Key: E | e
+    KEY_F               = 70,       // Key: F | f
+    KEY_G               = 71,       // Key: G | g
+    KEY_H               = 72,       // Key: H | h
+    KEY_I               = 73,       // Key: I | i
+    KEY_J               = 74,       // Key: J | j
+    KEY_K               = 75,       // Key: K | k
+    KEY_L               = 76,       // Key: L | l
+    KEY_M               = 77,       // Key: M | m
+    KEY_N               = 78,       // Key: N | n
+    KEY_O               = 79,       // Key: O | o
+    KEY_P               = 80,       // Key: P | p
+    KEY_Q               = 81,       // Key: Q | q
+    KEY_R               = 82,       // Key: R | r
+    KEY_S               = 83,       // Key: S | s
+    KEY_T               = 84,       // Key: T | t
+    KEY_U               = 85,       // Key: U | u
+    KEY_V               = 86,       // Key: V | v
+    KEY_W               = 87,       // Key: W | w
+    KEY_X               = 88,       // Key: X | x
+    KEY_Y               = 89,       // Key: Y | y
+    KEY_Z               = 90,       // Key: Z | z
+    KEY_LEFT_BRACKET    = 91,       // Key: [
+    KEY_BACKSLASH       = 92,       // Key: '\'
+    KEY_RIGHT_BRACKET   = 93,       // Key: ]
+    KEY_GRAVE           = 96,       // Key: `
+    // Function keys
+    KEY_SPACE           = 32,       // Key: Space
+    KEY_ESCAPE          = 256,      // Key: Esc
+    KEY_ENTER           = 257,      // Key: Enter
+    KEY_TAB             = 258,      // Key: Tab
+    KEY_BACKSPACE       = 259,      // Key: Backspace
+    KEY_INSERT          = 260,      // Key: Ins
+    KEY_DELETE          = 261,      // Key: Del
+    KEY_RIGHT           = 262,      // Key: Cursor right
+    KEY_LEFT            = 263,      // Key: Cursor left
+    KEY_DOWN            = 264,      // Key: Cursor down
+    KEY_UP              = 265,      // Key: Cursor up
+    KEY_PAGE_UP         = 266,      // Key: Page up
+    KEY_PAGE_DOWN       = 267,      // Key: Page down
+    KEY_HOME            = 268,      // Key: Home
+    KEY_END             = 269,      // Key: End
+    KEY_CAPS_LOCK       = 280,      // Key: Caps lock
+    KEY_SCROLL_LOCK     = 281,      // Key: Scroll down
+    KEY_NUM_LOCK        = 282,      // Key: Num lock
+    KEY_PRINT_SCREEN    = 283,      // Key: Print screen
+    KEY_PAUSE           = 284,      // Key: Pause
+    KEY_F1              = 290,      // Key: F1
+    KEY_F2              = 291,      // Key: F2
+    KEY_F3              = 292,      // Key: F3
+    KEY_F4              = 293,      // Key: F4
+    KEY_F5              = 294,      // Key: F5
+    KEY_F6              = 295,      // Key: F6
+    KEY_F7              = 296,      // Key: F7
+    KEY_F8              = 297,      // Key: F8
+    KEY_F9              = 298,      // Key: F9
+    KEY_F10             = 299,      // Key: F10
+    KEY_F11             = 300,      // Key: F11
+    KEY_F12             = 301,      // Key: F12
+    KEY_LEFT_SHIFT      = 340,      // Key: Shift left
+    KEY_LEFT_CONTROL    = 341,      // Key: Control left
+    KEY_LEFT_ALT        = 342,      // Key: Alt left
+    KEY_LEFT_SUPER      = 343,      // Key: Super left
+    KEY_RIGHT_SHIFT     = 344,      // Key: Shift right
+    KEY_RIGHT_CONTROL   = 345,      // Key: Control right
+    KEY_RIGHT_ALT       = 346,      // Key: Alt right
+    KEY_RIGHT_SUPER     = 347,      // Key: Super right
+    KEY_KB_MENU         = 348,      // Key: KB menu
+    // Keypad keys
+    KEY_KP_0            = 320,      // Key: Keypad 0
+    KEY_KP_1            = 321,      // Key: Keypad 1
+    KEY_KP_2            = 322,      // Key: Keypad 2
+    KEY_KP_3            = 323,      // Key: Keypad 3
+    KEY_KP_4            = 324,      // Key: Keypad 4
+    KEY_KP_5            = 325,      // Key: Keypad 5
+    KEY_KP_6            = 326,      // Key: Keypad 6
+    KEY_KP_7            = 327,      // Key: Keypad 7
+    KEY_KP_8            = 328,      // Key: Keypad 8
+    KEY_KP_9            = 329,      // Key: Keypad 9
+    KEY_KP_DECIMAL      = 330,      // Key: Keypad .
+    KEY_KP_DIVIDE       = 331,      // Key: Keypad /
+    KEY_KP_MULTIPLY     = 332,      // Key: Keypad *
+    KEY_KP_SUBTRACT     = 333,      // Key: Keypad -
+    KEY_KP_ADD          = 334,      // Key: Keypad +
+    KEY_KP_ENTER        = 335,      // Key: Keypad Enter
+    KEY_KP_EQUAL        = 336,      // Key: Keypad =
+    // Android key buttons
+    KEY_BACK            = 4,        // Key: Android back button
+    KEY_MENU            = 82,       // Key: Android menu button
+    KEY_VOLUME_UP       = 24,       // Key: Android volume up button
+    KEY_VOLUME_DOWN     = 25        // Key: Android volume down button
+} KeyboardKey;
+
+// Add backwards compatibility support for deprecated names
+#define MOUSE_LEFT_BUTTON   MOUSE_BUTTON_LEFT
+#define MOUSE_RIGHT_BUTTON  MOUSE_BUTTON_RIGHT
+#define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE
+
+// Mouse buttons
+typedef enum {
+    MOUSE_BUTTON_LEFT    = 0,       // Mouse button left
+    MOUSE_BUTTON_RIGHT   = 1,       // Mouse button right
+    MOUSE_BUTTON_MIDDLE  = 2,       // Mouse button middle (pressed wheel)
+    MOUSE_BUTTON_SIDE    = 3,       // Mouse button side (advanced mouse device)
+    MOUSE_BUTTON_EXTRA   = 4,       // Mouse button extra (advanced mouse device)
+    MOUSE_BUTTON_FORWARD = 5,       // Mouse button fordward (advanced mouse device)
+    MOUSE_BUTTON_BACK    = 6,       // Mouse button back (advanced mouse device)
+} MouseButton;
+
+// Mouse cursor
+typedef enum {
+    MOUSE_CURSOR_DEFAULT       = 0,     // Default pointer shape
+    MOUSE_CURSOR_ARROW         = 1,     // Arrow shape
+    MOUSE_CURSOR_IBEAM         = 2,     // Text writing cursor shape
+    MOUSE_CURSOR_CROSSHAIR     = 3,     // Cross shape
+    MOUSE_CURSOR_POINTING_HAND = 4,     // Pointing hand cursor
+    MOUSE_CURSOR_RESIZE_EW     = 5,     // Horizontal resize/move arrow shape
+    MOUSE_CURSOR_RESIZE_NS     = 6,     // Vertical resize/move arrow shape
+    MOUSE_CURSOR_RESIZE_NWSE   = 7,     // Top-left to bottom-right diagonal resize/move arrow shape
+    MOUSE_CURSOR_RESIZE_NESW   = 8,     // The top-right to bottom-left diagonal resize/move arrow shape
+    MOUSE_CURSOR_RESIZE_ALL    = 9,     // The omni-directional resize/move cursor shape
+    MOUSE_CURSOR_NOT_ALLOWED   = 10     // The operation-not-allowed shape
+} MouseCursor;
+
+// Gamepad buttons
+typedef enum {
+    GAMEPAD_BUTTON_UNKNOWN = 0,         // Unknown button, just for error checking
+    GAMEPAD_BUTTON_LEFT_FACE_UP,        // Gamepad left DPAD up button
+    GAMEPAD_BUTTON_LEFT_FACE_RIGHT,     // Gamepad left DPAD right button
+    GAMEPAD_BUTTON_LEFT_FACE_DOWN,      // Gamepad left DPAD down button
+    GAMEPAD_BUTTON_LEFT_FACE_LEFT,      // Gamepad left DPAD left button
+    GAMEPAD_BUTTON_RIGHT_FACE_UP,       // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)
+    GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,    // Gamepad right button right (i.e. PS3: Square, Xbox: X)
+    GAMEPAD_BUTTON_RIGHT_FACE_DOWN,     // Gamepad right button down (i.e. PS3: Cross, Xbox: A)
+    GAMEPAD_BUTTON_RIGHT_FACE_LEFT,     // Gamepad right button left (i.e. PS3: Circle, Xbox: B)
+    GAMEPAD_BUTTON_LEFT_TRIGGER_1,      // Gamepad top/back trigger left (first), it could be a trailing button
+    GAMEPAD_BUTTON_LEFT_TRIGGER_2,      // Gamepad top/back trigger left (second), it could be a trailing button
+    GAMEPAD_BUTTON_RIGHT_TRIGGER_1,     // Gamepad top/back trigger right (one), it could be a trailing button
+    GAMEPAD_BUTTON_RIGHT_TRIGGER_2,     // Gamepad top/back trigger right (second), it could be a trailing button
+    GAMEPAD_BUTTON_MIDDLE_LEFT,         // Gamepad center buttons, left one (i.e. PS3: Select)
+    GAMEPAD_BUTTON_MIDDLE,              // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)
+    GAMEPAD_BUTTON_MIDDLE_RIGHT,        // Gamepad center buttons, right one (i.e. PS3: Start)
+    GAMEPAD_BUTTON_LEFT_THUMB,          // Gamepad joystick pressed button left
+    GAMEPAD_BUTTON_RIGHT_THUMB          // Gamepad joystick pressed button right
+} GamepadButton;
+
+// Gamepad axis
+typedef enum {
+    GAMEPAD_AXIS_LEFT_X        = 0,     // Gamepad left stick X axis
+    GAMEPAD_AXIS_LEFT_Y        = 1,     // Gamepad left stick Y axis
+    GAMEPAD_AXIS_RIGHT_X       = 2,     // Gamepad right stick X axis
+    GAMEPAD_AXIS_RIGHT_Y       = 3,     // Gamepad right stick Y axis
+    GAMEPAD_AXIS_LEFT_TRIGGER  = 4,     // Gamepad back trigger left, pressure level: [1..-1]
+    GAMEPAD_AXIS_RIGHT_TRIGGER = 5      // Gamepad back trigger right, pressure level: [1..-1]
+} GamepadAxis;
+
+// Material map index
+typedef enum {
+    MATERIAL_MAP_ALBEDO    = 0,     // Albedo material (same as: MATERIAL_MAP_DIFFUSE)
+    MATERIAL_MAP_METALNESS,         // Metalness material (same as: MATERIAL_MAP_SPECULAR)
+    MATERIAL_MAP_NORMAL,            // Normal material
+    MATERIAL_MAP_ROUGHNESS,         // Roughness material
+    MATERIAL_MAP_OCCLUSION,         // Ambient occlusion material
+    MATERIAL_MAP_EMISSION,          // Emission material
+    MATERIAL_MAP_HEIGHT,            // Heightmap material
+    MATERIAL_MAP_CUBEMAP,           // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
+    MATERIAL_MAP_IRRADIANCE,        // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
+    MATERIAL_MAP_PREFILTER,         // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
+    MATERIAL_MAP_BRDF               // Brdf material
+} MaterialMapIndex;
+
+#define MATERIAL_MAP_DIFFUSE      MATERIAL_MAP_ALBEDO
+#define MATERIAL_MAP_SPECULAR     MATERIAL_MAP_METALNESS
+
+// Shader location index
+typedef enum {
+    SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
+    SHADER_LOC_VERTEX_TEXCOORD01,   // Shader location: vertex attribute: texcoord01
+    SHADER_LOC_VERTEX_TEXCOORD02,   // Shader location: vertex attribute: texcoord02
+    SHADER_LOC_VERTEX_NORMAL,       // Shader location: vertex attribute: normal
+    SHADER_LOC_VERTEX_TANGENT,      // Shader location: vertex attribute: tangent
+    SHADER_LOC_VERTEX_COLOR,        // Shader location: vertex attribute: color
+    SHADER_LOC_MATRIX_MVP,          // Shader location: matrix uniform: model-view-projection
+    SHADER_LOC_MATRIX_VIEW,         // Shader location: matrix uniform: view (camera transform)
+    SHADER_LOC_MATRIX_PROJECTION,   // Shader location: matrix uniform: projection
+    SHADER_LOC_MATRIX_MODEL,        // Shader location: matrix uniform: model (transform)
+    SHADER_LOC_MATRIX_NORMAL,       // Shader location: matrix uniform: normal
+    SHADER_LOC_VECTOR_VIEW,         // Shader location: vector uniform: view
+    SHADER_LOC_COLOR_DIFFUSE,       // Shader location: vector uniform: diffuse color
+    SHADER_LOC_COLOR_SPECULAR,      // Shader location: vector uniform: specular color
+    SHADER_LOC_COLOR_AMBIENT,       // Shader location: vector uniform: ambient color
+    SHADER_LOC_MAP_ALBEDO,          // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)
+    SHADER_LOC_MAP_METALNESS,       // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)
+    SHADER_LOC_MAP_NORMAL,          // Shader location: sampler2d texture: normal
+    SHADER_LOC_MAP_ROUGHNESS,       // Shader location: sampler2d texture: roughness
+    SHADER_LOC_MAP_OCCLUSION,       // Shader location: sampler2d texture: occlusion
+    SHADER_LOC_MAP_EMISSION,        // Shader location: sampler2d texture: emission
+    SHADER_LOC_MAP_HEIGHT,          // Shader location: sampler2d texture: height
+    SHADER_LOC_MAP_CUBEMAP,         // Shader location: samplerCube texture: cubemap
+    SHADER_LOC_MAP_IRRADIANCE,      // Shader location: samplerCube texture: irradiance
+    SHADER_LOC_MAP_PREFILTER,       // Shader location: samplerCube texture: prefilter
+    SHADER_LOC_MAP_BRDF             // Shader location: sampler2d texture: brdf
+} ShaderLocationIndex;
+
+#define SHADER_LOC_MAP_DIFFUSE      SHADER_LOC_MAP_ALBEDO
+#define SHADER_LOC_MAP_SPECULAR     SHADER_LOC_MAP_METALNESS
+
+// Shader uniform data type
+typedef enum {
+    SHADER_UNIFORM_FLOAT = 0,       // Shader uniform type: float
+    SHADER_UNIFORM_VEC2,            // Shader uniform type: vec2 (2 float)
+    SHADER_UNIFORM_VEC3,            // Shader uniform type: vec3 (3 float)
+    SHADER_UNIFORM_VEC4,            // Shader uniform type: vec4 (4 float)
+    SHADER_UNIFORM_INT,             // Shader uniform type: int
+    SHADER_UNIFORM_IVEC2,           // Shader uniform type: ivec2 (2 int)
+    SHADER_UNIFORM_IVEC3,           // Shader uniform type: ivec3 (3 int)
+    SHADER_UNIFORM_IVEC4,           // Shader uniform type: ivec4 (4 int)
+    SHADER_UNIFORM_SAMPLER2D        // Shader uniform type: sampler2d
+} ShaderUniformDataType;
+
+// Shader attribute data types
+typedef enum {
+    SHADER_ATTRIB_FLOAT = 0,        // Shader attribute type: float
+    SHADER_ATTRIB_VEC2,             // Shader attribute type: vec2 (2 float)
+    SHADER_ATTRIB_VEC3,             // Shader attribute type: vec3 (3 float)
+    SHADER_ATTRIB_VEC4              // Shader attribute type: vec4 (4 float)
+} ShaderAttributeDataType;
+
+// Pixel formats
+// NOTE: Support depends on OpenGL version and platform
+typedef enum {
+    PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
+    PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,    // 8*2 bpp (2 channels)
+    PIXELFORMAT_UNCOMPRESSED_R5G6B5,        // 16 bpp
+    PIXELFORMAT_UNCOMPRESSED_R8G8B8,        // 24 bpp
+    PIXELFORMAT_UNCOMPRESSED_R5G5B5A1,      // 16 bpp (1 bit alpha)
+    PIXELFORMAT_UNCOMPRESSED_R4G4B4A4,      // 16 bpp (4 bit alpha)
+    PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,      // 32 bpp
+    PIXELFORMAT_UNCOMPRESSED_R32,           // 32 bpp (1 channel - float)
+    PIXELFORMAT_UNCOMPRESSED_R32G32B32,     // 32*3 bpp (3 channels - float)
+    PIXELFORMAT_UNCOMPRESSED_R32G32B32A32,  // 32*4 bpp (4 channels - float)
+    PIXELFORMAT_COMPRESSED_DXT1_RGB,        // 4 bpp (no alpha)
+    PIXELFORMAT_COMPRESSED_DXT1_RGBA,       // 4 bpp (1 bit alpha)
+    PIXELFORMAT_COMPRESSED_DXT3_RGBA,       // 8 bpp
+    PIXELFORMAT_COMPRESSED_DXT5_RGBA,       // 8 bpp
+    PIXELFORMAT_COMPRESSED_ETC1_RGB,        // 4 bpp
+    PIXELFORMAT_COMPRESSED_ETC2_RGB,        // 4 bpp
+    PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA,   // 8 bpp
+    PIXELFORMAT_COMPRESSED_PVRT_RGB,        // 4 bpp
+    PIXELFORMAT_COMPRESSED_PVRT_RGBA,       // 4 bpp
+    PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA,   // 8 bpp
+    PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA    // 2 bpp
+} PixelFormat;
+
+// Texture parameters: filter mode
+// NOTE 1: Filtering considers mipmaps if available in the texture
+// NOTE 2: Filter is accordingly set for minification and magnification
+typedef enum {
+    TEXTURE_FILTER_POINT = 0,               // No filter, just pixel approximation
+    TEXTURE_FILTER_BILINEAR,                // Linear filtering
+    TEXTURE_FILTER_TRILINEAR,               // Trilinear filtering (linear with mipmaps)
+    TEXTURE_FILTER_ANISOTROPIC_4X,          // Anisotropic filtering 4x
+    TEXTURE_FILTER_ANISOTROPIC_8X,          // Anisotropic filtering 8x
+    TEXTURE_FILTER_ANISOTROPIC_16X,         // Anisotropic filtering 16x
+} TextureFilter;
+
+// Texture parameters: wrap mode
+typedef enum {
+    TEXTURE_WRAP_REPEAT = 0,                // Repeats texture in tiled mode
+    TEXTURE_WRAP_CLAMP,                     // Clamps texture to edge pixel in tiled mode
+    TEXTURE_WRAP_MIRROR_REPEAT,             // Mirrors and repeats the texture in tiled mode
+    TEXTURE_WRAP_MIRROR_CLAMP               // Mirrors and clamps to border the texture in tiled mode
+} TextureWrap;
+
+// Cubemap layouts
+typedef enum {
+    CUBEMAP_LAYOUT_AUTO_DETECT = 0,         // Automatically detect layout type
+    CUBEMAP_LAYOUT_LINE_VERTICAL,           // Layout is defined by a vertical line with faces
+    CUBEMAP_LAYOUT_LINE_HORIZONTAL,         // Layout is defined by an horizontal line with faces
+    CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR,     // Layout is defined by a 3x4 cross with cubemap faces
+    CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE,     // Layout is defined by a 4x3 cross with cubemap faces
+    CUBEMAP_LAYOUT_PANORAMA                 // Layout is defined by a panorama image (equirectangular map)
+} CubemapLayout;
+
+// Font type, defines generation method
+typedef enum {
+    FONT_DEFAULT = 0,               // Default font generation, anti-aliased
+    FONT_BITMAP,                    // Bitmap font generation, no anti-aliasing
+    FONT_SDF                        // SDF font generation, requires external shader
+} FontType;
+
+// Color blending modes (pre-defined)
+typedef enum {
+    BLEND_ALPHA = 0,                // Blend textures considering alpha (default)
+    BLEND_ADDITIVE,                 // Blend textures adding colors
+    BLEND_MULTIPLIED,               // Blend textures multiplying colors
+    BLEND_ADD_COLORS,               // Blend textures adding colors (alternative)
+    BLEND_SUBTRACT_COLORS,          // Blend textures subtracting colors (alternative)
+    BLEND_ALPHA_PREMULTIPLY,        // Blend premultiplied textures considering alpha
+    BLEND_CUSTOM                    // Blend textures using custom src/dst factors (use rlSetBlendMode())
+} BlendMode;
+
+// Gesture
+// NOTE: It could be used as flags to enable only some gestures
+typedef enum {
+    GESTURE_NONE        = 0,        // No gesture
+    GESTURE_TAP         = 1,        // Tap gesture
+    GESTURE_DOUBLETAP   = 2,        // Double tap gesture
+    GESTURE_HOLD        = 4,        // Hold gesture
+    GESTURE_DRAG        = 8,        // Drag gesture
+    GESTURE_SWIPE_RIGHT = 16,       // Swipe right gesture
+    GESTURE_SWIPE_LEFT  = 32,       // Swipe left gesture
+    GESTURE_SWIPE_UP    = 64,       // Swipe up gesture
+    GESTURE_SWIPE_DOWN  = 128,      // Swipe down gesture
+    GESTURE_PINCH_IN    = 256,      // Pinch in gesture
+    GESTURE_PINCH_OUT   = 512       // Pinch out gesture
+} Gesture;
+
+// Camera system modes
+typedef enum {
+    CAMERA_CUSTOM = 0,              // Custom camera
+    CAMERA_FREE,                    // Free camera
+    CAMERA_ORBITAL,                 // Orbital camera
+    CAMERA_FIRST_PERSON,            // First person camera
+    CAMERA_THIRD_PERSON             // Third person camera
+} CameraMode;
+
+// Camera projection
+typedef enum {
+    CAMERA_PERSPECTIVE = 0,         // Perspective projection
+    CAMERA_ORTHOGRAPHIC             // Orthographic projection
+} CameraProjection;
+
+// N-patch layout
+typedef enum {
+    NPATCH_NINE_PATCH = 0,          // Npatch layout: 3x3 tiles
+    NPATCH_THREE_PATCH_VERTICAL,    // Npatch layout: 1x3 tiles
+    NPATCH_THREE_PATCH_HORIZONTAL   // Npatch layout: 3x1 tiles
+} NPatchLayout;
+
+// Callbacks to hook some internal functions
+// WARNING: This callbacks are intended for advance users
+typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args);  // Logging: Redirect trace log messages
+typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, unsigned int *bytesRead);      // FileIO: Load binary data
+typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, unsigned int bytesToWrite);  // FileIO: Save binary data
+typedef char *(*LoadFileTextCallback)(const char *fileName);            // FileIO: Load text data
+typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data
+
+//------------------------------------------------------------------------------------
+// Global Variables Definition
+//------------------------------------------------------------------------------------
+// It's lonely here...
+
+//------------------------------------------------------------------------------------
+// Window and Graphics Device Functions (Module: core)
+//------------------------------------------------------------------------------------
+
+#if defined(__cplusplus)
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+// Window-related functions
+RLAPI void InitWindow(int width, int height, const char *title);  // Initialize window and OpenGL context
+RLAPI bool WindowShouldClose(void);                               // Check if KEY_ESCAPE pressed or Close icon pressed
+RLAPI void CloseWindow(void);                                     // Close window and unload OpenGL context
+RLAPI bool IsWindowReady(void);                                   // Check if window has been initialized successfully
+RLAPI bool IsWindowFullscreen(void);                              // Check if window is currently fullscreen
+RLAPI bool IsWindowHidden(void);                                  // Check if window is currently hidden (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowMinimized(void);                               // Check if window is currently minimized (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowMaximized(void);                               // Check if window is currently maximized (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowFocused(void);                                 // Check if window is currently focused (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowResized(void);                                 // Check if window has been resized last frame
+RLAPI bool IsWindowState(unsigned int flag);                      // Check if one specific window flag is enabled
+RLAPI void SetWindowState(unsigned int flags);                    // Set window configuration state using flags (only PLATFORM_DESKTOP)
+RLAPI void ClearWindowState(unsigned int flags);                  // Clear window configuration state flags
+RLAPI void ToggleFullscreen(void);                                // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
+RLAPI void MaximizeWindow(void);                                  // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
+RLAPI void MinimizeWindow(void);                                  // Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
+RLAPI void RestoreWindow(void);                                   // Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
+RLAPI void SetWindowIcon(Image image);                            // Set icon for window (only PLATFORM_DESKTOP)
+RLAPI void SetWindowTitle(const char *title);                     // Set title for window (only PLATFORM_DESKTOP)
+RLAPI void SetWindowPosition(int x, int y);                       // Set window position on screen (only PLATFORM_DESKTOP)
+RLAPI void SetWindowMonitor(int monitor);                         // Set monitor for the current window (fullscreen mode)
+RLAPI void SetWindowMinSize(int width, int height);               // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
+RLAPI void SetWindowSize(int width, int height);                  // Set window dimensions
+RLAPI void SetWindowOpacity(float opacity);                       // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
+RLAPI void *GetWindowHandle(void);                                // Get native window handle
+RLAPI int GetScreenWidth(void);                                   // Get current screen width
+RLAPI int GetScreenHeight(void);                                  // Get current screen height
+RLAPI int GetRenderWidth(void);                                   // Get current render width (it considers HiDPI)
+RLAPI int GetRenderHeight(void);                                  // Get current render height (it considers HiDPI)
+RLAPI int GetMonitorCount(void);                                  // Get number of connected monitors
+RLAPI int GetCurrentMonitor(void);                                // Get current connected monitor
+RLAPI Vector2 GetMonitorPosition(int monitor);                    // Get specified monitor position
+RLAPI int GetMonitorWidth(int monitor);                           // Get specified monitor width (current video mode used by monitor)
+RLAPI int GetMonitorHeight(int monitor);                          // Get specified monitor height (current video mode used by monitor)
+RLAPI int GetMonitorPhysicalWidth(int monitor);                   // Get specified monitor physical width in millimetres
+RLAPI int GetMonitorPhysicalHeight(int monitor);                  // Get specified monitor physical height in millimetres
+RLAPI int GetMonitorRefreshRate(int monitor);                     // Get specified monitor refresh rate
+RLAPI Vector2 GetWindowPosition(void);                            // Get window position XY on monitor
+RLAPI Vector2 GetWindowScaleDPI(void);                            // Get window scale DPI factor
+RLAPI const char *GetMonitorName(int monitor);                    // Get the human-readable, UTF-8 encoded name of the primary monitor
+RLAPI void SetClipboardText(const char *text);                    // Set clipboard text content
+RLAPI const char *GetClipboardText(void);                         // Get clipboard text content
+RLAPI void EnableEventWaiting(void);                              // Enable waiting for events on EndDrawing(), no automatic event polling
+RLAPI void DisableEventWaiting(void);                             // Disable waiting for events on EndDrawing(), automatic events polling
+
+// Custom frame control functions
+// NOTE: Those functions are intended for advance users that want full control over the frame processing
+// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timming + PollInputEvents()
+// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
+RLAPI void SwapScreenBuffer(void);                                // Swap back buffer with front buffer (screen drawing)
+RLAPI void PollInputEvents(void);                                 // Register all input events
+RLAPI void WaitTime(double seconds);                              // Wait for some time (halt program execution)
+
+// Cursor-related functions
+RLAPI void ShowCursor(void);                                      // Shows cursor
+RLAPI void HideCursor(void);                                      // Hides cursor
+RLAPI bool IsCursorHidden(void);                                  // Check if cursor is not visible
+RLAPI void EnableCursor(void);                                    // Enables cursor (unlock cursor)
+RLAPI void DisableCursor(void);                                   // Disables cursor (lock cursor)
+RLAPI bool IsCursorOnScreen(void);                                // Check if cursor is on the screen
+
+// Drawing-related functions
+RLAPI void ClearBackground(Color color);                          // Set background color (framebuffer clear color)
+RLAPI void BeginDrawing(void);                                    // Setup canvas (framebuffer) to start drawing
+RLAPI void EndDrawing(void);                                      // End canvas drawing and swap buffers (double buffering)
+RLAPI void BeginMode2D(Camera2D camera);                          // Begin 2D mode with custom camera (2D)
+RLAPI void EndMode2D(void);                                       // Ends 2D mode with custom camera
+RLAPI void BeginMode3D(Camera3D camera);                          // Begin 3D mode with custom camera (3D)
+RLAPI void EndMode3D(void);                                       // Ends 3D mode and returns to default 2D orthographic mode
+RLAPI void BeginTextureMode(RenderTexture2D target);              // Begin drawing to render texture
+RLAPI void EndTextureMode(void);                                  // Ends drawing to render texture
+RLAPI void BeginShaderMode(Shader shader);                        // Begin custom shader drawing
+RLAPI void EndShaderMode(void);                                   // End custom shader drawing (use default shader)
+RLAPI void BeginBlendMode(int mode);                              // Begin blending mode (alpha, additive, multiplied, subtract, custom)
+RLAPI void EndBlendMode(void);                                    // End blending mode (reset to default: alpha blending)
+RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing)
+RLAPI void EndScissorMode(void);                                  // End scissor mode
+RLAPI void BeginVrStereoMode(VrStereoConfig config);              // Begin stereo rendering (requires VR simulator)
+RLAPI void EndVrStereoMode(void);                                 // End stereo rendering (requires VR simulator)
+
+// VR stereo config functions for VR simulator
+RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device);     // Load VR stereo config for VR simulator device parameters
+RLAPI void UnloadVrStereoConfig(VrStereoConfig config);           // Unload VR stereo config
+
+// Shader management functions
+// NOTE: Shader functionality is not available on OpenGL 1.1
+RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);   // Load shader from files and bind default locations
+RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
+RLAPI int GetShaderLocation(Shader shader, const char *uniformName);       // Get shader uniform location
+RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName);  // Get shader attribute location
+RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType);               // Set shader uniform value
+RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count);   // Set shader uniform value vector
+RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat);         // Set shader uniform value (matrix 4x4)
+RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d)
+RLAPI void UnloadShader(Shader shader);                                    // Unload shader from GPU memory (VRAM)
+
+// Screen-space-related functions
+RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera);      // Get a ray trace from mouse position
+RLAPI Matrix GetCameraMatrix(Camera camera);                      // Get camera transform matrix (view matrix)
+RLAPI Matrix GetCameraMatrix2D(Camera2D camera);                  // Get camera 2d transform matrix
+RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);  // Get the screen space position for a 3d world space position
+RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position
+RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
+RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position
+
+// Timing-related functions
+RLAPI void SetTargetFPS(int fps);                                 // Set target FPS (maximum)
+RLAPI int GetFPS(void);                                           // Get current FPS
+RLAPI float GetFrameTime(void);                                   // Get time in seconds for last frame drawn (delta time)
+RLAPI double GetTime(void);                                       // Get elapsed time in seconds since InitWindow()
+
+// Misc. functions
+RLAPI int GetRandomValue(int min, int max);                       // Get a random value between min and max (both included)
+RLAPI void SetRandomSeed(unsigned int seed);                      // Set the seed for the random number generator
+RLAPI void TakeScreenshot(const char *fileName);                  // Takes a screenshot of current screen (filename extension defines format)
+RLAPI void SetConfigFlags(unsigned int flags);                    // Setup init configuration flags (view FLAGS)
+
+RLAPI void TraceLog(int logLevel, const char *text, ...);         // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
+RLAPI void SetTraceLogLevel(int logLevel);                        // Set the current threshold (minimum) log level
+RLAPI void *MemAlloc(int size);                                   // Internal memory allocator
+RLAPI void *MemRealloc(void *ptr, int size);                      // Internal memory reallocator
+RLAPI void MemFree(void *ptr);                                    // Internal memory free
+
+// Set custom callbacks
+// WARNING: Callbacks setup is intended for advance users
+RLAPI void SetTraceLogCallback(TraceLogCallback callback);         // Set custom trace log
+RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader
+RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver
+RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader
+RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver
+
+// Files management functions
+RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead);       // Load file data as byte array (read)
+RLAPI void UnloadFileData(unsigned char *data);                   // Unload file data allocated by LoadFileData()
+RLAPI bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite);   // Save data to file from byte array (write), returns true on success
+RLAPI bool ExportDataAsCode(const char *data, unsigned int size, const char *fileName); // Export data to code (.h), returns true on success
+RLAPI char *LoadFileText(const char *fileName);                   // Load text data from file (read), returns a '\0' terminated string
+RLAPI void UnloadFileText(char *text);                            // Unload file text data allocated by LoadFileText()
+RLAPI bool SaveFileText(const char *fileName, char *text);        // Save text data to file (write), string must be '\0' terminated, returns true on success
+RLAPI bool FileExists(const char *fileName);                      // Check if file exists
+RLAPI bool DirectoryExists(const char *dirPath);                  // Check if a directory path exists
+RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav)
+RLAPI int GetFileLength(const char *fileName);                    // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
+RLAPI const char *GetFileExtension(const char *fileName);         // Get pointer to extension for a filename string (includes dot: '.png')
+RLAPI const char *GetFileName(const char *filePath);              // Get pointer to filename for a path string
+RLAPI const char *GetFileNameWithoutExt(const char *filePath);    // Get filename string without extension (uses static string)
+RLAPI const char *GetDirectoryPath(const char *filePath);         // Get full path for a given fileName with path (uses static string)
+RLAPI const char *GetPrevDirectoryPath(const char *dirPath);      // Get previous directory path for a given path (uses static string)
+RLAPI const char *GetWorkingDirectory(void);                      // Get current working directory (uses static string)
+RLAPI const char *GetApplicationDirectory(void);                  // Get the directory if the running application (uses static string)
+RLAPI bool ChangeDirectory(const char *dir);                      // Change working directory, return true on success
+RLAPI bool IsPathFile(const char *path);                          // Check if a given path is a file or a directory
+RLAPI FilePathList LoadDirectoryFiles(const char *dirPath);       // Load directory filepaths
+RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan
+RLAPI void UnloadDirectoryFiles(FilePathList files);              // Unload filepaths
+RLAPI bool IsFileDropped(void);                                   // Check if a file has been dropped into window
+RLAPI FilePathList LoadDroppedFiles(void);                        // Load dropped filepaths
+RLAPI void UnloadDroppedFiles(FilePathList files);                // Unload dropped filepaths
+RLAPI long GetFileModTime(const char *fileName);                  // Get file modification time (last write time)
+
+// Compression/Encoding functionality
+RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize);        // Compress data (DEFLATE algorithm), memory must be MemFree()
+RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize);  // Decompress data (DEFLATE algorithm), memory must be MemFree()
+RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize);               // Encode data to Base64 string, memory must be MemFree()
+RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize);                    // Decode Base64 string data, memory must be MemFree()
+
+// Persistent storage management
+RLAPI bool SaveStorageValue(unsigned int position, int value);    // Save integer value to storage file (to defined position), returns true on success
+RLAPI int LoadStorageValue(unsigned int position);                // Load integer value from storage file (from defined position)
+
+RLAPI void OpenURL(const char *url);                              // Open URL with default system browser (if available)
+
+//------------------------------------------------------------------------------------
+// Input Handling Functions (Module: core)
+//------------------------------------------------------------------------------------
+
+// Input-related functions: keyboard
+RLAPI bool IsKeyPressed(int key);                             // Check if a key has been pressed once
+RLAPI bool IsKeyDown(int key);                                // Check if a key is being pressed
+RLAPI bool IsKeyReleased(int key);                            // Check if a key has been released once
+RLAPI bool IsKeyUp(int key);                                  // Check if a key is NOT being pressed
+RLAPI void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
+RLAPI int GetKeyPressed(void);                                // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
+RLAPI int GetCharPressed(void);                               // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
+
+// Input-related functions: gamepads
+RLAPI bool IsGamepadAvailable(int gamepad);                   // Check if a gamepad is available
+RLAPI const char *GetGamepadName(int gamepad);                // Get gamepad internal name id
+RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Check if a gamepad button has been pressed once
+RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Check if a gamepad button is being pressed
+RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Check if a gamepad button has been released once
+RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Check if a gamepad button is NOT being pressed
+RLAPI int GetGamepadButtonPressed(void);                      // Get the last gamepad button pressed
+RLAPI int GetGamepadAxisCount(int gamepad);                   // Get gamepad axis count for a gamepad
+RLAPI float GetGamepadAxisMovement(int gamepad, int axis);    // Get axis movement value for a gamepad axis
+RLAPI int SetGamepadMappings(const char *mappings);           // Set internal gamepad mappings (SDL_GameControllerDB)
+
+// Input-related functions: mouse
+RLAPI bool IsMouseButtonPressed(int button);                  // Check if a mouse button has been pressed once
+RLAPI bool IsMouseButtonDown(int button);                     // Check if a mouse button is being pressed
+RLAPI bool IsMouseButtonReleased(int button);                 // Check if a mouse button has been released once
+RLAPI bool IsMouseButtonUp(int button);                       // Check if a mouse button is NOT being pressed
+RLAPI int GetMouseX(void);                                    // Get mouse position X
+RLAPI int GetMouseY(void);                                    // Get mouse position Y
+RLAPI Vector2 GetMousePosition(void);                         // Get mouse position XY
+RLAPI Vector2 GetMouseDelta(void);                            // Get mouse delta between frames
+RLAPI void SetMousePosition(int x, int y);                    // Set mouse position XY
+RLAPI void SetMouseOffset(int offsetX, int offsetY);          // Set mouse offset
+RLAPI void SetMouseScale(float scaleX, float scaleY);         // Set mouse scaling
+RLAPI float GetMouseWheelMove(void);                          // Get mouse wheel movement for X or Y, whichever is larger
+RLAPI Vector2 GetMouseWheelMoveV(void);                       // Get mouse wheel movement for both X and Y
+RLAPI void SetMouseCursor(int cursor);                        // Set mouse cursor
+
+// Input-related functions: touch
+RLAPI int GetTouchX(void);                                    // Get touch position X for touch point 0 (relative to screen size)
+RLAPI int GetTouchY(void);                                    // Get touch position Y for touch point 0 (relative to screen size)
+RLAPI Vector2 GetTouchPosition(int index);                    // Get touch position XY for a touch point index (relative to screen size)
+RLAPI int GetTouchPointId(int index);                         // Get touch point identifier for given index
+RLAPI int GetTouchPointCount(void);                           // Get number of touch points
+
+//------------------------------------------------------------------------------------
+// Gestures and Touch Handling Functions (Module: rgestures)
+//------------------------------------------------------------------------------------
+RLAPI void SetGesturesEnabled(unsigned int flags);      // Enable a set of gestures using flags
+RLAPI bool IsGestureDetected(int gesture);              // Check if a gesture have been detected
+RLAPI int GetGestureDetected(void);                     // Get latest detected gesture
+RLAPI float GetGestureHoldDuration(void);               // Get gesture hold time in milliseconds
+RLAPI Vector2 GetGestureDragVector(void);               // Get gesture drag vector
+RLAPI float GetGestureDragAngle(void);                  // Get gesture drag angle
+RLAPI Vector2 GetGesturePinchVector(void);              // Get gesture pinch delta
+RLAPI float GetGesturePinchAngle(void);                 // Get gesture pinch angle
+
+//------------------------------------------------------------------------------------
+// Camera System Functions (Module: rcamera)
+//------------------------------------------------------------------------------------
+RLAPI void SetCameraMode(Camera camera, int mode);      // Set camera mode (multiple camera modes available)
+RLAPI void UpdateCamera(Camera *camera);                // Update camera position for selected mode
+
+RLAPI void SetCameraPanControl(int keyPan);             // Set camera pan key to combine with mouse movement (free camera)
+RLAPI void SetCameraAltControl(int keyAlt);             // Set camera alt key to combine with mouse movement (free camera)
+RLAPI void SetCameraSmoothZoomControl(int keySmoothZoom); // Set camera smooth zoom key to combine with mouse (free camera)
+RLAPI void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown); // Set camera move controls (1st person and 3rd person cameras)
+
+//------------------------------------------------------------------------------------
+// Basic Shapes Drawing Functions (Module: shapes)
+//------------------------------------------------------------------------------------
+// Set texture and rectangle to be used on shapes drawing
+// NOTE: It can be useful when using basic shapes and one single font,
+// defining a font char white rectangle would allow drawing everything in a single draw call
+RLAPI void SetShapesTexture(Texture2D texture, Rectangle source);       // Set texture and rectangle to be used on shapes drawing
+
+// Basic shapes drawing functions
+RLAPI void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel
+RLAPI void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel (Vector version)
+RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                // Draw a line
+RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (Vector version)
+RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line defining thickness
+RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw a line using cubic-bezier curves in-out
+RLAPI void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); // Draw line using quadratic bezier curves with a control point
+RLAPI void DrawLineBezierCubic(Vector2 startPos, Vector2 endPos, Vector2 startControlPos, Vector2 endControlPos, float thick, Color color); // Draw line using cubic bezier curves with 2 control points
+RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color);                                  // Draw lines sequence
+RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
+RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color);      // Draw a piece of a circle
+RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
+RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);       // Draw a gradient-filled circle
+RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
+RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
+RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);             // Draw ellipse
+RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);        // Draw ellipse outline
+RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring
+RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color);    // Draw ring outline
+RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color);                        // Draw a color-filled rectangle
+RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
+RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
+RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
+RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
+RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
+RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors
+RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
+RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color);                            // Draw rectangle outline with extended parameters
+RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);              // Draw rectangle with rounded edges
+RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline
+RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color);                                // Draw a triangle fan defined by points (first vertex is the center)
+RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color);                              // Draw a triangle strip defined by points
+RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
+RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);          // Draw a polygon outline of n sides
+RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters
+
+// Basic shapes collision detection functions
+RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                           // Check collision between two rectangles
+RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);        // Check collision between two circles
+RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                         // Check collision between circle and rectangle
+RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                         // Check if point is inside rectangle
+RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                       // Check if point is inside circle
+RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);               // Check if point is inside a triangle
+RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference
+RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold);                // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
+RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                         // Get collision rectangle for two rectangles collision
+
+//------------------------------------------------------------------------------------
+// Texture Loading and Drawing Functions (Module: textures)
+//------------------------------------------------------------------------------------
+
+// Image loading functions
+// NOTE: This functions do not require GPU access
+RLAPI Image LoadImage(const char *fileName);                                                             // Load image from file into CPU memory (RAM)
+RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);       // Load image from RAW file data
+RLAPI Image LoadImageAnim(const char *fileName, int *frames);                                            // Load image sequence from file (frames appended to image.data)
+RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);      // Load image from memory buffer, fileType refers to extension: i.e. '.png'
+RLAPI Image LoadImageFromTexture(Texture2D texture);                                                     // Load image from GPU texture data
+RLAPI Image LoadImageFromScreen(void);                                                                   // Load image from screen buffer and (screenshot)
+RLAPI void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
+RLAPI bool ExportImage(Image image, const char *fileName);                                               // Export image data to file, returns true on success
+RLAPI bool ExportImageAsCode(Image image, const char *fileName);                                         // Export image as code file defining an array of bytes, returns true on success
+
+// Image generation functions
+RLAPI Image GenImageColor(int width, int height, Color color);                                           // Generate image: plain color
+RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom);                           // Generate image: vertical gradient
+RLAPI Image GenImageGradientH(int width, int height, Color left, Color right);                           // Generate image: horizontal gradient
+RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer);      // Generate image: radial gradient
+RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);    // Generate image: checked
+RLAPI Image GenImageWhiteNoise(int width, int height, float factor);                                     // Generate image: white noise
+RLAPI Image GenImageCellular(int width, int height, int tileSize);                                       // Generate image: cellular algorithm, bigger tileSize means bigger cells
+
+// Image manipulation functions
+RLAPI Image ImageCopy(Image image);                                                                      // Create an image duplicate (useful for transformations)
+RLAPI Image ImageFromImage(Image image, Rectangle rec);                                                  // Create an image from another image piece
+RLAPI Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
+RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint);         // Create an image from text (custom sprite font)
+RLAPI void ImageFormat(Image *image, int newFormat);                                                     // Convert image data to desired format
+RLAPI void ImageToPOT(Image *image, Color fill);                                                         // Convert image to POT (power-of-two)
+RLAPI void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
+RLAPI void ImageAlphaCrop(Image *image, float threshold);                                                // Crop image depending on alpha value
+RLAPI void ImageAlphaClear(Image *image, Color color, float threshold);                                  // Clear alpha channel to desired color
+RLAPI void ImageAlphaMask(Image *image, Image alphaMask);                                                // Apply alpha mask to image
+RLAPI void ImageAlphaPremultiply(Image *image);                                                          // Premultiply alpha channel
+RLAPI void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize image (Bicubic scaling algorithm)
+RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight);                                      // Resize image (Nearest-Neighbor scaling algorithm)
+RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill);  // Resize canvas and fill with color
+RLAPI void ImageMipmaps(Image *image);                                                                   // Compute all mipmap levels for a provided image
+RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
+RLAPI void ImageFlipVertical(Image *image);                                                              // Flip image vertically
+RLAPI void ImageFlipHorizontal(Image *image);                                                            // Flip image horizontally
+RLAPI void ImageRotateCW(Image *image);                                                                  // Rotate image clockwise 90deg
+RLAPI void ImageRotateCCW(Image *image);                                                                 // Rotate image counter-clockwise 90deg
+RLAPI void ImageColorTint(Image *image, Color color);                                                    // Modify image color: tint
+RLAPI void ImageColorInvert(Image *image);                                                               // Modify image color: invert
+RLAPI void ImageColorGrayscale(Image *image);                                                            // Modify image color: grayscale
+RLAPI void ImageColorContrast(Image *image, float contrast);                                             // Modify image color: contrast (-100 to 100)
+RLAPI void ImageColorBrightness(Image *image, int brightness);                                           // Modify image color: brightness (-255 to 255)
+RLAPI void ImageColorReplace(Image *image, Color color, Color replace);                                  // Modify image color: replace color
+RLAPI Color *LoadImageColors(Image image);                                                               // Load color data from image as a Color array (RGBA - 32bit)
+RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount);                         // Load colors palette from image as a Color array (RGBA - 32bit)
+RLAPI void UnloadImageColors(Color *colors);                                                             // Unload color data loaded with LoadImageColors()
+RLAPI void UnloadImagePalette(Color *colors);                                                            // Unload colors palette loaded with LoadImagePalette()
+RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold);                                       // Get image alpha border rectangle
+RLAPI Color GetImageColor(Image image, int x, int y);                                                    // Get image pixel color at (x, y) position
+
+// Image drawing functions
+// NOTE: Image software-rendering functions (CPU)
+RLAPI void ImageClearBackground(Image *dst, Color color);                                                // Clear image background with given color
+RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color);                                  // Draw pixel within an image
+RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color);                                   // Draw pixel within an image (Vector version)
+RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image
+RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color);                          // Draw line within an image (Vector version)
+RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color);               // Draw circle within an image
+RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color);                        // Draw circle within an image (Vector version)
+RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color);       // Draw rectangle within an image
+RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color);                 // Draw rectangle within an image (Vector version)
+RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image
+RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color);                   // Draw rectangle lines within an image
+RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint);             // Draw a source image within a destination image (tint applied to source)
+RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color);   // Draw text (using default font) within an image (destination)
+RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination)
+
+// Texture loading functions
+// NOTE: These functions require GPU access
+RLAPI Texture2D LoadTexture(const char *fileName);                                                       // Load texture from file into GPU memory (VRAM)
+RLAPI Texture2D LoadTextureFromImage(Image image);                                                       // Load texture from image data
+RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout);                                        // Load cubemap from image, multiple image cubemap layouts supported
+RLAPI RenderTexture2D LoadRenderTexture(int width, int height);                                          // Load texture for rendering (framebuffer)
+RLAPI void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
+RLAPI void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
+RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data
+RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data
+
+// Texture configuration functions
+RLAPI void GenTextureMipmaps(Texture2D *texture);                                                        // Generate GPU mipmaps for a texture
+RLAPI void SetTextureFilter(Texture2D texture, int filter);                                              // Set texture scaling filter mode
+RLAPI void SetTextureWrap(Texture2D texture, int wrap);                                                  // Set texture wrapping mode
+
+// Texture drawing functions
+RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint);                               // Draw a Texture2D
+RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);                                // Draw a Texture2D with position defined as Vector2
+RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
+RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint);            // Draw a part of a texture defined by a rectangle
+RLAPI void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint);  // Draw texture quad with tiling and offset parameters
+RLAPI void DrawTextureTiled(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, float scale, Color tint); // Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.
+RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint);           // Draw a part of a texture defined by a rectangle with 'pro' parameters
+RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint);   // Draws a texture (or part of it) that stretches or shrinks nicely
+RLAPI void DrawTexturePoly(Texture2D texture, Vector2 center, Vector2 *points, Vector2 *texcoords, int pointCount, Color tint);       // Draw a textured polygon
+
+// Color/pixel related functions
+RLAPI Color Fade(Color color, float alpha);                                 // Get color with alpha applied, alpha goes from 0.0f to 1.0f
+RLAPI int ColorToInt(Color color);                                          // Get hexadecimal value for a Color
+RLAPI Vector4 ColorNormalize(Color color);                                  // Get Color normalized as float [0..1]
+RLAPI Color ColorFromNormalized(Vector4 normalized);                        // Get Color from normalized values [0..1]
+RLAPI Vector3 ColorToHSV(Color color);                                      // Get HSV values for a Color, hue [0..360], saturation/value [0..1]
+RLAPI Color ColorFromHSV(float hue, float saturation, float value);         // Get a Color from HSV values, hue [0..360], saturation/value [0..1]
+RLAPI Color ColorAlpha(Color color, float alpha);                           // Get color with alpha applied, alpha goes from 0.0f to 1.0f
+RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint);              // Get src alpha-blended into dst color with tint
+RLAPI Color GetColor(unsigned int hexValue);                                // Get Color structure from hexadecimal value
+RLAPI Color GetPixelColor(void *srcPtr, int format);                        // Get Color from a source pixel pointer of certain format
+RLAPI void SetPixelColor(void *dstPtr, Color color, int format);            // Set color formatted into destination pixel pointer
+RLAPI int GetPixelDataSize(int width, int height, int format);              // Get pixel data size in bytes for certain format
+
+//------------------------------------------------------------------------------------
+// Font Loading and Text Drawing Functions (Module: text)
+//------------------------------------------------------------------------------------
+
+// Font loading/unloading functions
+RLAPI Font GetFontDefault(void);                                                            // Get the default Font
+RLAPI Font LoadFont(const char *fileName);                                                  // Load font from file into GPU memory (VRAM)
+RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount);  // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set
+RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar);                        // Load font from Image (XNA style)
+RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
+RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use
+RLAPI Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
+RLAPI void UnloadFontData(GlyphInfo *chars, int glyphCount);                                // Unload font chars info data (RAM)
+RLAPI void UnloadFont(Font font);                                                           // Unload font from GPU memory (VRAM)
+RLAPI bool ExportFontAsCode(Font font, const char *fileName);                               // Export font as code file, returns true on success
+
+// Text drawing functions
+RLAPI void DrawFPS(int posX, int posY);                                                     // Draw current FPS
+RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color);       // Draw text (using default font)
+RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
+RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
+RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
+RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
+
+// Text font info functions
+RLAPI int MeasureText(const char *text, int fontSize);                                      // Measure string width for default font
+RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);    // Measure string size for Font
+RLAPI int GetGlyphIndex(Font font, int codepoint);                                          // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
+RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint);                                     // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
+RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint);                                 // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
+
+// Text codepoints management functions (unicode characters)
+RLAPI int *LoadCodepoints(const char *text, int *count);              // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
+RLAPI void UnloadCodepoints(int *codepoints);                         // Unload codepoints data from memory
+RLAPI int GetCodepointCount(const char *text);                        // Get total number of codepoints in a UTF-8 encoded string
+RLAPI int GetCodepoint(const char *text, int *bytesProcessed);        // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
+RLAPI const char *CodepointToUTF8(int codepoint, int *byteSize);      // Encode one codepoint into UTF-8 byte array (array length returned as parameter)
+RLAPI char *TextCodepointsToUTF8(const int *codepoints, int length);  // Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)
+
+// Text strings management functions (no UTF-8 strings, only byte chars)
+// NOTE: Some strings allocate memory internally for returned strings, just be careful!
+RLAPI int TextCopy(char *dst, const char *src);                                             // Copy one string to another, returns bytes copied
+RLAPI bool TextIsEqual(const char *text1, const char *text2);                               // Check if two text string are equal
+RLAPI unsigned int TextLength(const char *text);                                            // Get text length, checks for '\0' ending
+RLAPI const char *TextFormat(const char *text, ...);                                        // Text formatting with variables (sprintf() style)
+RLAPI const char *TextSubtext(const char *text, int position, int length);                  // Get a piece of a text string
+RLAPI char *TextReplace(char *text, const char *replace, const char *by);                   // Replace text string (WARNING: memory must be freed!)
+RLAPI char *TextInsert(const char *text, const char *insert, int position);                 // Insert text in a position (WARNING: memory must be freed!)
+RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter);        // Join text strings with delimiter
+RLAPI const char **TextSplit(const char *text, char delimiter, int *count);                 // Split text into multiple strings
+RLAPI void TextAppend(char *text, const char *append, int *position);                       // Append text at specific position and move cursor!
+RLAPI int TextFindIndex(const char *text, const char *find);                                // Find first text occurrence within a string
+RLAPI const char *TextToUpper(const char *text);                      // Get upper case version of provided string
+RLAPI const char *TextToLower(const char *text);                      // Get lower case version of provided string
+RLAPI const char *TextToPascal(const char *text);                     // Get Pascal case notation version of provided string
+RLAPI int TextToInteger(const char *text);                            // Get integer value from text (negative values not supported)
+
+//------------------------------------------------------------------------------------
+// Basic 3d Shapes Drawing Functions (Module: models)
+//------------------------------------------------------------------------------------
+
+// Basic geometric 3D shapes drawing functions
+RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
+RLAPI void DrawPoint3D(Vector3 position, Color color);                                                   // Draw a point in 3D space, actually a small line
+RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
+RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color);                            // Draw a triangle strip defined by points
+RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
+RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
+RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
+RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  // Draw cube wires (Vector version)
+RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured
+RLAPI void DrawCubeTextureRec(Texture2D texture, Rectangle source, Vector3 position, float width, float height, float length, Color color); // Draw cube with a region of a texture
+RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
+RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
+RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
+RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
+RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos
+RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
+RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
+RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
+RLAPI void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
+RLAPI void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
+
+//------------------------------------------------------------------------------------
+// Model 3d Loading and Drawing Functions (Module: models)
+//------------------------------------------------------------------------------------
+
+// Model management functions
+RLAPI Model LoadModel(const char *fileName);                                                // Load model from files (meshes and materials)
+RLAPI Model LoadModelFromMesh(Mesh mesh);                                                   // Load model from generated mesh (default material)
+RLAPI void UnloadModel(Model model);                                                        // Unload model (including meshes) from memory (RAM and/or VRAM)
+RLAPI void UnloadModelKeepMeshes(Model model);                                              // Unload model (but not meshes) from memory (RAM and/or VRAM)
+RLAPI BoundingBox GetModelBoundingBox(Model model);                                         // Compute model bounding box limits (considers all meshes)
+
+// Model drawing functions
+RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);                           // Draw a model (with texture if set)
+RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
+RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                      // Draw a model wires (with texture if set)
+RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
+RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                               // Draw bounding box (wires)
+RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint);   // Draw a billboard texture
+RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
+RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation
+
+// Mesh management functions
+RLAPI void UploadMesh(Mesh *mesh, bool dynamic);                                            // Upload mesh vertex data in GPU and provide VAO/VBO ids
+RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index
+RLAPI void UnloadMesh(Mesh mesh);                                                           // Unload mesh data from CPU and GPU
+RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform);                        // Draw a 3d mesh with material and transform
+RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms
+RLAPI bool ExportMesh(Mesh mesh, const char *fileName);                                     // Export mesh data to file, returns true on success
+RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh);                                            // Compute mesh bounding box limits
+RLAPI void GenMeshTangents(Mesh *mesh);                                                     // Compute mesh tangents
+RLAPI void GenMeshBinormals(Mesh *mesh);                                                    // Compute mesh binormals
+
+// Mesh generation functions
+RLAPI Mesh GenMeshPoly(int sides, float radius);                                            // Generate polygonal mesh
+RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                     // Generate plane mesh (with subdivisions)
+RLAPI Mesh GenMeshCube(float width, float height, float length);                            // Generate cuboid mesh
+RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                              // Generate sphere mesh (standard sphere)
+RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices);                          // Generate half-sphere mesh (no bottom cap)
+RLAPI Mesh GenMeshCylinder(float radius, float height, int slices);                         // Generate cylinder mesh
+RLAPI Mesh GenMeshCone(float radius, float height, int slices);                             // Generate cone/pyramid mesh
+RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                   // Generate torus mesh
+RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                    // Generate trefoil knot mesh
+RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                 // Generate heightmap mesh from image data
+RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                               // Generate cubes-based map mesh from image data
+
+// Material loading/unloading functions
+RLAPI Material *LoadMaterials(const char *fileName, int *materialCount);                    // Load materials from model file
+RLAPI Material LoadMaterialDefault(void);                                                   // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
+RLAPI void UnloadMaterial(Material material);                                               // Unload material from GPU memory (VRAM)
+RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture);          // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
+RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId);                  // Set material for a mesh
+
+// Model animations loading/unloading functions
+RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, unsigned int *animCount);   // Load model animations from file
+RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);               // Update model animation pose
+RLAPI void UnloadModelAnimation(ModelAnimation anim);                                       // Unload animation data
+RLAPI void UnloadModelAnimations(ModelAnimation *animations, unsigned int count);           // Unload animation array data
+RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim);                         // Check model animation skeleton match
+
+// Collision detection functions
+RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2);   // Check collision between two spheres
+RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                 // Check collision between two bounding boxes
+RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                  // Check collision between box and sphere
+RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius);                    // Get collision info between ray and sphere
+RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box);                                    // Get collision info between ray and box
+RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform);                       // Get collision info between ray and mesh
+RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);            // Get collision info between ray and triangle
+RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4);    // Get collision info between ray and quad
+
+//------------------------------------------------------------------------------------
+// Audio Loading and Playing Functions (Module: audio)
+//------------------------------------------------------------------------------------
+typedef void (*AudioCallback)(void *bufferData, unsigned int frames);
+
+// Audio device management functions
+RLAPI void InitAudioDevice(void);                                     // Initialize audio device and context
+RLAPI void CloseAudioDevice(void);                                    // Close the audio device and context
+RLAPI bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
+RLAPI void SetMasterVolume(float volume);                             // Set master volume (listener)
+
+// Wave/Sound loading/unloading functions
+RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
+RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
+RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
+RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
+RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
+RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
+RLAPI void UnloadSound(Sound sound);                                  // Unload sound
+RLAPI bool ExportWave(Wave wave, const char *fileName);               // Export wave data to file, returns true on success
+RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h), returns true on success
+
+// Wave/Sound management functions
+RLAPI void PlaySound(Sound sound);                                    // Play a sound
+RLAPI void StopSound(Sound sound);                                    // Stop playing a sound
+RLAPI void PauseSound(Sound sound);                                   // Pause a sound
+RLAPI void ResumeSound(Sound sound);                                  // Resume a paused sound
+RLAPI void PlaySoundMulti(Sound sound);                               // Play a sound (using multichannel buffer pool)
+RLAPI void StopSoundMulti(void);                                      // Stop any sound playing (using multichannel buffer pool)
+RLAPI int GetSoundsPlaying(void);                                     // Get number of sounds playing in the multichannel
+RLAPI bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
+RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
+RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
+RLAPI void SetSoundPan(Sound sound, float pan);                       // Set pan for a sound (0.5 is center)
+RLAPI Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
+RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample);     // Crop a wave to defined samples range
+RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
+RLAPI float *LoadWaveSamples(Wave wave);                              // Load samples data from wave as a 32bit float data array
+RLAPI void UnloadWaveSamples(float *samples);                         // Unload samples data loaded with LoadWaveSamples()
+
+// Music management functions
+RLAPI Music LoadMusicStream(const char *fileName);                    // Load music stream from file
+RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
+RLAPI void UnloadMusicStream(Music music);                            // Unload music stream
+RLAPI void PlayMusicStream(Music music);                              // Start music playing
+RLAPI bool IsMusicStreamPlaying(Music music);                         // Check if music is playing
+RLAPI void UpdateMusicStream(Music music);                            // Updates buffers for music streaming
+RLAPI void StopMusicStream(Music music);                              // Stop music playing
+RLAPI void PauseMusicStream(Music music);                             // Pause music playing
+RLAPI void ResumeMusicStream(Music music);                            // Resume playing paused music
+RLAPI void SeekMusicStream(Music music, float position);              // Seek music to a position (in seconds)
+RLAPI void SetMusicVolume(Music music, float volume);                 // Set volume for music (1.0 is max level)
+RLAPI void SetMusicPitch(Music music, float pitch);                   // Set pitch for a music (1.0 is base level)
+RLAPI void SetMusicPan(Music music, float pan);                       // Set pan for a music (0.5 is center)
+RLAPI float GetMusicTimeLength(Music music);                          // Get music time length (in seconds)
+RLAPI float GetMusicTimePlayed(Music music);                          // Get current music time played (in seconds)
+
+// AudioStream management functions
+RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
+RLAPI void UnloadAudioStream(AudioStream stream);                     // Unload audio stream and free memory
+RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data
+RLAPI bool IsAudioStreamProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
+RLAPI void PlayAudioStream(AudioStream stream);                       // Play audio stream
+RLAPI void PauseAudioStream(AudioStream stream);                      // Pause audio stream
+RLAPI void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
+RLAPI bool IsAudioStreamPlaying(AudioStream stream);                  // Check if audio stream is playing
+RLAPI void StopAudioStream(AudioStream stream);                       // Stop audio stream
+RLAPI void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
+RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
+RLAPI void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan for audio stream (0.5 is centered)
+RLAPI void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
+RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback);  // Audio thread callback to request new data
+
+RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor);
+RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // RAYLIB_H
+ rlImGui/raylib/src/raymath.h view
@@ -0,0 +1,2020 @@+/**********************************************************************************************
+*
+*   raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions
+*
+*   CONFIGURATION:
+*
+*   #define RAYMATH_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   #define RAYMATH_STATIC_INLINE
+*       Define static inline functions code, so #include header suffices for use.
+*       This may use up lots of memory.
+*
+*   CONVENTIONS:
+*
+*     - Functions are always self-contained, no function use another raymath function inside,
+*       required code is directly re-implemented inside
+*     - Functions input parameters are always received by value (2 unavoidable exceptions)
+*     - Functions use always a "result" variable for return
+*     - Functions are always defined inline
+*     - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience)
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2015-2022 Ramon Santamaria (@raysan5)
+*
+*   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 RAYMATH_H
+#define RAYMATH_H
+
+#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE)
+    #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory"
+#endif
+
+// Function specifiers definition
+#if defined(RAYMATH_IMPLEMENTATION)
+    #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
+        #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll).
+    #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
+        #define RMAPI __declspec(dllimport)         // We are using raylib as a Win32 shared library (.dll)
+    #else
+        #define RMAPI extern inline // Provide external definition
+    #endif
+#elif defined(RAYMATH_STATIC_INLINE)
+    #define RMAPI static inline // Functions may be inlined, no external out-of-line definition
+#else
+    #if defined(__TINYC__)
+        #define RMAPI static inline // plain inline not supported by tinycc (See issue #435)
+    #else
+        #define RMAPI inline        // Functions may be inlined or external definition used
+    #endif
+#endif
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#ifndef PI
+    #define PI 3.14159265358979323846f
+#endif
+
+#ifndef EPSILON
+    #define EPSILON 0.000001f
+#endif
+
+#ifndef DEG2RAD
+    #define DEG2RAD (PI/180.0f)
+#endif
+
+#ifndef RAD2DEG
+    #define RAD2DEG (180.0f/PI)
+#endif
+
+// Get float vector for Matrix
+#ifndef MatrixToFloat
+    #define MatrixToFloat(mat) (MatrixToFloatV(mat).v)
+#endif
+
+// Get float vector for Vector3
+#ifndef Vector3ToFloat
+    #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v)
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+#if !defined(RL_VECTOR2_TYPE)
+// Vector2 type
+typedef struct Vector2 {
+    float x;
+    float y;
+} Vector2;
+#define RL_VECTOR2_TYPE
+#endif
+
+#if !defined(RL_VECTOR3_TYPE)
+// Vector3 type
+typedef struct Vector3 {
+    float x;
+    float y;
+    float z;
+} Vector3;
+#define RL_VECTOR3_TYPE
+#endif
+
+#if !defined(RL_VECTOR4_TYPE)
+// Vector4 type
+typedef struct Vector4 {
+    float x;
+    float y;
+    float z;
+    float w;
+} Vector4;
+#define RL_VECTOR4_TYPE
+#endif
+
+#if !defined(RL_QUATERNION_TYPE)
+// Quaternion type
+typedef Vector4 Quaternion;
+#define RL_QUATERNION_TYPE
+#endif
+
+#if !defined(RL_MATRIX_TYPE)
+// Matrix type (OpenGL style 4x4 - right handed, column major)
+typedef struct Matrix {
+    float m0, m4, m8, m12;      // Matrix first row (4 components)
+    float m1, m5, m9, m13;      // Matrix second row (4 components)
+    float m2, m6, m10, m14;     // Matrix third row (4 components)
+    float m3, m7, m11, m15;     // Matrix fourth row (4 components)
+} Matrix;
+#define RL_MATRIX_TYPE
+#endif
+
+// NOTE: Helper types to be used instead of array return types for *ToFloat functions
+typedef struct float3 {
+    float v[3];
+} float3;
+
+typedef struct float16 {
+    float v[16];
+} float16;
+
+#include <math.h>       // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs()
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Utils math
+//----------------------------------------------------------------------------------
+
+// Clamp float value
+RMAPI float Clamp(float value, float min, float max)
+{
+    float result = (value < min)? min : value;
+
+    if (result > max) result = max;
+
+    return result;
+}
+
+// Calculate linear interpolation between two floats
+RMAPI float Lerp(float start, float end, float amount)
+{
+    float result = start + amount*(end - start);
+
+    return result;
+}
+
+// Normalize input value within input range
+RMAPI float Normalize(float value, float start, float end)
+{
+    float result = (value - start)/(end - start);
+
+    return result;
+}
+
+// Remap input value within input range to output range
+RMAPI float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd)
+{
+    float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart;
+
+    return result;
+}
+
+// Wrap input value from min to max
+RMAPI float Wrap(float value, float min, float max)
+{
+	float result = value - (max - min)*floor((value - min)/(max - min));
+
+	return result;
+}
+
+// Check whether two given floats are almost equal
+RMAPI int FloatEquals(float x, float y)
+{
+    int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y))));
+
+    return result;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vector2 math
+//----------------------------------------------------------------------------------
+
+// Vector with components value 0.0f
+RMAPI Vector2 Vector2Zero(void)
+{
+    Vector2 result = { 0.0f, 0.0f };
+
+    return result;
+}
+
+// Vector with components value 1.0f
+RMAPI Vector2 Vector2One(void)
+{
+    Vector2 result = { 1.0f, 1.0f };
+
+    return result;
+}
+
+// Add two vectors (v1 + v2)
+RMAPI Vector2 Vector2Add(Vector2 v1, Vector2 v2)
+{
+    Vector2 result = { v1.x + v2.x, v1.y + v2.y };
+
+    return result;
+}
+
+// Add vector and float value
+RMAPI Vector2 Vector2AddValue(Vector2 v, float add)
+{
+    Vector2 result = { v.x + add, v.y + add };
+
+    return result;
+}
+
+// Subtract two vectors (v1 - v2)
+RMAPI Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
+{
+    Vector2 result = { v1.x - v2.x, v1.y - v2.y };
+
+    return result;
+}
+
+// Subtract vector by float value
+RMAPI Vector2 Vector2SubtractValue(Vector2 v, float sub)
+{
+    Vector2 result = { v.x - sub, v.y - sub };
+
+    return result;
+}
+
+// Calculate vector length
+RMAPI float Vector2Length(Vector2 v)
+{
+    float result = sqrtf((v.x*v.x) + (v.y*v.y));
+
+    return result;
+}
+
+// Calculate vector square length
+RMAPI float Vector2LengthSqr(Vector2 v)
+{
+    float result = (v.x*v.x) + (v.y*v.y);
+
+    return result;
+}
+
+// Calculate two vectors dot product
+RMAPI float Vector2DotProduct(Vector2 v1, Vector2 v2)
+{
+    float result = (v1.x*v2.x + v1.y*v2.y);
+
+    return result;
+}
+
+// Calculate distance between two vectors
+RMAPI float Vector2Distance(Vector2 v1, Vector2 v2)
+{
+    float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));
+
+    return result;
+}
+
+// Calculate square distance between two vectors
+RMAPI float Vector2DistanceSqr(Vector2 v1, Vector2 v2)
+{
+    float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));
+
+    return result;
+}
+
+// Calculate angle from two vectors
+RMAPI float Vector2Angle(Vector2 v1, Vector2 v2)
+{
+    float result = atan2f(v2.y, v2.x) - atan2f(v1.y, v1.x);
+
+    return result;
+}
+
+// Scale vector (multiply by value)
+RMAPI Vector2 Vector2Scale(Vector2 v, float scale)
+{
+    Vector2 result = { v.x*scale, v.y*scale };
+
+    return result;
+}
+
+// Multiply vector by vector
+RMAPI Vector2 Vector2Multiply(Vector2 v1, Vector2 v2)
+{
+    Vector2 result = { v1.x*v2.x, v1.y*v2.y };
+
+    return result;
+}
+
+// Negate vector
+RMAPI Vector2 Vector2Negate(Vector2 v)
+{
+    Vector2 result = { -v.x, -v.y };
+
+    return result;
+}
+
+// Divide vector by vector
+RMAPI Vector2 Vector2Divide(Vector2 v1, Vector2 v2)
+{
+    Vector2 result = { v1.x/v2.x, v1.y/v2.y };
+
+    return result;
+}
+
+// Normalize provided vector
+RMAPI Vector2 Vector2Normalize(Vector2 v)
+{
+    Vector2 result = { 0 };
+    float length = sqrtf((v.x*v.x) + (v.y*v.y));
+
+    if (length > 0)
+    {
+        float ilength = 1.0f/length;
+        result.x = v.x*ilength;
+        result.y = v.y*ilength;
+    }
+
+    return result;
+}
+
+// Transforms a Vector2 by a given Matrix
+RMAPI Vector2 Vector2Transform(Vector2 v, Matrix mat)
+{
+    Vector2 result = { 0 };
+
+    float x = v.x;
+    float y = v.y;
+    float z = 0;
+
+    result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
+    result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
+
+    return result;
+}
+
+// Calculate linear interpolation between two vectors
+RMAPI Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount)
+{
+    Vector2 result = { 0 };
+
+    result.x = v1.x + amount*(v2.x - v1.x);
+    result.y = v1.y + amount*(v2.y - v1.y);
+
+    return result;
+}
+
+// Calculate reflected vector to normal
+RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal)
+{
+    Vector2 result = { 0 };
+
+    float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product
+
+    result.x = v.x - (2.0f*normal.x)*dotProduct;
+    result.y = v.y - (2.0f*normal.y)*dotProduct;
+
+    return result;
+}
+
+// Rotate vector by angle
+RMAPI Vector2 Vector2Rotate(Vector2 v, float angle)
+{
+    Vector2 result = { 0 };
+
+    float cosres = cosf(angle);
+    float sinres = sinf(angle);
+
+    result.x = v.x*cosres - v.y*sinres;
+    result.y = v.x*sinres + v.y*cosres;
+
+    return result;
+}
+
+// Move Vector towards target
+RMAPI Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance)
+{
+    Vector2 result = { 0 };
+
+    float dx = target.x - v.x;
+    float dy = target.y - v.y;
+    float value = (dx*dx) + (dy*dy);
+
+    if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target;
+
+    float dist = sqrtf(value);
+
+    result.x = v.x + dx/dist*maxDistance;
+    result.y = v.y + dy/dist*maxDistance;
+
+    return result;
+}
+
+// Invert the given vector
+RMAPI Vector2 Vector2Invert(Vector2 v)
+{
+    Vector2 result = { 1.0f/v.x, 1.0f/v.y };
+
+    return result;
+}
+
+// Clamp the components of the vector between
+// min and max values specified by the given vectors
+RMAPI Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max)
+{
+    Vector2 result = { 0 };
+
+    result.x = fminf(max.x, fmaxf(min.x, v.x));
+    result.y = fminf(max.y, fmaxf(min.y, v.y));
+
+    return result;
+}
+
+// Clamp the magnitude of the vector between two min and max values
+RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max)
+{
+    Vector2 result = { 0 };
+
+    float length = (v.x*v.x) + (v.y*v.y);
+    if (length > 0.0f)
+    {
+        length = sqrtf(length);
+
+        if (length < min)
+        {
+            float scale = min/length;
+            result.x = v.x*scale;
+            result.y = v.y*scale;
+        }
+        else if (length > max)
+        {
+            float scale = max/length;
+            result.x = v.x*scale;
+            result.y = v.y*scale;
+        }
+    }
+
+    return result;
+}
+
+// Check whether two given vectors are almost equal
+RMAPI int Vector2Equals(Vector2 p, Vector2 q)
+{
+    int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) &&
+                  ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y)))));
+
+    return result;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vector3 math
+//----------------------------------------------------------------------------------
+
+// Vector with components value 0.0f
+RMAPI Vector3 Vector3Zero(void)
+{
+    Vector3 result = { 0.0f, 0.0f, 0.0f };
+
+    return result;
+}
+
+// Vector with components value 1.0f
+RMAPI Vector3 Vector3One(void)
+{
+    Vector3 result = { 1.0f, 1.0f, 1.0f };
+
+    return result;
+}
+
+// Add two vectors
+RMAPI Vector3 Vector3Add(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
+
+    return result;
+}
+
+// Add vector and float value
+RMAPI Vector3 Vector3AddValue(Vector3 v, float add)
+{
+    Vector3 result = { v.x + add, v.y + add, v.z + add };
+
+    return result;
+}
+
+// Subtract two vectors
+RMAPI Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
+
+    return result;
+}
+
+// Subtract vector by float value
+RMAPI Vector3 Vector3SubtractValue(Vector3 v, float sub)
+{
+    Vector3 result = { v.x - sub, v.y - sub, v.z - sub };
+
+    return result;
+}
+
+// Multiply vector by scalar
+RMAPI Vector3 Vector3Scale(Vector3 v, float scalar)
+{
+    Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar };
+
+    return result;
+}
+
+// Multiply vector by vector
+RMAPI Vector3 Vector3Multiply(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z };
+
+    return result;
+}
+
+// Calculate two vectors cross product
+RMAPI Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x };
+
+    return result;
+}
+
+// Calculate one vector perpendicular vector
+RMAPI Vector3 Vector3Perpendicular(Vector3 v)
+{
+    Vector3 result = { 0 };
+
+    float min = (float) fabs(v.x);
+    Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
+
+    if (fabsf(v.y) < min)
+    {
+        min = (float) fabs(v.y);
+        Vector3 tmp = {0.0f, 1.0f, 0.0f};
+        cardinalAxis = tmp;
+    }
+
+    if (fabsf(v.z) < min)
+    {
+        Vector3 tmp = {0.0f, 0.0f, 1.0f};
+        cardinalAxis = tmp;
+    }
+
+    // Cross product between vectors
+    result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y;
+    result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z;
+    result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x;
+
+    return result;
+}
+
+// Calculate vector length
+RMAPI float Vector3Length(const Vector3 v)
+{
+    float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+
+    return result;
+}
+
+// Calculate vector square length
+RMAPI float Vector3LengthSqr(const Vector3 v)
+{
+    float result = v.x*v.x + v.y*v.y + v.z*v.z;
+
+    return result;
+}
+
+// Calculate two vectors dot product
+RMAPI float Vector3DotProduct(Vector3 v1, Vector3 v2)
+{
+    float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
+
+    return result;
+}
+
+// Calculate distance between two vectors
+RMAPI float Vector3Distance(Vector3 v1, Vector3 v2)
+{
+    float result = 0.0f;
+
+    float dx = v2.x - v1.x;
+    float dy = v2.y - v1.y;
+    float dz = v2.z - v1.z;
+    result = sqrtf(dx*dx + dy*dy + dz*dz);
+
+    return result;
+}
+
+// Calculate square distance between two vectors
+RMAPI float Vector3DistanceSqr(Vector3 v1, Vector3 v2)
+{
+    float result = 0.0f;
+
+    float dx = v2.x - v1.x;
+    float dy = v2.y - v1.y;
+    float dz = v2.z - v1.z;
+    result = dx*dx + dy*dy + dz*dz;
+
+    return result;
+}
+
+// Calculate angle between two vectors
+RMAPI float Vector3Angle(Vector3 v1, Vector3 v2)
+{
+    float result = 0.0f;
+
+    Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x };
+    float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z);
+    float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
+    result = atan2f(len, dot);
+
+    return result;
+}
+
+// Negate provided vector (invert direction)
+RMAPI Vector3 Vector3Negate(Vector3 v)
+{
+    Vector3 result = { -v.x, -v.y, -v.z };
+
+    return result;
+}
+
+// Divide vector by vector
+RMAPI Vector3 Vector3Divide(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z };
+
+    return result;
+}
+
+// Normalize provided vector
+RMAPI Vector3 Vector3Normalize(Vector3 v)
+{
+    Vector3 result = v;
+
+    float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    if (length == 0.0f) length = 1.0f;
+    float ilength = 1.0f/length;
+
+    result.x *= ilength;
+    result.y *= ilength;
+    result.z *= ilength;
+
+    return result;
+}
+
+// Orthonormalize provided vectors
+// Makes vectors normalized and orthogonal to each other
+// Gram-Schmidt function implementation
+RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2)
+{
+    float length = 0.0f;
+    float ilength = 0.0f;
+
+    // Vector3Normalize(*v1);
+    Vector3 v = *v1;
+    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    if (length == 0.0f) length = 1.0f;
+    ilength = 1.0f/length;
+    v1->x *= ilength;
+    v1->y *= ilength;
+    v1->z *= ilength;
+
+    // Vector3CrossProduct(*v1, *v2)
+    Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x };
+
+    // Vector3Normalize(vn1);
+    v = vn1;
+    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    if (length == 0.0f) length = 1.0f;
+    ilength = 1.0f/length;
+    vn1.x *= ilength;
+    vn1.y *= ilength;
+    vn1.z *= ilength;
+
+    // Vector3CrossProduct(vn1, *v1)
+    Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x };
+
+    *v2 = vn2;
+}
+
+// Transforms a Vector3 by a given Matrix
+RMAPI Vector3 Vector3Transform(Vector3 v, Matrix mat)
+{
+    Vector3 result = { 0 };
+
+    float x = v.x;
+    float y = v.y;
+    float z = v.z;
+
+    result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
+    result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
+    result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
+
+    return result;
+}
+
+// Transform a vector by quaternion rotation
+RMAPI Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q)
+{
+    Vector3 result = { 0 };
+
+    result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y);
+    result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z);
+    result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z);
+
+    return result;
+}
+
+// Calculate linear interpolation between two vectors
+RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)
+{
+    Vector3 result = { 0 };
+
+    result.x = v1.x + amount*(v2.x - v1.x);
+    result.y = v1.y + amount*(v2.y - v1.y);
+    result.z = v1.z + amount*(v2.z - v1.z);
+
+    return result;
+}
+
+// Calculate reflected vector to normal
+RMAPI Vector3 Vector3Reflect(Vector3 v, Vector3 normal)
+{
+    Vector3 result = { 0 };
+
+    // I is the original vector
+    // N is the normal of the incident plane
+    // R = I - (2*N*(DotProduct[I, N]))
+
+    float dotProduct = (v.x*normal.x + v.y*normal.y + v.z*normal.z);
+
+    result.x = v.x - (2.0f*normal.x)*dotProduct;
+    result.y = v.y - (2.0f*normal.y)*dotProduct;
+    result.z = v.z - (2.0f*normal.z)*dotProduct;
+
+    return result;
+}
+
+// Get min value for each pair of components
+RMAPI Vector3 Vector3Min(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { 0 };
+
+    result.x = fminf(v1.x, v2.x);
+    result.y = fminf(v1.y, v2.y);
+    result.z = fminf(v1.z, v2.z);
+
+    return result;
+}
+
+// Get max value for each pair of components
+RMAPI Vector3 Vector3Max(Vector3 v1, Vector3 v2)
+{
+    Vector3 result = { 0 };
+
+    result.x = fmaxf(v1.x, v2.x);
+    result.y = fmaxf(v1.y, v2.y);
+    result.z = fmaxf(v1.z, v2.z);
+
+    return result;
+}
+
+// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
+// NOTE: Assumes P is on the plane of the triangle
+RMAPI Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
+{
+    Vector3 result = { 0 };
+
+    Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z };   // Vector3Subtract(b, a)
+    Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z };   // Vector3Subtract(c, a)
+    Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z };   // Vector3Subtract(p, a)
+    float d00 = (v0.x*v0.x + v0.y*v0.y + v0.z*v0.z);    // Vector3DotProduct(v0, v0)
+    float d01 = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z);    // Vector3DotProduct(v0, v1)
+    float d11 = (v1.x*v1.x + v1.y*v1.y + v1.z*v1.z);    // Vector3DotProduct(v1, v1)
+    float d20 = (v2.x*v0.x + v2.y*v0.y + v2.z*v0.z);    // Vector3DotProduct(v2, v0)
+    float d21 = (v2.x*v1.x + v2.y*v1.y + v2.z*v1.z);    // Vector3DotProduct(v2, v1)
+
+    float denom = d00*d11 - d01*d01;
+
+    result.y = (d11*d20 - d01*d21)/denom;
+    result.z = (d00*d21 - d01*d20)/denom;
+    result.x = 1.0f - (result.z + result.y);
+
+    return result;
+}
+
+// Projects a Vector3 from screen space into object space
+// NOTE: We are avoiding calling other raymath functions despite available
+RMAPI Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view)
+{
+    Vector3 result = { 0 };
+
+    // Calculate unproject matrix (multiply view patrix by projection matrix) and invert it
+    Matrix matViewProj = {      // MatrixMultiply(view, projection);
+        view.m0*projection.m0 + view.m1*projection.m4 + view.m2*projection.m8 + view.m3*projection.m12,
+        view.m0*projection.m1 + view.m1*projection.m5 + view.m2*projection.m9 + view.m3*projection.m13,
+        view.m0*projection.m2 + view.m1*projection.m6 + view.m2*projection.m10 + view.m3*projection.m14,
+        view.m0*projection.m3 + view.m1*projection.m7 + view.m2*projection.m11 + view.m3*projection.m15,
+        view.m4*projection.m0 + view.m5*projection.m4 + view.m6*projection.m8 + view.m7*projection.m12,
+        view.m4*projection.m1 + view.m5*projection.m5 + view.m6*projection.m9 + view.m7*projection.m13,
+        view.m4*projection.m2 + view.m5*projection.m6 + view.m6*projection.m10 + view.m7*projection.m14,
+        view.m4*projection.m3 + view.m5*projection.m7 + view.m6*projection.m11 + view.m7*projection.m15,
+        view.m8*projection.m0 + view.m9*projection.m4 + view.m10*projection.m8 + view.m11*projection.m12,
+        view.m8*projection.m1 + view.m9*projection.m5 + view.m10*projection.m9 + view.m11*projection.m13,
+        view.m8*projection.m2 + view.m9*projection.m6 + view.m10*projection.m10 + view.m11*projection.m14,
+        view.m8*projection.m3 + view.m9*projection.m7 + view.m10*projection.m11 + view.m11*projection.m15,
+        view.m12*projection.m0 + view.m13*projection.m4 + view.m14*projection.m8 + view.m15*projection.m12,
+        view.m12*projection.m1 + view.m13*projection.m5 + view.m14*projection.m9 + view.m15*projection.m13,
+        view.m12*projection.m2 + view.m13*projection.m6 + view.m14*projection.m10 + view.m15*projection.m14,
+        view.m12*projection.m3 + view.m13*projection.m7 + view.m14*projection.m11 + view.m15*projection.m15 };
+
+    // Calculate inverted matrix -> MatrixInvert(matViewProj);
+    // Cache the matrix values (speed optimization)
+    float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3;
+    float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7;
+    float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11;
+    float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15;
+
+    float b00 = a00*a11 - a01*a10;
+    float b01 = a00*a12 - a02*a10;
+    float b02 = a00*a13 - a03*a10;
+    float b03 = a01*a12 - a02*a11;
+    float b04 = a01*a13 - a03*a11;
+    float b05 = a02*a13 - a03*a12;
+    float b06 = a20*a31 - a21*a30;
+    float b07 = a20*a32 - a22*a30;
+    float b08 = a20*a33 - a23*a30;
+    float b09 = a21*a32 - a22*a31;
+    float b10 = a21*a33 - a23*a31;
+    float b11 = a22*a33 - a23*a32;
+
+    // Calculate the invert determinant (inlined to avoid double-caching)
+    float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06);
+
+    Matrix matViewProjInv = {
+        (a11*b11 - a12*b10 + a13*b09)*invDet,
+        (-a01*b11 + a02*b10 - a03*b09)*invDet,
+        (a31*b05 - a32*b04 + a33*b03)*invDet,
+        (-a21*b05 + a22*b04 - a23*b03)*invDet,
+        (-a10*b11 + a12*b08 - a13*b07)*invDet,
+        (a00*b11 - a02*b08 + a03*b07)*invDet,
+        (-a30*b05 + a32*b02 - a33*b01)*invDet,
+        (a20*b05 - a22*b02 + a23*b01)*invDet,
+        (a10*b10 - a11*b08 + a13*b06)*invDet,
+        (-a00*b10 + a01*b08 - a03*b06)*invDet,
+        (a30*b04 - a31*b02 + a33*b00)*invDet,
+        (-a20*b04 + a21*b02 - a23*b00)*invDet,
+        (-a10*b09 + a11*b07 - a12*b06)*invDet,
+        (a00*b09 - a01*b07 + a02*b06)*invDet,
+        (-a30*b03 + a31*b01 - a32*b00)*invDet,
+        (a20*b03 - a21*b01 + a22*b00)*invDet };
+
+    // Create quaternion from source point
+    Quaternion quat = { source.x, source.y, source.z, 1.0f };
+
+    // Multiply quat point by unproject matrix
+    Quaternion qtransformed = {     // QuaternionTransform(quat, matViewProjInv)
+        matViewProjInv.m0*quat.x + matViewProjInv.m4*quat.y + matViewProjInv.m8*quat.z + matViewProjInv.m12*quat.w,
+        matViewProjInv.m1*quat.x + matViewProjInv.m5*quat.y + matViewProjInv.m9*quat.z + matViewProjInv.m13*quat.w,
+        matViewProjInv.m2*quat.x + matViewProjInv.m6*quat.y + matViewProjInv.m10*quat.z + matViewProjInv.m14*quat.w,
+        matViewProjInv.m3*quat.x + matViewProjInv.m7*quat.y + matViewProjInv.m11*quat.z + matViewProjInv.m15*quat.w };
+
+    // Normalized world points in vectors
+    result.x = qtransformed.x/qtransformed.w;
+    result.y = qtransformed.y/qtransformed.w;
+    result.z = qtransformed.z/qtransformed.w;
+
+    return result;
+}
+
+// Get Vector3 as float array
+RMAPI float3 Vector3ToFloatV(Vector3 v)
+{
+    float3 buffer = { 0 };
+
+    buffer.v[0] = v.x;
+    buffer.v[1] = v.y;
+    buffer.v[2] = v.z;
+
+    return buffer;
+}
+
+// Invert the given vector
+RMAPI Vector3 Vector3Invert(Vector3 v)
+{
+    Vector3 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z };
+
+    return result;
+}
+
+// Clamp the components of the vector between
+// min and max values specified by the given vectors
+RMAPI Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max)
+{
+    Vector3 result = { 0 };
+
+    result.x = fminf(max.x, fmaxf(min.x, v.x));
+    result.y = fminf(max.y, fmaxf(min.y, v.y));
+    result.z = fminf(max.z, fmaxf(min.z, v.z));
+
+    return result;
+}
+
+// Clamp the magnitude of the vector between two values
+RMAPI Vector3 Vector3ClampValue(Vector3 v, float min, float max)
+{
+    Vector3 result = { 0 };
+
+    float length = (v.x*v.x) + (v.y*v.y) + (v.z*v.z);
+    if (length > 0.0f)
+    {
+        length = sqrtf(length);
+
+        if (length < min)
+        {
+            float scale = min/length;
+            result.x = v.x*scale;
+            result.y = v.y*scale;
+            result.z = v.z*scale;
+        }
+        else if (length > max)
+        {
+            float scale = max/length;
+            result.x = v.x*scale;
+            result.y = v.y*scale;
+            result.z = v.z*scale;
+        }
+    }
+
+    return result;
+}
+
+// Check whether two given vectors are almost equal
+RMAPI int Vector3Equals(Vector3 p, Vector3 q)
+{
+    int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) &&
+                  ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) &&
+                  ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z)))));
+
+    return result;
+}
+
+// Compute the direction of a refracted ray where v specifies the
+// normalized direction of the incoming ray, n specifies the
+// normalized normal vector of the interface of two optical media,
+// and r specifies the ratio of the refractive index of the medium
+// from where the ray comes to the refractive index of the medium
+// on the other side of the surface
+RMAPI Vector3 Vector3Refract(Vector3 v, Vector3 n, float r)
+{
+    Vector3 result = { 0 };
+
+    float dot = v.x*n.x + v.y*n.y + v.z*n.z;
+    float d = 1.0f - r*r*(1.0f - dot*dot);
+
+    if (d >= 0.0f)
+    {
+        d = sqrtf(d);
+        v.x = r*v.x - (r*dot + d)*n.x;
+        v.y = r*v.y - (r*dot + d)*n.y;
+        v.z = r*v.z - (r*dot + d)*n.z;
+
+        result = v;
+    }
+
+    return result;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Matrix math
+//----------------------------------------------------------------------------------
+
+// Compute matrix determinant
+RMAPI float MatrixDeterminant(Matrix mat)
+{
+    float result = 0.0f;
+
+    // Cache the matrix values (speed optimization)
+    float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
+    float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7;
+    float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11;
+    float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15;
+
+    result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 +
+             a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 +
+             a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 +
+             a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 +
+             a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 +
+             a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33;
+
+    return result;
+}
+
+// Get the trace of the matrix (sum of the values along the diagonal)
+RMAPI float MatrixTrace(Matrix mat)
+{
+    float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15);
+
+    return result;
+}
+
+// Transposes provided matrix
+RMAPI Matrix MatrixTranspose(Matrix mat)
+{
+    Matrix result = { 0 };
+
+    result.m0 = mat.m0;
+    result.m1 = mat.m4;
+    result.m2 = mat.m8;
+    result.m3 = mat.m12;
+    result.m4 = mat.m1;
+    result.m5 = mat.m5;
+    result.m6 = mat.m9;
+    result.m7 = mat.m13;
+    result.m8 = mat.m2;
+    result.m9 = mat.m6;
+    result.m10 = mat.m10;
+    result.m11 = mat.m14;
+    result.m12 = mat.m3;
+    result.m13 = mat.m7;
+    result.m14 = mat.m11;
+    result.m15 = mat.m15;
+
+    return result;
+}
+
+// Invert provided matrix
+RMAPI Matrix MatrixInvert(Matrix mat)
+{
+    Matrix result = { 0 };
+
+    // Cache the matrix values (speed optimization)
+    float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
+    float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7;
+    float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11;
+    float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15;
+
+    float b00 = a00*a11 - a01*a10;
+    float b01 = a00*a12 - a02*a10;
+    float b02 = a00*a13 - a03*a10;
+    float b03 = a01*a12 - a02*a11;
+    float b04 = a01*a13 - a03*a11;
+    float b05 = a02*a13 - a03*a12;
+    float b06 = a20*a31 - a21*a30;
+    float b07 = a20*a32 - a22*a30;
+    float b08 = a20*a33 - a23*a30;
+    float b09 = a21*a32 - a22*a31;
+    float b10 = a21*a33 - a23*a31;
+    float b11 = a22*a33 - a23*a32;
+
+    // Calculate the invert determinant (inlined to avoid double-caching)
+    float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06);
+
+    result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet;
+    result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet;
+    result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet;
+    result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet;
+    result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet;
+    result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet;
+    result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet;
+    result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet;
+    result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet;
+    result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet;
+    result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet;
+    result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet;
+    result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet;
+    result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet;
+    result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet;
+    result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet;
+
+    return result;
+}
+
+// Get identity matrix
+RMAPI Matrix MatrixIdentity(void)
+{
+    Matrix result = { 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 };
+
+    return result;
+}
+
+// Add two matrices
+RMAPI Matrix MatrixAdd(Matrix left, Matrix right)
+{
+    Matrix result = { 0 };
+
+    result.m0 = left.m0 + right.m0;
+    result.m1 = left.m1 + right.m1;
+    result.m2 = left.m2 + right.m2;
+    result.m3 = left.m3 + right.m3;
+    result.m4 = left.m4 + right.m4;
+    result.m5 = left.m5 + right.m5;
+    result.m6 = left.m6 + right.m6;
+    result.m7 = left.m7 + right.m7;
+    result.m8 = left.m8 + right.m8;
+    result.m9 = left.m9 + right.m9;
+    result.m10 = left.m10 + right.m10;
+    result.m11 = left.m11 + right.m11;
+    result.m12 = left.m12 + right.m12;
+    result.m13 = left.m13 + right.m13;
+    result.m14 = left.m14 + right.m14;
+    result.m15 = left.m15 + right.m15;
+
+    return result;
+}
+
+// Subtract two matrices (left - right)
+RMAPI Matrix MatrixSubtract(Matrix left, Matrix right)
+{
+    Matrix result = { 0 };
+
+    result.m0 = left.m0 - right.m0;
+    result.m1 = left.m1 - right.m1;
+    result.m2 = left.m2 - right.m2;
+    result.m3 = left.m3 - right.m3;
+    result.m4 = left.m4 - right.m4;
+    result.m5 = left.m5 - right.m5;
+    result.m6 = left.m6 - right.m6;
+    result.m7 = left.m7 - right.m7;
+    result.m8 = left.m8 - right.m8;
+    result.m9 = left.m9 - right.m9;
+    result.m10 = left.m10 - right.m10;
+    result.m11 = left.m11 - right.m11;
+    result.m12 = left.m12 - right.m12;
+    result.m13 = left.m13 - right.m13;
+    result.m14 = left.m14 - right.m14;
+    result.m15 = left.m15 - right.m15;
+
+    return result;
+}
+
+// Get two matrix multiplication
+// NOTE: When multiplying matrices... the order matters!
+RMAPI Matrix MatrixMultiply(Matrix left, Matrix right)
+{
+    Matrix result = { 0 };
+
+    result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
+    result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
+    result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14;
+    result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15;
+    result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12;
+    result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13;
+    result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14;
+    result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15;
+    result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12;
+    result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13;
+    result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14;
+    result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15;
+    result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12;
+    result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13;
+    result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14;
+    result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15;
+
+    return result;
+}
+
+// Get translation matrix
+RMAPI Matrix MatrixTranslate(float x, float y, float z)
+{
+    Matrix result = { 1.0f, 0.0f, 0.0f, x,
+                      0.0f, 1.0f, 0.0f, y,
+                      0.0f, 0.0f, 1.0f, z,
+                      0.0f, 0.0f, 0.0f, 1.0f };
+
+    return result;
+}
+
+// Create rotation matrix from axis and angle
+// NOTE: Angle should be provided in radians
+RMAPI Matrix MatrixRotate(Vector3 axis, float angle)
+{
+    Matrix result = { 0 };
+
+    float x = axis.x, y = axis.y, z = axis.z;
+
+    float lengthSquared = x*x + y*y + z*z;
+
+    if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f))
+    {
+        float ilength = 1.0f/sqrtf(lengthSquared);
+        x *= ilength;
+        y *= ilength;
+        z *= ilength;
+    }
+
+    float sinres = sinf(angle);
+    float cosres = cosf(angle);
+    float t = 1.0f - cosres;
+
+    result.m0 = x*x*t + cosres;
+    result.m1 = y*x*t + z*sinres;
+    result.m2 = z*x*t - y*sinres;
+    result.m3 = 0.0f;
+
+    result.m4 = x*y*t - z*sinres;
+    result.m5 = y*y*t + cosres;
+    result.m6 = z*y*t + x*sinres;
+    result.m7 = 0.0f;
+
+    result.m8 = x*z*t + y*sinres;
+    result.m9 = y*z*t - x*sinres;
+    result.m10 = z*z*t + cosres;
+    result.m11 = 0.0f;
+
+    result.m12 = 0.0f;
+    result.m13 = 0.0f;
+    result.m14 = 0.0f;
+    result.m15 = 1.0f;
+
+    return result;
+}
+
+// Get x-rotation matrix (angle in radians)
+RMAPI Matrix MatrixRotateX(float angle)
+{
+    Matrix result = { 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 }; // MatrixIdentity()
+
+    float cosres = cosf(angle);
+    float sinres = sinf(angle);
+
+    result.m5 = cosres;
+    result.m6 = -sinres;
+    result.m9 = sinres;
+    result.m10 = cosres;
+
+    return result;
+}
+
+// Get y-rotation matrix (angle in radians)
+RMAPI Matrix MatrixRotateY(float angle)
+{
+    Matrix result = { 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 }; // MatrixIdentity()
+
+    float cosres = cosf(angle);
+    float sinres = sinf(angle);
+
+    result.m0 = cosres;
+    result.m2 = sinres;
+    result.m8 = -sinres;
+    result.m10 = cosres;
+
+    return result;
+}
+
+// Get z-rotation matrix (angle in radians)
+RMAPI Matrix MatrixRotateZ(float angle)
+{
+    Matrix result = { 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 }; // MatrixIdentity()
+
+    float cosres = cosf(angle);
+    float sinres = sinf(angle);
+
+    result.m0 = cosres;
+    result.m1 = -sinres;
+    result.m4 = sinres;
+    result.m5 = cosres;
+
+    return result;
+}
+
+
+// Get xyz-rotation matrix (angles in radians)
+RMAPI Matrix MatrixRotateXYZ(Vector3 ang)
+{
+    Matrix result = { 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 }; // MatrixIdentity()
+
+    float cosz = cosf(-ang.z);
+    float sinz = sinf(-ang.z);
+    float cosy = cosf(-ang.y);
+    float siny = sinf(-ang.y);
+    float cosx = cosf(-ang.x);
+    float sinx = sinf(-ang.x);
+
+    result.m0 = cosz*cosy;
+    result.m4 = (cosz*siny*sinx) - (sinz*cosx);
+    result.m8 = (cosz*siny*cosx) + (sinz*sinx);
+
+    result.m1 = sinz*cosy;
+    result.m5 = (sinz*siny*sinx) + (cosz*cosx);
+    result.m9 = (sinz*siny*cosx) - (cosz*sinx);
+
+    result.m2 = -siny;
+    result.m6 = cosy*sinx;
+    result.m10= cosy*cosx;
+
+    return result;
+}
+
+// Get zyx-rotation matrix (angles in radians)
+RMAPI Matrix MatrixRotateZYX(Vector3 ang)
+{
+    Matrix result = { 0 };
+
+    float cz = cosf(ang.z);
+    float sz = sinf(ang.z);
+    float cy = cosf(ang.y);
+    float sy = sinf(ang.y);
+    float cx = cosf(ang.x);
+    float sx = sinf(ang.x);
+
+    result.m0 = cz*cy;
+    result.m1 = cz*sy*sx - cx*sz;
+    result.m2 = sz*sx + cz*cx*sy;
+    result.m3 = 0;
+
+    result.m4 = cy*sz;
+    result.m5 = cz*cx + sz*sy*sx;
+    result.m6 = cx*sz*sy - cz*sx;
+    result.m7 = 0;
+
+    result.m8 = -sy;
+    result.m9 = cy*sx;
+    result.m10 = cy*cx;
+    result.m11 = 0;
+
+    result.m12 = 0;
+    result.m13 = 0;
+    result.m14 = 0;
+    result.m15 = 1;
+
+    return result;
+}
+
+// Get scaling matrix
+RMAPI Matrix MatrixScale(float x, float y, float z)
+{
+    Matrix result = { x, 0.0f, 0.0f, 0.0f,
+                      0.0f, y, 0.0f, 0.0f,
+                      0.0f, 0.0f, z, 0.0f,
+                      0.0f, 0.0f, 0.0f, 1.0f };
+
+    return result;
+}
+
+// Get perspective projection matrix
+RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far)
+{
+    Matrix result = { 0 };
+
+    float rl = (float)(right - left);
+    float tb = (float)(top - bottom);
+    float fn = (float)(far - near);
+
+    result.m0 = ((float)near*2.0f)/rl;
+    result.m1 = 0.0f;
+    result.m2 = 0.0f;
+    result.m3 = 0.0f;
+
+    result.m4 = 0.0f;
+    result.m5 = ((float)near*2.0f)/tb;
+    result.m6 = 0.0f;
+    result.m7 = 0.0f;
+
+    result.m8 = ((float)right + (float)left)/rl;
+    result.m9 = ((float)top + (float)bottom)/tb;
+    result.m10 = -((float)far + (float)near)/fn;
+    result.m11 = -1.0f;
+
+    result.m12 = 0.0f;
+    result.m13 = 0.0f;
+    result.m14 = -((float)far*(float)near*2.0f)/fn;
+    result.m15 = 0.0f;
+
+    return result;
+}
+
+// Get perspective projection matrix
+// NOTE: Angle should be provided in radians
+RMAPI Matrix MatrixPerspective(double fovy, double aspect, double near, double far)
+{
+    Matrix result = { 0 };
+
+    double top = near*tan(fovy*0.5);
+    double bottom = -top;
+    double right = top*aspect;
+    double left = -right;
+
+    // MatrixFrustum(-right, right, -top, top, near, far);
+    float rl = (float)(right - left);
+    float tb = (float)(top - bottom);
+    float fn = (float)(far - near);
+
+    result.m0 = ((float)near*2.0f)/rl;
+    result.m5 = ((float)near*2.0f)/tb;
+    result.m8 = ((float)right + (float)left)/rl;
+    result.m9 = ((float)top + (float)bottom)/tb;
+    result.m10 = -((float)far + (float)near)/fn;
+    result.m11 = -1.0f;
+    result.m14 = -((float)far*(float)near*2.0f)/fn;
+
+    return result;
+}
+
+// Get orthographic projection matrix
+RMAPI Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far)
+{
+    Matrix result = { 0 };
+
+    float rl = (float)(right - left);
+    float tb = (float)(top - bottom);
+    float fn = (float)(far - near);
+
+    result.m0 = 2.0f/rl;
+    result.m1 = 0.0f;
+    result.m2 = 0.0f;
+    result.m3 = 0.0f;
+    result.m4 = 0.0f;
+    result.m5 = 2.0f/tb;
+    result.m6 = 0.0f;
+    result.m7 = 0.0f;
+    result.m8 = 0.0f;
+    result.m9 = 0.0f;
+    result.m10 = -2.0f/fn;
+    result.m11 = 0.0f;
+    result.m12 = -((float)left + (float)right)/rl;
+    result.m13 = -((float)top + (float)bottom)/tb;
+    result.m14 = -((float)far + (float)near)/fn;
+    result.m15 = 1.0f;
+
+    return result;
+}
+
+// Get camera look-at matrix (view matrix)
+RMAPI Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
+{
+    Matrix result = { 0 };
+
+    float length = 0.0f;
+    float ilength = 0.0f;
+
+    // Vector3Subtract(eye, target)
+    Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z };
+
+    // Vector3Normalize(vz)
+    Vector3 v = vz;
+    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    if (length == 0.0f) length = 1.0f;
+    ilength = 1.0f/length;
+    vz.x *= ilength;
+    vz.y *= ilength;
+    vz.z *= ilength;
+
+    // Vector3CrossProduct(up, vz)
+    Vector3 vx = { up.y*vz.z - up.z*vz.y, up.z*vz.x - up.x*vz.z, up.x*vz.y - up.y*vz.x };
+
+    // Vector3Normalize(x)
+    v = vx;
+    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+    if (length == 0.0f) length = 1.0f;
+    ilength = 1.0f/length;
+    vx.x *= ilength;
+    vx.y *= ilength;
+    vx.z *= ilength;
+
+    // Vector3CrossProduct(vz, vx)
+    Vector3 vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x };
+
+    result.m0 = vx.x;
+    result.m1 = vy.x;
+    result.m2 = vz.x;
+    result.m3 = 0.0f;
+    result.m4 = vx.y;
+    result.m5 = vy.y;
+    result.m6 = vz.y;
+    result.m7 = 0.0f;
+    result.m8 = vx.z;
+    result.m9 = vy.z;
+    result.m10 = vz.z;
+    result.m11 = 0.0f;
+    result.m12 = -(vx.x*eye.x + vx.y*eye.y + vx.z*eye.z);   // Vector3DotProduct(vx, eye)
+    result.m13 = -(vy.x*eye.x + vy.y*eye.y + vy.z*eye.z);   // Vector3DotProduct(vy, eye)
+    result.m14 = -(vz.x*eye.x + vz.y*eye.y + vz.z*eye.z);   // Vector3DotProduct(vz, eye)
+    result.m15 = 1.0f;
+
+    return result;
+}
+
+// Get float array of matrix data
+RMAPI float16 MatrixToFloatV(Matrix mat)
+{
+    float16 result = { 0 };
+
+    result.v[0] = mat.m0;
+    result.v[1] = mat.m1;
+    result.v[2] = mat.m2;
+    result.v[3] = mat.m3;
+    result.v[4] = mat.m4;
+    result.v[5] = mat.m5;
+    result.v[6] = mat.m6;
+    result.v[7] = mat.m7;
+    result.v[8] = mat.m8;
+    result.v[9] = mat.m9;
+    result.v[10] = mat.m10;
+    result.v[11] = mat.m11;
+    result.v[12] = mat.m12;
+    result.v[13] = mat.m13;
+    result.v[14] = mat.m14;
+    result.v[15] = mat.m15;
+
+    return result;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Quaternion math
+//----------------------------------------------------------------------------------
+
+// Add two quaternions
+RMAPI Quaternion QuaternionAdd(Quaternion q1, Quaternion q2)
+{
+    Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w};
+
+    return result;
+}
+
+// Add quaternion and float value
+RMAPI Quaternion QuaternionAddValue(Quaternion q, float add)
+{
+    Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add};
+
+    return result;
+}
+
+// Subtract two quaternions
+RMAPI Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2)
+{
+    Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w};
+
+    return result;
+}
+
+// Subtract quaternion and float value
+RMAPI Quaternion QuaternionSubtractValue(Quaternion q, float sub)
+{
+    Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub};
+
+    return result;
+}
+
+// Get identity quaternion
+RMAPI Quaternion QuaternionIdentity(void)
+{
+    Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f };
+
+    return result;
+}
+
+// Computes the length of a quaternion
+RMAPI float QuaternionLength(Quaternion q)
+{
+    float result = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+
+    return result;
+}
+
+// Normalize provided quaternion
+RMAPI Quaternion QuaternionNormalize(Quaternion q)
+{
+    Quaternion result = { 0 };
+
+    float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+    if (length == 0.0f) length = 1.0f;
+    float ilength = 1.0f/length;
+
+    result.x = q.x*ilength;
+    result.y = q.y*ilength;
+    result.z = q.z*ilength;
+    result.w = q.w*ilength;
+
+    return result;
+}
+
+// Invert provided quaternion
+RMAPI Quaternion QuaternionInvert(Quaternion q)
+{
+    Quaternion result = q;
+
+    float lengthSq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
+
+    if (lengthSq != 0.0f)
+    {
+        float invLength = 1.0f/lengthSq;
+
+        result.x *= -invLength;
+        result.y *= -invLength;
+        result.z *= -invLength;
+        result.w *= invLength;
+    }
+
+    return result;
+}
+
+// Calculate two quaternion multiplication
+RMAPI Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
+{
+    Quaternion result = { 0 };
+
+    float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w;
+    float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w;
+
+    result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby;
+    result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz;
+    result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx;
+    result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz;
+
+    return result;
+}
+
+// Scale quaternion by float value
+RMAPI Quaternion QuaternionScale(Quaternion q, float mul)
+{
+    Quaternion result = { 0 };
+
+    result.x = q.x*mul;
+    result.y = q.y*mul;
+    result.z = q.z*mul;
+    result.w = q.w*mul;
+
+    return result;
+}
+
+// Divide two quaternions
+RMAPI Quaternion QuaternionDivide(Quaternion q1, Quaternion q2)
+{
+    Quaternion result = { q1.x/q2.x, q1.y/q2.y, q1.z/q2.z, q1.w/q2.w };
+
+    return result;
+}
+
+// Calculate linear interpolation between two quaternions
+RMAPI Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)
+{
+    Quaternion result = { 0 };
+
+    result.x = q1.x + amount*(q2.x - q1.x);
+    result.y = q1.y + amount*(q2.y - q1.y);
+    result.z = q1.z + amount*(q2.z - q1.z);
+    result.w = q1.w + amount*(q2.w - q1.w);
+
+    return result;
+}
+
+// Calculate slerp-optimized interpolation between two quaternions
+RMAPI Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount)
+{
+    Quaternion result = { 0 };
+
+    // QuaternionLerp(q1, q2, amount)
+    result.x = q1.x + amount*(q2.x - q1.x);
+    result.y = q1.y + amount*(q2.y - q1.y);
+    result.z = q1.z + amount*(q2.z - q1.z);
+    result.w = q1.w + amount*(q2.w - q1.w);
+
+    // QuaternionNormalize(q);
+    Quaternion q = result;
+    float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+    if (length == 0.0f) length = 1.0f;
+    float ilength = 1.0f/length;
+
+    result.x = q.x*ilength;
+    result.y = q.y*ilength;
+    result.z = q.z*ilength;
+    result.w = q.w*ilength;
+
+    return result;
+}
+
+// Calculates spherical linear interpolation between two quaternions
+RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)
+{
+    Quaternion result = { 0 };
+
+    float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w;
+
+    if (cosHalfTheta < 0)
+    {
+        q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w;
+        cosHalfTheta = -cosHalfTheta;
+    }
+
+    if (fabsf(cosHalfTheta) >= 1.0f) result = q1;
+    else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount);
+    else
+    {
+        float halfTheta = acosf(cosHalfTheta);
+        float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta);
+
+        if (fabsf(sinHalfTheta) < 0.001f)
+        {
+            result.x = (q1.x*0.5f + q2.x*0.5f);
+            result.y = (q1.y*0.5f + q2.y*0.5f);
+            result.z = (q1.z*0.5f + q2.z*0.5f);
+            result.w = (q1.w*0.5f + q2.w*0.5f);
+        }
+        else
+        {
+            float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta;
+            float ratioB = sinf(amount*halfTheta)/sinHalfTheta;
+
+            result.x = (q1.x*ratioA + q2.x*ratioB);
+            result.y = (q1.y*ratioA + q2.y*ratioB);
+            result.z = (q1.z*ratioA + q2.z*ratioB);
+            result.w = (q1.w*ratioA + q2.w*ratioB);
+        }
+    }
+
+    return result;
+}
+
+// Calculate quaternion based on the rotation from one vector to another
+RMAPI Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
+{
+    Quaternion result = { 0 };
+
+    float cos2Theta = (from.x*to.x + from.y*to.y + from.z*to.z);    // Vector3DotProduct(from, to)
+    Vector3 cross = { from.y*to.z - from.z*to.y, from.z*to.x - from.x*to.z, from.x*to.y - from.y*to.x }; // Vector3CrossProduct(from, to)
+
+    result.x = cross.x;
+    result.y = cross.y;
+    result.z = cross.z;
+    result.w = 1.0f + cos2Theta;
+
+    // QuaternionNormalize(q);
+    // NOTE: Normalize to essentially nlerp the original and identity to 0.5
+    Quaternion q = result;
+    float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+    if (length == 0.0f) length = 1.0f;
+    float ilength = 1.0f/length;
+
+    result.x = q.x*ilength;
+    result.y = q.y*ilength;
+    result.z = q.z*ilength;
+    result.w = q.w*ilength;
+
+    return result;
+}
+
+// Get a quaternion for a given rotation matrix
+RMAPI Quaternion QuaternionFromMatrix(Matrix mat)
+{
+    Quaternion result = { 0 };
+
+    if ((mat.m0 > mat.m5) && (mat.m0 > mat.m10))
+    {
+        float s = sqrtf(1.0f + mat.m0 - mat.m5 - mat.m10)*2;
+
+        result.x = 0.25f*s;
+        result.y = (mat.m4 + mat.m1)/s;
+        result.z = (mat.m2 + mat.m8)/s;
+        result.w = (mat.m9 - mat.m6)/s;
+    }
+    else if (mat.m5 > mat.m10)
+    {
+        float s = sqrtf(1.0f + mat.m5 - mat.m0 - mat.m10)*2;
+        result.x = (mat.m4 + mat.m1)/s;
+        result.y = 0.25f*s;
+        result.z = (mat.m9 + mat.m6)/s;
+        result.w = (mat.m2 - mat.m8)/s;
+    }
+    else
+    {
+        float s = sqrtf(1.0f + mat.m10 - mat.m0 - mat.m5)*2;
+        result.x = (mat.m2 + mat.m8)/s;
+        result.y = (mat.m9 + mat.m6)/s;
+        result.z = 0.25f*s;
+        result.w = (mat.m4 - mat.m1)/s;
+    }
+
+    return result;
+}
+
+// Get a matrix for a given quaternion
+RMAPI Matrix QuaternionToMatrix(Quaternion q)
+{
+    Matrix result = { 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 }; // MatrixIdentity()
+
+    float a2 = q.x*q.x;
+    float b2 = q.y*q.y;
+    float c2 = q.z*q.z;
+    float ac = q.x*q.z;
+    float ab = q.x*q.y;
+    float bc = q.y*q.z;
+    float ad = q.w*q.x;
+    float bd = q.w*q.y;
+    float cd = q.w*q.z;
+
+    result.m0 = 1 - 2*(b2 + c2);
+    result.m1 = 2*(ab + cd);
+    result.m2 = 2*(ac - bd);
+
+    result.m4 = 2*(ab - cd);
+    result.m5 = 1 - 2*(a2 + c2);
+    result.m6 = 2*(bc + ad);
+
+    result.m8 = 2*(ac + bd);
+    result.m9 = 2*(bc - ad);
+    result.m10 = 1 - 2*(a2 + b2);
+
+    return result;
+}
+
+// Get rotation quaternion for an angle and axis
+// NOTE: angle must be provided in radians
+RMAPI Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)
+{
+    Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f };
+
+    float axisLength = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z);
+
+    if (axisLength != 0.0f)
+    {
+        angle *= 0.5f;
+
+        float length = 0.0f;
+        float ilength = 0.0f;
+
+        // Vector3Normalize(axis)
+        Vector3 v = axis;
+        length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
+        if (length == 0.0f) length = 1.0f;
+        ilength = 1.0f/length;
+        axis.x *= ilength;
+        axis.y *= ilength;
+        axis.z *= ilength;
+
+        float sinres = sinf(angle);
+        float cosres = cosf(angle);
+
+        result.x = axis.x*sinres;
+        result.y = axis.y*sinres;
+        result.z = axis.z*sinres;
+        result.w = cosres;
+
+        // QuaternionNormalize(q);
+        Quaternion q = result;
+        length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+        if (length == 0.0f) length = 1.0f;
+        ilength = 1.0f/length;
+        result.x = q.x*ilength;
+        result.y = q.y*ilength;
+        result.z = q.z*ilength;
+        result.w = q.w*ilength;
+    }
+
+    return result;
+}
+
+// Get the rotation angle and axis for a given quaternion
+RMAPI void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle)
+{
+    if (fabsf(q.w) > 1.0f)
+    {
+        // QuaternionNormalize(q);
+        float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
+        if (length == 0.0f) length = 1.0f;
+        float ilength = 1.0f/length;
+
+        q.x = q.x*ilength;
+        q.y = q.y*ilength;
+        q.z = q.z*ilength;
+        q.w = q.w*ilength;
+    }
+
+    Vector3 resAxis = { 0.0f, 0.0f, 0.0f };
+    float resAngle = 2.0f*acosf(q.w);
+    float den = sqrtf(1.0f - q.w*q.w);
+
+    if (den > 0.0001f)
+    {
+        resAxis.x = q.x/den;
+        resAxis.y = q.y/den;
+        resAxis.z = q.z/den;
+    }
+    else
+    {
+        // This occurs when the angle is zero.
+        // Not a problem: just set an arbitrary normalized axis.
+        resAxis.x = 1.0f;
+    }
+
+    *outAxis = resAxis;
+    *outAngle = resAngle;
+}
+
+// Get the quaternion equivalent to Euler angles
+// NOTE: Rotation order is ZYX
+RMAPI Quaternion QuaternionFromEuler(float pitch, float yaw, float roll)
+{
+    Quaternion result = { 0 };
+
+    float x0 = cosf(pitch*0.5f);
+    float x1 = sinf(pitch*0.5f);
+    float y0 = cosf(yaw*0.5f);
+    float y1 = sinf(yaw*0.5f);
+    float z0 = cosf(roll*0.5f);
+    float z1 = sinf(roll*0.5f);
+
+    result.x = x1*y0*z0 - x0*y1*z1;
+    result.y = x0*y1*z0 + x1*y0*z1;
+    result.z = x0*y0*z1 - x1*y1*z0;
+    result.w = x0*y0*z0 + x1*y1*z1;
+
+    return result;
+}
+
+// Get the Euler angles equivalent to quaternion (roll, pitch, yaw)
+// NOTE: Angles are returned in a Vector3 struct in radians
+RMAPI Vector3 QuaternionToEuler(Quaternion q)
+{
+    Vector3 result = { 0 };
+
+    // Roll (x-axis rotation)
+    float x0 = 2.0f*(q.w*q.x + q.y*q.z);
+    float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y);
+    result.x = atan2f(x0, x1);
+
+    // Pitch (y-axis rotation)
+    float y0 = 2.0f*(q.w*q.y - q.z*q.x);
+    y0 = y0 > 1.0f ? 1.0f : y0;
+    y0 = y0 < -1.0f ? -1.0f : y0;
+    result.y = asinf(y0);
+
+    // Yaw (z-axis rotation)
+    float z0 = 2.0f*(q.w*q.z + q.x*q.y);
+    float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z);
+    result.z = atan2f(z0, z1);
+
+    return result;
+}
+
+// Transform a quaternion given a transformation matrix
+RMAPI Quaternion QuaternionTransform(Quaternion q, Matrix mat)
+{
+    Quaternion result = { 0 };
+
+    result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w;
+    result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w;
+    result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w;
+    result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w;
+
+    return result;
+}
+
+// Check whether two given quaternions are almost equal
+RMAPI int QuaternionEquals(Quaternion p, Quaternion q)
+{
+    int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) &&
+                  ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) &&
+                  ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) &&
+                  ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))));
+
+    return result;
+}
+
+#endif  // RAYMATH_H
+ rlImGui/raylib/src/rcamera.h view
@@ -0,0 +1,567 @@+/*******************************************************************************************
+*
+*   rcamera - Basic camera system for multiple camera modes
+*
+*   NOTE: Memory footprint of this library is aproximately 52 bytes (global variables)
+*
+*   CONFIGURATION:
+*
+*   #define CAMERA_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   #define CAMERA_STANDALONE
+*       If defined, the library can be used as standalone as a camera system but some
+*       functions must be redefined to manage inputs accordingly.
+*
+*   CONTRIBUTORS:
+*       Ramon Santamaria:   Supervision, review, update and maintenance
+*       Marc Palau:         Initial implementation (2014)
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2015-2022 Ramon Santamaria (@raysan5)
+*
+*   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 RCAMERA_H
+#define RCAMERA_H
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+// NOTE: Below types are required for CAMERA_STANDALONE usage
+//----------------------------------------------------------------------------------
+#if defined(CAMERA_STANDALONE)
+    // Vector2 type
+    typedef struct Vector2 {
+        float x;
+        float y;
+    } Vector2;
+
+    // Vector3 type
+    typedef struct Vector3 {
+        float x;
+        float y;
+        float z;
+    } Vector3;
+
+    // Camera type, defines a camera position/orientation in 3d space
+    typedef struct Camera3D {
+        Vector3 position;       // Camera position
+        Vector3 target;         // Camera target it looks-at
+        Vector3 up;             // Camera up vector (rotation over its axis)
+        float fovy;             // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
+        int type;               // Camera type, defines projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+    } Camera3D;
+
+    typedef Camera3D Camera;    // Camera type fallback, defaults to Camera3D
+
+    // Camera system modes
+    typedef enum {
+        CAMERA_CUSTOM = 0,
+        CAMERA_FREE,
+        CAMERA_ORBITAL,
+        CAMERA_FIRST_PERSON,
+        CAMERA_THIRD_PERSON
+    } CameraMode;
+
+    // Camera projection modes
+    typedef enum {
+        CAMERA_PERSPECTIVE = 0,
+        CAMERA_ORTHOGRAPHIC
+    } CameraProjection;
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+#if defined(CAMERA_STANDALONE)
+void SetCameraMode(Camera camera, int mode);                // Set camera mode (multiple camera modes available)
+void UpdateCamera(Camera *camera);                          // Update camera position for selected mode
+
+void SetCameraPanControl(int keyPan);                       // Set camera pan key to combine with mouse movement (free camera)
+void SetCameraAltControl(int keyAlt);                       // Set camera alt key to combine with mouse movement (free camera)
+void SetCameraSmoothZoomControl(int szoomKey);              // Set camera smooth zoom key to combine with mouse (free camera)
+void SetCameraMoveControls(int keyFront, int keyBack,
+                           int keyRight, int keyLeft,
+                           int keyUp, int keyDown);         // Set camera move controls (1st person and 3rd person cameras)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CAMERA_H
+
+
+/***********************************************************************************
+*
+*   CAMERA IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(CAMERA_IMPLEMENTATION)
+
+#include <math.h>               // Required for: sinf(), cosf(), sqrtf()
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#ifndef PI
+    #define PI 3.14159265358979323846
+#endif
+#ifndef DEG2RAD
+    #define DEG2RAD (PI/180.0f)
+#endif
+#ifndef RAD2DEG
+    #define RAD2DEG (180.0f/PI)
+#endif
+
+// Camera mouse movement sensitivity
+#define CAMERA_MOUSE_MOVE_SENSITIVITY                   0.003f
+#define CAMERA_MOUSE_SCROLL_SENSITIVITY                 1.5f
+
+// FREE_CAMERA
+#define CAMERA_FREE_MOUSE_SENSITIVITY                   0.01f
+#define CAMERA_FREE_DISTANCE_MIN_CLAMP                  0.3f
+#define CAMERA_FREE_DISTANCE_MAX_CLAMP                  120.0f
+#define CAMERA_FREE_MIN_CLAMP                           85.0f
+#define CAMERA_FREE_MAX_CLAMP                          -85.0f
+#define CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY             0.05f
+#define CAMERA_FREE_PANNING_DIVIDER                     5.1f
+
+// ORBITAL_CAMERA
+#define CAMERA_ORBITAL_SPEED                            0.01f       // Radians per frame
+
+// FIRST_PERSON
+//#define CAMERA_FIRST_PERSON_MOUSE_SENSITIVITY           0.003f
+#define CAMERA_FIRST_PERSON_FOCUS_DISTANCE              25.0f
+#define CAMERA_FIRST_PERSON_MIN_CLAMP                   89.0f
+#define CAMERA_FIRST_PERSON_MAX_CLAMP                  -89.0f
+
+#define CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER  8.0f
+#define CAMERA_FIRST_PERSON_STEP_DIVIDER                30.0f
+#define CAMERA_FIRST_PERSON_WAVING_DIVIDER              200.0f
+
+// THIRD_PERSON
+//#define CAMERA_THIRD_PERSON_MOUSE_SENSITIVITY           0.003f
+#define CAMERA_THIRD_PERSON_DISTANCE_CLAMP              1.2f
+#define CAMERA_THIRD_PERSON_MIN_CLAMP                   5.0f
+#define CAMERA_THIRD_PERSON_MAX_CLAMP                  -85.0f
+#define CAMERA_THIRD_PERSON_OFFSET                      (Vector3){ 0.4f, 0.0f, 0.0f }
+
+// PLAYER (used by camera)
+#define PLAYER_MOVEMENT_SENSITIVITY                     20.0f
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+// Camera move modes (first person and third person cameras)
+typedef enum {
+    MOVE_FRONT = 0,
+    MOVE_BACK,
+    MOVE_RIGHT,
+    MOVE_LEFT,
+    MOVE_UP,
+    MOVE_DOWN
+} CameraMove;
+
+// Camera global state context data [56 bytes]
+typedef struct {
+    unsigned int mode;              // Current camera mode
+    float targetDistance;           // Camera distance from position to target
+    float playerEyesPosition;       // Player eyes position from ground (in meters)
+    Vector2 angle;                  // Camera angle in plane XZ
+    Vector2 previousMousePosition;  // Previous mouse position
+
+    // Camera movement control keys
+    int moveControl[6];             // Move controls (CAMERA_FIRST_PERSON)
+    int smoothZoomControl;          // Smooth zoom control key
+    int altControl;                 // Alternative control key
+    int panControl;                 // Pan view control key
+} CameraData;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+static CameraData CAMERA = {        // Global CAMERA state context
+    .mode = 0,
+    .targetDistance = 0,
+    .playerEyesPosition = 1.85f,
+    .angle = { 0 },
+    .previousMousePosition = { 0 },
+    .moveControl = { 'W', 'S', 'D', 'A', 'E', 'Q' },
+    .smoothZoomControl = 341,       // raylib: KEY_LEFT_CONTROL
+    .altControl = 342,              // raylib: KEY_LEFT_ALT
+    .panControl = 2                 // raylib: MOUSE_BUTTON_MIDDLE
+};
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+#if defined(CAMERA_STANDALONE)
+// NOTE: Camera controls depend on some raylib input functions
+static void EnableCursor() {}       // Unlock cursor
+static void DisableCursor() {}      // Lock cursor
+
+static int IsKeyDown(int key) { return 0; }
+
+static int IsMouseButtonDown(int button) { return 0;}
+static float GetMouseWheelMove() { return 0.0f; }
+static Vector2 GetMousePosition() { return (Vector2){ 0.0f, 0.0f }; }
+#endif
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+
+// Select camera mode (multiple camera modes available)
+void SetCameraMode(Camera camera, int mode)
+{
+    Vector3 v1 = camera.position;
+    Vector3 v2 = camera.target;
+
+    float dx = v2.x - v1.x;
+    float dy = v2.y - v1.y;
+    float dz = v2.z - v1.z;
+
+    CAMERA.targetDistance = sqrtf(dx*dx + dy*dy + dz*dz);   // Distance to target
+
+    // Camera angle calculation
+    CAMERA.angle.x = atan2f(dx, dz);                        // Camera angle in plane XZ (0 aligned with Z, move positive CCW)
+    CAMERA.angle.y = atan2f(dy, sqrtf(dx*dx + dz*dz));      // Camera angle in plane XY (0 aligned with X, move positive CW)
+
+    CAMERA.playerEyesPosition = camera.position.y;          // Init player eyes position to camera Y position
+
+    CAMERA.previousMousePosition = GetMousePosition();      // Init mouse position
+
+    // Lock cursor for first person and third person cameras
+    if ((mode == CAMERA_FIRST_PERSON) || (mode == CAMERA_THIRD_PERSON)) DisableCursor();
+    else EnableCursor();
+
+    CAMERA.mode = mode;
+}
+
+// Update camera depending on selected mode
+// NOTE: Camera controls depend on some raylib functions:
+//       System: EnableCursor(), DisableCursor()
+//       Mouse: IsMouseButtonDown(), GetMousePosition(), GetMouseWheelMove()
+//       Keys:  IsKeyDown()
+void UpdateCamera(Camera *camera)
+{
+    static int swingCounter = 0;    // Used for 1st person swinging movement
+
+    // TODO: Compute CAMERA.targetDistance and CAMERA.angle here (?)
+
+    // Mouse movement detection
+    Vector2 mousePositionDelta = { 0.0f, 0.0f };
+    Vector2 mousePosition = GetMousePosition();
+    float mouseWheelMove = GetMouseWheelMove();
+
+    // Keys input detection
+    // TODO: Input detection is raylib-dependant, it could be moved outside the module
+    bool keyPan = IsMouseButtonDown(CAMERA.panControl);
+    bool keyAlt = IsKeyDown(CAMERA.altControl);
+    bool szoomKey = IsKeyDown(CAMERA.smoothZoomControl);
+    bool direction[6] = { IsKeyDown(CAMERA.moveControl[MOVE_FRONT]),
+                          IsKeyDown(CAMERA.moveControl[MOVE_BACK]),
+                          IsKeyDown(CAMERA.moveControl[MOVE_RIGHT]),
+                          IsKeyDown(CAMERA.moveControl[MOVE_LEFT]),
+                          IsKeyDown(CAMERA.moveControl[MOVE_UP]),
+                          IsKeyDown(CAMERA.moveControl[MOVE_DOWN]) };
+
+    if (CAMERA.mode != CAMERA_CUSTOM)
+    {
+        mousePositionDelta.x = mousePosition.x - CAMERA.previousMousePosition.x;
+        mousePositionDelta.y = mousePosition.y - CAMERA.previousMousePosition.y;
+
+        CAMERA.previousMousePosition = mousePosition;
+    }
+
+    // Support for multiple automatic camera modes
+    // NOTE: In case of CAMERA_CUSTOM nothing happens here, user must update it manually
+    switch (CAMERA.mode)
+    {
+        case CAMERA_FREE:           // Camera free controls, using standard 3d-content-creation scheme
+        {
+            // Camera zoom
+            if ((CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
+            {
+                CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
+                if (CAMERA.targetDistance > CAMERA_FREE_DISTANCE_MAX_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MAX_CLAMP;
+            }
+
+            // Camera looking down
+            else if ((camera->position.y > camera->target.y) && (CAMERA.targetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
+            {
+                camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+            }
+            else if ((camera->position.y > camera->target.y) && (camera->target.y >= 0))
+            {
+                camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+
+                // if (camera->target.y < 0) camera->target.y = -0.001;
+            }
+            else if ((camera->position.y > camera->target.y) && (camera->target.y < 0) && (mouseWheelMove > 0))
+            {
+                CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
+                if (CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
+            }
+            // Camera looking up
+            else if ((camera->position.y < camera->target.y) && (CAMERA.targetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (mouseWheelMove < 0))
+            {
+                camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+            }
+            else if ((camera->position.y < camera->target.y) && (camera->target.y <= 0))
+            {
+                camera->target.x += mouseWheelMove*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.y += mouseWheelMove*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+                camera->target.z += mouseWheelMove*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
+
+                // if (camera->target.y > 0) camera->target.y = 0.001;
+            }
+            else if ((camera->position.y < camera->target.y) && (camera->target.y > 0) && (mouseWheelMove > 0))
+            {
+                CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
+                if (CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
+            }
+
+            // Input keys checks
+            if (keyPan)
+            {
+                if (keyAlt)     // Alternative key behaviour
+                {
+                    if (szoomKey)
+                    {
+                        // Camera smooth zoom
+                        CAMERA.targetDistance += (mousePositionDelta.y*CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY);
+                    }
+                    else
+                    {
+                        // Camera rotation
+                        CAMERA.angle.x += mousePositionDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY;
+                        CAMERA.angle.y += mousePositionDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY;
+
+                        // Angle clamp
+                        if (CAMERA.angle.y > CAMERA_FREE_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FREE_MIN_CLAMP*DEG2RAD;
+                        else if (CAMERA.angle.y < CAMERA_FREE_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FREE_MAX_CLAMP*DEG2RAD;
+                    }
+                }
+                else
+                {
+                    // Camera panning
+                    camera->target.x += ((mousePositionDelta.x*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.x) + (mousePositionDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(CAMERA.angle.x)*sinf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
+                    camera->target.y += ((mousePositionDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
+                    camera->target.z += ((mousePositionDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(CAMERA.angle.x) + (mousePositionDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.x)*sinf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
+                }
+            }
+
+            // Update camera position with changes
+            camera->position.x = -sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
+            camera->position.y = -sinf(CAMERA.angle.y)*CAMERA.targetDistance + camera->target.y;
+            camera->position.z = -cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
+
+        } break;
+        case CAMERA_ORBITAL:        // Camera just orbits around target, only zoom allowed
+        {
+            CAMERA.angle.x += CAMERA_ORBITAL_SPEED;      // Camera orbit angle
+            CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);   // Camera zoom
+
+            // Camera distance clamp
+            if (CAMERA.targetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) CAMERA.targetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
+
+            // Update camera position with changes
+            camera->position.x = sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
+            camera->position.y = ((CAMERA.angle.y <= 0.0f)? 1 : -1)*sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
+            camera->position.z = cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
+
+        } break;
+        case CAMERA_FIRST_PERSON:   // Camera moves as in a first-person game, controls are configurable
+        {
+            camera->position.x += (sinf(CAMERA.angle.x)*direction[MOVE_BACK] -
+                                   sinf(CAMERA.angle.x)*direction[MOVE_FRONT] -
+                                   cosf(CAMERA.angle.x)*direction[MOVE_LEFT] +
+                                   cosf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
+
+            camera->position.y += (sinf(CAMERA.angle.y)*direction[MOVE_FRONT] -
+                                   sinf(CAMERA.angle.y)*direction[MOVE_BACK] +
+                                   1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])/PLAYER_MOVEMENT_SENSITIVITY;
+
+            camera->position.z += (cosf(CAMERA.angle.x)*direction[MOVE_BACK] -
+                                   cosf(CAMERA.angle.x)*direction[MOVE_FRONT] +
+                                   sinf(CAMERA.angle.x)*direction[MOVE_LEFT] -
+                                   sinf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
+
+            // Camera orientation calculation
+            CAMERA.angle.x += (mousePositionDelta.x*-CAMERA_MOUSE_MOVE_SENSITIVITY);
+            CAMERA.angle.y += (mousePositionDelta.y*-CAMERA_MOUSE_MOVE_SENSITIVITY);
+
+            // Angle clamp
+            if (CAMERA.angle.y > CAMERA_FIRST_PERSON_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FIRST_PERSON_MIN_CLAMP*DEG2RAD;
+            else if (CAMERA.angle.y < CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD;
+
+            // Calculate translation matrix
+            Matrix matTranslation = { 1.0f, 0.0f, 0.0f, 0.0f,
+                                      0.0f, 1.0f, 0.0f, 0.0f,
+                                      0.0f, 0.0f, 1.0f, (CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER),
+                                      0.0f, 0.0f, 0.0f, 1.0f };
+
+            // Calculate rotation matrix
+            Matrix matRotation = { 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 cosz = cosf(0.0f);
+            float sinz = sinf(0.0f);
+            float cosy = cosf(-(PI*2 - CAMERA.angle.x));
+            float siny = sinf(-(PI*2 - CAMERA.angle.x));
+            float cosx = cosf(-(PI*2 - CAMERA.angle.y));
+            float sinx = sinf(-(PI*2 - CAMERA.angle.y));
+
+            matRotation.m0 = cosz*cosy;
+            matRotation.m4 = (cosz*siny*sinx) - (sinz*cosx);
+            matRotation.m8 = (cosz*siny*cosx) + (sinz*sinx);
+            matRotation.m1 = sinz*cosy;
+            matRotation.m5 = (sinz*siny*sinx) + (cosz*cosx);
+            matRotation.m9 = (sinz*siny*cosx) - (cosz*sinx);
+            matRotation.m2 = -siny;
+            matRotation.m6 = cosy*sinx;
+            matRotation.m10= cosy*cosx;
+
+            // Multiply translation and rotation matrices
+            Matrix matTransform = { 0 };
+            matTransform.m0 = matTranslation.m0*matRotation.m0 + matTranslation.m1*matRotation.m4 + matTranslation.m2*matRotation.m8 + matTranslation.m3*matRotation.m12;
+            matTransform.m1 = matTranslation.m0*matRotation.m1 + matTranslation.m1*matRotation.m5 + matTranslation.m2*matRotation.m9 + matTranslation.m3*matRotation.m13;
+            matTransform.m2 = matTranslation.m0*matRotation.m2 + matTranslation.m1*matRotation.m6 + matTranslation.m2*matRotation.m10 + matTranslation.m3*matRotation.m14;
+            matTransform.m3 = matTranslation.m0*matRotation.m3 + matTranslation.m1*matRotation.m7 + matTranslation.m2*matRotation.m11 + matTranslation.m3*matRotation.m15;
+            matTransform.m4 = matTranslation.m4*matRotation.m0 + matTranslation.m5*matRotation.m4 + matTranslation.m6*matRotation.m8 + matTranslation.m7*matRotation.m12;
+            matTransform.m5 = matTranslation.m4*matRotation.m1 + matTranslation.m5*matRotation.m5 + matTranslation.m6*matRotation.m9 + matTranslation.m7*matRotation.m13;
+            matTransform.m6 = matTranslation.m4*matRotation.m2 + matTranslation.m5*matRotation.m6 + matTranslation.m6*matRotation.m10 + matTranslation.m7*matRotation.m14;
+            matTransform.m7 = matTranslation.m4*matRotation.m3 + matTranslation.m5*matRotation.m7 + matTranslation.m6*matRotation.m11 + matTranslation.m7*matRotation.m15;
+            matTransform.m8 = matTranslation.m8*matRotation.m0 + matTranslation.m9*matRotation.m4 + matTranslation.m10*matRotation.m8 + matTranslation.m11*matRotation.m12;
+            matTransform.m9 = matTranslation.m8*matRotation.m1 + matTranslation.m9*matRotation.m5 + matTranslation.m10*matRotation.m9 + matTranslation.m11*matRotation.m13;
+            matTransform.m10 = matTranslation.m8*matRotation.m2 + matTranslation.m9*matRotation.m6 + matTranslation.m10*matRotation.m10 + matTranslation.m11*matRotation.m14;
+            matTransform.m11 = matTranslation.m8*matRotation.m3 + matTranslation.m9*matRotation.m7 + matTranslation.m10*matRotation.m11 + matTranslation.m11*matRotation.m15;
+            matTransform.m12 = matTranslation.m12*matRotation.m0 + matTranslation.m13*matRotation.m4 + matTranslation.m14*matRotation.m8 + matTranslation.m15*matRotation.m12;
+            matTransform.m13 = matTranslation.m12*matRotation.m1 + matTranslation.m13*matRotation.m5 + matTranslation.m14*matRotation.m9 + matTranslation.m15*matRotation.m13;
+            matTransform.m14 = matTranslation.m12*matRotation.m2 + matTranslation.m13*matRotation.m6 + matTranslation.m14*matRotation.m10 + matTranslation.m15*matRotation.m14;
+            matTransform.m15 = matTranslation.m12*matRotation.m3 + matTranslation.m13*matRotation.m7 + matTranslation.m14*matRotation.m11 + matTranslation.m15*matRotation.m15;
+
+            camera->target.x = camera->position.x - matTransform.m12;
+            camera->target.y = camera->position.y - matTransform.m13;
+            camera->target.z = camera->position.z - matTransform.m14;
+
+            // If movement detected (some key pressed), increase swinging
+            for (int i = 0; i < 6; i++) if (direction[i]) { swingCounter++; break; }
+
+            // Camera position update
+            // NOTE: On CAMERA_FIRST_PERSON player Y-movement is limited to player 'eyes position'
+            camera->position.y = CAMERA.playerEyesPosition - sinf(swingCounter/CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER)/CAMERA_FIRST_PERSON_STEP_DIVIDER;
+
+            camera->up.x = sinf(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
+            camera->up.z = -sinf(swingCounter/(CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER*2))/CAMERA_FIRST_PERSON_WAVING_DIVIDER;
+
+        } break;
+        case CAMERA_THIRD_PERSON:   // Camera moves as in a third-person game, following target at a distance, controls are configurable
+        {
+            camera->position.x += (sinf(CAMERA.angle.x)*direction[MOVE_BACK] -
+                                   sinf(CAMERA.angle.x)*direction[MOVE_FRONT] -
+                                   cosf(CAMERA.angle.x)*direction[MOVE_LEFT] +
+                                   cosf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
+
+            camera->position.y += (sinf(CAMERA.angle.y)*direction[MOVE_FRONT] -
+                                   sinf(CAMERA.angle.y)*direction[MOVE_BACK] +
+                                   1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])/PLAYER_MOVEMENT_SENSITIVITY;
+
+            camera->position.z += (cosf(CAMERA.angle.x)*direction[MOVE_BACK] -
+                                   cosf(CAMERA.angle.x)*direction[MOVE_FRONT] +
+                                   sinf(CAMERA.angle.x)*direction[MOVE_LEFT] -
+                                   sinf(CAMERA.angle.x)*direction[MOVE_RIGHT])/PLAYER_MOVEMENT_SENSITIVITY;
+
+            // Camera orientation calculation
+            CAMERA.angle.x += (mousePositionDelta.x*-CAMERA_MOUSE_MOVE_SENSITIVITY);
+            CAMERA.angle.y += (mousePositionDelta.y*-CAMERA_MOUSE_MOVE_SENSITIVITY);
+
+            // Angle clamp
+            if (CAMERA.angle.y > CAMERA_THIRD_PERSON_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_THIRD_PERSON_MIN_CLAMP*DEG2RAD;
+            else if (CAMERA.angle.y < CAMERA_THIRD_PERSON_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_THIRD_PERSON_MAX_CLAMP*DEG2RAD;
+
+            // Camera zoom
+            CAMERA.targetDistance -= (mouseWheelMove*CAMERA_MOUSE_SCROLL_SENSITIVITY);
+
+            // Camera distance clamp
+            if (CAMERA.targetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) CAMERA.targetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
+
+            camera->position.x = sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
+
+            if (CAMERA.angle.y <= 0.0f) camera->position.y = sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
+            else camera->position.y = -sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
+
+            camera->position.z = cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
+
+        } break;
+        case CAMERA_CUSTOM: break;
+        default: break;
+    }
+}
+
+// Set camera pan key to combine with mouse movement (free camera)
+void SetCameraPanControl(int keyPan) { CAMERA.panControl = keyPan; }
+
+// Set camera alt key to combine with mouse movement (free camera)
+void SetCameraAltControl(int keyAlt) { CAMERA.altControl = keyAlt; }
+
+// Set camera smooth zoom key to combine with mouse (free camera)
+void SetCameraSmoothZoomControl(int szoomKey) { CAMERA.smoothZoomControl = szoomKey; }
+
+// Set camera move controls (1st person and 3rd person cameras)
+void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown)
+{
+    CAMERA.moveControl[MOVE_FRONT] = keyFront;
+    CAMERA.moveControl[MOVE_BACK] = keyBack;
+    CAMERA.moveControl[MOVE_RIGHT] = keyRight;
+    CAMERA.moveControl[MOVE_LEFT] = keyLeft;
+    CAMERA.moveControl[MOVE_UP] = keyUp;
+    CAMERA.moveControl[MOVE_DOWN] = keyDown;
+}
+
+#endif // CAMERA_IMPLEMENTATION
+ rlImGui/raylib/src/rgestures.h view
@@ -0,0 +1,566 @@+/**********************************************************************************************
+*
+*   rgestures - Gestures system, gestures processing based on input events (touch/mouse)
+*
+*   NOTE: Memory footprint of this library is aproximately 128 bytes (global variables)
+*
+*   CONFIGURATION:
+*
+*   #define GESTURES_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   #define GESTURES_STANDALONE
+*       If defined, the library can be used as standalone to process gesture events with
+*       no external dependencies.
+*
+*   CONTRIBUTORS:
+*       Marc Palau:         Initial implementation (2014)
+*       Albert Martos:      Complete redesign and testing (2015)
+*       Ian Eito:           Complete redesign and testing (2015)
+*       Ramon Santamaria:   Supervision, review, update and maintenance
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2014-2022 Ramon Santamaria (@raysan5)
+*
+*   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 RGESTURES_H
+#define RGESTURES_H
+
+#ifndef PI
+    #define PI 3.14159265358979323846
+#endif
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#ifndef MAX_TOUCH_POINTS
+    #define MAX_TOUCH_POINTS        8        // Maximum number of touch points supported
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+// NOTE: Below types are required for GESTURES_STANDALONE usage
+//----------------------------------------------------------------------------------
+// Boolean type
+#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
+    #include <stdbool.h>
+#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
+    typedef enum bool { false = 0, true = !false } bool;
+#endif
+
+#if !defined(RL_VECTOR2_TYPE)
+// Vector2 type
+typedef struct Vector2 {
+    float x;
+    float y;
+} Vector2;
+#endif
+
+#if defined(GESTURES_STANDALONE)
+// Gestures type
+// NOTE: It could be used as flags to enable only some gestures
+typedef enum {
+    GESTURE_NONE        = 0,
+    GESTURE_TAP         = 1,
+    GESTURE_DOUBLETAP   = 2,
+    GESTURE_HOLD        = 4,
+    GESTURE_DRAG        = 8,
+    GESTURE_SWIPE_RIGHT = 16,
+    GESTURE_SWIPE_LEFT  = 32,
+    GESTURE_SWIPE_UP    = 64,
+    GESTURE_SWIPE_DOWN  = 128,
+    GESTURE_PINCH_IN    = 256,
+    GESTURE_PINCH_OUT   = 512
+} Gesture;
+#endif
+
+typedef enum {
+    TOUCH_ACTION_UP = 0,
+    TOUCH_ACTION_DOWN,
+    TOUCH_ACTION_MOVE,
+    TOUCH_ACTION_CANCEL
+} TouchAction;
+
+// Gesture event
+typedef struct {
+    int touchAction;
+    int pointCount;
+    int pointId[MAX_TOUCH_POINTS];
+    Vector2 position[MAX_TOUCH_POINTS];
+} GestureEvent;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+void ProcessGestureEvent(GestureEvent event);           // Process gesture event and translate it into gestures
+void UpdateGestures(void);                              // Update gestures detected (must be called every frame)
+
+#if defined(GESTURES_STANDALONE)
+void SetGesturesEnabled(unsigned int flags);            // Enable a set of gestures using flags
+bool IsGestureDetected(int gesture);                    // Check if a gesture have been detected
+int GetGestureDetected(void);                           // Get latest detected gesture
+
+float GetGestureHoldDuration(void);                     // Get gesture hold time in milliseconds
+Vector2 GetGestureDragVector(void);                     // Get gesture drag vector
+float GetGestureDragAngle(void);                        // Get gesture drag angle
+Vector2 GetGesturePinchVector(void);                    // Get gesture pinch delta
+float GetGesturePinchAngle(void);                       // Get gesture pinch angle
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GESTURES_H
+
+/***********************************************************************************
+*
+*   GESTURES IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(GESTURES_IMPLEMENTATION)
+
+#if defined(_WIN32)
+    #if defined(__cplusplus)
+    extern "C" {        // Prevents name mangling of functions
+    #endif
+    // Functions required to query time on Windows
+    int __stdcall QueryPerformanceCounter(unsigned long long int *lpPerformanceCount);
+    int __stdcall QueryPerformanceFrequency(unsigned long long int *lpFrequency);
+    #if defined(__cplusplus)
+    }
+    #endif
+#elif defined(__linux__)
+    #if _POSIX_C_SOURCE < 199309L
+        #undef _POSIX_C_SOURCE
+        #define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
+    #endif
+    #include <sys/time.h>               // Required for: timespec
+    #include <time.h>                   // Required for: clock_gettime()
+
+    #include <math.h>                   // Required for: sqrtf(), atan2f()
+#endif
+#if defined(__APPLE__)                  // macOS also defines __MACH__
+    #include <mach/clock.h>             // Required for: clock_get_time()
+    #include <mach/mach.h>              // Required for: mach_timespec_t
+#endif
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#define FORCE_TO_SWIPE      0.0005f     // Swipe force, measured in normalized screen units/time
+#define MINIMUM_DRAG        0.015f      // Drag minimum force, measured in normalized screen units (0.0f to 1.0f)
+#define MINIMUM_PINCH       0.005f      // Pinch minimum force, measured in normalized screen units (0.0f to 1.0f)
+#define TAP_TIMEOUT         300         // Tap minimum time, measured in milliseconds
+#define PINCH_TIMEOUT       300         // Pinch minimum time, measured in milliseconds
+#define DOUBLETAP_RANGE     0.03f       // DoubleTap range, measured in normalized screen units (0.0f to 1.0f)
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+// Gestures module state context [136 bytes]
+typedef struct {
+    unsigned int current;               // Current detected gesture
+    unsigned int enabledFlags;          // Enabled gestures flags
+    struct {
+        int firstId;                    // Touch id for first touch point
+        int pointCount;                 // Touch points counter
+        double eventTime;               // Time stamp when an event happened
+        Vector2 upPosition;             // Touch up position
+        Vector2 downPositionA;          // First touch down position
+        Vector2 downPositionB;          // Second touch down position
+        Vector2 downDragPosition;       // Touch drag position
+        Vector2 moveDownPositionA;      // First touch down position on move
+        Vector2 moveDownPositionB;      // Second touch down position on move
+        int tapCounter;                 // TAP counter (one tap implies TOUCH_ACTION_DOWN and TOUCH_ACTION_UP actions)
+    } Touch;
+    struct {
+        bool resetRequired;             // HOLD reset to get first touch point again
+        double timeDuration;            // HOLD duration in milliseconds
+    } Hold;
+    struct {
+        Vector2 vector;                 // DRAG vector (between initial and current position)
+        float angle;                    // DRAG angle (relative to x-axis)
+        float distance;                 // DRAG distance (from initial touch point to final) (normalized [0..1])
+        float intensity;                // DRAG intensity, how far why did the DRAG (pixels per frame)
+    } Drag;
+    struct {
+        bool start;                     // SWIPE used to define when start measuring GESTURES.Swipe.timeDuration
+        double timeDuration;            // SWIPE time to calculate drag intensity
+    } Swipe;
+    struct {
+        Vector2 vector;                 // PINCH vector (between first and second touch points)
+        float angle;                    // PINCH angle (relative to x-axis)
+        float distance;                 // PINCH displacement distance (normalized [0..1])
+    } Pinch;
+} GesturesData;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+static GesturesData GESTURES = {
+    .Touch.firstId = -1,
+    .current = GESTURE_NONE,        // No current gesture detected
+    .enabledFlags = 0b0000001111111111  // All gestures supported by default
+};
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+static float rgVector2Angle(Vector2 initialPosition, Vector2 finalPosition);
+static float rgVector2Distance(Vector2 v1, Vector2 v2);
+static double rgGetCurrentTime(void);
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+
+// Enable only desired getures to be detected
+void SetGesturesEnabled(unsigned int flags)
+{
+    GESTURES.enabledFlags = flags;
+}
+
+// Check if a gesture have been detected
+bool IsGestureDetected(int gesture)
+{
+    if ((GESTURES.enabledFlags & GESTURES.current) == gesture) return true;
+    else return false;
+}
+
+// Process gesture event and translate it into gestures
+void ProcessGestureEvent(GestureEvent event)
+{
+    // Reset required variables
+    GESTURES.Touch.pointCount = event.pointCount;      // Required on UpdateGestures()
+
+    if (GESTURES.Touch.pointCount == 1)     // One touch point
+    {
+        if (event.touchAction == TOUCH_ACTION_DOWN)
+        {
+            GESTURES.Touch.tapCounter++;    // Tap counter
+
+            // Detect GESTURE_DOUBLE_TAP
+            if ((GESTURES.current == GESTURE_NONE) && (GESTURES.Touch.tapCounter >= 2) && ((rgGetCurrentTime() - GESTURES.Touch.eventTime) < TAP_TIMEOUT) && (rgVector2Distance(GESTURES.Touch.downPositionA, event.position[0]) < DOUBLETAP_RANGE))
+            {
+                GESTURES.current = GESTURE_DOUBLETAP;
+                GESTURES.Touch.tapCounter = 0;
+            }
+            else    // Detect GESTURE_TAP
+            {
+                GESTURES.Touch.tapCounter = 1;
+                GESTURES.current = GESTURE_TAP;
+            }
+
+            GESTURES.Touch.downPositionA = event.position[0];
+            GESTURES.Touch.downDragPosition = event.position[0];
+
+            GESTURES.Touch.upPosition = GESTURES.Touch.downPositionA;
+            GESTURES.Touch.eventTime = rgGetCurrentTime();
+
+            GESTURES.Touch.firstId = event.pointId[0];
+
+            GESTURES.Drag.vector = (Vector2){ 0.0f, 0.0f };
+        }
+        else if (event.touchAction == TOUCH_ACTION_UP)
+        {
+            if (GESTURES.current == GESTURE_DRAG) GESTURES.Touch.upPosition = event.position[0];
+
+            // NOTE: GESTURES.Drag.intensity dependend on the resolution of the screen
+            GESTURES.Drag.distance = rgVector2Distance(GESTURES.Touch.downPositionA, GESTURES.Touch.upPosition);
+            GESTURES.Drag.intensity = GESTURES.Drag.distance/(float)((rgGetCurrentTime() - GESTURES.Swipe.timeDuration));
+
+            GESTURES.Swipe.start = false;
+
+            // Detect GESTURE_SWIPE
+            if ((GESTURES.Drag.intensity > FORCE_TO_SWIPE) && (GESTURES.Touch.firstId == event.pointId[0]))
+            {
+                // NOTE: Angle should be inverted in Y
+                GESTURES.Drag.angle = 360.0f - rgVector2Angle(GESTURES.Touch.downPositionA, GESTURES.Touch.upPosition);
+
+                if ((GESTURES.Drag.angle < 30) || (GESTURES.Drag.angle > 330)) GESTURES.current = GESTURE_SWIPE_RIGHT;        // Right
+                else if ((GESTURES.Drag.angle > 30) && (GESTURES.Drag.angle < 120)) GESTURES.current = GESTURE_SWIPE_UP;      // Up
+                else if ((GESTURES.Drag.angle > 120) && (GESTURES.Drag.angle < 210)) GESTURES.current = GESTURE_SWIPE_LEFT;   // Left
+                else if ((GESTURES.Drag.angle > 210) && (GESTURES.Drag.angle < 300)) GESTURES.current = GESTURE_SWIPE_DOWN;   // Down
+                else GESTURES.current = GESTURE_NONE;
+            }
+            else
+            {
+                GESTURES.Drag.distance = 0.0f;
+                GESTURES.Drag.intensity = 0.0f;
+                GESTURES.Drag.angle = 0.0f;
+
+                GESTURES.current = GESTURE_NONE;
+            }
+
+            GESTURES.Touch.downDragPosition = (Vector2){ 0.0f, 0.0f };
+            GESTURES.Touch.pointCount = 0;
+        }
+        else if (event.touchAction == TOUCH_ACTION_MOVE)
+        {
+            if (GESTURES.current == GESTURE_DRAG) GESTURES.Touch.eventTime = rgGetCurrentTime();
+
+            if (!GESTURES.Swipe.start)
+            {
+                GESTURES.Swipe.timeDuration = rgGetCurrentTime();
+                GESTURES.Swipe.start = true;
+            }
+
+            GESTURES.Touch.moveDownPositionA = event.position[0];
+
+            if (GESTURES.current == GESTURE_HOLD)
+            {
+                if (GESTURES.Hold.resetRequired) GESTURES.Touch.downPositionA = event.position[0];
+
+                GESTURES.Hold.resetRequired = false;
+
+                // Detect GESTURE_DRAG
+                if (rgVector2Distance(GESTURES.Touch.downPositionA, GESTURES.Touch.moveDownPositionA) >= MINIMUM_DRAG)
+                {
+                    GESTURES.Touch.eventTime = rgGetCurrentTime();
+                    GESTURES.current = GESTURE_DRAG;
+                }
+            }
+
+            GESTURES.Drag.vector.x = GESTURES.Touch.moveDownPositionA.x - GESTURES.Touch.downDragPosition.x;
+            GESTURES.Drag.vector.y = GESTURES.Touch.moveDownPositionA.y - GESTURES.Touch.downDragPosition.y;
+        }
+    }
+    else if (GESTURES.Touch.pointCount == 2)    // Two touch points
+    {
+        if (event.touchAction == TOUCH_ACTION_DOWN)
+        {
+            GESTURES.Touch.downPositionA = event.position[0];
+            GESTURES.Touch.downPositionB = event.position[1];
+
+            //GESTURES.Pinch.distance = rgVector2Distance(GESTURES.Touch.downPositionA, GESTURES.Touch.downPositionB);
+
+            GESTURES.Pinch.vector.x = GESTURES.Touch.downPositionB.x - GESTURES.Touch.downPositionA.x;
+            GESTURES.Pinch.vector.y = GESTURES.Touch.downPositionB.y - GESTURES.Touch.downPositionA.y;
+
+            GESTURES.current = GESTURE_HOLD;
+            GESTURES.Hold.timeDuration = rgGetCurrentTime();
+        }
+        else if (event.touchAction == TOUCH_ACTION_MOVE)
+        {
+            GESTURES.Pinch.distance = rgVector2Distance(GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB);
+
+            GESTURES.Touch.downPositionA = GESTURES.Touch.moveDownPositionA;
+            GESTURES.Touch.downPositionB = GESTURES.Touch.moveDownPositionB;
+
+            GESTURES.Touch.moveDownPositionA = event.position[0];
+            GESTURES.Touch.moveDownPositionB = event.position[1];
+
+            GESTURES.Pinch.vector.x = GESTURES.Touch.moveDownPositionB.x - GESTURES.Touch.moveDownPositionA.x;
+            GESTURES.Pinch.vector.y = GESTURES.Touch.moveDownPositionB.y - GESTURES.Touch.moveDownPositionA.y;
+
+            if ((rgVector2Distance(GESTURES.Touch.downPositionA, GESTURES.Touch.moveDownPositionA) >= MINIMUM_PINCH) || (rgVector2Distance(GESTURES.Touch.downPositionB, GESTURES.Touch.moveDownPositionB) >= MINIMUM_PINCH))
+            {
+                if ((rgVector2Distance(GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB) - GESTURES.Pinch.distance) < 0) GESTURES.current = GESTURE_PINCH_IN;
+                else GESTURES.current = GESTURE_PINCH_OUT;
+            }
+            else
+            {
+                GESTURES.current = GESTURE_HOLD;
+                GESTURES.Hold.timeDuration = rgGetCurrentTime();
+            }
+
+            // NOTE: Angle should be inverted in Y
+            GESTURES.Pinch.angle = 360.0f - rgVector2Angle(GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB);
+        }
+        else if (event.touchAction == TOUCH_ACTION_UP)
+        {
+            GESTURES.Pinch.distance = 0.0f;
+            GESTURES.Pinch.angle = 0.0f;
+            GESTURES.Pinch.vector = (Vector2){ 0.0f, 0.0f };
+            GESTURES.Touch.pointCount = 0;
+
+            GESTURES.current = GESTURE_NONE;
+        }
+    }
+    else if (GESTURES.Touch.pointCount > 2)     // More than two touch points
+    {
+        // TODO: Process gesture events for more than two points
+    }
+}
+
+// Update gestures detected (must be called every frame)
+void UpdateGestures(void)
+{
+    // NOTE: Gestures are processed through system callbacks on touch events
+
+    // Detect GESTURE_HOLD
+    if (((GESTURES.current == GESTURE_TAP) || (GESTURES.current == GESTURE_DOUBLETAP)) && (GESTURES.Touch.pointCount < 2))
+    {
+        GESTURES.current = GESTURE_HOLD;
+        GESTURES.Hold.timeDuration = rgGetCurrentTime();
+    }
+
+    if (((rgGetCurrentTime() - GESTURES.Touch.eventTime) > TAP_TIMEOUT) && (GESTURES.current == GESTURE_DRAG) && (GESTURES.Touch.pointCount < 2))
+    {
+        GESTURES.current = GESTURE_HOLD;
+        GESTURES.Hold.timeDuration = rgGetCurrentTime();
+        GESTURES.Hold.resetRequired = true;
+    }
+
+    // Detect GESTURE_NONE
+    if ((GESTURES.current == GESTURE_SWIPE_RIGHT) || (GESTURES.current == GESTURE_SWIPE_UP) || (GESTURES.current == GESTURE_SWIPE_LEFT) || (GESTURES.current == GESTURE_SWIPE_DOWN))
+    {
+        GESTURES.current = GESTURE_NONE;
+    }
+}
+
+// Get latest detected gesture
+int GetGestureDetected(void)
+{
+    // Get current gesture only if enabled
+    return (GESTURES.enabledFlags & GESTURES.current);
+}
+
+// Hold time measured in ms
+float GetGestureHoldDuration(void)
+{
+    // NOTE: time is calculated on current gesture HOLD
+
+    double time = 0.0;
+
+    if (GESTURES.current == GESTURE_HOLD) time = rgGetCurrentTime() - GESTURES.Hold.timeDuration;
+
+    return (float)time;
+}
+
+// Get drag vector (between initial touch point to current)
+Vector2 GetGestureDragVector(void)
+{
+    // NOTE: drag vector is calculated on one touch points TOUCH_ACTION_MOVE
+
+    return GESTURES.Drag.vector;
+}
+
+// Get drag angle
+// NOTE: Angle in degrees, horizontal-right is 0, counterclock-wise
+float GetGestureDragAngle(void)
+{
+    // NOTE: drag angle is calculated on one touch points TOUCH_ACTION_UP
+
+    return GESTURES.Drag.angle;
+}
+
+// Get distance between two pinch points
+Vector2 GetGesturePinchVector(void)
+{
+    // NOTE: Pinch distance is calculated on two touch points TOUCH_ACTION_MOVE
+
+    return GESTURES.Pinch.vector;
+}
+
+// Get angle beween two pinch points
+// NOTE: Angle in degrees, horizontal-right is 0, counterclock-wise
+float GetGesturePinchAngle(void)
+{
+    // NOTE: pinch angle is calculated on two touch points TOUCH_ACTION_MOVE
+
+    return GESTURES.Pinch.angle;
+}
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Definition
+//----------------------------------------------------------------------------------
+// Get angle from two-points vector with X-axis
+static float rgVector2Angle(Vector2 v1, Vector2 v2)
+{
+    float angle = atan2f(v2.y - v1.y, v2.x - v1.x)*(180.0f/PI);
+
+    if (angle < 0) angle += 360.0f;
+
+    return angle;
+}
+
+// Calculate distance between two Vector2
+static float rgVector2Distance(Vector2 v1, Vector2 v2)
+{
+    float result;
+
+    float dx = v2.x - v1.x;
+    float dy = v2.y - v1.y;
+
+    result = (float)sqrt(dx*dx + dy*dy);
+
+    return result;
+}
+
+// Time measure returned are milliseconds
+static double rgGetCurrentTime(void)
+{
+    double time = 0;
+
+#if defined(_WIN32)
+    unsigned long long int clockFrequency, currentTime;
+
+    QueryPerformanceFrequency(&clockFrequency);     // BE CAREFUL: Costly operation!
+    QueryPerformanceCounter(&currentTime);
+
+    time = (double)currentTime/clockFrequency*1000.0f;  // Time in miliseconds
+#endif
+
+#if defined(__linux__)
+    // NOTE: Only for Linux-based systems
+    struct timespec now;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    unsigned long long int nowTime = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec;     // Time in nanoseconds
+
+    time = ((double)nowTime/1000000.0);     // Time in miliseconds
+#endif
+
+#if defined(__APPLE__)
+    //#define CLOCK_REALTIME  CALENDAR_CLOCK    // returns UTC time since 1970-01-01
+    //#define CLOCK_MONOTONIC SYSTEM_CLOCK      // returns the time since boot time
+
+    clock_serv_t cclock;
+    mach_timespec_t now;
+    host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
+
+    // NOTE: OS X does not have clock_gettime(), using clock_get_time()
+    clock_get_time(cclock, &now);
+    mach_port_deallocate(mach_task_self(), cclock);
+    unsigned long long int nowTime = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec;     // Time in nanoseconds
+
+    time = ((double)nowTime/1000000.0);     // Time in miliseconds
+#endif
+
+    return time;
+}
+
+#endif // GESTURES_IMPLEMENTATION
+ rlImGui/raylib/src/rlgl.h view
@@ -0,0 +1,4717 @@+/**********************************************************************************************
+*
+*   rlgl v4.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
+*
+*   An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0)
+*   that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
+*
+*   When chosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
+*   initialized on rlglInit() to accumulate vertex data.
+*
+*   When an internal state change is required all the stored vertex data is renderer in batch,
+*   additioanlly, rlDrawRenderBatchActive() could be called to force flushing of the batch.
+*
+*   Some additional resources are also loaded for convenience, here the complete list:
+*      - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
+*      - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
+*      - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
+*
+*   Internal buffer (and additional resources) must be manually unloaded calling rlglClose().
+*
+*
+*   CONFIGURATION:
+*
+*   #define GRAPHICS_API_OPENGL_11
+*   #define GRAPHICS_API_OPENGL_21
+*   #define GRAPHICS_API_OPENGL_33
+*   #define GRAPHICS_API_OPENGL_43
+*   #define GRAPHICS_API_OPENGL_ES2
+*       Use selected OpenGL graphics backend, should be supported by platform
+*       Those preprocessor defines are only used on rlgl module, if OpenGL version is
+*       required by any other module, use rlGetVersion() to check it
+*
+*   #define RLGL_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   #define RLGL_RENDER_TEXTURES_HINT
+*       Enable framebuffer objects (fbo) support (enabled by default)
+*       Some GPUs could not support them despite the OpenGL version
+*
+*   #define RLGL_SHOW_GL_DETAILS_INFO
+*       Show OpenGL extensions and capabilities detailed logs on init
+*
+*   #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
+*       Enable debug context (only available on OpenGL 4.3)
+*
+*   rlgl capabilities could be customized just defining some internal
+*   values before library inclusion (default values listed):
+*
+*   #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch elements limits
+*   #define RL_DEFAULT_BATCH_BUFFERS              1    // Default number of batch buffers (multi-buffering)
+*   #define RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw calls (by state changes: mode, texture)
+*   #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+*
+*   #define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of internal Matrix stack
+*   #define RL_MAX_SHADER_LOCATIONS              32    // Maximum number of shader locations supported
+*   #define RL_CULL_DISTANCE_NEAR              0.01    // Default projection matrix near cull distance
+*   #define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
+*
+*   When loading a shader, the following vertex attribute and uniform
+*   location names are tried to be set automatically:
+*
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Binded by default to shader location: 0
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Binded by default to shader location: 1
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Binded by default to shader location: 2
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Binded by default to shader location: 3
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Binded by default to shader location: 4
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Binded by default to shader location: 5
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+*
+*   DEPENDENCIES:
+*
+*      - OpenGL libraries (depending on platform and OpenGL version selected)
+*      - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core)
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2014-2022 Ramon Santamaria (@raysan5)
+*
+*   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 RLGL_H
+#define RLGL_H
+
+#define RLGL_VERSION  "4.0"
+
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+#if defined(_WIN32)
+    #if defined(BUILD_LIBTYPE_SHARED)
+        #define RLAPI __declspec(dllexport)     // We are building the library as a Win32 shared library (.dll)
+    #elif defined(USE_LIBTYPE_SHARED)
+        #define RLAPI __declspec(dllimport)     // We are using the library as a Win32 shared library (.dll)
+    #endif
+#endif
+
+// Function specifiers definition
+#ifndef RLAPI
+    #define RLAPI       // Functions defined as 'extern' by default (implicit specifiers)
+#endif
+
+// Support TRACELOG macros
+#ifndef TRACELOG
+    #define TRACELOG(level, ...) (void)0
+    #define TRACELOGD(...) (void)0
+#endif
+
+// Allow custom memory allocators
+#ifndef RL_MALLOC
+    #define RL_MALLOC(sz)     malloc(sz)
+#endif
+#ifndef RL_CALLOC
+    #define RL_CALLOC(n,sz)   calloc(n,sz)
+#endif
+#ifndef RL_REALLOC
+    #define RL_REALLOC(n,sz)  realloc(n,sz)
+#endif
+#ifndef RL_FREE
+    #define RL_FREE(p)        free(p)
+#endif
+
+// Security check in case no GRAPHICS_API_OPENGL_* defined
+#if !defined(GRAPHICS_API_OPENGL_11) && \
+    !defined(GRAPHICS_API_OPENGL_21) && \
+    !defined(GRAPHICS_API_OPENGL_33) && \
+    !defined(GRAPHICS_API_OPENGL_43) && \
+    !defined(GRAPHICS_API_OPENGL_ES2)
+        #define GRAPHICS_API_OPENGL_33
+#endif
+
+// Security check in case multiple GRAPHICS_API_OPENGL_* defined
+#if defined(GRAPHICS_API_OPENGL_11)
+    #if defined(GRAPHICS_API_OPENGL_21)
+        #undef GRAPHICS_API_OPENGL_21
+    #endif
+    #if defined(GRAPHICS_API_OPENGL_33)
+        #undef GRAPHICS_API_OPENGL_33
+    #endif
+    #if defined(GRAPHICS_API_OPENGL_43)
+        #undef GRAPHICS_API_OPENGL_43
+    #endif
+    #if defined(GRAPHICS_API_OPENGL_ES2)
+        #undef GRAPHICS_API_OPENGL_ES2
+    #endif
+#endif
+
+// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality
+// WARNING: Specific parts are checked with #if defines
+#if defined(GRAPHICS_API_OPENGL_21)
+    #define GRAPHICS_API_OPENGL_33
+#endif
+
+// OpenGL 4.3 uses OpenGL 3.3 Core functionality
+#if defined(GRAPHICS_API_OPENGL_43)
+    #define GRAPHICS_API_OPENGL_33
+#endif
+
+// Support framebuffer objects by default
+// NOTE: Some driver implementation do not support it, despite they should
+#define RLGL_RENDER_TEXTURES_HINT
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+
+// Default internal render batch elements limits
+#ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS
+    #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+        // This is the maximum amount of elements (quads) per batch
+        // NOTE: Be careful with text, every letter maps to a quad
+        #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS  8192
+    #endif
+    #if defined(GRAPHICS_API_OPENGL_ES2)
+        // We reduce memory sizes for embedded systems (RPI and HTML5)
+        // NOTE: On HTML5 (emscripten) this is allocated on heap,
+        // by default it's only 16MB!...just take care...
+        #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS  2048
+    #endif
+#endif
+#ifndef RL_DEFAULT_BATCH_BUFFERS
+    #define RL_DEFAULT_BATCH_BUFFERS                 1      // Default number of batch buffers (multi-buffering)
+#endif
+#ifndef RL_DEFAULT_BATCH_DRAWCALLS
+    #define RL_DEFAULT_BATCH_DRAWCALLS             256      // Default number of batch draw calls (by state changes: mode, texture)
+#endif
+#ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS
+    #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS       4      // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+#endif
+
+// Internal Matrix stack
+#ifndef RL_MAX_MATRIX_STACK_SIZE
+    #define RL_MAX_MATRIX_STACK_SIZE                32      // Maximum size of Matrix stack
+#endif
+
+// Shader limits
+#ifndef RL_MAX_SHADER_LOCATIONS
+    #define RL_MAX_SHADER_LOCATIONS                 32      // Maximum number of shader locations supported
+#endif
+
+// Projection matrix culling
+#ifndef RL_CULL_DISTANCE_NEAR
+    #define RL_CULL_DISTANCE_NEAR                 0.01      // Default near cull distance
+#endif
+#ifndef RL_CULL_DISTANCE_FAR
+    #define RL_CULL_DISTANCE_FAR                1000.0      // Default far cull distance
+#endif
+
+// Texture parameters (equivalent to OpenGL defines)
+#define RL_TEXTURE_WRAP_S                       0x2802      // GL_TEXTURE_WRAP_S
+#define RL_TEXTURE_WRAP_T                       0x2803      // GL_TEXTURE_WRAP_T
+#define RL_TEXTURE_MAG_FILTER                   0x2800      // GL_TEXTURE_MAG_FILTER
+#define RL_TEXTURE_MIN_FILTER                   0x2801      // GL_TEXTURE_MIN_FILTER
+
+#define RL_TEXTURE_FILTER_NEAREST               0x2600      // GL_NEAREST
+#define RL_TEXTURE_FILTER_LINEAR                0x2601      // GL_LINEAR
+#define RL_TEXTURE_FILTER_MIP_NEAREST           0x2700      // GL_NEAREST_MIPMAP_NEAREST
+#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR    0x2702      // GL_NEAREST_MIPMAP_LINEAR
+#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST    0x2701      // GL_LINEAR_MIPMAP_NEAREST
+#define RL_TEXTURE_FILTER_MIP_LINEAR            0x2703      // GL_LINEAR_MIPMAP_LINEAR
+#define RL_TEXTURE_FILTER_ANISOTROPIC           0x3000      // Anisotropic filter (custom identifier)
+
+#define RL_TEXTURE_WRAP_REPEAT                  0x2901      // GL_REPEAT
+#define RL_TEXTURE_WRAP_CLAMP                   0x812F      // GL_CLAMP_TO_EDGE
+#define RL_TEXTURE_WRAP_MIRROR_REPEAT           0x8370      // GL_MIRRORED_REPEAT
+#define RL_TEXTURE_WRAP_MIRROR_CLAMP            0x8742      // GL_MIRROR_CLAMP_EXT
+
+// Matrix modes (equivalent to OpenGL)
+#define RL_MODELVIEW                            0x1700      // GL_MODELVIEW
+#define RL_PROJECTION                           0x1701      // GL_PROJECTION
+#define RL_TEXTURE                              0x1702      // GL_TEXTURE
+
+// Primitive assembly draw modes
+#define RL_LINES                                0x0001      // GL_LINES
+#define RL_TRIANGLES                            0x0004      // GL_TRIANGLES
+#define RL_QUADS                                0x0007      // GL_QUADS
+
+// GL equivalent data types
+#define RL_UNSIGNED_BYTE                        0x1401      // GL_UNSIGNED_BYTE
+#define RL_FLOAT                                0x1406      // GL_FLOAT
+
+// Buffer usage hint
+#define RL_STREAM_DRAW                          0x88E0      // GL_STREAM_DRAW
+#define RL_STREAM_READ                          0x88E1      // GL_STREAM_READ
+#define RL_STREAM_COPY                          0x88E2      // GL_STREAM_COPY
+#define RL_STATIC_DRAW                          0x88E4      // GL_STATIC_DRAW
+#define RL_STATIC_READ                          0x88E5      // GL_STATIC_READ
+#define RL_STATIC_COPY                          0x88E6      // GL_STATIC_COPY
+#define RL_DYNAMIC_DRAW                         0x88E8      // GL_DYNAMIC_DRAW
+#define RL_DYNAMIC_READ                         0x88E9      // GL_DYNAMIC_READ
+#define RL_DYNAMIC_COPY                         0x88EA      // GL_DYNAMIC_COPY
+
+// GL Shader type
+#define RL_FRAGMENT_SHADER                      0x8B30      // GL_FRAGMENT_SHADER
+#define RL_VERTEX_SHADER                        0x8B31      // GL_VERTEX_SHADER
+#define RL_COMPUTE_SHADER                       0x91B9      // GL_COMPUTE_SHADER
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef enum {
+    OPENGL_11 = 1,
+    OPENGL_21,
+    OPENGL_33,
+    OPENGL_43,
+    OPENGL_ES_20
+} rlGlVersion;
+
+typedef enum {
+    RL_ATTACHMENT_COLOR_CHANNEL0 = 0,
+    RL_ATTACHMENT_COLOR_CHANNEL1,
+    RL_ATTACHMENT_COLOR_CHANNEL2,
+    RL_ATTACHMENT_COLOR_CHANNEL3,
+    RL_ATTACHMENT_COLOR_CHANNEL4,
+    RL_ATTACHMENT_COLOR_CHANNEL5,
+    RL_ATTACHMENT_COLOR_CHANNEL6,
+    RL_ATTACHMENT_COLOR_CHANNEL7,
+    RL_ATTACHMENT_DEPTH = 100,
+    RL_ATTACHMENT_STENCIL = 200,
+} rlFramebufferAttachType;
+
+typedef enum {
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0,
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_X,
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_Y,
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y,
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_Z,
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z,
+    RL_ATTACHMENT_TEXTURE2D = 100,
+    RL_ATTACHMENT_RENDERBUFFER = 200,
+} rlFramebufferAttachTextureType;
+
+// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
+typedef struct rlVertexBuffer {
+    int elementCount;           // Number of elements in the buffer (QUADS)
+
+    float *vertices;            // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    float *texcoords;           // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    unsigned char *colors;      // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+    unsigned int *indices;      // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    unsigned short *indices;    // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
+#endif
+    unsigned int vaoId;         // OpenGL Vertex Array Object id
+    unsigned int vboId[4];      // OpenGL Vertex Buffer Objects id (4 types of vertex data)
+} rlVertexBuffer;
+
+// Draw call type
+// NOTE: Only texture changes register a new draw, other state-change-related elements are not
+// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any
+// of those state-change happens (this is done in core module)
+typedef struct rlDrawCall {
+    int mode;                   // Drawing mode: LINES, TRIANGLES, QUADS
+    int vertexCount;            // Number of vertex of the draw
+    int vertexAlignment;        // Number of vertex required for index alignment (LINES, TRIANGLES)
+    //unsigned int vaoId;       // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
+    //unsigned int shaderId;    // Shader id to be used on the draw -> Using RLGL.currentShaderId
+    unsigned int textureId;     // Texture id to be used on the draw -> Use to create new draw call if changes
+
+    //Matrix projection;      // Projection matrix for this draw -> Using RLGL.projection by default
+    //Matrix modelview;       // Modelview matrix for this draw -> Using RLGL.modelview by default
+} rlDrawCall;
+
+// rlRenderBatch type
+typedef struct rlRenderBatch {
+    int bufferCount;            // Number of vertex buffers (multi-buffering support)
+    int currentBuffer;          // Current buffer tracking in case of multi-buffering
+    rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data
+
+    rlDrawCall *draws;          // Draw calls array, depends on textureId
+    int drawCounter;            // Draw calls counter
+    float currentDepth;         // Current depth value for next draw
+} rlRenderBatch;
+
+#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
+    #include <stdbool.h>
+#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
+    // Boolean type
+typedef enum bool { false = 0, true = !false } bool;
+#endif
+
+#if !defined(RL_MATRIX_TYPE)
+// Matrix, 4x4 components, column major, OpenGL style, right handed
+typedef struct Matrix {
+    float m0, m4, m8, m12;  // Matrix first row (4 components)
+    float m1, m5, m9, m13;  // Matrix second row (4 components)
+    float m2, m6, m10, m14; // Matrix third row (4 components)
+    float m3, m7, m11, m15; // Matrix fourth row (4 components)
+} Matrix;
+#define RL_MATRIX_TYPE
+#endif
+
+// Trace log level
+// NOTE: Organized by priority level
+typedef enum {
+    RL_LOG_ALL = 0,            // Display all logs
+    RL_LOG_TRACE,              // Trace logging, intended for internal use only
+    RL_LOG_DEBUG,              // Debug logging, used for internal debugging, it should be disabled on release builds
+    RL_LOG_INFO,               // Info logging, used for program execution info
+    RL_LOG_WARNING,            // Warning logging, used on recoverable failures
+    RL_LOG_ERROR,              // Error logging, used on unrecoverable failures
+    RL_LOG_FATAL,              // Fatal logging, used to abort program: exit(EXIT_FAILURE)
+    RL_LOG_NONE                // Disable logging
+} rlTraceLogLevel;
+
+// Texture formats (support depends on OpenGL version)
+typedef enum {
+    RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1,     // 8 bit per pixel (no alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,        // 8*2 bpp (2 channels)
+    RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5,            // 16 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8,            // 24 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1,          // 16 bpp (1 bit alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4,          // 16 bpp (4 bit alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,          // 32 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R32,               // 32 bpp (1 channel - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32,         // 32*3 bpp (3 channels - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32,      // 32*4 bpp (4 channels - float)
+    RL_PIXELFORMAT_COMPRESSED_DXT1_RGB,            // 4 bpp (no alpha)
+    RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA,           // 4 bpp (1 bit alpha)
+    RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA,           // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA,           // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC1_RGB,            // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC2_RGB,            // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA,       // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_PVRT_RGB,            // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA,           // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA,       // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA        // 2 bpp
+} rlPixelFormat;
+
+// Texture parameters: filter mode
+// NOTE 1: Filtering considers mipmaps if available in the texture
+// NOTE 2: Filter is accordingly set for minification and magnification
+typedef enum {
+    RL_TEXTURE_FILTER_POINT = 0,               // No filter, just pixel approximation
+    RL_TEXTURE_FILTER_BILINEAR,                // Linear filtering
+    RL_TEXTURE_FILTER_TRILINEAR,               // Trilinear filtering (linear with mipmaps)
+    RL_TEXTURE_FILTER_ANISOTROPIC_4X,          // Anisotropic filtering 4x
+    RL_TEXTURE_FILTER_ANISOTROPIC_8X,          // Anisotropic filtering 8x
+    RL_TEXTURE_FILTER_ANISOTROPIC_16X,         // Anisotropic filtering 16x
+} rlTextureFilter;
+
+// Color blending modes (pre-defined)
+typedef enum {
+    RL_BLEND_ALPHA = 0,                // Blend textures considering alpha (default)
+    RL_BLEND_ADDITIVE,                 // Blend textures adding colors
+    RL_BLEND_MULTIPLIED,               // Blend textures multiplying colors
+    RL_BLEND_ADD_COLORS,               // Blend textures adding colors (alternative)
+    RL_BLEND_SUBTRACT_COLORS,          // Blend textures subtracting colors (alternative)
+    RL_BLEND_ALPHA_PREMULTIPLY,        // Blend premultiplied textures considering alpha
+    RL_BLEND_CUSTOM                    // Blend textures using custom src/dst factors (use rlSetBlendFactors())
+} rlBlendMode;
+
+// Shader location point type
+typedef enum {
+    RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
+    RL_SHADER_LOC_VERTEX_TEXCOORD01,   // Shader location: vertex attribute: texcoord01
+    RL_SHADER_LOC_VERTEX_TEXCOORD02,   // Shader location: vertex attribute: texcoord02
+    RL_SHADER_LOC_VERTEX_NORMAL,       // Shader location: vertex attribute: normal
+    RL_SHADER_LOC_VERTEX_TANGENT,      // Shader location: vertex attribute: tangent
+    RL_SHADER_LOC_VERTEX_COLOR,        // Shader location: vertex attribute: color
+    RL_SHADER_LOC_MATRIX_MVP,          // Shader location: matrix uniform: model-view-projection
+    RL_SHADER_LOC_MATRIX_VIEW,         // Shader location: matrix uniform: view (camera transform)
+    RL_SHADER_LOC_MATRIX_PROJECTION,   // Shader location: matrix uniform: projection
+    RL_SHADER_LOC_MATRIX_MODEL,        // Shader location: matrix uniform: model (transform)
+    RL_SHADER_LOC_MATRIX_NORMAL,       // Shader location: matrix uniform: normal
+    RL_SHADER_LOC_VECTOR_VIEW,         // Shader location: vector uniform: view
+    RL_SHADER_LOC_COLOR_DIFFUSE,       // Shader location: vector uniform: diffuse color
+    RL_SHADER_LOC_COLOR_SPECULAR,      // Shader location: vector uniform: specular color
+    RL_SHADER_LOC_COLOR_AMBIENT,       // Shader location: vector uniform: ambient color
+    RL_SHADER_LOC_MAP_ALBEDO,          // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
+    RL_SHADER_LOC_MAP_METALNESS,       // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
+    RL_SHADER_LOC_MAP_NORMAL,          // Shader location: sampler2d texture: normal
+    RL_SHADER_LOC_MAP_ROUGHNESS,       // Shader location: sampler2d texture: roughness
+    RL_SHADER_LOC_MAP_OCCLUSION,       // Shader location: sampler2d texture: occlusion
+    RL_SHADER_LOC_MAP_EMISSION,        // Shader location: sampler2d texture: emission
+    RL_SHADER_LOC_MAP_HEIGHT,          // Shader location: sampler2d texture: height
+    RL_SHADER_LOC_MAP_CUBEMAP,         // Shader location: samplerCube texture: cubemap
+    RL_SHADER_LOC_MAP_IRRADIANCE,      // Shader location: samplerCube texture: irradiance
+    RL_SHADER_LOC_MAP_PREFILTER,       // Shader location: samplerCube texture: prefilter
+    RL_SHADER_LOC_MAP_BRDF             // Shader location: sampler2d texture: brdf
+} rlShaderLocationIndex;
+
+#define RL_SHADER_LOC_MAP_DIFFUSE      RL_SHADER_LOC_MAP_ALBEDO
+#define RL_SHADER_LOC_MAP_SPECULAR     RL_SHADER_LOC_MAP_METALNESS
+
+// Shader uniform data type
+typedef enum {
+    RL_SHADER_UNIFORM_FLOAT = 0,       // Shader uniform type: float
+    RL_SHADER_UNIFORM_VEC2,            // Shader uniform type: vec2 (2 float)
+    RL_SHADER_UNIFORM_VEC3,            // Shader uniform type: vec3 (3 float)
+    RL_SHADER_UNIFORM_VEC4,            // Shader uniform type: vec4 (4 float)
+    RL_SHADER_UNIFORM_INT,             // Shader uniform type: int
+    RL_SHADER_UNIFORM_IVEC2,           // Shader uniform type: ivec2 (2 int)
+    RL_SHADER_UNIFORM_IVEC3,           // Shader uniform type: ivec3 (3 int)
+    RL_SHADER_UNIFORM_IVEC4,           // Shader uniform type: ivec4 (4 int)
+    RL_SHADER_UNIFORM_SAMPLER2D        // Shader uniform type: sampler2d
+} rlShaderUniformDataType;
+
+// Shader attribute data types
+typedef enum {
+    RL_SHADER_ATTRIB_FLOAT = 0,        // Shader attribute type: float
+    RL_SHADER_ATTRIB_VEC2,             // Shader attribute type: vec2 (2 float)
+    RL_SHADER_ATTRIB_VEC3,             // Shader attribute type: vec3 (3 float)
+    RL_SHADER_ATTRIB_VEC4              // Shader attribute type: vec4 (4 float)
+} rlShaderAttributeDataType;
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Matrix operations
+//------------------------------------------------------------------------------------
+
+#if defined(__cplusplus)
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+RLAPI void rlMatrixMode(int mode);                    // Choose the current matrix to be transformed
+RLAPI void rlPushMatrix(void);                        // Push the current matrix to stack
+RLAPI void rlPopMatrix(void);                         // Pop lattest inserted matrix from stack
+RLAPI void rlLoadIdentity(void);                      // Reset current matrix to identity matrix
+RLAPI void rlTranslatef(float x, float y, float z);   // Multiply the current matrix by a translation matrix
+RLAPI void rlRotatef(float angle, float x, float y, float z);  // Multiply the current matrix by a rotation matrix
+RLAPI void rlScalef(float x, float y, float z);       // Multiply the current matrix by a scaling matrix
+RLAPI void rlMultMatrixf(float *matf);                // Multiply the current matrix by another matrix
+RLAPI void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
+RLAPI void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
+RLAPI void rlViewport(int x, int y, int width, int height); // Set the viewport area
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Vertex level operations
+//------------------------------------------------------------------------------------
+RLAPI void rlBegin(int mode);                         // Initialize drawing mode (how to organize vertex)
+RLAPI void rlEnd(void);                               // Finish vertex providing
+RLAPI void rlVertex2i(int x, int y);                  // Define one vertex (position) - 2 int
+RLAPI void rlVertex2f(float x, float y);              // Define one vertex (position) - 2 float
+RLAPI void rlVertex3f(float x, float y, float z);     // Define one vertex (position) - 3 float
+RLAPI void rlTexCoord2f(float x, float y);            // Define one vertex (texture coordinate) - 2 float
+RLAPI void rlNormal3f(float x, float y, float z);     // Define one vertex (normal) - 3 float
+RLAPI void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);  // Define one vertex (color) - 4 byte
+RLAPI void rlColor3f(float x, float y, float z);          // Define one vertex (color) - 3 float
+RLAPI void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
+// NOTE: This functions are used to completely abstract raylib code from OpenGL layer,
+// some of them are direct wrappers over OpenGL calls, some others are custom
+//------------------------------------------------------------------------------------
+
+// Vertex buffers state
+RLAPI bool rlEnableVertexArray(unsigned int vaoId);     // Enable vertex array (VAO, if supported)
+RLAPI void rlDisableVertexArray(void);                  // Disable vertex array (VAO, if supported)
+RLAPI void rlEnableVertexBuffer(unsigned int id);       // Enable vertex buffer (VBO)
+RLAPI void rlDisableVertexBuffer(void);                 // Disable vertex buffer (VBO)
+RLAPI void rlEnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element)
+RLAPI void rlDisableVertexBufferElement(void);          // Disable vertex buffer element (VBO element)
+RLAPI void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index
+RLAPI void rlDisableVertexAttribute(unsigned int index);// Disable vertex attribute index
+#if defined(GRAPHICS_API_OPENGL_11)
+RLAPI void rlEnableStatePointer(int vertexAttribType, void *buffer);    // Enable attribute state pointer
+RLAPI void rlDisableStatePointer(int vertexAttribType);                 // Disable attribute state pointer
+#endif
+
+// Textures state
+RLAPI void rlActiveTextureSlot(int slot);               // Select and active a texture slot
+RLAPI void rlEnableTexture(unsigned int id);            // Enable texture
+RLAPI void rlDisableTexture(void);                      // Disable texture
+RLAPI void rlEnableTextureCubemap(unsigned int id);     // Enable texture cubemap
+RLAPI void rlDisableTextureCubemap(void);               // Disable texture cubemap
+RLAPI void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap)
+
+// Shader state
+RLAPI void rlEnableShader(unsigned int id);             // Enable shader program
+RLAPI void rlDisableShader(void);                       // Disable shader program
+
+// Framebuffer state
+RLAPI void rlEnableFramebuffer(unsigned int id);        // Enable render texture (fbo)
+RLAPI void rlDisableFramebuffer(void);                  // Disable render texture (fbo), return to default framebuffer
+RLAPI void rlActiveDrawBuffers(int count);              // Activate multiple draw color buffers
+
+// General render state
+RLAPI void rlEnableColorBlend(void);                     // Enable color blending
+RLAPI void rlDisableColorBlend(void);                   // Disable color blending
+RLAPI void rlEnableDepthTest(void);                     // Enable depth test
+RLAPI void rlDisableDepthTest(void);                    // Disable depth test
+RLAPI void rlEnableDepthMask(void);                     // Enable depth write
+RLAPI void rlDisableDepthMask(void);                    // Disable depth write
+RLAPI void rlEnableBackfaceCulling(void);               // Enable backface culling
+RLAPI void rlDisableBackfaceCulling(void);              // Disable backface culling
+RLAPI void rlEnableScissorTest(void);                   // Enable scissor test
+RLAPI void rlDisableScissorTest(void);                  // Disable scissor test
+RLAPI void rlScissor(int x, int y, int width, int height); // Scissor test
+RLAPI void rlEnableWireMode(void);                      // Enable wire mode
+RLAPI void rlDisableWireMode(void);                     // Disable wire mode
+RLAPI void rlSetLineWidth(float width);                 // Set the line drawing width
+RLAPI float rlGetLineWidth(void);                       // Get the line drawing width
+RLAPI void rlEnableSmoothLines(void);                   // Enable line aliasing
+RLAPI void rlDisableSmoothLines(void);                  // Disable line aliasing
+RLAPI void rlEnableStereoRender(void);                  // Enable stereo rendering
+RLAPI void rlDisableStereoRender(void);                 // Disable stereo rendering
+RLAPI bool rlIsStereoRenderEnabled(void);               // Check if stereo render is enabled
+
+RLAPI void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color
+RLAPI void rlClearScreenBuffers(void);                  // Clear used screen buffers (color and depth)
+RLAPI void rlCheckErrors(void);                         // Check and log OpenGL error codes
+RLAPI void rlSetBlendMode(int mode);                    // Set blending mode
+RLAPI void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors)
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - rlgl functionality
+//------------------------------------------------------------------------------------
+// rlgl initialization functions
+RLAPI void rlglInit(int width, int height);           // Initialize rlgl (buffers, shaders, textures, states)
+RLAPI void rlglClose(void);                           // De-inititialize rlgl (buffers, shaders, textures)
+RLAPI void rlLoadExtensions(void *loader);            // Load OpenGL extensions (loader function required)
+RLAPI int rlGetVersion(void);                         // Get current OpenGL version
+RLAPI void rlSetFramebufferWidth(int width);          // Set current framebuffer width
+RLAPI int rlGetFramebufferWidth(void);                // Get default framebuffer width
+RLAPI void rlSetFramebufferHeight(int height);        // Set current framebuffer height
+RLAPI int rlGetFramebufferHeight(void);               // Get default framebuffer height
+
+RLAPI unsigned int rlGetTextureIdDefault(void);       // Get default texture id
+RLAPI unsigned int rlGetShaderIdDefault(void);        // Get default shader id
+RLAPI int *rlGetShaderLocsDefault(void);              // Get default shader locations
+
+// Render batch management
+// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode
+// but this render batch API is exposed in case of custom batches are required
+RLAPI rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements);  // Load a render batch system
+RLAPI void rlUnloadRenderBatch(rlRenderBatch batch);                        // Unload render batch system
+RLAPI void rlDrawRenderBatch(rlRenderBatch *batch);                         // Draw render batch data (Update->Draw->Reset)
+RLAPI void rlSetRenderBatchActive(rlRenderBatch *batch);                    // Set the active render batch for rlgl (NULL for default internal)
+RLAPI void rlDrawRenderBatchActive(void);                                   // Update and draw internal render batch
+RLAPI bool rlCheckRenderBatchLimit(int vCount);                             // Check internal buffer overflow for a given number of vertex
+RLAPI void rlSetTexture(unsigned int id);           // Set current texture for render batch and check buffers limits
+
+//------------------------------------------------------------------------------------------------------------------------
+
+// Vertex buffers management
+RLAPI unsigned int rlLoadVertexArray(void);                               // Load vertex array (vao) if supported
+RLAPI unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic);            // Load a vertex buffer attribute
+RLAPI unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic);     // Load a new attributes element buffer
+RLAPI void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset);     // Update GPU buffer with new data
+RLAPI void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset);   // Update vertex buffer elements with new data
+RLAPI void rlUnloadVertexArray(unsigned int vaoId);
+RLAPI void rlUnloadVertexBuffer(unsigned int vboId);
+RLAPI void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer);
+RLAPI void rlSetVertexAttributeDivisor(unsigned int index, int divisor);
+RLAPI void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value
+RLAPI void rlDrawVertexArray(int offset, int count);
+RLAPI void rlDrawVertexArrayElements(int offset, int count, const void *buffer);
+RLAPI void rlDrawVertexArrayInstanced(int offset, int count, int instances);
+RLAPI void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances);
+
+// Textures management
+RLAPI unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU
+RLAPI unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer);               // Load depth texture/renderbuffer (to be attached to fbo)
+RLAPI unsigned int rlLoadTextureCubemap(const void *data, int size, int format);                        // Load texture cubemap
+RLAPI void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data);  // Update GPU texture with new data
+RLAPI void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType);  // Get OpenGL internal formats
+RLAPI const char *rlGetPixelFormatName(unsigned int format);              // Get name string for pixel format
+RLAPI void rlUnloadTexture(unsigned int id);                              // Unload texture from GPU memory
+RLAPI void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture
+RLAPI void *rlReadTexturePixels(unsigned int id, int width, int height, int format);              // Read texture pixel data
+RLAPI unsigned char *rlReadScreenPixels(int width, int height);           // Read screen pixel data (color buffer)
+
+// Framebuffer management (fbo)
+RLAPI unsigned int rlLoadFramebuffer(int width, int height);              // Load an empty framebuffer
+RLAPI void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel);  // Attach texture/renderbuffer to a framebuffer
+RLAPI bool rlFramebufferComplete(unsigned int id);                        // Verify framebuffer is complete
+RLAPI void rlUnloadFramebuffer(unsigned int id);                          // Delete framebuffer from GPU
+
+// Shaders management
+RLAPI unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode);    // Load shader from code strings
+RLAPI unsigned int rlCompileShader(const char *shaderCode, int type);           // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
+RLAPI unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program
+RLAPI void rlUnloadShaderProgram(unsigned int id);                              // Unload shader program
+RLAPI int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform
+RLAPI int rlGetLocationAttrib(unsigned int shaderId, const char *attribName);   // Get shader location attribute
+RLAPI void rlSetUniform(int locIndex, const void *value, int uniformType, int count);   // Set shader value uniform
+RLAPI void rlSetUniformMatrix(int locIndex, Matrix mat);                        // Set shader value matrix
+RLAPI void rlSetUniformSampler(int locIndex, unsigned int textureId);           // Set shader value sampler
+RLAPI void rlSetShader(unsigned int id, int *locs);                             // Set shader currently active (id and locations)
+
+// Compute shader management
+RLAPI unsigned int rlLoadComputeShaderProgram(unsigned int shaderId);           // Load compute shader program
+RLAPI void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ);  // Dispatch compute shader (equivalent to *draw* for graphics pilepine)
+
+// Shader buffer storage object management (ssbo)
+RLAPI unsigned int rlLoadShaderBuffer(unsigned long long size, const void *data, int usageHint);    // Load shader storage buffer object (SSBO)
+RLAPI void rlUnloadShaderBuffer(unsigned int ssboId);                           // Unload shader storage buffer object (SSBO)
+RLAPI void rlUpdateShaderBufferElements(unsigned int id, const void *data, unsigned long long dataSize, unsigned long long offset); // Update SSBO buffer data
+RLAPI unsigned long long rlGetShaderBufferSize(unsigned int id);                // Get SSBO buffer size
+RLAPI void rlReadShaderBufferElements(unsigned int id, void *dest, unsigned long long count, unsigned long long offset);    // Bind SSBO buffer
+RLAPI void rlBindShaderBuffer(unsigned int id, unsigned int index);             // Copy SSBO buffer data
+
+// Buffer management
+RLAPI void rlCopyBuffersElements(unsigned int destId, unsigned int srcId, unsigned long long destOffset, unsigned long long srcOffset, unsigned long long count); // Copy SSBO buffer data
+RLAPI void rlBindImageTexture(unsigned int id, unsigned int index, unsigned int format, int readonly);  // Bind image texture
+
+// Matrix state management
+RLAPI Matrix rlGetMatrixModelview(void);                                  // Get internal modelview matrix
+RLAPI Matrix rlGetMatrixProjection(void);                                 // Get internal projection matrix
+RLAPI Matrix rlGetMatrixTransform(void);                                  // Get internal accumulated transform matrix
+RLAPI Matrix rlGetMatrixProjectionStereo(int eye);                        // Get internal projection matrix for stereo render (selected eye)
+RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye);                        // Get internal view offset matrix for stereo render (selected eye)
+RLAPI void rlSetMatrixProjection(Matrix proj);                            // Set a custom projection matrix (replaces internal projection matrix)
+RLAPI void rlSetMatrixModelview(Matrix view);                             // Set a custom modelview matrix (replaces internal modelview matrix)
+RLAPI void rlSetMatrixProjectionStereo(Matrix right, Matrix left);        // Set eyes projection matrices for stereo rendering
+RLAPI void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left);        // Set eyes view offsets matrices for stereo rendering
+
+// Quick and dirty cube/quad buffers load->draw->unload
+RLAPI void rlLoadDrawCube(void);     // Load and draw a cube
+RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // RLGL_H
+
+/***********************************************************************************
+*
+*   RLGL IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(RLGL_IMPLEMENTATION)
+
+#if defined(GRAPHICS_API_OPENGL_11)
+    #if defined(__APPLE__)
+        #include <OpenGL/gl.h>          // OpenGL 1.1 library for OSX
+        #include <OpenGL/glext.h>       // OpenGL extensions library
+    #else
+        // APIENTRY for OpenGL function pointer declarations is required
+        #ifndef APIENTRY
+            #if defined(_WIN32)
+                #define APIENTRY __stdcall
+            #else
+                #define APIENTRY
+            #endif
+        #endif
+        // WINGDIAPI definition. Some Windows OpenGL headers need it
+        #if !defined(WINGDIAPI) && defined(_WIN32)
+            #define WINGDIAPI __declspec(dllimport)
+        #endif
+
+        #include <GL/gl.h>              // OpenGL 1.1 library
+    #endif
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_33)
+    #if defined(__APPLE__)
+        #include <OpenGL/gl3.h>         // OpenGL 3 library for OSX
+        #include <OpenGL/gl3ext.h>      // OpenGL 3 extensions library for OSX
+    #else
+        #define GLAD_MALLOC RL_MALLOC
+        #define GLAD_FREE RL_FREE
+
+        #define GLAD_GL_IMPLEMENTATION
+        #include "external/glad.h"      // GLAD extensions loading library, includes OpenGL headers
+    #endif
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    #define GL_GLEXT_PROTOTYPES
+    //#include <EGL/egl.h>              // EGL library -> not required, platform layer
+    #include <GLES2/gl2.h>              // OpenGL ES 2.0 library
+    #include <GLES2/gl2ext.h>           // OpenGL ES 2.0 extensions library
+
+    // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi
+    // provided headers (despite being defined in official Khronos GLES2 headers)
+    #if defined(PLATFORM_RPI) || defined(PLATFORM_DRM)
+    typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
+    typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
+    typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor);
+    #endif
+#endif
+
+#include <stdlib.h>                     // Required for: malloc(), free()
+#include <string.h>                     // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
+#include <math.h>                       // Required for: sqrtf(), sinf(), cosf(), floor(), log()
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#ifndef PI
+    #define PI 3.14159265358979323846f
+#endif
+#ifndef DEG2RAD
+    #define DEG2RAD (PI/180.0f)
+#endif
+#ifndef RAD2DEG
+    #define RAD2DEG (180.0f/PI)
+#endif
+
+#ifndef GL_SHADING_LANGUAGE_VERSION
+    #define GL_SHADING_LANGUAGE_VERSION         0x8B8C
+#endif
+
+#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+    #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT     0x83F0
+#endif
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
+    #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT    0x83F1
+#endif
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
+    #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT    0x83F2
+#endif
+#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+    #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT    0x83F3
+#endif
+#ifndef GL_ETC1_RGB8_OES
+    #define GL_ETC1_RGB8_OES                    0x8D64
+#endif
+#ifndef GL_COMPRESSED_RGB8_ETC2
+    #define GL_COMPRESSED_RGB8_ETC2             0x9274
+#endif
+#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC
+    #define GL_COMPRESSED_RGBA8_ETC2_EAC        0x9278
+#endif
+#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG  0x8C00
+#endif
+#ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
+#endif
+#ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR
+    #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR     0x93b0
+#endif
+#ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR
+    #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR     0x93b7
+#endif
+
+#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
+    #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT   0x84FF
+#endif
+#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT
+    #define GL_TEXTURE_MAX_ANISOTROPY_EXT       0x84FE
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_11)
+    #define GL_UNSIGNED_SHORT_5_6_5             0x8363
+    #define GL_UNSIGNED_SHORT_5_5_5_1           0x8034
+    #define GL_UNSIGNED_SHORT_4_4_4_4           0x8033
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_21)
+    #define GL_LUMINANCE                        0x1909
+    #define GL_LUMINANCE_ALPHA                  0x190A
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    #define glClearDepth                 glClearDepthf
+    #define GL_READ_FRAMEBUFFER         GL_FRAMEBUFFER
+    #define GL_DRAW_FRAMEBUFFER         GL_FRAMEBUFFER
+#endif
+
+// Default shader vertex attribute names to set location points
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Binded by default to shader location: 0
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Binded by default to shader location: 1
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Binded by default to shader location: 2
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Binded by default to shader location: 3
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Binded by default to shader location: 4
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Binded by default to shader location: 5
+#endif
+
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+#endif
+#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0
+    #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+#endif
+#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1
+    #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+#endif
+#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2
+    #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+typedef struct rlglData {
+    rlRenderBatch *currentBatch;            // Current render batch
+    rlRenderBatch defaultBatch;             // Default internal render batch
+
+    struct {
+        int vertexCounter;                  // Current active render batch vertex counter (generic, used for all batches)
+        float texcoordx, texcoordy;         // Current active texture coordinate (added on glVertex*())
+        float normalx, normaly, normalz;    // Current active normal (added on glVertex*())
+        unsigned char colorr, colorg, colorb, colora;   // Current active color (added on glVertex*())
+
+        int currentMatrixMode;              // Current matrix mode
+        Matrix *currentMatrix;              // Current matrix pointer
+        Matrix modelview;                   // Default modelview matrix
+        Matrix projection;                  // Default projection matrix
+        Matrix transform;                   // Transform matrix to be used with rlTranslate, rlRotate, rlScale
+        bool transformRequired;             // Require transform matrix application to current draw-call vertex (if required)
+        Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop
+        int stackCounter;                   // Matrix stack counter
+
+        unsigned int defaultTextureId;      // Default texture used on shapes/poly drawing (required by shader)
+        unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS];    // Active texture ids to be enabled on batch drawing (0 active by default)
+        unsigned int defaultVShaderId;      // Default vertex shader id (used by default shader program)
+        unsigned int defaultFShaderId;      // Default fragment shader id (used by default shader program)
+        unsigned int defaultShaderId;       // Default shader program id, supports vertex color and diffuse texture
+        int *defaultShaderLocs;             // Default shader locations pointer to be used on rendering
+        unsigned int currentShaderId;       // Current shader id to be used on rendering (by default, defaultShaderId)
+        int *currentShaderLocs;             // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs)
+
+        bool stereoRender;                  // Stereo rendering flag
+        Matrix projectionStereo[2];         // VR stereo rendering eyes projection matrices
+        Matrix viewOffsetStereo[2];         // VR stereo rendering eyes view offset matrices
+
+        int currentBlendMode;               // Blending mode active
+        int glBlendSrcFactor;               // Blending source factor
+        int glBlendDstFactor;               // Blending destination factor
+        int glBlendEquation;                // Blending equation
+
+        int framebufferWidth;               // Current framebuffer width
+        int framebufferHeight;              // Current framebuffer height
+
+    } State;            // Renderer state
+    struct {
+        bool vao;                           // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object)
+        bool instancing;                    // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
+        bool texNPOT;                       // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
+        bool texDepth;                      // Depth textures supported (GL_ARB_depth_texture, GL_WEBGL_depth_texture, GL_OES_depth_texture)
+        bool texFloat32;                    // float textures support (32 bit per channel) (GL_OES_texture_float)
+        bool texCompDXT;                    // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc)
+        bool texCompETC1;                   // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1)
+        bool texCompETC2;                   // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility)
+        bool texCompPVRT;                   // PVR texture compression support (GL_IMG_texture_compression_pvrtc)
+        bool texCompASTC;                   // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr)
+        bool texMirrorClamp;                // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp)
+        bool texAnisoFilter;                // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic)
+        bool computeShader;                 // Compute shaders support (GL_ARB_compute_shader)
+        bool ssbo;                          // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object)
+
+        float maxAnisotropyLevel;           // Maximum anisotropy level supported (minimum is 2.0f)
+        int maxDepthBits;                   // Maximum bits for depth component
+
+    } ExtSupported;     // Extensions supported flags
+} rlglData;
+
+typedef void *(*rlglLoadProc)(const char *name);   // OpenGL extension functions loader signature (same as GLADloadproc)
+
+#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+static rlglData RLGL = { 0 };
+#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+#if defined(GRAPHICS_API_OPENGL_ES2)
+// NOTE: VAO functionality is exposed through extensions (OES)
+static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL;
+static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL;
+static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL;
+
+// NOTE: Instancing functionality could also be available through extension
+static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL;
+static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL;
+static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL;
+#endif
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+static void rlLoadShaderDefault(void);      // Load default shader
+static void rlUnloadShaderDefault(void);    // Unload default shader
+#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+static char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name
+#endif  // RLGL_SHOW_GL_DETAILS_INFO
+#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#if defined(GRAPHICS_API_OPENGL_11)
+static int rlGenTextureMipmapsData(unsigned char *data, int baseWidth, int baseHeight);         // Generate mipmaps data on CPU side
+static unsigned char *rlGenNextMipmapData(unsigned char *srcData, int srcWidth, int srcHeight); // Generate next mipmap level on CPU side
+#endif
+static int rlGetPixelDataSize(int width, int height, int format);   // Get pixel data size in bytes (image or texture)
+// Auxiliar matrix math functions
+static Matrix rlMatrixIdentity(void);                             // Get identity matrix
+static Matrix rlMatrixMultiply(Matrix left, Matrix right);    // Multiply two matrices
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Matrix operations
+//----------------------------------------------------------------------------------
+
+#if defined(GRAPHICS_API_OPENGL_11)
+// Fallback to OpenGL 1.1 function calls
+//---------------------------------------
+void rlMatrixMode(int mode)
+{
+    switch (mode)
+    {
+        case RL_PROJECTION: glMatrixMode(GL_PROJECTION); break;
+        case RL_MODELVIEW: glMatrixMode(GL_MODELVIEW); break;
+        case RL_TEXTURE: glMatrixMode(GL_TEXTURE); break;
+        default: break;
+    }
+}
+
+void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
+{
+    glFrustum(left, right, bottom, top, znear, zfar);
+}
+
+void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
+{
+    glOrtho(left, right, bottom, top, znear, zfar);
+}
+
+void rlPushMatrix(void) { glPushMatrix(); }
+void rlPopMatrix(void) { glPopMatrix(); }
+void rlLoadIdentity(void) { glLoadIdentity(); }
+void rlTranslatef(float x, float y, float z) { glTranslatef(x, y, z); }
+void rlRotatef(float angle, float x, float y, float z) { glRotatef(angle, x, y, z); }
+void rlScalef(float x, float y, float z) { glScalef(x, y, z); }
+void rlMultMatrixf(float *matf) { glMultMatrixf(matf); }
+#endif
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+// Choose the current matrix to be transformed
+void rlMatrixMode(int mode)
+{
+    if (mode == RL_PROJECTION) RLGL.State.currentMatrix = &RLGL.State.projection;
+    else if (mode == RL_MODELVIEW) RLGL.State.currentMatrix = &RLGL.State.modelview;
+    //else if (mode == RL_TEXTURE) // Not supported
+
+    RLGL.State.currentMatrixMode = mode;
+}
+
+// Push the current matrix into RLGL.State.stack
+void rlPushMatrix(void)
+{
+    if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)");
+
+    if (RLGL.State.currentMatrixMode == RL_MODELVIEW)
+    {
+        RLGL.State.transformRequired = true;
+        RLGL.State.currentMatrix = &RLGL.State.transform;
+    }
+
+    RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix;
+    RLGL.State.stackCounter++;
+}
+
+// Pop lattest inserted matrix from RLGL.State.stack
+void rlPopMatrix(void)
+{
+    if (RLGL.State.stackCounter > 0)
+    {
+        Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1];
+        *RLGL.State.currentMatrix = mat;
+        RLGL.State.stackCounter--;
+    }
+
+    if ((RLGL.State.stackCounter == 0) && (RLGL.State.currentMatrixMode == RL_MODELVIEW))
+    {
+        RLGL.State.currentMatrix = &RLGL.State.modelview;
+        RLGL.State.transformRequired = false;
+    }
+}
+
+// Reset current matrix to identity matrix
+void rlLoadIdentity(void)
+{
+    *RLGL.State.currentMatrix = rlMatrixIdentity();
+}
+
+// Multiply the current matrix by a translation matrix
+void rlTranslatef(float x, float y, float z)
+{
+    Matrix matTranslation = {
+        1.0f, 0.0f, 0.0f, x,
+        0.0f, 1.0f, 0.0f, y,
+        0.0f, 0.0f, 1.0f, z,
+        0.0f, 0.0f, 0.0f, 1.0f
+    };
+
+    // NOTE: We transpose matrix with multiplication order
+    *RLGL.State.currentMatrix = rlMatrixMultiply(matTranslation, *RLGL.State.currentMatrix);
+}
+
+// Multiply the current matrix by a rotation matrix
+// NOTE: The provided angle must be in degrees
+void rlRotatef(float angle, float x, float y, float z)
+{
+    Matrix matRotation = rlMatrixIdentity();
+
+    // Axis vector (x, y, z) normalization
+    float lengthSquared = x*x + y*y + z*z;
+    if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f))
+    {
+        float inverseLength = 1.0f/sqrtf(lengthSquared);
+        x *= inverseLength;
+        y *= inverseLength;
+        z *= inverseLength;
+    }
+
+    // Rotation matrix generation
+    float sinres = sinf(DEG2RAD*angle);
+    float cosres = cosf(DEG2RAD*angle);
+    float t = 1.0f - cosres;
+
+    matRotation.m0 = x*x*t + cosres;
+    matRotation.m1 = y*x*t + z*sinres;
+    matRotation.m2 = z*x*t - y*sinres;
+    matRotation.m3 = 0.0f;
+
+    matRotation.m4 = x*y*t - z*sinres;
+    matRotation.m5 = y*y*t + cosres;
+    matRotation.m6 = z*y*t + x*sinres;
+    matRotation.m7 = 0.0f;
+
+    matRotation.m8 = x*z*t + y*sinres;
+    matRotation.m9 = y*z*t - x*sinres;
+    matRotation.m10 = z*z*t + cosres;
+    matRotation.m11 = 0.0f;
+
+    matRotation.m12 = 0.0f;
+    matRotation.m13 = 0.0f;
+    matRotation.m14 = 0.0f;
+    matRotation.m15 = 1.0f;
+
+    // NOTE: We transpose matrix with multiplication order
+    *RLGL.State.currentMatrix = rlMatrixMultiply(matRotation, *RLGL.State.currentMatrix);
+}
+
+// Multiply the current matrix by a scaling matrix
+void rlScalef(float x, float y, float z)
+{
+    Matrix matScale = {
+        x, 0.0f, 0.0f, 0.0f,
+        0.0f, y, 0.0f, 0.0f,
+        0.0f, 0.0f, z, 0.0f,
+        0.0f, 0.0f, 0.0f, 1.0f
+    };
+
+    // NOTE: We transpose matrix with multiplication order
+    *RLGL.State.currentMatrix = rlMatrixMultiply(matScale, *RLGL.State.currentMatrix);
+}
+
+// Multiply the current matrix by another matrix
+void rlMultMatrixf(float *matf)
+{
+    // Matrix creation from array
+    Matrix mat = { matf[0], matf[4], matf[8], matf[12],
+                   matf[1], matf[5], matf[9], matf[13],
+                   matf[2], matf[6], matf[10], matf[14],
+                   matf[3], matf[7], matf[11], matf[15] };
+
+    *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, mat);
+}
+
+// Multiply the current matrix by a perspective matrix generated by parameters
+void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
+{
+    Matrix matFrustum = { 0 };
+
+    float rl = (float)(right - left);
+    float tb = (float)(top - bottom);
+    float fn = (float)(zfar - znear);
+
+    matFrustum.m0 = ((float) znear*2.0f)/rl;
+    matFrustum.m1 = 0.0f;
+    matFrustum.m2 = 0.0f;
+    matFrustum.m3 = 0.0f;
+
+    matFrustum.m4 = 0.0f;
+    matFrustum.m5 = ((float) znear*2.0f)/tb;
+    matFrustum.m6 = 0.0f;
+    matFrustum.m7 = 0.0f;
+
+    matFrustum.m8 = ((float)right + (float)left)/rl;
+    matFrustum.m9 = ((float)top + (float)bottom)/tb;
+    matFrustum.m10 = -((float)zfar + (float)znear)/fn;
+    matFrustum.m11 = -1.0f;
+
+    matFrustum.m12 = 0.0f;
+    matFrustum.m13 = 0.0f;
+    matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn;
+    matFrustum.m15 = 0.0f;
+
+    *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum);
+}
+
+// Multiply the current matrix by an orthographic matrix generated by parameters
+void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
+{
+    // NOTE: If left-right and top-botton values are equal it could create a division by zero,
+    // response to it is platform/compiler dependant
+    Matrix matOrtho = { 0 };
+
+    float rl = (float)(right - left);
+    float tb = (float)(top - bottom);
+    float fn = (float)(zfar - znear);
+
+    matOrtho.m0 = 2.0f/rl;
+    matOrtho.m1 = 0.0f;
+    matOrtho.m2 = 0.0f;
+    matOrtho.m3 = 0.0f;
+    matOrtho.m4 = 0.0f;
+    matOrtho.m5 = 2.0f/tb;
+    matOrtho.m6 = 0.0f;
+    matOrtho.m7 = 0.0f;
+    matOrtho.m8 = 0.0f;
+    matOrtho.m9 = 0.0f;
+    matOrtho.m10 = -2.0f/fn;
+    matOrtho.m11 = 0.0f;
+    matOrtho.m12 = -((float)left + (float)right)/rl;
+    matOrtho.m13 = -((float)top + (float)bottom)/tb;
+    matOrtho.m14 = -((float)zfar + (float)znear)/fn;
+    matOrtho.m15 = 1.0f;
+
+    *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho);
+}
+#endif
+
+// Set the viewport area (transformation from normalized device coordinates to window coordinates)
+// NOTE: We store current viewport dimensions
+void rlViewport(int x, int y, int width, int height)
+{
+    glViewport(x, y, width, height);
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vertex level operations
+//----------------------------------------------------------------------------------
+#if defined(GRAPHICS_API_OPENGL_11)
+// Fallback to OpenGL 1.1 function calls
+//---------------------------------------
+void rlBegin(int mode)
+{
+    switch (mode)
+    {
+        case RL_LINES: glBegin(GL_LINES); break;
+        case RL_TRIANGLES: glBegin(GL_TRIANGLES); break;
+        case RL_QUADS: glBegin(GL_QUADS); break;
+        default: break;
+    }
+}
+
+void rlEnd() { glEnd(); }
+void rlVertex2i(int x, int y) { glVertex2i(x, y); }
+void rlVertex2f(float x, float y) { glVertex2f(x, y); }
+void rlVertex3f(float x, float y, float z) { glVertex3f(x, y, z); }
+void rlTexCoord2f(float x, float y) { glTexCoord2f(x, y); }
+void rlNormal3f(float x, float y, float z) { glNormal3f(x, y, z); }
+void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { glColor4ub(r, g, b, a); }
+void rlColor3f(float x, float y, float z) { glColor3f(x, y, z); }
+void rlColor4f(float x, float y, float z, float w) { glColor4f(x, y, z, w); }
+#endif
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+// Initialize drawing mode (how to organize vertex)
+void rlBegin(int mode)
+{
+    // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
+    // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer
+    if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode)
+    {
+        if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
+        {
+            // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
+            // that way, following QUADS drawing will keep aligned with index processing
+            // It implies adding some extra alignment vertex at the end of the draw,
+            // those vertex are not processed but they are considered as an additional offset
+            // for the next set of vertex to be drawn
+            if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4);
+            else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4)));
+            else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0;
+
+            if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
+            {
+                RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
+                RLGL.currentBatch->drawCounter++;
+            }
+        }
+
+        if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
+
+        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode;
+        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0;
+        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId;
+    }
+}
+
+// Finish vertex providing
+void rlEnd(void)
+{
+    // NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values,
+    // as well as depth buffer bit-depth (16bit or 24bit or 32bit)
+    // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits)
+    RLGL.currentBatch->currentDepth += (1.0f/20000.0f);
+
+    // Verify internal buffers limits
+    // NOTE: This check is combined with usage of rlCheckRenderBatchLimit()
+    if (RLGL.State.vertexCounter >= (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4 - 4))
+    {
+        // WARNING: If we are between rlPushMatrix() and rlPopMatrix() and we need to force a rlDrawRenderBatch(),
+        // we need to call rlPopMatrix() before to recover *RLGL.State.currentMatrix (RLGL.State.modelview) for the next forced draw call!
+        // If we have multiple matrix pushed, it will require "RLGL.State.stackCounter" pops before launching the draw
+        for (int i = RLGL.State.stackCounter; i >= 0; i--) rlPopMatrix();
+        rlDrawRenderBatch(RLGL.currentBatch);
+    }
+}
+
+// Define one vertex (position)
+// NOTE: Vertex position data is the basic information required for drawing
+void rlVertex3f(float x, float y, float z)
+{
+    float tx = x;
+    float ty = y;
+    float tz = z;
+
+    // Transform provided vector if required
+    if (RLGL.State.transformRequired)
+    {
+        tx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z + RLGL.State.transform.m12;
+        ty = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z + RLGL.State.transform.m13;
+        tz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z + RLGL.State.transform.m14;
+    }
+
+    // Verify that current vertex buffer elements limit has not been reached
+    if (RLGL.State.vertexCounter < (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4))
+    {
+        // Add vertices
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter] = tx;
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 1] = ty;
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 2] = tz;
+
+        // Add current texcoord
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter] = RLGL.State.texcoordx;
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter + 1] = RLGL.State.texcoordy;
+
+        // TODO: Add current normal
+        // By default rlVertexBuffer type does not store normals
+
+        // Add current color
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter] = RLGL.State.colorr;
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 1] = RLGL.State.colorg;
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 2] = RLGL.State.colorb;
+        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 3] = RLGL.State.colora;
+
+        RLGL.State.vertexCounter++;
+
+        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount++;
+    }
+    else TRACELOG(RL_LOG_ERROR, "RLGL: Batch elements overflow");
+}
+
+// Define one vertex (position)
+void rlVertex2f(float x, float y)
+{
+    rlVertex3f(x, y, RLGL.currentBatch->currentDepth);
+}
+
+// Define one vertex (position)
+void rlVertex2i(int x, int y)
+{
+    rlVertex3f((float)x, (float)y, RLGL.currentBatch->currentDepth);
+}
+
+// Define one vertex (texture coordinate)
+// NOTE: Texture coordinates are limited to QUADS only
+void rlTexCoord2f(float x, float y)
+{
+    RLGL.State.texcoordx = x;
+    RLGL.State.texcoordy = y;
+}
+
+// Define one vertex (normal)
+// NOTE: Normals limited to TRIANGLES only?
+void rlNormal3f(float x, float y, float z)
+{
+    RLGL.State.normalx = x;
+    RLGL.State.normaly = y;
+    RLGL.State.normalz = z;
+}
+
+// Define one vertex (color)
+void rlColor4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w)
+{
+    RLGL.State.colorr = x;
+    RLGL.State.colorg = y;
+    RLGL.State.colorb = z;
+    RLGL.State.colora = w;
+}
+
+// Define one vertex (color)
+void rlColor4f(float r, float g, float b, float a)
+{
+    rlColor4ub((unsigned char)(r*255), (unsigned char)(g*255), (unsigned char)(b*255), (unsigned char)(a*255));
+}
+
+// Define one vertex (color)
+void rlColor3f(float x, float y, float z)
+{
+    rlColor4ub((unsigned char)(x*255), (unsigned char)(y*255), (unsigned char)(z*255), 255);
+}
+
+#endif
+
+//--------------------------------------------------------------------------------------
+// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2)
+//--------------------------------------------------------------------------------------
+
+// Set current texture to use
+void rlSetTexture(unsigned int id)
+{
+    if (id == 0)
+    {
+#if defined(GRAPHICS_API_OPENGL_11)
+        rlDisableTexture();
+#else
+        // NOTE: If quads batch limit is reached, we force a draw call and next batch starts
+        if (RLGL.State.vertexCounter >=
+            RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4)
+        {
+            rlDrawRenderBatch(RLGL.currentBatch);
+        }
+#endif
+    }
+    else
+    {
+#if defined(GRAPHICS_API_OPENGL_11)
+        rlEnableTexture(id);
+#else
+        if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId != id)
+        {
+            if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
+            {
+                // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
+                // that way, following QUADS drawing will keep aligned with index processing
+                // It implies adding some extra alignment vertex at the end of the draw,
+                // those vertex are not processed but they are considered as an additional offset
+                // for the next set of vertex to be drawn
+                if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4);
+                else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4)));
+                else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0;
+
+                if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
+                {
+                    RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
+
+                    RLGL.currentBatch->drawCounter++;
+                }
+            }
+
+            if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
+
+            RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = id;
+            RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0;
+        }
+#endif
+    }
+}
+
+// Select and active a texture slot
+void rlActiveTextureSlot(int slot)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glActiveTexture(GL_TEXTURE0 + slot);
+#endif
+}
+
+// Enable texture
+void rlEnableTexture(unsigned int id)
+{
+#if defined(GRAPHICS_API_OPENGL_11)
+    glEnable(GL_TEXTURE_2D);
+#endif
+    glBindTexture(GL_TEXTURE_2D, id);
+}
+
+// Disable texture
+void rlDisableTexture(void)
+{
+#if defined(GRAPHICS_API_OPENGL_11)
+    glDisable(GL_TEXTURE_2D);
+#endif
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+// Enable texture cubemap
+void rlEnableTextureCubemap(unsigned int id)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindTexture(GL_TEXTURE_CUBE_MAP, id);
+#endif
+}
+
+// Disable texture cubemap
+void rlDisableTextureCubemap(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
+#endif
+}
+
+// Set texture parameters (wrap mode/filter mode)
+void rlTextureParameters(unsigned int id, int param, int value)
+{
+    glBindTexture(GL_TEXTURE_2D, id);
+    
+#if !defined(GRAPHICS_API_OPENGL_11)
+    // Reset anisotropy filter, in case it was set
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
+#endif
+
+    switch (param)
+    {
+        case RL_TEXTURE_WRAP_S:
+        case RL_TEXTURE_WRAP_T:
+        {
+            if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP)
+            {
+#if !defined(GRAPHICS_API_OPENGL_11)
+                if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value);
+                else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)");
+#endif
+            }
+            else glTexParameteri(GL_TEXTURE_2D, param, value);
+
+        } break;
+        case RL_TEXTURE_MAG_FILTER:
+        case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break;
+        case RL_TEXTURE_FILTER_ANISOTROPIC:
+        {
+#if !defined(GRAPHICS_API_OPENGL_11)
+            if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
+            else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f)
+            {
+                TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel);
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
+            }
+            else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported");
+#endif
+        } break;
+        default: break;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+// Enable shader program
+void rlEnableShader(unsigned int id)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
+    glUseProgram(id);
+#endif
+}
+
+// Disable shader program
+void rlDisableShader(void)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
+    glUseProgram(0);
+#endif
+}
+
+// Enable rendering to texture (fbo)
+void rlEnableFramebuffer(unsigned int id)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+    glBindFramebuffer(GL_FRAMEBUFFER, id);
+#endif
+}
+
+// Disable rendering to texture
+void rlDisableFramebuffer(void)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+#endif
+}
+
+// Activate multiple draw color buffers
+// NOTE: One color buffer is always active by default
+void rlActiveDrawBuffers(int count)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) && defined(RLGL_RENDER_TEXTURES_HINT))
+    // NOTE: Maximum number of draw buffers supported is implementation dependant,
+    // it can be queried with glGet*() but it must be at least 8
+    //GLint maxDrawBuffers = 0;
+    //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
+
+    if (count > 0)
+    {
+        if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8");
+        else
+        {
+            unsigned int buffers[8] = {
+                GL_COLOR_ATTACHMENT0,
+                GL_COLOR_ATTACHMENT1,
+                GL_COLOR_ATTACHMENT2,
+                GL_COLOR_ATTACHMENT3,
+                GL_COLOR_ATTACHMENT4,
+                GL_COLOR_ATTACHMENT5,
+                GL_COLOR_ATTACHMENT6,
+                GL_COLOR_ATTACHMENT7,
+            };
+
+            glDrawBuffers(count, buffers);
+        }
+    }
+    else TRACELOG(LOG_WARNING, "GL: One color buffer active by default");
+#endif
+}
+
+//----------------------------------------------------------------------------------
+// General render state configuration
+//----------------------------------------------------------------------------------
+
+// Enable color blending
+void rlEnableColorBlend(void) { glEnable(GL_BLEND); }
+
+// Disable color blending
+void rlDisableColorBlend(void) { glDisable(GL_BLEND); }
+
+// Enable depth test
+void rlEnableDepthTest(void) { glEnable(GL_DEPTH_TEST); }
+
+// Disable depth test
+void rlDisableDepthTest(void) { glDisable(GL_DEPTH_TEST); }
+
+// Enable depth write
+void rlEnableDepthMask(void) { glDepthMask(GL_TRUE); }
+
+// Disable depth write
+void rlDisableDepthMask(void) { glDepthMask(GL_FALSE); }
+
+// Enable backface culling
+void rlEnableBackfaceCulling(void) { glEnable(GL_CULL_FACE); }
+
+// Disable backface culling
+void rlDisableBackfaceCulling(void) { glDisable(GL_CULL_FACE); }
+
+// Enable scissor test
+void rlEnableScissorTest(void) { glEnable(GL_SCISSOR_TEST); }
+
+// Disable scissor test
+void rlDisableScissorTest(void) { glDisable(GL_SCISSOR_TEST); }
+
+// Scissor test
+void rlScissor(int x, int y, int width, int height) { glScissor(x, y, width, height); }
+
+// Enable wire mode
+void rlEnableWireMode(void)
+{
+#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+    // NOTE: glPolygonMode() not available on OpenGL ES
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+#endif
+}
+
+// Disable wire mode
+void rlDisableWireMode(void)
+{
+#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+    // NOTE: glPolygonMode() not available on OpenGL ES
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+#endif
+}
+
+// Set the line drawing width
+void rlSetLineWidth(float width) { glLineWidth(width); }
+
+// Get the line drawing width
+float rlGetLineWidth(void)
+{
+    float width = 0;
+    glGetFloatv(GL_LINE_WIDTH, &width);
+    return width;
+}
+
+// Enable line aliasing
+void rlEnableSmoothLines(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11)
+    glEnable(GL_LINE_SMOOTH);
+#endif
+}
+
+// Disable line aliasing
+void rlDisableSmoothLines(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11)
+    glDisable(GL_LINE_SMOOTH);
+#endif
+}
+
+// Enable stereo rendering
+void rlEnableStereoRender(void)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
+    RLGL.State.stereoRender = true;
+#endif
+}
+
+// Disable stereo rendering
+void rlDisableStereoRender(void)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
+    RLGL.State.stereoRender = false;
+#endif
+}
+
+// Check if stereo render is enabled
+bool rlIsStereoRenderEnabled(void)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
+    return RLGL.State.stereoRender;
+#else
+    return false;
+#endif
+}
+
+// Clear color buffer with color
+void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+    // Color values clamp to 0.0f(0) and 1.0f(255)
+    float cr = (float)r/255;
+    float cg = (float)g/255;
+    float cb = (float)b/255;
+    float ca = (float)a/255;
+
+    glClearColor(cr, cg, cb, ca);
+}
+
+// Clear used screen buffers (color and depth)
+void rlClearScreenBuffers(void)
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear used buffers: Color and Depth (Depth is used for 3D)
+    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);     // Stencil buffer not used...
+}
+
+// Check and log OpenGL error codes
+void rlCheckErrors()
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    int check = 1;
+    while (check)
+    {
+        const GLenum err = glGetError();
+        switch (err)
+        {
+            case GL_NO_ERROR: check = 0; break;
+            case 0x0500: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM"); break;
+            case 0x0501: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE"); break;
+            case 0x0502: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION"); break;
+            case 0x0503: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW"); break;
+            case 0x0504: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW"); break;
+            case 0x0505: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY"); break;
+            case 0x0506: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION"); break;
+            default: TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err); break;
+        }
+    }
+#endif
+}
+
+// Set blend mode
+void rlSetBlendMode(int mode)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.State.currentBlendMode != mode)
+    {
+        rlDrawRenderBatch(RLGL.currentBatch);
+
+        switch (mode)
+        {
+            case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
+            case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
+            case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
+            case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
+            case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break;
+            case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
+            case RL_BLEND_CUSTOM:
+            {
+                // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
+                glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation);
+            } break;
+            default: break;
+        }
+
+        RLGL.State.currentBlendMode = mode;
+    }
+#endif
+}
+
+// Set blending mode factor and equation
+void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.glBlendSrcFactor = glSrcFactor;
+    RLGL.State.glBlendDstFactor = glDstFactor;
+    RLGL.State.glBlendEquation = glEquation;
+#endif
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - OpenGL Debug
+//----------------------------------------------------------------------------------
+#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43)
+static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
+{
+    // Ignore non-significant error/warning codes (NVidia drivers)
+    // NOTE: Here there are the details with a sample output:
+    // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low)
+    // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4)
+    //             will use VIDEO memory as the source for buffer object operations. (severity: low)
+    // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium)
+    // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have
+    //             a defined base level and cannot be used for texture mapping. (severity: low)
+    if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204)) return;
+
+    const char *msgSource = NULL;
+    switch (source)
+    {
+        case GL_DEBUG_SOURCE_API: msgSource = "API"; break;
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM: msgSource = "WINDOW_SYSTEM"; break;
+        case GL_DEBUG_SOURCE_SHADER_COMPILER: msgSource = "SHADER_COMPILER"; break;
+        case GL_DEBUG_SOURCE_THIRD_PARTY: msgSource = "THIRD_PARTY"; break;
+        case GL_DEBUG_SOURCE_APPLICATION: msgSource = "APPLICATION"; break;
+        case GL_DEBUG_SOURCE_OTHER: msgSource = "OTHER"; break;
+        default: break;
+    }
+
+    const char *msgType = NULL;
+    switch (type)
+    {
+        case GL_DEBUG_TYPE_ERROR: msgType = "ERROR"; break;
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: msgType = "DEPRECATED_BEHAVIOR"; break;
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: msgType = "UNDEFINED_BEHAVIOR"; break;
+        case GL_DEBUG_TYPE_PORTABILITY: msgType = "PORTABILITY"; break;
+        case GL_DEBUG_TYPE_PERFORMANCE: msgType = "PERFORMANCE"; break;
+        case GL_DEBUG_TYPE_MARKER: msgType = "MARKER"; break;
+        case GL_DEBUG_TYPE_PUSH_GROUP: msgType = "PUSH_GROUP"; break;
+        case GL_DEBUG_TYPE_POP_GROUP: msgType = "POP_GROUP"; break;
+        case GL_DEBUG_TYPE_OTHER: msgType = "OTHER"; break;
+        default: break;
+    }
+
+    const char *msgSeverity = "DEFAULT";
+    switch (severity)
+    {
+        case GL_DEBUG_SEVERITY_LOW: msgSeverity = "LOW"; break;
+        case GL_DEBUG_SEVERITY_MEDIUM: msgSeverity = "MEDIUM"; break;
+        case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break;
+        case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break;
+        default: break;
+    }
+
+    TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message);
+    TRACELOG(LOG_WARNING, "    > Type: %s", msgType);
+    TRACELOG(LOG_WARNING, "    > Source = %s", msgSource);
+    TRACELOG(LOG_WARNING, "    > Severity = %s", msgSeverity);
+}
+#endif
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - rlgl functionality
+//----------------------------------------------------------------------------------
+
+// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states
+void rlglInit(int width, int height)
+{
+    // Enable OpenGL debug context if required
+#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43)
+    if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL))
+    {
+        glDebugMessageCallback(rlDebugMessageCallback, 0);
+        // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); // TODO: Filter message
+
+        // Debug context options:
+        //  - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints
+        //  - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error
+        glEnable(GL_DEBUG_OUTPUT);
+        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+    }
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // Init default white texture
+    unsigned char pixels[4] = { 255, 255, 255, 255 };   // 1 pixel RGBA (4 bytes)
+    RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1);
+
+    if (RLGL.State.defaultTextureId != 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId);
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture");
+
+    // Init default Shader (customized for GL 3.3 and ES2)
+    // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs
+    rlLoadShaderDefault();
+    RLGL.State.currentShaderId = RLGL.State.defaultShaderId;
+    RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs;
+
+    // Init default vertex arrays buffers
+    RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS);
+    RLGL.currentBatch = &RLGL.defaultBatch;
+
+    // Init stack matrices (emulating OpenGL 1.1)
+    for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity();
+
+    // Init internal matrices
+    RLGL.State.transform = rlMatrixIdentity();
+    RLGL.State.projection = rlMatrixIdentity();
+    RLGL.State.modelview = rlMatrixIdentity();
+    RLGL.State.currentMatrix = &RLGL.State.modelview;
+#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+    // Initialize OpenGL default states
+    //----------------------------------------------------------
+    // Init state: Depth test
+    glDepthFunc(GL_LEQUAL);                                 // Type of depth testing to apply
+    glDisable(GL_DEPTH_TEST);                               // Disable depth testing for 2D (only used for 3D)
+
+    // Init state: Blending mode
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);      // Color blending function (how colors are mixed)
+    glEnable(GL_BLEND);                                     // Enable color blending (required to work with transparencies)
+
+    // Init state: Culling
+    // NOTE: All shapes/models triangles are drawn CCW
+    glCullFace(GL_BACK);                                    // Cull the back face (default)
+    glFrontFace(GL_CCW);                                    // Front face are defined counter clockwise (default)
+    glEnable(GL_CULL_FACE);                                 // Enable backface culling
+
+    // Init state: Cubemap seamless
+#if defined(GRAPHICS_API_OPENGL_33)
+    glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);                 // Seamless cubemaps (not supported on OpenGL ES 2.0)
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_11)
+    // Init state: Color hints (deprecated in OpenGL 3.0+)
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Improve quality of color and texture coordinate interpolation
+    glShadeModel(GL_SMOOTH);                                // Smooth shading between vertex (vertex colors interpolation)
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // Store screen size into global variables
+    RLGL.State.framebufferWidth = width;
+    RLGL.State.framebufferHeight = height;
+
+    TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully");
+    //----------------------------------------------------------
+#endif
+
+    // Init state: Color/Depth buffers clear
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);                   // Set clear color (black)
+    glClearDepth(1.0f);                                     // Set clear depth value (default)
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear color and depth buffers (depth buffer required for 3D)
+}
+
+// Vertex Buffer Object deinitialization (memory free)
+void rlglClose(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    rlUnloadRenderBatch(RLGL.defaultBatch);
+
+    rlUnloadShaderDefault();          // Unload default shader
+
+    glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture
+    TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId);
+#endif
+}
+
+// Load OpenGL extensions
+// NOTE: External loader function must be provided
+void rlLoadExtensions(void *loader)
+{
+#if defined(GRAPHICS_API_OPENGL_33)     // Also defined for GRAPHICS_API_OPENGL_21
+    // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions)
+    #if !defined(__APPLE__)
+        if (gladLoadGL((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions");
+        else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully");
+    #endif
+
+    // Get number of supported extensions
+    GLint numExt = 0;
+    glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
+    TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);
+
+#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+    // Get supported extensions list
+    // WARNING: glGetStringi() not available on OpenGL 2.1
+    TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:");
+    for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, "    %s", glGetStringi(GL_EXTENSIONS, i));
+#endif
+
+    // Register supported extensions flags
+    // OpenGL 3.3 extensions supported by default (core)
+    RLGL.ExtSupported.vao = true;
+    RLGL.ExtSupported.instancing = true;
+    RLGL.ExtSupported.texNPOT = true;
+    RLGL.ExtSupported.texFloat32 = true;
+    RLGL.ExtSupported.texDepth = true;
+    RLGL.ExtSupported.maxDepthBits = 32;
+    RLGL.ExtSupported.texAnisoFilter = true;
+    RLGL.ExtSupported.texMirrorClamp = true;
+    #if defined(GRAPHICS_API_OPENGL_43)
+    if (GLAD_GL_ARB_compute_shader) RLGL.ExtSupported.computeShader = true;
+    if (GLAD_GL_ARB_shader_storage_buffer_object) RLGL.ExtSupported.ssbo = true;
+    #endif
+    #if !defined(__APPLE__)
+    // NOTE: With GLAD, we can check if an extension is supported using the GLAD_GL_xxx booleans
+    if (GLAD_GL_EXT_texture_compression_s3tc) RLGL.ExtSupported.texCompDXT = true;  // Texture compression: DXT
+    if (GLAD_GL_ARB_ES3_compatibility) RLGL.ExtSupported.texCompETC2 = true;        // Texture compression: ETC2/EAC
+    #endif
+#endif  // GRAPHICS_API_OPENGL_33
+
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    // Get supported extensions list
+    GLint numExt = 0;
+    const char **extList = RL_MALLOC(512*sizeof(const char *)); // Allocate 512 strings pointers (2 KB)
+    const char *extensions = (const char *)glGetString(GL_EXTENSIONS);  // One big const string
+
+    // NOTE: We have to duplicate string because glGetString() returns a const string
+    int size = strlen(extensions) + 1;      // Get extensions string size in bytes
+    char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char));
+    strcpy(extensionsDup, extensions);
+    extList[numExt] = extensionsDup;
+
+    for (int i = 0; i < size; i++)
+    {
+        if (extensionsDup[i] == ' ')
+        {
+            extensionsDup[i] = '\0';
+            numExt++;
+            extList[numExt] = &extensionsDup[i + 1];
+        }
+    }
+
+    TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);
+
+#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+    TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:");
+    for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, "    %s", extList[i]);
+#endif
+
+    // Check required extensions
+    for (int i = 0; i < numExt; i++)
+    {
+        // Check VAO support
+        // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature
+        if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0)
+        {
+            // The extension is supported by our hardware and driver, try to get related functions pointers
+            // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance...
+            glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glGenVertexArraysOES");
+            glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((rlglLoadProc)loader)("glBindVertexArrayOES");
+            glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glDeleteVertexArraysOES");
+            //glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES");     // NOTE: Fails in WebGL, omitted
+
+            if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL.ExtSupported.vao = true;
+        }
+
+        // Check instanced rendering support
+        if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0)         // Web ANGLE
+        {
+            glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedANGLE");
+            glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedANGLE");
+            glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorANGLE");
+
+            if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true;
+        }
+        else
+        {
+            if ((strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0) &&     // Standard EXT
+                (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0))
+            {
+                glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT");
+                glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT");
+                glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorEXT");
+
+                if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true;
+            }
+        }
+
+        // Check NPOT textures support
+        // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature
+        if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) RLGL.ExtSupported.texNPOT = true;
+
+        // Check texture float support
+        if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL.ExtSupported.texFloat32 = true;
+
+        // Check depth texture support
+        if ((strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) ||
+            (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0)) RLGL.ExtSupported.texDepth = true;
+
+        if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24;
+        if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32;
+
+        // Check texture compression support: DXT
+        if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) ||
+            (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) ||
+            (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL.ExtSupported.texCompDXT = true;
+
+        // Check texture compression support: ETC1
+        if ((strcmp(extList[i], (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) ||
+            (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") == 0)) RLGL.ExtSupported.texCompETC1 = true;
+
+        // Check texture compression support: ETC2/EAC
+        if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0) RLGL.ExtSupported.texCompETC2 = true;
+
+        // Check texture compression support: PVR
+        if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") == 0) RLGL.ExtSupported.texCompPVRT = true;
+
+        // Check texture compression support: ASTC
+        if (strcmp(extList[i], (const char *)"GL_KHR_texture_compression_astc_hdr") == 0) RLGL.ExtSupported.texCompASTC = true;
+
+        // Check anisotropic texture filter support
+        if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") == 0) RLGL.ExtSupported.texAnisoFilter = true;
+
+        // Check clamp mirror wrap mode support
+        if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) RLGL.ExtSupported.texMirrorClamp = true;
+    }
+
+    // Free extensions pointers
+    RL_FREE(extList);
+    RL_FREE(extensionsDup);    // Duplicated string must be deallocated
+#endif  // GRAPHICS_API_OPENGL_ES2
+
+    // Check OpenGL information and capabilities
+    //------------------------------------------------------------------------------
+    // Show current OpenGL and GLSL version
+    TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:");
+    TRACELOG(RL_LOG_INFO, "    > Vendor:   %s", glGetString(GL_VENDOR));
+    TRACELOG(RL_LOG_INFO, "    > Renderer: %s", glGetString(GL_RENDERER));
+    TRACELOG(RL_LOG_INFO, "    > Version:  %s", glGetString(GL_VERSION));
+    TRACELOG(RL_LOG_INFO, "    > GLSL:     %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // NOTE: Anisotropy levels capability is an extension
+    #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
+        #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+    #endif
+    glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel);
+
+#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+    // Show some OpenGL GPU capabilities
+    TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:");
+    GLint capability = 0;
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_TEXTURE_SIZE: %i", capability);
+    glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability);
+    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability);
+    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_VERTEX_ATTRIBS: %i", capability);
+    #if !defined(GRAPHICS_API_OPENGL_ES2)
+    glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability);
+    glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_DRAW_BUFFERS: %i", capability);
+    if (RLGL.ExtSupported.texAnisoFilter) TRACELOG(RL_LOG_INFO, "    GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL.ExtSupported.maxAnisotropyLevel);
+    #endif
+    glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability);
+    GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint));
+    glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats);
+    for (int i = 0; i < capability; i++) TRACELOG(RL_LOG_INFO, "        %s", rlGetCompressedFormatName(compFormats[i]));
+    RL_FREE(compFormats);
+
+#if defined(GRAPHICS_API_OPENGL_43)
+    glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability);
+    glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability);
+    TRACELOG(RL_LOG_INFO, "    GL_MAX_UNIFORM_LOCATIONS: %i", capability);
+#endif  // GRAPHICS_API_OPENGL_43
+#else   // RLGL_SHOW_GL_DETAILS_INFO
+
+    // Show some basic info about GL supported features
+    #if defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.ExtSupported.vao) TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully");
+    else TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported");
+    if (RLGL.ExtSupported.texNPOT) TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported");
+    else TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)");
+    #endif
+    if (RLGL.ExtSupported.texCompDXT) TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported");
+    if (RLGL.ExtSupported.texCompETC1) TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed textures supported");
+    if (RLGL.ExtSupported.texCompETC2) TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported");
+    if (RLGL.ExtSupported.texCompPVRT) TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported");
+    if (RLGL.ExtSupported.texCompASTC) TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported");
+    if (RLGL.ExtSupported.computeShader) TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported");
+    if (RLGL.ExtSupported.ssbo) TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported");
+#endif  // RLGL_SHOW_GL_DETAILS_INFO
+
+#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+}
+
+// Get current OpenGL version
+int rlGetVersion(void)
+{
+    int glVersion = 0;
+#if defined(GRAPHICS_API_OPENGL_11)
+    glVersion = OPENGL_11;
+#endif
+#if defined(GRAPHICS_API_OPENGL_21)
+    #if defined(__APPLE__)
+        glVersion = OPENGL_33;           // NOTE: Force OpenGL 3.3 on OSX
+    #else
+        glVersion = OPENGL_21;
+    #endif
+#elif defined(GRAPHICS_API_OPENGL_33)
+    glVersion = OPENGL_33;
+#endif
+#if defined(GRAPHICS_API_OPENGL_43)
+    glVersion = OPENGL_43;
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    glVersion = OPENGL_ES_20;
+#endif
+    return glVersion;
+}
+
+// Set current framebuffer width
+void rlSetFramebufferWidth(int width)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.framebufferWidth = width;
+#endif
+}
+
+// Set current framebuffer height
+void rlSetFramebufferHeight(int height)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.framebufferHeight = height;
+#endif
+}
+
+// Get default framebuffer width
+int rlGetFramebufferWidth(void)
+{
+    int width = 0;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    width = RLGL.State.framebufferWidth;
+#endif
+    return width;
+}
+
+// Get default framebuffer height
+int rlGetFramebufferHeight(void)
+{
+    int height = 0;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    height = RLGL.State.framebufferHeight;
+#endif
+    return height;
+}
+
+// Get default internal texture (white texture)
+// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
+unsigned int rlGetTextureIdDefault(void)
+{
+    unsigned int id = 0;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    id = RLGL.State.defaultTextureId;
+#endif
+    return id;
+}
+
+// Get default shader id
+unsigned int rlGetShaderIdDefault(void)
+{
+    unsigned int id = 0;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    id = RLGL.State.defaultShaderId;
+#endif
+    return id;
+}
+
+// Get default shader locs
+int *rlGetShaderLocsDefault(void)
+{
+    int *locs = NULL;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    locs = RLGL.State.defaultShaderLocs;
+#endif
+    return locs;
+}
+
+// Render batch management
+//------------------------------------------------------------------------------------------------
+// Load render batch
+rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements)
+{
+    rlRenderBatch batch = { 0 };
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes)
+    //--------------------------------------------------------------------------------------------
+    batch.vertexBuffer = (rlVertexBuffer *)RL_MALLOC(numBuffers*sizeof(rlVertexBuffer));
+
+    for (int i = 0; i < numBuffers; i++)
+    {
+        batch.vertexBuffer[i].elementCount = bufferElements;
+
+        batch.vertexBuffer[i].vertices = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float));        // 3 float by vertex, 4 vertex by quad
+        batch.vertexBuffer[i].texcoords = (float *)RL_MALLOC(bufferElements*2*4*sizeof(float));       // 2 float by texcoord, 4 texcoord by quad
+        batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(bufferElements*4*4*sizeof(unsigned char));   // 4 float by color, 4 colors by quad
+#if defined(GRAPHICS_API_OPENGL_33)
+        batch.vertexBuffer[i].indices = (unsigned int *)RL_MALLOC(bufferElements*6*sizeof(unsigned int));      // 6 int by quad (indices)
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+        batch.vertexBuffer[i].indices = (unsigned short *)RL_MALLOC(bufferElements*6*sizeof(unsigned short));  // 6 int by quad (indices)
+#endif
+
+        for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f;
+        for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f;
+        for (int j = 0; j < (4*4*bufferElements); j++) batch.vertexBuffer[i].colors[j] = 0;
+
+        int k = 0;
+
+        // Indices can be initialized right now
+        for (int j = 0; j < (6*bufferElements); j += 6)
+        {
+            batch.vertexBuffer[i].indices[j] = 4*k;
+            batch.vertexBuffer[i].indices[j + 1] = 4*k + 1;
+            batch.vertexBuffer[i].indices[j + 2] = 4*k + 2;
+            batch.vertexBuffer[i].indices[j + 3] = 4*k;
+            batch.vertexBuffer[i].indices[j + 4] = 4*k + 2;
+            batch.vertexBuffer[i].indices[j + 5] = 4*k + 3;
+
+            k++;
+        }
+
+        RLGL.State.vertexCounter = 0;
+    }
+
+    TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)");
+    //--------------------------------------------------------------------------------------------
+
+    // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs
+    //--------------------------------------------------------------------------------------------
+    for (int i = 0; i < numBuffers; i++)
+    {
+        if (RLGL.ExtSupported.vao)
+        {
+            // Initialize Quads VAO
+            glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId);
+            glBindVertexArray(batch.vertexBuffer[i].vaoId);
+        }
+
+        // Quads - Vertex buffers binding and attributes enable
+        // Vertex position buffer (shader-location = 0)
+        glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]);
+        glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]);
+        glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW);
+        glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]);
+        glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
+
+        // Vertex texcoord buffer (shader-location = 1)
+        glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]);
+        glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]);
+        glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW);
+        glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]);
+        glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
+
+        // Vertex color buffer (shader-location = 3)
+        glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]);
+        glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]);
+        glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW);
+        glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]);
+        glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
+
+        // Fill index buffer
+        glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]);
+#if defined(GRAPHICS_API_OPENGL_33)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(int), batch.vertexBuffer[i].indices, GL_STATIC_DRAW);
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(short), batch.vertexBuffer[i].indices, GL_STATIC_DRAW);
+#endif
+    }
+
+    TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)");
+
+    // Unbind the current VAO
+    if (RLGL.ExtSupported.vao) glBindVertexArray(0);
+    //--------------------------------------------------------------------------------------------
+
+    // Init draw calls tracking system
+    //--------------------------------------------------------------------------------------------
+    batch.draws = (rlDrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall));
+
+    for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
+    {
+        batch.draws[i].mode = RL_QUADS;
+        batch.draws[i].vertexCount = 0;
+        batch.draws[i].vertexAlignment = 0;
+        //batch.draws[i].vaoId = 0;
+        //batch.draws[i].shaderId = 0;
+        batch.draws[i].textureId = RLGL.State.defaultTextureId;
+        //batch.draws[i].RLGL.State.projection = rlMatrixIdentity();
+        //batch.draws[i].RLGL.State.modelview = rlMatrixIdentity();
+    }
+
+    batch.bufferCount = numBuffers;    // Record buffer count
+    batch.drawCounter = 1;             // Reset draws counter
+    batch.currentDepth = -1.0f;         // Reset depth value
+    //--------------------------------------------------------------------------------------------
+#endif
+
+    return batch;
+}
+
+// Unload default internal buffers vertex data from CPU and GPU
+void rlUnloadRenderBatch(rlRenderBatch batch)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // Unbind everything
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+    // Unload all vertex buffers data
+    for (int i = 0; i < batch.bufferCount; i++)
+    {
+        // Unbind VAO attribs data
+        if (RLGL.ExtSupported.vao)
+        {
+            glBindVertexArray(batch.vertexBuffer[i].vaoId);
+            glDisableVertexAttribArray(0);
+            glDisableVertexAttribArray(1);
+            glDisableVertexAttribArray(2);
+            glDisableVertexAttribArray(3);
+            glBindVertexArray(0);
+        }
+
+        // Delete VBOs from GPU (VRAM)
+        glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]);
+        glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]);
+        glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]);
+        glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]);
+
+        // Delete VAOs from GPU (VRAM)
+        if (RLGL.ExtSupported.vao) glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId);
+
+        // Free vertex arrays memory from CPU (RAM)
+        RL_FREE(batch.vertexBuffer[i].vertices);
+        RL_FREE(batch.vertexBuffer[i].texcoords);
+        RL_FREE(batch.vertexBuffer[i].colors);
+        RL_FREE(batch.vertexBuffer[i].indices);
+    }
+
+    // Unload arrays
+    RL_FREE(batch.vertexBuffer);
+    RL_FREE(batch.draws);
+#endif
+}
+
+// Draw render batch
+// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer)
+void rlDrawRenderBatch(rlRenderBatch *batch)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // Update batch vertex buffers
+    //------------------------------------------------------------------------------------------------------------
+    // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0)
+    // TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (change flag required)
+    if (RLGL.State.vertexCounter > 0)
+    {
+        // Activate elements VAO
+        if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
+
+        // Vertex positions buffer
+        glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices);
+        //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW);  // Update all buffer
+
+        // Texture coordinates buffer
+        glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*2*sizeof(float), batch->vertexBuffer[batch->currentBuffer].texcoords);
+        //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer
+
+        // Colors buffer
+        glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors);
+        //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW);    // Update all buffer
+
+        // NOTE: glMapBuffer() causes sync issue.
+        // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job.
+        // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer().
+        // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new
+        // allocated pointer immediately even if GPU is still working with the previous data.
+
+        // Another option: map the buffer object into client's memory
+        // Probably this code could be moved somewhere else...
+        // batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
+        // if (batch->vertexBuffer[batch->currentBuffer].vertices)
+        // {
+            // Update vertex data
+        // }
+        // glUnmapBuffer(GL_ARRAY_BUFFER);
+
+        // Unbind the current VAO
+        if (RLGL.ExtSupported.vao) glBindVertexArray(0);
+    }
+    //------------------------------------------------------------------------------------------------------------
+
+    // Draw batch vertex buffers (considering VR stereo if required)
+    //------------------------------------------------------------------------------------------------------------
+    Matrix matProjection = RLGL.State.projection;
+    Matrix matModelView = RLGL.State.modelview;
+
+    int eyeCount = 1;
+    if (RLGL.State.stereoRender) eyeCount = 2;
+
+    for (int eye = 0; eye < eyeCount; eye++)
+    {
+        if (eyeCount == 2)
+        {
+            // Setup current eye viewport (half screen width)
+            rlViewport(eye*RLGL.State.framebufferWidth/2, 0, RLGL.State.framebufferWidth/2, RLGL.State.framebufferHeight);
+
+            // Set current eye view offset to modelview matrix
+            rlSetMatrixModelview(rlMatrixMultiply(matModelView, RLGL.State.viewOffsetStereo[eye]));
+            // Set current eye projection matrix
+            rlSetMatrixProjection(RLGL.State.projectionStereo[eye]);
+        }
+
+        // Draw buffers
+        if (RLGL.State.vertexCounter > 0)
+        {
+            // Set current shader and upload current MVP matrix
+            glUseProgram(RLGL.State.currentShaderId);
+
+            // Create modelview-projection matrix and upload to shader
+            Matrix matMVP = rlMatrixMultiply(RLGL.State.modelview, RLGL.State.projection);
+            float matMVPfloat[16] = {
+                matMVP.m0, matMVP.m1, matMVP.m2, matMVP.m3,
+                matMVP.m4, matMVP.m5, matMVP.m6, matMVP.m7,
+                matMVP.m8, matMVP.m9, matMVP.m10, matMVP.m11,
+                matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15
+            };
+            glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP], 1, false, matMVPfloat);
+
+            if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
+            else
+            {
+                // Bind vertex attrib: position (shader-location = 0)
+                glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]);
+                glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
+                glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]);
+
+                // Bind vertex attrib: texcoord (shader-location = 1)
+                glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]);
+                glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
+                glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]);
+
+                // Bind vertex attrib: color (shader-location = 3)
+                glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]);
+                glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
+                glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]);
+
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]);
+            }
+
+            // Setup some default shader values
+            glUniform4f(RLGL.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f);
+            glUniform1i(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE], 0);  // Active default sampler2D: texture0
+
+            // Activate additional sampler textures
+            // Those additional textures will be common for all draw calls of the batch
+            for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
+            {
+                if (RLGL.State.activeTextureId[i] > 0)
+                {
+                    glActiveTexture(GL_TEXTURE0 + 1 + i);
+                    glBindTexture(GL_TEXTURE_2D, RLGL.State.activeTextureId[i]);
+                }
+            }
+
+            // Activate default sampler2D texture0 (one texture is always active for default batch shader)
+            // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls
+            glActiveTexture(GL_TEXTURE0);
+
+            for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++)
+            {
+                // Bind current draw call texture, activated as GL_TEXTURE0 and binded to sampler2D texture0 by default
+                glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId);
+
+                if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount);
+                else
+                {
+#if defined(GRAPHICS_API_OPENGL_33)
+                    // We need to define the number of indices to be processed: elementCount*6
+                    // NOTE: The final parameter tells the GPU the offset in bytes from the
+                    // start of the index buffer to the location of the first index to process
+                    glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint)));
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+                    glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_SHORT, (GLvoid *)(vertexOffset/4*6*sizeof(GLushort)));
+#endif
+                }
+
+                vertexOffset += (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment);
+            }
+
+            if (!RLGL.ExtSupported.vao)
+            {
+                glBindBuffer(GL_ARRAY_BUFFER, 0);
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+            }
+
+            glBindTexture(GL_TEXTURE_2D, 0);    // Unbind textures
+        }
+
+        if (RLGL.ExtSupported.vao) glBindVertexArray(0); // Unbind VAO
+
+        glUseProgram(0);    // Unbind shader program
+    }
+
+    // Restore viewport to default measures
+    if (eyeCount == 2) rlViewport(0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight);
+    //------------------------------------------------------------------------------------------------------------
+
+    // Reset batch buffers
+    //------------------------------------------------------------------------------------------------------------
+    // Reset vertex counter for next frame
+    RLGL.State.vertexCounter = 0;
+
+    // Reset depth for next draw
+    batch->currentDepth = -1.0f;
+
+    // Restore projection/modelview matrices
+    RLGL.State.projection = matProjection;
+    RLGL.State.modelview = matModelView;
+
+    // Reset RLGL.currentBatch->draws array
+    for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
+    {
+        batch->draws[i].mode = RL_QUADS;
+        batch->draws[i].vertexCount = 0;
+        batch->draws[i].textureId = RLGL.State.defaultTextureId;
+    }
+
+    // Reset active texture units for next batch
+    for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL.State.activeTextureId[i] = 0;
+
+    // Reset draws counter to one draw for the batch
+    batch->drawCounter = 1;
+    //------------------------------------------------------------------------------------------------------------
+
+    // Change to next buffer in the list (in case of multi-buffering)
+    batch->currentBuffer++;
+    if (batch->currentBuffer >= batch->bufferCount) batch->currentBuffer = 0;
+#endif
+}
+
+// Set the active render batch for rlgl
+void rlSetRenderBatchActive(rlRenderBatch *batch)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    rlDrawRenderBatch(RLGL.currentBatch);
+
+    if (batch != NULL) RLGL.currentBatch = batch;
+    else RLGL.currentBatch = &RLGL.defaultBatch;
+#endif
+}
+
+// Update and draw internal render batch
+void rlDrawRenderBatchActive(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    rlDrawRenderBatch(RLGL.currentBatch);    // NOTE: Stereo rendering is checked inside
+#endif
+}
+
+// Check internal buffer overflow for a given number of vertex
+// and force a rlRenderBatch draw call if required
+bool rlCheckRenderBatchLimit(int vCount)
+{
+    bool overflow = false;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if ((RLGL.State.vertexCounter + vCount) >=
+        (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4))
+    {
+        int currentMode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode;
+        int currentTexture = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId;
+
+        overflow = true;
+        rlDrawRenderBatch(RLGL.currentBatch);    // NOTE: Stereo rendering is checked inside
+
+        // Restore state of last batch so we can continue adding vertices
+        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = currentMode;
+        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = currentTexture;
+    }
+#endif
+
+    return overflow;
+}
+
+// Textures data management
+//-----------------------------------------------------------------------------------------
+// Convert image data to OpenGL texture (returns OpenGL valid Id)
+unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount)
+{
+    glBindTexture(GL_TEXTURE_2D, 0);    // Free any old binding
+
+    unsigned int id = 0;
+
+    // Check texture format support by OpenGL 1.1 (compressed textures not supported)
+#if defined(GRAPHICS_API_OPENGL_11)
+    if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
+    {
+        TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats");
+        return id;
+    }
+#else
+    if ((!RLGL.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) ||
+        (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA)))
+    {
+        TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported");
+        return id;
+    }
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if ((!RLGL.ExtSupported.texCompETC1) && (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB))
+    {
+        TRACELOG(RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported");
+        return id;
+    }
+
+    if ((!RLGL.ExtSupported.texCompETC2) && ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA)))
+    {
+        TRACELOG(RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported");
+        return id;
+    }
+
+    if ((!RLGL.ExtSupported.texCompPVRT) && ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA)))
+    {
+        TRACELOG(RL_LOG_WARNING, "GL: PVRT compressed texture format not supported");
+        return id;
+    }
+
+    if ((!RLGL.ExtSupported.texCompASTC) && ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)))
+    {
+        TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported");
+        return id;
+    }
+#endif
+#endif  // GRAPHICS_API_OPENGL_11
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    glGenTextures(1, &id);              // Generate texture id
+
+    glBindTexture(GL_TEXTURE_2D, id);
+
+    int mipWidth = width;
+    int mipHeight = height;
+    int mipOffset = 0;          // Mipmap data offset
+
+    // Load the different mipmap levels
+    for (int i = 0; i < mipmapCount; i++)
+    {
+        unsigned int mipSize = rlGetPixelDataSize(mipWidth, mipHeight, format);
+
+        unsigned int glInternalFormat, glFormat, glType;
+        rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
+
+        TRACELOGD("TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset);
+
+        if (glInternalFormat != -1)
+        {
+            if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, (unsigned char *)data + mipOffset);
+#if !defined(GRAPHICS_API_OPENGL_11)
+            else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, (unsigned char *)data + mipOffset);
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_33)
+            if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
+            {
+                GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
+                glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
+            }
+            else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
+            {
+#if defined(GRAPHICS_API_OPENGL_21)
+                GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
+#elif defined(GRAPHICS_API_OPENGL_33)
+                GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN };
+#endif
+                glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
+            }
+#endif
+        }
+
+        mipWidth /= 2;
+        mipHeight /= 2;
+        mipOffset += mipSize;
+
+        // Security check for NPOT textures
+        if (mipWidth < 1) mipWidth = 1;
+        if (mipHeight < 1) mipHeight = 1;
+    }
+
+    // Texture parameters configuration
+    // NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used
+    if (RLGL.ExtSupported.texNPOT)
+    {
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);       // Set texture to repeat on x-axis
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);       // Set texture to repeat on y-axis
+    }
+    else
+    {
+        // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work!
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);       // Set texture to clamp on x-axis
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);       // Set texture to clamp on y-axis
+    }
+#else
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);       // Set texture to repeat on x-axis
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);       // Set texture to repeat on y-axis
+#endif
+
+    // Magnification and minification filters
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);  // Alternative: GL_LINEAR
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);  // Alternative: GL_LINEAR
+
+#if defined(GRAPHICS_API_OPENGL_33)
+    if (mipmapCount > 1)
+    {
+        // Activate Trilinear filtering if mipmaps are available
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    }
+#endif
+
+    // At this point we have the texture loaded in GPU and texture parameters configured
+
+    // NOTE: If mipmaps were not in data, they are not generated automatically
+
+    // Unbind current texture
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", id, width, height, rlGetPixelFormatName(format), mipmapCount);
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture");
+
+    return id;
+}
+
+// Load depth texture/renderbuffer (to be attached to fbo)
+// WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture/WEBGL_depth_texture extensions
+unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer)
+{
+    unsigned int id = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // In case depth textures not supported, we force renderbuffer usage
+    if (!RLGL.ExtSupported.texDepth) useRenderBuffer = true;
+
+    // NOTE: We let the implementation to choose the best bit-depth
+    // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F
+    unsigned int glInternalFormat = GL_DEPTH_COMPONENT;
+
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES;
+    else if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES;
+    else glInternalFormat = GL_DEPTH_COMPONENT16;
+#endif
+
+    if (!useRenderBuffer && RLGL.ExtSupported.texDepth)
+    {
+        glGenTextures(1, &id);
+        glBindTexture(GL_TEXTURE_2D, id);
+        glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+        TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully");
+    }
+    else
+    {
+        // Create the renderbuffer that will serve as the depth attachment for the framebuffer
+        // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices
+        glGenRenderbuffers(1, &id);
+        glBindRenderbuffer(GL_RENDERBUFFER, id);
+        glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height);
+
+        glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+        TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL.ExtSupported.maxDepthBits >= 24)? RLGL.ExtSupported.maxDepthBits : 16);
+    }
+#endif
+
+    return id;
+}
+
+// Load texture cubemap
+// NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other),
+// expected the following convention: +X, -X, +Y, -Y, +Z, -Z
+unsigned int rlLoadTextureCubemap(const void *data, int size, int format)
+{
+    unsigned int id = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    unsigned int dataSize = rlGetPixelDataSize(size, size, format);
+
+    glGenTextures(1, &id);
+    glBindTexture(GL_TEXTURE_CUBE_MAP, id);
+
+    unsigned int glInternalFormat, glFormat, glType;
+    rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
+
+    if (glInternalFormat != -1)
+    {
+        // Load cubemap faces
+        for (unsigned int i = 0; i < 6; i++)
+        {
+            if (data == NULL)
+            {
+                if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
+                {
+                    if (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32)
+                    {
+                        // Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB)
+                        if (RLGL.ExtSupported.texFloat32) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, size, size, 0, GL_RGB, GL_FLOAT, NULL);
+                        else TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
+                    }
+                    else if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32)) TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
+                    else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL);
+                }
+                else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format");
+            }
+            else
+            {
+                if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize);
+                else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, dataSize, (unsigned char *)data + i*dataSize);
+            }
+
+#if defined(GRAPHICS_API_OPENGL_33)
+            if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
+            {
+                GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
+                glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
+            }
+            else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
+            {
+#if defined(GRAPHICS_API_OPENGL_21)
+                GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
+#elif defined(GRAPHICS_API_OPENGL_33)
+                GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN };
+#endif
+                glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
+            }
+#endif
+        }
+    }
+
+    // Set cubemap texture sampling parameters
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+#if defined(GRAPHICS_API_OPENGL_33)
+    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);  // Flag not supported on OpenGL ES 2.0
+#endif
+
+    glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
+#endif
+
+    if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size);
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture");
+
+    return id;
+}
+
+// Update already loaded texture in GPU with new data
+// NOTE: We don't know safely if internal texture format is the expected one...
+void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data)
+{
+    glBindTexture(GL_TEXTURE_2D, id);
+
+    unsigned int glInternalFormat, glFormat, glType;
+    rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
+
+    if ((glInternalFormat != -1) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB))
+    {
+        glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data);
+    }
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format);
+}
+
+// Get OpenGL internal formats and data type from raylib PixelFormat
+void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType)
+{
+    *glInternalFormat = 0;
+    *glFormat = 0;
+    *glType = 0;
+
+    switch (format)
+    {
+    #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2)
+        // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
+        #if !defined(GRAPHICS_API_OPENGL_11)
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break;   // NOTE: Requires extension OES_texture_float
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break;         // NOTE: Requires extension OES_texture_float
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break;    // NOTE: Requires extension OES_texture_float
+        #endif
+    #elif defined(GRAPHICS_API_OPENGL_33)
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break;
+    #endif
+    #if !defined(GRAPHICS_API_OPENGL_11)
+        case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break;
+        case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
+        case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
+        case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
+        case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: if (RLGL.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break;                      // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
+        case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break;               // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
+        case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break;     // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
+        case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break;    // NOTE: Requires PowerVR GPU
+        case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break;  // NOTE: Requires PowerVR GPU
+        case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break;  // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
+        case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break;  // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
+    #endif
+        default: TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break;
+    }
+}
+
+// Unload texture from GPU memory
+void rlUnloadTexture(unsigned int id)
+{
+    glDeleteTextures(1, &id);
+}
+
+// Generate mipmap data for selected texture
+void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps)
+{
+    glBindTexture(GL_TEXTURE_2D, id);
+
+    // Check if texture is power-of-two (POT)
+    bool texIsPOT = false;
+
+    if (((width > 0) && ((width & (width - 1)) == 0)) &&
+        ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true;
+
+#if defined(GRAPHICS_API_OPENGL_11)
+    if (texIsPOT)
+    {
+        // WARNING: Manual mipmap generation only works for RGBA 32bit textures!
+        if (format == RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
+        {
+            // Retrieve texture data from VRAM
+            void *texData = rlReadTexturePixels(id, width, height, format);
+
+            // NOTE: Texture data size is reallocated to fit mipmaps data
+            // NOTE: CPU mipmap generation only supports RGBA 32bit data
+            int mipmapCount = rlGenTextureMipmapsData(texData, width, height);
+
+            int size = width*height*4;
+            int offset = size;
+
+            int mipWidth = width/2;
+            int mipHeight = height/2;
+
+            // Load the mipmaps
+            for (int level = 1; level < mipmapCount; level++)
+            {
+                glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA8, mipWidth, mipHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, (unsigned char *)texData + offset);
+
+                size = mipWidth*mipHeight*4;
+                offset += size;
+
+                mipWidth /= 2;
+                mipHeight /= 2;
+            }
+
+            *mipmaps = mipmapCount + 1;
+            RL_FREE(texData); // Once mipmaps have been generated and data has been uploaded to GPU VRAM, we can discard RAM data
+
+            TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Mipmaps generated manually on CPU side, total: %i", id, *mipmaps);
+        }
+        else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps for provided texture format", id);
+    }
+#endif
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if ((texIsPOT) || (RLGL.ExtSupported.texNPOT))
+    {
+        //glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);   // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE
+        glGenerateMipmap(GL_TEXTURE_2D);    // Generate mipmaps automatically
+
+        #define MIN(a,b) (((a)<(b))? (a):(b))
+        #define MAX(a,b) (((a)>(b))? (a):(b))
+
+        *mipmaps = 1 + (int)floor(log(MAX(width, height))/log(2));
+        TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps);
+    }
+#endif
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+
+// Read texture pixel data
+void *rlReadTexturePixels(unsigned int id, int width, int height, int format)
+{
+    void *pixels = NULL;
+
+#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+    glBindTexture(GL_TEXTURE_2D, id);
+
+    // NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0)
+    // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE
+    //int width, height, format;
+    //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
+    //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
+    //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format);
+
+    // NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding.
+    // Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting.
+    // GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.)
+    // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.)
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    unsigned int glInternalFormat, glFormat, glType;
+    rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
+    unsigned int size = rlGetPixelDataSize(width, height, format);
+
+    if ((glInternalFormat != -1) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB))
+    {
+        pixels = RL_MALLOC(size);
+        glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels);
+    }
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+#endif
+
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    // glGetTexImage() is not available on OpenGL ES 2.0
+    // Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id.
+    // Two possible Options:
+    // 1 - Bind texture to color fbo attachment and glReadPixels()
+    // 2 - Create an fbo, activate it, render quad with texture, glReadPixels()
+    // We are using Option 1, just need to care for texture format on retrieval
+    // NOTE: This behaviour could be conditioned by graphic driver...
+    unsigned int fboId = rlLoadFramebuffer(width, height);
+
+    glBindFramebuffer(GL_FRAMEBUFFER, fboId);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    // Attach our texture to FBO
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0);
+
+    // We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
+    pixels = (unsigned char *)RL_MALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8));
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    // Clean up temporal fbo
+    rlUnloadFramebuffer(fboId);
+#endif
+
+    return pixels;
+}
+
+// Read screen pixel data (color buffer)
+unsigned char *rlReadScreenPixels(int width, int height)
+{
+    unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char));
+
+    // NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
+    // NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly!
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData);
+
+    // Flip image vertically!
+    unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*4*sizeof(unsigned char));
+
+    for (int y = height - 1; y >= 0; y--)
+    {
+        for (int x = 0; x < (width*4); x++)
+        {
+            imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x];  // Flip line
+
+            // Set alpha component value to 255 (no trasparent image retrieval)
+            // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it!
+            if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255;
+        }
+    }
+
+    RL_FREE(screenData);
+
+    return imgData;     // NOTE: image data should be freed
+}
+
+// Framebuffer management (fbo)
+//-----------------------------------------------------------------------------------------
+// Load a framebuffer to be used for rendering
+// NOTE: No textures attached
+unsigned int rlLoadFramebuffer(int width, int height)
+{
+    unsigned int fboId = 0;
+
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+    glGenFramebuffers(1, &fboId);       // Create the framebuffer object
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);   // Unbind any framebuffer
+#endif
+
+    return fboId;
+}
+
+// Attach color buffer texture to an fbo (unloads previous attachment)
+// NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture
+void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+    glBindFramebuffer(GL_FRAMEBUFFER, fboId);
+
+    switch (attachType)
+    {
+        case RL_ATTACHMENT_COLOR_CHANNEL0:
+        case RL_ATTACHMENT_COLOR_CHANNEL1:
+        case RL_ATTACHMENT_COLOR_CHANNEL2:
+        case RL_ATTACHMENT_COLOR_CHANNEL3:
+        case RL_ATTACHMENT_COLOR_CHANNEL4:
+        case RL_ATTACHMENT_COLOR_CHANNEL5:
+        case RL_ATTACHMENT_COLOR_CHANNEL6:
+        case RL_ATTACHMENT_COLOR_CHANNEL7:
+        {
+            if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel);
+            else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId);
+            else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel);
+
+        } break;
+        case RL_ATTACHMENT_DEPTH:
+        {
+            if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel);
+            else if (texType == RL_ATTACHMENT_RENDERBUFFER)  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId);
+
+        } break;
+        case RL_ATTACHMENT_STENCIL:
+        {
+            if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel);
+            else if (texType == RL_ATTACHMENT_RENDERBUFFER)  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId);
+
+        } break;
+        default: break;
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+#endif
+}
+
+// Verify render texture is complete
+bool rlFramebufferComplete(unsigned int id)
+{
+    bool result = false;
+
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+    glBindFramebuffer(GL_FRAMEBUFFER, id);
+
+    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+
+    if (status != GL_FRAMEBUFFER_COMPLETE)
+    {
+        switch (status)
+        {
+            case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break;
+            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break;
+#if defined(GRAPHICS_API_OPENGL_ES2)
+            case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break;
+#endif
+            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break;
+            default: break;
+        }
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    result = (status == GL_FRAMEBUFFER_COMPLETE);
+#endif
+
+    return result;
+}
+
+// Unload framebuffer from GPU memory
+// NOTE: All attached textures/cubemaps/renderbuffers are also deleted
+void rlUnloadFramebuffer(unsigned int id)
+{
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+
+    // Query depth attachment to automatically delete texture/renderbuffer
+    int depthType = 0, depthId = 0;
+    glBindFramebuffer(GL_FRAMEBUFFER, id);   // Bind framebuffer to query depth texture type
+    glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType);
+    glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId);
+
+    unsigned int depthIdU = (unsigned int)depthId;
+    if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU);
+    else if (depthType == GL_RENDERBUFFER) glDeleteTextures(1, &depthIdU);
+
+    // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer,
+    // the texture image is automatically detached from the currently bound framebuffer.
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glDeleteFramebuffers(1, &id);
+
+    TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id);
+#endif
+}
+
+// Vertex data management
+//-----------------------------------------------------------------------------------------
+// Load a new attributes buffer
+unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic)
+{
+    unsigned int id = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glGenBuffers(1, &id);
+    glBindBuffer(GL_ARRAY_BUFFER, id);
+    glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
+#endif
+
+    return id;
+}
+
+// Load a new attributes element buffer
+unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic)
+{
+    unsigned int id = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glGenBuffers(1, &id);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
+#endif
+
+    return id;
+}
+
+// Enable vertex buffer (VBO)
+void rlEnableVertexBuffer(unsigned int id)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindBuffer(GL_ARRAY_BUFFER, id);
+#endif
+}
+
+// Disable vertex buffer (VBO)
+void rlDisableVertexBuffer(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+#endif
+}
+
+// Enable vertex buffer element (VBO element)
+void rlEnableVertexBufferElement(unsigned int id)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
+#endif
+}
+
+// Disable vertex buffer element (VBO element)
+void rlDisableVertexBufferElement(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#endif
+}
+
+// Update vertex buffer with new data
+// NOTE: dataSize and offset must be provided in bytes
+void rlUpdateVertexBuffer(unsigned int id, const void *data, int dataSize, int offset)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindBuffer(GL_ARRAY_BUFFER, id);
+    glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data);
+#endif
+}
+
+// Update vertex buffer elements with new data
+// NOTE: dataSize and offset must be provided in bytes
+void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
+    glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data);
+#endif
+}
+
+// Enable vertex array object (VAO)
+bool rlEnableVertexArray(unsigned int vaoId)
+{
+    bool result = false;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.ExtSupported.vao)
+    {
+        glBindVertexArray(vaoId);
+        result = true;
+    }
+#endif
+    return result;
+}
+
+// Disable vertex array object (VAO)
+void rlDisableVertexArray(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.ExtSupported.vao) glBindVertexArray(0);
+#endif
+}
+
+// Enable vertex attribute index
+void rlEnableVertexAttribute(unsigned int index)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glEnableVertexAttribArray(index);
+#endif
+}
+
+// Disable vertex attribute index
+void rlDisableVertexAttribute(unsigned int index)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glDisableVertexAttribArray(index);
+#endif
+}
+
+// Draw vertex array
+void rlDrawVertexArray(int offset, int count)
+{
+    glDrawArrays(GL_TRIANGLES, offset, count);
+}
+
+// Draw vertex array elements
+void rlDrawVertexArrayElements(int offset, int count, const void *buffer)
+{
+    glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset);
+}
+
+// Draw vertex array instanced
+void rlDrawVertexArrayInstanced(int offset, int count, int instances)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glDrawArraysInstanced(GL_TRIANGLES, 0, count, instances);
+#endif
+}
+
+// Draw vertex array elements instanced
+void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)buffer + offset, instances);
+#endif
+}
+
+#if defined(GRAPHICS_API_OPENGL_11)
+// Enable vertex state pointer
+void rlEnableStatePointer(int vertexAttribType, void *buffer)
+{
+    if (buffer != NULL) glEnableClientState(vertexAttribType);
+    switch (vertexAttribType)
+    {
+        case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break;
+        case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break;
+        case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break;
+        case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break;
+        //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors
+        default: break;
+    }
+}
+
+// Disable vertex state pointer
+void rlDisableStatePointer(int vertexAttribType)
+{
+    glDisableClientState(vertexAttribType);
+}
+#endif
+
+// Load vertex array object (VAO)
+unsigned int rlLoadVertexArray(void)
+{
+    unsigned int vaoId = 0;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.ExtSupported.vao)
+    {
+        glGenVertexArrays(1, &vaoId);
+    }
+#endif
+    return vaoId;
+}
+
+// Set vertex attribute
+void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glVertexAttribPointer(index, compSize, type, normalized, stride, pointer);
+#endif
+}
+
+// Set vertex attribute divisor
+void rlSetVertexAttributeDivisor(unsigned int index, int divisor)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glVertexAttribDivisor(index, divisor);
+#endif
+}
+
+// Unload vertex array object (VAO)
+void rlUnloadVertexArray(unsigned int vaoId)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.ExtSupported.vao)
+    {
+        glBindVertexArray(0);
+        glDeleteVertexArrays(1, &vaoId);
+        TRACELOG(RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId);
+    }
+#endif
+}
+
+// Unload vertex buffer (VBO)
+void rlUnloadVertexBuffer(unsigned int vboId)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glDeleteBuffers(1, &vboId);
+    //TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)");
+#endif
+}
+
+// Shaders management
+//-----------------------------------------------------------------------------------------------
+// Load shader from code strings
+// NOTE: If shader string is NULL, using default vertex/fragment shaders
+unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode)
+{
+    unsigned int id = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    unsigned int vertexShaderId = 0;
+    unsigned int fragmentShaderId = 0;
+
+    // Compile vertex shader (if provided)
+    if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER);
+    // In case no vertex shader was provided or compilation failed, we use default vertex shader
+    if (vertexShaderId == 0) vertexShaderId = RLGL.State.defaultVShaderId;
+
+    // Compile fragment shader (if provided)
+    if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER);
+    // In case no fragment shader was provided or compilation failed, we use default fragment shader
+    if (fragmentShaderId == 0) fragmentShaderId = RLGL.State.defaultFShaderId;
+
+    // In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id
+    if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId;
+    else
+    {
+        // One of or both shader are new, we need to compile a new shader program
+        id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId);
+
+        // We can detach and delete vertex/fragment shaders (if not default ones)
+        // NOTE: We detach shader before deletion to make sure memory is freed
+        if (vertexShaderId != RLGL.State.defaultVShaderId)
+        {
+            glDetachShader(id, vertexShaderId);
+            glDeleteShader(vertexShaderId);
+        }
+        if (fragmentShaderId != RLGL.State.defaultFShaderId)
+        {
+            glDetachShader(id, fragmentShaderId);
+            glDeleteShader(fragmentShaderId);
+        }
+
+        // In case shader program loading failed, we assign default shader
+        if (id == 0)
+        {
+            // In case shader loading fails, we return the default shader
+            TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader");
+            id = RLGL.State.defaultShaderId;
+        }
+        /*
+        else
+        {
+            // Get available shader uniforms
+            // NOTE: This information is useful for debug...
+            int uniformCount = -1;
+            glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount);
+
+            for (int i = 0; i < uniformCount; i++)
+            {
+                int namelen = -1;
+                int num = -1;
+                char name[256] = { 0 };     // Assume no variable names longer than 256
+                GLenum type = GL_ZERO;
+
+                // Get the name of the uniforms
+                glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name);
+
+                name[namelen] = 0;
+                TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
+            }
+        }
+        */
+    }
+#endif
+
+    return id;
+}
+
+// Compile custom shader and return shader id
+unsigned int rlCompileShader(const char *shaderCode, int type)
+{
+    unsigned int shader = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    shader = glCreateShader(type);
+    glShaderSource(shader, 1, &shaderCode, NULL);
+
+    GLint success = 0;
+    glCompileShader(shader);
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+
+    if (success == GL_FALSE)
+    {
+        switch (type)
+        {
+            case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break;
+            case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break;
+            //case GL_GEOMETRY_SHADER:
+        #if defined(GRAPHICS_API_OPENGL_43)
+            case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break;
+        #endif
+            default: break;
+        }
+
+        int maxLength = 0;
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
+
+        if (maxLength > 0)
+        {
+            int length = 0;
+            char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
+            glGetShaderInfoLog(shader, maxLength, &length, log);
+            TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log);
+            RL_FREE(log);
+        }
+    }
+    else
+    {
+        switch (type)
+        {
+            case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break;
+            case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break;
+            //case GL_GEOMETRY_SHADER:
+        #if defined(GRAPHICS_API_OPENGL_43)
+            case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break;
+        #endif
+            default: break;
+        }
+    }
+#endif
+
+    return shader;
+}
+
+// Load custom shader strings and return program id
+unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId)
+{
+    unsigned int program = 0;
+
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    GLint success = 0;
+    program = glCreateProgram();
+
+    glAttachShader(program, vShaderId);
+    glAttachShader(program, fShaderId);
+
+    // NOTE: Default attribute shader locations must be binded before linking
+    glBindAttribLocation(program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION);
+    glBindAttribLocation(program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
+    glBindAttribLocation(program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
+    glBindAttribLocation(program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
+    glBindAttribLocation(program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
+    glBindAttribLocation(program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
+
+    // NOTE: If some attrib name is no found on the shader, it locations becomes -1
+
+    glLinkProgram(program);
+
+    // NOTE: All uniform variables are intitialised to 0 when a program links
+
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+
+    if (success == GL_FALSE)
+    {
+        TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program);
+
+        int maxLength = 0;
+        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
+
+        if (maxLength > 0)
+        {
+            int length = 0;
+            char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
+            glGetProgramInfoLog(program, maxLength, &length, log);
+            TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log);
+            RL_FREE(log);
+        }
+
+        glDeleteProgram(program);
+
+        program = 0;
+    }
+    else
+    {
+        // Get the size of compiled shader program (not available on OpenGL ES 2.0)
+        // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero.
+        //GLint binarySize = 0;
+        //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
+
+        TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program);
+    }
+#endif
+    return program;
+}
+
+// Unload shader program
+void rlUnloadShaderProgram(unsigned int id)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    glDeleteProgram(id);
+
+    TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id);
+#endif
+}
+
+// Get shader location uniform
+int rlGetLocationUniform(unsigned int shaderId, const char *uniformName)
+{
+    int location = -1;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    location = glGetUniformLocation(shaderId, uniformName);
+
+    if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName);
+    else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location);
+#endif
+    return location;
+}
+
+// Get shader location attribute
+int rlGetLocationAttrib(unsigned int shaderId, const char *attribName)
+{
+    int location = -1;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    location = glGetAttribLocation(shaderId, attribName);
+
+    if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName);
+    else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location);
+#endif
+    return location;
+}
+
+// Set shader value uniform
+void rlSetUniform(int locIndex, const void *value, int uniformType, int count)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    switch (uniformType)
+    {
+        case RL_SHADER_UNIFORM_FLOAT: glUniform1fv(locIndex, count, (float *)value); break;
+        case RL_SHADER_UNIFORM_VEC2: glUniform2fv(locIndex, count, (float *)value); break;
+        case RL_SHADER_UNIFORM_VEC3: glUniform3fv(locIndex, count, (float *)value); break;
+        case RL_SHADER_UNIFORM_VEC4: glUniform4fv(locIndex, count, (float *)value); break;
+        case RL_SHADER_UNIFORM_INT: glUniform1iv(locIndex, count, (int *)value); break;
+        case RL_SHADER_UNIFORM_IVEC2: glUniform2iv(locIndex, count, (int *)value); break;
+        case RL_SHADER_UNIFORM_IVEC3: glUniform3iv(locIndex, count, (int *)value); break;
+        case RL_SHADER_UNIFORM_IVEC4: glUniform4iv(locIndex, count, (int *)value); break;
+        case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break;
+        default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized");
+    }
+#endif
+}
+
+// Set shader value attribute
+void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    switch (attribType)
+    {
+        case RL_SHADER_ATTRIB_FLOAT: if (count == 1) glVertexAttrib1fv(locIndex, (float *)value); break;
+        case RL_SHADER_ATTRIB_VEC2: if (count == 2) glVertexAttrib2fv(locIndex, (float *)value); break;
+        case RL_SHADER_ATTRIB_VEC3: if (count == 3) glVertexAttrib3fv(locIndex, (float *)value); break;
+        case RL_SHADER_ATTRIB_VEC4: if (count == 4) glVertexAttrib4fv(locIndex, (float *)value); break;
+        default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized");
+    }
+#endif
+}
+
+// Set shader value uniform matrix
+void rlSetUniformMatrix(int locIndex, Matrix mat)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    float matfloat[16] = {
+        mat.m0, mat.m1, mat.m2, mat.m3,
+        mat.m4, mat.m5, mat.m6, mat.m7,
+        mat.m8, mat.m9, mat.m10, mat.m11,
+        mat.m12, mat.m13, mat.m14, mat.m15
+    };
+    glUniformMatrix4fv(locIndex, 1, false, matfloat);
+#endif
+}
+
+// Set shader value uniform sampler
+void rlSetUniformSampler(int locIndex, unsigned int textureId)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // Check if texture is already active
+    for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) if (RLGL.State.activeTextureId[i] == textureId) return;
+
+    // Register a new active texture for the internal batch system
+    // NOTE: Default texture is always activated as GL_TEXTURE0
+    for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
+    {
+        if (RLGL.State.activeTextureId[i] == 0)
+        {
+            glUniform1i(locIndex, 1 + i);              // Activate new texture unit
+            RLGL.State.activeTextureId[i] = textureId; // Save texture id for binding on drawing
+            break;
+        }
+    }
+#endif
+}
+
+// Set shader currently active (id and locations)
+void rlSetShader(unsigned int id, int *locs)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (RLGL.State.currentShaderId != id)
+    {
+        rlDrawRenderBatch(RLGL.currentBatch);
+        RLGL.State.currentShaderId = id;
+        RLGL.State.currentShaderLocs = locs;
+    }
+#endif
+}
+
+// Load compute shader program
+unsigned int rlLoadComputeShaderProgram(unsigned int shaderId)
+{
+    unsigned int program = 0;
+
+#if defined(GRAPHICS_API_OPENGL_43)
+    GLint success = 0;
+    program = glCreateProgram();
+    glAttachShader(program, shaderId);
+    glLinkProgram(program);
+
+    // NOTE: All uniform variables are intitialised to 0 when a program links
+
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+
+    if (success == GL_FALSE)
+    {
+        TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program);
+
+        int maxLength = 0;
+        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
+
+        if (maxLength > 0)
+        {
+            int length = 0;
+            char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
+            glGetProgramInfoLog(program, maxLength, &length, log);
+            TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log);
+            RL_FREE(log);
+        }
+
+        glDeleteProgram(program);
+
+        program = 0;
+    }
+    else
+    {
+        // Get the size of compiled shader program (not available on OpenGL ES 2.0)
+        // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero.
+        //GLint binarySize = 0;
+        //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
+
+        TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program);
+    }
+#endif
+
+    return program;
+}
+
+// Dispatch compute shader (equivalent to *draw* for graphics pilepine)
+void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    glDispatchCompute(groupX, groupY, groupZ);
+#endif
+}
+
+// Load shader storage buffer object (SSBO)
+unsigned int rlLoadShaderBuffer(unsigned long long size, const void *data, int usageHint)
+{
+    unsigned int ssbo = 0;
+
+#if defined(GRAPHICS_API_OPENGL_43)
+    glGenBuffers(1, &ssbo);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, size, data, usageHint? usageHint : RL_STREAM_COPY);
+    glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 0);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+#endif
+
+    return ssbo;
+}
+
+// Unload shader storage buffer object (SSBO)
+void rlUnloadShaderBuffer(unsigned int ssboId)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    glDeleteBuffers(1, &ssboId);
+#endif
+}
+
+// Update SSBO buffer data
+void rlUpdateShaderBufferElements(unsigned int id, const void *data, unsigned long long dataSize, unsigned long long offset)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
+    glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data);
+#endif
+}
+
+// Get SSBO buffer size
+unsigned long long rlGetShaderBufferSize(unsigned int id)
+{
+    long long size = 0;
+
+#if defined(GRAPHICS_API_OPENGL_43)
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
+    glGetInteger64v(GL_SHADER_STORAGE_BUFFER_SIZE, &size);
+#endif
+
+    return (size > 0)? size : 0;
+}
+
+// Read SSBO buffer data
+void rlReadShaderBufferElements(unsigned int id, void *dest, unsigned long long count, unsigned long long offset)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
+    glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest);
+#endif
+}
+
+// Bind SSBO buffer
+void rlBindShaderBuffer(unsigned int id, unsigned int index)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id);
+#endif
+}
+
+// Copy SSBO buffer data
+void rlCopyBuffersElements(unsigned int destId, unsigned int srcId, unsigned long long destOffset, unsigned long long srcOffset, unsigned long long count)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    glBindBuffer(GL_COPY_READ_BUFFER, srcId);
+    glBindBuffer(GL_COPY_WRITE_BUFFER, destId);
+    glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count);
+#endif
+}
+
+// Bind image texture
+void rlBindImageTexture(unsigned int id, unsigned int index, unsigned int format, int readonly)
+{
+#if defined(GRAPHICS_API_OPENGL_43)
+    unsigned int glInternalFormat = 0, glFormat = 0, glType = 0;
+
+    rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
+    glBindImageTexture(index, id, 0, 0, 0, readonly ? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat);
+#endif
+}
+
+// Matrix state management
+//-----------------------------------------------------------------------------------------
+// Get internal modelview matrix
+Matrix rlGetMatrixModelview(void)
+{
+    Matrix matrix = rlMatrixIdentity();
+#if defined(GRAPHICS_API_OPENGL_11)
+    float mat[16];
+    glGetFloatv(GL_MODELVIEW_MATRIX, mat);
+    matrix.m0 = mat[0];
+    matrix.m1 = mat[1];
+    matrix.m2 = mat[2];
+    matrix.m3 = mat[3];
+    matrix.m4 = mat[4];
+    matrix.m5 = mat[5];
+    matrix.m6 = mat[6];
+    matrix.m7 = mat[7];
+    matrix.m8 = mat[8];
+    matrix.m9 = mat[9];
+    matrix.m10 = mat[10];
+    matrix.m11 = mat[11];
+    matrix.m12 = mat[12];
+    matrix.m13 = mat[13];
+    matrix.m14 = mat[14];
+    matrix.m15 = mat[15];
+#else
+    matrix = RLGL.State.modelview;
+#endif
+    return matrix;
+}
+
+// Get internal projection matrix
+Matrix rlGetMatrixProjection(void)
+{
+#if defined(GRAPHICS_API_OPENGL_11)
+    float mat[16];
+    glGetFloatv(GL_PROJECTION_MATRIX,mat);
+    Matrix m;
+    m.m0 = mat[0];
+    m.m1 = mat[1];
+    m.m2 = mat[2];
+    m.m3 = mat[3];
+    m.m4 = mat[4];
+    m.m5 = mat[5];
+    m.m6 = mat[6];
+    m.m7 = mat[7];
+    m.m8 = mat[8];
+    m.m9 = mat[9];
+    m.m10 = mat[10];
+    m.m11 = mat[11];
+    m.m12 = mat[12];
+    m.m13 = mat[13];
+    m.m14 = mat[14];
+    m.m15 = mat[15];
+    return m;
+#else
+    return RLGL.State.projection;
+#endif
+}
+
+// Get internal accumulated transform matrix
+Matrix rlGetMatrixTransform(void)
+{
+    Matrix mat = rlMatrixIdentity();
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    // TODO: Consider possible transform matrices in the RLGL.State.stack
+    // Is this the right order? or should we start with the first stored matrix instead of the last one?
+    //Matrix matStackTransform = rlMatrixIdentity();
+    //for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform);
+    mat = RLGL.State.transform;
+#endif
+    return mat;
+}
+
+// Get internal projection matrix for stereo render (selected eye)
+RLAPI Matrix rlGetMatrixProjectionStereo(int eye)
+{
+    Matrix mat = rlMatrixIdentity();
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    mat = RLGL.State.projectionStereo[eye];
+#endif
+    return mat;
+}
+
+// Get internal view offset matrix for stereo render (selected eye)
+RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye)
+{
+    Matrix mat = rlMatrixIdentity();
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    mat = RLGL.State.viewOffsetStereo[eye];
+#endif
+    return mat;
+}
+
+// Set a custom modelview matrix (replaces internal modelview matrix)
+void rlSetMatrixModelview(Matrix view)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.modelview = view;
+#endif
+}
+
+// Set a custom projection matrix (replaces internal projection matrix)
+void rlSetMatrixProjection(Matrix projection)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.projection = projection;
+#endif
+}
+
+// Set eyes projection matrices for stereo rendering
+void rlSetMatrixProjectionStereo(Matrix right, Matrix left)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.projectionStereo[0] = right;
+    RLGL.State.projectionStereo[1] = left;
+#endif
+}
+
+// Set eyes view offsets matrices for stereo rendering
+void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    RLGL.State.viewOffsetStereo[0] = right;
+    RLGL.State.viewOffsetStereo[1] = left;
+#endif
+}
+
+// Load and draw a quad in NDC
+void rlLoadDrawQuad(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    unsigned int quadVAO = 0;
+    unsigned int quadVBO = 0;
+
+    float vertices[] = {
+         // Positions         Texcoords
+        -1.0f,  1.0f, 0.0f,   0.0f, 1.0f,
+        -1.0f, -1.0f, 0.0f,   0.0f, 0.0f,
+         1.0f,  1.0f, 0.0f,   1.0f, 1.0f,
+         1.0f, -1.0f, 0.0f,   1.0f, 0.0f,
+    };
+
+    // Gen VAO to contain VBO
+    glGenVertexArrays(1, &quadVAO);
+    glBindVertexArray(quadVAO);
+
+    // Gen and fill vertex buffer (VBO)
+    glGenBuffers(1, &quadVBO);
+    glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);
+
+    // Bind vertex attributes (position, texcoords)
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)0); // Positions
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)(3*sizeof(float))); // Texcoords
+
+    // Draw quad
+    glBindVertexArray(quadVAO);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    glBindVertexArray(0);
+
+    // Delete buffers (VBO and VAO)
+    glDeleteBuffers(1, &quadVBO);
+    glDeleteVertexArrays(1, &quadVAO);
+#endif
+}
+
+// Load and draw a cube in NDC
+void rlLoadDrawCube(void)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    unsigned int cubeVAO = 0;
+    unsigned int cubeVBO = 0;
+
+    float vertices[] = {
+         // Positions          Normals               Texcoords
+        -1.0f, -1.0f, -1.0f,   0.0f,  0.0f, -1.0f,   0.0f, 0.0f,
+         1.0f,  1.0f, -1.0f,   0.0f,  0.0f, -1.0f,   1.0f, 1.0f,
+         1.0f, -1.0f, -1.0f,   0.0f,  0.0f, -1.0f,   1.0f, 0.0f,
+         1.0f,  1.0f, -1.0f,   0.0f,  0.0f, -1.0f,   1.0f, 1.0f,
+        -1.0f, -1.0f, -1.0f,   0.0f,  0.0f, -1.0f,   0.0f, 0.0f,
+        -1.0f,  1.0f, -1.0f,   0.0f,  0.0f, -1.0f,   0.0f, 1.0f,
+        -1.0f, -1.0f,  1.0f,   0.0f,  0.0f,  1.0f,   0.0f, 0.0f,
+         1.0f, -1.0f,  1.0f,   0.0f,  0.0f,  1.0f,   1.0f, 0.0f,
+         1.0f,  1.0f,  1.0f,   0.0f,  0.0f,  1.0f,   1.0f, 1.0f,
+         1.0f,  1.0f,  1.0f,   0.0f,  0.0f,  1.0f,   1.0f, 1.0f,
+        -1.0f,  1.0f,  1.0f,   0.0f,  0.0f,  1.0f,   0.0f, 1.0f,
+        -1.0f, -1.0f,  1.0f,   0.0f,  0.0f,  1.0f,   0.0f, 0.0f,
+        -1.0f,  1.0f,  1.0f,  -1.0f,  0.0f,  0.0f,   1.0f, 0.0f,
+        -1.0f,  1.0f, -1.0f,  -1.0f,  0.0f,  0.0f,   1.0f, 1.0f,
+        -1.0f, -1.0f, -1.0f,  -1.0f,  0.0f,  0.0f,   0.0f, 1.0f,
+        -1.0f, -1.0f, -1.0f,  -1.0f,  0.0f,  0.0f,   0.0f, 1.0f,
+        -1.0f, -1.0f,  1.0f,  -1.0f,  0.0f,  0.0f,   0.0f, 0.0f,
+        -1.0f,  1.0f,  1.0f,  -1.0f,  0.0f,  0.0f,   1.0f, 0.0f,
+         1.0f,  1.0f,  1.0f,   1.0f,  0.0f,  0.0f,   1.0f, 0.0f,
+         1.0f, -1.0f, -1.0f,   1.0f,  0.0f,  0.0f,   0.0f, 1.0f,
+         1.0f,  1.0f, -1.0f,   1.0f,  0.0f,  0.0f,   1.0f, 1.0f,
+         1.0f, -1.0f, -1.0f,   1.0f,  0.0f,  0.0f,   0.0f, 1.0f,
+         1.0f,  1.0f,  1.0f,   1.0f,  0.0f,  0.0f,   1.0f, 0.0f,
+         1.0f, -1.0f,  1.0f,   1.0f,  0.0f,  0.0f,   0.0f, 0.0f,
+        -1.0f, -1.0f, -1.0f,   0.0f, -1.0f,  0.0f,   0.0f, 1.0f,
+         1.0f, -1.0f, -1.0f,   0.0f, -1.0f,  0.0f,   1.0f, 1.0f,
+         1.0f, -1.0f,  1.0f,   0.0f, -1.0f,  0.0f,   1.0f, 0.0f,
+         1.0f, -1.0f,  1.0f,   0.0f, -1.0f,  0.0f,   1.0f, 0.0f,
+        -1.0f, -1.0f,  1.0f,   0.0f, -1.0f,  0.0f,   0.0f, 0.0f,
+        -1.0f, -1.0f, -1.0f,   0.0f, -1.0f,  0.0f,   0.0f, 1.0f,
+        -1.0f,  1.0f, -1.0f,   0.0f,  1.0f,  0.0f,   0.0f, 1.0f,
+         1.0f,  1.0f,  1.0f,   0.0f,  1.0f,  0.0f,   1.0f, 0.0f,
+         1.0f,  1.0f, -1.0f,   0.0f,  1.0f,  0.0f,   1.0f, 1.0f,
+         1.0f,  1.0f,  1.0f,   0.0f,  1.0f,  0.0f,   1.0f, 0.0f,
+        -1.0f,  1.0f, -1.0f,   0.0f,  1.0f,  0.0f,   0.0f, 1.0f,
+        -1.0f,  1.0f,  1.0f,   0.0f,  1.0f,  0.0f,   0.0f, 0.0f
+    };
+
+    // Gen VAO to contain VBO
+    glGenVertexArrays(1, &cubeVAO);
+    glBindVertexArray(cubeVAO);
+
+    // Gen and fill vertex buffer (VBO)
+    glGenBuffers(1, &cubeVBO);
+    glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    // Bind vertex attributes (position, normals, texcoords)
+    glBindVertexArray(cubeVAO);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)0); // Positions
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(3*sizeof(float))); // Normals
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(6*sizeof(float))); // Texcoords
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+
+    // Draw cube
+    glBindVertexArray(cubeVAO);
+    glDrawArrays(GL_TRIANGLES, 0, 36);
+    glBindVertexArray(0);
+
+    // Delete VBO and VAO
+    glDeleteBuffers(1, &cubeVBO);
+    glDeleteVertexArrays(1, &cubeVAO);
+#endif
+}
+
+// Get name string for pixel format
+const char *rlGetPixelFormatName(unsigned int format)
+{
+    switch (format)
+    {
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: return "GRAYSCALE"; break;         // 8 bit per pixel (no alpha)
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: return "GRAY_ALPHA"; break;       // 8*2 bpp (2 channels)
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: return "R5G6B5"; break;               // 16 bpp
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: return "R8G8B8"; break;               // 24 bpp
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: return "R5G5B5A1"; break;           // 16 bpp (1 bit alpha)
+        case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: return "R4G4B4A4"; break;           // 16 bpp (4 bit alpha)
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: return "R8G8B8A8"; break;           // 32 bpp
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32: return "R32"; break;                     // 32 bpp (1 channel - float)
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: return "R32G32B32"; break;         // 32*3 bpp (3 channels - float)
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: return "R32G32B32A32"; break;   // 32*4 bpp (4 channels - float)
+        case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: return "DXT1_RGB"; break;             // 4 bpp (no alpha)
+        case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: return "DXT1_RGBA"; break;           // 4 bpp (1 bit alpha)
+        case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: return "DXT3_RGBA"; break;           // 8 bpp
+        case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: return "DXT5_RGBA"; break;           // 8 bpp
+        case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: return "ETC1_RGB"; break;             // 4 bpp
+        case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: return "ETC2_RGB"; break;             // 4 bpp
+        case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: return "ETC2_RGBA"; break;       // 8 bpp
+        case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: return "PVRT_RGB"; break;             // 4 bpp
+        case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: return "PVRT_RGBA"; break;           // 4 bpp
+        case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA"; break;   // 8 bpp
+        case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: return "ASTC_8x8_RGBA"; break;   // 2 bpp
+        default: return "UNKNOWN"; break;
+    }
+}
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Definition
+//----------------------------------------------------------------------------------
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+// Load default shader (just vertex positioning and texture coloring)
+// NOTE: This shader program is used for internal buffers
+// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
+static void rlLoadShaderDefault(void)
+{
+    RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int));
+
+    // NOTE: All locations must be reseted to -1 (no location)
+    for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1;
+
+    // Vertex shader directly defined, no external file required
+    const char *defaultVShaderCode =
+#if defined(GRAPHICS_API_OPENGL_21)
+    "#version 120                       \n"
+    "attribute vec3 vertexPosition;     \n"
+    "attribute vec2 vertexTexCoord;     \n"
+    "attribute vec4 vertexColor;        \n"
+    "varying vec2 fragTexCoord;         \n"
+    "varying vec4 fragColor;            \n"
+#elif defined(GRAPHICS_API_OPENGL_33)
+    "#version 330                       \n"
+    "in vec3 vertexPosition;            \n"
+    "in vec2 vertexTexCoord;            \n"
+    "in vec4 vertexColor;               \n"
+    "out vec2 fragTexCoord;             \n"
+    "out vec4 fragColor;                \n"
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    "#version 100                       \n"
+    "attribute vec3 vertexPosition;     \n"
+    "attribute vec2 vertexTexCoord;     \n"
+    "attribute vec4 vertexColor;        \n"
+    "varying vec2 fragTexCoord;         \n"
+    "varying vec4 fragColor;            \n"
+#endif
+    "uniform mat4 mvp;                  \n"
+    "void main()                        \n"
+    "{                                  \n"
+    "    fragTexCoord = vertexTexCoord; \n"
+    "    fragColor = vertexColor;       \n"
+    "    gl_Position = mvp*vec4(vertexPosition, 1.0); \n"
+    "}                                  \n";
+
+    // Fragment shader directly defined, no external file required
+    const char *defaultFShaderCode =
+#if defined(GRAPHICS_API_OPENGL_21)
+    "#version 120                       \n"
+    "varying vec2 fragTexCoord;         \n"
+    "varying vec4 fragColor;            \n"
+    "uniform sampler2D texture0;        \n"
+    "uniform vec4 colDiffuse;           \n"
+    "void main()                        \n"
+    "{                                  \n"
+    "    vec4 texelColor = texture2D(texture0, fragTexCoord); \n"
+    "    gl_FragColor = texelColor*colDiffuse*fragColor;      \n"
+    "}                                  \n";
+#elif defined(GRAPHICS_API_OPENGL_33)
+    "#version 330       \n"
+    "in vec2 fragTexCoord;              \n"
+    "in vec4 fragColor;                 \n"
+    "out vec4 finalColor;               \n"
+    "uniform sampler2D texture0;        \n"
+    "uniform vec4 colDiffuse;           \n"
+    "void main()                        \n"
+    "{                                  \n"
+    "    vec4 texelColor = texture(texture0, fragTexCoord);   \n"
+    "    finalColor = texelColor*colDiffuse*fragColor;        \n"
+    "}                                  \n";
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2)
+    "#version 100                       \n"
+    "precision mediump float;           \n"     // Precision required for OpenGL ES2 (WebGL)
+    "varying vec2 fragTexCoord;         \n"
+    "varying vec4 fragColor;            \n"
+    "uniform sampler2D texture0;        \n"
+    "uniform vec4 colDiffuse;           \n"
+    "void main()                        \n"
+    "{                                  \n"
+    "    vec4 texelColor = texture2D(texture0, fragTexCoord); \n"
+    "    gl_FragColor = texelColor*colDiffuse*fragColor;      \n"
+    "}                                  \n";
+#endif
+
+    // NOTE: Compiled vertex/fragment shaders are not deleted,
+    // they are kept for re-use as default shaders in case some shader loading fails
+    RLGL.State.defaultVShaderId = rlCompileShader(defaultVShaderCode, GL_VERTEX_SHADER);     // Compile default vertex shader
+    RLGL.State.defaultFShaderId = rlCompileShader(defaultFShaderCode, GL_FRAGMENT_SHADER);   // Compile default fragment shader
+
+    RLGL.State.defaultShaderId = rlLoadShaderProgram(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId);
+
+    if (RLGL.State.defaultShaderId > 0)
+    {
+        TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId);
+
+        // Set default shader locations: attributes locations
+        RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexPosition");
+        RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexTexCoord");
+        RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexColor");
+
+        // Set default shader locations: uniform locations
+        RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP]  = glGetUniformLocation(RLGL.State.defaultShaderId, "mvp");
+        RLGL.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "colDiffuse");
+        RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "texture0");
+    }
+    else TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL.State.defaultShaderId);
+}
+
+// Unload default shader
+// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
+static void rlUnloadShaderDefault(void)
+{
+    glUseProgram(0);
+
+    glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId);
+    glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId);
+    glDeleteShader(RLGL.State.defaultVShaderId);
+    glDeleteShader(RLGL.State.defaultFShaderId);
+
+    glDeleteProgram(RLGL.State.defaultShaderId);
+
+    RL_FREE(RLGL.State.defaultShaderLocs);
+
+    TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId);
+}
+
+#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+// Get compressed format official GL identifier name
+static char *rlGetCompressedFormatName(int format)
+{
+    switch (format)
+    {
+        // GL_EXT_texture_compression_s3tc
+        case 0x83F0: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; break;
+        case 0x83F1: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; break;
+        case 0x83F2: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; break;
+        case 0x83F3: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; break;
+        // GL_3DFX_texture_compression_FXT1
+        case 0x86B0: return "GL_COMPRESSED_RGB_FXT1_3DFX"; break;
+        case 0x86B1: return "GL_COMPRESSED_RGBA_FXT1_3DFX"; break;
+        // GL_IMG_texture_compression_pvrtc
+        case 0x8C00: return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; break;
+        case 0x8C01: return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; break;
+        case 0x8C02: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; break;
+        case 0x8C03: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; break;
+        // GL_OES_compressed_ETC1_RGB8_texture
+        case 0x8D64: return "GL_ETC1_RGB8_OES"; break;
+        // GL_ARB_texture_compression_rgtc
+        case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1"; break;
+        case 0x8DBC: return "GL_COMPRESSED_SIGNED_RED_RGTC1"; break;
+        case 0x8DBD: return "GL_COMPRESSED_RG_RGTC2"; break;
+        case 0x8DBE: return "GL_COMPRESSED_SIGNED_RG_RGTC2"; break;
+        // GL_ARB_texture_compression_bptc
+        case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; break;
+        case 0x8E8D: return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; break;
+        case 0x8E8E: return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; break;
+        case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; break;
+        // GL_ARB_ES3_compatibility
+        case 0x9274: return "GL_COMPRESSED_RGB8_ETC2"; break;
+        case 0x9275: return "GL_COMPRESSED_SRGB8_ETC2"; break;
+        case 0x9276: return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break;
+        case 0x9277: return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break;
+        case 0x9278: return "GL_COMPRESSED_RGBA8_ETC2_EAC"; break;
+        case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; break;
+        case 0x9270: return "GL_COMPRESSED_R11_EAC"; break;
+        case 0x9271: return "GL_COMPRESSED_SIGNED_R11_EAC"; break;
+        case 0x9272: return "GL_COMPRESSED_RG11_EAC"; break;
+        case 0x9273: return "GL_COMPRESSED_SIGNED_RG11_EAC"; break;
+        // GL_KHR_texture_compression_astc_hdr
+        case 0x93B0: return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; break;
+        case 0x93B1: return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; break;
+        case 0x93B2: return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; break;
+        case 0x93B3: return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; break;
+        case 0x93B4: return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; break;
+        case 0x93B5: return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; break;
+        case 0x93B6: return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; break;
+        case 0x93B7: return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; break;
+        case 0x93B8: return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; break;
+        case 0x93B9: return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; break;
+        case 0x93BA: return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; break;
+        case 0x93BB: return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; break;
+        case 0x93BC: return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; break;
+        case 0x93BD: return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; break;
+        case 0x93D0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; break;
+        case 0x93D1: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; break;
+        case 0x93D2: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; break;
+        case 0x93D3: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; break;
+        case 0x93D4: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; break;
+        case 0x93D5: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; break;
+        case 0x93D6: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; break;
+        case 0x93D7: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; break;
+        case 0x93D8: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; break;
+        case 0x93D9: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; break;
+        case 0x93DA: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; break;
+        case 0x93DB: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; break;
+        case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break;
+        case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break;
+        default: return "GL_COMPRESSED_UNKNOWN"; break;
+    }
+}
+#endif  // RLGL_SHOW_GL_DETAILS_INFO
+
+#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+#if defined(GRAPHICS_API_OPENGL_11)
+// Mipmaps data is generated after image data
+// NOTE: Only works with RGBA (4 bytes) data!
+static int rlGenTextureMipmapsData(unsigned char *data, int baseWidth, int baseHeight)
+{
+    int mipmapCount = 1;                // Required mipmap levels count (including base level)
+    int width = baseWidth;
+    int height = baseHeight;
+    int size = baseWidth*baseHeight*4;  // Size in bytes (will include mipmaps...), RGBA only
+
+    // Count mipmap levels required
+    while ((width != 1) && (height != 1))
+    {
+        width /= 2;
+        height /= 2;
+
+        TRACELOGD("TEXTURE: Next mipmap size: %i x %i", width, height);
+
+        mipmapCount++;
+
+        size += (width*height*4);       // Add mipmap size (in bytes)
+    }
+
+    TRACELOGD("TEXTURE: Total mipmaps required: %i", mipmapCount);
+    TRACELOGD("TEXTURE: Total size of data required: %i", size);
+
+    unsigned char *temp = RL_REALLOC(data, size);
+
+    if (temp != NULL) data = temp;
+    else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to re-allocate required mipmaps memory");
+
+    width = baseWidth;
+    height = baseHeight;
+    size = (width*height*4);    // RGBA: 4 bytes
+
+    // Generate mipmaps
+    // NOTE: Every mipmap data is stored after data (RGBA - 4 bytes)
+    unsigned char *image = (unsigned char *)RL_MALLOC(width*height*4);
+    unsigned char *mipmap = NULL;
+    int offset = 0;
+
+    for (int i = 0; i < size; i += 4)
+    {
+        image[i] = data[i];
+        image[i + 1] = data[i + 1];
+        image[i + 2] = data[i + 2];
+        image[i + 3] = data[i + 3];
+    }
+
+    TRACELOGD("TEXTURE: Mipmap base size (%ix%i)", width, height);
+
+    for (int mip = 1; mip < mipmapCount; mip++)
+    {
+        mipmap = rlGenNextMipmapData(image, width, height);
+
+        offset += (width*height*4); // Size of last mipmap
+
+        width /= 2;
+        height /= 2;
+        size = (width*height*4);    // Mipmap size to store after offset
+
+        // Add mipmap to data
+        for (int i = 0; i < size; i += 4)
+        {
+            data[offset + i] = mipmap[i];
+            data[offset + i + 1] = mipmap[i + 1];
+            data[offset + i + 2] = mipmap[i + 2];
+            data[offset + i + 3] = mipmap[i + 3];
+        }
+
+        RL_FREE(image);
+
+        image = mipmap;
+        mipmap = NULL;
+    }
+
+    RL_FREE(mipmap);       // free mipmap data
+
+    return mipmapCount;
+}
+
+// Manual mipmap generation (basic scaling algorithm)
+static unsigned char *rlGenNextMipmapData(unsigned char *srcData, int srcWidth, int srcHeight)
+{
+    int x2 = 0;
+    int y2 = 0;
+    unsigned char prow[4] = { 0 };
+    unsigned char pcol[4] = { 0 };
+
+    int width = srcWidth/2;
+    int height = srcHeight/2;
+
+    unsigned char *mipmap = (unsigned char *)RL_MALLOC(width*height*4);
+
+    // Scaling algorithm works perfectly (box-filter)
+    for (int y = 0; y < height; y++)
+    {
+        y2 = 2*y;
+
+        for (int x = 0; x < width; x++)
+        {
+            x2 = 2*x;
+
+            prow[0] = (srcData[(y2*srcWidth + x2)*4 + 0] + srcData[(y2*srcWidth + x2 + 1)*4 + 0])/2;
+            prow[1] = (srcData[(y2*srcWidth + x2)*4 + 1] + srcData[(y2*srcWidth + x2 + 1)*4 + 1])/2;
+            prow[2] = (srcData[(y2*srcWidth + x2)*4 + 2] + srcData[(y2*srcWidth + x2 + 1)*4 + 2])/2;
+            prow[3] = (srcData[(y2*srcWidth + x2)*4 + 3] + srcData[(y2*srcWidth + x2 + 1)*4 + 3])/2;
+
+            pcol[0] = (srcData[((y2 + 1)*srcWidth + x2)*4 + 0] + srcData[((y2 + 1)*srcWidth + x2 + 1)*4 + 0])/2;
+            pcol[1] = (srcData[((y2 + 1)*srcWidth + x2)*4 + 1] + srcData[((y2 + 1)*srcWidth + x2 + 1)*4 + 1])/2;
+            pcol[2] = (srcData[((y2 + 1)*srcWidth + x2)*4 + 2] + srcData[((y2 + 1)*srcWidth + x2 + 1)*4 + 2])/2;
+            pcol[3] = (srcData[((y2 + 1)*srcWidth + x2)*4 + 3] + srcData[((y2 + 1)*srcWidth + x2 + 1)*4 + 3])/2;
+
+            mipmap[(y*width + x)*4 + 0] = (prow[0] + pcol[0])/2;
+            mipmap[(y*width + x)*4 + 1] = (prow[1] + pcol[1])/2;
+            mipmap[(y*width + x)*4 + 2] = (prow[2] + pcol[2])/2;
+            mipmap[(y*width + x)*4 + 3] = (prow[3] + pcol[3])/2;
+        }
+    }
+
+    TRACELOGD("TEXTURE: Mipmap generated successfully (%ix%i)", width, height);
+
+    return mipmap;
+}
+#endif  // GRAPHICS_API_OPENGL_11
+
+// Get pixel data size in bytes (image or texture)
+// NOTE: Size depends on pixel format
+static int rlGetPixelDataSize(int width, int height, int format)
+{
+    int dataSize = 0;       // Size in bytes
+    int bpp = 0;            // Bits per pixel
+
+    switch (format)
+    {
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5:
+        case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
+        case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
+        case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
+        case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB:
+        case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA:
+        case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB:
+        case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB:
+        case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB:
+        case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
+        case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA:
+        case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA:
+        case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
+        case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
+        case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
+        default: break;
+    }
+
+    dataSize = width*height*bpp/8;  // Total data size in bytes
+
+    // Most compressed formats works on 4x4 blocks,
+    // if texture is smaller, minimum dataSize is 8 or 16
+    if ((width < 4) && (height < 4))
+    {
+        if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8;
+        else if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
+    }
+
+    return dataSize;
+}
+
+// Auxiliar math functions
+
+// Get identity matrix
+static Matrix rlMatrixIdentity(void)
+{
+    Matrix result = {
+        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
+    };
+
+    return result;
+}
+
+// Get two matrix multiplication
+// NOTE: When multiplying matrices... the order matters!
+static Matrix rlMatrixMultiply(Matrix left, Matrix right)
+{
+    Matrix result = { 0 };
+
+    result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
+    result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
+    result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14;
+    result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15;
+    result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12;
+    result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13;
+    result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14;
+    result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15;
+    result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12;
+    result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13;
+    result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14;
+    result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15;
+    result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12;
+    result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13;
+    result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14;
+    result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15;
+
+    return result;
+}
+
+#endif  // RLGL_IMPLEMENTATION
+ rlImGui/raylib/src/rmem.h view
@@ -0,0 +1,788 @@+/**********************************************************************************************
+*
+*   rmem v1.3 - raylib memory pool and objects pool
+*
+*   A quick, efficient, and minimal free list and arena-based allocator
+*
+*   PURPOSE:
+*     - A quicker, efficient memory allocator alternative to 'malloc()' and friends.
+*     - Reduce the possibilities of memory leaks for beginner developers using raylib.
+*     - Being able to flexibly range check memory if necessary.
+*
+*   CONFIGURATION:
+*
+*   #define RMEM_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   DOCUMENTATION:
+*
+*       raylib Wiki: https://github.com/raysan5/raylib/wiki/raylib-memory-pool
+*       Usage example with raylib: https://github.com/raysan5/raylib/issues/1329
+*
+*   CHANGELOG:
+*
+*       v1.0: First version
+*       v1.1: Bug patches for the mempool and addition of object pool
+*       v1.2: Addition of bidirectional arena
+*       v1.3: Several changes:
+*         Pptimizations of allocators
+*         Renamed 'Stack' to 'Arena'
+*         Replaced certain define constants with an anonymous enum
+*         Refactored MemPool to no longer require active or deferred defragging
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2019 Kevin 'Assyrianic' Yonan (@assyrianic) and reviewed by Ramon Santamaria (@raysan5)
+*
+*   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 RMEM_H
+#define RMEM_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
+    #define RMEMAPI __declspec(dllexport)         // We are building library as a Win32 shared library (.dll)
+#elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
+    #define RMEMAPI __declspec(dllimport)         // We are using library as a Win32 shared library (.dll)
+#else
+    #define RMEMAPI   // We are building or using library as a static library (or Linux shared library)
+#endif
+
+#define RMEM_VERSION    "v1.3"    // changelog at bottom of header.
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+enum {
+    MEMPOOL_BUCKET_SIZE = 8,
+    MEMPOOL_BUCKET_BITS = (sizeof(uintptr_t) >> 1) + 1,
+    MEM_SPLIT_THRESHOLD = sizeof(uintptr_t) * 4
+};
+
+// Memory pool node
+typedef struct MemNode MemNode;
+struct MemNode {
+    size_t size;
+    MemNode *next, *prev;
+};
+
+// Freelist implementation
+typedef struct AllocList {
+    MemNode *head, *tail;
+    size_t len;
+} AllocList;
+
+// Arena allocator
+typedef struct Arena {
+    uintptr_t mem, offs;
+    size_t size;
+} Arena;
+
+// Memory pool
+typedef struct MemPool {
+    AllocList large, buckets[MEMPOOL_BUCKET_SIZE];
+    Arena arena;
+} MemPool;
+
+// Object pool
+typedef struct ObjPool {
+    uintptr_t mem, offs;
+    size_t objSize, freeBlocks, memSize;
+} ObjPool;
+
+// Double-ended stack (aka Deque)
+typedef struct BiStack {
+    uintptr_t mem, front, back;
+    size_t size;
+} BiStack;
+
+
+#if defined(__cplusplus)
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Memory Pool
+//------------------------------------------------------------------------------------
+RMEMAPI MemPool CreateMemPool(size_t bytes);
+RMEMAPI MemPool CreateMemPoolFromBuffer(void *buf, size_t bytes);
+RMEMAPI void DestroyMemPool(MemPool *mempool);
+
+RMEMAPI void *MemPoolAlloc(MemPool *mempool, size_t bytes);
+RMEMAPI void *MemPoolRealloc(MemPool *mempool, void *ptr, size_t bytes);
+RMEMAPI void MemPoolFree(MemPool *mempool, void *ptr);
+RMEMAPI void MemPoolCleanUp(MemPool *mempool, void **ptrref);
+RMEMAPI void MemPoolReset(MemPool *mempool);
+RMEMAPI size_t GetMemPoolFreeMemory(const MemPool mempool);
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Object Pool
+//------------------------------------------------------------------------------------
+RMEMAPI ObjPool CreateObjPool(size_t objsize, size_t len);
+RMEMAPI ObjPool CreateObjPoolFromBuffer(void *buf, size_t objsize, size_t len);
+RMEMAPI void DestroyObjPool(ObjPool *objpool);
+
+RMEMAPI void *ObjPoolAlloc(ObjPool *objpool);
+RMEMAPI void ObjPoolFree(ObjPool *objpool, void *ptr);
+RMEMAPI void ObjPoolCleanUp(ObjPool *objpool, void **ptrref);
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Double-Ended Stack
+//------------------------------------------------------------------------------------
+RMEMAPI BiStack CreateBiStack(size_t len);
+RMEMAPI BiStack CreateBiStackFromBuffer(void *buf, size_t len);
+RMEMAPI void DestroyBiStack(BiStack *destack);
+
+RMEMAPI void *BiStackAllocFront(BiStack *destack, size_t len);
+RMEMAPI void *BiStackAllocBack(BiStack *destack, size_t len);
+
+RMEMAPI void BiStackResetFront(BiStack *destack);
+RMEMAPI void BiStackResetBack(BiStack *destack);
+RMEMAPI void BiStackResetAll(BiStack *destack);
+
+RMEMAPI intptr_t BiStackMargins(BiStack destack);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // RMEM_H
+
+/***********************************************************************************
+*
+*   RMEM IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(RMEM_IMPLEMENTATION)
+
+#include <stdlib.h>         // Required for: malloc(), calloc(), free()
+#include <string.h>         // Required for: memset(), memcpy(), memmove()
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+
+// Make sure restrict type qualifier for pointers is defined
+// NOTE: Not supported by C++, it is a C only keyword
+#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) || defined(_MSC_VER)
+    #ifndef restrict
+        #define restrict __restrict
+    #endif
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+// ...
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+static inline size_t __AlignSize(const size_t size, const size_t align)
+{
+    return (size + (align - 1)) & -align;
+}
+
+static MemNode *__SplitMemNode(MemNode *const node, const size_t bytes)
+{
+    uintptr_t n = ( uintptr_t )node;
+    MemNode *const r = ( MemNode* )(n + (node->size - bytes));
+    node->size -= bytes;
+    r->size = bytes;
+    
+    return r;
+}
+
+static void __InsertMemNodeBefore(AllocList *const list, MemNode *const insert, MemNode *const curr)
+{
+    insert->next = curr;
+    
+    if (curr->prev==NULL) list->head = insert;
+    else
+    {
+        insert->prev = curr->prev;
+        curr->prev->next = insert;
+    }
+    
+    curr->prev = insert;
+}
+
+static void __ReplaceMemNode(MemNode *const old, MemNode *const replace)
+{
+    replace->prev = old->prev;
+    replace->next = old->next;
+
+    if (old->prev != NULL) old->prev->next = replace;
+    if (old->next != NULL) old->next->prev = replace;
+}
+
+
+static MemNode *__RemoveMemNode(AllocList *const list, MemNode *const node)
+{
+    if (node->prev != NULL) node->prev->next = node->next;
+    else
+    {
+        list->head = node->next;
+        if (list->head != NULL) list->head->prev = NULL;
+        else list->tail = NULL;
+    }
+
+    if (node->next != NULL) node->next->prev = node->prev;
+    else
+    {
+        list->tail = node->prev;
+        if (list->tail != NULL) list->tail->next = NULL;
+        else list->head = NULL;
+    }
+    
+    list->len--;
+    
+    return node;
+}
+
+static MemNode *__FindMemNode(AllocList *const list, const size_t bytes)
+{
+    for (MemNode *node = list->head; node != NULL; node = node->next)
+    {
+        if (node->size < bytes) continue;
+        
+        // Close in size - reduce fragmentation by not splitting
+        else if (node->size <= bytes + MEM_SPLIT_THRESHOLD) return __RemoveMemNode(list, node);
+        else return __SplitMemNode(node, bytes);
+    }
+    
+    return NULL;
+}
+
+static void __InsertMemNode(MemPool *const mempool, AllocList *const list, MemNode *const node, const bool is_bucket)
+{
+    if (list->head == NULL)
+    {
+        list->head = node;
+        list->len++;
+    }
+    else
+    {
+        for (MemNode *iter = list->head; iter != NULL; iter = iter->next)
+        {
+            if ((uintptr_t)iter == mempool->arena.offs)
+            {
+                mempool->arena.offs += iter->size;
+                __RemoveMemNode(list, iter);
+                iter = list->head;
+                
+                if (iter == NULL)
+                {
+                    list->head = node;    
+                    return;
+                }
+            }
+            
+            const uintptr_t inode = (uintptr_t)node;
+            const uintptr_t iiter = (uintptr_t)iter;
+            const uintptr_t iter_end = iiter + iter->size;
+            const uintptr_t node_end = inode + node->size;
+            
+            if (iter == node) return;
+            else if (iter < node)
+            {
+                // node was coalesced prior.
+                if (iter_end > inode) return;
+                else if ((iter_end == inode) && !is_bucket)
+                {
+                    // if we can coalesce, do so.
+                    iter->size += node->size;
+                    
+                    return;
+                }
+                else if (iter->next == NULL)
+                {
+                    // we reached the end of the free list -> append the node
+                    iter->next = node;
+                    node->prev = iter;
+                    list->len++;
+                    
+                    return;    
+                }
+            }
+            else if (iter > node)
+            {
+                // Address sort, lowest to highest aka ascending order.
+                if (iiter < node_end) return;
+                else if ((iter == list->head) && !is_bucket)
+                {
+                    if (iter_end == inode) iter->size += node->size;
+                    else if (node_end == iiter)
+                    {
+                        node->size += list->head->size;
+                        node->next = list->head->next;
+                        node->prev = NULL;
+                        list->head = node;
+                    }
+                    else
+                    {
+                        node->next = iter;
+                        node->prev = NULL;
+                        iter->prev = node;
+                        list->head = node;
+                        list->len++;
+                    }
+                    
+                    return;
+                }
+                else if ((iter_end == inode) && !is_bucket)
+                {
+                    // if we can coalesce, do so.
+                    iter->size += node->size;
+                    return;
+                }
+                else
+                {
+                    __InsertMemNodeBefore(list, node, iter);
+                    list->len++;
+                    return;
+                }
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Memory Pool
+//----------------------------------------------------------------------------------
+
+MemPool CreateMemPool(const size_t size)
+{
+    MemPool mempool = { 0 };
+
+    if (size == 0) return mempool;
+    else
+    {
+        // Align the mempool size to at least the size of an alloc node.
+        uint8_t *const restrict buf = malloc(size*sizeof *buf);
+        
+        if (buf==NULL) return mempool;
+        else
+        {
+            mempool.arena.size = size;
+            mempool.arena.mem = (uintptr_t)buf;
+            mempool.arena.offs = mempool.arena.mem + mempool.arena.size;
+            
+            return mempool;
+        }
+    }
+}
+
+MemPool CreateMemPoolFromBuffer(void *const restrict buf, const size_t size)
+{
+    MemPool mempool = { 0 };
+    
+    if ((size == 0) || (buf == NULL) || (size <= sizeof(MemNode))) return mempool;
+    else
+    {
+        mempool.arena.size = size;
+        mempool.arena.mem = (uintptr_t)buf;
+        mempool.arena.offs = mempool.arena.mem + mempool.arena.size;
+        
+        return mempool;
+    }
+}
+
+void DestroyMemPool(MemPool *const restrict mempool)
+{
+    if (mempool->arena.mem == 0) return;
+    else
+    {
+        void *const restrict ptr = (void *)mempool->arena.mem;
+        free(ptr);
+        *mempool = (MemPool){ 0 };
+    }
+}
+
+void *MemPoolAlloc(MemPool *const mempool, const size_t size)
+{
+    if ((size == 0) || (size > mempool->arena.size)) return NULL;
+    else
+    {
+        MemNode *new_mem = NULL;
+        const size_t ALLOC_SIZE = __AlignSize(size + sizeof *new_mem, sizeof(intptr_t));
+        const size_t BUCKET_SLOT = (ALLOC_SIZE >> MEMPOOL_BUCKET_BITS) - 1;
+
+        // If the size is small enough, let's check if our buckets has a fitting memory block.
+        if (BUCKET_SLOT < MEMPOOL_BUCKET_SIZE)
+        {
+            new_mem = __FindMemNode(&mempool->buckets[BUCKET_SLOT], ALLOC_SIZE);
+        }
+        else if (mempool->large.head != NULL)
+        {
+            new_mem = __FindMemNode(&mempool->large, ALLOC_SIZE);
+        }
+
+        if (new_mem == NULL)
+        {
+            // not enough memory to support the size!
+            if ((mempool->arena.offs - ALLOC_SIZE) < mempool->arena.mem) return NULL;
+            else
+            {
+                // Couldn't allocate from a freelist, allocate from available mempool.
+                // Subtract allocation size from the mempool.
+                mempool->arena.offs -= ALLOC_SIZE;
+
+                // Use the available mempool space as the new node.
+                new_mem = ( MemNode* )mempool->arena.offs;
+                new_mem->size = ALLOC_SIZE;
+            }
+        }
+
+        // Visual of the allocation block.
+        // --------------
+        // | mem size   | lowest addr of block
+        // | next node  | 12 byte (32-bit) header
+        // | prev node  | 24 byte (64-bit) header
+        // |------------|
+        // |   alloc'd  |
+        // |   memory   |
+        // |   space    | highest addr of block
+        // --------------
+        new_mem->next = new_mem->prev = NULL;
+        uint8_t *const restrict final_mem = (uint8_t *)new_mem + sizeof *new_mem;
+        
+        return memset(final_mem, 0, new_mem->size - sizeof *new_mem);
+    }
+}
+
+void *MemPoolRealloc(MemPool *const restrict mempool, void *const ptr, const size_t size)
+{
+    if (size > mempool->arena.size) return NULL;
+    // NULL ptr should make this work like regular Allocation
+    else if (ptr == NULL) return MemPoolAlloc(mempool, size);
+    else if ((uintptr_t)ptr - sizeof(MemNode) < mempool->arena.mem) return NULL;
+    else
+    {
+        MemNode *const node = (MemNode *)((uint8_t *)ptr - sizeof *node);
+        const size_t NODE_SIZE = sizeof *node;
+        uint8_t *const resized_block = MemPoolAlloc(mempool, size);
+        
+        if (resized_block == NULL) return NULL;
+        else
+        {
+            MemNode *const resized = (MemNode *)(resized_block - sizeof *resized);
+            memmove(resized_block, ptr, (node->size > resized->size)? (resized->size - NODE_SIZE) : (node->size - NODE_SIZE));
+            MemPoolFree(mempool, ptr);
+            
+            return resized_block;
+        }
+    }
+}
+
+void MemPoolFree(MemPool *const restrict mempool, void *const ptr)
+{
+    const uintptr_t p = (uintptr_t)ptr;
+    
+    if ((ptr == NULL) || (p - sizeof(MemNode) < mempool->arena.mem)) return;
+    else
+    {
+        // Behind the actual pointer data is the allocation info.
+        const uintptr_t block = p - sizeof(MemNode);
+        MemNode *const mem_node = ( MemNode* )block;
+        const size_t BUCKET_SLOT = (mem_node->size >> MEMPOOL_BUCKET_BITS) - 1;
+
+        // Make sure the pointer data is valid.
+        if ((block < mempool->arena.offs) ||
+            ((block - mempool->arena.mem) > mempool->arena.size) ||
+            (mem_node->size == 0) ||
+            (mem_node->size > mempool->arena.size)) return;
+        // If the mem_node is right at the arena offs, then merge it back to the arena.
+        else if (block == mempool->arena.offs)
+        {
+            mempool->arena.offs += mem_node->size;
+        }
+        else
+        {
+            // try to place it into bucket or large freelist.
+            struct AllocList *const l = (BUCKET_SLOT < MEMPOOL_BUCKET_SIZE) ? &mempool->buckets[BUCKET_SLOT] : &mempool->large;
+            __InsertMemNode(mempool, l, mem_node, (BUCKET_SLOT < MEMPOOL_BUCKET_SIZE));
+        }
+    }
+}
+
+void MemPoolCleanUp(MemPool *const restrict mempool, void **const ptrref)
+{
+    if ((ptrref == NULL) || (*ptrref == NULL)) return;
+    else
+    {
+        MemPoolFree(mempool, *ptrref);
+        *ptrref = NULL;
+    }
+}
+
+size_t GetMemPoolFreeMemory(const MemPool mempool)
+{
+    size_t total_remaining = mempool.arena.offs - mempool.arena.mem;
+
+    for (MemNode *n = mempool.large.head; n != NULL; n = n->next) total_remaining += n->size;
+
+    for (size_t i = 0; i < MEMPOOL_BUCKET_SIZE; i++) for (MemNode *n = mempool.buckets[i].head; n != NULL; n = n->next) total_remaining += n->size;
+
+    return total_remaining;
+}
+
+void MemPoolReset(MemPool *const mempool)
+{
+    mempool->large.head = mempool->large.tail = NULL;
+    mempool->large.len = 0;
+    
+    for (size_t i = 0; i < MEMPOOL_BUCKET_SIZE; i++)
+    {
+        mempool->buckets[i].head = mempool->buckets[i].tail = NULL;
+        mempool->buckets[i].len = 0;
+    }
+    
+    mempool->arena.offs = mempool->arena.mem + mempool->arena.size;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Object Pool
+//----------------------------------------------------------------------------------
+
+ObjPool CreateObjPool(const size_t objsize, const size_t len)
+{
+    ObjPool objpool = { 0 };
+    
+    if ((len == 0) || (objsize == 0)) return objpool;
+    else
+    {
+        const size_t aligned_size = __AlignSize(objsize, sizeof(size_t));
+        uint8_t *const restrict buf = calloc(len, aligned_size);
+        
+        if (buf == NULL) return objpool;
+        objpool.objSize = aligned_size;
+        objpool.memSize = objpool.freeBlocks = len;
+        objpool.mem = (uintptr_t)buf;
+
+        for (size_t i=0; i<objpool.freeBlocks; i++)
+        {
+            size_t *const restrict index = (size_t *)(objpool.mem + (i*aligned_size));
+            *index = i + 1;
+        }
+
+        objpool.offs = objpool.mem;
+        return objpool;
+    }
+}
+
+ObjPool CreateObjPoolFromBuffer(void *const restrict buf, const size_t objsize, const size_t len)
+{
+    ObjPool objpool = { 0 };
+
+    // If the object size isn't large enough to align to a size_t, then we can't use it
+    const size_t aligned_size = __AlignSize(objsize, sizeof(size_t));
+    
+    if ((buf == NULL) || (len == 0) || (objsize < sizeof(size_t)) || (objsize*len != aligned_size*len)) return objpool;
+    else
+    {
+        objpool.objSize = aligned_size;
+        objpool.memSize = objpool.freeBlocks = len;
+        objpool.mem = (uintptr_t)buf;
+
+        for (size_t i=0; i<objpool.freeBlocks; i++)
+        {
+            size_t *const restrict index = (size_t *)(objpool.mem + (i*aligned_size));
+            *index = i + 1;
+        }
+
+        objpool.offs = objpool.mem;
+        return objpool;
+    }
+}
+
+void DestroyObjPool(ObjPool *const restrict objpool)
+{
+    if (objpool->mem == 0) return;
+    else
+    {
+        void *const restrict ptr = (void *)objpool->mem;
+        free(ptr);
+        
+        *objpool = (ObjPool){ 0 };
+    }
+}
+
+void *ObjPoolAlloc(ObjPool *const objpool)
+{
+    if (objpool->freeBlocks > 0)
+    {
+        // For first allocation, head points to the very first index.
+        // Head = &pool[0];
+        // ret = Head == ret = &pool[0];
+        size_t *const restrict block = (size_t *)objpool->offs;
+        objpool->freeBlocks--;
+
+        // After allocating, we set head to the address of the index that *Head holds.
+        // Head = &pool[*Head * pool.objsize];
+        objpool->offs = (objpool->freeBlocks != 0)? objpool->mem + (*block*objpool->objSize) : 0;
+        
+        return memset(block, 0, objpool->objSize);
+    }
+    else return NULL;
+}
+
+void ObjPoolFree(ObjPool *const restrict objpool, void *const ptr)
+{
+    uintptr_t block = (uintptr_t)ptr;
+    
+    if ((ptr == NULL) || (block < objpool->mem) || (block > objpool->mem + objpool->memSize*objpool->objSize)) return;
+    else
+    {
+        // When we free our pointer, we recycle the pointer space to store the previous index and then we push it as our new head.
+        // *p = index of Head in relation to the buffer;
+        // Head = p;
+        size_t *const restrict index = (size_t *)block;
+        *index = (objpool->offs != 0)? (objpool->offs - objpool->mem)/objpool->objSize : objpool->memSize;
+        objpool->offs = block;
+        objpool->freeBlocks++;
+    }
+}
+
+void ObjPoolCleanUp(ObjPool *const restrict objpool, void **const restrict ptrref)
+{
+    if (ptrref == NULL) return;
+    else
+    {
+        ObjPoolFree(objpool, *ptrref);
+        *ptrref = NULL;
+    }
+}
+
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Double-Ended Stack
+//----------------------------------------------------------------------------------
+
+BiStack CreateBiStack(const size_t len)
+{
+    BiStack destack = { 0 };
+    
+    if (len == 0) return destack;
+
+    uint8_t *const buf = malloc(len*sizeof *buf);
+    if (buf == NULL) return destack;
+    destack.size = len;
+    destack.mem = (uintptr_t)buf;
+    destack.front = destack.mem;
+    destack.back = destack.mem + len;
+    
+    return destack;
+}
+
+BiStack CreateBiStackFromBuffer(void *const buf, const size_t len)
+{
+    BiStack destack = { 0 };
+    
+    if ((len == 0) || (buf == NULL)) return destack;
+    else
+    {
+        destack.size = len;
+        destack.mem = destack.front = (uintptr_t)buf;
+        destack.back = destack.mem + len;
+        
+        return destack;
+    }
+}
+
+void DestroyBiStack(BiStack *const restrict destack)
+{
+    if (destack->mem == 0) return;
+    else
+    {
+        uint8_t *const restrict buf = (uint8_t *)destack->mem;
+        free(buf);
+        *destack = (BiStack){ 0 };
+    }
+}
+
+void *BiStackAllocFront(BiStack *const restrict destack, const size_t len)
+{
+    if (destack->mem == 0) return NULL;
+    else
+    {
+        const size_t ALIGNED_LEN = __AlignSize(len, sizeof(uintptr_t));
+        // front end arena is too high!
+        if (destack->front + ALIGNED_LEN >= destack->back) return NULL;
+        else
+        {
+            uint8_t *const restrict ptr = (uint8_t *)destack->front;
+            destack->front += ALIGNED_LEN;
+            
+            return ptr;
+        }
+    }
+}
+
+void *BiStackAllocBack(BiStack *const restrict destack, const size_t len)
+{
+    if (destack->mem == 0) return NULL;
+    else
+    {
+        const size_t ALIGNED_LEN = __AlignSize(len, sizeof(uintptr_t));
+        // back end arena is too low
+        if (destack->back - ALIGNED_LEN <= destack->front) return NULL;
+        else
+        {
+            destack->back -= ALIGNED_LEN;
+            uint8_t *const restrict ptr = (uint8_t *)destack->back;
+            
+            return ptr;
+        }
+    }
+}
+
+void BiStackResetFront(BiStack *const destack)
+{
+    if (destack->mem == 0) return;
+    else destack->front = destack->mem;
+}
+
+void BiStackResetBack(BiStack *const destack)
+{
+    if (destack->mem == 0) return;
+    else destack->back = destack->mem + destack->size;
+}
+
+void BiStackResetAll(BiStack *const destack)
+{
+    BiStackResetBack(destack);
+    BiStackResetFront(destack);
+}
+
+inline intptr_t BiStackMargins(const BiStack destack)
+{
+    return destack.back - destack.front;
+}
+
+#endif  // RMEM_IMPLEMENTATION
+ rlImGui/raylib/src/utils.h view
@@ -0,0 +1,81 @@+/**********************************************************************************************
+*
+*   raylib.utils - Some common utility functions
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2014-2022 Ramon Santamaria (@raysan5)
+*
+*   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 UTILS_H
+#define UTILS_H
+
+#if defined(PLATFORM_ANDROID)
+    #include <stdio.h>                      // Required for: FILE
+    #include <android/asset_manager.h>      // Required for: AAssetManager
+#endif
+
+#if defined(SUPPORT_TRACELOG)
+    #define TRACELOG(level, ...) TraceLog(level, __VA_ARGS__)
+
+    #if defined(SUPPORT_TRACELOG_DEBUG)
+        #define TRACELOGD(...) TraceLog(LOG_DEBUG, __VA_ARGS__)
+    #else
+        #define TRACELOGD(...) (void)0
+    #endif
+#else
+    #define TRACELOG(level, ...) (void)0
+    #define TRACELOGD(...) (void)0
+#endif
+
+//----------------------------------------------------------------------------------
+// Some basic Defines
+//----------------------------------------------------------------------------------
+#if defined(PLATFORM_ANDROID)
+    #define fopen(name, mode) android_fopen(name, mode)
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+//...
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+// Nop...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+#ifdef __cplusplus
+extern "C" {            // Prevents name mangling of functions
+#endif
+
+#if defined(PLATFORM_ANDROID)
+void InitAssetManager(AAssetManager *manager, const char *dataPath);   // Initialize asset manager from android app
+FILE *android_fopen(const char *fileName, const char *mode);           // Replacement for fopen() -> Read-only!
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UTILS_H
+ rlImGui/rlImGui.cpp view
@@ -0,0 +1,508 @@+/**********************************************************************************************
+*
+*   raylibExtras * Utilities and Shared Components for Raylib
+*
+*   rlImGui * basic ImGui integration
+*
+*   LICENSE: ZLIB
+*
+*   Copyright (c) 2020 Jeffery Myers
+*
+*   Permission is hereby granted, free of charge, to any person obtaining a copy
+*   of this software and associated documentation files (the "Software"), to deal
+*   in the Software without restriction, including without limitation the rights
+*   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+*   copies of the Software, and to permit persons to whom the Software is
+*   furnished to do so, subject to the following conditions:
+*
+*   The above copyright notice and this permission notice shall be included in all
+*   copies or substantial portions of the Software.
+*
+*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+*   SOFTWARE.
+*
+**********************************************************************************************/
+#include "rlImGui.h"
+
+#include "imgui.h"
+#include "raylib.h"
+#include "rlgl.h"
+
+#ifdef PLATFORM_DESKTOP
+#include <GLFW/glfw3.h>
+#endif
+
+#include <math.h>
+
+#ifndef NO_FONT_AWESOME
+#include "extras/FA6FreeSolidFontData.h"
+#endif
+
+static Texture2D FontTexture;
+
+static ImGuiMouseCursor CurrentMouseCursor = ImGuiMouseCursor_COUNT;
+static MouseCursor MouseCursorMap[ImGuiMouseCursor_COUNT];
+
+static const char* rlImGuiGetClipText(void*)
+{
+    return GetClipboardText();
+}
+
+static void rlImGuiSetClipText(void*, const char* text)
+{
+    SetClipboardText(text);
+}
+
+static void rlImGuiNewFrame()
+{
+    ImGuiIO& io = ImGui::GetIO();
+
+    if (IsWindowFullscreen())
+    {
+        int monitor = GetCurrentMonitor();
+        io.DisplaySize.x = float(GetMonitorWidth(monitor));
+        io.DisplaySize.y = float(GetMonitorHeight(monitor));
+    }
+    else
+    {
+        io.DisplaySize.x = float(GetScreenWidth());
+        io.DisplaySize.y = float(GetScreenHeight());
+    }
+
+    int width = int(io.DisplaySize.x), height = int(io.DisplaySize.y);
+#ifdef PLATFORM_DESKTOP
+    glfwGetFramebufferSize(glfwGetCurrentContext(), &width, &height);
+#endif
+    if (width > 0 && height > 0) {
+        io.DisplayFramebufferScale = ImVec2(width / io.DisplaySize.x, height / io.DisplaySize.y);
+    }
+    else {
+        io.DisplayFramebufferScale = ImVec2(1.0f, 1.0f);
+    }
+
+    io.DeltaTime = GetFrameTime();
+
+    io.KeyCtrl = IsKeyDown(KEY_RIGHT_CONTROL) || IsKeyDown(KEY_LEFT_CONTROL);
+    io.KeyShift = IsKeyDown(KEY_RIGHT_SHIFT) || IsKeyDown(KEY_LEFT_SHIFT);
+    io.KeyAlt = IsKeyDown(KEY_RIGHT_ALT) || IsKeyDown(KEY_LEFT_ALT);
+    io.KeySuper = IsKeyDown(KEY_RIGHT_SUPER) || IsKeyDown(KEY_LEFT_SUPER);
+
+    if (io.WantSetMousePos)
+    {
+        SetMousePosition((int)io.MousePos.x, (int)io.MousePos.y);
+    }
+    else
+    {
+        io.MousePos.x = (float)GetMouseX();
+        io.MousePos.y = (float)GetMouseY();
+    }
+
+    io.MouseDown[0] = IsMouseButtonDown(MOUSE_LEFT_BUTTON);
+    io.MouseDown[1] = IsMouseButtonDown(MOUSE_RIGHT_BUTTON);
+    io.MouseDown[2] = IsMouseButtonDown(MOUSE_MIDDLE_BUTTON);
+
+    if (GetMouseWheelMove() > 0)
+        io.MouseWheel += 1;
+    else if (GetMouseWheelMove() < 0)
+        io.MouseWheel -= 1;
+
+    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) == 0)
+    {
+        ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
+        if (imgui_cursor != CurrentMouseCursor || io.MouseDrawCursor)
+        {
+            CurrentMouseCursor = imgui_cursor;
+            if (io.MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None)
+            {
+                HideCursor();
+            }
+            else
+            {
+                ShowCursor();
+
+                if (!(io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange))
+                {
+		    SetMouseCursor((imgui_cursor > -1 && imgui_cursor < ImGuiMouseCursor_COUNT) ? MouseCursorMap[imgui_cursor] : MOUSE_CURSOR_DEFAULT);
+                }
+            }
+        }
+    }
+}
+
+#define FOR_ALL_KEYS(X) \
+    do { \
+    X(KEY_APOSTROPHE); \
+    X(KEY_COMMA); \
+    X(KEY_MINUS); \
+    X(KEY_PERIOD); \
+    X(KEY_SLASH); \
+    X(KEY_ZERO); \
+    X(KEY_ONE); \
+    X(KEY_TWO); \
+    X(KEY_THREE); \
+    X(KEY_FOUR); \
+    X(KEY_FIVE); \
+    X(KEY_SIX); \
+    X(KEY_SEVEN); \
+    X(KEY_EIGHT); \
+    X(KEY_NINE); \
+    X(KEY_SEMICOLON); \
+    X(KEY_EQUAL); \
+    X(KEY_A); \
+    X(KEY_B); \
+    X(KEY_C); \
+    X(KEY_D); \
+    X(KEY_E); \
+    X(KEY_F); \
+    X(KEY_G); \
+    X(KEY_H); \
+    X(KEY_I); \
+    X(KEY_J); \
+    X(KEY_K); \
+    X(KEY_L); \
+    X(KEY_M); \
+    X(KEY_N); \
+    X(KEY_O); \
+    X(KEY_P); \
+    X(KEY_Q); \
+    X(KEY_R); \
+    X(KEY_S); \
+    X(KEY_T); \
+    X(KEY_U); \
+    X(KEY_V); \
+    X(KEY_W); \
+    X(KEY_X); \
+    X(KEY_Y); \
+    X(KEY_Z); \
+    X(KEY_SPACE); \
+    X(KEY_ESCAPE); \
+    X(KEY_ENTER); \
+    X(KEY_TAB); \
+    X(KEY_BACKSPACE); \
+    X(KEY_INSERT); \
+    X(KEY_DELETE); \
+    X(KEY_RIGHT); \
+    X(KEY_LEFT); \
+    X(KEY_DOWN); \
+    X(KEY_UP); \
+    X(KEY_PAGE_UP); \
+    X(KEY_PAGE_DOWN); \
+    X(KEY_HOME); \
+    X(KEY_END); \
+    X(KEY_CAPS_LOCK); \
+    X(KEY_SCROLL_LOCK); \
+    X(KEY_NUM_LOCK); \
+    X(KEY_PRINT_SCREEN); \
+    X(KEY_PAUSE); \
+    X(KEY_F1); \
+    X(KEY_F2); \
+    X(KEY_F3); \
+    X(KEY_F4); \
+    X(KEY_F5); \
+    X(KEY_F6); \
+    X(KEY_F7); \
+    X(KEY_F8); \
+    X(KEY_F9); \
+    X(KEY_F10); \
+    X(KEY_F11); \
+    X(KEY_F12); \
+    X(KEY_LEFT_SHIFT); \
+    X(KEY_LEFT_CONTROL); \
+    X(KEY_LEFT_ALT); \
+    X(KEY_LEFT_SUPER); \
+    X(KEY_RIGHT_SHIFT); \
+    X(KEY_RIGHT_CONTROL); \
+    X(KEY_RIGHT_ALT); \
+    X(KEY_RIGHT_SUPER); \
+    X(KEY_KB_MENU); \
+    X(KEY_LEFT_BRACKET); \
+    X(KEY_BACKSLASH); \
+    X(KEY_RIGHT_BRACKET); \
+    X(KEY_GRAVE); \
+    X(KEY_KP_0); \
+    X(KEY_KP_1); \
+    X(KEY_KP_2); \
+    X(KEY_KP_3); \
+    X(KEY_KP_4); \
+    X(KEY_KP_5); \
+    X(KEY_KP_6); \
+    X(KEY_KP_7); \
+    X(KEY_KP_8); \
+    X(KEY_KP_9); \
+    X(KEY_KP_DECIMAL); \
+    X(KEY_KP_DIVIDE); \
+    X(KEY_KP_MULTIPLY); \
+    X(KEY_KP_SUBTRACT); \
+    X(KEY_KP_ADD); \
+    X(KEY_KP_ENTER); \
+    X(KEY_KP_EQUAL); \
+    } while(0)
+
+#define SET_KEY_DOWN(KEY) io.KeysDown[KEY] = IsKeyDown(KEY)
+
+
+static void rlImGuiEvents()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    FOR_ALL_KEYS(SET_KEY_DOWN);
+
+    unsigned int pressed = GetCharPressed();
+    if (pressed != 0)
+        io.AddInputCharacter(pressed);
+}
+
+static void rlImGuiTriangleVert(ImDrawVert& idx_vert)
+{
+    Color* c;
+    c = (Color*)&idx_vert.col;
+    rlColor4ub(c->r, c->g, c->b, c->a);
+    rlTexCoord2f(idx_vert.uv.x, idx_vert.uv.y);
+    rlVertex2f(idx_vert.pos.x, idx_vert.pos.y);
+}
+
+static void rlImGuiRenderTriangles(unsigned int count, int indexStart, const ImVector<ImDrawIdx>& indexBuffer, const ImVector<ImDrawVert>& vertBuffer, void* texturePtr)
+{
+    if (count < 3)
+        return;
+	
+    Texture* texture = (Texture*)texturePtr;
+
+    unsigned int textureId = (texture == nullptr) ? 0 : texture->id;
+
+    rlBegin(RL_TRIANGLES);
+    rlSetTexture(textureId);
+
+    for (unsigned int i = 0; i <= (count - 3); i += 3)
+    {
+        if(rlCheckRenderBatchLimit(3)) 
+        {
+            rlBegin(RL_TRIANGLES);
+            rlSetTexture(textureId);
+        }
+
+        ImDrawIdx indexA = indexBuffer[indexStart + i];
+        ImDrawIdx indexB = indexBuffer[indexStart + i + 1];
+        ImDrawIdx indexC = indexBuffer[indexStart + i + 2];
+
+        ImDrawVert vertexA = vertBuffer[indexA];
+        ImDrawVert vertexB = vertBuffer[indexB];
+        ImDrawVert vertexC = vertBuffer[indexC];
+
+        rlImGuiTriangleVert(vertexA);
+        rlImGuiTriangleVert(vertexB);
+        rlImGuiTriangleVert(vertexC);
+    }
+    rlEnd();
+}
+
+static void EnableScissor(float x, float y, float width, float height)
+{
+    rlEnableScissorTest();
+    ImGuiIO& io = ImGui::GetIO();
+    rlScissor((int)(x * io.DisplayFramebufferScale.x),
+		int((GetScreenHeight() - (int)(y + height)) * io.DisplayFramebufferScale.y),
+		(int)(width * io.DisplayFramebufferScale.x),
+		(int)(height * io.DisplayFramebufferScale.y));
+}
+
+static void rlRenderData(ImDrawData* data)
+{
+    rlDrawRenderBatchActive();
+    rlDisableBackfaceCulling();
+
+    for (int l = 0; l < data->CmdListsCount; ++l)
+    {
+        const ImDrawList* commandList = data->CmdLists[l];
+
+        for (const auto& cmd : commandList->CmdBuffer)
+        {
+            EnableScissor(cmd.ClipRect.x - data->DisplayPos.x, cmd.ClipRect.y - data->DisplayPos.y, cmd.ClipRect.z - (cmd.ClipRect.x - data->DisplayPos.x), cmd.ClipRect.w - (cmd.ClipRect.y - data->DisplayPos.y));
+            if (cmd.UserCallback != nullptr)
+            {
+                cmd.UserCallback(commandList, &cmd);
+  
+                continue;
+            }
+
+            rlImGuiRenderTriangles(cmd.ElemCount, cmd.IdxOffset, commandList->IdxBuffer, commandList->VtxBuffer, cmd.TextureId);
+            rlDrawRenderBatchActive();
+        }
+    }
+
+    rlSetTexture(0);
+    rlDisableScissorTest();
+    rlEnableBackfaceCulling();
+}
+
+void SetupMouseCursors()
+{
+    MouseCursorMap[ImGuiMouseCursor_Arrow] = MOUSE_CURSOR_ARROW;
+    MouseCursorMap[ImGuiMouseCursor_TextInput] = MOUSE_CURSOR_IBEAM;
+    MouseCursorMap[ImGuiMouseCursor_Hand] = MOUSE_CURSOR_POINTING_HAND;
+    MouseCursorMap[ImGuiMouseCursor_ResizeAll] = MOUSE_CURSOR_RESIZE_ALL;
+    MouseCursorMap[ImGuiMouseCursor_ResizeEW] = MOUSE_CURSOR_RESIZE_EW;
+    MouseCursorMap[ImGuiMouseCursor_ResizeNESW] = MOUSE_CURSOR_RESIZE_NESW;
+    MouseCursorMap[ImGuiMouseCursor_ResizeNS] = MOUSE_CURSOR_RESIZE_NS;
+    MouseCursorMap[ImGuiMouseCursor_ResizeNWSE] = MOUSE_CURSOR_RESIZE_NWSE;
+    MouseCursorMap[ImGuiMouseCursor_NotAllowed] = MOUSE_CURSOR_NOT_ALLOWED;
+}
+
+void rlImGuiBeginInitImGui()
+{
+    ImGui::CreateContext(nullptr);
+}
+
+void rlImGuiEndInitImGui()
+{
+    SetupMouseCursors();
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.BackendPlatformName = "imgui_impl_raylib";
+
+    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;
+
+    io.KeyMap[ImGuiKey_Tab] = KEY_TAB;
+    io.KeyMap[ImGuiKey_LeftArrow] = KEY_LEFT;
+    io.KeyMap[ImGuiKey_RightArrow] = KEY_RIGHT;
+    io.KeyMap[ImGuiKey_UpArrow] = KEY_UP;
+    io.KeyMap[ImGuiKey_DownArrow] = KEY_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = KEY_PAGE_DOWN;
+    io.KeyMap[ImGuiKey_PageDown] = KEY_PAGE_UP;
+    io.KeyMap[ImGuiKey_Home] = KEY_HOME;
+    io.KeyMap[ImGuiKey_End] = KEY_END;
+    io.KeyMap[ImGuiKey_Insert] = KEY_INSERT;
+    io.KeyMap[ImGuiKey_Delete] = KEY_DELETE;
+    io.KeyMap[ImGuiKey_Backspace] = KEY_BACKSPACE;
+    io.KeyMap[ImGuiKey_Space] = KEY_SPACE;
+    io.KeyMap[ImGuiKey_Enter] = KEY_ENTER;
+    io.KeyMap[ImGuiKey_Escape] = KEY_ESCAPE;
+    io.KeyMap[ImGuiKey_KeyPadEnter] = KEY_KP_ENTER;
+    io.KeyMap[ImGuiKey_A] = KEY_A;
+    io.KeyMap[ImGuiKey_C] = KEY_C;
+    io.KeyMap[ImGuiKey_V] = KEY_V;
+    io.KeyMap[ImGuiKey_X] = KEY_X;
+    io.KeyMap[ImGuiKey_Y] = KEY_Y;
+    io.KeyMap[ImGuiKey_Z] = KEY_Z;
+
+    io.MousePos = ImVec2(0, 0);
+
+    io.SetClipboardTextFn = rlImGuiSetClipText;
+    io.GetClipboardTextFn = rlImGuiGetClipText;
+
+    io.ClipboardUserData = nullptr;
+
+
+    rlImGuiReloadFonts();
+}
+
+void rlImGuiSetup(bool dark)
+{
+    rlImGuiBeginInitImGui();
+
+    if (dark)
+        ImGui::StyleColorsDark();
+    else
+        ImGui::StyleColorsLight();
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.Fonts->AddFontDefault();
+
+#ifndef NO_FONT_AWESOME
+    static const ImWchar icons_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
+    ImFontConfig icons_config;
+    icons_config.MergeMode = true;
+    icons_config.PixelSnapH = true;
+    icons_config.FontDataOwnedByAtlas = false;
+    io.Fonts->AddFontFromMemoryCompressedTTF((void*)fa_solid_900_compressed_data, fa_solid_900_compressed_size, FONT_AWESOME_ICON_SIZE, &icons_config, icons_ranges);
+#endif
+
+    rlImGuiEndInitImGui();
+}
+
+void rlImGuiReloadFonts()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    unsigned char* pixels = nullptr;
+
+    int width;
+    int height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height, nullptr);
+    Image image = GenImageColor(width, height, BLANK);
+    memcpy(image.data, pixels, width * height * 4);
+
+    if (FontTexture.id != 0)
+        UnloadTexture(FontTexture);
+
+    FontTexture = LoadTextureFromImage(image);
+    UnloadImage(image);
+    io.Fonts->TexID = &FontTexture;
+}
+
+void rlImGuiBegin()
+{
+    rlImGuiNewFrame();
+    rlImGuiEvents();
+    ImGui::NewFrame();
+}
+
+void rlImGuiEnd()
+{
+    ImGui::Render();
+    rlRenderData(ImGui::GetDrawData());
+}
+
+void rlImGuiShutdown()
+{
+    UnloadTexture(FontTexture);
+
+    ImGui::DestroyContext();
+}
+
+void rlImGuiImage(const Texture *image)
+{
+    ImGui::Image((ImTextureID)image, ImVec2(float(image->width), float(image->height)));
+}
+
+bool rlImGuiImageButton(const Texture *image) {
+    return ImGui::ImageButton((ImTextureID)image, ImVec2(float(image->width), float(image->height)));
+}
+
+void rlImGuiImageSize(const Texture *image, int width, int height)
+{
+    ImGui::Image((ImTextureID)image, ImVec2(float(width), float(height)));
+}
+
+void rlImGuiImageRect(const Texture* image, int destWidth, int destHeight, Rectangle sourceRect)
+{
+    ImVec2 uv0;
+    ImVec2 uv1;
+
+    if (sourceRect.width < 0)
+    {
+        uv0.x = -((float)sourceRect.x / image->width);
+        uv1.x = (uv0.x - (float)(fabs(sourceRect.width) / image->width));
+    }
+    else
+    {
+        uv0.x = (float)sourceRect.x / image->width;
+        uv1.x = uv0.x + (float)(sourceRect.width / image->width);
+    }
+
+    if (sourceRect.height < 0)
+    {
+        uv0.y = -((float)sourceRect.y / image->height);
+        uv1.y = (uv0.y - (float)(fabs(sourceRect.height) / image->height));
+    }
+    else
+    {
+        uv0.y = (float)sourceRect.y / image->height;
+        uv1.y = uv0.y + (float)(sourceRect.height / image->height);
+    }
+
+    ImGui::Image((ImTextureID)image, ImVec2(float(destWidth), float(destHeight)),uv0,uv1);
+}
+ rlImGui/rlImGui.h view
@@ -0,0 +1,63 @@+/**********************************************************************************************
+*
+*   raylibExtras * Utilities and Shared Components for Raylib
+*
+*   rlImGui * basic ImGui integration
+*
+*   LICENSE: ZLIB
+*
+*   Copyright (c) 2020 Jeffery Myers
+*
+*   Permission is hereby granted, free of charge, to any person obtaining a copy
+*   of this software and associated documentation files (the "Software"), to deal
+*   in the Software without restriction, including without limitation the rights
+*   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+*   copies of the Software, and to permit persons to whom the Software is
+*   furnished to do so, subject to the following conditions:
+*
+*   The above copyright notice and this permission notice shall be included in all
+*   copies or substantial portions of the Software.
+*
+*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+*   SOFTWARE.
+*
+**********************************************************************************************/
+
+#pragma once
+
+#include "raylib.h"
+
+#ifndef NO_FONT_AWESOME
+#include "extras/IconsFontAwesome6.h"
+#define FONT_AWESOME_ICON_SIZE 11
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// basic API
+void rlImGuiSetup(bool dark);
+void rlImGuiBegin();
+void rlImGuiEnd();
+void rlImGuiShutdown();
+
+// Advanced StartupAPI
+void rlImGuiBeginInitImGui();
+void rlImGuiEndInitImGui();
+void rlImGuiReloadFonts();
+
+// image API
+void rlImGuiImage(const Texture *image);
+bool rlImGuiImageButton(const Texture *image);
+void rlImGuiImageSize(const Texture *image, int width, int height);
+void rlImGuiImageRect(const Texture* image, int destWidth, int destHeight, Rectangle sourceRect);
+
+#ifdef __cplusplus
+}
+#endif
+ rlImGui/rlImGuiColors.h view
@@ -0,0 +1,42 @@+/**********************************************************************************************
+*
+*   raylibExtras * Utilities and Shared Components for Raylib
+*
+*   rlImGui * basic ImGui integration
+*
+*   LICENSE: ZLIB
+*
+*   Copyright (c) 2020 Jeffery Myers
+*
+*   Permission is hereby granted, free of charge, to any person obtaining a copy
+*   of this software and associated documentation files (the "Software"), to deal
+*   in the Software without restriction, including without limitation the rights
+*   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+*   copies of the Software, and to permit persons to whom the Software is
+*   furnished to do so, subject to the following conditions:
+*
+*   The above copyright notice and this permission notice shall be included in all
+*   copies or substantial portions of the Software.
+*
+*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+*   SOFTWARE.
+*
+**********************************************************************************************/
+
+#pragma once
+
+#include "raylib.h"
+#include "imgui.h"
+
+namespace rlImGuiColors
+{
+    inline ImVec4 Convert(::Color color)
+    {
+        return ImVec4(color.r / 255.0f, color.g / 255.0f, color.b / 255.0f, color.a / 255.0f);
+    }
+}
+ src/Raylib/ImGui.hs view
@@ -0,0 +1,54 @@+module Raylib.ImGui
+  ( rlImGuiSetup,
+    rlImGuiBegin,
+    rlImGuiEnd,
+    rlImGuiShutdown,
+    rlImGuiBeginInitImGui,
+    rlImGuiEndInitImGui,
+    rlImGuiReloadFonts,
+    rlImGuiImage,
+    rlImGuiImageButton,
+    rlImGuiImageSize,
+    rlImGuiImageRect,
+  )
+where
+
+import Foreign (Ptr, with)
+import Raylib.Types (Rectangle, Texture)
+
+-- basic API
+foreign import ccall safe "rlImGui.h rlImGuiSetup" rlImGuiSetup :: Bool -> IO ()
+
+foreign import ccall safe "rlImGui.h rlImGuiBegin" rlImGuiBegin :: IO ()
+
+foreign import ccall safe "rlImGui.h rlImGuiEnd" rlImGuiEnd :: IO ()
+
+foreign import ccall safe "rlImGui.h rlImGuiShutdown" rlImGuiShutdown :: IO ()
+
+-- Advanced StartupAPI
+foreign import ccall safe "rlImGui.h rlImGuiBeginInitImGui" rlImGuiBeginInitImGui :: IO ()
+
+foreign import ccall safe "rlImGui.h rlImGuiEndInitImGui" rlImGuiEndInitImGui :: IO ()
+
+foreign import ccall safe "rlImGui.h rlImGuiReloadFonts" rlImGuiReloadFonts :: IO ()
+
+-- image API
+foreign import ccall safe "rlImGui.h rlImGuiImage" c'rlImGuiImage :: Ptr Texture -> IO ()
+
+foreign import ccall safe "rlImGui.h rlImGuiImageButton" c'rlImGuiImageButton :: Ptr Texture -> IO Bool
+
+foreign import ccall safe "rlImGui.h rlImGuiImageSize" c'rlImGuiImageSize :: Ptr Texture -> Int -> Int -> IO ()
+
+foreign import ccall safe "wrapper.h rlImGuiImageRect_" c'rlImGuiImageRect :: Ptr Texture -> Int -> Int -> Ptr Rectangle -> IO ()
+
+rlImGuiImage :: Texture -> IO ()
+rlImGuiImage texture = with texture c'rlImGuiImage
+
+rlImGuiImageButton :: Texture -> IO Bool
+rlImGuiImageButton texture = with texture c'rlImGuiImageButton
+
+rlImGuiImageSize :: Texture -> Int -> Int -> IO ()
+rlImGuiImageSize texture width height = with texture (\t -> c'rlImGuiImageSize t width height)
+
+rlImGuiImageRect :: Texture -> Int -> Int -> Rectangle -> IO ()
+rlImGuiImageRect texture width height rect = with texture (\t -> with rect (c'rlImGuiImageRect t width height))