diff --git a/esp/.gitignore b/esp/.gitignore new file mode 100755 index 0000000..89cc49c --- /dev/null +++ b/esp/.gitignore @@ -0,0 +1,5 @@ +.pio +.vscode/.browse.c_cpp.db* +.vscode/c_cpp_properties.json +.vscode/launch.json +.vscode/ipch diff --git a/esp/include/README b/esp/include/README new file mode 100755 index 0000000..45496b1 --- /dev/null +++ b/esp/include/README @@ -0,0 +1,39 @@ + +This directory is intended for project header files. + +A header file is a file containing C declarations and macro definitions +to be shared between several project source files. You request the use of a +header file in your project source file (C, C++, etc) located in `src` folder +by including it, with the C preprocessing directive `#include'. + +```src/main.c + +#include "header.h" + +int main (void) +{ + ... +} +``` + +Including a header file produces the same results as copying the header file +into each source file that needs it. Such copying would be time-consuming +and error-prone. With a header file, the related declarations appear +in only one place. If they need to be changed, they can be changed in one +place, and programs that include the header file will automatically use the +new version when next recompiled. The header file eliminates the labor of +finding and changing all the copies as well as the risk that a failure to +find one copy will result in inconsistencies within a program. + +In C, the usual convention is to give header files names that end with `.h'. +It is most portable to use only letters, digits, dashes, and underscores in +header file names, and at most one dot. + +Read more about using header files in official GCC documentation: + +* Include Syntax +* Include Operation +* Once-Only Headers +* Computed Includes + +https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/esp/lib/Micro-RTSP/.gitignore b/esp/lib/Micro-RTSP/.gitignore new file mode 100644 index 0000000..3488a22 --- /dev/null +++ b/esp/lib/Micro-RTSP/.gitignore @@ -0,0 +1,2 @@ +testserver +octo.jpg diff --git a/esp/lib/Micro-RTSP/LICENSE b/esp/lib/Micro-RTSP/LICENSE new file mode 100644 index 0000000..136bbd2 --- /dev/null +++ b/esp/lib/Micro-RTSP/LICENSE @@ -0,0 +1,7 @@ +Copyright 2018 S. Kevin Hester-Chow, kevinh@geeksville.com (MIT License) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/esp/lib/Micro-RTSP/README.md b/esp/lib/Micro-RTSP/README.md new file mode 100644 index 0000000..37d6aec --- /dev/null +++ b/esp/lib/Micro-RTSP/README.md @@ -0,0 +1,93 @@ +# Micro-RTSP + +This is a small library which can be used to serve up RTSP streams from +resource constrained MCUs. It lets you trivially make a $10 open source +RTSP video stream camera. + +# Usage + +This library works for ESP32/arduino targets but also for most any posixish platform. + +## Example arduino/ESP32 usage + +This library will work standalone, but it is _super_ easy to use if your app is platform.io based. +Just "pio lib install Micro-RTSP" to pull the latest version from their library server. If you want to use the OV2640 +camera support you'll need to be targeting the espressif32 platform in your project. + +See the [example platform.io app](/examples). It should build and run on virtually any of the $10 +ESP32-CAM boards (such as M5CAM). The relevant bit of the code is included below. In short: +1. Listen for a TCP connection on the RTSP port with accept() +2. When a connection comes in, create a CRtspSession and OV2640Streamer camera streamer objects. +3. While the connection remains, call session->handleRequests(0) to handle any incoming client requests. +4. Every 100ms or so call session->broadcastCurrentFrame() to send new frames to any clients. + +``` +void loop() +{ + uint32_t msecPerFrame = 100; + static uint32_t lastimage = millis(); + + // If we have an active client connection, just service that until gone + // (FIXME - support multiple simultaneous clients) + if(session) { + session->handleRequests(0); // we don't use a timeout here, + // instead we send only if we have new enough frames + + uint32_t now = millis(); + if(now > lastimage + msecPerFrame || now < lastimage) { // handle clock rollover + session->broadcastCurrentFrame(now); + lastimage = now; + + // check if we are overrunning our max frame rate + now = millis(); + if(now > lastimage + msecPerFrame) + printf("warning exceeding max frame rate of %d ms\n", now - lastimage); + } + + if(session->m_stopped) { + delete session; + delete streamer; + session = NULL; + streamer = NULL; + } + } + else { + client = rtspServer.accept(); + + if(client) { + //streamer = new SimStreamer(&client, true); // our streamer for UDP/TCP based RTP transport + streamer = new OV2640Streamer(&client, cam); // our streamer for UDP/TCP based RTP transport + + session = new CRtspSession(&client, streamer); // our threads RTSP session and state + } + } +} +``` +## Example posix/linux usage + +There is a small standalone example [here](/test/RTSPTestServer.cpp). You can build it by following [these](/test/README.md) directions. The usage of the two key classes (CRtspSession and SimStreamer) are very similar to to the ESP32 usage. + +## Supporting new camera devices + +Supporting new camera devices is quite simple. See OV2640Streamer for an example and implement streamImage() +by reading a frame from your camera. + +# Structure and design notes + +# Issues and sending pull requests + +Please report issues and send pull requests. I'll happily reply. ;-) + +# Credits + +The server code was initially based on a great 2013 [tutorial](https://www.medialan.de/usecase0001.html) by Medialan. + +# License + +Copyright 2018 S. Kevin Hester-Chow, kevinh@geeksville.com (MIT License) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/esp/lib/Micro-RTSP/TODO.md b/esp/lib/Micro-RTSP/TODO.md new file mode 100644 index 0000000..3699d88 --- /dev/null +++ b/esp/lib/Micro-RTSP/TODO.md @@ -0,0 +1,18 @@ +* add instructions for example app +* push RTSP streams to other servers ( https://github.com/ant-media/Ant-Media-Server/wiki/Getting-Started ) +* make stack larger so that the various scratch buffers (currently in bss) can be shared +* cleanup code to a less ugly unified coding standard +* support multiple simultaneous clients on the device +* make octocat test image work again (by changing encoding type from 1 to 0 (422 vs 420)) + +DONE: +* serve real jpegs (use correct quantization & huffman tables) +* test that both TCP and UDP clients work +* change framerate to something slow +* test remote access +* select a licence and put license into github +* find cause of new mystery pause when starting up in sim mode +* split sim code from real code via inheritence +* use device camera +* package the ESP32-CAM stuff as a library so I can depend on it +* package as a library https://docs.platformio.org/en/latest/librarymanager/creating.html#library-creating-examples diff --git a/esp/lib/Micro-RTSP/examples/.gitignore b/esp/lib/Micro-RTSP/examples/.gitignore new file mode 100644 index 0000000..3ba3003 --- /dev/null +++ b/esp/lib/Micro-RTSP/examples/.gitignore @@ -0,0 +1,3 @@ +wifikeys.h +.pioenvs +.piolibdeps diff --git a/esp/lib/Micro-RTSP/examples/ESP32-devcam.ino b/esp/lib/Micro-RTSP/examples/ESP32-devcam.ino new file mode 100644 index 0000000..3137605 --- /dev/null +++ b/esp/lib/Micro-RTSP/examples/ESP32-devcam.ino @@ -0,0 +1,223 @@ +#include "OV2640.h" +#include +#include +#include + +#include "SimStreamer.h" +#include "OV2640Streamer.h" +#include "CRtspSession.h" + +// #define ENABLE_OLED //if want use oled ,turn on thi macro +// #define SOFTAP_MODE // If you want to run our own softap turn this on +#define ENABLE_WEBSERVER +#define ENABLE_RTSPSERVER + +#ifdef ENABLE_OLED +#include "SSD1306.h" +#define OLED_ADDRESS 0x3c +#define I2C_SDA 14 +#define I2C_SCL 13 +SSD1306Wire display(OLED_ADDRESS, I2C_SDA, I2C_SCL, GEOMETRY_128_32); +bool hasDisplay; // we probe for the device at runtime +#endif + +OV2640 cam; + +#ifdef ENABLE_WEBSERVER +WebServer server(80); +#endif + +#ifdef ENABLE_RTSPSERVER +WiFiServer rtspServer(8554); +#endif + + +#ifdef SOFTAP_MODE +IPAddress apIP = IPAddress(192, 168, 1, 1); +#else +#include "wifikeys.h" +#endif + +#ifdef ENABLE_WEBSERVER +void handle_jpg_stream(void) +{ + WiFiClient client = server.client(); + String response = "HTTP/1.1 200 OK\r\n"; + response += "Content-Type: multipart/x-mixed-replace; boundary=frame\r\n\r\n"; + server.sendContent(response); + + while (1) + { + cam.run(); + if (!client.connected()) + break; + response = "--frame\r\n"; + response += "Content-Type: image/jpeg\r\n\r\n"; + server.sendContent(response); + + client.write((char *)cam.getfb(), cam.getSize()); + server.sendContent("\r\n"); + if (!client.connected()) + break; + } +} + +void handle_jpg(void) +{ + WiFiClient client = server.client(); + + cam.run(); + if (!client.connected()) + { + return; + } + String response = "HTTP/1.1 200 OK\r\n"; + response += "Content-disposition: inline; filename=capture.jpg\r\n"; + response += "Content-type: image/jpeg\r\n\r\n"; + server.sendContent(response); + client.write((char *)cam.getfb(), cam.getSize()); +} + +void handleNotFound() +{ + String message = "Server is running!\n\n"; + message += "URI: "; + message += server.uri(); + message += "\nMethod: "; + message += (server.method() == HTTP_GET) ? "GET" : "POST"; + message += "\nArguments: "; + message += server.args(); + message += "\n"; + server.send(200, "text/plain", message); +} +#endif + +#ifdef ENABLE_OLED +#define LCD_MESSAGE(msg) lcdMessage(msg) +#else +#define LCD_MESSAGE(msg) +#endif + +#ifdef ENABLE_OLED +void lcdMessage(String msg) +{ + if(hasDisplay) { + display.clear(); + display.drawString(128 / 2, 32 / 2, msg); + display.display(); + } +} +#endif + +CStreamer *streamer; + +void setup() +{ + #ifdef ENABLE_OLED + hasDisplay = display.init(); + if(hasDisplay) { + display.flipScreenVertically(); + display.setFont(ArialMT_Plain_16); + display.setTextAlignment(TEXT_ALIGN_CENTER); + } + #endif + LCD_MESSAGE("booting"); + + Serial.begin(115200); + while (!Serial) + { + ; + } + cam.init(esp32cam_config); + + IPAddress ip; + + +#ifdef SOFTAP_MODE + const char *hostname = "devcam"; + // WiFi.hostname(hostname); // FIXME - find out why undefined + LCD_MESSAGE("starting softAP"); + WiFi.mode(WIFI_AP); + WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0)); + bool result = WiFi.softAP(hostname, "12345678", 1, 0); + if (!result) + { + Serial.println("AP Config failed."); + return; + } + else + { + Serial.println("AP Config Success."); + Serial.print("AP MAC: "); + Serial.println(WiFi.softAPmacAddress()); + + ip = WiFi.softAPIP(); + } +#else + LCD_MESSAGE(String("join ") + ssid); + WiFi.mode(WIFI_STA); + WiFi.begin(ssid, password); + while (WiFi.status() != WL_CONNECTED) + { + delay(500); + Serial.print(F(".")); + } + ip = WiFi.localIP(); + Serial.println(F("WiFi connected")); + Serial.println(""); + Serial.println(ip); +#endif + + LCD_MESSAGE(ip.toString()); + +#ifdef ENABLE_WEBSERVER + server.on("/", HTTP_GET, handle_jpg_stream); + server.on("/jpg", HTTP_GET, handle_jpg); + server.onNotFound(handleNotFound); + server.begin(); +#endif + +#ifdef ENABLE_RTSPSERVER + rtspServer.begin(); + + //streamer = new SimStreamer(true); // our streamer for UDP/TCP based RTP transport + streamer = new OV2640Streamer(cam); // our streamer for UDP/TCP based RTP transport +#endif +} + +void loop() +{ +#ifdef ENABLE_WEBSERVER + server.handleClient(); +#endif + +#ifdef ENABLE_RTSPSERVER + uint32_t msecPerFrame = 100; + static uint32_t lastimage = millis(); + + // If we have an active client connection, just service that until gone + streamer->handleRequests(0); // we don't use a timeout here, + // instead we send only if we have new enough frames + uint32_t now = millis(); + if(streamer->anySessions()) { + if(now > lastimage + msecPerFrame || now < lastimage) { // handle clock rollover + streamer->streamImage(now); + lastimage = now; + + // check if we are overrunning our max frame rate + now = millis(); + if(now > lastimage + msecPerFrame) { + printf("warning exceeding max frame rate of %d ms\n", now - lastimage); + } + } + } + + WiFiClient rtspClient = rtspServer.accept(); + if(rtspClient) { + Serial.print("client: "); + Serial.print(rtspClient.remoteIP()); + Serial.println(); + streamer->addSession(rtspClient); + } +#endif +} diff --git a/esp/lib/Micro-RTSP/examples/platformio.ini b/esp/lib/Micro-RTSP/examples/platformio.ini new file mode 100644 index 0000000..b9bc75e --- /dev/null +++ b/esp/lib/Micro-RTSP/examples/platformio.ini @@ -0,0 +1,15 @@ +; PlatformIO Project Configuration File +; +; Build options: build flags, source filter +; Upload options: custom upload port, speed and extra flags +; Library options: dependencies, extra library storages +; Advanced options: extra scripting +; +; Please visit documentation for the other options and examples +; https://docs.platformio.org/page/projectconf.html + +[env:m5stack-core-esp32] +platform = espressif32@>=1.6.0 +board = m5stack-core-esp32 +framework = arduino +lib_deps = Micro-RTSP diff --git a/esp/lib/Micro-RTSP/examples/wifikeys.h b/esp/lib/Micro-RTSP/examples/wifikeys.h new file mode 100755 index 0000000..77c9749 --- /dev/null +++ b/esp/lib/Micro-RTSP/examples/wifikeys.h @@ -0,0 +1,3 @@ +// copy this file to wifikeys.h and edit +const char *ssid = "S O S"; // Put your SSID here +const char *password = "SandraArSnygg"; // Put your PASSWORD here diff --git a/esp/lib/Micro-RTSP/examples/wifikeys_template.h b/esp/lib/Micro-RTSP/examples/wifikeys_template.h new file mode 100644 index 0000000..7b61f3b --- /dev/null +++ b/esp/lib/Micro-RTSP/examples/wifikeys_template.h @@ -0,0 +1,3 @@ +// copy this file to wifikeys.h and edit +const char *ssid = "YOURNETHERE"; // Put your SSID here +const char *password = "YOURPASSWORDHERE"; // Put your PASSWORD here diff --git a/esp/lib/Micro-RTSP/library.json b/esp/lib/Micro-RTSP/library.json new file mode 100644 index 0000000..74d1249 --- /dev/null +++ b/esp/lib/Micro-RTSP/library.json @@ -0,0 +1,22 @@ +{ + "name": "Micro-RTSP", + "keywords": "esp32, camera, esp32-cam, rtsp", + "description": "A small/efficient RTSP server for ESP32 and other micros", + "repository": + { + "type": "git", + "url": "https://github.com/geeksville/Micro-RTSP.git" + }, + "authors": + [ + { + "name": "Kevin Hester", + "email": "kevinh@geeksville.com", + "url": "https://github.com/geeksville", + "maintainer": true + } + ], + "version": "0.1.6", + "frameworks": "arduino", + "platforms": "*" +} diff --git a/esp/lib/Micro-RTSP/library.properties b/esp/lib/Micro-RTSP/library.properties new file mode 100644 index 0000000..03b5dc2 --- /dev/null +++ b/esp/lib/Micro-RTSP/library.properties @@ -0,0 +1,9 @@ +name=Micro-RTSP +version=0.1.6 +author=Kevin Hester +maintainer=Kevin Hester +sentence=Mikro RTSP server for mikros +paragraph=A small/efficient RTSP server for ESP32 and other micros +category=Data Storage +url=https://github.com/geeksville/Micro-RTSP.git +architectures=* diff --git a/esp/lib/Micro-RTSP/src/CRtspSession.cpp b/esp/lib/Micro-RTSP/src/CRtspSession.cpp new file mode 100644 index 0000000..4db4522 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/CRtspSession.cpp @@ -0,0 +1,422 @@ +#include "CRtspSession.h" +#include +#include + +CRtspSession::CRtspSession(WiFiClient& aClient, CStreamer * aStreamer) : LinkedListElement(aStreamer->getClientsListHead()), + m_Client(aClient), + m_Streamer(aStreamer) +{ + printf("Creating RTSP session\n"); + Init(); + + m_RtspClient = &m_Client; + m_RtspSessionID = getRandom(); // create a session ID + m_RtspSessionID |= 0x80000000; + m_StreamID = -1; + m_ClientRTPPort = 0; + m_ClientRTCPPort = 0; + m_TcpTransport = false; + m_streaming = false; + m_stopped = false; + + m_RtpClientPort = 0; + m_RtcpClientPort = 0; +}; + +CRtspSession::~CRtspSession() +{ + m_Streamer->ReleaseUdpTransport(); + closesocket(m_RtspClient); +}; + +void CRtspSession::Init() +{ + m_RtspCmdType = RTSP_UNKNOWN; + memset(m_URLPreSuffix, 0x00, sizeof(m_URLPreSuffix)); + memset(m_URLSuffix, 0x00, sizeof(m_URLSuffix)); + memset(m_CSeq, 0x00, sizeof(m_CSeq)); + memset(m_URLHostPort, 0x00, sizeof(m_URLHostPort)); + m_ContentLength = 0; +}; + +bool CRtspSession::ParseRtspRequest(char const * aRequest, unsigned aRequestSize) +{ + char CmdName[RTSP_PARAM_STRING_MAX]; + static char CurRequest[RTSP_BUFFER_SIZE]; // Note: we assume single threaded, this large buf we keep off of the tiny stack + unsigned CurRequestSize; + + Init(); + CurRequestSize = aRequestSize; + memcpy(CurRequest,aRequest,aRequestSize); + + // check whether the request contains information about the RTP/RTCP UDP client ports (SETUP command) + char * ClientPortPtr; + char * TmpPtr; + static char CP[1024]; + char * pCP; + + ClientPortPtr = strstr(CurRequest,"client_port"); + if (ClientPortPtr != nullptr) + { + TmpPtr = strstr(ClientPortPtr,"\r\n"); + if (TmpPtr != nullptr) + { + TmpPtr[0] = 0x00; + strcpy(CP,ClientPortPtr); + pCP = strstr(CP,"="); + if (pCP != nullptr) + { + pCP++; + strcpy(CP,pCP); + pCP = strstr(CP,"-"); + if (pCP != nullptr) + { + pCP[0] = 0x00; + m_ClientRTPPort = atoi(CP); + m_ClientRTCPPort = m_ClientRTPPort + 1; + }; + }; + }; + }; + + // Read everything up to the first space as the command name + bool parseSucceeded = false; + unsigned i; + for (i = 0; i < sizeof(CmdName)-1 && i < CurRequestSize; ++i) + { + char c = CurRequest[i]; + if (c == ' ' || c == '\t') + { + parseSucceeded = true; + break; + } + CmdName[i] = c; + } + CmdName[i] = '\0'; + if (!parseSucceeded) { + printf("failed to parse RTSP\n"); + return false; + } + + printf("RTSP received %s\n", CmdName); + + // find out the command type + if (strstr(CmdName,"OPTIONS") != nullptr) m_RtspCmdType = RTSP_OPTIONS; else + if (strstr(CmdName,"DESCRIBE") != nullptr) m_RtspCmdType = RTSP_DESCRIBE; else + if (strstr(CmdName,"SETUP") != nullptr) m_RtspCmdType = RTSP_SETUP; else + if (strstr(CmdName,"PLAY") != nullptr) m_RtspCmdType = RTSP_PLAY; else + if (strstr(CmdName,"TEARDOWN") != nullptr) m_RtspCmdType = RTSP_TEARDOWN; + + // check whether the request contains transport information (UDP or TCP) + if (m_RtspCmdType == RTSP_SETUP) + { + TmpPtr = strstr(CurRequest,"RTP/AVP/TCP"); + if (TmpPtr != nullptr) m_TcpTransport = true; else m_TcpTransport = false; + }; + + // Skip over the prefix of any "rtsp://" or "rtsp:/" URL that follows: + unsigned j = i+1; + while (j < CurRequestSize && (CurRequest[j] == ' ' || CurRequest[j] == '\t')) ++j; // skip over any additional white space + for (; (int)j < (int)(CurRequestSize-8); ++j) + { + if ((CurRequest[j] == 'r' || CurRequest[j] == 'R') && + (CurRequest[j+1] == 't' || CurRequest[j+1] == 'T') && + (CurRequest[j+2] == 's' || CurRequest[j+2] == 'S') && + (CurRequest[j+3] == 'p' || CurRequest[j+3] == 'P') && + CurRequest[j+4] == ':' && CurRequest[j+5] == '/') + { + j += 6; + if (CurRequest[j] == '/') + { // This is a "rtsp://" URL; skip over the host:port part that follows: + ++j; + unsigned uidx = 0; + while (j < CurRequestSize && CurRequest[j] != '/' && CurRequest[j] != ' ' && uidx < sizeof(m_URLHostPort) - 1) + { // extract the host:port part of the URL here + m_URLHostPort[uidx] = CurRequest[j]; + uidx++; + ++j; + }; + } + else --j; + i = j; + break; + } + } + + // Look for the URL suffix (before the following "RTSP/"): + parseSucceeded = false; + for (unsigned k = i+1; (int)k < (int)(CurRequestSize-5); ++k) + { + if (CurRequest[k] == 'R' && CurRequest[k+1] == 'T' && + CurRequest[k+2] == 'S' && CurRequest[k+3] == 'P' && + CurRequest[k+4] == '/') + { + while (--k >= i && CurRequest[k] == ' ') {} + unsigned k1 = k; + while (k1 > i && CurRequest[k1] != '/') --k1; + if (k - k1 + 1 > sizeof(m_URLSuffix)) return false; + unsigned n = 0, k2 = k1+1; + + while (k2 <= k) m_URLSuffix[n++] = CurRequest[k2++]; + m_URLSuffix[n] = '\0'; + + if (k1 - i > sizeof(m_URLPreSuffix)) return false; + n = 0; k2 = i + 1; + while (k2 <= k1 - 1) m_URLPreSuffix[n++] = CurRequest[k2++]; + m_URLPreSuffix[n] = '\0'; + i = k + 7; + parseSucceeded = true; + break; + } + } + if (!parseSucceeded) return false; + + // Look for "CSeq:", skip whitespace, then read everything up to the next \r or \n as 'CSeq': + parseSucceeded = false; + for (j = i; (int)j < (int)(CurRequestSize-5); ++j) + { + if (CurRequest[j] == 'C' && CurRequest[j+1] == 'S' && + CurRequest[j+2] == 'e' && CurRequest[j+3] == 'q' && + CurRequest[j+4] == ':') + { + j += 5; + while (j < CurRequestSize && (CurRequest[j] == ' ' || CurRequest[j] == '\t')) ++j; + unsigned n; + for (n = 0; n < sizeof(m_CSeq)-1 && j < CurRequestSize; ++n,++j) + { + char c = CurRequest[j]; + if (c == '\r' || c == '\n') + { + parseSucceeded = true; + break; + } + m_CSeq[n] = c; + } + m_CSeq[n] = '\0'; + break; + } + } + if (!parseSucceeded) return false; + + // Also: Look for "Content-Length:" (optional) + for (j = i; (int)j < (int)(CurRequestSize-15); ++j) + { + if (CurRequest[j] == 'C' && CurRequest[j+1] == 'o' && + CurRequest[j+2] == 'n' && CurRequest[j+3] == 't' && + CurRequest[j+4] == 'e' && CurRequest[j+5] == 'n' && + CurRequest[j+6] == 't' && CurRequest[j+7] == '-' && + (CurRequest[j+8] == 'L' || CurRequest[j+8] == 'l') && + CurRequest[j+9] == 'e' && CurRequest[j+10] == 'n' && + CurRequest[j+11] == 'g' && CurRequest[j+12] == 't' && + CurRequest[j+13] == 'h' && CurRequest[j+14] == ':') + { + j += 15; + while (j < CurRequestSize && (CurRequest[j] == ' ' || CurRequest[j] == '\t')) ++j; + unsigned num; + if (sscanf(&CurRequest[j], "%u", &num) == 1) m_ContentLength = num; + } + } + return true; +}; + +RTSP_CMD_TYPES CRtspSession::Handle_RtspRequest(char const * aRequest, unsigned aRequestSize) +{ + if (ParseRtspRequest(aRequest,aRequestSize)) + { + switch (m_RtspCmdType) + { + case RTSP_OPTIONS: { Handle_RtspOPTION(); break; }; + case RTSP_DESCRIBE: { Handle_RtspDESCRIBE(); break; }; + case RTSP_SETUP: { Handle_RtspSETUP(); break; }; + case RTSP_PLAY: { Handle_RtspPLAY(); break; }; + default: {}; + }; + }; + return m_RtspCmdType; +}; + +void CRtspSession::Handle_RtspOPTION() +{ + static char Response[1024]; // Note: we assume single threaded, this large buf we keep off of the tiny stack + + snprintf(Response,sizeof(Response), + "RTSP/1.0 200 OK\r\nCSeq: %s\r\n" + "Public: DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE\r\n\r\n",m_CSeq); + + socketsend(m_RtspClient,Response,strlen(Response)); +} + +void CRtspSession::Handle_RtspDESCRIBE() +{ + static char Response[1024]; // Note: we assume single threaded, this large buf we keep off of the tiny stack + static char SDPBuf[1024]; + static char URLBuf[1024]; + + // check whether we know a stream with the URL which is requested + m_StreamID = -1; // invalid URL + if ((strcmp(m_URLPreSuffix,"mjpeg") == 0) && (strcmp(m_URLSuffix,"1") == 0)) m_StreamID = 0; else + if ((strcmp(m_URLPreSuffix,"mjpeg") == 0) && (strcmp(m_URLSuffix,"2") == 0)) m_StreamID = 1; + if (m_StreamID == -1) + { // Stream not available + snprintf(Response,sizeof(Response), + "RTSP/1.0 404 Stream Not Found\r\nCSeq: %s\r\n%s\r\n", + m_CSeq, + DateHeader()); + + socketsend(m_RtspClient,Response,strlen(Response)); + return; + }; + + // simulate DESCRIBE server response + static char OBuf[256]; + char * ColonPtr; + strcpy(OBuf,m_URLHostPort); + ColonPtr = strstr(OBuf,":"); + if (ColonPtr != nullptr) ColonPtr[0] = 0x00; + + snprintf(SDPBuf,sizeof(SDPBuf), + "v=0\r\n" + "o=- %d 1 IN IP4 %s\r\n" + "s=\r\n" + "t=0 0\r\n" // start / stop - 0 -> unbounded and permanent session + "m=video 0 RTP/AVP 26\r\n" // currently we just handle UDP sessions + // "a=x-dimensions: 640,480\r\n" + "c=IN IP4 0.0.0.0\r\n", + rand(), + OBuf); + char StreamName[64]; + switch (m_StreamID) + { + case 0: strcpy(StreamName,"mjpeg/1"); break; + case 1: strcpy(StreamName,"mjpeg/2"); break; + }; + snprintf(URLBuf,sizeof(URLBuf), + "rtsp://%s/%s", + m_URLHostPort, + StreamName); + snprintf(Response,sizeof(Response), + "RTSP/1.0 200 OK\r\nCSeq: %s\r\n" + "%s\r\n" + "Content-Base: %s/\r\n" + "Content-Type: application/sdp\r\n" + "Content-Length: %d\r\n\r\n" + "%s", + m_CSeq, + DateHeader(), + URLBuf, + (int) strlen(SDPBuf), + SDPBuf); + + socketsend(m_RtspClient,Response,strlen(Response)); +} + +void CRtspSession::InitTransport(u_short aRtpPort, u_short aRtcpPort) +{ + m_RtpClientPort = aRtpPort; + m_RtcpClientPort = aRtcpPort; + + if (!m_TcpTransport) + { // allocate port pairs for RTP/RTCP ports in UDP transport mode + m_Streamer->InitUdpTransport(); + }; +}; + +void CRtspSession::Handle_RtspSETUP() +{ + static char Response[1024]; + static char Transport[255]; + + // init RTSP Session transport type (UDP or TCP) and ports for UDP transport + InitTransport(m_ClientRTPPort,m_ClientRTCPPort); + + // simulate SETUP server response + if (m_TcpTransport) + snprintf(Transport,sizeof(Transport),"RTP/AVP/TCP;unicast;interleaved=0-1"); + else + snprintf(Transport,sizeof(Transport), + "RTP/AVP;unicast;destination=127.0.0.1;source=127.0.0.1;client_port=%i-%i;server_port=%i-%i", + m_ClientRTPPort, + m_ClientRTCPPort, + m_Streamer->GetRtpServerPort(), + m_Streamer->GetRtcpServerPort()); + snprintf(Response,sizeof(Response), + "RTSP/1.0 200 OK\r\nCSeq: %s\r\n" + "%s\r\n" + "Transport: %s\r\n" + "Session: %i\r\n\r\n", + m_CSeq, + DateHeader(), + Transport, + m_RtspSessionID); + + socketsend(m_RtspClient,Response,strlen(Response)); +} + +void CRtspSession::Handle_RtspPLAY() +{ + static char Response[1024]; + + // simulate SETUP server response + snprintf(Response,sizeof(Response), + "RTSP/1.0 200 OK\r\nCSeq: %s\r\n" + "%s\r\n" + "Range: npt=0.000-\r\n" + "Session: %i\r\n" + "RTP-Info: url=rtsp://127.0.0.1:8554/mjpeg/1/track1\r\n\r\n", + m_CSeq, + DateHeader(), + m_RtspSessionID); + + socketsend(m_RtspClient,Response,strlen(Response)); +} + +char const * CRtspSession::DateHeader() +{ + static char buf[200]; + time_t tt = time(NULL); + strftime(buf, sizeof buf, "Date: %a, %b %d %Y %H:%M:%S GMT", gmtime(&tt)); + return buf; +} + +int CRtspSession::GetStreamID() +{ + return m_StreamID; +}; + + + +/** + Read from our socket, parsing commands as possible. + */ +bool CRtspSession::handleRequests(uint32_t readTimeoutMs) +{ + if(m_stopped) + return false; // Already closed down + + static char RecvBuf[RTSP_BUFFER_SIZE]; // Note: we assume single threaded, this large buf we keep off of the tiny stack + + memset(RecvBuf,0x00,sizeof(RecvBuf)); + int res = socketread(m_RtspClient,RecvBuf,sizeof(RecvBuf), readTimeoutMs); + if(res > 0) { + // we filter away everything which seems not to be an RTSP command: O-ption, D-escribe, S-etup, P-lay, T-eardown + if ((RecvBuf[0] == 'O') || (RecvBuf[0] == 'D') || (RecvBuf[0] == 'S') || (RecvBuf[0] == 'P') || (RecvBuf[0] == 'T')) + { + RTSP_CMD_TYPES C = Handle_RtspRequest(RecvBuf,res); + if (C == RTSP_PLAY) + m_streaming = true; + else if (C == RTSP_TEARDOWN) + m_stopped = true; + } + return true; + } + else if(res == 0) { + printf("client closed socket, exiting\n"); + m_stopped = true; + return true; + } + else { + // Timeout on read + + return false; + } +} diff --git a/esp/lib/Micro-RTSP/src/CRtspSession.h b/esp/lib/Micro-RTSP/src/CRtspSession.h new file mode 100644 index 0000000..0cee707 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/CRtspSession.h @@ -0,0 +1,79 @@ +#pragma once + +#include "LinkedListElement.h" +#include "CStreamer.h" +#include "platglue.h" + +// supported command types +enum RTSP_CMD_TYPES +{ + RTSP_OPTIONS, + RTSP_DESCRIBE, + RTSP_SETUP, + RTSP_PLAY, + RTSP_TEARDOWN, + RTSP_UNKNOWN +}; + +#define RTSP_BUFFER_SIZE 10000 // for incoming requests, and outgoing responses +#define RTSP_PARAM_STRING_MAX 200 +#define MAX_HOSTNAME_LEN 256 + +class CRtspSession : public LinkedListElement +{ +public: + CRtspSession(WiFiClient& aRtspClient, CStreamer * aStreamer); + ~CRtspSession(); + + RTSP_CMD_TYPES Handle_RtspRequest(char const * aRequest, unsigned aRequestSize); + int GetStreamID(); + + /** + Read from our socket, parsing commands as possible. + + return false if the read timed out + */ + bool handleRequests(uint32_t readTimeoutMs); + + bool m_streaming; + bool m_stopped; + + void InitTransport(u_short aRtpPort, u_short aRtcpPort); + + bool isTcpTransport() { return m_TcpTransport; } + SOCKET& getClient() { return m_RtspClient; } + + uint16_t getRtpClientPort() { return m_RtpClientPort; } +private: + void Init(); + bool ParseRtspRequest(char const * aRequest, unsigned aRequestSize); + char const * DateHeader(); + + // RTSP request command handlers + void Handle_RtspOPTION(); + void Handle_RtspDESCRIBE(); + void Handle_RtspSETUP(); + void Handle_RtspPLAY(); + + // global session state parameters + int m_RtspSessionID; + WiFiClient m_Client; + SOCKET m_RtspClient; // RTSP socket of that session + int m_StreamID; // number of simulated stream of that session + IPPORT m_ClientRTPPort; // client port for UDP based RTP transport + IPPORT m_ClientRTCPPort; // client port for UDP based RTCP transport + bool m_TcpTransport; // if Tcp based streaming was activated + CStreamer * m_Streamer; // the UDP or TCP streamer of that session + + // parameters of the last received RTSP request + + RTSP_CMD_TYPES m_RtspCmdType; // command type (if any) of the current request + char m_URLPreSuffix[RTSP_PARAM_STRING_MAX]; // stream name pre suffix + char m_URLSuffix[RTSP_PARAM_STRING_MAX]; // stream name suffix + char m_CSeq[RTSP_PARAM_STRING_MAX]; // RTSP command sequence number + char m_URLHostPort[MAX_HOSTNAME_LEN]; // host:port part of the URL + unsigned m_ContentLength; // SDP string size + + uint16_t m_RtpClientPort; // RTP receiver port on client (in host byte order!) + uint16_t m_RtcpClientPort; // RTCP receiver port on client (in host byte order!) +}; diff --git a/esp/lib/Micro-RTSP/src/CStreamer.cpp b/esp/lib/Micro-RTSP/src/CStreamer.cpp new file mode 100644 index 0000000..88115a8 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/CStreamer.cpp @@ -0,0 +1,412 @@ +#include "CStreamer.h" +#include "CRtspSession.h" + +#include + +CStreamer::CStreamer(u_short width, u_short height) : m_Clients() +{ + printf("Creating TSP streamer\n"); + m_RtpServerPort = 0; + m_RtcpServerPort = 0; + + m_SequenceNumber = 0; + m_Timestamp = 0; + m_SendIdx = 0; + + m_RtpSocket = NULLSOCKET; + m_RtcpSocket = NULLSOCKET; + + m_width = width; + m_height = height; + m_prevMsec = 0; + + m_udpRefCount = 0; +}; + +CStreamer::~CStreamer() +{ + LinkedListElement* element = m_Clients.m_Next; + CRtspSession* session = NULL; + while (element != &m_Clients) + { + session = static_cast(element); + element = element->m_Next; + delete session; + } +}; + +void CStreamer::addSession(WiFiClient& aClient) +{ + // printf("CStreamer::addSession\n"); + CRtspSession* session = new CRtspSession(aClient, this); // our threads RTSP session and state + // we have it stored in m_Clients +} + +int CStreamer::SendRtpPacket(unsigned const char * jpeg, int jpegLen, int fragmentOffset, BufPtr quant0tbl, BufPtr quant1tbl) +{ + // printf("CStreamer::SendRtpPacket offset:%d - begin\n", fragmentOffset); +#define KRtpHeaderSize 12 // size of the RTP header +#define KJpegHeaderSize 8 // size of the special JPEG payload header + +#define MAX_FRAGMENT_SIZE 1100 // FIXME, pick more carefully + int fragmentLen = MAX_FRAGMENT_SIZE; + if(fragmentLen + fragmentOffset > jpegLen) // Shrink last fragment if needed + fragmentLen = jpegLen - fragmentOffset; + + bool isLastFragment = (fragmentOffset + fragmentLen) == jpegLen; + + if (!m_Clients.NotEmpty()) + { + return isLastFragment ? 0 : fragmentOffset; + } + + // Do we have custom quant tables? If so include them per RFC + + bool includeQuantTbl = quant0tbl && quant1tbl && fragmentOffset == 0; + uint8_t q = includeQuantTbl ? 128 : 0x5e; + + static char RtpBuf[2048]; // Note: we assume single threaded, this large buf we keep off of the tiny stack + int RtpPacketSize = fragmentLen + KRtpHeaderSize + KJpegHeaderSize + (includeQuantTbl ? (4 + 64 * 2) : 0); + + memset(RtpBuf,0x00,sizeof(RtpBuf)); + // Prepare the first 4 byte of the packet. This is the Rtp over Rtsp header in case of TCP based transport + RtpBuf[0] = '$'; // magic number + RtpBuf[1] = 0; // number of multiplexed subchannel on RTPS connection - here the RTP channel + RtpBuf[2] = (RtpPacketSize & 0x0000FF00) >> 8; + RtpBuf[3] = (RtpPacketSize & 0x000000FF); + // Prepare the 12 byte RTP header + RtpBuf[4] = 0x80; // RTP version + RtpBuf[5] = 0x1a | (isLastFragment ? 0x80 : 0x00); // JPEG payload (26) and marker bit + RtpBuf[7] = m_SequenceNumber & 0x0FF; // each packet is counted with a sequence counter + RtpBuf[6] = m_SequenceNumber >> 8; + RtpBuf[8] = (m_Timestamp & 0xFF000000) >> 24; // each image gets a timestamp + RtpBuf[9] = (m_Timestamp & 0x00FF0000) >> 16; + RtpBuf[10] = (m_Timestamp & 0x0000FF00) >> 8; + RtpBuf[11] = (m_Timestamp & 0x000000FF); + RtpBuf[12] = 0x13; // 4 byte SSRC (sychronization source identifier) + RtpBuf[13] = 0xf9; // we just an arbitrary number here to keep it simple + RtpBuf[14] = 0x7e; + RtpBuf[15] = 0x67; + + // Prepare the 8 byte payload JPEG header + RtpBuf[16] = 0x00; // type specific + RtpBuf[17] = (fragmentOffset & 0x00FF0000) >> 16; // 3 byte fragmentation offset for fragmented images + RtpBuf[18] = (fragmentOffset & 0x0000FF00) >> 8; + RtpBuf[19] = (fragmentOffset & 0x000000FF); + + /* These sampling factors indicate that the chrominance components of + type 0 video is downsampled horizontally by 2 (often called 4:2:2) + while the chrominance components of type 1 video are downsampled both + horizontally and vertically by 2 (often called 4:2:0). */ + RtpBuf[20] = 0x00; // type (fixme might be wrong for camera data) https://tools.ietf.org/html/rfc2435 + RtpBuf[21] = q; // quality scale factor was 0x5e + RtpBuf[22] = m_width / 8; // width / 8 + RtpBuf[23] = m_height / 8; // height / 8 + + int headerLen = 24; // Inlcuding jpeg header but not qant table header + if(includeQuantTbl) { // we need a quant header - but only in first packet of the frame + //printf("inserting quanttbl\n"); + RtpBuf[24] = 0; // MBZ + RtpBuf[25] = 0; // 8 bit precision + RtpBuf[26] = 0; // MSB of lentgh + + int numQantBytes = 64; // Two 64 byte tables + RtpBuf[27] = 2 * numQantBytes; // LSB of length + + headerLen += 4; + + memcpy(RtpBuf + headerLen, quant0tbl, numQantBytes); + headerLen += numQantBytes; + + memcpy(RtpBuf + headerLen, quant1tbl, numQantBytes); + headerLen += numQantBytes; + } + // printf("Sending timestamp %d, seq %d, fragoff %d, fraglen %d, jpegLen %d\n", m_Timestamp, m_SequenceNumber, fragmentOffset, fragmentLen, jpegLen); + + // append the JPEG scan data to the RTP buffer + memcpy(RtpBuf + headerLen,jpeg + fragmentOffset, fragmentLen); + fragmentOffset += fragmentLen; + + m_SequenceNumber++; // prepare the packet counter for the next packet + + IPADDRESS otherip; + IPPORT otherport; + + // RTP marker bit must be set on last fragment + LinkedListElement* element = m_Clients.m_Next; + CRtspSession* session = NULL; + while (element != &m_Clients) + { + session = static_cast(element); + if (session->m_streaming && !session->m_stopped) { + if (session->isTcpTransport()) // RTP over RTSP - we send the buffer + 4 byte additional header + socketsend(session->getClient(),RtpBuf,RtpPacketSize + 4); + else // UDP - we send just the buffer by skipping the 4 byte RTP over RTSP header + { + socketpeeraddr(session->getClient(), &otherip, &otherport); + udpsocketsend(m_RtpSocket,&RtpBuf[4],RtpPacketSize, otherip, session->getRtpClientPort()); + } + } + element = element->m_Next; + } + // printf("CStreamer::SendRtpPacket offset:%d - end\n", fragmentOffset); + return isLastFragment ? 0 : fragmentOffset; +}; + +u_short CStreamer::GetRtpServerPort() +{ + return m_RtpServerPort; +}; + +u_short CStreamer::GetRtcpServerPort() +{ + return m_RtcpServerPort; +}; + +bool CStreamer::InitUdpTransport(void) +{ + if (m_udpRefCount != 0) + { + ++m_udpRefCount; + return true; + } + + for (u_short P = 6970; P < 0xFFFE; P += 2) + { + m_RtpSocket = udpsocketcreate(P); + if (m_RtpSocket) + { // Rtp socket was bound successfully. Lets try to bind the consecutive Rtsp socket + m_RtcpSocket = udpsocketcreate(P + 1); + if (m_RtcpSocket) + { + m_RtpServerPort = P; + m_RtcpServerPort = P+1; + break; + } + else + { + udpsocketclose(m_RtpSocket); + udpsocketclose(m_RtcpSocket); + }; + } + }; + ++m_udpRefCount; + return true; +} + +void CStreamer::ReleaseUdpTransport(void) +{ + --m_udpRefCount; + if (m_udpRefCount == 0) + { + m_RtpServerPort = 0; + m_RtcpServerPort = 0; + udpsocketclose(m_RtpSocket); + udpsocketclose(m_RtcpSocket); + + m_RtpSocket = NULLSOCKET; + m_RtcpSocket = NULLSOCKET; + } +} + +/** + Call handleRequests on all sessions + */ +bool CStreamer::handleRequests(uint32_t readTimeoutMs) +{ + bool retVal = true; + LinkedListElement* element = m_Clients.m_Next; + while(element != &m_Clients) + { + CRtspSession* session = static_cast(element); + retVal &= session->handleRequests(readTimeoutMs); + + element = element->m_Next; + + if (session->m_stopped) + { + // remove session here, so we wont have to send to it + delete session; + } + } + + return retVal; +} + +void CStreamer::streamFrame(unsigned const char *data, uint32_t dataLen, uint32_t curMsec) +{ + if(m_prevMsec == 0) // first frame init our timestamp + m_prevMsec = curMsec; + + // compute deltat (being careful to handle clock rollover with a little lie) + uint32_t deltams = (curMsec >= m_prevMsec) ? curMsec - m_prevMsec : 100; + m_prevMsec = curMsec; + + // locate quant tables if possible + BufPtr qtable0, qtable1; + + if(!decodeJPEGfile(&data, &dataLen, &qtable0, &qtable1)) { + printf("can't decode jpeg data\n"); + return; + } + + int offset = 0; + do { + offset = SendRtpPacket(data, dataLen, offset, qtable0, qtable1); + } while(offset != 0); + + // Increment ONLY after a full frame + uint32_t units = 90000; // Hz per RFC 2435 + m_Timestamp += (units * deltams / 1000); // fixed timestamp increment for a frame rate of 25fps + + m_SendIdx++; + if (m_SendIdx > 1) m_SendIdx = 0; +}; + +#include + +// search for a particular JPEG marker, moves *start to just after that marker +// This function fixes up the provided start ptr to point to the +// actual JPEG stream data and returns the number of bytes skipped +// APP0 e0 +// DQT db +// DQT db +// DHT c4 +// DHT c4 +// DHT c4 +// DHT c4 +// SOF0 c0 baseline (not progressive) 3 color 0x01 Y, 0x21 2h1v, 0x00 tbl0 +// - 0x02 Cb, 0x11 1h1v, 0x01 tbl1 - 0x03 Cr, 0x11 1h1v, 0x01 tbl1 +// therefore 4:2:2, with two separate quant tables (0 and 1) +// SOS da +// EOI d9 (no need to strip data after this RFC says client will discard) +bool findJPEGheader(BufPtr *start, uint32_t *len, uint8_t marker) { + // per https://en.wikipedia.org/wiki/JPEG_File_Interchange_Format + unsigned const char *bytes = *start; + + // kinda skanky, will break if unlucky and the headers inxlucde 0xffda + // might fall off array if jpeg is invalid + // FIXME - return false instead + while(bytes - *start < *len) { + uint8_t framing = *bytes++; // better be 0xff + if(framing != 0xff) { + printf("malformed jpeg, framing=%x\n", framing); + return false; + } + uint8_t typecode = *bytes++; + if(typecode == marker) { + unsigned skipped = bytes - *start; + //printf("found marker 0x%x, skipped %d\n", marker, skipped); + + *start = bytes; + + // shrink len for the bytes we just skipped + *len -= skipped; + + return true; + } + else { + // not the section we were looking for, skip the entire section + switch(typecode) { + case 0xd8: // start of image + { + break; // no data to skip + } + case 0xe0: // app0 + case 0xdb: // dqt + case 0xc4: // dht + case 0xc0: // sof0 + case 0xda: // sos + { + // standard format section with 2 bytes for len. skip that many bytes + uint32_t len = bytes[0] * 256 + bytes[1]; + //printf("skipping section 0x%x, %d bytes\n", typecode, len); + bytes += len; + break; + } + default: + printf("unexpected jpeg typecode 0x%x\n", typecode); + break; + } + } + } + + printf("failed to find jpeg marker 0x%x", marker); + return false; +} + +// the scan data uses byte stuffing to guarantee anything that starts with 0xff +// followed by something not zero, is a new section. Look for that marker and return the ptr +// pointing there +void skipScanBytes(BufPtr *start) { + BufPtr bytes = *start; + + while(true) { // FIXME, check against length + while(*bytes++ != 0xff); + if(*bytes++ != 0) { + *start = bytes - 2; // back up to the 0xff marker we just found + return; + } + } +} +void nextJpegBlock(BufPtr *bytes) { + uint32_t len = (*bytes)[0] * 256 + (*bytes)[1]; + //printf("going to next jpeg block %d bytes\n", len); + *bytes += len; +} + +// When JPEG is stored as a file it is wrapped in a container +// This function fixes up the provided start ptr to point to the +// actual JPEG stream data and returns the number of bytes skipped +bool decodeJPEGfile(BufPtr *start, uint32_t *len, BufPtr *qtable0, BufPtr *qtable1) { + // per https://en.wikipedia.org/wiki/JPEG_File_Interchange_Format + unsigned const char *bytes = *start; + + if(!findJPEGheader(&bytes, len, 0xd8)) // better at least look like a jpeg file + return false; // FAILED! + + // Look for quant tables if they are present + *qtable0 = NULL; + *qtable1 = NULL; + BufPtr quantstart = *start; + uint32_t quantlen = *len; + if(!findJPEGheader(&quantstart, &quantlen, 0xdb)) { + printf("error can't find quant table 0\n"); + } + else { + // printf("found quant table %x\n", quantstart[2]); + + *qtable0 = quantstart + 3; // 3 bytes of header skipped + nextJpegBlock(&quantstart); + if(!findJPEGheader(&quantstart, &quantlen, 0xdb)) { + printf("error can't find quant table 1\n"); + } + else { + // printf("found quant table %x\n", quantstart[2]); + } + *qtable1 = quantstart + 3; + nextJpegBlock(&quantstart); + } + + if(!findJPEGheader(start, len, 0xda)) + return false; // FAILED! + + // Skip the header bytes of the SOS marker FIXME why doesn't this work? + uint32_t soslen = (*start)[0] * 256 + (*start)[1]; + *start += soslen; + *len -= soslen; + + // start scanning the data portion of the scan to find the end marker + BufPtr endmarkerptr = *start; + uint32_t endlen = *len; + + skipScanBytes(&endmarkerptr); + if(!findJPEGheader(&endmarkerptr, &endlen, 0xd9)) + return false; // FAILED! + + // endlen must now be the # of bytes between the start of our scan and + // the end marker, tell the caller to ignore bytes afterwards + *len = endmarkerptr - *start; + + return true; +} diff --git a/esp/lib/Micro-RTSP/src/CStreamer.h b/esp/lib/Micro-RTSP/src/CStreamer.h new file mode 100644 index 0000000..7b901ef --- /dev/null +++ b/esp/lib/Micro-RTSP/src/CStreamer.h @@ -0,0 +1,65 @@ +#pragma once + +#include "platglue.h" +#include "LinkedListElement.h" + +typedef unsigned const char *BufPtr; + +class CStreamer +{ +public: + CStreamer(u_short width, u_short height); + virtual ~CStreamer(); + + void addSession(WiFiClient& aClient); + LinkedListElement* getClientsListHead() { return &m_Clients; } + + int anySessions() { return m_Clients.NotEmpty(); } + + bool handleRequests(uint32_t readTimeoutMs); + + u_short GetRtpServerPort(); + u_short GetRtcpServerPort(); + + virtual void streamImage(uint32_t curMsec) = 0; // send a new image to the client + bool InitUdpTransport(void); + void ReleaseUdpTransport(void); +protected: + + void streamFrame(unsigned const char *data, uint32_t dataLen, uint32_t curMsec); + +private: + int SendRtpPacket(unsigned const char *jpeg, int jpegLen, int fragmentOffset, BufPtr quant0tbl = NULL, BufPtr quant1tbl = NULL);// returns new fragmentOffset or 0 if finished with frame + + UDPSOCKET m_RtpSocket; // RTP socket for streaming RTP packets to client + UDPSOCKET m_RtcpSocket; // RTCP socket for sending/receiving RTCP packages + + IPPORT m_RtpServerPort; // RTP sender port on server + IPPORT m_RtcpServerPort; // RTCP sender port on server + + u_short m_SequenceNumber; + uint32_t m_Timestamp; + int m_SendIdx; + + LinkedListElement m_Clients; + uint32_t m_prevMsec; + + int m_udpRefCount; + + u_short m_width; // image data info + u_short m_height; +}; + + + +// When JPEG is stored as a file it is wrapped in a container +// This function fixes up the provided start ptr to point to the +// actual JPEG stream data and returns the number of bytes skipped +// returns true if the file seems to be valid jpeg +// If quant tables can be found they will be stored in qtable0/1 +bool decodeJPEGfile(BufPtr *start, uint32_t *len, BufPtr *qtable0, BufPtr *qtable1); +bool findJPEGheader(BufPtr *start, uint32_t *len, uint8_t marker); + +// Given a jpeg ptr pointing to a pair of length bytes, advance the pointer to +// the next 0xff marker byte +void nextJpegBlock(BufPtr *start); diff --git a/esp/lib/Micro-RTSP/src/JPEGSamples.cpp b/esp/lib/Micro-RTSP/src/JPEGSamples.cpp new file mode 100644 index 0000000..12def78 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/JPEGSamples.cpp @@ -0,0 +1,3327 @@ +#include "JPEGSamples.h" + +#ifdef INCLUDE_SIMDATA +// APP0 e0 +// DQT db +// DQT db +// DHT c4 +// DHT c4 +// DHT c4 +// DHT c4 +// SOF0 c0 baseline (not progressive) 3 color 0x01 Y, 0x21 2h1v, 0x00 tbl0 +// - 0x02 Cb, 0x11 1h1v, 0x01 tbl1 - 0x03 Cr, 0x11 1h1v, 0x01 tbl1 +// therefore 4:2:2, with two separate quant tables (0 and 1) +// SOS da +// EOI d9 (no need to strip data after this RFC says client will discard) +unsigned const char capture_jpg[] = { + 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43, + 0x00, 0x0f, 0x0a, 0x0b, 0x0d, 0x0b, 0x09, 0x0f, 0x0d, 0x0c, 0x0d, 0x11, + 0x10, 0x0f, 0x12, 0x17, 0x26, 0x18, 0x17, 0x15, 0x15, 0x17, 0x2e, 0x21, + 0x23, 0x1b, 0x26, 0x36, 0x30, 0x39, 0x38, 0x35, 0x30, 0x35, 0x34, 0x3c, + 0x44, 0x56, 0x49, 0x3c, 0x40, 0x52, 0x41, 0x34, 0x35, 0x4b, 0x66, 0x4c, + 0x52, 0x59, 0x5c, 0x61, 0x62, 0x61, 0x3a, 0x48, 0x6a, 0x71, 0x69, 0x5e, + 0x71, 0x56, 0x5f, 0x61, 0x5d, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x10, 0x11, + 0x11, 0x17, 0x14, 0x17, 0x2c, 0x18, 0x18, 0x2c, 0x5d, 0x3e, 0x35, 0x3e, + 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, + 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, + 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, + 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, + 0x5d, 0x5d, 0xff, 0xc4, 0x00, 0x1f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, + 0xc4, 0x00, 0xb5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, + 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, + 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, + 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, + 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, + 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, + 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, + 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, + 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, + 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, + 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, + 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, + 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, + 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, + 0xf9, 0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, + 0xc4, 0x00, 0xb5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, + 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, + 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, + 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, + 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, + 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, + 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, + 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, + 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, + 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, + 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, + 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, + 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, + 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, + 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, + 0xf9, 0xfa, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x02, 0x58, 0x03, 0x20, 0x03, + 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xda, 0x00, + 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xc7, + 0x10, 0xd3, 0xa3, 0x84, 0xaf, 0x34, 0xda, 0x08, 0x9a, 0xe3, 0x1b, 0x46, + 0x29, 0xc9, 0xf7, 0xc5, 0x4f, 0x40, 0x34, 0xd3, 0xa5, 0x3a, 0x84, 0x20, + 0xa5, 0xa6, 0x20, 0xa2, 0x81, 0x85, 0x14, 0x08, 0x28, 0xa0, 0x62, 0xd1, + 0x40, 0x05, 0x14, 0x00, 0x94, 0x50, 0x01, 0x45, 0x03, 0x0a, 0x28, 0x10, + 0x52, 0x50, 0x01, 0x49, 0x40, 0xc2, 0x8a, 0x00, 0x29, 0x28, 0x01, 0x28, + 0xa0, 0x02, 0x92, 0x80, 0x12, 0x8a, 0x00, 0x4a, 0x4a, 0x00, 0x29, 0x28, + 0x01, 0x29, 0x28, 0x01, 0x28, 0xa0, 0x04, 0xa4, 0xa0, 0x02, 0x92, 0x80, + 0x12, 0x92, 0x80, 0x12, 0x8a, 0x60, 0x25, 0x25, 0x02, 0x12, 0x92, 0x80, + 0x12, 0x8a, 0x00, 0x4a, 0x4a, 0x40, 0x14, 0x50, 0x02, 0x52, 0x53, 0x10, + 0x94, 0x94, 0x08, 0x4a, 0x28, 0x10, 0x94, 0x94, 0x00, 0x52, 0x50, 0x02, + 0x52, 0x50, 0x02, 0x51, 0x40, 0x09, 0x49, 0x40, 0x09, 0x4f, 0x4e, 0x94, + 0x08, 0x75, 0x15, 0x42, 0x12, 0x8a, 0x42, 0x12, 0x92, 0x98, 0x09, 0x45, + 0x00, 0x14, 0x94, 0x08, 0x28, 0xa4, 0x02, 0x52, 0x53, 0x10, 0x52, 0x52, + 0x00, 0xa4, 0xa0, 0x90, 0x13, 0x2d, 0x4a, 0xb2, 0x27, 0xa8, 0xa9, 0x67, + 0x51, 0x76, 0x06, 0xdd, 0x06, 0x7d, 0xe9, 0xd4, 0x90, 0xcd, 0x28, 0x4e, + 0x56, 0xa5, 0xa1, 0x08, 0x29, 0x69, 0x88, 0x28, 0xa0, 0x02, 0x8a, 0x00, + 0x28, 0xa0, 0x61, 0x4b, 0x40, 0x09, 0x4b, 0x40, 0x84, 0xa2, 0x81, 0x85, + 0x14, 0x00, 0x51, 0x40, 0xc2, 0x92, 0x81, 0x05, 0x14, 0x00, 0x94, 0x50, + 0x01, 0x49, 0x40, 0x05, 0x25, 0x03, 0x0a, 0x4a, 0x00, 0x29, 0x28, 0x01, + 0x29, 0x28, 0x00, 0xa4, 0xa0, 0x04, 0xa2, 0x80, 0x12, 0x92, 0x81, 0x09, + 0x45, 0x03, 0x12, 0x92, 0x80, 0x12, 0x8a, 0x00, 0x4a, 0x4a, 0x62, 0x12, + 0x92, 0x90, 0x09, 0x49, 0x40, 0x09, 0x49, 0x40, 0x05, 0x25, 0x02, 0x12, + 0x8a, 0x60, 0x25, 0x25, 0x00, 0x14, 0x94, 0x08, 0x29, 0xb4, 0x00, 0x52, + 0x50, 0x21, 0x29, 0x28, 0x00, 0xa4, 0xa0, 0x04, 0xa2, 0x98, 0x86, 0xd1, + 0x48, 0x04, 0xa7, 0xa5, 0x00, 0x3a, 0x90, 0xd5, 0x12, 0x25, 0x25, 0x00, + 0x14, 0x50, 0x02, 0x51, 0x40, 0x84, 0xa4, 0xa0, 0x02, 0x8a, 0x00, 0x4a, + 0x29, 0x08, 0x29, 0x28, 0x01, 0x29, 0x29, 0x88, 0xcb, 0xf3, 0x4d, 0x28, + 0x90, 0xd2, 0xb1, 0xd4, 0x6d, 0xe8, 0xf2, 0x6f, 0xb6, 0xdb, 0xe9, 0x93, + 0xfa, 0xd5, 0xda, 0xce, 0x23, 0x65, 0xeb, 0x43, 0x94, 0xab, 0x14, 0xd0, + 0x98, 0xb4, 0x53, 0x24, 0x28, 0xa0, 0x05, 0xa2, 0x80, 0x0a, 0x28, 0x18, + 0x51, 0x40, 0x05, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, 0x00, 0x51, 0x40, + 0x09, 0x45, 0x00, 0x14, 0x94, 0x0c, 0x28, 0xa0, 0x02, 0x92, 0x80, 0x0a, + 0x4a, 0x00, 0x29, 0x28, 0x00, 0xa4, 0xa0, 0x04, 0xa2, 0x80, 0x12, 0x8a, + 0x00, 0x4a, 0x4a, 0x00, 0x4a, 0x4a, 0x00, 0x4a, 0x28, 0x01, 0x29, 0x28, + 0x10, 0x94, 0x50, 0x31, 0x29, 0x28, 0x10, 0x94, 0x94, 0x0c, 0x4a, 0x4a, + 0x62, 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, 0x0a, 0x4a, 0x04, 0x14, 0x94, + 0x00, 0x53, 0x68, 0x10, 0x52, 0x50, 0x02, 0x51, 0x40, 0x86, 0xd1, 0x40, + 0x09, 0x49, 0x4c, 0x04, 0xa2, 0x80, 0x12, 0x92, 0x81, 0x09, 0x4f, 0x4a, + 0x40, 0x3a, 0x9b, 0x56, 0x48, 0x52, 0x50, 0x01, 0x45, 0x20, 0x0a, 0x29, + 0x08, 0x4a, 0x4a, 0x60, 0x25, 0x14, 0x80, 0x4a, 0x29, 0x92, 0x14, 0x94, + 0x80, 0x4a, 0x29, 0x8c, 0xc4, 0xcd, 0x28, 0xe9, 0x53, 0x63, 0xa4, 0xd7, + 0xd0, 0x5f, 0xe7, 0x91, 0x7f, 0xd9, 0xfe, 0xb5, 0xad, 0x59, 0xc4, 0xa9, + 0x97, 0x2c, 0xcf, 0x6a, 0xb9, 0x4d, 0x12, 0x14, 0xb5, 0x42, 0x0a, 0x28, + 0x00, 0xa2, 0x80, 0x16, 0x8a, 0x00, 0x28, 0xa0, 0x41, 0x45, 0x00, 0x14, + 0x50, 0x30, 0xa4, 0xa0, 0x02, 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x92, 0x81, + 0x85, 0x14, 0x00, 0x94, 0x50, 0x01, 0x49, 0x40, 0x05, 0x25, 0x00, 0x14, + 0x94, 0x00, 0x52, 0x50, 0x02, 0x52, 0x50, 0x01, 0x49, 0x40, 0x09, 0x49, + 0x40, 0x09, 0x49, 0x40, 0x05, 0x25, 0x00, 0x25, 0x14, 0x00, 0x94, 0x94, + 0x00, 0x94, 0x94, 0x00, 0x94, 0x94, 0xc4, 0x25, 0x25, 0x20, 0x12, 0x92, + 0x80, 0x12, 0x92, 0x80, 0x0a, 0x29, 0x80, 0x94, 0x94, 0x08, 0x29, 0x29, + 0x08, 0x6d, 0x15, 0x40, 0x25, 0x25, 0x21, 0x09, 0x45, 0x20, 0x12, 0x92, + 0x81, 0x09, 0x49, 0x4c, 0x02, 0x9c, 0x94, 0x00, 0xfa, 0x69, 0xaa, 0x24, + 0x4a, 0x4a, 0x00, 0x29, 0x68, 0x01, 0x28, 0xa4, 0x21, 0x28, 0xa6, 0x02, + 0x52, 0x52, 0x00, 0xa2, 0x81, 0x09, 0x45, 0x31, 0x09, 0x4d, 0x35, 0x43, + 0x30, 0xa9, 0xea, 0x6a, 0x2c, 0x74, 0x9a, 0x3a, 0x3b, 0xe2, 0xf6, 0x25, + 0xfe, 0xf3, 0x62, 0xb7, 0xab, 0x3e, 0xa3, 0x96, 0xc4, 0xf6, 0x87, 0xe7, + 0xad, 0x01, 0x42, 0x10, 0xb4, 0x55, 0x08, 0x5a, 0x28, 0x10, 0x51, 0x40, + 0x0b, 0x49, 0x40, 0xc5, 0xa2, 0x98, 0x05, 0x14, 0x80, 0x29, 0x28, 0x00, + 0xa2, 0x80, 0x0a, 0x28, 0x00, 0xa2, 0x80, 0x0a, 0x4a, 0x06, 0x14, 0x50, + 0x02, 0x51, 0x40, 0x05, 0x25, 0x00, 0x14, 0x94, 0x00, 0x52, 0x50, 0x01, + 0x49, 0x40, 0x09, 0x45, 0x00, 0x25, 0x25, 0x00, 0x25, 0x25, 0x00, 0x14, + 0x94, 0x00, 0x94, 0x94, 0x00, 0x94, 0x50, 0x02, 0x52, 0x50, 0x21, 0x29, + 0x28, 0x01, 0x29, 0xb4, 0x00, 0x52, 0x50, 0x21, 0x29, 0x28, 0x01, 0x29, + 0x29, 0x80, 0x94, 0x52, 0x00, 0xa4, 0xa6, 0x21, 0x29, 0x28, 0x01, 0x29, + 0x28, 0x00, 0xa4, 0x34, 0x08, 0x4a, 0x4a, 0x04, 0x25, 0x14, 0x00, 0xda, + 0x28, 0x01, 0x29, 0xcb, 0x40, 0x0f, 0xa4, 0xab, 0x20, 0x4a, 0x4a, 0x00, + 0x28, 0xa0, 0x04, 0xa2, 0x81, 0x09, 0x45, 0x21, 0x85, 0x25, 0x02, 0x12, + 0x8a, 0x00, 0x4a, 0x4a, 0x42, 0x0a, 0x29, 0x81, 0x81, 0x4e, 0x14, 0x8e, + 0xa2, 0xcd, 0x9b, 0xf9, 0x77, 0x51, 0xbf, 0xa1, 0xae, 0xa3, 0xf8, 0x54, + 0xfa, 0x81, 0x51, 0xf6, 0x87, 0xd0, 0x92, 0x0e, 0x25, 0x15, 0xa4, 0xbd, + 0x29, 0x75, 0x10, 0xb4, 0xb5, 0x42, 0x0a, 0x28, 0x10, 0xb4, 0x50, 0x01, + 0x45, 0x03, 0x0a, 0x29, 0x80, 0xb4, 0x94, 0x80, 0x29, 0x68, 0x01, 0x28, + 0xa0, 0x02, 0x8a, 0x00, 0x29, 0x29, 0x80, 0xb4, 0x94, 0x86, 0x14, 0x50, + 0x02, 0x52, 0xd0, 0x02, 0x52, 0x50, 0x01, 0x45, 0x00, 0x14, 0x94, 0x00, + 0x94, 0x94, 0x00, 0x52, 0x50, 0x02, 0x52, 0x50, 0x01, 0x49, 0x40, 0x09, + 0x49, 0x40, 0x09, 0x49, 0x40, 0x09, 0x49, 0x40, 0x09, 0x45, 0x00, 0x25, + 0x25, 0x02, 0x12, 0x92, 0x98, 0x09, 0x49, 0x48, 0x42, 0x52, 0x50, 0x02, + 0x52, 0x50, 0x02, 0x52, 0x53, 0x00, 0xa2, 0x81, 0x09, 0x49, 0x40, 0x09, + 0x49, 0x40, 0x09, 0x45, 0x00, 0x36, 0x8a, 0x64, 0x89, 0x49, 0x48, 0x62, + 0x51, 0x45, 0xc4, 0x25, 0x2a, 0x50, 0x03, 0xe8, 0xaa, 0x24, 0x4a, 0x28, + 0x10, 0x94, 0x50, 0x02, 0x51, 0x40, 0x86, 0xd1, 0x48, 0x61, 0x49, 0x45, + 0xc4, 0x25, 0x14, 0xc0, 0x4a, 0x29, 0x00, 0x94, 0xb4, 0x08, 0xe7, 0xe9, + 0xc0, 0xd0, 0xce, 0x91, 0xd9, 0xae, 0xbe, 0x36, 0xdf, 0x0a, 0x9f, 0xc3, + 0xf4, 0xac, 0xdf, 0xc4, 0x57, 0xd9, 0x1c, 0x3a, 0xd6, 0x9c, 0x7c, 0xad, + 0x1d, 0x44, 0x3e, 0x8a, 0xa1, 0x0b, 0x45, 0x00, 0x14, 0xb4, 0x08, 0x28, + 0xa0, 0x61, 0x45, 0x00, 0x14, 0xb4, 0x00, 0x94, 0x50, 0x02, 0xd2, 0x50, + 0x01, 0x45, 0x00, 0x14, 0x94, 0x00, 0x51, 0x40, 0x05, 0x14, 0x0c, 0x4a, + 0x28, 0x00, 0xa2, 0x80, 0x12, 0x8a, 0x00, 0x4a, 0x28, 0x01, 0x28, 0xa0, + 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x02, 0x92, 0x80, 0x12, 0x92, 0x80, + 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, 0x0a, 0x4a, 0x00, 0x6d, 0x14, 0x00, + 0x94, 0x94, 0x08, 0x4a, 0x4a, 0x04, 0x25, 0x36, 0x80, 0x12, 0x92, 0x80, + 0x0a, 0x4a, 0x00, 0x4a, 0x28, 0x01, 0x29, 0x28, 0x10, 0x94, 0x94, 0x0c, + 0x29, 0x28, 0x10, 0x94, 0x94, 0x08, 0x4a, 0x29, 0x88, 0x4a, 0x43, 0x40, + 0x09, 0x4e, 0x5a, 0x60, 0x3e, 0x8a, 0x76, 0x24, 0x6d, 0x14, 0x00, 0x52, + 0x50, 0x21, 0x28, 0xa0, 0x42, 0x52, 0x1a, 0x2c, 0x30, 0xa2, 0x80, 0x12, + 0x92, 0x98, 0x82, 0x92, 0xa4, 0x41, 0x49, 0x4c, 0x66, 0x05, 0x14, 0x1d, + 0x03, 0x96, 0xba, 0x9d, 0x29, 0xf7, 0xe9, 0xab, 0xeb, 0xb9, 0xab, 0x29, + 0xbd, 0x51, 0x7f, 0x64, 0xb3, 0xda, 0xb4, 0xa0, 0x39, 0x4a, 0x1e, 0xe4, + 0x92, 0xd2, 0xd5, 0x08, 0x5a, 0x28, 0x10, 0x51, 0x40, 0x0b, 0x45, 0x00, + 0x14, 0x50, 0x30, 0xa2, 0x80, 0x0a, 0x28, 0x00, 0xa2, 0x80, 0x0a, 0x4a, + 0x00, 0x28, 0xa0, 0x05, 0xa4, 0xa0, 0x61, 0x45, 0x02, 0x0a, 0x4a, 0x06, + 0x14, 0x50, 0x02, 0x51, 0x40, 0x05, 0x25, 0x00, 0x14, 0x94, 0x00, 0x94, + 0x94, 0x00, 0x52, 0x50, 0x02, 0x52, 0x50, 0x02, 0x52, 0x50, 0x02, 0x52, + 0x50, 0x02, 0x52, 0x50, 0x02, 0x52, 0x50, 0x02, 0x52, 0x50, 0x21, 0x28, + 0xa0, 0x62, 0x53, 0x68, 0x10, 0x94, 0x94, 0x08, 0x4a, 0x4a, 0x06, 0x25, + 0x25, 0x02, 0x12, 0x8a, 0x00, 0x4a, 0x28, 0x10, 0x94, 0x94, 0x00, 0x94, + 0x53, 0x10, 0x94, 0x94, 0x0c, 0x4a, 0x4a, 0x09, 0x12, 0x92, 0x98, 0x05, + 0x2a, 0xf5, 0xa0, 0x07, 0xd1, 0x4c, 0x91, 0x28, 0xa0, 0x42, 0x52, 0x50, + 0x01, 0x45, 0x00, 0x25, 0x36, 0x80, 0x0a, 0x29, 0x88, 0x4a, 0x29, 0x08, + 0x43, 0x45, 0x20, 0x1b, 0x45, 0x00, 0x73, 0xf4, 0x50, 0x74, 0x8e, 0x53, + 0x5d, 0x0f, 0x87, 0xdf, 0x74, 0x0c, 0x87, 0xb0, 0xcf, 0xeb, 0x59, 0x54, + 0x45, 0xa3, 0x4f, 0xb5, 0x5e, 0xb4, 0x3f, 0x2d, 0x53, 0x24, 0xb3, 0x4b, + 0x4c, 0x41, 0x45, 0x00, 0x2d, 0x14, 0x08, 0x28, 0xa0, 0x02, 0x96, 0x81, + 0x85, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, 0x00, 0x52, 0x50, 0x30, 0xa2, + 0x81, 0x05, 0x14, 0x0c, 0x29, 0x28, 0x01, 0x69, 0x28, 0x00, 0xa4, 0xa0, + 0x02, 0x8a, 0x00, 0x4a, 0x28, 0x01, 0x28, 0xa0, 0x04, 0xa2, 0x80, 0x12, + 0x92, 0x80, 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, 0x12, + 0x92, 0x80, 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, 0x0a, 0x6d, 0x00, 0x25, + 0x25, 0x02, 0x12, 0x92, 0x80, 0x1b, 0x45, 0x02, 0x12, 0x92, 0x98, 0x09, + 0x49, 0x40, 0x05, 0x25, 0x02, 0x12, 0x92, 0x80, 0x0a, 0x4a, 0x42, 0x10, + 0xd2, 0x53, 0x01, 0x29, 0x28, 0x00, 0xa6, 0xd0, 0x20, 0xa5, 0x1d, 0x69, + 0x80, 0xfa, 0x29, 0x92, 0x25, 0x25, 0x31, 0x05, 0x25, 0x00, 0x25, 0x14, + 0x00, 0x94, 0x50, 0x21, 0x28, 0xa4, 0x02, 0x51, 0x4c, 0x04, 0xa4, 0xa4, + 0x01, 0x45, 0x22, 0x4e, 0x76, 0x92, 0x9d, 0xb5, 0x3a, 0x87, 0x0a, 0xd9, + 0xf0, 0xec, 0x9f, 0xe9, 0x32, 0x2f, 0xf7, 0xb6, 0x8f, 0xd6, 0xb2, 0xa8, + 0x5c, 0x0d, 0xda, 0xb5, 0x66, 0x79, 0xc5, 0x36, 0x4a, 0x2e, 0xd2, 0xd3, + 0x10, 0xb4, 0x94, 0x08, 0x5a, 0x5a, 0x00, 0x4a, 0x28, 0x18, 0xb4, 0x53, + 0x00, 0xa2, 0x90, 0x05, 0x14, 0xc0, 0x28, 0xa4, 0x01, 0x45, 0x03, 0x0a, + 0x28, 0x10, 0x51, 0x40, 0xc2, 0x92, 0x81, 0x05, 0x14, 0x0c, 0x29, 0x28, + 0x00, 0xa2, 0x80, 0x0a, 0x4a, 0x00, 0x29, 0x28, 0x00, 0xa4, 0xa0, 0x04, + 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, + 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, + 0xa4, 0xa0, 0x42, 0x52, 0x50, 0x02, 0x53, 0x69, 0x88, 0x4a, 0x4a, 0x40, + 0x25, 0x25, 0x00, 0x14, 0x53, 0x10, 0x94, 0x94, 0x00, 0x94, 0x94, 0x80, + 0x4a, 0x4a, 0x62, 0x0a, 0x6d, 0x02, 0x12, 0x92, 0x98, 0x05, 0x2a, 0xd2, + 0x02, 0x4a, 0x4a, 0xa2, 0x44, 0xa4, 0xa0, 0x41, 0x49, 0x4c, 0x02, 0x92, + 0x81, 0x89, 0x45, 0x21, 0x09, 0x45, 0x32, 0x44, 0xa4, 0xa0, 0x02, 0x8a, + 0x40, 0x25, 0x14, 0x86, 0x73, 0x94, 0xb4, 0x23, 0xa0, 0x4c, 0xd6, 0x86, + 0x8a, 0xf8, 0xd4, 0x61, 0xff, 0x00, 0x7c, 0x54, 0x54, 0xd8, 0xd2, 0x9e, + 0xe7, 0x51, 0xe9, 0x53, 0xda, 0xff, 0x00, 0xac, 0xa5, 0xba, 0x20, 0xd0, + 0x14, 0xb5, 0x42, 0x16, 0x8a, 0x04, 0x2d, 0x14, 0x0c, 0x28, 0xa0, 0x02, + 0x8a, 0x00, 0x5a, 0x28, 0x00, 0xa2, 0x80, 0x0a, 0x28, 0x18, 0x51, 0x40, + 0x05, 0x14, 0xc0, 0x28, 0xa4, 0x02, 0x52, 0xd0, 0x02, 0x51, 0x40, 0x05, + 0x14, 0x00, 0x52, 0x50, 0x01, 0x49, 0x40, 0x05, 0x14, 0x00, 0x94, 0x94, + 0x00, 0x94, 0x94, 0x00, 0x53, 0x68, 0x00, 0xa4, 0xa0, 0x06, 0xd2, 0x50, + 0x02, 0x52, 0x50, 0x02, 0x52, 0x50, 0x02, 0x52, 0x50, 0x02, 0x52, 0x50, + 0x02, 0x52, 0x50, 0x02, 0x53, 0x68, 0x01, 0x29, 0x28, 0x10, 0x94, 0x94, + 0x08, 0x6d, 0x25, 0x30, 0x0a, 0x29, 0x00, 0x94, 0x94, 0x08, 0x4a, 0x4a, + 0x60, 0x25, 0x14, 0x84, 0x36, 0x8a, 0x00, 0x4a, 0x4a, 0x62, 0x12, 0x94, + 0x52, 0x02, 0x4a, 0x4a, 0xb2, 0x44, 0xa2, 0x98, 0x84, 0xa2, 0x90, 0x09, + 0x49, 0x40, 0x09, 0x45, 0x02, 0x12, 0x8a, 0x04, 0x25, 0x14, 0x00, 0x94, + 0x94, 0x00, 0x51, 0x49, 0x01, 0xcd, 0x52, 0xd3, 0xb1, 0xd4, 0x15, 0x62, + 0xc9, 0xfc, 0xbb, 0x84, 0x7f, 0xee, 0xf3, 0x51, 0x3d, 0x8a, 0x8e, 0xe7, + 0x62, 0x3e, 0xe2, 0x7f, 0xba, 0x3f, 0x95, 0x4b, 0x0f, 0x12, 0x0a, 0x95, + 0xf0, 0x93, 0xd4, 0xd2, 0x5e, 0x94, 0xea, 0xa1, 0x0b, 0x45, 0x00, 0x14, + 0x50, 0x21, 0x68, 0xa0, 0x02, 0x8a, 0x06, 0x14, 0x53, 0x00, 0xa2, 0x90, + 0x05, 0x2d, 0x00, 0x25, 0x14, 0x00, 0x51, 0x40, 0xc5, 0xa2, 0x80, 0x12, + 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x8a, 0x00, 0x29, 0x28, 0x00, 0xa2, 0x80, + 0x12, 0x92, 0x80, 0x0a, 0x4a, 0x00, 0x4a, 0x28, 0x01, 0x29, 0x28, 0x01, + 0x29, 0x28, 0x01, 0x29, 0x28, 0x01, 0xb4, 0x94, 0x00, 0x94, 0x94, 0x00, + 0x94, 0x94, 0x00, 0x94, 0x94, 0x00, 0x94, 0x94, 0x08, 0x6d, 0x25, 0x00, + 0x25, 0x25, 0x00, 0x36, 0x92, 0x81, 0x09, 0x49, 0x40, 0x09, 0x45, 0x00, + 0x14, 0x94, 0x00, 0x94, 0x94, 0x08, 0x4a, 0x4a, 0x00, 0x4a, 0x4a, 0x04, + 0x25, 0x25, 0x31, 0x05, 0x14, 0x01, 0x25, 0x25, 0x31, 0x09, 0x45, 0x31, + 0x09, 0x45, 0x00, 0x25, 0x14, 0x12, 0x25, 0x25, 0x00, 0x14, 0x94, 0xc0, + 0x4a, 0x29, 0x08, 0x4a, 0x4a, 0x00, 0x29, 0x28, 0x03, 0x9c, 0xa2, 0xa4, + 0xea, 0x0a, 0x50, 0xdc, 0x7e, 0x14, 0xa5, 0xb0, 0xe2, 0x76, 0xb6, 0xef, + 0xe6, 0xdb, 0xab, 0x7e, 0x1f, 0xa0, 0xa9, 0x97, 0xae, 0x6a, 0x21, 0xf0, + 0x83, 0xdc, 0xd3, 0x8f, 0xee, 0xd4, 0x95, 0x68, 0x90, 0xa2, 0x80, 0x16, + 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x96, 0x80, 0x0a, 0x28, 0x00, 0xa2, 0x81, + 0x85, 0x2d, 0x02, 0x12, 0x8a, 0x06, 0x14, 0x50, 0x01, 0x45, 0x00, 0x14, + 0x50, 0x01, 0x45, 0x00, 0x14, 0x50, 0x01, 0x49, 0x40, 0x05, 0x14, 0x00, + 0x94, 0x50, 0x01, 0x49, 0x40, 0x09, 0x49, 0x40, 0x09, 0x49, 0x40, 0x09, + 0x49, 0x40, 0x09, 0x49, 0x40, 0x09, 0x4d, 0xa0, 0x04, 0xa4, 0xa0, 0x04, + 0xa4, 0xa0, 0x06, 0xd2, 0x50, 0x02, 0x52, 0x50, 0x21, 0x29, 0x28, 0x01, + 0xb4, 0x50, 0x03, 0x69, 0x28, 0x01, 0x29, 0x28, 0x10, 0x94, 0x94, 0x00, + 0x52, 0x50, 0x21, 0x29, 0x28, 0x01, 0x29, 0x28, 0x10, 0x94, 0x94, 0x00, + 0x86, 0x92, 0x98, 0x09, 0x45, 0x02, 0x24, 0xa2, 0xa8, 0x91, 0x28, 0xa0, + 0x42, 0x51, 0x40, 0x09, 0x45, 0x00, 0x25, 0x25, 0x31, 0x09, 0x45, 0x21, + 0x09, 0x45, 0x03, 0x12, 0x8a, 0x62, 0x12, 0x8a, 0x00, 0xe6, 0x8d, 0x2e, + 0x78, 0xa9, 0x3a, 0x80, 0x51, 0x40, 0x2d, 0xce, 0xb7, 0x44, 0x7f, 0x33, + 0x4c, 0x1f, 0xef, 0xb5, 0x5e, 0xed, 0x59, 0x53, 0xd8, 0x72, 0xf8, 0x8d, + 0x2b, 0x7e, 0x52, 0xa5, 0xab, 0x44, 0x8b, 0x4b, 0x40, 0x05, 0x14, 0x00, + 0xb4, 0x94, 0x00, 0xb4, 0x50, 0x01, 0x45, 0x00, 0x14, 0x50, 0x02, 0xd1, + 0x40, 0xc2, 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x8a, 0x00, 0x28, 0xa0, 0x02, + 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x8a, 0x00, 0x29, 0x28, 0x01, 0x28, 0xa0, + 0x04, 0xa2, 0x80, 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, 0x12, 0x92, 0x80, + 0x12, 0x92, 0x80, 0x1b, 0x49, 0x40, 0x09, 0x49, 0x40, 0x09, 0x49, 0x40, + 0x0d, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa6, 0xd0, 0x02, 0x52, 0x50, + 0x21, 0x29, 0x28, 0x10, 0xda, 0x4a, 0x00, 0x29, 0x28, 0x01, 0x29, 0x28, + 0x10, 0x94, 0x94, 0x00, 0x94, 0x94, 0x00, 0x94, 0x94, 0xc4, 0x25, 0x25, + 0x02, 0x12, 0x8a, 0x40, 0x49, 0x45, 0x50, 0x84, 0xa4, 0xa6, 0x48, 0x52, + 0x53, 0x00, 0xa4, 0xa4, 0x01, 0x49, 0x40, 0x82, 0x92, 0x81, 0x09, 0x45, + 0x21, 0x89, 0x45, 0x31, 0x09, 0x45, 0x20, 0x39, 0xaa, 0x5e, 0x94, 0xec, + 0x75, 0x0a, 0x29, 0x31, 0x4a, 0xc0, 0x74, 0x7e, 0x19, 0x7c, 0xc3, 0x24, + 0x7f, 0xdd, 0x19, 0xff, 0x00, 0xc7, 0xab, 0x66, 0xb3, 0xa7, 0xd8, 0xa9, + 0xee, 0x5d, 0xb3, 0x6f, 0x92, 0xad, 0x55, 0x22, 0x18, 0xb4, 0x50, 0x01, + 0x4b, 0x40, 0x82, 0x8a, 0x06, 0x14, 0x53, 0x00, 0xa2, 0x90, 0x0b, 0x45, + 0x00, 0x14, 0x50, 0x30, 0xa5, 0xa0, 0x02, 0x8a, 0x00, 0x28, 0xa0, 0x02, + 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x8a, 0x00, 0x28, 0xa0, 0x04, 0xa2, 0x80, + 0x12, 0x8a, 0x00, 0x29, 0x28, 0x01, 0x29, 0x28, 0x00, 0xa4, 0xa0, 0x06, + 0xd2, 0x50, 0x02, 0x52, 0x50, 0x02, 0x53, 0x68, 0x01, 0x29, 0x28, 0x01, + 0x29, 0xb4, 0x00, 0x94, 0x94, 0x00, 0x94, 0xda, 0x00, 0x29, 0xb4, 0x08, + 0x4a, 0x69, 0xa0, 0x04, 0xa4, 0xa0, 0x42, 0x52, 0x50, 0x02, 0x52, 0x50, + 0x02, 0x51, 0x40, 0x0d, 0xa4, 0xa6, 0x21, 0x29, 0x29, 0x00, 0x94, 0x94, + 0xc4, 0x06, 0x9b, 0x40, 0x09, 0x45, 0x02, 0x1f, 0x45, 0x32, 0x44, 0xa2, + 0x98, 0x05, 0x25, 0x00, 0x14, 0x50, 0x21, 0x29, 0x29, 0x80, 0x94, 0x50, + 0x21, 0x28, 0xa0, 0x02, 0x92, 0x90, 0x84, 0xa2, 0x98, 0x1c, 0xd5, 0x25, + 0x23, 0xa8, 0x70, 0xe9, 0x4b, 0x48, 0x0d, 0x9f, 0x0e, 0x49, 0xfe, 0x99, + 0x27, 0xfb, 0x5b, 0x57, 0xf5, 0xae, 0x88, 0x56, 0x50, 0xea, 0x54, 0xcb, + 0x56, 0x47, 0x9c, 0x55, 0xda, 0xa4, 0x4b, 0x16, 0x8a, 0x62, 0x16, 0x8a, + 0x00, 0x28, 0xa0, 0x02, 0x96, 0x98, 0x05, 0x14, 0x86, 0x14, 0x50, 0x21, + 0x68, 0xa0, 0x61, 0x45, 0x00, 0x2d, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, + 0x00, 0x51, 0x40, 0x05, 0x14, 0x00, 0x51, 0x40, 0x09, 0x45, 0x00, 0x14, + 0x94, 0x00, 0x52, 0x50, 0x02, 0x51, 0x40, 0x09, 0x49, 0x40, 0x09, 0x49, + 0x40, 0x0d, 0xa4, 0xa0, 0x04, 0xa6, 0xd0, 0x02, 0x52, 0x50, 0x02, 0x53, + 0x68, 0x01, 0x29, 0xb4, 0x00, 0x94, 0x94, 0x00, 0x94, 0x94, 0x00, 0xda, + 0x4a, 0x04, 0x25, 0x25, 0x00, 0x25, 0x25, 0x00, 0x25, 0x25, 0x02, 0x1b, + 0x45, 0x00, 0x25, 0x36, 0x81, 0x05, 0x21, 0xa0, 0x06, 0xd1, 0x40, 0x86, + 0xd2, 0x50, 0x02, 0x52, 0x50, 0x04, 0x9d, 0xa9, 0x2a, 0x90, 0x98, 0x52, + 0x53, 0x24, 0x28, 0xa0, 0x41, 0x49, 0x40, 0xc2, 0x8a, 0x04, 0x25, 0x25, + 0x30, 0x12, 0x92, 0x90, 0x85, 0xa4, 0xa4, 0x02, 0x51, 0x48, 0x0e, 0x62, + 0x96, 0xad, 0x9d, 0x21, 0x4a, 0x33, 0xde, 0x96, 0x80, 0x68, 0x68, 0x8f, + 0xb3, 0x53, 0x83, 0xde, 0x41, 0x5d, 0x68, 0xac, 0x97, 0xc4, 0x54, 0xb6, + 0x44, 0xf6, 0xa7, 0x12, 0xd6, 0x88, 0xe9, 0x54, 0x48, 0x52, 0xd0, 0x20, + 0xa2, 0x80, 0x16, 0x8a, 0x00, 0x28, 0xa6, 0x01, 0x4b, 0x48, 0x02, 0x8a, + 0x06, 0x14, 0xb4, 0x00, 0x51, 0x40, 0x05, 0x2d, 0x00, 0x14, 0x50, 0x01, + 0x45, 0x00, 0x14, 0x50, 0x01, 0x4b, 0x40, 0x09, 0x45, 0x00, 0x14, 0x94, + 0x00, 0x52, 0x52, 0x00, 0xa4, 0xa6, 0x02, 0x51, 0x40, 0x09, 0x49, 0x40, + 0x09, 0x49, 0x40, 0x0d, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x06, 0xd2, 0x50, + 0x03, 0x69, 0x28, 0x01, 0x0d, 0x36, 0x80, 0x12, 0x9b, 0x40, 0x09, 0x49, + 0x40, 0x09, 0x4d, 0xa0, 0x42, 0x52, 0x50, 0x02, 0x52, 0x1a, 0x00, 0x4a, + 0x6d, 0x00, 0x25, 0x14, 0x08, 0x6d, 0x25, 0x00, 0x25, 0x14, 0xc4, 0x36, + 0x92, 0x90, 0x84, 0xa4, 0xa6, 0x21, 0x29, 0x29, 0x00, 0xf1, 0x45, 0x31, + 0x05, 0x25, 0x31, 0x05, 0x25, 0x50, 0x85, 0xa4, 0xa4, 0x30, 0xa4, 0xa4, + 0x21, 0x28, 0xaa, 0x01, 0x29, 0x29, 0x12, 0x14, 0x52, 0xb8, 0xc4, 0xa4, + 0xa6, 0x17, 0x39, 0xaa, 0x4a, 0x47, 0x48, 0x52, 0x8a, 0x56, 0x02, 0x7b, + 0x39, 0x3c, 0xab, 0xa8, 0xe4, 0xfe, 0xef, 0x3f, 0xa5, 0x76, 0xeb, 0xf7, + 0x13, 0xfd, 0xd1, 0xfc, 0xab, 0x3f, 0xb6, 0x5c, 0xbe, 0x12, 0x48, 0xb8, + 0x90, 0x56, 0x9a, 0xf4, 0xaa, 0xea, 0x40, 0xb4, 0xb4, 0xc4, 0x14, 0xb4, + 0xc0, 0x28, 0xa4, 0x01, 0x45, 0x00, 0x2d, 0x14, 0x0c, 0x28, 0xa0, 0x42, + 0xd1, 0x40, 0xc2, 0x8a, 0x00, 0x29, 0x68, 0x00, 0xa2, 0x80, 0x0a, 0x5a, + 0x00, 0x28, 0xa0, 0x02, 0x8a, 0x00, 0x28, 0xa0, 0x04, 0xa2, 0x80, 0x0a, + 0x4a, 0x00, 0x29, 0x28, 0x01, 0x28, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, + 0xa0, 0x04, 0xa6, 0xd0, 0x02, 0x52, 0x50, 0x03, 0x69, 0x28, 0x01, 0xb4, + 0x94, 0x00, 0xda, 0x4a, 0x00, 0x6d, 0x25, 0x00, 0x25, 0x36, 0x80, 0x12, + 0x92, 0x81, 0x0d, 0xa2, 0x80, 0x1b, 0x49, 0x40, 0x0d, 0xa4, 0xa0, 0x04, + 0xa2, 0x81, 0x0d, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, 0x91, + 0x29, 0xb4, 0xc0, 0x4a, 0x4a, 0x40, 0x3b, 0xb5, 0x2d, 0x32, 0x44, 0xa2, + 0x81, 0x05, 0x2d, 0x50, 0x84, 0xa2, 0x90, 0x09, 0x49, 0x4c, 0x05, 0xa4, + 0xa6, 0x21, 0x29, 0x29, 0x00, 0x52, 0x54, 0x80, 0x51, 0x40, 0x8e, 0x6f, + 0x63, 0x51, 0xe5, 0x9a, 0xd5, 0x9d, 0x43, 0x71, 0x8a, 0x75, 0x64, 0x03, + 0x4f, 0xdd, 0x3c, 0xf6, 0xae, 0xea, 0xd9, 0xfc, 0xcb, 0x65, 0x6f, 0xc3, + 0xf4, 0x15, 0x1f, 0x6c, 0xbb, 0xfb, 0xa4, 0xc3, 0xad, 0x6a, 0x27, 0xdd, + 0xaa, 0x7b, 0x90, 0x3a, 0x9d, 0x4c, 0x41, 0x45, 0x20, 0x0a, 0x29, 0x80, + 0xb4, 0x50, 0x01, 0x45, 0x20, 0x0a, 0x5a, 0x06, 0x14, 0x50, 0x02, 0xd1, + 0x40, 0x05, 0x14, 0x00, 0xb4, 0x50, 0x01, 0x45, 0x00, 0x14, 0x50, 0x02, + 0xd1, 0x40, 0x05, 0x14, 0x00, 0x51, 0x40, 0x09, 0x49, 0x40, 0x05, 0x25, + 0x00, 0x25, 0x14, 0x00, 0x94, 0x94, 0x00, 0x94, 0x94, 0x80, 0x4a, 0x4a, + 0x60, 0x36, 0x92, 0x80, 0x1b, 0x49, 0x40, 0x0d, 0xa6, 0xd0, 0x02, 0x53, + 0x68, 0x01, 0x29, 0xb4, 0x00, 0x94, 0x94, 0x00, 0x94, 0xda, 0x00, 0x69, + 0xa4, 0x34, 0x08, 0x4a, 0x69, 0xa0, 0x04, 0xa4, 0xa0, 0x04, 0xa4, 0xa0, + 0x42, 0x52, 0x50, 0x02, 0x52, 0x50, 0x21, 0x29, 0x28, 0x01, 0x29, 0xb4, + 0xc0, 0x43, 0x49, 0x48, 0x07, 0x0a, 0x29, 0x92, 0x25, 0x2d, 0x31, 0x05, + 0x25, 0x31, 0x0b, 0x49, 0x40, 0x05, 0x14, 0x84, 0x25, 0x14, 0xc4, 0x25, + 0x25, 0x00, 0x14, 0x94, 0x08, 0x29, 0x31, 0x48, 0x66, 0x16, 0xf1, 0xdc, + 0x53, 0xc4, 0x8b, 0xf8, 0x55, 0x33, 0xa4, 0x3e, 0x43, 0x4d, 0xd8, 0xb4, + 0xae, 0x03, 0x4c, 0x60, 0xd7, 0x55, 0xa2, 0x36, 0xed, 0x34, 0x7f, 0xbe, + 0xd5, 0x9b, 0xf8, 0x91, 0x4b, 0xe1, 0x2f, 0x76, 0xad, 0x38, 0x0f, 0xc9, + 0x4d, 0xee, 0x49, 0x2d, 0x2d, 0x02, 0x0a, 0x29, 0x80, 0xb4, 0x52, 0x00, + 0xa2, 0x98, 0x05, 0x2d, 0x00, 0x14, 0xb4, 0x0c, 0x4a, 0x5a, 0x40, 0x14, + 0x50, 0x02, 0xd1, 0x40, 0x05, 0x2d, 0x00, 0x14, 0x50, 0x01, 0x4b, 0x40, + 0x05, 0x14, 0x00, 0x51, 0x40, 0x05, 0x25, 0x00, 0x14, 0x94, 0x00, 0x51, + 0x40, 0x09, 0x49, 0x40, 0x09, 0x49, 0x40, 0x05, 0x25, 0x00, 0x36, 0x92, + 0x90, 0x09, 0x4d, 0xa6, 0x03, 0x69, 0x28, 0x01, 0xb4, 0xd3, 0x40, 0x0d, + 0xa6, 0xd0, 0x02, 0x52, 0x50, 0x03, 0x69, 0x28, 0x01, 0x29, 0xb4, 0x00, + 0xd3, 0x4d, 0xa0, 0x04, 0xa4, 0xa0, 0x42, 0x53, 0x68, 0x00, 0xa4, 0xa0, + 0x04, 0xa6, 0xd0, 0x21, 0x29, 0x28, 0x01, 0x29, 0x28, 0x01, 0x29, 0x28, + 0x24, 0x4a, 0x4a, 0x00, 0x51, 0x4b, 0x4c, 0x42, 0x51, 0x4c, 0x41, 0x45, + 0x00, 0x2d, 0x25, 0x04, 0x89, 0x45, 0x30, 0x0a, 0x4a, 0x04, 0x25, 0x14, + 0x00, 0x94, 0x51, 0x70, 0x12, 0x8a, 0x04, 0x73, 0xa4, 0xd2, 0x66, 0x9d, + 0x8e, 0xa0, 0xcd, 0x2e, 0xef, 0x7a, 0x90, 0x1f, 0x9a, 0xe8, 0xbc, 0x37, + 0x26, 0x60, 0x74, 0xcf, 0x40, 0x4f, 0xfe, 0x3d, 0x59, 0x4b, 0xa1, 0x6b, + 0x63, 0x62, 0xaf, 0x59, 0x9c, 0xa5, 0x5c, 0x88, 0x2c, 0xd2, 0xd3, 0x10, + 0x51, 0x48, 0x05, 0xa2, 0x80, 0x0a, 0x5a, 0x06, 0x14, 0x50, 0x20, 0xa5, + 0xa0, 0x61, 0x45, 0x00, 0x2d, 0x14, 0x00, 0x51, 0x40, 0x0b, 0x45, 0x00, + 0x14, 0xb4, 0x00, 0x51, 0x40, 0x05, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, + 0x00, 0x94, 0x52, 0x00, 0xa4, 0xa6, 0x01, 0x49, 0x48, 0x02, 0x92, 0x80, + 0x12, 0x92, 0x98, 0x09, 0x4d, 0xa0, 0x04, 0xa6, 0xd0, 0x02, 0x53, 0x4d, + 0x20, 0x1a, 0x69, 0xb4, 0xc0, 0x61, 0xa4, 0xa0, 0x06, 0xd3, 0x68, 0x01, + 0x29, 0xb4, 0x80, 0x6d, 0x36, 0x80, 0x12, 0x92, 0x80, 0x1b, 0x45, 0x30, + 0x12, 0x92, 0x80, 0x12, 0x92, 0x81, 0x09, 0x4d, 0xa4, 0x02, 0x52, 0x53, + 0x01, 0x29, 0x28, 0x24, 0x6d, 0x25, 0x00, 0x25, 0x25, 0x02, 0x0a, 0x75, + 0x02, 0x12, 0x8a, 0x60, 0x14, 0x50, 0x21, 0x68, 0xa6, 0x21, 0x28, 0xa6, + 0x02, 0x51, 0x40, 0x84, 0xa2, 0x90, 0x84, 0xa2, 0x80, 0x12, 0x8a, 0x62, + 0x39, 0xb6, 0xa6, 0xd5, 0x33, 0xa8, 0x5a, 0x5c, 0xd6, 0x7a, 0x85, 0xc7, + 0x56, 0xcf, 0x86, 0x24, 0xff, 0x00, 0x4a, 0x91, 0x7d, 0x42, 0x8f, 0xd6, + 0xa2, 0x65, 0x44, 0xe9, 0x2a, 0xdd, 0x97, 0x71, 0x57, 0x32, 0x11, 0x76, + 0x8a, 0x00, 0x29, 0x68, 0x00, 0xa2, 0x90, 0x05, 0x2d, 0x03, 0x0a, 0x5a, + 0x00, 0x28, 0xa0, 0x02, 0x96, 0x80, 0x0a, 0x28, 0x01, 0x68, 0xa0, 0x05, + 0xa2, 0x80, 0x0a, 0x5a, 0x00, 0x4a, 0x5a, 0x00, 0x28, 0xa0, 0x02, 0x8a, + 0x06, 0x14, 0x94, 0x00, 0x52, 0x50, 0x01, 0x45, 0x20, 0x12, 0x8a, 0x00, + 0x4a, 0x28, 0x10, 0x94, 0x94, 0x00, 0x94, 0xda, 0x00, 0x4a, 0x6d, 0x30, + 0x12, 0x9a, 0x68, 0x01, 0x86, 0x9a, 0x68, 0x01, 0xa6, 0x9b, 0x40, 0x0d, + 0x34, 0xda, 0x90, 0x1b, 0x4d, 0xa0, 0x06, 0xd3, 0x68, 0x01, 0x29, 0x28, + 0x00, 0xa6, 0xd3, 0x01, 0x29, 0x28, 0x01, 0x28, 0xdb, 0x40, 0x06, 0xda, + 0x4d, 0xb4, 0x08, 0x42, 0x2a, 0x33, 0x4c, 0x43, 0x68, 0xa4, 0x02, 0x52, + 0x53, 0x10, 0x94, 0xda, 0x00, 0x51, 0x4b, 0x40, 0x84, 0xa2, 0x82, 0x42, + 0x8a, 0xa0, 0x16, 0x8a, 0x62, 0x0a, 0x4a, 0x04, 0x14, 0x50, 0x02, 0x51, + 0x48, 0x04, 0xa2, 0x98, 0x84, 0xa2, 0x81, 0x1c, 0xd9, 0xa6, 0xd6, 0x96, + 0xb1, 0xd2, 0x14, 0x56, 0x4d, 0x8c, 0x5a, 0xd2, 0xd0, 0x5f, 0x6e, 0xad, + 0x07, 0xbb, 0x8a, 0x8a, 0x9a, 0xa2, 0xa0, 0x75, 0xc3, 0xa5, 0x58, 0xb4, + 0x3f, 0xbc, 0xaa, 0x96, 0xc4, 0xa3, 0x43, 0xb5, 0x14, 0x21, 0x0b, 0x45, + 0x00, 0x14, 0x50, 0x31, 0x68, 0xa4, 0x20, 0xa5, 0xa0, 0x61, 0x45, 0x00, + 0x2d, 0x14, 0x00, 0xb4, 0x50, 0x02, 0xd1, 0x40, 0x05, 0x2d, 0x00, 0x14, + 0x50, 0x01, 0x4b, 0x40, 0x09, 0x45, 0x00, 0x14, 0x50, 0x30, 0xa2, 0x80, + 0x0a, 0x4a, 0x40, 0x14, 0x94, 0x00, 0x52, 0x50, 0x20, 0xa4, 0xa0, 0x62, + 0x52, 0x50, 0x20, 0xa4, 0xa0, 0x06, 0xd2, 0x50, 0x03, 0x69, 0xa6, 0x98, + 0x0c, 0x34, 0xce, 0xf8, 0xf5, 0xa0, 0x08, 0x16, 0x5d, 0xc7, 0x14, 0xea, + 0x4c, 0x06, 0xd3, 0x69, 0x00, 0xda, 0x6d, 0x00, 0x36, 0x9b, 0x40, 0x09, + 0xba, 0x96, 0x80, 0x0c, 0x66, 0x93, 0x14, 0xc0, 0x4a, 0x6e, 0x68, 0x10, + 0x99, 0xa3, 0x75, 0x2b, 0x80, 0xdd, 0xe2, 0x93, 0x7d, 0x3b, 0x80, 0xc3, + 0x20, 0xa4, 0x6a, 0x2e, 0x21, 0x94, 0x50, 0x31, 0x28, 0xa6, 0x21, 0xb4, + 0x94, 0x08, 0x4a, 0x5a, 0x04, 0x14, 0x53, 0x10, 0x52, 0xd2, 0x10, 0x51, + 0x54, 0x48, 0x51, 0x40, 0x09, 0x45, 0x30, 0x12, 0x96, 0xa4, 0x04, 0xa4, + 0xa6, 0x20, 0xa4, 0xa1, 0x01, 0xce, 0x37, 0x5e, 0x29, 0xb8, 0xad, 0xeb, + 0x7c, 0x4c, 0xe9, 0x12, 0x96, 0xb0, 0x00, 0xab, 0x36, 0x12, 0x79, 0x57, + 0x90, 0xc9, 0xfd, 0xd3, 0x9f, 0xd2, 0xa6, 0x7b, 0x15, 0x0d, 0xce, 0xe1, + 0x7e, 0xe2, 0x7f, 0xba, 0x3f, 0x95, 0x4d, 0x07, 0x12, 0x8a, 0x7f, 0x60, + 0x9e, 0xa6, 0x90, 0xe9, 0x4b, 0x42, 0x10, 0x51, 0x40, 0x0b, 0x45, 0x00, + 0x14, 0x50, 0x31, 0x68, 0xa4, 0x01, 0x4b, 0x40, 0x05, 0x2d, 0x00, 0x14, + 0x50, 0x02, 0xd1, 0x40, 0x0b, 0x45, 0x00, 0x14, 0x50, 0x02, 0xd1, 0x40, + 0x05, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, 0x0c, 0x4a, 0x29, 0x00, 0x94, + 0x50, 0x01, 0x4d, 0xa0, 0x02, 0x8a, 0x04, 0x25, 0x25, 0x00, 0x25, 0x25, + 0x30, 0x0a, 0x69, 0xa0, 0x06, 0xd3, 0x71, 0x9a, 0x00, 0x5f, 0x28, 0xfa, + 0x54, 0x32, 0xdb, 0x4a, 0x4a, 0xed, 0x1d, 0x29, 0xa0, 0x21, 0x5b, 0x09, + 0x95, 0xf7, 0x71, 0xf9, 0xd4, 0x8d, 0x1e, 0x3a, 0xd2, 0x60, 0x42, 0xd5, + 0x19, 0xa4, 0x02, 0x1a, 0x6d, 0x48, 0x0c, 0x34, 0xc3, 0x4c, 0x08, 0x9d, + 0xb1, 0x53, 0x7f, 0x0d, 0x00, 0x34, 0x1a, 0x5c, 0xd3, 0x01, 0x8e, 0xf8, + 0x15, 0x4c, 0xde, 0x0d, 0xf8, 0xe9, 0x45, 0x84, 0x3f, 0xcd, 0xa8, 0xfc, + 0xef, 0x9f, 0x19, 0xa4, 0x21, 0xcc, 0x78, 0xa8, 0x43, 0xf3, 0xcd, 0x21, + 0x11, 0xca, 0x70, 0xe1, 0xbd, 0x2a, 0xef, 0xf0, 0x0f, 0xa5, 0x30, 0x19, + 0x45, 0x31, 0x89, 0x49, 0x4c, 0x02, 0x92, 0x81, 0x0d, 0xa2, 0x81, 0x0b, + 0x45, 0x32, 0x45, 0xa2, 0x98, 0x05, 0x2d, 0x21, 0x09, 0x4b, 0x4c, 0x42, + 0x51, 0x40, 0x84, 0xa2, 0x80, 0x0a, 0x4a, 0x00, 0x4a, 0x29, 0x81, 0xce, + 0x51, 0xb4, 0xd5, 0xb6, 0x74, 0x86, 0xda, 0x36, 0xd6, 0x63, 0x48, 0x00, + 0xa3, 0xee, 0xe4, 0x8f, 0x4a, 0x96, 0x38, 0xee, 0x77, 0x96, 0xcc, 0x1e, + 0xdd, 0x48, 0x3e, 0xdf, 0xa0, 0xa9, 0x97, 0x86, 0x14, 0xd7, 0xc0, 0x4b, + 0xf8, 0x8d, 0x44, 0xfb, 0xb4, 0xea, 0x48, 0x42, 0xd1, 0x4c, 0x02, 0x8a, + 0x00, 0x29, 0x68, 0x00, 0xa2, 0x90, 0xc5, 0xa2, 0x80, 0x0a, 0x28, 0x01, + 0x68, 0xa0, 0x05, 0xa2, 0x80, 0x16, 0x8a, 0x00, 0x29, 0x68, 0x00, 0xa2, + 0x80, 0x0a, 0x28, 0x18, 0x51, 0x40, 0x05, 0x14, 0x80, 0x29, 0x28, 0x00, + 0xa4, 0xa0, 0x02, 0x92, 0x90, 0x05, 0x25, 0x31, 0x05, 0x25, 0x00, 0x25, + 0x25, 0x00, 0x25, 0x25, 0x30, 0x1b, 0x42, 0x7d, 0xf1, 0x40, 0x17, 0x14, + 0xe0, 0x53, 0x5e, 0x5a, 0x00, 0xa9, 0x2c, 0x84, 0xd5, 0x66, 0xa0, 0x08, + 0x1e, 0xa3, 0xa4, 0x02, 0x53, 0x49, 0xa4, 0x04, 0x66, 0x9a, 0x68, 0x02, + 0x19, 0x7a, 0x54, 0x90, 0xbe, 0x62, 0xa1, 0x80, 0x77, 0xa1, 0xce, 0x05, + 0x50, 0x15, 0x5a, 0x5d, 0xdc, 0x54, 0x12, 0x28, 0x54, 0x26, 0x80, 0x14, + 0xfc, 0xe9, 0xc5, 0x34, 0x45, 0xce, 0x6a, 0x09, 0x15, 0x81, 0xc8, 0xa4, + 0xef, 0x40, 0x81, 0x86, 0xe5, 0x23, 0xbd, 0x4e, 0xad, 0x8e, 0x0d, 0x03, + 0x48, 0x43, 0x49, 0x54, 0x30, 0xa2, 0x81, 0x09, 0x49, 0x40, 0x09, 0x49, + 0x40, 0x82, 0x96, 0x99, 0x2c, 0x29, 0x6a, 0x84, 0x14, 0xb4, 0xc4, 0x14, + 0x50, 0x20, 0xa4, 0xa0, 0x41, 0x45, 0x03, 0x12, 0x8a, 0x42, 0x12, 0x8c, + 0xd1, 0xb8, 0x18, 0x0b, 0xef, 0x4e, 0xa0, 0xee, 0x12, 0x99, 0x83, 0x48, + 0x04, 0xa4, 0xaa, 0xe8, 0x66, 0xb7, 0x3b, 0x3d, 0x0e, 0x4f, 0x37, 0x4b, + 0x53, 0xfe, 0xdb, 0x55, 0xea, 0x54, 0xd7, 0xb8, 0x29, 0x7c, 0x46, 0x9c, + 0x07, 0xe4, 0xa9, 0x2a, 0x50, 0x82, 0x96, 0x98, 0x05, 0x2d, 0x00, 0x14, + 0x50, 0x01, 0x4b, 0x48, 0x61, 0x45, 0x00, 0x14, 0xb4, 0xc0, 0x28, 0xa4, + 0x03, 0xa8, 0xa0, 0x02, 0x8a, 0x00, 0x5a, 0x28, 0x00, 0xa2, 0x80, 0x0a, + 0x28, 0x01, 0x69, 0x29, 0x00, 0x51, 0x4c, 0x61, 0x49, 0x40, 0x05, 0x25, + 0x20, 0x0a, 0x28, 0x01, 0x28, 0xa0, 0x04, 0xa2, 0x80, 0x1b, 0x49, 0x40, + 0x84, 0xa6, 0x93, 0x4c, 0x05, 0x48, 0x99, 0xea, 0x65, 0x80, 0x2d, 0x00, + 0x29, 0xa8, 0x9a, 0x80, 0x2b, 0xbd, 0x42, 0x68, 0x02, 0x09, 0x2a, 0x23, + 0x48, 0x06, 0xd3, 0x0d, 0x48, 0x0d, 0xa6, 0x1a, 0x60, 0x43, 0x2f, 0x4a, + 0x4b, 0x57, 0xea, 0x3d, 0x28, 0x60, 0x4a, 0x4d, 0x38, 0xfc, 0xeb, 0x54, + 0x06, 0x63, 0x26, 0xd6, 0xa9, 0x67, 0x1e, 0x64, 0x25, 0x47, 0x71, 0x43, + 0xdc, 0x43, 0x2d, 0xd0, 0xc7, 0x16, 0xd6, 0x39, 0xe4, 0x9a, 0x5f, 0x30, + 0x54, 0x00, 0xc3, 0x32, 0xd3, 0x37, 0xb3, 0x74, 0xa0, 0x40, 0x1d, 0xd1, + 0xd7, 0x7f, 0x4c, 0xd5, 0xae, 0xb4, 0x0c, 0x43, 0x49, 0x54, 0x01, 0x45, + 0x02, 0x12, 0x92, 0x90, 0x84, 0xa4, 0xaa, 0x01, 0x28, 0xcd, 0x04, 0x8b, + 0x9a, 0x75, 0x32, 0x42, 0x96, 0xa8, 0x02, 0x8a, 0x42, 0x0a, 0x4a, 0x04, + 0x14, 0x53, 0x00, 0xa2, 0x81, 0x09, 0x45, 0x20, 0x39, 0xfc, 0xd2, 0x83, + 0x49, 0x9d, 0xd1, 0x1d, 0x9a, 0x61, 0xeb, 0x49, 0x14, 0x34, 0x9a, 0x07, + 0x4a, 0xb4, 0x62, 0xce, 0xa3, 0xc2, 0xf2, 0xee, 0xb5, 0x68, 0xff, 0x00, + 0xbb, 0x96, 0xff, 0x00, 0xc7, 0xab, 0x66, 0xa6, 0x97, 0xc2, 0x13, 0xf8, + 0x8b, 0xd6, 0x87, 0x29, 0x56, 0x29, 0x21, 0x31, 0x68, 0xa6, 0x01, 0x4b, + 0x40, 0x05, 0x14, 0x0c, 0x28, 0xa0, 0x05, 0xa2, 0x80, 0x0a, 0x28, 0x01, + 0x69, 0x69, 0x00, 0x52, 0xd0, 0x01, 0x4b, 0x40, 0x05, 0x14, 0x00, 0x51, + 0x40, 0x0b, 0x45, 0x20, 0x0a, 0x28, 0x18, 0x52, 0x53, 0x00, 0xa4, 0xa0, + 0x61, 0x45, 0x20, 0x0a, 0x28, 0x10, 0x94, 0x94, 0x00, 0x94, 0x94, 0x00, + 0x94, 0x94, 0x08, 0x4a, 0x86, 0x5a, 0x68, 0x0b, 0x96, 0xaf, 0xbe, 0x2a, + 0x94, 0xd1, 0x10, 0x23, 0x6a, 0x85, 0xa8, 0x02, 0x07, 0xa8, 0x1a, 0x80, + 0x20, 0x97, 0xa5, 0x40, 0x4d, 0x4b, 0x01, 0x84, 0xd3, 0x73, 0x48, 0x63, + 0x69, 0xa4, 0xd0, 0x04, 0x0e, 0xd5, 0x52, 0xda, 0x5d, 0xb3, 0xed, 0xcf, + 0x5e, 0x29, 0xbd, 0x80, 0xb8, 0xd2, 0x2f, 0x72, 0x2a, 0x2f, 0xb7, 0x43, + 0x1f, 0xde, 0x6a, 0x40, 0x67, 0xdd, 0xea, 0x11, 0x6e, 0xf9, 0x7f, 0x95, + 0x3a, 0xd6, 0xfa, 0x39, 0x46, 0xd2, 0x7e, 0x61, 0x4a, 0x57, 0x11, 0x66, + 0x47, 0xfd, 0xd9, 0xe7, 0x1c, 0x53, 0x3c, 0xa1, 0x8c, 0xd2, 0xb8, 0x86, + 0x05, 0x19, 0xe9, 0x52, 0x6d, 0x2b, 0xcd, 0x51, 0x23, 0x2e, 0x33, 0xe5, + 0xd3, 0xe0, 0x98, 0x3a, 0x66, 0xa5, 0x8d, 0x13, 0x75, 0xa6, 0xd5, 0xad, + 0x86, 0x14, 0x50, 0x02, 0x52, 0x1a, 0x04, 0x26, 0x69, 0xb9, 0xa1, 0x08, + 0x4c, 0xd2, 0xd5, 0x5c, 0x41, 0x9a, 0x5c, 0xd0, 0x48, 0xb9, 0xa5, 0xa6, + 0x21, 0x68, 0xa6, 0x20, 0xa2, 0x98, 0x05, 0x14, 0x00, 0x94, 0x52, 0x24, + 0x28, 0xa0, 0x67, 0x39, 0xd6, 0x9d, 0xf3, 0x55, 0x58, 0xe9, 0x1f, 0xb4, + 0xf7, 0xa3, 0x61, 0x35, 0x08, 0xab, 0x89, 0xe5, 0xe0, 0xd3, 0x31, 0x83, + 0x55, 0x62, 0x4d, 0xdf, 0x0a, 0x3f, 0xfa, 0x4c, 0xc9, 0xea, 0xa3, 0xff, + 0x00, 0x42, 0xae, 0x92, 0x95, 0x25, 0xba, 0x09, 0x96, 0xec, 0xcd, 0x5c, + 0xa9, 0x00, 0xa2, 0x98, 0x82, 0x8a, 0x00, 0x29, 0x68, 0x18, 0x51, 0x48, + 0x02, 0x96, 0x80, 0x0a, 0x5a, 0x00, 0x5a, 0x29, 0x80, 0x52, 0xd2, 0x00, + 0xa5, 0xa0, 0x02, 0x8a, 0x00, 0x28, 0xa0, 0x05, 0xa2, 0x81, 0x85, 0x14, + 0x80, 0x29, 0x28, 0x00, 0xa2, 0x81, 0x89, 0x45, 0x02, 0x0a, 0x4a, 0x40, + 0x14, 0x94, 0x00, 0x53, 0x69, 0x80, 0x94, 0x94, 0x00, 0xda, 0x86, 0x6e, + 0x94, 0x08, 0x7d, 0x8c, 0x98, 0x97, 0x6f, 0xaf, 0x15, 0xa1, 0x4d, 0x03, + 0x23, 0x6a, 0x85, 0xa9, 0x81, 0x5d, 0xea, 0x07, 0xa4, 0x04, 0x32, 0x74, + 0xaa, 0x84, 0xd4, 0x81, 0x19, 0x6a, 0x89, 0xee, 0x23, 0x5e, 0xae, 0x3f, + 0x3a, 0x91, 0x95, 0xa4, 0xd4, 0xa0, 0x4e, 0xad, 0x55, 0x24, 0xd6, 0x93, + 0xf8, 0x56, 0xab, 0x95, 0xb1, 0x14, 0xe5, 0xd5, 0xe4, 0x6f, 0xba, 0xa0, + 0x55, 0x46, 0xbb, 0x90, 0xb6, 0x7a, 0x53, 0x51, 0x01, 0x8d, 0x3c, 0x8d, + 0xd5, 0xcd, 0x46, 0x49, 0xa6, 0x02, 0x52, 0x86, 0x2a, 0x73, 0x45, 0x80, + 0xd3, 0x4b, 0xcf, 0x3a, 0x06, 0x07, 0xef, 0x55, 0xe5, 0x62, 0x63, 0xac, + 0xb6, 0x18, 0x80, 0xe0, 0xd4, 0xbe, 0x68, 0xc5, 0x16, 0x64, 0x91, 0x33, + 0x13, 0x50, 0xdb, 0x9c, 0x4a, 0x57, 0xf1, 0xaa, 0xe8, 0x4a, 0x2f, 0x25, + 0x21, 0xa1, 0x6c, 0x31, 0x28, 0xa2, 0xc0, 0x25, 0x25, 0x30, 0x1a, 0x4d, + 0x37, 0x34, 0x80, 0x4c, 0xd1, 0x9a, 0x64, 0x8b, 0x46, 0x6a, 0x84, 0x00, + 0xd3, 0xb3, 0x4c, 0x07, 0x66, 0x96, 0x82, 0x45, 0xa2, 0x98, 0x82, 0x92, + 0x81, 0x05, 0x14, 0x00, 0x51, 0x45, 0x80, 0xe7, 0x3a, 0x51, 0xbc, 0x8a, + 0xa6, 0xce, 0x91, 0xde, 0x69, 0xa6, 0x99, 0x18, 0xd2, 0x40, 0x33, 0x71, + 0xa3, 0x34, 0x80, 0xd5, 0xf0, 0xe4, 0x9b, 0x35, 0x58, 0x47, 0xf7, 0x98, + 0x0a, 0xec, 0x3b, 0x52, 0xa7, 0xf1, 0x30, 0xa9, 0xd0, 0xb1, 0x6a, 0x7e, + 0x7a, 0xbd, 0x47, 0x50, 0x0a, 0x29, 0x88, 0x5a, 0x29, 0x00, 0x51, 0x40, + 0x05, 0x2d, 0x21, 0x85, 0x2d, 0x00, 0x14, 0xb4, 0x00, 0x52, 0xd0, 0x02, + 0xd1, 0x40, 0x05, 0x14, 0x00, 0x52, 0xd0, 0x01, 0x45, 0x00, 0x2d, 0x25, + 0x20, 0x16, 0x8a, 0x06, 0x14, 0x94, 0x00, 0x52, 0x50, 0x30, 0xa2, 0x90, + 0x09, 0x45, 0x00, 0x14, 0x94, 0xc0, 0x4a, 0x4a, 0x04, 0x25, 0x36, 0x80, + 0x1b, 0x9a, 0x86, 0x63, 0xf2, 0xd3, 0x11, 0x02, 0x3e, 0xc7, 0x07, 0xd2, + 0xb6, 0x50, 0xee, 0x40, 0x68, 0xea, 0x03, 0x5a, 0xa0, 0x6a, 0x60, 0x40, + 0xf5, 0x5d, 0xea, 0x40, 0x8d, 0xfa, 0x56, 0x73, 0xb7, 0x3d, 0x69, 0x01, + 0x85, 0xab, 0xea, 0x5c, 0x6c, 0x85, 0xfe, 0xb5, 0x90, 0x65, 0x76, 0xea, + 0xd5, 0x62, 0x43, 0x73, 0x49, 0x9a, 0x43, 0x0a, 0x4c, 0xd0, 0x02, 0xd2, + 0x50, 0x20, 0xa2, 0x80, 0x00, 0x7d, 0xeb, 0x5a, 0xca, 0xe8, 0x3a, 0x6c, + 0xfe, 0x2c, 0xd4, 0x4c, 0x65, 0xce, 0xd5, 0x2a, 0xc4, 0x2a, 0x6e, 0x48, + 0xbe, 0x58, 0xaa, 0x73, 0x83, 0x1c, 0xc8, 0xfd, 0xb3, 0xcd, 0x52, 0xd8, + 0x0b, 0x4a, 0xc7, 0x14, 0x67, 0x34, 0x90, 0xc3, 0x34, 0x55, 0x5c, 0x04, + 0x34, 0x94, 0x84, 0x21, 0xa8, 0xe8, 0x01, 0x33, 0x4b, 0x54, 0x21, 0x29, + 0x73, 0x4c, 0x40, 0x29, 0xf4, 0x5c, 0x91, 0xc2, 0x9d, 0x4c, 0x42, 0xd1, + 0x4c, 0x90, 0xa2, 0x90, 0x05, 0x25, 0x50, 0x05, 0x25, 0x24, 0x23, 0x9c, + 0xcd, 0x25, 0x5a, 0x48, 0xea, 0x41, 0x49, 0x48, 0x02, 0x96, 0x86, 0x80, + 0xb7, 0xa5, 0xbf, 0x97, 0xa8, 0xc0, 0xde, 0x8d, 0x9f, 0xd0, 0xd7, 0x74, + 0xbc, 0xc6, 0x87, 0xd5, 0x47, 0xf2, 0xa8, 0x87, 0xf1, 0x02, 0x7b, 0x12, + 0xc1, 0xfe, 0xb0, 0x56, 0x88, 0xe9, 0x47, 0x50, 0x0a, 0x5a, 0x04, 0x14, + 0x50, 0x01, 0x45, 0x00, 0x14, 0xb4, 0x0c, 0x29, 0x68, 0x00, 0xa5, 0xa4, + 0x02, 0xd1, 0x40, 0x0b, 0x45, 0x00, 0x14, 0x50, 0x01, 0x45, 0x00, 0x14, + 0xb4, 0x00, 0x51, 0x40, 0xc2, 0x8a, 0x00, 0x29, 0x29, 0x0c, 0x29, 0x29, + 0x00, 0x51, 0x40, 0x05, 0x25, 0x00, 0x14, 0x94, 0x00, 0x94, 0x99, 0xa6, + 0x21, 0xa4, 0xd4, 0x65, 0xe9, 0x01, 0x13, 0x4a, 0x05, 0x40, 0xf2, 0xe6, + 0x98, 0x10, 0x96, 0xad, 0x5d, 0x3a, 0x6d, 0xf1, 0x6d, 0xcf, 0x23, 0x9a, + 0x43, 0x2c, 0xb5, 0x40, 0xd5, 0x44, 0x90, 0xbd, 0x56, 0x92, 0x80, 0x21, + 0x93, 0xee, 0xd7, 0x35, 0xaa, 0xdc, 0xb4, 0x28, 0x48, 0x26, 0x9c, 0x50, + 0x33, 0x9c, 0x63, 0x97, 0x24, 0xd0, 0x0d, 0x30, 0x16, 0x8a, 0x90, 0x0a, + 0x29, 0x80, 0x52, 0x52, 0x10, 0x51, 0x40, 0xc2, 0x9c, 0xad, 0xb4, 0xe4, + 0x50, 0xc0, 0xd9, 0xb4, 0xbb, 0x59, 0xd3, 0x07, 0xef, 0xd5, 0xd5, 0x6e, + 0x2b, 0x9c, 0x07, 0x8e, 0x45, 0x24, 0x91, 0x6e, 0x5a, 0xd1, 0x09, 0x82, + 0x47, 0xf2, 0xf2, 0x69, 0x7c, 0xae, 0x3e, 0xf5, 0x52, 0x11, 0x17, 0x7a, + 0x28, 0x18, 0x52, 0x52, 0x10, 0xda, 0x61, 0xa4, 0x02, 0x51, 0x4c, 0x42, + 0x52, 0xd5, 0x80, 0x53, 0xb3, 0x45, 0x89, 0x1c, 0x29, 0xc2, 0x82, 0x07, + 0x51, 0x54, 0x20, 0xa2, 0x81, 0x85, 0x14, 0x08, 0x28, 0xa4, 0x07, 0x33, + 0x4b, 0x4d, 0x9d, 0x22, 0xf6, 0xa6, 0xd3, 0x01, 0x73, 0x4b, 0xda, 0x90, + 0x0e, 0x56, 0xda, 0x77, 0x0e, 0xd9, 0xfe, 0x55, 0xe8, 0x16, 0xe7, 0x75, + 0xba, 0x1f, 0x61, 0xfc, 0x85, 0x4a, 0xfe, 0x20, 0x3f, 0x84, 0x99, 0x3e, + 0xf0, 0xad, 0x15, 0xfb, 0xb4, 0xde, 0xe0, 0x3a, 0x8a, 0x62, 0x0a, 0x5a, + 0x40, 0x14, 0x50, 0x01, 0x45, 0x03, 0x0a, 0x5a, 0x40, 0x14, 0xb4, 0x00, + 0x52, 0xd0, 0x01, 0x45, 0x00, 0x2d, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, + 0x0c, 0x4a, 0x29, 0x0c, 0x33, 0x49, 0x9a, 0x40, 0x19, 0xa3, 0x34, 0x86, + 0x14, 0x94, 0xc0, 0x29, 0x68, 0x00, 0xa4, 0xa4, 0x21, 0x29, 0x29, 0x80, + 0x99, 0xa6, 0x3b, 0x60, 0x53, 0x11, 0x55, 0xee, 0x2a, 0xbb, 0x4d, 0xef, + 0x52, 0x02, 0x67, 0x34, 0xc3, 0x4c, 0x64, 0x64, 0xd5, 0xbd, 0x36, 0x6d, + 0xb7, 0x20, 0x7f, 0x7a, 0xa5, 0x94, 0x6c, 0xf6, 0xa8, 0x5e, 0xb4, 0x33, + 0x2b, 0xb5, 0x57, 0x92, 0x80, 0x21, 0x6a, 0xe4, 0xf5, 0xcf, 0xf5, 0x67, + 0xf1, 0xaa, 0x80, 0xa4, 0x60, 0x9a, 0x4a, 0x43, 0x1e, 0x0d, 0x2d, 0x20, + 0x0a, 0x4a, 0x77, 0x00, 0xa2, 0x90, 0x84, 0xcd, 0x1b, 0xa8, 0x18, 0xdc, + 0xd1, 0x9a, 0x00, 0xb3, 0x63, 0x29, 0x49, 0xc7, 0xbd, 0x6b, 0xa4, 0xbc, + 0x72, 0x6b, 0x26, 0x03, 0xd6, 0xee, 0x21, 0xc6, 0xf3, 0x50, 0x49, 0x7c, + 0xe7, 0xa3, 0xe2, 0x9c, 0x22, 0x04, 0x4b, 0x34, 0xb2, 0x7f, 0xcb, 0x43, + 0x53, 0x45, 0x33, 0x35, 0xbc, 0x8a, 0x4f, 0xcc, 0x06, 0x73, 0xf8, 0xd5, + 0xc8, 0x0b, 0x29, 0xf7, 0x29, 0xd5, 0x02, 0x0c, 0xd2, 0x50, 0x02, 0x52, + 0x55, 0x12, 0x36, 0x92, 0x98, 0x05, 0x2d, 0x31, 0x05, 0x2d, 0x02, 0x16, + 0x9c, 0x29, 0xa2, 0x47, 0x52, 0xd5, 0x08, 0x28, 0xa4, 0x26, 0x14, 0x50, + 0x02, 0x51, 0x40, 0x1c, 0xd5, 0x2d, 0x51, 0xd0, 0x26, 0x33, 0x45, 0x26, + 0x86, 0x14, 0xa2, 0x86, 0x80, 0x5f, 0xe1, 0x35, 0xdb, 0xe8, 0xb2, 0xf9, + 0xba, 0x72, 0x9f, 0xf6, 0x8d, 0x45, 0xbd, 0xe4, 0x3f, 0xb0, 0x68, 0x56, + 0x8c, 0x47, 0x2b, 0x55, 0x3d, 0xc9, 0x43, 0xe8, 0xa4, 0x01, 0x45, 0x00, + 0x14, 0xb4, 0x00, 0x51, 0x48, 0x61, 0x4b, 0x40, 0x05, 0x14, 0xc0, 0x5a, + 0x29, 0x00, 0x52, 0xd0, 0x02, 0x52, 0xd0, 0x01, 0x49, 0x40, 0x09, 0xb8, + 0x51, 0x9a, 0x91, 0x8d, 0x2d, 0x50, 0x4f, 0x78, 0x90, 0xae, 0x58, 0xd0, + 0x33, 0x3e, 0x1d, 0x7a, 0x39, 0x6e, 0x96, 0x20, 0x38, 0x26, 0xb5, 0x83, + 0x64, 0x56, 0x6f, 0x49, 0x58, 0xd3, 0x97, 0x41, 0x73, 0x4b, 0x4c, 0x90, + 0xa2, 0xa8, 0x41, 0x45, 0x00, 0x14, 0x94, 0x00, 0x99, 0xa6, 0xe6, 0x98, + 0x86, 0x16, 0xe6, 0xa2, 0x94, 0x6f, 0x18, 0xcd, 0x51, 0x25, 0x71, 0x0a, + 0x8f, 0x7a, 0x43, 0x12, 0x7a, 0x52, 0x01, 0x70, 0x29, 0xaf, 0xd2, 0x80, + 0x29, 0xb9, 0xe6, 0x9a, 0x18, 0xab, 0x66, 0xa6, 0x45, 0xa3, 0xa3, 0xb7, + 0x93, 0xcd, 0x84, 0x30, 0xfa, 0x52, 0xbd, 0x38, 0x6c, 0x4b, 0x2b, 0x49, + 0x55, 0xde, 0xa8, 0x44, 0x0d, 0x5c, 0xb6, 0xbc, 0x3e, 0x56, 0xff, 0x00, + 0x77, 0x34, 0xe0, 0x29, 0x1c, 0xf5, 0x14, 0xc6, 0x02, 0x9f, 0x52, 0x01, + 0x9a, 0x6e, 0x68, 0xb0, 0x5c, 0x4c, 0xd1, 0x9a, 0x00, 0x4a, 0x28, 0x01, + 0x28, 0xa6, 0x03, 0x93, 0xad, 0x4b, 0x96, 0x3d, 0xcd, 0x45, 0x86, 0x2a, + 0xf1, 0x56, 0xfe, 0x5d, 0xb5, 0xa4, 0x44, 0xc5, 0xf2, 0xb2, 0x99, 0x53, + 0x51, 0xfc, 0xf1, 0xe7, 0x06, 0xa6, 0xc0, 0x5c, 0x8a, 0x46, 0xdb, 0xd6, + 0xa4, 0xf3, 0x4d, 0x65, 0x62, 0x85, 0xf3, 0x4d, 0x2f, 0x9d, 0x48, 0x9b, + 0x0f, 0x59, 0x77, 0x53, 0xab, 0x44, 0x48, 0x53, 0x6a, 0xac, 0x48, 0x52, + 0xd0, 0x48, 0x94, 0xb4, 0x08, 0x5a, 0x70, 0xaa, 0x01, 0x69, 0x68, 0x10, + 0x51, 0x40, 0x82, 0x8a, 0x2c, 0x01, 0x45, 0x2b, 0x01, 0xcd, 0xd1, 0x5a, + 0x9b, 0x80, 0xa2, 0xa5, 0x8c, 0x28, 0x15, 0x1b, 0x80, 0xbd, 0x2b, 0xac, + 0xf0, 0xc4, 0x9b, 0xac, 0xca, 0x67, 0xa6, 0x4f, 0xeb, 0x53, 0x27, 0xaa, + 0x29, 0x6c, 0xcd, 0xba, 0xbd, 0x6a, 0x72, 0x95, 0xa4, 0xc9, 0x44, 0xf4, + 0x54, 0x80, 0x51, 0x40, 0x05, 0x14, 0x00, 0x51, 0x4c, 0x61, 0x45, 0x20, + 0x16, 0x8a, 0x40, 0x2d, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, 0x00, 0x52, + 0x77, 0x14, 0x03, 0x39, 0x3b, 0xfd, 0x4e, 0xe1, 0x2e, 0xb0, 0x8d, 0xc5, + 0x4b, 0x6d, 0xaf, 0x4e, 0x06, 0x1d, 0x73, 0x45, 0x58, 0xea, 0x6d, 0x05, + 0x78, 0x84, 0x9a, 0xe4, 0xbd, 0xb0, 0x2b, 0x36, 0xee, 0xf6, 0x4b, 0xaf, + 0xbf, 0x51, 0xb1, 0x4a, 0x28, 0x86, 0x13, 0xb2, 0x5d, 0xcb, 0x5d, 0xac, + 0x2f, 0x98, 0x54, 0xfb, 0x0f, 0xe5, 0x58, 0xcb, 0xe2, 0x2e, 0x5f, 0x09, + 0x20, 0x34, 0xec, 0xd6, 0x86, 0x02, 0xd1, 0x54, 0x01, 0x9a, 0x5c, 0xd2, + 0x01, 0x29, 0x29, 0x88, 0x08, 0x6c, 0x64, 0x03, 0x50, 0x92, 0xdf, 0xdd, + 0x3f, 0x95, 0x5a, 0x57, 0x11, 0x13, 0x6e, 0x5e, 0xa0, 0xd3, 0x4c, 0x94, + 0x3d, 0x04, 0x44, 0x5f, 0x9a, 0x4d, 0xd5, 0x37, 0x01, 0xbb, 0xe9, 0xac, + 0x68, 0x02, 0x8c, 0xbe, 0x67, 0x9a, 0x36, 0xe7, 0x15, 0x2c, 0x4a, 0x58, + 0x80, 0x70, 0x3e, 0xb5, 0x12, 0xdc, 0xd1, 0x6c, 0x6b, 0x69, 0x72, 0x71, + 0xb2, 0xae, 0xb1, 0xaa, 0x81, 0x12, 0x2a, 0xc9, 0x55, 0xde, 0xa8, 0x92, + 0xbb, 0xd7, 0x39, 0xe2, 0x01, 0xf2, 0x4b, 0xfe, 0xed, 0x54, 0x37, 0x14, + 0x8e, 0x68, 0xf5, 0xa4, 0xaa, 0x63, 0x14, 0x51, 0x52, 0x02, 0x52, 0xd0, + 0x02, 0x51, 0x40, 0x09, 0x45, 0x20, 0x0a, 0x29, 0x88, 0x96, 0x24, 0x35, + 0x3e, 0xca, 0x45, 0x8f, 0x8a, 0x20, 0x5f, 0xe6, 0xa9, 0xdd, 0x03, 0x0c, + 0x52, 0x4c, 0x2c, 0x1b, 0x4e, 0x29, 0xdb, 0x32, 0x39, 0xa2, 0xe1, 0x61, + 0xea, 0x30, 0x29, 0x6b, 0x31, 0x87, 0x34, 0xef, 0x2d, 0xaa, 0xc9, 0xb9, + 0x2c, 0x71, 0x6d, 0x39, 0xcd, 0x48, 0x4d, 0x34, 0x66, 0xc4, 0xcd, 0x25, + 0x32, 0x44, 0xa3, 0x34, 0xc4, 0x2d, 0x2d, 0x02, 0x17, 0x34, 0xea, 0x62, + 0x16, 0x8e, 0xf4, 0xc0, 0x5a, 0x29, 0x08, 0x28, 0xa0, 0x02, 0x8a, 0x62, + 0x39, 0xaa, 0x29, 0xb6, 0x75, 0x0b, 0x49, 0x52, 0x01, 0x49, 0x40, 0x85, + 0xae, 0x8b, 0xc2, 0x72, 0x7e, 0xf6, 0x54, 0xff, 0x00, 0x64, 0x7f, 0xe8, + 0x55, 0x9d, 0x44, 0x5c, 0x4e, 0x98, 0x55, 0xbb, 0x3a, 0xd2, 0x64, 0x22, + 0xdd, 0x14, 0x80, 0x28, 0xa0, 0x02, 0x8a, 0x06, 0x14, 0x53, 0x00, 0xa2, + 0x90, 0x05, 0x14, 0x80, 0x5a, 0x5a, 0x00, 0x29, 0x28, 0x00, 0xa4, 0xa0, + 0x06, 0x3b, 0xed, 0x15, 0x0f, 0xda, 0x14, 0x9a, 0x68, 0x4c, 0xe4, 0x35, + 0x1e, 0x2f, 0x0f, 0xd2, 0xab, 0x99, 0x82, 0x74, 0xc5, 0x2a, 0xdf, 0x11, + 0xbd, 0x2f, 0x84, 0x84, 0xc9, 0xba, 0x9b, 0xe6, 0x56, 0x46, 0x82, 0xac, + 0xa6, 0xb6, 0xac, 0x35, 0xb6, 0x8a, 0x3f, 0x2d, 0x86, 0xee, 0xb5, 0x0e, + 0x1d, 0x4a, 0xf2, 0x3a, 0x44, 0x6d, 0xc8, 0x18, 0x77, 0x15, 0x20, 0xa1, + 0x6a, 0x62, 0xd0, 0xb4, 0x66, 0xac, 0x42, 0x66, 0x8c, 0xd2, 0x10, 0x99, + 0xa6, 0x34, 0x9b, 0x46, 0x6a, 0x80, 0xb1, 0x63, 0xa8, 0xc4, 0x99, 0x0e, + 0x2a, 0xd7, 0xf6, 0x9d, 0xa9, 0xf5, 0xfc, 0xa8, 0x8e, 0x83, 0xf6, 0x77, + 0x2a, 0xea, 0x77, 0xb0, 0xb5, 0xa9, 0x54, 0x07, 0x2c, 0x08, 0xac, 0x33, + 0x29, 0xab, 0x9b, 0xd0, 0x98, 0xc6, 0xc3, 0x7c, 0xea, 0x97, 0x20, 0xd6, + 0x25, 0xd8, 0x4d, 0xcb, 0xeb, 0x51, 0x99, 0x45, 0x3d, 0x45, 0x61, 0x86, + 0x5e, 0x78, 0x14, 0x9b, 0x9c, 0xd2, 0x19, 0x34, 0x12, 0x34, 0x52, 0xab, + 0x1a, 0xd9, 0xce, 0x56, 0xaa, 0x3b, 0x93, 0x22, 0x07, 0xa8, 0x1e, 0xb4, + 0x66, 0x65, 0x69, 0x2b, 0x07, 0x5d, 0x19, 0x8d, 0xfd, 0xc5, 0x38, 0x6e, + 0x29, 0x1c, 0xab, 0x7d, 0xe3, 0xf5, 0xa4, 0xaa, 0x6c, 0x61, 0x4b, 0x48, + 0x02, 0x92, 0x92, 0x01, 0x28, 0xa0, 0x03, 0x06, 0x9f, 0xe5, 0x9a, 0x02, + 0xc3, 0xc4, 0x0d, 0x52, 0x2d, 0xb1, 0xa5, 0x71, 0xd8, 0xb5, 0x14, 0x07, + 0x1d, 0x31, 0x53, 0x08, 0x6b, 0x2e, 0x63, 0x41, 0x7c, 0xa1, 0x4e, 0xc0, + 0xa0, 0x01, 0x7e, 0x6e, 0x94, 0xfd, 0x95, 0x46, 0x6e, 0x43, 0xbc, 0xaa, + 0x5d, 0xa2, 0xa8, 0x9b, 0x8b, 0xd2, 0x97, 0x34, 0xc4, 0x2e, 0x69, 0x09, + 0xa0, 0x43, 0x77, 0x51, 0xba, 0x82, 0x43, 0x75, 0x19, 0xa6, 0x01, 0x9a, + 0x5c, 0xd0, 0x21, 0xd4, 0xa2, 0xa8, 0x43, 0xa9, 0x68, 0x10, 0x52, 0xd2, + 0x10, 0x51, 0x4c, 0x02, 0x8a, 0x04, 0x73, 0x74, 0xb4, 0xce, 0xa1, 0x28, + 0x15, 0x00, 0x21, 0xa2, 0x80, 0x1d, 0x5a, 0xde, 0x1b, 0x7d, 0x9a, 0x9a, + 0x2f, 0xf7, 0x99, 0x47, 0xf3, 0xa8, 0xa9, 0xb1, 0x70, 0x3b, 0x05, 0xe9, + 0x56, 0xad, 0x0f, 0xcf, 0x5a, 0x3d, 0x88, 0x45, 0xda, 0x28, 0x10, 0x51, + 0x40, 0x05, 0x14, 0x0c, 0x28, 0xa0, 0x04, 0xa5, 0xa4, 0x01, 0x45, 0x00, + 0x14, 0x50, 0x01, 0x45, 0x00, 0x14, 0x94, 0x01, 0x5e, 0xe7, 0xa5, 0x63, + 0x35, 0xfc, 0x62, 0xe3, 0xca, 0x63, 0x86, 0xe2, 0xae, 0xda, 0x5c, 0x5d, + 0x4c, 0x5b, 0xb7, 0xdc, 0x72, 0x6a, 0x91, 0xe6, 0xb3, 0x99, 0xb4, 0x40, + 0x29, 0xc7, 0x43, 0x4d, 0xef, 0xc5, 0x09, 0x14, 0xc7, 0x04, 0x35, 0xa9, + 0xa3, 0x5a, 0xf9, 0x97, 0x49, 0xe6, 0x27, 0xcb, 0x9a, 0x99, 0xc6, 0xc5, + 0xa3, 0xa9, 0x4e, 0x14, 0x0a, 0x7e, 0x6b, 0x34, 0x64, 0x2e, 0xea, 0x4d, + 0xd5, 0x40, 0x26, 0xfa, 0x69, 0x90, 0x54, 0x8c, 0x61, 0x9c, 0x7a, 0xd4, + 0x12, 0xdc, 0xae, 0xd2, 0x28, 0xb8, 0x72, 0x95, 0xa2, 0x6d, 0xd2, 0x71, + 0x57, 0x92, 0x16, 0x04, 0x1a, 0x39, 0x8e, 0x8d, 0x91, 0x16, 0xa0, 0xdc, + 0xa2, 0x7a, 0x55, 0x3a, 0xa9, 0x19, 0xb1, 0xa4, 0x53, 0xe3, 0xe6, 0x91, + 0x23, 0xcc, 0x23, 0x34, 0x9e, 0x58, 0xa4, 0x48, 0xbb, 0x69, 0x69, 0x0c, + 0x46, 0xe9, 0x5a, 0x36, 0x72, 0xf9, 0x90, 0xfb, 0x8a, 0x64, 0xb1, 0xcf, + 0x55, 0xda, 0xb6, 0x33, 0x2b, 0xcb, 0xd2, 0xb1, 0x35, 0x7c, 0x15, 0xc7, + 0xa9, 0xa1, 0x09, 0x9c, 0xbb, 0xa7, 0xcc, 0xdf, 0x5a, 0x8f, 0x63, 0x7a, + 0x1a, 0x60, 0x37, 0x14, 0xec, 0x50, 0x01, 0xb0, 0xd3, 0xc4, 0x06, 0x80, + 0xb1, 0x22, 0xdb, 0x7d, 0x6a, 0x55, 0xb4, 0xa9, 0xe6, 0x34, 0xe5, 0x26, + 0x4b, 0x2a, 0x99, 0x6d, 0x36, 0xd6, 0x6e, 0x65, 0xf2, 0x8f, 0x10, 0x20, + 0xa7, 0x61, 0x16, 0x8d, 0x58, 0xf4, 0x43, 0x1a, 0x50, 0xb4, 0x6f, 0xcf, + 0x34, 0xd4, 0x0c, 0xb9, 0x84, 0xcd, 0x15, 0xa5, 0x88, 0x6c, 0x4b, 0x63, + 0xf3, 0x35, 0x59, 0xcd, 0x21, 0x09, 0x9a, 0x4d, 0xd4, 0xac, 0x21, 0x37, + 0x53, 0x0c, 0xa0, 0x77, 0xa0, 0x08, 0xda, 0xed, 0x45, 0x40, 0xf7, 0xde, + 0x82, 0xa9, 0x21, 0x91, 0x1b, 0xc7, 0xff, 0x00, 0x26, 0x99, 0xf6, 0xd7, + 0xef, 0xcd, 0x16, 0x02, 0x41, 0x7c, 0x6a, 0x41, 0x7a, 0x3d, 0xa9, 0x59, + 0x8a, 0xc4, 0x8b, 0x74, 0xbe, 0xf5, 0x2a, 0xcc, 0x3d, 0x69, 0x85, 0x87, + 0x89, 0x85, 0x48, 0x24, 0x14, 0xc8, 0xb0, 0xfd, 0xd4, 0xbb, 0xa8, 0x24, + 0x5c, 0xd2, 0xd3, 0x10, 0xb4, 0xb4, 0x08, 0x28, 0xa2, 0xe2, 0x39, 0xba, + 0x2b, 0x43, 0xa4, 0x28, 0xa9, 0x18, 0x51, 0x48, 0x02, 0xae, 0x69, 0x4f, + 0xe5, 0xea, 0x30, 0x37, 0xfb, 0x55, 0x35, 0x2d, 0xca, 0x5c, 0x37, 0x3b, + 0xa4, 0xfb, 0xab, 0xfe, 0xe8, 0xab, 0x10, 0x1c, 0x48, 0x28, 0xfb, 0x24, + 0x1a, 0x03, 0xa5, 0x25, 0x31, 0x0b, 0x45, 0x00, 0x14, 0x50, 0x01, 0x45, + 0x00, 0x25, 0x14, 0x0c, 0x28, 0xa4, 0x01, 0x45, 0x00, 0x14, 0x50, 0x01, + 0x4d, 0x26, 0x80, 0x2b, 0xdc, 0xb7, 0xc9, 0x58, 0x37, 0x9a, 0x6c, 0x57, + 0x13, 0x79, 0x85, 0x99, 0x5a, 0xb5, 0x8c, 0xac, 0x4d, 0xb5, 0xb9, 0x91, + 0x76, 0x9e, 0x41, 0xd9, 0x55, 0xc5, 0x63, 0x50, 0xe8, 0xa7, 0xa9, 0xb9, + 0x6d, 0x6a, 0xbf, 0x67, 0xe9, 0x4e, 0x8b, 0x4a, 0x0c, 0xc4, 0x88, 0xbf, + 0x4a, 0x28, 0x31, 0x4d, 0x59, 0xdc, 0x9f, 0xfb, 0x2e, 0x4f, 0xe1, 0x8c, + 0xd4, 0xf6, 0x96, 0x52, 0xc1, 0x26, 0xe6, 0x4c, 0x57, 0x5d, 0x54, 0xb9, + 0x48, 0x8c, 0xcb, 0x7e, 0x60, 0x1d, 0xe9, 0xa6, 0xe5, 0x47, 0x7a, 0xf3, + 0xcd, 0x08, 0xda, 0xf5, 0x45, 0x42, 0xda, 0x87, 0xa5, 0x45, 0xcb, 0x50, + 0x22, 0x6b, 0xe7, 0x3d, 0x2a, 0x26, 0xba, 0x90, 0xf7, 0xa5, 0x73, 0x4e, + 0x51, 0x86, 0x42, 0x7b, 0xd3, 0x73, 0x41, 0x64, 0xb6, 0xd2, 0xf9, 0x72, + 0x83, 0x5b, 0x30, 0xcd, 0xd2, 0x92, 0x5a, 0x8d, 0xec, 0x51, 0xd4, 0x64, + 0x12, 0x5d, 0x65, 0x7d, 0x05, 0x41, 0x5b, 0xcc, 0xc5, 0x85, 0x3e, 0x2f, + 0xbd, 0x50, 0x41, 0x39, 0xa6, 0xd2, 0x24, 0x4a, 0x6d, 0x00, 0x21, 0xe9, + 0x4e, 0xb1, 0x9f, 0x65, 0xca, 0xc7, 0xfd, 0xf3, 0x8a, 0x60, 0x69, 0x35, + 0x57, 0x7a, 0xd6, 0xe6, 0x45, 0x5b, 0x96, 0xfd, 0xdb, 0x57, 0x2b, 0x37, + 0x9d, 0x23, 0x9d, 0xc4, 0x9c, 0x1a, 0x77, 0xd0, 0x12, 0xbb, 0x20, 0xf2, + 0x39, 0xa3, 0xc8, 0xac, 0xf9, 0x8d, 0x94, 0x05, 0xfb, 0x28, 0x3d, 0x56, + 0x9c, 0xb6, 0x23, 0xfb, 0xb4, 0xb9, 0xc7, 0xc8, 0x4a, 0xb6, 0x3e, 0xc2, + 0xa4, 0x16, 0xa8, 0x2a, 0x79, 0xca, 0xe5, 0x1e, 0x12, 0x35, 0xec, 0x29, + 0x0c, 0xa8, 0xb4, 0x25, 0x71, 0x68, 0x88, 0x8d, 0xc5, 0x30, 0xcc, 0x4d, + 0x68, 0xa0, 0x64, 0xe6, 0x30, 0xb1, 0xa4, 0xad, 0x2c, 0x67, 0x71, 0x92, + 0xfd, 0xda, 0x91, 0x69, 0x88, 0x09, 0xa6, 0xee, 0xa4, 0x05, 0x63, 0x75, + 0xb3, 0x3b, 0x45, 0x11, 0x5e, 0xb6, 0xff, 0x00, 0x98, 0x71, 0xf5, 0xa2, + 0xc3, 0x26, 0x6b, 0xd1, 0x51, 0x35, 0xe3, 0x76, 0xe2, 0x8b, 0x01, 0x0b, + 0x5c, 0x31, 0xef, 0x51, 0x34, 0xb9, 0xef, 0x40, 0x86, 0x79, 0x94, 0xdd, + 0xe6, 0x81, 0x8d, 0xc9, 0xa2, 0x81, 0x0b, 0xb6, 0x9e, 0x05, 0x00, 0x38, + 0x1c, 0x54, 0x9e, 0x69, 0xa0, 0x05, 0xf3, 0x4d, 0x3c, 0x5c, 0x38, 0xa3, + 0x70, 0x24, 0x17, 0x4d, 0xde, 0xa4, 0x5b, 0xca, 0x56, 0x11, 0x62, 0x3b, + 0x9d, 0xd5, 0x30, 0x9a, 0x92, 0x64, 0x34, 0x4a, 0x0d, 0x3e, 0xa9, 0x33, + 0x30, 0xa5, 0xaa, 0xb0, 0x1c, 0xe5, 0x25, 0x07, 0x48, 0x1e, 0x94, 0x52, + 0x01, 0x68, 0xa6, 0x80, 0x4a, 0x92, 0x16, 0xdb, 0x26, 0xef, 0xad, 0x4c, + 0xf6, 0x2a, 0x1b, 0x9e, 0x81, 0x6d, 0xcc, 0x11, 0x9f, 0xf6, 0x47, 0xf2, + 0xab, 0x2b, 0xf7, 0x85, 0x28, 0xfc, 0x24, 0xbd, 0xcd, 0x05, 0xe9, 0x4b, + 0x54, 0x01, 0x45, 0x00, 0x14, 0x50, 0x01, 0x45, 0x20, 0x12, 0x92, 0x80, + 0x0a, 0x28, 0x00, 0xa2, 0x80, 0x0a, 0x4c, 0xd0, 0x03, 0x77, 0x54, 0x53, + 0x49, 0xf2, 0x1c, 0x51, 0x70, 0x28, 0xcb, 0x21, 0x6a, 0xac, 0xcc, 0x69, + 0x5c, 0x66, 0x76, 0xa1, 0x6d, 0xf6, 0x84, 0xe3, 0xef, 0x0a, 0xc4, 0x62, + 0x62, 0x72, 0xad, 0x43, 0xd5, 0x15, 0x07, 0x66, 0x6c, 0x69, 0xba, 0x9a, + 0x30, 0x11, 0x3f, 0x5a, 0xf4, 0x0d, 0x2a, 0xd6, 0x34, 0x87, 0x77, 0x1c, + 0xd7, 0x34, 0x74, 0x95, 0x8d, 0xaa, 0xec, 0x5f, 0x70, 0x31, 0x59, 0xb7, + 0x5b, 0x6b, 0xb9, 0xb3, 0x96, 0xc7, 0x29, 0xa8, 0x36, 0xd9, 0xf8, 0xe9, + 0x55, 0xb7, 0x66, 0xb9, 0xaa, 0xee, 0x76, 0x53, 0xd8, 0x33, 0x4d, 0xcd, + 0x73, 0x9b, 0x09, 0x9a, 0x68, 0x6d, 0xdd, 0x29, 0x00, 0xfa, 0x75, 0x00, + 0x2a, 0xf5, 0xad, 0xeb, 0x44, 0xfd, 0xde, 0xfe, 0xd5, 0xa4, 0x5e, 0xa5, + 0x74, 0x32, 0xae, 0xbf, 0xd6, 0x53, 0x33, 0x5a, 0xcb, 0x73, 0x19, 0x8e, + 0xa7, 0x45, 0xf7, 0xaa, 0x0c, 0xcb, 0x06, 0x9b, 0x4d, 0x90, 0x25, 0x26, + 0x2a, 0x46, 0x21, 0xaa, 0x53, 0x31, 0x8e, 0x40, 0xc3, 0xa8, 0xaa, 0x03, + 0x6d, 0x24, 0xf3, 0x21, 0x0d, 0x55, 0x6e, 0xa6, 0xd8, 0x2a, 0xa2, 0xf4, + 0x33, 0xea, 0x66, 0x4d, 0x2c, 0x92, 0xf1, 0x9a, 0xad, 0xe4, 0x0a, 0xce, + 0x4c, 0xdd, 0x21, 0x86, 0xdc, 0x7a, 0xd2, 0xf9, 0x28, 0x3d, 0x2a, 0x2e, + 0xcb, 0xb0, 0x9b, 0xa3, 0x5a, 0x61, 0xb8, 0x41, 0xde, 0xad, 0x45, 0x92, + 0xdd, 0x88, 0x5a, 0xe7, 0xda, 0xa2, 0x33, 0x31, 0xef, 0x5a, 0xf2, 0x18, + 0xba, 0x83, 0x0b, 0x13, 0x4d, 0xad, 0x0c, 0x84, 0xa5, 0xa0, 0x02, 0x8a, + 0x04, 0x32, 0x4e, 0x94, 0x2b, 0x71, 0x43, 0x10, 0x85, 0xaa, 0xbd, 0xc4, + 0x85, 0x71, 0x40, 0xc4, 0xb7, 0x45, 0x9b, 0xef, 0x54, 0xc6, 0x38, 0x17, + 0xf8, 0x69, 0x5c, 0x0a, 0x9e, 0xb8, 0xa6, 0x91, 0x4c, 0x63, 0x0a, 0xd3, + 0x76, 0x50, 0x20, 0xd9, 0x4a, 0x23, 0xa0, 0x63, 0xb1, 0x4b, 0x40, 0x82, + 0x8a, 0x00, 0x4c, 0xd2, 0x6e, 0xa0, 0x62, 0x6e, 0xa7, 0x86, 0xa4, 0x20, + 0x2f, 0x49, 0xba, 0x98, 0x16, 0xad, 0x5a, 0xae, 0x21, 0xac, 0xc4, 0xcb, + 0x31, 0x9a, 0x98, 0x56, 0x88, 0xcc, 0x5a, 0x5a, 0x64, 0x9c, 0xef, 0x7a, + 0x4a, 0xd2, 0xc6, 0xe2, 0xd1, 0x52, 0x31, 0x40, 0x34, 0x63, 0x07, 0x91, + 0x49, 0x08, 0x6d, 0x3b, 0xb1, 0xa2, 0x43, 0x8e, 0xe7, 0x7b, 0xa3, 0xbf, + 0x9b, 0x60, 0xa7, 0xfd, 0xa3, 0xfd, 0x2b, 0x47, 0x1c, 0x54, 0x53, 0xf8, + 0x47, 0x3f, 0x88, 0xb9, 0x1f, 0xdd, 0xa5, 0xa6, 0x89, 0x16, 0x8a, 0x60, + 0x14, 0x53, 0x18, 0x52, 0x52, 0x01, 0x28, 0xa4, 0x02, 0x51, 0x9a, 0x00, + 0x4d, 0xd4, 0xc3, 0x28, 0x1d, 0xe8, 0x60, 0x42, 0xf7, 0x68, 0x3b, 0xd4, + 0x26, 0xf2, 0xb2, 0x6c, 0x9e, 0x62, 0x13, 0x7c, 0x7d, 0x29, 0xbf, 0x68, + 0x2c, 0x32, 0x2a, 0x05, 0x71, 0x14, 0x96, 0xed, 0x46, 0xd3, 0x53, 0x71, + 0x31, 0x8c, 0x17, 0xf8, 0xb1, 0x5c, 0xe6, 0xaa, 0x8a, 0x2e, 0x8e, 0xde, + 0x98, 0x15, 0xa5, 0x36, 0x54, 0x6f, 0x72, 0x9a, 0x65, 0x4f, 0x15, 0xd8, + 0x5b, 0x5e, 0xea, 0x10, 0xdb, 0x02, 0x8f, 0x95, 0xad, 0x69, 0xa8, 0xb9, + 0xea, 0x74, 0x49, 0xfb, 0xa3, 0x2e, 0x35, 0x8d, 0x40, 0x8e, 0x49, 0xab, + 0x50, 0xcc, 0xef, 0x0f, 0xcc, 0xd9, 0xae, 0xba, 0xd0, 0x51, 0xd8, 0xc9, + 0x19, 0xba, 0x91, 0xc3, 0x8c, 0xf7, 0xa8, 0x63, 0xe9, 0x5e, 0x7d, 0x63, + 0xae, 0x97, 0xc2, 0x3a, 0x8a, 0xc4, 0xd0, 0x43, 0x50, 0x6d, 0x60, 0xdc, + 0x53, 0xb0, 0x89, 0x79, 0xa7, 0x0a, 0x7c, 0xa3, 0xb8, 0xe5, 0xeb, 0x5d, + 0x25, 0xa4, 0x32, 0x1b, 0x4f, 0x96, 0x9c, 0x7e, 0x20, 0xe7, 0xb2, 0x33, + 0xb5, 0x0b, 0x57, 0x5c, 0xb1, 0xe2, 0xb3, 0xb7, 0x1a, 0xda, 0xaa, 0x31, + 0x52, 0xe6, 0x1e, 0x24, 0xa9, 0x62, 0x3c, 0xd6, 0x20, 0xd1, 0x68, 0xf4, + 0xa6, 0xe4, 0x53, 0x20, 0x61, 0x75, 0xa6, 0x19, 0x94, 0x54, 0x95, 0x62, + 0x17, 0x9e, 0xab, 0x4a, 0xdb, 0xb9, 0x35, 0x45, 0x58, 0x9a, 0x0d, 0x43, + 0x62, 0x18, 0xf1, 0xd3, 0x9c, 0xd4, 0x72, 0x4f, 0xbc, 0xe4, 0x9a, 0x5b, + 0x0b, 0x94, 0x81, 0xa7, 0x02, 0xa2, 0x6b, 0xa1, 0x4d, 0x42, 0xe0, 0xe6, + 0x91, 0x13, 0x5c, 0x9e, 0xd5, 0x0b, 0x4a, 0xc7, 0xbd, 0x6d, 0xc8, 0x8c, + 0x5d, 0x46, 0x44, 0x4e, 0x4d, 0x15, 0x66, 0x62, 0x51, 0x40, 0x05, 0x25, + 0x00, 0x25, 0x2d, 0x00, 0x25, 0x25, 0x02, 0x18, 0xe7, 0x8a, 0x62, 0xfd, + 0xda, 0x42, 0x10, 0x9a, 0x82, 0x7f, 0xb9, 0x54, 0x03, 0x2d, 0xdb, 0x14, + 0xf2, 0xcb, 0xeb, 0x52, 0x8a, 0x2b, 0xb3, 0x73, 0xc5, 0x1e, 0x65, 0x0c, + 0x57, 0x17, 0xcc, 0xa3, 0x70, 0xa0, 0x63, 0xa9, 0x68, 0x10, 0x62, 0x8c, + 0x50, 0x02, 0x52, 0x71, 0x40, 0x0d, 0x6a, 0x6d, 0x30, 0x16, 0x8a, 0x00, + 0x4c, 0xd1, 0x9a, 0x40, 0x59, 0xb7, 0x35, 0x75, 0x0d, 0x48, 0x99, 0x65, + 0x0f, 0x15, 0x30, 0x35, 0x48, 0xcd, 0x8e, 0xcd, 0x2e, 0x68, 0x20, 0xe7, + 0xa8, 0x35, 0xa9, 0xd2, 0x14, 0xf5, 0xa8, 0x60, 0x5a, 0x18, 0x0b, 0x51, + 0x4b, 0x8c, 0x54, 0xc4, 0x08, 0x71, 0x4b, 0x8e, 0xd4, 0xc0, 0xec, 0xfc, + 0x2c, 0xfb, 0xb4, 0xfd, 0xbe, 0x9b, 0x8f, 0xeb, 0x5b, 0xe8, 0x32, 0xb5, + 0x9d, 0x2d, 0x8b, 0xa9, 0xb9, 0x62, 0x25, 0xf9, 0x69, 0xd8, 0xad, 0x0c, + 0xc4, 0xa2, 0x80, 0x0a, 0x28, 0x18, 0xda, 0x42, 0x68, 0x01, 0xa5, 0xc7, + 0xad, 0x46, 0x65, 0x51, 0xde, 0xa6, 0xe0, 0x46, 0xd7, 0x48, 0x3b, 0xd4, + 0x7f, 0x6c, 0x07, 0xa5, 0x4d, 0xca, 0xb1, 0x04, 0x97, 0x2c, 0xc3, 0x1d, + 0x2a, 0x21, 0xb8, 0xf5, 0xac, 0xe5, 0x23, 0x2b, 0x83, 0x42, 0x0d, 0x1e, + 0x4a, 0xe2, 0xa2, 0xe4, 0x86, 0xd5, 0xc6, 0x29, 0xca, 0x10, 0x0e, 0xc2, + 0xa5, 0x8c, 0x6b, 0xdd, 0x43, 0x10, 0xe5, 0xaa, 0xa4, 0xda, 0xcc, 0x2b, + 0xc2, 0x02, 0xc7, 0xe9, 0x57, 0x18, 0x5c, 0x46, 0x75, 0xc5, 0xed, 0xc4, + 0xfd, 0x3e, 0x51, 0xed, 0x54, 0x58, 0x36, 0x7e, 0x6a, 0xdb, 0x92, 0xc6, + 0xf0, 0x56, 0x45, 0x73, 0x2a, 0xd7, 0x61, 0xa2, 0xcf, 0xe6, 0xd9, 0x0f, + 0xa9, 0xa7, 0xb3, 0x45, 0xef, 0x11, 0x93, 0x7c, 0xca, 0x6a, 0xc5, 0x97, + 0xfa, 0xb3, 0x5d, 0x95, 0xb6, 0x33, 0x89, 0x99, 0xe2, 0x21, 0x85, 0x8c, + 0xff, 0x00, 0xb4, 0x7f, 0xf4, 0x1a, 0xa9, 0x67, 0x3f, 0x99, 0xf2, 0x9e, + 0xb5, 0xc5, 0x5d, 0x68, 0x99, 0xd1, 0x41, 0xe9, 0x62, 0xde, 0x29, 0x71, + 0x5c, 0xe6, 0xc2, 0xe2, 0x8a, 0x00, 0xb7, 0x07, 0x94, 0x63, 0xe4, 0x73, + 0x50, 0xcc, 0xa1, 0x9f, 0xe5, 0xad, 0x96, 0x91, 0x30, 0x5f, 0x10, 0xc1, + 0x19, 0xae, 0xaf, 0x45, 0x90, 0x7d, 0x93, 0x04, 0xfa, 0xd6, 0x5d, 0x4a, + 0x9e, 0xc5, 0x7d, 0x69, 0x81, 0x85, 0xb9, 0xed, 0x5c, 0xe9, 0x1f, 0x31, + 0xae, 0x8a, 0x9b, 0x19, 0xd2, 0x42, 0x62, 0x9c, 0x38, 0xae, 0x63, 0x71, + 0xe6, 0x53, 0x8e, 0xb5, 0x1b, 0x4b, 0x4c, 0x08, 0xda, 0x5f, 0x7a, 0x89, + 0xa5, 0xf5, 0x34, 0xf9, 0x40, 0x85, 0xee, 0x14, 0x0e, 0xb5, 0x52, 0x5b, + 0xcc, 0x74, 0xad, 0x3d, 0x99, 0x0e, 0xa5, 0x86, 0xf9, 0xef, 0xd7, 0xa1, + 0xa4, 0xf3, 0x19, 0xba, 0x9a, 0xd2, 0x31, 0x31, 0x73, 0xb8, 0x75, 0xa3, + 0x15, 0x56, 0x33, 0x12, 0x92, 0x80, 0x12, 0x8a, 0x00, 0x4a, 0x29, 0x00, + 0x94, 0x50, 0x02, 0x62, 0x99, 0x23, 0x6c, 0x5c, 0x9a, 0x00, 0x8d, 0x27, + 0x0c, 0x71, 0x52, 0x1a, 0x9e, 0xa0, 0x31, 0x87, 0x14, 0x46, 0xbb, 0x85, + 0x50, 0x88, 0x5a, 0xa2, 0x97, 0xee, 0xd3, 0xb0, 0x11, 0x27, 0x5a, 0x47, + 0x5c, 0x49, 0x40, 0x0d, 0x2b, 0xcd, 0x34, 0xad, 0x00, 0x25, 0x14, 0x86, + 0x14, 0xbb, 0xcd, 0x00, 0x3f, 0x79, 0xa4, 0xdc, 0x68, 0xb0, 0x82, 0x8a, + 0x00, 0x4a, 0x28, 0x01, 0x28, 0xa0, 0x02, 0x81, 0x40, 0x16, 0x60, 0xab, + 0x91, 0xd2, 0x02, 0xc2, 0x1a, 0x94, 0x1a, 0x66, 0x6c, 0x93, 0x34, 0xb4, + 0x12, 0x73, 0xf4, 0x55, 0x9b, 0x8a, 0x06, 0x4d, 0x48, 0x8a, 0x43, 0x50, + 0x05, 0x81, 0x19, 0xa5, 0xfb, 0x39, 0xf4, 0xfd, 0x2a, 0x40, 0x51, 0x68, + 0xcc, 0x71, 0xe5, 0xb7, 0xfd, 0xf3, 0x56, 0xd3, 0x49, 0xb8, 0x93, 0xee, + 0xc7, 0x81, 0x5a, 0x72, 0xf7, 0x11, 0xd0, 0x68, 0x56, 0xb2, 0xd9, 0xab, + 0x09, 0x40, 0x00, 0xfb, 0xfb, 0xd6, 0xe4, 0x2c, 0x37, 0x62, 0xb1, 0xb7, + 0x29, 0x4d, 0xdc, 0xd0, 0x81, 0x72, 0x28, 0x74, 0xa7, 0x12, 0x59, 0x1e, + 0xda, 0x6d, 0x30, 0x1b, 0x49, 0x4c, 0x0a, 0xd7, 0x53, 0xf9, 0x29, 0xba, + 0xb3, 0x9f, 0x53, 0x3d, 0x85, 0x4c, 0xf4, 0x45, 0xc1, 0x5c, 0xae, 0xf7, + 0xf2, 0x1e, 0xf5, 0x11, 0xb8, 0x73, 0xde, 0xb1, 0xb9, 0xb2, 0x89, 0x13, + 0x3b, 0x1e, 0xf4, 0xd1, 0x76, 0xf0, 0xfb, 0xd3, 0xb5, 0xd1, 0x13, 0x1c, + 0xba, 0xba, 0x7f, 0x12, 0x55, 0xd8, 0xae, 0xbc, 0xc8, 0xf7, 0x20, 0x15, + 0x9f, 0x2e, 0xa6, 0x1c, 0xa5, 0x49, 0x35, 0xa4, 0x47, 0xda, 0x62, 0x39, + 0xa8, 0x5f, 0x5c, 0x6f, 0xe1, 0x86, 0xaa, 0x54, 0x83, 0x94, 0x81, 0xb5, + 0x7b, 0xa6, 0xfb, 0xaa, 0x17, 0xf1, 0xa8, 0x1e, 0xee, 0xf2, 0x6f, 0xf9, + 0x6a, 0x6b, 0x58, 0x53, 0x8f, 0x50, 0xe4, 0x64, 0x62, 0xda, 0x59, 0x1b, + 0x2e, 0x33, 0x53, 0x7d, 0x9c, 0xf1, 0xb4, 0x55, 0x5d, 0x5c, 0xd3, 0x93, + 0x42, 0x58, 0x93, 0xd6, 0x96, 0xe1, 0x7f, 0x77, 0x53, 0xcd, 0xa9, 0xa7, + 0x2d, 0x91, 0x89, 0x30, 0x09, 0x21, 0x18, 0xad, 0xed, 0x12, 0xec, 0xac, + 0x5b, 0x47, 0x6f, 0xf1, 0xaa, 0x62, 0x5b, 0x16, 0x3c, 0xd0, 0xd1, 0x90, + 0x5a, 0xae, 0xe9, 0xa7, 0xf7, 0x67, 0x15, 0xd5, 0x57, 0xe1, 0x25, 0x10, + 0xeb, 0x10, 0x79, 0xb0, 0x73, 0xda, 0xa8, 0x5b, 0x5b, 0x79, 0x6d, 0x5c, + 0x55, 0x76, 0xb1, 0xad, 0x12, 0x69, 0x25, 0x58, 0xbe, 0xf5, 0x31, 0x2e, + 0x91, 0xa4, 0x0b, 0x9e, 0xbe, 0xd5, 0x8f, 0x26, 0x97, 0x2f, 0x9f, 0x5b, + 0x17, 0x15, 0x72, 0x29, 0x7c, 0xba, 0x94, 0x50, 0xe5, 0x87, 0x34, 0xf1, + 0x16, 0x0d, 0x5d, 0xc8, 0x1f, 0x80, 0x2a, 0x54, 0xb8, 0xf2, 0xc7, 0x07, + 0x15, 0x20, 0x43, 0x35, 0xce, 0xfe, 0xa7, 0x35, 0x58, 0x9a, 0x72, 0x63, + 0x5a, 0x0c, 0x32, 0x01, 0x51, 0xb4, 0xc2, 0x9a, 0x8d, 0xc7, 0xcd, 0x62, + 0x33, 0x3e, 0x7b, 0x54, 0x4d, 0x31, 0xad, 0x55, 0x33, 0x17, 0x54, 0x89, + 0xa4, 0x3e, 0xb5, 0x19, 0x35, 0xa2, 0x89, 0x93, 0x91, 0x0b, 0x1a, 0x87, + 0x6e, 0xe7, 0xa6, 0x22, 0x6a, 0x70, 0x15, 0x20, 0x3b, 0x14, 0x62, 0xa8, + 0x03, 0x61, 0xa6, 0x62, 0x9b, 0x40, 0x25, 0x18, 0xa8, 0x01, 0x76, 0x1a, + 0x6e, 0xda, 0x2c, 0x01, 0xb6, 0x97, 0x6d, 0x20, 0x0c, 0x55, 0x5b, 0xe1, + 0xfb, 0xa3, 0x4d, 0x6e, 0x26, 0x67, 0x03, 0xf3, 0x0a, 0xb8, 0x67, 0x18, + 0x14, 0x9a, 0x18, 0x79, 0xdb, 0xfb, 0x56, 0xbe, 0x9d, 0x68, 0x02, 0x92, + 0xfc, 0xd0, 0x22, 0x79, 0xac, 0x23, 0x6c, 0xf1, 0x59, 0x57, 0x5a, 0x54, + 0xa3, 0x98, 0xfa, 0x55, 0xa7, 0xdc, 0xcc, 0xa0, 0xd6, 0xb2, 0xc6, 0xdf, + 0x32, 0xd3, 0x58, 0x53, 0xb1, 0x57, 0x19, 0x46, 0x29, 0x58, 0xa1, 0x92, + 0x27, 0xa5, 0x45, 0x40, 0x05, 0x15, 0x23, 0x1d, 0x45, 0x02, 0x0a, 0x29, + 0x80, 0xb4, 0xa3, 0x14, 0x80, 0x09, 0xe2, 0x9b, 0x40, 0x05, 0x2d, 0x00, + 0x4f, 0x05, 0x5b, 0x4a, 0x56, 0x11, 0x32, 0x9a, 0x98, 0x1a, 0x09, 0x1e, + 0x0d, 0x3f, 0x34, 0xc9, 0x32, 0xc5, 0xbe, 0xee, 0x8a, 0x7f, 0x0a, 0x9a, + 0x3d, 0x3e, 0x57, 0xe9, 0x1b, 0x7e, 0x55, 0xb1, 0xa1, 0x7a, 0x2d, 0x0a, + 0xe5, 0xbf, 0xe5, 0x98, 0xfc, 0x4d, 0x5e, 0x8b, 0xc3, 0x6d, 0xff, 0x00, + 0x2d, 0x24, 0xc7, 0xe4, 0x69, 0x0a, 0xe5, 0xd8, 0xb4, 0x0b, 0x65, 0xea, + 0xc4, 0xfe, 0x15, 0x72, 0x2d, 0x26, 0xd6, 0x3e, 0x91, 0x0a, 0x9e, 0x61, + 0x97, 0x62, 0xb6, 0x89, 0x3f, 0x80, 0x0a, 0xb2, 0x15, 0x00, 0xed, 0x51, + 0x70, 0xb0, 0xc2, 0x15, 0x8d, 0x2a, 0x42, 0xa0, 0xe6, 0x86, 0xc6, 0x8b, + 0xf6, 0xdd, 0x6a, 0x76, 0x5a, 0x51, 0x19, 0x13, 0xa7, 0x15, 0x55, 0xea, + 0x84, 0x32, 0x9a, 0xdf, 0x76, 0x80, 0x33, 0x2e, 0xfe, 0x65, 0x35, 0x90, + 0xdc, 0x1a, 0x55, 0x36, 0x34, 0xa4, 0x25, 0x15, 0x81, 0xb3, 0x62, 0x54, + 0x6c, 0xa0, 0xd6, 0x88, 0xcd, 0x90, 0xb4, 0x00, 0xfa, 0xd4, 0x5f, 0x67, + 0xbb, 0x1f, 0xea, 0xe5, 0x6c, 0x7d, 0x6a, 0xf4, 0xea, 0x40, 0x0b, 0x4b, + 0x8d, 0xf9, 0x90, 0x7e, 0xb5, 0x37, 0x90, 0x07, 0x50, 0x2a, 0x64, 0x52, + 0x06, 0x01, 0x50, 0x9c, 0x53, 0x22, 0x7c, 0xb8, 0x15, 0x3d, 0x2e, 0x52, + 0x65, 0xc5, 0x15, 0x25, 0x67, 0x73, 0x42, 0xb9, 0xf9, 0x24, 0xa5, 0x97, + 0xe7, 0x89, 0x87, 0xad, 0x1d, 0x41, 0xec, 0x64, 0x4d, 0x06, 0xf9, 0x73, + 0xd6, 0xb4, 0xf4, 0x48, 0x17, 0xcc, 0x2a, 0x6b, 0x49, 0xcf, 0x42, 0x63, + 0x13, 0x7d, 0x74, 0x24, 0x97, 0x90, 0xd8, 0xab, 0x96, 0xda, 0x52, 0x5a, + 0x7f, 0x1e, 0x6b, 0x7f, 0x6b, 0xcd, 0x1b, 0x18, 0x14, 0xb5, 0x3d, 0x85, + 0x76, 0xad, 0x50, 0x48, 0xeb, 0x0a, 0x86, 0xf0, 0x21, 0xb9, 0xb5, 0xf3, + 0x31, 0xed, 0x51, 0x45, 0x63, 0x87, 0x07, 0x9a, 0x97, 0x2d, 0x07, 0x15, + 0xa9, 0xa2, 0x30, 0x00, 0xa7, 0x64, 0x56, 0x45, 0x89, 0xe6, 0x62, 0x90, + 0xcb, 0x4c, 0x08, 0xda, 0x5f, 0x7a, 0x88, 0xcb, 0x5a, 0x28, 0xdc, 0x87, + 0x3b, 0x0c, 0x32, 0x55, 0x71, 0x2b, 0x33, 0x11, 0x5b, 0x2a, 0x66, 0x4e, + 0xa0, 0xa6, 0xa2, 0x7e, 0x95, 0xa2, 0x46, 0x77, 0x0e, 0xd4, 0xd3, 0x48, + 0x08, 0xcd, 0x30, 0xd5, 0x6c, 0x22, 0xbc, 0x8d, 0xe9, 0x4b, 0x1d, 0x43, + 0x1a, 0x26, 0x02, 0xa4, 0x55, 0xa1, 0x03, 0x2c, 0x2d, 0xb1, 0x63, 0xc0, + 0xab, 0x70, 0xe9, 0xa5, 0xba, 0xd3, 0x62, 0x2e, 0x47, 0xa7, 0x44, 0xbd, + 0xab, 0x3b, 0x53, 0xb6, 0xdb, 0x36, 0x54, 0x7f, 0x9c, 0x55, 0x45, 0x92, + 0x54, 0x4b, 0x66, 0x6e, 0x82, 0xad, 0xc1, 0xa7, 0x16, 0x3f, 0x30, 0xa8, + 0x2c, 0xbf, 0x0e, 0x99, 0x12, 0x8f, 0x99, 0x45, 0x67, 0x6a, 0x90, 0x2c, + 0x53, 0xf0, 0x38, 0xc0, 0xa6, 0x49, 0x40, 0xe0, 0x77, 0xa6, 0x19, 0x14, + 0x56, 0x05, 0x91, 0x35, 0xc0, 0xed, 0x55, 0xa6, 0x9b, 0xcc, 0x18, 0x22, + 0x98, 0x58, 0x80, 0xaa, 0xfa, 0x50, 0x2a, 0xc4, 0x68, 0xe9, 0x96, 0x62, + 0x59, 0x33, 0xda, 0xb7, 0x02, 0x15, 0x14, 0x21, 0x31, 0xd9, 0x22, 0x93, + 0x23, 0xd2, 0x8b, 0x10, 0x35, 0x91, 0x58, 0x55, 0x77, 0xb7, 0x4e, 0xe8, + 0x29, 0x05, 0x8a, 0x72, 0xe9, 0xf0, 0xb7, 0x6c, 0x1a, 0xab, 0x2e, 0x9b, + 0x93, 0xf2, 0x1a, 0xab, 0xf7, 0x0d, 0x86, 0xa6, 0x9b, 0x37, 0x4c, 0x52, + 0x36, 0x89, 0x26, 0x33, 0x9a, 0xad, 0x02, 0xe5, 0x39, 0x74, 0xf9, 0xa3, + 0xed, 0x9a, 0xa8, 0x46, 0x38, 0xa1, 0xd8, 0xa4, 0xc2, 0x96, 0xa4, 0x61, + 0x4b, 0x40, 0x05, 0x14, 0x80, 0x29, 0x68, 0x10, 0x94, 0xb4, 0x01, 0x2c, + 0x55, 0x6d, 0x05, 0x00, 0x4e, 0x12, 0x9f, 0x82, 0x3b, 0x50, 0x48, 0xe0, + 0x69, 0xf9, 0xa4, 0x23, 0xa8, 0x8a, 0xd6, 0x24, 0xfb, 0xb0, 0xaf, 0xe5, + 0x56, 0x15, 0x1b, 0xb7, 0x15, 0x77, 0x2a, 0xc3, 0xf6, 0x1f, 0xe2, 0x6a, + 0x77, 0xca, 0x2a, 0x6e, 0x50, 0xbb, 0x80, 0xa5, 0xf3, 0x28, 0x01, 0x3c, + 0xc6, 0xa4, 0xcd, 0x21, 0x8f, 0x8f, 0xef, 0x55, 0xc5, 0xcd, 0x20, 0x2c, + 0x47, 0xf2, 0x9a, 0x95, 0xa4, 0xf7, 0xa0, 0x08, 0x5e, 0x74, 0x1d, 0x5a, + 0xa9, 0xbc, 0xb9, 0x7e, 0x3a, 0x55, 0x08, 0x78, 0xe6, 0x91, 0xba, 0x53, + 0x40, 0x67, 0x4e, 0x39, 0x22, 0xb1, 0xa7, 0xe3, 0x35, 0x53, 0xd8, 0xba, + 0x65, 0x4f, 0x30, 0xf3, 0xcd, 0x20, 0x91, 0x8e, 0x79, 0xac, 0xac, 0x5b, + 0x91, 0x07, 0xda, 0x1c, 0xb1, 0xe6, 0xad, 0xa6, 0xe2, 0xa3, 0x9a, 0x87, + 0xa0, 0x22, 0x5c, 0x62, 0xac, 0x47, 0xc2, 0x52, 0x18, 0xbb, 0xaa, 0xb3, + 0x55, 0x81, 0x0c, 0xdf, 0x70, 0xd5, 0x68, 0xb8, 0x93, 0xf1, 0xaa, 0xe8, + 0x4a, 0xf8, 0x8d, 0x18, 0x46, 0x6a, 0x56, 0x5e, 0x2b, 0x9d, 0x1a, 0xb2, + 0xb4, 0xe2, 0x84, 0x39, 0x5a, 0x63, 0xe8, 0x55, 0x54, 0xcb, 0x9e, 0xbd, + 0x6a, 0xed, 0xac, 0x7b, 0x24, 0xc8, 0xa1, 0xb2, 0xba, 0x1a, 0xf0, 0x4f, + 0x2a, 0xae, 0x03, 0x9a, 0x73, 0xcc, 0xcd, 0xf7, 0x9c, 0x9a, 0xd1, 0x33, + 0x3b, 0x15, 0x9b, 0x14, 0xda, 0x86, 0x5a, 0x13, 0x34, 0xd2, 0xe0, 0x52, + 0x48, 0x06, 0x99, 0x85, 0x47, 0xe7, 0x56, 0x8a, 0x99, 0x9b, 0xa8, 0x34, + 0xc8, 0xde, 0xb4, 0xcc, 0x9a, 0xd1, 0x53, 0x46, 0x4e, 0x6c, 0x29, 0x2b, + 0x4b, 0x12, 0x25, 0x41, 0xd2, 0x5a, 0xa1, 0x12, 0x1a, 0x8e, 0xa4, 0x61, + 0x4c, 0x34, 0x01, 0x19, 0xa8, 0x65, 0x38, 0x14, 0xc4, 0x44, 0x16, 0xa4, + 0x44, 0xe6, 0xa4, 0x65, 0xc8, 0xa2, 0x26, 0xb4, 0xad, 0x2c, 0xc7, 0xf1, + 0xd4, 0x81, 0xa2, 0x91, 0x2c, 0x7d, 0x05, 0x3f, 0xb5, 0x31, 0x08, 0x2a, + 0x39, 0xa0, 0x59, 0x3e, 0xf0, 0xa1, 0x08, 0x45, 0x89, 0x13, 0xa2, 0xd4, + 0x9d, 0xa9, 0x0c, 0x55, 0xac, 0x2f, 0x12, 0x39, 0x8f, 0xcb, 0x23, 0xd7, + 0xfa, 0x55, 0x44, 0x4c, 0xe7, 0xcc, 0xa4, 0xf5, 0xa8, 0xcb, 0x66, 0xa2, + 0xc6, 0x82, 0x66, 0x93, 0xbd, 0x20, 0x1a, 0x4d, 0x0b, 0xd6, 0x98, 0x8d, + 0xed, 0x24, 0x6c, 0x8b, 0x35, 0xac, 0x1e, 0x84, 0x43, 0x17, 0x83, 0x4d, + 0xf2, 0xc1, 0xa6, 0x21, 0xa6, 0x1f, 0x43, 0x49, 0xe5, 0x37, 0xd6, 0x91, + 0x23, 0xbc, 0x8c, 0x8e, 0x95, 0x1b, 0x42, 0x16, 0x84, 0x03, 0x37, 0x62, + 0xa2, 0x79, 0xf8, 0xe6, 0x81, 0x99, 0x9a, 0x84, 0xf8, 0xe8, 0x6b, 0x0e, + 0x6e, 0x64, 0xcd, 0x31, 0xa1, 0x94, 0xa2, 0x82, 0xc7, 0x51, 0x41, 0x21, + 0x45, 0x31, 0x8b, 0x8a, 0x31, 0x48, 0x44, 0x89, 0x03, 0xbf, 0x41, 0x56, + 0xe2, 0xd3, 0xff, 0x00, 0xbc, 0x68, 0x25, 0x96, 0xd2, 0xd2, 0x30, 0xbd, + 0x2a, 0x74, 0x86, 0x35, 0xfe, 0x11, 0x48, 0x90, 0x64, 0xe6, 0x8e, 0x94, + 0xc4, 0x47, 0x8c, 0xd3, 0x84, 0x74, 0x86, 0x76, 0x1b, 0xa8, 0xc9, 0xf5, + 0xa0, 0xd4, 0x5a, 0x31, 0x48, 0x07, 0x88, 0xd8, 0xf6, 0xa9, 0x16, 0xdd, + 0xcd, 0x30, 0x24, 0x16, 0x9f, 0xde, 0x6a, 0x7f, 0x95, 0x02, 0x7d, 0xe2, + 0x28, 0x01, 0x0c, 0xf6, 0xd1, 0xf4, 0x1f, 0xa5, 0x30, 0xea, 0x3f, 0xdd, + 0x8e, 0x8b, 0x01, 0x19, 0xbd, 0xb8, 0x6e, 0x9c, 0x54, 0x12, 0x35, 0xcb, + 0x7f, 0x1d, 0x55, 0x90, 0x08, 0x90, 0x48, 0xdf, 0x78, 0xd5, 0xa5, 0x4c, + 0x52, 0x02, 0x55, 0xe2, 0xa5, 0x1c, 0xd0, 0x05, 0x0b, 0x94, 0xf9, 0xab, + 0x16, 0xfe, 0x2f, 0xdd, 0x33, 0x55, 0x30, 0x83, 0x33, 0xd1, 0x73, 0x4f, + 0xf2, 0x30, 0xbd, 0xf3, 0x58, 0xdc, 0xd8, 0xab, 0xe4, 0xb0, 0x6e, 0x6a, + 0xdd, 0xb1, 0xc8, 0xc1, 0xed, 0x4a, 0x48, 0x22, 0x49, 0x3f, 0x4e, 0x3b, + 0xd4, 0xe3, 0xee, 0x54, 0xb1, 0x8a, 0x9c, 0xd3, 0xa4, 0x87, 0x8c, 0xd3, + 0x4c, 0x19, 0x46, 0x61, 0x9a, 0xaa, 0x99, 0xf3, 0x2a, 0xfa, 0x02, 0x34, + 0x60, 0x3d, 0x2a, 0xc6, 0x6b, 0x13, 0x46, 0x41, 0x24, 0x6c, 0xfd, 0x05, + 0x3d, 0x2d, 0x8f, 0x7a, 0x4c, 0x11, 0x20, 0xb6, 0x45, 0xa7, 0x84, 0x0b, + 0x40, 0xc7, 0x6e, 0xc5, 0x34, 0xc9, 0x56, 0xa2, 0x27, 0x24, 0x30, 0xcb, + 0x4c, 0xf3, 0x0d, 0x6a, 0xa9, 0x99, 0x3a, 0x83, 0x79, 0x3d, 0xe8, 0x22, + 0xad, 0x44, 0xca, 0xe3, 0x29, 0xb5, 0x68, 0x90, 0xa5, 0xa0, 0x61, 0x45, + 0x20, 0x0a, 0xaf, 0xff, 0x00, 0x2d, 0xa9, 0x8c, 0x93, 0x14, 0xcc, 0x73, + 0x50, 0x01, 0xb6, 0x9a, 0x56, 0x8b, 0x81, 0x14, 0x9f, 0x28, 0xa8, 0x02, + 0x17, 0x6c, 0xd5, 0x08, 0x9a, 0x1b, 0x76, 0x90, 0xf4, 0xab, 0x70, 0xd8, + 0x3e, 0xf1, 0x52, 0x33, 0x4a, 0x1b, 0x60, 0x95, 0x61, 0x78, 0x34, 0x84, + 0x4f, 0x8c, 0x8a, 0x5c, 0x53, 0x00, 0xc5, 0x14, 0x80, 0x61, 0x14, 0x62, + 0x90, 0x0b, 0x59, 0x1a, 0xfd, 0xa9, 0xb9, 0x48, 0xb1, 0xd9, 0x8f, 0xf2, + 0xab, 0x83, 0xb1, 0x32, 0x31, 0x9a, 0xc2, 0x28, 0xa1, 0xf9, 0x8e, 0x5a, + 0xb3, 0x5e, 0xd7, 0x93, 0x83, 0x51, 0x72, 0xc6, 0x7d, 0x9d, 0x87, 0x4a, + 0x6e, 0xc7, 0x14, 0x05, 0xc3, 0x69, 0xee, 0x28, 0x14, 0x86, 0x6f, 0xe9, + 0xcf, 0xfb, 0xac, 0x55, 0xe0, 0xd4, 0xd1, 0x0c, 0x78, 0x6a, 0x76, 0xea, + 0x64, 0x86, 0xea, 0x43, 0x2e, 0x29, 0x0c, 0x3e, 0xd1, 0x50, 0xbc, 0xc5, + 0xa8, 0x10, 0xcd, 0xa6, 0xab, 0xcf, 0xc5, 0x00, 0x64, 0x6a, 0x1c, 0xf1, + 0x54, 0x7c, 0xba, 0x2e, 0x68, 0x90, 0x9e, 0x55, 0x37, 0xcb, 0x22, 0x80, + 0xb0, 0x98, 0x34, 0xf1, 0x1b, 0x1e, 0x94, 0x08, 0x7a, 0xdb, 0x48, 0xdd, + 0xaa, 0xc2, 0x69, 0xec, 0x7a, 0x9a, 0xa2, 0x2e, 0x4e, 0x9a, 0x72, 0xf7, + 0xa9, 0xd2, 0xd6, 0x34, 0xfe, 0x1a, 0x9b, 0x88, 0x97, 0x66, 0x29, 0x76, + 0xd0, 0x21, 0xd4, 0x50, 0x20, 0xa4, 0xc5, 0x00, 0x20, 0x14, 0xf0, 0x28, + 0x03, 0xb1, 0x5b, 0x67, 0xff, 0x00, 0x26, 0xa5, 0x16, 0x9e, 0xad, 0x41, + 0xa8, 0xef, 0x2e, 0x04, 0xfb, 0xc4, 0x1a, 0x69, 0xb9, 0xb6, 0x8f, 0xa0, + 0xfd, 0x28, 0x18, 0xc3, 0xa8, 0xff, 0x00, 0x71, 0x2a, 0x23, 0x7b, 0x70, + 0xdd, 0x38, 0xa3, 0x94, 0x06, 0x7f, 0xa4, 0x3f, 0x56, 0x34, 0xa2, 0xd8, + 0x9e, 0xa6, 0x98, 0x12, 0xad, 0xb2, 0xd4, 0xab, 0x02, 0xff, 0x00, 0x76, + 0x80, 0x24, 0x11, 0xd4, 0x4c, 0x3f, 0x79, 0x40, 0x12, 0x85, 0xe2, 0x97, + 0xcb, 0x34, 0x00, 0xf1, 0x15, 0x3f, 0x6e, 0x28, 0x02, 0xac, 0xe3, 0x71, + 0xac, 0x0d, 0x53, 0x70, 0x2c, 0x81, 0x4e, 0x18, 0x7a, 0x56, 0x9b, 0x89, + 0x14, 0xe0, 0x42, 0x3a, 0x8a, 0x9f, 0x8a, 0xe6, 0x92, 0x3a, 0x11, 0x0c, + 0xcc, 0x3a, 0x54, 0x70, 0xfc, 0x87, 0x9a, 0x4c, 0x48, 0x25, 0x6c, 0xb5, + 0x4e, 0x25, 0xf9, 0x40, 0xc5, 0x12, 0x2d, 0x12, 0xad, 0x49, 0xf3, 0x15, + 0xa5, 0x70, 0x21, 0xfb, 0x23, 0x37, 0xb5, 0x2a, 0x69, 0xc8, 0xa7, 0x27, + 0x93, 0x4f, 0x98, 0x14, 0x49, 0xc5, 0xbc, 0x6b, 0xda, 0x9d, 0xb5, 0x45, + 0x49, 0x41, 0xb8, 0x0a, 0x6e, 0xfa, 0xb5, 0x02, 0x39, 0xc4, 0xdd, 0x49, + 0x9a, 0xd1, 0x40, 0xc9, 0xd4, 0x1b, 0x4c, 0xad, 0x6c, 0x67, 0x70, 0xa4, + 0xa6, 0x01, 0x4a, 0x4d, 0x48, 0xc8, 0xe9, 0xb4, 0xc4, 0x34, 0x9a, 0x7a, + 0xf3, 0x48, 0x64, 0xde, 0x53, 0x7a, 0x53, 0x5a, 0x36, 0x03, 0xa5, 0x48, + 0x11, 0x66, 0xa0, 0x6f, 0xf5, 0xb4, 0xc0, 0x92, 0x9a, 0x6a, 0x46, 0x3d, + 0x69, 0x0d, 0x08, 0x08, 0x7c, 0x97, 0x9d, 0xba, 0x71, 0x56, 0xe3, 0xb1, + 0xe3, 0x9a, 0xa6, 0xc0, 0xb7, 0x6f, 0x6e, 0xb0, 0xf4, 0x15, 0x6b, 0x15, + 0x00, 0x3b, 0x14, 0x95, 0x42, 0x26, 0x46, 0xe2, 0x97, 0x75, 0x48, 0xc6, + 0x97, 0xa6, 0xef, 0xa0, 0x04, 0xdf, 0x4e, 0x06, 0x80, 0x0c, 0xd6, 0x76, + 0xaf, 0x26, 0xc8, 0x01, 0x1e, 0xf5, 0x48, 0x96, 0x60, 0xc8, 0xed, 0x25, + 0x20, 0x84, 0x9a, 0x82, 0x8b, 0x09, 0x67, 0xbc, 0x72, 0x0d, 0x59, 0x4d, + 0x35, 0x3a, 0xbd, 0x17, 0x01, 0xb7, 0x56, 0x91, 0x0b, 0x77, 0xc0, 0x19, + 0xc7, 0x15, 0xcd, 0x79, 0x4c, 0x1c, 0xf1, 0xdc, 0xd5, 0x74, 0x25, 0x6e, + 0x6a, 0xd8, 0xb6, 0xd5, 0xad, 0x28, 0xdf, 0x75, 0x24, 0x36, 0x49, 0x4f, + 0x0d, 0x54, 0x40, 0xd6, 0x7a, 0x88, 0xe6, 0x90, 0x08, 0xab, 0x52, 0xaa, + 0xd2, 0x01, 0x64, 0xe0, 0x56, 0x6d, 0xdc, 0xc1, 0x01, 0x26, 0x80, 0x31, + 0x66, 0x9c, 0x49, 0x25, 0x34, 0x73, 0x52, 0xcd, 0x90, 0xb4, 0x99, 0xa2, + 0xc0, 0xc7, 0x62, 0xa4, 0x49, 0x36, 0xf4, 0xa9, 0xdc, 0x56, 0x2c, 0xc7, + 0x77, 0x8e, 0xd5, 0x66, 0x3b, 0x85, 0x7a, 0x35, 0x25, 0xc4, 0x96, 0x93, + 0x35, 0xa1, 0x02, 0x6e, 0x14, 0x9b, 0xa8, 0x24, 0x5a, 0x28, 0x00, 0xc9, + 0x1d, 0xa9, 0x54, 0xe7, 0xb5, 0x02, 0x25, 0xc5, 0x19, 0xc5, 0x02, 0x3a, + 0x83, 0x77, 0x70, 0xdd, 0x38, 0xa6, 0xfe, 0xfd, 0xfa, 0xb9, 0xa6, 0x6e, + 0x28, 0xb7, 0xcf, 0x5a, 0x91, 0x6d, 0x94, 0x52, 0x02, 0x65, 0x84, 0x7a, + 0x53, 0x84, 0x74, 0x08, 0x77, 0x97, 0x4b, 0x85, 0xfe, 0xf5, 0x03, 0x0f, + 0x36, 0x35, 0xa4, 0xfb, 0x48, 0xec, 0x28, 0x00, 0xf3, 0x9c, 0xf6, 0xc5, + 0x39, 0x23, 0x24, 0xe4, 0xd0, 0x05, 0x90, 0x38, 0xa4, 0xa0, 0x03, 0x35, + 0x0c, 0x92, 0xd3, 0x11, 0x09, 0xa8, 0x9e, 0x14, 0x6e, 0xa2, 0x98, 0x15, + 0xa5, 0xb4, 0x5c, 0x70, 0x2b, 0x3e, 0xe2, 0xd4, 0xaf, 0x4a, 0x24, 0x69, + 0x06, 0x57, 0xfb, 0x3e, 0xe3, 0x52, 0xad, 0x9d, 0x73, 0xb3, 0x72, 0x45, + 0xb5, 0x5a, 0x78, 0x85, 0x45, 0x48, 0x0f, 0xc0, 0x14, 0x6e, 0x14, 0xec, + 0x31, 0x4b, 0x54, 0x7b, 0xeb, 0x45, 0x03, 0x27, 0x31, 0xbb, 0x8d, 0x27, + 0x35, 0xa2, 0x81, 0x9f, 0x38, 0x51, 0x56, 0x48, 0x51, 0x55, 0x61, 0x08, + 0x69, 0xb4, 0x00, 0x86, 0x9b, 0x9a, 0x40, 0x47, 0xe6, 0x8a, 0x63, 0x4c, + 0x2b, 0x3b, 0x94, 0x46, 0xd3, 0x0a, 0x8f, 0xce, 0x1e, 0xb4, 0x5c, 0x00, + 0x48, 0x1a, 0xb5, 0x6d, 0xa3, 0x53, 0x8a, 0xce, 0x52, 0x2a, 0x31, 0x3a, + 0x6b, 0xbd, 0x35, 0x52, 0x34, 0x2b, 0x8e, 0x14, 0x93, 0x59, 0x3a, 0x90, + 0x48, 0x2d, 0xc9, 0x26, 0xaa, 0x0e, 0xe9, 0x12, 0xce, 0x73, 0xcc, 0xf3, + 0x24, 0x24, 0x74, 0xa6, 0xb9, 0xf9, 0xa9, 0xdc, 0x76, 0x26, 0x19, 0x22, + 0x94, 0xc7, 0xc5, 0x4a, 0x60, 0x3a, 0x3c, 0x53, 0xe0, 0x29, 0x2b, 0x9f, + 0x6a, 0x04, 0x5c, 0x50, 0x07, 0x4a, 0x90, 0x55, 0x00, 0xb9, 0xc5, 0x2f, + 0x9a, 0x28, 0x01, 0x0c, 0xb5, 0x19, 0x91, 0x8d, 0x00, 0x27, 0x98, 0xde, + 0xb5, 0x34, 0x79, 0x22, 0x90, 0xc9, 0x31, 0x4d, 0xa0, 0x42, 0x35, 0x3e, + 0x3a, 0x40, 0x3f, 0x15, 0x4b, 0x52, 0x8c, 0x3a, 0xaa, 0x9f, 0xf3, 0xc5, + 0x5a, 0x21, 0x95, 0x3e, 0xc0, 0x31, 0xd6, 0xa5, 0x4b, 0x55, 0x5a, 0x86, + 0xcb, 0x25, 0x1b, 0x57, 0xa5, 0x31, 0xde, 0xa4, 0x0c, 0x9b, 0xc9, 0x82, + 0x9f, 0xbd, 0x54, 0x0b, 0x03, 0xd2, 0xac, 0x09, 0xed, 0x31, 0xe6, 0x63, + 0xd6, 0xb4, 0x56, 0x3a, 0x98, 0xb0, 0x63, 0xfa, 0x75, 0xa2, 0xb5, 0x33, + 0x12, 0xa2, 0x90, 0xf1, 0xc5, 0x24, 0x03, 0xa1, 0x27, 0x6e, 0x0f, 0x5a, + 0xb0, 0x38, 0x14, 0x86, 0x57, 0xb8, 0x7d, 0xdf, 0x2d, 0x65, 0xdf, 0x63, + 0xcb, 0xda, 0x68, 0x1a, 0x32, 0x9a, 0x2a, 0x45, 0x14, 0x8b, 0x1f, 0x49, + 0x8e, 0x68, 0x28, 0x90, 0x0e, 0x29, 0x6a, 0x09, 0x03, 0x42, 0xcb, 0xb1, + 0xb3, 0x4e, 0xc2, 0xb9, 0x60, 0x5d, 0xb9, 0xa7, 0x89, 0x19, 0xba, 0xb5, + 0x55, 0x88, 0x14, 0xff, 0x00, 0xbf, 0x4e, 0x8c, 0x65, 0xaa, 0xac, 0x49, + 0x6d, 0x13, 0x8a, 0x7f, 0x14, 0x99, 0x21, 0x8a, 0x31, 0x40, 0x0b, 0x51, + 0x3d, 0x16, 0x03, 0xb4, 0x09, 0x4f, 0x09, 0x41, 0xb0, 0xec, 0x01, 0xde, + 0x93, 0xcc, 0x8c, 0x50, 0x02, 0x1b, 0x81, 0xd9, 0x69, 0xbe, 0x73, 0x9e, + 0x82, 0x80, 0x1a, 0x7c, 0xe3, 0xde, 0xb9, 0xfb, 0x9d, 0x53, 0xca, 0xb8, + 0x2a, 0xd2, 0x55, 0x72, 0xfb, 0xa2, 0x4f, 0xde, 0xb1, 0xa7, 0xa7, 0xde, + 0xdb, 0xdc, 0x60, 0x6f, 0x15, 0xae, 0x91, 0x2d, 0x62, 0xa5, 0xd0, 0xb9, + 0x44, 0x94, 0x01, 0x4e, 0xad, 0x09, 0x17, 0x35, 0x1b, 0x1a, 0x04, 0x42, + 0xcf, 0x51, 0xd3, 0x00, 0xa2, 0x81, 0x8c, 0x35, 0x04, 0xb1, 0xe6, 0x98, + 0xd1, 0x5b, 0x6f, 0xb5, 0x1b, 0x4d, 0x65, 0xca, 0x6d, 0xcc, 0x34, 0x8a, + 0x84, 0xb9, 0xdf, 0x8a, 0xb5, 0x4c, 0x8f, 0x68, 0x32, 0xe5, 0xca, 0xa1, + 0xc5, 0x16, 0xfb, 0xb6, 0xf3, 0x56, 0xe3, 0x62, 0x39, 0xae, 0x4a, 0x6a, + 0x3a, 0x64, 0x85, 0x14, 0xc0, 0x28, 0xa0, 0x41, 0x45, 0x50, 0x08, 0x4d, + 0x30, 0x9a, 0x43, 0x23, 0x67, 0xc5, 0x20, 0xff, 0x00, 0x55, 0x4e, 0xc0, + 0x67, 0xaa, 0x33, 0xb9, 0xe6, 0xa0, 0x96, 0x62, 0xa7, 0x07, 0xad, 0x4c, + 0xa1, 0xd4, 0xab, 0x90, 0x99, 0x58, 0xf7, 0xa8, 0xdd, 0xda, 0xb9, 0xc0, + 0x96, 0xd2, 0x6f, 0x9f, 0x69, 0xef, 0x5b, 0x30, 0xce, 0xf1, 0x91, 0xcd, + 0x46, 0xe5, 0xa6, 0x69, 0x5c, 0xeb, 0xf7, 0xed, 0x6d, 0xb3, 0x78, 0x03, + 0x6e, 0xda, 0xe7, 0xb5, 0x3b, 0xcb, 0x89, 0xf8, 0x92, 0x53, 0x8f, 0x4a, + 0xb8, 0xab, 0x0f, 0xcc, 0x5b, 0x1c, 0x2a, 0x7c, 0xd5, 0x25, 0xcc, 0xa9, + 0xb7, 0xe5, 0xa8, 0x4d, 0x89, 0x8f, 0xfb, 0x7a, 0x05, 0xe0, 0x54, 0x2f, + 0x7c, 0xc6, 0x9a, 0x89, 0x44, 0x6d, 0x23, 0x95, 0xeb, 0x5a, 0x3a, 0x6c, + 0x65, 0x13, 0x9e, 0xf5, 0x6c, 0x92, 0xed, 0x2e, 0x69, 0x90, 0x3d, 0x95, + 0xb1, 0x40, 0x8c, 0xd3, 0x18, 0x86, 0x9e, 0xb1, 0x66, 0x91, 0x42, 0xf9, + 0x27, 0x35, 0x32, 0xa6, 0x05, 0x04, 0x92, 0xaa, 0xd4, 0x72, 0x75, 0xa0, + 0x44, 0x75, 0x22, 0xd2, 0x01, 0xf5, 0x4b, 0x50, 0xfe, 0x1f, 0xad, 0x51, + 0x24, 0x4b, 0x2f, 0xcb, 0xcd, 0x46, 0xf3, 0xe3, 0xf8, 0xab, 0x3b, 0x14, + 0x56, 0x6b, 0xd4, 0x15, 0x4e, 0x7b, 0xa6, 0x7f, 0xbb, 0x42, 0x02, 0x9b, + 0x2e, 0x4e, 0x69, 0x0e, 0x05, 0x3b, 0x95, 0x62, 0x1d, 0xce, 0x1f, 0x2a, + 0x71, 0x57, 0x62, 0xbe, 0x9c, 0x0f, 0x98, 0xe6, 0x95, 0xae, 0x04, 0xff, + 0x00, 0x6e, 0x24, 0x7c, 0xc9, 0x47, 0xdb, 0x2a, 0x85, 0xca, 0x39, 0x6f, + 0x13, 0xb8, 0xa9, 0x96, 0xea, 0x13, 0x4b, 0x51, 0x72, 0x92, 0x09, 0xa1, + 0xfe, 0xf5, 0x0d, 0x3c, 0x67, 0xf8, 0xa8, 0xe6, 0x17, 0x29, 0x56, 0x7b, + 0xa8, 0xd7, 0xa1, 0xcd, 0x65, 0xcc, 0xc6, 0x47, 0xa0, 0x69, 0x11, 0x62, + 0x9b, 0x81, 0x4a, 0xe5, 0x87, 0x14, 0xdd, 0xf8, 0xa4, 0x21, 0x86, 0x4a, + 0x4d, 0xc6, 0xae, 0xc2, 0xb8, 0xf1, 0x27, 0xa8, 0xa9, 0x01, 0x8d, 0xbd, + 0x28, 0x13, 0x1e, 0x23, 0xf4, 0x34, 0xe1, 0x01, 0xf5, 0xa7, 0x72, 0x09, + 0x92, 0x2a, 0xbb, 0x1a, 0x71, 0xd6, 0x99, 0x2c, 0x7d, 0x2d, 0x04, 0x0b, + 0x46, 0x28, 0x00, 0xc5, 0x26, 0xda, 0x00, 0xea, 0xbc, 0xe7, 0xec, 0x29, + 0x7f, 0x78, 0xdd, 0xe9, 0x9b, 0x8f, 0x10, 0x16, 0xea, 0x6a, 0x41, 0x6d, + 0x48, 0x43, 0xc4, 0x20, 0x54, 0x98, 0xc5, 0x00, 0x57, 0xbc, 0x97, 0xc9, + 0x81, 0x9a, 0xbc, 0xd6, 0xea, 0x76, 0x92, 0xe5, 0x89, 0xf5, 0x23, 0xaf, + 0xb9, 0xae, 0x85, 0xfc, 0x33, 0x35, 0xf1, 0x89, 0x6d, 0x75, 0x25, 0xbc, + 0xbb, 0x90, 0xe2, 0xbb, 0xad, 0x13, 0x56, 0x4b, 0x98, 0x42, 0xb1, 0xf9, + 0xab, 0xcf, 0xa9, 0xa4, 0xae, 0x77, 0x7c, 0x51, 0x36, 0x41, 0xa7, 0x66, + 0xb6, 0x47, 0x38, 0xb5, 0x1c, 0x87, 0x8a, 0xa4, 0x26, 0x56, 0xcd, 0x46, + 0x25, 0x56, 0x3c, 0x1a, 0x00, 0x7e, 0x69, 0x73, 0x4c, 0x00, 0xd3, 0x68, + 0x01, 0x36, 0x8a, 0x6b, 0x2d, 0x34, 0x04, 0x0e, 0xb5, 0x46, 0x51, 0x89, + 0x81, 0xad, 0x09, 0xea, 0x2c, 0x91, 0xef, 0x5a, 0x21, 0x18, 0x8e, 0x93, + 0x1a, 0x1e, 0x6a, 0x23, 0x40, 0x82, 0x8a, 0x06, 0x21, 0x35, 0x19, 0x93, + 0x14, 0x80, 0x4f, 0x32, 0x9a, 0xd2, 0xe0, 0x53, 0x03, 0x36, 0x6b, 0xf7, + 0x17, 0x7b, 0x41, 0x3b, 0x6b, 0x49, 0x3e, 0x61, 0x53, 0x3d, 0x19, 0x4b, + 0x61, 0x66, 0x0a, 0x22, 0xf7, 0xc5, 0x44, 0x0f, 0x6a, 0xb4, 0x4a, 0x1b, + 0x6a, 0xc1, 0x9c, 0xe0, 0x56, 0x7e, 0xa0, 0x37, 0xdc, 0x7e, 0x02, 0x9f, + 0x46, 0x4b, 0xd5, 0x95, 0xc4, 0x75, 0x15, 0xc7, 0x0b, 0x5c, 0x69, 0x96, + 0x43, 0x01, 0xc4, 0x9b, 0xab, 0x4a, 0x1b, 0x82, 0x13, 0x15, 0x56, 0xbb, + 0x2d, 0x12, 0x5c, 0x6a, 0x1f, 0xbb, 0xc6, 0x3a, 0x56, 0x64, 0xb7, 0x26, + 0x43, 0x55, 0xcb, 0x61, 0xf3, 0x13, 0x09, 0x36, 0xae, 0x0d, 0x3b, 0xe5, + 0x7e, 0x6b, 0x3d, 0x88, 0x1e, 0x29, 0x0d, 0x17, 0x34, 0x52, 0x27, 0xb7, + 0x5f, 0x33, 0x02, 0xb6, 0x93, 0x85, 0x14, 0x5f, 0x51, 0x31, 0xf4, 0xe8, + 0x86, 0xe6, 0xab, 0x24, 0xb2, 0x29, 0xc2, 0x98, 0x88, 0xd8, 0x7c, 0xd4, + 0xe5, 0xa4, 0x34, 0x4e, 0xa4, 0x52, 0xee, 0x5f, 0x51, 0x4a, 0xe0, 0x2e, + 0xf5, 0xf5, 0xa8, 0x1f, 0x93, 0x4c, 0x42, 0x0a, 0x75, 0x30, 0x1c, 0x0d, + 0x67, 0x6a, 0x93, 0xf9, 0x45, 0x3e, 0xbf, 0xd2, 0x98, 0x8a, 0x5f, 0x68, + 0x69, 0x3e, 0xe8, 0xc5, 0x54, 0xba, 0xdc, 0x5b, 0x04, 0xd4, 0x21, 0x90, + 0x84, 0xa4, 0x69, 0x11, 0x6a, 0x0d, 0x36, 0x2b, 0xb4, 0x99, 0xa6, 0x53, + 0x0b, 0x0f, 0x5a, 0x90, 0x50, 0x30, 0xa2, 0x98, 0x09, 0x45, 0x2b, 0x92, + 0x14, 0xd6, 0x22, 0x90, 0xc8, 0xc9, 0x15, 0x19, 0x92, 0x98, 0x11, 0x3c, + 0xc0, 0x54, 0x2d, 0x71, 0xe9, 0x55, 0xca, 0x4d, 0xc8, 0x8c, 0xac, 0x68, + 0xdf, 0x54, 0x48, 0xe0, 0xd5, 0x25, 0x20, 0x16, 0x97, 0x14, 0x0c, 0x70, + 0xc8, 0xe9, 0x52, 0x2c, 0xf2, 0x0e, 0xf4, 0x84, 0x4a, 0x2e, 0xdf, 0xbd, + 0x4c, 0x97, 0x39, 0xea, 0x48, 0xa0, 0x4e, 0x25, 0xb8, 0x5f, 0x23, 0xef, + 0x66, 0xac, 0x0a, 0x68, 0xc9, 0xa1, 0x77, 0x01, 0x46, 0x68, 0x24, 0x4c, + 0xd3, 0x77, 0x53, 0x03, 0xb3, 0x0a, 0x05, 0x3c, 0x53, 0x66, 0xe4, 0x80, + 0xd2, 0xd0, 0x21, 0x0d, 0x47, 0xbf, 0x9a, 0x43, 0x1b, 0x73, 0x17, 0x98, + 0x84, 0x11, 0x95, 0x35, 0xc3, 0xeb, 0xda, 0x4b, 0x5a, 0xbf, 0x99, 0x18, + 0xf9, 0x0d, 0x74, 0xd1, 0x77, 0x56, 0x31, 0x97, 0xbb, 0x23, 0x0c, 0xe4, + 0x1a, 0xbb, 0xa6, 0xde, 0x1b, 0x7b, 0xa5, 0x62, 0x78, 0xae, 0x7a, 0xd1, + 0xd0, 0xeb, 0xa4, 0xf5, 0x3b, 0xfb, 0x1b, 0xe4, 0xb9, 0xb7, 0x56, 0x07, + 0x9a, 0xb2, 0xb2, 0x66, 0xb1, 0xa7, 0xb1, 0x32, 0xdc, 0x94, 0x1a, 0x64, + 0xc7, 0x8a, 0xd5, 0x10, 0x51, 0xb9, 0x93, 0xcb, 0x89, 0x9b, 0xd2, 0xa9, + 0x69, 0x88, 0x7c, 0xc9, 0x1c, 0x9e, 0xbd, 0x3f, 0x3a, 0x72, 0xf8, 0x42, + 0x26, 0x86, 0x69, 0x77, 0x50, 0x02, 0x6e, 0xa3, 0x34, 0x0c, 0x5c, 0xd2, + 0x66, 0x80, 0x13, 0x15, 0x46, 0xed, 0x30, 0x73, 0x57, 0x12, 0x47, 0xb2, + 0x7c, 0xbf, 0x85, 0x44, 0xa2, 0x8e, 0x82, 0x11, 0xf8, 0xaa, 0xcf, 0x32, + 0x03, 0xf7, 0x85, 0x50, 0xc3, 0xce, 0x04, 0x71, 0x4c, 0x32, 0x35, 0x4a, + 0x01, 0xbb, 0xe9, 0x3a, 0xd2, 0x65, 0x12, 0xad, 0x05, 0x44, 0x9c, 0x1a, + 0x23, 0x2b, 0x03, 0x33, 0xae, 0x74, 0xb9, 0x03, 0xef, 0x8f, 0x9a, 0xd2, + 0xb5, 0x80, 0x98, 0x79, 0xa7, 0x57, 0x5b, 0x34, 0x28, 0x6c, 0x54, 0xbb, + 0x3f, 0xbf, 0x09, 0xe9, 0x4b, 0xb5, 0xb1, 0xef, 0x4c, 0x3a, 0x0f, 0xb4, + 0x84, 0xae, 0xe6, 0x38, 0xe6, 0xa3, 0xb9, 0xd3, 0x9d, 0xfe, 0x74, 0xab, + 0x4d, 0x6c, 0x4b, 0x32, 0x9f, 0x7c, 0x47, 0x0e, 0x2a, 0xb4, 0xd2, 0x8a, + 0xc1, 0xc2, 0xcc, 0xad, 0xc6, 0x27, 0xcd, 0x56, 0xe0, 0x1c, 0x50, 0x31, + 0x97, 0x08, 0x76, 0x1e, 0x2a, 0x90, 0x1c, 0xd6, 0xf2, 0x8e, 0x82, 0x45, + 0xc9, 0xe3, 0x7f, 0x28, 0x30, 0x1c, 0x0e, 0xb5, 0x02, 0x3e, 0x2b, 0x07, + 0xb0, 0xc7, 0xfd, 0xa3, 0xb5, 0x3b, 0xcf, 0x3e, 0x95, 0x9d, 0x80, 0xbd, + 0x67, 0x20, 0x4c, 0x39, 0xad, 0x34, 0xba, 0x0d, 0xd3, 0x15, 0x8f, 0x53, + 0x5d, 0xc9, 0x7c, 0xcf, 0xa5, 0x39, 0x2e, 0x36, 0x75, 0xc5, 0x69, 0x71, + 0x58, 0x71, 0xd4, 0x23, 0x15, 0x0b, 0x6b, 0x11, 0xad, 0x51, 0x03, 0x3f, + 0xb6, 0xa2, 0xfe, 0xf5, 0x30, 0xeb, 0x91, 0xfa, 0xd1, 0x66, 0x05, 0x59, + 0xbc, 0x43, 0xfd, 0xca, 0xaa, 0xda, 0xec, 0xc7, 0xb9, 0xad, 0x39, 0x45, + 0x72, 0x4b, 0x5d, 0x4e, 0x79, 0xe4, 0xda, 0xcf, 0x5d, 0x1d, 0xb6, 0xe3, + 0x18, 0xcd, 0x62, 0xfe, 0x22, 0x8b, 0x21, 0x31, 0x4b, 0x8a, 0xd1, 0x12, + 0x57, 0x96, 0x53, 0x1f, 0xf0, 0xd7, 0x3d, 0x7b, 0xaa, 0xf9, 0xf2, 0xe3, + 0x67, 0x4a, 0xa9, 0x2d, 0x02, 0x3b, 0x96, 0x2d, 0xef, 0x20, 0x23, 0xae, + 0x2a, 0xb5, 0xec, 0xea, 0x65, 0xf9, 0x6b, 0x9e, 0x37, 0x35, 0x65, 0x36, + 0x76, 0x6a, 0x4d, 0xbe, 0xb5, 0x4c, 0x61, 0x8a, 0x4a, 0x43, 0x01, 0x52, + 0x50, 0x21, 0x69, 0x2a, 0x84, 0x34, 0x9a, 0x63, 0x49, 0x49, 0x81, 0x1f, + 0x9b, 0x50, 0xbc, 0xe2, 0x9d, 0x89, 0x64, 0x2d, 0x71, 0xe9, 0x51, 0x19, + 0x09, 0xab, 0xb1, 0x17, 0x19, 0x9a, 0x4a, 0xa0, 0x16, 0x8a, 0x00, 0x5a, + 0x76, 0x69, 0x00, 0xf0, 0xd4, 0xf5, 0x6a, 0x06, 0x48, 0x0d, 0x3a, 0xa0, + 0x02, 0x9a, 0x5c, 0x0a, 0x60, 0x33, 0xed, 0x2c, 0xa7, 0x83, 0x57, 0x6d, + 0x35, 0x20, 0x4e, 0xd9, 0x68, 0x62, 0x34, 0x70, 0x24, 0x5c, 0x83, 0xc5, + 0x41, 0xb4, 0xa1, 0xe3, 0x8a, 0xa5, 0xa9, 0x90, 0x07, 0x97, 0xd6, 0x9d, + 0xf3, 0x37, 0x7a, 0x62, 0x3b, 0xbd, 0xd4, 0x66, 0x83, 0x52, 0x78, 0xf6, + 0xe2, 0xa5, 0xf9, 0x29, 0x01, 0x04, 0xec, 0x16, 0xaa, 0x97, 0xa6, 0xc4, + 0x89, 0x62, 0x93, 0xb1, 0xa8, 0x6f, 0x6d, 0x52, 0x68, 0xf6, 0xb0, 0xc8, + 0x34, 0x42, 0x56, 0x62, 0xa8, 0xae, 0x8e, 0x13, 0x57, 0xb0, 0x6b, 0x3b, + 0x9e, 0x73, 0xb4, 0xf4, 0xac, 0xec, 0x60, 0xd6, 0xd5, 0x57, 0x50, 0xa4, + 0xf4, 0x34, 0xf4, 0xed, 0x51, 0xad, 0x48, 0x19, 0xe2, 0xbb, 0x4d, 0x3a, + 0xee, 0x39, 0xed, 0xc3, 0x67, 0x9a, 0xe1, 0xf8, 0x19, 0xd0, 0xf5, 0x57, + 0x2d, 0x89, 0x69, 0x25, 0x7e, 0x2b, 0x74, 0x64, 0x66, 0xea, 0x32, 0x7e, + 0xe0, 0x8f, 0x5c, 0xd3, 0xac, 0x76, 0xa4, 0x1b, 0x47, 0xa9, 0x34, 0x48, + 0x6b, 0x62, 0x6d, 0xe2, 0x8c, 0xd0, 0x20, 0xa5, 0xcd, 0x00, 0x2e, 0x69, + 0x69, 0x80, 0xea, 0xaf, 0x74, 0xb9, 0x02, 0x9a, 0x25, 0x92, 0xec, 0xcc, + 0x55, 0x53, 0x18, 0x26, 0xa9, 0x6c, 0x2e, 0xa6, 0x6e, 0xa3, 0x79, 0xe5, + 0xa3, 0x2a, 0xe7, 0x76, 0x2b, 0x9a, 0x92, 0x69, 0x59, 0xfe, 0x62, 0x6b, + 0x6b, 0x59, 0x0a, 0x25, 0xeb, 0x09, 0x78, 0xc1, 0x35, 0xaf, 0x01, 0xdf, + 0xc5, 0x73, 0x6c, 0xcd, 0x65, 0xa8, 0xe7, 0xb6, 0x6e, 0xab, 0xd2, 0x9d, + 0x1c, 0x47, 0xbd, 0x6d, 0x52, 0xd6, 0xb9, 0x10, 0xec, 0x3e, 0x40, 0x91, + 0xaf, 0x26, 0xab, 0x24, 0xeb, 0xbb, 0xad, 0x60, 0x59, 0xa3, 0x03, 0x2c, + 0x8b, 0x52, 0x49, 0x19, 0xd9, 0xf2, 0x55, 0x41, 0xdc, 0x97, 0xa1, 0x94, + 0x96, 0xb2, 0xfd, 0xb3, 0xf7, 0xcb, 0xde, 0xb4, 0x3e, 0xc9, 0xc5, 0x6f, + 0xcb, 0xa8, 0x93, 0xd0, 0x6b, 0x47, 0xb6, 0x9d, 0x11, 0xf5, 0xac, 0xe4, + 0xac, 0x51, 0x05, 0xdd, 0xb4, 0x2c, 0xa4, 0xb2, 0xd7, 0x35, 0x79, 0xa7, + 0x49, 0xbb, 0x74, 0x63, 0x8a, 0x49, 0xdc, 0x56, 0xb1, 0x57, 0x98, 0xc6, + 0x3b, 0xd5, 0xdb, 0x4f, 0xf5, 0x64, 0xb5, 0x44, 0x95, 0x86, 0xb5, 0x3a, + 0x64, 0xb2, 0xb7, 0x7b, 0x0f, 0xba, 0x32, 0x6b, 0x09, 0xf4, 0x99, 0x11, + 0x1e, 0x60, 0x03, 0x46, 0xb9, 0xef, 0xef, 0x5a, 0xa9, 0xde, 0x16, 0x33, + 0x51, 0xe5, 0x98, 0x0f, 0x96, 0x33, 0x55, 0x0d, 0xba, 0x93, 0x58, 0x6c, + 0x6b, 0x2d, 0xc6, 0xfd, 0x95, 0x73, 0x47, 0xc8, 0x9d, 0x05, 0x65, 0x76, + 0xc4, 0x46, 0xd3, 0x0a, 0x44, 0xb9, 0xd9, 0x4e, 0xc6, 0xd1, 0x76, 0x1f, + 0xf6, 0xf9, 0x7a, 0x06, 0x34, 0xdf, 0xb4, 0xcd, 0xfd, 0xe3, 0x56, 0xa2, + 0x4b, 0x91, 0x19, 0x79, 0x18, 0xfd, 0xf3, 0x40, 0xb5, 0x91, 0xf9, 0xe2, + 0xaf, 0x44, 0x66, 0x3b, 0xec, 0x4f, 0xed, 0x47, 0xd8, 0xcf, 0xad, 0x1c, + 0xc1, 0x60, 0xfb, 0x18, 0x1d, 0x5e, 0x9d, 0xf6, 0x78, 0x97, 0xa9, 0xa3, + 0x98, 0x2c, 0x44, 0x24, 0x58, 0xa5, 0xca, 0x56, 0x9d, 0xa6, 0xbf, 0x24, + 0x43, 0x6f, 0xde, 0xc5, 0x65, 0x38, 0x5c, 0xb8, 0xb3, 0x4a, 0x0f, 0x11, + 0xab, 0x7f, 0xac, 0x5c, 0x56, 0x94, 0x3a, 0x9c, 0x32, 0xf4, 0xa9, 0xd6, + 0x23, 0x71, 0x25, 0x96, 0xea, 0x2f, 0x25, 0xb0, 0x6b, 0x8e, 0x91, 0x01, + 0x95, 0xbe, 0xa7, 0xf9, 0xd6, 0xbc, 0xde, 0xe8, 0xa1, 0x1d, 0x45, 0x10, + 0x8a, 0x5f, 0x28, 0x0a, 0xc2, 0xe6, 0xf6, 0x0c, 0x51, 0x4c, 0x43, 0x0d, + 0x36, 0x82, 0x40, 0x53, 0xf3, 0x8a, 0x60, 0x21, 0x7a, 0x89, 0xe5, 0xc5, + 0x3d, 0xc9, 0x2b, 0xbd, 0xc0, 0x15, 0x0b, 0x5c, 0x1e, 0xd5, 0x7c, 0xa4, + 0x36, 0x44, 0x5c, 0xb7, 0x5a, 0x65, 0x59, 0x21, 0x45, 0x00, 0x25, 0x2d, + 0x00, 0x14, 0xb4, 0x00, 0xb4, 0xb4, 0x80, 0x29, 0x45, 0x00, 0x3c, 0x35, + 0x3f, 0x77, 0x15, 0x36, 0x19, 0x13, 0x4d, 0xe9, 0x51, 0x97, 0x26, 0xaa, + 0xc2, 0x1b, 0x4b, 0x4c, 0x0b, 0xb6, 0x97, 0xcd, 0x0b, 0x7f, 0xb3, 0x5a, + 0x1f, 0x6d, 0x8d, 0x86, 0x6b, 0x3b, 0x59, 0x8a, 0x48, 0x95, 0x24, 0x57, + 0xfb, 0xa6, 0x94, 0xd5, 0x19, 0x9d, 0xa6, 0x4d, 0x49, 0x1c, 0x4e, 0xc7, + 0xa5, 0x51, 0xa1, 0x68, 0x46, 0x40, 0xa4, 0x67, 0x0b, 0x41, 0x37, 0x28, + 0xcc, 0xe5, 0x8d, 0x34, 0x35, 0x0c, 0xa4, 0x47, 0x3c, 0xfe, 0x50, 0x18, + 0xa5, 0x49, 0xa4, 0x75, 0xeb, 0x53, 0xd4, 0x2f, 0x72, 0xad, 0xf4, 0x0b, + 0x73, 0x19, 0x47, 0x5a, 0xe4, 0x75, 0x1b, 0x19, 0x6d, 0x1c, 0xef, 0x5c, + 0x2f, 0xad, 0x75, 0x47, 0xde, 0x8d, 0x8c, 0xbe, 0x19, 0x14, 0xc5, 0x68, + 0x58, 0xdf, 0xcb, 0x6e, 0xc3, 0x0d, 0xc5, 0x72, 0xce, 0x3a, 0x1d, 0x11, + 0x67, 0x61, 0xa7, 0xcf, 0xf6, 0x88, 0xb7, 0x54, 0xf3, 0x4e, 0x8b, 0x16, + 0x59, 0xc0, 0xf4, 0xc9, 0xa9, 0xa7, 0xa8, 0xa5, 0xb9, 0x8d, 0xa9, 0xdf, + 0x05, 0x65, 0xf2, 0xb0, 0xf4, 0x1d, 0x43, 0xec, 0xd0, 0x6e, 0xc7, 0xcc, + 0x6b, 0xa1, 0x53, 0xe6, 0x69, 0x13, 0x7b, 0x13, 0xe9, 0x53, 0x49, 0x72, + 0xa6, 0x47, 0xcf, 0x5f, 0x5f, 0x7a, 0xd0, 0x35, 0x8b, 0x5e, 0xf3, 0x28, + 0x29, 0x69, 0x88, 0x5a, 0x7d, 0x30, 0x1c, 0x29, 0xb3, 0x0f, 0x96, 0x9a, + 0x25, 0x8f, 0x87, 0xfd, 0x4f, 0xe3, 0x50, 0xa4, 0x79, 0x62, 0x29, 0xad, + 0x83, 0xa9, 0x4b, 0x54, 0xd1, 0xd6, 0x54, 0xca, 0x8e, 0x7d, 0xab, 0x99, + 0x6b, 0x53, 0x14, 0xa5, 0x66, 0xf9, 0x3d, 0xeb, 0xa7, 0xe2, 0x89, 0x92, + 0xde, 0xc5, 0x59, 0x18, 0x45, 0x2e, 0x15, 0xb3, 0x5a, 0xd6, 0xcf, 0xc8, + 0x39, 0xae, 0x4a, 0x9b, 0x9d, 0x10, 0xd8, 0xd8, 0xb7, 0x6d, 0xc0, 0x54, + 0xcd, 0x18, 0x23, 0x8e, 0xb4, 0x26, 0x4b, 0xd0, 0xcd, 0xb9, 0xb7, 0x79, + 0x32, 0x8e, 0x6a, 0x18, 0xec, 0xbc, 0xbe, 0xe6, 0xa9, 0xae, 0x84, 0xfb, + 0x42, 0xe5, 0xbe, 0x52, 0xb4, 0x61, 0x62, 0xc3, 0x9a, 0x9d, 0x8b, 0xdc, + 0xbf, 0x6b, 0x66, 0x27, 0x93, 0xa5, 0x68, 0x7f, 0x63, 0x2e, 0x2b, 0x68, + 0x4c, 0x86, 0xac, 0x43, 0x26, 0x8e, 0x8b, 0xc9, 0xac, 0xfb, 0xb8, 0x12, + 0x25, 0xe2, 0x94, 0xdd, 0xc0, 0xc1, 0xd5, 0x3c, 0xc6, 0x5d, 0xb1, 0xe6, + 0x9b, 0x0c, 0x6f, 0xe5, 0x61, 0x85, 0x27, 0x6b, 0x15, 0x72, 0x9e, 0xa3, + 0x69, 0x19, 0x8f, 0x20, 0x60, 0xd6, 0x68, 0x27, 0xa2, 0xd6, 0x72, 0xd5, + 0x04, 0x74, 0x67, 0x45, 0x63, 0x3e, 0x6d, 0xf1, 0x54, 0xe7, 0xd4, 0x4a, + 0xdb, 0x49, 0x6d, 0xb3, 0x3b, 0xb2, 0x3a, 0xd4, 0xc3, 0xe1, 0x2d, 0xbd, + 0x4a, 0xd1, 0x9d, 0xe9, 0x4d, 0x64, 0xc5, 0x65, 0x71, 0x32, 0x19, 0x98, + 0x2a, 0x1a, 0xa0, 0x5b, 0x71, 0xaa, 0x8a, 0x04, 0x26, 0xd3, 0x46, 0xca, + 0xb2, 0xc5, 0x58, 0xfb, 0x9a, 0x75, 0x51, 0x98, 0x99, 0xc5, 0x2f, 0xda, + 0x1b, 0xb5, 0x2b, 0x01, 0x0b, 0x5c, 0xb8, 0x3f, 0x78, 0xd3, 0x4d, 0xc3, + 0xfa, 0xd1, 0xca, 0x17, 0x13, 0xcd, 0x73, 0xde, 0x98, 0x4d, 0x30, 0x15, + 0x73, 0x56, 0x6d, 0xe1, 0xf5, 0xa8, 0x94, 0x8a, 0x8a, 0x2f, 0xc5, 0x6f, + 0x57, 0x63, 0x01, 0x6b, 0x16, 0xcd, 0xed, 0x61, 0xec, 0xff, 0x00, 0x2e, + 0x2a, 0x8b, 0x8e, 0x69, 0xdc, 0x04, 0x14, 0x1a, 0x45, 0x0d, 0xa4, 0xc5, + 0x04, 0x89, 0x4d, 0x38, 0xaa, 0x11, 0x1b, 0x48, 0x05, 0x42, 0xf7, 0x1e, + 0x95, 0x4a, 0x06, 0x7c, 0xc5, 0x67, 0x9d, 0x8d, 0x45, 0x92, 0x7a, 0xd6, + 0xbc, 0xb6, 0x33, 0xe6, 0x13, 0x14, 0x62, 0x81, 0x5c, 0x5c, 0x52, 0xe2, + 0x81, 0x0b, 0xb6, 0x93, 0xcb, 0xa0, 0x43, 0x48, 0xc5, 0x36, 0x99, 0x41, + 0x4b, 0x48, 0x62, 0xd1, 0x48, 0x05, 0xa5, 0xa0, 0x07, 0x53, 0xbf, 0x86, + 0xa7, 0xa8, 0x15, 0xcf, 0x5a, 0x4a, 0xb0, 0x16, 0x8a, 0x00, 0x5a, 0x33, + 0x40, 0x16, 0x2d, 0x66, 0x68, 0xdc, 0x62, 0xad, 0x49, 0x78, 0x4d, 0x47, + 0x50, 0x68, 0xf5, 0x05, 0x0a, 0x3b, 0x54, 0xc1, 0xeb, 0x42, 0x04, 0x72, + 0x3f, 0x89, 0xc5, 0x55, 0x96, 0x44, 0xfe, 0x1e, 0x69, 0xdc, 0x45, 0x39, + 0x32, 0x4d, 0x25, 0x4b, 0x2d, 0x10, 0x5d, 0x28, 0x92, 0x32, 0x0d, 0x54, + 0xd3, 0x66, 0x90, 0x48, 0x63, 0xcf, 0xc8, 0x3f, 0xc6, 0x94, 0xb6, 0x08, + 0xee, 0x68, 0x3e, 0x0d, 0x32, 0xe2, 0xde, 0x3b, 0xab, 0x46, 0x89, 0xc7, + 0x5e, 0x2b, 0x4a, 0x6e, 0xd2, 0x46, 0x75, 0x15, 0xd1, 0xc2, 0x4d, 0x1f, + 0x95, 0x33, 0x27, 0xbf, 0xf5, 0xa6, 0xf4, 0xab, 0xab, 0xf1, 0x1a, 0x41, + 0xe8, 0x6c, 0xe8, 0x9a, 0x83, 0x47, 0xbd, 0x59, 0x8e, 0x31, 0xfd, 0x69, + 0x75, 0x6b, 0xa6, 0x97, 0x1b, 0x5b, 0xe4, 0x15, 0x95, 0x05, 0x6b, 0x97, + 0x3d, 0x4a, 0xf6, 0xfc, 0xbc, 0x31, 0xe3, 0xef, 0x39, 0xfe, 0x55, 0x73, + 0x52, 0x18, 0xb6, 0x80, 0x0f, 0xf3, 0xf2, 0xd6, 0xf4, 0x7e, 0x23, 0x29, + 0xad, 0x8d, 0x6d, 0x3f, 0x10, 0xc2, 0x16, 0xaf, 0x75, 0xae, 0x4e, 0xa6, + 0xac, 0x75, 0x2d, 0x32, 0x47, 0x0a, 0x5a, 0xa0, 0x0a, 0x59, 0x06, 0x63, + 0x34, 0xd0, 0x98, 0x42, 0x71, 0x1d, 0x47, 0x1b, 0x62, 0x71, 0x48, 0x7d, + 0x4d, 0x20, 0x16, 0x44, 0xed, 0x8a, 0xc7, 0xd5, 0xb4, 0xb4, 0x9d, 0x48, + 0xc5, 0x69, 0x46, 0x66, 0x35, 0x22, 0x71, 0x17, 0xba, 0x7c, 0xd6, 0x32, + 0x9d, 0xc3, 0xe5, 0xcf, 0x06, 0xac, 0x5a, 0xb9, 0xe0, 0x0e, 0xb4, 0x57, + 0x86, 0xb7, 0x46, 0xd4, 0x65, 0x74, 0x6f, 0x58, 0xb9, 0x23, 0x91, 0xcd, + 0x68, 0xa0, 0x27, 0xb5, 0x64, 0x8a, 0x90, 0x92, 0x26, 0x3a, 0xd5, 0x59, + 0x2b, 0x56, 0x71, 0xdb, 0x52, 0xdd, 0x94, 0x51, 0xec, 0xc9, 0x1c, 0xd4, + 0xf9, 0x02, 0xb2, 0x4c, 0xea, 0x2f, 0x69, 0xd7, 0x3b, 0x24, 0x15, 0xb6, + 0x2e, 0x57, 0x6e, 0x69, 0xc7, 0x70, 0x91, 0x4a, 0xee, 0xf3, 0x8e, 0x2b, + 0x0a, 0xf2, 0x46, 0x6e, 0xb5, 0x4c, 0x84, 0x53, 0x62, 0xa3, 0x92, 0x2b, + 0x3a, 0xeb, 0x55, 0xda, 0xbb, 0x51, 0x7a, 0xd6, 0x5a, 0x96, 0x66, 0xdc, + 0xdc, 0x3b, 0x2f, 0x27, 0xad, 0x53, 0x4e, 0xb4, 0x3d, 0x80, 0xd5, 0xb1, + 0x93, 0x1c, 0x54, 0x17, 0x89, 0x89, 0xcd, 0x3a, 0x7d, 0x86, 0xc7, 0x5a, + 0x21, 0x7e, 0x05, 0x17, 0x3b, 0xa3, 0x3b, 0x58, 0x73, 0x47, 0x28, 0x9b, + 0xd4, 0xce, 0x9f, 0x27, 0x35, 0x5d, 0x0e, 0x1a, 0x97, 0x42, 0xe2, 0x8b, + 0x1c, 0x1a, 0x8f, 0xbd, 0x49, 0xa5, 0x87, 0x37, 0x02, 0xa2, 0x35, 0xa1, + 0x83, 0x23, 0xa4, 0xa6, 0x03, 0x59, 0x73, 0x4e, 0x8e, 0x02, 0xd4, 0x9b, + 0xb0, 0xd2, 0x27, 0x5b, 0x4a, 0x90, 0x5a, 0x8f, 0x4a, 0xcf, 0x98, 0xd9, + 0x53, 0x24, 0x10, 0x01, 0x53, 0x44, 0x80, 0x1a, 0xca, 0x4c, 0xd1, 0x46, + 0xc5, 0x92, 0x46, 0x06, 0xda, 0x6e, 0xea, 0x10, 0x0b, 0x9a, 0x63, 0x0a, + 0x2e, 0x04, 0x74, 0x94, 0xc4, 0x34, 0xb5, 0x37, 0x24, 0xd5, 0x58, 0x86, + 0xc3, 0xca, 0x95, 0xba, 0x0a, 0x4f, 0xb0, 0x4c, 0xdd, 0x6b, 0x64, 0xac, + 0x60, 0xe6, 0x3c, 0x69, 0x3f, 0xde, 0x6a, 0x91, 0x74, 0xb8, 0xc7, 0xff, + 0x00, 0xaa, 0x9f, 0x31, 0x06, 0x76, 0xa7, 0x6e, 0x90, 0xb0, 0xd9, 0xfe, + 0x78, 0xaa, 0x20, 0x55, 0x30, 0x42, 0xed, 0xa5, 0xc5, 0x48, 0xc5, 0xc5, + 0x14, 0x00, 0x52, 0x8f, 0x9a, 0x80, 0x1d, 0xe4, 0x16, 0xa8, 0xa4, 0x5f, + 0x2f, 0x83, 0x45, 0xc0, 0x8a, 0x96, 0x82, 0x85, 0xa2, 0xa4, 0x05, 0xa5, + 0xa0, 0x62, 0xd3, 0xfb, 0x50, 0x22, 0xb1, 0xeb, 0x45, 0x50, 0x05, 0x14, + 0x00, 0xb4, 0x50, 0x04, 0xa9, 0x52, 0x54, 0x81, 0xea, 0xbb, 0x98, 0xd2, + 0x3b, 0x32, 0x2e, 0x4b, 0x56, 0xe9, 0x19, 0x36, 0x73, 0x97, 0x17, 0x57, + 0x37, 0x52, 0xb2, 0xa4, 0x8d, 0x81, 0x56, 0xf4, 0xab, 0x82, 0xc4, 0xc6, + 0x6b, 0x2a, 0xbe, 0x46, 0xb1, 0x7a, 0x1a, 0x4c, 0xb5, 0x0b, 0x53, 0x24, + 0x82, 0x5e, 0x54, 0xd5, 0x0b, 0x47, 0xf2, 0xee, 0x19, 0x5f, 0xa9, 0xa4, + 0xfe, 0x11, 0xad, 0xcd, 0x38, 0xc6, 0xee, 0x0d, 0x53, 0xd4, 0x2f, 0x06, + 0x9e, 0x57, 0x3f, 0x36, 0x7d, 0x2a, 0xa9, 0xea, 0x44, 0x8e, 0x71, 0x22, + 0x17, 0xd7, 0x2e, 0xc7, 0xb7, 0xf8, 0xd5, 0x4b, 0xbb, 0x57, 0xb7, 0x71, + 0xbf, 0xa7, 0x6a, 0xab, 0xf3, 0x19, 0x46, 0x7c, 0xb2, 0xe5, 0x35, 0xbc, + 0x31, 0x62, 0x97, 0x53, 0x91, 0x2f, 0xdd, 0xe3, 0x3f, 0x9d, 0x4d, 0xe2, + 0x3b, 0x14, 0xb4, 0xb8, 0x55, 0x87, 0xee, 0x37, 0x1f, 0xf8, 0xed, 0x3c, + 0x33, 0xbf, 0x32, 0x37, 0xa8, 0xf9, 0x64, 0x8a, 0xf6, 0x69, 0x9b, 0xa4, + 0x20, 0x7d, 0xcc, 0x35, 0x6a, 0xc9, 0x0a, 0xca, 0x10, 0x32, 0xe7, 0x15, + 0x2b, 0x70, 0x6c, 0x97, 0xee, 0xd4, 0xd1, 0xcb, 0x59, 0x34, 0x59, 0x65, + 0x5f, 0x34, 0xfe, 0xb4, 0x08, 0x76, 0x30, 0x29, 0x54, 0x8c, 0x53, 0x01, + 0x9e, 0x60, 0x53, 0xcd, 0x47, 0x25, 0xe2, 0xe3, 0x02, 0x98, 0x98, 0xd4, + 0x97, 0x34, 0x15, 0x24, 0xd2, 0x63, 0x45, 0xcb, 0x36, 0x21, 0xf1, 0x53, + 0xdc, 0x76, 0xa5, 0x00, 0x91, 0x42, 0xea, 0xc1, 0x2e, 0xd0, 0xab, 0x2e, + 0x73, 0x54, 0x63, 0xf0, 0xfd, 0xba, 0x3f, 0xdd, 0xad, 0xbd, 0xa3, 0xb1, + 0x0a, 0x36, 0x66, 0xd5, 0xa6, 0x9d, 0x04, 0x71, 0x70, 0x29, 0xbb, 0xe2, + 0x53, 0x8e, 0x95, 0x9f, 0x4b, 0x95, 0xd4, 0x8e, 0x50, 0x25, 0xaa, 0xb2, + 0x44, 0x2a, 0x65, 0x23, 0x68, 0x53, 0x08, 0x38, 0x24, 0x54, 0xad, 0x4a, + 0x24, 0x48, 0x96, 0xd1, 0x87, 0x99, 0x5a, 0xe9, 0x32, 0xf9, 0x75, 0x44, + 0xbd, 0x8c, 0xfb, 0xb3, 0xcf, 0x06, 0xab, 0xdd, 0x0f, 0xdd, 0x55, 0xb3, + 0x38, 0xa2, 0x84, 0xa3, 0x28, 0x71, 0x58, 0x12, 0xdb, 0xc8, 0xb2, 0x12, + 0xeb, 0x8e, 0x6a, 0x6d, 0x72, 0x9e, 0xe5, 0x49, 0x79, 0x35, 0x25, 0xb5, + 0xa4, 0x92, 0xfc, 0xca, 0x38, 0xa6, 0x97, 0x42, 0x8b, 0x50, 0xc4, 0xca, + 0xe2, 0xac, 0x98, 0xd5, 0x99, 0x77, 0x52, 0x94, 0x79, 0x47, 0xb8, 0xd9, + 0x8c, 0x56, 0xec, 0x3c, 0xa3, 0x96, 0xaa, 0x93, 0xb9, 0x91, 0xf2, 0xdc, + 0x9a, 0x96, 0x38, 0xab, 0x95, 0x24, 0x4a, 0xa6, 0xfc, 0x1a, 0x46, 0x82, + 0x83, 0x4e, 0x5e, 0xb4, 0x8a, 0x62, 0xc9, 0x51, 0x35, 0x68, 0x8e, 0x71, + 0x94, 0x50, 0x00, 0x2b, 0x46, 0x10, 0x0a, 0x66, 0xb1, 0xa8, 0x6f, 0x48, + 0x97, 0x6d, 0x18, 0xac, 0xae, 0x6c, 0x2e, 0x28, 0xc5, 0x50, 0x0e, 0xa3, + 0xa5, 0x48, 0x09, 0xbe, 0xa3, 0x69, 0xb1, 0x4d, 0x44, 0x86, 0xc8, 0x8c, + 0xd4, 0x0d, 0xcd, 0x5b, 0xa8, 0x98, 0xca, 0x64, 0xc9, 0x6e, 0x4f, 0xde, + 0xab, 0x09, 0x14, 0x6b, 0x4f, 0x63, 0x2b, 0x92, 0x79, 0xa8, 0xbd, 0xe9, + 0xad, 0x77, 0x12, 0xf7, 0xa9, 0x11, 0x09, 0xd4, 0xa2, 0xa8, 0x1f, 0x54, + 0xfe, 0xe8, 0xa7, 0xca, 0x33, 0x3e, 0xe6, 0x73, 0x70, 0x7e, 0x61, 0x50, + 0x62, 0xac, 0x81, 0x69, 0xb9, 0x14, 0x0c, 0x42, 0xf4, 0xdc, 0xd0, 0x51, + 0x22, 0xad, 0x49, 0x18, 0xa4, 0x4b, 0x2c, 0xc6, 0x2a, 0xa5, 0xe7, 0xfa, + 0xca, 0x71, 0x02, 0xad, 0x2d, 0x05, 0x85, 0x2d, 0x00, 0x14, 0xea, 0x00, + 0x5a, 0x7f, 0x6a, 0x40, 0x57, 0x6e, 0xb4, 0xda, 0x60, 0x2d, 0x14, 0x00, + 0x52, 0xd0, 0x03, 0xd0, 0xd4, 0xb5, 0x36, 0x03, 0xd6, 0x96, 0x33, 0x4d, + 0xba, 0x83, 0x30, 0xb7, 0x35, 0xd5, 0x0d, 0xcc, 0x26, 0x61, 0x5b, 0xd9, + 0xdc, 0x43, 0x23, 0xe1, 0x33, 0x93, 0xfd, 0x6a, 0xc5, 0x9d, 0xab, 0xc0, + 0xe5, 0xde, 0xa2, 0x71, 0xde, 0xc6, 0x8a, 0xc6, 0x87, 0x55, 0xaa, 0xcc, + 0x39, 0xa8, 0xe8, 0x04, 0x4f, 0xd2, 0xb3, 0xee, 0xad, 0xb7, 0x1d, 0xca, + 0x76, 0xb5, 0x24, 0x36, 0x11, 0xcf, 0x73, 0x0a, 0xe3, 0xad, 0x52, 0x9a, + 0xc2, 0x7b, 0xf9, 0xf7, 0xcc, 0xdf, 0x81, 0xe6, 0x9c, 0x6d, 0x11, 0x3d, + 0x5d, 0xcb, 0x49, 0x65, 0xe5, 0x11, 0x84, 0xa9, 0xee, 0x6c, 0xa3, 0xbb, + 0xb5, 0x68, 0xf6, 0xf3, 0x8e, 0x31, 0x45, 0xac, 0xee, 0x71, 0x56, 0xde, + 0xe6, 0x7d, 0x82, 0xcb, 0xa6, 0xb3, 0x20, 0x49, 0x39, 0xe0, 0x1c, 0x7b, + 0xd5, 0xe7, 0xb0, 0x9e, 0xfe, 0x3c, 0xb2, 0x73, 0x9e, 0x0d, 0x6d, 0x4e, + 0x3c, 0x8e, 0xe7, 0x4c, 0xa5, 0xce, 0xae, 0x5c, 0xb0, 0xd0, 0xcc, 0x2a, + 0x77, 0x1a, 0x9d, 0xe0, 0x58, 0x97, 0x00, 0x54, 0xb4, 0x51, 0x51, 0xa3, + 0xe6, 0x8c, 0x01, 0x58, 0xb3, 0x51, 0x7c, 0xc5, 0x5e, 0xf4, 0xf1, 0x78, + 0xa3, 0xbd, 0x40, 0xc8, 0xe4, 0xd4, 0x07, 0x6a, 0x87, 0xed, 0xaf, 0xda, + 0x82, 0xd4, 0x48, 0xcb, 0xb3, 0x77, 0xa4, 0x5e, 0x0d, 0x30, 0x91, 0x6a, + 0xdd, 0xbe, 0x71, 0x57, 0x29, 0x32, 0x47, 0x23, 0xec, 0x39, 0xa9, 0x65, + 0x9d, 0x5d, 0x28, 0x8e, 0xe2, 0x63, 0xb4, 0xd6, 0xf3, 0x24, 0xc5, 0x68, + 0xc9, 0x69, 0xbf, 0xee, 0xd5, 0xd3, 0x7a, 0x93, 0x3d, 0x08, 0xc5, 0xb4, + 0xe8, 0x31, 0x54, 0xe4, 0xd3, 0xdf, 0x3b, 0x98, 0xd6, 0x96, 0x26, 0xe4, + 0x43, 0x03, 0x8a, 0x8a, 0x5a, 0xe6, 0x96, 0xe7, 0x74, 0x36, 0x22, 0x8f, + 0xef, 0xd4, 0x93, 0x0c, 0x2d, 0x38, 0x1c, 0xf3, 0x24, 0xd3, 0xff, 0x00, + 0xd6, 0x8a, 0xd4, 0x92, 0x2f, 0x97, 0x81, 0x5a, 0x47, 0x73, 0x2a, 0x9b, + 0x15, 0x4a, 0xb1, 0x93, 0xa5, 0x3e, 0xe6, 0x3d, 0xd1, 0x62, 0xaa, 0x7a, + 0x31, 0x47, 0x54, 0x51, 0xf2, 0x29, 0x24, 0xb6, 0x57, 0x4c, 0x62, 0xb3, + 0xbd, 0x99, 0x6d, 0x68, 0x73, 0x3a, 0xbd, 0x83, 0x5b, 0x49, 0x95, 0xfb, + 0xb4, 0xb6, 0x17, 0x2f, 0x6f, 0x0f, 0x09, 0xf9, 0x8a, 0xd5, 0xae, 0xa4, + 0xa7, 0x74, 0x34, 0x5c, 0x3b, 0x31, 0xc2, 0xf5, 0xa1, 0xc4, 0x95, 0x33, + 0x91, 0x51, 0x56, 0x21, 0xf2, 0xf9, 0xcd, 0x48, 0x23, 0xae, 0x76, 0xcd, + 0xa2, 0x41, 0x72, 0x06, 0xde, 0x2a, 0x89, 0x43, 0x4d, 0x31, 0x8c, 0xc6, + 0x29, 0xea, 0x2a, 0x81, 0xec, 0x12, 0x54, 0x4d, 0x5a, 0x18, 0x0d, 0xa2, + 0x80, 0x0a, 0xb7, 0x64, 0xdc, 0xed, 0xac, 0xe6, 0x8d, 0x69, 0x6e, 0x5d, + 0xa5, 0xc5, 0x60, 0x74, 0x87, 0x14, 0xd2, 0xc2, 0x98, 0x88, 0x5e, 0x75, + 0x5a, 0xad, 0x25, 0xf2, 0x76, 0xaa, 0x50, 0x6c, 0xce, 0x53, 0x48, 0x83, + 0xed, 0x8c, 0xc6, 0x83, 0x2d, 0x6c, 0x95, 0x8e, 0x77, 0x2b, 0x8a, 0x26, + 0xa9, 0xd6, 0xf7, 0x6f, 0x6a, 0x76, 0x24, 0x1b, 0x50, 0x7e, 0xd5, 0x11, + 0xb9, 0x91, 0xbf, 0x8a, 0x8b, 0x12, 0x33, 0xcc, 0x6f, 0x5a, 0x43, 0xcd, + 0x16, 0xd4, 0x57, 0x12, 0x8a, 0x62, 0x1a, 0x6a, 0x32, 0xe0, 0x50, 0x55, + 0x88, 0xcb, 0xd2, 0x50, 0x50, 0xa0, 0x54, 0xa1, 0x28, 0x19, 0x2e, 0x38, + 0xa7, 0x45, 0xd2, 0x91, 0x04, 0xcb, 0xc5, 0x51, 0x9c, 0xfe, 0xf2, 0x92, + 0x19, 0x1e, 0x05, 0x36, 0xa8, 0xa0, 0xa2, 0x80, 0x1d, 0x45, 0x20, 0x1d, + 0x4e, 0x1d, 0x28, 0x02, 0x06, 0xeb, 0x49, 0x4c, 0x04, 0xa5, 0xa0, 0x02, + 0x8a, 0x00, 0x70, 0xa9, 0xc5, 0x20, 0x3d, 0x79, 0xa6, 0x1d, 0x8d, 0x47, + 0xf6, 0x94, 0x6e, 0xa6, 0xb5, 0xb9, 0x9d, 0x89, 0x92, 0x68, 0x94, 0x67, + 0x22, 0xa1, 0x94, 0x7d, 0xa0, 0xfc, 0xa6, 0xaa, 0xe4, 0x58, 0x0c, 0x5b, + 0x56, 0xa9, 0x4c, 0x30, 0x69, 0x74, 0x1a, 0xdc, 0x80, 0xf3, 0x51, 0xb5, + 0x64, 0x6a, 0x45, 0x27, 0x4a, 0x6d, 0xb9, 0xf9, 0xa8, 0x03, 0x77, 0x4e, + 0xb7, 0x8e, 0x53, 0xf3, 0x01, 0x5a, 0x8b, 0xa5, 0xc1, 0xfd, 0xda, 0xda, + 0x9c, 0x8e, 0x7a, 0x91, 0x25, 0x1a, 0x74, 0x03, 0xf8, 0x45, 0x29, 0x86, + 0x34, 0xe8, 0xb5, 0xb1, 0x05, 0x59, 0xeb, 0x1e, 0xfb, 0xe4, 0x42, 0x69, + 0x33, 0x44, 0x54, 0xb7, 0x46, 0xb9, 0xce, 0xd1, 0xd2, 0xaa, 0x5e, 0x41, + 0x73, 0x1f, 0xdd, 0xce, 0x2b, 0x9d, 0x2e, 0x63, 0x7b, 0xd9, 0x94, 0x32, + 0xe7, 0xad, 0x39, 0x54, 0x9a, 0xca, 0xc6, 0xd7, 0x25, 0x11, 0xd4, 0xd1, + 0xc0, 0x7f, 0xbb, 0xfa, 0x55, 0x72, 0xdc, 0xcf, 0x98, 0x90, 0x43, 0xed, + 0x47, 0xd9, 0xfd, 0x69, 0xda, 0xc2, 0xb8, 0xd1, 0xfb, 0xa9, 0x05, 0x5e, + 0x53, 0x95, 0x15, 0x12, 0x29, 0x6c, 0x0d, 0xd2, 0xb3, 0xa5, 0xb9, 0x64, + 0x3d, 0x69, 0xa4, 0x06, 0x8e, 0x81, 0x3f, 0x99, 0x38, 0xfa, 0xd7, 0x5b, + 0x00, 0xe9, 0x51, 0x0d, 0xc2, 0xa2, 0x26, 0x93, 0xee, 0x1a, 0xcb, 0xbd, + 0x6f, 0x90, 0xd7, 0x52, 0x39, 0xce, 0x65, 0x66, 0xfd, 0xe3, 0x66, 0xa4, + 0x33, 0xe4, 0x57, 0x3c, 0xd7, 0xbc, 0x76, 0x46, 0x76, 0x44, 0x31, 0xc9, + 0xfb, 0xce, 0xb5, 0x35, 0xc5, 0xc2, 0x08, 0xba, 0xd2, 0x5b, 0x91, 0x2d, + 0x48, 0x2c, 0xef, 0x57, 0xcf, 0x00, 0x57, 0x5d, 0x01, 0xcc, 0x40, 0xd1, + 0x1f, 0x88, 0x89, 0xad, 0x08, 0x65, 0x7e, 0x6a, 0xbb, 0xf3, 0x57, 0x21, + 0x45, 0x0c, 0xd9, 0x49, 0xb2, 0xb3, 0x19, 0x97, 0x75, 0xb0, 0xc8, 0x55, + 0xb1, 0xd2, 0xa9, 0xbf, 0x94, 0xa9, 0xb4, 0x0a, 0x2f, 0xa8, 0xed, 0xa1, + 0x93, 0x0c, 0x91, 0xac, 0xc7, 0x91, 0xd6, 0xa7, 0x69, 0xa2, 0x3d, 0xea, + 0x5e, 0xe6, 0xaa, 0x24, 0x6d, 0x71, 0x1f, 0xad, 0x40, 0xf7, 0x04, 0xfd, + 0xda, 0x8f, 0x53, 0x44, 0x88, 0xc2, 0x16, 0xeb, 0x4b, 0xe5, 0x52, 0xb9, + 0xa5, 0x83, 0xc8, 0x14, 0x92, 0x44, 0x02, 0xf4, 0xaa, 0xbe, 0xa4, 0x49, + 0x68, 0x51, 0x93, 0xad, 0x42, 0xd5, 0xd0, 0x72, 0x0c, 0xa2, 0x80, 0x12, + 0xa6, 0xb7, 0x7d, 0x8d, 0x9a, 0x52, 0xd8, 0xa8, 0xee, 0x69, 0xf9, 0xa9, + 0x8e, 0xa2, 0xa2, 0x92, 0xed, 0x57, 0xb8, 0xae, 0x54, 0x8e, 0xa7, 0x2b, + 0x14, 0xe4, 0xd4, 0x7d, 0x2a, 0xac, 0x97, 0x6e, 0xdf, 0xfe, 0xba, 0xe8, + 0x8c, 0x4c, 0x1d, 0x42, 0x22, 0xcc, 0xdd, 0x4d, 0x1b, 0x6a, 0xcc, 0x5b, + 0x1c, 0x05, 0x2d, 0x04, 0x0b, 0x4e, 0xa0, 0x05, 0xa2, 0x81, 0x0b, 0x49, + 0x40, 0x08, 0x5c, 0x0a, 0x88, 0xcd, 0xe9, 0x41, 0x64, 0x65, 0xc9, 0xa6, + 0xd3, 0x28, 0x29, 0xc2, 0x80, 0x24, 0x15, 0x2a, 0x54, 0x88, 0x7b, 0x74, + 0xa5, 0x8b, 0xa5, 0x04, 0x93, 0x76, 0xaa, 0x13, 0x7d, 0xfa, 0x60, 0xb7, + 0x19, 0xda, 0x9b, 0x41, 0x61, 0x4b, 0x40, 0x0b, 0x45, 0x20, 0x14, 0x53, + 0xc7, 0x4a, 0x40, 0x42, 0xdd, 0x69, 0xb5, 0x42, 0x0a, 0x28, 0x18, 0x51, + 0x40, 0x0e, 0x4e, 0xb5, 0x3d, 0x26, 0x07, 0x71, 0x2e, 0xa0, 0x55, 0x38, + 0xeb, 0x4b, 0xa6, 0xdc, 0xb4, 0xb3, 0xfc, 0xc7, 0xa9, 0xad, 0x27, 0x1b, + 0x22, 0xd4, 0x74, 0xb9, 0xa3, 0x77, 0xfe, 0xa4, 0x7e, 0x35, 0xa5, 0xa6, + 0x27, 0xfa, 0x20, 0xfa, 0x9a, 0x97, 0xd0, 0xe7, 0xee, 0x4d, 0x22, 0xd6, + 0x6d, 0xd0, 0xc5, 0x6e, 0xc9, 0x45, 0x16, 0x6c, 0x53, 0x37, 0x57, 0x33, + 0x36, 0x18, 0xc6, 0xa0, 0x47, 0xc4, 0x94, 0x08, 0xd8, 0xd3, 0x2e, 0xb1, + 0x28, 0xe6, 0xba, 0x78, 0x5b, 0x2a, 0x29, 0xd3, 0x7e, 0xf0, 0xa6, 0x58, + 0xa8, 0xe4, 0x5a, 0xee, 0x47, 0x39, 0x4a, 0x65, 0xac, 0x7d, 0x46, 0x3d, + 0xd1, 0x30, 0xa9, 0x6c, 0xa4, 0x59, 0xf0, 0xfd, 0xb0, 0x8c, 0x90, 0xd5, + 0xa3, 0x7b, 0xa6, 0xa4, 0xc3, 0x28, 0x30, 0x6b, 0x9a, 0x8c, 0xb5, 0x66, + 0x95, 0xba, 0x18, 0xf7, 0x9a, 0x01, 0x65, 0xca, 0x28, 0xcd, 0x54, 0x8f, + 0x44, 0x3d, 0x1c, 0x73, 0x5a, 0x4b, 0xb8, 0xa3, 0x2e, 0x86, 0x8d, 0x97, + 0x86, 0xd3, 0xef, 0x4d, 0xfc, 0xab, 0x62, 0x2d, 0x3a, 0xda, 0x25, 0xc0, + 0x88, 0x56, 0x7c, 0xc3, 0x63, 0x7f, 0xb3, 0x6d, 0xf7, 0x67, 0x60, 0xae, + 0x5f, 0x56, 0x0d, 0x1c, 0x99, 0x5a, 0xdf, 0xe2, 0x46, 0x71, 0xdc, 0xcb, + 0x67, 0x2d, 0x57, 0x2d, 0x9f, 0xe4, 0xae, 0x29, 0x9d, 0xab, 0x62, 0x7a, + 0xc9, 0xba, 0x8c, 0x99, 0x78, 0xa6, 0xb6, 0x27, 0xa9, 0x67, 0x4a, 0xcd, + 0xbc, 0xc1, 0xab, 0xb5, 0xb0, 0xb8, 0x59, 0x50, 0x73, 0xcd, 0x60, 0xb4, + 0x66, 0xb3, 0x57, 0x45, 0x99, 0xa4, 0x54, 0x43, 0x9a, 0xc8, 0xba, 0x6d, + 0xd1, 0xb6, 0x2b, 0xb5, 0x6c, 0x71, 0x9c, 0xb3, 0xfc, 0xb2, 0x1a, 0x53, + 0x90, 0xb5, 0x9c, 0xb7, 0x3a, 0xa3, 0x0d, 0x08, 0xb0, 0xc7, 0xa5, 0x4d, + 0xfd, 0x98, 0xd3, 0x2f, 0xce, 0x69, 0x0a, 0x5a, 0x0f, 0x83, 0x4c, 0x30, + 0xb8, 0xc5, 0x74, 0x56, 0xd7, 0x0c, 0xb1, 0x05, 0x22, 0x8e, 0xb7, 0x25, + 0xbb, 0xa1, 0x7a, 0xd1, 0xb6, 0x94, 0x99, 0x21, 0x8a, 0x31, 0x52, 0x07, + 0x3f, 0xa8, 0x2e, 0x2f, 0x3f, 0x2a, 0xcd, 0x92, 0xe0, 0xac, 0xbb, 0x68, + 0x9e, 0xe5, 0xc3, 0x53, 0x24, 0xdb, 0xb3, 0x48, 0x48, 0xcd, 0x3c, 0x5b, + 0x9f, 0x7a, 0x87, 0x23, 0x65, 0x01, 0xeb, 0x6b, 0x52, 0xac, 0x20, 0x54, + 0x36, 0x6a, 0x87, 0xed, 0x02, 0x93, 0x15, 0x23, 0x12, 0x98, 0xfd, 0x28, + 0x44, 0xb3, 0x32, 0x51, 0xcd, 0x40, 0x6b, 0xb0, 0xe2, 0x19, 0x49, 0x40, + 0x05, 0x19, 0xc5, 0x00, 0x36, 0x49, 0x9f, 0xd6, 0xab, 0x92, 0x49, 0xa1, + 0x21, 0xdc, 0x4a, 0x5a, 0x04, 0x2e, 0x69, 0xea, 0x68, 0x11, 0x28, 0x02, + 0x97, 0x6d, 0x06, 0x62, 0xe2, 0x8c, 0x50, 0x20, 0xa4, 0x2c, 0x05, 0x03, + 0x22, 0x69, 0x7d, 0x2a, 0x32, 0xc6, 0x8b, 0x1a, 0x58, 0x4a, 0x6d, 0x03, + 0x0a, 0x28, 0x00, 0xa5, 0xa0, 0x42, 0xe6, 0xa7, 0x8e, 0x89, 0x20, 0x24, + 0x6e, 0x94, 0xf8, 0xba, 0x52, 0x44, 0x92, 0xb7, 0x4a, 0xce, 0x7e, 0xb4, + 0xd0, 0x96, 0xe3, 0x7b, 0x51, 0x41, 0xa0, 0x51, 0x48, 0x05, 0xa2, 0x90, + 0x0b, 0x4f, 0x14, 0x01, 0x13, 0x53, 0x6a, 0x84, 0x18, 0xa4, 0xa0, 0x62, + 0x52, 0xd0, 0x03, 0xd3, 0xad, 0x4d, 0x4a, 0xc0, 0x75, 0xdf, 0xd9, 0xf3, + 0x34, 0x98, 0xda, 0x7e, 0xb5, 0x72, 0xce, 0xc5, 0xed, 0xc8, 0x2d, 0x5d, + 0x75, 0xec, 0xcb, 0x53, 0xf7, 0x4b, 0x77, 0x2f, 0xfb, 0xb1, 0x5b, 0x9a, + 0x68, 0xff, 0x00, 0x45, 0x1f, 0x53, 0x5c, 0xd6, 0x7a, 0x1c, 0xfd, 0x19, + 0x3b, 0xad, 0x66, 0xde, 0x27, 0x15, 0xd0, 0x66, 0x8c, 0x59, 0xdb, 0x63, + 0x73, 0x55, 0x9a, 0xe9, 0x47, 0xad, 0x73, 0x4c, 0xe9, 0x89, 0x03, 0xde, + 0x31, 0xe9, 0x50, 0x79, 0x8e, 0x4d, 0x67, 0x72, 0xf9, 0x4b, 0x76, 0x72, + 0x95, 0x95, 0x73, 0x5d, 0xce, 0x97, 0x37, 0x99, 0x00, 0xa2, 0x2f, 0xdf, + 0x26, 0xa2, 0xf7, 0x4d, 0x41, 0xd2, 0x9a, 0xfd, 0x2b, 0xd1, 0x47, 0x13, + 0x29, 0xcc, 0x2b, 0x1f, 0x50, 0x6d, 0xbd, 0x2a, 0x64, 0x5c, 0x4b, 0x5a, + 0x73, 0x10, 0x77, 0x81, 0x5a, 0xf1, 0x4a, 0x64, 0xea, 0x2b, 0x92, 0x2a, + 0xda, 0x9b, 0x4c, 0x96, 0xa0, 0x6e, 0x26, 0x15, 0xb6, 0xe8, 0xc9, 0x5a, + 0xe3, 0xa3, 0xb8, 0x8e, 0x53, 0x85, 0x6a, 0x96, 0xb2, 0x34, 0x10, 0xb0, + 0x02, 0xb9, 0x5b, 0xd2, 0x24, 0x95, 0xab, 0x68, 0xe9, 0x13, 0x3f, 0xb4, + 0x56, 0x8f, 0x4a, 0xf3, 0x89, 0x38, 0x34, 0x87, 0x4d, 0x9a, 0x16, 0xe3, + 0x9a, 0x8d, 0x1a, 0x36, 0x52, 0xb0, 0xbf, 0x65, 0xb8, 0x23, 0x85, 0xfd, + 0x6a, 0xbc, 0x96, 0x72, 0xa3, 0x72, 0xb5, 0x1c, 0xa6, 0x8a, 0x48, 0x8f, + 0x69, 0x5f, 0x6a, 0xbf, 0x69, 0x7a, 0x61, 0x20, 0xe6, 0xb9, 0xe4, 0x8d, + 0xfa, 0x13, 0x49, 0xac, 0xee, 0x97, 0x61, 0xe7, 0x35, 0x15, 0xc5, 0xe9, + 0x09, 0xc7, 0x7a, 0xd9, 0x76, 0x39, 0xec, 0x65, 0xce, 0xdb, 0x9c, 0x10, + 0x28, 0x67, 0xf9, 0x31, 0x8a, 0x3a, 0x9d, 0x9a, 0x24, 0x3a, 0xdf, 0x99, + 0x16, 0xb6, 0x55, 0xc6, 0x05, 0x2e, 0xa7, 0x3d, 0x46, 0x48, 0xbb, 0x69, + 0xfc, 0x0a, 0x66, 0x43, 0x8c, 0x98, 0x15, 0x4c, 0xea, 0x6a, 0x1b, 0x15, + 0x0d, 0x14, 0x84, 0xfe, 0xd3, 0x5a, 0x3f, 0xb4, 0xd6, 0xb3, 0x2b, 0x94, + 0xcd, 0xbd, 0xb8, 0x12, 0xb6, 0x45, 0x67, 0x34, 0x79, 0x6c, 0xd3, 0x9c, + 0x8b, 0xa7, 0x1b, 0x07, 0x96, 0x3d, 0x29, 0xe1, 0x31, 0x59, 0x23, 0x5b, + 0x8c, 0x6c, 0x0a, 0x8c, 0xb5, 0x50, 0x26, 0x44, 0x65, 0xa6, 0x79, 0x82, + 0xa5, 0x22, 0x80, 0x4a, 0xb4, 0x17, 0x14, 0x09, 0x94, 0x27, 0xfb, 0xd5, + 0x58, 0xd7, 0x59, 0xc4, 0xc6, 0x1a, 0x6d, 0x30, 0x12, 0x8a, 0x00, 0x6b, + 0x0c, 0xd4, 0x24, 0x73, 0x4c, 0x42, 0x51, 0x48, 0x61, 0x4b, 0x40, 0x0b, + 0x9a, 0x91, 0x25, 0xf5, 0xa0, 0x56, 0x25, 0x0e, 0x0d, 0x35, 0xa5, 0x02, + 0x91, 0x3c, 0xa4, 0x2d, 0x36, 0x6a, 0x3c, 0x93, 0x4c, 0xa1, 0x69, 0xd8, + 0xa0, 0x62, 0x53, 0x28, 0x00, 0xa2, 0x80, 0x16, 0x96, 0x80, 0x0a, 0x9e, + 0x3a, 0x1b, 0x11, 0x23, 0x0e, 0x2a, 0x58, 0xbe, 0xed, 0x22, 0x47, 0xc9, + 0xc2, 0x56, 0x6b, 0xd3, 0x04, 0x03, 0xa5, 0x25, 0x05, 0x8b, 0x45, 0x20, + 0x0a, 0x29, 0x80, 0xb4, 0xe1, 0xd2, 0x90, 0x11, 0x37, 0x5a, 0x41, 0x4c, + 0x05, 0x34, 0xda, 0x00, 0x28, 0xa0, 0x07, 0xa7, 0x5a, 0x9a, 0xa4, 0x0f, + 0x56, 0x86, 0x1e, 0x7a, 0x52, 0xcb, 0x6f, 0x9e, 0xd5, 0xd6, 0xb5, 0x24, + 0xc8, 0xd4, 0xa2, 0x6d, 0xbc, 0x56, 0xd6, 0x93, 0x36, 0x62, 0x0b, 0x58, + 0xd5, 0xbd, 0xd0, 0x2d, 0x8d, 0x26, 0xe4, 0x55, 0x1b, 0xa5, 0xad, 0xd1, + 0xce, 0x73, 0x1a, 0xa2, 0xf2, 0x2b, 0x37, 0x15, 0xcb, 0x5b, 0x46, 0x75, + 0xd2, 0x7a, 0x06, 0xca, 0x5d, 0xb5, 0x8d, 0xcd, 0x19, 0x32, 0xa9, 0xae, + 0xa7, 0xc3, 0xf7, 0x1c, 0xed, 0x34, 0x9e, 0xe2, 0x7b, 0x1d, 0x32, 0x1e, + 0x29, 0x4f, 0x4a, 0xf4, 0xa2, 0xce, 0x09, 0x14, 0xe7, 0x35, 0x10, 0xb1, + 0x8d, 0xf9, 0x96, 0x94, 0x98, 0x22, 0xd2, 0xb4, 0x71, 0xae, 0x16, 0x84, + 0x90, 0x6e, 0xac, 0x8d, 0x11, 0x36, 0xe1, 0x50, 0x4d, 0xf3, 0x1a, 0xa8, + 0x10, 0xca, 0xd6, 0x3a, 0x7f, 0x93, 0x2c, 0x8e, 0xdc, 0x86, 0xe9, 0xf9, + 0xd5, 0x89, 0x54, 0xd5, 0x79, 0x95, 0xcc, 0x56, 0x2f, 0xf2, 0x90, 0x6a, + 0x8a, 0x5a, 0x82, 0xfc, 0x8e, 0xf5, 0x9d, 0xf4, 0x2b, 0xa9, 0xa4, 0x1a, + 0x38, 0x63, 0xe2, 0xb3, 0x7c, 0xed, 0xd3, 0x7a, 0x54, 0xfd, 0x92, 0x96, + 0xe5, 0x95, 0x95, 0x14, 0x7c, 0xcd, 0x54, 0x6f, 0x35, 0x28, 0x11, 0x4f, + 0xcd, 0x50, 0x8a, 0xb1, 0xcf, 0xdc, 0x6a, 0x42, 0x69, 0x38, 0x1c, 0x55, + 0x2b, 0x8d, 0x45, 0xa3, 0x3f, 0x2d, 0x43, 0x57, 0x67, 0x46, 0xc8, 0x8e, + 0x1b, 0xff, 0x00, 0x32, 0xee, 0x33, 0x20, 0xc7, 0x35, 0xaa, 0xf7, 0x31, + 0xca, 0x8a, 0x01, 0xa9, 0xbd, 0x98, 0xa2, 0x89, 0xe2, 0xb6, 0x59, 0x06, + 0x6a, 0x3b, 0xb8, 0x96, 0x15, 0xe3, 0xad, 0x74, 0x50, 0xf7, 0xcc, 0xaa, + 0xcf, 0x94, 0xa8, 0x27, 0x68, 0xfd, 0x69, 0x46, 0xaa, 0x54, 0xf3, 0x5d, + 0x72, 0xc3, 0xf5, 0x30, 0x55, 0xae, 0x5d, 0x8f, 0x53, 0x52, 0x82, 0x9d, + 0xfd, 0xa3, 0x9e, 0x95, 0xe7, 0x48, 0xec, 0xe4, 0x18, 0xd7, 0x6e, 0xd5, + 0x5c, 0xe4, 0x9a, 0x8b, 0x94, 0x90, 0x98, 0xa7, 0x8a, 0x96, 0x50, 0xc9, + 0x2a, 0x2c, 0xd0, 0x03, 0x09, 0xe6, 0x97, 0x76, 0x05, 0x20, 0x2b, 0x48, + 0xd5, 0x59, 0xa4, 0xa2, 0xc5, 0x22, 0x17, 0x9a, 0xab, 0xbc, 0xfe, 0xf5, + 0x51, 0x89, 0x2e, 0x44, 0x2d, 0x73, 0x8a, 0x8d, 0xaf, 0x49, 0xab, 0xf6, + 0x66, 0x5c, 0xe1, 0x14, 0x9b, 0xcd, 0x48, 0x6b, 0x43, 0x31, 0x86, 0x99, + 0x40, 0x09, 0x45, 0x00, 0x25, 0x42, 0xdd, 0x69, 0x88, 0x6d, 0x14, 0x0c, + 0x4a, 0x76, 0x29, 0x00, 0x52, 0x50, 0x02, 0x6e, 0x34, 0x94, 0xc4, 0x14, + 0xb4, 0x86, 0x3c, 0x51, 0x40, 0x05, 0x47, 0x40, 0x05, 0x2d, 0x36, 0x01, + 0x4e, 0xa4, 0x01, 0x53, 0xc5, 0xd2, 0x86, 0x22, 0x46, 0xe9, 0x53, 0x47, + 0xd2, 0x91, 0x01, 0x3f, 0xdc, 0xac, 0xc6, 0xaa, 0xe8, 0x08, 0x55, 0xa7, + 0x52, 0x34, 0x0c, 0x51, 0x8a, 0x00, 0x28, 0xa4, 0x01, 0x4e, 0x14, 0x01, + 0x0b, 0x75, 0xa0, 0x53, 0x10, 0xb4, 0x94, 0x00, 0x52, 0x50, 0x03, 0x96, + 0xa6, 0xa9, 0x63, 0x3d, 0xa6, 0xda, 0x0a, 0x7d, 0xca, 0x0c, 0x57, 0x6d, + 0x24, 0x63, 0x36, 0x61, 0x5f, 0x2f, 0x06, 0x9f, 0xa4, 0x9d, 0xac, 0x3e, + 0xb5, 0x85, 0x72, 0xe0, 0x6e, 0xff, 0x00, 0x0d, 0x53, 0xb9, 0xe9, 0x5a, + 0x47, 0x63, 0x03, 0x9a, 0xd5, 0x97, 0xe5, 0x35, 0x92, 0x05, 0x61, 0x58, + 0xea, 0xa4, 0x4a, 0x07, 0x14, 0x6d, 0xac, 0x6e, 0x6c, 0x58, 0x89, 0x2b, + 0x42, 0xc9, 0x8c, 0x2c, 0x0d, 0x48, 0x8e, 0x8a, 0xd6, 0xf5, 0xd8, 0x63, + 0x15, 0x6a, 0x49, 0x5f, 0x67, 0x35, 0xd7, 0x44, 0xe4, 0xa8, 0x88, 0xa3, + 0xe7, 0x9a, 0x94, 0xa1, 0x61, 0x5a, 0x90, 0x2a, 0xc7, 0x4b, 0xe5, 0x1a, + 0x00, 0xb1, 0x18, 0xe2, 0xab, 0x5e, 0x48, 0x10, 0xf5, 0xa9, 0xe8, 0x3e, + 0xa4, 0xe6, 0x40, 0x91, 0x02, 0x6a, 0x8c, 0xb3, 0xb3, 0xf0, 0x2a, 0x53, + 0xd0, 0x2d, 0xa8, 0xc4, 0x88, 0x9a, 0x71, 0x01, 0x28, 0x28, 0xad, 0x71, + 0x20, 0x11, 0x92, 0x4f, 0x15, 0xce, 0x5d, 0xeb, 0x1b, 0x64, 0x29, 0x6e, + 0xb9, 0x6f, 0x5e, 0x69, 0xda, 0xe8, 0x16, 0xe4, 0x3e, 0x75, 0xd4, 0xa3, + 0xe6, 0x7d, 0xbf, 0x4a, 0xcf, 0x9a, 0x36, 0x2f, 0x86, 0xf9, 0xab, 0x16, + 0xf4, 0x3a, 0x61, 0xb8, 0xe8, 0xe0, 0xa7, 0xb5, 0xaa, 0x3f, 0x51, 0x5c, + 0xfc, 0xc7, 0x43, 0x44, 0x2f, 0x60, 0x3f, 0x87, 0x8a, 0xaa, 0xd0, 0xcb, + 0x09, 0xc8, 0xab, 0xbd, 0xcc, 0xb6, 0x2c, 0x45, 0xad, 0xcd, 0x0a, 0xe3, + 0x15, 0x32, 0xea, 0x9e, 0x67, 0x2f, 0xf3, 0x7e, 0x15, 0xbe, 0x1f, 0xdd, + 0x67, 0x3e, 0x23, 0xde, 0x1e, 0x2f, 0x15, 0xbb, 0x55, 0x1b, 0xac, 0xc9, + 0x27, 0x02, 0xbd, 0x27, 0x56, 0xd1, 0x39, 0x29, 0xd1, 0x7c, 0xe4, 0xb6, + 0xf1, 0x95, 0x15, 0xa1, 0x08, 0xe2, 0xbc, 0x26, 0xee, 0xcf, 0x63, 0xa1, + 0x3e, 0xda, 0x6e, 0x70, 0x6a, 0xcc, 0xc8, 0x9d, 0xe9, 0x9b, 0x8d, 0x4b, + 0x65, 0x20, 0xce, 0x7a, 0xd2, 0x56, 0x77, 0x2a, 0xc4, 0x52, 0x4c, 0xa9, + 0x54, 0x9e, 0xf7, 0xde, 0xa9, 0x08, 0xa9, 0x2d, 0xd7, 0xbd, 0x55, 0x92, + 0xe8, 0x76, 0x35, 0xa2, 0x44, 0x39, 0x95, 0xda, 0xe0, 0xd4, 0x65, 0x8d, + 0x6c, 0x62, 0xdd, 0xc6, 0xd2, 0x53, 0xd8, 0x44, 0xb1, 0x1c, 0x35, 0x5b, + 0xed, 0x48, 0x06, 0x1a, 0x61, 0xa0, 0x06, 0xd1, 0x40, 0x05, 0x34, 0x8c, + 0xd0, 0x98, 0x06, 0xce, 0x2a, 0x13, 0x4c, 0x42, 0x53, 0xc5, 0x21, 0x85, + 0x34, 0xd0, 0x03, 0x69, 0x76, 0xd3, 0x01, 0xd8, 0xa5, 0xc5, 0x4d, 0xc0, + 0x5a, 0x4a, 0x2e, 0x01, 0x51, 0x9a, 0x60, 0x14, 0xe1, 0x40, 0x0b, 0x49, + 0x40, 0x21, 0x45, 0x5a, 0x4f, 0xbb, 0x43, 0x01, 0xc6, 0xa6, 0x5a, 0x46, + 0x42, 0x5c, 0x7d, 0xca, 0xcb, 0x3d, 0x69, 0x95, 0x11, 0xc9, 0x4b, 0x41, + 0x63, 0xe9, 0xc2, 0x90, 0x08, 0xd4, 0xca, 0x60, 0x14, 0xea, 0x40, 0x44, + 0xdd, 0x69, 0x29, 0x88, 0x5a, 0x5a, 0x00, 0x43, 0x4d, 0xa0, 0x07, 0xad, + 0x4b, 0x48, 0x67, 0xb7, 0x5a, 0xbe, 0x56, 0xa6, 0x95, 0x32, 0xb5, 0xdf, + 0x48, 0xe5, 0x9e, 0xe6, 0x05, 0xf2, 0xf5, 0xa8, 0x6c, 0xfe, 0x59, 0x45, + 0x73, 0xe2, 0x0d, 0xe0, 0x6f, 0xaf, 0x31, 0xd5, 0x4b, 0xa2, 0x00, 0xeb, + 0x4e, 0x1b, 0x18, 0xbd, 0xce, 0x57, 0x55, 0x9f, 0xcc, 0x7d, 0x8b, 0x8a, + 0xa8, 0x13, 0x8a, 0xe7, 0xab, 0xbd, 0x8e, 0xba, 0x6b, 0x41, 0xe1, 0x69, + 0xe1, 0x6b, 0x13, 0x42, 0x78, 0xd6, 0xb4, 0x21, 0xd9, 0x8c, 0x1a, 0x48, + 0x4c, 0xe8, 0x34, 0xf1, 0x0e, 0x06, 0xdc, 0x66, 0xa5, 0xd4, 0x1f, 0x11, + 0x7e, 0x75, 0xdb, 0x40, 0xe2, 0xaa, 0x25, 0x9a, 0xe6, 0x3e, 0x7a, 0xf5, + 0xa7, 0xca, 0xf8, 0x38, 0x15, 0x51, 0xd8, 0x19, 0x24, 0x3e, 0xf5, 0x2e, + 0xe1, 0x4e, 0x22, 0x64, 0x12, 0x5d, 0xaa, 0x1e, 0x39, 0xac, 0x6b, 0xb8, + 0xe6, 0x9e, 0xe0, 0x49, 0x9f, 0x97, 0xd2, 0xa8, 0x16, 0xe5, 0xed, 0xcc, + 0xca, 0x01, 0xa9, 0x62, 0x41, 0x58, 0x24, 0x5b, 0x1f, 0x2b, 0x88, 0xd6, + 0xb2, 0xef, 0x6e, 0xf0, 0x33, 0x9e, 0x2b, 0x5b, 0x12, 0x61, 0xde, 0xde, + 0x3d, 0xc2, 0xec, 0x07, 0x09, 0x54, 0xbe, 0x44, 0xe8, 0x2b, 0x29, 0xcb, + 0x4b, 0x1b, 0xc2, 0x02, 0xf9, 0x84, 0xd2, 0x6c, 0xe7, 0x26, 0xb9, 0x9b, + 0x3b, 0x23, 0x0b, 0x12, 0x62, 0x93, 0x15, 0x98, 0x0e, 0x02, 0x92, 0x48, + 0xb3, 0x40, 0x14, 0xe5, 0xb2, 0x57, 0xed, 0x51, 0xa6, 0x9f, 0xb5, 0x86, + 0x0d, 0x5a, 0x9d, 0x8c, 0xdc, 0x0b, 0x69, 0x66, 0x3a, 0x9a, 0x77, 0xd9, + 0xd5, 0x7a, 0x01, 0x57, 0xcf, 0x70, 0xb5, 0x88, 0x98, 0x73, 0x52, 0xc6, + 0xd8, 0xac, 0xca, 0x25, 0x2f, 0xc5, 0x46, 0x69, 0x89, 0x22, 0x36, 0x34, + 0xcd, 0xe2, 0xb2, 0x65, 0x91, 0xbc, 0xc0, 0x55, 0x29, 0x2f, 0x87, 0xaf, + 0xeb, 0x4e, 0x31, 0x0b, 0xd8, 0xcd, 0x9a, 0xfb, 0x7d, 0x55, 0x7b, 0x86, + 0x35, 0xd1, 0x18, 0x9c, 0xf2, 0x99, 0x11, 0x62, 0x69, 0xb5, 0x64, 0x06, + 0x29, 0x69, 0xd8, 0x04, 0xa5, 0xa0, 0x05, 0x1d, 0x6a, 0xe2, 0x1c, 0xad, + 0x20, 0x03, 0x4d, 0x34, 0x00, 0xca, 0x4a, 0x00, 0x4a, 0x5a, 0x40, 0x3a, + 0xaa, 0xbf, 0xde, 0xa6, 0x21, 0x2a, 0x41, 0x40, 0xc7, 0x53, 0x48, 0xa0, + 0x04, 0xdb, 0x4b, 0x48, 0x05, 0xa4, 0xa0, 0x02, 0x8a, 0x00, 0x6d, 0x30, + 0xd3, 0x00, 0xa7, 0x2d, 0x00, 0x3f, 0x14, 0xca, 0x00, 0x72, 0x75, 0xab, + 0x29, 0x40, 0x31, 0x5a, 0xa7, 0x4a, 0x46, 0x63, 0x2e, 0x7e, 0xe5, 0x66, + 0x9a, 0x63, 0x88, 0xe5, 0xa5, 0xa0, 0xb1, 0x69, 0x73, 0x45, 0x80, 0x09, + 0xa6, 0xd2, 0x01, 0x69, 0xd4, 0x01, 0x13, 0x75, 0xa2, 0x98, 0x83, 0x14, + 0x0a, 0x40, 0x3a, 0x9a, 0x45, 0x30, 0x05, 0xeb, 0x52, 0xd2, 0xea, 0x33, + 0xdb, 0x2c, 0x4f, 0xc9, 0x56, 0xa4, 0x6f, 0x96, 0xbb, 0x68, 0xec, 0x73, + 0x54, 0x31, 0x75, 0x05, 0xe6, 0xb3, 0x51, 0xc4, 0x72, 0xf2, 0x6b, 0x3c, + 0x41, 0xac, 0x0d, 0x5f, 0xed, 0x28, 0xd2, 0x2a, 0xc5, 0xbf, 0xd4, 0x1a, + 0x5c, 0xaa, 0x71, 0x58, 0xc6, 0x5a, 0x0f, 0x93, 0x53, 0x37, 0xcb, 0xcb, + 0x6e, 0x34, 0xed, 0xb5, 0xce, 0xce, 0x81, 0xca, 0x29, 0xf8, 0xe6, 0xa4, + 0x09, 0x10, 0x54, 0xeb, 0xc5, 0x30, 0x2c, 0x43, 0x76, 0xd1, 0x9a, 0xd0, + 0x17, 0xde, 0x76, 0xd4, 0x7a, 0xd2, 0x2f, 0x94, 0xca, 0x71, 0xb9, 0xa3, + 0x04, 0x83, 0xaa, 0x1f, 0xc2, 0x95, 0xfe, 0x76, 0xe9, 0x5d, 0x31, 0x77, + 0x39, 0xd9, 0x3a, 0x82, 0x16, 0xab, 0xb8, 0x91, 0xab, 0x48, 0xad, 0x09, + 0x6c, 0x8f, 0xec, 0xe4, 0x9f, 0x7a, 0x5b, 0xe7, 0xfb, 0x34, 0x1c, 0x2f, + 0x5a, 0x69, 0x5c, 0x2e, 0x36, 0xc5, 0x5e, 0x71, 0x92, 0x31, 0x56, 0xe5, + 0xdb, 0x6f, 0x1f, 0xbd, 0x44, 0x51, 0x52, 0x76, 0x31, 0xaf, 0x75, 0x24, + 0x5c, 0x96, 0xae, 0x76, 0xee, 0xf5, 0xe7, 0x7e, 0x7a, 0x54, 0xc9, 0xd8, + 0xd2, 0x9c, 0x46, 0x2a, 0xc8, 0xe2, 0x90, 0x44, 0x01, 0xf9, 0x8e, 0x2b, + 0x9f, 0x73, 0xb9, 0x35, 0x12, 0xa7, 0xdb, 0xa3, 0x0f, 0x8a, 0xb4, 0xb7, + 0xb6, 0xe0, 0x72, 0x6b, 0x3b, 0x3b, 0x8e, 0x75, 0x2f, 0xb1, 0x2a, 0xdd, + 0x40, 0xdf, 0xfe, 0xaa, 0x78, 0x68, 0x8f, 0x43, 0x45, 0xcc, 0x47, 0x6d, + 0x1d, 0x54, 0xd3, 0x6a, 0x59, 0xa2, 0x61, 0x4e, 0x51, 0x52, 0x50, 0xfd, + 0xb4, 0x85, 0x29, 0x5c, 0x76, 0x23, 0x68, 0xaa, 0x22, 0x31, 0x4c, 0x44, + 0x6f, 0x20, 0x51, 0x50, 0x35, 0xc7, 0xa1, 0xa4, 0x05, 0x69, 0x6f, 0x42, + 0xf5, 0x35, 0x46, 0x6d, 0x48, 0x0e, 0x95, 0xa2, 0xa7, 0x72, 0x5c, 0x8a, + 0x32, 0xdf, 0xc8, 0xf5, 0x5c, 0xb9, 0x6e, 0xb5, 0xb2, 0x85, 0x8e, 0x76, + 0xee, 0x32, 0x8a, 0x62, 0x0a, 0x5a, 0x76, 0x00, 0xa2, 0x80, 0x16, 0x8a, + 0x40, 0x15, 0x3c, 0x2d, 0x4c, 0x09, 0xa9, 0xa6, 0x90, 0x88, 0xcd, 0x36, + 0x80, 0x0a, 0x4a, 0x06, 0x3a, 0xa1, 0x93, 0xad, 0x08, 0x4c, 0x65, 0x48, + 0xb4, 0x0c, 0x5a, 0x28, 0x18, 0xb4, 0x94, 0x00, 0x94, 0x50, 0x20, 0xa4, + 0xa0, 0x02, 0xa3, 0x34, 0x20, 0x0a, 0x70, 0xa0, 0x07, 0xd3, 0x4d, 0x00, + 0x2a, 0x55, 0x84, 0xa0, 0x07, 0x35, 0x4e, 0x9d, 0x29, 0x19, 0x90, 0xdd, + 0xfd, 0xca, 0xa1, 0x4c, 0x71, 0x1c, 0xb4, 0xe1, 0x41, 0x62, 0xe2, 0x96, + 0x8b, 0x88, 0x69, 0xa4, 0xa4, 0x31, 0xd4, 0xb4, 0x80, 0x8d, 0xba, 0xd2, + 0x8a, 0x62, 0x0c, 0x52, 0x62, 0x98, 0x0b, 0x45, 0x00, 0x20, 0xeb, 0x52, + 0x8a, 0x43, 0x3d, 0x8b, 0x4b, 0x97, 0x30, 0xd5, 0x9b, 0x89, 0x0f, 0x15, + 0xd5, 0x87, 0xf8, 0x4c, 0x2a, 0x7c, 0x45, 0x2b, 0xce, 0x63, 0x15, 0xcf, + 0xde, 0x47, 0x33, 0xb8, 0x11, 0xf1, 0xcd, 0x69, 0x25, 0x74, 0x34, 0xec, + 0x46, 0x15, 0xc7, 0x12, 0x75, 0xa3, 0x8a, 0xe2, 0x6a, 0xc6, 0xf7, 0x1a, + 0x69, 0x2b, 0x36, 0x50, 0xe5, 0x34, 0xec, 0x54, 0x6c, 0x31, 0xe2, 0x9e, + 0xb4, 0x0c, 0x95, 0x45, 0x38, 0x64, 0x3d, 0x59, 0x24, 0xe2, 0xe0, 0x83, + 0xcd, 0x69, 0x5a, 0xdf, 0x0c, 0xfc, 0xc7, 0x34, 0xf9, 0xac, 0x44, 0xa3, + 0x73, 0x66, 0x27, 0x49, 0x17, 0x2b, 0x8a, 0x73, 0x2e, 0x6b, 0xae, 0x9c, + 0xee, 0x72, 0x38, 0xd9, 0x80, 0x50, 0x29, 0xb2, 0xc0, 0x92, 0xfd, 0xf1, + 0x9a, 0xbb, 0xd8, 0x42, 0x34, 0x91, 0x40, 0x9d, 0x40, 0x15, 0xce, 0x6b, + 0x3a, 0xc1, 0x20, 0xac, 0x1d, 0x6a, 0x63, 0xa6, 0xac, 0xab, 0x5d, 0x98, + 0x3e, 0x49, 0x90, 0xee, 0x91, 0x89, 0x3e, 0xf4, 0xfd, 0xb1, 0xc6, 0x33, + 0xd2, 0xb9, 0xa7, 0x3b, 0xb3, 0xb1, 0x14, 0xef, 0xb5, 0x58, 0xe1, 0x52, + 0x17, 0x93, 0x58, 0x77, 0x5a, 0x9c, 0xd3, 0xe4, 0x74, 0x53, 0xe8, 0x68, + 0x48, 0x4d, 0x95, 0x50, 0xd3, 0x5f, 0xef, 0x55, 0x22, 0x6e, 0xc4, 0x12, + 0xb2, 0xf4, 0x63, 0x52, 0xa5, 0xec, 0xc8, 0x78, 0x73, 0x53, 0xc9, 0x73, + 0x4e, 0x62, 0xca, 0xeb, 0x13, 0x63, 0xff, 0x00, 0xaf, 0x4f, 0x5d, 0x62, + 0x4c, 0xfc, 0xc4, 0x9a, 0xcd, 0xd2, 0x29, 0x4e, 0xc5, 0x88, 0x35, 0x8e, + 0x79, 0xad, 0xcb, 0x5b, 0x85, 0x95, 0x6b, 0x9a, 0x4b, 0x95, 0x9d, 0x31, + 0xd5, 0x16, 0x29, 0xac, 0xc0, 0x53, 0x02, 0xbc, 0xd7, 0x28, 0xbd, 0xeb, + 0x3a, 0x7b, 0xe1, 0x54, 0x91, 0x06, 0x7c, 0xf7, 0xea, 0x3b, 0xd6, 0x7c, + 0xb7, 0xec, 0xdd, 0x2b, 0x65, 0x13, 0x27, 0x32, 0xb3, 0x4a, 0xcd, 0xd4, + 0xd4, 0x79, 0xad, 0x4c, 0x6e, 0x14, 0x50, 0x01, 0x4b, 0x48, 0x04, 0xa5, + 0xa6, 0x01, 0x45, 0x30, 0x1d, 0x8a, 0x7a, 0xad, 0x20, 0x1d, 0x22, 0x60, + 0x54, 0x4a, 0x70, 0x68, 0x02, 0xca, 0x3e, 0x69, 0xc6, 0x81, 0x0c, 0x22, + 0x99, 0x48, 0x63, 0x68, 0xa0, 0x02, 0xa3, 0x7e, 0xb4, 0xc4, 0x32, 0x9e, + 0xb4, 0x86, 0x3a, 0x8a, 0x00, 0x28, 0xa0, 0x04, 0xa2, 0x90, 0x05, 0x14, + 0x00, 0x94, 0xc3, 0x4c, 0x04, 0xa7, 0x0a, 0x00, 0x75, 0x36, 0x80, 0x1c, + 0xb5, 0x3a, 0xd0, 0x0c, 0x52, 0x7e, 0x6a, 0xb2, 0x94, 0x8c, 0xca, 0xf7, + 0x67, 0x8a, 0xa5, 0x54, 0x38, 0x8f, 0x4a, 0x78, 0xa4, 0x58, 0x51, 0x83, + 0x45, 0x84, 0x34, 0xd1, 0x49, 0x8c, 0x29, 0xc2, 0x90, 0x11, 0xb7, 0x5a, + 0x51, 0x54, 0x21, 0xd4, 0x94, 0x08, 0x69, 0xa6, 0xe6, 0x81, 0x8a, 0x2a, + 0x5a, 0x06, 0x7a, 0xbe, 0x91, 0x27, 0xcb, 0x8a, 0xd6, 0x6d, 0xac, 0x05, + 0x5d, 0x09, 0x59, 0x11, 0x38, 0x5e, 0x45, 0x79, 0xb0, 0xdc, 0x76, 0xaa, + 0x93, 0x98, 0xe0, 0x84, 0x91, 0x8a, 0xeb, 0x5a, 0x9c, 0xf3, 0xec, 0x62, + 0xca, 0x09, 0x3b, 0x9a, 0xa3, 0xe2, 0xb9, 0x2a, 0x6e, 0x75, 0x43, 0x61, + 0xac, 0xde, 0xd4, 0xcc, 0x9f, 0x4a, 0xc8, 0xa1, 0xd1, 0xc5, 0x33, 0x74, + 0x5a, 0x9d, 0x20, 0x97, 0xb8, 0x1f, 0x9d, 0x3e, 0x41, 0x73, 0x93, 0x79, + 0x34, 0xf5, 0xb7, 0x3e, 0xb4, 0xb9, 0x47, 0xcc, 0x4b, 0xe5, 0x15, 0x14, + 0x8b, 0x1e, 0x69, 0xd8, 0x57, 0x14, 0xc4, 0x69, 0x9b, 0x48, 0xa2, 0xc5, + 0x73, 0x17, 0x20, 0xbc, 0x92, 0x3c, 0x56, 0x95, 0xbe, 0xa6, 0x3b, 0x9f, + 0xce, 0xa5, 0x7b, 0xa4, 0xc9, 0x5c, 0xb1, 0xfd, 0xa7, 0x15, 0x41, 0x73, + 0xad, 0xc5, 0x0c, 0x44, 0x81, 0xcd, 0x6c, 0xa6, 0x63, 0xec, 0xce, 0x66, + 0xe6, 0xfa, 0xe2, 0xed, 0xc9, 0x76, 0xe3, 0xd2, 0xa0, 0xc6, 0x2a, 0x2a, + 0x54, 0xb9, 0xd3, 0x1a, 0x76, 0x17, 0x9a, 0x82, 0xee, 0x27, 0x78, 0x48, + 0x5a, 0xc1, 0x3d, 0x4d, 0x24, 0xb4, 0x30, 0xe7, 0xd3, 0x27, 0xea, 0x71, + 0x55, 0x5e, 0xc6, 0x55, 0xfe, 0x1a, 0xe8, 0x52, 0xb9, 0x85, 0x86, 0x79, + 0x2e, 0x3b, 0x53, 0x1e, 0x26, 0xf4, 0xa6, 0x84, 0x45, 0xe5, 0xb0, 0xed, + 0x4d, 0xc1, 0xa2, 0xc3, 0x12, 0x9c, 0x05, 0x48, 0x17, 0x2d, 0x2c, 0xa4, + 0x99, 0xba, 0x1c, 0x57, 0x4f, 0x67, 0x6f, 0xe4, 0xa7, 0x5a, 0xe5, 0xa8, + 0xee, 0xce, 0xc8, 0x2b, 0x22, 0x59, 0x6e, 0x16, 0x31, 0xcd, 0x66, 0x4f, + 0xa9, 0x73, 0xc5, 0x25, 0x11, 0x36, 0x64, 0xdc, 0x5f, 0x77, 0xc9, 0xaa, + 0x32, 0x5e, 0x3b, 0x74, 0x3c, 0x57, 0x4a, 0x89, 0x84, 0xa6, 0x56, 0x24, + 0x93, 0xcd, 0x25, 0x59, 0x98, 0x51, 0x40, 0x09, 0x45, 0x30, 0x16, 0x8a, + 0x90, 0x0a, 0x5a, 0x00, 0x4a, 0x5a, 0x60, 0x48, 0x2a, 0x45, 0xa4, 0x03, + 0xa4, 0xfb, 0xb5, 0x57, 0x1c, 0xd0, 0x04, 0xb1, 0xe4, 0x1a, 0xb0, 0x0d, + 0x00, 0xc0, 0x8a, 0x89, 0x85, 0x02, 0x19, 0x45, 0x03, 0x12, 0x9a, 0xd4, + 0x08, 0x8a, 0x9e, 0xb4, 0xc6, 0x3a, 0x8a, 0x40, 0x14, 0x52, 0x01, 0x28, + 0xa2, 0xc0, 0x25, 0x2d, 0x00, 0x25, 0x25, 0x50, 0x06, 0x29, 0x69, 0x00, + 0xb8, 0xa4, 0xc5, 0x20, 0x01, 0x52, 0x07, 0xa5, 0x60, 0x63, 0xb7, 0xf3, + 0x56, 0x11, 0xc5, 0x04, 0x15, 0xee, 0xdb, 0x9a, 0xad, 0x54, 0x34, 0x28, + 0x38, 0xa9, 0x63, 0xe4, 0x50, 0x50, 0xea, 0x33, 0x83, 0x40, 0x86, 0x4a, + 0x72, 0xd4, 0xca, 0x43, 0x16, 0x9d, 0x48, 0x06, 0x37, 0x5a, 0x51, 0x54, + 0x21, 0x69, 0xa4, 0xd0, 0x03, 0x69, 0x28, 0x18, 0xe1, 0x52, 0x0e, 0x95, + 0x20, 0x7a, 0x3d, 0x94, 0x84, 0x36, 0x06, 0x6b, 0x7a, 0x31, 0x95, 0x19, + 0x6a, 0xa4, 0x8d, 0x79, 0x92, 0x2b, 0xcf, 0x2e, 0x24, 0xfb, 0xd8, 0x15, + 0x91, 0x79, 0x7d, 0x18, 0xcb, 0x1e, 0x47, 0xa2, 0xf5, 0xae, 0xa8, 0xec, + 0x71, 0x4f, 0xe2, 0x33, 0xbe, 0xd6, 0x6e, 0xe6, 0x08, 0xb9, 0xdb, 0x57, + 0xa3, 0xb4, 0x5e, 0xec, 0x6b, 0x07, 0xab, 0x36, 0xd9, 0x12, 0x3c, 0x30, + 0xa2, 0xf4, 0xaa, 0x98, 0x06, 0x4f, 0x6a, 0x52, 0xd8, 0x11, 0x6b, 0xed, + 0x51, 0x01, 0x8c, 0xd3, 0x0d, 0xc6, 0x7a, 0x54, 0xdc, 0x2c, 0x09, 0x37, + 0xcd, 0xcd, 0x4f, 0xf6, 0xa4, 0x5a, 0x45, 0x10, 0xbe, 0xa4, 0xbb, 0xb6, + 0xf1, 0xf9, 0xd3, 0xe3, 0xbe, 0x43, 0xc5, 0x29, 0x68, 0x09, 0x13, 0x79, + 0xd9, 0xa6, 0xef, 0x35, 0x3c, 0xc5, 0x72, 0x86, 0xfa, 0x4c, 0x9a, 0x9b, + 0x97, 0x60, 0xa6, 0x34, 0x7e, 0xd4, 0x93, 0x18, 0xdf, 0x2e, 0x97, 0xcb, + 0xa8, 0x6c, 0xb0, 0xd9, 0x4a, 0x40, 0xef, 0x48, 0x64, 0x05, 0xa3, 0xa5, + 0xf2, 0x15, 0x85, 0x5a, 0xd0, 0x96, 0x91, 0x1f, 0xd8, 0x22, 0x6e, 0xd4, + 0xd6, 0xd1, 0xe0, 0x6e, 0xab, 0x5b, 0x29, 0xd8, 0xc6, 0x51, 0x2a, 0xdc, + 0xe8, 0xf1, 0xed, 0x1b, 0x06, 0xdf, 0xa5, 0x67, 0xbe, 0x90, 0xe3, 0xbe, + 0x6a, 0x9d, 0x52, 0x54, 0x0a, 0x8f, 0xa6, 0xcd, 0x9f, 0xbb, 0x56, 0xec, + 0xb4, 0x67, 0x2d, 0x99, 0x78, 0x15, 0x95, 0x49, 0x9a, 0xd3, 0x89, 0xb5, + 0x14, 0x31, 0xdb, 0x2d, 0x54, 0xb9, 0xd4, 0x82, 0xf0, 0xa6, 0xb0, 0x8a, + 0x36, 0x6c, 0xc7, 0xb9, 0xbe, 0xc9, 0xf9, 0x8e, 0x6b, 0x3e, 0x4b, 0xa7, + 0x6e, 0x95, 0xd3, 0x18, 0x9c, 0xf3, 0x65, 0x66, 0x39, 0xeb, 0x49, 0x5b, + 0x10, 0x14, 0x94, 0x84, 0x25, 0x2d, 0x21, 0x85, 0x15, 0x42, 0x0a, 0x2a, + 0x46, 0x2d, 0x14, 0x80, 0x28, 0xaa, 0x02, 0x55, 0xa7, 0xe6, 0xa4, 0x43, + 0xdb, 0x95, 0xa8, 0x01, 0xc5, 0x31, 0x8b, 0x9a, 0x96, 0x3c, 0xd0, 0x04, + 0xc3, 0x9a, 0x64, 0x8b, 0x48, 0x92, 0x03, 0x49, 0x40, 0xc4, 0xa4, 0xa0, + 0x08, 0xda, 0x94, 0x53, 0x63, 0x43, 0xb3, 0x45, 0x20, 0x12, 0x8a, 0x00, + 0x5a, 0x4a, 0x04, 0x14, 0x53, 0x00, 0xa2, 0x86, 0x01, 0x45, 0x20, 0x16, + 0x8a, 0x00, 0x43, 0x4c, 0xa6, 0x01, 0x9a, 0x70, 0x90, 0x8a, 0x56, 0x01, + 0x33, 0x9a, 0x5c, 0x53, 0x01, 0xad, 0x53, 0x45, 0xf7, 0x29, 0x00, 0xfa, + 0x88, 0xd1, 0x70, 0x1b, 0xde, 0x92, 0x90, 0xc5, 0xa7, 0x0a, 0x00, 0x63, + 0x75, 0xa3, 0x34, 0xc4, 0x2d, 0x46, 0x68, 0x00, 0xa2, 0x81, 0x8e, 0x15, + 0x20, 0xa0, 0x0f, 0x5b, 0xfb, 0x32, 0xda, 0x29, 0x6e, 0x33, 0x54, 0x26, + 0xd4, 0x8a, 0xb6, 0x31, 0x9f, 0xc6, 0xba, 0xa6, 0xb9, 0x4c, 0x29, 0xbe, + 0x66, 0x67, 0xdc, 0x5d, 0xca, 0xcd, 0xc1, 0xaa, 0x8f, 0x6e, 0xb2, 0xf3, + 0x23, 0x56, 0x77, 0xd0, 0xd1, 0x8f, 0xb6, 0x78, 0xe0, 0x3c, 0x55, 0x9f, + 0xb5, 0xfa, 0x66, 0xa5, 0x09, 0x95, 0x6e, 0xaf, 0xcf, 0x4e, 0xbf, 0x5a, + 0x84, 0x5d, 0xbe, 0x3a, 0x7e, 0xb4, 0xdd, 0x31, 0x29, 0x11, 0x1b, 0x96, + 0xce, 0x49, 0x35, 0x13, 0x6a, 0x72, 0x29, 0xc2, 0x8f, 0xd6, 0x9f, 0xb2, + 0x2b, 0x98, 0x85, 0xb5, 0x09, 0xbe, 0x95, 0x19, 0xbb, 0x9c, 0xff, 0x00, + 0xcb, 0x43, 0x53, 0x6b, 0x0e, 0xe3, 0x3c, 0xc7, 0xcf, 0xdf, 0x35, 0xa1, + 0xa3, 0x2c, 0x92, 0xdd, 0x0f, 0x98, 0xe2, 0xb3, 0xad, 0xb1, 0xad, 0x2d, + 0xce, 0x94, 0x27, 0x02, 0x97, 0x6d, 0x73, 0x16, 0x3b, 0x65, 0x38, 0x44, + 0x4f, 0x41, 0x40, 0xcb, 0x31, 0xe9, 0xf2, 0x3f, 0x6a, 0x8e, 0xea, 0xd8, + 0xdb, 0xfd, 0xea, 0xdb, 0x94, 0xcf, 0x9f, 0x52, 0xb5, 0x15, 0xce, 0x6e, + 0x36, 0x99, 0x27, 0x4a, 0x10, 0x99, 0x44, 0xdb, 0x1d, 0xd5, 0x69, 0x14, + 0xd5, 0x30, 0x48, 0x99, 0x45, 0x48, 0x2a, 0x2e, 0x55, 0x86, 0x91, 0x9a, + 0x61, 0x8c, 0x7a, 0x51, 0x70, 0xb1, 0x1f, 0x94, 0xa2, 0xa0, 0xb8, 0xb8, + 0x8e, 0x04, 0xcd, 0x35, 0xa8, 0x6c, 0x62, 0x5e, 0xea, 0x06, 0x4c, 0xf3, + 0xc7, 0xb5, 0x64, 0xcd, 0x75, 0xe9, 0x5d, 0x11, 0x89, 0x8b, 0x65, 0x46, + 0x62, 0xd4, 0x95, 0xa1, 0x90, 0x86, 0x92, 0x98, 0x05, 0x25, 0x02, 0x0a, + 0x5c, 0x52, 0x18, 0xb8, 0xa4, 0xa6, 0x80, 0x4a, 0x5a, 0x00, 0x29, 0x68, + 0x01, 0x29, 0x69, 0x00, 0xf1, 0x4f, 0x14, 0x80, 0x97, 0xf8, 0x69, 0x82, + 0x2a, 0x04, 0x4a, 0x23, 0x02, 0x9d, 0x8a, 0x04, 0x37, 0xa1, 0xa9, 0x78, + 0x65, 0xa0, 0x0a, 0xae, 0xb8, 0xa8, 0xe8, 0x01, 0x29, 0x28, 0x18, 0xd3, + 0x49, 0x4c, 0x62, 0xd2, 0xd2, 0x10, 0x51, 0x40, 0x05, 0x14, 0xc0, 0x28, + 0xa4, 0x02, 0x51, 0x40, 0x06, 0x28, 0xa0, 0x61, 0x4b, 0x40, 0x82, 0xa3, + 0xa0, 0x04, 0xa2, 0x81, 0x8e, 0x5a, 0x75, 0x31, 0x0d, 0x6a, 0x96, 0x1f, + 0xbb, 0x48, 0x07, 0xf6, 0xa8, 0xa8, 0x01, 0x86, 0x8a, 0x06, 0x2d, 0x3a, + 0x90, 0x0c, 0x6a, 0x41, 0x4e, 0xc0, 0x49, 0xfc, 0x35, 0x0d, 0x02, 0x12, + 0x9d, 0x40, 0xc5, 0xa9, 0x29, 0x30, 0x3d, 0x37, 0x53, 0xbb, 0x77, 0x3b, + 0x73, 0x59, 0xbb, 0x47, 0x2e, 0x6b, 0xa6, 0xb6, 0xb2, 0xb1, 0x8d, 0x3f, + 0x76, 0x37, 0x2b, 0xb4, 0x9f, 0x3e, 0x4f, 0xdd, 0x15, 0x14, 0x7e, 0x7c, + 0xc7, 0x8f, 0xbb, 0xef, 0x55, 0xca, 0x47, 0x30, 0xa2, 0xd1, 0xde, 0x40, + 0x37, 0x6d, 0xfa, 0x55, 0xcf, 0xb3, 0x72, 0x06, 0x49, 0xfc, 0x2a, 0x89, + 0xb9, 0x05, 0xc5, 0xb0, 0x3c, 0x2f, 0x5a, 0x86, 0xe1, 0x56, 0xde, 0x23, + 0xf2, 0xd6, 0x84, 0xdc, 0xa0, 0xd7, 0x1b, 0x07, 0xff, 0x00, 0x5e, 0xa9, + 0xb1, 0xc9, 0x35, 0x93, 0x36, 0x48, 0x51, 0x49, 0x59, 0x58, 0xd0, 0x3e, + 0x83, 0x9a, 0xeb, 0x34, 0x1b, 0x2f, 0x22, 0x0d, 0xe4, 0x7c, 0xc6, 0xb9, + 0x6b, 0xbe, 0x87, 0x45, 0x25, 0xa5, 0xcd, 0x4d, 0x94, 0x6d, 0xac, 0x4a, + 0x16, 0xb4, 0x34, 0x98, 0x95, 0xe4, 0x62, 0xc0, 0x71, 0x8a, 0x40, 0xf6, + 0x34, 0x65, 0xb8, 0x8a, 0xdc, 0xe0, 0x57, 0x3d, 0xac, 0x5c, 0x19, 0xfe, + 0xed, 0x75, 0xde, 0xc7, 0x34, 0x62, 0xee, 0x53, 0x55, 0x38, 0xa7, 0xd7, + 0x19, 0xd8, 0x14, 0xda, 0x00, 0x6e, 0x29, 0xd4, 0x0c, 0x5a, 0x75, 0x21, + 0x85, 0x21, 0x38, 0xa0, 0x0c, 0xdb, 0xeb, 0xf1, 0x0a, 0xfc, 0xbc, 0x9a, + 0xe7, 0xee, 0xaf, 0x0b, 0xb6, 0x5f, 0x9a, 0xde, 0x28, 0xc5, 0xc8, 0xcc, + 0x96, 0xe0, 0xbd, 0x42, 0x2b, 0x74, 0x62, 0xc7, 0x52, 0x53, 0x01, 0x29, + 0xb4, 0x00, 0x94, 0x54, 0x80, 0x66, 0x9d, 0x9a, 0x04, 0x26, 0x69, 0x33, + 0x54, 0x30, 0xa5, 0xa4, 0x01, 0x45, 0x00, 0x14, 0x52, 0x01, 0xeb, 0x52, + 0x0a, 0x00, 0x91, 0x4d, 0x4b, 0x40, 0x83, 0x34, 0xb4, 0x08, 0x6b, 0x53, + 0x51, 0xf1, 0x40, 0x09, 0x27, 0x35, 0x01, 0xa1, 0x00, 0xdc, 0xd2, 0x50, + 0x50, 0x94, 0xa0, 0x50, 0x01, 0x45, 0x32, 0x42, 0x8a, 0x43, 0x0a, 0x33, + 0x40, 0x09, 0x9a, 0x37, 0x50, 0x02, 0x6e, 0xa5, 0xdf, 0x40, 0x09, 0xbe, + 0x8d, 0xd4, 0x00, 0x6e, 0xa7, 0xee, 0xe2, 0x80, 0x19, 0x9a, 0x69, 0xa0, + 0x04, 0xa2, 0x98, 0xc7, 0x2d, 0x3a, 0x90, 0x86, 0xb5, 0x4b, 0x09, 0xf9, + 0x68, 0x01, 0x69, 0x94, 0x30, 0x18, 0x68, 0xa0, 0x62, 0xd2, 0xd4, 0x80, + 0xd7, 0xa6, 0x8a, 0xa0, 0x24, 0x6f, 0xb9, 0x51, 0x50, 0x20, 0xa5, 0x14, + 0x0c, 0x5c, 0xd3, 0xe9, 0x01, 0xe8, 0xd2, 0x21, 0x63, 0xbd, 0xeb, 0x36, + 0xe2, 0x4f, 0x35, 0xbc, 0xb5, 0xfb, 0xbd, 0xeb, 0xaa, 0x3a, 0xbe, 0x63, + 0x9e, 0x5d, 0x84, 0x58, 0x8b, 0x9f, 0x25, 0x39, 0x53, 0xe9, 0x57, 0x45, + 0xa8, 0x8c, 0x04, 0x40, 0x72, 0x6b, 0x43, 0x33, 0x46, 0x1b, 0x3f, 0x22, + 0x0d, 0xc5, 0x23, 0xdd, 0xeb, 0x9a, 0x72, 0x42, 0xb1, 0x23, 0x49, 0xe6, + 0xe3, 0xda, 0x9a, 0x64, 0xb3, 0x35, 0xbc, 0xbd, 0xfb, 0x98, 0xb6, 0x41, + 0xaa, 0x17, 0x3f, 0xbc, 0x72, 0x48, 0xe3, 0xde, 0xa9, 0x05, 0x8c, 0xab, + 0x80, 0xac, 0xdc, 0x0e, 0x95, 0x0e, 0xca, 0xc6, 0x7b, 0x9b, 0xc4, 0x29, + 0xb5, 0x9b, 0x28, 0xbb, 0xa4, 0xda, 0xfd, 0xa6, 0xf1, 0x01, 0x1f, 0x28, + 0x35, 0xda, 0x5b, 0xc6, 0x12, 0x25, 0x51, 0xd0, 0x0a, 0xe0, 0xa9, 0xac, + 0x8e, 0xd8, 0xfc, 0x24, 0x84, 0x55, 0x7b, 0x89, 0x04, 0x29, 0xb8, 0xd1, + 0x15, 0x72, 0x5b, 0x28, 0xc9, 0xa9, 0xa2, 0x0c, 0xd4, 0x71, 0xf8, 0x94, + 0x40, 0xd8, 0x59, 0x76, 0xd5, 0x3a, 0x4c, 0x14, 0x91, 0x66, 0xd7, 0x53, + 0xfb, 0x74, 0xb5, 0x68, 0x8a, 0x8e, 0x62, 0xb9, 0x6c, 0x36, 0x98, 0x45, + 0x22, 0x82, 0x9b, 0x40, 0x08, 0x69, 0x05, 0x16, 0x01, 0xd4, 0x54, 0x14, + 0x26, 0x6b, 0x33, 0x51, 0xd4, 0x3c, 0xa1, 0xb5, 0x7a, 0xd6, 0x90, 0x8d, + 0xc9, 0x93, 0x39, 0xbb, 0x9b, 0xa2, 0xce, 0x49, 0x35, 0x42, 0x47, 0xdd, + 0x5d, 0x56, 0x39, 0xe4, 0x45, 0x4e, 0x15, 0x64, 0x8b, 0x49, 0x40, 0x05, + 0x34, 0xd4, 0x80, 0xda, 0x4a, 0x04, 0x82, 0x96, 0x9d, 0xc6, 0x14, 0x52, + 0x01, 0x68, 0xa4, 0x01, 0x4b, 0x4c, 0x02, 0x8a, 0x40, 0x2a, 0xd4, 0x82, + 0x80, 0x24, 0x5e, 0xb5, 0x2d, 0x02, 0x0a, 0x5a, 0x00, 0x4a, 0x89, 0xc6, + 0x39, 0xa0, 0x06, 0xe6, 0x9a, 0xd4, 0x0c, 0x65, 0x14, 0x08, 0x6d, 0x3c, + 0x30, 0xc5, 0x00, 0x30, 0x9a, 0x6e, 0x69, 0xee, 0x02, 0xe6, 0x93, 0x34, + 0x86, 0x26, 0x68, 0xcd, 0x00, 0x25, 0x14, 0x00, 0x51, 0x40, 0x09, 0x4b, + 0x4c, 0x05, 0xa6, 0xd0, 0x02, 0xd1, 0x8a, 0x40, 0x2e, 0x29, 0x31, 0x40, + 0x87, 0x2d, 0x3a, 0x80, 0x1a, 0xd5, 0x24, 0x3d, 0x0d, 0x00, 0x38, 0xd4, + 0x74, 0x00, 0xda, 0x29, 0x0c, 0x51, 0x4b, 0x40, 0x0d, 0x7a, 0x6d, 0x30, + 0x15, 0x8f, 0x14, 0xda, 0x00, 0x4a, 0x78, 0x14, 0x00, 0xec, 0x53, 0xa8, + 0x03, 0xd0, 0xf5, 0x19, 0x73, 0xfb, 0xb4, 0xea, 0x6a, 0x88, 0x4d, 0x9f, + 0xc3, 0xf3, 0x1a, 0xe9, 0x8a, 0x39, 0x59, 0xa5, 0xa7, 0xd8, 0x98, 0x17, + 0x7e, 0xee, 0x7e, 0xb5, 0xa1, 0x04, 0x0a, 0xff, 0x00, 0xbd, 0x9a, 0x46, + 0x03, 0xda, 0xb4, 0x44, 0x49, 0x99, 0x17, 0xd7, 0xe1, 0x2e, 0x30, 0x9f, + 0xbc, 0x51, 0xfd, 0xea, 0x8d, 0xee, 0x6e, 0x6e, 0xe3, 0x2a, 0x91, 0x44, + 0xa3, 0xd7, 0x75, 0x5c, 0xb4, 0x90, 0x2d, 0x8a, 0xc5, 0x67, 0xf3, 0x02, + 0x34, 0xbc, 0x54, 0x37, 0xce, 0x04, 0x7b, 0x43, 0x9d, 0xd5, 0x3d, 0x47, + 0xb9, 0x9b, 0x48, 0x71, 0x58, 0xbd, 0xcd, 0xc8, 0xd8, 0xd3, 0x7e, 0x95, + 0x0c, 0xa8, 0x9d, 0x5f, 0x87, 0xec, 0xfc, 0x98, 0x3c, 0xc3, 0xf7, 0x8f, + 0xf8, 0xd6, 0xe4, 0x75, 0xe6, 0xee, 0x76, 0xb1, 0x4d, 0x64, 0xeb, 0xdf, + 0xf1, 0xe2, 0xdf, 0x8d, 0x6f, 0x47, 0xe2, 0x39, 0xea, 0xfc, 0x27, 0x2f, + 0x2f, 0x4a, 0xce, 0x97, 0xad, 0x7a, 0x12, 0xd8, 0xe7, 0x8b, 0x36, 0xfc, + 0x31, 0x20, 0x87, 0x7f, 0xd3, 0xfa, 0xd6, 0xe9, 0xbe, 0x5a, 0xf2, 0xf9, + 0x7d, 0xe6, 0x7a, 0x12, 0x64, 0x7f, 0xda, 0x0b, 0x47, 0xdb, 0x47, 0xbd, + 0x57, 0x29, 0x37, 0x1b, 0xf6, 0xcf, 0x63, 0x4d, 0xfb, 0x67, 0xb1, 0xaa, + 0x51, 0x23, 0x98, 0x0d, 0xef, 0xfb, 0x26, 0xa3, 0x5b, 0xd2, 0x7f, 0x86, + 0x93, 0x88, 0xe2, 0xcb, 0x70, 0xc8, 0x5d, 0x6a, 0x6a, 0xc4, 0xd8, 0xce, + 0xd5, 0x2f, 0x84, 0x11, 0xe0, 0x7d, 0xea, 0xe5, 0xee, 0x67, 0xdc, 0xd9, + 0x35, 0xd1, 0x04, 0x60, 0xe4, 0x51, 0x27, 0x3d, 0x69, 0x2b, 0x63, 0x21, + 0x48, 0xe6, 0x8a, 0x00, 0x43, 0x49, 0x40, 0x05, 0x34, 0xd0, 0x03, 0x68, + 0xa4, 0x02, 0xd2, 0x55, 0x00, 0x51, 0x48, 0x05, 0xa2, 0x80, 0x0a, 0x5a, + 0x40, 0x14, 0x50, 0x02, 0xad, 0x48, 0x28, 0x01, 0xea, 0x6a, 0x5a, 0x00, + 0x5a, 0x28, 0x10, 0x53, 0x5b, 0xee, 0x1a, 0x04, 0x57, 0xcf, 0x34, 0x53, + 0x18, 0xda, 0x29, 0x00, 0xc3, 0x4d, 0xa0, 0x04, 0xa2, 0x98, 0x0b, 0x49, + 0x48, 0x61, 0x45, 0x30, 0x16, 0x8c, 0x52, 0x10, 0xb8, 0xa5, 0xc5, 0x00, + 0x32, 0x9e, 0x28, 0x01, 0x68, 0xc5, 0x03, 0x11, 0x69, 0x28, 0x10, 0x66, + 0x92, 0x98, 0x0a, 0xb4, 0xea, 0x43, 0x1a, 0x69, 0xd1, 0x1a, 0x00, 0x71, + 0xa6, 0xd0, 0x21, 0xb4, 0x50, 0x31, 0x68, 0xa0, 0x00, 0xd2, 0x50, 0x03, + 0x69, 0x31, 0x40, 0x05, 0x48, 0x28, 0x00, 0xdd, 0x49, 0x9a, 0x00, 0xef, + 0x91, 0x77, 0x39, 0x79, 0x2a, 0xd6, 0x9d, 0x6d, 0xe6, 0xcf, 0xba, 0x55, + 0x62, 0x05, 0x75, 0x1c, 0x86, 0xc7, 0x91, 0xe6, 0x61, 0x56, 0x11, 0xff, + 0x00, 0x02, 0x38, 0xa6, 0x6b, 0x17, 0xf2, 0x59, 0x59, 0xf9, 0x42, 0x28, + 0xc6, 0x78, 0xf9, 0x4d, 0x74, 0xc1, 0x6a, 0x61, 0x2d, 0x8e, 0x49, 0xb0, + 0x5c, 0x9f, 0x53, 0x57, 0x62, 0xb9, 0x8a, 0x35, 0xc0, 0xdd, 0x9a, 0xc2, + 0x6e, 0xf2, 0x36, 0x5b, 0x11, 0x49, 0x38, 0x1f, 0xc0, 0x33, 0x59, 0xb7, + 0x2f, 0xe6, 0x1c, 0x95, 0xc5, 0x52, 0x63, 0x48, 0xaf, 0x8a, 0x8d, 0xab, + 0x37, 0xa9, 0xa8, 0xcc, 0x55, 0xcd, 0x26, 0xd7, 0xed, 0x37, 0xa8, 0x31, + 0xf2, 0xe6, 0xb9, 0xaa, 0xbb, 0x44, 0xde, 0x92, 0xd4, 0xed, 0x63, 0x5d, + 0xb1, 0xa8, 0x1e, 0x95, 0x2a, 0xd7, 0x11, 0xb8, 0xe3, 0x59, 0x7a, 0xda, + 0xee, 0xb3, 0x61, 0xf5, 0xad, 0xa8, 0xfc, 0x46, 0x15, 0x76, 0x39, 0x79, + 0xc6, 0x06, 0x2b, 0x3a, 0x41, 0xf3, 0x57, 0x7c, 0x96, 0x87, 0x3c, 0x0d, + 0xdf, 0x0e, 0xdb, 0x16, 0x47, 0x7e, 0xd8, 0xfe, 0xb5, 0xa8, 0xf6, 0xb5, + 0xe7, 0xf5, 0x3b, 0x64, 0x33, 0xec, 0xc3, 0xd2, 0x9c, 0xb6, 0xf5, 0x7b, + 0x88, 0x9c, 0x5a, 0x67, 0xff, 0x00, 0xd5, 0x4b, 0xf6, 0x51, 0x53, 0x66, + 0x3d, 0x06, 0x9b, 0x74, 0xa4, 0xf2, 0x12, 0xa5, 0xb2, 0x92, 0x24, 0x55, + 0x0b, 0x55, 0xef, 0x6e, 0x56, 0xde, 0x12, 0xc6, 0xa2, 0x2a, 0xec, 0xa9, + 0x1c, 0x9d, 0xed, 0xd1, 0x9a, 0x42, 0xed, 0x59, 0xec, 0x77, 0x57, 0x5c, + 0x4e, 0x71, 0x29, 0x45, 0x36, 0x48, 0xfc, 0x71, 0x51, 0xd3, 0xb8, 0x09, + 0x45, 0x48, 0x0a, 0x72, 0x6a, 0x33, 0x4e, 0xe0, 0x36, 0x8a, 0x00, 0x7d, + 0x36, 0x8b, 0x80, 0x62, 0x8a, 0x2e, 0x02, 0x53, 0xa8, 0x00, 0xa5, 0x14, + 0x80, 0x29, 0x0d, 0x00, 0x02, 0xa5, 0x14, 0x00, 0xb5, 0x32, 0xf4, 0xa0, + 0x05, 0xa2, 0x81, 0x0b, 0x47, 0x6a, 0x04, 0x54, 0x3f, 0x7a, 0x8a, 0x60, + 0x25, 0x14, 0xae, 0x31, 0x86, 0x81, 0x40, 0x08, 0x69, 0x29, 0x8c, 0x5a, + 0x28, 0x10, 0x62, 0x9d, 0xb6, 0x90, 0x06, 0x29, 0x68, 0xb8, 0x0b, 0x49, + 0x40, 0x82, 0x8d, 0xb4, 0x0c, 0x5c, 0x52, 0xe2, 0x80, 0x13, 0x6d, 0x30, + 0x8a, 0x62, 0x0d, 0xb4, 0xb8, 0xa4, 0x30, 0xa2, 0x80, 0x18, 0xd5, 0x24, + 0x3d, 0xe8, 0x00, 0x6a, 0x6d, 0x00, 0x21, 0xa2, 0x81, 0x85, 0x2d, 0x2b, + 0x80, 0xec, 0x66, 0x82, 0x29, 0x88, 0x6e, 0x28, 0x34, 0x98, 0xc4, 0xa4, + 0xcd, 0x30, 0x12, 0x94, 0x0a, 0x00, 0xf4, 0x36, 0xf9, 0xa4, 0x11, 0xd6, + 0xbd, 0xa5, 0xce, 0xd0, 0x23, 0x49, 0x30, 0x7d, 0xab, 0xa9, 0xe8, 0xce, + 0x4d, 0xd0, 0xeb, 0xbb, 0xbf, 0x22, 0x13, 0x23, 0x34, 0x8d, 0x8f, 0xee, + 0xd7, 0x29, 0xa9, 0xdd, 0x34, 0xad, 0xe6, 0x7c, 0xdb, 0x7f, 0xdd, 0xae, + 0xa5, 0x1d, 0x0c, 0xba, 0x94, 0x7c, 0xf7, 0x28, 0x5b, 0x9c, 0x7b, 0xd4, + 0xb6, 0xf9, 0x61, 0x97, 0xe0, 0x57, 0x31, 0xb9, 0x5b, 0x69, 0x9e, 0x6e, + 0x1b, 0x8a, 0x99, 0xb9, 0xc0, 0xa7, 0xf6, 0x82, 0xe3, 0x1b, 0xa5, 0x40, + 0x6a, 0x64, 0x52, 0x0c, 0x13, 0xd2, 0xba, 0xaf, 0x0e, 0x69, 0xed, 0x1c, + 0x5b, 0xf6, 0xfc, 0xdf, 0xfd, 0x7a, 0xe5, 0xad, 0xd8, 0xea, 0xa5, 0xa6, + 0xa7, 0x44, 0xba, 0x7c, 0xed, 0xda, 0xa7, 0x5d, 0x2e, 0x4f, 0xef, 0x52, + 0xf6, 0x44, 0x7b, 0x54, 0x3b, 0xfb, 0x35, 0xbf, 0xbd, 0x55, 0x35, 0x0d, + 0x1c, 0xc9, 0x6e, 0x46, 0xe3, 0x5b, 0x52, 0xa6, 0x94, 0x8c, 0x6a, 0xd5, + 0xf7, 0x4e, 0x5a, 0xe3, 0x43, 0xbb, 0x24, 0xfc, 0xa2, 0xab, 0x2f, 0x86, + 0x6e, 0x5f, 0xa9, 0x02, 0xbb, 0x27, 0x63, 0x08, 0x4c, 0xe8, 0x34, 0x7d, + 0x0d, 0xad, 0xad, 0xf6, 0x75, 0xeb, 0x5a, 0x23, 0x49, 0x26, 0xb8, 0x94, + 0x0e, 0xa9, 0x55, 0x24, 0x1a, 0x38, 0xa9, 0x97, 0x4b, 0x51, 0x4e, 0xc4, + 0x73, 0x8f, 0x36, 0x91, 0xc4, 0xb9, 0xae, 0x73, 0x51, 0xbc, 0x54, 0x27, + 0x6d, 0x2e, 0x5d, 0x07, 0x19, 0xea, 0x62, 0xdc, 0xea, 0xcf, 0x9d, 0xa8, + 0xbf, 0xad, 0x5d, 0xb3, 0x9b, 0xcc, 0x5a, 0xe2, 0xa9, 0xb9, 0xdf, 0x4f, + 0x62, 0xce, 0xec, 0x57, 0x35, 0xac, 0x5e, 0x99, 0xa5, 0xda, 0x3a, 0x0a, + 0xba, 0x68, 0xce, 0xa3, 0x31, 0x1c, 0x92, 0x69, 0x36, 0xf1, 0x5b, 0x18, + 0x8e, 0x0b, 0x45, 0x3d, 0xc4, 0x1d, 0xaa, 0x3a, 0x06, 0x1c, 0xd2, 0x73, + 0x45, 0x80, 0x4e, 0x69, 0x3a, 0xd0, 0x03, 0x69, 0x3b, 0xd3, 0x60, 0x3e, + 0x8c, 0x52, 0xb0, 0x05, 0x36, 0x8b, 0x00, 0x94, 0xb4, 0x80, 0x29, 0x69, + 0x80, 0xb4, 0x52, 0x01, 0x29, 0xe2, 0x80, 0x1e, 0x2a, 0x45, 0xcd, 0x02, + 0x1d, 0x45, 0x30, 0x16, 0x95, 0x7a, 0xd2, 0xb8, 0x8a, 0xce, 0x39, 0xa6, + 0x53, 0x60, 0x86, 0xd2, 0xd2, 0x28, 0x43, 0x41, 0xa6, 0x21, 0x29, 0xb4, + 0x80, 0x50, 0x29, 0xe1, 0x68, 0x01, 0xdd, 0x29, 0x28, 0x00, 0xc5, 0x18, + 0xa0, 0x03, 0x14, 0x98, 0xa0, 0x02, 0x8a, 0x00, 0x5c, 0xd2, 0xe6, 0x8b, + 0x08, 0x33, 0x48, 0x68, 0x18, 0x94, 0x94, 0x00, 0x51, 0x40, 0x0d, 0x34, + 0xf8, 0x7a, 0x9a, 0x06, 0x07, 0xad, 0x21, 0xa0, 0x44, 0x7d, 0xe8, 0xa0, + 0x62, 0xe6, 0x9d, 0x48, 0x07, 0x52, 0x66, 0x98, 0x0d, 0x26, 0x92, 0x80, + 0x12, 0x97, 0x14, 0x08, 0x5a, 0x28, 0x19, 0xe9, 0xd1, 0xd9, 0xb7, 0xde, + 0x28, 0x0f, 0xd6, 0xae, 0xd9, 0xda, 0xc0, 0x9f, 0xbe, 0x95, 0x9c, 0x7b, + 0x01, 0x5d, 0xdb, 0x9c, 0x43, 0x9e, 0x0f, 0x3e, 0x5d, 0xd1, 0x6d, 0xf2, + 0xff, 0x00, 0xda, 0x35, 0x9b, 0x7f, 0x1b, 0xc9, 0x27, 0x97, 0x80, 0x56, + 0xb4, 0xba, 0x23, 0xd4, 0xa7, 0x75, 0x02, 0x24, 0x3b, 0x16, 0x35, 0x19, + 0xac, 0x5b, 0xa9, 0x76, 0x2f, 0x93, 0x19, 0xc0, 0x35, 0x25, 0xc7, 0x72, + 0x58, 0x53, 0xc8, 0x83, 0x27, 0xa9, 0xfd, 0x69, 0xf0, 0x41, 0x9e, 0x58, + 0xd6, 0x45, 0xb1, 0x97, 0x71, 0xac, 0x69, 0x85, 0xa8, 0xec, 0x2c, 0x65, + 0xbd, 0x9c, 0x47, 0x1a, 0xf2, 0x6a, 0xa7, 0xdc, 0x21, 0xa9, 0xd8, 0xe9, + 0x9e, 0x0e, 0x85, 0x42, 0xbd, 0xd7, 0x27, 0xd3, 0x02, 0xba, 0x7b, 0x7b, + 0x68, 0xad, 0x93, 0x6c, 0x49, 0x81, 0x5c, 0xb3, 0x95, 0xcd, 0xa3, 0x72, + 0x5a, 0x2a, 0x0a, 0xe4, 0x41, 0x45, 0x3b, 0xd8, 0xc7, 0x96, 0xfa, 0x0c, + 0x31, 0x21, 0xfe, 0x11, 0x48, 0xb6, 0xf1, 0x2f, 0x44, 0x15, 0xa7, 0xb4, + 0xb9, 0x1e, 0xce, 0xc3, 0xf0, 0x3d, 0x29, 0x6a, 0x79, 0x8a, 0xe4, 0x0a, + 0x46, 0xe0, 0x55, 0x27, 0x70, 0xb5, 0x8c, 0x2f, 0x10, 0x5d, 0xb4, 0x36, + 0xdb, 0x14, 0xfc, 0xcd, 0x91, 0x5c, 0x1d, 0xfd, 0xce, 0xd2, 0xc1, 0x7a, + 0x93, 0x4e, 0x7b, 0x17, 0x4b, 0x72, 0x8c, 0x7f, 0x31, 0xc9, 0xad, 0xad, + 0x35, 0xf8, 0xc5, 0x70, 0x54, 0x3d, 0x18, 0x12, 0x6a, 0x77, 0x5e, 0x45, + 0xb9, 0xc7, 0xde, 0xed, 0x5c, 0xa4, 0xaf, 0xb9, 0xcd, 0x6d, 0x4f, 0x63, + 0x9a, 0x7b, 0x91, 0xe2, 0x9d, 0x5a, 0x12, 0x2d, 0x06, 0x90, 0x11, 0x66, + 0x9b, 0x4c, 0x02, 0x8a, 0x00, 0x29, 0xb4, 0x80, 0x63, 0x52, 0x03, 0x54, + 0x04, 0x94, 0x52, 0x00, 0xa6, 0xd0, 0x02, 0x51, 0x48, 0x02, 0x96, 0xa8, + 0x05, 0xa2, 0xa5, 0x80, 0x94, 0xf5, 0xa0, 0x07, 0x53, 0xd2, 0x81, 0x12, + 0x51, 0x40, 0x05, 0x20, 0x6f, 0x9a, 0x98, 0x11, 0xce, 0x3e, 0x7a, 0x8a, + 0x81, 0x09, 0x40, 0xa4, 0x50, 0x53, 0x68, 0x10, 0x94, 0xa0, 0x50, 0x04, + 0x80, 0x53, 0xc0, 0xa0, 0x03, 0x14, 0x98, 0xa0, 0x02, 0x9b, 0x9a, 0x00, + 0x4c, 0xd2, 0x66, 0x80, 0x0a, 0x28, 0x18, 0x52, 0x66, 0x98, 0x83, 0x34, + 0x66, 0x90, 0x06, 0x69, 0x33, 0x40, 0x82, 0x8a, 0x06, 0x07, 0x9a, 0x74, + 0x5d, 0x68, 0x01, 0xa4, 0xf3, 0x49, 0x40, 0xc4, 0xa4, 0xa0, 0x02, 0x97, + 0x34, 0x00, 0xbb, 0xa9, 0x28, 0x00, 0xa2, 0x80, 0x16, 0x96, 0x80, 0x12, + 0x8a, 0x00, 0xf5, 0xe8, 0xa1, 0x69, 0xa7, 0x01, 0x72, 0xeb, 0xdf, 0x70, + 0xa9, 0x6e, 0xe7, 0x2a, 0xbe, 0x47, 0x96, 0x23, 0xcf, 0xf7, 0x2b, 0xd0, + 0x5d, 0xd1, 0xe7, 0xb2, 0x85, 0xd4, 0x90, 0xc7, 0x16, 0xc4, 0x67, 0x24, + 0xfa, 0xad, 0x51, 0xff, 0x00, 0x52, 0x85, 0xb7, 0xe2, 0x82, 0x8c, 0xc9, + 0xae, 0x36, 0x83, 0x21, 0x6c, 0x91, 0x54, 0xec, 0xa3, 0xf3, 0xe7, 0xde, + 0x7a, 0x2f, 0xaf, 0xd6, 0xa2, 0x6f, 0x42, 0xa2, 0x5b, 0x65, 0xde, 0xde, + 0xc2, 0x9a, 0xd2, 0x34, 0x7f, 0x76, 0x80, 0x29, 0xca, 0xcd, 0x2b, 0x7b, + 0xe2, 0xbb, 0xef, 0x09, 0xe9, 0x8b, 0x6d, 0x6b, 0xe7, 0x32, 0xfc, 0xed, + 0x91, 0xfa, 0xd7, 0x3d, 0x67, 0xd0, 0xe9, 0xa6, 0xb4, 0x3a, 0x1a, 0x2b, + 0x22, 0xc2, 0x8a, 0x00, 0x33, 0x45, 0x04, 0x44, 0x28, 0xa0, 0xb0, 0xa2, + 0x80, 0x0a, 0x3a, 0xd3, 0x89, 0x95, 0x43, 0x90, 0xf1, 0x9c, 0xfe, 0x40, + 0xc8, 0xea, 0x39, 0x1f, 0x95, 0x70, 0x6c, 0x4b, 0xc9, 0x93, 0xcd, 0x6d, + 0x5f, 0x64, 0x56, 0x18, 0x9a, 0x2a, 0xd2, 0xb3, 0xf9, 0x6b, 0xcf, 0x91, + 0xdc, 0x8c, 0xfd, 0x5e, 0xe3, 0xcc, 0x97, 0x06, 0xb2, 0x47, 0xde, 0xae, + 0xa5, 0xb1, 0xc8, 0xc7, 0x77, 0xa2, 0xa8, 0x42, 0xd2, 0x37, 0x4a, 0x90, + 0x22, 0xa6, 0xd3, 0x18, 0x51, 0x40, 0x0b, 0x4d, 0xa4, 0xc4, 0x34, 0xd3, + 0x68, 0x01, 0x69, 0x68, 0x18, 0x66, 0x92, 0x90, 0x05, 0x14, 0xc4, 0x14, + 0x50, 0x31, 0x69, 0x29, 0x00, 0x53, 0xd6, 0x98, 0x87, 0xd3, 0xd6, 0x80, + 0x24, 0xa2, 0x81, 0x08, 0xd5, 0x1e, 0x79, 0xa0, 0x68, 0x7c, 0xa3, 0x85, + 0xaa, 0xef, 0x40, 0x84, 0xcd, 0x25, 0x03, 0x16, 0x9a, 0x69, 0x00, 0x0a, + 0x78, 0xa6, 0x03, 0xa9, 0xe0, 0xd2, 0x01, 0x09, 0xa6, 0x96, 0xa0, 0x42, + 0x53, 0x73, 0x40, 0xc4, 0xcd, 0x26, 0x69, 0x80, 0x99, 0xa2, 0x90, 0x05, + 0x25, 0x00, 0x14, 0xb4, 0x00, 0x51, 0x4c, 0x02, 0x8a, 0x00, 0x5a, 0x50, + 0x71, 0x48, 0x04, 0xa4, 0xa1, 0x00, 0x94, 0x53, 0x01, 0x28, 0xa4, 0x31, + 0x71, 0x4b, 0x40, 0x84, 0xa2, 0x80, 0x16, 0x92, 0x81, 0x8b, 0x45, 0x00, + 0x7b, 0x21, 0x95, 0x6d, 0x6d, 0x4f, 0xef, 0xdb, 0x71, 0xfe, 0xe8, 0xcd, + 0x67, 0x89, 0x36, 0xee, 0x90, 0xa0, 0x63, 0xfe, 0xd0, 0xae, 0xd5, 0xb1, + 0xc2, 0xf7, 0x18, 0x21, 0xf3, 0xff, 0x00, 0x78, 0xff, 0x00, 0x28, 0xac, + 0xdd, 0x4a, 0x68, 0xc1, 0xf2, 0xd7, 0xa7, 0x7a, 0xd1, 0x77, 0x24, 0xe7, + 0xa6, 0x79, 0x2e, 0xa6, 0x58, 0xd4, 0x63, 0xb5, 0x6c, 0xac, 0x5e, 0x45, + 0xb8, 0x8d, 0x7f, 0x8b, 0x9a, 0xc1, 0xeb, 0x23, 0x7d, 0x90, 0xad, 0xf2, + 0xad, 0x51, 0x99, 0xb9, 0xab, 0xe8, 0x40, 0x96, 0x89, 0xe6, 0x5c, 0x2a, + 0xfa, 0xff, 0x00, 0x85, 0x7a, 0xa5, 0xa2, 0x85, 0xb6, 0x8f, 0x1f, 0xdd, + 0x15, 0xc5, 0x53, 0xe3, 0x3b, 0x23, 0xa4, 0x09, 0xa8, 0xa0, 0x02, 0x8a, + 0x68, 0x97, 0x23, 0x9f, 0xd5, 0x35, 0x19, 0x61, 0xb8, 0x3b, 0x1f, 0x8d, + 0xa2, 0xa1, 0xb7, 0xd7, 0xca, 0x47, 0xfb, 0xce, 0xbe, 0xb5, 0xa5, 0x58, + 0x76, 0x22, 0x9b, 0xb9, 0xb7, 0x65, 0x7c, 0x97, 0x5d, 0x2a, 0xdd, 0x63, + 0x12, 0xa6, 0xec, 0x14, 0x55, 0xd8, 0x8e, 0x70, 0xa8, 0xa6, 0x97, 0x65, + 0x52, 0x44, 0x5c, 0xe0, 0xfc, 0x65, 0x37, 0x9d, 0x8e, 0x7b, 0x7f, 0x4a, + 0xe5, 0x54, 0x73, 0x46, 0x21, 0x9d, 0x18, 0x75, 0xa1, 0x76, 0xde, 0x12, + 0x71, 0x5a, 0x1b, 0x76, 0x47, 0xbb, 0xd2, 0xb8, 0xba, 0x9d, 0x4f, 0x63, + 0x9c, 0xb9, 0x25, 0xe4, 0x63, 0xf8, 0x54, 0x41, 0x71, 0x5d, 0x27, 0x30, + 0xe3, 0x49, 0x8a, 0x60, 0x39, 0x54, 0x9a, 0x64, 0xa3, 0x14, 0x80, 0x84, + 0xd2, 0x50, 0x00, 0x45, 0x25, 0x30, 0x12, 0x92, 0x80, 0x0a, 0x6e, 0x28, + 0x01, 0x71, 0x4b, 0x49, 0x80, 0x94, 0x94, 0xc0, 0x4a, 0x28, 0x00, 0xa2, + 0x80, 0x16, 0x8a, 0x40, 0x25, 0x48, 0xb4, 0x00, 0xfa, 0x7a, 0xd0, 0x22, + 0x5e, 0xd4, 0x84, 0xd0, 0x22, 0x07, 0x7a, 0x8b, 0x75, 0x03, 0x24, 0x32, + 0x7c, 0xb5, 0x1e, 0x6a, 0x80, 0x28, 0xa4, 0x20, 0xa4, 0x34, 0x86, 0x28, + 0xa7, 0x50, 0x31, 0x73, 0x46, 0x4d, 0x02, 0x12, 0x93, 0x34, 0x0c, 0x6e, + 0xea, 0x4a, 0x04, 0x25, 0x2d, 0x00, 0x25, 0x2d, 0x00, 0x14, 0x50, 0x01, + 0x45, 0x03, 0x0a, 0x28, 0xb8, 0x82, 0x8a, 0x00, 0x28, 0xa0, 0x02, 0x8a, + 0x00, 0x31, 0x45, 0x03, 0x12, 0x8a, 0x40, 0x19, 0xa2, 0x98, 0x0b, 0x8a, + 0x28, 0x00, 0x34, 0xda, 0x40, 0x2d, 0x3a, 0x98, 0x1e, 0x96, 0x24, 0x59, + 0x64, 0xc8, 0x00, 0x53, 0xb2, 0xd7, 0x12, 0x88, 0xb2, 0xc5, 0x6b, 0xae, + 0xe7, 0x1d, 0x8b, 0xd7, 0xf2, 0xc1, 0x67, 0x60, 0x71, 0x0f, 0xcf, 0x8f, + 0xa7, 0xa5, 0x72, 0x3a, 0x8b, 0x95, 0x89, 0xd8, 0x9f, 0xbd, 0x9c, 0x7f, + 0x3a, 0xe9, 0xda, 0x3a, 0x99, 0xad, 0x58, 0xed, 0x12, 0xcf, 0x6e, 0x6e, + 0x25, 0xcf, 0xe3, 0xf5, 0xab, 0xf8, 0xdc, 0xfb, 0x9b, 0xb5, 0x72, 0x47, + 0xb9, 0xb4, 0xf7, 0xb1, 0x5e, 0x73, 0x54, 0x1f, 0xad, 0x6a, 0x4a, 0x35, + 0x34, 0x5d, 0x26, 0xe6, 0x6b, 0x85, 0x75, 0x4c, 0x00, 0x7e, 0x95, 0xe8, + 0x56, 0xea, 0xc9, 0x0a, 0x86, 0xeb, 0x8a, 0xe4, 0x94, 0x57, 0x35, 0xcd, + 0xa5, 0x2f, 0x76, 0xc4, 0xb4, 0x52, 0x64, 0xab, 0xb0, 0xa2, 0xae, 0x2e, + 0xc4, 0x33, 0x3a, 0x6d, 0x26, 0x39, 0x5f, 0x24, 0x0a, 0x60, 0xd1, 0x21, + 0xf4, 0x5a, 0xd9, 0xd4, 0x44, 0xab, 0x96, 0xed, 0x6c, 0xa3, 0xb6, 0xfb, + 0xa2, 0xac, 0xd7, 0x39, 0xa8, 0x51, 0x4a, 0xe0, 0xe2, 0x15, 0x95, 0xaf, + 0x5e, 0x0b, 0x5b, 0x5e, 0x3e, 0xf1, 0xcd, 0x6b, 0x4f, 0x52, 0x5a, 0x3c, + 0xff, 0x00, 0x58, 0x94, 0xcd, 0xd7, 0xde, 0xaa, 0xd9, 0xc1, 0xe6, 0x3d, + 0x72, 0xd7, 0x91, 0xdf, 0x41, 0x58, 0xd8, 0x8a, 0x0d, 0xa3, 0x1d, 0xaa, + 0x3d, 0x43, 0xf7, 0x76, 0x52, 0x63, 0xd2, 0xb1, 0x86, 0xe5, 0xcf, 0x63, + 0x98, 0xea, 0xc7, 0xeb, 0x46, 0x2b, 0xa4, 0xe7, 0x1d, 0xe5, 0x9a, 0xb1, + 0x1c, 0x23, 0x14, 0x00, 0x93, 0x62, 0x35, 0xcd, 0x67, 0x31, 0xdc, 0x68, + 0x10, 0xca, 0x28, 0x18, 0xec, 0x52, 0x53, 0x01, 0xb4, 0xde, 0xf4, 0x00, + 0xb4, 0x50, 0x02, 0x52, 0x66, 0x80, 0x12, 0x92, 0x90, 0x09, 0x45, 0x3b, + 0x00, 0xb4, 0x52, 0x00, 0xa5, 0xa0, 0x02, 0x9c, 0xb4, 0x00, 0xfa, 0x5d, + 0xf4, 0x08, 0x53, 0x25, 0x44, 0x58, 0xd0, 0x31, 0xa4, 0xd3, 0x68, 0x10, + 0xea, 0x28, 0x18, 0xb4, 0x50, 0x20, 0xa3, 0x19, 0xa0, 0x03, 0x14, 0xb4, + 0x0c, 0x28, 0xcd, 0x02, 0x1a, 0x4d, 0x36, 0x80, 0x0a, 0x5a, 0x00, 0x28, + 0xa0, 0x61, 0x45, 0x00, 0x2d, 0x25, 0x02, 0x0a, 0x28, 0x00, 0xa5, 0xa0, + 0x04, 0xa2, 0x80, 0x0a, 0x28, 0x18, 0x51, 0x40, 0x0b, 0x49, 0x40, 0x84, + 0xa3, 0x14, 0x0c, 0x5c, 0x52, 0xe2, 0x90, 0x0b, 0x4d, 0xcd, 0x00, 0x18, + 0xa5, 0xa6, 0x01, 0x4b, 0x48, 0x0f, 0x44, 0xf2, 0x64, 0xd9, 0xc7, 0x5a, + 0xe9, 0x34, 0x5b, 0x3f, 0xb3, 0x43, 0xbc, 0xc4, 0xa1, 0xbd, 0x6b, 0xb3, + 0x94, 0xe3, 0x7b, 0x18, 0x3a, 0xf5, 0xf1, 0xba, 0xbf, 0x11, 0x3b, 0x7c, + 0x91, 0xe0, 0xe3, 0x3c, 0x77, 0x15, 0xce, 0xed, 0x3a, 0xa6, 0xa4, 0xb1, + 0xff, 0x00, 0xcb, 0x35, 0xc6, 0x7f, 0x51, 0x5b, 0xd5, 0x76, 0x22, 0x8a, + 0x37, 0x24, 0x5d, 0x91, 0xac, 0x2b, 0xe9, 0xcf, 0xe5, 0x50, 0xc9, 0xf2, + 0x8c, 0x56, 0x51, 0x2a, 0xe5, 0x19, 0x89, 0x26, 0xb4, 0xb4, 0x2d, 0x14, + 0xdf, 0x4f, 0x97, 0xfb, 0x83, 0xad, 0x4d, 0x49, 0x58, 0xb8, 0x23, 0xb9, + 0xb6, 0xb6, 0x8e, 0xda, 0x30, 0xb1, 0x8c, 0x54, 0xd5, 0xcb, 0x73, 0x5b, + 0x20, 0xa2, 0x91, 0xa8, 0x51, 0x4c, 0xc6, 0xde, 0xf0, 0x51, 0x48, 0xa6, + 0x14, 0x50, 0x48, 0x51, 0x4d, 0x0a, 0x4c, 0x09, 0xc7, 0x5a, 0xe1, 0x7c, + 0x47, 0x7e, 0x25, 0xb8, 0x66, 0x63, 0xf2, 0xa5, 0x6d, 0x0d, 0x9b, 0x17, + 0xda, 0x39, 0x67, 0x90, 0xca, 0xd9, 0x35, 0xa3, 0xa6, 0xc7, 0x83, 0x93, + 0xd6, 0xbc, 0xfa, 0x8e, 0xe7, 0xa3, 0x4c, 0xd2, 0xaa, 0x9a, 0xaf, 0xfc, + 0x78, 0xc9, 0xfe, 0xed, 0x10, 0xdc, 0x55, 0x36, 0x30, 0x12, 0x1c, 0xf5, + 0xf5, 0xa9, 0x44, 0x38, 0xed, 0x5d, 0x27, 0x28, 0xae, 0x94, 0xcd, 0xdb, + 0x68, 0x02, 0x9d, 0xc4, 0x9b, 0xb8, 0xaa, 0xf5, 0x43, 0x10, 0xd1, 0x48, + 0x63, 0xa9, 0x28, 0x10, 0xda, 0x4a, 0x06, 0x25, 0x36, 0x81, 0x09, 0x49, + 0x40, 0x09, 0x45, 0x03, 0x0a, 0x28, 0x00, 0xa2, 0x80, 0x16, 0x8a, 0x00, + 0x29, 0x73, 0x40, 0x06, 0x68, 0xcd, 0x00, 0x19, 0xa4, 0xcd, 0x20, 0x1b, + 0x45, 0x00, 0x3a, 0x96, 0x98, 0x05, 0x14, 0x84, 0x2d, 0x14, 0xc0, 0x5a, + 0x4a, 0x40, 0x14, 0x94, 0x00, 0x94, 0x50, 0xc0, 0x28, 0xa0, 0x05, 0xa2, + 0x85, 0xa0, 0x09, 0x45, 0x31, 0x85, 0x14, 0x84, 0x2d, 0x25, 0x03, 0x16, + 0x92, 0x81, 0x05, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, 0x0c, 0x28, 0xa0, + 0x42, 0xe2, 0x97, 0x14, 0x00, 0x62, 0x8a, 0x06, 0x25, 0x18, 0xa4, 0x01, + 0x4b, 0x40, 0x09, 0x49, 0x4c, 0x0f, 0x5d, 0xd3, 0x20, 0xdf, 0x74, 0x1b, + 0x83, 0x8a, 0xb7, 0xe2, 0x09, 0xe7, 0x8a, 0xcc, 0xc7, 0x13, 0xfc, 0xe4, + 0x11, 0x5e, 0x85, 0x1b, 0x4e, 0x57, 0x3c, 0xf9, 0xbb, 0x1c, 0x66, 0xa9, + 0x17, 0xd9, 0xed, 0x0a, 0xc4, 0x4e, 0xe9, 0x37, 0x67, 0xb7, 0xbd, 0x5c, + 0xd1, 0xad, 0x92, 0xda, 0xd8, 0xc9, 0x8d, 0xce, 0x7f, 0xc6, 0xa6, 0xa6, + 0xeb, 0xcc, 0xda, 0x1b, 0x32, 0xc6, 0x3b, 0xd5, 0x59, 0xcd, 0x04, 0x0d, + 0xb3, 0xb4, 0xfb, 0x5c, 0xe1, 0x7b, 0x1a, 0xef, 0xac, 0xad, 0x92, 0xd6, + 0x00, 0x88, 0x31, 0x5c, 0x95, 0x25, 0x79, 0x58, 0xe9, 0x8a, 0xb4, 0x6e, + 0x58, 0xa2, 0x95, 0x8c, 0x79, 0xb5, 0x0a, 0x46, 0x6d, 0xbd, 0x68, 0x51, + 0xb9, 0xb3, 0x95, 0x88, 0xd6, 0x75, 0x67, 0xda, 0x2a, 0x5a, 0x97, 0xd8, + 0x22, 0x14, 0x50, 0x50, 0x51, 0x54, 0x61, 0xd4, 0x28, 0xa6, 0xc4, 0x51, + 0xd5, 0xe7, 0x30, 0xd9, 0x3e, 0xdf, 0xbc, 0x47, 0x15, 0xe6, 0x9a, 0xbc, + 0xcc, 0xf2, 0xb0, 0xec, 0x4f, 0xf3, 0xad, 0x5c, 0x5a, 0xa6, 0x55, 0x2d, + 0x66, 0x56, 0xb6, 0x8f, 0x27, 0x15, 0xbb, 0x6d, 0x1e, 0xd5, 0xaf, 0x36, + 0x47, 0xa6, 0x4f, 0x55, 0xaf, 0xd3, 0x7d, 0xbb, 0x0f, 0x6a, 0xa8, 0x6e, + 0x44, 0xf6, 0x32, 0x02, 0xe3, 0x8a, 0x5c, 0x56, 0xec, 0xe6, 0x17, 0x65, + 0x50, 0xba, 0x3c, 0xd5, 0x22, 0x4a, 0x4f, 0x4d, 0xa1, 0x94, 0x21, 0xa0, + 0x52, 0x63, 0x1d, 0x4d, 0x34, 0xc4, 0x30, 0x9a, 0x6d, 0x03, 0x12, 0x9b, + 0x4c, 0x02, 0x8a, 0x40, 0x14, 0x50, 0x02, 0x51, 0x4c, 0x02, 0x8a, 0x40, + 0x2d, 0x14, 0x80, 0x28, 0xa0, 0x41, 0x49, 0x4c, 0x61, 0x49, 0x48, 0x02, + 0x8a, 0x60, 0x2d, 0x3a, 0x80, 0x0a, 0x54, 0xeb, 0x43, 0x10, 0xa6, 0x92, + 0x90, 0x0b, 0x45, 0x17, 0x18, 0xda, 0x4a, 0x04, 0x28, 0xe6, 0x96, 0x9b, + 0x01, 0x08, 0xa2, 0x90, 0x05, 0x14, 0x00, 0x51, 0x40, 0x05, 0x14, 0x00, + 0x52, 0x50, 0x02, 0xd2, 0x50, 0x01, 0x4b, 0x40, 0x05, 0x25, 0x00, 0x14, + 0x50, 0x01, 0x4b, 0x40, 0xc5, 0x14, 0xa6, 0x90, 0x09, 0x45, 0x0c, 0x04, + 0xcd, 0x2d, 0x00, 0x25, 0x26, 0x69, 0x80, 0x94, 0x50, 0x07, 0xff, 0xd9, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xca, 0x0c, 0x57, 0x6d, 0x24, 0x63, 0x36, 0x61, 0x5f, 0x2f, 0x06, 0x9f, + 0xa4, 0x9d, 0xac, 0x3e, 0xb5, 0x85, 0x72, 0xe0, 0x6e, 0xff, 0x00, 0x0d, + 0x53, 0xb9, 0xe9, 0x5a, 0x47, 0x63, 0x03, 0x9a, 0xd5, 0x97, 0xe5, 0x35, + 0x92, 0x05, 0x61, 0x58, 0xea, 0xa4, 0x4a, 0x07, 0x14, 0x6d, 0xac, 0x6e, + 0x6c, 0x58, 0x89, 0x2b, 0x42, 0xc9, 0x8c, 0x2c, 0x0d, 0x48, 0x8e, 0x8a, + 0xd6, 0xf5, 0xd8, 0x63, 0x15, 0x6a, 0x49, 0x5f, 0x67, 0x35, 0xd7, 0x44, + 0xe4, 0xa8, 0x88, 0xa3, 0xe7, 0x9a, 0x94, 0xa1, 0x61, 0x5a, 0x90, 0x2a, + 0xc7, 0x4b, 0xe5, 0x1a, 0x00, 0xb1, 0x18, 0xe2, 0xab, 0x5e, 0x48, 0x10, + 0xf5, 0xa9, 0xe8, 0x3e, 0xa4, 0xe6, 0x40, 0x91, 0x02, 0x6a, 0x8c, 0xb3, + 0xb3, 0xf0, 0x2a, 0x53, 0xd0, 0x2d, 0xa8, 0xc4, 0x88, 0x9a, 0x71, 0x01, + 0x28, 0x28, 0xad, 0x71, 0x20, 0x11, 0x92, 0x4f, 0x15, 0xce, 0x5d, 0xeb, + 0x1b, 0x64, 0x29, 0x6e, 0xb9, 0x6f, 0x5e, 0x69, 0xda, 0xe8, 0x16, 0xe4, + 0x3e, 0x75, 0xd4, 0xa3, 0xe6, 0x7d, 0xbf, 0x4a, 0xcf, 0x9a, 0x36, 0x2f, + 0x86, 0xf9, 0xab, 0x16, 0xf4, 0x3a, 0x61, 0xb8, 0xe8, 0xe0, 0xa7, 0xb5, + 0xaa, 0x3f, 0x51, 0x5c, 0xfc, 0xc7, 0x43, 0x44, 0x2f, 0x60, 0x3f, 0x87, + 0x8a, 0xaa, 0xd0, 0xcb, 0x09, 0xc8, 0xab, 0xbd, 0xcc, 0xb6, 0x2c, 0x45, + 0xad, 0xcd, 0x0a, 0xe3, 0x15, 0x32, 0xea, 0x9e, 0x67, 0x2f, 0xf3, 0x7e, + 0x15, 0xbe, 0x1f, 0xdd, 0x67, 0x3e, 0x23, 0xde, 0x1e, 0x2f, 0x15, 0xbb, + 0x55, 0x1b, 0xac, 0xc9, 0x27, 0x02, 0xbd, 0x27, 0x56, 0xd1, 0x39, 0x29, + 0xd1, 0x7c, 0xe4, 0xb6, 0xf1, 0x95, 0x15, 0xa1, 0x08, 0xe2, 0xbc, 0x26, + 0xee, 0xcf, 0x63, 0xa1, 0x3e, 0xda, 0x6e, 0x70, 0x6a, 0xcc, 0xc8, 0x9d, + 0xe9, 0x9b, 0x8d, 0x4b, 0x65, 0x20, 0xce, 0x7a, 0xd2, 0x56, 0x77, 0x2a, + 0xc4, 0x52, 0x4c, 0xa9, 0x54, 0x9e, 0xf7, 0xde, 0xa9, 0x08, 0xa9, 0x2d, + 0xd7, 0xbd, 0x55, 0x92, 0xe8, 0x76, 0x35, 0xa2, 0x44, 0x39, 0x95, 0xda, + 0xe0, 0xd4, 0x65, 0x8d, 0x6c, 0x62, 0xdd, 0xc6, 0xd2, 0x53, 0xd8, 0x44, + 0xb1, 0x1c, 0x35, 0x5b, 0xed, 0x48, 0x06, 0x1a, 0x61, 0xa0, 0x06, 0xd1, + 0x40, 0x05, 0x34, 0x8c, 0xd0, 0x98, 0x06, 0xce, 0x2a, 0x13, 0x4c, 0x42, + 0x53, 0xc5, 0x21, 0x85, 0x34, 0xd0, 0x03, 0x69, 0x76, 0xd3, 0x01, 0xd8, + 0xa5, 0xc5, 0x4d, 0xc0, 0x5a, 0x4a, 0x2e, 0x01, 0x51, 0x9a, 0x60, 0x14, + 0xe1, 0x40, 0x0b, 0x49, 0x40, 0x21, 0x45, 0x5a, 0x4f, 0xbb, 0x43, 0x01, + 0xc6, 0xa6, 0x5a, 0x46, 0x42, 0x5c, 0x7d, 0xca, 0xcb, 0x3d, 0x69, 0x95, + 0x11, 0xc9, 0x4b, 0x41, 0x63, 0xe9, 0xc2, 0x90, 0x08, 0xd4, 0xca, 0x60, + 0x14, 0xea, 0x40, 0x44, 0xdd, 0x69, 0x29, 0x88, 0x5a, 0x5a, 0x00, 0x43, + 0x4d, 0xa0, 0x07, 0xad, 0x4b, 0x48, 0x67, 0xb7, 0x5a, 0xbe, 0x56, 0xa6, + 0x95, 0x32, 0xb5, 0xdf, 0x48, 0xe5, 0x9e, 0xe6, 0x05, 0xf2, 0xf5, 0xa8, + 0x6c, 0xfe, 0x59, 0x45, 0x73, 0xe2, 0x0d, 0xe0, 0x6f, 0xaf, 0x31, 0xd5, + 0x4b, 0xa2, 0x00, 0xeb, 0x4e, 0x1b, 0x18, 0xbd, 0xce, 0x57, 0x55, 0x9f, + 0xcc, 0x7d, 0x8b, 0x8a, 0xa8, 0x13, 0x8a, 0xe7, 0xab, 0xbd, 0x8e, 0xba, + 0x6b, 0x41, 0xe1, 0x69, 0xe1, 0x6b, 0x13, 0x42, 0x78, 0xd6, 0xb4, 0x21, + 0xd9, 0x8c, 0x1a, 0x48, 0x4c, 0xe8, 0x34, 0xf1, 0x0e, 0x06, 0xdc, 0x66, + 0xa5, 0xd4, 0x1f, 0x11, 0x7e, 0x75, 0xdb, 0x40, 0xe2, 0xaa, 0x25, 0x9a, + 0xe6, 0x3e, 0x7a, 0xf5, 0xa7, 0xca, 0xf8, 0x38, 0x15, 0x51, 0xd8, 0x19, + 0x24, 0x3e, 0xf5, 0x2e, 0xe1, 0x4e, 0x22, 0x64, 0x12, 0x5d, 0xaa, 0x1e, + 0x39, 0xac, 0x6b, 0xb8, 0xe6, 0x9e, 0xe0, 0x49, 0x9f, 0x97, 0xd2, 0xa8, + 0x16, 0xe5, 0xed, 0xcc, 0xca, 0x01, 0xa9, 0x62, 0x41, 0x58, 0x24, 0x5b, + 0x1f, 0x2b, 0x88, 0xd6, 0xb2, 0xef, 0x6e, 0xf0, 0x33, 0x9e, 0x2b, 0x5b, + 0x12, 0x61, 0xde, 0xde, 0x3d, 0xc2, 0xec, 0x07, 0x09, 0x54, 0xbe, 0x44, + 0xe8, 0x2b, 0x29, 0xcb, 0x4b, 0x1b, 0xc2, 0x02, 0xf9, 0x84, 0xd2, 0x6c, + 0xe7, 0x26, 0xb9, 0x9b, 0x3b, 0x23, 0x0b, 0x12, 0x62, 0x93, 0x15, 0x98, + 0x0e, 0x02, 0x92, 0x48, 0xb3, 0x40, 0x14, 0xe5, 0xb2, 0x57, 0xed, 0x51, + 0xa6, 0x9f, 0xb5, 0x86, 0x0d, 0x5a, 0x9d, 0x8c, 0xdc, 0x0b, 0x69, 0x66, + 0x3a, 0x9a, 0x77, 0xd9, 0xd5, 0x7a, 0x01, 0x57, 0xcf, 0x70, 0xb5, 0x88, + 0x98, 0x73, 0x52, 0xc6, 0xd8, 0xac, 0xca, 0x25, 0x2f, 0xc5, 0x46, 0x69, + 0x89, 0x22, 0x36, 0x34, 0xcd, 0xe2, 0xb2, 0x65, 0x91, 0xbc, 0xc0, 0x55, + 0x29, 0x2f, 0x87, 0xaf, 0xeb, 0x4e, 0x31, 0x0b, 0xd8, 0xcd, 0x9a, 0xfb, + 0x7d, 0x55, 0x7b, 0x86, 0x35, 0xd1, 0x18, 0x9c, 0xf2, 0x99, 0x11, 0x62, + 0x69, 0xb5, 0x64, 0x06, 0x29, 0x69, 0xd8, 0x04, 0xa5, 0xa0, 0x05, 0x1d, + 0x6a, 0xe2, 0x1c, 0xad, 0x20, 0x03, 0x4d, 0x34, 0x00, 0xca, 0x4a, 0x00, + 0x4a, 0x5a, 0x40, 0x3a, 0xaa, 0xbf, 0xde, 0xa6, 0x21, 0x2a, 0x41, 0x40, + 0xc7, 0x53, 0x48, 0xa0, 0x04, 0xdb, 0x4b, 0x48, 0x05, 0xa4, 0xa0, 0x02, + 0x8a, 0x00, 0x6d, 0x30, 0xd3, 0x00, 0xa7, 0x2d, 0x00, 0x3f, 0x14, 0xca, + 0x00, 0x72, 0x75, 0xab, 0x29, 0x40, 0x31, 0x5a, 0xa7, 0x4a, 0x46, 0x63, + 0x2e, 0x7e, 0xe5, 0x66, 0x9a, 0x63, 0x88, 0xe5, 0xa5, 0xa0, 0xb1, 0x69, + 0x73, 0x45, 0x80, 0x09, 0xa6, 0xd2, 0x01, 0x69, 0xd4, 0x01, 0x13, 0x75, + 0xa2, 0x98, 0x83, 0x14, 0x0a, 0x40, 0x3a, 0x9a, 0x45, 0x30, 0x05, 0xeb, + 0x52, 0xd2, 0xea, 0x33, 0xdb, 0x2c, 0x4f, 0xc9, 0x56, 0xa4, 0x6f, 0x96, + 0xbb, 0x68, 0xec, 0x73, 0x54, 0x31, 0x75, 0x05 +}; +unsigned int capture_jpg_len = 24800; + + +unsigned const char octo_jpg[] = { + 0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, + 0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43, + 0x00, 0x11, 0x0b, 0x0c, 0x0f, 0x0c, 0x0a, 0x11, 0x0f, 0x0e, 0x0f, 0x13, + 0x12, 0x11, 0x14, 0x19, 0x2a, 0x1b, 0x19, 0x17, 0x17, 0x19, 0x33, 0x24, + 0x26, 0x1e, 0x2a, 0x3c, 0x35, 0x3f, 0x3e, 0x3b, 0x35, 0x3a, 0x39, 0x43, + 0x4b, 0x60, 0x51, 0x43, 0x47, 0x5a, 0x48, 0x39, 0x3a, 0x53, 0x71, 0x54, + 0x5a, 0x63, 0x66, 0x6b, 0x6c, 0x6b, 0x40, 0x50, 0x76, 0x7e, 0x74, 0x68, + 0x7d, 0x60, 0x69, 0x6b, 0x67, 0xff, 0xdb, 0x00, 0x43, 0x01, 0x12, 0x13, + 0x13, 0x19, 0x16, 0x19, 0x31, 0x1b, 0x1b, 0x31, 0x67, 0x45, 0x3a, 0x45, + 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, + 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, + 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, + 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, + 0x67, 0x67, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x01, 0xe0, 0x02, 0x80, 0x03, + 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00, + 0x1f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00, + 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, + 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, + 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, + 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, + 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, + 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, + 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, + 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, + 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, + 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, + 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, + 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, + 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, + 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, + 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xc4, 0x00, + 0x1f, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00, + 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, + 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, + 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, + 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, + 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, + 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, + 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, + 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, + 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, + 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, + 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, + 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, + 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, + 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, + 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xda, 0x00, + 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xef, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa4, 0xa5, 0xa0, + 0x02, 0x8a, 0x4a, 0x5a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, + 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, + 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, + 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, + 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa4, 0xa5, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x92, 0x96, + 0xab, 0xdd, 0x4e, 0x96, 0xb6, 0xd2, 0xcc, 0xe7, 0x09, 0x1a, 0x96, 0x3f, + 0x80, 0xa0, 0x09, 0x8b, 0x28, 0xea, 0xc0, 0x7e, 0x34, 0x07, 0x53, 0xd1, + 0x81, 0xfc, 0x6b, 0xc8, 0xaf, 0x6f, 0xe7, 0xbd, 0xbb, 0x96, 0x69, 0x25, + 0x7c, 0xbb, 0x13, 0x80, 0xc7, 0x00, 0x54, 0x71, 0xdd, 0x4f, 0x19, 0xf9, + 0x27, 0x95, 0x48, 0xfe, 0xeb, 0x1a, 0x00, 0xf6, 0x2a, 0x2b, 0xcb, 0x6d, + 0x7c, 0x4b, 0xaa, 0xda, 0x91, 0xb2, 0xed, 0xdd, 0x47, 0xf0, 0xc9, 0xf3, + 0x56, 0xdd, 0x87, 0x8f, 0x5c, 0x61, 0x6f, 0xad, 0x81, 0x1f, 0xdf, 0x88, + 0xff, 0x00, 0x43, 0x40, 0x1d, 0xbd, 0x15, 0x99, 0xa7, 0xeb, 0xda, 0x7e, + 0xa1, 0x81, 0x05, 0xc2, 0xee, 0x3f, 0xc0, 0xdc, 0x1a, 0xd3, 0x1d, 0x28, + 0x01, 0x68, 0xa4, 0xa2, 0x80, 0x16, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x29, 0x28, 0x01, 0x69, 0x28, 0xcd, 0x21, 0x3c, 0xf3, + 0xd2, 0x80, 0x16, 0x8a, 0xca, 0xd4, 0x7c, 0x45, 0xa7, 0x69, 0xc0, 0xf9, + 0xd3, 0x86, 0x71, 0xfc, 0x09, 0xc9, 0xae, 0x6e, 0xfb, 0xc7, 0x93, 0x3e, + 0x56, 0xca, 0xdd, 0x50, 0x76, 0x79, 0x39, 0xfd, 0x28, 0x03, 0xb9, 0xa4, + 0x2e, 0xa3, 0xab, 0x01, 0xf8, 0xd7, 0x96, 0x5d, 0x78, 0x8b, 0x55, 0xba, + 0x24, 0xbd, 0xe4, 0x8b, 0xec, 0x9f, 0x28, 0xfd, 0x2a, 0x8b, 0xdc, 0xcf, + 0x26, 0x4b, 0xcf, 0x23, 0x7d, 0x5c, 0xd0, 0x07, 0xb0, 0x87, 0x53, 0xd1, + 0x81, 0xfc, 0x69, 0x6b, 0xc9, 0xb4, 0x9d, 0x46, 0x5b, 0x1d, 0x42, 0x19, + 0xbc, 0xd6, 0xda, 0x8c, 0x0b, 0x02, 0xc7, 0x91, 0xde, 0xbd, 0x5a, 0x36, + 0x57, 0x45, 0x74, 0x39, 0x56, 0x00, 0x83, 0xed, 0x40, 0x12, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, + 0x14, 0x00, 0x57, 0x3b, 0xe3, 0x8b, 0xcf, 0xb3, 0x68, 0x4d, 0x18, 0x3f, + 0x34, 0xec, 0x13, 0xf0, 0xea, 0x7f, 0x95, 0x74, 0x55, 0xc2, 0x7c, 0x44, + 0xb8, 0xdf, 0x77, 0x6d, 0x00, 0x3c, 0x22, 0x17, 0x23, 0xdc, 0x9c, 0x7f, + 0x4a, 0x00, 0xe4, 0xa8, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x5c, + 0xed, 0x3b, 0x81, 0x23, 0xdc, 0x75, 0xfc, 0xeb, 0x6f, 0x4a, 0xf1, 0x5e, + 0xa1, 0xa7, 0xe1, 0x1d, 0xfe, 0xd1, 0x10, 0xe8, 0x92, 0x76, 0xfa, 0x1e, + 0xb5, 0x86, 0x28, 0xa0, 0x0f, 0x4d, 0xd2, 0x7c, 0x4f, 0x61, 0xa9, 0xe1, + 0x44, 0x9e, 0x4c, 0xa7, 0xfe, 0x59, 0xc8, 0x70, 0x7f, 0x0f, 0x5a, 0xda, + 0x06, 0xbc, 0x64, 0x70, 0x72, 0x38, 0x3e, 0xbf, 0xfd, 0x7f, 0x5a, 0xde, + 0xd1, 0xfc, 0x5b, 0x79, 0x60, 0x56, 0x2b, 0x82, 0x6e, 0x60, 0xe9, 0x86, + 0x3f, 0x3a, 0x8f, 0x63, 0xfe, 0x7f, 0x0a, 0x00, 0xf4, 0x8a, 0x2a, 0x86, + 0x99, 0xaa, 0xda, 0x6a, 0x91, 0x6f, 0xb6, 0x94, 0x37, 0x19, 0x28, 0x78, + 0x65, 0x3f, 0x4a, 0xba, 0x58, 0x28, 0xe4, 0x81, 0xf5, 0xa0, 0x07, 0x51, + 0x54, 0x6e, 0x75, 0x8d, 0x3e, 0xd7, 0x26, 0x6b, 0xb8, 0x57, 0x1d, 0xb7, + 0x64, 0xd6, 0x65, 0xc7, 0x8c, 0xf4, 0xa8, 0x41, 0xd9, 0x24, 0x92, 0x9f, + 0xf6, 0x13, 0xaf, 0xe7, 0x40, 0x1d, 0x0d, 0x15, 0xc6, 0xcb, 0xe3, 0xd8, + 0x97, 0x88, 0x6c, 0x9d, 0x87, 0x6d, 0xee, 0x07, 0xe8, 0x05, 0x53, 0x93, + 0xc7, 0x97, 0xcd, 0xfe, 0xae, 0xda, 0x05, 0xfa, 0x92, 0x4f, 0xf3, 0xa0, + 0x0e, 0xfa, 0x8a, 0xf3, 0x87, 0xf1, 0xae, 0xaa, 0xd9, 0xc3, 0x44, 0xa3, + 0xd0, 0x20, 0xa8, 0xdb, 0xc5, 0xfa, 0xc3, 0x1f, 0xf8, 0xf9, 0x51, 0xf4, + 0x45, 0xa0, 0x0f, 0x4b, 0xa2, 0xbc, 0xc4, 0xf8, 0xb3, 0x58, 0x3f, 0xf2, + 0xf6, 0x7f, 0xef, 0x81, 0xfe, 0x14, 0x0f, 0x16, 0x6b, 0x03, 0xfe, 0x5e, + 0xcf, 0xfd, 0xf0, 0x3f, 0xc2, 0x80, 0x3d, 0x3a, 0x8a, 0xf3, 0x35, 0xf1, + 0x7e, 0xb0, 0xbf, 0xf2, 0xf2, 0x0f, 0xd5, 0x07, 0xf8, 0x54, 0xe9, 0xe3, + 0x6d, 0x55, 0x7e, 0xf3, 0x42, 0xff, 0x00, 0xef, 0x27, 0xf8, 0x50, 0x07, + 0xa2, 0xd1, 0x5c, 0x14, 0x7e, 0x3d, 0xbc, 0x18, 0xf3, 0x2d, 0xa1, 0x71, + 0xdf, 0x04, 0x83, 0x56, 0xed, 0xfc, 0x7f, 0x0f, 0xfc, 0xb6, 0xb3, 0x95, + 0x7d, 0xd1, 0xf7, 0x7f, 0x3a, 0x00, 0xec, 0xa8, 0xac, 0x0b, 0x7f, 0x18, + 0xe9, 0x32, 0xe0, 0x34, 0xaf, 0x11, 0x3d, 0x9d, 0x3f, 0xc2, 0xb4, 0xed, + 0xb5, 0x6b, 0x1b, 0xac, 0x79, 0x37, 0x51, 0x39, 0x3d, 0x83, 0x50, 0x05, + 0xcc, 0xd2, 0x1a, 0xce, 0xd5, 0x75, 0xab, 0x3d, 0x2a, 0x1d, 0xd7, 0x12, + 0xfc, 0xc7, 0xa2, 0x29, 0xcb, 0x1a, 0xe1, 0xb5, 0x8f, 0x15, 0x5e, 0xea, + 0x5b, 0xa3, 0x8d, 0x8c, 0x10, 0x1c, 0xfc, 0x88, 0x70, 0x4f, 0xd4, 0xd0, + 0x07, 0x5b, 0xab, 0xf8, 0xae, 0xc3, 0x4d, 0xdc, 0x88, 0xc6, 0xe2, 0x61, + 0xd5, 0x23, 0x39, 0x03, 0xea, 0x6b, 0x8e, 0xd5, 0x7c, 0x4f, 0xa8, 0x6a, + 0x7f, 0x29, 0x94, 0xc1, 0x11, 0xfe, 0x08, 0xce, 0x3f, 0x33, 0x59, 0x1f, + 0xe7, 0xfc, 0xfa, 0xd2, 0x50, 0x02, 0x9e, 0xb9, 0xff, 0x00, 0xeb, 0xd2, + 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x1d, 0x47, 0xad, 0x7a, 0x67, + 0x84, 0x2f, 0x0d, 0xde, 0x83, 0x0e, 0xe3, 0x96, 0x8b, 0x28, 0xdf, 0x87, + 0x4a, 0xf3, 0x3a, 0xed, 0x7e, 0x1d, 0xdc, 0x66, 0x3b, 0xb8, 0x33, 0xc0, + 0x21, 0xc5, 0x00, 0x76, 0x74, 0x52, 0x52, 0xd0, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x5e, 0x6d, 0xe3, + 0x89, 0x3c, 0xcf, 0x11, 0xc8, 0xbf, 0xdc, 0x45, 0x5f, 0xd3, 0x3f, 0xd6, + 0xbd, 0x26, 0xbc, 0xbf, 0xc5, 0xc7, 0x3e, 0x26, 0xbc, 0xf6, 0x2b, 0xff, + 0x00, 0xa0, 0x8a, 0x00, 0xc7, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa3, 0xfa, 0xf5, 0xa2, 0x8a, 0x00, 0x96, + 0xde, 0xe6, 0x6b, 0x59, 0x44, 0xb0, 0x48, 0xd1, 0xc8, 0x3b, 0xa9, 0xc5, + 0x4b, 0x75, 0xaa, 0x5e, 0xdd, 0x93, 0xe7, 0x5c, 0xca, 0xd9, 0xed, 0xbb, + 0x15, 0x56, 0x8a, 0x00, 0x3b, 0xe7, 0xbf, 0xbd, 0x2d, 0x25, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0xb4, 0x98, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, + 0x00, 0x28, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x0b, 0x42, 0xf0, + 0x72, 0x32, 0x3b, 0xe4, 0x1c, 0x52, 0x51, 0x40, 0x0e, 0x67, 0x77, 0x39, + 0x76, 0x66, 0x61, 0xc0, 0x24, 0xe7, 0x02, 0x92, 0x92, 0x8a, 0x00, 0x28, + 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x2b, + 0xa5, 0xf0, 0x0c, 0xa5, 0x35, 0xd9, 0x23, 0xec, 0xf0, 0x91, 0xf9, 0x11, + 0xfe, 0x15, 0xcd, 0x56, 0xf7, 0x81, 0xff, 0x00, 0xe4, 0x64, 0x88, 0x7f, + 0xb0, 0xdf, 0xca, 0x80, 0x3d, 0x24, 0x7a, 0xd2, 0xd2, 0x0a, 0x5a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x2b, 0xcc, 0xbc, 0x67, 0x1e, 0xcf, 0x12, 0xdc, 0x13, 0xfc, 0x61, 0x48, + 0xff, 0x00, 0xbe, 0x45, 0x7a, 0x6d, 0x79, 0xf7, 0xc4, 0x08, 0x3c, 0xbd, + 0x5e, 0x19, 0x40, 0xe2, 0x58, 0x87, 0x3e, 0xe3, 0x20, 0xfe, 0x98, 0xa0, + 0x0e, 0x62, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0xba, 0x1f, 0x02, 0xa6, 0xef, 0x10, + 0x06, 0xfe, 0xe4, 0x4c, 0xc7, 0xf9, 0x7f, 0x5a, 0xe7, 0xba, 0x57, 0x5d, + 0xf0, 0xf2, 0xdf, 0x75, 0xd5, 0xd4, 0xe4, 0x70, 0xa8, 0x10, 0x1f, 0xaf, + 0xff, 0x00, 0xaa, 0x80, 0x3b, 0x91, 0x4b, 0x49, 0x4b, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x72, + 0xfe, 0x3d, 0xb3, 0xf3, 0xf4, 0xa4, 0xb8, 0x51, 0xf3, 0x40, 0xfc, 0xfd, + 0x0f, 0x1f, 0xcf, 0x15, 0xd3, 0xd7, 0x17, 0xe3, 0x2f, 0x10, 0x8d, 0xaf, + 0xa6, 0xdb, 0x61, 0x89, 0xe2, 0x67, 0xea, 0x07, 0xb0, 0xa0, 0x0e, 0x32, + 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, + 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, + 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, + 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, + 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, + 0x8a, 0x28, 0xa0, 0x03, 0xb5, 0x77, 0x7e, 0x01, 0x9a, 0xd8, 0x69, 0xf2, + 0xc4, 0x8f, 0xfe, 0x90, 0x5c, 0xb3, 0xa9, 0xf4, 0xed, 0x8a, 0xe1, 0x2a, + 0x6b, 0x4b, 0xb9, 0x6c, 0x6e, 0x12, 0x78, 0x1c, 0xa3, 0xa1, 0xc8, 0x23, + 0xf9, 0x50, 0x07, 0xb0, 0xd2, 0xd6, 0x56, 0x83, 0xac, 0xc7, 0xac, 0x59, + 0x09, 0x57, 0x0b, 0x2a, 0xf1, 0x22, 0x67, 0xa1, 0xff, 0x00, 0x0a, 0xd4, + 0xa0, 0x05, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa4, 0xa5, + 0xaa, 0xf7, 0x57, 0x31, 0xda, 0xdb, 0x49, 0x3c, 0x87, 0x09, 0x1a, 0x96, + 0x26, 0x80, 0x31, 0xbc, 0x5b, 0xae, 0x8d, 0x2a, 0xcf, 0xc9, 0x85, 0x87, + 0xda, 0x66, 0x18, 0x51, 0x9f, 0xba, 0x3d, 0x6b, 0xce, 0x8e, 0x59, 0x8b, + 0x12, 0x49, 0x27, 0x39, 0x35, 0x67, 0x55, 0xbf, 0x93, 0x53, 0xd4, 0x65, + 0xb9, 0x94, 0x93, 0xb8, 0x9d, 0xa3, 0xfb, 0xa3, 0xb0, 0xaa, 0xb4, 0x00, + 0x94, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x5f, 0xd1, 0x75, 0x49, + 0x74, 0x9b, 0xf4, 0xb8, 0x8f, 0x25, 0x73, 0x89, 0x13, 0x3f, 0x79, 0x6b, + 0xd4, 0xad, 0x2e, 0x62, 0xbb, 0xb7, 0x8e, 0x78, 0x5b, 0x74, 0x72, 0x0c, + 0xa9, 0xaf, 0x1f, 0xfe, 0x67, 0xa5, 0x75, 0xbe, 0x04, 0xd5, 0xcc, 0x72, + 0xb6, 0x9d, 0x33, 0x1d, 0x8f, 0xf3, 0x43, 0x9e, 0xc7, 0xd2, 0x80, 0x3b, + 0x9a, 0x5a, 0x6d, 0x3a, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x10, 0xf4, 0xae, + 0x3f, 0xc7, 0xda, 0x91, 0x8e, 0x18, 0xec, 0x22, 0x3f, 0x7f, 0xe7, 0x93, + 0x1e, 0x9d, 0x87, 0xf9, 0xf6, 0xae, 0xbc, 0x9e, 0x39, 0xaf, 0x29, 0xd7, + 0x6f, 0x8e, 0xa3, 0xab, 0xdc, 0x4f, 0x9f, 0x94, 0xb1, 0x09, 0xfe, 0xe8, + 0xa0, 0x0a, 0x14, 0x94, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, + 0x51, 0x40, 0x05, 0x4b, 0x6d, 0x71, 0x25, 0xad, 0xc4, 0x73, 0xc4, 0x70, + 0xf1, 0x9d, 0xc2, 0xa2, 0xa2, 0x80, 0x3d, 0x77, 0x4f, 0xbb, 0x5b, 0xeb, + 0x38, 0x6e, 0x23, 0xe9, 0x22, 0xe7, 0xe9, 0xea, 0x3f, 0x03, 0x56, 0xeb, + 0x92, 0xf8, 0x7f, 0x7a, 0x65, 0xb0, 0x9a, 0xd1, 0xce, 0x5a, 0x17, 0xdc, + 0xbf, 0x43, 0xff, 0x00, 0xd7, 0xae, 0xb6, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x4a, 0x5a, 0x4a, + 0x00, 0xcf, 0xd7, 0xae, 0xbe, 0xc7, 0xa3, 0x5d, 0xcc, 0x3a, 0xac, 0x64, + 0x2f, 0xd4, 0xf0, 0x3f, 0x5a, 0xf2, 0x93, 0xc8, 0xe6, 0xbd, 0x0b, 0xc7, + 0x53, 0x18, 0xf4, 0x1f, 0x2c, 0x1c, 0x79, 0x92, 0xa8, 0xc7, 0xb0, 0xc9, + 0xfe, 0x82, 0xbc, 0xf2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, + 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa5, 0xfe, 0x42, 0x80, 0x12, + 0x8a, 0x72, 0xa3, 0x39, 0xc2, 0x2b, 0x31, 0xf4, 0x00, 0xd5, 0x98, 0xf4, + 0xcb, 0xd9, 0x31, 0x8b, 0x77, 0x00, 0xfa, 0x8c, 0x7f, 0x3a, 0x34, 0x1d, + 0x99, 0x52, 0x8a, 0xd2, 0x1a, 0x15, 0xf9, 0xff, 0x00, 0x96, 0x4a, 0x3f, + 0xe0, 0x42, 0x97, 0xfb, 0x06, 0xf7, 0xfb, 0x8b, 0xff, 0x00, 0x7d, 0x0a, + 0x57, 0x41, 0xca, 0xcc, 0xca, 0x2b, 0x48, 0xe8, 0x57, 0xf9, 0xff, 0x00, + 0x54, 0xbf, 0xf7, 0xd0, 0xa6, 0x36, 0x8b, 0x7c, 0xa3, 0x98, 0x33, 0xf4, + 0x61, 0x45, 0xd0, 0x72, 0xb2, 0x85, 0x15, 0x6d, 0xb4, 0xbb, 0xd5, 0xeb, + 0x6f, 0x27, 0xe4, 0x2a, 0x23, 0x67, 0x70, 0xbd, 0x6d, 0xe5, 0xcf, 0xfb, + 0x86, 0x8b, 0xa0, 0xb3, 0x21, 0xa2, 0x9e, 0xd0, 0xc8, 0xa7, 0xe6, 0x8d, + 0xd7, 0xea, 0xa4, 0x52, 0x15, 0x3d, 0xd4, 0xfe, 0x46, 0x8b, 0x85, 0x98, + 0xda, 0x29, 0xdb, 0x4f, 0x70, 0x7f, 0x2a, 0x36, 0x9e, 0xc0, 0xfe, 0x54, + 0xee, 0x16, 0x1b, 0x45, 0x3b, 0x69, 0xf4, 0x3f, 0x95, 0x39, 0x61, 0x9a, + 0x4f, 0xb9, 0x13, 0xb7, 0xfb, 0xaa, 0x4d, 0x2b, 0x85, 0x99, 0x1d, 0x15, + 0x3a, 0xd9, 0x5d, 0x3f, 0x0b, 0x6f, 0x2f, 0xfd, 0xf1, 0x8f, 0xe7, 0x52, + 0x8d, 0x2a, 0xf8, 0xf4, 0xb6, 0x7f, 0xd2, 0x8b, 0xa0, 0xb3, 0x29, 0xd1, + 0x5a, 0x0b, 0xa1, 0xdf, 0x30, 0xcf, 0x93, 0x8f, 0xab, 0x01, 0x4e, 0x1a, + 0x0d, 0xf7, 0x78, 0x97, 0xfe, 0xfa, 0x14, 0x5d, 0x07, 0x2b, 0x33, 0x68, + 0xad, 0x3f, 0xec, 0x0b, 0xdc, 0x7d, 0xd4, 0xff, 0x00, 0xbe, 0x85, 0x27, + 0xf6, 0x15, 0xf8, 0x07, 0xf7, 0x4a, 0x7e, 0x8c, 0x28, 0xba, 0x0e, 0x56, + 0x66, 0xd1, 0x56, 0xa5, 0xd3, 0x6f, 0x22, 0x53, 0xbe, 0xde, 0x4c, 0x7a, + 0x85, 0xc8, 0xfd, 0x2a, 0xb3, 0x29, 0x53, 0x86, 0x52, 0x3d, 0x88, 0x34, + 0xee, 0x2b, 0x31, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, + 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0xe8, 0x7c, 0x0f, 0x73, 0xe4, + 0x6b, 0xeb, 0x19, 0x3c, 0x4c, 0x85, 0x7f, 0xaf, 0xf4, 0xaf, 0x46, 0xcd, + 0x79, 0x36, 0x89, 0x37, 0xd9, 0xf5, 0xcb, 0x39, 0x73, 0x8f, 0xdf, 0x28, + 0x27, 0xd8, 0x9c, 0x1f, 0xd0, 0xd7, 0xac, 0x0a, 0x00, 0x75, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x1c, 0x87, 0xc4, 0x56, 0xff, 0x00, 0x43, 0xb4, 0x5f, 0x59, 0x09, + 0xfd, 0x2b, 0x86, 0xae, 0xdb, 0xe2, 0x2f, 0xfa, 0x8b, 0x3f, 0xf7, 0x9b, + 0xf9, 0x0a, 0xe2, 0x68, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa5, 0xa4, 0xab, 0x3a, 0x7d, 0x84, 0x97, 0xf3, 0x88, 0xe3, 0xe0, + 0x0f, 0xbc, 0xc7, 0xa2, 0x8f, 0xf3, 0xd2, 0x93, 0xd0, 0x06, 0x5b, 0x5a, + 0xcd, 0x77, 0x27, 0x97, 0x0a, 0x16, 0x35, 0xd0, 0xd8, 0x78, 0x6e, 0x31, + 0x83, 0x36, 0x66, 0x6f, 0xee, 0x8e, 0x17, 0x35, 0xb5, 0xa5, 0xe9, 0x51, + 0x5a, 0xc2, 0xa1, 0x57, 0x0a, 0x7a, 0xf1, 0xcb, 0x7b, 0x9a, 0xd2, 0x00, + 0x2f, 0x0b, 0xc0, 0x1d, 0xab, 0x39, 0x4e, 0xfb, 0x1b, 0x46, 0x09, 0x6e, + 0x67, 0xdb, 0xe9, 0x8b, 0x12, 0xed, 0x45, 0x48, 0xc7, 0xa0, 0x15, 0x38, + 0xb2, 0x5e, 0xee, 0xc6, 0xac, 0xd2, 0x8a, 0x8b, 0x9a, 0x58, 0xaf, 0xf6, + 0x28, 0xbf, 0xda, 0xfc, 0xe9, 0x0d, 0x94, 0x5f, 0xed, 0x7e, 0x75, 0x66, + 0x8a, 0x00, 0xad, 0xf6, 0x28, 0xfd, 0x5a, 0x90, 0xd8, 0xaf, 0x67, 0x35, + 0x6a, 0x8a, 0x00, 0xa6, 0x6c, 0x7d, 0x1f, 0xf4, 0xa6, 0x9b, 0x27, 0xec, + 0xe2, 0xaf, 0x1a, 0x05, 0x00, 0x50, 0x36, 0x52, 0x76, 0xdb, 0x4d, 0xfb, + 0x14, 0x9f, 0xdd, 0x53, 0x5a, 0x26, 0x81, 0x45, 0xc2, 0xc8, 0xcd, 0x36, + 0x2f, 0xde, 0x25, 0xfc, 0x85, 0x02, 0xc5, 0xfb, 0x44, 0xbf, 0x90, 0xad, + 0x2a, 0x4a, 0x2e, 0x16, 0x46, 0x78, 0xb3, 0x93, 0xd1, 0x45, 0x38, 0x59, + 0x49, 0xdc, 0x81, 0x57, 0xa9, 0x68, 0xb8, 0x14, 0x45, 0x93, 0xf7, 0x71, + 0xf9, 0x53, 0x85, 0x88, 0xee, 0xff, 0x00, 0xa5, 0x5c, 0xa2, 0x8b, 0x81, + 0x50, 0x59, 0x27, 0x76, 0x26, 0x9e, 0x2c, 0xa2, 0xef, 0xbb, 0xf3, 0xab, + 0x14, 0x50, 0x05, 0x7f, 0xb1, 0xc3, 0xe8, 0x69, 0x3e, 0xc5, 0x17, 0x6d, + 0xdf, 0x9d, 0x59, 0xa2, 0x80, 0x2a, 0x9b, 0x25, 0xfe, 0x17, 0x35, 0x56, + 0xe7, 0x4a, 0x49, 0x94, 0x89, 0x22, 0x49, 0x41, 0xf5, 0x15, 0xa8, 0x68, + 0x14, 0x5c, 0x2c, 0x71, 0x97, 0xfe, 0x1a, 0xc1, 0x66, 0xb7, 0x62, 0xad, + 0xff, 0x00, 0x3c, 0xdb, 0xfa, 0x1a, 0xc1, 0x96, 0x29, 0x21, 0x90, 0xa4, + 0x8a, 0x55, 0x97, 0xb1, 0xaf, 0x4f, 0x74, 0x57, 0x18, 0x71, 0x9f, 0xc3, + 0xa5, 0x62, 0xeb, 0x3a, 0x2c, 0x77, 0x71, 0x1e, 0x06, 0xe1, 0xf7, 0x5f, + 0xd0, 0xfb, 0xfb, 0x55, 0xa9, 0x99, 0xca, 0x1d, 0x8e, 0x1e, 0x8a, 0x96, + 0xe6, 0xda, 0x5b, 0x59, 0xda, 0x29, 0x57, 0x6b, 0x2f, 0x7f, 0x5f, 0x7a, + 0x8a, 0xb5, 0x31, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x1c, + 0x8e, 0x63, 0x75, 0x71, 0xd5, 0x08, 0x6f, 0xca, 0xbd, 0x8d, 0x79, 0x03, + 0xe9, 0x5e, 0x34, 0x7a, 0x1a, 0xf6, 0x54, 0xfb, 0x8b, 0xf4, 0x14, 0x00, + 0xfa, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, + 0x0a, 0x28, 0xa2, 0x80, 0x39, 0x0f, 0x88, 0xa3, 0xfd, 0x0e, 0xd1, 0xbd, + 0x24, 0x61, 0xfa, 0x57, 0x0d, 0x5d, 0xf7, 0xc4, 0x28, 0xf3, 0xa3, 0xc3, + 0x27, 0xf7, 0x66, 0x03, 0xf3, 0x06, 0xb8, 0x1a, 0x00, 0x28, 0xa2, 0x8a, + 0x00, 0x28, 0xa2, 0x96, 0x80, 0x1f, 0x6d, 0x04, 0x97, 0x33, 0xa4, 0x31, + 0x02, 0x59, 0x8e, 0x3f, 0xfd, 0x75, 0xde, 0x68, 0xfa, 0x5c, 0x76, 0x76, + 0xca, 0xa1, 0x78, 0xea, 0x49, 0xee, 0x7d, 0x6b, 0x23, 0xc2, 0x5a, 0x66, + 0x50, 0xdc, 0xc8, 0xbf, 0x78, 0xe1, 0x7e, 0x9f, 0xfe, 0xba, 0xea, 0x80, + 0x00, 0x60, 0x74, 0x15, 0x94, 0xdd, 0xdd, 0x8d, 0xa1, 0x1b, 0x2b, 0xb1, + 0x47, 0x41, 0x9a, 0x28, 0x14, 0x1f, 0x5a, 0x83, 0x40, 0x35, 0x34, 0x56, + 0xc5, 0xf9, 0x63, 0x80, 0x69, 0xd6, 0xd0, 0xe7, 0xe7, 0x61, 0xf4, 0xab, + 0x55, 0x71, 0x8f, 0x73, 0x29, 0x4f, 0xa2, 0x21, 0x5b, 0x58, 0xc0, 0xc6, + 0x09, 0xf7, 0xcd, 0x35, 0xed, 0x06, 0x3e, 0x53, 0x83, 0x4d, 0xb8, 0xbf, + 0xb6, 0xb7, 0x38, 0x96, 0x55, 0x56, 0xf4, 0xce, 0x4d, 0x16, 0xda, 0x85, + 0xb5, 0xc9, 0xc4, 0x33, 0x23, 0x1f, 0x4c, 0xf3, 0x57, 0x64, 0x4d, 0xe5, + 0xb9, 0x5d, 0xd1, 0x91, 0x88, 0x65, 0xc1, 0xa0, 0x55, 0xe9, 0x62, 0x12, + 0x29, 0x07, 0xaf, 0x63, 0x54, 0x4a, 0xec, 0x62, 0xa7, 0xa8, 0xac, 0xe5, + 0x1b, 0x1a, 0x42, 0x57, 0x0a, 0x28, 0xa2, 0xa4, 0xb0, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa3, 0xbf, 0x4c, 0xd1, 0x56, 0x2d, 0x61, 0xe3, 0x7b, 0x7a, 0xf0, + 0x29, 0xa5, 0x76, 0x26, 0xec, 0xae, 0x24, 0x56, 0xc5, 0x80, 0x2e, 0x70, + 0x2a, 0x51, 0x6b, 0x1f, 0x7c, 0x9f, 0xc6, 0x96, 0x69, 0xe2, 0x81, 0x37, + 0x4d, 0x22, 0xa2, 0xfb, 0x9a, 0xae, 0x9a, 0xbd, 0x93, 0xb6, 0xd1, 0x3a, + 0x03, 0xef, 0xc5, 0x6a, 0x92, 0x46, 0x37, 0x93, 0x25, 0x7b, 0x51, 0x82, + 0x50, 0xe3, 0xda, 0xab, 0x32, 0x94, 0x38, 0x61, 0x83, 0x5a, 0x0a, 0xc1, + 0x97, 0x20, 0x82, 0x3d, 0x45, 0x32, 0x68, 0x84, 0x8a, 0x78, 0xe7, 0xb5, + 0x4c, 0xa3, 0xd8, 0x71, 0x9b, 0x5b, 0x94, 0x68, 0x23, 0x23, 0x04, 0x64, + 0x1e, 0xa2, 0x82, 0x36, 0x9c, 0x1e, 0xbd, 0xe8, 0x15, 0x99, 0xb1, 0x83, + 0xe2, 0x0d, 0x1d, 0x6e, 0xa0, 0x2d, 0x18, 0x02, 0x41, 0xca, 0x9e, 0xdf, + 0x43, 0xed, 0x5c, 0x5b, 0x29, 0x46, 0x2a, 0xc0, 0x82, 0x0e, 0x08, 0x3d, + 0x73, 0x5e, 0xa2, 0xc0, 0x30, 0x21, 0x80, 0xc1, 0x15, 0xc4, 0xf8, 0xab, + 0x4e, 0x36, 0xf7, 0x2b, 0x70, 0x06, 0x12, 0x43, 0xb5, 0xf1, 0xd8, 0xff, + 0x00, 0xf5, 0xc5, 0x69, 0x09, 0x74, 0x33, 0x9c, 0x7a, 0x98, 0x54, 0x52, + 0xd2, 0x56, 0x86, 0x21, 0x45, 0x14, 0x50, 0x02, 0x80, 0x4f, 0x4a, 0xf6, + 0x44, 0xfb, 0xa3, 0xe8, 0x2b, 0xc7, 0xad, 0x97, 0xcc, 0xba, 0x86, 0x3f, + 0xef, 0x48, 0xab, 0xf9, 0x90, 0x2b, 0xd8, 0x87, 0x41, 0xf4, 0xa0, 0x07, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x52, 0x52, 0xd2, 0x1e, 0x94, 0x01, 0x83, 0xe3, 0x68, 0x7c, 0xdf, 0x0e, + 0x4c, 0x47, 0x58, 0xd9, 0x5b, 0xf5, 0xc7, 0xf5, 0xaf, 0x36, 0xaf, 0x58, + 0xd6, 0xa0, 0xfb, 0x4e, 0x8d, 0x77, 0x0f, 0x76, 0x89, 0xb1, 0xf5, 0xc6, + 0x6b, 0xca, 0x39, 0xe9, 0xde, 0x80, 0x12, 0x8a, 0x28, 0xa0, 0x02, 0xa4, + 0x82, 0x36, 0x9a, 0x74, 0x88, 0x73, 0xbd, 0x82, 0xfe, 0x75, 0x1d, 0x68, + 0xf8, 0x7a, 0x21, 0x2e, 0xb5, 0x6c, 0xac, 0x38, 0xde, 0x49, 0xfc, 0x29, + 0x31, 0xad, 0xce, 0xee, 0xc6, 0x01, 0x6d, 0x6b, 0x1c, 0x4a, 0x31, 0x80, + 0x3f, 0x95, 0x58, 0xa6, 0x8e, 0x82, 0x9d, 0x58, 0x1d, 0x21, 0x42, 0x29, + 0x77, 0x0b, 0xdc, 0x9a, 0x2a, 0x6b, 0x41, 0x99, 0xb3, 0xe8, 0x29, 0xad, + 0x58, 0xa4, 0xec, 0x8b, 0x6a, 0x02, 0xae, 0x07, 0x6a, 0xca, 0xd6, 0x2f, + 0xe5, 0x8d, 0x96, 0xda, 0xd0, 0x33, 0x4e, 0xe3, 0x27, 0x03, 0x3b, 0x47, + 0xad, 0x6a, 0xbb, 0x05, 0x52, 0x7d, 0x2b, 0x9d, 0xd2, 0x35, 0x08, 0x9b, + 0x53, 0xb8, 0x79, 0x9c, 0x29, 0x94, 0xfc, 0x84, 0xfa, 0x64, 0xf1, 0x5a, + 0xbe, 0xc6, 0x30, 0x4d, 0xea, 0x64, 0x5d, 0x5b, 0x4f, 0x6e, 0xe0, 0xdc, + 0x23, 0xa1, 0x63, 0xd4, 0x8c, 0xfe, 0xb5, 0x0a, 0xb1, 0x53, 0xb8, 0x1c, + 0x30, 0x3d, 0x73, 0x5d, 0x27, 0x89, 0x2e, 0xa0, 0x6b, 0x2f, 0x29, 0x4a, + 0xbc, 0x85, 0x81, 0x18, 0xed, 0xef, 0x5c, 0xdf, 0x7f, 0xaf, 0x35, 0x93, + 0x56, 0x67, 0x5d, 0x37, 0xcc, 0xb5, 0x47, 0x4f, 0xa0, 0xea, 0x86, 0xe5, + 0x7c, 0x89, 0x8e, 0x65, 0x5e, 0x41, 0xf5, 0x15, 0x7a, 0xf1, 0x0e, 0xe0, + 0xeb, 0x5c, 0x85, 0xa4, 0xe6, 0xda, 0xea, 0x29, 0x54, 0xe3, 0x6b, 0x0c, + 0xfb, 0x8e, 0xf5, 0xda, 0x4d, 0x89, 0x2d, 0xf7, 0x0e, 0xe3, 0x22, 0xae, + 0xf7, 0x46, 0x13, 0x8f, 0x2c, 0xae, 0x8a, 0x60, 0xf1, 0x45, 0x02, 0x8a, + 0xcc, 0xb0, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x01, 0x63, 0x4f, 0x31, 0xd5, 0x7d, 0x4d, + 0x58, 0xbd, 0xbb, 0x8e, 0xc2, 0xd1, 0xa5, 0x7e, 0x8b, 0xc0, 0x1e, 0xb4, + 0xcb, 0x35, 0xcc, 0xa4, 0xfa, 0x56, 0x2f, 0x89, 0xee, 0x0b, 0xdc, 0xa5, + 0xb8, 0x3f, 0x2a, 0x8c, 0x91, 0xea, 0x4d, 0x5c, 0x74, 0x57, 0x33, 0x6b, + 0x9a, 0x56, 0x28, 0x4c, 0xd7, 0x7a, 0x8b, 0xbc, 0xed, 0x1b, 0xc8, 0x07, + 0x65, 0x07, 0x02, 0xaa, 0x63, 0x07, 0x07, 0x8c, 0x57, 0x53, 0xa4, 0x6a, + 0x16, 0x8b, 0x61, 0x1a, 0x19, 0x12, 0x36, 0x51, 0x86, 0x0c, 0x79, 0xae, + 0x7b, 0x50, 0x96, 0x39, 0xef, 0xe5, 0x92, 0x21, 0x84, 0x27, 0x8a, 0x4d, + 0x1b, 0x41, 0xbb, 0xf2, 0xd8, 0xb7, 0xa3, 0xea, 0xaf, 0x6b, 0x38, 0x8e, + 0x56, 0x2d, 0x0b, 0x1c, 0x7d, 0x3f, 0xfa, 0xd5, 0xd6, 0x2b, 0x06, 0x50, + 0x41, 0xc8, 0x3c, 0x83, 0x5c, 0x06, 0x3f, 0x3a, 0xeb, 0xb4, 0x1b, 0x93, + 0x71, 0xa6, 0xa1, 0x6e, 0x59, 0x3e, 0x53, 0xf8, 0x55, 0x45, 0xf4, 0x66, + 0x75, 0xa0, 0x96, 0xa8, 0x9e, 0xf1, 0x30, 0xe1, 0x87, 0x43, 0x50, 0x0a, + 0xbb, 0x76, 0xbb, 0xa1, 0x3e, 0xd5, 0x4a, 0xa6, 0x4a, 0xcc, 0x50, 0x77, + 0x40, 0x79, 0xac, 0xdd, 0x7e, 0xcc, 0x5d, 0xe9, 0x93, 0x0c, 0x65, 0x95, + 0x77, 0x0f, 0xa8, 0xad, 0x23, 0x4d, 0x74, 0x0e, 0x85, 0x58, 0x64, 0x10, + 0x45, 0x4a, 0xdc, 0xb7, 0xb1, 0xe5, 0xd8, 0x23, 0x83, 0xd4, 0x75, 0xa4, + 0xa9, 0x2e, 0x57, 0x65, 0xcc, 0xab, 0xfd, 0xd7, 0x22, 0xa3, 0xae, 0x83, + 0x94, 0x29, 0x69, 0x29, 0x7d, 0x28, 0x02, 0xe6, 0x8b, 0x1f, 0x9b, 0xad, + 0xd9, 0x20, 0x1c, 0x79, 0xe8, 0x4f, 0xd3, 0x22, 0xbd, 0x64, 0x57, 0x98, + 0xf8, 0x42, 0x2f, 0x37, 0xc4, 0x76, 0xb9, 0x1f, 0x74, 0x96, 0xfc, 0x94, + 0x8f, 0xeb, 0x5e, 0x9c, 0x28, 0x01, 0xd4, 0x51, 0x45, 0x00, 0x14, 0x51, + 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, + 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, + 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, + 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x49, 0x40, 0x0b, 0x45, + 0x25, 0x14, 0x00, 0xb4, 0x52, 0x66, 0x8a, 0x00, 0x5a, 0x29, 0x28, 0xa0, + 0x05, 0xa2, 0x92, 0x90, 0xba, 0x8e, 0xac, 0x07, 0xe3, 0x40, 0x0b, 0x45, + 0x37, 0xcc, 0x4f, 0xef, 0x2f, 0xe7, 0x49, 0xe7, 0x46, 0x3a, 0xc8, 0x83, + 0xfe, 0x04, 0x28, 0x02, 0x4a, 0x2a, 0x2f, 0x3e, 0x2f, 0xf9, 0xea, 0x9f, + 0xf7, 0xd0, 0xa3, 0xcf, 0x8b, 0xfe, 0x7a, 0xa7, 0xfd, 0xf4, 0x28, 0x01, + 0xec, 0xa1, 0x94, 0x82, 0x32, 0x08, 0xc1, 0xaf, 0x23, 0xd5, 0x2d, 0x8d, + 0x9e, 0xa5, 0x71, 0x01, 0xff, 0x00, 0x96, 0x72, 0x10, 0x3e, 0x99, 0xe2, + 0xbd, 0x68, 0x4b, 0x19, 0xe8, 0xeb, 0xf9, 0xd7, 0x01, 0xe3, 0xcb, 0x41, + 0x16, 0xaa, 0x97, 0x0b, 0x8d, 0xb3, 0xa7, 0x38, 0x3d, 0xc5, 0x00, 0x73, + 0x54, 0x52, 0xd2, 0x50, 0x01, 0x5a, 0xbe, 0x17, 0x3f, 0xf1, 0x3c, 0xb7, + 0xcf, 0xfb, 0x5f, 0xc8, 0xd6, 0x55, 0x68, 0x68, 0x12, 0x79, 0x7a, 0xd5, + 0xa9, 0x3d, 0xdf, 0x1f, 0x9e, 0x45, 0x27, 0xb0, 0xd6, 0xe7, 0xa2, 0x63, + 0x8a, 0x28, 0xcd, 0x15, 0x81, 0xd2, 0x15, 0x3d, 0x97, 0xdf, 0x6f, 0xa5, + 0x40, 0x6a, 0x6b, 0x46, 0xc4, 0xa4, 0x7a, 0x8a, 0x71, 0xdc, 0x99, 0xec, + 0x4d, 0x76, 0x71, 0x69, 0x29, 0x1d, 0x42, 0x13, 0xfa, 0x57, 0x08, 0x3b, + 0x1f, 0xc6, 0xbb, 0xe9, 0x57, 0x7c, 0x4c, 0x9f, 0xde, 0x04, 0x57, 0x0b, + 0x22, 0x18, 0xe4, 0x68, 0xc8, 0xe5, 0x49, 0x1f, 0x95, 0x5c, 0xc7, 0x43, + 0xa8, 0xca, 0x29, 0x68, 0xa8, 0x3a, 0x44, 0x27, 0x1c, 0xd7, 0x6d, 0x6c, + 0xd9, 0xd3, 0x63, 0x27, 0xa9, 0x41, 0x5c, 0x5a, 0x23, 0x49, 0x22, 0xa2, + 0xff, 0x00, 0x19, 0xc5, 0x76, 0xe5, 0x04, 0x56, 0x41, 0x07, 0x45, 0x50, + 0x2a, 0xa2, 0x73, 0x57, 0xdd, 0x15, 0x05, 0x14, 0x0a, 0x2a, 0x06, 0x14, + 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, + 0x51, 0x45, 0x00, 0x58, 0xb2, 0xea, 0xf5, 0xcc, 0x6b, 0xc4, 0x9d, 0x5a, + 0x6c, 0xfb, 0x63, 0xf2, 0xae, 0x9a, 0xcd, 0xb1, 0x21, 0x1e, 0xb5, 0xcf, + 0x78, 0x8e, 0x23, 0x1e, 0xa6, 0x5f, 0x1c, 0x48, 0xb9, 0xfd, 0x2a, 0xfe, + 0xc9, 0x30, 0xd2, 0x66, 0x5d, 0x2f, 0xf5, 0xa4, 0x1d, 0x29, 0x6a, 0x0e, + 0xa0, 0xae, 0x8f, 0xc2, 0xcd, 0xfe, 0x8f, 0x30, 0xec, 0x18, 0x57, 0x36, + 0x6b, 0xa9, 0xf0, 0xcc, 0x3b, 0x34, 0xf6, 0x90, 0x8c, 0x19, 0x1b, 0x35, + 0x70, 0xdc, 0xc2, 0xb3, 0xf7, 0x4d, 0x49, 0xff, 0x00, 0xd4, 0xb7, 0xd2, + 0xa8, 0x0e, 0x82, 0xae, 0xdc, 0xb6, 0xd8, 0x5a, 0xa9, 0x0a, 0x27, 0xb9, + 0x95, 0x3d, 0x82, 0x94, 0x75, 0x14, 0x94, 0x13, 0x80, 0x4f, 0xa5, 0x42, + 0x34, 0x3c, 0xca, 0xff, 0x00, 0x9b, 0xfb, 0x83, 0xff, 0x00, 0x4d, 0x1b, + 0xf9, 0xd4, 0x15, 0x25, 0xc3, 0x17, 0xb8, 0x91, 0xbf, 0xbc, 0xc4, 0xfe, + 0xb5, 0x1d, 0x74, 0x2d, 0x8e, 0x67, 0xb8, 0x52, 0xf3, 0x8e, 0x3a, 0xd2, + 0x51, 0xf4, 0xa0, 0x47, 0x4f, 0xf0, 0xfe, 0x0f, 0x33, 0x58, 0x9a, 0x6c, + 0x7c, 0xb1, 0x45, 0x81, 0xf8, 0x9f, 0xfe, 0xb1, 0xaf, 0x40, 0xae, 0x4f, + 0xc0, 0x16, 0xe2, 0x2d, 0x3e, 0xe2, 0xe5, 0x88, 0x1e, 0x74, 0x81, 0x57, + 0x27, 0xb0, 0xff, 0x00, 0xf5, 0xd7, 0x52, 0x65, 0x8c, 0x75, 0x91, 0x47, + 0xfc, 0x08, 0x50, 0x04, 0x94, 0x54, 0x5e, 0x7c, 0x5f, 0xf3, 0xd5, 0x3f, + 0xef, 0xa1, 0x47, 0x9f, 0x17, 0xfc, 0xf5, 0x4f, 0xfb, 0xe8, 0x50, 0x04, + 0xb4, 0x54, 0x42, 0x68, 0x8f, 0x49, 0x13, 0xfe, 0xfa, 0x14, 0xef, 0x31, + 0x3f, 0xbc, 0xbf, 0x9d, 0x00, 0x3e, 0x8a, 0x68, 0x75, 0x3d, 0x18, 0x1f, + 0xc6, 0x96, 0x80, 0x16, 0x8a, 0x4a, 0x28, 0x01, 0x68, 0xa4, 0xa2, 0x80, + 0x16, 0x8a, 0x4a, 0x28, 0x01, 0x68, 0xa4, 0xa2, 0x80, 0x16, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x04, 0xcd, 0x55, 0xb8, 0xd4, 0x2d, 0x2d, + 0x4f, 0xef, 0xae, 0x62, 0x88, 0xfa, 0x33, 0x81, 0x56, 0x4d, 0x67, 0x7f, + 0x61, 0xe9, 0xcd, 0x33, 0xcc, 0xd6, 0x91, 0x3c, 0x92, 0x31, 0x66, 0x67, + 0x19, 0xc9, 0x3e, 0xc6, 0x80, 0x20, 0x7f, 0x14, 0xe9, 0x6a, 0xdb, 0x52, + 0x66, 0x95, 0xbd, 0x23, 0x42, 0xd4, 0x87, 0x5f, 0x96, 0x4f, 0xf8, 0xf7, + 0xd2, 0xef, 0x24, 0xf7, 0x64, 0xdb, 0xfc, 0xeb, 0x56, 0x28, 0x22, 0x88, + 0x62, 0x38, 0x96, 0x31, 0xe8, 0x14, 0x0a, 0x93, 0x14, 0x01, 0x89, 0xf6, + 0xfd, 0x72, 0x4f, 0xf5, 0x7a, 0x64, 0x51, 0xe7, 0xa1, 0x92, 0x51, 0xfd, + 0x29, 0x42, 0xf8, 0x86, 0x51, 0xcb, 0xda, 0x43, 0x9f, 0x40, 0x4e, 0x2b, + 0x6e, 0x8c, 0xf7, 0xa0, 0x0c, 0x51, 0xa7, 0xeb, 0x2f, 0xfe, 0xb3, 0x54, + 0x44, 0xff, 0x00, 0x72, 0x21, 0x41, 0xd0, 0xef, 0x24, 0x1f, 0xbe, 0xd6, + 0x2e, 0x4f, 0xfb, 0x80, 0x2d, 0x6d, 0x64, 0x51, 0x9a, 0x00, 0xc3, 0x1e, + 0x19, 0x53, 0xf7, 0xf5, 0x1b, 0xe7, 0xfa, 0xcb, 0x47, 0xfc, 0x22, 0x96, + 0x47, 0xef, 0xcd, 0x74, 0xff, 0x00, 0x59, 0x4d, 0x6e, 0x12, 0x3b, 0xd4, + 0x32, 0x5d, 0x43, 0x17, 0xfa, 0xc9, 0xa3, 0x4f, 0xf7, 0x9c, 0x0a, 0x00, + 0xca, 0x1e, 0x13, 0xd3, 0x57, 0xa8, 0x98, 0xfd, 0x65, 0x34, 0xa3, 0xc2, + 0x9a, 0x5f, 0x78, 0x5c, 0xfd, 0x64, 0x35, 0x6a, 0x4d, 0x73, 0x4c, 0x87, + 0xef, 0xdf, 0xc1, 0xf8, 0x38, 0x3f, 0xca, 0xab, 0xb7, 0x8a, 0x74, 0xa1, + 0x90, 0xb7, 0x0c, 0xe7, 0xd1, 0x23, 0x63, 0xfd, 0x28, 0x01, 0x3f, 0xe1, + 0x14, 0xd2, 0xbf, 0xe7, 0x83, 0x7f, 0xdf, 0x66, 0x93, 0xfe, 0x11, 0x5d, + 0x2b, 0xfe, 0x78, 0xb7, 0xfd, 0xfc, 0x34, 0x7f, 0xc2, 0x51, 0x6a, 0xdf, + 0xea, 0xad, 0xaf, 0x25, 0xff, 0x00, 0x72, 0x03, 0x47, 0xfc, 0x24, 0x13, + 0x3f, 0xfa, 0xad, 0x1f, 0x51, 0x6f, 0x76, 0x8c, 0x2f, 0xf5, 0xa0, 0x00, + 0xf8, 0x4f, 0x4b, 0xff, 0x00, 0x9e, 0x52, 0x0f, 0xa4, 0x86, 0xb3, 0x35, + 0xbf, 0x0a, 0xda, 0x2e, 0x97, 0x34, 0x96, 0xbe, 0x67, 0x9d, 0x1a, 0x97, + 0x5c, 0xb9, 0x6f, 0xaf, 0xe7, 0x5a, 0x27, 0x58, 0xd5, 0x1c, 0x7e, 0xef, + 0x42, 0x9c, 0xff, 0x00, 0xbf, 0x3a, 0xad, 0x0f, 0xa8, 0xeb, 0x4e, 0x08, + 0x1a, 0x22, 0x80, 0x78, 0x3b, 0xee, 0x41, 0xfe, 0x42, 0x80, 0x3c, 0xd0, + 0x13, 0xde, 0x8a, 0xd0, 0xd6, 0xf4, 0xfb, 0x8d, 0x3e, 0xf4, 0xfd, 0xa2, + 0x01, 0x08, 0x94, 0x97, 0x45, 0x0c, 0x0a, 0xe3, 0xd3, 0x35, 0x9f, 0x40, + 0x05, 0x49, 0x6f, 0x2f, 0x93, 0x71, 0x1c, 0xa0, 0xe3, 0xcb, 0x65, 0x61, + 0xf8, 0x1a, 0x8e, 0x8e, 0x7b, 0x50, 0x07, 0xa8, 0xc4, 0xe2, 0x58, 0x92, + 0x45, 0xe4, 0x30, 0xc8, 0x3e, 0xd4, 0xfa, 0xc7, 0xf0, 0xb5, 0xea, 0xdd, + 0xe8, 0xf1, 0xa9, 0x39, 0x92, 0x1f, 0xdd, 0x91, 0xec, 0x39, 0x1f, 0xa5, + 0x6c, 0x56, 0x0f, 0x46, 0x74, 0xa7, 0x74, 0x14, 0xb1, 0x39, 0x59, 0x54, + 0xf6, 0xce, 0x29, 0x33, 0x41, 0xa4, 0x86, 0xf5, 0x34, 0x73, 0x9f, 0xce, + 0xb9, 0x8f, 0x10, 0xd8, 0x34, 0x37, 0x06, 0xe1, 0x01, 0xd9, 0x27, 0xde, + 0xc7, 0xf0, 0x9c, 0xf5, 0xae, 0x86, 0xda, 0x6d, 0xcb, 0xb5, 0xbe, 0xf0, + 0xa9, 0x24, 0x8d, 0x25, 0x42, 0x92, 0x00, 0xca, 0xc3, 0x04, 0x1a, 0xd9, + 0xda, 0x48, 0xc2, 0x32, 0x70, 0x91, 0xc1, 0x76, 0xcd, 0x2d, 0x74, 0x37, + 0x3e, 0x1a, 0x46, 0x25, 0xad, 0xe6, 0xd8, 0x3f, 0xba, 0x57, 0x22, 0x8b, + 0x6f, 0x0c, 0xa2, 0xb6, 0xeb, 0x89, 0xb7, 0x8f, 0xee, 0xa8, 0xda, 0x2b, + 0x3e, 0x56, 0x74, 0xfb, 0x68, 0xd8, 0xab, 0xe1, 0xdd, 0x3d, 0xa6, 0xb9, + 0x17, 0x2e, 0xb8, 0x8d, 0x3e, 0xee, 0x7b, 0x9a, 0xe8, 0x2f, 0x1f, 0xe5, + 0x0a, 0x3b, 0xd3, 0xd1, 0x12, 0xde, 0x10, 0xa8, 0x02, 0xa2, 0x8c, 0x00, + 0x06, 0x2a, 0x9b, 0xb9, 0x91, 0xcb, 0x1f, 0xc2, 0xa9, 0xfb, 0xaa, 0xc6, + 0x29, 0xb9, 0xca, 0xe2, 0x01, 0x45, 0x14, 0x56, 0x46, 0x81, 0x45, 0x14, + 0x66, 0x98, 0x06, 0x68, 0xa8, 0x6e, 0x2e, 0xa1, 0xb7, 0xff, 0x00, 0x5a, + 0xe0, 0x1f, 0x4e, 0xf4, 0x41, 0x75, 0x0d, 0xc0, 0xcc, 0x4e, 0x1c, 0xf7, + 0x1e, 0x94, 0x0e, 0xc4, 0xd4, 0x51, 0x45, 0x02, 0x0a, 0x28, 0xa2, 0x80, + 0x1d, 0x0b, 0x14, 0x94, 0x37, 0xbe, 0x29, 0x9a, 0xed, 0x81, 0xbd, 0xb3, + 0xdd, 0x18, 0xfd, 0xe4, 0x7c, 0xaf, 0xbd, 0x2e, 0x3d, 0x2a, 0xe5, 0xb4, + 0xbb, 0xd3, 0x69, 0xea, 0x2a, 0xe3, 0xd8, 0xce, 0x57, 0x4f, 0x99, 0x1c, + 0x29, 0xc8, 0x24, 0x1e, 0x08, 0xeb, 0xed, 0x45, 0x75, 0x9a, 0x86, 0x87, + 0x0d, 0xdb, 0x79, 0x8a, 0xc6, 0x29, 0x0f, 0x52, 0x06, 0x41, 0xfc, 0x2a, + 0x82, 0x78, 0x62, 0x4d, 0xd8, 0x92, 0xe1, 0x76, 0xe7, 0xf8, 0x57, 0x9a, + 0x1c, 0x59, 0xb4, 0x6b, 0x45, 0xad, 0x4c, 0x9b, 0x3b, 0x59, 0x2f, 0x2e, + 0x56, 0x28, 0xc6, 0x77, 0x1e, 0x4f, 0xf7, 0x45, 0x76, 0xb6, 0xf1, 0x2d, + 0xbc, 0x0b, 0x12, 0x8f, 0x95, 0x06, 0x05, 0x43, 0x63, 0xa7, 0xc3, 0x63, + 0x1e, 0xd8, 0x97, 0x9e, 0xec, 0x7a, 0x9a, 0xb0, 0xee, 0x11, 0x37, 0x31, + 0xc0, 0x15, 0x51, 0x56, 0x30, 0xa9, 0x3e, 0x76, 0x41, 0x78, 0xfc, 0x84, + 0x1f, 0x5a, 0xad, 0x43, 0xb9, 0x77, 0x2c, 0x7b, 0xd2, 0x0e, 0x95, 0x9b, + 0x77, 0x65, 0xc5, 0x59, 0x0b, 0x55, 0xf5, 0x09, 0xbc, 0x8b, 0x09, 0xa5, + 0xce, 0x36, 0xa1, 0x3f, 0xa1, 0xab, 0x15, 0x87, 0xe2, 0xfb, 0xbf, 0xb3, + 0xe9, 0x0d, 0x10, 0x3f, 0x3c, 0xec, 0x17, 0x1e, 0xc3, 0xad, 0x09, 0x5d, + 0x8d, 0xe8, 0x8e, 0x20, 0x9c, 0x9f, 0x6c, 0xd2, 0x52, 0x9a, 0x4a, 0xdc, + 0xe6, 0x0a, 0x50, 0x0b, 0x10, 0x17, 0x96, 0x3d, 0x07, 0xad, 0x25, 0x69, + 0x78, 0x7e, 0xca, 0xe6, 0xef, 0x52, 0x49, 0x2d, 0x6d, 0xc4, 0xed, 0x01, + 0x0e, 0xca, 0xed, 0x81, 0x40, 0x1d, 0x8d, 0x87, 0x84, 0x6c, 0x92, 0xce, + 0x21, 0x37, 0x9d, 0xe6, 0x6c, 0xcb, 0xe2, 0x42, 0x06, 0x7e, 0x95, 0x68, + 0x78, 0x4f, 0x4b, 0xef, 0x1c, 0xa7, 0xeb, 0x21, 0xa6, 0xff, 0x00, 0x68, + 0xeb, 0x83, 0xef, 0x68, 0xe8, 0x7f, 0xdd, 0xb9, 0x14, 0xa7, 0x57, 0xd5, + 0x97, 0xef, 0xe8, 0x32, 0xff, 0x00, 0xc0, 0x2e, 0x15, 0xbf, 0xa5, 0x00, + 0x3b, 0xfe, 0x11, 0x4d, 0x2b, 0xfe, 0x78, 0x31, 0xff, 0x00, 0xb6, 0x86, + 0x8f, 0xf8, 0x45, 0x34, 0xaf, 0xf9, 0xe0, 0xdf, 0xf7, 0xd9, 0xa6, 0x8d, + 0x7a, 0xe5, 0x07, 0xef, 0x34, 0x4d, 0x40, 0x1f, 0xf6, 0x14, 0x37, 0xf5, + 0xa3, 0xfe, 0x12, 0x48, 0x54, 0x7e, 0xfa, 0xca, 0xfe, 0x2f, 0xf7, 0xa0, + 0x3c, 0x7e, 0x54, 0x00, 0xa7, 0xc2, 0x9a, 0x5f, 0xfc, 0xf1, 0x7f, 0xc2, + 0x43, 0x41, 0xf0, 0x9e, 0x98, 0x7a, 0x24, 0xa3, 0xe9, 0x29, 0xa5, 0x5f, + 0x14, 0xe9, 0x7f, 0xc7, 0x2c, 0x91, 0xff, 0x00, 0xbd, 0x13, 0x0f, 0xe9, + 0x53, 0xc5, 0xaf, 0xe9, 0x52, 0x0f, 0x96, 0xfe, 0x1f, 0xf8, 0x13, 0x63, + 0xf9, 0xd0, 0x05, 0x5f, 0xf8, 0x44, 0xec, 0x47, 0xdd, 0x96, 0xe5, 0x7e, + 0x92, 0x9a, 0x3f, 0xe1, 0x17, 0x8d, 0x7f, 0xd5, 0xdf, 0xde, 0xa7, 0xd2, + 0x5a, 0xd4, 0x8e, 0xf6, 0xde, 0x61, 0x98, 0xe7, 0x89, 0xff, 0x00, 0xdd, + 0x70, 0x6a, 0x70, 0xc0, 0xf4, 0x34, 0x01, 0x8a, 0x34, 0x0b, 0x88, 0xff, + 0x00, 0xd4, 0xea, 0xf7, 0x8b, 0xfe, 0xf1, 0x0d, 0x4b, 0xfd, 0x99, 0xac, + 0x20, 0xf9, 0x35, 0x7d, 0xc7, 0xfd, 0xb8, 0x85, 0x6d, 0x51, 0x91, 0x40, + 0x18, 0x9e, 0x57, 0x88, 0x22, 0xfb, 0xb7, 0x16, 0x92, 0x8e, 0xd9, 0x52, + 0x29, 0x05, 0xde, 0xbf, 0x11, 0x1e, 0x65, 0x84, 0x12, 0x8f, 0x54, 0x93, + 0x15, 0xb9, 0x46, 0x05, 0x00, 0x62, 0x7f, 0x6e, 0xdd, 0xc7, 0xff, 0x00, + 0x1f, 0x1a, 0x45, 0xca, 0x8f, 0x54, 0xc3, 0x52, 0x8f, 0x14, 0xe9, 0xca, + 0x76, 0xcc, 0xd2, 0xdb, 0xb7, 0xf7, 0x65, 0x88, 0xad, 0x6d, 0x53, 0x1e, + 0x34, 0x71, 0x86, 0x50, 0x41, 0xec, 0x45, 0x00, 0x55, 0xb7, 0xd6, 0x2c, + 0x2e, 0x3f, 0xd4, 0xde, 0x42, 0xc7, 0xd3, 0x78, 0x15, 0x70, 0x10, 0x7d, + 0xea, 0x84, 0xda, 0x16, 0x9b, 0x71, 0xcc, 0x96, 0x71, 0x67, 0xd5, 0x57, + 0x15, 0x79, 0x10, 0x46, 0x81, 0x54, 0x60, 0x01, 0x80, 0x28, 0x01, 0xf4, + 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, + 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x25, 0x19, 0xe2, 0x96, 0xb2, + 0xaf, 0x64, 0xd5, 0x9a, 0xe5, 0xa3, 0xb3, 0x8a, 0xd9, 0x22, 0x03, 0xfd, + 0x6c, 0xac, 0x49, 0x3f, 0x80, 0xa0, 0x0d, 0x4a, 0x82, 0x7b, 0xcb, 0x7b, + 0x75, 0xcc, 0xd3, 0xc7, 0x18, 0xff, 0x00, 0x69, 0x80, 0xac, 0x93, 0xa2, + 0x5f, 0x5d, 0x73, 0x7d, 0xaa, 0xcc, 0x41, 0x3c, 0xa4, 0x00, 0x20, 0xa9, + 0xad, 0xfc, 0x35, 0xa6, 0x42, 0x77, 0x1b, 0x7f, 0x35, 0x87, 0xf1, 0x4a, + 0xc5, 0xcf, 0xeb, 0x40, 0x09, 0x27, 0x89, 0xb4, 0xd5, 0x6d, 0xb1, 0xc9, + 0x24, 0xed, 0xe9, 0x12, 0x16, 0xa6, 0x8d, 0x6a, 0xf2, 0x60, 0x4d, 0xae, + 0x95, 0x70, 0xe0, 0xf4, 0x32, 0x10, 0x82, 0xb5, 0x62, 0xb7, 0x8a, 0x11, + 0x88, 0xe3, 0x44, 0x1f, 0xec, 0xae, 0x2a, 0x5c, 0x7a, 0xd0, 0x06, 0x11, + 0x6f, 0x11, 0x5c, 0x7d, 0xd8, 0xed, 0x2d, 0x81, 0xfe, 0xf1, 0x2e, 0x45, + 0x20, 0xd2, 0x75, 0x69, 0xb1, 0xf6, 0x8d, 0x65, 0xd4, 0x77, 0x11, 0x46, + 0x17, 0xf5, 0xad, 0xec, 0x51, 0x8a, 0x00, 0xc4, 0x5f, 0x0d, 0x40, 0xff, + 0x00, 0xf1, 0xf1, 0x77, 0x79, 0x3f, 0xfb, 0xf2, 0x91, 0xfc, 0xaa, 0x64, + 0xf0, 0xd6, 0x96, 0x9c, 0x9b, 0x45, 0x73, 0xea, 0xe4, 0x9a, 0xd5, 0xa2, + 0x80, 0x29, 0xc7, 0xa5, 0x58, 0xc5, 0xfe, 0xae, 0xd2, 0x10, 0x7f, 0xdc, + 0x15, 0x61, 0x20, 0x89, 0x3e, 0xec, 0x68, 0xbf, 0x45, 0x02, 0xa4, 0xa2, + 0x80, 0x13, 0x1e, 0x9c, 0x52, 0xe2, 0x8a, 0x5a, 0x00, 0x4c, 0x71, 0x46, + 0x29, 0x68, 0xa0, 0x0c, 0x7f, 0x10, 0xe9, 0x0b, 0xab, 0xe9, 0xcd, 0x16, + 0x00, 0x95, 0x3e, 0x68, 0xdb, 0xd0, 0x8f, 0xf1, 0xaf, 0x32, 0x96, 0x27, + 0x86, 0x56, 0x8a, 0x55, 0x2a, 0xea, 0xdb, 0x4a, 0x9e, 0xa0, 0xd7, 0xb2, + 0x62, 0xb9, 0x4f, 0x17, 0xf8, 0x77, 0xed, 0x8a, 0x6f, 0xed, 0x14, 0x7d, + 0xa1, 0x07, 0xef, 0x14, 0x0f, 0xbe, 0x3f, 0xc6, 0x80, 0x38, 0x3a, 0x29, + 0x7a, 0x1c, 0x1e, 0x29, 0x28, 0x03, 0x5b, 0xc3, 0x5a, 0x90, 0xd3, 0xf5, + 0x10, 0x24, 0x38, 0x86, 0x6f, 0x91, 0x8f, 0xa7, 0xbd, 0x77, 0xbd, 0x46, + 0x45, 0x79, 0x6f, 0xf4, 0xae, 0xbf, 0xc3, 0x1a, 0xe0, 0x9d, 0x16, 0xca, + 0xe5, 0xb1, 0x22, 0x8c, 0x46, 0xc7, 0xa3, 0x0f, 0x4f, 0xad, 0x67, 0x38, + 0xf5, 0x35, 0x84, 0xba, 0x33, 0xa4, 0xa3, 0x14, 0x0f, 0xff, 0x00, 0x5f, + 0xb5, 0x15, 0x99, 0xa8, 0x0c, 0xa9, 0xc8, 0x3c, 0xd5, 0xa8, 0xae, 0x94, + 0x8c, 0x3f, 0x07, 0xd6, 0xaa, 0xd1, 0x8a, 0x69, 0xb4, 0x4c, 0xa2, 0x99, + 0xa0, 0x1d, 0x4f, 0x71, 0x4d, 0x79, 0x91, 0x06, 0x73, 0x93, 0x54, 0x68, + 0xc5, 0x57, 0x3b, 0x27, 0xd9, 0x8f, 0x9a, 0x66, 0x95, 0xb1, 0xd0, 0x76, + 0xa6, 0x0a, 0x28, 0xc5, 0x43, 0xd4, 0xb4, 0xac, 0x14, 0x51, 0x45, 0x03, + 0x0c, 0xd1, 0x46, 0x29, 0x33, 0x40, 0x1c, 0xee, 0xab, 0xbf, 0xed, 0xf2, + 0x19, 0x3b, 0x9e, 0x29, 0xfa, 0x28, 0x7f, 0xb7, 0x8d, 0x99, 0xdb, 0x86, + 0xdd, 0xfe, 0x7e, 0xb5, 0xb7, 0x3d, 0xb4, 0x53, 0x8c, 0x4a, 0x81, 0x8d, + 0x10, 0xc1, 0x15, 0xba, 0xe2, 0x34, 0x0a, 0x3d, 0xa8, 0x2f, 0x9b, 0x4b, + 0x12, 0xd1, 0x49, 0x4b, 0x41, 0x21, 0x45, 0x14, 0x50, 0x20, 0xa1, 0x49, + 0x46, 0xdc, 0x0f, 0x34, 0x51, 0x8a, 0x00, 0xb7, 0x15, 0xca, 0x30, 0xf9, + 0xb8, 0x35, 0x36, 0xf4, 0x3d, 0xc5, 0x67, 0x51, 0xcd, 0x5f, 0x3b, 0x33, + 0x74, 0xd1, 0x79, 0xe7, 0x44, 0x19, 0xce, 0x4f, 0xb5, 0x54, 0x96, 0x63, + 0x29, 0xe7, 0x81, 0xe9, 0x4c, 0xc5, 0x14, 0x9c, 0x9b, 0x1c, 0x60, 0x90, + 0x62, 0x8a, 0x28, 0xc7, 0x07, 0xda, 0xa4, 0xb0, 0xae, 0x13, 0xc5, 0x77, + 0xc2, 0xf3, 0x54, 0x28, 0x8d, 0xba, 0x38, 0x3e, 0x41, 0xf5, 0xef, 0x5d, + 0x27, 0x88, 0xb5, 0x65, 0xd3, 0x6d, 0x0a, 0x46, 0x41, 0xb8, 0x94, 0x6d, + 0x50, 0x3b, 0x7b, 0xd7, 0x06, 0x49, 0x27, 0x24, 0xe5, 0x8f, 0x53, 0xeb, + 0x5a, 0x41, 0x75, 0x32, 0x9c, 0xba, 0x09, 0x45, 0x14, 0x64, 0x63, 0x39, + 0xe2, 0xb4, 0x32, 0x14, 0x02, 0xc4, 0x2a, 0x82, 0x49, 0xe9, 0x5e, 0x97, + 0xe1, 0x6d, 0x24, 0x69, 0x7a, 0x5a, 0x87, 0x50, 0x27, 0x9b, 0xe7, 0x93, + 0x8e, 0x87, 0xb0, 0xae, 0x7b, 0xc1, 0x9a, 0x07, 0xda, 0x25, 0x5d, 0x42, + 0xe5, 0x7f, 0x74, 0x87, 0x31, 0x03, 0xfc, 0x47, 0xd7, 0xe9, 0x5d, 0xd8, + 0x14, 0x00, 0xb4, 0x62, 0x96, 0x8a, 0x00, 0x4c, 0x51, 0x8c, 0xd2, 0xd1, + 0x40, 0x11, 0xbc, 0x68, 0xff, 0x00, 0x79, 0x14, 0xfd, 0x57, 0x35, 0x04, + 0x9a, 0x75, 0x9c, 0xbf, 0xeb, 0x2d, 0x60, 0x6f, 0xac, 0x62, 0xad, 0x51, + 0x40, 0x19, 0x6f, 0xe1, 0xdd, 0x2e, 0x43, 0x93, 0x65, 0x10, 0xff, 0x00, + 0x74, 0x62, 0xa1, 0x6f, 0x0c, 0x59, 0x81, 0x98, 0x65, 0xb9, 0xb7, 0x3e, + 0xb1, 0xcc, 0x7f, 0xad, 0x6d, 0x51, 0x40, 0x18, 0x47, 0x43, 0xd4, 0x62, + 0xc1, 0xb6, 0xd6, 0x67, 0x00, 0x76, 0x95, 0x43, 0x51, 0xe5, 0xf8, 0x86, + 0xdf, 0xa4, 0xb6, 0x97, 0x20, 0x7f, 0x78, 0x6d, 0x26, 0xb7, 0x68, 0xc5, + 0x00, 0x62, 0x9d, 0x5b, 0x52, 0x87, 0x1f, 0x68, 0xd2, 0x24, 0xc7, 0xac, + 0x2e, 0x1a, 0x95, 0x7c, 0x51, 0x62, 0x1b, 0x6c, 0xeb, 0x3d, 0xbb, 0x7a, + 0x4b, 0x19, 0x15, 0xb3, 0x8a, 0x63, 0xc4, 0x92, 0x0c, 0x3a, 0x2b, 0x0f, + 0x42, 0x33, 0x40, 0x15, 0xed, 0xb5, 0x3b, 0x3b, 0xac, 0x79, 0x17, 0x51, + 0x39, 0x3d, 0x83, 0x0c, 0xfe, 0x55, 0x6c, 0x1c, 0x8c, 0xd6, 0x6d, 0xce, + 0x81, 0xa6, 0x5d, 0x64, 0xbd, 0xa4, 0x61, 0xbf, 0xbc, 0x83, 0x69, 0xfc, + 0xc5, 0x55, 0xff, 0x00, 0x84, 0x7a, 0x58, 0x0e, 0x6c, 0x75, 0x3b, 0xa8, + 0x4f, 0xf7, 0x5c, 0xef, 0x1f, 0xad, 0x00, 0x6e, 0x66, 0x8a, 0xc5, 0x8c, + 0xeb, 0xb6, 0xf2, 0x22, 0xc8, 0xb6, 0xd7, 0x69, 0xbb, 0x0c, 0xc0, 0xec, + 0x60, 0x3e, 0x9d, 0x2b, 0x64, 0x74, 0xa0, 0x07, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x52, 0x63, 0x1d, 0x29, 0x68, 0xa0, 0x04, 0xc5, + 0x14, 0xb4, 0x50, 0x02, 0x52, 0xd1, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x98, 0xa5, 0xa2, 0x80, 0x39, 0x2f, 0x13, + 0xf8, 0x57, 0xed, 0x5b, 0xae, 0xec, 0x15, 0x56, 0x7e, 0xaf, 0x1f, 0x40, + 0xdf, 0x4a, 0xe1, 0xa4, 0x46, 0x8a, 0x46, 0x49, 0x15, 0x91, 0xd7, 0xaa, + 0xb0, 0xe4, 0x57, 0xb2, 0xe2, 0xb1, 0x35, 0xdf, 0x0d, 0xda, 0xea, 0xe0, + 0xbe, 0x3c, 0xab, 0x81, 0xca, 0xc8, 0xbd, 0xfe, 0xbe, 0xb4, 0x01, 0xe6, + 0x9e, 0xd4, 0x02, 0x54, 0x86, 0x52, 0x54, 0x8e, 0x84, 0x76, 0xfa, 0x55, + 0xfd, 0x5b, 0x45, 0xbc, 0xd2, 0x65, 0x22, 0xe2, 0x3f, 0xdd, 0x9f, 0xbb, + 0x20, 0xe5, 0x4f, 0xf8, 0x56, 0x7e, 0x3f, 0x2f, 0x7a, 0x00, 0xeb, 0x74, + 0x2f, 0x13, 0xab, 0x85, 0xb7, 0xbf, 0x6d, 0xad, 0x8c, 0x2c, 0xbe, 0xbe, + 0xc6, 0xba, 0x75, 0x60, 0xea, 0x19, 0x48, 0x60, 0x7b, 0x83, 0x5e, 0x59, + 0xdb, 0x18, 0xc8, 0xad, 0x1d, 0x33, 0x5c, 0xbb, 0xd3, 0x4e, 0xd8, 0xdf, + 0xcc, 0x8f, 0xbc, 0x6d, 0xcf, 0xe5, 0x59, 0xb8, 0x2e, 0x86, 0x91, 0x9d, + 0xb7, 0x3d, 0x0a, 0x8a, 0xc4, 0xd3, 0xfc, 0x53, 0x65, 0x75, 0x85, 0x98, + 0x9b, 0x79, 0x0f, 0x66, 0xe4, 0x7e, 0x75, 0xb4, 0x8e, 0xb2, 0x20, 0x64, + 0x60, 0xca, 0x7b, 0xa9, 0xcd, 0x66, 0xd3, 0x46, 0xa9, 0xa6, 0x2d, 0x14, + 0x76, 0xa3, 0x34, 0x0c, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, + 0x33, 0x58, 0xed, 0x3c, 0xb6, 0x1a, 0xa3, 0x19, 0x4b, 0x18, 0xdc, 0xf0, + 0x7b, 0x56, 0xc6, 0x2a, 0x1b, 0x8b, 0x68, 0xee, 0x63, 0x29, 0x2a, 0xe4, + 0x76, 0x3e, 0x94, 0x0d, 0x12, 0x46, 0xeb, 0x22, 0x86, 0x46, 0x04, 0x1f, + 0x4a, 0x49, 0x24, 0x8e, 0x24, 0xdd, 0x23, 0x05, 0x51, 0xef, 0x59, 0x67, + 0x48, 0x9e, 0x33, 0xfe, 0x8f, 0x39, 0x03, 0xd3, 0x38, 0xa5, 0x5d, 0x22, + 0x59, 0x1f, 0x75, 0xc4, 0xfb, 0x87, 0xfb, 0x3c, 0xd0, 0x3b, 0x21, 0x2d, + 0x26, 0x9a, 0xfb, 0x52, 0x32, 0xab, 0x32, 0xc2, 0xbd, 0x79, 0xe3, 0xda, + 0xb5, 0xea, 0x38, 0x60, 0x8e, 0x08, 0xc2, 0x46, 0xa1, 0x40, 0xa9, 0x33, + 0x40, 0x98, 0x51, 0x45, 0x19, 0xa0, 0x41, 0x45, 0x14, 0x66, 0x80, 0x0a, + 0x28, 0xa3, 0x34, 0x00, 0x51, 0x9a, 0x4e, 0x95, 0x15, 0xc5, 0xd4, 0x16, + 0x91, 0xef, 0xb8, 0x95, 0x23, 0x5e, 0xdb, 0x8e, 0x33, 0x40, 0x12, 0xf6, + 0xfe, 0x55, 0x9f, 0xac, 0xeb, 0x30, 0x69, 0x71, 0x12, 0xc4, 0x3c, 0xe7, + 0xee, 0x46, 0x3f, 0x99, 0xac, 0x6d, 0x53, 0xc5, 0xc3, 0x0d, 0x1e, 0x9e, + 0x87, 0x3f, 0xf3, 0xd5, 0x87, 0x4f, 0xa0, 0xae, 0x62, 0x69, 0x64, 0x9e, + 0x43, 0x24, 0xae, 0xce, 0xec, 0x72, 0x49, 0xe6, 0xad, 0x43, 0xb9, 0x9c, + 0xa6, 0xba, 0x12, 0x5e, 0xde, 0x4d, 0x7d, 0x72, 0xf3, 0xce, 0xfb, 0x9d, + 0x8f, 0xe5, 0x50, 0x51, 0x4f, 0x8a, 0x29, 0x27, 0x90, 0x47, 0x12, 0x33, + 0xc8, 0xc7, 0x01, 0x54, 0x64, 0xd6, 0xa6, 0x23, 0x2b, 0xa1, 0xf0, 0xcf, + 0x86, 0x64, 0xd4, 0xa4, 0x5b, 0x8b, 0xa5, 0x29, 0x6a, 0xa7, 0x20, 0x63, + 0x05, 0xcf, 0xa5, 0x69, 0xf8, 0x7f, 0xc1, 0xa5, 0x59, 0x6e, 0x35, 0x30, + 0x09, 0x1c, 0x88, 0x07, 0x4f, 0xc6, 0xbb, 0x14, 0x45, 0x55, 0x0a, 0xa0, + 0x28, 0x03, 0x00, 0x0e, 0xd4, 0x00, 0x91, 0x46, 0x91, 0x22, 0xa4, 0x6a, + 0x15, 0x14, 0x60, 0x28, 0x1d, 0x29, 0xf4, 0x62, 0x96, 0x80, 0x0a, 0x28, + 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, + 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x4a, 0x5a, 0x28, 0x01, 0x28, + 0xa5, 0xa2, 0x80, 0x13, 0x1e, 0xf4, 0x52, 0xd1, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x09, 0x46, 0x6a, 0x1b, 0xb9, 0x8d, 0xbd, + 0xa4, 0xb2, 0x85, 0xde, 0x63, 0x42, 0xc1, 0x47, 0x7c, 0x57, 0x9b, 0xdd, + 0xf8, 0xaf, 0x54, 0xb9, 0x72, 0xcb, 0x39, 0x85, 0x4f, 0xf0, 0x27, 0x6f, + 0xad, 0x00, 0x7a, 0x75, 0x15, 0xe5, 0x71, 0xf8, 0x8f, 0x56, 0x8c, 0xe7, + 0xed, 0xb2, 0xe3, 0xdf, 0x9a, 0xd9, 0xd3, 0x7c, 0x63, 0xa8, 0xaf, 0xfa, + 0xfb, 0x6f, 0xb4, 0xc6, 0xbf, 0x79, 0x91, 0x48, 0x61, 0x40, 0x1d, 0xe5, + 0x15, 0x95, 0xa5, 0x6b, 0xd6, 0x5a, 0xaa, 0xfe, 0xe2, 0x4c, 0x49, 0x8e, + 0x63, 0x6e, 0x0d, 0x69, 0xe6, 0x80, 0x1d, 0x49, 0x4b, 0x45, 0x00, 0x43, + 0x34, 0x11, 0xcd, 0x1b, 0x47, 0x22, 0x2b, 0xa3, 0x7d, 0xe5, 0x61, 0x90, + 0x7e, 0xb5, 0xcc, 0xea, 0xbe, 0x08, 0xb7, 0x9f, 0x32, 0x58, 0x3f, 0x91, + 0x27, 0xf7, 0x1b, 0x95, 0x3f, 0xe1, 0x5d, 0x5d, 0x18, 0xa0, 0x0f, 0x28, + 0xd4, 0x74, 0x3b, 0xfd, 0x34, 0x9f, 0xb4, 0xdb, 0xb8, 0x5e, 0xce, 0x9f, + 0x32, 0x9f, 0xc4, 0x74, 0xac, 0xfe, 0x9e, 0xbf, 0x88, 0xaf, 0x66, 0x65, + 0x0c, 0xa4, 0x10, 0x08, 0x3d, 0x8f, 0x4a, 0xc8, 0xbe, 0xf0, 0xc6, 0x97, + 0x7d, 0x92, 0xf6, 0xe1, 0x1f, 0xfb, 0xf1, 0xf0, 0x68, 0x03, 0xcc, 0x6a, + 0x6b, 0x5b, 0xcb, 0x8b, 0x47, 0xdd, 0x6f, 0x3c, 0x91, 0x1f, 0xf6, 0x5b, + 0x83, 0xf8, 0x57, 0x4f, 0x7b, 0xe0, 0x39, 0x54, 0x93, 0x65, 0x72, 0xae, + 0x0f, 0xf0, 0xca, 0x30, 0x47, 0xe3, 0x58, 0xd7, 0x7e, 0x1a, 0xd5, 0x6d, + 0x32, 0x5a, 0xd5, 0x9d, 0x47, 0x74, 0xe6, 0x80, 0x2c, 0x5b, 0xf8, 0xb6, + 0xfe, 0x2c, 0x09, 0x44, 0x73, 0x28, 0xfe, 0xf2, 0xed, 0xad, 0x2b, 0x7f, + 0x19, 0x40, 0x40, 0xfb, 0x45, 0xb4, 0x88, 0x7d, 0x54, 0xe4, 0x57, 0x29, + 0x24, 0x52, 0xc4, 0xdb, 0x64, 0x8e, 0x44, 0x3e, 0x8c, 0xa6, 0xa3, 0xe3, + 0xb7, 0x5a, 0x9e, 0x54, 0x52, 0x9b, 0x47, 0x7d, 0x17, 0x89, 0x74, 0xb9, + 0x7f, 0xe5, 0xb9, 0x43, 0xe8, 0xc8, 0xd5, 0x6a, 0x3d, 0x56, 0xc2, 0x4f, + 0xb9, 0x79, 0x01, 0xfa, 0xc8, 0x05, 0x79, 0xbf, 0xb5, 0x02, 0x97, 0x22, + 0x2b, 0xda, 0x33, 0xd4, 0x56, 0x68, 0xdb, 0xee, 0xc8, 0x87, 0xe8, 0x69, + 0xe0, 0x83, 0xd0, 0x8f, 0xce, 0xbc, 0xb0, 0x1d, 0xbd, 0x09, 0x1f, 0x43, + 0x4f, 0x17, 0x13, 0xaf, 0x49, 0xa4, 0x1f, 0xf0, 0x23, 0x4b, 0x90, 0x7e, + 0xd0, 0xf5, 0x0a, 0x2b, 0xcc, 0xc5, 0xf5, 0xd2, 0xf4, 0xb9, 0x9b, 0xfe, + 0xfb, 0x34, 0xe1, 0xa9, 0x5e, 0x0e, 0x97, 0x32, 0xff, 0x00, 0xdf, 0x46, + 0x97, 0x20, 0x7b, 0x43, 0xd2, 0xa8, 0xaf, 0x35, 0xfe, 0xd3, 0xbe, 0xff, + 0x00, 0x9f, 0xa9, 0x7f, 0xef, 0xaa, 0x5f, 0xed, 0x4b, 0xef, 0xf9, 0xfb, + 0x9b, 0xfe, 0xfa, 0xa3, 0x90, 0x3d, 0xa1, 0xe9, 0x34, 0x95, 0xe6, 0xdf, + 0xda, 0x77, 0xc7, 0xad, 0xd4, 0xbf, 0xf7, 0xd5, 0x21, 0xd4, 0x2f, 0x0f, + 0xfc, 0xbd, 0x4b, 0xff, 0x00, 0x7d, 0x1a, 0x39, 0x03, 0xda, 0x1e, 0x97, + 0xf8, 0xd2, 0x12, 0x07, 0x52, 0x3f, 0x3a, 0xf3, 0x33, 0x7b, 0x72, 0xdf, + 0x7a, 0xe2, 0x6f, 0xfb, 0xec, 0xd3, 0x1a, 0xe2, 0x76, 0xeb, 0x3c, 0x87, + 0xea, 0xc6, 0x8f, 0x66, 0x1e, 0xd0, 0xf4, 0xd6, 0x92, 0x35, 0x1c, 0xba, + 0x81, 0xea, 0x5b, 0x15, 0x5e, 0x4d, 0x4e, 0xca, 0x31, 0xf3, 0xdd, 0xc2, + 0x3d, 0xb7, 0x82, 0x6b, 0xcd, 0xc9, 0x2c, 0x72, 0xc4, 0x9f, 0xa9, 0xa2, + 0x9f, 0x20, 0x7b, 0x43, 0xbe, 0x9b, 0xc4, 0xba, 0x64, 0x5d, 0x2e, 0x37, + 0x1f, 0x44, 0x53, 0x59, 0xf7, 0x1e, 0x32, 0x81, 0x78, 0xb7, 0xb7, 0x91, + 0xcf, 0xab, 0x9d, 0xa2, 0xb9, 0x1f, 0xc7, 0x8a, 0x06, 0x73, 0xf2, 0xfe, + 0x60, 0x53, 0xe4, 0x44, 0xb9, 0xb3, 0x66, 0xeb, 0xc5, 0x7a, 0x84, 0xe0, + 0x88, 0xd9, 0x20, 0x1d, 0xb6, 0x0e, 0x7f, 0x5c, 0xd6, 0x4c, 0xd3, 0x4b, + 0x3b, 0x97, 0x9a, 0x46, 0x77, 0x3d, 0x59, 0x8e, 0x4d, 0x4d, 0x6d, 0xa6, + 0x5f, 0x5d, 0x36, 0x21, 0xb5, 0x95, 0xfd, 0xf6, 0x56, 0xbd, 0xaf, 0x82, + 0xb5, 0x39, 0xf0, 0x65, 0xf2, 0xe0, 0x1d, 0xf7, 0x1c, 0xd5, 0x59, 0x22, + 0x6e, 0xd9, 0xcf, 0x7e, 0xb4, 0xf8, 0x62, 0x92, 0x77, 0x54, 0x85, 0x1a, + 0x47, 0x27, 0x01, 0x51, 0x72, 0x4d, 0x77, 0x76, 0x3e, 0x06, 0xb1, 0x87, + 0x0d, 0x75, 0x23, 0xdc, 0x37, 0xf7, 0x73, 0xb5, 0x7f, 0x4a, 0xdf, 0xb4, + 0xb0, 0xb6, 0xb2, 0x4d, 0xb6, 0xf0, 0x24, 0x43, 0xfd, 0x91, 0xcd, 0x31, + 0x1c, 0x3e, 0x95, 0xe0, 0xab, 0xcb, 0xa2, 0xb2, 0x5e, 0x1f, 0xb3, 0x47, + 0xdd, 0x7a, 0xb1, 0xff, 0x00, 0x0a, 0xec, 0x74, 0xbd, 0x16, 0xcb, 0x4a, + 0x4c, 0x5b, 0x44, 0x03, 0x63, 0x97, 0x3c, 0xb1, 0xfc, 0x6b, 0x44, 0x0a, + 0x31, 0x40, 0x08, 0x07, 0xe9, 0x4e, 0xa4, 0xa5, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, + 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x06, 0x90, 0x0a, 0x90, 0x79, 0x15, 0xc8, + 0xeb, 0xde, 0x0f, 0x4b, 0x89, 0x9a, 0xe3, 0x4f, 0x61, 0x1c, 0x8f, 0xc9, + 0x88, 0xf0, 0x1b, 0xe9, 0xe9, 0x5d, 0x79, 0xaa, 0x13, 0x4d, 0x8b, 0xd5, + 0x1f, 0xc2, 0xbd, 0x69, 0xa5, 0x72, 0x64, 0xec, 0x8f, 0x2e, 0xbc, 0xb2, + 0xb9, 0xb1, 0x98, 0xc3, 0x75, 0x0b, 0x42, 0xc3, 0x8e, 0x47, 0x5f, 0xa1, + 0xe9, 0x56, 0xf4, 0xad, 0x6a, 0x7d, 0x2d, 0x5d, 0x63, 0x8d, 0x24, 0x49, + 0x39, 0x2a, 0xf5, 0xe9, 0x77, 0x96, 0x56, 0xf7, 0xf0, 0x18, 0xae, 0x22, + 0x57, 0x42, 0x3a, 0x11, 0xc8, 0xae, 0x07, 0xc4, 0x7e, 0x19, 0x97, 0x4a, + 0x3e, 0x7d, 0xbe, 0x65, 0xb6, 0x39, 0xfa, 0xa7, 0xb1, 0xff, 0x00, 0x1a, + 0x13, 0xb0, 0xda, 0xb9, 0x47, 0x4e, 0xb2, 0xba, 0xd4, 0xef, 0x26, 0x96, + 0xd0, 0xac, 0x72, 0x26, 0x18, 0x90, 0xd8, 0xc6, 0x6b, 0xab, 0xd0, 0x7c, + 0x47, 0x27, 0xda, 0x7f, 0xb3, 0xb5, 0x5f, 0xdd, 0xdc, 0x8f, 0x95, 0x1c, + 0xff, 0x00, 0x17, 0xa0, 0x3e, 0xfe, 0xf5, 0xc6, 0x58, 0xdf, 0xcf, 0xa7, + 0xcf, 0xe6, 0xdb, 0xb6, 0x1b, 0x18, 0x20, 0xf2, 0x0f, 0xe1, 0x4f, 0x96, + 0x5b, 0xad, 0x5e, 0xf9, 0xa4, 0x08, 0x5e, 0x66, 0x00, 0x81, 0x18, 0xe8, + 0x05, 0x1a, 0x58, 0x5a, 0xa6, 0x7a, 0xde, 0x68, 0xae, 0x67, 0xc2, 0x9a, + 0xcc, 0x97, 0x51, 0x9b, 0x1b, 0xc0, 0xcb, 0x73, 0x0a, 0x8c, 0x6e, 0xea, + 0xcb, 0xfe, 0x35, 0xd3, 0x52, 0x28, 0x5a, 0x28, 0xa2, 0x80, 0x0a, 0x4c, + 0x52, 0xd1, 0x40, 0x09, 0x46, 0x29, 0x68, 0xa0, 0x08, 0x25, 0xb6, 0x86, + 0x61, 0x89, 0x61, 0x47, 0x1e, 0x8c, 0xa0, 0xd5, 0x0b, 0x8f, 0x0e, 0x69, + 0x77, 0x1c, 0x3d, 0x94, 0x63, 0x3f, 0xdd, 0xf9, 0x7f, 0x95, 0x6a, 0xd2, + 0x1a, 0x00, 0xe6, 0x67, 0xf0, 0x46, 0x96, 0xc0, 0xb2, 0x99, 0xa1, 0x1f, + 0xec, 0xbf, 0x03, 0xf3, 0x15, 0xc5, 0x6b, 0x42, 0xc2, 0xca, 0xe7, 0xc8, + 0xb0, 0x9e, 0x4b, 0x80, 0xa7, 0xe6, 0x72, 0x00, 0x03, 0xd8, 0x57, 0x43, + 0xe3, 0x4f, 0x10, 0xc9, 0x2c, 0xad, 0xa7, 0x5a, 0x49, 0xb6, 0x35, 0x38, + 0x99, 0xd4, 0xf2, 0x7d, 0xab, 0x8e, 0x5b, 0x74, 0x03, 0x04, 0x93, 0x40, + 0x0c, 0xfb, 0x4f, 0xaa, 0xfe, 0xb4, 0xbf, 0x69, 0x1f, 0xdd, 0x35, 0x28, + 0x86, 0x31, 0xfc, 0x22, 0x9c, 0x11, 0x47, 0xf0, 0x8f, 0xca, 0x80, 0x21, + 0xfb, 0x50, 0xfe, 0xe9, 0xa3, 0xed, 0x23, 0xfb, 0xa6, 0xa6, 0xda, 0xa3, + 0xb0, 0xa5, 0xc0, 0xf4, 0x14, 0x01, 0x0f, 0xda, 0x47, 0xf7, 0x1a, 0x93, + 0xed, 0x23, 0xfb, 0x8d, 0x53, 0xe3, 0xd8, 0x51, 0x81, 0xe9, 0x40, 0x10, + 0xfd, 0xa1, 0x7f, 0xba, 0x69, 0x3e, 0xd2, 0x3f, 0xba, 0x6a, 0x7c, 0x0f, + 0x4a, 0x69, 0x55, 0x3d, 0x54, 0x7e, 0x54, 0x01, 0x0f, 0xda, 0x47, 0xf7, + 0x7f, 0x5a, 0x3e, 0xd4, 0x3f, 0xbb, 0x52, 0x98, 0xd0, 0xf5, 0x51, 0x51, + 0xb5, 0xaa, 0x9f, 0xba, 0x48, 0xa0, 0x09, 0xec, 0xa5, 0xb6, 0x92, 0xe5, + 0x16, 0xee, 0x47, 0x8a, 0x12, 0x70, 0x5d, 0x46, 0x48, 0xae, 0xde, 0xcb, + 0xc1, 0x7a, 0x6c, 0xf0, 0xc7, 0x32, 0xdd, 0xcd, 0x3a, 0xb8, 0x0c, 0x19, + 0x08, 0x00, 0x8a, 0xf3, 0xc7, 0x85, 0xd3, 0xb6, 0x47, 0xb5, 0x6f, 0xf8, + 0x5b, 0xc4, 0x72, 0x68, 0xb7, 0x22, 0x29, 0x99, 0x9a, 0xce, 0x43, 0xf3, + 0xae, 0x7e, 0xe1, 0xfe, 0xf0, 0xfe, 0xa2, 0x80, 0x3b, 0x78, 0x3c, 0x23, + 0xa4, 0x43, 0xcf, 0xd9, 0x77, 0x9f, 0x57, 0x62, 0x6b, 0x46, 0x1d, 0x2e, + 0xca, 0xdf, 0xfd, 0x4d, 0xac, 0x4b, 0xf4, 0x5a, 0xb1, 0x14, 0x89, 0x2c, + 0x6b, 0x24, 0x6c, 0x19, 0x18, 0x64, 0x11, 0xd0, 0x8a, 0x7d, 0x00, 0x22, + 0xa8, 0x51, 0x80, 0x00, 0xfa, 0x0a, 0x5a, 0x29, 0x68, 0x01, 0x31, 0x45, + 0x2d, 0x14, 0x00, 0x94, 0xb4, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, + 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x08, 0x7a, 0x56, 0x3c, 0x8c, + 0x4c, 0x8c, 0x4f, 0x5c, 0xd6, 0xc1, 0xa8, 0x5a, 0xd6, 0x26, 0x7d, 0xc5, + 0x79, 0xaa, 0x8c, 0x92, 0x33, 0x9c, 0x5c, 0xb6, 0x1d, 0x09, 0x2d, 0x0a, + 0x93, 0xd7, 0x14, 0xb2, 0x46, 0xb2, 0xc6, 0xc8, 0xea, 0x19, 0x58, 0x60, + 0x83, 0xde, 0x9c, 0x00, 0x50, 0x00, 0xe9, 0x4b, 0x52, 0x5a, 0x3c, 0xcf, + 0xc5, 0x3a, 0x1b, 0x69, 0x17, 0xbe, 0x64, 0x40, 0x9b, 0x69, 0x8f, 0xc8, + 0x7f, 0xbb, 0xea, 0x2a, 0xa6, 0x89, 0xa8, 0x0d, 0x36, 0xfd, 0x67, 0x65, + 0x2d, 0x19, 0x05, 0x5b, 0x1d, 0x79, 0xef, 0x5e, 0x93, 0xab, 0xe9, 0xf1, + 0xea, 0x76, 0x12, 0x5b, 0x4a, 0x06, 0x18, 0x7c, 0xa7, 0xd1, 0xbb, 0x57, + 0x95, 0xdd, 0x5b, 0xc9, 0x69, 0x73, 0x24, 0x13, 0xa9, 0x59, 0x11, 0x8a, + 0x91, 0xee, 0x3a, 0x7e, 0x14, 0x2d, 0x01, 0xab, 0xa3, 0x5f, 0x58, 0xd6, + 0x62, 0x7d, 0x5a, 0xde, 0xee, 0xc0, 0x9f, 0x32, 0x21, 0xf3, 0x31, 0x04, + 0x64, 0xfd, 0x2b, 0xbb, 0xd1, 0xb5, 0x38, 0xb5, 0x6b, 0x04, 0xb8, 0x8c, + 0xe1, 0x8f, 0x0e, 0x99, 0xe5, 0x5b, 0xb8, 0xaf, 0x2f, 0xd3, 0xe3, 0x86, + 0x5b, 0xe8, 0x63, 0x9c, 0xe2, 0x26, 0x60, 0x1a, 0xba, 0xab, 0x9b, 0x7f, + 0xf8, 0x47, 0x08, 0xbf, 0xb0, 0x2c, 0x23, 0x04, 0x2c, 0xd0, 0xb3, 0x7c, + 0xae, 0x3e, 0xa6, 0xaa, 0xcd, 0xea, 0x4d, 0xd4, 0x74, 0x3b, 0x6a, 0x5a, + 0xce, 0xd2, 0x75, 0x6b, 0x6d, 0x56, 0xdc, 0x4b, 0x6d, 0x26, 0x71, 0xf7, + 0x90, 0xfd, 0xe5, 0x3e, 0xe2, 0xb4, 0x07, 0x4a, 0x92, 0xc5, 0xa2, 0x92, + 0x96, 0x80, 0x0a, 0x28, 0xa4, 0xa0, 0x05, 0xac, 0x5f, 0x14, 0xea, 0xbf, + 0xd9, 0x5a, 0x53, 0x32, 0x36, 0x26, 0x94, 0xec, 0x8c, 0x7b, 0x9e, 0xff, + 0x00, 0x85, 0x6c, 0x1f, 0x4a, 0xf3, 0xcf, 0x1d, 0xde, 0x9b, 0x8d, 0x64, + 0x40, 0xa7, 0xe4, 0xb7, 0x4c, 0x1f, 0xa9, 0xeb, 0x40, 0x1c, 0xf3, 0x12, + 0x49, 0x24, 0xe4, 0x93, 0x92, 0x69, 0x28, 0xa4, 0xa0, 0x02, 0x96, 0x92, + 0x8a, 0x00, 0x5a, 0x29, 0x28, 0xa0, 0x05, 0xa2, 0x8f, 0x6f, 0xca, 0x8f, + 0x5e, 0x3a, 0x50, 0x01, 0x49, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0xb5, 0x14, 0xb0, 0xee, 0x19, 0x5f, 0xbc, 0x3f, 0x5a, 0x92, 0x8a, 0x00, + 0xec, 0x7e, 0x1f, 0x6b, 0x26, 0x58, 0x5f, 0x4d, 0x98, 0xfc, 0xf1, 0x8d, + 0xd1, 0x7b, 0x8e, 0xe2, 0xbb, 0x61, 0xd0, 0x57, 0x90, 0x69, 0x57, 0x6d, + 0xa6, 0xeb, 0x16, 0xf7, 0x6b, 0xc0, 0x57, 0x01, 0xc7, 0xb1, 0xeb, 0x5e, + 0xba, 0xac, 0x19, 0x43, 0x29, 0xc8, 0x23, 0x22, 0x80, 0x1f, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x02, 0x51, 0x4b, + 0x45, 0x00, 0x25, 0x2d, 0x14, 0x50, 0x02, 0x57, 0x1d, 0xe3, 0x9d, 0x1b, + 0xcc, 0x4f, 0xed, 0x28, 0x57, 0xe6, 0x41, 0xb6, 0x50, 0x07, 0x51, 0xeb, + 0x5d, 0x95, 0x42, 0xf1, 0xac, 0xa8, 0xc8, 0xea, 0x19, 0x58, 0x10, 0x41, + 0x19, 0x04, 0x1e, 0xa2, 0x80, 0x3c, 0x77, 0xa1, 0xab, 0x12, 0x5e, 0xdc, + 0x4b, 0x6e, 0xb0, 0x49, 0x3b, 0xb4, 0x4b, 0xd1, 0x49, 0xad, 0x4f, 0x13, + 0xe8, 0x0f, 0xa4, 0x5d, 0x19, 0x62, 0x52, 0x6d, 0x64, 0x3f, 0x2b, 0x0f, + 0xe1, 0x3e, 0x86, 0xb0, 0xe8, 0x15, 0x8d, 0xdd, 0x17, 0x47, 0xd4, 0x5a, + 0x15, 0xbf, 0xb3, 0xb8, 0x58, 0x5c, 0xe7, 0x6f, 0x24, 0x6e, 0xf6, 0x35, + 0xb1, 0x69, 0xe3, 0x49, 0x6d, 0x65, 0x36, 0xfa, 0xad, 0xb9, 0x59, 0x10, + 0xe0, 0xba, 0x7f, 0x85, 0x73, 0x7a, 0x6e, 0xb7, 0x77, 0xa7, 0x21, 0x8e, + 0x16, 0x47, 0x8b, 0x39, 0xd9, 0x20, 0xc8, 0xcf, 0xaf, 0x5a, 0xab, 0x79, + 0x75, 0x2d, 0xed, 0xd3, 0xcf, 0x31, 0x05, 0xdb, 0xd3, 0xb7, 0xd2, 0xa9, + 0xda, 0xc2, 0x57, 0xbe, 0xa7, 0xa5, 0xdb, 0x78, 0x8f, 0x4b, 0xb9, 0x1f, + 0x25, 0xe4, 0x60, 0xfa, 0x31, 0xc5, 0x5d, 0x17, 0xd6, 0xcc, 0x32, 0x2e, + 0x23, 0x23, 0xfd, 0xe1, 0x5c, 0x6e, 0x99, 0x6f, 0xa2, 0x4d, 0xa7, 0x26, + 0xf3, 0x08, 0x7d, 0xa3, 0xcc, 0x2e, 0xdb, 0x58, 0x1e, 0xe7, 0x26, 0xb9, + 0x8b, 0xb5, 0x89, 0x2e, 0xa5, 0x5b, 0x76, 0x2d, 0x08, 0x63, 0xb0, 0xfa, + 0x8a, 0x1a, 0xb2, 0x05, 0x2b, 0xb3, 0xd5, 0x65, 0xd5, 0xac, 0x21, 0x1f, + 0xbc, 0xbc, 0x85, 0x7e, 0xae, 0x2b, 0x32, 0xef, 0xc6, 0x3a, 0x5d, 0xb0, + 0x3b, 0x65, 0x69, 0x4f, 0x40, 0x23, 0x15, 0xcf, 0xe8, 0x96, 0x3a, 0x44, + 0xba, 0x6a, 0x3c, 0xcd, 0x1b, 0xcc, 0x47, 0xef, 0x3c, 0xc6, 0xc1, 0x53, + 0xfd, 0x2b, 0x07, 0x53, 0x8e, 0xde, 0x3b, 0xf9, 0x92, 0xd1, 0xf7, 0x40, + 0x0f, 0xca, 0x41, 0xcf, 0xe5, 0xed, 0xcd, 0x26, 0x81, 0x4a, 0xee, 0xc7, + 0x4d, 0x7f, 0xe2, 0x8d, 0x56, 0xea, 0xca, 0x49, 0xec, 0xad, 0x44, 0x16, + 0xe0, 0x1f, 0xde, 0x39, 0xf9, 0xab, 0x92, 0x96, 0x69, 0x2e, 0x64, 0x69, + 0xa6, 0x73, 0x24, 0x8f, 0xcb, 0x33, 0x75, 0x26, 0xaf, 0xcd, 0xae, 0xca, + 0x74, 0x36, 0xd3, 0xde, 0x24, 0x2b, 0x80, 0xa1, 0xc1, 0xc1, 0xc6, 0x7d, + 0x2b, 0x34, 0x70, 0x00, 0xa1, 0xd8, 0x6a, 0xfd, 0x42, 0x8a, 0x28, 0xfc, + 0x69, 0x0c, 0x50, 0x09, 0x38, 0x03, 0x27, 0x38, 0x03, 0xde, 0x9d, 0x24, + 0x4f, 0x0c, 0x85, 0x25, 0x46, 0x47, 0x5e, 0x08, 0x61, 0x82, 0x2b, 0xa2, + 0xf0, 0x3e, 0x98, 0xb7, 0x9a, 0x83, 0xdc, 0xc8, 0x01, 0x48, 0x30, 0x54, + 0x1f, 0xef, 0x1f, 0xfe, 0xb0, 0x35, 0x9f, 0xe2, 0xaf, 0xf9, 0x18, 0xaf, + 0x07, 0xfb, 0x74, 0x01, 0x95, 0x45, 0x14, 0x50, 0x06, 0xf7, 0x83, 0x2d, + 0xa2, 0xb9, 0xd7, 0x00, 0x99, 0x12, 0x45, 0x58, 0xc9, 0xc3, 0x0c, 0x8c, + 0xd6, 0x87, 0x8f, 0xac, 0xe0, 0x83, 0xec, 0xd3, 0x45, 0x12, 0xc6, 0xce, + 0x4a, 0xb6, 0xd1, 0x8c, 0xd5, 0x3f, 0x01, 0x7f, 0xc8, 0x78, 0xff, 0x00, + 0xd7, 0x26, 0xad, 0x3f, 0x88, 0x9f, 0xea, 0xac, 0xff, 0x00, 0xde, 0x6f, + 0xe4, 0x28, 0x03, 0x8a, 0xa2, 0x96, 0x92, 0x80, 0x0a, 0x71, 0x52, 0xa7, + 0x0c, 0x08, 0x3e, 0x84, 0x74, 0xa1, 0x3f, 0xd6, 0x2f, 0xfb, 0xc2, 0xba, + 0xff, 0x00, 0x1c, 0xe9, 0x0a, 0x89, 0x1e, 0xa5, 0x0a, 0x81, 0xd1, 0x25, + 0x03, 0xf4, 0x3f, 0xd3, 0xf2, 0xa0, 0x0e, 0x3e, 0x92, 0x8f, 0xc3, 0x1e, + 0xd4, 0x50, 0x00, 0x40, 0x65, 0x22, 0xbd, 0x67, 0x45, 0x97, 0xce, 0xd2, + 0x2d, 0x24, 0x3d, 0xe2, 0x51, 0xf9, 0x71, 0x5e, 0x4e, 0x7a, 0x7e, 0x15, + 0xe9, 0xfe, 0x14, 0x6d, 0xde, 0x1d, 0xb4, 0xf6, 0x52, 0x3f, 0x53, 0x40, + 0x1b, 0x14, 0x52, 0x52, 0xd0, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, + 0x50, 0x04, 0x17, 0x16, 0xf1, 0x5c, 0xc0, 0xf1, 0x4c, 0x81, 0xe3, 0x71, + 0x86, 0x56, 0xe9, 0x5c, 0x06, 0xbf, 0xe1, 0x49, 0xf4, 0xf2, 0xd7, 0x16, + 0x80, 0xcd, 0x6d, 0xe8, 0x07, 0xcd, 0x1f, 0xe1, 0xdc, 0x7d, 0x2b, 0xd1, + 0xa9, 0xa4, 0x03, 0xc1, 0x1f, 0x5a, 0x00, 0xf1, 0xae, 0x9f, 0x85, 0x15, + 0xe9, 0x3a, 0xb7, 0x85, 0x6c, 0x35, 0x22, 0x64, 0x11, 0x98, 0x66, 0x3f, + 0xc6, 0x9f, 0xd4, 0x57, 0x2f, 0x7f, 0xe0, 0xad, 0x46, 0xdc, 0x93, 0x6f, + 0xb2, 0xe2, 0x3e, 0xa3, 0x07, 0x04, 0x7e, 0x06, 0x80, 0x39, 0xda, 0x2a, + 0xe4, 0xda, 0x55, 0xf4, 0x07, 0x12, 0xda, 0xcc, 0x3d, 0x72, 0x95, 0x55, + 0xa2, 0x90, 0x75, 0x89, 0xc7, 0xe0, 0x68, 0x01, 0x28, 0xa7, 0x08, 0xdf, + 0xb2, 0x39, 0xff, 0x00, 0x80, 0x9a, 0x92, 0x3b, 0x2b, 0x99, 0x7f, 0xd5, + 0xdb, 0xca, 0xc7, 0xd9, 0x4d, 0x00, 0x56, 0x9b, 0xee, 0x1f, 0xa8, 0xa7, + 0x76, 0x15, 0xa2, 0x3c, 0x37, 0xaa, 0xcd, 0x13, 0x32, 0xda, 0x48, 0xa0, + 0x72, 0x77, 0x71, 0xc5, 0x67, 0x90, 0x41, 0xda, 0x7a, 0x8e, 0xb4, 0x00, + 0x94, 0x51, 0x41, 0xa0, 0x0f, 0x47, 0xf0, 0x35, 0xb8, 0x87, 0x40, 0x56, + 0xc6, 0x0c, 0xb2, 0x33, 0x9f, 0xd0, 0x7f, 0x4a, 0xe3, 0x7c, 0x55, 0xff, + 0x00, 0x23, 0x15, 0xe7, 0xfb, 0xff, 0x00, 0xd2, 0xbb, 0xcf, 0x0b, 0x00, + 0x3c, 0x39, 0x67, 0x8f, 0xee, 0x1f, 0xe6, 0x6b, 0x83, 0xf1, 0x57, 0xfc, + 0x8c, 0x57, 0x9f, 0xef, 0xff, 0x00, 0x4a, 0x00, 0xca, 0xa2, 0x8a, 0x28, + 0x03, 0xa2, 0xf0, 0x17, 0xfc, 0x87, 0xcf, 0xfd, 0x72, 0x6a, 0xd3, 0xf8, + 0x8b, 0xfe, 0xaa, 0xcb, 0xfd, 0xe6, 0xfe, 0x42, 0xb3, 0x3c, 0x05, 0xff, + 0x00, 0x21, 0xe3, 0xff, 0x00, 0x5c, 0x9a, 0xb4, 0xbe, 0x22, 0xff, 0x00, + 0xab, 0xb3, 0xfa, 0xb7, 0xf2, 0x14, 0x01, 0xc5, 0xd1, 0x45, 0x14, 0x00, + 0xa9, 0xf7, 0xc7, 0xfb, 0xc2, 0xbd, 0x53, 0x5c, 0xb7, 0x17, 0x5a, 0x15, + 0xc4, 0x24, 0x67, 0x31, 0x64, 0x7e, 0x03, 0x3f, 0xd2, 0xbc, 0xad, 0x3f, + 0xd6, 0x2f, 0xfb, 0xc2, 0xbd, 0x7e, 0x60, 0x1a, 0xd1, 0xc1, 0xe8, 0x63, + 0x23, 0xf4, 0xa0, 0x0f, 0x20, 0x1c, 0x8a, 0x4a, 0x73, 0x8c, 0x48, 0xe3, + 0xd1, 0x88, 0xfd, 0x69, 0xb4, 0x00, 0x76, 0xaf, 0x4e, 0xf0, 0x8f, 0xfc, + 0x8b, 0x76, 0xbf, 0xee, 0x9f, 0xe6, 0x6b, 0xcc, 0x7b, 0x57, 0xa7, 0x78, + 0x47, 0xfe, 0x45, 0xbb, 0x5f, 0xf7, 0x4f, 0xf3, 0x34, 0x01, 0xb5, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x49, + 0x4b, 0x45, 0x00, 0x14, 0x98, 0xa5, 0xa2, 0x80, 0x1a, 0x46, 0x47, 0x22, + 0x9a, 0x62, 0x8c, 0xf5, 0x8d, 0x4f, 0xe0, 0x2a, 0x4a, 0x28, 0x02, 0x21, + 0x0c, 0x63, 0xa4, 0x6a, 0x3f, 0xe0, 0x22, 0x9e, 0x14, 0x0e, 0x80, 0x52, + 0xd2, 0xd0, 0x04, 0x17, 0x5f, 0xf1, 0xe9, 0x37, 0xfb, 0x87, 0xf9, 0x57, + 0x90, 0x37, 0xde, 0x3f, 0x53, 0x5e, 0xbf, 0x75, 0xff, 0x00, 0x1e, 0x93, + 0x7f, 0xb8, 0x7f, 0x95, 0x79, 0x03, 0xfd, 0xe3, 0xf5, 0x34, 0x00, 0xda, + 0x0d, 0x14, 0x1a, 0x00, 0xf5, 0x2f, 0x0b, 0xff, 0x00, 0xc8, 0xbb, 0x65, + 0xfe, 0xe7, 0xf5, 0x35, 0xc1, 0x78, 0xab, 0xfe, 0x46, 0x2b, 0xcf, 0xf7, + 0xff, 0x00, 0xa5, 0x77, 0xbe, 0x17, 0xff, 0x00, 0x91, 0x76, 0xcb, 0xfd, + 0xcf, 0xea, 0x6b, 0x82, 0xf1, 0x57, 0xfc, 0x8c, 0x57, 0x9f, 0xef, 0xff, + 0x00, 0x4a, 0x00, 0xca, 0xa2, 0x8a, 0x28, 0x03, 0xa2, 0xf0, 0x17, 0xfc, + 0x87, 0x8f, 0xfd, 0x72, 0x6a, 0xd2, 0xf8, 0x8b, 0xfe, 0xae, 0xcf, 0xea, + 0xdf, 0xc8, 0x56, 0x6f, 0x80, 0xbf, 0xe4, 0x3c, 0x7f, 0xeb, 0x93, 0x56, + 0x97, 0xc4, 0x5f, 0xf5, 0x76, 0x7f, 0x56, 0xfe, 0x42, 0x80, 0x38, 0xba, + 0x28, 0xa2, 0x80, 0x15, 0x3f, 0xd6, 0x2f, 0xfb, 0xc2, 0xbd, 0x86, 0x4f, + 0xf8, 0xf6, 0x6f, 0xf7, 0x0f, 0xf2, 0xaf, 0x1e, 0x4f, 0xf5, 0x8b, 0xfe, + 0xf0, 0xaf, 0x61, 0x93, 0xfe, 0x3d, 0x9b, 0xfd, 0xc3, 0xfc, 0xa8, 0x03, + 0xc8, 0x25, 0xff, 0x00, 0x5d, 0x27, 0xfb, 0xcd, 0xfc, 0xe9, 0x94, 0xf9, + 0xbf, 0xd7, 0x49, 0xfe, 0xf3, 0x7f, 0x3a, 0x65, 0x00, 0x1d, 0xab, 0xd3, + 0xbc, 0x23, 0xff, 0x00, 0x22, 0xdd, 0xaf, 0xfb, 0xa7, 0xf9, 0x9a, 0xf3, + 0x1e, 0xd5, 0xe9, 0xde, 0x11, 0xff, 0x00, 0x91, 0x6e, 0xd7, 0xfd, 0xd3, + 0xfc, 0xcd, 0x00, 0x6d, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, + 0x51, 0x49, 0x4b, 0x40, 0x05, 0x14, 0x94, 0x50, 0x04, 0x37, 0x5f, 0xf1, + 0xe9, 0x37, 0xfb, 0x87, 0xf9, 0x57, 0x90, 0x3f, 0xde, 0x3f, 0x53, 0x5e, + 0xbf, 0x77, 0xff, 0x00, 0x1e, 0xb3, 0x7f, 0xb8, 0xdf, 0xca, 0xbc, 0x81, + 0xfe, 0xf1, 0xfa, 0x9a, 0x00, 0x6d, 0x06, 0x8a, 0x28, 0x03, 0xd4, 0xbc, + 0x2f, 0xff, 0x00, 0x22, 0xf5, 0x9f, 0xfb, 0x9f, 0xd4, 0xd7, 0x05, 0xe2, + 0xaf, 0xf9, 0x18, 0xaf, 0x3f, 0xdf, 0xfe, 0x95, 0xdc, 0xf8, 0x6a, 0xe2, + 0x34, 0xf0, 0xfd, 0x98, 0x2d, 0xc8, 0x4f, 0xea, 0x6b, 0x85, 0xf1, 0x43, + 0x07, 0xf1, 0x0d, 0xd9, 0x1d, 0x0b, 0xd1, 0x61, 0x5d, 0x19, 0x74, 0x0e, + 0xb4, 0x51, 0x40, 0xce, 0x8f, 0xc0, 0x5f, 0xf2, 0x1e, 0x3f, 0xf5, 0xc9, + 0xab, 0x4b, 0xe2, 0x2f, 0xfa, 0xbb, 0x2f, 0xf7, 0x9b, 0xf9, 0x0a, 0xca, + 0xf0, 0x4c, 0xa2, 0x2d, 0x6c, 0xb1, 0x19, 0xfd, 0xd3, 0x55, 0xff, 0x00, + 0x1f, 0x4e, 0x27, 0x8e, 0xd3, 0x00, 0x8c, 0x33, 0x7f, 0x21, 0x4e, 0xce, + 0xd7, 0x17, 0x32, 0xbd, 0x8e, 0x42, 0x8a, 0x28, 0xa4, 0x31, 0x53, 0xfd, + 0x62, 0xff, 0x00, 0xbc, 0x2b, 0xd8, 0x64, 0xff, 0x00, 0x8f, 0x66, 0xff, + 0x00, 0x70, 0xff, 0x00, 0x2a, 0xf1, 0xf4, 0xfb, 0xe3, 0xea, 0x3f, 0x9d, + 0x7a, 0xcb, 0x5d, 0xc4, 0x6d, 0xd8, 0x64, 0x8f, 0x90, 0xff, 0x00, 0x2a, + 0x2d, 0x71, 0x36, 0x96, 0xe7, 0x93, 0xcd, 0xfe, 0xba, 0x4f, 0xf7, 0x9b, + 0xf9, 0xd3, 0x29, 0xf2, 0xf3, 0x34, 0x9f, 0xef, 0x1f, 0xe7, 0x4c, 0xa0, + 0x61, 0xda, 0xbd, 0x3f, 0xc2, 0x3f, 0xf2, 0x2e, 0x5a, 0xff, 0x00, 0xba, + 0x7f, 0x99, 0xaf, 0x30, 0xed, 0x5e, 0x9f, 0xe1, 0x1f, 0xf9, 0x17, 0x2d, + 0x7f, 0xdd, 0x3f, 0xcc, 0xd0, 0x06, 0xc5, 0x2d, 0x25, 0x14, 0x00, 0xb4, + 0x52, 0x52, 0xd0, 0x01, 0x45, 0x25, 0x2d, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, + 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x49, 0x40, + 0x05, 0x14, 0xc7, 0x95, 0x50, 0x7c, 0xcc, 0x05, 0x56, 0x92, 0xf9, 0x47, + 0x11, 0x8c, 0xfb, 0xd3, 0x49, 0xb2, 0x5c, 0x92, 0x2e, 0x1a, 0x6b, 0x48, + 0xa9, 0xf7, 0x98, 0x0a, 0xcd, 0x92, 0xea, 0x57, 0xfe, 0x2d, 0xbf, 0x4a, + 0x88, 0xe4, 0xf7, 0x27, 0xeb, 0x56, 0xa9, 0xb3, 0x37, 0x59, 0x74, 0x34, + 0x5e, 0xf6, 0x25, 0xe0, 0x1d, 0xc7, 0xda, 0xa1, 0x6b, 0xf3, 0xfc, 0x2b, + 0x8a, 0xa9, 0x45, 0x52, 0x82, 0x33, 0x75, 0x64, 0x3e, 0xea, 0xf2, 0x56, + 0xb5, 0x97, 0xa0, 0xf9, 0x0f, 0xf2, 0xaf, 0x30, 0x6f, 0xbc, 0x79, 0xee, + 0x6b, 0xd1, 0xee, 0x7f, 0xe3, 0xde, 0x5f, 0xf7, 0x4d, 0x79, 0xbb, 0x75, + 0x3f, 0x5a, 0x99, 0xa4, 0x8d, 0x29, 0x49, 0xbd, 0xc4, 0xa2, 0x8a, 0x2b, + 0x33, 0x63, 0xbf, 0xd0, 0x7f, 0xe4, 0x0b, 0x6b, 0x9f, 0xee, 0x7f, 0xec, + 0xc6, 0xb9, 0x0f, 0x10, 0x7f, 0xc8, 0x6e, 0xe7, 0xfd, 0xfa, 0xeb, 0xf4, + 0x2f, 0xf9, 0x02, 0xda, 0xff, 0x00, 0xb9, 0xfd, 0x4d, 0x72, 0x3e, 0x20, + 0xff, 0x00, 0x90, 0xd5, 0xd7, 0xfb, 0xf5, 0xac, 0xbe, 0x13, 0x0a, 0x7f, + 0x13, 0x33, 0xa8, 0xa2, 0x8e, 0xf5, 0x91, 0xb9, 0xb5, 0xe1, 0x1f, 0xf9, + 0x0b, 0xff, 0x00, 0xdb, 0x36, 0xab, 0xde, 0x34, 0xfb, 0x96, 0xdf, 0x56, + 0xfe, 0x42, 0xa8, 0xf8, 0x47, 0xfe, 0x42, 0xff, 0x00, 0xf6, 0xcd, 0xaa, + 0xf7, 0x8d, 0x3e, 0xed, 0xb7, 0xd5, 0xbf, 0x90, 0xad, 0x17, 0xc2, 0x62, + 0xfe, 0x33, 0x97, 0xa2, 0x8a, 0x2b, 0x33, 0x61, 0xc9, 0xf7, 0x87, 0xd4, + 0x57, 0xa4, 0x1f, 0xf5, 0x07, 0xfd, 0xc3, 0xfc, 0xab, 0xcd, 0xd7, 0xef, + 0x0f, 0xa8, 0xaf, 0x48, 0x3f, 0xea, 0x1b, 0xfd, 0xc3, 0xfc, 0xab, 0x58, + 0x18, 0xd5, 0xe8, 0x79, 0xc4, 0x9f, 0xeb, 0x5f, 0xfd, 0xe3, 0xfc, 0xe9, + 0x94, 0xf9, 0x3f, 0xd6, 0xbf, 0xfb, 0xc7, 0xf9, 0xd3, 0x2b, 0x36, 0x6a, + 0xb6, 0x0a, 0xef, 0xfc, 0x33, 0x34, 0x89, 0xa1, 0xdb, 0x85, 0x62, 0x00, + 0x07, 0x8f, 0xc4, 0xd7, 0x01, 0x5d, 0xe7, 0x87, 0x3f, 0xe4, 0x0b, 0x6f, + 0xf4, 0x3f, 0xcc, 0xd5, 0x41, 0x5d, 0x99, 0xd5, 0x6d, 0x2d, 0x0d, 0xa4, + 0xbd, 0x94, 0x01, 0x9c, 0x1a, 0x91, 0x6f, 0xc7, 0xf1, 0x29, 0xaa, 0x63, + 0xa5, 0x15, 0xa7, 0x22, 0x66, 0x3e, 0xd2, 0x48, 0xd2, 0x4b, 0xa8, 0x9f, + 0xf8, 0xb1, 0xf5, 0xa9, 0x43, 0x02, 0x32, 0x08, 0x35, 0x91, 0xfc, 0xe9, + 0x43, 0x32, 0x9c, 0xab, 0x10, 0x7d, 0x73, 0x52, 0xe9, 0xf6, 0x2d, 0x56, + 0x7d, 0x4d, 0x8a, 0x2b, 0x32, 0x3b, 0xc9, 0x54, 0xf2, 0x43, 0x0f, 0x71, + 0x56, 0xa3, 0xbd, 0x8d, 0xf8, 0x3f, 0x29, 0xa8, 0x71, 0x68, 0xd1, 0x54, + 0x8b, 0x2c, 0xd2, 0xd3, 0x15, 0x83, 0x0c, 0x83, 0x9a, 0x75, 0x49, 0xa0, + 0xb4, 0x52, 0x52, 0xd0, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, + 0x01, 0x45, 0x14, 0x50, 0x01, 0x49, 0x9a, 0x33, 0x55, 0x6e, 0x6e, 0x84, + 0x43, 0x6a, 0x9c, 0xb1, 0xfd, 0x28, 0x4a, 0xe2, 0x6d, 0x25, 0xa9, 0x3c, + 0x92, 0xac, 0x63, 0x2c, 0x71, 0x54, 0xa5, 0xbd, 0x66, 0x38, 0x8f, 0x81, + 0x55, 0xdd, 0xda, 0x43, 0x97, 0x39, 0xa4, 0xad, 0x94, 0x12, 0xdc, 0xe7, + 0x95, 0x46, 0xf6, 0x06, 0x25, 0xcf, 0xcc, 0x49, 0xa2, 0x8a, 0x2a, 0xcc, + 0xb7, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa4, 0x66, 0x0a, 0xa5, 0x89, + 0x00, 0x0e, 0xb9, 0x3d, 0x28, 0x02, 0xae, 0xa9, 0x3a, 0xdb, 0x69, 0xb3, + 0xca, 0xe7, 0x18, 0x5e, 0x2b, 0xcf, 0x7a, 0xf2, 0x7b, 0xd6, 0xdf, 0x89, + 0x75, 0x95, 0xbe, 0x93, 0xec, 0xd6, 0xed, 0x98, 0x11, 0xb9, 0x6f, 0xef, + 0x9a, 0xc3, 0xef, 0x58, 0xcd, 0xdd, 0x9d, 0x34, 0xa3, 0x64, 0x14, 0x7a, + 0xd1, 0x57, 0x34, 0x8b, 0x17, 0xbf, 0xd4, 0x23, 0x85, 0x46, 0x57, 0x70, + 0x2d, 0xec, 0xb5, 0x2b, 0x53, 0x46, 0xec, 0xae, 0x76, 0xfa, 0x42, 0x18, + 0xf4, 0xab, 0x64, 0x23, 0x04, 0x46, 0x0f, 0xe7, 0xcd, 0x71, 0xbe, 0x20, + 0xff, 0x00, 0x90, 0xd5, 0xd7, 0xfb, 0xf5, 0xde, 0x05, 0x0a, 0x00, 0x1f, + 0x74, 0x0c, 0x0a, 0xe0, 0xfc, 0x41, 0xff, 0x00, 0x21, 0xab, 0xaf, 0xf7, + 0xeb, 0x49, 0xec, 0x61, 0x49, 0xde, 0x4c, 0xce, 0xa2, 0x8a, 0x2b, 0x23, + 0xa0, 0xda, 0xf0, 0x8f, 0xfc, 0x85, 0xbf, 0xed, 0x99, 0xab, 0xde, 0x34, + 0xfb, 0xb6, 0xdf, 0x56, 0xfe, 0x42, 0xa8, 0xf8, 0x4b, 0xfe, 0x42, 0xff, + 0x00, 0xf6, 0xcc, 0xd5, 0xdf, 0x1a, 0x7d, 0xdb, 0x5f, 0xab, 0x7f, 0x2a, + 0xd1, 0x7c, 0x26, 0x2f, 0xe3, 0x39, 0x8a, 0x28, 0xa2, 0xb3, 0x36, 0x1c, + 0xbf, 0x78, 0x7e, 0x15, 0xe9, 0x40, 0x66, 0x3c, 0x7b, 0x62, 0xbc, 0xd5, + 0x7e, 0xf8, 0xfa, 0x8a, 0xf4, 0xa5, 0xfb, 0xa2, 0xb5, 0xa6, 0x61, 0x5b, + 0xa1, 0xe7, 0x17, 0x48, 0x63, 0xba, 0x95, 0x08, 0xc1, 0x57, 0x35, 0x15, + 0x6d, 0xf8, 0xaa, 0xc0, 0xdb, 0x6a, 0x1f, 0x68, 0x51, 0xfb, 0xa9, 0xb9, + 0x27, 0xd1, 0xab, 0x17, 0xf9, 0xfa, 0x56, 0x6d, 0x59, 0x9b, 0x45, 0xdd, + 0x21, 0x2b, 0xaf, 0xf0, 0x7d, 0xe0, 0x96, 0xc6, 0x4b, 0x66, 0x38, 0x78, + 0x9b, 0x23, 0xfd, 0xd3, 0x5c, 0x85, 0x5b, 0xd3, 0x2f, 0xdf, 0x4e, 0xbc, + 0x49, 0xd3, 0xa0, 0xe1, 0xd7, 0xb1, 0x53, 0xd6, 0x9c, 0x5d, 0x99, 0x33, + 0x8f, 0x32, 0xb1, 0xe8, 0x63, 0x90, 0x33, 0xde, 0x8a, 0x82, 0xd2, 0xea, + 0x1b, 0xcb, 0x75, 0x9a, 0x17, 0x0c, 0x84, 0x77, 0x3c, 0x83, 0xef, 0x53, + 0xd6, 0xe7, 0x26, 0xdb, 0x85, 0x14, 0x51, 0x40, 0x05, 0x06, 0x8a, 0x28, + 0x10, 0xe8, 0xe5, 0x78, 0xc8, 0x2a, 0x48, 0xab, 0x50, 0xdf, 0x03, 0xf2, + 0xc8, 0x31, 0xee, 0x2a, 0x9d, 0x15, 0x2e, 0x29, 0x97, 0x19, 0xb8, 0x9a, + 0xea, 0xc1, 0x86, 0x41, 0xc8, 0xa7, 0x56, 0x54, 0x33, 0x49, 0x11, 0xe0, + 0xf1, 0xe9, 0x5a, 0x10, 0x4c, 0xb2, 0xae, 0x54, 0xfe, 0x15, 0x94, 0xa3, + 0x63, 0xa2, 0x13, 0x52, 0x26, 0xa2, 0x92, 0x96, 0xa4, 0xd0, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, + 0x8a, 0x00, 0x28, 0xa2, 0x92, 0x80, 0x20, 0xb9, 0x9b, 0xc9, 0x8c, 0x9f, + 0xe2, 0x3d, 0x2b, 0x34, 0x92, 0x58, 0xb1, 0xe4, 0x9e, 0xb5, 0x62, 0xfd, + 0xb3, 0x36, 0xde, 0xc0, 0x55, 0x7a, 0xda, 0x0a, 0xca, 0xe7, 0x2d, 0x49, + 0x5d, 0xd8, 0x28, 0xa2, 0x8a, 0xb3, 0x30, 0xa2, 0x8a, 0x28, 0x00, 0xa2, + 0x8a, 0x28, 0x03, 0x37, 0x59, 0xd6, 0x62, 0xd2, 0x91, 0x41, 0x53, 0x24, + 0xcf, 0xf7, 0x56, 0xb9, 0x3d, 0x43, 0x5a, 0xbb, 0xd4, 0x32, 0xb2, 0x49, + 0xb2, 0x3e, 0xd1, 0xa7, 0x03, 0xf1, 0xf5, 0xae, 0x97, 0x5e, 0xd0, 0x8e, + 0xa9, 0x22, 0xcb, 0x1c, 0x81, 0x24, 0x55, 0xdb, 0xf3, 0x56, 0x23, 0x78, + 0x62, 0xe9, 0x4f, 0xcd, 0x24, 0x63, 0xf0, 0xac, 0xe4, 0xa4, 0xde, 0x86, + 0xd0, 0x71, 0x4b, 0x53, 0x1b, 0xf0, 0xc5, 0x27, 0x6a, 0xdd, 0x4f, 0x0c, + 0x39, 0x3f, 0xbc, 0x9d, 0x40, 0xf6, 0x19, 0xab, 0xb6, 0xfe, 0x1f, 0xb4, + 0x84, 0x82, 0xfb, 0xa5, 0x23, 0xb3, 0x74, 0xa1, 0x52, 0x93, 0x34, 0x75, + 0x22, 0x8e, 0x7e, 0xc3, 0x4f, 0x9f, 0x50, 0x90, 0x24, 0x11, 0x92, 0x3b, + 0xb9, 0xe8, 0x05, 0x76, 0xba, 0x3e, 0x95, 0x16, 0x95, 0x6d, 0xe5, 0xa6, + 0x1a, 0x56, 0xfb, 0xef, 0x8e, 0x4d, 0x49, 0x6e, 0xe9, 0x12, 0x84, 0x11, + 0xaa, 0x28, 0xe8, 0x54, 0x62, 0xad, 0x03, 0xb8, 0x64, 0x1e, 0xb5, 0x6a, + 0x1c, 0xa6, 0x33, 0xa8, 0xe4, 0x29, 0xe9, 0x5c, 0x0e, 0xbe, 0x73, 0xad, + 0xdc, 0xe3, 0xfb, 0xf5, 0xde, 0x3b, 0x2c, 0x68, 0x5e, 0x43, 0xb5, 0x14, + 0x65, 0x8f, 0xa0, 0xaf, 0x39, 0xbd, 0x9f, 0xed, 0x57, 0x92, 0xcf, 0x8e, + 0x24, 0x72, 0xc3, 0xf1, 0xa8, 0xa8, 0x55, 0x1d, 0xc8, 0x68, 0xa2, 0x96, + 0xb2, 0x3a, 0x0d, 0xcf, 0x07, 0xa1, 0x3a, 0xab, 0xb7, 0x65, 0x4a, 0xb9, + 0xe3, 0x45, 0x26, 0x2b, 0x66, 0x1d, 0x32, 0xc3, 0xf4, 0xa9, 0x3c, 0x1f, + 0x64, 0xd1, 0xdb, 0x49, 0x72, 0xc3, 0x06, 0x53, 0xf2, 0xfd, 0x2a, 0xef, + 0x89, 0x2c, 0xcd, 0xee, 0x95, 0x26, 0xc0, 0x0c, 0x91, 0x7c, 0xeb, 0xef, + 0xc7, 0x23, 0xf2, 0xad, 0x52, 0xf7, 0x4e, 0x77, 0x25, 0xce, 0x70, 0xb4, + 0x52, 0xd2, 0x56, 0x47, 0x40, 0xa0, 0xe1, 0x81, 0xf4, 0xaf, 0x4a, 0x89, + 0x83, 0x44, 0x8c, 0x3a, 0x11, 0x9a, 0xf3, 0x4a, 0xef, 0x3c, 0x3f, 0x74, + 0x2e, 0xf4, 0x98, 0x9b, 0x39, 0x74, 0x1b, 0x5b, 0xd8, 0xd6, 0x94, 0xcc, + 0x6b, 0x2d, 0x0b, 0x57, 0x96, 0x90, 0xde, 0xdb, 0x34, 0x13, 0x28, 0x65, + 0x6f, 0xcc, 0x1f, 0x5a, 0xe2, 0xf5, 0x4d, 0x12, 0xe3, 0x4e, 0x76, 0x24, + 0x19, 0x21, 0x3d, 0x1d, 0x46, 0x7f, 0x3a, 0xee, 0xf3, 0x51, 0x4d, 0x2a, + 0x80, 0x53, 0x86, 0xf5, 0x07, 0xa5, 0x68, 0xe1, 0xcc, 0x65, 0x19, 0xb8, + 0x9e, 0x71, 0x45, 0x75, 0xf7, 0x7a, 0x2d, 0x9d, 0xd3, 0x16, 0xf2, 0xfc, + 0xb6, 0x3f, 0xdd, 0xe2, 0xb3, 0xe4, 0xf0, 0xc1, 0xff, 0x00, 0x96, 0x53, + 0xff, 0x00, 0xdf, 0x42, 0xa1, 0xd2, 0x92, 0x36, 0x55, 0x53, 0x32, 0x2c, + 0xb5, 0x0b, 0x8d, 0x3e, 0x4d, 0xf6, 0xf2, 0x94, 0x24, 0xe7, 0x1d, 0x41, + 0xfc, 0x2b, 0xac, 0xd0, 0xf5, 0xd5, 0xd4, 0xd8, 0xc3, 0x2a, 0x2c, 0x77, + 0x00, 0x64, 0x63, 0xa3, 0x56, 0x21, 0xf0, 0xcd, 0xc1, 0x38, 0x59, 0x50, + 0xd6, 0xb6, 0x85, 0xa0, 0x36, 0x9f, 0x71, 0xf6, 0x89, 0x9c, 0x34, 0x80, + 0x61, 0x54, 0x76, 0xa2, 0x2a, 0x49, 0x93, 0x37, 0x06, 0x8d, 0xd1, 0xd2, + 0x96, 0x8a, 0x2b, 0x43, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa7, 0x43, 0x2b, 0x44, 0xe1, 0x87, 0xe3, 0x4d, 0xa2, 0x86, 0xae, + 0x09, 0xd9, 0xdc, 0xd7, 0x47, 0x0e, 0xa1, 0x87, 0x43, 0x4f, 0xaa, 0x9a, + 0x7b, 0x13, 0x11, 0x53, 0xd8, 0xd5, 0xba, 0xe7, 0x6a, 0xce, 0xc7, 0x64, + 0x5d, 0xd5, 0xc2, 0x8a, 0x28, 0xa4, 0x50, 0x51, 0x45, 0x14, 0x00, 0x51, + 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, + 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, + 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, + 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, + 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, + 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x52, 0x52, 0xd1, 0x40, 0x19, + 0xd7, 0xe8, 0x44, 0xa1, 0xbb, 0x1a, 0xad, 0x5a, 0x77, 0x11, 0x09, 0x63, + 0x2b, 0xdf, 0xb5, 0x66, 0x32, 0xb2, 0x36, 0xd7, 0x18, 0x22, 0xb6, 0x83, + 0xba, 0xb1, 0xcb, 0x52, 0x36, 0x77, 0x0a, 0x28, 0xa2, 0xac, 0xcc, 0x28, + 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x29, 0x19, 0x43, 0x8c, 0x11, + 0x4b, 0x45, 0x30, 0x29, 0xca, 0x85, 0x1b, 0x1d, 0xa9, 0x95, 0x6a, 0x75, + 0xdd, 0x19, 0xf5, 0x02, 0xaa, 0x8f, 0x7a, 0xd1, 0x3b, 0x80, 0xb4, 0xe5, + 0xb8, 0x5b, 0x74, 0x2f, 0x23, 0x62, 0x30, 0x32, 0x49, 0xa6, 0xd5, 0x4d, + 0x52, 0x09, 0x2e, 0x2c, 0x25, 0x8a, 0x1f, 0xbe, 0x47, 0x03, 0xd6, 0x89, + 0x6c, 0x0b, 0x73, 0x17, 0x5a, 0xf1, 0x13, 0xdf, 0x2b, 0x43, 0x6e, 0x3c, + 0xb8, 0x0f, 0x7e, 0xee, 0x3d, 0xfd, 0x2b, 0x14, 0xfd, 0x38, 0xa9, 0x5a, + 0xd2, 0xe1, 0x5b, 0x06, 0xde, 0x5c, 0xfb, 0x29, 0xa9, 0xe0, 0xd1, 0xef, + 0x67, 0x23, 0x10, 0xb0, 0x07, 0xfb, 0xdc, 0x57, 0x1d, 0xa4, 0xd9, 0xd6, + 0xb9, 0x62, 0x8a, 0x55, 0xa7, 0xa2, 0x68, 0xf2, 0x6a, 0x73, 0x86, 0x6f, + 0x96, 0xdd, 0x4e, 0x5d, 0xcf, 0x7f, 0x61, 0x5a, 0x36, 0x5e, 0x1b, 0x8e, + 0x3c, 0x3d, 0xcb, 0xef, 0x3f, 0xdd, 0x5e, 0x9f, 0x8d, 0x6e, 0x41, 0xb6, + 0x0d, 0xab, 0x1a, 0x85, 0x51, 0xc6, 0x07, 0x40, 0x2b, 0x48, 0xd2, 0x7b, + 0xb2, 0x27, 0x55, 0x5a, 0xc8, 0xb7, 0x12, 0x24, 0x51, 0x2c, 0x71, 0x8c, + 0x2a, 0x8c, 0x01, 0xe8, 0x29, 0xe7, 0x91, 0xcd, 0x20, 0x21, 0x86, 0x47, + 0xa5, 0x2d, 0x59, 0xce, 0x72, 0x1e, 0x20, 0xd0, 0x5a, 0xdd, 0xda, 0xea, + 0xd9, 0x73, 0x13, 0x1c, 0xba, 0x0f, 0xe0, 0x3f, 0xe1, 0x58, 0x15, 0xe8, + 0x73, 0xc9, 0xb8, 0x94, 0x1d, 0x07, 0x51, 0x58, 0xf7, 0xfa, 0x15, 0xbd, + 0xd1, 0x2f, 0x17, 0xee, 0x64, 0x3d, 0x48, 0x1c, 0x1a, 0x99, 0x53, 0xbe, + 0xa8, 0xde, 0x15, 0x6d, 0xa3, 0x39, 0x4a, 0xbd, 0xa4, 0x6a, 0xb3, 0x69, + 0x73, 0x6f, 0x8c, 0x6e, 0x8d, 0x87, 0xcc, 0x84, 0xe3, 0x77, 0xbf, 0xd6, + 0xa4, 0xb8, 0xd0, 0xaf, 0x20, 0x24, 0x84, 0x12, 0x8e, 0xc5, 0x6a, 0xa2, + 0xd8, 0xdd, 0x33, 0x6d, 0x5b, 0x79, 0x09, 0xee, 0x76, 0xd6, 0x5c, 0xb2, + 0x46, 0xad, 0xc5, 0xa3, 0xb7, 0x83, 0x52, 0x86, 0xfa, 0xd8, 0x4b, 0x6e, + 0x4e, 0xd3, 0xc1, 0x07, 0xaa, 0xd2, 0xd6, 0x6e, 0x81, 0x63, 0x2d, 0x9d, + 0xab, 0x79, 0xc3, 0x6b, 0x48, 0xdb, 0xb6, 0xff, 0x00, 0x76, 0xb4, 0xeb, + 0xaa, 0x1b, 0x6a, 0x72, 0x49, 0x24, 0xf4, 0x12, 0x94, 0x02, 0xcc, 0x00, + 0xeb, 0xda, 0x8a, 0x9a, 0xd9, 0x3a, 0xb1, 0xaa, 0xbd, 0x84, 0x49, 0x1c, + 0x4a, 0x83, 0xa7, 0x35, 0x20, 0xa0, 0x51, 0x59, 0xde, 0xe0, 0x14, 0x51, + 0x45, 0x20, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, + 0xa9, 0x20, 0x84, 0xcc, 0xe0, 0x01, 0xc7, 0x73, 0x43, 0x76, 0x1a, 0x4d, + 0xbb, 0x22, 0xdd, 0x8a, 0x95, 0x8b, 0x71, 0xfe, 0x23, 0x56, 0xe9, 0xaa, + 0xa1, 0x40, 0x03, 0xa0, 0xa7, 0x57, 0x3b, 0x77, 0x67, 0x64, 0x55, 0x95, + 0x82, 0x8a, 0x28, 0xa4, 0x30, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, + 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x01, 0x0d, 0x41, 0x71, + 0x6e, 0xb3, 0x0f, 0x46, 0xec, 0x6a, 0x7a, 0x28, 0xd8, 0x4d, 0x27, 0xb9, + 0x93, 0x2c, 0x2d, 0x13, 0x61, 0xf8, 0x1e, 0xbe, 0xb4, 0xca, 0xd6, 0x64, + 0x57, 0x18, 0x60, 0x08, 0xaa, 0xb2, 0xd8, 0xf7, 0x88, 0xe3, 0xd8, 0xd6, + 0xb1, 0x9a, 0xea, 0x61, 0x2a, 0x4d, 0x6a, 0x8a, 0x74, 0x53, 0x9e, 0x37, + 0x8c, 0x9d, 0xca, 0x45, 0x34, 0x56, 0x97, 0x31, 0xb3, 0x5b, 0x85, 0x14, + 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x0d, 0x7f, 0xba, 0x7e, 0x95, 0x4b, + 0xb9, 0xab, 0xad, 0xf7, 0x4f, 0xd0, 0xd5, 0x2a, 0xd2, 0x20, 0x2d, 0x25, + 0x2d, 0x15, 0x40, 0x5a, 0x45, 0xdd, 0x00, 0x1e, 0xa2, 0xaa, 0x91, 0x82, + 0x47, 0xbd, 0x5b, 0x8b, 0xfd, 0x52, 0xd5, 0x59, 0x06, 0x25, 0x6f, 0xad, + 0x4c, 0x77, 0x01, 0x28, 0xa2, 0x8a, 0xa0, 0x2c, 0x5b, 0x1c, 0xc7, 0x8e, + 0xe2, 0xa4, 0x73, 0xb5, 0x09, 0xf6, 0xa8, 0x6d, 0x8e, 0x37, 0x0a, 0x7d, + 0xc1, 0xc4, 0x47, 0xde, 0xb3, 0x6b, 0x50, 0x2a, 0x9e, 0xb9, 0xf5, 0xa5, + 0xa4, 0xa5, 0xab, 0x00, 0xab, 0x30, 0x2e, 0x23, 0xcf, 0x72, 0x2a, 0xb5, + 0x5c, 0x51, 0x84, 0xc7, 0xa0, 0xa5, 0x20, 0x29, 0x9e, 0x49, 0xfa, 0xd1, + 0x41, 0xea, 0x7e, 0xb4, 0x55, 0x20, 0x0a, 0xb5, 0x6f, 0xfe, 0xa8, 0x55, + 0x5a, 0xb3, 0x07, 0xfa, 0xa1, 0x53, 0x2d, 0x80, 0x96, 0x8a, 0x28, 0xac, + 0xc0, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x29, 0x3e, 0x95, + 0x2c, 0x76, 0xf2, 0x48, 0x78, 0x04, 0x0f, 0x53, 0x57, 0x21, 0xb3, 0x44, + 0x39, 0x7f, 0x99, 0xaa, 0x5c, 0x92, 0x2e, 0x34, 0xdb, 0x2a, 0xc3, 0x6c, + 0xf2, 0x9c, 0xf4, 0x5f, 0x5a, 0xd0, 0x8e, 0x35, 0x8d, 0x70, 0xa3, 0x14, + 0xe0, 0x29, 0x6b, 0x27, 0x26, 0xce, 0x88, 0xc1, 0x44, 0x5a, 0x28, 0xa2, + 0xa4, 0xb0, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, + 0x28, 0x01, 0x28, 0xa5, 0xa2, 0x80, 0x18, 0x54, 0x30, 0xc1, 0x19, 0xa8, + 0x64, 0xb3, 0x8d, 0xfe, 0xee, 0x54, 0xfb, 0x55, 0x8a, 0x29, 0xdd, 0xa1, + 0x38, 0xa7, 0xb9, 0x9d, 0x25, 0x94, 0x8b, 0x9d, 0xbc, 0x8a, 0x85, 0xa3, + 0x75, 0xfb, 0xca, 0x41, 0xfa, 0x56, 0xb9, 0xa4, 0x20, 0x1e, 0xbc, 0xfe, + 0x15, 0x4a, 0x6c, 0xcd, 0xd2, 0x4c, 0xc7, 0xa2, 0xb4, 0xda, 0xda, 0x27, + 0xea, 0x83, 0xf0, 0xa8, 0x9a, 0xc1, 0x0f, 0x46, 0x22, 0xaf, 0xda, 0x23, + 0x37, 0x49, 0xad, 0x8c, 0xf6, 0xfb, 0xa7, 0xe9, 0x54, 0xeb, 0x59, 0xec, + 0x24, 0xda, 0x76, 0xb0, 0x39, 0x15, 0x41, 0xb4, 0xfb, 0x94, 0xc9, 0xf2, + 0x89, 0xfa, 0x10, 0x6b, 0x48, 0xcd, 0x10, 0xe1, 0x24, 0x41, 0x45, 0x3c, + 0xc3, 0x2a, 0xf0, 0xd1, 0xb0, 0xfc, 0x29, 0x84, 0x11, 0xd4, 0x62, 0xb4, + 0xba, 0xee, 0x4d, 0x99, 0x6e, 0x2f, 0xf5, 0x4b, 0xf4, 0xaa, 0xd3, 0x7f, + 0xad, 0x6a, 0xb3, 0x17, 0xfa, 0xa1, 0x55, 0xa6, 0x3f, 0xbe, 0x6f, 0xad, + 0x4c, 0x5e, 0xa0, 0x36, 0x8a, 0x28, 0xab, 0x02, 0x5b, 0x5f, 0xbc, 0x7e, + 0x94, 0xfb, 0xaf, 0xb8, 0x3e, 0xb4, 0xcb, 0x5f, 0xbc, 0x7e, 0x94, 0xfb, + 0xaf, 0xb8, 0x3f, 0xde, 0xa8, 0xea, 0x05, 0x7a, 0x28, 0xa2, 0xac, 0x02, + 0xae, 0xf6, 0x1f, 0x4a, 0xa3, 0x9a, 0xba, 0x39, 0x51, 0xf4, 0xa8, 0x90, + 0x14, 0xdb, 0xef, 0x1f, 0xad, 0x14, 0x87, 0xef, 0x1f, 0xad, 0x28, 0x56, + 0x3d, 0x14, 0x9f, 0xc0, 0xd5, 0x5d, 0x06, 0xa2, 0x55, 0xa8, 0x3f, 0xd4, + 0x8a, 0x85, 0x6d, 0x67, 0x7f, 0xbb, 0x0b, 0xfd, 0x71, 0x57, 0xed, 0xec, + 0xa6, 0x11, 0x80, 0xca, 0x17, 0xea, 0x6a, 0x25, 0x25, 0x61, 0xa8, 0xb7, + 0xd0, 0x8e, 0x8a, 0xb6, 0xb6, 0x0d, 0xd5, 0x9c, 0x7e, 0x02, 0xa5, 0x5b, + 0x28, 0x87, 0x52, 0x58, 0xd6, 0x5c, 0xe8, 0xb5, 0x4e, 0x4c, 0xcf, 0x3c, + 0x53, 0xd2, 0x19, 0x24, 0xfb, 0xaa, 0x7f, 0x1a, 0xd1, 0x58, 0x23, 0x4e, + 0x42, 0x01, 0x52, 0x54, 0xba, 0x85, 0xaa, 0x3d, 0xca, 0x09, 0x62, 0xe7, + 0xef, 0xb0, 0x1f, 0x4a, 0xb3, 0x1d, 0xac, 0x71, 0xf4, 0x19, 0x3e, 0xf5, + 0x38, 0xa2, 0xa5, 0xc9, 0xb3, 0x45, 0x08, 0xa0, 0x14, 0x51, 0x4b, 0x52, + 0x58, 0x94, 0xb4, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, + 0x40, 0x05, 0x14, 0x51, 0x40, 0x09, 0x45, 0x2d, 0x14, 0x00, 0x94, 0x52, + 0xd1, 0x40, 0x09, 0x45, 0x2d, 0x14, 0x00, 0x86, 0x9a, 0x63, 0x56, 0xea, + 0xa0, 0xd3, 0xa8, 0xa0, 0x56, 0x23, 0x30, 0xc6, 0x47, 0xdc, 0x1f, 0x95, + 0x46, 0xf6, 0x36, 0xef, 0xc9, 0x8c, 0x55, 0x9a, 0x4a, 0x77, 0x61, 0xca, + 0x8a, 0x87, 0x4d, 0xb6, 0x3f, 0xc0, 0x7f, 0x3a, 0x69, 0xd2, 0xed, 0xcf, + 0xf0, 0x91, 0xf8, 0xd5, 0xda, 0x29, 0xf3, 0x3e, 0xe2, 0xe4, 0x89, 0x4d, + 0x34, 0xd8, 0x50, 0xe4, 0x6e, 0xfc, 0xe9, 0x5f, 0x4e, 0x86, 0x41, 0x83, + 0xbb, 0xf3, 0xab, 0x74, 0x51, 0xcc, 0xc3, 0x92, 0x25, 0x0f, 0xec, 0x98, + 0x3f, 0xdb, 0xfc, 0xe9, 0xc3, 0x4b, 0xb7, 0x1f, 0xc2, 0x4f, 0xd4, 0xd5, + 0xda, 0x28, 0xe7, 0x97, 0x70, 0xe4, 0x89, 0x54, 0x69, 0xd6, 0xe3, 0xfe, + 0x59, 0xe7, 0xf1, 0xa9, 0x05, 0xbc, 0x43, 0xf8, 0x07, 0xe5, 0x53, 0x51, + 0x4b, 0x99, 0x87, 0x2a, 0x22, 0x10, 0x44, 0x3a, 0x46, 0xbf, 0x95, 0x3c, + 0x28, 0x1d, 0x00, 0x14, 0xea, 0x29, 0x6a, 0x3b, 0x20, 0xa2, 0x96, 0x8a, + 0x06, 0x25, 0x14, 0xb4, 0x50, 0x02, 0x51, 0x4b, 0x45, 0x00, 0x25, 0x2d, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, + 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x07, 0xff, 0xd9 +}; +unsigned int octo_jpg_len = 14817; + +#endif diff --git a/esp/lib/Micro-RTSP/src/JPEGSamples.h b/esp/lib/Micro-RTSP/src/JPEGSamples.h new file mode 100644 index 0000000..038b19f --- /dev/null +++ b/esp/lib/Micro-RTSP/src/JPEGSamples.h @@ -0,0 +1,11 @@ +#pragma once + +#ifndef ARDUINO_ARCH_ESP32 +#define INCLUDE_SIMDATA +#endif + +#ifdef INCLUDE_SIMDATA +extern unsigned const char capture_jpg[]; +extern unsigned const char octo_jpg[]; +extern unsigned int octo_jpg_len, capture_jpg_len; +#endif diff --git a/esp/lib/Micro-RTSP/src/LinkedListElement.h b/esp/lib/Micro-RTSP/src/LinkedListElement.h new file mode 100644 index 0000000..64cbc53 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/LinkedListElement.h @@ -0,0 +1,43 @@ +#pragma once + +#include "platglue.h" +#include + +class LinkedListElement +{ +public: + LinkedListElement* m_Next; + LinkedListElement* m_Prev; + + LinkedListElement(void) + { + m_Next = this; + m_Prev = this; + printf("LinkedListElement (%p)->(%p)->(%p)\n", m_Prev, this, m_Next); + } + + int NotEmpty(void) + { + return (m_Next != this); + } + + LinkedListElement(LinkedListElement* linkedList) + { + // add to the end of list + m_Prev = linkedList->m_Prev; + linkedList->m_Prev = this; + m_Prev->m_Next = this; + m_Next = linkedList; + printf("LinkedListElement (%p)->(%p)->(%p)\n", m_Prev, this, m_Next); + } + + ~LinkedListElement() + { + printf("~LinkedListElement(%p)->(%p)->(%p)\n", m_Prev, this, m_Next); + if (m_Next) + m_Next->m_Prev = m_Prev; + if (m_Prev) + m_Prev->m_Next = m_Next; + printf("~LinkedListElement after: (%p)->(%p)", m_Prev, m_Prev->m_Next); + } +}; diff --git a/esp/lib/Micro-RTSP/src/OV2640.cpp b/esp/lib/Micro-RTSP/src/OV2640.cpp new file mode 100644 index 0000000..3237058 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/OV2640.cpp @@ -0,0 +1,201 @@ +#include "OV2640.h" + +#define TAG "OV2640" + +// definitions appropriate for the ESP32-CAM devboard (and most clones) +camera_config_t esp32cam_config{ + + .pin_pwdn = -1, // FIXME: on the TTGO T-Journal I think this is GPIO 0 + .pin_reset = 15, + + .pin_xclk = 27, + + .pin_sscb_sda = 25, + .pin_sscb_scl = 23, + + .pin_d7 = 19, + .pin_d6 = 36, + .pin_d5 = 18, + .pin_d4 = 39, + .pin_d3 = 5, + .pin_d2 = 34, + .pin_d1 = 35, + .pin_d0 = 17, + .pin_vsync = 22, + .pin_href = 26, + .pin_pclk = 21, + .xclk_freq_hz = 20000000, + .ledc_timer = LEDC_TIMER_0, + .ledc_channel = LEDC_CHANNEL_0, + .pixel_format = PIXFORMAT_JPEG, + // .frame_size = FRAMESIZE_UXGA, // needs 234K of framebuffer space + // .frame_size = FRAMESIZE_SXGA, // needs 160K for framebuffer + // .frame_size = FRAMESIZE_XGA, // needs 96K or even smaller FRAMESIZE_SVGA - can work if using only 1 fb + .frame_size = FRAMESIZE_SVGA, + .jpeg_quality = 12, //0-63 lower numbers are higher quality + .fb_count = 2 // if more than one i2s runs in continous mode. Use only with jpeg +}; + +camera_config_t esp32cam_aithinker_config{ + + .pin_pwdn = 32, + .pin_reset = -1, + + .pin_xclk = 0, + + .pin_sscb_sda = 26, + .pin_sscb_scl = 27, + + // Note: LED GPIO is apparently 4 not sure where that goes + // per https://github.com/donny681/ESP32_CAMERA_QR/blob/e4ef44549876457cd841f33a0892c82a71f35358/main/led.c + .pin_d7 = 35, + .pin_d6 = 34, + .pin_d5 = 39, + .pin_d4 = 36, + .pin_d3 = 21, + .pin_d2 = 19, + .pin_d1 = 18, + .pin_d0 = 5, + .pin_vsync = 25, + .pin_href = 23, + .pin_pclk = 22, + .xclk_freq_hz = 20000000, + .ledc_timer = LEDC_TIMER_1, + .ledc_channel = LEDC_CHANNEL_1, + .pixel_format = PIXFORMAT_JPEG, + // .frame_size = FRAMESIZE_UXGA, // needs 234K of framebuffer space + // .frame_size = FRAMESIZE_SXGA, // needs 160K for framebuffer + // .frame_size = FRAMESIZE_XGA, // needs 96K or even smaller FRAMESIZE_SVGA - can work if using only 1 fb + .frame_size = FRAMESIZE_SVGA, + .jpeg_quality = 12, //0-63 lower numbers are higher quality + .fb_count = 2 // if more than one i2s runs in continous mode. Use only with jpeg +}; + +camera_config_t esp32cam_ttgo_t_config{ + + .pin_pwdn = 26, + .pin_reset = -1, + + .pin_xclk = 32, + + .pin_sscb_sda = 13, + .pin_sscb_scl = 12, + + .pin_d7 = 39, + .pin_d6 = 36, + .pin_d5 = 23, + .pin_d4 = 18, + .pin_d3 = 15, + .pin_d2 = 4, + .pin_d1 = 14, + .pin_d0 = 5, + .pin_vsync = 27, + .pin_href = 25, + .pin_pclk = 19, + .xclk_freq_hz = 20000000, + .ledc_timer = LEDC_TIMER_0, + .ledc_channel = LEDC_CHANNEL_0, + .pixel_format = PIXFORMAT_JPEG, + .frame_size = FRAMESIZE_SVGA, + .jpeg_quality = 12, //0-63 lower numbers are higher quality + .fb_count = 2 // if more than one i2s runs in continous mode. Use only with jpeg +}; +void OV2640::done(void) +{ + if (fb) { + //return the frame buffer back to the driver for reuse + esp_camera_fb_return(fb); + fb = NULL; + } +} + +void OV2640::run(void) +{ + if (fb) + //return the frame buffer back to the driver for reuse + esp_camera_fb_return(fb); + + fb = esp_camera_fb_get(); +} + +void OV2640::runIfNeeded(void) +{ + if (!fb) + run(); +} + +int OV2640::getWidth(void) +{ + runIfNeeded(); + return fb->width; +} + +int OV2640::getHeight(void) +{ + runIfNeeded(); + return fb->height; +} + +size_t OV2640::getSize(void) +{ + runIfNeeded(); + if (!fb) + return 0; // FIXME - this shouldn't be possible but apparently the new cam board returns null sometimes? + return fb->len; +} + +uint8_t *OV2640::getfb(void) +{ + runIfNeeded(); + if (!fb) + return NULL; // FIXME - this shouldn't be possible but apparently the new cam board returns null sometimes? + + return fb->buf; +} + +framesize_t OV2640::getFrameSize(void) +{ + return _cam_config.frame_size; +} + +void OV2640::setFrameSize(framesize_t size) +{ + _cam_config.frame_size = size; +} + +pixformat_t OV2640::getPixelFormat(void) +{ + return _cam_config.pixel_format; +} + +void OV2640::setPixelFormat(pixformat_t format) +{ + switch (format) + { + case PIXFORMAT_RGB565: + case PIXFORMAT_YUV422: + case PIXFORMAT_GRAYSCALE: + case PIXFORMAT_JPEG: + _cam_config.pixel_format = format; + break; + default: + _cam_config.pixel_format = PIXFORMAT_GRAYSCALE; + break; + } +} + +esp_err_t OV2640::init(camera_config_t config) +{ + memset(&_cam_config, 0, sizeof(_cam_config)); + memcpy(&_cam_config, &config, sizeof(config)); + + esp_err_t err = esp_camera_init(&_cam_config); + if (err != ESP_OK) + { + printf("Camera probe failed with error 0x%x", err); + return err; + } + // ESP_ERROR_CHECK(gpio_install_isr_service(0)); + + return ESP_OK; +} diff --git a/esp/lib/Micro-RTSP/src/OV2640.h b/esp/lib/Micro-RTSP/src/OV2640.h new file mode 100644 index 0000000..b922476 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/OV2640.h @@ -0,0 +1,44 @@ +#ifndef OV2640_H_ +#define OV2640_H_ + +#include +#include +#include +#include "esp_log.h" +#include "esp_attr.h" +#include "esp_camera.h" + +extern camera_config_t esp32cam_config, esp32cam_aithinker_config, esp32cam_ttgo_t_config; + +class OV2640 +{ +public: + OV2640(){ + fb = NULL; + }; + ~OV2640(){ + }; + esp_err_t init(camera_config_t config); + void done(void); + void run(void); + size_t getSize(void); + uint8_t *getfb(void); + int getWidth(void); + int getHeight(void); + framesize_t getFrameSize(void); + pixformat_t getPixelFormat(void); + + void setFrameSize(framesize_t size); + void setPixelFormat(pixformat_t format); + +private: + void runIfNeeded(); // grab a frame if we don't already have one + + // camera_framesize_t _frame_size; + // camera_pixelformat_t _pixel_format; + camera_config_t _cam_config; + + camera_fb_t *fb; +}; + +#endif //OV2640_H_ diff --git a/esp/lib/Micro-RTSP/src/OV2640Streamer.cpp b/esp/lib/Micro-RTSP/src/OV2640Streamer.cpp new file mode 100644 index 0000000..8683e84 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/OV2640Streamer.cpp @@ -0,0 +1,19 @@ + +#include "OV2640Streamer.h" +#include + + + +OV2640Streamer::OV2640Streamer(OV2640 &cam) : CStreamer(cam.getWidth(), cam.getHeight()), m_cam(cam) +{ + printf("Created streamer width=%d, height=%d\n", cam.getWidth(), cam.getHeight()); +} + +void OV2640Streamer::streamImage(uint32_t curMsec) +{ + m_cam.run();// queue up a read for next time + + BufPtr bytes = m_cam.getfb(); + streamFrame(bytes, m_cam.getSize(), curMsec); + m_cam.done(); +} diff --git a/esp/lib/Micro-RTSP/src/OV2640Streamer.h b/esp/lib/Micro-RTSP/src/OV2640Streamer.h new file mode 100644 index 0000000..bd96263 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/OV2640Streamer.h @@ -0,0 +1,15 @@ +#pragma once + +#include "CStreamer.h" +#include "OV2640.h" + +class OV2640Streamer : public CStreamer +{ + bool m_showBig; + OV2640 &m_cam; + +public: + OV2640Streamer(OV2640 &cam); + + virtual void streamImage(uint32_t curMsec); +}; diff --git a/esp/lib/Micro-RTSP/src/SimStreamer.cpp b/esp/lib/Micro-RTSP/src/SimStreamer.cpp new file mode 100644 index 0000000..f94a23c --- /dev/null +++ b/esp/lib/Micro-RTSP/src/SimStreamer.cpp @@ -0,0 +1,28 @@ + +#include "SimStreamer.h" +#include "JPEGSamples.h" + + +#ifdef INCLUDE_SIMDATA +SimStreamer::SimStreamer(bool showBig) : CStreamer(showBig ? 800 : 640, showBig ? 600 : 480) +{ + m_showBig = showBig; +} + +void SimStreamer::streamImage(uint32_t curMsec) +{ + if(m_showBig) { + BufPtr bytes = capture_jpg; + uint32_t len = capture_jpg_len; + + streamFrame(bytes, len, curMsec); + } + else { + BufPtr bytes = octo_jpg; + uint32_t len = octo_jpg_len; + + streamFrame(bytes, len, curMsec); + } +} + +#endif diff --git a/esp/lib/Micro-RTSP/src/SimStreamer.h b/esp/lib/Micro-RTSP/src/SimStreamer.h new file mode 100644 index 0000000..5dc58f3 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/SimStreamer.h @@ -0,0 +1,15 @@ +#pragma once + +#include "JPEGSamples.h" +#include "CStreamer.h" + +#ifdef INCLUDE_SIMDATA +class SimStreamer : public CStreamer +{ + bool m_showBig; +public: + SimStreamer(bool showBig); + + virtual void streamImage(uint32_t curMsec); +}; +#endif diff --git a/esp/lib/Micro-RTSP/src/platglue-esp32.h b/esp/lib/Micro-RTSP/src/platglue-esp32.h new file mode 100644 index 0000000..8646904 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/platglue-esp32.h @@ -0,0 +1,107 @@ +#pragma once + +#include +#include +#include +#include +#include +//#include +#include + +#include +#include +#include +#include + + +typedef WiFiClient *SOCKET; +typedef WiFiUDP *UDPSOCKET; +typedef IPAddress IPADDRESS; // On linux use uint32_t in network byte order (per getpeername) +typedef uint16_t IPPORT; // on linux use network byte order + +#define NULLSOCKET NULL + +inline void closesocket(SOCKET s) { + printf("closing TCP socket\n"); + + if(s) { + s->stop(); + // delete s; TDP WiFiClients are never on the heap in arduino land? + } +} + +#define getRandom() random(65536) + +inline void socketpeeraddr(SOCKET s, IPADDRESS *addr, IPPORT *port) { + *addr = s->remoteIP(); + *port = s->remotePort(); +} + +inline void udpsocketclose(UDPSOCKET s) { + printf("closing UDP socket\n"); + if(s) { + s->stop(); + delete s; + } +} + +inline UDPSOCKET udpsocketcreate(unsigned short portNum) +{ + UDPSOCKET s = new WiFiUDP(); + + if(!s->begin(portNum)) { + printf("Can't bind port %d\n", portNum); + delete s; + return NULL; + } + + return s; +} + +// TCP sending +inline ssize_t socketsend(SOCKET sockfd, const void *buf, size_t len) +{ + return sockfd->write((uint8_t *) buf, len); +} + +inline ssize_t udpsocketsend(UDPSOCKET sockfd, const void *buf, size_t len, + IPADDRESS destaddr, IPPORT destport) +{ + sockfd->beginPacket(destaddr, destport); + sockfd->write((const uint8_t *) buf, len); + if(!sockfd->endPacket()) + printf("error sending udp packet\n"); + + return len; +} + +/** + Read from a socket with a timeout. + + Return 0=socket was closed by client, -1=timeout, >0 number of bytes read + */ +inline int socketread(SOCKET sock, char *buf, size_t buflen, int timeoutmsec) +{ + if(!sock->connected()) { + printf("client has closed the socket\n"); + return 0; + } + + int numAvail = sock->available(); + if(numAvail == 0 && timeoutmsec != 0) { + // sleep and hope for more + delay(timeoutmsec); + numAvail = sock->available(); + } + + if(numAvail == 0) { + // printf("timeout on read\n"); + return -1; + } + else { + // int numRead = sock->readBytesUntil('\n', buf, buflen); + int numRead = sock->readBytes(buf, buflen); + // printf("bytes avail %d, read %d: %s", numAvail, numRead, buf); + return numRead; + } +} diff --git a/esp/lib/Micro-RTSP/src/platglue-mbed.h b/esp/lib/Micro-RTSP/src/platglue-mbed.h new file mode 100644 index 0000000..771a594 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/platglue-mbed.h @@ -0,0 +1,94 @@ +/** + * @author Marco Garzola + */ +#pragma once + +#include "mbed.h" + +typedef TCPSocket* SOCKET; +typedef UDPSocket* UDPSOCKET; +typedef SocketAddress IPADDRESS; +typedef uint16_t IPPORT; + +#define SEND_TMEOUT_MS 1000 +#define NULLSOCKET NULL + +inline void closesocket(SOCKET s) +{ + if (s) + { + s->close(); + } +} + +#define getRandom() rand() + +inline void socketpeeraddr(SOCKET s, IPADDRESS* addr, IPPORT* port) +{ + s->getpeername(addr); + *port = addr->get_port(); +} + +inline UDPSOCKET udpsocketcreate(unsigned short portNum) +{ + UDPSOCKET s = new UDPSocket(); + + if (s->open(NetworkInterface::get_default_instance()) != 0 && s->bind(portNum) != 0) + { + printf("Can't bind port %d\n", portNum); + delete s; + return nullptr; + } + return s; +} + +inline void udpsocketclose(UDPSOCKET s) +{ + if (s) + { + s->close(); + delete s; + } +} + +inline ssize_t +udpsocketsend(UDPSOCKET sockfd, const void* buf, size_t len, IPADDRESS destaddr, uint16_t destport) +{ + if (sockfd) + { + return sockfd->sendto(destaddr.get_ip_address(), destport, buf, len); + } + else + { + return 0; + } +} +// TCP sending +inline ssize_t socketsend(SOCKET sockfd, const void* buf, size_t len) +{ + if (sockfd && buf) + { + sockfd->set_blocking(true); + sockfd->set_timeout(SEND_TMEOUT_MS); + return sockfd->send(buf, len); + } + else + { + return 0; + } +} + +inline int socketread(SOCKET sock, char* buf, size_t buflen, int timeoutmsec) +{ + if (sock && buf) + { + sock->set_blocking(true); + sock->set_timeout(timeoutmsec); + return sock->recv(buf, buflen); + } + else + { + return -1; + } +} + diff --git a/esp/lib/Micro-RTSP/src/platglue-posix.h b/esp/lib/Micro-RTSP/src/platglue-posix.h new file mode 100644 index 0000000..046258e --- /dev/null +++ b/esp/lib/Micro-RTSP/src/platglue-posix.h @@ -0,0 +1,111 @@ +#pragma once + +#include +#include +#include +#include + +#include +#include +#include +#include + +typedef int SOCKET; +typedef int UDPSOCKET; +typedef uint32_t IPADDRESS; // On linux use uint32_t in network byte order (per getpeername) +typedef uint16_t IPPORT; // on linux use network byte order + +#define NULLSOCKET 0 + +inline void closesocket(SOCKET s) { + close(s); +} + +#define getRandom() rand() + +inline void socketpeeraddr(SOCKET s, IPADDRESS *addr, IPPORT *port) { + + sockaddr_in r; + socklen_t len = sizeof(r); + if(getpeername(s,(struct sockaddr*)&r,&len) < 0) { + printf("getpeername failed\n"); + *addr = 0; + *port = 0; + } + else { + //htons + + *port = r.sin_port; + *addr = r.sin_addr.s_addr; + } +} + +inline void udpsocketclose(UDPSOCKET s) { + close(s); +} + +inline UDPSOCKET udpsocketcreate(unsigned short portNum) +{ + sockaddr_in addr; + + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = INADDR_ANY; + + int s = socket(AF_INET, SOCK_DGRAM, 0); + addr.sin_port = htons(portNum); + if (bind(s,(sockaddr*)&addr,sizeof(addr)) != 0) { + printf("Error, can't bind\n"); + close(s); + s = 0; + } + + return s; +} + +// TCP sending +inline ssize_t socketsend(SOCKET sockfd, const void *buf, size_t len) +{ + // printf("TCP send\n"); + return send(sockfd, buf, len, 0); +} + +inline ssize_t udpsocketsend(UDPSOCKET sockfd, const void *buf, size_t len, + IPADDRESS destaddr, uint16_t destport) +{ + sockaddr_in addr; + + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = destaddr; + addr.sin_port = htons(destport); + //printf("UDP send to 0x%0x:%0x\n", destaddr, destport); + + return sendto(sockfd, buf, len, 0, (sockaddr *) &addr, sizeof(addr)); +} + +/** + Read from a socket with a timeout. + + Return 0=socket was closed by client, -1=timeout, >0 number of bytes read + */ +inline int socketread(SOCKET sock, char *buf, size_t buflen, int timeoutmsec) +{ + // Use a timeout on our socket read to instead serve frames + struct timeval tv; + tv.tv_sec = 0; + tv.tv_usec = timeoutmsec * 1000; // send a new frame ever + setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv); + + int res = recv(sock,buf,buflen,0); + if(res > 0) { + return res; + } + else if(res == 0) { + return 0; // client dropped connection + } + else { + if (errno == EWOULDBLOCK || errno == EAGAIN) + return -1; + else + return 0; // unknown error, just claim client dropped it + }; +} diff --git a/esp/lib/Micro-RTSP/src/platglue.h b/esp/lib/Micro-RTSP/src/platglue.h new file mode 100644 index 0000000..cce3e22 --- /dev/null +++ b/esp/lib/Micro-RTSP/src/platglue.h @@ -0,0 +1,7 @@ +#pragma once + +#ifdef ARDUINO_ARCH_ESP32 +#include "platglue-esp32.h" +#else +#include "platglue-posix.h" +#endif diff --git a/esp/lib/Micro-RTSP/test/Makefile b/esp/lib/Micro-RTSP/test/Makefile new file mode 100644 index 0000000..7a394ea --- /dev/null +++ b/esp/lib/Micro-RTSP/test/Makefile @@ -0,0 +1,7 @@ + +SRCS = ../src/CRtspSession.cpp ../src/CStreamer.cpp ../src/JPEGSamples.cpp ../src/SimStreamer.cpp + +run: *.cpp ../src/* + skill testerver + g++ -o testserver -I ../src -I . *.cpp $(SRCS) + ./testserver diff --git a/esp/lib/Micro-RTSP/test/README.md b/esp/lib/Micro-RTSP/test/README.md new file mode 100644 index 0000000..3e63b44 --- /dev/null +++ b/esp/lib/Micro-RTSP/test/README.md @@ -0,0 +1,15 @@ +# Testserver + +This is a standalone Linux test application to allow development of this +library without going through the slow process of always testing on the ESP32. +Almost all of the code is the same - only platglue-posix.h differs from +platglue-esp32.h (thus serving as a crude HAL). + +RESPTestServer.cpp also serves as a small example of how this library could +be used on Poxix systems. + +# Usage + +Run "make" to build and run the server. Run "runvlc.sh" to fire up a VLC client +that talks to that server. If all is working you should see a static image +of my office that I captured using a ESP32-CAM. diff --git a/esp/lib/Micro-RTSP/test/RTSPTestServer.cpp b/esp/lib/Micro-RTSP/test/RTSPTestServer.cpp new file mode 100644 index 0000000..352c19d --- /dev/null +++ b/esp/lib/Micro-RTSP/test/RTSPTestServer.cpp @@ -0,0 +1,69 @@ +#include "platglue.h" + +#include "SimStreamer.h" +#include "CRtspSession.h" +#include "JPEGSamples.h" +#include +#include + + + +void workerThread(SOCKET s) +{ + SimStreamer streamer(s, true); // our streamer for UDP/TCP based RTP transport + + CRtspSession rtsp(s, &streamer); // our threads RTSP session and state + + while (!rtsp.m_stopped) + { + uint32_t timeout = 400; + if(!rtsp.handleRequests(timeout)) { + struct timeval now; + gettimeofday(&now, NULL); // crufty msecish timer + uint32_t msec = now.tv_sec * 1000 + now.tv_usec / 1000; + rtsp.broadcastCurrentFrame(msec); + } + } +} + +int main() +{ + SOCKET MasterSocket; // our masterSocket(socket that listens for RTSP client connections) + SOCKET ClientSocket; // RTSP socket to handle an client + sockaddr_in ServerAddr; // server address parameters + sockaddr_in ClientAddr; // address parameters of a new RTSP client + socklen_t ClientAddrLen = sizeof(ClientAddr); + + printf("running RTSP server\n"); + + ServerAddr.sin_family = AF_INET; + ServerAddr.sin_addr.s_addr = INADDR_ANY; + ServerAddr.sin_port = htons(8554); // listen on RTSP port 8554 + MasterSocket = socket(AF_INET,SOCK_STREAM,0); + + int enable = 1; + if (setsockopt(MasterSocket, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0) { + printf("setsockopt(SO_REUSEADDR) failed"); + return 0; + } + + // bind our master socket to the RTSP port and listen for a client connection + if (bind(MasterSocket,(sockaddr*)&ServerAddr,sizeof(ServerAddr)) != 0) { + printf("error can't bind port errno=%d\n", errno); + + return 0; + } + if (listen(MasterSocket,5) != 0) return 0; + + while (true) + { // loop forever to accept client connections + ClientSocket = accept(MasterSocket,(struct sockaddr*)&ClientAddr,&ClientAddrLen); + printf("Client connected. Client address: %s\r\n",inet_ntoa(ClientAddr.sin_addr)); + if(fork() == 0) + workerThread(ClientSocket); + } + + closesocket(MasterSocket); + + return 0; +} diff --git a/esp/lib/Micro-RTSP/test/devvlc.sh b/esp/lib/Micro-RTSP/test/devvlc.sh new file mode 100755 index 0000000..27f4817 --- /dev/null +++ b/esp/lib/Micro-RTSP/test/devvlc.sh @@ -0,0 +1,2 @@ +# for testing +vlc -v rtsp://192.168.86.215:8554/mjpeg/1 diff --git a/esp/lib/Micro-RTSP/test/rfccode.cpp b/esp/lib/Micro-RTSP/test/rfccode.cpp new file mode 100644 index 0000000..c7d09e4 --- /dev/null +++ b/esp/lib/Micro-RTSP/test/rfccode.cpp @@ -0,0 +1,111 @@ +#include "platglue.h" + +#include "SimStreamer.h" +#include "CRtspSession.h" +#include "JPEGSamples.h" + + +// From RFC2435 generates standard quantization tables + +/* + * Table K.1 from JPEG spec. + */ +static const int jpeg_luma_quantizer[64] = { + 16, 11, 10, 16, 24, 40, 51, 61, + 12, 12, 14, 19, 26, 58, 60, 55, + 14, 13, 16, 24, 40, 57, 69, 56, + 14, 17, 22, 29, 51, 87, 80, 62, + 18, 22, 37, 56, 68, 109, 103, 77, + 24, 35, 55, 64, 81, 104, 113, 92, + 49, 64, 78, 87, 103, 121, 120, 101, + 72, 92, 95, 98, 112, 100, 103, 99 +}; + +/* + * Table K.2 from JPEG spec. + */ +static const int jpeg_chroma_quantizer[64] = { + 17, 18, 24, 47, 99, 99, 99, 99, + 18, 21, 26, 66, 99, 99, 99, 99, + 24, 26, 56, 99, 99, 99, 99, 99, + 47, 66, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99 +}; + +/* + * Call MakeTables with the Q factor and two u_char[64] return arrays + */ +void +MakeTables(int q, u_char *lqt, u_char *cqt) +{ + int i; + int factor = q; + + if (q < 1) factor = 1; + if (q > 99) factor = 99; + if (q < 50) + q = 5000 / factor; + else + q = 200 - factor*2; + + for (i=0; i < 64; i++) { + int lq = (jpeg_luma_quantizer[i] * q + 50) / 100; + int cq = (jpeg_chroma_quantizer[i] * q + 50) / 100; + + /* Limit the quantizers to 1 <= q <= 255 */ + if (lq < 1) lq = 1; + else if (lq > 255) lq = 255; + lqt[i] = lq; + + if (cq < 1) cq = 1; + else if (cq > 255) cq = 255; + cqt[i] = cq; + } +} + + + +// analyze an imge from our camera to find which quant table it is using... +// Used to see if our camera is spitting out standard RTP tables (it isn't) + +// So we have to use Q of 255 to indicate that each frame has unique quant tables +// use 0 for precision in the qant header, 64 for length +void findCameraQuant() +{ + BufPtr bytes = capture_jpg; + uint32_t len = capture_jpg_len; + + if(!findJPEGheader(&bytes, &len, 0xdb)) { + printf("error can't find quant table 0\n"); + return; + } + else { + printf("found quant table %x (len %d)\n", bytes[2], bytes[1]); + } + BufPtr qtable0 = bytes + 3; // 3 bytes of header skipped + + nextJpegBlock(&bytes); + if(!findJPEGheader(&bytes, &len, 0xdb)) { + printf("error can't find quant table 1\n"); + return; + } + else { + printf("found quant table %x\n", bytes[2]); + } + BufPtr qtable1 = bytes + 3; + + nextJpegBlock(&bytes); + + for(int q = 0; q < 128; q++) { + uint8_t lqt[64], cqt[64]; + MakeTables(q, lqt, cqt); + + if(memcmp(qtable0, lqt, sizeof(lqt)) == 0 && memcmp(qtable1, cqt, sizeof(cqt)) == 0) { + printf("Found matching quant table %d\n", q); + } + } + printf("No matching quant table found!\n"); +} diff --git a/esp/lib/Micro-RTSP/test/runvlc.sh b/esp/lib/Micro-RTSP/test/runvlc.sh new file mode 100755 index 0000000..99150b5 --- /dev/null +++ b/esp/lib/Micro-RTSP/test/runvlc.sh @@ -0,0 +1,2 @@ +# for testing +vlc -v rtsp://127.0.0.1:8554/mjpeg/1 diff --git a/esp/lib/README b/esp/lib/README new file mode 100755 index 0000000..8c9c29c --- /dev/null +++ b/esp/lib/README @@ -0,0 +1,46 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into executable file. + +The source code of each library should be placed in a an own separate directory +("lib/your_library_name/[here are source files]"). + +For example, see a structure of the following two libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html +| | +| |--Foo +| | |- Foo.c +| | |- Foo.h +| | +| |- README --> THIS FILE +| +|- platformio.ini +|--src + |- main.c + +and a contents of `src/main.c`: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +PlatformIO Library Dependency Finder will find automatically dependent +libraries scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html diff --git a/esp/platformio.ini b/esp/platformio.ini new file mode 100755 index 0000000..fe1c71a --- /dev/null +++ b/esp/platformio.ini @@ -0,0 +1,18 @@ +; PlatformIO Project Configuration File +; +; Build options: build flags, source filter +; Upload options: custom upload port, speed and extra flags +; Library options: dependencies, extra library storages +; Advanced options: extra scripting +; +; Please visit documentation for the other options and examples +; https://docs.platformio.org/page/projectconf.html + +[env:m5stack-core-esp32] +platform = espressif32 +board = esp-wrover-kit +framework = arduino +lib_deps = + esp32-camera + Micro-RTSP +monitor_speed = 115200 diff --git a/esp/src/ESP32-devcam.ino b/esp/src/ESP32-devcam.ino new file mode 100755 index 0000000..50a58a9 --- /dev/null +++ b/esp/src/ESP32-devcam.ino @@ -0,0 +1,224 @@ +#include +#include "OV2640.h" +#include +#include +#include + +#include "SimStreamer.h" +#include "OV2640Streamer.h" +#include "CRtspSession.h" + +// #define ENABLE_OLED //if want use oled ,turn on thi macro +// #define SOFTAP_MODE // If you want to run our own softap turn this on +#define ENABLE_WEBSERVER +#define ENABLE_RTSPSERVER + +#ifdef ENABLE_OLED +#include "SSD1306.h" +#define OLED_ADDRESS 0x3c +#define I2C_SDA 14 +#define I2C_SCL 13 +SSD1306Wire display(OLED_ADDRESS, I2C_SDA, I2C_SCL, GEOMETRY_128_32); +bool hasDisplay; // we probe for the device at runtime +#endif + +OV2640 cam; + +#ifdef ENABLE_WEBSERVER +WebServer server(80); +#endif + +#ifdef ENABLE_RTSPSERVER +WiFiServer rtspServer(8554); +#endif + + +#ifdef SOFTAP_MODE +IPAddress apIP = IPAddress(192, 168, 1, 1); +#else +#include "wifikeys.h" +#endif + +#ifdef ENABLE_WEBSERVER +void handle_jpg_stream(void) +{ + WiFiClient client = server.client(); + String response = "HTTP/1.1 200 OK\r\n"; + response += "Content-Type: multipart/x-mixed-replace; boundary=frame\r\n\r\n"; + server.sendContent(response); + + while (1) + { + cam.run(); + if (!client.connected()) + break; + response = "--frame\r\n"; + response += "Content-Type: image/jpeg\r\n\r\n"; + server.sendContent(response); + + client.write((char *)cam.getfb(), cam.getSize()); + server.sendContent("\r\n"); + if (!client.connected()) + break; + } +} + +void handle_jpg(void) +{ + WiFiClient client = server.client(); + + cam.run(); + if (!client.connected()) + { + return; + } + String response = "HTTP/1.1 200 OK\r\n"; + response += "Content-disposition: inline; filename=capture.jpg\r\n"; + response += "Content-type: image/jpeg\r\n\r\n"; + server.sendContent(response); + client.write((char *)cam.getfb(), cam.getSize()); +} + +void handleNotFound() +{ + String message = "Server is running!\n\n"; + message += "URI: "; + message += server.uri(); + message += "\nMethod: "; + message += (server.method() == HTTP_GET) ? "GET" : "POST"; + message += "\nArguments: "; + message += server.args(); + message += "\n"; + server.send(200, "text/plain", message); +} +#endif + +#ifdef ENABLE_OLED +#define LCD_MESSAGE(msg) lcdMessage(msg) +#else +#define LCD_MESSAGE(msg) +#endif + +#ifdef ENABLE_OLED +void lcdMessage(String msg) +{ + if(hasDisplay) { + display.clear(); + display.drawString(128 / 2, 32 / 2, msg); + display.display(); + } +} +#endif + +CStreamer *streamer; + +void setup() +{ + #ifdef ENABLE_OLED + hasDisplay = display.init(); + if(hasDisplay) { + display.flipScreenVertically(); + display.setFont(ArialMT_Plain_16); + display.setTextAlignment(TEXT_ALIGN_CENTER); + } + #endif + LCD_MESSAGE("booting"); + + Serial.begin(115200); + while (!Serial) + { + ; + } + cam.init(esp32cam_config); + + IPAddress ip; + + +#ifdef SOFTAP_MODE + const char *hostname = "devcam"; + // WiFi.hostname(hostname); // FIXME - find out why undefined + LCD_MESSAGE("starting softAP"); + WiFi.mode(WIFI_AP); + WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0)); + bool result = WiFi.softAP(hostname, "12345678", 1, 0); + if (!result) + { + Serial.println("AP Config failed."); + return; + } + else + { + Serial.println("AP Config Success."); + Serial.print("AP MAC: "); + Serial.println(WiFi.softAPmacAddress()); + + ip = WiFi.softAPIP(); + } +#else + LCD_MESSAGE(String("join ") + ssid); + WiFi.mode(WIFI_STA); + WiFi.begin(ssid, password); + while (WiFi.status() != WL_CONNECTED) + { + delay(500); + Serial.print(F(".")); + } + ip = WiFi.localIP(); + Serial.println(F("WiFi connected")); + Serial.println(""); + Serial.println(ip); +#endif + + LCD_MESSAGE(ip.toString()); + +#ifdef ENABLE_WEBSERVER + server.on("/", HTTP_GET, handle_jpg_stream); + server.on("/jpg", HTTP_GET, handle_jpg); + server.onNotFound(handleNotFound); + server.begin(); +#endif + +#ifdef ENABLE_RTSPSERVER + rtspServer.begin(); + + //streamer = new SimStreamer(true); // our streamer for UDP/TCP based RTP transport + streamer = new OV2640Streamer(cam); // our streamer for UDP/TCP based RTP transport +#endif +} + +void loop() +{ +#ifdef ENABLE_WEBSERVER + server.handleClient(); +#endif + +#ifdef ENABLE_RTSPSERVER + uint32_t msecPerFrame = 100; + static uint32_t lastimage = millis(); + + // If we have an active client connection, just service that until gone + streamer->handleRequests(0); // we don't use a timeout here, + // instead we send only if we have new enough frames + uint32_t now = millis(); + if(streamer->anySessions()) { + if(now > lastimage + msecPerFrame || now < lastimage) { // handle clock rollover + streamer->streamImage(now); + lastimage = now; + + // check if we are overrunning our max frame rate + now = millis(); + if(now > lastimage + msecPerFrame) { + printf("warning exceeding max frame rate of %d ms\n", now - lastimage); + } + } + } + + WiFiClient rtspClient = rtspServer.accept(); + if(rtspClient) { + Serial.print("client: "); + Serial.print(rtspClient.remoteIP()); + Serial.println(); + streamer->addSession(rtspClient); + } +#endif +} diff --git a/esp/src/wifikeys.h b/esp/src/wifikeys.h new file mode 100755 index 0000000..8977a29 --- /dev/null +++ b/esp/src/wifikeys.h @@ -0,0 +1,3 @@ +// copy this file to wifikeys.h and edit +const char *ssid = "S o S"; // Put your SSID here +const char *password = "SandraArSnygg"; // Put your PASSWORD here diff --git a/esp/test/README b/esp/test/README new file mode 100755 index 0000000..c3b0ed6 --- /dev/null +++ b/esp/test/README @@ -0,0 +1,11 @@ + +This directory is intended for PIO Unit Testing and project tests. + +Unit Testing is a software testing method by which individual units of +source code, sets of one or more MCU program modules together with associated +control data, usage procedures, and operating procedures, are tested to +determine whether they are fit for use. Unit testing finds problems early +in the development cycle. + +More information about PIO Unit Testing: +- https://docs.platformio.org/page/plus/unit-testing.html diff --git a/water_meter/calibration.py b/water_meter/calibration.py new file mode 100755 index 0000000..614e9af --- /dev/null +++ b/water_meter/calibration.py @@ -0,0 +1,239 @@ +import math +import sys +import cv2 +import os +import numpy as np + + +class WaterMeter(object): + + def __init__(self, url, img=None, debug=False): + self.url = url + self.img = img + self.debug = debug + + def read(self): + if self.img: + img = cv2.imread(self.img) + return img + + def loop(self): + img = self.read() + needle = self.find_red_needle(img) + #needle = self.get_contours(needle, img) + dials = self.find_circle(img) + + for dial in dials: + ulx = int(dial[0]) + uly = int(dial[1]) + radius = int(dial[2]) * 3 + cut = img[uly - radius: uly + radius, + ulx - radius: ulx + radius] + needle_cut = needle[uly - radius: uly + radius, + ulx - radius: ulx + radius] + self.findAngle(cut, needle_cut, (radius, radius), radius * 2) + if self.debug: + cv2.imshow('image', img) + cv2.waitKey(0) + + + @staticmethod + def line(p1, p2): + A = (p1[1] - p2[1]) + B = (p2[0] - p1[0]) + C = (p1[0] * p2[1] - p2[0] * p1[1]) + return A, B, -C + + @staticmethod + def intersection(L1, L2): + D = L1[0] * L2[1] - L1[1] * L2[0] + Dx = L1[2] * L2[1] - L1[1] * L2[2] + Dy = L1[0] * L2[2] - L1[2] * L2[0] + if D != 0: + x = Dx / D + y = Dy / D + return x, y + else: + return False + + def find_circle(self, img): + img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + gradient = cv2.HOUGH_GRADIENT + # Find suitable number by running detect_circle.py + circles = cv2.HoughCircles(img, gradient, 1.2, 40, + param1=50, param2=50, minRadius=50, + maxRadius=100) + if circles is not None: + circles = np.round(circles[0, :]).astype("int") + dials = [] + for (x, y, r) in circles: + dials.append([x, y, r]) + if self.debug: + # draw the circle + cv2.circle(img, (x, y), r, (0, 255, 0), 4) + # draw a rectangle in the middle + cv2.rectangle(img, (x - 5, y - 5), (x + 5, y + 5), + (0, 128, 255), + -1) + if self.debug: + cv2.imshow('circle', img) + cv2.waitKey(0) + + return dials + + def find_red_needle(self, img): + hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) + # Find suitable hsv number by running detect_hsv.py + lower_red_hue = self.create_hue_mask(hsv, [0, 100, 100], [10, 255, 255]) + higher_red_hue = self.create_hue_mask(hsv, [170, 100, 100], [179, 255, 255]) + + mask = cv2.bitwise_or(lower_red_hue, higher_red_hue) + needle = cv2.GaussianBlur(mask, (5, 5), 0) + return needle + + def get_contours(self, img, org): + ret, thresh = cv2.threshold(img, 127, 255, 0) + contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, + cv2.CHAIN_APPROX_SIMPLE) + + if self.debug: + for contour in contours: + peri = cv2.arcLength(contour, True) + approx = cv2.approxPolyDP(contour, 0.04 * peri, True) + + cv2.drawContours(org, [approx], -1, (0, 0, 255), 3) + + #cv2.drawContours(org, contours, -1, (0, 255, 0), 3) + cv2.imshow('needle', org) + cv2.waitKey(0) + + return contours + + @staticmethod + def draw_line(lines, img): + for r, theta in lines[0]: + # Stores the value of cos(theta) in a + a = np.cos(theta) + + # Stores the value of sin(theta) in b + b = np.sin(theta) + + # x0 stores the value rcos(theta) + x0 = a * r + + # y0 stores the value rsin(theta) + y0 = b * r + + # x1 stores the rounded off value of (rcos(theta)-1000sin(theta)) + x1 = int(x0 + 1000 * (-b)) + + # y1 stores the rounded off value of (rsin(theta)+1000cos(theta)) + y1 = int(y0 + 1000 * (a)) + + # x2 stores the rounded off value of (rcos(theta)+1000sin(theta)) + x2 = int(x0 - 1000 * (-b)) + + # y2 stores the rounded off value of (rsin(theta)-1000cos(theta)) + y2 = int(y0 - 1000 * (a)) + + # cv2.line draws a line in img from the point(x1,y1) to (x2,y2). + # (0,0,255) denotes the colour of the line to be + # drawn. In this case, it is red. + cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2) + + return img + + def findAngle(self, img, redimg, center, width): + ### lines + edges = cv2.Canny(redimg, 100, 200, apertureSize=3) + lines = cv2.HoughLinesP(image=edges, + rho=1, + theta=np.pi / 90, + threshold=15, + minLineLength=width / 4, + maxLineGap=50) + + tip = None + maxlen = 0 + if lines is None: + print("No lines found") + + cv2.imshow('error', img) + cv2.waitKey() + cv2.destroyAllWindows() + + else: + pl = None + img = self.draw_line(lines, img) + cv2.imshow('error', img) + cv2.waitKey() + cv2.destroyAllWindows() + # print "%d lines" % len(lines) + for x in range(0, len(lines)): + for x1, y1, x2, y2 in lines[x]: + l = self.line([x1, y1], [x2, y2]); + cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 2) + # print "line: %d,%d %d,%d" % (x1, y1, x2, y2) + + # see if it intersects any other line + for y in range(0, len(lines)): + for xx1, yy1, xx2, yy2 in lines[y]: + l2 = self.line([xx1, yy1], [xx2, yy2]); + if l2 is l: + continue + r = self.intersection(l, l2) + if r and r[0] > 0 and r[1] > 0: + dist = math.sqrt((r[0] - center[0]) ** 2 + ( + r[1] - center[1]) ** 2) + # print "intersection %d,%d at distance %d" % ( r[0], r[1], dist) + # cv2.circle(img,(r[0],r[1]),2,(0,0,255),2) + if dist > maxlen and dist < width / 2: + tip = r + maxlen = dist + + + + # print "chosen intersection: %d,%d at distance %d" % ( tip[0], tip[1], maxlen) + #cv2.line(img, (tip[0], tip[1]), (center[0], center[1]), (255, 0, 255), + # 2) + + xlen = tip[0] - center[0] + ylen = center[1] - tip[1] + rad = math.atan2(ylen, xlen) + deg = math.degrees(rad) + # print "angle deg:", deg + # print "angle rad:", rad + + if deg < 0: + percent = (90 + abs(deg)) / 360 + elif deg < 90: + percent = (90 - deg) / 360 + else: + percent = (450 - deg) / 360 + + # print "percent", math.trunc(percent * 100) + string = "%d%%" % math.trunc(percent * 100) + cv2.putText(img, string, (center[0] - width / 5, center[1] - width / 3), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, + (255, 255, 255), 2) + + return math.trunc(percent * 100) + + @staticmethod + def create_hue_mask(image, lower_color, upper_color): + lower = np.array(lower_color, np.uint8) + upper = np.array(upper_color, np.uint8) + + # Create a mask from the colors + mask = cv2.inRange(image, lower, upper) + return mask + + + + + + +if __name__ == '__main__': + water_meter = WaterMeter('', img='capture_1.jpg', debug=True) + water_meter.loop() + diff --git a/water_meter/capture.jpg b/water_meter/capture.jpg new file mode 100755 index 0000000..385ff2a Binary files /dev/null and b/water_meter/capture.jpg differ diff --git a/water_meter/capture_1.jpg b/water_meter/capture_1.jpg new file mode 100755 index 0000000..84a6365 Binary files /dev/null and b/water_meter/capture_1.jpg differ diff --git a/water_meter/detect_circle.py b/water_meter/detect_circle.py new file mode 100755 index 0000000..12f8b02 --- /dev/null +++ b/water_meter/detect_circle.py @@ -0,0 +1,82 @@ +import cv2 +import numpy as np + + +def nothing(x): + pass + + +# Load image +image = cv2.imread('capture_1.jpg') + +# Create a window +cv2.namedWindow('image') +# dp, minDist, circles=None, param1=None, param2=None, minRadius=None, maxRadius=None) +# Create trackbars for color change +# Hue is from 0-179 for Opencv +cv2.createTrackbar('dp', 'image', 0, 300, nothing) +cv2.createTrackbar('minDist', 'image', 0, 1000, nothing) +cv2.createTrackbar('param1', 'image', 0, 179, nothing) +cv2.createTrackbar('param2', 'image', 0, 255, nothing) +cv2.createTrackbar('minRadius', 'image', 0, 255, nothing) +cv2.createTrackbar('maxRadius', 'image', 0, 255, nothing) + +# Set default value for Max HSV trackbars +cv2.setTrackbarPos('dp', 'image', 100) +cv2.setTrackbarPos('minDist', 'image', 50) +cv2.setTrackbarPos('param1', 'image', 20) +cv2.setTrackbarPos('param2', 'image', 15) +cv2.setTrackbarPos('minRadius', 'image', 20) +cv2.setTrackbarPos('maxRadius', 'image', 50) + +# Initialize HSV min/max values +dp = minDist = param1 = param2 = minRadius = maxRadius = 0 +pdp = pminDist = pparam1 = pparam2 = pminRadius = pmaxRadius = 0 + +while (1): + # Get current positions of all trackbars + dp = cv2.getTrackbarPos('dp', 'image') + minDist = cv2.getTrackbarPos('minDist', 'image') + param1 = cv2.getTrackbarPos('param1', 'image') + param2 = cv2.getTrackbarPos('param2', 'image') + minRadius = cv2.getTrackbarPos('minRadius', 'image') + maxRadius = cv2.getTrackbarPos('maxRadius', 'image') + + img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) + gradient = cv2.HOUGH_GRADIENT + circles = cv2.HoughCircles(img, gradient, dp/100.0, minDist, + param1=param1, param2=param2, minRadius=minRadius, + maxRadius=maxRadius) + + # Print if there is a change in HSV value + if ((pdp != dp) | (pminDist != minDist) | (pparam1 != param1) | ( + pparam2 != param2) | (pminRadius != minRadius) | ( + pmaxRadius != maxRadius)): + print("dp: {}, minDist: {}, param1: {}, param2: {}, minRadius: {}, maxRadius: {}" + .format(dp, minDist, param1, param2, minRadius, maxRadius)) + pdp = dp + pminDist = minDist + pparam1 = param1 + pparam2 = param2 + pminRadius = minRadius + pmaxRadius = maxRadius + + # Display result image + if circles is None: + cv2.imshow('image', img) + else: + circles = np.round(circles[0, :]).astype("int") + output = image.copy() + # loop over the (x, y) coordinates and radius of the circles + for (x, y, r) in circles: + # draw the circle in the output image, then draw a rectangle + # corresponding to the center of the circle + cv2.circle(output, (x, y), r, (0, 255, 0), 4) + cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), + -1) + cv2.imshow('image', output) + + if cv2.waitKey(10) & 0xFF == ord('q'): + break + +cv2.destroyAllWindows() diff --git a/water_meter/detect_hsv.py b/water_meter/detect_hsv.py new file mode 100755 index 0000000..0400462 --- /dev/null +++ b/water_meter/detect_hsv.py @@ -0,0 +1,64 @@ +import cv2 +import numpy as np + +def nothing(x): + pass + +# Load image +image = cv2.imread('capture.jpg') + +# Create a window +cv2.namedWindow('image') + +# Create trackbars for color change +# Hue is from 0-179 for Opencv +cv2.createTrackbar('HMin', 'image', 0, 179, nothing) +cv2.createTrackbar('SMin', 'image', 0, 255, nothing) +cv2.createTrackbar('VMin', 'image', 0, 255, nothing) +cv2.createTrackbar('HMax', 'image', 0, 179, nothing) +cv2.createTrackbar('SMax', 'image', 0, 255, nothing) +cv2.createTrackbar('VMax', 'image', 0, 255, nothing) + +# Set default value for Max HSV trackbars +cv2.setTrackbarPos('HMax', 'image', 179) +cv2.setTrackbarPos('SMax', 'image', 255) +cv2.setTrackbarPos('VMax', 'image', 255) + +# Initialize HSV min/max values +hMin = sMin = vMin = hMax = sMax = vMax = 0 +phMin = psMin = pvMin = phMax = psMax = pvMax = 0 + +while(1): + # Get current positions of all trackbars + hMin = cv2.getTrackbarPos('HMin', 'image') + sMin = cv2.getTrackbarPos('SMin', 'image') + vMin = cv2.getTrackbarPos('VMin', 'image') + hMax = cv2.getTrackbarPos('HMax', 'image') + sMax = cv2.getTrackbarPos('SMax', 'image') + vMax = cv2.getTrackbarPos('VMax', 'image') + + # Set minimum and maximum HSV values to display + lower = np.array([hMin, sMin, vMin]) + upper = np.array([hMax, sMax, vMax]) + + # Convert to HSV format and color threshold + hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) + mask = cv2.inRange(hsv, lower, upper) + result = cv2.bitwise_and(image, image, mask=mask) + + # Print if there is a change in HSV value + if((phMin != hMin) | (psMin != sMin) | (pvMin != vMin) | (phMax != hMax) | (psMax != sMax) | (pvMax != vMax) ): + print("(hMin = %d , sMin = %d, vMin = %d), (hMax = %d , sMax = %d, vMax = %d)" % (hMin , sMin , vMin, hMax, sMax , vMax)) + phMin = hMin + psMin = sMin + pvMin = vMin + phMax = hMax + psMax = sMax + pvMax = vMax + + # Display result image + cv2.imshow('image', result) + if cv2.waitKey(10) & 0xFF == ord('q'): + break + +cv2.destroyAllWindows()