From 7aa69e63ac5a133f0d78cd59af83ebdb7552b0c5 Mon Sep 17 00:00:00 2001 From: Simon Milvert Date: Wed, 6 Jan 2021 22:09:55 +0100 Subject: [PATCH] ESP code timeouts, Python program for calibrate has a first draft --- esp/.gitignore | 5 + esp/include/README | 39 + esp/lib/Micro-RTSP/.gitignore | 2 + esp/lib/Micro-RTSP/LICENSE | 7 + esp/lib/Micro-RTSP/README.md | 93 + esp/lib/Micro-RTSP/TODO.md | 18 + esp/lib/Micro-RTSP/examples/.gitignore | 3 + esp/lib/Micro-RTSP/examples/ESP32-devcam.ino | 223 ++ esp/lib/Micro-RTSP/examples/platformio.ini | 15 + esp/lib/Micro-RTSP/examples/wifikeys.h | 3 + .../Micro-RTSP/examples/wifikeys_template.h | 3 + esp/lib/Micro-RTSP/library.json | 22 + esp/lib/Micro-RTSP/library.properties | 9 + esp/lib/Micro-RTSP/src/CRtspSession.cpp | 422 +++ esp/lib/Micro-RTSP/src/CRtspSession.h | 79 + esp/lib/Micro-RTSP/src/CStreamer.cpp | 412 ++ esp/lib/Micro-RTSP/src/CStreamer.h | 65 + esp/lib/Micro-RTSP/src/JPEGSamples.cpp | 3327 +++++++++++++++++ esp/lib/Micro-RTSP/src/JPEGSamples.h | 11 + esp/lib/Micro-RTSP/src/LinkedListElement.h | 43 + esp/lib/Micro-RTSP/src/OV2640.cpp | 201 + esp/lib/Micro-RTSP/src/OV2640.h | 44 + esp/lib/Micro-RTSP/src/OV2640Streamer.cpp | 19 + esp/lib/Micro-RTSP/src/OV2640Streamer.h | 15 + esp/lib/Micro-RTSP/src/SimStreamer.cpp | 28 + esp/lib/Micro-RTSP/src/SimStreamer.h | 15 + esp/lib/Micro-RTSP/src/platglue-esp32.h | 107 + esp/lib/Micro-RTSP/src/platglue-mbed.h | 94 + esp/lib/Micro-RTSP/src/platglue-posix.h | 111 + esp/lib/Micro-RTSP/src/platglue.h | 7 + esp/lib/Micro-RTSP/test/Makefile | 7 + esp/lib/Micro-RTSP/test/README.md | 15 + esp/lib/Micro-RTSP/test/RTSPTestServer.cpp | 69 + esp/lib/Micro-RTSP/test/devvlc.sh | 2 + esp/lib/Micro-RTSP/test/rfccode.cpp | 111 + esp/lib/Micro-RTSP/test/runvlc.sh | 2 + esp/lib/README | 46 + esp/platformio.ini | 18 + esp/src/ESP32-devcam.ino | 224 ++ esp/src/wifikeys.h | 3 + esp/test/README | 11 + water_meter/calibration.py | 239 ++ water_meter/capture.jpg | Bin 0 -> 22258 bytes water_meter/capture_1.jpg | Bin 0 -> 22456 bytes water_meter/detect_circle.py | 82 + water_meter/detect_hsv.py | 64 + 46 files changed, 6335 insertions(+) create mode 100755 esp/.gitignore create mode 100755 esp/include/README create mode 100644 esp/lib/Micro-RTSP/.gitignore create mode 100644 esp/lib/Micro-RTSP/LICENSE create mode 100644 esp/lib/Micro-RTSP/README.md create mode 100644 esp/lib/Micro-RTSP/TODO.md create mode 100644 esp/lib/Micro-RTSP/examples/.gitignore create mode 100644 esp/lib/Micro-RTSP/examples/ESP32-devcam.ino create mode 100644 esp/lib/Micro-RTSP/examples/platformio.ini create mode 100755 esp/lib/Micro-RTSP/examples/wifikeys.h create mode 100644 esp/lib/Micro-RTSP/examples/wifikeys_template.h create mode 100644 esp/lib/Micro-RTSP/library.json create mode 100644 esp/lib/Micro-RTSP/library.properties create mode 100644 esp/lib/Micro-RTSP/src/CRtspSession.cpp create mode 100644 esp/lib/Micro-RTSP/src/CRtspSession.h create mode 100644 esp/lib/Micro-RTSP/src/CStreamer.cpp create mode 100644 esp/lib/Micro-RTSP/src/CStreamer.h create mode 100644 esp/lib/Micro-RTSP/src/JPEGSamples.cpp create mode 100644 esp/lib/Micro-RTSP/src/JPEGSamples.h create mode 100644 esp/lib/Micro-RTSP/src/LinkedListElement.h create mode 100644 esp/lib/Micro-RTSP/src/OV2640.cpp create mode 100644 esp/lib/Micro-RTSP/src/OV2640.h create mode 100644 esp/lib/Micro-RTSP/src/OV2640Streamer.cpp create mode 100644 esp/lib/Micro-RTSP/src/OV2640Streamer.h create mode 100644 esp/lib/Micro-RTSP/src/SimStreamer.cpp create mode 100644 esp/lib/Micro-RTSP/src/SimStreamer.h create mode 100644 esp/lib/Micro-RTSP/src/platglue-esp32.h create mode 100644 esp/lib/Micro-RTSP/src/platglue-mbed.h create mode 100644 esp/lib/Micro-RTSP/src/platglue-posix.h create mode 100644 esp/lib/Micro-RTSP/src/platglue.h create mode 100644 esp/lib/Micro-RTSP/test/Makefile create mode 100644 esp/lib/Micro-RTSP/test/README.md create mode 100644 esp/lib/Micro-RTSP/test/RTSPTestServer.cpp create mode 100755 esp/lib/Micro-RTSP/test/devvlc.sh create mode 100644 esp/lib/Micro-RTSP/test/rfccode.cpp create mode 100755 esp/lib/Micro-RTSP/test/runvlc.sh create mode 100755 esp/lib/README create mode 100755 esp/platformio.ini create mode 100755 esp/src/ESP32-devcam.ino create mode 100755 esp/src/wifikeys.h create mode 100755 esp/test/README create mode 100755 water_meter/calibration.py create mode 100755 water_meter/capture.jpg create mode 100755 water_meter/capture_1.jpg create mode 100755 water_meter/detect_circle.py create mode 100755 water_meter/detect_hsv.py 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 0000000000000000000000000000000000000000..385ff2a0429dd2a53d520a6c8755126383c1310d GIT binary patch literal 22258 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 literal 0 HcmV?d00001 diff --git a/water_meter/capture_1.jpg b/water_meter/capture_1.jpg new file mode 100755 index 0000000000000000000000000000000000000000..84a6365e34a0800367174c5c47d8086e0e317935 GIT binary patch literal 22456 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 f38$8)rbSS@2~zJHxv-n literal 0 HcmV?d00001 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()