diff --git a/oom_bella_engine.h b/oom_bella_engine.h new file mode 100644 index 0000000..38c0f49 --- /dev/null +++ b/oom_bella_engine.h @@ -0,0 +1,107 @@ +#pragma once + +// Bella SDK includes - external libraries for 3D rendering +#include "../bella_engine_sdk/src/bella_sdk/bella_engine.h" // For creating and manipulating 3D scenes in Bella + +// Define the oom namespace +namespace oom { + namespace bella { + // Function declaration + dl::bella_sdk::Node essentialsToScene(dl::bella_sdk::Scene& belScene); + + // @param belScene - the scene to create the essentials in + // @return - the world node + dl::bella_sdk::Node essentialsToScene(dl::bella_sdk::Scene& belScene) { + // Create the basic scene elements in Bella + // Each line creates a different type of node in the scene auto belBeautyPass = belScene.createNode("beautyPass","oomerBeautyPass","oomerBeautyPass"); + auto belWorld = belScene.world(); // Get scene world root + { + dl::bella_sdk::Scene::EventScope es(belScene); + + auto belCamForm = belScene.createNode("xform","oomerCameraXform","oomerCameraXform"); + auto belCam = belScene.createNode("camera","oomerCamera","oomerCamera"); + auto belSensor = belScene.createNode("sensor","oomerSensor","oomerSensor"); + auto belLens = belScene.createNode("thinLens","oomerThinLens","oomerThinLens"); + auto belImageDome = belScene.createNode("imageDome","oomerImageDome","oomerImageDome"); + auto belGroundPlane = belScene.createNode("groundPlane","oomerGroundPlane","oomerGroundPlane"); + + auto belBeautyPass = belScene.createNode("beautyPass","oomerBeautyPass","oomerBeautyPass"); + auto belGroundMat = belScene.createNode("quickMaterial","oomerGroundMat","oomerGroundMat"); + auto belSun = belScene.createNode("sun","oomerSun","oomerSun"); + auto belColorDome = belScene.createNode("colorDome","oomerColorDome","oomerColorDome"); + auto belSettings = belScene.settings(); // Get scene settings + // Configure camera + belCam["resolution"] = dl::Vec2 {1920, 1080}; // Set resolution to 1080p + belCam["lens"] = belLens; // Connect camera to lens + belCam["sensor"] = belSensor; // Connect camera to sensor + belCamForm.parentTo(belWorld); // Parent camera transform to world + belCam.parentTo(belCamForm); // Parent camera to camera transform + + // Position the camera with a transformation matrix + belCamForm["steps"][0]["xform"] = dl::Mat4 {0.525768608156, -0.850627633385, 0, 0, -0.234464751651, -0.144921468924, -0.961261695938, 0, 0.817675761479, 0.505401223947, -0.275637355817, 0, -88.12259018466, -54.468125200218, 50.706001690932, 1}; + + // Configure environment (image-based lighting) + belImageDome["ext"] = ".jpg"; + belImageDome["dir"] = "./res"; + belImageDome["multiplier"] = 6.0f; + belImageDome["file"] = "DayEnvironmentHDRI019_1K-TONEMAPPED"; + belImageDome["overrides"]["background"] = belColorDome; + belColorDome["zenith"] = dl::Rgba{1.0f, 1.0f, 1.0f, 1.0f}; + belColorDome["horizon"] = dl::Rgba{.85f, 0.76f, 0.294f, 1.0f}; + belColorDome["altitude"] = 14.0f; + // Configure ground plane + //belGroundPlane["elevation"] = -.5f; + belGroundPlane["material"] = belGroundMat; + + /* Commented out: Sun configuration + belSun["size"] = 20.0f; + belSun["month"] = "july"; + belSun["rotation"] = 50.0f;*/ + + // Configure materials + belGroundMat["type"] = "metal"; + belGroundMat["roughness"] = 22.0f; + belGroundMat["color"] = dl::Rgba{0.138431623578, 0.5, 0.3, 1.0}; + + // Set up scene settings + belSettings["beautyPass"] = belBeautyPass; + belSettings["camera"] = belCam; + belSettings["environment"] = belColorDome; + belSettings["iprScale"] = 100.0f; + belSettings["threads"] = dl::bella_sdk::Input(0); // Auto-detect thread count + belSettings["groundPlane"] = belGroundPlane; + belSettings["iprNavigation"] = "maya"; // Use Maya-like navigation in viewer + //settings["sun"] = sun; + + auto belVoxel = belScene.createNode("box","oomerVoxel","oomerVoxel"); + auto belLiqVoxel = belScene.createNode("box","oomerLiqVoxel","oomerLiqVoxel"); + auto belVoxelForm = belScene.createNode("xform","oomerVoxelXform","oomerVoxelXform"); + auto belLiqVoxelForm = belScene.createNode("xform","oomerLiqVoxelXform","oomerLiqVoxelXform"); + auto belVoxelMat = belScene.createNode("orenNayar","oomerVoxelMat","oomerVoxelMat"); + auto belMeshVoxel = belScene.createNode("mesh", "oomerMeshVoxel"); + auto belBevel = belScene.createNode("bevel", "oomerBevel"); + belBevel["radius"] = 90.0f; + belBevel["samples"] =dl::UInt(6); + + //#include "resources/smoothcube.h" + addMeshCube(belMeshVoxel); + // Configure voxel box dimensions + belVoxel["radius"] = 0.33f; + belVoxel["sizeX"] = 0.99f; + belVoxel["sizeY"] = 0.99f; + belVoxel["sizeZ"] = 0.99f; + + // Less gap to make liquid look better, allows more light to pass through + belLiqVoxel["sizeX"] = 0.99945f; + belLiqVoxel["sizeY"] = 0.99945f; + belLiqVoxel["sizeZ"] = 0.99945f; + + belVoxel.parentTo(belVoxelForm); + belVoxelForm["steps"][0]["xform"] = dl::Mat4 {0.999,0,0,0,0,0.999,0,0,0,0,0.999,0,0,0,0,1}; + belVoxelMat["reflectance"] = dl::Rgba{0.0, 0.0, 0.0, 1.0}; + belVoxelForm["material"] = belVoxelMat; + } + return belWorld; + } + } +} diff --git a/oom_bella_long.h b/oom_bella_long.h new file mode 100644 index 0000000..b97d777 --- /dev/null +++ b/oom_bella_long.h @@ -0,0 +1,1979 @@ +#pragma once + +// Bella SDK includes - external libraries for 3D rendering +#include "../bella_scene_sdk/src/bella_sdk/bella_scene.h" // For creating and manipulating 3D scenes in Bella +//#include "../bella_scene_sdk/src/dl_core/dl_main.inl" // Core functionality from the Diffuse Logic engine + +void addMeshCube(dl::bella_sdk::Node& belMeshVoxel); +// Now define the oomer namespace with using declarations for all functions/classes +namespace oom { + namespace bella { + void addMeshCube(dl::bella_sdk::Node& belMeshVoxel) { + belMeshVoxel["name"] = "oomerMeshVoxel"; + belMeshVoxel["channels"][0] = "st"; + belMeshVoxel["optimized"] = false; + + dl::ds::Vector polygons; + polygons.push_back(dl::Vec4u{0, 1, 2, 3}); + polygons.push_back(dl::Vec4u{4, 5, 6, 7}); + polygons.push_back(dl::Vec4u{8, 9, 10, 11}); + polygons.push_back(dl::Vec4u{12, 13, 14, 15}); + polygons.push_back(dl::Vec4u{16, 17, 18, 19}); + polygons.push_back(dl::Vec4u{20, 21, 22, 23}); + polygons.push_back(dl::Vec4u{24, 25, 26, 27}); + polygons.push_back(dl::Vec4u{28, 29, 30, 31}); + polygons.push_back(dl::Vec4u{32, 33, 34, 35}); + polygons.push_back(dl::Vec4u{36, 37, 38, 39}); + polygons.push_back(dl::Vec4u{40, 41, 42, 43}); + polygons.push_back(dl::Vec4u{44, 45, 46, 47}); + polygons.push_back(dl::Vec4u{48, 49, 50, 51}); + polygons.push_back(dl::Vec4u{52, 53, 54, 55}); + polygons.push_back(dl::Vec4u{56, 57, 58, 59}); + polygons.push_back(dl::Vec4u{60, 61, 62, 63}); + polygons.push_back(dl::Vec4u{64, 65, 66, 67}); + polygons.push_back(dl::Vec4u{68, 69, 70, 71}); + polygons.push_back(dl::Vec4u{72, 73, 74, 75}); + polygons.push_back(dl::Vec4u{76, 77, 78, 79}); + polygons.push_back(dl::Vec4u{80, 81, 82, 83}); + polygons.push_back(dl::Vec4u{84, 85, 86, 87}); + polygons.push_back(dl::Vec4u{88, 89, 90, 91}); + polygons.push_back(dl::Vec4u{92, 93, 94, 95}); + polygons.push_back(dl::Vec4u{96, 97, 98, 99}); + polygons.push_back(dl::Vec4u{100, 101, 102, 103}); + polygons.push_back(dl::Vec4u{104, 105, 106, 107}); + polygons.push_back(dl::Vec4u{108, 109, 110, 111}); + polygons.push_back(dl::Vec4u{112, 113, 114, 115}); + polygons.push_back(dl::Vec4u{116, 117, 118, 119}); + polygons.push_back(dl::Vec4u{120, 121, 122, 123}); + polygons.push_back(dl::Vec4u{124, 125, 126, 127}); + polygons.push_back(dl::Vec4u{128, 129, 130, 131}); + polygons.push_back(dl::Vec4u{132, 133, 134, 135}); + polygons.push_back(dl::Vec4u{136, 137, 138, 139}); + polygons.push_back(dl::Vec4u{140, 141, 142, 143}); + polygons.push_back(dl::Vec4u{144, 145, 146, 147}); + polygons.push_back(dl::Vec4u{148, 149, 150, 151}); + polygons.push_back(dl::Vec4u{152, 153, 154, 155}); + polygons.push_back(dl::Vec4u{156, 157, 158, 159}); + polygons.push_back(dl::Vec4u{160, 161, 162, 163}); + polygons.push_back(dl::Vec4u{164, 165, 166, 167}); + polygons.push_back(dl::Vec4u{168, 169, 170, 171}); + polygons.push_back(dl::Vec4u{172, 173, 174, 175}); + polygons.push_back(dl::Vec4u{176, 177, 178, 179}); + polygons.push_back(dl::Vec4u{180, 181, 182, 183}); + polygons.push_back(dl::Vec4u{184, 185, 186, 187}); + polygons.push_back(dl::Vec4u{188, 189, 190, 191}); + polygons.push_back(dl::Vec4u{192, 193, 194, 195}); + polygons.push_back(dl::Vec4u{196, 197, 198, 199}); + polygons.push_back(dl::Vec4u{200, 201, 202, 203}); + polygons.push_back(dl::Vec4u{204, 205, 206, 207}); + polygons.push_back(dl::Vec4u{208, 209, 210, 211}); + polygons.push_back(dl::Vec4u{212, 213, 214, 215}); + polygons.push_back(dl::Vec4u{216, 217, 218, 219}); + polygons.push_back(dl::Vec4u{220, 221, 222, 223}); + polygons.push_back(dl::Vec4u{224, 225, 226, 227}); + polygons.push_back(dl::Vec4u{228, 229, 230, 231}); + polygons.push_back(dl::Vec4u{232, 233, 234, 235}); + polygons.push_back(dl::Vec4u{236, 237, 238, 239}); + polygons.push_back(dl::Vec4u{240, 241, 242, 243}); + polygons.push_back(dl::Vec4u{244, 245, 246, 247}); + polygons.push_back(dl::Vec4u{248, 249, 250, 251}); + polygons.push_back(dl::Vec4u{252, 253, 254, 255}); + polygons.push_back(dl::Vec4u{256, 257, 258, 259}); + polygons.push_back(dl::Vec4u{260, 261, 262, 263}); + polygons.push_back(dl::Vec4u{264, 265, 266, 267}); + polygons.push_back(dl::Vec4u{268, 269, 270, 271}); + polygons.push_back(dl::Vec4u{272, 273, 274, 275}); + polygons.push_back(dl::Vec4u{276, 277, 278, 279}); + polygons.push_back(dl::Vec4u{280, 281, 282, 283}); + polygons.push_back(dl::Vec4u{284, 285, 286, 287}); + polygons.push_back(dl::Vec4u{288, 289, 290, 291}); + polygons.push_back(dl::Vec4u{292, 293, 294, 295}); + polygons.push_back(dl::Vec4u{296, 297, 298, 299}); + polygons.push_back(dl::Vec4u{300, 301, 302, 303}); + polygons.push_back(dl::Vec4u{304, 305, 306, 307}); + polygons.push_back(dl::Vec4u{308, 309, 310, 311}); + polygons.push_back(dl::Vec4u{312, 313, 314, 315}); + polygons.push_back(dl::Vec4u{316, 317, 318, 319}); + polygons.push_back(dl::Vec4u{320, 321, 322, 323}); + polygons.push_back(dl::Vec4u{324, 325, 326, 327}); + polygons.push_back(dl::Vec4u{328, 329, 330, 331}); + polygons.push_back(dl::Vec4u{332, 333, 334, 335}); + polygons.push_back(dl::Vec4u{336, 337, 338, 339}); + polygons.push_back(dl::Vec4u{340, 341, 342, 343}); + polygons.push_back(dl::Vec4u{344, 345, 346, 347}); + polygons.push_back(dl::Vec4u{348, 349, 350, 351}); + polygons.push_back(dl::Vec4u{352, 353, 354, 355}); + polygons.push_back(dl::Vec4u{356, 357, 358, 359}); + polygons.push_back(dl::Vec4u{360, 361, 362, 363}); + polygons.push_back(dl::Vec4u{364, 365, 366, 367}); + polygons.push_back(dl::Vec4u{368, 369, 370, 371}); + polygons.push_back(dl::Vec4u{372, 373, 374, 375}); + polygons.push_back(dl::Vec4u{376, 377, 378, 379}); + polygons.push_back(dl::Vec4u{380, 381, 382, 383}); + polygons.push_back(dl::Vec4u{384, 385, 386, 387}); + polygons.push_back(dl::Vec4u{388, 389, 390, 391}); + polygons.push_back(dl::Vec4u{392, 393, 394, 395}); + polygons.push_back(dl::Vec4u{396, 397, 398, 399}); + polygons.push_back(dl::Vec4u{400, 401, 402, 403}); + polygons.push_back(dl::Vec4u{404, 405, 406, 407}); + polygons.push_back(dl::Vec4u{408, 409, 410, 411}); + polygons.push_back(dl::Vec4u{412, 413, 414, 415}); + polygons.push_back(dl::Vec4u{416, 417, 418, 419}); + polygons.push_back(dl::Vec4u{420, 421, 422, 423}); + polygons.push_back(dl::Vec4u{424, 425, 426, 427}); + polygons.push_back(dl::Vec4u{428, 429, 430, 431}); + polygons.push_back(dl::Vec4u{432, 433, 434, 435}); + polygons.push_back(dl::Vec4u{436, 437, 438, 439}); + polygons.push_back(dl::Vec4u{440, 441, 442, 443}); + polygons.push_back(dl::Vec4u{444, 445, 446, 447}); + polygons.push_back(dl::Vec4u{448, 449, 450, 451}); + polygons.push_back(dl::Vec4u{452, 453, 454, 455}); + polygons.push_back(dl::Vec4u{456, 457, 458, 459}); + polygons.push_back(dl::Vec4u{460, 461, 462, 463}); + polygons.push_back(dl::Vec4u{464, 465, 466, 467}); + polygons.push_back(dl::Vec4u{468, 469, 470, 471}); + polygons.push_back(dl::Vec4u{472, 473, 474, 475}); + polygons.push_back(dl::Vec4u{476, 477, 478, 479}); + polygons.push_back(dl::Vec4u{480, 481, 482, 483}); + polygons.push_back(dl::Vec4u{484, 485, 486, 487}); + polygons.push_back(dl::Vec4u{488, 489, 490, 491}); + polygons.push_back(dl::Vec4u{492, 493, 494, 495}); + polygons.push_back(dl::Vec4u{496, 497, 498, 499}); + polygons.push_back(dl::Vec4u{500, 501, 502, 503}); + polygons.push_back(dl::Vec4u{504, 505, 506, 507}); + polygons.push_back(dl::Vec4u{508, 509, 510, 511}); + polygons.push_back(dl::Vec4u{512, 513, 514, 515}); + polygons.push_back(dl::Vec4u{516, 517, 518, 519}); + polygons.push_back(dl::Vec4u{520, 521, 522, 523}); + polygons.push_back(dl::Vec4u{524, 525, 526, 527}); + polygons.push_back(dl::Vec4u{528, 529, 530, 531}); + polygons.push_back(dl::Vec4u{532, 533, 534, 535}); + polygons.push_back(dl::Vec4u{536, 537, 538, 539}); + polygons.push_back(dl::Vec4u{540, 541, 542, 543}); + polygons.push_back(dl::Vec4u{544, 545, 546, 547}); + polygons.push_back(dl::Vec4u{548, 549, 550, 551}); + polygons.push_back(dl::Vec4u{552, 553, 554, 555}); + polygons.push_back(dl::Vec4u{556, 557, 558, 559}); + polygons.push_back(dl::Vec4u{560, 561, 562, 563}); + polygons.push_back(dl::Vec4u{564, 565, 566, 567}); + polygons.push_back(dl::Vec4u{568, 569, 570, 571}); + polygons.push_back(dl::Vec4u{572, 573, 574, 575}); + polygons.push_back(dl::Vec4u{576, 577, 578, 579}); + polygons.push_back(dl::Vec4u{580, 581, 582, 583}); + polygons.push_back(dl::Vec4u{584, 585, 586, 587}); + polygons.push_back(dl::Vec4u{588, 589, 590, 591}); + polygons.push_back(dl::Vec4u{592, 593, 594, 595}); + polygons.push_back(dl::Vec4u{596, 597, 598, 599}); + belMeshVoxel["polygons"] = polygons; + + dl::ds::Vector normals; + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{0, -1, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{1, 0, 0}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{0, 0, 1}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{-1, 0, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{0, 1, 0}); + normals.push_back(dl::Vec3f{-0.00001, -0.000047, -1}); + normals.push_back(dl::Vec3f{-0.000062, -0.382654, -0.923892}); + normals.push_back(dl::Vec3f{-0.367325, -0.367291, -0.8545}); + normals.push_back(dl::Vec3f{-0.382636, -0.000045, -0.923899}); + normals.push_back(dl::Vec3f{-0, -0.38271, -0.923869}); + normals.push_back(dl::Vec3f{-0.000048, -0.707083, -0.707131}); + normals.push_back(dl::Vec3f{-0.334722, -0.66629, -0.666347}); + normals.push_back(dl::Vec3f{-0.367321, -0.367379, -0.854463}); + normals.push_back(dl::Vec3f{-0.38268, -0.000035, -0.923881}); + normals.push_back(dl::Vec3f{-0.367373, -0.367314, -0.854469}); + normals.push_back(dl::Vec3f{-0.6663, -0.3347, -0.66634}); + normals.push_back(dl::Vec3f{-0.707079, -0.000042, -0.707135}); + normals.push_back(dl::Vec3f{-0.367366, -0.36739, -0.85444}); + normals.push_back(dl::Vec3f{-0.334782, -0.666288, -0.66632}); + normals.push_back(dl::Vec3f{-0.577331, -0.577344, -0.577376}); + normals.push_back(dl::Vec3f{-0.666285, -0.334777, -0.666324}); + normals.push_back(dl::Vec3f{-0.000047, -1, -0.00001}); + normals.push_back(dl::Vec3f{-0.382654, -0.923892, -0.000062}); + normals.push_back(dl::Vec3f{-0.367291, -0.8545, -0.367325}); + normals.push_back(dl::Vec3f{-0.000045, -0.923899, -0.382636}); + normals.push_back(dl::Vec3f{-0.38271, -0.923869, -0}); + normals.push_back(dl::Vec3f{-0.707083, -0.707131, -0.000048}); + normals.push_back(dl::Vec3f{-0.66629, -0.666347, -0.334722}); + normals.push_back(dl::Vec3f{-0.367379, -0.854463, -0.367321}); + normals.push_back(dl::Vec3f{-0.000035, -0.923881, -0.38268}); + normals.push_back(dl::Vec3f{-0.367314, -0.854469, -0.367373}); + normals.push_back(dl::Vec3f{-0.3347, -0.66634, -0.6663}); + normals.push_back(dl::Vec3f{-0.000042, -0.707135, -0.707079}); + normals.push_back(dl::Vec3f{-0.36739, -0.85444, -0.367366}); + normals.push_back(dl::Vec3f{-0.666288, -0.66632, -0.334782}); + normals.push_back(dl::Vec3f{-0.577344, -0.577376, -0.577331}); + normals.push_back(dl::Vec3f{-0.334777, -0.666324, -0.666285}); + normals.push_back(dl::Vec3f{-1, -0.00001, -0.000047}); + normals.push_back(dl::Vec3f{-0.923892, -0.000062, -0.382654}); + normals.push_back(dl::Vec3f{-0.8545, -0.367325, -0.367291}); + normals.push_back(dl::Vec3f{-0.923899, -0.382636, -0.000045}); + normals.push_back(dl::Vec3f{-0.923869, -0, -0.38271}); + normals.push_back(dl::Vec3f{-0.707131, -0.000048, -0.707083}); + normals.push_back(dl::Vec3f{-0.666347, -0.334722, -0.66629}); + normals.push_back(dl::Vec3f{-0.854463, -0.367321, -0.367379}); + normals.push_back(dl::Vec3f{-0.923881, -0.38268, -0.000035}); + normals.push_back(dl::Vec3f{-0.854469, -0.367373, -0.367314}); + normals.push_back(dl::Vec3f{-0.66634, -0.6663, -0.3347}); + normals.push_back(dl::Vec3f{-0.707135, -0.707079, -0.000042}); + normals.push_back(dl::Vec3f{-0.85444, -0.367366, -0.36739}); + normals.push_back(dl::Vec3f{-0.66632, -0.334782, -0.666288}); + normals.push_back(dl::Vec3f{-0.577376, -0.577331, -0.577344}); + normals.push_back(dl::Vec3f{-0.666324, -0.666285, -0.334777}); + normals.push_back(dl::Vec3f{-0.00001, -1, 0.000046}); + normals.push_back(dl::Vec3f{-0.000063, -0.923892, 0.382654}); + normals.push_back(dl::Vec3f{-0.367325, -0.8545, 0.367291}); + normals.push_back(dl::Vec3f{-0.382636, -0.923899, 0.000045}); + normals.push_back(dl::Vec3f{-0, -0.923868, 0.38271}); + normals.push_back(dl::Vec3f{-0.000049, -0.70713, 0.707083}); + normals.push_back(dl::Vec3f{-0.334723, -0.666346, 0.66629}); + normals.push_back(dl::Vec3f{-0.367322, -0.854463, 0.36738}); + normals.push_back(dl::Vec3f{-0.38268, -0.923881, 0.000035}); + normals.push_back(dl::Vec3f{-0.367373, -0.854469, 0.367314}); + normals.push_back(dl::Vec3f{-0.6663, -0.666341, 0.3347}); + normals.push_back(dl::Vec3f{-0.707079, -0.707135, 0.000042}); + normals.push_back(dl::Vec3f{-0.367366, -0.854439, 0.36739}); + normals.push_back(dl::Vec3f{-0.334781, -0.66632, 0.666288}); + normals.push_back(dl::Vec3f{-0.577331, -0.577375, 0.577345}); + normals.push_back(dl::Vec3f{-0.666285, -0.666324, 0.334778}); + normals.push_back(dl::Vec3f{-0.000046, -0.00001, 1}); + normals.push_back(dl::Vec3f{-0.382654, -0.000063, 0.923892}); + normals.push_back(dl::Vec3f{-0.367291, -0.367325, 0.8545}); + normals.push_back(dl::Vec3f{-0.000045, -0.382636, 0.923899}); + normals.push_back(dl::Vec3f{-0.38271, -0, 0.923869}); + normals.push_back(dl::Vec3f{-0.707083, -0.000049, 0.70713}); + normals.push_back(dl::Vec3f{-0.666291, -0.334723, 0.666346}); + normals.push_back(dl::Vec3f{-0.36738, -0.367322, 0.854463}); + normals.push_back(dl::Vec3f{-0.000035, -0.38268, 0.923881}); + normals.push_back(dl::Vec3f{-0.367314, -0.367373, 0.854469}); + normals.push_back(dl::Vec3f{-0.3347, -0.6663, 0.666341}); + normals.push_back(dl::Vec3f{-0.000042, -0.707079, 0.707135}); + normals.push_back(dl::Vec3f{-0.36739, -0.367366, 0.854439}); + normals.push_back(dl::Vec3f{-0.666288, -0.334781, 0.66632}); + normals.push_back(dl::Vec3f{-0.577345, -0.577331, 0.577375}); + normals.push_back(dl::Vec3f{-0.334778, -0.666285, 0.666324}); + normals.push_back(dl::Vec3f{-1, -0.000046, 0.00001}); + normals.push_back(dl::Vec3f{-0.923892, -0.382654, 0.000062}); + normals.push_back(dl::Vec3f{-0.8545, -0.367291, 0.367325}); + normals.push_back(dl::Vec3f{-0.923899, -0.000045, 0.382636}); + normals.push_back(dl::Vec3f{-0.923868, -0.38271, 0}); + normals.push_back(dl::Vec3f{-0.70713, -0.707083, 0.000049}); + normals.push_back(dl::Vec3f{-0.666346, -0.66629, 0.334723}); + normals.push_back(dl::Vec3f{-0.854463, -0.36738, 0.367322}); + normals.push_back(dl::Vec3f{-0.923881, -0.000035, 0.38268}); + normals.push_back(dl::Vec3f{-0.854469, -0.367314, 0.367373}); + normals.push_back(dl::Vec3f{-0.666341, -0.3347, 0.6663}); + normals.push_back(dl::Vec3f{-0.707135, -0.000042, 0.707079}); + normals.push_back(dl::Vec3f{-0.854439, -0.36739, 0.367366}); + normals.push_back(dl::Vec3f{-0.66632, -0.666288, 0.334781}); + normals.push_back(dl::Vec3f{-0.577375, -0.577345, 0.577331}); + normals.push_back(dl::Vec3f{-0.666324, -0.334778, 0.666285}); + normals.push_back(dl::Vec3f{-0.000046, 0.00001, -1}); + normals.push_back(dl::Vec3f{-0.382654, 0.000063, -0.923892}); + normals.push_back(dl::Vec3f{-0.367291, 0.367325, -0.8545}); + normals.push_back(dl::Vec3f{-0.000045, 0.382636, -0.923899}); + normals.push_back(dl::Vec3f{-0.38271, 0, -0.923869}); + normals.push_back(dl::Vec3f{-0.707083, 0.000049, -0.70713}); + normals.push_back(dl::Vec3f{-0.666291, 0.334723, -0.666346}); + normals.push_back(dl::Vec3f{-0.36738, 0.367322, -0.854463}); + normals.push_back(dl::Vec3f{-0.000035, 0.38268, -0.923881}); + normals.push_back(dl::Vec3f{-0.367314, 0.367373, -0.854469}); + normals.push_back(dl::Vec3f{-0.3347, 0.6663, -0.666341}); + normals.push_back(dl::Vec3f{-0.000042, 0.707079, -0.707135}); + normals.push_back(dl::Vec3f{-0.36739, 0.367366, -0.854439}); + normals.push_back(dl::Vec3f{-0.666288, 0.334781, -0.66632}); + normals.push_back(dl::Vec3f{-0.577345, 0.577331, -0.577375}); + normals.push_back(dl::Vec3f{-0.334778, 0.666285, -0.666324}); + normals.push_back(dl::Vec3f{-1, 0.000046, -0.00001}); + normals.push_back(dl::Vec3f{-0.923892, 0.382654, -0.000062}); + normals.push_back(dl::Vec3f{-0.8545, 0.367291, -0.367325}); + normals.push_back(dl::Vec3f{-0.923899, 0.000045, -0.382636}); + normals.push_back(dl::Vec3f{-0.923868, 0.38271, -0}); + normals.push_back(dl::Vec3f{-0.70713, 0.707083, -0.000049}); + normals.push_back(dl::Vec3f{-0.666346, 0.66629, -0.334723}); + normals.push_back(dl::Vec3f{-0.854463, 0.36738, -0.367322}); + normals.push_back(dl::Vec3f{-0.923881, 0.000035, -0.38268}); + normals.push_back(dl::Vec3f{-0.854469, 0.367314, -0.367373}); + normals.push_back(dl::Vec3f{-0.666341, 0.3347, -0.6663}); + normals.push_back(dl::Vec3f{-0.707135, 0.000042, -0.707079}); + normals.push_back(dl::Vec3f{-0.854439, 0.36739, -0.367366}); + normals.push_back(dl::Vec3f{-0.66632, 0.666288, -0.334781}); + normals.push_back(dl::Vec3f{-0.577375, 0.577345, -0.577331}); + normals.push_back(dl::Vec3f{-0.666324, 0.334778, -0.666285}); + normals.push_back(dl::Vec3f{-0.00001, 1, -0.000046}); + normals.push_back(dl::Vec3f{-0.000063, 0.923892, -0.382654}); + normals.push_back(dl::Vec3f{-0.367325, 0.8545, -0.367291}); + normals.push_back(dl::Vec3f{-0.382636, 0.923899, -0.000045}); + normals.push_back(dl::Vec3f{-0, 0.923868, -0.38271}); + normals.push_back(dl::Vec3f{-0.000049, 0.70713, -0.707083}); + normals.push_back(dl::Vec3f{-0.334723, 0.666346, -0.66629}); + normals.push_back(dl::Vec3f{-0.367322, 0.854463, -0.36738}); + normals.push_back(dl::Vec3f{-0.38268, 0.923881, -0.000035}); + normals.push_back(dl::Vec3f{-0.367373, 0.854469, -0.367314}); + normals.push_back(dl::Vec3f{-0.6663, 0.666341, -0.3347}); + normals.push_back(dl::Vec3f{-0.707079, 0.707135, -0.000042}); + normals.push_back(dl::Vec3f{-0.367366, 0.854439, -0.36739}); + normals.push_back(dl::Vec3f{-0.334781, 0.66632, -0.666288}); + normals.push_back(dl::Vec3f{-0.577331, 0.577375, -0.577345}); + normals.push_back(dl::Vec3f{-0.666285, 0.666324, -0.334778}); + normals.push_back(dl::Vec3f{-0.00001, 0.000047, 1}); + normals.push_back(dl::Vec3f{-0.000062, 0.382654, 0.923892}); + normals.push_back(dl::Vec3f{-0.367325, 0.367291, 0.8545}); + normals.push_back(dl::Vec3f{-0.382636, 0.000045, 0.923899}); + normals.push_back(dl::Vec3f{-0, 0.38271, 0.923869}); + normals.push_back(dl::Vec3f{-0.000048, 0.707083, 0.707131}); + normals.push_back(dl::Vec3f{-0.334722, 0.66629, 0.666347}); + normals.push_back(dl::Vec3f{-0.367321, 0.367379, 0.854463}); + normals.push_back(dl::Vec3f{-0.38268, 0.000035, 0.923881}); + normals.push_back(dl::Vec3f{-0.367373, 0.367314, 0.854469}); + normals.push_back(dl::Vec3f{-0.6663, 0.3347, 0.66634}); + normals.push_back(dl::Vec3f{-0.707079, 0.000042, 0.707135}); + normals.push_back(dl::Vec3f{-0.367366, 0.36739, 0.85444}); + normals.push_back(dl::Vec3f{-0.334782, 0.666288, 0.66632}); + normals.push_back(dl::Vec3f{-0.577331, 0.577344, 0.577376}); + normals.push_back(dl::Vec3f{-0.666285, 0.334777, 0.666324}); + normals.push_back(dl::Vec3f{-0.000047, 1, 0.00001}); + normals.push_back(dl::Vec3f{-0.382654, 0.923892, 0.000062}); + normals.push_back(dl::Vec3f{-0.367291, 0.8545, 0.367325}); + normals.push_back(dl::Vec3f{-0.000045, 0.923899, 0.382636}); + normals.push_back(dl::Vec3f{-0.38271, 0.923869, 0}); + normals.push_back(dl::Vec3f{-0.707083, 0.707131, 0.000048}); + normals.push_back(dl::Vec3f{-0.66629, 0.666347, 0.334722}); + normals.push_back(dl::Vec3f{-0.367379, 0.854463, 0.367321}); + normals.push_back(dl::Vec3f{-0.000035, 0.923881, 0.38268}); + normals.push_back(dl::Vec3f{-0.367314, 0.854469, 0.367373}); + normals.push_back(dl::Vec3f{-0.3347, 0.66634, 0.6663}); + normals.push_back(dl::Vec3f{-0.000042, 0.707135, 0.707079}); + normals.push_back(dl::Vec3f{-0.36739, 0.85444, 0.367366}); + normals.push_back(dl::Vec3f{-0.666288, 0.66632, 0.334782}); + normals.push_back(dl::Vec3f{-0.577344, 0.577376, 0.577331}); + normals.push_back(dl::Vec3f{-0.334777, 0.666324, 0.666285}); + normals.push_back(dl::Vec3f{-1, 0.00001, 0.000047}); + normals.push_back(dl::Vec3f{-0.923892, 0.000062, 0.382654}); + normals.push_back(dl::Vec3f{-0.8545, 0.367325, 0.367291}); + normals.push_back(dl::Vec3f{-0.923899, 0.382636, 0.000045}); + normals.push_back(dl::Vec3f{-0.923869, 0, 0.38271}); + normals.push_back(dl::Vec3f{-0.707131, 0.000048, 0.707083}); + normals.push_back(dl::Vec3f{-0.666347, 0.334722, 0.66629}); + normals.push_back(dl::Vec3f{-0.854463, 0.367321, 0.367379}); + normals.push_back(dl::Vec3f{-0.923881, 0.38268, 0.000035}); + normals.push_back(dl::Vec3f{-0.854469, 0.367373, 0.367314}); + normals.push_back(dl::Vec3f{-0.66634, 0.6663, 0.3347}); + normals.push_back(dl::Vec3f{-0.707135, 0.707079, 0.000042}); + normals.push_back(dl::Vec3f{-0.85444, 0.367366, 0.36739}); + normals.push_back(dl::Vec3f{-0.66632, 0.334782, 0.666288}); + normals.push_back(dl::Vec3f{-0.577376, 0.577331, 0.577344}); + normals.push_back(dl::Vec3f{-0.666324, 0.666285, 0.334777}); + normals.push_back(dl::Vec3f{0.000046, -0.00001, -1}); + normals.push_back(dl::Vec3f{0.382654, -0.000063, -0.923892}); + normals.push_back(dl::Vec3f{0.367291, -0.367325, -0.8545}); + normals.push_back(dl::Vec3f{0.000045, -0.382636, -0.923899}); + normals.push_back(dl::Vec3f{0.38271, -0, -0.923869}); + normals.push_back(dl::Vec3f{0.707083, -0.000049, -0.70713}); + normals.push_back(dl::Vec3f{0.666291, -0.334723, -0.666346}); + normals.push_back(dl::Vec3f{0.36738, -0.367322, -0.854463}); + normals.push_back(dl::Vec3f{0.000035, -0.38268, -0.923881}); + normals.push_back(dl::Vec3f{0.367314, -0.367373, -0.854469}); + normals.push_back(dl::Vec3f{0.3347, -0.6663, -0.666341}); + normals.push_back(dl::Vec3f{0.000042, -0.707079, -0.707135}); + normals.push_back(dl::Vec3f{0.36739, -0.367366, -0.854439}); + normals.push_back(dl::Vec3f{0.666288, -0.334781, -0.66632}); + normals.push_back(dl::Vec3f{0.577345, -0.577331, -0.577375}); + normals.push_back(dl::Vec3f{0.334778, -0.666285, -0.666324}); + normals.push_back(dl::Vec3f{1, -0.000046, -0.00001}); + normals.push_back(dl::Vec3f{0.923892, -0.382654, -0.000062}); + normals.push_back(dl::Vec3f{0.8545, -0.367291, -0.367325}); + normals.push_back(dl::Vec3f{0.923899, -0.000045, -0.382636}); + normals.push_back(dl::Vec3f{0.923868, -0.38271, -0}); + normals.push_back(dl::Vec3f{0.70713, -0.707083, -0.000049}); + normals.push_back(dl::Vec3f{0.666346, -0.66629, -0.334723}); + normals.push_back(dl::Vec3f{0.854463, -0.36738, -0.367322}); + normals.push_back(dl::Vec3f{0.923881, -0.000035, -0.38268}); + normals.push_back(dl::Vec3f{0.854469, -0.367314, -0.367373}); + normals.push_back(dl::Vec3f{0.666341, -0.3347, -0.6663}); + normals.push_back(dl::Vec3f{0.707135, -0.000042, -0.707079}); + normals.push_back(dl::Vec3f{0.854439, -0.36739, -0.367366}); + normals.push_back(dl::Vec3f{0.66632, -0.666288, -0.334781}); + normals.push_back(dl::Vec3f{0.577375, -0.577345, -0.577331}); + normals.push_back(dl::Vec3f{0.666324, -0.334778, -0.666285}); + normals.push_back(dl::Vec3f{0.00001, -1, -0.000046}); + normals.push_back(dl::Vec3f{0.000063, -0.923892, -0.382654}); + normals.push_back(dl::Vec3f{0.367325, -0.8545, -0.367291}); + normals.push_back(dl::Vec3f{0.382636, -0.923899, -0.000045}); + normals.push_back(dl::Vec3f{0, -0.923868, -0.38271}); + normals.push_back(dl::Vec3f{0.000049, -0.70713, -0.707083}); + normals.push_back(dl::Vec3f{0.334723, -0.666346, -0.66629}); + normals.push_back(dl::Vec3f{0.367322, -0.854463, -0.36738}); + normals.push_back(dl::Vec3f{0.38268, -0.923881, -0.000035}); + normals.push_back(dl::Vec3f{0.367373, -0.854469, -0.367314}); + normals.push_back(dl::Vec3f{0.6663, -0.666341, -0.3347}); + normals.push_back(dl::Vec3f{0.707079, -0.707135, -0.000042}); + normals.push_back(dl::Vec3f{0.367366, -0.854439, -0.36739}); + normals.push_back(dl::Vec3f{0.334781, -0.66632, -0.666288}); + normals.push_back(dl::Vec3f{0.577331, -0.577375, -0.577345}); + normals.push_back(dl::Vec3f{0.666285, -0.666324, -0.334778}); + normals.push_back(dl::Vec3f{0.00001, -0.000047, 1}); + normals.push_back(dl::Vec3f{0.000062, -0.382654, 0.923892}); + normals.push_back(dl::Vec3f{0.367325, -0.367291, 0.8545}); + normals.push_back(dl::Vec3f{0.382636, -0.000045, 0.923899}); + normals.push_back(dl::Vec3f{0, -0.38271, 0.923869}); + normals.push_back(dl::Vec3f{0.000048, -0.707083, 0.707131}); + normals.push_back(dl::Vec3f{0.334722, -0.66629, 0.666347}); + normals.push_back(dl::Vec3f{0.367321, -0.367379, 0.854463}); + normals.push_back(dl::Vec3f{0.38268, -0.000035, 0.923881}); + normals.push_back(dl::Vec3f{0.367373, -0.367314, 0.854469}); + normals.push_back(dl::Vec3f{0.6663, -0.3347, 0.66634}); + normals.push_back(dl::Vec3f{0.707079, -0.000042, 0.707135}); + normals.push_back(dl::Vec3f{0.367366, -0.36739, 0.85444}); + normals.push_back(dl::Vec3f{0.334782, -0.666288, 0.66632}); + normals.push_back(dl::Vec3f{0.577331, -0.577344, 0.577376}); + normals.push_back(dl::Vec3f{0.666285, -0.334777, 0.666324}); + normals.push_back(dl::Vec3f{0.000047, -1, 0.00001}); + normals.push_back(dl::Vec3f{0.382654, -0.923892, 0.000062}); + normals.push_back(dl::Vec3f{0.367291, -0.8545, 0.367325}); + normals.push_back(dl::Vec3f{0.000045, -0.923899, 0.382636}); + normals.push_back(dl::Vec3f{0.38271, -0.923869, 0}); + normals.push_back(dl::Vec3f{0.707083, -0.707131, 0.000048}); + normals.push_back(dl::Vec3f{0.66629, -0.666347, 0.334722}); + normals.push_back(dl::Vec3f{0.367379, -0.854463, 0.367321}); + normals.push_back(dl::Vec3f{0.000035, -0.923881, 0.38268}); + normals.push_back(dl::Vec3f{0.367314, -0.854469, 0.367373}); + normals.push_back(dl::Vec3f{0.3347, -0.66634, 0.6663}); + normals.push_back(dl::Vec3f{0.000042, -0.707135, 0.707079}); + normals.push_back(dl::Vec3f{0.36739, -0.85444, 0.367366}); + normals.push_back(dl::Vec3f{0.666288, -0.66632, 0.334782}); + normals.push_back(dl::Vec3f{0.577344, -0.577376, 0.577331}); + normals.push_back(dl::Vec3f{0.334777, -0.666324, 0.666285}); + normals.push_back(dl::Vec3f{1, -0.00001, 0.000047}); + normals.push_back(dl::Vec3f{0.923892, -0.000062, 0.382654}); + normals.push_back(dl::Vec3f{0.8545, -0.367325, 0.367291}); + normals.push_back(dl::Vec3f{0.923899, -0.382636, 0.000045}); + normals.push_back(dl::Vec3f{0.923869, -0, 0.38271}); + normals.push_back(dl::Vec3f{0.707131, -0.000048, 0.707083}); + normals.push_back(dl::Vec3f{0.666347, -0.334722, 0.66629}); + normals.push_back(dl::Vec3f{0.854463, -0.367321, 0.367379}); + normals.push_back(dl::Vec3f{0.923881, -0.38268, 0.000035}); + normals.push_back(dl::Vec3f{0.854469, -0.367373, 0.367314}); + normals.push_back(dl::Vec3f{0.66634, -0.6663, 0.3347}); + normals.push_back(dl::Vec3f{0.707135, -0.707079, 0.000042}); + normals.push_back(dl::Vec3f{0.85444, -0.367366, 0.36739}); + normals.push_back(dl::Vec3f{0.66632, -0.334782, 0.666288}); + normals.push_back(dl::Vec3f{0.577376, -0.577331, 0.577344}); + normals.push_back(dl::Vec3f{0.666324, -0.666285, 0.334777}); + normals.push_back(dl::Vec3f{0.00001, 0.000047, -1}); + normals.push_back(dl::Vec3f{0.000062, 0.382654, -0.923892}); + normals.push_back(dl::Vec3f{0.367325, 0.367291, -0.8545}); + normals.push_back(dl::Vec3f{0.382636, 0.000045, -0.923899}); + normals.push_back(dl::Vec3f{0, 0.38271, -0.923869}); + normals.push_back(dl::Vec3f{0.000048, 0.707083, -0.707131}); + normals.push_back(dl::Vec3f{0.334722, 0.66629, -0.666347}); + normals.push_back(dl::Vec3f{0.367321, 0.367379, -0.854463}); + normals.push_back(dl::Vec3f{0.38268, 0.000035, -0.923881}); + normals.push_back(dl::Vec3f{0.367373, 0.367314, -0.854469}); + normals.push_back(dl::Vec3f{0.6663, 0.3347, -0.66634}); + normals.push_back(dl::Vec3f{0.707079, 0.000042, -0.707135}); + normals.push_back(dl::Vec3f{0.367366, 0.36739, -0.85444}); + normals.push_back(dl::Vec3f{0.334782, 0.666288, -0.66632}); + normals.push_back(dl::Vec3f{0.577331, 0.577344, -0.577376}); + normals.push_back(dl::Vec3f{0.666285, 0.334777, -0.666324}); + normals.push_back(dl::Vec3f{0.000047, 1, -0.00001}); + normals.push_back(dl::Vec3f{0.382654, 0.923892, -0.000062}); + normals.push_back(dl::Vec3f{0.367291, 0.8545, -0.367325}); + normals.push_back(dl::Vec3f{0.000045, 0.923899, -0.382636}); + normals.push_back(dl::Vec3f{0.38271, 0.923869, -0}); + normals.push_back(dl::Vec3f{0.707083, 0.707131, -0.000048}); + normals.push_back(dl::Vec3f{0.66629, 0.666347, -0.334722}); + normals.push_back(dl::Vec3f{0.367379, 0.854463, -0.367321}); + normals.push_back(dl::Vec3f{0.000035, 0.923881, -0.38268}); + normals.push_back(dl::Vec3f{0.367314, 0.854469, -0.367373}); + normals.push_back(dl::Vec3f{0.3347, 0.66634, -0.6663}); + normals.push_back(dl::Vec3f{0.000042, 0.707135, -0.707079}); + normals.push_back(dl::Vec3f{0.36739, 0.85444, -0.367366}); + normals.push_back(dl::Vec3f{0.666288, 0.66632, -0.334782}); + normals.push_back(dl::Vec3f{0.577344, 0.577376, -0.577331}); + normals.push_back(dl::Vec3f{0.334777, 0.666324, -0.666285}); + normals.push_back(dl::Vec3f{1, 0.00001, -0.000047}); + normals.push_back(dl::Vec3f{0.923892, 0.000062, -0.382654}); + normals.push_back(dl::Vec3f{0.8545, 0.367325, -0.367291}); + normals.push_back(dl::Vec3f{0.923899, 0.382636, -0.000045}); + normals.push_back(dl::Vec3f{0.923869, 0, -0.38271}); + normals.push_back(dl::Vec3f{0.707131, 0.000048, -0.707083}); + normals.push_back(dl::Vec3f{0.666347, 0.334722, -0.66629}); + normals.push_back(dl::Vec3f{0.854463, 0.367321, -0.367379}); + normals.push_back(dl::Vec3f{0.923881, 0.38268, -0.000035}); + normals.push_back(dl::Vec3f{0.854469, 0.367373, -0.367314}); + normals.push_back(dl::Vec3f{0.66634, 0.6663, -0.3347}); + normals.push_back(dl::Vec3f{0.707135, 0.707079, -0.000042}); + normals.push_back(dl::Vec3f{0.85444, 0.367366, -0.36739}); + normals.push_back(dl::Vec3f{0.66632, 0.334782, -0.666288}); + normals.push_back(dl::Vec3f{0.577376, 0.577331, -0.577344}); + normals.push_back(dl::Vec3f{0.666324, 0.666285, -0.334777}); + normals.push_back(dl::Vec3f{0.000046, 0.00001, 1}); + normals.push_back(dl::Vec3f{0.382654, 0.000063, 0.923892}); + normals.push_back(dl::Vec3f{0.367291, 0.367325, 0.8545}); + normals.push_back(dl::Vec3f{0.000045, 0.382636, 0.923899}); + normals.push_back(dl::Vec3f{0.38271, 0, 0.923869}); + normals.push_back(dl::Vec3f{0.707083, 0.000049, 0.70713}); + normals.push_back(dl::Vec3f{0.666291, 0.334723, 0.666346}); + normals.push_back(dl::Vec3f{0.36738, 0.367322, 0.854463}); + normals.push_back(dl::Vec3f{0.000035, 0.38268, 0.923881}); + normals.push_back(dl::Vec3f{0.367314, 0.367373, 0.854469}); + normals.push_back(dl::Vec3f{0.3347, 0.6663, 0.666341}); + normals.push_back(dl::Vec3f{0.000042, 0.707079, 0.707135}); + normals.push_back(dl::Vec3f{0.36739, 0.367366, 0.854439}); + normals.push_back(dl::Vec3f{0.666288, 0.334781, 0.66632}); + normals.push_back(dl::Vec3f{0.577345, 0.577331, 0.577375}); + normals.push_back(dl::Vec3f{0.334778, 0.666285, 0.666324}); + normals.push_back(dl::Vec3f{1, 0.000046, 0.00001}); + normals.push_back(dl::Vec3f{0.923892, 0.382654, 0.000062}); + normals.push_back(dl::Vec3f{0.8545, 0.367291, 0.367325}); + normals.push_back(dl::Vec3f{0.923899, 0.000045, 0.382636}); + normals.push_back(dl::Vec3f{0.923868, 0.38271, 0}); + normals.push_back(dl::Vec3f{0.70713, 0.707083, 0.000049}); + normals.push_back(dl::Vec3f{0.666346, 0.66629, 0.334723}); + normals.push_back(dl::Vec3f{0.854463, 0.36738, 0.367322}); + normals.push_back(dl::Vec3f{0.923881, 0.000035, 0.38268}); + normals.push_back(dl::Vec3f{0.854469, 0.367314, 0.367373}); + normals.push_back(dl::Vec3f{0.666341, 0.3347, 0.6663}); + normals.push_back(dl::Vec3f{0.707135, 0.000042, 0.707079}); + normals.push_back(dl::Vec3f{0.854439, 0.36739, 0.367366}); + normals.push_back(dl::Vec3f{0.66632, 0.666288, 0.334781}); + normals.push_back(dl::Vec3f{0.577375, 0.577345, 0.577331}); + normals.push_back(dl::Vec3f{0.666324, 0.334778, 0.666285}); + normals.push_back(dl::Vec3f{0.00001, 1, 0.000046}); + normals.push_back(dl::Vec3f{0.000063, 0.923892, 0.382654}); + normals.push_back(dl::Vec3f{0.367325, 0.8545, 0.367291}); + normals.push_back(dl::Vec3f{0.382636, 0.923899, 0.000045}); + normals.push_back(dl::Vec3f{0, 0.923868, 0.38271}); + normals.push_back(dl::Vec3f{0.000049, 0.70713, 0.707083}); + normals.push_back(dl::Vec3f{0.334723, 0.666346, 0.66629}); + normals.push_back(dl::Vec3f{0.367322, 0.854463, 0.36738}); + normals.push_back(dl::Vec3f{0.38268, 0.923881, 0.000035}); + normals.push_back(dl::Vec3f{0.367373, 0.854469, 0.367314}); + normals.push_back(dl::Vec3f{0.6663, 0.666341, 0.3347}); + normals.push_back(dl::Vec3f{0.707079, 0.707135, 0.000042}); + normals.push_back(dl::Vec3f{0.367366, 0.854439, 0.36739}); + normals.push_back(dl::Vec3f{0.334781, 0.66632, 0.666288}); + normals.push_back(dl::Vec3f{0.577331, 0.577375, 0.577345}); + normals.push_back(dl::Vec3f{0.666285, 0.666324, 0.334778}); + normals.push_back(dl::Vec3f{-0.000042, -0, -1}); + normals.push_back(dl::Vec3f{-0.000042, 0, -1}); + normals.push_back(dl::Vec3f{-0.382645, 0, -0.923896}); + normals.push_back(dl::Vec3f{-0.382645, -0, -0.923896}); + normals.push_back(dl::Vec3f{-0.382722, -0, -0.923863}); + normals.push_back(dl::Vec3f{-0.382722, 0, -0.923863}); + normals.push_back(dl::Vec3f{-0.707077, 0, -0.707136}); + normals.push_back(dl::Vec3f{-0.707077, -0, -0.707136}); + normals.push_back(dl::Vec3f{-0.707136, -0, -0.707077}); + normals.push_back(dl::Vec3f{-0.707136, 0, -0.707077}); + normals.push_back(dl::Vec3f{-0.923863, 0, -0.382722}); + normals.push_back(dl::Vec3f{-0.923863, -0, -0.382722}); + normals.push_back(dl::Vec3f{-0.923896, -0, -0.382645}); + normals.push_back(dl::Vec3f{-0.923896, 0, -0.382645}); + normals.push_back(dl::Vec3f{-1, 0, -0.000042}); + normals.push_back(dl::Vec3f{-1, -0, -0.000042}); + normals.push_back(dl::Vec3f{-0.000042, -1, 0}); + normals.push_back(dl::Vec3f{-0.000042, -1, -0}); + normals.push_back(dl::Vec3f{-0.382645, -0.923896, -0}); + normals.push_back(dl::Vec3f{-0.382645, -0.923896, 0}); + normals.push_back(dl::Vec3f{-0.382722, -0.923863, 0}); + normals.push_back(dl::Vec3f{-0.382722, -0.923863, -0}); + normals.push_back(dl::Vec3f{-0.707077, -0.707136, -0}); + normals.push_back(dl::Vec3f{-0.707077, -0.707136, 0}); + normals.push_back(dl::Vec3f{-0.707136, -0.707077, 0}); + normals.push_back(dl::Vec3f{-0.707136, -0.707077, -0}); + normals.push_back(dl::Vec3f{-0.923863, -0.382722, -0}); + normals.push_back(dl::Vec3f{-0.923863, -0.382722, 0}); + normals.push_back(dl::Vec3f{-0.923896, -0.382645, 0}); + normals.push_back(dl::Vec3f{-0.923896, -0.382645, -0}); + normals.push_back(dl::Vec3f{-1, -0.000042, -0}); + normals.push_back(dl::Vec3f{-1, -0.000042, 0}); + normals.push_back(dl::Vec3f{-0.000042, 0, 1}); + normals.push_back(dl::Vec3f{-0.000042, -0, 1}); + normals.push_back(dl::Vec3f{-0.382645, -0, 0.923896}); + normals.push_back(dl::Vec3f{-0.382645, 0, 0.923896}); + normals.push_back(dl::Vec3f{-0.382722, 0, 0.923863}); + normals.push_back(dl::Vec3f{-0.382722, -0, 0.923863}); + normals.push_back(dl::Vec3f{-0.707077, -0, 0.707136}); + normals.push_back(dl::Vec3f{-0.707077, 0, 0.707136}); + normals.push_back(dl::Vec3f{-0.707136, 0, 0.707077}); + normals.push_back(dl::Vec3f{-0.707136, -0, 0.707077}); + normals.push_back(dl::Vec3f{-0.923863, -0, 0.382722}); + normals.push_back(dl::Vec3f{-0.923863, 0, 0.382722}); + normals.push_back(dl::Vec3f{-0.923896, 0, 0.382645}); + normals.push_back(dl::Vec3f{-0.923896, -0, 0.382645}); + normals.push_back(dl::Vec3f{-1, -0, 0.000042}); + normals.push_back(dl::Vec3f{-1, 0, 0.000042}); + normals.push_back(dl::Vec3f{-0.000042, 1, -0}); + normals.push_back(dl::Vec3f{-0.000042, 1, 0}); + normals.push_back(dl::Vec3f{-0.382645, 0.923896, 0}); + normals.push_back(dl::Vec3f{-0.382645, 0.923896, -0}); + normals.push_back(dl::Vec3f{-0.382722, 0.923863, -0}); + normals.push_back(dl::Vec3f{-0.382722, 0.923863, 0}); + normals.push_back(dl::Vec3f{-0.707077, 0.707136, 0}); + normals.push_back(dl::Vec3f{-0.707077, 0.707136, -0}); + normals.push_back(dl::Vec3f{-0.707136, 0.707077, -0}); + normals.push_back(dl::Vec3f{-0.707136, 0.707077, 0}); + normals.push_back(dl::Vec3f{-0.923863, 0.382722, 0}); + normals.push_back(dl::Vec3f{-0.923863, 0.382722, -0}); + normals.push_back(dl::Vec3f{-0.923896, 0.382645, -0}); + normals.push_back(dl::Vec3f{-0.923896, 0.382645, 0}); + normals.push_back(dl::Vec3f{-1, 0.000042, 0}); + normals.push_back(dl::Vec3f{-1, 0.000042, -0}); + normals.push_back(dl::Vec3f{-0, 0.000042, -1}); + normals.push_back(dl::Vec3f{0, 0.000042, -1}); + normals.push_back(dl::Vec3f{0, 0.382645, -0.923896}); + normals.push_back(dl::Vec3f{-0, 0.382645, -0.923896}); + normals.push_back(dl::Vec3f{-0, 0.382722, -0.923863}); + normals.push_back(dl::Vec3f{0, 0.382722, -0.923863}); + normals.push_back(dl::Vec3f{0, 0.707077, -0.707136}); + normals.push_back(dl::Vec3f{-0, 0.707077, -0.707136}); + normals.push_back(dl::Vec3f{-0, 0.707136, -0.707077}); + normals.push_back(dl::Vec3f{0, 0.707136, -0.707077}); + normals.push_back(dl::Vec3f{0, 0.923863, -0.382722}); + normals.push_back(dl::Vec3f{-0, 0.923863, -0.382722}); + normals.push_back(dl::Vec3f{-0, 0.923896, -0.382645}); + normals.push_back(dl::Vec3f{0, 0.923896, -0.382645}); + normals.push_back(dl::Vec3f{0, 1, -0.000042}); + normals.push_back(dl::Vec3f{-0, 1, -0.000042}); + normals.push_back(dl::Vec3f{0, 0.000042, 1}); + normals.push_back(dl::Vec3f{-0, 0.000042, 1}); + normals.push_back(dl::Vec3f{-0, 0.382645, 0.923896}); + normals.push_back(dl::Vec3f{0, 0.382645, 0.923896}); + normals.push_back(dl::Vec3f{0, 0.382722, 0.923863}); + normals.push_back(dl::Vec3f{-0, 0.382722, 0.923863}); + normals.push_back(dl::Vec3f{-0, 0.707077, 0.707136}); + normals.push_back(dl::Vec3f{0, 0.707077, 0.707136}); + normals.push_back(dl::Vec3f{0, 0.707136, 0.707077}); + normals.push_back(dl::Vec3f{-0, 0.707136, 0.707077}); + normals.push_back(dl::Vec3f{-0, 0.923863, 0.382722}); + normals.push_back(dl::Vec3f{0, 0.923863, 0.382722}); + normals.push_back(dl::Vec3f{0, 0.923896, 0.382645}); + normals.push_back(dl::Vec3f{-0, 0.923896, 0.382645}); + normals.push_back(dl::Vec3f{-0, 1, 0.000042}); + normals.push_back(dl::Vec3f{0, 1, 0.000042}); + normals.push_back(dl::Vec3f{1, 0.000042, -0}); + normals.push_back(dl::Vec3f{1, 0.000042, 0}); + normals.push_back(dl::Vec3f{0.923896, 0.382645, 0}); + normals.push_back(dl::Vec3f{0.923896, 0.382645, -0}); + normals.push_back(dl::Vec3f{0.923863, 0.382722, -0}); + normals.push_back(dl::Vec3f{0.923863, 0.382722, 0}); + normals.push_back(dl::Vec3f{0.707136, 0.707077, 0}); + normals.push_back(dl::Vec3f{0.707136, 0.707077, -0}); + normals.push_back(dl::Vec3f{0.707077, 0.707136, -0}); + normals.push_back(dl::Vec3f{0.707077, 0.707136, 0}); + normals.push_back(dl::Vec3f{0.382722, 0.923863, 0}); + normals.push_back(dl::Vec3f{0.382722, 0.923863, -0}); + normals.push_back(dl::Vec3f{0.382645, 0.923896, -0}); + normals.push_back(dl::Vec3f{0.382645, 0.923896, 0}); + normals.push_back(dl::Vec3f{0.000042, 1, 0}); + normals.push_back(dl::Vec3f{0.000042, 1, -0}); + normals.push_back(dl::Vec3f{0.000042, 0, -1}); + normals.push_back(dl::Vec3f{0.000042, -0, -1}); + normals.push_back(dl::Vec3f{0.382645, -0, -0.923896}); + normals.push_back(dl::Vec3f{0.382645, 0, -0.923896}); + normals.push_back(dl::Vec3f{0.382722, 0, -0.923863}); + normals.push_back(dl::Vec3f{0.382722, -0, -0.923863}); + normals.push_back(dl::Vec3f{0.707077, -0, -0.707136}); + normals.push_back(dl::Vec3f{0.707077, 0, -0.707136}); + normals.push_back(dl::Vec3f{0.707136, 0, -0.707077}); + normals.push_back(dl::Vec3f{0.707136, -0, -0.707077}); + normals.push_back(dl::Vec3f{0.923863, -0, -0.382722}); + normals.push_back(dl::Vec3f{0.923863, 0, -0.382722}); + normals.push_back(dl::Vec3f{0.923896, 0, -0.382645}); + normals.push_back(dl::Vec3f{0.923896, -0, -0.382645}); + normals.push_back(dl::Vec3f{1, -0, -0.000042}); + normals.push_back(dl::Vec3f{1, 0, -0.000042}); + normals.push_back(dl::Vec3f{0.000042, -0, 1}); + normals.push_back(dl::Vec3f{0.000042, 0, 1}); + normals.push_back(dl::Vec3f{0.382645, 0, 0.923896}); + normals.push_back(dl::Vec3f{0.382645, -0, 0.923896}); + normals.push_back(dl::Vec3f{0.382722, -0, 0.923863}); + normals.push_back(dl::Vec3f{0.382722, 0, 0.923863}); + normals.push_back(dl::Vec3f{0.707077, 0, 0.707136}); + normals.push_back(dl::Vec3f{0.707077, -0, 0.707136}); + normals.push_back(dl::Vec3f{0.707136, -0, 0.707077}); + normals.push_back(dl::Vec3f{0.707136, 0, 0.707077}); + normals.push_back(dl::Vec3f{0.923863, 0, 0.382722}); + normals.push_back(dl::Vec3f{0.923863, -0, 0.382722}); + normals.push_back(dl::Vec3f{0.923896, -0, 0.382645}); + normals.push_back(dl::Vec3f{0.923896, 0, 0.382645}); + normals.push_back(dl::Vec3f{1, 0, 0.000042}); + normals.push_back(dl::Vec3f{1, -0, 0.000042}); + normals.push_back(dl::Vec3f{0.000042, -1, -0}); + normals.push_back(dl::Vec3f{0.000042, -1, 0}); + normals.push_back(dl::Vec3f{0.382645, -0.923896, 0}); + normals.push_back(dl::Vec3f{0.382645, -0.923896, -0}); + normals.push_back(dl::Vec3f{0.382722, -0.923863, -0}); + normals.push_back(dl::Vec3f{0.382722, -0.923863, 0}); + normals.push_back(dl::Vec3f{0.707077, -0.707136, 0}); + normals.push_back(dl::Vec3f{0.707077, -0.707136, -0}); + normals.push_back(dl::Vec3f{0.707136, -0.707077, -0}); + normals.push_back(dl::Vec3f{0.707136, -0.707077, 0}); + normals.push_back(dl::Vec3f{0.923863, -0.382722, 0}); + normals.push_back(dl::Vec3f{0.923863, -0.382722, -0}); + normals.push_back(dl::Vec3f{0.923896, -0.382645, -0}); + normals.push_back(dl::Vec3f{0.923896, -0.382645, 0}); + normals.push_back(dl::Vec3f{1, -0.000042, 0}); + normals.push_back(dl::Vec3f{1, -0.000042, -0}); + normals.push_back(dl::Vec3f{0, -0.000042, -1}); + normals.push_back(dl::Vec3f{-0, -0.000042, -1}); + normals.push_back(dl::Vec3f{-0, -0.382645, -0.923896}); + normals.push_back(dl::Vec3f{0, -0.382645, -0.923896}); + normals.push_back(dl::Vec3f{0, -0.382722, -0.923863}); + normals.push_back(dl::Vec3f{-0, -0.382722, -0.923863}); + normals.push_back(dl::Vec3f{-0, -0.707077, -0.707136}); + normals.push_back(dl::Vec3f{0, -0.707077, -0.707136}); + normals.push_back(dl::Vec3f{0, -0.707136, -0.707077}); + normals.push_back(dl::Vec3f{-0, -0.707136, -0.707077}); + normals.push_back(dl::Vec3f{-0, -0.923863, -0.382722}); + normals.push_back(dl::Vec3f{0, -0.923863, -0.382722}); + normals.push_back(dl::Vec3f{0, -0.923896, -0.382645}); + normals.push_back(dl::Vec3f{-0, -0.923896, -0.382645}); + normals.push_back(dl::Vec3f{-0, -1, -0.000042}); + normals.push_back(dl::Vec3f{0, -1, -0.000042}); + normals.push_back(dl::Vec3f{-0, -0.000042, 1}); + normals.push_back(dl::Vec3f{0, -0.000042, 1}); + normals.push_back(dl::Vec3f{0, -0.382645, 0.923896}); + normals.push_back(dl::Vec3f{-0, -0.382645, 0.923896}); + normals.push_back(dl::Vec3f{-0, -0.382722, 0.923863}); + normals.push_back(dl::Vec3f{0, -0.382722, 0.923863}); + normals.push_back(dl::Vec3f{0, -0.707077, 0.707136}); + normals.push_back(dl::Vec3f{-0, -0.707077, 0.707136}); + normals.push_back(dl::Vec3f{-0, -0.707136, 0.707077}); + normals.push_back(dl::Vec3f{0, -0.707136, 0.707077}); + normals.push_back(dl::Vec3f{0, -0.923863, 0.382722}); + normals.push_back(dl::Vec3f{-0, -0.923863, 0.382722}); + normals.push_back(dl::Vec3f{-0, -0.923896, 0.382645}); + normals.push_back(dl::Vec3f{0, -0.923896, 0.382645}); + normals.push_back(dl::Vec3f{0, -1, 0.000042}); + normals.push_back(dl::Vec3f{-0, -1, 0.000042}); + normals.push_back(dl::Vec3f{0, 0, -1}); + normals.push_back(dl::Vec3f{0, 0, -1}); + normals.push_back(dl::Vec3f{0, 0, -1}); + normals.push_back(dl::Vec3f{0, 0, -1}); + belMeshVoxel["steps"][0]["normals"] = normals; + + dl::ds::Vector uvs; + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.160712, 0.75}); + uvs.push_back(dl::Vec2f{0.147414, 0.75}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.125, 0.727586}); + uvs.push_back(dl::Vec2f{0.125, 0.714288}); + uvs.push_back(dl::Vec2f{0.1467, 0.728297}); + uvs.push_back(dl::Vec2f{0.147414, 0.75}); + uvs.push_back(dl::Vec2f{0.140094, 0.75}); + uvs.push_back(dl::Vec2f{0.125, 0.727586}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.410712, 1}); + uvs.push_back(dl::Vec2f{0.397414, 1}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.375, 0.977586}); + uvs.push_back(dl::Vec2f{0.375, 0.964288}); + uvs.push_back(dl::Vec2f{0.3967, 0.978297}); + uvs.push_back(dl::Vec2f{0.397414, 1}); + uvs.push_back(dl::Vec2f{0.390094, 1}); + uvs.push_back(dl::Vec2f{0.375, 0.977586}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.375, 0.035712}); + uvs.push_back(dl::Vec2f{0.375, 0.022414}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.397414, 0}); + uvs.push_back(dl::Vec2f{0.410712, 0}); + uvs.push_back(dl::Vec2f{0.3967, 0.0217}); + uvs.push_back(dl::Vec2f{0.375, 0.022414}); + uvs.push_back(dl::Vec2f{0.375, 0.015094}); + uvs.push_back(dl::Vec2f{0.397414, 0}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.625, 0.964288}); + uvs.push_back(dl::Vec2f{0.625, 0.977586}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.602586, 1}); + uvs.push_back(dl::Vec2f{0.589288, 1}); + uvs.push_back(dl::Vec2f{0.603297, 0.978297}); + uvs.push_back(dl::Vec2f{0.625, 0.977586}); + uvs.push_back(dl::Vec2f{0.625, 0.9849}); + uvs.push_back(dl::Vec2f{0.602586, 1}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.875, 0.714288}); + uvs.push_back(dl::Vec2f{0.875, 0.727586}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.852586, 0.75}); + uvs.push_back(dl::Vec2f{0.839288, 0.75}); + uvs.push_back(dl::Vec2f{0.853297, 0.728297}); + uvs.push_back(dl::Vec2f{0.875, 0.727586}); + uvs.push_back(dl::Vec2f{0.875, 0.7349}); + uvs.push_back(dl::Vec2f{0.852586, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.589287, 0}); + uvs.push_back(dl::Vec2f{0.602586, 0}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.625, 0.022414}); + uvs.push_back(dl::Vec2f{0.625, 0.035712}); + uvs.push_back(dl::Vec2f{0.603297, 0.0217}); + uvs.push_back(dl::Vec2f{0.602586, 0}); + uvs.push_back(dl::Vec2f{0.6099, 0}); + uvs.push_back(dl::Vec2f{0.625, 0.022414}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.125, 0.535712}); + uvs.push_back(dl::Vec2f{0.125, 0.522414}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.147414, 0.5}); + uvs.push_back(dl::Vec2f{0.160712, 0.5}); + uvs.push_back(dl::Vec2f{0.1467, 0.5217}); + uvs.push_back(dl::Vec2f{0.125, 0.522414}); + uvs.push_back(dl::Vec2f{0.125, 0.515094}); + uvs.push_back(dl::Vec2f{0.147414, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.375, 0.227586}); + uvs.push_back(dl::Vec2f{0.375, 0.214288}); + uvs.push_back(dl::Vec2f{0.3967, 0.228297}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.390094, 0.25}); + uvs.push_back(dl::Vec2f{0.375, 0.227586}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.375, 0.285712}); + uvs.push_back(dl::Vec2f{0.375, 0.272414}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.3967, 0.2717}); + uvs.push_back(dl::Vec2f{0.375, 0.272414}); + uvs.push_back(dl::Vec2f{0.375, 0.265094}); + uvs.push_back(dl::Vec2f{0.397414, 0.25}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.839288, 0.5}); + uvs.push_back(dl::Vec2f{0.852586, 0.5}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.875, 0.522414}); + uvs.push_back(dl::Vec2f{0.875, 0.535712}); + uvs.push_back(dl::Vec2f{0.853297, 0.5217}); + uvs.push_back(dl::Vec2f{0.852586, 0.5}); + uvs.push_back(dl::Vec2f{0.8599, 0.5}); + uvs.push_back(dl::Vec2f{0.875, 0.522414}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.625, 0.272414}); + uvs.push_back(dl::Vec2f{0.625, 0.285712}); + uvs.push_back(dl::Vec2f{0.603297, 0.2717}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.6099, 0.25}); + uvs.push_back(dl::Vec2f{0.625, 0.272414}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.625, 0.214288}); + uvs.push_back(dl::Vec2f{0.625, 0.227586}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.603297, 0.228297}); + uvs.push_back(dl::Vec2f{0.625, 0.227586}); + uvs.push_back(dl::Vec2f{0.625, 0.2349}); + uvs.push_back(dl::Vec2f{0.602586, 0.25}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.352586, 0.75}); + uvs.push_back(dl::Vec2f{0.339288, 0.75}); + uvs.push_back(dl::Vec2f{0.353297, 0.728297}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.380031, 0.75}); + uvs.push_back(dl::Vec2f{0.352586, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.3967, 0.728297}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.380031, 0.75}); + uvs.push_back(dl::Vec2f{0.375, 0.727586}); + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.375, 0.785712}); + uvs.push_back(dl::Vec2f{0.375, 0.772414}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.3967, 0.7717}); + uvs.push_back(dl::Vec2f{0.375, 0.772414}); + uvs.push_back(dl::Vec2f{0.380031, 0.75}); + uvs.push_back(dl::Vec2f{0.397414, 0.75}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.660712, 0.75}); + uvs.push_back(dl::Vec2f{0.647414, 0.75}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.6467, 0.728297}); + uvs.push_back(dl::Vec2f{0.647414, 0.75}); + uvs.push_back(dl::Vec2f{0.625, 0.744969}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.625, 0.772414}); + uvs.push_back(dl::Vec2f{0.625, 0.785712}); + uvs.push_back(dl::Vec2f{0.603297, 0.7717}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.625, 0.744969}); + uvs.push_back(dl::Vec2f{0.625, 0.772414}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.603297, 0.728297}); + uvs.push_back(dl::Vec2f{0.625, 0.727586}); + uvs.push_back(dl::Vec2f{0.625, 0.744969}); + uvs.push_back(dl::Vec2f{0.602586, 0.75}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.339288, 0.5}); + uvs.push_back(dl::Vec2f{0.352586, 0.5}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.353297, 0.5217}); + uvs.push_back(dl::Vec2f{0.352586, 0.5}); + uvs.push_back(dl::Vec2f{0.375, 0.505031}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.375, 0.477586}); + uvs.push_back(dl::Vec2f{0.375, 0.464288}); + uvs.push_back(dl::Vec2f{0.3967, 0.478297}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.375, 0.505031}); + uvs.push_back(dl::Vec2f{0.375, 0.477586}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.3967, 0.5217}); + uvs.push_back(dl::Vec2f{0.375, 0.522414}); + uvs.push_back(dl::Vec2f{0.375, 0.505031}); + uvs.push_back(dl::Vec2f{0.397414, 0.5}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.647414, 0.5}); + uvs.push_back(dl::Vec2f{0.660712, 0.5}); + uvs.push_back(dl::Vec2f{0.6467, 0.5217}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.619969, 0.5}); + uvs.push_back(dl::Vec2f{0.647414, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.603297, 0.5217}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.619969, 0.5}); + uvs.push_back(dl::Vec2f{0.625, 0.522414}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.625, 0.464288}); + uvs.push_back(dl::Vec2f{0.625, 0.477586}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.603297, 0.478297}); + uvs.push_back(dl::Vec2f{0.625, 0.477586}); + uvs.push_back(dl::Vec2f{0.619969, 0.5}); + uvs.push_back(dl::Vec2f{0.602586, 0.5}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.147046, 0.535712}); + uvs.push_back(dl::Vec2f{0.147046, 0.714288}); + uvs.push_back(dl::Vec2f{0.125, 0.714288}); + uvs.push_back(dl::Vec2f{0.125, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.214288}); + uvs.push_back(dl::Vec2f{0.375, 0.035712}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.397046, 0.214288}); + uvs.push_back(dl::Vec2f{0.397046, 0.035712}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.410712, 0.977954}); + uvs.push_back(dl::Vec2f{0.589288, 0.977954}); + uvs.push_back(dl::Vec2f{0.589288, 1}); + uvs.push_back(dl::Vec2f{0.410712, 1}); + uvs.push_back(dl::Vec2f{0.410712, 0}); + uvs.push_back(dl::Vec2f{0.589287, 0}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.410712, 0.022046}); + uvs.push_back(dl::Vec2f{0.589288, 0.022046}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.410712, 0.035712}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.852954, 0.714288}); + uvs.push_back(dl::Vec2f{0.852954, 0.535712}); + uvs.push_back(dl::Vec2f{0.875, 0.535712}); + uvs.push_back(dl::Vec2f{0.875, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.035712}); + uvs.push_back(dl::Vec2f{0.625, 0.214288}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.602954, 0.035712}); + uvs.push_back(dl::Vec2f{0.602954, 0.214288}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.589288, 0.035712}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.589288, 0.272046}); + uvs.push_back(dl::Vec2f{0.410712, 0.272046}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.589288, 0.25}); + uvs.push_back(dl::Vec2f{0.410712, 0.25}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.589288, 0.227954}); + uvs.push_back(dl::Vec2f{0.410712, 0.227954}); + uvs.push_back(dl::Vec2f{0.410712, 0.214288}); + uvs.push_back(dl::Vec2f{0.589288, 0.214288}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.339288, 0.522046}); + uvs.push_back(dl::Vec2f{0.160712, 0.522046}); + uvs.push_back(dl::Vec2f{0.160712, 0.5}); + uvs.push_back(dl::Vec2f{0.339288, 0.5}); + uvs.push_back(dl::Vec2f{0.375, 0.464288}); + uvs.push_back(dl::Vec2f{0.375, 0.285712}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.397046, 0.464288}); + uvs.push_back(dl::Vec2f{0.397046, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.285712}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.839288, 0.535712}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.839288, 0.522046}); + uvs.push_back(dl::Vec2f{0.660712, 0.522046}); + uvs.push_back(dl::Vec2f{0.660712, 0.5}); + uvs.push_back(dl::Vec2f{0.839288, 0.5}); + uvs.push_back(dl::Vec2f{0.625, 0.285712}); + uvs.push_back(dl::Vec2f{0.625, 0.464288}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.602954, 0.285712}); + uvs.push_back(dl::Vec2f{0.602954, 0.464288}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.589288, 0.285712}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.589288, 0.522046}); + uvs.push_back(dl::Vec2f{0.410712, 0.522046}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.589288, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.5}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.589288, 0.477954}); + uvs.push_back(dl::Vec2f{0.410712, 0.477954}); + uvs.push_back(dl::Vec2f{0.410712, 0.464288}); + uvs.push_back(dl::Vec2f{0.589288, 0.464288}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.352954, 0.714288}); + uvs.push_back(dl::Vec2f{0.352954, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.714288}); + uvs.push_back(dl::Vec2f{0.375, 0.535712}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.397046, 0.714288}); + uvs.push_back(dl::Vec2f{0.397046, 0.535712}); + uvs.push_back(dl::Vec2f{0.410712, 0.535713}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.660712, 0.535712}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.647046, 0.535712}); + uvs.push_back(dl::Vec2f{0.647046, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.535712}); + uvs.push_back(dl::Vec2f{0.625, 0.714288}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.602954, 0.535712}); + uvs.push_back(dl::Vec2f{0.602954, 0.714288}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.589288, 0.535713}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.589288, 0.772046}); + uvs.push_back(dl::Vec2f{0.410712, 0.772046}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.589288, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.75}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.589288, 0.727954}); + uvs.push_back(dl::Vec2f{0.410712, 0.727954}); + uvs.push_back(dl::Vec2f{0.410712, 0.714288}); + uvs.push_back(dl::Vec2f{0.589288, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.160712, 0.727954}); + uvs.push_back(dl::Vec2f{0.339288, 0.727954}); + uvs.push_back(dl::Vec2f{0.339288, 0.75}); + uvs.push_back(dl::Vec2f{0.160712, 0.75}); + uvs.push_back(dl::Vec2f{0.375, 0.964288}); + uvs.push_back(dl::Vec2f{0.375, 0.785712}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.397046, 0.964288}); + uvs.push_back(dl::Vec2f{0.397046, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.785712}); + uvs.push_back(dl::Vec2f{0.410712, 0.964288}); + uvs.push_back(dl::Vec2f{0.660712, 0.714288}); + uvs.push_back(dl::Vec2f{0.839287, 0.714288}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.660712, 0.727954}); + uvs.push_back(dl::Vec2f{0.839288, 0.727954}); + uvs.push_back(dl::Vec2f{0.839288, 0.75}); + uvs.push_back(dl::Vec2f{0.660712, 0.75}); + uvs.push_back(dl::Vec2f{0.625, 0.785712}); + uvs.push_back(dl::Vec2f{0.625, 0.964288}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.602954, 0.785712}); + uvs.push_back(dl::Vec2f{0.602954, 0.964288}); + uvs.push_back(dl::Vec2f{0.589288, 0.964287}); + uvs.push_back(dl::Vec2f{0.589288, 0.785712}); + uvs.push_back(dl::Vec2f{0.160712, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.535712}); + uvs.push_back(dl::Vec2f{0.339288, 0.714288}); + uvs.push_back(dl::Vec2f{0.160712, 0.714288}); + belMeshVoxel["steps"][0]["uvs"] = uvs; + + dl::ds::Vector points; + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{-0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{-0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{-0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.409055, -0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.40624, -0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.409055, -0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.409055, -0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.40624, -0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.471243, -0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, -0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.435228, -0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, -0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.409055, 0.409055, -0.471243}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, -0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.40624, 0.446387, -0.446387}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, -0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.40624, -0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, -0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.446387, -0.40624}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.409055, 0.409055, 0.471243}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.471243, 0.409055, 0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.40624, 0.446387}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.409055, 0.471243, 0.409055}); + points.push_back(dl::Pos3f{0.40624, 0.446387, 0.446387}); + points.push_back(dl::Pos3f{0.435228, 0.435228, 0.435228}); + points.push_back(dl::Pos3f{0.446387, 0.446387, 0.40624}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{-0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{-0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{-0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{-0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, 0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, 0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, 0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, -0.484235}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.453579, -0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.453579, 0.353579, -0.453579}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.353579, -0.407698}); + points.push_back(dl::Pos3f{0.495, 0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.353579, 0.353579, 0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.407698, 0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.407698, -0.353579, 0.484235}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.453579, 0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.453579, -0.353579, 0.453579}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, 0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.484235, -0.353579, 0.407698}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.495, 0.353579, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, 0.353579}); + points.push_back(dl::Pos3f{0.407698, -0.484235, -0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, 0.353579}); + points.push_back(dl::Pos3f{0.453579, -0.453579, -0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, 0.353579}); + points.push_back(dl::Pos3f{0.484235, -0.407698, -0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, -0.353579}); + points.push_back(dl::Pos3f{0.495, -0.353579, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, -0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.453579, -0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.484235, -0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{-0.353579, -0.495, -0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, 0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.407698, 0.484235}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.453579, 0.453579}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.484235, 0.407698}); + points.push_back(dl::Pos3f{-0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{0.353579, -0.495, 0.353579}); + points.push_back(dl::Pos3f{-0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, 0.353579, -0.495}); + points.push_back(dl::Pos3f{0.353579, -0.353579, -0.495}); + points.push_back(dl::Pos3f{-0.353579, -0.353579, -0.495}); + belMeshVoxel["steps"][0]["points"] = points; + } + } +} \ No newline at end of file diff --git a/oom_bella_scene.h b/oom_bella_scene.h new file mode 100644 index 0000000..56fef27 --- /dev/null +++ b/oom_bella_scene.h @@ -0,0 +1,108 @@ +#pragma once + +// Bella SDK includes - external libraries for 3D rendering +#include "../bella_scene_sdk/src/bella_sdk/bella_scene.h" // For creating and manipulating 3D scenes in Bella +//#include "../bella_scene_sdk/src/dl_core/dl_main.inl" // Core functionality from the Diffuse Logic engine + +// Define the oom namespace +namespace oom { + namespace bella { + // Function declaration + dl::bella_sdk::Node essentialsToScene(dl::bella_sdk::Scene& belScene); + + // @param belScene - the scene to create the essentials in + // @return - the world node + dl::bella_sdk::Node essentialsToScene(dl::bella_sdk::Scene& belScene) { + // Create the basic scene elements in Bella + // Each line creates a different type of node in the scene auto belBeautyPass = belScene.createNode("beautyPass","oomerBeautyPass","oomerBeautyPass"); + auto belWorld = belScene.world(); // Get scene world root + { + dl::bella_sdk::Scene::EventScope es(belScene); + + auto belCamForm = belScene.createNode("xform","oomerCameraXform","oomerCameraXform"); + auto belCam = belScene.createNode("camera","oomerCamera","oomerCamera"); + auto belSensor = belScene.createNode("sensor","oomerSensor","oomerSensor"); + auto belLens = belScene.createNode("thinLens","oomerThinLens","oomerThinLens"); + auto belImageDome = belScene.createNode("imageDome","oomerImageDome","oomerImageDome"); + auto belGroundPlane = belScene.createNode("groundPlane","oomerGroundPlane","oomerGroundPlane"); + + auto belBeautyPass = belScene.createNode("beautyPass","oomerBeautyPass","oomerBeautyPass"); + auto belGroundMat = belScene.createNode("quickMaterial","oomerGroundMat","oomerGroundMat"); + auto belSun = belScene.createNode("sun","oomerSun","oomerSun"); + auto belColorDome = belScene.createNode("colorDome","oomerColorDome","oomerColorDome"); + auto belSettings = belScene.settings(); // Get scene settings + // Configure camera + belCam["resolution"] = dl::Vec2 {1920, 1080}; // Set resolution to 1080p + belCam["lens"] = belLens; // Connect camera to lens + belCam["sensor"] = belSensor; // Connect camera to sensor + belCamForm.parentTo(belWorld); // Parent camera transform to world + belCam.parentTo(belCamForm); // Parent camera to camera transform + + // Position the camera with a transformation matrix + belCamForm["steps"][0]["xform"] = dl::Mat4 {0.525768608156, -0.850627633385, 0, 0, -0.234464751651, -0.144921468924, -0.961261695938, 0, 0.817675761479, 0.505401223947, -0.275637355817, 0, -88.12259018466, -54.468125200218, 50.706001690932, 1}; + + // Configure environment (image-based lighting) + belImageDome["ext"] = ".jpg"; + belImageDome["dir"] = "./res"; + belImageDome["multiplier"] = 6.0f; + belImageDome["file"] = "DayEnvironmentHDRI019_1K-TONEMAPPED"; + belImageDome["overrides"]["background"] = belColorDome; + belColorDome["zenith"] = dl::Rgba{1.0f, 1.0f, 1.0f, 1.0f}; + belColorDome["horizon"] = dl::Rgba{.85f, 0.76f, 0.294f, 1.0f}; + belColorDome["altitude"] = 14.0f; + // Configure ground plane + //belGroundPlane["elevation"] = -.5f; + belGroundPlane["material"] = belGroundMat; + + /* Commented out: Sun configuration + belSun["size"] = 20.0f; + belSun["month"] = "july"; + belSun["rotation"] = 50.0f;*/ + + // Configure materials + belGroundMat["type"] = "metal"; + belGroundMat["roughness"] = 22.0f; + belGroundMat["color"] = dl::Rgba{0.138431623578, 0.5, 0.3, 1.0}; + + // Set up scene settings + belSettings["beautyPass"] = belBeautyPass; + belSettings["camera"] = belCam; + belSettings["environment"] = belColorDome; + belSettings["iprScale"] = 100.0f; + belSettings["threads"] = dl::bella_sdk::Input(0); // Auto-detect thread count + belSettings["groundPlane"] = belGroundPlane; + belSettings["iprNavigation"] = "maya"; // Use Maya-like navigation in viewer + //settings["sun"] = sun; + + auto belVoxel = belScene.createNode("box","oomerVoxel","oomerVoxel"); + auto belLiqVoxel = belScene.createNode("box","oomerLiqVoxel","oomerLiqVoxel"); + auto belVoxelForm = belScene.createNode("xform","oomerVoxelXform","oomerVoxelXform"); + auto belLiqVoxelForm = belScene.createNode("xform","oomerLiqVoxelXform","oomerLiqVoxelXform"); + auto belVoxelMat = belScene.createNode("orenNayar","oomerVoxelMat","oomerVoxelMat"); + auto belMeshVoxel = belScene.createNode("mesh", "oomerMeshVoxel"); + auto belBevel = belScene.createNode("bevel", "oomerBevel"); + belBevel["radius"] = 90.0f; + belBevel["samples"] =dl::UInt(6); + + //#include "resources/smoothcube.h" + addMeshCube(belMeshVoxel); + // Configure voxel box dimensions + belVoxel["radius"] = 0.33f; + belVoxel["sizeX"] = 0.99f; + belVoxel["sizeY"] = 0.99f; + belVoxel["sizeZ"] = 0.99f; + + // Less gap to make liquid look better, allows more light to pass through + belLiqVoxel["sizeX"] = 0.99945f; + belLiqVoxel["sizeY"] = 0.99945f; + belLiqVoxel["sizeZ"] = 0.99945f; + + belVoxel.parentTo(belVoxelForm); + belVoxelForm["steps"][0]["xform"] = dl::Mat4 {0.999,0,0,0,0,0.999,0,0,0,0,0.999,0,0,0,0,1}; + belVoxelMat["reflectance"] = dl::Rgba{0.0, 0.0, 0.0, 1.0}; + belVoxelForm["material"] = belVoxelMat; + } + return belWorld; + } + } +} diff --git a/oom_license.h b/oom_license.h new file mode 100644 index 0000000..3caee9f --- /dev/null +++ b/oom_license.h @@ -0,0 +1,90 @@ +#pragma once + +#include + +namespace oom { + namespace license { + // R"(...)" is a C++ raw string literal - allows multi-line strings with preserved formatting + inline std::string printLicense() { return R"( +MIT License + +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.)"; + } + + inline std::string printBellaSDK() { return R"( +Bella SDK (Software Development Kit) + +Copyright Diffuse Logic SCP, all rights reserved. + +Permission is hereby granted to any person obtaining a copy of this software +(the "Software"), to use, copy, publish, distribute, sublicense, and/or sell +copies of the Software. + +THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL +IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY +ARE HEREBY DISCLAIMED.)"; + } + + inline std::string printOpenGameTools() { return R"( +opengametools +https://github.com/jpaver/opengametools + +MIT License + +Copyright (c) 2019 Justin Paver + +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.)"; + } + + inline std::string printLZFSE() { return R"( +lzfse +https://github.com/lzfse/lzfse + +Copyright (c) 2015-2016, Apple Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. 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. + +3. Neither the name of the copyright holder(s) nor the names of any 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.)"; + } + + inline std::string printLibPlist() { return R"( +libplist +https://github.com/libimobiledevice/libplist + +This software uses libraries from the libplist project under the LGPL version 2.1.)"; + } + } +} \ No newline at end of file diff --git a/oom_misc.h b/oom_misc.h new file mode 100644 index 0000000..7e79587 --- /dev/null +++ b/oom_misc.h @@ -0,0 +1,1530 @@ +#pragma once +#include // For std::string +#include +#include // For std::ofstream +#include // For std::filesystem +//#include "DayEnvironmentHDRI019_1K-TONEMAPPED.h" // embedded image dome light +#include // For std::pow + +/*extern const unsigned int DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len; +extern const unsigned char DayEnvironmentHDRI019_1K_TONEMAPPED_jpg[]; +inline float srgbToLinear(float value); +inline std::vector LZFSEToArray(const std::string& lzfseFullName); +inline std::vector decompressLZFSE(const std::string& dirName, const std::string& compressedName); +inline void saveHDRI(); +*/ + +namespace oom { + namespace misc { + //Forward declarations + extern const unsigned char DayEnvironmentHDRI019_1K_TONEMAPPED_jpg[]; + extern const unsigned int DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len; + // Convert sRGB color value to linear color space + inline float srgbToLinear(float value) { + return (value <= 0.04045f) ? + (value * (1.0f/12.92f)) : + std::pow((value + 0.055f) * (1.0f/1.055f), 2.4f); + } + + // read binary compressed LZFSE file into an array + inline std::vector LZFSEToArray(const std::string& lzfseFullName) { + std::ifstream lzfseFile(lzfseFullName, std::ios::binary); + if (!lzfseFile.is_open()) { + std::cerr << "Error: Could not open LZFSE file: " << lzfseFullName << std::endl; + throw std::runtime_error("Error message"); + } + // Get file size using std::filesystem + size_t lzfseFileSize = std::filesystem::file_size(lzfseFullName); + + // store the lzfse file in a memory buffer + std::vector lzfseArray(lzfseFileSize); + lzfseFile.read(reinterpret_cast(lzfseArray.data()), lzfseFileSize); + lzfseFile.close(); + return lzfseArray; + } + + // read binary compressed LZFSE file + // Why not use liblzfse directly? + // @param dirName: the name of the directory containing the LZFSE file + // @param compressedName: the name of the LZFSE file to decompress + inline std::vector decompressLZFSE(const std::string& dirName, const std::string& compressedName) { + std::string lzfseFullName = dirName + "/"+compressedName; + + std::cout << "Decompressing LZFSE file: " << lzfseFullName << std::endl; + std::ifstream lzfseFile(lzfseFullName, std::ios::binary); + if (!lzfseFile.is_open()) { + std::cerr << "Error: Could not open input file: " << lzfseFullName << std::endl; + throw std::runtime_error("Error message"); + } + + // Get lzfse file size and read content + lzfseFile.seekg(0, std::ios::end); + size_t lzfseFileSize = lzfseFile.tellg(); + lzfseFile.seekg(0, std::ios::beg); + // store the lzfse file in a memory buffer + std::vector lzfseBuffer(lzfseFileSize); + lzfseFile.read(reinterpret_cast(lzfseBuffer.data()), lzfseFileSize); + lzfseFile.close(); + return lzfseBuffer; + } + + // Function that saves the embedded HDRI file to the res directory + // Allows executable to be moved around without the HDRI file + inline void saveHDRI() { + // Create hdri file if it doesn't exist + std::string hdriName = "DayEnvironmentHDRI019_1K-TONEMAPPED.jpg"; + std::string resDir= "./res"; + std::filesystem::path hdriFile = std::filesystem::path(resDir) / hdriName; + if (!std::filesystem::exists(hdriFile)) { + std::cout << "HDRI file not found, creating it" << std::endl; + std::filesystem::create_directories(resDir); + std::ofstream outFile(hdriFile, std::ios::binary); + if (!outFile) { + std::cerr << "HDRI failed to write" << hdriFile << std::endl; + } + + // Write the data to the file using the exact length + outFile.write(reinterpret_cast(DayEnvironmentHDRI019_1K_TONEMAPPED_jpg), + DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len); + // Check if write was successful + if (!outFile) { + std::cerr << "HDRI failed to write" << hdriFile << std::endl; + } + } + } + + + inline std::string printDayEnvironmentHDRI019_1K_TONEMAPPEDLicence() { + return R"( + DayEnvironmentHDRI019_1K-TONEMAPPED.jpg from ambientCG.com, + licensed under the Creative Commons CC0 1.0 Universal License.)"; + } + + const unsigned char DayEnvironmentHDRI019_1K_TONEMAPPED_jpg[] = { + 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xe1, 0x00, 0x4c, + 0x45, 0x78, 0x69, 0x66, 0x00, 0x00, 0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, + 0x00, 0x08, 0x00, 0x01, 0x87, 0x69, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xa0, 0x01, + 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xa0, 0x02, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0xa0, 0x03, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xed, 0x00, 0x38, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x73, + 0x68, 0x6f, 0x70, 0x20, 0x33, 0x2e, 0x30, 0x00, 0x38, 0x42, 0x49, 0x4d, + 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x42, 0x49, 0x4d, + 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xd4, 0x1d, 0x8c, 0xd9, + 0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e, + 0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0x80, 0x01, 0x00, 0x03, 0x01, 0x22, + 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00, 0x1f, 0x00, + 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00, 0x02, 0x01, + 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, + 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, + 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, + 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, + 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, + 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, + 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, + 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, + 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, + 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, + 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, + 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, + 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, + 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01, + 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00, 0x02, 0x01, + 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, + 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, + 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, + 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, + 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, + 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, + 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, + 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, + 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, + 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, + 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, + 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, + 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, + 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xdb, 0x00, 0x43, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x03, 0x04, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x04, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x01, 0x01, 0x01, + 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x03, 0x08, 0x05, 0x05, 0x05, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0xff, 0xdd, 0x00, 0x04, 0x00, 0x10, 0xff, 0xda, 0x00, 0x0c, 0x03, + 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xfa, 0xdf, 0x42, + 0xf8, 0xbd, 0xf0, 0x27, 0xc4, 0xba, 0xde, 0x9b, 0xa5, 0xf8, 0x66, 0xcf, + 0x52, 0xd3, 0x5a, 0xee, 0xe0, 0x45, 0x73, 0x71, 0xe2, 0x49, 0x9e, 0x44, + 0x47, 0x2d, 0x80, 0x90, 0x3c, 0x77, 0xf0, 0xc3, 0x33, 0x1c, 0x81, 0xe5, + 0xab, 0x79, 0x81, 0x8e, 0x0a, 0x82, 0x40, 0xa8, 0xfe, 0x24, 0x7c, 0x46, + 0xf0, 0xad, 0x8e, 0x93, 0x3d, 0xcf, 0x85, 0x2c, 0xb4, 0x6d, 0x58, 0xd9, + 0x4a, 0x12, 0xe7, 0xed, 0x45, 0x92, 0xe0, 0xb0, 0x38, 0x65, 0x5b, 0x51, + 0x3c, 0x93, 0x7c, 0xa3, 0xae, 0xe6, 0xc9, 0xe9, 0xd6, 0xbe, 0x29, 0xf8, + 0x2f, 0xf1, 0x8e, 0xf7, 0xc4, 0x16, 0x97, 0x9e, 0x1f, 0xd1, 0x27, 0xd3, + 0x24, 0xd5, 0x6f, 0x60, 0x86, 0xc9, 0xf4, 0xcb, 0xab, 0x8b, 0x58, 0x96, + 0x26, 0x54, 0x60, 0x8b, 0x0c, 0x33, 0xc9, 0x1a, 0x3e, 0xc2, 0x79, 0x68, + 0xc2, 0x30, 0x04, 0x90, 0xc1, 0x9b, 0x23, 0xdf, 0xbf, 0x67, 0xdf, 0xd9, + 0xcf, 0x58, 0xf8, 0xcf, 0x26, 0x94, 0x87, 0xfe, 0x15, 0xe4, 0x72, 0xa6, + 0xa9, 0x34, 0xf7, 0xe6, 0xf3, 0x53, 0x37, 0x71, 0xcf, 0x35, 0xaa, 0x10, + 0xb1, 0xbd, 0x94, 0x12, 0xde, 0x32, 0xc8, 0xec, 0x00, 0x25, 0x23, 0x52, + 0xa0, 0x38, 0x04, 0x73, 0xb7, 0xf8, 0xa6, 0x18, 0x4a, 0x78, 0xc7, 0x2a, + 0x36, 0xb3, 0xd3, 0x4d, 0x7f, 0xcd, 0x2f, 0x3e, 0xde, 0x76, 0xdb, 0x86, + 0x35, 0x64, 0xd2, 0xe5, 0x3c, 0x13, 0xe2, 0x17, 0xed, 0x91, 0xf0, 0xdf, + 0xc2, 0xda, 0xb6, 0x75, 0x5d, 0x3b, 0xc3, 0x46, 0x35, 0x83, 0x65, 0xcc, + 0x3a, 0x4c, 0x3a, 0x84, 0x12, 0xc2, 0x70, 0x4e, 0xe2, 0x24, 0x55, 0xfd, + 0xe0, 0xce, 0x08, 0x66, 0x2a, 0x4f, 0x7a, 0xf1, 0x19, 0xff, 0x00, 0x6d, + 0x4f, 0x00, 0x6a, 0x96, 0x8f, 0x36, 0x8b, 0xa7, 0x25, 0xcc, 0x0d, 0x9d, + 0xf2, 0x3d, 0xca, 0x45, 0x3c, 0x61, 0x9b, 0x68, 0xdb, 0xe6, 0x4c, 0x84, + 0x9f, 0x40, 0xbd, 0x0f, 0x04, 0xe6, 0xbe, 0xc8, 0xf8, 0xef, 0xff, 0x00, + 0x04, 0xfc, 0xbd, 0x16, 0xba, 0xcf, 0x8a, 0x74, 0xb3, 0xa4, 0x58, 0x43, + 0xa0, 0x5e, 0x3d, 0xbe, 0xb3, 0xa2, 0xe9, 0xd3, 0x4b, 0xf6, 0x98, 0xae, + 0x19, 0x41, 0x12, 0x5a, 0xd9, 0xdd, 0x4d, 0x24, 0xcd, 0x0b, 0x87, 0x43, + 0x1b, 0x3a, 0xc6, 0xaf, 0xc8, 0x54, 0x0c, 0x18, 0x57, 0xd1, 0xbf, 0x05, + 0xff, 0x00, 0x67, 0xbf, 0xd8, 0x7b, 0xe3, 0x0f, 0xc1, 0xb3, 0xa3, 0xe9, + 0xfe, 0x18, 0xf0, 0x34, 0x5a, 0xc8, 0x86, 0x1b, 0x5d, 0x46, 0xf7, 0xc5, + 0xb3, 0xdd, 0x5a, 0x6b, 0x92, 0x5e, 0x18, 0x42, 0x3a, 0x59, 0xdb, 0xc6, + 0x65, 0xb5, 0x95, 0x8c, 0xc4, 0x98, 0xda, 0x46, 0x51, 0xb5, 0x01, 0x96, + 0x0e, 0x41, 0x3e, 0xde, 0x17, 0x83, 0xf0, 0x55, 0x2d, 0x4e, 0xa2, 0x69, + 0xa5, 0x7d, 0x64, 0xd2, 0xb6, 0xbb, 0x2e, 0xb7, 0xf2, 0x6c, 0xc6, 0xf5, + 0x5c, 0xac, 0xda, 0x3f, 0x0e, 0xb5, 0xff, 0x00, 0xda, 0x0f, 0xed, 0x9a, + 0xbb, 0xda, 0xe8, 0x7a, 0x8e, 0xbb, 0xa7, 0x94, 0x21, 0xd8, 0xdd, 0xcf, + 0x95, 0xc1, 0x3c, 0x28, 0x55, 0x94, 0x6d, 0xe3, 0xfb, 0xcc, 0x7e, 0x95, + 0x9f, 0xab, 0xfc, 0x6a, 0xf1, 0x15, 0xc5, 0x93, 0xdc, 0xdb, 0x78, 0xae, + 0xea, 0x08, 0xbe, 0x48, 0x61, 0x8d, 0xd9, 0x24, 0x99, 0xe5, 0x23, 0x24, + 0x66, 0xdd, 0xb7, 0xf6, 0x3c, 0x14, 0x07, 0xa7, 0x24, 0xd7, 0xea, 0xcc, + 0x3f, 0xf0, 0x4f, 0x7f, 0x81, 0x9e, 0x07, 0xf1, 0xc3, 0x78, 0x7b, 0xc6, + 0x7a, 0x15, 0xb4, 0xba, 0x8e, 0xa9, 0xac, 0xdb, 0x6a, 0x1a, 0x5c, 0x9e, + 0x1c, 0xf1, 0x85, 0x95, 0x99, 0x02, 0x79, 0x04, 0x09, 0x6d, 0x04, 0x32, + 0xd9, 0x5d, 0xc5, 0x2d, 0xab, 0xcf, 0xb8, 0x00, 0x63, 0xf3, 0x97, 0x85, + 0xd8, 0x54, 0x12, 0xdf, 0x70, 0xfc, 0x5c, 0xff, 0x00, 0x82, 0x4a, 0xfe, + 0xc4, 0x96, 0x3f, 0x0c, 0xa3, 0xd7, 0x6e, 0xa3, 0xf1, 0x77, 0x87, 0x75, + 0xb3, 0x75, 0x25, 0xdc, 0x3a, 0x3b, 0xdf, 0xd9, 0xc9, 0x79, 0x1b, 0xe5, + 0x99, 0x61, 0x68, 0x63, 0xb3, 0xf3, 0x66, 0x54, 0x54, 0x60, 0x8f, 0xb8, + 0x06, 0x05, 0x4e, 0xd0, 0x32, 0xab, 0xee, 0xd3, 0xe1, 0xcc, 0x2d, 0x3a, + 0x52, 0x92, 0x76, 0xe4, 0x57, 0x77, 0x49, 0x3b, 0x79, 0x5d, 0x5a, 0xef, + 0xb5, 0xfe, 0xf3, 0x38, 0xe1, 0x6a, 0x4a, 0xfa, 0x9f, 0x80, 0xde, 0x0c, + 0x3a, 0xb6, 0xa5, 0xa5, 0x4f, 0xaa, 0x78, 0x93, 0xc6, 0xda, 0xcb, 0xcb, + 0x0a, 0x3c, 0x83, 0x4f, 0xb2, 0x32, 0x99, 0x51, 0x97, 0x8f, 0xde, 0xf0, + 0xec, 0x99, 0x6e, 0x00, 0x61, 0xed, 0xc1, 0xa9, 0xb4, 0x1b, 0xed, 0x37, + 0x53, 0xb1, 0x9b, 0x5b, 0xd5, 0xfe, 0x21, 0x5e, 0xe9, 0x91, 0xc5, 0xbd, + 0x61, 0x85, 0x1a, 0x2b, 0xd9, 0xdc, 0xae, 0x0e, 0x5a, 0x0b, 0xa9, 0xa2, + 0xca, 0xe0, 0xf5, 0x4c, 0x91, 0xd4, 0xa8, 0x1c, 0xd7, 0x73, 0xfb, 0x4f, + 0x69, 0xff, 0x00, 0xb2, 0xcf, 0xc2, 0x3d, 0x06, 0x1f, 0x0e, 0xf8, 0x0e, + 0xc2, 0xf6, 0x0b, 0xf8, 0xef, 0x21, 0xb9, 0xbf, 0x92, 0xe4, 0xdc, 0x4f, + 0xa8, 0x0f, 0x25, 0x36, 0xfc, 0xd1, 0xcc, 0xfe, 0x4b, 0x39, 0xdc, 0x0c, + 0xb1, 0x3a, 0xac, 0x71, 0x90, 0x81, 0x9f, 0x92, 0x95, 0xf1, 0x6e, 0x93, + 0xe0, 0x1d, 0x6f, 0xe2, 0x1c, 0x56, 0xf2, 0x68, 0xba, 0x0d, 0xf3, 0xb3, + 0x4b, 0x24, 0xb7, 0x17, 0xf7, 0x52, 0x88, 0xe2, 0x98, 0xba, 0x2c, 0x8b, + 0x1c, 0x51, 0xd9, 0x59, 0x92, 0x82, 0x25, 0x60, 0x15, 0x99, 0xb6, 0x93, + 0x9c, 0x95, 0x1c, 0x2f, 0x89, 0x86, 0xc2, 0x29, 0x27, 0x5a, 0x55, 0x5a, + 0x57, 0xed, 0x14, 0xad, 0xe5, 0x74, 0xbf, 0xaf, 0xc2, 0x5d, 0x2b, 0x3e, + 0x57, 0xfa, 0x9f, 0x49, 0x2f, 0x8c, 0xfe, 0x1d, 0xdc, 0x58, 0x48, 0x20, + 0xf1, 0x6f, 0x8a, 0x6f, 0x25, 0x8f, 0x20, 0xdd, 0xc6, 0x96, 0x71, 0xc4, + 0x1c, 0x63, 0xe5, 0x68, 0x4a, 0x92, 0xc4, 0x93, 0xd0, 0x48, 0xb8, 0xc8, + 0x19, 0x6e, 0x33, 0xcd, 0x78, 0x73, 0xc4, 0x5a, 0x7e, 0xa7, 0xaa, 0x32, + 0xea, 0x5e, 0x2e, 0xd5, 0xb4, 0x7b, 0x21, 0x38, 0x56, 0xbe, 0xbe, 0xb4, + 0x12, 0xc2, 0x01, 0x5d, 0xd8, 0x22, 0x34, 0x99, 0x81, 0xc1, 0xc8, 0xda, + 0xac, 0x00, 0xeb, 0xe9, 0x5f, 0x3d, 0x68, 0x96, 0x5e, 0x38, 0xf0, 0xf4, + 0xf2, 0x4d, 0x6d, 0xe1, 0x4d, 0x37, 0x54, 0x4b, 0x8b, 0xe5, 0x89, 0xed, + 0x2e, 0x7c, 0xc9, 0x9e, 0x56, 0x5d, 0xbb, 0x81, 0xb9, 0x8e, 0x6d, 0xd0, + 0x6f, 0x0d, 0xc3, 0x89, 0x53, 0x0c, 0x09, 0x52, 0x73, 0x5f, 0x5d, 0xfc, + 0x56, 0xfd, 0xb0, 0xfc, 0x65, 0xf1, 0x43, 0x46, 0xd1, 0xbe, 0x1a, 0x5d, + 0x78, 0x1b, 0xc1, 0xde, 0x06, 0xb2, 0xd1, 0x8c, 0x11, 0x35, 0xbe, 0x8f, + 0x02, 0xdf, 0x5f, 0x08, 0x18, 0x36, 0xd8, 0xe6, 0xb8, 0xbd, 0xb8, 0x96, + 0x6b, 0x86, 0xf9, 0x87, 0xca, 0xf3, 0x33, 0x73, 0x8f, 0x97, 0x21, 0x6b, + 0xd4, 0xfa, 0x85, 0x25, 0x09, 0x4e, 0x15, 0x5b, 0x6e, 0xda, 0x5e, 0x3b, + 0x75, 0x7b, 0x3f, 0xf8, 0x73, 0x29, 0x2e, 0xe7, 0xa7, 0x5b, 0xf8, 0x3f, + 0xe1, 0xee, 0xa3, 0xaf, 0x59, 0xe8, 0x7e, 0x1f, 0xf8, 0x81, 0xfd, 0xa4, + 0xd7, 0xc8, 0x25, 0xb7, 0xd4, 0x75, 0x48, 0x3f, 0xb2, 0xad, 0x58, 0x3e, + 0x55, 0x5f, 0x33, 0x5b, 0xf1, 0x19, 0x6c, 0xe1, 0xdb, 0x0a, 0x71, 0xce, + 0x06, 0x4d, 0x7a, 0xd6, 0x9d, 0xfb, 0x31, 0x78, 0x9e, 0x7d, 0x4e, 0x3b, + 0x0d, 0x2f, 0xc6, 0x7a, 0x1c, 0xf2, 0x99, 0x9a, 0x28, 0xe4, 0x86, 0xfb, + 0x47, 0x91, 0x1c, 0x82, 0xbf, 0x28, 0x2d, 0x23, 0x45, 0x26, 0x37, 0x0c, + 0x95, 0xce, 0x73, 0xc0, 0xaf, 0xcf, 0x27, 0xd7, 0xbc, 0x49, 0x7f, 0xa6, + 0xea, 0x9a, 0x0e, 0x9b, 0x1e, 0x87, 0x78, 0xa8, 0x96, 0x86, 0xd6, 0x34, + 0xd3, 0xed, 0x3c, 0xfb, 0x7b, 0x3b, 0xd2, 0x42, 0x22, 0xdc, 0xed, 0x12, + 0xc7, 0x21, 0x38, 0x59, 0x32, 0x8d, 0x22, 0x11, 0x86, 0x60, 0x46, 0x2b, + 0xd3, 0xfe, 0x1d, 0xfc, 0x30, 0xf8, 0xe1, 0xae, 0xf8, 0x23, 0x42, 0xf1, + 0x9f, 0xc3, 0xff, 0x00, 0x0b, 0xdd, 0xea, 0x03, 0x52, 0xd7, 0x0e, 0x8f, + 0x64, 0xb0, 0x16, 0x90, 0xde, 0x4b, 0x17, 0xcd, 0x29, 0x58, 0x51, 0x5b, + 0xf7, 0x11, 0xe7, 0x12, 0x5c, 0x4c, 0x52, 0x35, 0x3b, 0x07, 0x4c, 0xd7, + 0x5c, 0x78, 0x7d, 0x56, 0x8b, 0x71, 0x6e, 0x2f, 0xe4, 0xd5, 0xbe, 0x69, + 0x7f, 0x97, 0x4d, 0x74, 0x32, 0x75, 0xda, 0xd2, 0xd7, 0x3f, 0x62, 0x3e, + 0x14, 0x7f, 0xc1, 0x34, 0xfe, 0x32, 0xfc, 0x54, 0x5b, 0x8d, 0x3f, 0xc2, + 0x3e, 0x2a, 0xf0, 0xf4, 0x13, 0xdb, 0x81, 0x2c, 0x96, 0xd0, 0xdf, 0x5b, + 0xad, 0xe3, 0x37, 0x46, 0xc4, 0x96, 0x90, 0x10, 0x17, 0x27, 0xee, 0x17, + 0xe0, 0xe3, 0x8c, 0x74, 0xf7, 0xbb, 0x6f, 0xf8, 0x24, 0x5f, 0xc7, 0x5d, + 0x2a, 0xd7, 0xcd, 0xf1, 0x57, 0x8a, 0xa5, 0x8a, 0x22, 0xe7, 0x25, 0xb5, + 0x68, 0x8c, 0x45, 0x41, 0x3b, 0x49, 0x69, 0x1a, 0x1c, 0x67, 0x18, 0xeb, + 0x8c, 0x9e, 0xb5, 0xf1, 0x6e, 0x97, 0xf0, 0x33, 0xf6, 0xb8, 0xf8, 0x25, + 0xf0, 0xd6, 0xf3, 0xe2, 0xa7, 0xc6, 0xef, 0x01, 0xdc, 0xbd, 0xb4, 0x7a, + 0x9c, 0x36, 0xab, 0xf6, 0xeb, 0xe9, 0x22, 0x8e, 0xdd, 0x2e, 0x97, 0x08, + 0xcf, 0x67, 0x6d, 0x11, 0x2b, 0x19, 0x77, 0x53, 0x13, 0xc7, 0x34, 0x64, + 0x12, 0x01, 0x45, 0xc1, 0xaf, 0xdc, 0xdf, 0xd8, 0x9f, 0xe0, 0x57, 0xc3, + 0xcf, 0x8a, 0x9e, 0x00, 0xb3, 0xf8, 0xa3, 0xe2, 0x3d, 0x2b, 0x5e, 0xd2, + 0x6f, 0xe3, 0xcd, 0xb3, 0xd8, 0xc9, 0x77, 0x3f, 0x93, 0x30, 0x08, 0x81, + 0xd9, 0xe2, 0xbb, 0x8e, 0x49, 0x42, 0x86, 0x2c, 0x15, 0x44, 0xac, 0x07, + 0xcc, 0x72, 0x0b, 0x10, 0x3e, 0x9b, 0x2b, 0xe0, 0x8c, 0x3b, 0xaa, 0xb0, + 0xd5, 0x69, 0x4a, 0x53, 0x6a, 0xea, 0xf2, 0xb2, 0x6b, 0xbb, 0xf7, 0x34, + 0xfd, 0x76, 0x3a, 0x68, 0xe2, 0x9c, 0x9d, 0xad, 0x6f, 0xbc, 0xf9, 0x63, + 0xc1, 0x7f, 0xf0, 0x4c, 0x06, 0xd5, 0x66, 0x16, 0xcd, 0x33, 0x4e, 0x8a, + 0xc8, 0xaf, 0x72, 0xba, 0xad, 0x95, 0xd2, 0xc9, 0x93, 0x86, 0x3b, 0x52, + 0x77, 0x2b, 0x83, 0xd4, 0x02, 0xde, 0xd9, 0x3c, 0x57, 0xbb, 0xe8, 0xdf, + 0xf0, 0x49, 0x8f, 0x83, 0x37, 0x17, 0x5f, 0x60, 0xf1, 0x5b, 0xf8, 0xac, + 0x4e, 0xf3, 0x32, 0x6e, 0xd3, 0x66, 0xb2, 0x10, 0xed, 0x50, 0x09, 0x21, + 0xe4, 0x8c, 0x60, 0x1e, 0xdd, 0x4f, 0xb0, 0xe9, 0x5f, 0xad, 0xfe, 0x0b, + 0xf0, 0x6f, 0x82, 0xb4, 0x98, 0xb7, 0xe8, 0x16, 0xd1, 0x83, 0x0b, 0xec, + 0xde, 0xd1, 0xed, 0x64, 0x60, 0x07, 0x19, 0x2a, 0x0e, 0x40, 0xc5, 0x7a, + 0x7c, 0x56, 0xe3, 0x18, 0xe0, 0x0f, 0x6a, 0xfb, 0xdc, 0x3f, 0x86, 0x19, + 0x6d, 0x94, 0xaa, 0x41, 0x37, 0x7f, 0x2d, 0xbe, 0x49, 0x7e, 0xa7, 0x5c, + 0x25, 0xe4, 0x7e, 0x40, 0x6a, 0xdf, 0xf0, 0x49, 0x7f, 0x82, 0xf1, 0x79, + 0x50, 0xe8, 0x16, 0x3a, 0x84, 0x91, 0x2c, 0x80, 0xc9, 0x2d, 0xd6, 0xba, + 0x04, 0xcc, 0xbf, 0xee, 0x0d, 0x35, 0xa3, 0xe3, 0xeb, 0x9f, 0x7a, 0xe7, + 0x6f, 0xbf, 0xe0, 0x94, 0xf0, 0xd9, 0x78, 0x91, 0xe7, 0xf0, 0xd4, 0x7e, + 0x1f, 0x9b, 0x48, 0x0b, 0xb9, 0x2d, 0x75, 0x7b, 0xab, 0xb3, 0x3e, 0xe2, + 0x39, 0x50, 0xd6, 0xb1, 0x44, 0xa0, 0x67, 0xa1, 0xce, 0x7d, 0xab, 0xf6, + 0xb0, 0x40, 0xa0, 0x0c, 0x11, 0xf8, 0xd3, 0xfc, 0xa1, 0xea, 0x2b, 0xba, + 0xaf, 0x87, 0x19, 0x4c, 0x9b, 0x7e, 0xca, 0xde, 0x96, 0x56, 0xfb, 0x96, + 0xbf, 0x3b, 0x97, 0xce, 0xed, 0x63, 0xf9, 0xf4, 0xb8, 0xff, 0x00, 0x82, + 0x5b, 0x7c, 0x48, 0xb8, 0xf1, 0x28, 0x82, 0x7d, 0x0f, 0xc3, 0x89, 0xa7, + 0xb6, 0xef, 0x32, 0x7b, 0x1d, 0x62, 0xf1, 0x07, 0x24, 0x81, 0x8f, 0x3f, + 0xcd, 0x7c, 0x81, 0x82, 0x47, 0x97, 0x83, 0xd3, 0x23, 0xad, 0x7b, 0xce, + 0x97, 0xff, 0x00, 0x04, 0x6d, 0xf8, 0x0b, 0x77, 0x6f, 0x24, 0x9e, 0x22, + 0xbb, 0xd5, 0xa0, 0xb8, 0x64, 0xc4, 0x5f, 0x60, 0xbb, 0x49, 0x91, 0x5c, + 0x8f, 0xbc, 0x44, 0xb6, 0xa8, 0xdc, 0x1e, 0xdb, 0xce, 0x7d, 0x6b, 0xf6, + 0x44, 0xa2, 0x8f, 0x4a, 0x4c, 0x28, 0xe9, 0x4b, 0x0d, 0xe1, 0xce, 0x55, + 0x4e, 0x72, 0x9f, 0xb3, 0x6e, 0xfd, 0xde, 0xde, 0x96, 0xb1, 0x3c, 0xc7, + 0xe4, 0x1e, 0x81, 0xff, 0x00, 0x04, 0x71, 0xf8, 0x0b, 0x61, 0x7d, 0xe7, + 0x6b, 0xda, 0xce, 0xb7, 0x7f, 0x6e, 0xa0, 0xf9, 0x70, 0x44, 0xb1, 0xdb, + 0x3e, 0x4f, 0x4d, 0xf2, 0x2e, 0xfd, 0xc0, 0x0e, 0xa3, 0x68, 0xcf, 0x5c, + 0x8a, 0xee, 0x2d, 0xff, 0x00, 0xe0, 0x96, 0xff, 0x00, 0x04, 0x34, 0xc9, + 0xcc, 0x16, 0x56, 0xf3, 0xc9, 0x6a, 0x33, 0x82, 0x6e, 0xee, 0x62, 0x9c, + 0x13, 0xfc, 0x41, 0xc4, 0xcc, 0xa4, 0x8e, 0xa3, 0x28, 0x07, 0xb6, 0x38, + 0xaf, 0xd4, 0x6d, 0xcb, 0xd6, 0x8c, 0xad, 0x6c, 0xfc, 0x3d, 0xca, 0x79, + 0x79, 0x7d, 0x87, 0x5b, 0xeb, 0x29, 0x3f, 0xcd, 0xbb, 0xaf, 0x27, 0xa1, + 0x4a, 0x76, 0xe8, 0x7e, 0x36, 0xf8, 0x97, 0xfe, 0x09, 0xaf, 0xe2, 0x6d, + 0x03, 0x5a, 0x92, 0xd7, 0xe1, 0x75, 0xf4, 0x57, 0x7a, 0x7c, 0x8a, 0x5d, + 0x27, 0xf1, 0x1c, 0xe2, 0x59, 0x21, 0x38, 0x3f, 0x22, 0x84, 0x8f, 0x71, + 0x1d, 0x00, 0x39, 0xe4, 0xf5, 0x03, 0xad, 0x79, 0xae, 0xb1, 0xfb, 0x06, + 0x7c, 0x77, 0xd3, 0xec, 0x24, 0xd4, 0x6f, 0x1e, 0xda, 0x2e, 0x19, 0x5a, + 0xdb, 0x45, 0xb7, 0x82, 0x79, 0x24, 0xc0, 0xe1, 0x86, 0x59, 0x4a, 0x9e, + 0xdc, 0x06, 0x3f, 0x9d, 0x7e, 0xee, 0x6e, 0x1d, 0x29, 0xc3, 0x19, 0xaf, + 0x17, 0x15, 0xe1, 0x2e, 0x55, 0x52, 0x4e, 0x50, 0xe6, 0x85, 0xee, 0xec, + 0x9e, 0x9f, 0x73, 0xe9, 0xf3, 0x29, 0x55, 0x67, 0xf3, 0x8f, 0x61, 0xfb, + 0x14, 0x7e, 0xd3, 0x48, 0xf1, 0xbc, 0xda, 0x5d, 0x8c, 0xf6, 0x73, 0xc4, + 0xb3, 0xc7, 0x2e, 0xa4, 0xf7, 0xc6, 0x61, 0xbd, 0xb1, 0xb1, 0xa3, 0x8a, + 0x09, 0x4a, 0xc8, 0x01, 0xe8, 0x7e, 0x51, 0xea, 0x79, 0xaf, 0xa1, 0x74, + 0xbf, 0xd8, 0x7b, 0xf6, 0x82, 0xb3, 0xd3, 0x9a, 0x7b, 0x5d, 0x2b, 0xc0, + 0x8b, 0x28, 0xdb, 0x12, 0xc7, 0xfe, 0x96, 0x25, 0x3b, 0x17, 0x87, 0x7d, + 0xde, 0x5a, 0x10, 0xd9, 0xe7, 0x6b, 0x72, 0x7a, 0x8f, 0x4f, 0xdb, 0x70, + 0xc3, 0x1c, 0x60, 0x1a, 0x42, 0xcd, 0xed, 0x59, 0xe0, 0x7c, 0x24, 0xcb, + 0x28, 0xdf, 0x76, 0xfb, 0xde, 0xcc, 0x97, 0x51, 0xbe, 0xa7, 0xf3, 0xdb, + 0xf1, 0x1f, 0xc1, 0x9f, 0xb6, 0x17, 0xc2, 0x1b, 0xc4, 0xbc, 0x7d, 0x3f, + 0xc2, 0xf6, 0xf6, 0xcd, 0x22, 0xda, 0x47, 0x6d, 0xa7, 0x03, 0x14, 0x32, + 0xb1, 0x56, 0x65, 0x76, 0xf3, 0xa1, 0x69, 0x00, 0x38, 0x20, 0x9f, 0x34, + 0x0e, 0x00, 0xe7, 0x35, 0xf3, 0x16, 0xab, 0xfb, 0x46, 0xfc, 0x5e, 0x32, + 0x24, 0x3a, 0x81, 0x96, 0xde, 0xe3, 0x24, 0x98, 0x6d, 0x17, 0x30, 0xb2, + 0x8c, 0x91, 0x86, 0xb6, 0xdb, 0x26, 0xd1, 0xdd, 0x88, 0x3c, 0x77, 0xaf, + 0xe9, 0xeb, 0x55, 0xf0, 0x27, 0x86, 0x75, 0x9d, 0x60, 0x6b, 0xba, 0x9c, + 0x53, 0x49, 0x70, 0x0a, 0x95, 0x22, 0x79, 0x55, 0x46, 0xc1, 0x80, 0x02, + 0x2b, 0x01, 0x8f, 0x5e, 0x39, 0x35, 0xf0, 0xff, 0x00, 0xc7, 0x4f, 0x1c, + 0xfe, 0xc1, 0xfe, 0x1d, 0xb4, 0xbd, 0xf0, 0x9f, 0x8e, 0xf5, 0x3f, 0x0c, + 0x69, 0xba, 0x8c, 0x56, 0xb7, 0x12, 0xc5, 0xa4, 0xea, 0x1a, 0x95, 0xde, + 0x8f, 0x6d, 0x24, 0xf6, 0xe8, 0xca, 0x44, 0xde, 0x41, 0x45, 0x0e, 0x77, + 0x60, 0xb1, 0x56, 0x91, 0x87, 0x40, 0xd8, 0xaf, 0x9f, 0xcd, 0x7c, 0x38, + 0x74, 0x54, 0xb9, 0x31, 0x56, 0x4e, 0xf6, 0x53, 0x9b, 0xfc, 0x34, 0x7f, + 0x86, 0xbd, 0x35, 0x07, 0x37, 0xba, 0x91, 0xf8, 0x29, 0x7f, 0xfb, 0x71, + 0x7c, 0x5c, 0xd1, 0x2e, 0xc5, 0x8d, 0xb6, 0x8b, 0x60, 0xd0, 0x39, 0xd9, + 0x23, 0x6a, 0x03, 0x54, 0xb8, 0xbb, 0x45, 0xe0, 0x19, 0x23, 0x55, 0x68, + 0xd0, 0x83, 0x9c, 0xae, 0xe6, 0x52, 0x7d, 0x00, 0xad, 0x49, 0x7f, 0x6e, + 0x8f, 0x19, 0xc9, 0xe1, 0x51, 0x75, 0x1e, 0x9c, 0x6e, 0x24, 0xb6, 0x99, + 0xd7, 0xed, 0x30, 0xcb, 0x2d, 0xb1, 0x91, 0x88, 0x25, 0x41, 0x86, 0x69, + 0xa2, 0x5c, 0x0c, 0x72, 0x00, 0x27, 0x3d, 0x33, 0xc8, 0x3f, 0x3f, 0x7e, + 0xd1, 0xbf, 0x16, 0xfc, 0x3d, 0xab, 0xdc, 0xbf, 0x83, 0xf4, 0xdd, 0x03, + 0xc3, 0x96, 0x56, 0xbf, 0xe9, 0x53, 0xbd, 0xd5, 0xa6, 0xb7, 0x3d, 0xd1, + 0x48, 0xe3, 0xdc, 0x20, 0xf2, 0x65, 0xf3, 0x5d, 0x54, 0x4c, 0x85, 0x64, + 0x53, 0x2c, 0x09, 0x21, 0x1d, 0x02, 0x8a, 0xf8, 0x47, 0x47, 0x9e, 0xdb, + 0xe2, 0x57, 0x8b, 0x2d, 0xf4, 0x2b, 0x46, 0xd6, 0x75, 0x6d, 0x5a, 0xe2, + 0xf8, 0xd9, 0x47, 0xa7, 0x69, 0xf7, 0xb0, 0x1b, 0x34, 0x62, 0x9f, 0xbb, + 0x76, 0xbb, 0xb8, 0x69, 0x6d, 0x41, 0x92, 0x5f, 0x90, 0x87, 0x55, 0x3d, + 0x43, 0x1c, 0x9c, 0x9f, 0xca, 0xaa, 0x51, 0xc5, 0x42, 0x4a, 0x14, 0xea, + 0x35, 0x6e, 0xcd, 0xf9, 0xef, 0x7b, 0x6f, 0xfa, 0x1c, 0xf2, 0xac, 0xef, + 0x6b, 0xdc, 0xfb, 0x23, 0x53, 0xff, 0x00, 0x82, 0x91, 0xf8, 0xe4, 0xf9, + 0xf6, 0x1a, 0xfe, 0x81, 0x6b, 0x34, 0x20, 0x96, 0x8a, 0x5b, 0xcb, 0xb9, + 0xed, 0xee, 0x62, 0x0b, 0x9d, 0xc4, 0xab, 0xba, 0x21, 0x1c, 0xf1, 0xb4, + 0xb0, 0xe8, 0x01, 0x26, 0xae, 0xf8, 0x7b, 0xf6, 0xbb, 0xf0, 0x27, 0x88, + 0x4a, 0xea, 0x7e, 0x25, 0xb2, 0xd7, 0xee, 0xad, 0x61, 0x90, 0x4b, 0x7f, + 0x0e, 0x8e, 0xb6, 0xf6, 0x88, 0x88, 0x46, 0x0a, 0x7d, 0xaa, 0x6b, 0xa9, + 0x32, 0xc0, 0x91, 0x8c, 0xae, 0x4e, 0x71, 0xc6, 0x2b, 0xc5, 0x3e, 0x24, + 0xfc, 0x0b, 0xd2, 0x7e, 0x19, 0xdf, 0xa6, 0x87, 0xa8, 0x4d, 0x02, 0xdf, + 0x40, 0x62, 0x8b, 0x55, 0xf0, 0xe5, 0xdc, 0x30, 0x5c, 0x5c, 0xc3, 0x34, + 0x8a, 0x15, 0x76, 0x48, 0x87, 0xc8, 0x99, 0x49, 0xe4, 0xb4, 0x6d, 0xb9, + 0x0f, 0x45, 0xc6, 0x4d, 0x79, 0x95, 0xd7, 0xc7, 0xfb, 0xdf, 0x08, 0xe9, + 0x83, 0xc1, 0x3e, 0x16, 0xbf, 0x8a, 0x2b, 0x78, 0x27, 0x96, 0x51, 0x6a, + 0xe1, 0x67, 0xb4, 0x67, 0x42, 0x02, 0xc6, 0x62, 0x02, 0x4d, 0x8b, 0xc0, + 0xc1, 0x55, 0x11, 0x8f, 0x94, 0x83, 0x9a, 0xf2, 0x71, 0xf8, 0xd8, 0xce, + 0xa2, 0x4a, 0x12, 0x94, 0x96, 0x8f, 0x57, 0xa7, 0xad, 0xfa, 0xf9, 0x7d, + 0xe4, 0xa9, 0x4e, 0x37, 0xe6, 0x67, 0xff, 0xd0, 0xfc, 0x0c, 0xd6, 0x24, + 0xd4, 0xb4, 0x5b, 0x84, 0xba, 0x67, 0x90, 0x4e, 0xaa, 0x51, 0x58, 0x48, + 0xca, 0xc3, 0x1c, 0xe1, 0xb6, 0xba, 0x8e, 0x18, 0x67, 0x04, 0x63, 0xd8, + 0xf5, 0xae, 0x93, 0xc1, 0x9f, 0xb4, 0x07, 0xc4, 0xaf, 0x87, 0xb2, 0x48, + 0xfe, 0x1c, 0xd5, 0x2e, 0x6c, 0x1d, 0xc0, 0x53, 0x71, 0x61, 0x3b, 0x5a, + 0xce, 0x08, 0xe4, 0x17, 0x74, 0x70, 0x79, 0x03, 0x38, 0xcf, 0x3f, 0x95, + 0x7e, 0x88, 0x6a, 0xdf, 0xb1, 0x4f, 0xc7, 0x3f, 0x11, 0x5b, 0x49, 0xac, + 0x78, 0x3f, 0xc0, 0x1e, 0x2f, 0xbf, 0xd2, 0x6c, 0xa5, 0xb8, 0x82, 0xe6, + 0x7b, 0x1b, 0x71, 0xa8, 0x2c, 0xc2, 0x29, 0x17, 0x7b, 0xb5, 0xd5, 0xad, + 0x9a, 0x22, 0x86, 0xdd, 0x84, 0x29, 0x6e, 0x77, 0x8d, 0xa5, 0x01, 0x51, + 0x9a, 0xf8, 0xbb, 0xe3, 0x77, 0x84, 0xac, 0xda, 0xd2, 0xc3, 0xc2, 0x5e, + 0x05, 0xbd, 0xfb, 0x64, 0xd6, 0xde, 0x6c, 0xfa, 0xbe, 0x98, 0xb6, 0x9f, + 0x62, 0x97, 0x4e, 0x9a, 0xd8, 0x3f, 0x99, 0x14, 0xa8, 0x23, 0x8c, 0x12, + 0x8a, 0xad, 0xe6, 0xbe, 0xd0, 0xc5, 0x87, 0xdd, 0x23, 0x00, 0x7f, 0x3b, + 0xc6, 0x54, 0xeb, 0x25, 0x29, 0xc1, 0x38, 0xf7, 0xfc, 0xba, 0x68, 0x7c, + 0xfa, 0xa2, 0xd0, 0xe9, 0xff, 0x00, 0x69, 0xcf, 0x8a, 0x3e, 0x24, 0xd4, + 0x93, 0x5f, 0xbe, 0xf1, 0x26, 0xa5, 0x71, 0x38, 0x54, 0x92, 0x39, 0xef, + 0x6f, 0xa6, 0x69, 0x16, 0x40, 0x32, 0x85, 0x18, 0xbb, 0x64, 0x00, 0x30, + 0xad, 0x93, 0xb3, 0x91, 0xc0, 0xc5, 0x7d, 0xd7, 0xe0, 0xaf, 0xdb, 0x57, + 0x4d, 0xbe, 0xf8, 0x57, 0x3f, 0x84, 0x35, 0xfd, 0x25, 0x9f, 0x52, 0xbf, + 0x48, 0x66, 0x59, 0x74, 0xc8, 0x60, 0x8a, 0xce, 0x59, 0x6c, 0x3c, 0xb4, + 0x78, 0xcb, 0x48, 0x24, 0x8c, 0x6f, 0x88, 0x02, 0xe5, 0x62, 0x93, 0x05, + 0x73, 0xb2, 0x3d, 0xee, 0xc7, 0xf1, 0x37, 0x41, 0xf0, 0xe5, 0xfe, 0xac, + 0x6e, 0x75, 0x7b, 0xc7, 0x92, 0xda, 0xc2, 0x26, 0x10, 0xab, 0x92, 0xf8, + 0x33, 0x0c, 0x16, 0x8f, 0x05, 0x15, 0xce, 0xd1, 0x91, 0x8c, 0x01, 0xbb, + 0x00, 0x13, 0xc9, 0xab, 0x3a, 0xf7, 0xc4, 0x6b, 0x7f, 0x09, 0x4b, 0x06, + 0x9f, 0xe0, 0xd9, 0x27, 0x8e, 0xee, 0x37, 0xf3, 0x4d, 0xdc, 0x8f, 0xf2, + 0x20, 0x44, 0xd8, 0xcd, 0x1a, 0x93, 0x8c, 0xb2, 0x02, 0xa5, 0x73, 0x86, + 0x52, 0x54, 0xe4, 0x64, 0x0e, 0xa9, 0x65, 0x70, 0x9c, 0x9a, 0xa5, 0x6b, + 0xf5, 0xf2, 0xf5, 0x7e, 0x46, 0x94, 0xa2, 0xd3, 0x76, 0x3f, 0x41, 0x3c, + 0x79, 0xfb, 0x47, 0x78, 0xdf, 0xc3, 0x7e, 0x33, 0xbc, 0xd5, 0x7c, 0x29, + 0x2d, 0xed, 0xb3, 0xa4, 0xe8, 0x66, 0x8e, 0xe1, 0xa3, 0xb9, 0x96, 0x07, + 0x0e, 0xd2, 0x94, 0x1b, 0xa1, 0x55, 0x54, 0x57, 0x73, 0xc2, 0xae, 0x30, + 0x48, 0x38, 0x52, 0x6a, 0xdf, 0x8a, 0x7f, 0x6f, 0xdf, 0xda, 0xc3, 0xe3, + 0x34, 0xd6, 0x3e, 0x1d, 0xd7, 0xfc, 0x59, 0xab, 0x7f, 0xa0, 0x6f, 0x96, + 0x39, 0x04, 0xad, 0xe7, 0x6e, 0x50, 0x63, 0x65, 0x63, 0x95, 0x2d, 0xf2, + 0x12, 0xa1, 0x33, 0x8c, 0x64, 0x10, 0x73, 0x8a, 0xf3, 0xaf, 0x81, 0x5f, + 0x09, 0xef, 0x3e, 0x26, 0x78, 0xfe, 0x4f, 0x84, 0x3e, 0x10, 0xb6, 0xd4, + 0x7c, 0x55, 0xe2, 0xed, 0x7f, 0x4e, 0xb7, 0xba, 0xb2, 0xd4, 0xec, 0x6e, + 0x2e, 0x26, 0x5d, 0x32, 0x0c, 0x94, 0xbc, 0xb9, 0x68, 0xde, 0x01, 0xe6, + 0x61, 0x15, 0xcf, 0x96, 0x84, 0x82, 0x1a, 0x33, 0x90, 0x37, 0x57, 0xaa, + 0xf8, 0xf3, 0x4a, 0xd0, 0x3e, 0x0d, 0x29, 0xf8, 0x59, 0x73, 0xa4, 0xac, + 0xba, 0xc0, 0xb4, 0x87, 0x59, 0xb5, 0x4b, 0xbd, 0x3e, 0x5b, 0x7d, 0x72, + 0xca, 0xee, 0x47, 0x21, 0xe6, 0x96, 0x5d, 0x83, 0x7d, 0xbe, 0xdd, 0xbb, + 0xe3, 0xb9, 0x12, 0x44, 0xcb, 0x22, 0xaa, 0x46, 0x24, 0x05, 0x85, 0x54, + 0xc2, 0x53, 0xc3, 0xd0, 0x56, 0xd5, 0xb5, 0xf2, 0xdb, 0x77, 0xbd, 0xfe, + 0x7b, 0x75, 0x34, 0x54, 0xe5, 0xb2, 0x66, 0x72, 0x7e, 0xcb, 0xbe, 0x34, + 0xf1, 0x71, 0xba, 0xf1, 0x2e, 0xa5, 0xa8, 0x5d, 0xea, 0x10, 0x46, 0x11, + 0xae, 0x6e, 0x2f, 0x96, 0x54, 0x90, 0xc4, 0xe8, 0x24, 0x46, 0x91, 0xa4, + 0x79, 0xc2, 0xfe, 0xef, 0x24, 0xb0, 0x05, 0x55, 0x81, 0x50, 0x18, 0x2e, + 0x4d, 0xaf, 0x03, 0xfe, 0xcf, 0xf0, 0xde, 0x5d, 0xc7, 0x77, 0xa6, 0xeb, + 0xb1, 0xdc, 0x69, 0x56, 0xec, 0x27, 0xd4, 0x34, 0x9b, 0xab, 0x98, 0x56, + 0xe1, 0x54, 0xb6, 0xd9, 0xd6, 0x3b, 0x65, 0x7f, 0xde, 0xba, 0xaa, 0xe4, + 0xec, 0x51, 0x21, 0x50, 0x1b, 0xe5, 0x5c, 0x11, 0xe2, 0xd6, 0x7e, 0x3b, + 0xbf, 0xf1, 0xd5, 0xa4, 0xda, 0xb7, 0x8a, 0xfc, 0x47, 0x74, 0xe6, 0xea, + 0x0f, 0xb4, 0x26, 0x93, 0x63, 0x9d, 0x3e, 0xc5, 0x2e, 0xc1, 0x2e, 0x5f, + 0xc8, 0x8a, 0x07, 0x45, 0xde, 0xa5, 0x95, 0x11, 0x36, 0x37, 0x98, 0xb9, + 0xf9, 0x50, 0x80, 0x79, 0x2d, 0x7b, 0xe2, 0x5f, 0x8f, 0x3c, 0x55, 0x6b, + 0x05, 0xd4, 0x37, 0x9a, 0xb5, 0xad, 0x85, 0x85, 0xb7, 0xf6, 0x6d, 0x81, + 0xb8, 0x99, 0xa0, 0x82, 0x55, 0xb4, 0x42, 0xe2, 0x3c, 0x1f, 0x95, 0x9c, + 0x92, 0x19, 0x51, 0x57, 0x83, 0xd7, 0xb9, 0xaf, 0x3a, 0x9e, 0x17, 0x11, + 0x56, 0x32, 0x8c, 0xaa, 0x5f, 0x4b, 0x69, 0xa2, 0x5e, 0x7b, 0x7d, 0xcb, + 0xf2, 0x1f, 0x22, 0x4f, 0x63, 0xe9, 0x88, 0x8e, 0xa3, 0xe0, 0x1d, 0x4a, + 0x6b, 0x8f, 0x0f, 0xc0, 0xff, 0x00, 0x66, 0x22, 0x69, 0xac, 0xe7, 0xbd, + 0x84, 0xc7, 0x71, 0xe4, 0xa3, 0xe5, 0x8a, 0xbc, 0x89, 0xe6, 0x6d, 0x46, + 0xf9, 0x02, 0xf9, 0xaf, 0xdb, 0x3d, 0x98, 0x50, 0xd7, 0xf5, 0xbf, 0x14, + 0x78, 0xbc, 0x59, 0x78, 0xd7, 0x51, 0x4b, 0x69, 0xca, 0x9f, 0x2a, 0x6b, + 0x7b, 0x5d, 0xb1, 0x5c, 0x15, 0x00, 0x85, 0x91, 0x53, 0xe4, 0xf3, 0x46, + 0x08, 0x22, 0x46, 0xf4, 0xc0, 0xc8, 0x53, 0x5f, 0x0d, 0x3f, 0xc5, 0x2f, + 0x1e, 0xc8, 0x12, 0x79, 0xb5, 0x29, 0x21, 0x8e, 0x29, 0xfe, 0x54, 0x67, + 0xc4, 0x8f, 0xd7, 0x86, 0xc9, 0xc1, 0xe0, 0x1e, 0x54, 0x60, 0x7a, 0x9c, + 0x8a, 0xee, 0x61, 0xf8, 0xa5, 0xe2, 0x7b, 0x99, 0xed, 0x53, 0x50, 0x9e, + 0x18, 0x56, 0x08, 0xd5, 0x2d, 0xa2, 0xb1, 0x09, 0x0b, 0xe5, 0xc0, 0xdc, + 0x84, 0xa7, 0xcc, 0xfb, 0xf1, 0x9e, 0x72, 0x14, 0x9c, 0xa8, 0x5c, 0x91, + 0x59, 0x50, 0xe1, 0x89, 0x27, 0xcf, 0x2f, 0x79, 0xbd, 0x9f, 0x51, 0x4e, + 0x37, 0x3e, 0xc6, 0xf0, 0xdf, 0x8d, 0xbc, 0x3d, 0x61, 0xa9, 0xf9, 0xdf, + 0x11, 0xfc, 0x3f, 0x73, 0x0c, 0x93, 0xac, 0xab, 0x0d, 0xf6, 0x9e, 0x22, + 0xbe, 0x46, 0xde, 0xd9, 0x56, 0x92, 0x27, 0x72, 0x06, 0xd1, 0x85, 0xc8, + 0x70, 0xd9, 0xc9, 0x07, 0x02, 0xbf, 0x61, 0x7f, 0x64, 0xdf, 0xda, 0x37, + 0xe0, 0x8f, 0xc3, 0x9d, 0x52, 0xd9, 0xbc, 0x5f, 0xe1, 0x75, 0xd5, 0xde, + 0x0f, 0x2a, 0x7b, 0x4b, 0xdf, 0x0c, 0x5d, 0x43, 0x67, 0x7d, 0xe4, 0xef, + 0x62, 0xb3, 0xc9, 0x04, 0xc6, 0x31, 0x24, 0x9b, 0xb2, 0x36, 0x34, 0x8e, + 0x06, 0x3e, 0x5c, 0x16, 0x2c, 0xdf, 0x84, 0xde, 0x08, 0xbf, 0xb9, 0x9e, + 0x47, 0xbf, 0x9d, 0x25, 0x0b, 0x2e, 0xfb, 0x49, 0x65, 0x8e, 0x64, 0x88, + 0x74, 0x2e, 0xc0, 0x92, 0x64, 0x56, 0x52, 0xb9, 0x39, 0x03, 0x2c, 0x73, + 0xc7, 0x51, 0x5e, 0xad, 0xa1, 0xf8, 0x32, 0xd8, 0x49, 0x24, 0xf6, 0xfa, + 0xf5, 0xfc, 0x13, 0xc0, 0x9f, 0xe8, 0x73, 0x3a, 0xa4, 0xcd, 0x0c, 0x4b, + 0x20, 0xdc, 0x52, 0x21, 0xb6, 0x42, 0x9c, 0xb7, 0x39, 0x55, 0xc6, 0x32, + 0x38, 0xc1, 0x98, 0x61, 0x5e, 0x12, 0xb2, 0x97, 0x32, 0x5e, 0x4d, 0x5f, + 0xf3, 0xbf, 0xf5, 0xb5, 0x8c, 0x35, 0x47, 0xf6, 0xbf, 0xf0, 0xeb, 0xfe, + 0x0a, 0x69, 0xf0, 0x22, 0xdb, 0xc4, 0x17, 0x1e, 0x1a, 0xd4, 0x75, 0x2d, + 0x67, 0x5b, 0x47, 0x48, 0xd2, 0x08, 0xb5, 0x31, 0xa6, 0x58, 0x3c, 0x13, + 0x03, 0xb4, 0xa7, 0x9c, 0xf2, 0x40, 0x8e, 0x72, 0x76, 0xb9, 0x24, 0x85, + 0x65, 0xe1, 0xd9, 0x4e, 0xea, 0xfb, 0x0f, 0x41, 0xfd, 0xa2, 0xfe, 0x03, + 0xfc, 0x3d, 0xf8, 0x7b, 0x75, 0xe3, 0xaf, 0x16, 0xde, 0xe8, 0x7e, 0x1d, + 0x12, 0x4e, 0xb3, 0xcb, 0xa1, 0xd8, 0x6a, 0x36, 0xf7, 0xd7, 0x50, 0x87, + 0x55, 0xc3, 0x4b, 0x0c, 0x2c, 0x02, 0xcd, 0xb4, 0x65, 0xe3, 0x8c, 0x36, + 0xc0, 0xb8, 0x24, 0x9c, 0x81, 0xfc, 0x31, 0x78, 0x1f, 0xc4, 0x3a, 0x87, + 0x84, 0x74, 0x4b, 0xad, 0x2f, 0x57, 0xd4, 0x12, 0xe6, 0xe6, 0x68, 0xe5, + 0x66, 0x8e, 0x40, 0xd2, 0x39, 0xd8, 0xe4, 0x99, 0x12, 0xdd, 0x5b, 0x69, + 0x91, 0xb8, 0x20, 0xe4, 0x67, 0xd3, 0x8c, 0x1e, 0x8b, 0x59, 0xf1, 0xc4, + 0xda, 0xc5, 0x98, 0x96, 0x53, 0xaf, 0xbd, 0xb4, 0x50, 0x89, 0x27, 0x79, + 0xd2, 0x51, 0x1c, 0xb1, 0x47, 0x21, 0xc4, 0x6e, 0xad, 0xf2, 0xa9, 0x77, + 0x2a, 0x06, 0x42, 0xfa, 0x60, 0x9c, 0x67, 0xea, 0x70, 0x3c, 0x7f, 0x8f, + 0x55, 0x65, 0x19, 0xfb, 0xcb, 0xa6, 0x9a, 0x2f, 0x3e, 0xef, 0xef, 0xef, + 0x74, 0x6f, 0x4e, 0xaf, 0xbb, 0xaa, 0x3f, 0xb6, 0x8f, 0x0d, 0x7e, 0xdf, + 0x3f, 0xb3, 0x9f, 0x8b, 0xf4, 0x1f, 0xf8, 0x48, 0xbc, 0x31, 0x7b, 0x73, + 0x34, 0x1f, 0x6c, 0xfb, 0x20, 0x33, 0xc6, 0xb0, 0xe4, 0x03, 0x83, 0x20, + 0x25, 0xcf, 0xcb, 0xfc, 0x43, 0xb9, 0x1c, 0x8a, 0xfa, 0x83, 0xc0, 0x3f, + 0x14, 0xfe, 0x1d, 0xfc, 0x4a, 0xb5, 0x7b, 0xaf, 0x04, 0xea, 0x96, 0x97, + 0xe2, 0x20, 0xa6, 0x54, 0x86, 0x54, 0x69, 0x13, 0x70, 0xc8, 0xdc, 0xaa, + 0x49, 0x1c, 0xe4, 0x72, 0x39, 0x20, 0xe3, 0x38, 0xcd, 0x7f, 0x0a, 0x1a, + 0x7f, 0xed, 0x07, 0xe2, 0x0d, 0x6b, 0x45, 0xb6, 0xb3, 0xf0, 0xf4, 0xcb, + 0x6c, 0xb1, 0xc0, 0x6e, 0x2e, 0x7c, 0xa7, 0x68, 0x56, 0x45, 0x32, 0xf9, + 0x41, 0x9a, 0x15, 0x79, 0x04, 0x65, 0x30, 0x98, 0x68, 0xc2, 0x0d, 0xad, + 0x8e, 0xb9, 0xcf, 0xec, 0xff, 0x00, 0xfc, 0x12, 0xfb, 0xe2, 0xdf, 0x87, + 0xb5, 0xbf, 0x8a, 0x36, 0x10, 0x6b, 0x9a, 0xa5, 0xf8, 0xf1, 0x0e, 0xa9, + 0x0f, 0xd8, 0xed, 0xac, 0x51, 0x54, 0xc4, 0x2d, 0xa1, 0xdc, 0xf2, 0x79, + 0xc1, 0xc3, 0x9d, 0xa0, 0xaa, 0x04, 0x75, 0x90, 0x1f, 0x9b, 0xa1, 0xce, + 0x6b, 0xd9, 0xc8, 0x38, 0xd7, 0x32, 0xab, 0x8e, 0x8d, 0x1c, 0x53, 0x83, + 0x84, 0x9d, 0x95, 0x93, 0x4d, 0x7c, 0xf5, 0x57, 0xbf, 0xf9, 0x16, 0xf1, + 0x0a, 0xea, 0x36, 0x3f, 0xa4, 0xd7, 0x95, 0x05, 0x55, 0x79, 0xd0, 0xf4, + 0xc9, 0xaa, 0xb8, 0x77, 0xe7, 0x93, 0x51, 0x34, 0x64, 0x73, 0xd2, 0xbf, + 0x66, 0x51, 0x45, 0xb6, 0xfa, 0x22, 0x47, 0x94, 0x91, 0xd7, 0x15, 0x09, + 0xb9, 0x0b, 0xc1, 0x35, 0xe4, 0xfe, 0x3e, 0xf8, 0xe1, 0xf0, 0x9f, 0xe1, + 0x85, 0xf5, 0xbe, 0x97, 0xe3, 0xbd, 0x77, 0x4f, 0xd3, 0xae, 0x2e, 0x83, + 0x34, 0x51, 0x5c, 0x4c, 0xaa, 0x76, 0xa2, 0xb3, 0xb1, 0x39, 0x3c, 0x00, + 0x14, 0xf5, 0xaf, 0x16, 0xb9, 0xfd, 0xb3, 0xbe, 0x00, 0xdd, 0x69, 0x6d, + 0xaa, 0x68, 0xfa, 0x94, 0xd7, 0xc4, 0x16, 0x11, 0x47, 0x6f, 0x17, 0x32, + 0x85, 0x19, 0xdc, 0x85, 0x88, 0x52, 0xa4, 0xf0, 0x0e, 0x73, 0x9e, 0xdd, + 0x33, 0xe6, 0x63, 0x73, 0xfc, 0x06, 0x1a, 0xeb, 0x13, 0x88, 0x8c, 0x3d, + 0x5a, 0x23, 0x99, 0xbd, 0x11, 0xf6, 0x08, 0xba, 0xe0, 0xe3, 0x14, 0xd8, + 0xaf, 0xe2, 0x7e, 0x51, 0x95, 0x86, 0x7a, 0xa9, 0x04, 0x71, 0xef, 0xed, + 0x5f, 0x9a, 0xff, 0x00, 0x14, 0xbf, 0x6a, 0xdd, 0x1b, 0x4b, 0x87, 0x5b, + 0x59, 0x2f, 0xa6, 0x87, 0x4e, 0xb5, 0xd2, 0x13, 0x53, 0x86, 0x6b, 0x59, + 0xa3, 0x33, 0x83, 0x73, 0x11, 0x68, 0x93, 0x64, 0x44, 0xb1, 0x50, 0x40, + 0x2c, 0x58, 0xa9, 0x8f, 0x3f, 0x33, 0x67, 0x02, 0xbe, 0x4e, 0xf0, 0xd7, + 0xfc, 0x14, 0x83, 0xc0, 0xd2, 0x78, 0x4e, 0xdb, 0x4d, 0xf0, 0xfd, 0xf2, + 0xd9, 0x6a, 0xd0, 0xa2, 0x3a, 0xc5, 0x68, 0xf1, 0xc8, 0x97, 0xb2, 0x87, + 0x91, 0xa4, 0x81, 0x63, 0x91, 0x8a, 0xa1, 0x72, 0x77, 0x2b, 0x60, 0xe4, + 0x02, 0x73, 0xd0, 0x57, 0xcd, 0x62, 0xfc, 0x44, 0xcb, 0x68, 0xd5, 0x74, + 0xe5, 0x2d, 0x12, 0x7f, 0x3b, 0x74, 0x5f, 0xa5, 0xda, 0xbd, 0xbb, 0x96, + 0xaf, 0x63, 0xf7, 0x76, 0xe3, 0x57, 0xb1, 0xb1, 0x81, 0xae, 0x6f, 0x24, + 0x48, 0xd1, 0x17, 0x73, 0xbc, 0x8c, 0x14, 0x28, 0xe9, 0x93, 0xe8, 0x2b, + 0x4a, 0x39, 0xc4, 0xb1, 0xac, 0xcb, 0x8d, 0x8e, 0x37, 0x2b, 0xe7, 0xe5, + 0x23, 0x19, 0xc8, 0x3d, 0x3a, 0x57, 0xe2, 0x06, 0xa5, 0xfb, 0x77, 0x78, + 0x67, 0xc5, 0xf6, 0xce, 0xba, 0xbd, 0xdf, 0xf6, 0x4d, 0xed, 0x8e, 0x99, + 0x35, 0xcd, 0xed, 0xed, 0xc0, 0x92, 0xce, 0xd9, 0x2d, 0xf6, 0x00, 0x01, + 0xc8, 0x7d, 0xe1, 0xd9, 0xd4, 0xe5, 0xd3, 0x67, 0xdd, 0x23, 0x39, 0xaf, + 0x8f, 0x7e, 0x20, 0xff, 0x00, 0xc1, 0x5a, 0xfc, 0x51, 0xa2, 0xf8, 0x3e, + 0x4f, 0x00, 0x41, 0x0d, 0xbd, 0xe6, 0x9d, 0xa9, 0x42, 0xd6, 0x96, 0x5a, + 0x95, 0xfc, 0x52, 0xc9, 0x3c, 0x0d, 0x32, 0x06, 0x55, 0x12, 0x07, 0x54, + 0x67, 0x45, 0x65, 0x74, 0x65, 0xdc, 0x39, 0x04, 0x8c, 0x10, 0x07, 0x9b, + 0x5f, 0xc4, 0xec, 0x04, 0x6c, 0xe3, 0x19, 0x34, 0xd6, 0x9a, 0x3f, 0xc7, + 0xb7, 0x6e, 0xa0, 0xa4, 0x96, 0xec, 0xfe, 0x9e, 0x2d, 0x75, 0x8d, 0x27, + 0x50, 0x85, 0x27, 0xd3, 0xee, 0x61, 0x99, 0x58, 0x95, 0x1e, 0x5b, 0xa9, + 0xcb, 0x01, 0x92, 0xbd, 0x73, 0xb8, 0x67, 0x91, 0xd4, 0x77, 0xab, 0x73, + 0xc7, 0x24, 0xf6, 0xef, 0x0c, 0x32, 0x34, 0x2e, 0xe8, 0x42, 0x4a, 0xaa, + 0x09, 0x42, 0x46, 0x03, 0x00, 0xc0, 0x83, 0x8e, 0xbc, 0x8c, 0x57, 0xe0, + 0x7f, 0xec, 0x31, 0xf1, 0x43, 0xe2, 0xbf, 0xc4, 0x4d, 0x61, 0x4d, 0xd7, + 0x88, 0x6c, 0x8d, 0xae, 0x93, 0x6c, 0x75, 0x1b, 0x7d, 0x3e, 0x79, 0x26, + 0x68, 0xda, 0x72, 0xc0, 0x36, 0xff, 0x00, 0x20, 0x2c, 0x72, 0x3e, 0xcf, + 0x2d, 0x5a, 0x35, 0x91, 0xb6, 0x02, 0xa5, 0x8e, 0xe0, 0x54, 0x7e, 0xe3, + 0x69, 0x3e, 0x2a, 0xb2, 0xbd, 0xd2, 0x52, 0xee, 0x6b, 0xdb, 0x57, 0x30, + 0x84, 0x82, 0xf2, 0x60, 0xe1, 0x11, 0x2e, 0x14, 0x28, 0x75, 0x70, 0x48, + 0xd8, 0xdb, 0x8f, 0xdd, 0x6c, 0x11, 0x90, 0x31, 0x5f, 0x51, 0xc3, 0xd9, + 0xda, 0xcc, 0x30, 0xea, 0xba, 0x8f, 0x2d, 0xfc, 0xc6, 0xa4, 0x7c, 0xdd, + 0xab, 0x5a, 0x7c, 0x7a, 0xf0, 0x8f, 0xc5, 0xd9, 0xf5, 0xad, 0x5b, 0x59, + 0xd3, 0xe7, 0xf0, 0xb4, 0xe8, 0xcf, 0x63, 0x14, 0x50, 0x47, 0x1d, 0xdb, + 0x34, 0x0a, 0x64, 0x68, 0xaf, 0xa7, 0x36, 0x8c, 0xb1, 0xdb, 0x95, 0xdf, + 0xb4, 0xa3, 0x02, 0xa5, 0x41, 0x67, 0xf9, 0x8d, 0x7e, 0x7f, 0x7c, 0x76, + 0xfd, 0x94, 0x2c, 0xbe, 0x34, 0xf8, 0xa3, 0x58, 0x1a, 0x55, 0xf7, 0x83, + 0xbc, 0x37, 0xa7, 0xc3, 0x73, 0x3e, 0xad, 0x61, 0xaa, 0xcd, 0x37, 0xdb, + 0x75, 0x08, 0x66, 0x37, 0x0e, 0x62, 0x81, 0x91, 0x04, 0xb6, 0xd6, 0xf0, + 0xbd, 0xc3, 0xef, 0x59, 0x98, 0xbb, 0x80, 0x36, 0x22, 0x46, 0x2b, 0xf4, + 0x2f, 0xf6, 0x8c, 0xf1, 0x8f, 0xc3, 0xa6, 0xf8, 0x63, 0xff, 0x00, 0x09, + 0xac, 0x9e, 0x1f, 0xb5, 0xf1, 0xf4, 0xd6, 0xe9, 0x25, 0xce, 0x91, 0xa7, + 0xe9, 0xee, 0x97, 0x4d, 0x2f, 0xca, 0xd1, 0xbb, 0xa1, 0x8d, 0xff, 0x00, + 0xd5, 0x28, 0x62, 0x24, 0x20, 0x90, 0x01, 0xe8, 0x5b, 0x68, 0x3f, 0x96, + 0x5a, 0x5f, 0xc6, 0x9d, 0x4f, 0xc3, 0xbf, 0x11, 0xaf, 0xbc, 0x13, 0xaf, + 0x5f, 0x68, 0xb3, 0x6a, 0x5a, 0x8d, 0x85, 0xc4, 0xde, 0x20, 0xd0, 0xf5, + 0x9d, 0x1e, 0xcb, 0x50, 0xd3, 0xb4, 0x7b, 0x8b, 0x70, 0x4f, 0xf6, 0x78, + 0x9e, 0x0b, 0x98, 0xcc, 0xb0, 0x46, 0xb2, 0xff, 0x00, 0xab, 0x94, 0x2c, + 0x9b, 0xf0, 0x32, 0x5c, 0xe1, 0x3c, 0x5c, 0xf3, 0x2f, 0xc3, 0xca, 0x2a, + 0x9e, 0x21, 0xf3, 0x45, 0xbd, 0x2e, 0xef, 0xbf, 0x9f, 0xae, 0xd6, 0x7d, + 0x2f, 0xd0, 0x89, 0xd6, 0xb3, 0x51, 0x48, 0xfc, 0xaf, 0xf1, 0x6f, 0x85, + 0x3e, 0x26, 0xf8, 0x29, 0xf5, 0x9d, 0x7f, 0xe2, 0x67, 0x87, 0x3e, 0x1f, + 0xea, 0x97, 0x32, 0xdf, 0xa6, 0x87, 0x13, 0x78, 0x9a, 0x2d, 0x2b, 0x45, + 0x7b, 0x34, 0x8e, 0xd4, 0x94, 0xbc, 0xbf, 0x97, 0x4d, 0x36, 0xf3, 0xbb, + 0xa2, 0x97, 0x92, 0xda, 0x68, 0xcc, 0xc6, 0x79, 0x1e, 0x36, 0x85, 0x9c, + 0x11, 0xe6, 0x7c, 0x05, 0x75, 0xa0, 0xfc, 0x5d, 0xf8, 0x69, 0x6b, 0x69, + 0xae, 0x7c, 0x32, 0x9e, 0xd7, 0x40, 0x81, 0xae, 0xaf, 0x3f, 0xe2, 0xa6, + 0xf0, 0xe4, 0xef, 0x1c, 0xf7, 0x70, 0x87, 0x2e, 0xf1, 0xc5, 0x75, 0x14, + 0xbb, 0x9d, 0xb6, 0xb6, 0x7e, 0x72, 0x65, 0x88, 0x10, 0x0a, 0xed, 0xf9, + 0x0f, 0xed, 0x1f, 0x8f, 0xbc, 0x7b, 0xa1, 0x6a, 0x77, 0xba, 0xac, 0xb0, + 0xe9, 0x7e, 0x0c, 0xf0, 0xa6, 0xb7, 0xab, 0x44, 0xda, 0x87, 0x88, 0x75, + 0x23, 0xa9, 0x89, 0x34, 0x8b, 0xcb, 0x1b, 0x9b, 0x7f, 0x2a, 0x44, 0xb6, + 0x80, 0xfd, 0xa5, 0xa5, 0x8d, 0xd4, 0x79, 0x2d, 0x6d, 0xe5, 0x4b, 0x99, + 0x5b, 0x18, 0x0c, 0x85, 0x47, 0xe6, 0xd7, 0x88, 0x3f, 0x67, 0x8d, 0x5f, + 0xc0, 0x3f, 0x0d, 0xee, 0xbc, 0x51, 0xa9, 0xc5, 0x16, 0x91, 0xa6, 0xea, + 0xfa, 0x95, 0xd5, 0xe6, 0x9d, 0xfd, 0xa3, 0x31, 0x17, 0xfe, 0x62, 0x4a, + 0x13, 0x69, 0x49, 0x08, 0x9e, 0x39, 0x11, 0x5f, 0x6b, 0x27, 0x93, 0x81, + 0xf2, 0xf3, 0xb5, 0x95, 0x8f, 0xe6, 0x3c, 0x51, 0x96, 0x62, 0x29, 0x47, + 0xeb, 0x18, 0x77, 0xa4, 0x77, 0x7a, 0x7e, 0x37, 0xf7, 0xbb, 0x6f, 0xa1, + 0xc5, 0x09, 0x27, 0x2b, 0x1f, 0x97, 0xff, 0x00, 0x19, 0x3c, 0x53, 0xe3, + 0xcf, 0x89, 0x7a, 0xf4, 0xba, 0x9f, 0x8b, 0x75, 0xbb, 0xeb, 0xad, 0x52, + 0xd6, 0xd2, 0x3b, 0x18, 0x2e, 0xf5, 0x2f, 0x32, 0x59, 0x25, 0xb5, 0x45, + 0x2c, 0x8c, 0x92, 0x0c, 0x86, 0x4c, 0xb1, 0x1b, 0x9d, 0x83, 0x73, 0x91, + 0xd0, 0xe3, 0xe6, 0x5b, 0xe8, 0x75, 0xbd, 0x3e, 0x76, 0x9e, 0xee, 0x63, + 0xe7, 0x48, 0x10, 0xab, 0xa3, 0x2b, 0x11, 0x11, 0x24, 0x61, 0xe4, 0x19, + 0x75, 0x72, 0xc0, 0x1c, 0x30, 0x07, 0xbe, 0xec, 0xd7, 0xd7, 0xde, 0x35, + 0xf8, 0x77, 0xe2, 0x5d, 0x52, 0x57, 0xd3, 0xac, 0xe2, 0xd5, 0x2e, 0xa1, + 0x59, 0x61, 0x37, 0x1a, 0x76, 0x9f, 0x66, 0xd3, 0xde, 0x4a, 0x65, 0x0d, + 0x23, 0x49, 0x6b, 0x0a, 0x88, 0xde, 0x41, 0x1a, 0x00, 0xcd, 0x99, 0x0a, + 0x81, 0x92, 0x70, 0x3a, 0x47, 0xa0, 0x7c, 0x0b, 0xf8, 0x8f, 0xe2, 0x2b, + 0x03, 0xe2, 0x7b, 0x4b, 0x1b, 0xbf, 0xec, 0xa8, 0xae, 0xd6, 0xc3, 0x57, + 0xbf, 0xb9, 0x8e, 0xdd, 0x05, 0x94, 0x90, 0x3a, 0x2c, 0x2d, 0x79, 0x04, + 0x4a, 0xee, 0x8a, 0xea, 0xcb, 0x87, 0x90, 0x48, 0x1f, 0x04, 0xff, 0x00, + 0x06, 0x6b, 0xc3, 0xc2, 0xe3, 0x6d, 0x4f, 0xda, 0xb5, 0x74, 0xf7, 0xdf, + 0x6d, 0x3a, 0xb5, 0x7f, 0xe9, 0x5b, 0x7d, 0x07, 0x4e, 0xfb, 0x1f, 0xff, + 0xd1, 0xf2, 0x1d, 0x3b, 0xf6, 0xc1, 0xfd, 0xa0, 0x7c, 0x67, 0x79, 0xa5, + 0xf8, 0x59, 0x1b, 0x54, 0xd2, 0xf4, 0x37, 0x92, 0x09, 0x96, 0x3f, 0x0c, + 0xc1, 0x71, 0xa4, 0x35, 0xe8, 0xc8, 0xda, 0x96, 0xf7, 0x16, 0xb2, 0x47, + 0x70, 0xa1, 0xd1, 0xbf, 0xd6, 0x33, 0x95, 0x64, 0x1c, 0x44, 0xa4, 0x0c, + 0x71, 0x7a, 0xbf, 0xc4, 0x5f, 0x81, 0x3e, 0x21, 0xbd, 0xd5, 0xfe, 0x25, + 0x78, 0xe6, 0xe6, 0x1b, 0x3d, 0x6e, 0x4b, 0xc9, 0x8e, 0x87, 0x77, 0xe2, + 0x2b, 0x18, 0xb5, 0x79, 0x52, 0x65, 0x89, 0xbc, 0xd8, 0xaf, 0x5b, 0x51, + 0x37, 0x17, 0x32, 0xa3, 0x04, 0x81, 0x22, 0x73, 0x24, 0xc0, 0x21, 0x24, + 0x85, 0x2c, 0x58, 0x7e, 0x8a, 0x7e, 0xd8, 0x5f, 0xb3, 0x97, 0xc3, 0x8f, + 0xd9, 0x27, 0xc3, 0x5a, 0xbf, 0x89, 0x3c, 0x71, 0xa9, 0xea, 0x7a, 0x8f, + 0x88, 0xe6, 0xbd, 0x87, 0x48, 0xf0, 0x3e, 0x8d, 0xa6, 0xeb, 0x46, 0x3b, + 0x3b, 0x68, 0xfe, 0xf4, 0x91, 0xde, 0x5b, 0x40, 0x04, 0xea, 0xf6, 0xa9, + 0xb5, 0x4b, 0xcc, 0x1d, 0x4b, 0x7d, 0xe4, 0x6d, 0xc0, 0x0f, 0xe7, 0x07, + 0xe3, 0xff, 0x00, 0xc6, 0xef, 0x89, 0x5f, 0x12, 0x75, 0x9b, 0x8d, 0x0b, + 0xc4, 0xfa, 0xc5, 0xe5, 0xec, 0x50, 0x5c, 0x7e, 0xf6, 0x2d, 0x46, 0x76, + 0x99, 0xa1, 0x98, 0x29, 0x89, 0x84, 0x5b, 0x89, 0x2d, 0x90, 0x36, 0xf2, + 0x03, 0x1e, 0xa4, 0x13, 0x9c, 0xff, 0x00, 0x3c, 0xcb, 0x26, 0xc4, 0x61, + 0xe6, 0xa9, 0xce, 0x76, 0x7d, 0x52, 0x7a, 0x2e, 0xcf, 0xfc, 0x5a, 0xf9, + 0x1e, 0x34, 0x6b, 0xf4, 0x67, 0x85, 0xf8, 0xff, 0x00, 0xc7, 0x10, 0x5c, + 0xde, 0xdf, 0xea, 0xd7, 0xd7, 0x36, 0xda, 0x8d, 0xe5, 0xfb, 0xbd, 0xe4, + 0x4d, 0x6c, 0x8d, 0xf6, 0x75, 0x9e, 0x49, 0x4f, 0x98, 0x36, 0x48, 0x7f, + 0x76, 0x00, 0xc9, 0x45, 0x25, 0x89, 0xf9, 0x72, 0x15, 0x46, 0xda, 0xf9, + 0x9f, 0xc4, 0xe7, 0x53, 0xbf, 0xd4, 0xa4, 0xb7, 0xd5, 0xad, 0x9e, 0xde, + 0xf0, 0x49, 0x2c, 0x32, 0xdb, 0xc8, 0xac, 0x93, 0x2b, 0x8c, 0xee, 0x46, + 0x89, 0xb0, 0xc9, 0xcf, 0x63, 0x93, 0xea, 0x4f, 0x04, 0xfb, 0x2e, 0xa4, + 0x2e, 0xad, 0x5e, 0xea, 0xc0, 0x34, 0x46, 0xe7, 0x6b, 0xdd, 0x46, 0xb2, + 0x28, 0x75, 0x95, 0x8b, 0x63, 0x0b, 0xb8, 0x10, 0xdd, 0xf0, 0x32, 0x72, + 0x32, 0x4d, 0x78, 0x16, 0xa5, 0x79, 0x12, 0x6a, 0xb2, 0xdd, 0x97, 0x90, + 0x1f, 0xb3, 0x15, 0x77, 0x2e, 0x5a, 0x43, 0x20, 0xc8, 0xce, 0xec, 0xe7, + 0x07, 0x23, 0x39, 0xec, 0x6b, 0xeb, 0x72, 0xea, 0x09, 0x41, 0xa4, 0xb5, + 0xfc, 0xff, 0x00, 0x23, 0x6a, 0x4e, 0xe8, 0xfa, 0x2b, 0xc3, 0x3f, 0x12, + 0x7c, 0x61, 0xf0, 0xe2, 0xf7, 0xc3, 0x3f, 0x13, 0xbc, 0x11, 0x05, 0xe4, + 0x5a, 0x85, 0x96, 0x74, 0xc7, 0xd5, 0x94, 0x4a, 0xaa, 0x9f, 0x6a, 0x50, + 0xcb, 0x01, 0x9a, 0x36, 0x01, 0x24, 0x65, 0x46, 0xe0, 0x30, 0x26, 0x32, + 0xf9, 0x04, 0x16, 0x15, 0xdf, 0x5f, 0xfc, 0x53, 0xb8, 0xf0, 0x36, 0xa3, + 0x20, 0xf0, 0x24, 0x07, 0x52, 0xba, 0xbd, 0xb3, 0x16, 0x9a, 0xd4, 0x9a, + 0xba, 0x4b, 0xe4, 0xc5, 0x75, 0x37, 0x37, 0x30, 0x85, 0x8a, 0xe0, 0x07, + 0x5d, 0xdf, 0x2b, 0x06, 0x0a, 0x71, 0x94, 0x38, 0x1b, 0xc1, 0xf3, 0x0d, + 0x7a, 0xfb, 0xc3, 0x77, 0x1e, 0x03, 0xf0, 0xee, 0x8f, 0xa4, 0xea, 0x56, + 0xbf, 0x6b, 0x29, 0x26, 0xa1, 0x7e, 0xb1, 0xc7, 0x2c, 0x1f, 0x65, 0x96, + 0x00, 0xe1, 0x61, 0x9d, 0x8a, 0xed, 0x9a, 0x49, 0x3e, 0x42, 0x8e, 0x87, + 0x11, 0xa9, 0xda, 0x7b, 0x9a, 0xfb, 0x83, 0xf6, 0x6b, 0xf0, 0x6f, 0x88, + 0x7e, 0x21, 0xfc, 0x3d, 0x83, 0xe1, 0x77, 0xc1, 0x9f, 0x02, 0xb5, 0xf7, + 0x88, 0xa7, 0xd4, 0x2e, 0x1b, 0x58, 0xf1, 0x43, 0x42, 0x6e, 0xa5, 0x92, + 0xc1, 0xa2, 0x48, 0x0c, 0x56, 0x2f, 0xb1, 0x3c, 0x90, 0x80, 0xc8, 0xf3, + 0x65, 0x97, 0x74, 0x6f, 0xc9, 0x8c, 0xa9, 0x66, 0xee, 0x8e, 0x40, 0xa7, + 0x18, 0xb4, 0xaf, 0x6f, 0xf3, 0xd2, 0xff, 0x00, 0x7e, 0x86, 0x55, 0x2b, + 0x28, 0xb3, 0xe4, 0x2b, 0x7f, 0x88, 0x16, 0xfe, 0x2d, 0x58, 0xef, 0xfc, + 0x55, 0x15, 0xf3, 0xcb, 0x69, 0x6d, 0x0d, 0x85, 0xb5, 0xc4, 0x13, 0xac, + 0x41, 0x21, 0x51, 0xb4, 0xc3, 0x15, 0xba, 0x95, 0x8c, 0xa6, 0xd6, 0x60, + 0xa1, 0x11, 0x46, 0x09, 0xdd, 0xbb, 0x9c, 0x6f, 0x7c, 0x59, 0xf1, 0xef, + 0x87, 0xf5, 0x4f, 0x0d, 0x5a, 0xcb, 0xe1, 0x9b, 0x2d, 0x62, 0xc2, 0x7b, + 0x56, 0x31, 0xdf, 0xa6, 0xa3, 0xe4, 0x41, 0x0a, 0x79, 0x88, 0x78, 0xb6, + 0x58, 0xf7, 0x48, 0xcc, 0x76, 0xff, 0x00, 0xac, 0x90, 0xfc, 0xc3, 0x0b, + 0x81, 0xb7, 0x2f, 0xf6, 0xcf, 0xc5, 0x9f, 0xd9, 0x0f, 0xc3, 0xdf, 0x06, + 0xed, 0x64, 0x4b, 0xa8, 0xf5, 0x9b, 0x5d, 0x72, 0xfe, 0xe7, 0x4f, 0x5d, + 0x2f, 0x43, 0xb9, 0x8d, 0x4d, 0xf5, 0x80, 0xb9, 0x24, 0xc3, 0xf6, 0xa1, + 0x06, 0x02, 0x4b, 0x30, 0x42, 0xc9, 0x1a, 0xae, 0xe1, 0xca, 0xef, 0x76, + 0x42, 0xb5, 0xf0, 0xff, 0x00, 0x8e, 0x7c, 0x39, 0x77, 0xac, 0x69, 0xba, + 0x8e, 0x83, 0xe6, 0x4d, 0xa9, 0xdc, 0xdc, 0x62, 0x4d, 0x3d, 0xe4, 0xb4, + 0x6f, 0xb7, 0x35, 0xc4, 0x2e, 0x1e, 0x37, 0x56, 0x93, 0x64, 0xe9, 0x1b, + 0xc0, 0x4e, 0x78, 0x70, 0xe7, 0xb7, 0x71, 0xce, 0xf2, 0xe9, 0x53, 0xa8, + 0x95, 0x45, 0x6f, 0xcb, 0xe5, 0xea, 0x61, 0x1c, 0x4a, 0x94, 0x8f, 0x0e, + 0x9f, 0x50, 0xd2, 0x6f, 0x35, 0x54, 0xb5, 0xb1, 0x96, 0xe1, 0xed, 0x7c, + 0xdd, 0xa8, 0xf8, 0xf2, 0x24, 0xc4, 0x85, 0x37, 0x17, 0xcb, 0xc8, 0xaa, + 0x32, 0x76, 0x86, 0xdd, 0xdc, 0x16, 0xce, 0x38, 0x92, 0x2b, 0xbb, 0xfd, + 0x2b, 0xc5, 0x1f, 0xf0, 0x8f, 0xdb, 0x97, 0xdf, 0x04, 0xb2, 0x05, 0x65, + 0x9b, 0x20, 0xc9, 0x1b, 0x1c, 0x9f, 0x35, 0x48, 0xde, 0xa4, 0x00, 0x37, + 0x2f, 0x27, 0xaa, 0xf5, 0x02, 0xba, 0x8b, 0x0f, 0x03, 0xe9, 0xb6, 0xfe, + 0x24, 0xd3, 0x66, 0xd3, 0xc4, 0x76, 0xa8, 0xba, 0x70, 0xba, 0x9d, 0xaf, + 0x1f, 0xe4, 0x33, 0x42, 0x5c, 0x11, 0x94, 0x0b, 0x80, 0xe0, 0x20, 0xc3, + 0x90, 0xc4, 0xf2, 0x71, 0xb8, 0x0a, 0xd2, 0xf0, 0x4e, 0x91, 0xe3, 0x36, + 0xf1, 0xce, 0xa7, 0xe3, 0xdd, 0x0b, 0x4e, 0x8e, 0x54, 0xd0, 0x83, 0xea, + 0x77, 0x61, 0x63, 0x69, 0xe0, 0xb7, 0x59, 0x27, 0x58, 0x83, 0x34, 0x6d, + 0x27, 0x28, 0x92, 0x30, 0x50, 0x1c, 0x95, 0x24, 0x00, 0xf9, 0x04, 0xe7, + 0xdb, 0x8d, 0x04, 0xae, 0xd6, 0xc9, 0x7f, 0x5f, 0x71, 0xd5, 0xed, 0x23, + 0xb9, 0xed, 0xfa, 0x0f, 0xc5, 0x49, 0xf5, 0xbb, 0x58, 0x6c, 0x6f, 0x63, + 0x46, 0x95, 0xfe, 0x69, 0xa4, 0x41, 0x3b, 0xcb, 0x08, 0x25, 0x41, 0x74, + 0x56, 0x32, 0x2a, 0xec, 0x39, 0x01, 0x97, 0x69, 0x1b, 0x8f, 0x71, 0x96, + 0xf4, 0x56, 0xf1, 0x7f, 0x85, 0xbc, 0x27, 0x72, 0xf7, 0x36, 0xfa, 0xba, + 0x5c, 0x45, 0x2d, 0x99, 0x69, 0x20, 0x82, 0x4f, 0xdf, 0x0b, 0x80, 0xbc, + 0xa1, 0x73, 0x21, 0x1b, 0x33, 0x86, 0x2d, 0x9d, 0xe7, 0x90, 0x30, 0x05, + 0x7c, 0x89, 0xe1, 0xcb, 0x2b, 0x9d, 0x63, 0xc5, 0xd7, 0x12, 0xcf, 0x35, + 0xae, 0x9a, 0xcb, 0x25, 0xd3, 0xc7, 0x01, 0x42, 0xb0, 0xab, 0x96, 0xda, + 0x61, 0xb7, 0x89, 0xd9, 0xf2, 0x08, 0x77, 0x0a, 0x0e, 0xe2, 0x0e, 0x39, + 0xcf, 0x23, 0xbe, 0xb6, 0xb9, 0xb6, 0xf8, 0x57, 0xe3, 0xbd, 0x33, 0x5b, + 0xf0, 0xfc, 0xf6, 0x3a, 0x9c, 0xb0, 0x5a, 0xc1, 0xa9, 0xc8, 0xf0, 0x44, + 0xb2, 0xc5, 0x0d, 0xc3, 0xe5, 0xbc, 0x96, 0x59, 0xd3, 0x6c, 0xad, 0x17, + 0x01, 0xf7, 0x26, 0xd2, 0xe0, 0xa8, 0xdc, 0x06, 0xe6, 0xf0, 0xeb, 0x65, + 0x34, 0xe4, 0xd4, 0xb6, 0xf4, 0x32, 0x9c, 0x93, 0xd8, 0xfa, 0x7b, 0xc0, + 0xda, 0xef, 0xc4, 0x2d, 0x72, 0x39, 0x7c, 0x47, 0xa7, 0xc4, 0xfb, 0x44, + 0x4d, 0x2d, 0xbc, 0x32, 0xb2, 0x19, 0x2e, 0x25, 0x42, 0xb9, 0x58, 0x23, + 0x6d, 0xf2, 0xbc, 0xdb, 0x5b, 0x12, 0x6d, 0x1d, 0x08, 0xc9, 0xe4, 0x57, + 0xba, 0xe9, 0x5f, 0x16, 0x6f, 0xfc, 0x2d, 0x75, 0x0b, 0x36, 0xb7, 0x04, + 0x76, 0xf7, 0x76, 0x91, 0xb5, 0xe6, 0x9d, 0x6d, 0x6d, 0x0b, 0x18, 0x7c, + 0xf2, 0x41, 0xf3, 0xa3, 0x91, 0xc0, 0x57, 0x3b, 0x4f, 0x98, 0xac, 0xa3, + 0x67, 0x1c, 0xe0, 0x8c, 0xf8, 0x2c, 0x1e, 0x3c, 0xd2, 0x7c, 0x57, 0xa6, + 0xc9, 0x7a, 0xe9, 0x34, 0x5a, 0xb3, 0x83, 0x2e, 0x9d, 0xa8, 0xbc, 0xc9, + 0x0d, 0xa3, 0x5e, 0x33, 0x00, 0xf2, 0xcf, 0x12, 0x44, 0x1d, 0x4e, 0xc6, + 0xf2, 0xf6, 0x46, 0x4a, 0x65, 0x83, 0x9e, 0x71, 0x9f, 0x18, 0xf1, 0x24, + 0x5a, 0x37, 0x8a, 0x35, 0x14, 0xd5, 0xec, 0xee, 0x64, 0x82, 0xfe, 0xeb, + 0x55, 0x30, 0xde, 0xda, 0xc3, 0x1a, 0x49, 0x1c, 0x50, 0x95, 0xc3, 0xcc, + 0x6e, 0x73, 0xf3, 0x33, 0xee, 0x39, 0xf9, 0x14, 0x00, 0x37, 0x64, 0xe7, + 0x03, 0x87, 0x13, 0x93, 0xe1, 0xea, 0xa6, 0xe5, 0xa3, 0x31, 0xb3, 0xe8, + 0x7e, 0xb1, 0x78, 0x23, 0xc5, 0x1e, 0x0c, 0xf1, 0x2d, 0xb4, 0x56, 0x5e, + 0x1e, 0xbf, 0xb2, 0x99, 0x66, 0x8d, 0x12, 0xe2, 0x78, 0x2d, 0x52, 0xd4, + 0x4b, 0x22, 0xee, 0x06, 0x26, 0x02, 0x46, 0x5e, 0x37, 0x2b, 0xab, 0x85, + 0x25, 0x5f, 0xd4, 0x61, 0x8f, 0xea, 0x87, 0xec, 0x6d, 0xaf, 0xdf, 0xfc, + 0x3a, 0xf8, 0xd3, 0xe1, 0xad, 0x5f, 0xc2, 0x3f, 0xda, 0xfa, 0xdf, 0xf6, + 0x56, 0x04, 0xf6, 0x50, 0xe9, 0x7e, 0x64, 0xf7, 0x20, 0x33, 0x35, 0xc5, + 0xb5, 0xa2, 0x36, 0xe5, 0x39, 0x65, 0x3b, 0x19, 0x5a, 0x32, 0x4e, 0xd6, + 0x1d, 0x48, 0xaf, 0xe7, 0x33, 0xc3, 0x5e, 0x0f, 0x6f, 0x0c, 0xeb, 0xd1, + 0xf8, 0xef, 0xc1, 0xb6, 0x72, 0x1b, 0x7b, 0x49, 0x9e, 0x6b, 0x67, 0xb5, + 0x94, 0xcb, 0x22, 0xc6, 0x08, 0x50, 0xd2, 0x21, 0x18, 0x93, 0x60, 0x26, + 0x47, 0x2c, 0x01, 0xc0, 0x66, 0xda, 0x14, 0x01, 0x5f, 0xbc, 0xff, 0x00, + 0xb2, 0x6f, 0xc4, 0xbf, 0x82, 0x7e, 0x0a, 0xf0, 0xde, 0x99, 0xe3, 0xad, + 0x62, 0xf3, 0x5c, 0xbb, 0xd4, 0x6c, 0x0c, 0x76, 0x92, 0xf8, 0x77, 0x53, + 0xbb, 0xbe, 0x86, 0x3b, 0x9b, 0x88, 0x16, 0x39, 0x5a, 0x4b, 0x29, 0xec, + 0x60, 0x11, 0xc3, 0x20, 0x72, 0x16, 0x23, 0x3c, 0xae, 0x00, 0x20, 0xba, + 0xa7, 0xcb, 0x9f, 0x3b, 0x01, 0x93, 0x38, 0xe2, 0x23, 0x3f, 0x6f, 0xcb, + 0x15, 0xae, 0xba, 0x3d, 0x1d, 0xf4, 0xd5, 0xef, 0xd9, 0xd9, 0xdc, 0xcb, + 0xda, 0xeb, 0x67, 0xd0, 0xfe, 0xbd, 0x7e, 0x18, 0xfc, 0x59, 0x5f, 0x1c, + 0x78, 0x5b, 0x4f, 0xd5, 0x7c, 0x59, 0xa7, 0xcb, 0xe1, 0x8d, 0x53, 0x50, + 0x86, 0x4b, 0xa4, 0xd0, 0xf5, 0x72, 0xb6, 0xf7, 0x4b, 0x12, 0xb6, 0x01, + 0x11, 0xbb, 0x07, 0x6d, 0xa0, 0xa8, 0x73, 0xb4, 0x0d, 0xdd, 0x3e, 0x5c, + 0x13, 0xf2, 0x47, 0xed, 0xb1, 0xfb, 0x6b, 0xe9, 0xff, 0x00, 0xb2, 0xe5, + 0xc6, 0x8f, 0xa3, 0x4b, 0x1d, 0xb4, 0xff, 0x00, 0xf0, 0x91, 0x5b, 0x5c, + 0xc3, 0x15, 0xe4, 0x37, 0x0a, 0xd3, 0x69, 0xf7, 0x20, 0x06, 0xb7, 0x96, + 0x68, 0x70, 0xdf, 0xe8, 0xf2, 0x28, 0x71, 0xbf, 0xbb, 0x0c, 0x0e, 0x86, + 0xbf, 0x0d, 0x7f, 0x6a, 0x3f, 0xda, 0x7b, 0x53, 0xf1, 0x4f, 0xc3, 0x4b, + 0xc7, 0xd0, 0xae, 0xef, 0xac, 0xbf, 0xb2, 0xbc, 0xef, 0xec, 0x2b, 0x9b, + 0x6b, 0xd9, 0x2e, 0xef, 0xed, 0x11, 0x2e, 0x8c, 0xeb, 0xf6, 0xa7, 0x9a, + 0x56, 0x92, 0x59, 0x90, 0x14, 0x89, 0xcb, 0x37, 0xfa, 0xb5, 0x1c, 0x96, + 0xc9, 0xaf, 0xcc, 0xed, 0x4b, 0xf6, 0x9d, 0xd4, 0xee, 0x34, 0xbb, 0x1f, + 0x8a, 0x3f, 0x1b, 0xae, 0x6f, 0x6e, 0x6e, 0x61, 0xb3, 0xfb, 0x13, 0xde, + 0x4b, 0x70, 0xc8, 0x26, 0xdc, 0x02, 0x46, 0xe0, 0xb9, 0x69, 0x19, 0x44, + 0x00, 0x65, 0x1f, 0xca, 0x0b, 0xcf, 0x04, 0xe0, 0xd7, 0xd5, 0xe7, 0xbc, + 0x77, 0x51, 0x50, 0x9d, 0x1c, 0x12, 0xe6, 0x93, 0x49, 0x29, 0x27, 0xae, + 0xab, 0xb5, 0xb7, 0xfc, 0xb7, 0xb2, 0x3a, 0x3e, 0xb3, 0x76, 0xa2, 0x7d, + 0x9b, 0xe2, 0x8d, 0x52, 0x6f, 0xda, 0x17, 0xc4, 0x17, 0xbe, 0x39, 0xb0, + 0xf1, 0x3e, 0xa3, 0x73, 0x74, 0xda, 0x83, 0x6a, 0x17, 0x92, 0xdc, 0xc9, + 0x18, 0x45, 0x8d, 0xe7, 0x69, 0x4d, 0xa4, 0x53, 0x26, 0xed, 0xb0, 0x06, + 0x24, 0xa9, 0x18, 0xc0, 0x1d, 0x0e, 0x45, 0x78, 0x56, 0xb3, 0xf1, 0xd7, + 0x52, 0xf8, 0x5f, 0x76, 0xfa, 0x7d, 0xf4, 0xf7, 0xa9, 0xa6, 0xda, 0xa0, + 0x9e, 0x14, 0xfb, 0x47, 0x9d, 0x77, 0x79, 0x21, 0x2d, 0xbd, 0x1f, 0x80, + 0xbc, 0x11, 0xc3, 0x60, 0xe4, 0x11, 0xca, 0x90, 0x48, 0xf0, 0x6b, 0x6f, + 0x8c, 0x1a, 0x4e, 0x87, 0xa3, 0x3f, 0x89, 0x34, 0x5b, 0xb7, 0x8a, 0x2b, + 0xa7, 0x37, 0x33, 0xc7, 0x6f, 0x37, 0x97, 0xb6, 0x29, 0x57, 0x69, 0xf2, + 0xf6, 0xb1, 0x2a, 0xbb, 0x18, 0x3f, 0xcd, 0xf3, 0x73, 0xc0, 0x03, 0x04, + 0x7c, 0xe1, 0xfb, 0x40, 0x7c, 0x4e, 0xd0, 0x26, 0xf0, 0xe8, 0x16, 0xfa, + 0xb4, 0xd7, 0x92, 0x37, 0xef, 0xe7, 0x9c, 0xce, 0x43, 0xc7, 0x1c, 0x8a, + 0x07, 0x94, 0x9b, 0x24, 0x00, 0x29, 0x18, 0x57, 0x38, 0xce, 0x08, 0xc8, + 0x23, 0xa7, 0xe0, 0xd1, 0xc0, 0xe2, 0x71, 0xb5, 0x9c, 0x2b, 0xbe, 0x64, + 0xde, 0xfb, 0xbf, 0xbd, 0x7f, 0x5a, 0xf7, 0xd4, 0xdb, 0x9a, 0x2a, 0xdc, + 0xba, 0x33, 0xd3, 0xfc, 0x75, 0xfb, 0x79, 0x68, 0xfa, 0xd1, 0xbc, 0xd2, + 0xb4, 0x87, 0xd5, 0x2d, 0xee, 0xe5, 0x50, 0xf7, 0x16, 0x7f, 0xbd, 0x0b, + 0x32, 0x4b, 0x8c, 0x89, 0x06, 0xf6, 0x03, 0x19, 0xf9, 0xf0, 0xac, 0x73, + 0x93, 0xce, 0xd0, 0x2b, 0xe4, 0x0f, 0x0d, 0x7e, 0xd4, 0x17, 0x9a, 0x07, + 0x8d, 0xe3, 0xb7, 0xb5, 0xb2, 0x4d, 0x02, 0xe1, 0x2f, 0x3c, 0xc8, 0xa5, + 0xf2, 0x16, 0xe2, 0xe4, 0x2b, 0x11, 0x90, 0x5e, 0x76, 0x40, 0xbb, 0x9b, + 0x6b, 0x72, 0x47, 0x04, 0x60, 0xed, 0xe2, 0xbe, 0x27, 0xf1, 0x87, 0x8b, + 0x56, 0xeb, 0x5e, 0xb9, 0xd3, 0x74, 0x19, 0xa1, 0xb5, 0x12, 0x49, 0xf2, + 0x30, 0x91, 0xc2, 0x65, 0x06, 0x14, 0x92, 0x77, 0x31, 0x04, 0x12, 0x47, + 0xd3, 0xa7, 0x27, 0x35, 0x6c, 0xad, 0x7e, 0xdf, 0x30, 0xd6, 0x3c, 0x50, + 0xf3, 0x8b, 0x79, 0x16, 0x4b, 0x88, 0x2e, 0x6d, 0xe4, 0x0c, 0xeb, 0x2a, + 0xe1, 0x46, 0x51, 0xcb, 0x00, 0x09, 0x20, 0x00, 0x40, 0x1b, 0x78, 0x07, + 0x18, 0xaf, 0xbd, 0xcb, 0xf8, 0x57, 0x0d, 0x41, 0x49, 0xa4, 0xf6, 0xea, + 0xdd, 0xef, 0xe5, 0xfd, 0x32, 0x64, 0xa4, 0xde, 0xa7, 0xee, 0xae, 0x8d, + 0xfb, 0x56, 0x1f, 0x11, 0x78, 0xe2, 0xca, 0x3b, 0xad, 0x6f, 0x54, 0xb6, + 0x55, 0xf2, 0x5f, 0x50, 0xd5, 0xa3, 0x53, 0x23, 0x5b, 0x5b, 0x38, 0x48, + 0xe7, 0x79, 0x22, 0x88, 0x86, 0x96, 0x1d, 0xfb, 0x8a, 0xc4, 0xe7, 0x6a, + 0x80, 0x15, 0x48, 0x6c, 0x9a, 0xc6, 0xf8, 0xc3, 0xf1, 0x67, 0xc0, 0xfe, + 0x2f, 0x7d, 0x37, 0x4f, 0x9a, 0xfa, 0xce, 0x5b, 0x1d, 0x1a, 0x25, 0xb0, + 0xb4, 0x1a, 0x5e, 0xeb, 0x54, 0x90, 0x5a, 0x33, 0x94, 0x99, 0xe0, 0x00, + 0x28, 0x92, 0x61, 0xb4, 0xc9, 0xb4, 0x97, 0x60, 0x76, 0xe7, 0x03, 0x35, + 0xf8, 0xd5, 0xa2, 0x78, 0xd3, 0x58, 0xd2, 0x96, 0x28, 0xad, 0x6e, 0x36, + 0x9b, 0xc2, 0xb1, 0xb2, 0xce, 0x44, 0x1e, 0x58, 0x90, 0x7c, 0xa1, 0xe4, + 0x04, 0x06, 0x0c, 0xaa, 0x77, 0x7c, 0xa0, 0x7c, 0xa3, 0x8e, 0x95, 0xf4, + 0xe7, 0xc0, 0xdb, 0x4f, 0x0e, 0x7c, 0x45, 0x87, 0x54, 0xb3, 0xd7, 0x64, + 0x8a, 0xce, 0x48, 0x20, 0x9a, 0xdc, 0xdd, 0xea, 0x31, 0xca, 0xad, 0x1d, + 0xc0, 0x06, 0x28, 0xad, 0xc2, 0x96, 0x76, 0x32, 0x6e, 0x2a, 0xc1, 0xc6, + 0xd4, 0x04, 0x10, 0x54, 0x92, 0x2b, 0xcf, 0xc4, 0xe5, 0x3e, 0xcd, 0x73, + 0xb9, 0xf2, 0xc7, 0xab, 0xff, 0x00, 0x81, 0xfd, 0x3e, 0xdd, 0x89, 0xe4, + 0x67, 0xec, 0x5f, 0xc2, 0x2f, 0xf8, 0x28, 0x00, 0xf8, 0x5b, 0x69, 0x37, + 0x80, 0x7c, 0x12, 0x6d, 0x74, 0xf4, 0x96, 0xe1, 0x26, 0x7b, 0xc6, 0x55, + 0x69, 0xa2, 0x5c, 0xf2, 0xb6, 0xf2, 0x46, 0x54, 0x21, 0x7c, 0xb1, 0xdd, + 0xb7, 0x78, 0x18, 0x42, 0xc7, 0x35, 0xea, 0x7e, 0x23, 0xfd, 0xa9, 0xfe, + 0x30, 0xda, 0xdc, 0xdf, 0xf8, 0x8f, 0x4f, 0xf1, 0x75, 0xe5, 0xdb, 0x6b, + 0xf0, 0x99, 0xbc, 0x45, 0x66, 0x2f, 0x1a, 0x33, 0x72, 0x62, 0x54, 0x68, + 0xe5, 0x6d, 0x8c, 0x32, 0xa0, 0x2a, 0x8d, 0xa8, 0x43, 0xee, 0x52, 0x55, + 0x81, 0x2d, 0x5f, 0x81, 0xff, 0x00, 0x10, 0x7e, 0x1e, 0xf8, 0xcf, 0xe0, + 0x7b, 0x36, 0xa7, 0xa6, 0xa5, 0xed, 0xf5, 0x92, 0x42, 0xb1, 0x5d, 0x5f, + 0xc6, 0x64, 0x56, 0x85, 0x83, 0x04, 0x0d, 0x95, 0x2c, 0x0c, 0x6d, 0x9c, + 0x8e, 0x71, 0x82, 0x47, 0x5a, 0xe4, 0x34, 0x7f, 0x8b, 0x9a, 0x8d, 0x84, + 0xd1, 0x26, 0xa6, 0x97, 0x88, 0x66, 0x52, 0xb6, 0x9b, 0xc3, 0x42, 0x8e, + 0xe9, 0xd5, 0xc3, 0x93, 0x86, 0x65, 0xc8, 0x07, 0x8e, 0x3b, 0xf6, 0xae, + 0x3a, 0x38, 0x5c, 0x54, 0x9c, 0x65, 0x85, 0xc4, 0xb7, 0x05, 0x7d, 0x9b, + 0xb5, 0xfa, 0xe9, 0x75, 0x67, 0xbf, 0xc9, 0x8e, 0x53, 0x76, 0x3f, 0x72, + 0x1f, 0xf6, 0xc8, 0xf8, 0x89, 0x67, 0x70, 0xbe, 0x06, 0xf0, 0x36, 0xad, + 0x3d, 0x8d, 0xc5, 0xd5, 0xbf, 0xf6, 0x4c, 0x52, 0x48, 0x76, 0x39, 0x5b, + 0x80, 0xc0, 0xc0, 0x5a, 0x63, 0x29, 0x8a, 0x36, 0x66, 0x2a, 0xc2, 0x27, + 0x53, 0x28, 0x20, 0x1e, 0x82, 0xbb, 0x0f, 0x82, 0x1f, 0x16, 0x7c, 0x1f, + 0xe3, 0xad, 0x2f, 0x58, 0x1f, 0x11, 0xae, 0x7f, 0xb6, 0x3c, 0x40, 0xd2, + 0x45, 0x69, 0xa4, 0x69, 0x70, 0x49, 0x79, 0x1d, 0xa5, 0xe6, 0x56, 0xde, + 0x02, 0xf3, 0xc4, 0xd2, 0xa1, 0x90, 0xe4, 0x39, 0x25, 0x1d, 0x59, 0x9a, + 0x21, 0xf2, 0xe3, 0x0c, 0xbf, 0x82, 0x1a, 0x47, 0xc5, 0xcf, 0x15, 0x78, + 0x8f, 0x5f, 0x93, 0x4c, 0xf0, 0xcd, 0xcb, 0x4f, 0x70, 0x1f, 0x6b, 0x49, + 0x72, 0xc8, 0x1e, 0x29, 0x94, 0x73, 0x92, 0x5b, 0x20, 0x83, 0x81, 0xd3, + 0x21, 0xb3, 0x8c, 0xf5, 0xaf, 0xe8, 0x27, 0xf6, 0x0b, 0xfd, 0x83, 0xfc, + 0x4e, 0xda, 0xd7, 0x86, 0x6e, 0xfc, 0x41, 0xe2, 0x5f, 0x0d, 0xe9, 0x3e, + 0x36, 0x96, 0xfa, 0xdf, 0xc4, 0x76, 0x5a, 0x6e, 0xa9, 0x75, 0xe4, 0xf9, + 0x96, 0xca, 0xd1, 0xbc, 0x2e, 0x8d, 0xf6, 0x79, 0x09, 0xdb, 0x0b, 0x8b, + 0x9d, 0x92, 0x15, 0xdd, 0x88, 0xc4, 0x61, 0x8b, 0x19, 0x57, 0xed, 0x72, + 0x7c, 0x36, 0x31, 0xb5, 0x4e, 0xb4, 0xae, 0xb4, 0x56, 0x6e, 0xfb, 0xed, + 0xbf, 0xe1, 0xf7, 0x9c, 0x2d, 0xbb, 0xec, 0x7e, 0xb9, 0x7c, 0x1e, 0xfd, + 0x9f, 0xff, 0x00, 0x65, 0x7f, 0x86, 0xde, 0x24, 0xd2, 0x3c, 0x6f, 0xfb, + 0x4d, 0xcd, 0xa6, 0x5b, 0x5d, 0x78, 0x8e, 0xc1, 0x0e, 0x99, 0xab, 0x34, + 0x4b, 0x77, 0xa1, 0xca, 0x6f, 0xad, 0x9a, 0x48, 0xa4, 0x8e, 0xfa, 0xe2, + 0xea, 0xe6, 0x06, 0x09, 0x0c, 0x86, 0x21, 0xf6, 0xab, 0x76, 0x53, 0xf2, + 0x48, 0x0e, 0xf6, 0x04, 0x7d, 0xb9, 0x65, 0xfb, 0x16, 0x7c, 0x3b, 0x79, + 0xa3, 0x99, 0x74, 0x3f, 0x09, 0x6a, 0x9a, 0x44, 0x3a, 0xa5, 0xac, 0xda, + 0x24, 0x90, 0xc7, 0x35, 0xac, 0x56, 0xba, 0x7c, 0xd3, 0x89, 0x6e, 0x25, + 0x8a, 0x28, 0x65, 0x74, 0x6b, 0xa3, 0x21, 0x25, 0x4e, 0x23, 0x86, 0x2e, + 0x4c, 0x48, 0x09, 0x20, 0xfc, 0xdd, 0xfb, 0x44, 0xfc, 0x65, 0xf8, 0x21, + 0xe1, 0xbd, 0x0a, 0x3f, 0x00, 0x69, 0x1e, 0x09, 0xd3, 0xaf, 0xa7, 0xb3, + 0x81, 0xb4, 0x7b, 0x96, 0x36, 0x4d, 0x6b, 0x6d, 0x6f, 0x77, 0x6d, 0xbb, + 0xce, 0x5b, 0x6b, 0x29, 0x59, 0x8c, 0x31, 0x3e, 0xf6, 0x7d, 0x8c, 0x15, + 0xd9, 0x64, 0x52, 0x72, 0xbf, 0x35, 0x7a, 0x67, 0xec, 0xe5, 0xfb, 0x59, + 0xf8, 0x32, 0xd7, 0x5e, 0x97, 0xc3, 0x13, 0x98, 0x62, 0x8e, 0x41, 0x25, + 0xdc, 0x49, 0x1c, 0xa1, 0x96, 0xc2, 0xd1, 0x44, 0xb3, 0x6c, 0x32, 0x10, + 0xa1, 0xce, 0xf3, 0xf3, 0x31, 0x27, 0x73, 0x12, 0xc4, 0x92, 0x4d, 0x7e, + 0x99, 0x82, 0xa9, 0x83, 0xa7, 0x27, 0x84, 0xa9, 0x6e, 0x57, 0xe5, 0xa5, + 0xdf, 0x47, 0x7d, 0x19, 0xd4, 0xf4, 0xd9, 0x1e, 0xdb, 0xfb, 0x53, 0xfe, + 0xcb, 0x9f, 0xb2, 0x8e, 0xae, 0xde, 0x19, 0xd7, 0x7c, 0x49, 0x6b, 0x6b, + 0xa1, 0x6a, 0xf6, 0x97, 0xad, 0xa4, 0xf8, 0x63, 0xfb, 0x17, 0x4f, 0xb4, + 0x37, 0x13, 0xcc, 0xd6, 0xec, 0xe9, 0x64, 0x8b, 0xe5, 0xab, 0x79, 0x40, + 0x44, 0xcf, 0x85, 0x91, 0x3e, 0x63, 0xcb, 0xe0, 0x85, 0xaf, 0xe7, 0x0f, + 0xc6, 0x5f, 0xb4, 0x37, 0xc2, 0xaf, 0x85, 0x5e, 0x17, 0xbd, 0xf8, 0x71, + 0xf0, 0xae, 0xd1, 0x2e, 0x74, 0xdd, 0x0b, 0x5a, 0xbe, 0x09, 0xa8, 0x6a, + 0x31, 0xc6, 0x9a, 0x7e, 0xa1, 0x75, 0x23, 0xb2, 0xcf, 0x6f, 0xa9, 0xc1, + 0x2b, 0x5c, 0x49, 0x34, 0x50, 0x44, 0x86, 0x18, 0xe3, 0x8c, 0x34, 0x6a, + 0xad, 0xb8, 0x0d, 0xee, 0x09, 0xfd, 0xb6, 0xfd, 0xb8, 0xe6, 0xf0, 0x0f, + 0xc6, 0xbb, 0xad, 0x20, 0xe8, 0xd2, 0xe9, 0x33, 0x6a, 0x3a, 0x6a, 0xdb, + 0x46, 0x2e, 0x75, 0x3b, 0xa8, 0x55, 0x21, 0x17, 0x8c, 0x5c, 0x88, 0xe3, + 0x2b, 0x2a, 0xf9, 0x8a, 0x8b, 0x99, 0x4b, 0x23, 0x2a, 0xa9, 0x1c, 0x1c, + 0xf3, 0xf2, 0x1f, 0xc4, 0x4f, 0xd8, 0xde, 0xcb, 0xe2, 0xa7, 0x8c, 0xb4, + 0x0f, 0x0a, 0xdd, 0x0f, 0x04, 0x78, 0xb2, 0xcc, 0xde, 0x41, 0x26, 0xbb, + 0xa8, 0xf8, 0x6a, 0xc5, 0x77, 0x43, 0x0a, 0x4e, 0xed, 0xb5, 0xd1, 0x64, + 0xc4, 0x02, 0x28, 0xd4, 0x15, 0x78, 0xd3, 0x05, 0xe5, 0x29, 0x8c, 0x63, + 0x3f, 0x1d, 0xc5, 0xb9, 0x74, 0xf1, 0x15, 0xa7, 0x47, 0x08, 0x94, 0x6d, + 0x65, 0x75, 0xd5, 0x3b, 0x2b, 0x7e, 0x1d, 0x17, 0x4f, 0x93, 0xe8, 0x73, + 0xfb, 0x49, 0x1f, 0xff, 0xd2, 0xe4, 0xff, 0x00, 0x6b, 0xaf, 0x89, 0xbe, + 0x00, 0xf8, 0xb3, 0xf1, 0x63, 0x5c, 0xf1, 0x04, 0x2d, 0x71, 0xa9, 0x6a, + 0x3f, 0x64, 0x8e, 0x48, 0xae, 0x7c, 0x42, 0x2d, 0x91, 0xae, 0x2e, 0xc3, + 0x30, 0x90, 0xd9, 0x08, 0x56, 0x18, 0xa4, 0x0e, 0xb9, 0x1b, 0xd5, 0x19, + 0x82, 0x20, 0x01, 0xb9, 0x3b, 0xff, 0x00, 0x02, 0x7e, 0x20, 0x4c, 0xf7, + 0x3e, 0x2b, 0xba, 0x87, 0x57, 0xd3, 0xae, 0xb4, 0xf9, 0x52, 0x79, 0x3c, + 0xc9, 0x8a, 0x2b, 0x1c, 0xee, 0x63, 0x82, 0x54, 0x92, 0xc0, 0x9c, 0xe0, + 0x85, 0xc6, 0x39, 0xe7, 0x9a, 0xfb, 0x4f, 0x58, 0xf1, 0x6f, 0xc5, 0x2f, + 0x15, 0xfc, 0x65, 0xd2, 0xa5, 0xd2, 0x6c, 0xae, 0x6f, 0x2c, 0x2d, 0x7c, + 0x3f, 0xe6, 0x5d, 0x08, 0x2e, 0x55, 0x7e, 0xce, 0xec, 0x76, 0x82, 0xc3, + 0x0c, 0xb2, 0x14, 0x6d, 0xa4, 0x6d, 0x0c, 0x77, 0x6d, 0x23, 0x07, 0x91, + 0xe1, 0x5f, 0x10, 0xd0, 0xcb, 0xab, 0xdf, 0x6a, 0xfa, 0x81, 0x2a, 0x63, + 0x7e, 0x21, 0x96, 0x45, 0x95, 0x88, 0x2b, 0xf7, 0x9b, 0x78, 0x40, 0x76, + 0x82, 0xd8, 0x04, 0x1c, 0x9e, 0xbc, 0x12, 0x2b, 0xf1, 0x29, 0x51, 0xf6, + 0x78, 0xa9, 0x37, 0x24, 0xef, 0xae, 0xfd, 0x5f, 0xf9, 0x9f, 0x2b, 0x4e, + 0xbd, 0xdd, 0xd9, 0xe0, 0xde, 0x21, 0xbb, 0xd3, 0xf5, 0x1b, 0x07, 0xbd, + 0xd4, 0x9a, 0x65, 0xb9, 0x65, 0x21, 0x8c, 0x65, 0x0b, 0x47, 0xe5, 0x2e, + 0xf5, 0x08, 0xc7, 0x27, 0x3c, 0x82, 0xd8, 0x18, 0xe4, 0xf4, 0x35, 0xf3, + 0xa7, 0x8a, 0xe6, 0xb7, 0x91, 0x63, 0xd4, 0x60, 0xc0, 0x9c, 0x81, 0x6e, + 0x41, 0x50, 0x9b, 0x97, 0x69, 0xc3, 0x95, 0xc6, 0x33, 0xb9, 0x79, 0xed, + 0xfc, 0xab, 0xd9, 0x7c, 0x77, 0xa9, 0xc1, 0xa7, 0x59, 0x79, 0x2a, 0xa1, + 0x1f, 0x6a, 0xab, 0x13, 0xb3, 0xf7, 0xa5, 0x41, 0x32, 0x00, 0x8a, 0x3a, + 0x65, 0x82, 0xee, 0x04, 0xe7, 0x9e, 0xd9, 0xcf, 0xcf, 0x3e, 0x27, 0xd4, + 0x2c, 0xaf, 0xac, 0xa3, 0xd4, 0xad, 0x14, 0xa2, 0xab, 0xaa, 0x79, 0x51, + 0xf3, 0xb7, 0x0c, 0x33, 0x19, 0xc0, 0x1d, 0x49, 0xe3, 0x9e, 0x87, 0xeb, + 0x5f, 0x4d, 0x96, 0x51, 0xd1, 0x3b, 0x1e, 0xce, 0x19, 0x5c, 0xa7, 0xe1, + 0x8b, 0xe8, 0x66, 0xd7, 0xae, 0xa4, 0x63, 0x70, 0x60, 0x41, 0x2c, 0x8c, + 0x91, 0x03, 0xb0, 0x0d, 0xb9, 0x70, 0x54, 0x8c, 0x94, 0x5c, 0x1e, 0x73, + 0xd1, 0x47, 0xbe, 0x3f, 0x72, 0x7f, 0x64, 0xcf, 0xf8, 0x29, 0xe4, 0xdf, + 0xb1, 0x7e, 0x91, 0x6d, 0xe1, 0x9f, 0x84, 0x1e, 0x1e, 0xf0, 0x54, 0xe0, + 0x2c, 0xb6, 0xf7, 0x57, 0x9e, 0x25, 0xb0, 0x8f, 0x52, 0x6b, 0xc8, 0xae, + 0x6d, 0xe2, 0x49, 0xa3, 0x9a, 0xe8, 0x6c, 0x63, 0x02, 0xcb, 0x1b, 0xcb, + 0x1c, 0x0a, 0x87, 0x97, 0xe7, 0x79, 0x45, 0xcf, 0xe0, 0x16, 0x9b, 0x7e, + 0xb1, 0x5f, 0xdd, 0x99, 0xc1, 0x8f, 0xcc, 0x12, 0x0b, 0x72, 0x49, 0xc9, + 0x1f, 0x31, 0x2d, 0xd7, 0x19, 0x39, 0xf4, 0xe3, 0xa5, 0x6e, 0xeb, 0x5e, + 0x22, 0xbb, 0xb4, 0x91, 0xec, 0xa6, 0xb7, 0xf3, 0x6d, 0xc2, 0xc4, 0x02, + 0x09, 0x36, 0x36, 0x4a, 0x67, 0x80, 0x70, 0x72, 0x71, 0x8c, 0xe7, 0x8e, + 0xb8, 0xed, 0x5e, 0xb4, 0xa1, 0x5a, 0xef, 0xd9, 0xc9, 0xa2, 0x31, 0x34, + 0x6f, 0x2b, 0xa3, 0xf5, 0x1f, 0xe3, 0xa7, 0xed, 0x79, 0xe3, 0xaf, 0x8c, + 0x9e, 0x23, 0xbf, 0xf1, 0xd5, 0xe9, 0xb7, 0xb0, 0x92, 0xf3, 0x57, 0x93, + 0x55, 0xd5, 0xac, 0x6c, 0x65, 0x79, 0x20, 0xba, 0xba, 0x32, 0xbb, 0x6f, + 0x0f, 0x21, 0xf3, 0x3e, 0xcc, 0x80, 0x81, 0x1c, 0x25, 0x98, 0x27, 0x5e, + 0xa4, 0xd7, 0x39, 0x3f, 0x8e, 0xac, 0xfc, 0x63, 0xe0, 0xb8, 0xee, 0xfc, + 0x4b, 0x2d, 0xb4, 0x9a, 0xad, 0xbd, 0x8c, 0xf6, 0xd1, 0x5c, 0xdc, 0xbc, + 0xaf, 0x74, 0xb0, 0x84, 0x41, 0x6c, 0xf1, 0x16, 0x65, 0x84, 0x88, 0xc8, + 0xd9, 0xe5, 0xe0, 0x6d, 0x8d, 0xc9, 0x5d, 0xc4, 0x2a, 0xc7, 0xf9, 0xa1, + 0x6b, 0xe3, 0x4f, 0x10, 0xf9, 0x10, 0x59, 0x69, 0xab, 0x38, 0xb6, 0x95, + 0xc2, 0xdc, 0xdb, 0x4b, 0x23, 0x1d, 0x80, 0x71, 0xf2, 0xbf, 0x42, 0xb8, + 0x63, 0xc1, 0xf4, 0xe4, 0x73, 0x5e, 0xfb, 0xe1, 0x8f, 0x14, 0x6a, 0x9a, + 0x0d, 0xdc, 0x77, 0x9e, 0x1d, 0x92, 0xed, 0x2f, 0x23, 0x40, 0xa1, 0xed, + 0xa5, 0x68, 0x56, 0x38, 0xd8, 0x61, 0x9f, 0x7a, 0x10, 0x70, 0xc1, 0x88, + 0xea, 0xa7, 0x03, 0x9e, 0x6b, 0xcf, 0xaf, 0x46, 0xb4, 0x1a, 0x95, 0x47, + 0xcc, 0x79, 0xd5, 0x68, 0xa8, 0xea, 0x8f, 0xae, 0x7e, 0x0b, 0xfc, 0x47, + 0xf8, 0x7b, 0xe0, 0x5d, 0x62, 0xde, 0x5f, 0x88, 0x5a, 0x43, 0xf8, 0x9b, + 0x44, 0xba, 0xf0, 0xa4, 0xba, 0x6c, 0xb6, 0x57, 0x72, 0x79, 0x32, 0xdb, + 0xbc, 0xb2, 0x2b, 0x19, 0xad, 0xa7, 0x50, 0xcb, 0x13, 0x2b, 0xc6, 0x70, + 0x19, 0x1d, 0x70, 0x4f, 0x07, 0x3c, 0x32, 0xef, 0xe3, 0x4d, 0x85, 0xe7, + 0x8a, 0x7c, 0x73, 0x7d, 0xe0, 0x55, 0xb7, 0xd0, 0xf4, 0x4d, 0x56, 0xc1, + 0xac, 0x13, 0x42, 0xb7, 0x6b, 0x88, 0xed, 0xa7, 0xb3, 0x37, 0x25, 0xe3, + 0x88, 0xed, 0x75, 0xf3, 0x8c, 0x6d, 0x89, 0x7f, 0x78, 0x59, 0x77, 0x8c, + 0xf9, 0x67, 0x68, 0x51, 0xf1, 0x3e, 0xa7, 0x73, 0x73, 0x69, 0xaa, 0xa1, + 0x92, 0x55, 0x4b, 0x7f, 0xf5, 0x50, 0xa4, 0x72, 0xa1, 0x55, 0x0e, 0xc1, + 0x80, 0xc1, 0x21, 0xb1, 0x92, 0xdc, 0x64, 0xfa, 0xe6, 0xb5, 0x23, 0xb9, + 0xbc, 0x75, 0x8a, 0x7b, 0x26, 0x65, 0x44, 0x97, 0x6c, 0xa8, 0x50, 0x6e, + 0x27, 0x1c, 0x8e, 0x7a, 0x0e, 0x57, 0xe6, 0xe0, 0x83, 0x4e, 0xa6, 0x3a, + 0xb7, 0x27, 0x2b, 0x6a, 0xcf, 0xcb, 0xf5, 0xfd, 0x08, 0x9f, 0x46, 0x99, + 0xa5, 0x61, 0xe2, 0x0d, 0x2b, 0x48, 0xf1, 0x62, 0xbe, 0xad, 0x6a, 0x97, + 0xd6, 0xf1, 0x34, 0xee, 0xf0, 0x3c, 0xbe, 0x4b, 0xc8, 0x65, 0xdc, 0xb1, + 0x48, 0x92, 0x36, 0xcc, 0x84, 0x90, 0x86, 0x65, 0x24, 0x6f, 0x50, 0x46, + 0x57, 0x21, 0xab, 0xdb, 0x34, 0x1f, 0x86, 0xfe, 0x3e, 0xd5, 0xb4, 0xdf, + 0x14, 0x6b, 0xda, 0x0d, 0xee, 0x9d, 0xa7, 0xd8, 0x5a, 0x88, 0x24, 0xbc, + 0xb0, 0x9f, 0x51, 0xb7, 0xb7, 0x9e, 0x45, 0x93, 0x98, 0xa2, 0x8a, 0x19, + 0x9c, 0x4d, 0x37, 0x96, 0x32, 0x0e, 0xc0, 0x76, 0xe3, 0x2d, 0xc1, 0x35, + 0xf3, 0x26, 0xab, 0x1e, 0xab, 0x69, 0xab, 0xc7, 0x7d, 0x04, 0xb1, 0xc8, + 0x81, 0x14, 0xf9, 0x62, 0x45, 0x24, 0xbb, 0x7c, 0xed, 0xb1, 0x95, 0x38, + 0x3d, 0x36, 0x90, 0xa0, 0x13, 0xeb, 0xc1, 0x3d, 0x7d, 0x8f, 0x8c, 0x6d, + 0xf4, 0xdb, 0xcf, 0xb1, 0x5c, 0x44, 0xe0, 0x30, 0x23, 0xc8, 0x0b, 0xf3, + 0xe5, 0x97, 0x9c, 0x70, 0x14, 0x92, 0x41, 0xe0, 0x1e, 0xbf, 0x4a, 0xc1, + 0x55, 0x95, 0xac, 0x95, 0xff, 0x00, 0xaf, 0xeb, 0xfa, 0xd9, 0xd4, 0xa9, + 0x65, 0x74, 0x7e, 0xda, 0xfe, 0xc2, 0xbf, 0x08, 0x3e, 0x18, 0x78, 0x9b, + 0xe1, 0xc7, 0x88, 0x75, 0x8f, 0x1a, 0xe8, 0xfa, 0x76, 0xb7, 0xe2, 0x27, + 0xb1, 0x1a, 0x3e, 0x8d, 0x6f, 0x77, 0x24, 0xbf, 0x65, 0xb0, 0x92, 0x53, + 0x18, 0x6d, 0x46, 0x48, 0xa2, 0x92, 0xde, 0xed, 0x1a, 0x28, 0xe7, 0x46, + 0xb7, 0x71, 0x95, 0x79, 0x46, 0xdd, 0xa7, 0x70, 0x2b, 0xf9, 0x87, 0xac, + 0x5d, 0x59, 0x78, 0x6b, 0xc7, 0xd7, 0xd2, 0x49, 0x3c, 0x01, 0x23, 0xd4, + 0xae, 0x56, 0x3f, 0x28, 0x09, 0x55, 0xa3, 0x01, 0xb6, 0x12, 0xae, 0x4a, + 0xed, 0xe4, 0x6d, 0x24, 0x9c, 0x76, 0xcf, 0x5a, 0xd8, 0xf8, 0x73, 0xf1, + 0x5f, 0xc4, 0xbe, 0x18, 0xbd, 0x33, 0x69, 0x89, 0x6f, 0x75, 0x0b, 0xdb, + 0x86, 0x96, 0xde, 0xfc, 0xbb, 0xa9, 0x12, 0x6d, 0xcb, 0x34, 0x6a, 0xde, + 0x59, 0xe0, 0x29, 0x1b, 0xbb, 0xe3, 0x8e, 0x05, 0x78, 0xe7, 0xc5, 0x0d, + 0x76, 0xef, 0xc6, 0x9e, 0x2c, 0xbd, 0xd5, 0xb5, 0x15, 0x78, 0x25, 0xb9, + 0xd4, 0xa7, 0x9c, 0xa2, 0xb3, 0x71, 0x19, 0x50, 0x10, 0x1e, 0x7e, 0xe9, + 0xc0, 0xc6, 0x79, 0x2b, 0xf5, 0xcd, 0x72, 0x54, 0xc4, 0x73, 0xda, 0x0e, + 0x36, 0xb7, 0x5d, 0x2d, 0xfe, 0x66, 0xb4, 0xa4, 0xa4, 0xb7, 0xb1, 0xfa, + 0x07, 0xf0, 0xfb, 0xf6, 0x83, 0xf1, 0x36, 0x9d, 0xa0, 0x4d, 0xe1, 0xbb, + 0x3b, 0xbb, 0x49, 0xad, 0xb5, 0x89, 0x41, 0xb8, 0x97, 0x55, 0xb0, 0x8a, + 0xfc, 0xab, 0x02, 0x26, 0x76, 0x4b, 0x89, 0x22, 0x92, 0x54, 0xfb, 0xad, + 0xb4, 0x06, 0x20, 0xab, 0x48, 0x30, 0x4b, 0x31, 0xaf, 0xd1, 0xaf, 0x87, + 0xff, 0x00, 0x11, 0x6c, 0xbc, 0x73, 0xe1, 0xed, 0x33, 0xc4, 0x01, 0xf4, + 0x0f, 0x0b, 0x5d, 0x69, 0xdf, 0x68, 0xb0, 0x8e, 0xd3, 0xc2, 0x56, 0x33, + 0xa2, 0x4e, 0xb3, 0x13, 0x2b, 0xcb, 0x72, 0x97, 0x32, 0xaa, 0xc4, 0x59, + 0x48, 0x42, 0x13, 0xf7, 0x44, 0x82, 0xdb, 0x32, 0x58, 0xb7, 0xf3, 0xcb, + 0xa7, 0x78, 0xc6, 0x1f, 0x0f, 0x03, 0x67, 0x6d, 0x14, 0x26, 0x11, 0x10, + 0x79, 0xe2, 0x77, 0x39, 0x21, 0x31, 0xbd, 0xa1, 0x18, 0x39, 0x65, 0x19, + 0xc1, 0xfc, 0x7b, 0x57, 0xd9, 0x9f, 0x02, 0xbe, 0x29, 0xf8, 0x82, 0xeb, + 0x40, 0xd5, 0xed, 0xb4, 0x9d, 0x50, 0x47, 0x6a, 0xb6, 0x92, 0x43, 0x75, + 0x1a, 0x4b, 0x04, 0xb7, 0x17, 0x31, 0xcc, 0xc8, 0xd0, 0x28, 0xde, 0xcf, + 0x30, 0x31, 0xed, 0x0d, 0x29, 0x25, 0xc2, 0xa8, 0x5c, 0x05, 0x3c, 0x57, + 0x3c, 0xdd, 0x57, 0x16, 0x9c, 0xbd, 0xdf, 0x3d, 0x7e, 0xee, 0xc6, 0x53, + 0x8b, 0xb5, 0xde, 0xa7, 0xd5, 0x7f, 0xb4, 0x87, 0xc5, 0x5d, 0x02, 0x61, + 0xa9, 0x69, 0x9a, 0x76, 0xa7, 0xa9, 0xcb, 0x7d, 0x75, 0x70, 0xb2, 0xfd, + 0x96, 0xc2, 0xf5, 0x21, 0x58, 0x90, 0x37, 0xce, 0xbe, 0x62, 0x8d, 0xcf, + 0xd4, 0x93, 0x8f, 0x61, 0xc8, 0x3b, 0x8f, 0xc1, 0x5e, 0x25, 0xf8, 0xc3, + 0xe1, 0xfd, 0x32, 0x58, 0xb4, 0x1f, 0x0e, 0x43, 0x79, 0x6c, 0x21, 0x8d, + 0x8d, 0xec, 0xd6, 0x52, 0x93, 0x3c, 0xd2, 0xc8, 0x03, 0x4b, 0x70, 0xd3, + 0x5c, 0x96, 0x6d, 0xc1, 0xc7, 0xc8, 0xea, 0xa9, 0x8f, 0x98, 0xaf, 0x27, + 0x9f, 0x2f, 0xf8, 0xd7, 0xad, 0xf8, 0x97, 0x46, 0xb9, 0xb6, 0x8e, 0xfe, + 0xc7, 0x6c, 0xb2, 0x46, 0xb7, 0xd6, 0xd7, 0x22, 0x52, 0xe0, 0x06, 0x3f, + 0x24, 0xaa, 0x14, 0x83, 0x92, 0x33, 0x9d, 0xd9, 0x03, 0x90, 0x72, 0x40, + 0xaf, 0x9c, 0xf5, 0x3d, 0x7b, 0xc6, 0x57, 0x3a, 0x9c, 0xf7, 0x3a, 0x55, + 0xdd, 0xcc, 0x2f, 0x3a, 0x18, 0xa7, 0x68, 0xc9, 0xcb, 0x29, 0x23, 0x70, + 0x04, 0x72, 0x7b, 0x63, 0x1d, 0x0f, 0x4a, 0x8c, 0xa3, 0x24, 0x84, 0x57, + 0x3f, 0x35, 0xec, 0x55, 0x28, 0x36, 0xae, 0x7d, 0x8f, 0xac, 0x7c, 0x5c, + 0xd5, 0x3c, 0x23, 0x60, 0xd7, 0xba, 0x9c, 0xfa, 0x5e, 0xb7, 0x6a, 0x20, + 0x8d, 0x6c, 0x66, 0xdc, 0x4e, 0x55, 0x94, 0x00, 0x0d, 0xbc, 0x81, 0x19, + 0xe4, 0x52, 0xdf, 0x3c, 0xbf, 0x38, 0x2c, 0x4e, 0x1c, 0x70, 0x07, 0xc8, + 0x9e, 0x37, 0xf8, 0xc1, 0xab, 0x78, 0x87, 0x50, 0x9e, 0x79, 0xb7, 0x85, + 0x95, 0xcb, 0xc7, 0x12, 0x3f, 0xca, 0xa4, 0x02, 0xab, 0xf2, 0xaf, 0x0a, + 0x71, 0xe9, 0x8f, 0xc4, 0x56, 0x36, 0xbd, 0xa3, 0x5c, 0xc6, 0xb1, 0x59, + 0x49, 0x70, 0x64, 0x31, 0xc8, 0xd2, 0xbf, 0xda, 0xb7, 0xb9, 0x4c, 0xa8, + 0xf9, 0x94, 0xa6, 0x54, 0xf2, 0x41, 0x38, 0x24, 0x11, 0xea, 0x05, 0x78, + 0xe5, 0xd2, 0xbc, 0x17, 0x4e, 0xd2, 0xb7, 0xc8, 0xbf, 0x20, 0xf2, 0xce, + 0x43, 0x0e, 0x49, 0x20, 0xe7, 0x9e, 0x3d, 0x3b, 0x57, 0xbf, 0x80, 0xcb, + 0x28, 0xc5, 0xb9, 0xa5, 0xab, 0x3b, 0xe9, 0x53, 0xb6, 0xe7, 0x41, 0x27, + 0x89, 0xf5, 0x3f, 0xed, 0x90, 0xb7, 0x1e, 0x70, 0x98, 0xca, 0x41, 0x53, + 0x80, 0xc8, 0xd9, 0xc7, 0x00, 0x72, 0x0a, 0xe3, 0xa1, 0x1c, 0x0c, 0x0e, + 0xd5, 0xf4, 0xc6, 0x81, 0xf1, 0x33, 0xc3, 0x97, 0x10, 0x3d, 0x8d, 0xfe, + 0x16, 0x4b, 0x9b, 0x01, 0x6d, 0x77, 0x04, 0x4a, 0x36, 0x6f, 0x8d, 0x86, + 0xd1, 0xb4, 0xb0, 0x21, 0xb8, 0xc9, 0x23, 0x92, 0xc0, 0x1e, 0x71, 0x8a, + 0xf8, 0xd2, 0x4d, 0x52, 0xd9, 0xa6, 0x71, 0x08, 0x2b, 0xb8, 0xe4, 0x01, + 0xcf, 0xca, 0x41, 0xc0, 0x5c, 0xe4, 0x9f, 0xc4, 0xe7, 0x8e, 0xf5, 0x5e, + 0x2b, 0xa6, 0xb5, 0x9a, 0x49, 0xd6, 0x43, 0xbd, 0x97, 0x70, 0x20, 0x91, + 0x83, 0xcf, 0x43, 0x9e, 0x41, 0x38, 0xce, 0x6b, 0xbf, 0x13, 0x95, 0xc2, + 0x76, 0xb2, 0xb5, 0x8d, 0xdc, 0x7b, 0x1f, 0x42, 0xea, 0x7f, 0x13, 0xee, + 0x75, 0xa5, 0x2e, 0x8c, 0xbf, 0xba, 0x48, 0xe1, 0x6d, 0xca, 0x01, 0x69, + 0x21, 0xe3, 0x70, 0x3c, 0x9c, 0x36, 0x72, 0x71, 0xd8, 0x57, 0xa9, 0x78, + 0x1f, 0xe2, 0x9e, 0xa5, 0xa6, 0xda, 0xc7, 0x67, 0xa4, 0x43, 0x24, 0x3b, + 0x64, 0x49, 0x9e, 0x60, 0x5c, 0xee, 0x62, 0x39, 0x67, 0x05, 0xb6, 0x90, + 0xd8, 0xeb, 0x80, 0x48, 0x03, 0x92, 0x41, 0xaf, 0x8f, 0xb4, 0xe9, 0x64, + 0x85, 0xe4, 0xd8, 0xbf, 0x23, 0x66, 0x64, 0x91, 0x8f, 0x19, 0x27, 0x3b, + 0x8e, 0x72, 0x08, 0x2b, 0x9e, 0x38, 0xe7, 0xf2, 0x3d, 0xbe, 0x97, 0xae, + 0xc9, 0x67, 0xa8, 0xaa, 0xc4, 0xc5, 0xa1, 0x29, 0xd4, 0x00, 0xc7, 0x95, + 0xf9, 0x87, 0x7e, 0x9f, 0x5f, 0xc2, 0xb8, 0xf1, 0x99, 0x35, 0x27, 0x17, + 0x05, 0x10, 0x70, 0x4e, 0x3b, 0x1f, 0xa1, 0xb3, 0x7e, 0xd1, 0xbe, 0x2d, + 0xb6, 0xf0, 0xba, 0xe8, 0x97, 0x92, 0xc9, 0xf6, 0x69, 0xe4, 0xcc, 0xa5, + 0x25, 0x3b, 0xdc, 0x81, 0xd1, 0x1b, 0x39, 0x04, 0xe4, 0x83, 0xec, 0x78, + 0xe0, 0x9c, 0xfc, 0xcf, 0x7d, 0xe2, 0x6f, 0x10, 0xf8, 0xd3, 0x58, 0xb6, + 0xd1, 0x8d, 0xfb, 0x38, 0x12, 0x79, 0x56, 0xf1, 0x5d, 0x5c, 0x14, 0x83, + 0x63, 0xb1, 0x20, 0x10, 0xe4, 0xa2, 0x2f, 0x2b, 0xba, 0x4e, 0x3e, 0x6f, + 0x9b, 0x20, 0x1d, 0xd5, 0xe3, 0x7a, 0xd7, 0x8a, 0x2e, 0x27, 0xb5, 0x36, + 0xf2, 0xf9, 0x8a, 0xdb, 0x4a, 0xc6, 0xb1, 0x6d, 0x65, 0x8f, 0x91, 0xfc, + 0x19, 0x23, 0xee, 0xe4, 0x1c, 0x10, 0x71, 0xd2, 0xae, 0xc7, 0x76, 0x74, + 0x8b, 0x28, 0x2f, 0xa1, 0x7b, 0x67, 0xba, 0x56, 0x25, 0x31, 0x97, 0x25, + 0x31, 0xd4, 0x03, 0xf2, 0x9c, 0x63, 0x90, 0x47, 0x3c, 0x67, 0xa8, 0x15, + 0xe6, 0xd1, 0xc8, 0xa9, 0x50, 0x4e, 0x74, 0xe2, 0x93, 0x7f, 0xd5, 0xff, + 0x00, 0xcc, 0xc6, 0x54, 0xdd, 0x8f, 0x7f, 0xf0, 0x85, 0xb4, 0x1e, 0x0a, + 0xbb, 0x92, 0xee, 0xfe, 0xe4, 0xc7, 0x7b, 0x79, 0x3c, 0x8c, 0x24, 0x49, + 0x7c, 0xb8, 0xe6, 0x50, 0x4b, 0x31, 0xdc, 0xa5, 0xd5, 0x90, 0xb0, 0x04, + 0x02, 0x76, 0x9f, 0xef, 0x73, 0x8a, 0xfe, 0x87, 0xbf, 0xe0, 0x9c, 0x1a, + 0xde, 0x91, 0xf1, 0xc3, 0xc6, 0x10, 0xe9, 0xda, 0xbc, 0x97, 0xe7, 0xc6, + 0x16, 0x29, 0x1d, 0x96, 0x9d, 0x35, 0x9c, 0xde, 0x5d, 0xfb, 0x5a, 0xc7, + 0x11, 0xb7, 0xd9, 0xa6, 0x8b, 0x47, 0xb3, 0xf3, 0x5a, 0x23, 0x2c, 0x4f, + 0x1c, 0x62, 0x51, 0xbb, 0x69, 0x24, 0x9c, 0x2a, 0xa7, 0xf2, 0xe1, 0xa1, + 0x78, 0x96, 0xf6, 0xff, 0x00, 0x54, 0xb7, 0xd2, 0xef, 0x27, 0x13, 0xc7, + 0x71, 0x74, 0x17, 0xcc, 0xb8, 0x52, 0x63, 0x8d, 0x9b, 0x38, 0x70, 0x01, + 0x24, 0x0e, 0x73, 0x9e, 0xfe, 0x87, 0xa5, 0x7e, 0xb1, 0xfe, 0xcb, 0x5f, + 0x12, 0xfc, 0x6b, 0xf0, 0x6f, 0xc6, 0x3a, 0x77, 0x89, 0xbc, 0x22, 0xd7, + 0x65, 0xb4, 0xd9, 0xcc, 0x96, 0xda, 0x8a, 0x83, 0xe7, 0x16, 0x2b, 0xb5, + 0xd1, 0x76, 0x6f, 0x2a, 0xc4, 0x1f, 0x97, 0xe6, 0xef, 0xce, 0x4e, 0x48, + 0xf9, 0xfe, 0x23, 0xc4, 0x4f, 0x0d, 0xc9, 0x52, 0x4e, 0xed, 0x34, 0xf4, + 0xed, 0xf3, 0xfc, 0xbf, 0x13, 0x8a, 0x74, 0xfd, 0xed, 0x4f, 0xea, 0x1b, + 0xf6, 0xd2, 0xf8, 0x49, 0xa7, 0x78, 0x03, 0x56, 0xd5, 0x75, 0xdd, 0x3e, + 0xea, 0x5b, 0x4b, 0x7d, 0x35, 0x20, 0x4b, 0x7d, 0x46, 0x50, 0x41, 0xbe, + 0xd6, 0xe4, 0xb7, 0xdd, 0x2c, 0x11, 0x02, 0xcf, 0x24, 0x71, 0xa9, 0xc1, + 0x1f, 0xbf, 0x94, 0x0d, 0xc5, 0x8c, 0x84, 0xe3, 0x77, 0xe7, 0x7f, 0xc2, + 0x7d, 0x7f, 0xc5, 0x3e, 0x11, 0xd2, 0x2f, 0xbc, 0x45, 0xe2, 0x73, 0x0a, + 0x5f, 0xfd, 0xac, 0x6d, 0x11, 0x5d, 0xa5, 0xd4, 0xb2, 0x46, 0xee, 0xcd, + 0x96, 0x48, 0xd8, 0xb2, 0xa6, 0x71, 0xb5, 0x8b, 0x8c, 0x90, 0x46, 0x39, + 0x38, 0xe2, 0x7c, 0x55, 0xfb, 0x67, 0x6b, 0xbf, 0x10, 0xf5, 0x0b, 0x2f, + 0x0f, 0xfc, 0x50, 0xbb, 0x7d, 0x56, 0xd0, 0x5e, 0xa3, 0xac, 0x36, 0xc8, + 0x63, 0x48, 0xac, 0x60, 0x88, 0x08, 0x91, 0xe2, 0x8d, 0x52, 0x1f, 0x32, + 0x30, 0xac, 0xa5, 0xcf, 0xdf, 0x07, 0x1c, 0x71, 0xb7, 0xe4, 0x6f, 0x1e, + 0xfc, 0x3b, 0xf8, 0xc7, 0xe1, 0xff, 0x00, 0x18, 0x2e, 0xb9, 0xf0, 0xd9, + 0x75, 0x0b, 0xcd, 0x1f, 0x5b, 0x7c, 0x43, 0x6d, 0x63, 0x1b, 0xce, 0x96, + 0xf9, 0x3c, 0xac, 0xcc, 0x81, 0x15, 0x43, 0x6d, 0x52, 0xae, 0xd9, 0x4d, + 0xc0, 0xe4, 0x8c, 0x64, 0xf3, 0xae, 0x25, 0xc2, 0x57, 0xa8, 0xa1, 0x46, + 0x2e, 0x09, 0xa6, 0xd5, 0xfa, 0xf5, 0xd3, 0xb7, 0xfc, 0x07, 0xab, 0x7a, + 0xb9, 0xa9, 0x51, 0xa7, 0x78, 0xa3, 0xf5, 0xeb, 0x49, 0xf8, 0xc7, 0xa1, + 0xf8, 0xaa, 0xfe, 0x1b, 0x6b, 0xcb, 0xc9, 0xe2, 0xf3, 0xca, 0x99, 0xae, + 0xe3, 0x7c, 0x48, 0x97, 0x4c, 0xbe, 0x58, 0x66, 0xe5, 0xbf, 0x8b, 0x04, + 0x0f, 0x97, 0x77, 0x18, 0x35, 0xd5, 0x7c, 0x25, 0xf1, 0xc7, 0xc5, 0x99, + 0x7c, 0x73, 0x75, 0x63, 0xa1, 0x97, 0x3f, 0x64, 0x89, 0xae, 0x75, 0x5b, + 0x8f, 0x32, 0xde, 0xda, 0x61, 0xe5, 0x65, 0xe3, 0x99, 0x63, 0x93, 0xf7, + 0x6d, 0x04, 0x85, 0x0e, 0x64, 0x73, 0xb4, 0xf9, 0x6c, 0xcd, 0x81, 0xc8, + 0xfc, 0x68, 0xf0, 0xfd, 0xaf, 0xc4, 0x5f, 0x0e, 0xbf, 0xfc, 0x24, 0xba, + 0xf4, 0x71, 0xc9, 0x63, 0x13, 0x46, 0xaf, 0x0c, 0x5b, 0xbc, 0xf8, 0x51, + 0x82, 0xf9, 0x8b, 0x24, 0x7c, 0x1d, 0xc1, 0xc1, 0x5d, 0x8b, 0xc7, 0x04, + 0x92, 0x14, 0x1a, 0xea, 0x3c, 0x79, 0xfb, 0x42, 0x37, 0x87, 0xbc, 0x43, + 0x67, 0xe2, 0x2b, 0x3b, 0xf6, 0xb2, 0x4b, 0xbd, 0x26, 0x58, 0x6e, 0x26, + 0x96, 0x62, 0x2d, 0x6e, 0x02, 0xab, 0x66, 0x29, 0x82, 0x9e, 0x92, 0x01, + 0x94, 0xc2, 0x96, 0x0c, 0xc3, 0xe4, 0xe3, 0x23, 0xd5, 0xca, 0xea, 0x46, + 0x75, 0x79, 0x7e, 0x24, 0xfb, 0x3b, 0x3b, 0xfa, 0xf4, 0xf3, 0x09, 0x62, + 0x2e, 0xed, 0xd4, 0xff, 0xd3, 0xf2, 0x0f, 0x1a, 0xfc, 0x1b, 0xf0, 0x9f, + 0x82, 0xad, 0x6e, 0x64, 0xf0, 0xa8, 0xf2, 0xa3, 0x1b, 0x0c, 0x76, 0x96, + 0xaa, 0x0c, 0x71, 0x2c, 0x20, 0x85, 0x11, 0xc4, 0xa0, 0x02, 0xd8, 0xe0, + 0x33, 0x64, 0xf6, 0xf6, 0x3f, 0x93, 0x3f, 0x16, 0x34, 0x19, 0x3c, 0x45, + 0x3d, 0xc4, 0x5a, 0x34, 0x6f, 0xa7, 0x11, 0x72, 0xea, 0xef, 0x2f, 0x92, + 0x93, 0xcd, 0xb5, 0x49, 0xc7, 0x90, 0xe3, 0x95, 0x3c, 0x0f, 0xbb, 0x9e, + 0x79, 0xce, 0x73, 0x5f, 0xa9, 0x1e, 0x32, 0xf1, 0xa7, 0x9b, 0x1c, 0x91, + 0x4a, 0x49, 0x59, 0x01, 0x46, 0xed, 0xc1, 0x04, 0x1c, 0x8c, 0xfb, 0xd7, + 0xc2, 0xdf, 0x10, 0xb4, 0x58, 0xe3, 0x95, 0xaf, 0x34, 0x5b, 0x74, 0x2d, + 0x1c, 0xbe, 0x72, 0xc5, 0x14, 0x51, 0x8f, 0x9d, 0x72, 0xe1, 0xd9, 0x82, + 0x93, 0xd7, 0xa9, 0x00, 0xb1, 0xcf, 0x00, 0xf2, 0x2b, 0xe2, 0xf8, 0x8b, + 0x86, 0xbd, 0x85, 0x67, 0x8a, 0xa5, 0xb3, 0xe9, 0xd9, 0xf9, 0x79, 0x7e, + 0x47, 0x8a, 0xb0, 0x4a, 0x4f, 0x9a, 0x9a, 0xd7, 0xb1, 0xf0, 0x17, 0x88, + 0xfc, 0x05, 0xa7, 0x68, 0xe2, 0x48, 0x35, 0x6b, 0xc7, 0x94, 0xc2, 0xcd, + 0x27, 0xd9, 0xd5, 0x87, 0xee, 0x4b, 0xf0, 0x57, 0x70, 0x0a, 0x07, 0x3d, + 0x00, 0x23, 0x8e, 0x9d, 0x06, 0x7e, 0x7b, 0xd6, 0xa0, 0x16, 0xf7, 0x37, + 0x16, 0xb0, 0x08, 0xbc, 0x98, 0x8a, 0xaa, 0x34, 0x6c, 0x4a, 0xbb, 0x13, + 0xbb, 0x76, 0x3a, 0xe4, 0x71, 0x9c, 0x9e, 0x7a, 0x57, 0xd4, 0x3e, 0x3f, + 0xf0, 0x0f, 0x8c, 0x3c, 0x4b, 0x39, 0x96, 0xea, 0xfa, 0xd9, 0x03, 0x49, + 0x23, 0xc1, 0x63, 0x6e, 0xaa, 0x03, 0x0d, 0xb8, 0x73, 0xf3, 0x92, 0xf2, + 0x3e, 0x08, 0xf9, 0x88, 0xe0, 0xe7, 0x85, 0x18, 0x07, 0x91, 0xd2, 0x3e, + 0x0b, 0xdf, 0x5a, 0x99, 0x6c, 0x64, 0x68, 0xa4, 0x79, 0xe3, 0x8f, 0x33, + 0xca, 0x59, 0x92, 0x21, 0x95, 0x00, 0x95, 0x8c, 0x92, 0xd8, 0xdc, 0x7b, + 0x70, 0x06, 0x47, 0x3c, 0xd7, 0x15, 0x2c, 0x4a, 0x8a, 0xf7, 0x99, 0xbe, + 0x1e, 0x8d, 0x4d, 0x5e, 0xe7, 0xcd, 0x3a, 0x8e, 0x92, 0xb0, 0x5c, 0x45, + 0x7d, 0x13, 0x0c, 0x41, 0x93, 0x12, 0x44, 0x01, 0x38, 0x3d, 0x4b, 0x9e, + 0xb9, 0x23, 0x9f, 0xff, 0x00, 0x58, 0xad, 0xa8, 0xf4, 0x09, 0xb5, 0xcb, + 0x96, 0xba, 0x6f, 0x92, 0x29, 0x02, 0xfd, 0xec, 0xe4, 0xf1, 0x8c, 0x60, + 0x9e, 0xd8, 0x24, 0x9e, 0xdf, 0x95, 0x7b, 0xf5, 0x8f, 0xc3, 0x2d, 0x52, + 0xee, 0xe6, 0x68, 0x6e, 0x7c, 0xa6, 0x26, 0x76, 0xb7, 0x9a, 0xe0, 0xb7, + 0x97, 0x0e, 0x20, 0x3b, 0x98, 0x04, 0x73, 0xbd, 0x8e, 0x3d, 0x38, 0x03, + 0x3c, 0x71, 0x5b, 0x36, 0x7e, 0x17, 0x8e, 0x29, 0xe0, 0xb2, 0x9e, 0x19, + 0x55, 0x65, 0x97, 0xf7, 0x51, 0x60, 0x85, 0xe1, 0xb3, 0xc9, 0x23, 0x81, + 0x81, 0xd0, 0x0e, 0xa3, 0x8e, 0x49, 0xad, 0x7f, 0xb4, 0x63, 0x14, 0xd2, + 0x77, 0x38, 0x2a, 0x56, 0xe8, 0x8f, 0x06, 0x8b, 0xc1, 0xb1, 0xdb, 0x49, + 0xb5, 0xb0, 0xc4, 0x0c, 0x81, 0xd3, 0x38, 0xeb, 0x80, 0x3e, 0xbc, 0x7f, + 0xfa, 0xab, 0x4e, 0xca, 0xd2, 0xe2, 0xce, 0x5f, 0x21, 0x61, 0x66, 0x54, + 0x89, 0xbc, 0xc2, 0x13, 0x24, 0x03, 0x91, 0x8e, 0x3a, 0x03, 0xdf, 0x23, + 0x19, 0xfc, 0xab, 0xd8, 0x2e, 0xb4, 0x68, 0xf4, 0xfd, 0x52, 0x3b, 0x3e, + 0x48, 0x79, 0x7c, 0xc0, 0x19, 0xbe, 0x50, 0xb9, 0x24, 0x29, 0x62, 0x14, + 0xf0, 0xbc, 0x0e, 0x87, 0xf3, 0xae, 0x17, 0x56, 0xbd, 0xd5, 0xec, 0x56, + 0x70, 0xac, 0x6e, 0xe5, 0x07, 0xfd, 0x54, 0x28, 0xf2, 0x28, 0xc8, 0x3c, + 0x92, 0x19, 0x70, 0x3a, 0x8f, 0x62, 0x47, 0x4c, 0xe6, 0xa1, 0xe2, 0x1c, + 0xd5, 0xbb, 0x9c, 0x9e, 0xd6, 0x4f, 0x43, 0x02, 0x5d, 0x2b, 0x4a, 0x96, + 0x5c, 0x6a, 0xa2, 0x43, 0x37, 0x94, 0xc0, 0x60, 0x8d, 0xb1, 0x83, 0xf3, + 0x7c, 0xd9, 0xc0, 0xc8, 0xcf, 0x60, 0x38, 0xef, 0x93, 0x57, 0xcc, 0x7e, + 0x25, 0xb8, 0x94, 0x69, 0x1e, 0x1e, 0x68, 0x92, 0x28, 0x60, 0x2f, 0xe6, + 0x65, 0xd9, 0x63, 0x52, 0x46, 0x59, 0xd8, 0x21, 0xe4, 0x91, 0x90, 0xb9, + 0xe7, 0xd7, 0xd6, 0x85, 0xde, 0x8b, 0x79, 0xad, 0xe9, 0x76, 0x8f, 0x71, + 0x2b, 0xd9, 0xbd, 0xc4, 0xcb, 0x14, 0x91, 0xd8, 0xc4, 0xde, 0x60, 0xf3, + 0x1b, 0x6a, 0x79, 0xa0, 0xb6, 0x01, 0x1b, 0x83, 0x10, 0x32, 0x46, 0x48, + 0xe8, 0x01, 0xae, 0xae, 0xc7, 0xc0, 0x1a, 0xa6, 0x9d, 0x12, 0xcb, 0x6b, + 0x34, 0x52, 0x79, 0x2c, 0x61, 0x92, 0x78, 0x51, 0xa6, 0x9d, 0x64, 0x87, + 0x1f, 0x39, 0x42, 0x40, 0xda, 0x70, 0x70, 0x36, 0x13, 0xcf, 0x71, 0xcd, + 0x73, 0xd7, 0x8d, 0x92, 0x77, 0xb8, 0x9d, 0xd5, 0x93, 0x67, 0x25, 0x7f, + 0xa8, 0xc1, 0xa3, 0x3d, 0xc6, 0x91, 0xac, 0xad, 0xa4, 0x8c, 0x56, 0x38, + 0xad, 0xae, 0x4b, 0xee, 0x09, 0xb7, 0x86, 0x0c, 0x04, 0x9b, 0xa3, 0x2c, + 0xd9, 0xe9, 0xf3, 0xe0, 0x82, 0x70, 0x39, 0xad, 0x8d, 0x1f, 0xfb, 0x1a, + 0xea, 0xd6, 0x2b, 0xcd, 0x31, 0x61, 0xb6, 0x64, 0x9f, 0x63, 0xc3, 0x29, + 0x48, 0x46, 0x57, 0x3b, 0xd4, 0x90, 0xb2, 0xbb, 0xee, 0x07, 0x83, 0x8e, + 0x9d, 0xb8, 0x02, 0xb4, 0x13, 0xc1, 0xf7, 0x9a, 0xc4, 0xf1, 0x47, 0x73, + 0xa6, 0x47, 0x72, 0x0c, 0x53, 0x4b, 0x14, 0x7a, 0x91, 0x82, 0xde, 0xe1, + 0xa3, 0x50, 0x73, 0xb1, 0x58, 0x33, 0x13, 0xd0, 0x0d, 0xcb, 0x9f, 0x42, + 0x0e, 0x6b, 0x67, 0x49, 0xd1, 0x7c, 0xef, 0x3e, 0xd9, 0xa0, 0x99, 0x2d, + 0x9c, 0x29, 0x16, 0x77, 0x16, 0xa1, 0xd0, 0x6e, 0xdb, 0x82, 0xdb, 0x1b, + 0xef, 0x12, 0xa4, 0xe3, 0x6a, 0xf3, 0xc8, 0x38, 0x04, 0x1c, 0x9a, 0x49, + 0x22, 0xdc, 0x74, 0xb9, 0x9f, 0x6e, 0x9a, 0xb4, 0x51, 0x9b, 0x88, 0x9a, + 0xd9, 0x65, 0x8f, 0x6e, 0xc8, 0x4b, 0xbe, 0x14, 0x64, 0x9c, 0x85, 0xf2, + 0xc6, 0xec, 0x21, 0x23, 0x19, 0xce, 0xee, 0x0e, 0x0e, 0x45, 0x61, 0xe9, + 0x3a, 0x4e, 0xb3, 0x78, 0x5c, 0xea, 0x49, 0x20, 0x99, 0xce, 0xe9, 0x0c, + 0xbb, 0x94, 0x29, 0x72, 0xb8, 0xce, 0x40, 0xee, 0xc3, 0x8c, 0xe4, 0x77, + 0x07, 0xbf, 0xbe, 0xf8, 0x5f, 0xe1, 0x66, 0xa7, 0xa9, 0xf3, 0x6d, 0x6f, + 0x1c, 0x43, 0xcc, 0x1b, 0xa7, 0x58, 0x8a, 0x97, 0xda, 0x4e, 0x77, 0xe4, + 0x01, 0xdb, 0x9c, 0x1c, 0x8c, 0x74, 0xec, 0x7e, 0x8e, 0xd0, 0xbe, 0x18, + 0xe8, 0x96, 0x09, 0x9d, 0x79, 0xd2, 0x47, 0x04, 0x33, 0x46, 0xec, 0x5d, + 0x63, 0x90, 0x2e, 0x0a, 0x8c, 0xe1, 0xb6, 0x9c, 0xf2, 0xa4, 0xe0, 0x0e, + 0xc0, 0x1a, 0xda, 0x86, 0x16, 0x73, 0xf8, 0x63, 0xa7, 0x73, 0xb3, 0x0d, + 0x97, 0xd5, 0xa9, 0xf0, 0xab, 0x1f, 0x33, 0xf8, 0x4b, 0xe1, 0x1d, 0xef, + 0x8a, 0x9c, 0x4e, 0x91, 0x5b, 0xdb, 0xa0, 0xfd, 0xe4, 0xb7, 0x72, 0x28, + 0x61, 0xe5, 0x95, 0xf9, 0xc0, 0xc2, 0xf7, 0x19, 0xe0, 0x30, 0xfa, 0x7a, + 0xfd, 0x71, 0xfb, 0x25, 0xe8, 0x7f, 0x0f, 0x3e, 0x16, 0x6a, 0x1a, 0xbd, + 0x87, 0x89, 0xfc, 0x2f, 0x2f, 0x88, 0xb4, 0x2b, 0x90, 0x9e, 0x4a, 0xce, + 0xcb, 0x13, 0x49, 0x2a, 0x79, 0x7b, 0x18, 0x36, 0x32, 0xa8, 0xa1, 0x08, + 0x21, 0x79, 0x6c, 0xf2, 0x48, 0xc8, 0x39, 0xdf, 0xd9, 0xf7, 0x9a, 0x8d, + 0xef, 0xf6, 0x76, 0x83, 0x17, 0x93, 0x63, 0xc4, 0x4e, 0x07, 0xca, 0xac, + 0x83, 0x19, 0x50, 0x07, 0x18, 0x24, 0x72, 0x3b, 0xd7, 0xbf, 0x78, 0x47, + 0x47, 0xba, 0xb7, 0x85, 0x60, 0x65, 0x55, 0x03, 0x00, 0x2e, 0x2b, 0xee, + 0x72, 0x6c, 0xb1, 0x42, 0x3c, 0xd2, 0xd7, 0xfa, 0xec, 0x7a, 0x15, 0x30, + 0x91, 0xa2, 0xb9, 0x6f, 0x77, 0xd4, 0xf0, 0xaf, 0xda, 0x57, 0x43, 0xd1, + 0x3e, 0x2a, 0x78, 0x9e, 0xe7, 0x50, 0xd2, 0x34, 0xd1, 0xe1, 0xdb, 0x0f, + 0xb1, 0x0b, 0x4b, 0x3b, 0x68, 0xc6, 0xf8, 0x2d, 0xe3, 0x43, 0xb8, 0xa9, + 0x0a, 0xab, 0x92, 0x5c, 0xb3, 0x64, 0x11, 0xd4, 0xf0, 0x73, 0x5f, 0x1e, + 0x6a, 0xdf, 0x08, 0xfc, 0x75, 0xe1, 0x9b, 0x86, 0xd4, 0x6c, 0xad, 0xcd, + 0xd5, 0x9e, 0xed, 0xc9, 0x79, 0xa7, 0x6d, 0x9c, 0x15, 0xf5, 0x28, 0x14, + 0x32, 0x9f, 0xe1, 0xc1, 0xed, 0xd6, 0xbf, 0x5f, 0x2e, 0xb4, 0x1b, 0x59, + 0x20, 0xff, 0x00, 0x49, 0x8e, 0x36, 0x53, 0xc3, 0x02, 0xb9, 0xfa, 0xd7, + 0x99, 0x6a, 0x9e, 0x0b, 0xb5, 0xd3, 0xa5, 0x6d, 0x43, 0xc3, 0xbf, 0xba, + 0x75, 0x53, 0xfe, 0x8f, 0x92, 0x22, 0x6e, 0x0f, 0x61, 0xd3, 0xaf, 0x51, + 0x9f, 0xa1, 0xac, 0xb1, 0xd9, 0x54, 0x3d, 0xe9, 0x45, 0x5a, 0xfd, 0xbb, + 0xfa, 0x1a, 0x53, 0xc3, 0xc2, 0x7a, 0x3d, 0x0f, 0xc6, 0x1b, 0xeb, 0xa6, + 0x9a, 0xe6, 0x6b, 0x29, 0xd4, 0x89, 0xae, 0x5d, 0xc4, 0x8c, 0x4e, 0xd6, + 0x8d, 0x14, 0x91, 0x86, 0xe3, 0x71, 0x2b, 0x8c, 0x16, 0x00, 0xe0, 0xe4, + 0x06, 0xc7, 0x15, 0xf3, 0xc6, 0xb9, 0x35, 0x8c, 0x37, 0x37, 0x16, 0x79, + 0x96, 0x19, 0x15, 0xb6, 0x18, 0x18, 0xfd, 0x0f, 0x27, 0xaa, 0x93, 0xd8, + 0x73, 0xe9, 0x5f, 0xaf, 0xbf, 0x15, 0x34, 0x8f, 0x08, 0xea, 0x2f, 0x22, + 0x78, 0xab, 0x47, 0xf2, 0x59, 0xed, 0xc2, 0x9b, 0xc5, 0x86, 0x3f, 0x3d, + 0x9d, 0x37, 0x31, 0x55, 0x93, 0x69, 0x47, 0x05, 0x86, 0xe0, 0x0e, 0x18, + 0x67, 0x27, 0x04, 0x1a, 0xf8, 0xef, 0xc6, 0x5f, 0xb3, 0xdd, 0x85, 0xcc, + 0x92, 0x4d, 0xe1, 0x7b, 0xfd, 0xc6, 0x44, 0x32, 0x3f, 0x9a, 0x42, 0x3b, + 0x21, 0x3c, 0x06, 0x60, 0x06, 0x49, 0x27, 0x9e, 0xa4, 0x67, 0x8c, 0x57, + 0x91, 0x43, 0x0f, 0x28, 0xb7, 0x73, 0x5a, 0xb4, 0x1c, 0x1d, 0xb7, 0xf4, + 0x3e, 0x2a, 0xb0, 0xd4, 0xad, 0x64, 0xbe, 0xb6, 0x26, 0x37, 0x91, 0xfc, + 0xc2, 0x24, 0x88, 0x44, 0x1f, 0xe4, 0xc6, 0x03, 0x01, 0xcf, 0xd0, 0xfd, + 0x72, 0x31, 0xd6, 0xb5, 0x24, 0x16, 0x6d, 0x71, 0x15, 0xd4, 0x1f, 0xea, + 0xf8, 0x0d, 0xb4, 0x29, 0xc9, 0x66, 0xe5, 0x7b, 0xf7, 0x18, 0xe3, 0x23, + 0x9a, 0xee, 0xb5, 0xff, 0x00, 0x85, 0x3e, 0x2a, 0xf0, 0xf2, 0x07, 0xfe, + 0xcf, 0xb8, 0x96, 0x4d, 0x9e, 0x4b, 0xc9, 0x19, 0x67, 0x0c, 0xa5, 0x89, + 0xdd, 0xc9, 0x5e, 0x7b, 0x92, 0x7d, 0x7a, 0x1c, 0x57, 0x0f, 0x07, 0x87, + 0xb5, 0x48, 0xa6, 0x68, 0x75, 0x1b, 0x39, 0x20, 0x64, 0x5d, 0xf1, 0x32, + 0x2e, 0xcc, 0x95, 0xe7, 0x18, 0xc1, 0xc9, 0xcf, 0x1c, 0x7f, 0x8d, 0x74, + 0x73, 0x2e, 0xe6, 0x0e, 0x5e, 0x56, 0x1d, 0x7d, 0x7a, 0xd0, 0x13, 0x15, + 0xa2, 0xb0, 0x06, 0x4f, 0xde, 0x09, 0x0f, 0x4e, 0x70, 0x38, 0x07, 0x18, + 0xc0, 0xee, 0x3b, 0xfb, 0xd4, 0x77, 0xfa, 0xc5, 0x9c, 0x60, 0x4e, 0x65, + 0x7c, 0x7c, 0xa8, 0x91, 0x82, 0xca, 0xa0, 0x05, 0x00, 0x9f, 0x9b, 0x27, + 0x38, 0x1e, 0xa4, 0x56, 0x6d, 0xc4, 0x17, 0xb7, 0xf7, 0x96, 0xf1, 0x3c, + 0x7e, 0x53, 0x4a, 0x86, 0x10, 0xf2, 0xa8, 0x0c, 0x0a, 0x64, 0xfc, 0xdc, + 0xe4, 0x0c, 0xf4, 0xef, 0xf5, 0xad, 0x23, 0xa1, 0xcb, 0x7b, 0x32, 0x3d, + 0xa4, 0x0f, 0xe5, 0x8f, 0x97, 0x6c, 0x03, 0xcc, 0x05, 0xcf, 0x38, 0x1c, + 0x6e, 0xf5, 0x1d, 0x3b, 0x13, 0xcf, 0x35, 0x1a, 0x2b, 0x5c, 0x9f, 0x6a, + 0x96, 0xe6, 0xbd, 0xa6, 0xbf, 0xa7, 0xa5, 0xc2, 0xc9, 0x76, 0x44, 0x8a, + 0x8a, 0x4c, 0x6a, 0x41, 0x07, 0x9f, 0xef, 0x05, 0x6e, 0x3e, 0xa0, 0xe7, + 0xb7, 0xbd, 0x6e, 0x4f, 0xa9, 0xd9, 0xcf, 0x0f, 0x51, 0x18, 0xc9, 0xf9, + 0x09, 0xe4, 0x03, 0xf3, 0x75, 0xec, 0x49, 0x03, 0x27, 0xd3, 0x8c, 0xfa, + 0x79, 0xdd, 0x8d, 0x8f, 0xcf, 0xf6, 0x84, 0x57, 0x50, 0x66, 0xf2, 0x55, + 0x98, 0xe5, 0x77, 0xe0, 0xed, 0x03, 0x04, 0x10, 0xcc, 0x01, 0xc0, 0x00, + 0xd6, 0x9d, 0x96, 0x93, 0xad, 0x2e, 0xa4, 0xd2, 0xc3, 0x69, 0x36, 0x4c, + 0x82, 0x39, 0x91, 0x9d, 0x4e, 0x32, 0x33, 0x85, 0x5e, 0x30, 0x57, 0xa8, + 0xef, 0xb7, 0x3e, 0xf5, 0x9c, 0xe1, 0xd7, 0x98, 0x4e, 0x6a, 0xfd, 0x8f, + 0x5a, 0xf0, 0xe6, 0xb1, 0x6d, 0x69, 0x72, 0x93, 0x5c, 0x22, 0xef, 0xc8, + 0x70, 0x24, 0x01, 0x80, 0x3c, 0x6d, 0xda, 0x7d, 0xbf, 0x9f, 0xd6, 0xbe, + 0xe2, 0xf8, 0x57, 0xe3, 0xad, 0x32, 0x3b, 0x28, 0x8c, 0x8b, 0x24, 0x32, + 0xc5, 0x3a, 0xc8, 0xb1, 0x33, 0xb6, 0x33, 0x91, 0xb9, 0x98, 0x82, 0x70, + 0xbc, 0x06, 0x2c, 0x3f, 0x0e, 0x79, 0xaf, 0x82, 0x2d, 0x3c, 0x0f, 0xe3, + 0x0b, 0xd9, 0x73, 0x6b, 0x6d, 0x73, 0xe4, 0x49, 0x1f, 0x9d, 0x0d, 0xd1, + 0x86, 0x53, 0x13, 0xb8, 0xcf, 0xee, 0xd6, 0x50, 0x98, 0xdf, 0x91, 0x80, + 0xa0, 0x1e, 0x7f, 0x0a, 0xe8, 0x74, 0xeb, 0x3f, 0x88, 0xba, 0x86, 0x97, + 0x1b, 0x69, 0x7a, 0x76, 0xa2, 0x2e, 0x16, 0x7f, 0x24, 0xce, 0xdb, 0xed, + 0x8c, 0x6a, 0x71, 0x90, 0xde, 0x62, 0x80, 0x72, 0x0f, 0x1e, 0x9f, 0x4e, + 0x2b, 0xe6, 0x33, 0x6c, 0x99, 0x62, 0x55, 0x9b, 0x30, 0x71, 0xe6, 0x7e, + 0xe9, 0xf7, 0xb2, 0xfc, 0x5b, 0xd6, 0x62, 0xf1, 0x1a, 0x6a, 0x67, 0x51, + 0x8a, 0x38, 0x22, 0xd4, 0x96, 0x27, 0xb6, 0x8a, 0x55, 0xc8, 0xb6, 0xdb, + 0x86, 0xda, 0xb2, 0x3a, 0x17, 0x0c, 0x31, 0x8f, 0xbc, 0x31, 0x92, 0x00, + 0xcd, 0x7e, 0xa6, 0x78, 0x7f, 0xe3, 0x65, 0xce, 0xab, 0x63, 0xa7, 0x5b, + 0x78, 0x46, 0x59, 0x6f, 0x4d, 0xc1, 0x5b, 0x79, 0x5a, 0xd9, 0x15, 0x59, + 0x23, 0x45, 0x6c, 0xef, 0xda, 0xc0, 0x05, 0x04, 0x0e, 0xa4, 0x0e, 0xc7, + 0x23, 0x15, 0xf8, 0xdd, 0xe0, 0x9f, 0x80, 0x7e, 0x35, 0xf1, 0x1b, 0x5b, + 0x6a, 0x1a, 0xad, 0xff, 0x00, 0x9a, 0xb0, 0xa8, 0x13, 0xda, 0x5b, 0xe9, + 0xe9, 0x72, 0xf2, 0x30, 0x65, 0x2c, 0x10, 0xac, 0x6a, 0xbf, 0x75, 0x80, + 0xce, 0xf3, 0x9e, 0x9c, 0x8c, 0xd7, 0xeb, 0xc7, 0xc0, 0x9f, 0x83, 0x53, + 0xf8, 0x53, 0x47, 0xfb, 0x27, 0x89, 0xe5, 0x5f, 0xb0, 0x96, 0x59, 0x62, + 0xb0, 0xb7, 0x50, 0x92, 0xb0, 0xe9, 0x8b, 0x86, 0x0a, 0x15, 0x41, 0x00, + 0x7c, 0x88, 0x38, 0xc9, 0x19, 0xef, 0x5f, 0x23, 0x5b, 0x82, 0xea, 0x62, + 0x2b, 0xd3, 0x78, 0x58, 0xdd, 0xa5, 0x67, 0xd1, 0x5b, 0xcd, 0xe9, 0xff, + 0x00, 0x04, 0xd1, 0xe5, 0xb2, 0x6b, 0x9a, 0x5a, 0x23, 0xe9, 0xfd, 0x3b, + 0xe0, 0xff, 0x00, 0x84, 0xfe, 0x31, 0x38, 0xbc, 0xf1, 0x04, 0x4f, 0x0f, + 0x97, 0xe5, 0xa9, 0x7b, 0x59, 0x1d, 0x21, 0xca, 0x15, 0x93, 0x6b, 0x61, + 0xb6, 0xb1, 0x2d, 0x86, 0x05, 0x70, 0x31, 0x81, 0xd2, 0xbd, 0x4e, 0x7f, + 0xd9, 0xef, 0xe0, 0x9d, 0x96, 0x8e, 0x9a, 0x24, 0x9a, 0x4e, 0x97, 0x3c, + 0x51, 0xc3, 0xe4, 0xa2, 0xdc, 0xdb, 0xa3, 0x90, 0xbd, 0x86, 0x71, 0xf9, + 0x73, 0x5c, 0x95, 0xbf, 0x8d, 0x61, 0xd3, 0x6c, 0xe3, 0xb0, 0xd3, 0x42, + 0xc5, 0x6f, 0x0a, 0x08, 0xa3, 0x8a, 0x3f, 0xba, 0x00, 0xfa, 0x1f, 0xcf, + 0xd6, 0xb9, 0xad, 0x4b, 0xe2, 0x0c, 0x92, 0x92, 0x4b, 0x3b, 0x63, 0x8e, + 0x4f, 0xff, 0x00, 0x5e, 0xbf, 0x64, 0xe1, 0x8e, 0x0f, 0x86, 0x06, 0x17, + 0xab, 0x2e, 0x79, 0xbf, 0xb9, 0x7a, 0x2f, 0xe9, 0x8d, 0x51, 0xa7, 0x0f, + 0x81, 0x7c, 0xcf, 0xff, 0xd4, 0xfc, 0xf5, 0xd6, 0xfc, 0x43, 0x2d, 0xc4, + 0x4d, 0xf3, 0x6e, 0xe4, 0xaf, 0x3c, 0xfa, 0xfb, 0xd7, 0x91, 0x6a, 0xb3, + 0x1b, 0xe2, 0x60, 0x7f, 0x98, 0x13, 0x8e, 0xbd, 0xbf, 0xc6, 0xbd, 0x0e, + 0x4d, 0x13, 0x52, 0x74, 0x92, 0x47, 0x7b, 0x40, 0x01, 0xe5, 0x5a, 0x43, + 0xb8, 0xf5, 0xce, 0x3e, 0x4e, 0x6b, 0x88, 0xd5, 0xf4, 0xbb, 0xa8, 0xd7, + 0x7c, 0x53, 0xc5, 0xd4, 0x6e, 0x50, 0x84, 0x1c, 0x13, 0xce, 0x18, 0xf1, + 0xfa, 0x7f, 0x4a, 0xec, 0xc4, 0x54, 0x8c, 0xa2, 0xe2, 0xf5, 0x39, 0x68, + 0xc1, 0xa6, 0xa4, 0x8f, 0x25, 0xbc, 0xd1, 0x20, 0xd3, 0xee, 0x64, 0xbd, + 0x8c, 0xdc, 0x65, 0x6d, 0xe5, 0xd8, 0xb0, 0x29, 0x33, 0x0d, 0xaa, 0xdd, + 0x24, 0x55, 0xe0, 0x73, 0x8c, 0x6e, 0x52, 0xc0, 0x90, 0x49, 0xcd, 0x60, + 0xfc, 0x3e, 0xd2, 0x87, 0x88, 0x7c, 0x52, 0x3c, 0x2f, 0x73, 0x2c, 0xf6, + 0x37, 0x12, 0x79, 0xfe, 0x6d, 0xd5, 0xce, 0x10, 0x44, 0xd1, 0x92, 0x71, + 0xe5, 0xae, 0x3e, 0x7e, 0x76, 0xae, 0xe2, 0x76, 0x90, 0x39, 0xcd, 0x7a, + 0xac, 0xd0, 0x49, 0x6e, 0x99, 0x79, 0x19, 0x58, 0x1c, 0x87, 0x42, 0x72, + 0x0f, 0x3c, 0xe7, 0x8d, 0xbd, 0x7f, 0xfa, 0xf5, 0xc5, 0xdf, 0x45, 0x02, + 0xce, 0x97, 0x56, 0xe8, 0xad, 0x34, 0x4c, 0x76, 0xcc, 0xa3, 0x6b, 0x0d, + 0xdd, 0x79, 0x5f, 0xf3, 0xf5, 0xed, 0xf1, 0x15, 0x38, 0x7f, 0xdf, 0xe6, + 0x7a, 0xa7, 0xd0, 0xee, 0xab, 0x4e, 0x95, 0x49, 0x49, 0xcb, 0x46, 0xcd, + 0x7d, 0x47, 0xe1, 0xe6, 0xaf, 0xa7, 0x6a, 0xa2, 0xf2, 0xc6, 0xe1, 0xae, + 0x60, 0x03, 0xca, 0x54, 0x9d, 0x17, 0x7b, 0x47, 0x92, 0x49, 0x46, 0x8c, + 0x2b, 0x2e, 0x49, 0xdd, 0xd7, 0x3c, 0x9c, 0xe4, 0xf4, 0xe1, 0x23, 0xf0, + 0x4e, 0xb1, 0x65, 0x3b, 0x6a, 0x5f, 0x66, 0x49, 0xdd, 0xc4, 0xa6, 0x55, + 0x72, 0xec, 0xaa, 0xee, 0xac, 0xa5, 0x81, 0x27, 0xb9, 0xc6, 0x39, 0x53, + 0x8c, 0x8c, 0x30, 0x27, 0x3d, 0xbb, 0x78, 0xfb, 0x59, 0xb4, 0x78, 0xe2, + 0x99, 0x1a, 0xe2, 0xdd, 0x54, 0x80, 0xb3, 0xa0, 0x0c, 0xc1, 0x80, 0xc8, + 0x05, 0x46, 0x38, 0xc1, 0xc7, 0xf1, 0x11, 0xcf, 0x1d, 0x06, 0x85, 0x8f, + 0xc4, 0x1f, 0x0f, 0x5f, 0x06, 0x92, 0x13, 0x3c, 0x4a, 0xcc, 0xce, 0x8b, + 0x90, 0xd1, 0x6f, 0x6e, 0xa0, 0xf0, 0xe3, 0xef, 0x77, 0x03, 0x38, 0xed, + 0x53, 0x53, 0x23, 0xa1, 0x2d, 0x52, 0xe5, 0xf4, 0xff, 0x00, 0x23, 0x92, + 0xa6, 0x5d, 0x09, 0x69, 0xcb, 0xf7, 0x1e, 0x19, 0x7b, 0x61, 0x3d, 0xcc, + 0x0b, 0x69, 0x71, 0xa7, 0xcd, 0x6e, 0x86, 0x5b, 0x78, 0xcd, 0xe1, 0x47, + 0x72, 0x15, 0x48, 0xdd, 0xbe, 0x40, 0x54, 0x31, 0x04, 0xe0, 0x60, 0xaa, + 0xe0, 0x75, 0xe4, 0x63, 0x99, 0x99, 0x2c, 0x2e, 0x6d, 0x4a, 0x4a, 0x65, + 0x0d, 0xb4, 0xa9, 0x29, 0x0c, 0x91, 0x89, 0x3e, 0x62, 0x85, 0x42, 0x01, + 0x95, 0x07, 0x9d, 0xd9, 0xc1, 0xc0, 0x07, 0xb9, 0xaf, 0xab, 0x91, 0xb4, + 0xcd, 0x52, 0x63, 0x3b, 0xc9, 0x6e, 0x4a, 0xc5, 0x2c, 0x8b, 0x10, 0x60, + 0xa3, 0x7e, 0x17, 0x6a, 0xed, 0xce, 0xef, 0xef, 0x0c, 0x90, 0x3a, 0xd6, + 0xb5, 0x9d, 0xb5, 0xaf, 0xd9, 0x53, 0x61, 0xb4, 0x2c, 0xec, 0x44, 0x83, + 0x80, 0x23, 0x1d, 0x41, 0xeb, 0x93, 0xc6, 0x3f, 0x3a, 0xc6, 0x39, 0x14, + 0x7f, 0x9d, 0x99, 0x4b, 0x28, 0x82, 0x7b, 0xff, 0x00, 0x5e, 0xa7, 0xc9, + 0xf6, 0x70, 0xc3, 0x2c, 0xfe, 0x45, 0xcc, 0x93, 0x8d, 0xee, 0xde, 0x4c, + 0x31, 0xc1, 0x1c, 0x64, 0x06, 0x47, 0x04, 0x65, 0x9f, 0x8c, 0x7d, 0xe2, + 0xdb, 0xba, 0xfc, 0xc3, 0x3c, 0x8a, 0xb3, 0xff, 0x00, 0x08, 0x84, 0x1a, + 0x9d, 0xf8, 0x96, 0xc6, 0x1d, 0x48, 0x4b, 0x2f, 0xef, 0x6d, 0xe6, 0x16, + 0xeb, 0xb4, 0x1d, 0xfb, 0x04, 0x72, 0x67, 0x66, 0xc5, 0xc1, 0x27, 0x93, + 0xf7, 0x78, 0xea, 0x54, 0x57, 0xd2, 0xf1, 0x49, 0xe1, 0x7d, 0x3e, 0x36, + 0x37, 0xb3, 0xdb, 0x2f, 0x96, 0xc4, 0x44, 0xa6, 0x36, 0x6c, 0x6d, 0x38, + 0xe7, 0xa0, 0x1c, 0x74, 0xc7, 0xd2, 0xb4, 0xe3, 0xf1, 0x27, 0x84, 0xde, + 0xe4, 0xcd, 0x6d, 0x22, 0x22, 0xc6, 0x59, 0x1a, 0x40, 0x8a, 0xa4, 0xa6, + 0xd1, 0x80, 0x77, 0x1e, 0x4e, 0xe2, 0x48, 0x1c, 0x0f, 0xd7, 0x35, 0xfd, + 0x81, 0x1b, 0xfc, 0x6c, 0xca, 0x39, 0x5c, 0x6e, 0xec, 0xcf, 0x27, 0xb0, + 0xf8, 0x7b, 0xe2, 0x49, 0xaf, 0x21, 0x9b, 0x50, 0x68, 0xad, 0xd6, 0x2c, + 0x79, 0x33, 0x6d, 0x0f, 0xb1, 0x98, 0x10, 0x43, 0x60, 0x00, 0x4b, 0x6e, + 0x27, 0x2d, 0xc7, 0xa1, 0xe1, 0x6b, 0xb2, 0xb1, 0xf0, 0x5f, 0x87, 0xb4, + 0x2d, 0xb3, 0x5f, 0x6f, 0xbb, 0x9f, 0xe6, 0x63, 0xb1, 0x40, 0xca, 0x96, + 0xe7, 0x19, 0xc2, 0x00, 0x0e, 0x07, 0x27, 0x8c, 0x0e, 0x6a, 0x29, 0xfe, + 0x22, 0x5b, 0xcf, 0xa7, 0x7f, 0x66, 0xdb, 0x87, 0x99, 0xa2, 0xb8, 0xf3, + 0x1a, 0x49, 0x48, 0x05, 0xa4, 0x5c, 0x05, 0x6f, 0x94, 0xed, 0xc7, 0xa0, + 0xfe, 0x7d, 0x2b, 0x13, 0x54, 0xd7, 0x3c, 0x49, 0xe2, 0xd9, 0x22, 0xb9, + 0x79, 0x16, 0x4f, 0x25, 0x76, 0xa3, 0x31, 0xdd, 0x86, 0x24, 0xb3, 0x85, + 0x50, 0x02, 0xa7, 0x61, 0xc0, 0x62, 0x7b, 0xfa, 0xd7, 0x65, 0x1c, 0xaa, + 0x94, 0x15, 0xe0, 0xb5, 0xf3, 0xd4, 0xf5, 0x28, 0x60, 0x29, 0x53, 0x9a, + 0xba, 0xbf, 0xf5, 0xa7, 0xe2, 0x75, 0xed, 0xe2, 0x18, 0x24, 0x78, 0xe0, + 0xb0, 0x80, 0xc6, 0xac, 0x4f, 0xee, 0x51, 0xb0, 0xc5, 0x08, 0x3b, 0x59, + 0xc9, 0x00, 0x8c, 0x75, 0xc2, 0x9c, 0x67, 0xb9, 0xe2, 0xb5, 0x60, 0xd2, + 0x2e, 0xb5, 0x89, 0x59, 0xa6, 0x04, 0x2b, 0x48, 0x5d, 0xa4, 0x93, 0x82, + 0x4b, 0x72, 0xca, 0x14, 0x1c, 0x01, 0x9f, 0xc7, 0xe8, 0x38, 0xac, 0xff, + 0x00, 0x0d, 0xe8, 0xd8, 0x6f, 0xb5, 0x5d, 0x84, 0xdd, 0xd4, 0x28, 0x18, + 0xc7, 0x7c, 0x12, 0x49, 0x24, 0x8f, 0x5e, 0x3e, 0x95, 0xe9, 0xd6, 0x08, + 0x87, 0x01, 0x41, 0x03, 0xeb, 0xce, 0x6b, 0xd4, 0xc3, 0x60, 0xde, 0xf2, + 0x67, 0x6e, 0x2b, 0x18, 0x9e, 0x90, 0x8a, 0x4b, 0xfa, 0xea, 0x49, 0xa6, + 0x68, 0xb1, 0x5a, 0x22, 0xc5, 0x0e, 0x06, 0xda, 0xf4, 0xad, 0x22, 0x76, + 0x84, 0x2a, 0x37, 0xcc, 0x07, 0x1e, 0xe2, 0xb9, 0xb8, 0x15, 0x54, 0x02, + 0x79, 0xfe, 0x75, 0xa7, 0x0b, 0x88, 0xf9, 0xf6, 0xc8, 0x15, 0xeb, 0x41, + 0xd9, 0x59, 0x1e, 0x3c, 0xb5, 0x77, 0x67, 0x77, 0x2d, 0xd2, 0x49, 0x6f, + 0xb7, 0xb8, 0xae, 0x0b, 0x56, 0x97, 0x69, 0x2c, 0xa4, 0x83, 0xcf, 0x35, + 0x64, 0xdf, 0x29, 0x53, 0xbc, 0x8c, 0x8e, 0x99, 0xf5, 0xe9, 0xf8, 0x56, + 0x3d, 0xf3, 0x79, 0x89, 0xf3, 0x77, 0x1c, 0x67, 0xf2, 0xc8, 0xfc, 0x8d, + 0x4f, 0x37, 0x71, 0xd8, 0xf3, 0x7f, 0x13, 0x47, 0x06, 0xa3, 0x68, 0xf6, + 0xb7, 0xa8, 0xb2, 0xa3, 0x8c, 0x32, 0xb2, 0x82, 0x1b, 0xea, 0x08, 0xc1, + 0xaf, 0x96, 0x3c, 0x47, 0xf0, 0xd9, 0x12, 0xe9, 0xae, 0x74, 0x3b, 0x99, + 0xa0, 0x24, 0xe7, 0x63, 0x13, 0x24, 0x7d, 0x7a, 0x0c, 0x9d, 0xc0, 0x7d, + 0x1b, 0x03, 0xb0, 0xaf, 0xae, 0x35, 0x0b, 0x60, 0xcb, 0x90, 0x41, 0xed, + 0xb6, 0xb8, 0x2d, 0x4b, 0x4a, 0x56, 0xc9, 0xc0, 0xcf, 0x3d, 0x2b, 0x9e, + 0xae, 0x1a, 0x2c, 0xda, 0x13, 0x3e, 0x42, 0xd4, 0x34, 0x9f, 0x1a, 0x69, + 0xb9, 0x01, 0x3c, 0xe8, 0xd7, 0xa2, 0xc7, 0xf3, 0x21, 0xe3, 0x18, 0x2a, + 0x71, 0xc7, 0x7e, 0x87, 0xfa, 0xd6, 0x2d, 0xe6, 0xa3, 0xa3, 0x79, 0x65, + 0xb5, 0xdd, 0x3e, 0x0d, 0xe0, 0x11, 0xb5, 0xe1, 0xda, 0xd9, 0xe3, 0xaf, + 0xdd, 0x18, 0xeb, 0x5f, 0x56, 0x5c, 0xe8, 0xce, 0xd9, 0xe8, 0x7d, 0x88, + 0xfe, 0x95, 0x8b, 0x36, 0x83, 0xbd, 0x4a, 0xb4, 0x2a, 0xc0, 0xfa, 0x01, + 0xd0, 0x7a, 0xf6, 0xae, 0x29, 0xe1, 0x1f, 0x73, 0x4b, 0xa3, 0xe5, 0xdb, + 0x38, 0x7e, 0x1d, 0xde, 0x62, 0xe0, 0xe9, 0xe1, 0xa3, 0x6d, 0xdb, 0xc2, + 0xb8, 0x40, 0xa7, 0x8e, 0x3e, 0xe3, 0x72, 0x39, 0xfc, 0xb1, 0x57, 0xed, + 0x3c, 0x39, 0xf0, 0xce, 0x69, 0x8d, 0xcc, 0x5a, 0x5d, 0xd6, 0x76, 0x6f, + 0xdd, 0x95, 0x24, 0x91, 0xd8, 0x1c, 0x03, 0xeb, 0xfe, 0x4d, 0x7b, 0xb4, + 0x9e, 0x17, 0xd2, 0x18, 0x9d, 0xd6, 0x30, 0xb1, 0x27, 0xf8, 0xa2, 0x42, + 0x7d, 0xc7, 0x23, 0x9f, 0xeb, 0x51, 0x8f, 0x05, 0xf8, 0x73, 0x70, 0x5f, + 0xec, 0xf8, 0x49, 0xcf, 0x43, 0x12, 0xfe, 0x9c, 0x0a, 0xe6, 0xa9, 0x81, + 0x93, 0xe8, 0x1c, 0x90, 0x7b, 0x9e, 0x57, 0xa6, 0xe9, 0x9f, 0x08, 0x62, + 0x85, 0x6e, 0x9b, 0x48, 0xf3, 0x16, 0x32, 0xca, 0x55, 0xcc, 0x4a, 0x78, + 0x04, 0xe4, 0x10, 0x8c, 0x7e, 0xf0, 0x1c, 0xfe, 0x23, 0x15, 0xd5, 0x78, + 0x6a, 0xef, 0xc1, 0xf3, 0x5e, 0x05, 0xd0, 0x7c, 0x33, 0x63, 0x3b, 0x12, + 0x0b, 0xac, 0xca, 0x67, 0x6c, 0x8e, 0x87, 0x8d, 0x87, 0x83, 0x8e, 0x06, + 0x4f, 0x53, 0x8a, 0xf4, 0xdd, 0x2f, 0xc2, 0x3a, 0x0d, 0x86, 0xd4, 0xb7, + 0xd3, 0x6d, 0xd7, 0x03, 0x0a, 0x7c, 0xb4, 0xe3, 0xa7, 0xb1, 0xf4, 0xaf, + 0x49, 0xd3, 0xed, 0xee, 0x17, 0x68, 0x2a, 0x8a, 0xbc, 0x74, 0x1c, 0x0e, + 0xc3, 0xdb, 0xf2, 0xac, 0x7f, 0xb3, 0x1b, 0xf2, 0x29, 0x46, 0x9a, 0xd6, + 0xc7, 0x1f, 0xa7, 0xe9, 0xbf, 0x12, 0xaf, 0xf4, 0x7b, 0xed, 0x2f, 0x40, + 0xd3, 0xac, 0x74, 0xd4, 0xbb, 0x86, 0x55, 0x48, 0xe6, 0x88, 0x47, 0x1b, + 0x3b, 0xfd, 0xd6, 0x64, 0x20, 0xb9, 0xc1, 0x19, 0xf9, 0x88, 0x00, 0xf3, + 0xcf, 0x7e, 0xe3, 0xc0, 0xdf, 0x09, 0x35, 0x61, 0x27, 0x93, 0xe2, 0x2b, + 0x78, 0xe6, 0xb8, 0x0b, 0x87, 0x96, 0xd9, 0x5a, 0x4c, 0x2f, 0xca, 0x49, + 0x52, 0x88, 0xb9, 0xc9, 0x56, 0x01, 0x41, 0x64, 0x03, 0xb6, 0x4f, 0x1d, + 0x7e, 0x94, 0xf2, 0xc5, 0xb6, 0x3b, 0x99, 0x18, 0xa2, 0x9f, 0x95, 0x41, + 0x20, 0x0e, 0x7a, 0x81, 0xd0, 0x57, 0xa4, 0xd8, 0x78, 0x96, 0x5d, 0x3e, + 0x31, 0x1c, 0x07, 0x80, 0x06, 0x72, 0x3b, 0x7a, 0x7b, 0xfb, 0x57, 0x47, + 0xf6, 0x34, 0x24, 0x92, 0x92, 0xd8, 0x4a, 0x70, 0x4e, 0xfc, 0xa7, 0x43, + 0xe1, 0x99, 0x74, 0x3d, 0x06, 0x33, 0x69, 0xa6, 0xc7, 0x15, 0xbe, 0x3f, + 0x76, 0xdb, 0x14, 0x07, 0x24, 0x1e, 0x43, 0x77, 0xe0, 0x71, 0x8a, 0xeb, + 0x64, 0xf1, 0x7f, 0x96, 0x9b, 0x15, 0xd7, 0x00, 0xf0, 0xa5, 0x8e, 0x4f, + 0x15, 0xc3, 0x4d, 0xe2, 0x4d, 0x2b, 0x55, 0x1b, 0x35, 0x68, 0x62, 0x91, + 0xc2, 0x05, 0xdc, 0xea, 0x32, 0xa0, 0x67, 0x18, 0x6c, 0x86, 0x1d, 0x7f, + 0x85, 0x85, 0x65, 0xde, 0x68, 0x3a, 0x45, 0xde, 0x1a, 0xc6, 0xe2, 0xe2, + 0x22, 0x48, 0x65, 0x57, 0x61, 0x2a, 0x9c, 0xfa, 0x67, 0x0d, 0xf4, 0xcb, + 0x1a, 0xf7, 0xf0, 0xd0, 0x8d, 0x38, 0xa4, 0x95, 0x8c, 0x2b, 0x49, 0xcd, + 0xdd, 0xbb, 0x9e, 0xad, 0xa4, 0xf8, 0x82, 0xd2, 0xee, 0xec, 0xa6, 0xb7, + 0x78, 0x6c, 0xa0, 0xf2, 0x8b, 0x89, 0x21, 0x8c, 0xc9, 0x97, 0x0d, 0x8d, + 0x84, 0x0c, 0xed, 0xe3, 0x07, 0x38, 0x20, 0xf4, 0xe3, 0x1c, 0xf2, 0x7a, + 0xc7, 0x8a, 0xd2, 0x2b, 0xd9, 0xad, 0x6c, 0x2e, 0x0d, 0xc5, 0xba, 0xfd, + 0xcb, 0x86, 0x8c, 0xc4, 0x5b, 0x8e, 0x72, 0xa4, 0xe7, 0x83, 0x9e, 0x70, + 0x01, 0xeb, 0xc5, 0x70, 0x12, 0xe9, 0x3a, 0xc4, 0x12, 0x7f, 0xa3, 0xcf, + 0x06, 0x02, 0x9e, 0x5f, 0x7c, 0x7c, 0xfa, 0x9c, 0x06, 0xeb, 0xec, 0xd5, + 0x9d, 0x35, 0x97, 0x88, 0x1f, 0x11, 0xb9, 0x87, 0x1b, 0x43, 0x63, 0xcc, + 0x20, 0x71, 0xf5, 0x5e, 0xa7, 0x3f, 0xe4, 0xd6, 0xca, 0xa4, 0xb9, 0xee, + 0x9e, 0x84, 0x49, 0x47, 0x96, 0xd6, 0xd4, 0xff, 0xd5, 0xfc, 0xde, 0x37, + 0x64, 0x38, 0x3f, 0x2e, 0x17, 0x1b, 0x90, 0x16, 0x19, 0x5c, 0xf2, 0x7a, + 0xf7, 0xac, 0x3b, 0xe3, 0xb9, 0x76, 0x64, 0x9f, 0x9b, 0x3d, 0x3b, 0xfe, + 0x54, 0x2d, 0xec, 0x4d, 0x19, 0x32, 0x32, 0x82, 0xa8, 0x47, 0x97, 0xd9, + 0x89, 0x20, 0x60, 0x60, 0x11, 0x91, 0xea, 0x70, 0x31, 0x9e, 0xfd, 0x72, + 0xae, 0x2e, 0xf7, 0x92, 0x5b, 0x6e, 0x70, 0x4a, 0xaa, 0xe4, 0x64, 0x7e, + 0x95, 0xd6, 0xac, 0x71, 0x5d, 0x98, 0x37, 0xd0, 0xdb, 0xb6, 0x4b, 0x02, + 0xc7, 0x04, 0x03, 0x8e, 0x95, 0x85, 0xe4, 0x2b, 0x12, 0xa0, 0x0c, 0x74, + 0xc5, 0x6f, 0x5d, 0x3b, 0x31, 0x3b, 0x32, 0x48, 0x19, 0x39, 0xf4, 0xef, + 0x91, 0xd7, 0xf5, 0xac, 0xd5, 0xda, 0x8b, 0xb9, 0xf8, 0x18, 0xcb, 0x75, + 0xe7, 0xdb, 0x35, 0x56, 0x56, 0xd0, 0xa5, 0x27, 0xd4, 0xcf, 0x6d, 0x3c, + 0xb3, 0xee, 0xec, 0x3b, 0x91, 0xfc, 0xab, 0x16, 0x7f, 0x09, 0xe9, 0x4e, + 0xb0, 0xc7, 0xe4, 0xa4, 0x6b, 0x0c, 0x86, 0x44, 0x58, 0xbe, 0x4c, 0x93, + 0x9c, 0x86, 0x03, 0xa8, 0x39, 0xcf, 0x5e, 0xb5, 0xda, 0x2e, 0xc2, 0xdb, + 0x94, 0x71, 0xfe, 0x73, 0xc5, 0x3f, 0x64, 0x00, 0x15, 0x39, 0xf9, 0xbb, + 0x1f, 0x5a, 0xc6, 0x74, 0x53, 0xd1, 0x9a, 0x42, 0xab, 0x4f, 0x43, 0x88, + 0x93, 0xc2, 0xd6, 0xa6, 0x32, 0xd6, 0xe6, 0x45, 0xde, 0x54, 0x67, 0xe5, + 0x3b, 0x7d, 0xd4, 0x1e, 0x71, 0xc7, 0x72, 0x40, 0xa8, 0x9f, 0xc3, 0xd7, + 0x0a, 0xc1, 0x61, 0xb8, 0x18, 0x53, 0x97, 0x18, 0xfb, 0xc4, 0xe0, 0x73, + 0xcf, 0x07, 0x03, 0xe9, 0x5d, 0xd7, 0xca, 0x46, 0x06, 0x33, 0x9e, 0x49, + 0xc7, 0x5a, 0x80, 0xc2, 0x00, 0xde, 0x70, 0x7d, 0x79, 0xeb, 0x5c, 0xef, + 0x0a, 0x8d, 0xd6, 0x21, 0xf5, 0x3c, 0xff, 0x00, 0x50, 0xf0, 0xba, 0xcb, + 0x07, 0x95, 0x2b, 0x02, 0xc7, 0x70, 0x1c, 0x93, 0xd7, 0xa6, 0x47, 0x43, + 0x4c, 0xb4, 0xf0, 0xed, 0xb4, 0x5f, 0xbb, 0x6c, 0xb7, 0xcb, 0x8d, 0xc4, + 0x00, 0xdc, 0x77, 0xca, 0x81, 0xc8, 0xae, 0xee, 0x68, 0x58, 0x2e, 0xe0, + 0x73, 0x8f, 0x40, 0x7f, 0xad, 0x20, 0xb2, 0x0c, 0x37, 0x0c, 0x8c, 0xf4, + 0x3c, 0x83, 0xf8, 0xf5, 0xfc, 0x6a, 0xbe, 0xab, 0x1e, 0xa2, 0xf6, 0xed, + 0x98, 0xba, 0x5e, 0x89, 0xa3, 0x69, 0xb1, 0x94, 0xb7, 0xb7, 0x88, 0x17, + 0x6d, 0xcc, 0x08, 0xea, 0x71, 0xd7, 0xbf, 0x4a, 0xe9, 0xad, 0x62, 0x83, + 0xfe, 0x59, 0xa0, 0x03, 0xdb, 0x81, 0x8f, 0xf3, 0xff, 0x00, 0xea, 0xaa, + 0x42, 0xd1, 0x51, 0x87, 0x72, 0x48, 0xca, 0x83, 0xf9, 0x91, 0xd7, 0x1f, + 0xe7, 0xeb, 0x57, 0xe1, 0x04, 0x48, 0x15, 0x0e, 0xec, 0x0c, 0x72, 0x00, + 0x3f, 0xfd, 0x7f, 0xd2, 0xb4, 0xf6, 0x29, 0x11, 0xed, 0x1b, 0x3a, 0x5b, + 0x36, 0x5d, 0xc3, 0xe5, 0x38, 0xc6, 0x46, 0x3b, 0x77, 0xae, 0xa2, 0xd2, + 0x44, 0x0a, 0x19, 0xb0, 0x0e, 0x33, 0xc7, 0x5f, 0x63, 0x5c, 0x3c, 0x37, + 0x18, 0xc0, 0xfb, 0xa4, 0x0c, 0xe3, 0x20, 0x67, 0x1f, 0x5f, 0xe8, 0x6a, + 0xec, 0x77, 0x8c, 0xa7, 0x78, 0x6c, 0x81, 0xc1, 0x04, 0xff, 0x00, 0xfa, + 0xb2, 0x68, 0xe5, 0x44, 0xdf, 0xb9, 0xe9, 0x30, 0xdd, 0x03, 0xc6, 0xe0, + 0x36, 0xe3, 0xfc, 0xf3, 0x52, 0x49, 0x78, 0x31, 0xc3, 0x77, 0xc0, 0x39, + 0xaf, 0x3d, 0x3a, 0xb9, 0x4f, 0xf5, 0x7c, 0x8e, 0x83, 0x9e, 0x4f, 0xe3, + 0x9a, 0xb6, 0xba, 0xb2, 0xb2, 0x00, 0xca, 0xa4, 0xf1, 0xcf, 0xcd, 0x9c, + 0x0e, 0xbe, 0xdc, 0xe6, 0x95, 0x84, 0x75, 0xdf, 0x6e, 0xc9, 0xf9, 0xfa, + 0x9f, 0x5f, 0x43, 0x51, 0xcb, 0x72, 0x79, 0x18, 0xe7, 0xbe, 0x0e, 0x71, + 0x5c, 0x8b, 0xea, 0xd1, 0x46, 0x9b, 0xdf, 0x00, 0x03, 0x82, 0xc7, 0x3d, + 0x01, 0xfc, 0x2a, 0x16, 0xd5, 0xff, 0x00, 0x79, 0x87, 0x60, 0x06, 0x70, + 0x39, 0x1c, 0x8e, 0xfd, 0xe8, 0x71, 0x11, 0xb5, 0x34, 0xc4, 0x82, 0xc3, + 0x1e, 0x9c, 0xf1, 0x9a, 0xc4, 0xb9, 0x40, 0xca, 0x46, 0x31, 0x8f, 0x5e, + 0x08, 0xa7, 0xff, 0x00, 0x69, 0xc6, 0xec, 0x70, 0x09, 0xce, 0x71, 0x81, + 0xc7, 0x7f, 0xa5, 0x52, 0x9a, 0xf1, 0x26, 0x5d, 0xdc, 0xe7, 0x39, 0xda, + 0x39, 0x20, 0x76, 0xfa, 0x55, 0x72, 0x85, 0xca, 0x2f, 0x0f, 0xcc, 0x48, + 0x1d, 0x4f, 0x39, 0x18, 0xe7, 0xdb, 0x15, 0x44, 0xc6, 0x26, 0x95, 0x62, + 0x89, 0x43, 0x33, 0x30, 0x50, 0x07, 0x52, 0x49, 0xc0, 0x1d, 0x6a, 0xfb, + 0x5c, 0xc6, 0xdf, 0xbc, 0x61, 0x81, 0x8c, 0x91, 0xfe, 0x35, 0x1c, 0x7b, + 0x19, 0x8c, 0x88, 0xa1, 0x41, 0x07, 0x1d, 0x87, 0xff, 0x00, 0x5a, 0x87, + 0x01, 0xa9, 0x99, 0x6d, 0xa7, 0xba, 0x4e, 0xf1, 0xca, 0x36, 0xb2, 0x31, + 0x04, 0x63, 0xa3, 0x8e, 0x31, 0xf8, 0x54, 0xd1, 0xd9, 0x87, 0x6d, 0xb8, + 0xe7, 0x38, 0x15, 0x71, 0xe4, 0x85, 0x13, 0xe4, 0x46, 0xe3, 0x8e, 0x3b, + 0x9f, 0x5c, 0x55, 0x94, 0x2f, 0x2b, 0x26, 0x5b, 0xa2, 0x60, 0x67, 0xb7, + 0x1c, 0x0a, 0x95, 0x4d, 0x14, 0xe6, 0x3e, 0xda, 0xd2, 0x2f, 0x30, 0x85, + 0x03, 0x76, 0xd5, 0xf4, 0xc8, 0xff, 0x00, 0x26, 0xb5, 0xa3, 0x89, 0x87, + 0x0c, 0xca, 0xa0, 0x1c, 0x7a, 0x03, 0x9f, 0xc3, 0xf2, 0xaa, 0x36, 0xca, + 0x50, 0x8e, 0x46, 0x3b, 0xf7, 0xeb, 0x5b, 0x30, 0xed, 0xea, 0xa3, 0x38, + 0xcf, 0x6c, 0x64, 0x51, 0xc8, 0x85, 0xce, 0xcb, 0x31, 0x2f, 0x97, 0x86, + 0x62, 0x73, 0x9e, 0xa7, 0xb7, 0xff, 0x00, 0xae, 0xb6, 0xa3, 0x6f, 0x3a, + 0x1c, 0x63, 0x20, 0x73, 0xc0, 0x00, 0xf3, 0xea, 0x7a, 0xff, 0x00, 0x4a, + 0xc8, 0x56, 0x59, 0x0e, 0x00, 0xdd, 0xe8, 0x7b, 0x8c, 0x7f, 0x3a, 0xd3, + 0x80, 0xc0, 0x17, 0x6e, 0xe3, 0x9c, 0xe7, 0x8e, 0x6b, 0x45, 0xe4, 0x26, + 0xcb, 0x30, 0xdb, 0x4a, 0xce, 0x15, 0x7a, 0x74, 0x18, 0xe9, 0xfd, 0x73, + 0x5d, 0x25, 0xaa, 0x1b, 0x75, 0x2b, 0x93, 0x9f, 0x5e, 0xd9, 0xff, 0x00, + 0x3d, 0x6b, 0x36, 0x0b, 0x95, 0xc6, 0xd2, 0x57, 0x23, 0xef, 0x33, 0x75, + 0xfc, 0x71, 0x56, 0x13, 0x50, 0x88, 0x82, 0xd9, 0x0c, 0x01, 0xc0, 0x61, + 0xd3, 0xea, 0x08, 0xeb, 0x4a, 0xfa, 0x92, 0xd1, 0xa8, 0x2e, 0x19, 0x13, + 0x6c, 0x6e, 0x01, 0xee, 0x4f, 0x1f, 0xef, 0x1c, 0xd6, 0x0d, 0xfc, 0xf2, + 0x3e, 0x5d, 0xb9, 0x1c, 0xf4, 0x24, 0xe7, 0x1f, 0x8e, 0x29, 0xd2, 0xea, + 0x1b, 0x23, 0x25, 0x4b, 0x29, 0x74, 0xda, 0x17, 0x90, 0x36, 0x9e, 0xbc, + 0x7b, 0xf7, 0xac, 0x29, 0xef, 0x54, 0x7d, 0xee, 0x4e, 0x3f, 0x5e, 0x6a, + 0xa3, 0xb8, 0xa4, 0xec, 0x7f, 0xff, 0xd6, 0xfc, 0xa4, 0x2e, 0x8a, 0xad, + 0x1c, 0x87, 0x18, 0x6f, 0x6c, 0x63, 0x8f, 0x7c, 0xf5, 0xcf, 0x7a, 0xa6, + 0xf2, 0x42, 0x48, 0x0c, 0x38, 0x03, 0x20, 0x9e, 0x45, 0x57, 0x7b, 0xa8, + 0x9b, 0xe6, 0x1c, 0xe3, 0xa7, 0x22, 0xa2, 0x33, 0x92, 0x73, 0x85, 0x38, + 0xfe, 0x12, 0xd9, 0xfe, 0x55, 0xd2, 0xee, 0x71, 0x7c, 0x88, 0xe4, 0xdc, + 0x09, 0x09, 0x92, 0x4f, 0x7e, 0x41, 0xfe, 0xb5, 0x51, 0xa1, 0x25, 0xc3, + 0xc8, 0xe1, 0x4e, 0x0e, 0x3b, 0x37, 0xbf, 0x5f, 0xa5, 0x4f, 0x73, 0x2c, + 0x93, 0xb6, 0xf2, 0x22, 0x8b, 0xda, 0x3c, 0x80, 0x7e, 0xb9, 0x27, 0xfc, + 0x2a, 0x8c, 0xa3, 0x2a, 0x23, 0x6e, 0x4f, 0x6c, 0x12, 0x47, 0xe8, 0x29, + 0x29, 0x30, 0xe5, 0x2d, 0xf9, 0x6c, 0x70, 0xb1, 0xb7, 0x52, 0x00, 0x24, + 0x1f, 0xfe, 0xb5, 0x43, 0x24, 0xce, 0xaf, 0x86, 0x00, 0xf3, 0xc8, 0xe7, + 0xaf, 0x4f, 0x4a, 0xa2, 0xf1, 0x4f, 0xbb, 0xe5, 0x1f, 0x36, 0x79, 0xcb, + 0x0c, 0x7e, 0x54, 0xd8, 0xd2, 0xff, 0x00, 0x24, 0x12, 0x9e, 0xf8, 0x1c, + 0x75, 0xeb, 0xc1, 0xcd, 0x37, 0x2d, 0x46, 0x93, 0x12, 0x5b, 0xd6, 0x8d, + 0xc2, 0xe3, 0x39, 0x3d, 0x80, 0x3c, 0xe2, 0xa2, 0x6d, 0x53, 0x68, 0x05, + 0x23, 0x38, 0xcf, 0x07, 0xa7, 0x4f, 0x4e, 0x6a, 0x59, 0x62, 0xbc, 0xce, + 0xcc, 0x82, 0x3d, 0x36, 0x93, 0xed, 0xdf, 0xdb, 0xda, 0xa9, 0x4d, 0x65, + 0x77, 0x23, 0xf0, 0x4a, 0xe3, 0x9e, 0x13, 0x1c, 0xfe, 0x15, 0x5c, 0xc8, + 0x5b, 0x12, 0x2e, 0xab, 0x38, 0x52, 0xeb, 0x19, 0x2a, 0x0f, 0xcd, 0x9e, + 0xc4, 0x8e, 0x33, 0xcf, 0xf4, 0xab, 0x56, 0x9a, 0xe9, 0x61, 0x89, 0x15, + 0x17, 0x9c, 0xe7, 0x24, 0x74, 0xed, 0xc9, 0xac, 0xcf, 0xec, 0xfb, 0xa8, + 0x1b, 0xcc, 0x59, 0x1f, 0xd0, 0x8c, 0x1e, 0x9f, 0x4e, 0x95, 0x58, 0xe9, + 0x45, 0x88, 0x42, 0xf2, 0x83, 0x8e, 0xb8, 0x07, 0xf3, 0x1f, 0x2f, 0xf9, + 0xed, 0x4b, 0x99, 0x02, 0x6f, 0x73, 0xaf, 0x8e, 0xfe, 0x09, 0xdb, 0x9d, + 0x9c, 0x76, 0x2c, 0x32, 0x7f, 0x2c, 0xf4, 0xad, 0x78, 0xae, 0x6d, 0xd1, + 0x32, 0x19, 0x54, 0x8c, 0x10, 0xcb, 0xc6, 0x3f, 0xcf, 0xe1, 0x5e, 0x6b, + 0xfd, 0x99, 0x76, 0x1b, 0x31, 0xcc, 0xdb, 0x54, 0xf0, 0x0a, 0x95, 0xfe, + 0x59, 0xa6, 0x9b, 0x7d, 0x4a, 0x3c, 0x2e, 0x64, 0x60, 0x7f, 0xba, 0x0a, + 0xf3, 0xfa, 0x71, 0x52, 0xd7, 0x62, 0x94, 0x9f, 0x63, 0xd0, 0x9e, 0x7b, + 0x55, 0x24, 0x79, 0xcb, 0x96, 0x6e, 0xc4, 0x11, 0x83, 0xeb, 0xc9, 0xfd, + 0x2a, 0xbb, 0xdd, 0xc7, 0xd1, 0x59, 0x48, 0x03, 0xf8, 0x3f, 0xc4, 0x73, + 0xfa, 0x57, 0x04, 0x96, 0xd7, 0xff, 0x00, 0x7a, 0x55, 0x63, 0x9c, 0x0e, + 0x0f, 0x23, 0xf3, 0xff, 0x00, 0x1a, 0x73, 0xdb, 0xea, 0x4d, 0x18, 0x08, + 0x87, 0xaf, 0x21, 0x8e, 0x31, 0xf9, 0x67, 0xfa, 0x50, 0xad, 0xd4, 0x77, + 0x67, 0x63, 0xf6, 0xa7, 0x70, 0x5f, 0xe6, 0xe3, 0xb8, 0x27, 0xf3, 0x20, + 0xd3, 0x16, 0xe2, 0x66, 0x7d, 0xee, 0x48, 0x5c, 0xed, 0x19, 0xc7, 0x05, + 0x4f, 0x39, 0xe0, 0x7a, 0x8a, 0xe3, 0x4c, 0x1a, 0x94, 0x07, 0xe4, 0x57, + 0x04, 0x73, 0x95, 0x38, 0x03, 0x3d, 0x71, 0xcd, 0x48, 0xcb, 0xaa, 0xdc, + 0x2e, 0xc9, 0x4c, 0x8c, 0x3d, 0x0e, 0x4f, 0xf2, 0x22, 0xaa, 0xca, 0xfb, + 0x87, 0x31, 0xd9, 0x8b, 0xc4, 0x49, 0x08, 0x03, 0xa9, 0xdf, 0xbb, 0x8e, + 0x4f, 0x70, 0x30, 0x3f, 0x4a, 0x79, 0xbe, 0xb4, 0xc0, 0xf3, 0xa4, 0x38, + 0x27, 0x3c, 0xf5, 0x1e, 0x9e, 0x9f, 0xca, 0xb9, 0x7b, 0x58, 0xef, 0x2d, + 0x86, 0xe5, 0x50, 0xb9, 0x3c, 0x8e, 0x4f, 0x51, 0xdf, 0xa8, 0xe6, 0xac, + 0xca, 0x93, 0xcf, 0x28, 0x79, 0x90, 0x02, 0xa3, 0x0a, 0x49, 0x1d, 0x3e, + 0x98, 0xc7, 0xeb, 0x4d, 0x45, 0x77, 0x13, 0x99, 0xae, 0xfa, 0x82, 0xaf, + 0x4c, 0xb0, 0xcf, 0x0c, 0xa7, 0x9f, 0xcb, 0x92, 0x45, 0x3b, 0xfb, 0x45, + 0xe4, 0x20, 0x42, 0x8d, 0x9c, 0x60, 0x91, 0xc1, 0xc7, 0xae, 0x47, 0x4f, + 0xcb, 0xf2, 0xaa, 0x11, 0xed, 0x87, 0xe7, 0x75, 0x52, 0x38, 0x1b, 0x41, + 0x51, 0xfc, 0x89, 0xfe, 0x55, 0x7c, 0x5e, 0xdb, 0x6d, 0x2a, 0x88, 0xe3, + 0x9e, 0xbb, 0x89, 0xfc, 0x38, 0xa6, 0xe2, 0x84, 0xa5, 0xd0, 0x9e, 0x1b, + 0xac, 0xb8, 0x69, 0x5b, 0x73, 0x1e, 0x70, 0xe3, 0x38, 0xfc, 0x7a, 0x7f, + 0x5a, 0xbf, 0xe7, 0x29, 0x00, 0x21, 0xc8, 0xcf, 0x71, 0x81, 0x9f, 0xce, + 0xb2, 0x9a, 0xe6, 0x07, 0x1c, 0xed, 0x23, 0x18, 0x39, 0xc9, 0x3f, 0xad, + 0x49, 0xf6, 0x9b, 0x48, 0xce, 0x4a, 0x12, 0x47, 0x18, 0x53, 0x8e, 0x3e, + 0xa5, 0x6a, 0x6c, 0x3b, 0xf6, 0x35, 0xde, 0xe1, 0x89, 0x0c, 0xdc, 0x11, + 0xc0, 0xc7, 0x4c, 0x0e, 0xd5, 0x6c, 0xbb, 0xc5, 0x3a, 0xcf, 0x1b, 0x61, + 0xd7, 0x0e, 0x42, 0x12, 0xbb, 0x48, 0xe4, 0x60, 0x80, 0x30, 0x47, 0x5e, + 0x0d, 0x66, 0xc7, 0x79, 0xa4, 0x9e, 0x62, 0x8a, 0xe1, 0x4f, 0x19, 0x72, + 0xea, 0x7f, 0x00, 0x31, 0xd3, 0xeb, 0x44, 0xb7, 0x96, 0x4b, 0xf3, 0x15, + 0x94, 0x13, 0xfd, 0xf3, 0xd4, 0x7b, 0x70, 0x28, 0x48, 0x1b, 0x67, 0x45, + 0xe7, 0x2a, 0x0f, 0x36, 0x43, 0xb9, 0xa5, 0xcb, 0x3b, 0x64, 0xe7, 0x71, + 0x27, 0x92, 0x4e, 0x49, 0xc9, 0xe4, 0x9e, 0xf5, 0x2a, 0x5c, 0xc6, 0x88, + 0x5a, 0x3e, 0xdd, 0x71, 0xc5, 0x73, 0x49, 0xa9, 0xda, 0x92, 0x15, 0xf3, + 0xb4, 0x73, 0x80, 0x7d, 0x7a, 0xf3, 0x8a, 0x90, 0xea, 0x10, 0x6e, 0x0e, + 0x08, 0x0a, 0x4e, 0x79, 0x27, 0x3f, 0x5e, 0xdf, 0xce, 0x93, 0x8d, 0x85, + 0xcd, 0xd8, 0xeb, 0x12, 0x7d, 0xc4, 0xf2, 0xc1, 0x8f, 0x43, 0xf7, 0xbf, + 0xfa, 0xdf, 0xae, 0x6b, 0x42, 0x2b, 0x8f, 0x24, 0x0f, 0x9d, 0x89, 0xec, + 0x41, 0x18, 0x23, 0xe9, 0xd3, 0xf4, 0xcd, 0x70, 0x71, 0xea, 0x68, 0xec, + 0x77, 0x04, 0x18, 0x1f, 0xc0, 0xd8, 0x3c, 0x7e, 0x38, 0xfd, 0x0d, 0x09, + 0xa9, 0xa9, 0x61, 0x24, 0x4a, 0x57, 0x9c, 0xe7, 0x69, 0x27, 0x3f, 0x5e, + 0xd4, 0xb9, 0x47, 0xcc, 0x77, 0xa7, 0x53, 0x9c, 0x11, 0x1a, 0x01, 0x95, + 0xe0, 0x30, 0x1c, 0x73, 0xeb, 0xcf, 0x38, 0xa9, 0x93, 0x50, 0x56, 0x01, + 0x66, 0x75, 0x2c, 0x30, 0x4e, 0x7f, 0xc3, 0x35, 0xc6, 0x8d, 0x58, 0x32, + 0x6d, 0xf3, 0x19, 0x79, 0xe8, 0xfc, 0xff, 0x00, 0x4c, 0xd5, 0x85, 0xb9, + 0xb5, 0x75, 0xde, 0xd7, 0x30, 0x80, 0xa7, 0x9c, 0xa1, 0xe7, 0xfa, 0x9a, + 0x5c, 0xa3, 0xe6, 0xb9, 0xd2, 0x3d, 0xde, 0xf6, 0x2c, 0x4f, 0x1e, 0xa7, + 0x07, 0x8a, 0xce, 0x92, 0x55, 0x70, 0x5a, 0x33, 0x8f, 0xbd, 0x90, 0xc3, + 0x9c, 0xfb, 0x73, 0x5c, 0xdc, 0xfa, 0xa4, 0x71, 0x7c, 0xb1, 0x11, 0x21, + 0x27, 0xef, 0x20, 0x65, 0x1f, 0x53, 0xbb, 0x03, 0xf5, 0xa8, 0x06, 0xa8, + 0xbc, 0x06, 0x27, 0x9c, 0xf7, 0xe0, 0x0f, 0xd6, 0x9a, 0x25, 0xdc, 0xff, + 0xd9 + }; + const unsigned int DayEnvironmentHDRI019_1K_TONEMAPPED_jpg_len = 17065; + } +} \ No newline at end of file diff --git a/oom_voxel_ogt.h b/oom_voxel_ogt.h new file mode 100644 index 0000000..aff4c34 --- /dev/null +++ b/oom_voxel_ogt.h @@ -0,0 +1,158 @@ +// oomer wrapper code for opengametools voxel conversion + +#pragma once + +#include "oom_voxel_vmax.h" + +#include +#include +#include +#include +#include +#include + +#include "../opengametools/src/ogt_vox.h" + +// Only define implementation once to avoid redefinition errors +#ifndef OGT_VOXEL_MESHIFY_IMPLEMENTATION +#define OGT_VOXEL_MESHIFY_IMPLEMENTATION +#endif +#include "../opengametools/src/ogt_voxel_meshify.h" + +namespace oom { + namespace ogt { + + ogt_vox_model* convert_voxelsoftype_to_ogt_vox(const std::vector& voxelsOfType) ; + void free_ogt_vox_model(ogt_vox_model* model) ; + static void* voxel_meshify_malloc(size_t size, void* user_data) ; + static void voxel_meshify_free(void* ptr, void* user_data) ; + + + // Convert a vector of VmaxVoxel to an ogt_vox_model + // Note: The returned ogt_vox_model must be freed using ogt_vox_free when no longer needed + ogt_vox_model* convert_voxelsoftype_to_ogt_vox(const std::vector& voxelsOfType) { + // Find the maximum dimensions from the voxels + uint32_t size_x = 0; + uint32_t size_y = 0; + uint32_t size_z = 0; + + // WARNING must add 1 to each dimension + // because voxel coordinates are 0-based + for (const auto& voxel : voxelsOfType) { + size_x = std::max(size_x, static_cast(voxel.x)+1); // this seems wasteful + size_y = std::max(size_y, static_cast(voxel.y)+1); + size_z = std::max(size_z, static_cast(voxel.z)+1); + } + + // Add some safety checks + // This is a dense voxel model, so we need to make sure it's not too large + // todo use a sparse storage like morton + if (size_x > 256 || size_y > 256 || size_z > 256) { + std::cout << "Warning: Model dimensions exceed 256 limit. Clamping to 256." << std::endl; + size_x = std::min(size_x, 256u); + size_y = std::min(size_y, 256u); + size_z = std::min(size_z, 256u); + } + if (size_x == 0 || size_y == 0 || size_z == 0) { + std::cout << "Error: Model has zero dimensions. Setting minimum size of 1x1x1." << std::endl; + size_x = std::max(size_x, 1u); + size_y = std::max(size_y, 1u); + size_z = std::max(size_z, 1u); + } + + // Create the voxel data array (initialized to 0, which means empty in ogt_vox) + size_t voxel_count = size_x * size_y * size_z; + uint8_t* voxel_data = (uint8_t*)ogt_vox_malloc(voxel_count); + if (!voxel_data) { + std::cout << "Error: Failed to allocate memory for voxel data" << std::endl; + return nullptr; + } + memset(voxel_data, 0, voxel_count); // Initialize all to 0 (empty) + + // Fill the voxel data array with color indices + int voxel_count_populated = 0; + + // Loop through the vector of voxels directly + for (const auto& voxel : voxelsOfType) { + // Get the coordinates and palette + uint32_t x = voxel.x; + uint32_t y = voxel.y; + uint32_t z = voxel.z; + + // Skip voxels outside our valid range + if (x >= size_x || y >= size_y || z >= size_z) + continue; + + // Calculate the index in the 1D array + size_t index = x + (y * size_x) + (z * size_x * size_y); + + if (index < voxel_count) { + uint8_t palette_index = 0; // hardcoded for now + if (palette_index == 0) palette_index = 1; // If palette is 0, use 1 instead to make it visible + voxel_data[index] = palette_index; + voxel_count_populated++; + } + } + + // Create the model + ogt_vox_model* model = (ogt_vox_model*)ogt_vox_malloc(sizeof(ogt_vox_model)); + if (!model) { + std::cout << "Error: Failed to allocate memory for model" << std::endl; + ogt_vox_free(voxel_data); + return nullptr; + } + + model->size_x = size_x; + model->size_y = size_y; + model->size_z = size_z; + model->voxel_data = voxel_data; + + // Calculate a simple hash for the voxel data + uint32_t hash = 0; + for (size_t i = 0; i < voxel_count; i++) { + hash = hash * 65599 + voxel_data[i]; + } + model->voxel_hash = hash; + + return model; + } + + // Free resources allocated for an ogt_vox_model created by convert_vmax_to_ogt_vox + void free_ogt_vox_model(ogt_vox_model* model) { + if (model) { + if (model->voxel_data) { + ogt_vox_free((void*)model->voxel_data); + } + ogt_vox_free(model); + } + } + + // Free resources allocated for an ogt_vox_scene created by create_ogt_vox_scene_from_vmax + /*void free_ogt_vox_scene(ogt_vox_scene* scene) { + if (scene) { + // Free each model + for (uint32_t i = 0; i < scene->num_models; i++) { + free_ogt_vox_model((ogt_vox_model*)scene->models[i]); + } + + // Free pointers + if (scene->models) ogt_vox_free((void*)scene->models); + if (scene->instances) ogt_vox_free((void*)scene->instances); + if (scene->layers) ogt_vox_free((void*)scene->layers); + + // Free the scene itself + ogt_vox_free(scene); + } + } + */ + + // Custom allocator functions for ogt_voxel_meshify + static void* voxel_meshify_malloc(size_t size, void* user_data) { + return malloc(size); + } + + static void voxel_meshify_free(void* ptr, void* user_data) { + free(ptr); + } + } +} \ No newline at end of file diff --git a/oom_voxel_vmax.h b/oom_voxel_vmax.h new file mode 100644 index 0000000..57e4abc --- /dev/null +++ b/oom_voxel_vmax.h @@ -0,0 +1,991 @@ +#pragma once + +// This is a set of common oomer utilities for Vmax models +// Will avoid using bella_sdk + + +// Standard C++ library includes - these provide essential functionality +#include // For key-value pair data structures (maps) +#include // For set data structure +#include // For dynamic arrays (vectors) +#include // For std::string +#include // For fixed-size integer types (uint8_t, uint32_t, etc.) +#include // For file operations (reading/writing files) +#include // For input/output operations (cout, cin, etc.) +#include // For file system operations (directory handling, path manipulation) + +#include "../lzfse/src/lzfse.h" +#include "../libplist/include/plist/plist.h" // Library for handling Apple property list files +#include "thirdparty/json.hpp" + +using json = nlohmann::json; + +// Define STB_IMAGE_IMPLEMENTATION before including to create the implementation +#define STB_IMAGE_IMPLEMENTATION +#include "thirdparty/stb_image.h" // STB Image library + +namespace oom { + namespace vmax { + //Forward declarations + struct VmaxMatrix4x4; + VmaxMatrix4x4 axisAngleToMatrix4x4(double ax, double ay, double az, double angle); + VmaxMatrix4x4 combineVmaxTransforms(double rotx, double roty, double rotz, double rota, double posx, double posy, double posz, double scalex, double scaley, double scalez); + struct VmaxRGBA; + std::vector read256x1PaletteFromPNG(const std::string& filename); + struct VmaxVoxel; + inline uint32_t compactBits(uint32_t n); + inline void decodeMorton3DOptimized(uint32_t morton, uint32_t& x, uint32_t& y, uint32_t& z); + struct VmaxMaterial; + struct VmaxVoxelGrid; + struct VmaxModel; + inline std::array getVmaxMaterials(plist_t pnodPalettePlist); + inline std::vector decodeVoxels(const std::vector& dsData, int mortonOffset, uint16_t chunkID); + struct VmaxChunkInfo; + plist_t getNestedPlistNode(plist_t plist_root, const std::vector& path); + VmaxChunkInfo vmaxChunkInfo(const plist_t& plist_snapshot_dict_item); + std::vector vmaxVoxelInfo(plist_t& plist_datastream, uint64_t chunkID, uint64_t minMorton); + inline plist_t readPlist(const std::string& inStrPlist, std::string outStrPlist, bool decompress); + inline plist_t readPlist(const std::string& inStrPlist, bool decompress); + struct JsonModelInfo; + struct JsonGroupInfo; + class JsonVmaxSceneParser; + + // Structure to represent a 4x4 matrix for 3D transformations + // The matrix is stored as a 2D array where m[i][j] represents row i, column j + struct VmaxMatrix4x4 { + double m[4][4]; + // Constructor: Creates an identity matrix (1's on diagonal, 0's elsewhere) + VmaxMatrix4x4() { + for(int i = 0; i < 4; i++) { + for(int j = 0; j < 4; j++) { + m[i][j] = (i == j) ? 1.0 : 0.0; // 1.0 on diagonal, 0.0 elsewhere + } + } + } + + // Matrix multiplication operator to combine transformations + // Returns: A new matrix that represents the combined transformation + VmaxMatrix4x4 operator*(const VmaxMatrix4x4& other) const { + VmaxMatrix4x4 result; + // Perform matrix multiplication + for(int i = 0; i < 4; i++) { + for(int j = 0; j < 4; j++) { + result.m[i][j] = 0.0; + for(int k = 0; k < 4; k++) { + result.m[i][j] += m[i][k] * other.m[k][j]; + } + } + } + + return result; + } + + // Helper function to create a translation matrix + static VmaxMatrix4x4 createTranslation(double x, double y, double z) { + VmaxMatrix4x4 result; + result.m[3][0] = x; // Translation in X (bottom row) + result.m[3][1] = y; // Translation in Y (bottom row) + result.m[3][2] = z; // Translation in Z (bottom row) + return result; + } + + // Helper function to create a scale matrix + static VmaxMatrix4x4 createScale(double x, double y, double z) { + VmaxMatrix4x4 result; + result.m[0][0] = x; // Scale in X + result.m[1][1] = y; // Scale in Y + result.m[2][2] = z; // Scale in Z + return result; + } + }; + + // Converts axis-angle rotation to a 4x4 rotation matrix + // Parameters: + // ax, ay, az: The axis vector to rotate around (doesn't need to be normalized) + // angle: The angle to rotate by (in radians) + // Returns: A 4x4 rotation matrix that can be used to transform vectors + VmaxMatrix4x4 axisAngleToMatrix4x4(double ax, double ay, double az, double angle) { + // Step 1: Normalize the axis vector to make it a unit vector + // This is required for the rotation formula to work correctly + double length = sqrt(ax*ax + ay*ay + az*az); + if (length != 0) { + ax /= length; + ay /= length; + az /= length; + } + + // Step 2: Calculate trigonometric values needed for the rotation + double s = sin(angle); // sine of angle + double c = cos(angle); // cosine of angle + double t = 1.0 - c; // 1 - cos(angle), used in formula + + // Step 3: Create rotation matrix using Rodrigues' rotation formula + // This formula converts an axis-angle rotation into a 3x3 matrix + // We'll embed it in the upper-left corner of our 4x4 matrix + VmaxMatrix4x4 result; + + // First row of rotation matrix (upper-left 3x3 portion) + result.m[0][0] = t*ax*ax + c; // First column + result.m[0][1] = t*ax*ay + s*az; // Second column (changed sign) + result.m[0][2] = t*ax*az - s*ay; // Third column (changed sign) + + // Second row of rotation matrix + result.m[1][0] = t*ax*ay - s*az; // First column (changed sign) + result.m[1][1] = t*ay*ay + c; // Second column + result.m[1][2] = t*ay*az + s*ax; // Third column (changed sign) + + // Third row of rotation matrix + result.m[2][0] = t*ax*az + s*ay; // First column (changed sign) + result.m[2][1] = t*ay*az - s*ax; // Second column (changed sign) + result.m[2][2] = t*az*az + c; // Third column + + // Fourth row and column remain unchanged (0,0,0,1) + // This is already set by the constructor + + return result; + } + + // Combine a rotation, translation, and scale into a single 4x4 matrix + // Parameters: + // rotx, roty, rotz: The axis vector to rotate around (doesn't need to be normalized) + // rota: The angle to rotate by (in radians) + // posx, posy, posz: The position to translate to + // scalex, scaley, scalez: The scale to apply to the object + // Returns: A 4x4 matrix that represents the combined transformation + VmaxMatrix4x4 combineVmaxTransforms(double rotx, double roty, double rotz, double rota, double posx, double posy, double posz, double scalex, double scaley, double scalez) { + VmaxMatrix4x4 rotMat4 = axisAngleToMatrix4x4(rotx, + roty, + rotz, + rota); + VmaxMatrix4x4 transMat4 = VmaxMatrix4x4(); + transMat4 = transMat4.createTranslation(posx, + posy, + posz); + VmaxMatrix4x4 scaleMat4 = VmaxMatrix4x4(); + scaleMat4 = scaleMat4.createScale(scalex, + scaley, + scalez); + VmaxMatrix4x4 resultMat4 = scaleMat4 * rotMat4 * transMat4; + return resultMat4; + } + + + struct VmaxRGBA { + uint8_t r, g, b, a; + }; + + // Read a 256x1 PNG file and return a vector of VmaxRGBA colors + std::vector read256x1PaletteFromPNG(const std::string& filename) { + int width, height, channels; + // Load the image with 4 desired channels (RGBA) + unsigned char* data = stbi_load(filename.c_str(), &width, &height, &channels, 4); + + if (!data) { + std::cerr << "Error loading PNG file: " << filename << std::endl; + return {}; + } + // Make sure the image is 256x1 as expected + if (width != 256 || height != 1) { + std::cerr << "Warning: Expected a 256x1 image, but got " << width << "x" << height << std::endl; + } + // Create our palette array + std::vector palette; + // Read each pixel (each pixel is 4 bytes - RGBA) + for (int i = 0; i < width; i++) { + VmaxRGBA color; + color.r = data[i * 4]; + color.g = data[i * 4 + 1]; + color.b = data[i * 4 + 2]; + color.a = data[i * 4 + 3]; + palette.push_back(color); + } + stbi_image_free(data); // Free the image data + return palette; + } + + // Standard useful voxel structure, maps easily to VoxelMax's voxel structure and probably MagicaVoxel's + // We are using this to unpack a chunked voxel into a simple giant voxel + // using a uint8_t saves memory over a uint32_t and both VM and MV models are 256x256x256 + // The world itself can be larger, see scene.json + // Helper struct because in VmaxModel we use array of arrays to store material and color + // Allowing us to group voxels by material and color + struct VmaxVoxel { + uint8_t x, y, z; + uint8_t material; // material value 0-7 + uint8_t palette; // Color palette mapping index 0-255, search palette1.png + uint16_t chunkID; // Chunk ID 0-511 8x8x8 is a morton code + uint16_t minMorton; // morton encoded offset from chunk origin 0-32767 32x32x32, decoded value is added to voxel x y z + // Constructor + VmaxVoxel( uint8_t _x, + uint8_t _y, + uint8_t _z, + uint8_t _material, + uint8_t _palette, + uint16_t _chunkID, + uint16_t _minMorton) + : x(_x), y(_y), z(_z), material(_material), palette(_palette), chunkID(_chunkID), minMorton(_minMorton) { + } + }; + + inline uint32_t compactBits(uint32_t n) { + // For a 32-bit integer in C++ + n &= 0x49249249; // Keep only every 3rd bit + n = (n ^ (n >> 2)) & 0xc30c30c3; // Merge groups + n = (n ^ (n >> 4)) & 0x0f00f00f; // Continue merging + n = (n ^ (n >> 8)) & 0x00ff00ff; // Merge larger groups + n = (n ^ (n >> 16)) & 0x0000ffff; // Final merge + return n; + } + + // Optimized function to decode Morton code using parallel bit manipulation + inline void decodeMorton3DOptimized(uint32_t morton, uint32_t& x, uint32_t& y, uint32_t& z) { + x = compactBits(morton); + y = compactBits(morton >> 1); + z = compactBits(morton >> 2); + } + + struct VmaxMaterial { + std::string materialName; + double transmission; + double roughness; + double metalness; + double emission; + bool enableShadows; + bool dielectric; // future use + bool volumetric; // future use + }; + + struct VmaxVoxelGrid { + // dimensions of the voxel grid + uint32_t size_x, size_y, size_z; + // voxel data + uint8_t* voxel_data; + }; + + + // Create a structure to represent a model with its voxels with helper functions + // since the xyz coords are at the voxel level, we need an accessor to walk it sequentially + // maybe I create a new structure called VmaxVoxelGrid + struct VmaxModel { + // Model identifier or name + std::string vmaxbFileName; // file name is used like a key + + // Voxels organized by material and color + // First dimension: material (0-7) + // Second dimension: color (1-255, index 0 unused since color 0 means no voxel) + std::vector voxels[8][256]; + + // EDUCATIONAL NOTES ON DUAL DATA STRUCTURES FOR VOXELS: + // ---------------------------------------------------- + // This class uses two different data structures to store the same voxel data, + // each optimized for different access patterns: + // + // 1. voxels[8][256] - Organizes voxels by material and color + // - Efficient for queries like "give me all voxels of material 2, color 37" + // - Poor for spatial queries like "what's at position (x,y,z)?" + // + // 2. voxelsSpatial - Organizes voxels by their spatial position + // - Efficient for spatial queries like "what's at position (x,y,z)?" + // - Uses a map for memory efficiency with sparse data + // + // Tradeoffs: + // - Memory: We use more memory by storing voxels twice + // - Performance: We get optimal performance for both types of queries + // - Complexity: We need to maintain both structures in sync + // + // For novice programmers: This is a common technique in game/graphics programming + // where performance is critical. We're trading some extra memory for faster access. + + // Using a map for sparse 3D data instead of a fixed-size 3D array + // Key format: (x << 16) | (y << 8) | z + // This approach is memory-efficient for sparse data (mostly empty space) + // A 3D array would need 256³ = 16.7 million elements even if most are empty! + + + // todo we need to do morton decoing using chunkid to get x,y,z + std::map> voxelsSpatial; + + // Each model has local 0-7 materials + std::array materials; + // Each model has local colors + std::array colors; + uint8_t maxx=0, maxy=0, maxz=0; + + // Constructor + VmaxModel(const std::string& modelName) : vmaxbFileName(modelName) { + } + + // Helper function to create a key for the voxelsSpatial map + static uint32_t makeVoxelKey(uint8_t x, uint8_t y, uint8_t z) { + return (static_cast(x) << 16) | (static_cast(y) << 8) | static_cast(z); + } + + // Add a voxel to this model + // EDUCATIONAL NOTE: + // Notice how we maintain BOTH data structures when adding a voxel. + // This is a key practice when using dual data structures - keep them in sync + // by updating both whenever data changes. + void addVoxel(int x, int y, int z, int material, int color, int chunk, int chunkMin) { + + //todo add chunk offset to x,y,z + //chunkMin is offset withing each chunk used earlier + uint32_t _tempx, _tempy, _tempz; + decodeMorton3DOptimized(chunk, _tempx, _tempy, _tempz); // index IS the morton code + int worldOffsetX = _tempx * 24; // get world loc within 256x256x256 grid + int worldOffsetY = _tempy * 24; // Don't know why we need to multiply by 24 + int worldOffsetZ = _tempz * 24; // use to be 32 + x += worldOffsetX; + y += worldOffsetY; + z += worldOffsetZ; + + + if (material >= 0 && material < 8 && color > 0 && color < 256) { + voxels[material][color].emplace_back(x, y, z, material, color, chunk, chunkMin); + + // Add to voxelsSpatial using the map approach + uint32_t key = makeVoxelKey(x, y, z); + //todo add chunk offset to x,y,z + voxelsSpatial[key].emplace_back(x, y, z, material, color, chunk, chunkMin); + + if (x > maxx) maxx = x; + if (y > maxy) maxy = y; + if (z > maxz) maxz = z; + } + } + + // Get voxels at a specific position + // EDUCATIONAL NOTE: + // This method demonstrates the power of our spatial index. + // Time complexity: O(log n) where n is the number of occupied positions. + // Without voxelsSpatial, we would need to scan through ALL voxels (potentially thousands) + // to find those at a specific position, which would be O(total_voxel_count). + const std::vector& getVoxelsAt(uint8_t x, uint8_t y, uint8_t z) const { + uint32_t key = makeVoxelKey(x, y, z); + auto it = voxelsSpatial.find(key); + if (it != voxelsSpatial.end()) { + return it->second; + } + static const std::vector empty; + return empty; + } + + // Check if there are voxels at a specific position + // Another spatial query that benefits from our map-based structure + bool hasVoxelsAt(uint8_t x, uint8_t y, uint8_t z) const { + uint32_t key = makeVoxelKey(x, y, z); + auto it = voxelsSpatial.find(key); + return (it != voxelsSpatial.end() && !it->second.empty()); + } + + // Add materials to this model + void addMaterials(const std::array newMaterials) { + materials = newMaterials; + } + + // Add colors to this model + void addColors(const std::array newColors) { + colors = newColors; + } + + // Get all voxels of a specific material and color + const std::vector& getVoxels(int material, int color) const { + if (material >= 0 && material < 8 && color > 0 && color < 256) { + return voxels[material][color]; + } + static std::vector empty; + return empty; + } + + // Get total voxel count for this model + size_t getTotalVoxelCount() const { + size_t count = 0; + for (int m = 0; m < 8; m++) { + for (int c = 1; c < 256; c++) { // Skip index 0 + count += voxels[m][c].size(); + } + } + return count; + } + + // Get a map of used materials and their associated colors + std::map> getUsedMaterialsAndColors() const { + std::map> result; + + // Iterate through fixed size arrays - we know it's 8 materials and 256 colors + for (int material = 0; material < 8; material++) { + for (int color = 1; color < 256; color++) { // Skip index 0 as it means no voxel + if (!voxels[material][color].empty()) { + result[material].insert(color); + } + } + } + + return result; + } + }; + + inline std::array getVmaxMaterials(plist_t pnodPalettePlist) { + // Directly access the materials array + std::array vmaxMaterials; + plist_t materialsNode = plist_dict_get_item(pnodPalettePlist, "materials"); + if (materialsNode && plist_get_node_type(materialsNode) == PLIST_ARRAY) { + uint32_t materialsCount = plist_array_get_size(materialsNode); + //std::cout << "Found materials array with " << materialsCount << " items" << std::endl; + + // Process each material + for (uint32_t i = 0; i < materialsCount; i++) { + plist_t materialNode = plist_array_get_item(materialsNode, i); + if (materialNode && plist_get_node_type(materialNode) == PLIST_DICT) { + plist_t nameNode = plist_dict_get_item(materialNode, "mi"); + std::string vmaxMaterialName; + double vmaxTransmission = 0.0; // Declare outside the if block + double vmaxEmission = 0.0; // Declare outside the if block + double vmaxRoughness = 0.0; // Declare outside the if block + double vmaxMetalness = 0.0; // Declare outside the if block + uint8_t vmaxEnableShadows = 1; + + if (nameNode) { + char* rawName = nullptr; + plist_get_string_val(nameNode, &rawName); + vmaxMaterialName = rawName ? rawName : "unnamed"; + free(rawName); + } + plist_t pnodTc = plist_dict_get_item(materialNode, "tc"); + if (pnodTc) { plist_get_real_val(pnodTc, &vmaxTransmission); } + plist_t pnodEmission = plist_dict_get_item(materialNode, "sic"); + if (pnodEmission) { plist_get_real_val(pnodEmission, &vmaxEmission); } + plist_t pnodRoughness = plist_dict_get_item(materialNode, "rc"); + if (pnodRoughness) { plist_get_real_val(pnodRoughness, &vmaxRoughness); } + plist_t pnodMetalness = plist_dict_get_item(materialNode, "mc"); + if (pnodMetalness) { plist_get_real_val(pnodMetalness, &vmaxMetalness); } + plist_t pnodEnableShadow = plist_dict_get_item(materialNode, "sh"); + if (pnodEnableShadow) { plist_get_bool_val(pnodEnableShadow, &vmaxEnableShadows); } + + vmaxMaterials[i] = { + vmaxMaterialName, + vmaxTransmission, + vmaxRoughness, + vmaxMetalness, + vmaxEmission, + static_cast(vmaxEnableShadows), + false, // dielectric + false, // volumetric + }; + } + } + } else { + std::cout << "No materials array found or invalid type" << std::endl; + } + #ifdef _DEBUG23 + for (const auto& material : vmaxMaterials) { + std::cout << "Material: " << material.materialName << std::endl; + std::cout << " Transmission: " << material.transmission << std::endl; + std::cout << " Emission: " << material.emission << std::endl; + std::cout << " Roughness: " << material.roughness << std::endl; + std::cout << " Metalness: " << material.metalness << std::endl; + std::cout << " Enable Shadows: " << material.enableShadows << std::endl; + std::cout << " Dielectric: " << material.dielectric << std::endl; + std::cout << " Volumetric: " << material.volumetric << std::endl; + } + #endif + return vmaxMaterials; + } + + + /** + * Decodes a voxel's material index and palette index from the ds data stream + * + * @param dsData The raw ds data stream containing material and palette index pairs + * @param mortonOffset offset to apply to the morton code + * @param chunkID chunk ID + * @return vector of VmaxVoxel structures containing the voxels local to a snapshot + */ + inline std::vector decodeVoxels(const std::vector& dsData, int mortonOffset, uint16_t chunkID) { + std::vector voxels; + uint8_t material; + uint8_t color; + for (int i = 0; i < dsData.size() - 1; i += 2) { + material = dsData[i]; // also known as a layer color + color = dsData[i + 1]; + uint32_t _tempx, _tempy, _tempz; + decodeMorton3DOptimized(i/2 + mortonOffset, + _tempx, + _tempy, + _tempz); // index IS the morton code + if (color != 0) { + VmaxVoxel voxel = { + static_cast(_tempx), + static_cast(_tempy), + static_cast(_tempz), + material, + color, + chunkID, // todo is wasteful to pass chunkID? + static_cast(mortonOffset) + }; + voxels.push_back(voxel); + } + } + return voxels; + } + + //libplist reads in 64 bits + struct VmaxChunkInfo { + int64_t id; // was uint but will use -1 to indicate bad chunk + uint64_t type; + uint64_t mortoncode; + uint32_t voxelOffsetX; + uint32_t voxelOffsetY; + uint32_t voxelOffsetZ; + }; + + // Helper function to get a nested dictionary item + // @param root: root dictionary + // @param path: path to the item + // @return: item + // Using a vector of strings for dynamic path length + plist_t getNestedPlistNode(plist_t plist_root, const std::vector& path) { + plist_t current = plist_root; + for (const auto& key : path) { + if (!current) return nullptr; + current = plist_dict_get_item(current, key.c_str()); + } + return current; + } + + // Need morton code in snapshot before we can decode voxels + // @param an individual chunk: plist_t of a snapshot dict->item->s + // @return Chunk level info needed to decode voxels + VmaxChunkInfo vmaxChunkInfo(const plist_t& plist_snapshot_dict_item) { + uint64_t id; + uint64_t type; + uint64_t mortoncode; + uint32_t voxelOffsetX, voxelOffsetY, voxelOffsetZ; + try { + plist_t plist_snapshot = getNestedPlistNode(plist_snapshot_dict_item, {"s"}); + + // vmax file format must guarantee the existence + // s.st.min + // s.id.t + // s.id.c + plist_t plist_min = getNestedPlistNode(plist_snapshot, {"st", "min"}); + plist_t plist_min_val = plist_array_get_item(plist_min, 3); + plist_get_uint_val(plist_min_val, &mortoncode); + + // convert to 32x32x32 chunk offset + decodeMorton3DOptimized(mortoncode, + voxelOffsetX, + voxelOffsetY, + voxelOffsetZ); + + plist_t plist_type = getNestedPlistNode(plist_snapshot, {"id","t"}); + plist_get_uint_val(plist_type, &type); + plist_t plist_chunk = getNestedPlistNode(plist_snapshot, {"id","c"}); + plist_get_uint_val(plist_chunk, &id); + + return VmaxChunkInfo{static_cast(id), + type, + mortoncode, + voxelOffsetX, + voxelOffsetY, + voxelOffsetZ}; + } catch (std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + // Just continue to next snapshot + // This bypass might mean we miss useful snapshots + } + return VmaxChunkInfo{-1, 0, 0, 0, 0, 0}; + } + + + // Right after we get VmaxChunkInfo, we can get the voxels because we need morton chunk offset + // @param pnodSnaphot: plist_t of a snapshot + // @return vector of VmaxVoxel + //std::vector getVmaxSnapshot(plist_t& pnod_each_snapshot) { + std::vector vmaxVoxelInfo(plist_t& plist_datastream, uint64_t chunkID, uint64_t minMorton) { + std::vector voxelsArray; + try { + + // Extract the binary data + char* data = nullptr; + uint64_t length = 0; + plist_get_data_val(plist_datastream, &data, &length); + auto foo = std::vector(data, data + length) ; + std::vector allModelVoxels = decodeVoxels(std::vector(data, data + length), minMorton, chunkID); + + //std::cout << "allModelVoxels: " << allModelVoxels.size() << std::endl; + + uint32_t model_8x8x8_x, model_8x8x8_y, model_8x8x8_z; + decodeMorton3DOptimized(chunkID, + model_8x8x8_x, + model_8x8x8_y, + model_8x8x8_z); // index IS the morton code + int model_256x256x256_x = model_8x8x8_x * 8; // convert to model space + int model_256x256x256_y = model_8x8x8_y * 8; + int model_256x256x256_z = model_8x8x8_z * 8; + + for (const VmaxVoxel& eachVmaxVoxel : allModelVoxels) { + auto [ chunk_32x32x32_x, + chunk_32x32x32_y, + chunk_32x32x32_z, + materialMap, + colorMap, + chunkID, + minMorton] = eachVmaxVoxel; + + int voxel_256x256x256_x = model_256x256x256_x + chunk_32x32x32_x; + int voxel_256x256x256_y = model_256x256x256_y + chunk_32x32x32_y; + int voxel_256x256x256_z = model_256x256x256_z + chunk_32x32x32_z; + + auto one_voxel = VmaxVoxel(voxel_256x256x256_x, + voxel_256x256x256_y, + voxel_256x256x256_z, + materialMap, + colorMap, + chunkID, + minMorton); + voxelsArray.push_back(one_voxel); + } + return voxelsArray; + } catch (std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + // Just continue to next snapshot + // This bypass might mean we miss useful snapshots + } + return voxelsArray; // empty return + } + + /** + * Read a binary plist file and return a plist node. + * if the file is lzfse compressed, decompress it and parse the decompressed data + * + * Memory Management: + * - Creates temporary buffers for decompression + * - Handles buffer resizing if needed + * - Returns a plist node that must be freed by the caller + * + * @param lzfseFullName Path to the LZFSE file + * @param plistName Name of the plist file to write (optional) + * @return plist_t A pointer to the root node of the parsed plist, or nullptr if failed + */ + // read binary lzfse compressed/uncompressed file + inline plist_t readPlist(const std::string& inStrPlist, std::string outStrPlist, bool decompress) { + // Get file size using std::filesystem + size_t rawFileSize = std::filesystem::file_size(inStrPlist); + std::vector rawBytes(rawFileSize); + std::vector outBuffer; + size_t decodedSize = 0; + if (decompress) { // files are either lzfse compressed or uncompressed + std::ifstream rawBytesFile(inStrPlist, std::ios::binary); + if (!rawBytesFile.is_open()) { + std::cerr << "Error: Could not open plist file: " << inStrPlist << std::endl; + throw std::runtime_error("Error message"); // [learned] no need to return nullptr + } + + rawBytesFile.read(reinterpret_cast(rawBytes.data()), rawFileSize); + rawBytesFile.close(); + // Start with output buffer 4x input size (compression ratio is usually < 4) + size_t outAllocatedSize = rawFileSize * 8; + // vector automatically manages memory allocation/deallocation + //std::vector outBuffer(outAllocatedSize); + outBuffer.resize(outAllocatedSize); // Resize preserves existing content + + // LZFSE needs a scratch buffer for its internal operations + // Get the required size and allocate it + size_t scratchSize = lzfse_decode_scratch_size(); + std::vector scratch(scratchSize); + + // Decompress the data, growing the output buffer if needed + //size_t decodedSize = 0; + while (true) { + // Try to decompress with current buffer size + decodedSize = lzfse_decode_buffer( + outBuffer.data(), // Where to store decompressed data + outAllocatedSize, // Size of output buffer + rawBytes.data(), // Source of compressed data + rawBytes.size(), // Size of compressed data + scratch.data()); // Scratch space for LZFSE + + // Check if we need a larger buffer: + // - decodedSize == 0 indicates failure + // - decodedSize == outAllocatedSize might mean buffer was too small + if (decodedSize == 0 || decodedSize == outAllocatedSize) { + outAllocatedSize *= 2; // Double the buffer size + outBuffer.resize(outAllocatedSize); // Resize preserves existing content + continue; // Try again with larger buffer + } + break; // Successfully decompressed + } + + // Check if decompression failed + if (decodedSize == 0) { + std::cerr << "Failed to decompress data" << std::endl; + return nullptr; + } + + // If requested, write the decompressed data to a file + if (!outStrPlist.empty()) { + std::ofstream outFile(outStrPlist, std::ios::binary); + if (outFile) { + outFile.write(reinterpret_cast(outBuffer.data()), decodedSize); + std::cout << "Wrote decompressed plist to: " << outStrPlist << std::endl; + } else { + std::cerr << "Failed to write plist to file: " << outStrPlist << std::endl; + } + } + } else { + outBuffer.resize(rawFileSize); + // if the file is not compressed, just read the raw bytes + std::ifstream rawBytesFile(inStrPlist, std::ios::binary); + if (!rawBytesFile.is_open()) { + std::cerr << "Error: Could not open plist file: " << inStrPlist << std::endl; + throw std::runtime_error("Error message"); // [learned] no need to return nullptr + } + rawBytesFile.read(reinterpret_cast(outBuffer.data()), rawFileSize); + rawBytesFile.close(); + decodedSize = rawFileSize; // decodedSize is the same as rawFileSize when data is not compressed + + + } // outBuffer now contains the raw bytes of the plist file + + // Parse the decompressed data as a plist + plist_t root_node = nullptr; + plist_format_t format; // Will store the format of the plist (binary, xml, etc.) + + // Convert the raw decompressed data into a plist structure + plist_err_t err = plist_from_memory( + reinterpret_cast(outBuffer.data()), // Cast uint8_t* to char* + static_cast(decodedSize), // Cast size_t to uint32_t + &root_node, // Where to store the parsed plist + &format); // Where to store the format + + // Check if parsing succeeded + if (err != PLIST_ERR_SUCCESS) { + std::cerr << "Failed to parse plist data" << std::endl; + return nullptr; + } + + return root_node; // Caller is responsible for calling plist_free() + } + + // Overload for when you only want to specify inStrPlist and decompress + inline plist_t readPlist(const std::string& inStrPlist, bool decompress) { + return readPlist(inStrPlist, "", decompress); + } + + // Structure to hold object/model information from VoxelMax's scene.json + struct JsonModelInfo { + std::string id; + std::string parentId; + std::string name; + std::string dataFile; // The .vmaxb file + std::string paletteFile; // The palette PNG + std::string historyFile; // The history file, not sure what this is + + // Transform information + std::vector position; // t_p + std::vector rotation; // t_r + std::vector scale; // t_s + + // Extent information + std::vector extentCenter; // e_c + std::vector extentMin; // e_mi + std::vector extentMax; // e_ma + }; + + // Structure to hold group information from VoxelMax's scene.json + struct JsonGroupInfo { + std::string id; + std::string name; + std::vector position; + std::vector rotation; + std::vector scale; + std::vector extentCenter; + std::vector extentMin; + std::vector extentMax; + bool selected = false; + std::string parentId; + }; + + // Class to parse VoxelMax's scene.json + class JsonVmaxSceneParser { + private: + std::map models; // a vmax model can also be called a content + std::map groups; + + public: + bool parseScene(const std::string& jsonFilePath) { + try { + // Read the JSON file + std::ifstream file(jsonFilePath); + if (!file.is_open()) { + std::cerr << "Failed to open file: " << jsonFilePath << std::endl; + return false; + } + + // Parse the JSON + json sceneData; + file >> sceneData; + file.close(); + + // Parse groups + if (sceneData.contains("groups") && sceneData["groups"].is_array()) { + for (const auto& group : sceneData["groups"]) { + JsonGroupInfo groupInfo; + + // Extract group information + if (group.contains("id")) groupInfo.id = group["id"]; + if (group.contains("name")) groupInfo.name = group["name"]; + + // Extract transform data + if (group.contains("t_p") && group["t_p"].is_array()) + groupInfo.position = group["t_p"].get>(); + + if (group.contains("t_r") && group["t_r"].is_array()) + groupInfo.rotation = group["t_r"].get>(); + + if (group.contains("t_s") && group["t_s"].is_array()) + groupInfo.scale = group["t_s"].get>(); + + // Extract extent data + if (group.contains("e_c") && group["e_c"].is_array()) + groupInfo.extentCenter = group["e_c"].get>(); + + if (group.contains("e_mi") && group["e_mi"].is_array()) + groupInfo.extentMin = group["e_mi"].get>(); + + if (group.contains("e_ma") && group["e_ma"].is_array()) + groupInfo.extentMax = group["e_ma"].get>(); + + // Check if selected + if (group.contains("s")) groupInfo.selected = group["s"].get(); + + if (group.contains("pid")) groupInfo.parentId = group["pid"]; + // Store the group + groups[groupInfo.id] = groupInfo; + } + } + + // Parse objects (models) , objects are instances of models + // Maybe rename this objects, will leave for now + if (sceneData.contains("objects") && sceneData["objects"].is_array()) { + for (const auto& obj : sceneData["objects"]) { + JsonModelInfo modelInfo; + + // Extract model information + if (obj.contains("id")) modelInfo.id = obj["id"]; + if (obj.contains("pid")) modelInfo.parentId = obj["pid"]; + if (obj.contains("n")) modelInfo.name = obj["n"]; + + // Extract file paths + if (obj.contains("data")) modelInfo.dataFile = obj["data"];// This is the canonical model + if (obj.contains("pal")) modelInfo.paletteFile = obj["pal"]; + if (obj.contains("hist")) modelInfo.historyFile = obj["hist"]; + + // Extract transform data + if (obj.contains("t_p") && obj["t_p"].is_array()) + modelInfo.position = obj["t_p"].get>(); + + if (obj.contains("t_r") && obj["t_r"].is_array()) + modelInfo.rotation = obj["t_r"].get>(); + + if (obj.contains("t_s") && obj["t_s"].is_array()) + modelInfo.scale = obj["t_s"].get>(); + + // Extract extent data + if (obj.contains("e_c") && obj["e_c"].is_array()) + modelInfo.extentCenter = obj["e_c"].get>(); + + if (obj.contains("e_mi") && obj["e_mi"].is_array()) + modelInfo.extentMin = obj["e_mi"].get>(); + + if (obj.contains("e_ma") && obj["e_ma"].is_array()) + modelInfo.extentMax = obj["e_ma"].get>(); + + // Store the model + models[modelInfo.id] = modelInfo; + } + } + + return true; + + } catch (const std::exception& e) { + std::cerr << "Error parsing JSON: " << e.what() << std::endl; + return false; + } + } + + // Get the parsed models + const std::map& getModels() const { + return models; + } + + // Get the parsed groups + const std::map& getGroups() const { + return groups; + } + + /* Groups models by their data file names ie contentsN.vmaxb + * Since we can instance models, we can grab the first one when translating it to Bella + * @return Map where: + * - Key: contentN.vmaxb (string) + * - Value: vector of models using that data file + * Example: + * Input models: {"id1": model1, "id2": model2} where both use "data.file" + * Output: {"data.file": [model1, model2]} + */ + std::map> getModelContentVMaxbMap() const { + std::map> fileMap; + + for (const auto& [id, model] : models) { + fileMap[model.dataFile].push_back(model); + } + + return fileMap; + } + + // Print summary of parsed data + void printSummary() const { + std::cout << "=========== Scene Summary ===========" << std::endl; + std::cout << "Groups: " << groups.size() << std::endl; + std::cout << "Models: " << models.size() << std::endl; + + // Print unique model files + std::map modelFiles; + for (const auto& [id, model] : models) { + modelFiles[model.dataFile]++; + } + + std::cout << "\nModel Files:" << std::endl; + for (const auto& [file, count] : modelFiles) { + std::cout << " " << file << " (used " << count << " times)" << std::endl; + } + + std::cout << "\nGroups:" << std::endl; + for (const auto& [id, group] : groups) { + std::cout << " " << group.name << " (ID: " << id << ")" << std::endl; + if (!group.position.empty()) { + std::cout << " Position: [" + << group.position[0] << ", " + << group.position[1] << ", " + << group.position[2] << "]" << std::endl; + } + } + + std::cout << "\nModels:" << std::endl; + for (const auto& [id, model] : models) { + std::cout << " " << model.name << " (ID: " << id << ")" << std::endl; + std::cout << " Data: " << model.dataFile << std::endl; + std::cout << " Palette: " << model.paletteFile << std::endl; + std::cout << " Parent: " << model.parentId << std::endl; + + if (!model.position.empty()) { + std::cout << " Position: [" + << model.position[0] << ", " + << model.position[1] << ", " + << model.position[2] << "]" << std::endl; + } + } + } + }; + } +} diff --git a/thirdparty/json.hpp b/thirdparty/json.hpp new file mode 100644 index 0000000..8b72ea6 --- /dev/null +++ b/thirdparty/json.hpp @@ -0,0 +1,24765 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1); + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows to call any std function as if (e.g. with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +inline constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval +#include // tuple +#include // char_traits + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& + is_complete_type < + detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template