diff --git a/3dtextures2.bin b/3dtextures2.bin new file mode 100644 index 0000000..a8a775c Binary files /dev/null and b/3dtextures2.bin differ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..ff3cac8 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,4 @@ +cmake_minimum_required(VERSION 3.16) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(i80_controller) diff --git a/DiscWorld11.bin b/DiscWorld11.bin new file mode 100644 index 0000000..36268ac Binary files /dev/null and b/DiscWorld11.bin differ diff --git a/amaze_2_title.png b/amaze_2_title.png new file mode 100644 index 0000000..84887d7 Binary files /dev/null and b/amaze_2_title.png differ diff --git a/dependencies.lock b/dependencies.lock new file mode 100644 index 0000000..866c1b1 --- /dev/null +++ b/dependencies.lock @@ -0,0 +1,10 @@ +dependencies: + idf: + source: + type: idf + version: 5.3.0 +direct_dependencies: +- idf +manifest_hash: 620bb73887c520f756e6770a2a31cc1ad0837429534c5bc6dd432791ad7c3df6 +target: esp32s3 +version: 2.0.0 diff --git a/gameover.png b/gameover.png new file mode 100644 index 0000000..3a431e5 Binary files /dev/null and b/gameover.png differ diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt new file mode 100644 index 0000000..a5aef52 --- /dev/null +++ b/main/CMakeLists.txt @@ -0,0 +1,30 @@ + +idf_component_register( + SRCS + "i80_lcd_main.cpp" + "ShowWorld.cpp" + "ClipBound.cpp" + "CameraWork.cpp" + "CheckTriangles.cpp" + "ShowError.cpp" + "TriangleQueues.cpp" + "wr_gpio.cpp" + "ChunkChooser.cpp" + "RasteriseBox.cpp" + "lcd_setup.c" + "ParseWorld.cpp" + "FindHitFace.cpp" + "TimeTracker.cpp" + "EventManager.cpp" + + INCLUDE_DIRS + "." + "includes" + "World" + REQUIRES esp_partition esp_lcd esp_mm esp_timer + ) + + + + + diff --git a/main/CameraWork.cpp b/main/CameraWork.cpp new file mode 100644 index 0000000..efeaae4 --- /dev/null +++ b/main/CameraWork.cpp @@ -0,0 +1,51 @@ +#include + +#include "geometry.h" +#include "CameraWork.h" + + +void make_camera(const Vec3f direction, const Vec3f cameraPosition, Matrix44f& worldToCamera) +{ + // Build the view matrix as per https://medium.com/@carmencincotti/lets-look-at-magic-lookat-matrices-c77e53ebdf78 + // This has worked with basic geometry functions but converted to glm to ensure that it works with the rest of 3D code + + Vec3f forwardvector = (-direction).normalize(); + + const Vec3f tempup = { 0,1,0 }; + Vec3f rightvector = (tempup.crossProduct(forwardvector)).normalize(); + + Vec3f upvector = (forwardvector.crossProduct(rightvector)).normalize(); + + Vec3f translate; + translate.x = rightvector.dotProduct(cameraPosition); + translate.y = upvector.dotProduct(cameraPosition); + translate.z = forwardvector.dotProduct(cameraPosition); + + Matrix44f LookAt = { + rightvector.x,rightvector.y,rightvector.z,-translate.x, + upvector.x,upvector.y,upvector.z,-translate.y, + forwardvector.x,forwardvector.y,forwardvector.z,-translate.z, + 0,0,0,1 }; + + worldToCamera = LookAt.transposed(); +} // End of make_camera() + +// Make a perspective projection matrix, simplified from glm opensource library +// so that can be used without glm library +void make_perspective( + float const fovy, // must be in radians + float const aspect, + float const zNear, + float const zFar, + Matrix44f& Result +) +{ + float tanHalfFovy = tan(fovy / 2.0f); + + Result[0][0] = 1.0f / (aspect * tanHalfFovy); + Result[1][1] = 1.0f / (tanHalfFovy); + Result[2][2] = -(zFar + zNear) / (zFar - zNear); + Result[2][3] = -1.0f; + Result[3][2] = -(2.0f * zFar * zNear) / (zFar - zNear); +} // End of make_perspective + diff --git a/main/CheckTriangles.cpp b/main/CheckTriangles.cpp new file mode 100644 index 0000000..01ded61 --- /dev/null +++ b/main/CheckTriangles.cpp @@ -0,0 +1,439 @@ +#include +#include + +#include "geometry.h" +#include "globals.h" +#include "structures.h" + +#include "esp_log.h" + +#include "CameraWork.h" +#include "TriangleQueues.h" +#include "ClipBound.h" +#include "CheckTriangles.h" +#include "ChunkChooser.h" + +// A global pingpong flag +extern bool flipped; + +// Transform a given vertex in clip-space [-w,w] to raster-space [0, {w|h}] +constexpr float half_width = g_scWidth/2; +constexpr float half_height = g_scHeight/2; + +#define TO_RASTER(v) Vec4f((half_width * (v.x + v.w)), (half_height * (v.w - v.y)), v.z, v.w) + +#define FOV 60.0f // field of view in degrees, will be compiled into radians + +// If the triangle crosses the view frustrum it will be tiled before rasterisation and +// clearly there's a trade-off as smaller allows more elimination but extended to 1px square it's +// literally back to square one. Needs optimising on a platform and may depend on the world model too. +const unsigned int g_xTile = 8; // Tile size needs to be optimised for screen size +const unsigned int g_yTile = 8; // 8x8 for 128x128 a maybe 32 x 24 for 320x240 + +Rect2D TriBoundBox; +//float farPlane = 100.0f; +const float nearPlane = 0.1f; + +Matrix44f view = { + 1.0f,0.0f,0.0f,0.0f, + 0.0f,1.0f,0.0f,0.0f, + 0.0f,0.0f,1.0f,0.0f, + 0.0f,0.0f,0.0f,1.0f }; + +Matrix44f proj = { + 0.0f,0.0f,0.0f,0.0f, + 0.0f,0.0f,0.0f,0.0f, + 0.0f,0.0f,0.0f,0.0f, + 0.0f,0.0f,0.0f,0.0f }; + +// This is named after Vertex Shader which doesn't feel helpful +// Originally took matrices of position, view and model but in this +// implementation we aren't placing individual models into the world +//return (P * V * Vec4f(pos, 1.0f)); +Vec4f VS(const Vec3f& pos, const Matrix44f& V) +{ + Vec4f result; + V.multVecMatrix(pos, result); // On ESP32 the dspm_mult_f32_aes32() function gives no clear advantage + return result; +} // End of VS + +void ProjectionMatrix() +{ + // Build projection matrix (right-handed sysem) + make_perspective((2.0f * M_PI) * (FOV / 360.0f), ((float)g_scWidth / (float)g_scHeight), nearPlane, farPlane, proj); +} + +float edge_function(const Vec3f a, const Vec3f b, const Vec3f p) +{ + // Vec3f are passed even though Vec2f sufficient to save copying the input + // From https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/rasterization-stage.html + // Simpler than matrix used in main routines, note X and Z are horizontal axes + return (p.x - a.x) * (b.z - a.z) - (p.z - a.z) * (b.x - a.x); +}; // end of edge_function + +float BaseTriangles(const Vec3f eye, const Vec3f direction, const uint32_t this_chunk, const WorldLayout* layo_ptr) +{ + static const char *TAG = "BaseTriangles"; + // Static as if a match is not found the old result is returned + static float this_height = 0.0f; // The ultimate result + float found_height = 0.0f; // The height of the face being tested + float best_height = 0.0f; // The best result so far in the list of faces + + // Various reasons to quit without doing anything more + // Return default height of 0.0f if nothing to check + if (this_chunk == INVALID_CHUNK) return (0.0f); // Quit as it's invalid chunk beyond border, but we did need depth buffer reset perhaps + + if (layo_ptr->TheChunks[this_chunk].face_count == 0) return (0.0f); // Quit as this chunk is empty with zero faces, which is valid? + + // Projection calculation removed as a simple othographic view will be used + const uint16_t* this_list = layo_ptr->TheChunks[this_chunk].faces_ptr; // fetch the list of faces applicable to this chunk + + // Currently there is no knowledge of whether there is more than one triangle beneath eye + // so the height returned simply reflects the last that was hit from the list + for (uint32_t get_face = 0; get_face < layo_ptr->TheChunks[this_chunk].face_count; get_face++) + { + // The chunk list is a subset of all triangles so pull the global index for rendering + uint32_t idx = this_list[get_face]; // Keep a plain idx so code is easier to read in rest of this function + + // Fetch object-space vertices from the vertex buffer indexed by the values in index buffer + const Vec3f v0 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3]]; + const Vec3f v1 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3 + 1]]; + const Vec3f v2 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3 + 2]]; + + // Simple non-homogenous edge functions are used as there is no need to consider issues such as clip space + // One could do a bounding box calculation first but only a benefit if many triangles to check per chunk + float w0 = edge_function(v1, v2, eye); // Signed area of the triangle v1v2p multiplied by 2 + float w1 = edge_function(v2, v0, eye); // Signed area of the triangle v2v0p multiplied by 2 + float w2 = edge_function(v0, v1, eye); // Signed area of the triangle v0v1p multiplied by 2 + + // If point p is inside triangles defined by vertices v0, v1, v2 + if (w0 >= 0 && w1 >= 0 && w2 >= 0) + { + // Eye is over/inside the triangle + + // Do top left rule to avoid being over 2 abutting triangles + // As above, it's a Vec2f operation but we haven't copied the vertices + Vec3f edge0 = v2 - v1; + Vec3f edge1 = v0 - v2; + Vec3f edge2 = v1 - v0; + + bool overlaps = true; + + // If the point is on the edge, test if it is a top or left edge, + // otherwise test if the edge function is positive + overlaps &= (w0 == 0 ? ((edge0.y == 0 && edge0.x > 0) || edge0.y > 0) : (w0 > 0)); + overlaps &= (w1 == 0 ? ((edge1.y == 0 && edge1.x > 0) || edge1.y > 0) : (w1 > 0)); + overlaps &= (w2 == 0 ? ((edge2.y == 0 && edge2.x > 0) || edge2.y > 0) : (w2 > 0)); + + if (overlaps) // Check has passed + { + // The area is only needed if eye is inside the base triangle + float oneoverarea = 1 / (edge_function(v0, v1, v2)); // Area of the triangle multiplied by 2 + // Barycentric coordinates are the areas of the sub-triangles divided by the area of the main triangle + w0 *= oneoverarea; + w1 *= oneoverarea; + w2 *= oneoverarea; + + // Interpolate a height from the triangle's vertices + found_height = w0 * v0.y + w1 * v1.y + w2 * v2.y; + // In a 'bridge' or 'tunnel' there may be more than one face that is projected at the location + // A chosen one must be lower than eye + if (found_height < eye.y) + { + // Now keep the highest of the previous best_height and that just found + // and update this_height as we have an acceptable match + this_height = best_height = std::max(best_height,found_height); + } + } // End of overlap test + } + else + { + } + // There is no explicit action if a face is NOT matched, last static value returned + } // End of loop through triangles + return(this_height); // Return the spot height from the underlying triangle +} // End of BaseTriangles + +uint32_t CheckTriangles(const Vec3f eye, const Vec3f direction, const uint32_t this_chunk, const WorldLayout* layo_ptr) +{ + static const char *TAG = "CheckTriangles"; + extern Time_tracked time_report; + + // Various reasons to quit without doing anything more + if (this_chunk == INVALID_CHUNK) return (0); // Quit as it's invalid chunk beyond border, but we did need depth buffer reset perhaps + + if (layo_ptr->TheChunks[this_chunk].face_count == 0) return (0); // Quit as this chunk is empty with zero faces, which is valid? + + uint32_t pixels_done = 0; // Tracks the rasterised pixels to give indication of workload + + Vec3f clip_zs; // This will hold 'z' of the three clipped vertices + + TriToRaster this_tri; // A structure to pass to rasteriser + + make_camera(direction, eye, view); // coded to replace glm::lookat function at lower level + + // Multiply view and projection matrices here as there is no need to do this within the triangle loop + Matrix44f ViewProj = view * proj; + + const uint16_t* this_list = layo_ptr->TheChunks[this_chunk].faces_ptr; // fetch the list of faces applicable to this chunk + + for (uint32_t get_face = 0; get_face < layo_ptr->TheChunks[this_chunk].face_count; get_face++) + { + time_report.triangles++; // Keep count of primitives processed + // The chunk list is a subset of all triangles so pull the global index for rendering + uint32_t idx = this_list[get_face]; // Keep a plain idx so code is easier to read in rest of this function + + this_tri.idx = this_list[get_face]; // For passing to rasteriser stuct + this_tri.layout = layo_ptr; // Pass the layout as ptr to the queue on a per triangle basis + + // Fetch object-space vertices from the vertex buffer indexed by the values in index buffer + // and pass them directly to each VS invocation + const Vec3f v0 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3]]; + const Vec3f v1 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3 + 1]]; + const Vec3f v2 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3 + 2]]; + + // Invoke function for each vertex of the triangle to transform them from object-space to clip-space (-w, w) + Vec4f v0Clip = VS(v0, ViewProj); + Vec4f v1Clip = VS(v1, ViewProj); + Vec4f v2Clip = VS(v2, ViewProj); + + this_tri.clip_zs = { v0Clip.z, v1Clip.z, v2Clip.z }; // For passing to rasteriser struct + + // Apply viewport transformation + // Notice that we haven't applied homogeneous division and are still utilizing homogeneous coordinates + Vec4f v0Homogen = TO_RASTER(v0Clip); + Vec4f v1Homogen = TO_RASTER(v1Clip); + Vec4f v2Homogen = TO_RASTER(v2Clip); + + // Base vertex matrix + Matrix33f M = + { + v0Homogen.x, v1Homogen.x, v2Homogen.x, + v0Homogen.y, v1Homogen.y, v2Homogen.y, + v0Homogen.w, v1Homogen.w, v2Homogen.w, + }; + + // Singular vertex matrix (det(M) == 0.0) means that the triangle has zero area, + // which in turn means that it's a degenerate triangle which should not be rendered anyways, + // whereas (det(M) > 0) implies a back-facing triangle so we're going to skip such primitives + + // Do backface culling as early as possible so not sent to rasterise + float det = M.determinant(); + if (det >= 0.0f) + { + //tri_backface++; // Track how many are facing away + continue; + } + + // Worth doing more if not culled already + + // Work out brightness of the face + //this_tri.face_brightness = MakeShade(idx, eye, direction, layo_ptr); + MakeShade(idx, eye, direction, layo_ptr,& this_tri.face_brightness); + + // Compute the inverse of vertex matrix to use it for setting up edge & constant functions + Matrix33f invM = M.inverse(); + this_tri.invM = invM; // For passing to rasteriser stuct + + // Constants for primitive interpolation could be done here and added to tri structure + // Calculate constant function to interpolate 1/w + invM.multVecMatrix(Vec3f(1, 1, 1), this_tri.C); + // Calculate z interpolation vector + invM.multVecMatrix(this_tri.clip_zs, this_tri.Z); + + //switch (ExecuteFullTriangleClipping(idx, v0Clip, v1Clip, v2Clip, &TriBoundBox)) + switch (ExecuteFullTriangleClipping(v0Clip, v1Clip, v2Clip, &TriBoundBox)) + { + case CLIP_TR: + //tri_not_rendered++; + continue; // Bounding box is totally off screen + case CLIP_TA: + // the simplest function parameter passing approach is illustrated, + // but now uses a struct to allow array of primitives and chnges to the parameter list + // pixels_done += RasteriseBox(idx, v0Clip, v1Clip, v2Clip, TileBox, M); + + this_tri.BoBox = TriBoundBox; // The other parameters have been pre-populated +// pixels_done += RasteriseBox(this_tri); + if (flipped) pixels_done += QueueTriangle(this_tri,2); + else pixels_done += QueueTriangle(this_tri,0); + + break; + case CLIP_MC: + // Make the edge cooefficients for this triangle + + // Set up edge functions based on the vertex matrix + Vec3f E0 = { invM[0][0], invM[0][1], invM[0][2] }; + Vec3f E1 = { invM[1][0], invM[1][1], invM[1][2] }; + Vec3f E2 = { invM[2][0], invM[2][1], invM[2][2] }; + + // Normalize edge functions + E0 /= (abs(E0.x) + abs(E0.y)); + E1 /= (abs(E1.x) + abs(E1.y)); + E2 /= (abs(E2.x) + abs(E2.y)); + + // Indices of tile corners: + // LL -> 0 LR -> 1 + // UL -> 2 UR -> 3 + + const Vec2f scTileCornerOffsets[] = // this was const + { + { 0.f, 0.f}, // LL + { g_xTile, 0.f }, // LR + { 0.f, g_yTile }, // UL + { g_xTile, g_yTile} // UR + }; + + // (x, y) -> sample location | (a, b, c) -> edge equation coefficients + // E(x, y) = (a * x) + (b * y) + c + // E(x + s, y + t) = E(x, y) + (a * s) + (b * t) + + // Based on edge normal n=(a, b), set up tile TR corners for each edge + const uint8_t edge0TRCorner = (E0.y >= 0.f) ? ((E0.x >= 0.f) ? 3u : 2u) : (E0.x >= 0.f) ? 1u : 0u; + const uint8_t edge1TRCorner = (E1.y >= 0.f) ? ((E1.x >= 0.f) ? 3u : 2u) : (E1.x >= 0.f) ? 1u : 0u; + const uint8_t edge2TRCorner = (E2.y >= 0.f) ? ((E2.x >= 0.f) ? 3u : 2u) : (E2.x >= 0.f) ? 1u : 0u; + + // TA corner is the one diagonal from TR corner calculated above + const uint8_t edge0TACorner = 3u - edge0TRCorner; + const uint8_t edge1TACorner = 3u - edge1TRCorner; + const uint8_t edge2TACorner = 3u - edge2TRCorner; + + // Evaluate edge equation at first tile origin + // Surely origin is zero for our first case as we returned a full screen bounding box + const float edgeFunc0 = E0.z; // +((E0.x * tilePosX) + (E0.y * tilePosY)); + const float edgeFunc1 = E1.z; // +((E1.x * tilePosX) + (E1.y * tilePosY)); + const float edgeFunc2 = E2.z; // +((E2.x * tilePosX) + (E2.y * tilePosY)); + + // Break the full screen bounding box into tiles and rasterise them individually + for (uint32_t ty = 0, tyy = 0; ty < TriBoundBox.m_MaxY / g_yTile; ty++, tyy++) + { + for (uint32_t tx = 0, txx = 0; tx < TriBoundBox.m_MaxX / g_xTile; tx++, txx++) + { + // Using EE coefficients calculated in TriangleSetup stage and positive half-space tests, determine one of three cases possible for each tile: + // 1) TrivialReject -- tile within tri's bbox does not intersect tri -> move on + // 2) TrivialAccept -- tile within tri's bbox is completely within tri -> rasterise with no edge checks + // 3) Overlap -- tile within tri's bbox intersects tri -> rasterization with edge checks on each pixel + + // (txx, tyy) = how many steps are done per dimension + const float txxOffset = static_cast(txx * g_xTile); + const float tyyOffset = static_cast(tyy * g_yTile); + + // Step from edge function computed above for the first tile in bbox + float edgeFuncTR0 = edgeFunc0 + ((E0.x * (scTileCornerOffsets[edge0TRCorner].x + txxOffset)) + (E0.y * (scTileCornerOffsets[edge0TRCorner].y + tyyOffset))); + float edgeFuncTR1 = edgeFunc1 + ((E1.x * (scTileCornerOffsets[edge1TRCorner].x + txxOffset)) + (E1.y * (scTileCornerOffsets[edge1TRCorner].y + tyyOffset))); + float edgeFuncTR2 = edgeFunc2 + ((E2.x * (scTileCornerOffsets[edge2TRCorner].x + txxOffset)) + (E2.y * (scTileCornerOffsets[edge2TRCorner].y + tyyOffset))); + + // If TR corner of the tile is outside any edge, reject whole tile + bool TRForEdge0 = (edgeFuncTR0 < 0.f); + bool TRForEdge1 = (edgeFuncTR1 < 0.f); + bool TRForEdge2 = (edgeFuncTR2 < 0.f); + + if (TRForEdge0 || TRForEdge1 || TRForEdge2) + { + //tile_rejected++; + // TrivialReject + // Tile is completely outside of one or more edges + continue; // Skip to next tile now + } + + // Is the TA testing worthwhile if most are passed to be partial anyway? + // Tile is partially or completely inside one or more edges, do TrivialAccept tests first + // Compute edge functions at TA corners based on edge function at first tile origin + float edgeFuncTA0 = edgeFunc0 + ((E0.x * (scTileCornerOffsets[edge0TACorner].x + txxOffset)) + (E0.y * (scTileCornerOffsets[edge0TACorner].y + tyyOffset))); + float edgeFuncTA1 = edgeFunc1 + ((E1.x * (scTileCornerOffsets[edge1TACorner].x + txxOffset)) + (E1.y * (scTileCornerOffsets[edge1TACorner].y + tyyOffset))); + float edgeFuncTA2 = edgeFunc2 + ((E2.x * (scTileCornerOffsets[edge2TACorner].x + txxOffset)) + (E2.y * (scTileCornerOffsets[edge2TACorner].y + tyyOffset))); + + // If TA corner of the tile is outside all edges, accept whole tile + bool TAForEdge0 = (edgeFuncTA0 >= 0.f); + bool TAForEdge1 = (edgeFuncTA1 >= 0.f); + bool TAForEdge2 = (edgeFuncTA2 >= 0.f); + + if (TAForEdge0 && TAForEdge1 && TAForEdge2) + { + //tile_accepted++; + pixels_done += (g_xTile * g_yTile); // No need to count individual pixerls as it's all rasterised + + // TrivialAccept + // Tile is completely inside of the triangle, so no edge checks needed, + // whole tile will be fragment-shaded, with interpolation done in simplified rasteriser + + // Send tile for rasterisation without edge checking + this_tri.BoBox = { (float)(tx * g_xTile),(float)(ty * g_yTile),(float)((tx + 1) * g_xTile),(float)((ty + 1) * g_yTile) }; + // NotRasteriseBox(this_tri); + if (flipped) QueueTriangle(this_tri, 3); // Push to Not queue + else QueueTriangle(this_tri, 1); + continue; // Skip to next tile now + } + // By default the tile must be only partially covered + //tile_partial++; + // Make a box for each tile within the full screen bound box + this_tri.BoBox = { (float)(tx * g_xTile),(float)(ty * g_yTile),(float)((tx + 1) * g_xTile),(float)((ty + 1) * g_yTile) }; + // and do normal rasterisation with edge checking +// pixels_done += RasteriseBox(this_tri); + if (flipped) pixels_done += QueueTriangle(this_tri,2); + else pixels_done += QueueTriangle(this_tri,0); + + } // End of x tile loop + } // End of y tile loop + break; + } // End of switch on clip outcomes + } // End of loop through triangles + return(pixels_done); // Let the caller know how much was displayed +} // End of CheckTriangles + +// ************************************************************************************************ +// Basic shader that calculates face normal on the fly (rather than fetching pre-calculated) +// and is called as a triangle is processed so passed to rasteriser via queue +// The model uses embedded roughness to calculate uint32_t multipliers + +void MakeShade(uint32_t idx, const Vec3f eye, const Vec3f direction, const WorldLayout* layo_ptr, Shade_params* surface_shade) +{ + static const char *TAG = "MakeShade"; + + // Fetch object-space vertices from the vertex buffer indexed by the values in index buffer + const Vec3f& v0 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3]]; + const Vec3f& v1 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3 + 1]]; + const Vec3f& v2 = layo_ptr->vertices[layo_ptr->nvertices[idx * 3 + 2]]; + + // Read the face colour from the palette + // which has high order byte Ns for block colours and textures from mtl file + // Finally scale to 0 to 1.0 + const uint32_t this_Ns = (0xff000000 & (layo_ptr->palette[layo_ptr->attributes[idx]].rgb888)) >> 24; + float Ns = ((float) this_Ns) / 255.0f; + + // Calculate the face normal + // This should be from original vertices rather than projected + Vec3f FaceNormal = (v1 - v0).crossProduct(v2 - v0); + FaceNormal.normalize(); + // The dot product between face normal and the incident light shades the face + // Negative values are set to zero, in theory will not exceed 1.0f but wise to clamp + float lambertian = std::clamp(FaceNormal.dotProduct(IncidentLight), 0.f, 1.f); + + // Calculate the Halfway vector simplifed from + // https://learn.microsoft.com/en-us/windows/uwp/graphics-concepts/specular-lighting + // done on a face basis rather than vertex + Vec3f face_centre = (v0 + v1 + v2); + face_centre /= 3; + const Vec3f H = ((eye - face_centre).normalize() - IncidentLight).normalize(); // Sign of incident light has been reversed + + // The dot product between the face normal and eye shades according to whether it faces viewer + // As above, clamp away negative values + float shine = std::clamp(FaceNormal.dotProduct(H), 0.f, 1.f); + // A power of shine is needed, traditionaly ^4 is a good starting point to focus specular + shine = shine * shine * shine * shine * shine * shine; // Or as pow(), but that is double + //ESP_LOGI(TAG,"shine %f", shine ); + + // Diffuse is base lighting with a Lambertian proportion + // whereas a shiney surface is most affected by angle to viewer + const float Ns_power = (Ns * 0.5f); // How much of the Ns is fed into specular + float diffuse = (1.0f - Ns_power) * 0.5f + lambertian * 0.5f; + float specular = Ns_power * (0.1f + shine * 0.9f); + + // The degree of roughness is indicated by Ns and so the two elements above are mixed + // Large Ns is more specular + //float shade = (specular * (Ns)) + (diffuse * (1 - Ns)); + //surface_shade->x = diffuse; + //surface_shade->y = specular; + + surface_shade->lamb = static_cast(std::clamp(256.f * diffuse, 0.f, 255.f)); + surface_shade->spec = static_cast(std::clamp(256.f * specular, 0.f, 255.f)); +} // End of MakeShade() diff --git a/main/ChunkChooser.cpp b/main/ChunkChooser.cpp new file mode 100644 index 0000000..39154dd --- /dev/null +++ b/main/ChunkChooser.cpp @@ -0,0 +1,179 @@ +// It seemed a good idea to use an orthographic projection to build a 2d map of the world +// which could be used for chunking. BUT triangles that are 'edge-on' are invisible in the edge-detection +// and thus not placed in a chunk, so abandoned as an approach. +// +// This simple routine allows the 360 degree view to be divided into sectors and then a series of chunks tested for rendering +// The search array is readily altered for more or fewer sectors and numbers of chunks to be worked through +// +// Some of the functions are very small so it feels as though there might be an excessive overhead +// passing parameters, although rasteriser mostly likely the bottleneck + +#include +#include +#include "esp_log.h" +//static const char *TAG = "ChunkChooser"; + + +#include "ChunkChooser.h" +#include "globals.h" +//#include "CameraWork.h" +//#include "RasteriseBox.h" +#include "geometry.h" + + +// Check if the chunk is in range of the model and return false if not in the defined model +bool test_chunk(Vec2i chunk, const ChunkArr& chunk_param) +{ + if (chunk.x < 0 || chunk.x>(chunk_param.xcount - 1)) return false; // range check x + if (chunk.y < 0 || chunk.y>(chunk_param.zcount - 1)) return false; // range check z + + return (true); +} + +// Calculate chunk coordinate from eye position +// this is separated from test so scanning can occur from invalid chunks +// also passing the chunk parameters so can swap world layouts +Vec2i find_chunk(const Vec3f location, const ChunkArr& chunk_param) +{ + Vec2i this_chunk; + + this_chunk.x = (int)floor((location.x - chunk_param.xmin) / chunk_param.size); + + // Don't forget that z is the other axis in the horizontal world plane + this_chunk.y = (int)floor((location.z - chunk_param.zmin) / chunk_param.size); + + return (this_chunk); +} + +// Return the chunk's index in the model's array from coordinates of chunk +uint32_t chunk_index(const Vec2i chunk, const ChunkArr& chunk_param) + { + return (chunk.x + chunk_param.xcount * chunk.y); +} + +// An array of offsets to use to pick the next chunk for display +const uint32_t test_zones = 32; // The number of chunks listed in decreasing priority +const uint32_t test_sectors = 8; // The sectors into which a 2D horizontal circle is divided + +const Vec2i ChunkSequence[test_sectors][test_zones] = { + { {0,0},{0,1},{-1,1},{-1,0},{1,0},{0,2},{-1,2},{1,1},{-2,1},{-2,0},{1,2},{-2,2},{2,3},{-3,1},{0,3},{1,3},{-1,3},{2,3},{-2,3},{-3,2},{0,4},{-1,4},{1,4},{-2,4},{2,4},{-3,3},{-4,2},{3,4},{-3,4},{-4,3},{0,5},{-1,5} }, // Sector 0 + { {0,0},{-1,0},{-1,1},{0,1},{0,-1},{-2,0},{-2,1},{-1,-1},{-1,2},{0,2},{-2,-1},{-2,2},{-3,-2},{-1,3},{-3,0},{-3,-1},{-3,1},{-3,-2},{-3,2},{-2,3},{-4,0},{-4,1},{-4,-1},{-4,2},{-4,-2},{-3,3},{-2,4},{-4,-3},{-4,3},{-3,4},{-5,0},{-5,1} }, // Sector 1 + { {0,0},{-1,0},{-1,-1},{0,-1},{0,1},{-2,0},{-2,-1},{-1,1},{-1,-2},{0,-2},{-2,1},{-2,-2},{-3,2},{-1,-3},{-3,0},{-3,1},{-3,-1},{-3,2},{-3,-2},{-2,-3},{-4,0},{-4,-1},{-4,1},{-4,-2},{-4,2},{-3,-3},{-2,-4},{-4,3},{-4,-3},{-3,-4},{-5,0},{-5,-1} }, // Sector 2 + { {0,0},{0,-1},{-1,-1},{-1,0},{1,0},{0,-2},{-1,-2},{1,-1},{-2,-1},{-2,0},{1,-2},{-2,-2},{2,-3},{-3,-1},{0,-3},{1,-3},{-1,-3},{2,-3},{-2,-3},{-3,-2},{0,-4},{-1,-4},{1,-4},{-2,-4},{2,-4},{-3,-3},{-4,-2},{3,-4},{-3,-4},{-4,-3},{0,-5},{-1,-5} }, // Sector 3 + { {0,0},{0,-1},{1,-1},{1,0},{-1,0},{0,-2},{1,-2},{-1,-1},{2,-1},{2,0},{-1,-2},{2,-2},{-2,-3},{3,-1},{0,-3},{-1,-3},{1,-3},{-2,-3},{2,-3},{3,-2},{0,-4},{1,-4},{-1,-4},{2,-4},{-2,-4},{3,-3},{4,-2},{-3,-4},{3,-4},{4,-3},{0,-5},{1,-5} }, // Sector 4 + { {0,0},{1,0},{1,-1},{0,-1},{0,1},{2,0},{2,-1},{1,1},{1,-2},{0,-2},{2,1},{2,-2},{3,2},{1,-3},{3,0},{3,1},{3,-1},{3,2},{3,-2},{2,-3},{4,0},{4,-1},{4,1},{4,-2},{4,2},{3,-3},{2,-4},{4,3},{4,-3},{3,-4},{5,0},{5,-1} }, // Sector 5 + { {0,0},{1,0},{1,1},{0,1},{0,-1},{2,0},{2,1},{1,-1},{1,2},{0,2},{2,-1},{2,2},{3,-2},{1,3},{3,0},{3,-1},{3,1},{3,-2},{3,2},{2,3},{4,0},{4,1},{4,-1},{4,2},{4,-2},{3,3},{2,4},{4,-3},{4,3},{3,4},{5,0},{5,1} }, // Sector 6 + { {0,0},{0,1},{1,1},{1,0},{-1,0},{0,2},{1,2},{-1,1},{2,1},{2,0},{-1,2},{2,2},{-2,3},{3,1},{0,3},{-1,3},{1,3},{-2,3},{2,3},{3,2},{0,4},{1,4},{-1,4},{2,4},{-2,4},{3,3},{4,2},{-3,4},{3,4},{4,3},{0,5},{1,5} } // Sector 7 +}; + + +// Return a chunk index using eye and direction Vec3f with progressive +// scanning around through the array from the current chunk location +// Sending the layout too as we will be overlaying models +uint32_t ChunkChooser(const Vec3f eye, Vec3f direction, const bool eye_moved, const WorldLayout* layo_ptr) +{ +// direction can't be const as we zero y component in this function + + const Vec2f axis = { 0,-1 }; // The reference axis, hopefully calculated in at compile as it's const + + // These variables to persist as the direction vector stays the same between calls until 'moved' + // The calculations aren't massive but why do them 8 times extra? + static int32_t search_step = -1; // Keep track of which chunk we will return to + static Vec2i this_chunk; + static Vec3f ch_dir; + static float det, dot,pointing; + static uint32_t pointing_index; + + // if we have moved then restart the choosing process + // using static old values gave false movement presumably due to rounding issues + // so it is now a specific flag + if (eye_moved) + { + search_step = -1; + // Find the chunk that we sit in with result into passed variables + // and kept for each call to save time + this_chunk = find_chunk(eye,layo_ptr->ChAr); + + direction.y = 0; // Ignore 3rd dimension of y and then normalise the way we're looking + ch_dir = direction.normalize(); + + // As atan2 gives result -PI to +PI when we add PI the sequence around the dial is simply 0 to 2PI! + dot = axis.x * ch_dir.x + axis.y * ch_dir.z; // Note it's z in Vec3f, OK to be zero + det = ch_dir.z * axis.x - ch_dir.x * axis.y; + + // angle is atan2 (determinant,dot product) plus PI + constexpr float pointing_factor = test_sectors / (2 * M_PI); + pointing = (atan2(det, dot) + M_PI) * pointing_factor; // divide into the sectors + // A bitwise mask was used in the next line to avoid a divide, but not generalisable and it's only done once per frame + pointing_index = ((uint32_t)floor(pointing)) % test_sectors; // Ensure no overflow at 2 * PI + } // end of if (eye_moved) + + if (search_step++ == test_zones) + { + return(LAST_CHUNK); // All options have been used now so caller won't come back + } + Vec2i this_offset = ChunkSequence[pointing_index][search_step]; + Vec2i new_chunk = this_chunk + this_offset; + + uint32_t chosen_chunk; + + if (test_chunk(new_chunk,layo_ptr->ChAr)) + { + chosen_chunk= chunk_index(new_chunk,layo_ptr->ChAr); // The chunk is in range so send that back + } + else chosen_chunk = INVALID_CHUNK; // Return that the chunk is out of range and then it won't be rendered + + return(chosen_chunk); // return a valid chunk or an error for each chunk derived from the search array +} + +// Return a chunk index using eye and direction Vec3f with progressive +// scanning around through the array from the current chunk location +// Sending the layout too as we will be overlaying models +// Indexed doesn't needed a static index nor a 'reset' flag +uint32_t IndexChunkChooser(const Vec3f eye, Vec3f direction, uint32_t index, const WorldLayout* layo_ptr) +{ +// direction can't be const as we zero y component in this function + + const Vec2f axis = { 0,-1 }; // The reference axis, hopefully calculated in at compile as it's const + + // These variables to persist as the direction vector stays the same between calls until 'moved' + // The calculations aren't massive but why do them 8 times extra? + Vec2i this_chunk; + Vec3f ch_dir; + float det, dot,pointing; + uint32_t pointing_index; + + if (index == test_zones) + { + return(LAST_CHUNK); // All options have been used now so caller won't come back + } + // Find the chunk that we sit in with result into passed variables + // and kept for each call to save time + this_chunk = find_chunk(eye,layo_ptr->ChAr); + + direction.y = 0; // Ignore 3rd dimension of y and then normalise the way we're looking + ch_dir = direction.normalize(); + + // As atan2 gives result -PI to +PI when we add PI the sequence around the dial is simply 0 to 2PI! + dot = axis.x * ch_dir.x + axis.y * ch_dir.z; // Note it's z in Vec3f, OK to be zero + det = ch_dir.z * axis.x - ch_dir.x * axis.y; + + // angle is atan2 (determinant,dot product) plus PI + constexpr float pointing_factor = test_sectors / (2 * M_PI); + pointing = (atan2(det, dot) + M_PI) * pointing_factor; // divide into the sectors + // A bitwise mask was used in the next line to avoid a divide, but not generalisable and it's only done once per frame + pointing_index = ((uint32_t)floor(pointing)) % test_sectors; // Ensure no overflow at 2 * PI + + Vec2i this_offset = ChunkSequence[pointing_index][index]; + Vec2i new_chunk = this_chunk + this_offset; + + uint32_t chosen_chunk; + + if (test_chunk(new_chunk,layo_ptr->ChAr)) + { + chosen_chunk= chunk_index(new_chunk,layo_ptr->ChAr); // The chunk is in range so send that back + } + else chosen_chunk = INVALID_CHUNK; // Return that the chunk is out of range and then it won't be rendered + + return(chosen_chunk); // return a valid chunk or an error for each chunk derived from the search array +} diff --git a/main/ClipBound.cpp b/main/ClipBound.cpp new file mode 100644 index 0000000..8667468 --- /dev/null +++ b/main/ClipBound.cpp @@ -0,0 +1,186 @@ +#include +#include +#include "globals.h" +#include "geometry.h" +#include "structures.h" +#include "CheckTriangles.h" + +#include "ClipBound.h" + + +// Although the homogenous coordinate sytem renders triangles off screen well it wastes time +// on triangles crossing frustrum as it returns a full bounding box +// Tiling will deal with that! +// This routine is based on source from https://tayfunkayhan.wordpress.com/2019/07/26/chasing-triangles-in-a-tile-based-rasterizer/ + +unsigned int ExecuteFullTriangleClipping(const Vec4f& v0Clip, const Vec4f& v1Clip, const Vec4f& v2Clip, Rect2D* pBbox) +{ + + // Clip-space positions are to be bounded by: + // -w < x < w -> LEFT/RIGHT + // -w < y < w -> TOP/BOTTOM + // 0 < z < w -> NEAR/FAR + // However, we will only clip primitives that are *completely* outside of any of clipping planes. + // This means that, triangles intersecting view frustum are passed as-is, to be rasterized as usual. + // Because we're utilizing homogeneous rasterization, we don't need to do explcit line-clipping here. + + // Clip against w+x=0 left plane + bool allOutsideLeftPlane = + (v0Clip.x < -v0Clip.w) && + (v1Clip.x < -v1Clip.w) && + (v2Clip.x < -v2Clip.w); + + bool allInsideLeftPlane = + (v0Clip.x >= -v0Clip.w) && + (v1Clip.x >= -v1Clip.w) && + (v2Clip.x >= -v2Clip.w); + + // Clip against w-x=0 right plane + bool allOutsideRightPlane = + (v0Clip.x > v0Clip.w) && + (v1Clip.x > v1Clip.w) && + (v2Clip.x > v2Clip.w); + + bool allInsideRightPlane = + (v0Clip.x <= v0Clip.w) && + (v1Clip.x <= v1Clip.w) && + (v2Clip.x <= v2Clip.w); + + // Clip against w+y top plane + bool allOutsideBottomPlane = + (v0Clip.y < -v0Clip.w) && + (v1Clip.y < -v1Clip.w) && + (v2Clip.y < -v2Clip.w); + + bool allInsideBottomPlane = + (v0Clip.y >= -v0Clip.w) && + (v1Clip.y >= -v1Clip.w) && + (v2Clip.y >= -v2Clip.w); + + // Clip against w-y bottom plane + bool allOutsideTopPlane = + (v0Clip.y > v0Clip.w) && + (v1Clip.y > v1Clip.w) && + (v2Clip.y > v2Clip.w); + + bool allInsideTopPlane = + (v0Clip.y <= v0Clip.w) && + (v1Clip.y <= v1Clip.w) && + (v2Clip.y <= v2Clip.w); + + // Clip against 0= 0.f) && + (v1Clip.z >= 0.f) && + (v2Clip.z >= 0.f); + + // Clip against z>w far plane + bool allOutsideFarPlane = + (v0Clip.z > v0Clip.w) && + (v1Clip.z > v1Clip.w) && + (v2Clip.z > v2Clip.w); + + bool allInsideFarPlane = + (v0Clip.z <= v0Clip.w) && + (v1Clip.z <= v1Clip.w) && + (v2Clip.z <= v2Clip.w); + + float width = g_scWidth; // Not ideal but quick and easy + float height = g_scHeight; + + if (allOutsideLeftPlane || + allOutsideRightPlane || + allOutsideBottomPlane || + allOutsideTopPlane || + allOutsideNearPlane || + allOutsideFarPlane) + { + // TRIVIALREJECT case + + // Primitive completely outside of one of the clip planes, discard it + return CLIP_TR; + } + else if (allInsideLeftPlane && + allInsideRightPlane && + allInsideBottomPlane && + allInsideTopPlane && + allInsideNearPlane && + allInsideFarPlane) + { + // TRIVIALACCEPT + //tri_trivial_accept++; + + //LOG("Prim %d TA'd in FT-clipper by thread %d", primIdx, m_ThreadIdx); + + // Primitive is completely inside view frustum + + // Compute bounding box + Rect2D bbox = ComputeBoundingBox(v0Clip, v1Clip, v2Clip, width, height); + + // Clamp bbox to screen extents + bbox.m_MinX = std::max(0.0f, bbox.m_MinX); + bbox.m_MaxX = std::min(width - 1, bbox.m_MaxX); + bbox.m_MinY = std::max(0.0f, bbox.m_MinY); + bbox.m_MaxY = std::min(height - 1, bbox.m_MaxY); + + *pBbox = bbox; + + return CLIP_TA; + } + else + { + // MUSTCLIP + + // Primitive is partially inside view frustum, but we don't clip for this + // so we must be conservative and return the whole range to rasterize further. + // Note that is *overly* conservative in practice; we could do better by implementing + // Blinn's method of screen coverage calculation properly but it's an overkill here. + // Note that simple use of Bounding Box doesn't work correctly even with homogenous coordinates + + //tri_mustclip++; + + Rect2D bbox = + { + 0.f, + 0.f, + width, + height + }; + + *pBbox = bbox; + + return CLIP_MC; + } +} + +Rect2D ComputeBoundingBox(const Vec4f& v0Clip, const Vec4f& v1Clip, const Vec4f& v2Clip, float width, float height) +{ + Vec2f v0Raster = Vec2f((g_scWidth * (v0Clip.x + v0Clip.w) / (2 * v0Clip.w)), (g_scHeight * (v0Clip.w - v0Clip.y) / (2 * v0Clip.w))); + Vec2f v1Raster = Vec2f((g_scWidth * (v1Clip.x + v1Clip.w) / (2 * v1Clip.w)), (g_scHeight * (v1Clip.w - v1Clip.y) / (2 * v1Clip.w))); + Vec2f v2Raster = Vec2f((g_scWidth * (v2Clip.x + v2Clip.w) / (2 * v2Clip.w)), (g_scHeight * (v2Clip.w - v2Clip.y) / (2 * v2Clip.w))); + + + // Find min/max in X & Y + + float xmin = std::min(v0Raster.x, std::min(v1Raster.x, v2Raster.x)); + float xmax = std::max(v0Raster.x, std::max(v1Raster.x, v2Raster.x)); + float ymin = std::min(v0Raster.y, std::min(v1Raster.y, v2Raster.y)); + float ymax = std::max(v0Raster.y, std::max(v1Raster.y, v2Raster.y)); + + Rect2D bbox; + bbox.m_MinX = xmin; + bbox.m_MinY = ymin; + bbox.m_MaxX = xmax; + bbox.m_MaxY = ymax; + + //box_count++; // track how many boxes are made + //box_length += (long unsigned int)(xmax - xmin + ymax - ymin); // calculate w + h for this box + + return (bbox); +} + diff --git a/main/EventManager.cpp b/main/EventManager.cpp new file mode 100644 index 0000000..1e4f2bd --- /dev/null +++ b/main/EventManager.cpp @@ -0,0 +1,325 @@ +#include +#include + +#include +#include +#include "freertos/event_groups.h" + +#include "esp_timer.h" + +#include "esp_log.h" + +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" + +#include "structures.h" +#include "events_global.h" + +#include "ShowWorld.h" + +#include "GradientBar.h" +#include "numberfont.h" // 10 digits as a bitmap for use as a 'font' and 'game over' +#include "EventManager.h" + +extern QueueHandle_t game_event_queue; // A FreeRTOS queue to pass game play events from world to manager +extern std::vector world; // An unsized vector of layouts each of which can contain multiple frames +extern TimerHandle_t track_handle_p; // Handle for popup removal timer +extern bool OverlayFlag; // Causes the 2D overlay to be added +extern uint16_t * overlay_buffer; // 2D buffer allocated in start-up + +// Track parameters and report occasionally +Time_tracked time_report; + +void GetGameEvent(void * parameter) +{ + static const char *TAG = "GetGameEvent"; + extern TwoD_overlay score_overlay; + extern EventGroupHandle_t raster_event_group; + extern TimerHandle_t track_handle_s; + + static int64_t game_start_time = esp_timer_get_time(); // The time game play starts is found dynamically on first run + + Near_pix this_event_pix; + + ESP_LOGI(TAG,"Entering GetGameEvent task to loop"); + + // A task that waits for a game play event to appear on the queue + while (1) + { + // Block until a queue item is available + xQueueReceive( game_event_queue, & this_event_pix, portMAX_DELAY); + uint32_t event_code = this_event_pix.event; + //ESP_LOGI(TAG,"Event is %04x",(int)event_code); + // Nested if allows actions to be accumulated rather than isolated with switch + if (event_code & EVNT_ENERGY) // Actions related to player's energy level + { + if (event_code & EE_SET) + { + // Set its value, generally as game is reset + time_report.health = (event_code & EVNT_NN_MASK) >> EVNT_NN_SHIFT; + time_report.health = std::clamp(time_report.health, (uint16_t)0 , (uint16_t)128); + // ESP_LOGI(TAG,"Energy set to %d",(int)time_report.health); + } + if (event_code & EE_CHANGE) + { + //ESP_LOGI(TAG,"Energy incoming %d",(int)time_report.health); + + // Adjust its value, done with time, incidents and awards + // Working with 16bit ints until it's been clamped as it can overflow on a temporary basis + uint16_t temp_health = time_report.health + (int8_t)((event_code & EVNT_NN_MASK) >> EVNT_NN_SHIFT); + //ESP_LOGI(TAG,"Temp health %d", (int)temp_health); + time_report.health = std::clamp(temp_health, (uint16_t)0 , (uint16_t)128); + // ESP_LOGI(TAG,"Energy changed to %d",(int)time_report.health); + if (time_report.health <= 0) + // End of the game + { + // Halt key tasks rather than deleting as it's cleaner and allows restarting if required + xEventGroupClearBits(raster_event_group, GAME_RUNNING); // Hold the ShowWorld task which will in turn halt raster queues + xTimerStop(track_handle_s,5); // Halt the one second update timer + const uint16_t game_play_time = (uint16_t)((esp_timer_get_time() - game_start_time)/1000000); + // Display the score on stationary game screen when last frame has been done + MakeNumber(0,game_play_time, score_overlay); // make the score buffer + xEventGroupWaitBits( + raster_event_group, // event group handle + RASTER_DONE, // bits to wait for + pdTRUE, // clear the bit once we've started + pdTRUE, // AND for any of the defined bits + 100 ); // block for a bit + + // Send the 'game over' screen + TwoD_overlay gameover_screen = {GAMEOVER_W, GAMEOVER_H, (uint16_t *) gameover}; + OverlayTwoD(gameover_screen); + OverlayTwoD(score_overlay); // overlay the buffer + flipped = !flipped; // align writing and display buffers + SendFlippedFrame(); // draw frame buffer with its overlay onto LCD + } // End of end of game + } + if (event_code & EE_DISPLAY) + { + // Show the energy bar + // ESP_LOGI(TAG,"To display energy"); + EvntHealthBar(time_report.health); + } + if (event_code & EE_SCORE) + { + // Make a buffer that has digits as raster + MakeNumber(1,((event_code & EVNT_NN_MASK) >> EVNT_NN_SHIFT), score_overlay); + // Show the overlay + // ESP_LOGI(TAG,"Show top-ups of energy"); + // Start the popup removal timer now + if( xTimerStart( track_handle_p, 0 ) != pdPASS ) assert("Start of popup xTimer failed"); + OverlayFlag = true; + } + } // End of EVNT_ENERGY + + if (event_code & EVNT_FACES) // Actions related to faces in the worlds + { + if (event_code & EF_DELETE) + { + // Delete faces matching event code + //ESP_LOGI(TAG,"To delete faces"); + EvntDeleteFaces(this_event_pix); // Delete the item impacted + } + } // End of EVNT_FACES + //taskYIELD(); + } // End of infinite while loop + } // End of GetGameEvent + +// Delete all of the faces from chunk lists that have the same event code throughout this layout +// Works through ALL frames of ALL world layouts +void EvntDeleteFaces(Near_pix this_event_pix) +{ + static const char *TAG = "EvntDeleteFaces"; + WorldLayout * this_world_ptr; // ptr to const world + + // Loop through all of the world layouts to draw the world(s) + for (uint32_t worlds=0 ; worlds < world.size() ; worlds++) + { + // See if the layout has mutiple frames and loop accordingly + // Note that single frame layouts have a count of '1' + for (uint16_t this_frame = 0; this_frame < world[worlds].frames; this_frame++) + { + //ESP_LOGI(TAG,"World % d and frame %d", (int)worlds, (int)this_frame); + + // set the pointer to the layout in use + this_world_ptr = & (world[worlds].frame_layouts[this_frame]); + + // We could check here if the event code is in the palette in this frame + // to save checking all faces in irrelevant layouts/frames + // faceMaterials * this_palette = this_world_ptr->palette; + // Note that we don't know how many entries are in the palette... + // It seems fast enough without the extra checking + + // Work through chunks finding which faces share the event code value + // Fetch the number of chunks in the recetangle from ChAr x and z + + uint32_t chunk_number = this_world_ptr->ChAr.xcount * this_world_ptr->ChAr.zcount; + // Loop through all chunks + for (uint32_t chnk = 0; chnk < chunk_number; chnk ++) + { + // Fetch the base address of the list of faces + uint16_t * face_ptr = this_world_ptr->TheChunks[chnk].faces_ptr; + + uint32_t i = 0; // A counter to step into chunk array + + // Will quit when no faces in a chunk or i shows it's at the end + while (this_world_ptr->TheChunks[chnk].face_count && i < this_world_ptr->TheChunks[chnk].face_count) + { + // It is an option to use the face idx to retrieve the attribute but that isn't + // reprodcibile across layouts, whereas checking for the specific event code is more indorection + // but actually does what is wanted without making assumptions about the event code and attribute ampping + while (this_world_ptr->palette[this_world_ptr->attributes[face_ptr[i]]].event == this_event_pix.event) + { + // Yes it is, so copy last face into the space and decrement face count in chunk table + //ESP_LOGI(TAG, "Deleting face %d at %i",(int)face_ptr[i],(int)i); + // Deletion done by putting last face into a matched slot + face_ptr[i] = face_ptr[this_world_ptr->TheChunks[chnk].face_count - 1]; + this_world_ptr->TheChunks[chnk].face_count --; + if (this_world_ptr->TheChunks[chnk].face_count == 0) break; // Quit if all deleted + } + i++; // Move on to the next spot in the face list now matches removed at a given spot + } // End of face delete while + } // End of for through chunks + } // End of frame loop + } // End of world loop +} // End of EvntDeleteFaces + +void EvntHealthBar(const uint16_t health) +{ + extern esp_lcd_panel_handle_t panel_handle; + extern EventGroupHandle_t raster_event_group; + + const uint32_t horiz_space = 4; // A space between world window and the bar + static uint16_t bar_buffer[GRADBAR_H * GRADBAR_W]; // Make an empty graphic bar + + // A bar is built in RAM with black top part and coloured gradient lower + // +1 so that initial 127 shows as the full health bar of 128 lines + const auto transition_index = (GRADBAR_W * (GRADBAR_H - health)); + + // Copy the lower part of gradient-coloured bar as required + for (int i = transition_index; i < (GRADBAR_H * GRADBAR_W); i++) + { + bar_buffer[i] = gradient_bar[i]; + } + + // Blank out the top part as required, for loop is good as it allows zero executions + for (int i = 0; i < transition_index; i++) + { + bar_buffer[i] = 0x0000; + } + + // Check that LCD is free to use + xEventGroupWaitBits( + raster_event_group, // event group handle + CLEAR_READY, // bits to wait for + pdTRUE, // clear the bit once we've started + pdTRUE, // AND for any of the defined bits + portMAX_DELAY ); // block forever + + // Signal that DMA is in use + //xEventGroupClearBits( raster_event_group, CLEAR_READY); + + // A single DMA process is initiated rather than sending top and bottom separately + // No check done that other DMA ongoing, is this needed? + // MUTEX or use the event flag? + // Perhaps this should go inside the world screen for the minature devices? + ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, + g_scWidth + horiz_space + 0, 0, // Start and end of the complete buffer + g_scWidth + horiz_space + GRADBAR_W, GRADBAR_H, + bar_buffer )); +} // End of HealthBar + +void OverlayTwoD(TwoD_overlay & this_overlay) +{ +static const char *TAG = "OverlayTwoD"; + +extern bool flipped; // A global pingpong flag +extern uint16_t * frame_buffer_A; +extern uint16_t * frame_buffer_B; + +uint16_t *frame_buffer_this; + +if (flipped) frame_buffer_this = frame_buffer_A; +else frame_buffer_this = frame_buffer_B; + +//ESP_LOGI(TAG," width %d and height %d", (int)this_overlay.width, (int)this_overlay.height); +// Calculate the first corner to copy to so as to centralise the overlay every frame +const auto start_index = ((g_scWidth * (g_scHeight - this_overlay.height) / 2) + (g_scWidth - this_overlay.width)/2); +//ESP_LOGI(TAG,"Start index %d",(int)start_index); +// Do the copying based on parameters for source +for (auto h = 0; h < this_overlay.height; h++) +{ + for (auto w = 0; w < this_overlay.width; w++) + { + const uint16_t pix_write = this_overlay.buffer[h*this_overlay.width + w]; + // Only write non-zero pixels from source image + if (pix_write) frame_buffer_this[h * g_scWidth + w + start_index] = pix_write; + } +} +} // End of Overlay2D + +void StopOverlayTwoD(TimerHandle_t tracked_handle) +{ + static const char *TAG = "StopOverlayTwoD"; + + //ESP_LOGI(TAG,"Removing popup"); + OverlayFlag = false; + +} // End of StopOverlayTwoD + +// Input a score and make a bitmap for display +// Maybe needs a structure for the bitmap and its dimensions +void MakeNumber(uint16_t font_index, uint16_t score, TwoD_overlay & this_overlay) +{ + static const char *TAG = "MakeNumber"; + + std::vectordigits; // Somewhere to keep the digits + this_overlay.buffer = overlay_buffer; // Define where the build buffer is + + // Start by splitting score into digits, this will give them in reverse order + // such that lowest is deepest, actually this may well be optimum + while(score) + { + digits.push_back(score % 10); + score = score / 10; + } + + // Run through the vector to find the full width of buffer required, don't pull the items though + uint16_t this_buffer_width = 0; + for (auto this_digit : digits ) + { + this_buffer_width += nesto[font_index].locations[this_digit + 1] - nesto[font_index].locations[this_digit]; + } + //ESP_LOGI(TAG,"Buffer width set to %d",(int)this_buffer_width); + + // Knowing the destination layout copy raster from the char sources one by one + // Starting with most significant digit which is popped first + uint16_t buffer_x_pos = 0; // Current placement position in buffer, starting at the beginning + while (!digits.empty()) + { + uint16_t this_digit = digits.back(); digits.pop_back();// Fetch a digit, highest order first + // Find where the digit resides in the source array that holds the numbers + const uint16_t font_start_column = nesto[font_index].locations[this_digit]; + const uint16_t font_end_column = nesto[font_index].locations[this_digit + 1]; + const uint16_t font_char_width = font_end_column - font_start_column; + + //ESP_LOGI(TAG, "Digit %d, start %d and end %d",(int)this_digit, (int)font_start_column, (int)font_end_column); + + // Copy the font into the buffer area, background removed by the overlayer later + for (auto font_row = 0; font_row < nesto[font_index].height; font_row ++) // Loop through each row of font in the copy + { + for (auto font_pos = 0; font_pos < font_char_width; font_pos++) + { + this_overlay.buffer[buffer_x_pos + font_pos + (font_row * this_buffer_width)] = nesto[font_index].buffer[font_start_column + font_pos + (font_row * nesto[font_index].width)]; + //ESP_LOGI(TAG, "At row %d, pos %d", (int)font_row, (int)font_pos); + } // End of copying along a row + } // End of font column copy for loop + buffer_x_pos += font_char_width; // Move along in destination buffer + } // End of while to pull every digit from buffer + + // Update the parameters of the written buffer for the consumer + this_overlay.width = this_buffer_width; + this_overlay.height = nesto[font_index].height; + //ESP_LOGI(TAG,"Height %d and width %d",(int)this_overlay.height,(int)this_overlay.width); +} // End of MakeNumber \ No newline at end of file diff --git a/main/FindHitFace.cpp b/main/FindHitFace.cpp new file mode 100644 index 0000000..9755d2f --- /dev/null +++ b/main/FindHitFace.cpp @@ -0,0 +1,89 @@ +#include +#include + +#include "esp_log.h" + +#include "globals.h" +#include "geometry.h" +#include "structures.h" + +#include "ShowError.h" + +#include "FindHitFace.h" +#include "RasteriseBox.h" // For CheckEdgeFunction + +// ************************************************************************************************ +// Checks if a triangle is intersected by the viewer pixel test_x and test_y +// using rasteriser layout, returns LARGE_FLOAT if not contained or a smaller z value if found +float CheckHitFace(const TriToRaster & tri, const uint32_t test_x, const uint32_t test_y) +{ + //static const char *TAG = "CheckHitFace"; + const Matrix33f invM = tri.invM; + + // Check if text_x and test_y lie within the bounding box as a first step + if (! TestBoBox(tri.BoBox, test_x, test_y)) return (farPlane); + + float z = farPlane; + + // Homogenous appraoch to edge function used as triangles may extend beyond view frustrum + // Set up edge functions based on the vertex matrix + const Vec3f E0 = { invM[0][0], invM[0][1], invM[0][2] }; + const Vec3f E1 = { invM[1][0], invM[1][1], invM[1][2] }; + const Vec3f E2 = { invM[2][0], invM[2][1], invM[2][2] }; + + // Calculate constant function to interpolate 1/w + const Vec3f C = tri.C; + + // Calculate z interpolation vector + const Vec3f Z = tri.Z; + + Vec3f Sample = { test_x + 0.5f, test_y + 0.5f, 1.0f }; + + // Set up the EvaluateEdgeFunction + float Edge0 = (E0.x * Sample.x) + (E0.y * Sample.y) + E0.z; + float Edge1 = (E1.x * Sample.x) + (E1.y * Sample.y) + E1.z; + float Edge2 = (E2.x * Sample.x) + (E2.y * Sample.y) + E2.z; + + + // Check if the text pixel is within the projected triangle + if (CheckEdgeFunction(E0, Edge0) && CheckEdgeFunction(E1, Edge1) && CheckEdgeFunction(E2, Edge2)) + { + // It is inside so do further work + // Find z that will be used for depth test + const float w = 1/((C.x * Sample.x) + (C.y * Sample.y) + C.z); + z = w * ((Z.x * Sample.x) + (Z.y * Sample.y) + Z.z); + } + return (z); // LARGE_FLOAT if not contained +} // End of CheckFace + +// Tests the pixel z depth against a tiled primitive, so no edge checking needed +float CheckHitTile(const TriToRaster & tri, const uint32_t test_x, const uint32_t test_y) +{ + //static const char *TAG = "CheckHitTile"; + + // Check if text_x and test_y lie within the bounding box as a first step and exit if not + if (! TestBoBox(tri.BoBox, test_x, test_y)) return (farPlane); + + // Calculate constant function to interpolate 1/w + const Vec3f C = tri.C; + + // Calculate z interpolation vector + const Vec3f Z = tri.Z; + + // The triangle does need to be checked + Vec3f Sample = { test_x + 0.5f, test_y + 0.5f, 1.0f }; + // Find z that will be used for depth test + const float w = 1/((C.x * Sample.x) + (C.y * Sample.y) + C.z); + const float z = w * ((Z.x * Sample.x) + (Z.y * Sample.y) + Z.z); +return (z); +} // End of CheckHitTile + +// For hit checking, basic test if the test pixel is within the bounding box for rendering +inline bool TestBoBox(const Rect2D box, const uint32_t test_x, const uint32_t test_y) +{ + if ((test_x >= (uint32_t)box.m_MinX) && (test_x <= (uint32_t)box.m_MaxX) && + (test_y >= (uint32_t)box.m_MinY) && (test_y <= (uint32_t)box.m_MaxY)) + return (true); + else return (false); +} // End of TestBoBox + diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild new file mode 100644 index 0000000..1d11e66 --- /dev/null +++ b/main/Kconfig.projbuild @@ -0,0 +1,83 @@ +menu "Example Configuration" + + config EXAMPLE_LCD_I80_COLOR_IN_PSRAM + bool "Allocate color data from PSRAM" + depends on IDF_TARGET_ESP32S3 + default y + help + Enable this option if you wish to allocate the color buffer used by LVGL from PSRAM. + Unmatched PSRAM band width with LCD requirement can lead to blurred image display. + + choice EXAMPLE_LCD_I80_CONTROLLER_MODEL + prompt "i80 LCD controller model" + default EXAMPLE_LCD_I80_CONTROLLER_ST7789 + help + Select LCD controller model + + config EXAMPLE_LCD_I80_CONTROLLER_ST7789 + bool "ST7789" + + config EXAMPLE_LCD_I80_CONTROLLER_NT35510 + bool "NT35510" + + config EXAMPLE_LCD_I80_CONTROLLER_ILI9341 + bool "ILI9341" + endchoice + + if EXAMPLE_LCD_I80_CONTROLLER_NT35510 + choice EXAMPLE_LCD_NT35510_DATA_WIDTH + prompt "NT35510 Data Width" + default EXAMPLE_LCD_NT35510_DATA_WIDTH_8 + help + Select NT35510 Data Width (8 or 16), a.k.a, the number of data lines. + + config EXAMPLE_LCD_NT35510_DATA_WIDTH_8 + bool "8" + + config EXAMPLE_LCD_NT35510_DATA_WIDTH_16 + bool "16" + endchoice + + endif + + config EXAMPLE_LCD_I80_BUS_WIDTH + int + default 16 if EXAMPLE_LCD_NT35510_DATA_WIDTH_16 + default 8 + + config EXAMPLE_LCD_TOUCH_ENABLED + bool "Enable LCD touch" + default n + help + Enable this option if you wish to use display touch. You can select from three touch controllers. + + choice EXAMPLE_LCD_TOUCH_CONTROLLER + prompt "LCD touch controller model" + depends on EXAMPLE_LCD_TOUCH_ENABLED + default EXAMPLE_LCD_TOUCH_CONTROLLER_FT5X06 + help + Select LCD touch controller model + + config EXAMPLE_LCD_TOUCH_CONTROLLER_GT911 + bool "GT911" + + config EXAMPLE_LCD_TOUCH_CONTROLLER_TT21100 + bool "TT21100" + + config EXAMPLE_LCD_TOUCH_CONTROLLER_FT5X06 + bool "FT5X06" + endchoice + + choice EXAMPLE_LCD_IMAGE_SOURCE + prompt "LCD image source from" + default EXAMPLE_LCD_IMAGE_FROM_EMBEDDED_BINARY + help + Select LCD image source + + config EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM + bool "File system" + + config EXAMPLE_LCD_IMAGE_FROM_EMBEDDED_BINARY + bool "Embedded binary" + endchoice +endmenu diff --git a/main/ParseWorld.cpp b/main/ParseWorld.cpp new file mode 100644 index 0000000..c38ac4a --- /dev/null +++ b/main/ParseWorld.cpp @@ -0,0 +1,236 @@ +#include + +#include "structures.h" +#include "ParseWorld.h" +#include "esp_log.h" +#include "esp_heap_caps_init.h" + +//extern std::vector world; +extern std::vector world; // An unsized vector of layouts which can contain multiple frames +extern std::vector the_layouts; // Global presently but not good idea + +// Takes an average of the whole texture to retun an average shade +// As images are gamma adjusted it's not ideal to do a mean but it is sufficient +// Ns is sent from the blender roughness +uint32_t AvgCol(const uint32_t * bitmap_ptr, const uint32_t size, const uint32_t Ns) +{ +static const char *TAG = "avgcol"; +//ESP_LOGI(TAG,"offset %p",bitmap_ptr); +//ESP_LOG_BUFFER_HEX_LEVEL(TAG, bitmap_ptr, 128, (esp_log_level_t)1); // Dump 128 bytes + + // Keep track of the totals, 32 bit is sufficient up to 4k x 4k texture + uint32_t tot_red = 0,tot_green = 0, tot_blue = 0; + //uint32_t tot_Ns = 0x80 ; // Default roughness value + + for (uint32_t i = 0; i < size; i++) + { + uint32_t pixel = bitmap_ptr[i]; + // get each of the colour values and add it on + tot_red += (pixel & 0x00ff0000) >> 16; + tot_green += (pixel & 0x0000ff00) >> 8; + tot_blue += (pixel & 0x000000ff) >> 0; // Shift for illustration + } + // Do the averages and mask just to be safe + tot_red = 0xff & (tot_red / size); + tot_green = 0xff & (tot_green / size); + tot_blue = 0xff & (tot_blue / size); + + // rebuild the RGB + //uint32_t rgb_out = (tot_Ns << 24) | (tot_red<<16) | (tot_green<<8) | (tot_blue); + uint32_t rgb_out = (Ns & 0xff000000) | (tot_red<<16) | (tot_green<<8) | (tot_blue); + return (rgb_out); +} + +// Work through the partition world header to understand what is there +// and build structures that describe each of the worlds +// Enter with a pointer to the partition +void ParseWorld(const void * w_ptr , const void * texture_map_ptr ) +{ +static const char *TAG = "ParseWorld"; + + EachLayout temp_layout; + uint32_t member; + + world_partition_header * world_partition_header_ptr = (world_partition_header *) w_ptr; + uint32_t * descriptor_ptr = (uint32_t *) & (world_partition_header_ptr->world_start); + + // Loop until zero, the end marker + while ((member = * descriptor_ptr)) { + + //ESP_LOGI(TAG, "member is %x", (unsigned int) member); + // The first read member SHOULD be a descriptor + if (! (member & 0x10000000)) assert ("Error parsing descriptor"); + + // It is a descriptor so a fresh layout follows + + temp_layout.frame_layouts.clear(); // Clear the vector part of the temp_layout for each new layout + const uint32_t frames = (member & 0x00ff0000) >> 16; // Extract the frame count + temp_layout.frames = frames; // Store how many frames are in this layout + + descriptor_ptr ++ ; // Step to first offset value + + // Loop through the frame layouts + for (unsigned int frame_i = 0 ; frame_i < frames ; frame_i++) + { + const uint32_t offset = * descriptor_ptr; + //ESP_LOGI(TAG,"Offset is %x",(unsigned int)offset); + //ESP_LOGI(TAG, "looking at %p",(void *)(w_ptr + offset)); + + // Interpret a layout and push its structure into a vector of frames + temp_layout.frame_layouts.push_back(ReadWorld(w_ptr + offset, texture_map_ptr)); + + descriptor_ptr++; // Go to the next offset + } + // All of the offsets have been read now so push that layout + world.push_back(temp_layout); // Store the layout we have just read + } // End of while (member) +}; // End of ParseWorld + +// Input a pointer into the partition, read the values, adjust offsets to build a temporary structure +// This is then pushed into a global vector so we don't need to track indicies here +// Using a vector is better C++ practice than malloc and we don't need to know that this is DMA-friendly RAM +WorldLayout ReadWorld(const void * w_ptr , const void * texture_map_ptr) +{ + static const char *TAG = "ReadWorld"; + + const part_faceMaterials * temp_thin_palette; // To access the thin palette in the word partition + const uint8_t * tex_ptr; // Use a byte wise at present + const uint8_t * w_map_ptr = (uint8_t *) w_ptr; // Cast for use + + // Uses a structure into partition header to save a lot of pointer messing + WorldLayout temp_world; // A temp_world will be defined to be later pushed into the vector + + // Base address of this world strcture in the partition is indicated by w_map_ptr + // Make and cast a new pointer (which is at the same location in memory to read nicely + world_header * world_header_ptr = (world_header *) w_map_ptr; + + temp_world.vertices = (Vec3f *) (w_map_ptr + world_header_ptr->vertices); + temp_world.nvertices = (uint16_t *) (w_map_ptr + world_header_ptr->nvertices); + temp_world.vts = (Vec2f *) (w_map_ptr + world_header_ptr->vts); + temp_world.texel_verts = (uint16_t *) (w_map_ptr + world_header_ptr->texels); + temp_world.attributes = (uint16_t *) (w_map_ptr + world_header_ptr->attributes); + + ESP_LOGI(TAG,"Attributes are at %p",temp_world.attributes); + + // Find the thin palette in the world binary and build a proper palette in RAM + ESP_LOGI(TAG,"Palette offset is %p",(void *)world_header_ptr->thin_palette); + const uint32_t * part_palette_ptr = (uint32_t const *)(w_map_ptr + world_header_ptr->thin_palette); + const uint32_t pal_nmats = * part_palette_ptr; // Fetch the size of the thin palette in the partition + temp_thin_palette = (const part_faceMaterials *) (part_palette_ptr + 1); // Start a structured thin palette + + ESP_LOGI(TAG,"Working on a palette with %d entries",(int)pal_nmats); + faceMaterials * world_palette_ptr = (faceMaterials *) heap_caps_malloc(sizeof(faceMaterials) * pal_nmats , MALLOC_CAP_INTERNAL | MALLOC_CAP_32BIT); + if (world_palette_ptr == NULL) assert ("Failed to malloc world palette"); + + temp_world.palette = world_palette_ptr; // Place ptr for the RAM palette in world structure + + //ESP_LOG_BUFFER_HEX_LEVEL(TAG, (texture_map_ptr+ 0x00000), 128, (esp_log_level_t)1); // Dump 128 bytes + + // Open texture partition with a byte pointer so offsets make sense without adjustment + tex_ptr = (uint8_t *)texture_map_ptr; // cast to suit + + // The palette texture pointers need to be updated with new memory mapping + ESP_LOGI(TAG,"Calculating texture offsets and making average shade"); + + for(int i=0;ichunks),0x10,(esp_log_level_t)1); + + int16_t * chunk_param_ptr = (int16_t *)(w_map_ptr + world_header_ptr->chunks); + + // Chunk parameters copied from partition into the structure + temp_world.ChAr.xmin = * (chunk_param_ptr + 0); + temp_world.ChAr.zmin = * (chunk_param_ptr + 1); + temp_world.ChAr.xcount = * (chunk_param_ptr + 2); + temp_world.ChAr.zcount = * (chunk_param_ptr + 3); + temp_world.ChAr.size = * (chunk_param_ptr + 4); + + // calculate the size of the chunk map array based on its components + int16_t chunk_map_size = temp_world.ChAr.xcount * temp_world.ChAr.zcount * (sizeof(uint16_t *) + sizeof(uint32_t)); + + //ESP_LOGI(TAG, "Chunk map size in bytes is %d",chunk_map_size); + + // make memory for the map, point to it from world struct + temp_world.TheChunks = (ChunkFaces *) heap_caps_malloc(chunk_map_size , MALLOC_CAP_INTERNAL | MALLOC_CAP_32BIT); + if (temp_world.TheChunks == NULL) assert ("Chunk table malloc failed"); + + // Find the start of the chunk map in the partition + constexpr uint32_t chunk_header_size = sizeof(uint16_t) * 6; // 5 values plus 1 padding + + uint8_t * temp_ch_ptr = (uint8_t *) chunk_param_ptr; // Cast to byte size to keep arithetic in line + uint32_t * chunk_map_ptr = (uint32_t *) (temp_ch_ptr + chunk_header_size); // Ptr to read from the map + + // Do a looped copy so that pointers can be updated as it happens using offsets in the binary + // The chunk map will then point to chunk list in flash partition + for (uint32_t ch_index = 0; ch_index < temp_world.ChAr.xcount * temp_world.ChAr.zcount ; ch_index++) + { + // Adapt to copy face lists into arrays in heap + + // Fetch the pointer to the list of faces, and step to the count + uint16_t * const faces_ptr = (uint16_t *)(temp_ch_ptr + (* chunk_map_ptr)); chunk_map_ptr++; + + // Fetch the count and step for next chunk + const uint32_t face_count = * chunk_map_ptr; chunk_map_ptr++; + + //ESP_LOGI(TAG,"Chunk index %d and face count is %d",(int)ch_index, (int)face_count); + + temp_world.TheChunks[ch_index].face_count = face_count; + if (face_count == 0) continue; // No faces in this chunk so don't do malloc etc + + // malloc enough space for the count and put the address in the pointer area + uint16_t * temp_chunk_face_ptr = (uint16_t *) heap_caps_malloc(face_count * sizeof(uint16_t) , MALLOC_CAP_INTERNAL); + if (temp_chunk_face_ptr == NULL) assert ("Chunk face list malloc failed"); + temp_world.TheChunks[ch_index].faces_ptr = temp_chunk_face_ptr; + + // Copy array of faces from the partition to the RAM + for (uint32_t i = 0; i < face_count; i++) + { + //ESP_LOGI(TAG,"face in chunk %d",(int)faces_ptr[i]); + temp_chunk_face_ptr[i] = faces_ptr[i]; + } + } // End of for to each chunk + + // Return the world layout that's been built + return(temp_world); +}; // End of ReadWorld \ No newline at end of file diff --git a/main/RasteriseBox.cpp b/main/RasteriseBox.cpp new file mode 100644 index 0000000..46e6c0e --- /dev/null +++ b/main/RasteriseBox.cpp @@ -0,0 +1,525 @@ +#include +#include + +#include "esp_log.h" +#include "esp_random.h" +//#include "esp_dsp.h" + +#include "globals.h" +#include "geometry.h" +#include "structures.h" + +#include "ShowError.h" + +#include "RasteriseBox.h" + +float* depthBuffer; // depthBuffer restricted in scope to this unit, albeit globally +extern uint16_t * frame_buffer_this; + +#define TEXTURE_DEPTH_THRESHOLD 22.f // Depth at which textures are disabled and base colour sent + +// ************************************************************************************************ +// Start with various support functions for rasteriser + +void MakeDepthBuffer() +{ + depthBuffer = (float*)malloc(sizeof(float) * g_scWidth * g_scHeight); + if (!depthBuffer) + { + show_error("Failed to allocate depth buffer"); + } +} + +void ClearDepthBuffer(float farPlane) +{ + // Passing farPlane as we may use it dynamically to affect redraw speed + // Clear the depth buffer to a high z now we are using this rather than 1/w + for (int pixel = 0; pixel < g_scWidth * g_scHeight; ++pixel) + { + depthBuffer[pixel] = farPlane; + } +} + +void CheckCollide(Near_pix * near) +{ + // Just scan part of the area as an 'eyeline' + + //uint32_t collide_colour; + + // Aim to do calculation at compile time, divides invovled! + constexpr uint32_t y_start = g_scHeight / 5; + constexpr uint32_t y_end = 3 * g_scHeight / 5; + constexpr uint32_t x_start = g_scWidth / 4; + constexpr uint32_t x_end = 3 * g_scWidth / 4; + + near->depth = farPlane; // Initial value for nearest is farClip of view + + for (uint32_t y = y_start; y < y_end; y = y + 2) + { + for (uint32_t x = x_start + (y%4); x < x_end; x = x + 4) + { + if (depthBuffer[y * g_scWidth + x] < near->depth) + { + near->depth = depthBuffer[y * g_scWidth + x]; + near->x = x; // Store the point that is the nearest + near->y = y; + } + /* + { // Just for illustration, colour each test point + collide_colour = 0x0000ff00; + if (depthBuffer[y * g_scWidth + x] < COLLISION_DISTANCE * 1.5f) collide_colour = 0x000000ff; + if (depthBuffer[y * g_scWidth + x] < COLLISION_DISTANCE) collide_colour = 0x00ff0000; + } + WritePixel888(y * g_scWidth + x, collide_colour, 1.0f); + */ + } + } + //return(nearest); // return the distance of the nearest scanned point +} + + +// Here we only check the edge function and will increment it elsewhere +// has been inline +bool CheckEdgeFunction(const Vec3f& E, const float result) +{ + // Apply tie-breaking rules on shared vertices in order to avoid double-shading fragments + if (result > 0.0f) return true; + else if (result < 0.0f) return false; + + // These tests only done if result is zero which seems highly improbable + // A breakpoint here is never used in the benchmark view + if (E.x > 0.f) return true; + else if (E.x < 0.0f) return false; + + if ((E.x == 0.0f) && (E.y < 0.0f)) return false; + else return true; +} + +// ************************************************************************************************ +// Rasterises a primitive triangle using passed struct with edge checking and +// interpolating z and UV mapping +//uint32_t RasteriseBox(const TriToRaster& tri) +void RasteriseBox(const TriToRaster & tri) +{ + //static const char *TAG = "RasteriseBox"; + const uint32_t idx = tri.idx; // idx is used so many times it makes sense to have this stage, compiler might delete it? + const Rect2D TriBoundBox = tri.BoBox; + const Matrix33f invM = tri.invM; + uint32_t this_colour = 0; // This will be filled with face or texture colour + + //WorldLayout layo = *tri.layout; // Find the layout structure from the ptr passed to here + const WorldLayout* layo_ptr = tri.layout; + + //uint32_t pixels_done = 0; // Track the load + + // M determinant and inverse used to be calculated here but better to pass invM in and backface cull in CheckTriangles + + // Set up edge functions based on the vertex matrix + Vec3f E0 = { invM[0][0], invM[0][1], invM[0][2] }; + Vec3f E1 = { invM[1][0], invM[1][1], invM[1][2] }; + Vec3f E2 = { invM[2][0], invM[2][1], invM[2][2] }; + + + // Calculate constant function to interpolate 1/w + //Vec3f C; + //invM.multVecMatrix(Vec3f(1, 1, 1), C); + const Vec3f C = tri.C; + + // Calculate z interpolation vector + // tri.clip_zs is equivalent of sample Vec3f shown + // invM.multVecMatrix(Vec3f(v0Clip.z, v1Clip.z, v2Clip.z), Z); + + // Calculate z interpolation vector + //Vec3f Z; + //invM.multVecMatrix(tri.clip_zs, Z); + const Vec3f Z = tri.Z; + + // Fetch the shading overview for the triangle + const Shade_params surface = tri.face_brightness; + + // This has been pulled out of the pixel loop as it is sufficient to do once per box (or actually per triangle) + Vec3f PUVS, PUVT; // They have to be declared is the later IF doesn't know if they are needed! + bool Texturise = false; // Is the box valid for a texture, a size test was trialled but at 128x128px some triangles are only 1 px! + // If it is small then just use base colour + + if (layo_ptr->palette[layo_ptr->attributes[idx]].width && (TriBoundBox.m_MaxX-TriBoundBox.m_MinX) > 6 && (TriBoundBox.m_MaxY-TriBoundBox.m_MinY) > 6) + { + Texturise = true; + // Calculate UV interpolation vector + invM.multVecMatrix(Vec3f(layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 0]].x, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 1]].x, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 2]].x), PUVS); + invM.multVecMatrix(Vec3f(layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 0]].y, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 1]].y, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 2]].y), PUVT); + } + else + { + // Read the face colour from the palette which will be used for untextured primitives + this_colour = layo_ptr->palette[layo_ptr->attributes[idx]].rgb888; + // Adjust primitive colour based on surface diffuse and specular components + + this_colour = spec_shade_pixel (this_colour, surface); + } + //if ( &(layo_ptr->attributes[idx]) & 0x01 ) ESP_LOGI(TAG, "Odd attribute address ****"); + // sample for the edge function at the first pixel for this rectangle + Vec3f StartSample = { (unsigned int)TriBoundBox.m_MinX + 0.5f, (unsigned int)TriBoundBox.m_MinY + 0.5f, 1.0f }; + + // Do the first EvaluateEdgeFunction + float EdgeFirst0 = (E0.x * StartSample.x) + (E0.y * StartSample.y) + E0.z; + float EdgeFirst1 = (E1.x * StartSample.x) + (E1.y * StartSample.y) + E1.z; + float EdgeFirst2 = (E2.x * StartSample.x) + (E2.y * StartSample.y) + E2.z; + + // w and z can be estimated incrementally too which saves multiplication + float oneOverWFirst = (C.x * StartSample.x) + (C.y * StartSample.y) + C.z; + + // Interpolate z that will be used for depth test + float zOverWFirst = (Z.x * StartSample.x) + (Z.y * StartSample.y) + Z.z; + + // Start rasterizing by looping over pixels to output a per-pixel color + for (unsigned int y = (unsigned int)TriBoundBox.m_MinY; y < TriBoundBox.m_MaxY; y++) + { + float EdgeRes0 = EdgeFirst0; // EdgeFirst will be incremented by y values + float EdgeRes1 = EdgeFirst1; + float EdgeRes2 = EdgeFirst2; + + float oneOverW = oneOverWFirst; + float zOverW = zOverWFirst; + + // Once the edge function shows that the scan has exited the triangles then the line can be quit + bool x_inside = 0; + for (unsigned int x = (unsigned int)TriBoundBox.m_MinX; x < TriBoundBox.m_MaxX; x++) + { + //pixels_scanned++; // How many pixels in all of the bounding boxes + // sample for the edge function at every pixel + Vec3f sample = { x + 0.5f, y + 0.5f, 1.0f }; + + // In simplest implementation the edge functions would be evaluated here for every pixel + // but as they are linear functions it is more efficient to increment by pre-calculated + // values for each x and y step + // The result is slightly different which isn't surprising with floating point math + + + // Edge function incremented at end of both x and y pixel loops + // These checks in function is shown as a major impact in the profiler + // So give opportunities to not take the test, reduces load from 12% to 8 % + // The progressive 'if' is faster than doing all 3 everytime + + bool inside0 = 0, inside1 = 0, inside2 = 0; + + if ( (inside0 = CheckEdgeFunction(E0, EdgeRes0)) ) + { + if ( (inside1 = CheckEdgeFunction(E1, EdgeRes1)) ) + { + inside2 = CheckEdgeFunction(E2, EdgeRes2); + } + } + + // If sample is "inside" of all three half-spaces bounded by the three edges of the triangle + // it's 'on' the triangle + // This test is redundant after the tests above but there is an 'else' dependent on it + if (inside0 && inside1 && inside2) + // Perhaps need to add stuff from https://tayfunkayhan.wordpress.com/2019/07/26/chasing-triangles-in-a-tile-based-rasterizer/ + { + // We are drawing pixels inside now; + x_inside = 1; + + // w and z are estimated incrementally too which saves multiplication + // as per the edge function they will be incremented at the end of each loop + + float w = 1 / oneOverW; + float z = zOverW * w; + + // Previously 1/w was used as a surrogate for depth but that doesn't allow true + // prespective mapping so true z interpolation added as per 'GoWild.h' sample + // as this is crucial for correct texture or normal mapping + if (z <= depthBuffer[x + y * g_scWidth]) + { + // Sensible to only consider texture if depth test passed + + // Depth test passed; update depth buffer value + depthBuffer[x + y * g_scWidth] = z;// oneOverW previously; + + // If the Texture table has a width then the flag will be set and the material is texture mapped + if (Texturise) + { + if (z < TEXTURE_DEPTH_THRESHOLD) // Don't texturise if too far away + { + // Interpolate texture coordinates + float uOverW = abs((PUVS.x * sample.x) + (PUVS.y * sample.y) + PUVS.z); + float vOverW = abs((PUVT.x * sample.x) + (PUVT.y * sample.y) + PUVT.z); + + Vec2f texCoords = Vec2f(uOverW, vOverW) * w; // {u/w, v/w} * w -> {u, v} + // Now fetch from the image + + uint32_t idxS = static_cast((texCoords.x - static_cast(texCoords.x)) * layo_ptr->palette[layo_ptr->attributes[idx]].width - 0.5f); + uint32_t idxT = static_cast((texCoords.y - static_cast(texCoords.y)) * layo_ptr->palette[layo_ptr->attributes[idx]].height - 0.5f); + + // Flip y over as world and bitmap have opposite y-axes, it isn't expensive in time, less than 1ms per frame + // uint32_t image_idx = ((layo_ptr->palette[layo_ptr->attributes[idx]].height - idxT) * layo_ptr->palette[layo_ptr->attributes[idx]].width + idxS); + // The flip is not required actually, no bad thing, one fewer operation per pixel! + uint32_t image_idx = (idxT * layo_ptr->palette[layo_ptr->attributes[idx]].width + idxS); + + // Fetch the pointer to the texture image and then get the relevant pixel + const uint32_t* this_colour_ptr = layo_ptr->palette[layo_ptr->attributes[idx]].image; + this_colour = this_colour_ptr[image_idx]; + } + else + { + // Read the face colour + this_colour = layo_ptr->palette[layo_ptr->attributes[idx]].rgb888; // read the palette + } + this_colour = spec_shade_pixel (this_colour, surface); + } + // Send the pixel and its shading + WritePixel2Fog888(g_scWidth * y + x, this_colour, z); + } // end of depth check + + } // end of inside check + else + { + if (x_inside) + // This is true if last check was inside and now we're outside, with a convex triangle + // it indicates that no more edge tests are required on this x scan so break to next y + { + break; // This gives up to 9% reduction when box is applied previously + } + } //end of being outside triangle + EdgeRes0 += E0.x; // Incremental increase on x axis + EdgeRes1 += E1.x; + EdgeRes2 += E2.x; + + oneOverW += C.x; // Incremental increase of barycentric coordinates on x axis + zOverW += Z.x; + } // end of x pixel scan + EdgeFirst0 += E0.y; // Incremental increase on y axis + EdgeFirst1 += E1.y; + EdgeFirst2 += E2.y; + + oneOverWFirst += C.y; // Incremental increase of barycentric coordinates on y axis + zOverWFirst += Z.y; + } // end of y pixel scan +// return(pixels_done); // Return how much was shown +} // End of RasteriseBox + +// ************************************************************************************************ +// Rasterises a primitive triangle using passed struct WITHOUT edge checking as it's +// only called for TA (totally accepted) tiles, it does interpolate z and UV mapping +void NotRasteriseBox(const TriToRaster & tri) +{ +// Rasterise without edge checking as tile is 'Trivial Accept', but otherwise as RasteriseBox + //static const char *TAG = "NotRasteriseBox"; + const uint32_t idx = tri.idx; + const Rect2D TriBoundBox = tri.BoBox; + const Matrix33f invM = tri.invM; + bool Texturise = false; // Is the box valid for a texture, a size test was trialled but at 128x128px some triangles are only 1 px! + uint32_t this_colour = 0; // This will be filled with face or texture colour + + const WorldLayout* layo_ptr = tri.layout; // Find the layout structure from the ptr passed to here + + // M determinant and inverse used to be calculated here but better to pass invM in and backface cull in CheckTriangles + // Likewise C and Z fetched rather than calcuated + const Vec3f C = tri.C; // Constant function to interpolate 1/w + const Vec3f Z = tri.Z; // Fetch z interpolation vector + + const Shade_params surface = tri.face_brightness; + + // This has been pulled out of the pixel loop as it is sufficient to do once per box (or actually per triangle) + Vec3f PUVS, PUVT; // They have to be declared is the later IF doesn't know if they are needed! + if (layo_ptr->palette[layo_ptr->attributes[idx]].width && (TriBoundBox.m_MaxX-TriBoundBox.m_MinX)>3 && (TriBoundBox.m_MaxY-TriBoundBox.m_MinY)>3) + { + // Calculate UV interpolation vector + invM.multVecMatrix(Vec3f(layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 0]].x, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 1]].x, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 2]].x), PUVS); + invM.multVecMatrix(Vec3f(layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 0]].y, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 1]].y, layo_ptr->vts[layo_ptr->texel_verts[idx * 3 + 2]].y), PUVT); + + //diffuse = MakeShade(idx,layo_ptr); + + Texturise=true; + } + else + { + // Read the face colour from the palette which will be used for untextured primitives + this_colour = layo_ptr->palette[layo_ptr->attributes[idx]].rgb888; + // Adjust primitve colur based on surface diffuse and psecular components + this_colour = spec_shade_pixel (this_colour, surface); + } + + //if (layo_ptr->attributes[idx] > 20) ESP_LOGI(TAG, "Attribute is %x",layo_ptr->attributes[idx]); + + // sample for UV mapping at the first pixel for this rectangle + Vec3f StartSample = { (unsigned int)TriBoundBox.m_MinX + 0.5f, (unsigned int)TriBoundBox.m_MinY + 0.5f, 1.0f }; + + // w and z can be estimated incrementally too which saves multiplication + float oneOverWFirst = (C.x * StartSample.x) + (C.y * StartSample.y) + C.z; + + // Interpolate z that will be used for depth test + float zOverWFirst = (Z.x * StartSample.x) + (Z.y * StartSample.y) + Z.z; + + // An incremented x and y was tried but made no speed difference + // but it was harder to read code so removed + + for (unsigned int y = (unsigned int)TriBoundBox.m_MinY; y < TriBoundBox.m_MaxY; y++) + { + float oneOverW = oneOverWFirst; + float zOverW = zOverWFirst; + + for (unsigned int x = (unsigned int)TriBoundBox.m_MinX; x < TriBoundBox.m_MaxX; x++) + { + //pixels_scanned++; // How many pixels in all of the bounding boxes + // sample for interpolation at every pixel + Vec3f sample = { x + 0.5f, y + 0.5f, 1.0f }; + + // w and z are estimated incrementally too which saves multiplication + // as per the edge function they will be incremented at the end of each loop + + float w = 1 / oneOverW; + float z = zOverW * w; + + if (z <= depthBuffer[x + y * g_scWidth]) + { + // Sensible to only consider texture if depth test passed + + // Depth test passed; update depth buffer value + depthBuffer[x + y * g_scWidth] = z; + + // Starting on Texture + // If the Texture table has a width then the material is texture mapped + if (Texturise) + { + if (z {u, v} + // Now fetch from the image + // Simplifed from 64 bit, can't see a point in this! + // uint32_t idxS = static_cast((texCoords.x - static_cast(texCoords.x)) * layo_ptr->palette[layo_ptr->attributes[idx]].width - 0.5f); + // uint32_t idxT = static_cast((texCoords.y - static_cast(texCoords.y)) * layo_ptr->palette[layo_ptr->attributes[idx]].height - 0.5f); + + uint32_t idxS = static_cast((texCoords.x - static_cast(texCoords.x)) * layo_ptr->palette[layo_ptr->attributes[idx]].width - 0.5f); + uint32_t idxT = static_cast((texCoords.y - static_cast(texCoords.y)) * layo_ptr->palette[layo_ptr->attributes[idx]].height - 0.5f); + + + uint32_t image_idx = (idxT * layo_ptr->palette[layo_ptr->attributes[idx]].width + idxS); + + // Fetch the pointer to the texture image and then get the relevant pixel + const uint32_t* this_colour_ptr = layo_ptr->palette[layo_ptr->attributes[idx]].image; + this_colour = this_colour_ptr[image_idx]; + } + else + { + // Read the face colour for distant textured primitive + this_colour = layo_ptr->palette[layo_ptr->attributes[idx]].rgb888; // read the palette + } + this_colour = spec_shade_pixel (this_colour, surface); + } + //Put the pixel into a 16 bit sprite buffer, using previous shading and z for fog + WritePixel2Fog888(g_scWidth * y + x, this_colour, z); + } // end of depth check + oneOverW += C.x; // Incremental increase of barycentric coordinates on x axis + zOverW += Z.x; + } // end of x pixel scan + oneOverWFirst += C.y; // Incremental increase of barycentric coordinates on y axis + zOverWFirst += Z.y; + } // end of y pixel scan +} // End of NotRasteriseBox + +// ************************************************************************************************ +// Function to write pixels to a buffer, mixes the rgb with fog based on depth +// No merit being in IRAM + +void WritePixel2Fog888(const uint32_t frame_index, const uint32_t rgb888, const float depth) +// Takes rgb in 888 format, which has already been adjusted by the shade +// Mixes with the fog and finally converts to rgb565 + +// One may consider that textures and palettes should be in 565 format but +// although it would save space in memory would it be any faster as it would +// still need unpacking for shading and then repacking? + +// It was tried with a struct that contained seperate rgb to save the unpacking and packing between +// functions but there was no apparent speed improvement and it's less adaptable +{ + // The background colour for clearing screen which will also be fog + extern const uint32_t fog; + + // These would be nice as constexpr but can't make it work + // Static makes it VERY slow!! + const uint32_t fog_red = (fog & 0x00ff0000) >> 16; + const uint32_t fog_green = (fog & 0x0000ff00) >> 8; + const uint32_t fog_blue = (fog & 0x000000ff); + + // There may be vector math optimisation to make here but previous attempts not encouraging + const uint32_t pix_red = (rgb888 & 0x00ff0000) >> 16; + const uint32_t pix_green = (rgb888 & 0x0000ff00) >> 8; + const uint32_t pix_blue = (rgb888 & 0x000000ff) >> 0; + + uint32_t fog_depth = (uint32_t) (255.f * FogFunction(depth)); + + // intmix is for integers and has 'a' of 0 to 255, returns with value <<8 + const uint32_t fogged_red = intmix(fog_red , pix_red , fog_depth); + const uint32_t fogged_green = intmix(fog_green , pix_green , fog_depth); + const uint32_t fogged_blue = intmix(fog_blue , pix_blue , fog_depth); + + // Shift to divide by 'a' in intmix + uint16_t rgb565 = ((fogged_red) & 0b1111100000000000) | ((fogged_green >> 5) & 0b0000011111100000) | ((fogged_blue >> 11) & 0b0000000000011111); + + // Using ESP-IDF the DMA routine will do the byte swap so here can be standard pack to 565 + // We have a pixel in 565 format so send it to the appropriate viewer + frame_buffer_this[frame_index] = rgb565; +} // end of WritePixel2Fog888 + +// adjusts input rgb according to surface shade for simple specular and diffuse illumination +// ideally worked on a face level for non-textured primitives +//uint32_t spec_shade_pixel (const uint32_t rgb888, const Vec2f surface_shade) +uint32_t spec_shade_pixel (const uint32_t rgb888, const Shade_params surface_shade) +{ + const uint32_t intShade = surface_shade.lamb; + const uint32_t intSpecular = surface_shade.spec; // Adds white/grey rather than an incident light colour + + // I'm not sure if these values can overflow?? + // Assumes that the reflected light is white so equal addition to each rgb channel + + /* + const uint32_t pix_red = std::min(((intShade * (rgb888 & 0x00ff0000)) >> 24) + intSpecular, (uint32_t) 0xff); + const uint32_t pix_green = std::min(((intShade * (rgb888 & 0x0000ff00)) >> 16) + intSpecular, (uint32_t) 0xff); + const uint32_t pix_blue = std::min(((intShade * (rgb888 & 0x000000ff)) >> 8) + intSpecular, (uint32_t) 0xff); + */ + const uint32_t pix_red = ((intShade * (rgb888 & 0x00ff0000)) >> 24) + intSpecular; + const uint32_t pix_green = ((intShade * (rgb888 & 0x0000ff00)) >> 16) + intSpecular; + const uint32_t pix_blue = ((intShade * (rgb888 & 0x000000ff)) >> 8) + intSpecular; + + const uint32_t temp_rgb888 = (pix_red << 16) | (pix_green << 8) | (pix_blue); + + return (temp_rgb888); +} // End of spec_shade_pixel + +// Although the fpu is great at fp multiple there are issues on casting to and from floats +// as that is complex with many considerations +// 'a' is in the range 0 to 255 +// inline is worth a few ms per frame here +inline uint32_t intmix(const uint32_t x, const uint32_t y, const uint32_t a) +{ + return (x * (255-a) + y * a); +} + +// Linear fog presently, calculated live +float FogFunction(float const depth) +{ + constexpr float start = 5.0f; + constexpr float end = 30.0f; + constexpr float divisor = 1/(end-start); // Known at compile time, a division avoided + + float fog_temp = (end-depth) * divisor; + return (std::clamp(fog_temp , 0.f , 1.f)); +} + +// Clear frame buffer to fog background colour +void ClearWorldFrame(uint16_t * frame_buffer) +{ +extern const uint16_t BackgroundColour; // = ((fog >> 8) & 0b1111100000000000) | ((fog >> 5) & 0b0000011111100000) | ((fog >> 3) & 0b0000000000011111); + + // memset() is char-based, could make this uint32_t perhaps? + for (int i=0; i < g_scWidth * g_scHeight; i++) + { + frame_buffer[i] = BackgroundColour; // Background colour + } +} // End of ClearWorldFrame \ No newline at end of file diff --git a/main/ShowError.cpp b/main/ShowError.cpp new file mode 100644 index 0000000..fc738a2 --- /dev/null +++ b/main/ShowError.cpp @@ -0,0 +1,12 @@ +// All catch messages will be sent to here for showing and then hold, no recovery options +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" + +void show_error(const char* error_string) +{ + printf("ERROR: %s",error_string); + + vTaskDelay(10*1000/portTICK_PERIOD_MS); + esp_restart(); +} \ No newline at end of file diff --git a/main/ShowWorld.cpp b/main/ShowWorld.cpp new file mode 100644 index 0000000..ec93386 --- /dev/null +++ b/main/ShowWorld.cpp @@ -0,0 +1,359 @@ +#include +#include +#include +#include + +#include "driver/gpio.h" +#include "esp_timer.h" +#include "esp_err.h" +#include "esp_log.h" +#include "esp_cache.h" + +//#include "esp_lcd_panel_io.h" +//#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" + +#include +//#include +#include "freertos/event_groups.h" + +#include "geometry.h" +#include "structures.h" +#include "globals.h" +#include "buttons.h" +#include "events_global.h" + +#include "TriangleQueues.h" // For EmptyQueue +#include "ChunkChooser.h" +#include "CheckTriangles.h" +#include "RasteriseBox.h" +#include "EventManager.h" + +#include "ShowWorld.h" + +extern std::vector world; // An unsized vector of layouts each of which can contain multiple frames + +// Position and movement are global +extern Vec3f eye; +extern float eye_level; +extern Vec3f direction; + +extern Time_tracked time_report; // Health and fps etc for reporting +extern QueueHandle_t game_event_queue; // A FreeRTOS queue to pass game play events from world to manager + +// This module maintains the 2D overlay description but not the actual buffer +TwoD_overlay score_overlay; + +bool OverlayFlag = false; + +void ShowWorld(void * parameter) +{ +static const char *TAG = "ShowWorld"; +static uint32_t max_pixel_count = 5 * g_scHeight * g_scWidth ; // Pick a start value to initialise +static int64_t elapsed_time = esp_timer_get_time(); // Internal microsecond clock +static uint32_t frame_time; + + +static Vec3f scaled_direction; +float spot_height = 0.0f; // The result of mapping height will be put here +static float old_spot_height = 0.0f; // The previous spot height found +float delta_height = 0.0f; // change in height since last frame; +float fallen = 0.0f; // Accumulate fallen distance at a rate + +static bool control_not_pressed = true; // Track whether player has a control down, if not we can render more! + +WorldLayout * this_world_ptr;// ptr to const world + +xEventGroupSetBits( raster_event_group, GAME_RUNNING); + +ESP_LOGI(TAG, "ShowWorld task about to enter infinite loop"); + +while(1) +{ // Loop forever as a task +//ESP_LOGI(TAG, "ShowWorld task looping"); + +// Manage pingpong +flipped = ! flipped; + +// Needs depth buffer cleared before sending, depth could be adjusted to limit rendering +ClearDepthBuffer(200.0f); // Just the one to clear before rasterise + +// Oddly the rasterising is started at the start of the loop which seems unexpected but sets +// the two threads working nicely +xEventGroupSetBits( raster_event_group, START_RASTER); + +SendFlippedFrame(); + + // Start a new screen render + uint32_t this_frame; // Track frame index + const uint32_t frame_period = (1000 * 100); // A constant period per animation frame + + // Find the eye / viewer's height based on current position + // We assume that the base plan is in world[0] and single frame + // set the pointer to the layout in use + this_world_ptr = & (world[0].frame_layouts[0]); + + // Which chunk is the eye in? We don't need to check deeper + // The moved flag is set true to force check of [0,0] offset + uint32_t base_chunk = ChunkChooser(eye, direction, true, this_world_ptr); + + // Is the location in the world? If not, assume same as before !zero + if (base_chunk == INVALID_CHUNK) spot_height = old_spot_height; // 0.0f; + else + { + // Current location is in the world so find height + spot_height = BaseTriangles(eye, direction, base_chunk, this_world_ptr); + delta_height = spot_height - old_spot_height; // This is an absolute change and will be scaled later + old_spot_height = spot_height; + } + //ESP_LOGI(TAG,"BASE %x SPOT %f",(int)base_chunk,spot_height); + + //ESP_LOGI(TAG, "Spot height is %f",spot_height); + // Adjust eye height based on what has been found + eye.y = spot_height + eye_level; + + // Now the rendering can take place + // reduce the search but don't let it get too small or needlessly big + // 99ms is an arbitrary maximum + // The MCU clock can't be used to limit this as this thread is not rate limiting + max_pixel_count = std::clamp(max_pixel_count+(MAX_FRAME_DURATION-frame_time)*100,(g_scWidth * g_scHeight * 2),(g_scWidth * g_scHeight * 5)); + + + // Start a new screen render + uint32_t count=0; // use as a workload indicator + + uint32_t chunk_index_count = 0; + do + { + // Loop through all of the world layouts to draw the world(s) + for (uint32_t worlds=0 ; worlds < world.size() ; worlds++) + { + // See if the layout has mutiple frames + if (world[worlds].frames > 1 ) + { + // This uses two divides but is conceptually very simple + this_frame = (elapsed_time / frame_period) % world[worlds].frames; + } + else this_frame = 0; // Defaults to the sole first frame + + // set the pointer to the layout in use + this_world_ptr = & (world[worlds].frame_layouts[this_frame]); + + uint32_t my_chunk = IndexChunkChooser(eye, direction,chunk_index_count,this_world_ptr); + if (my_chunk == LAST_CHUNK) goto ChunksDone; // There is nothing more to be found so move on + { + // CheckTriangles returns itself if the chunk is invalid + count += CheckTriangles(eye, direction, my_chunk,this_world_ptr); // Which pushes onto rasteriser queues + } + } // End of world loop + chunk_index_count++; // Go onto the next chunk in the sequence + + } + // Adjust how many chunks are included by pixel estimate + // But keep going if no control pressed + // This will also affect render depth when a key is pressed as complexity is still being estimated + while ((count < max_pixel_count) || control_not_pressed); + +ChunksDone: // A goto is used to reach here to exit from a depth of two loops + // Wait for rasterisation of queue to be finished, that's is the bigger job + + // It is possible that Core 0 does not idle if rasteriser is quick so fore a wdt reset + // so Core 0 WDT is disabled in SDK configuration editor + // as adding a 1 tck vTaskDelay didn't help + + xEventGroupWaitBits( + raster_event_group, // event group handle + RASTER_DONE | CLEAR_READY | GAME_RUNNING, // bits to wait for + pdFALSE, // don't clear the bit once we've started + pdTRUE, // AND for any of the defined bits + portMAX_DELAY ); // block forever + xEventGroupClearBits(raster_event_group, RASTER_DONE | CLEAR_READY); // Clear the bits we want to allow game play + + // Collision is checked by sampling depth buffer in a field of view + // A struct is sent and updated + // Later, if an impact is detected the triangle buffers are run again + // to see which triangle has caused the impact, whilst this has an overhead it is only invoked + // when player is stationary whereas checking and recording the object per pixel + // on every frame would have quite an overhead, although I've not benchmarked it + Near_pix test_pix; + CheckCollide( &test_pix); // check proximity, returns depth + const float nearest = test_pix.depth; // For later use in movement +// Do basic player movement. +// Speed is adjusted by the PREVIOUS frame's duration which isn't perfect but +// we can't predict the NEXT frame build time! + +// Simple direction control adjusted to move at a standardised angular speed +constexpr float rot_factor = M_PI * 0.0003f; +const float rotSpeed = rot_factor * (float)frame_time; + +// At this point scaled_direction is the size it was on the previous frame which +// resulted in delta_height, so we can work out a gradient +float rate_of_ascent = delta_height/scaled_direction.length(); +if (rate_of_ascent < -0.8f) +{ + fallen += delta_height; + //ESP_LOGI(TAG, "Fallen %f",fallen); +} +else +{ + // Stopped falling now, that's the dangerous part + if (fallen < -1.0f) + { + Near_pix temp_event; + const int8_t fall = (uint8_t)round(fallen); + //ESP_LOGI(TAG,"Damage factor %f, %x",fallen,fall); + temp_event.event = EVNT_ENERGY | EE_CHANGE | ((0xff & fall) <palette[test_pix.layout->attributes[test_pix.idx]].event; + + // Check a valid event and also don't allow repeated messages for the same impact + if (this_event && (this_event != last_event)) + { + last_event = this_event; // Note what happened previously + test_pix.event = this_event; // Pass the event code since we've found it already + // Send Near_pix event messsage if present + // Wait for 10 ticks for space to become available if necessary + // This might need to be longer than frame duration? + if( xQueueSend( game_event_queue, ( void * ) &test_pix, ( TickType_t ) 10 ) != pdPASS ) + //if( xQueueSend( game_event_queue, ( void * ) &this_event, ( TickType_t ) 10 ) != pdPASS ) + { + // Failed to post the message, even after 10 ticks. + ESP_LOGI(TAG,"Failed to post item in event queue"); + } + } // End of this_event detected + } // end of found check + else ESP_LOGI(TAG,"Impacted face not found"); // Should be rare occurance + + // Adjust this step so as not to go too far + // The steps are reduced once we're in that close zone + scaled_direction = (nearest - COLLISION_DISTANCE) * 0.2f * scaled_direction; + } // End of nearest + + eye.x += scaled_direction.x; + eye.z += scaled_direction.z; // Don't add on the y element of ther vector + } + else last_event = 0; // reset event record when button lifted +/* +// Reverse is inhibited at the moment as it really needs code to 'look back' +if (!gpio_get_level(CONTROL_DOWN)) + { + eye.x -= scaled_direction.x; + eye.z -= scaled_direction.z; // Don't add on the y element of ther vector + } +*/ +if (!gpio_get_level(CONTROL_RIGHT)) + { + control_not_pressed = false; + if (nearest < COLLISION_DISTANCE) + { + // For turning, push back if too close + eye = eye - (COLLISION_DISTANCE - nearest) * direction; + } + + const float oldDirX = direction.x; + direction.x = direction.x * cos(rotSpeed) - direction.z * sin(rotSpeed); + direction.z = oldDirX * sin(rotSpeed) + direction.z * cos(rotSpeed); + //ESP_LOGI(TAG,"RIGHT"); + } + + +if (!gpio_get_level(CONTROL_LEFT)) + { + control_not_pressed = false; + if (nearest < COLLISION_DISTANCE) + { + // For turning, push back if too close + eye = eye - (COLLISION_DISTANCE - nearest) * direction; + } + const float oldDirX = direction.x; + direction.x = direction.x * cos(-rotSpeed) - direction.z * sin(-rotSpeed); + direction.z = oldDirX * sin(-rotSpeed) + direction.z * cos(-rotSpeed); + //ESP_LOGI(TAG,"LEFT"); + } + +// Find frame refresh duration and update the time + frame_time=(esp_timer_get_time()-elapsed_time)>>10; // Divide by 1024 is near enough and faster + elapsed_time=esp_timer_get_time(); + //ESP_LOGI(TAG, "Frame time is %d ",(int)frame_time); + // Record the frame in the reporting structure + time_report.frames++; + + // Frame buffer is written now and various movements and impacts so this + // is the time to do 2D information overlays if needed + + if (OverlayFlag) OverlayTwoD(score_overlay); + //taskYIELD(); +} // end of loop forever + +} // end of ShowWorld function + +void SendFlippedFrame(void) +{ + // Signal that DMA is use +xEventGroupClearBits( raster_event_group, CLEAR_READY); + +// Display the previously-prepared image from the indicated buffer +// On completion the call back will clear the pushed buffer +// Also empty the triangle queues that will be used by CheckTriangles +// The queues may be needed in this module so removed reset in SendQueue +if (flipped) + { + ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, g_scWidth, g_scWidth, frame_buffer_B)); + EmptyQueue(2); + EmptyQueue(3); + } +else + { + ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(panel_handle, 0, 0, g_scWidth, g_scWidth, frame_buffer_A)); + EmptyQueue(0); + EmptyQueue(1); + } +} // End of SendFlippedFrame \ No newline at end of file diff --git a/main/TimeTracker.cpp b/main/TimeTracker.cpp new file mode 100644 index 0000000..adeced5 --- /dev/null +++ b/main/TimeTracker.cpp @@ -0,0 +1,35 @@ +#include +#include "structures.h" +#include "globals.h" + +#include +#include +#include "freertos/event_groups.h" + +#include "esp_log.h" + +#include "events_global.h" +#include "EventManager.h" + +#include "TimeTracker.h" + +void TimeTrack (TimerHandle_t tracked_handle) +{ + static const char *TAG = "TimeTrack"; + extern QueueHandle_t game_event_queue; // A FreeRTOS queue to pass game play events from world to manager + + extern Time_tracked time_report; + + // Send an update event every tick to subtract -1 (ie 0xff) from energy + Near_pix temp_event; + temp_event.event = EVNT_ENERGY | EE_CHANGE | (0xff < + +#include "esp_log.h" + +#include +#include +#include "freertos/event_groups.h" + +#include "globals.h" +#include "geometry.h" +#include "structures.h" +#include "events_global.h" + +#include "FindHitFace.h" +#include "ShowError.h" +#include "RasteriseBox.h" + +#include "TriangleQueues.h" + +// A global pingpong flag +extern bool flipped; +extern EventGroupHandle_t raster_event_group; +extern uint16_t * frame_buffer_A; +extern uint16_t * frame_buffer_B; + +uint16_t *frame_buffer_this; + +unsigned int max_raster_buf[4]; + +// Reserve space for a minimum of two queues of primitives using struct of TriToRaster +// One for Rasterise triangles and one for NotRasterise tiles +TriQueue BlockA[4]; + +static const char *TAG = "TriangleQueues"; + + +// Manage queues via cores and tasks +void rasteriseTask(void * parameter) +{ + ESP_LOGI(TAG, "Entered rasterise task and waiting"); + + while(1) + { + xEventGroupWaitBits( + raster_event_group, // event group handle + START_RASTER, // bits to wait for + pdTRUE, // clear the bit once we've started + pdTRUE, // AND for any of the defined bits + portMAX_DELAY ); // block forever + //xEventGroupClearBits(raster_event_group, START_RASTER); // retain GAME_RUNNING BIT + + if (flipped) + { + frame_buffer_this=frame_buffer_A; // Set the target frame buffer + ClearWorldFrame(frame_buffer_this); // Perhaps not ideal to do this on rasteriser core? + + SendQueue(0); // Send both queues to the rasteriser + SendQueue(1); + } + else + { + frame_buffer_this=frame_buffer_B; // Set the target frame buffer + ClearWorldFrame(frame_buffer_this); // Perhaps not ideal to do this on rasteriser core? + SendQueue(2); // Send both queues to the rasteriser + SendQueue(3); + } + xEventGroupSetBits( + raster_event_group, + RASTER_DONE); + + //taskYIELD(); + } +} + + +// Set up a queue with the various parameters +void MakeQueue(const uint32_t tri_count, const uint32_t block) +{ + BlockA[block].size = 0; // Record being of zero size + // Get a pointer to the start of the allocated memory area + TriToRaster* this_ptr; + + this_ptr = (TriToRaster*)malloc(sizeof(TriToRaster) * tri_count); + BlockA[block].itemptr = this_ptr; + + if (!this_ptr) // manage failure to allocate + { + show_error("Failed to allocate triangle queue"); + } + BlockA[block].size = tri_count; // Record size + BlockA[block].count = 0; // and it's now empty +} + +// Empty Queues +void EmptyQueues() +{ + // Counters (which is used to fill and read) are set to empty rather than anything being deleted + BlockA[0].count=0; + BlockA[1].count=0; + BlockA[2].count=0; + BlockA[3].count=0; +} + +void EmptyQueue(const uint32_t block) +{ + // Counter (which is used to fill and read) are set to empty rather than anything being deleted + BlockA[block].count=0; +}; + +// Put a triangle on the queue +uint32_t QueueTriangle(const TriToRaster triangle, const uint32_t block) +{ + // sizeof(triangle) is >70 bytes with multiple elements of the struct + // Put the passed triangle into the memory space as if an array + // It's inefficient as tiles pass a matrix that's the same many times... + BlockA[block].itemptr[BlockA[block].count] = triangle; + + // Increment the counter + BlockA[block].count++; + + if (BlockA[block].count >= BlockA[block].size) + { + ESP_LOGI(TAG,"Block %d queue overflow",(int)block); + show_error("Triangle queue overflow"); // Manage buffer overflow + } + // Use the bounding box to (over)estimate how many pixels will be placed although + // it will be correct for tiles in odd block + uint32_t pixel_estimate = (uint32_t)((triangle.BoBox.m_MaxX - triangle.BoBox.m_MinX) * (triangle.BoBox.m_MaxY - triangle.BoBox.m_MinY)); + + return(pixel_estimate); +} + +// Send all of the queued triangles or tiles to the rasteriser +// Use block to choose RasteriseBox or NotRasteriseBox such that +// an odd block goes to NotRasteriseBox +void SendQueue(const uint32_t block) +{ + // Loop through the queue items, the order doesn't matter as pixels + // placed based on z depth + if (BlockA[block].count == 0) return; // Quit immediately if an empty queue + for (uint32_t cnt = 0; cnt < BlockA[block].count; cnt++) + { + TriToRaster this_tri = BlockA[block].itemptr[cnt]; + if (block & 0x01) // test bit zero for oddness + { + NotRasteriseBox(this_tri); + } + else + { + RasteriseBox(this_tri); + } + } + //std::cout << "Triangle queue size in " << block << " is " << BlockA[block].count << "\n"; + + if (BlockA[block].count > max_raster_buf[block]) max_raster_buf[block] = BlockA[block].count; // track buffer usage + + // Reset of counter is done before use in ShowWorld now + //BlockA[block].count = 0; //reset queue counter at the end +} + +// Send all of the queued triangles or tiles to be checked for an impact +// Use block to choose whether to edge check or not such that +// an odd block goes to simply checking the bounding box +bool SendImpactQueue(const uint32_t block, Near_pix * to_test) +{ + bool found = false; // Failsafe for not findign an impact + // Loop through the queue items + if (BlockA[block].count==0) return(false); // Quit immediately if an empty queue + + // Loop through and find the nearest point + for (uint32_t cnt = 0; cnt < BlockA[block].count; cnt++) + { + TriToRaster this_tri = BlockA[block].itemptr[cnt]; + if (block & 0x01) // test bit zero for oddness + { + const float z = CheckHitTile(this_tri, to_test->x, to_test->y); + if (z < to_test->depth) + { + found = true; + to_test->depth = z; + to_test->idx = this_tri.idx; + to_test->layout = this_tri.layout; + } + } + else + { + const float z = CheckHitFace(this_tri, to_test->x, to_test->y); + if (z < to_test->depth) + { + found = true; + to_test->depth = z; + to_test->idx = this_tri.idx; + to_test->layout = this_tri.layout; + } + } + } +return (found); +} // End of SendImpactQueue \ No newline at end of file diff --git a/main/i80_lcd_main.cpp b/main/i80_lcd_main.cpp new file mode 100644 index 0000000..2a94875 --- /dev/null +++ b/main/i80_lcd_main.cpp @@ -0,0 +1,308 @@ + +// Note that SDK config has 128k reserved for DMA etc in internal memory +// 2 x 32k is needed for frame_buffer_A and _B, depth buffer is ok via cache though + + +#include +#include +#include "driver/gpio.h" + +#include "esp_partition.h" +#include "esp_err.h" +#include "esp_log.h" +#include "esp_dma_utils.h" + +#include "esp_cache.h" +#include "esp_heap_caps_init.h" +#include "esp_timer.h" + +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" + + +#include +#include +#include +//#include // Doesn't seem to be essential, perhaps embedded in another? + +#include "ST7789_def.h" +#include "lcd_setup.h" + +#include "buttons.h" +#include "title.h" // A 128 square title screen ideally + +#include "events_global.h" +#include "wr_gpio.h" +#include "TriangleQueues.h" +#include "RasteriseBox.h" +#include "CheckTriangles.h" +#include "ShowWorld.h" +#include "ParseWorld.h" +#include "TimeTracker.h" +#include "EventManager.h" + +#define LO_PLAIN 0 // A static world +#define LO_FLIP 1 // Flip book with some sets of vertices + +// The background colour for clearing screen which is made from fog +extern constexpr uint32_t fog = 0x00303030; +extern constexpr uint16_t BackgroundColour = ((fog >> 8) & 0b1111100000000000) | ((fog >> 5) & 0b0000011111100000) | ((fog >> 3) & 0b0000000000011111); + + +uint32_t * world_dummy; + +std::vector the_layouts; // Global presently but not good idea + +std::vector world; // An unsized vector of layouts which can contain multiple frames + +// Declare a global variable to hold the created event group +// which will synchronise the Core 0 and Core 1 tasks +// Bit definitions in event_globals.h +EventGroupHandle_t raster_event_group; + +QueueHandle_t game_event_queue; + +TimerHandle_t track_handle_s; +TimerHandle_t track_handle_p; + + +// When the frame buffers are created their memory will be pointed to by +uint16_t * frame_buffer_A; +uint16_t * frame_buffer_B; + +uint16_t * overlay_buffer; // For 2D operations + +esp_lcd_panel_handle_t panel_handle = NULL; + +bool flipped = true; + +Vec3f direction; +Vec3f eye; +float eye_level; // Height of the viewer will be found from the world eye and spot_height + +extern "C" void app_main(void) +{ + static const char *TAG = "main"; + // A time check will be done after setup and a delay made to retain title screen if required + const int64_t startup_time = esp_timer_get_time(); // Internal microsecond clock + + ESP_LOGI(TAG, "Allocating memory for frame buffers"); + // allocate a screen buffer but must be on 32 byte boundary it seems for cache flush to work + void *mem = malloc(sizeof(uint16_t) * EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES + EXAMPLE_PSRAM_DATA_ALIGNMENT - 1); + uint16_t *pix = (uint16_t *)(((uintptr_t)mem + EXAMPLE_PSRAM_DATA_ALIGNMENT - 1) & ~ (uintptr_t)(EXAMPLE_PSRAM_DATA_ALIGNMENT - 1)); + // The below should work better without cache etc but it leaves screen gaps + //uint16_t * pix = (uint16_t *)heap_caps_aligned_alloc(0x04 , sizeof(uint16_t) * EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES , MALLOC_CAP_DMA); + if ( pix == NULL) assert("malloc for full screen buffer failed"); + + // Make frame buffers + frame_buffer_A = (uint16_t *)heap_caps_malloc(sizeof(uint16_t) * g_scWidth * g_scHeight , MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA | MALLOC_CAP_32BIT); + if ( frame_buffer_A == NULL) assert("malloc failed for frame_buffer_A"); + + frame_buffer_B = (uint16_t *)heap_caps_malloc(sizeof(uint16_t) * g_scWidth * g_scHeight , MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA | MALLOC_CAP_32BIT); + if ( frame_buffer_B == NULL) assert("malloc failed for frame_buffer_B"); + + overlay_buffer = (uint16_t *)heap_caps_malloc(sizeof(uint16_t) * g_scWidth * g_scHeight , MALLOC_CAP_INTERNAL | MALLOC_CAP_32BIT); + if ( overlay_buffer == NULL) assert("malloc failed for overlay_buffer"); + + // Attempt to create the event group - before DMA callback is invoked + raster_event_group = xEventGroupCreate(); + // Was the event group created successfully? + if( raster_event_group == NULL ) assert("Create event group failed"); + + // make sure all bits are cleared so tasks don't start unexpectedly + xEventGroupClearBits(raster_event_group,0xff); + + + // Build the structures that make lcd handles + esp_lcd_panel_io_handle_t io_handle = NULL; + init_lcd_i80_bus(&io_handle); + init_lcd_panel(io_handle, &panel_handle); + + // Clear the WHOLE screen, not just out display area + for (int i=0;isize, ESP_PARTITION_MMAP_DATA, &texture_map_ptr, &map_handle)); + ESP_LOGI(TAG, "Mapped textures partition to data memory address %p", texture_map_ptr); + unsigned int size = partition->size; + ESP_LOGI(TAG, "Texture partition is of size %x", size); + + ESP_LOGI(TAG,"Finding partition for the 3D world and mapping memmory"); + // Find the partition map in the partition table for the world itself + const esp_partition_t * w_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, "world"); + assert(w_partition != NULL); + + //uint8_t *w_map_ptr; + const void * w_ptr; // This is the start of the partition + esp_partition_mmap_handle_t w_map_handle; + + // Map the textures partition to data memory + ESP_ERROR_CHECK(esp_partition_mmap(w_partition, 0, w_partition->size, ESP_PARTITION_MMAP_DATA, &w_ptr, &w_map_handle)); + ESP_LOGI(TAG, "Mapped world partition to data memory address and getting offsets %p", w_ptr); + // w_ptr is a pointer to the start of the world partition + // It is cast to uint8 * in w_map_ptr so that byte offsets can be done + //w_map_ptr = (uint8_t *)w_ptr; + + // Use a structure into partition header to save pointer messing + // to extract the over-arching parameters + world_partition_header * world_partition_header_ptr = (world_partition_header *) w_ptr; + + eye = world_partition_header_ptr->eye; + eye_level = eye.y; // Copy eye level from the world and save for later + direction = world_partition_header_ptr->direction; +/* + // Fetch the offset of the first world from the opening header + // world_start will be a descriptor that is followed by an offset + const uint32_t w_map_offset = (const uint32_t) * (1 + &(world_partition_header_ptr->world_start)); + + ESP_LOGI(TAG, "First offset to world is %p", (void *)w_map_offset); + + w_map_ptr += w_map_offset; // Skip past the world header and offset to the world's own list of pointers + + // Each set of offsets is relative to its own header start + // So there is a need to know where each header begins +*/ +/* + world_header * world_header_ptr = (world_header *) (w_ptr + w_map_offset); + + ESP_LOGI(TAG, "header %p",world_header_ptr); + ESP_LOGI(TAG, "w_map %p",w_map_ptr); + ESP_LOGI(TAG, "map %p",texture_map_ptr); +*/ + // Uses a ragged array to give offsets of world layouts in the partition + ParseWorld ( w_ptr , texture_map_ptr ); + + // Use the partition pointers to read the ROM world descriptors into a + // structure of pointers, calculating the values from offsets for each case + //ReadWorld(w_map_ptr , world_header_ptr , texture_map_ptr); + //ReadWorld(w_ptr , texture_map_ptr); + + // Make a queue which will take event words generated during play and apss to a manager + // Create a queue capable of containing 10 Near_pix values which say a lot about the impact + game_event_queue = xQueueCreate( 10, sizeof( Near_pix ) ); + if( game_event_queue == 0 ) assert("Creation of game event queue failed"); + + // Set the initial health bar via the event queue system + Near_pix first_event; + first_event.event = EVNT_ENERGY | EE_SET | ( 0x79 << EVNT_NN_SHIFT) | EE_DISPLAY; // Start with 120 - actually 121 - energy so a life of 2 minutes + if( xQueueSend( game_event_queue, ( void * ) &first_event, ( TickType_t ) 10 ) != pdPASS ) + { + // Failed to post the message, even after 10 ticks. + ESP_LOGI(TAG,"Failed to post item in event queue"); + } + + // Nearly everything is done, so see if the title screen can be removed yet + while (esp_timer_get_time() < startup_time + 1000000); + +// A reloading second timer for user updates + track_handle_s = xTimerCreate("SecondTimer", // Just a text name, not used by the kernel. + (1000 / portTICK_PERIOD_MS), // Activate every 1000ms + pdTRUE, // The timer will auto-reload on expiration + ( void * ) 0, // No id field really used once events up and running +// ( void * ) &time_report, // Pass the data structure via the id field + TimeTrack // The one per second callback + ); + if (track_handle_s == NULL) assert("Create tracker xTimerCreate failed"); + if( xTimerStart( track_handle_s, 0 ) != pdPASS ) assert("Start of tracker xTimer failed"); + + // A oneshot timer that will be used to remove 2D popup overlays + track_handle_p = xTimerCreate("PopupTimer", // Just a text name, not used by the kernel + (800 / portTICK_PERIOD_MS), // Delay to remove overlay goes here + pdFALSE, // The timer is one-shot + ( void * ) 0, // No id field really used once events up and running + StopOverlayTwoD // The overlay callback + ); + if (track_handle_p == NULL) assert("Create popup xTimerCreate failed"); + + // Note that if the stacks here are too big the tasks will not run BUT + // the create error will not be shown!! + + // On Arduino this would run as loop() + ESP_LOGI(TAG,"Start ShowWorld task now everything else ready"); + if (xTaskCreatePinnedToCore ( + ShowWorld, // Task function + "ShowWorldTask", // String with name of task + 30000, // Stack size in bytes + NULL,// Passing nothing at the moment + 4, // Priority of the task + NULL, // Task handle + 0) // Core + != pdPASS) assert("Failed to create ShowWorld task"); + + ESP_LOGI(TAG,"Start rasterise task"); + if (xTaskCreatePinnedToCore ( + rasteriseTask, // Task function + "RasteriseTask", // String with name of task + 30000, // Stack size in bytes + NULL,// Passing nothing at the moment + 6, // Priority of the task - highest for this core + NULL, // Task handle + 1) // Core - some RTOS tasks on zero so put this where less work + != pdPASS) assert("Failed to create Rasterisation task"); + + ESP_LOGI(TAG,"Start game event manager task"); + if (xTaskCreatePinnedToCore ( + GetGameEvent, // Task function + "GameEventTask", // String with name of task + 10000, // Stack size in bytes + NULL,// Passing nothing at the moment + 3, // Priority of the task + NULL, // Task handle + tskNO_AFFINITY) + != pdPASS) assert("Failed to create GameEvent task"); + +} // End of main now that work passed to three tasks diff --git a/main/idf_component.yml b/main/idf_component.yml new file mode 100644 index 0000000..9db8a64 --- /dev/null +++ b/main/idf_component.yml @@ -0,0 +1,3 @@ +dependencies: + idf: ">=4.4" + diff --git a/main/includes/CameraWork.h b/main/includes/CameraWork.h new file mode 100644 index 0000000..3fafecd --- /dev/null +++ b/main/includes/CameraWork.h @@ -0,0 +1,14 @@ +#pragma once + +#include "geometry.h" + +void make_camera(const Vec3f direction, const Vec3f cameraPosition, Matrix44f& worldToCamera); + +void make_perspective( + float const fovy, // must be in radians + float const aspect, + float const zNear, + float const zFar, + Matrix44f& Result +); + diff --git a/main/includes/CheckTriangles.h b/main/includes/CheckTriangles.h new file mode 100644 index 0000000..ce2eaa0 --- /dev/null +++ b/main/includes/CheckTriangles.h @@ -0,0 +1,24 @@ +#pragma once + +#include +#include "geometry.h" +#include "structures.h" + +#define CLIP_TR 0 // reject a triangle that is outside frustrum +#define CLIP_TA 1 // totally accept and applied a bounding box as it's inside frustrum +#define CLIP_MC 2 // triangle exits frustrum and so a bounding box of the whole screen is given which is then rasterised in tiles + +void ProjectionMatrix(); + +// Checks every face and transforms prior to putting into rasteriser queue +uint32_t CheckTriangles(const Vec3f eye, const Vec3f direction, const uint32_t this_chunk, const WorldLayout* layo_ptr); + +// Basic edge function for BaseTriangles, no awareness of frustrum +float edge_function(const Vec3f a, const Vec3f b, const Vec3f p); + +// Derived from the above to simply find the current spot height of the viewer +float BaseTriangles(const Vec3f eye, const Vec3f direction, const uint32_t this_chunk, const WorldLayout* layo_ptr); + +// Calculated face shading based on normal and lighting +void MakeShade(uint32_t idx, const Vec3f eye, const Vec3f direction, const WorldLayout* layo_ptr, Shade_params* surface_shade); + diff --git a/main/includes/ChunkChooser.h b/main/includes/ChunkChooser.h new file mode 100644 index 0000000..1e11097 --- /dev/null +++ b/main/includes/ChunkChooser.h @@ -0,0 +1,19 @@ +#pragma once + +#include +#include "geometry.h" +#include "structures.h" + +// Various flags returned by the chunk chooser functions +#define INVALID_CHUNK 0xffffffff +#define LAST_CHUNK 0xfffffffe + +bool test_chunk(Vec2i chunk, const ChunkArr& chunk_param); + +Vec2i find_chunk(const Vec3f location, const ChunkArr& chunk_param); + +uint32_t chunk_index(const Vec2i chunk, const ChunkArr& chunk_param); + +uint32_t ChunkChooser(const Vec3f eye, Vec3f direction, const bool eye_moved, const WorldLayout* layo_ptr); + +uint32_t IndexChunkChooser(const Vec3f eye, Vec3f direction, uint32_t index, const WorldLayout* layo_ptr); diff --git a/main/includes/ClipBound.h b/main/includes/ClipBound.h new file mode 100644 index 0000000..f9cc7f3 --- /dev/null +++ b/main/includes/ClipBound.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include "geometry.h" +#include "structures.h" + +unsigned int ExecuteFullTriangleClipping(const Vec4f& v0Clip, const Vec4f& v1Clip, const Vec4f& v2Clip, Rect2D* pBbox); + +Rect2D ComputeBoundingBox(const Vec4f& v0Clip, const Vec4f& v1Clip, const Vec4f& v2Clip, float width, float height); + + diff --git a/main/includes/EventManager.h b/main/includes/EventManager.h new file mode 100644 index 0000000..62b8f3b --- /dev/null +++ b/main/includes/EventManager.h @@ -0,0 +1,45 @@ +#pragma once + +// An event code is uint32_t and encoded from the Blender material name by the +// node.js script into the palette. +// The intention is that a material is ascribed to a set of faces that behave +// in a defined way collectively. Note though that the bit pattern is not +// granular enough to allow every permutation unambiguously. +// One event can push another into the queue although care is needed +// for example, after faes are deleted they cannot be re-referenced by a code +// The event codes are global across the world, which can have benefits and drawbacks! +// As is traditional, codes are OR'd to generate complex actions. +// Format of the word is: +// 0xTEFSSNNXX +// ||||||-- - identification number used by world designer +// ||||-- - one byte number in twos complement to action things +// |||- - three nibbles for an action's subtype organised as Energy, Faces, TBC +// - - one nibble for an action +#define EVNT_NN_MASK 0x0000ff00 // Mask to present the operand +#define EVNT_NN_SHIFT 8 // Bit shift required to move operand to LSB + +#define EVNT_ENERGY 0x10000000 + #define EE_DISPLAY 0x01000000 // Sends the energy bar display via DMA + #define EE_CHANGE 0x02000000 // Alters the energy level as per NN + #define EE_SCORE 0x04000000 // Activates display of an energy award graphic as per NN + #define EE_SET 0x08000000 // Set the energy level as per NN + +#define EVNT_FACES 0x20000000 + #define EF_DELETE 0x00100000 // Delete all faces with the exact same event code + +#include +#include "structures.h" + +void GetGameEvent(void * parameter); + +void EvntDeleteFaces(Near_pix this_event_pix); + +void EvntHealthBar(const uint16_t health); + +void OverlayTwoD(TwoD_overlay & this_overlay); + +void StopOverlayTwoD(TimerHandle_t tracked_handle); + +void MakeNumber(uint16_t font_index, uint16_t score, TwoD_overlay & this_overlay); + + diff --git a/main/includes/FindHitFace.h b/main/includes/FindHitFace.h new file mode 100644 index 0000000..3471758 --- /dev/null +++ b/main/includes/FindHitFace.h @@ -0,0 +1,12 @@ +#pragma once +#include + +#include "globals.h" +#include "geometry.h" +#include "structures.h" + +float CheckHitFace(const TriToRaster & tri, const uint32_t test_x, const uint32_t test_y); + +float CheckHitTile(const TriToRaster & tri, const uint32_t test_x, const uint32_t test_y); + +bool TestBoBox(const Rect2D box, const uint32_t test_x, const uint32_t test_y); \ No newline at end of file diff --git a/main/includes/GradientBar.h b/main/includes/GradientBar.h new file mode 100644 index 0000000..84c855b --- /dev/null +++ b/main/includes/GradientBar.h @@ -0,0 +1,96 @@ +#pragma once + +#include + +// Generated by : ImageConverter 565 Online +// Generated from : gradient_bar.png +// Time generated : Fri, 11 Oct 24 21:34:02 +0200 (Server timezone: CET) +// Image Size : 10x128 pixels +// Memory usage : 2560 bytes +// A coloured bar from green to red, can be used as a health indicator + +#define GRADBAR_W 10 +#define GRADBAR_H 128 + +const uint16_t gradient_bar[1280] = { +0x2744, 0x2744, 0x2744, 0x2743, 0x2743, 0x2743, 0x2744, 0x2743, 0x2743, 0x2744, 0x2743, 0x2744, 0x2743, 0x2743, 0x2744, 0x2744, // 0x0010 (16) pixels +0x2744, 0x2744, 0x2744, 0x2743, 0x2723, 0x2724, 0x2744, 0x2744, 0x2723, 0x2724, 0x2723, 0x2724, 0x2723, 0x2724, 0x2723, 0x2724, // 0x0020 (32) pixels +0x2724, 0x2724, 0x2723, 0x2724, 0x2723, 0x2724, 0x2724, 0x2723, 0x2F24, 0x2F24, 0x2F24, 0x2F24, 0x2F23, 0x2F24, 0x2F24, 0x2F24, // 0x0030 (48) pixels +0x2F24, 0x2F23, 0x2F04, 0x2F04, 0x2F04, 0x2F04, 0x2F03, 0x2F04, 0x2F04, 0x2F04, 0x2F04, 0x2F04, 0x2F03, 0x2F03, 0x2F03, 0x2F03, // 0x0040 (64) pixels +0x2F04, 0x2F04, 0x2F03, 0x2F04, 0x2F04, 0x2F03, 0x2F04, 0x2EE4, 0x2EE4, 0x2F03, 0x2F04, 0x2EE4, 0x2F03, 0x2F03, 0x2EE3, 0x2F03, // 0x0050 (80) pixels +0x2EE3, 0x2EE4, 0x2EE3, 0x36E4, 0x36E4, 0x2EE4, 0x36E3, 0x36E4, 0x2EE4, 0x2EE4, 0x36E4, 0x36E4, 0x36E4, 0x36E4, 0x36E4, 0x36E4, // 0x0060 (96) pixels +0x36E4, 0x36E4, 0x36E3, 0x36E4, 0x36C3, 0x36C4, 0x36C3, 0x36C3, 0x36C4, 0x36C4, 0x36C4, 0x36C3, 0x36C4, 0x36C3, 0x36C4, 0x36C4, // 0x0070 (112) pixels +0x36C3, 0x36C3, 0x36C4, 0x36C4, 0x36C4, 0x36C4, 0x36C3, 0x36C4, 0x36A4, 0x36A3, 0x36A3, 0x36C4, 0x36C4, 0x36A4, 0x36C3, 0x36C4, // 0x0080 (128) pixels +0x36C4, 0x36C4, 0x3EA4, 0x3EA4, 0x3EA4, 0x3EA4, 0x3EA4, 0x3EA4, 0x3EA4, 0x3EA4, 0x3EA3, 0x3EA4, 0x3EA3, 0x3EA4, 0x3EA4, 0x3EA4, // 0x0090 (144) pixels +0x3EA4, 0x3EA4, 0x3EA3, 0x3EA4, 0x3EA4, 0x3EA4, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E83, // 0x00A0 (160) pixels +0x3E83, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E84, 0x3E83, 0x3E84, 0x3E84, 0x3E84, // 0x00B0 (176) pixels +0x3E64, 0x3E64, 0x3E84, 0x3E83, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, // 0x00C0 (192) pixels +0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4664, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, // 0x00D0 (208) pixels +0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4644, 0x4E44, 0x4644, 0x4644, 0x4E44, // 0x00E0 (224) pixels +0x4E44, 0x4644, 0x4E44, 0x4644, 0x4E44, 0x4644, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, // 0x00F0 (240) pixels +0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E24, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, // 0x0100 (256) pixels +0x4E24, 0x4E04, 0x4E24, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x4E04, 0x5604, 0x5604, // 0x0110 (272) pixels +0x5604, 0x5604, 0x5604, 0x5604, 0x5604, 0x5604, 0x5604, 0x5604, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, // 0x0120 (288) pixels +0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55E4, 0x55C4, 0x55C4, 0x55E4, // 0x0130 (304) pixels +0x55C4, 0x55E4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, 0x55C4, // 0x0140 (320) pixels +0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DC4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, // 0x0150 (336) pixels +0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5DA4, 0x5D84, 0x5D84, // 0x0160 (352) pixels +0x5DA4, 0x5D84, 0x5D84, 0x5DA4, 0x5D84, 0x5DA4, 0x5DA4, 0x5D84, 0x5D84, 0x6584, 0x6584, 0x5D84, 0x6584, 0x6584, 0x5D84, 0x5D84, // 0x0170 (368) pixels +0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6584, 0x6564, 0x6564, 0x6564, 0x6564, // 0x0180 (384) pixels +0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, 0x6564, // 0x0190 (400) pixels +0x6544, 0x6544, 0x6564, 0x6544, 0x6544, 0x6544, 0x6544, 0x6564, 0x6544, 0x6544, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, // 0x01A0 (416) pixels +0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D44, 0x6D24, 0x6D24, // 0x01B0 (432) pixels +0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, 0x6D24, // 0x01C0 (448) pixels +0x6D24, 0x6D24, 0x6D24, 0x6D04, 0x6D04, 0x6D04, 0x6D04, 0x6D24, 0x6D24, 0x6D24, 0x6D04, 0x6D24, 0x7504, 0x7504, 0x7504, 0x7504, // 0x01D0 (464) pixels +0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, 0x7504, // 0x01E0 (480) pixels +0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, // 0x01F0 (496) pixels +0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x74E4, 0x7CE4, 0x7CC4, 0x7CE4, 0x74C4, 0x74C4, 0x74E4, 0x74C4, 0x7CC4, 0x7CC4, // 0x0200 (512) pixels +0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, 0x7CC4, // 0x0210 (528) pixels +0x7CC4, 0x7CC4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, // 0x0220 (544) pixels +0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x7CA4, 0x84A4, 0x84A4, 0x8484, 0x84A4, 0x8484, 0x8484, 0x8484, 0x8484, 0x84A4, 0x8484, // 0x0230 (560) pixels +0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, 0x8484, // 0x0240 (576) pixels +0x8484, 0x8484, 0x8484, 0x8484, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, 0x8464, // 0x0250 (592) pixels +0x8C64, 0x8C64, 0x8464, 0x8C64, 0x8C64, 0x8464, 0x8464, 0x8C64, 0x8C64, 0x8C44, 0x8C64, 0x8C44, 0x8C64, 0x8C44, 0x8C64, 0x8C64, // 0x0260 (608) pixels +0x8C64, 0x8C64, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, // 0x0270 (624) pixels +0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C44, 0x8C24, 0x8C24, 0x8C24, 0x8C24, 0x8C24, 0x8C24, 0x8C24, 0x8C24, 0x8C24, 0x8C24, // 0x0280 (640) pixels +0x9424, 0x9424, 0x9424, 0x9424, 0x9424, 0x9424, 0x9424, 0x9424, 0x9424, 0x8C24, 0x9424, 0x9424, 0x9424, 0x9404, 0x9404, 0x9404, // 0x0290 (656) pixels +0x9424, 0x9424, 0x9424, 0x9424, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, // 0x02A0 (672) pixels +0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x9404, 0x93E4, 0x93E4, 0x93E4, 0x93E4, 0x93E4, 0x93E4, 0x93E4, 0x93E4, // 0x02B0 (688) pixels +0x93E4, 0x93E4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BE4, 0x9BC4, 0x9BE4, 0x9BE4, 0x9BE4, // 0x02C0 (704) pixels +0x9BE4, 0x9BE4, 0x9BE4, 0x9BC4, 0x9BE4, 0x9BE4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, // 0x02D0 (720) pixels +0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BC4, 0x9BA4, 0x9BA4, 0x9BA4, 0x9BA4, 0x9BA4, 0x9BA4, // 0x02E0 (736) pixels +0xA3A4, 0xA3A4, 0x9BA4, 0x9BA4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, 0xA3A4, // 0x02F0 (752) pixels +0xA3A4, 0xA3A4, 0xA3A4, 0xA384, 0xA3A4, 0xA384, 0xA3A4, 0xA3A4, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, // 0x0300 (768) pixels +0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xA384, 0xAB64, 0xAB64, 0xAB64, 0xA384, // 0x0310 (784) pixels +0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xA364, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, // 0x0320 (800) pixels +0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB64, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, // 0x0330 (816) pixels +0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xAB44, 0xB324, 0xB324, // 0x0340 (832) pixels +0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB344, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, // 0x0350 (848) pixels +0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB324, 0xB304, 0xB304, 0xB304, 0xB304, // 0x0360 (864) pixels +0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, 0xB304, // 0x0370 (880) pixels +0xBAE4, 0xBAE4, 0xBB04, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBB04, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, // 0x0380 (896) pixels +0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAE4, 0xBAC4, 0xBAC4, // 0x0390 (912) pixels +0xBAC4, 0xBAC4, 0xBAC4, 0xBAC4, 0xBAC4, 0xBAC4, 0xBAC4, 0xBAC4, 0xC2C4, 0xC2C4, 0xBAC4, 0xBAC4, 0xC2C4, 0xBAC4, 0xC2C4, 0xC2C4, // 0x03A0 (928) pixels +0xC2C4, 0xC2C4, 0xC2A4, 0xC2C4, 0xC2A4, 0xC2C4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2C4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, // 0x03B0 (944) pixels +0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, 0xC2A4, // 0x03C0 (960) pixels +0xC284, 0xC284, 0xC284, 0xC284, 0xC284, 0xC284, 0xC284, 0xC284, 0xC284, 0xC284, 0xCA84, 0xCA84, 0xCA84, 0xCA84, 0xCA84, 0xCA84, // 0x03D0 (976) pixels +0xCA84, 0xCA84, 0xCA84, 0xCA84, 0xCA84, 0xCA64, 0xCA84, 0xCA64, 0xCA64, 0xCA84, 0xCA84, 0xCA64, 0xCA84, 0xCA64, 0xCA64, 0xCA64, // 0x03E0 (992) pixels +0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, 0xCA64, // 0x03F0 (1008) pixels +0xCA64, 0xCA64, 0xCA44, 0xCA44, 0xCA44, 0xCA44, 0xCA44, 0xCA44, 0xCA44, 0xCA44, 0xD244, 0xCA44, 0xD244, 0xD244, 0xD244, 0xD244, // 0x0400 (1024) pixels +0xD244, 0xD244, 0xD244, 0xD244, 0xD244, 0xD244, 0xD244, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, // 0x0410 (1040) pixels +0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, 0xD224, // 0x0420 (1056) pixels +0xD224, 0xD224, 0xD224, 0xD224, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, // 0x0430 (1072) pixels +0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xDA04, 0xD9E4, 0xDA04, 0xDA04, 0xDA04, 0xD9E4, // 0x0440 (1088) pixels +0xDA04, 0xDA04, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, // 0x0450 (1104) pixels +0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xD9E4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, // 0x0460 (1120) pixels +0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1A4, 0xE1A4, 0xE1C4, 0xE1C4, 0xE1C4, 0xE1C4, // 0x0470 (1136) pixels +0xE1A4, 0xE1C4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE1A4, 0xE9A4, // 0x0480 (1152) pixels +0xE1A4, 0xE9A4, 0xE9A4, 0xE1A4, 0xE1A4, 0xE9A4, 0xE1A4, 0xE1A4, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, // 0x0490 (1168) pixels +0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, 0xE984, // 0x04A0 (1184) pixels +0xE964, 0xE964, 0xE984, 0xE984, 0xE984, 0xE984, 0xE964, 0xE964, 0xE964, 0xE964, 0xE964, 0xE964, 0xE964, 0xE964, 0xE964, 0xE964, // 0x04B0 (1200) pixels +0xF164, 0xF164, 0xF164, 0xF164, 0xF164, 0xF164, 0xF164, 0xF164, 0xF164, 0xF164, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, // 0x04C0 (1216) pixels +0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, 0xF144, // 0x04D0 (1232) pixels +0xF144, 0xF124, 0xF144, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, 0xF124, // 0x04E0 (1248) pixels +0xF124, 0xF124, 0xF924, 0xF924, 0xF924, 0xF924, 0xF924, 0xF924, 0xF924, 0xF924, 0xF924, 0xF924, 0xF904, 0xF904, 0xF904, 0xF904, // 0x04F0 (1264) pixels +0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, 0xF904, // 0x0500 (1280) pixels +}; diff --git a/main/includes/ParseWorld.h b/main/includes/ParseWorld.h new file mode 100644 index 0000000..0f887f4 --- /dev/null +++ b/main/includes/ParseWorld.h @@ -0,0 +1,12 @@ +#pragma once + +#include + +// Thin palette format is a uint32_t count of materials followed by +// type word that is coded, each of which is followed by value which could be: +#define PAL_PLAIN 0x01 //RGB888 colour +#define PAL_TEXOFF 0x02 // Offset into texture table + +void ParseWorld(const void * w_ptr , const void * texture_map_ptr); + +WorldLayout ReadWorld(const void * w_map_ptr , const void * map_ptr); diff --git a/main/includes/RasteriseBox.h b/main/includes/RasteriseBox.h new file mode 100644 index 0000000..ca85506 --- /dev/null +++ b/main/includes/RasteriseBox.h @@ -0,0 +1,36 @@ +#pragma once +#include + +#include "globals.h" +#include "geometry.h" +#include "structures.h" + +void MakeDepthBuffer(); + +void ClearDepthBuffer(float farPlane); + +void CheckCollide(Near_pix * near); + +bool CheckEdgeFunction(const Vec3f& E, const float result); + +void RasteriseBox(const TriToRaster & tri); + +void NotRasteriseBox(const TriToRaster & tri); + +uint32_t spec_shade_pixel (const uint32_t rgb888, const Shade_params surface_shade); + +void WritePixel2Fog888(const uint32_t frame_index, const uint32_t rgb888, const float depth); + +float FogFunction(const float depth); // end and start are set in the function + +uint32_t intmix(const uint32_t x, const uint32_t y, const uint32_t a); + +void ClearWorldFrame(uint16_t * frame_buffer); + + + + + + + + diff --git a/main/includes/ST7789_def.h b/main/includes/ST7789_def.h new file mode 100644 index 0000000..6da1e11 --- /dev/null +++ b/main/includes/ST7789_def.h @@ -0,0 +1,176 @@ +#pragma once +// Change the width and height if required (defined in portrait mode) +// or use the constructor to over-ride defaults +#ifndef TFT_WIDTH + #define TFT_WIDTH 240 +#endif +#ifndef TFT_HEIGHT + #define TFT_HEIGHT 320 +#endif + +#if (TFT_HEIGHT == 240) && (TFT_WIDTH == 240) + #ifndef CGRAM_OFFSET + #define CGRAM_OFFSET + #endif +#endif + +// Adafruit 1.44 TFT support +#if (TFT_HEIGHT == 240) && (TFT_WIDTH == 135) + #ifndef CGRAM_OFFSET + #define CGRAM_OFFSET + #endif +#endif + +// Adafruit 1.69 round corner TFT support +#if (TFT_HEIGHT == 280) && (TFT_WIDTH == 240) + #ifndef CGRAM_OFFSET + #define CGRAM_OFFSET + #endif +#endif + +// 1.47" 172x320 Round Rectangle Color IPS TFT Display +#if (TFT_HEIGHT == 320) && (TFT_WIDTH == 172) + #ifndef CGRAM_OFFSET + #define CGRAM_OFFSET + #endif +#endif + +#if (TFT_HEIGHT == 320) && (TFT_WIDTH == 170) + #ifndef CGRAM_OFFSET + #define CGRAM_OFFSET + #endif +#endif + +#if (TFT_HEIGHT == 300) && (TFT_WIDTH == 240) + #ifndef CGRAM_OFFSET + #define CGRAM_OFFSET + #endif +#endif + +// Delay between some initialisation commands +#define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked + + +// Generic commands used by TFT_eSPI.cpp +#define TFT_NOP 0x00 +#define TFT_SWRST 0x01 + +#define TFT_SLPIN 0x10 +#define TFT_SLPOUT 0x11 +#define TFT_NORON 0x13 + +#define TFT_INVOFF 0x20 +#define TFT_INVON 0x21 +#define TFT_DISPOFF 0x28 +#define TFT_DISPON 0x29 +#define TFT_CASET 0x2A +#define TFT_PASET 0x2B +#define TFT_RAMWR 0x2C +#define TFT_RAMRD 0x2E +#define TFT_MADCTL 0x36 +#define TFT_COLMOD 0x3A + +// Flags for TFT_MADCTL +#define TFT_MAD_MY 0x80 +#define TFT_MAD_MX 0x40 +#define TFT_MAD_MV 0x20 +#define TFT_MAD_ML 0x10 +#define TFT_MAD_RGB 0x00 +#define TFT_MAD_BGR 0x08 +#define TFT_MAD_MH 0x04 +#define TFT_MAD_SS 0x02 +#define TFT_MAD_GS 0x01 + +#ifdef TFT_RGB_ORDER + #if (TFT_RGB_ORDER == 1) + #define TFT_MAD_COLOR_ORDER TFT_MAD_RGB + #else + #define TFT_MAD_COLOR_ORDER TFT_MAD_BGR + #endif +#else + #ifdef CGRAM_OFFSET + #define TFT_MAD_COLOR_ORDER TFT_MAD_BGR + #else + #define TFT_MAD_COLOR_ORDER TFT_MAD_RGB + #endif +#endif + +#define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read + +// ST7789 specific commands used in init +#define ST7789_NOP 0x00 +#define ST7789_SWRESET 0x01 +#define ST7789_RDDID 0x04 +#define ST7789_RDDST 0x09 + +#define ST7789_RDDPM 0x0A // Read display power mode +#define ST7789_RDD_MADCTL 0x0B // Read display MADCTL +#define ST7789_RDD_COLMOD 0x0C // Read display pixel format +#define ST7789_RDDIM 0x0D // Read display image mode +#define ST7789_RDDSM 0x0E // Read display signal mode +#define ST7789_RDDSR 0x0F // Read display self-diagnostic result (ST7789V) + +#define ST7789_SLPIN 0x10 +#define ST7789_SLPOUT 0x11 +#define ST7789_PTLON 0x12 +#define ST7789_NORON 0x13 + +#define ST7789_INVOFF 0x20 +#define ST7789_INVON 0x21 +#define ST7789_GAMSET 0x26 // Gamma set +#define ST7789_DISPOFF 0x28 +#define ST7789_DISPON 0x29 +#define ST7789_CASET 0x2A +#define ST7789_RASET 0x2B +#define ST7789_RAMWR 0x2C +#define ST7789_RGBSET 0x2D // Color setting for 4096, 64K and 262K colors +#define ST7789_RAMRD 0x2E + +#define ST7789_PTLAR 0x30 +#define ST7789_VSCRDEF 0x33 // Vertical scrolling definition (ST7789V) +#define ST7789_TEOFF 0x34 // Tearing effect line off +#define ST7789_TEON 0x35 // Tearing effect line on +#define ST7789_MADCTL 0x36 // Memory data access control +#define ST7789_VSCRSADD 0x37 // Vertical screoll address +#define ST7789_IDMOFF 0x38 // Idle mode off +#define ST7789_IDMON 0x39 // Idle mode on +#define ST7789_RAMWRC 0x3C // Memory write continue (ST7789V) +#define ST7789_RAMRDC 0x3E // Memory read continue (ST7789V) +#define ST7789_COLMOD 0x3A + +#define ST7789_RAMCTRL 0xB0 // RAM control +#define ST7789_RGBCTRL 0xB1 // RGB control +#define ST7789_PORCTRL 0xB2 // Porch control +#define ST7789_FRCTRL1 0xB3 // Frame rate control +#define ST7789_PARCTRL 0xB5 // Partial mode control +#define ST7789_GCTRL 0xB7 // Gate control +#define ST7789_GTADJ 0xB8 // Gate on timing adjustment +#define ST7789_DGMEN 0xBA // Digital gamma enable +#define ST7789_VCOMS 0xBB // VCOMS setting +#define ST7789_LCMCTRL 0xC0 // LCM control +#define ST7789_IDSET 0xC1 // ID setting +#define ST7789_VDVVRHEN 0xC2 // VDV and VRH command enable +#define ST7789_VRHS 0xC3 // VRH set +#define ST7789_VDVSET 0xC4 // VDV setting +#define ST7789_VCMOFSET 0xC5 // VCOMS offset set +#define ST7789_FRCTR2 0xC6 // FR Control 2 +#define ST7789_CABCCTRL 0xC7 // CABC control +#define ST7789_REGSEL1 0xC8 // Register value section 1 +#define ST7789_REGSEL2 0xCA // Register value section 2 +#define ST7789_PWMFRSEL 0xCC // PWM frequency selection +#define ST7789_PWCTRL1 0xD0 // Power control 1 +#define ST7789_VAPVANEN 0xD2 // Enable VAP/VAN signal output +#define ST7789_CMD2EN 0xDF // Command 2 enable +#define ST7789_PVGAMCTRL 0xE0 // Positive voltage gamma control +#define ST7789_NVGAMCTRL 0xE1 // Negative voltage gamma control +#define ST7789_DGMLUTR 0xE2 // Digital gamma look-up table for red +#define ST7789_DGMLUTB 0xE3 // Digital gamma look-up table for blue +#define ST7789_GATECTRL 0xE4 // Gate control +#define ST7789_SPI2EN 0xE7 // SPI2 enable +#define ST7789_PWCTRL2 0xE8 // Power control 2 +#define ST7789_EQCTRL 0xE9 // Equalize time control +#define ST7789_PROMCTRL 0xEC // Program control +#define ST7789_PROMEN 0xFA // Program mode enable +#define ST7789_NVMSET 0xFC // NVM setting +#define ST7789_PROMACT 0xFE // Program action + diff --git a/main/includes/ShowError.h b/main/includes/ShowError.h new file mode 100644 index 0000000..7d7077a --- /dev/null +++ b/main/includes/ShowError.h @@ -0,0 +1,4 @@ +#pragma once +#include + +void show_error(const char* error_string); \ No newline at end of file diff --git a/main/includes/ShowWorld.h b/main/includes/ShowWorld.h new file mode 100644 index 0000000..b35f2ca --- /dev/null +++ b/main/includes/ShowWorld.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +#include "esp_lcd_panel_vendor.h" + +// Access to global variables +extern bool flipped; +extern EventGroupHandle_t raster_event_group; +extern uint16_t * frame_buffer_A; +extern uint16_t * frame_buffer_B; +extern esp_lcd_panel_handle_t panel_handle; + +void ShowWorld(void * parameter); + +void SendFlippedFrame(void); + diff --git a/main/includes/TimeTracker.h b/main/includes/TimeTracker.h new file mode 100644 index 0000000..cf5a06c --- /dev/null +++ b/main/includes/TimeTracker.h @@ -0,0 +1,7 @@ +#pragma once + +#include +#include +#include + +void TimeTrack(TimerHandle_t); \ No newline at end of file diff --git a/main/includes/TriangleQueues.h b/main/includes/TriangleQueues.h new file mode 100644 index 0000000..2c72b8e --- /dev/null +++ b/main/includes/TriangleQueues.h @@ -0,0 +1,19 @@ +#pragma once +#include +#include "geometry.h" +#include "structures.h" + +void rasteriseTask(void * parameter); + +void MakeQueue(const uint32_t tri_count, const uint32_t block); + +void EmptyQueue(const uint32_t block); + +void EmptyQueues(); + +uint32_t QueueTriangle(const TriToRaster triangle, const uint32_t block); + +void SendQueue(const uint32_t block); + +bool SendImpactQueue(const uint32_t block, Near_pix * to_test); + diff --git a/main/includes/buttons.h b/main/includes/buttons.h new file mode 100644 index 0000000..8fe484d --- /dev/null +++ b/main/includes/buttons.h @@ -0,0 +1,11 @@ +#pragma once +// Digital pin definitions for Volo's Game Board for ESP32 T-Display S3 +// Note that none of these seem to be be RTC wake-up pins +// For the 2023 challenge we only used two but others might have debug functions + +#define CONTROL_LEFT GPIO_NUM_43 // The Arduino/ESP32 pin identifiers +#define CONTROL_UP GPIO_NUM_44 +#define CONTROL_DOWN GPIO_NUM_18 +#define CONTROL_RIGHT GPIO_NUM_17 +#define CONTROL_A GPIO_NUM_21 +#define CONTROL_B GPIO_NUM_16 \ No newline at end of file diff --git a/main/includes/events_global.h b/main/includes/events_global.h new file mode 100644 index 0000000..207afa5 --- /dev/null +++ b/main/includes/events_global.h @@ -0,0 +1,7 @@ +#pragma once + +#define START_RASTER (1 << 0) // start the rasterisation +#define RASTER_DONE (1 << 2) // rasterisation is finished +#define CLEAR_READY (1 << 3) // lcd callback says send is done so OK to clear the DMA'd buffer +#define GAME_RUNNING (1 << 4) // the game is allowed to run, cleared at the end of play + diff --git a/main/includes/geometry.h b/main/includes/geometry.h new file mode 100644 index 0000000..b3bc69e --- /dev/null +++ b/main/includes/geometry.h @@ -0,0 +1,741 @@ +#pragma once + +//#include +#include + +// Amended for more Vec4 / Matrix 44 / inverse etc by motoani December 2023 +// +// This program illustrates how the concept of vector and matrix can be implemented +// in C++. This is a light version of the implementation. It contains the most +// essential methods to manipulate vectors and matrices. It should be enough +// for most projects. Vectors and matrices are really the alphabet as we said +// in the lesson of any graphics application. It's really important you feel +// confortable with these techniques especially with the concepts of +// normalizing vectors, computing their length, computing the dot and cross products +// of two vectors, and the point- and vector-matrix multiplication (and knowing +// the difference between the two). + +// Copyright (C) 2012 www.scratchapixel.com +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +//[/ignore] + +template +class Vec2 +{ +public: + Vec2() : x(T(0)), y(T(0)) {} // AKJ it was: x(0), y(0) {} but changed to match Vec3 + Vec2(T xx) : x(xx), y(xx) {} + Vec2(T xx, T yy) : x(xx), y(yy) {} + Vec2 operator + (const Vec2& v) const + { + return Vec2(x + v.x, y + v.y); + } + Vec2 operator / (const T& r) const + { + return Vec2(x / r, y / r); + } + Vec2 operator * (const T& r) const + { + return Vec2(x * r, y * r); + } + Vec2& operator /= (const T& r) + { + x /= r, y /= r; return *this; + } + Vec2& operator *= (const T& r) + { + x *= r, y *= r; return *this; + } + /* + friend std::ostream& operator << (std::ostream& s, const Vec2& v) + { + return s << '[' << v.x << ' ' << v.y << ']'; + } + */ + + friend Vec2 operator * (const T& r, const Vec2& v) + { + return Vec2(v.x * r, v.y * r); + } + T x, y; +}; + +typedef Vec2 Vec2f; +typedef Vec2 Vec2i; + +//[comment] +// Implementation of a generic vector class - it will be used to deal with 3D points, vectors and normals. +// The class is implemented as a template. While it may complicate the code a bit, it gives us +// the flexibility later, to specialize the type of the coordinates into anything we want. +// For example: Vec3f if we want the coordinates to be floats or Vec3i if we want the coordinates to be integers. +// +// Vec3 is a standard/common way of naming vectors, points, etc. The OpenEXR and Autodesk libraries +// use this convention for instance. +//[/comment] +template +class Vec3 +{ +public: + Vec3() : x(T(0)), y(T(0)), z(T(0)) {} + Vec3(T xx) : x(xx), y(xx), z(xx) {} + Vec3(T xx, T yy, T zz) : x(xx), y(yy), z(zz) {} + Vec3 operator + (const Vec3& v) const + { + return Vec3(x + v.x, y + v.y, z + v.z); + } + Vec3 operator - (const Vec3& v) const + { + return Vec3(x - v.x, y - v.y, z - v.z); + } + Vec3 operator - () const + { + return Vec3(-x, -y, -z); + } + Vec3 operator * (const T& r) const + { + return Vec3(x * r, y * r, z * r); + } + Vec3 operator * (const Vec3& v) const + { + return Vec3(x * v.x, y * v.y, z * v.z); + } + T dotProduct(const Vec3& v) const + { + return x * v.x + y * v.y + z * v.z; + } + /* + T print() const + { + std::cout << x << " " << y << " " << " " << z << std::endl; + return 1; + }*/ + + Vec3& operator /= (const T& r) + { + x /= r, y /= r, z /= r; return *this; + } + Vec3& operator *= (const T& r) + { + x *= r, y *= r, z *= r; return *this; + } + Vec3 crossProduct(const Vec3& v) const + { + return Vec3(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); + } + T norm() const + { + return x * x + y * y + z * z; + } + T length() const + { + return sqrt(norm()); + } + //[comment] + // The next two operators are sometimes called access operators or + // accessors. The Vec coordinates can be accessed that way v[0], v[1], v[2], + // rather than using the more traditional form v.x, v.y, v.z. This useful + // when vectors are used in loops: the coordinates can be accessed with the + // loop index (e.g. v[i]). + //[/comment] + const T& operator [] (uint8_t i) const { return (&x)[i]; } + T& operator [] (uint8_t i) { return (&x)[i]; } + Vec3& normalize() + { + T n = norm(); + if (n > 0) { + T factor = 1 / sqrt(n); + x *= factor, y *= factor, z *= factor; + } + + return *this; + } + + friend Vec3 operator * (const T& r, const Vec3& v) + { + return Vec3(v.x * r, v.y * r, v.z * r); + } + friend Vec3 operator / (const T& r, const Vec3& v) + { + return Vec3(r / v.x, r / v.y, r / v.z); + } + + /* + friend std::ostream& operator << (std::ostream& s, const Vec3& v) + { + return s << '[' << v.x << ' ' << v.y << ' ' << v.z << ']'; + } + */ + + T x, y, z; +}; + +//[comment] +// Now you can specialize the class. We are just showing two examples here. In your code +// you can declare a vector either that way: Vec3 a, or that way: Vec3f a +//[/comment] +typedef Vec3 Vec3f; +typedef Vec3 Vec3i; + +// Implementation of a generic vector class - it will be used to deal with 3D points, vectors and normals. +// The class is implemented as a template. While it may complicate the code a bit, it gives us +// the flexibility later, to specialize the type of the coordinates into anything we want. +// For example: Vec4f if we want the coordinates to be floats or Vec4i if we want the coordinates to be integers. +// +// This vector enables w to be included for homogenous coordinate work +// Added by AKJ December 2023 +template +class Vec4 +{ +public: + Vec4() : x(T(0)), y(T(0)), z(T(0)), w(T(0)) {} + Vec4(T xx) : x(xx), y(xx), z(xx), w(xx) {} + Vec4(T xx, T yy, T zz, T ww) : x(xx), y(yy), z(zz), w(ww) {} + Vec4 operator + (const Vec4& v) const + { + return Vec4(x + v.x, y + v.y, z + v.z, w + v.w); + } + Vec4 operator - (const Vec4& v) const + { + return Vec4(x - v.x, y - v.y, z + v.z, w + v.w); + } + Vec4 operator - () const + { + return Vec4(-x, -y, -z, -w); + } + Vec4 operator * (const T& r) const + { + return Vec4(x * r, y * r, z * r, w * r); + } + Vec4 operator * (const Vec4& v) const + { + return Vec4(x * v.x, y * v.y, z * v.z, w * v.w); + } + T dotProduct(const Vec4& v) const + { + return x * v.x + y * v.y + z * v.z + w * v.w; + } + Vec4& operator /= (const T& r) + { + x /= r, y /= r, z /= r, w /= r; return *this; + } + Vec4& operator *= (const T& r) + { + x *= r, y *= r, z *= r, w *= r; return *this; + } + Vec4 crossProduct(const Vec4& v) const // NEEDS MAKING FOR Vec4, debatable if it can be done .... + { + return Vec4(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x, 0); // same as 3D with w defined as zero + } + T norm() const + { + return x * x + y * y + z * z + w * w; + } + T length() const + { + return sqrt(norm()); + } + // The next two operators are sometimes called access operators or + // accessors. The Vec coordinates can be accessed that way v[0], v[1], v[2],v[3] + // rather than using the more traditional form v.x, v.y, v.z, v.w. This useful + // when vectors are used in loops: the coordinates can be accessed with the + // loop index (e.g. v[i]). + //[/comment] + const T& operator [] (uint8_t i) const { return (&x)[i]; } + T& operator [] (uint8_t i) { return (&x)[i]; } + Vec4& normalize() + { + T n = norm(); + if (n > 0) { + T factor = 1 / sqrt(n); + x *= factor, y *= factor, z *= factor, w *= factor; + } + + return *this; + } + + friend Vec4 operator * (const T& r, const Vec4& v) + { + return Vec4(v.x * r, v.y * r, v.z * r, v.w * r); + } + friend Vec4 operator / (const T& r, const Vec4& v) + { + return Vec4(r / v.x, r / v.y, r / v.z, r / v.w); + } + T x, y, z, w; +}; + +//#define TO_RASTER(v) Vec4f((imageWidth * (v.x + v.w) / 2), (imageHeight * (v.w - v.y) / 2), v.z, v.w) + + +template +class Matrix33 +{ +public: + + T x[3][3] = { {1,0,0},{0,1,0},{0,0,1} }; + + Matrix33() {} + + Matrix33(T a, T b, T c, T d, T e, T f, T g, T h, T i) + { + x[0][0] = a; + x[0][1] = b; + x[0][2] = c; + x[1][0] = d; + x[1][1] = e; + x[1][2] = f; + x[2][0] = g; + x[2][1] = h; + x[2][2] = i; + } + + const T* operator [] (uint8_t i) const { return x[i]; } + T* operator [] (uint8_t i) { return x[i]; } + + float determinant() + { + return ( + x[0][0] * (x[1][1] * x[2][2] - x[1][2] * x[2][1]) + - x[0][1] * (x[1][0] * x[2][2] - x[1][2] * x[2][0]) + + x[0][2] * (x[1][0] * x[2][1] - x[1][1] * x[2][0]) + ); + } + + Matrix33 inverse() + { + // This method for inverting a 3x3 matrix is from + // https://www.geertarien.com/blog/2017/05/15/different-methods-for-matrix-inversion/ + // It was chosen as branchless which suits processor with a reasonable cache + // and although at this size any method will be fine at least it's not recursive! + Matrix33 matout; + Matrix33 t(*this); + + + float det_inv = 1 / t.determinant(); + + matout[0][0] = (x[1][1] * x[2][2] + - x[1][2] * x[2][1]) * det_inv; + matout[0][1] = -(x[0][1] * x[2][2] + - x[0][2] * x[2][1]) * det_inv; + matout[0][2] = (x[0][1] * x[1][2] + - x[0][2] * x[1][1]) * det_inv; + matout[1][0] = -(x[1][0] * x[2][2] + - x[1][2] * x[2][0]) * det_inv; + matout[1][1] = (x[0][0] * x[2][2] + - x[0][2] * x[2][0]) * det_inv; + matout[1][2] = -(x[0][0] * x[1][2] + - x[0][2] * x[1][0]) * det_inv; + matout[2][0] = (x[1][0] * x[2][1] + - x[1][1] * x[2][0]) * det_inv; + matout[2][1] = -(x[0][0] * x[2][1] + - x[0][1] * x[2][0]) * det_inv; + matout[2][2] = (x[0][0] * x[1][1] + - x[0][1] * x[1][0]) * det_inv; + + return matout; + } + + template + void multVecMatrix(const Vec3& src, Vec3& dst) const + { + S a, b, c; + + a = src[0] * x[0][0] + src[1] * x[1][0] + src[2] * x[2][0]; + b = src[0] * x[0][1] + src[1] * x[1][1] + src[2] * x[2][1]; + c = src[0] * x[0][2] + src[1] * x[1][2] + src[2] * x[2][2]; + + dst.x = a; + dst.y = b; + dst.z = c; + } +}; +typedef Matrix33 Matrix33f; + + +//[comment] +// Now you can specialize the class. We are just showing two examples here. In your code +// you can declare a vector either that way: Vec4 a, or that way: Vec4f a +//[/comment] +typedef Vec4 Vec4f; +typedef Vec4 Vec4i; + + +//[comment] +// Implementation of a generic 4x4 Matrix class - Same thing here than with the Vec3 class. It uses +// a template which is maybe less useful than with vectors but it can be used to +// define the coefficients of the matrix to be either floats (the most case) or doubles depending +// on our needs. +// +// To use you can either write: Matrix44 m; or: Matrix44f m; +//[/comment] +template +class Matrix44 +{ +public: + + T x[4][4] = { {1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1} }; + + Matrix44() {} + + Matrix44(T a, T b, T c, T d, T e, T f, T g, T h, + T i, T j, T k, T l, T m, T n, T o, T p) + { + x[0][0] = a; + x[0][1] = b; + x[0][2] = c; + x[0][3] = d; + x[1][0] = e; + x[1][1] = f; + x[1][2] = g; + x[1][3] = h; + x[2][0] = i; + x[2][1] = j; + x[2][2] = k; + x[2][3] = l; + x[3][0] = m; + x[3][1] = n; + x[3][2] = o; + x[3][3] = p; + } + + const T* operator [] (uint8_t i) const { return x[i]; } + T* operator [] (uint8_t i) { return x[i]; } + + // Multiply the current matrix with another matrix (rhs) + Matrix44 operator * (const Matrix44& v) const + { + Matrix44 tmp; + multiply(*this, v, tmp); + + return tmp; + } + + //[comment] + // To make it easier to understand how a matrix multiplication works, the fragment of code + // included within the #if-#else statement, show how this works if you were to iterate + // over the coefficients of the resulting matrix (a). However you will often see this + // multiplication being done using the code contained within the #else-#end statement. + // It is exactly the same as the first fragment only we have litteraly written down + // as a series of operations what would actually result from executing the two for() loops + // contained in the first fragment. It is supposed to be faster, however considering + // matrix multiplication is not necessarily that common, this is probably not super + // useful nor really necessary (but nice to have -- and it gives you an example of how + // it can be done, as this how you will this operation implemented in most libraries). + //[/comment] + static void multiply(const Matrix44& a, const Matrix44& b, Matrix44& c) + { +#if 0 + for (uint8_t i = 0; i < 4; ++i) { + for (uint8_t j = 0; j < 4; ++j) { + c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + + a[i][2] * b[2][j] + a[i][3] * b[3][j]; + } + } +#else + // A restric qualified pointer (or reference) is basically a promise + // to the compiler that for the scope of the pointer, the target of the + // pointer will only be accessed through that pointer (and pointers + // copied from it. + const T* __restrict ap = &a.x[0][0]; + const T* __restrict bp = &b.x[0][0]; + T* __restrict cp = &c.x[0][0]; + + T a0, a1, a2, a3; + + a0 = ap[0]; + a1 = ap[1]; + a2 = ap[2]; + a3 = ap[3]; + + cp[0] = a0 * bp[0] + a1 * bp[4] + a2 * bp[8] + a3 * bp[12]; + cp[1] = a0 * bp[1] + a1 * bp[5] + a2 * bp[9] + a3 * bp[13]; + cp[2] = a0 * bp[2] + a1 * bp[6] + a2 * bp[10] + a3 * bp[14]; + cp[3] = a0 * bp[3] + a1 * bp[7] + a2 * bp[11] + a3 * bp[15]; + + a0 = ap[4]; + a1 = ap[5]; + a2 = ap[6]; + a3 = ap[7]; + + cp[4] = a0 * bp[0] + a1 * bp[4] + a2 * bp[8] + a3 * bp[12]; + cp[5] = a0 * bp[1] + a1 * bp[5] + a2 * bp[9] + a3 * bp[13]; + cp[6] = a0 * bp[2] + a1 * bp[6] + a2 * bp[10] + a3 * bp[14]; + cp[7] = a0 * bp[3] + a1 * bp[7] + a2 * bp[11] + a3 * bp[15]; + + a0 = ap[8]; + a1 = ap[9]; + a2 = ap[10]; + a3 = ap[11]; + + cp[8] = a0 * bp[0] + a1 * bp[4] + a2 * bp[8] + a3 * bp[12]; + cp[9] = a0 * bp[1] + a1 * bp[5] + a2 * bp[9] + a3 * bp[13]; + cp[10] = a0 * bp[2] + a1 * bp[6] + a2 * bp[10] + a3 * bp[14]; + cp[11] = a0 * bp[3] + a1 * bp[7] + a2 * bp[11] + a3 * bp[15]; + + a0 = ap[12]; + a1 = ap[13]; + a2 = ap[14]; + a3 = ap[15]; + + cp[12] = a0 * bp[0] + a1 * bp[4] + a2 * bp[8] + a3 * bp[12]; + cp[13] = a0 * bp[1] + a1 * bp[5] + a2 * bp[9] + a3 * bp[13]; + cp[14] = a0 * bp[2] + a1 * bp[6] + a2 * bp[10] + a3 * bp[14]; + cp[15] = a0 * bp[3] + a1 * bp[7] + a2 * bp[11] + a3 * bp[15]; +#endif + } + + // \brief return a transposed copy of the current matrix as a new matrix + Matrix44 transposed() const + { +#if 0 + Matrix44 t; + for (uint8_t i = 0; i < 4; ++i) { + for (uint8_t j = 0; j < 4; ++j) { + t[i][j] = x[j][i]; + } + } + + return t; +#else + return Matrix44(x[0][0], + x[1][0], + x[2][0], + x[3][0], + x[0][1], + x[1][1], + x[2][1], + x[3][1], + x[0][2], + x[1][2], + x[2][2], + x[3][2], + x[0][3], + x[1][3], + x[2][3], + x[3][3]); +#endif + } + + // \brief transpose itself + Matrix44& transpose() + { + Matrix44 tmp(x[0][0], + x[1][0], + x[2][0], + x[3][0], + x[0][1], + x[1][1], + x[2][1], + x[3][1], + x[0][2], + x[1][2], + x[2][2], + x[3][2], + x[0][3], + x[1][3], + x[2][3], + x[3][3]); + *this = tmp; + + return *this; + } + + //[comment] + // This method needs to be used for point-matrix multiplication. Keep in mind + // we don't make the distinction between points and vectors at least from + // a programming point of view, as both (as well as normals) are declared as Vec3. + // However, mathematically they need to be treated differently. Points can be translated + // when translation for vectors is meaningless. Furthermore, points are implicitly + // be considered as having homogeneous coordinates. Thus the w coordinates needs + // to be computed and to convert the coordinates from homogeneous back to Cartesian + // coordinates, we need to divided x, y z by w. + // In this TEST we retain w so return Vec4f, assuming incoming w is 1.0f + // + // The coordinate w is more often than not equals to 1, but it can be different than + // 1 especially when the matrix is projective matrix (perspective projection matrix). + //[/comment] + template + void multVecMatrix(const Vec3& src, Vec4& dst) const + { + S a, b, c, w; + + a = src[0] * x[0][0] + src[1] * x[1][0] + src[2] * x[2][0] + x[3][0]; + b = src[0] * x[0][1] + src[1] * x[1][1] + src[2] * x[2][1] + x[3][1]; + c = src[0] * x[0][2] + src[1] * x[1][2] + src[2] * x[2][2] + x[3][2]; + w = src[0] * x[0][3] + src[1] * x[1][3] + src[2] * x[2][3] + x[3][3]; + + // For this test code we want to retain w + // dst.x = a / w; + // dst.y = b / w; + // dst.z = c / w; + dst.x = a; + dst.y = b; + dst.z = c; + dst.w = w; + + } + + //[comment] + // This method needs to be used for vector-matrix multiplication. Look at the differences + // with the previous method (to compute a point-matrix multiplication). We don't use + // the coefficients in the matrix that account for translation (x[3][0], x[3][1], x[3][2]) + // and we don't compute w. + //[/comment] + template + void multDirMatrix(const Vec3& src, Vec3& dst) const + { + S a, b, c; + + a = src[0] * x[0][0] + src[1] * x[1][0] + src[2] * x[2][0]; + b = src[0] * x[0][1] + src[1] * x[1][1] + src[2] * x[2][1]; + c = src[0] * x[0][2] + src[1] * x[1][2] + src[2] * x[2][2]; + + dst.x = a; + dst.y = b; + dst.z = c; + } + + //[comment] + // Compute the inverse of the matrix using the Gauss-Jordan (or reduced row) elimination method. + // We didn't explain in the lesson on Geometry how the inverse of matrix can be found. Don't + // worry at this point if you don't understand how this works. But we will need to be able to + // compute the inverse of matrices in the first lessons of the "Foundation of 3D Rendering" section, + // which is why we've added this code. For now, you can just use it and rely on it + // for doing what it's supposed to do. If you want to learn how this works though, check the lesson + // on called Matrix Inverse in the "Mathematics and Physics of Computer Graphics" section. + //[/comment] + Matrix44 inverse() const + { + int i, j, k; + Matrix44 s; + Matrix44 t(*this); + + // Forward elimination + for (i = 0; i < 3; i++) { + int pivot = i; + + T pivotsize = t[i][i]; + + if (pivotsize < 0) + pivotsize = -pivotsize; + + for (j = i + 1; j < 4; j++) { + T tmp = t[j][i]; + + if (tmp < 0) + tmp = -tmp; + + if (tmp > pivotsize) { + pivot = j; + pivotsize = tmp; + } + } + + if (pivotsize == 0) { + // Cannot invert singular matrix + return Matrix44(); + } + + if (pivot != i) { + for (j = 0; j < 4; j++) { + T tmp; + + tmp = t[i][j]; + t[i][j] = t[pivot][j]; + t[pivot][j] = tmp; + + tmp = s[i][j]; + s[i][j] = s[pivot][j]; + s[pivot][j] = tmp; + } + } + + for (j = i + 1; j < 4; j++) { + T f = t[j][i] / t[i][i]; + + for (k = 0; k < 4; k++) { + t[j][k] -= f * t[i][k]; + s[j][k] -= f * s[i][k]; + } + } + } + + // Backward substitution + for (i = 3; i >= 0; --i) { + T f; + + if ((f = t[i][i]) == 0) { + // Cannot invert singular matrix + return Matrix44(); + } + + for (j = 0; j < 4; j++) { + t[i][j] /= f; + s[i][j] /= f; + } + + for (j = 0; j < i; j++) { + f = t[j][i]; + + for (k = 0; k < 4; k++) { + t[j][k] -= f * t[i][k]; + s[j][k] -= f * s[i][k]; + } + } + } + + return s; + } + + // \brief set current matrix to its inverse + const Matrix44& invert() + { + *this = inverse(); + return *this; + } + /* + friend std::ostream& operator << (std::ostream& s, const Matrix44& m) + { + std::ios_base::fmtflags oldFlags = s.flags(); + int width = 12; // total with of the displayed number + s.precision(5); // control the number of displayed decimals + s.setf(std::ios_base::fixed); + + s << "[" << std::setw(width) << m[0][0] << + " " << std::setw(width) << m[0][1] << + " " << std::setw(width) << m[0][2] << + " " << std::setw(width) << m[0][3] << "\n" << + + " " << std::setw(width) << m[1][0] << + " " << std::setw(width) << m[1][1] << + " " << std::setw(width) << m[1][2] << + " " << std::setw(width) << m[1][3] << "\n" << + + " " << std::setw(width) << m[2][0] << + " " << std::setw(width) << m[2][1] << + " " << std::setw(width) << m[2][2] << + " " << std::setw(width) << m[2][3] << "\n" << + + " " << std::setw(width) << m[3][0] << + " " << std::setw(width) << m[3][1] << + " " << std::setw(width) << m[3][2] << + " " << std::setw(width) << m[3][3] << "]"; + + s.flags(oldFlags); + return s; + }*/ +}; + +typedef Matrix44 Matrix44f; diff --git a/main/includes/globals.h b/main/includes/globals.h new file mode 100644 index 0000000..4ab0253 --- /dev/null +++ b/main/includes/globals.h @@ -0,0 +1,19 @@ +#pragma once + +#include +#include +#include "geometry.h" + +// Shared global variables + +// Size of the game view port +const uint32_t g_scWidth = 128; // This means that the constant is included at compile time multiple times +const uint32_t g_scHeight = 128; + +const float farPlane = 100.0f; + +const float COLLISION_DISTANCE = 1.0f; + +const uint32_t MAX_FRAME_DURATION = 99; + +const Vec3f IncidentLight = { 0.548821f, -0.329293f, 0.768350f }; // The direction by which light reaches the world, must be magnitude 1.0f diff --git a/main/includes/lcd_setup.h b/main/includes/lcd_setup.h new file mode 100644 index 0000000..8f657e3 --- /dev/null +++ b/main/includes/lcd_setup.h @@ -0,0 +1,40 @@ +#pragma once + +#include + +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" + +// The pixel number in horizontal and vertical - note that X Y swap is active +#define EXAMPLE_LCD_H_RES 320 +#define EXAMPLE_LCD_V_RES 170 + +// Other congigurations constants +#define CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH 8 +// Supported alignment: 16, 32, 64. A higher alignment can enables higher burst transfer size, thus a higher i80 bus throughput. +#define EXAMPLE_PSRAM_DATA_ALIGNMENT 64 // This must be a power of two, and at least 32 for the cache clearance + +extern bool flipped; +extern uint16_t * frame_buffer_A; +extern uint16_t * frame_buffer_B; + +// Prototypes +#ifdef __cplusplus +extern "C" { +#endif +void init_lcd_i80_bus(esp_lcd_panel_io_handle_t *io_handle); +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +extern "C" { +#endif +void init_lcd_panel(esp_lcd_panel_io_handle_t io_handle, esp_lcd_panel_handle_t *panel); +#ifdef __cplusplus +} +#endif + + + diff --git a/main/includes/numberfont.h b/main/includes/numberfont.h new file mode 100644 index 0000000..8050ecf --- /dev/null +++ b/main/includes/numberfont.h @@ -0,0 +1,1777 @@ +#pragma once + +#include +#include "structures.h" + + +// RGB565 Encoded numbers 0 to 9 in two sizes from this online font +// https://www.fontspace.com/nesto-beryl42-font-f86660 +// Background is 0x0000 but likely affected by anti-aliasing + +// Information defined in the structure array at the end of thsi file +/* +Font_numbers nesto[2] = { + { + 21, 189, + 1, 21, 30, 49, 68, 88, 107, 128, 145, 167, 188, + nesto_numbers_21px, + }, + { + 44, 396, + 1, 45, 62, 102, 142, 185, 226, 268, 306, 351, 394, + nesto_numbers_44px, + } + }; +*/ + +// Generated by : ImageConverter 565 Online +// Generated from : nesto_numbers_44px.png +// Time generated : Thu, 24 Oct 24 09:16:27 +0200 (Server timezone: CET) +// Image Size : 396x44 pixels +// Memory usage : 34848 bytes + +const uint16_t nesto_numbers_44px[17424] = { +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0010 (16) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0020 (32) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0030 (48) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0040 (64) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0050 (80) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0060 (96) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0070 (112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0080 (128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0090 (144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00A0 (160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00B0 (176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00C0 (192) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00D0 (208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00E0 (224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00F0 (240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0100 (256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0110 (272) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0120 (288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0130 (304) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0140 (320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0150 (336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0160 (352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0170 (368) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0180 (384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0190 (400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01A0 (416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01B0 (432) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01C0 (448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01D0 (464) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01E0 (480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01F0 (496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0200 (512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0210 (528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0220 (544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0230 (560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0240 (576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0250 (592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0260 (608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0270 (624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0280 (640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0290 (656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02A0 (672) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02B0 (688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02C0 (704) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02D0 (720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02E0 (736) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02F0 (752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0300 (768) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0310 (784) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0320 (800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0330 (816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0340 (832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0350 (848) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0360 (864) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0370 (880) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0380 (896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0390 (912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03A0 (928) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03B0 (944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03C0 (960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03D0 (976) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03E0 (992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03F0 (1008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0400 (1024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0410 (1040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0420 (1056) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0430 (1072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0440 (1088) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0450 (1104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0460 (1120) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0470 (1136) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0480 (1152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0490 (1168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x04A0 (1184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x04B0 (1200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x2165, 0x42AB, 0x5BAF, 0x7451, 0x7CB3, 0x84F4, 0x84F4, 0x7CD4, 0x7472, 0x63AF, // 0x04C0 (1216) pixels +0x4ACC, 0x2986, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x04D0 (1232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x2165, 0x3208, 0x3208, 0x3208, 0x3208, 0x3A29, 0x2986, 0x0000, // 0x04E0 (1248) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x04F0 (1264) pixels +0x0000, 0x0861, 0x2165, 0x428A, 0x5B8F, 0x7451, 0x7CD3, 0x84F4, 0x84F4, 0x84D4, 0x7492, 0x6C10, 0x534D, 0x3A29, 0x18E4, 0x0020, // 0x0500 (1280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0510 (1296) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x10A2, 0x2166, 0x426A, 0x5B4E, 0x6BF0, 0x7472, 0x7CD4, 0x8515, 0x8515, 0x84F4, 0x7CB3, // 0x0520 (1312) pixels +0x7451, 0x5B8E, 0x42AB, 0x2986, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0530 (1328) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0540 (1344) pixels +0x0000, 0x0000, 0x0862, 0x3208, 0x3208, 0x31C7, 0x31C7, 0x31C7, 0x31E8, 0x29A7, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0550 (1360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0560 (1376) pixels +0x2145, 0x3A29, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, // 0x0570 (1392) pixels +0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31E8, // 0x0580 (1408) pixels +0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0590 (1424) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x31E7, 0x532D, 0x63F0, 0x7492, 0x7CD4, 0x8515, 0x8515, 0x84F4, 0x7CB3, // 0x05A0 (1440) pixels +0x6C31, 0x5B6E, 0x428A, 0x2166, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x05B0 (1456) pixels +0x0000, 0x0000, 0x10A2, 0x3A49, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, // 0x05C0 (1472) pixels +0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, 0x3208, // 0x05D0 (1488) pixels +0x3208, 0x3208, 0x3A28, 0x10E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x05E0 (1504) pixels +0x0000, 0x0000, 0x0020, 0x10C3, 0x31C7, 0x4AEC, 0x63CF, 0x7472, 0x7CB3, 0x84F4, 0x8D35, 0x8535, 0x8514, 0x7CD3, 0x7492, 0x63F0, // 0x05F0 (1520) pixels +0x532D, 0x3A49, 0x2125, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0600 (1536) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, // 0x0610 (1552) pixels +0x29A7, 0x4AEC, 0x63CF, 0x7472, 0x84F4, 0x8515, 0x84F4, 0x84F4, 0x7472, 0x63CF, 0x4B0C, 0x29C7, 0x10A2, 0x0000, 0x0000, 0x0000, // 0x0620 (1568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0630 (1584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x3A49, // 0x0640 (1600) pixels +0x7472, 0xA639, 0xBF1D, 0xC77E, 0xCFBF, 0xC79F, 0xC75E, 0xC75E, 0xC75E, 0xC75E, 0xC77F, 0xCFBF, 0xC77F, 0xBF1D, 0xA639, 0x7C93, // 0x0650 (1616) pixels +0x42AB, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 0x0660 (1632) pixels +0x3A49, 0x5B6E, 0x7C93, 0x9DD8, 0xAE9B, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF1D, 0xC77F, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0670 (1648) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x428A, 0x7C93, 0xA639, 0xBF1D, 0xC77E, // 0x0680 (1664) pixels +0xCF9F, 0xC77F, 0xC75E, 0xBF3E, 0xBF3E, 0xC75E, 0xC77E, 0xC79F, 0xC79F, 0xBF5E, 0xB6DC, 0x95B7, 0x63AF, 0x2986, 0x0000, 0x0000, // 0x0690 (1680) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x18E3, 0x3A08, 0x532D, // 0x06A0 (1696) pixels +0x7472, 0x9597, 0xA63A, 0xB6FC, 0xC77F, 0xC79F, 0xC75E, 0xBF5E, 0xBF3E, 0xBF3E, 0xBF5E, 0xC75E, 0xC77F, 0xC79F, 0xC77E, 0xBF1D, // 0x06B0 (1712) pixels +0xAE7A, 0x84F4, 0x532D, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06C0 (1728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x638F, // 0x06D0 (1744) pixels +0xAE9B, 0xBF3E, 0xBF3D, 0xBF1D, 0xB6DC, 0xAE9B, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06E0 (1760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31E8, 0x9DD8, 0xBF3E, 0xBF1D, // 0x06F0 (1776) pixels +0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, // 0x0700 (1792) pixels +0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xBF1D, 0xC77F, 0x84F4, 0x0000, 0x0000, 0x0000, // 0x0710 (1808) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, // 0x0720 (1824) pixels +0x534D, 0x8D55, 0xB6DC, 0xBF3E, 0xC75E, 0xC75E, 0xBF3E, 0xBF1D, 0xB6FD, 0xB6FD, 0xBF1D, 0xBF3D, 0xC75E, 0xC75E, 0xBF3E, 0xBF1D, // 0x0730 (1840) pixels +0xAE9B, 0x8D35, 0x5B8E, 0x29C7, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x8D35, // 0x0740 (1856) pixels +0xC77F, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, 0xBF3E, // 0x0750 (1872) pixels +0xBF3E, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF3D, 0xBF1D, 0xC75E, 0x530C, // 0x0760 (1888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2986, 0x4AEC, 0x7452, 0x9576, // 0x0770 (1904) pixels +0xA619, 0xAEBB, 0xB6FD, 0xB6BC, 0xAE7B, 0xAE5A, 0xA63A, 0xA63A, 0xA65A, 0xAE7B, 0xAE9C, 0xB6DC, 0xBEFD, 0xB6FD, 0xB6FC, 0xA65A, // 0x0780 (1920) pixels +0x84F4, 0x530C, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0790 (1936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x4AEC, 0x84F4, 0xAE9B, 0xBF3E, 0xC75E, 0xC77E, 0xBF5E, // 0x07A0 (1952) pixels +0xBF1D, 0xB6FD, 0xB6DC, 0xB6FD, 0xBF1D, 0xC75E, 0xBF3E, 0xBF3D, 0xAEBB, 0x8535, 0x5B6E, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07B0 (1968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07C0 (1984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x42AB, 0x9597, 0xBF1D, 0xCF9F, 0xBF1D, 0xAE7B, 0x9DF9, // 0x07D0 (2000) pixels +0x9577, 0x8D36, 0x8D16, 0x8515, 0x8515, 0x8D16, 0x8D56, 0x9597, 0x9DF9, 0xAE7B, 0xBF1D, 0xC79F, 0xC77F, 0xA639, 0x5B6E, 0x0882, // 0x07E0 (2016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x532D, 0x9DF9, 0xA63A, 0x9DD8, // 0x07F0 (2032) pixels +0x95B8, 0x9DD8, 0x9DD8, 0x9DD8, 0xAE9B, 0xC79F, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0800 (2048) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1925, 0x5B4D, 0x9597, 0xB6DC, 0xC75E, 0xB6FD, 0xA65A, 0x9DD8, 0x9577, 0x8D36, 0x8515, 0x84F5, // 0x0810 (2064) pixels +0x84F5, 0x8D15, 0x8D36, 0x8D57, 0x9DD8, 0xA63A, 0xB6DC, 0xC75E, 0xCF9F, 0xBF1D, 0x8D35, 0x3A28, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0820 (2080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x31C7, 0x530D, 0x6C11, 0x7CD4, 0x8D36, 0x9577, 0x9577, 0x9597, 0x9577, // 0x0830 (2096) pixels +0x8D57, 0x8D36, 0x8515, 0x84F5, 0x84D5, 0x84D5, 0x84F5, 0x8515, 0x8D36, 0x9577, 0x9DD8, 0xA65A, 0xB6DC, 0xC77F, 0xC79F, 0xB6DC, // 0x0840 (2112) pixels +0x7492, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0850 (2128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x18E4, 0x4ACC, 0x9DB8, 0x9597, 0x9DB8, // 0x0860 (2144) pixels +0xB6DC, 0xB6FD, 0x29A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0870 (2160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, 0x31C8, 0x8D15, 0x9557, 0x8D56, 0x8D56, 0x8D56, 0x8D57, // 0x0880 (2176) pixels +0x8D57, 0x8D57, 0x8D57, 0x8D57, 0x9557, 0x9557, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, // 0x0890 (2192) pixels +0x9577, 0x9597, 0x9597, 0x9597, 0x9597, 0x9577, 0x9DF9, 0xC79F, 0x8514, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08A0 (2208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x6BF0, 0xA639, 0xBF1D, 0xBF1D, 0xA63A, 0x9597, // 0x08B0 (2224) pixels +0x8D16, 0x84D5, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x84D5, 0x8D16, 0x9577, 0x9DD8, 0xAE5A, 0xBF1D, 0xC77E, 0xBF3E, // 0x08C0 (2240) pixels +0x95D8, 0x5B6E, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2987, 0x8D36, 0xA63A, 0xA619, 0xA619, // 0x08D0 (2256) pixels +0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA619, 0xA61A, 0xA61A, // 0x08E0 (2272) pixels +0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA65A, 0xBF1D, 0xC77E, 0x530C, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08F0 (2288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x31C7, 0x5B4E, 0x7452, 0x84D5, 0x84F5, 0x84F5, 0x84D4, 0x7CB4, 0x7C94, 0x7C94, // 0x0900 (2304) pixels +0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x84B4, 0x84D4, 0x84D5, 0x84F5, 0x9577, 0x9DF9, 0xB6DC, 0xC75E, 0xB6FC, 0x84F4, // 0x0910 (2320) pixels +0x31E7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0920 (2336) pixels +0x0000, 0x0000, 0x2125, 0x5B8F, 0x95B7, 0xB6DC, 0xBEFD, 0xAE7B, 0x9DD8, 0x8D56, 0x84F5, 0x7CB4, 0x7C94, 0x7C94, 0x7C94, 0x7CB4, // 0x0930 (2352) pixels +0x7CB4, 0x84D5, 0x8D36, 0x9597, 0xA63A, 0xBEFD, 0xC77F, 0xBF1D, 0x84F4, 0x426A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0940 (2368) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0950 (2384) pixels +0x0000, 0x0000, 0x0000, 0x29A7, 0x7CD4, 0xAE7B, 0xAE9B, 0xA63A, 0x9577, 0x84D4, 0x7C73, 0x7453, 0x7453, 0x7C73, 0x7C94, 0x7C94, // 0x0960 (2400) pixels +0x7C94, 0x7C94, 0x7C94, 0x7C73, 0x7C73, 0x7C94, 0x84F5, 0x9597, 0xAE7B, 0xC75E, 0xC79F, 0xA639, 0x428A, 0x0000, 0x0000, 0x0000, // 0x0970 (2416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x1905, 0x6390, 0x84B4, 0x7C93, 0x7C73, 0x7473, 0x7473, 0x7452, // 0x0980 (2432) pixels +0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x530D, // 0x0990 (2448) pixels +0x84F5, 0x9DD8, 0x9DD8, 0x9577, 0x84F5, 0x7C94, 0x7453, 0x7453, 0x7453, 0x7C73, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C93, // 0x09A0 (2464) pixels +0x7C73, 0x7C73, 0x7CB4, 0x8D36, 0x9DF9, 0xB6FD, 0xC79F, 0xBF3E, 0x7492, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09B0 (2480) pixels +0x0000, 0x0000, 0x10A3, 0x4AAC, 0x6BF0, 0x7432, 0x7473, 0x7C73, 0x7C73, 0x7473, 0x7453, 0x7453, 0x7453, 0x7C73, 0x7C94, 0x7C94, // 0x09C0 (2496) pixels +0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7C94, 0x7C94, 0x7C93, 0x7C94, 0x84B4, 0x8D56, 0xA619, 0xBEFD, 0xCF9F, 0xBEFD, 0x7472, 0x10C3, // 0x09D0 (2512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09E0 (2528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2125, 0x31C8, 0x7453, 0x7453, 0x84D4, 0xBF1D, 0xB6FC, 0x29A6, 0x0000, // 0x09F0 (2544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A00 (2560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2967, 0x6BF1, 0x7453, 0x7432, 0x7453, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C94, 0x7C94, // 0x0A10 (2576) pixels +0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x84B4, 0x84B4, 0x84B4, 0x84B4, 0x84D4, // 0x0A20 (2592) pixels +0x84D4, 0x7CB4, 0x9557, 0xC79F, 0x84F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A30 (2608) pixels +0x0000, 0x0000, 0x0000, 0x0882, 0x532D, 0x9577, 0xA619, 0x95B8, 0x8D15, 0x7C94, 0x7453, 0x7473, 0x7C94, 0x7CB4, 0x7CB4, 0x7C94, // 0x0A40 (2624) pixels +0x7C94, 0x7C93, 0x7C94, 0x7CB4, 0x84D4, 0x84D5, 0x7CB4, 0x7C94, 0x7CB4, 0x84B4, 0x8D36, 0x9DF9, 0xB6FC, 0xC79F, 0xB6DC, 0x6C31, // 0x0A50 (2640) pixels +0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2106, 0x5B2E, 0x7C73, 0x7453, 0x7453, 0x7453, 0x7453, 0x7453, 0x7453, // 0x0A60 (2656) pixels +0x7453, 0x7473, 0x7473, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C93, 0x7C93, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C94, // 0x0A70 (2672) pixels +0x7C94, 0x7C94, 0x7C94, 0x7C93, 0x84F5, 0xB6DC, 0xC75E, 0x4B0C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A80 (2688) pixels +0x1904, 0x424A, 0x532E, 0x6BF1, 0x7453, 0x7473, 0x7453, 0x7453, 0x7C73, 0x7453, 0x7432, 0x63D0, 0x5B6F, 0x5B4E, 0x532E, 0x5B2E, // 0x0A90 (2704) pixels +0x5B2E, 0x5B6F, 0x63B0, 0x6BF1, 0x7453, 0x7C94, 0x84D4, 0x7CB4, 0x7CB4, 0x8D16, 0xA63A, 0xC75E, 0xBF5E, 0x7CB3, 0x10C3, 0x0000, // 0x0AA0 (2720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x4ACC, 0x84D4, 0x9597, // 0x0AB0 (2736) pixels +0x9597, 0x8D36, 0x7CB4, 0x7453, 0x7453, 0x7C73, 0x7C94, 0x7CB4, 0x7C94, 0x7C73, 0x7C73, 0x7C93, 0x7C94, 0x84B4, 0x7CB4, 0x7C94, // 0x0AC0 (2752) pixels +0x7C94, 0x7CB4, 0x8D36, 0xA63A, 0xC75E, 0xC77F, 0x8D56, 0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AD0 (2768) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4AAB, 0x8D56, // 0x0AE0 (2784) pixels +0x9DD8, 0x9597, 0x84F5, 0x7473, 0x7432, 0x7473, 0x7C94, 0x7C94, 0x7453, 0x7412, 0x6BF1, 0x63B0, 0x63B0, 0x6BF1, 0x7432, 0x7453, // 0x0AF0 (2800) pixels +0x7CB4, 0x84D5, 0x7C94, 0x7C73, 0x7CB4, 0x9577, 0xAE9B, 0xC77F, 0xC77E, 0x7472, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B00 (2816) pixels +0x0000, 0x0000, 0x0000, 0x0841, 0x1905, 0x5B6F, 0x7C94, 0x7453, 0x7453, 0x7C73, 0x7C73, 0x7453, 0x9DD9, 0xC77F, 0x8D56, 0x0000, // 0x0B10 (2832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x31E8, 0x6BF0, 0x7CB4, 0x84D4, 0x7CB4, 0x7473, 0x7433, // 0x0B20 (2848) pixels +0x7453, 0x7C74, 0x7C94, 0x7453, 0x7412, 0x6BD1, 0x638F, 0x5B4F, 0x5B4F, 0x638F, 0x63D0, 0x7432, 0x7C73, 0x84D4, 0x7CB4, 0x7C73, // 0x0B30 (2864) pixels +0x7C73, 0x84F5, 0xA619, 0xBF3D, 0xC79F, 0x95B7, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x2126, // 0x0B40 (2880) pixels +0x63D0, 0x7C73, 0x7453, 0x7453, 0x7453, 0x7C73, 0x7453, 0x7453, 0x7412, 0x6BD1, 0x5B6F, 0x5B4E, 0x532E, 0x532E, 0x5B2E, 0x5B6F, // 0x0B50 (2896) pixels +0x63B0, 0x7432, 0x7C73, 0x84D4, 0x84B4, 0x7C94, 0x7C73, 0x84F5, 0x9DF9, 0xBF1D, 0xCFBF, 0xA619, 0x2166, 0x0000, 0x0000, 0x0000, // 0x0B60 (2912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B70 (2928) pixels +0x0000, 0x0000, 0x10A3, 0x2105, 0x3A2A, 0x7C94, 0x7C73, 0x84F5, 0xBF1D, 0xB6BC, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B80 (2944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B90 (2960) pixels +0x18E5, 0x2987, 0x6C12, 0x7C73, 0x7453, 0x52ED, 0x4ACC, 0x530D, 0x530D, 0x530D, 0x530D, 0x530D, 0x530D, 0x530D, 0x530D, 0x530E, // 0x0BA0 (2976) pixels +0x530E, 0x530E, 0x530E, 0x530E, 0x530E, 0x532E, 0x532E, 0x5B2E, 0x5B4E, 0x5B6F, 0x5B6F, 0x638F, 0x63B0, 0x6390, 0x7452, 0xC77F, // 0x0BB0 (2992) pixels +0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x6C11, // 0x0BC0 (3008) pixels +0x8D36, 0x8515, 0x7C94, 0x7453, 0x7453, 0x7C94, 0x7C94, 0x7432, 0x638F, 0x52ED, 0x428B, 0x3A4A, 0x3A2A, 0x3A0A, 0x3A2A, 0x424A, // 0x0BD0 (3024) pixels +0x428B, 0x4ACD, 0x5B6F, 0x6BF1, 0x7473, 0x84B4, 0x84D4, 0x7C94, 0x84D4, 0x9577, 0xAE9B, 0xC79F, 0xAE7A, 0x3208, 0x0000, 0x0000, // 0x0BE0 (3040) pixels +0x0000, 0x0000, 0x1082, 0x2126, 0x5B4F, 0x7C74, 0x7453, 0x7453, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C73, 0x7C94, // 0x0BF0 (3056) pixels +0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7CB4, 0x7C94, // 0x0C00 (3072) pixels +0x8515, 0xB6DC, 0xC75E, 0x4B0C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x31E9, 0x4AAC, 0x6BF1, 0x7C73, // 0x0C10 (3088) pixels +0x7453, 0x7453, 0x7C73, 0x7473, 0x6C11, 0x5B6F, 0x428B, 0x29A7, 0x2105, 0x1905, 0x18E5, 0x18E5, 0x18E5, 0x1905, 0x2126, 0x2146, // 0x0C20 (3104) pixels +0x29A8, 0x3A2A, 0x52ED, 0x6C11, 0x84D4, 0x7CB4, 0x7C93, 0x8D16, 0xAE9B, 0xCF9F, 0xA619, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C30 (3120) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x5B6E, 0x7C73, 0x7C93, 0x7C94, 0x7453, 0x7432, 0x7453, 0x7C73, // 0x0C40 (3136) pixels +0x7432, 0x63D0, 0x532E, 0x4A8C, 0x424B, 0x3A2A, 0x3A0A, 0x3A2A, 0x3A4A, 0x4A8C, 0x530E, 0x6BD1, 0x7C73, 0x84D4, 0x7C94, 0x7C73, // 0x0C50 (3152) pixels +0x8515, 0xA63A, 0xC77E, 0xBF3E, 0x6C11, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C60 (3168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x530C, 0x8515, 0x8515, 0x84D4, 0x7453, 0x7432, 0x7453, // 0x0C70 (3184) pixels +0x7C74, 0x7412, 0x5B2E, 0x424B, 0x31C8, 0x2967, 0x2146, 0x2146, 0x2126, 0x2146, 0x2967, 0x31A8, 0x424A, 0x5B4E, 0x7452, 0x84D4, // 0x0C80 (3200) pixels +0x7CB4, 0x7C73, 0x7CB4, 0x9DF9, 0xBF1D, 0xCF9F, 0x8D56, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x0C90 (3216) pixels +0x2967, 0x63B0, 0x5B4E, 0x31A8, 0x31E9, 0x6C12, 0x7C94, 0x7453, 0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CA0 (3232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x532E, 0x6C11, 0x7432, 0x7433, 0x7433, 0x7C73, 0x7473, 0x6BF1, 0x5B2E, 0x426B, 0x31E9, // 0x0CB0 (3248) pixels +0x2987, 0x2146, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2967, 0x31E9, 0x4A8C, 0x63B0, 0x7CB4, 0x7CB4, 0x7C73, 0x7C73, 0x9597, // 0x0CC0 (3264) pixels +0xB6FD, 0xC79F, 0x95B7, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2126, 0x63B0, 0x7453, 0x7453, 0x7452, // 0x0CD0 (3280) pixels +0x6C12, 0x6BD0, 0x5B6F, 0x4ACC, 0x3A4A, 0x31A8, 0x2146, 0x2126, 0x2126, 0x2125, 0x2126, 0x2126, 0x2126, 0x2967, 0x31C8, 0x428B, // 0x0CE0 (3296) pixels +0x6390, 0x7C93, 0x84D5, 0x7C94, 0x7C73, 0x8D36, 0xB6BC, 0xC79F, 0xAE7B, 0x2165, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CF0 (3312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, 0x1905, // 0x0D00 (3328) pixels +0x428B, 0x7C94, 0x7453, 0x8D36, 0xBF3E, 0xAE7A, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D10 (3344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x6BF2, 0x7432, // 0x0D20 (3360) pixels +0x9577, 0x8515, 0x2966, 0x18C4, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, // 0x0D30 (3376) pixels +0x18E5, 0x18E5, 0x18E5, 0x1905, 0x1905, 0x2105, 0x2105, 0x2125, 0x2126, 0x2126, 0x2105, 0x63D0, 0x7CB3, 0x0000, 0x0000, 0x0000, // 0x0D40 (3392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2166, 0x6BF1, 0x7473, 0x7473, 0x7453, 0x7433, 0x7C73, // 0x0D50 (3408) pixels +0x7453, 0x5B6F, 0x424A, 0x2987, 0x2126, 0x2105, 0x18E5, 0x18E4, 0x18E4, 0x18C4, 0x18C4, 0x18C4, 0x18C4, 0x18E4, 0x2105, 0x2146, // 0x0D60 (3424) pixels +0x31A8, 0x426B, 0x5B4E, 0x7452, 0x84D5, 0x7CB4, 0x7C94, 0x9DB8, 0xCFBF, 0x5B8E, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2146, // 0x0D70 (3440) pixels +0x31C9, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, // 0x0D80 (3456) pixels +0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A2A, 0x3A4A, 0x3A4A, 0x3A4A, 0x3A09, 0x530D, 0x84B4, 0x7C94, 0x84F5, 0xB6DC, 0xC77E, 0x530C, // 0x0D90 (3472) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2146, 0x3A09, 0x6C12, 0x7C73, 0x7432, 0x7473, 0x8D36, 0x8D56, 0x84D4, // 0x0DA0 (3488) pixels +0x638F, 0x3A29, 0x1925, 0x1082, 0x0041, 0x0020, 0x0020, 0x0020, 0x0020, 0x0021, 0x0841, 0x0862, 0x10A3, 0x18C4, 0x1905, 0x2146, // 0x0DB0 (3504) pixels +0x426B, 0x7432, 0x84D5, 0x7C93, 0x7CB4, 0xA65A, 0xCF9F, 0xA619, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DC0 (3520) pixels +0x0000, 0x0000, 0x18E4, 0x532D, 0x63B0, 0x6C11, 0x7453, 0x7433, 0x7453, 0x7453, 0x7412, 0x5B6F, 0x4A8B, 0x31C8, 0x2126, 0x18E5, // 0x0DD0 (3536) pixels +0x18E4, 0x18E4, 0x18E4, 0x18E4, 0x18E4, 0x18E5, 0x2105, 0x2146, 0x31C8, 0x4ACC, 0x7432, 0x84D5, 0x7C94, 0x7C73, 0x8D56, 0xB6DC, // 0x0DE0 (3552) pixels +0xCFBF, 0x8D76, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DF0 (3568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x4AAB, 0x7C73, 0x7473, 0x7473, 0x7432, 0x7432, 0x7453, 0x7432, 0x5B4E, 0x39E9, 0x2126, 0x1905, // 0x0E00 (3584) pixels +0x18E5, 0x18E4, 0x18C4, 0x10A3, 0x10A3, 0x18C4, 0x18E4, 0x18E5, 0x1905, 0x2105, 0x2987, 0x4AAC, 0x7432, 0x84D5, 0x7C94, 0x7C73, // 0x0E10 (3600) pixels +0x9577, 0xBEFD, 0xC79F, 0x8D56, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x5B6F, 0x6BF1, 0x3A09, 0x18E4, // 0x0E20 (3616) pixels +0x2146, 0x6BF1, 0x7C94, 0x7453, 0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E30 (3632) pixels +0x10A3, 0x2987, 0x6BF1, 0x7453, 0x7453, 0x7432, 0x638F, 0x424A, 0x2967, 0x2126, 0x1905, 0x18E5, 0x18E4, 0x18C4, 0x10A3, 0x10A3, // 0x0E40 (3648) pixels +0x1083, 0x1083, 0x10C4, 0x18E4, 0x1905, 0x1905, 0x2126, 0x3A2A, 0x6BF1, 0x84B4, 0x7C94, 0x7453, 0x9577, 0xBF1D, 0xC79F, 0x6C31, // 0x0E50 (3664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x7452, 0x8D16, 0x84D4, 0x7C93, 0x6C11, 0x5B4E, 0x42AB, 0x3A09, // 0x0E60 (3680) pixels +0x2966, 0x18E4, 0x1083, 0x0862, 0x0862, 0x0862, 0x0862, 0x1082, 0x10A3, 0x18C4, 0x18E5, 0x1905, 0x2125, 0x31C8, 0x5B6F, 0x7CB4, // 0x0E70 (3696) pixels +0x7CB4, 0x7C73, 0x8515, 0xB6BC, 0xC79F, 0x95B7, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E80 (3712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x1905, 0x530D, 0x7C94, 0x7432, 0x95B8, // 0x0E90 (3728) pixels +0xC77F, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EA0 (3744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x6BF1, 0x7412, 0x8D57, 0xCFDF, 0x5B6E, 0x0000, // 0x0EB0 (3760) pixels +0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0021, // 0x0EC0 (3776) pixels +0x0021, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0ED0 (3792) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x5B6E, 0x63D0, 0x7432, 0x7433, 0x7453, 0x7453, 0x63D0, 0x428B, 0x31C8, 0x2146, 0x1905, // 0x0EE0 (3808) pixels +0x10C3, 0x0862, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0841, 0x0862, 0x1083, 0x10C4, 0x1905, 0x2987, // 0x0EF0 (3824) pixels +0x428B, 0x6BF1, 0x7CB4, 0x9577, 0xC77E, 0x534D, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2146, 0x1905, 0x18E5, 0x18E5, 0x18E5, // 0x0F00 (3840) pixels +0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, 0x18E5, // 0x0F10 (3856) pixels +0x18E5, 0x18E5, 0x18E5, 0x18E4, 0x10A3, 0x3A2A, 0x84D5, 0x7C93, 0x8D15, 0xBEFD, 0xC75E, 0x4B0C, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F20 (3872) pixels +0x0000, 0x0862, 0x2126, 0x2126, 0x6390, 0x7C73, 0x7432, 0x7C94, 0xA63A, 0xAE9B, 0x8D56, 0x428A, 0x10A2, 0x0000, 0x0000, 0x0000, // 0x0F30 (3888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x18E5, 0x18E5, 0x2967, 0x6BD1, 0x84D5, // 0x0F40 (3904) pixels +0x7C93, 0x84D5, 0xB6BC, 0xCFBF, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x426B, 0x4AED, // 0x0F50 (3920) pixels +0x6390, 0x7433, 0x7433, 0x7432, 0x7453, 0x7432, 0x63D0, 0x532E, 0x3A4A, 0x2146, 0x1082, 0x0841, 0x0020, 0x0000, 0x0000, 0x0020, // 0x0F60 (3936) pixels +0x0021, 0x0861, 0x1082, 0x18C4, 0x1905, 0x1905, 0x2967, 0x52ED, 0x7C93, 0x84B4, 0x7C73, 0x84D5, 0xAE5A, 0xCFBF, 0x9DF8, 0x18E4, // 0x0F70 (3952) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31E8, // 0x0F80 (3968) pixels +0x6BF0, 0x6BF0, 0x7432, 0x7432, 0x7432, 0x7433, 0x6C12, 0x532E, 0x428B, 0x3A09, 0x2125, 0x0862, 0x0021, 0x0000, 0x0000, 0x0000, // 0x0F90 (3984) pixels +0x0000, 0x0000, 0x0000, 0x0020, 0x0862, 0x18C4, 0x2105, 0x18E5, 0x2987, 0x638F, 0x84B4, 0x7C94, 0x7473, 0x9577, 0xBF1D, 0xC79F, // 0x0FA0 (4000) pixels +0x7472, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x1924, 0x0861, 0x0862, 0x2125, 0x2967, 0x6BF1, 0x7C94, 0x7433, // 0x0FB0 (4016) pixels +0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2987, 0x6BF1, 0x7433, // 0x0FC0 (4032) pixels +0x63B0, 0x52ED, 0x3A09, 0x2146, 0x18E4, 0x10A3, 0x0861, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FD0 (4048) pixels +0x0041, 0x10A3, 0x2105, 0x1905, 0x2146, 0x638F, 0x7CB4, 0x7C73, 0x7473, 0xA619, 0xBF3E, 0xB6FD, 0x2145, 0x0000, 0x0000, 0x0000, // 0x0FE0 (4064) pixels +0x0000, 0x0000, 0x0841, 0x5B6F, 0xA619, 0x8515, 0x63D0, 0x428A, 0x2166, 0x10C3, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FF0 (4080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0882, 0x18E5, 0x2105, 0x1905, 0x426B, 0x7C93, 0x7CB4, 0x7453, 0x8D56, // 0x1000 (4096) pixels +0xBF1D, 0xC77F, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1010 (4112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2125, 0x2146, 0x63D0, 0x7C73, 0x7453, 0xA63A, 0xCFBF, 0x63AF, 0x0000, 0x0000, // 0x1020 (4128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1030 (4144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x6BF1, 0x7412, 0x8D56, 0xCF9F, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1040 (4160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1050 (4176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, // 0x1060 (4192) pixels +0x4ACC, 0x5B4E, 0x6BF1, 0x7433, 0x7433, 0x7432, 0x5B8F, 0x4AAC, 0x426A, 0x29A7, 0x10A3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1070 (4208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0882, 0x10C4, 0x2146, 0x426B, 0x84F5, // 0x1080 (4224) pixels +0xC79F, 0x534D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, // 0x1090 (4240) pixels +0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x2146, // 0x10A0 (4256) pixels +0x2987, 0x530D, 0x7CB4, 0x7C94, 0x7473, 0x7C93, 0x6BF0, 0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2105, 0x3A0A, // 0x10B0 (4272) pixels +0x7453, 0x7432, 0x7432, 0xA63A, 0xC75E, 0x9E19, 0x2166, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10C0 (4288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x18E4, 0x1905, 0x2987, 0x7453, 0x7CB4, 0x7C73, 0x9DD8, 0xC75E, // 0x10D0 (4304) pixels +0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x3A2A, 0x52ED, 0x7432, 0x7432, 0x6C12, 0x7C94, // 0x10E0 (4320) pixels +0x84F5, 0x84D4, 0x63AF, 0x29A7, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10F0 (4336) pixels +0x0021, 0x10A3, 0x1905, 0x1905, 0x31C8, 0x6BD1, 0x84D5, 0x7C73, 0x7C94, 0xA63A, 0xCF9F, 0x9DD8, 0x10A2, 0x0000, 0x0000, 0x0000, // 0x1100 (4352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x532E, 0x5B4E, 0x6BD1, 0x7432, 0x7432, // 0x1110 (4368) pixels +0x7432, 0x7432, 0x6BF0, 0x638F, 0x4AAB, 0x10E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1120 (4384) pixels +0x0000, 0x0000, 0x0841, 0x1905, 0x2105, 0x2105, 0x530D, 0x7CB4, 0x7C94, 0x7473, 0x9DB8, 0xBF3D, 0xC75E, 0x428A, 0x0000, 0x0000, // 0x1130 (4400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6BF1, 0x7C73, 0x7432, 0x9DD8, 0xC77F, 0x8D56, 0x0000, // 0x1140 (4416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2967, 0x6BD1, 0x6BF1, 0x532E, 0x3A2A, 0x2125, 0x0861, // 0x1150 (4432) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x1905, // 0x1160 (4448) pixels +0x2105, 0x2146, 0x6BF1, 0x7CB4, 0x7453, 0x8D16, 0xB6FD, 0xC77E, 0x530C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x6C11, // 0x1170 (4464) pixels +0x3A69, 0x10E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1180 (4480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x18E4, 0x428B, 0x7CB4, 0x7C93, 0x7C93, 0xAE7A, 0xC79F, 0x84D4, 0x0000, // 0x1190 (4496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11A0 (4512) pixels +0x0000, 0x10A3, 0x2105, 0x31E9, 0x7453, 0x7453, 0x7CB4, 0xB6FC, 0xBF3D, 0x29C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11B0 (4528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11C0 (4544) pixels +0x18E5, 0x2987, 0x6BF1, 0x6C12, 0x8D56, 0xC79F, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11D0 (4560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11E0 (4576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x31E9, 0x4A8B, 0x63B0, 0x7433, 0x7432, // 0x11F0 (4592) pixels +0x7432, 0x63B0, 0x5B4E, 0x4ACC, 0x1925, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1200 (4608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x10A3, 0x31E8, 0xB6BB, 0x5B8E, 0x0000, 0x0000, // 0x1210 (4624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1220 (4640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x530D, 0x63D0, 0x7C94, 0x7C94, 0x7452, // 0x1230 (4656) pixels +0x63B0, 0x4AED, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, 0x1905, 0x4ACD, 0x7453, 0x6BF2, 0x84D5, 0xBF1D, // 0x1240 (4672) pixels +0xC75E, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1250 (4688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x18E5, 0x5B2E, 0x84D4, 0x7C73, 0x8D36, 0xBF1D, 0xBF3E, 0x31E8, 0x0000, 0x0000, // 0x1260 (4704) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2987, 0x3A09, 0x6BD1, 0x7433, 0x6C12, 0x7CB4, 0x9DF8, 0x9DD8, 0x5B8F, 0x1082, 0x0000, // 0x1270 (4720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x18E4, // 0x1280 (4736) pixels +0x1905, 0x2146, 0x5B6F, 0x84B4, 0x7C73, 0x7C94, 0xAE7A, 0xCFBF, 0x7CB3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1290 (4752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x3A29, 0x52ED, 0x5B4E, 0x7412, 0x7432, 0x6C12, 0x7C73, 0x84D4, 0x7C93, 0x530D, // 0x12A0 (4768) pixels +0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 0x12B0 (4784) pixels +0x18C4, 0x2126, 0x1905, 0x5B2E, 0x84B4, 0x7C73, 0x7C73, 0xAE5A, 0xC77E, 0xA63A, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x12C0 (4800) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6BD1, 0x7C73, 0x7432, 0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x12D0 (4816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x3A09, 0x7452, 0x5B4E, 0x2966, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x12E0 (4832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x2125, 0x18E5, 0x428B, 0x7C94, // 0x12F0 (4848) pixels +0x7C73, 0x7C94, 0xAE9B, 0xC77F, 0x7452, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1300 (4864) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1310 (4880) pixels +0x0000, 0x0000, 0x10A3, 0x2126, 0x2126, 0x6BD1, 0x7CB4, 0x7453, 0x9DD8, 0xC77F, 0x9597, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1320 (4896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x1905, 0x52ED, // 0x1330 (4912) pixels +0x7C74, 0x7412, 0x9577, 0xC77F, 0x9597, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1340 (4928) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x6BD1, 0x6BF2, // 0x1350 (4944) pixels +0x8D36, 0xC79F, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1360 (4960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1370 (4976) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x3A09, 0x52ED, 0x7432, 0x7412, 0x7412, 0x6C11, 0x6BF1, 0x530D, 0x10A2, // 0x1380 (4992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1390 (5008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x638F, 0x5B8F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13A0 (5024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13B0 (5040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x4AAC, 0x638F, 0x7C93, 0x7C94, 0x7453, 0x6BD0, 0x5B8F, 0x1904, 0x0000, 0x0000, // 0x13C0 (5056) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, 0x2105, 0x4ACD, 0x7453, 0x6BF1, 0x8D16, 0xBF3D, 0xB6DC, 0x1904, 0x0000, 0x0000, // 0x13D0 (5072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13E0 (5088) pixels +0x0000, 0x18E4, 0x2105, 0x4ACC, 0x84B4, 0x7C73, 0x8D16, 0xBEFD, 0xBF3E, 0x3A29, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13F0 (5104) pixels +0x1905, 0x2126, 0x4AAC, 0x7433, 0x6BF2, 0x7453, 0xAE7B, 0xB6DC, 0x6C11, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1400 (5120) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2125, 0x2126, 0x638F, // 0x1410 (5136) pixels +0x84B4, 0x7453, 0x84D5, 0xB6DC, 0xC77F, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1420 (5152) pixels +0x0000, 0x10C3, 0x426B, 0x428B, 0x63B0, 0x7432, 0x6BF2, 0x7453, 0x9597, 0x9597, 0x6BF0, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1430 (5168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2126, 0x2146, // 0x1440 (5184) pixels +0x6BF1, 0x7CB4, 0x7453, 0x8515, 0xB6FD, 0xC79F, 0x534D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x1450 (5200) pixels +0x2967, 0x6BD1, 0x7C73, 0x7432, 0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1460 (5216) pixels +0x18E4, 0x63B0, 0x4AAB, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1470 (5232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2105, 0x31E9, 0x7C94, 0x7C73, 0x7C73, 0xAE7B, 0xC77F, // 0x1480 (5248) pixels +0x7C93, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1490 (5264) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, // 0x14A0 (5280) pixels +0x18E5, 0x532E, 0x7CB4, 0x7453, 0x95B8, 0xC77F, 0x9597, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x14B0 (5296) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2987, 0x6BF1, 0x7453, 0x7433, 0xAE7B, 0xCF9F, // 0x14C0 (5312) pixels +0x532D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x14D0 (5328) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x6BD1, 0x6BF2, 0x8D36, 0xC79F, 0x5B6E, 0x0000, // 0x14E0 (5344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x14F0 (5360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1500 (5376) pixels +0x0000, 0x0021, 0x2146, 0x31E8, 0x6BD1, 0x7432, 0x6C12, 0x7453, 0x7C93, 0x63AF, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1510 (5392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1520 (5408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1530 (5424) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1540 (5440) pixels +0x1904, 0x3A4A, 0x532E, 0x7473, 0x7C74, 0x7453, 0x6C11, 0x6BF0, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1550 (5456) pixels +0x0000, 0x1905, 0x1905, 0x428B, 0x7453, 0x6BF1, 0x84D5, 0xBF1D, 0xBEFD, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1560 (5472) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x1905, 0x530D, // 0x1570 (5488) pixels +0x7CB4, 0x7453, 0x8D56, 0xBF3D, 0xBF1D, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x2125, 0x2126, 0x5B6F, 0x7432, // 0x1580 (5504) pixels +0x6BD1, 0x9597, 0xC77E, 0xA63A, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1590 (5520) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x2105, 0x2967, 0x6BF1, 0x7CB4, 0x7453, 0x9577, // 0x15A0 (5536) pixels +0xC77E, 0xA639, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x3A09, 0x4AAC, // 0x15B0 (5552) pixels +0x6C12, 0x6C12, 0x6BF1, 0x95B8, 0xAE7A, 0x8D56, 0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x15C0 (5568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, 0x1905, 0x3A2A, 0x7C94, 0x7C73, 0x7453, // 0x15D0 (5584) pixels +0xA63A, 0xC77E, 0x9DF8, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6BD1, 0x7453, 0x7412, // 0x15E0 (5600) pixels +0x9DD8, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x31C7, 0x0000, 0x0000, // 0x15F0 (5616) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1600 (5632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x1905, 0x3A2A, 0x7C94, 0x7453, 0x7C94, 0xAEBB, 0xC77F, 0x6C11, 0x0000, 0x0000, 0x0000, // 0x1610 (5648) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1620 (5664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x2105, 0x5B6F, 0x7CB4, 0x7453, // 0x1630 (5680) pixels +0x9DD8, 0xC77F, 0x7CD3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1640 (5696) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x1905, 0x4AAC, 0x7C73, 0x6C12, 0x8515, 0xBF3E, 0xA65A, 0x10A2, 0x0000, 0x0000, 0x0000, // 0x1650 (5712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1660 (5728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x6BD1, 0x6BF1, 0x8D36, 0xC79F, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1670 (5744) pixels +0x0020, 0x10C3, 0x1904, 0x2145, 0x2986, 0x2145, 0x2145, 0x1904, 0x10A2, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1680 (5760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x4A8C, // 0x1690 (5776) pixels +0x7432, 0x6BF2, 0x7432, 0x8515, 0x7C93, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2145, 0x31C7, // 0x16A0 (5792) pixels +0x3A49, 0x428A, 0x428A, 0x426A, 0x31E8, 0x2145, 0x10C3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x16B0 (5808) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x16C0 (5824) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x31C8, 0x4AAC, 0x7453, 0x7C73, // 0x16D0 (5840) pixels +0x7453, 0x7432, 0x7452, 0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2125, 0x31E9, // 0x16E0 (5856) pixels +0x7412, 0x6C12, 0x7432, 0xAE9B, 0xC79F, 0x6C10, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x16F0 (5872) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x3A09, 0x2967, 0x6BF1, 0x7C94, 0x7453, 0x95B8, 0xBF5E, // 0x1700 (5888) pixels +0xA639, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2987, 0x6BD1, 0x6C12, 0x6C12, 0xAE5A, 0xC79F, 0x7452, // 0x1710 (5904) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1720 (5920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x1905, 0x31E9, 0x7C73, 0x7C73, 0x7C73, 0xAE7B, 0xC79F, 0x4ACB, 0x0000, // 0x1730 (5936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2987, 0x31A8, 0x5B2E, 0x7412, 0x6BD1, 0x7C94, 0xB6FC, // 0x1740 (5952) pixels +0xBEFD, 0x530C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1750 (5968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x2126, 0x2105, 0x638F, 0x7C94, 0x7453, 0x8D36, 0xBF1D, 0xBF3E, 0x3A29, // 0x1760 (5984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x63D1, 0x7453, 0x6C12, 0x9DB8, 0xC79F, 0x8D56, 0x0000, // 0x1770 (6000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1780 (6016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, // 0x1790 (6032) pixels +0x2125, 0x2126, 0x6390, 0x7C73, 0x7432, 0x84F5, 0xBEFD, 0xC77E, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17A0 (6048) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17B0 (6064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x3A09, 0x31E9, 0x7432, 0x7C73, 0x7C73, 0x9E19, 0xBF3E, 0x4ACC, 0x0000, // 0x17C0 (6080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, // 0x17D0 (6096) pixels +0x2125, 0x29A8, 0x6BF1, 0x7432, 0x7432, 0xA619, 0xC75E, 0x534D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x42AB, 0x8515, // 0x17E0 (6112) pixels +0x7CD4, 0x7CB3, 0x7CB3, 0x7CD4, 0x7472, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17F0 (6128) pixels +0x18E5, 0x2987, 0x6BD1, 0x6BF1, 0x8D36, 0xCFBF, 0x534D, 0x0000, 0x10C3, 0x31E8, 0x5B6E, 0x7CB3, 0x95B7, 0xAE9B, 0xB6FC, 0xBF3D, // 0x1800 (6144) pixels +0xBF5E, 0xC75E, 0xBF3D, 0xB6DC, 0xA65A, 0x95B7, 0x84F4, 0x63AF, 0x3208, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1810 (6160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2146, 0x6370, 0x7412, 0x6BF1, 0x84F5, 0x9597, // 0x1820 (6176) pixels +0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x3A49, 0x6C11, 0x9596, 0xAE7A, 0xBF3D, 0xC75E, 0xC75E, 0xC75E, 0xBF5E, 0xC75E, // 0x1830 (6192) pixels +0xC75E, 0xBF3D, 0xAE9B, 0x95B7, 0x7CB3, 0x4ACB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1840 (6208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1850 (6224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2967, 0x3A2A, 0x6C12, 0x7C73, 0x7453, 0x7452, 0x7C93, 0x4AAB, 0x0000, // 0x1860 (6240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2126, 0x5B4F, 0x7433, 0x6BD1, 0x84F5, // 0x1870 (6256) pixels +0xBF3D, 0xBF3E, 0x530D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1880 (6272) pixels +0x0000, 0x0000, 0x0000, 0x2125, 0x530D, 0x428B, 0x5B2E, 0x7C94, 0x7453, 0x7C94, 0x9E19, 0xBF3D, 0x63CF, 0x0000, 0x0000, 0x0000, // 0x1890 (6288) pixels +0x0000, 0x0000, 0x0000, 0x0882, 0x2126, 0x31A8, 0x6BD1, 0x6BF2, 0x7432, 0xB6BB, 0xCF9F, 0x532D, 0x0000, 0x0000, 0x0000, 0x0000, // 0x18A0 (6304) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x18B0 (6320) pixels +0x0000, 0x0000, 0x0021, 0x2125, 0x1905, 0x530E, 0x7CB4, 0x7453, 0x8D56, 0xC77F, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x18C0 (6336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2146, 0x29A8, 0x63B0, 0x6BF2, 0x6BB1, 0x95B8, 0xC77E, 0xAE7A, 0x10A2, 0x0000, 0x0000, // 0x18D0 (6352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x18E0 (6368) pixels +0x0000, 0x0000, 0x0000, 0x1905, 0x18E5, 0x426B, 0x7C94, 0x7453, 0x7C94, 0xB6BC, 0xC79F, 0x63D0, 0x0000, 0x0000, 0x0000, 0x0000, // 0x18F0 (6384) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x63B0, 0x7453, 0x6C12, 0x9DB8, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1900 (6400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1910 (6416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x29A7, 0x31A8, 0x2146, 0x530D, 0x7C73, 0x7453, // 0x1920 (6432) pixels +0x7433, 0x9597, 0xB6FD, 0xAE9B, 0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1930 (6448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1940 (6464) pixels +0x0041, 0x29A7, 0x532D, 0x4AAC, 0x63B0, 0x7C73, 0x7453, 0x84F5, 0xA65A, 0x95B8, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1950 (6480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2146, 0x2126, 0x530E, 0x7453, 0x6BF1, // 0x1960 (6496) pixels +0x84F5, 0xB6DC, 0x95B7, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2967, 0x8D15, 0xC77F, 0xC77E, 0xC75E, 0xCF9F, // 0x1970 (6512) pixels +0xBF1D, 0x1924, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x63B1, 0x6BD1, // 0x1980 (6528) pixels +0x8D36, 0xBF5E, 0x7452, 0x5B8F, 0x8D35, 0x9DD8, 0x9DF9, 0x9E19, 0x9DD9, 0x9577, 0x8D36, 0x8D16, 0x8D16, 0x8D36, 0x9557, 0x95B8, // 0x1990 (6544) pixels +0xA63A, 0xAE9C, 0xBF1D, 0xC75E, 0xC77E, 0xAE9B, 0x7CB3, 0x426A, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x19A0 (6560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x1905, 0x31E9, 0x6BF2, 0x6BF1, 0x7433, 0x9DD8, 0x8D35, 0x0861, 0x0000, 0x0861, 0x3A09, // 0x19B0 (6576) pixels +0x6C11, 0x9DD8, 0xB6BB, 0xB6DC, 0xB6BC, 0xA619, 0x9597, 0x8D36, 0x8515, 0x84F5, 0x84F5, 0x8D15, 0x8D36, 0x9577, 0xA619, 0xB6BC, // 0x19C0 (6592) pixels +0xBF3E, 0xC77F, 0xB6FC, 0x8515, 0x428A, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x19D0 (6608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x19E0 (6624) pixels +0x0000, 0x0041, 0x2105, 0x2987, 0x63B0, 0x7C73, 0x7433, 0x7473, 0x7CB4, 0x63AF, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x19F0 (6640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2126, 0x31A8, 0x6BF1, 0x7432, 0x6BD1, 0x8D16, 0xBF1D, 0xC77E, 0x8D55, // 0x1A00 (6656) pixels +0x428A, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x31C7, 0x5B8E, 0x7CB3, // 0x1A10 (6672) pixels +0x6C11, 0x63D0, 0x7C73, 0x7473, 0x7453, 0x8D15, 0xA65A, 0x8D56, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, // 0x1A20 (6688) pixels +0x2126, 0x29A8, 0x6BD1, 0x6BF1, 0x6C12, 0xAE9B, 0xCF9F, 0x5B8E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1A30 (6704) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, // 0x1A40 (6720) pixels +0x2105, 0x31A8, 0x7453, 0x7C73, 0x7C94, 0xB6DC, 0xB6FC, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1A50 (6736) pixels +0x18C4, 0x2126, 0x31E9, 0x6BF2, 0x6BD1, 0x6BF2, 0xAE5A, 0xC77F, 0x7CB3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1A60 (6752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, // 0x1A70 (6768) pixels +0x2126, 0x2987, 0x7432, 0x7C73, 0x7453, 0xA63A, 0xC77F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x1A80 (6784) pixels +0x2967, 0x63B0, 0x7433, 0x6BF2, 0x9DB8, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1A90 (6800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1AA0 (6816) pixels +0x0000, 0x0000, 0x0862, 0x29A7, 0x4ACC, 0x532D, 0x4AAC, 0x4A8B, 0x63B0, 0x7C73, 0x7453, 0x7433, 0x7CB4, 0x9597, 0xAE7B, 0x63AF, // 0x1AB0 (6832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1AC0 (6848) pixels +0x0882, 0x31E8, 0x29C7, 0x29A7, 0x29A7, 0x29A7, 0x29A7, 0x29A7, 0x29C7, 0x3A28, 0x4ACB, 0x63AF, 0x7472, 0x7CB3, 0x6BF1, 0x6BF1, // 0x1AD0 (6864) pixels +0x7C73, 0x7453, 0x7C73, 0x8D76, 0x9DF9, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1AE0 (6880) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2146, 0x31A8, 0x3A4A, 0x7412, 0x6C12, 0x7433, 0x9DF9, 0xAE9B, 0x3A29, 0x0000, // 0x1AF0 (6896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x18E4, 0x2126, 0x7432, 0x84D5, 0x8515, 0xB6FD, 0xAE9B, 0x1904, 0x0000, 0x0000, // 0x1B00 (6912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x63B0, 0x6BD1, 0x8D36, 0x9597, 0x7452, 0x7CB4, // 0x1B10 (6928) pixels +0x7C73, 0x7453, 0x7432, 0x7412, 0x7412, 0x7412, 0x7412, 0x7412, 0x7412, 0x7432, 0x7432, 0x7432, 0x7432, 0x7432, 0x7453, 0x84D5, // 0x1B20 (6944) pixels +0x9597, 0xAE9B, 0xC77F, 0xC77F, 0x9DF8, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1B30 (6960) pixels +0x0882, 0x2105, 0x426B, 0x7412, 0x63B1, 0x84D5, 0xAE9B, 0x63AF, 0x0841, 0x3A4A, 0x7472, 0x9597, 0x95B8, 0x8D56, 0x84D5, 0x7473, // 0x1B40 (6976) pixels +0x7412, 0x7412, 0x7412, 0x7412, 0x7412, 0x7432, 0x7432, 0x7432, 0x7432, 0x7432, 0x7432, 0x7432, 0x7C94, 0x8D36, 0xA65A, 0xC75E, // 0x1B50 (6992) pixels +0xC77F, 0x95D8, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1B60 (7008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2125, 0x52ED, // 0x1B70 (7024) pixels +0x7C73, 0x7432, 0x7473, 0x84D4, 0x7C93, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1B80 (7040) pixels +0x0000, 0x0000, 0x0000, 0x18E4, 0x2126, 0x31E9, 0x6390, 0x7432, 0x6BF1, 0x7C74, 0x9DD8, 0xBEFD, 0xC75E, 0xB6BB, 0x95B7, 0x84F4, // 0x1B90 (7056) pixels +0x6C31, 0x63CF, 0x63AF, 0x5B8E, 0x63AF, 0x6C11, 0x7CD3, 0x9576, 0xAE7A, 0xB6FC, 0xA619, 0x84F5, 0x7453, 0x7C73, 0x7453, 0x7453, // 0x1BA0 (7072) pixels +0x7CB4, 0x9597, 0x84F4, 0x1924, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x2146, 0x6390, 0x6BF2, // 0x1BB0 (7088) pixels +0x6BD1, 0x9DF9, 0xC79F, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1BC0 (7104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x18E5, 0x5B2E, 0x7C94, // 0x1BD0 (7120) pixels +0x7433, 0xA619, 0xC77E, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x2105, 0x424B, 0x6BF2, // 0x1BE0 (7136) pixels +0x6BB1, 0x7453, 0xB6DC, 0xC77F, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1BF0 (7152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2126, 0x63B0, 0x7C73, // 0x1C00 (7168) pixels +0x7432, 0x9DB8, 0xC77E, 0xA63A, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x63B0, 0x7433, 0x6BF2, // 0x1C10 (7184) pixels +0x9DB8, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1C20 (7200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x3208, 0x63CF, 0x7CD4, 0x84F4, // 0x1C30 (7216) pixels +0x7452, 0x63B0, 0x63B0, 0x7432, 0x7453, 0x7453, 0x7453, 0x6C32, 0x7473, 0x8D56, 0x7472, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1C40 (7232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x7CD4, 0xC75E, 0xC77E, // 0x1C50 (7248) pixels +0xC75E, 0xC75E, 0xC75E, 0xC75E, 0xC75E, 0xBF5E, 0xB6FD, 0xA63A, 0x8D36, 0x7473, 0x7453, 0x7453, 0x7453, 0x7432, 0x7CD4, 0x8D56, // 0x1C60 (7264) pixels +0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1C70 (7280) pixels +0x0000, 0x1904, 0x3A4A, 0x3A2A, 0x63D1, 0x7412, 0x6BF2, 0x8D36, 0xAE7B, 0x7431, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1C80 (7296) pixels +0x0000, 0x0020, 0x1905, 0x2967, 0x63B0, 0x7432, 0x7C73, 0xB6FC, 0xAE9B, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1C90 (7312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2987, 0x63B0, 0x6BF2, 0x7412, 0x6BF1, 0x6BF1, 0x6BF2, 0x6BF2, 0x6BF1, 0x63B0, 0x5B6F, // 0x1CA0 (7328) pixels +0x530E, 0x4ACD, 0x4AAC, 0x4AAC, 0x4ACD, 0x52ED, 0x532E, 0x636F, 0x63D1, 0x7412, 0x7453, 0x7433, 0x7412, 0x7432, 0x84D5, 0xA619, // 0x1CB0 (7344) pixels +0xC75E, 0xC77F, 0x84F4, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x52ED, 0x6BF2, // 0x1CC0 (7360) pixels +0x6BB1, 0x9597, 0xAEBB, 0x63D0, 0x638F, 0x7CD4, 0x7CD4, 0x7453, 0x6C12, 0x6BF2, 0x6BF2, 0x7412, 0x6C12, 0x63B0, 0x5B6F, 0x532E, // 0x1CD0 (7376) pixels +0x52ED, 0x4ACD, 0x4ACD, 0x52ED, 0x5B2E, 0x6390, 0x6BF1, 0x7453, 0x7453, 0x7432, 0x7432, 0x84B4, 0x9DF9, 0xC77E, 0xC75E, 0x7451, // 0x1CE0 (7392) pixels +0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1CF0 (7408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2105, 0x424A, 0x7453, 0x7432, 0x7433, 0x84D4, 0x8D36, // 0x1D00 (7424) pixels +0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1D10 (7440) pixels +0x10A3, 0x18C4, 0x2146, 0x4A8C, 0x6390, 0x6BD1, 0x6BD1, 0x7432, 0x84D5, 0x9597, 0xA63A, 0xB69C, 0xB6DC, 0xB6DC, 0xB6FC, 0xB6FC, // 0x1D20 (7456) pixels +0xB6DC, 0xB6DC, 0xB6BC, 0xAE5B, 0x9DD8, 0x8D16, 0x7C73, 0x7432, 0x7432, 0x6C12, 0x6BD1, 0x6BF1, 0x6C31, 0x530D, 0x1082, 0x0000, // 0x1D30 (7472) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2105, 0x2105, 0x4ACD, 0x6C12, 0x63B1, 0x84D5, 0xBF3D, 0xBF5E, // 0x1D40 (7488) pixels +0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1D50 (7504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x4AAB, 0x31E8, 0x4ACC, 0x7C74, 0x7432, 0x9577, 0xCFBF, 0x63D0, // 0x1D60 (7520) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x1905, 0x4A8C, 0x6BF2, 0x63B1, 0x7C94, 0xBF1D, 0xBF3E, // 0x1D70 (7536) pixels +0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1D80 (7552) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2125, 0x2125, 0x5B2E, 0x7C74, 0x7412, 0x9577, 0xBF3E, 0xB6BB, // 0x1D90 (7568) pixels +0x1924, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x63B0, 0x7432, 0x6BF1, 0x95B8, 0xC79F, 0x8D56, 0x0000, // 0x1DA0 (7584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1DB0 (7600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x3208, 0x7472, 0xA65A, 0xBF1D, 0xAE9B, 0x9577, 0x7C93, 0x7412, 0x7412, 0x7433, 0x7453, // 0x1DC0 (7616) pixels +0x7453, 0x6BF1, 0x5B4F, 0x5B6E, 0x6C11, 0x5B8F, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1DD0 (7632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x6BD1, 0x8D16, 0x84F5, 0x84F5, 0x84F5, 0x84F5, // 0x1DE0 (7648) pixels +0x84F5, 0x84D5, 0x7C94, 0x7453, 0x7412, 0x7432, 0x6BF1, 0x63B0, 0x5B8F, 0x63D0, 0x63AF, 0x29C7, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1DF0 (7664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x4AAC, 0x428B, 0x5B6F, // 0x1E00 (7680) pixels +0x7412, 0x6BD1, 0x7C93, 0x9DF8, 0x8D56, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, // 0x1E10 (7696) pixels +0x63B0, 0x7433, 0x7C94, 0xB6FC, 0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1E20 (7712) pixels +0x18E5, 0x2987, 0x63B0, 0x6BF2, 0x6BB1, 0x6BD1, 0x6BF1, 0x6BD1, 0x5B6F, 0x4AED, 0x3A2A, 0x2967, 0x1905, 0x18E4, 0x18E4, 0x18E4, // 0x1E30 (7728) pixels +0x18E5, 0x18E5, 0x2105, 0x2126, 0x2967, 0x31C9, 0x426B, 0x5B4F, 0x7412, 0x7453, 0x7412, 0x7412, 0x8515, 0xB6BC, 0xCFBF, 0xA639, // 0x1E40 (7744) pixels +0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2146, 0x5B2F, 0x6BD1, 0x6BD1, 0xAE5A, 0x8D56, 0x63B0, // 0x1E50 (7760) pixels +0x7412, 0x6C12, 0x6BF1, 0x6BF1, 0x6BF2, 0x6BD1, 0x5B4F, 0x426B, 0x31C9, 0x2967, 0x2126, 0x2105, 0x2105, 0x1905, 0x1905, 0x2105, // 0x1E60 (7776) pixels +0x2105, 0x2146, 0x29A8, 0x3A2A, 0x530E, 0x6BF1, 0x7453, 0x7432, 0x7412, 0x8515, 0xB6DC, 0xCFBF, 0x9576, 0x10A2, 0x0000, 0x0000, // 0x1E70 (7792) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1E80 (7808) pixels +0x0000, 0x0000, 0x0000, 0x1083, 0x2125, 0x29A8, 0x6BF1, 0x7433, 0x7412, 0x84D4, 0x8D76, 0x63D0, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1E90 (7824) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x3209, 0x3A4A, // 0x1EA0 (7840) pixels +0x4A8B, 0x532E, 0x63B0, 0x6BF1, 0x6BD1, 0x6BD1, 0x6BF1, 0x6BF1, 0x7412, 0x7433, 0x7453, 0x7453, 0x7453, 0x7432, 0x7412, 0x6C12, // 0x1EB0 (7856) pixels +0x6C12, 0x6C12, 0x7412, 0x6C12, 0x6C12, 0x7432, 0x7C93, 0x84F4, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1EC0 (7872) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x31C8, 0x6BD1, 0x6BD1, 0x63B1, 0x9DD9, 0xC77F, 0xAE7A, 0x2166, 0x0000, 0x0000, // 0x1ED0 (7888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1EE0 (7904) pixels +0x0000, 0x1924, 0x532D, 0x7452, 0x7432, 0x6C12, 0x7453, 0x7453, 0x7432, 0x8D16, 0xC77F, 0x7CB3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1EF0 (7920) pixels +0x0000, 0x0000, 0x0000, 0x0020, 0x2126, 0x1905, 0x4AAC, 0x6BF2, 0x6390, 0x84D5, 0xBF3D, 0xB6DC, 0x2986, 0x0000, 0x0000, 0x0000, // 0x1F00 (7936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1F10 (7952) pixels +0x0000, 0x0000, 0x0000, 0x0021, 0x2125, 0x2105, 0x52ED, 0x7C73, 0x7412, 0x8D36, 0xBF3D, 0xB6DC, 0x2165, 0x0000, 0x0000, 0x0000, // 0x1F20 (7968) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6390, 0x7412, 0x6BF1, 0x95B8, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1F30 (7984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2166, 0x63D0, // 0x1F40 (8000) pixels +0x9E19, 0xC75E, 0xC79F, 0xB6FD, 0x9DD8, 0x7CB4, 0x7412, 0x6BF2, 0x7412, 0x7433, 0x7453, 0x63B0, 0x4AAC, 0x3209, 0x424A, 0x4ACC, // 0x1F50 (8016) pixels +0x3A29, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1F60 (8032) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2105, 0x4AAD, 0x7433, 0x6BF2, 0x6BF2, 0x6C12, 0x6C12, 0x6C12, 0x6C12, 0x6C12, 0x7412, // 0x1F70 (8048) pixels +0x7412, 0x6BF1, 0x6BF0, 0x7452, 0x7CD4, 0x84F5, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1F80 (8064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x4ACC, 0x530D, 0x5B4F, 0x6BF2, 0x6BD1, 0x7432, 0x8D56, 0x95B7, // 0x1F90 (8080) pixels +0x29C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, 0x63B0, 0x7432, 0x7C94, 0xB6FC, // 0x1FA0 (8096) pixels +0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2967, 0x5B70, 0x7412, // 0x1FB0 (8112) pixels +0x7C94, 0x7CB4, 0x6C11, 0x530D, 0x3A09, 0x2125, 0x10A3, 0x0861, 0x0021, 0x0020, 0x0000, 0x0000, 0x0020, 0x0021, 0x0841, 0x0862, // 0x1FC0 (8128) pixels +0x10A3, 0x18C4, 0x1905, 0x2126, 0x31A8, 0x530D, 0x7432, 0x7453, 0x6BF2, 0x7C73, 0xAE7B, 0xC79F, 0xAE7A, 0x1904, 0x0000, 0x0000, // 0x1FD0 (8144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2146, 0x5B4F, 0x6BD1, 0x6BF2, 0x9597, 0x63B0, 0x63B0, 0x6BD1, 0x6BD1, 0x6BD1, 0x63B0, // 0x1FE0 (8160) pixels +0x5B2E, 0x428B, 0x31C8, 0x2125, 0x10A3, 0x1083, 0x0862, 0x0841, 0x0841, 0x0021, 0x0841, 0x0841, 0x0862, 0x10A3, 0x10C4, 0x18E5, // 0x1FF0 (8176) pixels +0x2105, 0x2987, 0x4ACD, 0x7432, 0x7453, 0x6C12, 0x7C94, 0xAE7B, 0xCFBF, 0x8D56, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2000 (8192) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2125, // 0x2010 (8208) pixels +0x2126, 0x5B2E, 0x7453, 0x6BF2, 0x7C93, 0x9577, 0x8D35, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2020 (8224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x31E8, 0x530D, 0x6BF1, 0x7452, 0x7453, 0x7432, 0x7412, 0x7412, // 0x2030 (8240) pixels +0x7412, 0x7412, 0x7412, 0x6BF2, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BF1, 0x6C12, 0x7433, 0x7453, 0x7453, 0x7453, 0x7453, // 0x2040 (8256) pixels +0x7CB4, 0x8D36, 0x9DF9, 0xB6BC, 0xBF1D, 0x9DD8, 0x4B0C, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2050 (8272) pixels +0x0021, 0x2126, 0x2125, 0x4AAD, 0x6BF2, 0x63B1, 0x6BF2, 0xA619, 0xC79F, 0xAE9B, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2060 (8288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2986, 0x5B8F, 0x84F5, 0x84F5, 0x7453, // 0x2070 (8304) pixels +0x7432, 0x7433, 0x7453, 0x7433, 0x7432, 0x84D5, 0xBF5E, 0x8515, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 0x2080 (8320) pixels +0x2125, 0x2105, 0x4ACD, 0x6BF2, 0x6390, 0x84D5, 0xBF3E, 0xB6BB, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2090 (8336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 0x20A0 (8352) pixels +0x2105, 0x1905, 0x52ED, 0x7C73, 0x7412, 0x8D16, 0xBF1D, 0xB6FC, 0x29A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x20B0 (8368) pixels +0x2967, 0x6390, 0x7412, 0x6BD1, 0x95B8, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x20C0 (8384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3208, 0x84F4, 0xBF1D, 0xCFBF, 0xBF3E, 0xA61A, 0x8D16, 0x7432, // 0x20D0 (8400) pixels +0x6BD1, 0x6BF1, 0x7412, 0x7432, 0x6BF1, 0x5B4F, 0x3A2A, 0x2946, 0x2105, 0x2146, 0x2166, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x20E0 (8416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x20F0 (8432) pixels +0x1082, 0x2126, 0x3A2A, 0x530E, 0x52ED, 0x52ED, 0x530E, 0x5B2E, 0x5B6F, 0x6390, 0x6BD1, 0x7432, 0x7433, 0x7433, 0x7453, 0x8D16, // 0x2100 (8448) pixels +0xA63A, 0xBF1D, 0xBF1D, 0x7CB3, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2110 (8464) pixels +0x0000, 0x0000, 0x0021, 0x4AEC, 0x63D0, 0x638F, 0x6BD1, 0x6BD1, 0x6BF2, 0x84D4, 0x9597, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2120 (8480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, 0x63B0, 0x7432, 0x7C73, 0xB6DC, 0xAEBB, 0x1904, 0x0000, 0x0000, // 0x2130 (8496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x31E9, 0x8D57, 0x95B7, 0x7431, 0x426A, 0x1904, 0x0041, // 0x2140 (8512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x10C4, // 0x2150 (8528) pixels +0x1905, 0x1905, 0x3A09, 0x6BF1, 0x7453, 0x6BF2, 0x7C73, 0xAEBB, 0xC79F, 0x8515, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2160 (8544) pixels +0x18E4, 0x2146, 0x5B4F, 0x6BD1, 0x6BD1, 0x6BF1, 0x63B0, 0x6BB1, 0x6BD1, 0x6BD1, 0x63B0, 0x5B4E, 0x426B, 0x2966, 0x10A3, 0x0020, // 0x2170 (8560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x10A3, 0x1905, 0x1905, 0x31C8, // 0x2180 (8576) pixels +0x6BD1, 0x7C53, 0x6BF2, 0x7C94, 0xB6BC, 0xCFBF, 0x6C10, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2190 (8592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2105, 0x424B, 0x7432, 0x6BF2, 0x7432, // 0x21A0 (8608) pixels +0x8D56, 0x9DD8, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x21B0 (8624) pixels +0x0000, 0x0020, 0x1905, 0x39E9, 0x4ACC, 0x6390, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x5B6F, 0x52ED, 0x4A8C, 0x3A2A, 0x39E9, 0x31E9, // 0x21C0 (8640) pixels +0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31C8, 0x31C9, 0x3A09, 0x3A2A, 0x4A8C, 0x530D, 0x636F, 0x6BF2, 0x7432, 0x7432, 0x7453, // 0x21D0 (8656) pixels +0x8D56, 0xB6DC, 0xC79F, 0x95B7, 0x29A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x2146, // 0x21E0 (8672) pixels +0x530E, 0x6BF2, 0x63B1, 0x6BF1, 0x9DD8, 0xBF5E, 0xC77E, 0x8535, 0x426A, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x21F0 (8688) pixels +0x0000, 0x0000, 0x0000, 0x0862, 0x2986, 0x532D, 0x84D4, 0x9DD8, 0x9597, 0x7CB4, 0x7432, 0x7412, 0x7412, 0x7453, 0x7432, 0x7432, // 0x2200 (8704) pixels +0x7432, 0x84B4, 0xBF3E, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2125, 0x1905, 0x4AAC, 0x6BF2, // 0x2210 (8720) pixels +0x6390, 0x84D5, 0xBF3D, 0xB6DC, 0x2166, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2220 (8736) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2125, 0x2105, 0x52ED, 0x7C73, // 0x2230 (8752) pixels +0x6C12, 0x8D36, 0xBF3D, 0xB6DC, 0x2166, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6390, 0x7412, 0x6BD1, // 0x2240 (8768) pixels +0x95B8, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2250 (8784) pixels +0x0000, 0x0000, 0x31E8, 0x8D56, 0xC75E, 0xC79F, 0xB6BC, 0x9577, 0x7453, 0x6BD1, 0x63B1, 0x6BF2, 0x7412, 0x6BD1, 0x5B2F, 0x426B, // 0x2260 (8800) pixels +0x29A8, 0x2126, 0x2105, 0x2105, 0x18E4, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2270 (8816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2947, 0x2126, 0x2105, // 0x2280 (8832) pixels +0x2105, 0x2105, 0x2105, 0x2105, 0x2126, 0x2967, 0x29A8, 0x3A09, 0x4AAC, 0x5B4F, 0x6BF2, 0x7432, 0x6C12, 0x7CB4, 0xA65A, 0xCFBF, // 0x2290 (8848) pixels +0xAE7B, 0x3208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x530C, 0x7452, // 0x22A0 (8864) pixels +0x63D0, 0x6BD1, 0x6BD1, 0x6BD1, 0x7C73, 0x8D36, 0x532D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x22B0 (8880) pixels +0x0000, 0x0020, 0x1905, 0x2967, 0x63B0, 0x7412, 0x7C73, 0xB6DC, 0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x22C0 (8896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x7CD4, 0x7451, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x22D0 (8912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x2105, 0x1905, 0x31C8, // 0x22E0 (8928) pixels +0x6BF1, 0x7453, 0x6BF1, 0x8D16, 0xBF1D, 0xC75E, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2146, 0x5B2F, 0x6BD1, // 0x22F0 (8944) pixels +0x63B1, 0x6390, 0x63B1, 0x6C12, 0x7453, 0x7452, 0x534E, 0x29A7, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2300 (8960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x1905, 0x2105, 0x2987, 0x63D1, 0x7453, 0x6BF2, // 0x2310 (8976) pixels +0x8D16, 0xBF3D, 0xBF1D, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2320 (8992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x2987, 0x63B1, 0x7412, 0x6BF1, 0x84F5, 0x9DF9, 0x8515, 0x0882, 0x0000, // 0x2330 (9008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x1905, 0x2126, 0x424A, // 0x2340 (9024) pixels +0x6390, 0x6BD1, 0x6BB1, 0x6BD1, 0x5B6F, 0x4AAC, 0x31C8, 0x2105, 0x18E4, 0x10C4, 0x10A3, 0x1083, 0x0882, 0x0862, 0x0862, 0x0862, // 0x2350 (9040) pixels +0x0862, 0x0862, 0x1082, 0x1083, 0x10A3, 0x18E4, 0x1905, 0x2146, 0x31A8, 0x426B, 0x636F, 0x7433, 0x6C12, 0x7432, 0x9DD8, 0xC79F, // 0x2360 (9056) pixels +0xB6FC, 0x3A6A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, 0x2126, 0x2146, 0x530E, 0x6BF2, 0x63B1, // 0x2370 (9072) pixels +0x63B0, 0x7CB4, 0xA65A, 0xC75E, 0xC79F, 0xAE7A, 0x8D35, 0x6BF0, 0x530C, 0x42AB, 0x428A, 0x42AB, 0x532D, 0x6C11, 0x8D35, 0xA619, // 0x2380 (9088) pixels +0xB6BC, 0xAE9B, 0x9DB8, 0x84D4, 0x7432, 0x6C12, 0x6C12, 0x7432, 0x84D4, 0x84F4, 0x6BD0, 0x7432, 0x7412, 0x84D5, 0xC75E, 0x8515, // 0x2390 (9104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x1905, 0x426B, 0x6BD1, 0x6390, 0x7C73, 0xBF1D, 0xBF5E, // 0x23A0 (9120) pixels +0x3208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x23B0 (9136) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x2125, 0x532E, 0x7453, 0x6BF2, 0x9557, 0xBF5E, 0xAEBB, // 0x23C0 (9152) pixels +0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6390, 0x6C12, 0x6BD1, 0x9598, 0xC79F, 0x8D56, 0x0000, // 0x23D0 (9168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x7452, 0xBF3D, 0xCF9F, // 0x23E0 (9184) pixels +0xAE7B, 0x84F5, 0x6BF2, 0x6390, 0x63B1, 0x6BF2, 0x6BD1, 0x5B4F, 0x428B, 0x31A8, 0x2126, 0x2105, 0x2105, 0x18E5, 0x10A3, 0x0041, // 0x23F0 (9200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2400 (9216) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, // 0x2410 (9232) pixels +0x0862, 0x0862, 0x1083, 0x10C3, 0x18E5, 0x2126, 0x31C8, 0x52ED, 0x6C12, 0x6C12, 0x6C12, 0x9597, 0xC77E, 0xBF1D, 0x3208, 0x0000, // 0x2420 (9248) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x5B6E, 0x84F4, 0x7432, 0x6BB1, 0x6BB1, 0x6BD1, 0x7432, // 0x2430 (9264) pixels +0x84F4, 0x5B6E, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, // 0x2440 (9280) pixels +0x6390, 0x7412, 0x7C73, 0xB6DC, 0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2450 (9296) pixels +0x31C7, 0x2165, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2460 (9312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2125, 0x18E5, 0x424A, 0x7433, 0x7412, 0x7412, // 0x2470 (9328) pixels +0xA63A, 0xC79F, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2126, 0x530E, 0x6BD1, 0x63B1, 0x6BF2, 0x7CB4, 0x84F5, // 0x2480 (9344) pixels +0x7452, 0x3A09, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2490 (9360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x1905, 0x31E9, 0x7412, 0x7432, 0x6C12, 0xA619, 0xCFBF, 0x7472, // 0x24A0 (9376) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x24B0 (9392) pixels +0x0021, 0x2126, 0x2105, 0x4ACD, 0x7412, 0x6BD1, 0x7453, 0x9DD8, 0xA639, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x24C0 (9408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2125, 0x3A09, 0x63B1, 0x6BD1, 0x63B1, 0x7412, 0x6C11, // 0x24D0 (9424) pixels +0x5B6F, 0x3A29, 0x18E4, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x24E0 (9440) pixels +0x0000, 0x0000, 0x0021, 0x0862, 0x10C4, 0x1905, 0x2126, 0x426B, 0x6C12, 0x7432, 0x6BF2, 0x9577, 0xC77E, 0xB6DC, 0x2166, 0x0000, // 0x24F0 (9456) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2126, 0x2146, 0x428B, 0x63B1, 0x6BF2, 0x63B0, 0x63B1, 0x7C73, // 0x2500 (9472) pixels +0x9577, 0xA65A, 0xB6FD, 0xBF3E, 0xC77E, 0xC77F, 0xC77E, 0xC75E, 0xBF3E, 0xBEFD, 0xB6BC, 0x9DF9, 0x8515, 0x7473, 0x6BF2, 0x6BF2, // 0x2510 (9488) pixels +0x6C12, 0x6C12, 0x7452, 0x8515, 0x8D56, 0x6C11, 0x6BF1, 0x7432, 0x6BF2, 0x84F5, 0xC77F, 0x7CB3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2520 (9504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x2105, 0x3A2A, 0x63B1, 0x6390, 0x7412, 0xB6DC, 0xC79F, 0x532D, 0x0000, 0x0000, 0x0000, // 0x2530 (9520) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2540 (9536) pixels +0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2126, 0x6390, 0x7433, 0x6BF1, 0x9DB8, 0xC77E, 0xA63A, 0x0841, 0x0000, 0x0000, 0x0000, // 0x2550 (9552) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x6370, 0x6BF2, 0x63B1, 0x9598, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2560 (9568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x29A7, 0x8D56, 0xB6FC, 0xAE9B, 0x8D36, 0x6BD1, 0x6390, 0x63B1, 0x6BD1, // 0x2570 (9584) pixels +0x6390, 0x530E, 0x3A0A, 0x2146, 0x2105, 0x1905, 0x18E4, 0x10A3, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2580 (9600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2590 (9616) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x25A0 (9632) pixels +0x0020, 0x0862, 0x18C4, 0x1905, 0x31E9, 0x63B0, 0x7412, 0x6BD1, 0x9577, 0xC77F, 0xAE7B, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x25B0 (9648) pixels +0x0000, 0x0000, 0x0000, 0x0862, 0x6C11, 0x9597, 0x7453, 0x63B1, 0x63B1, 0x63B1, 0x6BF1, 0x7C73, 0x534D, 0x0841, 0x0000, 0x0000, // 0x25C0 (9664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x2967, 0x6390, 0x6C12, 0x7473, 0xB6DC, // 0x25D0 (9680) pixels +0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x25E0 (9696) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x25F0 (9712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2126, 0x2126, 0x6390, 0x7433, 0x6BF1, 0x8D56, 0xBF5E, 0xAEBB, 0x18E3, // 0x2600 (9728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x4A8C, 0x6BD1, 0x6370, 0x8D56, 0xB6DC, 0x8D56, 0x10C3, 0x0000, 0x0000, 0x0000, // 0x2610 (9744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2620 (9760) pixels +0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x1905, 0x530E, 0x7453, 0x6BF1, 0x8D16, 0xC75E, 0xA65A, 0x0882, 0x0000, 0x0000, 0x0000, // 0x2630 (9776) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2125, 0x31C8, 0x6BD1, // 0x2640 (9792) pixels +0x6BF2, 0x6BD1, 0x8D56, 0xAE5A, 0x8515, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2650 (9808) pixels +0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x29A8, 0x6390, 0x6BB1, 0x6390, 0x7C94, 0x8D35, 0x7452, 0x29A7, 0x0020, 0x0000, 0x0000, // 0x2660 (9824) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2670 (9840) pixels +0x0000, 0x0862, 0x1905, 0x1905, 0x3A09, 0x6C12, 0x7432, 0x6BF2, 0x9DF9, 0xCFBF, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2680 (9856) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2105, 0x2105, 0x31A8, 0x52ED, 0x63B1, 0x6BD1, 0x6BB1, 0x63B1, 0x63B1, 0x6C12, 0x7453, // 0x2690 (9872) pixels +0x7C94, 0x7C94, 0x7C94, 0x7C94, 0x7C73, 0x7432, 0x6BF2, 0x6BD1, 0x6BF1, 0x6BF2, 0x6BF2, 0x6BD1, 0x6BF1, 0x7452, 0x7C93, 0x63AF, // 0x26A0 (9888) pixels +0x5B4E, 0x7431, 0x6C12, 0x7412, 0x6BF1, 0x8D56, 0xCFBF, 0x63F0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x26B0 (9904) pixels +0x10C4, 0x2126, 0x31A8, 0x6390, 0x6390, 0x6390, 0xA63A, 0xC79F, 0x84F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x26C0 (9920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, // 0x26D0 (9936) pixels +0x2126, 0x29A8, 0x6BF2, 0x7412, 0x6C12, 0xA63A, 0xC77F, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x26E0 (9952) pixels +0x2967, 0x6370, 0x6BF2, 0x63B1, 0x9598, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x26F0 (9968) pixels +0x0000, 0x0000, 0x3A29, 0x8D56, 0x9DF8, 0x8D36, 0x6BF2, 0x6370, 0x6390, 0x63B1, 0x63B0, 0x5B4F, 0x4ACC, 0x424A, 0x31C8, 0x1905, // 0x2700 (9984) pixels +0x1082, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2710 (10000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2720 (10016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, // 0x2730 (10032) pixels +0x1905, 0x2987, 0x6BD1, 0x6C12, 0x6BF2, 0xA63A, 0xCFBF, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x84F4, // 0x2740 (10048) pixels +0x9DF9, 0x7C73, 0x6390, 0x63B1, 0x63B0, 0x6390, 0x6BD0, 0x4AAB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2750 (10064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, 0x2946, 0x6390, 0x6BF2, 0x7453, 0xB6DC, 0xAEBB, 0x10E3, 0x0000, 0x0000, // 0x2760 (10080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2770 (10096) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2780 (10112) pixels +0x0000, 0x0000, 0x0020, 0x2125, 0x1905, 0x4ACD, 0x7433, 0x6BF1, 0x84B4, 0xBF1D, 0xBF5E, 0x3208, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2790 (10128) pixels +0x0862, 0x2105, 0x3A09, 0x6BB1, 0x6370, 0x7C94, 0xC75E, 0xB6DC, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x27A0 (10144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x27B0 (10160) pixels +0x18E4, 0x1905, 0x3A09, 0x7432, 0x6BF2, 0x7C74, 0xB6DC, 0xBF3D, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x27C0 (10176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x2126, 0x2105, 0x52ED, 0x6C12, 0x6BB1, 0x7453, 0xA639, 0xAE9B, // 0x27D0 (10192) pixels +0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, // 0x27E0 (10208) pixels +0x2125, 0x4ACD, 0x6BD1, 0x6370, 0x7C94, 0xA639, 0x9597, 0x31C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x27F0 (10224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2105, // 0x2800 (10240) pixels +0x18E5, 0x426B, 0x7433, 0x6BF2, 0x7C94, 0xB6FC, 0xBF3D, 0x31E7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2810 (10256) pixels +0x0000, 0x0021, 0x10C4, 0x1905, 0x2126, 0x29A8, 0x424B, 0x530E, 0x6370, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, // 0x2820 (10272) pixels +0x6BD1, 0x6BF1, 0x6BD1, 0x63B0, 0x5B6F, 0x5B4E, 0x5B4E, 0x5B8F, 0x63AF, 0x530D, 0x2986, 0x0000, 0x530C, 0x7C93, 0x7412, 0x6C12, // 0x2830 (10288) pixels +0x6BF2, 0x95B8, 0xC75E, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2126, 0x2146, 0x5B2F, // 0x2840 (10304) pixels +0x63B1, 0x5B4F, 0x8D56, 0xC75E, 0xB6DC, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2850 (10320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2987, 0x2125, 0x426B, 0x7433, 0x6BF2, // 0x2860 (10336) pixels +0x7453, 0xAE9B, 0xC79F, 0x63AF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x5B6F, 0x6BF1, 0x63B1, // 0x2870 (10352) pixels +0x9598, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31E8, 0x7CB4, 0x84F5, // 0x2880 (10368) pixels +0x7473, 0x6390, 0x6370, 0x6390, 0x6BB1, 0x6BF1, 0x6BF0, 0x5B6F, 0x428B, 0x2145, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2890 (10384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x28A0 (10400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x28B0 (10416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x1905, 0x4AAC, 0x7432, // 0x28C0 (10432) pixels +0x6BD1, 0x8D16, 0xC77E, 0xA65A, 0x1082, 0x0000, 0x0000, 0x0000, 0x0020, 0x4ACB, 0xAE7A, 0xA63A, 0x7453, 0x6370, 0x6390, 0x6390, // 0x28D0 (10448) pixels +0x5B8F, 0x7452, 0x9597, 0x9DD8, 0x9597, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, 0x95B7, // 0x28E0 (10464) pixels +0x95B7, 0x9DD8, 0x5B6F, 0x2146, 0x5B6F, 0x6BF2, 0x7453, 0xB6FC, 0xBF3D, 0x9DF8, 0x95B7, 0x95B7, 0x95B7, 0x9597, 0x95B7, 0x3208, // 0x28F0 (10480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2900 (10496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, // 0x2910 (10512) pixels +0x2105, 0x426B, 0x7432, 0x6BF1, 0x7C94, 0xB6DC, 0xC75E, 0x4AAB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2105, 0x2967, 0x5B4F, // 0x2920 (10528) pixels +0x6390, 0x6390, 0xA63A, 0xCF9F, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2930 (10544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x29A8, 0x6BF1, // 0x2940 (10560) pixels +0x6C12, 0x7432, 0xAE9B, 0xC75E, 0x426A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2950 (10576) pixels +0x0000, 0x0000, 0x0000, 0x18E4, 0x2125, 0x31C8, 0x6BD1, 0x6BD1, 0x63B1, 0x9577, 0xB6BC, 0x9597, 0x0861, 0x0000, 0x0000, 0x0000, // 0x2960 (10592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x5B70, 0x6390, 0x6390, // 0x2970 (10608) pixels +0xA619, 0xBF1D, 0x7452, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2980 (10624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x2967, 0x6BD1, 0x7432, // 0x2990 (10640) pixels +0x6BF2, 0xA619, 0xCF9F, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, // 0x29A0 (10656) pixels +0x10A3, 0x18E4, 0x1905, 0x2126, 0x2987, 0x31C9, 0x3A2A, 0x426B, 0x4A8C, 0x4AAC, 0x4AAC, 0x4A8C, 0x426B, 0x3A0A, 0x39E9, 0x3A0A, // 0x29B0 (10672) pixels +0x3A2A, 0x426B, 0x3A4A, 0x31C7, 0x10C3, 0x0000, 0x0000, 0x10C3, 0x7C93, 0x7C93, 0x6C12, 0x6BF2, 0x7412, 0xA63A, 0xAE9B, 0x1904, // 0x29C0 (10688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2126, 0x2105, 0x426B, 0x63B1, 0x5B70, 0x7412, 0xB6DC, // 0x29D0 (10704) pixels +0xC79F, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x29E0 (10720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x424A, 0x31A8, 0x5B6F, 0x7412, 0x6BD1, 0x84F5, 0xB6BC, 0xBEFD, 0x31C7, // 0x29F0 (10736) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x5B6F, 0x6BD1, 0x6390, 0x9597, 0xC79F, 0x8D56, 0x0000, // 0x2A00 (10752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x63D0, 0x6C31, 0x6BF1, 0x6370, 0x6370, 0x6390, 0x7432, // 0x2A10 (10768) pixels +0x7CD4, 0x7CB4, 0x5B6F, 0x2986, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2A20 (10784) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2A30 (10800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2A40 (10816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2125, 0x3A09, 0x7412, 0x6BD1, 0x7C94, 0xB6DC, 0xB6FC, // 0x2A50 (10832) pixels +0x2166, 0x0000, 0x0000, 0x0000, 0x0021, 0x4ACC, 0x7C93, 0x6C12, 0x5B50, 0x6390, 0x6370, 0x6390, 0x84F5, 0x9DF9, 0xA63A, 0xAE5A, // 0x2A60 (10848) pixels +0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE9B, 0xA63A, 0x63D0, // 0x2A70 (10864) pixels +0x5B6F, 0x6BF1, 0x7432, 0x9DF9, 0xA63A, 0xAE7B, 0xAE9B, 0xAE9B, 0xAE7B, 0xB6DC, 0xCFBF, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2A80 (10880) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2A90 (10896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x2105, 0x424B, 0x7412, 0x6BF1, // 0x2AA0 (10912) pixels +0x7C73, 0xB6DC, 0xC75E, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2125, 0x4A8C, 0x63B1, 0x5B4F, 0x7CB4, 0xBF3E, // 0x2AB0 (10928) pixels +0xBF1D, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2AC0 (10944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x29A8, 0x6BD1, 0x6C12, 0x7432, 0xAE9B, 0xBF5E, // 0x2AD0 (10960) pixels +0x426A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, // 0x2AE0 (10976) pixels +0x2105, 0x52ED, 0x6BF2, 0x63B1, 0x7432, 0xAE7A, 0xB6FD, 0x5B4E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2AF0 (10992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2125, 0x31E9, 0x6390, 0x6370, 0x6BD1, 0xB6DC, 0xC75E, 0x4AEC, 0x0000, // 0x2B00 (11008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2B10 (11024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x2105, 0x5B2E, 0x7432, 0x6BD1, 0x9577, 0xC79F, 0x8D56, // 0x2B20 (11040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x1082, // 0x2B30 (11056) pixels +0x10A3, 0x18C4, 0x18E4, 0x18E5, 0x1905, 0x2105, 0x2105, 0x1905, 0x18E5, 0x18E4, 0x18E4, 0x1905, 0x18E4, 0x0882, 0x0000, 0x0000, // 0x2B40 (11072) pixels +0x0000, 0x0000, 0x0000, 0x532D, 0x8D15, 0x7453, 0x6BF2, 0x6BD1, 0x7C94, 0xAE9B, 0x84F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2B50 (11088) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2126, 0x29A8, 0x6370, 0x6390, 0x5B4F, 0x9577, 0xC75E, 0xB6FD, 0x31E7, 0x0000, // 0x2B60 (11104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2B70 (11120) pixels +0x0000, 0x10A3, 0x52ED, 0x428B, 0x4ACD, 0x6BF2, 0x6BF1, 0x6BF1, 0x9597, 0xB6DC, 0x8D56, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2B80 (11136) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2967, 0x5B4F, 0x6BD1, 0x6390, 0x9597, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2B90 (11152) pixels +0x0000, 0x0000, 0x0000, 0x0861, 0x4AAC, 0x5B6E, 0x6390, 0x6370, 0x6370, 0x6370, 0x7CB4, 0x95B7, 0x8D56, 0x4AAB, 0x0841, 0x0000, // 0x2BA0 (11168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2BB0 (11184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2BC0 (11200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2BD0 (11216) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2105, 0x3A2A, 0x7412, 0x6BD1, 0x7C74, 0xB6DC, 0xBF1D, 0x2986, 0x0000, 0x0000, 0x0000, // 0x2BE0 (11232) pixels +0x0041, 0x10A4, 0x31C8, 0x6391, 0x6390, 0x6390, 0x6390, 0x63B1, 0x63B1, 0x6391, 0x6390, 0x6390, 0x6390, 0x6390, 0x6390, 0x6391, // 0x2BF0 (11248) pixels +0x63B1, 0x63B1, 0x63B1, 0x63B1, 0x63B1, 0x63B1, 0x6BB1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BD1, 0x7412, 0x6BF1, 0x6BD1, 0x6BD1, 0x6BD1, // 0x2C00 (11264) pixels +0x6BF1, 0x6BF1, 0x6BF2, 0x6BF2, 0x6BD1, 0x8D16, 0xC77E, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2C10 (11280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2C20 (11296) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2146, 0x1905, 0x4ACD, 0x7412, 0x6BD1, 0x7C94, 0xBEFD, 0xC75E, 0x3A29, // 0x2C30 (11312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2988, 0x6370, 0x6390, 0x6370, 0x9DD9, 0xCF9F, 0x9DD8, 0x0861, 0x0000, // 0x2C40 (11328) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2C50 (11344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2105, 0x31E9, 0x6C12, 0x6BF1, 0x7453, 0xB6DC, 0xBF3E, 0x31E8, 0x0000, 0x0000, 0x0000, // 0x2C60 (11360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x2126, 0x29A8, 0x63B1, 0x6BB1, 0x6390, // 0x2C70 (11376) pixels +0x8D56, 0xBEFD, 0xAE7B, 0x1924, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2C80 (11392) pixels +0x0000, 0x0000, 0x10C3, 0x2105, 0x3A0A, 0x6391, 0x5B50, 0x7412, 0xB6DC, 0xC77E, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2C90 (11408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2CA0 (11424) pixels +0x0000, 0x0000, 0x0000, 0x0021, 0x2126, 0x2105, 0x52ED, 0x7432, 0x6BD1, 0x8D36, 0xC77F, 0x95B7, 0x0841, 0x0000, 0x0000, 0x0000, // 0x2CB0 (11440) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 0x2CC0 (11456) pixels +0x0021, 0x0021, 0x0021, 0x0021, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31E8, 0x8D36, // 0x2CD0 (11472) pixels +0x84D4, 0x6BF2, 0x6BF1, 0x6BD1, 0x8D16, 0xAE9B, 0x42AA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2CE0 (11488) pixels +0x0000, 0x0841, 0x2126, 0x2125, 0x4AAC, 0x63B1, 0x5B50, 0x63B1, 0xAE7B, 0xC77F, 0xAE7A, 0x1924, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2CF0 (11504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x5B6E, 0x63B0, 0x532E, // 0x2D00 (11520) pixels +0x6BD1, 0x6BF2, 0x6BD1, 0x7C73, 0x9DD8, 0xAE9B, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x2D10 (11536) pixels +0x2966, 0x5B4F, 0x6BD1, 0x6390, 0x9597, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2166, // 0x2D20 (11552) pixels +0x4AAC, 0x52ED, 0x6370, 0x6370, 0x5B4F, 0x84F5, 0xAE7A, 0x9DD8, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2D30 (11568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2D40 (11584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x7CD4, 0x3208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2D50 (11600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, // 0x2D60 (11616) pixels +0x2126, 0x1905, 0x4ACD, 0x6C12, 0x63B1, 0x84D5, 0xBF3E, 0xB6DC, 0x2145, 0x0000, 0x0000, 0x0000, 0x0041, 0x1905, 0x39E9, 0x6370, // 0x2D70 (11632) pixels +0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B6F, 0x5B70, 0x5B70, 0x5B70, 0x6370, 0x6370, 0x6370, 0x6370, // 0x2D80 (11648) pixels +0x6370, 0x6390, 0x6390, 0x6390, 0x6390, 0x6390, 0x6390, 0x6390, 0x6BD1, 0x6BD1, 0x6BD1, 0x5B70, 0x6390, 0x63B1, 0x63B0, 0x63B1, // 0x2D90 (11664) pixels +0x6370, 0x84F5, 0xCFBF, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2DA0 (11680) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2DB0 (11696) pixels +0x0000, 0x0000, 0x2145, 0x2967, 0x2966, 0x6390, 0x6C12, 0x63B1, 0x8D16, 0xBF1D, 0xB6BC, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2DC0 (11712) pixels +0x0000, 0x0000, 0x1905, 0x2105, 0x424B, 0x63B1, 0x5B50, 0x6BD1, 0xAE7B, 0xCFBF, 0x84F4, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2DD0 (11728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, // 0x2DE0 (11744) pixels +0x2126, 0x1905, 0x52ED, 0x7412, 0x6BB1, 0x84D5, 0xBF1D, 0xB6BC, 0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2DF0 (11760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x2126, 0x1905, 0x426B, 0x6BD1, 0x6390, 0x6BD1, 0xAE7B, 0xC75E, 0x84D4, 0x0000, // 0x2E00 (11776) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, 0x2105, // 0x2E10 (11792) pixels +0x39E9, 0x6390, 0x5B50, 0x6BD1, 0xB6DC, 0xC79F, 0x6BF0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2E20 (11808) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, // 0x2E30 (11824) pixels +0x2987, 0x1905, 0x532E, 0x7412, 0x6BD1, 0x8D36, 0xC77E, 0x9DD8, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x3208, // 0x2E40 (11840) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2E50 (11856) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2986, 0x8D36, 0x8D76, 0x7453, 0x6BD1, 0x6BD1, 0x7432, // 0x2E60 (11872) pixels +0x9DB8, 0x8D35, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2126, // 0x2E70 (11888) pixels +0x2967, 0x5B4F, 0x6390, 0x5B4F, 0x7432, 0xB6BC, 0xC79F, 0xA63A, 0x29C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2E80 (11904) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x6C11, 0x7CB4, 0x6BF1, 0x63B1, 0x6BF1, 0x6BD1, 0x6BF1, 0x8515, // 0x2E90 (11920) pixels +0x9DF9, 0x84D4, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2966, 0x5B4F, 0x6BB1, 0x6370, // 0x2EA0 (11936) pixels +0x9597, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x31A8, 0x3A29, 0x530E, 0x6370, 0x5B2F, // 0x2EB0 (11952) pixels +0x7412, 0xB6DC, 0xB6DC, 0x4B0C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2EC0 (11968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2ED0 (11984) pixels +0x0000, 0x0842, 0x7C73, 0xC79F, 0x84F4, 0x3A49, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2EE0 (12000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x29A8, 0x2126, 0x29A8, 0x63B1, 0x6BF2, // 0x2EF0 (12016) pixels +0x63B1, 0x9577, 0xC77E, 0x9DF8, 0x0841, 0x0000, 0x0000, 0x0000, 0x0041, 0x2126, 0x2967, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, // 0x2F00 (12032) pixels +0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, // 0x2F10 (12048) pixels +0x2987, 0x2987, 0x2967, 0x29A8, 0x5B6F, 0x6BD1, 0x7453, 0x7473, 0x31A8, 0x2967, 0x2987, 0x2988, 0x2967, 0x31E9, 0x9DB8, 0x4AEC, // 0x2F20 (12064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x4ACC, 0x63AF, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2F30 (12080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x424A, 0x29A7, // 0x2F40 (12096) pixels +0x4AAC, 0x6BF2, 0x6BD1, 0x6BF1, 0x9DD8, 0xBF1D, 0x84F4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x2F50 (12112) pixels +0x2126, 0x52EE, 0x6391, 0x5B2F, 0x7432, 0xB6DC, 0xCFBF, 0x8515, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2F60 (12128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x1905, 0x31E9, 0x6BD1, 0x6BF1, // 0x2F70 (12144) pixels +0x6BD1, 0x9577, 0xBF1D, 0x8535, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2F80 (12160) pixels +0x0000, 0x10A3, 0x2126, 0x2146, 0x5B2F, 0x6BB1, 0x6370, 0x7CB4, 0xBF1D, 0xC75E, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2F90 (12176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x29A8, 0x5B50, 0x6370, 0x5B4F, // 0x2FA0 (12192) pixels +0x9DD8, 0xC77E, 0xAE7A, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2FB0 (12208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31E8, 0x31C8, 0x29A8, 0x63B1, 0x6BF2, // 0x2FC0 (12224) pixels +0x6BD1, 0x9DD8, 0xC79F, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x7432, 0x84F4, 0x18E3, 0x0000, 0x0000, // 0x2FD0 (12240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x2FE0 (12256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x3A29, 0x8D76, 0x9DD8, 0x7C94, 0x6BD1, 0x6BD1, 0x6BD1, 0x84D4, 0x9DB8, 0x426A, 0x0000, 0x0000, // 0x2FF0 (12272) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x2126, 0x2105, 0x31E9, 0x6370, 0x6370, // 0x3000 (12288) pixels +0x5B2F, 0x7432, 0xAE9B, 0xC79F, 0xB6DC, 0x5B8E, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3010 (12304) pixels +0x0000, 0x0861, 0x4ACB, 0x9577, 0x9DB8, 0x84D4, 0x6BF1, 0x6BD1, 0x6BD1, 0x6BD1, 0x7C73, 0x8D56, 0x9577, 0x2986, 0x0000, 0x0000, // 0x3020 (12320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2966, 0x5B4F, 0x63B1, 0x6370, 0x9577, 0xC79F, 0x8D56, 0x0000, // 0x3030 (12336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2967, 0x31E9, 0x5B4F, 0x6370, 0x5B2F, 0x95B8, 0xC79F, 0x8D56, 0x0000, // 0x3040 (12352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3050 (12368) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x31C8, 0x9DB8, // 0x3060 (12384) pixels +0xC77F, 0xC79F, 0xA619, 0x6C10, 0x3208, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3070 (12400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x31C7, 0x4ACC, 0x424A, 0x31C8, 0x5B4F, 0x6BF2, 0x63B1, 0x6C12, 0xA619, 0xC75E, 0x6C10, // 0x3080 (12416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x10A3, 0x10A3, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, // 0x3090 (12432) pixels +0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x10A3, 0x1905, 0x2146, // 0x30A0 (12448) pixels +0x5B4F, 0x6BD1, 0x7433, 0xBF1D, 0x8D56, 0x18E4, 0x1083, 0x1083, 0x1083, 0x0862, 0x18E4, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, // 0x30B0 (12464) pixels +0x2967, 0xAE7B, 0xAE9B, 0x5BAF, 0x2125, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x30C0 (12480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x3A29, 0x530D, 0x426B, 0x4ACD, 0x6BD1, 0x6BD1, 0x63B1, 0x84D4, // 0x30D0 (12496) pixels +0xA63A, 0xAE9B, 0x31E7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x2967, 0x5B2F, 0x6390, // 0x30E0 (12512) pixels +0x5B2F, 0x6C12, 0xAE7B, 0xCFBF, 0xA619, 0x3A29, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x30F0 (12528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x31C8, 0x2146, 0x2967, 0x6390, 0x6BF2, 0x6BB1, 0x7453, 0x9DB8, 0xAE7B, 0x3A49, // 0x3100 (12544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x2105, 0x31C9, // 0x3110 (12560) pixels +0x6391, 0x6390, 0x5B70, 0x95B8, 0xC75E, 0xAE9B, 0x10E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3120 (12576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x2126, 0x4AAD, 0x6390, 0x5B2F, 0x6BF2, 0xB6BC, 0xC79F, 0x9596, // 0x3130 (12592) pixels +0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3140 (12608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x3A29, 0x530D, 0x3A2A, 0x530E, 0x6BF2, 0x6BB1, 0x7432, 0xB6BC, 0xC79F, 0x5B4E, // 0x3150 (12624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2987, 0xA619, 0xB6FC, 0x63F0, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3160 (12640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x63AF, // 0x3170 (12656) pixels +0xA639, 0xA619, 0x84D4, 0x63B1, 0x6BD1, 0x6BD1, 0x7432, 0x8D56, 0x63D0, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3180 (12672) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2146, 0x2105, 0x3A2A, 0x6390, 0x6370, 0x5B2F, 0x6BF2, 0x9DF9, // 0x3190 (12688) pixels +0xC75E, 0xC79F, 0xA639, 0x6BF0, 0x3208, 0x18E3, 0x0041, 0x0000, 0x0000, 0x0020, 0x10C3, 0x31E8, 0x63AF, 0x9DF9, 0xBF3D, 0xAE9B, // 0x31A0 (12704) pixels +0x8D36, 0x6BF2, 0x63B1, 0x6BD1, 0x6BB1, 0x6C12, 0x7CB4, 0x8D36, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x31B0 (12720) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2966, 0x5B2F, 0x63B1, 0x5B70, 0x9577, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x31C0 (12736) pixels +0x0000, 0x0000, 0x18E4, 0x2105, 0x39E9, 0x6370, 0x5B2F, 0x63B1, 0xB6BC, 0xC75E, 0x84F4, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, // 0x31D0 (12752) pixels +0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, 0x428A, // 0x31E0 (12768) pixels +0x428A, 0x428A, 0x428A, 0x4AAB, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2967, 0x530E, 0x7433, 0x9598, 0xBEFD, 0xCF9F, // 0x31F0 (12784) pixels +0xC77E, 0xA65A, 0x8515, 0x5B6E, 0x3A69, 0x29A6, 0x1904, 0x0882, 0x0841, 0x0020, 0x0041, 0x0882, 0x1904, 0x29A6, 0x426A, 0x5B8E, // 0x3200 (12800) pixels +0x7452, 0x7452, 0x5B6F, 0x52ED, 0x6370, 0x6BD1, 0x6BB1, 0x63B1, 0x84F5, 0xA63A, 0xA639, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3210 (12816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3220 (12832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x2967, 0x5B4F, 0x63B1, 0x7412, 0xB6DC, // 0x3230 (12848) pixels +0xB6FC, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x530E, 0x9DD9, 0xBF3E, // 0x3240 (12864) pixels +0xB6FC, 0x8D56, 0x530C, 0x2986, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3250 (12880) pixels +0x0000, 0x18E4, 0x426A, 0x63D0, 0x6BF1, 0x5B4E, 0x5B4F, 0x6BD1, 0x6BD1, 0x63B1, 0x7432, 0x9597, 0xAE5A, 0x63AF, 0x0000, 0x0000, // 0x3260 (12896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2126, 0x2988, 0x5B2F, 0x6390, 0x5B2F, 0x63B1, 0x9DB8, // 0x3270 (12912) pixels +0xC77E, 0xC77E, 0x8D35, 0x3A49, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1904, // 0x3280 (12928) pixels +0x426A, 0x530D, 0x426A, 0x3A2A, 0x5B70, 0x6BF2, 0x6BD1, 0x6BD1, 0x7CB4, 0x95B8, 0x6C11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3290 (12944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x1905, 0x426B, 0x63B1, 0x6370, 0x63B1, 0xAE7B, // 0x32A0 (12960) pixels +0xC77F, 0x8D55, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x32B0 (12976) pixels +0x0000, 0x0000, 0x0000, 0x18C4, 0x2126, 0x2988, 0x5B4F, 0x6370, 0x5B2F, 0x7433, 0xAEBB, 0xCFBF, 0xAE7A, 0x530C, 0x0882, 0x0000, // 0x32C0 (12992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x32D0 (13008) pixels +0x29A6, 0x63AF, 0x7452, 0x5B6E, 0x5B4F, 0x6BF1, 0x6BD1, 0x63B1, 0x9598, 0xC77E, 0xA65A, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x32E0 (13024) pixels +0x0000, 0x0000, 0x1082, 0x2126, 0x4ACD, 0x8D57, 0xBF1D, 0xB6DC, 0x8514, 0x42AA, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x32F0 (13040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2986, 0x63AF, 0x9DF9, 0xB6BC, 0x9DF9, 0x7C73, 0x63B1, 0x63B1, // 0x3300 (13056) pixels +0x6BB1, 0x6BF1, 0x7CB3, 0x7432, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3310 (13072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2146, 0x2105, 0x3A0A, 0x5B50, 0x6390, 0x5B2F, 0x5B50, 0x7C94, 0xA619, 0xBF3E, 0xCFBF, // 0x3320 (13088) pixels +0xC77E, 0xAE9B, 0xA639, 0x9DD8, 0x9DD8, 0xA619, 0xAE9B, 0xC75E, 0xCFBF, 0xC75E, 0xA63A, 0x7CB4, 0x63B1, 0x6390, 0x6BB1, 0x63B1, // 0x3330 (13104) pixels +0x63D0, 0x7431, 0x7CB4, 0x52EC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, // 0x3340 (13120) pixels +0x2966, 0x5B2F, 0x63B1, 0x5B50, 0x9577, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, 0x2105, // 0x3350 (13136) pixels +0x424B, 0x6370, 0x5B0F, 0x7433, 0xB6FD, 0xB6FC, 0xC75E, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, // 0x3360 (13152) pixels +0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCFBF, 0xCF9F, 0xCFDF, // 0x3370 (13168) pixels +0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2987, 0x5B2F, 0x5B4F, 0x5B2F, 0x6BD1, 0x84D5, 0x9DF9, 0xB6DC, 0xC75E, 0xCFBF, // 0x3380 (13184) pixels +0xCF9F, 0xBF1D, 0xB6BB, 0xA65A, 0xA639, 0x9E19, 0xA639, 0xA65A, 0xB6BB, 0xBF1D, 0xB6FD, 0xA619, 0x8D35, 0x6C32, 0x63B0, 0x63B1, // 0x3390 (13200) pixels +0x6BD1, 0x6BB1, 0x63B1, 0x7452, 0x8D56, 0x9DF9, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x33A0 (13216) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x33B0 (13232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, 0x5B4F, 0x63B1, 0x7412, 0xB6DC, 0xAEBB, 0x1904, 0x0000, 0x0000, // 0x33C0 (13248) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x4A8C, 0x5B50, 0x63B1, 0x8D16, 0xAE7B, 0xC75E, 0xBF1D, // 0x33D0 (13264) pixels +0xA639, 0x84F4, 0x5B8E, 0x426A, 0x29A7, 0x2145, 0x18E4, 0x1904, 0x2145, 0x29C7, 0x428A, 0x5B8E, 0x7CB3, 0x8D56, 0x8D56, 0x7C93, // 0x33E0 (13280) pixels +0x6BD1, 0x63B0, 0x6BB1, 0x63B1, 0x63B1, 0x7412, 0x8515, 0x9DD8, 0x7431, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x33F0 (13296) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x2126, 0x2967, 0x52ED, 0x6390, 0x5B4F, 0x5B4F, 0x7C94, 0xAE5A, 0xC79F, 0xC77F, // 0x3400 (13312) pixels +0xA65A, 0x7492, 0x4B0C, 0x3A29, 0x29A7, 0x2145, 0x2986, 0x3208, 0x42AB, 0x63AF, 0x7493, 0x84D4, 0x7452, 0x5B6F, 0x5B2E, 0x63B1, // 0x3410 (13328) pixels +0x6BD1, 0x6BD1, 0x63B1, 0x6BF1, 0x7CB4, 0x7452, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3420 (13344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x2126, 0x52EE, 0x63B1, 0x5B50, 0x7433, 0xB6FD, 0xC77F, 0x5B8F, 0x0000, 0x0000, // 0x3430 (13360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x3440 (13376) pixels +0x2125, 0x2125, 0x31E9, 0x5B4F, 0x6370, 0x5B2F, 0x63B1, 0x9598, 0xBF1D, 0xCF9F, 0xA65A, 0x7451, 0x3A49, 0x1924, 0x0020, 0x0000, // 0x3450 (13392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x3208, 0x5B8F, 0x8D35, 0x9DF9, 0x8D56, 0x7432, 0x63B1, // 0x3460 (13408) pixels +0x6BD1, 0x6BB1, 0x63B1, 0x84D5, 0xAEBB, 0xBF1D, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2146, // 0x3470 (13424) pixels +0x4AAD, 0x5B2F, 0x6390, 0x8D16, 0xAE9C, 0xC77E, 0xB6DC, 0x95B7, 0x6C10, 0x4ACB, 0x3A28, 0x2986, 0x2145, 0x1904, 0x2145, 0x2986, // 0x3480 (13440) pixels +0x3208, 0x4AEC, 0x6C31, 0x95B7, 0xB6FC, 0xBF3D, 0xAE7B, 0x8D36, 0x6BF2, 0x6390, 0x63B1, 0x6BB1, 0x63B0, 0x6C31, 0x6BF1, 0x1904, // 0x3490 (13456) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x34A0 (13472) pixels +0x0000, 0x10A3, 0x2126, 0x2105, 0x31A8, 0x52EE, 0x6390, 0x6370, 0x5B2F, 0x5B50, 0x7412, 0x8D16, 0x9DD9, 0xAE7B, 0xB6DC, 0xBEFD, // 0x34B0 (13488) pixels +0xBF1D, 0xB6DC, 0xAE7B, 0x9DF9, 0x8D56, 0x7453, 0x6390, 0x6370, 0x63B1, 0x6BB1, 0x6390, 0x5B6F, 0x63B0, 0x6C11, 0x428B, 0x0000, // 0x34C0 (13504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2946, 0x5B2F, 0x6391, 0x5B4F, // 0x34D0 (13520) pixels +0x9577, 0xC79F, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x2125, 0x426C, 0x5B50, 0x5B2F, 0x6BD1, // 0x34E0 (13536) pixels +0x8D16, 0x8D57, 0x8D57, 0x8D57, 0x8D57, 0x8D57, 0x8D57, 0x8D57, 0x9557, 0x9557, 0x9557, 0x9557, 0x9577, 0x9577, 0x9577, 0x9577, // 0x34F0 (13552) pixels +0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0x9577, 0xAE5A, 0xC77E, 0x428A, 0x0000, 0x0000, 0x0000, // 0x3500 (13568) pixels +0x0000, 0x10A3, 0x2946, 0x424B, 0x5B2F, 0x6370, 0x5B50, 0x5B0F, 0x5B2F, 0x63B1, 0x7433, 0x84F5, 0x9598, 0xA619, 0xAE7B, 0xB6BC, // 0x3510 (13584) pixels +0xB6DC, 0xB6DC, 0xB6DC, 0xB6BC, 0xAE7B, 0xA619, 0x9557, 0x7C73, 0x6BD1, 0x6390, 0x63B1, 0x6BB1, 0x6BB1, 0x63B0, 0x6BD0, 0x7C73, // 0x3520 (13600) pixels +0x8D15, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3530 (13616) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3540 (13632) pixels +0x0000, 0x0020, 0x1905, 0x2967, 0x5B4F, 0x63B1, 0x7412, 0xB6DC, 0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3550 (13648) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x3A2A, 0x5B2F, 0x5B50, 0x5B2F, 0x5B4F, 0x6BF2, 0x84F5, 0xA5F9, 0xB6BC, 0xC75E, 0xC77E, // 0x3560 (13664) pixels +0xBF1D, 0xB6FC, 0xB6DC, 0xB6DC, 0xB6FC, 0xBF3D, 0xC77F, 0xBF1D, 0xA63A, 0x8D16, 0x7453, 0x6BD1, 0x6391, 0x63B1, 0x63B1, 0x63B1, // 0x3570 (13680) pixels +0x6C11, 0x7CB4, 0x8D36, 0x63AF, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3580 (13696) pixels +0x0000, 0x0000, 0x10C4, 0x2126, 0x2146, 0x424B, 0x5B50, 0x6370, 0x5B2F, 0x6370, 0x7C94, 0x9DD8, 0xB6DC, 0xC77E, 0xCF9F, 0xC77E, // 0x3590 (13712) pixels +0xBF3D, 0xB6FC, 0xBF1D, 0xC75E, 0xC77F, 0xB6DC, 0x95B8, 0x7C93, 0x6BD1, 0x63B0, 0x6BB1, 0x6BD1, 0x6BD1, 0x5B6F, 0x5B4E, 0x63D0, // 0x35A0 (13728) pixels +0x5B8F, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x35B0 (13744) pixels +0x18C4, 0x2126, 0x2967, 0x5B4F, 0x6390, 0x5B4F, 0x84F5, 0xBF3D, 0xC75E, 0x3A29, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x35C0 (13760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2105, 0x2125, 0x31A8, // 0x35D0 (13776) pixels +0x52EE, 0x6370, 0x5B2F, 0x5B2F, 0x6BF2, 0x8D36, 0xAE5B, 0xBF5E, 0xC77E, 0xB6DC, 0xA65A, 0x9597, 0x84F4, 0x7492, 0x7472, 0x7451, // 0x35E0 (13792) pixels +0x7472, 0x7CD3, 0x8D56, 0x9E19, 0xAE9B, 0xBF3E, 0xC77F, 0xAE7B, 0x8D15, 0x6C12, 0x63B1, 0x63B1, 0x63B1, 0x6BD1, 0x7CB4, 0xA619, // 0x35F0 (13808) pixels +0xAE7A, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2146, 0x3A0A, 0x5B2F, 0x5B50, 0x5B2F, // 0x3600 (13824) pixels +0x5B50, 0x7412, 0x8D57, 0xA65A, 0xBEFD, 0xC77F, 0xBF5E, 0xBEFD, 0xB6FC, 0xB6DC, 0xB6FC, 0xBF1D, 0xC75E, 0xC79F, 0xC77F, 0xBF1D, // 0x3610 (13840) pixels +0xA63A, 0x8D16, 0x7412, 0x6370, 0x6390, 0x6BB1, 0x6390, 0x5B6F, 0x63B0, 0x5B4E, 0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3620 (13856) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x2125, // 0x3630 (13872) pixels +0x2126, 0x2146, 0x424B, 0x5B0F, 0x6370, 0x6370, 0x5B4F, 0x5B2F, 0x5B4F, 0x6390, 0x63B1, 0x6BD1, 0x6BD1, 0x6BB1, 0x6390, 0x6370, // 0x3640 (13888) pixels +0x5B4F, 0x6370, 0x63B1, 0x63B1, 0x6370, 0x530E, 0x52ED, 0x5B4E, 0x5B4E, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3650 (13904) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2946, 0x5B4F, 0x63B1, 0x6370, 0x9598, 0xC79F, 0x8D56, 0x0000, // 0x3660 (13920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x2125, 0x4A8C, 0x5B50, 0x5B4F, 0x5B2F, 0x530E, 0x530E, 0x530E, 0x530F, // 0x3670 (13936) pixels +0x5B0F, 0x5B0F, 0x5B0F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, // 0x3680 (13952) pixels +0x5B50, 0x5B50, 0x5B50, 0x5B70, 0x5B70, 0x5B2F, 0x9577, 0xC77F, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2125, 0x2126, // 0x3690 (13968) pixels +0x2967, 0x3A2A, 0x52EE, 0x5B4F, 0x6370, 0x5B50, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B4F, 0x6370, 0x63B1, 0x6BB1, 0x6BB1, 0x6BB1, 0x63B1, // 0x36A0 (13984) pixels +0x6390, 0x6370, 0x5B50, 0x6370, 0x6391, 0x6BB1, 0x63B1, 0x6370, 0x530E, 0x532E, 0x63D0, 0x6BF1, 0x3208, 0x0000, 0x0000, 0x0000, // 0x36B0 (14000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x36C0 (14016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, // 0x36D0 (14032) pixels +0x5B2F, 0x6391, 0x7412, 0xB6DC, 0xAEBB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x36E0 (14048) pixels +0x18C4, 0x2126, 0x2987, 0x3A2A, 0x52EE, 0x5B2F, 0x5B50, 0x5B2F, 0x5B2F, 0x6390, 0x6BF2, 0x7C74, 0x8516, 0x9577, 0x9598, 0x9598, // 0x36F0 (14064) pixels +0x9577, 0x8D36, 0x84B5, 0x7432, 0x6BB1, 0x6390, 0x6370, 0x6391, 0x63B1, 0x6390, 0x6390, 0x6BD0, 0x7473, 0x7452, 0x3A6A, 0x0000, // 0x3700 (14080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, // 0x3710 (14096) pixels +0x1905, 0x2126, 0x29A8, 0x4AAC, 0x5B50, 0x6370, 0x5B2F, 0x5B4F, 0x63B1, 0x7433, 0x84D5, 0x8D57, 0x9577, 0x9598, 0x9577, 0x8D36, // 0x3720 (14112) pixels +0x84D5, 0x7432, 0x63B1, 0x6390, 0x6391, 0x6BD1, 0x6BB1, 0x5B4F, 0x4A8C, 0x426B, 0x4AEC, 0x424A, 0x0862, 0x0000, 0x0000, 0x0000, // 0x3730 (14128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x2125, 0x31A8, 0x6370, // 0x3740 (14144) pixels +0x6370, 0x5B2F, 0x9577, 0xC75E, 0xB6BB, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3750 (14160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x18E4, 0x2125, 0x2146, 0x3A2A, 0x530E, 0x5B50, // 0x3760 (14176) pixels +0x5B50, 0x5B2F, 0x5B70, 0x6BD1, 0x7C74, 0x8D36, 0x9DB8, 0xA61A, 0xAE5B, 0xAE7B, 0xAE9B, 0xAE9C, 0xAE7B, 0xAE7B, 0xA63A, 0x9DF9, // 0x3770 (14192) pixels +0x9577, 0x84D5, 0x7432, 0x6BB1, 0x6390, 0x6391, 0x63B1, 0x63B1, 0x6BF1, 0x7C93, 0x9597, 0x8515, 0x31E8, 0x0000, 0x0000, 0x0000, // 0x3780 (14208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x1905, 0x2126, 0x2967, 0x424B, 0x52EE, 0x5B50, 0x5B50, 0x5B2F, 0x5B4F, // 0x3790 (14224) pixels +0x6390, 0x7412, 0x7C94, 0x84F6, 0x9557, 0x9597, 0x9598, 0x9577, 0x8D57, 0x84F5, 0x7C73, 0x6BF2, 0x6390, 0x5B50, 0x6390, 0x63B1, // 0x37A0 (14240) pixels +0x6390, 0x530E, 0x52ED, 0x532D, 0x426A, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x37B0 (14256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x18C4, 0x2126, 0x2125, 0x2966, // 0x37C0 (14272) pixels +0x3A09, 0x4AAC, 0x5B2F, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, 0x5B70, 0x52EE, 0x428C, // 0x37D0 (14288) pixels +0x424A, 0x426B, 0x4AAC, 0x3A29, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x37E0 (14304) pixels +0x0000, 0x0000, 0x0862, 0x2126, 0x2146, 0x4A8C, 0x52CD, 0x4A8C, 0x7CB4, 0xCFDF, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x37F0 (14320) pixels +0x0000, 0x0862, 0x2146, 0x2125, 0x4A8C, 0x5B4F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B50, // 0x3800 (14336) pixels +0x5B50, 0x5B50, 0x5B70, 0x5B70, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, 0x6390, // 0x3810 (14352) pixels +0x6390, 0x6370, 0x95B8, 0xCFBF, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x10A3, 0x1905, 0x2126, 0x2146, 0x31A8, // 0x3820 (14368) pixels +0x422A, 0x4AAD, 0x5B0E, 0x5B4F, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, 0x6370, // 0x3830 (14384) pixels +0x5B2E, 0x4A8C, 0x3A2A, 0x39E9, 0x426A, 0x4ACC, 0x426A, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3840 (14400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3850 (14416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x2967, 0x5B2F, 0x6390, 0x7412, 0xBF1D, // 0x3860 (14432) pixels +0xB6BB, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x10C4, 0x1905, // 0x3870 (14448) pixels +0x2146, 0x31A8, 0x3A2A, 0x4AAD, 0x5B2F, 0x5B4F, 0x5B50, 0x5B50, 0x5B4F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B4F, 0x5B4F, 0x6370, 0x6370, // 0x3880 (14464) pixels +0x6390, 0x6390, 0x6370, 0x5B2F, 0x530E, 0x5B2E, 0x638F, 0x63AF, 0x4AAB, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3890 (14480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x10C4, 0x1905, 0x2126, // 0x38A0 (14496) pixels +0x31A8, 0x426B, 0x530E, 0x5B50, 0x6370, 0x5B70, 0x5B50, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B4F, 0x5B50, 0x6370, 0x6390, 0x6391, 0x6390, // 0x38B0 (14512) pixels +0x5B70, 0x52CD, 0x3A09, 0x2967, 0x2967, 0x31C8, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x38C0 (14528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2125, 0x2105, 0x31E9, 0x5B70, 0x5B50, 0x5B2F, 0x9DD9, 0xCFBF, // 0x38D0 (14544) pixels +0xA639, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x38E0 (14560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x1905, 0x2125, 0x2967, 0x39E9, 0x4A8C, 0x530E, 0x5B4F, 0x5B50, // 0x38F0 (14576) pixels +0x5B50, 0x5B4F, 0x5B2F, 0x5B4F, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, 0x6370, 0x5B50, 0x6370, 0x6390, 0x6390, 0x6390, // 0x3900 (14592) pixels +0x6370, 0x5B4F, 0x5B6F, 0x63B0, 0x7452, 0x7432, 0x4ACC, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3910 (14608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x18E4, 0x2105, 0x2967, 0x31C9, 0x426C, 0x52EE, 0x5B2F, 0x5B4F, 0x5B50, 0x5B50, 0x5B4F, // 0x3920 (14624) pixels +0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B4F, 0x5B50, 0x6370, 0x6390, 0x6390, 0x6370, 0x5B2E, 0x4AAC, 0x424A, 0x424A, 0x3A4A, 0x2125, // 0x3930 (14640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3940 (14656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x18C4, 0x2105, 0x2125, 0x2126, 0x2967, 0x31C8, // 0x3950 (14672) pixels +0x3A0A, 0x426B, 0x4A8C, 0x4AAC, 0x4A8C, 0x4A8C, 0x426B, 0x3A2A, 0x31C9, 0x2967, 0x2967, 0x2987, 0x31C8, 0x2987, 0x10C3, 0x0000, // 0x3960 (14688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2146, // 0x3970 (14704) pixels +0x2126, 0x2126, 0x2126, 0x2105, 0x2146, 0x9576, 0x9DD8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2146, 0x2125, // 0x3980 (14720) pixels +0x2987, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, // 0x3990 (14736) pixels +0x31A8, 0x31A8, 0x31C8, 0x31A8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x2987, 0x52ED, 0xBF1D, // 0x39A0 (14752) pixels +0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x1083, 0x18E4, 0x2105, 0x2105, 0x2126, 0x2967, 0x29A8, // 0x39B0 (14768) pixels +0x39E9, 0x3A2A, 0x426B, 0x4A8C, 0x4AAC, 0x4AAC, 0x4A8C, 0x4A8C, 0x426B, 0x3A2A, 0x31E9, 0x2988, 0x2146, 0x2125, 0x2125, 0x2966, // 0x39C0 (14784) pixels +0x2966, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x39D0 (14800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x39E0 (14816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, 0x2146, 0x31C8, 0x31E9, 0x31C9, 0x8515, 0xB6FD, 0x1924, 0x0000, 0x0000, // 0x39F0 (14832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x1083, 0x18E4, 0x1905, 0x2126, // 0x3A00 (14848) pixels +0x2987, 0x31E9, 0x424B, 0x4A8C, 0x4ACD, 0x52EE, 0x530E, 0x530E, 0x530E, 0x52EE, 0x4ACD, 0x4A8C, 0x426B, 0x424A, 0x424A, 0x426B, // 0x3A10 (14864) pixels +0x428B, 0x428B, 0x31E8, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3A20 (14880) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x10A3, 0x18E4, 0x2105, 0x2967, 0x31C8, // 0x3A30 (14896) pixels +0x3A2A, 0x4A8C, 0x52CD, 0x530E, 0x5B0E, 0x5B2F, 0x5B0E, 0x530E, 0x52CD, 0x4AAC, 0x424B, 0x31E9, 0x2987, 0x2126, 0x1905, 0x18E4, // 0x3A40 (14912) pixels +0x1083, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3A50 (14928) pixels +0x0000, 0x0000, 0x0000, 0x0021, 0x2126, 0x2126, 0x2146, 0x2987, 0x2987, 0x2947, 0x4AEC, 0xB6BC, 0xA65A, 0x0000, 0x0000, 0x0000, // 0x3A60 (14944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3A70 (14960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x18C4, 0x1905, 0x2126, 0x2967, 0x31A8, 0x3A2A, 0x426B, 0x4AAC, 0x52CD, 0x52EE, // 0x3A80 (14976) pixels +0x530E, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x5B2F, 0x530E, 0x530E, 0x52CD, 0x4A8C, 0x424B, 0x3A2A, 0x424A, 0x4A8B, 0x4ACC, 0x4AAB, // 0x3A90 (14992) pixels +0x31E8, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3AA0 (15008) pixels +0x0000, 0x0000, 0x0862, 0x10C4, 0x18E5, 0x2125, 0x2147, 0x31A8, 0x3A09, 0x424B, 0x4A8C, 0x4ACD, 0x52EE, 0x530E, 0x530E, 0x530E, // 0x3AB0 (15024) pixels +0x530E, 0x52EE, 0x4AAD, 0x4A8C, 0x3A0A, 0x29A8, 0x2967, 0x2987, 0x2987, 0x1904, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3AC0 (15040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3AD0 (15056) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x1082, 0x18C4, 0x1905, 0x2105, 0x2105, 0x2105, 0x2126, 0x2126, // 0x3AE0 (15072) pixels +0x2126, 0x2126, 0x2105, 0x2105, 0x2105, 0x1905, 0x18E4, 0x10A3, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3AF0 (15088) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2126, 0x2125, 0x2125, 0x2125, 0x2125, // 0x3B00 (15104) pixels +0x18E5, 0x2987, 0x5B4E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x2126, 0x2125, 0x2105, 0x1905, 0x1905, 0x1905, // 0x3B10 (15120) pixels +0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, // 0x3B20 (15136) pixels +0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x1905, 0x18C4, 0x4AAB, 0x31E8, 0x0000, 0x0000, 0x0000, // 0x3B30 (15152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x1083, 0x18C4, 0x18E5, 0x2105, 0x2105, 0x2105, 0x2105, 0x2126, // 0x3B40 (15168) pixels +0x2126, 0x2126, 0x2126, 0x2125, 0x2105, 0x2105, 0x2105, 0x1905, 0x18E4, 0x10A3, 0x0862, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3B50 (15184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3B60 (15200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3B70 (15216) pixels +0x0000, 0x0020, 0x1905, 0x2126, 0x1905, 0x1905, 0x18E4, 0x2126, 0x63AF, 0x1924, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3B80 (15232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0882, 0x10A3, 0x18E4, 0x1905, 0x2105, // 0x3B90 (15248) pixels +0x2146, 0x2946, 0x2967, 0x2967, 0x2967, 0x2146, 0x2126, 0x2105, 0x2125, 0x2146, 0x2146, 0x2125, 0x10C3, 0x0020, 0x0000, 0x0000, // 0x3BA0 (15264) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3BB0 (15280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x10A3, 0x18C4, 0x18E5, 0x2105, 0x2146, 0x2946, // 0x3BC0 (15296) pixels +0x2967, 0x2967, 0x2967, 0x2967, 0x2146, 0x2105, 0x1905, 0x1905, 0x18C4, 0x10A3, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3BD0 (15312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 0x3BE0 (15328) pixels +0x2105, 0x2126, 0x2125, 0x1905, 0x1905, 0x2105, 0x18C4, 0x3A29, 0x7431, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3BF0 (15344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3C00 (15360) pixels +0x0000, 0x0000, 0x0000, 0x0020, 0x0862, 0x10A3, 0x18C4, 0x18E5, 0x1905, 0x2125, 0x2146, 0x2947, 0x2967, 0x2967, 0x2967, 0x2967, // 0x3C10 (15376) pixels +0x2967, 0x2967, 0x2967, 0x2146, 0x2126, 0x1905, 0x18E5, 0x1905, 0x2125, 0x1904, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3C20 (15392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3C30 (15408) pixels +0x0020, 0x0862, 0x10A3, 0x18C4, 0x18E5, 0x1905, 0x2105, 0x2146, 0x2146, 0x2967, 0x2967, 0x2967, 0x2967, 0x2146, 0x2126, 0x1905, // 0x3C40 (15424) pixels +0x18E5, 0x18C4, 0x10A3, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3C50 (15440) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3C60 (15456) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0862, 0x1082, 0x1083, 0x10A3, 0x10A3, 0x1083, 0x1082, 0x0862, // 0x3C70 (15472) pixels +0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3C80 (15488) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, // 0x3C90 (15504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, // 0x3CA0 (15520) pixels +0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, // 0x3CB0 (15536) pixels +0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3CC0 (15552) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0882, 0x1082, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, // 0x3CD0 (15568) pixels +0x1083, 0x0882, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3CE0 (15584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3CF0 (15600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, // 0x3D00 (15616) pixels +0x0020, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3D10 (15632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0862, 0x1082, 0x1083, 0x1083, // 0x3D20 (15648) pixels +0x1083, 0x1082, 0x0862, 0x0862, 0x0041, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3D30 (15664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3D40 (15680) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0862, 0x0882, 0x1083, 0x1083, 0x1083, 0x1083, // 0x3D50 (15696) pixels +0x0882, 0x0862, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3D60 (15712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, // 0x3D70 (15728) pixels +0x0020, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3D80 (15744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3D90 (15760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0841, 0x0862, 0x0862, 0x1082, 0x1083, 0x1083, 0x1083, 0x1083, 0x1082, 0x0882, 0x0862, // 0x3DA0 (15776) pixels +0x0841, 0x0041, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3DB0 (15792) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3DC0 (15808) pixels +0x0000, 0x0021, 0x0841, 0x0862, 0x0882, 0x1083, 0x1083, 0x1083, 0x1083, 0x0882, 0x0862, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, // 0x3DD0 (15824) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3DE0 (15840) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3DF0 (15856) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E00 (15872) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E10 (15888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E20 (15904) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E30 (15920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E40 (15936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E50 (15952) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E60 (15968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E70 (15984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E80 (16000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3E90 (16016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3EA0 (16032) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3EB0 (16048) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3EC0 (16064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3ED0 (16080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3EE0 (16096) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3EF0 (16112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F00 (16128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F10 (16144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F20 (16160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F30 (16176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F40 (16192) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F50 (16208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F60 (16224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F70 (16240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F80 (16256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3F90 (16272) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3FA0 (16288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3FB0 (16304) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3FC0 (16320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3FD0 (16336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3FE0 (16352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x3FF0 (16368) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4000 (16384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4010 (16400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4020 (16416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4030 (16432) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4040 (16448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4050 (16464) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4060 (16480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4070 (16496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4080 (16512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4090 (16528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40A0 (16544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40B0 (16560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40C0 (16576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40D0 (16592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40E0 (16608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40F0 (16624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4100 (16640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4110 (16656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4120 (16672) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4130 (16688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4140 (16704) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4150 (16720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4160 (16736) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4170 (16752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4180 (16768) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4190 (16784) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x41A0 (16800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x41B0 (16816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x41C0 (16832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x41D0 (16848) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x41E0 (16864) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x41F0 (16880) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4200 (16896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4210 (16912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4220 (16928) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4230 (16944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4240 (16960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4250 (16976) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4260 (16992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4270 (17008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4280 (17024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4290 (17040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x42A0 (17056) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x42B0 (17072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x42C0 (17088) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x42D0 (17104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x42E0 (17120) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x42F0 (17136) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4300 (17152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4310 (17168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4320 (17184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4330 (17200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4340 (17216) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4350 (17232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4360 (17248) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4370 (17264) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4380 (17280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4390 (17296) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x43A0 (17312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x43B0 (17328) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x43C0 (17344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x43D0 (17360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x43E0 (17376) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x43F0 (17392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4400 (17408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x4410 (17424) pixels +}; + +// Generated by : ImageConverter 565 Online +// Generated from : nesto_numbers_21px.png +// Time generated : Thu, 24 Oct 24 13:55:04 +0200 (Server timezone: CET) +// Image Size : 189x20 pixels + +const uint16_t nesto_numbers_20px[3780] = { +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0010 (16) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0020 (32) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0030 (48) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0040 (64) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0050 (80) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0060 (96) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0070 (112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0080 (128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0090 (144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00A0 (160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00B0 (176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00C0 (192) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x3A49, 0x530C, 0x534D, 0x530C, 0x3A49, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00D0 (208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x10C3, 0x29C7, 0x31C7, 0x2986, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00E0 (224) pixels +0x0000, 0x0841, 0x2986, 0x42AA, 0x532D, 0x534D, 0x4AEC, 0x3A28, 0x10E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00F0 (240) pixels +0x0000, 0x0000, 0x0861, 0x2145, 0x3A49, 0x4AEC, 0x534D, 0x532D, 0x4ACB, 0x3208, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0100 (256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x29A7, 0x29C7, 0x29A6, 0x0861, 0x0000, 0x0000, 0x0000, // 0x0110 (272) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x29A6, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29A7, 0x29A7, 0x29A7, 0x29A7, // 0x0120 (288) pixels +0x29A7, 0x29A7, 0x29A7, 0x29A7, 0x29A7, 0x29A7, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0130 (304) pixels +0x10E3, 0x3A28, 0x4AEC, 0x534D, 0x532D, 0x4ACB, 0x3208, 0x18E4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2145, 0x31E8, // 0x0140 (320) pixels +0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x29C7, 0x2145, 0x0000, 0x0000, // 0x0150 (336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1904, 0x3A29, 0x4AEB, 0x532D, 0x532D, 0x4AEC, 0x426A, 0x29A6, 0x0882, 0x0000, 0x0000, // 0x0160 (352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1924, 0x3A49, 0x530C, 0x534D, 0x530C, 0x426A, // 0x0170 (368) pixels +0x2165, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0180 (384) pixels +0x426A, 0x8D56, 0xAE7B, 0xAE9B, 0xAE7B, 0xAE5B, 0xAE7B, 0xAE9C, 0xAE9B, 0x9596, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0190 (400) pixels +0x0021, 0x63D0, 0x9DD8, 0xA63A, 0xAE9B, 0xB6DC, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x63AF, 0x9DD8, 0xAE9B, // 0x01A0 (416) pixels +0xAE7B, 0xAE5B, 0xAE5B, 0xAE7B, 0xAE9B, 0xAE7B, 0x8D56, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2986, 0x534E, 0x7CB3, // 0x01B0 (432) pixels +0x95B8, 0xAE5A, 0xAE7B, 0xAE5A, 0xAE5B, 0xAE7B, 0xAE9B, 0xAE5A, 0x8D56, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01C0 (448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x6BD0, 0xAE5A, 0xBF3D, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01D0 (464) pixels +0x0000, 0x0000, 0x0000, 0x0020, 0x6BD0, 0xA63A, 0xA619, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA65A, 0xA65A, 0xA65A, // 0x01E0 (480) pixels +0xA65A, 0xA63A, 0xC77F, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31E7, 0x7CB3, 0xA639, 0xAE5A, 0xA63A, // 0x01F0 (496) pixels +0xA61A, 0xA63A, 0xAE5B, 0xAE7B, 0xA65A, 0x9576, 0x5B8E, 0x1904, 0x0000, 0x0000, 0x0000, 0x4AAC, 0xAE9B, 0xAE7B, 0xAE7B, 0xAE7B, // 0x0200 (512) pixels +0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE7B, 0xAE9B, 0xAE9B, 0xAE9B, 0xAE7B, 0xBF1D, 0x95B7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, // 0x0210 (528) pixels +0x3208, 0x6BF0, 0x8D15, 0x9DD8, 0x9DD9, 0x9598, 0x9598, 0x9DD8, 0xA619, 0xA63A, 0x9DF8, 0x7CD3, 0x3208, 0x0000, 0x0000, 0x0000, // 0x0220 (544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x3A49, 0x84F4, 0xA63A, 0xAE5B, 0xA63A, 0xA61A, 0xA63A, 0xA65A, 0xA65A, 0x95B8, 0x63F0, // 0x0230 (560) pixels +0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x6C11, 0x9DF9, 0x9577, 0x7C94, // 0x0240 (576) pixels +0x6BF1, 0x6390, 0x5B6F, 0x63B0, 0x7412, 0x84F5, 0x9DD9, 0xBEFD, 0x8D76, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x530D, 0x7453, // 0x0250 (592) pixels +0x6C12, 0x84F5, 0xAEBB, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0041, 0x426A, 0x84D4, 0x9577, 0x84F5, 0x7432, 0x6390, 0x5B4F, 0x5B4F, // 0x0260 (608) pixels +0x6390, 0x7432, 0x84F5, 0x9DF9, 0xBF3E, 0x7472, 0x0000, 0x0000, 0x0000, 0x0000, 0x4AAC, 0x84B5, 0x7C94, 0x7C73, 0x6BF1, 0x5B6F, // 0x0270 (624) pixels +0x532E, 0x5B2E, 0x638F, 0x6C12, 0x84F5, 0x9DF9, 0xBEFD, 0x8D56, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0280 (640) pixels +0x0000, 0x0000, 0x0021, 0x39E9, 0x7C73, 0xB6DC, 0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0290 (656) pixels +0x0000, 0x3A09, 0x7C74, 0x5B6F, 0x52ED, 0x530E, 0x532E, 0x532E, 0x5B2E, 0x5B2E, 0x5B2E, 0x5B4E, 0x5B4F, 0x5B6F, 0x5B4F, 0x9DD8, // 0x02A0 (672) pixels +0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x532D, 0x8D57, 0x8D36, 0x7453, 0x636F, 0x52ED, 0x4A8C, 0x4A8C, 0x4ACD, // 0x02B0 (688) pixels +0x5B4F, 0x7432, 0x8D36, 0xAE5B, 0xAE9B, 0x4B0C, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x6C12, 0x6BF2, 0x6C12, 0x6C12, 0x7412, 0x7432, // 0x02C0 (704) pixels +0x7432, 0x7432, 0x7432, 0x7432, 0x7432, 0x7473, 0x9DF9, 0x9DD8, 0x0000, 0x0000, 0x0000, 0x0862, 0x428B, 0x7453, 0x7CB4, 0x84B4, // 0x02D0 (720) pixels +0x5B6F, 0x31E9, 0x2967, 0x2967, 0x29A7, 0x3A09, 0x530D, 0x7473, 0x9DD8, 0xB6DC, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02E0 (736) pixels +0x10A2, 0x5B6E, 0x8D36, 0x84F5, 0x7453, 0x6390, 0x4ACD, 0x4A8C, 0x4AAC, 0x530D, 0x6BD1, 0x8D16, 0xA65A, 0xAE9B, 0x5B6E, 0x0000, // 0x02F0 (752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x63D0, 0x84F5, 0x7433, 0x6BD1, 0x426B, 0x2105, 0x10A3, 0x1083, // 0x0300 (768) pixels +0x10A3, 0x2125, 0x3A2A, 0x6390, 0x84B4, 0xAE9B, 0xA65A, 0x10A2, 0x0000, 0x0000, 0x0861, 0x4AAB, 0x2146, 0x5B2E, 0x8D16, 0xAE9B, // 0x0310 (784) pixels +0x10C3, 0x0000, 0x0000, 0x0000, 0x0862, 0x5B6F, 0x7C94, 0x6390, 0x3A09, 0x2126, 0x10A3, 0x0882, 0x0862, 0x10A3, 0x2126, 0x424B, // 0x0320 (800) pixels +0x6C11, 0x84F5, 0xC77E, 0x5B8F, 0x0000, 0x0000, 0x0000, 0x5B2E, 0x8D36, 0x63D0, 0x428B, 0x2146, 0x1082, 0x0841, 0x0842, 0x1082, // 0x0330 (816) pixels +0x1905, 0x3A09, 0x6390, 0x7CB4, 0xB6DC, 0x8D56, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, // 0x0340 (832) pixels +0x4A8C, 0x84D5, 0xB6DC, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A2A, 0x8D16, // 0x0350 (848) pixels +0x84F4, 0x0000, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0841, 0x0841, 0x18C4, 0x10C3, 0x0000, 0x0000, // 0x0360 (864) pixels +0x0000, 0x0000, 0x0021, 0x4AEC, 0x7C94, 0x7453, 0x638F, 0x31C8, 0x10A3, 0x0841, 0x0000, 0x0000, 0x0000, 0x0841, 0x10A3, 0x2987, // 0x0370 (880) pixels +0x52ED, 0x95B8, 0x8D56, 0x0000, 0x0000, 0x18C4, 0x2125, 0x2105, 0x2105, 0x2105, 0x2105, 0x2105, 0x2105, 0x2105, 0x2105, 0x2105, // 0x0380 (896) pixels +0x18E4, 0x2966, 0x7412, 0x9DF9, 0x8D35, 0x0000, 0x0000, 0x0021, 0x2987, 0x6BF1, 0x8D16, 0x9E19, 0x42AB, 0x0862, 0x0000, 0x0000, // 0x0390 (912) pixels +0x0000, 0x0000, 0x0000, 0x0021, 0x2125, 0x5B4F, 0x84D5, 0xBF3E, 0x532D, 0x0000, 0x0000, 0x0000, 0x0841, 0x4AAB, 0x7432, 0x7433, // 0x03A0 (928) pixels +0x7C93, 0x52ED, 0x18E4, 0x0021, 0x0000, 0x0020, 0x0841, 0x10C4, 0x31E9, 0x6390, 0x8D16, 0xB6FD, 0x7492, 0x0000, 0x0000, 0x0000, // 0x03B0 (944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x3A4A, 0x6C12, 0x7412, 0x7C73, 0x530D, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x03C0 (960) pixels +0x18E5, 0x530E, 0x7C94, 0xB6BC, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x5B4E, 0x8D16, 0xAE9B, 0x10C3, 0x0000, 0x0000, // 0x03D0 (976) pixels +0x0000, 0x0821, 0x5B4E, 0x5B6E, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0842, 0x31C8, 0x7412, 0x95B8, // 0x03E0 (992) pixels +0xAE7A, 0x0841, 0x0000, 0x0841, 0x428B, 0x2166, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x18E5, // 0x03F0 (1008) pixels +0x5B6F, 0x84F5, 0xBF3D, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x5B4F, 0x9598, 0x9DF8, // 0x0400 (1024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A2A, 0x8D16, 0x9597, 0x0000, 0x0000, // 0x0410 (1040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, // 0x0420 (1056) pixels +0x6BD1, 0x7453, 0x6BF1, 0x29A7, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3209, 0x7452, // 0x0430 (1072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x5B6F, 0x7C94, // 0x0440 (1088) pixels +0x63D0, 0x10C3, 0x0000, 0x0000, 0x0862, 0x424B, 0x7453, 0xB6BC, 0x63AF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0450 (1104) pixels +0x0000, 0x0000, 0x2966, 0x7432, 0xA619, 0x95B7, 0x0000, 0x0000, 0x0000, 0x18E4, 0x5B2E, 0x7453, 0x9DD8, 0x534D, 0x0841, 0x0000, // 0x0460 (1120) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x530D, 0x7CB4, 0xBEFD, 0x63AF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0470 (1136) pixels +0x10A3, 0x4ACD, 0x6BF1, 0x84F5, 0x8515, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x18E5, 0x636F, // 0x0480 (1152) pixels +0x84D5, 0xBF3E, 0x3A29, 0x0000, 0x0000, 0x0000, 0x10C4, 0x5B2E, 0x84F5, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x18C4, 0x3A4A, // 0x0490 (1168) pixels +0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x638F, 0x8D36, 0xB6DC, 0x10A3, 0x0000, // 0x04A0 (1184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x424A, 0x7CB4, 0xB6FD, // 0x04B0 (1200) pixels +0x3208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x31C8, 0x6C12, 0xAE9C, 0x5B6D, 0x0000, 0x0000, 0x0000, // 0x04C0 (1216) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A0A, 0x84F6, 0x8D76, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, // 0x04D0 (1232) pixels +0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x426B, 0x7432, 0x7CB4, 0x3A29, // 0x04E0 (1248) pixels +0x0000, 0x0000, 0x0000, 0x0020, 0x10A2, 0x10C3, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x0000, 0x0000, 0x0000, // 0x04F0 (1264) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x5B4F, 0x84B4, 0x7432, 0x1904, 0x0000, 0x0000, // 0x0500 (1280) pixels +0x0000, 0x0862, 0x3A2A, 0x7432, 0xB6DC, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, // 0x0510 (1296) pixels +0x6C12, 0xA63A, 0x8D76, 0x0000, 0x0000, 0x0000, 0x2146, 0x6390, 0x9DB8, 0x9597, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0520 (1312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x5B4E, 0x84F5, 0xB6DC, 0x2125, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x52ED, 0x7433, // 0x0530 (1328) pixels +0xB6DC, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x31E9, 0x7453, 0xAE5B, 0x8514, // 0x0540 (1344) pixels +0x0000, 0x0000, 0x0000, 0x10C4, 0x5B2E, 0x84F5, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0550 (1360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x31C8, 0x6C12, 0x9DB8, 0xA639, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0560 (1376) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x29A7, 0x5B4F, 0x8D16, 0xA639, 0x10A2, 0x0000, 0x0000, // 0x0570 (1392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x532E, 0x84F6, 0xA619, 0x0882, 0x0000, 0x0000, 0x3A4A, 0x84F4, 0x8535, 0x426A, // 0x0580 (1408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x3A0A, 0x84D5, 0x9597, 0x29A7, 0x5B4E, 0x7CB3, 0x9576, 0x95B7, 0x9597, 0x8D56, 0x7CB3, // 0x0590 (1424) pixels +0x5B8E, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x5B2E, 0x84D5, 0x6C11, 0x0000, 0x1904, 0x530C, 0x7CB3, // 0x05A0 (1440) pixels +0x9597, 0x9DD8, 0x9DF8, 0x9DD8, 0x9576, 0x7C93, 0x4ACB, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x05B0 (1456) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x426B, 0x7C73, 0x84D4, 0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2146, // 0x05C0 (1472) pixels +0x6390, 0x8D36, 0xA67A, 0x3A49, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1924, 0x4ACC, 0x638F, 0x7C94, 0xAE7B, 0x42AB, // 0x05D0 (1488) pixels +0x0000, 0x0000, 0x0020, 0x29A8, 0x63B1, 0xAE7B, 0x6C10, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x05E0 (1504) pixels +0x0000, 0x0000, 0x2146, 0x6BF1, 0xAE5B, 0x6C10, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x5B2E, 0x84F5, 0xAEBB, 0x0882, 0x0000, // 0x05F0 (1520) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2105, 0x63B0, 0x9577, 0xA65A, 0x0021, 0x0000, 0x0000, // 0x0600 (1536) pixels +0x10C4, 0x530E, 0x84D5, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0610 (1552) pixels +0x2125, 0x428A, 0x530D, 0x5B4E, 0x7432, 0x7C73, 0x9DB8, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, // 0x0620 (1568) pixels +0x5B6E, 0x63CF, 0x63AF, 0x63AF, 0x6C10, 0x7432, 0x6C12, 0x7432, 0x8D36, 0x428A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0630 (1584) pixels +0x0000, 0x10C3, 0x4A8C, 0x7412, 0xA619, 0x428A, 0x0000, 0x0000, 0x0000, 0x2146, 0x7CB4, 0xBF1E, 0x6C10, 0x0000, 0x0000, 0x0000, // 0x0640 (1600) pixels +0x0000, 0x0020, 0x3A0A, 0x7453, 0x7CB4, 0x7CB4, 0x84D5, 0x7453, 0x6BD1, 0x6BD1, 0x6C12, 0x7C94, 0x8D36, 0xA5F9, 0xAE7B, 0x8D56, // 0x0650 (1616) pixels +0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x2146, 0x6390, 0x95B8, 0x5B8E, 0x4AEC, 0x84F5, 0x9577, 0x84F5, 0x7453, 0x6BD1, 0x6BD1, // 0x0660 (1632) pixels +0x6C12, 0x7C94, 0x9577, 0xAE5A, 0xA63A, 0x530C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0670 (1648) pixels +0x0000, 0x0000, 0x2987, 0x6BF2, 0x84F5, 0x5B4E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2146, 0x530E, 0x7C94, // 0x0680 (1664) pixels +0x9DF9, 0x9576, 0x7CB3, 0x7472, 0x7452, 0x7CB3, 0x8D56, 0x9577, 0x7C93, 0x7432, 0x7432, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0690 (1680) pixels +0x2146, 0x6370, 0x9598, 0x95B7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, // 0x06A0 (1696) pixels +0x530E, 0x9557, 0x9597, 0x0000, 0x0000, 0x0000, 0x0020, 0x2146, 0x5B4F, 0x9577, 0x9DD8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06B0 (1712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x5B2E, 0x8D16, 0xB6BB, 0x10C3, 0x0000, 0x0000, 0x10C4, 0x530E, 0x84B5, // 0x06C0 (1728) pixels +0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x5B6E, 0x9597, 0x9DF9, 0x8D16, 0x7C74, // 0x06D0 (1744) pixels +0x7432, 0x5B4F, 0x5B2E, 0x3A29, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x6BF1, 0x9DB8, 0x9577, // 0x06E0 (1760) pixels +0x9578, 0x8D36, 0x7C74, 0x7432, 0x7CB4, 0x3208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x52ED, 0x6BD1, // 0x06F0 (1776) pixels +0x8D36, 0x6C11, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x5B4F, 0xA63A, 0x63CF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A0A, // 0x0700 (1792) pixels +0x7C94, 0x7432, 0x532E, 0x31C8, 0x18C4, 0x1083, 0x10A3, 0x10C4, 0x2125, 0x31E9, 0x52ED, 0x7432, 0x9DD9, 0xB6FC, 0x3208, 0x0000, // 0x0710 (1808) pixels +0x0000, 0x0000, 0x29A8, 0x6BD1, 0x8D16, 0x6C11, 0x7453, 0x6BF2, 0x52ED, 0x29A7, 0x1905, 0x10C4, 0x10A3, 0x18E4, 0x2967, 0x424B, // 0x0720 (1824) pixels +0x6390, 0x84F5, 0xB6FD, 0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x5B4F, // 0x0730 (1840) pixels +0x7CB4, 0x84F4, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2966, 0x530D, 0x6390, 0x6BF2, 0x7453, 0x7C94, // 0x0740 (1856) pixels +0x84B5, 0x84D5, 0x84B5, 0x7C94, 0x7453, 0x7C73, 0x8D36, 0x7CB3, 0x1924, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x4AAC, 0x7412, // 0x0750 (1872) pixels +0xAE9C, 0x6C31, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x29A6, 0x5B6E, 0x6C12, 0x6C12, 0x7CB4, 0x9E19, // 0x0760 (1888) pixels +0x0861, 0x0000, 0x0000, 0x0020, 0x2146, 0x5B2F, 0x9577, 0x9597, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0770 (1904) pixels +0x0000, 0x0000, 0x0000, 0x10C4, 0x530E, 0x84F5, 0xB6BC, 0x1904, 0x0000, 0x0000, 0x10C4, 0x530E, 0x7CB4, 0xAE9B, 0x10C3, 0x0000, // 0x0780 (1920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x7CB3, 0xAE7B, 0xA61A, 0x84F6, 0x6BF2, 0x5B4F, 0x4A8C, 0x2987, 0x10C4, 0x0862, // 0x0790 (1936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2987, 0x39E9, 0x39E9, 0x3A2A, 0x4AAC, 0x5B6F, // 0x07A0 (1952) pixels +0x7453, 0x9DB8, 0x9DD8, 0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x638F, 0x6BD1, 0x7C74, 0x7452, 0x0861, 0x0000, // 0x07B0 (1968) pixels +0x0000, 0x0000, 0x0000, 0x1905, 0x6370, 0xA63A, 0x63CF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x5B4E, 0x5B4E, 0x1924, 0x0020, // 0x07C0 (1984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x3A0A, 0x6BD1, 0x9598, 0xAE9B, 0x0882, 0x0000, 0x0000, 0x31A8, // 0x07D0 (2000) pixels +0x6BD1, 0x63B0, 0x6C12, 0x6BD1, 0x31E8, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2105, 0x530E, 0x7C73, // 0x07E0 (2016) pixels +0xBF1D, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x426B, 0x7432, 0x9598, 0x428A, 0x0000, // 0x07F0 (2032) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x31C8, 0x63B0, 0x7412, 0x6390, 0x3A2A, 0x2987, 0x2126, 0x1905, 0x1905, 0x2125, // 0x0800 (2048) pixels +0x2967, 0x31E9, 0x4ACD, 0x6BF1, 0x9557, 0xAE9B, 0x63AF, 0x0000, 0x0000, 0x0000, 0x0020, 0x2126, 0x52EE, 0x7433, 0xA63A, 0x95B8, // 0x0810 (2064) pixels +0x63AF, 0x3A49, 0x29A7, 0x31C7, 0x428A, 0x63AF, 0x7CD4, 0x8515, 0x7C94, 0x7CB4, 0x7432, 0x7C74, 0x9E19, 0x0882, 0x0000, 0x0000, // 0x0820 (2080) pixels +0x0000, 0x2125, 0x530E, 0x8D16, 0xA639, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0830 (2096) pixels +0x18E4, 0x5B4F, 0x8D16, 0xAE9B, 0x0882, 0x0000, 0x0000, 0x18C4, 0x52ED, 0x7C94, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0840 (2112) pixels +0x0000, 0x4AEC, 0xAE7B, 0x9598, 0x6C12, 0x6370, 0x4AAC, 0x2987, 0x18C4, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0850 (2128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2987, 0x530E, 0x8D16, // 0x0860 (2144) pixels +0xB6FC, 0x29C7, 0x0000, 0x0000, 0x0000, 0x2125, 0x7473, 0x6C12, 0x6BB1, 0x5B6E, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0870 (2160) pixels +0x10C4, 0x5B6F, 0xA63A, 0x5B8E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0880 (2176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x4A8C, 0x7432, 0xBEFD, 0x530C, 0x0000, 0x0000, 0x2967, 0x6370, 0x8D16, 0x7472, // 0x0890 (2192) pixels +0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2126, 0x636F, 0x9577, 0x9DF8, 0x0000, // 0x08A0 (2208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2967, 0x6390, 0x84F5, 0x8D35, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08B0 (2224) pixels +0x0000, 0x0020, 0x2946, 0x5B4F, 0x7C53, 0x6C31, 0x1925, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x08C0 (2240) pixels +0x18E4, 0x4AAC, 0x7C73, 0xBF1D, 0x4ACB, 0x0000, 0x0000, 0x0000, 0x0020, 0x1905, 0x426B, 0x5B70, 0x7C94, 0x9DB8, 0x9DF9, 0x9DF9, // 0x08D0 (2256) pixels +0x9DD9, 0x9DD9, 0x8D37, 0x7C73, 0x7432, 0x6C11, 0x6C11, 0x6C11, 0x7CB4, 0x9DF8, 0x0020, 0x0000, 0x0000, 0x0000, 0x18C4, 0x4AAC, // 0x08E0 (2272) pixels +0x7433, 0xBF1D, 0x2986, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2987, 0x63B0, 0x9598, // 0x08F0 (2288) pixels +0x9DD8, 0x0000, 0x0000, 0x0000, 0x18C4, 0x52ED, 0x7C94, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x4ACC, 0x8D56, 0x6BD1, // 0x0900 (2304) pixels +0x63B1, 0x6BF1, 0x3A29, 0x10A3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0910 (2320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2105, 0x5B4F, 0x9DD8, 0x8D76, 0x0000, // 0x0920 (2336) pixels +0x0000, 0x3A29, 0x8D56, 0x7412, 0x6390, 0x84F4, 0x6C31, 0x5B6E, 0x5B8E, 0x5B8E, 0x5B8E, 0x5B8F, 0x63AF, 0x428B, 0x530E, 0x9DF9, // 0x0930 (2352) pixels +0x95B7, 0x5B8E, 0x63CF, 0x29C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0940 (2368) pixels +0x0000, 0x0000, 0x0821, 0x31C8, 0x6BD1, 0xA65A, 0x7472, 0x0000, 0x0000, 0x18E4, 0x52EE, 0x8D57, 0x9DD8, 0x0000, 0x0000, 0x0000, // 0x0950 (2384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x4AAC, 0x7CB4, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, // 0x0960 (2400) pixels +0x0000, 0x0000, 0x0000, 0x10A3, 0x4A8C, 0x6BF2, 0xA65A, 0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x426B, // 0x0970 (2416) pixels +0x6C12, 0xA63A, 0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x5B4F, // 0x0980 (2432) pixels +0x9557, 0x9DF8, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2105, 0x31C9, 0x424B, 0x4AAD, 0x52CD, 0x4ACD, 0x428C, 0x428B, // 0x0990 (2448) pixels +0x426B, 0x31E8, 0x0861, 0x532D, 0x7433, 0x8D36, 0x84D4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x3A09, 0x6370, 0xA619, 0x8D76, // 0x09A0 (2464) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A09, 0x530E, 0x6BF2, 0xA65A, 0x5B6E, 0x0000, 0x0000, // 0x09B0 (2480) pixels +0x0000, 0x18C4, 0x52CD, 0x7C74, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x2166, 0x6BF1, 0x5B50, 0x7C74, 0x7CB3, 0x2166, 0x0000, // 0x09C0 (2496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09D0 (2512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10C4, 0x530E, 0x84F5, 0xA639, 0x0020, 0x0000, 0x31E9, 0x6BF2, // 0x09E0 (2528) pixels +0x6390, 0x6BF2, 0x84B5, 0x8D16, 0x8D37, 0x8D57, 0x8D57, 0x9557, 0x9557, 0x9578, 0x84B4, 0x63B1, 0x7412, 0x8D16, 0x9557, 0xBEFD, // 0x09F0 (2544) pixels +0x6C31, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, // 0x0A00 (2560) pixels +0x31E9, 0x6BD1, 0xAE5B, 0x7472, 0x0000, 0x0000, 0x0842, 0x3A2A, 0x6391, 0xAE9B, 0x63AF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A10 (2576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x4AAC, 0x7CB4, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x0A20 (2592) pixels +0x2967, 0x5B4F, 0x84D5, 0xA65A, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x4AAD, 0x7C74, 0xB6DC, 0x0862, // 0x0A30 (2608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x4ACD, 0x7CB4, 0xAE9B, 0x10A3, // 0x0A40 (2624) pixels +0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0841, 0x0862, 0x0841, 0x0021, 0x0020, 0x0000, 0x0000, 0x2986, // 0x0A50 (2640) pixels +0x84F5, 0x6BD1, 0x9DB8, 0x426A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2105, 0x4ACD, 0x6BD1, 0xB6DC, 0x7CB3, 0x0041, 0x0000, // 0x0A60 (2656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x534D, 0x7432, 0x63B1, 0x7C94, 0x9576, 0x0882, 0x0000, 0x0000, 0x0000, 0x18C4, 0x4ACD, // 0x0A70 (2672) pixels +0x7C53, 0xAE9B, 0x10C3, 0x0000, 0x0000, 0x0000, 0x3A09, 0x5B2F, 0x7C74, 0x9DF8, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A80 (2688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A29, 0x8515, 0x3A49, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A90 (2704) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x31A8, 0x6370, 0x9598, 0x95B7, 0x0000, 0x0000, 0x18E4, 0x31C9, 0x39E9, 0x31E9, 0x31C8, // 0x0AA0 (2720) pixels +0x31C8, 0x31C8, 0x31C8, 0x31C9, 0x31C9, 0x31C9, 0x31C9, 0x3A09, 0x6390, 0x7453, 0x426B, 0x29A8, 0x530D, 0x4AEC, 0x0000, 0x0882, // 0x0AB0 (2736) pixels +0x428A, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x31C8, 0x52EE, 0x7412, 0xB6BC, // 0x0AC0 (2752) pixels +0x3A69, 0x0000, 0x0000, 0x0000, 0x18E5, 0x4AAD, 0x7412, 0xB6DC, 0x5B4D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AD0 (2768) pixels +0x0000, 0x0841, 0x2967, 0x6390, 0x8D57, 0x9597, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x3A2A, 0x6391, 0xAE5B, // 0x0AE0 (2784) pixels +0x7472, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x4A8C, 0x6BD2, 0xBEFD, 0x4ACB, 0x0000, 0x0000, 0x0000, // 0x0AF0 (2800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x29A8, 0x530E, 0x84D5, 0xAE9B, 0x0862, 0x0000, 0x0000, 0x3A29, // 0x0B00 (2816) pixels +0x42AB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3208, 0x8D56, 0x7432, 0x7453, 0x7C93, // 0x0B10 (2832) pixels +0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x2967, 0x52EE, 0x6BD1, 0xAE5B, 0x9E19, 0x5B8E, 0x3208, 0x29A6, 0x3208, // 0x0B20 (2848) pixels +0x63AF, 0x9DD8, 0x8D57, 0x6BD1, 0x6BF2, 0x84F5, 0x31C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x4AAD, 0x7453, 0xAE9B, 0x10C3, // 0x0B30 (2864) pixels +0x0000, 0x0000, 0x0862, 0x31C9, 0x5B2F, 0xA61A, 0x9E18, 0x530C, 0x534D, 0x534D, 0x534D, 0x534D, 0x532D, 0x532D, 0x532D, 0x532D, // 0x0B40 (2880) pixels +0x532D, 0x534D, 0x428A, 0x0000, 0x0000, 0x18C4, 0x7C94, 0xA63A, 0x9DF8, 0x7C93, 0x534D, 0x3A49, 0x29C7, 0x29C7, 0x3A69, 0x532D, // 0x0B50 (2896) pixels +0x5B8F, 0x5B4E, 0x5B70, 0x6BF2, 0xA63A, 0x42AA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B60 (2912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x530E, 0xA61A, 0x63AF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x7432, 0x95B8, 0x6C10, // 0x0B70 (2928) pixels +0x3A69, 0x1904, 0x0041, 0x0000, 0x0000, 0x0861, 0x2145, 0x428B, 0x5B6F, 0x5B6F, 0x6BD1, 0x9557, 0x7C93, 0x0000, 0x0000, 0x0000, // 0x0B80 (2944) pixels +0x0000, 0x0021, 0x2146, 0x52CD, 0x6BF2, 0xAE7B, 0x8D56, 0x426A, 0x10C3, 0x0020, 0x0020, 0x0882, 0x2145, 0x3A49, 0x426B, 0x5B4F, // 0x0B90 (2960) pixels +0x7412, 0x8D56, 0x31E8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E5, 0x4ACD, 0x6BF2, 0xBF1D, 0x3A49, 0x0000, 0x0000, // 0x0BA0 (2976) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x29A8, 0x5B0F, 0x7C94, 0xB6BC, 0x63CF, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BB0 (2992) pixels +0x0000, 0x0000, 0x10A2, 0x3A29, 0x638F, 0x5B6F, 0x63B1, 0xAE7B, 0x7472, 0x0000, 0x0000, 0x0000, 0x2126, 0x8D36, 0x8D35, 0x5B4D, // 0x0BC0 (3008) pixels +0x2986, 0x0882, 0x0020, 0x0000, 0x0020, 0x10C3, 0x3A29, 0x7C93, 0x9DD8, 0x7453, 0x6BD1, 0x7473, 0x1925, 0x0000, 0x0000, 0x0000, // 0x0BD0 (3024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x2967, 0x4A8C, 0x5B4F, 0x7C94, 0x9DD9, 0xA63A, 0xA63A, 0xA63A, 0x9DF9, 0x7CB5, 0x6390, // 0x0BE0 (3040) pixels +0x6390, 0x63D0, 0x31C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C4, 0x4ACD, 0x7C74, 0xB6BC, 0x10C3, 0x0000, 0x0000, 0x1082, // 0x0BF0 (3056) pixels +0x3A0A, 0x6370, 0x7C94, 0x9577, 0x9DD9, 0x9DD9, 0x9DD9, 0x9DD9, 0x9DD9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0xAE7B, 0xAE7A, // 0x0C00 (3072) pixels +0x0020, 0x0000, 0x10C4, 0x424B, 0x530F, 0x7413, 0x8D16, 0x9DD9, 0xA61A, 0xA63A, 0xA63A, 0xA63A, 0x9578, 0x7453, 0x6BD1, 0x63B1, // 0x0C10 (3088) pixels +0x7C73, 0x530C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C20 (3104) pixels +0x0000, 0x1905, 0x5B2F, 0xA61A, 0x63F0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x31E9, 0x6370, 0x84B5, 0x9598, 0x9DD8, 0x9577, // 0x0C30 (3120) pixels +0x8D35, 0x8D56, 0x95B7, 0x9577, 0x7C94, 0x6BD1, 0x6BD1, 0x7C94, 0x63D0, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x0C40 (3136) pixels +0x2105, 0x426B, 0x5B4F, 0x8CF6, 0xA63A, 0x9E19, 0x9597, 0x9577, 0x95B8, 0x8D36, 0x7433, 0x6BD1, 0x6390, 0x638F, 0x31E8, 0x0000, // 0x0C50 (3152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2947, 0x5B2F, 0x84B5, 0xB6FC, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C60 (3168) pixels +0x0000, 0x0000, 0x0000, 0x0882, 0x31A8, 0x52CD, 0x6BF2, 0x9DB8, 0x9DD9, 0x8D35, 0x7472, 0x6C11, 0x6BF0, 0x7452, 0x84F4, 0x9DD8, // 0x0C70 (3184) pixels +0x9577, 0x7412, 0x6BF2, 0x8D36, 0x7CB3, 0x0861, 0x0000, 0x0000, 0x0000, 0x18E4, 0x424B, 0x6BD2, 0x8D37, 0x9DB8, 0x9597, 0x8D56, // 0x0C80 (3200) pixels +0x8D36, 0x9597, 0x9E19, 0xA63A, 0x8D36, 0x6BD1, 0x6390, 0x5B6E, 0x1925, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C90 (3216) pixels +0x0000, 0x0000, 0x0041, 0x18C4, 0x31A8, 0x424B, 0x4AAD, 0x530E, 0x5B2F, 0x5B0E, 0x52CD, 0x4A8C, 0x426B, 0x3A09, 0x10C3, 0x0000, // 0x0CA0 (3232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x3A0A, 0x52CD, 0xA619, 0x1904, 0x0000, 0x0000, 0x10A3, 0x39E9, 0x52EE, 0x4A8C, // 0x0CB0 (3248) pixels +0x4A8C, 0x4A8C, 0x4A8C, 0x4A8C, 0x4A8D, 0x4AAD, 0x4AAD, 0x4AAD, 0x4AAD, 0x4ACD, 0x4AAD, 0x5B4F, 0x95B7, 0x0841, 0x0000, 0x0020, // 0x0CC0 (3264) pixels +0x1082, 0x2146, 0x31E9, 0x424B, 0x4AAD, 0x52EE, 0x5B2F, 0x5B2F, 0x530E, 0x52CD, 0x428C, 0x3A2A, 0x3A2A, 0x2145, 0x0000, 0x0000, // 0x0CD0 (3280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2105, 0x4A8C, // 0x0CE0 (3296) pixels +0x9577, 0x6C10, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x18E5, 0x31A8, 0x424B, 0x52EE, 0x6391, 0x6BF2, 0x6BF2, 0x63B1, // 0x0CF0 (3312) pixels +0x5B2F, 0x530E, 0x532E, 0x52ED, 0x29C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x2967, // 0x0D00 (3328) pixels +0x422B, 0x52CE, 0x6390, 0x6BF2, 0x6BF2, 0x63B1, 0x5B2F, 0x4ACD, 0x39E9, 0x2146, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D10 (3344) pixels +0x0000, 0x0000, 0x0862, 0x2987, 0x4A8C, 0x7453, 0xAE7A, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D20 (3360) pixels +0x0000, 0x0021, 0x18E4, 0x31C8, 0x424B, 0x530E, 0x6BD1, 0x7433, 0x7C74, 0x7C94, 0x7C74, 0x7412, 0x6370, 0x530E, 0x5B4F, 0x5B6F, // 0x0D30 (3376) pixels +0x3A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x1082, 0x2146, 0x3A0A, 0x4AAD, 0x5B2F, 0x6BB1, 0x6BF2, 0x6BF2, 0x6390, // 0x0D40 (3392) pixels +0x530E, 0x4A8C, 0x424B, 0x29A7, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D50 (3408) pixels +0x0000, 0x0021, 0x0862, 0x18C4, 0x1905, 0x2125, 0x1905, 0x10C4, 0x0882, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D60 (3424) pixels +0x0000, 0x0000, 0x1083, 0x10A3, 0x0862, 0x2987, 0x0882, 0x0000, 0x0000, 0x0862, 0x10C4, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, // 0x0D70 (3440) pixels +0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x10A3, 0x29A7, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, // 0x0D80 (3456) pixels +0x0882, 0x10C4, 0x1905, 0x2125, 0x2125, 0x1905, 0x10C4, 0x0862, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D90 (3472) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x10A3, 0x2125, 0x2986, 0x0000, // 0x0DA0 (3488) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x10A3, 0x1905, 0x2126, 0x2146, 0x2105, 0x18E4, 0x18E4, 0x10A2, // 0x0DB0 (3504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x10A3, 0x1905, // 0x0DC0 (3520) pixels +0x2126, 0x2146, 0x2125, 0x18C4, 0x0862, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, // 0x0DD0 (3536) pixels +0x10C4, 0x1083, 0x10C3, 0x3A09, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DE0 (3552) pixels +0x0000, 0x0841, 0x10A3, 0x18E5, 0x2126, 0x2146, 0x2146, 0x2126, 0x1905, 0x10C4, 0x10C3, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DF0 (3568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x1082, 0x18C4, 0x2105, 0x2146, 0x2146, 0x2105, 0x10C4, 0x0862, 0x0020, // 0x0E00 (3584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E10 (3600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E20 (3616) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E30 (3632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E40 (3648) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E50 (3664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E60 (3680) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E70 (3696) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E80 (3712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E90 (3728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EA0 (3744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EB0 (3760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EC0 (3776) pixels +0x0000, 0x0000, 0x0000, 0x0000 +}; + +Font_numbers nesto[2] = { + { + 189, 20, + 1, 21, 30, 49, 68, 88, 107, 128, 145, 167, 188, + nesto_numbers_20px, + }, + { + 396, 44, + 1, 45, 62, 102, 142, 185, 226, 268, 306, 351, 394, + nesto_numbers_44px, + } + }; + +// Generated by : ImageConverter 565 Online +// Generated from : gameover.png +// Time generated : Thu, 24 Oct 24 15:52:59 +0200 (Server timezone: CET) +// Image Size : 88x70 pixels +// Memory usage : 12320 bytes +#define GAMEOVER_W 88 +#define GAMEOVER_H 70 + +const uint16_t gameover[6160] = { +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0010 (16) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0020 (32) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0030 (48) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0040 (64) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0050 (80) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0060 (96) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0070 (112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0080 (128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0090 (144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00A0 (160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00B0 (176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x29A6, 0xA639, 0xB6FD, 0xB6FD, 0xB6DC, 0xB6BB, 0xB6DC, 0xB6FD, 0xB6FD, 0xB6FD, // 0x00C0 (192) pixels +0xB6FD, 0x8D35, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7431, // 0x00D0 (208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x29A7, 0x0000, // 0x00E0 (224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7431, // 0x00F0 (240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A4A, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, // 0x0100 (256) pixels +0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0xB6FD, 0xAE9B, 0x7C93, // 0x0110 (272) pixels +0x7C73, 0x7C73, 0x7C94, 0x7C94, 0x7C94, 0x7CB4, 0x7CB4, 0x7CB4, 0x84B4, 0x84F5, 0xB6DC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0120 (288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7452, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0130 (304) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0140 (320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7453, 0x7453, // 0x0150 (336) pixels +0x7473, 0x7C73, 0x7C73, 0x7C73, 0x7C94, 0x7C94, 0x7C94, 0x7CB4, 0x7CB4, 0x7CB4, 0x84B4, 0x84D4, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x0160 (352) pixels +0x0000, 0x0000, 0x0000, 0x3A29, 0x95B7, 0x7473, 0x7453, 0x63B0, 0x2967, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, // 0x0170 (368) pixels +0x31C8, 0x532E, 0xB6BC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x39E9, 0x7C73, // 0x0180 (384) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7432, 0xB6FD, // 0x0190 (400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B0, 0xB6FD, // 0x01A0 (416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7433, 0x8D16, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, // 0x01B0 (432) pixels +0x2126, 0x2126, 0x2126, 0x2126, 0x3A4A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x6C31, 0x7432, 0x7432, 0x5B4E, 0x31E9, // 0x01C0 (448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01D0 (464) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7453, 0x7453, 0x8515, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01E0 (480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6C12, 0x84F5, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x01F0 (496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x4AAC, 0x7C94, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7432, 0x8D16, // 0x0200 (512) pixels +0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0210 (528) pixels +0x0000, 0x0000, 0x428B, 0x6BF1, 0x7412, 0x8D56, 0x31C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0220 (544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x4AAC, 0x7432, 0x3209, // 0x0230 (560) pixels +0x7453, 0xA65A, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BF2, 0x6BF2, // 0x0240 (576) pixels +0x9577, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x39E9, 0x7C73, 0x7C73, 0xB6DC, // 0x0250 (592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7412, 0x8515, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0260 (608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x29A8, 0x6BF2, 0xA619, 0x6C10, 0x0000, 0x0000, // 0x0270 (624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0280 (640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7412, 0x8D36, 0x31C8, 0x5B6F, 0x7432, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0290 (656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x31C8, 0x6BF2, 0xAE7B, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02A0 (672) pixels +0x0000, 0x0000, 0x0000, 0x2126, 0x7453, 0x9577, 0x7473, 0xAE7B, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6C12, 0x84F5, // 0x02B0 (688) pixels +0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02C0 (704) pixels +0x0000, 0x18E4, 0x426B, 0x6BF1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x02D0 (720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BF2, 0x6C12, 0x9576, 0x0000, // 0x02E0 (736) pixels +0x2126, 0x7432, 0x84F5, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0xB6FD, // 0x02F0 (752) pixels +0x426B, 0x6BF1, 0xAE9B, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7412, 0x84F5, 0x3A4A, 0x7453, 0x9DF9, // 0x0300 (768) pixels +0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BF2, 0x84F5, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0310 (784) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2105, 0x52ED, 0x6BD1, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x0320 (800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0330 (816) pixels +0x0000, 0x0000, 0x1083, 0x428B, 0x6BF1, 0xB6FC, 0x1904, 0x0000, 0x0841, 0x31E9, 0x7412, 0xB6FD, 0x29A7, 0x0000, 0x0000, 0x0000, // 0x0340 (832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2967, 0x63B1, 0xB6FD, 0x2126, 0x52ED, 0x6BD1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0350 (848) pixels +0x0000, 0x2126, 0x5B6F, 0x7C73, 0xB6FD, 0x2126, 0x7433, 0x9577, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x7C94, // 0x0360 (864) pixels +0x9DD8, 0x9DD8, 0x9DD8, 0x9DD9, 0x9DD9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0370 (880) pixels +0x0000, 0x2126, 0x530E, 0x6BB1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ED, 0x7412, 0x7412, 0x7432, // 0x0380 (896) pixels +0x7432, 0x7432, 0x7433, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x9577, 0x7472, 0x0000, 0x0000, // 0x0390 (912) pixels +0x0000, 0x2126, 0x6C12, 0x6C12, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x31E9, 0x6390, 0xB6FD, // 0x03A0 (928) pixels +0x0000, 0x2126, 0x5B4F, 0x7453, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x2126, 0x4ACD, 0x6C12, 0xB6FC, 0x0000, 0x2126, 0x7412, 0x84F5, // 0x03B0 (944) pixels +0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x6BB1, 0x6390, 0x6390, 0x6390, 0x6390, 0x6390, 0x63B0, 0x63B0, 0x63B0, // 0x03C0 (960) pixels +0x63B1, 0x6BD1, 0x6BF1, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x428C, 0x63B1, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x03D0 (976) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x18E4, 0x18E4, 0x18E4, 0x18E4, 0x2126, 0x7432, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x03E0 (992) pixels +0x0000, 0x2126, 0x426B, 0x63B1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BF2, 0xA63A, 0x5B6E, 0x0000, 0x0000, // 0x03F0 (1008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x424A, 0x6390, 0xB6FD, 0x0000, 0x0000, 0x2126, 0x63B1, 0x84D5, 0xB6FD, 0x0000, 0x1083, // 0x0400 (1024) pixels +0x3A4A, 0x6BF1, 0xAE5A, 0x29A7, 0x0000, 0x18E4, 0x6370, 0x7453, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B1, 0x84B5, // 0x0410 (1040) pixels +0x7431, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0420 (1056) pixels +0x0000, 0x0841, 0x2146, 0x6390, 0xAE5A, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0430 (1072) pixels +0x0000, 0x2126, 0x7412, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6390, 0xB6FD, 0x428A, 0x0000, 0x0000, 0x0000, // 0x0440 (1088) pixels +0x0000, 0x0000, 0x18E4, 0x428C, 0x6BF2, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x4A8C, 0x6370, 0xB6FD, // 0x0450 (1104) pixels +0x0000, 0x0000, 0x0841, 0x2967, 0x63B1, 0x9577, 0x7431, 0x31A8, 0x6BD1, 0x9DB8, 0x5B6E, 0x0000, 0x0000, 0x18E4, 0x52ED, 0x6C12, // 0x0460 (1120) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6390, 0x7CB4, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0470 (1136) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B2F, 0x6390, 0xB6FD, 0x0000, 0x0000, // 0x0480 (1152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6C12, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0490 (1168) pixels +0x2126, 0x6390, 0x6390, 0xA619, 0xA61A, 0xA61A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0xA63A, 0x6BD1, 0x7CB4, 0xB6FD, 0x0000, // 0x04A0 (1184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x530E, 0x6BD1, 0x8D35, 0x0000, 0x0000, 0x0000, 0x1083, 0x29A8, 0x6390, 0x6C11, 0x63B1, // 0x04B0 (1200) pixels +0x84D5, 0x8D35, 0x0000, 0x0000, 0x0000, 0x1083, 0x426B, 0x6BF2, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6390, 0x7CB4, // 0x04C0 (1216) pixels +0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x04D0 (1232) pixels +0x0000, 0x0000, 0x1083, 0x2126, 0x6370, 0x6BD1, 0xB6FD, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x04E0 (1248) pixels +0x2125, 0x2125, 0x6BF1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x1083, 0x424B, 0x6370, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, // 0x04F0 (1264) pixels +0x63B1, 0x63B1, 0x63B1, 0x6BB1, 0x6BD1, 0x6BD1, 0xB6FD, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B4F, 0x7C94, 0x5B6E, // 0x0500 (1280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x424B, 0x6390, 0x7C73, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x31E9, 0x6BD1, // 0x0510 (1296) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6370, 0x7C94, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0520 (1312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2146, 0x6370, 0x6370, 0x95B8, // 0x0530 (1328) pixels +0xB6FD, 0xB6FD, 0x5B6E, 0x5BAF, 0x532D, 0x6C31, 0x9DB8, 0x8D35, 0x6C11, 0x6BD1, 0x6BD1, 0xB6DC, 0x0000, 0x0000, 0x0000, 0x2126, // 0x0540 (1344) pixels +0x5B4F, 0x8D36, 0x5B6E, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x0841, 0x2126, 0x530E, 0x6BD1, 0xB6FD, // 0x0550 (1360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B2F, 0x8D36, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x530E, 0xB6FD, // 0x0560 (1376) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2146, 0x6BD1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B70, 0x7C94, // 0x0570 (1392) pixels +0xB6FD, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x0000, 0x0000, 0x0000, // 0x0580 (1408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x426B, 0x5B70, 0x6370, 0x6370, 0x6BF2, 0x7C53, 0x7C73, 0x7432, 0x6390, 0x63B1, // 0x0590 (1424) pixels +0x63B1, 0x7473, 0x8D76, 0x0882, 0x0000, 0x0000, 0x2126, 0x4AAD, 0x5B2F, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x05A0 (1440) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B1, 0x8D57, 0x8D35, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B0F, 0x9DD9, 0x29A7, // 0x05B0 (1456) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2146, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B1, // 0x05C0 (1472) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B4F, 0x5B50, 0x5B50, 0x5B70, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, // 0x05D0 (1488) pixels +0x6390, 0x63B1, 0x63B1, 0x63B1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, // 0x05E0 (1504) pixels +0x2126, 0x3A0A, 0x4A8C, 0x52ED, 0x4ACD, 0x52ED, 0x52ED, 0x5B4E, 0x638F, 0x2166, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x2126, // 0x05F0 (1520) pixels +0x3A4A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x2126, // 0x0600 (1536) pixels +0x3A4A, 0x0000, 0x0000, 0x0000, 0x2126, 0x2126, 0x3A4A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0610 (1552) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x2126, 0x3A4A, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x39E9, 0x39E9, // 0x0620 (1568) pixels +0x39E9, 0x39E9, 0x3A09, 0x3A09, 0x3A09, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x0630 (1584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0841, 0x10A3, 0x0862, 0x1082, 0x0020, 0x0000, // 0x0640 (1600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0650 (1616) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0660 (1632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0670 (1648) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0680 (1664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0690 (1680) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06A0 (1696) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06B0 (1712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06C0 (1728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06D0 (1744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06E0 (1760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x06F0 (1776) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0700 (1792) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0710 (1808) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0720 (1824) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0730 (1840) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0740 (1856) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0750 (1872) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0760 (1888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0770 (1904) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0780 (1920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0790 (1936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07A0 (1952) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07B0 (1968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07C0 (1984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07D0 (2000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07E0 (2016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x07F0 (2032) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0800 (2048) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0810 (2064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0820 (2080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0830 (2096) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0840 (2112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0850 (2128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0860 (2144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0870 (2160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0880 (2176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0890 (2192) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08A0 (2208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08B0 (2224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08C0 (2240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08D0 (2256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08E0 (2272) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x08F0 (2288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0900 (2304) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0910 (2320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0920 (2336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0930 (2352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0940 (2368) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0950 (2384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0960 (2400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0970 (2416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0980 (2432) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0990 (2448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09A0 (2464) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09B0 (2480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09C0 (2496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09D0 (2512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09E0 (2528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x09F0 (2544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A00 (2560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A10 (2576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A20 (2592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A30 (2608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A40 (2624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A50 (2640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A60 (2656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A70 (2672) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A80 (2688) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0A90 (2704) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AA0 (2720) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AB0 (2736) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AC0 (2752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AD0 (2768) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AE0 (2784) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0AF0 (2800) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B00 (2816) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B10 (2832) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B20 (2848) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B30 (2864) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B40 (2880) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B50 (2896) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B60 (2912) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B70 (2928) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B80 (2944) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0B90 (2960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BA0 (2976) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BB0 (2992) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BC0 (3008) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BD0 (3024) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BE0 (3040) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0BF0 (3056) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C00 (3072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C10 (3088) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C20 (3104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C30 (3120) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C40 (3136) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C50 (3152) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C60 (3168) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C70 (3184) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C80 (3200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0C90 (3216) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CA0 (3232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CB0 (3248) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CC0 (3264) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CD0 (3280) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CE0 (3296) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0CF0 (3312) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D00 (3328) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D10 (3344) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D20 (3360) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D30 (3376) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D40 (3392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D50 (3408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D60 (3424) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D70 (3440) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D80 (3456) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0D90 (3472) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DA0 (3488) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DB0 (3504) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DC0 (3520) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DD0 (3536) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DE0 (3552) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0DF0 (3568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E00 (3584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E10 (3600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E20 (3616) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E30 (3632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E40 (3648) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E50 (3664) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E60 (3680) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E70 (3696) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E80 (3712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0E90 (3728) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EA0 (3744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EB0 (3760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EC0 (3776) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0ED0 (3792) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EE0 (3808) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0EF0 (3824) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F00 (3840) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F10 (3856) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F20 (3872) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F30 (3888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F40 (3904) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F50 (3920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F60 (3936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F70 (3952) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F80 (3968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0F90 (3984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FA0 (4000) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FB0 (4016) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FC0 (4032) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FD0 (4048) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FE0 (4064) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x0FF0 (4080) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1000 (4096) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1010 (4112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1020 (4128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1030 (4144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1040 (4160) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1050 (4176) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1060 (4192) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1070 (4208) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1080 (4224) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1090 (4240) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10A0 (4256) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10B0 (4272) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10C0 (4288) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10D0 (4304) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10E0 (4320) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10F0 (4336) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1100 (4352) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1110 (4368) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1120 (4384) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1130 (4400) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1140 (4416) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1150 (4432) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1160 (4448) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1170 (4464) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1180 (4480) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1190 (4496) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11A0 (4512) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11B0 (4528) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11C0 (4544) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11D0 (4560) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11E0 (4576) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x11F0 (4592) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1200 (4608) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1210 (4624) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1220 (4640) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1230 (4656) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1240 (4672) pixels +0x0882, 0x9597, 0xB6FD, 0xB6FD, 0xB6FD, 0xAE5A, 0xB6FD, 0xB6FD, 0xB6FD, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, // 0x1250 (4688) pixels +0xB6FD, 0xB6FD, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0xB6FD, // 0x1260 (4704) pixels +0xB6FD, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x3A4A, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, // 0x1270 (4720) pixels +0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x3A4A, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, // 0x1280 (4736) pixels +0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1290 (4752) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x84F5, 0x8D56, 0x7473, 0x7C73, 0x7C73, 0x7C73, 0x7C94, 0x7C94, 0x7C94, // 0x12A0 (4768) pixels +0x7CB4, 0x9DD8, 0xB6FD, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6C12, 0x84D5, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x12B0 (4784) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7C73, 0x9577, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x2126, 0x7453, 0x7453, // 0x12C0 (4800) pixels +0x7473, 0x7C73, 0x7C73, 0x7C73, 0x7C94, 0x7C94, 0x7C94, 0x7CB4, 0x7CB4, 0x7CB4, 0x84B4, 0x84D4, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x12D0 (4816) pixels +0x2126, 0x7433, 0x7453, 0x7453, 0x7453, 0x7473, 0x7C73, 0x7C73, 0x7C73, 0x7C93, 0x7C94, 0x7C94, 0x7CB4, 0x7CB4, 0x9DD8, 0xB6FD, // 0x12E0 (4832) pixels +0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x6C11, 0x7453, // 0x12F0 (4848) pixels +0x7453, 0x63D1, 0x2146, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x4ACD, 0x7C94, 0x7C94, 0x9DD8, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x1300 (4864) pixels +0x0841, 0x29A7, 0x7432, 0xA65A, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x428B, 0x7CB4, // 0x1310 (4880) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7433, 0x7C94, 0x2146, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, // 0x1320 (4896) pixels +0x2126, 0x2126, 0x2126, 0x2126, 0x3A4A, 0x0000, 0x0000, 0x0000, 0x2126, 0x7432, 0x84F5, 0x2126, 0x2126, 0x2126, 0x2126, 0x2126, // 0x1330 (4912) pixels +0x2126, 0x2126, 0x2126, 0x2126, 0x2126, 0x4AED, 0x7C94, 0x7CB4, 0xB6FD, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1340 (4928) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ED, 0x7432, 0x7432, 0x63B0, 0x4ACC, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1350 (4944) pixels +0x1083, 0x2126, 0x4ACD, 0x7C94, 0xAE5A, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B2E, 0x7432, 0xB6FD, 0x0000, 0x0000, 0x0000, // 0x1360 (4960) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7C94, 0x9DB8, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7432, 0x7C94, // 0x1370 (4976) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1380 (4992) pixels +0x2126, 0x7412, 0x84D5, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x7C94, // 0x1390 (5008) pixels +0x7C94, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x29A8, 0x5B4E, 0x6C12, 0x8D36, // 0x13A0 (5024) pixels +0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B0, 0x7C93, 0xB6FD, 0x29A7, 0x0000, // 0x13B0 (5040) pixels +0x0000, 0x0000, 0x2126, 0x7412, 0x9DB8, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x530D, 0x7C73, 0xB6FD, // 0x13C0 (5056) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7412, 0x7C73, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13D0 (5072) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6C12, 0x84D5, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13E0 (5088) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x7C93, 0xAE5A, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x13F0 (5104) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2967, 0x6BF2, 0x8D57, 0x9DD8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1400 (5120) pixels +0x0000, 0x0000, 0x0841, 0x2126, 0x7C73, 0x8D16, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x18E4, 0x4A8C, 0x6C12, 0xB6FD, 0x0000, 0x0000, // 0x1410 (5136) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2146, 0x7453, 0xA619, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6C12, 0x7C73, // 0x1420 (5152) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1430 (5168) pixels +0x2126, 0x6BF2, 0x84B4, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, // 0x1440 (5184) pixels +0x7C73, 0x8515, 0x9597, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x31C9, 0x6BD1, 0xB6FD, 0x532D, // 0x1450 (5200) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x7453, 0x7473, 0xB6FD, 0x0000, // 0x1460 (5216) pixels +0x0000, 0x0000, 0x0000, 0x2126, 0x6BF2, 0x8D16, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x638F, 0x7CB4, 0xB6FD, 0x0000, // 0x1470 (5232) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BF2, 0x7453, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1480 (5248) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x7CB4, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1490 (5264) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A3, 0x2126, 0x7453, 0x8D56, 0x7431, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x14A0 (5280) pixels +0x0000, 0x0000, 0x0000, 0x18C4, 0x426B, 0x6BD1, 0xB6FD, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x14B0 (5296) pixels +0x0000, 0x0000, 0x0000, 0x2126, 0x638F, 0x7453, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x3A09, 0x6BF1, 0xB6BC, 0x0000, // 0x14C0 (5312) pixels +0x0000, 0x0000, 0x1083, 0x31C8, 0x7432, 0xAE9B, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x7412, // 0x14D0 (5328) pixels +0x9DD8, 0x9DD8, 0x9DD8, 0x9DD9, 0x9DD9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x9DF9, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, // 0x14E0 (5344) pixels +0x2126, 0x6BD1, 0x7C94, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x428A, 0x638F, 0x7433, // 0x14F0 (5360) pixels +0x7453, 0x8D56, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x426B, 0x63B1, 0xB6FD, 0x0000, // 0x1500 (5376) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x4AAC, 0x7432, 0xB6FD, 0x0000, // 0x1510 (5392) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B6F, 0x7C74, 0xB6FD, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x8516, 0xB6FD, 0x0000, 0x0000, // 0x1520 (5408) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x6BD1, 0x6370, 0x6390, 0x6390, 0x6390, 0x6390, 0x63B0, 0x63B0, 0x63B0, // 0x1530 (5424) pixels +0x63B1, 0x63D1, 0x6BD1, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B1, 0x7C94, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, 0xB6FD, // 0x1540 (5440) pixels +0xB6FD, 0xB6FD, 0xB6FD, 0x9E19, 0xA63A, 0x7CB4, 0x7432, 0x7432, 0x5B4E, 0x10C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1550 (5456) pixels +0x0000, 0x0000, 0x0000, 0x18E4, 0x31C8, 0x6390, 0xB6FD, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1560 (5472) pixels +0x0000, 0x0000, 0x0000, 0x2146, 0x5B6F, 0x7432, 0xB6BC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2967, 0x6BD1, 0xA63A, // 0x1570 (5488) pixels +0x29A7, 0x1083, 0x424B, 0x6BF2, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B1, 0x7412, // 0x1580 (5504) pixels +0xB6FD, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x1083, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1590 (5520) pixels +0x2126, 0x6390, 0x63B1, 0x63B1, 0x63B1, 0x6BB1, 0x6BD1, 0x6BD1, 0x6BD1, 0x6BF1, 0x6BF1, 0x6BF2, 0x6BF2, 0x5B4F, 0x2126, 0x2146, // 0x15A0 (5536) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x6390, 0xA61A, 0x8D35, // 0x15B0 (5552) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3A09, 0x6C12, 0x7C73, 0xA619, 0x0000, // 0x15C0 (5568) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x52CD, 0x6BD1, 0xB6FD, 0x2126, 0x6BD1, 0x9597, 0x5B6E, 0x0000, 0x0000, 0x0000, // 0x15D0 (5584) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6390, 0x6C12, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x15E0 (5600) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6390, 0x7C73, 0x3A4A, 0x18E4, 0x18E4, 0x18E4, 0x18E4, // 0x15F0 (5616) pixels +0x18E4, 0x2126, 0x428B, 0x6BD1, 0xB6DC, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1600 (5632) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x52ED, 0x6390, 0xB6FD, 0x29A7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1610 (5648) pixels +0x0000, 0x0000, 0x530D, 0x5B6F, 0x6BF2, 0x84F4, 0x4AEC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x63B1, // 0x1620 (5664) pixels +0x95B8, 0x52CD, 0x6BB1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6390, 0x6BF2, // 0x1630 (5680) pixels +0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1640 (5696) pixels +0x2126, 0x6370, 0x7453, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6BD1, 0x6BD1, 0xB6FD, 0x0000, 0x0000, // 0x1650 (5712) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2126, 0x6370, 0x6370, // 0x1660 (5728) pixels +0xB6FD, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x7CB4, 0x7473, 0x6BD1, 0x6BD1, 0x7432, 0x0000, 0x0000, // 0x1670 (5744) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x424B, 0x6390, 0x63B1, 0xAE7B, 0x5B6E, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1680 (5760) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x6370, 0x6BF2, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1690 (5776) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B70, 0x7453, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x16A0 (5792) pixels +0x0000, 0x0000, 0x0000, 0x2126, 0x6BB1, 0x6BD1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x16B0 (5808) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x5B50, 0x6370, 0x8D36, 0xB6FD, 0xB6FD, 0x5B6E, 0x42AB, 0x63CF, 0xB6BC, // 0x16C0 (5824) pixels +0xB6DC, 0x7453, 0x6BB1, 0x6370, 0x530D, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, // 0x16D0 (5840) pixels +0x6390, 0x7433, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B50, 0x6BD1, // 0x16E0 (5856) pixels +0xB6FD, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x8D35, 0x0000, 0x0000, 0x0000, // 0x16F0 (5872) pixels +0x2126, 0x5B4F, 0x7433, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x63B1, 0x7C94, 0xB6FD, // 0x1700 (5888) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, // 0x1710 (5904) pixels +0x424B, 0x5B50, 0x5B70, 0x6370, 0x7453, 0x7453, 0x6390, 0x6390, 0x6390, 0x6390, 0x3A09, 0x31E9, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1720 (5920) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x2987, 0xB6FC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1730 (5936) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B4F, 0x5B50, 0x5B50, 0x5B70, 0x6370, 0x6370, 0x6370, 0x6390, 0x6390, 0x6390, // 0x1740 (5952) pixels +0x6390, 0x63B1, 0x63B1, 0x63B1, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x2126, 0x5B2F, 0x7433, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1750 (5968) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x18E4, 0x31C8, 0x63B1, 0x7C94, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1760 (5984) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1083, 0x2126, 0x2126, 0x424B, 0x424B, 0x52CD, 0x424B, 0x31C8, // 0x1770 (6000) pixels +0x2126, 0x2126, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1780 (6016) pixels +0x2126, 0x8D35, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x39E9, 0x39E9, // 0x1790 (6032) pixels +0x39E9, 0x39E9, 0x3A09, 0x3A09, 0x3A09, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x3A0A, 0x7431, 0x0000, 0x0000, 0x0000, // 0x17A0 (6048) pixels +0x2126, 0x2126, 0x2126, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x2126, 0x2126, // 0x17B0 (6064) pixels +0x2126, 0xB6FD, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17C0 (6080) pixels +0x0000, 0x0000, 0x0000, 0x0841, 0x1083, 0x1083, 0x0862, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17D0 (6096) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17E0 (6112) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x17F0 (6128) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1800 (6144) pixels +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x1810 (6160) pixels +}; diff --git a/main/includes/structures.h b/main/includes/structures.h new file mode 100644 index 0000000..9038f9f --- /dev/null +++ b/main/includes/structures.h @@ -0,0 +1,161 @@ +#pragma once + +// World parameters and structures +#include +#include "geometry.h" +#include "globals.h" +#include + +struct Font_numbers // Describes a bitmapped font +{ + uint16_t width; //Dimensions + uint16_t height; + uint16_t locations[11]; // A list of start and end pixel columns + const uint16_t * buffer; // Pointer to the actual bitmap +}; + +struct TwoD_overlay // Describes a buffer to overlay on the 3D viewport +{ + uint16_t width = 0; // Dimensions of the buffer in use + uint16_t height = 0; + uint16_t * buffer; // Pointer to the memory area +}; + +struct Time_tracked // Various parameters that are tracked in time and displayed periodically +{ + uint16_t frames; // Frame since last call, used to indicate fps + uint16_t health; // Player's wellbeing + uint32_t triangles; // Primitives processed +}; + +struct Shade_params // Defines the amount of lambertian diffuse and specular relection from a surface +{ + uint32_t lamb; + uint32_t spec; +}; + +struct world_partition_header // Defines how the worlds are placed in the partition +{ + const Vec3f eye; // The observer + const Vec3f direction; + // These values are followed by descriptors and offsets + const uint32_t world_start; // Use this as a starting memory location +}; + +struct world_header // The header of a single world in the partition, constants mostly +{ + //Vec3f eye; + //Vec3f direction; + //const uint32_t world_descriptor; // This will be used to describe for animation etc + const uint32_t vertices; // Vec3f* + const uint32_t nvertices; // uint16_t* + const uint32_t vts; // Vec2f* + const uint32_t texels;// uint16_t* + const uint32_t attributes; // uint16_t* + const uint32_t thin_palette; // uint32_t* + const uint32_t chunks; // int16_t* + //const uint32_t next_world; // world_header* + //const uint32_t next_frame; // link to the next frame of an animated world +}; + +struct faceMaterials // To describe live palette as it's built in RAM +{ + uint32_t rgb888; // A shade for block colours and textures, but texture calculates its own and places it here + uint16_t width; // Not constant as they are set from partition + uint16_t height; + const uint32_t * image; // Pointer to a (constant) image array + uint32_t event; // A word to identify and describe events associated with this palette attribute +}; + +struct part_faceMaterials // To describe palette in the partition +{ + const uint32_t type; // What type of material is here so how next word will be used + const uint32_t parameter; // Offset start in the partition or rgb888 or ? in future + const uint32_t event_code;// An event word to be added here, for all cases or optional? +}; + +struct ChunkArr // Describes the layout of chunks in an a given layer +{ + int16_t xmin; + int16_t zmin; + int16_t xcount; + int16_t zcount; + int16_t size; // Of each tile +}; + +struct ChunkFaces +{ + uint16_t * faces_ptr; // Pointer to the array of faces for that chunk + uint32_t face_count; // The length of the array +}; + +// In theory this box can be integer but I've tried to work this through the algorithm and lost pixels each time +struct Rect2D +{ + float m_MinX; + float m_MinY; + float m_MaxX; + float m_MaxY; +}; + +struct WorldLayout +{ + // The constants of number of triangles etc aren't needed as they are fixed via chunks + // Pointers were constant but now they have to be updated to match partition mapping + // Animation has been moved out of here + Vec3f * vertices; // Pointer to an array of Vec3f vertices - these are all const ptrs to const values + uint16_t * nvertices; // Pointer to an array of indices to the vertex coordinates + uint16_t * texel_verts; // Pointer to an array of indices to texture UV coordinates + Vec2f * vts; // Pointer to an array of UV coordinates + faceMaterials * palette; // Pointer to an array of faceMaterials that's a palette + uint16_t * attributes; // Pointer to an array that selects from the palette per face + ChunkFaces * TheChunks; // Pointer to the array of lists of faces per chunk + ChunkArr ChAr; // The arrangement of chunks used in this layout +}; + +// A structure that stores the pointers to layouts and is set up as the world is parsed from partition +// It will be a ragged array when built as the included vector will vary in length depending on layouts/frames +struct EachLayout +{ + uint16_t frames; // The number of frames in this layout + //uint16_t current_frame; // Store which frame is to be used for display + std::vector frame_layouts; // A list of world layouts +}; + +struct Near_pix // To find and report on an impacted face at a pixel +{ + float depth; // z depth found on CheckCollide but also returns from SendImpactQueue + uint32_t x; // The pixel to be tested + uint32_t y; + const WorldLayout* layout; // The layout in which a found face is contained + uint32_t idx; // Face index + uint32_t event; // Event code detected +}; + +// A struct to define how a triangle is rasterised, it's big but no obvious reductions +// to be made as invM used to derive a fair few other parameters but maybe more efficient +// for those to be calculated outside rasteriser in future? +// Especially for tiles there is a degree of inefficiency of passing and re-calculating +// a range of parameters +struct TriToRaster +{ + const WorldLayout* layout; // A ptr to structure of the world so the queue can have multiple layouts queued for rasterising + // Can't pass the struct as the constants aren't defined when this struct is declared + // and doing it by pointer probably faster and more transparent anyway. + uint32_t idx; // Triangle index + Vec3f clip_zs; // just z value of the 3 clipped vertices passed in this Vec3f + Rect2D BoBox; // Bounding box + Matrix33f invM; // Matrix to solve edge equations etc + Vec3f C; // Constant function (derived from invM) paased to reduce Rasteriser load + Vec3f Z; // Z interpolation + Shade_params face_brightness; // Based on the face and half normals to determine shading + }; + +// A struct to keep track of the TriToRaster queues, at least two are needed, one per rasteriser +// and a duplicate of those is needed for multicore implementation, so 4 in total +struct TriQueue +{ + TriToRaster* itemptr; + uint32_t size; + uint32_t count; +}; diff --git a/main/includes/title.h b/main/includes/title.h new file mode 100644 index 0000000..5f21ee5 --- /dev/null +++ b/main/includes/title.h @@ -0,0 +1,1038 @@ +// Generated by : ImageConverter 565 Online +// http://www.rinkydinkelectronics.com/t_imageconverter565.php +// Generated from : amaze_2_title.png +// Time generated : Wed, 09 Oct 24 19:26:49 +0200 (Server timezone: CET) +// Image Size : 128x128 pixels +// Memory usage : 32768 bytes +#pragma once +#include + +#define TITLE_H 128 +#define TITLE_W 128 + +const uint16_t amaze_2_title[16384] = { +0x08C3, 0x08C3, 0x00A3, 0x0082, 0x0062, 0x0062, 0x00A3, 0x00C3, 0x1104, 0x00A3, 0x0082, 0x0062, 0x00A3, 0x0083, 0x1145, 0x0945, // 0x0010 (16) pixels +0x1186, 0x0966, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x00C3, 0x08E4, 0x08C3, 0x08C4, 0x08C3, 0x08C4, 0x08C4, 0x00A3, 0x0062, 0x0062, // 0x0020 (32) pixels +0x0063, 0x0063, 0x0063, 0x0063, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, // 0x0030 (48) pixels +0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, // 0x0040 (64) pixels +0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x00A3, 0x0083, 0x00A3, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, // 0x0050 (80) pixels +0x0082, 0x0062, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x0060 (96) pixels +0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x08C4, 0x08E4, 0x08C4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x11A6, 0x1166, // 0x0070 (112) pixels +0x1186, 0x0904, 0x0904, 0x0083, 0x0082, 0x0042, 0x00C3, 0x0904, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0062, 0x00A3, 0x08C3, 0x00C3, // 0x0080 (128) pixels +0x08C3, 0x08C3, 0x00A3, 0x0082, 0x0062, 0x0062, 0x00A3, 0x00C3, 0x1104, 0x00A3, 0x0082, 0x0062, 0x00A3, 0x00A3, 0x1145, 0x0945, // 0x0090 (144) pixels +0x1186, 0x1166, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x00A3, 0x08C4, 0x08C3, 0x08C3, 0x08C3, 0x08E4, 0x08C4, 0x0083, 0x0062, 0x0062, // 0x00A0 (160) pixels +0x0063, 0x0062, 0x0062, 0x0063, 0x0062, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, 0x00A3, 0x0083, 0x0083, 0x0083, 0x00A3, 0x00A3, // 0x00B0 (176) pixels +0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0883, 0x0883, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, // 0x00C0 (192) pixels +0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, // 0x00D0 (208) pixels +0x0083, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0083, 0x0083, 0x0083, 0x0062, 0x0083, 0x0082, 0x0062, 0x0082, 0x0062, 0x00A3, // 0x00E0 (224) pixels +0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x08C4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x19C7, 0x1186, // 0x00F0 (240) pixels +0x1987, 0x0904, 0x0904, 0x0083, 0x0082, 0x0042, 0x00C3, 0x0904, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0062, 0x00A3, 0x08C3, 0x00C3, // 0x0100 (256) pixels +0x08C3, 0x08C3, 0x00C3, 0x0082, 0x0062, 0x0062, 0x00A3, 0x08C3, 0x1104, 0x00A3, 0x0082, 0x0062, 0x0083, 0x00A3, 0x1145, 0x1145, // 0x0110 (272) pixels +0x19A7, 0x1186, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x00A3, 0x08C4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x08E4, 0x08E4, 0x08C4, 0x00A3, // 0x0120 (288) pixels +0x0062, 0x0083, 0x0063, 0x0063, 0x0062, 0x0062, 0x0062, 0x0082, 0x0062, 0x0082, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, // 0x0130 (304) pixels +0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, // 0x0140 (320) pixels +0x0083, 0x00A3, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, // 0x0150 (336) pixels +0x00A3, 0x00A3, 0x0083, 0x0083, 0x0083, 0x0082, 0x0082, 0x0082, 0x0082, 0x0062, 0x0062, 0x0082, 0x0062, 0x0062, 0x0062, 0x0904, // 0x0160 (352) pixels +0x0905, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x08C4, 0x08E4, 0x08E4, 0x0905, 0x0905, 0x08E4, 0x08E4, 0x19C7, 0x1186, // 0x0170 (368) pixels +0x1186, 0x08E4, 0x0905, 0x0083, 0x0062, 0x0042, 0x08C3, 0x0904, 0x08E4, 0x0082, 0x0082, 0x0062, 0x0062, 0x08A3, 0x08C4, 0x08C4, // 0x0180 (384) pixels +0x08E3, 0x08E3, 0x00A3, 0x0082, 0x0062, 0x0062, 0x00A3, 0x00C3, 0x1104, 0x00A3, 0x0082, 0x0062, 0x0083, 0x00A3, 0x1145, 0x0945, // 0x0190 (400) pixels +0x19C7, 0x1186, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x00A3, 0x08C3, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x1105, 0x1125, 0x1125, // 0x01A0 (416) pixels +0x00A3, 0x08C4, 0x08E4, 0x08E4, 0x08E4, 0x0082, 0x00A3, 0x08E4, 0x0904, 0x0904, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, // 0x01B0 (432) pixels +0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, // 0x01C0 (448) pixels +0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x08C4, 0x08C4, 0x08C4, 0x08C4, 0x08C4, 0x08C4, 0x08C4, // 0x01D0 (464) pixels +0x08C4, 0x08C4, 0x08C3, 0x08C3, 0x08A3, 0x08A3, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x00A3, 0x1125, 0x1125, 0x1986, // 0x01E0 (480) pixels +0x1125, 0x0904, 0x0904, 0x0904, 0x08E4, 0x08E5, 0x08C4, 0x08C4, 0x0905, 0x0905, 0x08E4, 0x08E5, 0x08E4, 0x08E4, 0x19C7, 0x11A6, // 0x01F0 (496) pixels +0x1186, 0x00E4, 0x0905, 0x0083, 0x0062, 0x0042, 0x08C3, 0x0904, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0062, 0x08C3, 0x08E4, 0x00E3, // 0x0200 (512) pixels +0x08C3, 0x08C3, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0082, 0x00C3, 0x1105, 0x00A3, 0x00A3, 0x0062, 0x00A3, 0x00A3, 0x1166, 0x1145, // 0x0210 (528) pixels +0x19C7, 0x1186, 0x0904, 0x0905, 0x08E4, 0x08E4, 0x00A3, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x00C4, 0x08E4, 0x1125, // 0x0220 (544) pixels +0x0062, 0x0062, 0x08C3, 0x08E4, 0x1946, 0x00C4, 0x00C4, 0x0905, 0x0904, 0x0904, 0x0904, 0x0904, 0x1125, 0x1125, 0x1125, 0x1125, // 0x0230 (560) pixels +0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1105, // 0x0240 (576) pixels +0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, // 0x0250 (592) pixels +0x1105, 0x1125, 0x1105, 0x1125, 0x1105, 0x1105, 0x08E4, 0x1125, 0x1925, 0x1105, 0x0063, 0x0062, 0x08C4, 0x1166, 0x1146, 0x00A3, // 0x0260 (608) pixels +0x00C4, 0x08E4, 0x08E4, 0x08E4, 0x0905, 0x0905, 0x08E4, 0x08C4, 0x0905, 0x0904, 0x0905, 0x0905, 0x08E5, 0x08E4, 0x19E7, 0x1186, // 0x0270 (624) pixels +0x11A7, 0x0105, 0x0905, 0x00A3, 0x0083, 0x0062, 0x08C4, 0x1125, 0x08E4, 0x0083, 0x0062, 0x0062, 0x0082, 0x08C3, 0x08E4, 0x00E4, // 0x0280 (640) pixels +0x08E4, 0x08E4, 0x08E3, 0x0082, 0x0062, 0x0062, 0x0082, 0x00C3, 0x0904, 0x00A3, 0x00A3, 0x0062, 0x00A3, 0x00A3, 0x1946, 0x1145, // 0x0290 (656) pixels +0x19C7, 0x11A7, 0x08E4, 0x0905, 0x08E4, 0x08E4, 0x08C3, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x0904, 0x0905, 0x1166, // 0x02A0 (672) pixels +0x0062, 0x0062, 0x08C4, 0x08E4, 0x1966, 0x0905, 0x08E4, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, // 0x02B0 (688) pixels +0x08C4, 0x08C4, 0x08C4, 0x08C4, 0x08C3, 0x08C3, 0x08C3, 0x08A3, 0x08A3, 0x08A3, 0x08C3, 0x08C3, 0x08A3, 0x00C3, 0x00C3, 0x08C3, // 0x02C0 (704) pixels +0x08C3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, 0x08C4, 0x08C3, 0x08C3, 0x08A3, 0x08A3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, // 0x02D0 (720) pixels +0x08C3, 0x08C3, 0x08C3, 0x08C3, 0x08A3, 0x1104, 0x08E4, 0x1966, 0x1146, 0x1105, 0x00A3, 0x0083, 0x08E4, 0x1166, 0x1166, 0x08E4, // 0x02E0 (736) pixels +0x0905, 0x0904, 0x08E4, 0x08E4, 0x0905, 0x0905, 0x08E4, 0x08C4, 0x0905, 0x0905, 0x0905, 0x0905, 0x08E4, 0x08E4, 0x19E7, 0x11A7, // 0x02F0 (752) pixels +0x11A7, 0x0105, 0x0905, 0x00A2, 0x0083, 0x0062, 0x08C4, 0x1125, 0x08E4, 0x0083, 0x0062, 0x0062, 0x0082, 0x08C4, 0x08E4, 0x00E4, // 0x0300 (768) pixels +0x08E4, 0x08E4, 0x08C3, 0x0082, 0x0082, 0x0062, 0x0082, 0x08C3, 0x1105, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x00A3, 0x1946, 0x1166, // 0x0310 (784) pixels +0x19C7, 0x11A7, 0x0904, 0x0905, 0x08E4, 0x0904, 0x00C3, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x0905, 0x1145, 0x1986, // 0x0320 (800) pixels +0x0062, 0x0062, 0x08C4, 0x08E4, 0x1125, 0x1105, 0x1125, 0x08E4, 0x08E4, 0x08E5, 0x08E4, 0x08E5, 0x08E4, 0x08E4, 0x08E4, 0x0904, // 0x0330 (816) pixels +0x08E4, 0x10E4, 0x10E4, 0x10E4, 0x08E5, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x10E5, 0x08E4, 0x0905, 0x0905, 0x0905, 0x0905, 0x08E4, // 0x0340 (832) pixels +0x08E4, 0x08E4, 0x08E4, 0x10E5, 0x10E4, 0x10E4, 0x10E4, 0x10E4, 0x10E4, 0x10E4, 0x10E4, 0x08E4, 0x10E4, 0x10E4, 0x10E4, 0x10E4, // 0x0350 (848) pixels +0x10E4, 0x10E4, 0x08E4, 0x08E4, 0x08E4, 0x1104, 0x0905, 0x1986, 0x08E4, 0x00C4, 0x0083, 0x0083, 0x0905, 0x19A7, 0x1186, 0x0904, // 0x0360 (864) pixels +0x0905, 0x0905, 0x0904, 0x0904, 0x0905, 0x0905, 0x08E4, 0x08E4, 0x1105, 0x1105, 0x1105, 0x1105, 0x1105, 0x08E4, 0x19C7, 0x11A7, // 0x0370 (880) pixels +0x11C7, 0x0905, 0x0905, 0x0082, 0x0083, 0x0042, 0x08C4, 0x1125, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0082, 0x08C4, 0x00E4, 0x00E4, // 0x0380 (896) pixels +0x08E3, 0x08E4, 0x08E3, 0x00A2, 0x0082, 0x0062, 0x0082, 0x08C3, 0x1105, 0x00A3, 0x00A3, 0x0062, 0x00A3, 0x00A3, 0x1166, 0x1166, // 0x0390 (912) pixels +0x19C7, 0x19A7, 0x08E4, 0x0905, 0x08E4, 0x0904, 0x08C3, 0x08E4, 0x0905, 0x0905, 0x08E4, 0x08E4, 0x0904, 0x0925, 0x1186, 0x19A7, // 0x03A0 (928) pixels +0x0082, 0x0083, 0x00A3, 0x08C3, 0x08E4, 0x0905, 0x1146, 0x0905, 0x1125, 0x1125, 0x1125, 0x1145, 0x1125, 0x0945, 0x1125, 0x1125, // 0x03B0 (944) pixels +0x1125, 0x1125, 0x1125, 0x1145, 0x1125, 0x1145, 0x1145, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x1146, 0x1146, 0x1146, 0x1145, // 0x03C0 (960) pixels +0x1125, 0x1125, 0x1145, 0x1146, 0x1145, 0x1145, 0x1145, 0x1145, 0x1125, 0x1125, 0x1125, 0x1125, 0x1145, 0x1125, 0x1125, 0x1125, // 0x03D0 (976) pixels +0x1125, 0x1125, 0x1125, 0x1125, 0x1105, 0x1125, 0x1166, 0x1125, 0x08E4, 0x00A3, 0x0083, 0x0083, 0x0905, 0x21E8, 0x19A7, 0x0925, // 0x03E0 (992) pixels +0x0905, 0x1105, 0x0905, 0x0905, 0x1105, 0x1105, 0x08E4, 0x08E4, 0x1105, 0x0905, 0x0905, 0x1105, 0x10E5, 0x08E4, 0x19C7, 0x11A7, // 0x03F0 (1008) pixels +0x11A7, 0x0925, 0x0904, 0x0082, 0x0083, 0x0062, 0x08C4, 0x1125, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0083, 0x08E4, 0x08E4, 0x00E4, // 0x0400 (1024) pixels +0x08E3, 0x08E4, 0x08E3, 0x00A3, 0x0082, 0x0062, 0x0082, 0x08A3, 0x1105, 0x00A3, 0x00A3, 0x0062, 0x08A3, 0x00C3, 0x1166, 0x1186, // 0x0410 (1040) pixels +0x19E7, 0x19C7, 0x08E5, 0x0905, 0x0905, 0x0905, 0x00C4, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0904, 0x0925, 0x1187, 0x19C8, // 0x0420 (1056) pixels +0x0083, 0x0083, 0x00C4, 0x08C4, 0x08C4, 0x0925, 0x1986, 0x0905, 0x1145, 0x1125, 0x1145, 0x1125, 0x1145, 0x1145, 0x1145, 0x1145, // 0x0430 (1072) pixels +0x1145, 0x1125, 0x1125, 0x1125, 0x0925, 0x0925, 0x1125, 0x1125, 0x0925, 0x0945, 0x1125, 0x1145, 0x1125, 0x1125, 0x1125, 0x1145, // 0x0440 (1088) pixels +0x1125, 0x1125, 0x1125, 0x1125, 0x1105, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, // 0x0450 (1104) pixels +0x1125, 0x1125, 0x1105, 0x1125, 0x0905, 0x1125, 0x1966, 0x0925, 0x08E4, 0x00C4, 0x0083, 0x0062, 0x0905, 0x2209, 0x19C7, 0x0925, // 0x0460 (1120) pixels +0x0905, 0x0925, 0x0905, 0x0905, 0x1105, 0x1105, 0x08E4, 0x08E4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1105, 0x0905, 0x19E8, 0x11A7, // 0x0470 (1136) pixels +0x11C7, 0x0925, 0x1124, 0x00A3, 0x00A2, 0x0062, 0x08C3, 0x0905, 0x00E4, 0x0082, 0x0062, 0x0062, 0x0082, 0x08E4, 0x08E4, 0x00C3, // 0x0480 (1152) pixels +0x08E3, 0x0904, 0x08E4, 0x00A3, 0x0082, 0x0062, 0x0082, 0x08C3, 0x1105, 0x00A3, 0x00A3, 0x0062, 0x08C3, 0x00C3, 0x1986, 0x11A6, // 0x0490 (1168) pixels +0x19E7, 0x11A7, 0x0904, 0x0925, 0x0905, 0x0905, 0x00C4, 0x1105, 0x0905, 0x0905, 0x0904, 0x0905, 0x0905, 0x0925, 0x19C7, 0x1A08, // 0x04A0 (1184) pixels +0x0083, 0x00A3, 0x00C4, 0x08C4, 0x08E4, 0x1166, 0x19A7, 0x0945, 0x0905, 0x0905, 0x0925, 0x0925, 0x0925, 0x0925, 0x0925, 0x0925, // 0x04B0 (1200) pixels +0x0925, 0x0905, 0x1125, 0x1145, 0x0925, 0x1145, 0x1145, 0x1145, 0x1145, 0x1145, 0x1125, 0x1125, 0x1145, 0x1145, 0x1145, 0x0925, // 0x04C0 (1216) pixels +0x1125, 0x0925, 0x0925, 0x1125, 0x1145, 0x1145, 0x1145, 0x1125, 0x1125, 0x1125, 0x1145, 0x1145, 0x1125, 0x1125, 0x0925, 0x0925, // 0x04D0 (1232) pixels +0x1125, 0x1125, 0x1105, 0x1105, 0x0904, 0x1145, 0x1166, 0x0925, 0x0904, 0x08E4, 0x00A3, 0x0062, 0x0925, 0x2229, 0x19E8, 0x0945, // 0x04E0 (1248) pixels +0x1125, 0x1125, 0x0925, 0x0905, 0x1105, 0x1125, 0x08E4, 0x08E4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1105, 0x0905, 0x1A08, 0x11C7, // 0x04F0 (1264) pixels +0x19C7, 0x0925, 0x1125, 0x00A3, 0x00A2, 0x0062, 0x08C3, 0x0905, 0x08E4, 0x0082, 0x0062, 0x0062, 0x0083, 0x08E4, 0x08E4, 0x00C3, // 0x0500 (1280) pixels +0x00C3, 0x0904, 0x08E4, 0x00A3, 0x0082, 0x0062, 0x0062, 0x00A3, 0x1104, 0x08A3, 0x0083, 0x0062, 0x08C3, 0x00C3, 0x1986, 0x1186, // 0x0510 (1296) pixels +0x11C7, 0x1A28, 0x1146, 0x0905, 0x1105, 0x1125, 0x00C4, 0x1125, 0x1105, 0x1105, 0x0905, 0x1105, 0x0925, 0x0945, 0x19E7, 0x1A28, // 0x0520 (1312) pixels +0x0083, 0x00A3, 0x08C4, 0x08C4, 0x08E4, 0x1186, 0x19C7, 0x0966, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x1186, 0x1186, 0x1186, // 0x0530 (1328) pixels +0x1186, 0x1186, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, // 0x0540 (1344) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1166, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, // 0x0550 (1360) pixels +0x1145, 0x1145, 0x1125, 0x1145, 0x0925, 0x1166, 0x19A7, 0x0925, 0x0925, 0x08E4, 0x00A3, 0x0083, 0x0925, 0x2249, 0x1A08, 0x0946, // 0x0560 (1376) pixels +0x0925, 0x1125, 0x0925, 0x0925, 0x1125, 0x1125, 0x08E4, 0x08E4, 0x1125, 0x1125, 0x1125, 0x1105, 0x0925, 0x0905, 0x228A, 0x09C7, // 0x0570 (1392) pixels +0x11C7, 0x0945, 0x1125, 0x00A3, 0x00A3, 0x0062, 0x08C3, 0x0904, 0x08E4, 0x0082, 0x0082, 0x0062, 0x0083, 0x08E4, 0x08E4, 0x00C3, // 0x0580 (1408) pixels +0x00C3, 0x0904, 0x08E4, 0x00A3, 0x0082, 0x0062, 0x0062, 0x08A3, 0x10E4, 0x08C3, 0x00A3, 0x0062, 0x08C4, 0x08C4, 0x1986, 0x11A6, // 0x0590 (1424) pixels +0x11C7, 0x1A49, 0x0966, 0x0925, 0x1105, 0x1105, 0x00C4, 0x1105, 0x0905, 0x1105, 0x0925, 0x1125, 0x1145, 0x1166, 0x1A08, 0x2228, // 0x05A0 (1440) pixels +0x0083, 0x00A3, 0x08C4, 0x08C4, 0x0904, 0x1186, 0x19C7, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x1186, 0x1186, 0x1186, // 0x05B0 (1456) pixels +0x1186, 0x1186, 0x1186, 0x1186, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, // 0x05C0 (1472) pixels +0x1187, 0x1187, 0x1187, 0x1187, 0x1186, 0x1186, 0x1186, 0x1186, 0x1186, 0x1186, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x1186, // 0x05D0 (1488) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x0946, 0x1186, 0x19C8, 0x0946, 0x1126, 0x08E4, 0x00A3, 0x0062, 0x0966, 0x228A, 0x1A29, 0x0966, // 0x05E0 (1504) pixels +0x0925, 0x1145, 0x1125, 0x1125, 0x1125, 0x1125, 0x08E4, 0x08E4, 0x1125, 0x1105, 0x1105, 0x1105, 0x0925, 0x0905, 0x1A69, 0x11E8, // 0x05F0 (1520) pixels +0x11E8, 0x0945, 0x1145, 0x00A3, 0x00A3, 0x0062, 0x08C4, 0x1125, 0x08C4, 0x0082, 0x0082, 0x0082, 0x0083, 0x08E4, 0x08E4, 0x00C3, // 0x0600 (1536) pixels +0x00A2, 0x08E4, 0x08E4, 0x00C3, 0x0083, 0x0062, 0x0062, 0x00A3, 0x0904, 0x08C3, 0x00A3, 0x0062, 0x08C3, 0x00C3, 0x1987, 0x11A7, // 0x0610 (1552) pixels +0x11C7, 0x2269, 0x0946, 0x0925, 0x1105, 0x1125, 0x08E4, 0x1125, 0x1125, 0x0925, 0x0905, 0x1125, 0x1145, 0x0966, 0x1A08, 0x2249, // 0x0620 (1568) pixels +0x00A3, 0x00C3, 0x08C4, 0x08E4, 0x08E5, 0x19A7, 0x19E8, 0x1146, 0x1146, 0x1166, 0x1166, 0x1166, 0x1186, 0x1166, 0x1166, 0x1166, // 0x0630 (1584) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, // 0x0640 (1600) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1146, // 0x0650 (1616) pixels +0x0946, 0x0925, 0x0946, 0x0946, 0x0925, 0x1186, 0x19C8, 0x0946, 0x1146, 0x08E4, 0x00A3, 0x0082, 0x0945, 0x228A, 0x1A49, 0x1186, // 0x0660 (1632) pixels +0x1145, 0x1145, 0x0925, 0x0925, 0x1145, 0x1145, 0x0904, 0x08E4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x0925, 0x1A69, 0x1208, // 0x0670 (1648) pixels +0x1A08, 0x0946, 0x1145, 0x00A3, 0x0083, 0x0062, 0x08C3, 0x1124, 0x08C3, 0x0082, 0x0062, 0x0062, 0x00A2, 0x08E4, 0x00E3, 0x00C3, // 0x0680 (1664) pixels +0x0082, 0x08E4, 0x08E4, 0x00C3, 0x0082, 0x0062, 0x0062, 0x00A3, 0x0904, 0x08C3, 0x00A3, 0x0062, 0x08C4, 0x08E4, 0x1986, 0x11A7, // 0x0690 (1680) pixels +0x11E7, 0x2269, 0x0966, 0x1125, 0x1105, 0x1125, 0x08E4, 0x1125, 0x1105, 0x0925, 0x0925, 0x1145, 0x1145, 0x1166, 0x1A28, 0x2249, // 0x06A0 (1696) pixels +0x00A3, 0x00C3, 0x08C4, 0x08E4, 0x0905, 0x19C7, 0x2209, 0x0925, 0x0904, 0x0905, 0x0105, 0x0125, 0x0925, 0x0125, 0x0125, 0x0125, // 0x06B0 (1712) pixels +0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, // 0x06C0 (1728) pixels +0x0125, 0x0925, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0125, 0x0925, 0x0125, 0x0125, 0x0905, 0x0905, 0x0105, 0x0105, // 0x06D0 (1744) pixels +0x0905, 0x0105, 0x0125, 0x0905, 0x00E4, 0x0925, 0x19E8, 0x1146, 0x1146, 0x08E5, 0x00A3, 0x0082, 0x0966, 0x22AB, 0x1A49, 0x1186, // 0x06E0 (1760) pixels +0x1166, 0x1166, 0x1146, 0x1145, 0x1125, 0x1145, 0x08E4, 0x08E4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x0905, 0x1A69, 0x1208, // 0x06F0 (1776) pixels +0x1A08, 0x0946, 0x1146, 0x00C3, 0x0083, 0x0062, 0x08C3, 0x1124, 0x08E3, 0x0082, 0x0062, 0x0082, 0x00A3, 0x08E4, 0x08E3, 0x00C3, // 0x0700 (1792) pixels +0x0082, 0x08E4, 0x08E4, 0x00C3, 0x0082, 0x0062, 0x0062, 0x0083, 0x0904, 0x08C3, 0x00A3, 0x0062, 0x08C4, 0x00C3, 0x19A7, 0x11A7, // 0x0710 (1808) pixels +0x11E7, 0x2269, 0x1166, 0x0925, 0x1105, 0x1125, 0x08E4, 0x1125, 0x1125, 0x1125, 0x0925, 0x0945, 0x1166, 0x1186, 0x1A28, 0x2269, // 0x0720 (1824) pixels +0x00A3, 0x00A3, 0x08E4, 0x08E4, 0x08E5, 0x19C8, 0x2229, 0x0925, 0x1187, 0x19A7, 0x19C7, 0x11C7, 0x11C7, 0x11C7, 0x19C8, 0x19C7, // 0x0730 (1840) pixels +0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C8, // 0x0740 (1856) pixels +0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x19C7, 0x11A7, 0x11A7, // 0x0750 (1872) pixels +0x11A7, 0x11A7, 0x1187, 0x11A7, 0x1167, 0x0946, 0x2249, 0x0966, 0x1166, 0x0905, 0x00A3, 0x0082, 0x0986, 0x22CB, 0x1A6A, 0x11A7, // 0x0760 (1888) pixels +0x1145, 0x1166, 0x1145, 0x1145, 0x1145, 0x1146, 0x00E4, 0x08E4, 0x1145, 0x1125, 0x1125, 0x1125, 0x1126, 0x0925, 0x1A69, 0x1208, // 0x0770 (1904) pixels +0x1A08, 0x0966, 0x1146, 0x00C3, 0x00A3, 0x0082, 0x08C3, 0x1124, 0x08E3, 0x0082, 0x0082, 0x0082, 0x00A3, 0x08E4, 0x00C3, 0x00A3, // 0x0780 (1920) pixels +0x0082, 0x08C3, 0x08E4, 0x00A3, 0x0083, 0x0062, 0x0062, 0x0083, 0x0904, 0x08C3, 0x00A3, 0x0082, 0x08E4, 0x08E4, 0x19A7, 0x11A7, // 0x0790 (1936) pixels +0x11E7, 0x1A69, 0x1166, 0x0925, 0x1105, 0x1125, 0x08E4, 0x1125, 0x1125, 0x1145, 0x1145, 0x1146, 0x1186, 0x11A7, 0x1A49, 0x2289, // 0x07A0 (1952) pixels +0x00A3, 0x00C3, 0x08E4, 0x08E4, 0x0905, 0x19E8, 0x2229, 0x0925, 0x1186, 0x11A7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11E7, 0x11E7, // 0x07B0 (1968) pixels +0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, // 0x07C0 (1984) pixels +0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11E7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x11C7, // 0x07D0 (2000) pixels +0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x1166, 0x0946, 0x2249, 0x0986, 0x1167, 0x0905, 0x00A3, 0x0083, 0x1186, 0x22CB, 0x1AAA, 0x11C7, // 0x07E0 (2016) pixels +0x1166, 0x1166, 0x1166, 0x1145, 0x1146, 0x1146, 0x00E4, 0x1105, 0x1125, 0x1125, 0x1125, 0x1125, 0x1126, 0x0925, 0x2269, 0x1208, // 0x07F0 (2032) pixels +0x1A29, 0x1166, 0x1166, 0x00C3, 0x00A3, 0x0082, 0x08C3, 0x1124, 0x08E3, 0x0082, 0x0082, 0x0082, 0x00C3, 0x08E4, 0x00C3, 0x00A3, // 0x0800 (2048) pixels +0x0062, 0x08C4, 0x08E4, 0x08C3, 0x0083, 0x0062, 0x0062, 0x0083, 0x1105, 0x08E4, 0x00C3, 0x0062, 0x08E4, 0x08E4, 0x19A7, 0x11C7, // 0x0810 (2064) pixels +0x11E7, 0x2269, 0x1166, 0x1125, 0x1125, 0x1125, 0x08E4, 0x1125, 0x1145, 0x1125, 0x1146, 0x1166, 0x11A7, 0x11C7, 0x2269, 0x228A, // 0x0820 (2080) pixels +0x00A3, 0x00C4, 0x00E4, 0x08E5, 0x0905, 0x1A08, 0x1A49, 0x0926, 0x11A7, 0x19C8, 0x11C8, 0x11E8, 0x11E8, 0x11E8, 0x1208, 0x1208, // 0x0830 (2096) pixels +0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1A08, 0x1A08, 0x1208, 0x1A08, 0x1A08, 0x1A08, // 0x0840 (2112) pixels +0x11E8, 0x1A08, 0x11E8, 0x1A08, 0x1A08, 0x1A08, 0x1A08, 0x11E8, 0x11E8, 0x11E8, 0x11C8, 0x11C8, 0x11C8, 0x11C8, 0x11C7, 0x11C7, // 0x0850 (2128) pixels +0x11C7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x1187, 0x226A, 0x0987, 0x1167, 0x0905, 0x00A3, 0x0083, 0x1186, 0x2B0C, 0x22CB, 0x11C7, // 0x0860 (2144) pixels +0x1166, 0x1166, 0x1146, 0x1146, 0x1145, 0x1166, 0x08E4, 0x0905, 0x1125, 0x1145, 0x1145, 0x1145, 0x1126, 0x0925, 0x22AA, 0x1228, // 0x0870 (2160) pixels +0x1A29, 0x1166, 0x1966, 0x08E3, 0x00A3, 0x0082, 0x08E3, 0x1125, 0x08C4, 0x0062, 0x0062, 0x0062, 0x08C3, 0x08E3, 0x00C3, 0x00A3, // 0x0880 (2176) pixels +0x0082, 0x08C3, 0x08E4, 0x08C3, 0x0083, 0x0062, 0x0062, 0x0083, 0x1105, 0x08C4, 0x08C3, 0x0082, 0x08E4, 0x08E4, 0x19A7, 0x11C7, // 0x0890 (2192) pixels +0x1A08, 0x22CA, 0x1166, 0x1125, 0x1125, 0x1125, 0x08E4, 0x1125, 0x1145, 0x1145, 0x1166, 0x1166, 0x11A7, 0x11C7, 0x2269, 0x22AA, // 0x08A0 (2208) pixels +0x00A3, 0x00C4, 0x0905, 0x0905, 0x0925, 0x1A08, 0x1A29, 0x0146, 0x1187, 0x11A7, 0x11A7, 0x11C7, 0x11A7, 0x11A7, 0x1187, 0x1187, // 0x08B0 (2224) pixels +0x1187, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x1187, 0x11A7, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, // 0x08C0 (2240) pixels +0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, // 0x08D0 (2256) pixels +0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x0966, 0x226A, 0x0987, 0x1187, 0x0905, 0x00A3, 0x0083, 0x1187, 0x2B0C, 0x22CB, 0x11E8, // 0x08E0 (2272) pixels +0x1166, 0x1186, 0x1146, 0x1146, 0x1166, 0x1166, 0x08C4, 0x0905, 0x1145, 0x1145, 0x1125, 0x1145, 0x1126, 0x0905, 0x228A, 0x1208, // 0x08F0 (2288) pixels +0x1A29, 0x1186, 0x1966, 0x08C3, 0x08A3, 0x0062, 0x08E3, 0x1125, 0x08C4, 0x0082, 0x0062, 0x0062, 0x08C3, 0x08E3, 0x00C3, 0x00A3, // 0x0900 (2304) pixels +0x0062, 0x00A3, 0x08E4, 0x08C3, 0x0083, 0x0062, 0x0062, 0x0083, 0x1105, 0x08C4, 0x00C3, 0x0082, 0x08E4, 0x08E4, 0x19C7, 0x11C7, // 0x0910 (2320) pixels +0x11E8, 0x2ACB, 0x1166, 0x1125, 0x1125, 0x1145, 0x08E4, 0x1145, 0x1146, 0x1146, 0x1146, 0x11A7, 0x11A7, 0x11C7, 0x1A69, 0x2AEB, // 0x0920 (2336) pixels +0x00A3, 0x00C4, 0x0905, 0x0905, 0x0925, 0x1A49, 0x228A, 0x0966, 0x0926, 0x0946, 0x1187, 0x11C7, 0x08E5, 0x00C4, 0x00C4, 0x00C4, // 0x0930 (2352) pixels +0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, // 0x0940 (2368) pixels +0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, 0x00C4, // 0x0950 (2384) pixels +0x0905, 0x1166, 0x1166, 0x1166, 0x0946, 0x0987, 0x2AAB, 0x11A7, 0x11A8, 0x0905, 0x00A3, 0x0083, 0x1187, 0x332D, 0x22EC, 0x11C7, // 0x0960 (2400) pixels +0x1186, 0x1186, 0x1146, 0x1146, 0x1166, 0x1166, 0x08C4, 0x0905, 0x1145, 0x1145, 0x1145, 0x1145, 0x1126, 0x0925, 0x22CA, 0x1A48, // 0x0970 (2416) pixels +0x1A29, 0x1186, 0x1966, 0x08E3, 0x08A3, 0x0062, 0x08E3, 0x1125, 0x08C4, 0x0082, 0x0062, 0x0062, 0x08C3, 0x08E3, 0x00C3, 0x00A3, // 0x0980 (2432) pixels +0x0062, 0x00A3, 0x08E4, 0x00C3, 0x0083, 0x0062, 0x0062, 0x0083, 0x1105, 0x08C4, 0x08C3, 0x0082, 0x0904, 0x08E4, 0x19C7, 0x11C7, // 0x0990 (2448) pixels +0x11E8, 0x2AEB, 0x1166, 0x1125, 0x1125, 0x1125, 0x00E4, 0x1166, 0x1145, 0x1145, 0x1166, 0x11A6, 0x11C7, 0x11E8, 0x1A89, 0x2AEB, // 0x09A0 (2464) pixels +0x00A3, 0x00C4, 0x0905, 0x0905, 0x0946, 0x226A, 0x228A, 0x0966, 0x0926, 0x1166, 0x0966, 0x0946, 0x00C4, 0x1125, 0x0905, 0x0905, // 0x09B0 (2480) pixels +0x0905, 0x0905, 0x0905, 0x1105, 0x0905, 0x1105, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, // 0x09C0 (2496) pixels +0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x0905, 0x08E5, 0x08E5, 0x08E5, // 0x09D0 (2512) pixels +0x0925, 0x1166, 0x1146, 0x1166, 0x0946, 0x0967, 0x2ACC, 0x19C8, 0x19A8, 0x0905, 0x00A3, 0x0083, 0x1186, 0x2B2D, 0x230C, 0x11C7, // 0x09E0 (2528) pixels +0x1186, 0x1187, 0x1166, 0x1166, 0x1166, 0x1166, 0x08C4, 0x0905, 0x1146, 0x1146, 0x1145, 0x1145, 0x1126, 0x0925, 0x2AEB, 0x1A69, // 0x09F0 (2544) pixels +0x1A29, 0x1186, 0x1966, 0x08E4, 0x08A3, 0x0062, 0x08E3, 0x1125, 0x08C4, 0x0062, 0x0062, 0x0062, 0x08C3, 0x08E3, 0x00C3, 0x00A3, // 0x0A00 (2560) pixels +0x0062, 0x00A3, 0x08C4, 0x08C3, 0x0083, 0x0062, 0x0062, 0x0083, 0x1104, 0x08C3, 0x08C3, 0x0062, 0x1105, 0x08E4, 0x19C7, 0x11C7, // 0x0A10 (2576) pixels +0x1A08, 0x2AEB, 0x1166, 0x1125, 0x1125, 0x1145, 0x08E4, 0x1166, 0x1166, 0x1166, 0x0945, 0x11A6, 0x11C7, 0x11E7, 0x228A, 0x22EB, // 0x0A20 (2592) pixels +0x00A3, 0x00C4, 0x0905, 0x0905, 0x0946, 0x228A, 0x22AA, 0x1166, 0x0926, 0x1146, 0x1146, 0x0926, 0x00A4, 0x08E5, 0x00E4, 0x08C4, // 0x0A30 (2608) pixels +0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, // 0x0A40 (2624) pixels +0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x08E5, 0x00C4, 0x0905, 0x08E5, 0x00E5, // 0x0A50 (2640) pixels +0x0925, 0x1166, 0x1166, 0x1166, 0x0946, 0x09A7, 0x332D, 0x11C7, 0x11A8, 0x0905, 0x00A3, 0x00A3, 0x11A7, 0x2B6E, 0x232D, 0x11E8, // 0x0A60 (2656) pixels +0x1186, 0x1186, 0x1166, 0x1166, 0x1166, 0x1966, 0x08E4, 0x0904, 0x1146, 0x1146, 0x1145, 0x1145, 0x1146, 0x0925, 0x2B0C, 0x1269, // 0x0A70 (2672) pixels +0x1A6A, 0x1186, 0x1966, 0x08E4, 0x08C3, 0x0062, 0x08E4, 0x1125, 0x08C3, 0x0082, 0x0082, 0x0062, 0x08C3, 0x08C3, 0x00A3, 0x00A2, // 0x0A80 (2688) pixels +0x0082, 0x0083, 0x08E4, 0x08C3, 0x0083, 0x0062, 0x0062, 0x0083, 0x1104, 0x08E3, 0x08E4, 0x0082, 0x1105, 0x0904, 0x19A7, 0x11C7, // 0x0A90 (2704) pixels +0x1A08, 0x228A, 0x1166, 0x1125, 0x1125, 0x1145, 0x00E4, 0x1166, 0x1166, 0x1166, 0x0946, 0x11A6, 0x11C7, 0x11E8, 0x228A, 0x22EB, // 0x0AA0 (2720) pixels +0x00A3, 0x00C4, 0x0905, 0x0905, 0x1187, 0x22AB, 0x22AA, 0x0966, 0x0946, 0x1146, 0x1146, 0x0926, 0x00C4, 0x1146, 0x0926, 0x0926, // 0x0AB0 (2736) pixels +0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, // 0x0AC0 (2752) pixels +0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0926, 0x0925, 0x0925, // 0x0AD0 (2768) pixels +0x0925, 0x1187, 0x0966, 0x0966, 0x0946, 0x09A7, 0x336D, 0x11E8, 0x11C8, 0x0925, 0x00A3, 0x00A3, 0x11A7, 0x2B6E, 0x234D, 0x1208, // 0x0AE0 (2784) pixels +0x1186, 0x11A6, 0x1186, 0x1166, 0x1166, 0x1966, 0x08E4, 0x0904, 0x1146, 0x1145, 0x1145, 0x1145, 0x1146, 0x0925, 0x2B0C, 0x1269, // 0x0AF0 (2800) pixels +0x1A6A, 0x11A7, 0x1986, 0x08E4, 0x08A3, 0x0062, 0x08E4, 0x1125, 0x08C3, 0x0082, 0x0082, 0x0082, 0x08E3, 0x00C3, 0x00A3, 0x00A2, // 0x0B00 (2816) pixels +0x0083, 0x0082, 0x08E4, 0x08E4, 0x00A3, 0x0083, 0x0062, 0x0083, 0x0904, 0x08E4, 0x08E3, 0x0062, 0x1105, 0x0905, 0x19C7, 0x11C8, // 0x0B10 (2832) pixels +0x1208, 0x22EB, 0x0946, 0x1126, 0x1125, 0x1145, 0x00E4, 0x1166, 0x1166, 0x1166, 0x1166, 0x11A7, 0x19E8, 0x1A08, 0x22AA, 0x2AEB, // 0x0B20 (2848) pixels +0x00A3, 0x00C4, 0x0925, 0x0925, 0x1187, 0x22CB, 0x2AEB, 0x0987, 0x0946, 0x0966, 0x1166, 0x0946, 0x00C4, 0x1166, 0x2209, 0x1A29, // 0x0B30 (2864) pixels +0x2249, 0x2249, 0x1A49, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, 0x2249, // 0x0B40 (2880) pixels +0x2249, 0x2249, 0x2249, 0x2249, 0x224A, 0x1A29, 0x1A29, 0x1A29, 0x2249, 0x2249, 0x1A29, 0x2249, 0x2249, 0x11A7, 0x0946, 0x0946, // 0x0B50 (2896) pixels +0x0925, 0x0125, 0x0967, 0x0966, 0x0946, 0x09E8, 0x336E, 0x1209, 0x19E8, 0x0925, 0x08C4, 0x00A3, 0x11A7, 0x2B8E, 0x234D, 0x1208, // 0x0B60 (2912) pixels +0x11A6, 0x1186, 0x1186, 0x1166, 0x1166, 0x1966, 0x08E4, 0x0905, 0x1146, 0x1145, 0x1145, 0x1146, 0x1146, 0x0925, 0x2B2C, 0x1A8A, // 0x0B70 (2928) pixels +0x1A6A, 0x1187, 0x19A7, 0x08E4, 0x08C3, 0x0062, 0x08E4, 0x1145, 0x00C3, 0x0062, 0x0082, 0x0082, 0x08C3, 0x08C3, 0x00A3, 0x0082, // 0x0B80 (2944) pixels +0x0083, 0x0082, 0x08C3, 0x08C3, 0x00A3, 0x0082, 0x0062, 0x0083, 0x0904, 0x08E4, 0x08E3, 0x0082, 0x1105, 0x0905, 0x19C7, 0x19E8, // 0x0B90 (2960) pixels +0x1A28, 0x2B0B, 0x1166, 0x1126, 0x1125, 0x1145, 0x00E4, 0x1166, 0x1166, 0x1166, 0x1166, 0x11A7, 0x19E8, 0x1208, 0x22AA, 0x2AEB, // 0x0BA0 (2976) pixels +0x00A4, 0x00E4, 0x0925, 0x0925, 0x09A7, 0x22CB, 0x22EB, 0x0987, 0x1146, 0x1166, 0x1166, 0x0946, 0x00E4, 0x0946, 0x19E8, 0x1A29, // 0x0BB0 (2992) pixels +0x1A29, 0x0987, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, // 0x0BC0 (3008) pixels +0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x1A08, 0x226A, 0x11C8, 0x0125, 0x0926, // 0x0BD0 (3024) pixels +0x0925, 0x0125, 0x1166, 0x0966, 0x0966, 0x09E8, 0x338E, 0x1209, 0x1A08, 0x0926, 0x00A3, 0x00C3, 0x11A7, 0x2BAE, 0x234D, 0x1228, // 0x0BE0 (3040) pixels +0x11A6, 0x11A7, 0x1186, 0x1166, 0x1186, 0x1986, 0x08E4, 0x0905, 0x1146, 0x1145, 0x1145, 0x1145, 0x1146, 0x0945, 0x2B0C, 0x1AAA, // 0x0BF0 (3056) pixels +0x228A, 0x11A7, 0x19A7, 0x08E4, 0x08A3, 0x0082, 0x08E4, 0x1125, 0x00C3, 0x0062, 0x0082, 0x0082, 0x08C3, 0x00A3, 0x0082, 0x0082, // 0x0C00 (3072) pixels +0x0062, 0x0082, 0x0082, 0x00A3, 0x0083, 0x0082, 0x0062, 0x0083, 0x08E4, 0x08C4, 0x08C4, 0x0062, 0x1104, 0x0904, 0x19C7, 0x19E7, // 0x0C10 (3088) pixels +0x1A28, 0x2B0B, 0x0946, 0x1126, 0x1126, 0x1126, 0x08E5, 0x1166, 0x1166, 0x1166, 0x1166, 0x11A7, 0x11E8, 0x1228, 0x22AB, 0x2B0C, // 0x0C20 (3104) pixels +0x00A3, 0x00C4, 0x0926, 0x0926, 0x11A7, 0x22CB, 0x230C, 0x09A7, 0x0946, 0x1167, 0x1167, 0x0946, 0x00E5, 0x1146, 0x0105, 0x11E8, // 0x0C30 (3120) pixels +0x1A29, 0x0966, 0x0966, 0x0967, 0x0967, 0x1167, 0x0946, 0x0946, 0x0946, 0x1146, 0x1146, 0x1146, 0x0946, 0x0946, 0x0946, 0x0946, // 0x0C40 (3136) pixels +0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0926, 0x11E8, 0x226A, 0x19C8, 0x0926, 0x0946, // 0x0C50 (3152) pixels +0x0946, 0x0926, 0x0987, 0x0967, 0x0967, 0x09E8, 0x3BCF, 0x1229, 0x19E9, 0x0926, 0x00C4, 0x00C3, 0x1187, 0x33CF, 0x2B6D, 0x1228, // 0x0C60 (3168) pixels +0x11A7, 0x11A7, 0x1186, 0x1186, 0x1166, 0x1986, 0x08E4, 0x0905, 0x1145, 0x1146, 0x1146, 0x1146, 0x1146, 0x0945, 0x2B0C, 0x1AAA, // 0x0C70 (3184) pixels +0x1A8A, 0x11A7, 0x19A7, 0x08E4, 0x08A3, 0x0062, 0x08E4, 0x1125, 0x08C4, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, 0x0062, 0x0062, // 0x0C80 (3200) pixels +0x0082, 0x0082, 0x0062, 0x0062, 0x0082, 0x0062, 0x0082, 0x0083, 0x08E4, 0x08C4, 0x08E4, 0x0062, 0x1104, 0x0904, 0x19C7, 0x19E8, // 0x0C90 (3216) pixels +0x1A28, 0x2B0B, 0x1146, 0x1126, 0x1125, 0x1126, 0x08E4, 0x1166, 0x1166, 0x1166, 0x1166, 0x19A7, 0x1A08, 0x1A28, 0x22AB, 0x2B0B, // 0x0CA0 (3232) pixels +0x00C3, 0x00C4, 0x0925, 0x0926, 0x11A7, 0x22CB, 0x230C, 0x09C7, 0x1167, 0x1167, 0x1167, 0x0946, 0x00E5, 0x0926, 0x0905, 0x11E8, // 0x0CB0 (3248) pixels +0x1A29, 0x0967, 0x1187, 0x1187, 0x1167, 0x1167, 0x1167, 0x1167, 0x1187, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, // 0x0CC0 (3264) pixels +0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x0966, 0x19E8, 0x224A, 0x19C8, 0x0926, 0x0946, // 0x0CD0 (3280) pixels +0x0926, 0x0926, 0x0967, 0x0967, 0x0967, 0x11E8, 0x33CF, 0x1229, 0x1A09, 0x0946, 0x00C4, 0x00C3, 0x11A7, 0x33CF, 0x2B6E, 0x1228, // 0x0CE0 (3296) pixels +0x11A7, 0x11A7, 0x1186, 0x1186, 0x1186, 0x1987, 0x08E4, 0x0905, 0x1145, 0x1146, 0x1145, 0x1146, 0x1146, 0x0945, 0x2B0B, 0x1AAA, // 0x0CF0 (3312) pixels +0x228A, 0x11C7, 0x19A7, 0x0904, 0x08A3, 0x0082, 0x08E4, 0x1125, 0x08C4, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x0D00 (3328) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x10E4, 0x08E4, 0x08C4, 0x0083, 0x1105, 0x0904, 0x19E7, 0x19E8, // 0x0D10 (3344) pixels +0x1248, 0x2B2B, 0x1166, 0x1126, 0x1126, 0x1146, 0x0905, 0x1187, 0x1166, 0x21A6, 0x8BC4, 0x8BE4, 0x8C25, 0x8C45, 0x9486, 0x94A7, // 0x0D20 (3360) pixels +0x8382, 0x8383, 0x83C4, 0x83C3, 0x8C04, 0x94A6, 0x94C7, 0x8404, 0x8BE4, 0x8BE4, 0x8BE4, 0x83C4, 0x83A3, 0x8BC4, 0x83A3, 0x8C25, // 0x0D30 (3376) pixels +0x8C25, 0x83E4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, // 0x0D40 (3392) pixels +0x8BE4, 0x8BE4, 0x8BE4, 0x5B05, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x6B45, 0x83E4, 0x8C25, 0x9446, 0x8C05, 0x83C4, 0x83C4, // 0x0D50 (3408) pixels +0x83C4, 0x83C4, 0x8BE4, 0x83E4, 0x83E4, 0x8C25, 0x9D08, 0x8C46, 0x8C25, 0x83C4, 0x8383, 0x8382, 0x8BE4, 0x9D08, 0x94E7, 0x8C25, // 0x0D60 (3424) pixels +0x8C04, 0x8C04, 0x8BE4, 0x8BE4, 0x8BE4, 0x8BE4, 0x8383, 0x83A3, 0x8BC3, 0x8BC3, 0x8BC3, 0x8BC3, 0x8BC4, 0x83C3, 0x94A6, 0x9486, // 0x0D70 (3440) pixels +0x9466, 0x8C04, 0x8BE4, 0x0904, 0x08A3, 0x0062, 0x08E4, 0x1124, 0x08A3, 0x0062, 0x0062, 0x0062, 0x0042, 0x0062, 0x0062, 0x0062, // 0x0D80 (3456) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x00A3, 0x08A3, 0x08C4, 0x0082, 0x1105, 0x0904, 0x19C7, 0x19E8, // 0x0D90 (3472) pixels +0x1A69, 0x2B2C, 0x1166, 0x1146, 0x1126, 0x1146, 0x0905, 0x1187, 0x1166, 0x52A5, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0DA0 (3488) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0DB0 (3504) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0DC0 (3520) pixels +0xFE41, 0xFE41, 0xFE41, 0x9B03, 0x4884, 0x28C4, 0x0925, 0x0925, 0x0125, 0xD542, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0DD0 (3536) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0DE0 (3552) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0DF0 (3568) pixels +0xFE41, 0xFE41, 0xED82, 0x4883, 0x4063, 0x0082, 0x08C3, 0x00A2, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x0E00 (3584) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x00C3, 0x1986, 0x21C7, // 0x0E10 (3600) pixels +0x1A28, 0x336D, 0x0966, 0x1126, 0x1145, 0x1146, 0x0904, 0x1186, 0x1166, 0x8BC4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0E20 (3616) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0E30 (3632) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0E40 (3648) pixels +0xFE41, 0xFE41, 0xFE41, 0x9922, 0x8802, 0x38C5, 0x0946, 0x0946, 0x19A6, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0E50 (3664) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0E60 (3680) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0E70 (3696) pixels +0xFE41, 0xFE41, 0xD3E2, 0x8802, 0x6822, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x0E80 (3712) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x00A3, 0x08C4, 0x1125, 0x1125, 0x00E4, 0x0925, // 0x0E90 (3728) pixels +0x0986, 0x2ACA, 0x1146, 0x1126, 0x1145, 0x1146, 0x0904, 0x1186, 0x1166, 0xB4C3, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0EA0 (3744) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0EB0 (3760) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0EC0 (3776) pixels +0xFE41, 0xFE41, 0xFDE1, 0x8802, 0x8002, 0x2946, 0x1187, 0x1187, 0x4AC6, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0ED0 (3792) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0EE0 (3808) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0EF0 (3824) pixels +0xFE41, 0xFE41, 0xB262, 0x8802, 0x4822, 0x0083, 0x0083, 0x0083, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x0F00 (3840) pixels +0x0083, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x08C3, 0x0904, 0x1987, 0x1166, // 0x0F10 (3856) pixels +0x0125, 0x0986, 0x1146, 0x1146, 0x1145, 0x1146, 0x0905, 0x1186, 0x1186, 0x52A5, 0x8BE4, 0xDCE2, 0xFDE1, 0xFE41, 0xFE41, 0xFE41, // 0x0F20 (3872) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0F30 (3888) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF581, 0xDC42, 0xCB82, // 0x0F40 (3904) pixels +0xBAC2, 0xB262, 0x9922, 0x8802, 0x7823, 0x1187, 0x1187, 0x1187, 0x2A26, 0x7B84, 0xB443, 0xED22, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0F50 (3920) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0F60 (3936) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFDE1, 0xED22, 0xD3E2, 0xC322, // 0x0F70 (3952) pixels +0xB262, 0xA9E2, 0x8862, 0x8002, 0x3083, 0x08A3, 0x0083, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0062, 0x0082, 0x0082, // 0x0F80 (3968) pixels +0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0083, 0x0083, 0x0062, 0x0082, 0x0082, 0x0082, 0x0083, 0x0082, 0x00A3, 0x00C3, 0x08E4, 0x1146, // 0x0F90 (3984) pixels +0x19C7, 0x11A7, 0x0105, 0x1146, 0x1146, 0x1146, 0x0905, 0x1987, 0x1186, 0x1966, 0x1186, 0x3967, 0x5105, 0x9203, 0xD402, 0xFE41, // 0x0FA0 (4000) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0FB0 (4016) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xE4A2, 0xA9E2, 0x8862, 0x8802, 0x8802, 0x7823, // 0x0FC0 (4032) pixels +0x6084, 0x50A4, 0x40E5, 0x38E5, 0x2146, 0x0987, 0x0987, 0x0987, 0x1187, 0x1167, 0x2126, 0x4926, 0x71A5, 0xAA83, 0xF582, 0xFE41, // 0x0FD0 (4048) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x0FE0 (4064) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFDE1, 0xC322, 0x90C2, 0x8802, 0x8802, 0x8002, 0x6823, // 0x0FF0 (4080) pixels +0x5043, 0x4884, 0x40C4, 0x28A3, 0x08A3, 0x0083, 0x0083, 0x0062, 0x0062, 0x0062, 0x0083, 0x0082, 0x0082, 0x0082, 0x00A2, 0x00A2, // 0x1000 (4096) pixels +0x00A3, 0x00A3, 0x08E4, 0x08E4, 0x00A3, 0x0083, 0x00A3, 0x0083, 0x0082, 0x0082, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x00C3, 0x08E4, // 0x1010 (4112) pixels +0x0925, 0x1166, 0x19C7, 0x0945, 0x0925, 0x1166, 0x0925, 0x1987, 0x1166, 0x1166, 0x1186, 0x1A08, 0x1229, 0x1A69, 0x22EC, 0x5AE9, // 0x1020 (4128) pixels +0xC402, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1030 (4144) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xA9E2, 0x8802, 0x8802, 0x6864, 0x3106, 0x1967, 0x1187, // 0x1040 (4160) pixels +0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x1187, 0x1167, 0x0967, 0x1A09, 0x1AAB, 0x1A09, 0x1926, 0x82E4, // 0x1050 (4176) pixels +0xF5E1, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1060 (4192) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xD3E2, 0x8862, 0x8802, 0x7802, 0x4083, 0x18E5, 0x08E4, 0x1966, // 0x1070 (4208) pixels +0x21A7, 0x08E4, 0x00C3, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0062, 0x0082, 0x0083, 0x00A3, 0x00A3, 0x00A3, 0x0083, 0x08E4, 0x00C3, // 0x1080 (4224) pixels +0x00A3, 0x00A3, 0x00E4, 0x0925, 0x0925, 0x0904, 0x00C3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00C3, 0x08C3, // 0x1090 (4240) pixels +0x08E4, 0x08E4, 0x1145, 0x1186, 0x1166, 0x0904, 0x0904, 0x1986, 0x1166, 0x1986, 0x1186, 0x1A08, 0x1A29, 0x1A69, 0x22EC, 0x2B2C, // 0x10A0 (4256) pixels +0x00E4, 0x9BE3, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x10B0 (4272) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xBAC2, 0x8802, 0x8002, 0x3106, 0x1187, 0x1187, 0x1187, 0x1187, // 0x10C0 (4288) pixels +0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x1187, 0x1167, 0x0987, 0x1A09, 0x1A8B, 0x1A09, 0x0946, 0x0967, // 0x10D0 (4304) pixels +0x3A46, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x10E0 (4320) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0x8802, 0x8002, 0x5043, 0x08C4, 0x1145, 0x21C7, 0x21C8, 0x0905, // 0x10F0 (4336) pixels +0x00C3, 0x00C3, 0x00C3, 0x00A3, 0x0083, 0x0082, 0x0082, 0x00A3, 0x00A3, 0x00A3, 0x00C3, 0x08E4, 0x0904, 0x0904, 0x0904, 0x00C3, // 0x1100 (4352) pixels +0x08A3, 0x00A3, 0x08E4, 0x0904, 0x0904, 0x0904, 0x0904, 0x0925, 0x0904, 0x08E4, 0x00C3, 0x00C3, 0x00C3, 0x00C3, 0x08C3, 0x00A3, // 0x1110 (4368) pixels +0x00A3, 0x08C4, 0x08E4, 0x0905, 0x1145, 0x1166, 0x00E4, 0x0925, 0x1987, 0x1186, 0x1186, 0x1A08, 0x1A29, 0x1A6A, 0x22EC, 0x2B2C, // 0x1120 (4384) pixels +0x00E4, 0x39E4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1130 (4400) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0x8802, 0x8002, 0x40E5, 0x1187, 0x1187, 0x1187, 0x11A7, 0x11A7, // 0x1140 (4416) pixels +0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x1187, 0x0987, 0x0987, 0x1187, 0x1187, 0x1187, 0x1A09, 0x1A8B, 0x1A09, 0x0967, 0x1167, // 0x1150 (4432) pixels +0x0946, 0xD562, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1160 (4448) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xAA02, 0x8802, 0x6802, 0x0904, 0x21C7, 0x21C7, 0x08E4, 0x00C4, 0x08C4, // 0x1170 (4464) pixels +0x00C3, 0x00C3, 0x00A3, 0x00A3, 0x00A3, 0x00C3, 0x00C3, 0x00C3, 0x08E4, 0x1125, 0x0904, 0x0904, 0x0904, 0x0904, 0x0904, 0x00C3, // 0x1180 (4480) pixels +0x00A3, 0x08C4, 0x1125, 0x0925, 0x0904, 0x0904, 0x0924, 0x0904, 0x0924, 0x0945, 0x0925, 0x0925, 0x08E4, 0x00C3, 0x00C3, 0x08E4, // 0x1190 (4496) pixels +0x08A3, 0x00A3, 0x00C3, 0x00C4, 0x00E4, 0x0905, 0x0925, 0x1146, 0x0945, 0x1986, 0x1186, 0x1A08, 0x1A29, 0x1A6A, 0x22EC, 0x2B2C, // 0x11A0 (4512) pixels +0x00E4, 0x39E4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x11B0 (4528) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xBAC2, 0x8802, 0x7043, 0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x11E8, // 0x11C0 (4544) pixels +0x11C8, 0x11C8, 0x19C8, 0x19C8, 0x19C8, 0x19C8, 0x11A8, 0x1187, 0x1187, 0x1187, 0x1187, 0x1A29, 0x22AB, 0x1A09, 0x0967, 0x1167, // 0x11D0 (4560) pixels +0x0967, 0xC503, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x11E0 (4576) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0x8802, 0x8002, 0x30E4, 0x1946, 0x00C4, 0x00A3, 0x08C4, 0x08C4, 0x00A3, // 0x11F0 (4592) pixels +0x00A3, 0x00A3, 0x00A3, 0x00C3, 0x00E4, 0x08E4, 0x1125, 0x1145, 0x1145, 0x0925, 0x1104, 0x0904, 0x0904, 0x00C3, 0x00C3, 0x00A3, // 0x1200 (4608) pixels +0x0082, 0x00C3, 0x08E4, 0x00E4, 0x0904, 0x0904, 0x0925, 0x0925, 0x0945, 0x1145, 0x1145, 0x1145, 0x1146, 0x1145, 0x1105, 0x08E4, // 0x1210 (4624) pixels +0x0905, 0x0905, 0x08E4, 0x08C4, 0x00E4, 0x00C3, 0x00C3, 0x1145, 0x1186, 0x1166, 0x1186, 0x1A28, 0x1A49, 0x1A8A, 0x230C, 0x234C, // 0x1220 (4640) pixels +0x00E4, 0x5AA4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1230 (4656) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x9922, 0x8802, 0x4105, 0x11A7, 0x11A7, 0x11A7, 0x11A8, 0x11A7, 0x11A8, // 0x1240 (4672) pixels +0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x1187, 0x19E8, 0x11A7, 0x11A7, 0x1187, 0x1187, 0x1A29, 0x1AAB, 0x1209, 0x0967, 0x1187, // 0x1250 (4688) pixels +0x1167, 0xD562, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1260 (4704) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xD3E2, 0x8802, 0x7043, 0x08E4, 0x08E4, 0x08E4, 0x08C4, 0x08C4, 0x08C4, 0x00A3, // 0x1270 (4720) pixels +0x08C4, 0x08E4, 0x0904, 0x1125, 0x1166, 0x1166, 0x1145, 0x1165, 0x1145, 0x0904, 0x00C3, 0x00C3, 0x0904, 0x0904, 0x0904, 0x00C3, // 0x1280 (4736) pixels +0x00A3, 0x08E4, 0x1104, 0x0904, 0x00A3, 0x00A3, 0x00A3, 0x0925, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1125, 0x1145, 0x1145, // 0x1290 (4752) pixels +0x1125, 0x0905, 0x0925, 0x0905, 0x0905, 0x0925, 0x08E4, 0x0905, 0x0965, 0x1987, 0x1186, 0x1A28, 0x1A49, 0x1A8A, 0x230C, 0x234C, // 0x12A0 (4768) pixels +0x00E5, 0x83A3, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x12B0 (4784) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFDE1, 0x8802, 0x8002, 0x2105, 0x0926, 0x0926, 0x0926, 0x0946, 0x0926, 0x0946, // 0x12C0 (4800) pixels +0x0926, 0x0926, 0x0926, 0x0926, 0x0926, 0x0125, 0x19C8, 0x11A7, 0x1187, 0x1187, 0x1187, 0x1A29, 0x1ACB, 0x1209, 0x0967, 0x1167, // 0x12D0 (4816) pixels +0x21C7, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x12E0 (4832) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xAA02, 0x8802, 0x5063, 0x0905, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x08E4, 0x1105, // 0x12F0 (4848) pixels +0x1125, 0x1146, 0x1166, 0x1145, 0x1145, 0x1145, 0x1145, 0x0945, 0x1166, 0x00E4, 0x0083, 0x00A3, 0x0905, 0x0904, 0x00C3, 0x08E4, // 0x1300 (4864) pixels +0x08E4, 0x0904, 0x1105, 0x08E4, 0x00A3, 0x00A3, 0x00E4, 0x0945, 0x1165, 0x1145, 0x1145, 0x0925, 0x0925, 0x1125, 0x0945, 0x1146, // 0x1310 (4880) pixels +0x1145, 0x1166, 0x1166, 0x0925, 0x0905, 0x0925, 0x0905, 0x0925, 0x0925, 0x1186, 0x1187, 0x1A08, 0x1A6A, 0x1A6A, 0x230C, 0x234C, // 0x1320 (4896) pixels +0x00E4, 0xC4E2, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1330 (4912) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xDC42, 0x8802, 0x7823, 0x0946, 0x1146, 0x1146, 0x1126, 0x1126, 0x1126, 0x1126, // 0x1340 (4928) pixels +0x1126, 0x1126, 0x1126, 0x1146, 0x1146, 0x0926, 0x19E8, 0x11A7, 0x11A8, 0x11A8, 0x11A7, 0x1A29, 0x1AAB, 0x1229, 0x0967, 0x1167, // 0x1350 (4944) pixels +0x4AA6, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1360 (4960) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x90C2, 0x8002, 0x28A4, 0x08E4, 0x0905, 0x0904, 0x0904, 0x1125, 0x1166, 0x1986, // 0x1370 (4976) pixels +0x1166, 0x1145, 0x1145, 0x0925, 0x0904, 0x00E4, 0x0945, 0x1186, 0x1165, 0x08E4, 0x0083, 0x0083, 0x08C3, 0x08E4, 0x08E4, 0x08C4, // 0x1380 (4992) pixels +0x0042, 0x0062, 0x08A3, 0x00A3, 0x00A3, 0x00A3, 0x00C3, 0x0945, 0x1145, 0x1145, 0x0904, 0x0104, 0x08E4, 0x0905, 0x1166, 0x1166, // 0x1390 (5008) pixels +0x1166, 0x0966, 0x1166, 0x0966, 0x1166, 0x1166, 0x0905, 0x1146, 0x1186, 0x1986, 0x1186, 0x1A08, 0x1A6A, 0x1A6A, 0x230C, 0x234C, // 0x13A0 (5024) pixels +0x00E4, 0xF5E2, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x13B0 (5040) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xBAC2, 0x8802, 0x5864, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0946, // 0x13C0 (5056) pixels +0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0926, 0x19E8, 0x11A8, 0x11A7, 0x11A7, 0x11A8, 0x1A29, 0x22AB, 0x1A29, 0x0967, 0x0967, // 0x13D0 (5072) pixels +0x8BE4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x13E0 (5088) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0x8802, 0x8002, 0x18E4, 0x0904, 0x0905, 0x1125, 0x1186, 0x11C7, 0x11A6, 0x1186, // 0x13F0 (5104) pixels +0x0965, 0x0945, 0x0925, 0x0904, 0x0904, 0x00E4, 0x0904, 0x1166, 0x1165, 0x1125, 0x08C4, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x0062, // 0x1400 (5120) pixels +0x0062, 0x0082, 0x0083, 0x0083, 0x00A3, 0x00C3, 0x0904, 0x1145, 0x1145, 0x1145, 0x0904, 0x0904, 0x0904, 0x1145, 0x1186, 0x11C7, // 0x1410 (5136) pixels +0x1A08, 0x2228, 0x19E7, 0x1186, 0x1166, 0x1146, 0x1145, 0x1966, 0x1186, 0x1987, 0x1186, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x2B4D, // 0x1420 (5152) pixels +0x31E4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1430 (5168) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xA182, 0x8802, 0x38A4, 0x11A7, 0x19A7, 0x11A7, 0x19A7, 0x11A7, 0x11A7, 0x19A7, // 0x1440 (5184) pixels +0x19C7, 0x19C8, 0x11A7, 0x0966, 0x0946, 0x0926, 0x19E9, 0x11A8, 0x11A8, 0x11A8, 0x11A7, 0x1A49, 0x22CB, 0x1209, 0x0987, 0x1187, // 0x1450 (5200) pixels +0xC523, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1460 (5216) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xDC42, 0x8802, 0x7023, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x22AA, 0x22EB, 0x2269, // 0x1470 (5232) pixels +0x1A08, 0x19C7, 0x1166, 0x1105, 0x0904, 0x0104, 0x0904, 0x1986, 0x1986, 0x1966, 0x08E4, 0x0083, 0x0062, 0x0062, 0x0062, 0x0062, // 0x1480 (5248) pixels +0x0062, 0x0082, 0x0062, 0x0062, 0x0082, 0x00A3, 0x00C3, 0x0904, 0x1125, 0x1125, 0x1125, 0x08E4, 0x0904, 0x1145, 0x19A6, 0x1186, // 0x1490 (5264) pixels +0x11C7, 0x19E8, 0x2208, 0x19E7, 0x1166, 0x1166, 0x1145, 0x1166, 0x1186, 0x1987, 0x1186, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x2B4D, // 0x14A0 (5280) pixels +0x62E3, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x14B0 (5296) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x8802, 0x8002, 0x2905, 0x1A09, 0x1187, 0x1187, 0x11A7, 0x11A7, 0x11A7, 0x1187, // 0x14C0 (5312) pixels +0x1187, 0x0986, 0x19E8, 0x11A7, 0x0946, 0x0926, 0x1A09, 0x11C8, 0x11A8, 0x11A8, 0x11A8, 0x1A4A, 0x22CB, 0x1A29, 0x0967, 0x1187, // 0x14D0 (5328) pixels +0xF602, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x14E0 (5344) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xBAC2, 0x8802, 0x5863, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1A29, 0x11E7, 0x09A6, // 0x14F0 (5360) pixels +0x11C7, 0x11A7, 0x19A6, 0x1145, 0x0904, 0x0904, 0x0904, 0x08C3, 0x00A3, 0x0082, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0082, // 0x1500 (5376) pixels +0x0062, 0x0082, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0083, 0x08A3, 0x08C4, 0x1945, 0x19A7, 0x11A6, // 0x1510 (5392) pixels +0x11A6, 0x0945, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1986, 0x1187, 0x1187, 0x1187, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x2B4D, // 0x1520 (5408) pixels +0xA442, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1530 (5424) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xE4A2, 0x8802, 0x8002, 0x0966, 0x1A09, 0x0946, 0x0966, 0x0966, 0x0966, 0x0946, 0x0946, // 0x1540 (5440) pixels +0x0966, 0x0946, 0x19E8, 0x2229, 0x2A29, 0x0926, 0x19E9, 0x11C8, 0x11A8, 0x11A8, 0x11A8, 0x1A49, 0x22CB, 0x1A29, 0x0967, 0x3A66, // 0x1550 (5456) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1560 (5472) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x9922, 0x8002, 0x38C4, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x0945, 0x11A7, 0x2228, // 0x1570 (5488) pixels +0x2249, 0x19E8, 0x19A6, 0x1104, 0x00C3, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, // 0x1580 (5504) pixels +0x0062, 0x0062, 0x0062, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0062, 0x0062, 0x0062, 0x08E4, 0x0925, // 0x1590 (5520) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1986, 0x1187, 0x1186, 0x1187, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x2B4D, // 0x15A0 (5536) pixels +0xD542, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x15B0 (5552) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xCB82, 0x8802, 0x6064, 0x1187, 0x1A29, 0x0986, 0x0987, 0x1187, 0x1187, 0x0966, 0x2A4A, // 0x15C0 (5568) pixels +0x6BF0, 0x7451, 0xBE38, 0xF79E, 0x6BD0, 0x0926, 0x1A09, 0x11C8, 0x11A8, 0x11A8, 0x11A8, 0x1A4A, 0x22CB, 0x1A29, 0x0967, 0x6B45, // 0x15D0 (5584) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x15E0 (5600) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFDE1, 0x8802, 0x8002, 0x2105, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x1146, 0x11A6, 0x1A08, // 0x15F0 (5616) pixels +0x1166, 0x00C4, 0x0062, 0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x0083, // 0x1600 (5632) pixels +0x0062, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0042, 0x0042, 0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0062, 0x0083, 0x08A4, // 0x1610 (5648) pixels +0x0925, 0x2249, 0x11A7, 0x1166, 0x1166, 0x1166, 0x1146, 0x1987, 0x1187, 0x1166, 0x1187, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x336C, // 0x1620 (5664) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1630 (5680) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xA182, 0x8802, 0x50C5, 0x11A7, 0x1A6A, 0x09A7, 0x11A7, 0x11A7, 0x3AEC, 0xC679, 0xFFFF, // 0x1640 (5696) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xADB7, 0x0946, 0x0926, 0x1A09, 0x11C8, 0x11A8, 0x11C8, 0x11A7, 0x1A4A, 0x22CB, 0x1A29, 0x0967, 0xA484, // 0x1650 (5712) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1660 (5728) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xE4A2, 0x8802, 0x7822, 0x1125, 0x1145, 0x1145, 0x1146, 0x1146, 0x1145, 0x0945, 0x1A08, 0x11A6, // 0x1670 (5744) pixels +0x0082, 0x0062, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0042, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, 0x0083, // 0x1680 (5760) pixels +0x0062, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0062, 0x0042, 0x0062, 0x0062, 0x0042, 0x0042, 0x0062, 0x0042, 0x0083, 0x08A4, // 0x1690 (5776) pixels +0x00E4, 0x2249, 0x19C7, 0x1146, 0x1166, 0x1166, 0x1146, 0x1987, 0x1187, 0x1166, 0x1187, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x5C0A, // 0x16A0 (5792) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x16B0 (5808) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x8862, 0x8002, 0x2966, 0x11C8, 0x228A, 0x09C7, 0x11C8, 0x6C31, 0xFFFF, 0xFFFF, 0xFFFF, // 0x16C0 (5824) pixels +0xFFFF, 0xFFFF, 0xE75D, 0x3ACC, 0x0946, 0x0946, 0x1209, 0x11E8, 0x11A8, 0x11A8, 0x11C8, 0x1A4A, 0x22CB, 0x1A29, 0x0967, 0xD563, // 0x16D0 (5840) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x16E0 (5856) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xC322, 0x8802, 0x5843, 0x1125, 0x1145, 0x1145, 0x1146, 0x1146, 0x1146, 0x0925, 0x330B, 0x1A29, // 0x16F0 (5872) pixels +0x00A3, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0042, 0x0062, 0x0042, 0x0083, 0x0083, 0x0083, 0x0083, // 0x1700 (5888) pixels +0x0062, 0x0082, 0x0082, 0x0082, 0x0062, 0x0082, 0x0062, 0x0062, 0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0082, 0x0083, 0x08A4, // 0x1710 (5904) pixels +0x00E5, 0x2249, 0x19E8, 0x1166, 0x1166, 0x1166, 0x1146, 0x1987, 0x1187, 0x1166, 0x1187, 0x1A08, 0x1A69, 0x1A69, 0x230C, 0x94C7, // 0x1720 (5920) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1730 (5936) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xED22, 0x8802, 0x8002, 0x19A8, 0x09C8, 0x22AA, 0x11E8, 0x5BCF, 0xF79E, 0xD6DB, 0xFFFF, 0xFFFF, // 0x1740 (5952) pixels +0xFFFF, 0xFFFF, 0x53EF, 0x1A29, 0x0966, 0x0926, 0x1A09, 0x11E8, 0x11A8, 0x11A8, 0x11A8, 0x1A4A, 0x22CB, 0x1A29, 0x19C7, 0xFE41, // 0x1750 (5968) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1760 (5984) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xA182, 0x8802, 0x3863, 0x1125, 0x1145, 0x1145, 0x1146, 0x1146, 0x1145, 0x0104, 0x43EE, 0x228A, // 0x1770 (6000) pixels +0x00C3, 0x0082, 0x0082, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0062, 0x0082, 0x0083, 0x0083, 0x0083, 0x0083, // 0x1780 (6016) pixels +0x0062, 0x0082, 0x0062, 0x0062, 0x0083, 0x0062, 0x0062, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x00A3, 0x00C3, 0x00C4, 0x08E4, // 0x1790 (6032) pixels +0x00E4, 0x2A6A, 0x19E8, 0x1166, 0x1166, 0x1166, 0x1146, 0x1987, 0x1187, 0x1166, 0x1187, 0x1A08, 0x1A49, 0x1A69, 0x230C, 0xCD84, // 0x17A0 (6048) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x17B0 (6064) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xD3E2, 0x8802, 0x7064, 0x11C8, 0x11E8, 0x22CB, 0x3B2D, 0xD6FB, 0x9D75, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17C0 (6080) pixels +0xFFFF, 0x8514, 0x1AAA, 0x1A49, 0x0967, 0x0946, 0x1A09, 0x11E8, 0x11A8, 0x11A8, 0x11C8, 0x1A4A, 0x22CB, 0x1A29, 0x5B05, 0xFE41, // 0x17D0 (6096) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x17E0 (6112) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x8862, 0x8002, 0x20A4, 0x1125, 0x1145, 0x1145, 0x1146, 0x1146, 0x0925, 0x0904, 0x3BCE, 0x1A89, // 0x17F0 (6128) pixels +0x1145, 0x0904, 0x00C3, 0x00C3, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0042, 0x0082, 0x0083, 0x0082, 0x0083, 0x0083, 0x0083, // 0x1800 (6144) pixels +0x0062, 0x0082, 0x0083, 0x0083, 0x0082, 0x0083, 0x08A3, 0x1104, 0x08C4, 0x0062, 0x08E4, 0x00A3, 0x08E4, 0x0905, 0x1166, 0x09C7, // 0x1810 (6160) pixels +0x11E7, 0x11A7, 0x0965, 0x1166, 0x1166, 0x1166, 0x1146, 0x1987, 0x1187, 0x1186, 0x1187, 0x1208, 0x1A49, 0x1A69, 0x22EC, 0xF602, // 0x1820 (6176) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1830 (6192) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xAA02, 0x8802, 0x58C5, 0x11C8, 0x1209, 0x4BCF, 0xC69A, 0x5C10, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1840 (6208) pixels +0xB639, 0x0A29, 0x1AEB, 0x1A6A, 0x1167, 0x0946, 0x1A09, 0x11E8, 0x11C8, 0x11C8, 0x11C8, 0x1A6A, 0x22CB, 0x1A29, 0x9424, 0xFE41, // 0x1850 (6224) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1860 (6240) pixels +0xFE41, 0xFE41, 0xFE41, 0xE4A2, 0x8802, 0x8002, 0x08C4, 0x1125, 0x1145, 0x1145, 0x1146, 0x1146, 0x1105, 0x0925, 0x0145, 0x09C7, // 0x1870 (6256) pixels +0x0986, 0x1125, 0x1146, 0x00C4, 0x00A3, 0x08C3, 0x0062, 0x0082, 0x08C4, 0x08E4, 0x08C3, 0x0083, 0x0082, 0x0083, 0x0083, 0x0083, // 0x1880 (6272) pixels +0x0062, 0x0082, 0x0083, 0x0082, 0x0083, 0x0083, 0x00A3, 0x1125, 0x08E4, 0x0083, 0x1145, 0x08E4, 0x1125, 0x1146, 0x19C7, 0x228A, // 0x1890 (6288) pixels +0x2B4C, 0x1228, 0x09C6, 0x0986, 0x1166, 0x1166, 0x1146, 0x1987, 0x1187, 0x1186, 0x1187, 0x1208, 0x1A49, 0x1A69, 0x4B89, 0xFE41, // 0x18A0 (6304) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x18B0 (6320) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x90C2, 0x8002, 0x3967, 0x11C8, 0x434D, 0xAE38, 0x436E, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xE75D, // 0x18C0 (6336) pixels +0x332C, 0x1269, 0x230C, 0x1A8B, 0x1166, 0x0946, 0x1A09, 0x11E8, 0x11C8, 0x11C8, 0x11C8, 0x1A4A, 0x22AB, 0x1A29, 0xC503, 0xFE41, // 0x18D0 (6352) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x18E0 (6368) pixels +0xFE41, 0xFE41, 0xFE41, 0xCB82, 0x8802, 0x6084, 0x00E4, 0x1146, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x11A7, 0x1289, 0x2B4C, // 0x18F0 (6384) pixels +0x2ACA, 0x19C7, 0x19E8, 0x0966, 0x1125, 0x08E4, 0x0082, 0x0082, 0x08E4, 0x08E4, 0x08C3, 0x00A3, 0x0082, 0x0083, 0x0083, 0x0083, // 0x1900 (6400) pixels +0x0062, 0x0082, 0x0083, 0x0083, 0x0083, 0x0083, 0x00A3, 0x1145, 0x1104, 0x00A3, 0x1125, 0x08E4, 0x1146, 0x1166, 0x11A7, 0x22CA, // 0x1910 (6416) pixels +0x232C, 0x232C, 0x2AEB, 0x0965, 0x1165, 0x1146, 0x1146, 0x1987, 0x1186, 0x1166, 0x1166, 0x1208, 0x1A49, 0x1A49, 0x8447, 0xFE41, // 0x1920 (6432) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1930 (6448) pixels +0xFE41, 0xFE41, 0xFE41, 0xF582, 0x8802, 0x8002, 0x21A8, 0x536E, 0x7CD3, 0x43EF, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x334D, // 0x1940 (6464) pixels +0x12AA, 0x12AA, 0x232C, 0x1A8A, 0x1167, 0x0966, 0x1A09, 0x11E8, 0x11C8, 0x11C8, 0x09A7, 0x1A49, 0x22AB, 0x1A09, 0xFE41, 0xFE41, // 0x1950 (6480) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1960 (6496) pixels +0xFE41, 0xFE41, 0xFE41, 0xAA02, 0x8802, 0x50C4, 0x08E4, 0x1146, 0x1145, 0x1145, 0x1146, 0x1145, 0x0966, 0x1A28, 0x44D1, 0x1B4C, // 0x1970 (6512) pixels +0x1AAA, 0x19E7, 0x19E8, 0x1166, 0x1105, 0x08C4, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x00C3, 0x00A3, 0x0082, 0x0083, 0x0083, 0x0083, // 0x1980 (6528) pixels +0x0062, 0x0062, 0x0083, 0x0083, 0x0083, 0x0083, 0x00A3, 0x1145, 0x0904, 0x00A3, 0x1125, 0x08E4, 0x1145, 0x1166, 0x11A7, 0x22CA, // 0x1990 (6544) pixels +0x232C, 0x230B, 0x22CB, 0x0945, 0x1145, 0x1146, 0x1146, 0x1987, 0x1186, 0x1166, 0x1166, 0x1208, 0x1A49, 0x1A69, 0xBD24, 0xFE41, // 0x19A0 (6560) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x19B0 (6576) pixels +0xFE41, 0xFE41, 0xFE41, 0xDC42, 0x8802, 0x7043, 0x7C92, 0x7CB3, 0x2B0C, 0xE77D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x7D14, 0x1ACB, // 0x19C0 (6592) pixels +0x1ACB, 0x12CB, 0x234D, 0x1ACB, 0x0967, 0x0966, 0x1A09, 0x11E8, 0x11C8, 0x11C8, 0x09A7, 0x228B, 0x2AEC, 0x5307, 0xFE41, 0xFE41, // 0x19D0 (6608) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x19E0 (6624) pixels +0xFE41, 0xFE41, 0xFE41, 0x90C2, 0x8002, 0x3925, 0x08E4, 0x1146, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x09C7, 0x344F, 0x1B6C, // 0x19F0 (6640) pixels +0x1AAA, 0x19E7, 0x21E8, 0x1166, 0x1105, 0x08E4, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x00C3, 0x00A3, 0x0082, 0x0083, 0x0083, 0x0083, // 0x1A00 (6656) pixels +0x0062, 0x0083, 0x0083, 0x0083, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x08E4, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x11A7, 0x22AA, // 0x1A10 (6672) pixels +0x230C, 0x230C, 0x22CA, 0x0945, 0x1146, 0x1146, 0x1146, 0x1987, 0x1186, 0x1166, 0x1166, 0x1208, 0x1A49, 0x1A69, 0xE5C3, 0xFE41, // 0x1A20 (6688) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1A30 (6704) pixels +0xFE41, 0xFE41, 0xFE41, 0xBAC2, 0x8802, 0x9B6F, 0x536E, 0x2AAB, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAE18, 0x1AEC, 0x1AEC, // 0x1A40 (6720) pixels +0x1B0C, 0x12EC, 0x238D, 0x22AB, 0x0967, 0x0966, 0x1A09, 0x11E8, 0x11E8, 0x11E8, 0x11A8, 0x1A2A, 0x1A4A, 0x7BA5, 0xFE41, 0xFE41, // 0x1A50 (6736) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1A60 (6752) pixels +0xFE41, 0xFE41, 0xED22, 0x8802, 0x8002, 0x2166, 0x08E4, 0x1146, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x0987, 0x3C70, 0x1B4D, // 0x1A70 (6768) pixels +0x22AA, 0x19C7, 0x19E8, 0x1146, 0x1145, 0x00E4, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1A80 (6784) pixels +0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x08E4, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1166, 0x11A7, 0x22AA, // 0x1A90 (6800) pixels +0x230C, 0x230C, 0x22CA, 0x0945, 0x1146, 0x1146, 0x1146, 0x1987, 0x1186, 0x1166, 0x1167, 0x11E8, 0x1A49, 0x32E8, 0xFE41, 0xFE41, // 0x1AA0 (6816) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1AB0 (6832) pixels +0xFE41, 0xFE41, 0xFE41, 0x9922, 0xB30D, 0x59E9, 0x32CC, 0xE73D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE77D, 0x33AF, 0x1B2C, 0x132C, // 0x1AC0 (6848) pixels +0x132D, 0x132C, 0x238E, 0x22CB, 0x0967, 0x0966, 0x1A09, 0x11E8, 0x11C8, 0x11E8, 0x11C8, 0x11E8, 0x1229, 0xB4E3, 0xFE41, 0xFE41, // 0x1AD0 (6864) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1AE0 (6880) pixels +0xFE41, 0xFE41, 0xD3E2, 0x8802, 0x6863, 0x1986, 0x00E4, 0x1145, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x0987, 0x3C50, 0x234D, // 0x1AF0 (6896) pixels +0x228A, 0x19C7, 0x19E8, 0x1146, 0x1145, 0x00C4, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1B00 (6912) pixels +0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x00A3, 0x1145, 0x0904, 0x1145, 0x1166, 0x11C7, 0x22AA, // 0x1B10 (6928) pixels +0x2B2C, 0x230C, 0x1AAA, 0x0145, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, 0x1166, 0x1166, 0x11E8, 0x1A29, 0x6387, 0xFE41, 0xFE41, // 0x1B20 (6944) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1B30 (6960) pixels +0xFE41, 0xFE41, 0xFE03, 0xAA8B, 0x8002, 0x52CC, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x33F0, 0x1B6E, 0x1B6E, 0x1B6E, // 0x1B40 (6976) pixels +0x136E, 0x136E, 0x23AE, 0x22EC, 0x0967, 0x0967, 0x1A09, 0x11E8, 0x11C8, 0x11E8, 0x11C8, 0x11E9, 0x1A4A, 0xE5A2, 0xFE41, 0xFE41, // 0x1B50 (6992) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1B60 (7008) pixels +0xFE41, 0xFE41, 0xB262, 0x8802, 0x50A4, 0x1987, 0x00E4, 0x1145, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x0987, 0x3C50, 0x234D, // 0x1B70 (7024) pixels +0x22AA, 0x19C7, 0x19E8, 0x1146, 0x1145, 0x00C4, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1B80 (7040) pixels +0x0062, 0x0083, 0x0083, 0x0083, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x00A3, 0x1145, 0x08E4, 0x1145, 0x1146, 0x11C7, 0x22AA, // 0x1B90 (7056) pixels +0x2B2C, 0x230C, 0x1AAA, 0x0945, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, 0x1166, 0x1166, 0x11E8, 0x1A29, 0x9C85, 0xFE41, 0xFE41, // 0x1BA0 (7072) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1BB0 (7088) pixels +0xFE41, 0xFE63, 0xED89, 0x8802, 0xB38F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8E38, 0x1C31, 0x2451, 0x1C51, 0x1C51, // 0x1BC0 (7104) pixels +0x1C51, 0x1C51, 0x2C71, 0x1B0C, 0x0967, 0x0967, 0x1A09, 0x11E8, 0x11C8, 0x11E8, 0x11C8, 0x09C8, 0x3AC9, 0xFE41, 0xFE41, 0xFE41, // 0x1BD0 (7120) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1BE0 (7136) pixels +0xFE41, 0xFE41, 0x9922, 0x8002, 0x3905, 0x1987, 0x00E4, 0x1125, 0x1145, 0x1145, 0x1146, 0x1145, 0x1146, 0x0987, 0x3C50, 0x1B4C, // 0x1BF0 (7152) pixels +0x1A8A, 0x19E7, 0x19E7, 0x1166, 0x1145, 0x00C4, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08C3, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1C00 (7168) pixels +0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x0904, 0x1145, 0x1145, 0x11C7, 0x22AA, // 0x1C10 (7184) pixels +0x230C, 0x230C, 0x1AAA, 0x0945, 0x1145, 0x0925, 0x1146, 0x1987, 0x1186, 0x1166, 0x1167, 0x32CB, 0x434D, 0xD5EA, 0xFEED, 0xFEED, // 0x1C20 (7200) pixels +0xFECB, 0xFEA9, 0xFEA9, 0xFE85, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1C30 (7216) pixels +0xFE85, 0xFE63, 0xC322, 0xCC93, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE79E, 0x2514, 0x2514, 0x2514, 0x2514, 0x2514, // 0x1C40 (7232) pixels +0x2514, 0x1D14, 0x3514, 0x1AEC, 0x0967, 0x0966, 0x1A09, 0x11E9, 0x11E8, 0x11E8, 0x11C8, 0x11C8, 0x6BA8, 0xFE41, 0xFE41, 0xFE41, // 0x1C50 (7248) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1C60 (7264) pixels +0xFE41, 0xFDE1, 0x8802, 0x8002, 0x2946, 0x1987, 0x00E4, 0x1125, 0x1145, 0x1145, 0x1145, 0x1145, 0x1146, 0x0986, 0x3C50, 0x1B4C, // 0x1C70 (7280) pixels +0x1AAA, 0x11E7, 0x19C7, 0x1186, 0x1125, 0x00C3, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08E4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1C80 (7296) pixels +0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00C3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x11C7, 0x22AA, // 0x1C90 (7312) pixels +0x230C, 0x230C, 0x1AAA, 0x0966, 0x1145, 0x0925, 0x21A7, 0x532D, 0x9D35, 0xC659, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1CA0 (7328) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBA, 0xFF76, 0xFF0F, 0xFE87, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, // 0x1CB0 (7344) pixels +0xFE63, 0xFE85, 0xEE78, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DF, 0x3D56, 0x24F4, 0x24F4, 0x2514, 0x2514, 0x24F4, // 0x1CC0 (7360) pixels +0x24F4, 0x1CF4, 0x2D14, 0x1ACC, 0x0967, 0x0966, 0x1A09, 0x11E8, 0x11E8, 0x11E8, 0x11C8, 0x11C8, 0xA4A5, 0xFE41, 0xFE41, 0xFE41, // 0x1CD0 (7376) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1CE0 (7392) pixels +0xFE41, 0xDC42, 0x9988, 0xAB2E, 0x8CD3, 0x638E, 0x00E4, 0x1146, 0x1145, 0x1145, 0x1146, 0x1146, 0x1145, 0x0986, 0x3C50, 0x1B4C, // 0x1CF0 (7408) pixels +0x1A8A, 0x19E7, 0x19C7, 0x1166, 0x1125, 0x00C3, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08E4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1D00 (7424) pixels +0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x0945, 0x11C7, 0x22AA, // 0x1D10 (7440) pixels +0x230C, 0x230C, 0x1AAA, 0x0966, 0x4AEC, 0xA576, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1D20 (7456) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFF54, 0xFE85, 0xFE41, 0xFE63, 0xFE87, 0xFE41, // 0x1D30 (7472) pixels +0xFEA9, 0xFFDC, 0xFFFF, 0xF71C, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8E7A, 0x2515, 0x2534, 0x2535, 0x2535, 0x2535, 0x2535, // 0x1D40 (7488) pixels +0x2514, 0x2515, 0x2D14, 0x1AEC, 0x0967, 0x0967, 0x1A09, 0x11E8, 0x11E8, 0x11E8, 0x11C8, 0x11E8, 0xCD44, 0xFE41, 0xFE41, 0xFE41, // 0x1D50 (7504) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1D60 (7520) pixels +0xFE41, 0xDD71, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x532D, 0x1125, 0x1145, 0x1145, 0x1145, 0x1145, 0x1146, 0x09A6, 0x342F, 0x1B4C, // 0x1D70 (7536) pixels +0x1A8A, 0x19E7, 0x19C7, 0x1166, 0x1125, 0x00C3, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1D80 (7552) pixels +0x0062, 0x0082, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x11C7, 0x22AA, // 0x1D90 (7568) pixels +0x230C, 0x230C, 0x5410, 0xC659, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xC659, 0xA576, 0xADB7, 0xCE75, 0xFF54, 0xFF54, 0xFF98, // 0x1DA0 (7584) pixels +0xFFBA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF30, 0xFE85, 0xFE41, 0xFF32, // 0x1DB0 (7600) pixels +0xFFFF, 0xFFFF, 0xDD96, 0xC411, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAE79, 0x2D35, 0x2515, 0x2535, 0x1D35, 0x2535, 0x2535, 0x2535, // 0x1DC0 (7616) pixels +0x2514, 0x2515, 0x2D14, 0x1AEC, 0x0967, 0x0967, 0x1A09, 0x11E8, 0x11E8, 0x11E8, 0x11C8, 0x11E8, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1DD0 (7632) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFE63, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1DE0 (7648) pixels +0xFF30, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x638E, 0x1146, 0x1146, 0x1146, 0x1166, 0x1146, 0x1166, 0x09A6, 0x340F, 0x1B4C, // 0x1DF0 (7664) pixels +0x1A8A, 0x19E7, 0x19C7, 0x1166, 0x21A7, 0x1145, 0x0083, 0x0082, 0x0904, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1E00 (7680) pixels +0x0063, 0x0063, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x11C7, 0x22AA, // 0x1E10 (7696) pixels +0x336D, 0xAE38, 0xFFFF, 0xFFFF, 0xC659, 0x8CB2, 0x4B0C, 0x21A7, 0x1146, 0x0945, 0x1166, 0x1166, 0xB4C3, 0xFE41, 0xFE41, 0xFE41, // 0x1E20 (7712) pixels +0xFE41, 0xFE41, 0xFE87, 0xFECB, 0xFF54, 0xFFBA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF32, 0xFE41, 0xFE85, 0xFFBA, 0xFFFF, // 0x1E30 (7728) pixels +0xFF98, 0xDCA9, 0x9106, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xE75D, 0x5493, 0x3514, 0x55D7, 0x7639, 0x8679, 0x969A, 0x969A, 0x3555, // 0x1E40 (7744) pixels +0x2534, 0x3D76, 0x75F8, 0x7D35, 0x84B3, 0xB5F8, 0xB618, 0x11E9, 0x32AB, 0x63D0, 0x6C31, 0x9D32, 0xFF30, 0xFE85, 0xFE41, 0xFE41, // 0x1E50 (7760) pixels +0xFE41, 0xFE41, 0xFE85, 0xFF32, 0xFFFE, 0xFFFF, 0xFFFF, 0xFECB, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xFE41, 0xFE85, // 0x1E60 (7776) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x3229, 0x1966, 0x29E8, 0x3A49, 0x5B2D, 0x7410, 0xC659, 0x63F0, 0x342F, 0x1B4C, // 0x1E70 (7792) pixels +0x1A8A, 0x536D, 0x9D55, 0xF79E, 0xFFFF, 0xFFFF, 0xB5B6, 0x2166, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1E80 (7808) pixels +0x0063, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00C3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x11C7, 0x4BAE, // 0x1E90 (7824) pixels +0xE77D, 0xF7BE, 0x8D55, 0x11A7, 0x0905, 0x0905, 0x0925, 0x0925, 0x1146, 0x1146, 0x1146, 0x1166, 0xE5A2, 0xFE41, 0xFE41, 0xFE41, // 0x1EA0 (7840) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFF54, 0xFFDC, 0xFFBA, 0xFEA9, 0xFE41, 0xFF0F, 0xFFFE, 0xFFFF, 0xFFFF, // 0x1EB0 (7856) pixels +0xFF30, 0xAA02, 0xDD96, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x6C52, 0x32AC, 0xE79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE7BE, 0x7659, // 0x1EC0 (7872) pixels +0xD77D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA596, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFE85, 0xFE41, 0xFE41, // 0x1ED0 (7888) pixels +0xFE63, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF32, 0xFE85, 0xFECB, 0xFEED, 0xFF30, 0xFF76, 0xFFBA, 0xFE41, 0xFF0F, // 0x1EE0 (7904) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BB, 0x09A7, 0x340F, 0x2B8E, // 0x1EF0 (7920) pixels +0x9DB6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x94B3, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1F00 (7936) pixels +0x0083, 0x0063, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x328A, 0xF7BE, // 0x1F10 (7952) pixels +0xBE79, 0x336D, 0x22AA, 0x0966, 0x1145, 0x1146, 0x1145, 0x1166, 0x1146, 0x1166, 0x1166, 0x3226, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1F20 (7968) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xFE41, 0xFE85, 0xFF98, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1F30 (7984) pixels +0xFFFF, 0xFF9E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9D76, 0x3AED, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE7BE, 0xFFFF, // 0x1F40 (8000) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF0F, 0xFE41, 0xFE41, 0xFEA9, // 0x1F50 (8016) pixels +0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFE85, 0xFE41, 0xFF0F, // 0x1F60 (8032) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x29E8, 0x09A7, 0x4CB1, 0xE77D, // 0x1F70 (8048) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDF1C, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x1F80 (8064) pixels +0x0083, 0x0063, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1146, 0x4B4D, 0x9555, // 0x1F90 (8080) pixels +0x336D, 0x230C, 0x1269, 0x0125, 0x0904, 0x0904, 0x0905, 0x0905, 0x0905, 0x0905, 0x0105, 0x52C4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x1FA0 (8096) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xFEA9, 0xFE63, 0xFE63, 0xFF30, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1FB0 (8112) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE75D, 0x228B, 0xC679, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1FC0 (8128) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF11, 0xFE41, 0xFE41, 0xFF0F, 0xFFFF, // 0x1FD0 (8144) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFECB, 0xFE41, 0xFE41, 0xFE85, // 0x1FE0 (8160) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x29E8, 0x0904, 0x2A6A, 0xE79E, 0xFFFF, // 0x1FF0 (8176) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2000 (8192) pixels +0x0082, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x0904, 0x1145, 0x1166, 0x11C7, 0x22AA, // 0x2010 (8208) pixels +0x232C, 0x232C, 0x1A8A, 0x0945, 0x0925, 0x0925, 0x1145, 0x0925, 0x1125, 0x0925, 0x0945, 0x9423, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2020 (8224) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xFEA9, 0xFE87, 0xFE41, 0xFEA9, 0xFFDC, 0xFFFF, 0xFF54, 0xFF0F, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2030 (8240) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x2ACC, 0x8D35, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2040 (8256) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9D53, 0xFE41, 0xFE41, 0xFF30, 0xFFFF, 0xFFFF, // 0x2050 (8272) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF0F, 0xFE41, 0xFE41, 0xFE41, 0xFF32, // 0x2060 (8288) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x428B, 0x1146, 0x3209, 0xE73C, 0xFFFF, 0xFFFF, // 0x2070 (8304) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA535, 0x0904, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2080 (8320) pixels +0x0083, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x0904, 0x00A2, 0x1145, 0x08E4, 0x1145, 0x1166, 0x11E7, 0x22AA, // 0x2090 (8336) pixels +0x232C, 0x232C, 0x1A6A, 0x0945, 0x0925, 0x0925, 0x1145, 0x1986, 0x1987, 0x1187, 0x1987, 0xD562, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x20A0 (8352) pixels +0xFE41, 0xFE41, 0xFECB, 0xFEA9, 0xFE41, 0xFE85, 0xFF98, 0xFFFF, 0xFFFE, 0xFF0F, 0xFE41, 0xFE41, 0xFE85, 0xFFDC, 0xFFFF, 0xFFFF, // 0x20B0 (8368) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8CF4, 0x4BF0, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x20C0 (8384) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8CF4, 0x5B46, 0xFE41, 0xFF30, 0xFFFF, 0xFFFF, 0xFFFF, // 0x20D0 (8400) pixels +0xFFFF, 0xFFFE, 0xFF30, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF30, 0xFE41, 0xFE41, 0xFE41, 0xFF0F, 0xFFFF, // 0x20E0 (8416) pixels +0xFFFF, 0xFFFF, 0x94B3, 0xD6DB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x63AF, 0x0905, 0x1986, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, // 0x20F0 (8432) pixels +0xF7BE, 0x8CF3, 0x8CF3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x2166, 0x0904, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2100 (8448) pixels +0x0083, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x0082, 0x1145, 0x08E4, 0x1145, 0x1166, 0x11E7, 0x22AA, // 0x2110 (8464) pixels +0x5C71, 0xCEDB, 0x6430, 0x0925, 0x0925, 0x0925, 0x0925, 0x1986, 0x1967, 0x1187, 0x21C6, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2120 (8480) pixels +0xFECB, 0xFEED, 0xFE63, 0xFE63, 0xFF32, 0xFFFF, 0xFFFF, 0xFF98, 0xFE87, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFFFE, 0xFFFF, // 0x2130 (8496) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xE75D, 0x11E9, 0xC69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2140 (8512) pixels +0xFFFF, 0xFFFF, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB618, 0x11E8, 0xA4A4, 0xFEA9, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2150 (8528) pixels +0xFFDC, 0xFE87, 0xFF30, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF32, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFFFF, 0xFFFF, // 0x2160 (8544) pixels +0xFFFF, 0xB431, 0x8CD3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8CB2, 0x1145, 0x1145, 0x9D14, 0xFFFF, 0xFFFF, 0xFFFF, 0xE77D, // 0x2170 (8560) pixels +0x3B4D, 0x8CF3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8451, 0x0082, 0x0904, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2180 (8576) pixels +0x0062, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x00A3, 0x1125, 0x08E4, 0x1145, 0x1166, 0x536D, 0xCEBA, // 0x2190 (8592) pixels +0xFFFF, 0x8555, 0x1A6A, 0x0925, 0x0925, 0x0925, 0x0945, 0x1986, 0x1166, 0x1186, 0x52A5, 0xFE41, 0xFE41, 0xFE63, 0xFEA9, 0xFEA9, // 0x21A0 (8608) pixels +0xFE63, 0xFE63, 0xFF30, 0xFFFE, 0xFFFF, 0xFFFE, 0xFF0F, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF32, 0xFFFF, // 0x21B0 (8624) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0x3AEC, 0x6C31, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xD6DB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x21C0 (8640) pixels +0xFFFF, 0xE73C, 0xA596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6DB, 0x1A09, 0x11E8, 0xD5A4, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, // 0x21D0 (8656) pixels +0xFE85, 0xFE85, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBA, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFFDC, 0xFFFF, 0xFFFF, // 0x21E0 (8672) pixels +0xC411, 0x69A7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9D14, 0x1145, 0x1145, 0x2A08, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0x7534, // 0x21F0 (8688) pixels +0xD6FB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5D7, 0x0083, 0x0082, 0x08E4, 0x08E4, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2200 (8704) pixels +0x0083, 0x0063, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x00A2, 0x1125, 0x08E3, 0x1165, 0x9534, 0xFFFF, 0xD71B, // 0x2210 (8720) pixels +0x4BEF, 0x2B4C, 0x1A89, 0x0945, 0x0925, 0x1145, 0x0945, 0x1166, 0x1166, 0x1166, 0x7B84, 0xFE63, 0xFEA9, 0xFE87, 0xFE41, 0xFE63, // 0x2220 (8736) pixels +0xFF30, 0xFFFE, 0xFFFF, 0xFFFE, 0xFF30, 0xFE63, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xFFDC, 0xFFFF, // 0x2230 (8752) pixels +0xFFFF, 0xFFFF, 0x9D55, 0x11A7, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x5B6E, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2240 (8768) pixels +0xC659, 0x3A8B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE77D, 0x4C30, 0x0967, 0x3AAA, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFE85, // 0x2250 (8784) pixels +0xFE41, 0xFE63, 0xFFBA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBA, 0xFE63, 0xFE41, 0xFE63, 0xFEA9, 0xFFBA, 0xFFFF, 0xFFFF, 0xCC91, // 0x2260 (8800) pixels +0x8002, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5D7, 0x1146, 0x1145, 0x21A7, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xFFFF, // 0x2270 (8816) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9514, 0x08E4, 0x0083, 0x0082, 0x08E4, 0x08E3, 0x08C3, 0x00C3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2280 (8832) pixels +0x0083, 0x0063, 0x0083, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x1145, 0x0904, 0x00A3, 0x1125, 0x1165, 0xD6DB, 0xFFFF, 0x9D55, 0x2B0C, // 0x2290 (8848) pixels +0x1B0C, 0x234C, 0x1A89, 0x0945, 0x0925, 0x0925, 0x1145, 0x1166, 0x1166, 0x3AAB, 0xD5CA, 0xFE87, 0xFE41, 0xFEA9, 0xFF32, 0xFFFE, // 0x22A0 (8864) pixels +0xFFFF, 0xFFFE, 0xFF30, 0xFE63, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF30, 0xFFFF, 0xFFFF, // 0x22B0 (8880) pixels +0xFFFF, 0xEF1C, 0x2A09, 0x8493, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x2A29, 0xA596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9515, // 0x22C0 (8896) pixels +0x1146, 0xA596, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BB, 0x2ACB, 0x230C, 0x0146, 0xEF5C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFE87, 0xFE41, // 0x22D0 (8912) pixels +0xFE41, 0xFE41, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBA, 0xFE85, 0xFE41, 0xFE63, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFED1, 0x8802, // 0x22E0 (8928) pixels +0xC411, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC679, 0x1125, 0x1146, 0x3229, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x22F0 (8944) pixels +0xFFFF, 0xFFFF, 0xC679, 0x4B2C, 0x1125, 0x7410, 0x2186, 0x0082, 0x08E4, 0x08E4, 0x08C3, 0x00C3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2300 (8960) pixels +0x0083, 0x0063, 0x0083, 0x0083, 0x0083, 0x0083, 0x00A3, 0x1145, 0x08E4, 0x0083, 0x3208, 0xD6BA, 0xFFFF, 0x8CB3, 0x11E7, 0x1AAA, // 0x2310 (8976) pixels +0x230C, 0x2B4C, 0x1A69, 0x0925, 0x1125, 0x0945, 0x3A8A, 0x3249, 0x42AB, 0x1166, 0xF623, 0xFEED, 0xFF98, 0xFFFF, 0xFFFF, 0xFFDC, // 0x2320 (8992) pixels +0xFF30, 0xFE63, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2330 (9008) pixels +0xFFFF, 0x8B6F, 0x21E9, 0xE75D, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x324A, 0x324A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8CB3, 0x1167, // 0x2340 (9024) pixels +0x324A, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x2A4A, 0x0126, 0x1AAA, 0x9DB6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF30, 0xFE41, 0xFE41, // 0x2350 (9040) pixels +0xFE41, 0xFE85, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFE63, 0xFE41, 0xFE41, 0xFF98, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF30, 0xDC42, 0xA20A, // 0x2360 (9056) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC659, 0x1986, 0x00C4, 0x21A7, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC679, 0xC6DA, 0x9E17, // 0x2370 (9072) pixels +0x74B2, 0x2249, 0x19E7, 0x1186, 0x8492, 0xFFFF, 0x73CF, 0x0082, 0x08E4, 0x08E4, 0x08C3, 0x00C3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2380 (9088) pixels +0x0083, 0x0063, 0x0083, 0x0083, 0x0083, 0x0083, 0x00A3, 0x1145, 0x0904, 0x0082, 0xB5F7, 0xFFFF, 0xF79E, 0x1166, 0x11E8, 0x22AA, // 0x2390 (9104) pixels +0x230C, 0x33AD, 0x53CF, 0x3A8A, 0x2A08, 0x3A8A, 0x1145, 0x21C8, 0x530D, 0xB5F6, 0xFFFE, 0xFFFF, 0xFFFF, 0xFF98, 0xFEA9, 0xFE41, // 0x23A0 (9120) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, // 0x23B0 (9136) pixels +0xD515, 0x28E5, 0x7472, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x2A29, 0x1146, 0xA596, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD96, 0x1146, 0x1146, // 0x23C0 (9152) pixels +0x9514, 0xFFFF, 0xFFFF, 0xFFFF, 0xA576, 0x0946, 0x0926, 0x8D55, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFE41, 0xFE41, 0xFE41, // 0x23D0 (9168) pixels +0xFE41, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEED, 0xFE41, 0xFE41, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF30, 0xFE41, 0xC366, 0xF71C, // 0x23E0 (9184) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x530C, 0x1986, 0x00C4, 0xB5F7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9514, 0x11A7, 0x342F, 0x23AD, // 0x23F0 (9200) pixels +0x1AAA, 0x19E8, 0x2249, 0x9D34, 0xFFFF, 0xE73C, 0x1104, 0x0082, 0x08E4, 0x08E3, 0x08C3, 0x00C3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2400 (9216) pixels +0x0082, 0x0062, 0x0082, 0x00A3, 0x0083, 0x0083, 0x00A3, 0x1145, 0x0904, 0x426A, 0xFFFF, 0xFFFF, 0xFFFF, 0xC659, 0xB618, 0x9DB6, // 0x2410 (9232) pixels +0x6492, 0x5C71, 0x2ACB, 0x0946, 0x3A6A, 0x7C31, 0xA596, 0xF79E, 0xFFFF, 0xFFFF, 0xFFDC, 0xFF30, 0xFE85, 0xFE41, 0xFE41, 0xFE41, // 0x2420 (9248) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2430 (9264) pixels +0x9106, 0x0105, 0xE75D, 0xFFFF, 0xFFFF, 0xE73C, 0x2A29, 0x1146, 0x0966, 0xE73C, 0xFFFF, 0xFFFF, 0xE73C, 0x19C8, 0x0946, 0x1166, // 0x2440 (9280) pixels +0xC659, 0xFFFF, 0xFFFF, 0xFFFF, 0x4B0C, 0x1146, 0x8493, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEED, 0xFE41, 0xFE41, 0xFE41, // 0x2450 (9296) pixels +0xFE63, 0xFFBA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFE63, 0xFE63, 0xFF98, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF30, 0xFE41, 0xFE41, 0xDD94, 0xFFFF, // 0x2460 (9312) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x1166, 0x21E8, 0xC639, 0xFFFF, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0x3A6A, 0x11A7, 0x342F, 0x23AE, // 0x2470 (9328) pixels +0x1AAA, 0x538E, 0xD6DB, 0xFFFF, 0xE73C, 0x21C7, 0x00A3, 0x0082, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0083, 0x0082, 0x0083, // 0x2480 (9344) pixels +0x0083, 0x0062, 0x0083, 0x00A3, 0x0083, 0x0083, 0x00A3, 0x1145, 0x0904, 0x8451, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB618, 0x8514, // 0x2490 (9360) pixels +0x9DD7, 0xAE38, 0xC69A, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x9D35, 0xBD4A, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x24A0 (9376) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF54, 0xFFFF, 0xFFFF, 0xFFFF, 0xC411, // 0x24B0 (9392) pixels +0x6043, 0x42AB, 0xFFFF, 0xFFFF, 0xFFFF, 0x6BD0, 0x1166, 0x1167, 0x5B8E, 0xFFFF, 0xFFFF, 0xFFFF, 0x324A, 0x1187, 0x1187, 0x1187, // 0x24C0 (9408) pixels +0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0x324A, 0xC679, 0xFFFF, 0xFFFF, 0xCEF9, 0xFFFF, 0xFFFF, 0xFFFE, 0xFE87, 0xFE41, 0xFE85, 0xFF30, // 0x24D0 (9424) pixels +0xFFFE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFEED, 0xFFDC, 0xFFFF, 0xFFFE, 0xFFDC, 0xFF30, 0xFE41, 0xFE41, 0xFEAD, 0xFFFF, 0xFFFF, // 0x24E0 (9440) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xC679, 0x4B0C, 0xE73C, 0xFFFF, 0xE73C, 0x4AEC, 0xFFFF, 0xFFFF, 0xFFFF, 0xA576, 0x11A7, 0x342F, 0x5491, // 0x24F0 (9456) pixels +0x9DB6, 0xFFFF, 0xFFFF, 0xE73C, 0x29E8, 0x08C4, 0x00A3, 0x0082, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0083, 0x0082, 0x0083, // 0x2500 (9472) pixels +0x0083, 0x0062, 0x0083, 0x0083, 0x0083, 0x0083, 0x00A3, 0x1145, 0x0904, 0x428A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2510 (9488) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xA576, 0x7C31, 0x2A29, 0x1166, 0x1166, 0xD562, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2520 (9504) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFFFF, 0xFFFF, 0xFFFF, 0xF75C, 0x9106, // 0x2530 (9520) pixels +0x4883, 0xA5D7, 0xFFFF, 0xFFFF, 0xA576, 0x0926, 0x0926, 0x0926, 0xA576, 0xFFFF, 0xFFFF, 0x84B3, 0x0946, 0x0946, 0x0946, 0x0946, // 0x2540 (9536) pixels +0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x42EC, 0x84AB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF, // 0x2550 (9552) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFE87, 0xFE41, 0xFE41, 0xFE41, 0xFE85, 0xFF9C, 0xFFFF, 0xFFFF, // 0x2560 (9568) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x3209, 0x21A7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xFFFF, // 0x2570 (9584) pixels +0xFFFF, 0xFFFF, 0xD6DB, 0x3269, 0x0904, 0x00C3, 0x0083, 0x0082, 0x08E4, 0x08C4, 0x08C4, 0x00A3, 0x0083, 0x0083, 0x0082, 0x0083, // 0x2580 (9600) pixels +0x0082, 0x0062, 0x0082, 0x0083, 0x0083, 0x0083, 0x00A3, 0x1145, 0x1104, 0x00A3, 0x3208, 0x532C, 0x8CB2, 0x8CB3, 0x8CF4, 0x8514, // 0x2590 (9616) pixels +0x74D3, 0x5C71, 0x2ACB, 0x0925, 0x1125, 0x1146, 0x1145, 0x1166, 0x21C6, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x25A0 (9632) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFEED, 0xFFFF, 0xFFFF, 0xFFFF, 0xBB4D, 0x8002, // 0x25B0 (9648) pixels +0x28C4, 0xBE9A, 0xFFFF, 0xE73C, 0x2A29, 0x1146, 0x1146, 0x1146, 0xC659, 0xFFFF, 0xE73C, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, // 0x25C0 (9664) pixels +0xB5F8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x322A, 0x1167, 0xA4A5, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x25D0 (9680) pixels +0xFF0F, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDC, 0xFE85, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF76, 0xFFFF, 0xFFFF, 0xFFFF, // 0x25E0 (9696) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6DB, 0x21A7, 0x1145, 0x1145, 0x9D14, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x25F0 (9712) pixels +0xF7BE, 0x8CF4, 0x2249, 0x1186, 0x0904, 0x08E4, 0x0083, 0x0082, 0x08E4, 0x08C3, 0x08C4, 0x00A3, 0x0083, 0x0083, 0x0082, 0x0083, // 0x2600 (9728) pixels +0x0083, 0x0063, 0x0083, 0x0083, 0x00A3, 0x0082, 0x00A3, 0x1125, 0x08E4, 0x0083, 0x1125, 0x00E3, 0x1145, 0x0945, 0x11E8, 0x22CB, // 0x2610 (9744) pixels +0x230C, 0x234C, 0x2269, 0x0945, 0x1125, 0x1125, 0x1146, 0x1186, 0x4AC5, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2620 (9760) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF76, 0xFFFF, 0xFFFF, 0xFFBC, 0x8802, 0x8002, // 0x2630 (9776) pixels +0x228A, 0xB659, 0xFFFF, 0x63CF, 0x0926, 0x0926, 0x1146, 0x1146, 0xB5F8, 0xFFFF, 0x6BF0, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, // 0x2640 (9792) pixels +0x2A2A, 0xD6DB, 0xFFFF, 0xD6DB, 0x8CB3, 0x21A8, 0x1146, 0x1146, 0xD542, 0xFECB, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFDC, 0xFF30, 0xFE63, // 0x2650 (9808) pixels +0xFE41, 0xFE87, 0xFFDC, 0xFFFF, 0xFFDC, 0xFF32, 0xFF30, 0xFF54, 0xFF98, 0xFF54, 0xFF30, 0xFF32, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2660 (9824) pixels +0x8CF3, 0xD6DB, 0xF79E, 0xC659, 0x6BCF, 0x1166, 0x00C4, 0x1125, 0x1105, 0x1105, 0x8C92, 0xD6BB, 0xFFFF, 0xE73C, 0xCF1C, 0x95F7, // 0x2670 (9840) pixels +0x2B0C, 0x19E8, 0x19E7, 0x1186, 0x08E4, 0x08E4, 0x00A3, 0x0082, 0x0904, 0x08E3, 0x08E3, 0x00C3, 0x00A3, 0x00A3, 0x0082, 0x0083, // 0x2680 (9856) pixels +0x0083, 0x0063, 0x0083, 0x0083, 0x00A3, 0x0082, 0x00A3, 0x1145, 0x08E4, 0x0083, 0x1125, 0x00E3, 0x1165, 0x0965, 0x11E8, 0x22CB, // 0x2690 (9872) pixels +0x230C, 0x2B6C, 0x226A, 0x0945, 0x1125, 0x1125, 0x1146, 0x1186, 0x8BE4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x26A0 (9888) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFFBA, 0xFFFF, 0xFFFF, 0xEE74, 0x8802, 0x6823, // 0x26B0 (9904) pixels +0x3BEF, 0x330C, 0x7452, 0x1167, 0x1167, 0x1167, 0x1167, 0x1167, 0x2A4A, 0x6BF0, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, // 0x26C0 (9920) pixels +0x0967, 0x0967, 0x1187, 0x1167, 0x1167, 0x1167, 0x0946, 0x1986, 0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x26D0 (9936) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF30, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, // 0x26E0 (9952) pixels +0x7C91, 0x4B2D, 0x1186, 0x1166, 0x1166, 0x1166, 0x00C4, 0x1125, 0x1105, 0x1105, 0x1125, 0x1105, 0x1125, 0x11C7, 0x3450, 0x33CE, // 0x26F0 (9968) pixels +0x22CB, 0x19E8, 0x19E7, 0x1186, 0x08E4, 0x08E4, 0x00A3, 0x0082, 0x1104, 0x08E4, 0x08C3, 0x00C3, 0x00A3, 0x00A3, 0x0082, 0x0083, // 0x2700 (9984) pixels +0x0083, 0x0063, 0x0083, 0x0083, 0x0083, 0x0083, 0x08A3, 0x1105, 0x08E4, 0x00A3, 0x0904, 0x0904, 0x1166, 0x1166, 0x1A08, 0x22CB, // 0x2710 (10000) pixels +0x12AA, 0x0A69, 0x1A49, 0x0945, 0x1105, 0x1125, 0x1145, 0x1166, 0xC503, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2720 (10016) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFFBA, 0xFFFF, 0xFFFF, 0xBB06, 0x8802, 0x5063, // 0x2730 (10032) pixels +0x4CB2, 0x0166, 0x0966, 0x1167, 0x1167, 0x1187, 0x1187, 0x1187, 0x1187, 0x0987, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, 0x1187, // 0x2740 (10048) pixels +0x1187, 0x11A7, 0x1187, 0x1187, 0x1167, 0x1167, 0x1187, 0x4AA5, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2750 (10064) pixels +0xFE41, 0xFE41, 0xFE63, 0xFF98, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2760 (10080) pixels +0xFFFF, 0xFFFF, 0xE73C, 0x638E, 0x1166, 0x1166, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1125, 0x0905, 0x0905, 0x11C7, 0x3C50, 0x230C, // 0x2770 (10096) pixels +0x1249, 0x1187, 0x11A6, 0x1145, 0x1104, 0x08C4, 0x0083, 0x0083, 0x08C3, 0x08A3, 0x00A3, 0x00A3, 0x0083, 0x0082, 0x0083, 0x0083, // 0x2780 (10112) pixels +0x0083, 0x0063, 0x0083, 0x0083, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x00A3, 0x00A2, 0x08C3, 0x08E4, 0x0925, 0x11E8, // 0x2790 (10128) pixels +0x1AEB, 0x3BEF, 0x09A7, 0x0925, 0x1125, 0x1125, 0x1145, 0x1166, 0xF602, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x27A0 (10144) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFF54, 0xFFFF, 0xFF98, 0x9922, 0x8002, 0x41A7, // 0x27B0 (10160) pixels +0x340F, 0x0987, 0x1187, 0x1187, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x1187, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, // 0x27C0 (10176) pixels +0x11A7, 0x11A7, 0x1187, 0x1187, 0x1167, 0x1187, 0x1187, 0x9424, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x27D0 (10192) pixels +0xFE41, 0xFE41, 0xFF54, 0xFFFF, 0xFFFF, 0xFFBA, 0xFECB, 0xFE87, 0xFECB, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x27E0 (10208) pixels +0xFFFF, 0xFFFF, 0xFFFF, 0x8CB3, 0x1166, 0x1166, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1125, 0x0905, 0x0925, 0x0986, 0x1B0B, 0x126A, // 0x27F0 (10224) pixels +0x09C7, 0x0986, 0x0965, 0x0904, 0x00C3, 0x00A3, 0x0062, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, // 0x2800 (10240) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, 0x00C3, 0x08E3, 0x0904, 0x1125, 0x0946, 0x11C8, // 0x2810 (10256) pixels +0x128A, 0x2B6D, 0x1208, 0x0925, 0x1125, 0x1125, 0x1146, 0x3A65, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2820 (10272) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE87, 0xFF54, 0xF582, 0x8802, 0x8002, 0x43AE, // 0x2830 (10288) pixels +0x1ACB, 0x00E5, 0x0926, 0x0926, 0x0146, 0x0946, 0x0926, 0x0946, 0x0926, 0x0946, 0x0946, 0x0946, 0x0926, 0x0946, 0x0946, 0x0926, // 0x2840 (10304) pixels +0x0946, 0x0946, 0x0946, 0x0946, 0x0946, 0x0947, 0x0946, 0xC503, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2850 (10320) pixels +0xFE41, 0xFE85, 0xFFFF, 0xFFFF, 0xFFDC, 0xFE63, 0xFE41, 0xFE63, 0xFF32, 0xFFFF, 0xFFFF, 0xFFFF, 0xF75C, 0xFFFF, 0xFFFF, 0xFFFF, // 0x2860 (10336) pixels +0xFFFF, 0xF79E, 0x6BF0, 0x1186, 0x1166, 0x1186, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1105, 0x1105, 0x0925, 0x0966, 0x4C71, 0x336D, // 0x2870 (10352) pixels +0x1A29, 0x11A7, 0x1166, 0x1124, 0x00A3, 0x00A3, 0x0083, 0x0062, 0x0083, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x0082, // 0x2880 (10368) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0083, 0x00A3, 0x08E3, 0x08E4, 0x0905, 0x1146, 0x11E8, // 0x2890 (10384) pixels +0x1ACB, 0x2B4D, 0x09A7, 0x1166, 0x1125, 0x1125, 0x1146, 0x7BA4, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x28A0 (10400) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE63, 0xDC42, 0x8802, 0x7043, 0x340F, // 0x28B0 (10416) pixels +0x2B2D, 0x0987, 0x1187, 0x1188, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x11A7, 0x19A8, 0x11A8, 0x11A8, 0x11A8, 0x11A8, 0x11A8, 0x11A8, // 0x28C0 (10432) pixels +0x11A8, 0x11A8, 0x11A8, 0x11A8, 0x11A8, 0x11A8, 0x11A8, 0xF602, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x28D0 (10448) pixels +0xFE41, 0xFECB, 0xFFFF, 0xFFFF, 0xFF54, 0xFEA9, 0xFF30, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF54, 0x9944, 0x9106, 0x94D3, 0x8D14, // 0x28E0 (10464) pixels +0x6C10, 0x2208, 0x1187, 0x1186, 0x1166, 0x1186, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1105, 0x1105, 0x0925, 0x0986, 0x2BAE, 0x126A, // 0x28F0 (10480) pixels +0x11A7, 0x0966, 0x1145, 0x0904, 0x08C4, 0x00A3, 0x0083, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x0082, // 0x2900 (10496) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, 0x0083, 0x08E4, 0x0904, 0x0904, 0x1125, 0x1146, 0x11C8, // 0x2910 (10512) pixels +0x22EC, 0x33CF, 0x11E8, 0x0946, 0x0905, 0x1126, 0x1146, 0xB4C3, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2920 (10528) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xC322, 0x8802, 0x60C5, 0x0A69, // 0x2930 (10544) pixels +0x0A09, 0x0166, 0x0987, 0x0967, 0x0966, 0x0967, 0x0966, 0x0966, 0x0966, 0x0966, 0x0966, 0x0987, 0x0967, 0x0987, 0x0987, 0x0987, // 0x2940 (10560) pixels +0x0987, 0x0987, 0x0987, 0x0987, 0x0987, 0x0967, 0x3A66, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2950 (10576) pixels +0xFE41, 0xFF0F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF32, 0xFDE1, 0x8802, 0x8023, 0x2AEB, 0x1A29, // 0x2960 (10592) pixels +0x11A7, 0x11A7, 0x1166, 0x1166, 0x1166, 0x1186, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x0966, 0x2BAE, 0x230C, // 0x2970 (10608) pixels +0x19E8, 0x11A7, 0x1146, 0x1124, 0x08C3, 0x00A3, 0x0083, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x2980 (10624) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0083, 0x0083, 0x00A3, 0x00C3, 0x08E4, 0x0905, 0x0925, 0x0986, // 0x2990 (10640) pixels +0x0A29, 0x1B0C, 0x1208, 0x0105, 0x0905, 0x1126, 0x1146, 0xE5A2, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x29A0 (10656) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xAA02, 0x8802, 0x4946, 0x224A, // 0x29B0 (10672) pixels +0x1A4A, 0x1A29, 0x1A49, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, // 0x29C0 (10688) pixels +0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x1A29, 0x8406, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x29D0 (10704) pixels +0xFE41, 0xFE63, 0xFFDC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBA, 0xFEA9, 0xFE41, 0xE4A2, 0x8802, 0x7884, 0x234C, 0x1A29, // 0x29E0 (10720) pixels +0x19C7, 0x11A7, 0x1186, 0x1166, 0x1166, 0x1186, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x0986, 0x4450, 0x230C, // 0x29F0 (10736) pixels +0x11E8, 0x11A7, 0x1146, 0x1124, 0x08C3, 0x0083, 0x0083, 0x0082, 0x0062, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x2A00 (10752) pixels +0x0082, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x00A3, 0x00C3, 0x08E3, 0x08E4, 0x0905, 0x0925, 0x1A09, // 0x2A10 (10768) pixels +0x2B2C, 0x2BAE, 0x1228, 0x0924, 0x1105, 0x1126, 0x4A85, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2A20 (10784) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xA182, 0x8002, 0x28E5, 0x0146, // 0x2A30 (10800) pixels +0x0967, 0x0967, 0x0967, 0x0966, 0x0946, 0x0946, 0x0966, 0x0966, 0x0966, 0x0967, 0x0967, 0x0967, 0x0967, 0x0967, 0x0967, 0x0966, // 0x2A40 (10816) pixels +0x0966, 0x0966, 0x0966, 0x0966, 0x0966, 0x0966, 0xD562, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2A50 (10832) pixels +0xFE41, 0xFE41, 0xFE85, 0xFF30, 0xFF76, 0xFF54, 0xFF30, 0xFEA9, 0xFE41, 0xFE41, 0xFE41, 0xDC42, 0x8802, 0x6947, 0x232C, 0x1228, // 0x2A60 (10848) pixels +0x11A7, 0x19A7, 0x1186, 0x1166, 0x1166, 0x1186, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x0905, 0x0147, 0x2BD0, 0x12AB, // 0x2A70 (10864) pixels +0x1229, 0x11C7, 0x1186, 0x0945, 0x08E4, 0x00C3, 0x08C4, 0x00A3, 0x00A3, 0x0082, 0x0082, 0x0082, 0x0062, 0x00A3, 0x0083, 0x0083, // 0x2A80 (10880) pixels +0x00A3, 0x00A3, 0x0083, 0x0082, 0x0082, 0x0082, 0x00A3, 0x00C3, 0x08E4, 0x0904, 0x0945, 0x1165, 0x11A6, 0x11A7, 0x1A28, 0x22EB, // 0x2A90 (10896) pixels +0x2C10, 0x3CB3, 0x0A29, 0x0125, 0x1105, 0x1125, 0xA463, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2AA0 (10912) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xB262, 0x8002, 0x3167, 0x11E8, // 0x2AB0 (10928) pixels +0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, // 0x2AC0 (10944) pixels +0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x11E9, 0x3288, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2AD0 (10960) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xED22, 0x8802, 0x6987, 0x1B4C, 0x1248, // 0x2AE0 (10976) pixels +0x11A6, 0x19A7, 0x1186, 0x1186, 0x1166, 0x1186, 0x00C4, 0x1125, 0x1125, 0x1125, 0x1125, 0x0905, 0x0187, 0x65F8, 0x66FB, 0x4D76, // 0x2AF0 (10992) pixels +0x238E, 0x1A6A, 0x11E8, 0x11A7, 0x1125, 0x0904, 0x08E4, 0x08C4, 0x00C3, 0x00A3, 0x0082, 0x0082, 0x0083, 0x00A3, 0x00A3, 0x00A3, // 0x2B00 (11008) pixels +0x08E4, 0x08E4, 0x0904, 0x08C4, 0x0083, 0x00A3, 0x0904, 0x0925, 0x0925, 0x0965, 0x11A7, 0x19C6, 0x11E7, 0x1A28, 0x22CA, 0x33AD, // 0x2B10 (11024) pixels +0x3CD3, 0x5638, 0x6E99, 0x11C7, 0x08E5, 0x7B64, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2B20 (11040) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xE4A2, 0x8002, 0x4167, 0x1A49, // 0x2B30 (11056) pixels +0x124A, 0x1229, 0x1229, 0x1A2A, 0x1A4A, 0x1A4A, 0x1A4A, 0x1A4A, 0x1A4A, 0x1A4A, 0x1A6A, 0x1A6A, 0x124A, 0x124A, 0x124A, 0x124A, // 0x2B40 (11072) pixels +0x124A, 0x124A, 0x124A, 0x124A, 0x32C9, 0xE5C2, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2B50 (11088) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x90C2, 0x7106, 0x234D, 0x1248, // 0x2B60 (11104) pixels +0x11A7, 0x19A7, 0x1186, 0x1166, 0x1186, 0x1986, 0x00E4, 0x1145, 0x1145, 0x1145, 0x1145, 0x00E4, 0x4451, 0x5EBA, 0x4E79, 0x4596, // 0x2B70 (11120) pixels +0x2BEF, 0x22CB, 0x1A29, 0x19E8, 0x1186, 0x1145, 0x1125, 0x0904, 0x08E4, 0x08C3, 0x0082, 0x0082, 0x08C4, 0x08E4, 0x08E4, 0x08E4, // 0x2B80 (11136) pixels +0x08E4, 0x08E4, 0x00C4, 0x00C3, 0x0082, 0x00A3, 0x08E4, 0x0904, 0x0904, 0x1125, 0x1145, 0x1186, 0x11A6, 0x19E8, 0x2269, 0x230B, // 0x2B90 (11152) pixels +0x2BEF, 0x3CB3, 0x5595, 0x1184, 0x83A3, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2BA0 (11168) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xC322, 0x6884, 0x124A, // 0x2BB0 (11184) pixels +0x126A, 0x126A, 0x126A, 0x126A, 0x124A, 0x124A, 0x124A, 0x124A, 0x124A, 0x124A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, // 0x2BC0 (11200) pixels +0x126A, 0x126A, 0x126A, 0x4B68, 0xE5C2, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2BD0 (11216) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0x90E2, 0x2A8B, 0x1A28, // 0x2BE0 (11232) pixels +0x19A7, 0x1987, 0x1166, 0x1986, 0x1166, 0x1987, 0x00C4, 0x1145, 0x1145, 0x1145, 0x1125, 0x08E4, 0x4CF3, 0x3D13, 0x3CD3, 0x2BF0, // 0x2BF0 (11248) pixels +0x22EB, 0x2269, 0x2228, 0x19E7, 0x1166, 0x1145, 0x0925, 0x0904, 0x08E4, 0x08C3, 0x00A3, 0x0082, 0x08C4, 0x08E4, 0x08E4, 0x08E4, // 0x2C00 (11264) pixels +0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0082, 0x0083, 0x0083, 0x0083, 0x0082, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x00A3, 0x1144, // 0x2C10 (11280) pixels +0x3204, 0x6303, 0xB505, 0xEDE2, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2C20 (11296) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0xA3C4, // 0x2C30 (11312) pixels +0x5388, 0x22CA, 0x1A8B, 0x1A8B, 0x128B, 0x128B, 0x128B, 0x128B, 0x128B, 0x1AAB, 0x128B, 0x128B, 0x128B, 0x128B, 0x128B, 0x330A, // 0x2C40 (11328) pixels +0x63C8, 0x9CA6, 0xC564, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2C50 (11344) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xCC02, 0x7345, // 0x2C60 (11360) pixels +0x3A65, 0x1166, 0x1146, 0x0925, 0x0905, 0x08E5, 0x08E4, 0x08E5, 0x08C4, 0x08C4, 0x08C4, 0x00A4, 0x1A8A, 0x22EC, 0x0125, 0x0104, // 0x2C70 (11376) pixels +0x00C4, 0x00C3, 0x00A3, 0x00A3, 0x0083, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0082, 0x0082, 0x0062, 0x0062, 0x00A3, 0x0082, 0x0082, // 0x2C80 (11392) pixels +0x0083, 0x0083, 0x0082, 0x0062, 0x0062, 0x0062, 0x0083, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x00A3, 0x08C3, 0x00A3, 0xEDE1, 0xFE41, // 0x2C90 (11408) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2CA0 (11424) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2CB0 (11440) pixels +0xFE41, 0xFE41, 0xF602, 0xE5C3, 0xC564, 0x2B0C, 0x1ACC, 0x1ACC, 0x1ACC, 0x1AED, 0x3B4B, 0xC564, 0xD5A3, 0xE5C3, 0xFE41, 0xFE41, // 0x2CC0 (11456) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2CD0 (11472) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2CE0 (11488) pixels +0xFE41, 0xFE41, 0xE5A2, 0xD562, 0x7B84, 0x1126, 0x1105, 0x1105, 0x1105, 0x0905, 0x0905, 0x00C4, 0x438F, 0x11C8, 0x1166, 0x1125, // 0x2CF0 (11504) pixels +0x1105, 0x08E4, 0x08E4, 0x08C4, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0082, 0x0082, 0x0061, 0x0062, 0x00A3, 0x0083, 0x0083, // 0x2D00 (11520) pixels +0x08A3, 0x0083, 0x0082, 0x0082, 0x0062, 0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x00A3, 0x08C3, 0x08A3, 0x08C3, 0xFE41, 0xFE41, // 0x2D10 (11536) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2D20 (11552) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2D30 (11568) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xF582, 0x7864, 0x68E6, 0x234E, 0x1B8F, 0x1B8F, 0x748A, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2D40 (11584) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2D50 (11600) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2D60 (11616) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xA202, 0x7043, 0x40A4, 0x1105, 0x0925, 0x0905, 0x0905, 0x00E4, 0x3B8E, 0x11C8, 0x1146, 0x1125, // 0x2D70 (11632) pixels +0x0905, 0x08E4, 0x08C4, 0x00C4, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x00A3, 0x0082, 0x0082, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x00A3, // 0x2D80 (11648) pixels +0x08A3, 0x0083, 0x0083, 0x0062, 0x0062, 0x0062, 0x0083, 0x0083, 0x00A3, 0x00A3, 0x00A3, 0x08C3, 0x08C3, 0x08C3, 0xFE41, 0xFE41, // 0x2D90 (11664) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2DA0 (11680) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2DB0 (11696) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xD3E2, 0x8802, 0x70A4, 0x1C31, 0x1C51, 0x1C51, 0xAD87, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2DC0 (11712) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2DD0 (11728) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2DE0 (11744) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0x8862, 0x8002, 0x30E5, 0x1126, 0x0926, 0x0926, 0x0926, 0x00E4, 0x33CF, 0x11C8, 0x1166, 0x0925, // 0x2DF0 (11760) pixels +0x0925, 0x0904, 0x08E4, 0x08C4, 0x00C3, 0x00C3, 0x00A3, 0x00A3, 0x00A3, 0x0082, 0x0082, 0x0062, 0x0083, 0x00A3, 0x0083, 0x0083, // 0x2E00 (11776) pixels +0x00A3, 0x00A3, 0x0083, 0x0062, 0x0062, 0x0083, 0x0083, 0x08A3, 0x00A3, 0x00A3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, 0xFE41, 0xFE41, // 0x2E10 (11792) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2E20 (11808) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2E30 (11824) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xAA02, 0x8802, 0x59E9, 0x1CD3, 0x1CD3, 0x1CD3, 0xE604, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2E40 (11840) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2E50 (11856) pixels +0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, 0xFE41, // 0x2E60 (11872) pixels +0xFE41, 0xFE41, 0xFE41, 0xE4A2, 0x8802, 0x8002, 0x1146, 0x1146, 0x0926, 0x0946, 0x0926, 0x0105, 0x33AF, 0x11E8, 0x1166, 0x1105, // 0x2E70 (11888) pixels +0x0904, 0x08E4, 0x08E4, 0x08C3, 0x00A3, 0x08A3, 0x00A3, 0x00A3, 0x08A3, 0x0083, 0x0082, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x00A3, // 0x2E80 (11904) pixels +0x00A3, 0x00A3, 0x00A3, 0x0062, 0x0062, 0x0083, 0x0083, 0x0883, 0x00A3, 0x00A3, 0x08C3, 0x08C3, 0x08C3, 0x08C3, 0x08E4, 0x0905, // 0x2E90 (11920) pixels +0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, // 0x2EA0 (11936) pixels +0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, // 0x2EB0 (11952) pixels +0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8002, 0x3BAF, 0x1D34, 0x1D14, 0x1D14, 0x1D14, 0x1CF4, 0x7884, 0x8802, 0x8802, 0x8802, // 0x2EC0 (11968) pixels +0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, // 0x2ED0 (11984) pixels +0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x8802, // 0x2EE0 (12000) pixels +0x8802, 0x8802, 0x8802, 0x8802, 0x8802, 0x6064, 0x1166, 0x1166, 0x1146, 0x1146, 0x1126, 0x0905, 0x33CE, 0x1208, 0x1186, 0x0925, // 0x2EF0 (12016) pixels +0x0925, 0x0904, 0x08E4, 0x08C4, 0x08A3, 0x08C3, 0x08A3, 0x08A3, 0x08A3, 0x0082, 0x0082, 0x0062, 0x0083, 0x00A3, 0x00A3, 0x00A3, // 0x2F00 (12032) pixels +0x0083, 0x0083, 0x0083, 0x0062, 0x0062, 0x0062, 0x0083, 0x08A3, 0x0883, 0x08A3, 0x08A3, 0x08A3, 0x08C3, 0x08C3, 0x08E4, 0x0904, // 0x2F10 (12048) pixels +0x0945, 0x0945, 0x334C, 0x0946, 0x00C4, 0x08E4, 0x08E4, 0x08E4, 0x00E4, 0x0905, 0x0905, 0x0105, 0x1126, 0x0926, 0x0946, 0x0987, // 0x2F20 (12064) pixels +0x1249, 0x2B2D, 0x4451, 0x34D2, 0x5618, 0x238F, 0x4D56, 0x2CD3, 0x2CF3, 0x34D3, 0x13AF, 0x02EC, 0x2534, 0x1D13, 0x1D13, 0x1D34, // 0x2F30 (12080) pixels +0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D35, 0x1D34, 0x1D54, 0x1D55, 0x1D55, // 0x2F40 (12096) pixels +0x1D55, 0x1D55, 0x1D55, 0x1D55, 0x1D55, 0x1D55, 0x1D55, 0x1D35, 0x1D55, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, // 0x2F50 (12112) pixels +0x1D35, 0x1D15, 0x1D14, 0x1D15, 0x1C92, 0x24D3, 0x3D96, 0x3D75, 0x3D55, 0x1C11, 0x55B7, 0x3D14, 0x2C71, 0x1B0C, 0x11C8, 0x1146, // 0x2F60 (12128) pixels +0x0925, 0x0925, 0x0905, 0x0905, 0x0905, 0x0905, 0x08E4, 0x00E4, 0x08E4, 0x08E4, 0x00C4, 0x0083, 0x338D, 0x11E8, 0x1186, 0x0945, // 0x2F70 (12144) pixels +0x0925, 0x0904, 0x08E4, 0x08E4, 0x08C3, 0x08C3, 0x00A3, 0x00A3, 0x08A3, 0x0082, 0x0082, 0x0062, 0x0083, 0x08A3, 0x0883, 0x0883, // 0x2F80 (12160) pixels +0x0083, 0x0083, 0x0083, 0x0082, 0x0062, 0x0062, 0x0083, 0x08A3, 0x08A3, 0x08A3, 0x08A3, 0x08C4, 0x08C3, 0x08C4, 0x08E4, 0x1104, // 0x2F90 (12176) pixels +0x0925, 0x0945, 0x332C, 0x0125, 0x0083, 0x00A3, 0x00A3, 0x08A3, 0x08A3, 0x08A3, 0x08A4, 0x00A4, 0x08A4, 0x08A4, 0x00C4, 0x00C4, // 0x2FA0 (12192) pixels +0x00C4, 0x00E3, 0x0166, 0x1ACB, 0x12AB, 0x09C8, 0x0A8A, 0x2430, 0x24D3, 0x24D3, 0x1CB3, 0x2D55, 0x2534, 0x2534, 0x1D54, 0x1D54, // 0x2FB0 (12208) pixels +0x1D54, 0x1D54, 0x1D54, 0x1D54, 0x2534, 0x2554, 0x1D54, 0x1D54, 0x2535, 0x2534, 0x1D35, 0x1D35, 0x1D34, 0x1D54, 0x1D35, 0x1D35, // 0x2FC0 (12224) pixels +0x1D55, 0x1D55, 0x1D55, 0x1D55, 0x2555, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x2535, 0x1D35, 0x2535, 0x1D15, // 0x2FD0 (12240) pixels +0x2515, 0x1D14, 0x1D14, 0x1D14, 0x1CF4, 0x2492, 0x030C, 0x0B6D, 0x2CD3, 0x238E, 0x0126, 0x0104, 0x00C4, 0x00C4, 0x00E4, 0x00A3, // 0x2FE0 (12256) pixels +0x00A3, 0x00A3, 0x00A3, 0x00A4, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0083, 0x0062, 0x2ACB, 0x1187, 0x1166, 0x0924, // 0x2FF0 (12272) pixels +0x0904, 0x08E4, 0x08C4, 0x08C4, 0x08C4, 0x08C3, 0x00A3, 0x00A3, 0x08A3, 0x0083, 0x0082, 0x0062, 0x0083, 0x08A3, 0x0883, 0x0883, // 0x3000 (12288) pixels +0x0082, 0x0082, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0082, 0x0082, 0x0082, 0x0082, 0x0083, 0x0083, 0x00A3, 0x08A3, 0x00A3, // 0x3010 (12304) pixels +0x08C4, 0x00A3, 0x19C8, 0x0945, 0x0905, 0x1125, 0x1125, 0x1126, 0x1125, 0x1125, 0x1146, 0x1126, 0x1146, 0x1146, 0x1166, 0x1187, // 0x3020 (12320) pixels +0x1187, 0x11C7, 0x19E8, 0x1A29, 0x1208, 0x09A7, 0x1ACC, 0x3471, 0x1C51, 0x0C31, 0x2514, 0x1D14, 0x1D34, 0x2534, 0x2534, 0x2534, // 0x3030 (12336) pixels +0x2535, 0x2535, 0x2535, 0x2535, 0x1D35, 0x1D35, 0x2535, 0x2535, 0x2535, 0x2535, 0x2534, 0x2535, 0x2535, 0x1D35, 0x1D34, 0x2535, // 0x3040 (12352) pixels +0x2535, 0x2535, 0x1D35, 0x1D35, 0x1D35, 0x1D55, 0x1D55, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D15, 0x1D35, // 0x3050 (12368) pixels +0x1D35, 0x1D35, 0x1D15, 0x1D35, 0x24F4, 0x1CD3, 0x2CF4, 0x2CB2, 0x2410, 0x1ACB, 0x0987, 0x0987, 0x0966, 0x0946, 0x0926, 0x0925, // 0x3060 (12384) pixels +0x0925, 0x0905, 0x0905, 0x08E5, 0x0905, 0x0905, 0x0904, 0x0904, 0x0905, 0x0905, 0x0925, 0x0905, 0x11A7, 0x00E4, 0x08E4, 0x08C4, // 0x3070 (12400) pixels +0x08A3, 0x00A3, 0x00A3, 0x00A3, 0x0062, 0x0082, 0x0062, 0x0082, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0063, 0x0063, // 0x3080 (12416) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0041, 0x0041, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x3090 (12432) pixels +0x0042, 0x0945, 0x11C7, 0x11A7, 0x11A7, 0x19C7, 0x19C7, 0x19C7, 0x19C7, 0x19C8, 0x19E8, 0x19E8, 0x19E8, 0x1A09, 0x1A09, 0x1A29, // 0x30A0 (12448) pixels +0x1A6A, 0x1A8A, 0x1ACB, 0x22EC, 0x1AEC, 0x0A69, 0x3471, 0x24B2, 0x24B2, 0x24D3, 0x24F4, 0x1D14, 0x1D14, 0x1D14, 0x2534, 0x2534, // 0x30B0 (12464) pixels +0x1D14, 0x2514, 0x2514, 0x2514, 0x1D34, 0x1D14, 0x1D14, 0x1D34, 0x2514, 0x1D14, 0x2535, 0x2535, 0x2535, 0x2535, 0x2535, 0x2514, // 0x30C0 (12480) pixels +0x1D34, 0x1D14, 0x1D14, 0x1D14, 0x1D35, 0x1D35, 0x1D35, 0x1D35, 0x1D34, 0x1D34, 0x1D34, 0x1D34, 0x1D15, 0x1D35, 0x1D35, 0x1D15, // 0x30D0 (12496) pixels +0x2514, 0x2514, 0x1D14, 0x1D14, 0x1CF4, 0x1CD3, 0x24B3, 0x13F0, 0x23CF, 0x23AE, 0x2BCF, 0x338E, 0x336E, 0x336E, 0x2B0D, 0x2B0C, // 0x30E0 (12512) pixels +0x2AEC, 0x2AAB, 0x2AAB, 0x2A8A, 0x226A, 0x226A, 0x2249, 0x2249, 0x2249, 0x2249, 0x2229, 0x2229, 0x2229, 0x19A7, 0x0082, 0x0082, // 0x30F0 (12528) pixels +0x0083, 0x0062, 0x0062, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0042, 0x0042, // 0x3100 (12544) pixels +0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0062, 0x0042, 0x0042, 0x0062, 0x0062, 0x0042, 0x0062, // 0x3110 (12560) pixels +0x0904, 0x2228, 0x1A49, 0x1A49, 0x1A49, 0x1A69, 0x228A, 0x228A, 0x228A, 0x22AA, 0x22CB, 0x22EC, 0x230C, 0x230C, 0x234D, 0x2B6D, // 0x3120 (12576) pixels +0x2B8E, 0x2BAE, 0x23AE, 0x2BEF, 0x2C0F, 0x3430, 0x1B6E, 0x136E, 0x1CB2, 0x1CB3, 0x24F3, 0x1CD4, 0x1CF4, 0x2514, 0x1D14, 0x1D14, // 0x3130 (12592) pixels +0x1D14, 0x1D14, 0x1D14, 0x1D14, 0x2514, 0x2514, 0x2514, 0x2514, 0x1D34, 0x1D34, 0x2535, 0x2535, 0x2535, 0x2535, 0x1D14, 0x2514, // 0x3140 (12608) pixels +0x1D14, 0x1D14, 0x1D14, 0x1D14, 0x1D15, 0x1D15, 0x1D35, 0x1D35, 0x1D34, 0x2535, 0x1D14, 0x1D14, 0x2515, 0x1D15, 0x1D14, 0x1D14, // 0x3150 (12624) pixels +0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1D14, 0x1CF3, 0x24B3, 0x1C10, 0x130D, 0x138E, 0x138E, 0x130C, 0x12EC, 0x12CB, 0x12AB, 0x128B, // 0x3160 (12640) pixels +0x0A6A, 0x0A49, 0x0A29, 0x0A08, 0x0A08, 0x09E8, 0x09E8, 0x09E8, 0x09C7, 0x09C7, 0x09C7, 0x09C7, 0x09A7, 0x11C7, 0x0986, 0x00A3, // 0x3170 (12656) pixels +0x0062, 0x0062, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, // 0x3180 (12672) pixels +0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0062, 0x0062, 0x0042, 0x0062, 0x0062, 0x0062, 0x0042, // 0x3190 (12688) pixels +0x19A7, 0x1A28, 0x1208, 0x1208, 0x1208, 0x1228, 0x1208, 0x1208, 0x1229, 0x1229, 0x124A, 0x126A, 0x128A, 0x0AAA, 0x12CB, 0x12CB, // 0x31A0 (12704) pixels +0x12EC, 0x132C, 0x132C, 0x134D, 0x136E, 0x138E, 0x1BAF, 0x2431, 0x1CB2, 0x24D3, 0x24D3, 0x1CF3, 0x1CD3, 0x1CF3, 0x1CF4, 0x24F4, // 0x31B0 (12720) pixels +0x24F4, 0x24F4, 0x24F4, 0x24F4, 0x1D14, 0x1D14, 0x1D14, 0x1D14, 0x1D14, 0x1D14, 0x2514, 0x1D14, 0x1D14, 0x1D14, 0x2514, 0x2514, // 0x31C0 (12736) pixels +0x1D14, 0x1D14, 0x1D14, 0x2514, 0x1D14, 0x1D14, 0x1CF4, 0x1D14, 0x1D14, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1D14, // 0x31D0 (12752) pixels +0x24F4, 0x24F4, 0x1D14, 0x2514, 0x24F4, 0x1CD3, 0x1CD3, 0x24B2, 0x24B2, 0x2471, 0x2471, 0x2471, 0x2450, 0x2430, 0x2410, 0x23EF, // 0x31E0 (12768) pixels +0x23EF, 0x23CF, 0x1B8E, 0x1B6D, 0x1B4D, 0x1B4C, 0x1B2C, 0x1B0C, 0x1AEB, 0x1AEB, 0x1ACB, 0x1ACB, 0x12AA, 0x1AAA, 0x22AA, 0x2289, // 0x31F0 (12784) pixels +0x0021, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, // 0x3200 (12800) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0041, 0x0041, 0x0041, 0x0041, 0x0042, 0x0042, 0x0042, 0x0041, 0x0062, 0x0062, 0x0062, 0x0041, // 0x3210 (12816) pixels +0x11E8, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8B, 0x1ACB, 0x1ACB, 0x1B0C, 0x232C, 0x1B4D, 0x236D, 0x23AE, 0x23AE, // 0x3220 (12832) pixels +0x23CF, 0x23EF, 0x240F, 0x2430, 0x2451, 0x1C51, 0x1C71, 0x24B2, 0x1CB2, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD4, 0x1CF4, 0x1CF4, // 0x3230 (12848) pixels +0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x24F4, 0x24F4, 0x24F4, 0x1D15, 0x1D15, 0x1D15, 0x1D15, 0x1D15, 0x1D15, // 0x3240 (12864) pixels +0x2514, 0x2514, 0x2514, 0x2514, 0x2514, 0x2514, 0x2514, 0x2514, 0x24F4, 0x1CF4, 0x1CF4, 0x1CD4, 0x1CD4, 0x24D4, 0x1CF4, 0x1CF4, // 0x3250 (12880) pixels +0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x24D4, 0x1CD4, 0x1CD3, 0x1CD3, 0x1C92, 0x1C71, 0x2451, 0x1C31, 0x1C30, 0x1C30, 0x1C10, 0x1BEF, // 0x3260 (12896) pixels +0x1BCF, 0x1BAE, 0x1B8E, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B2C, 0x1B0C, 0x1AEB, 0x1AEB, 0x12CA, 0x12CA, 0x12AA, 0x1AAA, 0x1A8A, 0x22AB, // 0x3270 (12912) pixels +0x0082, 0x0061, 0x0062, 0x0061, 0x0041, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, 0x0061, // 0x3280 (12928) pixels +0x0042, 0x0042, 0x0063, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0063, 0x0063, 0x0063, 0x0022, // 0x3290 (12944) pixels +0x2249, 0x1A8A, 0x1A89, 0x1A8A, 0x1A6A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1AAB, 0x1ACB, 0x1AEB, 0x1B0C, 0x1B4D, 0x236D, 0x1B8E, 0x23AE, // 0x32A0 (12960) pixels +0x1BCF, 0x23EF, 0x1BEF, 0x2430, 0x2451, 0x1C51, 0x1C71, 0x2492, 0x1CB2, 0x1CB3, 0x1CB3, 0x1CD3, 0x1CD3, 0x24D3, 0x24D4, 0x24D4, // 0x32B0 (12976) pixels +0x24F3, 0x24F3, 0x24F3, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CD4, 0x1CD4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, 0x1CF4, // 0x32C0 (12992) pixels +0x1CF3, 0x1CF3, 0x1CF3, 0x1CF3, 0x1CF3, 0x1CF3, 0x1CF3, 0x1CF3, 0x1CD4, 0x1CD4, 0x24D4, 0x24D4, 0x1CD4, 0x1CD4, 0x1CD3, 0x1CD4, // 0x32D0 (13008) pixels +0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x24D3, 0x24D3, 0x1CB2, 0x2472, 0x2451, 0x2431, 0x1C30, 0x1C31, 0x1C10, 0x1BF0, // 0x32E0 (13024) pixels +0x1BCF, 0x1BAE, 0x1B8E, 0x1B6E, 0x1B6D, 0x1B2D, 0x1B0C, 0x1AEC, 0x1AEB, 0x12CB, 0x12CA, 0x12CA, 0x12CA, 0x12AA, 0x1A8A, 0x22CA, // 0x32F0 (13040) pixels +0x0063, 0x0042, 0x0042, 0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, // 0x3300 (13056) pixels +0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0045, 0x0065, 0x0045, 0x0045, 0x0045, 0x0065, 0x0024, // 0x3310 (13072) pixels +0x228B, 0x1A8A, 0x1A8A, 0x1A89, 0x1A6A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1AAB, 0x1ACB, 0x1ACB, 0x1B0C, 0x1B2C, 0x1B4D, 0x1B6D, 0x1B8E, // 0x3320 (13088) pixels +0x1BAE, 0x1BCF, 0x1BCF, 0x1C0F, 0x1C30, 0x1C51, 0x1C51, 0x1C91, 0x2492, 0x24B2, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, // 0x3330 (13104) pixels +0x1CB3, 0x1CB3, 0x24D3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, // 0x3340 (13120) pixels +0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x24D3, 0x24D3, 0x1CD3, 0x1CD3, 0x1CB3, 0x1CD3, // 0x3350 (13136) pixels +0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB2, 0x24B2, 0x1C92, 0x1C51, 0x1C31, 0x1C10, 0x1C10, 0x1BEF, 0x1BCF, 0x1BAE, // 0x3360 (13152) pixels +0x1BAE, 0x1B6E, 0x1B6D, 0x1B6D, 0x1B4C, 0x1B0C, 0x1B0C, 0x1B0C, 0x1AEB, 0x1ACB, 0x12CA, 0x12AA, 0x12AA, 0x1AAA, 0x128A, 0x22CB, // 0x3370 (13168) pixels +0x0086, 0x0066, 0x0066, 0x0066, 0x0065, 0x0065, 0x0065, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0064, 0x0064, 0x0064, 0x0043, // 0x3380 (13184) pixels +0x0044, 0x0044, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0065, 0x0065, 0x0066, 0x0066, 0x0046, 0x0046, 0x0046, 0x0045, // 0x3390 (13200) pixels +0x11E8, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A8A, 0x1AAB, 0x1AAB, 0x1ACB, 0x1B0C, 0x1B0C, 0x1B2C, 0x1B4D, 0x1B6D, // 0x33A0 (13216) pixels +0x1B8E, 0x1BCE, 0x1BCF, 0x1BEF, 0x1C10, 0x1C30, 0x1C51, 0x1C71, 0x1C51, 0x2472, 0x2492, 0x1CB2, 0x1C92, 0x1C92, 0x1CB2, 0x1CB2, // 0x33B0 (13232) pixels +0x1C92, 0x1C92, 0x1CB2, 0x1CB2, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CB3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, // 0x33C0 (13248) pixels +0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x24B3, 0x24B3, 0x1CB3, 0x1CB3, 0x1CB2, 0x1CB2, // 0x33D0 (13264) pixels +0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C71, 0x1C31, 0x1C30, 0x1BF0, 0x1BEF, 0x1BCF, 0x1BAF, 0x1B8E, // 0x33E0 (13280) pixels +0x1B8E, 0x1B6D, 0x1B4D, 0x1B2D, 0x130C, 0x130C, 0x1AEC, 0x1AEC, 0x1AEB, 0x1ACB, 0x12CA, 0x12CA, 0x12AA, 0x12AA, 0x128A, 0x1A8A, // 0x33F0 (13296) pixels +0x0066, 0x0067, 0x0067, 0x0067, 0x0066, 0x0066, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, // 0x3400 (13312) pixels +0x0044, 0x0044, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0065, 0x0065, 0x0046, 0x0046, 0x0066, // 0x3410 (13328) pixels +0x0906, 0x222A, 0x1A29, 0x1228, 0x1A69, 0x1A6A, 0x1A8A, 0x1A8A, 0x1AAA, 0x1AAA, 0x1ACA, 0x1AEB, 0x12EB, 0x130B, 0x1B2C, 0x1B6D, // 0x3420 (13344) pixels +0x1B8D, 0x1BAE, 0x1BAE, 0x1BCE, 0x1BEF, 0x1C10, 0x1C30, 0x1C30, 0x1C51, 0x1C51, 0x1C71, 0x1C71, 0x1C71, 0x1C51, 0x1C72, 0x1C72, // 0x3430 (13360) pixels +0x1C72, 0x1C72, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, // 0x3440 (13376) pixels +0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C93, 0x1C93, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C92, 0x1C72, 0x1C72, 0x1C72, // 0x3450 (13392) pixels +0x1C71, 0x1C72, 0x1C71, 0x1C71, 0x1C71, 0x1C71, 0x1C71, 0x1C71, 0x1C51, 0x1C51, 0x1C10, 0x1BEF, 0x1BCF, 0x1BCF, 0x1BAE, 0x1B8E, // 0x3460 (13408) pixels +0x1B6E, 0x1B4D, 0x1B4D, 0x1B2C, 0x1B0C, 0x12EC, 0x1AEB, 0x1ACB, 0x1ACB, 0x1AAA, 0x128A, 0x128A, 0x1A8A, 0x228A, 0x2A8B, 0x0968, // 0x3470 (13424) pixels +0x0067, 0x0048, 0x0088, 0x0066, 0x0045, 0x0045, 0x0044, 0x0044, 0x0044, 0x0045, 0x0044, 0x0044, 0x0045, 0x0045, 0x0045, 0x0045, // 0x3480 (13440) pixels +0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0065, 0x0065, 0x0064, // 0x3490 (13456) pixels +0x0063, 0x0043, 0x0042, 0x00E4, 0x1A69, 0x1249, 0x126A, 0x1269, 0x126A, 0x128A, 0x12AA, 0x1ACB, 0x12EB, 0x130B, 0x1B2C, 0x132C, // 0x34A0 (13472) pixels +0x1B6D, 0x1B8E, 0x1B8E, 0x1BAE, 0x1BCF, 0x1BEF, 0x1C10, 0x1C10, 0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C51, 0x1C51, 0x1C51, 0x1C51, // 0x34B0 (13488) pixels +0x1C51, 0x1C71, 0x1C71, 0x1C72, 0x1C72, 0x1C72, 0x1C72, 0x1C72, 0x1C72, 0x1C72, 0x1C71, 0x1C71, 0x1C72, 0x1C72, 0x1C72, 0x1C72, // 0x34C0 (13504) pixels +0x1C72, 0x1C72, 0x1C71, 0x1C71, 0x1C72, 0x1C72, 0x1C72, 0x1C72, 0x1C72, 0x1C92, 0x1C92, 0x1C92, 0x1C72, 0x1C72, 0x1C72, 0x1C72, // 0x34D0 (13520) pixels +0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C31, 0x1C10, 0x1BEF, 0x1BCF, 0x1BAE, 0x1B8E, 0x1B6D, // 0x34E0 (13536) pixels +0x1B4D, 0x132D, 0x1B2C, 0x130C, 0x1AEC, 0x1AEC, 0x1ACB, 0x1AAB, 0x12CA, 0x1AAA, 0x1A8A, 0x22AB, 0x00A2, 0x0062, 0x0042, 0x0022, // 0x34F0 (13552) pixels +0x0065, 0x0887, 0x0887, 0x0046, 0x0045, 0x0045, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, // 0x3500 (13568) pixels +0x0045, 0x0045, 0x0065, 0x0065, 0x0044, 0x0044, 0x0044, 0x0044, 0x0045, 0x0045, 0x0045, 0x0065, 0x0085, 0x0064, 0x0063, 0x0062, // 0x3510 (13584) pixels +0x0042, 0x0083, 0x1166, 0x19A7, 0x1187, 0x1A29, 0x1A69, 0x1AAA, 0x1A8A, 0x1A8A, 0x128A, 0x1289, 0x12CB, 0x12EB, 0x1B2C, 0x1B4D, // 0x3520 (13600) pixels +0x1B6D, 0x1B6D, 0x134D, 0x1BAE, 0x1BAF, 0x1BCF, 0x1BEF, 0x1C0F, 0x1C10, 0x1C10, 0x1C10, 0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C30, // 0x3530 (13616) pixels +0x1C50, 0x1C50, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C71, 0x1C71, 0x1C51, 0x1C71, 0x1C71, 0x1C71, 0x1C92, 0x1C71, // 0x3540 (13632) pixels +0x1C71, 0x1C91, 0x1C71, 0x1C71, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C31, // 0x3550 (13648) pixels +0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C30, 0x1C10, 0x1C10, 0x1C0F, 0x1BCF, 0x1BCE, 0x136D, 0x1B8D, 0x1B6D, // 0x3560 (13664) pixels +0x1B4D, 0x1B4D, 0x1B2C, 0x1B0C, 0x12EB, 0x1AEB, 0x1ACB, 0x0A49, 0x0A89, 0x1269, 0x09C7, 0x0966, 0x0925, 0x1104, 0x0021, 0x0041, // 0x3570 (13680) pixels +0x0042, 0x0043, 0x0885, 0x0887, 0x0087, 0x0066, 0x0065, 0x0085, 0x0065, 0x0065, 0x0045, 0x0065, 0x0065, 0x0065, 0x0065, 0x0044, // 0x3580 (13696) pixels +0x0045, 0x0045, 0x0045, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0886, 0x0886, 0x0063, 0x0063, 0x0062, 0x0041, // 0x3590 (13712) pixels +0x0082, 0x1945, 0x0905, 0x08E5, 0x00C4, 0x00C4, 0x0125, 0x1A69, 0x1A8A, 0x128A, 0x1ACB, 0x1ACB, 0x12CB, 0x12EB, 0x1B2C, 0x1B4D, // 0x35A0 (13728) pixels +0x1B4D, 0x0AEB, 0x136D, 0x1BAE, 0x1BAE, 0x1BEF, 0x1BEF, 0x1BEF, 0x1C10, 0x1BF0, 0x1C10, 0x1C10, 0x1C0F, 0x1C30, 0x1C10, 0x1C30, // 0x35B0 (13744) pixels +0x1C30, 0x1C50, 0x1C30, 0x1C50, 0x1C51, 0x1C51, 0x1C31, 0x1C31, 0x1C51, 0x1C51, 0x1C71, 0x2492, 0x24B2, 0x1CB2, 0x1CB2, 0x1CB2, // 0x35C0 (13760) pixels +0x1CB2, 0x1CB2, 0x1CB2, 0x24D2, 0x1C71, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C51, 0x1C31, 0x1C31, 0x1C31, 0x1C31, 0x1C31, 0x1C31, // 0x35D0 (13776) pixels +0x1C10, 0x1C10, 0x1C10, 0x1C10, 0x1C10, 0x1C10, 0x1C10, 0x1C10, 0x1BF0, 0x1BF0, 0x1BEF, 0x1BAF, 0x1B8E, 0x1B8E, 0x0ACB, 0x236D, // 0x35E0 (13792) pixels +0x234D, 0x234D, 0x1B2C, 0x1B0B, 0x12EB, 0x130B, 0x1B0B, 0x1B0B, 0x22CB, 0x22AA, 0x11A7, 0x0905, 0x2209, 0x2208, 0x1166, 0x0082, // 0x35F0 (13808) pixels +0x0042, 0x0041, 0x0042, 0x0064, 0x08E8, 0x08E8, 0x0065, 0x0066, 0x0066, 0x0066, 0x0066, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, // 0x3600 (13824) pixels +0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0086, 0x08C6, 0x08A5, 0x0083, 0x0042, 0x0042, 0x0021, 0x08E4, // 0x3610 (13840) pixels +0x1166, 0x0905, 0x08E5, 0x2269, 0x2269, 0x2269, 0x1A49, 0x1208, 0x228A, 0x1A8A, 0x1A89, 0x1ACA, 0x1AAB, 0x1B0B, 0x1B2C, 0x1B2C, // 0x3620 (13856) pixels +0x12AB, 0x12EB, 0x23CE, 0x1BAE, 0x1BAE, 0x1BCF, 0x1BCF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1C0F, 0x1C0F, 0x1C10, 0x1C10, // 0x3630 (13872) pixels +0x1C30, 0x1C30, 0x2430, 0x2430, 0x1C30, 0x1C30, 0x2431, 0x2431, 0x1C31, 0x1C10, 0x1C71, 0x24B2, 0x24D2, 0x24D2, 0x1CB3, 0x1CB3, // 0x3640 (13888) pixels +0x1CD3, 0x1CD3, 0x1CD3, 0x1CD3, 0x2492, 0x1430, 0x1C51, 0x1C31, 0x1C51, 0x1C31, 0x1C31, 0x1C31, 0x1C31, 0x1C31, 0x1C30, 0x1C10, // 0x3650 (13904) pixels +0x1C10, 0x1C30, 0x1C10, 0x1C10, 0x1C10, 0x1BEF, 0x1BEF, 0x1BCF, 0x1BEF, 0x1BCF, 0x1BAF, 0x1BAE, 0x1B8E, 0x238E, 0x1B4C, 0x0269, // 0x3660 (13920) pixels +0x01E7, 0x01E7, 0x230C, 0x1B2C, 0x1B0C, 0x1AEB, 0x1ACB, 0x01A7, 0x0966, 0x00E4, 0x0105, 0x0945, 0x0125, 0x0104, 0x0905, 0x19A7, // 0x3670 (13936) pixels +0x08E4, 0x0042, 0x0042, 0x0042, 0x0043, 0x0085, 0x08E7, 0x0086, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, 0x0065, // 0x3680 (13952) pixels +0x0063, 0x0063, 0x0063, 0x0063, 0x0043, 0x0043, 0x0063, 0x0043, 0x08C5, 0x0064, 0x0042, 0x0042, 0x0042, 0x0062, 0x1925, 0x1966, // 0x3690 (13968) pixels +0x0105, 0x0925, 0x0105, 0x0145, 0x0986, 0x11E7, 0x09A7, 0x0986, 0x00E5, 0x0104, 0x22AA, 0x1AEB, 0x1ACB, 0x1B0B, 0x1B0B, 0x1B0C, // 0x36A0 (13984) pixels +0x1B0C, 0x1B6D, 0x1B6D, 0x1B8E, 0x1B8E, 0x1BAE, 0x1BCE, 0x1BCE, 0x1BCF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, // 0x36B0 (14000) pixels +0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BF0, 0x1BF0, 0x1BF0, 0x1C10, 0x13CF, 0x2471, 0x1CB2, 0x1CB2, 0x1CB2, 0x1CB2, 0x1CB3, // 0x36C0 (14016) pixels +0x1CB3, 0x1CB3, 0x1CB3, 0x1CD2, 0x2492, 0x13AF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1C10, 0x1C10, 0x1BF0, 0x1C10, // 0x36D0 (14032) pixels +0x1BF0, 0x2410, 0x1BF0, 0x1BEF, 0x1BCF, 0x1BEF, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BAF, 0x1BAE, 0x1BAE, 0x1B8E, 0x1B8E, 0x1B6D, 0x234D, // 0x36E0 (14048) pixels +0x234C, 0x234C, 0x1B2C, 0x1B0B, 0x1ACB, 0x22AB, 0x11E8, 0x1209, 0x11E8, 0x11C8, 0x1A29, 0x1A08, 0x19E8, 0x19C7, 0x1186, 0x1166, // 0x36F0 (14064) pixels +0x1125, 0x1146, 0x0063, 0x0042, 0x0042, 0x0042, 0x0084, 0x08A5, 0x0063, 0x0063, 0x0063, 0x0043, 0x0062, 0x0062, 0x0062, 0x0062, // 0x3700 (14080) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0063, 0x0042, 0x0042, 0x0042, 0x0042, 0x0062, 0x0042, 0x0062, 0x1125, 0x1125, 0x08E4, // 0x3710 (14096) pixels +0x0104, 0x11C7, 0x1A08, 0x19E8, 0x0966, 0x0145, 0x1A29, 0x1229, 0x11E8, 0x09A7, 0x0987, 0x0125, 0x1208, 0x1ACB, 0x0A29, 0x0187, // 0x3720 (14112) pixels +0x12EC, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B8D, 0x1B8E, 0x1B8E, 0x1B8E, 0x1BAE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1BCE, 0x1BCF, 0x1BCF, // 0x3730 (14128) pixels +0x1BCF, 0x1BCF, 0x1BCE, 0x1BCF, 0x1BCF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x13AE, 0x2430, 0x2471, 0x2C92, 0x2492, 0x2C92, 0x2CB2, // 0x3740 (14144) pixels +0x2C92, 0x2C92, 0x2C92, 0x2CB2, 0x2451, 0x138D, 0x1BEF, 0x1BEF, 0x1BCF, 0x1BEF, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BCF, // 0x3750 (14160) pixels +0x23EF, 0x23EF, 0x23EF, 0x1BAF, 0x1BCE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1B8E, 0x1B8E, 0x1B8E, 0x1B8E, 0x1B6E, 0x1B6D, 0x1B4D, 0x1B4C, // 0x3760 (14176) pixels +0x1B2B, 0x12EB, 0x1289, 0x1A8A, 0x1249, 0x0166, 0x0146, 0x1208, 0x1A69, 0x1A49, 0x1229, 0x01A6, 0x0946, 0x0925, 0x0905, 0x00C3, // 0x3770 (14192) pixels +0x00A3, 0x1145, 0x1146, 0x0083, 0x0041, 0x0041, 0x0042, 0x0042, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, // 0x3780 (14208) pixels +0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0062, 0x0042, 0x0041, 0x0042, 0x0061, 0x0042, 0x0062, 0x1104, 0x0904, 0x0904, 0x0925, // 0x3790 (14224) pixels +0x19A7, 0x11E7, 0x19E8, 0x19E8, 0x0986, 0x1208, 0x1A8A, 0x1A8A, 0x1A8A, 0x1A29, 0x11C8, 0x0987, 0x0A08, 0x12AA, 0x232C, 0x232C, // 0x37A0 (14240) pixels +0x1B2D, 0x1B4C, 0x1B4D, 0x134D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B8D, 0x1B8D, 0x1B8D, 0x1B8D, 0x1B8E, 0x1BAE, 0x1BAE, 0x1BAE, // 0x37B0 (14256) pixels +0x1BAE, 0x1BAE, 0x1BAE, 0x1BCE, 0x1BCE, 0x1BCF, 0x1BCF, 0x1BCE, 0x1BEF, 0x1BEF, 0x134D, 0x0ACB, 0x02AA, 0x0AAA, 0x0ACB, 0x0ACB, // 0x37C0 (14272) pixels +0x0ACB, 0x0ACB, 0x0AAA, 0x02AB, 0x0AEC, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BEF, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BCF, // 0x37D0 (14288) pixels +0x1BCE, 0x1BCE, 0x1BAE, 0x1BAE, 0x1B8E, 0x1B8D, 0x1B8D, 0x1B8D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4D, 0x1B4C, 0x1B4C, // 0x37E0 (14304) pixels +0x1B2B, 0x1B0B, 0x09E7, 0x09C7, 0x11C7, 0x1A29, 0x1229, 0x1A09, 0x1A49, 0x1A49, 0x1A29, 0x1248, 0x1A08, 0x11E7, 0x19E8, 0x11A7, // 0x37F0 (14320) pixels +0x1166, 0x1166, 0x1966, 0x1946, 0x08A3, 0x0042, 0x0042, 0x0042, 0x0041, 0x0820, 0x0041, 0x0041, 0x0061, 0x0061, 0x0061, 0x0041, // 0x3800 (14336) pixels +0x0083, 0x0083, 0x0083, 0x0083, 0x0082, 0x0082, 0x0062, 0x0062, 0x0042, 0x0042, 0x00A3, 0x1925, 0x1145, 0x1165, 0x0945, 0x1186, // 0x3810 (14352) pixels +0x11A7, 0x0986, 0x0125, 0x11E7, 0x1A89, 0x1A69, 0x1A89, 0x0145, 0x01A7, 0x09C7, 0x09C7, 0x09C7, 0x09C7, 0x1269, 0x1AEB, 0x132C, // 0x3820 (14368) pixels +0x1B2C, 0x1B4C, 0x134C, 0x134C, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B8D, 0x1B8E, 0x1B8E, 0x1BAE, // 0x3830 (14384) pixels +0x1BAE, 0x1BAE, 0x1BAE, 0x23CE, 0x1BCE, 0x1BCF, 0x1BCF, 0x1BCF, 0x1BEF, 0x23EF, 0x240F, 0x2410, 0x23EF, 0x23EF, 0x23EF, 0x23F0, // 0x3840 (14400) pixels +0x23EF, 0x2BEF, 0x23EF, 0x23EF, 0x23CF, 0x1BCF, 0x23CF, 0x1BCE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1BAE, 0x1B8E, 0x1B8E, // 0x3850 (14416) pixels +0x1B8E, 0x1B8E, 0x1B8E, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4C, // 0x3860 (14432) pixels +0x1B0B, 0x1AEB, 0x1ACB, 0x128A, 0x1269, 0x1AAA, 0x1AAA, 0x1289, 0x09C7, 0x0166, 0x1208, 0x1A69, 0x1248, 0x11E7, 0x1A08, 0x11E8, // 0x3870 (14448) pixels +0x1166, 0x0945, 0x1146, 0x0945, 0x00E4, 0x0062, 0x00A3, 0x0000, 0x0861, 0x08A3, 0x1144, 0x1125, 0x0041, 0x0062, 0x0062, 0x00A3, // 0x3880 (14464) pixels +0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1125, 0x1105, 0x1104, 0x10E5, 0x00A3, 0x1104, 0x1966, 0x1166, 0x1166, 0x1186, 0x19C7, // 0x3890 (14480) pixels +0x11E8, 0x11A7, 0x0966, 0x11E7, 0x1A49, 0x1248, 0x1228, 0x1228, 0x1229, 0x22AA, 0x1AAA, 0x1A8A, 0x1A6A, 0x1A8A, 0x1AEB, 0x1B0C, // 0x38A0 (14496) pixels +0x1B2C, 0x1B2C, 0x1B4D, 0x1B4C, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, 0x134D, // 0x38B0 (14512) pixels +0x134D, 0x134D, 0x1B6D, 0x1B6E, 0x1B8E, 0x1B8E, 0x1B8E, 0x1B8E, 0x136D, 0x1B8E, 0x136D, 0x136D, 0x1B8E, 0x1B8E, 0x1B8E, 0x1B6E, // 0x38C0 (14528) pixels +0x1B6D, 0x1B6D, 0x1B8D, 0x1B8D, 0x1B6E, 0x1B6D, 0x1B6D, 0x1B6E, 0x1B6E, 0x1B8E, 0x1B8E, 0x1B8E, 0x1B6E, 0x1B8E, 0x1B6D, 0x1B6D, // 0x38D0 (14544) pixels +0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B2C, 0x1B2C, // 0x38E0 (14560) pixels +0x1AEC, 0x1ACB, 0x1ACB, 0x1ACB, 0x0A48, 0x0A69, 0x128A, 0x1A8A, 0x1A49, 0x11C7, 0x11C7, 0x1229, 0x1208, 0x0986, 0x0145, 0x11C7, // 0x38F0 (14576) pixels +0x11C7, 0x11A7, 0x0986, 0x0945, 0x0104, 0x0945, 0x19A6, 0x11A6, 0x1166, 0x1186, 0x1186, 0x1166, 0x1186, 0x1125, 0x1125, 0x1125, // 0x3900 (14592) pixels +0x1125, 0x1125, 0x1125, 0x1125, 0x1145, 0x1166, 0x1966, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x0965, 0x11C7, // 0x3910 (14608) pixels +0x11E7, 0x11C7, 0x19E8, 0x1208, 0x1228, 0x1228, 0x1A69, 0x1269, 0x1289, 0x1269, 0x1269, 0x1269, 0x1269, 0x128A, 0x1ACB, 0x1AEB, // 0x3920 (14624) pixels +0x1B0C, 0x1B2C, 0x1B2C, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, // 0x3930 (14640) pixels +0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B6D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, // 0x3940 (14656) pixels +0x1B6D, 0x1B6D, 0x1B6D, 0x1B8D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B8D, 0x1B8D, 0x1B6D, 0x1B6D, // 0x3950 (14672) pixels +0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x130C, 0x1B0C, // 0x3960 (14688) pixels +0x12EB, 0x12CA, 0x1AAA, 0x1AAA, 0x1269, 0x1269, 0x1269, 0x1249, 0x1249, 0x1A08, 0x1208, 0x1208, 0x11E7, 0x11C7, 0x11A7, 0x0986, // 0x3970 (14704) pixels +0x11A6, 0x11A6, 0x0966, 0x0945, 0x0965, 0x0965, 0x0965, 0x1186, 0x1166, 0x1145, 0x1186, 0x1145, 0x1166, 0x1966, 0x1145, 0x1146, // 0x3980 (14720) pixels +0x1145, 0x1145, 0x1145, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x0986, 0x11C7, // 0x3990 (14736) pixels +0x11C7, 0x19C8, 0x11C7, 0x11E7, 0x09C7, 0x11E7, 0x09E7, 0x1248, 0x1249, 0x1249, 0x1249, 0x1249, 0x126A, 0x128A, 0x12AA, 0x1ACB, // 0x39A0 (14752) pixels +0x1AEB, 0x12EB, 0x1AEB, 0x130B, 0x130C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B4C, 0x1B4C, 0x1B4C, 0x1B4C, // 0x39B0 (14768) pixels +0x1B4C, 0x1B4C, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B6D, 0x1B8D, 0x1B8D, 0x1B6D, 0x1B6D, 0x1B6D, // 0x39C0 (14784) pixels +0x1B6D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B6D, 0x1B4D, 0x1B6D, 0x1B6D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x134C, 0x134C, 0x1B4C, 0x1B4D, // 0x39D0 (14800) pixels +0x1B4C, 0x1B4C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B0C, 0x1B0C, 0x130B, 0x1B0C, 0x1B0C, 0x130B, 0x12EB, 0x1B0B, 0x1AEB, 0x12EB, 0x12EB, // 0x39E0 (14816) pixels +0x12CA, 0x12AA, 0x128A, 0x128A, 0x128A, 0x1A8A, 0x1269, 0x1269, 0x1229, 0x1228, 0x1208, 0x11E8, 0x11E7, 0x11C7, 0x11C7, 0x11C7, // 0x39F0 (14832) pixels +0x1146, 0x0104, 0x1166, 0x0124, 0x0925, 0x0124, 0x0985, 0x11A6, 0x1145, 0x1166, 0x1166, 0x1986, 0x1166, 0x1146, 0x1146, 0x1146, // 0x3A00 (14848) pixels +0x1146, 0x1146, 0x1146, 0x1166, 0x1146, 0x1166, 0x1146, 0x1146, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x11A6, 0x11A6, 0x11A7, // 0x3A10 (14864) pixels +0x11A7, 0x11A7, 0x0986, 0x09A7, 0x11E7, 0x11E8, 0x1208, 0x09C7, 0x09E8, 0x1228, 0x1269, 0x1249, 0x128A, 0x12AA, 0x12AA, 0x12AA, // 0x3A20 (14880) pixels +0x12AA, 0x12CA, 0x12CB, 0x12CB, 0x12CB, 0x12EB, 0x12EB, 0x1AEB, 0x1AEB, 0x1AEC, 0x130C, 0x130C, 0x130C, 0x130C, 0x1B0C, 0x1B0C, // 0x3A30 (14896) pixels +0x130C, 0x1B2C, 0x132C, 0x1B2C, 0x1B2C, 0x1B4C, 0x1B4C, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, 0x1B4D, // 0x3A40 (14912) pixels +0x1B4D, 0x1B6D, 0x1B4D, 0x1B4C, 0x1B4C, 0x1B4C, 0x1B4C, 0x1B4C, 0x1B4C, 0x1B4D, 0x1B4C, 0x132C, 0x132C, 0x132C, 0x1B2C, 0x1B2C, // 0x3A50 (14928) pixels +0x1B2C, 0x1B2C, 0x1B0C, 0x1B0B, 0x1AEB, 0x1AEB, 0x12EB, 0x1AEB, 0x12EB, 0x12EB, 0x12EB, 0x12EA, 0x12CB, 0x12CB, 0x12CA, 0x12CA, // 0x3A60 (14944) pixels +0x12CA, 0x12AA, 0x128A, 0x12AA, 0x1289, 0x1249, 0x1249, 0x1249, 0x1228, 0x1208, 0x11C7, 0x11C7, 0x1208, 0x11E7, 0x09C7, 0x11E7, // 0x3A70 (14960) pixels +0x11A6, 0x0945, 0x1186, 0x1165, 0x0945, 0x0124, 0x0124, 0x1186, 0x1966, 0x1966, 0x1166, 0x1945, 0x1166, 0x1166, 0x1146, 0x1146, // 0x3A80 (14976) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, 0x1146, 0x1146, 0x1166, 0x1166, 0x1166, 0x1966, 0x1186, 0x11A6, 0x11A6, 0x11A7, // 0x3A90 (14992) pixels +0x11A7, 0x11A7, 0x19C7, 0x19E8, 0x1A49, 0x1A69, 0x1A49, 0x09C7, 0x1228, 0x1249, 0x1A69, 0x1269, 0x128A, 0x1AAA, 0x12AA, 0x1AAA, // 0x3AA0 (15008) pixels +0x12AA, 0x1AAA, 0x12CA, 0x12CA, 0x12AA, 0x12AB, 0x12AA, 0x12CB, 0x12CB, 0x12CB, 0x12EB, 0x12EB, 0x12EB, 0x12EB, 0x12EB, 0x12EB, // 0x3AB0 (15024) pixels +0x12EB, 0x12EC, 0x12EC, 0x130C, 0x130C, 0x130C, 0x130C, 0x130C, 0x1B2C, 0x1B2C, 0x1B2C, 0x1B2C, 0x132C, 0x132C, 0x132C, 0x132C, // 0x3AC0 (15040) pixels +0x132C, 0x132C, 0x132C, 0x132C, 0x130C, 0x130C, 0x130C, 0x130C, 0x130C, 0x130C, 0x1B2C, 0x130C, 0x130C, 0x130C, 0x1B0C, 0x1B0C, // 0x3AD0 (15056) pixels +0x130B, 0x130B, 0x1B0C, 0x1B0C, 0x1B0B, 0x1B0B, 0x1AEB, 0x1AEB, 0x1AEB, 0x1AEB, 0x1ACB, 0x12CB, 0x1ACB, 0x1ACB, 0x1ACA, 0x12CA, // 0x3AE0 (15072) pixels +0x1ACA, 0x1AAA, 0x128A, 0x128A, 0x1289, 0x1249, 0x09E8, 0x1A49, 0x1A69, 0x1A49, 0x09C7, 0x09A6, 0x1A28, 0x11E8, 0x11C7, 0x11C7, // 0x3AF0 (15088) pixels +0x11A6, 0x1186, 0x11A6, 0x1146, 0x0104, 0x1166, 0x0124, 0x1966, 0x1166, 0x1945, 0x1966, 0x1146, 0x1966, 0x1946, 0x1946, 0x1946, // 0x3B00 (15104) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1186, 0x1186, 0x11A6, // 0x3B10 (15120) pixels +0x0986, 0x11A7, 0x11C7, 0x11E8, 0x1208, 0x1A08, 0x1A08, 0x09C7, 0x1228, 0x1249, 0x1A69, 0x1289, 0x1A8A, 0x128A, 0x128A, 0x128A, // 0x3B20 (15136) pixels +0x128A, 0x128A, 0x128A, 0x128A, 0x1AAA, 0x1AAB, 0x1AAB, 0x1AAB, 0x1ACB, 0x12CB, 0x12CB, 0x12EB, 0x12EB, 0x12EB, 0x12EB, 0x12EB, // 0x3B30 (15152) pixels +0x12EB, 0x1AEB, 0x1AEB, 0x1AEB, 0x1AEB, 0x12EB, 0x1B0B, 0x1B0B, 0x1AEC, 0x1B0C, 0x1B0C, 0x1B0C, 0x1B0C, 0x130C, 0x130C, 0x130C, // 0x3B40 (15168) pixels +0x130C, 0x130C, 0x130C, 0x1B0C, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, 0x1AEC, // 0x3B50 (15184) pixels +0x1AEB, 0x12EB, 0x1AEB, 0x12EB, 0x1ACB, 0x1ACB, 0x1ACB, 0x1ACB, 0x1AAA, 0x1ACA, 0x12AA, 0x12AA, 0x12AA, 0x12AA, 0x128A, 0x128A, // 0x3B60 (15200) pixels +0x128A, 0x128A, 0x128A, 0x128A, 0x1249, 0x1249, 0x1208, 0x1229, 0x1A48, 0x1A49, 0x09C7, 0x11E7, 0x11C7, 0x11E8, 0x11C7, 0x1186, // 0x3B70 (15216) pixels +0x1185, 0x1166, 0x1186, 0x11A6, 0x00E4, 0x1986, 0x0104, 0x1966, 0x1966, 0x1165, 0x1966, 0x1966, 0x1946, 0x1146, 0x1146, 0x1946, // 0x3B80 (15232) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, 0x0925, 0x0925, 0x1146, 0x1166, 0x1166, 0x1186, // 0x3B90 (15248) pixels +0x1166, 0x1186, 0x1186, 0x1187, 0x11A7, 0x11C7, 0x11A7, 0x11C7, 0x1228, 0x1249, 0x1249, 0x1269, 0x126A, 0x1269, 0x1269, 0x1269, // 0x3BA0 (15264) pixels +0x1269, 0x1269, 0x126A, 0x1269, 0x128A, 0x1A8A, 0x1A8A, 0x1AAA, 0x12AA, 0x12AB, 0x12CB, 0x1AEC, 0x1AEB, 0x12EB, 0x1AEB, 0x1AEB, // 0x3BB0 (15280) pixels +0x12EB, 0x12EB, 0x1ACB, 0x1ACB, 0x12CB, 0x12CB, 0x12EB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, // 0x3BC0 (15296) pixels +0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, // 0x3BD0 (15312) pixels +0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x1ACB, 0x1ACB, 0x1ACB, 0x12AB, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x1269, 0x1269, // 0x3BE0 (15328) pixels +0x1269, 0x1269, 0x1249, 0x1249, 0x1229, 0x1229, 0x1208, 0x09E8, 0x11E8, 0x11E8, 0x11E8, 0x11C7, 0x11A6, 0x11A7, 0x0966, 0x0965, // 0x3BF0 (15344) pixels +0x1186, 0x11A6, 0x1186, 0x1186, 0x11A6, 0x1145, 0x1966, 0x1966, 0x1146, 0x1166, 0x1166, 0x1166, 0x1146, 0x1145, 0x1146, 0x1146, // 0x3C00 (15360) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1125, 0x1125, 0x1146, 0x1146, 0x1166, 0x1166, // 0x3C10 (15376) pixels +0x1166, 0x1186, 0x1166, 0x1166, 0x1166, 0x1187, 0x11A7, 0x11E7, 0x1208, 0x1229, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, // 0x3C20 (15392) pixels +0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x126A, 0x126A, 0x1269, 0x128A, 0x12AA, 0x12AB, 0x1ACB, 0x1ACB, 0x1ACB, 0x1ACC, 0x1ACC, // 0x3C30 (15408) pixels +0x1ACB, 0x1ACB, 0x1ACB, 0x1ACB, 0x12CB, 0x12AB, 0x12AB, 0x12CB, 0x12CB, 0x12CB, 0x12CB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, // 0x3C40 (15424) pixels +0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, // 0x3C50 (15440) pixels +0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x12AB, 0x1AAB, 0x12AB, 0x128A, 0x128A, 0x128A, 0x126A, 0x126A, 0x1249, 0x1249, 0x1269, 0x1249, // 0x3C60 (15456) pixels +0x1249, 0x1249, 0x1249, 0x1249, 0x1229, 0x1228, 0x1208, 0x11C7, 0x0986, 0x09A6, 0x11A6, 0x0945, 0x0945, 0x0985, 0x11A6, 0x1145, // 0x3C70 (15472) pixels +0x11A6, 0x1166, 0x1966, 0x1166, 0x1966, 0x1966, 0x1966, 0x1966, 0x1966, 0x1166, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, // 0x3C80 (15488) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, // 0x3C90 (15504) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x1187, 0x11A7, 0x11E7, 0x1208, 0x0A08, 0x0A28, 0x1208, 0x0A28, 0x1228, 0x1228, 0x1228, // 0x3CA0 (15520) pixels +0x1229, 0x1249, 0x1249, 0x1249, 0x1269, 0x1269, 0x1269, 0x1269, 0x126A, 0x126A, 0x128A, 0x126A, 0x128A, 0x12AA, 0x12AB, 0x12AB, // 0x3CB0 (15536) pixels +0x12AB, 0x12AA, 0x12AA, 0x12AB, 0x12AA, 0x12AA, 0x12AA, 0x1AAB, 0x12AA, 0x12AB, 0x128A, 0x12AA, 0x12AA, 0x12AA, 0x12AA, 0x12AA, // 0x3CC0 (15552) pixels +0x12AA, 0x12AA, 0x12AA, 0x12AA, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, // 0x3CD0 (15568) pixels +0x128A, 0x128A, 0x128A, 0x128A, 0x1A8A, 0x1A8A, 0x128A, 0x126A, 0x1269, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, // 0x3CE0 (15584) pixels +0x1228, 0x1228, 0x1228, 0x1228, 0x1208, 0x1208, 0x1208, 0x11E8, 0x11C7, 0x1185, 0x11A6, 0x0124, 0x0104, 0x0104, 0x0124, 0x1986, // 0x3CF0 (15600) pixels +0x1166, 0x1166, 0x1966, 0x1966, 0x1966, 0x1966, 0x1966, 0x1166, 0x1166, 0x1966, 0x1146, 0x1166, 0x1146, 0x1145, 0x1146, 0x1146, // 0x3D00 (15616) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, // 0x3D10 (15632) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1166, 0x11A7, 0x11C7, 0x11E7, 0x0A08, 0x0A08, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, // 0x3D20 (15648) pixels +0x1229, 0x1229, 0x1229, 0x1229, 0x1229, 0x1249, 0x1249, 0x1249, 0x1249, 0x1269, 0x1249, 0x1269, 0x126A, 0x126A, 0x126A, 0x126A, // 0x3D30 (15664) pixels +0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x128A, 0x126A, 0x1269, 0x1269, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, // 0x3D40 (15680) pixels +0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, // 0x3D50 (15696) pixels +0x1269, 0x1269, 0x1269, 0x1269, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1229, 0x1228, 0x1228, // 0x3D60 (15712) pixels +0x1208, 0x1228, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x11E8, 0x11E8, 0x1186, 0x11A6, 0x0945, 0x1186, 0x0124, 0x1146, 0x1965, // 0x3D70 (15728) pixels +0x1166, 0x2166, 0x1186, 0x1186, 0x1166, 0x1166, 0x1966, 0x1166, 0x1966, 0x1966, 0x1966, 0x1166, 0x1146, 0x1145, 0x1146, 0x1146, // 0x3D80 (15744) pixels +0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1166, // 0x3D90 (15760) pixels +0x1166, 0x1166, 0x1186, 0x1166, 0x1166, 0x11A7, 0x11C7, 0x09C7, 0x09E7, 0x09E7, 0x09E8, 0x09E8, 0x09E8, 0x09E8, 0x09E8, 0x09E8, // 0x3DA0 (15776) pixels +0x1208, 0x1208, 0x1208, 0x1208, 0x1209, 0x1229, 0x1229, 0x1229, 0x1229, 0x1229, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, // 0x3DB0 (15792) pixels +0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, // 0x3DC0 (15808) pixels +0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, // 0x3DD0 (15824) pixels +0x1269, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1208, // 0x3DE0 (15840) pixels +0x1208, 0x1208, 0x11E8, 0x1208, 0x11E8, 0x1208, 0x11E8, 0x11E8, 0x11E8, 0x11A6, 0x1186, 0x11A6, 0x0925, 0x1986, 0x1186, 0x2165, // 0x3DF0 (15856) pixels +0x1966, 0x1186, 0x1186, 0x1186, 0x11A6, 0x1125, 0x1966, 0x1966, 0x1166, 0x1966, 0x1966, 0x1166, 0x1946, 0x1146, 0x1146, 0x1146, // 0x3E00 (15872) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1146, // 0x3E10 (15888) pixels +0x1166, 0x1166, 0x1166, 0x1186, 0x1186, 0x11A7, 0x11A7, 0x09C7, 0x09C7, 0x09E7, 0x11E8, 0x11E8, 0x09E8, 0x09E8, 0x11E8, 0x11E8, // 0x3E20 (15904) pixels +0x11E8, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1229, 0x1229, 0x1229, 0x1229, 0x1228, 0x1228, 0x1249, 0x1249, // 0x3E30 (15920) pixels +0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1269, 0x126A, 0x126A, 0x126A, 0x126A, 0x126A, 0x1269, 0x1269, 0x1269, 0x1269, 0x1269, // 0x3E40 (15936) pixels +0x1269, 0x1269, 0x1269, 0x1269, 0x1249, 0x1249, 0x1249, 0x1249, 0x1269, 0x1269, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, // 0x3E50 (15952) pixels +0x1249, 0x1249, 0x1229, 0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, // 0x3E60 (15968) pixels +0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x09E7, 0x11A7, 0x1186, 0x11A6, 0x1186, 0x1187, 0x1166, 0x1166, 0x1166, // 0x3E70 (15984) pixels +0x1946, 0x1186, 0x1186, 0x1186, 0x1165, 0x1165, 0x1166, 0x1166, 0x1146, 0x1166, 0x1166, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, // 0x3E80 (16000) pixels +0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1166, 0x1146, // 0x3E90 (16016) pixels +0x1166, 0x1166, 0x1186, 0x1186, 0x1186, 0x11A7, 0x09A7, 0x11C7, 0x09C7, 0x09C7, 0x09C7, 0x09C7, 0x11E7, 0x09E7, 0x09E7, 0x09E7, // 0x3EA0 (16032) pixels +0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x1208, 0x1208, 0x1208, 0x1229, 0x1229, 0x1229, 0x1208, 0x1208, 0x1208, 0x1208, 0x1228, 0x1208, // 0x3EB0 (16048) pixels +0x1228, 0x1228, 0x1228, 0x1228, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x126A, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, // 0x3EC0 (16064) pixels +0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1249, 0x1229, 0x1228, // 0x3ED0 (16080) pixels +0x1229, 0x1229, 0x1228, 0x1208, 0x1208, 0x1208, 0x1228, 0x1228, 0x1208, 0x1208, 0x1208, 0x1208, 0x11E7, 0x1208, 0x11E7, 0x11E7, // 0x3EE0 (16096) pixels +0x11E8, 0x11E8, 0x11C7, 0x11C8, 0x11E8, 0x11E8, 0x09E7, 0x09C7, 0x11C7, 0x11C7, 0x11A6, 0x1185, 0x1186, 0x1186, 0x1166, 0x1166, // 0x3EF0 (16112) pixels +0x1966, 0x1146, 0x11A6, 0x1166, 0x1186, 0x1145, 0x1166, 0x1166, 0x1146, 0x1146, 0x1146, 0x1166, 0x1146, 0x1146, 0x1146, 0x1146, // 0x3F00 (16128) pixels +0x1145, 0x1145, 0x1145, 0x1145, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, // 0x3F10 (16144) pixels +0x1166, 0x1166, 0x1166, 0x0986, 0x1186, 0x11A7, 0x11A7, 0x09A7, 0x09A7, 0x11C7, 0x11C7, 0x11A7, 0x09C7, 0x09C7, 0x09C7, 0x09C7, // 0x3F20 (16160) pixels +0x09C7, 0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x09E8, 0x1208, 0x1229, 0x1208, 0x1208, 0x1208, 0x0A08, 0x1208, 0x1208, 0x1208, 0x1208, // 0x3F30 (16176) pixels +0x1228, 0x1228, 0x1228, 0x1228, 0x1229, 0x1229, 0x1229, 0x1229, 0x1229, 0x1229, 0x1249, 0x1229, 0x1229, 0x1229, 0x1229, 0x1229, // 0x3F40 (16192) pixels +0x1229, 0x1229, 0x1229, 0x1249, 0x1229, 0x1229, 0x1229, 0x1229, 0x1228, 0x1228, 0x1249, 0x1229, 0x1228, 0x1228, 0x1208, 0x1208, // 0x3F50 (16208) pixels +0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11E7, 0x11C7, 0x11C7, // 0x3F60 (16224) pixels +0x11C7, 0x11C7, 0x11C7, 0x11C7, 0x09C7, 0x09C7, 0x09C7, 0x09C7, 0x11C7, 0x11A7, 0x1185, 0x1186, 0x1186, 0x1186, 0x1166, 0x1966, // 0x3F70 (16240) pixels +0x1166, 0x1966, 0x1966, 0x1186, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1146, 0x1145, 0x1146, 0x1166, 0x1146, 0x1145, 0x1146, // 0x3F80 (16256) pixels +0x1146, 0x1146, 0x1146, 0x1145, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, 0x1146, // 0x3F90 (16272) pixels +0x1166, 0x1166, 0x1166, 0x0966, 0x0986, 0x0986, 0x0986, 0x0986, 0x0987, 0x09A7, 0x09A7, 0x09A7, 0x09A7, 0x09A7, 0x09A7, 0x09A7, // 0x3FA0 (16288) pixels +0x09A7, 0x09C7, 0x09C7, 0x09C7, 0x09E8, 0x09E8, 0x09E8, 0x1208, 0x0A08, 0x09E8, 0x1208, 0x1208, 0x0A08, 0x0A08, 0x0A08, 0x0A08, // 0x3FB0 (16304) pixels +0x0A08, 0x0A28, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1208, 0x1228, 0x1228, 0x0A28, 0x0A28, 0x0A28, 0x0A28, 0x0A29, 0x0A28, // 0x3FC0 (16320) pixels +0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1228, 0x1229, 0x1228, 0x1228, 0x0A08, 0x0A08, 0x1208, 0x1208, 0x0A08, 0x0A08, // 0x3FD0 (16336) pixels +0x11E8, 0x11E8, 0x11E8, 0x11E8, 0x0A07, 0x0A07, 0x09E7, 0x09E7, 0x09E7, 0x09E7, 0x11C7, 0x11C7, 0x09C7, 0x09E7, 0x09C7, 0x09C7, // 0x3FE0 (16352) pixels +0x09C7, 0x09C7, 0x09A7, 0x11A7, 0x09C7, 0x09C7, 0x09A7, 0x09A7, 0x09A7, 0x09A7, 0x1186, 0x1186, 0x1186, 0x1186, 0x1166, 0x1966, // 0x3FF0 (16368) pixels +0x1966, 0x1166, 0x1966, 0x1966, 0x1166, 0x1166, 0x1166, 0x1166, 0x1146, 0x1145, 0x1146, 0x1146, 0x1166, 0x1146, 0x1146, 0x1145, // 0x4000 (16384) pixels +}; diff --git a/main/includes/wr_gpio.h b/main/includes/wr_gpio.h new file mode 100644 index 0000000..d30299f --- /dev/null +++ b/main/includes/wr_gpio.h @@ -0,0 +1,4 @@ +#pragma once +#include "driver/gpio.h" + +void set_input_pin (gpio_num_t pin); diff --git a/main/lcd_setup.c b/main/lcd_setup.c new file mode 100644 index 0000000..441c6ad --- /dev/null +++ b/main/lcd_setup.c @@ -0,0 +1,242 @@ +#include + +#include "esp_lcd_panel_io.h" +#include "esp_lcd_panel_vendor.h" +#include "esp_lcd_panel_ops.h" + +#include "driver/gpio.h" + +#include "esp_err.h" +#include "esp_log.h" +#include "esp_dma_utils.h" + +#include +//#include +#include "freertos/event_groups.h" +#include "events_global.h" + +#include "esp_cache.h" + +#include "ST7789_def.h" +#include "lcd_setup.h" + + + + +static const char *TAG = "lcd_setup"; + +extern EventGroupHandle_t raster_event_group; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////// Parameters from Lilygo and Bodmer's resources ////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// PCLK frequency can't go too high as the limitation of PSRAM bandwidth 2MHz +// Datasheet suggests 66ns write cycle time which equates to 15Mhz +// In my case I've set to use internal RAM - 10MHz fine, 20 MHZ write error +#define EXAMPLE_LCD_PIXEL_CLOCK_HZ (14 * 1000 * 1000) + +#define EXAMPLE_LCD_BK_LIGHT_ON_LEVEL 1 +#define EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL !EXAMPLE_LCD_BK_LIGHT_ON_LEVEL +#define EXAMPLE_PIN_NUM_DATA0 39 +#define EXAMPLE_PIN_NUM_DATA1 40 +#define EXAMPLE_PIN_NUM_DATA2 41 +#define EXAMPLE_PIN_NUM_DATA3 42 +#define EXAMPLE_PIN_NUM_DATA4 45 +#define EXAMPLE_PIN_NUM_DATA5 46 +#define EXAMPLE_PIN_NUM_DATA6 47 +#define EXAMPLE_PIN_NUM_DATA7 48 + +#define EXAMPLE_PIN_NUM_PCLK 8 // Write +#define EXAMPLE_PIN_NUM_CS 6 +#define EXAMPLE_PIN_NUM_DC 7 +#define EXAMPLE_PIN_NUM_RST 5 +#define EXAMPLE_PIN_NUM_BK_LIGHT 38 + +#define EXAMPLE_PIN_NUM_RD 9 + +// Bit number used to represent command and parameter +#define EXAMPLE_LCD_CMD_BITS 8 +#define EXAMPLE_LCD_PARAM_BITS 8 + + +#ifdef __cplusplus +extern "C" { +#endif +static bool lcd_callback(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx) +{ + /* + extern const uint16_t BackgroundColour; // = ((fog >> 8) & 0b1111100000000000) | ((fog >> 5) & 0b0000011111100000) | ((fog >> 3) & 0b0000000000011111); + + // Once pushed to TFT the buffer can be cleared + // This is called when DMA is complete, in this case we can clear the buffer + if (flipped) + { + // Clear screen, could make a function, but is it worth it? + // memset() is char-based, could make this uint32_t perhaps? + for (int i=0;i < 128 * 128;i++) + { + frame_buffer_B[i] = BackgroundColour; // Background colour + } + } + else + { + for (int i=0;i < 128 * 128;i++) + { + frame_buffer_A[i] = BackgroundColour; // Background colour + } + } + */ + // A flag set to show that screen is cleared so DMA or re-use of frame buffer can occur + // DMA transfer can be slower than a fast frame which gives write errors hance need for flag + // 10Mhz clock makes this less of a limiting rate + xEventGroupSetBits( + raster_event_group, + CLEAR_READY); + + return (false); +} // End of lcd_callback +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +extern "C" { +#endif +void init_lcd_i80_bus(esp_lcd_panel_io_handle_t *io_handle) +{ + ESP_LOGI(TAG, "Initialize Intel 8080 bus"); + + esp_lcd_i80_bus_handle_t i80_bus = NULL; + esp_lcd_i80_bus_config_t bus_config = { + .dc_gpio_num = EXAMPLE_PIN_NUM_DC, + .wr_gpio_num = EXAMPLE_PIN_NUM_PCLK, + .clk_src = LCD_CLK_SRC_DEFAULT, + .data_gpio_nums = { + EXAMPLE_PIN_NUM_DATA0, + EXAMPLE_PIN_NUM_DATA1, + EXAMPLE_PIN_NUM_DATA2, + EXAMPLE_PIN_NUM_DATA3, + EXAMPLE_PIN_NUM_DATA4, + EXAMPLE_PIN_NUM_DATA5, + EXAMPLE_PIN_NUM_DATA6, + EXAMPLE_PIN_NUM_DATA7, + }, + .bus_width = CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH, + .max_transfer_bytes = EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES * sizeof(uint16_t), + .psram_trans_align = EXAMPLE_PSRAM_DATA_ALIGNMENT, + .sram_trans_align = 4, + }; + ESP_ERROR_CHECK(esp_lcd_new_i80_bus(&bus_config, &i80_bus)); + + esp_lcd_panel_io_i80_config_t io_config = { + .cs_gpio_num = EXAMPLE_PIN_NUM_CS, + .pclk_hz = EXAMPLE_LCD_PIXEL_CLOCK_HZ, + .trans_queue_depth = 10, + .on_color_trans_done = lcd_callback, + .lcd_cmd_bits = EXAMPLE_LCD_CMD_BITS, + .lcd_param_bits = EXAMPLE_LCD_PARAM_BITS, + .dc_levels = { + .dc_idle_level = 0, + .dc_cmd_level = 0, + .dc_dummy_level = 0, + .dc_data_level = 1, + }, + .flags = { + .swap_color_bytes = true, // Swap to be done by DMA hardware + }, + //.user_ctx = user_ctx, + }; + ESP_ERROR_CHECK(esp_lcd_new_panel_io_i80(i80_bus, &io_config, io_handle)); + + ESP_LOGI(TAG, "Set RD pin high"); // This is CRITICAL but isn't in driver information + gpio_config_t rd_gpio_config = { + .pin_bit_mask = 1ULL << EXAMPLE_PIN_NUM_RD, + .mode = GPIO_MODE_OUTPUT, + }; + ESP_ERROR_CHECK(gpio_config(&rd_gpio_config)); + gpio_set_level((gpio_num_t) EXAMPLE_PIN_NUM_RD, 1); +} // End of init_lcd_i80_bus +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +extern "C" { +#endif +void init_lcd_panel(esp_lcd_panel_io_handle_t io_handle, esp_lcd_panel_handle_t *panel) +{ +#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0 + ESP_LOGI(TAG, "Turn off LCD backlight"); + gpio_config_t bk_gpio_config = { + .pin_bit_mask = 1ULL << EXAMPLE_PIN_NUM_BK_LIGHT, + .mode = GPIO_MODE_OUTPUT + }; + ESP_ERROR_CHECK(gpio_config(&bk_gpio_config)); + gpio_set_level((gpio_num_t) EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_OFF_LEVEL); +#endif // EXAMPLE_PIN_NUM_BK_LIGHT >= 0 + + ESP_LOGI(TAG, "Install LCD driver of st7789"); + esp_lcd_panel_dev_config_t panel_config = { + .reset_gpio_num = EXAMPLE_PIN_NUM_RST, + .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB, + .bits_per_pixel = 16, + }; + ESP_ERROR_CHECK(esp_lcd_new_panel_st7789(io_handle, &panel_config, panel)); + + esp_lcd_panel_reset(* panel); + esp_lcd_panel_init(* panel); + // Set inversion, x/y coordinate order, x/y mirror according to your LCD module spec + ESP_ERROR_CHECK(esp_lcd_panel_swap_xy(* panel, true)); + ESP_ERROR_CHECK(esp_lcd_panel_mirror(* panel, true,false)); + + // the gap is LCD panel specific, even panels with the same driver IC, can have different gap value + esp_lcd_panel_invert_color(* panel, true); + ESP_ERROR_CHECK(esp_lcd_panel_set_gap(* panel,0,35)); // Trial and error + + // These set up parameters from Bodmer's TFT library ST7789_Init.h + //------------------------------display and color format setting--------------------------------// +//writecommand(ST7789_MADCTL); +//writedata(TFT_MAD_COLOR_ORDER); + +//writecommand(0x3A); +//writedata(0x05); +//--------------------------------ST7789V Frame rate setting----------------------------------// +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_PORCTRL,(uint8_t[]){0x0b, 0x0b, 0x00, 0x33, 0x33},5)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_GCTRL,(uint8_t[]){0x75},1)); + +//---------------------------------ST7789V Power setting--------------------------------------// +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_VCOMS,(uint8_t[]){0x28},1)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_LCMCTRL,(uint8_t[]){0x2c},1)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_VDVVRHEN,(uint8_t[]){0x01},1)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_VRHS,(uint8_t[]){0x1f},1)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_FRCTR2,(uint8_t[]){0x13},1)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_PWCTRL1,(uint8_t[]){0xa7},1)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_PWCTRL1,(uint8_t[]){0xa4, 0xa1},2)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,0xd6,(uint8_t[]){0xa1},1)); + +//--------------------------------ST7789V gamma setting---------------------------------------// +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_PVGAMCTRL,(uint8_t[]){0xf0, 0x05, 0x0a, 0x06, 0x06, 0x03, 0x2b, 0x32, 0x43, 0x36, 0x11, 0x10, 0x2b, 0x32},14)); + +ESP_ERROR_CHECK(esp_lcd_panel_io_tx_param(io_handle,ST7789_NVGAMCTRL,(uint8_t[]){0xf0, 0x08, 0x0c, 0x0b, 0x09, 0x24, 0x2b, 0x22, 0x43, 0x38, 0x15, 0x16, 0x2f, 0x37},14)); + +// Now we are set up activate the display +ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(*panel, true)); + +#if EXAMPLE_PIN_NUM_BK_LIGHT >= 0 + ESP_LOGI(TAG, "Turn on LCD backlight"); + gpio_set_level((gpio_num_t) EXAMPLE_PIN_NUM_BK_LIGHT, EXAMPLE_LCD_BK_LIGHT_ON_LEVEL); +#endif // EXAMPLE_PIN_NUM_BK_LIGHT >= 0 +} // End of init_lcd_panel +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/main/wr_gpio.cpp b/main/wr_gpio.cpp new file mode 100644 index 0000000..6ccdbea --- /dev/null +++ b/main/wr_gpio.cpp @@ -0,0 +1,16 @@ +// Generic GPIO functions to serve the 3d world rasteriser + +#include +#include "driver/gpio.h" +#include "buttons.h" + +// Makes a numbered pin input with an internal pullup +// This sort of thing is hidden in Arduino +// Are ALL four parts really needed? +void set_input_pin (gpio_num_t pin) +{ + gpio_set_direction(pin,GPIO_MODE_INPUT); + //gpio_pulldown_dis(pin); + //gpio_pullup_en(pin); + gpio_set_pull_mode(pin, GPIO_PULLUP_ONLY); +} diff --git a/nesto_Large.png b/nesto_Large.png new file mode 100644 index 0000000..bfaaa41 Binary files /dev/null and b/nesto_Large.png differ diff --git a/nesto_beryl_42.png b/nesto_beryl_42.png new file mode 100644 index 0000000..4fd9fa9 Binary files /dev/null and b/nesto_beryl_42.png differ diff --git a/nesto_numbers_21px.png b/nesto_numbers_21px.png new file mode 100644 index 0000000..0c7a413 Binary files /dev/null and b/nesto_numbers_21px.png differ diff --git a/nesto_numsbers_44px.png b/nesto_numsbers_44px.png new file mode 100644 index 0000000..6cf48f0 Binary files /dev/null and b/nesto_numsbers_44px.png differ diff --git a/partition_table/partitionTable.bin b/partition_table/partitionTable.bin new file mode 100644 index 0000000..5de4bf6 Binary files /dev/null and b/partition_table/partitionTable.bin differ diff --git a/partition_table/partitionTable.csv b/partition_table/partitionTable.csv new file mode 100644 index 0000000..de3139e --- /dev/null +++ b/partition_table/partitionTable.csv @@ -0,0 +1,7 @@ +# ESP-IDF Partition Table +# Name, Type, SubType, Offset, Size, Flags +nvs,data,nvs,0x9000,24K, +phy_init,data,phy,0xf000,4K, +factory,app,factory,0x10000,1M, +world,data,undefined,0x110000,4M, +textures,data,undefined,0x510000,1M, diff --git a/partitions_3D.csv b/partitions_3D.csv new file mode 100644 index 0000000..87f39d6 --- /dev/null +++ b/partitions_3D.csv @@ -0,0 +1,7 @@ +# Name, Type, SubType, Offset, Size, Flags +# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap +nvs, data, nvs, 0x9000, 0x6000, +phy_init, data, phy, 0xf000, 0x1000, +factory, app, factory, 0x10000, 1M, +world, data, , , 4M, +textures, data, , , 1M, diff --git a/sdkconfig b/sdkconfig new file mode 100644 index 0000000..11627f4 --- /dev/null +++ b/sdkconfig @@ -0,0 +1,2204 @@ +# +# Automatically generated file. DO NOT EDIT. +# Espressif IoT Development Framework (ESP-IDF) 5.3.0 Project Configuration +# +CONFIG_SOC_MPU_MIN_REGION_SIZE=0x20000000 +CONFIG_SOC_MPU_REGIONS_MAX_NUM=8 +CONFIG_SOC_ADC_SUPPORTED=y +CONFIG_SOC_UART_SUPPORTED=y +CONFIG_SOC_PCNT_SUPPORTED=y +CONFIG_SOC_PHY_SUPPORTED=y +CONFIG_SOC_WIFI_SUPPORTED=y +CONFIG_SOC_TWAI_SUPPORTED=y +CONFIG_SOC_GDMA_SUPPORTED=y +CONFIG_SOC_AHB_GDMA_SUPPORTED=y +CONFIG_SOC_GPTIMER_SUPPORTED=y +CONFIG_SOC_LCDCAM_SUPPORTED=y +CONFIG_SOC_MCPWM_SUPPORTED=y +CONFIG_SOC_DEDICATED_GPIO_SUPPORTED=y +CONFIG_SOC_CACHE_SUPPORT_WRAP=y +CONFIG_SOC_ULP_SUPPORTED=y +CONFIG_SOC_ULP_FSM_SUPPORTED=y +CONFIG_SOC_RISCV_COPROC_SUPPORTED=y +CONFIG_SOC_BT_SUPPORTED=y +CONFIG_SOC_USB_OTG_SUPPORTED=y +CONFIG_SOC_USB_SERIAL_JTAG_SUPPORTED=y +CONFIG_SOC_CCOMP_TIMER_SUPPORTED=y +CONFIG_SOC_ASYNC_MEMCPY_SUPPORTED=y +CONFIG_SOC_SUPPORTS_SECURE_DL_MODE=y +CONFIG_SOC_EFUSE_KEY_PURPOSE_FIELD=y +CONFIG_SOC_EFUSE_SUPPORTED=y +CONFIG_SOC_SDMMC_HOST_SUPPORTED=y +CONFIG_SOC_RTC_FAST_MEM_SUPPORTED=y +CONFIG_SOC_RTC_SLOW_MEM_SUPPORTED=y +CONFIG_SOC_RTC_MEM_SUPPORTED=y +CONFIG_SOC_PSRAM_DMA_CAPABLE=y +CONFIG_SOC_XT_WDT_SUPPORTED=y +CONFIG_SOC_I2S_SUPPORTED=y +CONFIG_SOC_RMT_SUPPORTED=y +CONFIG_SOC_SDM_SUPPORTED=y +CONFIG_SOC_GPSPI_SUPPORTED=y +CONFIG_SOC_LEDC_SUPPORTED=y +CONFIG_SOC_I2C_SUPPORTED=y +CONFIG_SOC_SYSTIMER_SUPPORTED=y +CONFIG_SOC_SUPPORT_COEXISTENCE=y +CONFIG_SOC_TEMP_SENSOR_SUPPORTED=y +CONFIG_SOC_AES_SUPPORTED=y +CONFIG_SOC_MPI_SUPPORTED=y +CONFIG_SOC_SHA_SUPPORTED=y +CONFIG_SOC_HMAC_SUPPORTED=y +CONFIG_SOC_DIG_SIGN_SUPPORTED=y +CONFIG_SOC_FLASH_ENC_SUPPORTED=y +CONFIG_SOC_SECURE_BOOT_SUPPORTED=y +CONFIG_SOC_MEMPROT_SUPPORTED=y +CONFIG_SOC_TOUCH_SENSOR_SUPPORTED=y +CONFIG_SOC_BOD_SUPPORTED=y +CONFIG_SOC_CLK_TREE_SUPPORTED=y +CONFIG_SOC_MPU_SUPPORTED=y +CONFIG_SOC_WDT_SUPPORTED=y +CONFIG_SOC_SPI_FLASH_SUPPORTED=y +CONFIG_SOC_RNG_SUPPORTED=y +CONFIG_SOC_LIGHT_SLEEP_SUPPORTED=y +CONFIG_SOC_DEEP_SLEEP_SUPPORTED=y +CONFIG_SOC_LP_PERIPH_SHARE_INTERRUPT=y +CONFIG_SOC_PM_SUPPORTED=y +CONFIG_SOC_XTAL_SUPPORT_40M=y +CONFIG_SOC_APPCPU_HAS_CLOCK_GATING_BUG=y +CONFIG_SOC_ADC_RTC_CTRL_SUPPORTED=y +CONFIG_SOC_ADC_DIG_CTRL_SUPPORTED=y +CONFIG_SOC_ADC_ARBITER_SUPPORTED=y +CONFIG_SOC_ADC_DIG_IIR_FILTER_SUPPORTED=y +CONFIG_SOC_ADC_MONITOR_SUPPORTED=y +CONFIG_SOC_ADC_DMA_SUPPORTED=y +CONFIG_SOC_ADC_PERIPH_NUM=2 +CONFIG_SOC_ADC_MAX_CHANNEL_NUM=10 +CONFIG_SOC_ADC_ATTEN_NUM=4 +CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM=2 +CONFIG_SOC_ADC_PATT_LEN_MAX=24 +CONFIG_SOC_ADC_DIGI_MIN_BITWIDTH=12 +CONFIG_SOC_ADC_DIGI_MAX_BITWIDTH=12 +CONFIG_SOC_ADC_DIGI_RESULT_BYTES=4 +CONFIG_SOC_ADC_DIGI_DATA_BYTES_PER_CONV=4 +CONFIG_SOC_ADC_DIGI_IIR_FILTER_NUM=2 +CONFIG_SOC_ADC_DIGI_MONITOR_NUM=2 +CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH=83333 +CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW=611 +CONFIG_SOC_ADC_RTC_MIN_BITWIDTH=12 +CONFIG_SOC_ADC_RTC_MAX_BITWIDTH=12 +CONFIG_SOC_ADC_CALIBRATION_V1_SUPPORTED=y +CONFIG_SOC_ADC_SELF_HW_CALI_SUPPORTED=y +CONFIG_SOC_ADC_SHARED_POWER=y +CONFIG_SOC_APB_BACKUP_DMA=y +CONFIG_SOC_BROWNOUT_RESET_SUPPORTED=y +CONFIG_SOC_CACHE_WRITEBACK_SUPPORTED=y +CONFIG_SOC_CACHE_FREEZE_SUPPORTED=y +CONFIG_SOC_CPU_CORES_NUM=2 +CONFIG_SOC_CPU_INTR_NUM=32 +CONFIG_SOC_CPU_HAS_FPU=y +CONFIG_SOC_HP_CPU_HAS_MULTIPLE_CORES=y +CONFIG_SOC_CPU_BREAKPOINTS_NUM=2 +CONFIG_SOC_CPU_WATCHPOINTS_NUM=2 +CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=64 +CONFIG_SOC_DS_SIGNATURE_MAX_BIT_LEN=4096 +CONFIG_SOC_DS_KEY_PARAM_MD_IV_LENGTH=16 +CONFIG_SOC_DS_KEY_CHECK_MAX_WAIT_US=1100 +CONFIG_SOC_AHB_GDMA_VERSION=1 +CONFIG_SOC_GDMA_NUM_GROUPS_MAX=1 +CONFIG_SOC_GDMA_PAIRS_PER_GROUP=5 +CONFIG_SOC_GDMA_PAIRS_PER_GROUP_MAX=5 +CONFIG_SOC_AHB_GDMA_SUPPORT_PSRAM=y +CONFIG_SOC_GPIO_PORT=1 +CONFIG_SOC_GPIO_PIN_COUNT=49 +CONFIG_SOC_GPIO_SUPPORT_PIN_GLITCH_FILTER=y +CONFIG_SOC_GPIO_FILTER_CLK_SUPPORT_APB=y +CONFIG_SOC_GPIO_SUPPORT_RTC_INDEPENDENT=y +CONFIG_SOC_GPIO_SUPPORT_FORCE_HOLD=y +CONFIG_SOC_GPIO_VALID_GPIO_MASK=0x1FFFFFFFFFFFF +CONFIG_SOC_GPIO_IN_RANGE_MAX=48 +CONFIG_SOC_GPIO_OUT_RANGE_MAX=48 +CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK=0x0001FFFFFC000000 +CONFIG_SOC_GPIO_CLOCKOUT_BY_IO_MUX=y +CONFIG_SOC_GPIO_CLOCKOUT_CHANNEL_NUM=3 +CONFIG_SOC_DEDIC_GPIO_OUT_CHANNELS_NUM=8 +CONFIG_SOC_DEDIC_GPIO_IN_CHANNELS_NUM=8 +CONFIG_SOC_DEDIC_GPIO_OUT_AUTO_ENABLE=y +CONFIG_SOC_I2C_NUM=2 +CONFIG_SOC_HP_I2C_NUM=2 +CONFIG_SOC_I2C_FIFO_LEN=32 +CONFIG_SOC_I2C_CMD_REG_NUM=8 +CONFIG_SOC_I2C_SUPPORT_SLAVE=y +CONFIG_SOC_I2C_SUPPORT_HW_CLR_BUS=y +CONFIG_SOC_I2C_SUPPORT_XTAL=y +CONFIG_SOC_I2C_SUPPORT_RTC=y +CONFIG_SOC_I2C_SUPPORT_10BIT_ADDR=y +CONFIG_SOC_I2C_SLAVE_SUPPORT_BROADCAST=y +CONFIG_SOC_I2C_SLAVE_SUPPORT_I2CRAM_ACCESS=y +CONFIG_SOC_I2S_NUM=2 +CONFIG_SOC_I2S_HW_VERSION_2=y +CONFIG_SOC_I2S_SUPPORTS_XTAL=y +CONFIG_SOC_I2S_SUPPORTS_PLL_F160M=y +CONFIG_SOC_I2S_SUPPORTS_PCM=y +CONFIG_SOC_I2S_SUPPORTS_PDM=y +CONFIG_SOC_I2S_SUPPORTS_PDM_TX=y +CONFIG_SOC_I2S_PDM_MAX_TX_LINES=2 +CONFIG_SOC_I2S_SUPPORTS_PDM_RX=y +CONFIG_SOC_I2S_PDM_MAX_RX_LINES=4 +CONFIG_SOC_I2S_SUPPORTS_TDM=y +CONFIG_SOC_LEDC_SUPPORT_APB_CLOCK=y +CONFIG_SOC_LEDC_SUPPORT_XTAL_CLOCK=y +CONFIG_SOC_LEDC_CHANNEL_NUM=8 +CONFIG_SOC_LEDC_TIMER_BIT_WIDTH=14 +CONFIG_SOC_LEDC_SUPPORT_FADE_STOP=y +CONFIG_SOC_MCPWM_GROUPS=2 +CONFIG_SOC_MCPWM_TIMERS_PER_GROUP=3 +CONFIG_SOC_MCPWM_OPERATORS_PER_GROUP=3 +CONFIG_SOC_MCPWM_COMPARATORS_PER_OPERATOR=2 +CONFIG_SOC_MCPWM_GENERATORS_PER_OPERATOR=2 +CONFIG_SOC_MCPWM_TRIGGERS_PER_OPERATOR=2 +CONFIG_SOC_MCPWM_GPIO_FAULTS_PER_GROUP=3 +CONFIG_SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP=y +CONFIG_SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER=3 +CONFIG_SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP=3 +CONFIG_SOC_MCPWM_SWSYNC_CAN_PROPAGATE=y +CONFIG_SOC_MMU_LINEAR_ADDRESS_REGION_NUM=1 +CONFIG_SOC_MMU_PERIPH_NUM=1 +CONFIG_SOC_PCNT_GROUPS=1 +CONFIG_SOC_PCNT_UNITS_PER_GROUP=4 +CONFIG_SOC_PCNT_CHANNELS_PER_UNIT=2 +CONFIG_SOC_PCNT_THRES_POINT_PER_UNIT=2 +CONFIG_SOC_RMT_GROUPS=1 +CONFIG_SOC_RMT_TX_CANDIDATES_PER_GROUP=4 +CONFIG_SOC_RMT_RX_CANDIDATES_PER_GROUP=4 +CONFIG_SOC_RMT_CHANNELS_PER_GROUP=8 +CONFIG_SOC_RMT_MEM_WORDS_PER_CHANNEL=48 +CONFIG_SOC_RMT_SUPPORT_RX_PINGPONG=y +CONFIG_SOC_RMT_SUPPORT_RX_DEMODULATION=y +CONFIG_SOC_RMT_SUPPORT_TX_ASYNC_STOP=y +CONFIG_SOC_RMT_SUPPORT_TX_LOOP_COUNT=y +CONFIG_SOC_RMT_SUPPORT_TX_LOOP_AUTO_STOP=y +CONFIG_SOC_RMT_SUPPORT_TX_SYNCHRO=y +CONFIG_SOC_RMT_SUPPORT_TX_CARRIER_DATA_ONLY=y +CONFIG_SOC_RMT_SUPPORT_XTAL=y +CONFIG_SOC_RMT_SUPPORT_RC_FAST=y +CONFIG_SOC_RMT_SUPPORT_APB=y +CONFIG_SOC_RMT_SUPPORT_DMA=y +CONFIG_SOC_LCD_I80_SUPPORTED=y +CONFIG_SOC_LCD_RGB_SUPPORTED=y +CONFIG_SOC_LCD_I80_BUSES=1 +CONFIG_SOC_LCD_RGB_PANELS=1 +CONFIG_SOC_LCD_I80_BUS_WIDTH=16 +CONFIG_SOC_LCD_RGB_DATA_WIDTH=16 +CONFIG_SOC_LCD_SUPPORT_RGB_YUV_CONV=y +CONFIG_SOC_RTC_CNTL_CPU_PD_DMA_BUS_WIDTH=128 +CONFIG_SOC_RTC_CNTL_CPU_PD_REG_FILE_NUM=549 +CONFIG_SOC_RTC_CNTL_TAGMEM_PD_DMA_BUS_WIDTH=128 +CONFIG_SOC_RTCIO_PIN_COUNT=22 +CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED=y +CONFIG_SOC_RTCIO_HOLD_SUPPORTED=y +CONFIG_SOC_RTCIO_WAKE_SUPPORTED=y +CONFIG_SOC_SDM_GROUPS=y +CONFIG_SOC_SDM_CHANNELS_PER_GROUP=8 +CONFIG_SOC_SDM_CLK_SUPPORT_APB=y +CONFIG_SOC_SPI_PERIPH_NUM=3 +CONFIG_SOC_SPI_MAX_CS_NUM=6 +CONFIG_SOC_SPI_MAXIMUM_BUFFER_SIZE=64 +CONFIG_SOC_SPI_SUPPORT_DDRCLK=y +CONFIG_SOC_SPI_SLAVE_SUPPORT_SEG_TRANS=y +CONFIG_SOC_SPI_SUPPORT_CD_SIG=y +CONFIG_SOC_SPI_SUPPORT_CONTINUOUS_TRANS=y +CONFIG_SOC_SPI_SUPPORT_SLAVE_HD_VER2=y +CONFIG_SOC_SPI_SUPPORT_CLK_APB=y +CONFIG_SOC_SPI_SUPPORT_CLK_XTAL=y +CONFIG_SOC_SPI_PERIPH_SUPPORT_CONTROL_DUMMY_OUT=y +CONFIG_SOC_MEMSPI_IS_INDEPENDENT=y +CONFIG_SOC_SPI_MAX_PRE_DIVIDER=16 +CONFIG_SOC_SPI_SUPPORT_OCT=y +CONFIG_SOC_SPI_SCT_SUPPORTED=y +CONFIG_SOC_SPI_SCT_REG_NUM=14 +CONFIG_SOC_SPI_SCT_BUFFER_NUM_MAX=y +CONFIG_SOC_SPI_SCT_CONF_BITLEN_MAX=0x3FFFA +CONFIG_SOC_MEMSPI_SRC_FREQ_120M=y +CONFIG_SOC_MEMSPI_SRC_FREQ_80M_SUPPORTED=y +CONFIG_SOC_MEMSPI_SRC_FREQ_40M_SUPPORTED=y +CONFIG_SOC_MEMSPI_SRC_FREQ_20M_SUPPORTED=y +CONFIG_SOC_SPIRAM_SUPPORTED=y +CONFIG_SOC_SPIRAM_XIP_SUPPORTED=y +CONFIG_SOC_SYSTIMER_COUNTER_NUM=2 +CONFIG_SOC_SYSTIMER_ALARM_NUM=3 +CONFIG_SOC_SYSTIMER_BIT_WIDTH_LO=32 +CONFIG_SOC_SYSTIMER_BIT_WIDTH_HI=20 +CONFIG_SOC_SYSTIMER_FIXED_DIVIDER=y +CONFIG_SOC_SYSTIMER_INT_LEVEL=y +CONFIG_SOC_SYSTIMER_ALARM_MISS_COMPENSATE=y +CONFIG_SOC_TIMER_GROUPS=2 +CONFIG_SOC_TIMER_GROUP_TIMERS_PER_GROUP=2 +CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH=54 +CONFIG_SOC_TIMER_GROUP_SUPPORT_XTAL=y +CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y +CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=4 +CONFIG_SOC_TOUCH_SENSOR_VERSION=2 +CONFIG_SOC_TOUCH_SENSOR_NUM=15 +CONFIG_SOC_TOUCH_PROXIMITY_CHANNEL_NUM=3 +CONFIG_SOC_TOUCH_PROXIMITY_MEAS_DONE_SUPPORTED=y +CONFIG_SOC_TOUCH_SAMPLER_NUM=1 +CONFIG_SOC_TWAI_CONTROLLER_NUM=1 +CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y +CONFIG_SOC_TWAI_BRP_MIN=2 +CONFIG_SOC_TWAI_BRP_MAX=16384 +CONFIG_SOC_TWAI_SUPPORTS_RX_STATUS=y +CONFIG_SOC_UART_NUM=3 +CONFIG_SOC_UART_HP_NUM=3 +CONFIG_SOC_UART_FIFO_LEN=128 +CONFIG_SOC_UART_BITRATE_MAX=5000000 +CONFIG_SOC_UART_SUPPORT_FSM_TX_WAIT_SEND=y +CONFIG_SOC_UART_SUPPORT_WAKEUP_INT=y +CONFIG_SOC_UART_SUPPORT_APB_CLK=y +CONFIG_SOC_UART_SUPPORT_RTC_CLK=y +CONFIG_SOC_UART_SUPPORT_XTAL_CLK=y +CONFIG_SOC_USB_OTG_PERIPH_NUM=1 +CONFIG_SOC_SHA_DMA_MAX_BUFFER_SIZE=3968 +CONFIG_SOC_SHA_SUPPORT_DMA=y +CONFIG_SOC_SHA_SUPPORT_RESUME=y +CONFIG_SOC_SHA_GDMA=y +CONFIG_SOC_SHA_SUPPORT_SHA1=y +CONFIG_SOC_SHA_SUPPORT_SHA224=y +CONFIG_SOC_SHA_SUPPORT_SHA256=y +CONFIG_SOC_SHA_SUPPORT_SHA384=y +CONFIG_SOC_SHA_SUPPORT_SHA512=y +CONFIG_SOC_SHA_SUPPORT_SHA512_224=y +CONFIG_SOC_SHA_SUPPORT_SHA512_256=y +CONFIG_SOC_SHA_SUPPORT_SHA512_T=y +CONFIG_SOC_MPI_MEM_BLOCKS_NUM=4 +CONFIG_SOC_MPI_OPERATIONS_NUM=3 +CONFIG_SOC_RSA_MAX_BIT_LEN=4096 +CONFIG_SOC_AES_SUPPORT_DMA=y +CONFIG_SOC_AES_GDMA=y +CONFIG_SOC_AES_SUPPORT_AES_128=y +CONFIG_SOC_AES_SUPPORT_AES_256=y +CONFIG_SOC_PM_SUPPORT_EXT0_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_EXT1_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_EXT_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_WIFI_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_BT_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_CPU_PD=y +CONFIG_SOC_PM_SUPPORT_TAGMEM_PD=y +CONFIG_SOC_PM_SUPPORT_RTC_PERIPH_PD=y +CONFIG_SOC_PM_SUPPORT_RC_FAST_PD=y +CONFIG_SOC_PM_SUPPORT_VDDSDIO_PD=y +CONFIG_SOC_PM_SUPPORT_MAC_BB_PD=y +CONFIG_SOC_PM_SUPPORT_MODEM_PD=y +CONFIG_SOC_CONFIGURABLE_VDDSDIO_SUPPORTED=y +CONFIG_SOC_PM_SUPPORT_DEEPSLEEP_CHECK_STUB_ONLY=y +CONFIG_SOC_PM_CPU_RETENTION_BY_RTCCNTL=y +CONFIG_SOC_PM_MODEM_RETENTION_BY_BACKUPDMA=y +CONFIG_SOC_CLK_RC_FAST_D256_SUPPORTED=y +CONFIG_SOC_RTC_SLOW_CLK_SUPPORT_RC_FAST_D256=y +CONFIG_SOC_CLK_RC_FAST_SUPPORT_CALIBRATION=y +CONFIG_SOC_CLK_XTAL32K_SUPPORTED=y +CONFIG_SOC_EFUSE_DIS_DOWNLOAD_ICACHE=y +CONFIG_SOC_EFUSE_DIS_DOWNLOAD_DCACHE=y +CONFIG_SOC_EFUSE_HARD_DIS_JTAG=y +CONFIG_SOC_EFUSE_DIS_USB_JTAG=y +CONFIG_SOC_EFUSE_SOFT_DIS_JTAG=y +CONFIG_SOC_EFUSE_DIS_DIRECT_BOOT=y +CONFIG_SOC_EFUSE_DIS_ICACHE=y +CONFIG_SOC_EFUSE_BLOCK9_KEY_PURPOSE_QUIRK=y +CONFIG_SOC_SECURE_BOOT_V2_RSA=y +CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS=3 +CONFIG_SOC_EFUSE_REVOKE_BOOT_KEY_DIGESTS=y +CONFIG_SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY=y +CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX=64 +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES=y +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_OPTIONS=y +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_128=y +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_256=y +CONFIG_SOC_MEMPROT_CPU_PREFETCH_PAD_SIZE=16 +CONFIG_SOC_MEMPROT_MEM_ALIGN_SIZE=256 +CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE=21 +CONFIG_SOC_MAC_BB_PD_MEM_SIZE=192 +CONFIG_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH=12 +CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_WAIT_IDLE=y +CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_SUSPEND=y +CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_RESUME=y +CONFIG_SOC_SPI_MEM_SUPPORT_SW_SUSPEND=y +CONFIG_SOC_SPI_MEM_SUPPORT_OPI_MODE=y +CONFIG_SOC_SPI_MEM_SUPPORT_TIMING_TUNING=y +CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE=y +CONFIG_SOC_SPI_MEM_SUPPORT_WRAP=y +CONFIG_SOC_MEMSPI_TIMING_TUNING_BY_MSPI_DELAY=y +CONFIG_SOC_MEMSPI_CORE_CLK_SHARED_WITH_PSRAM=y +CONFIG_SOC_COEX_HW_PTI=y +CONFIG_SOC_EXTERNAL_COEX_LEADER_TX_LINE=y +CONFIG_SOC_SDMMC_USE_GPIO_MATRIX=y +CONFIG_SOC_SDMMC_NUM_SLOTS=2 +CONFIG_SOC_SDMMC_SUPPORT_XTAL_CLOCK=y +CONFIG_SOC_SDMMC_DELAY_PHASE_NUM=4 +CONFIG_SOC_TEMPERATURE_SENSOR_SUPPORT_FAST_RC=y +CONFIG_SOC_WIFI_HW_TSF=y +CONFIG_SOC_WIFI_FTM_SUPPORT=y +CONFIG_SOC_WIFI_GCMP_SUPPORT=y +CONFIG_SOC_WIFI_WAPI_SUPPORT=y +CONFIG_SOC_WIFI_CSI_SUPPORT=y +CONFIG_SOC_WIFI_MESH_SUPPORT=y +CONFIG_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW=y +CONFIG_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND=y +CONFIG_SOC_BLE_SUPPORTED=y +CONFIG_SOC_BLE_MESH_SUPPORTED=y +CONFIG_SOC_BLE_50_SUPPORTED=y +CONFIG_SOC_BLE_DEVICE_PRIVACY_SUPPORTED=y +CONFIG_SOC_BLUFI_SUPPORTED=y +CONFIG_SOC_ULP_HAS_ADC=y +CONFIG_SOC_PHY_COMBO_MODULE=y +CONFIG_IDF_CMAKE=y +CONFIG_IDF_TOOLCHAIN="gcc" +CONFIG_IDF_TARGET_ARCH_XTENSA=y +CONFIG_IDF_TARGET_ARCH="xtensa" +CONFIG_IDF_TARGET="esp32s3" +CONFIG_IDF_INIT_VERSION="5.3.0" +CONFIG_IDF_TARGET_ESP32S3=y +CONFIG_IDF_FIRMWARE_CHIP_ID=0x0009 + +# +# Build type +# +CONFIG_APP_BUILD_TYPE_APP_2NDBOOT=y +# CONFIG_APP_BUILD_TYPE_RAM is not set +CONFIG_APP_BUILD_GENERATE_BINARIES=y +CONFIG_APP_BUILD_BOOTLOADER=y +CONFIG_APP_BUILD_USE_FLASH_SECTIONS=y +# CONFIG_APP_REPRODUCIBLE_BUILD is not set +# CONFIG_APP_NO_BLOBS is not set +# end of Build type + +# +# Bootloader config +# + +# +# Bootloader manager +# +CONFIG_BOOTLOADER_COMPILE_TIME_DATE=y +CONFIG_BOOTLOADER_PROJECT_VER=1 +# end of Bootloader manager + +CONFIG_BOOTLOADER_OFFSET_IN_FLASH=0x0 +CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y +# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG is not set +# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF is not set +# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_NONE is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_WARN is not set +CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y +# CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set +CONFIG_BOOTLOADER_LOG_LEVEL=3 + +# +# Serial Flash Configurations +# +# CONFIG_BOOTLOADER_FLASH_DC_AWARE is not set +CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y +# end of Serial Flash Configurations + +CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V=y +# CONFIG_BOOTLOADER_FACTORY_RESET is not set +# CONFIG_BOOTLOADER_APP_TEST is not set +CONFIG_BOOTLOADER_REGION_PROTECTION_ENABLE=y +CONFIG_BOOTLOADER_WDT_ENABLE=y +# CONFIG_BOOTLOADER_WDT_DISABLE_IN_USER_CODE is not set +CONFIG_BOOTLOADER_WDT_TIME_MS=9000 +# CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE is not set +# CONFIG_BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP is not set +# CONFIG_BOOTLOADER_SKIP_VALIDATE_ON_POWER_ON is not set +# CONFIG_BOOTLOADER_SKIP_VALIDATE_ALWAYS is not set +CONFIG_BOOTLOADER_RESERVE_RTC_SIZE=0 +# CONFIG_BOOTLOADER_CUSTOM_RESERVE_RTC is not set +# end of Bootloader config + +# +# Security features +# +CONFIG_SECURE_BOOT_V2_RSA_SUPPORTED=y +CONFIG_SECURE_BOOT_V2_PREFERRED=y +# CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT is not set +# CONFIG_SECURE_BOOT is not set +# CONFIG_SECURE_FLASH_ENC_ENABLED is not set +CONFIG_SECURE_ROM_DL_MODE_ENABLED=y +# end of Security features + +# +# Application manager +# +CONFIG_APP_COMPILE_TIME_DATE=y +# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set +# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set +# CONFIG_APP_PROJECT_VER_FROM_CONFIG is not set +CONFIG_APP_RETRIEVE_LEN_ELF_SHA=9 +# end of Application manager + +CONFIG_ESP_ROM_HAS_CRC_LE=y +CONFIG_ESP_ROM_HAS_CRC_BE=y +CONFIG_ESP_ROM_HAS_MZ_CRC32=y +CONFIG_ESP_ROM_HAS_JPEG_DECODE=y +CONFIG_ESP_ROM_UART_CLK_IS_XTAL=y +CONFIG_ESP_ROM_HAS_RETARGETABLE_LOCKING=y +CONFIG_ESP_ROM_USB_OTG_NUM=3 +CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM=4 +CONFIG_ESP_ROM_HAS_ERASE_0_REGION_BUG=y +CONFIG_ESP_ROM_HAS_ENCRYPTED_WRITES_USING_LEGACY_DRV=y +CONFIG_ESP_ROM_GET_CLK_FREQ=y +CONFIG_ESP_ROM_HAS_HAL_WDT=y +CONFIG_ESP_ROM_NEEDS_SWSETUP_WORKAROUND=y +CONFIG_ESP_ROM_HAS_LAYOUT_TABLE=y +CONFIG_ESP_ROM_HAS_SPI_FLASH=y +CONFIG_ESP_ROM_HAS_ETS_PRINTF_BUG=y +CONFIG_ESP_ROM_HAS_NEWLIB=y +CONFIG_ESP_ROM_HAS_NEWLIB_NANO_FORMAT=y +CONFIG_ESP_ROM_HAS_NEWLIB_32BIT_TIME=y +CONFIG_ESP_ROM_NEEDS_SET_CACHE_MMU_SIZE=y +CONFIG_ESP_ROM_RAM_APP_NEEDS_MMU_INIT=y +CONFIG_ESP_ROM_HAS_FLASH_COUNT_PAGES_BUG=y +CONFIG_ESP_ROM_HAS_CACHE_SUSPEND_WAITI_BUG=y +CONFIG_ESP_ROM_HAS_CACHE_WRITEBACK_BUG=y +CONFIG_ESP_ROM_HAS_SW_FLOAT=y +CONFIG_ESP_ROM_HAS_VERSION=y +CONFIG_ESP_ROM_SUPPORT_DEEP_SLEEP_WAKEUP_STUB=y + +# +# Boot ROM Behavior +# +CONFIG_BOOT_ROM_LOG_ALWAYS_ON=y +# CONFIG_BOOT_ROM_LOG_ALWAYS_OFF is not set +# CONFIG_BOOT_ROM_LOG_ON_GPIO_HIGH is not set +# CONFIG_BOOT_ROM_LOG_ON_GPIO_LOW is not set +# end of Boot ROM Behavior + +# +# Serial flasher config +# +# CONFIG_ESPTOOLPY_NO_STUB is not set +# CONFIG_ESPTOOLPY_OCT_FLASH is not set +CONFIG_ESPTOOLPY_FLASH_MODE_AUTO_DETECT=y +CONFIG_ESPTOOLPY_FLASHMODE_QIO=y +# CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set +# CONFIG_ESPTOOLPY_FLASHMODE_DIO is not set +# CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set +CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y +CONFIG_ESPTOOLPY_FLASHMODE="dio" +# CONFIG_ESPTOOLPY_FLASHFREQ_120M is not set +CONFIG_ESPTOOLPY_FLASHFREQ_80M=y +# CONFIG_ESPTOOLPY_FLASHFREQ_40M is not set +# CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set +CONFIG_ESPTOOLPY_FLASHFREQ_80M_DEFAULT=y +CONFIG_ESPTOOLPY_FLASHFREQ="80m" +# CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_2MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set +CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y +# CONFIG_ESPTOOLPY_FLASHSIZE_32MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_64MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_128MB is not set +CONFIG_ESPTOOLPY_FLASHSIZE="16MB" +# CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE is not set +CONFIG_ESPTOOLPY_BEFORE_RESET=y +# CONFIG_ESPTOOLPY_BEFORE_NORESET is not set +CONFIG_ESPTOOLPY_BEFORE="default_reset" +CONFIG_ESPTOOLPY_AFTER_RESET=y +# CONFIG_ESPTOOLPY_AFTER_NORESET is not set +CONFIG_ESPTOOLPY_AFTER="hard_reset" +CONFIG_ESPTOOLPY_MONITOR_BAUD=115200 +# end of Serial flasher config + +# +# Partition Table +# +# CONFIG_PARTITION_TABLE_SINGLE_APP is not set +# CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE is not set +# CONFIG_PARTITION_TABLE_TWO_OTA is not set +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_3D.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions_3D.csv" +CONFIG_PARTITION_TABLE_OFFSET=0x8000 +CONFIG_PARTITION_TABLE_MD5=y +# end of Partition Table + +# +# Example Configuration +# +# CONFIG_EXAMPLE_LCD_I80_COLOR_IN_PSRAM is not set +CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ST7789=y +# CONFIG_EXAMPLE_LCD_I80_CONTROLLER_NT35510 is not set +# CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ILI9341 is not set +CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH=8 +# CONFIG_EXAMPLE_LCD_TOUCH_ENABLED is not set +# CONFIG_EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM is not set +CONFIG_EXAMPLE_LCD_IMAGE_FROM_EMBEDDED_BINARY=y +# end of Example Configuration + +# +# Compiler options +# +CONFIG_COMPILER_OPTIMIZATION_DEBUG=y +# CONFIG_COMPILER_OPTIMIZATION_SIZE is not set +# CONFIG_COMPILER_OPTIMIZATION_PERF is not set +# CONFIG_COMPILER_OPTIMIZATION_NONE is not set +CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y +# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT is not set +# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE is not set +CONFIG_COMPILER_FLOAT_LIB_FROM_GCCLIB=y +CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL=2 +# CONFIG_COMPILER_OPTIMIZATION_CHECKS_SILENT is not set +CONFIG_COMPILER_HIDE_PATHS_MACROS=y +# CONFIG_COMPILER_CXX_EXCEPTIONS is not set +# CONFIG_COMPILER_CXX_RTTI is not set +CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y +# CONFIG_COMPILER_STACK_CHECK_MODE_NORM is not set +# CONFIG_COMPILER_STACK_CHECK_MODE_STRONG is not set +# CONFIG_COMPILER_STACK_CHECK_MODE_ALL is not set +# CONFIG_COMPILER_WARN_WRITE_STRINGS is not set +# CONFIG_COMPILER_DISABLE_GCC12_WARNINGS is not set +# CONFIG_COMPILER_DISABLE_GCC13_WARNINGS is not set +# CONFIG_COMPILER_DUMP_RTL_FILES is not set +CONFIG_COMPILER_RT_LIB_GCCLIB=y +CONFIG_COMPILER_RT_LIB_NAME="gcc" +# CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING is not set +CONFIG_COMPILER_ORPHAN_SECTIONS_PLACE=y +# end of Compiler options + +# +# Component config +# + +# +# Application Level Tracing +# +# CONFIG_APPTRACE_DEST_JTAG is not set +CONFIG_APPTRACE_DEST_NONE=y +# CONFIG_APPTRACE_DEST_UART0 is not set +# CONFIG_APPTRACE_DEST_UART1 is not set +# CONFIG_APPTRACE_DEST_UART2 is not set +# CONFIG_APPTRACE_DEST_USB_CDC is not set +CONFIG_APPTRACE_DEST_UART_NONE=y +CONFIG_APPTRACE_UART_TASK_PRIO=1 +CONFIG_APPTRACE_LOCK_ENABLE=y +# end of Application Level Tracing + +# +# Bluetooth +# +# CONFIG_BT_ENABLED is not set +CONFIG_BT_ALARM_MAX_NUM=50 +# end of Bluetooth + +# +# Console Library +# +# CONFIG_CONSOLE_SORTED_HELP is not set +# end of Console Library + +# +# Driver Configurations +# + +# +# TWAI Configuration +# +# CONFIG_TWAI_ISR_IN_IRAM is not set +CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y +# end of TWAI Configuration + +# +# Legacy ADC Driver Configuration +# +# CONFIG_ADC_SUPPRESS_DEPRECATE_WARN is not set + +# +# Legacy ADC Calibration Configuration +# +# CONFIG_ADC_CALI_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy ADC Calibration Configuration +# end of Legacy ADC Driver Configuration + +# +# Legacy MCPWM Driver Configurations +# +# CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy MCPWM Driver Configurations + +# +# Legacy Timer Group Driver Configurations +# +# CONFIG_GPTIMER_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy Timer Group Driver Configurations + +# +# Legacy RMT Driver Configurations +# +# CONFIG_RMT_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy RMT Driver Configurations + +# +# Legacy I2S Driver Configurations +# +# CONFIG_I2S_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy I2S Driver Configurations + +# +# Legacy PCNT Driver Configurations +# +# CONFIG_PCNT_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy PCNT Driver Configurations + +# +# Legacy SDM Driver Configurations +# +# CONFIG_SDM_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy SDM Driver Configurations + +# +# Legacy Temperature Sensor Driver Configurations +# +# CONFIG_TEMP_SENSOR_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy Temperature Sensor Driver Configurations +# end of Driver Configurations + +# +# eFuse Bit Manager +# +# CONFIG_EFUSE_CUSTOM_TABLE is not set +# CONFIG_EFUSE_VIRTUAL is not set +CONFIG_EFUSE_MAX_BLK_LEN=256 +# end of eFuse Bit Manager + +# +# ESP-TLS +# +CONFIG_ESP_TLS_USING_MBEDTLS=y +CONFIG_ESP_TLS_USE_DS_PERIPHERAL=y +# CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS is not set +# CONFIG_ESP_TLS_SERVER_SESSION_TICKETS is not set +# CONFIG_ESP_TLS_SERVER_CERT_SELECT_HOOK is not set +# CONFIG_ESP_TLS_SERVER_MIN_AUTH_MODE_OPTIONAL is not set +# CONFIG_ESP_TLS_PSK_VERIFICATION is not set +# CONFIG_ESP_TLS_INSECURE is not set +# end of ESP-TLS + +# +# ADC and ADC Calibration +# +# CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM is not set +# CONFIG_ADC_CONTINUOUS_ISR_IRAM_SAFE is not set +# CONFIG_ADC_CONTINUOUS_FORCE_USE_ADC2_ON_C3_S3 is not set +# CONFIG_ADC_ENABLE_DEBUG_LOG is not set +# end of ADC and ADC Calibration + +# +# Wireless Coexistence +# +CONFIG_ESP_COEX_ENABLED=y +# CONFIG_ESP_COEX_EXTERNAL_COEXIST_ENABLE is not set +# end of Wireless Coexistence + +# +# Common ESP-related +# +CONFIG_ESP_ERR_TO_NAME_LOOKUP=y +# end of Common ESP-related + +# +# ESP-Driver:GPIO Configurations +# +# CONFIG_GPIO_CTRL_FUNC_IN_IRAM is not set +# end of ESP-Driver:GPIO Configurations + +# +# ESP-Driver:GPTimer Configurations +# +CONFIG_GPTIMER_ISR_HANDLER_IN_IRAM=y +# CONFIG_GPTIMER_CTRL_FUNC_IN_IRAM is not set +# CONFIG_GPTIMER_ISR_IRAM_SAFE is not set +# CONFIG_GPTIMER_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:GPTimer Configurations + +# +# ESP-Driver:I2C Configurations +# +# CONFIG_I2C_ISR_IRAM_SAFE is not set +# CONFIG_I2C_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:I2C Configurations + +# +# ESP-Driver:I2S Configurations +# +# CONFIG_I2S_ISR_IRAM_SAFE is not set +# CONFIG_I2S_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:I2S Configurations + +# +# ESP-Driver:LEDC Configurations +# +# CONFIG_LEDC_CTRL_FUNC_IN_IRAM is not set +# end of ESP-Driver:LEDC Configurations + +# +# ESP-Driver:MCPWM Configurations +# +# CONFIG_MCPWM_ISR_IRAM_SAFE is not set +# CONFIG_MCPWM_CTRL_FUNC_IN_IRAM is not set +# CONFIG_MCPWM_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:MCPWM Configurations + +# +# ESP-Driver:PCNT Configurations +# +# CONFIG_PCNT_CTRL_FUNC_IN_IRAM is not set +# CONFIG_PCNT_ISR_IRAM_SAFE is not set +# CONFIG_PCNT_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:PCNT Configurations + +# +# ESP-Driver:RMT Configurations +# +# CONFIG_RMT_ISR_IRAM_SAFE is not set +# CONFIG_RMT_RECV_FUNC_IN_IRAM is not set +# CONFIG_RMT_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:RMT Configurations + +# +# ESP-Driver:Sigma Delta Modulator Configurations +# +# CONFIG_SDM_CTRL_FUNC_IN_IRAM is not set +# CONFIG_SDM_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:Sigma Delta Modulator Configurations + +# +# ESP-Driver:SPI Configurations +# +CONFIG_SPI_MASTER_IN_IRAM=y +CONFIG_SPI_MASTER_ISR_IN_IRAM=y +# CONFIG_SPI_SLAVE_IN_IRAM is not set +CONFIG_SPI_SLAVE_ISR_IN_IRAM=y +# end of ESP-Driver:SPI Configurations + +# +# ESP-Driver:Temperature Sensor Configurations +# +# CONFIG_TEMP_SENSOR_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:Temperature Sensor Configurations + +# +# ESP-Driver:UART Configurations +# +# CONFIG_UART_ISR_IN_IRAM is not set +# end of ESP-Driver:UART Configurations + +# +# ESP-Driver:USB Serial/JTAG Configuration +# +CONFIG_USJ_ENABLE_USB_SERIAL_JTAG=y +# end of ESP-Driver:USB Serial/JTAG Configuration + +# +# Ethernet +# +# CONFIG_ETH_USE_SPI_ETHERNET is not set +# CONFIG_ETH_USE_OPENETH is not set +# end of Ethernet + +# +# Event Loop Library +# +# CONFIG_ESP_EVENT_LOOP_PROFILING is not set +CONFIG_ESP_EVENT_POST_FROM_ISR=y +CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR=y +# end of Event Loop Library + +# +# GDB Stub +# +CONFIG_ESP_GDBSTUB_ENABLED=y +# CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME is not set +CONFIG_ESP_GDBSTUB_SUPPORT_TASKS=y +CONFIG_ESP_GDBSTUB_MAX_TASKS=32 +# end of GDB Stub + +# +# ESP HTTP client +# +# CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS is not set +# CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH is not set +# CONFIG_ESP_HTTP_CLIENT_ENABLE_DIGEST_AUTH is not set +# CONFIG_ESP_HTTP_CLIENT_ENABLE_CUSTOM_TRANSPORT is not set +# end of ESP HTTP client + +# +# HTTP Server +# +CONFIG_HTTPD_MAX_REQ_HDR_LEN=512 +CONFIG_HTTPD_MAX_URI_LEN=512 +CONFIG_HTTPD_ERR_RESP_NO_DELAY=y +CONFIG_HTTPD_PURGE_BUF_LEN=32 +# CONFIG_HTTPD_LOG_PURGE_DATA is not set +# CONFIG_HTTPD_WS_SUPPORT is not set +# CONFIG_HTTPD_QUEUE_WORK_BLOCKING is not set +# end of HTTP Server + +# +# ESP HTTPS OTA +# +# CONFIG_ESP_HTTPS_OTA_DECRYPT_CB is not set +# CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP is not set +# end of ESP HTTPS OTA + +# +# ESP HTTPS server +# +# CONFIG_ESP_HTTPS_SERVER_ENABLE is not set +# end of ESP HTTPS server + +# +# Hardware Settings +# + +# +# Chip revision +# +CONFIG_ESP32S3_REV_MIN_0=y +# CONFIG_ESP32S3_REV_MIN_1 is not set +# CONFIG_ESP32S3_REV_MIN_2 is not set +CONFIG_ESP32S3_REV_MIN_FULL=0 +CONFIG_ESP_REV_MIN_FULL=0 + +# +# Maximum Supported ESP32-S3 Revision (Rev v0.99) +# +CONFIG_ESP32S3_REV_MAX_FULL=99 +CONFIG_ESP_REV_MAX_FULL=99 +# end of Chip revision + +# +# MAC Config +# +CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA=y +CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP=y +CONFIG_ESP_MAC_ADDR_UNIVERSE_BT=y +CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH=y +CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES_FOUR=y +CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES=4 +# CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_TWO is not set +CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_FOUR=y +CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES=4 +# CONFIG_ESP_MAC_USE_CUSTOM_MAC_AS_BASE_MAC is not set +# end of MAC Config + +# +# Sleep Config +# +CONFIG_ESP_SLEEP_FLASH_LEAKAGE_WORKAROUND=y +CONFIG_ESP_SLEEP_PSRAM_LEAKAGE_WORKAROUND=y +CONFIG_ESP_SLEEP_MSPI_NEED_ALL_IO_PU=y +CONFIG_ESP_SLEEP_RTC_BUS_ISO_WORKAROUND=y +CONFIG_ESP_SLEEP_GPIO_RESET_WORKAROUND=y +CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY=2000 +# CONFIG_ESP_SLEEP_CACHE_SAFE_ASSERTION is not set +# CONFIG_ESP_SLEEP_DEBUG is not set +CONFIG_ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS=y +# end of Sleep Config + +# +# RTC Clock Config +# +CONFIG_RTC_CLK_SRC_INT_RC=y +# CONFIG_RTC_CLK_SRC_EXT_CRYS is not set +# CONFIG_RTC_CLK_SRC_EXT_OSC is not set +# CONFIG_RTC_CLK_SRC_INT_8MD256 is not set +CONFIG_RTC_CLK_CAL_CYCLES=1024 +# end of RTC Clock Config + +# +# Peripheral Control +# +CONFIG_PERIPH_CTRL_FUNC_IN_IRAM=y +# end of Peripheral Control + +# +# GDMA Configurations +# +CONFIG_GDMA_CTRL_FUNC_IN_IRAM=y +# CONFIG_GDMA_ISR_IRAM_SAFE is not set +# CONFIG_GDMA_ENABLE_DEBUG_LOG is not set +# end of GDMA Configurations + +# +# Main XTAL Config +# +CONFIG_XTAL_FREQ_40=y +CONFIG_XTAL_FREQ=40 +# end of Main XTAL Config + +CONFIG_ESP_SPI_BUS_LOCK_ISR_FUNCS_IN_IRAM=y +CONFIG_ESP_SPI_BUS_LOCK_FUNCS_IN_IRAM=y +# end of Hardware Settings + +# +# LCD and Touch Panel +# + +# +# LCD Touch Drivers are maintained in the IDF Component Registry +# + +# +# LCD Peripheral Configuration +# +CONFIG_LCD_PANEL_IO_FORMAT_BUF_SIZE=32 +# CONFIG_LCD_ENABLE_DEBUG_LOG is not set +# CONFIG_LCD_RGB_ISR_IRAM_SAFE is not set +# CONFIG_LCD_RGB_RESTART_IN_VSYNC is not set +# end of LCD Peripheral Configuration +# end of LCD and Touch Panel + +# +# ESP NETIF Adapter +# +CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL=120 +# CONFIG_ESP_NETIF_TCPIP_LWIP is not set +CONFIG_ESP_NETIF_LOOPBACK=y +# CONFIG_ESP_NETIF_RECEIVE_REPORT_ERRORS is not set +# CONFIG_ESP_NETIF_L2_TAP is not set +# end of ESP NETIF Adapter + +# +# Partition API Configuration +# +# end of Partition API Configuration + +# +# PHY +# +CONFIG_ESP_PHY_ENABLED=y +CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE=y +# CONFIG_ESP_PHY_INIT_DATA_IN_PARTITION is not set +CONFIG_ESP_PHY_MAX_WIFI_TX_POWER=20 +CONFIG_ESP_PHY_MAX_TX_POWER=20 +# CONFIG_ESP_PHY_REDUCE_TX_POWER is not set +CONFIG_ESP_PHY_ENABLE_USB=y +# CONFIG_ESP_PHY_ENABLE_CERT_TEST is not set +CONFIG_ESP_PHY_RF_CAL_PARTIAL=y +# CONFIG_ESP_PHY_RF_CAL_NONE is not set +# CONFIG_ESP_PHY_RF_CAL_FULL is not set +CONFIG_ESP_PHY_CALIBRATION_MODE=0 +# CONFIG_ESP_PHY_PLL_TRACK_DEBUG is not set +# end of PHY + +# +# Power Management +# +# CONFIG_PM_ENABLE is not set +CONFIG_PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP=y +CONFIG_PM_RESTORE_CACHE_TAGMEM_AFTER_LIGHT_SLEEP=y +# end of Power Management + +# +# ESP PSRAM +# +CONFIG_SPIRAM=y + +# +# SPI RAM config +# +# CONFIG_SPIRAM_MODE_QUAD is not set +CONFIG_SPIRAM_MODE_OCT=y +CONFIG_SPIRAM_TYPE_AUTO=y +# CONFIG_SPIRAM_TYPE_ESPPSRAM64 is not set +CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY=y +CONFIG_SPIRAM_CLK_IO=30 +CONFIG_SPIRAM_CS_IO=26 +# CONFIG_SPIRAM_XIP_FROM_PSRAM is not set +CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y +CONFIG_SPIRAM_RODATA=y +CONFIG_SPIRAM_SPEED_80M=y +# CONFIG_SPIRAM_SPEED_40M is not set +CONFIG_SPIRAM_SPEED=80 +# CONFIG_SPIRAM_ECC_ENABLE is not set +CONFIG_SPIRAM_BOOT_INIT=y +# CONFIG_SPIRAM_IGNORE_NOTFOUND is not set +# CONFIG_SPIRAM_USE_MEMMAP is not set +# CONFIG_SPIRAM_USE_CAPS_ALLOC is not set +CONFIG_SPIRAM_USE_MALLOC=y +CONFIG_SPIRAM_MEMTEST=y +CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=16384 +# CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP is not set +CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL=131072 +# CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY is not set +# end of SPI RAM config +# end of ESP PSRAM + +# +# ESP Ringbuf +# +# CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH is not set +# end of ESP Ringbuf + +# +# ESP System Settings +# +# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_80 is not set +# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160 is not set +CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y +CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=240 + +# +# Cache config +# +# CONFIG_ESP32S3_INSTRUCTION_CACHE_16KB is not set +CONFIG_ESP32S3_INSTRUCTION_CACHE_32KB=y +CONFIG_ESP32S3_INSTRUCTION_CACHE_SIZE=0x8000 +# CONFIG_ESP32S3_INSTRUCTION_CACHE_4WAYS is not set +CONFIG_ESP32S3_INSTRUCTION_CACHE_8WAYS=y +CONFIG_ESP32S3_ICACHE_ASSOCIATED_WAYS=8 +CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_32B=y +CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_SIZE=32 +# CONFIG_ESP32S3_DATA_CACHE_16KB is not set +# CONFIG_ESP32S3_DATA_CACHE_32KB is not set +CONFIG_ESP32S3_DATA_CACHE_64KB=y +CONFIG_ESP32S3_DATA_CACHE_SIZE=0x10000 +# CONFIG_ESP32S3_DATA_CACHE_4WAYS is not set +CONFIG_ESP32S3_DATA_CACHE_8WAYS=y +CONFIG_ESP32S3_DCACHE_ASSOCIATED_WAYS=8 +CONFIG_ESP32S3_DATA_CACHE_LINE_32B=y +# CONFIG_ESP32S3_DATA_CACHE_LINE_64B is not set +CONFIG_ESP32S3_DATA_CACHE_LINE_SIZE=32 +# end of Cache config + +# +# Memory +# +# CONFIG_ESP32S3_RTCDATA_IN_FAST_MEM is not set +# CONFIG_ESP32S3_USE_FIXED_STATIC_RAM_SIZE is not set +# end of Memory + +# +# Trace memory +# +# CONFIG_ESP32S3_TRAX is not set +CONFIG_ESP32S3_TRACEMEM_RESERVE_DRAM=0x0 +# end of Trace memory + +# CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT is not set +CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y +# CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set +# CONFIG_ESP_SYSTEM_PANIC_GDBSTUB is not set +CONFIG_ESP_SYSTEM_PANIC_REBOOT_DELAY_SECONDS=0 +CONFIG_ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK=y +CONFIG_ESP_SYSTEM_ALLOW_RTC_FAST_MEM_AS_HEAP=y + +# +# Memory protection +# +CONFIG_ESP_SYSTEM_MEMPROT_FEATURE=y +CONFIG_ESP_SYSTEM_MEMPROT_FEATURE_LOCK=y +# end of Memory protection + +CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32 +CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2304 +CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584 +CONFIG_ESP_MAIN_TASK_AFFINITY_CPU0=y +# CONFIG_ESP_MAIN_TASK_AFFINITY_CPU1 is not set +# CONFIG_ESP_MAIN_TASK_AFFINITY_NO_AFFINITY is not set +CONFIG_ESP_MAIN_TASK_AFFINITY=0x0 +CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048 +# CONFIG_ESP_CONSOLE_UART_DEFAULT is not set +# CONFIG_ESP_CONSOLE_USB_CDC is not set +CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y +# CONFIG_ESP_CONSOLE_UART_CUSTOM is not set +# CONFIG_ESP_CONSOLE_NONE is not set +CONFIG_ESP_CONSOLE_SECONDARY_NONE=y +CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG_ENABLED=y +CONFIG_ESP_CONSOLE_UART_NUM=-1 +CONFIG_ESP_CONSOLE_ROM_SERIAL_PORT_NUM=4 +CONFIG_ESP_INT_WDT=y +CONFIG_ESP_INT_WDT_TIMEOUT_MS=300 +CONFIG_ESP_INT_WDT_CHECK_CPU1=y +CONFIG_ESP_TASK_WDT_EN=y +CONFIG_ESP_TASK_WDT_INIT=y +# CONFIG_ESP_TASK_WDT_PANIC is not set +CONFIG_ESP_TASK_WDT_TIMEOUT_S=5 +# CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0 is not set +CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=y +# CONFIG_ESP_PANIC_HANDLER_IRAM is not set +# CONFIG_ESP_DEBUG_STUBS_ENABLE is not set +CONFIG_ESP_DEBUG_OCDAWARE=y +CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_4=y + +# +# Brownout Detector +# +CONFIG_ESP_BROWNOUT_DET=y +CONFIG_ESP_BROWNOUT_DET_LVL_SEL_7=y +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_6 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_5 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_4 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_3 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_2 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_1 is not set +CONFIG_ESP_BROWNOUT_DET_LVL=7 +# end of Brownout Detector + +CONFIG_ESP_SYSTEM_BROWNOUT_INTR=y +CONFIG_ESP_SYSTEM_BBPLL_RECALIB=y +# end of ESP System Settings + +# +# IPC (Inter-Processor Call) +# +CONFIG_ESP_IPC_TASK_STACK_SIZE=1280 +CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y +CONFIG_ESP_IPC_ISR_ENABLE=y +# end of IPC (Inter-Processor Call) + +# +# ESP Timer (High Resolution Timer) +# +# CONFIG_ESP_TIMER_PROFILING is not set +CONFIG_ESP_TIME_FUNCS_USE_RTC_TIMER=y +CONFIG_ESP_TIME_FUNCS_USE_ESP_TIMER=y +CONFIG_ESP_TIMER_TASK_STACK_SIZE=3584 +CONFIG_ESP_TIMER_INTERRUPT_LEVEL=1 +# CONFIG_ESP_TIMER_SHOW_EXPERIMENTAL is not set +CONFIG_ESP_TIMER_TASK_AFFINITY=0x0 +CONFIG_ESP_TIMER_TASK_AFFINITY_CPU0=y +CONFIG_ESP_TIMER_ISR_AFFINITY_CPU0=y +# CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD is not set +CONFIG_ESP_TIMER_IMPL_SYSTIMER=y +# end of ESP Timer (High Resolution Timer) + +# +# Wi-Fi +# +CONFIG_ESP_WIFI_ENABLED=y +CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM=10 +CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=32 +CONFIG_ESP_WIFI_STATIC_TX_BUFFER=y +CONFIG_ESP_WIFI_TX_BUFFER_TYPE=0 +CONFIG_ESP_WIFI_STATIC_TX_BUFFER_NUM=16 +CONFIG_ESP_WIFI_CACHE_TX_BUFFER_NUM=32 +CONFIG_ESP_WIFI_STATIC_RX_MGMT_BUFFER=y +# CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER is not set +CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUF=0 +CONFIG_ESP_WIFI_RX_MGMT_BUF_NUM_DEF=5 +# CONFIG_ESP_WIFI_CSI_ENABLED is not set +CONFIG_ESP_WIFI_AMPDU_TX_ENABLED=y +CONFIG_ESP_WIFI_TX_BA_WIN=6 +CONFIG_ESP_WIFI_AMPDU_RX_ENABLED=y +CONFIG_ESP_WIFI_RX_BA_WIN=6 +# CONFIG_ESP_WIFI_AMSDU_TX_ENABLED is not set +CONFIG_ESP_WIFI_NVS_ENABLED=y +CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0=y +# CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_1 is not set +CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN=752 +CONFIG_ESP_WIFI_MGMT_SBUF_NUM=32 +CONFIG_ESP_WIFI_IRAM_OPT=y +# CONFIG_ESP_WIFI_EXTRA_IRAM_OPT is not set +CONFIG_ESP_WIFI_RX_IRAM_OPT=y +CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=y +CONFIG_ESP_WIFI_ENABLE_SAE_PK=y +CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT=y +CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA=y +# CONFIG_ESP_WIFI_SLP_IRAM_OPT is not set +CONFIG_ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME=50 +CONFIG_ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME=10 +CONFIG_ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME=15 +# CONFIG_ESP_WIFI_FTM_ENABLE is not set +CONFIG_ESP_WIFI_STA_DISCONNECTED_PM_ENABLE=y +# CONFIG_ESP_WIFI_GCMP_SUPPORT is not set +# CONFIG_ESP_WIFI_GMAC_SUPPORT is not set +CONFIG_ESP_WIFI_SOFTAP_SUPPORT=y +# CONFIG_ESP_WIFI_SLP_BEACON_LOST_OPT is not set +CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM=7 +CONFIG_ESP_WIFI_MBEDTLS_CRYPTO=y +CONFIG_ESP_WIFI_MBEDTLS_TLS_CLIENT=y +# CONFIG_ESP_WIFI_WAPI_PSK is not set +# CONFIG_ESP_WIFI_SUITE_B_192 is not set +# CONFIG_ESP_WIFI_11KV_SUPPORT is not set +# CONFIG_ESP_WIFI_MBO_SUPPORT is not set +# CONFIG_ESP_WIFI_DPP_SUPPORT is not set +# CONFIG_ESP_WIFI_11R_SUPPORT is not set +# CONFIG_ESP_WIFI_WPS_SOFTAP_REGISTRAR is not set + +# +# WPS Configuration Options +# +# CONFIG_ESP_WIFI_WPS_STRICT is not set +# CONFIG_ESP_WIFI_WPS_PASSPHRASE is not set +# end of WPS Configuration Options + +# CONFIG_ESP_WIFI_DEBUG_PRINT is not set +# CONFIG_ESP_WIFI_TESTING_OPTIONS is not set +CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=y +# CONFIG_ESP_WIFI_ENT_FREE_DYNAMIC_BUFFER is not set +# end of Wi-Fi + +# +# Core dump +# +# CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH is not set +# CONFIG_ESP_COREDUMP_ENABLE_TO_UART is not set +CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y +# end of Core dump + +# +# FAT Filesystem support +# +CONFIG_FATFS_VOLUME_COUNT=2 +CONFIG_FATFS_LFN_NONE=y +# CONFIG_FATFS_LFN_HEAP is not set +# CONFIG_FATFS_LFN_STACK is not set +# CONFIG_FATFS_SECTOR_512 is not set +CONFIG_FATFS_SECTOR_4096=y +# CONFIG_FATFS_CODEPAGE_DYNAMIC is not set +CONFIG_FATFS_CODEPAGE_437=y +# CONFIG_FATFS_CODEPAGE_720 is not set +# CONFIG_FATFS_CODEPAGE_737 is not set +# CONFIG_FATFS_CODEPAGE_771 is not set +# CONFIG_FATFS_CODEPAGE_775 is not set +# CONFIG_FATFS_CODEPAGE_850 is not set +# CONFIG_FATFS_CODEPAGE_852 is not set +# CONFIG_FATFS_CODEPAGE_855 is not set +# CONFIG_FATFS_CODEPAGE_857 is not set +# CONFIG_FATFS_CODEPAGE_860 is not set +# CONFIG_FATFS_CODEPAGE_861 is not set +# CONFIG_FATFS_CODEPAGE_862 is not set +# CONFIG_FATFS_CODEPAGE_863 is not set +# CONFIG_FATFS_CODEPAGE_864 is not set +# CONFIG_FATFS_CODEPAGE_865 is not set +# CONFIG_FATFS_CODEPAGE_866 is not set +# CONFIG_FATFS_CODEPAGE_869 is not set +# CONFIG_FATFS_CODEPAGE_932 is not set +# CONFIG_FATFS_CODEPAGE_936 is not set +# CONFIG_FATFS_CODEPAGE_949 is not set +# CONFIG_FATFS_CODEPAGE_950 is not set +CONFIG_FATFS_CODEPAGE=437 +CONFIG_FATFS_FS_LOCK=0 +CONFIG_FATFS_TIMEOUT_MS=10000 +CONFIG_FATFS_PER_FILE_CACHE=y +CONFIG_FATFS_ALLOC_PREFER_EXTRAM=y +# CONFIG_FATFS_USE_FASTSEEK is not set +CONFIG_FATFS_VFS_FSTAT_BLKSIZE=0 +# CONFIG_FATFS_IMMEDIATE_FSYNC is not set +# CONFIG_FATFS_USE_LABEL is not set +CONFIG_FATFS_LINK_LOCK=y +# end of FAT Filesystem support + +# +# FreeRTOS +# + +# +# Kernel +# +# CONFIG_FREERTOS_SMP is not set +# CONFIG_FREERTOS_UNICORE is not set +CONFIG_FREERTOS_HZ=100 +# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set +# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set +CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y +CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=1 +CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1536 +# CONFIG_FREERTOS_USE_IDLE_HOOK is not set +# CONFIG_FREERTOS_USE_TICK_HOOK is not set +CONFIG_FREERTOS_MAX_TASK_NAME_LEN=16 +# CONFIG_FREERTOS_ENABLE_BACKWARD_COMPATIBILITY is not set +CONFIG_FREERTOS_TIMER_SERVICE_TASK_NAME="Tmr Svc" +# CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU0 is not set +# CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU1 is not set +CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY=y +CONFIG_FREERTOS_TIMER_SERVICE_TASK_CORE_AFFINITY=0x7FFFFFFF +CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 +CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=4096 +CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=10 +CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +# CONFIG_FREERTOS_USE_TRACE_FACILITY is not set +# CONFIG_FREERTOS_USE_LIST_DATA_INTEGRITY_CHECK_BYTES is not set +# CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set +# CONFIG_FREERTOS_USE_APPLICATION_TASK_TAG is not set +# end of Kernel + +# +# Port +# +CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER=y +# CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK is not set +CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS=y +# CONFIG_FREERTOS_TASK_PRE_DELETION_HOOK is not set +# CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP is not set +CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y +CONFIG_FREERTOS_ISR_STACKSIZE=1536 +CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y +CONFIG_FREERTOS_TICK_SUPPORT_SYSTIMER=y +CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL1=y +# CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL3 is not set +CONFIG_FREERTOS_SYSTICK_USES_SYSTIMER=y +# CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH is not set +# CONFIG_FREERTOS_CHECK_PORT_CRITICAL_COMPLIANCE is not set +# end of Port + +CONFIG_FREERTOS_PORT=y +CONFIG_FREERTOS_NO_AFFINITY=0x7FFFFFFF +CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION=y +CONFIG_FREERTOS_DEBUG_OCDAWARE=y +CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT=y +CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y +CONFIG_FREERTOS_NUMBER_OF_CORES=2 +# end of FreeRTOS + +# +# Hardware Abstraction Layer (HAL) and Low Level (LL) +# +CONFIG_HAL_ASSERTION_EQUALS_SYSTEM=y +# CONFIG_HAL_ASSERTION_DISABLE is not set +# CONFIG_HAL_ASSERTION_SILENT is not set +# CONFIG_HAL_ASSERTION_ENABLE is not set +CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=2 +CONFIG_HAL_WDT_USE_ROM_IMPL=y +CONFIG_HAL_SPI_MASTER_FUNC_IN_IRAM=y +CONFIG_HAL_SPI_SLAVE_FUNC_IN_IRAM=y +# end of Hardware Abstraction Layer (HAL) and Low Level (LL) + +# +# Heap memory debugging +# +CONFIG_HEAP_POISONING_DISABLED=y +# CONFIG_HEAP_POISONING_LIGHT is not set +# CONFIG_HEAP_POISONING_COMPREHENSIVE is not set +CONFIG_HEAP_TRACING_OFF=y +# CONFIG_HEAP_TRACING_STANDALONE is not set +# CONFIG_HEAP_TRACING_TOHOST is not set +# CONFIG_HEAP_USE_HOOKS is not set +# CONFIG_HEAP_TASK_TRACKING is not set +# CONFIG_HEAP_ABORT_WHEN_ALLOCATION_FAILS is not set +# CONFIG_HEAP_PLACE_FUNCTION_INTO_FLASH is not set +# end of Heap memory debugging + +# +# Log output +# +# CONFIG_LOG_DEFAULT_LEVEL_NONE is not set +# CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set +# CONFIG_LOG_DEFAULT_LEVEL_WARN is not set +CONFIG_LOG_DEFAULT_LEVEL_INFO=y +# CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set +# CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set +CONFIG_LOG_DEFAULT_LEVEL=3 +CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT=y +# CONFIG_LOG_MAXIMUM_LEVEL_DEBUG is not set +# CONFIG_LOG_MAXIMUM_LEVEL_VERBOSE is not set +CONFIG_LOG_MAXIMUM_LEVEL=3 +# CONFIG_LOG_MASTER_LEVEL is not set +CONFIG_LOG_COLORS=y +CONFIG_LOG_TIMESTAMP_SOURCE_RTOS=y +# CONFIG_LOG_TIMESTAMP_SOURCE_SYSTEM is not set +# end of Log output + +# +# LWIP +# +CONFIG_LWIP_ENABLE=y +CONFIG_LWIP_LOCAL_HOSTNAME="espressif" +# CONFIG_LWIP_NETIF_API is not set +CONFIG_LWIP_TCPIP_TASK_PRIO=18 +# CONFIG_LWIP_TCPIP_CORE_LOCKING is not set +# CONFIG_LWIP_CHECK_THREAD_SAFETY is not set +CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y +# CONFIG_LWIP_L2_TO_L3_COPY is not set +# CONFIG_LWIP_IRAM_OPTIMIZATION is not set +# CONFIG_LWIP_EXTRA_IRAM_OPTIMIZATION is not set +CONFIG_LWIP_TIMERS_ONDEMAND=y +CONFIG_LWIP_ND6=y +# CONFIG_LWIP_FORCE_ROUTER_FORWARDING is not set +CONFIG_LWIP_MAX_SOCKETS=10 +# CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set +# CONFIG_LWIP_SO_LINGER is not set +CONFIG_LWIP_SO_REUSE=y +CONFIG_LWIP_SO_REUSE_RXTOALL=y +# CONFIG_LWIP_SO_RCVBUF is not set +# CONFIG_LWIP_NETBUF_RECVINFO is not set +CONFIG_LWIP_IP_DEFAULT_TTL=64 +CONFIG_LWIP_IP4_FRAG=y +CONFIG_LWIP_IP6_FRAG=y +# CONFIG_LWIP_IP4_REASSEMBLY is not set +# CONFIG_LWIP_IP6_REASSEMBLY is not set +CONFIG_LWIP_IP_REASS_MAX_PBUFS=10 +# CONFIG_LWIP_IP_FORWARD is not set +# CONFIG_LWIP_STATS is not set +CONFIG_LWIP_ESP_GRATUITOUS_ARP=y +CONFIG_LWIP_GARP_TMR_INTERVAL=60 +CONFIG_LWIP_ESP_MLDV6_REPORT=y +CONFIG_LWIP_MLDV6_TMR_INTERVAL=40 +CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=32 +CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y +# CONFIG_LWIP_DHCP_DISABLE_CLIENT_ID is not set +CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID=y +# CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set +CONFIG_LWIP_DHCP_OPTIONS_LEN=68 +CONFIG_LWIP_NUM_NETIF_CLIENT_DATA=0 +CONFIG_LWIP_DHCP_COARSE_TIMER_SECS=1 + +# +# DHCP server +# +# CONFIG_LWIP_DHCPS is not set +# end of DHCP server + +# CONFIG_LWIP_AUTOIP is not set +CONFIG_LWIP_IPV4=y +CONFIG_LWIP_IPV6=y +# CONFIG_LWIP_IPV6_AUTOCONFIG is not set +CONFIG_LWIP_IPV6_NUM_ADDRESSES=3 +# CONFIG_LWIP_IPV6_FORWARD is not set +# CONFIG_LWIP_NETIF_STATUS_CALLBACK is not set +CONFIG_LWIP_NETIF_LOOPBACK=y +CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8 + +# +# TCP +# +CONFIG_LWIP_MAX_ACTIVE_TCP=16 +CONFIG_LWIP_MAX_LISTENING_TCP=16 +CONFIG_LWIP_TCP_HIGH_SPEED_RETRANSMISSION=y +CONFIG_LWIP_TCP_MAXRTX=12 +CONFIG_LWIP_TCP_SYNMAXRTX=12 +CONFIG_LWIP_TCP_MSS=1440 +CONFIG_LWIP_TCP_TMR_INTERVAL=250 +CONFIG_LWIP_TCP_MSL=60000 +CONFIG_LWIP_TCP_FIN_WAIT_TIMEOUT=20000 +CONFIG_LWIP_TCP_SND_BUF_DEFAULT=5760 +CONFIG_LWIP_TCP_WND_DEFAULT=5760 +CONFIG_LWIP_TCP_RECVMBOX_SIZE=6 +CONFIG_LWIP_TCP_ACCEPTMBOX_SIZE=6 +CONFIG_LWIP_TCP_QUEUE_OOSEQ=y +CONFIG_LWIP_TCP_OOSEQ_TIMEOUT=6 +CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS=4 +# CONFIG_LWIP_TCP_SACK_OUT is not set +CONFIG_LWIP_TCP_OVERSIZE_MSS=y +# CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set +# CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set +CONFIG_LWIP_TCP_RTO_TIME=1500 +# end of TCP + +# +# UDP +# +CONFIG_LWIP_MAX_UDP_PCBS=16 +CONFIG_LWIP_UDP_RECVMBOX_SIZE=6 +# end of UDP + +# +# Checksums +# +# CONFIG_LWIP_CHECKSUM_CHECK_IP is not set +# CONFIG_LWIP_CHECKSUM_CHECK_UDP is not set +CONFIG_LWIP_CHECKSUM_CHECK_ICMP=y +# end of Checksums + +CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=3072 +CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y +# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set +# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU1 is not set +CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF +# CONFIG_LWIP_PPP_SUPPORT is not set +CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3 +CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5 +# CONFIG_LWIP_SLIP_SUPPORT is not set + +# +# ICMP +# +CONFIG_LWIP_ICMP=y +# CONFIG_LWIP_MULTICAST_PING is not set +# CONFIG_LWIP_BROADCAST_PING is not set +# end of ICMP + +# +# LWIP RAW API +# +CONFIG_LWIP_MAX_RAW_PCBS=16 +# end of LWIP RAW API + +# +# SNTP +# +CONFIG_LWIP_SNTP_MAX_SERVERS=1 +# CONFIG_LWIP_DHCP_GET_NTP_SRV is not set +CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000 +CONFIG_LWIP_SNTP_STARTUP_DELAY=y +CONFIG_LWIP_SNTP_MAXIMUM_STARTUP_DELAY=5000 +# end of SNTP + +# +# DNS +# +CONFIG_LWIP_DNS_MAX_SERVERS=3 +# CONFIG_LWIP_FALLBACK_DNS_SERVER_SUPPORT is not set +# end of DNS + +CONFIG_LWIP_BRIDGEIF_MAX_PORTS=7 +CONFIG_LWIP_ESP_LWIP_ASSERT=y + +# +# Hooks +# +# CONFIG_LWIP_HOOK_TCP_ISN_NONE is not set +CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT=y +# CONFIG_LWIP_HOOK_TCP_ISN_CUSTOM is not set +CONFIG_LWIP_HOOK_IP6_ROUTE_NONE=y +# CONFIG_LWIP_HOOK_IP6_ROUTE_DEFAULT is not set +# CONFIG_LWIP_HOOK_IP6_ROUTE_CUSTOM is not set +CONFIG_LWIP_HOOK_ND6_GET_GW_NONE=y +# CONFIG_LWIP_HOOK_ND6_GET_GW_DEFAULT is not set +# CONFIG_LWIP_HOOK_ND6_GET_GW_CUSTOM is not set +CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_NONE=y +# CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_DEFAULT is not set +# CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_CUSTOM is not set +CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE=y +# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_DEFAULT is not set +# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_CUSTOM is not set +CONFIG_LWIP_HOOK_IP6_INPUT_NONE=y +# CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT is not set +# CONFIG_LWIP_HOOK_IP6_INPUT_CUSTOM is not set +# end of Hooks + +# CONFIG_LWIP_DEBUG is not set +# end of LWIP + +# +# mbedTLS +# +CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC=y +# CONFIG_MBEDTLS_EXTERNAL_MEM_ALLOC is not set +# CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC is not set +# CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC is not set +CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y +CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384 +CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096 +# CONFIG_MBEDTLS_DYNAMIC_BUFFER is not set +# CONFIG_MBEDTLS_DEBUG is not set + +# +# mbedTLS v3.x related +# +# CONFIG_MBEDTLS_SSL_PROTO_TLS1_3 is not set +# CONFIG_MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH is not set +# CONFIG_MBEDTLS_X509_TRUSTED_CERT_CALLBACK is not set +# CONFIG_MBEDTLS_SSL_CONTEXT_SERIALIZATION is not set +CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE=y +CONFIG_MBEDTLS_PKCS7_C=y +# end of mbedTLS v3.x related + +# +# Certificate Bundle +# +CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y +CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=y +# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN is not set +# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_NONE is not set +# CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE is not set +# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEPRECATED_LIST is not set +CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS=200 +# end of Certificate Bundle + +# CONFIG_MBEDTLS_ECP_RESTARTABLE is not set +CONFIG_MBEDTLS_CMAC_C=y +CONFIG_MBEDTLS_HARDWARE_AES=y +CONFIG_MBEDTLS_AES_USE_INTERRUPT=y +CONFIG_MBEDTLS_AES_INTERRUPT_LEVEL=0 +# CONFIG_MBEDTLS_GCM_SUPPORT_NON_AES_CIPHER is not set +CONFIG_MBEDTLS_HARDWARE_MPI=y +# CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI is not set +CONFIG_MBEDTLS_MPI_USE_INTERRUPT=y +CONFIG_MBEDTLS_MPI_INTERRUPT_LEVEL=0 +CONFIG_MBEDTLS_HARDWARE_SHA=y +CONFIG_MBEDTLS_ROM_MD5=y +# CONFIG_MBEDTLS_ATCA_HW_ECDSA_SIGN is not set +# CONFIG_MBEDTLS_ATCA_HW_ECDSA_VERIFY is not set +CONFIG_MBEDTLS_HAVE_TIME=y +# CONFIG_MBEDTLS_PLATFORM_TIME_ALT is not set +# CONFIG_MBEDTLS_HAVE_TIME_DATE is not set +CONFIG_MBEDTLS_ECDSA_DETERMINISTIC=y +CONFIG_MBEDTLS_SHA512_C=y +CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y +# CONFIG_MBEDTLS_TLS_SERVER_ONLY is not set +# CONFIG_MBEDTLS_TLS_CLIENT_ONLY is not set +# CONFIG_MBEDTLS_TLS_DISABLED is not set +CONFIG_MBEDTLS_TLS_SERVER=y +CONFIG_MBEDTLS_TLS_CLIENT=y +CONFIG_MBEDTLS_TLS_ENABLED=y + +# +# TLS Key Exchange Methods +# +# CONFIG_MBEDTLS_PSK_MODES is not set +CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y +# end of TLS Key Exchange Methods + +CONFIG_MBEDTLS_SSL_RENEGOTIATION=y +CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y +# CONFIG_MBEDTLS_SSL_PROTO_GMTSSL1_1 is not set +# CONFIG_MBEDTLS_SSL_PROTO_DTLS is not set +CONFIG_MBEDTLS_SSL_ALPN=y +CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=y +CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=y + +# +# Symmetric Ciphers +# +CONFIG_MBEDTLS_AES_C=y +# CONFIG_MBEDTLS_CAMELLIA_C is not set +# CONFIG_MBEDTLS_DES_C is not set +# CONFIG_MBEDTLS_BLOWFISH_C is not set +# CONFIG_MBEDTLS_XTEA_C is not set +CONFIG_MBEDTLS_CCM_C=y +CONFIG_MBEDTLS_GCM_C=y +# CONFIG_MBEDTLS_NIST_KW_C is not set +# end of Symmetric Ciphers + +# CONFIG_MBEDTLS_RIPEMD160_C is not set + +# +# Certificates +# +CONFIG_MBEDTLS_PEM_PARSE_C=y +CONFIG_MBEDTLS_PEM_WRITE_C=y +CONFIG_MBEDTLS_X509_CRL_PARSE_C=y +CONFIG_MBEDTLS_X509_CSR_PARSE_C=y +# end of Certificates + +CONFIG_MBEDTLS_ECP_C=y +# CONFIG_MBEDTLS_DHM_C is not set +CONFIG_MBEDTLS_ECDH_C=y +CONFIG_MBEDTLS_ECDSA_C=y +# CONFIG_MBEDTLS_ECJPAKE_C is not set +CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y +CONFIG_MBEDTLS_ECP_NIST_OPTIM=y +CONFIG_MBEDTLS_ECP_FIXED_POINT_OPTIM=y +# CONFIG_MBEDTLS_POLY1305_C is not set +# CONFIG_MBEDTLS_CHACHA20_C is not set +# CONFIG_MBEDTLS_HKDF_C is not set +# CONFIG_MBEDTLS_THREADING_C is not set +CONFIG_MBEDTLS_ERROR_STRINGS=y +# end of mbedTLS + +# +# ESP-MQTT Configurations +# +CONFIG_MQTT_PROTOCOL_311=y +# CONFIG_MQTT_PROTOCOL_5 is not set +CONFIG_MQTT_TRANSPORT_SSL=y +CONFIG_MQTT_TRANSPORT_WEBSOCKET=y +CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y +# CONFIG_MQTT_MSG_ID_INCREMENTAL is not set +# CONFIG_MQTT_SKIP_PUBLISH_IF_DISCONNECTED is not set +# CONFIG_MQTT_REPORT_DELETED_MESSAGES is not set +# CONFIG_MQTT_USE_CUSTOM_CONFIG is not set +# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set +# CONFIG_MQTT_CUSTOM_OUTBOX is not set +# end of ESP-MQTT Configurations + +# +# Newlib +# +CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y +# CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF is not set +# CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR is not set +# CONFIG_NEWLIB_STDIN_LINE_ENDING_CRLF is not set +# CONFIG_NEWLIB_STDIN_LINE_ENDING_LF is not set +CONFIG_NEWLIB_STDIN_LINE_ENDING_CR=y +# CONFIG_NEWLIB_NANO_FORMAT is not set +CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT=y +# CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC is not set +# CONFIG_NEWLIB_TIME_SYSCALL_USE_HRT is not set +# CONFIG_NEWLIB_TIME_SYSCALL_USE_NONE is not set +# end of Newlib + +CONFIG_STDATOMIC_S32C1I_SPIRAM_WORKAROUND=y + +# +# NVS +# +# CONFIG_NVS_ENCRYPTION is not set +# CONFIG_NVS_ASSERT_ERROR_CHECK is not set +# CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY is not set +# end of NVS + +# +# OpenThread +# +# CONFIG_OPENTHREAD_ENABLED is not set + +# +# Thread Operational Dataset +# +CONFIG_OPENTHREAD_NETWORK_NAME="OpenThread-ESP" +CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX="fd00:db8:a0:0::/64" +CONFIG_OPENTHREAD_NETWORK_CHANNEL=15 +CONFIG_OPENTHREAD_NETWORK_PANID=0x1234 +CONFIG_OPENTHREAD_NETWORK_EXTPANID="dead00beef00cafe" +CONFIG_OPENTHREAD_NETWORK_MASTERKEY="00112233445566778899aabbccddeeff" +CONFIG_OPENTHREAD_NETWORK_PSKC="104810e2315100afd6bc9215a6bfac53" +# end of Thread Operational Dataset + +CONFIG_OPENTHREAD_XTAL_ACCURACY=130 +# CONFIG_OPENTHREAD_SPINEL_ONLY is not set +CONFIG_OPENTHREAD_RX_ON_WHEN_IDLE=y + +# +# Thread Address Query Config +# +# end of Thread Address Query Config +# end of OpenThread + +# +# Protocomm +# +CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0=y +CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1=y +CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2=y +# end of Protocomm + +# +# PThreads +# +CONFIG_PTHREAD_TASK_PRIO_DEFAULT=5 +CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072 +CONFIG_PTHREAD_STACK_MIN=768 +CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY=y +# CONFIG_PTHREAD_DEFAULT_CORE_0 is not set +# CONFIG_PTHREAD_DEFAULT_CORE_1 is not set +CONFIG_PTHREAD_TASK_CORE_DEFAULT=-1 +CONFIG_PTHREAD_TASK_NAME_DEFAULT="pthread" +# end of PThreads + +# +# MMU Config +# +CONFIG_MMU_PAGE_SIZE_64KB=y +CONFIG_MMU_PAGE_MODE="64KB" +CONFIG_MMU_PAGE_SIZE=0x10000 +# end of MMU Config + +# +# Main Flash configuration +# + +# +# SPI Flash behavior when brownout +# +CONFIG_SPI_FLASH_BROWNOUT_RESET_XMC=y +CONFIG_SPI_FLASH_BROWNOUT_RESET=y +# end of SPI Flash behavior when brownout + +# +# Optional and Experimental Features (READ DOCS FIRST) +# + +# +# Features here require specific hardware (READ DOCS FIRST!) +# +# CONFIG_SPI_FLASH_HPM_ENA is not set +CONFIG_SPI_FLASH_HPM_AUTO=y +# CONFIG_SPI_FLASH_HPM_DIS is not set +CONFIG_SPI_FLASH_HPM_ON=y +CONFIG_SPI_FLASH_HPM_DC_AUTO=y +# CONFIG_SPI_FLASH_HPM_DC_DISABLE is not set +CONFIG_SPI_FLASH_SUSPEND_QVL_SUPPORTED=y +# CONFIG_SPI_FLASH_AUTO_SUSPEND is not set +CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US=50 +# end of Optional and Experimental Features (READ DOCS FIRST) +# end of Main Flash configuration + +# +# SPI Flash driver +# +# CONFIG_SPI_FLASH_VERIFY_WRITE is not set +# CONFIG_SPI_FLASH_ENABLE_COUNTERS is not set +CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y +# CONFIG_SPI_FLASH_ROM_IMPL is not set +CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y +# CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set +# CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set +# CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set +CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y +CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS=20 +CONFIG_SPI_FLASH_ERASE_YIELD_TICKS=1 +CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE=8192 +# CONFIG_SPI_FLASH_SIZE_OVERRIDE is not set +# CONFIG_SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED is not set +# CONFIG_SPI_FLASH_OVERRIDE_CHIP_DRIVER_LIST is not set + +# +# Auto-detect flash chips +# +CONFIG_SPI_FLASH_VENDOR_XMC_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_GD_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_ISSI_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_MXIC_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_WINBOND_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_BOYA_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_TH_SUPPORTED=y +CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_GD_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_TH_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP=y +# end of Auto-detect flash chips + +CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE=y +# end of SPI Flash driver + +# +# SPIFFS Configuration +# +CONFIG_SPIFFS_MAX_PARTITIONS=3 + +# +# SPIFFS Cache Configuration +# +CONFIG_SPIFFS_CACHE=y +CONFIG_SPIFFS_CACHE_WR=y +# CONFIG_SPIFFS_CACHE_STATS is not set +# end of SPIFFS Cache Configuration + +CONFIG_SPIFFS_PAGE_CHECK=y +CONFIG_SPIFFS_GC_MAX_RUNS=10 +# CONFIG_SPIFFS_GC_STATS is not set +CONFIG_SPIFFS_PAGE_SIZE=256 +CONFIG_SPIFFS_OBJ_NAME_LEN=32 +# CONFIG_SPIFFS_FOLLOW_SYMLINKS is not set +CONFIG_SPIFFS_USE_MAGIC=y +CONFIG_SPIFFS_USE_MAGIC_LENGTH=y +CONFIG_SPIFFS_META_LENGTH=4 +CONFIG_SPIFFS_USE_MTIME=y + +# +# Debug Configuration +# +# CONFIG_SPIFFS_DBG is not set +# CONFIG_SPIFFS_API_DBG is not set +# CONFIG_SPIFFS_GC_DBG is not set +# CONFIG_SPIFFS_CACHE_DBG is not set +# CONFIG_SPIFFS_CHECK_DBG is not set +# CONFIG_SPIFFS_TEST_VISUALISATION is not set +# end of Debug Configuration +# end of SPIFFS Configuration + +# +# TCP Transport +# + +# +# Websocket +# +CONFIG_WS_TRANSPORT=y +CONFIG_WS_BUFFER_SIZE=1024 +# CONFIG_WS_DYNAMIC_BUFFER is not set +# end of Websocket +# end of TCP Transport + +# +# Ultra Low Power (ULP) Co-processor +# +# CONFIG_ULP_COPROC_ENABLED is not set + +# +# ULP Debugging Options +# +# end of ULP Debugging Options +# end of Ultra Low Power (ULP) Co-processor + +# +# Unity unit testing library +# +CONFIG_UNITY_ENABLE_FLOAT=y +CONFIG_UNITY_ENABLE_DOUBLE=y +# CONFIG_UNITY_ENABLE_64BIT is not set +# CONFIG_UNITY_ENABLE_COLOR is not set +CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=y +# CONFIG_UNITY_ENABLE_FIXTURE is not set +# CONFIG_UNITY_ENABLE_BACKTRACE_ON_FAIL is not set +# end of Unity unit testing library + +# +# USB-OTG +# +CONFIG_USB_HOST_CONTROL_TRANSFER_MAX_SIZE=256 +CONFIG_USB_HOST_HW_BUFFER_BIAS_BALANCED=y +# CONFIG_USB_HOST_HW_BUFFER_BIAS_IN is not set +# CONFIG_USB_HOST_HW_BUFFER_BIAS_PERIODIC_OUT is not set + +# +# Root Hub configuration +# +CONFIG_USB_HOST_DEBOUNCE_DELAY_MS=250 +CONFIG_USB_HOST_RESET_HOLD_MS=30 +CONFIG_USB_HOST_RESET_RECOVERY_MS=30 +CONFIG_USB_HOST_SET_ADDR_RECOVERY_MS=10 +# end of Root Hub configuration + +# CONFIG_USB_HOST_ENABLE_ENUM_FILTER_CALLBACK is not set +CONFIG_USB_OTG_SUPPORTED=y +# end of USB-OTG + +# +# Virtual file system +# +CONFIG_VFS_SUPPORT_IO=y +CONFIG_VFS_SUPPORT_DIR=y +CONFIG_VFS_SUPPORT_SELECT=y +CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=y +# CONFIG_VFS_SELECT_IN_RAM is not set +CONFIG_VFS_SUPPORT_TERMIOS=y +CONFIG_VFS_MAX_COUNT=8 + +# +# Host File System I/O (Semihosting) +# +CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS=1 +# end of Host File System I/O (Semihosting) +# end of Virtual file system + +# +# Wear Levelling +# +# CONFIG_WL_SECTOR_SIZE_512 is not set +CONFIG_WL_SECTOR_SIZE_4096=y +CONFIG_WL_SECTOR_SIZE=4096 +# end of Wear Levelling + +# +# Wi-Fi Provisioning Manager +# +CONFIG_WIFI_PROV_SCAN_MAX_ENTRIES=16 +CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT=30 +# CONFIG_WIFI_PROV_BLE_FORCE_ENCRYPTION is not set +CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y +# CONFIG_WIFI_PROV_STA_FAST_SCAN is not set +# end of Wi-Fi Provisioning Manager +# end of Component config + +# CONFIG_IDF_EXPERIMENTAL_FEATURES is not set + +# Deprecated options for backward compatibility +# CONFIG_APP_BUILD_TYPE_ELF_RAM is not set +# CONFIG_NO_BLOBS is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set +CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y +# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set +CONFIG_LOG_BOOTLOADER_LEVEL=3 +# CONFIG_APP_ROLLBACK_ENABLE is not set +# CONFIG_FLASH_ENCRYPTION_ENABLED is not set +CONFIG_FLASHMODE_QIO=y +# CONFIG_FLASHMODE_QOUT is not set +# CONFIG_FLASHMODE_DIO is not set +# CONFIG_FLASHMODE_DOUT is not set +CONFIG_MONITOR_BAUD=115200 +CONFIG_OPTIMIZATION_LEVEL_DEBUG=y +CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG=y +CONFIG_COMPILER_OPTIMIZATION_DEFAULT=y +# CONFIG_OPTIMIZATION_LEVEL_RELEASE is not set +# CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE is not set +CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y +# CONFIG_OPTIMIZATION_ASSERTIONS_SILENT is not set +# CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED is not set +CONFIG_OPTIMIZATION_ASSERTION_LEVEL=2 +# CONFIG_CXX_EXCEPTIONS is not set +CONFIG_STACK_CHECK_NONE=y +# CONFIG_STACK_CHECK_NORM is not set +# CONFIG_STACK_CHECK_STRONG is not set +# CONFIG_STACK_CHECK_ALL is not set +# CONFIG_WARN_WRITE_STRINGS is not set +# CONFIG_ESP32_APPTRACE_DEST_TRAX is not set +CONFIG_ESP32_APPTRACE_DEST_NONE=y +CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y +# CONFIG_EXTERNAL_COEX_ENABLE is not set +# CONFIG_ESP_WIFI_EXTERNAL_COEXIST_ENABLE is not set +# CONFIG_MCPWM_ISR_IN_IRAM is not set +# CONFIG_EVENT_LOOP_PROFILING is not set +CONFIG_POST_EVENTS_FROM_ISR=y +CONFIG_POST_EVENTS_FROM_IRAM_ISR=y +CONFIG_GDBSTUB_SUPPORT_TASKS=y +CONFIG_GDBSTUB_MAX_TASKS=32 +# CONFIG_OTA_ALLOW_HTTP is not set +CONFIG_ESP32S3_DEEP_SLEEP_WAKEUP_DELAY=2000 +CONFIG_ESP_SLEEP_DEEP_SLEEP_WAKEUP_DELAY=2000 +CONFIG_ESP32S3_RTC_CLK_SRC_INT_RC=y +# CONFIG_ESP32S3_RTC_CLK_SRC_EXT_CRYS is not set +# CONFIG_ESP32S3_RTC_CLK_SRC_EXT_OSC is not set +# CONFIG_ESP32S3_RTC_CLK_SRC_INT_8MD256 is not set +CONFIG_ESP32S3_RTC_CLK_CAL_CYCLES=1024 +CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE=y +# CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION is not set +CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20 +CONFIG_ESP32_PHY_MAX_TX_POWER=20 +# CONFIG_REDUCE_PHY_TX_POWER is not set +# CONFIG_ESP32_REDUCE_PHY_TX_POWER is not set +CONFIG_ESP_SYSTEM_PM_POWER_DOWN_CPU=y +CONFIG_PM_POWER_DOWN_TAGMEM_IN_LIGHT_SLEEP=y +CONFIG_ESP32S3_SPIRAM_SUPPORT=y +CONFIG_DEFAULT_PSRAM_CLK_IO=30 +CONFIG_DEFAULT_PSRAM_CS_IO=26 +# CONFIG_ESP32S3_DEFAULT_CPU_FREQ_80 is not set +# CONFIG_ESP32S3_DEFAULT_CPU_FREQ_160 is not set +CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y +CONFIG_ESP32S3_DEFAULT_CPU_FREQ_MHZ=240 +CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32 +CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2304 +CONFIG_MAIN_TASK_STACK_SIZE=3584 +# CONFIG_CONSOLE_UART_DEFAULT is not set +# CONFIG_CONSOLE_UART_CUSTOM is not set +# CONFIG_CONSOLE_UART_NONE is not set +# CONFIG_ESP_CONSOLE_UART_NONE is not set +CONFIG_CONSOLE_UART_NUM=-1 +CONFIG_INT_WDT=y +CONFIG_INT_WDT_TIMEOUT_MS=300 +CONFIG_INT_WDT_CHECK_CPU1=y +CONFIG_TASK_WDT=y +CONFIG_ESP_TASK_WDT=y +# CONFIG_TASK_WDT_PANIC is not set +CONFIG_TASK_WDT_TIMEOUT_S=5 +# CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0 is not set +CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=y +# CONFIG_ESP32_DEBUG_STUBS_ENABLE is not set +CONFIG_ESP32S3_DEBUG_OCDAWARE=y +CONFIG_BROWNOUT_DET=y +CONFIG_ESP32S3_BROWNOUT_DET=y +CONFIG_ESP32S3_BROWNOUT_DET=y +CONFIG_BROWNOUT_DET_LVL_SEL_7=y +CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_7=y +# CONFIG_BROWNOUT_DET_LVL_SEL_6 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_6 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_5 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_5 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_4 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_4 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_3 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_3 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_2 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_2 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_1 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_1 is not set +CONFIG_BROWNOUT_DET_LVL=7 +CONFIG_ESP32S3_BROWNOUT_DET_LVL=7 +CONFIG_IPC_TASK_STACK_SIZE=1280 +CONFIG_TIMER_TASK_STACK_SIZE=3584 +CONFIG_ESP32_WIFI_ENABLED=y +CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10 +CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32 +CONFIG_ESP32_WIFI_STATIC_TX_BUFFER=y +CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=0 +CONFIG_ESP32_WIFI_STATIC_TX_BUFFER_NUM=16 +CONFIG_ESP32_WIFI_CACHE_TX_BUFFER_NUM=32 +# CONFIG_ESP32_WIFI_CSI_ENABLED is not set +CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y +CONFIG_ESP32_WIFI_TX_BA_WIN=6 +CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y +CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y +CONFIG_ESP32_WIFI_RX_BA_WIN=6 +CONFIG_ESP32_WIFI_RX_BA_WIN=6 +# CONFIG_ESP32_WIFI_AMSDU_TX_ENABLED is not set +CONFIG_ESP32_WIFI_NVS_ENABLED=y +CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0=y +# CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1 is not set +CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752 +CONFIG_ESP32_WIFI_MGMT_SBUF_NUM=32 +CONFIG_ESP32_WIFI_IRAM_OPT=y +CONFIG_ESP32_WIFI_RX_IRAM_OPT=y +CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE=y +CONFIG_ESP32_WIFI_ENABLE_WPA3_OWE_STA=y +CONFIG_WPA_MBEDTLS_CRYPTO=y +CONFIG_WPA_MBEDTLS_TLS_CLIENT=y +# CONFIG_WPA_WAPI_PSK is not set +# CONFIG_WPA_SUITE_B_192 is not set +# CONFIG_WPA_11KV_SUPPORT is not set +# CONFIG_WPA_MBO_SUPPORT is not set +# CONFIG_WPA_DPP_SUPPORT is not set +# CONFIG_WPA_11R_SUPPORT is not set +# CONFIG_WPA_WPS_SOFTAP_REGISTRAR is not set +# CONFIG_WPA_WPS_STRICT is not set +# CONFIG_WPA_DEBUG_PRINT is not set +# CONFIG_WPA_TESTING_OPTIONS is not set +# CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH is not set +# CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set +CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y +CONFIG_TIMER_TASK_PRIORITY=1 +CONFIG_TIMER_TASK_STACK_DEPTH=4096 +CONFIG_TIMER_QUEUE_LENGTH=10 +# CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK is not set +# CONFIG_HAL_ASSERTION_SILIENT is not set +# CONFIG_L2_TO_L3_COPY is not set +CONFIG_ESP_GRATUITOUS_ARP=y +CONFIG_GARP_TMR_INTERVAL=60 +CONFIG_TCPIP_RECVMBOX_SIZE=32 +CONFIG_TCP_MAXRTX=12 +CONFIG_TCP_SYNMAXRTX=12 +CONFIG_TCP_MSS=1440 +CONFIG_TCP_MSL=60000 +CONFIG_TCP_SND_BUF_DEFAULT=5760 +CONFIG_TCP_WND_DEFAULT=5760 +CONFIG_TCP_RECVMBOX_SIZE=6 +CONFIG_TCP_QUEUE_OOSEQ=y +CONFIG_TCP_OVERSIZE_MSS=y +# CONFIG_TCP_OVERSIZE_QUARTER_MSS is not set +# CONFIG_TCP_OVERSIZE_DISABLE is not set +CONFIG_UDP_RECVMBOX_SIZE=6 +CONFIG_TCPIP_TASK_STACK_SIZE=3072 +CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y +# CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set +# CONFIG_TCPIP_TASK_AFFINITY_CPU1 is not set +CONFIG_TCPIP_TASK_AFFINITY=0x7FFFFFFF +# CONFIG_PPP_SUPPORT is not set +CONFIG_ESP32S3_TIME_SYSCALL_USE_RTC_SYSTIMER=y +CONFIG_ESP32S3_TIME_SYSCALL_USE_RTC_FRC1=y +# CONFIG_ESP32S3_TIME_SYSCALL_USE_RTC is not set +# CONFIG_ESP32S3_TIME_SYSCALL_USE_SYSTIMER is not set +# CONFIG_ESP32S3_TIME_SYSCALL_USE_FRC1 is not set +# CONFIG_ESP32S3_TIME_SYSCALL_USE_NONE is not set +CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5 +CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072 +CONFIG_ESP32_PTHREAD_STACK_MIN=768 +CONFIG_ESP32_DEFAULT_PTHREAD_CORE_NO_AFFINITY=y +# CONFIG_ESP32_DEFAULT_PTHREAD_CORE_0 is not set +# CONFIG_ESP32_DEFAULT_PTHREAD_CORE_1 is not set +CONFIG_ESP32_PTHREAD_TASK_CORE_DEFAULT=-1 +CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread" +CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS=y +# CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_FAILS is not set +# CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED is not set +CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y +CONFIG_SUPPORT_TERMIOS=y +CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS=1 +# End of deprecated options diff --git a/sdkconfig.defaults.esp32s3 b/sdkconfig.defaults.esp32s3 new file mode 100644 index 0000000..3832d81 --- /dev/null +++ b/sdkconfig.defaults.esp32s3 @@ -0,0 +1,7 @@ +CONFIG_SPIRAM=y +CONFIG_SPIRAM_SPEED_80M=y + +# Enabling the following configurations can help increase the PCLK frequency in the case when +# the Frame Buffer is allocated from the PSRAM and fetched by EDMA +CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y +CONFIG_SPIRAM_RODATA=y diff --git a/sdkconfig.old b/sdkconfig.old new file mode 100644 index 0000000..65fd7dc --- /dev/null +++ b/sdkconfig.old @@ -0,0 +1,2203 @@ +# +# Automatically generated file. DO NOT EDIT. +# Espressif IoT Development Framework (ESP-IDF) 5.3.0 Project Configuration +# +CONFIG_SOC_MPU_MIN_REGION_SIZE=0x20000000 +CONFIG_SOC_MPU_REGIONS_MAX_NUM=8 +CONFIG_SOC_ADC_SUPPORTED=y +CONFIG_SOC_UART_SUPPORTED=y +CONFIG_SOC_PCNT_SUPPORTED=y +CONFIG_SOC_PHY_SUPPORTED=y +CONFIG_SOC_WIFI_SUPPORTED=y +CONFIG_SOC_TWAI_SUPPORTED=y +CONFIG_SOC_GDMA_SUPPORTED=y +CONFIG_SOC_AHB_GDMA_SUPPORTED=y +CONFIG_SOC_GPTIMER_SUPPORTED=y +CONFIG_SOC_LCDCAM_SUPPORTED=y +CONFIG_SOC_MCPWM_SUPPORTED=y +CONFIG_SOC_DEDICATED_GPIO_SUPPORTED=y +CONFIG_SOC_CACHE_SUPPORT_WRAP=y +CONFIG_SOC_ULP_SUPPORTED=y +CONFIG_SOC_ULP_FSM_SUPPORTED=y +CONFIG_SOC_RISCV_COPROC_SUPPORTED=y +CONFIG_SOC_BT_SUPPORTED=y +CONFIG_SOC_USB_OTG_SUPPORTED=y +CONFIG_SOC_USB_SERIAL_JTAG_SUPPORTED=y +CONFIG_SOC_CCOMP_TIMER_SUPPORTED=y +CONFIG_SOC_ASYNC_MEMCPY_SUPPORTED=y +CONFIG_SOC_SUPPORTS_SECURE_DL_MODE=y +CONFIG_SOC_EFUSE_KEY_PURPOSE_FIELD=y +CONFIG_SOC_EFUSE_SUPPORTED=y +CONFIG_SOC_SDMMC_HOST_SUPPORTED=y +CONFIG_SOC_RTC_FAST_MEM_SUPPORTED=y +CONFIG_SOC_RTC_SLOW_MEM_SUPPORTED=y +CONFIG_SOC_RTC_MEM_SUPPORTED=y +CONFIG_SOC_PSRAM_DMA_CAPABLE=y +CONFIG_SOC_XT_WDT_SUPPORTED=y +CONFIG_SOC_I2S_SUPPORTED=y +CONFIG_SOC_RMT_SUPPORTED=y +CONFIG_SOC_SDM_SUPPORTED=y +CONFIG_SOC_GPSPI_SUPPORTED=y +CONFIG_SOC_LEDC_SUPPORTED=y +CONFIG_SOC_I2C_SUPPORTED=y +CONFIG_SOC_SYSTIMER_SUPPORTED=y +CONFIG_SOC_SUPPORT_COEXISTENCE=y +CONFIG_SOC_TEMP_SENSOR_SUPPORTED=y +CONFIG_SOC_AES_SUPPORTED=y +CONFIG_SOC_MPI_SUPPORTED=y +CONFIG_SOC_SHA_SUPPORTED=y +CONFIG_SOC_HMAC_SUPPORTED=y +CONFIG_SOC_DIG_SIGN_SUPPORTED=y +CONFIG_SOC_FLASH_ENC_SUPPORTED=y +CONFIG_SOC_SECURE_BOOT_SUPPORTED=y +CONFIG_SOC_MEMPROT_SUPPORTED=y +CONFIG_SOC_TOUCH_SENSOR_SUPPORTED=y +CONFIG_SOC_BOD_SUPPORTED=y +CONFIG_SOC_CLK_TREE_SUPPORTED=y +CONFIG_SOC_MPU_SUPPORTED=y +CONFIG_SOC_WDT_SUPPORTED=y +CONFIG_SOC_SPI_FLASH_SUPPORTED=y +CONFIG_SOC_RNG_SUPPORTED=y +CONFIG_SOC_LIGHT_SLEEP_SUPPORTED=y +CONFIG_SOC_DEEP_SLEEP_SUPPORTED=y +CONFIG_SOC_LP_PERIPH_SHARE_INTERRUPT=y +CONFIG_SOC_PM_SUPPORTED=y +CONFIG_SOC_XTAL_SUPPORT_40M=y +CONFIG_SOC_APPCPU_HAS_CLOCK_GATING_BUG=y +CONFIG_SOC_ADC_RTC_CTRL_SUPPORTED=y +CONFIG_SOC_ADC_DIG_CTRL_SUPPORTED=y +CONFIG_SOC_ADC_ARBITER_SUPPORTED=y +CONFIG_SOC_ADC_DIG_IIR_FILTER_SUPPORTED=y +CONFIG_SOC_ADC_MONITOR_SUPPORTED=y +CONFIG_SOC_ADC_DMA_SUPPORTED=y +CONFIG_SOC_ADC_PERIPH_NUM=2 +CONFIG_SOC_ADC_MAX_CHANNEL_NUM=10 +CONFIG_SOC_ADC_ATTEN_NUM=4 +CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM=2 +CONFIG_SOC_ADC_PATT_LEN_MAX=24 +CONFIG_SOC_ADC_DIGI_MIN_BITWIDTH=12 +CONFIG_SOC_ADC_DIGI_MAX_BITWIDTH=12 +CONFIG_SOC_ADC_DIGI_RESULT_BYTES=4 +CONFIG_SOC_ADC_DIGI_DATA_BYTES_PER_CONV=4 +CONFIG_SOC_ADC_DIGI_IIR_FILTER_NUM=2 +CONFIG_SOC_ADC_DIGI_MONITOR_NUM=2 +CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_HIGH=83333 +CONFIG_SOC_ADC_SAMPLE_FREQ_THRES_LOW=611 +CONFIG_SOC_ADC_RTC_MIN_BITWIDTH=12 +CONFIG_SOC_ADC_RTC_MAX_BITWIDTH=12 +CONFIG_SOC_ADC_CALIBRATION_V1_SUPPORTED=y +CONFIG_SOC_ADC_SELF_HW_CALI_SUPPORTED=y +CONFIG_SOC_ADC_SHARED_POWER=y +CONFIG_SOC_APB_BACKUP_DMA=y +CONFIG_SOC_BROWNOUT_RESET_SUPPORTED=y +CONFIG_SOC_CACHE_WRITEBACK_SUPPORTED=y +CONFIG_SOC_CACHE_FREEZE_SUPPORTED=y +CONFIG_SOC_CPU_CORES_NUM=2 +CONFIG_SOC_CPU_INTR_NUM=32 +CONFIG_SOC_CPU_HAS_FPU=y +CONFIG_SOC_HP_CPU_HAS_MULTIPLE_CORES=y +CONFIG_SOC_CPU_BREAKPOINTS_NUM=2 +CONFIG_SOC_CPU_WATCHPOINTS_NUM=2 +CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=64 +CONFIG_SOC_DS_SIGNATURE_MAX_BIT_LEN=4096 +CONFIG_SOC_DS_KEY_PARAM_MD_IV_LENGTH=16 +CONFIG_SOC_DS_KEY_CHECK_MAX_WAIT_US=1100 +CONFIG_SOC_AHB_GDMA_VERSION=1 +CONFIG_SOC_GDMA_NUM_GROUPS_MAX=1 +CONFIG_SOC_GDMA_PAIRS_PER_GROUP=5 +CONFIG_SOC_GDMA_PAIRS_PER_GROUP_MAX=5 +CONFIG_SOC_AHB_GDMA_SUPPORT_PSRAM=y +CONFIG_SOC_GPIO_PORT=1 +CONFIG_SOC_GPIO_PIN_COUNT=49 +CONFIG_SOC_GPIO_SUPPORT_PIN_GLITCH_FILTER=y +CONFIG_SOC_GPIO_FILTER_CLK_SUPPORT_APB=y +CONFIG_SOC_GPIO_SUPPORT_RTC_INDEPENDENT=y +CONFIG_SOC_GPIO_SUPPORT_FORCE_HOLD=y +CONFIG_SOC_GPIO_VALID_GPIO_MASK=0x1FFFFFFFFFFFF +CONFIG_SOC_GPIO_IN_RANGE_MAX=48 +CONFIG_SOC_GPIO_OUT_RANGE_MAX=48 +CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK=0x0001FFFFFC000000 +CONFIG_SOC_GPIO_CLOCKOUT_BY_IO_MUX=y +CONFIG_SOC_GPIO_CLOCKOUT_CHANNEL_NUM=3 +CONFIG_SOC_DEDIC_GPIO_OUT_CHANNELS_NUM=8 +CONFIG_SOC_DEDIC_GPIO_IN_CHANNELS_NUM=8 +CONFIG_SOC_DEDIC_GPIO_OUT_AUTO_ENABLE=y +CONFIG_SOC_I2C_NUM=2 +CONFIG_SOC_HP_I2C_NUM=2 +CONFIG_SOC_I2C_FIFO_LEN=32 +CONFIG_SOC_I2C_CMD_REG_NUM=8 +CONFIG_SOC_I2C_SUPPORT_SLAVE=y +CONFIG_SOC_I2C_SUPPORT_HW_CLR_BUS=y +CONFIG_SOC_I2C_SUPPORT_XTAL=y +CONFIG_SOC_I2C_SUPPORT_RTC=y +CONFIG_SOC_I2C_SUPPORT_10BIT_ADDR=y +CONFIG_SOC_I2C_SLAVE_SUPPORT_BROADCAST=y +CONFIG_SOC_I2C_SLAVE_SUPPORT_I2CRAM_ACCESS=y +CONFIG_SOC_I2S_NUM=2 +CONFIG_SOC_I2S_HW_VERSION_2=y +CONFIG_SOC_I2S_SUPPORTS_XTAL=y +CONFIG_SOC_I2S_SUPPORTS_PLL_F160M=y +CONFIG_SOC_I2S_SUPPORTS_PCM=y +CONFIG_SOC_I2S_SUPPORTS_PDM=y +CONFIG_SOC_I2S_SUPPORTS_PDM_TX=y +CONFIG_SOC_I2S_PDM_MAX_TX_LINES=2 +CONFIG_SOC_I2S_SUPPORTS_PDM_RX=y +CONFIG_SOC_I2S_PDM_MAX_RX_LINES=4 +CONFIG_SOC_I2S_SUPPORTS_TDM=y +CONFIG_SOC_LEDC_SUPPORT_APB_CLOCK=y +CONFIG_SOC_LEDC_SUPPORT_XTAL_CLOCK=y +CONFIG_SOC_LEDC_CHANNEL_NUM=8 +CONFIG_SOC_LEDC_TIMER_BIT_WIDTH=14 +CONFIG_SOC_LEDC_SUPPORT_FADE_STOP=y +CONFIG_SOC_MCPWM_GROUPS=2 +CONFIG_SOC_MCPWM_TIMERS_PER_GROUP=3 +CONFIG_SOC_MCPWM_OPERATORS_PER_GROUP=3 +CONFIG_SOC_MCPWM_COMPARATORS_PER_OPERATOR=2 +CONFIG_SOC_MCPWM_GENERATORS_PER_OPERATOR=2 +CONFIG_SOC_MCPWM_TRIGGERS_PER_OPERATOR=2 +CONFIG_SOC_MCPWM_GPIO_FAULTS_PER_GROUP=3 +CONFIG_SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP=y +CONFIG_SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER=3 +CONFIG_SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP=3 +CONFIG_SOC_MCPWM_SWSYNC_CAN_PROPAGATE=y +CONFIG_SOC_MMU_LINEAR_ADDRESS_REGION_NUM=1 +CONFIG_SOC_MMU_PERIPH_NUM=1 +CONFIG_SOC_PCNT_GROUPS=1 +CONFIG_SOC_PCNT_UNITS_PER_GROUP=4 +CONFIG_SOC_PCNT_CHANNELS_PER_UNIT=2 +CONFIG_SOC_PCNT_THRES_POINT_PER_UNIT=2 +CONFIG_SOC_RMT_GROUPS=1 +CONFIG_SOC_RMT_TX_CANDIDATES_PER_GROUP=4 +CONFIG_SOC_RMT_RX_CANDIDATES_PER_GROUP=4 +CONFIG_SOC_RMT_CHANNELS_PER_GROUP=8 +CONFIG_SOC_RMT_MEM_WORDS_PER_CHANNEL=48 +CONFIG_SOC_RMT_SUPPORT_RX_PINGPONG=y +CONFIG_SOC_RMT_SUPPORT_RX_DEMODULATION=y +CONFIG_SOC_RMT_SUPPORT_TX_ASYNC_STOP=y +CONFIG_SOC_RMT_SUPPORT_TX_LOOP_COUNT=y +CONFIG_SOC_RMT_SUPPORT_TX_LOOP_AUTO_STOP=y +CONFIG_SOC_RMT_SUPPORT_TX_SYNCHRO=y +CONFIG_SOC_RMT_SUPPORT_TX_CARRIER_DATA_ONLY=y +CONFIG_SOC_RMT_SUPPORT_XTAL=y +CONFIG_SOC_RMT_SUPPORT_RC_FAST=y +CONFIG_SOC_RMT_SUPPORT_APB=y +CONFIG_SOC_RMT_SUPPORT_DMA=y +CONFIG_SOC_LCD_I80_SUPPORTED=y +CONFIG_SOC_LCD_RGB_SUPPORTED=y +CONFIG_SOC_LCD_I80_BUSES=1 +CONFIG_SOC_LCD_RGB_PANELS=1 +CONFIG_SOC_LCD_I80_BUS_WIDTH=16 +CONFIG_SOC_LCD_RGB_DATA_WIDTH=16 +CONFIG_SOC_LCD_SUPPORT_RGB_YUV_CONV=y +CONFIG_SOC_RTC_CNTL_CPU_PD_DMA_BUS_WIDTH=128 +CONFIG_SOC_RTC_CNTL_CPU_PD_REG_FILE_NUM=549 +CONFIG_SOC_RTC_CNTL_TAGMEM_PD_DMA_BUS_WIDTH=128 +CONFIG_SOC_RTCIO_PIN_COUNT=22 +CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED=y +CONFIG_SOC_RTCIO_HOLD_SUPPORTED=y +CONFIG_SOC_RTCIO_WAKE_SUPPORTED=y +CONFIG_SOC_SDM_GROUPS=y +CONFIG_SOC_SDM_CHANNELS_PER_GROUP=8 +CONFIG_SOC_SDM_CLK_SUPPORT_APB=y +CONFIG_SOC_SPI_PERIPH_NUM=3 +CONFIG_SOC_SPI_MAX_CS_NUM=6 +CONFIG_SOC_SPI_MAXIMUM_BUFFER_SIZE=64 +CONFIG_SOC_SPI_SUPPORT_DDRCLK=y +CONFIG_SOC_SPI_SLAVE_SUPPORT_SEG_TRANS=y +CONFIG_SOC_SPI_SUPPORT_CD_SIG=y +CONFIG_SOC_SPI_SUPPORT_CONTINUOUS_TRANS=y +CONFIG_SOC_SPI_SUPPORT_SLAVE_HD_VER2=y +CONFIG_SOC_SPI_SUPPORT_CLK_APB=y +CONFIG_SOC_SPI_SUPPORT_CLK_XTAL=y +CONFIG_SOC_SPI_PERIPH_SUPPORT_CONTROL_DUMMY_OUT=y +CONFIG_SOC_MEMSPI_IS_INDEPENDENT=y +CONFIG_SOC_SPI_MAX_PRE_DIVIDER=16 +CONFIG_SOC_SPI_SUPPORT_OCT=y +CONFIG_SOC_SPI_SCT_SUPPORTED=y +CONFIG_SOC_SPI_SCT_REG_NUM=14 +CONFIG_SOC_SPI_SCT_BUFFER_NUM_MAX=y +CONFIG_SOC_SPI_SCT_CONF_BITLEN_MAX=0x3FFFA +CONFIG_SOC_MEMSPI_SRC_FREQ_120M=y +CONFIG_SOC_MEMSPI_SRC_FREQ_80M_SUPPORTED=y +CONFIG_SOC_MEMSPI_SRC_FREQ_40M_SUPPORTED=y +CONFIG_SOC_MEMSPI_SRC_FREQ_20M_SUPPORTED=y +CONFIG_SOC_SPIRAM_SUPPORTED=y +CONFIG_SOC_SPIRAM_XIP_SUPPORTED=y +CONFIG_SOC_SYSTIMER_COUNTER_NUM=2 +CONFIG_SOC_SYSTIMER_ALARM_NUM=3 +CONFIG_SOC_SYSTIMER_BIT_WIDTH_LO=32 +CONFIG_SOC_SYSTIMER_BIT_WIDTH_HI=20 +CONFIG_SOC_SYSTIMER_FIXED_DIVIDER=y +CONFIG_SOC_SYSTIMER_INT_LEVEL=y +CONFIG_SOC_SYSTIMER_ALARM_MISS_COMPENSATE=y +CONFIG_SOC_TIMER_GROUPS=2 +CONFIG_SOC_TIMER_GROUP_TIMERS_PER_GROUP=2 +CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH=54 +CONFIG_SOC_TIMER_GROUP_SUPPORT_XTAL=y +CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y +CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=4 +CONFIG_SOC_TOUCH_SENSOR_VERSION=2 +CONFIG_SOC_TOUCH_SENSOR_NUM=15 +CONFIG_SOC_TOUCH_PROXIMITY_CHANNEL_NUM=3 +CONFIG_SOC_TOUCH_PROXIMITY_MEAS_DONE_SUPPORTED=y +CONFIG_SOC_TOUCH_SAMPLER_NUM=1 +CONFIG_SOC_TWAI_CONTROLLER_NUM=1 +CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y +CONFIG_SOC_TWAI_BRP_MIN=2 +CONFIG_SOC_TWAI_BRP_MAX=16384 +CONFIG_SOC_TWAI_SUPPORTS_RX_STATUS=y +CONFIG_SOC_UART_NUM=3 +CONFIG_SOC_UART_HP_NUM=3 +CONFIG_SOC_UART_FIFO_LEN=128 +CONFIG_SOC_UART_BITRATE_MAX=5000000 +CONFIG_SOC_UART_SUPPORT_FSM_TX_WAIT_SEND=y +CONFIG_SOC_UART_SUPPORT_WAKEUP_INT=y +CONFIG_SOC_UART_SUPPORT_APB_CLK=y +CONFIG_SOC_UART_SUPPORT_RTC_CLK=y +CONFIG_SOC_UART_SUPPORT_XTAL_CLK=y +CONFIG_SOC_USB_OTG_PERIPH_NUM=1 +CONFIG_SOC_SHA_DMA_MAX_BUFFER_SIZE=3968 +CONFIG_SOC_SHA_SUPPORT_DMA=y +CONFIG_SOC_SHA_SUPPORT_RESUME=y +CONFIG_SOC_SHA_GDMA=y +CONFIG_SOC_SHA_SUPPORT_SHA1=y +CONFIG_SOC_SHA_SUPPORT_SHA224=y +CONFIG_SOC_SHA_SUPPORT_SHA256=y +CONFIG_SOC_SHA_SUPPORT_SHA384=y +CONFIG_SOC_SHA_SUPPORT_SHA512=y +CONFIG_SOC_SHA_SUPPORT_SHA512_224=y +CONFIG_SOC_SHA_SUPPORT_SHA512_256=y +CONFIG_SOC_SHA_SUPPORT_SHA512_T=y +CONFIG_SOC_MPI_MEM_BLOCKS_NUM=4 +CONFIG_SOC_MPI_OPERATIONS_NUM=3 +CONFIG_SOC_RSA_MAX_BIT_LEN=4096 +CONFIG_SOC_AES_SUPPORT_DMA=y +CONFIG_SOC_AES_GDMA=y +CONFIG_SOC_AES_SUPPORT_AES_128=y +CONFIG_SOC_AES_SUPPORT_AES_256=y +CONFIG_SOC_PM_SUPPORT_EXT0_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_EXT1_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_EXT_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_WIFI_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_BT_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP=y +CONFIG_SOC_PM_SUPPORT_CPU_PD=y +CONFIG_SOC_PM_SUPPORT_TAGMEM_PD=y +CONFIG_SOC_PM_SUPPORT_RTC_PERIPH_PD=y +CONFIG_SOC_PM_SUPPORT_RC_FAST_PD=y +CONFIG_SOC_PM_SUPPORT_VDDSDIO_PD=y +CONFIG_SOC_PM_SUPPORT_MAC_BB_PD=y +CONFIG_SOC_PM_SUPPORT_MODEM_PD=y +CONFIG_SOC_CONFIGURABLE_VDDSDIO_SUPPORTED=y +CONFIG_SOC_PM_SUPPORT_DEEPSLEEP_CHECK_STUB_ONLY=y +CONFIG_SOC_PM_CPU_RETENTION_BY_RTCCNTL=y +CONFIG_SOC_PM_MODEM_RETENTION_BY_BACKUPDMA=y +CONFIG_SOC_CLK_RC_FAST_D256_SUPPORTED=y +CONFIG_SOC_RTC_SLOW_CLK_SUPPORT_RC_FAST_D256=y +CONFIG_SOC_CLK_RC_FAST_SUPPORT_CALIBRATION=y +CONFIG_SOC_CLK_XTAL32K_SUPPORTED=y +CONFIG_SOC_EFUSE_DIS_DOWNLOAD_ICACHE=y +CONFIG_SOC_EFUSE_DIS_DOWNLOAD_DCACHE=y +CONFIG_SOC_EFUSE_HARD_DIS_JTAG=y +CONFIG_SOC_EFUSE_DIS_USB_JTAG=y +CONFIG_SOC_EFUSE_SOFT_DIS_JTAG=y +CONFIG_SOC_EFUSE_DIS_DIRECT_BOOT=y +CONFIG_SOC_EFUSE_DIS_ICACHE=y +CONFIG_SOC_EFUSE_BLOCK9_KEY_PURPOSE_QUIRK=y +CONFIG_SOC_SECURE_BOOT_V2_RSA=y +CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS=3 +CONFIG_SOC_EFUSE_REVOKE_BOOT_KEY_DIGESTS=y +CONFIG_SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY=y +CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX=64 +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES=y +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_OPTIONS=y +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_128=y +CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_256=y +CONFIG_SOC_MEMPROT_CPU_PREFETCH_PAD_SIZE=16 +CONFIG_SOC_MEMPROT_MEM_ALIGN_SIZE=256 +CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE=21 +CONFIG_SOC_MAC_BB_PD_MEM_SIZE=192 +CONFIG_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH=12 +CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_WAIT_IDLE=y +CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_SUSPEND=y +CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_RESUME=y +CONFIG_SOC_SPI_MEM_SUPPORT_SW_SUSPEND=y +CONFIG_SOC_SPI_MEM_SUPPORT_OPI_MODE=y +CONFIG_SOC_SPI_MEM_SUPPORT_TIMING_TUNING=y +CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE=y +CONFIG_SOC_SPI_MEM_SUPPORT_WRAP=y +CONFIG_SOC_MEMSPI_TIMING_TUNING_BY_MSPI_DELAY=y +CONFIG_SOC_MEMSPI_CORE_CLK_SHARED_WITH_PSRAM=y +CONFIG_SOC_COEX_HW_PTI=y +CONFIG_SOC_EXTERNAL_COEX_LEADER_TX_LINE=y +CONFIG_SOC_SDMMC_USE_GPIO_MATRIX=y +CONFIG_SOC_SDMMC_NUM_SLOTS=2 +CONFIG_SOC_SDMMC_SUPPORT_XTAL_CLOCK=y +CONFIG_SOC_SDMMC_DELAY_PHASE_NUM=4 +CONFIG_SOC_TEMPERATURE_SENSOR_SUPPORT_FAST_RC=y +CONFIG_SOC_WIFI_HW_TSF=y +CONFIG_SOC_WIFI_FTM_SUPPORT=y +CONFIG_SOC_WIFI_GCMP_SUPPORT=y +CONFIG_SOC_WIFI_WAPI_SUPPORT=y +CONFIG_SOC_WIFI_CSI_SUPPORT=y +CONFIG_SOC_WIFI_MESH_SUPPORT=y +CONFIG_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW=y +CONFIG_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND=y +CONFIG_SOC_BLE_SUPPORTED=y +CONFIG_SOC_BLE_MESH_SUPPORTED=y +CONFIG_SOC_BLE_50_SUPPORTED=y +CONFIG_SOC_BLE_DEVICE_PRIVACY_SUPPORTED=y +CONFIG_SOC_BLUFI_SUPPORTED=y +CONFIG_SOC_ULP_HAS_ADC=y +CONFIG_SOC_PHY_COMBO_MODULE=y +CONFIG_IDF_CMAKE=y +CONFIG_IDF_TOOLCHAIN="gcc" +CONFIG_IDF_TARGET_ARCH_XTENSA=y +CONFIG_IDF_TARGET_ARCH="xtensa" +CONFIG_IDF_TARGET="esp32s3" +CONFIG_IDF_INIT_VERSION="5.3.0" +CONFIG_IDF_TARGET_ESP32S3=y +CONFIG_IDF_FIRMWARE_CHIP_ID=0x0009 + +# +# Build type +# +CONFIG_APP_BUILD_TYPE_APP_2NDBOOT=y +# CONFIG_APP_BUILD_TYPE_RAM is not set +CONFIG_APP_BUILD_GENERATE_BINARIES=y +CONFIG_APP_BUILD_BOOTLOADER=y +CONFIG_APP_BUILD_USE_FLASH_SECTIONS=y +# CONFIG_APP_REPRODUCIBLE_BUILD is not set +# CONFIG_APP_NO_BLOBS is not set +# end of Build type + +# +# Bootloader config +# + +# +# Bootloader manager +# +CONFIG_BOOTLOADER_COMPILE_TIME_DATE=y +CONFIG_BOOTLOADER_PROJECT_VER=1 +# end of Bootloader manager + +CONFIG_BOOTLOADER_OFFSET_IN_FLASH=0x0 +CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y +# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_DEBUG is not set +# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_PERF is not set +# CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_NONE is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_NONE is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_ERROR is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_WARN is not set +CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y +# CONFIG_BOOTLOADER_LOG_LEVEL_DEBUG is not set +# CONFIG_BOOTLOADER_LOG_LEVEL_VERBOSE is not set +CONFIG_BOOTLOADER_LOG_LEVEL=3 + +# +# Serial Flash Configurations +# +# CONFIG_BOOTLOADER_FLASH_DC_AWARE is not set +CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y +# end of Serial Flash Configurations + +CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V=y +# CONFIG_BOOTLOADER_FACTORY_RESET is not set +# CONFIG_BOOTLOADER_APP_TEST is not set +CONFIG_BOOTLOADER_REGION_PROTECTION_ENABLE=y +CONFIG_BOOTLOADER_WDT_ENABLE=y +# CONFIG_BOOTLOADER_WDT_DISABLE_IN_USER_CODE is not set +CONFIG_BOOTLOADER_WDT_TIME_MS=9000 +# CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE is not set +# CONFIG_BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP is not set +# CONFIG_BOOTLOADER_SKIP_VALIDATE_ON_POWER_ON is not set +# CONFIG_BOOTLOADER_SKIP_VALIDATE_ALWAYS is not set +CONFIG_BOOTLOADER_RESERVE_RTC_SIZE=0 +# CONFIG_BOOTLOADER_CUSTOM_RESERVE_RTC is not set +# end of Bootloader config + +# +# Security features +# +CONFIG_SECURE_BOOT_V2_RSA_SUPPORTED=y +CONFIG_SECURE_BOOT_V2_PREFERRED=y +# CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT is not set +# CONFIG_SECURE_BOOT is not set +# CONFIG_SECURE_FLASH_ENC_ENABLED is not set +CONFIG_SECURE_ROM_DL_MODE_ENABLED=y +# end of Security features + +# +# Application manager +# +CONFIG_APP_COMPILE_TIME_DATE=y +# CONFIG_APP_EXCLUDE_PROJECT_VER_VAR is not set +# CONFIG_APP_EXCLUDE_PROJECT_NAME_VAR is not set +# CONFIG_APP_PROJECT_VER_FROM_CONFIG is not set +CONFIG_APP_RETRIEVE_LEN_ELF_SHA=9 +# end of Application manager + +CONFIG_ESP_ROM_HAS_CRC_LE=y +CONFIG_ESP_ROM_HAS_CRC_BE=y +CONFIG_ESP_ROM_HAS_MZ_CRC32=y +CONFIG_ESP_ROM_HAS_JPEG_DECODE=y +CONFIG_ESP_ROM_UART_CLK_IS_XTAL=y +CONFIG_ESP_ROM_HAS_RETARGETABLE_LOCKING=y +CONFIG_ESP_ROM_USB_OTG_NUM=3 +CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM=4 +CONFIG_ESP_ROM_HAS_ERASE_0_REGION_BUG=y +CONFIG_ESP_ROM_HAS_ENCRYPTED_WRITES_USING_LEGACY_DRV=y +CONFIG_ESP_ROM_GET_CLK_FREQ=y +CONFIG_ESP_ROM_HAS_HAL_WDT=y +CONFIG_ESP_ROM_NEEDS_SWSETUP_WORKAROUND=y +CONFIG_ESP_ROM_HAS_LAYOUT_TABLE=y +CONFIG_ESP_ROM_HAS_SPI_FLASH=y +CONFIG_ESP_ROM_HAS_ETS_PRINTF_BUG=y +CONFIG_ESP_ROM_HAS_NEWLIB=y +CONFIG_ESP_ROM_HAS_NEWLIB_NANO_FORMAT=y +CONFIG_ESP_ROM_HAS_NEWLIB_32BIT_TIME=y +CONFIG_ESP_ROM_NEEDS_SET_CACHE_MMU_SIZE=y +CONFIG_ESP_ROM_RAM_APP_NEEDS_MMU_INIT=y +CONFIG_ESP_ROM_HAS_FLASH_COUNT_PAGES_BUG=y +CONFIG_ESP_ROM_HAS_CACHE_SUSPEND_WAITI_BUG=y +CONFIG_ESP_ROM_HAS_CACHE_WRITEBACK_BUG=y +CONFIG_ESP_ROM_HAS_SW_FLOAT=y +CONFIG_ESP_ROM_HAS_VERSION=y +CONFIG_ESP_ROM_SUPPORT_DEEP_SLEEP_WAKEUP_STUB=y + +# +# Boot ROM Behavior +# +CONFIG_BOOT_ROM_LOG_ALWAYS_ON=y +# CONFIG_BOOT_ROM_LOG_ALWAYS_OFF is not set +# CONFIG_BOOT_ROM_LOG_ON_GPIO_HIGH is not set +# CONFIG_BOOT_ROM_LOG_ON_GPIO_LOW is not set +# end of Boot ROM Behavior + +# +# Serial flasher config +# +# CONFIG_ESPTOOLPY_NO_STUB is not set +# CONFIG_ESPTOOLPY_OCT_FLASH is not set +CONFIG_ESPTOOLPY_FLASH_MODE_AUTO_DETECT=y +CONFIG_ESPTOOLPY_FLASHMODE_QIO=y +# CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set +# CONFIG_ESPTOOLPY_FLASHMODE_DIO is not set +# CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set +CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y +CONFIG_ESPTOOLPY_FLASHMODE="dio" +# CONFIG_ESPTOOLPY_FLASHFREQ_120M is not set +CONFIG_ESPTOOLPY_FLASHFREQ_80M=y +# CONFIG_ESPTOOLPY_FLASHFREQ_40M is not set +# CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set +CONFIG_ESPTOOLPY_FLASHFREQ_80M_DEFAULT=y +CONFIG_ESPTOOLPY_FLASHFREQ="80m" +# CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_2MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set +CONFIG_ESPTOOLPY_FLASHSIZE_16MB=y +# CONFIG_ESPTOOLPY_FLASHSIZE_32MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_64MB is not set +# CONFIG_ESPTOOLPY_FLASHSIZE_128MB is not set +CONFIG_ESPTOOLPY_FLASHSIZE="16MB" +# CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE is not set +CONFIG_ESPTOOLPY_BEFORE_RESET=y +# CONFIG_ESPTOOLPY_BEFORE_NORESET is not set +CONFIG_ESPTOOLPY_BEFORE="default_reset" +CONFIG_ESPTOOLPY_AFTER_RESET=y +# CONFIG_ESPTOOLPY_AFTER_NORESET is not set +CONFIG_ESPTOOLPY_AFTER="hard_reset" +CONFIG_ESPTOOLPY_MONITOR_BAUD=115200 +# end of Serial flasher config + +# +# Partition Table +# +# CONFIG_PARTITION_TABLE_SINGLE_APP is not set +# CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE is not set +# CONFIG_PARTITION_TABLE_TWO_OTA is not set +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions_3D.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions_3D.csv" +CONFIG_PARTITION_TABLE_OFFSET=0x8000 +CONFIG_PARTITION_TABLE_MD5=y +# end of Partition Table + +# +# Example Configuration +# +# CONFIG_EXAMPLE_LCD_I80_COLOR_IN_PSRAM is not set +CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ST7789=y +# CONFIG_EXAMPLE_LCD_I80_CONTROLLER_NT35510 is not set +# CONFIG_EXAMPLE_LCD_I80_CONTROLLER_ILI9341 is not set +CONFIG_EXAMPLE_LCD_I80_BUS_WIDTH=8 +# CONFIG_EXAMPLE_LCD_TOUCH_ENABLED is not set +# CONFIG_EXAMPLE_LCD_IMAGE_FROM_FILE_SYSTEM is not set +CONFIG_EXAMPLE_LCD_IMAGE_FROM_EMBEDDED_BINARY=y +# end of Example Configuration + +# +# Compiler options +# +# CONFIG_COMPILER_OPTIMIZATION_DEBUG is not set +# CONFIG_COMPILER_OPTIMIZATION_SIZE is not set +CONFIG_COMPILER_OPTIMIZATION_PERF=y +# CONFIG_COMPILER_OPTIMIZATION_NONE is not set +CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y +# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT is not set +# CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE is not set +CONFIG_COMPILER_FLOAT_LIB_FROM_GCCLIB=y +CONFIG_COMPILER_OPTIMIZATION_ASSERTION_LEVEL=2 +# CONFIG_COMPILER_OPTIMIZATION_CHECKS_SILENT is not set +CONFIG_COMPILER_HIDE_PATHS_MACROS=y +# CONFIG_COMPILER_CXX_EXCEPTIONS is not set +# CONFIG_COMPILER_CXX_RTTI is not set +CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y +# CONFIG_COMPILER_STACK_CHECK_MODE_NORM is not set +# CONFIG_COMPILER_STACK_CHECK_MODE_STRONG is not set +# CONFIG_COMPILER_STACK_CHECK_MODE_ALL is not set +# CONFIG_COMPILER_WARN_WRITE_STRINGS is not set +# CONFIG_COMPILER_DISABLE_GCC12_WARNINGS is not set +# CONFIG_COMPILER_DISABLE_GCC13_WARNINGS is not set +# CONFIG_COMPILER_DUMP_RTL_FILES is not set +CONFIG_COMPILER_RT_LIB_GCCLIB=y +CONFIG_COMPILER_RT_LIB_NAME="gcc" +# CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING is not set +CONFIG_COMPILER_ORPHAN_SECTIONS_PLACE=y +# end of Compiler options + +# +# Component config +# + +# +# Application Level Tracing +# +# CONFIG_APPTRACE_DEST_JTAG is not set +CONFIG_APPTRACE_DEST_NONE=y +# CONFIG_APPTRACE_DEST_UART0 is not set +# CONFIG_APPTRACE_DEST_UART1 is not set +# CONFIG_APPTRACE_DEST_UART2 is not set +# CONFIG_APPTRACE_DEST_USB_CDC is not set +CONFIG_APPTRACE_DEST_UART_NONE=y +CONFIG_APPTRACE_UART_TASK_PRIO=1 +CONFIG_APPTRACE_LOCK_ENABLE=y +# end of Application Level Tracing + +# +# Bluetooth +# +# CONFIG_BT_ENABLED is not set +CONFIG_BT_ALARM_MAX_NUM=50 +# end of Bluetooth + +# +# Console Library +# +# CONFIG_CONSOLE_SORTED_HELP is not set +# end of Console Library + +# +# Driver Configurations +# + +# +# TWAI Configuration +# +# CONFIG_TWAI_ISR_IN_IRAM is not set +CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y +# end of TWAI Configuration + +# +# Legacy ADC Driver Configuration +# +# CONFIG_ADC_SUPPRESS_DEPRECATE_WARN is not set + +# +# Legacy ADC Calibration Configuration +# +# CONFIG_ADC_CALI_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy ADC Calibration Configuration +# end of Legacy ADC Driver Configuration + +# +# Legacy MCPWM Driver Configurations +# +# CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy MCPWM Driver Configurations + +# +# Legacy Timer Group Driver Configurations +# +# CONFIG_GPTIMER_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy Timer Group Driver Configurations + +# +# Legacy RMT Driver Configurations +# +# CONFIG_RMT_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy RMT Driver Configurations + +# +# Legacy I2S Driver Configurations +# +# CONFIG_I2S_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy I2S Driver Configurations + +# +# Legacy PCNT Driver Configurations +# +# CONFIG_PCNT_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy PCNT Driver Configurations + +# +# Legacy SDM Driver Configurations +# +# CONFIG_SDM_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy SDM Driver Configurations + +# +# Legacy Temperature Sensor Driver Configurations +# +# CONFIG_TEMP_SENSOR_SUPPRESS_DEPRECATE_WARN is not set +# end of Legacy Temperature Sensor Driver Configurations +# end of Driver Configurations + +# +# eFuse Bit Manager +# +# CONFIG_EFUSE_CUSTOM_TABLE is not set +# CONFIG_EFUSE_VIRTUAL is not set +CONFIG_EFUSE_MAX_BLK_LEN=256 +# end of eFuse Bit Manager + +# +# ESP-TLS +# +CONFIG_ESP_TLS_USING_MBEDTLS=y +CONFIG_ESP_TLS_USE_DS_PERIPHERAL=y +# CONFIG_ESP_TLS_CLIENT_SESSION_TICKETS is not set +# CONFIG_ESP_TLS_SERVER_SESSION_TICKETS is not set +# CONFIG_ESP_TLS_SERVER_CERT_SELECT_HOOK is not set +# CONFIG_ESP_TLS_SERVER_MIN_AUTH_MODE_OPTIONAL is not set +# CONFIG_ESP_TLS_PSK_VERIFICATION is not set +# CONFIG_ESP_TLS_INSECURE is not set +# end of ESP-TLS + +# +# ADC and ADC Calibration +# +# CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM is not set +# CONFIG_ADC_CONTINUOUS_ISR_IRAM_SAFE is not set +# CONFIG_ADC_CONTINUOUS_FORCE_USE_ADC2_ON_C3_S3 is not set +# CONFIG_ADC_ENABLE_DEBUG_LOG is not set +# end of ADC and ADC Calibration + +# +# Wireless Coexistence +# +CONFIG_ESP_COEX_ENABLED=y +# CONFIG_ESP_COEX_EXTERNAL_COEXIST_ENABLE is not set +# end of Wireless Coexistence + +# +# Common ESP-related +# +CONFIG_ESP_ERR_TO_NAME_LOOKUP=y +# end of Common ESP-related + +# +# ESP-Driver:GPIO Configurations +# +# CONFIG_GPIO_CTRL_FUNC_IN_IRAM is not set +# end of ESP-Driver:GPIO Configurations + +# +# ESP-Driver:GPTimer Configurations +# +CONFIG_GPTIMER_ISR_HANDLER_IN_IRAM=y +# CONFIG_GPTIMER_CTRL_FUNC_IN_IRAM is not set +# CONFIG_GPTIMER_ISR_IRAM_SAFE is not set +# CONFIG_GPTIMER_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:GPTimer Configurations + +# +# ESP-Driver:I2C Configurations +# +# CONFIG_I2C_ISR_IRAM_SAFE is not set +# CONFIG_I2C_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:I2C Configurations + +# +# ESP-Driver:I2S Configurations +# +# CONFIG_I2S_ISR_IRAM_SAFE is not set +# CONFIG_I2S_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:I2S Configurations + +# +# ESP-Driver:LEDC Configurations +# +# CONFIG_LEDC_CTRL_FUNC_IN_IRAM is not set +# end of ESP-Driver:LEDC Configurations + +# +# ESP-Driver:MCPWM Configurations +# +# CONFIG_MCPWM_ISR_IRAM_SAFE is not set +# CONFIG_MCPWM_CTRL_FUNC_IN_IRAM is not set +# CONFIG_MCPWM_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:MCPWM Configurations + +# +# ESP-Driver:PCNT Configurations +# +# CONFIG_PCNT_CTRL_FUNC_IN_IRAM is not set +# CONFIG_PCNT_ISR_IRAM_SAFE is not set +# CONFIG_PCNT_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:PCNT Configurations + +# +# ESP-Driver:RMT Configurations +# +# CONFIG_RMT_ISR_IRAM_SAFE is not set +# CONFIG_RMT_RECV_FUNC_IN_IRAM is not set +# CONFIG_RMT_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:RMT Configurations + +# +# ESP-Driver:Sigma Delta Modulator Configurations +# +# CONFIG_SDM_CTRL_FUNC_IN_IRAM is not set +# CONFIG_SDM_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:Sigma Delta Modulator Configurations + +# +# ESP-Driver:SPI Configurations +# +CONFIG_SPI_MASTER_IN_IRAM=y +CONFIG_SPI_MASTER_ISR_IN_IRAM=y +# CONFIG_SPI_SLAVE_IN_IRAM is not set +CONFIG_SPI_SLAVE_ISR_IN_IRAM=y +# end of ESP-Driver:SPI Configurations + +# +# ESP-Driver:Temperature Sensor Configurations +# +# CONFIG_TEMP_SENSOR_ENABLE_DEBUG_LOG is not set +# end of ESP-Driver:Temperature Sensor Configurations + +# +# ESP-Driver:UART Configurations +# +# CONFIG_UART_ISR_IN_IRAM is not set +# end of ESP-Driver:UART Configurations + +# +# ESP-Driver:USB Serial/JTAG Configuration +# +CONFIG_USJ_ENABLE_USB_SERIAL_JTAG=y +# end of ESP-Driver:USB Serial/JTAG Configuration + +# +# Ethernet +# +# CONFIG_ETH_USE_SPI_ETHERNET is not set +# CONFIG_ETH_USE_OPENETH is not set +# end of Ethernet + +# +# Event Loop Library +# +# CONFIG_ESP_EVENT_LOOP_PROFILING is not set +CONFIG_ESP_EVENT_POST_FROM_ISR=y +CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR=y +# end of Event Loop Library + +# +# GDB Stub +# +CONFIG_ESP_GDBSTUB_ENABLED=y +# CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME is not set +CONFIG_ESP_GDBSTUB_SUPPORT_TASKS=y +CONFIG_ESP_GDBSTUB_MAX_TASKS=32 +# end of GDB Stub + +# +# ESP HTTP client +# +# CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS is not set +# CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH is not set +# CONFIG_ESP_HTTP_CLIENT_ENABLE_DIGEST_AUTH is not set +# CONFIG_ESP_HTTP_CLIENT_ENABLE_CUSTOM_TRANSPORT is not set +# end of ESP HTTP client + +# +# HTTP Server +# +CONFIG_HTTPD_MAX_REQ_HDR_LEN=512 +CONFIG_HTTPD_MAX_URI_LEN=512 +CONFIG_HTTPD_ERR_RESP_NO_DELAY=y +CONFIG_HTTPD_PURGE_BUF_LEN=32 +# CONFIG_HTTPD_LOG_PURGE_DATA is not set +# CONFIG_HTTPD_WS_SUPPORT is not set +# CONFIG_HTTPD_QUEUE_WORK_BLOCKING is not set +# end of HTTP Server + +# +# ESP HTTPS OTA +# +# CONFIG_ESP_HTTPS_OTA_DECRYPT_CB is not set +# CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP is not set +# end of ESP HTTPS OTA + +# +# ESP HTTPS server +# +# CONFIG_ESP_HTTPS_SERVER_ENABLE is not set +# end of ESP HTTPS server + +# +# Hardware Settings +# + +# +# Chip revision +# +CONFIG_ESP32S3_REV_MIN_0=y +# CONFIG_ESP32S3_REV_MIN_1 is not set +# CONFIG_ESP32S3_REV_MIN_2 is not set +CONFIG_ESP32S3_REV_MIN_FULL=0 +CONFIG_ESP_REV_MIN_FULL=0 + +# +# Maximum Supported ESP32-S3 Revision (Rev v0.99) +# +CONFIG_ESP32S3_REV_MAX_FULL=99 +CONFIG_ESP_REV_MAX_FULL=99 +# end of Chip revision + +# +# MAC Config +# +CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA=y +CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP=y +CONFIG_ESP_MAC_ADDR_UNIVERSE_BT=y +CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH=y +CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES_FOUR=y +CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES=4 +# CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_TWO is not set +CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_FOUR=y +CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES=4 +# CONFIG_ESP_MAC_USE_CUSTOM_MAC_AS_BASE_MAC is not set +# end of MAC Config + +# +# Sleep Config +# +CONFIG_ESP_SLEEP_FLASH_LEAKAGE_WORKAROUND=y +CONFIG_ESP_SLEEP_PSRAM_LEAKAGE_WORKAROUND=y +CONFIG_ESP_SLEEP_MSPI_NEED_ALL_IO_PU=y +CONFIG_ESP_SLEEP_RTC_BUS_ISO_WORKAROUND=y +CONFIG_ESP_SLEEP_GPIO_RESET_WORKAROUND=y +CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY=2000 +# CONFIG_ESP_SLEEP_CACHE_SAFE_ASSERTION is not set +# CONFIG_ESP_SLEEP_DEBUG is not set +CONFIG_ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS=y +# end of Sleep Config + +# +# RTC Clock Config +# +CONFIG_RTC_CLK_SRC_INT_RC=y +# CONFIG_RTC_CLK_SRC_EXT_CRYS is not set +# CONFIG_RTC_CLK_SRC_EXT_OSC is not set +# CONFIG_RTC_CLK_SRC_INT_8MD256 is not set +CONFIG_RTC_CLK_CAL_CYCLES=1024 +# end of RTC Clock Config + +# +# Peripheral Control +# +CONFIG_PERIPH_CTRL_FUNC_IN_IRAM=y +# end of Peripheral Control + +# +# GDMA Configurations +# +CONFIG_GDMA_CTRL_FUNC_IN_IRAM=y +# CONFIG_GDMA_ISR_IRAM_SAFE is not set +# CONFIG_GDMA_ENABLE_DEBUG_LOG is not set +# end of GDMA Configurations + +# +# Main XTAL Config +# +CONFIG_XTAL_FREQ_40=y +CONFIG_XTAL_FREQ=40 +# end of Main XTAL Config + +CONFIG_ESP_SPI_BUS_LOCK_ISR_FUNCS_IN_IRAM=y +CONFIG_ESP_SPI_BUS_LOCK_FUNCS_IN_IRAM=y +# end of Hardware Settings + +# +# LCD and Touch Panel +# + +# +# LCD Touch Drivers are maintained in the IDF Component Registry +# + +# +# LCD Peripheral Configuration +# +CONFIG_LCD_PANEL_IO_FORMAT_BUF_SIZE=32 +# CONFIG_LCD_ENABLE_DEBUG_LOG is not set +# CONFIG_LCD_RGB_ISR_IRAM_SAFE is not set +# CONFIG_LCD_RGB_RESTART_IN_VSYNC is not set +# end of LCD Peripheral Configuration +# end of LCD and Touch Panel + +# +# ESP NETIF Adapter +# +CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL=120 +# CONFIG_ESP_NETIF_TCPIP_LWIP is not set +CONFIG_ESP_NETIF_LOOPBACK=y +# CONFIG_ESP_NETIF_RECEIVE_REPORT_ERRORS is not set +# CONFIG_ESP_NETIF_L2_TAP is not set +# end of ESP NETIF Adapter + +# +# Partition API Configuration +# +# end of Partition API Configuration + +# +# PHY +# +CONFIG_ESP_PHY_ENABLED=y +CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE=y +# CONFIG_ESP_PHY_INIT_DATA_IN_PARTITION is not set +CONFIG_ESP_PHY_MAX_WIFI_TX_POWER=20 +CONFIG_ESP_PHY_MAX_TX_POWER=20 +# CONFIG_ESP_PHY_REDUCE_TX_POWER is not set +CONFIG_ESP_PHY_ENABLE_USB=y +# CONFIG_ESP_PHY_ENABLE_CERT_TEST is not set +CONFIG_ESP_PHY_RF_CAL_PARTIAL=y +# CONFIG_ESP_PHY_RF_CAL_NONE is not set +# CONFIG_ESP_PHY_RF_CAL_FULL is not set +CONFIG_ESP_PHY_CALIBRATION_MODE=0 +# CONFIG_ESP_PHY_PLL_TRACK_DEBUG is not set +# end of PHY + +# +# Power Management +# +# CONFIG_PM_ENABLE is not set +CONFIG_PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP=y +CONFIG_PM_RESTORE_CACHE_TAGMEM_AFTER_LIGHT_SLEEP=y +# end of Power Management + +# +# ESP PSRAM +# +CONFIG_SPIRAM=y + +# +# SPI RAM config +# +# CONFIG_SPIRAM_MODE_QUAD is not set +CONFIG_SPIRAM_MODE_OCT=y +CONFIG_SPIRAM_TYPE_AUTO=y +# CONFIG_SPIRAM_TYPE_ESPPSRAM64 is not set +CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY=y +CONFIG_SPIRAM_CLK_IO=30 +CONFIG_SPIRAM_CS_IO=26 +# CONFIG_SPIRAM_XIP_FROM_PSRAM is not set +CONFIG_SPIRAM_FETCH_INSTRUCTIONS=y +CONFIG_SPIRAM_RODATA=y +CONFIG_SPIRAM_SPEED_80M=y +# CONFIG_SPIRAM_SPEED_40M is not set +CONFIG_SPIRAM_SPEED=80 +# CONFIG_SPIRAM_ECC_ENABLE is not set +CONFIG_SPIRAM_BOOT_INIT=y +# CONFIG_SPIRAM_IGNORE_NOTFOUND is not set +# CONFIG_SPIRAM_USE_MEMMAP is not set +# CONFIG_SPIRAM_USE_CAPS_ALLOC is not set +CONFIG_SPIRAM_USE_MALLOC=y +CONFIG_SPIRAM_MEMTEST=y +CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=16384 +# CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP is not set +CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL=131072 +# CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY is not set +# end of SPI RAM config +# end of ESP PSRAM + +# +# ESP Ringbuf +# +# CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH is not set +# end of ESP Ringbuf + +# +# ESP System Settings +# +# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_80 is not set +# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160 is not set +CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y +CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=240 + +# +# Cache config +# +# CONFIG_ESP32S3_INSTRUCTION_CACHE_16KB is not set +CONFIG_ESP32S3_INSTRUCTION_CACHE_32KB=y +CONFIG_ESP32S3_INSTRUCTION_CACHE_SIZE=0x8000 +# CONFIG_ESP32S3_INSTRUCTION_CACHE_4WAYS is not set +CONFIG_ESP32S3_INSTRUCTION_CACHE_8WAYS=y +CONFIG_ESP32S3_ICACHE_ASSOCIATED_WAYS=8 +CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_32B=y +CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_SIZE=32 +# CONFIG_ESP32S3_DATA_CACHE_16KB is not set +# CONFIG_ESP32S3_DATA_CACHE_32KB is not set +CONFIG_ESP32S3_DATA_CACHE_64KB=y +CONFIG_ESP32S3_DATA_CACHE_SIZE=0x10000 +# CONFIG_ESP32S3_DATA_CACHE_4WAYS is not set +CONFIG_ESP32S3_DATA_CACHE_8WAYS=y +CONFIG_ESP32S3_DCACHE_ASSOCIATED_WAYS=8 +CONFIG_ESP32S3_DATA_CACHE_LINE_32B=y +# CONFIG_ESP32S3_DATA_CACHE_LINE_64B is not set +CONFIG_ESP32S3_DATA_CACHE_LINE_SIZE=32 +# end of Cache config + +# +# Memory +# +# CONFIG_ESP32S3_RTCDATA_IN_FAST_MEM is not set +# CONFIG_ESP32S3_USE_FIXED_STATIC_RAM_SIZE is not set +# end of Memory + +# +# Trace memory +# +# CONFIG_ESP32S3_TRAX is not set +CONFIG_ESP32S3_TRACEMEM_RESERVE_DRAM=0x0 +# end of Trace memory + +# CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT is not set +CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y +# CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set +# CONFIG_ESP_SYSTEM_PANIC_GDBSTUB is not set +CONFIG_ESP_SYSTEM_PANIC_REBOOT_DELAY_SECONDS=0 +CONFIG_ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK=y +CONFIG_ESP_SYSTEM_ALLOW_RTC_FAST_MEM_AS_HEAP=y + +# +# Memory protection +# +CONFIG_ESP_SYSTEM_MEMPROT_FEATURE=y +CONFIG_ESP_SYSTEM_MEMPROT_FEATURE_LOCK=y +# end of Memory protection + +CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32 +CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2304 +CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584 +CONFIG_ESP_MAIN_TASK_AFFINITY_CPU0=y +# CONFIG_ESP_MAIN_TASK_AFFINITY_CPU1 is not set +# CONFIG_ESP_MAIN_TASK_AFFINITY_NO_AFFINITY is not set +CONFIG_ESP_MAIN_TASK_AFFINITY=0x0 +CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048 +# CONFIG_ESP_CONSOLE_UART_DEFAULT is not set +# CONFIG_ESP_CONSOLE_USB_CDC is not set +CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=y +# CONFIG_ESP_CONSOLE_UART_CUSTOM is not set +# CONFIG_ESP_CONSOLE_NONE is not set +CONFIG_ESP_CONSOLE_SECONDARY_NONE=y +CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG_ENABLED=y +CONFIG_ESP_CONSOLE_UART_NUM=-1 +CONFIG_ESP_CONSOLE_ROM_SERIAL_PORT_NUM=4 +CONFIG_ESP_INT_WDT=y +CONFIG_ESP_INT_WDT_TIMEOUT_MS=300 +CONFIG_ESP_INT_WDT_CHECK_CPU1=y +CONFIG_ESP_TASK_WDT_EN=y +CONFIG_ESP_TASK_WDT_INIT=y +# CONFIG_ESP_TASK_WDT_PANIC is not set +CONFIG_ESP_TASK_WDT_TIMEOUT_S=5 +# CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0 is not set +CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=y +# CONFIG_ESP_PANIC_HANDLER_IRAM is not set +# CONFIG_ESP_DEBUG_STUBS_ENABLE is not set +CONFIG_ESP_DEBUG_OCDAWARE=y +CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_4=y + +# +# Brownout Detector +# +CONFIG_ESP_BROWNOUT_DET=y +CONFIG_ESP_BROWNOUT_DET_LVL_SEL_7=y +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_6 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_5 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_4 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_3 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_2 is not set +# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_1 is not set +CONFIG_ESP_BROWNOUT_DET_LVL=7 +# end of Brownout Detector + +CONFIG_ESP_SYSTEM_BROWNOUT_INTR=y +CONFIG_ESP_SYSTEM_BBPLL_RECALIB=y +# end of ESP System Settings + +# +# IPC (Inter-Processor Call) +# +CONFIG_ESP_IPC_TASK_STACK_SIZE=1280 +CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y +CONFIG_ESP_IPC_ISR_ENABLE=y +# end of IPC (Inter-Processor Call) + +# +# ESP Timer (High Resolution Timer) +# +# CONFIG_ESP_TIMER_PROFILING is not set +CONFIG_ESP_TIME_FUNCS_USE_RTC_TIMER=y +CONFIG_ESP_TIME_FUNCS_USE_ESP_TIMER=y +CONFIG_ESP_TIMER_TASK_STACK_SIZE=3584 +CONFIG_ESP_TIMER_INTERRUPT_LEVEL=1 +# CONFIG_ESP_TIMER_SHOW_EXPERIMENTAL is not set +CONFIG_ESP_TIMER_TASK_AFFINITY=0x0 +CONFIG_ESP_TIMER_TASK_AFFINITY_CPU0=y +CONFIG_ESP_TIMER_ISR_AFFINITY_CPU0=y +# CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD is not set +CONFIG_ESP_TIMER_IMPL_SYSTIMER=y +# end of ESP Timer (High Resolution Timer) + +# +# Wi-Fi +# +CONFIG_ESP_WIFI_ENABLED=y +CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM=10 +CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=32 +CONFIG_ESP_WIFI_STATIC_TX_BUFFER=y +CONFIG_ESP_WIFI_TX_BUFFER_TYPE=0 +CONFIG_ESP_WIFI_STATIC_TX_BUFFER_NUM=16 +CONFIG_ESP_WIFI_CACHE_TX_BUFFER_NUM=32 +CONFIG_ESP_WIFI_STATIC_RX_MGMT_BUFFER=y +# CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER is not set +CONFIG_ESP_WIFI_DYNAMIC_RX_MGMT_BUF=0 +CONFIG_ESP_WIFI_RX_MGMT_BUF_NUM_DEF=5 +# CONFIG_ESP_WIFI_CSI_ENABLED is not set +CONFIG_ESP_WIFI_AMPDU_TX_ENABLED=y +CONFIG_ESP_WIFI_TX_BA_WIN=6 +CONFIG_ESP_WIFI_AMPDU_RX_ENABLED=y +CONFIG_ESP_WIFI_RX_BA_WIN=6 +# CONFIG_ESP_WIFI_AMSDU_TX_ENABLED is not set +CONFIG_ESP_WIFI_NVS_ENABLED=y +CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0=y +# CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_1 is not set +CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN=752 +CONFIG_ESP_WIFI_MGMT_SBUF_NUM=32 +CONFIG_ESP_WIFI_IRAM_OPT=y +# CONFIG_ESP_WIFI_EXTRA_IRAM_OPT is not set +CONFIG_ESP_WIFI_RX_IRAM_OPT=y +CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=y +CONFIG_ESP_WIFI_ENABLE_SAE_PK=y +CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT=y +CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA=y +# CONFIG_ESP_WIFI_SLP_IRAM_OPT is not set +CONFIG_ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME=50 +CONFIG_ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME=10 +CONFIG_ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME=15 +# CONFIG_ESP_WIFI_FTM_ENABLE is not set +CONFIG_ESP_WIFI_STA_DISCONNECTED_PM_ENABLE=y +# CONFIG_ESP_WIFI_GCMP_SUPPORT is not set +# CONFIG_ESP_WIFI_GMAC_SUPPORT is not set +CONFIG_ESP_WIFI_SOFTAP_SUPPORT=y +# CONFIG_ESP_WIFI_SLP_BEACON_LOST_OPT is not set +CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM=7 +CONFIG_ESP_WIFI_MBEDTLS_CRYPTO=y +CONFIG_ESP_WIFI_MBEDTLS_TLS_CLIENT=y +# CONFIG_ESP_WIFI_WAPI_PSK is not set +# CONFIG_ESP_WIFI_SUITE_B_192 is not set +# CONFIG_ESP_WIFI_11KV_SUPPORT is not set +# CONFIG_ESP_WIFI_MBO_SUPPORT is not set +# CONFIG_ESP_WIFI_DPP_SUPPORT is not set +# CONFIG_ESP_WIFI_11R_SUPPORT is not set +# CONFIG_ESP_WIFI_WPS_SOFTAP_REGISTRAR is not set + +# +# WPS Configuration Options +# +# CONFIG_ESP_WIFI_WPS_STRICT is not set +# CONFIG_ESP_WIFI_WPS_PASSPHRASE is not set +# end of WPS Configuration Options + +# CONFIG_ESP_WIFI_DEBUG_PRINT is not set +# CONFIG_ESP_WIFI_TESTING_OPTIONS is not set +CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=y +# CONFIG_ESP_WIFI_ENT_FREE_DYNAMIC_BUFFER is not set +# end of Wi-Fi + +# +# Core dump +# +# CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH is not set +# CONFIG_ESP_COREDUMP_ENABLE_TO_UART is not set +CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y +# end of Core dump + +# +# FAT Filesystem support +# +CONFIG_FATFS_VOLUME_COUNT=2 +CONFIG_FATFS_LFN_NONE=y +# CONFIG_FATFS_LFN_HEAP is not set +# CONFIG_FATFS_LFN_STACK is not set +# CONFIG_FATFS_SECTOR_512 is not set +CONFIG_FATFS_SECTOR_4096=y +# CONFIG_FATFS_CODEPAGE_DYNAMIC is not set +CONFIG_FATFS_CODEPAGE_437=y +# CONFIG_FATFS_CODEPAGE_720 is not set +# CONFIG_FATFS_CODEPAGE_737 is not set +# CONFIG_FATFS_CODEPAGE_771 is not set +# CONFIG_FATFS_CODEPAGE_775 is not set +# CONFIG_FATFS_CODEPAGE_850 is not set +# CONFIG_FATFS_CODEPAGE_852 is not set +# CONFIG_FATFS_CODEPAGE_855 is not set +# CONFIG_FATFS_CODEPAGE_857 is not set +# CONFIG_FATFS_CODEPAGE_860 is not set +# CONFIG_FATFS_CODEPAGE_861 is not set +# CONFIG_FATFS_CODEPAGE_862 is not set +# CONFIG_FATFS_CODEPAGE_863 is not set +# CONFIG_FATFS_CODEPAGE_864 is not set +# CONFIG_FATFS_CODEPAGE_865 is not set +# CONFIG_FATFS_CODEPAGE_866 is not set +# CONFIG_FATFS_CODEPAGE_869 is not set +# CONFIG_FATFS_CODEPAGE_932 is not set +# CONFIG_FATFS_CODEPAGE_936 is not set +# CONFIG_FATFS_CODEPAGE_949 is not set +# CONFIG_FATFS_CODEPAGE_950 is not set +CONFIG_FATFS_CODEPAGE=437 +CONFIG_FATFS_FS_LOCK=0 +CONFIG_FATFS_TIMEOUT_MS=10000 +CONFIG_FATFS_PER_FILE_CACHE=y +CONFIG_FATFS_ALLOC_PREFER_EXTRAM=y +# CONFIG_FATFS_USE_FASTSEEK is not set +CONFIG_FATFS_VFS_FSTAT_BLKSIZE=0 +# CONFIG_FATFS_IMMEDIATE_FSYNC is not set +# CONFIG_FATFS_USE_LABEL is not set +CONFIG_FATFS_LINK_LOCK=y +# end of FAT Filesystem support + +# +# FreeRTOS +# + +# +# Kernel +# +# CONFIG_FREERTOS_SMP is not set +# CONFIG_FREERTOS_UNICORE is not set +CONFIG_FREERTOS_HZ=100 +# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set +# CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set +CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y +CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=1 +CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1536 +# CONFIG_FREERTOS_USE_IDLE_HOOK is not set +# CONFIG_FREERTOS_USE_TICK_HOOK is not set +CONFIG_FREERTOS_MAX_TASK_NAME_LEN=16 +# CONFIG_FREERTOS_ENABLE_BACKWARD_COMPATIBILITY is not set +CONFIG_FREERTOS_TIMER_SERVICE_TASK_NAME="Tmr Svc" +# CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU0 is not set +# CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU1 is not set +CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY=y +CONFIG_FREERTOS_TIMER_SERVICE_TASK_CORE_AFFINITY=0x7FFFFFFF +CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1 +CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=4096 +CONFIG_FREERTOS_TIMER_QUEUE_LENGTH=10 +CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0 +CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES=1 +# CONFIG_FREERTOS_USE_TRACE_FACILITY is not set +# CONFIG_FREERTOS_USE_LIST_DATA_INTEGRITY_CHECK_BYTES is not set +# CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS is not set +# CONFIG_FREERTOS_USE_APPLICATION_TASK_TAG is not set +# end of Kernel + +# +# Port +# +# CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK is not set +CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS=y +# CONFIG_FREERTOS_TASK_PRE_DELETION_HOOK is not set +# CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP is not set +CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y +CONFIG_FREERTOS_ISR_STACKSIZE=1536 +CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y +CONFIG_FREERTOS_TICK_SUPPORT_SYSTIMER=y +CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL1=y +# CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL3 is not set +CONFIG_FREERTOS_SYSTICK_USES_SYSTIMER=y +# CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH is not set +# CONFIG_FREERTOS_CHECK_PORT_CRITICAL_COMPLIANCE is not set +# end of Port + +CONFIG_FREERTOS_PORT=y +CONFIG_FREERTOS_NO_AFFINITY=0x7FFFFFFF +CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION=y +CONFIG_FREERTOS_DEBUG_OCDAWARE=y +CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT=y +CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y +CONFIG_FREERTOS_NUMBER_OF_CORES=2 +# end of FreeRTOS + +# +# Hardware Abstraction Layer (HAL) and Low Level (LL) +# +CONFIG_HAL_ASSERTION_EQUALS_SYSTEM=y +# CONFIG_HAL_ASSERTION_DISABLE is not set +# CONFIG_HAL_ASSERTION_SILENT is not set +# CONFIG_HAL_ASSERTION_ENABLE is not set +CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=2 +CONFIG_HAL_WDT_USE_ROM_IMPL=y +CONFIG_HAL_SPI_MASTER_FUNC_IN_IRAM=y +CONFIG_HAL_SPI_SLAVE_FUNC_IN_IRAM=y +# end of Hardware Abstraction Layer (HAL) and Low Level (LL) + +# +# Heap memory debugging +# +CONFIG_HEAP_POISONING_DISABLED=y +# CONFIG_HEAP_POISONING_LIGHT is not set +# CONFIG_HEAP_POISONING_COMPREHENSIVE is not set +CONFIG_HEAP_TRACING_OFF=y +# CONFIG_HEAP_TRACING_STANDALONE is not set +# CONFIG_HEAP_TRACING_TOHOST is not set +# CONFIG_HEAP_USE_HOOKS is not set +# CONFIG_HEAP_TASK_TRACKING is not set +# CONFIG_HEAP_ABORT_WHEN_ALLOCATION_FAILS is not set +# CONFIG_HEAP_PLACE_FUNCTION_INTO_FLASH is not set +# end of Heap memory debugging + +# +# Log output +# +# CONFIG_LOG_DEFAULT_LEVEL_NONE is not set +# CONFIG_LOG_DEFAULT_LEVEL_ERROR is not set +# CONFIG_LOG_DEFAULT_LEVEL_WARN is not set +CONFIG_LOG_DEFAULT_LEVEL_INFO=y +# CONFIG_LOG_DEFAULT_LEVEL_DEBUG is not set +# CONFIG_LOG_DEFAULT_LEVEL_VERBOSE is not set +CONFIG_LOG_DEFAULT_LEVEL=3 +CONFIG_LOG_MAXIMUM_EQUALS_DEFAULT=y +# CONFIG_LOG_MAXIMUM_LEVEL_DEBUG is not set +# CONFIG_LOG_MAXIMUM_LEVEL_VERBOSE is not set +CONFIG_LOG_MAXIMUM_LEVEL=3 +# CONFIG_LOG_MASTER_LEVEL is not set +CONFIG_LOG_COLORS=y +CONFIG_LOG_TIMESTAMP_SOURCE_RTOS=y +# CONFIG_LOG_TIMESTAMP_SOURCE_SYSTEM is not set +# end of Log output + +# +# LWIP +# +CONFIG_LWIP_ENABLE=y +CONFIG_LWIP_LOCAL_HOSTNAME="espressif" +# CONFIG_LWIP_NETIF_API is not set +CONFIG_LWIP_TCPIP_TASK_PRIO=18 +# CONFIG_LWIP_TCPIP_CORE_LOCKING is not set +# CONFIG_LWIP_CHECK_THREAD_SAFETY is not set +CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y +# CONFIG_LWIP_L2_TO_L3_COPY is not set +# CONFIG_LWIP_IRAM_OPTIMIZATION is not set +# CONFIG_LWIP_EXTRA_IRAM_OPTIMIZATION is not set +CONFIG_LWIP_TIMERS_ONDEMAND=y +CONFIG_LWIP_ND6=y +# CONFIG_LWIP_FORCE_ROUTER_FORWARDING is not set +CONFIG_LWIP_MAX_SOCKETS=10 +# CONFIG_LWIP_USE_ONLY_LWIP_SELECT is not set +# CONFIG_LWIP_SO_LINGER is not set +CONFIG_LWIP_SO_REUSE=y +CONFIG_LWIP_SO_REUSE_RXTOALL=y +# CONFIG_LWIP_SO_RCVBUF is not set +# CONFIG_LWIP_NETBUF_RECVINFO is not set +CONFIG_LWIP_IP_DEFAULT_TTL=64 +CONFIG_LWIP_IP4_FRAG=y +CONFIG_LWIP_IP6_FRAG=y +# CONFIG_LWIP_IP4_REASSEMBLY is not set +# CONFIG_LWIP_IP6_REASSEMBLY is not set +CONFIG_LWIP_IP_REASS_MAX_PBUFS=10 +# CONFIG_LWIP_IP_FORWARD is not set +# CONFIG_LWIP_STATS is not set +CONFIG_LWIP_ESP_GRATUITOUS_ARP=y +CONFIG_LWIP_GARP_TMR_INTERVAL=60 +CONFIG_LWIP_ESP_MLDV6_REPORT=y +CONFIG_LWIP_MLDV6_TMR_INTERVAL=40 +CONFIG_LWIP_TCPIP_RECVMBOX_SIZE=32 +CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y +# CONFIG_LWIP_DHCP_DISABLE_CLIENT_ID is not set +CONFIG_LWIP_DHCP_DISABLE_VENDOR_CLASS_ID=y +# CONFIG_LWIP_DHCP_RESTORE_LAST_IP is not set +CONFIG_LWIP_DHCP_OPTIONS_LEN=68 +CONFIG_LWIP_NUM_NETIF_CLIENT_DATA=0 +CONFIG_LWIP_DHCP_COARSE_TIMER_SECS=1 + +# +# DHCP server +# +# CONFIG_LWIP_DHCPS is not set +# end of DHCP server + +# CONFIG_LWIP_AUTOIP is not set +CONFIG_LWIP_IPV4=y +CONFIG_LWIP_IPV6=y +# CONFIG_LWIP_IPV6_AUTOCONFIG is not set +CONFIG_LWIP_IPV6_NUM_ADDRESSES=3 +# CONFIG_LWIP_IPV6_FORWARD is not set +# CONFIG_LWIP_NETIF_STATUS_CALLBACK is not set +CONFIG_LWIP_NETIF_LOOPBACK=y +CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8 + +# +# TCP +# +CONFIG_LWIP_MAX_ACTIVE_TCP=16 +CONFIG_LWIP_MAX_LISTENING_TCP=16 +CONFIG_LWIP_TCP_HIGH_SPEED_RETRANSMISSION=y +CONFIG_LWIP_TCP_MAXRTX=12 +CONFIG_LWIP_TCP_SYNMAXRTX=12 +CONFIG_LWIP_TCP_MSS=1440 +CONFIG_LWIP_TCP_TMR_INTERVAL=250 +CONFIG_LWIP_TCP_MSL=60000 +CONFIG_LWIP_TCP_FIN_WAIT_TIMEOUT=20000 +CONFIG_LWIP_TCP_SND_BUF_DEFAULT=5760 +CONFIG_LWIP_TCP_WND_DEFAULT=5760 +CONFIG_LWIP_TCP_RECVMBOX_SIZE=6 +CONFIG_LWIP_TCP_ACCEPTMBOX_SIZE=6 +CONFIG_LWIP_TCP_QUEUE_OOSEQ=y +CONFIG_LWIP_TCP_OOSEQ_TIMEOUT=6 +CONFIG_LWIP_TCP_OOSEQ_MAX_PBUFS=4 +# CONFIG_LWIP_TCP_SACK_OUT is not set +CONFIG_LWIP_TCP_OVERSIZE_MSS=y +# CONFIG_LWIP_TCP_OVERSIZE_QUARTER_MSS is not set +# CONFIG_LWIP_TCP_OVERSIZE_DISABLE is not set +CONFIG_LWIP_TCP_RTO_TIME=1500 +# end of TCP + +# +# UDP +# +CONFIG_LWIP_MAX_UDP_PCBS=16 +CONFIG_LWIP_UDP_RECVMBOX_SIZE=6 +# end of UDP + +# +# Checksums +# +# CONFIG_LWIP_CHECKSUM_CHECK_IP is not set +# CONFIG_LWIP_CHECKSUM_CHECK_UDP is not set +CONFIG_LWIP_CHECKSUM_CHECK_ICMP=y +# end of Checksums + +CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=3072 +CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y +# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set +# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU1 is not set +CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF +# CONFIG_LWIP_PPP_SUPPORT is not set +CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3 +CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5 +# CONFIG_LWIP_SLIP_SUPPORT is not set + +# +# ICMP +# +CONFIG_LWIP_ICMP=y +# CONFIG_LWIP_MULTICAST_PING is not set +# CONFIG_LWIP_BROADCAST_PING is not set +# end of ICMP + +# +# LWIP RAW API +# +CONFIG_LWIP_MAX_RAW_PCBS=16 +# end of LWIP RAW API + +# +# SNTP +# +CONFIG_LWIP_SNTP_MAX_SERVERS=1 +# CONFIG_LWIP_DHCP_GET_NTP_SRV is not set +CONFIG_LWIP_SNTP_UPDATE_DELAY=3600000 +CONFIG_LWIP_SNTP_STARTUP_DELAY=y +CONFIG_LWIP_SNTP_MAXIMUM_STARTUP_DELAY=5000 +# end of SNTP + +# +# DNS +# +CONFIG_LWIP_DNS_MAX_SERVERS=3 +# CONFIG_LWIP_FALLBACK_DNS_SERVER_SUPPORT is not set +# end of DNS + +CONFIG_LWIP_BRIDGEIF_MAX_PORTS=7 +CONFIG_LWIP_ESP_LWIP_ASSERT=y + +# +# Hooks +# +# CONFIG_LWIP_HOOK_TCP_ISN_NONE is not set +CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT=y +# CONFIG_LWIP_HOOK_TCP_ISN_CUSTOM is not set +CONFIG_LWIP_HOOK_IP6_ROUTE_NONE=y +# CONFIG_LWIP_HOOK_IP6_ROUTE_DEFAULT is not set +# CONFIG_LWIP_HOOK_IP6_ROUTE_CUSTOM is not set +CONFIG_LWIP_HOOK_ND6_GET_GW_NONE=y +# CONFIG_LWIP_HOOK_ND6_GET_GW_DEFAULT is not set +# CONFIG_LWIP_HOOK_ND6_GET_GW_CUSTOM is not set +CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_NONE=y +# CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_DEFAULT is not set +# CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_CUSTOM is not set +CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_NONE=y +# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_DEFAULT is not set +# CONFIG_LWIP_HOOK_NETCONN_EXT_RESOLVE_CUSTOM is not set +CONFIG_LWIP_HOOK_IP6_INPUT_NONE=y +# CONFIG_LWIP_HOOK_IP6_INPUT_DEFAULT is not set +# CONFIG_LWIP_HOOK_IP6_INPUT_CUSTOM is not set +# end of Hooks + +# CONFIG_LWIP_DEBUG is not set +# end of LWIP + +# +# mbedTLS +# +CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC=y +# CONFIG_MBEDTLS_EXTERNAL_MEM_ALLOC is not set +# CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC is not set +# CONFIG_MBEDTLS_CUSTOM_MEM_ALLOC is not set +CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN=y +CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN=16384 +CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN=4096 +# CONFIG_MBEDTLS_DYNAMIC_BUFFER is not set +# CONFIG_MBEDTLS_DEBUG is not set + +# +# mbedTLS v3.x related +# +# CONFIG_MBEDTLS_SSL_PROTO_TLS1_3 is not set +# CONFIG_MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH is not set +# CONFIG_MBEDTLS_X509_TRUSTED_CERT_CALLBACK is not set +# CONFIG_MBEDTLS_SSL_CONTEXT_SERIALIZATION is not set +CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE=y +CONFIG_MBEDTLS_PKCS7_C=y +# end of mbedTLS v3.x related + +# +# Certificate Bundle +# +CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y +CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=y +# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN is not set +# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_NONE is not set +# CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE is not set +# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEPRECATED_LIST is not set +CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS=200 +# end of Certificate Bundle + +# CONFIG_MBEDTLS_ECP_RESTARTABLE is not set +CONFIG_MBEDTLS_CMAC_C=y +CONFIG_MBEDTLS_HARDWARE_AES=y +CONFIG_MBEDTLS_AES_USE_INTERRUPT=y +CONFIG_MBEDTLS_AES_INTERRUPT_LEVEL=0 +# CONFIG_MBEDTLS_GCM_SUPPORT_NON_AES_CIPHER is not set +CONFIG_MBEDTLS_HARDWARE_MPI=y +# CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI is not set +CONFIG_MBEDTLS_MPI_USE_INTERRUPT=y +CONFIG_MBEDTLS_MPI_INTERRUPT_LEVEL=0 +CONFIG_MBEDTLS_HARDWARE_SHA=y +CONFIG_MBEDTLS_ROM_MD5=y +# CONFIG_MBEDTLS_ATCA_HW_ECDSA_SIGN is not set +# CONFIG_MBEDTLS_ATCA_HW_ECDSA_VERIFY is not set +CONFIG_MBEDTLS_HAVE_TIME=y +# CONFIG_MBEDTLS_PLATFORM_TIME_ALT is not set +# CONFIG_MBEDTLS_HAVE_TIME_DATE is not set +CONFIG_MBEDTLS_ECDSA_DETERMINISTIC=y +CONFIG_MBEDTLS_SHA512_C=y +CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y +# CONFIG_MBEDTLS_TLS_SERVER_ONLY is not set +# CONFIG_MBEDTLS_TLS_CLIENT_ONLY is not set +# CONFIG_MBEDTLS_TLS_DISABLED is not set +CONFIG_MBEDTLS_TLS_SERVER=y +CONFIG_MBEDTLS_TLS_CLIENT=y +CONFIG_MBEDTLS_TLS_ENABLED=y + +# +# TLS Key Exchange Methods +# +# CONFIG_MBEDTLS_PSK_MODES is not set +CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y +# end of TLS Key Exchange Methods + +CONFIG_MBEDTLS_SSL_RENEGOTIATION=y +CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y +# CONFIG_MBEDTLS_SSL_PROTO_GMTSSL1_1 is not set +# CONFIG_MBEDTLS_SSL_PROTO_DTLS is not set +CONFIG_MBEDTLS_SSL_ALPN=y +CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=y +CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=y + +# +# Symmetric Ciphers +# +CONFIG_MBEDTLS_AES_C=y +# CONFIG_MBEDTLS_CAMELLIA_C is not set +# CONFIG_MBEDTLS_DES_C is not set +# CONFIG_MBEDTLS_BLOWFISH_C is not set +# CONFIG_MBEDTLS_XTEA_C is not set +CONFIG_MBEDTLS_CCM_C=y +CONFIG_MBEDTLS_GCM_C=y +# CONFIG_MBEDTLS_NIST_KW_C is not set +# end of Symmetric Ciphers + +# CONFIG_MBEDTLS_RIPEMD160_C is not set + +# +# Certificates +# +CONFIG_MBEDTLS_PEM_PARSE_C=y +CONFIG_MBEDTLS_PEM_WRITE_C=y +CONFIG_MBEDTLS_X509_CRL_PARSE_C=y +CONFIG_MBEDTLS_X509_CSR_PARSE_C=y +# end of Certificates + +CONFIG_MBEDTLS_ECP_C=y +# CONFIG_MBEDTLS_DHM_C is not set +CONFIG_MBEDTLS_ECDH_C=y +CONFIG_MBEDTLS_ECDSA_C=y +# CONFIG_MBEDTLS_ECJPAKE_C is not set +CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y +CONFIG_MBEDTLS_ECP_NIST_OPTIM=y +CONFIG_MBEDTLS_ECP_FIXED_POINT_OPTIM=y +# CONFIG_MBEDTLS_POLY1305_C is not set +# CONFIG_MBEDTLS_CHACHA20_C is not set +# CONFIG_MBEDTLS_HKDF_C is not set +# CONFIG_MBEDTLS_THREADING_C is not set +CONFIG_MBEDTLS_ERROR_STRINGS=y +# end of mbedTLS + +# +# ESP-MQTT Configurations +# +CONFIG_MQTT_PROTOCOL_311=y +# CONFIG_MQTT_PROTOCOL_5 is not set +CONFIG_MQTT_TRANSPORT_SSL=y +CONFIG_MQTT_TRANSPORT_WEBSOCKET=y +CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=y +# CONFIG_MQTT_MSG_ID_INCREMENTAL is not set +# CONFIG_MQTT_SKIP_PUBLISH_IF_DISCONNECTED is not set +# CONFIG_MQTT_REPORT_DELETED_MESSAGES is not set +# CONFIG_MQTT_USE_CUSTOM_CONFIG is not set +# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set +# CONFIG_MQTT_CUSTOM_OUTBOX is not set +# end of ESP-MQTT Configurations + +# +# Newlib +# +CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y +# CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF is not set +# CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR is not set +# CONFIG_NEWLIB_STDIN_LINE_ENDING_CRLF is not set +# CONFIG_NEWLIB_STDIN_LINE_ENDING_LF is not set +CONFIG_NEWLIB_STDIN_LINE_ENDING_CR=y +# CONFIG_NEWLIB_NANO_FORMAT is not set +CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT=y +# CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC is not set +# CONFIG_NEWLIB_TIME_SYSCALL_USE_HRT is not set +# CONFIG_NEWLIB_TIME_SYSCALL_USE_NONE is not set +# end of Newlib + +CONFIG_STDATOMIC_S32C1I_SPIRAM_WORKAROUND=y + +# +# NVS +# +# CONFIG_NVS_ENCRYPTION is not set +# CONFIG_NVS_ASSERT_ERROR_CHECK is not set +# CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY is not set +# end of NVS + +# +# OpenThread +# +# CONFIG_OPENTHREAD_ENABLED is not set + +# +# Thread Operational Dataset +# +CONFIG_OPENTHREAD_NETWORK_NAME="OpenThread-ESP" +CONFIG_OPENTHREAD_MESH_LOCAL_PREFIX="fd00:db8:a0:0::/64" +CONFIG_OPENTHREAD_NETWORK_CHANNEL=15 +CONFIG_OPENTHREAD_NETWORK_PANID=0x1234 +CONFIG_OPENTHREAD_NETWORK_EXTPANID="dead00beef00cafe" +CONFIG_OPENTHREAD_NETWORK_MASTERKEY="00112233445566778899aabbccddeeff" +CONFIG_OPENTHREAD_NETWORK_PSKC="104810e2315100afd6bc9215a6bfac53" +# end of Thread Operational Dataset + +CONFIG_OPENTHREAD_XTAL_ACCURACY=130 +# CONFIG_OPENTHREAD_SPINEL_ONLY is not set +CONFIG_OPENTHREAD_RX_ON_WHEN_IDLE=y + +# +# Thread Address Query Config +# +# end of Thread Address Query Config +# end of OpenThread + +# +# Protocomm +# +CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_0=y +CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_1=y +CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_VERSION_2=y +# end of Protocomm + +# +# PThreads +# +CONFIG_PTHREAD_TASK_PRIO_DEFAULT=5 +CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072 +CONFIG_PTHREAD_STACK_MIN=768 +CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY=y +# CONFIG_PTHREAD_DEFAULT_CORE_0 is not set +# CONFIG_PTHREAD_DEFAULT_CORE_1 is not set +CONFIG_PTHREAD_TASK_CORE_DEFAULT=-1 +CONFIG_PTHREAD_TASK_NAME_DEFAULT="pthread" +# end of PThreads + +# +# MMU Config +# +CONFIG_MMU_PAGE_SIZE_64KB=y +CONFIG_MMU_PAGE_MODE="64KB" +CONFIG_MMU_PAGE_SIZE=0x10000 +# end of MMU Config + +# +# Main Flash configuration +# + +# +# SPI Flash behavior when brownout +# +CONFIG_SPI_FLASH_BROWNOUT_RESET_XMC=y +CONFIG_SPI_FLASH_BROWNOUT_RESET=y +# end of SPI Flash behavior when brownout + +# +# Optional and Experimental Features (READ DOCS FIRST) +# + +# +# Features here require specific hardware (READ DOCS FIRST!) +# +# CONFIG_SPI_FLASH_HPM_ENA is not set +CONFIG_SPI_FLASH_HPM_AUTO=y +# CONFIG_SPI_FLASH_HPM_DIS is not set +CONFIG_SPI_FLASH_HPM_ON=y +CONFIG_SPI_FLASH_HPM_DC_AUTO=y +# CONFIG_SPI_FLASH_HPM_DC_DISABLE is not set +CONFIG_SPI_FLASH_SUSPEND_QVL_SUPPORTED=y +# CONFIG_SPI_FLASH_AUTO_SUSPEND is not set +CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US=50 +# end of Optional and Experimental Features (READ DOCS FIRST) +# end of Main Flash configuration + +# +# SPI Flash driver +# +# CONFIG_SPI_FLASH_VERIFY_WRITE is not set +# CONFIG_SPI_FLASH_ENABLE_COUNTERS is not set +CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y +# CONFIG_SPI_FLASH_ROM_IMPL is not set +CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS=y +# CONFIG_SPI_FLASH_DANGEROUS_WRITE_FAILS is not set +# CONFIG_SPI_FLASH_DANGEROUS_WRITE_ALLOWED is not set +# CONFIG_SPI_FLASH_BYPASS_BLOCK_ERASE is not set +CONFIG_SPI_FLASH_YIELD_DURING_ERASE=y +CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS=20 +CONFIG_SPI_FLASH_ERASE_YIELD_TICKS=1 +CONFIG_SPI_FLASH_WRITE_CHUNK_SIZE=8192 +# CONFIG_SPI_FLASH_SIZE_OVERRIDE is not set +# CONFIG_SPI_FLASH_CHECK_ERASE_TIMEOUT_DISABLED is not set +# CONFIG_SPI_FLASH_OVERRIDE_CHIP_DRIVER_LIST is not set + +# +# Auto-detect flash chips +# +CONFIG_SPI_FLASH_VENDOR_XMC_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_GD_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_ISSI_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_MXIC_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_WINBOND_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_BOYA_SUPPORTED=y +CONFIG_SPI_FLASH_VENDOR_TH_SUPPORTED=y +CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_GD_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_TH_CHIP=y +CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP=y +# end of Auto-detect flash chips + +CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE=y +# end of SPI Flash driver + +# +# SPIFFS Configuration +# +CONFIG_SPIFFS_MAX_PARTITIONS=3 + +# +# SPIFFS Cache Configuration +# +CONFIG_SPIFFS_CACHE=y +CONFIG_SPIFFS_CACHE_WR=y +# CONFIG_SPIFFS_CACHE_STATS is not set +# end of SPIFFS Cache Configuration + +CONFIG_SPIFFS_PAGE_CHECK=y +CONFIG_SPIFFS_GC_MAX_RUNS=10 +# CONFIG_SPIFFS_GC_STATS is not set +CONFIG_SPIFFS_PAGE_SIZE=256 +CONFIG_SPIFFS_OBJ_NAME_LEN=32 +# CONFIG_SPIFFS_FOLLOW_SYMLINKS is not set +CONFIG_SPIFFS_USE_MAGIC=y +CONFIG_SPIFFS_USE_MAGIC_LENGTH=y +CONFIG_SPIFFS_META_LENGTH=4 +CONFIG_SPIFFS_USE_MTIME=y + +# +# Debug Configuration +# +# CONFIG_SPIFFS_DBG is not set +# CONFIG_SPIFFS_API_DBG is not set +# CONFIG_SPIFFS_GC_DBG is not set +# CONFIG_SPIFFS_CACHE_DBG is not set +# CONFIG_SPIFFS_CHECK_DBG is not set +# CONFIG_SPIFFS_TEST_VISUALISATION is not set +# end of Debug Configuration +# end of SPIFFS Configuration + +# +# TCP Transport +# + +# +# Websocket +# +CONFIG_WS_TRANSPORT=y +CONFIG_WS_BUFFER_SIZE=1024 +# CONFIG_WS_DYNAMIC_BUFFER is not set +# end of Websocket +# end of TCP Transport + +# +# Ultra Low Power (ULP) Co-processor +# +# CONFIG_ULP_COPROC_ENABLED is not set + +# +# ULP Debugging Options +# +# end of ULP Debugging Options +# end of Ultra Low Power (ULP) Co-processor + +# +# Unity unit testing library +# +CONFIG_UNITY_ENABLE_FLOAT=y +CONFIG_UNITY_ENABLE_DOUBLE=y +# CONFIG_UNITY_ENABLE_64BIT is not set +# CONFIG_UNITY_ENABLE_COLOR is not set +CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=y +# CONFIG_UNITY_ENABLE_FIXTURE is not set +# CONFIG_UNITY_ENABLE_BACKTRACE_ON_FAIL is not set +# end of Unity unit testing library + +# +# USB-OTG +# +CONFIG_USB_HOST_CONTROL_TRANSFER_MAX_SIZE=256 +CONFIG_USB_HOST_HW_BUFFER_BIAS_BALANCED=y +# CONFIG_USB_HOST_HW_BUFFER_BIAS_IN is not set +# CONFIG_USB_HOST_HW_BUFFER_BIAS_PERIODIC_OUT is not set + +# +# Root Hub configuration +# +CONFIG_USB_HOST_DEBOUNCE_DELAY_MS=250 +CONFIG_USB_HOST_RESET_HOLD_MS=30 +CONFIG_USB_HOST_RESET_RECOVERY_MS=30 +CONFIG_USB_HOST_SET_ADDR_RECOVERY_MS=10 +# end of Root Hub configuration + +# CONFIG_USB_HOST_ENABLE_ENUM_FILTER_CALLBACK is not set +CONFIG_USB_OTG_SUPPORTED=y +# end of USB-OTG + +# +# Virtual file system +# +CONFIG_VFS_SUPPORT_IO=y +CONFIG_VFS_SUPPORT_DIR=y +CONFIG_VFS_SUPPORT_SELECT=y +CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=y +# CONFIG_VFS_SELECT_IN_RAM is not set +CONFIG_VFS_SUPPORT_TERMIOS=y +CONFIG_VFS_MAX_COUNT=8 + +# +# Host File System I/O (Semihosting) +# +CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS=1 +# end of Host File System I/O (Semihosting) +# end of Virtual file system + +# +# Wear Levelling +# +# CONFIG_WL_SECTOR_SIZE_512 is not set +CONFIG_WL_SECTOR_SIZE_4096=y +CONFIG_WL_SECTOR_SIZE=4096 +# end of Wear Levelling + +# +# Wi-Fi Provisioning Manager +# +CONFIG_WIFI_PROV_SCAN_MAX_ENTRIES=16 +CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT=30 +# CONFIG_WIFI_PROV_BLE_FORCE_ENCRYPTION is not set +CONFIG_WIFI_PROV_STA_ALL_CHANNEL_SCAN=y +# CONFIG_WIFI_PROV_STA_FAST_SCAN is not set +# end of Wi-Fi Provisioning Manager +# end of Component config + +# CONFIG_IDF_EXPERIMENTAL_FEATURES is not set + +# Deprecated options for backward compatibility +# CONFIG_APP_BUILD_TYPE_ELF_RAM is not set +# CONFIG_NO_BLOBS is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_NONE is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_ERROR is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_WARN is not set +CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y +# CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG is not set +# CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE is not set +CONFIG_LOG_BOOTLOADER_LEVEL=3 +# CONFIG_APP_ROLLBACK_ENABLE is not set +# CONFIG_FLASH_ENCRYPTION_ENABLED is not set +CONFIG_FLASHMODE_QIO=y +# CONFIG_FLASHMODE_QOUT is not set +# CONFIG_FLASHMODE_DIO is not set +# CONFIG_FLASHMODE_DOUT is not set +CONFIG_MONITOR_BAUD=115200 +# CONFIG_OPTIMIZATION_LEVEL_DEBUG is not set +# CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG is not set +# CONFIG_COMPILER_OPTIMIZATION_DEFAULT is not set +# CONFIG_OPTIMIZATION_LEVEL_RELEASE is not set +# CONFIG_COMPILER_OPTIMIZATION_LEVEL_RELEASE is not set +CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y +# CONFIG_OPTIMIZATION_ASSERTIONS_SILENT is not set +# CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED is not set +CONFIG_OPTIMIZATION_ASSERTION_LEVEL=2 +# CONFIG_CXX_EXCEPTIONS is not set +CONFIG_STACK_CHECK_NONE=y +# CONFIG_STACK_CHECK_NORM is not set +# CONFIG_STACK_CHECK_STRONG is not set +# CONFIG_STACK_CHECK_ALL is not set +# CONFIG_WARN_WRITE_STRINGS is not set +# CONFIG_ESP32_APPTRACE_DEST_TRAX is not set +CONFIG_ESP32_APPTRACE_DEST_NONE=y +CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y +# CONFIG_EXTERNAL_COEX_ENABLE is not set +# CONFIG_ESP_WIFI_EXTERNAL_COEXIST_ENABLE is not set +# CONFIG_MCPWM_ISR_IN_IRAM is not set +# CONFIG_EVENT_LOOP_PROFILING is not set +CONFIG_POST_EVENTS_FROM_ISR=y +CONFIG_POST_EVENTS_FROM_IRAM_ISR=y +CONFIG_GDBSTUB_SUPPORT_TASKS=y +CONFIG_GDBSTUB_MAX_TASKS=32 +# CONFIG_OTA_ALLOW_HTTP is not set +CONFIG_ESP32S3_DEEP_SLEEP_WAKEUP_DELAY=2000 +CONFIG_ESP_SLEEP_DEEP_SLEEP_WAKEUP_DELAY=2000 +CONFIG_ESP32S3_RTC_CLK_SRC_INT_RC=y +# CONFIG_ESP32S3_RTC_CLK_SRC_EXT_CRYS is not set +# CONFIG_ESP32S3_RTC_CLK_SRC_EXT_OSC is not set +# CONFIG_ESP32S3_RTC_CLK_SRC_INT_8MD256 is not set +CONFIG_ESP32S3_RTC_CLK_CAL_CYCLES=1024 +CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE=y +# CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION is not set +CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20 +CONFIG_ESP32_PHY_MAX_TX_POWER=20 +# CONFIG_REDUCE_PHY_TX_POWER is not set +# CONFIG_ESP32_REDUCE_PHY_TX_POWER is not set +CONFIG_ESP_SYSTEM_PM_POWER_DOWN_CPU=y +CONFIG_PM_POWER_DOWN_TAGMEM_IN_LIGHT_SLEEP=y +CONFIG_ESP32S3_SPIRAM_SUPPORT=y +CONFIG_DEFAULT_PSRAM_CLK_IO=30 +CONFIG_DEFAULT_PSRAM_CS_IO=26 +# CONFIG_ESP32S3_DEFAULT_CPU_FREQ_80 is not set +# CONFIG_ESP32S3_DEFAULT_CPU_FREQ_160 is not set +CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240=y +CONFIG_ESP32S3_DEFAULT_CPU_FREQ_MHZ=240 +CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32 +CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2304 +CONFIG_MAIN_TASK_STACK_SIZE=3584 +# CONFIG_CONSOLE_UART_DEFAULT is not set +# CONFIG_CONSOLE_UART_CUSTOM is not set +# CONFIG_CONSOLE_UART_NONE is not set +# CONFIG_ESP_CONSOLE_UART_NONE is not set +CONFIG_CONSOLE_UART_NUM=-1 +CONFIG_INT_WDT=y +CONFIG_INT_WDT_TIMEOUT_MS=300 +CONFIG_INT_WDT_CHECK_CPU1=y +CONFIG_TASK_WDT=y +CONFIG_ESP_TASK_WDT=y +# CONFIG_TASK_WDT_PANIC is not set +CONFIG_TASK_WDT_TIMEOUT_S=5 +# CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0 is not set +CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=y +# CONFIG_ESP32_DEBUG_STUBS_ENABLE is not set +CONFIG_ESP32S3_DEBUG_OCDAWARE=y +CONFIG_BROWNOUT_DET=y +CONFIG_ESP32S3_BROWNOUT_DET=y +CONFIG_ESP32S3_BROWNOUT_DET=y +CONFIG_BROWNOUT_DET_LVL_SEL_7=y +CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_7=y +# CONFIG_BROWNOUT_DET_LVL_SEL_6 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_6 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_5 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_5 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_4 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_4 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_3 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_3 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_2 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_2 is not set +# CONFIG_BROWNOUT_DET_LVL_SEL_1 is not set +# CONFIG_ESP32S3_BROWNOUT_DET_LVL_SEL_1 is not set +CONFIG_BROWNOUT_DET_LVL=7 +CONFIG_ESP32S3_BROWNOUT_DET_LVL=7 +CONFIG_IPC_TASK_STACK_SIZE=1280 +CONFIG_TIMER_TASK_STACK_SIZE=3584 +CONFIG_ESP32_WIFI_ENABLED=y +CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10 +CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32 +CONFIG_ESP32_WIFI_STATIC_TX_BUFFER=y +CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=0 +CONFIG_ESP32_WIFI_STATIC_TX_BUFFER_NUM=16 +CONFIG_ESP32_WIFI_CACHE_TX_BUFFER_NUM=32 +# CONFIG_ESP32_WIFI_CSI_ENABLED is not set +CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y +CONFIG_ESP32_WIFI_TX_BA_WIN=6 +CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y +CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y +CONFIG_ESP32_WIFI_RX_BA_WIN=6 +CONFIG_ESP32_WIFI_RX_BA_WIN=6 +# CONFIG_ESP32_WIFI_AMSDU_TX_ENABLED is not set +CONFIG_ESP32_WIFI_NVS_ENABLED=y +CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0=y +# CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1 is not set +CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752 +CONFIG_ESP32_WIFI_MGMT_SBUF_NUM=32 +CONFIG_ESP32_WIFI_IRAM_OPT=y +CONFIG_ESP32_WIFI_RX_IRAM_OPT=y +CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE=y +CONFIG_ESP32_WIFI_ENABLE_WPA3_OWE_STA=y +CONFIG_WPA_MBEDTLS_CRYPTO=y +CONFIG_WPA_MBEDTLS_TLS_CLIENT=y +# CONFIG_WPA_WAPI_PSK is not set +# CONFIG_WPA_SUITE_B_192 is not set +# CONFIG_WPA_11KV_SUPPORT is not set +# CONFIG_WPA_MBO_SUPPORT is not set +# CONFIG_WPA_DPP_SUPPORT is not set +# CONFIG_WPA_11R_SUPPORT is not set +# CONFIG_WPA_WPS_SOFTAP_REGISTRAR is not set +# CONFIG_WPA_WPS_STRICT is not set +# CONFIG_WPA_DEBUG_PRINT is not set +# CONFIG_WPA_TESTING_OPTIONS is not set +# CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH is not set +# CONFIG_ESP32_ENABLE_COREDUMP_TO_UART is not set +CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y +CONFIG_TIMER_TASK_PRIORITY=1 +CONFIG_TIMER_TASK_STACK_DEPTH=4096 +CONFIG_TIMER_QUEUE_LENGTH=10 +# CONFIG_ENABLE_STATIC_TASK_CLEAN_UP_HOOK is not set +# CONFIG_HAL_ASSERTION_SILIENT is not set +# CONFIG_L2_TO_L3_COPY is not set +CONFIG_ESP_GRATUITOUS_ARP=y +CONFIG_GARP_TMR_INTERVAL=60 +CONFIG_TCPIP_RECVMBOX_SIZE=32 +CONFIG_TCP_MAXRTX=12 +CONFIG_TCP_SYNMAXRTX=12 +CONFIG_TCP_MSS=1440 +CONFIG_TCP_MSL=60000 +CONFIG_TCP_SND_BUF_DEFAULT=5760 +CONFIG_TCP_WND_DEFAULT=5760 +CONFIG_TCP_RECVMBOX_SIZE=6 +CONFIG_TCP_QUEUE_OOSEQ=y +CONFIG_TCP_OVERSIZE_MSS=y +# CONFIG_TCP_OVERSIZE_QUARTER_MSS is not set +# CONFIG_TCP_OVERSIZE_DISABLE is not set +CONFIG_UDP_RECVMBOX_SIZE=6 +CONFIG_TCPIP_TASK_STACK_SIZE=3072 +CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY=y +# CONFIG_TCPIP_TASK_AFFINITY_CPU0 is not set +# CONFIG_TCPIP_TASK_AFFINITY_CPU1 is not set +CONFIG_TCPIP_TASK_AFFINITY=0x7FFFFFFF +# CONFIG_PPP_SUPPORT is not set +CONFIG_ESP32S3_TIME_SYSCALL_USE_RTC_SYSTIMER=y +CONFIG_ESP32S3_TIME_SYSCALL_USE_RTC_FRC1=y +# CONFIG_ESP32S3_TIME_SYSCALL_USE_RTC is not set +# CONFIG_ESP32S3_TIME_SYSCALL_USE_SYSTIMER is not set +# CONFIG_ESP32S3_TIME_SYSCALL_USE_FRC1 is not set +# CONFIG_ESP32S3_TIME_SYSCALL_USE_NONE is not set +CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5 +CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072 +CONFIG_ESP32_PTHREAD_STACK_MIN=768 +CONFIG_ESP32_DEFAULT_PTHREAD_CORE_NO_AFFINITY=y +# CONFIG_ESP32_DEFAULT_PTHREAD_CORE_0 is not set +# CONFIG_ESP32_DEFAULT_PTHREAD_CORE_1 is not set +CONFIG_ESP32_PTHREAD_TASK_CORE_DEFAULT=-1 +CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT="pthread" +CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS=y +# CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_FAILS is not set +# CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED is not set +CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y +CONFIG_SUPPORT_TERMIOS=y +CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS=1 +# End of deprecated options